diff options
Diffstat (limited to 'tests')
66 files changed, 28246 insertions, 13 deletions
diff --git a/tests/arithm/tcast.nim b/tests/arithm/tcast.nim index 954e2e677..4017ed1c5 100644 --- a/tests/arithm/tcast.nim +++ b/tests/arithm/tcast.nim @@ -4,6 +4,9 @@ B0 B1 B2 B3 +B4 +B5 +B6 ''' """ @@ -14,6 +17,14 @@ template crossCheck(ty: untyped, exp: untyped) = echo "Got ", ct echo "Expected ", rt +template add1(x: uint8): untyped = x + 1 +template add1(x: uint16): untyped = x + 1 +template add1(x: uint32): untyped = x + 1 + +template sub1(x: uint8): untyped = x - 1 +template sub1(x: uint16): untyped = x - 1 +template sub1(x: uint32): untyped = x - 1 + block: when true: echo "B0" @@ -34,10 +45,34 @@ block: crossCheck(uint64, (-1).uint64 + 5'u64) echo "B3" - crossCheck(int8, 0'u8 - 5'u8) - crossCheck(int16, 0'u16 - 5'u16) - crossCheck(int32, 0'u32 - 5'u32) - crossCheck(int64, 0'u64 - 5'u64) + doAssert $sub1(0'u8) == "255" + doAssert $sub1(0'u16) == "65535" + doAssert $sub1(0'u32) == "4294967295" + + echo "B4" + doAssert $add1(255'u8) == "0" + doAssert $add1(65535'u16) == "0" + doAssert $add1(4294967295'u32) == "0" + + echo "B5" + crossCheck(int32, high(int32)) + crossCheck(int32, high(int32).int32) + crossCheck(int32, low(int32)) + crossCheck(int32, low(int32).int32) + crossCheck(int64, high(int8).int16.int32.int64) + crossCheck(int64, low(int8).int16.int32.int64) + + echo "B6" + crossCheck(int64, 0xFFFFFFFFFFFFFFFF'u64) + crossCheck(int32, 0xFFFFFFFFFFFFFFFF'u64) + crossCheck(int16, 0xFFFFFFFFFFFFFFFF'u64) + crossCheck(int8 , 0xFFFFFFFFFFFFFFFF'u64) + + # Out of range conversion, caught for `let`s only + # crossCheck(int8, 0'u8 - 5'u8) + # crossCheck(int16, 0'u16 - 5'u16) + # crossCheck(int32, 0'u32 - 5'u32) + # crossCheck(int64, 0'u64 - 5'u64) # crossCheck(int8, 0'u16 - 129'u16) # crossCheck(uint8, 0'i16 + 257'i16) diff --git a/tests/assert/tfailedassert_stacktrace.nim b/tests/assert/tfailedassert_stacktrace.nim new file mode 100644 index 000000000..43171ef6c --- /dev/null +++ b/tests/assert/tfailedassert_stacktrace.nim @@ -0,0 +1,19 @@ +discard """ + output: ''' +tfailedassert_stacktrace.nim(16) tfailedassert_stacktrace +tfailedassert_stacktrace.nim(15) foo +system.nim(3778) failedAssertImpl +system.nim(3771) raiseAssert +system.nim(2818) sysFatal +''' +""" + + + +try: + proc foo() = + assert(false) + foo() +except AssertionError: + let e = getCurrentException() + echo e.getStackTrace diff --git a/tests/ccgbugs/t8964.nim b/tests/ccgbugs/t8964.nim new file mode 100644 index 000000000..5b41e8bdb --- /dev/null +++ b/tests/ccgbugs/t8964.nim @@ -0,0 +1,10 @@ +discard """ + targets: "c cpp" +""" + +from json import JsonParsingError +import marshal + +const nothing = "" +doAssertRaises(JsonParsingError): + var bar = marshal.to[int](nothing) diff --git a/tests/ccgbugs/tborrowmagic.nim b/tests/ccgbugs/tborrowmagic.nim new file mode 100644 index 000000000..8d42ddcd8 --- /dev/null +++ b/tests/ccgbugs/tborrowmagic.nim @@ -0,0 +1,8 @@ +type + Bytes = distinct seq[byte] + +proc add(x: var Bytes; b: byte) {.borrow.} +var x = @[].Bytes +x.add(42) +let base = cast[seq[byte]](x) +doAssert base.len == 1 and base[0] == 42 diff --git a/tests/ccgbugs/tcodegendecllambda.nim b/tests/ccgbugs/tcodegendecllambda.nim new file mode 100644 index 000000000..6dce68db5 --- /dev/null +++ b/tests/ccgbugs/tcodegendecllambda.nim @@ -0,0 +1,13 @@ +discard """ + targets: "c cpp js" + ccodecheck: "'HELLO'" +""" + +when defined(JS): + var foo = proc(): void{.codegenDecl: "/*HELLO*/function $2($3)".} = + echo "baa" +else: + var foo = proc(): void{.codegenDecl: "/*HELLO*/$1 $2 $3".} = + echo "baa" + +foo() diff --git a/tests/ccgbugs/thtiobj.nim b/tests/ccgbugs/thtiobj.nim new file mode 100644 index 000000000..7a656905f --- /dev/null +++ b/tests/ccgbugs/thtiobj.nim @@ -0,0 +1,8 @@ +discard """ + targets: "c cpp" +""" + +import typeinfo + +var x = "" +discard (getPointer(toAny(x))) diff --git a/tests/cpp/tasync_cpp.nim b/tests/cpp/tasync_cpp.nim index 50bc1853c..a68be6cd5 100644 --- a/tests/cpp/tasync_cpp.nim +++ b/tests/cpp/tasync_cpp.nim @@ -1,7 +1,7 @@ discard """ targets: "cpp" output: "hello" - cmd: "nim cpp --nilseqs:on $file" + cmd: "nim cpp --nilseqs:on --nimblePath:tests/deps $file" """ # bug #3299 diff --git a/tests/deps/jester-#head/jester.nim b/tests/deps/jester-#head/jester.nim new file mode 100644 index 000000000..013f0d16d --- /dev/null +++ b/tests/deps/jester-#head/jester.nim @@ -0,0 +1,1350 @@ +# Copyright (C) 2015 Dominik Picheta +# MIT License - Look at license.txt for details. +import net, strtabs, re, tables, parseutils, os, strutils, uri, + times, mimetypes, asyncnet, asyncdispatch, macros, md5, + logging, httpcore, asyncfile, macrocache, json, options, + strformat + +import jester/private/[errorpages, utils] +import jester/[request, patterns] + +from cgi import decodeData, decodeUrl, CgiError + +export request +export strtabs +export tables +export httpcore +export MultiData +export HttpMethod +export asyncdispatch + +export SameSite + +when useHttpBeast: + import httpbeast except Settings, Request + import options +else: + import asynchttpserver except Request + +type + MatchProc* = proc (request: Request): Future[ResponseData] {.gcsafe, closure.} + MatchProcSync* = proc (request: Request): ResponseData{.gcsafe, closure.} + + Matcher = object + case async: bool + of false: + syncProc: MatchProcSync + of true: + asyncProc: MatchProc + + ErrorProc* = proc ( + request: Request, error: RouteError + ): Future[ResponseData] {.gcsafe, closure.} + + Jester* = object + when not useHttpBeast: + httpServer*: AsyncHttpServer + settings: Settings + matchers: seq[Matcher] + errorHandlers: seq[ErrorProc] + + MatchType* = enum + MRegex, MSpecial, MStatic + + RawHeaders* = seq[tuple[key, val: string]] + ResponseData* = tuple[ + action: CallbackAction, + code: HttpCode, + headers: Option[RawHeaders], + content: string, + matched: bool + ] + + CallbackAction* = enum + TCActionNothing, TCActionSend, TCActionRaw, TCActionPass + + RouteErrorKind* = enum + RouteException, RouteCode + RouteError* = object + case kind*: RouteErrorKind + of RouteException: + exc: ref Exception + of RouteCode: + data: ResponseData + +const jesterVer = "0.4.0" + +proc toStr(headers: Option[RawHeaders]): string = + return $newHttpHeaders(headers.get(@({:}))) + +proc createHeaders(headers: RawHeaders): string = + result = "" + if headers != nil: + for header in headers: + let (key, value) = header + result.add(key & ": " & value & "\c\L") + + result = result[0 .. ^3] # Strip trailing \c\L + +proc createResponse(status: HttpCode, headers: RawHeaders): string = + return "HTTP/1.1 " & $status & "\c\L" & createHeaders(headers) & "\c\L\c\L" + +proc unsafeSend(request: Request, content: string) = + when useHttpBeast: + request.getNativeReq.unsafeSend(content) + else: + # TODO: This may cause issues if we send too fast. + asyncCheck request.getNativeReq.client.send(content) + +proc send( + request: Request, code: HttpCode, headers: Option[RawHeaders], body: string +) = + when useHttpBeast: + let h = + if headers.isNone: "" + else: headers.get().createHeaders + request.getNativeReq.send(code, body, h) + else: + # TODO: This may cause issues if we send too fast. + asyncCheck request.getNativeReq.respond( + code, body, newHttpHeaders(headers.get(@({:}))) + ) + +proc statusContent(request: Request, status: HttpCode, content: string, + headers: Option[RawHeaders]) = + try: + send(request, status, headers, content) + when not defined(release): + logging.debug(" $1 $2" % [$status, toStr(headers)]) + except: + logging.error("Could not send response: $1" % osErrorMsg(osLastError())) + +# TODO: Add support for proper Future Streams instead of this weird raw mode. +template enableRawMode* = + # TODO: Use the effect system to make this implicit? + result.action = TCActionRaw + +proc send*(request: Request, content: string) = + ## Sends ``content`` immediately to the client socket. + ## + ## Routes using this procedure must enable raw mode. + unsafeSend(request, content) + +proc sendHeaders*(request: Request, status: HttpCode, + headers: RawHeaders) = + ## Sends ``status`` and ``headers`` to the client socket immediately. + ## The user is then able to send the content immediately to the client on + ## the fly through the use of ``response.client``. + let headerData = createResponse(status, headers) + try: + request.send(headerData) + logging.debug(" $1 $2" % [$status, $headers]) + except: + logging.error("Could not send response: $1" % [osErrorMsg(osLastError())]) + +proc sendHeaders*(request: Request, status: HttpCode) = + ## Sends ``status`` and ``Content-Type: text/html`` as the headers to the + ## client socket immediately. + let headers = @({"Content-Type": "text/html;charset=utf-8"}) + request.sendHeaders(status, headers) + +proc sendHeaders*(request: Request) = + ## Sends ``Http200`` and ``Content-Type: text/html`` as the headers to the + ## client socket immediately. + request.sendHeaders(Http200) + +proc send*(request: Request, status: HttpCode, headers: RawHeaders, + content: string) = + ## Sends out a HTTP response comprising of the ``status``, ``headers`` and + ## ``content`` specified. + var headers = headers & @({"Content-Length": $content.len}) + request.sendHeaders(status, headers) + request.send(content) + +# TODO: Cannot capture 'paths: varargs[string]' here. +proc sendStaticIfExists( + req: Request, paths: seq[string] +): Future[HttpCode] {.async.} = + result = Http200 + for p in paths: + if existsFile(p): + + var fp = getFilePermissions(p) + if not fp.contains(fpOthersRead): + return Http403 + + let fileSize = getFileSize(p) + let mimetype = req.settings.mimes.getMimetype(p.splitFile.ext[1 .. ^1]) + if fileSize < 10_000_000: # 10 mb + var file = readFile(p) + + var hashed = getMD5(file) + + # If the user has a cached version of this file and it matches our + # version, let them use it + if req.headers.hasKey("If-None-Match") and req.headers["If-None-Match"] == hashed: + req.statusContent(Http304, "", none[RawHeaders]()) + else: + req.statusContent(Http200, file, some(@({ + "Content-Type": mimetype, + "ETag": hashed + }))) + else: + let headers = @({ + "Content-Type": mimetype, + "Content-Length": $fileSize + }) + req.statusContent(Http200, "", some(headers)) + + var fileStream = newFutureStream[string]("sendStaticIfExists") + var file = openAsync(p, fmRead) + # Let `readToStream` write file data into fileStream in the + # background. + asyncCheck file.readToStream(fileStream) + # The `writeFromStream` proc will complete once all the data in the + # `bodyStream` has been written to the file. + while true: + let (hasValue, value) = await fileStream.read() + if hasValue: + req.unsafeSend(value) + else: + break + file.close() + + return + + # If we get to here then no match could be found. + return Http404 + +proc defaultErrorFilter(error: RouteError): ResponseData = + case error.kind + of RouteException: + let e = error.exc + let traceback = getStackTrace(e) + var errorMsg = e.msg + if errorMsg.isNil: errorMsg = "(nil)" + + let error = traceback & errorMsg + logging.error(error) + result.headers = some(@({ + "Content-Type": "text/html;charset=utf-8" + })) + result.content = routeException( + error.replace("\n", "<br/>\n"), + jesterVer + ) + result.code = Http502 + result.matched = true + result.action = TCActionSend + of RouteCode: + result.headers = some(@({ + "Content-Type": "text/html;charset=utf-8" + })) + result.content = error( + $error.data.code, + jesterVer + ) + result.code = error.data.code + result.matched = true + result.action = TCActionSend + +proc initRouteError(exc: ref Exception): RouteError = + RouteError( + kind: RouteException, + exc: exc + ) + +proc initRouteError(data: ResponseData): RouteError = + RouteError( + kind: RouteCode, + data: data + ) + +proc dispatchError( + jes: Jester, + request: Request, + error: RouteError +): Future[ResponseData] {.async.} = + for errorProc in jes.errorHandlers: + let data = await errorProc(request, error) + if data.matched: + return data + + return defaultErrorFilter(error) + +proc dispatch( + self: Jester, + req: Request +): Future[ResponseData] {.async.} = + for matcher in self.matchers: + if matcher.async: + let data = await matcher.asyncProc(req) + if data.matched: + return data + else: + let data = matcher.syncProc(req) + if data.matched: + return data + +proc handleFileRequest( + jes: Jester, req: Request +): Future[ResponseData] {.async.} = + # Find static file. + # TODO: Caching. + let path = normalizedPath( + jes.settings.staticDir / cgi.decodeUrl(req.pathInfo) + ) + + # Verify that this isn't outside our static` dir. + var status = Http400 + if path.splitFile.dir.startsWith(jes.settings.staticDir): + if existsDir(path): + status = await sendStaticIfExists( + req, + @[path / "index.html", path / "index.htm"] + ) + else: + status = await sendStaticIfExists(req, @[path]) + + # Http200 means that the data was sent so there is nothing else to do. + if status == Http200: + result[0] = TCActionRaw + when not defined(release): + logging.debug(" -> $1" % path) + return + + return (TCActionSend, status, none[seq[(string, string)]](), "", true) + +proc handleRequestSlow( + jes: Jester, + req: Request, + respDataFut: Future[ResponseData] | ResponseData, + dispatchedError: bool +): Future[void] {.async.} = + var dispatchedError = dispatchedError + var respData: ResponseData + + # httpReq.send(Http200, "Hello, World!", "") + try: + when respDataFut is Future[ResponseData]: + respData = await respDataFut + else: + respData = respDataFut + except: + # Handle any errors by showing them in the browser. + # TODO: Improve the look of this. + let exc = getCurrentException() + respData = await dispatchError(jes, req, initRouteError(exc)) + dispatchedError = true + + # TODO: Put this in a custom matcher? + if not respData.matched: + respData = await handleFileRequest(jes, req) + + case respData.action + of TCActionSend: + if (respData.code.is4xx or respData.code.is5xx) and + not dispatchedError and respData.content.len == 0: + respData = await dispatchError(jes, req, initRouteError(respData)) + + statusContent( + req, + respData.code, + respData.content, + respData.headers + ) + else: + when not defined(release): + logging.debug(" $1" % [$respData.action]) + + # Cannot close the client socket. AsyncHttpServer may be keeping it alive. + +proc handleRequest(jes: Jester, httpReq: NativeRequest): Future[void] = + var req = initRequest(httpReq, jes.settings) + try: + when not defined(release): + logging.debug("$1 $2" % [$req.reqMethod, req.pathInfo]) + + if likely(jes.matchers.len == 1 and not jes.matchers[0].async): + let respData = jes.matchers[0].syncProc(req) + if likely(respData.matched): + statusContent( + req, + respData.code, + respData.content, + respData.headers + ) + else: + return handleRequestSlow(jes, req, respData, false) + else: + return handleRequestSlow(jes, req, dispatch(jes, req), false) + except: + let exc = getCurrentException() + let respDataFut = dispatchError(jes, req, initRouteError(exc)) + return handleRequestSlow(jes, req, respDataFut, true) + +proc newSettings*( + port = Port(5000), staticDir = getCurrentDir() / "public", + appName = "", bindAddr = "", reusePort = false, + futureErrorHandler: proc (fut: Future[void]) {.closure, gcsafe.} = nil +): Settings = + result = Settings( + staticDir: staticDir, + appName: appName, + port: port, + bindAddr: bindAddr, + reusePort: reusePort, + futureErrorHandler: futureErrorHandler + ) + +proc register*(self: var Jester, matcher: MatchProc) = + ## Adds the specified matcher procedure to the specified Jester instance. + self.matchers.add( + Matcher( + async: true, + asyncProc: matcher + ) + ) + +proc register*(self: var Jester, matcher: MatchProcSync) = + ## Adds the specified matcher procedure to the specified Jester instance. + self.matchers.add( + Matcher( + async: false, + syncProc: matcher + ) + ) + +proc register*(self: var Jester, errorHandler: ErrorProc) = + ## Adds the specified error handler procedure to the specified Jester instance. + self.errorHandlers.add(errorHandler) + +proc initJester*( + settings: Settings = newSettings() +): Jester = + result.settings = settings + result.settings.mimes = newMimetypes() + result.matchers = @[] + result.errorHandlers = @[] + +proc initJester*( + matcher: MatchProc, + settings: Settings = newSettings() +): Jester = + result = initJester(settings) + result.register(matcher) + +proc initJester*( + matcher: MatchProcSync, # TODO: Annoying nim bug: `MatchProc | MatchProcSync` doesn't work. + settings: Settings = newSettings() +): Jester = + result = initJester(settings) + result.register(matcher) + +proc serve*( + self: var Jester +) = + ## Creates a new async http server instance and registers + ## it with the dispatcher. + ## + ## The event loop is executed by this function, so it will block forever. + + # Ensure we have at least one logger enabled, defaulting to console. + if logging.getHandlers().len == 0: + addHandler(logging.newConsoleLogger()) + setLogFilter(when defined(release): lvlInfo else: lvlDebug) + + if self.settings.bindAddr.len > 0: + logging.info("Jester is making jokes at http://$1:$2$3" % + [ + self.settings.bindAddr, $self.settings.port, self.settings.appName + ] + ) + else: + logging.info("Jester is making jokes at http://0.0.0.0:$1$2" % + [$self.settings.port, self.settings.appName]) + + var jes = self + when useHttpBeast: + run( + proc (req: httpbeast.Request): Future[void] = + result = handleRequest(jes, req), + httpbeast.initSettings(self.settings.port, self.settings.bindAddr) + ) + else: + self.httpServer = newAsyncHttpServer(reusePort=self.settings.reusePort) + let serveFut = self.httpServer.serve( + self.settings.port, + proc (req: asynchttpserver.Request): Future[void] {.gcsafe, closure.} = + result = handleRequest(jes, req), + self.settings.bindAddr) + if not self.settings.futureErrorHandler.isNil: + serveFut.callback = self.settings.futureErrorHandler + else: + asyncCheck serveFut + runForever() + +template resp*(code: HttpCode, + headers: openarray[tuple[key, value: string]], + content: string): typed = + ## Sets ``(code, headers, content)`` as the response. + bind TCActionSend, newHttpHeaders + result = (TCActionSend, code, headers.newHttpHeaders.some(), content, true) + break route + +template setHeader(headers: var Option[RawHeaders], key, value: string): typed = + bind isNone + if isNone(headers): + headers = some(@({key: value})) + else: + block outer: + # Overwrite key if it exists. + var h = headers.get() + for i in 0 ..< h.len: + if h[i][0] == key: + h[i][1] = value + headers = some(h) + break outer + + # Add key if it doesn't exist. + headers = some(h & @({key: value})) + +template resp*(content: string, contentType = "text/html;charset=utf-8"): typed = + ## Sets ``content`` as the response; ``Http200`` as the status code + ## and ``contentType`` as the Content-Type. + bind TCActionSend, newHttpHeaders, strtabs.`[]=` + result[0] = TCActionSend + result[1] = Http200 + setHeader(result[2], "Content-Type", contentType) + result[3] = content + # This will be set by our macro, so this is here for those not using it. + result.matched = true + break route + +template resp*(content: JsonNode): typed = + ## Serializes ``content`` as the response, sets ``Http200`` as status code + ## and "application/json" Content-Type. + resp($content, contentType="application/json") + +template resp*(code: HttpCode, content: string, + contentType = "text/html;charset=utf-8"): typed = + ## Sets ``content`` as the response; ``code`` as the status code + ## and ``contentType`` as the Content-Type. + bind TCActionSend, newHttpHeaders + result[0] = TCActionSend + result[1] = code + setHeader(result[2], "Content-Type", contentType) + result[3] = content + result.matched = true + break route + +template resp*(code: HttpCode): typed = + ## Responds with the specified ``HttpCode``. This ensures that error handlers + ## are called. + bind TCActionSend, newHttpHeaders + result[0] = TCActionSend + result[1] = code + result.matched = true + break route + +template redirect*(url: string): typed = + ## Redirects to ``url``. Returns from this request handler immediately. + ## Any set response headers are preserved for this request. + bind TCActionSend, newHttpHeaders + result[0] = TCActionSend + result[1] = Http303 + setHeader(result[2], "Location", url) + result[3] = "" + result.matched = true + break route + +template pass*(): typed = + ## Skips this request handler. + ## + ## If you want to stop this request from going further use ``halt``. + result.action = TCActionPass + break outerRoute + +template cond*(condition: bool): typed = + ## If ``condition`` is ``False`` then ``pass`` will be called, + ## i.e. this request handler will be skipped. + if not condition: break outerRoute + +template halt*(code: HttpCode, + headers: openarray[tuple[key, val: string]], + content: string): typed = + ## Immediately replies with the specified request. This means any further + ## code will not be executed after calling this template in the current + ## route. + bind TCActionSend, newHttpHeaders + result[0] = TCActionSend + result[1] = code + result[2] = some(@headers) + result[3] = content + result.matched = true + break allRoutes + +template halt*(): typed = + ## Halts the execution of this request immediately. Returns a 404. + ## All previously set values are **discarded**. + halt(Http404, {"Content-Type": "text/html;charset=utf-8"}, error($Http404, jesterVer)) + +template halt*(code: HttpCode): typed = + halt(code, {"Content-Type": "text/html;charset=utf-8"}, error($code, jesterVer)) + +template halt*(content: string): typed = + halt(Http404, {"Content-Type": "text/html;charset=utf-8"}, content) + +template halt*(code: HttpCode, content: string): typed = + halt(code, {"Content-Type": "text/html;charset=utf-8"}, content) + +template attachment*(filename = ""): typed = + ## Instructs the browser that the response should be stored on disk + ## rather than displayed in the browser. + var disposition = "attachment" + if filename != "": + disposition.add("; filename=\"" & extractFilename(filename) & "\"") + let ext = splitFile(filename).ext + let contentTypeSet = + isSome(result[2]) and result[2].get().toTable.hasKey("Content-Type") + if not contentTypeSet and ext != "": + setHeader(result[2], "Content-Type", getMimetype(request.settings.mimes, ext)) + setHeader(result[2], "Content-Disposition", disposition) + +template sendFile*(filename: string): typed = + ## Sends the file at the specified filename as the response. + result[0] = TCActionRaw + let sendFut = sendStaticIfExists(request, @[filename]) + yield sendFut + let status = sendFut.read() + if status != Http200: + raise newException(JesterError, "Couldn't send requested file: " & filename) + # This will be set by our macro, so this is here for those not using it. + result.matched = true + break route + +template `@`*(s: string): untyped = + ## Retrieves the parameter ``s`` from ``request.params``. ``""`` will be + ## returned if parameter doesn't exist. + if s in params(request): + # TODO: Why does request.params not work? :( + # TODO: This is some weird bug with macros/templates, I couldn't + # TODO: reproduce it easily. + params(request)[s] + else: + "" + +proc setStaticDir*(request: Request, dir: string) = + ## Sets the directory in which Jester will look for static files. It is + ## ``./public`` by default. + ## + ## The files will be served like so: + ## + ## ./public/css/style.css ``->`` http://example.com/css/style.css + ## + ## (``./public`` is not included in the final URL) + request.settings.staticDir = dir + +proc getStaticDir*(request: Request): string = + ## Gets the directory in which Jester will look for static files. + ## + ## ``./public`` by default. + return request.settings.staticDir + +proc makeUri*(request: Request, address = "", absolute = true, + addScriptName = true): string = + ## Creates a URI based on the current request. If ``absolute`` is true it will + ## add the scheme (Usually 'http://'), `request.host` and `request.port`. + ## If ``addScriptName`` is true `request.appName` will be prepended before + ## ``address``. + + # Check if address already starts with scheme:// + var uri = parseUri(address) + + if uri.scheme != "": return address + uri.path = "/" + uri.query = "" + uri.anchor = "" + if absolute: + uri.hostname = request.host + uri.scheme = (if request.secure: "https" else: "http") + if request.port != (if request.secure: 443 else: 80): + uri.port = $request.port + + if addScriptName: uri = uri / request.appName + if address != "": + uri = uri / address + else: + uri = uri / request.pathInfo + return $uri + +template uri*(address = "", absolute = true, addScriptName = true): untyped = + ## Convenience template which can be used in a route. + request.makeUri(address, absolute, addScriptName) + +proc daysForward*(days: int): DateTime = + ## Returns a DateTime object referring to the current time plus ``days``. + return getTime().utc + initInterval(days = days) + +template setCookie*(name, value: string, expires="", + sameSite: SameSite=Lax): typed = + ## Creates a cookie which stores ``value`` under ``name``. + ## + ## The SameSite argument determines the level of CSRF protection that + ## you wish to adopt for this cookie. It's set to Lax by default which + ## should protect you from most vulnerabilities. Note that this is only + ## supported by some browsers: + ## https://caniuse.com/#feat=same-site-cookie-attribute + let newCookie = makeCookie(name, value, expires) + if isSome(result[2]) and + (let headers = result[2].get(); headers.toTable.hasKey("Set-Cookie")): + result[2] = some(headers & @({"Set-Cookie": newCookie})) + else: + setHeader(result[2], "Set-Cookie", newCookie) + +template setCookie*(name, value: string, expires: DateTime, + sameSite: SameSite=Lax): typed = + ## Creates a cookie which stores ``value`` under ``name``. + setCookie(name, value, format(expires, "ddd',' dd MMM yyyy HH:mm:ss 'GMT'")) + +proc normalizeUri*(uri: string): string = + ## Remove any trailing ``/``. + if uri[uri.len-1] == '/': result = uri[0 .. uri.len-2] + else: result = uri + +# -- Macro + +proc checkAction*(respData: var ResponseData): bool = + case respData.action + of TCActionSend, TCActionRaw: + result = true + of TCActionPass: + result = false + of TCActionNothing: + assert(false) + +proc skipDo(node: NimNode): NimNode {.compiletime.} = + if node.kind == nnkDo: + result = node[6] + else: + result = node + +proc ctParsePattern(pattern, pathPrefix: string): NimNode {.compiletime.} = + result = newNimNode(nnkPrefix) + result.add newIdentNode("@") + result.add newNimNode(nnkBracket) + + proc addPattNode(res: var NimNode, typ, text, + optional: NimNode) {.compiletime.} = + var objConstr = newNimNode(nnkObjConstr) + + objConstr.add bindSym("Node") + objConstr.add newNimNode(nnkExprColonExpr).add( + newIdentNode("typ"), typ) + objConstr.add newNimNode(nnkExprColonExpr).add( + newIdentNode("text"), text) + objConstr.add newNimNode(nnkExprColonExpr).add( + newIdentNode("optional"), optional) + + res[1].add objConstr + + var patt = parsePattern(pattern) + if pathPrefix.len > 0: + result.addPattNode( + bindSym("NodeText"), # Node kind + newStrLitNode(pathPrefix), # Text + newIdentNode("false") # Optional? + ) + + for node in patt: + result.addPattNode( + case node.typ + of NodeText: bindSym("NodeText") + of NodeField: bindSym("NodeField"), + newStrLitNode(node.text), + newIdentNode(if node.optional: "true" else: "false")) + +template setDefaultResp*(): typed = + # TODO: bindSym this in the 'routes' macro and put it in each route + bind TCActionNothing, newHttpHeaders + result.action = TCActionNothing + result.code = Http200 + result.content = "" + +template declareSettings(): typed {.dirty.} = + when not declaredInScope(settings): + var settings = newSettings() + +proc createJesterPattern( + routeNode, patternMatchSym: NimNode, + pathPrefix: string +): NimNode {.compileTime.} = + var ctPattern = ctParsePattern(routeNode[1].strVal, pathPrefix) + # -> let <patternMatchSym> = <ctPattern>.match(request.path) + return newLetStmt(patternMatchSym, + newCall(bindSym"match", ctPattern, parseExpr("request.pathInfo"))) + +proc escapeRegex(s: string): string = + result = "" + for i in s: + case i + # https://stackoverflow.com/a/400316/492186 + of '.', '^', '$', '*', '+', '?', '(', ')', '[', '{', '\\', '|': + result.add('\\') + result.add(i) + else: + result.add(i) + +proc createRegexPattern( + routeNode, reMatchesSym, patternMatchSym: NimNode, + pathPrefix: string +): NimNode {.compileTime.} = + # -> let <patternMatchSym> = find(request.pathInfo, <pattern>, <reMatches>) + var strNode = routeNode[1].copyNimTree() + strNode[1].strVal = escapeRegex(pathPrefix) & strNode[1].strVal + return newLetStmt( + patternMatchSym, + newCall( + bindSym"find", + parseExpr("request.pathInfo"), + strNode, + reMatchesSym + ) + ) + +proc determinePatternType(pattern: NimNode): MatchType {.compileTime.} = + case pattern.kind + of nnkStrLit: + var patt = parsePattern(pattern.strVal) + if patt.len == 1 and patt[0].typ == NodeText: + return MStatic + else: + return MSpecial + of nnkCallStrLit: + expectKind(pattern[0], nnkIdent) + case ($pattern[0]).normalize + of "re": return MRegex + else: + macros.error("Invalid pattern type: " & $pattern[0]) + else: + macros.error("Unexpected node kind: " & $pattern.kind) + +proc createCheckActionIf(): NimNode = + var checkActionIf = parseExpr( + "if checkAction(result): result.matched = true; break routesList" + ) + checkActionIf[0][0][0] = bindSym"checkAction" + return checkActionIf + +proc createGlobalMetaRoute(routeNode, dest: NimNode) {.compileTime.} = + ## Creates a ``before`` or ``after`` route with no pattern, i.e. one which + ## will be always executed. + + # -> block route: <ifStmtBody> + var innerBlockStmt = newStmtList( + newNimNode(nnkBlockStmt).add(newIdentNode("route"), routeNode[1].skipDo()) + ) + + # -> block outerRoute: <innerBlockStmt> + var blockStmt = newNimNode(nnkBlockStmt).add( + newIdentNode("outerRoute"), innerBlockStmt) + dest.add blockStmt + +proc createRoute( + routeNode, dest: NimNode, pathPrefix: string, isMetaRoute: bool = false +) {.compileTime.} = + ## Creates code which checks whether the current request path + ## matches a route. + ## + ## The `isMetaRoute` parameter determines whether the route to be created is + ## one of either a ``before`` or an ``after`` route. + + var patternMatchSym = genSym(nskLet, "patternMatchRet") + + # Only used for Regex patterns. + var reMatchesSym = genSym(nskVar, "reMatches") + var reMatches = parseExpr("var reMatches: array[20, string]") + reMatches[0][0] = reMatchesSym + reMatches[0][1][1] = bindSym("MaxSubpatterns") + + let patternType = determinePatternType(routeNode[1]) + case patternType + of MStatic: + discard + of MSpecial: + dest.add createJesterPattern(routeNode, patternMatchSym, pathPrefix) + of MRegex: + dest.add reMatches + dest.add createRegexPattern( + routeNode, reMatchesSym, patternMatchSym, pathPrefix + ) + + var ifStmtBody = newStmtList() + case patternType + of MStatic: discard + of MSpecial: + # -> setPatternParams(request, ret.params) + ifStmtBody.add newCall(bindSym"setPatternParams", newIdentNode"request", + newDotExpr(patternMatchSym, newIdentNode"params")) + of MRegex: + # -> setReMatches(request, <reMatchesSym>) + ifStmtBody.add newCall(bindSym"setReMatches", newIdentNode"request", + reMatchesSym) + + ifStmtBody.add routeNode[2].skipDo() + + let checkActionIf = + if isMetaRoute: + parseExpr("break routesList") + else: + createCheckActionIf() + # -> block route: <ifStmtBody>; <checkActionIf> + var innerBlockStmt = newStmtList( + newNimNode(nnkBlockStmt).add(newIdentNode("route"), ifStmtBody), + checkActionIf + ) + + let ifCond = + case patternType + of MStatic: + infix( + parseExpr("request.pathInfo"), + "==", + newStrLitNode(pathPrefix & routeNode[1].strVal) + ) + of MSpecial: + newDotExpr(patternMatchSym, newIdentNode("matched")) + of MRegex: + infix(patternMatchSym, "!=", newIntLitNode(-1)) + + # -> if <patternMatchSym>.matched: <innerBlockStmt> + var ifStmt = newIfStmt((ifCond, innerBlockStmt)) + + # -> block outerRoute: <ifStmt> + var blockStmt = newNimNode(nnkBlockStmt).add( + newIdentNode("outerRoute"), ifStmt) + dest.add blockStmt + +proc createError( + errorNode: NimNode, + httpCodeBranches, + exceptionBranches: var seq[tuple[cond, body: NimNode]] +) = + if errorNode.len != 3: + error("Missing error condition or body.", errorNode) + + let routeIdent = newIdentNode("route") + let outerRouteIdent = newIdentNode("outerRoute") + let checkActionIf = createCheckActionIf() + let exceptionIdent = newIdentNode("exception") + let errorIdent = newIdentNode("error") # TODO: Ugh. I shouldn't need these... + let errorCond = errorNode[1] + let errorBody = errorNode[2] + let body = quote do: + block `outerRouteIdent`: + block `routeIdent`: + `errorBody` + `checkActionIf` + + case errorCond.kind + of nnkIdent: + let name = errorCond.strVal + if name.len == 7 and name.startsWith("Http"): + # HttpCode. + httpCodeBranches.add( + ( + infix(parseExpr("error.data.code"), "==", errorCond), + body + ) + ) + else: + # Exception + exceptionBranches.add( + ( + infix(parseExpr("error.exc"), "of", errorCond), + quote do: + let `exceptionIdent` = (ref `errorCond`)(`errorIdent`.exc) + `body` + ) + ) + of nnkCurly: + expectKind(errorCond[0], nnkInfix) + httpCodeBranches.add( + ( + infix(parseExpr("error.data.code"), "in", errorCond), + body + ) + ) + else: + error("Expected exception type or set[HttpCode].", errorCond) + +const definedRoutes = CacheTable"jester.routes" + +proc processRoutesBody( + body: NimNode, + # For HTTP methods. + caseStmtGetBody, + caseStmtPostBody, + caseStmtPutBody, + caseStmtDeleteBody, + caseStmtHeadBody, + caseStmtOptionsBody, + caseStmtTraceBody, + caseStmtConnectBody, + caseStmtPatchBody: var NimNode, + # For `error`. + httpCodeBranches, + exceptionBranches: var seq[tuple[cond, body: NimNode]], + # For before/after stmts. + beforeStmts, + afterStmts: var NimNode, + # For other statements. + outsideStmts: var NimNode, + pathPrefix: string +) = + for i in 0..<body.len: + case body[i].kind + of nnkCall: + let cmdName = body[i][0].`$`.normalize + case cmdName + of "before": + createGlobalMetaRoute(body[i], beforeStmts) + of "after": + createGlobalMetaRoute(body[i], afterStmts) + else: + outsideStmts.add(body[i]) + of nnkCommand: + let cmdName = body[i][0].`$`.normalize + case cmdName + # HTTP Methods + of "get": + createRoute(body[i], caseStmtGetBody, pathPrefix) + of "post": + createRoute(body[i], caseStmtPostBody, pathPrefix) + of "put": + createRoute(body[i], caseStmtPutBody, pathPrefix) + of "delete": + createRoute(body[i], caseStmtDeleteBody, pathPrefix) + of "head": + createRoute(body[i], caseStmtHeadBody, pathPrefix) + of "options": + createRoute(body[i], caseStmtOptionsBody, pathPrefix) + of "trace": + createRoute(body[i], caseStmtTraceBody, pathPrefix) + of "connect": + createRoute(body[i], caseStmtConnectBody, pathPrefix) + of "patch": + createRoute(body[i], caseStmtPatchBody, pathPrefix) + # Other + of "error": + createError(body[i], httpCodeBranches, exceptionBranches) + of "before": + createRoute(body[i], beforeStmts, pathPrefix, isMetaRoute=true) + of "after": + createRoute(body[i], afterStmts, pathPrefix, isMetaRoute=true) + of "extend": + # Extend another router. + let extend = body[i] + if extend[1].kind != nnkIdent: + error("Expected identifier.", extend[1]) + + let prefix = + if extend.len > 1: + extend[2].strVal + else: + "" + if prefix.len != 0 and prefix[0] != '/': + error("Path prefix for extended route must start with '/'", extend[2]) + + processRoutesBody( + definedRoutes[extend[1].strVal], + caseStmtGetBody, + caseStmtPostBody, + caseStmtPutBody, + caseStmtDeleteBody, + caseStmtHeadBody, + caseStmtOptionsBody, + caseStmtTraceBody, + caseStmtConnectBody, + caseStmtPatchBody, + httpCodeBranches, + exceptionBranches, + beforeStmts, + afterStmts, + outsideStmts, + pathPrefix & prefix + ) + else: + outsideStmts.add(body[i]) + of nnkCommentStmt: + discard + of nnkPragma: + if body[i][0].strVal.normalize notin ["async", "sync"]: + outsideStmts.add(body[i]) + else: + outsideStmts.add(body[i]) + +type + NeedsAsync = enum + ImplicitTrue, ImplicitFalse, ExplicitTrue, ExplicitFalse +proc needsAsync(node: NimNode): NeedsAsync = + result = ImplicitFalse + case node.kind + of nnkCommand, nnkCall: + if node[0].kind == nnkIdent: + case node[0].strVal.normalize + of "await", "sendfile": + return ImplicitTrue + of "resp", "halt", "attachment", "pass", "redirect", "cond", "get", + "post", "patch", "delete": + # This is just a simple heuristic. It's by no means meant to be + # exhaustive. + discard + else: + return ImplicitTrue + of nnkYieldStmt: + return ImplicitTrue + of nnkPragma: + if node[0].kind == nnkIdent: + case node[0].strVal.normalize + of "sync": + return ExplicitFalse + of "async": + return ExplicitTrue + else: discard + else: discard + + for c in node: + let r = needsAsync(c) + if r in {ImplicitTrue, ExplicitTrue, ExplicitFalse}: return r + +proc routesEx(name: string, body: NimNode): NimNode = + # echo(treeRepr(body)) + # echo(treeRepr(name)) + + # Save this route's body so that it can be incorporated into another route. + definedRoutes[name] = body.copyNimTree + + result = newStmtList() + + # -> declareSettings() + result.add newCall(bindSym"declareSettings") + + var outsideStmts = newStmtList() + + var matchBody = newNimNode(nnkStmtList) + let setDefaultRespIdent = bindSym"setDefaultResp" + matchBody.add newCall(setDefaultRespIdent) + # TODO: This diminishes the performance. Would be nice to only include it + # TODO: when setPatternParams or setReMatches is used. + matchBody.add parseExpr("var request = request") + + # HTTP router case statement nodes: + var caseStmt = newNimNode(nnkCaseStmt) + caseStmt.add parseExpr("request.reqMethod") + + var caseStmtGetBody = newNimNode(nnkStmtList) + var caseStmtPostBody = newNimNode(nnkStmtList) + var caseStmtPutBody = newNimNode(nnkStmtList) + var caseStmtDeleteBody = newNimNode(nnkStmtList) + var caseStmtHeadBody = newNimNode(nnkStmtList) + var caseStmtOptionsBody = newNimNode(nnkStmtList) + var caseStmtTraceBody = newNimNode(nnkStmtList) + var caseStmtConnectBody = newNimNode(nnkStmtList) + var caseStmtPatchBody = newNimNode(nnkStmtList) + + # Error handler nodes: + var httpCodeBranches: seq[tuple[cond, body: NimNode]] = @[] + var exceptionBranches: seq[tuple[cond, body: NimNode]] = @[] + + # Before/After nodes: + var beforeRoutes = newStmtList() + var afterRoutes = newStmtList() + + processRoutesBody( + body, + caseStmtGetBody, + caseStmtPostBody, + caseStmtPutBody, + caseStmtDeleteBody, + caseStmtHeadBody, + caseStmtOptionsBody, + caseStmtTraceBody, + caseStmtConnectBody, + caseStmtPatchBody, + httpCodeBranches, + exceptionBranches, + beforeRoutes, + afterRoutes, + outsideStmts, + "" + ) + + var ofBranchGet = newNimNode(nnkOfBranch) + ofBranchGet.add newIdentNode("HttpGet") + ofBranchGet.add caseStmtGetBody + caseStmt.add ofBranchGet + + var ofBranchPost = newNimNode(nnkOfBranch) + ofBranchPost.add newIdentNode("HttpPost") + ofBranchPost.add caseStmtPostBody + caseStmt.add ofBranchPost + + var ofBranchPut = newNimNode(nnkOfBranch) + ofBranchPut.add newIdentNode("HttpPut") + ofBranchPut.add caseStmtPutBody + caseStmt.add ofBranchPut + + var ofBranchDelete = newNimNode(nnkOfBranch) + ofBranchDelete.add newIdentNode("HttpDelete") + ofBranchDelete.add caseStmtDeleteBody + caseStmt.add ofBranchDelete + + var ofBranchHead = newNimNode(nnkOfBranch) + ofBranchHead.add newIdentNode("HttpHead") + ofBranchHead.add caseStmtHeadBody + caseStmt.add ofBranchHead + + var ofBranchOptions = newNimNode(nnkOfBranch) + ofBranchOptions.add newIdentNode("HttpOptions") + ofBranchOptions.add caseStmtOptionsBody + caseStmt.add ofBranchOptions + + var ofBranchTrace = newNimNode(nnkOfBranch) + ofBranchTrace.add newIdentNode("HttpTrace") + ofBranchTrace.add caseStmtTraceBody + caseStmt.add ofBranchTrace + + var ofBranchConnect = newNimNode(nnkOfBranch) + ofBranchConnect.add newIdentNode("HttpConnect") + ofBranchConnect.add caseStmtConnectBody + caseStmt.add ofBranchConnect + + var ofBranchPatch = newNimNode(nnkOfBranch) + ofBranchPatch.add newIdentNode("HttpPatch") + ofBranchPatch.add caseStmtPatchBody + caseStmt.add ofBranchPatch + + # Wrap the routes inside ``routesList`` blocks accordingly, and add them to + # the `match` procedure body. + let routesListIdent = newIdentNode("routesList") + matchBody.add( + quote do: + block `routesListIdent`: + `beforeRoutes` + ) + + matchBody.add( + quote do: + block `routesListIdent`: + `caseStmt` + ) + + matchBody.add( + quote do: + block `routesListIdent`: + `afterRoutes` + ) + + let matchIdent = newIdentNode(name) + let reqIdent = newIdentNode("request") + let needsAsync = needsAsync(body) + case needsAsync + of ImplicitFalse, ExplicitFalse: + hint(fmt"Synchronous route `{name}` has been optimised. Use `{{.async.}}` to change.") + of ImplicitTrue, ExplicitTrue: + hint(fmt"Asynchronous route: {name}.") + var matchProc = + if needsAsync in {ImplicitTrue, ExplicitTrue}: + quote do: + proc `matchIdent`( + `reqIdent`: Request + ): Future[ResponseData] {.async, gcsafe.} = + discard + else: + quote do: + proc `matchIdent`( + `reqIdent`: Request + ): ResponseData {.gcsafe.} = + discard + + # The following `block` is for `halt`. (`return` didn't work :/) + let allRoutesBlock = newTree( + nnkBlockStmt, + newIdentNode("allRoutes"), + matchBody + ) + matchProc[6] = newTree(nnkStmtList, allRoutesBlock) + result.add(outsideStmts) + result.add(matchProc) + + # Error handler proc + let errorHandlerIdent = newIdentNode(name & "ErrorHandler") + let errorIdent = newIdentNode("error") + let exceptionIdent = newIdentNode("exception") + let resultIdent = newIdentNode("result") + var errorHandlerProc = quote do: + proc `errorHandlerIdent`( + `reqIdent`: Request, `errorIdent`: RouteError + ): Future[ResponseData] {.gcsafe, async.} = + block `routesListIdent`: + `setDefaultRespIdent`() + case `errorIdent`.kind + of RouteException: + discard + of RouteCode: + discard + if exceptionBranches.len != 0: + var stmts = newStmtList() + for branch in exceptionBranches: + stmts.add(newIfStmt(branch)) + errorHandlerProc[6][0][1][^1][1][1][0] = stmts + if httpCodeBranches.len > 1: + var stmts = newStmtList() + for branch in httpCodeBranches: + stmts.add(newIfStmt(branch)) + errorHandlerProc[6][0][1][^1][2][1][0] = stmts + result.add(errorHandlerProc) + + # TODO: Replace `body`, `headers`, `code` in routes with `result[i]` to + # get these shortcuts back without sacrificing usability. + # TODO2: Make sure you replace what `guessAction` used to do for this. + + # echo toStrLit(result) + # echo treeRepr(result) + +macro routes*(body: untyped): typed = + result = routesEx("match", body) + let jesIdent = genSym(nskVar, "jes") + let matchIdent = newIdentNode("match") + let errorHandlerIdent = newIdentNode("matchErrorHandler") + let settingsIdent = newIdentNode("settings") + result.add( + quote do: + var `jesIdent` = initJester(`matchIdent`, `settingsIdent`) + `jesIdent`.register(`errorHandlerIdent`) + ) + result.add( + quote do: + serve(`jesIdent`) + ) + +macro router*(name: untyped, body: untyped): typed = + if name.kind != nnkIdent: + error("Need an ident.", name) + + routesEx($name.ident, body) + +macro settings*(body: untyped): typed = + #echo(treeRepr(body)) + expectKind(body, nnkStmtList) + + result = newStmtList() + + # var settings = newSettings() + let settingsIdent = newIdentNode("settings") + result.add newVarStmt(settingsIdent, newCall("newSettings")) + + for asgn in body.children: + expectKind(asgn, nnkAsgn) + result.add newAssignment(newDotExpr(settingsIdent, asgn[0]), asgn[1]) diff --git a/tests/deps/jester-#head/jester.nimble b/tests/deps/jester-#head/jester.nimble new file mode 100644 index 000000000..08e990bd7 --- /dev/null +++ b/tests/deps/jester-#head/jester.nimble @@ -0,0 +1,22 @@ +# Package + +version = "0.4.0" # Be sure to update jester.jesterVer too! +author = "Dominik Picheta" +description = "A sinatra-like web framework for Nim." +license = "MIT" + +skipFiles = @["todo.markdown"] +skipDirs = @["tests"] + +# Deps + +requires "nim >= 0.18.1" + +when not defined(windows): + requires "httpbeast >= 0.2.0" + +# For tests +requires "asynctools" + +task test, "Runs the test suite.": + exec "nimble c -y -r tests/tester" \ No newline at end of file diff --git a/tests/deps/jester-#head/jester/patterns.nim b/tests/deps/jester-#head/jester/patterns.nim new file mode 100644 index 000000000..52b0d3a15 --- /dev/null +++ b/tests/deps/jester-#head/jester/patterns.nim @@ -0,0 +1,141 @@ +# Copyright (C) 2012-2018 Dominik Picheta +# MIT License - Look at license.txt for details. +import parseutils, tables +type + NodeType* = enum + NodeText, NodeField + Node* = object + typ*: NodeType + text*: string + optional*: bool + + Pattern* = seq[Node] + +#/show/@id/? +proc parsePattern*(pattern: string): Pattern = + result = @[] + template addNode(result: var Pattern, theT: NodeType, theText: string, + isOptional: bool): typed = + block: + var newNode: Node + newNode.typ = theT + newNode.text = theText + newNode.optional = isOptional + result.add(newNode) + + template `{}`(s: string, i: int): char = + if i >= len(s): + '\0' + else: + s[i] + + var i = 0 + var text = "" + while i < pattern.len(): + case pattern[i] + of '@': + # Add the stored text. + if text != "": + result.addNode(NodeText, text, false) + text = "" + # Parse named parameter. + inc(i) # Skip @ + var nparam = "" + i += pattern.parseUntil(nparam, {'/', '?'}, i) + var optional = pattern{i} == '?' + result.addNode(NodeField, nparam, optional) + if pattern{i} == '?': inc(i) # Only skip ?. / should not be skipped. + of '?': + var optionalChar = text[^1] + setLen(text, text.len-1) # Truncate ``text``. + # Add the stored text. + if text != "": + result.addNode(NodeText, text, false) + text = "" + # Add optional char. + inc(i) # Skip ? + result.addNode(NodeText, $optionalChar, true) + of '\\': + inc i # Skip \ + if pattern[i] notin {'?', '@', '\\'}: + raise newException(ValueError, + "This character does not require escaping: " & pattern[i]) + text.add(pattern{i}) + inc i # Skip ``pattern[i]`` + else: + text.add(pattern{i}) + inc(i) + + if text != "": + result.addNode(NodeText, text, false) + +proc findNextText(pattern: Pattern, i: int, toNode: var Node): bool = + ## Finds the next NodeText in the pattern, starts looking from ``i``. + result = false + for n in i..pattern.len()-1: + if pattern[n].typ == NodeText: + toNode = pattern[n] + return true + +proc check(n: Node, s: string, i: int): bool = + let cutTo = (n.text.len-1)+i + if cutTo > s.len-1: return false + return s.substr(i, cutTo) == n.text + +proc match*(pattern: Pattern, s: string): + tuple[matched: bool, params: Table[string, string]] = + var i = 0 # Location in ``s``. + + result.matched = true + result.params = initTable[string, string]() + + for ncount, node in pattern: + case node.typ + of NodeText: + if node.optional: + if check(node, s, i): + inc(i, node.text.len) # Skip over this optional character. + else: + # If it's not there, we have nothing to do. It's optional after all. + discard + else: + if check(node, s, i): + inc(i, node.text.len) # Skip over this + else: + # No match. + result.matched = false + return + of NodeField: + var nextTxtNode: Node + var stopChar = '/' + if findNextText(pattern, ncount, nextTxtNode): + stopChar = nextTxtNode.text[0] + var matchNamed = "" + i += s.parseUntil(matchNamed, stopChar, i) + result.params[node.text] = matchNamed + if matchNamed == "" and not node.optional: + result.matched = false + return + + if s.len != i: + result.matched = false + +when isMainModule: + let f = parsePattern("/show/@id/test/@show?/?") + doAssert match(f, "/show/12/test/hallo/").matched + doAssert match(f, "/show/2131726/test/jjjuuwąąss").matched + doAssert(not match(f, "/").matched) + doAssert(not match(f, "/show//test//").matched) + doAssert(match(f, "/show/asd/test//").matched) + doAssert(not match(f, "/show/asd/asd/test/jjj/").matched) + doAssert(match(f, "/show/@łę¶ŧ←/test/asd/").params["id"] == "@łę¶ŧ←") + + let f2 = parsePattern("/test42/somefile.?@ext?/?") + doAssert(match(f2, "/test42/somefile/").params["ext"] == "") + doAssert(match(f2, "/test42/somefile.txt").params["ext"] == "txt") + doAssert(match(f2, "/test42/somefile.txt/").params["ext"] == "txt") + + let f3 = parsePattern(r"/test32/\@\\\??") + doAssert(match(f3, r"/test32/@\").matched) + doAssert(not match(f3, r"/test32/@\\").matched) + doAssert(match(f3, r"/test32/@\?").matched) diff --git a/tests/deps/jester-#head/jester/private/errorpages.nim b/tests/deps/jester-#head/jester/private/errorpages.nim new file mode 100644 index 000000000..d1e695040 --- /dev/null +++ b/tests/deps/jester-#head/jester/private/errorpages.nim @@ -0,0 +1,19 @@ +# Copyright (C) 2012 Dominik Picheta +# MIT License - Look at license.txt for details. +import htmlgen +proc error*(err, jesterVer: string): string = + return html(head(title(err)), + body(h1(err), + "<hr/>", + p("Jester " & jesterVer), + style = "text-align: center;" + ), + xmlns="http://www.w3.org/1999/xhtml") + +proc routeException*(error: string, jesterVer: string): string = + return html(head(title("Jester route exception")), + body( + h1("An error has occured in one of your routes."), + p(b("Detail: "), error) + ), + xmlns="http://www.w3.org/1999/xhtml") diff --git a/tests/deps/jester-#head/jester/private/utils.nim b/tests/deps/jester-#head/jester/private/utils.nim new file mode 100644 index 000000000..66f0b37a6 --- /dev/null +++ b/tests/deps/jester-#head/jester/private/utils.nim @@ -0,0 +1,195 @@ +# Copyright (C) 2012 Dominik Picheta +# MIT License - Look at license.txt for details. +import parseutils, strtabs, strutils, tables, net, mimetypes, asyncdispatch, os +from cgi import decodeUrl + +const + useHttpBeast* = false # not defined(windows) and not defined(useStdLib) + +type + MultiData* = OrderedTable[string, tuple[fields: StringTableRef, body: string]] + + Settings* = ref object + staticDir*: string # By default ./public + appName*: string + mimes*: MimeDb + port*: Port + bindAddr*: string + reusePort*: bool + futureErrorHandler*: proc (fut: Future[void]) {.closure, gcsafe.} + + JesterError* = object of Exception + +proc parseUrlQuery*(query: string, result: var Table[string, string]) + {.deprecated: "use stdlib".} = + var i = 0 + i = query.skip("?") + while i < query.len()-1: + var key = "" + var val = "" + i += query.parseUntil(key, '=', i) + if query[i] != '=': + raise newException(ValueError, "Expected '=' at " & $i & + " but got: " & $query[i]) + inc(i) # Skip = + i += query.parseUntil(val, '&', i) + inc(i) # Skip & + result[decodeUrl(key)] = decodeUrl(val) + +template parseContentDisposition(): typed = + var hCount = 0 + while hCount < hValue.len()-1: + var key = "" + hCount += hValue.parseUntil(key, {';', '='}, hCount) + if hValue[hCount] == '=': + var value = hvalue.captureBetween('"', start = hCount) + hCount += value.len+2 + inc(hCount) # Skip ; + hCount += hValue.skipWhitespace(hCount) + if key == "name": name = value + newPart[0][key] = value + else: + inc(hCount) + hCount += hValue.skipWhitespace(hCount) + +proc parseMultiPart*(body: string, boundary: string): MultiData = + result = initOrderedTable[string, tuple[fields: StringTableRef, body: string]]() + var mboundary = "--" & boundary + + var i = 0 + var partsLeft = true + while partsLeft: + var firstBoundary = body.skip(mboundary, i) + if firstBoundary == 0: + raise newException(ValueError, "Expected boundary. Got: " & body.substr(i, i+25)) + i += firstBoundary + i += body.skipWhitespace(i) + + # Headers + var newPart: tuple[fields: StringTableRef, body: string] = ({:}.newStringTable, "") + var name = "" + while true: + if body[i] == '\c': + inc(i, 2) # Skip \c\L + break + var hName = "" + i += body.parseUntil(hName, ':', i) + if body[i] != ':': + raise newException(ValueError, "Expected : in headers.") + inc(i) # Skip : + i += body.skipWhitespace(i) + var hValue = "" + i += body.parseUntil(hValue, {'\c', '\L'}, i) + if toLowerAscii(hName) == "content-disposition": + parseContentDisposition() + newPart[0][hName] = hValue + i += body.skip("\c\L", i) # Skip *one* \c\L + + # Parse body. + while true: + if body[i] == '\c' and body[i+1] == '\L' and + body.skip(mboundary, i+2) != 0: + if body.skip("--", i+2+mboundary.len) != 0: + partsLeft = false + break + break + else: + newPart[1].add(body[i]) + inc(i) + i += body.skipWhitespace(i) + + result.add(name, newPart) + +proc parseMPFD*(contentType: string, body: string): MultiData = + var boundaryEqIndex = contentType.find("boundary=")+9 + var boundary = contentType.substr(boundaryEqIndex, contentType.len()-1) + return parseMultiPart(body, boundary) + +proc parseCookies*(s: string): Table[string, string] = + ## parses cookies into a string table. + ## + ## The proc is meant to parse the Cookie header set by a client, not the + ## "Set-Cookie" header set by servers. + + result = initTable[string, string]() + var i = 0 + while true: + i += skipWhile(s, {' ', '\t'}, i) + var keystart = i + i += skipUntil(s, {'='}, i) + var keyend = i-1 + if i >= len(s): break + inc(i) # skip '=' + var valstart = i + i += skipUntil(s, {';'}, i) + result[substr(s, keystart, keyend)] = substr(s, valstart, i-1) + if i >= len(s): break + inc(i) # skip ';' + +type + SameSite* = enum + None, Lax, Strict + +proc makeCookie*(key, value, expires: string, domain = "", path = "", + secure = false, httpOnly = false, + sameSite = Lax): string = + result = "" + result.add key & "=" & value + if domain != "": result.add("; Domain=" & domain) + if path != "": result.add("; Path=" & path) + if expires != "": result.add("; Expires=" & expires) + if secure: result.add("; Secure") + if httpOnly: result.add("; HttpOnly") + if sameSite != None: + result.add("; SameSite=" & $sameSite) + +when not declared(tables.getOrDefault): + template getOrDefault*(tab, key): untyped = tab[key] + +when not declared(normalizePath) and not declared(normalizedPath): + proc normalizePath*(path: var string) = + ## Normalize a path. + ## + ## Consecutive directory separators are collapsed, including an initial double slash. + ## + ## On relative paths, double dot (..) sequences are collapsed if possible. + ## On absolute paths they are always collapsed. + ## + ## Warning: URL-encoded and Unicode attempts at directory traversal are not detected. + ## Triple dot is not handled. + let isAbs = isAbsolute(path) + var stack: seq[string] = @[] + for p in split(path, {DirSep}): + case p + of "", ".": + continue + of "..": + if stack.len == 0: + if isAbs: + discard # collapse all double dots on absoluta paths + else: + stack.add(p) + elif stack[^1] == "..": + stack.add(p) + else: + discard stack.pop() + else: + stack.add(p) + + if isAbs: + path = DirSep & join(stack, $DirSep) + elif stack.len > 0: + path = join(stack, $DirSep) + else: + path = "." + + proc normalizedPath*(path: string): string = + ## Returns a normalized path for the current OS. See `<#normalizePath>`_ + result = path + normalizePath(result) + +when isMainModule: + var r = {:}.newStringTable + parseUrlQuery("FirstName=Mickey", r) + echo r + diff --git a/tests/deps/jester-#head/jester/request.nim b/tests/deps/jester-#head/jester/request.nim new file mode 100644 index 000000000..1b837d728 --- /dev/null +++ b/tests/deps/jester-#head/jester/request.nim @@ -0,0 +1,184 @@ +import uri, cgi, tables, logging, strutils, re, options + +import jester/private/utils + +when useHttpBeast: + import httpbeast except Settings + import options, httpcore + + type + NativeRequest* = httpbeast.Request +else: + import asynchttpserver + + type + NativeRequest* = asynchttpserver.Request + +type + Request* = object + req: NativeRequest + patternParams: Option[Table[string, string]] + reMatches: array[MaxSubpatterns, string] + settings*: Settings + +proc body*(req: Request): string = + ## Body of the request, only for POST. + ## + ## You're probably looking for ``formData`` + ## instead. + when useHttpBeast: + req.req.body.get("") + else: + req.req.body + +proc headers*(req: Request): HttpHeaders = + ## Headers received with the request. + ## Retrieving these is case insensitive. + when useHttpBeast: + if req.req.headers.isNone: + newHttpHeaders() + else: + req.req.headers.get() + else: + req.req.headers + +proc path*(req: Request): string = + ## Path of request without the query string. + when useHttpBeast: + let p = req.req.path.get("") + let queryStart = p.find('?') + if unlikely(queryStart != -1): + return p[0 .. queryStart-1] + else: + return p + else: + let u = req.req.url + return u.path + +proc reqMethod*(req: Request): HttpMethod = + ## Request method, eg. HttpGet, HttpPost + when useHttpBeast: + req.req.httpMethod.get() + else: + req.req.reqMethod +proc reqMeth*(req: Request): HttpMethod {.deprecated.} = + req.reqMethod + +proc ip*(req: Request): string = + ## IP address of the requesting client. + when useHttpBeast: + result = req.req.ip + else: + result = req.req.hostname + + let headers = req.headers + if headers.hasKey("REMOTE_ADDR"): + result = headers["REMOTE_ADDR"] + if headers.hasKey("x-forwarded-for"): + result = headers["x-forwarded-for"] + +proc params*(req: Request): Table[string, string] = + ## Parameters from the pattern and the query string. + if req.patternParams.isSome(): + result = req.patternParams.get() + else: + result = initTable[string, string]() + + when useHttpBeast: + let query = req.req.path.get("").parseUri().query + else: + let query = req.req.url.query + + try: + for key, val in cgi.decodeData(query): + result[key] = val + except CgiError: + logging.warn("Incorrect query. Got: $1" % [query]) + + let contentType = req.headers.getOrDefault("Content-Type") + if contentType.startswith("application/x-www-form-urlencoded"): + try: + parseUrlQuery(req.body, result) + except: + logging.warn("Could not parse URL query.") + +proc formData*(req: Request): MultiData = + let contentType = req.headers.getOrDefault("Content-Type") + if contentType.startsWith("multipart/form-data"): + result = parseMPFD(contentType, req.body) + +proc matches*(req: Request): array[MaxSubpatterns, string] = + req.reMatches + +proc secure*(req: Request): bool = + if req.headers.hasKey("x-forwarded-proto"): + let proto = req.headers["x-forwarded-proto"] + case proto.toLowerAscii() + of "https": + result = true + of "http": + result = false + else: + logging.warn("Unknown x-forwarded-proto ", proto) + +proc port*(req: Request): int = + if (let p = req.headers.getOrDefault("SERVER_PORT"); p != ""): + result = p.parseInt + else: + result = if req.secure: 443 else: 80 + +proc host*(req: Request): string = + req.headers.getOrDefault("HOST") + +proc appName*(req: Request): string = + ## This is set by the user in ``run``, it is + ## overriden by the "SCRIPT_NAME" scgi + ## parameter. + req.settings.appName + +proc stripAppName(path, appName: string): string = + result = path + if appname.len > 0: + var slashAppName = appName + if slashAppName[0] != '/' and path[0] == '/': + slashAppName = '/' & slashAppName + + if path.startsWith(slashAppName): + if slashAppName.len() == path.len: + return "/" + else: + return path[slashAppName.len .. path.len-1] + else: + raise newException(ValueError, + "Expected script name at beginning of path. Got path: " & + path & " script name: " & slashAppName) + +proc pathInfo*(req: Request): string = + ## This is ``.path`` without ``.appName``. + req.path.stripAppName(req.appName) + +# TODO: Can cookie keys be duplicated? +proc cookies*(req: Request): Table[string, string] = + ## Cookies from the browser. + if (let cookie = req.headers.getOrDefault("Cookie"); cookie != ""): + result = parseCookies(cookie) + else: + result = initTable[string, string]() + +#[ Protected procs ]# + +proc initRequest*(req: NativeRequest, settings: Settings): Request {.inline.} = + Request( + req: req, + settings: settings + ) + +proc getNativeReq*(req: Request): NativeRequest = + req.req + +#[ Only to be used by our route macro. ]# +proc setPatternParams*(req: var Request, p: Table[string, string]) = + req.patternParams = some(p) + +proc setReMatches*(req: var Request, r: array[MaxSubpatterns, string]) = + req.reMatches = r diff --git a/tests/deps/opengl-1.1.0/glu.nim b/tests/deps/opengl-1.1.0/glu.nim new file mode 100644 index 000000000..5594ef915 --- /dev/null +++ b/tests/deps/opengl-1.1.0/glu.nim @@ -0,0 +1,326 @@ +# +# +# Adaption of the delphi3d.net OpenGL units to FreePascal +# Sebastian Guenther (sg@freepascal.org) in 2002 +# These units are free to use +#****************************************************************************** +# Converted to Delphi by Tom Nuydens (tom@delphi3d.net) +# For the latest updates, visit Delphi3D: http://www.delphi3d.net +#****************************************************************************** + +import opengl + +{.deadCodeElim: on.} + +when defined(windows): + {.push, callconv: stdcall.} +else: + {.push, callconv: cdecl.} + +when defined(windows): + const + dllname = "glu32.dll" +elif defined(macosx): + const + dllname = "/System/Library/Frameworks/OpenGL.framework/Libraries/libGLU.dylib" +else: + const + dllname = "libGLU.so.1" + +type + ViewPortArray* = array[0..3, GLint] + T16dArray* = array[0..15, GLdouble] + CallBack* = proc () {.cdecl.} + T3dArray* = array[0..2, GLdouble] + T4pArray* = array[0..3, pointer] + T4fArray* = array[0..3, GLfloat] + +{.deprecated: [ + TViewPortArray: ViewPortArray, + TCallBack: CallBack, +].} + +type + GLUnurbs*{.final.} = ptr object + GLUquadric*{.final.} = ptr object + GLUtesselator*{.final.} = ptr object + GLUnurbsObj* = GLUnurbs + GLUquadricObj* = GLUquadric + GLUtesselatorObj* = GLUtesselator + GLUtriangulatorObj* = GLUtesselator + +proc gluErrorString*(errCode: GLenum): cstring{.dynlib: dllname, + importc: "gluErrorString".} +when defined(Windows): + proc gluErrorUnicodeStringEXT*(errCode: GLenum): ptr int16{.dynlib: dllname, + importc: "gluErrorUnicodeStringEXT".} +proc gluGetString*(name: GLenum): cstring{.dynlib: dllname, + importc: "gluGetString".} +proc gluOrtho2D*(left, right, bottom, top: GLdouble){.dynlib: dllname, + importc: "gluOrtho2D".} +proc gluPerspective*(fovy, aspect, zNear, zFar: GLdouble){.dynlib: dllname, + importc: "gluPerspective".} +proc gluPickMatrix*(x, y, width, height: GLdouble, viewport: var ViewPortArray){. + dynlib: dllname, importc: "gluPickMatrix".} +proc gluLookAt*(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz: GLdouble){. + dynlib: dllname, importc: "gluLookAt".} +proc gluProject*(objx, objy, objz: GLdouble, + modelMatrix, projMatrix: var T16dArray, + viewport: var ViewPortArray, winx, winy, winz: ptr GLdouble): int{. + dynlib: dllname, importc: "gluProject".} +proc gluUnProject*(winx, winy, winz: GLdouble, + modelMatrix, projMatrix: var T16dArray, + viewport: var ViewPortArray, objx, objy, objz: ptr GLdouble): int{. + dynlib: dllname, importc: "gluUnProject".} +proc gluScaleImage*(format: GLenum, widthin, heightin: GLint, typein: GLenum, + datain: pointer, widthout, heightout: GLint, + typeout: GLenum, dataout: pointer): int{.dynlib: dllname, + importc: "gluScaleImage".} +proc gluBuild1DMipmaps*(target: GLenum, components, width: GLint, + format, atype: GLenum, data: pointer): int{. + dynlib: dllname, importc: "gluBuild1DMipmaps".} +proc gluBuild2DMipmaps*(target: GLenum, components, width, height: GLint, + format, atype: GLenum, data: pointer): int{. + dynlib: dllname, importc: "gluBuild2DMipmaps".} +proc gluNewQuadric*(): GLUquadric{.dynlib: dllname, importc: "gluNewQuadric".} +proc gluDeleteQuadric*(state: GLUquadric){.dynlib: dllname, + importc: "gluDeleteQuadric".} +proc gluQuadricNormals*(quadObject: GLUquadric, normals: GLenum){. + dynlib: dllname, importc: "gluQuadricNormals".} +proc gluQuadricTexture*(quadObject: GLUquadric, textureCoords: GLboolean){. + dynlib: dllname, importc: "gluQuadricTexture".} +proc gluQuadricOrientation*(quadObject: GLUquadric, orientation: GLenum){. + dynlib: dllname, importc: "gluQuadricOrientation".} +proc gluQuadricDrawStyle*(quadObject: GLUquadric, drawStyle: GLenum){. + dynlib: dllname, importc: "gluQuadricDrawStyle".} +proc gluCylinder*(qobj: GLUquadric, baseRadius, topRadius, height: GLdouble, + slices, stacks: GLint){.dynlib: dllname, + importc: "gluCylinder".} +proc gluDisk*(qobj: GLUquadric, innerRadius, outerRadius: GLdouble, + slices, loops: GLint){.dynlib: dllname, importc: "gluDisk".} +proc gluPartialDisk*(qobj: GLUquadric, innerRadius, outerRadius: GLdouble, + slices, loops: GLint, startAngle, sweepAngle: GLdouble){. + dynlib: dllname, importc: "gluPartialDisk".} +proc gluSphere*(qobj: GLuquadric, radius: GLdouble, slices, stacks: GLint){. + dynlib: dllname, importc: "gluSphere".} +proc gluQuadricCallback*(qobj: GLUquadric, which: GLenum, fn: CallBack){. + dynlib: dllname, importc: "gluQuadricCallback".} +proc gluNewTess*(): GLUtesselator{.dynlib: dllname, importc: "gluNewTess".} +proc gluDeleteTess*(tess: GLUtesselator){.dynlib: dllname, + importc: "gluDeleteTess".} +proc gluTessBeginPolygon*(tess: GLUtesselator, polygon_data: pointer){. + dynlib: dllname, importc: "gluTessBeginPolygon".} +proc gluTessBeginContour*(tess: GLUtesselator){.dynlib: dllname, + importc: "gluTessBeginContour".} +proc gluTessVertex*(tess: GLUtesselator, coords: var T3dArray, data: pointer){. + dynlib: dllname, importc: "gluTessVertex".} +proc gluTessEndContour*(tess: GLUtesselator){.dynlib: dllname, + importc: "gluTessEndContour".} +proc gluTessEndPolygon*(tess: GLUtesselator){.dynlib: dllname, + importc: "gluTessEndPolygon".} +proc gluTessProperty*(tess: GLUtesselator, which: GLenum, value: GLdouble){. + dynlib: dllname, importc: "gluTessProperty".} +proc gluTessNormal*(tess: GLUtesselator, x, y, z: GLdouble){.dynlib: dllname, + importc: "gluTessNormal".} +proc gluTessCallback*(tess: GLUtesselator, which: GLenum, fn: CallBack){. + dynlib: dllname, importc: "gluTessCallback".} +proc gluGetTessProperty*(tess: GLUtesselator, which: GLenum, value: ptr GLdouble){. + dynlib: dllname, importc: "gluGetTessProperty".} +proc gluNewNurbsRenderer*(): GLUnurbs{.dynlib: dllname, + importc: "gluNewNurbsRenderer".} +proc gluDeleteNurbsRenderer*(nobj: GLUnurbs){.dynlib: dllname, + importc: "gluDeleteNurbsRenderer".} +proc gluBeginSurface*(nobj: GLUnurbs){.dynlib: dllname, + importc: "gluBeginSurface".} +proc gluBeginCurve*(nobj: GLUnurbs){.dynlib: dllname, importc: "gluBeginCurve".} +proc gluEndCurve*(nobj: GLUnurbs){.dynlib: dllname, importc: "gluEndCurve".} +proc gluEndSurface*(nobj: GLUnurbs){.dynlib: dllname, importc: "gluEndSurface".} +proc gluBeginTrim*(nobj: GLUnurbs){.dynlib: dllname, importc: "gluBeginTrim".} +proc gluEndTrim*(nobj: GLUnurbs){.dynlib: dllname, importc: "gluEndTrim".} +proc gluPwlCurve*(nobj: GLUnurbs, count: GLint, aarray: ptr GLfloat, + stride: GLint, atype: GLenum){.dynlib: dllname, + importc: "gluPwlCurve".} +proc gluNurbsCurve*(nobj: GLUnurbs, nknots: GLint, knot: ptr GLfloat, + stride: GLint, ctlarray: ptr GLfloat, order: GLint, + atype: GLenum){.dynlib: dllname, importc: "gluNurbsCurve".} +proc gluNurbsSurface*(nobj: GLUnurbs, sknot_count: GLint, sknot: ptr GLfloat, + tknot_count: GLint, tknot: ptr GLfloat, + s_stride, t_stride: GLint, ctlarray: ptr GLfloat, + sorder, torder: GLint, atype: GLenum){.dynlib: dllname, + importc: "gluNurbsSurface".} +proc gluLoadSamplingMatrices*(nobj: GLUnurbs, + modelMatrix, projMatrix: var T16dArray, + viewport: var ViewPortArray){.dynlib: dllname, + importc: "gluLoadSamplingMatrices".} +proc gluNurbsProperty*(nobj: GLUnurbs, aproperty: GLenum, value: GLfloat){. + dynlib: dllname, importc: "gluNurbsProperty".} +proc gluGetNurbsProperty*(nobj: GLUnurbs, aproperty: GLenum, value: ptr GLfloat){. + dynlib: dllname, importc: "gluGetNurbsProperty".} +proc gluNurbsCallback*(nobj: GLUnurbs, which: GLenum, fn: CallBack){. + dynlib: dllname, importc: "gluNurbsCallback".} + #*** Callback function prototypes *** +type # gluQuadricCallback + GLUquadricErrorProc* = proc (p: GLenum) # gluTessCallback + GLUtessBeginProc* = proc (p: GLenum) + GLUtessEdgeFlagProc* = proc (p: GLboolean) + GLUtessVertexProc* = proc (p: pointer) + GLUtessEndProc* = proc () + GLUtessErrorProc* = proc (p: GLenum) + GLUtessCombineProc* = proc (p1: var T3dArray, p2: T4pArray, p3: T4fArray, + p4: ptr pointer) + GLUtessBeginDataProc* = proc (p1: GLenum, p2: pointer) + GLUtessEdgeFlagDataProc* = proc (p1: GLboolean, p2: pointer) + GLUtessVertexDataProc* = proc (p1, p2: pointer) + GLUtessEndDataProc* = proc (p: pointer) + GLUtessErrorDataProc* = proc (p1: GLenum, p2: pointer) + GLUtessCombineDataProc* = proc (p1: var T3dArray, p2: var T4pArray, + p3: var T4fArray, p4: ptr pointer, p5: pointer) # + GLUnurbsErrorProc* = proc (p: GLenum) #*** Generic constants ****/ + +const # Version + GLU_VERSION_1_1* = 1 + GLU_VERSION_1_2* = 1 # Errors: (return value 0 = no error) + GLU_INVALID_ENUM* = 100900 + GLU_INVALID_VALUE* = 100901 + GLU_OUT_OF_MEMORY* = 100902 + GLU_INCOMPATIBLE_GL_VERSION* = 100903 # StringName + GLU_VERSION* = 100800 + GLU_EXTENSIONS* = 100801 # Boolean + GLU_TRUE* = GL_TRUE + GLU_FALSE* = GL_FALSE #*** Quadric constants ****/ + # QuadricNormal + GLU_SMOOTH* = 100000 + GLU_FLAT* = 100001 + GLU_NONE* = 100002 # QuadricDrawStyle + GLU_POINT* = 100010 + GLU_LINE* = 100011 + GLU_FILL* = 100012 + GLU_SILHOUETTE* = 100013 # QuadricOrientation + GLU_OUTSIDE* = 100020 + GLU_INSIDE* = 100021 # Callback types: + # GLU_ERROR = 100103; + #*** Tesselation constants ****/ + GLU_TESS_MAX_COORD* = 1.00000e+150 # TessProperty + GLU_TESS_WINDING_RULE* = 100140 + GLU_TESS_BOUNDARY_ONLY* = 100141 + GLU_TESS_TOLERANCE* = 100142 # TessWinding + GLU_TESS_WINDING_ODD* = 100130 + GLU_TESS_WINDING_NONZERO* = 100131 + GLU_TESS_WINDING_POSITIVE* = 100132 + GLU_TESS_WINDING_NEGATIVE* = 100133 + GLU_TESS_WINDING_ABS_GEQ_TWO* = 100134 # TessCallback + GLU_TESS_BEGIN* = 100100 # void (CALLBACK*)(GLenum type) + constGLU_TESS_VERTEX* = 100101 # void (CALLBACK*)(void *data) + GLU_TESS_END* = 100102 # void (CALLBACK*)(void) + GLU_TESS_ERROR* = 100103 # void (CALLBACK*)(GLenum errno) + GLU_TESS_EDGE_FLAG* = 100104 # void (CALLBACK*)(GLboolean boundaryEdge) + GLU_TESS_COMBINE* = 100105 # void (CALLBACK*)(GLdouble coords[3], + # void *data[4], + # GLfloat weight[4], + # void **dataOut) + GLU_TESS_BEGIN_DATA* = 100106 # void (CALLBACK*)(GLenum type, + # void *polygon_data) + GLU_TESS_VERTEX_DATA* = 100107 # void (CALLBACK*)(void *data, + # void *polygon_data) + GLU_TESS_END_DATA* = 100108 # void (CALLBACK*)(void *polygon_data) + GLU_TESS_ERROR_DATA* = 100109 # void (CALLBACK*)(GLenum errno, + # void *polygon_data) + GLU_TESS_EDGE_FLAG_DATA* = 100110 # void (CALLBACK*)(GLboolean boundaryEdge, + # void *polygon_data) + GLU_TESS_COMBINE_DATA* = 100111 # void (CALLBACK*)(GLdouble coords[3], + # void *data[4], + # GLfloat weight[4], + # void **dataOut, + # void *polygon_data) + # TessError + GLU_TESS_ERROR1* = 100151 + GLU_TESS_ERROR2* = 100152 + GLU_TESS_ERROR3* = 100153 + GLU_TESS_ERROR4* = 100154 + GLU_TESS_ERROR5* = 100155 + GLU_TESS_ERROR6* = 100156 + GLU_TESS_ERROR7* = 100157 + GLU_TESS_ERROR8* = 100158 + GLU_TESS_MISSING_BEGIN_POLYGON* = GLU_TESS_ERROR1 + GLU_TESS_MISSING_BEGIN_CONTOUR* = GLU_TESS_ERROR2 + GLU_TESS_MISSING_END_POLYGON* = GLU_TESS_ERROR3 + GLU_TESS_MISSING_END_CONTOUR* = GLU_TESS_ERROR4 + GLU_TESS_COORD_TOO_LARGE* = GLU_TESS_ERROR5 + GLU_TESS_NEED_COMBINE_CALLBACK* = GLU_TESS_ERROR6 #*** NURBS constants ****/ + # NurbsProperty + GLU_AUTO_LOAD_MATRIX* = 100200 + GLU_CULLING* = 100201 + GLU_SAMPLING_TOLERANCE* = 100203 + GLU_DISPLAY_MODE* = 100204 + GLU_PARAMETRIC_TOLERANCE* = 100202 + GLU_SAMPLING_METHOD* = 100205 + GLU_U_STEP* = 100206 + GLU_V_STEP* = 100207 # NurbsSampling + GLU_PATH_LENGTH* = 100215 + GLU_PARAMETRIC_ERROR* = 100216 + GLU_DOMAIN_DISTANCE* = 100217 # NurbsTrim + GLU_MAP1_TRIM_2* = 100210 + GLU_MAP1_TRIM_3* = 100211 # NurbsDisplay + # GLU_FILL = 100012; + GLU_OUTLINE_POLYGON* = 100240 + GLU_OUTLINE_PATCH* = 100241 # NurbsCallback + # GLU_ERROR = 100103; + # NurbsErrors + GLU_NURBS_ERROR1* = 100251 + GLU_NURBS_ERROR2* = 100252 + GLU_NURBS_ERROR3* = 100253 + GLU_NURBS_ERROR4* = 100254 + GLU_NURBS_ERROR5* = 100255 + GLU_NURBS_ERROR6* = 100256 + GLU_NURBS_ERROR7* = 100257 + GLU_NURBS_ERROR8* = 100258 + GLU_NURBS_ERROR9* = 100259 + GLU_NURBS_ERROR10* = 100260 + GLU_NURBS_ERROR11* = 100261 + GLU_NURBS_ERROR12* = 100262 + GLU_NURBS_ERROR13* = 100263 + GLU_NURBS_ERROR14* = 100264 + GLU_NURBS_ERROR15* = 100265 + GLU_NURBS_ERROR16* = 100266 + GLU_NURBS_ERROR17* = 100267 + GLU_NURBS_ERROR18* = 100268 + GLU_NURBS_ERROR19* = 100269 + GLU_NURBS_ERROR20* = 100270 + GLU_NURBS_ERROR21* = 100271 + GLU_NURBS_ERROR22* = 100272 + GLU_NURBS_ERROR23* = 100273 + GLU_NURBS_ERROR24* = 100274 + GLU_NURBS_ERROR25* = 100275 + GLU_NURBS_ERROR26* = 100276 + GLU_NURBS_ERROR27* = 100277 + GLU_NURBS_ERROR28* = 100278 + GLU_NURBS_ERROR29* = 100279 + GLU_NURBS_ERROR30* = 100280 + GLU_NURBS_ERROR31* = 100281 + GLU_NURBS_ERROR32* = 100282 + GLU_NURBS_ERROR33* = 100283 + GLU_NURBS_ERROR34* = 100284 + GLU_NURBS_ERROR35* = 100285 + GLU_NURBS_ERROR36* = 100286 + GLU_NURBS_ERROR37* = 100287 #*** Backwards compatibility for old tesselator ****/ + +proc gluBeginPolygon*(tess: GLUtesselator){.dynlib: dllname, + importc: "gluBeginPolygon".} +proc gluNextContour*(tess: GLUtesselator, atype: GLenum){.dynlib: dllname, + importc: "gluNextContour".} +proc gluEndPolygon*(tess: GLUtesselator){.dynlib: dllname, + importc: "gluEndPolygon".} +const # Contours types -- obsolete! + GLU_CW* = 100120 + GLU_CCW* = 100121 + GLU_INTERIOR* = 100122 + GLU_EXTERIOR* = 100123 + GLU_UNKNOWN* = 100124 # Names without "TESS_" prefix + GLU_BEGIN* = GLU_TESS_BEGIN + GLU_VERTEX* = constGLU_TESS_VERTEX + GLU_END* = GLU_TESS_END + GLU_ERROR* = GLU_TESS_ERROR + GLU_EDGE_FLAG* = GLU_TESS_EDGE_FLAG + +{.pop.} +# implementation diff --git a/tests/deps/opengl-1.1.0/glut.nim b/tests/deps/opengl-1.1.0/glut.nim new file mode 100644 index 000000000..55a5da0c7 --- /dev/null +++ b/tests/deps/opengl-1.1.0/glut.nim @@ -0,0 +1,366 @@ +# +# +# Adaption of the delphi3d.net OpenGL units to FreePascal +# Sebastian Guenther (sg@freepascal.org) in 2002 +# These units are free to use +# + +# Copyright (c) Mark J. Kilgard, 1994, 1995, 1996. +# This program is freely distributable without licensing fees and is +# provided without guarantee or warrantee expressed or implied. This +# program is -not- in the public domain. +#****************************************************************************** +# Converted to Delphi by Tom Nuydens (tom@delphi3d.net) +# Contributions by Igor Karpov (glygrik@hotbox.ru) +# For the latest updates, visit Delphi3D: http://www.delphi3d.net +#****************************************************************************** + +import opengl + +{.deadCodeElim: on.} + +when defined(windows): + const + dllname = "glut32.dll" +elif defined(macosx): + const + dllname = "/System/Library/Frameworks/GLUT.framework/GLUT" +else: + const + dllname = "libglut.so.3" +type + TGlutVoidCallback* = proc (){.cdecl.} + TGlut1IntCallback* = proc (value: cint){.cdecl.} + TGlut2IntCallback* = proc (v1, v2: cint){.cdecl.} + TGlut3IntCallback* = proc (v1, v2, v3: cint){.cdecl.} + TGlut4IntCallback* = proc (v1, v2, v3, v4: cint){.cdecl.} + TGlut1Char2IntCallback* = proc (c: int8, v1, v2: cint){.cdecl.} + TGlut1UInt3IntCallback* = proc (u, v1, v2, v3: cint){.cdecl.} + +{.deprecated: [Pointer: pointer].} + +const + GLUT_API_VERSION* = 3 + GLUT_XLIB_IMPLEMENTATION* = 12 # Display mode bit masks. + GLUT_RGB* = 0 + GLUT_RGBA* = GLUT_RGB + GLUT_INDEX* = 1 + GLUT_SINGLE* = 0 + GLUT_DOUBLE* = 2 + GLUT_ACCUM* = 4 + GLUT_ALPHA* = 8 + GLUT_DEPTH* = 16 + GLUT_STENCIL* = 32 + GLUT_MULTISAMPLE* = 128 + GLUT_STEREO* = 256 + GLUT_LUMINANCE* = 512 # Mouse buttons. + GLUT_LEFT_BUTTON* = 0 + GLUT_MIDDLE_BUTTON* = 1 + GLUT_RIGHT_BUTTON* = 2 # Mouse button state. + GLUT_DOWN* = 0 + GLUT_UP* = 1 # function keys + GLUT_KEY_F1* = 1 + GLUT_KEY_F2* = 2 + GLUT_KEY_F3* = 3 + GLUT_KEY_F4* = 4 + GLUT_KEY_F5* = 5 + GLUT_KEY_F6* = 6 + GLUT_KEY_F7* = 7 + GLUT_KEY_F8* = 8 + GLUT_KEY_F9* = 9 + GLUT_KEY_F10* = 10 + GLUT_KEY_F11* = 11 + GLUT_KEY_F12* = 12 # directional keys + GLUT_KEY_LEFT* = 100 + GLUT_KEY_UP* = 101 + GLUT_KEY_RIGHT* = 102 + GLUT_KEY_DOWN* = 103 + GLUT_KEY_PAGE_UP* = 104 + GLUT_KEY_PAGE_DOWN* = 105 + GLUT_KEY_HOME* = 106 + GLUT_KEY_END* = 107 + GLUT_KEY_INSERT* = 108 # Entry/exit state. + GLUT_LEFT* = 0 + GLUT_ENTERED* = 1 # Menu usage state. + GLUT_MENU_NOT_IN_USE* = 0 + GLUT_MENU_IN_USE* = 1 # Visibility state. + GLUT_NOT_VISIBLE* = 0 + GLUT_VISIBLE* = 1 # Window status state. + GLUT_HIDDEN* = 0 + GLUT_FULLY_RETAINED* = 1 + GLUT_PARTIALLY_RETAINED* = 2 + GLUT_FULLY_COVERED* = 3 # Color index component selection values. + GLUT_RED* = 0 + GLUT_GREEN* = 1 + GLUT_BLUE* = 2 # Layers for use. + GLUT_NORMAL* = 0 + GLUT_OVERLAY* = 1 + +when defined(Windows): + const # Stroke font constants (use these in GLUT program). + GLUT_STROKE_ROMAN* = cast[pointer](0) + GLUT_STROKE_MONO_ROMAN* = cast[pointer](1) # Bitmap font constants (use these in GLUT program). + GLUT_BITMAP_9_BY_15* = cast[pointer](2) + GLUT_BITMAP_8_BY_13* = cast[pointer](3) + GLUT_BITMAP_TIMES_ROMAN_10* = cast[pointer](4) + GLUT_BITMAP_TIMES_ROMAN_24* = cast[pointer](5) + GLUT_BITMAP_HELVETICA_10* = cast[pointer](6) + GLUT_BITMAP_HELVETICA_12* = cast[pointer](7) + GLUT_BITMAP_HELVETICA_18* = cast[pointer](8) +else: + var # Stroke font constants (use these in GLUT program). + GLUT_STROKE_ROMAN*: pointer + GLUT_STROKE_MONO_ROMAN*: pointer # Bitmap font constants (use these in GLUT program). + GLUT_BITMAP_9_BY_15*: pointer + GLUT_BITMAP_8_BY_13*: pointer + GLUT_BITMAP_TIMES_ROMAN_10*: pointer + GLUT_BITMAP_TIMES_ROMAN_24*: pointer + GLUT_BITMAP_HELVETICA_10*: pointer + GLUT_BITMAP_HELVETICA_12*: pointer + GLUT_BITMAP_HELVETICA_18*: pointer +const # glutGet parameters. + GLUT_WINDOW_X* = 100 + GLUT_WINDOW_Y* = 101 + GLUT_WINDOW_WIDTH* = 102 + GLUT_WINDOW_HEIGHT* = 103 + GLUT_WINDOW_BUFFER_SIZE* = 104 + GLUT_WINDOW_STENCIL_SIZE* = 105 + GLUT_WINDOW_DEPTH_SIZE* = 106 + GLUT_WINDOW_RED_SIZE* = 107 + GLUT_WINDOW_GREEN_SIZE* = 108 + GLUT_WINDOW_BLUE_SIZE* = 109 + GLUT_WINDOW_ALPHA_SIZE* = 110 + GLUT_WINDOW_ACCUM_RED_SIZE* = 111 + GLUT_WINDOW_ACCUM_GREEN_SIZE* = 112 + GLUT_WINDOW_ACCUM_BLUE_SIZE* = 113 + GLUT_WINDOW_ACCUM_ALPHA_SIZE* = 114 + GLUT_WINDOW_DOUBLEBUFFER* = 115 + GLUT_WINDOW_RGBA* = 116 + GLUT_WINDOW_PARENT* = 117 + GLUT_WINDOW_NUM_CHILDREN* = 118 + GLUT_WINDOW_COLORMAP_SIZE* = 119 + GLUT_WINDOW_NUM_SAMPLES* = 120 + GLUT_WINDOW_STEREO* = 121 + GLUT_WINDOW_CURSOR* = 122 + GLUT_SCREEN_WIDTH* = 200 + GLUT_SCREEN_HEIGHT* = 201 + GLUT_SCREEN_WIDTH_MM* = 202 + GLUT_SCREEN_HEIGHT_MM* = 203 + GLUT_MENU_NUM_ITEMS* = 300 + GLUT_DISPLAY_MODE_POSSIBLE* = 400 + GLUT_INIT_WINDOW_X* = 500 + GLUT_INIT_WINDOW_Y* = 501 + GLUT_INIT_WINDOW_WIDTH* = 502 + GLUT_INIT_WINDOW_HEIGHT* = 503 + constGLUT_INIT_DISPLAY_MODE* = 504 + GLUT_ELAPSED_TIME* = 700 + GLUT_WINDOW_FORMAT_ID* = 123 # glutDeviceGet parameters. + GLUT_HAS_KEYBOARD* = 600 + GLUT_HAS_MOUSE* = 601 + GLUT_HAS_SPACEBALL* = 602 + GLUT_HAS_DIAL_AND_BUTTON_BOX* = 603 + GLUT_HAS_TABLET* = 604 + GLUT_NUM_MOUSE_BUTTONS* = 605 + GLUT_NUM_SPACEBALL_BUTTONS* = 606 + GLUT_NUM_BUTTON_BOX_BUTTONS* = 607 + GLUT_NUM_DIALS* = 608 + GLUT_NUM_TABLET_BUTTONS* = 609 + GLUT_DEVICE_IGNORE_KEY_REPEAT* = 610 + GLUT_DEVICE_KEY_REPEAT* = 611 + GLUT_HAS_JOYSTICK* = 612 + GLUT_OWNS_JOYSTICK* = 613 + GLUT_JOYSTICK_BUTTONS* = 614 + GLUT_JOYSTICK_AXES* = 615 + GLUT_JOYSTICK_POLL_RATE* = 616 # glutLayerGet parameters. + GLUT_OVERLAY_POSSIBLE* = 800 + GLUT_LAYER_IN_USE* = 801 + GLUT_HAS_OVERLAY* = 802 + GLUT_TRANSPARENT_INDEX* = 803 + GLUT_NORMAL_DAMAGED* = 804 + GLUT_OVERLAY_DAMAGED* = 805 # glutVideoResizeGet parameters. + GLUT_VIDEO_RESIZE_POSSIBLE* = 900 + GLUT_VIDEO_RESIZE_IN_USE* = 901 + GLUT_VIDEO_RESIZE_X_DELTA* = 902 + GLUT_VIDEO_RESIZE_Y_DELTA* = 903 + GLUT_VIDEO_RESIZE_WIDTH_DELTA* = 904 + GLUT_VIDEO_RESIZE_HEIGHT_DELTA* = 905 + GLUT_VIDEO_RESIZE_X* = 906 + GLUT_VIDEO_RESIZE_Y* = 907 + GLUT_VIDEO_RESIZE_WIDTH* = 908 + GLUT_VIDEO_RESIZE_HEIGHT* = 909 # glutGetModifiers return mask. + GLUT_ACTIVE_SHIFT* = 1 + GLUT_ACTIVE_CTRL* = 2 + GLUT_ACTIVE_ALT* = 4 # glutSetCursor parameters. + # Basic arrows. + GLUT_CURSOR_RIGHT_ARROW* = 0 + GLUT_CURSOR_LEFT_ARROW* = 1 # Symbolic cursor shapes. + GLUT_CURSOR_INFO* = 2 + GLUT_CURSOR_DESTROY* = 3 + GLUT_CURSOR_HELP* = 4 + GLUT_CURSOR_CYCLE* = 5 + GLUT_CURSOR_SPRAY* = 6 + GLUT_CURSOR_WAIT* = 7 + GLUT_CURSOR_TEXT* = 8 + GLUT_CURSOR_CROSSHAIR* = 9 # Directional cursors. + GLUT_CURSOR_UP_DOWN* = 10 + GLUT_CURSOR_LEFT_RIGHT* = 11 # Sizing cursors. + GLUT_CURSOR_TOP_SIDE* = 12 + GLUT_CURSOR_BOTTOM_SIDE* = 13 + GLUT_CURSOR_LEFT_SIDE* = 14 + GLUT_CURSOR_RIGHT_SIDE* = 15 + GLUT_CURSOR_TOP_LEFT_CORNER* = 16 + GLUT_CURSOR_TOP_RIGHT_CORNER* = 17 + GLUT_CURSOR_BOTTOM_RIGHT_CORNER* = 18 + GLUT_CURSOR_BOTTOM_LEFT_CORNER* = 19 # Inherit from parent window. + GLUT_CURSOR_INHERIT* = 100 # Blank cursor. + GLUT_CURSOR_NONE* = 101 # Fullscreen crosshair (if available). + GLUT_CURSOR_FULL_CROSSHAIR* = 102 # GLUT device control sub-API. + # glutSetKeyRepeat modes. + GLUT_KEY_REPEAT_OFF* = 0 + GLUT_KEY_REPEAT_ON* = 1 + GLUT_KEY_REPEAT_DEFAULT* = 2 # Joystick button masks. + GLUT_JOYSTICK_BUTTON_A* = 1 + GLUT_JOYSTICK_BUTTON_B* = 2 + GLUT_JOYSTICK_BUTTON_C* = 4 + GLUT_JOYSTICK_BUTTON_D* = 8 # GLUT game mode sub-API. + # glutGameModeGet. + GLUT_GAME_MODE_ACTIVE* = 0 + GLUT_GAME_MODE_POSSIBLE* = 1 + GLUT_GAME_MODE_WIDTH* = 2 + GLUT_GAME_MODE_HEIGHT* = 3 + GLUT_GAME_MODE_PIXEL_DEPTH* = 4 + GLUT_GAME_MODE_REFRESH_RATE* = 5 + GLUT_GAME_MODE_DISPLAY_CHANGED* = 6 # GLUT initialization sub-API. + +{.push dynlib: dllname, importc.} +proc glutInit*(argcp: ptr cint, argv: pointer) + +proc glutInit*() = + ## version that passes `argc` and `argc` implicitely. + var + cmdLine {.importc: "cmdLine".}: array[0..255, cstring] + cmdCount {.importc: "cmdCount".}: cint + glutInit(addr(cmdCount), addr(cmdLine)) + +proc glutInitDisplayMode*(mode: int16) +proc glutInitDisplayString*(str: cstring) +proc glutInitWindowPosition*(x, y: int) +proc glutInitWindowSize*(width, height: int) +proc glutMainLoop*() + # GLUT window sub-API. +proc glutCreateWindow*(title: cstring): int +proc glutCreateSubWindow*(win, x, y, width, height: int): int +proc glutDestroyWindow*(win: int) +proc glutPostRedisplay*() +proc glutPostWindowRedisplay*(win: int) +proc glutSwapBuffers*() +proc glutSetWindow*(win: int) +proc glutSetWindowTitle*(title: cstring) +proc glutSetIconTitle*(title: cstring) +proc glutPositionWindow*(x, y: int) +proc glutReshapeWindow*(width, height: int) +proc glutPopWindow*() +proc glutPushWindow*() +proc glutIconifyWindow*() +proc glutShowWindow*() +proc glutHideWindow*() +proc glutFullScreen*() +proc glutSetCursor*(cursor: int) +proc glutWarpPointer*(x, y: int) + # GLUT overlay sub-API. +proc glutEstablishOverlay*() +proc glutRemoveOverlay*() +proc glutUseLayer*(layer: GLenum) +proc glutPostOverlayRedisplay*() +proc glutPostWindowOverlayRedisplay*(win: int) +proc glutShowOverlay*() +proc glutHideOverlay*() + # GLUT menu sub-API. +proc glutCreateMenu*(callback: TGlut1IntCallback): int +proc glutDestroyMenu*(menu: int) +proc glutSetMenu*(menu: int) +proc glutAddMenuEntry*(caption: cstring, value: int) +proc glutAddSubMenu*(caption: cstring, submenu: int) +proc glutChangeToMenuEntry*(item: int, caption: cstring, value: int) +proc glutChangeToSubMenu*(item: int, caption: cstring, submenu: int) +proc glutRemoveMenuItem*(item: int) +proc glutAttachMenu*(button: int) +proc glutDetachMenu*(button: int) + # GLUT window callback sub-API. +proc glutDisplayFunc*(f: TGlutVoidCallback) +proc glutReshapeFunc*(f: TGlut2IntCallback) +proc glutKeyboardFunc*(f: TGlut1Char2IntCallback) +proc glutMouseFunc*(f: TGlut4IntCallback) +proc glutMotionFunc*(f: TGlut2IntCallback) +proc glutPassiveMotionFunc*(f: TGlut2IntCallback) +proc glutEntryFunc*(f: TGlut1IntCallback) +proc glutVisibilityFunc*(f: TGlut1IntCallback) +proc glutIdleFunc*(f: TGlutVoidCallback) +proc glutTimerFunc*(millis: int16, f: TGlut1IntCallback, value: int) +proc glutMenuStateFunc*(f: TGlut1IntCallback) +proc glutSpecialFunc*(f: TGlut3IntCallback) +proc glutSpaceballMotionFunc*(f: TGlut3IntCallback) +proc glutSpaceballRotateFunc*(f: TGlut3IntCallback) +proc glutSpaceballButtonFunc*(f: TGlut2IntCallback) +proc glutButtonBoxFunc*(f: TGlut2IntCallback) +proc glutDialsFunc*(f: TGlut2IntCallback) +proc glutTabletMotionFunc*(f: TGlut2IntCallback) +proc glutTabletButtonFunc*(f: TGlut4IntCallback) +proc glutMenuStatusFunc*(f: TGlut3IntCallback) +proc glutOverlayDisplayFunc*(f: TGlutVoidCallback) +proc glutWindowStatusFunc*(f: TGlut1IntCallback) +proc glutKeyboardUpFunc*(f: TGlut1Char2IntCallback) +proc glutSpecialUpFunc*(f: TGlut3IntCallback) +proc glutJoystickFunc*(f: TGlut1UInt3IntCallback, pollInterval: int) + # GLUT color index sub-API. +proc glutSetColor*(cell: int, red, green, blue: GLfloat) +proc glutGetColor*(ndx, component: int): GLfloat +proc glutCopyColormap*(win: int) + # GLUT state retrieval sub-API. + # GLUT extension support sub-API +proc glutExtensionSupported*(name: cstring): int + # GLUT font sub-API +proc glutBitmapCharacter*(font: pointer, character: int) +proc glutBitmapWidth*(font: pointer, character: int): int +proc glutStrokeCharacter*(font: pointer, character: int) +proc glutStrokeWidth*(font: pointer, character: int): int +proc glutBitmapLength*(font: pointer, str: cstring): int +proc glutStrokeLength*(font: pointer, str: cstring): int + # GLUT pre-built models sub-API +proc glutWireSphere*(radius: GLdouble, slices, stacks: GLint) +proc glutSolidSphere*(radius: GLdouble, slices, stacks: GLint) +proc glutWireCone*(base, height: GLdouble, slices, stacks: GLint) +proc glutSolidCone*(base, height: GLdouble, slices, stacks: GLint) +proc glutWireCube*(size: GLdouble) +proc glutSolidCube*(size: GLdouble) +proc glutWireTorus*(innerRadius, outerRadius: GLdouble, sides, rings: GLint) +proc glutSolidTorus*(innerRadius, outerRadius: GLdouble, sides, rings: GLint) +proc glutWireDodecahedron*() +proc glutSolidDodecahedron*() +proc glutWireTeapot*(size: GLdouble) +proc glutSolidTeapot*(size: GLdouble) +proc glutWireOctahedron*() +proc glutSolidOctahedron*() +proc glutWireTetrahedron*() +proc glutSolidTetrahedron*() +proc glutWireIcosahedron*() +proc glutSolidIcosahedron*() + # GLUT video resize sub-API. +proc glutVideoResizeGet*(param: GLenum): int +proc glutSetupVideoResizing*() +proc glutStopVideoResizing*() +proc glutVideoResize*(x, y, width, height: int) +proc glutVideoPan*(x, y, width, height: int) + # GLUT debugging sub-API. +proc glutReportErrors*() + # GLUT device control sub-API. +proc glutIgnoreKeyRepeat*(ignore: int) +proc glutSetKeyRepeat*(repeatMode: int) +proc glutForceJoystickFunc*() + # GLUT game mode sub-API. + #example glutGameModeString('1280x1024:32@75'); +proc glutGameModeString*(AString: cstring) +proc glutLeaveGameMode*() +proc glutGameModeGet*(mode: GLenum): int +# implementation +{.pop.} # dynlib: dllname, importc diff --git a/tests/deps/opengl-1.1.0/glx.nim b/tests/deps/opengl-1.1.0/glx.nim new file mode 100644 index 000000000..6ad096c7d --- /dev/null +++ b/tests/deps/opengl-1.1.0/glx.nim @@ -0,0 +1,154 @@ +# +# +# Translation of the Mesa GLX headers for FreePascal +# Copyright (C) 1999 Sebastian Guenther +# +# +# Mesa 3-D graphics library +# Version: 3.0 +# Copyright (C) 1995-1998 Brian Paul +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Library General Public +# License as published by the Free Software Foundation; either +# version 2 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Library General Public License for more details. +# +# You should have received a copy of the GNU Library General Public +# License along with this library; if not, write to the Free +# Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +# + +import X, XLib, XUtil, opengl + +{.deadCodeElim: on.} + +when defined(windows): + const + dllname = "GL.dll" +elif defined(macosx): + const + dllname = "/usr/X11R6/lib/libGL.dylib" +else: + const + dllname = "libGL.so" +const + GLX_USE_GL* = 1'i32 + GLX_BUFFER_SIZE* = 2'i32 + GLX_LEVEL* = 3'i32 + GLX_RGBA* = 4'i32 + GLX_DOUBLEBUFFER* = 5'i32 + GLX_STEREO* = 6'i32 + GLX_AUX_BUFFERS* = 7'i32 + GLX_RED_SIZE* = 8'i32 + GLX_GREEN_SIZE* = 9'i32 + GLX_BLUE_SIZE* = 10'i32 + GLX_ALPHA_SIZE* = 11'i32 + GLX_DEPTH_SIZE* = 12'i32 + GLX_STENCIL_SIZE* = 13'i32 + GLX_ACCUM_RED_SIZE* = 14'i32 + GLX_ACCUM_GREEN_SIZE* = 15'i32 + GLX_ACCUM_BLUE_SIZE* = 16'i32 + GLX_ACCUM_ALPHA_SIZE* = 17'i32 # GLX_EXT_visual_info extension + GLX_X_VISUAL_TYPE_EXT* = 0x00000022 + GLX_TRANSPARENT_TYPE_EXT* = 0x00000023 + GLX_TRANSPARENT_INDEX_VALUE_EXT* = 0x00000024 + GLX_TRANSPARENT_RED_VALUE_EXT* = 0x00000025 + GLX_TRANSPARENT_GREEN_VALUE_EXT* = 0x00000026 + GLX_TRANSPARENT_BLUE_VALUE_EXT* = 0x00000027 + GLX_TRANSPARENT_ALPHA_VALUE_EXT* = 0x00000028 # Error codes returned by glXGetConfig: + GLX_BAD_SCREEN* = 1 + GLX_BAD_ATTRIBUTE* = 2 + GLX_NO_EXTENSION* = 3 + GLX_BAD_VISUAL* = 4 + GLX_BAD_CONTEXT* = 5 + GLX_BAD_VALUE* = 6 + GLX_BAD_ENUM* = 7 # GLX 1.1 and later: + GLX_VENDOR* = 1 + GLX_VERSION* = 2 + GLX_EXTENSIONS* = 3 # GLX_visual_info extension + GLX_TRUE_COLOR_EXT* = 0x00008002 + GLX_DIRECT_COLOR_EXT* = 0x00008003 + GLX_PSEUDO_COLOR_EXT* = 0x00008004 + GLX_STATIC_COLOR_EXT* = 0x00008005 + GLX_GRAY_SCALE_EXT* = 0x00008006 + GLX_STATIC_GRAY_EXT* = 0x00008007 + GLX_NONE_EXT* = 0x00008000 + GLX_TRANSPARENT_RGB_EXT* = 0x00008008 + GLX_TRANSPARENT_INDEX_EXT* = 0x00008009 + +type # From XLib: + XPixmap* = TXID + XFont* = TXID + XColormap* = TXID + GLXContext* = pointer + GLXPixmap* = TXID + GLXDrawable* = TXID + GLXContextID* = TXID + TXPixmap* = XPixmap + TXFont* = XFont + TXColormap* = XColormap + TGLXContext* = GLXContext + TGLXPixmap* = GLXPixmap + TGLXDrawable* = GLXDrawable + TGLXContextID* = GLXContextID + +proc glXChooseVisual*(dpy: PDisplay, screen: int, attribList: ptr int32): PXVisualInfo{. + cdecl, dynlib: dllname, importc: "glXChooseVisual".} +proc glXCreateContext*(dpy: PDisplay, vis: PXVisualInfo, shareList: GLXContext, + direct: bool): GLXContext{.cdecl, dynlib: dllname, + importc: "glXCreateContext".} +proc glXDestroyContext*(dpy: PDisplay, ctx: GLXContext){.cdecl, dynlib: dllname, + importc: "glXDestroyContext".} +proc glXMakeCurrent*(dpy: PDisplay, drawable: GLXDrawable, ctx: GLXContext): bool{. + cdecl, dynlib: dllname, importc: "glXMakeCurrent".} +proc glXCopyContext*(dpy: PDisplay, src, dst: GLXContext, mask: int32){.cdecl, + dynlib: dllname, importc: "glXCopyContext".} +proc glXSwapBuffers*(dpy: PDisplay, drawable: GLXDrawable){.cdecl, + dynlib: dllname, importc: "glXSwapBuffers".} +proc glXCreateGLXPixmap*(dpy: PDisplay, visual: PXVisualInfo, pixmap: XPixmap): GLXPixmap{. + cdecl, dynlib: dllname, importc: "glXCreateGLXPixmap".} +proc glXDestroyGLXPixmap*(dpy: PDisplay, pixmap: GLXPixmap){.cdecl, + dynlib: dllname, importc: "glXDestroyGLXPixmap".} +proc glXQueryExtension*(dpy: PDisplay, errorb, event: var int): bool{.cdecl, + dynlib: dllname, importc: "glXQueryExtension".} +proc glXQueryVersion*(dpy: PDisplay, maj, min: var int): bool{.cdecl, + dynlib: dllname, importc: "glXQueryVersion".} +proc glXIsDirect*(dpy: PDisplay, ctx: GLXContext): bool{.cdecl, dynlib: dllname, + importc: "glXIsDirect".} +proc glXGetConfig*(dpy: PDisplay, visual: PXVisualInfo, attrib: int, + value: var int): int{.cdecl, dynlib: dllname, + importc: "glXGetConfig".} +proc glXGetCurrentContext*(): GLXContext{.cdecl, dynlib: dllname, + importc: "glXGetCurrentContext".} +proc glXGetCurrentDrawable*(): GLXDrawable{.cdecl, dynlib: dllname, + importc: "glXGetCurrentDrawable".} +proc glXWaitGL*(){.cdecl, dynlib: dllname, importc: "glXWaitGL".} +proc glXWaitX*(){.cdecl, dynlib: dllname, importc: "glXWaitX".} +proc glXUseXFont*(font: XFont, first, count, list: int){.cdecl, dynlib: dllname, + importc: "glXUseXFont".} + # GLX 1.1 and later +proc glXQueryExtensionsString*(dpy: PDisplay, screen: int): cstring{.cdecl, + dynlib: dllname, importc: "glXQueryExtensionsString".} +proc glXQueryServerString*(dpy: PDisplay, screen, name: int): cstring{.cdecl, + dynlib: dllname, importc: "glXQueryServerString".} +proc glXGetClientString*(dpy: PDisplay, name: int): cstring{.cdecl, + dynlib: dllname, importc: "glXGetClientString".} + # Mesa GLX Extensions +proc glXCreateGLXPixmapMESA*(dpy: PDisplay, visual: PXVisualInfo, + pixmap: XPixmap, cmap: XColormap): GLXPixmap{. + cdecl, dynlib: dllname, importc: "glXCreateGLXPixmapMESA".} +proc glXReleaseBufferMESA*(dpy: PDisplay, d: GLXDrawable): bool{.cdecl, + dynlib: dllname, importc: "glXReleaseBufferMESA".} +proc glXCopySubBufferMESA*(dpy: PDisplay, drawbale: GLXDrawable, + x, y, width, height: int){.cdecl, dynlib: dllname, + importc: "glXCopySubBufferMESA".} +proc glXGetVideoSyncSGI*(counter: var int32): int{.cdecl, dynlib: dllname, + importc: "glXGetVideoSyncSGI".} +proc glXWaitVideoSyncSGI*(divisor, remainder: int, count: var int32): int{. + cdecl, dynlib: dllname, importc: "glXWaitVideoSyncSGI".} +# implementation diff --git a/tests/deps/opengl-1.1.0/opengl.nim b/tests/deps/opengl-1.1.0/opengl.nim new file mode 100644 index 000000000..bea0c58ca --- /dev/null +++ b/tests/deps/opengl-1.1.0/opengl.nim @@ -0,0 +1,8481 @@ + +# +# +# Nimrod's Runtime Library +# (c) Copyright 2012 Andreas Rumpf +# +# See the file "copying.txt", included in this +# distribution, for details about the copyright. +# + +## This module is a wrapper around `opengl`:idx:. If you define the symbol +## ``useGlew`` this wrapper does not use Nimrod's ``dynlib`` mechanism, +## but `glew`:idx: instead. However, this shouldn't be necessary anymore; even +## extension loading for the different operating systems is handled here. +## +## You need to call ``loadExtensions`` after a rendering context has been +## created to load any extension proc that your code uses. + +{.deadCodeElim: on.} + +import macros, sequtils + +{.push warning[User]: off.} + +when defined(linux) and not defined(android) and not defined(emscripten): + import X, XLib, XUtil +elif defined(windows): + import winlean, os + +when defined(windows): + const + ogldll* = "OpenGL32.dll" + gludll* = "GLU32.dll" +elif defined(macosx): + #macosx has this notion of a framework, thus the path to the openGL dylib files + #is absolute + const + ogldll* = "/System/Library/Frameworks/OpenGL.framework/Versions/Current/Libraries/libGL.dylib" + gludll* = "/System/Library/Frameworks/OpenGL.framework/Versions/Current/Libraries/libGLU.dylib" +else: + const + ogldll* = "libGL.so.1" + gludll* = "libGLU.so.1" + +when defined(useGlew): + {.pragma: ogl, header: "<GL/glew.h>".} + {.pragma: oglx, header: "<GL/glxew.h>".} + {.pragma: wgl, header: "<GL/wglew.h>".} + {.pragma: glu, dynlib: gludll.} +elif defined(ios): + {.pragma: ogl.} + {.pragma: oglx.} + {.passC: "-framework OpenGLES", passL: "-framework OpenGLES".} +elif defined(android) or defined(js) or defined(emscripten): + {.pragma: ogl.} + {.pragma: oglx.} +else: + # quite complex ... thanks to extension support for various platforms: + import dynlib + + let oglHandle = loadLib(ogldll) + if isNil(oglHandle): quit("could not load: " & ogldll) + + when defined(windows): + var wglGetProcAddress = cast[proc (s: cstring): pointer {.stdcall.}]( + symAddr(oglHandle, "wglGetProcAddress")) + elif defined(linux): + var glxGetProcAddress = cast[proc (s: cstring): pointer {.cdecl.}]( + symAddr(oglHandle, "glxGetProcAddress")) + var glxGetProcAddressArb = cast[proc (s: cstring): pointer {.cdecl.}]( + symAddr(oglHandle, "glxGetProcAddressARB")) + + proc glGetProc(h: LibHandle; procName: cstring): pointer = + when defined(windows): + result = symAddr(h, procname) + if result != nil: return + if not isNil(wglGetProcAddress): result = wglGetProcAddress(procName) + elif defined(linux): + if not isNil(glxGetProcAddress): result = glxGetProcAddress(procName) + if result != nil: return + if not isNil(glxGetProcAddressArb): + result = glxGetProcAddressArb(procName) + if result != nil: return + result = symAddr(h, procname) + else: + result = symAddr(h, procName) + if result == nil: raiseInvalidLibrary(procName) + + var gluHandle: LibHandle + + proc gluGetProc(procname: cstring): pointer = + if gluHandle == nil: + gluHandle = loadLib(gludll) + if gluHandle == nil: quit("could not load: " & gludll) + result = glGetProc(gluHandle, procname) + + # undocumented 'dynlib' feature: the string literal is replaced by + # the imported proc name: + {.pragma: ogl, dynlib: glGetProc(oglHandle, "0").} + {.pragma: oglx, dynlib: glGetProc(oglHandle, "0").} + {.pragma: wgl, dynlib: glGetProc(oglHandle, "0").} + {.pragma: glu, dynlib: gluGetProc("").} + + proc nimLoadProcs0() {.importc.} + + template loadExtensions*() = + ## call this after your rendering context has been setup if you use + ## extensions. + bind nimLoadProcs0 + nimLoadProcs0() + +{.pop.} # warning[User]: off + +type + GLenum* = distinct uint32 + GLboolean* = bool + GLbitfield* = distinct uint32 + GLvoid* = pointer + GLbyte* = int8 + GLshort* = int64 + GLint* = int32 + GLclampx* = int32 + GLubyte* = uint8 + GLushort* = uint16 + GLuint* = uint32 + GLhandle* = GLuint + GLsizei* = int32 + GLfloat* = float32 + GLclampf* = float32 + GLdouble* = float64 + GLclampd* = float64 + GLeglImageOES* = distinct pointer + GLchar* = char + GLcharArb* = char + GLfixed* = int32 + GLhalfNv* = uint16 + GLvdpauSurfaceNv* = uint + GLintptr* = int + GLintptrArb* = int + GLint64EXT* = int64 + GLuint64EXT* = uint64 + GLint64* = int64 + GLsizeiptrArb* = int + GLsizeiptr* = int + GLsync* = distinct pointer + GLuint64* = uint64 + GLvectorub2* = array[0..1, GLubyte] + GLvectori2* = array[0..1, GLint] + GLvectorf2* = array[0..1, GLfloat] + GLvectord2* = array[0..1, GLdouble] + GLvectorp2* = array[0..1, pointer] + GLvectorb3* = array[0..2, GLbyte] + GLvectorub3* = array[0..2, GLubyte] + GLvectori3* = array[0..2, GLint] + GLvectorui3* = array[0..2, GLuint] + GLvectorf3* = array[0..2, GLfloat] + GLvectord3* = array[0..2, GLdouble] + GLvectorp3* = array[0..2, pointer] + GLvectors3* = array[0..2, GLshort] + GLvectorus3* = array[0..2, GLushort] + GLvectorb4* = array[0..3, GLbyte] + GLvectorub4* = array[0..3, GLubyte] + GLvectori4* = array[0..3, GLint] + GLvectorui4* = array[0..3, GLuint] + GLvectorf4* = array[0..3, GLfloat] + GLvectord4* = array[0..3, GLdouble] + GLvectorp4* = array[0..3, pointer] + GLvectors4* = array[0..3, GLshort] + GLvectorus4* = array[0..3, GLshort] + GLarray4f* = GLvectorf4 + GLarrayf3* = GLvectorf3 + GLarrayd3* = GLvectord3 + GLarrayi4* = GLvectori4 + GLarrayp4* = GLvectorp4 + GLmatrixub3* = array[0..2, array[0..2, GLubyte]] + GLmatrixi3* = array[0..2, array[0..2, GLint]] + GLmatrixf3* = array[0..2, array[0..2, GLfloat]] + GLmatrixd3* = array[0..2, array[0..2, GLdouble]] + GLmatrixub4* = array[0..3, array[0..3, GLubyte]] + GLmatrixi4* = array[0..3, array[0..3, GLint]] + GLmatrixf4* = array[0..3, array[0..3, GLfloat]] + GLmatrixd4* = array[0..3, array[0..3, GLdouble]] + ClContext* = distinct pointer + ClEvent* = distinct pointer + GLdebugProc* = proc ( + source: GLenum, + typ: GLenum, + id: GLuint, + severity: GLenum, + length: GLsizei, + message: ptr GLchar, + userParam: pointer) {.stdcall.} + GLdebugProcArb* = proc ( + source: GLenum, + typ: GLenum, + id: GLuint, + severity: GLenum, + len: GLsizei, + message: ptr GLchar, + userParam: pointer) {.stdcall.} + GLdebugProcAmd* = proc ( + id: GLuint, + category: GLenum, + severity: GLenum, + len: GLsizei, + message: ptr GLchar, + userParam: pointer) {.stdcall.} + GLdebugProcKhr* = proc ( + source, typ: GLenum, + id: GLuint, + severity: GLenum, + length: GLsizei, + message: ptr GLchar, + userParam: pointer) {.stdcall.} +type + GLerrorCode* {.size: GLenum.sizeof.} = enum # XXX: can't be evaluated when + # in the same type section as + # GLenum. + glErrNoError = (0, "no error") + glErrInvalidEnum = (0x0500, "invalid enum") + glErrInvalidValue = (0x0501, "invalid value") + glErrInvalidOperation = (0x0502, "invalid operation") + glErrStackOverflow = (0x0503, "stack overflow") + glErrStackUnderflow = (0x0504, "stack underflow") + glErrOutOfMem = (0x0505, "out of memory") + glErrInvalidFramebufferOperation = (0x0506, "invalid framebuffer operation") + glErrTableTooLarge = (0x8031, "table too large") + +const AllErrorCodes = { + glErrNoError, + glErrInvalidEnum, + glErrInvalidValue, + glErrInvalidOperation, + glErrStackOverflow, + glErrStackUnderflow, + glErrOutOfMem, + glErrInvalidFramebufferOperation, + glErrTableTooLarge, +} + +when defined(macosx): + type + GLhandleArb = pointer +else: + type + GLhandleArb = uint32 + +{.deprecated: [ + TGLerror: GLerrorCode, + TGLhandleARB: GLhandleArb, + TGLenum: GLenum, + TGLboolean: GLboolean, + TGLbitfield: GLbitfield, + TGLvoid: GLvoid, + TGLbyte: GLbyte, + TGLshort: GLshort, + TGLint: GLint, + TGLclampx: GLclampx, + TGLubyte: GLubyte, + TGLushort: GLushort, + TGLuint: GLuint, + TGLsizei: GLsizei, + TGLfloat: GLfloat, + TGLclampf: GLclampf, + TGLdouble: GLdouble, + TGLclampd: GLclampd, + TGLeglImageOES: GLeglImageOES, + TGLchar: GLchar, + TGLcharARB: GLcharArb, + TGLfixed: GLfixed, + TGLhalfNV: GLhalfNv, + TGLvdpauSurfaceNv: GLvdpauSurfaceNv, + TGLintptr: GLintptr, + TGLintptrARB: GLintptrArb, + TGLint64EXT: GLint64Ext, + TGLuint64EXT: GLuint64Ext, + TGLint64: GLint64, + TGLsizeiptrARB: GLsizeiptrArb, + TGLsizeiptr: GLsizeiptr, + TGLsync: GLsync, + TGLuint64: GLuint64, + TCL_context: ClContext, + TCL_event: ClEvent, + TGLdebugProc: GLdebugProc, + TGLDebugProcARB: GLdebugProcArb, + TGLDebugProcAMD: GLdebugProcAmd, + TGLDebugProcKHR: GLdebugProcKhr, + TGLVectorub2: GLvectorub2, + TGLVectori2: GLvectori2, + TGLVectorf2: GLvectorf2, + TGLVectord2: GLvectord2, + TGLVectorp2: GLvectorp2, + TGLVectorb3: GLvectorb3, + TGLVectorub3: GLvectorub3, + TGLVectori3: GLvectori3, + TGLVectorui3: GLvectorui3, + TGLVectorf3: GLvectorf3, + TGLVectord3: GLvectord3, + TGLVectorp3: GLvectorp3, + TGLVectors3: GLvectors3, + TGLVectorus3: GLvectorus3, + TGLVectorb4: GLvectorb4, + TGLVectorub4: GLvectorub4, + TGLVectori4: GLvectori4, + TGLVectorui4: GLvectorui4, + TGLVectorf4: GLvectorf4, + TGLVectord4: GLvectord4, + TGLVectorp4: GLvectorp4, + TGLVectors4: GLvectors4, + TGLVectorus4: GLvectorus4, + TGLArrayf4: GLarray4f, + TGLArrayf3: GLarrayf3, + TGLArrayd3: GLarrayd3, + TGLArrayi4: GLarrayi4, + TGLArrayp4: GLarrayp4, + TGLMatrixub3: GLmatrixub3, + TGLMatrixi3: GLmatrixi3, + TGLMatrixf3: GLmatrixf3, + TGLMatrixd3: GLmatrixd3, + TGLMatrixub4: GLmatrixub4, + TGLMatrixi4: GLmatrixi4, + TGLMatrixf4: GLmatrixf4, + TGLMatrixd4: GLmatrixd4, + TGLVector3d: GLvectord3, + TGLVector4i: GLvectori4, + TGLVector4f: GLvectorf4, + TGLVector4p: GLvectorp4, + TGLMatrix4f: GLmatrixf4, + TGLMatrix4d: GLmatrixd4, +].} + +proc `==`*(a, b: GLenum): bool {.borrow.} + +proc `==`*(a, b: GLbitfield): bool {.borrow.} + +proc `or`*(a, b: GLbitfield): GLbitfield {.borrow.} + +proc hash*(x: GLenum): int = + result = x.int + +proc glGetError*: GLenum {.stdcall, importc, ogl.} +proc getGLerrorCode*: GLerrorCode = glGetError().GLerrorCode + ## Like ``glGetError`` but returns an enumerator instead. + +type + GLerror* = object of Exception + ## An exception for OpenGL errors. + code*: GLerrorCode ## The error code. This might be invalid for two reasons: + ## an outdated list of errors or a bad driver. + +proc checkGLerror* = + ## Raise ``GLerror`` if the last call to an OpenGL function generated an error. + ## You might want to call this once every frame for example if automatic + ## error checking has been disabled. + let error = getGLerrorCode() + if error == glErrNoError: + return + + var + exc = new(GLerror) + for e in AllErrorCodes: + if e == error: + exc.msg = "OpenGL error: " & $e + raise exc + + exc.code = error + exc.msg = "OpenGL error: unknown (" & $error & ")" + raise exc + +{.push warning[User]: off.} + +const + NoAutoGLerrorCheck* = defined(noAutoGLerrorCheck) ##\ + ## This determines (at compile time) whether an exception should be raised + ## if an OpenGL call generates an error. No additional code will be generated + ## and ``enableAutoGLerrorCheck(bool)`` will have no effect when + ## ``noAutoGLerrorCheck`` is defined. + +{.pop.} # warning[User]: off + +var + gAutoGLerrorCheck = true + gInsideBeginEnd* = false # do not change manually. + +proc enableAutoGLerrorCheck*(yes: bool) = + ## This determines (at run time) whether an exception should be raised if an + ## OpenGL call generates an error. This has no effect when + ## ``noAutoGLerrorCheck`` is defined. + gAutoGLerrorCheck = yes + +macro wrapErrorChecking(f: stmt): stmt {.immediate.} = + f.expectKind nnkStmtList + result = newStmtList() + + for child in f.children: + if child.kind == nnkCommentStmt: + continue + child.expectKind nnkProcDef + + let params = toSeq(child.params.children) + var glProc = copy child + glProc.pragma = newNimNode(nnkPragma).add( + newNimNode(nnkExprColonExpr).add( + ident"importc" , newLit($child.name)) + ).add(ident"ogl") + + let rawGLprocName = $glProc.name + glProc.name = ident(rawGLprocName & "Impl") + var + body = newStmtList glProc + returnsSomething = child.params[0].kind != nnkEmpty + callParams = newSeq[when defined(nimnode): NimNode else: PNimrodNode]() + for param in params[1 .. <params.len]: + callParams.add param[0] + + let glCall = newCall(glProc.name, callParams) + body.add if returnsSomething: + newAssignment(ident"result", glCall) + else: + glCall + + if rawGLprocName == "glBegin": + body.add newAssignment(ident"gInsideBeginEnd", ident"true") + if rawGLprocName == "glEnd": + body.add newAssignment(ident"gInsideBeginEnd", ident"false") + + template errCheck: stmt = + when not (NoAutoGLerrorCheck): + if gAutoGLerrorCheck and not gInsideBeginEnd: + checkGLerror() + + body.add getAst(errCheck()) + + var procc = newProc(child.name, params, body) + procc.pragma = newNimNode(nnkPragma).add(ident"inline") + procc.name = postfix(procc.name, "*") + result.add procc + +{.push stdcall, hint[XDeclaredButNotUsed]: off, warning[SmallLshouldNotBeUsed]: off.} +wrapErrorChecking: + proc glMultiTexCoord2d(target: GLenum, s: GLdouble, t: GLdouble) {.importc.} + proc glDrawElementsIndirect(mode: GLenum, `type`: GLenum, indirect: pointer) {.importc.} + proc glEnableVertexArrayEXT(vaobj: GLuint, `array`: GLenum) {.importc.} + proc glDeleteFramebuffers(n: GLsizei, framebuffers: ptr GLuint) {.importc.} + proc glMultiTexCoord3dv(target: GLenum, v: ptr GLdouble) {.importc.} + proc glVertexAttrib4d(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glLoadPaletteFromModelViewMatrixOES() {.importc.} + proc glVertex3xvOES(coords: ptr GLfixed) {.importc.} + proc glNormalStream3sATI(stream: GLenum, nx: GLshort, ny: GLshort, nz: GLshort) {.importc.} + proc glMatrixFrustumEXT(mode: GLenum, left: GLdouble, right: GLdouble, bottom: GLdouble, top: GLdouble, zNear: GLdouble, zFar: GLdouble) {.importc.} + proc glUniformMatrix2fvARB(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glColor4dv(v: ptr GLdouble) {.importc.} + proc glColor3fv(v: ptr GLfloat) {.importc.} + proc glVertexAttribI1uiEXT(index: GLuint, x: GLuint) {.importc.} + proc glGetDebugMessageLogKHR(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: cstring): GLuint {.importc.} + proc glVertexAttribI2iv(index: GLuint, v: ptr GLint) {.importc.} + proc glTexCoord1xvOES(coords: ptr GLfixed) {.importc.} + proc glVertex3hNV(x: GLhalfNv, y: GLhalfNv, z: GLhalfNv) {.importc.} + proc glIsShader(shader: GLuint): GLboolean {.importc.} + proc glDeleteRenderbuffersEXT(n: GLsizei, renderbuffers: ptr GLuint) {.importc.} + proc glVertex3hvNV(v: ptr GLhalfNv) {.importc.} + proc glGetPointervKHR(pname: GLenum, params: ptr pointer) {.importc.} + proc glProgramUniform3i64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint64Ext) {.importc.} + proc glNamedFramebufferTexture1DEXT(framebuffer: GLuint, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glGetNamedProgramLocalParameterfvEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} + proc glGenRenderbuffersOES(n: GLsizei, renderbuffers: ptr GLuint) {.importc.} + proc glVertex4dv(v: ptr GLdouble) {.importc.} + proc glTexCoord2fColor4ubVertex3fvSUN(tc: ptr GLfloat, c: ptr GLubyte, v: ptr GLfloat) {.importc.} + proc glTexStorage2DEXT(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glVertexAttrib2d(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} + proc glVertexAttrib1dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glBindProgramARB(target: GLenum, program: GLuint) {.importc.} + proc glRasterPos2dv(v: ptr GLdouble) {.importc.} + proc glCompressedTextureSubImage2DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} + proc glNormalPointervINTEL(`type`: GLenum, `pointer`: ptr pointer) {.importc.} + proc glGetInteger64vAPPLE(pname: GLenum, params: ptr GLint64) {.importc.} + proc glPushMatrix() {.importc.} + proc glGetCompressedTexImageARB(target: GLenum, level: GLint, img: pointer) {.importc.} + proc glBindMaterialParameterEXT(face: GLenum, value: GLenum): GLuint {.importc.} + proc glBlendEquationIndexedAMD(buf: GLuint, mode: GLenum) {.importc.} + proc glGetObjectBufferfvATI(buffer: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glMakeNamedBufferNonResidentNV(buffer: GLuint) {.importc.} + proc glUniform2ui64NV(location: GLint, x: GLuint64Ext, y: GLuint64Ext) {.importc.} + proc glRasterPos4fv(v: ptr GLfloat) {.importc.} + proc glDeleteTextures(n: GLsizei, textures: ptr GLuint) {.importc.} + proc glSecondaryColorPointer(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glTextureSubImage1DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glEndTilingQCOM(preserveMask: GLbitfield) {.importc.} + proc glBindBuffer(target: GLenum, buffer: GLuint) {.importc.} + proc glUniformMatrix3fvARB(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glSamplerParameterf(sampler: GLuint, pname: GLenum, param: GLfloat) {.importc.} + proc glSecondaryColor3d(red: GLdouble, green: GLdouble, blue: GLdouble) {.importc.} + proc glVertexAttrib4sARB(index: GLuint, x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} + proc glNamedProgramLocalParameterI4iEXT(program: GLuint, target: GLenum, index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glProgramUniform2iEXT(program: GLuint, location: GLint, v0: GLint, v1: GLint) {.importc.} + proc glPopAttrib() {.importc.} + proc glGetnColorTableARB(target: GLenum, format: GLenum, `type`: GLenum, bufSize: GLsizei, table: pointer) {.importc.} + proc glMatrixLoadIdentityEXT(mode: GLenum) {.importc.} + proc glGetNamedProgramivEXT(program: GLuint, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glCopyTextureSubImage2DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glUniform4i64NV(location: GLint, x: GLint64Ext, y: GLint64Ext, z: GLint64Ext, w: GLint64Ext) {.importc.} + proc glDeleteTexturesEXT(n: GLsizei, textures: ptr GLuint) {.importc.} + proc glMultiTexCoord1dv(target: GLenum, v: ptr GLdouble) {.importc.} + proc glMultiTexRenderbufferEXT(texunit: GLenum, target: GLenum, renderbuffer: GLuint) {.importc.} + proc glMultiDrawArraysIndirect(mode: GLenum, indirect: ptr pointer, drawcount: GLsizei, stride: GLsizei) {.importc.} + proc glGetUniformfvARB(programObj: GLhandleArb, location: GLint, params: ptr GLfloat) {.importc.} + proc glBufferDataARB(target: GLenum, size: GLsizeiptrArb, data: pointer, usage: GLenum) {.importc.} + proc glTexCoord2d(s: GLdouble, t: GLdouble) {.importc.} + proc glGetArrayObjectfvATI(`array`: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glShaderOp1EXT(op: GLenum, res: GLuint, arg1: GLuint) {.importc.} + proc glColor3s(red: GLshort, green: GLshort, blue: GLshort) {.importc.} + proc glStencilFuncSeparate(face: GLenum, fun: GLenum, `ref`: GLint, mask: GLuint) {.importc.} + proc glTextureImage2DMultisampleCoverageNV(texture: GLuint, target: GLenum, coverageSamples: GLsizei, colorSamples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, fixedSampleLocations: GLboolean) {.importc.} + proc glMultiTexCoord2xvOES(texture: GLenum, coords: ptr GLfixed) {.importc.} + proc glGetVertexAttribLui64vNV(index: GLuint, pname: GLenum, params: ptr GLuint64Ext) {.importc.} + proc glNormal3xOES(nx: GLfixed, ny: GLfixed, nz: GLfixed) {.importc.} + proc glMapBufferRangeEXT(target: GLenum, offset: GLintptr, length: GLsizeiptr, access: GLbitfield): pointer {.importc.} + proc glCreateShader(`type`: GLenum): GLuint {.importc.} + proc glDrawRangeElementArrayAPPLE(mode: GLenum, start: GLuint, `end`: GLuint, first: GLint, count: GLsizei) {.importc.} + proc glVertex2bOES(x: GLbyte) {.importc.} + proc glGetMapxvOES(target: GLenum, query: GLenum, v: ptr GLfixed) {.importc.} + proc glRasterPos3sv(v: ptr GLshort) {.importc.} + proc glDeleteQueriesARB(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glProgramUniform1iv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glVertexStream2dvATI(stream: GLenum, coords: ptr GLdouble) {.importc.} + proc glBindVertexArrayOES(`array`: GLuint) {.importc.} + proc glLightModelfv(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glEvalCoord2dv(u: ptr GLdouble) {.importc.} + proc glColor3hNV(red: GLhalfNv, green: GLhalfNv, blue: GLhalfNv) {.importc.} + proc glSecondaryColor3iEXT(red: GLint, green: GLint, blue: GLint) {.importc.} + proc glBindTexture(target: GLenum, texture: GLuint) {.importc.} + proc glUniformBufferEXT(program: GLuint, location: GLint, buffer: GLuint) {.importc.} + proc glGetCombinerInputParameterfvNV(stage: GLenum, portion: GLenum, variable: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glUniform2ui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64Ext) {.importc.} + proc glMatrixMultTransposefEXT(mode: GLenum, m: ptr GLfloat) {.importc.} + proc glLineWidth(width: GLfloat) {.importc.} + proc glRotatef(angle: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glNormalStream3svATI(stream: GLenum, coords: ptr GLshort) {.importc.} + proc glTexCoordP4ui(`type`: GLenum, coords: GLuint) {.importc.} + proc glImageTransformParameterfvHP(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glUniform3uiEXT(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint) {.importc.} + proc glGetInvariantIntegervEXT(id: GLuint, value: GLenum, data: ptr GLint) {.importc.} + proc glGetTransformFeedbackVaryingEXT(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: cstring) {.importc.} + proc glSamplerParameterIuiv(sampler: GLuint, pname: GLenum, param: ptr GLuint) {.importc.} + proc glProgramUniform2fEXT(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat) {.importc.} + proc glMultiTexCoord2hvNV(target: GLenum, v: ptr GLhalfNv) {.importc.} + proc glDeleteRenderbuffersOES(n: GLsizei, renderbuffers: ptr GLuint) {.importc.} + proc glRenderbufferStorageMultisampleCoverageNV(target: GLenum, coverageSamples: GLsizei, colorSamples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glStencilClearTagEXT(stencilTagBits: GLsizei, stencilClearTag: GLuint) {.importc.} + proc glConvolutionParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glFenceSyncAPPLE(condition: GLenum, flags: GLbitfield): GLsync {.importc.} + proc glGetVariantArrayObjectivATI(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramUniform4dvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glPushDebugGroupKHR(source: GLenum, id: GLuint, length: GLsizei, message: cstring) {.importc.} + proc glFragmentLightivSGIX(light: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glFramebufferTexture2DEXT(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glGetActiveSubroutineUniformiv(program: GLuint, shadertype: GLenum, index: GLuint, pname: GLenum, values: ptr GLint) {.importc.} + proc glFrustumf(l: GLfloat, r: GLfloat, b: GLfloat, t: GLfloat, n: GLfloat, f: GLfloat) {.importc.} + proc glEndQueryIndexed(target: GLenum, index: GLuint) {.importc.} + proc glCompressedTextureSubImage3DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} + proc glGetProgramPipelineInfoLogEXT(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} + proc glGetVertexAttribfvNV(index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexArrayIndexOffsetEXT(vaobj: GLuint, buffer: GLuint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glDrawTexsvOES(coords: ptr GLshort) {.importc.} + proc glMultiTexCoord1hNV(target: GLenum, s: GLhalfNv) {.importc.} + proc glWindowPos2iv(v: ptr GLint) {.importc.} + proc glMultiTexCoordP1ui(texture: GLenum, `type`: GLenum, coords: GLuint) {.importc.} + proc glTexCoord1i(s: GLint) {.importc.} + proc glVertex4hvNV(v: ptr GLhalfNv) {.importc.} + proc glCallLists(n: GLsizei, `type`: GLenum, lists: pointer) {.importc.} + proc glIndexFormatNV(`type`: GLenum, stride: GLsizei) {.importc.} + proc glPointParameterfARB(pname: GLenum, param: GLfloat) {.importc.} + proc glProgramUniform1dv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glGetVertexAttribArrayObjectfvATI(index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVDPAUUnmapSurfacesNV(numSurface: GLsizei, surfaces: ptr GLvdpauSurfaceNv) {.importc.} + proc glVertexAttribIFormat(attribindex: GLuint, size: GLint, `type`: GLenum, relativeoffset: GLuint) {.importc.} + proc glClearColorx(red: GLfixed, green: GLfixed, blue: GLfixed, alpha: GLfixed) {.importc.} + proc glColor3bv(v: ptr GLbyte) {.importc.} + proc glNamedProgramLocalParameter4dEXT(program: GLuint, target: GLenum, index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glVertexPointer(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glGetObjectLabelKHR(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} + proc glCombinerStageParameterfvNV(stage: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glNormal3hvNV(v: ptr GLhalfNv) {.importc.} + proc glUniform2i64NV(location: GLint, x: GLint64Ext, y: GLint64Ext) {.importc.} + proc glMultiTexCoord2iv(target: GLenum, v: ptr GLint) {.importc.} + proc glProgramUniform3i(program: GLuint, location: GLint, v0: GLint, v1: GLint, v2: GLint) {.importc.} + proc glDeleteAsyncMarkersSGIX(marker: GLuint, range: GLsizei) {.importc.} + proc glStencilOp(fail: GLenum, zfail: GLenum, zpass: GLenum) {.importc.} + proc glColorP4ui(`type`: GLenum, color: GLuint) {.importc.} + proc glFinishAsyncSGIX(markerp: ptr GLuint): GLint {.importc.} + proc glDrawTexsOES(x: GLshort, y: GLshort, z: GLshort, width: GLshort, height: GLshort) {.importc.} + proc glLineStipple(factor: GLint, pattern: GLushort) {.importc.} + proc glAlphaFragmentOp1ATI(op: GLenum, dst: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint) {.importc.} + proc glMapTexture2DINTEL(texture: GLuint, level: GLint, access: GLbitfield, stride: ptr GLint, layout: ptr GLenum): pointer {.importc.} + proc glVertex4f(x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glFramebufferTextureARB(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glProgramUniform3ui64NV(program: GLuint, location: GLint, x: GLuint64Ext, y: GLuint64Ext, z: GLuint64Ext) {.importc.} + proc glMultTransposeMatrixxOES(m: ptr GLfixed) {.importc.} + proc glNormal3fv(v: ptr GLfloat) {.importc.} + proc glUniform4fARB(location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat, v3: GLfloat) {.importc.} + proc glBinormal3bEXT(bx: GLbyte, by: GLbyte, bz: GLbyte) {.importc.} + proc glGenProgramPipelinesEXT(n: GLsizei, pipelines: ptr GLuint) {.importc.} + proc glDispatchComputeIndirect(indirect: GLintptr) {.importc.} + proc glGetPerfMonitorCounterDataAMD(monitor: GLuint, pname: GLenum, dataSize: GLsizei, data: ptr GLuint, bytesWritten: ptr GLint) {.importc.} + proc glStencilOpValueAMD(face: GLenum, value: GLuint) {.importc.} + proc glTangent3fvEXT(v: ptr GLfloat) {.importc.} + proc glUniform3iARB(location: GLint, v0: GLint, v1: GLint, v2: GLint) {.importc.} + proc glMatrixScalefEXT(mode: GLenum, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glVertexAttrib2dARB(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} + proc glIsVertexArray(`array`: GLuint): GLboolean {.importc.} + proc glGetMaterialx(face: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glMultiTexCoord1dARB(target: GLenum, s: GLdouble) {.importc.} + proc glColor3usv(v: ptr GLushort) {.importc.} + proc glVertexStream3svATI(stream: GLenum, coords: ptr GLshort) {.importc.} + proc glRasterPos3s(x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glMultiTexCoord2bOES(texture: GLenum, s: GLbyte, t: GLbyte) {.importc.} + proc glGetClipPlanefOES(plane: GLenum, equation: ptr GLfloat) {.importc.} + proc glFramebufferTextureEXT(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glVertexAttrib1dNV(index: GLuint, x: GLdouble) {.importc.} + proc glSampleCoverageOES(value: GLfixed, invert: GLboolean) {.importc.} + proc glCompressedTexSubImage2DARB(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, data: pointer) {.importc.} + proc glUniform1iv(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glExtGetProgramsQCOM(programs: ptr GLuint, maxPrograms: GLint, numPrograms: ptr GLint) {.importc.} + proc glFogx(pname: GLenum, param: GLfixed) {.importc.} + proc glMultiTexCoord3hNV(target: GLenum, s: GLhalfNv, t: GLhalfNv, r: GLhalfNv) {.importc.} + proc glClipPlane(plane: GLenum, equation: ptr GLdouble) {.importc.} + proc glConvolutionParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glInvalidateBufferData(buffer: GLuint) {.importc.} + proc glCheckNamedFramebufferStatusEXT(framebuffer: GLuint, target: GLenum): GLenum {.importc.} + proc glLinkProgram(program: GLuint) {.importc.} + proc glCheckFramebufferStatus(target: GLenum): GLenum {.importc.} + proc glBlendFunci(buf: GLuint, src: GLenum, dst: GLenum) {.importc.} + proc glProgramUniform4uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glConvolutionFilter2D(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, image: pointer) {.importc.} + proc glVertex4bvOES(coords: ptr GLbyte) {.importc.} + proc glCopyTextureSubImage1DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glColor4uiv(v: ptr GLuint) {.importc.} + proc glGetBufferParameteri64v(target: GLenum, pname: GLenum, params: ptr GLint64) {.importc.} + proc glGetLocalConstantBooleanvEXT(id: GLuint, value: GLenum, data: ptr GLboolean) {.importc.} + proc glCoverStrokePathNV(path: GLuint, coverMode: GLenum) {.importc.} + proc glScaled(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glLightfv(light: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexParameterIiv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMakeImageHandleResidentNV(handle: GLuint64, access: GLenum) {.importc.} + proc glWindowPos3iARB(x: GLint, y: GLint, z: GLint) {.importc.} + proc glListBase(base: GLuint) {.importc.} + proc glFlushMappedBufferRangeEXT(target: GLenum, offset: GLintptr, length: GLsizeiptr) {.importc.} + proc glNormal3dv(v: ptr GLdouble) {.importc.} + proc glProgramUniform4d(program: GLuint, location: GLint, v0: GLdouble, v1: GLdouble, v2: GLdouble, v3: GLdouble) {.importc.} + proc glCreateShaderProgramEXT(`type`: GLenum, string: cstring): GLuint {.importc.} + proc glGetLightxvOES(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glGetObjectPtrLabelKHR(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} + proc glTransformPathNV(resultPath: GLuint, srcPath: GLuint, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} + proc glMultTransposeMatrixf(m: ptr GLfloat) {.importc.} + proc glMapVertexAttrib2dAPPLE(index: GLuint, size: GLuint, u1: GLdouble, u2: GLdouble, ustride: GLint, uorder: GLint, v1: GLdouble, v2: GLdouble, vstride: GLint, vorder: GLint, points: ptr GLdouble) {.importc.} + proc glIsSync(sync: GLsync): GLboolean {.importc.} + proc glMultMatrixx(m: ptr GLfixed) {.importc.} + proc glInterpolatePathsNV(resultPath: GLuint, pathA: GLuint, pathB: GLuint, weight: GLfloat) {.importc.} + proc glEnableClientStateIndexedEXT(`array`: GLenum, index: GLuint) {.importc.} + proc glProgramEnvParameter4fARB(target: GLenum, index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glVertexAttrib2svARB(index: GLuint, v: ptr GLshort) {.importc.} + proc glLighti(light: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glSelectBuffer(size: GLsizei, buffer: ptr GLuint) {.importc.} + proc glReplacementCodeusvSUN(code: ptr GLushort) {.importc.} + proc glMapVertexAttrib1fAPPLE(index: GLuint, size: GLuint, u1: GLfloat, u2: GLfloat, stride: GLint, order: GLint, points: ptr GLfloat) {.importc.} + proc glMaterialx(face: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glDrawTransformFeedback(mode: GLenum, id: GLuint) {.importc.} + proc glWindowPos2i(x: GLint, y: GLint) {.importc.} + proc glMultiTexEnviEXT(texunit: GLenum, target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glProgramUniform1fv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glDrawBuffersARB(n: GLsizei, bufs: ptr GLenum) {.importc.} + proc glGetUniformLocationARB(programObj: GLhandleArb, name: cstring): GLint {.importc.} + proc glResumeTransformFeedback() {.importc.} + proc glMap1f(target: GLenum, u1: GLfloat, u2: GLfloat, stride: GLint, order: GLint, points: ptr GLfloat) {.importc.} + proc glVertex3xOES(x: GLfixed, y: GLfixed) {.importc.} + proc glPathCoordsNV(path: GLuint, numCoords: GLsizei, coordType: GLenum, coords: pointer) {.importc.} + proc glListParameterfSGIX(list: GLuint, pname: GLenum, param: GLfloat) {.importc.} + proc glGetUniformivARB(programObj: GLhandleArb, location: GLint, params: ptr GLint) {.importc.} + proc glBinormal3bvEXT(v: ptr GLbyte) {.importc.} + proc glVertexAttribP3ui(index: GLuint, `type`: GLenum, normalized: GLboolean, value: GLuint) {.importc.} + proc glGetVertexArrayPointeri_vEXT(vaobj: GLuint, index: GLuint, pname: GLenum, param: ptr pointer) {.importc.} + proc glProgramParameter4fvNV(target: GLenum, index: GLuint, v: ptr GLfloat) {.importc.} + proc glDiscardFramebufferEXT(target: GLenum, numAttachments: GLsizei, attachments: ptr GLenum) {.importc.} + proc glGetDebugMessageLogARB(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: cstring): GLuint {.importc.} + proc glResolveMultisampleFramebufferAPPLE() {.importc.} + proc glGetIntegeri_vEXT(target: GLenum, index: GLuint, data: ptr GLint) {.importc.} + proc glDepthBoundsdNV(zmin: GLdouble, zmax: GLdouble) {.importc.} + proc glEnd() {.importc.} + proc glBindBufferBaseEXT(target: GLenum, index: GLuint, buffer: GLuint) {.importc.} + proc glVertexAttribDivisor(index: GLuint, divisor: GLuint) {.importc.} + proc glFogCoorddEXT(coord: GLdouble) {.importc.} + proc glFrontFace(mode: GLenum) {.importc.} + proc glVertexAttrib1hNV(index: GLuint, x: GLhalfNv) {.importc.} + proc glNamedProgramLocalParametersI4uivEXT(program: GLuint, target: GLenum, index: GLuint, count: GLsizei, params: ptr GLuint) {.importc.} + proc glTexCoord1dv(v: ptr GLdouble) {.importc.} + proc glBindVideoCaptureStreamTextureNV(video_capture_slot: GLuint, stream: GLuint, frame_region: GLenum, target: GLenum, texture: GLuint) {.importc.} + proc glWindowPos2iARB(x: GLint, y: GLint) {.importc.} + proc glVertexAttribFormatNV(index: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, stride: GLsizei) {.importc.} + proc glUniform1uivEXT(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glGetVideoivNV(video_slot: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttrib3fvARB(index: GLuint, v: ptr GLfloat) {.importc.} + proc glVertexArraySecondaryColorOffsetEXT(vaobj: GLuint, buffer: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glSecondaryColor3bv(v: ptr GLbyte) {.importc.} + proc glDispatchComputeGroupSizeARB(num_groups_x: GLuint, num_groups_y: GLuint, num_groups_z: GLuint, group_size_x: GLuint, group_size_y: GLuint, group_size_z: GLuint) {.importc.} + proc glNamedCopyBufferSubDataEXT(readBuffer: GLuint, writeBuffer: GLuint, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr) {.importc.} + proc glSampleCoverage(value: GLfloat, invert: GLboolean) {.importc.} + proc glGetnMapfvARB(target: GLenum, query: GLenum, bufSize: GLsizei, v: ptr GLfloat) {.importc.} + proc glVertexStream2svATI(stream: GLenum, coords: ptr GLshort) {.importc.} + proc glProgramParameters4fvNV(target: GLenum, index: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} + proc glVertexAttrib4fARB(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glIndexd(c: GLdouble) {.importc.} + proc glGetInteger64v(pname: GLenum, params: ptr GLint64) {.importc.} + proc glGetMultiTexImageEXT(texunit: GLenum, target: GLenum, level: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glLightModelx(pname: GLenum, param: GLfixed) {.importc.} + proc glMap2f(target: GLenum, u1: GLfloat, u2: GLfloat, ustride: GLint, uorder: GLint, v1: GLfloat, v2: GLfloat, vstride: GLint, vorder: GLint, points: ptr GLfloat) {.importc.} + proc glSecondaryColorPointerListIBM(size: GLint, `type`: GLenum, stride: GLint, `pointer`: ptr pointer, ptrstride: GLint) {.importc.} + proc glVertexArrayVertexAttribIOffsetEXT(vaobj: GLuint, buffer: GLuint, index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glProgramUniformHandleui64vARB(program: GLuint, location: GLint, count: GLsizei, values: ptr GLuint64) {.importc.} + proc glActiveProgramEXT(program: GLuint) {.importc.} + proc glProgramUniformMatrix4x3fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glCompressedTexSubImage3DARB(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, data: pointer) {.importc.} + proc glBindProgramPipelineEXT(pipeline: GLuint) {.importc.} + proc glDetailTexFuncSGIS(target: GLenum, n: GLsizei, points: ptr GLfloat) {.importc.} + proc glSecondaryColor3ubEXT(red: GLubyte, green: GLubyte, blue: GLubyte) {.importc.} + proc glDrawArraysInstanced(mode: GLenum, first: GLint, count: GLsizei, instancecount: GLsizei) {.importc.} + proc glWindowPos3fARB(x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glNamedProgramLocalParameter4fEXT(program: GLuint, target: GLenum, index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glTextureParameterfvEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glProgramUniformHandleui64ARB(program: GLuint, location: GLint, value: GLuint64) {.importc.} + proc glHistogramEXT(target: GLenum, width: GLsizei, internalformat: GLenum, sink: GLboolean) {.importc.} + proc glResumeTransformFeedbackNV() {.importc.} + proc glGetMaterialxv(face: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glMultiTexCoord1sv(target: GLenum, v: ptr GLshort) {.importc.} + proc glReadInstrumentsSGIX(marker: GLint) {.importc.} + proc glTexCoord4hNV(s: GLhalfNv, t: GLhalfNv, r: GLhalfNv, q: GLhalfNv) {.importc.} + proc glVertexAttribL4i64vNV(index: GLuint, v: ptr GLint64Ext) {.importc.} + proc glEnableVariantClientStateEXT(id: GLuint) {.importc.} + proc glSyncTextureINTEL(texture: GLuint) {.importc.} + proc glGetObjectPtrLabel(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} + proc glCopyTexSubImage1D(target: GLenum, level: GLint, xoffset: GLint, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glOrthofOES(l: GLfloat, r: GLfloat, b: GLfloat, t: GLfloat, n: GLfloat, f: GLfloat) {.importc.} + proc glWindowPos3sARB(x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glIsBufferARB(buffer: GLuint): GLboolean {.importc.} + proc glColor3sv(v: ptr GLshort) {.importc.} + proc glEvalMesh1(mode: GLenum, i1: GLint, i2: GLint) {.importc.} + proc glMultiDrawArrays(mode: GLenum, first: ptr GLint, count: ptr GLsizei, drawcount: GLsizei) {.importc.} + proc glGetMultiTexEnvfvEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glWindowPos3fMESA(x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glExtGetFramebuffersQCOM(framebuffers: ptr GLuint, maxFramebuffers: GLint, numFramebuffers: ptr GLint) {.importc.} + proc glTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glVertexAttrib4uiv(index: GLuint, v: ptr GLuint) {.importc.} + proc glProgramUniformui64NV(program: GLuint, location: GLint, value: GLuint64Ext) {.importc.} + proc glMultiTexCoord2ivARB(target: GLenum, v: ptr GLint) {.importc.} + proc glProgramUniform4i64NV(program: GLuint, location: GLint, x: GLint64Ext, y: GLint64Ext, z: GLint64Ext, w: GLint64Ext) {.importc.} + proc glWindowPos2svMESA(v: ptr GLshort) {.importc.} + proc glVertexAttrib3dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glColor4i(red: GLint, green: GLint, blue: GLint, alpha: GLint) {.importc.} + proc glClampColor(target: GLenum, clamp: GLenum) {.importc.} + proc glVertexP2ui(`type`: GLenum, value: GLuint) {.importc.} + proc glGenQueries(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glBindBufferOffsetNV(target: GLenum, index: GLuint, buffer: GLuint, offset: GLintptr) {.importc.} + proc glGetFragDataLocation(program: GLuint, name: cstring): GLint {.importc.} + proc glVertexAttribs2svNV(index: GLuint, count: GLsizei, v: ptr GLshort) {.importc.} + proc glGetPathLengthNV(path: GLuint, startSegment: GLsizei, numSegments: GLsizei): GLfloat {.importc.} + proc glVertexAttrib3dARB(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glMultiTexGenfvEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glFlushPixelDataRangeNV(target: GLenum) {.importc.} + proc glReplacementCodeuiNormal3fVertex3fSUN(rc: GLuint, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glPathParameteriNV(path: GLuint, pname: GLenum, value: GLint) {.importc.} + proc glVertexAttribI2iEXT(index: GLuint, x: GLint, y: GLint) {.importc.} + proc glPixelStorei(pname: GLenum, param: GLint) {.importc.} + proc glGetNamedFramebufferParameterivEXT(framebuffer: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetTexEnvxv(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glPathStringNV(path: GLuint, format: GLenum, length: GLsizei, pathString: pointer) {.importc.} + proc glDepthMask(flag: GLboolean) {.importc.} + proc glCopyTexImage1D(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, border: GLint) {.importc.} + proc glDepthRangexOES(n: GLfixed, f: GLfixed) {.importc.} + proc glUniform2i64vNV(location: GLint, count: GLsizei, value: ptr GLint64Ext) {.importc.} + proc glSetFragmentShaderConstantATI(dst: GLuint, value: ptr GLfloat) {.importc.} + proc glAttachShader(program: GLuint, shader: GLuint) {.importc.} + proc glGetFramebufferParameterivEXT(framebuffer: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glPointParameteriNV(pname: GLenum, param: GLint) {.importc.} + proc glWindowPos2dMESA(x: GLdouble, y: GLdouble) {.importc.} + proc glGetTextureParameterfvEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexBumpParameterfvATI(pname: GLenum, param: ptr GLfloat) {.importc.} + proc glCompressedTexImage1DARB(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} + proc glGetTexGendv(coord: GLenum, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glGetFragmentMaterialfvSGIX(face: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glBeginConditionalRenderNVX(id: GLuint) {.importc.} + proc glLightModelxOES(pname: GLenum, param: GLfixed) {.importc.} + proc glTexCoord2xOES(s: GLfixed, t: GLfixed) {.importc.} + proc glProgramUniformMatrix2x4fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glRasterPos2xvOES(coords: ptr GLfixed) {.importc.} + proc glGetMapiv(target: GLenum, query: GLenum, v: ptr GLint) {.importc.} + proc glGetImageHandleARB(texture: GLuint, level: GLint, layered: GLboolean, layer: GLint, format: GLenum): GLuint64 {.importc.} + proc glVDPAURegisterVideoSurfaceNV(vdpSurface: pointer, target: GLenum, numTextureNames: GLsizei, textureNames: ptr GLuint): GLvdpauSurfaceNv {.importc.} + proc glVertexAttribL2dEXT(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} + proc glVertexAttrib1dvNV(index: GLuint, v: ptr GLdouble) {.importc.} + proc glPollAsyncSGIX(markerp: ptr GLuint): GLint {.importc.} + proc glCullParameterfvEXT(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glMakeNamedBufferResidentNV(buffer: GLuint, access: GLenum) {.importc.} + proc glPointParameterfSGIS(pname: GLenum, param: GLfloat) {.importc.} + proc glGenLists(range: GLsizei): GLuint {.importc.} + proc glGetTexBumpParameterfvATI(pname: GLenum, param: ptr GLfloat) {.importc.} + proc glCompressedMultiTexSubImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} + proc glFinishFenceNV(fence: GLuint) {.importc.} + proc glPointSize(size: GLfloat) {.importc.} + proc glCompressedTextureImage2DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} + proc glGetUniformui64vNV(program: GLuint, location: GLint, params: ptr GLuint64Ext) {.importc.} + proc glGetMapControlPointsNV(target: GLenum, index: GLuint, `type`: GLenum, ustride: GLsizei, vstride: GLsizei, packed: GLboolean, points: pointer) {.importc.} + proc glGetPathColorGenfvNV(color: GLenum, pname: GLenum, value: ptr GLfloat) {.importc.} + proc glTexCoord2f(s: GLfloat, t: GLfloat) {.importc.} + proc glSampleMaski(index: GLuint, mask: GLbitfield) {.importc.} + proc glReadBufferIndexedEXT(src: GLenum, index: GLint) {.importc.} + proc glCoverFillPathNV(path: GLuint, coverMode: GLenum) {.importc.} + proc glColorTableParameterfvSGI(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glDeleteVertexArraysAPPLE(n: GLsizei, arrays: ptr GLuint) {.importc.} + proc glGetVertexAttribIiv(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glWeightbvARB(size: GLint, weights: ptr GLbyte) {.importc.} + proc glGetNamedBufferPointervEXT(buffer: GLuint, pname: GLenum, params: ptr pointer) {.importc.} + proc glTexCoordPointer(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glColor4fv(v: ptr GLfloat) {.importc.} + proc glGetnUniformfvARB(program: GLuint, location: GLint, bufSize: GLsizei, params: ptr GLfloat) {.importc.} + proc glMaterialxOES(face: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glGetFixedv(pname: GLenum, params: ptr GLfixed) {.importc.} + proc glMaterialf(face: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glVideoCaptureStreamParameterfvNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetDebugMessageLogAMD(count: GLuint, bufsize: GLsizei, categories: ptr GLenum, severities: ptr GLuint, ids: ptr GLuint, lengths: ptr GLsizei, message: cstring): GLuint {.importc.} + proc glProgramUniform2uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glMatrixMultTransposedEXT(mode: GLenum, m: ptr GLdouble) {.importc.} + proc glIsPointInStrokePathNV(path: GLuint, x: GLfloat, y: GLfloat): GLboolean {.importc.} + proc glDisable(cap: GLenum) {.importc.} + proc glCompileShader(shader: GLuint) {.importc.} + proc glLoadTransposeMatrixd(m: ptr GLdouble) {.importc.} + proc glGetMultiTexParameterIuivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glGetHistogram(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, values: pointer) {.importc.} + proc glMultiTexCoord3fvARB(target: GLenum, v: ptr GLfloat) {.importc.} + proc glColor4xvOES(components: ptr GLfixed) {.importc.} + proc glIsBuffer(buffer: GLuint): GLboolean {.importc.} + proc glVertex2dv(v: ptr GLdouble) {.importc.} + proc glNamedProgramLocalParameterI4uivEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} + proc glPixelTexGenParameteriSGIS(pname: GLenum, param: GLint) {.importc.} + proc glBindVertexBuffers(first: GLuint, count: GLsizei, buffers: ptr GLuint, offsets: ptr GLintptr, strides: ptr GLsizei) {.importc.} + proc glUniform1ui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64Ext) {.importc.} + proc glColor4ub(red: GLubyte, green: GLubyte, blue: GLubyte, alpha: GLubyte) {.importc.} + proc glConvolutionParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc: GLuint, r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glVertexAttribI2ui(index: GLuint, x: GLuint, y: GLuint) {.importc.} + proc glDeleteNamesAMD(identifier: GLenum, num: GLuint, names: ptr GLuint) {.importc.} + proc glPixelTransferxOES(pname: GLenum, param: GLfixed) {.importc.} + proc glVertexAttrib4ivARB(index: GLuint, v: ptr GLint) {.importc.} + proc glLightModeli(pname: GLenum, param: GLint) {.importc.} + proc glGetHistogramEXT(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, values: pointer) {.importc.} + proc glWindowPos3svMESA(v: ptr GLshort) {.importc.} + proc glRasterPos3iv(v: ptr GLint) {.importc.} + proc glCopyTextureSubImage3DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glTextureStorage3DMultisampleEXT(texture: GLuint, target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, fixedsamplelocations: GLboolean) {.importc.} + proc glIsNameAMD(identifier: GLenum, name: GLuint): GLboolean {.importc.} + proc glProgramUniformMatrix3fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glGetProgramParameterfvNV(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexStorage3D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei) {.importc.} + proc glMultiTexCoord2xOES(texture: GLenum, s: GLfixed, t: GLfixed) {.importc.} + proc glWindowPos2fARB(x: GLfloat, y: GLfloat) {.importc.} + proc glGetProgramResourceIndex(program: GLuint, programInterface: GLenum, name: cstring): GLuint {.importc.} + proc glProgramUniform2uivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glMakeImageHandleNonResidentNV(handle: GLuint64) {.importc.} + proc glNamedProgramLocalParameter4fvEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} + proc glInvalidateFramebuffer(target: GLenum, numAttachments: GLsizei, attachments: ptr GLenum) {.importc.} + proc glTexStorage3DMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, fixedsamplelocations: GLboolean) {.importc.} + proc glMapVertexAttrib2fAPPLE(index: GLuint, size: GLuint, u1: GLfloat, u2: GLfloat, ustride: GLint, uorder: GLint, v1: GLfloat, v2: GLfloat, vstride: GLint, vorder: GLint, points: ptr GLfloat) {.importc.} + proc glCombinerParameterfNV(pname: GLenum, param: GLfloat) {.importc.} + proc glCopyMultiTexImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint) {.importc.} + proc glBindVertexShaderEXT(id: GLuint) {.importc.} + proc glPathGlyphsNV(firstPathName: GLuint, fontTarget: GLenum, fontName: pointer, fontStyle: GLbitfield, numGlyphs: GLsizei, `type`: GLenum, charcodes: pointer, handleMissingGlyphs: GLenum, pathParameterTemplate: GLuint, emScale: GLfloat) {.importc.} + proc glProgramLocalParametersI4uivNV(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLuint) {.importc.} + proc glMultiTexCoord3hvNV(target: GLenum, v: ptr GLhalfNv) {.importc.} + proc glMultiTexCoordP2uiv(texture: GLenum, `type`: GLenum, coords: ptr GLuint) {.importc.} + proc glDisableVariantClientStateEXT(id: GLuint) {.importc.} + proc glGetTexLevelParameterxvOES(target: GLenum, level: GLint, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glRasterPos2sv(v: ptr GLshort) {.importc.} + proc glWeightPathsNV(resultPath: GLuint, numPaths: GLsizei, paths: ptr GLuint, weights: ptr GLfloat) {.importc.} + proc glDrawBuffersNV(n: GLsizei, bufs: ptr GLenum) {.importc.} + proc glBindBufferARB(target: GLenum, buffer: GLuint) {.importc.} + proc glVariantbvEXT(id: GLuint, `addr`: ptr GLbyte) {.importc.} + proc glColorP3uiv(`type`: GLenum, color: ptr GLuint) {.importc.} + proc glBlendEquationEXT(mode: GLenum) {.importc.} + proc glProgramLocalParameterI4uivNV(target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} + proc glRenderMode(mode: GLenum): GLint {.importc.} + proc glVertexStream4fATI(stream: GLenum, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glGetObjectLabelEXT(`type`: GLenum, `object`: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} + proc glNamedFramebufferTexture3DEXT(framebuffer: GLuint, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, zoffset: GLint) {.importc.} + proc glLoadMatrixf(m: ptr GLfloat) {.importc.} + proc glGetQueryObjectuivEXT(id: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glBindVideoCaptureStreamBufferNV(video_capture_slot: GLuint, stream: GLuint, frame_region: GLenum, offset: GLintPtrArb) {.importc.} + proc glMatrixOrthoEXT(mode: GLenum, left: GLdouble, right: GLdouble, bottom: GLdouble, top: GLdouble, zNear: GLdouble, zFar: GLdouble) {.importc.} + proc glBlendFunc(sfactor: GLenum, dfactor: GLenum) {.importc.} + proc glTexGenxvOES(coord: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glMatrixMode(mode: GLenum) {.importc.} + proc glColorTableParameterivSGI(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetProgramInfoLog(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} + proc glGetSeparableFilter(target: GLenum, format: GLenum, `type`: GLenum, row: pointer, column: pointer, span: pointer) {.importc.} + proc glFogfv(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glDrawTexfvOES(coords: ptr GLfloat) {.importc.} + proc glClipPlanexIMG(p: GLenum, eqn: ptr GLfixed) {.importc.} + proc glResetHistogramEXT(target: GLenum) {.importc.} + proc glMemoryBarrier(barriers: GLbitfield) {.importc.} + proc glGetPixelMapusv(map: GLenum, values: ptr GLushort) {.importc.} + proc glEvalCoord2f(u: GLfloat, v: GLfloat) {.importc.} + proc glUniform4uiv(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glIsProgramARB(program: GLuint): GLboolean {.importc.} + proc glPointParameterfv(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexBuffer(target: GLenum, internalformat: GLenum, buffer: GLuint) {.importc.} + proc glVertexAttrib1s(index: GLuint, x: GLshort) {.importc.} + proc glRenderbufferStorageMultisampleEXT(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glMapNamedBufferEXT(buffer: GLuint, access: GLenum): pointer {.importc.} + proc glDebugMessageCallbackAMD(callback: GLdebugProcAmd, userParam: ptr pointer) {.importc.} + proc glGetTexEnvfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexAttribI3uivEXT(index: GLuint, v: ptr GLuint) {.importc.} + proc glMultiTexEnvfEXT(texunit: GLenum, target: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glGetUniformiv(program: GLuint, location: GLint, params: ptr GLint) {.importc.} + proc glProgramLocalParameters4fvEXT(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLfloat) {.importc.} + proc glStencilStrokePathInstancedNV(numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, reference: GLint, mask: GLuint, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} + proc glBeginConditionalRender(id: GLuint, mode: GLenum) {.importc.} + proc glVertexAttribI3uiEXT(index: GLuint, x: GLuint, y: GLuint, z: GLuint) {.importc.} + proc glVDPAUMapSurfacesNV(numSurfaces: GLsizei, surfaces: ptr GLvdpauSurfaceNv) {.importc.} + proc glGetProgramResourceName(program: GLuint, programInterface: GLenum, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, name: cstring) {.importc.} + proc glMultiTexCoord4f(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} + proc glVertexAttrib2hNV(index: GLuint, x: GLhalfNv, y: GLhalfNv) {.importc.} + proc glDrawArraysInstancedNV(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei) {.importc.} + proc glClearAccum(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat) {.importc.} + proc glVertexAttribI4usv(index: GLuint, v: ptr GLushort) {.importc.} + proc glGetProgramNamedParameterfvNV(id: GLuint, len: GLsizei, name: ptr GLubyte, params: ptr GLfloat) {.importc.} + proc glTextureLightEXT(pname: GLenum) {.importc.} + proc glPathSubCoordsNV(path: GLuint, coordStart: GLsizei, numCoords: GLsizei, coordType: GLenum, coords: pointer) {.importc.} + proc glBindImageTexture(unit: GLuint, texture: GLuint, level: GLint, layered: GLboolean, layer: GLint, access: GLenum, format: GLenum) {.importc.} + proc glGenVertexArraysAPPLE(n: GLsizei, arrays: ptr GLuint) {.importc.} + proc glFogCoordf(coord: GLfloat) {.importc.} + proc glFrameTerminatorGREMEDY() {.importc.} + proc glValidateProgramPipelineEXT(pipeline: GLuint) {.importc.} + proc glScalexOES(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glReplacementCodeuiColor3fVertex3fvSUN(rc: ptr GLuint, c: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glProgramNamedParameter4dNV(id: GLuint, len: GLsizei, name: ptr GLubyte, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glMultiDrawElementsIndirectCountARB(mode: GLenum, `type`: GLenum, indirect: GLintptr, drawcount: GLintptr, maxdrawcount: GLsizei, stride: GLsizei) {.importc.} + proc glReferencePlaneSGIX(equation: ptr GLdouble) {.importc.} + proc glNormalStream3iATI(stream: GLenum, nx: GLint, ny: GLint, nz: GLint) {.importc.} + proc glGetColorTableParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetAttribLocation(program: GLuint, name: cstring): GLint {.importc.} + proc glMultiTexParameterfEXT(texunit: GLenum, target: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glGenFencesNV(n: GLsizei, fences: ptr GLuint) {.importc.} + proc glUniform4dv(location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glGetTexLevelParameterfv(target: GLenum, level: GLint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glProgramUniform1ivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glProgramUniform1dvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glLoadTransposeMatrixdARB(m: ptr GLdouble) {.importc.} + proc glVertexAttrib2fvARB(index: GLuint, v: ptr GLfloat) {.importc.} + proc glMultiTexGendEXT(texunit: GLenum, coord: GLenum, pname: GLenum, param: GLdouble) {.importc.} + proc glProgramUniformMatrix4x3dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glUniform4ui(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint) {.importc.} + proc glTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glVertexAttrib3hNV(index: GLuint, x: GLhalfNv, y: GLhalfNv, z: GLhalfNv) {.importc.} + proc glRotatexOES(angle: GLfixed, x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glGenTextures(n: GLsizei, textures: ptr GLuint) {.importc.} + proc glCheckFramebufferStatusOES(target: GLenum): GLenum {.importc.} + proc glGetVideoCaptureStreamdvNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glCompressedTextureSubImage1DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} + proc glCurrentPaletteMatrixOES(matrixpaletteindex: GLuint) {.importc.} + proc glCompressedMultiTexSubImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} + proc glNormal3d(nx: GLdouble, ny: GLdouble, nz: GLdouble) {.importc.} + proc glMultiTexCoord1fv(target: GLenum, v: ptr GLfloat) {.importc.} + proc glProgramUniform2uiEXT(program: GLuint, location: GLint, v0: GLuint, v1: GLuint) {.importc.} + proc glMultiTexCoord3fARB(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat) {.importc.} + proc glRasterPos3xOES(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glEGLImageTargetRenderbufferStorageOES(target: GLenum, image: GLeglImageOes) {.importc.} + proc glGetAttribLocationARB(programObj: GLhandleArb, name: cstring): GLint {.importc.} + proc glProgramNamedParameter4dvNV(id: GLuint, len: GLsizei, name: ptr GLubyte, v: ptr GLdouble) {.importc.} + proc glProgramLocalParameterI4uiNV(target: GLenum, index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint) {.importc.} + proc glNamedFramebufferTextureFaceEXT(framebuffer: GLuint, attachment: GLenum, texture: GLuint, level: GLint, face: GLenum) {.importc.} + proc glIndexf(c: GLfloat) {.importc.} + proc glExtTexObjectStateOverrideiQCOM(target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glCoverageOperationNV(operation: GLenum) {.importc.} + proc glColorP4uiv(`type`: GLenum, color: ptr GLuint) {.importc.} + proc glDeleteSync(sync: GLsync) {.importc.} + proc glGetHistogramParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexCoord4fColor4fNormal3fVertex4fSUN(s: GLfloat, t: GLfloat, p: GLfloat, q: GLfloat, r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glEndPerfMonitorAMD(monitor: GLuint) {.importc.} + proc glGetInternalformati64v(target: GLenum, internalformat: GLenum, pname: GLenum, bufSize: GLsizei, params: ptr GLint64) {.importc.} + proc glGenNamesAMD(identifier: GLenum, num: GLuint, names: ptr GLuint) {.importc.} + proc glDrawElementsInstancedBaseVertexBaseInstance(mode: GLenum, count: GLsizei, `type`: GLenum, indices: ptr pointer, instancecount: GLsizei, basevertex: GLint, baseinstance: GLuint) {.importc.} + proc glMultiTexCoord4i(target: GLenum, s: GLint, t: GLint, r: GLint, q: GLint) {.importc.} + proc glVertexAttribL1dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glGetProgramNamedParameterdvNV(id: GLuint, len: GLsizei, name: ptr GLubyte, params: ptr GLdouble) {.importc.} + proc glSetLocalConstantEXT(id: GLuint, `type`: GLenum, `addr`: pointer) {.importc.} + proc glProgramBinary(program: GLuint, binaryFormat: GLenum, binary: pointer, length: GLsizei) {.importc.} + proc glVideoCaptureNV(video_capture_slot: GLuint, sequence_num: ptr GLuint, capture_time: ptr GLuint64Ext): GLenum {.importc.} + proc glDebugMessageEnableAMD(category: GLenum, severity: GLenum, count: GLsizei, ids: ptr GLuint, enabled: GLboolean) {.importc.} + proc glVertexAttribI1i(index: GLuint, x: GLint) {.importc.} + proc glVertexWeighthNV(weight: GLhalfNv) {.importc.} + proc glTextureParameterIivEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glClipPlanefIMG(p: GLenum, eqn: ptr GLfloat) {.importc.} + proc glGetLightxv(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glGetAttachedObjectsARB(containerObj: GLhandleArb, maxCount: GLsizei, count: ptr GLsizei, obj: ptr GLhandleArb) {.importc.} + proc glVertexAttrib4fv(index: GLuint, v: ptr GLfloat) {.importc.} + proc glDisableVertexAttribArrayARB(index: GLuint) {.importc.} + proc glWindowPos3fvARB(v: ptr GLfloat) {.importc.} + proc glClearDepthdNV(depth: GLdouble) {.importc.} + proc glMapParameterivNV(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glEndConditionalRenderNVX() {.importc.} + proc glGetFragmentLightivSGIX(light: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramUniformMatrix4fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glVertexStream1iATI(stream: GLenum, x: GLint) {.importc.} + proc glColorP3ui(`type`: GLenum, color: GLuint) {.importc.} + proc glGetLightxOES(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glGetLightiv(light: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexStream3dATI(stream: GLenum, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glProgramUniform1iEXT(program: GLuint, location: GLint, v0: GLint) {.importc.} + proc glSecondaryColorFormatNV(size: GLint, `type`: GLenum, stride: GLsizei) {.importc.} + proc glDrawElementsBaseVertex(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, basevertex: GLint) {.importc.} + proc glGenFencesAPPLE(n: GLsizei, fences: ptr GLuint) {.importc.} + proc glBinormal3svEXT(v: ptr GLshort) {.importc.} + proc glUseProgramStagesEXT(pipeline: GLuint, stages: GLbitfield, program: GLuint) {.importc.} + proc glDebugMessageCallbackKHR(callback: GLdebugProcKhr, userParam: ptr pointer) {.importc.} + proc glCopyMultiTexSubImage3DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glColor4hvNV(v: ptr GLhalfNv) {.importc.} + proc glFenceSync(condition: GLenum, flags: GLbitfield): GLsync {.importc.} + proc glTexCoordPointerListIBM(size: GLint, `type`: GLenum, stride: GLint, `pointer`: ptr pointer, ptrstride: GLint) {.importc.} + proc glPopName() {.importc.} + proc glColor3fVertex3fvSUN(c: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glGetUniformfv(program: GLuint, location: GLint, params: ptr GLfloat) {.importc.} + proc glMultiTexCoord2hNV(target: GLenum, s: GLhalfNv, t: GLhalfNv) {.importc.} + proc glLightxv(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glVideoCaptureStreamParameterivNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glEvalCoord1xvOES(coords: ptr GLfixed) {.importc.} + proc glGetProgramEnvParameterIivNV(target: GLenum, index: GLuint, params: ptr GLint) {.importc.} + proc glObjectPurgeableAPPLE(objectType: GLenum, name: GLuint, option: GLenum): GLenum {.importc.} + proc glRequestResidentProgramsNV(n: GLsizei, programs: ptr GLuint) {.importc.} + proc glIsImageHandleResidentNV(handle: GLuint64): GLboolean {.importc.} + proc glColor3hvNV(v: ptr GLhalfNv) {.importc.} + proc glMultiTexCoord2dARB(target: GLenum, s: GLdouble, t: GLdouble) {.importc.} + proc glDeletePathsNV(path: GLuint, range: GLsizei) {.importc.} + proc glVertexAttrib4Nsv(index: GLuint, v: ptr GLshort) {.importc.} + proc glTexEnvf(target: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glGlobalAlphaFactoriSUN(factor: GLint) {.importc.} + proc glBlendColorEXT(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat) {.importc.} + proc glSecondaryColor3usvEXT(v: ptr GLushort) {.importc.} + proc glProgramEnvParameterI4uiNV(target: GLenum, index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint) {.importc.} + proc glTexImage4DSGIS(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, size4d: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glMatrixPushEXT(mode: GLenum) {.importc.} + proc glGetPixelTexGenParameterivSGIS(pname: GLenum, params: ptr GLint) {.importc.} + proc glVariantuivEXT(id: GLuint, `addr`: ptr GLuint) {.importc.} + proc glTexParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetSubroutineUniformLocation(program: GLuint, shadertype: GLenum, name: cstring): GLint {.importc.} + proc glProgramUniformMatrix3fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glDrawBuffersATI(n: GLsizei, bufs: ptr GLenum) {.importc.} + proc glGetVertexAttribivNV(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glMultiTexCoord4bvOES(texture: GLenum, coords: ptr GLbyte) {.importc.} + proc glCompressedTexSubImage1DARB(target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, imageSize: GLsizei, data: pointer) {.importc.} + proc glClientActiveTexture(texture: GLenum) {.importc.} + proc glVertexAttrib2fARB(index: GLuint, x: GLfloat, y: GLfloat) {.importc.} + proc glProgramUniform2fvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetBufferParameterui64vNV(target: GLenum, pname: GLenum, params: ptr GLuint64Ext) {.importc.} + proc glVertexStream3dvATI(stream: GLenum, coords: ptr GLdouble) {.importc.} + proc glReplacementCodeuiNormal3fVertex3fvSUN(rc: ptr GLuint, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glVertexAttrib4svNV(index: GLuint, v: ptr GLshort) {.importc.} + proc glClearBufferSubData(target: GLenum, internalformat: GLenum, offset: GLintptr, size: GLsizeiptr, format: GLenum, `type`: GLenum, data: ptr pointer) {.importc.} + proc glVertexStream2sATI(stream: GLenum, x: GLshort, y: GLshort) {.importc.} + proc glTextureImage2DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGetListParameterfvSGIX(list: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glUniform3uiv(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glIsTexture(texture: GLuint): GLboolean {.importc.} + proc glObjectUnpurgeableAPPLE(objectType: GLenum, name: GLuint, option: GLenum): GLenum {.importc.} + proc glGetVertexAttribdv(index: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glGetPointeri_vEXT(pname: GLenum, index: GLuint, params: ptr pointer) {.importc.} + proc glSampleCoveragex(value: GLclampx, invert: GLboolean) {.importc.} + proc glColor3f(red: GLfloat, green: GLfloat, blue: GLfloat) {.importc.} + proc glGetnMapivARB(target: GLenum, query: GLenum, bufSize: GLsizei, v: ptr GLint) {.importc.} + proc glMakeTextureHandleResidentARB(handle: GLuint64) {.importc.} + proc glSecondaryColorP3ui(`type`: GLenum, color: GLuint) {.importc.} + proc glMultiTexCoord4sARB(target: GLenum, s: GLshort, t: GLshort, r: GLshort, q: GLshort) {.importc.} + proc glUniform3i64NV(location: GLint, x: GLint64Ext, y: GLint64Ext, z: GLint64Ext) {.importc.} + proc glVDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNv, pname: GLenum, bufSize: GLsizei, length: ptr GLsizei, values: ptr GLint) {.importc.} + proc glTexBufferEXT(target: GLenum, internalformat: GLenum, buffer: GLuint) {.importc.} + proc glVertexAttribI4ubvEXT(index: GLuint, v: ptr GLubyte) {.importc.} + proc glDeleteFramebuffersOES(n: GLsizei, framebuffers: ptr GLuint) {.importc.} + proc glColor3fVertex3fSUN(r: GLfloat, g: GLfloat, b: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glCombinerInputNV(stage: GLenum, portion: GLenum, variable: GLenum, input: GLenum, mapping: GLenum, componentUsage: GLenum) {.importc.} + proc glPolygonOffsetEXT(factor: GLfloat, bias: GLfloat) {.importc.} + proc glWindowPos4dMESA(x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glVertex3f(x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glTexCoord3f(s: GLfloat, t: GLfloat, r: GLfloat) {.importc.} + proc glMultiTexCoord1fARB(target: GLenum, s: GLfloat) {.importc.} + proc glVertexAttrib4f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glGetFragDataLocationEXT(program: GLuint, name: cstring): GLint {.importc.} + proc glFlushMappedNamedBufferRangeEXT(buffer: GLuint, offset: GLintptr, length: GLsizeiptr) {.importc.} + proc glVertexAttrib1sARB(index: GLuint, x: GLshort) {.importc.} + proc glBitmapxOES(width: GLsizei, height: GLsizei, xorig: GLfixed, yorig: GLfixed, xmove: GLfixed, ymove: GLfixed, bitmap: ptr GLubyte) {.importc.} + proc glEnableVertexArrayAttribEXT(vaobj: GLuint, index: GLuint) {.importc.} + proc glDeleteRenderbuffers(n: GLsizei, renderbuffers: ptr GLuint) {.importc.} + proc glFramebufferRenderbuffer(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLuint) {.importc.} + proc glInvalidateTexImage(texture: GLuint, level: GLint) {.importc.} + proc glProgramUniform2i64NV(program: GLuint, location: GLint, x: GLint64Ext, y: GLint64Ext) {.importc.} + proc glTextureImage3DMultisampleNV(texture: GLuint, target: GLenum, samples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, fixedSampleLocations: GLboolean) {.importc.} + proc glValidateProgram(program: GLuint) {.importc.} + proc glUniform1dv(location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glNormalStream3dvATI(stream: GLenum, coords: ptr GLdouble) {.importc.} + proc glMultiDrawElementsIndirect(mode: GLenum, `type`: GLenum, indirect: ptr pointer, drawcount: GLsizei, stride: GLsizei) {.importc.} + proc glVertexBlendARB(count: GLint) {.importc.} + proc glIsSampler(sampler: GLuint): GLboolean {.importc.} + proc glVariantdvEXT(id: GLuint, `addr`: ptr GLdouble) {.importc.} + proc glProgramUniformMatrix3x2fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glVertexStream4fvATI(stream: GLenum, coords: ptr GLfloat) {.importc.} + proc glOrthoxOES(l: GLfixed, r: GLfixed, b: GLfixed, t: GLfixed, n: GLfixed, f: GLfixed) {.importc.} + proc glColorFormatNV(size: GLint, `type`: GLenum, stride: GLsizei) {.importc.} + proc glFogCoordPointer(`type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glVertexAttrib3dvARB(index: GLuint, v: ptr GLdouble) {.importc.} + proc glVertex3bOES(x: GLbyte, y: GLbyte) {.importc.} + proc glVertexAttribFormat(attribindex: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, relativeoffset: GLuint) {.importc.} + proc glTexCoord4fVertex4fSUN(s: GLfloat, t: GLfloat, p: GLfloat, q: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glEnableDriverControlQCOM(driverControl: GLuint) {.importc.} + proc glPointParameteri(pname: GLenum, param: GLint) {.importc.} + proc glVertexAttribI2i(index: GLuint, x: GLint, y: GLint) {.importc.} + proc glGetDriverControlStringQCOM(driverControl: GLuint, bufSize: GLsizei, length: ptr GLsizei, driverControlString: cstring) {.importc.} + proc glGetTexLevelParameteriv(target: GLenum, level: GLint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetHandleARB(pname: GLenum): GLhandleArb {.importc.} + proc glIndexubv(c: ptr GLubyte) {.importc.} + proc glBlendFunciARB(buf: GLuint, src: GLenum, dst: GLenum) {.importc.} + proc glColor4usv(v: ptr GLushort) {.importc.} + proc glBlendEquationSeparateOES(modeRgb: GLenum, modeAlpha: GLenum) {.importc.} + proc glVertexAttribI4ui(index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint) {.importc.} + proc glProgramUniform3f(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat) {.importc.} + proc glVertexAttribL3i64vNV(index: GLuint, v: ptr GLint64Ext) {.importc.} + proc glWeightdvARB(size: GLint, weights: ptr GLdouble) {.importc.} + proc glVertexArrayRangeAPPLE(length: GLsizei, `pointer`: pointer) {.importc.} + proc glMapGrid2d(un: GLint, u1: GLdouble, u2: GLdouble, vn: GLint, v1: GLdouble, v2: GLdouble) {.importc.} + proc glFogiv(pname: GLenum, params: ptr GLint) {.importc.} + proc glUniform2f(location: GLint, v0: GLfloat, v1: GLfloat) {.importc.} + proc glGetDoublei_v(target: GLenum, index: GLuint, data: ptr GLdouble) {.importc.} + proc glGetVertexAttribfv(index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexAttribI2ivEXT(index: GLuint, v: ptr GLint) {.importc.} + proc glIsProgramNV(id: GLuint): GLboolean {.importc.} + proc glTexCoord1hNV(s: GLhalfNv) {.importc.} + proc glMinSampleShadingARB(value: GLfloat) {.importc.} + proc glMultiDrawElements(mode: GLenum, count: ptr GLsizei, `type`: GLenum, indices: ptr pointer, drawcount: GLsizei) {.importc.} + proc glGetQueryObjectuiv(id: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glReadBuffer(mode: GLenum) {.importc.} + proc glMultiTexCoordP3uiv(texture: GLenum, `type`: GLenum, coords: ptr GLuint) {.importc.} + proc glUniformMatrix3x2fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glBindRenderbuffer(target: GLenum, renderbuffer: GLuint) {.importc.} + proc glBinormal3sEXT(bx: GLshort, by: GLshort, bz: GLshort) {.importc.} + proc glUniform4iARB(location: GLint, v0: GLint, v1: GLint, v2: GLint, v3: GLint) {.importc.} + proc glGetUniformOffsetEXT(program: GLuint, location: GLint): GLintptr {.importc.} + proc glDeleteLists(list: GLuint, range: GLsizei) {.importc.} + proc glVertexAttribI1iEXT(index: GLuint, x: GLint) {.importc.} + proc glFramebufferTexture1D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glVertexAttribI2uiv(index: GLuint, v: ptr GLuint) {.importc.} + proc glBindFragDataLocation(program: GLuint, color: GLuint, name: cstring) {.importc.} + proc glClearStencil(s: GLint) {.importc.} + proc glVertexAttrib4Nubv(index: GLuint, v: ptr GLubyte) {.importc.} + proc glConvolutionFilter2DEXT(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, image: pointer) {.importc.} + proc glGenFramebuffersEXT(n: GLsizei, framebuffers: ptr GLuint) {.importc.} + proc glFogCoordfvEXT(coord: ptr GLfloat) {.importc.} + proc glGetRenderbufferParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttribs1fvNV(index: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} + proc glTexCoord2fColor3fVertex3fSUN(s: GLfloat, t: GLfloat, r: GLfloat, g: GLfloat, b: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glRasterPos3i(x: GLint, y: GLint, z: GLint) {.importc.} + proc glMultiTexSubImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glConvolutionParameteriEXT(target: GLenum, pname: GLenum, params: GLint) {.importc.} + proc glVertexAttribI4iEXT(index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glVertexAttribL2i64vNV(index: GLuint, v: ptr GLint64Ext) {.importc.} + proc glBlendColor(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat) {.importc.} + proc glGetPathColorGenivNV(color: GLenum, pname: GLenum, value: ptr GLint) {.importc.} + proc glCompressedTextureImage1DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} + proc glDrawElementsInstanced(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, instancecount: GLsizei) {.importc.} + proc glFogCoordd(coord: GLdouble) {.importc.} + proc glTexParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glWindowPos3svARB(v: ptr GLshort) {.importc.} + proc glGetVertexArrayPointervEXT(vaobj: GLuint, pname: GLenum, param: ptr pointer) {.importc.} + proc glDrawTextureNV(texture: GLuint, sampler: GLuint, x0: GLfloat, y0: GLfloat, x1: GLfloat, y1: GLfloat, z: GLfloat, s0: GLfloat, t0: GLfloat, s1: GLfloat, t1: GLfloat) {.importc.} + proc glUniformMatrix2dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glTexImage3DOES(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glClampColorARB(target: GLenum, clamp: GLenum) {.importc.} + proc glTexParameteri(target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glWindowPos4svMESA(v: ptr GLshort) {.importc.} + proc glMultiTexCoordP4ui(texture: GLenum, `type`: GLenum, coords: GLuint) {.importc.} + proc glVertexP4uiv(`type`: GLenum, value: ptr GLuint) {.importc.} + proc glProgramUniform4iEXT(program: GLuint, location: GLint, v0: GLint, v1: GLint, v2: GLint, v3: GLint) {.importc.} + proc glTexCoord3xvOES(coords: ptr GLfixed) {.importc.} + proc glCopyTexImage2DEXT(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint) {.importc.} + proc glGenSamplers(count: GLsizei, samplers: ptr GLuint) {.importc.} + proc glRasterPos4iv(v: ptr GLint) {.importc.} + proc glWindowPos4sMESA(x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} + proc glProgramUniform2dvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glPrioritizeTexturesEXT(n: GLsizei, textures: ptr GLuint, priorities: ptr GLclampf) {.importc.} + proc glRects(x1: GLshort, y1: GLshort, x2: GLshort, y2: GLshort) {.importc.} + proc glMultiDrawElementsBaseVertex(mode: GLenum, count: ptr GLsizei, `type`: GLenum, indices: ptr pointer, drawcount: GLsizei, basevertex: ptr GLint) {.importc.} + proc glProgramBinaryOES(program: GLuint, binaryFormat: GLenum, binary: pointer, length: GLint) {.importc.} + proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc: ptr GLuint, tc: ptr GLfloat, c: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glGetMinmaxParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glColor4fNormal3fVertex3fSUN(r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glWindowPos2d(x: GLdouble, y: GLdouble) {.importc.} + proc glGetPerfMonitorGroupStringAMD(group: GLuint, bufSize: GLsizei, length: ptr GLsizei, groupString: cstring) {.importc.} + proc glUniformHandleui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64) {.importc.} + proc glBlendEquation(mode: GLenum) {.importc.} + proc glMapBufferARB(target: GLenum, access: GLenum): pointer {.importc.} + proc glGetMaterialxvOES(face: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glVertexAttribI1ivEXT(index: GLuint, v: ptr GLint) {.importc.} + proc glTexCoord4hvNV(v: ptr GLhalfNv) {.importc.} + proc glVertexArrayVertexAttribLOffsetEXT(vaobj: GLuint, buffer: GLuint, index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glExtGetShadersQCOM(shaders: ptr GLuint, maxShaders: GLint, numShaders: ptr GLint) {.importc.} + proc glWindowPos4ivMESA(v: ptr GLint) {.importc.} + proc glVertexAttrib1sNV(index: GLuint, x: GLshort) {.importc.} + proc glNormalStream3ivATI(stream: GLenum, coords: ptr GLint) {.importc.} + proc glSecondaryColor3fEXT(red: GLfloat, green: GLfloat, blue: GLfloat) {.importc.} + proc glVertexArrayFogCoordOffsetEXT(vaobj: GLuint, buffer: GLuint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glGetTextureImageEXT(texture: GLuint, target: GLenum, level: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glVertexAttrib4hNV(index: GLuint, x: GLhalfNv, y: GLhalfNv, z: GLhalfNv, w: GLhalfNv) {.importc.} + proc glReplacementCodeusSUN(code: GLushort) {.importc.} + proc glPixelTexGenSGIX(mode: GLenum) {.importc.} + proc glMultiDrawRangeElementArrayAPPLE(mode: GLenum, start: GLuint, `end`: GLuint, first: ptr GLint, count: ptr GLsizei, primcount: GLsizei) {.importc.} + proc glDrawElements(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer) {.importc.} + proc glTexCoord1hvNV(v: ptr GLhalfNv) {.importc.} + proc glGetPixelMapuiv(map: GLenum, values: ptr GLuint) {.importc.} + proc glRasterPos4d(x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glTexImage1D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glConvolutionParameterxOES(target: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glSecondaryColor3dEXT(red: GLdouble, green: GLdouble, blue: GLdouble) {.importc.} + proc glGetCombinerOutputParameterivNV(stage: GLenum, portion: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glQueryCounter(id: GLuint, target: GLenum) {.importc.} + proc glGetUniformi64vNV(program: GLuint, location: GLint, params: ptr GLint64Ext) {.importc.} + proc glTexCoord2fv(v: ptr GLfloat) {.importc.} + proc glWindowPos3d(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glBlendFuncSeparateINGR(sfactorRgb: GLenum, dfactorRgb: GLenum, sfactorAlpha: GLenum, dfactorAlpha: GLenum) {.importc.} + proc glTextureNormalEXT(mode: GLenum) {.importc.} + proc glVertexStream2fATI(stream: GLenum, x: GLfloat, y: GLfloat) {.importc.} + proc glViewportIndexedf(index: GLuint, x: GLfloat, y: GLfloat, w: GLfloat, h: GLfloat) {.importc.} + proc glMultiTexCoord4ivARB(target: GLenum, v: ptr GLint) {.importc.} + proc glBindBufferOffsetEXT(target: GLenum, index: GLuint, buffer: GLuint, offset: GLintptr) {.importc.} + proc glTexCoord3sv(v: ptr GLshort) {.importc.} + proc glVertexArrayVertexAttribBindingEXT(vaobj: GLuint, attribindex: GLuint, bindingindex: GLuint) {.importc.} + proc glVertexAttrib2f(index: GLuint, x: GLfloat, y: GLfloat) {.importc.} + proc glMultiTexGenivEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glUniformui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64Ext) {.importc.} + proc glGetInfoLogARB(obj: GLhandleArb, maxLength: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} + proc glGetNamedProgramLocalParameterIivEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLint) {.importc.} + proc glVertexAttrib4s(index: GLuint, x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} + proc glUniformMatrix4x2dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glVertexAttribs3dvNV(index: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} + proc glSecondaryColor3dvEXT(v: ptr GLdouble) {.importc.} + proc glTextureRenderbufferEXT(texture: GLuint, target: GLenum, renderbuffer: GLuint) {.importc.} + proc glVertexAttribL2ui64vNV(index: GLuint, v: ptr GLuint64Ext) {.importc.} + proc glBlendFuncSeparateOES(srcRgb: GLenum, dstRgb: GLenum, srcAlpha: GLenum, dstAlpha: GLenum) {.importc.} + proc glVertexAttribDivisorARB(index: GLuint, divisor: GLuint) {.importc.} + proc glWindowPos2sv(v: ptr GLshort) {.importc.} + proc glMultiTexCoord3svARB(target: GLenum, v: ptr GLshort) {.importc.} + proc glCombinerParameterfvNV(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetImageTransformParameterfvHP(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetArrayObjectivATI(`array`: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetTexParameterIuiv(target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glGetProgramPipelineInfoLog(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} + proc glGetOcclusionQueryuivNV(id: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glVertexAttrib4bvARB(index: GLuint, v: ptr GLbyte) {.importc.} + proc glListParameterfvSGIX(list: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glDeleteSamplers(count: GLsizei, samplers: ptr GLuint) {.importc.} + proc glNormalStream3dATI(stream: GLenum, nx: GLdouble, ny: GLdouble, nz: GLdouble) {.importc.} + proc glProgramUniform4i64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint64Ext) {.importc.} + proc glBlendFuncSeparateiARB(buf: GLuint, srcRgb: GLenum, dstRgb: GLenum, srcAlpha: GLenum, dstAlpha: GLenum) {.importc.} + proc glEndTransformFeedbackEXT() {.importc.} + proc glMultiTexCoord3i(target: GLenum, s: GLint, t: GLint, r: GLint) {.importc.} + proc glMakeBufferResidentNV(target: GLenum, access: GLenum) {.importc.} + proc glTangent3dvEXT(v: ptr GLdouble) {.importc.} + proc glMatrixPopEXT(mode: GLenum) {.importc.} + proc glVertexAttrib4NivARB(index: GLuint, v: ptr GLint) {.importc.} + proc glProgramUniform2ui64NV(program: GLuint, location: GLint, x: GLuint64Ext, y: GLuint64Ext) {.importc.} + proc glWeightPointerARB(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glCullParameterdvEXT(pname: GLenum, params: ptr GLdouble) {.importc.} + proc glFramebufferTexture2D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glGenVertexArrays(n: GLsizei, arrays: ptr GLuint) {.importc.} + proc glUniformHandleui64NV(location: GLint, value: GLuint64) {.importc.} + proc glIndexPointer(`type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glGetProgramSubroutineParameteruivNV(target: GLenum, index: GLuint, param: ptr GLuint) {.importc.} + proc glVertexAttrib1svARB(index: GLuint, v: ptr GLshort) {.importc.} + proc glDetachObjectARB(containerObj: GLhandleArb, attachedObj: GLhandleArb) {.importc.} + proc glCompressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} + proc glBlendFuncSeparate(sfactorRgb: GLenum, dfactorRgb: GLenum, sfactorAlpha: GLenum, dfactorAlpha: GLenum) {.importc.} + proc glExecuteProgramNV(target: GLenum, id: GLuint, params: ptr GLfloat) {.importc.} + proc glAttachObjectARB(containerObj: GLhandleArb, obj: GLhandleArb) {.importc.} + proc glCompressedTexSubImage1D(target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, imageSize: GLsizei, data: pointer) {.importc.} + proc glProgramUniform4iv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glVertexAttrib3sv(index: GLuint, v: ptr GLshort) {.importc.} + proc glTexCoord3bvOES(coords: ptr GLbyte) {.importc.} + proc glGenTexturesEXT(n: GLsizei, textures: ptr GLuint) {.importc.} + proc glColor4f(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat) {.importc.} + proc glGetFramebufferAttachmentParameterivOES(target: GLenum, attachment: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glClearColor(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat) {.importc.} + proc glNamedProgramLocalParametersI4ivEXT(program: GLuint, target: GLenum, index: GLuint, count: GLsizei, params: ptr GLint) {.importc.} + proc glMakeImageHandleNonResidentARB(handle: GLuint64) {.importc.} + proc glGenRenderbuffers(n: GLsizei, renderbuffers: ptr GLuint) {.importc.} + proc glVertexAttribL1ui64vARB(index: GLuint, v: ptr GLuint64Ext) {.importc.} + proc glBindFramebufferEXT(target: GLenum, framebuffer: GLuint) {.importc.} + proc glProgramUniform2dEXT(program: GLuint, location: GLint, x: GLdouble, y: GLdouble) {.importc.} + proc glCompressedMultiTexImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} + proc glDeleteSyncAPPLE(sync: GLsync) {.importc.} + proc glDebugMessageInsertAMD(category: GLenum, severity: GLenum, id: GLuint, length: GLsizei, buf: cstring) {.importc.} + proc glSecondaryColorPointerEXT(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glTextureImage2DMultisampleNV(texture: GLuint, target: GLenum, samples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, fixedSampleLocations: GLboolean) {.importc.} + proc glBeginFragmentShaderATI() {.importc.} + proc glClearDepth(depth: GLdouble) {.importc.} + proc glBindTextures(first: GLuint, count: GLsizei, textures: ptr GLuint) {.importc.} + proc glEvalCoord1d(u: GLdouble) {.importc.} + proc glSecondaryColor3b(red: GLbyte, green: GLbyte, blue: GLbyte) {.importc.} + proc glExtGetTexSubImageQCOM(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, texels: pointer) {.importc.} + proc glClearColorIiEXT(red: GLint, green: GLint, blue: GLint, alpha: GLint) {.importc.} + proc glVertex2xOES(x: GLfixed) {.importc.} + proc glVertexAttrib2s(index: GLuint, x: GLshort, y: GLshort) {.importc.} + proc glUniformHandleui64vARB(location: GLint, count: GLsizei, value: ptr GLuint64) {.importc.} + proc glAreTexturesResidentEXT(n: GLsizei, textures: ptr GLuint, residences: ptr GLboolean): GLboolean {.importc.} + proc glDrawElementsInstancedBaseInstance(mode: GLenum, count: GLsizei, `type`: GLenum, indices: ptr pointer, instancecount: GLsizei, baseinstance: GLuint) {.importc.} + proc glGetString(name: GLenum): ptr GLubyte {.importc.} + proc glDrawTransformFeedbackStream(mode: GLenum, id: GLuint, stream: GLuint) {.importc.} + proc glSecondaryColor3uiv(v: ptr GLuint) {.importc.} + proc glNamedFramebufferParameteriEXT(framebuffer: GLuint, pname: GLenum, param: GLint) {.importc.} + proc glVertexAttrib4hvNV(index: GLuint, v: ptr GLhalfNv) {.importc.} + proc glGetnUniformuivARB(program: GLuint, location: GLint, bufSize: GLsizei, params: ptr GLuint) {.importc.} + proc glProgramUniform4ui(program: GLuint, location: GLint, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint) {.importc.} + proc glPointParameterxvOES(pname: GLenum, params: ptr GLfixed) {.importc.} + proc glIsEnabledi(target: GLenum, index: GLuint): GLboolean {.importc.} + proc glColorPointerEXT(size: GLint, `type`: GLenum, stride: GLsizei, count: GLsizei, `pointer`: pointer) {.importc.} + proc glFragmentLightModelfvSGIX(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glRasterPos3f(x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glDeleteObjectARB(obj: GLhandleArb) {.importc.} + proc glSetFenceNV(fence: GLuint, condition: GLenum) {.importc.} + proc glTransformFeedbackAttribsNV(count: GLuint, attribs: ptr GLint, bufferMode: GLenum) {.importc.} + proc glProgramUniformMatrix2fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glGetPointerv(pname: GLenum, params: ptr pointer) {.importc.} + proc glWindowPos2dvMESA(v: ptr GLdouble) {.importc.} + proc glTexImage2DMultisample(target: GLenum, samples: GLsizei, internalformat: GLint, width: GLsizei, height: GLsizei, fixedsamplelocations: GLboolean) {.importc.} + proc glGenFragmentShadersATI(range: GLuint): GLuint {.importc.} + proc glTexCoord4fv(v: ptr GLfloat) {.importc.} + proc glCompressedTexImage1D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} + proc glGetNamedBufferSubDataEXT(buffer: GLuint, offset: GLintptr, size: GLsizeiptr, data: pointer) {.importc.} + proc glFinish() {.importc.} + proc glDeleteVertexShaderEXT(id: GLuint) {.importc.} + proc glFinishObjectAPPLE(`object`: GLenum, name: GLint) {.importc.} + proc glGetActiveAttribARB(programObj: GLhandleArb, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} + proc glPointParameterx(pname: GLenum, param: GLfixed) {.importc.} + proc glProgramUniformui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64Ext) {.importc.} + proc glSecondaryColor3ubv(v: ptr GLubyte) {.importc.} + proc glGetProgramLocalParameterIivNV(target: GLenum, index: GLuint, params: ptr GLint) {.importc.} + proc glDeleteProgramPipelinesEXT(n: GLsizei, pipelines: ptr GLuint) {.importc.} + proc glVertexAttrib4fNV(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glGetColorTableParameterfvSGI(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetFloati_v(target: GLenum, index: GLuint, data: ptr GLfloat) {.importc.} + proc glGenBuffers(n: GLsizei, buffers: ptr GLuint) {.importc.} + proc glNormal3b(nx: GLbyte, ny: GLbyte, nz: GLbyte) {.importc.} + proc glDrawArraysInstancedARB(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei) {.importc.} + proc glTexStorage2DMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, fixedsamplelocations: GLboolean) {.importc.} + proc glGetVariantIntegervEXT(id: GLuint, value: GLenum, data: ptr GLint) {.importc.} + proc glColor3ubv(v: ptr GLubyte) {.importc.} + proc glVertexAttribP4uiv(index: GLuint, `type`: GLenum, normalized: GLboolean, value: ptr GLuint) {.importc.} + proc glProgramUniform2ivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glVertexStream4dATI(stream: GLenum, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glVertexAttribL2ui64NV(index: GLuint, x: GLuint64Ext, y: GLuint64Ext) {.importc.} + proc glSecondaryColor3bEXT(red: GLbyte, green: GLbyte, blue: GLbyte) {.importc.} + proc glGetBufferPointervOES(target: GLenum, pname: GLenum, params: ptr pointer) {.importc.} + proc glGetMaterialfv(face: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexStream3sATI(stream: GLenum, x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glUniform1i(location: GLint, v0: GLint) {.importc.} + proc glVertexAttribL2d(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} + proc glTestObjectAPPLE(`object`: GLenum, name: GLuint): GLboolean {.importc.} + proc glGetTransformFeedbackVarying(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: cstring) {.importc.} + proc glFramebufferRenderbufferOES(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLuint) {.importc.} + proc glVertexStream3iATI(stream: GLenum, x: GLint, y: GLint, z: GLint) {.importc.} + proc glMakeTextureHandleNonResidentNV(handle: GLuint64) {.importc.} + proc glVertexAttrib4fvNV(index: GLuint, v: ptr GLfloat) {.importc.} + proc glArrayElement(i: GLint) {.importc.} + proc glClearBufferData(target: GLenum, internalformat: GLenum, format: GLenum, `type`: GLenum, data: ptr pointer) {.importc.} + proc glSecondaryColor3usEXT(red: GLushort, green: GLushort, blue: GLushort) {.importc.} + proc glRenderbufferStorageMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glTexCoord2xvOES(coords: ptr GLfixed) {.importc.} + proc glWindowPos3f(x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glTangent3svEXT(v: ptr GLshort) {.importc.} + proc glPointParameterf(pname: GLenum, param: GLfloat) {.importc.} + proc glVertexAttribI4uivEXT(index: GLuint, v: ptr GLuint) {.importc.} + proc glColorTableParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMatrixMultdEXT(mode: GLenum, m: ptr GLdouble) {.importc.} + proc glUseProgramStages(pipeline: GLuint, stages: GLbitfield, program: GLuint) {.importc.} + proc glVertexStream4sATI(stream: GLenum, x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} + proc glDrawElementsInstancedNV(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, primcount: GLsizei) {.importc.} + proc glUniform3d(location: GLint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glDebugMessageControlARB(source: GLenum, `type`: GLenum, severity: GLenum, count: GLsizei, ids: ptr GLuint, enabled: GLboolean) {.importc.} + proc glVertexAttribs3svNV(index: GLuint, count: GLsizei, v: ptr GLshort) {.importc.} + proc glElementPointerATI(`type`: GLenum, `pointer`: pointer) {.importc.} + proc glColor4fNormal3fVertex3fvSUN(c: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glGetPerfMonitorCountersAMD(group: GLuint, numCounters: ptr GLint, maxActiveCounters: ptr GLint, counterSize: GLsizei, counters: ptr GLuint) {.importc.} + proc glDispatchCompute(num_groups_x: GLuint, num_groups_y: GLuint, num_groups_z: GLuint) {.importc.} + proc glVertexAttribDivisorNV(index: GLuint, divisor: GLuint) {.importc.} + proc glProgramUniform3uiEXT(program: GLuint, location: GLint, v0: GLuint, v1: GLuint, v2: GLuint) {.importc.} + proc glRenderbufferStorageMultisampleNV(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glBinormalPointerEXT(`type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glRectxvOES(v1: ptr GLfixed, v2: ptr GLfixed) {.importc.} + proc glGenVertexArraysOES(n: GLsizei, arrays: ptr GLuint) {.importc.} + proc glDebugMessageControlKHR(source: GLenum, `type`: GLenum, severity: GLenum, count: GLsizei, ids: ptr GLuint, enabled: GLboolean) {.importc.} + proc glProgramUniform1uiEXT(program: GLuint, location: GLint, v0: GLuint) {.importc.} + proc glPixelTransferi(pname: GLenum, param: GLint) {.importc.} + proc glIsPointInFillPathNV(path: GLuint, mask: GLuint, x: GLfloat, y: GLfloat): GLboolean {.importc.} + proc glVertexBindingDivisor(bindingindex: GLuint, divisor: GLuint) {.importc.} + proc glGetVertexAttribLui64vARB(index: GLuint, pname: GLenum, params: ptr GLuint64Ext) {.importc.} + proc glProgramUniformMatrix3dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glDrawBuffer(mode: GLenum) {.importc.} + proc glMultiTexCoord1sARB(target: GLenum, s: GLshort) {.importc.} + proc glSeparableFilter2DEXT(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, row: pointer, column: pointer) {.importc.} + proc glTangent3bvEXT(v: ptr GLbyte) {.importc.} + proc glTexParameterIuiv(target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glVertexAttribL4i64NV(index: GLuint, x: GLint64Ext, y: GLint64Ext, z: GLint64Ext, w: GLint64Ext) {.importc.} + proc glDebugMessageCallbackARB(callback: GLdebugProcArb, userParam: ptr pointer) {.importc.} + proc glMultiTexCoordP1uiv(texture: GLenum, `type`: GLenum, coords: ptr GLuint) {.importc.} + proc glLabelObjectEXT(`type`: GLenum, `object`: GLuint, length: GLsizei, label: cstring) {.importc.} + proc glGetnPolygonStippleARB(bufSize: GLsizei, pattern: ptr GLubyte) {.importc.} + proc glTexCoord3xOES(s: GLfixed, t: GLfixed, r: GLfixed) {.importc.} + proc glCopyPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, `type`: GLenum) {.importc.} + proc glGetnUniformfvEXT(program: GLuint, location: GLint, bufSize: GLsizei, params: ptr GLfloat) {.importc.} + proc glColorMaski(index: GLuint, r: GLboolean, g: GLboolean, b: GLboolean, a: GLboolean) {.importc.} + proc glRasterPos2fv(v: ptr GLfloat) {.importc.} + proc glBindBuffersBase(target: GLenum, first: GLuint, count: GLsizei, buffers: ptr GLuint) {.importc.} + proc glSpriteParameterfvSGIX(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetSyncivAPPLE(sync: GLsync, pname: GLenum, bufSize: GLsizei, length: ptr GLsizei, values: ptr GLint) {.importc.} + proc glVertexAttribI3i(index: GLuint, x: GLint, y: GLint, z: GLint) {.importc.} + proc glPixelTransformParameteriEXT(target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glMultiDrawArraysEXT(mode: GLenum, first: ptr GLint, count: ptr GLsizei, primcount: GLsizei) {.importc.} + proc glGetTextureHandleNV(texture: GLuint): GLuint64 {.importc.} + proc glTexCoordP2ui(`type`: GLenum, coords: GLuint) {.importc.} + proc glDeleteQueries(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glGetVertexAttribArrayObjectivATI(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexArrayVertexBindingDivisorEXT(vaobj: GLuint, bindingindex: GLuint, divisor: GLuint) {.importc.} + proc glVertex3i(x: GLint, y: GLint, z: GLint) {.importc.} + proc glBlendEquationSeparatei(buf: GLuint, modeRgb: GLenum, modeAlpha: GLenum) {.importc.} + proc glGetMapAttribParameterivNV(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetVideoCaptureivNV(video_capture_slot: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glFragmentMaterialfvSGIX(face: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glEGLImageTargetTexture2DOES(target: GLenum, image: GLeglImageOes) {.importc.} + proc glCopyImageSubDataNV(srcName: GLuint, srcTarget: GLenum, srcLevel: GLint, srcX: GLint, srcY: GLint, srcZ: GLint, dstName: GLuint, dstTarget: GLenum, dstLevel: GLint, dstX: GLint, dstY: GLint, dstZ: GLint, width: GLsizei, height: GLsizei, depth: GLsizei) {.importc.} + proc glUniform2i(location: GLint, v0: GLint, v1: GLint) {.importc.} + proc glVertexAttrib3fvNV(index: GLuint, v: ptr GLfloat) {.importc.} + proc glNamedBufferStorageEXT(buffer: GLuint, size: GLsizeiptr, data: ptr pointer, flags: GLbitfield) {.importc.} + proc glProgramEnvParameterI4uivNV(target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} + proc glGetVertexAttribdvARB(index: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glVertexAttribL3ui64vNV(index: GLuint, v: ptr GLuint64Ext) {.importc.} + proc glUniform4fvARB(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glWeightsvARB(size: GLint, weights: ptr GLshort) {.importc.} + proc glMakeTextureHandleNonResidentARB(handle: GLuint64) {.importc.} + proc glEvalCoord1xOES(u: GLfixed) {.importc.} + proc glVertexAttrib2sv(index: GLuint, v: ptr GLshort) {.importc.} + proc glVertexAttrib4dvNV(index: GLuint, v: ptr GLdouble) {.importc.} + proc glProgramNamedParameter4fNV(id: GLuint, len: GLsizei, name: ptr GLubyte, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glCompileShaderARB(shaderObj: GLhandleArb) {.importc.} + proc glProgramEnvParameter4fvARB(target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} + proc glGetVertexAttribiv(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glEvalPoint1(i: GLint) {.importc.} + proc glEvalMapsNV(target: GLenum, mode: GLenum) {.importc.} + proc glGetTexGenxvOES(coord: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glBlendEquationSeparate(modeRgb: GLenum, modeAlpha: GLenum) {.importc.} + proc glGetColorTableParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glQueryCounterEXT(id: GLuint, target: GLenum) {.importc.} + proc glExtGetProgramBinarySourceQCOM(program: GLuint, shadertype: GLenum, source: cstring, length: ptr GLint) {.importc.} + proc glGetConvolutionParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glIsProgramPipeline(pipeline: GLuint): GLboolean {.importc.} + proc glVertexWeightfvEXT(weight: ptr GLfloat) {.importc.} + proc glDisableDriverControlQCOM(driverControl: GLuint) {.importc.} + proc glVertexStream1fvATI(stream: GLenum, coords: ptr GLfloat) {.importc.} + proc glMakeTextureHandleResidentNV(handle: GLuint64) {.importc.} + proc glSamplerParameteriv(sampler: GLuint, pname: GLenum, param: ptr GLint) {.importc.} + proc glTexEnvxOES(target: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glEndOcclusionQueryNV() {.importc.} + proc glFlushMappedBufferRangeAPPLE(target: GLenum, offset: GLintptr, size: GLsizeiptr) {.importc.} + proc glVertex4iv(v: ptr GLint) {.importc.} + proc glVertexArrayVertexAttribIFormatEXT(vaobj: GLuint, attribindex: GLuint, size: GLint, `type`: GLenum, relativeoffset: GLuint) {.importc.} + proc glDisableIndexedEXT(target: GLenum, index: GLuint) {.importc.} + proc glVertexAttribL1dEXT(index: GLuint, x: GLdouble) {.importc.} + proc glBeginPerfMonitorAMD(monitor: GLuint) {.importc.} + proc glConvolutionFilter1DEXT(target: GLenum, internalformat: GLenum, width: GLsizei, format: GLenum, `type`: GLenum, image: pointer) {.importc.} + proc glPrimitiveRestartIndex(index: GLuint) {.importc.} + proc glWindowPos2dv(v: ptr GLdouble) {.importc.} + proc glBindFramebufferOES(target: GLenum, framebuffer: GLuint) {.importc.} + proc glTessellationModeAMD(mode: GLenum) {.importc.} + proc glIsVariantEnabledEXT(id: GLuint, cap: GLenum): GLboolean {.importc.} + proc glColor3iv(v: ptr GLint) {.importc.} + proc glFogCoordFormatNV(`type`: GLenum, stride: GLsizei) {.importc.} + proc glClearNamedBufferDataEXT(buffer: GLuint, internalformat: GLenum, format: GLenum, `type`: GLenum, data: ptr pointer) {.importc.} + proc glTextureRangeAPPLE(target: GLenum, length: GLsizei, `pointer`: pointer) {.importc.} + proc glTexCoord4bvOES(coords: ptr GLbyte) {.importc.} + proc glRotated(angle: GLdouble, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glAccum(op: GLenum, value: GLfloat) {.importc.} + proc glVertex3d(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glGetPathMetricRangeNV(metricQueryMask: GLbitfield, firstPathName: GLuint, numPaths: GLsizei, stride: GLsizei, metrics: ptr GLfloat) {.importc.} + proc glUniform4d(location: GLint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glTextureSubImage2DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glMultiTexCoord1iv(target: GLenum, v: ptr GLint) {.importc.} + proc glFogFuncSGIS(n: GLsizei, points: ptr GLfloat) {.importc.} + proc glGetMaterialxOES(face: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glGlobalAlphaFactorbSUN(factor: GLbyte) {.importc.} + proc glGetProgramLocalParameterdvARB(target: GLenum, index: GLuint, params: ptr GLdouble) {.importc.} + proc glDeleteProgramsARB(n: GLsizei, programs: ptr GLuint) {.importc.} + proc glVertexStream1sATI(stream: GLenum, x: GLshort) {.importc.} + proc glMatrixTranslatedEXT(mode: GLenum, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glTexSubImage1D(target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGetBufferSubData(target: GLenum, offset: GLintptr, size: GLsizeiptr, data: pointer) {.importc.} + proc glUniform4uiEXT(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint) {.importc.} + proc glGetShaderiv(shader: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetQueryIndexediv(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glDebugMessageInsert(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: cstring) {.importc.} + proc glVertexAttribs2dvNV(index: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} + proc glGetFixedvOES(pname: GLenum, params: ptr GLfixed) {.importc.} + proc glUniform2iv(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glTextureView(texture: GLuint, target: GLenum, origtexture: GLuint, internalformat: GLenum, minlevel: GLuint, numlevels: GLuint, minlayer: GLuint, numlayers: GLuint) {.importc.} + proc glMultiTexCoord1xvOES(texture: GLenum, coords: ptr GLfixed) {.importc.} + proc glTexBufferRange(target: GLenum, internalformat: GLenum, buffer: GLuint, offset: GLintptr, size: GLsizeiptr) {.importc.} + proc glMultiTexCoordPointerEXT(texunit: GLenum, size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glBlendColorxOES(red: GLfixed, green: GLfixed, blue: GLfixed, alpha: GLfixed) {.importc.} + proc glReadPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glWindowPos3dARB(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glPixelTexGenParameterivSGIS(pname: GLenum, params: ptr GLint) {.importc.} + proc glSecondaryColor3svEXT(v: ptr GLshort) {.importc.} + proc glPopGroupMarkerEXT() {.importc.} + proc glImportSyncEXT(external_sync_type: GLenum, external_sync: GLintptr, flags: GLbitfield): GLsync {.importc.} + proc glVertexAttribLFormatNV(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei) {.importc.} + proc glVertexAttrib2sNV(index: GLuint, x: GLshort, y: GLshort) {.importc.} + proc glGetIntegeri_v(target: GLenum, index: GLuint, data: ptr GLint) {.importc.} + proc glProgramUniform3uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glGetActiveUniformBlockiv(program: GLuint, uniformBlockIndex: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glCreateShaderProgramv(`type`: GLenum, count: GLsizei, strings: cstringArray): GLuint {.importc.} + proc glUniform2fARB(location: GLint, v0: GLfloat, v1: GLfloat) {.importc.} + proc glVertexStream4ivATI(stream: GLenum, coords: ptr GLint) {.importc.} + proc glNormalP3uiv(`type`: GLenum, coords: ptr GLuint) {.importc.} + proc glVertexAttribLFormat(attribindex: GLuint, size: GLint, `type`: GLenum, relativeoffset: GLuint) {.importc.} + proc glTexCoord2bvOES(coords: ptr GLbyte) {.importc.} + proc glGetActiveUniformName(program: GLuint, uniformIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformName: cstring) {.importc.} + proc glTexCoord2sv(v: ptr GLshort) {.importc.} + proc glVertexAttrib2dNV(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} + proc glGetFogFuncSGIS(points: ptr GLfloat) {.importc.} + proc glSetFenceAPPLE(fence: GLuint) {.importc.} + proc glRasterPos2f(x: GLfloat, y: GLfloat) {.importc.} + proc glVertexWeightPointerEXT(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glEndList() {.importc.} + proc glVDPAUFiniNV() {.importc.} + proc glTbufferMask3DFX(mask: GLuint) {.importc.} + proc glVertexP4ui(`type`: GLenum, value: GLuint) {.importc.} + proc glTexEnviv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glColor4xOES(red: GLfixed, green: GLfixed, blue: GLfixed, alpha: GLfixed) {.importc.} + proc glBlendEquationi(buf: GLuint, mode: GLenum) {.importc.} + proc glLoadMatrixxOES(m: ptr GLfixed) {.importc.} + proc glFogxOES(pname: GLenum, param: GLfixed) {.importc.} + proc glTexCoord4dv(v: ptr GLdouble) {.importc.} + proc glFogCoordPointerListIBM(`type`: GLenum, stride: GLint, `pointer`: ptr pointer, ptrstride: GLint) {.importc.} + proc glGetPerfMonitorGroupsAMD(numGroups: ptr GLint, groupsSize: GLsizei, groups: ptr GLuint) {.importc.} + proc glVertex2hNV(x: GLhalfNv, y: GLhalfNv) {.importc.} + proc glDeleteFragmentShaderATI(id: GLuint) {.importc.} + proc glGetSamplerParameterIiv(sampler: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glUniform2fvARB(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glFogf(pname: GLenum, param: GLfloat) {.importc.} + proc glMultiTexCoord1iARB(target: GLenum, s: GLint) {.importc.} + proc glGetActiveUniformARB(programObj: GLhandleArb, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} + proc glMapGrid1xOES(n: GLint, u1: GLfixed, u2: GLfixed) {.importc.} + proc glIndexsv(c: ptr GLshort) {.importc.} + proc glFragmentMaterialfSGIX(face: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glBindTextureEXT(target: GLenum, texture: GLuint) {.importc.} + proc glRectiv(v1: ptr GLint, v2: ptr GLint) {.importc.} + proc glTangent3dEXT(tx: GLdouble, ty: GLdouble, tz: GLdouble) {.importc.} + proc glProgramUniformMatrix3x4fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glNormal3hNV(nx: GLhalfNv, ny: GLhalfNv, nz: GLhalfNv) {.importc.} + proc glPushClientAttribDefaultEXT(mask: GLbitfield) {.importc.} + proc glUnmapBufferARB(target: GLenum): GLboolean {.importc.} + proc glVertexAttribs1dvNV(index: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} + proc glUniformMatrix2x3dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glUniform3f(location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat) {.importc.} + proc glTexEnvxv(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glMapBufferOES(target: GLenum, access: GLenum): pointer {.importc.} + proc glBufferData(target: GLenum, size: GLsizeiptr, data: pointer, usage: GLenum) {.importc.} + proc glDrawElementsInstancedANGLE(mode: GLenum, count: GLsizei, `type`: GLenum, indices: ptr pointer, primcount: GLsizei) {.importc.} + proc glGetTextureHandleARB(texture: GLuint): GLuint64 {.importc.} + proc glNormal3f(nx: GLfloat, ny: GLfloat, nz: GLfloat) {.importc.} + proc glTexCoordP3uiv(`type`: GLenum, coords: ptr GLuint) {.importc.} + proc glTexParameterx(target: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glMapBufferRange(target: GLenum, offset: GLintptr, length: GLsizeiptr, access: GLbitfield): pointer {.importc.} + proc glTexCoord2fVertex3fSUN(s: GLfloat, t: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glVariantArrayObjectATI(id: GLuint, `type`: GLenum, stride: GLsizei, buffer: GLuint, offset: GLuint) {.importc.} + proc glGetnHistogramARB(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, bufSize: GLsizei, values: pointer) {.importc.} + proc glWindowPos3sv(v: ptr GLshort) {.importc.} + proc glGetVariantPointervEXT(id: GLuint, value: GLenum, data: ptr pointer) {.importc.} + proc glGetLightfv(light: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetnTexImageARB(target: GLenum, level: GLint, format: GLenum, `type`: GLenum, bufSize: GLsizei, img: pointer) {.importc.} + proc glGenRenderbuffersEXT(n: GLsizei, renderbuffers: ptr GLuint) {.importc.} + proc glMultiDrawArraysIndirectBindlessNV(mode: GLenum, indirect: pointer, drawCount: GLsizei, stride: GLsizei, vertexBufferCount: GLint) {.importc.} + proc glDisableClientStateIndexedEXT(`array`: GLenum, index: GLuint) {.importc.} + proc glMapGrid1f(un: GLint, u1: GLfloat, u2: GLfloat) {.importc.} + proc glTexStorage2D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glShaderStorageBlockBinding(program: GLuint, storageBlockIndex: GLuint, storageBlockBinding: GLuint) {.importc.} + proc glBlendBarrierNV() {.importc.} + proc glGetVideoui64vNV(video_slot: GLuint, pname: GLenum, params: ptr GLuint64Ext) {.importc.} + proc glUniform3ui64NV(location: GLint, x: GLuint64Ext, y: GLuint64Ext, z: GLuint64Ext) {.importc.} + proc glUniform4ivARB(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glGetQueryObjectivARB(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glCompressedTexSubImage3DOES(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, data: pointer) {.importc.} + proc glEnableIndexedEXT(target: GLenum, index: GLuint) {.importc.} + proc glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer: GLuint, coverageSamples: GLsizei, colorSamples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glVertexAttribI3iEXT(index: GLuint, x: GLint, y: GLint, z: GLint) {.importc.} + proc glUniform4uivEXT(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glGetUniformLocation(program: GLuint, name: cstring): GLint {.importc.} + proc glCurrentPaletteMatrixARB(index: GLint) {.importc.} + proc glVertexAttribLPointerEXT(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glFogCoorddvEXT(coord: ptr GLdouble) {.importc.} + proc glInitNames() {.importc.} + proc glGetPathSpacingNV(pathListMode: GLenum, numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, advanceScale: GLfloat, kerningScale: GLfloat, transformType: GLenum, returnedSpacing: ptr GLfloat) {.importc.} + proc glNormal3fVertex3fvSUN(n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glTexCoord2iv(v: ptr GLint) {.importc.} + proc glWindowPos3s(x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glProgramUniformMatrix3x4fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glVertexAttribP4ui(index: GLuint, `type`: GLenum, normalized: GLboolean, value: GLuint) {.importc.} + proc glVertexAttribs4ubvNV(index: GLuint, count: GLsizei, v: ptr GLubyte) {.importc.} + proc glProgramLocalParameterI4iNV(target: GLenum, index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glStencilMaskSeparate(face: GLenum, mask: GLuint) {.importc.} + proc glClientWaitSync(sync: GLsync, flags: GLbitfield, timeout: GLuint64): GLenum {.importc.} + proc glPolygonOffsetx(factor: GLfixed, units: GLfixed) {.importc.} + proc glCreateProgramObjectARB(): GLhandleArb {.importc.} + proc glClearColorIuiEXT(red: GLuint, green: GLuint, blue: GLuint, alpha: GLuint) {.importc.} + proc glDeleteTransformFeedbacksNV(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glFramebufferDrawBuffersEXT(framebuffer: GLuint, n: GLsizei, bufs: ptr GLenum) {.importc.} + proc glAreTexturesResident(n: GLsizei, textures: ptr GLuint, residences: ptr GLboolean): GLboolean {.importc.} + proc glNamedBufferDataEXT(buffer: GLuint, size: GLsizeiptr, data: pointer, usage: GLenum) {.importc.} + proc glGetInvariantFloatvEXT(id: GLuint, value: GLenum, data: ptr GLfloat) {.importc.} + proc glMultiTexCoord4d(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble, q: GLdouble) {.importc.} + proc glGetPixelTransformParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetStringi(name: GLenum, index: GLuint): ptr GLubyte {.importc.} + proc glMakeBufferNonResidentNV(target: GLenum) {.importc.} + proc glVertex4bOES(x: GLbyte, y: GLbyte, z: GLbyte) {.importc.} + proc glGetObjectLabel(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} + proc glClipPlanexOES(plane: GLenum, equation: ptr GLfixed) {.importc.} + proc glElementPointerAPPLE(`type`: GLenum, `pointer`: pointer) {.importc.} + proc glIsAsyncMarkerSGIX(marker: GLuint): GLboolean {.importc.} + proc glUseShaderProgramEXT(`type`: GLenum, program: GLuint) {.importc.} + proc glReplacementCodeuiColor4ubVertex3fSUN(rc: GLuint, r: GLubyte, g: GLubyte, b: GLubyte, a: GLubyte, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glIsTransformFeedback(id: GLuint): GLboolean {.importc.} + proc glEdgeFlag(flag: GLboolean) {.importc.} + proc glGetTexGeniv(coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glBeginQueryEXT(target: GLenum, id: GLuint) {.importc.} + proc glUniform1uiEXT(location: GLint, v0: GLuint) {.importc.} + proc glProgramUniform3fvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetVideoi64vNV(video_slot: GLuint, pname: GLenum, params: ptr GLint64Ext) {.importc.} + proc glProgramUniform3ui(program: GLuint, location: GLint, v0: GLuint, v1: GLuint, v2: GLuint) {.importc.} + proc glSecondaryColor3uiEXT(red: GLuint, green: GLuint, blue: GLuint) {.importc.} + proc glPathStencilFuncNV(fun: GLenum, `ref`: GLint, mask: GLuint) {.importc.} + proc glVertexAttribP1ui(index: GLuint, `type`: GLenum, normalized: GLboolean, value: GLuint) {.importc.} + proc glStencilFillPathInstancedNV(numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, fillMode: GLenum, mask: GLuint, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} + proc glFogCoordfEXT(coord: GLfloat) {.importc.} + proc glTextureParameterIuivEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glProgramUniform4dEXT(program: GLuint, location: GLint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glFramebufferTextureFaceARB(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint, face: GLenum) {.importc.} + proc glTexCoord3s(s: GLshort, t: GLshort, r: GLshort) {.importc.} + proc glGetFramebufferAttachmentParameteriv(target: GLenum, attachment: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glEndVideoCaptureNV(video_capture_slot: GLuint) {.importc.} + proc glProgramUniformMatrix2x4dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glGetFloatIndexedvEXT(target: GLenum, index: GLuint, data: ptr GLfloat) {.importc.} + proc glTexCoord1xOES(s: GLfixed) {.importc.} + proc glTexCoord4f(s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} + proc glShaderSource(shader: GLuint, count: GLsizei, string: cstringArray, length: ptr GLint) {.importc.} + proc glGetDetailTexFuncSGIS(target: GLenum, points: ptr GLfloat) {.importc.} + proc glResetHistogram(target: GLenum) {.importc.} + proc glVertexAttribP2ui(index: GLuint, `type`: GLenum, normalized: GLboolean, value: GLuint) {.importc.} + proc glDrawTransformFeedbackNV(mode: GLenum, id: GLuint) {.importc.} + proc glWindowPos2fMESA(x: GLfloat, y: GLfloat) {.importc.} + proc glObjectLabelKHR(identifier: GLenum, name: GLuint, length: GLsizei, label: cstring) {.importc.} + proc glMultiTexCoord2iARB(target: GLenum, s: GLint, t: GLint) {.importc.} + proc glVertexAttrib4usv(index: GLuint, v: ptr GLushort) {.importc.} + proc glGetGraphicsResetStatusARB(): GLenum {.importc.} + proc glProgramUniform3dEXT(program: GLuint, location: GLint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glPathSubCommandsNV(path: GLuint, commandStart: GLsizei, commandsToDelete: GLsizei, numCommands: GLsizei, commands: ptr GLubyte, numCoords: GLsizei, coordType: GLenum, coords: pointer) {.importc.} + proc glEndTransformFeedbackNV() {.importc.} + proc glWindowPos2sMESA(x: GLshort, y: GLshort) {.importc.} + proc glTangent3sEXT(tx: GLshort, ty: GLshort, tz: GLshort) {.importc.} + proc glLineWidthx(width: GLfixed) {.importc.} + proc glGetUniformBufferSizeEXT(program: GLuint, location: GLint): GLint {.importc.} + proc glTexCoord2bOES(s: GLbyte, t: GLbyte) {.importc.} + proc glWindowPos3iMESA(x: GLint, y: GLint, z: GLint) {.importc.} + proc glTexGend(coord: GLenum, pname: GLenum, param: GLdouble) {.importc.} + proc glRenderbufferStorageMultisampleANGLE(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glGetProgramiv(program: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glDrawTransformFeedbackStreamInstanced(mode: GLenum, id: GLuint, stream: GLuint, instancecount: GLsizei) {.importc.} + proc glMatrixTranslatefEXT(mode: GLenum, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glColor4iv(v: ptr GLint) {.importc.} + proc glSecondaryColor3ivEXT(v: ptr GLint) {.importc.} + proc glIsNamedStringARB(namelen: GLint, name: cstring): GLboolean {.importc.} + proc glVertexAttribL4dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glEndTransformFeedback() {.importc.} + proc glVertexStream3fvATI(stream: GLenum, coords: ptr GLfloat) {.importc.} + proc glProgramUniformMatrix4x2dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glTextureBufferRangeEXT(texture: GLuint, target: GLenum, internalformat: GLenum, buffer: GLuint, offset: GLintptr, size: GLsizeiptr) {.importc.} + proc glTexCoord2fNormal3fVertex3fvSUN(tc: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glProgramUniform2f(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat) {.importc.} + proc glMultiTexCoord2sv(target: GLenum, v: ptr GLshort) {.importc.} + proc glTexCoord3bOES(s: GLbyte, t: GLbyte, r: GLbyte) {.importc.} + proc glGenFramebuffersOES(n: GLsizei, framebuffers: ptr GLuint) {.importc.} + proc glMultiTexCoord3sv(target: GLenum, v: ptr GLshort) {.importc.} + proc glVertexAttrib4Nub(index: GLuint, x: GLubyte, y: GLubyte, z: GLubyte, w: GLubyte) {.importc.} + proc glColor3d(red: GLdouble, green: GLdouble, blue: GLdouble) {.importc.} + proc glGetActiveAttrib(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} + proc glConvolutionParameterfEXT(target: GLenum, pname: GLenum, params: GLfloat) {.importc.} + proc glTexSubImage2DEXT(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glBinormal3fvEXT(v: ptr GLfloat) {.importc.} + proc glDebugMessageControl(source: GLenum, `type`: GLenum, severity: GLenum, count: GLsizei, ids: ptr GLuint, enabled: GLboolean) {.importc.} + proc glProgramUniform3uivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glPNTrianglesiATI(pname: GLenum, param: GLint) {.importc.} + proc glGetPerfMonitorCounterInfoAMD(group: GLuint, counter: GLuint, pname: GLenum, data: pointer) {.importc.} + proc glVertexAttribL3ui64NV(index: GLuint, x: GLuint64Ext, y: GLuint64Ext, z: GLuint64Ext) {.importc.} + proc glIsRenderbufferOES(renderbuffer: GLuint): GLboolean {.importc.} + proc glColorSubTable(target: GLenum, start: GLsizei, count: GLsizei, format: GLenum, `type`: GLenum, data: pointer) {.importc.} + proc glCompressedMultiTexImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} + proc glBindSampler(unit: GLuint, sampler: GLuint) {.importc.} + proc glVariantubvEXT(id: GLuint, `addr`: ptr GLubyte) {.importc.} + proc glDisablei(target: GLenum, index: GLuint) {.importc.} + proc glVertexAttribI2uiEXT(index: GLuint, x: GLuint, y: GLuint) {.importc.} + proc glDrawElementArrayATI(mode: GLenum, count: GLsizei) {.importc.} + proc glTagSampleBufferSGIX() {.importc.} + proc glVertexPointerEXT(size: GLint, `type`: GLenum, stride: GLsizei, count: GLsizei, `pointer`: pointer) {.importc.} + proc glFragmentLightiSGIX(light: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glLoadTransposeMatrixxOES(m: ptr GLfixed) {.importc.} + proc glProgramLocalParameter4fvARB(target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} + proc glGetVariantFloatvEXT(id: GLuint, value: GLenum, data: ptr GLfloat) {.importc.} + proc glProgramUniform4ui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64Ext) {.importc.} + proc glFragmentLightfSGIX(light: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glIsVertexArrayAPPLE(`array`: GLuint): GLboolean {.importc.} + proc glTexCoord1bvOES(coords: ptr GLbyte) {.importc.} + proc glUniform4fv(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glPixelDataRangeNV(target: GLenum, length: GLsizei, `pointer`: pointer) {.importc.} + proc glUniformMatrix4x2fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glRectf(x1: GLfloat, y1: GLfloat, x2: GLfloat, y2: GLfloat) {.importc.} + proc glCoverageMaskNV(mask: GLboolean) {.importc.} + proc glPointParameterfvSGIS(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glProgramUniformMatrix4x2dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glFragmentLightModelfSGIX(pname: GLenum, param: GLfloat) {.importc.} + proc glDisableVertexAttribAPPLE(index: GLuint, pname: GLenum) {.importc.} + proc glMultiTexCoord3dvARB(target: GLenum, v: ptr GLdouble) {.importc.} + proc glTexCoord4iv(v: ptr GLint) {.importc.} + proc glUniform1f(location: GLint, v0: GLfloat) {.importc.} + proc glVertexAttribParameteriAMD(index: GLuint, pname: GLenum, param: GLint) {.importc.} + proc glGetConvolutionParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glRecti(x1: GLint, y1: GLint, x2: GLint, y2: GLint) {.importc.} + proc glTexEnvxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glGetRenderbufferParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glBlendFuncIndexedAMD(buf: GLuint, src: GLenum, dst: GLenum) {.importc.} + proc glProgramUniformMatrix3x2fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glDrawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei) {.importc.} + proc glTextureBarrierNV() {.importc.} + proc glDrawBuffersIndexedEXT(n: GLint, location: ptr GLenum, indices: ptr GLint) {.importc.} + proc glUniformMatrix4fvARB(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glInstrumentsBufferSGIX(size: GLsizei, buffer: ptr GLint) {.importc.} + proc glAlphaFuncQCOM(fun: GLenum, `ref`: GLclampf) {.importc.} + proc glUniformMatrix4fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glGetMinmaxParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetInvariantBooleanvEXT(id: GLuint, value: GLenum, data: ptr GLboolean) {.importc.} + proc glVDPAUIsSurfaceNV(surface: GLvdpauSurfaceNv) {.importc.} + proc glGenProgramsARB(n: GLsizei, programs: ptr GLuint) {.importc.} + proc glDrawRangeElementArrayATI(mode: GLenum, start: GLuint, `end`: GLuint, count: GLsizei) {.importc.} + proc glFramebufferRenderbufferEXT(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLuint) {.importc.} + proc glClearIndex(c: GLfloat) {.importc.} + proc glDepthRangeIndexed(index: GLuint, n: GLdouble, f: GLdouble) {.importc.} + proc glDrawTexivOES(coords: ptr GLint) {.importc.} + proc glTangent3iEXT(tx: GLint, ty: GLint, tz: GLint) {.importc.} + proc glStringMarkerGREMEDY(len: GLsizei, string: pointer) {.importc.} + proc glTexCoordP1ui(`type`: GLenum, coords: GLuint) {.importc.} + proc glOrthox(l: GLfixed, r: GLfixed, b: GLfixed, t: GLfixed, n: GLfixed, f: GLfixed) {.importc.} + proc glReplacementCodeuiVertex3fvSUN(rc: ptr GLuint, v: ptr GLfloat) {.importc.} + proc glMultiTexCoord1bvOES(texture: GLenum, coords: ptr GLbyte) {.importc.} + proc glDrawArraysInstancedBaseInstance(mode: GLenum, first: GLint, count: GLsizei, instancecount: GLsizei, baseinstance: GLuint) {.importc.} + proc glMultMatrixf(m: ptr GLfloat) {.importc.} + proc glProgramUniform4i(program: GLuint, location: GLint, v0: GLint, v1: GLint, v2: GLint, v3: GLint) {.importc.} + proc glScissorArrayv(first: GLuint, count: GLsizei, v: ptr GLint) {.importc.} + proc glGetnUniformivEXT(program: GLuint, location: GLint, bufSize: GLsizei, params: ptr GLint) {.importc.} + proc glGetTexEnvxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glWindowPos3ivARB(v: ptr GLint) {.importc.} + proc glProgramStringARB(target: GLenum, format: GLenum, len: GLsizei, string: pointer) {.importc.} + proc glTextureColorMaskSGIS(red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean) {.importc.} + proc glMultiTexCoord4fv(target: GLenum, v: ptr GLfloat) {.importc.} + proc glUniformMatrix4x3fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glIsPathNV(path: GLuint): GLboolean {.importc.} + proc glStartTilingQCOM(x: GLuint, y: GLuint, width: GLuint, height: GLuint, preserveMask: GLbitfield) {.importc.} + proc glVariantivEXT(id: GLuint, `addr`: ptr GLint) {.importc.} + proc glGetnMinmaxARB(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, bufSize: GLsizei, values: pointer) {.importc.} + proc glTransformFeedbackVaryings(program: GLuint, count: GLsizei, varyings: cstringArray, bufferMode: GLenum) {.importc.} + proc glShaderOp2EXT(op: GLenum, res: GLuint, arg1: GLuint, arg2: GLuint) {.importc.} + proc glVertexAttribPointer(index: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glMultiTexCoord4dvARB(target: GLenum, v: ptr GLdouble) {.importc.} + proc glProgramUniform1ui64NV(program: GLuint, location: GLint, x: GLuint64Ext) {.importc.} + proc glGetShaderSourceARB(obj: GLhandleArb, maxLength: GLsizei, length: ptr GLsizei, source: cstring) {.importc.} + proc glGetBufferSubDataARB(target: GLenum, offset: GLintPtrArb, size: GLsizeiptrArb, data: pointer) {.importc.} + proc glCopyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glProgramEnvParameterI4iNV(target: GLenum, index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glGetVertexAttribivARB(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetFinalCombinerInputParameterivNV(variable: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glIndexFuncEXT(fun: GLenum, `ref`: GLclampf) {.importc.} + proc glProgramUniformMatrix3dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glTexStorage1DEXT(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei) {.importc.} + proc glUniformMatrix2fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glConvolutionParameterf(target: GLenum, pname: GLenum, params: GLfloat) {.importc.} + proc glGlobalAlphaFactordSUN(factor: GLdouble) {.importc.} + proc glCopyTextureImage2DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint) {.importc.} + proc glVertex4xOES(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glClearDepthx(depth: GLfixed) {.importc.} + proc glGetColorTableParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGenProgramPipelines(n: GLsizei, pipelines: ptr GLuint) {.importc.} + proc glVertexAttribL4ui64vNV(index: GLuint, v: ptr GLuint64Ext) {.importc.} + proc glUniform1fARB(location: GLint, v0: GLfloat) {.importc.} + proc glUniformMatrix3fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glUniform3dv(location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glVertexAttribI4iv(index: GLuint, v: ptr GLint) {.importc.} + proc glPixelZoom(xfactor: GLfloat, yfactor: GLfloat) {.importc.} + proc glShadeModel(mode: GLenum) {.importc.} + proc glFramebufferTexture3DOES(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, zoffset: GLint) {.importc.} + proc glMultiTexCoord2i(target: GLenum, s: GLint, t: GLint) {.importc.} + proc glBlendEquationSeparateIndexedAMD(buf: GLuint, modeRgb: GLenum, modeAlpha: GLenum) {.importc.} + proc glIsEnabled(cap: GLenum): GLboolean {.importc.} + proc glTexImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glPolygonOffsetxOES(factor: GLfixed, units: GLfixed) {.importc.} + proc glDrawBuffersEXT(n: GLsizei, bufs: ptr GLenum) {.importc.} + proc glPixelTexGenParameterfSGIS(pname: GLenum, param: GLfloat) {.importc.} + proc glExtGetRenderbuffersQCOM(renderbuffers: ptr GLuint, maxRenderbuffers: GLint, numRenderbuffers: ptr GLint) {.importc.} + proc glBindImageTextures(first: GLuint, count: GLsizei, textures: ptr GLuint) {.importc.} + proc glVertexAttribP2uiv(index: GLuint, `type`: GLenum, normalized: GLboolean, value: ptr GLuint) {.importc.} + proc glTextureImage3DMultisampleCoverageNV(texture: GLuint, target: GLenum, coverageSamples: GLsizei, colorSamples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, fixedSampleLocations: GLboolean) {.importc.} + proc glRasterPos2s(x: GLshort, y: GLshort) {.importc.} + proc glVertexAttrib4dvARB(index: GLuint, v: ptr GLdouble) {.importc.} + proc glProgramUniformMatrix2x3fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glProgramUniformMatrix2x4dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glMultiTexCoord1d(target: GLenum, s: GLdouble) {.importc.} + proc glGetProgramParameterdvNV(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glPNTrianglesfATI(pname: GLenum, param: GLfloat) {.importc.} + proc glUniformMatrix3x4fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glVertexAttrib3sNV(index: GLuint, x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glGetVideoCaptureStreamfvNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glCombinerParameterivNV(pname: GLenum, params: ptr GLint) {.importc.} + proc glGetTexGenfvOES(coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glCopyTexSubImage2DEXT(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glGetProgramLocalParameterfvARB(target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} + proc glTexCoord3iv(v: ptr GLint) {.importc.} + proc glVertexAttribs2hvNV(index: GLuint, n: GLsizei, v: ptr GLhalfNv) {.importc.} + proc glNormal3sv(v: ptr GLshort) {.importc.} + proc glUniform2dv(location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glSecondaryColor3hvNV(v: ptr GLhalfNv) {.importc.} + proc glDrawArraysInstancedEXT(mode: GLenum, start: GLint, count: GLsizei, primcount: GLsizei) {.importc.} + proc glBeginTransformFeedback(primitiveMode: GLenum) {.importc.} + proc glTexParameterIuivEXT(target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glProgramBufferParametersfvNV(target: GLenum, bindingIndex: GLuint, wordIndex: GLuint, count: GLsizei, params: ptr GLfloat) {.importc.} + proc glVertexArrayBindVertexBufferEXT(vaobj: GLuint, bindingindex: GLuint, buffer: GLuint, offset: GLintptr, stride: GLsizei) {.importc.} + proc glPathParameterfNV(path: GLuint, pname: GLenum, value: GLfloat) {.importc.} + proc glGetClipPlanexOES(plane: GLenum, equation: ptr GLfixed) {.importc.} + proc glSecondaryColor3ubvEXT(v: ptr GLubyte) {.importc.} + proc glGetPixelMapxv(map: GLenum, size: GLint, values: ptr GLfixed) {.importc.} + proc glVertexAttribI1uivEXT(index: GLuint, v: ptr GLuint) {.importc.} + proc glMultiTexImage3DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glAlphaFuncxOES(fun: GLenum, `ref`: GLfixed) {.importc.} + proc glMultiTexCoord2dv(target: GLenum, v: ptr GLdouble) {.importc.} + proc glBindRenderbufferOES(target: GLenum, renderbuffer: GLuint) {.importc.} + proc glPathStencilDepthOffsetNV(factor: GLfloat, units: GLfloat) {.importc.} + proc glPointParameterfvEXT(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glSampleCoverageARB(value: GLfloat, invert: GLboolean) {.importc.} + proc glVertexAttrib3dNV(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glNamedProgramLocalParameter4dvEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLdouble) {.importc.} + proc glGenFramebuffers(n: GLsizei, framebuffers: ptr GLuint) {.importc.} + proc glMultiDrawElementsEXT(mode: GLenum, count: ptr GLsizei, `type`: GLenum, indices: ptr pointer, primcount: GLsizei) {.importc.} + proc glVertexAttrib2fNV(index: GLuint, x: GLfloat, y: GLfloat) {.importc.} + proc glProgramUniform4ivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glTexGeniOES(coord: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glBindProgramPipeline(pipeline: GLuint) {.importc.} + proc glBindSamplers(first: GLuint, count: GLsizei, samplers: ptr GLuint) {.importc.} + proc glColorTableSGI(target: GLenum, internalformat: GLenum, width: GLsizei, format: GLenum, `type`: GLenum, table: pointer) {.importc.} + proc glMultiTexCoord3xOES(texture: GLenum, s: GLfixed, t: GLfixed, r: GLfixed) {.importc.} + proc glIsQueryEXT(id: GLuint): GLboolean {.importc.} + proc glGenBuffersARB(n: GLsizei, buffers: ptr GLuint) {.importc.} + proc glVertex4xvOES(coords: ptr GLfixed) {.importc.} + proc glPixelMapuiv(map: GLenum, mapsize: GLsizei, values: ptr GLuint) {.importc.} + proc glDrawTexfOES(x: GLfloat, y: GLfloat, z: GLfloat, width: GLfloat, height: GLfloat) {.importc.} + proc glPointParameterfEXT(pname: GLenum, param: GLfloat) {.importc.} + proc glPathDashArrayNV(path: GLuint, dashCount: GLsizei, dashArray: ptr GLfloat) {.importc.} + proc glClearTexImage(texture: GLuint, level: GLint, format: GLenum, `type`: GLenum, data: ptr pointer) {.importc.} + proc glIndexdv(c: ptr GLdouble) {.importc.} + proc glMultTransposeMatrixfARB(m: ptr GLfloat) {.importc.} + proc glVertexAttribL3d(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glUniform3fv(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetProgramInterfaceiv(program: GLuint, programInterface: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glFogCoordfv(coord: ptr GLfloat) {.importc.} + proc glTexSubImage3DOES(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGetPolygonStipple(mask: ptr GLubyte) {.importc.} + proc glGetQueryObjectivEXT(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glColor3xOES(red: GLfixed, green: GLfixed, blue: GLfixed) {.importc.} + proc glMultiTexParameterIivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetMaterialiv(face: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertex2fv(v: ptr GLfloat) {.importc.} + proc glConvolutionParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGenOcclusionQueriesNV(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glGetVertexAttribdvNV(index: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glVertexAttribs4fvNV(index: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} + proc glVertexAttribL3dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glTexEnvi(target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glObjectPtrLabel(`ptr`: ptr pointer, length: GLsizei, label: cstring) {.importc.} + proc glGetTexGenfv(coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glMapVertexAttrib1dAPPLE(index: GLuint, size: GLuint, u1: GLdouble, u2: GLdouble, stride: GLint, order: GLint, points: ptr GLdouble) {.importc.} + proc glTexCoord3dv(v: ptr GLdouble) {.importc.} + proc glIsEnabledIndexedEXT(target: GLenum, index: GLuint): GLboolean {.importc.} + proc glGlobalAlphaFactoruiSUN(factor: GLuint) {.importc.} + proc glMatrixIndexPointerARB(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glUniformHandleui64ARB(location: GLint, value: GLuint64) {.importc.} + proc glUniform1fvARB(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetActiveSubroutineUniformName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: cstring) {.importc.} + proc glProgramUniformMatrix4x2fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glMultiTexCoord4fARB(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} + proc glGetDriverControlsQCOM(num: ptr GLint, size: GLsizei, driverControls: ptr GLuint) {.importc.} + proc glBindBufferRange(target: GLenum, index: GLuint, buffer: GLuint, offset: GLintptr, size: GLsizeiptr) {.importc.} + proc glMapGrid2f(un: GLint, u1: GLfloat, u2: GLfloat, vn: GLint, v1: GLfloat, v2: GLfloat) {.importc.} + proc glUniform2fv(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glOrtho(left: GLdouble, right: GLdouble, bottom: GLdouble, top: GLdouble, zNear: GLdouble, zFar: GLdouble) {.importc.} + proc glGetImageHandleNV(texture: GLuint, level: GLint, layered: GLboolean, layer: GLint, format: GLenum): GLuint64 {.importc.} + proc glIsImageHandleResidentARB(handle: GLuint64): GLboolean {.importc.} + proc glGetConvolutionParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glLineWidthxOES(width: GLfixed) {.importc.} + proc glPathCommandsNV(path: GLuint, numCommands: GLsizei, commands: ptr GLubyte, numCoords: GLsizei, coordType: GLenum, coords: pointer) {.importc.} + proc glMaterialxvOES(face: GLenum, pname: GLenum, param: ptr GLfixed) {.importc.} + proc glPauseTransformFeedbackNV() {.importc.} + proc glTexCoord4d(s: GLdouble, t: GLdouble, r: GLdouble, q: GLdouble) {.importc.} + proc glUniform3ui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64Ext) {.importc.} + proc glMultiTexCoord3dARB(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble) {.importc.} + proc glProgramUniform3fEXT(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat) {.importc.} + proc glTexImage3DMultisampleCoverageNV(target: GLenum, coverageSamples: GLsizei, colorSamples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, fixedSampleLocations: GLboolean) {.importc.} + proc glNormalPointerEXT(`type`: GLenum, stride: GLsizei, count: GLsizei, `pointer`: pointer) {.importc.} + proc glPathColorGenNV(color: GLenum, genMode: GLenum, colorFormat: GLenum, coeffs: ptr GLfloat) {.importc.} + proc glGetMultiTexGendvEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glColor3i(red: GLint, green: GLint, blue: GLint) {.importc.} + proc glPointSizex(size: GLfixed) {.importc.} + proc glGetConvolutionFilterEXT(target: GLenum, format: GLenum, `type`: GLenum, image: pointer) {.importc.} + proc glBindBufferBaseNV(target: GLenum, index: GLuint, buffer: GLuint) {.importc.} + proc glInsertComponentEXT(res: GLuint, src: GLuint, num: GLuint) {.importc.} + proc glVertex2d(x: GLdouble, y: GLdouble) {.importc.} + proc glGetPathDashArrayNV(path: GLuint, dashArray: ptr GLfloat) {.importc.} + proc glVertexAttrib2sARB(index: GLuint, x: GLshort, y: GLshort) {.importc.} + proc glScissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glLoadMatrixd(m: ptr GLdouble) {.importc.} + proc glVertex2bvOES(coords: ptr GLbyte) {.importc.} + proc glTexCoord2i(s: GLint, t: GLint) {.importc.} + proc glWriteMaskEXT(res: GLuint, `in`: GLuint, outX: GLenum, outY: GLenum, outZ: GLenum, outW: GLenum) {.importc.} + proc glClientWaitSyncAPPLE(sync: GLsync, flags: GLbitfield, timeout: GLuint64): GLenum {.importc.} + proc glGetObjectBufferivATI(buffer: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetNamedBufferParameterivEXT(buffer: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glTexCoord1bOES(s: GLbyte) {.importc.} + proc glVertexAttrib4dARB(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glUniform3fARB(location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat) {.importc.} + proc glWindowPos2ivARB(v: ptr GLint) {.importc.} + proc glCreateShaderProgramvEXT(`type`: GLenum, count: GLsizei, strings: cstringArray): GLuint {.importc.} + proc glListParameterivSGIX(list: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetGraphicsResetStatusEXT(): GLenum {.importc.} + proc glActiveShaderProgramEXT(pipeline: GLuint, program: GLuint) {.importc.} + proc glTexCoordP1uiv(`type`: GLenum, coords: ptr GLuint) {.importc.} + proc glVideoCaptureStreamParameterdvNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glGetVertexAttribPointerv(index: GLuint, pname: GLenum, `pointer`: ptr pointer) {.importc.} + proc glGetCompressedMultiTexImageEXT(texunit: GLenum, target: GLenum, lod: GLint, img: pointer) {.importc.} + proc glWindowPos4fMESA(x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glDrawElementsInstancedARB(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, primcount: GLsizei) {.importc.} + proc glVertexStream1dATI(stream: GLenum, x: GLdouble) {.importc.} + proc glMatrixMultfEXT(mode: GLenum, m: ptr GLfloat) {.importc.} + proc glGetPathParameterivNV(path: GLuint, pname: GLenum, value: ptr GLint) {.importc.} + proc glCombinerParameteriNV(pname: GLenum, param: GLint) {.importc.} + proc glUpdateObjectBufferATI(buffer: GLuint, offset: GLuint, size: GLsizei, `pointer`: pointer, preserve: GLenum) {.importc.} + proc glVertexAttrib4uivARB(index: GLuint, v: ptr GLuint) {.importc.} + proc glVertexAttrib4iv(index: GLuint, v: ptr GLint) {.importc.} + proc glFrustum(left: GLdouble, right: GLdouble, bottom: GLdouble, top: GLdouble, zNear: GLdouble, zFar: GLdouble) {.importc.} + proc glDrawTexxvOES(coords: ptr GLfixed) {.importc.} + proc glTexCoord2fColor4ubVertex3fSUN(s: GLfloat, t: GLfloat, r: GLubyte, g: GLubyte, b: GLubyte, a: GLubyte, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glMultiTexCoord2fARB(target: GLenum, s: GLfloat, t: GLfloat) {.importc.} + proc glGenTransformFeedbacksNV(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glMultiTexGenfEXT(texunit: GLenum, coord: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glGetMinmax(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, values: pointer) {.importc.} + proc glBindTransformFeedback(target: GLenum, id: GLuint) {.importc.} + proc glEnableVertexAttribArrayARB(index: GLuint) {.importc.} + proc glIsFenceAPPLE(fence: GLuint): GLboolean {.importc.} + proc glMultiTexGendvEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glRotatex(angle: GLfixed, x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glGetFragmentLightfvSGIX(light: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glMultiTexCoord4dv(target: GLenum, v: ptr GLdouble) {.importc.} + proc glBlendFuncSeparateEXT(sfactorRgb: GLenum, dfactorRgb: GLenum, sfactorAlpha: GLenum, dfactorAlpha: GLenum) {.importc.} + proc glMultiTexCoord1f(target: GLenum, s: GLfloat) {.importc.} + proc glWindowPos2f(x: GLfloat, y: GLfloat) {.importc.} + proc glGetPathTexGenivNV(texCoordSet: GLenum, pname: GLenum, value: ptr GLint) {.importc.} + proc glIndexxvOES(component: ptr GLfixed) {.importc.} + proc glDisableVertexArrayAttribEXT(vaobj: GLuint, index: GLuint) {.importc.} + proc glGetProgramivARB(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glPatchParameteri(pname: GLenum, value: GLint) {.importc.} + proc glMultiTexCoord2fv(target: GLenum, v: ptr GLfloat) {.importc.} + proc glTexSubImage3DEXT(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glFramebufferTexture1DEXT(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glTangent3fEXT(tx: GLfloat, ty: GLfloat, tz: GLfloat) {.importc.} + proc glIsVertexAttribEnabledAPPLE(index: GLuint, pname: GLenum): GLboolean {.importc.} + proc glGetShaderInfoLog(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} + proc glFrustumx(l: GLfixed, r: GLfixed, b: GLfixed, t: GLfixed, n: GLfixed, f: GLfixed) {.importc.} + proc glTexGenfv(coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glCompressedTexImage2DARB(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} + proc glMultiTexCoord2bvOES(texture: GLenum, coords: ptr GLbyte) {.importc.} + proc glGetTexBumpParameterivATI(pname: GLenum, param: ptr GLint) {.importc.} + proc glMultiTexCoord2svARB(target: GLenum, v: ptr GLshort) {.importc.} + proc glProgramBufferParametersIivNV(target: GLenum, bindingIndex: GLuint, wordIndex: GLuint, count: GLsizei, params: ptr GLint) {.importc.} + proc glIsQueryARB(id: GLuint): GLboolean {.importc.} + proc glFramebufferTextureLayer(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint, layer: GLint) {.importc.} + proc glUniform4i(location: GLint, v0: GLint, v1: GLint, v2: GLint, v3: GLint) {.importc.} + proc glDrawArrays(mode: GLenum, first: GLint, count: GLsizei) {.importc.} + proc glWeightubvARB(size: GLint, weights: ptr GLubyte) {.importc.} + proc glGetUniformSubroutineuiv(shadertype: GLenum, location: GLint, params: ptr GLuint) {.importc.} + proc glMultTransposeMatrixdARB(m: ptr GLdouble) {.importc.} + proc glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc: ptr GLuint, tc: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glGetMapdv(target: GLenum, query: GLenum, v: ptr GLdouble) {.importc.} + proc glGetMultisamplefvNV(pname: GLenum, index: GLuint, val: ptr GLfloat) {.importc.} + proc glVertex2hvNV(v: ptr GLhalfNv) {.importc.} + proc glProgramUniformMatrix2x3fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glProgramUniform3iEXT(program: GLuint, location: GLint, v0: GLint, v1: GLint, v2: GLint) {.importc.} + proc glGetnPixelMapusvARB(map: GLenum, bufSize: GLsizei, values: ptr GLushort) {.importc.} + proc glVertexWeighthvNV(weight: ptr GLhalfNv) {.importc.} + proc glDrawTransformFeedbackInstanced(mode: GLenum, id: GLuint, instancecount: GLsizei) {.importc.} + proc glFlushStaticDataIBM(target: GLenum) {.importc.} + proc glWindowPos2fvARB(v: ptr GLfloat) {.importc.} + proc glMultiTexCoord3sARB(target: GLenum, s: GLshort, t: GLshort, r: GLshort) {.importc.} + proc glWindowPos3fv(v: ptr GLfloat) {.importc.} + proc glFlushVertexArrayRangeNV() {.importc.} + proc glTangent3bEXT(tx: GLbyte, ty: GLbyte, tz: GLbyte) {.importc.} + proc glIglooInterfaceSGIX(pname: GLenum, params: pointer) {.importc.} + proc glProgramUniformMatrix4x2fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glVertexAttribIFormatNV(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei) {.importc.} + proc glNamedRenderbufferStorageMultisampleEXT(renderbuffer: GLuint, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glCopyTexImage1DEXT(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, border: GLint) {.importc.} + proc glBindTexGenParameterEXT(unit: GLenum, coord: GLenum, value: GLenum): GLuint {.importc.} + proc glVertex4hNV(x: GLhalfNv, y: GLhalfNv, z: GLhalfNv, w: GLhalfNv) {.importc.} + proc glGetMapfv(target: GLenum, query: GLenum, v: ptr GLfloat) {.importc.} + proc glSamplePatternEXT(pattern: GLenum) {.importc.} + proc glIndexxOES(component: GLfixed) {.importc.} + proc glVertexAttrib4ubv(index: GLuint, v: ptr GLubyte) {.importc.} + proc glGetColorTable(target: GLenum, format: GLenum, `type`: GLenum, table: pointer) {.importc.} + proc glFragmentLightModelivSGIX(pname: GLenum, params: ptr GLint) {.importc.} + proc glPixelTransformParameterfEXT(target: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glSamplerParameterfv(sampler: GLuint, pname: GLenum, param: ptr GLfloat) {.importc.} + proc glBindTextureUnitParameterEXT(unit: GLenum, value: GLenum): GLuint {.importc.} + proc glColor3ub(red: GLubyte, green: GLubyte, blue: GLubyte) {.importc.} + proc glGetMultiTexGenivEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVariantusvEXT(id: GLuint, `addr`: ptr GLushort) {.importc.} + proc glMaterialiv(face: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glPassTexCoordATI(dst: GLuint, coord: GLuint, swizzle: GLenum) {.importc.} + proc glGetIntegerui64vNV(value: GLenum, result: ptr GLuint64Ext) {.importc.} + proc glProgramParameteriEXT(program: GLuint, pname: GLenum, value: GLint) {.importc.} + proc glVertexArrayEdgeFlagOffsetEXT(vaobj: GLuint, buffer: GLuint, stride: GLsizei, offset: GLintptr) {.importc.} + proc glGetCombinerInputParameterivNV(stage: GLenum, portion: GLenum, variable: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glLogicOp(opcode: GLenum) {.importc.} + proc glConvolutionParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glIsBufferResidentNV(target: GLenum): GLboolean {.importc.} + proc glIsProgram(program: GLuint): GLboolean {.importc.} + proc glEndQueryARB(target: GLenum) {.importc.} + proc glRenderbufferStorage(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glMaterialfv(face: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTranslatex(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glPathParameterivNV(path: GLuint, pname: GLenum, value: ptr GLint) {.importc.} + proc glLightxOES(light: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glSampleMaskEXT(value: GLclampf, invert: GLboolean) {.importc.} + proc glReplacementCodeubvSUN(code: ptr GLubyte) {.importc.} + proc glVertexAttribArrayObjectATI(index: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, stride: GLsizei, buffer: GLuint, offset: GLuint) {.importc.} + proc glBeginTransformFeedbackNV(primitiveMode: GLenum) {.importc.} + proc glEvalCoord1fv(u: ptr GLfloat) {.importc.} + proc glProgramUniformMatrix2x3dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glMaterialxv(face: GLenum, pname: GLenum, param: ptr GLfixed) {.importc.} + proc glGetIntegerui64i_vNV(value: GLenum, index: GLuint, result: ptr GLuint64Ext) {.importc.} + proc glUniformBlockBinding(program: GLuint, uniformBlockIndex: GLuint, uniformBlockBinding: GLuint) {.importc.} + proc glColor4ui(red: GLuint, green: GLuint, blue: GLuint, alpha: GLuint) {.importc.} + proc glColor4ubVertex2fvSUN(c: ptr GLubyte, v: ptr GLfloat) {.importc.} + proc glRectd(x1: GLdouble, y1: GLdouble, x2: GLdouble, y2: GLdouble) {.importc.} + proc glGenVertexShadersEXT(range: GLuint): GLuint {.importc.} + proc glLinkProgramARB(programObj: GLhandleArb) {.importc.} + proc glVertexAttribL4dEXT(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glBlitFramebuffer(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum) {.importc.} + proc glUseProgram(program: GLuint) {.importc.} + proc glNamedProgramLocalParameterI4ivEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLint) {.importc.} + proc glMatrixLoadTransposedEXT(mode: GLenum, m: ptr GLdouble) {.importc.} + proc glTranslatef(x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glGetBooleani_v(target: GLenum, index: GLuint, data: ptr GLboolean) {.importc.} + proc glEndFragmentShaderATI() {.importc.} + proc glVertexAttribI4ivEXT(index: GLuint, v: ptr GLint) {.importc.} + proc glMultiDrawElementsIndirectBindlessNV(mode: GLenum, `type`: GLenum, indirect: pointer, drawCount: GLsizei, stride: GLsizei, vertexBufferCount: GLint) {.importc.} + proc glTexCoord2s(s: GLshort, t: GLshort) {.importc.} + proc glProgramUniform1i64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint64Ext) {.importc.} + proc glPointSizePointerOES(`type`: GLenum, stride: GLsizei, `pointer`: ptr pointer) {.importc.} + proc glGetTexFilterFuncSGIS(target: GLenum, filter: GLenum, weights: ptr GLfloat) {.importc.} + proc glMapGrid2xOES(n: GLint, u1: GLfixed, u2: GLfixed, v1: GLfixed, v2: GLfixed) {.importc.} + proc glRasterPos4xvOES(coords: ptr GLfixed) {.importc.} + proc glGetProgramBinary(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, binaryFormat: ptr GLenum, binary: pointer) {.importc.} + proc glNamedProgramLocalParameterI4uiEXT(program: GLuint, target: GLenum, index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint) {.importc.} + proc glGetTexImage(target: GLenum, level: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glColor4d(red: GLdouble, green: GLdouble, blue: GLdouble, alpha: GLdouble) {.importc.} + proc glTexCoord2fColor4fNormal3fVertex3fSUN(s: GLfloat, t: GLfloat, r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glIndexi(c: GLint) {.importc.} + proc glGetSamplerParameterIuiv(sampler: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glGetnUniformivARB(program: GLuint, location: GLint, bufSize: GLsizei, params: ptr GLint) {.importc.} + proc glCopyTexSubImage3DEXT(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glVertexAttribI2uivEXT(index: GLuint, v: ptr GLuint) {.importc.} + proc glVertexStream2fvATI(stream: GLenum, coords: ptr GLfloat) {.importc.} + proc glArrayElementEXT(i: GLint) {.importc.} + proc glVertexAttrib2fv(index: GLuint, v: ptr GLfloat) {.importc.} + proc glCopyMultiTexSubImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glTexCoord4sv(v: ptr GLshort) {.importc.} + proc glTexGenfvOES(coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glPointParameteriv(pname: GLenum, params: ptr GLint) {.importc.} + proc glGetNamedRenderbufferParameterivEXT(renderbuffer: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramVertexLimitNV(target: GLenum, limit: GLint) {.importc.} + proc glSetMultisamplefvAMD(pname: GLenum, index: GLuint, val: ptr GLfloat) {.importc.} + proc glLoadIdentityDeformationMapSGIX(mask: GLbitfield) {.importc.} + proc glIsSyncAPPLE(sync: GLsync): GLboolean {.importc.} + proc glProgramUniform1ui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64Ext) {.importc.} + proc glEdgeFlagPointerListIBM(stride: GLint, `pointer`: ptr ptr GLboolean, ptrstride: GLint) {.importc.} + proc glBeginVertexShaderEXT() {.importc.} + proc glGetIntegerv(pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttrib2dvARB(index: GLuint, v: ptr GLdouble) {.importc.} + proc glBeginConditionalRenderNV(id: GLuint, mode: GLenum) {.importc.} + proc glEdgeFlagv(flag: ptr GLboolean) {.importc.} + proc glReplacementCodeubSUN(code: GLubyte) {.importc.} + proc glObjectLabel(identifier: GLenum, name: GLuint, length: GLsizei, label: cstring) {.importc.} + proc glMultiTexCoord3xvOES(texture: GLenum, coords: ptr GLfixed) {.importc.} + proc glNormal3iv(v: ptr GLint) {.importc.} + proc glSamplerParameteri(sampler: GLuint, pname: GLenum, param: GLint) {.importc.} + proc glTextureStorage1DEXT(texture: GLuint, target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei) {.importc.} + proc glVertexStream4dvATI(stream: GLenum, coords: ptr GLdouble) {.importc.} + proc glWindowPos2fv(v: ptr GLfloat) {.importc.} + proc glTexCoord4i(s: GLint, t: GLint, r: GLint, q: GLint) {.importc.} + proc glVertexAttrib4NusvARB(index: GLuint, v: ptr GLushort) {.importc.} + proc glVertexAttribL4d(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glVertexAttribDivisorANGLE(index: GLuint, divisor: GLuint) {.importc.} + proc glMatrixIndexPointerOES(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glMultMatrixxOES(m: ptr GLfixed) {.importc.} + proc glMultiTexCoordP2ui(texture: GLenum, `type`: GLenum, coords: GLuint) {.importc.} + proc glDeformationMap3dSGIX(target: GLenum, u1: GLdouble, u2: GLdouble, ustride: GLint, uorder: GLint, v1: GLdouble, v2: GLdouble, vstride: GLint, vorder: GLint, w1: GLdouble, w2: GLdouble, wstride: GLint, worder: GLint, points: ptr GLdouble) {.importc.} + proc glClearDepthfOES(depth: GLclampf) {.importc.} + proc glVertexStream1ivATI(stream: GLenum, coords: ptr GLint) {.importc.} + proc glHint(target: GLenum, mode: GLenum) {.importc.} + proc glVertex3fv(v: ptr GLfloat) {.importc.} + proc glWaitSyncAPPLE(sync: GLsync, flags: GLbitfield, timeout: GLuint64) {.importc.} + proc glWindowPos3i(x: GLint, y: GLint, z: GLint) {.importc.} + proc glCompressedTexImage3DARB(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} + proc glVertexAttrib1fvARB(index: GLuint, v: ptr GLfloat) {.importc.} + proc glMultiTexCoord4xOES(texture: GLenum, s: GLfixed, t: GLfixed, r: GLfixed, q: GLfixed) {.importc.} + proc glUniform4ui64NV(location: GLint, x: GLuint64Ext, y: GLuint64Ext, z: GLuint64Ext, w: GLuint64Ext) {.importc.} + proc glProgramUniform4uiEXT(program: GLuint, location: GLint, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint) {.importc.} + proc glUnmapNamedBufferEXT(buffer: GLuint): GLboolean {.importc.} + proc glBitmap(width: GLsizei, height: GLsizei, xorig: GLfloat, yorig: GLfloat, xmove: GLfloat, ymove: GLfloat, bitmap: ptr GLubyte) {.importc.} + proc glNamedProgramLocalParameters4fvEXT(program: GLuint, target: GLenum, index: GLuint, count: GLsizei, params: ptr GLfloat) {.importc.} + proc glGetPathCommandsNV(path: GLuint, commands: ptr GLubyte) {.importc.} + proc glVertexAttrib3fNV(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glNamedProgramStringEXT(program: GLuint, target: GLenum, format: GLenum, len: GLsizei, string: pointer) {.importc.} + proc glMatrixIndexusvARB(size: GLint, indices: ptr GLushort) {.importc.} + proc glBlitFramebufferNV(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum) {.importc.} + proc glVertexAttribI1uiv(index: GLuint, v: ptr GLuint) {.importc.} + proc glEndConditionalRenderNV() {.importc.} + proc glFeedbackBuffer(size: GLsizei, `type`: GLenum, buffer: ptr GLfloat) {.importc.} + proc glMultiTexCoord3bvOES(texture: GLenum, coords: ptr GLbyte) {.importc.} + proc glCopyColorTableSGI(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glActiveTexture(texture: GLenum) {.importc.} + proc glFogCoordhNV(fog: GLhalfNv) {.importc.} + proc glColorMaskIndexedEXT(index: GLuint, r: GLboolean, g: GLboolean, b: GLboolean, a: GLboolean) {.importc.} + proc glGetCompressedTexImage(target: GLenum, level: GLint, img: pointer) {.importc.} + proc glRasterPos2iv(v: ptr GLint) {.importc.} + proc glGetBufferParameterivARB(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramUniform3d(program: GLuint, location: GLint, v0: GLdouble, v1: GLdouble, v2: GLdouble) {.importc.} + proc glRasterPos3xvOES(coords: ptr GLfixed) {.importc.} + proc glGetTextureParameterIuivEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glBindImageTextureEXT(index: GLuint, texture: GLuint, level: GLint, layered: GLboolean, layer: GLint, access: GLenum, format: GLint) {.importc.} + proc glWindowPos2iMESA(x: GLint, y: GLint) {.importc.} + proc glVertexPointervINTEL(size: GLint, `type`: GLenum, `pointer`: ptr pointer) {.importc.} + proc glPixelTexGenParameterfvSGIS(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glUniform1iARB(location: GLint, v0: GLint) {.importc.} + proc glTextureSubImage3DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glStencilOpSeparate(face: GLenum, sfail: GLenum, dpfail: GLenum, dppass: GLenum) {.importc.} + proc glVertexAttrib1dARB(index: GLuint, x: GLdouble) {.importc.} + proc glGetVideoCaptureStreamivNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glIsFramebufferEXT(framebuffer: GLuint): GLboolean {.importc.} + proc glPointParameterxv(pname: GLenum, params: ptr GLfixed) {.importc.} + proc glProgramUniform4dv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glPassThrough(token: GLfloat) {.importc.} + proc glGetProgramPipelineiv(pipeline: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glApplyTextureEXT(mode: GLenum) {.importc.} + proc glVertexArrayNormalOffsetEXT(vaobj: GLuint, buffer: GLuint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glTexFilterFuncSGIS(target: GLenum, filter: GLenum, n: GLsizei, weights: ptr GLfloat) {.importc.} + proc glRenderbufferStorageOES(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glBindParameterEXT(value: GLenum): GLuint {.importc.} + proc glVertex4s(x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} + proc glLoadTransposeMatrixf(m: ptr GLfloat) {.importc.} + proc glDepthFunc(fun: GLenum) {.importc.} + proc glGetFramebufferAttachmentParameterivEXT(target: GLenum, attachment: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glSampleMaskSGIS(value: GLclampf, invert: GLboolean) {.importc.} + proc glGetPointerIndexedvEXT(target: GLenum, index: GLuint, data: ptr pointer) {.importc.} + proc glVertexStream4iATI(stream: GLenum, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glUnlockArraysEXT() {.importc.} + proc glReplacementCodeuivSUN(code: ptr GLuint) {.importc.} + proc glMatrixScaledEXT(mode: GLenum, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glMultiTexImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glFeedbackBufferxOES(n: GLsizei, `type`: GLenum, buffer: ptr GLfixed) {.importc.} + proc glLightEnviSGIX(pname: GLenum, param: GLint) {.importc.} + proc glMultiTexCoord4dARB(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble, q: GLdouble) {.importc.} + proc glExtGetTexLevelParameterivQCOM(texture: GLuint, face: GLenum, level: GLint, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttribI4usvEXT(index: GLuint, v: ptr GLushort) {.importc.} + proc glWindowPos2dvARB(v: ptr GLdouble) {.importc.} + proc glBindFramebuffer(target: GLenum, framebuffer: GLuint) {.importc.} + proc glGetProgramPipelineivEXT(pipeline: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramUniformHandleui64vNV(program: GLuint, location: GLint, count: GLsizei, values: ptr GLuint64) {.importc.} + proc glFogCoordhvNV(fog: ptr GLhalfNv) {.importc.} + proc glTextureImage1DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGetActiveAtomicCounterBufferiv(program: GLuint, bufferIndex: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glBeginQueryARB(target: GLenum, id: GLuint) {.importc.} + proc glGetTexParameterIuivEXT(target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glUniform4ui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64Ext) {.importc.} + proc glClearAccumxOES(red: GLfixed, green: GLfixed, blue: GLfixed, alpha: GLfixed) {.importc.} + proc glFreeObjectBufferATI(buffer: GLuint) {.importc.} + proc glGetVideouivNV(video_slot: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glVertexAttribL4ui64NV(index: GLuint, x: GLuint64Ext, y: GLuint64Ext, z: GLuint64Ext, w: GLuint64Ext) {.importc.} + proc glGetUniformBlockIndex(program: GLuint, uniformBlockName: cstring): GLuint {.importc.} + proc glCopyMultiTexSubImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glVertex3bvOES(coords: ptr GLbyte) {.importc.} + proc glMultiDrawElementArrayAPPLE(mode: GLenum, first: ptr GLint, count: ptr GLsizei, primcount: GLsizei) {.importc.} + proc glPrimitiveRestartNV() {.importc.} + proc glMateriali(face: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glBegin(mode: GLenum) {.importc.} + proc glFogCoordPointerEXT(`type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glTexCoord1sv(v: ptr GLshort) {.importc.} + proc glVertexAttribI4sv(index: GLuint, v: ptr GLshort) {.importc.} + proc glTexEnvx(target: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glTexParameterIivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glLoadTransposeMatrixfARB(m: ptr GLfloat) {.importc.} + proc glGetTextureSamplerHandleARB(texture: GLuint, sampler: GLuint): GLuint64 {.importc.} + proc glVertexP3uiv(`type`: GLenum, value: ptr GLuint) {.importc.} + proc glProgramUniform2dv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glTexCoord4xvOES(coords: ptr GLfixed) {.importc.} + proc glTexStorage1D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei) {.importc.} + proc glTextureParameterfEXT(texture: GLuint, target: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glVertexAttrib1d(index: GLuint, x: GLdouble) {.importc.} + proc glGetnPixelMapfvARB(map: GLenum, bufSize: GLsizei, values: ptr GLfloat) {.importc.} + proc glDisableVertexAttribArray(index: GLuint) {.importc.} + proc glUniformMatrix4x3dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glRasterPos4f(x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glProgramUniform1fEXT(program: GLuint, location: GLint, v0: GLfloat) {.importc.} + proc glPathTexGenNV(texCoordSet: GLenum, genMode: GLenum, components: GLint, coeffs: ptr GLfloat) {.importc.} + proc glUniform3ui(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint) {.importc.} + proc glVDPAURegisterOutputSurfaceNV(vdpSurface: pointer, target: GLenum, numTextureNames: GLsizei, textureNames: ptr GLuint): GLvdpauSurfaceNv {.importc.} + proc glGetProgramLocalParameterIuivNV(target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} + proc glIsTextureHandleResidentNV(handle: GLuint64): GLboolean {.importc.} + proc glProgramEnvParameters4fvEXT(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLfloat) {.importc.} + proc glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc: GLuint, s: GLfloat, t: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glGetMultiTexEnvivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetFloatv(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glInsertEventMarkerEXT(length: GLsizei, marker: cstring) {.importc.} + proc glRasterPos3d(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glNamedFramebufferRenderbufferEXT(framebuffer: GLuint, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLuint) {.importc.} + proc glGetConvolutionFilter(target: GLenum, format: GLenum, `type`: GLenum, image: pointer) {.importc.} + proc glIsOcclusionQueryNV(id: GLuint): GLboolean {.importc.} + proc glGetnPixelMapuivARB(map: GLenum, bufSize: GLsizei, values: ptr GLuint) {.importc.} + proc glMapParameterfvNV(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glPushDebugGroup(source: GLenum, id: GLuint, length: GLsizei, message: cstring) {.importc.} + proc glMakeImageHandleResidentARB(handle: GLuint64, access: GLenum) {.importc.} + proc glProgramUniformMatrix2fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glUniform3i64vNV(location: GLint, count: GLsizei, value: ptr GLint64Ext) {.importc.} + proc glImageTransformParameteriHP(target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glMultiTexCoord1s(target: GLenum, s: GLshort) {.importc.} + proc glVertexAttribL4dvEXT(index: GLuint, v: ptr GLdouble) {.importc.} + proc glGetProgramEnvParameterfvARB(target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} + proc glVertexArrayColorOffsetEXT(vaobj: GLuint, buffer: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glGetHistogramParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetRenderbufferParameterivOES(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetBufferPointerv(target: GLenum, pname: GLenum, params: ptr pointer) {.importc.} + proc glSecondaryColor3ui(red: GLuint, green: GLuint, blue: GLuint) {.importc.} + proc glGetDebugMessageLog(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: cstring): GLuint {.importc.} + proc glNormal3i(nx: GLint, ny: GLint, nz: GLint) {.importc.} + proc glTestFenceNV(fence: GLuint): GLboolean {.importc.} + proc glSecondaryColor3usv(v: ptr GLushort) {.importc.} + proc glGenPathsNV(range: GLsizei): GLuint {.importc.} + proc glDeleteBuffersARB(n: GLsizei, buffers: ptr GLuint) {.importc.} + proc glProgramUniform4fvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetSharpenTexFuncSGIS(target: GLenum, points: ptr GLfloat) {.importc.} + proc glDrawMeshArraysSUN(mode: GLenum, first: GLint, count: GLsizei, width: GLsizei) {.importc.} + proc glVertexAttribs4hvNV(index: GLuint, n: GLsizei, v: ptr GLhalfNv) {.importc.} + proc glGetClipPlane(plane: GLenum, equation: ptr GLdouble) {.importc.} + proc glEvalCoord2fv(u: ptr GLfloat) {.importc.} + proc glAsyncMarkerSGIX(marker: GLuint) {.importc.} + proc glGetSynciv(sync: GLsync, pname: GLenum, bufSize: GLsizei, length: ptr GLsizei, values: ptr GLint) {.importc.} + proc glGetPathTexGenfvNV(texCoordSet: GLenum, pname: GLenum, value: ptr GLfloat) {.importc.} + proc glTexParameterf(target: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glMultiTexCoord1fvARB(target: GLenum, v: ptr GLfloat) {.importc.} + proc glNormalPointerListIBM(`type`: GLenum, stride: GLint, `pointer`: ptr pointer, ptrstride: GLint) {.importc.} + proc glFragmentLightfvSGIX(light: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glViewportArrayv(first: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} + proc glNormal3fVertex3fSUN(nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glMultiTexCoord2dvARB(target: GLenum, v: ptr GLdouble) {.importc.} + proc glCopyColorSubTable(target: GLenum, start: GLsizei, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glTexCoord2hvNV(v: ptr GLhalfNv) {.importc.} + proc glGetQueryObjectiv(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glColor4hNV(red: GLhalfNv, green: GLhalfNv, blue: GLhalfNv, alpha: GLhalfNv) {.importc.} + proc glProgramUniform2fv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glMultiTexCoord4hNV(target: GLenum, s: GLhalfNv, t: GLhalfNv, r: GLhalfNv, q: GLhalfNv) {.importc.} + proc glWindowPos2fvMESA(v: ptr GLfloat) {.importc.} + proc glVertexAttrib3s(index: GLuint, x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glGetIntegerIndexedvEXT(target: GLenum, index: GLuint, data: ptr GLint) {.importc.} + proc glVertexAttrib4Niv(index: GLuint, v: ptr GLint) {.importc.} + proc glProgramLocalParameter4dvARB(target: GLenum, index: GLuint, params: ptr GLdouble) {.importc.} + proc glFramebufferTextureLayerEXT(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint, layer: GLint) {.importc.} + proc glVertexAttribI1ui(index: GLuint, x: GLuint) {.importc.} + proc glFogCoorddv(coord: ptr GLdouble) {.importc.} + proc glLightModelxv(pname: GLenum, param: ptr GLfixed) {.importc.} + proc glGetCombinerOutputParameterfvNV(stage: GLenum, portion: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glFramebufferReadBufferEXT(framebuffer: GLuint, mode: GLenum) {.importc.} + proc glGetActiveUniformsiv(program: GLuint, uniformCount: GLsizei, uniformIndices: ptr GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetProgramStringNV(id: GLuint, pname: GLenum, program: ptr GLubyte) {.importc.} + proc glCopyConvolutionFilter2D(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glMultiTexCoord3iARB(target: GLenum, s: GLint, t: GLint, r: GLint) {.importc.} + proc glPushName(name: GLuint) {.importc.} + proc glProgramParameter4dNV(target: GLenum, index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glVertexAttrib4svARB(index: GLuint, v: ptr GLshort) {.importc.} + proc glSecondaryColor3iv(v: ptr GLint) {.importc.} + proc glCopyColorSubTableEXT(target: GLenum, start: GLsizei, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glCallList(list: GLuint) {.importc.} + proc glGetMultiTexLevelParameterivEXT(texunit: GLenum, target: GLenum, level: GLint, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramUniformMatrix2x4fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glTexBumpParameterivATI(pname: GLenum, param: ptr GLint) {.importc.} + proc glTexGeni(coord: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glSecondaryColor3dv(v: ptr GLdouble) {.importc.} + proc glGetnUniformdvARB(program: GLuint, location: GLint, bufSize: GLsizei, params: ptr GLdouble) {.importc.} + proc glGetNamedProgramLocalParameterdvEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLdouble) {.importc.} + proc glGetVertexAttribPointervARB(index: GLuint, pname: GLenum, `pointer`: ptr pointer) {.importc.} + proc glCopyColorTable(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glNamedFramebufferTextureLayerEXT(framebuffer: GLuint, attachment: GLenum, texture: GLuint, level: GLint, layer: GLint) {.importc.} + proc glLoadProgramNV(target: GLenum, id: GLuint, len: GLsizei, program: ptr GLubyte) {.importc.} + proc glAlphaFragmentOp2ATI(op: GLenum, dst: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint, arg2: GLuint, arg2Rep: GLuint, arg2Mod: GLuint) {.importc.} + proc glBindLightParameterEXT(light: GLenum, value: GLenum): GLuint {.importc.} + proc glVertexAttrib1fv(index: GLuint, v: ptr GLfloat) {.importc.} + proc glLoadIdentity() {.importc.} + proc glFramebufferTexture2DMultisampleEXT(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, samples: GLsizei) {.importc.} + proc glVertexAttrib1dvARB(index: GLuint, v: ptr GLdouble) {.importc.} + proc glDrawRangeElementsBaseVertex(mode: GLenum, start: GLuint, `end`: GLuint, count: GLsizei, `type`: GLenum, indices: pointer, basevertex: GLint) {.importc.} + proc glPixelMapfv(map: GLenum, mapsize: GLsizei, values: ptr GLfloat) {.importc.} + proc glPointParameterxOES(pname: GLenum, param: GLfixed) {.importc.} + proc glBindBufferRangeNV(target: GLenum, index: GLuint, buffer: GLuint, offset: GLintptr, size: GLsizeiptr) {.importc.} + proc glDepthBoundsEXT(zmin: GLclampd, zmax: GLclampd) {.importc.} + proc glProgramUniformMatrix2dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glSecondaryColor3s(red: GLshort, green: GLshort, blue: GLshort) {.importc.} + proc glEdgeFlagPointerEXT(stride: GLsizei, count: GLsizei, `pointer`: ptr GLboolean) {.importc.} + proc glVertexStream1fATI(stream: GLenum, x: GLfloat) {.importc.} + proc glUniformui64NV(location: GLint, value: GLuint64Ext) {.importc.} + proc glTexCoordP4uiv(`type`: GLenum, coords: ptr GLuint) {.importc.} + proc glTexCoord3d(s: GLdouble, t: GLdouble, r: GLdouble) {.importc.} + proc glDeleteProgramPipelines(n: GLsizei, pipelines: ptr GLuint) {.importc.} + proc glVertex2iv(v: ptr GLint) {.importc.} + proc glGetMultisamplefv(pname: GLenum, index: GLuint, val: ptr GLfloat) {.importc.} + proc glStartInstrumentsSGIX() {.importc.} + proc glGetOcclusionQueryivNV(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glDebugMessageCallback(callback: GLdebugProc, userParam: ptr pointer) {.importc.} + proc glPixelZoomxOES(xfactor: GLfixed, yfactor: GLfixed) {.importc.} + proc glTexCoord3i(s: GLint, t: GLint, r: GLint) {.importc.} + proc glEdgeFlagFormatNV(stride: GLsizei) {.importc.} + proc glProgramUniform2i(program: GLuint, location: GLint, v0: GLint, v1: GLint) {.importc.} + proc glColor3b(red: GLbyte, green: GLbyte, blue: GLbyte) {.importc.} + proc glDepthRangefOES(n: GLclampf, f: GLclampf) {.importc.} + proc glEndVertexShaderEXT() {.importc.} + proc glBindVertexArrayAPPLE(`array`: GLuint) {.importc.} + proc glColor4bv(v: ptr GLbyte) {.importc.} + proc glNamedFramebufferTexture2DEXT(framebuffer: GLuint, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glTexCoord1f(s: GLfloat) {.importc.} + proc glUniform3fvARB(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetQueryObjectuivARB(id: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glVertexAttrib4bv(index: GLuint, v: ptr GLbyte) {.importc.} + proc glGetPixelTransformParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttrib3svNV(index: GLuint, v: ptr GLshort) {.importc.} + proc glDeleteQueriesEXT(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glUniform3ivARB(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glNormal3xvOES(coords: ptr GLfixed) {.importc.} + proc glMatrixLoadfEXT(mode: GLenum, m: ptr GLfloat) {.importc.} + proc glGetNamedFramebufferAttachmentParameterivEXT(framebuffer: GLuint, attachment: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glSeparableFilter2D(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, row: pointer, column: pointer) {.importc.} + proc glVertexAttribI3uiv(index: GLuint, v: ptr GLuint) {.importc.} + proc glTextureStorageSparseAMD(texture: GLuint, target: GLenum, internalFormat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, layers: GLsizei, flags: GLbitfield) {.importc.} + proc glMultiDrawArraysIndirectCountARB(mode: GLenum, indirect: GLintptr, drawcount: GLintptr, maxdrawcount: GLsizei, stride: GLsizei) {.importc.} + proc glTranslated(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glColorPointer(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glDrawElementsInstancedBaseVertex(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, instancecount: GLsizei, basevertex: GLint) {.importc.} + proc glBindAttribLocationARB(programObj: GLhandleArb, index: GLuint, name: cstring) {.importc.} + proc glTexGendv(coord: GLenum, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glGetPathCoordsNV(path: GLuint, coords: ptr GLfloat) {.importc.} + proc glGetMapParameterivNV(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glClientAttribDefaultEXT(mask: GLbitfield) {.importc.} + proc glProgramUniformMatrix4x3fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glEnable(cap: GLenum) {.importc.} + proc glGetVertexAttribPointervNV(index: GLuint, pname: GLenum, `pointer`: ptr pointer) {.importc.} + proc glBindMultiTextureEXT(texunit: GLenum, target: GLenum, texture: GLuint) {.importc.} + proc glGetConvolutionParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glLightModelxvOES(pname: GLenum, param: ptr GLfixed) {.importc.} + proc glMultiTexCoord4sv(target: GLenum, v: ptr GLshort) {.importc.} + proc glGetColorTableParameterivSGI(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glFramebufferTexture2DOES(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glClearDepthxOES(depth: GLfixed) {.importc.} + proc glDisableClientStateiEXT(`array`: GLenum, index: GLuint) {.importc.} + proc glWindowPos2dARB(x: GLdouble, y: GLdouble) {.importc.} + proc glVertexAttrib1fvNV(index: GLuint, v: ptr GLfloat) {.importc.} + proc glDepthRangedNV(zNear: GLdouble, zFar: GLdouble) {.importc.} + proc glClear(mask: GLbitfield) {.importc.} + proc glUnmapTexture2DINTEL(texture: GLuint, level: GLint) {.importc.} + proc glSecondaryColor3ub(red: GLubyte, green: GLubyte, blue: GLubyte) {.importc.} + proc glVertexAttribI4bv(index: GLuint, v: ptr GLbyte) {.importc.} + proc glTexRenderbufferNV(target: GLenum, renderbuffer: GLuint) {.importc.} + proc glColor4ubVertex3fvSUN(c: ptr GLubyte, v: ptr GLfloat) {.importc.} + proc glVertexAttrib2svNV(index: GLuint, v: ptr GLshort) {.importc.} + proc glMultiTexCoord1ivARB(target: GLenum, v: ptr GLint) {.importc.} + proc glUniformMatrix3x2dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glVertexAttribL3dvEXT(index: GLuint, v: ptr GLdouble) {.importc.} + proc glMultiTexSubImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGetBufferPointervARB(target: GLenum, pname: GLenum, params: ptr pointer) {.importc.} + proc glGetMultiTexLevelParameterfvEXT(texunit: GLenum, target: GLenum, level: GLint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glMultiTexParameterIuivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glGetShaderSource(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, source: cstring) {.importc.} + proc glStencilFunc(fun: GLenum, `ref`: GLint, mask: GLuint) {.importc.} + proc glVertexAttribI4bvEXT(index: GLuint, v: ptr GLbyte) {.importc.} + proc glVertexAttrib4NuivARB(index: GLuint, v: ptr GLuint) {.importc.} + proc glIsObjectBufferATI(buffer: GLuint): GLboolean {.importc.} + proc glRasterPos2xOES(x: GLfixed, y: GLfixed) {.importc.} + proc glIsFenceNV(fence: GLuint): GLboolean {.importc.} + proc glGetFramebufferParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glClearBufferfv(buffer: GLenum, drawbuffer: GLint, value: ptr GLfloat) {.importc.} + proc glClearColorxOES(red: GLfixed, green: GLfixed, blue: GLfixed, alpha: GLfixed) {.importc.} + proc glVertexWeightfEXT(weight: GLfloat) {.importc.} + proc glExtIsProgramBinaryQCOM(program: GLuint): GLboolean {.importc.} + proc glTextureStorage2DMultisampleEXT(texture: GLuint, target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, fixedsamplelocations: GLboolean) {.importc.} + proc glGetHistogramParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glVertexAttrib4dNV(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glGetPerfMonitorCounterStringAMD(group: GLuint, counter: GLuint, bufSize: GLsizei, length: ptr GLsizei, counterString: cstring) {.importc.} + proc glMultiTexCoord2sARB(target: GLenum, s: GLshort, t: GLshort) {.importc.} + proc glSpriteParameterivSGIX(pname: GLenum, params: ptr GLint) {.importc.} + proc glCompressedTextureImage3DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} + proc glBufferSubData(target: GLenum, offset: GLintptr, size: GLsizeiptr, data: pointer) {.importc.} + proc glBlendParameteriNV(pname: GLenum, value: GLint) {.importc.} + proc glVertexAttrib2fvNV(index: GLuint, v: ptr GLfloat) {.importc.} + proc glGetVariantBooleanvEXT(id: GLuint, value: GLenum, data: ptr GLboolean) {.importc.} + proc glProgramParameteri(program: GLuint, pname: GLenum, value: GLint) {.importc.} + proc glGetLocalConstantIntegervEXT(id: GLuint, value: GLenum, data: ptr GLint) {.importc.} + proc glFragmentMaterialiSGIX(face: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glGetNamedStringivARB(namelen: GLint, name: cstring, pname: GLenum, params: ptr GLint) {.importc.} + proc glBinormal3ivEXT(v: ptr GLint) {.importc.} + proc glCheckFramebufferStatusEXT(target: GLenum): GLenum {.importc.} + proc glVertexAttrib1fNV(index: GLuint, x: GLfloat) {.importc.} + proc glNamedRenderbufferStorageEXT(renderbuffer: GLuint, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glPresentFrameKeyedNV(video_slot: GLuint, minPresentTime: GLuint64Ext, beginPresentTimeId: GLuint, presentDurationId: GLuint, `type`: GLenum, target0: GLenum, fill0: GLuint, key0: GLuint, target1: GLenum, fill1: GLuint, key1: GLuint) {.importc.} + proc glGetObjectParameterfvARB(obj: GLhandleArb, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertex3sv(v: ptr GLshort) {.importc.} + proc glColor4s(red: GLshort, green: GLshort, blue: GLshort, alpha: GLshort) {.importc.} + proc glGetQueryObjecti64vEXT(id: GLuint, pname: GLenum, params: ptr GLint64) {.importc.} + proc glEvalMesh2(mode: GLenum, i1: GLint, i2: GLint, j1: GLint, j2: GLint) {.importc.} + proc glBeginTransformFeedbackEXT(primitiveMode: GLenum) {.importc.} + proc glBufferAddressRangeNV(pname: GLenum, index: GLuint, address: GLuint64Ext, length: GLsizeiptr) {.importc.} + proc glPointParameterfvARB(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetActiveVaryingNV(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: cstring) {.importc.} + proc glIndexMask(mask: GLuint) {.importc.} + proc glVertexAttribBinding(attribindex: GLuint, bindingindex: GLuint) {.importc.} + proc glDeleteFencesNV(n: GLsizei, fences: ptr GLuint) {.importc.} + proc glVertexAttribI4ubv(index: GLuint, v: ptr GLubyte) {.importc.} + proc glPathParameterfvNV(path: GLuint, pname: GLenum, value: ptr GLfloat) {.importc.} + proc glVertexStream3fATI(stream: GLenum, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glVertexAttribs4svNV(index: GLuint, count: GLsizei, v: ptr GLshort) {.importc.} + proc glVertexAttrib4sNV(index: GLuint, x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} + proc glAlphaFragmentOp3ATI(op: GLenum, dst: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint, arg2: GLuint, arg2Rep: GLuint, arg2Mod: GLuint, arg3: GLuint, arg3Rep: GLuint, arg3Mod: GLuint) {.importc.} + proc glGetHistogramParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexAttribL1ui64NV(index: GLuint, x: GLuint64Ext) {.importc.} + proc glVertexAttribs3fvNV(index: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} + proc glMultiTexCoord3ivARB(target: GLenum, v: ptr GLint) {.importc.} + proc glClipPlanefOES(plane: GLenum, equation: ptr GLfloat) {.importc.} + proc glVertex3s(x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glVertex3dv(v: ptr GLdouble) {.importc.} + proc glWeightPointerOES(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glBindBufferBase(target: GLenum, index: GLuint, buffer: GLuint) {.importc.} + proc glIndexs(c: GLshort) {.importc.} + proc glTessellationFactorAMD(factor: GLfloat) {.importc.} + proc glColor4ubVertex3fSUN(r: GLubyte, g: GLubyte, b: GLubyte, a: GLubyte, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glPauseTransformFeedback() {.importc.} + proc glImageTransformParameterivHP(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glColor3dv(v: ptr GLdouble) {.importc.} + proc glRasterPos4sv(v: ptr GLshort) {.importc.} + proc glInvalidateTexSubImage(texture: GLuint, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei) {.importc.} + proc glNormalStream3bvATI(stream: GLenum, coords: ptr GLbyte) {.importc.} + proc glUniformMatrix2x4fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glMinmax(target: GLenum, internalformat: GLenum, sink: GLboolean) {.importc.} + proc glGetProgramStageiv(program: GLuint, shadertype: GLenum, pname: GLenum, values: ptr GLint) {.importc.} + proc glScalex(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glTexBufferARB(target: GLenum, internalformat: GLenum, buffer: GLuint) {.importc.} + proc glDrawArraysIndirect(mode: GLenum, indirect: pointer) {.importc.} + proc glMatrixLoadTransposefEXT(mode: GLenum, m: ptr GLfloat) {.importc.} + proc glMultiTexCoord2f(target: GLenum, s: GLfloat, t: GLfloat) {.importc.} + proc glDrawRangeElements(mode: GLenum, start: GLuint, `end`: GLuint, count: GLsizei, `type`: GLenum, indices: pointer) {.importc.} + proc glVertexAttrib4NubARB(index: GLuint, x: GLubyte, y: GLubyte, z: GLubyte, w: GLubyte) {.importc.} + proc glMultiTexCoord4xvOES(texture: GLenum, coords: ptr GLfixed) {.importc.} + proc glVertexArrayVertexAttribOffsetEXT(vaobj: GLuint, buffer: GLuint, index: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, stride: GLsizei, offset: GLintptr) {.importc.} + proc glVertexAttribL1i64vNV(index: GLuint, v: ptr GLint64Ext) {.importc.} + proc glMapBuffer(target: GLenum, access: GLenum): pointer {.importc.} + proc glUniform1ui(location: GLint, v0: GLuint) {.importc.} + proc glGetPixelMapfv(map: GLenum, values: ptr GLfloat) {.importc.} + proc glTexImage2DMultisampleCoverageNV(target: GLenum, coverageSamples: GLsizei, colorSamples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, fixedSampleLocations: GLboolean) {.importc.} + proc glUniform2ivARB(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glVertexAttribI3ui(index: GLuint, x: GLuint, y: GLuint, z: GLuint) {.importc.} + proc glGetProgramResourceiv(program: GLuint, programInterface: GLenum, index: GLuint, propCount: GLsizei, props: ptr GLenum, bufSize: GLsizei, length: ptr GLsizei, params: ptr GLint) {.importc.} + proc glUniform4iv(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glVertexAttrib3f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glClientActiveVertexStreamATI(stream: GLenum) {.importc.} + proc glTexCoord4fColor4fNormal3fVertex4fvSUN(tc: ptr GLfloat, c: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glColor3xvOES(components: ptr GLfixed) {.importc.} + proc glVertexPointerListIBM(size: GLint, `type`: GLenum, stride: GLint, `pointer`: ptr pointer, ptrstride: GLint) {.importc.} + proc glProgramEnvParameter4dARB(target: GLenum, index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glGetLocalConstantFloatvEXT(id: GLuint, value: GLenum, data: ptr GLfloat) {.importc.} + proc glTexCoordPointerEXT(size: GLint, `type`: GLenum, stride: GLsizei, count: GLsizei, `pointer`: pointer) {.importc.} + proc glTexCoordPointervINTEL(size: GLint, `type`: GLenum, `pointer`: ptr pointer) {.importc.} + proc glSelectPerfMonitorCountersAMD(monitor: GLuint, enable: GLboolean, group: GLuint, numCounters: GLint, counterList: ptr GLuint) {.importc.} + proc glVertexStream4svATI(stream: GLenum, coords: ptr GLshort) {.importc.} + proc glColor3ui(red: GLuint, green: GLuint, blue: GLuint) {.importc.} + proc glBindTransformFeedbackNV(target: GLenum, id: GLuint) {.importc.} + proc glDeformSGIX(mask: GLbitfield) {.importc.} + proc glDeformationMap3fSGIX(target: GLenum, u1: GLfloat, u2: GLfloat, ustride: GLint, uorder: GLint, v1: GLfloat, v2: GLfloat, vstride: GLint, vorder: GLint, w1: GLfloat, w2: GLfloat, wstride: GLint, worder: GLint, points: ptr GLfloat) {.importc.} + proc glNamedBufferSubDataEXT(buffer: GLuint, offset: GLintptr, size: GLsizeiptr, data: pointer) {.importc.} + proc glGetNamedProgramStringEXT(program: GLuint, target: GLenum, pname: GLenum, string: pointer) {.importc.} + proc glCopyPathNV(resultPath: GLuint, srcPath: GLuint) {.importc.} + proc glMapControlPointsNV(target: GLenum, index: GLuint, `type`: GLenum, ustride: GLsizei, vstride: GLsizei, uorder: GLint, vorder: GLint, packed: GLboolean, points: pointer) {.importc.} + proc glGetBufferParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glUnmapObjectBufferATI(buffer: GLuint) {.importc.} + proc glGetProgramResourceLocation(program: GLuint, programInterface: GLenum, name: cstring): GLint {.importc.} + proc glUniform4i64vNV(location: GLint, count: GLsizei, value: ptr GLint64Ext) {.importc.} + proc glImageTransformParameterfHP(target: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glArrayObjectATI(`array`: GLenum, size: GLint, `type`: GLenum, stride: GLsizei, buffer: GLuint, offset: GLuint) {.importc.} + proc glBindBufferRangeEXT(target: GLenum, index: GLuint, buffer: GLuint, offset: GLintptr, size: GLsizeiptr) {.importc.} + proc glVertexArrayVertexAttribFormatEXT(vaobj: GLuint, attribindex: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, relativeoffset: GLuint) {.importc.} + proc glBindRenderbufferEXT(target: GLenum, renderbuffer: GLuint) {.importc.} + proc glListParameteriSGIX(list: GLuint, pname: GLenum, param: GLint) {.importc.} + proc glProgramUniformMatrix2dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glProgramUniform2i64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint64Ext) {.importc.} + proc glObjectPtrLabelKHR(`ptr`: ptr pointer, length: GLsizei, label: cstring) {.importc.} + proc glVertexAttribL1i64NV(index: GLuint, x: GLint64Ext) {.importc.} + proc glMultiTexBufferEXT(texunit: GLenum, target: GLenum, internalformat: GLenum, buffer: GLuint) {.importc.} + proc glCoverFillPathInstancedNV(numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, coverMode: GLenum, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} + proc glGetVertexAttribIivEXT(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glLightf(light: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glGetMinmaxParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glUniform1d(location: GLint, x: GLdouble) {.importc.} + proc glLightiv(light: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttrib2dvNV(index: GLuint, v: ptr GLdouble) {.importc.} + proc glNormalP3ui(`type`: GLenum, coords: GLuint) {.importc.} + proc glFinalCombinerInputNV(variable: GLenum, input: GLenum, mapping: GLenum, componentUsage: GLenum) {.importc.} + proc glUniform1uiv(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glValidateProgramARB(programObj: GLhandleArb) {.importc.} + proc glNormalPointer(`type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glProgramNamedParameter4fvNV(id: GLuint, len: GLsizei, name: ptr GLubyte, v: ptr GLfloat) {.importc.} + proc glGetBooleanv(pname: GLenum, params: ptr GLboolean) {.importc.} + proc glTangent3ivEXT(v: ptr GLint) {.importc.} + proc glTexImage3DMultisample(target: GLenum, samples: GLsizei, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, fixedsamplelocations: GLboolean) {.importc.} + proc glGetUniformIndices(program: GLuint, uniformCount: GLsizei, uniformNames: cstringArray, uniformIndices: ptr GLuint) {.importc.} + proc glVDPAUInitNV(vdpDevice: pointer, getProcAddress: pointer) {.importc.} + proc glGetMinmaxParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMultiTexCoord2fvARB(target: GLenum, v: ptr GLfloat) {.importc.} + proc glProgramEnvParametersI4ivNV(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLint) {.importc.} + proc glClearTexSubImage(texture: GLuint, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, data: ptr pointer) {.importc.} + proc glRectxOES(x1: GLfixed, y1: GLfixed, x2: GLfixed, y2: GLfixed) {.importc.} + proc glBlendEquationOES(mode: GLenum) {.importc.} + proc glFramebufferTexture(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glGetInstrumentsSGIX(): GLint {.importc.} + proc glFramebufferParameteri(target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glPathCoverDepthFuncNV(fun: GLenum) {.importc.} + proc glGetTranslatedShaderSourceANGLE(shader: GLuint, bufsize: GLsizei, length: ptr GLsizei, source: cstring) {.importc.} + proc glIndexfv(c: ptr GLfloat) {.importc.} + proc glGetActiveUniformBlockName(program: GLuint, uniformBlockIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformBlockName: cstring) {.importc.} + proc glNormal3s(nx: GLshort, ny: GLshort, nz: GLshort) {.importc.} + proc glColorFragmentOp3ATI(op: GLenum, dst: GLuint, dstMask: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint, arg2: GLuint, arg2Rep: GLuint, arg2Mod: GLuint, arg3: GLuint, arg3Rep: GLuint, arg3Mod: GLuint) {.importc.} + proc glGetProgramResourceLocationIndex(program: GLuint, programInterface: GLenum, name: cstring): GLint {.importc.} + proc glGetBooleanIndexedvEXT(target: GLenum, index: GLuint, data: ptr GLboolean) {.importc.} + proc glGenPerfMonitorsAMD(n: GLsizei, monitors: ptr GLuint) {.importc.} + proc glDrawRangeElementsEXT(mode: GLenum, start: GLuint, `end`: GLuint, count: GLsizei, `type`: GLenum, indices: pointer) {.importc.} + proc glFramebufferTexture3D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, zoffset: GLint) {.importc.} + proc glGetTexParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glCompileShaderIncludeARB(shader: GLuint, count: GLsizei, path: cstringArray, length: ptr GLint) {.importc.} + proc glGetMultiTexParameterfvEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glEvalPoint2(i: GLint, j: GLint) {.importc.} + proc glGetProgramivNV(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramParameter4fNV(target: GLenum, index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glMultiTexParameterfvEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexAttrib3svARB(index: GLuint, v: ptr GLshort) {.importc.} + proc glDrawElementArrayAPPLE(mode: GLenum, first: GLint, count: GLsizei) {.importc.} + proc glMultiTexCoord4x(texture: GLenum, s: GLfixed, t: GLfixed, r: GLfixed, q: GLfixed) {.importc.} + proc glUniformMatrix3dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glVertexAttribPointerARB(index: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glProgramUniformMatrix3x4dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glGetFloati_vEXT(pname: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} + proc glGetObjectParameterivAPPLE(objectType: GLenum, name: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glPushGroupMarkerEXT(length: GLsizei, marker: cstring) {.importc.} + proc glProgramUniform4uivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glReplacementCodeuiVertex3fSUN(rc: GLuint, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glTexSubImage1DEXT(target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glProgramUniform1uivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glGetFenceivNV(fence: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetnCompressedTexImageARB(target: GLenum, lod: GLint, bufSize: GLsizei, img: pointer) {.importc.} + proc glTexGenfOES(coord: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glVertexAttrib4dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glVertexAttribL1ui64vNV(index: GLuint, v: ptr GLuint64Ext) {.importc.} + proc glVertexAttrib4fvARB(index: GLuint, v: ptr GLfloat) {.importc.} + proc glDeleteVertexArraysOES(n: GLsizei, arrays: ptr GLuint) {.importc.} + proc glSamplerParameterIiv(sampler: GLuint, pname: GLenum, param: ptr GLint) {.importc.} + proc glMapGrid1d(un: GLint, u1: GLdouble, u2: GLdouble) {.importc.} + proc glTranslatexOES(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glCullFace(mode: GLenum) {.importc.} + proc glPrioritizeTextures(n: GLsizei, textures: ptr GLuint, priorities: ptr GLfloat) {.importc.} + proc glGetSeparableFilterEXT(target: GLenum, format: GLenum, `type`: GLenum, row: pointer, column: pointer, span: pointer) {.importc.} + proc glVertexAttrib4NubvARB(index: GLuint, v: ptr GLubyte) {.importc.} + proc glGetTransformFeedbackVaryingNV(program: GLuint, index: GLuint, location: ptr GLint) {.importc.} + proc glTexCoord4xOES(s: GLfixed, t: GLfixed, r: GLfixed, q: GLfixed) {.importc.} + proc glGetProgramEnvParameterdvARB(target: GLenum, index: GLuint, params: ptr GLdouble) {.importc.} + proc glWindowPos2ivMESA(v: ptr GLint) {.importc.} + proc glGlobalAlphaFactorfSUN(factor: GLfloat) {.importc.} + proc glNormalStream3fvATI(stream: GLenum, coords: ptr GLfloat) {.importc.} + proc glRasterPos4i(x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glReleaseShaderCompiler() {.importc.} + proc glProgramUniformMatrix4fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glCopyMultiTexImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, border: GLint) {.importc.} + proc glColorTableParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glSecondaryColor3bvEXT(v: ptr GLbyte) {.importc.} + proc glMap1xOES(target: GLenum, u1: GLfixed, u2: GLfixed, stride: GLint, order: GLint, points: GLfixed) {.importc.} + proc glVertexStream1svATI(stream: GLenum, coords: ptr GLshort) {.importc.} + proc glIsRenderbuffer(renderbuffer: GLuint): GLboolean {.importc.} + proc glPatchParameterfv(pname: GLenum, values: ptr GLfloat) {.importc.} + proc glProgramUniformMatrix4dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glVertexAttrib4ubNV(index: GLuint, x: GLubyte, y: GLubyte, z: GLubyte, w: GLubyte) {.importc.} + proc glVertex2i(x: GLint, y: GLint) {.importc.} + proc glPushClientAttrib(mask: GLbitfield) {.importc.} + proc glDrawArraysEXT(mode: GLenum, first: GLint, count: GLsizei) {.importc.} + proc glCreateProgram(): GLuint {.importc.} + proc glPolygonStipple(mask: ptr GLubyte) {.importc.} + proc glGetColorTableEXT(target: GLenum, format: GLenum, `type`: GLenum, data: pointer) {.importc.} + proc glSharpenTexFuncSGIS(target: GLenum, n: GLsizei, points: ptr GLfloat) {.importc.} + proc glNamedFramebufferTextureEXT(framebuffer: GLuint, attachment: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glWindowPos3fvMESA(v: ptr GLfloat) {.importc.} + proc glBinormal3iEXT(bx: GLint, by: GLint, bz: GLint) {.importc.} + proc glEnableClientStateiEXT(`array`: GLenum, index: GLuint) {.importc.} + proc glProgramUniform3iv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glProgramUniform1dEXT(program: GLuint, location: GLint, x: GLdouble) {.importc.} + proc glPollInstrumentsSGIX(marker_p: ptr GLint): GLint {.importc.} + proc glSecondaryColor3f(red: GLfloat, green: GLfloat, blue: GLfloat) {.importc.} + proc glDeleteTransformFeedbacks(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glCoverStrokePathInstancedNV(numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, coverMode: GLenum, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} + proc glIsTextureHandleResidentARB(handle: GLuint64): GLboolean {.importc.} + proc glVariantsvEXT(id: GLuint, `addr`: ptr GLshort) {.importc.} + proc glTexCoordFormatNV(size: GLint, `type`: GLenum, stride: GLsizei) {.importc.} + proc glTexStorage3DEXT(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei) {.importc.} + proc glUniform2ui(location: GLint, v0: GLuint, v1: GLuint) {.importc.} + proc glReplacementCodePointerSUN(`type`: GLenum, stride: GLsizei, `pointer`: ptr pointer) {.importc.} + proc glFramebufferTextureLayerARB(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint, layer: GLint) {.importc.} + proc glBinormal3dvEXT(v: ptr GLdouble) {.importc.} + proc glProgramUniform2ui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64Ext) {.importc.} + proc glGetnConvolutionFilterARB(target: GLenum, format: GLenum, `type`: GLenum, bufSize: GLsizei, image: pointer) {.importc.} + proc glStopInstrumentsSGIX(marker: GLint) {.importc.} + proc glVertexAttrib1svNV(index: GLuint, v: ptr GLshort) {.importc.} + proc glVertexAttribs2fvNV(index: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} + proc glGetInternalformativ(target: GLenum, internalformat: GLenum, pname: GLenum, bufSize: GLsizei, params: ptr GLint) {.importc.} + proc glIsProgramPipelineEXT(pipeline: GLuint): GLboolean {.importc.} + proc glMatrixIndexubvARB(size: GLint, indices: ptr GLubyte) {.importc.} + proc glTexCoord4bOES(s: GLbyte, t: GLbyte, r: GLbyte, q: GLbyte) {.importc.} + proc glSecondaryColor3us(red: GLushort, green: GLushort, blue: GLushort) {.importc.} + proc glGlobalAlphaFactorubSUN(factor: GLubyte) {.importc.} + proc glNamedStringARB(`type`: GLenum, namelen: GLint, name: cstring, stringlen: GLint, string: cstring) {.importc.} + proc glGetAttachedShaders(program: GLuint, maxCount: GLsizei, count: ptr GLsizei, shaders: ptr GLuint) {.importc.} + proc glMatrixRotatefEXT(mode: GLenum, angle: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glVertexStream3ivATI(stream: GLenum, coords: ptr GLint) {.importc.} + proc glMatrixIndexuivARB(size: GLint, indices: ptr GLuint) {.importc.} + proc glMatrixRotatedEXT(mode: GLenum, angle: GLdouble, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glPathFogGenNV(genMode: GLenum) {.importc.} + proc glMultiTexCoord4hvNV(target: GLenum, v: ptr GLhalfNv) {.importc.} + proc glVertexAttribIPointer(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glMultiTexCoord3bOES(texture: GLenum, s: GLbyte, t: GLbyte, r: GLbyte) {.importc.} + proc glResizeBuffersMESA() {.importc.} + proc glPrimitiveRestartIndexNV(index: GLuint) {.importc.} + proc glProgramUniform4f(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat, v3: GLfloat) {.importc.} + proc glColor4ubVertex2fSUN(r: GLubyte, g: GLubyte, b: GLubyte, a: GLubyte, x: GLfloat, y: GLfloat) {.importc.} + proc glGetColorTableParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glDepthRangef(n: GLfloat, f: GLfloat) {.importc.} + proc glVertexArrayVertexOffsetEXT(vaobj: GLuint, buffer: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glMatrixLoaddEXT(mode: GLenum, m: ptr GLdouble) {.importc.} + proc glVariantfvEXT(id: GLuint, `addr`: ptr GLfloat) {.importc.} + proc glReplacementCodeuiTexCoord2fVertex3fvSUN(rc: ptr GLuint, tc: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glSamplePatternSGIS(pattern: GLenum) {.importc.} + proc glProgramUniform3i64NV(program: GLuint, location: GLint, x: GLint64Ext, y: GLint64Ext, z: GLint64Ext) {.importc.} + proc glUniform3uivEXT(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glGetImageTransformParameterivHP(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glPopMatrix() {.importc.} + proc glVertexAttrib3sARB(index: GLuint, x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glGenQueriesEXT(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glGetQueryObjectui64v(id: GLuint, pname: GLenum, params: ptr GLuint64) {.importc.} + proc glWeightusvARB(size: GLint, weights: ptr GLushort) {.importc.} + proc glWindowPos2sARB(x: GLshort, y: GLshort) {.importc.} + proc glGetTextureLevelParameterivEXT(texture: GLuint, target: GLenum, level: GLint, pname: GLenum, params: ptr GLint) {.importc.} + proc glBufferParameteriAPPLE(target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glMultiModeDrawArraysIBM(mode: ptr GLenum, first: ptr GLint, count: ptr GLsizei, primcount: GLsizei, modestride: GLint) {.importc.} + proc glUniformMatrix2x3fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glTangentPointerEXT(`type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glResetMinmax(target: GLenum) {.importc.} + proc glVertexAttribP1uiv(index: GLuint, `type`: GLenum, normalized: GLboolean, value: ptr GLuint) {.importc.} + proc glPixelMapx(map: GLenum, size: GLint, values: ptr GLfixed) {.importc.} + proc glPixelStoref(pname: GLenum, param: GLfloat) {.importc.} + proc glBinormal3dEXT(bx: GLdouble, by: GLdouble, bz: GLdouble) {.importc.} + proc glVertexAttribs1hvNV(index: GLuint, n: GLsizei, v: ptr GLhalfNv) {.importc.} + proc glVertexAttrib4usvARB(index: GLuint, v: ptr GLushort) {.importc.} + proc glUnmapBuffer(target: GLenum): GLboolean {.importc.} + proc glFlushRasterSGIX() {.importc.} + proc glColor3uiv(v: ptr GLuint) {.importc.} + proc glInvalidateBufferSubData(buffer: GLuint, offset: GLintptr, length: GLsizeiptr) {.importc.} + proc glPassThroughxOES(token: GLfixed) {.importc.} + proc glLockArraysEXT(first: GLint, count: GLsizei) {.importc.} + proc glStencilFuncSeparateATI(frontfunc: GLenum, backfunc: GLenum, `ref`: GLint, mask: GLuint) {.importc.} + proc glProgramUniform3dvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glGenTransformFeedbacks(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glCopyTexSubImage3DOES(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glIsNamedBufferResidentNV(buffer: GLuint): GLboolean {.importc.} + proc glSampleMaskIndexedNV(index: GLuint, mask: GLbitfield) {.importc.} + proc glVDPAUSurfaceAccessNV(surface: GLvdpauSurfaceNv, access: GLenum) {.importc.} + proc glProgramUniform3dv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glDeleteProgram(program: GLuint) {.importc.} + proc glConvolutionFilter1D(target: GLenum, internalformat: GLenum, width: GLsizei, format: GLenum, `type`: GLenum, image: pointer) {.importc.} + proc glVertex2f(x: GLfloat, y: GLfloat) {.importc.} + proc glWindowPos4dvMESA(v: ptr GLdouble) {.importc.} + proc glColor4us(red: GLushort, green: GLushort, blue: GLushort, alpha: GLushort) {.importc.} + proc glColorMask(red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean) {.importc.} + proc glGetTexEnviv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramUniform3ivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glSecondaryColor3i(red: GLint, green: GLint, blue: GLint) {.importc.} + proc glGetSamplerParameteriv(sampler: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glDeleteFramebuffersEXT(n: GLsizei, framebuffers: ptr GLuint) {.importc.} + proc glCompressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, data: pointer) {.importc.} + proc glVertex2s(x: GLshort, y: GLshort) {.importc.} + proc glIsQuery(id: GLuint): GLboolean {.importc.} + proc glFogxv(pname: GLenum, param: ptr GLfixed) {.importc.} + proc glAreProgramsResidentNV(n: GLsizei, programs: ptr GLuint, residences: ptr GLboolean): GLboolean {.importc.} + proc glShaderSourceARB(shaderObj: GLhandleArb, count: GLsizei, string: cstringArray, length: ptr GLint) {.importc.} + proc glPointSizexOES(size: GLfixed) {.importc.} + proc glPixelTransferf(pname: GLenum, param: GLfloat) {.importc.} + proc glExtractComponentEXT(res: GLuint, src: GLuint, num: GLuint) {.importc.} + proc glUniform1fv(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetNamedStringARB(namelen: GLint, name: cstring, bufSize: GLsizei, stringlen: ptr GLint, string: cstring) {.importc.} + proc glGetProgramBinaryOES(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, binaryFormat: ptr GLenum, binary: pointer) {.importc.} + proc glDeleteOcclusionQueriesNV(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glEnableClientState(`array`: GLenum) {.importc.} + proc glProgramBufferParametersIuivNV(target: GLenum, bindingIndex: GLuint, wordIndex: GLuint, count: GLsizei, params: ptr GLuint) {.importc.} + proc glProgramUniform2ui(program: GLuint, location: GLint, v0: GLuint, v1: GLuint) {.importc.} + proc glReplacementCodeuiSUN(code: GLuint) {.importc.} + proc glMultMatrixd(m: ptr GLdouble) {.importc.} + proc glInvalidateSubFramebuffer(target: GLenum, numAttachments: GLsizei, attachments: ptr GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glGenerateMultiTexMipmapEXT(texunit: GLenum, target: GLenum) {.importc.} + proc glDepthRangex(n: GLfixed, f: GLfixed) {.importc.} + proc glGetInteger64i_v(target: GLenum, index: GLuint, data: ptr GLint64) {.importc.} + proc glDrawBuffers(n: GLsizei, bufs: ptr GLenum) {.importc.} + proc glGetPointervEXT(pname: GLenum, params: ptr pointer) {.importc.} + proc glFogxvOES(pname: GLenum, param: ptr GLfixed) {.importc.} + proc glTexCoordP2uiv(`type`: GLenum, coords: ptr GLuint) {.importc.} + proc glVertexFormatNV(size: GLint, `type`: GLenum, stride: GLsizei) {.importc.} + proc glColorPointervINTEL(size: GLint, `type`: GLenum, `pointer`: ptr pointer) {.importc.} + proc glGetMultiTexParameterivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMultiTexCoordP4uiv(texture: GLenum, `type`: GLenum, coords: ptr GLuint) {.importc.} + proc glResetMinmaxEXT(target: GLenum) {.importc.} + proc glCopyBufferSubData(readTarget: GLenum, writeTarget: GLenum, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr) {.importc.} + proc glSecondaryColor3sv(v: ptr GLshort) {.importc.} + proc glPixelStorex(pname: GLenum, param: GLfixed) {.importc.} + proc glWaitSync(sync: GLsync, flags: GLbitfield, timeout: GLuint64) {.importc.} + proc glVertexAttribI1iv(index: GLuint, v: ptr GLint) {.importc.} + proc glColorSubTableEXT(target: GLenum, start: GLsizei, count: GLsizei, format: GLenum, `type`: GLenum, data: pointer) {.importc.} + proc glGetDoublev(pname: GLenum, params: ptr GLdouble) {.importc.} + proc glMultiTexParameterivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMultiTexCoord4svARB(target: GLenum, v: ptr GLshort) {.importc.} + proc glColorPointerListIBM(size: GLint, `type`: GLenum, stride: GLint, `pointer`: ptr pointer, ptrstride: GLint) {.importc.} + proc glScissorIndexed(index: GLuint, left: GLint, bottom: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glStencilOpSeparateATI(face: GLenum, sfail: GLenum, dpfail: GLenum, dppass: GLenum) {.importc.} + proc glLoadName(name: GLuint) {.importc.} + proc glIsTransformFeedbackNV(id: GLuint): GLboolean {.importc.} + proc glPopDebugGroup() {.importc.} + proc glClipPlanef(p: GLenum, eqn: ptr GLfloat) {.importc.} + proc glDeleteFencesAPPLE(n: GLsizei, fences: ptr GLuint) {.importc.} + proc glGetQueryObjecti64v(id: GLuint, pname: GLenum, params: ptr GLint64) {.importc.} + proc glAlphaFunc(fun: GLenum, `ref`: GLfloat) {.importc.} + proc glIndexPointerEXT(`type`: GLenum, stride: GLsizei, count: GLsizei, `pointer`: pointer) {.importc.} + proc glVertexAttribI3ivEXT(index: GLuint, v: ptr GLint) {.importc.} + proc glIndexub(c: GLubyte) {.importc.} + proc glVertexP2uiv(`type`: GLenum, value: ptr GLuint) {.importc.} + proc glProgramUniform1uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glDebugMessageInsertKHR(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: cstring) {.importc.} + proc glColor4b(red: GLbyte, green: GLbyte, blue: GLbyte, alpha: GLbyte) {.importc.} + proc glRenderbufferStorageMultisampleAPPLE(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glMinSampleShading(value: GLfloat) {.importc.} + proc glBindProgramNV(target: GLenum, id: GLuint) {.importc.} + proc glWindowPos3dMESA(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glEdgeFlagPointer(stride: GLsizei, `pointer`: pointer) {.importc.} + proc glGetFragDataIndex(program: GLuint, name: cstring): GLint {.importc.} + proc glTexCoord3hNV(s: GLhalfNv, t: GLhalfNv, r: GLhalfNv) {.importc.} + proc glMultiDrawArraysIndirectAMD(mode: GLenum, indirect: pointer, primcount: GLsizei, stride: GLsizei) {.importc.} + proc glFragmentColorMaterialSGIX(face: GLenum, mode: GLenum) {.importc.} + proc glTexGenf(coord: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glVertexAttrib4ubvARB(index: GLuint, v: ptr GLubyte) {.importc.} + proc glClearBufferiv(buffer: GLenum, drawbuffer: GLint, value: ptr GLint) {.importc.} + proc glGenQueriesARB(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glRectdv(v1: ptr GLdouble, v2: ptr GLdouble) {.importc.} + proc glBlendEquationSeparateEXT(modeRgb: GLenum, modeAlpha: GLenum) {.importc.} + proc glTestFenceAPPLE(fence: GLuint): GLboolean {.importc.} + proc glTexGeniv(coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glPolygonMode(face: GLenum, mode: GLenum) {.importc.} + proc glFrameZoomSGIX(factor: GLint) {.importc.} + proc glReplacementCodeuiTexCoord2fVertex3fSUN(rc: GLuint, s: GLfloat, t: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glUniformSubroutinesuiv(shadertype: GLenum, count: GLsizei, indices: ptr GLuint) {.importc.} + proc glBeginQueryIndexed(target: GLenum, index: GLuint, id: GLuint) {.importc.} + proc glMultiTexGeniEXT(texunit: GLenum, coord: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glRasterPos3fv(v: ptr GLfloat) {.importc.} + proc glMapObjectBufferATI(buffer: GLuint): pointer {.importc.} + proc glIndexiv(c: ptr GLint) {.importc.} + proc glVertexAttribLPointer(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glMultiTexCoord4s(target: GLenum, s: GLshort, t: GLshort, r: GLshort, q: GLshort) {.importc.} + proc glSecondaryColorP3uiv(`type`: GLenum, color: ptr GLuint) {.importc.} + proc glNormalFormatNV(`type`: GLenum, stride: GLsizei) {.importc.} + proc glVertex4i(x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glUniform1ui64NV(location: GLint, x: GLuint64Ext) {.importc.} + proc glScissorIndexedv(index: GLuint, v: ptr GLint) {.importc.} + proc glProgramUniform1i(program: GLuint, location: GLint, v0: GLint) {.importc.} + proc glCompressedMultiTexSubImage3DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} + proc glFinishTextureSUNX() {.importc.} + proc glFramebufferTexture3DEXT(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, zoffset: GLint) {.importc.} + proc glSetInvariantEXT(id: GLuint, `type`: GLenum, `addr`: pointer) {.importc.} + proc glGetTexParameterIivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMultiTexCoordP3ui(texture: GLenum, `type`: GLenum, coords: GLuint) {.importc.} + proc glMultiTexCoord3f(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat) {.importc.} + proc glNormalStream3fATI(stream: GLenum, nx: GLfloat, ny: GLfloat, nz: GLfloat) {.importc.} + proc glActiveShaderProgram(pipeline: GLuint, program: GLuint) {.importc.} + proc glDisableVertexArrayEXT(vaobj: GLuint, `array`: GLenum) {.importc.} + proc glVertexAttribI3iv(index: GLuint, v: ptr GLint) {.importc.} + proc glProvokingVertex(mode: GLenum) {.importc.} + proc glTexCoord1fv(v: ptr GLfloat) {.importc.} + proc glVertexAttrib3fv(index: GLuint, v: ptr GLfloat) {.importc.} + proc glWindowPos3iv(v: ptr GLint) {.importc.} + proc glProgramUniform4ui64NV(program: GLuint, location: GLint, x: GLuint64Ext, y: GLuint64Ext, z: GLuint64Ext, w: GLuint64Ext) {.importc.} + proc glProgramUniform2d(program: GLuint, location: GLint, v0: GLdouble, v1: GLdouble) {.importc.} + proc glDebugMessageInsertARB(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: cstring) {.importc.} + proc glMultiTexSubImage3DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glMap1d(target: GLenum, u1: GLdouble, u2: GLdouble, stride: GLint, order: GLint, points: ptr GLdouble) {.importc.} + proc glDeleteShader(shader: GLuint) {.importc.} + proc glTexturePageCommitmentEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, resident: GLboolean) {.importc.} + proc glFramebufferDrawBufferEXT(framebuffer: GLuint, mode: GLenum) {.importc.} + proc glTexCoord2fNormal3fVertex3fSUN(s: GLfloat, t: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glDeleteProgramsNV(n: GLsizei, programs: ptr GLuint) {.importc.} + proc glPointAlongPathNV(path: GLuint, startSegment: GLsizei, numSegments: GLsizei, distance: GLfloat, x: ptr GLfloat, y: ptr GLfloat, tangentX: ptr GLfloat, tangentY: ptr GLfloat): GLboolean {.importc.} + proc glTexCoord1d(s: GLdouble) {.importc.} + proc glStencilStrokePathNV(path: GLuint, reference: GLint, mask: GLuint) {.importc.} + proc glQueryMatrixxOES(mantissa: ptr GLfixed, exponent: ptr GLint): GLbitfield {.importc.} + proc glGetNamedProgramLocalParameterIuivEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} + proc glGenerateMipmapOES(target: GLenum) {.importc.} + proc glRenderbufferStorageMultisampleIMG(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glVertexBlendEnviATI(pname: GLenum, param: GLint) {.importc.} + proc glPushAttrib(mask: GLbitfield) {.importc.} + proc glShaderOp3EXT(op: GLenum, res: GLuint, arg1: GLuint, arg2: GLuint, arg3: GLuint) {.importc.} + proc glEnableVertexAttribArray(index: GLuint) {.importc.} + proc glVertexAttrib4Nbv(index: GLuint, v: ptr GLbyte) {.importc.} + proc glExtGetBuffersQCOM(buffers: ptr GLuint, maxBuffers: GLint, numBuffers: ptr GLint) {.importc.} + proc glCopyTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glDeletePerfMonitorsAMD(n: GLsizei, monitors: ptr GLuint) {.importc.} + proc glGetTrackMatrixivNV(target: GLenum, address: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glEndConditionalRender() {.importc.} + proc glVertexAttribL3i64NV(index: GLuint, x: GLint64Ext, y: GLint64Ext, z: GLint64Ext) {.importc.} + proc glProgramLocalParametersI4ivNV(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLint) {.importc.} + proc glFlush() {.importc.} + proc glGetNamedBufferParameterui64vNV(buffer: GLuint, pname: GLenum, params: ptr GLuint64Ext) {.importc.} + proc glGetVertexArrayIntegeri_vEXT(vaobj: GLuint, index: GLuint, pname: GLenum, param: ptr GLint) {.importc.} + proc glReadnPixelsEXT(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, bufSize: GLsizei, data: pointer) {.importc.} + proc glMultiTexImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGetVaryingLocationNV(program: GLuint, name: cstring): GLint {.importc.} + proc glMultiTexCoord4fvARB(target: GLenum, v: ptr GLfloat) {.importc.} + proc glMultiTexCoord3iv(target: GLenum, v: ptr GLint) {.importc.} + proc glVertexAttribL2dvEXT(index: GLuint, v: ptr GLdouble) {.importc.} + proc glTexParameterxOES(target: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glSecondaryColor3uivEXT(v: ptr GLuint) {.importc.} + proc glReadnPixelsARB(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, bufSize: GLsizei, data: pointer) {.importc.} + proc glCopyTexSubImage1DEXT(target: GLenum, level: GLint, xoffset: GLint, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glGetDoublei_vEXT(pname: GLenum, index: GLuint, params: ptr GLdouble) {.importc.} + proc glVariantPointerEXT(id: GLuint, `type`: GLenum, stride: GLuint, `addr`: pointer) {.importc.} + proc glProgramUniform3ui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64Ext) {.importc.} + proc glTexCoord2fColor3fVertex3fvSUN(tc: ptr GLfloat, c: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glProgramUniform3fv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glBindFragDataLocationIndexed(program: GLuint, colorNumber: GLuint, index: GLuint, name: cstring) {.importc.} + proc glGetnSeparableFilterARB(target: GLenum, format: GLenum, `type`: GLenum, rowBufSize: GLsizei, row: pointer, columnBufSize: GLsizei, column: pointer, span: pointer) {.importc.} + proc glTextureParameteriEXT(texture: GLuint, target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glGetUniformuivEXT(program: GLuint, location: GLint, params: ptr GLuint) {.importc.} + proc glFragmentMaterialivSGIX(face: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMultiTexCoord1svARB(target: GLenum, v: ptr GLshort) {.importc.} + proc glClientActiveTextureARB(texture: GLenum) {.importc.} + proc glVertexAttrib1fARB(index: GLuint, x: GLfloat) {.importc.} + proc glVertexAttrib4NbvARB(index: GLuint, v: ptr GLbyte) {.importc.} + proc glRasterPos2d(x: GLdouble, y: GLdouble) {.importc.} + proc glMultiTexCoord4iARB(target: GLenum, s: GLint, t: GLint, r: GLint, q: GLint) {.importc.} + proc glGetPixelTexGenParameterfvSGIS(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexAttribL2dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glGetProgramStringARB(target: GLenum, pname: GLenum, string: pointer) {.importc.} + proc glRasterPos2i(x: GLint, y: GLint) {.importc.} + proc glTexCoord2fColor4fNormal3fVertex3fvSUN(tc: ptr GLfloat, c: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glMultiTexCoord3s(target: GLenum, s: GLshort, t: GLshort, r: GLshort) {.importc.} + proc glMultTransposeMatrixd(m: ptr GLdouble) {.importc.} + proc glActiveVaryingNV(program: GLuint, name: cstring) {.importc.} + proc glProgramUniform1f(program: GLuint, location: GLint, v0: GLfloat) {.importc.} + proc glGetActiveSubroutineName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: cstring) {.importc.} + proc glClipPlanex(plane: GLenum, equation: ptr GLfixed) {.importc.} + proc glMultiTexCoord4iv(target: GLenum, v: ptr GLint) {.importc.} + proc glTransformFeedbackVaryingsEXT(program: GLuint, count: GLsizei, varyings: cstringArray, bufferMode: GLenum) {.importc.} + proc glBlendEquationSeparateiARB(buf: GLuint, modeRgb: GLenum, modeAlpha: GLenum) {.importc.} + proc glVertex2sv(v: ptr GLshort) {.importc.} + proc glAccumxOES(op: GLenum, value: GLfixed) {.importc.} + proc glProgramLocalParameter4dARB(target: GLenum, index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glIsRenderbufferEXT(renderbuffer: GLuint): GLboolean {.importc.} + proc glMultiDrawElementsIndirectAMD(mode: GLenum, `type`: GLenum, indirect: pointer, primcount: GLsizei, stride: GLsizei) {.importc.} + proc glVertexAttribI4uiEXT(index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint) {.importc.} + proc glVertex4fv(v: ptr GLfloat) {.importc.} + proc glGenerateMipmapEXT(target: GLenum) {.importc.} + proc glVertexP3ui(`type`: GLenum, value: GLuint) {.importc.} + proc glTexCoord2dv(v: ptr GLdouble) {.importc.} + proc glFlushMappedBufferRange(target: GLenum, offset: GLintptr, length: GLsizeiptr) {.importc.} + proc glTrackMatrixNV(target: GLenum, address: GLuint, matrix: GLenum, transform: GLenum) {.importc.} + proc glFragmentLightModeliSGIX(pname: GLenum, param: GLint) {.importc.} + proc glVertexAttrib4Nusv(index: GLuint, v: ptr GLushort) {.importc.} + proc glScalef(x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glLightxvOES(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glTextureParameterivEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glCompressedMultiTexImage3DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} + proc glVertexAttribL1d(index: GLuint, x: GLdouble) {.importc.} + proc glVertexAttrib3fARB(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glVertexAttrib3hvNV(index: GLuint, v: ptr GLhalfNv) {.importc.} + proc glSpriteParameteriSGIX(pname: GLenum, param: GLint) {.importc.} + proc glFrustumxOES(l: GLfixed, r: GLfixed, b: GLfixed, t: GLfixed, n: GLfixed, f: GLfixed) {.importc.} + proc glGetnMapdvARB(target: GLenum, query: GLenum, bufSize: GLsizei, v: ptr GLdouble) {.importc.} + proc glGetMinmaxEXT(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, values: pointer) {.importc.} + proc glProgramUniformHandleui64NV(program: GLuint, location: GLint, value: GLuint64) {.importc.} + proc glWindowPos4fvMESA(v: ptr GLfloat) {.importc.} + proc glExtGetTexturesQCOM(textures: ptr GLuint, maxTextures: GLint, numTextures: ptr GLint) {.importc.} + proc glProgramSubroutineParametersuivNV(target: GLenum, count: GLsizei, params: ptr GLuint) {.importc.} + proc glSampleCoveragexOES(value: GLclampx, invert: GLboolean) {.importc.} + proc glMultiTexEnvivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetFinalCombinerInputParameterfvNV(variable: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glLightModeliv(pname: GLenum, params: ptr GLint) {.importc.} + proc glUniform4f(location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat, v3: GLfloat) {.importc.} + proc glDepthRange(near: GLdouble, far: GLdouble) {.importc.} + proc glProgramUniformMatrix4x3dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glProgramUniform4fv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetTexParameterIiv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttribs4dvNV(index: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} + proc glConvolutionParameteri(target: GLenum, pname: GLenum, params: GLint) {.importc.} + proc glVertexAttribI4uiv(index: GLuint, v: ptr GLuint) {.importc.} + proc glEvalCoord1dv(u: ptr GLdouble) {.importc.} + proc glIsFramebuffer(framebuffer: GLuint): GLboolean {.importc.} + proc glEvalCoord2d(u: GLdouble, v: GLdouble) {.importc.} + proc glClearDepthf(d: GLfloat) {.importc.} + proc glCompressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, data: pointer) {.importc.} + proc glProgramUniformMatrix3x2dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glGetTexParameterxv(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glBinormal3fEXT(bx: GLfloat, by: GLfloat, bz: GLfloat) {.importc.} + proc glProgramParameteriARB(program: GLuint, pname: GLenum, value: GLint) {.importc.} + proc glWindowPos3ivMESA(v: ptr GLint) {.importc.} + proc glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc: ptr GLuint, c: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glPresentFrameDualFillNV(video_slot: GLuint, minPresentTime: GLuint64Ext, beginPresentTimeId: GLuint, presentDurationId: GLuint, `type`: GLenum, target0: GLenum, fill0: GLuint, target1: GLenum, fill1: GLuint, target2: GLenum, fill2: GLuint, target3: GLenum, fill3: GLuint) {.importc.} + proc glIndexPointerListIBM(`type`: GLenum, stride: GLint, `pointer`: ptr pointer, ptrstride: GLint) {.importc.} + proc glVertexStream2dATI(stream: GLenum, x: GLdouble, y: GLdouble) {.importc.} + proc glUniformMatrix3x4dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glMapNamedBufferRangeEXT(buffer: GLuint, offset: GLintptr, length: GLsizeiptr, access: GLbitfield): pointer {.importc.} + proc glColor4sv(v: ptr GLshort) {.importc.} + proc glStencilFillPathNV(path: GLuint, fillMode: GLenum, mask: GLuint) {.importc.} + proc glGetVertexAttribfvARB(index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glWindowPos3dv(v: ptr GLdouble) {.importc.} + proc glHintPGI(target: GLenum, mode: GLint) {.importc.} + proc glVertexAttribs3hvNV(index: GLuint, n: GLsizei, v: ptr GLhalfNv) {.importc.} + proc glProgramUniform1i64NV(program: GLuint, location: GLint, x: GLint64Ext) {.importc.} + proc glReplacementCodeuiColor3fVertex3fSUN(rc: GLuint, r: GLfloat, g: GLfloat, b: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glUniform2iARB(location: GLint, v0: GLint, v1: GLint) {.importc.} + proc glViewport(x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glBlendFuncSeparateIndexedAMD(buf: GLuint, srcRgb: GLenum, dstRgb: GLenum, srcAlpha: GLenum, dstAlpha: GLenum) {.importc.} + proc glColor3us(red: GLushort, green: GLushort, blue: GLushort) {.importc.} + proc glVertexAttrib2hvNV(index: GLuint, v: ptr GLhalfNv) {.importc.} + proc glGenerateMipmap(target: GLenum) {.importc.} + proc glGetProgramEnvParameterIuivNV(target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} + proc glBlendEquationiARB(buf: GLuint, mode: GLenum) {.importc.} + proc glReadBufferNV(mode: GLenum) {.importc.} + proc glProvokingVertexEXT(mode: GLenum) {.importc.} + proc glPointParameterivNV(pname: GLenum, params: ptr GLint) {.importc.} + proc glBlitFramebufferANGLE(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum) {.importc.} + proc glGetObjectParameterivARB(obj: GLhandleArb, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetSubroutineIndex(program: GLuint, shadertype: GLenum, name: cstring): GLuint {.importc.} + proc glMap2d(target: GLenum, u1: GLdouble, u2: GLdouble, ustride: GLint, uorder: GLint, v1: GLdouble, v2: GLdouble, vstride: GLint, vorder: GLint, points: ptr GLdouble) {.importc.} + proc glRectfv(v1: ptr GLfloat, v2: ptr GLfloat) {.importc.} + proc glDepthRangeArrayv(first: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} + proc glMultiTexParameteriEXT(texunit: GLenum, target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glTexStorageSparseAMD(target: GLenum, internalFormat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, layers: GLsizei, flags: GLbitfield) {.importc.} + proc glGenerateTextureMipmapEXT(texture: GLuint, target: GLenum) {.importc.} + proc glCopyConvolutionFilter1D(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glVertex4d(x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glGetPathParameterfvNV(path: GLuint, pname: GLenum, value: ptr GLfloat) {.importc.} + proc glDetachShader(program: GLuint, shader: GLuint) {.importc.} + proc glGetColorTableSGI(target: GLenum, format: GLenum, `type`: GLenum, table: pointer) {.importc.} + proc glPixelTransformParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glBufferSubDataARB(target: GLenum, offset: GLintPtrArb, size: GLsizeiptrArb, data: pointer) {.importc.} + proc glVertexAttrib4ubvNV(index: GLuint, v: ptr GLubyte) {.importc.} + proc glCopyTextureImage1DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, border: GLint) {.importc.} + proc glGetQueryivARB(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttribIPointerEXT(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glVertexAttribL3dEXT(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glGetQueryObjectui64vEXT(id: GLuint, pname: GLenum, params: ptr GLuint64) {.importc.} + proc glColor4x(red: GLfixed, green: GLfixed, blue: GLfixed, alpha: GLfixed) {.importc.} + proc glProgramUniformMatrix3x2dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glVertexAttribI4i(index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glVertexAttrib1f(index: GLuint, x: GLfloat) {.importc.} + proc glUnmapBufferOES(target: GLenum): GLboolean {.importc.} + proc glVertexStream2ivATI(stream: GLenum, coords: ptr GLint) {.importc.} + proc glBeginOcclusionQueryNV(id: GLuint) {.importc.} + proc glVertex4sv(v: ptr GLshort) {.importc.} + proc glEnablei(target: GLenum, index: GLuint) {.importc.} + proc glUseProgramObjectARB(programObj: GLhandleArb) {.importc.} + proc glGetVertexAttribLdvEXT(index: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glUniform2d(location: GLint, x: GLdouble, y: GLdouble) {.importc.} + proc glMinmaxEXT(target: GLenum, internalformat: GLenum, sink: GLboolean) {.importc.} + proc glTexImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGenSymbolsEXT(datatype: GLenum, storagetype: GLenum, range: GLenum, components: GLuint): GLuint {.importc.} + proc glVertexAttribI4svEXT(index: GLuint, v: ptr GLshort) {.importc.} + proc glProgramEnvParameter4dvARB(target: GLenum, index: GLuint, params: ptr GLdouble) {.importc.} + proc glProgramUniformMatrix4dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glGetSamplerParameterfv(sampler: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glPopClientAttrib() {.importc.} + proc glHistogram(target: GLenum, width: GLsizei, internalformat: GLenum, sink: GLboolean) {.importc.} + proc glTexEnvfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glMultiTexCoord1dvARB(target: GLenum, v: ptr GLdouble) {.importc.} + proc glGetTexGenivOES(coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glUniform1ivARB(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glTexCoord3fv(v: ptr GLfloat) {.importc.} + proc glVertex2xvOES(coords: ptr GLfixed) {.importc.} + proc glTexCoord4fVertex4fvSUN(tc: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glUniform2uiv(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glMultiTexEnvfvEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetTextureParameterIivEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMemoryBarrierEXT(barriers: GLbitfield) {.importc.} + proc glGetTexParameterPointervAPPLE(target: GLenum, pname: GLenum, params: ptr pointer) {.importc.} + proc glWindowPos2svARB(v: ptr GLshort) {.importc.} + proc glEndQuery(target: GLenum) {.importc.} + proc glBlitFramebufferEXT(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum) {.importc.} + proc glProgramEnvParametersI4uivNV(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLuint) {.importc.} + proc glGetActiveUniform(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} + proc glGenAsyncMarkersSGIX(range: GLsizei): GLuint {.importc.} + proc glClipControlARB(origin: GLenum, depth: GLenum) {.importc.} + proc glDrawElementsInstancedEXT(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, primcount: GLsizei) {.importc.} + proc glGetFragmentMaterialivSGIX(face: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glSwizzleEXT(res: GLuint, `in`: GLuint, outX: GLenum, outY: GLenum, outZ: GLenum, outW: GLenum) {.importc.} + proc glMultiTexCoord1bOES(texture: GLenum, s: GLbyte) {.importc.} + proc glProgramParameters4dvNV(target: GLenum, index: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} + proc glWindowPos2s(x: GLshort, y: GLshort) {.importc.} + proc glBlendFuncSeparatei(buf: GLuint, srcRgb: GLenum, dstRgb: GLenum, srcAlpha: GLenum, dstAlpha: GLenum) {.importc.} + proc glMultiModeDrawElementsIBM(mode: ptr GLenum, count: ptr GLsizei, `type`: GLenum, indices: ptr pointer, primcount: GLsizei, modestride: GLint) {.importc.} + proc glNormal3x(nx: GLfixed, ny: GLfixed, nz: GLfixed) {.importc.} + proc glProgramUniform1fvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glTexCoord2hNV(s: GLhalfNv, t: GLhalfNv) {.importc.} + proc glViewportIndexedfv(index: GLuint, v: ptr GLfloat) {.importc.} + proc glDrawTexxOES(x: GLfixed, y: GLfixed, z: GLfixed, width: GLfixed, height: GLfixed) {.importc.} + proc glProgramParameter4dvNV(target: GLenum, index: GLuint, v: ptr GLdouble) {.importc.} + proc glDeleteBuffers(n: GLsizei, buffers: ptr GLuint) {.importc.} + proc glGetVertexArrayIntegervEXT(vaobj: GLuint, pname: GLenum, param: ptr GLint) {.importc.} + proc glBindFragDataLocationEXT(program: GLuint, color: GLuint, name: cstring) {.importc.} + proc glGenProgramsNV(n: GLsizei, programs: ptr GLuint) {.importc.} + proc glMultiTexCoord1i(target: GLenum, s: GLint) {.importc.} + proc glCompressedTexImage3DOES(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} + proc glGetQueryivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glExtGetBufferPointervQCOM(target: GLenum, params: ptr pointer) {.importc.} + proc glVertex3iv(v: ptr GLint) {.importc.} + proc glVertexAttribL1dvEXT(index: GLuint, v: ptr GLdouble) {.importc.} + proc glValidateProgramPipeline(pipeline: GLuint) {.importc.} + proc glBindVertexArray(`array`: GLuint) {.importc.} + proc glUniform2uiEXT(location: GLint, v0: GLuint, v1: GLuint) {.importc.} + proc glUniform3i(location: GLint, v0: GLint, v1: GLint, v2: GLint) {.importc.} + proc glGetVertexAttribIuiv(index: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glVertexArrayParameteriAPPLE(pname: GLenum, param: GLint) {.importc.} + proc glVertexAttribL2i64NV(index: GLuint, x: GLint64Ext, y: GLint64Ext) {.importc.} + proc glTexGenivOES(coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glIsFramebufferOES(framebuffer: GLuint): GLboolean {.importc.} + proc glColor4ubv(v: ptr GLubyte) {.importc.} + proc glDeleteNamedStringARB(namelen: GLint, name: cstring) {.importc.} + proc glCopyConvolutionFilter1DEXT(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glBufferStorage(target: GLenum, size: GLsizeiptr, data: ptr pointer, flags: GLbitfield) {.importc.} + proc glDrawTexiOES(x: GLint, y: GLint, z: GLint, width: GLint, height: GLint) {.importc.} + proc glRasterPos3dv(v: ptr GLdouble) {.importc.} + proc glIndexMaterialEXT(face: GLenum, mode: GLenum) {.importc.} + proc glGetClipPlanex(plane: GLenum, equation: ptr GLfixed) {.importc.} + proc glIsVertexArrayOES(`array`: GLuint): GLboolean {.importc.} + proc glColorTableEXT(target: GLenum, internalFormat: GLenum, width: GLsizei, format: GLenum, `type`: GLenum, table: pointer) {.importc.} + proc glCompressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} + proc glLightx(light: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glGetTexParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexAttrib4NsvARB(index: GLuint, v: ptr GLshort) {.importc.} + proc glInterleavedArrays(format: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glProgramLocalParameter4fARB(target: GLenum, index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glPopDebugGroupKHR() {.importc.} + proc glVDPAUUnregisterSurfaceNV(surface: GLvdpauSurfaceNv) {.importc.} + proc glTexCoord1s(s: GLshort) {.importc.} + proc glFramebufferTexture2DMultisampleIMG(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, samples: GLsizei) {.importc.} + proc glShaderBinary(count: GLsizei, shaders: ptr GLuint, binaryformat: GLenum, binary: pointer, length: GLsizei) {.importc.} + proc glVertexAttrib2dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glUniformMatrix4dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glWeightivARB(size: GLint, weights: ptr GLint) {.importc.} + proc glGetMultiTexParameterIivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glCopyConvolutionFilter2DEXT(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glSecondaryColor3hNV(red: GLhalfNv, green: GLhalfNv, blue: GLhalfNv) {.importc.} + proc glVertexAttrib1sv(index: GLuint, v: ptr GLshort) {.importc.} + proc glFrustumfOES(l: GLfloat, r: GLfloat, b: GLfloat, t: GLfloat, n: GLfloat, f: GLfloat) {.importc.} + proc glVertexStream2iATI(stream: GLenum, x: GLint, y: GLint) {.importc.} + proc glNormalStream3bATI(stream: GLenum, nx: GLbyte, ny: GLbyte, nz: GLbyte) {.importc.} + proc glVertexArrayTexCoordOffsetEXT(vaobj: GLuint, buffer: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glGetQueryiv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glTransformFeedbackStreamAttribsNV(count: GLsizei, attribs: ptr GLint, nbuffers: GLsizei, bufstreams: ptr GLint, bufferMode: GLenum) {.importc.} + proc glTextureStorage3DEXT(texture: GLuint, target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei) {.importc.} + proc glWindowPos3dvMESA(v: ptr GLdouble) {.importc.} + proc glUniform2uivEXT(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glTextureStorage2DEXT(texture: GLuint, target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glVertexArrayMultiTexCoordOffsetEXT(vaobj: GLuint, buffer: GLuint, texunit: GLenum, size: GLint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glVertexStream1dvATI(stream: GLenum, coords: ptr GLdouble) {.importc.} + proc glCopyImageSubData(srcName: GLuint, srcTarget: GLenum, srcLevel: GLint, srcX: GLint, srcY: GLint, srcZ: GLint, dstName: GLuint, dstTarget: GLenum, dstLevel: GLint, dstX: GLint, dstY: GLint, dstZ: GLint, srcWidth: GLsizei, srcHeight: GLsizei, srcDepth: GLsizei) {.importc.} + proc glClearNamedBufferSubDataEXT(buffer: GLuint, internalformat: GLenum, format: GLenum, `type`: GLenum, offset: GLsizeiptr, size: GLsizeiptr, data: ptr pointer) {.importc.} + proc glBindBuffersRange(target: GLenum, first: GLuint, count: GLsizei, buffers: ptr GLuint, offsets: ptr GLintptr, sizes: ptr GLsizeiptr) {.importc.} + proc glGetVertexAttribIuivEXT(index: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glLoadMatrixx(m: ptr GLfixed) {.importc.} + proc glTransformFeedbackVaryingsNV(program: GLuint, count: GLsizei, locations: ptr GLint, bufferMode: GLenum) {.importc.} + proc glUniform1i64vNV(location: GLint, count: GLsizei, value: ptr GLint64Ext) {.importc.} + proc glVertexArrayVertexAttribLFormatEXT(vaobj: GLuint, attribindex: GLuint, size: GLint, `type`: GLenum, relativeoffset: GLuint) {.importc.} + proc glClearBufferuiv(buffer: GLenum, drawbuffer: GLint, value: ptr GLuint) {.importc.} + proc glCombinerOutputNV(stage: GLenum, portion: GLenum, abOutput: GLenum, cdOutput: GLenum, sumOutput: GLenum, scale: GLenum, bias: GLenum, abDotProduct: GLboolean, cdDotProduct: GLboolean, muxSum: GLboolean) {.importc.} + proc glTexImage3DEXT(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glPixelTransformParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glActiveStencilFaceEXT(face: GLenum) {.importc.} + proc glCreateShaderObjectARB(shaderType: GLenum): GLhandleArb {.importc.} + proc glGetTextureParameterivEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glCopyTextureLevelsAPPLE(destinationTexture: GLuint, sourceTexture: GLuint, sourceBaseLevel: GLint, sourceLevelCount: GLsizei) {.importc.} + proc glVertexAttrib4Nuiv(index: GLuint, v: ptr GLuint) {.importc.} + proc glDrawPixels(width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glWindowPos3dvARB(v: ptr GLdouble) {.importc.} + proc glProgramLocalParameterI4ivNV(target: GLenum, index: GLuint, params: ptr GLint) {.importc.} + proc glRasterPos4s(x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} + proc glTexCoord2fVertex3fvSUN(tc: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glGetPathMetricsNV(metricQueryMask: GLbitfield, numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, stride: GLsizei, metrics: ptr GLfloat) {.importc.} + proc glMultiTexCoord4bOES(texture: GLenum, s: GLbyte, t: GLbyte, r: GLbyte, q: GLbyte) {.importc.} + proc glTextureBufferEXT(texture: GLuint, target: GLenum, internalformat: GLenum, buffer: GLuint) {.importc.} + proc glSecondaryColor3fv(v: ptr GLfloat) {.importc.} + proc glMultiTexCoord3fv(target: GLenum, v: ptr GLfloat) {.importc.} + proc glGetTexParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMap2xOES(target: GLenum, u1: GLfixed, u2: GLfixed, ustride: GLint, uorder: GLint, v1: GLfixed, v2: GLfixed, vstride: GLint, vorder: GLint, points: GLfixed) {.importc.} + proc glFlushVertexArrayRangeAPPLE(length: GLsizei, `pointer`: pointer) {.importc.} + proc glActiveTextureARB(texture: GLenum) {.importc.} + proc glGetVertexAttribLi64vNV(index: GLuint, pname: GLenum, params: ptr GLint64Ext) {.importc.} + proc glNormal3bv(v: ptr GLbyte) {.importc.} + proc glCreateSyncFromCLeventARB(context: ptr ClContext, event: ptr ClContext, flags: GLbitfield): GLsync {.importc.} + proc glRenderbufferStorageEXT(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glGetCompressedTextureImageEXT(texture: GLuint, target: GLenum, lod: GLint, img: pointer) {.importc.} + proc glColorFragmentOp2ATI(op: GLenum, dst: GLuint, dstMask: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint, arg2: GLuint, arg2Rep: GLuint, arg2Mod: GLuint) {.importc.} + proc glPixelMapusv(map: GLenum, mapsize: GLsizei, values: ptr GLushort) {.importc.} + proc glGlobalAlphaFactorsSUN(factor: GLshort) {.importc.} + proc glTexParameterxv(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glEvalCoord2xOES(u: GLfixed, v: GLfixed) {.importc.} + proc glIsList(list: GLuint): GLboolean {.importc.} + proc glVertexAttrib3d(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glSpriteParameterfSGIX(pname: GLenum, param: GLfloat) {.importc.} + proc glPathGlyphRangeNV(firstPathName: GLuint, fontTarget: GLenum, fontName: pointer, fontStyle: GLbitfield, firstGlyph: GLuint, numGlyphs: GLsizei, handleMissingGlyphs: GLenum, pathParameterTemplate: GLuint, emScale: GLfloat) {.importc.} + proc glUniform3iv(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glClearBufferfi(buffer: GLenum, drawbuffer: GLint, depth: GLfloat, stencil: GLint) {.importc.} + proc glWindowPos3sMESA(x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glGetMapParameterfvNV(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glBindFragmentShaderATI(id: GLuint) {.importc.} + proc glTexCoord4s(s: GLshort, t: GLshort, r: GLshort, q: GLshort) {.importc.} + proc glGetMultiTexGenfvEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glColorMaterial(face: GLenum, mode: GLenum) {.importc.} + proc glVertexAttribs1svNV(index: GLuint, count: GLsizei, v: ptr GLshort) {.importc.} + proc glEnableVertexAttribAPPLE(index: GLuint, pname: GLenum) {.importc.} + proc glGetDoubleIndexedvEXT(target: GLenum, index: GLuint, data: ptr GLdouble) {.importc.} + proc glOrthof(l: GLfloat, r: GLfloat, b: GLfloat, t: GLfloat, n: GLfloat, f: GLfloat) {.importc.} + proc glVertexBlendEnvfATI(pname: GLenum, param: GLfloat) {.importc.} + proc glUniformMatrix2x4dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glPrioritizeTexturesxOES(n: GLsizei, textures: ptr GLuint, priorities: ptr GLfixed) {.importc.} + proc glGetTextureSamplerHandleNV(texture: GLuint, sampler: GLuint): GLuint64 {.importc.} + proc glDeleteVertexArrays(n: GLsizei, arrays: ptr GLuint) {.importc.} + proc glMultiTexCoord1xOES(texture: GLenum, s: GLfixed) {.importc.} + proc glGlobalAlphaFactorusSUN(factor: GLushort) {.importc.} + proc glGetConvolutionParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glProgramUniform4fEXT(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat, v3: GLfloat) {.importc.} + proc glProgramUniformMatrix3x4dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glBindVertexBuffer(bindingindex: GLuint, buffer: GLuint, offset: GLintptr, stride: GLsizei) {.importc.} + proc glGetHistogramParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetShaderPrecisionFormat(shadertype: GLenum, precisiontype: GLenum, range: ptr GLint, precision: ptr GLint) {.importc.} + proc glTextureMaterialEXT(face: GLenum, mode: GLenum) {.importc.} + proc glEvalCoord2xvOES(coords: ptr GLfixed) {.importc.} + proc glWeightuivARB(size: GLint, weights: ptr GLuint) {.importc.} + proc glGetTextureLevelParameterfvEXT(texture: GLuint, target: GLenum, level: GLint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexAttribP3uiv(index: GLuint, `type`: GLenum, normalized: GLboolean, value: ptr GLuint) {.importc.} + proc glProgramEnvParameterI4ivNV(target: GLenum, index: GLuint, params: ptr GLint) {.importc.} + proc glFogi(pname: GLenum, param: GLint) {.importc.} + proc glTexCoord1iv(v: ptr GLint) {.importc.} + proc glReplacementCodeuiColor4ubVertex3fvSUN(rc: ptr GLuint, c: ptr GLubyte, v: ptr GLfloat) {.importc.} + proc glProgramUniform1ui(program: GLuint, location: GLint, v0: GLuint) {.importc.} + proc glMultiTexCoord3d(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble) {.importc.} + proc glBeginVideoCaptureNV(video_capture_slot: GLuint) {.importc.} + proc glEvalCoord1f(u: GLfloat) {.importc.} + proc glMultiTexCoord1hvNV(target: GLenum, v: ptr GLhalfNv) {.importc.} + proc glSecondaryColor3sEXT(red: GLshort, green: GLshort, blue: GLshort) {.importc.} + proc glTextureImage3DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glCopyTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint) {.importc.} + proc glFinishFenceAPPLE(fence: GLuint) {.importc.} + proc glVertexArrayRangeNV(length: GLsizei, `pointer`: pointer) {.importc.} + proc glLightModelf(pname: GLenum, param: GLfloat) {.importc.} + proc glVertexAttribL1ui64ARB(index: GLuint, x: GLuint64Ext) {.importc.} + proc glPolygonOffset(factor: GLfloat, units: GLfloat) {.importc.} + proc glRasterPos4xOES(x: GLfixed, y: GLfixed, z: GLfixed, w: GLfixed) {.importc.} + proc glVertexAttrib3dvNV(index: GLuint, v: ptr GLdouble) {.importc.} + proc glBeginQuery(target: GLenum, id: GLuint) {.importc.} + proc glWeightfvARB(size: GLint, weights: ptr GLfloat) {.importc.} + proc glGetUniformuiv(program: GLuint, location: GLint, params: ptr GLuint) {.importc.} + proc glIsTextureEXT(texture: GLuint): GLboolean {.importc.} + proc glGetClipPlanef(plane: GLenum, equation: ptr GLfloat) {.importc.} + proc glTexGenxOES(coord: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glFramebufferTextureFaceEXT(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint, face: GLenum) {.importc.} + proc glDisableClientState(`array`: GLenum) {.importc.} + proc glTexPageCommitmentARB(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, resident: GLboolean) {.importc.} + proc glRasterPos4dv(v: ptr GLdouble) {.importc.} + proc glGetLightx(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glVertexAttrib1hvNV(index: GLuint, v: ptr GLhalfNv) {.importc.} + proc glMultiTexCoord2s(target: GLenum, s: GLshort, t: GLshort) {.importc.} + proc glProgramUniform2iv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glGetListParameterivSGIX(list: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glColorFragmentOp1ATI(op: GLenum, dst: GLuint, dstMask: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint) {.importc.} + proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc: GLuint, s: GLfloat, t: GLfloat, r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glSampleMapATI(dst: GLuint, interp: GLuint, swizzle: GLenum) {.importc.} + proc glProgramUniform1d(program: GLuint, location: GLint, v0: GLdouble) {.importc.} + proc glBindAttribLocation(program: GLuint, index: GLuint, name: cstring) {.importc.} + proc glGetCombinerStageParameterfvNV(stage: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexSubImage4DSGIS(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, woffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, size4d: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGetMapAttribParameterfvNV(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glNewObjectBufferATI(size: GLsizei, `pointer`: pointer, usage: GLenum): GLuint {.importc.} + proc glWindowPos4iMESA(x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glNewList(list: GLuint, mode: GLenum) {.importc.} + proc glUniform1i64NV(location: GLint, x: GLint64Ext) {.importc.} + proc glTexCoordP3ui(`type`: GLenum, coords: GLuint) {.importc.} + proc glEndQueryEXT(target: GLenum) {.importc.} + proc glGetVertexAttribLdv(index: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glStencilMask(mask: GLuint) {.importc.} + proc glVertexAttrib4sv(index: GLuint, v: ptr GLshort) {.importc.} + proc glRectsv(v1: ptr GLshort, v2: ptr GLshort) {.importc.} + proc glGetVariantArrayObjectfvATI(id: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexCoord3hvNV(v: ptr GLhalfNv) {.importc.} + proc glGetUniformdv(program: GLuint, location: GLint, params: ptr GLdouble) {.importc.} + proc glSecondaryColor3fvEXT(v: ptr GLfloat) {.importc.} + proc glAlphaFuncx(fun: GLenum, `ref`: GLfixed) {.importc.} + proc glVertexAttribPointerNV(index: GLuint, fsize: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glColorTable(target: GLenum, internalformat: GLenum, width: GLsizei, format: GLenum, `type`: GLenum, table: pointer) {.importc.} + proc glProgramUniformMatrix2x3dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + + ## # GL_ARB_direct_state_access + proc glCreateTransformFeedbacks(n: GLsizei; ids: ptr GLuint) {.importc.} + proc glTransformFeedbackBufferBase(xfb: GLuint; index: GLuint; buffer: GLuint) {.importc.} + proc glTransformFeedbackBufferRange(xfb: GLuint; index: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr) {.importc.} + proc glGetTransformFeedbackiv(xfb: GLuint; pname: GLenum; param: ptr GLint) {.importc.} + proc glGetTransformFeedbacki_v(xfb: GLuint; pname: GLenum; index: GLuint; param: ptr GLint) {.importc.} + proc glGetTransformFeedbacki64_v(xfb: GLuint; pname: GLenum; index: GLuint; param: ptr GLint64) {.importc.} + ## # Buffer object functions + + proc glCreateBuffers(n: GLsizei; buffers: ptr GLuint) {.importc.} + proc glNamedBufferStorage(buffer: GLuint; size: GLsizeiptr; data: pointer; flags: GLbitfield) {.importc.} + proc glNamedBufferData(buffer: GLuint; size: GLsizeiptr; data: pointer; usage: GLenum) {.importc.} + proc glNamedBufferSubData(buffer: GLuint; offset: GLintptr; size: GLsizeiptr; data: pointer) {.importc.} + proc glCopyNamedBufferSubData(readBuffer: GLuint; writeBuffer: GLuint; readOffset: GLintptr; writeOffset: GLintptr; size: GLsizeiptr) {.importc.} + proc glClearNamedBufferData(buffer: GLuint; internalformat: GLenum; format: GLenum; `type`: GLenum; data: pointer) {.importc.} + proc glClearNamedBufferSubData(buffer: GLuint; internalformat: GLenum; offset: GLintptr; size: GLsizeiptr; format: GLenum; `type`: GLenum; data: pointer) {.importc.} + proc glMapNamedBuffer(buffer: GLuint; access: GLenum): pointer {.importc.} + proc glMapNamedBufferRange(buffer: GLuint; offset: GLintptr; length: GLsizeiptr; access: GLbitfield): pointer {.importc.} + proc glUnmapNamedBuffer(buffer: GLuint): GLboolean {.importc.} + proc glFlushMappedNamedBufferRange(buffer: GLuint; offset: GLintptr; length: GLsizeiptr) {.importc.} + proc glGetNamedBufferParameteriv(buffer: GLuint; pname: GLenum; params: ptr GLint) {.importc.} + proc glGetNamedBufferParameteri64v(buffer: GLuint; pname: GLenum; params: ptr GLint64) {.importc.} + proc glGetNamedBufferPointerv(buffer: GLuint; pname: GLenum; params: ptr pointer) {.importc.} + proc glGetNamedBufferSubData(buffer: GLuint; offset: GLintptr; size: GLsizeiptr; data: pointer) {.importc.} + ## # Framebuffer object functions + + proc glCreateFramebuffers(n: GLsizei; framebuffers: ptr GLuint) {.importc.} + proc glNamedFramebufferRenderbuffer(framebuffer: GLuint; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint) {.importc.} + proc glNamedFramebufferParameteri(framebuffer: GLuint; pname: GLenum; param: GLint) {.importc.} + proc glNamedFramebufferTexture(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint) {.importc.} + proc glNamedFramebufferTextureLayer(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint) {.importc.} + proc glNamedFramebufferDrawBuffer(framebuffer: GLuint; mode: GLenum) {.importc.} + proc glNamedFramebufferDrawBuffers(framebuffer: GLuint; n: GLsizei; bufs: ptr GLenum) {.importc.} + proc glNamedFramebufferReadBuffer(framebuffer: GLuint; mode: GLenum) {.importc.} + proc glInvalidateNamedFramebufferData(framebuffer: GLuint; numAttachments: GLsizei; attachments: ptr GLenum) {.importc.} + proc glInvalidateNamedFramebufferSubData(framebuffer: GLuint; numAttachments: GLsizei; attachments: ptr GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei) {.importc.} + proc glClearNamedFramebufferiv(framebuffer: GLuint; buffer: GLenum; drawbuffer: GLint; value: ptr GLint) {.importc.} + proc glClearNamedFramebufferuiv(framebuffer: GLuint; buffer: GLenum; drawbuffer: GLint; value: ptr GLuint) {.importc.} + proc glClearNamedFramebufferfv(framebuffer: GLuint; buffer: GLenum; drawbuffer: GLint; value: ptr cfloat) {.importc.} + proc glClearNamedFramebufferfi(framebuffer: GLuint; buffer: GLenum; drawbuffer: GLint; depth: cfloat; stencil: GLint) {.importc.} + proc glBlitNamedFramebuffer(readFramebuffer: GLuint; drawFramebuffer: GLuint; srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; mask: GLbitfield; filter: GLenum) {.importc.} + proc glCheckNamedFramebufferStatus(framebuffer: GLuint; target: GLenum): GLenum {.importc.} + proc glGetNamedFramebufferParameteriv(framebuffer: GLuint; pname: GLenum; param: ptr GLint) {.importc.} + proc glGetNamedFramebufferAttachmentParameteriv(framebuffer: GLuint; attachment: GLenum; pname: GLenum; params: ptr GLint) {.importc.} + ## # Renderbuffer object functions + + proc glCreateRenderbuffers(n: GLsizei; renderbuffers: ptr GLuint) {.importc.} + proc glNamedRenderbufferStorage(renderbuffer: GLuint; internalformat: GLenum; width: GLsizei; height: GLsizei) {.importc.} + proc glNamedRenderbufferStorageMultisample(renderbuffer: GLuint; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei) {.importc.} + proc glGetNamedRenderbufferParameteriv(renderbuffer: GLuint; pname: GLenum; params: ptr GLint) {.importc.} + ## # Texture object functions + + proc glCreateTextures(target: GLenum; n: GLsizei; textures: ptr GLuint) {.importc.} + proc glTextureBuffer(texture: GLuint; internalformat: GLenum; buffer: GLuint) {.importc.} + proc glTextureBufferRange(texture: GLuint; internalformat: GLenum; buffer: GLuint; offset: GLintptr; size: GLsizeiptr) {.importc.} + proc glTextureStorage1D(texture: GLuint; levels: GLsizei; internalformat: GLenum; width: GLsizei) {.importc.} + proc glTextureStorage2D(texture: GLuint; levels: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei) {.importc.} + proc glTextureStorage3D(texture: GLuint; levels: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei) {.importc.} + proc glTextureStorage2DMultisample(texture: GLuint; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei; fixedsamplelocations: GLboolean) {.importc.} + proc glTextureStorage3DMultisample(texture: GLuint; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; fixedsamplelocations: GLboolean) {.importc.} + proc glTextureSubImage1D(texture: GLuint; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; `type`: GLenum; pixels: pointer) {.importc.} + proc glTextureSubImage2D(texture: GLuint; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; `type`: GLenum; pixels: pointer) {.importc.} + proc glTextureSubImage3D(texture: GLuint; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; `type`: GLenum; pixels: pointer) {.importc.} + proc glCompressedTextureSubImage1D(texture: GLuint; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; data: pointer) {.importc.} + proc glCompressedTextureSubImage2D(texture: GLuint; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; data: pointer) {.importc.} + proc glCompressedTextureSubImage3D(texture: GLuint; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; data: pointer) {.importc.} + proc glCopyTextureSubImage1D(texture: GLuint; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei) {.importc.} + proc glCopyTextureSubImage2D(texture: GLuint; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei) {.importc.} + proc glCopyTextureSubImage3D(texture: GLuint; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei) {.importc.} + proc glTextureParameterf(texture: GLuint; pname: GLenum; param: cfloat) {.importc.} + proc glTextureParameterfv(texture: GLuint; pname: GLenum; param: ptr cfloat) {.importc.} + proc glTextureParameteri(texture: GLuint; pname: GLenum; param: GLint) {.importc.} + proc glTextureParameterIiv(texture: GLuint; pname: GLenum; params: ptr GLint) {.importc.} + proc glTextureParameterIuiv(texture: GLuint; pname: GLenum; params: ptr GLuint) {.importc.} + proc glTextureParameteriv(texture: GLuint; pname: GLenum; param: ptr GLint) {.importc.} + proc glGenerateTextureMipmap(texture: GLuint) {.importc.} + proc glBindTextureUnit(unit: GLuint; texture: GLuint) {.importc.} + proc glGetTextureImage(texture: GLuint; level: GLint; format: GLenum; `type`: GLenum; bufSize: GLsizei; pixels: pointer) {.importc.} + + proc glGetCompressedTextureImage(texture: GLuint; level: GLint; bufSize: GLsizei; pixels: pointer) {.importc.} + proc glGetTextureLevelParameterfv(texture: GLuint; level: GLint; pname: GLenum; params: ptr cfloat) {.importc.} + proc glGetTextureLevelParameteriv(texture: GLuint; level: GLint; pname: GLenum; params: ptr GLint) {.importc.} + proc glGetTextureParameterfv(texture: GLuint; pname: GLenum; params: ptr cfloat) {.importc.} + proc glGetTextureParameterIiv(texture: GLuint; pname: GLenum; params: ptr GLint) {.importc.} + proc glGetTextureParameterIuiv(texture: GLuint; pname: GLenum; params: ptr GLuint) {.importc.} + proc glGetTextureParameteriv(texture: GLuint; pname: GLenum; params: ptr GLint) {.importc.} + ## # Vertex Array object functions + + proc glCreateVertexArrays(n: GLsizei; arrays: ptr GLuint) {.importc.} + proc glDisableVertexArrayAttrib(vaobj: GLuint; index: GLuint) {.importc.} + proc glEnableVertexArrayAttrib(vaobj: GLuint; index: GLuint) {.importc.} + proc glVertexArrayElementBuffer(vaobj: GLuint; buffer: GLuint) {.importc.} + proc glVertexArrayVertexBuffer(vaobj: GLuint; bindingindex: GLuint; buffer: GLuint; offset: GLintptr; stride: GLsizei) {.importc.} + proc glVertexArrayVertexBuffers(vaobj: GLuint; first: GLuint; count: GLsizei; buffers: ptr GLuint; offsets: ptr GLintptr; strides: ptr GLsizei) {.importc.} + proc glVertexArrayAttribFormat(vaobj: GLuint; attribindex: GLuint; size: GLint; `type`: GLenum; normalized: GLboolean; relativeoffset: GLuint) {.importc.} + proc glVertexArrayAttribIFormat(vaobj: GLuint; attribindex: GLuint; size: GLint; `type`: GLenum; relativeoffset: GLuint) {.importc.} + proc glVertexArrayAttribLFormat(vaobj: GLuint; attribindex: GLuint; size: GLint; `type`: GLenum; relativeoffset: GLuint) {.importc.} + proc glVertexArrayAttribBinding(vaobj: GLuint; attribindex: GLuint; bindingindex: GLuint) {.importc.} + proc glVertexArrayBindingDivisor(vaobj: GLuint; bindingindex: GLuint; divisor: GLuint) {.importc.} + proc glGetVertexArrayiv(vaobj: GLuint; pname: GLenum; param: ptr GLint) {.importc.} + proc glGetVertexArrayIndexediv(vaobj: GLuint; index: GLuint; pname: GLenum; param: ptr GLint) {.importc.} + proc glGetVertexArrayIndexed64iv(vaobj: GLuint; index: GLuint; pname: GLenum; param: ptr GLint64) {.importc.} + ## # Sampler object functions + + proc glCreateSamplers(n: GLsizei; samplers: ptr GLuint) {.importc.} + ## # Program Pipeline object functions + + proc glCreateProgramPipelines(n: GLsizei; pipelines: ptr GLuint) {.importc.} + ## # Query object functions + + proc glCreateQueries(target: GLenum; n: GLsizei; ids: ptr GLuint) {.importc.} + proc glGetQueryBufferObjectiv(id: GLuint; buffer: GLuint; pname: GLenum; offset: GLintptr) {.importc.} + proc glGetQueryBufferObjectuiv(id: GLuint; buffer: GLuint; pname: GLenum; offset: GLintptr) {.importc.} + proc glGetQueryBufferObjecti64v(id: GLuint; buffer: GLuint; pname: GLenum; offset: GLintptr) {.importc.} + proc glGetQueryBufferObjectui64v(id: GLuint; buffer: GLuint; pname: GLenum; offset: GLintptr) {.importc.} + +{.pop.} # stdcall, hint[XDeclaredButNotUsed]: off, warning[SmallLshouldNotBeUsed]: off. + +const + cGL_UNSIGNED_BYTE* = 0x1401.GLenum + cGL_UNSIGNED_SHORT* = 0x1403.GLenum + + GL_2X_BIT_ATI* = 0x00000001.GLbitfield + GL_MODELVIEW6_ARB* = 0x8726.GLenum + GL_CULL_FACE_MODE* = 0x0B45.GLenum + GL_TEXTURE_MAG_FILTER* = 0x2800.GLenum + GL_TRANSFORM_FEEDBACK_VARYINGS_EXT* = 0x8C83.GLenum + GL_PATH_JOIN_STYLE_NV* = 0x9079.GLenum + GL_FEEDBACK_BUFFER_SIZE* = 0x0DF1.GLenum + GL_FRAGMENT_LIGHT0_SGIX* = 0x840C.GLenum + GL_DRAW_BUFFER7_ARB* = 0x882C.GLenum + GL_POINT_SPRITE_OES* = 0x8861.GLenum + GL_INT_SAMPLER_RENDERBUFFER_NV* = 0x8E57.GLenum + GL_POST_CONVOLUTION_COLOR_TABLE_SGI* = 0x80D1.GLenum + GL_ZOOM_X* = 0x0D16.GLenum + GL_DRAW_FRAMEBUFFER_NV* = 0x8CA9.GLenum + GL_RGB_FLOAT16_ATI* = 0x881B.GLenum + GL_NUM_COMPRESSED_TEXTURE_FORMATS* = 0x86A2.GLenum + GL_LINE_STRIP* = 0x0003.GLenum + GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI* = 0x80D5.GLenum + GL_CURRENT_TIME_NV* = 0x8E28.GLenum + GL_FRAMEBUFFER_UNSUPPORTED* = 0x8CDD.GLenum + GL_PIXEL_TEX_GEN_Q_CEILING_SGIX* = 0x8184.GLenum + GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT* = 0x8C76.GLenum + GL_MAP_PERSISTENT_BIT* = 0x0040.GLbitfield + GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT* = 0x9056.GLenum + GL_CON_16_ATI* = 0x8951.GLenum + GL_DEPTH_BUFFER_BIT1_QCOM* = 0x00000200.GLbitfield + GL_TEXTURE30_ARB* = 0x84DE.GLenum + GL_SAMPLER_BUFFER* = 0x8DC2.GLenum + GL_MAX_COLOR_TEXTURE_SAMPLES* = 0x910E.GLenum + GL_DEPTH_STENCIL* = 0x84F9.GLenum + GL_C4F_N3F_V3F* = 0x2A26.GLenum + GL_ZOOM_Y* = 0x0D17.GLenum + GL_RGB10* = 0x8052.GLenum + GL_PRESERVE_ATI* = 0x8762.GLenum + GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB* = 0x8B4D.GLenum + GL_COLOR_ATTACHMENT12_NV* = 0x8CEC.GLenum + GL_GREEN_MAX_CLAMP_INGR* = 0x8565.GLenum + GL_CURRENT_VERTEX_ATTRIB* = 0x8626.GLenum + GL_TEXTURE_SHARED_SIZE* = 0x8C3F.GLenum + GL_NORMAL_ARRAY_TYPE* = 0x807E.GLenum + GL_DYNAMIC_READ* = 0x88E9.GLenum + GL_ALPHA4_EXT* = 0x803B.GLenum + GL_REPLACEMENT_CODE_ARRAY_SUN* = 0x85C0.GLenum + GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV* = 0x8852.GLenum + GL_MAX_VERTEX_ATTRIBS_ARB* = 0x8869.GLenum + GL_VIDEO_COLOR_CONVERSION_MIN_NV* = 0x902B.GLenum + GL_SOURCE3_RGB_NV* = 0x8583.GLenum + GL_ALPHA* = 0x1906.GLenum + GL_OUTPUT_TEXTURE_COORD16_EXT* = 0x87AD.GLenum + GL_BLEND_EQUATION_EXT* = 0x8009.GLenum + GL_BIAS_BIT_ATI* = 0x00000008.GLbitfield + GL_BLEND_EQUATION_RGB* = 0x8009.GLenum + GL_SHADER_BINARY_DMP* = 0x9250.GLenum + GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE* = 0x90C8.GLenum + GL_Z4Y12Z4CB12Z4CR12_444_NV* = 0x9037.GLenum + GL_READ_PIXELS_TYPE* = 0x828E.GLenum + GL_CONVOLUTION_HINT_SGIX* = 0x8316.GLenum + GL_TRANSPOSE_AFFINE_3D_NV* = 0x9098.GLenum + GL_PIXEL_MAP_B_TO_B* = 0x0C78.GLenum + GL_VERTEX_BLEND_ARB* = 0x86A7.GLenum + GL_LIGHT2* = 0x4002.GLenum + cGL_BYTE* = 0x1400.GLenum + GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS* = 0x92D3.GLenum + GL_DOMAIN* = 0x0A02.GLenum + GL_PROGRAM_NATIVE_TEMPORARIES_ARB* = 0x88A6.GLenum + GL_RELATIVE_CUBIC_CURVE_TO_NV* = 0x0D.GLenum + GL_TEXTURE_DEPTH_TYPE_ARB* = 0x8C16.GLenum + GL_STENCIL_BACK_PASS_DEPTH_PASS* = 0x8803.GLenum + GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV* = 0x8868.GLenum + GL_ATTRIB_STACK_DEPTH* = 0x0BB0.GLenum + GL_DEPTH_COMPONENT16_ARB* = 0x81A5.GLenum + GL_TESSELLATION_MODE_AMD* = 0x9004.GLenum + GL_UNSIGNED_INT8_VEC3_NV* = 0x8FEE.GLenum + GL_DOUBLE_VEC4* = 0x8FFE.GLenum + GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS* = 0x8E85.GLenum + GL_TEXTURE_GREEN_TYPE_ARB* = 0x8C11.GLenum + GL_PIXEL_PACK_BUFFER* = 0x88EB.GLenum + GL_VERTEX_WEIGHT_ARRAY_EXT* = 0x850C.GLenum + GL_HALF_FLOAT* = 0x140B.GLenum + GL_REG_0_ATI* = 0x8921.GLenum + GL_DEPTH_BUFFER_BIT4_QCOM* = 0x00001000.GLbitfield + GL_UNSIGNED_INT_5_9_9_9_REV_EXT* = 0x8C3E.GLenum + GL_DEPTH_COMPONENT16_SGIX* = 0x81A5.GLenum + GL_COMPRESSED_RGBA_ASTC_8x5_KHR* = 0x93B5.GLenum + GL_EDGE_FLAG_ARRAY_LENGTH_NV* = 0x8F30.GLenum + GL_CON_17_ATI* = 0x8952.GLenum + GL_PARAMETER_BUFFER_ARB* = 0x80EE.GLenum + GL_COLOR_ATTACHMENT6_EXT* = 0x8CE6.GLenum + GL_INDEX_ARRAY_EXT* = 0x8077.GLenum + GL_ALPHA_SCALE* = 0x0D1C.GLenum + GL_LINE_QUALITY_HINT_SGIX* = 0x835B.GLenum + GL_SLUMINANCE8* = 0x8C47.GLenum + GL_DEBUG_OUTPUT_KHR* = 0x92E0.GLenum + GL_TEXTURE_LIGHTING_MODE_HP* = 0x8167.GLenum + GL_SPOT_DIRECTION* = 0x1204.GLenum + GL_V3F* = 0x2A21.GLenum + GL_ALPHA16_EXT* = 0x803E.GLenum + GL_DRAW_BUFFER15_NV* = 0x8834.GLenum + GL_MIN_PROGRAM_TEXEL_OFFSET_EXT* = 0x8904.GLenum + GL_ACTIVE_VARYING_MAX_LENGTH_NV* = 0x8C82.GLenum + GL_COLOR_ATTACHMENT10* = 0x8CEA.GLenum + GL_COLOR_ARRAY_LIST_STRIDE_IBM* = 103082.GLenum + GL_TEXTURE_TARGET_QCOM* = 0x8BDA.GLenum + GL_DRAW_BUFFER12_ARB* = 0x8831.GLenum + GL_SAMPLE_MASK* = 0x8E51.GLenum + GL_TEXTURE_FORMAT_QCOM* = 0x8BD6.GLenum + GL_TEXTURE_COMPONENTS* = 0x1003.GLenum + GL_PROGRAM_PIPELINE_BINDING* = 0x825A.GLenum + GL_HIGH_INT* = 0x8DF5.GLenum + GL_MAP_INVALIDATE_BUFFER_BIT* = 0x0008.GLbitfield + GL_LAYOUT_LINEAR_CPU_CACHED_INTEL* = 2.GLenum + GL_TEXTURE_DS_SIZE_NV* = 0x871D.GLenum + GL_HALF_FLOAT_NV* = 0x140B.GLenum + GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE* = 0x80D5.GLenum + GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER* = 0x8A45.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR* = 0x93DB.GLenum + GL_REG_18_ATI* = 0x8933.GLenum + GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS* = 0x8266.GLenum + GL_UNPACK_FLIP_Y_WEBGL* = 0x9240.GLenum + GL_POLYGON_STIPPLE_BIT* = 0x00000010.GLbitfield + GL_MULTISAMPLE_BUFFER_BIT6_QCOM* = 0x40000000.GLbitfield + GL_ONE_MINUS_SRC_ALPHA* = 0x0303.GLenum + GL_RASTERIZER_DISCARD_EXT* = 0x8C89.GLenum + GL_BGRA_INTEGER* = 0x8D9B.GLenum + GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS* = 0x92CE.GLenum + GL_MODELVIEW1_EXT* = 0x850A.GLenum + GL_VERTEX_ELEMENT_SWIZZLE_AMD* = 0x91A4.GLenum + GL_MAP1_GRID_SEGMENTS* = 0x0DD1.GLenum + GL_PATH_ERROR_POSITION_NV* = 0x90AB.GLenum + GL_FOG_COORDINATE_ARRAY_EXT* = 0x8457.GLenum + GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI* = 0x8973.GLenum + GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB* = 0x880D.GLenum + GL_PATH_GEN_COLOR_FORMAT_NV* = 0x90B2.GLenum + GL_BUFFER_VARIABLE* = 0x92E5.GLenum + GL_PROXY_TEXTURE_CUBE_MAP_ARB* = 0x851B.GLenum + GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB* = 0x8E8D.GLenum + GL_TEXT_FRAGMENT_SHADER_ATI* = 0x8200.GLenum + GL_ALPHA_MAX_SGIX* = 0x8321.GLenum + GL_UNPACK_ALIGNMENT* = 0x0CF5.GLenum + GL_POST_COLOR_MATRIX_RED_SCALE* = 0x80B4.GLenum + GL_CIRCULAR_CW_ARC_TO_NV* = 0xFA.GLenum + GL_MAX_SAMPLES_APPLE* = 0x8D57.GLenum + GL_4PASS_3_SGIS* = 0x80A7.GLenum + GL_SAMPLER_3D_OES* = 0x8B5F.GLenum + GL_UNSIGNED_INT16_VEC2_NV* = 0x8FF1.GLenum + GL_UNSIGNED_INT_SAMPLER_1D_ARRAY* = 0x8DD6.GLenum + GL_REG_8_ATI* = 0x8929.GLenum + GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT* = 0x8366.GLenum + GL_QUERY_RESULT_AVAILABLE_EXT* = 0x8867.GLenum + GL_INTENSITY8_EXT* = 0x804B.GLenum + GL_OUTPUT_TEXTURE_COORD9_EXT* = 0x87A6.GLenum + GL_TEXTURE_BINDING_RECTANGLE_NV* = 0x84F6.GLenum + GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV* = 0x8853.GLenum + GL_IMAGE_FORMAT_COMPATIBILITY_TYPE* = 0x90C7.GLenum + GL_WRITE_ONLY* = 0x88B9.GLenum + GL_SAMPLER_1D_SHADOW* = 0x8B61.GLenum + GL_DISPATCH_INDIRECT_BUFFER_BINDING* = 0x90EF.GLenum + GL_VERTEX_PROGRAM_BINDING_NV* = 0x864A.GLenum + GL_RGB8_EXT* = 0x8051.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR* = 0x93D7.GLenum + GL_CON_5_ATI* = 0x8946.GLenum + GL_DUAL_INTENSITY8_SGIS* = 0x8119.GLenum + GL_MAX_SAMPLES_EXT* = 0x8D57.GLenum + GL_VERTEX_ARRAY_POINTER_EXT* = 0x808E.GLenum + GL_COMBINE_EXT* = 0x8570.GLenum + GL_MULTISAMPLE_BUFFER_BIT1_QCOM* = 0x02000000.GLbitfield + GL_MAGNITUDE_SCALE_NV* = 0x8712.GLenum + GL_SYNC_CONDITION_APPLE* = 0x9113.GLenum + GL_RGBA_S3TC* = 0x83A2.GLenum + GL_LINE_STIPPLE_REPEAT* = 0x0B26.GLenum + GL_TEXTURE_COMPRESSION_HINT* = 0x84EF.GLenum + GL_TEXTURE_COMPARE_MODE* = 0x884C.GLenum + GL_RGBA_FLOAT_MODE_ATI* = 0x8820.GLenum + GL_OPERAND0_RGB* = 0x8590.GLenum + GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV* = 0x870D.GLenum + GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI* = 0x80B5.GLenum + GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV* = 0x9033.GLenum + GL_UNPACK_ROW_LENGTH* = 0x0CF2.GLenum + GL_DOUBLE_MAT2_EXT* = 0x8F46.GLenum + GL_TEXTURE_GEQUAL_R_SGIX* = 0x819D.GLenum + GL_UNSIGNED_INT_8_24_REV_MESA* = 0x8752.GLenum + GL_DSDT8_NV* = 0x8709.GLenum + GL_RESAMPLE_DECIMATE_SGIX* = 0x8430.GLenum + GL_DEBUG_SOURCE_OTHER_KHR* = 0x824B.GLenum + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB* = 0x8DA8.GLenum + GL_MAX_VERTEX_UNITS_OES* = 0x86A4.GLenum + GL_ISOLINES* = 0x8E7A.GLenum + GL_INCR_WRAP* = 0x8507.GLenum + GL_BUFFER_MAP_POINTER* = 0x88BD.GLenum + GL_INT_SAMPLER_CUBE_MAP_ARRAY* = 0x900E.GLenum + GL_UNSIGNED_INT_VEC2* = 0x8DC6.GLenum + GL_RENDERBUFFER_HEIGHT_OES* = 0x8D43.GLenum + GL_COMPRESSED_RGBA_ASTC_10x10_KHR* = 0x93BB.GLenum + GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX* = 0x818A.GLenum + GL_LINEAR_SHARPEN_COLOR_SGIS* = 0x80AF.GLenum + GL_COLOR_ATTACHMENT5_EXT* = 0x8CE5.GLenum + GL_VERTEX_ATTRIB_ARRAY9_NV* = 0x8659.GLenum + GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING* = 0x889D.GLenum + GL_BLEND_DST_RGB* = 0x80C8.GLenum + GL_VERTEX_ARRAY_EXT* = 0x8074.GLenum + GL_VERTEX_ARRAY_RANGE_POINTER_NV* = 0x8521.GLenum + GL_DEBUG_SEVERITY_MEDIUM_ARB* = 0x9147.GLenum + GL_OPERAND0_ALPHA* = 0x8598.GLenum + GL_TEXTURE_BINDING_CUBE_MAP* = 0x8514.GLenum + GL_ADD_ATI* = 0x8963.GLenum + GL_AUX1* = 0x040A.GLenum + GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT* = 0x8210.GLenum + GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS* = 0x8CD9.GLenum + GL_MINUS_NV* = 0x929F.GLenum + GL_RGB4* = 0x804F.GLenum + GL_COMPRESSED_RGBA_ASTC_12x12_KHR* = 0x93BD.GLenum + GL_MAX_GEOMETRY_OUTPUT_VERTICES* = 0x8DE0.GLenum + GL_SURFACE_STATE_NV* = 0x86EB.GLenum + GL_COLOR_MATERIAL_FACE* = 0x0B55.GLenum + GL_TEXTURE18_ARB* = 0x84D2.GLenum + GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES* = 0x9277.GLenum + GL_LOWER_LEFT* = 0x8CA1.GLenum + GL_DRAW_BUFFER8_ATI* = 0x882D.GLenum + GL_TEXTURE_CONSTANT_DATA_SUNX* = 0x81D6.GLenum + GL_SAMPLER_1D* = 0x8B5D.GLenum + GL_POLYGON_OFFSET_EXT* = 0x8037.GLenum + GL_EQUIV* = 0x1509.GLenum + GL_QUERY_BUFFER_BINDING* = 0x9193.GLenum + GL_COMBINE_ARB* = 0x8570.GLenum + GL_MATRIX0_NV* = 0x8630.GLenum + GL_CLAMP_TO_BORDER_SGIS* = 0x812D.GLint + GL_INTENSITY8UI_EXT* = 0x8D7F.GLenum + GL_TRACK_MATRIX_TRANSFORM_NV* = 0x8649.GLenum + GL_SURFACE_MAPPED_NV* = 0x8700.GLenum + GL_INT_VEC3_ARB* = 0x8B54.GLenum + GL_IMAGE_TRANSFORM_2D_HP* = 0x8161.GLenum + GL_PROGRAM_BINARY_RETRIEVABLE_HINT* = 0x8257.GLenum + GL_DRAW_BUFFER8_EXT* = 0x882D.GLenum + GL_DEPTH_STENCIL_EXT* = 0x84F9.GLenum + GL_CONTEXT_PROFILE_MASK* = 0x9126.GLenum + GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB* = 0x88A3.GLenum + GL_MATRIX5_ARB* = 0x88C5.GLenum + GL_FRAMEBUFFER_UNDEFINED_OES* = 0x8219.GLenum + GL_UNPACK_CMYK_HINT_EXT* = 0x800F.GLenum + GL_UNSIGNED_NORMALIZED_EXT* = 0x8C17.GLenum + GL_ONE* = 1.GLenum + GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB* = 0x889B.GLenum + GL_TRANSPOSE_PROJECTION_MATRIX* = 0x84E4.GLenum + GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV* = 0x8C28.GLenum + GL_CLIP_DISTANCE3* = 0x3003.GLenum + GL_4PASS_1_SGIS* = 0x80A5.GLenum + GL_MAX_FRAGMENT_LIGHTS_SGIX* = 0x8404.GLenum + GL_TEXTURE_3D_OES* = 0x806F.GLenum + GL_TEXTURE0* = 0x84C0.GLenum + GL_INT_IMAGE_CUBE_EXT* = 0x905B.GLenum + GL_INNOCENT_CONTEXT_RESET_ARB* = 0x8254.GLenum + GL_INDEX_ARRAY_TYPE_EXT* = 0x8085.GLenum + GL_SAMPLER_OBJECT_AMD* = 0x9155.GLenum + GL_INDEX_ARRAY_BUFFER_BINDING_ARB* = 0x8899.GLenum + GL_RENDERBUFFER_DEPTH_SIZE_OES* = 0x8D54.GLenum + GL_MAX_SAMPLE_MASK_WORDS* = 0x8E59.GLenum + GL_COMBINER2_NV* = 0x8552.GLenum + GL_COLOR_ARRAY_BUFFER_BINDING_ARB* = 0x8898.GLenum + GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB* = 0x886A.GLenum + GL_STREAM_DRAW* = 0x88E0.GLenum + GL_RGB8I* = 0x8D8F.GLenum + GL_BLEND_COLOR_EXT* = 0x8005.GLenum + GL_MAX_VARYING_VECTORS* = 0x8DFC.GLenum + GL_COPY_WRITE_BUFFER_BINDING* = 0x8F37.GLenum + GL_FIXED_ONLY_ARB* = 0x891D.GLenum + GL_INT_VEC4* = 0x8B55.GLenum + GL_PROGRAM_PIPELINE_BINDING_EXT* = 0x825A.GLenum + GL_UNSIGNED_NORMALIZED_ARB* = 0x8C17.GLenum + GL_NUM_INSTRUCTIONS_PER_PASS_ATI* = 0x8971.GLenum + GL_PIXEL_MODE_BIT* = 0x00000020.GLbitfield + GL_COMPRESSED_RED_RGTC1* = 0x8DBB.GLenum + GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT* = 0x00000020.GLbitfield + GL_VARIANT_DATATYPE_EXT* = 0x87E5.GLenum + GL_DARKEN_NV* = 0x9297.GLenum + GL_POINT_SIZE_MAX_SGIS* = 0x8127.GLenum + GL_OBJECT_ATTACHED_OBJECTS_ARB* = 0x8B85.GLenum + GL_SLUMINANCE_ALPHA_EXT* = 0x8C44.GLenum + GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY* = 0x906A.GLenum + GL_EDGE_FLAG_ARRAY* = 0x8079.GLenum + GL_LINEAR_CLIPMAP_NEAREST_SGIX* = 0x844F.GLenum + GL_LUMINANCE_ALPHA32F_EXT* = 0x8819.GLenum + GL_NORMAL_BIT_PGI* = 0x08000000.GLbitfield + GL_SECONDARY_COLOR_ARRAY* = 0x845E.GLenum + GL_CLIP_PLANE1_IMG* = 0x3001.GLenum + GL_REG_19_ATI* = 0x8934.GLenum + GL_PIXEL_PACK_BUFFER_BINDING* = 0x88ED.GLenum + GL_PIXEL_GROUP_COLOR_SGIS* = 0x8356.GLenum + GL_SELECTION_BUFFER_SIZE* = 0x0DF4.GLenum + GL_SRC_OUT_NV* = 0x928C.GLenum + GL_TEXTURE7* = 0x84C7.GLenum + GL_COMPARE_R_TO_TEXTURE* = 0x884E.GLenum + GL_DUDV_ATI* = 0x8779.GLenum + GL_TEXTURE_BASE_LEVEL* = 0x813C.GLenum + GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI* = 0x87F5.GLenum + GL_LAYOUT_LINEAR_INTEL* = 1.GLenum + GL_DEPTH_BUFFER_BIT2_QCOM* = 0x00000400.GLbitfield + GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS* = 0x8E8A.GLenum + GL_LIGHT3* = 0x4003.GLenum + GL_ALPHA_MAX_CLAMP_INGR* = 0x8567.GLenum + GL_RG_INTEGER* = 0x8228.GLenum + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL* = 0x8CD2.GLenum + GL_TEXTURE_STACK_DEPTH* = 0x0BA5.GLenum + GL_ALREADY_SIGNALED* = 0x911A.GLenum + GL_TEXTURE_CUBE_MAP_OES* = 0x8513.GLenum + GL_N3F_V3F* = 0x2A25.GLenum + GL_SUBTRACT_ARB* = 0x84E7.GLenum + GL_ELEMENT_ARRAY_LENGTH_NV* = 0x8F33.GLenum + GL_NORMAL_ARRAY_EXT* = 0x8075.GLenum + GL_POLYGON_OFFSET_FACTOR_EXT* = 0x8038.GLenum + GL_EIGHTH_BIT_ATI* = 0x00000020.GLbitfield + GL_UNSIGNED_INT_SAMPLER_2D_RECT* = 0x8DD5.GLenum + GL_OBJECT_ACTIVE_ATTRIBUTES_ARB* = 0x8B89.GLenum + GL_MAX_VERTEX_VARYING_COMPONENTS_ARB* = 0x8DDE.GLenum + GL_TEXTURE_COORD_ARRAY_STRIDE_EXT* = 0x808A.GLenum + GL_4_BYTES* = 0x1409.GLenum + GL_SAMPLE_SHADING* = 0x8C36.GLenum + GL_FOG_MODE* = 0x0B65.GLenum + GL_CON_7_ATI* = 0x8948.GLenum + GL_DRAW_FRAMEBUFFER* = 0x8CA9.GLenum + GL_TEXTURE_MEMORY_LAYOUT_INTEL* = 0x83FF.GLenum + GL_RGB32I_EXT* = 0x8D83.GLenum + GL_VERTEX_ARRAY_STRIDE* = 0x807C.GLenum + GL_COLOR_ATTACHMENT3_NV* = 0x8CE3.GLenum + GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL* = 0x83F6.GLenum + GL_CONTRAST_NV* = 0x92A1.GLenum + GL_RGBA32F* = 0x8814.GLenum + GL_YCBAYCR8A_4224_NV* = 0x9032.GLenum + GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET* = 0x82D9.GLenum + GL_TEXTURE22* = 0x84D6.GLenum + GL_TEXTURE_3D* = 0x806F.GLenum + GL_STENCIL_PASS_DEPTH_FAIL* = 0x0B95.GLenum + GL_PROXY_HISTOGRAM_EXT* = 0x8025.GLenum + GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS* = 0x92C5.GLenum + GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE* = 0x92D8.GLenum + GL_FOG_COORD_ARRAY_TYPE* = 0x8454.GLenum + GL_MAP2_VERTEX_4* = 0x0DB8.GLenum + GL_PACK_COMPRESSED_SIZE_SGIX* = 0x831C.GLenum + GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX* = 0x817C.GLenum + GL_ITALIC_BIT_NV* = 0x02.GLbitfield + GL_COMPRESSED_LUMINANCE_ALPHA* = 0x84EB.GLenum + GL_COLOR_TABLE_SCALE_SGI* = 0x80D6.GLenum + GL_DOUBLE_MAT2x4_EXT* = 0x8F4A.GLenum + GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE* = 0x8215.GLenum + GL_MATRIX11_ARB* = 0x88CB.GLenum + GL_REG_5_ATI* = 0x8926.GLenum + GL_RGBA2_EXT* = 0x8055.GLenum + GL_DISCARD_NV* = 0x8530.GLenum + GL_TEXTURE7_ARB* = 0x84C7.GLenum + GL_LUMINANCE32UI_EXT* = 0x8D74.GLenum + GL_ACTIVE_UNIFORM_BLOCKS* = 0x8A36.GLenum + GL_UNSIGNED_INT16_VEC4_NV* = 0x8FF3.GLenum + GL_VERTEX_ATTRIB_ARRAY5_NV* = 0x8655.GLenum + GL_DOUBLE_MAT3x4* = 0x8F4C.GLenum + GL_BOOL* = 0x8B56.GLenum + GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB* = 0x86A2.GLenum + GL_COMPRESSED_RGB_ARB* = 0x84ED.GLenum + GL_DEBUG_TYPE_MARKER_KHR* = 0x8268.GLenum + GL_TEXTURE_DEPTH_QCOM* = 0x8BD4.GLenum + GL_VARIABLE_F_NV* = 0x8528.GLenum + GL_MAX_PIXEL_MAP_TABLE* = 0x0D34.GLenum + GL_DST_COLOR* = 0x0306.GLenum + GL_OR_INVERTED* = 0x150D.GLenum + GL_TRANSFORM_FEEDBACK_VARYINGS_NV* = 0x8C83.GLenum + GL_RGB_INTEGER* = 0x8D98.GLenum + GL_COLOR_MATERIAL* = 0x0B57.GLenum + GL_DEBUG_SEVERITY_LOW_AMD* = 0x9148.GLenum + GL_MIRROR_CLAMP_TO_BORDER_EXT* = 0x8912.GLint + GL_TEXTURE1_ARB* = 0x84C1.GLenum + GL_MIN_MAP_BUFFER_ALIGNMENT* = 0x90BC.GLenum + GL_MATRIX16_ARB* = 0x88D0.GLenum + GL_TEXTURE_ALPHA_TYPE_ARB* = 0x8C13.GLenum + GL_PROGRAM_POINT_SIZE* = 0x8642.GLenum + GL_COMBINER_AB_OUTPUT_NV* = 0x854A.GLenum + GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES* = 0x9276.GLenum + GL_RGB4_S3TC* = 0x83A1.GLenum + GL_TEXTURE_EXTERNAL_OES* = 0x8D65.GLenum + GL_MAX_MAP_TESSELLATION_NV* = 0x86D6.GLenum + GL_AUX_DEPTH_STENCIL_APPLE* = 0x8A14.GLenum + GL_MAX_DEBUG_LOGGED_MESSAGES_AMD* = 0x9144.GLenum + GL_CONSTANT_BORDER* = 0x8151.GLenum + GL_RESAMPLE_ZERO_FILL_OML* = 0x8987.GLenum + GL_POST_CONVOLUTION_ALPHA_SCALE_EXT* = 0x801F.GLenum + GL_OBJECT_VALIDATE_STATUS_ARB* = 0x8B83.GLenum + GL_DST_ALPHA* = 0x0304.GLenum + GL_COMBINER5_NV* = 0x8555.GLenum + GL_VERSION_ES_CL_1_1* = 1.GLenum + GL_MOVE_TO_CONTINUES_NV* = 0x90B6.GLenum + GL_IMAGE_MAG_FILTER_HP* = 0x815C.GLenum + GL_TEXTURE_FREE_MEMORY_ATI* = 0x87FC.GLenum + GL_DEBUG_TYPE_PORTABILITY_KHR* = 0x824F.GLenum + GL_BUFFER_UPDATE_BARRIER_BIT* = 0x00000200.GLbitfield + GL_FUNC_ADD* = 0x8006.GLenum + GL_PN_TRIANGLES_POINT_MODE_ATI* = 0x87F2.GLenum + GL_DEBUG_CALLBACK_USER_PARAM_ARB* = 0x8245.GLenum + GL_CURRENT_SECONDARY_COLOR* = 0x8459.GLenum + GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV* = 0x885A.GLenum + GL_FRAGMENT_LIGHT7_SGIX* = 0x8413.GLenum + GL_MAP2_TEXTURE_COORD_4* = 0x0DB6.GLenum + GL_PACK_ALIGNMENT* = 0x0D05.GLenum + GL_VERTEX23_BIT_PGI* = 0x00000004.GLbitfield + GL_MAX_CLIPMAP_DEPTH_SGIX* = 0x8177.GLenum + GL_TEXTURE_3D_BINDING_EXT* = 0x806A.GLenum + GL_COLOR_ATTACHMENT1* = 0x8CE1.GLenum + GL_NEAREST* = 0x2600.GLint + GL_MAX_DEBUG_LOGGED_MESSAGES* = 0x9144.GLenum + GL_COMBINER6_NV* = 0x8556.GLenum + GL_COLOR_SUM_EXT* = 0x8458.GLenum + GL_CONVOLUTION_WIDTH* = 0x8018.GLenum + GL_SAMPLE_ALPHA_TO_COVERAGE_ARB* = 0x809E.GLenum + GL_DRAW_FRAMEBUFFER_EXT* = 0x8CA9.GLenum + GL_PROXY_HISTOGRAM* = 0x8025.GLenum + GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS* = 0x8355.GLenum + GL_COMPRESSED_RGBA_ASTC_10x5_KHR* = 0x93B8.GLenum + GL_SMOOTH_CUBIC_CURVE_TO_NV* = 0x10.GLenum + GL_BGR_EXT* = 0x80E0.GLenum + GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB* = 0x88B6.GLenum + GL_VIBRANCE_BIAS_NV* = 0x8719.GLenum + GL_UNPACK_COLORSPACE_CONVERSION_WEBGL* = 0x9243.GLenum + GL_SLUMINANCE8_NV* = 0x8C47.GLenum + GL_TEXTURE_MAX_LEVEL_SGIS* = 0x813D.GLenum + GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX* = 0x92DA.GLenum + GL_RGB9_E5_EXT* = 0x8C3D.GLenum + GL_CULL_VERTEX_IBM* = 103050.GLenum + GL_PROXY_COLOR_TABLE* = 0x80D3.GLenum + GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE* = 0x8216.GLenum + GL_MAX_FRAGMENT_UNIFORM_COMPONENTS* = 0x8B49.GLenum + GL_CCW* = 0x0901.GLenum + GL_COLOR_WRITEMASK* = 0x0C23.GLenum + GL_TEXTURE19_ARB* = 0x84D3.GLenum + GL_VERTEX_STREAM3_ATI* = 0x876F.GLenum + GL_ONE_EXT* = 0x87DE.GLenum + GL_MAX_SAMPLES* = 0x8D57.GLenum + GL_STENCIL_PASS_DEPTH_PASS* = 0x0B96.GLenum + GL_PERFMON_RESULT_AVAILABLE_AMD* = 0x8BC4.GLenum + GL_RETURN* = 0x0102.GLenum + GL_DETAIL_TEXTURE_LEVEL_SGIS* = 0x809A.GLenum + GL_UNSIGNED_INT_IMAGE_CUBE_EXT* = 0x9066.GLenum + GL_FOG_OFFSET_VALUE_SGIX* = 0x8199.GLenum + GL_TEXTURE_MAX_LOD_SGIS* = 0x813B.GLenum + GL_TRANSPOSE_COLOR_MATRIX_ARB* = 0x84E6.GLenum + GL_DEBUG_SOURCE_APPLICATION_ARB* = 0x824A.GLenum + GL_SIGNED_ALPHA_NV* = 0x8705.GLenum + GL_UNSIGNED_INT_IMAGE_2D_EXT* = 0x9063.GLenum + GL_SHADER_IMAGE_ACCESS_BARRIER_BIT* = 0x00000020.GLbitfield + GL_ATOMIC_COUNTER_BARRIER_BIT* = 0x00001000.GLbitfield + GL_COLOR3_BIT_PGI* = 0x00010000.GLbitfield + GL_MATERIAL_SIDE_HINT_PGI* = 0x1A22C.GLenum + GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE* = 0x85B0.GLenum + GL_LINEAR_SHARPEN_SGIS* = 0x80AD.GLenum + GL_LUMINANCE_SNORM* = 0x9011.GLenum + GL_TEXTURE_LUMINANCE_SIZE* = 0x8060.GLenum + GL_REPLACE_MIDDLE_SUN* = 0x0002.GLenum + GL_TEXTURE_DEFORMATION_SGIX* = 0x8195.GLenum + GL_MULTISAMPLE_BUFFER_BIT7_QCOM* = 0x80000000.GLbitfield + GL_FONT_HAS_KERNING_BIT_NV* = 0x10000000.GLbitfield + GL_COPY* = 0x1503.GLenum + GL_READ_BUFFER_NV* = 0x0C02.GLenum + GL_TRANSPOSE_CURRENT_MATRIX_ARB* = 0x88B7.GLenum + GL_VERTEX_ARRAY_OBJECT_AMD* = 0x9154.GLenum + GL_TIMEOUT_EXPIRED* = 0x911B.GLenum + GL_DYNAMIC_COPY* = 0x88EA.GLenum + GL_DRAW_BUFFER2_ARB* = 0x8827.GLenum + GL_OUTPUT_TEXTURE_COORD10_EXT* = 0x87A7.GLenum + GL_SIGNED_RGBA8_NV* = 0x86FC.GLenum + GL_MATRIX6_ARB* = 0x88C6.GLenum + GL_OP_SUB_EXT* = 0x8796.GLenum + GL_NO_RESET_NOTIFICATION_EXT* = 0x8261.GLenum + GL_TEXTURE_BASE_LEVEL_SGIS* = 0x813C.GLenum + GL_ALPHA_INTEGER* = 0x8D97.GLenum + GL_TEXTURE13* = 0x84CD.GLenum + GL_EYE_LINEAR* = 0x2400.GLenum + GL_INTENSITY4_EXT* = 0x804A.GLenum + GL_SOURCE1_RGB_EXT* = 0x8581.GLenum + GL_AUX_BUFFERS* = 0x0C00.GLenum + GL_SOURCE0_ALPHA* = 0x8588.GLenum + GL_RGB32I* = 0x8D83.GLenum + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS* = 0x8C8A.GLenum + GL_VIEW_CLASS_S3TC_DXT1_RGBA* = 0x82CD.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV* = 0x8C85.GLenum + GL_SAMPLER_KHR* = 0x82E6.GLenum + GL_WRITEONLY_RENDERING_QCOM* = 0x8823.GLenum + GL_PACK_SKIP_ROWS* = 0x0D03.GLenum + GL_MAP1_VERTEX_ATTRIB0_4_NV* = 0x8660.GLenum + GL_PATH_STENCIL_VALUE_MASK_NV* = 0x90B9.GLenum + GL_REPLACE_EXT* = 0x8062.GLenum + GL_MODELVIEW3_ARB* = 0x8723.GLenum + GL_ONE_MINUS_CONSTANT_ALPHA* = 0x8004.GLenum + GL_DSDT8_MAG8_INTENSITY8_NV* = 0x870B.GLenum + GL_CURRENT_QUERY_ARB* = 0x8865.GLenum + GL_LUMINANCE8_ALPHA8_OES* = 0x8045.GLenum + GL_ARRAY_ELEMENT_LOCK_COUNT_EXT* = 0x81A9.GLenum + GL_MODELVIEW19_ARB* = 0x8733.GLenum + GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT* = 0x87C5.GLenum + GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB* = 0x8810.GLenum + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT* = 0x906C.GLenum + GL_NORMAL_ARRAY_BUFFER_BINDING* = 0x8897.GLenum + GL_AMBIENT* = 0x1200.GLenum + GL_TEXTURE_MATERIAL_PARAMETER_EXT* = 0x8352.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR* = 0x93DA.GLenum + GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS* = 0x8E7F.GLenum + GL_COMPRESSED_LUMINANCE_ALPHA_ARB* = 0x84EB.GLenum + GL_MODELVIEW14_ARB* = 0x872E.GLenum + GL_INTERLACE_READ_OML* = 0x8981.GLenum + GL_RENDERBUFFER_FREE_MEMORY_ATI* = 0x87FD.GLenum + GL_EMBOSS_MAP_NV* = 0x855F.GLenum + GL_POINT_SIZE_RANGE* = 0x0B12.GLenum + GL_FOG_COORDINATE* = 0x8451.GLenum + GL_MAJOR_VERSION* = 0x821B.GLenum + GL_FRAME_NV* = 0x8E26.GLenum + GL_CURRENT_TEXTURE_COORDS* = 0x0B03.GLenum + GL_PACK_RESAMPLE_OML* = 0x8984.GLenum + GL_DEPTH24_STENCIL8_OES* = 0x88F0.GLenum + GL_PROGRAM_BINARY_FORMATS_OES* = 0x87FF.GLenum + GL_TRANSLATE_3D_NV* = 0x9091.GLenum + GL_TEXTURE_GEN_Q* = 0x0C63.GLenum + GL_COLOR_ATTACHMENT0_EXT* = 0x8CE0.GLenum + GL_ALPHA12* = 0x803D.GLenum + GL_INCR_WRAP_EXT* = 0x8507.GLenum + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN* = 0x8C88.GLenum + GL_DUAL_ALPHA12_SGIS* = 0x8112.GLenum + GL_EYE_LINE_SGIS* = 0x81F6.GLenum + GL_TEXTURE_MAX_LEVEL_APPLE* = 0x813D.GLenum + GL_TRIANGLE_FAN* = 0x0006.GLenum + GL_DEBUG_GROUP_STACK_DEPTH* = 0x826D.GLenum + GL_IMAGE_CLASS_1_X_16* = 0x82BE.GLenum + GL_COMPILE* = 0x1300.GLenum + GL_LINE_SMOOTH* = 0x0B20.GLenum + GL_FEEDBACK_BUFFER_POINTER* = 0x0DF0.GLenum + GL_CURRENT_SECONDARY_COLOR_EXT* = 0x8459.GLenum + GL_DRAW_BUFFER2_ATI* = 0x8827.GLenum + GL_PN_TRIANGLES_NORMAL_MODE_ATI* = 0x87F3.GLenum + GL_MODELVIEW0_ARB* = 0x1700.GLenum + GL_SRGB8_ALPHA8* = 0x8C43.GLenum + GL_TEXTURE_BLUE_TYPE* = 0x8C12.GLenum + GL_POST_CONVOLUTION_ALPHA_BIAS* = 0x8023.GLenum + GL_PATH_STROKE_BOUNDING_BOX_NV* = 0x90A2.GLenum + GL_RGBA16UI* = 0x8D76.GLenum + GL_OFFSET_HILO_TEXTURE_2D_NV* = 0x8854.GLenum + GL_PREVIOUS_ARB* = 0x8578.GLenum + GL_BINORMAL_ARRAY_EXT* = 0x843A.GLenum + GL_UNSIGNED_INT_IMAGE_CUBE* = 0x9066.GLenum + GL_REG_30_ATI* = 0x893F.GLenum + GL_VIEWPORT_SUBPIXEL_BITS* = 0x825C.GLenum + GL_VERSION* = 0x1F02.GLenum + GL_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV* = 0x90FC.GLenum + GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD* = 0x914E.GLenum + GL_CONVOLUTION_FILTER_SCALE_EXT* = 0x8014.GLenum + GL_HALF_BIT_ATI* = 0x00000008.GLbitfield + GL_SPRITE_AXIS_SGIX* = 0x814A.GLenum + GL_INDEX_ARRAY_STRIDE* = 0x8086.GLenum + GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB* = 0x88B2.GLenum + GL_EVAL_VERTEX_ATTRIB0_NV* = 0x86C6.GLenum + GL_COUNTER_RANGE_AMD* = 0x8BC1.GLenum + GL_VERTEX_WEIGHTING_EXT* = 0x8509.GLenum + GL_POST_CONVOLUTION_GREEN_SCALE* = 0x801D.GLenum + GL_UNSIGNED_INT8_NV* = 0x8FEC.GLenum + GL_CURRENT_MATRIX_STACK_DEPTH_NV* = 0x8640.GLenum + GL_STENCIL_INDEX1_OES* = 0x8D46.GLenum + GL_SLUMINANCE_NV* = 0x8C46.GLenum + GL_UNSIGNED_INT_8_8_8_8_REV_EXT* = 0x8367.GLenum + GL_HISTOGRAM_FORMAT* = 0x8027.GLenum + GL_LUMINANCE12_ALPHA4_EXT* = 0x8046.GLenum + GL_FLOAT_MAT3* = 0x8B5B.GLenum + GL_MAX_PROGRAM_TEXEL_OFFSET_NV* = 0x8905.GLenum + GL_PALETTE8_RGBA4_OES* = 0x8B98.GLenum + GL_UNPACK_SKIP_IMAGES_EXT* = 0x806D.GLenum + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y* = 0x8518.GLenum + GL_UNPACK_SUBSAMPLE_RATE_SGIX* = 0x85A1.GLenum + GL_NORMAL_ARRAY_LENGTH_NV* = 0x8F2C.GLenum + GL_VERTEX_ATTRIB_ARRAY4_NV* = 0x8654.GLenum + GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES* = 0x8CD9.GLenum + GL_UNSIGNED_BYTE* = 0x1401.GLenum + GL_RGB2_EXT* = 0x804E.GLenum + GL_TEXTURE_BUFFER_SIZE* = 0x919E.GLenum + GL_MAP_STENCIL* = 0x0D11.GLenum + GL_TIMEOUT_EXPIRED_APPLE* = 0x911B.GLenum + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS* = 0x8C29.GLenum + GL_CON_14_ATI* = 0x894F.GLenum + GL_RGBA12* = 0x805A.GLenum + GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS* = 0x919A.GLenum + GL_CON_20_ATI* = 0x8955.GLenum + GL_LOCAL_CONSTANT_DATATYPE_EXT* = 0x87ED.GLenum + GL_DUP_FIRST_CUBIC_CURVE_TO_NV* = 0xF2.GLenum + GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV* = 0x8F27.GLenum + GL_TEXTURE_COORD_ARRAY* = 0x8078.GLenum + GL_LUMINANCE8I_EXT* = 0x8D92.GLenum + GL_REPLACE_OLDEST_SUN* = 0x0003.GLenum + GL_TEXTURE_SHADER_NV* = 0x86DE.GLenum + GL_UNSIGNED_INT_8_8_8_8_EXT* = 0x8035.GLenum + GL_SAMPLE_COVERAGE_INVERT* = 0x80AB.GLenum + GL_FOG_COORD_ARRAY_ADDRESS_NV* = 0x8F28.GLenum + GL_GPU_DISJOINT_EXT* = 0x8FBB.GLenum + GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI* = 0x8803.GLenum + GL_TEXTURE_GREEN_SIZE_EXT* = 0x805D.GLenum + GL_INTERLEAVED_ATTRIBS* = 0x8C8C.GLenum + GL_FOG_FUNC_SGIS* = 0x812A.GLenum + GL_TEXTURE_DEPTH_SIZE_ARB* = 0x884A.GLenum + GL_MAP_COHERENT_BIT* = 0x0080.GLbitfield + GL_COMPRESSED_SLUMINANCE_ALPHA* = 0x8C4B.GLenum + GL_RGB32UI* = 0x8D71.GLenum + GL_SEPARABLE_2D* = 0x8012.GLenum + GL_MATRIX10_ARB* = 0x88CA.GLenum + GL_FLOAT_RGBA32_NV* = 0x888B.GLenum + GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB* = 0x9199.GLenum + GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV* = 0x8E54.GLenum + GL_REG_9_ATI* = 0x892A.GLenum + GL_MAP2_VERTEX_ATTRIB14_4_NV* = 0x867E.GLenum + GL_OP_EXP_BASE_2_EXT* = 0x8791.GLenum + GL_INT_IMAGE_BUFFER_EXT* = 0x905C.GLenum + GL_TEXTURE_WRAP_R_EXT* = 0x8072.GLenum + GL_DOUBLE_VEC3* = 0x8FFD.GLenum + GL_DRAW_BUFFER5_EXT* = 0x882A.GLenum + GL_OUTPUT_TEXTURE_COORD7_EXT* = 0x87A4.GLenum + GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB* = 0x8242.GLenum + GL_MAX_TESS_GEN_LEVEL* = 0x8E7E.GLenum + GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB* = 0x8895.GLenum + GL_RGBA16I_EXT* = 0x8D88.GLenum + GL_REG_10_ATI* = 0x892B.GLenum + GL_MAT_EMISSION_BIT_PGI* = 0x00800000.GLbitfield + GL_TEXTURE_COORD_ARRAY_SIZE_EXT* = 0x8088.GLenum + GL_RED_BIAS* = 0x0D15.GLenum + GL_RGB16F_ARB* = 0x881B.GLenum + GL_ANY_SAMPLES_PASSED_CONSERVATIVE* = 0x8D6A.GLenum + GL_BLUE_MAX_CLAMP_INGR* = 0x8566.GLenum + cGL_FLOAT* = 0x1406.GLenum + GL_STENCIL_INDEX8_EXT* = 0x8D48.GLenum + GL_POINT_SIZE_ARRAY_OES* = 0x8B9C.GLenum + GL_INT16_NV* = 0x8FE4.GLenum + GL_PALETTE4_RGB8_OES* = 0x8B90.GLenum + GL_RENDERBUFFER_GREEN_SIZE_OES* = 0x8D51.GLenum + GL_SEPARATE_ATTRIBS_NV* = 0x8C8D.GLenum + GL_BOOL_VEC3_ARB* = 0x8B58.GLenum + GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES* = 0x92C6.GLenum + GL_STACK_UNDERFLOW_KHR* = 0x0504.GLenum + GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB* = 0x8519.GLenum + GL_COMPRESSED_INTENSITY_ARB* = 0x84EC.GLenum + GL_MAX_ASYNC_TEX_IMAGE_SGIX* = 0x835F.GLenum + GL_TEXTURE_4D_SGIS* = 0x8134.GLenum + GL_TEXCOORD3_BIT_PGI* = 0x40000000.GLbitfield + GL_PIXEL_MAP_I_TO_R_SIZE* = 0x0CB2.GLenum + GL_NORMAL_MAP_ARB* = 0x8511.GLenum + GL_MAX_CONVOLUTION_HEIGHT* = 0x801B.GLenum + GL_COMPRESSED_INTENSITY* = 0x84EC.GLenum + GL_FONT_Y_MAX_BOUNDS_BIT_NV* = 0x00080000.GLbitfield + GL_FLOAT_MAT2* = 0x8B5A.GLenum + GL_TEXTURE_SRGB_DECODE_EXT* = 0x8A48.GLenum + GL_FRAMEBUFFER_BLEND* = 0x828B.GLenum + GL_TEXTURE_COORD_ARRAY_LIST_IBM* = 103074.GLenum + GL_REG_12_ATI* = 0x892D.GLenum + GL_UNSIGNED_INT_ATOMIC_COUNTER* = 0x92DB.GLenum + GL_DETAIL_TEXTURE_2D_BINDING_SGIS* = 0x8096.GLenum + GL_OCCLUSION_TEST_HP* = 0x8165.GLenum + GL_TEXTURE11_ARB* = 0x84CB.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC* = 0x9279.GLenum + GL_BUFFER_MAPPED* = 0x88BC.GLenum + GL_VARIANT_ARRAY_STRIDE_EXT* = 0x87E6.GLenum + GL_CONVOLUTION_BORDER_COLOR_HP* = 0x8154.GLenum + GL_UNPACK_RESAMPLE_OML* = 0x8985.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE* = 0x8C85.GLenum + GL_PROXY_TEXTURE_2D_ARRAY_EXT* = 0x8C1B.GLenum + GL_RGBA4_EXT* = 0x8056.GLenum + GL_ALPHA32I_EXT* = 0x8D84.GLenum + GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE* = 0x92C4.GLenum + GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX* = 0x840A.GLenum + GL_BINORMAL_ARRAY_TYPE_EXT* = 0x8440.GLenum + GL_VIEW_CLASS_S3TC_DXT5_RGBA* = 0x82CF.GLenum + GL_TEXTURE_CLIPMAP_OFFSET_SGIX* = 0x8173.GLenum + GL_RESTART_SUN* = 0x0001.GLenum + GL_PERTURB_EXT* = 0x85AE.GLenum + GL_UNSIGNED_BYTE_3_3_2_EXT* = 0x8032.GLenum + GL_LUMINANCE16I_EXT* = 0x8D8C.GLenum + GL_TEXTURE3_ARB* = 0x84C3.GLenum + GL_POINT_SIZE_MIN_EXT* = 0x8126.GLenum + GL_OUTPUT_TEXTURE_COORD1_EXT* = 0x879E.GLenum + GL_COMPARE_REF_TO_TEXTURE* = 0x884E.GLenum + GL_KEEP* = 0x1E00.GLenum + GL_FLOAT_MAT2x4* = 0x8B66.GLenum + GL_FLOAT_VEC4_ARB* = 0x8B52.GLenum + GL_BIAS_BY_NEGATIVE_ONE_HALF_NV* = 0x8541.GLenum + GL_BGR* = 0x80E0.GLenum + GL_SHADER_BINARY_FORMATS* = 0x8DF8.GLenum + GL_CND0_ATI* = 0x896B.GLenum + GL_MIRRORED_REPEAT_IBM* = 0x8370.GLint + GL_REFLECTION_MAP_OES* = 0x8512.GLenum + GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT* = 0x8DE2.GLenum + GL_R* = 0x2002.GLenum + GL_MAX_SHADER_STORAGE_BLOCK_SIZE* = 0x90DE.GLenum + GL_ATTRIB_ARRAY_STRIDE_NV* = 0x8624.GLenum + GL_VARIABLE_E_NV* = 0x8527.GLenum + GL_HISTOGRAM_EXT* = 0x8024.GLenum + GL_TEXTURE_BINDING_BUFFER_ARB* = 0x8C2C.GLenum + GL_MAX_SPARSE_TEXTURE_SIZE_ARB* = 0x9198.GLenum + GL_TEXTURE5* = 0x84C5.GLenum + GL_NUM_ACTIVE_VARIABLES* = 0x9304.GLenum + GL_DEPTH_STENCIL_ATTACHMENT* = 0x821A.GLenum + GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB* = 0x889E.GLenum + GL_AMBIENT_AND_DIFFUSE* = 0x1602.GLenum + GL_LAYER_NV* = 0x8DAA.GLenum + GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV* = 0x08.GLbitfield + GL_TEXTURE8* = 0x84C8.GLenum + GL_MODELVIEW5_ARB* = 0x8725.GLenum + GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS* = 0x92D1.GLenum + GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS* = 0x92CD.GLenum + GL_BLUE_MIN_CLAMP_INGR* = 0x8562.GLenum + GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS* = 0x90D9.GLenum + GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES* = 0x8519.GLenum + GL_MAX_SAMPLES_IMG* = 0x9135.GLenum + GL_QUERY_BY_REGION_WAIT* = 0x8E15.GLenum + GL_T* = 0x2001.GLenum + GL_VIEW_CLASS_RGTC2_RG* = 0x82D1.GLenum + GL_TEXTURE_ENV_MODE* = 0x2200.GLenum + GL_COMPRESSED_SRGB8_ETC2* = 0x9275.GLenum + GL_MAP_FLUSH_EXPLICIT_BIT* = 0x0010.GLbitfield + GL_COLOR_MATERIAL_PARAMETER* = 0x0B56.GLenum + GL_HALF_FLOAT_ARB* = 0x140B.GLenum + GL_NOTEQUAL* = 0x0205.GLenum + GL_MAP_INVALIDATE_BUFFER_BIT_EXT* = 0x0008.GLbitfield + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT* = 0x8C29.GLenum + GL_DUAL_TEXTURE_SELECT_SGIS* = 0x8124.GLenum + GL_TEXTURE31* = 0x84DF.GLenum + GL_EVAL_TRIANGULAR_2D_NV* = 0x86C1.GLenum + GL_VIDEO_COLOR_CONVERSION_OFFSET_NV* = 0x902C.GLenum + GL_COMPRESSED_R11_EAC_OES* = 0x9270.GLenum + GL_RGB8_OES* = 0x8051.GLenum + GL_CLIP_PLANE2* = 0x3002.GLenum + GL_HINT_BIT* = 0x00008000.GLbitfield + GL_TEXTURE6_ARB* = 0x84C6.GLenum + GL_FLOAT_VEC2* = 0x8B50.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT* = 0x8C85.GLenum + GL_MAX_EVAL_ORDER* = 0x0D30.GLenum + GL_DUAL_LUMINANCE8_SGIS* = 0x8115.GLenum + GL_ALPHA16I_EXT* = 0x8D8A.GLenum + GL_IDENTITY_NV* = 0x862A.GLenum + GL_VIEW_CLASS_BPTC_UNORM* = 0x82D2.GLenum + GL_PATH_DASH_CAPS_NV* = 0x907B.GLenum + GL_IGNORE_BORDER_HP* = 0x8150.GLenum + GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI* = 0x87F6.GLenum + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT* = 0x8C8B.GLenum + GL_DRAW_BUFFER1_ATI* = 0x8826.GLenum + GL_TEXTURE_MIN_FILTER* = 0x2801.GLenum + GL_EVAL_VERTEX_ATTRIB12_NV* = 0x86D2.GLenum + GL_INT_IMAGE_2D_ARRAY* = 0x905E.GLenum + GL_SRC0_RGB* = 0x8580.GLenum + GL_MIN_EXT* = 0x8007.GLenum + GL_PROGRAM_PIPELINE_OBJECT_EXT* = 0x8A4F.GLenum + GL_STENCIL_BUFFER_BIT* = 0x00000400.GLbitfield + GL_SCREEN_COORDINATES_REND* = 0x8490.GLenum + GL_DOUBLE_VEC3_EXT* = 0x8FFD.GLenum + GL_SUBSAMPLE_DISTANCE_AMD* = 0x883F.GLenum + GL_VERTEX_SHADER_LOCALS_EXT* = 0x87D3.GLenum + GL_VERTEX_ATTRIB_ARRAY13_NV* = 0x865D.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR* = 0x93D9.GLenum + GL_UNSIGNED_NORMALIZED* = 0x8C17.GLenum + GL_DRAW_BUFFER10_NV* = 0x882F.GLenum + GL_PATH_STROKE_MASK_NV* = 0x9084.GLenum + GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB* = 0x88A7.GLenum + GL_SRGB_ALPHA_EXT* = 0x8C42.GLenum + GL_CONST_EYE_NV* = 0x86E5.GLenum + GL_MODELVIEW1_ARB* = 0x850A.GLenum + GL_FORMAT_SUBSAMPLE_244_244_OML* = 0x8983.GLenum + GL_LOGIC_OP_MODE* = 0x0BF0.GLenum + GL_CLIP_DISTANCE4* = 0x3004.GLenum + GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD* = 0x914A.GLenum + GL_SAMPLES* = 0x80A9.GLenum + GL_UNSIGNED_SHORT_5_5_5_1_EXT* = 0x8034.GLenum + GL_POINT_DISTANCE_ATTENUATION* = 0x8129.GLenum + GL_3D_COLOR* = 0x0602.GLenum + GL_BGRA* = 0x80E1.GLenum + GL_PARAMETER_BUFFER_BINDING_ARB* = 0x80EF.GLenum + GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM* = 103085.GLenum + GL_HSL_LUMINOSITY_NV* = 0x92B0.GLenum + GL_PROJECTION_STACK_DEPTH* = 0x0BA4.GLenum + GL_COMBINER_BIAS_NV* = 0x8549.GLenum + GL_AND* = 0x1501.GLenum + GL_TEXTURE27* = 0x84DB.GLenum + GL_VERTEX_PROGRAM_CALLBACK_DATA_MESA* = 0x8BB7.GLenum + GL_DRAW_BUFFER13_ATI* = 0x8832.GLenum + GL_UNSIGNED_SHORT_5_5_5_1* = 0x8034.GLenum + GL_PERFMON_GLOBAL_MODE_QCOM* = 0x8FA0.GLenum + GL_RED_EXT* = 0x1903.GLenum + GL_INNOCENT_CONTEXT_RESET_EXT* = 0x8254.GLenum + GL_UNIFORM_BUFFER_START* = 0x8A29.GLenum + GL_MAX_UNIFORM_BUFFER_BINDINGS* = 0x8A2F.GLenum + GL_SLICE_ACCUM_SUN* = 0x85CC.GLenum + GL_DRAW_BUFFER9_ATI* = 0x882E.GLenum + GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV* = 0x8DA2.GLenum + GL_READ_FRAMEBUFFER_BINDING_APPLE* = 0x8CAA.GLenum + GL_INDEX_ARRAY_LENGTH_NV* = 0x8F2E.GLenum + GL_DETAIL_TEXTURE_MODE_SGIS* = 0x809B.GLenum + GL_MATRIX13_ARB* = 0x88CD.GLenum + GL_ADD_SIGNED_ARB* = 0x8574.GLenum + GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE* = 0x910A.GLenum + GL_DEPTH_BITS* = 0x0D56.GLenum + GL_LUMINANCE_ALPHA_SNORM* = 0x9012.GLenum + GL_VIEW_CLASS_RGTC1_RED* = 0x82D0.GLenum + GL_LINE_WIDTH* = 0x0B21.GLenum + GL_DRAW_BUFFER14_ATI* = 0x8833.GLenum + GL_CON_30_ATI* = 0x895F.GLenum + GL_POST_COLOR_MATRIX_BLUE_BIAS* = 0x80BA.GLenum + GL_PIXEL_TRANSFORM_2D_EXT* = 0x8330.GLenum + GL_CONTEXT_LOST_WEBGL* = 0x9242.GLenum + GL_COLOR_TABLE_BLUE_SIZE_SGI* = 0x80DC.GLenum + GL_CONSTANT_EXT* = 0x8576.GLenum + GL_IMPLEMENTATION_COLOR_READ_TYPE* = 0x8B9A.GLenum + GL_HSL_COLOR_NV* = 0x92AF.GLenum + GL_LOAD* = 0x0101.GLenum + GL_TEXTURE_BIT* = 0x00040000.GLbitfield + GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT* = 0x8CD9.GLenum + GL_IMAGE_ROTATE_ORIGIN_X_HP* = 0x815A.GLenum + GL_DEPTH_BUFFER_BIT6_QCOM* = 0x00004000.GLbitfield + GL_QUERY* = 0x82E3.GLenum + GL_INVALID_VALUE* = 0x0501.GLenum + GL_PACK_COMPRESSED_BLOCK_HEIGHT* = 0x912C.GLenum + GL_MAX_PROGRAM_GENERIC_RESULTS_NV* = 0x8DA6.GLenum + GL_BACK_PRIMARY_COLOR_NV* = 0x8C77.GLenum + GL_ALPHA8_OES* = 0x803C.GLenum + GL_INDEX* = 0x8222.GLenum + GL_ATTRIB_ARRAY_SIZE_NV* = 0x8623.GLenum + GL_INT_IMAGE_1D_ARRAY* = 0x905D.GLenum + GL_LOCATION* = 0x930E.GLenum + GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT* = 0x8CD7.GLenum + GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE* = 0x82AF.GLenum + GL_RESAMPLE_ZERO_FILL_SGIX* = 0x842F.GLenum + GL_VERTEX_ARRAY_BINDING_OES* = 0x85B5.GLenum + GL_MATRIX4_ARB* = 0x88C4.GLenum + GL_NEXT_BUFFER_NV* = -2 + GL_ELEMENT_ARRAY_BARRIER_BIT* = 0x00000002.GLbitfield + GL_RGBA16_EXT* = 0x805B.GLenum + GL_SEPARABLE_2D_EXT* = 0x8012.GLenum + GL_R11F_G11F_B10F_EXT* = 0x8C3A.GLenum + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT* = 0x8CD4.GLenum + GL_IMAGE_2D_EXT* = 0x904D.GLenum + GL_DRAW_BUFFER6_NV* = 0x882B.GLenum + GL_TEXTURE_RANGE_LENGTH_APPLE* = 0x85B7.GLenum + GL_TEXTURE_RED_TYPE_ARB* = 0x8C10.GLenum + GL_ALPHA16F_ARB* = 0x881C.GLenum + GL_DEBUG_LOGGED_MESSAGES_ARB* = 0x9145.GLenum + GL_TRANSPOSE_MODELVIEW_MATRIX_ARB* = 0x84E3.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT* = 0x8C8F.GLenum + GL_MAX_CONVOLUTION_WIDTH* = 0x801A.GLenum + GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV* = 0x8E5B.GLenum + GL_PIXEL_TILE_CACHE_SIZE_SGIX* = 0x8145.GLenum + GL_4PASS_0_SGIS* = 0x80A4.GLenum + GL_PRIMITIVE_RESTART* = 0x8F9D.GLenum + GL_RG16_SNORM* = 0x8F99.GLenum + GL_SAMPLER_2D_SHADOW_EXT* = 0x8B62.GLenum + GL_FRONT* = 0x0404.GLenum + GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY* = 0x9103.GLenum + GL_SAMPLER_BINDING* = 0x8919.GLenum + GL_TEXTURE_2D_STACK_MESAX* = 0x875A.GLenum + GL_ASYNC_HISTOGRAM_SGIX* = 0x832C.GLenum + GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES* = 0x8B9B.GLenum + GL_OP_SET_LT_EXT* = 0x878D.GLenum + GL_INTERNALFORMAT_RED_TYPE* = 0x8278.GLenum + GL_AUX2* = 0x040B.GLenum + GL_CLAMP_FRAGMENT_COLOR* = 0x891B.GLenum + GL_BROWSER_DEFAULT_WEBGL* = 0x9244.GLenum + GL_IMAGE_CLASS_11_11_10* = 0x82C2.GLenum + GL_BUMP_ENVMAP_ATI* = 0x877B.GLenum + GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV* = 0x8DAD.GLenum + GL_RG_SNORM* = 0x8F91.GLenum + GL_BUMP_ROT_MATRIX_ATI* = 0x8775.GLenum + GL_UNIFORM_TYPE* = 0x8A37.GLenum + GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX* = 0x8403.GLenum + GL_TEXTURE_BINDING_CUBE_MAP_ARRAY* = 0x900A.GLenum + GL_LUMINANCE12* = 0x8041.GLenum + GL_QUERY_NO_WAIT_NV* = 0x8E14.GLenum + GL_TEXTURE_CUBE_MAP_ARRAY_ARB* = 0x9009.GLenum + GL_QUERY_BY_REGION_NO_WAIT_NV* = 0x8E16.GLenum + GL_FOG_END* = 0x0B64.GLenum + GL_OBJECT_LINK_STATUS_ARB* = 0x8B82.GLenum + GL_TEXTURE_COORD_ARRAY_SIZE* = 0x8088.GLenum + GL_SOURCE0_ALPHA_ARB* = 0x8588.GLenum + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB* = 0x8518.GLenum + GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX* = 0x840B.GLenum + GL_STATIC_COPY* = 0x88E6.GLenum + GL_LINE_WIDTH_RANGE* = 0x0B22.GLenum + GL_VERTEX_SOURCE_ATI* = 0x8774.GLenum + GL_FLOAT_MAT4x3* = 0x8B6A.GLenum + GL_HALF_APPLE* = 0x140B.GLenum + GL_TEXTURE11* = 0x84CB.GLenum + GL_DECODE_EXT* = 0x8A49.GLenum + GL_VERTEX_ARRAY_STRIDE_EXT* = 0x807C.GLenum + GL_SAMPLER_BUFFER_EXT* = 0x8DC2.GLenum + GL_TEXTURE_LOD_BIAS_EXT* = 0x8501.GLenum + GL_MODULATE_SIGNED_ADD_ATI* = 0x8745.GLenum + GL_DEPTH_CLEAR_VALUE* = 0x0B73.GLenum + GL_COMPRESSED_ALPHA* = 0x84E9.GLenum + GL_TEXTURE_1D_STACK_MESAX* = 0x8759.GLenum + GL_TEXTURE_FIXED_SAMPLE_LOCATIONS* = 0x9107.GLenum + GL_LARGE_CCW_ARC_TO_NV* = 0x16.GLenum + GL_COMBINER1_NV* = 0x8551.GLenum + GL_ARRAY_SIZE* = 0x92FB.GLenum + GL_MAX_COMPUTE_IMAGE_UNIFORMS* = 0x91BD.GLenum + GL_TEXTURE_BINDING_EXTERNAL_OES* = 0x8D67.GLenum + GL_REG_26_ATI* = 0x893B.GLenum + GL_MUL_ATI* = 0x8964.GLenum + GL_STENCIL_BUFFER_BIT6_QCOM* = 0x00400000.GLbitfield + GL_INVALID_OPERATION* = 0x0502.GLenum + GL_COLOR_SUM* = 0x8458.GLenum + GL_OP_CROSS_PRODUCT_EXT* = 0x8797.GLenum + GL_COLOR_ATTACHMENT4_NV* = 0x8CE4.GLenum + GL_MAX_RECTANGLE_TEXTURE_SIZE_NV* = 0x84F8.GLenum + GL_BOOL_ARB* = 0x8B56.GLenum + GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB* = 0x8625.GLenum + GL_MODELVIEW8_ARB* = 0x8728.GLenum + GL_STENCIL_TEST* = 0x0B90.GLenum + GL_SRC_OVER_NV* = 0x9288.GLenum + GL_COMPRESSED_LUMINANCE* = 0x84EA.GLenum + GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV* = 0x8E5A.GLenum + GL_WEIGHT_ARRAY_TYPE_ARB* = 0x86A9.GLenum + GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV* = 0x887C.GLenum + GL_COLOR_ARRAY_STRIDE_EXT* = 0x8083.GLenum + GL_BLEND_SRC_ALPHA_EXT* = 0x80CB.GLenum + GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB* = 0x88B4.GLenum + GL_SCALAR_EXT* = 0x87BE.GLenum + GL_DEBUG_SEVERITY_MEDIUM_KHR* = 0x9147.GLenum + GL_IMAGE_SCALE_X_HP* = 0x8155.GLenum + GL_LUMINANCE6_ALPHA2_EXT* = 0x8044.GLenum + GL_OUTPUT_TEXTURE_COORD22_EXT* = 0x87B3.GLenum + GL_CURRENT_PROGRAM* = 0x8B8D.GLenum + GL_FRAGMENT_PROGRAM_ARB* = 0x8804.GLenum + GL_INFO_LOG_LENGTH* = 0x8B84.GLenum + GL_TEXTURE_CUBE_MAP_POSITIVE_Z* = 0x8519.GLenum + GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES* = 0x898E.GLenum + GL_PRIMITIVE_RESTART_FIXED_INDEX* = 0x8D69.GLenum + GL_ARRAY_BUFFER_ARB* = 0x8892.GLenum + GL_DEPTH_STENCIL_MESA* = 0x8750.GLenum + GL_LUMINANCE8_OES* = 0x8040.GLenum + GL_REFLECTION_MAP_EXT* = 0x8512.GLenum + GL_PRIMITIVES_GENERATED* = 0x8C87.GLenum + GL_IMAGE_PIXEL_FORMAT* = 0x82A9.GLenum + GL_VERTEX_ARRAY_LIST_STRIDE_IBM* = 103080.GLenum + GL_MAP2_COLOR_4* = 0x0DB0.GLenum + GL_MULTIPLY_NV* = 0x9294.GLenum + GL_UNIFORM_BARRIER_BIT_EXT* = 0x00000004.GLbitfield + GL_STENCIL_BUFFER_BIT3_QCOM* = 0x00080000.GLbitfield + GL_REG_7_ATI* = 0x8928.GLenum + GL_STATIC_READ_ARB* = 0x88E5.GLenum + GL_MATRIX2_ARB* = 0x88C2.GLenum + GL_STENCIL_BUFFER_BIT5_QCOM* = 0x00200000.GLbitfield + GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB* = 0x8B4C.GLenum + GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG* = 0x8C03.GLenum + GL_R1UI_T2F_N3F_V3F_SUN* = 0x85CA.GLenum + GL_TEXTURE27_ARB* = 0x84DB.GLenum + GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES* = 0x8CDA.GLenum + GL_MAX_PROGRAM_TEXEL_OFFSET* = 0x8905.GLenum + GL_INT_SAMPLER_2D_ARRAY_EXT* = 0x8DCF.GLenum + GL_DRAW_BUFFER9_EXT* = 0x882E.GLenum + GL_RGB5_A1_EXT* = 0x8057.GLenum + GL_FIELDS_NV* = 0x8E27.GLenum + GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV* = 0x862E.GLenum + GL_SHADER_COMPILER* = 0x8DFA.GLenum + GL_SRC2_ALPHA* = 0x858A.GLenum + GL_TRACE_NAME_MESA* = 0x8756.GLenum + GL_MIRROR_CLAMP_TO_EDGE* = 0x8743.GLint + GL_OPERAND0_RGB_EXT* = 0x8590.GLenum + GL_UNSIGNED_BYTE_2_3_3_REV_EXT* = 0x8362.GLenum + GL_UNSIGNED_INT_2_10_10_10_REV* = 0x8368.GLenum + GL_MAX_CLIP_DISTANCES* = 0x0D32.GLenum + GL_MAP2_TEXTURE_COORD_3* = 0x0DB5.GLenum + GL_DUAL_LUMINANCE16_SGIS* = 0x8117.GLenum + GL_TEXTURE_UPDATE_BARRIER_BIT_EXT* = 0x00000100.GLbitfield + GL_IMAGE_BUFFER_EXT* = 0x9051.GLenum + GL_REDUCE_EXT* = 0x8016.GLenum + GL_EVAL_VERTEX_ATTRIB9_NV* = 0x86CF.GLenum + GL_IMAGE_CLASS_4_X_32* = 0x82B9.GLenum + GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT* = 0x8DE3.GLenum + GL_FRAGMENTS_INSTRUMENT_MAX_SGIX* = 0x8315.GLenum + GL_REG_28_ATI* = 0x893D.GLenum + GL_VARIABLE_B_NV* = 0x8524.GLenum + GL_GET_TEXTURE_IMAGE_TYPE* = 0x8292.GLenum + GL_PERCENTAGE_AMD* = 0x8BC3.GLenum + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB* = 0x8DE1.GLenum + GL_MAX_COMPUTE_UNIFORM_BLOCKS* = 0x91BB.GLenum + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE* = 0x8D56.GLenum + GL_PROVOKING_VERTEX* = 0x8E4F.GLenum + GL_FRAMEZOOM_FACTOR_SGIX* = 0x818C.GLenum + GL_COLOR_TABLE_ALPHA_SIZE* = 0x80DD.GLenum + GL_PIXEL_TEXTURE_SGIS* = 0x8353.GLenum + GL_MODELVIEW26_ARB* = 0x873A.GLenum + GL_MAX_DEBUG_MESSAGE_LENGTH_KHR* = 0x9143.GLenum + GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT* = 0x8519.GLenum + GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT* = 0x87D2.GLenum + GL_DRAW_INDIRECT_LENGTH_NV* = 0x8F42.GLenum + GL_OPERAND2_RGB_ARB* = 0x8592.GLenum + GL_TESS_EVALUATION_SHADER* = 0x8E87.GLenum + GL_INTERLACE_SGIX* = 0x8094.GLenum + GL_HARDLIGHT_NV* = 0x929B.GLenum + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT* = 0x8CD0.GLenum + GL_OUTPUT_TEXTURE_COORD6_EXT* = 0x87A3.GLenum + GL_SIGNED_LUMINANCE_NV* = 0x8701.GLenum + GL_CON_13_ATI* = 0x894E.GLenum + GL_CURRENT_TANGENT_EXT* = 0x843B.GLenum + GL_UNSIGNED_INT_IMAGE_3D* = 0x9064.GLenum + GL_MODELVIEW24_ARB* = 0x8738.GLenum + GL_EVAL_FRACTIONAL_TESSELLATION_NV* = 0x86C5.GLenum + GL_POINT_SPRITE_NV* = 0x8861.GLenum + GL_MULTISAMPLE_EXT* = 0x809D.GLenum + GL_INT64_VEC3_NV* = 0x8FEA.GLenum + GL_ABGR_EXT* = 0x8000.GLenum + GL_MAX_GENERAL_COMBINERS_NV* = 0x854D.GLenum + GL_NUM_PROGRAM_BINARY_FORMATS* = 0x87FE.GLenum + GL_TEXTURE_LO_SIZE_NV* = 0x871C.GLenum + GL_INT_IMAGE_1D_ARRAY_EXT* = 0x905D.GLenum + GL_MULTISAMPLE_BUFFER_BIT3_QCOM* = 0x08000000.GLbitfield + GL_TEXTURE_GEN_MODE_OES* = 0x2500.GLenum + GL_SECONDARY_COLOR_ARRAY_STRIDE* = 0x845C.GLenum + GL_ELEMENT_ARRAY_TYPE_APPLE* = 0x8A0D.GLenum + GL_UNPACK_IMAGE_HEIGHT_EXT* = 0x806E.GLenum + GL_PALETTE4_R5_G6_B5_OES* = 0x8B92.GLenum + GL_TEXTURE_RED_SIZE* = 0x805C.GLenum + GL_COLOR_ATTACHMENT7_EXT* = 0x8CE7.GLenum + GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET* = 0x8E5F.GLenum + GL_DRAW_BUFFER11* = 0x8830.GLenum + GL_MODELVIEW0_MATRIX_EXT* = 0x0BA6.GLenum + GL_LAYER_PROVOKING_VERTEX* = 0x825E.GLenum + GL_TEXTURE14* = 0x84CE.GLenum + GL_ALPHA8_EXT* = 0x803C.GLenum + GL_GENERIC_ATTRIB_NV* = 0x8C7D.GLenum + GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES* = 0x8B8B.GLenum + GL_STENCIL_ATTACHMENT_OES* = 0x8D20.GLenum + GL_MAX_VARYING_FLOATS* = 0x8B4B.GLenum + GL_RGB_SNORM* = 0x8F92.GLenum + GL_SECONDARY_COLOR_ARRAY_TYPE_EXT* = 0x845B.GLenum + GL_MAX_PROGRAM_LOOP_DEPTH_NV* = 0x88F7.GLenum + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER* = 0x8CD4.GLenum + GL_MAX_MODELVIEW_STACK_DEPTH* = 0x0D36.GLenum + GL_CON_23_ATI* = 0x8958.GLenum + GL_VERTEX_ARRAY_RANGE_POINTER_APPLE* = 0x8521.GLenum + GL_VERTEX_ARRAY_BUFFER_BINDING* = 0x8896.GLenum + GL_VERTEX_STREAM2_ATI* = 0x876E.GLenum + GL_STENCIL* = 0x1802.GLenum + GL_IMAGE_2D_ARRAY_EXT* = 0x9053.GLenum + GL_RGBA8* = 0x8058.GLenum + GL_TEXTURE_SPARSE_ARB* = 0x91A6.GLenum + GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX* = 0x8188.GLenum + GL_SECONDARY_INTERPOLATOR_ATI* = 0x896D.GLenum + GL_MAX_COMBINED_DIMENSIONS* = 0x8282.GLenum + GL_DEBUG_TYPE_POP_GROUP* = 0x826A.GLenum + GL_IMAGE_CLASS_4_X_8* = 0x82BF.GLenum + GL_VERTEX_ARRAY_RANGE_VALID_NV* = 0x851F.GLenum + GL_LUMINANCE_ALPHA8UI_EXT* = 0x8D81.GLenum + GL_RGBA32F_ARB* = 0x8814.GLenum + GL_GLYPH_HEIGHT_BIT_NV* = 0x02.GLbitfield + GL_FOG_COORD_ARRAY_BUFFER_BINDING* = 0x889D.GLenum + GL_TRACE_OPERATIONS_BIT_MESA* = 0x0001.GLbitfield + GL_INT8_VEC4_NV* = 0x8FE3.GLenum + GL_VERTEX_BINDING_STRIDE* = 0x82D8.GLenum + GL_LIGHT_ENV_MODE_SGIX* = 0x8407.GLenum + GL_PROXY_TEXTURE_1D_EXT* = 0x8063.GLenum + GL_CON_31_ATI* = 0x8960.GLenum + GL_TEXTURE_BORDER_COLOR* = 0x1004.GLenum + GL_ELEMENT_ARRAY_POINTER_APPLE* = 0x8A0E.GLenum + GL_NAME_LENGTH* = 0x92F9.GLenum + GL_PIXEL_COUNT_AVAILABLE_NV* = 0x8867.GLenum + GL_IUI_V3F_EXT* = 0x81AE.GLenum + GL_OBJECT_LINE_SGIS* = 0x81F7.GLenum + GL_T2F_N3F_V3F* = 0x2A2B.GLenum + GL_TRUE* = true.GLboolean + GL_COMPARE_REF_TO_TEXTURE_EXT* = 0x884E.GLenum + GL_MAX_3D_TEXTURE_SIZE* = 0x8073.GLenum + GL_LUMINANCE16_ALPHA16_EXT* = 0x8048.GLenum + GL_DRAW_INDIRECT_ADDRESS_NV* = 0x8F41.GLenum + GL_TEXTURE_IMAGE_FORMAT* = 0x828F.GLenum + GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES* = 0x898D.GLenum + GL_TEXTURE_RECTANGLE_ARB* = 0x84F5.GLenum + GL_TEXTURE_INDEX_SIZE_EXT* = 0x80ED.GLenum + GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV* = 0x8F2A.GLenum + GL_DEBUG_CALLBACK_USER_PARAM* = 0x8245.GLenum + GL_INTENSITY8_SNORM* = 0x9017.GLenum + GL_DISTANCE_ATTENUATION_EXT* = 0x8129.GLenum + GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS* = 0x90CC.GLenum + GL_ATTRIB_ARRAY_POINTER_NV* = 0x8645.GLenum + GL_OBJECT_TYPE* = 0x9112.GLenum + GL_PROGRAM_KHR* = 0x82E2.GLenum + GL_SOURCE0_ALPHA_EXT* = 0x8588.GLenum + GL_PIXEL_MAP_I_TO_G_SIZE* = 0x0CB3.GLenum + GL_RGBA_MODE* = 0x0C31.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR* = 0x93D6.GLenum + GL_MAX_ELEMENTS_VERTICES_EXT* = 0x80E8.GLenum + GL_DEBUG_SOURCE_SHADER_COMPILER* = 0x8248.GLenum + GL_ARC_TO_NV* = 0xFE.GLenum + GL_CON_6_ATI* = 0x8947.GLenum + GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT* = 0x87CE.GLenum + GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE* = 0x8A05.GLenum + GL_R16_SNORM* = 0x8F98.GLenum + GL_DOUBLE_VEC2_EXT* = 0x8FFC.GLenum + GL_UNSIGNED_INT8_VEC4_NV* = 0x8FEF.GLenum + GL_POST_CONVOLUTION_RED_SCALE* = 0x801C.GLenum + GL_FULL_STIPPLE_HINT_PGI* = 0x1A219.GLenum + GL_ACTIVE_ATTRIBUTES* = 0x8B89.GLenum + GL_TEXTURE_MATERIAL_FACE_EXT* = 0x8351.GLenum + GL_INCR_WRAP_OES* = 0x8507.GLenum + GL_UNPACK_COMPRESSED_BLOCK_WIDTH* = 0x9127.GLenum + GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT* = 0x8C73.GLenum + GL_MAX_VERTEX_SHADER_LOCALS_EXT* = 0x87C9.GLenum + GL_NUM_VIDEO_CAPTURE_STREAMS_NV* = 0x9024.GLenum + GL_DRAW_BUFFER3_ARB* = 0x8828.GLenum + GL_COMBINER_COMPONENT_USAGE_NV* = 0x8544.GLenum + GL_ELEMENT_ARRAY_POINTER_ATI* = 0x876A.GLenum + GL_RGB8UI_EXT* = 0x8D7D.GLenum + GL_RGBA8I* = 0x8D8E.GLenum + GL_TEXTURE_WIDTH_QCOM* = 0x8BD2.GLenum + GL_DOT3_RGB* = 0x86AE.GLenum + GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV* = 0x903B.GLenum + GL_TEXTURE_CUBE_MAP_NEGATIVE_X* = 0x8516.GLenum + GL_UNIFORM_BUFFER_SIZE* = 0x8A2A.GLenum + GL_OPERAND1_ALPHA* = 0x8599.GLenum + GL_TEXTURE_INTENSITY_SIZE_EXT* = 0x8061.GLenum + GL_DEBUG_TYPE_OTHER* = 0x8251.GLenum + GL_MAX_TESS_PATCH_COMPONENTS* = 0x8E84.GLenum + GL_UNIFORM_BUFFER_BINDING* = 0x8A28.GLenum + GL_INTENSITY_FLOAT16_APPLE* = 0x881D.GLenum + GL_TEXTURE_BLUE_SIZE* = 0x805E.GLenum + GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT* = 0x919F.GLenum + GL_TEXTURE_SWIZZLE_G* = 0x8E43.GLenum + GL_MAX_PROGRAM_TEXEL_OFFSET_EXT* = 0x8905.GLenum + GL_COLOR_BUFFER_BIT* = 0x00004000.GLbitfield + GL_ALPHA_FLOAT32_APPLE* = 0x8816.GLenum + GL_PROXY_TEXTURE_2D_EXT* = 0x8064.GLenum + GL_STENCIL_COMPONENTS* = 0x8285.GLenum + GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV* = 0x9026.GLenum + GL_TEXTURE_COMPRESSED_ARB* = 0x86A1.GLenum + GL_OBJECT_SUBTYPE_ARB* = 0x8B4F.GLenum + GL_MAX_PROGRAM_PARAMETERS_ARB* = 0x88A9.GLenum + GL_OFFSET_TEXTURE_2D_MATRIX_NV* = 0x86E1.GLenum + GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI* = 0x87F7.GLenum + GL_PATCH_VERTICES* = 0x8E72.GLenum + GL_NEGATIVE_Y_EXT* = 0x87DA.GLenum + GL_INT_2_10_10_10_REV* = 0x8D9F.GLenum + GL_READ_FRAMEBUFFER_BINDING_NV* = 0x8CAA.GLenum + GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI* = 0x80D2.GLenum + GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS* = 0x90DA.GLenum + GL_IMAGE_COMPATIBILITY_CLASS* = 0x82A8.GLenum + GL_FLOAT_MAT4* = 0x8B5C.GLenum + GL_FIELD_LOWER_NV* = 0x9023.GLenum + GL_UNPACK_IMAGE_HEIGHT* = 0x806E.GLenum + GL_PATH_COMMAND_COUNT_NV* = 0x909D.GLenum + GL_UNSIGNED_SHORT_4_4_4_4_EXT* = 0x8033.GLenum + GL_VIEW_CLASS_S3TC_DXT3_RGBA* = 0x82CE.GLenum + GL_STENCIL_BUFFER_BIT1_QCOM* = 0x00020000.GLbitfield + GL_BLOCK_INDEX* = 0x92FD.GLenum + GL_BUMP_TARGET_ATI* = 0x877C.GLenum + GL_PATH_STROKE_COVER_MODE_NV* = 0x9083.GLenum + GL_INT_IMAGE_2D_RECT* = 0x905A.GLenum + GL_VECTOR_EXT* = 0x87BF.GLenum + GL_INDEX_ARRAY_BUFFER_BINDING* = 0x8899.GLenum + GL_SAMPLER_2D_SHADOW* = 0x8B62.GLenum + GL_OBJECT_BUFFER_SIZE_ATI* = 0x8764.GLenum + GL_NORMALIZED_RANGE_EXT* = 0x87E0.GLenum + GL_DEPTH_COMPONENT32_OES* = 0x81A7.GLenum + GL_CON_9_ATI* = 0x894A.GLenum + GL_VIRTUAL_PAGE_SIZE_X_ARB* = 0x9195.GLenum + GL_LESS* = 0x0201.GLenum + GL_FRAMEBUFFER_UNSUPPORTED_OES* = 0x8CDD.GLenum + GL_CON_19_ATI* = 0x8954.GLenum + GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB* = 0x88A2.GLenum + GL_MAX_TEXTURE_COORDS_ARB* = 0x8871.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_MODE* = 0x8C7F.GLenum + GL_TEXTURE_1D_BINDING_EXT* = 0x8068.GLenum + GL_LINE_TOKEN* = 0x0702.GLenum + GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES* = 0x8CD7.GLenum + GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV* = 0x9036.GLenum + GL_TEXTURE_SWIZZLE_R* = 0x8E42.GLenum + GL_PIXEL_UNPACK_BUFFER_ARB* = 0x88EC.GLenum + GL_UNKNOWN_CONTEXT_RESET_EXT* = 0x8255.GLenum + GL_PROGRAM_ERROR_POSITION_NV* = 0x864B.GLenum + GL_ONE_MINUS_CONSTANT_COLOR* = 0x8002.GLenum + GL_POST_COLOR_MATRIX_GREEN_SCALE* = 0x80B5.GLenum + GL_TEXTURE_CUBE_MAP_SEAMLESS* = 0x884F.GLenum + GL_DRAW_BUFFER2* = 0x8827.GLenum + GL_STENCIL_INDEX* = 0x1901.GLenum + GL_FOG_DENSITY* = 0x0B62.GLenum + GL_MATRIX27_ARB* = 0x88DB.GLenum + GL_CURRENT_NORMAL* = 0x0B02.GLenum + GL_AFFINE_3D_NV* = 0x9094.GLenum + GL_STATIC_COPY_ARB* = 0x88E6.GLenum + GL_4X_BIT_ATI* = 0x00000002.GLbitfield + GL_COLOR_BUFFER_BIT3_QCOM* = 0x00000008.GLbitfield + GL_TEXTURE_MATRIX* = 0x0BA8.GLenum + GL_UNDEFINED_APPLE* = 0x8A1C.GLenum + GL_COLOR_TABLE_LUMINANCE_SIZE_SGI* = 0x80DE.GLenum + GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY* = 0x9061.GLenum + GL_RELATIVE_ARC_TO_NV* = 0xFF.GLenum + GL_UNPACK_PREMULTIPLY_ALPHA_WEBGL* = 0x9241.GLenum + GL_READ_FRAMEBUFFER_BINDING_EXT* = 0x8CAA.GLenum + GL_TEXTURE_WRAP_R_OES* = 0x8072.GLenum + GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT* = 0x8DDD.GLenum + GL_TEXTURE_CUBE_MAP_EXT* = 0x8513.GLenum + GL_COMMAND_BARRIER_BIT_EXT* = 0x00000040.GLbitfield + GL_DEBUG_SEVERITY_NOTIFICATION* = 0x826B.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR* = 0x93D8.GLenum + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS* = 0x8C8B.GLenum + GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV* = 0x90D0.GLenum + GL_INT_IMAGE_2D_EXT* = 0x9058.GLenum + GL_RGB_S3TC* = 0x83A0.GLenum + GL_SUCCESS_NV* = 0x902F.GLenum + GL_MATRIX_INDEX_ARRAY_SIZE_OES* = 0x8846.GLenum + GL_VIEW_CLASS_8_BITS* = 0x82CB.GLenum + GL_DONT_CARE* = 0x1100.GLenum + GL_FOG_COORDINATE_ARRAY* = 0x8457.GLenum + GL_DRAW_BUFFER9* = 0x882E.GLenum + GL_TEXTURE28_ARB* = 0x84DC.GLenum + GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB* = 0x8E5F.GLenum + GL_TEXTURE21* = 0x84D5.GLenum + GL_TRANSLATE_Y_NV* = 0x908F.GLenum + GL_MODELVIEW17_ARB* = 0x8731.GLenum + GL_ALPHA_FLOAT16_ATI* = 0x881C.GLenum + GL_DEPTH_STENCIL_OES* = 0x84F9.GLenum + GL_QUAD_MESH_SUN* = 0x8614.GLenum + GL_PROGRAM_ADDRESS_REGISTERS_ARB* = 0x88B0.GLenum + GL_VERTEX_BINDING_OFFSET* = 0x82D7.GLenum + GL_FIRST_TO_REST_NV* = 0x90AF.GLenum + GL_SHADE_MODEL* = 0x0B54.GLenum + GL_INT_IMAGE_2D_ARRAY_EXT* = 0x905E.GLenum + GL_FRONT_FACE* = 0x0B46.GLenum + GL_PRIMITIVE_RESTART_INDEX* = 0x8F9E.GLenum + GL_LUMINANCE8* = 0x8040.GLenum + GL_COVERAGE_ALL_FRAGMENTS_NV* = 0x8ED5.GLenum + GL_FRAGMENT_ALPHA_MODULATE_IMG* = 0x8C08.GLenum + GL_CLIP_PLANE3_IMG* = 0x3003.GLenum + GL_EVAL_VERTEX_ATTRIB15_NV* = 0x86D5.GLenum + GL_SYNC_GPU_COMMANDS_COMPLETE* = 0x9117.GLenum + GL_FALSE* = false.GLboolean + GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR* = 0x826C.GLenum + GL_STENCIL_ATTACHMENT_EXT* = 0x8D20.GLenum + GL_DST_ATOP_NV* = 0x928F.GLenum + GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN* = 0x85C1.GLenum + GL_COMBINE4_NV* = 0x8503.GLenum + GL_MINMAX_SINK_EXT* = 0x8030.GLenum + GL_RG16I* = 0x8239.GLenum + GL_BGRA_IMG* = 0x80E1.GLenum + GL_REFERENCED_BY_COMPUTE_SHADER* = 0x930B.GLenum + GL_MIN_LOD_WARNING_AMD* = 0x919C.GLenum + GL_READ_BUFFER_EXT* = 0x0C02.GLenum + GL_RGBA8UI_EXT* = 0x8D7C.GLenum + GL_LINE_BIT* = 0x00000004.GLbitfield + GL_CONDITION_SATISFIED* = 0x911C.GLenum + GL_SLUMINANCE_ALPHA* = 0x8C44.GLenum + GL_FOG_COORDINATE_ARRAY_TYPE* = 0x8454.GLenum + GL_EXPAND_NORMAL_NV* = 0x8538.GLenum + GL_TEXTURE_2D_ARRAY_EXT* = 0x8C1A.GLenum + GL_SAMPLER_2D_RECT_ARB* = 0x8B63.GLenum + GL_CLAMP_TO_BORDER_NV* = 0x812D.GLint + GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB* = 0x8DE0.GLenum + GL_TEXCOORD2_BIT_PGI* = 0x20000000.GLbitfield + GL_MATRIX0_ARB* = 0x88C0.GLenum + GL_STENCIL_BUFFER_BIT2_QCOM* = 0x00040000.GLbitfield + GL_COLOR_MATRIX_SGI* = 0x80B1.GLenum + GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI* = 0x87F4.GLenum + GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT* = 0x8CDC.GLenum + GL_LEFT* = 0x0406.GLenum + GL_LO_SCALE_NV* = 0x870F.GLenum + GL_STRICT_DEPTHFUNC_HINT_PGI* = 0x1A216.GLenum + GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS* = 0x8E1E.GLenum + GL_REPEAT* = 0x2901.GLint + GL_DEBUG_TYPE_PORTABILITY_ARB* = 0x824F.GLenum + GL_MAX_FRAMEBUFFER_LAYERS* = 0x9317.GLenum + GL_TRIANGLE_STRIP* = 0x0005.GLenum + GL_RECLAIM_MEMORY_HINT_PGI* = 0x1A1FE.GLenum + GL_RELATIVE_LINE_TO_NV* = 0x05.GLenum + GL_MAX_LIGHTS* = 0x0D31.GLenum + GL_MULTISAMPLE_BIT* = 0x20000000.GLbitfield + GL_READ_PIXELS* = 0x828C.GLenum + GL_DISCRETE_AMD* = 0x9006.GLenum + GL_QUAD_TEXTURE_SELECT_SGIS* = 0x8125.GLenum + GL_CON_25_ATI* = 0x895A.GLenum + GL_BUFFER_IMMUTABLE_STORAGE* = 0x821F.GLenum + GL_FLOAT_R16_NV* = 0x8884.GLenum + GL_GREEN_INTEGER_EXT* = 0x8D95.GLenum + cGL_FIXED* = 0x140C.GLenum + GL_LIST_PRIORITY_SGIX* = 0x8182.GLenum + GL_DRAW_BUFFER6_EXT* = 0x882B.GLenum + GL_OFFSET_TEXTURE_BIAS_NV* = 0x86E3.GLenum + GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB* = 0x8645.GLenum + GL_MALI_SHADER_BINARY_ARM* = 0x8F60.GLenum + GL_RGB_422_APPLE* = 0x8A1F.GLenum + GL_R1UI_N3F_V3F_SUN* = 0x85C7.GLenum + GL_VERTEX_ARRAY_OBJECT_EXT* = 0x9154.GLenum + GL_UNSIGNED_INT_10F_11F_11F_REV* = 0x8C3B.GLenum + GL_VERSION_ES_CM_1_1* = 1.GLenum + GL_CLEAR_TEXTURE* = 0x9365.GLenum + GL_FLOAT16_VEC3_NV* = 0x8FFA.GLenum + GL_TEXTURE_LUMINANCE_TYPE* = 0x8C14.GLenum + GL_TRANSFORM_FEEDBACK* = 0x8E22.GLenum + GL_POST_CONVOLUTION_COLOR_TABLE* = 0x80D1.GLenum + GL_DEPTH_TEST* = 0x0B71.GLenum + GL_CON_1_ATI* = 0x8942.GLenum + GL_FRAGMENT_SHADER_ATI* = 0x8920.GLenum + GL_SAMPLER_1D_ARRAY_SHADOW* = 0x8DC3.GLenum + GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT* = 0x90DF.GLenum + GL_MAX_SERVER_WAIT_TIMEOUT* = 0x9111.GLenum + GL_VERTEX_SHADER_BIT_EXT* = 0x00000001.GLbitfield + GL_TEXTURE_BINDING_CUBE_MAP_OES* = 0x8514.GLenum + GL_PIXEL_MAP_S_TO_S_SIZE* = 0x0CB1.GLenum + GL_CURRENT_OCCLUSION_QUERY_ID_NV* = 0x8865.GLenum + GL_TIMEOUT_IGNORED_APPLE* = 0xFFFFFFFFFFFFFFFF.GLenum + GL_MAX_COMPUTE_UNIFORM_COMPONENTS* = 0x8263.GLenum + GL_COPY_PIXEL_TOKEN* = 0x0706.GLenum + GL_SPOT_CUTOFF* = 0x1206.GLenum + GL_FRACTIONAL_EVEN* = 0x8E7C.GLenum + GL_MAP1_VERTEX_ATTRIB6_4_NV* = 0x8666.GLenum + GL_TRIANGLE_LIST_SUN* = 0x81D7.GLenum + GL_ATOMIC_COUNTER_BUFFER_START* = 0x92C2.GLenum + GL_MAX_ELEMENTS_VERTICES* = 0x80E8.GLenum + GL_COLOR_ATTACHMENT9_EXT* = 0x8CE9.GLenum + GL_ACCUM_CLEAR_VALUE* = 0x0B80.GLenum + GL_TEXTURE_COORD_ARRAY_LENGTH_NV* = 0x8F2F.GLenum + GL_DRAW_BUFFER3_EXT* = 0x8828.GLenum + GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT* = 0x8517.GLenum + GL_C4UB_V3F* = 0x2A23.GLenum + GL_MAX_PROGRAM_ATTRIBS_ARB* = 0x88AD.GLenum + GL_PIXEL_TILE_CACHE_INCREMENT_SGIX* = 0x813F.GLenum + GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB* = 0x8DA9.GLenum + GL_CON_8_ATI* = 0x8949.GLenum + GL_POST_COLOR_MATRIX_ALPHA_BIAS* = 0x80BB.GLenum + GL_RENDERBUFFER_WIDTH* = 0x8D42.GLenum + GL_VERTEX_ID_NV* = 0x8C7B.GLenum + GL_STRICT_LIGHTING_HINT_PGI* = 0x1A217.GLenum + GL_COMPRESSED_RGBA8_ETC2_EAC_OES* = 0x9278.GLenum + GL_PACK_COMPRESSED_BLOCK_WIDTH* = 0x912B.GLenum + GL_ZERO_EXT* = 0x87DD.GLenum + GL_DEBUG_SOURCE_OTHER* = 0x824B.GLenum + GL_MAP_UNSYNCHRONIZED_BIT* = 0x0020.GLbitfield + GL_VERTEX_ARRAY_POINTER* = 0x808E.GLenum + GL_FLOAT_RGBA_NV* = 0x8883.GLenum + GL_WEIGHT_ARRAY_STRIDE_OES* = 0x86AA.GLenum + GL_UNPACK_ROW_BYTES_APPLE* = 0x8A16.GLenum + GL_CURRENT_COLOR* = 0x0B00.GLenum + GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT* = 0x8CD7.GLenum + GL_MAX_NAME_STACK_DEPTH* = 0x0D37.GLenum + GL_SHADER_STORAGE_BUFFER_START* = 0x90D4.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT* = 0x8C7F.GLenum + GL_PATH_GEN_COMPONENTS_NV* = 0x90B3.GLenum + GL_AUTO_GENERATE_MIPMAP* = 0x8295.GLenum + GL_UNSIGNED_INT_5_9_9_9_REV* = 0x8C3E.GLenum + GL_VIEWPORT* = 0x0BA2.GLenum + GL_MAX_VERTEX_STREAMS_ATI* = 0x876B.GLenum + GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT* = 0x87CB.GLenum + GL_STENCIL_CLEAR_VALUE* = 0x0B91.GLenum + GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT* = 0x9069.GLenum + GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX* = 0x8409.GLenum + GL_FRAGMENT_SHADER_BIT_EXT* = 0x00000002.GLbitfield + GL_COLOR_SUM_ARB* = 0x8458.GLenum + GL_RGBA4_DXT5_S3TC* = 0x83A5.GLenum + GL_INT_IMAGE_CUBE* = 0x905B.GLenum + GL_ACTIVE_ATOMIC_COUNTER_BUFFERS* = 0x92D9.GLenum + GL_INTERNALFORMAT_GREEN_SIZE* = 0x8272.GLenum + GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV* = 0x8855.GLenum + GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI* = 0x87F1.GLenum + GL_REG_24_ATI* = 0x8939.GLenum + GL_MULT* = 0x0103.GLenum + GL_RGBA2* = 0x8055.GLenum + GL_CONVOLUTION_WIDTH_EXT* = 0x8018.GLenum + GL_STENCIL_EXT* = 0x1802.GLenum + GL_PATH_STROKE_WIDTH_NV* = 0x9075.GLenum + GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB* = 0x8247.GLenum + GL_QUERY_COUNTER_BITS* = 0x8864.GLenum + GL_OUTPUT_FOG_EXT* = 0x87BD.GLenum + GL_POST_COLOR_MATRIX_RED_BIAS* = 0x80B8.GLenum + GL_UNSIGNED_INT_10_10_10_2* = 0x8036.GLenum + GL_INT_SAMPLER_1D* = 0x8DC9.GLenum + GL_INT_IMAGE_2D_MULTISAMPLE_EXT* = 0x9060.GLenum + GL_RENDERBUFFER_INTERNAL_FORMAT_OES* = 0x8D44.GLenum + GL_TRACE_PIXELS_BIT_MESA* = 0x0010.GLbitfield + GL_FAILURE_NV* = 0x9030.GLenum + GL_INT_SAMPLER_3D_EXT* = 0x8DCB.GLenum + GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV* = 0x8DA1.GLenum + GL_OBJECT_DISTANCE_TO_POINT_SGIS* = 0x81F1.GLenum + GL_BLEND_SRC_RGB_OES* = 0x80C9.GLenum + GL_LUMINANCE4_ALPHA4_OES* = 0x8043.GLenum + GL_REG_4_ATI* = 0x8925.GLenum + GL_SHADING_LANGUAGE_VERSION_ARB* = 0x8B8C.GLenum + GL_RGBA16F_ARB* = 0x881A.GLenum + GL_R32F* = 0x822E.GLenum + GL_COMPRESSED_SRGB_S3TC_DXT1_NV* = 0x8C4C.GLenum + GL_TESS_CONTROL_OUTPUT_VERTICES* = 0x8E75.GLenum + GL_ONE_MINUS_DST_COLOR* = 0x0307.GLenum + GL_MATRIX19_ARB* = 0x88D3.GLenum + GL_INT_SAMPLER_2D_RECT* = 0x8DCD.GLenum + GL_POST_CONVOLUTION_GREEN_SCALE_EXT* = 0x801D.GLenum + GL_CLIP_DISTANCE5* = 0x3005.GLenum + GL_HISTOGRAM_RED_SIZE_EXT* = 0x8028.GLenum + GL_INTENSITY_FLOAT32_APPLE* = 0x8817.GLenum + GL_MODULATE_ADD_ATI* = 0x8744.GLenum + GL_NEGATIVE_X_EXT* = 0x87D9.GLenum + GL_REG_21_ATI* = 0x8936.GLenum + GL_STENCIL_RENDERABLE* = 0x8288.GLenum + GL_FOG_COORD_ARRAY_STRIDE* = 0x8455.GLenum + GL_FACTOR_MAX_AMD* = 0x901D.GLenum + GL_LUMINANCE16_EXT* = 0x8042.GLenum + GL_VARIANT_ARRAY_POINTER_EXT* = 0x87E9.GLenum + GL_DECAL* = 0x2101.GLenum + GL_SIGNED_ALPHA8_NV* = 0x8706.GLenum + GL_ALPHA_BITS* = 0x0D55.GLenum + GL_MATRIX29_ARB* = 0x88DD.GLenum + GL_FOG* = 0x0B60.GLenum + GL_INDEX_ARRAY_LIST_STRIDE_IBM* = 103083.GLenum + GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS* = 0x90C9.GLenum + GL_RGBA4_S3TC* = 0x83A3.GLenum + GL_LUMINANCE16_ALPHA16* = 0x8048.GLenum + GL_PROXY_TEXTURE_RECTANGLE* = 0x84F7.GLenum + GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV* = 0x8DA4.GLenum + GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER* = 0x84F0.GLenum + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE* = 0x8CD3.GLenum + GL_COLOR_TABLE_GREEN_SIZE_SGI* = 0x80DB.GLenum + GL_TEXTURE_PRE_SPECULAR_HP* = 0x8169.GLenum + GL_SHADOW_ATTENUATION_EXT* = 0x834E.GLenum + GL_SIGNED_RGB_NV* = 0x86FE.GLenum + GL_CLIENT_ALL_ATTRIB_BITS* = 0xFFFFFFFF.GLbitfield + GL_DEPTH_ATTACHMENT_EXT* = 0x8D00.GLenum + GL_DEBUG_SOURCE_API_KHR* = 0x8246.GLenum + GL_COLOR_INDEXES* = 0x1603.GLenum + GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH* = 0x8243.GLenum + GL_TEXTURE_BINDING_1D* = 0x8068.GLenum + GL_UNSIGNED_INT_SAMPLER_2D* = 0x8DD2.GLenum + GL_DRAW_BUFFER9_NV* = 0x882E.GLenum + GL_RED* = 0x1903.GLenum + GL_LINE_STRIP_ADJACENCY_EXT* = 0x000B.GLenum + GL_NUM_PASSES_ATI* = 0x8970.GLenum + GL_MAT_DIFFUSE_BIT_PGI* = 0x00400000.GLbitfield + GL_LUMINANCE_INTEGER_EXT* = 0x8D9C.GLenum + GL_PIXEL_MAP_I_TO_I* = 0x0C70.GLenum + GL_SLUMINANCE8_ALPHA8_NV* = 0x8C45.GLenum + GL_RGBA4_OES* = 0x8056.GLenum + GL_COMPRESSED_SIGNED_R11_EAC* = 0x9271.GLenum + GL_FRAGMENT_LIGHT4_SGIX* = 0x8410.GLenum + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV* = 0x8C80.GLenum + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT* = 0x8C4D.GLenum + GL_READ_FRAMEBUFFER_APPLE* = 0x8CA8.GLenum + GL_DRAW_BUFFER15_ARB* = 0x8834.GLenum + GL_INSTRUMENT_MEASUREMENTS_SGIX* = 0x8181.GLenum + GL_REG_15_ATI* = 0x8930.GLenum + GL_UNSIGNED_INT_IMAGE_1D_ARRAY* = 0x9068.GLenum + GL_COMPUTE_LOCAL_WORK_SIZE* = 0x8267.GLenum + GL_RGBA32I* = 0x8D82.GLenum + GL_VERTEX_ATTRIB_MAP2_APPLE* = 0x8A01.GLenum + GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR* = 0x824D.GLenum + GL_READ_FRAMEBUFFER_BINDING_ANGLE* = 0x8CAA.GLenum + GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR* = 0x8247.GLenum + GL_OP_FRAC_EXT* = 0x8789.GLenum + GL_RGB_FLOAT32_APPLE* = 0x8815.GLenum + GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER* = 0x8A44.GLenum + GL_NORMAL_ARRAY* = 0x8075.GLenum + GL_TEXTURE21_ARB* = 0x84D5.GLenum + GL_WRITE_ONLY_OES* = 0x88B9.GLenum + GL_TEXTURE0_ARB* = 0x84C0.GLenum + GL_SPRITE_OBJECT_ALIGNED_SGIX* = 0x814D.GLenum + GL_POSITION* = 0x1203.GLenum + GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR* = 0x824E.GLenum + GL_GEOMETRY_OUTPUT_TYPE_ARB* = 0x8DDC.GLenum + GL_IMAGE_PIXEL_TYPE* = 0x82AA.GLenum + GL_UNSIGNED_INT64_AMD* = 0x8BC2.GLenum + GL_LIST_INDEX* = 0x0B33.GLenum + GL_UNSIGNED_INT_8_8_S8_S8_REV_NV* = 0x86DB.GLenum + GL_MAP_ATTRIB_U_ORDER_NV* = 0x86C3.GLenum + GL_PROXY_TEXTURE_RECTANGLE_ARB* = 0x84F7.GLenum + GL_CLIP_NEAR_HINT_PGI* = 0x1A220.GLenum + GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX* = 0x817B.GLenum + GL_MAX_UNIFORM_BLOCK_SIZE* = 0x8A30.GLenum + GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER* = 0x8CDB.GLenum + GL_SAMPLE_MASK_INVERT_EXT* = 0x80AB.GLenum + GL_MAP1_VERTEX_ATTRIB14_4_NV* = 0x866E.GLenum + GL_SYNC_FLAGS* = 0x9115.GLenum + GL_COMPRESSED_RGBA* = 0x84EE.GLenum + GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT* = 0x82B2.GLenum + GL_INDEX_ARRAY_STRIDE_EXT* = 0x8086.GLenum + GL_CLIP_DISTANCE_NV* = 0x8C7A.GLenum + GL_UNSIGNED_INT_VEC4* = 0x8DC8.GLenum + GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB* = 0x8E8E.GLenum + GL_MIRRORED_REPEAT_OES* = 0x8370.GLint + GL_WEIGHT_ARRAY_SIZE_ARB* = 0x86AB.GLenum + GL_MIN_SAMPLE_SHADING_VALUE* = 0x8C37.GLenum + GL_SOURCE0_RGB* = 0x8580.GLenum + GL_RG32I* = 0x823B.GLenum + GL_QUERY_BUFFER_BINDING_AMD* = 0x9193.GLenum + GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV* = 0x8851.GLenum + GL_POST_CONVOLUTION_BLUE_SCALE_EXT* = 0x801E.GLenum + GL_DOUBLE_MAT3x4_EXT* = 0x8F4C.GLenum + GL_MAX_VERTEX_HINT_PGI* = 0x1A22D.GLenum + GL_ADD* = 0x0104.GLenum + GL_PATH_FORMAT_SVG_NV* = 0x9070.GLenum + GL_VIDEO_BUFFER_BINDING_NV* = 0x9021.GLenum + GL_NUM_EXTENSIONS* = 0x821D.GLenum + GL_DEPTH_RANGE* = 0x0B70.GLenum + GL_FRAGMENT_SUBROUTINE* = 0x92EC.GLenum + GL_DEPTH24_STENCIL8_EXT* = 0x88F0.GLenum + GL_COMPRESSED_RGBA_S3TC_DXT3_EXT* = 0x83F2.GLenum + GL_COLOR_TABLE_SGI* = 0x80D0.GLenum + GL_OBJECT_ACTIVE_UNIFORMS_ARB* = 0x8B86.GLenum + GL_RGBA16F* = 0x881A.GLenum + GL_COORD_REPLACE_ARB* = 0x8862.GLenum + GL_SAMPLE_POSITION_NV* = 0x8E50.GLenum + GL_SRC_ALPHA* = 0x0302.GLenum + GL_COMBINE_ALPHA* = 0x8572.GLenum + GL_CLEAR* = 0x1500.GLenum + GL_HSL_HUE_NV* = 0x92AD.GLenum + GL_SCISSOR_TEST* = 0x0C11.GLenum + GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT* = 0x8DD8.GLenum + GL_RGB16UI* = 0x8D77.GLenum + GL_MATRIX9_ARB* = 0x88C9.GLenum + GL_COLOR_ATTACHMENT13* = 0x8CED.GLenum + GL_BUMP_ROT_MATRIX_SIZE_ATI* = 0x8776.GLenum + GL_PIXEL_PACK_BUFFER_BINDING_ARB* = 0x88ED.GLenum + GL_FONT_X_MAX_BOUNDS_BIT_NV* = 0x00040000.GLbitfield + GL_MODELVIEW31_ARB* = 0x873F.GLenum + GL_DRAW_BUFFER14_ARB* = 0x8833.GLenum + GL_EDGEFLAG_BIT_PGI* = 0x00040000.GLbitfield + GL_TEXTURE_LOD_BIAS_R_SGIX* = 0x8190.GLenum + GL_FIELD_UPPER_NV* = 0x9022.GLenum + GL_CLIP_PLANE3* = 0x3003.GLenum + GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX* = 0x8408.GLenum + GL_BLUE* = 0x1905.GLenum + GL_LUMINANCE_ALPHA_FLOAT32_ATI* = 0x8819.GLenum + GL_MATRIX31_ARB* = 0x88DF.GLenum + GL_OR_REVERSE* = 0x150B.GLenum + GL_INTERPOLATE_EXT* = 0x8575.GLenum + GL_MODELVIEW13_ARB* = 0x872D.GLenum + GL_UTF16_NV* = 0x909B.GLenum + GL_READ_FRAMEBUFFER_ANGLE* = 0x8CA8.GLenum + GL_LUMINANCE16F_EXT* = 0x881E.GLenum + GL_VERTEX_ATTRIB_ARRAY7_NV* = 0x8657.GLenum + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT* = 0x8C8A.GLenum + GL_PRIMARY_COLOR_EXT* = 0x8577.GLenum + GL_VERTEX_ATTRIB_RELATIVE_OFFSET* = 0x82D5.GLenum + GL_LARGE_CW_ARC_TO_NV* = 0x18.GLenum + GL_PROGRAM_PARAMETER_NV* = 0x8644.GLenum + GL_ASYNC_MARKER_SGIX* = 0x8329.GLenum + GL_TEXTURE24_ARB* = 0x84D8.GLenum + GL_PIXEL_SUBSAMPLE_4242_SGIX* = 0x85A4.GLenum + GL_RGB10_A2_EXT* = 0x8059.GLenum + GL_IMAGE_CLASS_2_X_32* = 0x82BA.GLenum + GL_TEXTURE_INTENSITY_TYPE* = 0x8C15.GLenum + GL_TEXTURE_LOD_BIAS_S_SGIX* = 0x818E.GLenum + GL_PROGRAM_BINARY_LENGTH* = 0x8741.GLenum + GL_CURRENT_RASTER_NORMAL_SGIX* = 0x8406.GLenum + GL_DETAIL_TEXTURE_2D_SGIS* = 0x8095.GLenum + GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV* = 0x8E5C.GLenum + GL_CONVOLUTION_FILTER_BIAS_EXT* = 0x8015.GLenum + GL_DT_BIAS_NV* = 0x8717.GLenum + GL_RESET_NOTIFICATION_STRATEGY_EXT* = 0x8256.GLenum + GL_SHADER_STORAGE_BUFFER* = 0x90D2.GLenum + GL_RESET_NOTIFICATION_STRATEGY_ARB* = 0x8256.GLenum + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT* = 0x8CD1.GLenum + GL_SRC_NV* = 0x9286.GLenum + GL_POINT_FADE_THRESHOLD_SIZE* = 0x8128.GLenum + GL_DEPENDENT_RGB_TEXTURE_3D_NV* = 0x8859.GLenum + GL_QUERY_RESULT_ARB* = 0x8866.GLenum + GL_GEOMETRY_VERTICES_OUT* = 0x8916.GLenum + GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB* = 0x90EB.GLenum + GL_MODELVIEW27_ARB* = 0x873B.GLenum + GL_DRAW_BUFFER11_NV* = 0x8830.GLenum + GL_COLOR_ATTACHMENT9_NV* = 0x8CE9.GLenum + GL_BLEND_SRC* = 0x0BE1.GLenum + GL_CONVOLUTION_2D_EXT* = 0x8011.GLenum + GL_MAX_ELEMENTS_INDICES* = 0x80E9.GLenum + GL_LUMINANCE_ALPHA_FLOAT32_APPLE* = 0x8819.GLenum + GL_INT_IMAGE_1D* = 0x9057.GLenum + GL_CONSTANT_COLOR* = 0x8001.GLenum + GL_FRAMEBUFFER_BARRIER_BIT* = 0x00000400.GLbitfield + GL_POST_CONVOLUTION_BLUE_SCALE* = 0x801E.GLenum + GL_DEBUG_SOURCE_SHADER_COMPILER_ARB* = 0x8248.GLenum + GL_RGB16I* = 0x8D89.GLenum + GL_MAX_WIDTH* = 0x827E.GLenum + GL_LIGHT_MODEL_AMBIENT* = 0x0B53.GLenum + GL_COVERAGE_ATTACHMENT_NV* = 0x8ED2.GLenum + GL_PROGRAM* = 0x82E2.GLenum + GL_IMAGE_ROTATE_ANGLE_HP* = 0x8159.GLenum + GL_SRC2_RGB* = 0x8582.GLenum + GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR* = 0x824E.GLenum + GL_PASS_THROUGH_NV* = 0x86E6.GLenum + GL_HALF_BIAS_NEGATE_NV* = 0x853B.GLenum + GL_SAMPLER_CUBE_SHADOW_EXT* = 0x8DC5.GLenum + GL_COMPRESSED_RGBA_BPTC_UNORM_ARB* = 0x8E8C.GLenum + GL_MAX_SERVER_WAIT_TIMEOUT_APPLE* = 0x9111.GLenum + GL_STORAGE_PRIVATE_APPLE* = 0x85BD.GLenum + GL_VERTEX_SHADER_BIT* = 0x00000001.GLbitfield + GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI* = 0x80B6.GLenum + GL_VERTEX_SHADER_VARIANTS_EXT* = 0x87D0.GLenum + GL_TRANSFORM_FEEDBACK_ACTIVE* = 0x8E24.GLenum + GL_ACTIVE_UNIFORMS* = 0x8B86.GLenum + GL_MULTISAMPLE_BUFFER_BIT0_QCOM* = 0x01000000.GLbitfield + GL_OFFSET_TEXTURE_SCALE_NV* = 0x86E2.GLenum + GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB* = 0x88FE.GLenum + GL_BEVEL_NV* = 0x90A6.GLenum + GL_MAX_DRAW_BUFFERS_NV* = 0x8824.GLenum + GL_MAP1_TANGENT_EXT* = 0x8444.GLenum + GL_ANY_SAMPLES_PASSED* = 0x8C2F.GLenum + GL_MAX_IMAGE_SAMPLES* = 0x906D.GLenum + GL_PIXEL_UNPACK_BUFFER_BINDING* = 0x88EF.GLenum + GL_SRGB8_ALPHA8_EXT* = 0x8C43.GLenum + GL_2PASS_1_SGIS* = 0x80A3.GLenum + GL_PROGRAM_POINT_SIZE_ARB* = 0x8642.GLenum + GL_ALLOW_DRAW_WIN_HINT_PGI* = 0x1A20F.GLenum + GL_INTERNALFORMAT_RED_SIZE* = 0x8271.GLenum + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES* = 0x8CD3.GLenum + GL_4PASS_2_SGIS* = 0x80A6.GLenum + GL_PROGRAM_OBJECT_EXT* = 0x8B40.GLenum + GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST* = 0x82AD.GLenum + GL_LIGHTING_BIT* = 0x00000040.GLbitfield + GL_DRAW_BUFFER13_EXT* = 0x8832.GLenum + GL_STREAM_DRAW_ARB* = 0x88E0.GLenum + GL_INDEX_ARRAY_TYPE* = 0x8085.GLenum + GL_DEBUG_SOURCE_THIRD_PARTY* = 0x8249.GLenum + GL_DYNAMIC_COPY_ARB* = 0x88EA.GLenum + GL_COMPARE_R_TO_TEXTURE_ARB* = 0x884E.GLenum + GL_FRAGMENTS_INSTRUMENT_COUNTERS_SGIX* = 0x8314.GLenum + GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB* = 0x91A9.GLenum + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS* = 0x8DDF.GLenum + GL_READ_PIXEL_DATA_RANGE_POINTER_NV* = 0x887D.GLenum + GL_BUFFER_MAPPED_OES* = 0x88BC.GLenum + GL_COLOR_ARRAY_COUNT_EXT* = 0x8084.GLenum + GL_SET_AMD* = 0x874A.GLenum + GL_BLEND_DST_RGB_OES* = 0x80C8.GLenum + GL_MAX_CONVOLUTION_HEIGHT_EXT* = 0x801B.GLenum + GL_DEBUG_SEVERITY_MEDIUM* = 0x9147.GLenum + GL_TEXTURE_INTENSITY_TYPE_ARB* = 0x8C15.GLenum + GL_IMAGE_CLASS_10_10_10_2* = 0x82C3.GLenum + GL_TEXTURE_BORDER_COLOR_NV* = 0x1004.GLenum + GL_VERTEX_ATTRIB_ARRAY12_NV* = 0x865C.GLenum + GL_MAX_GEOMETRY_SHADER_INVOCATIONS* = 0x8E5A.GLenum + GL_NEAREST_CLIPMAP_NEAREST_SGIX* = 0x844D.GLenum + GL_MAP2_VERTEX_ATTRIB12_4_NV* = 0x867C.GLenum + GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING* = 0x889A.GLenum + GL_SEPARATE_SPECULAR_COLOR_EXT* = 0x81FA.GLenum + GL_MATRIX_INDEX_ARRAY_SIZE_ARB* = 0x8846.GLenum + GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB* = 0x8517.GLenum + GL_DECR* = 0x1E03.GLenum + GL_DEPTH_BUFFER_BIT7_QCOM* = 0x00008000.GLbitfield + GL_LOCAL_EXT* = 0x87C4.GLenum + GL_FUNC_REVERSE_SUBTRACT_OES* = 0x800B.GLenum + GL_FLOAT_VEC3* = 0x8B51.GLenum + GL_POINT_SIZE_GRANULARITY* = 0x0B13.GLenum + GL_COLOR_ATTACHMENT9* = 0x8CE9.GLenum + GL_MAT_SPECULAR_BIT_PGI* = 0x04000000.GLbitfield + GL_VERTEX_ATTRIB_MAP1_APPLE* = 0x8A00.GLenum + GL_DEBUG_SOURCE_WINDOW_SYSTEM* = 0x8247.GLenum + GL_NEAREST_MIPMAP_NEAREST* = 0x2700.GLint + GL_MODELVIEW7_ARB* = 0x8727.GLenum + GL_OUTPUT_VERTEX_EXT* = 0x879A.GLenum + GL_FRAMEBUFFER_EXT* = 0x8D40.GLenum + GL_ATC_RGBA_EXPLICIT_ALPHA_AMD* = 0x8C93.GLenum + GL_RENDERBUFFER_WIDTH_OES* = 0x8D42.GLenum + GL_TEXTURE_VIEW_MIN_LAYER* = 0x82DD.GLenum + GL_TEXTURE25_ARB* = 0x84D9.GLenum + GL_LIGHT7* = 0x4007.GLenum + GL_TESS_EVALUATION_SHADER_BIT* = 0x00000010.GLbitfield + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT* = 0x8CD2.GLenum + GL_COLOR_ATTACHMENT15_NV* = 0x8CEF.GLenum + GL_RED_SNORM* = 0x8F90.GLenum + GL_VIVIDLIGHT_NV* = 0x92A6.GLenum + GL_OBJECT_COMPILE_STATUS_ARB* = 0x8B81.GLenum + GL_INTERNALFORMAT_PREFERRED* = 0x8270.GLenum + GL_OUT_OF_MEMORY* = 0x0505.GLenum + GL_422_REV_EXT* = 0x80CD.GLenum + GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV* = 0x86F0.GLenum + GL_PROXY_TEXTURE_1D* = 0x8063.GLenum + GL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA* = 0x8BB2.GLenum + GL_YCBCR_422_APPLE* = 0x85B9.GLenum + GL_DRAW_BUFFER10_ATI* = 0x882F.GLenum + GL_COLOR_TABLE_ALPHA_SIZE_SGI* = 0x80DD.GLenum + GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS* = 0x8E86.GLenum + GL_MAX_PROGRAM_OUTPUT_VERTICES_NV* = 0x8C27.GLenum + GL_IMAGE_2D_MULTISAMPLE_EXT* = 0x9055.GLenum + GL_ACTIVE_TEXTURE_ARB* = 0x84E0.GLenum + GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV* = 0x02000000.GLbitfield + GL_QUERY_WAIT_NV* = 0x8E13.GLenum + GL_MAX_ELEMENT_INDEX* = 0x8D6B.GLenum + GL_OP_LOG_BASE_2_EXT* = 0x8792.GLenum + GL_ADD_SIGNED* = 0x8574.GLenum + GL_CONVOLUTION_FORMAT* = 0x8017.GLenum + GL_RENDERBUFFER_RED_SIZE_EXT* = 0x8D50.GLenum + GL_RENDERBUFFER_INTERNAL_FORMAT* = 0x8D44.GLenum + GL_COLOR_ATTACHMENT11_NV* = 0x8CEB.GLenum + GL_MATRIX14_ARB* = 0x88CE.GLenum + GL_COLOR_TABLE_RED_SIZE_SGI* = 0x80DA.GLenum + GL_CON_22_ATI* = 0x8957.GLenum + GL_TEXTURE_SWIZZLE_B_EXT* = 0x8E44.GLenum + GL_SAMPLES_SGIS* = 0x80A9.GLenum + GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV* = 0x887A.GLenum + GL_FONT_X_MIN_BOUNDS_BIT_NV* = 0x00010000.GLbitfield + GL_3_BYTES* = 0x1408.GLenum + GL_TEXTURE_MAX_CLAMP_S_SGIX* = 0x8369.GLenum + GL_PROXY_TEXTURE_CUBE_MAP_EXT* = 0x851B.GLenum + GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE* = 0x88FE.GLenum + GL_VERTEX_DATA_HINT_PGI* = 0x1A22A.GLenum + GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT* = 0x850D.GLenum + GL_MAX_INTEGER_SAMPLES* = 0x9110.GLenum + GL_TEXTURE_BUFFER_ARB* = 0x8C2A.GLenum + GL_FOG_COORD_ARRAY_POINTER* = 0x8456.GLenum + GL_UNSIGNED_SHORT_1_15_REV_MESA* = 0x8754.GLenum + GL_IMAGE_CUBIC_WEIGHT_HP* = 0x815E.GLenum + GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES* = 0x8CD6.GLenum + GL_RGBA_DXT5_S3TC* = 0x83A4.GLenum + GL_INT_IMAGE_2D_MULTISAMPLE* = 0x9060.GLenum + GL_ACTIVE_RESOURCES* = 0x92F5.GLenum + GL_TEXTURE_BINDING_2D* = 0x8069.GLenum + GL_SAMPLE_COVERAGE* = 0x80A0.GLenum + GL_SMOOTH* = 0x1D01.GLenum + GL_SAMPLER_1D_SHADOW_ARB* = 0x8B61.GLenum + GL_VIRTUAL_PAGE_SIZE_Y_AMD* = 0x9196.GLenum + GL_HORIZONTAL_LINE_TO_NV* = 0x06.GLenum + GL_HISTOGRAM_GREEN_SIZE_EXT* = 0x8029.GLenum + GL_COLOR_FLOAT_APPLE* = 0x8A0F.GLenum + GL_NUM_SHADER_BINARY_FORMATS* = 0x8DF9.GLenum + GL_TIMESTAMP* = 0x8E28.GLenum + GL_SRGB_EXT* = 0x8C40.GLenum + GL_MAX_VERTEX_UNIFORM_BLOCKS* = 0x8A2B.GLenum + GL_COLOR_ATTACHMENT2_EXT* = 0x8CE2.GLenum + GL_DEBUG_CALLBACK_FUNCTION_KHR* = 0x8244.GLenum + GL_DISPLAY_LIST* = 0x82E7.GLenum + GL_MAP1_NORMAL* = 0x0D92.GLenum + GL_COMPUTE_TEXTURE* = 0x82A0.GLenum + GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS* = 0x90DB.GLenum + GL_W_EXT* = 0x87D8.GLenum + GL_SAMPLE_SHADING_ARB* = 0x8C36.GLenum + GL_FRAGMENT_INTERPOLATION_OFFSET_BITS* = 0x8E5D.GLenum + GL_IMAGE_CLASS_4_X_16* = 0x82BC.GLenum + GL_FRAGMENT_DEPTH_EXT* = 0x8452.GLenum + GL_EVAL_BIT* = 0x00010000.GLbitfield + GL_UNSIGNED_INT_8_8_8_8* = 0x8035.GLenum + GL_MAX_TESS_CONTROL_INPUT_COMPONENTS* = 0x886C.GLenum + GL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA* = 0x8BB3.GLenum + GL_SLUMINANCE8_ALPHA8* = 0x8C45.GLenum + GL_MODULATE_COLOR_IMG* = 0x8C04.GLenum + GL_TEXTURE20* = 0x84D4.GLenum + GL_ALPHA_INTEGER_EXT* = 0x8D97.GLenum + GL_TEXTURE_BINDING_CUBE_MAP_EXT* = 0x8514.GLenum + GL_BACK_LEFT* = 0x0402.GLenum + GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT* = 0x8F39.GLenum + GL_MAX_TRANSFORM_FEEDBACK_BUFFERS* = 0x8E70.GLenum + GL_TRANSFORM_BIT* = 0x00001000.GLbitfield + GL_RGB4_EXT* = 0x804F.GLenum + GL_FRAGMENT_COLOR_EXT* = 0x834C.GLenum + GL_PIXEL_MAP_S_TO_S* = 0x0C71.GLenum + GL_COMPRESSED_RGBA_S3TC_DXT5_EXT* = 0x83F3.GLenum + GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV* = 0x90BD.GLenum + GL_SOURCE0_RGB_EXT* = 0x8580.GLenum + GL_PIXEL_COUNTER_BITS_NV* = 0x8864.GLenum + GL_ALIASED_LINE_WIDTH_RANGE* = 0x846E.GLenum + GL_DRAW_BUFFER10* = 0x882F.GLenum + GL_T4F_C4F_N3F_V4F* = 0x2A2D.GLenum + GL_BLEND_EQUATION_OES* = 0x8009.GLenum + GL_DEPTH_COMPONENT32* = 0x81A7.GLenum + GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT* = 0x87CA.GLenum + GL_DEPTH_BUFFER_BIT5_QCOM* = 0x00002000.GLbitfield + GL_RED_MIN_CLAMP_INGR* = 0x8560.GLenum + GL_RGBA_INTEGER_MODE_EXT* = 0x8D9E.GLenum + GL_DOUBLE_MAT4_EXT* = 0x8F48.GLenum + GL_OBJECT_DELETE_STATUS_ARB* = 0x8B80.GLenum + GL_FOG_COORD_ARRAY_LENGTH_NV* = 0x8F32.GLenum + GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING* = 0x889C.GLenum + GL_MAP1_VERTEX_ATTRIB7_4_NV* = 0x8667.GLenum + GL_BLEND_SRC_RGB_EXT* = 0x80C9.GLenum + GL_VERTEX_PROGRAM_POINT_SIZE_ARB* = 0x8642.GLenum + GL_STENCIL_INDEX1_EXT* = 0x8D46.GLenum + GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT* = 0x8516.GLenum + GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT* = 0x8A52.GLenum + GL_FOG_COORD_SRC* = 0x8450.GLenum + GL_ANY_SAMPLES_PASSED_EXT* = 0x8C2F.GLenum + GL_ALPHA4* = 0x803B.GLenum + GL_TEXTURE_GEN_MODE* = 0x2500.GLenum + GL_FLOAT_MAT3_ARB* = 0x8B5B.GLenum + GL_PIXEL_MAP_A_TO_A_SIZE* = 0x0CB9.GLenum + GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB* = 0x8B8B.GLenum + GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI* = 0x8802.GLenum + GL_COPY_READ_BUFFER_BINDING* = 0x8F36.GLenum + GL_YCRCB_444_SGIX* = 0x81BC.GLenum + GL_SLUMINANCE_EXT* = 0x8C46.GLenum + GL_EDGE_FLAG_ARRAY_EXT* = 0x8079.GLenum + GL_STENCIL_INDEX8_OES* = 0x8D48.GLenum + GL_RGBA32UI* = 0x8D70.GLenum + GL_TEXTURE_CUBE_MAP* = 0x8513.GLenum + GL_STREAM_COPY* = 0x88E2.GLenum + GL_VIEWPORT_BOUNDS_RANGE* = 0x825D.GLenum + GL_ASYNC_READ_PIXELS_SGIX* = 0x835E.GLenum + GL_VERTEX_ATTRIB_ARRAY_INTEGER* = 0x88FD.GLenum + GL_INTERNALFORMAT_STENCIL_TYPE* = 0x827D.GLenum + GL_OUTPUT_TEXTURE_COORD28_EXT* = 0x87B9.GLenum + GL_MATRIX_MODE* = 0x0BA0.GLenum + GL_MULTISAMPLE_SGIS* = 0x809D.GLenum + GL_R1UI_V3F_SUN* = 0x85C4.GLenum + GL_FLOAT_R32_NV* = 0x8885.GLenum + GL_MAX_DRAW_BUFFERS* = 0x8824.GLenum + GL_CIRCULAR_CCW_ARC_TO_NV* = 0xF8.GLenum + GL_PROGRAM_OUTPUT* = 0x92E4.GLenum + GL_MAX_CUBE_MAP_TEXTURE_SIZE* = 0x851C.GLenum + GL_TRIANGLE_STRIP_ADJACENCY_ARB* = 0x000D.GLenum + GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT* = 0x8A34.GLenum + GL_SRGB* = 0x8C40.GLenum + GL_BUFFER_ACCESS* = 0x88BB.GLenum + GL_TEXTURE_WRAP_S* = 0x2802.GLenum + GL_TRANSFORM_FEEDBACK_VARYINGS* = 0x8C83.GLenum + GL_RG16UI* = 0x823A.GLenum + GL_DUAL_LUMINANCE4_SGIS* = 0x8114.GLenum + GL_DOT_PRODUCT_DEPTH_REPLACE_NV* = 0x86ED.GLenum + GL_READ_FRAMEBUFFER_BINDING* = 0x8CAA.GLenum + GL_MAX_FOG_FUNC_POINTS_SGIS* = 0x812C.GLenum + GL_QUERY_RESULT_NO_WAIT* = 0x9194.GLenum + GL_FILE_NAME_NV* = 0x9074.GLenum + GL_DRAW_FRAMEBUFFER_BINDING* = 0x8CA6.GLenum + GL_FRAGMENT_SHADER* = 0x8B30.GLenum + GL_VIBRANCE_SCALE_NV* = 0x8713.GLenum + GL_PATH_FILL_COVER_MODE_NV* = 0x9082.GLenum + GL_LINEAR_MIPMAP_LINEAR* = 0x2703.GLint + GL_TEXTURE29* = 0x84DD.GLenum + GL_SCISSOR_BOX* = 0x0C10.GLenum + GL_PACK_SKIP_IMAGES* = 0x806B.GLenum + GL_BUFFER_MAP_OFFSET* = 0x9121.GLenum + GL_SLUMINANCE8_EXT* = 0x8C47.GLenum + GL_CONVOLUTION_1D* = 0x8010.GLenum + GL_MAX_GEOMETRY_IMAGE_UNIFORMS* = 0x90CD.GLenum + GL_MAP1_VERTEX_ATTRIB11_4_NV* = 0x866B.GLenum + GL_COLOR_LOGIC_OP* = 0x0BF2.GLenum + GL_SYNC_FLAGS_APPLE* = 0x9115.GLenum + GL_ACCUM_RED_BITS* = 0x0D58.GLenum + GL_VIEW_CLASS_128_BITS* = 0x82C4.GLenum + GL_INT_VEC3* = 0x8B54.GLenum + GL_INTENSITY12* = 0x804C.GLenum + GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER* = 0x90EC.GLenum + GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES* = 0x8D68.GLenum + GL_MAX_COLOR_MATRIX_STACK_DEPTH* = 0x80B3.GLenum + GL_GLOBAL_ALPHA_FACTOR_SUN* = 0x81DA.GLenum + GL_PACK_RESAMPLE_SGIX* = 0x842C.GLenum + GL_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB* = 0x91BF.GLenum + GL_DEPTH_BUFFER_FLOAT_MODE_NV* = 0x8DAF.GLenum + GL_SIGNED_LUMINANCE_ALPHA_NV* = 0x8703.GLenum + GL_OP_MIN_EXT* = 0x878B.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV* = 0x8C7F.GLenum + GL_COLOR_INDEX12_EXT* = 0x80E6.GLenum + GL_AUTO_NORMAL* = 0x0D80.GLenum + GL_ARRAY_BUFFER* = 0x8892.GLenum + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT* = 0x8DE1.GLenum + GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV* = 0x903C.GLenum + GL_ACCUM_BLUE_BITS* = 0x0D5A.GLenum + GL_RENDERBUFFER_SAMPLES_ANGLE* = 0x8CAB.GLenum + GL_MAX_ASYNC_HISTOGRAM_SGIX* = 0x832D.GLenum + GL_GLYPH_HAS_KERNING_BIT_NV* = 0x100.GLbitfield + GL_TESS_CONTROL_SUBROUTINE_UNIFORM* = 0x92EF.GLenum + GL_DRAW_BUFFER1* = 0x8826.GLenum + GL_INT8_NV* = 0x8FE0.GLenum + GL_2PASS_0_EXT* = 0x80A2.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_INDEX* = 0x934B.GLenum + GL_NUM_VIRTUAL_PAGE_SIZES_ARB* = 0x91A8.GLenum + GL_INT_SAMPLER_3D* = 0x8DCB.GLenum + GL_RASTERIZER_DISCARD* = 0x8C89.GLenum + GL_SOURCE2_RGB_ARB* = 0x8582.GLenum + GL_LOCAL_CONSTANT_EXT* = 0x87C3.GLenum + GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT* = 0x8DA9.GLenum + GL_MODELVIEW12_ARB* = 0x872C.GLenum + GL_VERTEX_SUBROUTINE_UNIFORM* = 0x92EE.GLenum + GL_OPERAND0_ALPHA_ARB* = 0x8598.GLenum + GL_DEPTH24_STENCIL8* = 0x88F0.GLenum + GL_RENDERBUFFER_RED_SIZE* = 0x8D50.GLenum + GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING* = 0x8210.GLenum + GL_DRAW_BUFFER10_ARB* = 0x882F.GLenum + GL_UNSIGNED_INT_SAMPLER_3D* = 0x8DD3.GLenum + GL_SKIP_COMPONENTS2_NV* = -5 + GL_PROGRAM_BINARY_LENGTH_OES* = 0x8741.GLenum + GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE* = 0x8A02.GLenum + GL_QUERY_RESULT_EXT* = 0x8866.GLenum + GL_CONSTANT_COLOR0_NV* = 0x852A.GLenum + GL_MAX_ASYNC_DRAW_PIXELS_SGIX* = 0x8360.GLenum + GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV* = 0x86F1.GLenum + GL_ALPHA_TEST_REF* = 0x0BC2.GLenum + GL_MAX_4D_TEXTURE_SIZE_SGIS* = 0x8138.GLenum + GL_INT_SAMPLER_2D_MULTISAMPLE* = 0x9109.GLenum + GL_DRAW_BUFFER6_ATI* = 0x882B.GLenum + GL_INTENSITY16UI_EXT* = 0x8D79.GLenum + GL_POINT_FADE_THRESHOLD_SIZE_ARB* = 0x8128.GLenum + GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING* = 0x889F.GLenum + GL_RENDERBUFFER_WIDTH_EXT* = 0x8D42.GLenum + GL_FIXED_ONLY* = 0x891D.GLenum + GL_HISTOGRAM_BLUE_SIZE* = 0x802A.GLenum + GL_PROGRAM_TEX_INSTRUCTIONS_ARB* = 0x8806.GLenum + GL_MAX_VERTEX_SHADER_VARIANTS_EXT* = 0x87C6.GLenum + GL_UNSIGNED_INT_10_10_10_2_EXT* = 0x8036.GLenum + GL_SAMPLE_ALPHA_TO_ONE_EXT* = 0x809F.GLenum + GL_INDEX_ARRAY* = 0x8077.GLenum + GL_GEQUAL* = 0x0206.GLenum + GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS* = 0x90D8.GLenum + GL_DITHER* = 0x0BD0.GLenum + GL_ATTACHED_SHADERS* = 0x8B85.GLenum + GL_FUNC_SUBTRACT* = 0x800A.GLenum + GL_ATOMIC_COUNTER_BARRIER_BIT_EXT* = 0x00001000.GLbitfield + GL_LUMINANCE4* = 0x803F.GLenum + GL_BLEND_EQUATION_RGB_EXT* = 0x8009.GLenum + GL_TEXTURE_MULTI_BUFFER_HINT_SGIX* = 0x812E.GLenum + GL_DEBUG_SEVERITY_LOW_KHR* = 0x9148.GLenum + GL_UNPACK_COMPRESSED_BLOCK_HEIGHT* = 0x9128.GLenum + GL_CULL_VERTEX_OBJECT_POSITION_EXT* = 0x81AC.GLenum + GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI* = 0x80BB.GLenum + GL_ADD_SIGNED_EXT* = 0x8574.GLenum + GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL* = 0x83F5.GLenum + GL_CURRENT_RASTER_SECONDARY_COLOR* = 0x845F.GLenum + GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV* = 0x8E5F.GLenum + GL_CONTINUOUS_AMD* = 0x9007.GLenum + GL_R1UI_T2F_C4F_N3F_V3F_SUN* = 0x85CB.GLenum + GL_COMPUTE_SHADER* = 0x91B9.GLenum + GL_CLIP_DISTANCE6* = 0x3006.GLenum + GL_SRC_ATOP_NV* = 0x928E.GLenum + GL_DEPTH_COMPONENT16_OES* = 0x81A5.GLenum + GL_DOUBLE_MAT4* = 0x8F48.GLenum + GL_MAT_SHININESS_BIT_PGI* = 0x02000000.GLbitfield + GL_SAMPLER_BUFFER_AMD* = 0x9001.GLenum + GL_ARRAY_BUFFER_BINDING_ARB* = 0x8894.GLenum + GL_VOLATILE_APPLE* = 0x8A1A.GLenum + GL_ALPHA32UI_EXT* = 0x8D72.GLenum + GL_COLOR_BUFFER_BIT1_QCOM* = 0x00000002.GLbitfield + GL_VERTEX_PROGRAM_CALLBACK_MESA* = 0x8BB4.GLenum + GL_CULL_VERTEX_EXT* = 0x81AA.GLenum + GL_RENDERBUFFER_STENCIL_SIZE_EXT* = 0x8D55.GLenum + GL_SELECT* = 0x1C02.GLenum + GL_LUMINANCE12_ALPHA4* = 0x8046.GLenum + GL_IMAGE_BINDING_LEVEL_EXT* = 0x8F3B.GLenum + GL_MATRIX_PALETTE_ARB* = 0x8840.GLenum + GL_DUAL_ALPHA4_SGIS* = 0x8110.GLenum + GL_BACK_NORMALS_HINT_PGI* = 0x1A223.GLenum + GL_UNSIGNED_SHORT_15_1_MESA* = 0x8753.GLenum + GL_UNSIGNED_SHORT_4_4_4_4_REV* = 0x8365.GLenum + GL_BUFFER* = 0x82E0.GLenum + GL_RENDERBUFFER_INTERNAL_FORMAT_EXT* = 0x8D44.GLenum + GL_MATRIX5_NV* = 0x8635.GLenum + GL_ATOMIC_COUNTER_BUFFER* = 0x92C0.GLenum + GL_SMOOTH_QUADRATIC_CURVE_TO_NV* = 0x0E.GLenum + GL_VARIABLE_D_NV* = 0x8526.GLenum + GL_PINLIGHT_NV* = 0x92A8.GLenum + GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT* = 0x88FD.GLenum + GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS* = 0x92CF.GLenum + GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV* = 0x9034.GLenum + GL_RESAMPLE_REPLICATE_SGIX* = 0x842E.GLenum + GL_UNSIGNED_SHORT_5_6_5_REV* = 0x8364.GLenum + GL_VERTEX_ATTRIB_ARRAY2_NV* = 0x8652.GLenum + GL_3D_COLOR_TEXTURE* = 0x0603.GLenum + GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS* = 0x8B4C.GLenum + GL_DEBUG_TYPE_PERFORMANCE_KHR* = 0x8250.GLenum + GL_MATRIX_INDEX_ARRAY_OES* = 0x8844.GLenum + GL_TEXTURE_TOO_LARGE_EXT* = 0x8065.GLenum + GL_PACK_IMAGE_HEIGHT_EXT* = 0x806C.GLenum + GL_YCBYCR8_422_NV* = 0x9031.GLenum + GL_COLOR_ATTACHMENT8* = 0x8CE8.GLenum + GL_SAMPLE_COVERAGE_ARB* = 0x80A0.GLenum + GL_CURRENT_VERTEX_EXT* = 0x87E2.GLenum + GL_LINEAR* = 0x2601.GLint + GL_STENCIL_TAG_BITS_EXT* = 0x88F2.GLenum + GL_T2F_IUI_V3F_EXT* = 0x81B2.GLenum + GL_TEXTURE_3D_BINDING_OES* = 0x806A.GLenum + GL_PATH_CLIENT_LENGTH_NV* = 0x907F.GLenum + GL_MAT_AMBIENT_BIT_PGI* = 0x00100000.GLbitfield + GL_DOUBLE_MAT4x3* = 0x8F4E.GLenum + GL_QUERY_BY_REGION_WAIT_NV* = 0x8E15.GLenum + GL_LEQUAL* = 0x0203.GLenum + GL_PROGRAM_ATTRIBS_ARB* = 0x88AC.GLenum + GL_BUFFER_MAPPED_ARB* = 0x88BC.GLenum + GL_VERTEX_SHADER_ARB* = 0x8B31.GLenum + GL_SOURCE1_ALPHA_EXT* = 0x8589.GLenum + GL_UNSIGNED_INT16_VEC3_NV* = 0x8FF2.GLenum + GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB* = 0x88B1.GLenum + GL_RGB16* = 0x8054.GLenum + GL_TEXTURE15_ARB* = 0x84CF.GLenum + GL_TEXTURE_GATHER_SHADOW* = 0x82A3.GLenum + GL_FENCE_APPLE* = 0x8A0B.GLenum + GL_TRIANGLES* = 0x0004.GLenum + GL_DOT4_ATI* = 0x8967.GLenum + GL_CURRENT_FOG_COORD* = 0x8453.GLenum + GL_DEPTH_CLAMP_NEAR_AMD* = 0x901E.GLenum + GL_SYNC_FENCE* = 0x9116.GLenum + GL_UNSIGNED_INT64_VEC3_NV* = 0x8FF6.GLenum + GL_DEPTH* = 0x1801.GLenum + GL_TEXTURE_COORD_NV* = 0x8C79.GLenum + GL_COMBINE* = 0x8570.GLenum + GL_MAX_VERTEX_UNITS_ARB* = 0x86A4.GLenum + GL_COLOR_INDEX2_EXT* = 0x80E3.GLenum + GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP* = 0x8162.GLenum + GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB* = 0x900E.GLenum + GL_MIRROR_CLAMP_EXT* = 0x8742.GLint + GL_STENCIL_VALUE_MASK* = 0x0B93.GLenum + GL_UNSIGNED_INT_SAMPLER_BUFFER* = 0x8DD8.GLenum + GL_TRACK_MATRIX_NV* = 0x8648.GLenum + GL_MAP1_VERTEX_3* = 0x0D97.GLenum + GL_OP_MOV_EXT* = 0x8799.GLenum + GL_MAP_INVALIDATE_RANGE_BIT_EXT* = 0x0004.GLbitfield + GL_MAX_CONVOLUTION_WIDTH_EXT* = 0x801A.GLenum + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES* = 0x8518.GLenum + GL_RGBA_SNORM* = 0x8F93.GLenum + GL_MAX_TRACK_MATRICES_NV* = 0x862F.GLenum + GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS* = 0x886D.GLenum + GL_DOUBLE_VEC4_EXT* = 0x8FFE.GLenum + GL_COLOR_TABLE_BLUE_SIZE* = 0x80DC.GLenum + GL_T2F_C3F_V3F* = 0x2A2A.GLenum + GL_INTENSITY16_SNORM* = 0x901B.GLenum + GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT* = 0x905F.GLenum + GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD* = 0x914C.GLenum + GL_NORMAL_MAP_EXT* = 0x8511.GLenum + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV* = 0x8C8B.GLenum + GL_DRAW_BUFFER4_EXT* = 0x8829.GLenum + GL_PIXEL_MAP_G_TO_G* = 0x0C77.GLenum + GL_TESS_GEN_POINT_MODE* = 0x8E79.GLenum + GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS* = 0x92CC.GLenum + GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT* = 0x8DD5.GLenum + GL_MULTISAMPLE_BUFFER_BIT2_QCOM* = 0x04000000.GLbitfield + GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI* = 0x80B9.GLenum + GL_POST_COLOR_MATRIX_GREEN_BIAS* = 0x80B9.GLenum + GL_TEXTURE10* = 0x84CA.GLenum + GL_RGB32F* = 0x8815.GLenum + GL_DYNAMIC_READ_ARB* = 0x88E9.GLenum + GL_MODELVIEW22_ARB* = 0x8736.GLenum + GL_VERTEX_STREAM0_ATI* = 0x876C.GLenum + GL_TEXTURE_FETCH_BARRIER_BIT_EXT* = 0x00000008.GLbitfield + GL_COMBINER_INPUT_NV* = 0x8542.GLenum + GL_DRAW_BUFFER0_NV* = 0x8825.GLenum + GL_ALPHA_TEST* = 0x0BC0.GLenum + GL_PIXEL_UNPACK_BUFFER* = 0x88EC.GLenum + GL_SRC_IN_NV* = 0x928A.GLenum + GL_COMPRESSED_SIGNED_RED_RGTC1_EXT* = 0x8DBC.GLenum + GL_PACK_SUBSAMPLE_RATE_SGIX* = 0x85A0.GLenum + GL_FRAMEBUFFER_DEFAULT_SAMPLES* = 0x9313.GLenum + GL_ARRAY_OBJECT_OFFSET_ATI* = 0x8767.GLenum + GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES* = 0x8515.GLenum + GL_STENCIL_BITS* = 0x0D57.GLenum + GL_DEPTH_COMPONENT24_OES* = 0x81A6.GLenum + GL_FRAMEBUFFER* = 0x8D40.GLenum + GL_8X_BIT_ATI* = 0x00000004.GLbitfield + GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY* = 0x9105.GLenum + GL_BOOL_VEC2* = 0x8B57.GLenum + GL_EXP* = 0x0800.GLenum + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT* = 0x851A.GLenum + GL_STENCIL_INDEX16* = 0x8D49.GLenum + GL_FRAGMENT_LIGHTING_SGIX* = 0x8400.GLenum + GL_PACK_SKIP_PIXELS* = 0x0D04.GLenum + GL_TEXTURE_MIN_LOD* = 0x813A.GLenum + GL_COMPRESSED_RGB* = 0x84ED.GLenum + GL_MAP1_VERTEX_ATTRIB2_4_NV* = 0x8662.GLenum + GL_CONJOINT_NV* = 0x9284.GLenum + GL_MAX_COMPUTE_SHARED_MEMORY_SIZE* = 0x8262.GLenum + GL_INTENSITY8* = 0x804B.GLenum + GL_SAMPLER_2D_MULTISAMPLE* = 0x9108.GLenum + GL_MAX_LIST_NESTING* = 0x0B31.GLenum + GL_DOUBLE_MAT3* = 0x8F47.GLenum + GL_TEXTURE_DEPTH* = 0x8071.GLenum + GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION* = 0x8E4C.GLenum + GL_TEXTURE12_ARB* = 0x84CC.GLenum + GL_R1UI_T2F_V3F_SUN* = 0x85C9.GLenum + GL_REPLACE* = 0x1E01.GLenum + GL_MAX_NUM_ACTIVE_VARIABLES* = 0x92F7.GLenum + GL_RGBA_INTEGER_EXT* = 0x8D99.GLenum + GL_TEXTURE_COMPRESSED_BLOCK_SIZE* = 0x82B3.GLenum + GL_INDEX_CLEAR_VALUE* = 0x0C20.GLenum + GL_PROGRAM_ERROR_POSITION_ARB* = 0x864B.GLenum + GL_LINEARBURN_NV* = 0x92A5.GLenum + GL_TEXTURE_BINDING_CUBE_MAP_ARB* = 0x8514.GLenum + GL_TESSELLATION_FACTOR_AMD* = 0x9005.GLenum + GL_SHADER_IMAGE_STORE* = 0x82A5.GLenum + GL_COMPRESSED_SLUMINANCE_ALPHA_EXT* = 0x8C4B.GLenum + GL_MAX_PALETTE_MATRICES_ARB* = 0x8842.GLenum + GL_UNPACK_CONSTANT_DATA_SUNX* = 0x81D5.GLenum + GL_FLOAT_MAT3x4* = 0x8B68.GLenum + GL_DRAW_BUFFER8_NV* = 0x882D.GLenum + GL_ATTENUATION_EXT* = 0x834D.GLenum + GL_REG_25_ATI* = 0x893A.GLenum + GL_UNSIGNED_INT_SAMPLER_1D* = 0x8DD1.GLenum + GL_TEXTURE_1D_STACK_BINDING_MESAX* = 0x875D.GLenum + GL_SYNC_STATUS_APPLE* = 0x9114.GLenum + GL_TEXTURE_CUBE_MAP_ARRAY* = 0x9009.GLenum + GL_EXP2* = 0x0801.GLenum + GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT* = 0x8C71.GLenum + GL_BUFFER_ACCESS_ARB* = 0x88BB.GLenum + GL_LO_BIAS_NV* = 0x8715.GLenum + GL_MIRROR_CLAMP_ATI* = 0x8742.GLint + GL_SAMPLE_COVERAGE_VALUE* = 0x80AA.GLenum + GL_UNSIGNED_INT_24_8_EXT* = 0x84FA.GLenum + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT* = 0x8C88.GLenum + GL_R16UI* = 0x8234.GLenum + GL_BLEND_PREMULTIPLIED_SRC_NV* = 0x9280.GLenum + GL_COLOR_ATTACHMENT0* = 0x8CE0.GLenum + GL_GEOMETRY_VERTICES_OUT_EXT* = 0x8DDA.GLenum + GL_SAMPLE_MASK_NV* = 0x8E51.GLenum + GL_BGRA_INTEGER_EXT* = 0x8D9B.GLenum + GL_PALETTE8_RGBA8_OES* = 0x8B96.GLenum + GL_MAX_ARRAY_TEXTURE_LAYERS_EXT* = 0x88FF.GLenum + GL_TEXTURE_COLOR_TABLE_SGI* = 0x80BC.GLenum + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT* = 0x8C80.GLenum + GL_TEXTURE10_ARB* = 0x84CA.GLenum + GL_TRIANGLES_ADJACENCY* = 0x000C.GLenum + GL_COLOR_ARRAY_EXT* = 0x8076.GLenum + GL_MAX_FRAMEBUFFER_SAMPLES* = 0x9318.GLenum + GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB* = 0x889F.GLenum + GL_IMAGE_TEXEL_SIZE* = 0x82A7.GLenum + GL_MAGNITUDE_BIAS_NV* = 0x8718.GLenum + GL_SHADOW_AMBIENT_SGIX* = 0x80BF.GLenum + GL_BUFFER_SERIALIZED_MODIFY_APPLE* = 0x8A12.GLenum + GL_TEXTURE_COORD_ARRAY_COUNT_EXT* = 0x808B.GLenum + GL_MAX_DRAW_BUFFERS_ARB* = 0x8824.GLenum + GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT* = 0x87CD.GLenum + GL_PASS_THROUGH_TOKEN* = 0x0700.GLenum + GL_BLEND_EQUATION* = 0x8009.GLenum + GL_FOG_HINT* = 0x0C54.GLenum + GL_FLOAT_RGB16_NV* = 0x8888.GLenum + GL_OUTPUT_TEXTURE_COORD18_EXT* = 0x87AF.GLenum + GL_T2F_IUI_N3F_V2F_EXT* = 0x81B3.GLenum + GL_SAMPLER_EXTERNAL_OES* = 0x8D66.GLenum + GL_MAX_SUBROUTINES* = 0x8DE7.GLenum + GL_RED_BIT_ATI* = 0x00000001.GLbitfield + GL_SOURCE2_ALPHA* = 0x858A.GLenum + GL_AUX0* = 0x0409.GLenum + GL_OPERAND1_ALPHA_ARB* = 0x8599.GLenum + GL_TEXTURE_MAX_ANISOTROPY_EXT* = 0x84FE.GLenum + GL_VERTEX_PROGRAM_POINT_SIZE_NV* = 0x8642.GLenum + GL_MULTIVIEW_EXT* = 0x90F1.GLenum + GL_FOG_OFFSET_SGIX* = 0x8198.GLenum + GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL* = 0x83F7.GLenum + GL_ELEMENT_ARRAY_ATI* = 0x8768.GLenum + GL_ALPHA16_SNORM* = 0x9018.GLenum + GL_COMPRESSED_SLUMINANCE_EXT* = 0x8C4A.GLenum + GL_TEXTURE_OBJECT_VALID_QCOM* = 0x8BDB.GLenum + GL_STENCIL_BACK_FUNC* = 0x8800.GLenum + GL_CULL_FACE* = 0x0B44.GLenum + GL_MAP1_COLOR_4* = 0x0D90.GLenum + GL_SHADER_OBJECT_ARB* = 0x8B48.GLenum + GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG* = 0x8C01.GLenum + GL_TANGENT_ARRAY_EXT* = 0x8439.GLenum + GL_NUM_FRAGMENT_CONSTANTS_ATI* = 0x896F.GLenum + GL_COLOR_RENDERABLE* = 0x8286.GLenum + GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS* = 0x8B4D.GLenum + GL_TRANSFORM_FEEDBACK_RECORD_NV* = 0x8C86.GLenum + GL_COLOR_ATTACHMENT1_NV* = 0x8CE1.GLenum + GL_ALPHA_SNORM* = 0x9010.GLenum + GL_PIXEL_TRANSFORM_2D_MATRIX_EXT* = 0x8338.GLenum + GL_SMOOTH_POINT_SIZE_GRANULARITY* = 0x0B13.GLenum + GL_R8I* = 0x8231.GLenum + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT* = 0x8D56.GLenum + GL_POLYGON_OFFSET_BIAS_EXT* = 0x8039.GLenum + GL_DEPTH_COMPONENT24* = 0x81A6.GLenum + GL_TEXTURE_SWIZZLE_B* = 0x8E44.GLenum + GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS* = 0x8E81.GLenum + GL_MAP2_INDEX* = 0x0DB1.GLenum + GL_SAMPLER_CUBE_MAP_ARRAY* = 0x900C.GLenum + GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT* = 0x8CD6.GLenum + GL_UNSIGNED_INT_8_8_8_8_REV* = 0x8367.GLenum + GL_PATH_GEN_COEFF_NV* = 0x90B1.GLenum + GL_OPERAND3_ALPHA_NV* = 0x859B.GLenum + GL_LUMINANCE* = 0x1909.GLenum + GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS* = 0x8DE8.GLenum + GL_MAP_READ_BIT* = 0x0001.GLbitfield + GL_MAX_TEXTURE_STACK_DEPTH* = 0x0D39.GLenum + GL_ORDER* = 0x0A01.GLenum + GL_PATH_FILL_MODE_NV* = 0x9080.GLenum + GL_RENDERBUFFER_BLUE_SIZE* = 0x8D52.GLenum + GL_TEXTURE_INTENSITY_SIZE* = 0x8061.GLenum + GL_DRAW_BUFFER1_NV* = 0x8826.GLenum + GL_SCREEN_NV* = 0x9295.GLenum + GL_RGB8I_EXT* = 0x8D8F.GLenum + GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET* = 0x8E5E.GLenum + GL_DUAL_INTENSITY12_SGIS* = 0x811A.GLenum + GL_SPARE1_NV* = 0x852F.GLenum + GL_PALETTE8_R5_G6_B5_OES* = 0x8B97.GLenum + GL_COLOR_ATTACHMENT7_NV* = 0x8CE7.GLenum + GL_TEXTURE_HEIGHT* = 0x1001.GLenum + GL_RENDERBUFFER_BINDING* = 0x8CA7.GLenum + GL_DRAW_BUFFER7_EXT* = 0x882C.GLenum + GL_HISTOGRAM* = 0x8024.GLenum + GL_COLOR_ATTACHMENT0_OES* = 0x8CE0.GLenum + GL_BINORMAL_ARRAY_STRIDE_EXT* = 0x8441.GLenum + GL_DEBUG_SEVERITY_HIGH_AMD* = 0x9146.GLenum + GL_MIN_SPARSE_LEVEL_AMD* = 0x919B.GLenum + GL_MAP1_VERTEX_ATTRIB10_4_NV* = 0x866A.GLenum + GL_COEFF* = 0x0A00.GLenum + GL_COMPRESSED_RGBA_ASTC_6x5_KHR* = 0x93B3.GLenum + GL_TEXTURE_4D_BINDING_SGIS* = 0x814F.GLenum + GL_BUFFER_USAGE* = 0x8765.GLenum + GL_YCBCR_MESA* = 0x8757.GLenum + GL_CLAMP_VERTEX_COLOR* = 0x891A.GLenum + GL_RGBA8_EXT* = 0x8058.GLenum + GL_BITMAP_TOKEN* = 0x0704.GLenum + GL_IMAGE_SCALE_Y_HP* = 0x8156.GLenum + GL_OUTPUT_TEXTURE_COORD25_EXT* = 0x87B6.GLenum + GL_DEBUG_SOURCE_API* = 0x8246.GLenum + GL_STACK_UNDERFLOW* = 0x0504.GLenum + GL_COMBINER_CD_DOT_PRODUCT_NV* = 0x8546.GLenum + GL_FRAMEBUFFER_BINDING_EXT* = 0x8CA6.GLenum + GL_REG_20_ATI* = 0x8935.GLenum + GL_MAP1_TEXTURE_COORD_4* = 0x0D96.GLenum + GL_DEBUG_OUTPUT_SYNCHRONOUS* = 0x8242.GLenum + GL_ACCUM_ALPHA_BITS* = 0x0D5B.GLenum + GL_INT_10_10_10_2_OES* = 0x8DF7.GLenum + GL_FLOAT_MAT2_ARB* = 0x8B5A.GLenum + GL_FRONT_RIGHT* = 0x0401.GLenum + GL_COMBINER_AB_DOT_PRODUCT_NV* = 0x8545.GLenum + GL_LUMINANCE_ALPHA* = 0x190A.GLenum + GL_C4UB_V2F* = 0x2A22.GLenum + GL_COMBINER_MUX_SUM_NV* = 0x8547.GLenum + GL_MODELVIEW_STACK_DEPTH* = 0x0BA3.GLenum + GL_SAMPLES_ARB* = 0x80A9.GLenum + GL_ALPHA_TEST_FUNC* = 0x0BC1.GLenum + GL_DEPTH_CLAMP* = 0x864F.GLenum + GL_MAP2_VERTEX_ATTRIB8_4_NV* = 0x8678.GLenum + GL_INVALID_INDEX* = 0xFFFFFFFF.GLenum + GL_COMBINER_SCALE_NV* = 0x8548.GLenum + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER* = 0x92CB.GLenum + GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV* = 0x864E.GLenum + GL_RELATIVE_SMALL_CW_ARC_TO_NV* = 0x15.GLenum + GL_UNSIGNED_INT_10_10_10_2_OES* = 0x8DF6.GLenum + GL_DISCARD_ATI* = 0x8763.GLenum + GL_PRIMITIVE_RESTART_INDEX_NV* = 0x8559.GLenum + GL_IMAGE_CLASS_2_X_8* = 0x82C0.GLenum + GL_MANUAL_GENERATE_MIPMAP* = 0x8294.GLenum + GL_FLOAT_R_NV* = 0x8880.GLenum + GL_SATURATE_BIT_ATI* = 0x00000040.GLbitfield + GL_BUFFER_SIZE* = 0x8764.GLenum + GL_FRAMEBUFFER_BARRIER_BIT_EXT* = 0x00000400.GLbitfield + GL_LUMINANCE8UI_EXT* = 0x8D80.GLenum + GL_T2F_IUI_V2F_EXT* = 0x81B1.GLenum + GL_OUTPUT_TEXTURE_COORD15_EXT* = 0x87AC.GLenum + GL_COVERAGE_AUTOMATIC_NV* = 0x8ED7.GLenum + GL_TEXTURE_INTERNAL_FORMAT_QCOM* = 0x8BD5.GLenum + GL_INT_IMAGE_CUBE_MAP_ARRAY* = 0x905F.GLenum + GL_BUFFER_UPDATE_BARRIER_BIT_EXT* = 0x00000200.GLbitfield + GL_GLYPH_WIDTH_BIT_NV* = 0x01.GLbitfield + GL_OP_MAX_EXT* = 0x878A.GLenum + GL_MINMAX_FORMAT_EXT* = 0x802F.GLenum + GL_R16I* = 0x8233.GLenum + GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB* = 0x8809.GLenum + GL_TEXTURE_MAX_LEVEL* = 0x813D.GLenum + GL_GEOMETRY_SHADER* = 0x8DD9.GLenum + GL_MAX_RENDERBUFFER_SIZE* = 0x84E8.GLenum + GL_RGB16_EXT* = 0x8054.GLenum + GL_DUAL_INTENSITY16_SGIS* = 0x811B.GLenum + GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT* = 0x8CD6.GLenum + GL_BLUE_SCALE* = 0x0D1A.GLenum + GL_RGBA_FLOAT16_APPLE* = 0x881A.GLenum + GL_RGBA8UI* = 0x8D7C.GLenum + GL_COLOR_ATTACHMENT5* = 0x8CE5.GLenum + GL_UNSIGNED_IDENTITY_NV* = 0x8536.GLenum + GL_COMPRESSED_RGBA_ASTC_10x8_KHR* = 0x93BA.GLenum + GL_FRAGMENT_SHADER_ARB* = 0x8B30.GLenum + GL_R8* = 0x8229.GLenum + GL_IMAGE_BINDING_LAYERED* = 0x8F3C.GLenum + GL_RGBA_FLOAT32_ATI* = 0x8814.GLenum + GL_TEXTURE_RED_SIZE_EXT* = 0x805C.GLenum + GL_INT8_VEC2_NV* = 0x8FE1.GLenum + GL_NEGATE_BIT_ATI* = 0x00000004.GLbitfield + GL_ALL_BARRIER_BITS_EXT* = 0xFFFFFFFF.GLbitfield + GL_LIGHT_MODEL_COLOR_CONTROL_EXT* = 0x81F8.GLenum + GL_LUMINANCE_ALPHA16UI_EXT* = 0x8D7B.GLenum + GL_COUNT_UP_NV* = 0x9088.GLenum + GL_QUERY_RESULT_AVAILABLE_ARB* = 0x8867.GLenum + GL_DRAW_INDIRECT_BUFFER* = 0x8F3F.GLenum + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT* = 0x8CD3.GLenum + GL_OP_DOT3_EXT* = 0x8784.GLenum + GL_COLOR_ATTACHMENT10_NV* = 0x8CEA.GLenum + GL_STENCIL_INDEX4_OES* = 0x8D47.GLenum + GL_LUMINANCE_FLOAT32_ATI* = 0x8818.GLenum + GL_DRAW_BUFFER9_ARB* = 0x882E.GLenum + GL_RG8_EXT* = 0x822B.GLenum + GL_FONT_DESCENDER_BIT_NV* = 0x00400000.GLbitfield + GL_TEXTURE_ALPHA_SIZE_EXT* = 0x805F.GLenum + GL_Y_EXT* = 0x87D6.GLenum + GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT* = 0x8DE4.GLenum + GL_SAMPLER_3D_ARB* = 0x8B5F.GLenum + GL_INVERT_OVG_NV* = 0x92B4.GLenum + GL_REFERENCED_BY_TESS_EVALUATION_SHADER* = 0x9308.GLenum + GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL* = 0x83F8.GLenum + GL_LIGHT4* = 0x4004.GLenum + GL_VERTEX_STATE_PROGRAM_NV* = 0x8621.GLenum + GL_ZERO* = 0.GLenum + GL_SAMPLER_CUBE_MAP_ARRAY_ARB* = 0x900C.GLenum + GL_SAMPLE_MASK_EXT* = 0x80A0.GLenum + GL_COMBINER_CD_OUTPUT_NV* = 0x854B.GLenum + GL_SAMPLE_ALPHA_TO_MASK_SGIS* = 0x809E.GLenum + GL_RGBA16* = 0x805B.GLenum + GL_PATH_TERMINAL_DASH_CAP_NV* = 0x907D.GLenum + GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB* = 0x889C.GLenum + GL_DEBUG_SEVERITY_HIGH_KHR* = 0x9146.GLenum + GL_DRAW_BUFFER14_EXT* = 0x8833.GLenum + GL_READ_FRAMEBUFFER* = 0x8CA8.GLenum + GL_UNSIGNED_SHORT_8_8_APPLE* = 0x85BA.GLenum + GL_OR* = 0x1507.GLenum + GL_ONE_MINUS_DST_ALPHA* = 0x0305.GLenum + GL_RGB12* = 0x8053.GLenum + GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES* = 0x8CDB.GLenum + GL_OUTPUT_TEXTURE_COORD26_EXT* = 0x87B7.GLenum + GL_LOCAL_CONSTANT_VALUE_EXT* = 0x87EC.GLenum + GL_SURFACE_REGISTERED_NV* = 0x86FD.GLenum + GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV* = 0x8E5D.GLenum + GL_COMPRESSED_RG_RGTC2* = 0x8DBD.GLenum + GL_MAX_VERTEX_ATTRIB_STRIDE* = 0x82E5.GLenum + GL_COLOR_ARRAY_ADDRESS_NV* = 0x8F23.GLenum + GL_MATRIX_INDEX_ARRAY_POINTER_ARB* = 0x8849.GLenum + GL_DUAL_ALPHA8_SGIS* = 0x8111.GLenum + GL_TEXTURE_MAX_LOD* = 0x813B.GLenum + GL_INTERNALFORMAT_SHARED_SIZE* = 0x8277.GLenum + GL_LINEAR_DETAIL_SGIS* = 0x8097.GLenum + GL_RG16F_EXT* = 0x822F.GLenum + GL_LIST_MODE* = 0x0B30.GLenum + GL_VIEWPORT_INDEX_PROVOKING_VERTEX* = 0x825F.GLenum + GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW* = 0x900D.GLenum + GL_COLOR_TABLE_LUMINANCE_SIZE* = 0x80DE.GLenum + GL_COLOR_ARRAY_POINTER* = 0x8090.GLenum + GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT* = 0x84FF.GLenum + GL_LUMINANCE32F_EXT* = 0x8818.GLenum + GL_FRAMEBUFFER_COMPLETE_OES* = 0x8CD5.GLenum + GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB* = 0x8F9F.GLenum + GL_FEEDBACK* = 0x1C01.GLenum + GL_UNSIGNED_INT_IMAGE_2D_ARRAY* = 0x9069.GLenum + GL_VERTEX_STREAM1_ATI* = 0x876D.GLenum + GL_SLUMINANCE_ALPHA_NV* = 0x8C44.GLenum + GL_MAX_TEXTURE_UNITS_ARB* = 0x84E2.GLenum + GL_MODELVIEW11_ARB* = 0x872B.GLenum + GL_DRAW_FRAMEBUFFER_BINDING_ANGLE* = 0x8CA6.GLenum + GL_NEGATIVE_W_EXT* = 0x87DC.GLenum + GL_MODELVIEW25_ARB* = 0x8739.GLenum + GL_NORMAL_ARRAY_LIST_STRIDE_IBM* = 103081.GLenum + GL_CON_0_ATI* = 0x8941.GLenum + GL_VERTEX_SHADER_INSTRUCTIONS_EXT* = 0x87CF.GLenum + GL_TRANSPOSE_PROGRAM_MATRIX_EXT* = 0x8E2E.GLenum + GL_TEXTURE_DEPTH_TYPE* = 0x8C16.GLenum + GL_PROGRAM_TARGET_NV* = 0x8646.GLenum + GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT* = 0x87CC.GLenum + GL_NORMAL_ARRAY_STRIDE_EXT* = 0x807F.GLenum + GL_INT_SAMPLER_2D* = 0x8DCA.GLenum + GL_MAP2_VERTEX_ATTRIB10_4_NV* = 0x867A.GLenum + GL_STEREO* = 0x0C33.GLenum + GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT* = 0x9065.GLenum + GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV* = 0x8C75.GLenum + GL_TRACE_ERRORS_BIT_MESA* = 0x0020.GLbitfield + GL_MAX_GEOMETRY_UNIFORM_BLOCKS* = 0x8A2C.GLenum + GL_CONVOLUTION_2D* = 0x8011.GLenum + GL_RGB_SCALE_ARB* = 0x8573.GLenum + GL_VIDEO_COLOR_CONVERSION_MAX_NV* = 0x902A.GLenum + GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS* = 0x90DD.GLenum + GL_TABLE_TOO_LARGE_EXT* = 0x8031.GLenum + GL_TRANSFORM_FEEDBACK_BINDING_NV* = 0x8E25.GLenum + GL_TEXTURE16_ARB* = 0x84D0.GLenum + GL_FRAGMENT_SHADER_DERIVATIVE_HINT* = 0x8B8B.GLenum + GL_IUI_N3F_V2F_EXT* = 0x81AF.GLenum + GL_CLIP_PLANE2_IMG* = 0x3002.GLenum + GL_VERTEX_ATTRIB_ARRAY10_NV* = 0x865A.GLenum + GL_TEXTURE_FETCH_BARRIER_BIT* = 0x00000008.GLbitfield + GL_DOT3_RGBA_EXT* = 0x8741.GLenum + GL_RENDERBUFFER_GREEN_SIZE_EXT* = 0x8D51.GLenum + GL_MAX_CLIENT_ATTRIB_STACK_DEPTH* = 0x0D3B.GLenum + GL_UNPACK_COMPRESSED_BLOCK_SIZE* = 0x912A.GLenum + GL_SAMPLE_BUFFERS_SGIS* = 0x80A8.GLenum + GL_MAP1_VERTEX_ATTRIB1_4_NV* = 0x8661.GLenum + GL_BUFFER_OBJECT_EXT* = 0x9151.GLenum + GL_INT_SAMPLER_1D_ARRAY* = 0x8DCE.GLenum + GL_POST_TEXTURE_FILTER_SCALE_SGIX* = 0x817A.GLenum + GL_RED_MAX_CLAMP_INGR* = 0x8564.GLenum + GL_POST_COLOR_MATRIX_RED_SCALE_SGI* = 0x80B4.GLenum + GL_TEXTURE_COORD_ARRAY_TYPE* = 0x8089.GLenum + GL_COMPRESSED_SIGNED_RG11_EAC* = 0x9273.GLenum + GL_MULTISAMPLE_FILTER_HINT_NV* = 0x8534.GLenum + GL_COMPRESSED_RGBA8_ETC2_EAC* = 0x9278.GLenum + GL_FONT_UNDERLINE_THICKNESS_BIT_NV* = 0x08000000.GLbitfield + GL_READ_WRITE_ARB* = 0x88BA.GLenum + GL_RENDER_MODE* = 0x0C40.GLenum + GL_MAX_NUM_COMPATIBLE_SUBROUTINES* = 0x92F8.GLenum + GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI* = 0x87F8.GLenum + GL_MODELVIEW0_STACK_DEPTH_EXT* = 0x0BA3.GLenum + GL_CONTEXT_FLAG_DEBUG_BIT* = 0x00000002.GLbitfield + GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT* = 0x8C84.GLenum + GL_POINT_SIZE_MAX_EXT* = 0x8127.GLenum + GL_COLOR_ARRAY_LENGTH_NV* = 0x8F2D.GLenum + GL_COLOR_COMPONENTS* = 0x8283.GLenum + GL_LINEARDODGE_NV* = 0x92A4.GLenum + GL_TEXTURE20_ARB* = 0x84D4.GLenum + GL_UNSIGNED_INT64_VEC4_NV* = 0x8FF7.GLenum + GL_TEXTURE28* = 0x84DC.GLenum + GL_HISTOGRAM_FORMAT_EXT* = 0x8027.GLenum + GL_PROGRAM_MATRIX_EXT* = 0x8E2D.GLenum + GL_PIXEL_PACK_BUFFER_EXT* = 0x88EB.GLenum + GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT* = 0x8515.GLenum + GL_STANDARD_FONT_NAME_NV* = 0x9072.GLenum + GL_REG_13_ATI* = 0x892E.GLenum + GL_GREEN_SCALE* = 0x0D18.GLenum + GL_COLOR_BUFFER_BIT7_QCOM* = 0x00000080.GLbitfield + GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS* = 0x8264.GLenum + GL_LUMINANCE8_ALPHA8_SNORM* = 0x9016.GLenum + GL_GCCSO_SHADER_BINARY_FJ* = 0x9260.GLenum + GL_COORD_REPLACE_NV* = 0x8862.GLenum + GL_SOURCE2_RGB_EXT* = 0x8582.GLenum + GL_IR_INSTRUMENT1_SGIX* = 0x817F.GLenum + GL_CONTEXT_FLAG_DEBUG_BIT_KHR* = 0x00000002.GLbitfield + GL_SWIZZLE_STR_ATI* = 0x8976.GLenum + GL_OUTPUT_TEXTURE_COORD17_EXT* = 0x87AE.GLenum + GL_MODELVIEW2_ARB* = 0x8722.GLenum + GL_R1UI_C4F_N3F_V3F_SUN* = 0x85C8.GLenum + GL_MAX_TEXTURE_BUFFER_SIZE_ARB* = 0x8C2B.GLenum + GL_OUTPUT_TEXTURE_COORD0_EXT* = 0x879D.GLenum + GL_POINT_FADE_THRESHOLD_SIZE_EXT* = 0x8128.GLenum + GL_OUTPUT_TEXTURE_COORD30_EXT* = 0x87BB.GLenum + GL_EVAL_VERTEX_ATTRIB3_NV* = 0x86C9.GLenum + GL_SPHERE_MAP* = 0x2402.GLenum + GL_SHADER_IMAGE_ATOMIC* = 0x82A6.GLenum + GL_INDEX_BITS* = 0x0D51.GLenum + GL_INTERNALFORMAT_ALPHA_TYPE* = 0x827B.GLenum + GL_CON_15_ATI* = 0x8950.GLenum + GL_TESS_EVALUATION_TEXTURE* = 0x829D.GLenum + GL_EDGE_FLAG_ARRAY_STRIDE* = 0x808C.GLenum + GL_VERTEX_ATTRIB_ARRAY8_NV* = 0x8658.GLenum + GL_POST_COLOR_MATRIX_COLOR_TABLE* = 0x80D2.GLenum + GL_CLOSE_PATH_NV* = 0x00.GLenum + GL_SCALE_BY_TWO_NV* = 0x853E.GLenum + GL_PALETTE8_RGB8_OES* = 0x8B95.GLenum + GL_MAX_COMPUTE_ATOMIC_COUNTERS* = 0x8265.GLenum + GL_VERTEX_ATTRIB_ARRAY_NORMALIZED* = 0x886A.GLenum + GL_MAX_VERTEX_ATTRIBS* = 0x8869.GLenum + GL_PROGRAM_POINT_SIZE_EXT* = 0x8642.GLenum + GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE* = 0x93A0.GLenum + GL_SIGNED_NORMALIZED* = 0x8F9C.GLenum + GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES* = 0x851C.GLenum + GL_OFFSET_TEXTURE_2D_SCALE_NV* = 0x86E2.GLenum + GL_COMPRESSED_SLUMINANCE* = 0x8C4A.GLenum + GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS* = 0x8E80.GLenum + GL_RASTER_POSITION_UNCLIPPED_IBM* = 0x19262.GLenum + GL_COMPRESSED_TEXTURE_FORMATS_ARB* = 0x86A3.GLenum + GL_TRANSPOSE_MODELVIEW_MATRIX* = 0x84E3.GLenum + GL_ALPHA_FLOAT16_APPLE* = 0x881C.GLenum + GL_PIXEL_MIN_FILTER_EXT* = 0x8332.GLenum + GL_MAX_SPARSE_TEXTURE_SIZE_AMD* = 0x9198.GLenum + GL_UNSIGNED_SHORT_5_6_5_REV_EXT* = 0x8364.GLenum + GL_DU8DV8_ATI* = 0x877A.GLenum + GL_COLOR_ARRAY_LIST_IBM* = 103072.GLenum + GL_RGBA8I_EXT* = 0x8D8E.GLenum + GL_MULTISAMPLE_BUFFER_BIT4_QCOM* = 0x10000000.GLbitfield + GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB* = 0x824D.GLenum + GL_MODELVIEW20_ARB* = 0x8734.GLenum + GL_COLOR_TABLE_RED_SIZE* = 0x80DA.GLenum + GL_UNIFORM_BARRIER_BIT* = 0x00000004.GLbitfield + GL_TEXTURE* = 0x1702.GLenum + GL_CLIP_PLANE0* = 0x3000.GLenum + GL_FOG_COORDINATE_ARRAY_POINTER* = 0x8456.GLenum + GL_CONSTANT_ALPHA_EXT* = 0x8003.GLenum + GL_NAME_STACK_DEPTH* = 0x0D70.GLenum + GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE* = 0x83F2.GLenum + GL_LINEAR_DETAIL_ALPHA_SGIS* = 0x8098.GLenum + GL_EDGE_FLAG_ARRAY_POINTER_EXT* = 0x8093.GLenum + GL_UNSIGNED_SHORT* = 0x1403.GLenum + GL_MAP2_VERTEX_ATTRIB1_4_NV* = 0x8671.GLenum + GL_DEPTH_CLAMP_FAR_AMD* = 0x901F.GLenum + GL_OPERAND3_RGB_NV* = 0x8593.GLenum + GL_TEXTURE_SWIZZLE_R_EXT* = 0x8E42.GLenum + GL_PATCHES* = 0x000E.GLenum + GL_TEXTURE12* = 0x84CC.GLenum + GL_COLOR_ATTACHMENT12_EXT* = 0x8CEC.GLenum + GL_MAP2_VERTEX_ATTRIB15_4_NV* = 0x867F.GLenum + GL_DRAW_BUFFER15_ATI* = 0x8834.GLenum + GL_GEOMETRY_INPUT_TYPE* = 0x8917.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_OES* = 0x9279.GLenum + GL_RGBA32UI_EXT* = 0x8D70.GLenum + GL_RGBA_FLOAT32_APPLE* = 0x8814.GLenum + GL_NORMAL_MAP_OES* = 0x8511.GLenum + GL_MAP2_GRID_DOMAIN* = 0x0DD2.GLenum + GL_RELATIVE_HORIZONTAL_LINE_TO_NV* = 0x07.GLenum + GL_TANGENT_ARRAY_STRIDE_EXT* = 0x843F.GLenum + GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT* = 0x8CDB.GLenum + GL_OBJECT_POINT_SGIS* = 0x81F5.GLenum + GL_IMAGE_2D_ARRAY* = 0x9053.GLenum + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB* = 0x8DDF.GLenum + GL_SPRITE_MODE_SGIX* = 0x8149.GLenum + GL_WEIGHT_ARRAY_OES* = 0x86AD.GLenum + GL_MAX_VERTEX_STREAMS* = 0x8E71.GLenum + GL_R16F_EXT* = 0x822D.GLenum + GL_VERSION_ES_CL_1_0* = 1.GLenum + GL_PROXY_TEXTURE_COLOR_TABLE_SGI* = 0x80BD.GLenum + GL_MAX_PROGRAM_INSTRUCTIONS_ARB* = 0x88A1.GLenum + GL_PURGEABLE_APPLE* = 0x8A1D.GLenum + GL_TEXTURE_SWIZZLE_G_EXT* = 0x8E43.GLenum + GL_FIRST_VERTEX_CONVENTION_EXT* = 0x8E4D.GLenum + GL_DEBUG_SEVERITY_LOW* = 0x9148.GLenum + GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT* = 0x00000001.GLbitfield + GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB* = 0x8B8A.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR* = 0x93D4.GLenum + GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV* = 0x86F3.GLenum + GL_RENDERBUFFER_DEPTH_SIZE* = 0x8D54.GLenum + GL_OPERAND1_RGB_ARB* = 0x8591.GLenum + GL_REFLECTION_MAP_NV* = 0x8512.GLenum + GL_MATRIX17_ARB* = 0x88D1.GLenum + GL_EYE_PLANE_ABSOLUTE_NV* = 0x855C.GLenum + GL_SRC1_ALPHA* = 0x8589.GLenum + GL_UNSIGNED_BYTE_2_3_3_REV* = 0x8362.GLenum + GL_RGB5_EXT* = 0x8050.GLenum + GL_TEXTURE_2D_ARRAY* = 0x8C1A.GLenum + GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB* = 0x8515.GLenum + GL_TEXTURE26* = 0x84DA.GLenum + GL_MAX_3D_TEXTURE_SIZE_OES* = 0x8073.GLenum + GL_PIXEL_TILE_WIDTH_SGIX* = 0x8140.GLenum + GL_PIXEL_UNPACK_BUFFER_BINDING_EXT* = 0x88EF.GLenum + GL_TEXTURE_ALPHA_SIZE* = 0x805F.GLenum + GL_RELATIVE_QUADRATIC_CURVE_TO_NV* = 0x0B.GLenum + GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES* = 0x8B9F.GLenum + GL_GEOMETRY_DEFORMATION_BIT_SGIX* = 0x00000002.GLbitfield + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS* = 0x8DA8.GLenum + GL_NAMED_STRING_LENGTH_ARB* = 0x8DE9.GLenum + GL_IMAGE_1D_ARRAY* = 0x9052.GLenum + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES* = 0x8CD4.GLenum + GL_MATRIX28_ARB* = 0x88DC.GLenum + GL_FRAGMENT_LIGHT1_SGIX* = 0x840D.GLenum + GL_HARDMIX_NV* = 0x92A9.GLenum + GL_DEBUG_SOURCE_THIRD_PARTY_KHR* = 0x8249.GLenum + GL_PACK_SWAP_BYTES* = 0x0D00.GLenum + GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB* = 0x8B4A.GLenum + GL_SOURCE2_ALPHA_EXT* = 0x858A.GLenum + GL_DOUBLE_MAT2x4* = 0x8F4A.GLenum + GL_MEDIUM_FLOAT* = 0x8DF1.GLenum + GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX* = 0x813E.GLenum + GL_UNPACK_SKIP_ROWS* = 0x0CF3.GLenum + GL_PACK_COMPRESSED_BLOCK_SIZE* = 0x912E.GLenum + GL_UNSIGNED_INT_IMAGE_2D* = 0x9063.GLenum + GL_COLOR_ARRAY_TYPE_EXT* = 0x8082.GLenum + GL_BUFFER_MAP_POINTER_ARB* = 0x88BD.GLenum + GL_CALLIGRAPHIC_FRAGMENT_SGIX* = 0x8183.GLenum + GL_ONE_MINUS_CONSTANT_COLOR_EXT* = 0x8002.GLenum + GL_COMPRESSED_RGBA_FXT1_3DFX* = 0x86B1.GLenum + GL_CLIP_PLANE1* = 0x3001.GLenum + GL_COVERAGE_BUFFERS_NV* = 0x8ED3.GLenum + GL_ADD_BLEND_IMG* = 0x8C09.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR* = 0x93D5.GLenum + GL_PIXEL_TILE_HEIGHT_SGIX* = 0x8141.GLenum + GL_SAMPLE_COVERAGE_INVERT_ARB* = 0x80AB.GLenum + GL_MAP1_VERTEX_ATTRIB9_4_NV* = 0x8669.GLenum + GL_COLOR_TABLE_BIAS_SGI* = 0x80D7.GLenum + GL_EDGE_FLAG_ARRAY_COUNT_EXT* = 0x808D.GLenum + GL_SAMPLE_BUFFERS_EXT* = 0x80A8.GLenum + GL_COLOR_INDEX* = 0x1900.GLenum + GL_REPLACEMENT_CODE_SUN* = 0x81D8.GLenum + GL_INT_SAMPLER_CUBE_EXT* = 0x8DCC.GLenum + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE* = 0x8D56.GLenum + GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV* = 0x8F1E.GLenum + GL_DUAL_LUMINANCE_ALPHA8_SGIS* = 0x811D.GLenum + GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX* = 0x8189.GLenum + GL_CLIP_DISTANCE7* = 0x3007.GLenum + GL_DOT3_RGB_ARB* = 0x86AE.GLenum + GL_TEXTURE_WRAP_T* = 0x2803.GLenum + GL_LUMINANCE12_EXT* = 0x8041.GLenum + GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX* = 0x8174.GLenum + GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB* = 0x86A0.GLenum + GL_EVAL_2D_NV* = 0x86C0.GLenum + GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS* = 0x9314.GLenum + GL_CURRENT_WEIGHT_ARB* = 0x86A8.GLenum + GL_DEBUG_SOURCE_API_ARB* = 0x8246.GLenum + GL_FOG_SPECULAR_TEXTURE_WIN* = 0x80EC.GLenum + GL_BOOL_VEC4* = 0x8B59.GLenum + GL_FRAGMENTS_INSTRUMENT_SGIX* = 0x8313.GLenum + GL_GEOMETRY_OUTPUT_TYPE_EXT* = 0x8DDC.GLenum + GL_TEXTURE_2D* = 0x0DE1.GLenum + GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI* = 0x00200000.GLbitfield + GL_TEXTURE_BINDING_RECTANGLE_ARB* = 0x84F6.GLenum + GL_SAMPLE_BUFFERS_3DFX* = 0x86B3.GLenum + GL_INDEX_OFFSET* = 0x0D13.GLenum + GL_MAX_COLOR_ATTACHMENTS* = 0x8CDF.GLenum + GL_PLUS_CLAMPED_NV* = 0x92B1.GLenum + GL_SIGNED_NEGATE_NV* = 0x853D.GLenum + GL_PROXY_TEXTURE_2D_STACK_MESAX* = 0x875C.GLenum + GL_MAX_VERTEX_UNIFORM_COMPONENTS* = 0x8B4A.GLenum + GL_SAMPLE_MASK_VALUE_SGIS* = 0x80AA.GLenum + GL_QUADRATIC_ATTENUATION* = 0x1209.GLenum + GL_LUMINANCE32F_ARB* = 0x8818.GLenum + GL_COVERAGE_COMPONENT4_NV* = 0x8ED1.GLenum + GL_MINMAX_FORMAT* = 0x802F.GLenum + GL_SRGB_DECODE_ARB* = 0x8299.GLenum + GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT* = 0x8CDA.GLenum + GL_UNSIGNED_INT_SAMPLER_CUBE_EXT* = 0x8DD4.GLenum + GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2* = 0x9277.GLenum + GL_DISJOINT_NV* = 0x9283.GLenum + GL_TEXTURE_ENV_BIAS_SGIX* = 0x80BE.GLenum + GL_PROXY_TEXTURE_3D_EXT* = 0x8070.GLenum + GL_SGX_BINARY_IMG* = 0x8C0A.GLenum + GL_COPY_READ_BUFFER* = 0x8F36.GLenum + GL_POINT_FADE_THRESHOLD_SIZE_SGIS* = 0x8128.GLenum + GL_UNIFORM_MATRIX_STRIDE* = 0x8A3D.GLenum + GL_UNIFORM_BLOCK_NAME_LENGTH* = 0x8A41.GLenum + GL_HISTOGRAM_LUMINANCE_SIZE* = 0x802C.GLenum + GL_UNSIGNED_SHORT_4_4_4_4* = 0x8033.GLenum + GL_MAX_DEPTH* = 0x8280.GLenum + GL_IMAGE_1D* = 0x904C.GLenum + GL_LUMINANCE8_ALPHA8_EXT* = 0x8045.GLenum + GL_MAX_TEXTURE_IMAGE_UNITS* = 0x8872.GLenum + GL_MODELVIEW16_ARB* = 0x8730.GLenum + GL_CURRENT_PALETTE_MATRIX_OES* = 0x8843.GLenum + GL_SIGNED_HILO_NV* = 0x86F9.GLenum + GL_FRAMEBUFFER_DEFAULT_HEIGHT* = 0x9311.GLenum + GL_UNPACK_SKIP_IMAGES* = 0x806D.GLenum + GL_2_BYTES* = 0x1407.GLenum + GL_ALLOW_DRAW_FRG_HINT_PGI* = 0x1A210.GLenum + GL_INTENSITY16I_EXT* = 0x8D8B.GLenum + GL_MAX_SAMPLES_NV* = 0x8D57.GLenum + GL_VERTEX_ARRAY_STORAGE_HINT_APPLE* = 0x851F.GLenum + GL_LINE_STRIP_ADJACENCY_ARB* = 0x000B.GLenum + GL_COORD_REPLACE* = 0x8862.GLenum + GL_INDEX_MATERIAL_FACE_EXT* = 0x81BA.GLenum + GL_MODELVIEW15_ARB* = 0x872F.GLenum + GL_TEXTURE19* = 0x84D3.GLenum + GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT* = 0x9068.GLenum + GL_SIGNED_INTENSITY8_NV* = 0x8708.GLenum + GL_TEXTURE_MAG_SIZE_NV* = 0x871F.GLenum + GL_DISPATCH_INDIRECT_BUFFER* = 0x90EE.GLenum + GL_MAP1_INDEX* = 0x0D91.GLenum + GL_TEXTURE_BUFFER_DATA_STORE_BINDING* = 0x8C2D.GLenum + GL_MAX_HEIGHT* = 0x827F.GLenum + GL_BLEND_DST_ALPHA* = 0x80CA.GLenum + GL_R1UI_C3F_V3F_SUN* = 0x85C6.GLenum + GL_TEXTURE_PRIORITY_EXT* = 0x8066.GLenum + GL_INT_IMAGE_2D* = 0x9058.GLenum + GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV* = 0x8E11.GLenum + GL_DRAW_BUFFER4_ATI* = 0x8829.GLenum + GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB* = 0x8DDD.GLenum + GL_DEPTH_EXT* = 0x1801.GLenum + GL_SAMPLE_POSITION* = 0x8E50.GLenum + GL_INTERNALFORMAT_DEPTH_TYPE* = 0x827C.GLenum + GL_MATRIX23_ARB* = 0x88D7.GLenum + GL_DEBUG_TYPE_PUSH_GROUP* = 0x8269.GLenum + GL_POLYGON_OFFSET_FILL* = 0x8037.GLenum + GL_FRAGMENT_PROGRAM_BINDING_NV* = 0x8873.GLenum + GL_FRAMEBUFFER_SRGB_CAPABLE_EXT* = 0x8DBA.GLenum + GL_VERTEX_ATTRIB_BINDING* = 0x82D4.GLenum + GL_UNSIGNED_INT8_VEC2_NV* = 0x8FED.GLenum + GL_POLYGON_OFFSET_FACTOR* = 0x8038.GLenum + GL_BOLD_BIT_NV* = 0x01.GLbitfield + GL_CLAMP_TO_BORDER_ARB* = 0x812D.GLint + GL_INDEX_MODE* = 0x0C30.GLenum + GL_SAMPLER_CUBE_SHADOW_NV* = 0x8DC5.GLenum + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT* = 0x8C4F.GLenum + GL_MATRIX21_ARB* = 0x88D5.GLenum + GL_UNPACK_ROW_LENGTH_EXT* = 0x0CF2.GLenum + GL_FRAGMENT_NORMAL_EXT* = 0x834A.GLenum + GL_DOT3_ATI* = 0x8966.GLenum + GL_IMPLEMENTATION_COLOR_READ_TYPE_OES* = 0x8B9A.GLenum + GL_IMAGE_BINDING_ACCESS_EXT* = 0x8F3E.GLenum + GL_SYNC_CL_EVENT_ARB* = 0x8240.GLenum + GL_UNSIGNED_INT_24_8* = 0x84FA.GLenum + GL_2PASS_1_EXT* = 0x80A3.GLenum + GL_POST_TEXTURE_FILTER_BIAS_SGIX* = 0x8179.GLenum + GL_TEXTURE_COMPRESSED_IMAGE_SIZE* = 0x86A0.GLenum + GL_LUMINANCE_ALPHA32UI_EXT* = 0x8D75.GLenum + GL_FORCE_BLUE_TO_ONE_NV* = 0x8860.GLenum + GL_FRAMEBUFFER_DEFAULT* = 0x8218.GLenum + GL_VIRTUAL_PAGE_SIZE_Z_ARB* = 0x9197.GLenum + GL_TEXTURE_LIGHT_EXT* = 0x8350.GLenum + GL_MULTISAMPLE_BUFFER_BIT5_QCOM* = 0x20000000.GLbitfield + GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY* = 0x910D.GLenum + GL_SYNC_CONDITION* = 0x9113.GLenum + GL_PERFMON_RESULT_SIZE_AMD* = 0x8BC5.GLenum + GL_PROGRAM_OBJECT_ARB* = 0x8B40.GLenum + GL_MAX_SHININESS_NV* = 0x8504.GLenum + GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB* = 0x880A.GLenum + GL_RENDERBUFFER_COLOR_SAMPLES_NV* = 0x8E10.GLenum + GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS* = 0x8A31.GLenum + GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH* = 0x8E49.GLenum + GL_MODELVIEW29_ARB* = 0x873D.GLenum + GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB* = 0x900B.GLenum + GL_SIGNED_HILO16_NV* = 0x86FA.GLenum + GL_TRANSFORM_HINT_APPLE* = 0x85B1.GLenum + GL_STENCIL_INDEX4* = 0x8D47.GLenum + GL_EXTENSIONS* = 0x1F03.GLenum + GL_RG16F* = 0x822F.GLenum + GL_MAP_UNSYNCHRONIZED_BIT_EXT* = 0x0020.GLbitfield + GL_LUMINANCE16F_ARB* = 0x881E.GLenum + GL_UNSIGNED_INT_IMAGE_BUFFER* = 0x9067.GLenum + GL_COMPRESSED_RGBA_ASTC_8x8_KHR* = 0x93B7.GLenum + GL_AVERAGE_HP* = 0x8160.GLenum + GL_INDEX_MATERIAL_EXT* = 0x81B8.GLenum + GL_COLOR_TABLE* = 0x80D0.GLenum + GL_FOG_COORDINATE_ARRAY_LIST_IBM* = 103076.GLenum + GL_DEBUG_CATEGORY_OTHER_AMD* = 0x9150.GLenum + GL_R1UI_C4UB_V3F_SUN* = 0x85C5.GLenum + GL_SYSTEM_FONT_NAME_NV* = 0x9073.GLenum + GL_STATIC_VERTEX_ARRAY_IBM* = 103061.GLenum + GL_VERTEX_ATTRIB_ARRAY_DIVISOR_NV* = 0x88FE.GLenum + GL_SCALE_BY_ONE_HALF_NV* = 0x8540.GLenum + GL_INTENSITY_FLOAT32_ATI* = 0x8817.GLenum + GL_FRAGMENT_LIGHT6_SGIX* = 0x8412.GLenum + GL_DECR_WRAP_OES* = 0x8508.GLenum + GL_MODELVIEW23_ARB* = 0x8737.GLenum + GL_PROXY_TEXTURE_1D_ARRAY* = 0x8C19.GLenum + GL_REFERENCED_BY_VERTEX_SHADER* = 0x9306.GLenum + GL_MAX_NAME_LENGTH* = 0x92F6.GLenum + GL_AFFINE_2D_NV* = 0x9092.GLenum + GL_SYNC_OBJECT_APPLE* = 0x8A53.GLenum + GL_PLUS_DARKER_NV* = 0x9292.GLenum + GL_TESS_CONTROL_PROGRAM_NV* = 0x891E.GLenum + GL_RGB_SCALE* = 0x8573.GLenum + GL_RGBA16UI_EXT* = 0x8D76.GLenum + GL_COMPATIBLE_SUBROUTINES* = 0x8E4B.GLenum + GL_COLOR_TABLE_WIDTH* = 0x80D9.GLenum + GL_MAX_COMBINED_UNIFORM_BLOCKS* = 0x8A2E.GLenum + GL_BACK_SECONDARY_COLOR_NV* = 0x8C78.GLenum + GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB* = 0x9344.GLenum + GL_SECONDARY_COLOR_NV* = 0x852D.GLenum + GL_RGB16UI_EXT* = 0x8D77.GLenum + GL_SHADER_STORAGE_BUFFER_SIZE* = 0x90D5.GLenum + GL_VERTEX_SUBROUTINE* = 0x92E8.GLenum + GL_MAP_COLOR* = 0x0D10.GLenum + GL_OBJECT_TYPE_ARB* = 0x8B4E.GLenum + GL_LAST_VIDEO_CAPTURE_STATUS_NV* = 0x9027.GLenum + GL_RGB12_EXT* = 0x8053.GLenum + GL_UNSIGNED_INT_IMAGE_3D_EXT* = 0x9064.GLenum + GL_LUMINANCE8_ALPHA8* = 0x8045.GLenum + GL_FLOAT_RGBA_MODE_NV* = 0x888E.GLenum + GL_CURRENT_RASTER_COLOR* = 0x0B04.GLenum + GL_CURRENT_RASTER_POSITION* = 0x0B07.GLenum + GL_UNIFORM_BLOCK_DATA_SIZE* = 0x8A40.GLenum + GL_MALI_PROGRAM_BINARY_ARM* = 0x8F61.GLenum + GL_QUERY_COUNTER_BITS_ARB* = 0x8864.GLenum + GL_VARIANT_ARRAY_EXT* = 0x87E8.GLenum + GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV* = 0x903A.GLenum + GL_DEPTH_COMPONENT24_ARB* = 0x81A6.GLenum + GL_UNSIGNED_INVERT_NV* = 0x8537.GLenum + GL_TEXTURE_IMMUTABLE_LEVELS* = 0x82DF.GLenum + GL_DRAW_BUFFER12_ATI* = 0x8831.GLenum + GL_MAP_FLUSH_EXPLICIT_BIT_EXT* = 0x0010.GLbitfield + GL_INDEX_WRITEMASK* = 0x0C21.GLenum + GL_POLYGON_SMOOTH* = 0x0B41.GLenum + GL_COMPRESSED_SIGNED_R11_EAC_OES* = 0x9271.GLenum + GL_TEXTURE_SWIZZLE_A_EXT* = 0x8E45.GLenum + GL_TEXTURE_COORD_ARRAY_STRIDE* = 0x808A.GLenum + GL_PIXEL_MAP_I_TO_R* = 0x0C72.GLenum + GL_CONVOLUTION_HEIGHT* = 0x8019.GLenum + GL_SIGNALED* = 0x9119.GLenum + GL_UNSIGNED_INT_24_8_OES* = 0x84FA.GLenum + GL_DRAW_BUFFER6_ARB* = 0x882B.GLenum + GL_BUFFER_SIZE_ARB* = 0x8764.GLenum + GL_CLEAR_BUFFER* = 0x82B4.GLenum + GL_LUMINANCE16UI_EXT* = 0x8D7A.GLenum + GL_FRAMEBUFFER_ATTACHMENT_ANGLE* = 0x93A3.GLenum + GL_STENCIL_ATTACHMENT* = 0x8D20.GLenum + GL_ALL_COMPLETED_NV* = 0x84F2.GLenum + GL_MIN* = 0x8007.GLenum + GL_COLOR_ATTACHMENT11* = 0x8CEB.GLenum + GL_PATH_STENCIL_FUNC_NV* = 0x90B7.GLenum + GL_MAX_LABEL_LENGTH* = 0x82E8.GLenum + GL_WEIGHT_ARRAY_TYPE_OES* = 0x86A9.GLenum + GL_ACCUM_BUFFER_BIT* = 0x00000200.GLbitfield + GL_WEIGHT_ARRAY_POINTER_ARB* = 0x86AC.GLenum + GL_WEIGHT_SUM_UNITY_ARB* = 0x86A6.GLenum + GL_COMPRESSED_SRGB_EXT* = 0x8C48.GLenum + GL_ATTRIB_ARRAY_TYPE_NV* = 0x8625.GLenum + GL_RED_INTEGER_EXT* = 0x8D94.GLenum + GL_ALWAYS_SOFT_HINT_PGI* = 0x1A20D.GLenum + GL_COMPRESSED_SRGB8_ETC2_OES* = 0x9275.GLenum + GL_LOW_FLOAT* = 0x8DF0.GLenum + GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS* = 0x8354.GLenum + GL_TEXTURE_LEQUAL_R_SGIX* = 0x819C.GLenum + GL_CONTEXT_COMPATIBILITY_PROFILE_BIT* = 0x00000002.GLbitfield + GL_INCR* = 0x1E02.GLenum + GL_3D* = 0x0601.GLenum + GL_SHADER_KHR* = 0x82E1.GLenum + GL_SRC_COLOR* = 0x0300.GLenum + GL_DRAW_BUFFER7_NV* = 0x882C.GLenum + GL_VERTEX_ARRAY_SIZE* = 0x807A.GLenum + GL_SAMPLER_2D_RECT* = 0x8B63.GLenum + GL_UNSIGNED_SHORT_4_4_4_4_REV_IMG* = 0x8365.GLenum + GL_READ_PIXEL_DATA_RANGE_NV* = 0x8879.GLenum + GL_EDGE_FLAG* = 0x0B43.GLenum + GL_TEXTURE_3D_EXT* = 0x806F.GLenum + GL_DOT_PRODUCT_TEXTURE_1D_NV* = 0x885C.GLenum + GL_COLOR_SUM_CLAMP_NV* = 0x854F.GLenum + GL_RGB10_A2* = 0x8059.GLenum + GL_BOOL_VEC3* = 0x8B58.GLenum + GL_REG_3_ATI* = 0x8924.GLenum + GL_LINEAR_SHARPEN_ALPHA_SGIS* = 0x80AE.GLenum + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT* = 0x8DA8.GLenum + GL_MAP1_VERTEX_ATTRIB5_4_NV* = 0x8665.GLenum + GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS* = 0x8F39.GLenum + GL_PIXEL_MAP_I_TO_B_SIZE* = 0x0CB4.GLenum + GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT* = 0x00000800.GLbitfield + GL_COLOR_BUFFER_BIT6_QCOM* = 0x00000040.GLbitfield + GL_PROGRAM_TEMPORARIES_ARB* = 0x88A4.GLenum + GL_ELEMENT_ARRAY_BUFFER* = 0x8893.GLenum + GL_ALWAYS_FAST_HINT_PGI* = 0x1A20C.GLenum + GL_INTENSITY_FLOAT16_ATI* = 0x881D.GLenum + GL_ACTIVE_ATTRIBUTE_MAX_LENGTH* = 0x8B8A.GLenum + GL_CON_12_ATI* = 0x894D.GLenum + GL_LINEAR_MIPMAP_NEAREST* = 0x2701.GLint + GL_TEXTURE_COVERAGE_SAMPLES_NV* = 0x9045.GLenum + GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB* = 0x88AB.GLenum + GL_DEPTH_SCALE* = 0x0D1E.GLenum + GL_SOURCE3_ALPHA_NV* = 0x858B.GLenum + GL_ACTIVE_VERTEX_UNITS_ARB* = 0x86A5.GLenum + GL_SWIZZLE_STR_DR_ATI* = 0x8978.GLenum + GL_RGB16I_EXT* = 0x8D89.GLenum + GL_INT_IMAGE_2D_RECT_EXT* = 0x905A.GLenum + GL_GREEN_BIAS* = 0x0D19.GLenum + GL_FRAMEBUFFER_RENDERABLE_LAYERED* = 0x828A.GLenum + GL_COMPRESSED_RGB8_ETC2* = 0x9274.GLenum + GL_COMPRESSED_RGBA_ARB* = 0x84EE.GLenum + GL_MAX_VERTEX_ATOMIC_COUNTERS* = 0x92D2.GLenum + GL_RGBA32I_EXT* = 0x8D82.GLenum + GL_WAIT_FAILED* = 0x911D.GLenum + GL_FOG_COORDINATE_SOURCE_EXT* = 0x8450.GLenum + GL_SAMPLE_MASK_VALUE_NV* = 0x8E52.GLenum + GL_OP_MUL_EXT* = 0x8786.GLenum + GL_FRAGMENT_TEXTURE* = 0x829F.GLenum + GL_GEOMETRY_PROGRAM_NV* = 0x8C26.GLenum + GL_MATRIX20_ARB* = 0x88D4.GLenum + GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT* = 0x845C.GLenum + GL_UNSIGNED_INT_2_10_10_10_REV_EXT* = 0x8368.GLenum + GL_PHONG_HINT_WIN* = 0x80EB.GLenum + GL_EYE_DISTANCE_TO_LINE_SGIS* = 0x81F2.GLenum + GL_SAMPLES_PASSED* = 0x8914.GLenum + GL_MAX_COLOR_ATTACHMENTS_NV* = 0x8CDF.GLenum + GL_WEIGHT_ARRAY_POINTER_OES* = 0x86AC.GLenum + GL_MAX_DEBUG_GROUP_STACK_DEPTH* = 0x826C.GLenum + GL_TEXTURE_2D_STACK_BINDING_MESAX* = 0x875E.GLenum + GL_VARIANT_VALUE_EXT* = 0x87E4.GLenum + GL_TEXTURE_GEN_R* = 0x0C62.GLenum + GL_COMPRESSED_RG11_EAC* = 0x9272.GLenum + GL_IMAGE_ROTATE_ORIGIN_Y_HP* = 0x815B.GLenum + GL_BLEND_ADVANCED_COHERENT_NV* = 0x9285.GLenum + GL_DEBUG_CALLBACK_FUNCTION* = 0x8244.GLenum + GL_PROXY_TEXTURE_4D_SGIS* = 0x8135.GLenum + GL_OCCLUSION_TEST_RESULT_HP* = 0x8166.GLenum + GL_COLOR_ATTACHMENT13_EXT* = 0x8CED.GLenum + GL_LINE_STRIP_ADJACENCY* = 0x000B.GLenum + GL_DEBUG_CATEGORY_APPLICATION_AMD* = 0x914F.GLenum + GL_CIRCULAR_TANGENT_ARC_TO_NV* = 0xFC.GLenum + GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB* = 0x88B3.GLenum + GL_VERTEX_ATTRIB_ARRAY_STRIDE* = 0x8624.GLenum + GL_COMPRESSED_SRGB_ALPHA_EXT* = 0x8C49.GLenum + GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY* = 0x900F.GLenum + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY* = 0x906C.GLenum + GL_LIGHT_MODEL_COLOR_CONTROL* = 0x81F8.GLenum + GL_INT_VEC2_ARB* = 0x8B53.GLenum + GL_PARALLEL_ARRAYS_INTEL* = 0x83F4.GLenum + GL_COLOR_ATTACHMENT11_EXT* = 0x8CEB.GLenum + GL_SAMPLE_ALPHA_TO_ONE_SGIS* = 0x809F.GLenum + GL_FUNC_ADD_OES* = 0x8006.GLenum + GL_COMBINER_MAPPING_NV* = 0x8543.GLenum + GL_INT_IMAGE_BUFFER* = 0x905C.GLenum + GL_TEXTURE_SWIZZLE_A* = 0x8E45.GLenum + GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB* = 0x8DA7.GLenum + GL_EXPAND_NEGATE_NV* = 0x8539.GLenum + GL_COVERAGE_EDGE_FRAGMENTS_NV* = 0x8ED6.GLenum + GL_PATH_OBJECT_BOUNDING_BOX_NV* = 0x908A.GLenum + GL_MAX_RECTANGLE_TEXTURE_SIZE* = 0x84F8.GLenum + GL_FONT_ASCENDER_BIT_NV* = 0x00200000.GLbitfield + GL_INDEX_SHIFT* = 0x0D12.GLenum + GL_LUMINANCE6_ALPHA2* = 0x8044.GLenum + GL_FLOAT_CLEAR_COLOR_VALUE_NV* = 0x888D.GLenum + GL_V2F* = 0x2A20.GLenum + GL_DRAW_BUFFER12_NV* = 0x8831.GLenum + GL_RIGHT* = 0x0407.GLenum + GL_CON_28_ATI* = 0x895D.GLenum + GL_SAMPLER_CUBE_ARB* = 0x8B60.GLenum + GL_OUTPUT_TEXTURE_COORD27_EXT* = 0x87B8.GLenum + GL_MAX_DEPTH_TEXTURE_SAMPLES* = 0x910F.GLenum + GL_MODULATE* = 0x2100.GLenum + GL_NUM_FILL_STREAMS_NV* = 0x8E29.GLenum + GL_DT_SCALE_NV* = 0x8711.GLenum + GL_ONE_MINUS_SRC_COLOR* = 0x0301.GLenum + GL_OPERAND2_ALPHA* = 0x859A.GLenum + GL_MATRIX15_ARB* = 0x88CF.GLenum + GL_MULTISAMPLE* = 0x809D.GLenum + GL_DEPTH32F_STENCIL8* = 0x8CAD.GLenum + GL_COMPRESSED_RGBA_ASTC_4x4_KHR* = 0x93B0.GLenum + GL_DUAL_ALPHA16_SGIS* = 0x8113.GLenum + GL_COMPRESSED_RGB_FXT1_3DFX* = 0x86B0.GLenum + GL_PROXY_TEXTURE_2D_ARRAY* = 0x8C1B.GLenum + GL_UNIFORM_NAME_LENGTH* = 0x8A39.GLenum + GL_COMPILE_AND_EXECUTE* = 0x1301.GLenum + GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG* = 0x9138.GLenum + GL_PIXEL_CUBIC_WEIGHT_EXT* = 0x8333.GLenum + GL_GREEN_MIN_CLAMP_INGR* = 0x8561.GLenum + GL_MAX_TEXTURE_LOD_BIAS* = 0x84FD.GLenum + GL_NORMAL_MAP_NV* = 0x8511.GLenum + GL_PIXEL_UNPACK_BUFFER_BINDING_ARB* = 0x88EF.GLenum + GL_LUMINANCE_ALPHA32F_ARB* = 0x8819.GLenum + GL_LUMINANCE_FLOAT16_APPLE* = 0x881E.GLenum + GL_FACTOR_MIN_AMD* = 0x901C.GLenum + GL_BUFFER_GPU_ADDRESS_NV* = 0x8F1D.GLenum + GL_DEBUG_TYPE_PERFORMANCE_ARB* = 0x8250.GLenum + GL_TEXTURE_RESIDENT* = 0x8067.GLenum + GL_TESS_CONTROL_SHADER_BIT* = 0x00000008.GLbitfield + GL_VERTEX_SHADER* = 0x8B31.GLenum + GL_COLOR_ATTACHMENT15_EXT* = 0x8CEF.GLenum + GL_DRAW_BUFFER2_NV* = 0x8827.GLenum + GL_UNSIGNED_INT* = 0x1405.GLenum + GL_TEXTURE_SHARED_SIZE_EXT* = 0x8C3F.GLenum + GL_LIGHT5* = 0x4005.GLenum + GL_VERTEX_ARRAY_SIZE_EXT* = 0x807A.GLenum + GL_YCRCB_SGIX* = 0x8318.GLenum + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER* = 0x92C9.GLenum + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES* = 0x8CD1.GLenum + GL_QUADRATIC_CURVE_TO_NV* = 0x0A.GLenum + GL_POINTS* = 0x0000.GLenum + GL_OPERAND1_RGB* = 0x8591.GLenum + GL_POINT_DISTANCE_ATTENUATION_ARB* = 0x8129.GLenum + GL_QUERY_BUFFER_BARRIER_BIT* = 0x00008000.GLbitfield + GL_QUAD_LUMINANCE4_SGIS* = 0x8120.GLenum + GL_GENERATE_MIPMAP_SGIS* = 0x8191.GLenum + GL_FRAMEBUFFER_UNSUPPORTED_EXT* = 0x8CDD.GLenum + GL_PALETTE4_RGB5_A1_OES* = 0x8B94.GLenum + GL_TEXTURE_CROP_RECT_OES* = 0x8B9D.GLenum + GL_COMPUTE_SHADER_BIT* = 0x00000020.GLbitfield + GL_OUTPUT_TEXTURE_COORD2_EXT* = 0x879F.GLenum + GL_PALETTE4_RGBA4_OES* = 0x8B93.GLenum + GL_TEXTURE_CLIPMAP_CENTER_SGIX* = 0x8171.GLenum + GL_BLUE_BITS* = 0x0D54.GLenum + GL_RELATIVE_LARGE_CCW_ARC_TO_NV* = 0x17.GLenum + GL_UNSIGNED_SHORT_5_6_5_EXT* = 0x8363.GLenum + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS* = 0x8DE1.GLenum + GL_UNCORRELATED_NV* = 0x9282.GLenum + GL_TESS_EVALUATION_SUBROUTINE* = 0x92EA.GLenum + GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB* = 0x8E5E.GLenum + GL_CON_11_ATI* = 0x894C.GLenum + GL_ACTIVE_TEXTURE* = 0x84E0.GLenum + GL_ASYNC_TEX_IMAGE_SGIX* = 0x835C.GLenum + GL_COLOR_CLEAR_VALUE* = 0x0C22.GLenum + GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY* = 0x910C.GLenum + GL_TESS_CONTROL_TEXTURE* = 0x829C.GLenum + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES* = 0x851A.GLenum + GL_HISTOGRAM_BLUE_SIZE_EXT* = 0x802A.GLenum + GL_PATCH_DEFAULT_OUTER_LEVEL* = 0x8E74.GLenum + GL_PROGRAM_MATRIX_STACK_DEPTH_EXT* = 0x8E2F.GLenum + GL_RENDERBUFFER_BINDING_ANGLE* = 0x8CA7.GLenum + GL_CONSTANT_ATTENUATION* = 0x1207.GLenum + GL_SHADER_CONSISTENT_NV* = 0x86DD.GLenum + GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS* = 0x92D4.GLenum + GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD* = 0x9160.GLenum + GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS* = 0x809C.GLenum + GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT* = 0x9061.GLenum + GL_COUNT_DOWN_NV* = 0x9089.GLenum + GL_MATRIX12_ARB* = 0x88CC.GLenum + GL_MAX_VERTEX_SHADER_INVARIANTS_EXT* = 0x87C7.GLenum + GL_REPLICATE_BORDER_HP* = 0x8153.GLenum + GL_MODELVIEW9_ARB* = 0x8729.GLenum + GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT* = 0x8D6A.GLenum + GL_PROGRAM_PARAMETERS_ARB* = 0x88A8.GLenum + GL_LIST_BIT* = 0x00020000.GLbitfield + GL_MAX_GEOMETRY_ATOMIC_COUNTERS* = 0x92D5.GLenum + GL_CONSTANT_COLOR1_NV* = 0x852B.GLenum + GL_AVERAGE_EXT* = 0x8335.GLenum + GL_SINGLE_COLOR_EXT* = 0x81F9.GLenum + GL_VERTEX_ARRAY* = 0x8074.GLenum + GL_COLOR_INDEX1_EXT* = 0x80E2.GLenum + GL_COMPUTE_PROGRAM_NV* = 0x90FB.GLenum + GL_LINES_ADJACENCY* = 0x000A.GLenum + GL_OP_ROUND_EXT* = 0x8790.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE* = 0x934C.GLenum + GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV* = 0x90D1.GLenum + GL_REG_11_ATI* = 0x892C.GLenum + GL_SAMPLES_EXT* = 0x80A9.GLenum + GL_FUNC_REVERSE_SUBTRACT* = 0x800B.GLenum + GL_POINT_SPRITE_COORD_ORIGIN* = 0x8CA0.GLenum + GL_REG_27_ATI* = 0x893C.GLenum + GL_TEXTURE_VIEW_MIN_LEVEL* = 0x82DB.GLenum + GL_NICEST* = 0x1102.GLenum + GL_CLIP_PLANE4_IMG* = 0x3004.GLenum + GL_ARRAY_BUFFER_BINDING* = 0x8894.GLenum + GL_422_AVERAGE_EXT* = 0x80CE.GLenum + GL_RENDERER* = 0x1F01.GLenum + GL_OVERLAY_NV* = 0x9296.GLenum + GL_TEXTURE_SAMPLES_IMG* = 0x9136.GLenum + GL_DEBUG_SOURCE_SHADER_COMPILER_KHR* = 0x8248.GLenum + GL_EYE_DISTANCE_TO_POINT_SGIS* = 0x81F0.GLenum + GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV* = 0x8DA5.GLenum + GL_FILTER4_SGIS* = 0x8146.GLenum + GL_LIGHT_MODEL_LOCAL_VIEWER* = 0x0B51.GLenum + GL_TRIANGLE_MESH_SUN* = 0x8615.GLenum + GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB* = 0x900D.GLenum + GL_DEPTH_COMPONENTS* = 0x8284.GLenum + GL_NUM_GENERAL_COMBINERS_NV* = 0x854E.GLenum + GL_CLIENT_ACTIVE_TEXTURE_ARB* = 0x84E1.GLenum + GL_FRAGMENT_DEPTH* = 0x8452.GLenum + GL_SEPARATE_ATTRIBS* = 0x8C8D.GLenum + GL_HALF_FLOAT_OES* = 0x8D61.GLenum + GL_PROXY_TEXTURE_2D* = 0x8064.GLenum + GL_VARIANT_ARRAY_TYPE_EXT* = 0x87E7.GLenum + GL_DRAW_BUFFER11_ATI* = 0x8830.GLenum + GL_MATRIX_INDEX_ARRAY_POINTER_OES* = 0x8849.GLenum + GL_CURRENT_INDEX* = 0x0B01.GLenum + GL_UNSIGNED_INT_24_8_MESA* = 0x8751.GLenum + GL_PROGRAM_SEPARABLE* = 0x8258.GLenum + GL_TEXTURE8_ARB* = 0x84C8.GLenum + GL_OPERAND0_ALPHA_EXT* = 0x8598.GLenum + GL_PER_STAGE_CONSTANTS_NV* = 0x8535.GLenum + GL_LINE_LOOP* = 0x0002.GLenum + GL_DRAW_PIXEL_TOKEN* = 0x0705.GLenum + GL_DRAW_BUFFER3* = 0x8828.GLenum + GL_GEOMETRY_DEFORMATION_SGIX* = 0x8194.GLenum + GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT* = 0x851C.GLenum + GL_GLYPH_VERTICAL_BEARING_X_BIT_NV* = 0x20.GLbitfield + GL_TEXTURE30* = 0x84DE.GLenum + GL_4PASS_1_EXT* = 0x80A5.GLenum + GL_RGB16F_EXT* = 0x881B.GLenum + GL_2PASS_0_SGIS* = 0x80A2.GLenum + GL_CON_27_ATI* = 0x895C.GLenum + GL_SAMPLE_ALPHA_TO_ONE* = 0x809F.GLenum + GL_POLYGON_SMOOTH_HINT* = 0x0C53.GLenum + GL_COLOR_ATTACHMENT_EXT* = 0x90F0.GLenum + GL_PATCH_DEFAULT_INNER_LEVEL* = 0x8E73.GLenum + GL_TEXTURE_MAX_CLAMP_T_SGIX* = 0x836A.GLenum + GL_WEIGHT_ARRAY_BUFFER_BINDING_OES* = 0x889E.GLenum + GL_TEXTURE1* = 0x84C1.GLenum + GL_LINES* = 0x0001.GLenum + GL_PIXEL_TILE_GRID_DEPTH_SGIX* = 0x8144.GLenum + GL_TEXTURE2* = 0x84C2.GLenum + GL_IMAGE_CUBE_MAP_ARRAY_EXT* = 0x9054.GLenum + GL_DRAW_BUFFER4* = 0x8829.GLenum + GL_DRAW_BUFFER_EXT* = 0x0C01.GLenum + GL_STENCIL_INDEX1* = 0x8D46.GLenum + GL_DEPTH_COMPONENT32F_NV* = 0x8DAB.GLenum + GL_VERTEX_ATTRIB_ARRAY_POINTER* = 0x8645.GLenum + GL_DOUBLE_MAT4x2* = 0x8F4D.GLenum + GL_MOVE_TO_NV* = 0x02.GLenum + GL_OP_RECIP_SQRT_EXT* = 0x8795.GLenum + GL_SAMPLER_1D_ARRAY* = 0x8DC0.GLenum + GL_MIN_FRAGMENT_INTERPOLATION_OFFSET* = 0x8E5B.GLenum + GL_TEXTURE_DEPTH_EXT* = 0x8071.GLenum + GL_STENCIL_INDEX8* = 0x8D48.GLenum + GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB* = 0x880C.GLenum + GL_INTERNALFORMAT_DEPTH_SIZE* = 0x8275.GLenum + GL_STATE_RESTORE* = 0x8BDC.GLenum + GL_SMALL_CW_ARC_TO_NV* = 0x14.GLenum + GL_LUMINANCE16* = 0x8042.GLenum + GL_VERTEX_ATTRIB_ARRAY1_NV* = 0x8651.GLenum + GL_TEXTURE_MAX_CLAMP_R_SGIX* = 0x836B.GLenum + GL_LUMINANCE_FLOAT16_ATI* = 0x881E.GLenum + GL_MAX_TEXTURE_UNITS* = 0x84E2.GLenum + GL_DRAW_BUFFER4_ARB* = 0x8829.GLenum + GL_DRAW_BUFFER12* = 0x8831.GLenum + GL_R8UI* = 0x8232.GLenum + GL_STENCIL_REF* = 0x0B97.GLenum + GL_VARIANT_EXT* = 0x87C1.GLenum + GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE* = 0x8A09.GLenum + GL_QUERY_OBJECT_AMD* = 0x9153.GLenum + GL_PLUS_NV* = 0x9291.GLenum + GL_UNPACK_SWAP_BYTES* = 0x0CF0.GLenum + GL_MAX_UNIFORM_LOCATIONS* = 0x826E.GLenum + GL_GUILTY_CONTEXT_RESET_EXT* = 0x8253.GLenum + GL_DOT3_RGBA_IMG* = 0x86AF.GLenum + GL_X_EXT* = 0x87D5.GLenum + GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB* = 0x900F.GLenum + GL_TEXTURE_COMPARE_FAIL_VALUE_ARB* = 0x80BF.GLenum + GL_ETC1_RGB8_OES* = 0x8D64.GLenum + GL_LUMINANCE_ALPHA_INTEGER_EXT* = 0x8D9D.GLenum + GL_MINMAX_SINK* = 0x8030.GLenum + GL_RG32F* = 0x8230.GLenum + GL_PROXY_TEXTURE_2D_MULTISAMPLE* = 0x9101.GLenum + GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV* = 0x86D9.GLenum + GL_R16* = 0x822A.GLenum + GL_BOUNDING_BOX_NV* = 0x908D.GLenum + GL_INVALID_ENUM* = 0x0500.GLenum + GL_MOVE_TO_RESETS_NV* = 0x90B5.GLenum + GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE* = 0x9117.GLenum + GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB* = 0x84F8.GLenum + GL_UNSIGNED_INT_10F_11F_11F_REV_EXT* = 0x8C3B.GLenum + GL_VERTEX_PRECLIP_HINT_SGIX* = 0x83EF.GLenum + GL_CLIENT_VERTEX_ARRAY_BIT* = 0x00000002.GLbitfield + GL_MAT_COLOR_INDEXES_BIT_PGI* = 0x01000000.GLbitfield + GL_PERFORMANCE_MONITOR_AMD* = 0x9152.GLenum + GL_QUAD_STRIP* = 0x0008.GLenum + GL_MAX_TEXTURE_COORDS_NV* = 0x8871.GLenum + GL_TESS_EVALUATION_SUBROUTINE_UNIFORM* = 0x92F0.GLenum + GL_DRAW_BUFFER1_EXT* = 0x8826.GLenum + GL_TEXTURE18* = 0x84D2.GLenum + GL_COLOR_ATTACHMENT5_NV* = 0x8CE5.GLenum + GL_MAX_COMPUTE_WORK_GROUP_SIZE* = 0x91BF.GLenum + GL_T2F_C4UB_V3F* = 0x2A29.GLenum + GL_MAP1_GRID_DOMAIN* = 0x0DD0.GLenum + GL_DEBUG_TYPE_PUSH_GROUP_KHR* = 0x8269.GLenum + GL_STATIC_READ* = 0x88E5.GLenum + GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB* = 0x880E.GLenum + GL_DOUBLE_EXT* = 0x140A.GLenum + GL_MAX_FRAGMENT_UNIFORM_VECTORS* = 0x8DFD.GLenum + GL_R32F_EXT* = 0x822E.GLenum + GL_MAX_RENDERBUFFER_SIZE_EXT* = 0x84E8.GLenum + GL_COMPRESSED_TEXTURE_FORMATS* = 0x86A3.GLenum + GL_MAX_EXT* = 0x8008.GLenum + GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB* = 0x8622.GLenum + GL_INTERPOLATE* = 0x8575.GLenum + GL_QUERY_RESULT_NO_WAIT_AMD* = 0x9194.GLenum + GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES* = 0x8516.GLenum + GL_LUMINANCE16_ALPHA16_SNORM* = 0x901A.GLenum + GL_SRC_ALPHA_SATURATE* = 0x0308.GLenum + GL_DRAW_INDIRECT_BUFFER_BINDING* = 0x8F43.GLenum + GL_T2F_IUI_N3F_V3F_EXT* = 0x81B4.GLenum + GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB* = 0x8B49.GLenum + GL_MAX_ASYNC_READ_PIXELS_SGIX* = 0x8361.GLenum + GL_VERTEX_ARRAY_RANGE_APPLE* = 0x851D.GLenum + GL_SAMPLER_2D_SHADOW_ARB* = 0x8B62.GLenum + GL_ETC1_SRGB8_NV* = 0x88EE.GLenum + GL_COLORBURN_NV* = 0x929A.GLenum + GL_SAMPLER_2D_ARRAY_SHADOW_EXT* = 0x8DC4.GLenum + GL_ALL_BARRIER_BITS* = 0xFFFFFFFF.GLbitfield + GL_TRIANGLE_STRIP_ADJACENCY_EXT* = 0x000D.GLenum + GL_MAX_TEXTURE_BUFFER_SIZE* = 0x8C2B.GLenum + GL_ALIASED_POINT_SIZE_RANGE* = 0x846D.GLenum + GL_STENCIL_BACK_VALUE_MASK* = 0x8CA4.GLenum + GL_CMYK_EXT* = 0x800C.GLenum + GL_OPERAND1_ALPHA_EXT* = 0x8599.GLenum + GL_TEXTURE_SHADOW* = 0x82A1.GLenum + GL_LINEAR_CLIPMAP_LINEAR_SGIX* = 0x8170.GLenum + GL_MIPMAP* = 0x8293.GLenum + GL_LINE_SMOOTH_HINT* = 0x0C52.GLenum + GL_DEPTH_STENCIL_TEXTURE_MODE* = 0x90EA.GLenum + GL_BUFFER_ACCESS_OES* = 0x88BB.GLenum + GL_PROXY_TEXTURE_1D_ARRAY_EXT* = 0x8C19.GLenum + GL_OBJECT_LINEAR* = 0x2401.GLenum + GL_MAP1_TEXTURE_COORD_3* = 0x0D95.GLenum + GL_TEXTURE_RENDERBUFFER_NV* = 0x8E55.GLenum + GL_FRAMEBUFFER_RENDERABLE* = 0x8289.GLenum + GL_DOT3_RGB_EXT* = 0x8740.GLenum + GL_QUAD_LUMINANCE8_SGIS* = 0x8121.GLenum + GL_UNIFORM_BLOCK_INDEX* = 0x8A3A.GLenum + GL_DS_SCALE_NV* = 0x8710.GLenum + GL_TYPE* = 0x92FA.GLenum + GL_MATRIX_EXT* = 0x87C0.GLenum + GL_VERTEX_STREAM4_ATI* = 0x8770.GLenum + GL_TOP_LEVEL_ARRAY_STRIDE* = 0x930D.GLenum + GL_INT_SAMPLER_2D_EXT* = 0x8DCA.GLenum + GL_PATH_FORMAT_PS_NV* = 0x9071.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR* = 0x93D2.GLenum + GL_MAX_TEXTURE_COORDS* = 0x8871.GLenum + GL_MAX_FRAGMENT_INTERPOLATION_OFFSET* = 0x8E5C.GLenum + GL_REG_17_ATI* = 0x8932.GLenum + GL_WAIT_FAILED_APPLE* = 0x911D.GLenum + GL_TEXTURE_BINDING_3D* = 0x806A.GLenum + GL_TEXTURE_VIEW* = 0x82B5.GLenum + GL_DOT3_RGBA_ARB* = 0x86AF.GLenum + GL_MAX_VARYING_FLOATS_ARB* = 0x8B4B.GLenum + GL_UNIFORM_IS_ROW_MAJOR* = 0x8A3E.GLenum + GL_FRAGMENT_SHADER_BIT* = 0x00000002.GLbitfield + GL_MATRIX_INDEX_ARRAY_ARB* = 0x8844.GLenum + GL_PIXEL_PACK_BUFFER_BINDING_EXT* = 0x88ED.GLenum + GL_MATRIX_PALETTE_OES* = 0x8840.GLenum + GL_INTENSITY_SNORM* = 0x9013.GLenum + GL_COLOR_BUFFER_BIT0_QCOM* = 0x00000001.GLbitfield + GL_BITMAP* = 0x1A00.GLenum + GL_CURRENT_MATRIX_NV* = 0x8641.GLenum + GL_QUERY_BUFFER_AMD* = 0x9192.GLenum + GL_EDGE_FLAG_ARRAY_BUFFER_BINDING* = 0x889B.GLenum + GL_4PASS_3_EXT* = 0x80A7.GLenum + GL_TEXTURE_4DSIZE_SGIS* = 0x8136.GLenum + GL_PATH_COORD_COUNT_NV* = 0x909E.GLenum + GL_SLUMINANCE* = 0x8C46.GLenum + GL_POINT_SMOOTH_HINT* = 0x0C51.GLenum + GL_ADJACENT_PAIRS_NV* = 0x90AE.GLenum + GL_BUFFER_BINDING* = 0x9302.GLenum + GL_ARRAY_OBJECT_BUFFER_ATI* = 0x8766.GLenum + GL_PATH_INITIAL_DASH_CAP_NV* = 0x907C.GLenum + GL_RGBA4* = 0x8056.GLenum + GL_PACK_LSB_FIRST* = 0x0D01.GLenum + GL_IMAGE_BINDING_NAME_EXT* = 0x8F3A.GLenum + GL_UNSIGNED_INT_SAMPLER_2D_EXT* = 0x8DD2.GLenum + GL_RGBA12_EXT* = 0x805A.GLenum + GL_COMBINER0_NV* = 0x8550.GLenum + GL_COLOR_BUFFER_BIT4_QCOM* = 0x00000010.GLbitfield + GL_TIME_ELAPSED* = 0x88BF.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_START* = 0x8C84.GLenum + GL_COMPRESSED_RGBA_ASTC_5x5_KHR* = 0x93B2.GLenum + GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD* = 0x9199.GLenum + GL_RENDERBUFFER_HEIGHT_EXT* = 0x8D43.GLenum + GL_QUARTER_BIT_ATI* = 0x00000010.GLbitfield + GL_TEXTURE_COMPRESSION_HINT_ARB* = 0x84EF.GLenum + GL_DRAW_BUFFER13* = 0x8832.GLenum + GL_CURRENT_MATRIX_STACK_DEPTH_ARB* = 0x8640.GLenum + GL_DEPENDENT_HILO_TEXTURE_2D_NV* = 0x8858.GLenum + GL_DST_NV* = 0x9287.GLenum + GL_DEBUG_OBJECT_MESA* = 0x8759.GLenum + GL_NUM_INSTRUCTIONS_TOTAL_ATI* = 0x8972.GLenum + GL_FLAT* = 0x1D00.GLenum + GL_EVAL_VERTEX_ATTRIB8_NV* = 0x86CE.GLenum + GL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA* = 0x8BB6.GLenum + GL_TEXTURE_COORD_ARRAY_EXT* = 0x8078.GLenum + GL_LOCATION_INDEX* = 0x930F.GLenum + GL_SLIM10U_SGIX* = 0x831E.GLenum + GL_PHONG_WIN* = 0x80EA.GLenum + GL_EVAL_VERTEX_ATTRIB1_NV* = 0x86C7.GLenum + GL_SMOOTH_LINE_WIDTH_RANGE* = 0x0B22.GLenum + GL_SAMPLER_RENDERBUFFER_NV* = 0x8E56.GLenum + GL_UNPACK_LSB_FIRST* = 0x0CF1.GLenum + GL_SELECTION_BUFFER_POINTER* = 0x0DF3.GLenum + GL_PIXEL_SUBSAMPLE_4444_SGIX* = 0x85A2.GLenum + GL_COMPRESSED_R11_EAC* = 0x9270.GLenum + GL_MAX_CLIP_PLANES* = 0x0D32.GLenum + GL_POST_CONVOLUTION_GREEN_BIAS* = 0x8021.GLenum + GL_COLOR_EXT* = 0x1800.GLenum + GL_VENDOR* = 0x1F00.GLenum + GL_MAP1_VERTEX_ATTRIB8_4_NV* = 0x8668.GLenum + GL_TEXTURE_ALPHA_TYPE* = 0x8C13.GLenum + GL_CURRENT_VERTEX_ATTRIB_ARB* = 0x8626.GLenum + GL_COLOR_BUFFER_BIT2_QCOM* = 0x00000004.GLbitfield + GL_VERTEX_ATTRIB_ARRAY15_NV* = 0x865F.GLenum + GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV* = 0x8850.GLenum + GL_DRAW_BUFFER5_ARB* = 0x882A.GLenum + GL_SAMPLES_PASSED_ARB* = 0x8914.GLenum + GL_PRIMITIVE_RESTART_NV* = 0x8558.GLenum + GL_FRAGMENT_LIGHT3_SGIX* = 0x840F.GLenum + GL_COLOR_INDEX16_EXT* = 0x80E7.GLenum + GL_RGBA8_OES* = 0x8058.GLenum + GL_PACK_CMYK_HINT_EXT* = 0x800E.GLenum + GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE* = 0x8214.GLenum + GL_MODELVIEW0_EXT* = 0x1700.GLenum + GL_RETAINED_APPLE* = 0x8A1B.GLenum + GL_DRAW_PIXELS_APPLE* = 0x8A0A.GLenum + GL_POINT_BIT* = 0x00000002.GLbitfield + GL_PIXEL_MAP_B_TO_B_SIZE* = 0x0CB8.GLenum + GL_RELATIVE_SMALL_CCW_ARC_TO_NV* = 0x13.GLenum + GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB* = 0x8624.GLenum + GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV* = 0x885D.GLenum + GL_CON_2_ATI* = 0x8943.GLenum + GL_SAMPLER_2D_ARRAY* = 0x8DC1.GLenum + GL_LINE_STIPPLE_PATTERN* = 0x0B25.GLenum + GL_IMPLEMENTATION_COLOR_READ_FORMAT* = 0x8B9B.GLenum + GL_TRANSPOSE_AFFINE_2D_NV* = 0x9096.GLenum + GL_COLOR_ATTACHMENT7* = 0x8CE7.GLenum + GL_COLOR_ATTACHMENT14* = 0x8CEE.GLenum + GL_SHADER* = 0x82E1.GLenum + GL_SKIP_MISSING_GLYPH_NV* = 0x90A9.GLenum + GL_VERTEX_ARRAY_TYPE* = 0x807B.GLenum + GL_OP_POWER_EXT* = 0x8793.GLenum + GL_MAX_BINDABLE_UNIFORM_SIZE_EXT* = 0x8DED.GLenum + GL_SRGB8* = 0x8C41.GLenum + GL_INTERNALFORMAT_ALPHA_SIZE* = 0x8274.GLenum + GL_IMAGE_2D_MULTISAMPLE* = 0x9055.GLenum + GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV* = 0x9039.GLenum + GL_NEVER* = 0x0200.GLenum + GL_MAP2_TEXTURE_COORD_2* = 0x0DB4.GLenum + GL_PROGRAM_RESULT_COMPONENTS_NV* = 0x8907.GLenum + GL_SHADER_STORAGE_BARRIER_BIT* = 0x00002000.GLbitfield + GL_SLIM8U_SGIX* = 0x831D.GLenum + GL_DRAW_BUFFER7_ATI* = 0x882C.GLenum + GL_CLAMP_TO_EDGE* = 0x812F.GLint + GL_LUMINANCE32I_EXT* = 0x8D86.GLenum + GL_NORMAL_ARRAY_POINTER* = 0x808F.GLenum + GL_ALPHA_TEST_REF_QCOM* = 0x0BC2.GLenum + GL_MATRIX7_NV* = 0x8637.GLenum + GL_REFERENCED_BY_FRAGMENT_SHADER* = 0x930A.GLenum + GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG* = 0x8C02.GLenum + GL_DEBUG_TYPE_MARKER* = 0x8268.GLenum + GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR* = 0x8242.GLenum + GL_CON_26_ATI* = 0x895B.GLenum + GL_COMBINER7_NV* = 0x8557.GLenum + GL_MAP2_TANGENT_EXT* = 0x8445.GLenum + GL_COMPRESSED_RGBA_ASTC_10x6_KHR* = 0x93B9.GLenum + GL_RG8* = 0x822B.GLenum + GL_INT_SAMPLER_1D_ARRAY_EXT* = 0x8DCE.GLenum + GL_POINT_SPRITE_R_MODE_NV* = 0x8863.GLenum + GL_ATOMIC_COUNTER_BUFFER_BINDING* = 0x92C1.GLenum + GL_INTENSITY16F_ARB* = 0x881D.GLenum + GL_DEFORMATIONS_MASK_SGIX* = 0x8196.GLenum + GL_PATH_TERMINAL_END_CAP_NV* = 0x9078.GLenum + GL_VERTEX_BINDING_DIVISOR* = 0x82D6.GLenum + GL_WIDE_LINE_HINT_PGI* = 0x1A222.GLenum + GL_LIGHTING* = 0x0B50.GLenum + GL_CURRENT_BIT* = 0x00000001.GLbitfield + GL_LOSE_CONTEXT_ON_RESET_ARB* = 0x8252.GLenum + GL_COLOR_ATTACHMENT15* = 0x8CEF.GLenum + GL_REGISTER_COMBINERS_NV* = 0x8522.GLenum + GL_UNSIGNED_INT64_VEC2_NV* = 0x8FF5.GLenum + GL_TEXTURE_CLIPMAP_DEPTH_SGIX* = 0x8176.GLenum + GL_HISTOGRAM_WIDTH* = 0x8026.GLenum + GL_RENDERBUFFER_ALPHA_SIZE* = 0x8D53.GLenum + GL_POST_CONVOLUTION_BLUE_BIAS_EXT* = 0x8022.GLenum + GL_SCALED_RESOLVE_FASTEST_EXT* = 0x90BA.GLenum + GL_DRAW_BUFFER15* = 0x8834.GLenum + GL_LUMINANCE4_ALPHA4* = 0x8043.GLenum + GL_SWIZZLE_STRQ_DQ_ATI* = 0x897B.GLenum + GL_OP_MADD_EXT* = 0x8788.GLenum + GL_MAX_ATTRIB_STACK_DEPTH* = 0x0D35.GLenum + GL_DEBUG_GROUP_STACK_DEPTH_KHR* = 0x826D.GLenum + GL_ACTIVE_VARYINGS_NV* = 0x8C81.GLenum + GL_DEBUG_SEVERITY_HIGH* = 0x9146.GLenum + GL_SRGB8_EXT* = 0x8C41.GLenum + GL_STENCIL_WRITEMASK* = 0x0B98.GLenum + GL_REG_14_ATI* = 0x892F.GLenum + GL_PROGRAM_BINARY_ANGLE* = 0x93A6.GLenum + GL_RENDERBUFFER_DEPTH_SIZE_EXT* = 0x8D54.GLenum + GL_ALPHA_BIAS* = 0x0D1D.GLenum + GL_STATIC_ATI* = 0x8760.GLenum + GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES* = 0x8B9E.GLenum + GL_SOFTLIGHT_NV* = 0x929C.GLenum + GL_INDEX_ARRAY_COUNT_EXT* = 0x8087.GLenum + GL_RENDERBUFFER_BLUE_SIZE_EXT* = 0x8D52.GLenum + GL_SHARED_TEXTURE_PALETTE_EXT* = 0x81FB.GLenum + GL_VERTEX_SHADER_OPTIMIZED_EXT* = 0x87D4.GLenum + GL_MAX_SAMPLE_MASK_WORDS_NV* = 0x8E59.GLenum + GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB* = 0x8841.GLenum + GL_MATRIX30_ARB* = 0x88DE.GLenum + GL_NORMAL_ARRAY_POINTER_EXT* = 0x808F.GLenum + GL_PIXEL_MAP_A_TO_A* = 0x0C79.GLenum + GL_MATRIX18_ARB* = 0x88D2.GLenum + GL_UNPACK_SKIP_ROWS_EXT* = 0x0CF3.GLenum + GL_INVARIANT_DATATYPE_EXT* = 0x87EB.GLenum + GL_INT_IMAGE_1D_EXT* = 0x9057.GLenum + GL_OUTPUT_TEXTURE_COORD24_EXT* = 0x87B5.GLenum + GL_MAP_WRITE_BIT_EXT* = 0x0002.GLbitfield + GL_MODELVIEW28_ARB* = 0x873C.GLenum + GL_MAX_VARYING_COMPONENTS_EXT* = 0x8B4B.GLenum + GL_OUTPUT_TEXTURE_COORD4_EXT* = 0x87A1.GLenum + GL_UNSIGNED_INT_VEC2_EXT* = 0x8DC6.GLenum + GL_READ_ONLY* = 0x88B8.GLenum + GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM* = 103087.GLenum + GL_UNSIGNED_INT64_NV* = 0x140F.GLenum + GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN* = 0x85C2.GLenum + GL_DEPTH_BUFFER_BIT0_QCOM* = 0x00000100.GLbitfield + GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE* = 0x8A06.GLenum + GL_POST_CONVOLUTION_ALPHA_SCALE* = 0x801F.GLenum + GL_TEXTURE_COLOR_SAMPLES_NV* = 0x9046.GLenum + GL_DEBUG_SEVERITY_HIGH_ARB* = 0x9146.GLenum + GL_MAP_WRITE_BIT* = 0x0002.GLbitfield + GL_SRC1_RGB* = 0x8581.GLenum + GL_LIGHT0* = 0x4000.GLenum + GL_READ_PIXELS_FORMAT* = 0x828D.GLenum + GL_COMBINE_RGB_EXT* = 0x8571.GLenum + GL_MATRIX2_NV* = 0x8632.GLenum + GL_INT16_VEC4_NV* = 0x8FE7.GLenum + GL_INT_SAMPLER_CUBE* = 0x8DCC.GLenum + GL_LUMINANCE_ALPHA8I_EXT* = 0x8D93.GLenum + GL_TRIANGLE_STRIP_ADJACENCY* = 0x000D.GLenum + GL_MAX_TEXTURE_BUFFER_SIZE_EXT* = 0x8C2B.GLenum + GL_COLOR_TABLE_BIAS* = 0x80D7.GLenum + GL_MAX_GEOMETRY_INPUT_COMPONENTS* = 0x9123.GLenum + GL_TEXTURE_RANGE_POINTER_APPLE* = 0x85B8.GLenum + GL_PIXEL_SUBSAMPLE_2424_SGIX* = 0x85A3.GLenum + GL_RESAMPLE_REPLICATE_OML* = 0x8986.GLenum + GL_ALL_STATIC_DATA_IBM* = 103060.GLenum + GL_DEBUG_CATEGORY_PERFORMANCE_AMD* = 0x914D.GLenum + GL_ALPHA_TEST_QCOM* = 0x0BC0.GLenum + GL_PREVIOUS_TEXTURE_INPUT_NV* = 0x86E4.GLenum + GL_SIGNED_RGBA_NV* = 0x86FB.GLenum + GL_GLOBAL_ALPHA_SUN* = 0x81D9.GLenum + GL_RGB_FLOAT16_APPLE* = 0x881B.GLenum + GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB* = 0x8808.GLenum + GL_UTF8_NV* = 0x909A.GLenum + GL_ALLOW_DRAW_OBJ_HINT_PGI* = 0x1A20E.GLenum + GL_INT_IMAGE_3D* = 0x9059.GLenum + GL_PACK_ROW_LENGTH* = 0x0D02.GLenum + GL_MAX_TEXTURE_LOD_BIAS_EXT* = 0x84FD.GLenum + GL_SCALED_RESOLVE_NICEST_EXT* = 0x90BB.GLenum + GL_422_EXT* = 0x80CC.GLenum + GL_SAMPLER_1D_ARRAY_SHADOW_EXT* = 0x8DC3.GLenum + GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT* = 0x8336.GLenum + GL_COMPRESSED_RED* = 0x8225.GLenum + GL_MAX_RATIONAL_EVAL_ORDER_NV* = 0x86D7.GLenum + GL_MAX_COMBINED_IMAGE_UNIFORMS* = 0x90CF.GLenum + GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV* = 0x10.GLbitfield + GL_TEXTURE_BINDING_1D_ARRAY* = 0x8C1C.GLenum + GL_FRAMEBUFFER_COMPLETE* = 0x8CD5.GLenum + GL_RG8I* = 0x8237.GLenum + GL_COLOR_ATTACHMENT2_NV* = 0x8CE2.GLenum + GL_INT64_VEC4_NV* = 0x8FEB.GLenum + GL_OP_SET_GE_EXT* = 0x878C.GLenum + GL_READ_WRITE* = 0x88BA.GLenum + GL_OPERAND1_RGB_EXT* = 0x8591.GLenum + GL_SHADER_STORAGE_BLOCK* = 0x92E6.GLenum + GL_TEXTURE_UPDATE_BARRIER_BIT* = 0x00000100.GLbitfield + GL_MAX_FRAGMENT_ATOMIC_COUNTERS* = 0x92D6.GLenum + GL_SHADER_INCLUDE_ARB* = 0x8DAE.GLenum + GL_UNSIGNED_SHORT_1_5_5_5_REV* = 0x8366.GLenum + GL_PROGRAM_PIPELINE* = 0x82E4.GLenum + GL_MAP1_TEXTURE_COORD_2* = 0x0D94.GLenum + GL_FOG_COORDINATE_ARRAY_STRIDE_EXT* = 0x8455.GLenum + GL_WEIGHT_ARRAY_SIZE_OES* = 0x86AB.GLenum + GL_R11F_G11F_B10F* = 0x8C3A.GLenum + GL_WRITE_PIXEL_DATA_RANGE_NV* = 0x8878.GLenum + GL_UNSIGNED_SHORT_8_8_REV_APPLE* = 0x85BB.GLenum + GL_CND_ATI* = 0x896A.GLenum + GL_IMAGE_2D_MULTISAMPLE_ARRAY* = 0x9056.GLenum + GL_MAX_TEXTURE_IMAGE_UNITS_NV* = 0x8872.GLenum + GL_COMPRESSED_SIGNED_RG11_EAC_OES* = 0x9273.GLenum + GL_DOT_PRODUCT_TEXTURE_3D_NV* = 0x86EF.GLenum + GL_IMAGE_TRANSLATE_Y_HP* = 0x8158.GLenum + GL_NORMAL_ARRAY_TYPE_EXT* = 0x807E.GLenum + GL_PIXEL_COUNT_NV* = 0x8866.GLenum + GL_INT_IMAGE_3D_EXT* = 0x9059.GLenum + GL_TEXTURE_TYPE_QCOM* = 0x8BD7.GLenum + GL_COMBINE_ALPHA_EXT* = 0x8572.GLenum + GL_POINT_TOKEN* = 0x0701.GLenum + GL_QUAD_ALPHA4_SGIS* = 0x811E.GLenum + GL_SIGNED_HILO8_NV* = 0x885F.GLenum + GL_MULTISAMPLE_ARB* = 0x809D.GLenum + GL_TEXTURE25* = 0x84D9.GLenum + GL_CURRENT_VERTEX_WEIGHT_EXT* = 0x850B.GLenum + GL_BLEND_DST_ALPHA_OES* = 0x80CA.GLenum + GL_UNSIGNED_SHORT_8_8_REV_MESA* = 0x85BB.GLenum + GL_CLAMP_TO_EDGE_SGIS* = 0x812F.GLint + GL_PATH_STENCIL_REF_NV* = 0x90B8.GLenum + GL_DEBUG_OUTPUT* = 0x92E0.GLenum + GL_OBJECT_TYPE_APPLE* = 0x9112.GLenum + GL_TEXTURE_COMPARE_MODE_ARB* = 0x884C.GLenum + GL_CONSTANT* = 0x8576.GLenum + GL_RGB5_A1_OES* = 0x8057.GLenum + GL_INT16_VEC2_NV* = 0x8FE5.GLenum + GL_CONVOLUTION_BORDER_MODE_EXT* = 0x8013.GLenum + GL_CONTEXT_FLAGS* = 0x821E.GLenum + GL_MAX_PROGRAM_SUBROUTINE_NUM_NV* = 0x8F45.GLenum + GL_SPRITE_SGIX* = 0x8148.GLenum + GL_CURRENT_QUERY* = 0x8865.GLenum + GL_STENCIL_OP_VALUE_AMD* = 0x874C.GLenum + GL_UNIFORM* = 0x92E1.GLenum + GL_TEXTURE_BINDING_RECTANGLE* = 0x84F6.GLenum + GL_TRIANGLES_ADJACENCY_EXT* = 0x000C.GLenum + GL_PROVOKING_VERTEX_EXT* = 0x8E4F.GLenum + GL_INT64_VEC2_NV* = 0x8FE9.GLenum + GL_INVERSE_NV* = 0x862B.GLenum + GL_CON_29_ATI* = 0x895E.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV* = 0x8E24.GLenum + GL_FRONT_AND_BACK* = 0x0408.GLenum + GL_MAX_LABEL_LENGTH_KHR* = 0x82E8.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_START_NV* = 0x8C84.GLenum + GL_EQUAL* = 0x0202.GLenum + GL_RGB10_EXT* = 0x8052.GLenum + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB* = 0x8C29.GLenum + GL_OP_ADD_EXT* = 0x8787.GLenum + GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN* = 0x85C3.GLenum + GL_NORMAL_ARRAY_LIST_IBM* = 103071.GLenum + GL_RENDERBUFFER_GREEN_SIZE* = 0x8D51.GLenum + GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV* = 0x8C74.GLenum + GL_CURRENT_PALETTE_MATRIX_ARB* = 0x8843.GLenum + GL_DEBUG_TYPE_ERROR* = 0x824C.GLenum + GL_UNIFORM_BUFFER* = 0x8A11.GLenum + GL_NEAREST_CLIPMAP_LINEAR_SGIX* = 0x844E.GLenum + GL_LAST_VERTEX_CONVENTION* = 0x8E4E.GLenum + GL_COMPRESSED_RGBA_ASTC_12x10_KHR* = 0x93BC.GLenum + GL_FENCE_STATUS_NV* = 0x84F3.GLenum + GL_POST_CONVOLUTION_BLUE_BIAS* = 0x8022.GLenum + GL_BLEND_OVERLAP_NV* = 0x9281.GLenum + GL_COMBINE_RGB_ARB* = 0x8571.GLenum + GL_TESS_GEN_MODE* = 0x8E76.GLenum + GL_TEXTURE_ENV* = 0x2300.GLenum + GL_VERTEX_ATTRIB_ARRAY11_NV* = 0x865B.GLenum + GL_SHININESS* = 0x1601.GLenum + GL_DYNAMIC_STORAGE_BIT* = 0x0100.GLbitfield + GL_MODELVIEW30_ARB* = 0x873E.GLenum + GL_WRAP_BORDER_SUN* = 0x81D4.GLenum + GL_SKIP_COMPONENTS1_NV* = -6 + GL_DEPTH_CLAMP_NV* = 0x864F.GLenum + GL_PROGRAM_BINARY_FORMATS* = 0x87FF.GLenum + GL_CURRENT_RASTER_POSITION_VALID* = 0x0B08.GLenum + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER* = 0x92C8.GLenum + GL_T2F_C4F_N3F_V3F* = 0x2A2C.GLenum + GL_R16F* = 0x822D.GLenum + GL_SECONDARY_COLOR_ARRAY_LENGTH_NV* = 0x8F31.GLenum + GL_SEPARATE_ATTRIBS_EXT* = 0x8C8D.GLenum + GL_NEGATIVE_Z_EXT* = 0x87DB.GLenum + GL_Z400_BINARY_AMD* = 0x8740.GLenum + GL_DRAW_INDIRECT_UNIFIED_NV* = 0x8F40.GLenum + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV* = 0x8C8A.GLenum + GL_UNSIGNED_INT_S8_S8_8_8_NV* = 0x86DA.GLenum + GL_SRGB8_NV* = 0x8C41.GLenum + GL_DEBUG_SEVERITY_MEDIUM_AMD* = 0x9147.GLenum + GL_MAX_DRAW_BUFFERS_ATI* = 0x8824.GLenum + GL_TEXTURE_COORD_ARRAY_POINTER_EXT* = 0x8092.GLenum + GL_RESAMPLE_AVERAGE_OML* = 0x8988.GLenum + GL_NO_ERROR* = 0.GLenum + GL_RGB5* = 0x8050.GLenum + GL_OP_CLAMP_EXT* = 0x878E.GLenum + GL_PROGRAM_RESIDENT_NV* = 0x8647.GLenum + GL_PROGRAM_ALU_INSTRUCTIONS_ARB* = 0x8805.GLenum + GL_ELEMENT_ARRAY_UNIFIED_NV* = 0x8F1F.GLenum + GL_SECONDARY_COLOR_ARRAY_LIST_IBM* = 103077.GLenum + GL_INTENSITY12_EXT* = 0x804C.GLenum + GL_STENCIL_BUFFER_BIT7_QCOM* = 0x00800000.GLbitfield + GL_SAMPLER* = 0x82E6.GLenum + GL_MAD_ATI* = 0x8968.GLenum + GL_STENCIL_BACK_FAIL* = 0x8801.GLenum + GL_LIGHT_MODEL_TWO_SIDE* = 0x0B52.GLenum + GL_UNPACK_SKIP_PIXELS* = 0x0CF4.GLenum + GL_PIXEL_TEX_GEN_SGIX* = 0x8139.GLenum + GL_FRACTIONAL_ODD* = 0x8E7B.GLenum + GL_LOW_INT* = 0x8DF3.GLenum + GL_MODELVIEW* = 0x1700.GLenum + GL_POST_CONVOLUTION_RED_SCALE_EXT* = 0x801C.GLenum + GL_DRAW_BUFFER11_EXT* = 0x8830.GLenum + GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH* = 0x8A35.GLenum + GL_CONVOLUTION_BORDER_MODE* = 0x8013.GLenum + GL_COMPRESSED_ALPHA_ARB* = 0x84E9.GLenum + GL_DEPTH_ATTACHMENT* = 0x8D00.GLenum + GL_ALPHA8_SNORM* = 0x9014.GLenum + GL_DOUBLE_MAT4x3_EXT* = 0x8F4E.GLenum + GL_INTERNALFORMAT_STENCIL_SIZE* = 0x8276.GLenum + GL_BOOL_VEC2_ARB* = 0x8B57.GLenum + GL_FASTEST* = 0x1101.GLenum + GL_MAX_FRAGMENT_INPUT_COMPONENTS* = 0x9125.GLenum + GL_STENCIL_BACK_FUNC_ATI* = 0x8800.GLenum + GL_POLYGON* = 0x0009.GLenum + GL_SAMPLER_1D_ARRAY_EXT* = 0x8DC0.GLenum + GL_OUTPUT_COLOR1_EXT* = 0x879C.GLenum + GL_IMAGE_2D_RECT* = 0x904F.GLenum + GL_RECT_NV* = 0xF6.GLenum + GL_OUTPUT_TEXTURE_COORD21_EXT* = 0x87B2.GLenum + GL_NOR* = 0x1508.GLenum + GL_FOG_COORD_ARRAY* = 0x8457.GLenum + GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES* = 0x8517.GLenum + GL_TANGENT_ARRAY_POINTER_EXT* = 0x8442.GLenum + GL_DST_OUT_NV* = 0x928D.GLenum + GL_RENDERBUFFER_BINDING_OES* = 0x8CA7.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR* = 0x93D3.GLenum + GL_TEXTURE_GEN_S* = 0x0C60.GLenum + GL_SLIM12S_SGIX* = 0x831F.GLenum + GL_VERTEX_ARRAY_BINDING* = 0x85B5.GLenum + GL_TRACE_PRIMITIVES_BIT_MESA* = 0x0002.GLbitfield + GL_MAX_DEBUG_MESSAGE_LENGTH* = 0x9143.GLenum + GL_EVAL_VERTEX_ATTRIB4_NV* = 0x86CA.GLenum + GL_ACTIVE_SUBROUTINE_UNIFORMS* = 0x8DE6.GLenum + GL_ACCUM_ADJACENT_PAIRS_NV* = 0x90AD.GLenum + GL_NEGATIVE_ONE_EXT* = 0x87DF.GLenum + GL_UNPACK_RESAMPLE_SGIX* = 0x842D.GLenum + GL_ACTIVE_SUBROUTINE_MAX_LENGTH* = 0x8E48.GLenum + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT* = 0x8518.GLenum + GL_DEBUG_CATEGORY_API_ERROR_AMD* = 0x9149.GLenum + GL_INTERNALFORMAT_BLUE_SIZE* = 0x8273.GLenum + GL_DRAW_BUFFER13_NV* = 0x8832.GLenum + GL_DEBUG_SOURCE_THIRD_PARTY_ARB* = 0x8249.GLenum + GL_R8_EXT* = 0x8229.GLenum + GL_GENERATE_MIPMAP* = 0x8191.GLenum + cGL_SHORT* = 0x1402.GLenum + GL_PACK_REVERSE_ROW_ORDER_ANGLE* = 0x93A4.GLenum + GL_PATH_DASH_OFFSET_RESET_NV* = 0x90B4.GLenum + GL_PACK_SKIP_VOLUMES_SGIS* = 0x8130.GLenum + GL_TEXTURE_RED_TYPE* = 0x8C10.GLenum + GL_MAX_COLOR_ATTACHMENTS_EXT* = 0x8CDF.GLenum + GL_MAP2_VERTEX_ATTRIB5_4_NV* = 0x8675.GLenum + GL_CONSTANT_ALPHA* = 0x8003.GLenum + GL_COLOR_INDEX8_EXT* = 0x80E5.GLenum + GL_DOUBLE_MAT3_EXT* = 0x8F47.GLenum + GL_ATOMIC_COUNTER_BUFFER_INDEX* = 0x9301.GLenum + GL_LINES_ADJACENCY_EXT* = 0x000A.GLenum + GL_RENDERBUFFER_SAMPLES_IMG* = 0x9133.GLenum + GL_COLOR_TABLE_FORMAT* = 0x80D8.GLenum + GL_VERTEX_ATTRIB_ARRAY_TYPE* = 0x8625.GLenum + GL_QUERY_OBJECT_EXT* = 0x9153.GLenum + GL_STREAM_READ_ARB* = 0x88E1.GLenum + GL_MIRROR_CLAMP_TO_EDGE_ATI* = 0x8743.GLint + GL_FRAGMENT_SUBROUTINE_UNIFORM* = 0x92F2.GLenum + GL_UNIFORM_BUFFER_EXT* = 0x8DEE.GLenum + GL_SOURCE2_RGB* = 0x8582.GLenum + GL_PROGRAM_NATIVE_ATTRIBS_ARB* = 0x88AE.GLenum + GL_LUMINANCE12_ALPHA12* = 0x8047.GLenum + GL_INT_SAMPLER_1D_EXT* = 0x8DC9.GLenum + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT* = 0x8D6C.GLenum + GL_DEPTH_RENDERABLE* = 0x8287.GLenum + GL_INTERNALFORMAT_BLUE_TYPE* = 0x827A.GLenum + GL_SLUMINANCE8_ALPHA8_EXT* = 0x8C45.GLenum + GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB* = 0x900A.GLenum + GL_COLOR_MATRIX* = 0x80B1.GLenum + GL_RGB8_SNORM* = 0x8F96.GLenum + GL_COLOR_ARRAY_SIZE* = 0x8081.GLenum + GL_DRAW_BUFFER4_NV* = 0x8829.GLenum + GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV* = 0x902D.GLenum + GL_PRESENT_TIME_NV* = 0x8E2A.GLenum + GL_COPY_WRITE_BUFFER* = 0x8F37.GLenum + GL_UNPACK_SKIP_PIXELS_EXT* = 0x0CF4.GLenum + GL_PRIMITIVES_GENERATED_NV* = 0x8C87.GLenum + GL_INT_SAMPLER_BUFFER* = 0x8DD0.GLenum + GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV* = 0x04.GLbitfield + GL_FOG_COORDINATE_EXT* = 0x8451.GLenum + GL_VERTEX_ARRAY_ADDRESS_NV* = 0x8F21.GLenum + GL_RENDERBUFFER_RED_SIZE_OES* = 0x8D50.GLenum + GL_BGR_INTEGER_EXT* = 0x8D9A.GLenum + GL_UNSIGNED_BYTE_3_3_2* = 0x8032.GLenum + GL_VBO_FREE_MEMORY_ATI* = 0x87FB.GLenum + GL_PATH_COMPUTED_LENGTH_NV* = 0x90A0.GLenum + GL_COLOR_MATRIX_STACK_DEPTH_SGI* = 0x80B2.GLenum + GL_STACK_OVERFLOW* = 0x0503.GLenum + GL_MODELVIEW1_MATRIX_EXT* = 0x8506.GLenum + GL_CURRENT_BINORMAL_EXT* = 0x843C.GLenum + GL_OP_MULTIPLY_MATRIX_EXT* = 0x8798.GLenum + GL_CLIENT_ATTRIB_STACK_DEPTH* = 0x0BB1.GLenum + GL_VERTEX_PROGRAM_TWO_SIDE_NV* = 0x8643.GLenum + GL_HISTOGRAM_WIDTH_EXT* = 0x8026.GLenum + GL_OBJECT_INFO_LOG_LENGTH_ARB* = 0x8B84.GLenum + GL_SAMPLER_2D_ARRAY_SHADOW* = 0x8DC4.GLenum + GL_UNSIGNED_INT_IMAGE_1D* = 0x9062.GLenum + GL_MAX_IMAGE_UNITS* = 0x8F38.GLenum + GL_TEXTURE31_ARB* = 0x84DF.GLenum + GL_CUBIC_HP* = 0x815F.GLenum + GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV* = 0x8856.GLenum + GL_ARRAY_STRIDE* = 0x92FE.GLenum + GL_DEPTH_PASS_INSTRUMENT_SGIX* = 0x8310.GLenum + GL_COMMAND_BARRIER_BIT* = 0x00000040.GLbitfield + GL_STATIC_DRAW_ARB* = 0x88E4.GLenum + GL_RGB16F* = 0x881B.GLenum + GL_INDEX_MATERIAL_PARAMETER_EXT* = 0x81B9.GLenum + GL_UNPACK_SKIP_VOLUMES_SGIS* = 0x8132.GLenum + GL_TEXTURE_1D* = 0x0DE0.GLenum + GL_VERTEX_PROGRAM_NV* = 0x8620.GLenum + GL_COLOR_ATTACHMENT0_NV* = 0x8CE0.GLenum + GL_READ_PIXEL_DATA_RANGE_LENGTH_NV* = 0x887B.GLenum + GL_FLOAT_32_UNSIGNED_INT_24_8_REV* = 0x8DAD.GLenum + GL_LINE_RESET_TOKEN* = 0x0707.GLenum + GL_WEIGHT_ARRAY_ARB* = 0x86AD.GLenum + GL_TEXTURE17* = 0x84D1.GLenum + GL_DEPTH_COMPONENT32_ARB* = 0x81A7.GLenum + GL_REFERENCED_BY_TESS_CONTROL_SHADER* = 0x9307.GLenum + GL_INVERT* = 0x150A.GLenum + GL_FOG_COORDINATE_ARRAY_STRIDE* = 0x8455.GLenum + GL_COMPRESSED_SIGNED_RG_RGTC2* = 0x8DBE.GLenum + GL_UNSIGNED_SHORT_8_8_MESA* = 0x85BA.GLenum + GL_ELEMENT_ARRAY_TYPE_ATI* = 0x8769.GLenum + GL_CLAMP_VERTEX_COLOR_ARB* = 0x891A.GLenum + GL_POINT_SIZE_ARRAY_STRIDE_OES* = 0x898B.GLenum + GL_RGB8* = 0x8051.GLenum + GL_MATRIX1_ARB* = 0x88C1.GLenum + GL_TEXTURE_POST_SPECULAR_HP* = 0x8168.GLenum + GL_TEXTURE_WRAP_Q_SGIS* = 0x8137.GLenum + GL_SAMPLER_2D_MULTISAMPLE_ARRAY* = 0x910B.GLenum + GL_INVALID_FRAMEBUFFER_OPERATION_OES* = 0x0506.GLenum + GL_VERTEX_ID_SWIZZLE_AMD* = 0x91A5.GLenum + GL_USE_MISSING_GLYPH_NV* = 0x90AA.GLenum + GL_LUMINANCE8_EXT* = 0x8040.GLenum + GL_INT_VEC2* = 0x8B53.GLenum + GL_TEXTURE9* = 0x84C9.GLenum + GL_RGB32UI_EXT* = 0x8D71.GLenum + GL_FENCE_CONDITION_NV* = 0x84F4.GLenum + GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT* = 0x8E4C.GLenum + GL_HSL_SATURATION_NV* = 0x92AE.GLenum + GL_CMYKA_EXT* = 0x800D.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_NV* = 0x8C8E.GLenum + GL_BUFFER_MAP_POINTER_OES* = 0x88BD.GLenum + GL_STORAGE_CLIENT_APPLE* = 0x85B4.GLenum + GL_VERTEX_ARRAY_BUFFER_BINDING_ARB* = 0x8896.GLenum + GL_TEXTURE_INTERNAL_FORMAT* = 0x1003.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED* = 0x8E23.GLenum + GL_UNSIGNED_INT_VEC3* = 0x8DC7.GLenum + GL_TRACE_MASK_MESA* = 0x8755.GLenum + GL_MAP_READ_BIT_EXT* = 0x0001.GLbitfield + GL_READ_FRAMEBUFFER_EXT* = 0x8CA8.GLenum + GL_HISTOGRAM_GREEN_SIZE* = 0x8029.GLenum + GL_COLOR_TABLE_INTENSITY_SIZE_SGI* = 0x80DF.GLenum + GL_SMALL_CCW_ARC_TO_NV* = 0x12.GLenum + GL_RELATIVE_LARGE_CW_ARC_TO_NV* = 0x19.GLenum + GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI* = 0x80BA.GLenum + GL_SCISSOR_BIT* = 0x00080000.GLbitfield + GL_DRAW_BUFFER0_ATI* = 0x8825.GLenum + GL_GEOMETRY_SHADER_BIT* = 0x00000004.GLbitfield + GL_CLIP_FAR_HINT_PGI* = 0x1A221.GLenum + GL_TEXTURE_COMPARE_FUNC_EXT* = 0x884D.GLenum + GL_IS_ROW_MAJOR* = 0x9300.GLenum + GL_MAP1_VERTEX_4* = 0x0D98.GLenum + GL_OUTPUT_TEXTURE_COORD8_EXT* = 0x87A5.GLenum + GL_MAX_VERTEX_IMAGE_UNIFORMS* = 0x90CA.GLenum + GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE* = 0x8211.GLenum + GL_SOURCE1_ALPHA_ARB* = 0x8589.GLenum + GL_VIRTUAL_PAGE_SIZE_X_AMD* = 0x9195.GLenum + GL_CULL_FRAGMENT_NV* = 0x86E7.GLenum + GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS* = 0x92DC.GLenum + GL_QUERY_COUNTER_BITS_EXT* = 0x8864.GLenum + GL_RGB565* = 0x8D62.GLenum + GL_OFFSET_TEXTURE_RECTANGLE_NV* = 0x864C.GLenum + GL_CONVOLUTION_FORMAT_EXT* = 0x8017.GLenum + GL_EYE_POINT_SGIS* = 0x81F4.GLenum + GL_ALPHA32F_ARB* = 0x8816.GLenum + GL_TEXTURE_DEPTH_SIZE* = 0x884A.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR* = 0x93D1.GLenum + GL_PRIMARY_COLOR_NV* = 0x852C.GLenum + GL_BLEND_DST_ALPHA_EXT* = 0x80CA.GLenum + GL_NORMALIZE* = 0x0BA1.GLenum + GL_POST_CONVOLUTION_GREEN_BIAS_EXT* = 0x8021.GLenum + GL_HI_SCALE_NV* = 0x870E.GLenum + GL_TESS_EVALUATION_PROGRAM_NV* = 0x891F.GLenum + GL_MAX_DUAL_SOURCE_DRAW_BUFFERS* = 0x88FC.GLenum + GL_SWIZZLE_STRQ_ATI* = 0x897A.GLenum + GL_READ_FRAMEBUFFER_NV* = 0x8CA8.GLenum + GL_MATRIX_INDEX_ARRAY_STRIDE_OES* = 0x8848.GLenum + GL_MIN_SPARSE_LEVEL_ARB* = 0x919B.GLenum + GL_RG32UI* = 0x823C.GLenum + GL_SAMPLER_2D_ARRAY_EXT* = 0x8DC1.GLenum + GL_TEXTURE22_ARB* = 0x84D6.GLenum + GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS* = 0x8A32.GLenum + GL_CULL_VERTEX_EYE_POSITION_EXT* = 0x81AB.GLenum + GL_TEXTURE_BUFFER* = 0x8C2A.GLenum + GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB* = 0x851C.GLenum + GL_NORMAL_ARRAY_COUNT_EXT* = 0x8080.GLenum + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV* = 0x8D56.GLenum + GL_ELEMENT_ARRAY_BARRIER_BIT_EXT* = 0x00000002.GLbitfield + GL_VERTEX_ARRAY_COUNT_EXT* = 0x807D.GLenum + GL_PROGRAM_ERROR_STRING_NV* = 0x8874.GLenum + GL_INVALID_FRAMEBUFFER_OPERATION* = 0x0506.GLenum + GL_RGB9_E5* = 0x8C3D.GLenum + GL_GREEN_BITS* = 0x0D53.GLenum + GL_CLIP_DISTANCE0* = 0x3000.GLenum + GL_COMBINER_SUM_OUTPUT_NV* = 0x854C.GLenum + GL_COLOR_ARRAY* = 0x8076.GLenum + GL_RGBA8_SNORM* = 0x8F97.GLenum + GL_PROGRAM_BINDING_ARB* = 0x8677.GLenum + GL_4PASS_0_EXT* = 0x80A4.GLenum + GL_STATIC_DRAW* = 0x88E4.GLenum + GL_TEXTURE_COMPRESSED_BLOCK_WIDTH* = 0x82B1.GLenum + GL_TEXTURE_STORAGE_SPARSE_BIT_AMD* = 0x00000001.GLbitfield + GL_MEDIUM_INT* = 0x8DF4.GLenum + GL_TEXTURE13_ARB* = 0x84CD.GLenum + GL_LUMINANCE_ALPHA16F_ARB* = 0x881F.GLenum + GL_CONTEXT_CORE_PROFILE_BIT* = 0x00000001.GLbitfield + GL_LOCATION_COMPONENT* = 0x934A.GLenum + GL_TEXTURE_RECTANGLE* = 0x84F5.GLenum + GL_SAMPLER_2D_ARB* = 0x8B5E.GLenum + GL_FLOAT_RG32_NV* = 0x8887.GLenum + GL_SKIP_DECODE_EXT* = 0x8A4A.GLenum + GL_LIGHT6* = 0x4006.GLenum + GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD* = 0x87EE.GLenum + GL_NOOP* = 0x1505.GLenum + GL_DEPTH_BUFFER_BIT* = 0x00000100.GLbitfield + GL_FRAMEBUFFER_BINDING_ANGLE* = 0x8CA6.GLenum + GL_DEBUG_TYPE_POP_GROUP_KHR* = 0x826A.GLenum + GL_SAMPLER_2D_RECT_SHADOW* = 0x8B64.GLenum + GL_CONSERVE_MEMORY_HINT_PGI* = 0x1A1FD.GLenum + GL_QUERY_BY_REGION_NO_WAIT* = 0x8E16.GLenum + GL_UNSIGNED_INT_SAMPLER_CUBE* = 0x8DD4.GLenum + GL_LUMINANCE4_EXT* = 0x803F.GLenum + GL_COLOR_ARRAY_STRIDE* = 0x8083.GLenum + GL_SAMPLER_2D_ARRAY_SHADOW_NV* = 0x8DC4.GLenum + GL_REFERENCED_BY_GEOMETRY_SHADER* = 0x9309.GLenum + GL_SIGNED_RGB_UNSIGNED_ALPHA_NV* = 0x870C.GLenum + GL_OBJECT_PLANE* = 0x2501.GLenum + GL_Q* = 0x2003.GLenum + GL_MAX_SPOT_EXPONENT_NV* = 0x8505.GLenum + GL_VERTEX_ATTRIB_ARRAY_LONG* = 0x874E.GLenum + GL_COLOR_ATTACHMENT3* = 0x8CE3.GLenum + GL_TEXTURE_BINDING_RENDERBUFFER_NV* = 0x8E53.GLenum + GL_EXCLUSION_NV* = 0x92A0.GLenum + GL_EDGE_FLAG_ARRAY_ADDRESS_NV* = 0x8F26.GLenum + GL_PRIMARY_COLOR_ARB* = 0x8577.GLenum + GL_LUMINANCE_ALPHA_FLOAT16_ATI* = 0x881F.GLenum + GL_TRACE_TEXTURES_BIT_MESA* = 0x0008.GLbitfield + GL_FRAMEBUFFER_OES* = 0x8D40.GLenum + GL_PIXEL_MAG_FILTER_EXT* = 0x8331.GLenum + GL_IMAGE_BINDING_LAYERED_EXT* = 0x8F3C.GLenum + GL_PATH_MITER_LIMIT_NV* = 0x907A.GLenum + GL_PROJECTION_MATRIX* = 0x0BA7.GLenum + GL_TEXTURE23_ARB* = 0x84D7.GLenum + GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE* = 0x8A07.GLenum + GL_RGB32F_ARB* = 0x8815.GLenum + GL_RED_SCALE* = 0x0D14.GLenum + GL_GEOMETRY_INPUT_TYPE_ARB* = 0x8DDB.GLenum + GL_EVAL_VERTEX_ATTRIB13_NV* = 0x86D3.GLenum + GL_INT64_NV* = 0x140E.GLenum + GL_VIEW_CLASS_24_BITS* = 0x82C9.GLenum + GL_FRAGMENT_LIGHT2_SGIX* = 0x840E.GLenum + GL_LUMINANCE12_ALPHA12_EXT* = 0x8047.GLenum + GL_MAP2_VERTEX_ATTRIB2_4_NV* = 0x8672.GLenum + GL_POINT_SIZE_MIN_SGIS* = 0x8126.GLenum + GL_DEBUG_TYPE_OTHER_ARB* = 0x8251.GLenum + GL_MAP2_VERTEX_ATTRIB0_4_NV* = 0x8670.GLenum + GL_DEBUG_PRINT_MESA* = 0x875A.GLenum + GL_TEXTURE_PRIORITY* = 0x8066.GLenum + GL_PIXEL_MAP_I_TO_G* = 0x0C73.GLenum + GL_VERTEX_ATTRIB_ARRAY_DIVISOR* = 0x88FE.GLenum + GL_TEXTURE_CUBE_MAP_ARB* = 0x8513.GLenum + GL_LUMINANCE8_SNORM* = 0x9015.GLenum + GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT* = 0x00004000.GLbitfield + GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS* = 0x8E1F.GLenum + GL_BUFFER_STORAGE_FLAGS* = 0x8220.GLenum + GL_DEPTH_COMPONENT24_SGIX* = 0x81A6.GLenum + GL_UNIFORM_OFFSET* = 0x8A3B.GLenum + GL_TEXTURE_DT_SIZE_NV* = 0x871E.GLenum + GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI* = 0x80B7.GLenum + GL_DEPTH32F_STENCIL8_NV* = 0x8DAC.GLenum + GL_STENCIL_FUNC* = 0x0B92.GLenum + GL_NEAREST_MIPMAP_LINEAR* = 0x2702.GLint + GL_COMPRESSED_LUMINANCE_LATC1_EXT* = 0x8C70.GLenum + GL_TEXTURE_BORDER* = 0x1005.GLenum + GL_COLOR_ATTACHMENT14_NV* = 0x8CEE.GLenum + GL_TEXTURE_STORAGE_HINT_APPLE* = 0x85BC.GLenum + GL_VERTEX_ARRAY_RANGE_NV* = 0x851D.GLenum + GL_COLOR_ARRAY_SIZE_EXT* = 0x8081.GLenum + GL_INTERNALFORMAT_SUPPORTED* = 0x826F.GLenum + GL_MULTISAMPLE_BIT_ARB* = 0x20000000.GLbitfield + GL_RGB* = 0x1907.GLenum + GL_TRANSFORM_FEEDBACK_PAUSED* = 0x8E23.GLenum + GL_ALPHA8* = 0x803C.GLenum + GL_STENCIL_FAIL* = 0x0B94.GLenum + GL_PACK_SKIP_IMAGES_EXT* = 0x806B.GLenum + GL_FOG_COORDINATE_ARRAY_TYPE_EXT* = 0x8454.GLenum + GL_RESCALE_NORMAL_EXT* = 0x803A.GLenum + GL_LERP_ATI* = 0x8969.GLenum + GL_MATRIX_INDEX_ARRAY_STRIDE_ARB* = 0x8848.GLenum + GL_PROGRAM_LENGTH_NV* = 0x8627.GLenum + GL_UNSIGNED_INT_SAMPLER_3D_EXT* = 0x8DD3.GLenum + GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT* = 0x8DBE.GLenum + GL_UNSIGNED_INT_24_8_NV* = 0x84FA.GLenum + GL_POINT_SIZE_MIN_ARB* = 0x8126.GLenum + GL_COMP_BIT_ATI* = 0x00000002.GLbitfield + GL_NORMAL_ARRAY_ADDRESS_NV* = 0x8F22.GLenum + GL_TEXTURE9_ARB* = 0x84C9.GLenum + GL_MAX_GEOMETRY_OUTPUT_COMPONENTS* = 0x9124.GLenum + GL_DOUBLEBUFFER* = 0x0C32.GLenum + GL_OFFSET_TEXTURE_2D_BIAS_NV* = 0x86E3.GLenum + GL_ACTIVE_PROGRAM_EXT* = 0x8B8D.GLenum + GL_PARTIAL_SUCCESS_NV* = 0x902E.GLenum + GL_SUBTRACT* = 0x84E7.GLenum + GL_DUAL_INTENSITY4_SGIS* = 0x8118.GLenum + GL_FILL* = 0x1B02.GLenum + GL_COMPRESSED_SRGB_ALPHA* = 0x8C49.GLenum + GL_RENDERBUFFER_OES* = 0x8D41.GLenum + GL_PIXEL_MAP_R_TO_R_SIZE* = 0x0CB6.GLenum + GL_TEXTURE_LUMINANCE_TYPE_ARB* = 0x8C14.GLenum + GL_TEXTURE_BUFFER_FORMAT_EXT* = 0x8C2E.GLenum + GL_OUTPUT_TEXTURE_COORD13_EXT* = 0x87AA.GLenum + GL_LINES_ADJACENCY_ARB* = 0x000A.GLenum + GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV* = 0x8F44.GLenum + GL_INTENSITY32UI_EXT* = 0x8D73.GLenum + GL_PACK_IMAGE_HEIGHT* = 0x806C.GLenum + GL_HI_BIAS_NV* = 0x8714.GLenum + GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB* = 0x824E.GLenum + GL_LINE_STIPPLE* = 0x0B24.GLenum + GL_INDEX_LOGIC_OP* = 0x0BF1.GLenum + GL_CON_18_ATI* = 0x8953.GLenum + GL_QUERY_RESULT* = 0x8866.GLenum + GL_FRAGMENT_PROGRAM_NV* = 0x8870.GLenum + GL_MATRIX1_NV* = 0x8631.GLenum + GL_FUNC_SUBTRACT_OES* = 0x800A.GLenum + GL_PIXEL_MAP_I_TO_A_SIZE* = 0x0CB5.GLenum + GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT* = 0x8365.GLenum + GL_OUTPUT_TEXTURE_COORD20_EXT* = 0x87B1.GLenum + GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT* = 0x00000001.GLbitfield + GL_TRIANGULAR_NV* = 0x90A5.GLenum + GL_TEXTURE_COMPARE_MODE_EXT* = 0x884C.GLenum + GL_SECONDARY_COLOR_ARRAY_SIZE_EXT* = 0x845A.GLenum + GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT* = 0x8DA7.GLenum + GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE* = 0x83F3.GLenum + GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB* = 0x9345.GLenum + GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB* = 0x889A.GLenum + GL_PROGRAM_FORMAT_ARB* = 0x8876.GLenum + GL_QUAD_INTENSITY4_SGIS* = 0x8122.GLenum + GL_REPLICATE_BORDER* = 0x8153.GLenum + GL_PN_TRIANGLES_ATI* = 0x87F0.GLenum + GL_DEPTH_TEXTURE_MODE* = 0x884B.GLenum + GL_VARIABLE_C_NV* = 0x8525.GLenum + GL_CLIP_PLANE0_IMG* = 0x3000.GLenum + GL_FRONT_LEFT* = 0x0400.GLenum + GL_MATRIX3_ARB* = 0x88C3.GLenum + GL_BLEND_EQUATION_ALPHA_EXT* = 0x883D.GLenum + GL_BGRA8_EXT* = 0x93A1.GLenum + GL_INTERLACE_READ_INGR* = 0x8568.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE* = 0x8E24.GLenum + GL_MAP1_VERTEX_ATTRIB13_4_NV* = 0x866D.GLenum + GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX* = 0x8186.GLenum + GL_UNSIGNED_INT_SAMPLER_2D_ARRAY* = 0x8DD7.GLenum + GL_ALL_SHADER_BITS_EXT* = 0xFFFFFFFF.GLbitfield + GL_ONE_MINUS_SRC1_ALPHA* = 0x88FB.GLenum + GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE* = 0x851E.GLenum + GL_PROXY_COLOR_TABLE_SGI* = 0x80D3.GLenum + GL_MAX_RENDERBUFFER_SIZE_OES* = 0x84E8.GLenum + GL_VERTEX_ATTRIB_ARRAY_ENABLED* = 0x8622.GLenum + GL_TEXTURE_BINDING_2D_MULTISAMPLE* = 0x9104.GLenum + GL_STENCIL_BUFFER_BIT0_QCOM* = 0x00010000.GLbitfield + GL_IMAGE_BINDING_FORMAT_EXT* = 0x906E.GLenum + GL_RENDERBUFFER_SAMPLES_NV* = 0x8CAB.GLenum + GL_ACCUM_GREEN_BITS* = 0x0D59.GLenum + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER* = 0x90ED.GLenum + GL_FRAMEBUFFER_UNDEFINED* = 0x8219.GLenum + GL_OFFSET_TEXTURE_2D_NV* = 0x86E8.GLenum + GL_POST_CONVOLUTION_RED_BIAS* = 0x8020.GLenum + GL_DRAW_BUFFER8* = 0x882D.GLenum + GL_MAP_INVALIDATE_RANGE_BIT* = 0x0004.GLbitfield + GL_ALWAYS* = 0x0207.GLenum + GL_ALPHA_MIN_SGIX* = 0x8320.GLenum + GL_SOURCE0_RGB_ARB* = 0x8580.GLenum + GL_POINT_SIZE_ARRAY_POINTER_OES* = 0x898C.GLenum + GL_CUBIC_EXT* = 0x8334.GLenum + GL_MAP2_NORMAL* = 0x0DB2.GLenum + GL_TEXTURE_RESIDENT_EXT* = 0x8067.GLenum + GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB* = 0x8C2D.GLenum + GL_BUMP_NUM_TEX_UNITS_ATI* = 0x8777.GLenum + GL_TEXTURE_LOD_BIAS_T_SGIX* = 0x818F.GLenum + GL_FONT_UNDERLINE_POSITION_BIT_NV* = 0x04000000.GLbitfield + GL_NORMAL_ARRAY_STRIDE* = 0x807F.GLenum + GL_CONDITION_SATISFIED_APPLE* = 0x911C.GLenum + GL_POINT_SIZE_MIN* = 0x8126.GLenum + GL_SPARE0_PLUS_SECONDARY_COLOR_NV* = 0x8532.GLenum + GL_LAYOUT_DEFAULT_INTEL* = 0.GLenum + GL_FRAMEBUFFER_BINDING* = 0x8CA6.GLenum + GL_HIGH_FLOAT* = 0x8DF2.GLenum + GL_NO_RESET_NOTIFICATION_ARB* = 0x8261.GLenum + GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV* = 0x864D.GLenum + GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV* = 0x8F20.GLenum + GL_VIEW_CLASS_96_BITS* = 0x82C5.GLenum + GL_BACK_RIGHT* = 0x0403.GLenum + GL_BLEND_EQUATION_ALPHA* = 0x883D.GLenum + GL_DISTANCE_ATTENUATION_SGIS* = 0x8129.GLenum + GL_PROXY_TEXTURE_CUBE_MAP_ARRAY* = 0x900B.GLenum + GL_RG16* = 0x822C.GLenum + GL_UNDEFINED_VERTEX* = 0x8260.GLenum + GL_PATH_DASH_OFFSET_NV* = 0x907E.GLenum + GL_ALL_ATTRIB_BITS* = 0xFFFFFFFF.GLbitfield + GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE* = 0x8A04.GLenum + GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI* = 0x80B3.GLenum + GL_TIME_ELAPSED_EXT* = 0x88BF.GLenum + GL_MAP2_VERTEX_3* = 0x0DB7.GLenum + GL_MAX_PROGRAM_RESULT_COMPONENTS_NV* = 0x8909.GLenum + GL_SAMPLER_2D_RECT_SHADOW_ARB* = 0x8B64.GLenum + GL_REFERENCE_PLANE_SGIX* = 0x817D.GLenum + GL_LUMINANCE4_ALPHA4_EXT* = 0x8043.GLenum + GL_PATH_FILL_MASK_NV* = 0x9081.GLenum + GL_FILTER* = 0x829A.GLenum + GL_INT_SAMPLER_2D_ARRAY* = 0x8DCF.GLenum + GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV* = 0x8908.GLenum + GL_EVAL_VERTEX_ATTRIB2_NV* = 0x86C8.GLenum + GL_NAND* = 0x150E.GLenum + GL_BLEND_SRC_RGB* = 0x80C9.GLenum + GL_OPERAND2_ALPHA_EXT* = 0x859A.GLenum + GL_IMAGE_1D_EXT* = 0x904C.GLenum + GL_CONVOLUTION_FILTER_SCALE* = 0x8014.GLenum + GL_IMAGE_CLASS_2_X_16* = 0x82BD.GLenum + GL_VIEW_CLASS_BPTC_FLOAT* = 0x82D3.GLenum + GL_PROGRAM_INPUT* = 0x92E3.GLenum + GL_1PASS_SGIS* = 0x80A1.GLenum + GL_FOG_DISTANCE_MODE_NV* = 0x855A.GLenum + GL_STENCIL_INDEX16_EXT* = 0x8D49.GLenum + GL_POST_CONVOLUTION_RED_BIAS_EXT* = 0x8020.GLenum + GL_PIXEL_MAP_R_TO_R* = 0x0C76.GLenum + GL_3DC_XY_AMD* = 0x87FA.GLenum + GL_POINT_SIZE_MAX* = 0x8127.GLenum + GL_DOUBLE_MAT3x2* = 0x8F4B.GLenum + GL_DOUBLE_MAT4x2_EXT* = 0x8F4D.GLenum + GL_TEXTURE_HI_SIZE_NV* = 0x871B.GLenum + GL_MATRIX4_NV* = 0x8634.GLenum + GL_SPRITE_TRANSLATION_SGIX* = 0x814B.GLenum + GL_TEXTURE_FILTER_CONTROL_EXT* = 0x8500.GLenum + GL_SMOOTH_LINE_WIDTH_GRANULARITY* = 0x0B23.GLenum + GL_TEXTURE_BINDING_BUFFER* = 0x8C2C.GLenum + GL_INTENSITY4* = 0x804A.GLenum + GL_MAX_IMAGE_SAMPLES_EXT* = 0x906D.GLenum + GL_COLOR_ATTACHMENT12* = 0x8CEC.GLenum + GL_CLAMP_READ_COLOR* = 0x891C.GLenum + GL_ELEMENT_ARRAY_BUFFER_ARB* = 0x8893.GLenum + GL_MAP2_VERTEX_ATTRIB6_4_NV* = 0x8676.GLenum + GL_CONVOLUTION_HEIGHT_EXT* = 0x8019.GLenum + GL_SGX_PROGRAM_BINARY_IMG* = 0x9130.GLenum + GL_MAP1_TEXTURE_COORD_1* = 0x0D93.GLenum + GL_COMPRESSED_RGBA_ASTC_6x6_KHR* = 0x93B4.GLenum + GL_TEXTURE_APPLICATION_MODE_EXT* = 0x834F.GLenum + GL_TEXTURE_GATHER* = 0x82A2.GLenum + GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS* = 0x90DC.GLenum + GL_DEBUG_LOGGED_MESSAGES_KHR* = 0x9145.GLenum + GL_TEXTURE_VIEW_NUM_LEVELS* = 0x82DC.GLenum + GL_ENABLE_BIT* = 0x00002000.GLbitfield + GL_VERTEX_PROGRAM_TWO_SIDE_ARB* = 0x8643.GLenum + GL_INDEX_TEST_EXT* = 0x81B5.GLenum + GL_TEXTURE_WRAP_R* = 0x8072.GLenum + GL_MAX* = 0x8008.GLenum + GL_UNPACK_IMAGE_DEPTH_SGIS* = 0x8133.GLenum + GL_COLOR_ATTACHMENT13_NV* = 0x8CED.GLenum + GL_FOG_BIT* = 0x00000080.GLbitfield + GL_GEOMETRY_SHADER_EXT* = 0x8DD9.GLenum + GL_ALPHA_TEST_FUNC_QCOM* = 0x0BC1.GLenum + GL_DRAW_BUFFER10_EXT* = 0x882F.GLenum + GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB* = 0x880F.GLenum + GL_STENCIL_BACK_REF* = 0x8CA3.GLenum + GL_SAMPLER_1D_ARB* = 0x8B5D.GLenum + GL_DRAW_BUFFER* = 0x0C01.GLenum + GL_CLIENT_PIXEL_STORE_BIT* = 0x00000001.GLbitfield + GL_TEXTURE_STENCIL_SIZE* = 0x88F1.GLenum + GL_ELEMENT_ARRAY_APPLE* = 0x8A0C.GLenum + GL_CON_21_ATI* = 0x8956.GLenum + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER* = 0x92C7.GLenum + GL_PIXEL_MAP_I_TO_B* = 0x0C74.GLenum + GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE* = 0x8A03.GLenum + GL_FOG_INDEX* = 0x0B61.GLenum + GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI* = 0x80D4.GLenum + GL_OUTPUT_TEXTURE_COORD29_EXT* = 0x87BA.GLenum + GL_TESS_CONTROL_SUBROUTINE* = 0x92E9.GLenum + GL_IMAGE_CUBE_MAP_ARRAY* = 0x9054.GLenum + GL_RGB_FLOAT32_ATI* = 0x8815.GLenum + GL_OBJECT_SHADER_SOURCE_LENGTH_ARB* = 0x8B88.GLenum + GL_COLOR_INDEX4_EXT* = 0x80E4.GLenum + GL_DRAW_BUFFER14* = 0x8833.GLenum + GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV* = 0x90BE.GLenum + GL_NATIVE_GRAPHICS_HANDLE_PGI* = 0x1A202.GLenum + GL_UNSIGNED_SHORT_5_6_5* = 0x8363.GLenum + GL_GREATER* = 0x0204.GLenum + GL_DATA_BUFFER_AMD* = 0x9151.GLenum + GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV* = 0x40.GLbitfield + GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2* = 0x9276.GLenum + GL_RELATIVE_MOVE_TO_NV* = 0x03.GLenum + GL_BLUE_INTEGER* = 0x8D96.GLenum + GL_BLUE_BIAS* = 0x0D1B.GLenum + GL_SHADER_TYPE* = 0x8B4F.GLenum + GL_TRANSFORM_FEEDBACK_BINDING* = 0x8E25.GLenum + GL_TEXTURE17_ARB* = 0x84D1.GLenum + GL_GREEN* = 0x1904.GLenum + GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS* = 0x8E89.GLenum + GL_DRAW_BUFFER6* = 0x882B.GLenum + GL_VALIDATE_STATUS* = 0x8B83.GLenum + GL_TEXTURE_COORD_ARRAY_ADDRESS_NV* = 0x8F25.GLenum + GL_MVP_MATRIX_EXT* = 0x87E3.GLenum + GL_PIXEL_BUFFER_BARRIER_BIT_EXT* = 0x00000080.GLbitfield + GL_MAX_VERTEX_VARYING_COMPONENTS_EXT* = 0x8DDE.GLenum + GL_STACK_OVERFLOW_KHR* = 0x0503.GLenum + GL_MAX_PROJECTION_STACK_DEPTH* = 0x0D38.GLenum + GL_SKIP_COMPONENTS3_NV* = -4 + GL_DEBUG_ASSERT_MESA* = 0x875B.GLenum + GL_INSTRUMENT_BUFFER_POINTER_SGIX* = 0x8180.GLenum + GL_SAMPLE_ALPHA_TO_MASK_EXT* = 0x809E.GLenum + GL_REG_29_ATI* = 0x893E.GLenum + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV* = 0x8C4E.GLenum + GL_DEBUG_CATEGORY_DEPRECATION_AMD* = 0x914B.GLenum + GL_DEPTH_STENCIL_TO_BGRA_NV* = 0x886F.GLenum + GL_UNSIGNED_INT_VEC3_EXT* = 0x8DC7.GLenum + GL_VERTEX_SHADER_EXT* = 0x8780.GLenum + GL_LIST_BASE* = 0x0B32.GLenum + GL_TEXTURE_STENCIL_SIZE_EXT* = 0x88F1.GLenum + GL_ACTIVE_PROGRAM* = 0x8259.GLenum + GL_RGBA_SIGNED_COMPONENTS_EXT* = 0x8C3C.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR* = 0x93DC.GLenum + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE* = 0x8CD0.GLenum + GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE* = 0x8217.GLenum + GL_MATRIX7_ARB* = 0x88C7.GLenum + GL_FLOAT_VEC3_ARB* = 0x8B51.GLenum + GL_PACK_ROW_BYTES_APPLE* = 0x8A15.GLenum + GL_PIXEL_TILE_GRID_HEIGHT_SGIX* = 0x8143.GLenum + GL_UNIFORM_BLOCK* = 0x92E2.GLenum + GL_VIEWPORT_BIT* = 0x00000800.GLbitfield + GL_RENDERBUFFER_COVERAGE_SAMPLES_NV* = 0x8CAB.GLenum + GL_MAP1_BINORMAL_EXT* = 0x8446.GLenum + GL_SAMPLER_3D* = 0x8B5F.GLenum + GL_RENDERBUFFER_SAMPLES_APPLE* = 0x8CAB.GLenum + GL_DEPTH_WRITEMASK* = 0x0B72.GLenum + GL_MAP2_VERTEX_ATTRIB9_4_NV* = 0x8679.GLenum + GL_TEXTURE_COMPARE_FUNC* = 0x884D.GLenum + GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB* = 0x00000004.GLbitfield + GL_READ_BUFFER* = 0x0C02.GLenum + GL_ONE_MINUS_SRC1_COLOR* = 0x88FA.GLenum + GL_PROGRAM_FORMAT_ASCII_ARB* = 0x8875.GLenum + GL_DRAW_FRAMEBUFFER_APPLE* = 0x8CA9.GLenum + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES* = 0x8CD0.GLenum + GL_BLEND_DST* = 0x0BE0.GLenum + GL_SHADER_OBJECT_EXT* = 0x8B48.GLenum + GL_UNSIGNALED* = 0x9118.GLenum + GL_VERTEX4_BIT_PGI* = 0x00000008.GLbitfield + GL_DRAW_FRAMEBUFFER_BINDING_APPLE* = 0x8CA6.GLenum + GL_IMAGE_CUBE_EXT* = 0x9050.GLenum + GL_CONTEXT_ROBUST_ACCESS_EXT* = 0x90F3.GLenum + GL_TEXTURE14_ARB* = 0x84CE.GLenum + GL_TEXTURE_CUBE_MAP_POSITIVE_Y* = 0x8517.GLenum + GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV* = 0x8857.GLenum + GL_COMPRESSED_RG11_EAC_OES* = 0x9272.GLenum + GL_OP_DOT4_EXT* = 0x8785.GLenum + GL_FRAMEBUFFER_COMPLETE_EXT* = 0x8CD5.GLenum + GL_TEXTURE_COMPARE_FUNC_ARB* = 0x884D.GLenum + GL_TEXTURE_FILTER4_SIZE_SGIS* = 0x8147.GLenum + GL_ELEMENT_ARRAY_BUFFER_BINDING* = 0x8895.GLenum + GL_UNSIGNED_INT_IMAGE_BUFFER_EXT* = 0x9067.GLenum + GL_IMAGE_1D_ARRAY_EXT* = 0x9052.GLenum + GL_CLAMP_READ_COLOR_ARB* = 0x891C.GLenum + GL_COMPUTE_SUBROUTINE* = 0x92ED.GLenum + GL_R3_G3_B2* = 0x2A10.GLenum + GL_PATH_DASH_ARRAY_COUNT_NV* = 0x909F.GLenum + GL_SPOT_EXPONENT* = 0x1205.GLenum + GL_NUM_PROGRAM_BINARY_FORMATS_OES* = 0x87FE.GLenum + GL_SWIZZLE_STQ_ATI* = 0x8977.GLenum + GL_SYNC_FLUSH_COMMANDS_BIT_APPLE* = 0x00000001.GLbitfield + GL_VERTEX_STREAM6_ATI* = 0x8772.GLenum + GL_FRAGMENT_COLOR_MATERIAL_SGIX* = 0x8401.GLenum + GL_DYNAMIC_ATI* = 0x8761.GLenum + GL_SUB_ATI* = 0x8965.GLenum + GL_PREVIOUS_EXT* = 0x8578.GLenum + GL_MAP2_TEXTURE_COORD_1* = 0x0DB3.GLenum + GL_COLOR_SAMPLES_NV* = 0x8E20.GLenum + GL_HILO_NV* = 0x86F4.GLenum + GL_SHADER_STORAGE_BUFFER_BINDING* = 0x90D3.GLenum + GL_DUP_LAST_CUBIC_CURVE_TO_NV* = 0xF4.GLenum + GL_ACTIVE_SUBROUTINES* = 0x8DE5.GLenum + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG* = 0x9134.GLenum + GL_INTENSITY16* = 0x804D.GLenum + GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB* = 0x88AF.GLenum + GL_TIMESTAMP_EXT* = 0x8E28.GLenum + GL_CLIENT_ACTIVE_TEXTURE* = 0x84E1.GLenum + GL_TEXTURE_BINDING_2D_ARRAY* = 0x8C1D.GLenum + GL_INT_SAMPLER_2D_RECT_EXT* = 0x8DCD.GLenum + GL_PREFER_DOUBLEBUFFER_HINT_PGI* = 0x1A1F8.GLenum + GL_TEXTURE_WIDTH* = 0x1000.GLenum + GL_CPU_OPTIMIZED_QCOM* = 0x8FB1.GLenum + GL_TEXTURE_IMAGE_TYPE* = 0x8290.GLenum + GL_MAX_VERTEX_UNIFORM_VECTORS* = 0x8DFB.GLenum + GL_MODULATE_SUBTRACT_ATI* = 0x8746.GLenum + GL_SYNC_STATUS* = 0x9114.GLenum + GL_IMAGE_2D_RECT_EXT* = 0x904F.GLenum + GL_MATRIX6_NV* = 0x8636.GLenum + GL_SOURCE1_RGB_ARB* = 0x8581.GLenum + GL_MAX_COMBINED_ATOMIC_COUNTERS* = 0x92D7.GLenum + GL_MAX_COMPUTE_LOCAL_INVOCATIONS* = 0x90EB.GLenum + GL_SAMPLER_CUBE* = 0x8B60.GLenum + GL_ALPHA_FLOAT32_ATI* = 0x8816.GLenum + GL_COMPRESSED_LUMINANCE_ARB* = 0x84EA.GLenum + GL_COMPRESSED_RGB8_ETC2_OES* = 0x9274.GLenum + GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR* = 0x8243.GLenum + GL_MINUS_CLAMPED_NV* = 0x92B3.GLenum + GL_REG_31_ATI* = 0x8940.GLenum + GL_ELEMENT_ARRAY_ADDRESS_NV* = 0x8F29.GLenum + GL_SRC1_COLOR* = 0x88F9.GLenum + GL_DEBUG_SEVERITY_LOW_ARB* = 0x9148.GLenum + GL_CON_3_ATI* = 0x8944.GLenum + GL_R32I* = 0x8235.GLenum + GL_BLEND_COLOR* = 0x8005.GLenum + GL_CLIP_PLANE4* = 0x3004.GLenum + GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT* = 0x00000001.GLbitfield + GL_FLOAT16_VEC4_NV* = 0x8FFB.GLenum + GL_DST_IN_NV* = 0x928B.GLenum + GL_VIRTUAL_PAGE_SIZE_Y_ARB* = 0x9196.GLenum + GL_COLOR_ATTACHMENT8_NV* = 0x8CE8.GLenum + GL_TESS_GEN_VERTEX_ORDER* = 0x8E78.GLenum + GL_LOSE_CONTEXT_ON_RESET_EXT* = 0x8252.GLenum + GL_PROGRAM_INSTRUCTIONS_ARB* = 0x88A0.GLenum + GL_TEXTURE_IMAGE_VALID_QCOM* = 0x8BD8.GLenum + GL_SAMPLE_MASK_VALUE_EXT* = 0x80AA.GLenum + GL_CURRENT_MATRIX_ARB* = 0x8641.GLenum + GL_DECR_WRAP_EXT* = 0x8508.GLenum + GL_BLUE_INTEGER_EXT* = 0x8D96.GLenum + GL_COMPRESSED_RG* = 0x8226.GLenum + GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV* = 0x88F4.GLenum + GL_MINMAX_EXT* = 0x802E.GLenum + GL_FLOAT_MAT4_ARB* = 0x8B5C.GLenum + GL_TEXTURE_CLIPMAP_FRAME_SGIX* = 0x8172.GLenum + GL_PIXEL_UNPACK_BUFFER_EXT* = 0x88EC.GLenum + GL_TEXTURE5_ARB* = 0x84C5.GLenum + GL_UNSIGNED_INT_IMAGE_2D_RECT* = 0x9065.GLenum + GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS* = 0x91BC.GLenum + GL_DEPTH_COMPONENT* = 0x1902.GLenum + GL_RG32F_EXT* = 0x8230.GLenum + GL_FACTOR_ALPHA_MODULATE_IMG* = 0x8C07.GLenum + GL_VERTEX_ARRAY_TYPE_EXT* = 0x807B.GLenum + GL_DS_BIAS_NV* = 0x8716.GLenum + GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI* = 0x1A203.GLenum + GL_ALPHA16UI_EXT* = 0x8D78.GLenum + GL_DOUBLE_VEC2* = 0x8FFC.GLenum + GL_MAP1_VERTEX_ATTRIB12_4_NV* = 0x866C.GLenum + GL_4D_COLOR_TEXTURE* = 0x0604.GLenum + GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS* = 0x90D6.GLenum + GL_SPECULAR* = 0x1202.GLenum + GL_TOP_LEVEL_ARRAY_SIZE* = 0x930C.GLenum + GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB* = 0x919A.GLenum + GL_COVERAGE_SAMPLES_NV* = 0x8ED4.GLenum + GL_SIGNALED_APPLE* = 0x9119.GLenum + GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR* = 0x824D.GLenum + GL_BUFFER_KHR* = 0x82E0.GLenum + GL_GEOMETRY_TEXTURE* = 0x829E.GLenum + GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV* = 0x8E5E.GLenum + GL_EVAL_VERTEX_ATTRIB7_NV* = 0x86CD.GLenum + GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV* = 0x80.GLbitfield + GL_BINORMAL_ARRAY_POINTER_EXT* = 0x8443.GLenum + GL_AUX3* = 0x040C.GLenum + GL_MULTISAMPLE_BIT_EXT* = 0x20000000.GLbitfield + GL_COLOR_TABLE_FORMAT_SGI* = 0x80D8.GLenum + GL_VERTEX_PROGRAM_POINT_SIZE* = 0x8642.GLenum + GL_LINE_WIDTH_GRANULARITY* = 0x0B23.GLenum + GL_MAX_VERTEX_ATTRIB_BINDINGS* = 0x82DA.GLenum + GL_TEXTURE_BINDING_2D_ARRAY_EXT* = 0x8C1D.GLenum + GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST* = 0x82AC.GLenum + GL_SCALE_BY_FOUR_NV* = 0x853F.GLenum + GL_VIRTUAL_PAGE_SIZE_Z_AMD* = 0x9197.GLenum + GL_TEXTURE16* = 0x84D0.GLenum + GL_DSDT8_MAG8_NV* = 0x870A.GLenum + GL_OP_FLOOR_EXT* = 0x878F.GLenum + GL_MAX_PROGRAM_IF_DEPTH_NV* = 0x88F6.GLenum + GL_VERTEX_ARRAY_LIST_IBM* = 103070.GLenum + GL_COMPRESSED_SIGNED_RED_RGTC1* = 0x8DBC.GLenum + GL_CUBIC_CURVE_TO_NV* = 0x0C.GLenum + GL_PROXY_POST_CONVOLUTION_COLOR_TABLE* = 0x80D4.GLenum + GL_SIGNED_IDENTITY_NV* = 0x853C.GLenum + GL_EVAL_VERTEX_ATTRIB6_NV* = 0x86CC.GLenum + GL_MODELVIEW10_ARB* = 0x872A.GLenum + GL_MULTISAMPLE_3DFX* = 0x86B2.GLenum + GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG* = 0x8C00.GLenum + GL_DSDT_MAG_VIB_NV* = 0x86F7.GLenum + GL_TEXCOORD4_BIT_PGI* = 0x80000000.GLbitfield + GL_TRANSFORM_FEEDBACK_BARRIER_BIT* = 0x00000800.GLbitfield + GL_EVAL_VERTEX_ATTRIB10_NV* = 0x86D0.GLenum + GL_DRAW_BUFFER13_ARB* = 0x8832.GLenum + GL_RENDERBUFFER_STENCIL_SIZE_OES* = 0x8D55.GLenum + GL_INTENSITY8I_EXT* = 0x8D91.GLenum + GL_STENCIL_BACK_PASS_DEPTH_FAIL* = 0x8802.GLenum + GL_INTENSITY32F_ARB* = 0x8817.GLenum + GL_CURRENT_ATTRIB_NV* = 0x8626.GLenum + GL_POLYGON_BIT* = 0x00000008.GLbitfield + GL_COMBINE_RGB* = 0x8571.GLenum + GL_MAX_FRAMEBUFFER_HEIGHT* = 0x9316.GLenum + GL_FRAMEBUFFER_BINDING_OES* = 0x8CA6.GLenum + GL_TEXTURE_GREEN_TYPE* = 0x8C11.GLenum + GL_LINE_TO_NV* = 0x04.GLenum + GL_FUNC_ADD_EXT* = 0x8006.GLenum + GL_TEXTURE_LOD_BIAS* = 0x8501.GLenum + GL_QUAD_INTENSITY8_SGIS* = 0x8123.GLenum + GL_SECONDARY_COLOR_ARRAY_EXT* = 0x845E.GLenum + GL_UNPACK_COMPRESSED_SIZE_SGIX* = 0x831A.GLenum + GL_RGBA_INTEGER* = 0x8D99.GLenum + GL_ATOMIC_COUNTER_BUFFER_SIZE* = 0x92C3.GLenum + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE* = 0x8D56.GLenum + GL_OBJECT_DISTANCE_TO_LINE_SGIS* = 0x81F3.GLenum + GL_DEPTH_BUFFER_BIT3_QCOM* = 0x00000800.GLbitfield + GL_RGB16_SNORM* = 0x8F9A.GLenum + GL_MATRIX_INDEX_ARRAY_TYPE_ARB* = 0x8847.GLenum + GL_TRANSLATE_X_NV* = 0x908E.GLenum + GL_BUFFER_ACCESS_FLAGS* = 0x911F.GLenum + GL_IS_PER_PATCH* = 0x92E7.GLenum + GL_PATH_GEN_MODE_NV* = 0x90B0.GLenum + GL_ALPHA_MIN_CLAMP_INGR* = 0x8563.GLenum + GL_LUMINANCE_ALPHA32I_EXT* = 0x8D87.GLenum + GL_BUFFER_USAGE_ARB* = 0x8765.GLenum + GL_POINT_SIZE* = 0x0B11.GLenum + GL_INVARIANT_EXT* = 0x87C2.GLenum + GL_IMAGE_BINDING_NAME* = 0x8F3A.GLenum + GL_BLEND_SRC_ALPHA* = 0x80CB.GLenum + GL_OUTPUT_TEXTURE_COORD23_EXT* = 0x87B4.GLenum + GL_EYE_PLANE* = 0x2502.GLenum + GL_BOOL_VEC4_ARB* = 0x8B59.GLenum + GL_MITER_REVERT_NV* = 0x90A7.GLenum + GL_SYNC_X11_FENCE_EXT* = 0x90E1.GLenum + GL_GEOMETRY_SHADER_INVOCATIONS* = 0x887F.GLenum + GL_DRAW_BUFFER5_ATI* = 0x882A.GLenum + GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB* = 0x889D.GLenum + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT* = 0x906B.GLenum + GL_PIXEL_TEX_GEN_Q_ROUND_SGIX* = 0x8185.GLenum + GL_DOUBLE_MAT3x2_EXT* = 0x8F4B.GLenum + GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB* = 0x8516.GLenum + GL_MOV_ATI* = 0x8961.GLenum + GL_COLOR4_BIT_PGI* = 0x00020000.GLbitfield + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR* = 0x93DD.GLenum + GL_DEPTH_BOUNDS_TEST_EXT* = 0x8890.GLenum + GL_DST_OVER_NV* = 0x9289.GLenum + GL_PIXEL_MAP_I_TO_I_SIZE* = 0x0CB0.GLenum + GL_ALPHA16F_EXT* = 0x881C.GLenum + GL_RENDERBUFFER_BINDING_EXT* = 0x8CA7.GLenum + GL_MATRIX25_ARB* = 0x88D9.GLenum + GL_OUTPUT_TEXTURE_COORD19_EXT* = 0x87B0.GLenum + GL_NORMAL_MAP* = 0x8511.GLenum + GL_GPU_ADDRESS_NV* = 0x8F34.GLenum + GL_STREAM_READ* = 0x88E1.GLenum + GL_MIRRORED_REPEAT* = 0x8370.GLint + GL_TEXTURE_SWIZZLE_RGBA* = 0x8E46.GLenum + GL_HALF_BIAS_NORMAL_NV* = 0x853A.GLenum + GL_STENCIL_BACK_OP_VALUE_AMD* = 0x874D.GLenum + GL_TEXTURE_BLUE_TYPE_ARB* = 0x8C12.GLenum + GL_MODELVIEW_PROJECTION_NV* = 0x8629.GLenum + GL_ACTIVE_UNIFORM_MAX_LENGTH* = 0x8B87.GLenum + GL_TEXTURE_SWIZZLE_RGBA_EXT* = 0x8E46.GLenum + GL_TEXTURE_GEN_T* = 0x0C61.GLenum + GL_HILO16_NV* = 0x86F8.GLenum + GL_CURRENT_QUERY_EXT* = 0x8865.GLenum + GL_FLOAT16_VEC2_NV* = 0x8FF9.GLenum + GL_RGBA_FLOAT_MODE_ARB* = 0x8820.GLenum + GL_POINT_SIZE_ARRAY_TYPE_OES* = 0x898A.GLenum + GL_GENERATE_MIPMAP_HINT* = 0x8192.GLenum + GL_1PASS_EXT* = 0x80A1.GLenum + GL_SWIZZLE_STQ_DQ_ATI* = 0x8979.GLenum + GL_VERTICAL_LINE_TO_NV* = 0x08.GLenum + GL_MINMAX* = 0x802E.GLenum + GL_RENDERBUFFER_ALPHA_SIZE_EXT* = 0x8D53.GLenum + GL_DEPTH_COMPONENT32F* = 0x8CAC.GLenum + GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV* = 0x9025.GLenum + GL_CLIP_PLANE5_IMG* = 0x3005.GLenum + GL_TEXTURE_2D_MULTISAMPLE* = 0x9100.GLenum + GL_PREVIOUS* = 0x8578.GLenum + GL_CULL_MODES_NV* = 0x86E0.GLenum + GL_TRACE_ARRAYS_BIT_MESA* = 0x0004.GLbitfield + GL_MAX_ACTIVE_LIGHTS_SGIX* = 0x8405.GLenum + GL_PRIMITIVE_ID_NV* = 0x8C7C.GLenum + GL_DEPTH_COMPONENT16* = 0x81A5.GLenum + GL_FRAMEBUFFER_ATTACHMENT_LAYERED* = 0x8DA7.GLenum + GL_MAX_FRAGMENT_UNIFORM_BLOCKS* = 0x8A2D.GLenum + GL_OUTPUT_COLOR0_EXT* = 0x879B.GLenum + GL_RGBA16F_EXT* = 0x881A.GLenum + GL_MAX_PALETTE_MATRICES_OES* = 0x8842.GLenum + GL_VIEW_CLASS_64_BITS* = 0x82C6.GLenum + GL_TRACE_ALL_BITS_MESA* = 0xFFFF.GLbitfield + GL_REPLACE_VALUE_AMD* = 0x874B.GLenum + GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP* = 0x8163.GLenum + GL_BGR_INTEGER* = 0x8D9A.GLenum + GL_MAX_DEBUG_LOGGED_MESSAGES_ARB* = 0x9144.GLenum + GL_FOG_COLOR* = 0x0B66.GLenum + GL_MAX_MULTIVIEW_BUFFERS_EXT* = 0x90F2.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER* = 0x8C8E.GLenum + GL_E_TIMES_F_NV* = 0x8531.GLenum + GL_COLOR_TABLE_WIDTH_SGI* = 0x80D9.GLenum + GL_VERTEX_ATTRIB_ARRAY_SIZE* = 0x8623.GLenum + GL_422_REV_AVERAGE_EXT* = 0x80CF.GLenum + GL_WRITE_DISCARD_NV* = 0x88BE.GLenum + GL_DRAW_BUFFER0_EXT* = 0x8825.GLenum + GL_FONT_HEIGHT_BIT_NV* = 0x00800000.GLbitfield + GL_INTERLACE_OML* = 0x8980.GLenum + GL_FUNC_REVERSE_SUBTRACT_EXT* = 0x800B.GLenum + GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT* = 0x87C8.GLenum + GL_PRIMARY_COLOR* = 0x8577.GLenum + GL_RGBA16I* = 0x8D88.GLenum + GL_TEXTURE6* = 0x84C6.GLenum + GL_PATH_FILL_BOUNDING_BOX_NV* = 0x90A1.GLenum + GL_WEIGHT_ARRAY_BUFFER_BINDING* = 0x889E.GLenum + GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI* = 0x8835.GLenum + GL_YCRCB_422_SGIX* = 0x81BB.GLenum + GL_RGB5_A1* = 0x8057.GLenum + GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT* = 0x8211.GLenum + GL_DRAW_FRAMEBUFFER_BINDING_EXT* = 0x8CA6.GLenum + GL_TEXTURE_1D_ARRAY* = 0x8C18.GLenum + GL_CLAMP_FRAGMENT_COLOR_ARB* = 0x891B.GLenum + GL_FULL_RANGE_EXT* = 0x87E1.GLenum + GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV* = 0x8DA3.GLenum + GL_CON_24_ATI* = 0x8959.GLenum + GL_2D* = 0x0600.GLenum + GL_DRAW_BUFFER5_NV* = 0x882A.GLenum + GL_PALETTE4_RGBA8_OES* = 0x8B91.GLenum + GL_READ_ONLY_ARB* = 0x88B8.GLenum + GL_NUM_SAMPLE_COUNTS* = 0x9380.GLenum + GL_MATRIX_STRIDE* = 0x92FF.GLenum + GL_HISTOGRAM_RED_SIZE* = 0x8028.GLenum + GL_COLOR_ATTACHMENT4* = 0x8CE4.GLenum + GL_PATH_INITIAL_END_CAP_NV* = 0x9077.GLenum + GL_TEXTURE_USAGE_ANGLE* = 0x93A2.GLenum + GL_DOUBLE_MAT2* = 0x8F46.GLenum + GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE* = 0x8212.GLenum + GL_SECONDARY_COLOR_ARRAY_POINTER* = 0x845D.GLenum + GL_MAX_VIEWPORTS* = 0x825B.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_EXT* = 0x8C8E.GLenum + GL_FRAMEBUFFER_SRGB_EXT* = 0x8DB9.GLenum + GL_STORAGE_SHARED_APPLE* = 0x85BF.GLenum + GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH* = 0x8C76.GLenum + GL_TRANSFORM_FEEDBACK_NV* = 0x8E22.GLenum + GL_MIRRORED_REPEAT_ARB* = 0x8370.GLint + GL_MAX_VERTEX_OUTPUT_COMPONENTS* = 0x9122.GLenum + GL_BUFFER_MAP_LENGTH* = 0x9120.GLenum + GL_BUFFER_OBJECT_APPLE* = 0x85B3.GLenum + GL_INT_VEC4_ARB* = 0x8B55.GLenum + GL_COMBINER3_NV* = 0x8553.GLenum + GL_INT16_VEC3_NV* = 0x8FE6.GLenum + GL_MAX_3D_TEXTURE_SIZE_EXT* = 0x8073.GLenum + GL_GENERATE_MIPMAP_HINT_SGIS* = 0x8192.GLenum + GL_SRC0_ALPHA* = 0x8588.GLenum + GL_IMAGE_2D* = 0x904D.GLenum + GL_VIEW_CLASS_S3TC_DXT1_RGB* = 0x82CC.GLenum + GL_DOT3_RGBA* = 0x86AF.GLenum + GL_TEXTURE_GREEN_SIZE* = 0x805D.GLenum + GL_DOUBLE_MAT2x3* = 0x8F49.GLenum + GL_COORD_REPLACE_OES* = 0x8862.GLenum + GL_MAX_DEBUG_MESSAGE_LENGTH_ARB* = 0x9143.GLenum + GL_TEXTURE_IMMUTABLE_FORMAT_EXT* = 0x912F.GLenum + GL_INDEX_ARRAY_POINTER_EXT* = 0x8091.GLenum + GL_NUM_SHADING_LANGUAGE_VERSIONS* = 0x82E9.GLenum + GL_DEBUG_CALLBACK_FUNCTION_ARB* = 0x8244.GLenum + GL_OFFSET_TEXTURE_MATRIX_NV* = 0x86E1.GLenum + GL_INTENSITY32I_EXT* = 0x8D85.GLenum + GL_BUMP_TEX_UNITS_ATI* = 0x8778.GLenum + GL_RENDERBUFFER* = 0x8D41.GLenum + GL_UPPER_LEFT* = 0x8CA2.GLenum + GL_GUILTY_CONTEXT_RESET_ARB* = 0x8253.GLenum + GL_MAP2_GRID_SEGMENTS* = 0x0DD3.GLenum + GL_REG_23_ATI* = 0x8938.GLenum + GL_UNSIGNED_INT16_NV* = 0x8FF0.GLenum + GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM* = 103084.GLenum + GL_INVARIANT_VALUE_EXT* = 0x87EA.GLenum + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV* = 0x8C88.GLenum + GL_TEXTURE2_ARB* = 0x84C2.GLenum + GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT* = 0x8DD7.GLenum + GL_IMAGE_CUBE* = 0x9050.GLenum + GL_MAX_PROGRAM_MATRICES_ARB* = 0x862F.GLenum + GL_SIGNED_LUMINANCE8_ALPHA8_NV* = 0x8704.GLenum + GL_INDEX_ARRAY_LIST_IBM* = 103073.GLenum + GL_EVAL_VERTEX_ATTRIB5_NV* = 0x86CB.GLenum + GL_SHADER_SOURCE_LENGTH* = 0x8B88.GLenum + GL_TEXTURE4* = 0x84C4.GLenum + GL_VERTEX_ATTRIB_ARRAY6_NV* = 0x8656.GLenum + GL_PROXY_TEXTURE_1D_STACK_MESAX* = 0x875B.GLenum + GL_MAP_ATTRIB_V_ORDER_NV* = 0x86C4.GLenum + GL_DSDT_NV* = 0x86F5.GLenum + GL_DEBUG_SEVERITY_NOTIFICATION_KHR* = 0x826B.GLenum + GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM* = 103086.GLenum + GL_COMPRESSED_RGBA_ASTC_8x6_KHR* = 0x93B6.GLenum + GL_LINEAR_ATTENUATION* = 0x1208.GLenum + GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV* = 0x9035.GLenum + GL_CONVOLUTION_FILTER_BIAS* = 0x8015.GLenum + GL_IMAGE_MIN_FILTER_HP* = 0x815D.GLenum + GL_EYE_RADIAL_NV* = 0x855B.GLenum + GL_TEXTURE_MIN_LOD_SGIS* = 0x813A.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV* = 0x8C8F.GLenum + GL_TRANSLATE_2D_NV* = 0x9090.GLenum + GL_CONSTANT_ARB* = 0x8576.GLenum + GL_FLOAT_MAT2x3* = 0x8B65.GLenum + GL_MULTISAMPLE_COVERAGE_MODES_NV* = 0x8E12.GLenum + GL_TRANSPOSE_COLOR_MATRIX* = 0x84E6.GLenum + GL_PROGRAM_STRING_NV* = 0x8628.GLenum + GL_UNSIGNED_INT_SAMPLER_1D_EXT* = 0x8DD1.GLenum + GL_BLEND_SRC_ALPHA_OES* = 0x80CB.GLenum + GL_RGB32F_EXT* = 0x8815.GLenum + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT* = 0x8CD4.GLenum + GL_RESTART_PATH_NV* = 0xF0.GLenum + GL_MAP2_VERTEX_ATTRIB11_4_NV* = 0x867B.GLenum + GL_VIEW_CLASS_16_BITS* = 0x82CA.GLenum + GL_BUFFER_DATA_SIZE* = 0x9303.GLenum + GL_BUFFER_FLUSHING_UNMAP_APPLE* = 0x8A13.GLenum + GL_RELATIVE_VERTICAL_LINE_TO_NV* = 0x09.GLenum + GL_SRGB_WRITE* = 0x8298.GLenum + GL_TEXTURE_LUMINANCE_SIZE_EXT* = 0x8060.GLenum + GL_VERTEX_PRECLIP_SGIX* = 0x83EE.GLenum + GL_LINEAR_DETAIL_COLOR_SGIS* = 0x8099.GLenum + GL_SOURCE2_ALPHA_ARB* = 0x858A.GLenum + GL_PATH_FOG_GEN_MODE_NV* = 0x90AC.GLenum + GL_RGB10_A2UI* = 0x906F.GLenum + GL_MULTISAMPLE_BIT_3DFX* = 0x20000000.GLbitfield + GL_PIXEL_MAP_G_TO_G_SIZE* = 0x0CB7.GLenum + GL_COVERAGE_BUFFER_BIT_NV* = 0x00008000.GLbitfield + GL_TEXTURE_COMPRESSED* = 0x86A1.GLenum + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER* = 0x92CA.GLenum + GL_NAMED_STRING_TYPE_ARB* = 0x8DEA.GLenum + GL_RESCALE_NORMAL* = 0x803A.GLenum + GL_OUTPUT_TEXTURE_COORD3_EXT* = 0x87A0.GLenum + GL_RENDERBUFFER_EXT* = 0x8D41.GLenum + GL_QUERY_NO_WAIT* = 0x8E14.GLenum + GL_SAMPLE_ALPHA_TO_COVERAGE* = 0x809E.GLenum + GL_RG8UI* = 0x8238.GLenum + GL_MATRIX3_NV* = 0x8633.GLenum + GL_SAMPLE_BUFFERS_ARB* = 0x80A8.GLenum + GL_VERTEX_CONSISTENT_HINT_PGI* = 0x1A22B.GLenum + GL_SPRITE_AXIAL_SGIX* = 0x814C.GLenum + GL_MODELVIEW_MATRIX* = 0x0BA6.GLenum + GL_SAMPLE_PATTERN_SGIS* = 0x80AC.GLenum + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE* = 0x906B.GLenum + GL_FLOAT_RG16_NV* = 0x8886.GLenum + GL_IMAGE_TRANSLATE_X_HP* = 0x8157.GLenum + GL_FRAMEBUFFER_SRGB* = 0x8DB9.GLenum + GL_DRAW_BUFFER7* = 0x882C.GLenum + GL_CONVOLUTION_BORDER_COLOR* = 0x8154.GLenum + GL_DRAW_BUFFER5* = 0x882A.GLenum + GL_GEOMETRY_INPUT_TYPE_EXT* = 0x8DDB.GLenum + GL_IUI_V2F_EXT* = 0x81AD.GLenum + GL_FLOAT_RG_NV* = 0x8881.GLenum + GL_VERTEX_SHADER_INVARIANTS_EXT* = 0x87D1.GLenum + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV* = 0x8C4D.GLenum + GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB* = 0x862E.GLenum + GL_SAMPLE_PATTERN_EXT* = 0x80AC.GLenum + GL_DIFFERENCE_NV* = 0x929E.GLenum + GL_POST_CONVOLUTION_ALPHA_BIAS_EXT* = 0x8023.GLenum + GL_COLOR_ATTACHMENT1_EXT* = 0x8CE1.GLenum + GL_TEXTURE_ALPHA_MODULATE_IMG* = 0x8C06.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV* = 0x8E23.GLenum + GL_MAX_TEXTURE_IMAGE_UNITS_ARB* = 0x8872.GLenum + GL_FIXED_OES* = 0x140C.GLenum + GL_ALREADY_SIGNALED_APPLE* = 0x911A.GLenum + GL_SET* = 0x150F.GLenum + GL_PERFMON_RESULT_AMD* = 0x8BC6.GLenum + GL_VARIABLE_G_NV* = 0x8529.GLenum + GL_DRAW_FRAMEBUFFER_ANGLE* = 0x8CA9.GLenum + GL_GEOMETRY_SUBROUTINE_UNIFORM* = 0x92F1.GLenum + GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT* = 0x884E.GLenum + GL_POINT* = 0x1B00.GLenum + GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV* = 0x01000000.GLbitfield + GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS* = 0x90CB.GLenum + GL_PLUS_CLAMPED_ALPHA_NV* = 0x92B2.GLenum + GL_DRAW_BUFFER3_ATI* = 0x8828.GLenum + GL_LUMINANCE_ALPHA16I_EXT* = 0x8D8D.GLenum + GL_SUBPIXEL_BITS* = 0x0D50.GLenum + GL_POINT_SPRITE* = 0x8861.GLenum + GL_DRAW_BUFFER0* = 0x8825.GLenum + GL_DEPTH_BIAS* = 0x0D1F.GLenum + GL_COLOR_ARRAY_TYPE* = 0x8082.GLenum + GL_DEPENDENT_GB_TEXTURE_2D_NV* = 0x86EA.GLenum + GL_MAX_SAMPLES_ANGLE* = 0x8D57.GLenum + GL_ALLOW_DRAW_MEM_HINT_PGI* = 0x1A211.GLenum + GL_GEOMETRY_OUTPUT_TYPE* = 0x8918.GLenum + GL_MAX_DEBUG_LOGGED_MESSAGES_KHR* = 0x9144.GLenum + GL_VERTEX_ATTRIB_ARRAY0_NV* = 0x8650.GLenum + GL_PRIMITIVES_GENERATED_EXT* = 0x8C87.GLenum + GL_TEXTURE_FLOAT_COMPONENTS_NV* = 0x888C.GLenum + GL_CLIP_VOLUME_CLIPPING_HINT_EXT* = 0x80F0.GLenum + GL_FRAGMENT_PROGRAM_POSITION_MESA* = 0x8BB0.GLenum + GL_MAX_FRAGMENT_IMAGE_UNIFORMS* = 0x90CE.GLenum + GL_VERTEX_ARRAY_BINDING_APPLE* = 0x85B5.GLenum + GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV* = 0x00000010.GLbitfield + GL_FIRST_VERTEX_CONVENTION* = 0x8E4D.GLenum + GL_DECR_WRAP* = 0x8508.GLenum + GL_IMAGE_CLASS_1_X_32* = 0x82BB.GLenum + GL_MAX_CLIP_PLANES_IMG* = 0x0D32.GLenum + GL_MAX_VARYING_COMPONENTS* = 0x8B4B.GLenum + GL_POST_COLOR_MATRIX_RED_BIAS_SGI* = 0x80B8.GLenum + GL_DSDT_MAG_NV* = 0x86F6.GLenum + GL_DEBUG_SOURCE_APPLICATION* = 0x824A.GLenum + GL_OPERAND0_RGB_ARB* = 0x8590.GLenum + GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE* = 0x82AE.GLenum + GL_VIDEO_COLOR_CONVERSION_MATRIX_NV* = 0x9029.GLenum + GL_MAP2_VERTEX_ATTRIB13_4_NV* = 0x867D.GLenum + GL_DOT2_ADD_ATI* = 0x896C.GLenum + GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS* = 0x8A33.GLenum + GL_IMAGE_BINDING_LAYER_EXT* = 0x8F3D.GLenum + GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX* = 0x8402.GLenum + GL_PACK_IMAGE_DEPTH_SGIS* = 0x8131.GLenum + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT* = 0x8DDF.GLenum + GL_Z_EXT* = 0x87D7.GLenum + GL_MAP1_VERTEX_ATTRIB15_4_NV* = 0x866F.GLenum + GL_RG8_SNORM* = 0x8F95.GLenum + GL_OUTPUT_TEXTURE_COORD5_EXT* = 0x87A2.GLenum + GL_TEXTURE_BINDING_1D_ARRAY_EXT* = 0x8C1C.GLenum + GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB* = 0x8B87.GLenum + GL_PATH_END_CAPS_NV* = 0x9076.GLenum + GL_COLOR_TABLE_GREEN_SIZE* = 0x80DB.GLenum + GL_MAX_ELEMENTS_INDICES_EXT* = 0x80E9.GLenum + GL_TEXTURE_IMMUTABLE_FORMAT* = 0x912F.GLenum + GL_WRITE_ONLY_ARB* = 0x88B9.GLenum + GL_COLOR_ATTACHMENT10_EXT* = 0x8CEA.GLenum + GL_INVERT_RGB_NV* = 0x92A3.GLenum + GL_CURRENT_RASTER_DISTANCE* = 0x0B09.GLenum + GL_DEPTH_STENCIL_TO_RGBA_NV* = 0x886E.GLenum + GL_INVERTED_SCREEN_W_REND* = 0x8491.GLenum + GL_TABLE_TOO_LARGE* = 0x8031.GLenum + GL_REG_16_ATI* = 0x8931.GLenum + GL_BLEND_EQUATION_ALPHA_OES* = 0x883D.GLenum + GL_DRAW_FRAMEBUFFER_BINDING_NV* = 0x8CA6.GLenum + GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS* = 0x8E47.GLenum + GL_TEXTURE_BLUE_SIZE_EXT* = 0x805E.GLenum + GL_TEXTURE_BORDER_VALUES_NV* = 0x871A.GLenum + GL_PROGRAM_LENGTH_ARB* = 0x8627.GLenum + GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV* = 0x909C.GLenum + GL_DOT_PRODUCT_NV* = 0x86EC.GLenum + GL_TRANSPOSE_PROJECTION_MATRIX_ARB* = 0x84E4.GLenum + GL_TEXTURE_2D_MULTISAMPLE_ARRAY* = 0x9102.GLenum + GL_MIN_PROGRAM_TEXEL_OFFSET_NV* = 0x8904.GLenum + GL_MAP2_BINORMAL_EXT* = 0x8447.GLenum + GL_COLOR_ARRAY_BUFFER_BINDING* = 0x8898.GLenum + GL_TEXTURE_COORD_ARRAY_POINTER* = 0x8092.GLenum + GL_TEXTURE4_ARB* = 0x84C4.GLenum + GL_VARIABLE_A_NV* = 0x8523.GLenum + GL_CURRENT_FOG_COORDINATE_EXT* = 0x8453.GLenum + GL_TEXTURE_CUBE_MAP_POSITIVE_X* = 0x8515.GLenum + GL_DEPENDENT_AR_TEXTURE_2D_NV* = 0x86E9.GLenum + GL_TEXTURE29_ARB* = 0x84DD.GLenum + GL_INVERSE_TRANSPOSE_NV* = 0x862D.GLenum + GL_TEXTURE_COLOR_WRITEMASK_SGIS* = 0x81EF.GLenum + GL_HISTOGRAM_SINK* = 0x802D.GLenum + GL_ALPHA12_EXT* = 0x803D.GLenum + GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX* = 0x8175.GLenum + GL_DSDT_MAG_INTENSITY_NV* = 0x86DC.GLenum + GL_ATC_RGB_AMD* = 0x8C92.GLenum + GL_PROGRAM_ATTRIB_COMPONENTS_NV* = 0x8906.GLenum + GL_UNIFORM_BLOCK_BINDING* = 0x8A3F.GLenum + GL_POLYGON_STIPPLE* = 0x0B42.GLenum + GL_BACK* = 0x0405.GLenum + GL_DEPTH_COMPONENT16_NONLINEAR_NV* = 0x8E2C.GLenum + GL_ALPHA32F_EXT* = 0x8816.GLenum + GL_CLAMP_TO_BORDER* = 0x812D.GLint + GL_FLOAT_RGBA16_NV* = 0x888A.GLenum + GL_VERTEX_ARRAY_RANGE_LENGTH_NV* = 0x851E.GLenum + GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV* = 0x8E58.GLenum + GL_SAMPLER_2D* = 0x8B5E.GLenum + GL_SMOOTH_POINT_SIZE_RANGE* = 0x0B12.GLenum + GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX* = 0x8312.GLenum + GL_INTERPOLATE_ARB* = 0x8575.GLenum + GL_VERTEX_ARRAY_LENGTH_NV* = 0x8F2B.GLenum + GL_FUNC_SUBTRACT_EXT* = 0x800A.GLenum + GL_OUTPUT_TEXTURE_COORD14_EXT* = 0x87AB.GLenum + GL_HISTOGRAM_SINK_EXT* = 0x802D.GLenum + GL_RG_EXT* = 0x8227.GLenum + GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS* = 0x80B0.GLenum + GL_COLOR_TABLE_SCALE* = 0x80D6.GLenum + GL_CURRENT_RASTER_TEXTURE_COORDS* = 0x0B06.GLenum + GL_PIXEL_BUFFER_BARRIER_BIT* = 0x00000080.GLbitfield + GL_SHADING_LANGUAGE_VERSION* = 0x8B8C.GLenum + GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES* = 0x898F.GLenum + GL_DUAL_LUMINANCE_ALPHA4_SGIS* = 0x811C.GLenum + GL_CLAMP* = 0x2900.GLint + GL_4PASS_2_EXT* = 0x80A6.GLenum + GL_POLYGON_OFFSET_LINE* = 0x2A02.GLenum + GL_LOGIC_OP* = 0x0BF1.GLenum + GL_RENDERBUFFER_HEIGHT* = 0x8D43.GLenum + GL_COPY_INVERTED* = 0x150C.GLenum + GL_NONE* = 0.GLenum + GL_COLOR_ENCODING* = 0x8296.GLenum + GL_ONE_MINUS_CONSTANT_ALPHA_EXT* = 0x8004.GLenum + GL_DEBUG_TYPE_ERROR_KHR* = 0x824C.GLenum + GL_PIXEL_TILE_GRID_WIDTH_SGIX* = 0x8142.GLenum + GL_UNIFORM_SIZE* = 0x8A38.GLenum + GL_VERTEX_SHADER_BINDING_EXT* = 0x8781.GLenum + GL_BLEND_DST_RGB_EXT* = 0x80C8.GLenum + GL_QUADS* = 0x0007.GLenum + cGL_INT* = 0x1404.GLenum + GL_PIXEL_TEX_GEN_MODE_SGIX* = 0x832B.GLenum + GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB* = 0x8E8F.GLenum + GL_SAMPLE_ALPHA_TO_ONE_ARB* = 0x809F.GLenum + GL_RGBA32F_EXT* = 0x8814.GLenum + GL_VERTEX_PROGRAM_POSITION_MESA* = 0x8BB4.GLenum + GL_GEOMETRY_SUBROUTINE* = 0x92EB.GLenum + GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT* = 0x8DD6.GLenum + GL_IMAGE_BINDING_LAYER* = 0x8F3D.GLenum + GL_PIXEL_PACK_BUFFER_ARB* = 0x88EB.GLenum + GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER* = 0x84F1.GLenum + GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB* = 0x8623.GLenum + GL_ALPHA8UI_EXT* = 0x8D7E.GLenum + GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV* = 0x11.GLenum + GL_CAVEAT_SUPPORT* = 0x82B8.GLenum + GL_ACCUM* = 0x0100.GLenum + GL_DRAW_BUFFER3_NV* = 0x8828.GLenum + GL_DEBUG_TYPE_OTHER_KHR* = 0x8251.GLenum + GL_TESS_GEN_SPACING* = 0x8E77.GLenum + GL_FLOAT_MAT4x2* = 0x8B69.GLenum + GL_TEXTURE_GEN_STR_OES* = 0x8D60.GLenum + GL_NUM_COMPATIBLE_SUBROUTINES* = 0x8E4A.GLenum + GL_CLIP_DISTANCE1* = 0x3001.GLenum + GL_DEPTH_COMPONENT32_SGIX* = 0x81A7.GLenum + GL_FRAMEZOOM_SGIX* = 0x818B.GLenum + GL_COLOR_ATTACHMENT14_EXT* = 0x8CEE.GLenum + GL_POLYGON_TOKEN* = 0x0703.GLenum + GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE* = 0x8213.GLenum + GL_DRAW_BUFFER2_EXT* = 0x8827.GLenum + GL_MATRIX_INDEX_ARRAY_TYPE_OES* = 0x8847.GLenum + GL_HISTOGRAM_LUMINANCE_SIZE_EXT* = 0x802C.GLenum + GL_DEPTH_BOUNDS_EXT* = 0x8891.GLenum + GL_TEXTURE24* = 0x84D8.GLenum + GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES* = 0x8A43.GLenum + GL_MAX_PATCH_VERTICES* = 0x8E7D.GLenum + GL_COMPILE_STATUS* = 0x8B81.GLenum + GL_MODELVIEW4_ARB* = 0x8724.GLenum + GL_SHADER_BINARY_VIV* = 0x8FC4.GLenum + GL_CON_10_ATI* = 0x894B.GLenum + GL_FRAGMENT_LIGHT5_SGIX* = 0x8411.GLenum + GL_CONVOLUTION_1D_EXT* = 0x8010.GLenum + GL_CONSTANT_BORDER_HP* = 0x8151.GLenum + GL_SAMPLE_BUFFERS* = 0x80A8.GLenum + GL_RGB8UI* = 0x8D7D.GLenum + GL_FRAGMENT_MATERIAL_EXT* = 0x8349.GLenum + GL_OP_RECIP_EXT* = 0x8794.GLenum + GL_SHADER_OPERATION_NV* = 0x86DF.GLenum + GL_COMPUTE_SUBROUTINE_UNIFORM* = 0x92F3.GLenum + GL_VIDEO_BUFFER_PITCH_NV* = 0x9028.GLenum + GL_UNKNOWN_CONTEXT_RESET_ARB* = 0x8255.GLenum + GL_COLOR_ATTACHMENT3_EXT* = 0x8CE3.GLenum + GL_QUERY_WAIT* = 0x8E13.GLenum + GL_SOURCE1_RGB* = 0x8581.GLenum + GL_DELETE_STATUS* = 0x8B80.GLenum + GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB* = 0x8243.GLenum + GL_HILO8_NV* = 0x885E.GLenum + GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT* = 0x906A.GLenum + GL_LUMINANCE_ALPHA_FLOAT16_APPLE* = 0x881F.GLenum + GL_LUMINANCE16_SNORM* = 0x9019.GLenum + GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX* = 0x8178.GLenum + GL_RENDER* = 0x1C00.GLenum + GL_RED_INTEGER* = 0x8D94.GLenum + GL_DEBUG_TYPE_ERROR_ARB* = 0x824C.GLenum + GL_IMAGE_BINDING_ACCESS* = 0x8F3E.GLenum + GL_COVERAGE_COMPONENT_NV* = 0x8ED0.GLenum + GL_TEXTURE_BINDING_BUFFER_EXT* = 0x8C2C.GLenum + GL_MAX_PROGRAM_PATCH_ATTRIBS_NV* = 0x86D8.GLenum + GL_DUAL_LUMINANCE12_SGIS* = 0x8116.GLenum + GL_QUAD_ALPHA8_SGIS* = 0x811F.GLenum + GL_COMPRESSED_RED_GREEN_RGTC2_EXT* = 0x8DBD.GLenum + GL_PACK_INVERT_MESA* = 0x8758.GLenum + GL_OUTPUT_TEXTURE_COORD11_EXT* = 0x87A8.GLenum + GL_DYNAMIC_DRAW_ARB* = 0x88E8.GLenum + GL_RGB565_OES* = 0x8D62.GLenum + GL_LINE* = 0x1B01.GLenum + GL_T2F_V3F* = 0x2A27.GLenum + GL_DIFFUSE* = 0x1201.GLenum + GL_FOG_COORDINATE_SOURCE* = 0x8450.GLenum + GL_TEXTURE_1D_ARRAY_EXT* = 0x8C18.GLenum + GL_TEXTURE_RECTANGLE_NV* = 0x84F5.GLenum + GL_STENCIL_INDEX4_EXT* = 0x8D47.GLenum + GL_VERTEX_PROGRAM_TWO_SIDE* = 0x8643.GLenum + GL_REDUCE* = 0x8016.GLenum + GL_DEBUG_CALLBACK_USER_PARAM_KHR* = 0x8245.GLenum + GL_DEBUG_LOGGED_MESSAGES_AMD* = 0x9145.GLenum + GL_FONT_UNITS_PER_EM_BIT_NV* = 0x00100000.GLbitfield + GL_INVALID_FRAMEBUFFER_OPERATION_EXT* = 0x0506.GLenum + GL_NORMAL_ARRAY_BUFFER_BINDING_ARB* = 0x8897.GLenum + GL_SAMPLE_MASK_INVERT_SGIS* = 0x80AB.GLenum + GL_MAX_SHADER_BUFFER_ADDRESS_NV* = 0x8F35.GLenum + GL_PIXEL_MAP_I_TO_A* = 0x0C75.GLenum + GL_MINOR_VERSION* = 0x821C.GLenum + GL_TEXTURE_BUFFER_EXT* = 0x8C2A.GLenum + GL_SKIP_COMPONENTS4_NV* = -3 + GL_FLOAT16_NV* = 0x8FF8.GLenum + GL_FEEDBACK_BUFFER_TYPE* = 0x0DF2.GLenum + GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT* = 0x8C72.GLenum + GL_REG_6_ATI* = 0x8927.GLenum + GL_EDGE_FLAG_ARRAY_LIST_IBM* = 103075.GLenum + GL_MATRIX26_ARB* = 0x88DA.GLenum + GL_ALPHA16* = 0x803E.GLenum + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME* = 0x8CD1.GLenum + GL_HISTOGRAM_ALPHA_SIZE* = 0x802B.GLenum + GL_COLOR_MATRIX_STACK_DEPTH* = 0x80B2.GLenum + GL_INTERNALFORMAT_GREEN_TYPE* = 0x8279.GLenum + GL_YCRCBA_SGIX* = 0x8319.GLenum + GL_VIEW_CLASS_48_BITS* = 0x82C7.GLenum + GL_VERTEX_ATTRIB_ARRAY3_NV* = 0x8653.GLenum + GL_CLIENT_STORAGE_BIT* = 0x0200.GLbitfield + GL_MIN_SAMPLE_SHADING_VALUE_ARB* = 0x8C37.GLenum + GL_PROXY_TEXTURE_CUBE_MAP* = 0x851B.GLenum + GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES* = 0x8F39.GLenum + GL_TEXTURE15* = 0x84CF.GLenum + GL_COLOR* = 0x1800.GLenum + GL_LIGHT1* = 0x4001.GLenum + GL_LUMINANCE_ALPHA16F_EXT* = 0x881F.GLenum + GL_TEXTURE_VIEW_NUM_LAYERS* = 0x82DE.GLenum + GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS* = 0x8E82.GLenum + GL_INTERLEAVED_ATTRIBS_NV* = 0x8C8C.GLenum + GL_INT_SAMPLER_BUFFER_EXT* = 0x8DD0.GLenum + GL_EVAL_VERTEX_ATTRIB14_NV* = 0x86D4.GLenum + GL_FRAGMENT_PROGRAM_CALLBACK_MESA* = 0x8BB1.GLenum + GL_EMISSION* = 0x1600.GLenum + GL_WEIGHT_ARRAY_STRIDE_ARB* = 0x86AA.GLenum + GL_ACTIVE_VARIABLES* = 0x9305.GLenum + GL_TIMEOUT_IGNORED* = 0xFFFFFFFFFFFFFFFF.GLenum + GL_VERTEX_STREAM5_ATI* = 0x8771.GLenum + GL_INDEX_ARRAY_POINTER* = 0x8091.GLenum + GL_POST_COLOR_MATRIX_ALPHA_SCALE* = 0x80B7.GLenum + GL_TESS_CONTROL_SHADER* = 0x8E88.GLenum + GL_POLYGON_MODE* = 0x0B40.GLenum + GL_ASYNC_DRAW_PIXELS_SGIX* = 0x835D.GLenum + GL_RGBA16_SNORM* = 0x8F9B.GLenum + GL_TEXTURE_NORMAL_EXT* = 0x85AF.GLenum + GL_REG_22_ATI* = 0x8937.GLenum + GL_FRAMEBUFFER_DEFAULT_WIDTH* = 0x9310.GLenum + GL_TEXCOORD1_BIT_PGI* = 0x10000000.GLbitfield + GL_REFERENCE_PLANE_EQUATION_SGIX* = 0x817E.GLenum + GL_COLOR_ALPHA_PAIRING_ATI* = 0x8975.GLenum + GL_SINGLE_COLOR* = 0x81F9.GLenum + GL_MODELVIEW21_ARB* = 0x8735.GLenum + GL_FORMAT_SUBSAMPLE_24_24_OML* = 0x8982.GLenum + GL_SOURCE1_ALPHA* = 0x8589.GLenum + GL_LINEARLIGHT_NV* = 0x92A7.GLenum + GL_REG_2_ATI* = 0x8923.GLenum + GL_QUERY_RESULT_AVAILABLE* = 0x8867.GLenum + GL_PERSPECTIVE_CORRECTION_HINT* = 0x0C50.GLenum + GL_COMBINE_ALPHA_ARB* = 0x8572.GLenum + GL_HISTOGRAM_ALPHA_SIZE_EXT* = 0x802B.GLenum + GL_SIGNED_RGB8_NV* = 0x86FF.GLenum + GL_DEPTH_TEXTURE_MODE_ARB* = 0x884B.GLenum + GL_PRESENT_DURATION_NV* = 0x8E2B.GLenum + GL_TRIANGLES_ADJACENCY_ARB* = 0x000C.GLenum + GL_TEXTURE_BUFFER_OFFSET* = 0x919D.GLenum + GL_PROGRAM_STRING_ARB* = 0x8628.GLenum + GL_UNSIGNED_INT_IMAGE_1D_EXT* = 0x9062.GLenum + GL_COLOR_ATTACHMENT2* = 0x8CE2.GLenum + GL_DOT_PRODUCT_TEXTURE_2D_NV* = 0x86EE.GLenum + GL_QUERY_BUFFER* = 0x9192.GLenum + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z* = 0x851A.GLenum + GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX* = 0x8187.GLenum + GL_FULL_SUPPORT* = 0x82B7.GLenum + GL_MAX_PROGRAM_ENV_PARAMETERS_ARB* = 0x88B5.GLenum + GL_MAX_COMPUTE_WORK_GROUP_COUNT* = 0x91BE.GLenum + GL_DEBUG_TYPE_PERFORMANCE* = 0x8250.GLenum + GL_DRAW_BUFFER12_EXT* = 0x8831.GLenum + GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD* = 0x9003.GLenum + GL_CURRENT_FOG_COORDINATE* = 0x8453.GLenum + GL_INTENSITY_EXT* = 0x8049.GLenum + GL_TRANSPOSE_NV* = 0x862C.GLenum + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV* = 0x8C4F.GLenum + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS* = 0x8C80.GLenum + GL_COLOR_ARRAY_POINTER_EXT* = 0x8090.GLenum + GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT* = 0x8C2D.GLenum + GL_GEOMETRY_VERTICES_OUT_ARB* = 0x8DDA.GLenum + GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV* = 0x0F.GLenum + GL_OP_INDEX_EXT* = 0x8782.GLenum + GL_REG_1_ATI* = 0x8922.GLenum + GL_OFFSET* = 0x92FC.GLenum + GL_PATH_COVER_DEPTH_FUNC_NV* = 0x90BF.GLenum + GL_UNPACK_COMPRESSED_BLOCK_DEPTH* = 0x9129.GLenum + GL_POLYGON_OFFSET_UNITS* = 0x2A00.GLenum + GL_INDEX_TEST_FUNC_EXT* = 0x81B6.GLenum + GL_POINT_SMOOTH* = 0x0B10.GLenum + GL_SCALEBIAS_HINT_SGIX* = 0x8322.GLenum + GL_COMPRESSED_RGBA_ASTC_5x4_KHR* = 0x93B1.GLenum + GL_SEPARATE_SPECULAR_COLOR* = 0x81FA.GLenum + GL_VERTEX_ATTRIB_ARRAY14_NV* = 0x865E.GLenum + GL_INTENSITY16_EXT* = 0x804D.GLenum + GL_R8_SNORM* = 0x8F94.GLenum + GL_DEBUG_LOGGED_MESSAGES* = 0x9145.GLenum + GL_ALPHA8I_EXT* = 0x8D90.GLenum + GL_OPERAND2_RGB* = 0x8592.GLenum + GL_EMBOSS_LIGHT_NV* = 0x855D.GLenum + GL_EDGE_FLAG_ARRAY_STRIDE_EXT* = 0x808C.GLenum + GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV* = 0x88FD.GLenum + GL_NUM_LOOPBACK_COMPONENTS_ATI* = 0x8974.GLenum + GL_DEBUG_SOURCE_APPLICATION_KHR* = 0x824A.GLenum + GL_COMPRESSED_RGB_S3TC_DXT1_EXT* = 0x83F0.GLenum + GL_DEBUG_SOURCE_OTHER_ARB* = 0x824B.GLenum + cGL_DOUBLE* = 0x140A.GLenum + GL_STENCIL_TEST_TWO_SIDE_EXT* = 0x8910.GLenum + GL_MIN_PROGRAM_TEXEL_OFFSET* = 0x8904.GLenum + GL_3DC_X_AMD* = 0x87F9.GLenum + GL_FLOAT_RGB32_NV* = 0x8889.GLenum + GL_SECONDARY_COLOR_ARRAY_POINTER_EXT* = 0x845D.GLenum + GL_OPERAND2_ALPHA_ARB* = 0x859A.GLenum + GL_IMAGE_3D* = 0x904E.GLenum + GL_SECONDARY_COLOR_ARRAY_SIZE* = 0x845A.GLenum + GL_RELEASED_APPLE* = 0x8A19.GLenum + GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM* = 0x8FB3.GLenum + GL_FRAMEBUFFER_DEFAULT_LAYERS* = 0x9312.GLenum + GL_INTENSITY* = 0x8049.GLenum + GL_RENDERBUFFER_BLUE_SIZE_OES* = 0x8D52.GLenum + GL_FLOAT_RGB_NV* = 0x8882.GLenum + GL_ARRAY_ELEMENT_LOCK_FIRST_EXT* = 0x81A8.GLenum + GL_CON_4_ATI* = 0x8945.GLenum + GL_ROUND_NV* = 0x90A4.GLenum + GL_CLIP_DISTANCE2* = 0x3002.GLenum + GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB* = 0x880B.GLenum + GL_PROGRAM_ERROR_STRING_ARB* = 0x8874.GLenum + GL_STORAGE_CACHED_APPLE* = 0x85BE.GLenum + GL_LIGHTEN_NV* = 0x9298.GLenum + GL_TEXTURE23* = 0x84D7.GLenum + GL_SAMPLER_CUBE_SHADOW* = 0x8DC5.GLenum + GL_VERTEX_PROGRAM_ARB* = 0x8620.GLenum + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT* = 0x8C4E.GLenum + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB* = 0x851A.GLenum + GL_RENDERBUFFER_SAMPLES* = 0x8CAB.GLenum + GL_RENDERBUFFER_STENCIL_SIZE* = 0x8D55.GLenum + GL_VIRTUAL_PAGE_SIZE_INDEX_ARB* = 0x91A7.GLenum + GL_CLIP_PLANE5* = 0x3005.GLenum + GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT* = 0x8510.GLenum + GL_COLOR_BUFFER_BIT5_QCOM* = 0x00000020.GLbitfield + GL_DOUBLE_MAT2x3_EXT* = 0x8F49.GLenum + GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS* = 0x8A42.GLenum + GL_COLOR_ATTACHMENT8_EXT* = 0x8CE8.GLenum + GL_UNIFORM_BUFFER_BINDING_EXT* = 0x8DEF.GLenum + GL_MATRIX8_ARB* = 0x88C8.GLenum + GL_COUNTER_TYPE_AMD* = 0x8BC0.GLenum + GL_INT8_VEC3_NV* = 0x8FE2.GLenum + GL_TEXTURE_BINDING_3D_OES* = 0x806A.GLenum + GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX* = 0x8311.GLenum + GL_IMAGE_BINDING_LEVEL* = 0x8F3B.GLenum + GL_STENCIL_BACK_FAIL_ATI* = 0x8801.GLenum + GL_TRANSFORM_FEEDBACK_ATTRIBS_NV* = 0x8C7E.GLenum + GL_COLOR_TABLE_INTENSITY_SIZE* = 0x80DF.GLenum + GL_TEXTURE_2D_BINDING_EXT* = 0x8069.GLenum + GL_CW* = 0x0900.GLenum + GL_COLOR_ATTACHMENT6* = 0x8CE6.GLenum + GL_R32UI* = 0x8236.GLenum + GL_PROXY_TEXTURE_3D* = 0x8070.GLenum + GL_FLOAT_VEC2_ARB* = 0x8B50.GLenum + GL_C3F_V3F* = 0x2A24.GLenum + GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV* = 0x8DA0.GLenum + GL_EVAL_VERTEX_ATTRIB11_NV* = 0x86D1.GLenum + GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV* = 0x8520.GLenum + GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES* = 0x8CDC.GLenum + GL_MAX_VIEWPORT_DIMS* = 0x0D3A.GLenum + GL_STENCIL_CLEAR_TAG_VALUE_EXT* = 0x88F3.GLenum + GL_TEXTURE_BUFFER_FORMAT_ARB* = 0x8C2E.GLenum + GL_PROGRAM_NATIVE_PARAMETERS_ARB* = 0x88AA.GLenum + GL_FLOAT_MAT3x2* = 0x8B67.GLenum + GL_BLUE_BIT_ATI* = 0x00000004.GLbitfield + GL_COLOR_ATTACHMENT6_NV* = 0x8CE6.GLenum + GL_AND_INVERTED* = 0x1504.GLenum + GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS* = 0x90D7.GLenum + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR* = 0x93D0.GLenum + GL_PACK_COMPRESSED_BLOCK_DEPTH* = 0x912D.GLenum + GL_TEXTURE_COMPARE_SGIX* = 0x819A.GLenum + GL_SYNC_CL_EVENT_COMPLETE_ARB* = 0x8241.GLenum + GL_DEBUG_TYPE_PORTABILITY* = 0x824F.GLenum + GL_IMAGE_BINDING_FORMAT* = 0x906E.GLenum + GL_RESAMPLE_DECIMATE_OML* = 0x8989.GLenum + GL_MAX_PROGRAM_TEMPORARIES_ARB* = 0x88A5.GLenum + GL_ALL_SHADER_BITS* = 0xFFFFFFFF.GLbitfield + GL_TRANSFORM_FEEDBACK_VARYING* = 0x92F4.GLenum + GL_TRANSFORM_FEEDBACK_BUFFER_BINDING* = 0x8C8F.GLenum + GL_ACTIVE_STENCIL_FACE_EXT* = 0x8911.GLenum + GL_MAP1_VERTEX_ATTRIB4_4_NV* = 0x8664.GLenum + GL_LINK_STATUS* = 0x8B82.GLenum + GL_SYNC_FLUSH_COMMANDS_BIT* = 0x00000001.GLbitfield + GL_BLEND* = 0x0BE2.GLenum + GL_OUTPUT_TEXTURE_COORD12_EXT* = 0x87A9.GLenum + GL_DRAW_BUFFER11_ARB* = 0x8830.GLenum + GL_OBJECT_BUFFER_USAGE_ATI* = 0x8765.GLenum + GL_COLORDODGE_NV* = 0x9299.GLenum + GL_SHADER_IMAGE_LOAD* = 0x82A4.GLenum + GL_EMBOSS_CONSTANT_NV* = 0x855E.GLenum + GL_MAP_TESSELLATION_NV* = 0x86C2.GLenum + GL_MAX_DRAW_BUFFERS_EXT* = 0x8824.GLenum + GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT* = 0x850E.GLenum + GL_TEXTURE_ENV_COLOR* = 0x2201.GLenum + GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER* = 0x8A46.GLenum + GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV* = 0x86F2.GLenum + GL_QUERY_KHR* = 0x82E3.GLenum + GL_RG* = 0x8227.GLenum + GL_MAX_TEXTURE_SIZE* = 0x0D33.GLenum + GL_TEXTURE_NUM_LEVELS_QCOM* = 0x8BD9.GLenum + GL_MAP2_VERTEX_ATTRIB3_4_NV* = 0x8673.GLenum + GL_LUMINANCE_FLOAT32_APPLE* = 0x8818.GLenum + GL_MAP2_VERTEX_ATTRIB7_4_NV* = 0x8677.GLenum + GL_GEOMETRY_SHADER_ARB* = 0x8DD9.GLenum + GL_SYNC_FENCE_APPLE* = 0x9116.GLenum + GL_SAMPLE_MASK_VALUE* = 0x8E52.GLenum + GL_PROXY_TEXTURE_RECTANGLE_NV* = 0x84F7.GLenum + GL_DEPTH_FUNC* = 0x0B74.GLenum + GL_S* = 0x2000.GLenum + GL_CONSTANT_COLOR_EXT* = 0x8001.GLenum + GL_MAX_PROGRAM_LOOP_COUNT_NV* = 0x88F8.GLenum + GL_VIEW_COMPATIBILITY_CLASS* = 0x82B6.GLenum + GL_INT_SAMPLER_BUFFER_AMD* = 0x9002.GLenum + GL_COMPRESSED_SRGB* = 0x8C48.GLenum + GL_PROGRAM_SEPARABLE_EXT* = 0x8258.GLenum + GL_FOG_FUNC_POINTS_SGIS* = 0x812B.GLenum + GL_MITER_TRUNCATE_NV* = 0x90A8.GLenum + GL_POLYGON_OFFSET_POINT* = 0x2A01.GLenum + GL_SRGB_READ* = 0x8297.GLenum + GL_INDEX_ARRAY_ADDRESS_NV* = 0x8F24.GLenum + GL_MAX_FRAMEBUFFER_WIDTH* = 0x9315.GLenum + GL_COMPRESSED_RED_RGTC1_EXT* = 0x8DBB.GLenum + GL_RGB_INTEGER_EXT* = 0x8D98.GLenum + GL_OP_NEGATE_EXT* = 0x8783.GLenum + GL_POINT_SIZE_MAX_ARB* = 0x8127.GLenum + GL_TEXTURE_DEFORMATION_BIT_SGIX* = 0x00000001.GLbitfield + GL_SIGNED_LUMINANCE8_NV* = 0x8702.GLenum + GL_OPERAND2_RGB_EXT* = 0x8592.GLenum + GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT* = 0x8337.GLenum + GL_RECIP_ADD_SIGNED_ALPHA_IMG* = 0x8C05.GLenum + GL_VERTEX_STREAM7_ATI* = 0x8773.GLenum + GL_MODELVIEW1_STACK_DEPTH_EXT* = 0x8502.GLenum + GL_DYNAMIC_DRAW* = 0x88E8.GLenum + GL_DRAW_BUFFER15_EXT* = 0x8834.GLenum + GL_TEXTURE_COMPARE_OPERATOR_SGIX* = 0x819B.GLenum + GL_SQUARE_NV* = 0x90A3.GLenum + GL_COMPRESSED_SRGB_S3TC_DXT1_EXT* = 0x8C4C.GLenum + GL_DRAW_BUFFER0_ARB* = 0x8825.GLenum + GL_GPU_OPTIMIZED_QCOM* = 0x8FB2.GLenum + GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT* = 0x850F.GLenum + GL_SPRITE_EYE_ALIGNED_SGIX* = 0x814E.GLenum + GL_MAP1_VERTEX_ATTRIB3_4_NV* = 0x8663.GLenum + GL_SAMPLE_MASK_SGIS* = 0x80A0.GLenum + GL_TEXTURE_SAMPLES* = 0x9106.GLenum + GL_AND_REVERSE* = 0x1502.GLenum + GL_COMBINER4_NV* = 0x8554.GLenum + GL_FONT_Y_MIN_BOUNDS_BIT_NV* = 0x00020000.GLbitfield + GL_VIEW_CLASS_32_BITS* = 0x82C8.GLenum + GL_BGRA_EXT* = 0x80E1.GLenum + GL_TANGENT_ARRAY_TYPE_EXT* = 0x843E.GLenum + GL_BLEND_EQUATION_RGB_OES* = 0x8009.GLenum + GL_TRANSPOSE_TEXTURE_MATRIX_ARB* = 0x84E5.GLenum + GL_GET_TEXTURE_IMAGE_FORMAT* = 0x8291.GLenum + GL_PACK_MAX_COMPRESSED_SIZE_SGIX* = 0x831B.GLenum + GL_UNIFORM_ARRAY_STRIDE* = 0x8A3C.GLenum + GL_REFLECTION_MAP_ARB* = 0x8512.GLenum + GL_RGBA_FLOAT16_ATI* = 0x881A.GLenum + GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS* = 0x8E83.GLenum + GL_RED_BITS* = 0x0D52.GLenum + GL_VERTEX_TEXTURE* = 0x829B.GLenum + GL_UNSIGNALED_APPLE* = 0x9118.GLenum + GL_RENDERBUFFER_ALPHA_SIZE_OES* = 0x8D53.GLenum + GL_DRAW_BUFFER14_NV* = 0x8833.GLenum + GL_STREAM_COPY_ARB* = 0x88E2.GLenum + GL_SECONDARY_COLOR_ARRAY_TYPE* = 0x845B.GLenum + GL_MATRIX22_ARB* = 0x88D6.GLenum + GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV* = 0x8533.GLenum + GL_IUI_N3F_V3F_EXT* = 0x81B0.GLenum + GL_SPARE0_NV* = 0x852E.GLenum + GL_FOG_COORD* = 0x8451.GLenum + GL_DRAW_BUFFER8_ARB* = 0x882D.GLenum + GL_MATRIX24_ARB* = 0x88D8.GLenum + GL_MAX_DEBUG_MESSAGE_LENGTH_AMD* = 0x9143.GLenum + GL_POST_COLOR_MATRIX_BLUE_SCALE* = 0x80B6.GLenum + GL_TEXTURE_HEIGHT_QCOM* = 0x8BD3.GLenum + GL_NUM_FRAGMENT_REGISTERS_ATI* = 0x896E.GLenum + GL_IMAGE_3D_EXT* = 0x904E.GLenum + GL_TEXTURE_FILTER_CONTROL* = 0x8500.GLenum + GL_VIDEO_BUFFER_NV* = 0x9020.GLenum + GL_CURRENT_MATRIX_INDEX_ARB* = 0x8845.GLenum + GL_STENCIL_BUFFER_BIT4_QCOM* = 0x00100000.GLbitfield + GL_SIGNED_INTENSITY_NV* = 0x8707.GLenum + GL_RASTERIZER_DISCARD_NV* = 0x8C89.GLenum + GL_MAX_DEFORMATION_ORDER_SGIX* = 0x8197.GLenum + GL_SAMPLES_3DFX* = 0x86B4.GLenum + GL_DOT_PRODUCT_PASS_THROUGH_NV* = 0x885B.GLenum + GL_RGB_SCALE_EXT* = 0x8573.GLenum + GL_TEXTURE_UNSIGNED_REMAP_MODE_NV* = 0x888F.GLenum + GL_MIRROR_CLAMP_TO_EDGE_EXT* = 0x8743.GLint + GL_NATIVE_GRAPHICS_END_HINT_PGI* = 0x1A204.GLenum + GL_UNPACK_CLIENT_STORAGE_APPLE* = 0x85B2.GLenum + GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER* = 0x8CDC.GLenum + GL_FOG_START* = 0x0B63.GLenum + GL_MAX_PROGRAM_CALL_DEPTH_NV* = 0x88F5.GLenum + GL_MODELVIEW18_ARB* = 0x8732.GLenum + GL_MAX_FRAMEZOOM_FACTOR_SGIX* = 0x818D.GLenum + GL_EDGE_FLAG_ARRAY_POINTER* = 0x8093.GLenum + GL_GREEN_INTEGER* = 0x8D95.GLenum + GL_IMAGE_BUFFER* = 0x9051.GLenum + GL_PROJECTION* = 0x1701.GLenum + GL_UNSIGNED_INT_VEC4_EXT* = 0x8DC8.GLenum + GL_PALETTE8_RGB5_A1_OES* = 0x8B99.GLenum + GL_RENDERBUFFER_SAMPLES_EXT* = 0x8CAB.GLenum + GL_TEXTURE3* = 0x84C3.GLenum + GL_CURRENT_RASTER_INDEX* = 0x0B05.GLenum + GL_INTERLEAVED_ATTRIBS_EXT* = 0x8C8C.GLenum + GL_STENCIL_BACK_WRITEMASK* = 0x8CA5.GLenum + GL_POINT_SPRITE_ARB* = 0x8861.GLenum + GL_TRANSPOSE_TEXTURE_MATRIX* = 0x84E5.GLenum + GL_DRAW_BUFFER1_ARB* = 0x8826.GLenum + GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS* = 0x92D0.GLenum + GL_DEPTH_ATTACHMENT_OES* = 0x8D00.GLenum + GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG* = 0x9137.GLenum + GL_SRGB_ALPHA* = 0x8C42.GLenum + GL_UNSIGNED_INT64_ARB* = 0x140F.GLenum + GL_LAST_VERTEX_CONVENTION_EXT* = 0x8E4E.GLenum + GL_IMAGE_CLASS_1_X_8* = 0x82C1.GLenum + GL_COMPRESSED_RGBA_S3TC_DXT1_EXT* = 0x83F1.GLenum + GL_REFLECTION_MAP* = 0x8512.GLenum + GL_MAX_IMAGE_UNITS_EXT* = 0x8F38.GLenum + GL_DEPTH_STENCIL_NV* = 0x84F9.GLenum + GL_PROGRAM_TEX_INDIRECTIONS_ARB* = 0x8807.GLenum + GL_BINNING_CONTROL_HINT_QCOM* = 0x8FB0.GLenum + GL_T4F_V4F* = 0x2A28.GLenum + GL_FLOAT_VEC4* = 0x8B52.GLenum + GL_CONVEX_HULL_NV* = 0x908B.GLenum + GL_TEXTURE26_ARB* = 0x84DA.GLenum + GL_INDEX_BIT_PGI* = 0x00080000.GLbitfield + GL_TEXTURE_COORD_ARRAY_TYPE_EXT* = 0x8089.GLenum + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES* = 0x8CD2.GLenum + GL_MAX_ARRAY_TEXTURE_LAYERS* = 0x88FF.GLenum + GL_COLOR_ATTACHMENT4_EXT* = 0x8CE4.GLenum + GL_SAMPLE_COVERAGE_VALUE_ARB* = 0x80AA.GLenum + GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE* = 0x8A08.GLenum + GL_MAX_LAYERS* = 0x8281.GLenum + GL_FOG_COORDINATE_ARRAY_POINTER_EXT* = 0x8456.GLenum + GL_INDEX_TEST_REF_EXT* = 0x81B7.GLenum + GL_GREEN_BIT_ATI* = 0x00000002.GLbitfield + GL_STRICT_SCISSOR_HINT_PGI* = 0x1A218.GLenum + GL_MAP2_VERTEX_ATTRIB4_4_NV* = 0x8674.GLenum + GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT* = 0x8DE0.GLenum + GL_OUTPUT_TEXTURE_COORD31_EXT* = 0x87BC.GLenum + GL_XOR* = 0x1506.GLenum + GL_VIDEO_CAPTURE_FRAME_WIDTH_NV* = 0x9038.GLenum + GL_RGBA* = 0x1908.GLenum + GL_TEXTURE_TARGET* = 0x1006.GLenum + GL_QUERY_TARGET* = 0x82EA.GLenum + +{.deprecated: [ + cGL_TRANSFORM_FEEDBACK_VARYINGS_EXT: GL_TRANSFORM_FEEDBACK_VARYINGS_EXT, + cGL_BLEND_EQUATION_EXT: GL_BLEND_EQUATION_EXT, + cGL_VERTEX_BLEND_ARB: GL_VERTEX_BLEND_ARB, + cGL_TESSELLATION_MODE_AMD: GL_TESSELLATION_MODE_AMD, + cGL_POLYGON_OFFSET_EXT: GL_POLYGON_OFFSET_EXT, + cGL_BLEND_COLOR_EXT: GL_BLEND_COLOR_EXT, + cGL_TRANSFORM_FEEDBACK_VARYINGS_NV: GL_TRANSFORM_FEEDBACK_VARYINGS_NV, + cGL_COLOR_MATERIAL: GL_COLOR_MATERIAL, + cGL_READ_BUFFER_NV: GL_READ_BUFFER_NV, + cGL_FOG_FUNC_SGIS: GL_FOG_FUNC_SGIS, + cGL_HISTOGRAM_EXT: GL_HISTOGRAM_EXT, + cGL_LINE_WIDTH: GL_LINE_WIDTH, + cGL_PROVOKING_VERTEX: GL_PROVOKING_VERTEX, + cGL_SHADE_MODEL: GL_SHADE_MODEL, + cGL_FRONT_FACE: GL_FRONT_FACE, + cGL_PRIMITIVE_RESTART_INDEX: GL_PRIMITIVE_RESTART_INDEX, + cGL_READ_PIXELS: GL_READ_PIXELS, + cGL_VIEWPORT: GL_VIEWPORT, + cGL_DEPTH_RANGE: GL_DEPTH_RANGE, + cGL_COLOR_TABLE_SGI: GL_COLOR_TABLE_SGI, + cGL_CLEAR: GL_CLEAR, + cGL_ASYNC_MARKER_SGIX: GL_ASYNC_MARKER_SGIX, + cGL_ACTIVE_TEXTURE_ARB: GL_ACTIVE_TEXTURE_ARB, + cGL_SAMPLE_COVERAGE: GL_SAMPLE_COVERAGE, + cGL_BLEND_EQUATION_OES: GL_BLEND_EQUATION_OES, + cGL_MATRIX_MODE: GL_MATRIX_MODE, + cGL_TRANSFORM_FEEDBACK_VARYINGS: GL_TRANSFORM_FEEDBACK_VARYINGS, + cGL_SAMPLE_COVERAGE_ARB: GL_SAMPLE_COVERAGE_ARB, + cGL_TRACK_MATRIX_NV: GL_TRACK_MATRIX_NV, + cGL_COMBINER_INPUT_NV: GL_COMBINER_INPUT_NV, + cGL_TESSELLATION_FACTOR_AMD: GL_TESSELLATION_FACTOR_AMD, + cGL_BLEND_EQUATION: GL_BLEND_EQUATION, + cGL_CULL_FACE: GL_CULL_FACE, + cGL_HISTOGRAM: GL_HISTOGRAM, + cGL_PRIMITIVE_RESTART_INDEX_NV: GL_PRIMITIVE_RESTART_INDEX_NV, + cGL_SAMPLE_MASK_EXT: GL_SAMPLE_MASK_EXT, + cGL_RENDER_MODE: GL_RENDER_MODE, + cGL_CURRENT_PALETTE_MATRIX_OES: GL_CURRENT_PALETTE_MATRIX_OES, + cGL_VERTEX_ATTRIB_BINDING: GL_VERTEX_ATTRIB_BINDING, + cGL_TEXTURE_LIGHT_EXT: GL_TEXTURE_LIGHT_EXT, + cGL_INDEX_MATERIAL_EXT: GL_INDEX_MATERIAL_EXT, + cGL_COLOR_TABLE: GL_COLOR_TABLE, + cGL_PATH_STENCIL_FUNC_NV: GL_PATH_STENCIL_FUNC_NV, + cGL_EDGE_FLAG: GL_EDGE_FLAG, + cGL_ACTIVE_TEXTURE: GL_ACTIVE_TEXTURE, + cGL_CLIENT_ACTIVE_TEXTURE_ARB: GL_CLIENT_ACTIVE_TEXTURE_ARB, + cGL_VERTEX_ARRAY_RANGE_APPLE: GL_VERTEX_ARRAY_RANGE_APPLE, + cGL_TEXTURE_VIEW: GL_TEXTURE_VIEW, + cGL_BITMAP: GL_BITMAP, + cGL_PRIMITIVE_RESTART_NV: GL_PRIMITIVE_RESTART_NV, + cGL_VERTEX_BINDING_DIVISOR: GL_VERTEX_BINDING_DIVISOR, + cGL_STENCIL_OP_VALUE_AMD: GL_STENCIL_OP_VALUE_AMD, + cGL_PROVOKING_VERTEX_EXT: GL_PROVOKING_VERTEX_EXT, + cGL_CURRENT_PALETTE_MATRIX_ARB: GL_CURRENT_PALETTE_MATRIX_ARB, + cGL_PIXEL_TEX_GEN_SGIX: GL_PIXEL_TEX_GEN_SGIX, + cGL_GENERATE_MIPMAP: GL_GENERATE_MIPMAP, + cGL_UNIFORM_BUFFER_EXT: GL_UNIFORM_BUFFER_EXT, + cGL_STENCIL_FUNC: GL_STENCIL_FUNC, + cGL_VERTEX_ARRAY_RANGE_NV: GL_VERTEX_ARRAY_RANGE_NV, + cGL_ACTIVE_PROGRAM_EXT: GL_ACTIVE_PROGRAM_EXT, + cGL_LINE_STIPPLE: GL_LINE_STIPPLE, + cGL_REFERENCE_PLANE_SGIX: GL_REFERENCE_PLANE_SGIX, + cGL_DRAW_BUFFER: GL_DRAW_BUFFER, + cGL_LIST_BASE: GL_LIST_BASE, + cGL_READ_BUFFER: GL_READ_BUFFER, + cGL_FRAGMENT_COLOR_MATERIAL_SGIX: GL_FRAGMENT_COLOR_MATERIAL_SGIX, + cGL_CLIENT_ACTIVE_TEXTURE: GL_CLIENT_ACTIVE_TEXTURE, + cGL_BLEND_COLOR: GL_BLEND_COLOR, + cGL_MINMAX_EXT: GL_MINMAX_EXT, + cGL_POINT_SIZE: GL_POINT_SIZE, + cGL_MINMAX: GL_MINMAX, + cGL_SAMPLE_PATTERN_SGIS: GL_SAMPLE_PATTERN_SGIS, + cGL_SAMPLE_PATTERN_EXT: GL_SAMPLE_PATTERN_EXT, + cGL_UNIFORM_BLOCK_BINDING: GL_UNIFORM_BLOCK_BINDING, + cGL_POLYGON_STIPPLE: GL_POLYGON_STIPPLE, + cGL_LOGIC_OP: GL_LOGIC_OP, + cGL_ACCUM: GL_ACCUM, + cGL_FRAMEZOOM_SGIX: GL_FRAMEZOOM_SGIX, + cGL_DEPTH_BOUNDS_EXT: GL_DEPTH_BOUNDS_EXT, + cGL_TEXTURE_BUFFER_EXT: GL_TEXTURE_BUFFER_EXT, + cGL_POLYGON_MODE: GL_POLYGON_MODE, + cGL_TEXTURE_NORMAL_EXT: GL_TEXTURE_NORMAL_EXT, + cGL_PROGRAM_STRING_ARB: GL_PROGRAM_STRING_ARB, + cGL_PATH_COVER_DEPTH_FUNC_NV: GL_PATH_COVER_DEPTH_FUNC_NV, + cGL_TRANSFORM_FEEDBACK_ATTRIBS_NV: GL_TRANSFORM_FEEDBACK_ATTRIBS_NV, + cGL_ACTIVE_STENCIL_FACE_EXT: GL_ACTIVE_STENCIL_FACE_EXT, + cGL_DEPTH_FUNC: GL_DEPTH_FUNC, + cGL_SAMPLE_MASK_SGIS: GL_SAMPLE_MASK_SGIS +].} diff --git a/tests/deps/opengl-1.1.0/opengl.nimble b/tests/deps/opengl-1.1.0/opengl.nimble new file mode 100644 index 000000000..ac3b8aa32 --- /dev/null +++ b/tests/deps/opengl-1.1.0/opengl.nimble @@ -0,0 +1,12 @@ +# Package + +version = "1.1.0" +author = "Andreas Rumpf" +description = "an OpenGL wrapper" +license = "MIT" + +srcDir = "src" + +# Dependencies" + +requires "nim >= 0.10.3", "x11" diff --git a/tests/deps/opengl-1.1.0/wingl.nim b/tests/deps/opengl-1.1.0/wingl.nim new file mode 100644 index 000000000..9497bffb4 --- /dev/null +++ b/tests/deps/opengl-1.1.0/wingl.nim @@ -0,0 +1,369 @@ +import opengl, windows + +{.deadCodeElim: on.} + +proc wglGetExtensionsStringARB*(hdc: HDC): cstring{.dynlib: dllname, + importc: "wglGetExtensionsStringARB".} +const + WGL_FRONT_COLOR_BUFFER_BIT_ARB* = 0x00000001 + WGL_BACK_COLOR_BUFFER_BIT_ARB* = 0x00000002 + WGL_DEPTH_BUFFER_BIT_ARB* = 0x00000004 + WGL_STENCIL_BUFFER_BIT_ARB* = 0x00000008 + +proc WinChoosePixelFormat*(DC: HDC, p2: PPixelFormatDescriptor): int{. + dynlib: "gdi32", importc: "ChoosePixelFormat".} +proc wglCreateBufferRegionARB*(hDC: HDC, iLayerPlane: TGLint, uType: TGLuint): THandle{. + dynlib: dllname, importc: "wglCreateBufferRegionARB".} +proc wglDeleteBufferRegionARB*(hRegion: THandle){.dynlib: dllname, + importc: "wglDeleteBufferRegionARB".} +proc wglSaveBufferRegionARB*(hRegion: THandle, x: TGLint, y: TGLint, + width: TGLint, height: TGLint): BOOL{. + dynlib: dllname, importc: "wglSaveBufferRegionARB".} +proc wglRestoreBufferRegionARB*(hRegion: THandle, x: TGLint, y: TGLint, + width: TGLint, height: TGLint, xSrc: TGLint, + ySrc: TGLint): BOOL{.dynlib: dllname, + importc: "wglRestoreBufferRegionARB".} +proc wglAllocateMemoryNV*(size: TGLsizei, readFrequency: TGLfloat, + writeFrequency: TGLfloat, priority: TGLfloat): PGLvoid{. + dynlib: dllname, importc: "wglAllocateMemoryNV".} +proc wglFreeMemoryNV*(pointer: PGLvoid){.dynlib: dllname, + importc: "wglFreeMemoryNV".} +const + WGL_IMAGE_BUFFER_MIN_ACCESS_I3D* = 0x00000001 + WGL_IMAGE_BUFFER_LOCK_I3D* = 0x00000002 + +proc wglCreateImageBufferI3D*(hDC: HDC, dwSize: DWORD, uFlags: UINT): PGLvoid{. + dynlib: dllname, importc: "wglCreateImageBufferI3D".} +proc wglDestroyImageBufferI3D*(hDC: HDC, pAddress: PGLvoid): BOOL{. + dynlib: dllname, importc: "wglDestroyImageBufferI3D".} +proc wglAssociateImageBufferEventsI3D*(hdc: HDC, pEvent: PHandle, + pAddress: PGLvoid, pSize: PDWORD, + count: UINT): BOOL{.dynlib: dllname, + importc: "wglAssociateImageBufferEventsI3D".} +proc wglReleaseImageBufferEventsI3D*(hdc: HDC, pAddress: PGLvoid, count: UINT): BOOL{. + dynlib: dllname, importc: "wglReleaseImageBufferEventsI3D".} +proc wglEnableFrameLockI3D*(): BOOL{.dynlib: dllname, + importc: "wglEnableFrameLockI3D".} +proc wglDisableFrameLockI3D*(): BOOL{.dynlib: dllname, + importc: "wglDisableFrameLockI3D".} +proc wglIsEnabledFrameLockI3D*(pFlag: PBOOL): BOOL{.dynlib: dllname, + importc: "wglIsEnabledFrameLockI3D".} +proc wglQueryFrameLockMasterI3D*(pFlag: PBOOL): BOOL{.dynlib: dllname, + importc: "wglQueryFrameLockMasterI3D".} +proc wglGetFrameUsageI3D*(pUsage: PGLfloat): BOOL{.dynlib: dllname, + importc: "wglGetFrameUsageI3D".} +proc wglBeginFrameTrackingI3D*(): BOOL{.dynlib: dllname, + importc: "wglBeginFrameTrackingI3D".} +proc wglEndFrameTrackingI3D*(): BOOL{.dynlib: dllname, + importc: "wglEndFrameTrackingI3D".} +proc wglQueryFrameTrackingI3D*(pFrameCount: PDWORD, pMissedFrames: PDWORD, + pLastMissedUsage: PGLfloat): BOOL{. + dynlib: dllname, importc: "wglQueryFrameTrackingI3D".} +const + WGL_NUMBER_PIXEL_FORMATS_ARB* = 0x00002000 + WGL_DRAW_TO_WINDOW_ARB* = 0x00002001 + WGL_DRAW_TO_BITMAP_ARB* = 0x00002002 + WGL_ACCELERATION_ARB* = 0x00002003 + WGL_NEED_PALETTE_ARB* = 0x00002004 + WGL_NEED_SYSTEM_PALETTE_ARB* = 0x00002005 + WGL_SWAP_LAYER_BUFFERS_ARB* = 0x00002006 + WGL_SWAP_METHOD_ARB* = 0x00002007 + WGL_NUMBER_OVERLAYS_ARB* = 0x00002008 + WGL_NUMBER_UNDERLAYS_ARB* = 0x00002009 + WGL_TRANSPARENT_ARB* = 0x0000200A + WGL_TRANSPARENT_RED_VALUE_ARB* = 0x00002037 + WGL_TRANSPARENT_GREEN_VALUE_ARB* = 0x00002038 + WGL_TRANSPARENT_BLUE_VALUE_ARB* = 0x00002039 + WGL_TRANSPARENT_ALPHA_VALUE_ARB* = 0x0000203A + WGL_TRANSPARENT_INDEX_VALUE_ARB* = 0x0000203B + WGL_SHARE_DEPTH_ARB* = 0x0000200C + WGL_SHARE_STENCIL_ARB* = 0x0000200D + WGL_SHARE_ACCUM_ARB* = 0x0000200E + WGL_SUPPORT_GDI_ARB* = 0x0000200F + WGL_SUPPORT_OPENGL_ARB* = 0x00002010 + WGL_DOUBLE_BUFFER_ARB* = 0x00002011 + WGL_STEREO_ARB* = 0x00002012 + WGL_PIXEL_TYPE_ARB* = 0x00002013 + WGL_COLOR_BITS_ARB* = 0x00002014 + WGL_RED_BITS_ARB* = 0x00002015 + WGL_RED_SHIFT_ARB* = 0x00002016 + WGL_GREEN_BITS_ARB* = 0x00002017 + WGL_GREEN_SHIFT_ARB* = 0x00002018 + WGL_BLUE_BITS_ARB* = 0x00002019 + WGL_BLUE_SHIFT_ARB* = 0x0000201A + WGL_ALPHA_BITS_ARB* = 0x0000201B + WGL_ALPHA_SHIFT_ARB* = 0x0000201C + WGL_ACCUM_BITS_ARB* = 0x0000201D + WGL_ACCUM_RED_BITS_ARB* = 0x0000201E + WGL_ACCUM_GREEN_BITS_ARB* = 0x0000201F + WGL_ACCUM_BLUE_BITS_ARB* = 0x00002020 + WGL_ACCUM_ALPHA_BITS_ARB* = 0x00002021 + WGL_DEPTH_BITS_ARB* = 0x00002022 + WGL_STENCIL_BITS_ARB* = 0x00002023 + WGL_AUX_BUFFERS_ARB* = 0x00002024 + WGL_NO_ACCELERATION_ARB* = 0x00002025 + WGL_GENERIC_ACCELERATION_ARB* = 0x00002026 + WGL_FULL_ACCELERATION_ARB* = 0x00002027 + WGL_SWAP_EXCHANGE_ARB* = 0x00002028 + WGL_SWAP_COPY_ARB* = 0x00002029 + WGL_SWAP_UNDEFINED_ARB* = 0x0000202A + WGL_TYPE_RGBA_ARB* = 0x0000202B + WGL_TYPE_COLORINDEX_ARB* = 0x0000202C + +proc wglGetPixelFormatAttribivARB*(hdc: HDC, iPixelFormat: TGLint, + iLayerPlane: TGLint, nAttributes: TGLuint, + piAttributes: PGLint, piValues: PGLint): BOOL{. + dynlib: dllname, importc: "wglGetPixelFormatAttribivARB".} +proc wglGetPixelFormatAttribfvARB*(hdc: HDC, iPixelFormat: TGLint, + iLayerPlane: TGLint, nAttributes: TGLuint, + piAttributes: PGLint, pfValues: PGLfloat): BOOL{. + dynlib: dllname, importc: "wglGetPixelFormatAttribfvARB".} +proc wglChoosePixelFormatARB*(hdc: HDC, piAttribIList: PGLint, + pfAttribFList: PGLfloat, nMaxFormats: TGLuint, + piFormats: PGLint, nNumFormats: PGLuint): BOOL{. + dynlib: dllname, importc: "wglChoosePixelFormatARB".} +const + WGL_ERROR_INVALID_PIXEL_TYPE_ARB* = 0x00002043 + WGL_ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB* = 0x00002054 + +proc wglMakeContextCurrentARB*(hDrawDC: HDC, hReadDC: HDC, hglrc: HGLRC): BOOL{. + dynlib: dllname, importc: "wglMakeContextCurrentARB".} +proc wglGetCurrentReadDCARB*(): HDC{.dynlib: dllname, + importc: "wglGetCurrentReadDCARB".} +const + WGL_DRAW_TO_PBUFFER_ARB* = 0x0000202D # WGL_DRAW_TO_PBUFFER_ARB { already defined } + WGL_MAX_PBUFFER_PIXELS_ARB* = 0x0000202E + WGL_MAX_PBUFFER_WIDTH_ARB* = 0x0000202F + WGL_MAX_PBUFFER_HEIGHT_ARB* = 0x00002030 + WGL_PBUFFER_LARGEST_ARB* = 0x00002033 + WGL_PBUFFER_WIDTH_ARB* = 0x00002034 + WGL_PBUFFER_HEIGHT_ARB* = 0x00002035 + WGL_PBUFFER_LOST_ARB* = 0x00002036 + +proc wglCreatePbufferARB*(hDC: HDC, iPixelFormat: TGLint, iWidth: TGLint, + iHeight: TGLint, piAttribList: PGLint): THandle{. + dynlib: dllname, importc: "wglCreatePbufferARB".} +proc wglGetPbufferDCARB*(hPbuffer: THandle): HDC{.dynlib: dllname, + importc: "wglGetPbufferDCARB".} +proc wglReleasePbufferDCARB*(hPbuffer: THandle, hDC: HDC): TGLint{. + dynlib: dllname, importc: "wglReleasePbufferDCARB".} +proc wglDestroyPbufferARB*(hPbuffer: THandle): BOOL{.dynlib: dllname, + importc: "wglDestroyPbufferARB".} +proc wglQueryPbufferARB*(hPbuffer: THandle, iAttribute: TGLint, piValue: PGLint): BOOL{. + dynlib: dllname, importc: "wglQueryPbufferARB".} +proc wglSwapIntervalEXT*(interval: TGLint): BOOL{.dynlib: dllname, + importc: "wglSwapIntervalEXT".} +proc wglGetSwapIntervalEXT*(): TGLint{.dynlib: dllname, + importc: "wglGetSwapIntervalEXT".} +const + WGL_BIND_TO_TEXTURE_RGB_ARB* = 0x00002070 + WGL_BIND_TO_TEXTURE_RGBA_ARB* = 0x00002071 + WGL_TEXTURE_FORMAT_ARB* = 0x00002072 + WGL_TEXTURE_TARGET_ARB* = 0x00002073 + WGL_MIPMAP_TEXTURE_ARB* = 0x00002074 + WGL_TEXTURE_RGB_ARB* = 0x00002075 + WGL_TEXTURE_RGBA_ARB* = 0x00002076 + WGL_NO_TEXTURE_ARB* = 0x00002077 + WGL_TEXTURE_CUBE_MAP_ARB* = 0x00002078 + WGL_TEXTURE_1D_ARB* = 0x00002079 + WGL_TEXTURE_2D_ARB* = 0x0000207A # WGL_NO_TEXTURE_ARB { already defined } + WGL_MIPMAP_LEVEL_ARB* = 0x0000207B + WGL_CUBE_MAP_FACE_ARB* = 0x0000207C + WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB* = 0x0000207D + WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB* = 0x0000207E + WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB* = 0x0000207F + WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB* = 0x00002080 + WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB* = 0x00002081 + WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB* = 0x00002082 + WGL_FRONT_LEFT_ARB* = 0x00002083 + WGL_FRONT_RIGHT_ARB* = 0x00002084 + WGL_BACK_LEFT_ARB* = 0x00002085 + WGL_BACK_RIGHT_ARB* = 0x00002086 + WGL_AUX0_ARB* = 0x00002087 + WGL_AUX1_ARB* = 0x00002088 + WGL_AUX2_ARB* = 0x00002089 + WGL_AUX3_ARB* = 0x0000208A + WGL_AUX4_ARB* = 0x0000208B + WGL_AUX5_ARB* = 0x0000208C + WGL_AUX6_ARB* = 0x0000208D + WGL_AUX7_ARB* = 0x0000208E + WGL_AUX8_ARB* = 0x0000208F + WGL_AUX9_ARB* = 0x00002090 + +proc wglBindTexImageARB*(hPbuffer: THandle, iBuffer: TGLint): BOOL{. + dynlib: dllname, importc: "wglBindTexImageARB".} +proc wglReleaseTexImageARB*(hPbuffer: THandle, iBuffer: TGLint): BOOL{. + dynlib: dllname, importc: "wglReleaseTexImageARB".} +proc wglSetPbufferAttribARB*(hPbuffer: THandle, piAttribList: PGLint): BOOL{. + dynlib: dllname, importc: "wglSetPbufferAttribARB".} +proc wglGetExtensionsStringEXT*(): cstring{.dynlib: dllname, + importc: "wglGetExtensionsStringEXT".} +proc wglMakeContextCurrentEXT*(hDrawDC: HDC, hReadDC: HDC, hglrc: HGLRC): BOOL{. + dynlib: dllname, importc: "wglMakeContextCurrentEXT".} +proc wglGetCurrentReadDCEXT*(): HDC{.dynlib: dllname, + importc: "wglGetCurrentReadDCEXT".} +const + WGL_DRAW_TO_PBUFFER_EXT* = 0x0000202D + WGL_MAX_PBUFFER_PIXELS_EXT* = 0x0000202E + WGL_MAX_PBUFFER_WIDTH_EXT* = 0x0000202F + WGL_MAX_PBUFFER_HEIGHT_EXT* = 0x00002030 + WGL_OPTIMAL_PBUFFER_WIDTH_EXT* = 0x00002031 + WGL_OPTIMAL_PBUFFER_HEIGHT_EXT* = 0x00002032 + WGL_PBUFFER_LARGEST_EXT* = 0x00002033 + WGL_PBUFFER_WIDTH_EXT* = 0x00002034 + WGL_PBUFFER_HEIGHT_EXT* = 0x00002035 + +proc wglCreatePbufferEXT*(hDC: HDC, iPixelFormat: TGLint, iWidth: TGLint, + iHeight: TGLint, piAttribList: PGLint): THandle{. + dynlib: dllname, importc: "wglCreatePbufferEXT".} +proc wglGetPbufferDCEXT*(hPbuffer: THandle): HDC{.dynlib: dllname, + importc: "wglGetPbufferDCEXT".} +proc wglReleasePbufferDCEXT*(hPbuffer: THandle, hDC: HDC): TGLint{. + dynlib: dllname, importc: "wglReleasePbufferDCEXT".} +proc wglDestroyPbufferEXT*(hPbuffer: THandle): BOOL{.dynlib: dllname, + importc: "wglDestroyPbufferEXT".} +proc wglQueryPbufferEXT*(hPbuffer: THandle, iAttribute: TGLint, piValue: PGLint): BOOL{. + dynlib: dllname, importc: "wglQueryPbufferEXT".} +const + WGL_NUMBER_PIXEL_FORMATS_EXT* = 0x00002000 + WGL_DRAW_TO_WINDOW_EXT* = 0x00002001 + WGL_DRAW_TO_BITMAP_EXT* = 0x00002002 + WGL_ACCELERATION_EXT* = 0x00002003 + WGL_NEED_PALETTE_EXT* = 0x00002004 + WGL_NEED_SYSTEM_PALETTE_EXT* = 0x00002005 + WGL_SWAP_LAYER_BUFFERS_EXT* = 0x00002006 + WGL_SWAP_METHOD_EXT* = 0x00002007 + WGL_NUMBER_OVERLAYS_EXT* = 0x00002008 + WGL_NUMBER_UNDERLAYS_EXT* = 0x00002009 + WGL_TRANSPARENT_EXT* = 0x0000200A + WGL_TRANSPARENT_VALUE_EXT* = 0x0000200B + WGL_SHARE_DEPTH_EXT* = 0x0000200C + WGL_SHARE_STENCIL_EXT* = 0x0000200D + WGL_SHARE_ACCUM_EXT* = 0x0000200E + WGL_SUPPORT_GDI_EXT* = 0x0000200F + WGL_SUPPORT_OPENGL_EXT* = 0x00002010 + WGL_DOUBLE_BUFFER_EXT* = 0x00002011 + WGL_STEREO_EXT* = 0x00002012 + WGL_PIXEL_TYPE_EXT* = 0x00002013 + WGL_COLOR_BITS_EXT* = 0x00002014 + WGL_RED_BITS_EXT* = 0x00002015 + WGL_RED_SHIFT_EXT* = 0x00002016 + WGL_GREEN_BITS_EXT* = 0x00002017 + WGL_GREEN_SHIFT_EXT* = 0x00002018 + WGL_BLUE_BITS_EXT* = 0x00002019 + WGL_BLUE_SHIFT_EXT* = 0x0000201A + WGL_ALPHA_BITS_EXT* = 0x0000201B + WGL_ALPHA_SHIFT_EXT* = 0x0000201C + WGL_ACCUM_BITS_EXT* = 0x0000201D + WGL_ACCUM_RED_BITS_EXT* = 0x0000201E + WGL_ACCUM_GREEN_BITS_EXT* = 0x0000201F + WGL_ACCUM_BLUE_BITS_EXT* = 0x00002020 + WGL_ACCUM_ALPHA_BITS_EXT* = 0x00002021 + WGL_DEPTH_BITS_EXT* = 0x00002022 + WGL_STENCIL_BITS_EXT* = 0x00002023 + WGL_AUX_BUFFERS_EXT* = 0x00002024 + WGL_NO_ACCELERATION_EXT* = 0x00002025 + WGL_GENERIC_ACCELERATION_EXT* = 0x00002026 + WGL_FULL_ACCELERATION_EXT* = 0x00002027 + WGL_SWAP_EXCHANGE_EXT* = 0x00002028 + WGL_SWAP_COPY_EXT* = 0x00002029 + WGL_SWAP_UNDEFINED_EXT* = 0x0000202A + WGL_TYPE_RGBA_EXT* = 0x0000202B + WGL_TYPE_COLORINDEX_EXT* = 0x0000202C + +proc wglGetPixelFormatAttribivEXT*(hdc: HDC, iPixelFormat: TGLint, + iLayerPlane: TGLint, nAttributes: TGLuint, + piAttributes: PGLint, piValues: PGLint): BOOL{. + dynlib: dllname, importc: "wglGetPixelFormatAttribivEXT".} +proc wglGetPixelFormatAttribfvEXT*(hdc: HDC, iPixelFormat: TGLint, + iLayerPlane: TGLint, nAttributes: TGLuint, + piAttributes: PGLint, pfValues: PGLfloat): BOOL{. + dynlib: dllname, importc: "wglGetPixelFormatAttribfvEXT".} +proc wglChoosePixelFormatEXT*(hdc: HDC, piAttribIList: PGLint, + pfAttribFList: PGLfloat, nMaxFormats: TGLuint, + piFormats: PGLint, nNumFormats: PGLuint): BOOL{. + dynlib: dllname, importc: "wglChoosePixelFormatEXT".} +const + WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D* = 0x00002050 + WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D* = 0x00002051 + WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D* = 0x00002052 + WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D* = 0x00002053 + +proc wglGetDigitalVideoParametersI3D*(hDC: HDC, iAttribute: TGLint, + piValue: PGLint): BOOL{.dynlib: dllname, + importc: "wglGetDigitalVideoParametersI3D".} +proc wglSetDigitalVideoParametersI3D*(hDC: HDC, iAttribute: TGLint, + piValue: PGLint): BOOL{.dynlib: dllname, + importc: "wglSetDigitalVideoParametersI3D".} +const + WGL_GAMMA_TABLE_SIZE_I3D* = 0x0000204E + WGL_GAMMA_EXCLUDE_DESKTOP_I3D* = 0x0000204F + +proc wglGetGammaTableParametersI3D*(hDC: HDC, iAttribute: TGLint, + piValue: PGLint): BOOL{.dynlib: dllname, + importc: "wglGetGammaTableParametersI3D".} +proc wglSetGammaTableParametersI3D*(hDC: HDC, iAttribute: TGLint, + piValue: PGLint): BOOL{.dynlib: dllname, + importc: "wglSetGammaTableParametersI3D".} +proc wglGetGammaTableI3D*(hDC: HDC, iEntries: TGLint, puRed: PGLUSHORT, + puGreen: PGLUSHORT, puBlue: PGLUSHORT): BOOL{. + dynlib: dllname, importc: "wglGetGammaTableI3D".} +proc wglSetGammaTableI3D*(hDC: HDC, iEntries: TGLint, puRed: PGLUSHORT, + puGreen: PGLUSHORT, puBlue: PGLUSHORT): BOOL{. + dynlib: dllname, importc: "wglSetGammaTableI3D".} +const + WGL_GENLOCK_SOURCE_MULTIVIEW_I3D* = 0x00002044 + WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D* = 0x00002045 + WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D* = 0x00002046 + WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D* = 0x00002047 + WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D* = 0x00002048 + WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D* = 0x00002049 + WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D* = 0x0000204A + WGL_GENLOCK_SOURCE_EDGE_RISING_I3D* = 0x0000204B + WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D* = 0x0000204C + WGL_FLOAT_COMPONENTS_NV* = 0x000020B0 + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV* = 0x000020B1 + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV* = 0x000020B2 + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV* = 0x000020B3 + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV* = 0x000020B4 + WGL_TEXTURE_FLOAT_R_NV* = 0x000020B5 + WGL_TEXTURE_FLOAT_RG_NV* = 0x000020B6 + WGL_TEXTURE_FLOAT_RGB_NV* = 0x000020B7 + WGL_TEXTURE_FLOAT_RGBA_NV* = 0x000020B8 + +proc wglEnableGenlockI3D*(hDC: HDC): BOOL{.dynlib: dllname, + importc: "wglEnableGenlockI3D".} +proc wglDisableGenlockI3D*(hDC: HDC): BOOL{.dynlib: dllname, + importc: "wglDisableGenlockI3D".} +proc wglIsEnabledGenlockI3D*(hDC: HDC, pFlag: PBOOL): BOOL{.dynlib: dllname, + importc: "wglIsEnabledGenlockI3D".} +proc wglGenlockSourceI3D*(hDC: HDC, uSource: TGLuint): BOOL{.dynlib: dllname, + importc: "wglGenlockSourceI3D".} +proc wglGetGenlockSourceI3D*(hDC: HDC, uSource: PGLUINT): BOOL{.dynlib: dllname, + importc: "wglGetGenlockSourceI3D".} +proc wglGenlockSourceEdgeI3D*(hDC: HDC, uEdge: TGLuint): BOOL{.dynlib: dllname, + importc: "wglGenlockSourceEdgeI3D".} +proc wglGetGenlockSourceEdgeI3D*(hDC: HDC, uEdge: PGLUINT): BOOL{. + dynlib: dllname, importc: "wglGetGenlockSourceEdgeI3D".} +proc wglGenlockSampleRateI3D*(hDC: HDC, uRate: TGLuint): BOOL{.dynlib: dllname, + importc: "wglGenlockSampleRateI3D".} +proc wglGetGenlockSampleRateI3D*(hDC: HDC, uRate: PGLUINT): BOOL{. + dynlib: dllname, importc: "wglGetGenlockSampleRateI3D".} +proc wglGenlockSourceDelayI3D*(hDC: HDC, uDelay: TGLuint): BOOL{. + dynlib: dllname, importc: "wglGenlockSourceDelayI3D".} +proc wglGetGenlockSourceDelayI3D*(hDC: HDC, uDelay: PGLUINT): BOOL{. + dynlib: dllname, importc: "wglGetGenlockSourceDelayI3D".} +proc wglQueryGenlockMaxSourceDelayI3D*(hDC: HDC, uMaxLineDelay: PGLUINT, + uMaxPixelDelay: PGLUINT): BOOL{. + dynlib: dllname, importc: "wglQueryGenlockMaxSourceDelayI3D".} +const + WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV* = 0x000020A0 + WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV* = 0x000020A1 + WGL_TEXTURE_RECTANGLE_NV* = 0x000020A2 + +const + WGL_RGBA_FLOAT_MODE_ATI* = 0x00008820 + WGL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI* = 0x00008835 + WGL_TYPE_RGBA_FLOAT_ATI* = 0x000021A0 + +# implementation diff --git a/tests/deps/x11-1.0/cursorfont.nim b/tests/deps/x11-1.0/cursorfont.nim new file mode 100644 index 000000000..b262ad7c1 --- /dev/null +++ b/tests/deps/x11-1.0/cursorfont.nim @@ -0,0 +1,110 @@ +# $Xorg: cursorfont.h,v 1.4 2001/02/09 02:03:39 xorgcvs Exp $ +# +# +#Copyright 1987, 1998 The Open Group +# +#Permission to use, copy, modify, distribute, and sell this software and its +#documentation for any purpose is hereby granted without fee, provided that +#the above copyright notice appear in all copies and that both that +#copyright notice and this permission notice appear in supporting +#documentation. +# +#The above copyright notice and this permission notice shall be included +#in all copies or substantial portions of the Software. +# +#THE SOFTWARE IS 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 OPEN GROUP 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 SOFTWARE OR THE USE OR +#OTHER DEALINGS IN THE SOFTWARE. +# +#Except as contained in this notice, the name of The Open Group shall +#not be used in advertising or otherwise to promote the sale, use or +#other dealings in this Software without prior written authorization +#from The Open Group. +# +# + +const + XC_num_glyphs* = 154 + XC_X_cursor* = 0 + XC_arrow* = 2 + XC_based_arrow_down* = 4 + XC_based_arrow_up* = 6 + XC_boat* = 8 + XC_bogosity* = 10 + XC_bottom_left_corner* = 12 + XC_bottom_right_corner* = 14 + XC_bottom_side* = 16 + XC_bottom_tee* = 18 + XC_box_spiral* = 20 + XC_center_ptr* = 22 + XC_circle* = 24 + XC_clock* = 26 + XC_coffee_mug* = 28 + XC_cross* = 30 + XC_cross_reverse* = 32 + XC_crosshair* = 34 + XC_diamond_cross* = 36 + XC_dot* = 38 + XC_dotbox* = 40 + XC_double_arrow* = 42 + XC_draft_large* = 44 + XC_draft_small* = 46 + XC_draped_box* = 48 + XC_exchange* = 50 + XC_fleur* = 52 + XC_gobbler* = 54 + XC_gumby* = 56 + XC_hand1* = 58 + XC_hand2* = 60 + XC_heart* = 62 + XC_icon* = 64 + XC_iron_cross* = 66 + XC_left_ptr* = 68 + XC_left_side* = 70 + XC_left_tee* = 72 + XC_leftbutton* = 74 + XC_ll_angle* = 76 + XC_lr_angle* = 78 + XC_man* = 80 + XC_middlebutton* = 82 + XC_mouse* = 84 + XC_pencil* = 86 + XC_pirate* = 88 + XC_plus* = 90 + XC_question_arrow* = 92 + XC_right_ptr* = 94 + XC_right_side* = 96 + XC_right_tee* = 98 + XC_rightbutton* = 100 + XC_rtl_logo* = 102 + XC_sailboat* = 104 + XC_sb_down_arrow* = 106 + XC_sb_h_double_arrow* = 108 + XC_sb_left_arrow* = 110 + XC_sb_right_arrow* = 112 + XC_sb_up_arrow* = 114 + XC_sb_v_double_arrow* = 116 + XC_shuttle* = 118 + XC_sizing* = 120 + XC_spider* = 122 + XC_spraycan* = 124 + XC_star* = 126 + XC_target* = 128 + XC_tcross* = 130 + XC_top_left_arrow* = 132 + XC_top_left_corner* = 134 + XC_top_right_corner* = 136 + XC_top_side* = 138 + XC_top_tee* = 140 + XC_trek* = 142 + XC_ul_angle* = 144 + XC_umbrella* = 146 + XC_ur_angle* = 148 + XC_watch* = 150 + XC_xterm* = 152 + +# implementation diff --git a/tests/deps/x11-1.0/keysym.nim b/tests/deps/x11-1.0/keysym.nim new file mode 100644 index 000000000..c001ab622 --- /dev/null +++ b/tests/deps/x11-1.0/keysym.nim @@ -0,0 +1,1926 @@ +# +#Converted from X11/keysym.h and X11/keysymdef.h +# +#Capital letter consts renamed from XK_... to XKc_... +# (since Pascal isn't case-sensitive) +# +#i.e. +#C Pascal +#XK_a XK_a +#XK_A XKc_A +# + +#* default keysyms * +import x + +const + XK_VoidSymbol*: TKeySym = 0x00FFFFFF # void symbol + +when defined(XK_MISCELLANY) or true: + const + #* + # * TTY Functions, cleverly chosen to map to ascii, for convenience of + # * programming, but could have been arbitrary (at the cost of lookup + # * tables in client code. + # * + XK_BackSpace*: TKeySym = 0x0000FF08 # back space, back char + XK_Tab*: TKeySym = 0x0000FF09 + XK_Linefeed*: TKeySym = 0x0000FF0A # Linefeed, LF + XK_Clear*: TKeySym = 0x0000FF0B + XK_Return*: TKeySym = 0x0000FF0D # Return, enter + XK_Pause*: TKeySym = 0x0000FF13 # Pause, hold + XK_Scroll_Lock*: TKeySym = 0x0000FF14 + XK_Sys_Req*: TKeySym = 0x0000FF15 + XK_Escape*: TKeySym = 0x0000FF1B + XK_Delete*: TKeySym = 0x0000FFFF # Delete, rubout \ + # International & multi-key character composition + XK_Multi_key*: TKeySym = 0x0000FF20 # Multi-key character compose + XK_Codeinput*: TKeySym = 0x0000FF37 + XK_SingleCandidate*: TKeySym = 0x0000FF3C + XK_MultipleCandidate*: TKeySym = 0x0000FF3D + XK_PreviousCandidate*: TKeySym = 0x0000FF3E # Japanese keyboard support + XK_Kanji*: TKeySym = 0x0000FF21 # Kanji, Kanji convert + XK_Muhenkan*: TKeySym = 0x0000FF22 # Cancel Conversion + XK_Henkan_Mode*: TKeySym = 0x0000FF23 # Start/Stop Conversion + XK_Henkan*: TKeySym = 0x0000FF23 # Alias for Henkan_Mode + XK_Romaji*: TKeySym = 0x0000FF24 # to Romaji + XK_Hiragana*: TKeySym = 0x0000FF25 # to Hiragana + XK_Katakana*: TKeySym = 0x0000FF26 # to Katakana + XK_Hiragana_Katakana*: TKeySym = 0x0000FF27 # Hiragana/Katakana toggle + XK_Zenkaku*: TKeySym = 0x0000FF28 # to Zenkaku + XK_Hankaku*: TKeySym = 0x0000FF29 # to Hankaku + XK_Zenkaku_Hankaku*: TKeySym = 0x0000FF2A # Zenkaku/Hankaku toggle + XK_Touroku*: TKeySym = 0x0000FF2B # Add to Dictionary + XK_Massyo*: TKeySym = 0x0000FF2C # Delete from Dictionary + XK_Kana_Lock*: TKeySym = 0x0000FF2D # Kana Lock + XK_Kana_Shift*: TKeySym = 0x0000FF2E # Kana Shift + XK_Eisu_Shift*: TKeySym = 0x0000FF2F # Alphanumeric Shift + XK_Eisu_toggle*: TKeySym = 0x0000FF30 # Alphanumeric toggle + XK_Kanji_Bangou*: TKeySym = 0x0000FF37 # Codeinput + XK_Zen_Koho*: TKeySym = 0x0000FF3D # Multiple/All Candidate(s) + XK_Mae_Koho*: TKeySym = 0x0000FF3E # Previous Candidate \ + # = $FF31 thru = $FF3F are under XK_KOREAN + # Cursor control & motion + XK_Home*: TKeySym = 0x0000FF50 + XK_Left*: TKeySym = 0x0000FF51 # Move left, left arrow + XK_Up*: TKeySym = 0x0000FF52 # Move up, up arrow + XK_Right*: TKeySym = 0x0000FF53 # Move right, right arrow + XK_Down*: TKeySym = 0x0000FF54 # Move down, down arrow + XK_Prior*: TKeySym = 0x0000FF55 # Prior, previous + XK_Page_Up*: TKeySym = 0x0000FF55 + XK_Next*: TKeySym = 0x0000FF56 # Next + XK_Page_Down*: TKeySym = 0x0000FF56 + XK_End*: TKeySym = 0x0000FF57 # EOL + XK_Begin*: TKeySym = 0x0000FF58 # BOL \ + # Misc Functions + XK_Select*: TKeySym = 0x0000FF60 # Select, mark + XK_Print*: TKeySym = 0x0000FF61 + XK_Execute*: TKeySym = 0x0000FF62 # Execute, run, do + XK_Insert*: TKeySym = 0x0000FF63 # Insert, insert here + XK_Undo*: TKeySym = 0x0000FF65 # Undo, oops + XK_Redo*: TKeySym = 0x0000FF66 # redo, again + XK_Menu*: TKeySym = 0x0000FF67 + XK_Find*: TKeySym = 0x0000FF68 # Find, search + XK_Cancel*: TKeySym = 0x0000FF69 # Cancel, stop, abort, exit + XK_Help*: TKeySym = 0x0000FF6A # Help + XK_Break*: TKeySym = 0x0000FF6B + XK_Mode_switch*: TKeySym = 0x0000FF7E # Character set switch + XK_script_switch*: TKeySym = 0x0000FF7E # Alias for mode_switch + XK_Num_Lock*: TKeySym = 0x0000FF7F # Keypad Functions, keypad numbers cleverly chosen to map to ascii + XK_KP_Space*: TKeySym = 0x0000FF80 # space + XK_KP_Tab*: TKeySym = 0x0000FF89 + XK_KP_Enter*: TKeySym = 0x0000FF8D # enter + XK_KP_F1*: TKeySym = 0x0000FF91 # PF1, KP_A, ... + XK_KP_F2*: TKeySym = 0x0000FF92 + XK_KP_F3*: TKeySym = 0x0000FF93 + XK_KP_F4*: TKeySym = 0x0000FF94 + XK_KP_Home*: TKeySym = 0x0000FF95 + XK_KP_Left*: TKeySym = 0x0000FF96 + XK_KP_Up*: TKeySym = 0x0000FF97 + XK_KP_Right*: TKeySym = 0x0000FF98 + XK_KP_Down*: TKeySym = 0x0000FF99 + XK_KP_Prior*: TKeySym = 0x0000FF9A + XK_KP_Page_Up*: TKeySym = 0x0000FF9A + XK_KP_Next*: TKeySym = 0x0000FF9B + XK_KP_Page_Down*: TKeySym = 0x0000FF9B + XK_KP_End*: TKeySym = 0x0000FF9C + XK_KP_Begin*: TKeySym = 0x0000FF9D + XK_KP_Insert*: TKeySym = 0x0000FF9E + XK_KP_Delete*: TKeySym = 0x0000FF9F + XK_KP_Equal*: TKeySym = 0x0000FFBD # equals + XK_KP_Multiply*: TKeySym = 0x0000FFAA + XK_KP_Add*: TKeySym = 0x0000FFAB + XK_KP_Separator*: TKeySym = 0x0000FFAC # separator, often comma + XK_KP_Subtract*: TKeySym = 0x0000FFAD + XK_KP_Decimal*: TKeySym = 0x0000FFAE + XK_KP_Divide*: TKeySym = 0x0000FFAF + XK_KP_0*: TKeySym = 0x0000FFB0 + XK_KP_1*: TKeySym = 0x0000FFB1 + XK_KP_2*: TKeySym = 0x0000FFB2 + XK_KP_3*: TKeySym = 0x0000FFB3 + XK_KP_4*: TKeySym = 0x0000FFB4 + XK_KP_5*: TKeySym = 0x0000FFB5 + XK_KP_6*: TKeySym = 0x0000FFB6 + XK_KP_7*: TKeySym = 0x0000FFB7 + XK_KP_8*: TKeySym = 0x0000FFB8 + XK_KP_9*: TKeySym = 0x0000FFB9 #*\ + # * Auxilliary Functions; note the duplicate definitions for left and right + # * function keys; Sun keyboards and a few other manufactures have such + # * function key groups on the left and/or right sides of the keyboard. + # * We've not found a keyboard with more than 35 function keys total. + # * + XK_F1*: TKeySym = 0x0000FFBE + XK_F2*: TKeySym = 0x0000FFBF + XK_F3*: TKeySym = 0x0000FFC0 + XK_F4*: TKeySym = 0x0000FFC1 + XK_F5*: TKeySym = 0x0000FFC2 + XK_F6*: TKeySym = 0x0000FFC3 + XK_F7*: TKeySym = 0x0000FFC4 + XK_F8*: TKeySym = 0x0000FFC5 + XK_F9*: TKeySym = 0x0000FFC6 + XK_F10*: TKeySym = 0x0000FFC7 + XK_F11*: TKeySym = 0x0000FFC8 + XK_L1*: TKeySym = 0x0000FFC8 + XK_F12*: TKeySym = 0x0000FFC9 + XK_L2*: TKeySym = 0x0000FFC9 + XK_F13*: TKeySym = 0x0000FFCA + XK_L3*: TKeySym = 0x0000FFCA + XK_F14*: TKeySym = 0x0000FFCB + XK_L4*: TKeySym = 0x0000FFCB + XK_F15*: TKeySym = 0x0000FFCC + XK_L5*: TKeySym = 0x0000FFCC + XK_F16*: TKeySym = 0x0000FFCD + XK_L6*: TKeySym = 0x0000FFCD + XK_F17*: TKeySym = 0x0000FFCE + XK_L7*: TKeySym = 0x0000FFCE + XK_F18*: TKeySym = 0x0000FFCF + XK_L8*: TKeySym = 0x0000FFCF + XK_F19*: TKeySym = 0x0000FFD0 + XK_L9*: TKeySym = 0x0000FFD0 + XK_F20*: TKeySym = 0x0000FFD1 + XK_L10*: TKeySym = 0x0000FFD1 + XK_F21*: TKeySym = 0x0000FFD2 + XK_R1*: TKeySym = 0x0000FFD2 + XK_F22*: TKeySym = 0x0000FFD3 + XK_R2*: TKeySym = 0x0000FFD3 + XK_F23*: TKeySym = 0x0000FFD4 + XK_R3*: TKeySym = 0x0000FFD4 + XK_F24*: TKeySym = 0x0000FFD5 + XK_R4*: TKeySym = 0x0000FFD5 + XK_F25*: TKeySym = 0x0000FFD6 + XK_R5*: TKeySym = 0x0000FFD6 + XK_F26*: TKeySym = 0x0000FFD7 + XK_R6*: TKeySym = 0x0000FFD7 + XK_F27*: TKeySym = 0x0000FFD8 + XK_R7*: TKeySym = 0x0000FFD8 + XK_F28*: TKeySym = 0x0000FFD9 + XK_R8*: TKeySym = 0x0000FFD9 + XK_F29*: TKeySym = 0x0000FFDA + XK_R9*: TKeySym = 0x0000FFDA + XK_F30*: TKeySym = 0x0000FFDB + XK_R10*: TKeySym = 0x0000FFDB + XK_F31*: TKeySym = 0x0000FFDC + XK_R11*: TKeySym = 0x0000FFDC + XK_F32*: TKeySym = 0x0000FFDD + XK_R12*: TKeySym = 0x0000FFDD + XK_F33*: TKeySym = 0x0000FFDE + XK_R13*: TKeySym = 0x0000FFDE + XK_F34*: TKeySym = 0x0000FFDF + XK_R14*: TKeySym = 0x0000FFDF + XK_F35*: TKeySym = 0x0000FFE0 + XK_R15*: TKeySym = 0x0000FFE0 # Modifiers + XK_Shift_L*: TKeySym = 0x0000FFE1 # Left shift + XK_Shift_R*: TKeySym = 0x0000FFE2 # Right shift + XK_Control_L*: TKeySym = 0x0000FFE3 # Left control + XK_Control_R*: TKeySym = 0x0000FFE4 # Right control + XK_Caps_Lock*: TKeySym = 0x0000FFE5 # Caps lock + XK_Shift_Lock*: TKeySym = 0x0000FFE6 # Shift lock + XK_Meta_L*: TKeySym = 0x0000FFE7 # Left meta + XK_Meta_R*: TKeySym = 0x0000FFE8 # Right meta + XK_Alt_L*: TKeySym = 0x0000FFE9 # Left alt + XK_Alt_R*: TKeySym = 0x0000FFEA # Right alt + XK_Super_L*: TKeySym = 0x0000FFEB # Left super + XK_Super_R*: TKeySym = 0x0000FFEC # Right super + XK_Hyper_L*: TKeySym = 0x0000FFED # Left hyper + XK_Hyper_R*: TKeySym = 0x0000FFEE # Right hyper +# XK_MISCELLANY +#* +# * ISO 9995 Function and Modifier Keys +# * Byte 3 = = $FE +# * + +when defined(XK_XKB_KEYS) or true: + const + XK_ISO_Lock*: TKeySym = 0x0000FE01 + XK_ISO_Level2_Latch*: TKeySym = 0x0000FE02 + XK_ISO_Level3_Shift*: TKeySym = 0x0000FE03 + XK_ISO_Level3_Latch*: TKeySym = 0x0000FE04 + XK_ISO_Level3_Lock*: TKeySym = 0x0000FE05 + XK_ISO_Group_Shift*: TKeySym = 0x0000FF7E # Alias for mode_switch + XK_ISO_Group_Latch*: TKeySym = 0x0000FE06 + XK_ISO_Group_Lock*: TKeySym = 0x0000FE07 + XK_ISO_Next_Group*: TKeySym = 0x0000FE08 + XK_ISO_Next_Group_Lock*: TKeySym = 0x0000FE09 + XK_ISO_Prev_Group*: TKeySym = 0x0000FE0A + XK_ISO_Prev_Group_Lock*: TKeySym = 0x0000FE0B + XK_ISO_First_Group*: TKeySym = 0x0000FE0C + XK_ISO_First_Group_Lock*: TKeySym = 0x0000FE0D + XK_ISO_Last_Group*: TKeySym = 0x0000FE0E + XK_ISO_Last_Group_Lock*: TKeySym = 0x0000FE0F + XK_ISO_Left_Tab*: TKeySym = 0x0000FE20 + XK_ISO_Move_Line_Up*: TKeySym = 0x0000FE21 + XK_ISO_Move_Line_Down*: TKeySym = 0x0000FE22 + XK_ISO_Partial_Line_Up*: TKeySym = 0x0000FE23 + XK_ISO_Partial_Line_Down*: TKeySym = 0x0000FE24 + XK_ISO_Partial_Space_Left*: TKeySym = 0x0000FE25 + XK_ISO_Partial_Space_Right*: TKeySym = 0x0000FE26 + XK_ISO_Set_Margin_Left*: TKeySym = 0x0000FE27 + XK_ISO_Set_Margin_Right*: TKeySym = 0x0000FE28 + XK_ISO_Release_Margin_Left*: TKeySym = 0x0000FE29 + XK_ISO_Release_Margin_Right*: TKeySym = 0x0000FE2A + XK_ISO_Release_Both_Margins*: TKeySym = 0x0000FE2B + XK_ISO_Fast_Cursor_Left*: TKeySym = 0x0000FE2C + XK_ISO_Fast_Cursor_Right*: TKeySym = 0x0000FE2D + XK_ISO_Fast_Cursor_Up*: TKeySym = 0x0000FE2E + XK_ISO_Fast_Cursor_Down*: TKeySym = 0x0000FE2F + XK_ISO_Continuous_Underline*: TKeySym = 0x0000FE30 + XK_ISO_Discontinuous_Underline*: TKeySym = 0x0000FE31 + XK_ISO_Emphasize*: TKeySym = 0x0000FE32 + XK_ISO_Center_Object*: TKeySym = 0x0000FE33 + XK_ISO_Enter*: TKeySym = 0x0000FE34 + XK_dead_grave*: TKeySym = 0x0000FE50 + XK_dead_acute*: TKeySym = 0x0000FE51 + XK_dead_circumflex*: TKeySym = 0x0000FE52 + XK_dead_tilde*: TKeySym = 0x0000FE53 + XK_dead_macron*: TKeySym = 0x0000FE54 + XK_dead_breve*: TKeySym = 0x0000FE55 + XK_dead_abovedot*: TKeySym = 0x0000FE56 + XK_dead_diaeresis*: TKeySym = 0x0000FE57 + XK_dead_abovering*: TKeySym = 0x0000FE58 + XK_dead_doubleacute*: TKeySym = 0x0000FE59 + XK_dead_caron*: TKeySym = 0x0000FE5A + XK_dead_cedilla*: TKeySym = 0x0000FE5B + XK_dead_ogonek*: TKeySym = 0x0000FE5C + XK_dead_iota*: TKeySym = 0x0000FE5D + XK_dead_voiced_sound*: TKeySym = 0x0000FE5E + XK_dead_semivoiced_sound*: TKeySym = 0x0000FE5F + XK_dead_belowdot*: TKeySym = 0x0000FE60 + XK_dead_hook*: TKeySym = 0x0000FE61 + XK_dead_horn*: TKeySym = 0x0000FE62 + XK_First_Virtual_Screen*: TKeySym = 0x0000FED0 + XK_Prev_Virtual_Screen*: TKeySym = 0x0000FED1 + XK_Next_Virtual_Screen*: TKeySym = 0x0000FED2 + XK_Last_Virtual_Screen*: TKeySym = 0x0000FED4 + XK_Terminate_Server*: TKeySym = 0x0000FED5 + XK_AccessX_Enable*: TKeySym = 0x0000FE70 + XK_AccessX_Feedback_Enable*: TKeySym = 0x0000FE71 + XK_RepeatKeys_Enable*: TKeySym = 0x0000FE72 + XK_SlowKeys_Enable*: TKeySym = 0x0000FE73 + XK_BounceKeys_Enable*: TKeySym = 0x0000FE74 + XK_StickyKeys_Enable*: TKeySym = 0x0000FE75 + XK_MouseKeys_Enable*: TKeySym = 0x0000FE76 + XK_MouseKeys_Accel_Enable*: TKeySym = 0x0000FE77 + XK_Overlay1_Enable*: TKeySym = 0x0000FE78 + XK_Overlay2_Enable*: TKeySym = 0x0000FE79 + XK_AudibleBell_Enable*: TKeySym = 0x0000FE7A + XK_Pointer_Left*: TKeySym = 0x0000FEE0 + XK_Pointer_Right*: TKeySym = 0x0000FEE1 + XK_Pointer_Up*: TKeySym = 0x0000FEE2 + XK_Pointer_Down*: TKeySym = 0x0000FEE3 + XK_Pointer_UpLeft*: TKeySym = 0x0000FEE4 + XK_Pointer_UpRight*: TKeySym = 0x0000FEE5 + XK_Pointer_DownLeft*: TKeySym = 0x0000FEE6 + XK_Pointer_DownRight*: TKeySym = 0x0000FEE7 + XK_Pointer_Button_Dflt*: TKeySym = 0x0000FEE8 + XK_Pointer_Button1*: TKeySym = 0x0000FEE9 + XK_Pointer_Button2*: TKeySym = 0x0000FEEA + XK_Pointer_Button3*: TKeySym = 0x0000FEEB + XK_Pointer_Button4*: TKeySym = 0x0000FEEC + XK_Pointer_Button5*: TKeySym = 0x0000FEED + XK_Pointer_DblClick_Dflt*: TKeySym = 0x0000FEEE + XK_Pointer_DblClick1*: TKeySym = 0x0000FEEF + XK_Pointer_DblClick2*: TKeySym = 0x0000FEF0 + XK_Pointer_DblClick3*: TKeySym = 0x0000FEF1 + XK_Pointer_DblClick4*: TKeySym = 0x0000FEF2 + XK_Pointer_DblClick5*: TKeySym = 0x0000FEF3 + XK_Pointer_Drag_Dflt*: TKeySym = 0x0000FEF4 + XK_Pointer_Drag1*: TKeySym = 0x0000FEF5 + XK_Pointer_Drag2*: TKeySym = 0x0000FEF6 + XK_Pointer_Drag3*: TKeySym = 0x0000FEF7 + XK_Pointer_Drag4*: TKeySym = 0x0000FEF8 + XK_Pointer_Drag5*: TKeySym = 0x0000FEFD + XK_Pointer_EnableKeys*: TKeySym = 0x0000FEF9 + XK_Pointer_Accelerate*: TKeySym = 0x0000FEFA + XK_Pointer_DfltBtnNext*: TKeySym = 0x0000FEFB + XK_Pointer_DfltBtnPrev*: TKeySym = 0x0000FEFC + #* + # * 3270 Terminal Keys + # * Byte 3 = = $FD + # * + +when defined(XK_3270) or true: + const + XK_3270_Duplicate*: TKeySym = 0x0000FD01 + XK_3270_FieldMark*: TKeySym = 0x0000FD02 + XK_3270_Right2*: TKeySym = 0x0000FD03 + XK_3270_Left2*: TKeySym = 0x0000FD04 + XK_3270_BackTab*: TKeySym = 0x0000FD05 + XK_3270_EraseEOF*: TKeySym = 0x0000FD06 + XK_3270_EraseInput*: TKeySym = 0x0000FD07 + XK_3270_Reset*: TKeySym = 0x0000FD08 + XK_3270_Quit*: TKeySym = 0x0000FD09 + XK_3270_PA1*: TKeySym = 0x0000FD0A + XK_3270_PA2*: TKeySym = 0x0000FD0B + XK_3270_PA3*: TKeySym = 0x0000FD0C + XK_3270_Test*: TKeySym = 0x0000FD0D + XK_3270_Attn*: TKeySym = 0x0000FD0E + XK_3270_CursorBlink*: TKeySym = 0x0000FD0F + XK_3270_AltCursor*: TKeySym = 0x0000FD10 + XK_3270_KeyClick*: TKeySym = 0x0000FD11 + XK_3270_Jump*: TKeySym = 0x0000FD12 + XK_3270_Ident*: TKeySym = 0x0000FD13 + XK_3270_Rule*: TKeySym = 0x0000FD14 + XK_3270_Copy*: TKeySym = 0x0000FD15 + XK_3270_Play*: TKeySym = 0x0000FD16 + XK_3270_Setup*: TKeySym = 0x0000FD17 + XK_3270_Record*: TKeySym = 0x0000FD18 + XK_3270_ChangeScreen*: TKeySym = 0x0000FD19 + XK_3270_DeleteWord*: TKeySym = 0x0000FD1A + XK_3270_ExSelect*: TKeySym = 0x0000FD1B + XK_3270_CursorSelect*: TKeySym = 0x0000FD1C + XK_3270_PrintScreen*: TKeySym = 0x0000FD1D + XK_3270_Enter*: TKeySym = 0x0000FD1E +#* +# * Latin 1 +# * Byte 3 = 0 +# * + +when defined(XK_LATIN1) or true: + const + XK_space*: TKeySym = 0x00000020 + XK_exclam*: TKeySym = 0x00000021 + XK_quotedbl*: TKeySym = 0x00000022 + XK_numbersign*: TKeySym = 0x00000023 + XK_dollar*: TKeySym = 0x00000024 + XK_percent*: TKeySym = 0x00000025 + XK_ampersand*: TKeySym = 0x00000026 + XK_apostrophe*: TKeySym = 0x00000027 + XK_quoteright*: TKeySym = 0x00000027 # deprecated + XK_parenleft*: TKeySym = 0x00000028 + XK_parenright*: TKeySym = 0x00000029 + XK_asterisk*: TKeySym = 0x0000002A + XK_plus*: TKeySym = 0x0000002B + XK_comma*: TKeySym = 0x0000002C + XK_minus*: TKeySym = 0x0000002D + XK_period*: TKeySym = 0x0000002E + XK_slash*: TKeySym = 0x0000002F + XK_0*: TKeySym = 0x00000030 + XK_1*: TKeySym = 0x00000031 + XK_2*: TKeySym = 0x00000032 + XK_3*: TKeySym = 0x00000033 + XK_4*: TKeySym = 0x00000034 + XK_5*: TKeySym = 0x00000035 + XK_6*: TKeySym = 0x00000036 + XK_7*: TKeySym = 0x00000037 + XK_8*: TKeySym = 0x00000038 + XK_9*: TKeySym = 0x00000039 + XK_colon*: TKeySym = 0x0000003A + XK_semicolon*: TKeySym = 0x0000003B + XK_less*: TKeySym = 0x0000003C + XK_equal*: TKeySym = 0x0000003D + XK_greater*: TKeySym = 0x0000003E + XK_question*: TKeySym = 0x0000003F + XK_at*: TKeySym = 0x00000040 + XKc_A*: TKeySym = 0x00000041 + XKc_B*: TKeySym = 0x00000042 + XKc_C*: TKeySym = 0x00000043 + XKc_D*: TKeySym = 0x00000044 + XKc_E*: TKeySym = 0x00000045 + XKc_F*: TKeySym = 0x00000046 + XKc_G*: TKeySym = 0x00000047 + XKc_H*: TKeySym = 0x00000048 + XKc_I*: TKeySym = 0x00000049 + XKc_J*: TKeySym = 0x0000004A + XKc_K*: TKeySym = 0x0000004B + XKc_L*: TKeySym = 0x0000004C + XKc_M*: TKeySym = 0x0000004D + XKc_N*: TKeySym = 0x0000004E + XKc_O*: TKeySym = 0x0000004F + XKc_P*: TKeySym = 0x00000050 + XKc_Q*: TKeySym = 0x00000051 + XKc_R*: TKeySym = 0x00000052 + XKc_S*: TKeySym = 0x00000053 + XKc_T*: TKeySym = 0x00000054 + XKc_U*: TKeySym = 0x00000055 + XKc_V*: TKeySym = 0x00000056 + XKc_W*: TKeySym = 0x00000057 + XKc_X*: TKeySym = 0x00000058 + XKc_Y*: TKeySym = 0x00000059 + XKc_Z*: TKeySym = 0x0000005A + XK_bracketleft*: TKeySym = 0x0000005B + XK_backslash*: TKeySym = 0x0000005C + XK_bracketright*: TKeySym = 0x0000005D + XK_asciicircum*: TKeySym = 0x0000005E + XK_underscore*: TKeySym = 0x0000005F + XK_grave*: TKeySym = 0x00000060 + XK_quoteleft*: TKeySym = 0x00000060 # deprecated + XK_a*: TKeySym = 0x00000061 + XK_b*: TKeySym = 0x00000062 + XK_c*: TKeySym = 0x00000063 + XK_d*: TKeySym = 0x00000064 + XK_e*: TKeySym = 0x00000065 + XK_f*: TKeySym = 0x00000066 + XK_g*: TKeySym = 0x00000067 + XK_h*: TKeySym = 0x00000068 + XK_i*: TKeySym = 0x00000069 + XK_j*: TKeySym = 0x0000006A + XK_k*: TKeySym = 0x0000006B + XK_l*: TKeySym = 0x0000006C + XK_m*: TKeySym = 0x0000006D + XK_n*: TKeySym = 0x0000006E + XK_o*: TKeySym = 0x0000006F + XK_p*: TKeySym = 0x00000070 + XK_q*: TKeySym = 0x00000071 + XK_r*: TKeySym = 0x00000072 + XK_s*: TKeySym = 0x00000073 + XK_t*: TKeySym = 0x00000074 + XK_u*: TKeySym = 0x00000075 + XK_v*: TKeySym = 0x00000076 + XK_w*: TKeySym = 0x00000077 + XK_x*: TKeySym = 0x00000078 + XK_y*: TKeySym = 0x00000079 + XK_z*: TKeySym = 0x0000007A + XK_braceleft*: TKeySym = 0x0000007B + XK_bar*: TKeySym = 0x0000007C + XK_braceright*: TKeySym = 0x0000007D + XK_asciitilde*: TKeySym = 0x0000007E + XK_nobreakspace*: TKeySym = 0x000000A0 + XK_exclamdown*: TKeySym = 0x000000A1 + XK_cent*: TKeySym = 0x000000A2 + XK_sterling*: TKeySym = 0x000000A3 + XK_currency*: TKeySym = 0x000000A4 + XK_yen*: TKeySym = 0x000000A5 + XK_brokenbar*: TKeySym = 0x000000A6 + XK_section*: TKeySym = 0x000000A7 + XK_diaeresis*: TKeySym = 0x000000A8 + XK_copyright*: TKeySym = 0x000000A9 + XK_ordfeminine*: TKeySym = 0x000000AA + XK_guillemotleft*: TKeySym = 0x000000AB # left angle quotation mark + XK_notsign*: TKeySym = 0x000000AC + XK_hyphen*: TKeySym = 0x000000AD + XK_registered*: TKeySym = 0x000000AE + XK_macron*: TKeySym = 0x000000AF + XK_degree*: TKeySym = 0x000000B0 + XK_plusminus*: TKeySym = 0x000000B1 + XK_twosuperior*: TKeySym = 0x000000B2 + XK_threesuperior*: TKeySym = 0x000000B3 + XK_acute*: TKeySym = 0x000000B4 + XK_mu*: TKeySym = 0x000000B5 + XK_paragraph*: TKeySym = 0x000000B6 + XK_periodcentered*: TKeySym = 0x000000B7 + XK_cedilla*: TKeySym = 0x000000B8 + XK_onesuperior*: TKeySym = 0x000000B9 + XK_masculine*: TKeySym = 0x000000BA + XK_guillemotright*: TKeySym = 0x000000BB # right angle quotation mark + XK_onequarter*: TKeySym = 0x000000BC + XK_onehalf*: TKeySym = 0x000000BD + XK_threequarters*: TKeySym = 0x000000BE + XK_questiondown*: TKeySym = 0x000000BF + XKc_Agrave*: TKeySym = 0x000000C0 + XKc_Aacute*: TKeySym = 0x000000C1 + XKc_Acircumflex*: TKeySym = 0x000000C2 + XKc_Atilde*: TKeySym = 0x000000C3 + XKc_Adiaeresis*: TKeySym = 0x000000C4 + XKc_Aring*: TKeySym = 0x000000C5 + XKc_AE*: TKeySym = 0x000000C6 + XKc_Ccedilla*: TKeySym = 0x000000C7 + XKc_Egrave*: TKeySym = 0x000000C8 + XKc_Eacute*: TKeySym = 0x000000C9 + XKc_Ecircumflex*: TKeySym = 0x000000CA + XKc_Ediaeresis*: TKeySym = 0x000000CB + XKc_Igrave*: TKeySym = 0x000000CC + XKc_Iacute*: TKeySym = 0x000000CD + XKc_Icircumflex*: TKeySym = 0x000000CE + XKc_Idiaeresis*: TKeySym = 0x000000CF + XKc_ETH*: TKeySym = 0x000000D0 + XKc_Ntilde*: TKeySym = 0x000000D1 + XKc_Ograve*: TKeySym = 0x000000D2 + XKc_Oacute*: TKeySym = 0x000000D3 + XKc_Ocircumflex*: TKeySym = 0x000000D4 + XKc_Otilde*: TKeySym = 0x000000D5 + XKc_Odiaeresis*: TKeySym = 0x000000D6 + XK_multiply*: TKeySym = 0x000000D7 + XKc_Ooblique*: TKeySym = 0x000000D8 + XKc_Oslash*: TKeySym = XKc_Ooblique + XKc_Ugrave*: TKeySym = 0x000000D9 + XKc_Uacute*: TKeySym = 0x000000DA + XKc_Ucircumflex*: TKeySym = 0x000000DB + XKc_Udiaeresis*: TKeySym = 0x000000DC + XKc_Yacute*: TKeySym = 0x000000DD + XKc_THORN*: TKeySym = 0x000000DE + XK_ssharp*: TKeySym = 0x000000DF + XK_agrave*: TKeySym = 0x000000E0 + XK_aacute*: TKeySym = 0x000000E1 + XK_acircumflex*: TKeySym = 0x000000E2 + XK_atilde*: TKeySym = 0x000000E3 + XK_adiaeresis*: TKeySym = 0x000000E4 + XK_aring*: TKeySym = 0x000000E5 + XK_ae*: TKeySym = 0x000000E6 + XK_ccedilla*: TKeySym = 0x000000E7 + XK_egrave*: TKeySym = 0x000000E8 + XK_eacute*: TKeySym = 0x000000E9 + XK_ecircumflex*: TKeySym = 0x000000EA + XK_ediaeresis*: TKeySym = 0x000000EB + XK_igrave*: TKeySym = 0x000000EC + XK_iacute*: TKeySym = 0x000000ED + XK_icircumflex*: TKeySym = 0x000000EE + XK_idiaeresis*: TKeySym = 0x000000EF + XK_eth*: TKeySym = 0x000000F0 + XK_ntilde*: TKeySym = 0x000000F1 + XK_ograve*: TKeySym = 0x000000F2 + XK_oacute*: TKeySym = 0x000000F3 + XK_ocircumflex*: TKeySym = 0x000000F4 + XK_otilde*: TKeySym = 0x000000F5 + XK_odiaeresis*: TKeySym = 0x000000F6 + XK_division*: TKeySym = 0x000000F7 + XK_oslash*: TKeySym = 0x000000F8 + XK_ooblique*: TKeySym = XK_oslash + XK_ugrave*: TKeySym = 0x000000F9 + XK_uacute*: TKeySym = 0x000000FA + XK_ucircumflex*: TKeySym = 0x000000FB + XK_udiaeresis*: TKeySym = 0x000000FC + XK_yacute*: TKeySym = 0x000000FD + XK_thorn*: TKeySym = 0x000000FE + XK_ydiaeresis*: TKeySym = 0x000000FF +# XK_LATIN1 +#* +# * Latin 2 +# * Byte 3 = 1 +# * + +when defined(XK_LATIN2) or true: + const + XKc_Aogonek*: TKeySym = 0x000001A1 + XK_breve*: TKeySym = 0x000001A2 + XKc_Lstroke*: TKeySym = 0x000001A3 + XKc_Lcaron*: TKeySym = 0x000001A5 + XKc_Sacute*: TKeySym = 0x000001A6 + XKc_Scaron*: TKeySym = 0x000001A9 + XKc_Scedilla*: TKeySym = 0x000001AA + XKc_Tcaron*: TKeySym = 0x000001AB + XKc_Zacute*: TKeySym = 0x000001AC + XKc_Zcaron*: TKeySym = 0x000001AE + XKc_Zabovedot*: TKeySym = 0x000001AF + XK_aogonek*: TKeySym = 0x000001B1 + XK_ogonek*: TKeySym = 0x000001B2 + XK_lstroke*: TKeySym = 0x000001B3 + XK_lcaron*: TKeySym = 0x000001B5 + XK_sacute*: TKeySym = 0x000001B6 + XK_caron*: TKeySym = 0x000001B7 + XK_scaron*: TKeySym = 0x000001B9 + XK_scedilla*: TKeySym = 0x000001BA + XK_tcaron*: TKeySym = 0x000001BB + XK_zacute*: TKeySym = 0x000001BC + XK_doubleacute*: TKeySym = 0x000001BD + XK_zcaron*: TKeySym = 0x000001BE + XK_zabovedot*: TKeySym = 0x000001BF + XKc_Racute*: TKeySym = 0x000001C0 + XKc_Abreve*: TKeySym = 0x000001C3 + XKc_Lacute*: TKeySym = 0x000001C5 + XKc_Cacute*: TKeySym = 0x000001C6 + XKc_Ccaron*: TKeySym = 0x000001C8 + XKc_Eogonek*: TKeySym = 0x000001CA + XKc_Ecaron*: TKeySym = 0x000001CC + XKc_Dcaron*: TKeySym = 0x000001CF + XKc_Dstroke*: TKeySym = 0x000001D0 + XKc_Nacute*: TKeySym = 0x000001D1 + XKc_Ncaron*: TKeySym = 0x000001D2 + XKc_Odoubleacute*: TKeySym = 0x000001D5 + XKc_Rcaron*: TKeySym = 0x000001D8 + XKc_Uring*: TKeySym = 0x000001D9 + XKc_Udoubleacute*: TKeySym = 0x000001DB + XKc_Tcedilla*: TKeySym = 0x000001DE + XK_racute*: TKeySym = 0x000001E0 + XK_abreve*: TKeySym = 0x000001E3 + XK_lacute*: TKeySym = 0x000001E5 + XK_cacute*: TKeySym = 0x000001E6 + XK_ccaron*: TKeySym = 0x000001E8 + XK_eogonek*: TKeySym = 0x000001EA + XK_ecaron*: TKeySym = 0x000001EC + XK_dcaron*: TKeySym = 0x000001EF + XK_dstroke*: TKeySym = 0x000001F0 + XK_nacute*: TKeySym = 0x000001F1 + XK_ncaron*: TKeySym = 0x000001F2 + XK_odoubleacute*: TKeySym = 0x000001F5 + XK_udoubleacute*: TKeySym = 0x000001FB + XK_rcaron*: TKeySym = 0x000001F8 + XK_uring*: TKeySym = 0x000001F9 + XK_tcedilla*: TKeySym = 0x000001FE + XK_abovedot*: TKeySym = 0x000001FF +# XK_LATIN2 +#* +# * Latin 3 +# * Byte 3 = 2 +# * + +when defined(XK_LATIN3) or true: + const + XKc_Hstroke*: TKeySym = 0x000002A1 + XKc_Hcircumflex*: TKeySym = 0x000002A6 + XKc_Iabovedot*: TKeySym = 0x000002A9 + XKc_Gbreve*: TKeySym = 0x000002AB + XKc_Jcircumflex*: TKeySym = 0x000002AC + XK_hstroke*: TKeySym = 0x000002B1 + XK_hcircumflex*: TKeySym = 0x000002B6 + XK_idotless*: TKeySym = 0x000002B9 + XK_gbreve*: TKeySym = 0x000002BB + XK_jcircumflex*: TKeySym = 0x000002BC + XKc_Cabovedot*: TKeySym = 0x000002C5 + XKc_Ccircumflex*: TKeySym = 0x000002C6 + XKc_Gabovedot*: TKeySym = 0x000002D5 + XKc_Gcircumflex*: TKeySym = 0x000002D8 + XKc_Ubreve*: TKeySym = 0x000002DD + XKc_Scircumflex*: TKeySym = 0x000002DE + XK_cabovedot*: TKeySym = 0x000002E5 + XK_ccircumflex*: TKeySym = 0x000002E6 + XK_gabovedot*: TKeySym = 0x000002F5 + XK_gcircumflex*: TKeySym = 0x000002F8 + XK_ubreve*: TKeySym = 0x000002FD + XK_scircumflex*: TKeySym = 0x000002FE +# XK_LATIN3 +#* +# * Latin 4 +# * Byte 3 = 3 +# * + +when defined(XK_LATIN4) or true: + const + XK_kra*: TKeySym = 0x000003A2 + XK_kappa*: TKeySym = 0x000003A2 # deprecated + XKc_Rcedilla*: TKeySym = 0x000003A3 + XKc_Itilde*: TKeySym = 0x000003A5 + XKc_Lcedilla*: TKeySym = 0x000003A6 + XKc_Emacron*: TKeySym = 0x000003AA + XKc_Gcedilla*: TKeySym = 0x000003AB + XKc_Tslash*: TKeySym = 0x000003AC + XK_rcedilla*: TKeySym = 0x000003B3 + XK_itilde*: TKeySym = 0x000003B5 + XK_lcedilla*: TKeySym = 0x000003B6 + XK_emacron*: TKeySym = 0x000003BA + XK_gcedilla*: TKeySym = 0x000003BB + XK_tslash*: TKeySym = 0x000003BC + XKc_ENG*: TKeySym = 0x000003BD + XK_eng*: TKeySym = 0x000003BF + XKc_Amacron*: TKeySym = 0x000003C0 + XKc_Iogonek*: TKeySym = 0x000003C7 + XKc_Eabovedot*: TKeySym = 0x000003CC + XKc_Imacron*: TKeySym = 0x000003CF + XKc_Ncedilla*: TKeySym = 0x000003D1 + XKc_Omacron*: TKeySym = 0x000003D2 + XKc_Kcedilla*: TKeySym = 0x000003D3 + XKc_Uogonek*: TKeySym = 0x000003D9 + XKc_Utilde*: TKeySym = 0x000003DD + XKc_Umacron*: TKeySym = 0x000003DE + XK_amacron*: TKeySym = 0x000003E0 + XK_iogonek*: TKeySym = 0x000003E7 + XK_eabovedot*: TKeySym = 0x000003EC + XK_imacron*: TKeySym = 0x000003EF + XK_ncedilla*: TKeySym = 0x000003F1 + XK_omacron*: TKeySym = 0x000003F2 + XK_kcedilla*: TKeySym = 0x000003F3 + XK_uogonek*: TKeySym = 0x000003F9 + XK_utilde*: TKeySym = 0x000003FD + XK_umacron*: TKeySym = 0x000003FE +# XK_LATIN4 +#* +# * Latin-8 +# * Byte 3 = 18 +# * + +when defined(XK_LATIN8) or true: + const + XKc_Babovedot*: TKeySym = 0x000012A1 + XK_babovedot*: TKeySym = 0x000012A2 + XKc_Dabovedot*: TKeySym = 0x000012A6 + XKc_Wgrave*: TKeySym = 0x000012A8 + XKc_Wacute*: TKeySym = 0x000012AA + XK_dabovedot*: TKeySym = 0x000012AB + XKc_Ygrave*: TKeySym = 0x000012AC + XKc_Fabovedot*: TKeySym = 0x000012B0 + XK_fabovedot*: TKeySym = 0x000012B1 + XKc_Mabovedot*: TKeySym = 0x000012B4 + XK_mabovedot*: TKeySym = 0x000012B5 + XKc_Pabovedot*: TKeySym = 0x000012B7 + XK_wgrave*: TKeySym = 0x000012B8 + XK_pabovedot*: TKeySym = 0x000012B9 + XK_wacute*: TKeySym = 0x000012BA + XKc_Sabovedot*: TKeySym = 0x000012BB + XK_ygrave*: TKeySym = 0x000012BC + XKc_Wdiaeresis*: TKeySym = 0x000012BD + XK_wdiaeresis*: TKeySym = 0x000012BE + XK_sabovedot*: TKeySym = 0x000012BF + XKc_Wcircumflex*: TKeySym = 0x000012D0 + XKc_Tabovedot*: TKeySym = 0x000012D7 + XKc_Ycircumflex*: TKeySym = 0x000012DE + XK_wcircumflex*: TKeySym = 0x000012F0 + XK_tabovedot*: TKeySym = 0x000012F7 + XK_ycircumflex*: TKeySym = 0x000012FE +# XK_LATIN8 +#* +# * Latin-9 (a.k.a. Latin-0) +# * Byte 3 = 19 +# * + +when defined(XK_LATIN9) or true: + const + XKc_OE*: TKeySym = 0x000013BC + XK_oe*: TKeySym = 0x000013BD + XKc_Ydiaeresis*: TKeySym = 0x000013BE +# XK_LATIN9 +#* +# * Katakana +# * Byte 3 = 4 +# * + +when defined(XK_KATAKANA) or true: + const + XK_overline*: TKeySym = 0x0000047E + XK_kana_fullstop*: TKeySym = 0x000004A1 + XK_kana_openingbracket*: TKeySym = 0x000004A2 + XK_kana_closingbracket*: TKeySym = 0x000004A3 + XK_kana_comma*: TKeySym = 0x000004A4 + XK_kana_conjunctive*: TKeySym = 0x000004A5 + XK_kana_middledot*: TKeySym = 0x000004A5 # deprecated + XKc_kana_WO*: TKeySym = 0x000004A6 + XK_kana_a*: TKeySym = 0x000004A7 + XK_kana_i*: TKeySym = 0x000004A8 + XK_kana_u*: TKeySym = 0x000004A9 + XK_kana_e*: TKeySym = 0x000004AA + XK_kana_o*: TKeySym = 0x000004AB + XK_kana_ya*: TKeySym = 0x000004AC + XK_kana_yu*: TKeySym = 0x000004AD + XK_kana_yo*: TKeySym = 0x000004AE + XK_kana_tsu*: TKeySym = 0x000004AF + XK_kana_tu*: TKeySym = 0x000004AF # deprecated + XK_prolongedsound*: TKeySym = 0x000004B0 + XKc_kana_A*: TKeySym = 0x000004B1 + XKc_kana_I*: TKeySym = 0x000004B2 + XKc_kana_U*: TKeySym = 0x000004B3 + XKc_kana_E*: TKeySym = 0x000004B4 + XKc_kana_O*: TKeySym = 0x000004B5 + XKc_kana_KA*: TKeySym = 0x000004B6 + XKc_kana_KI*: TKeySym = 0x000004B7 + XKc_kana_KU*: TKeySym = 0x000004B8 + XKc_kana_KE*: TKeySym = 0x000004B9 + XKc_kana_KO*: TKeySym = 0x000004BA + XKc_kana_SA*: TKeySym = 0x000004BB + XKc_kana_SHI*: TKeySym = 0x000004BC + XKc_kana_SU*: TKeySym = 0x000004BD + XKc_kana_SE*: TKeySym = 0x000004BE + XKc_kana_SO*: TKeySym = 0x000004BF + XKc_kana_TA*: TKeySym = 0x000004C0 + XKc_kana_CHI*: TKeySym = 0x000004C1 + XKc_kana_TI*: TKeySym = 0x000004C1 # deprecated + XKc_kana_TSU*: TKeySym = 0x000004C2 + XKc_kana_TU*: TKeySym = 0x000004C2 # deprecated + XKc_kana_TE*: TKeySym = 0x000004C3 + XKc_kana_TO*: TKeySym = 0x000004C4 + XKc_kana_NA*: TKeySym = 0x000004C5 + XKc_kana_NI*: TKeySym = 0x000004C6 + XKc_kana_NU*: TKeySym = 0x000004C7 + XKc_kana_NE*: TKeySym = 0x000004C8 + XKc_kana_NO*: TKeySym = 0x000004C9 + XKc_kana_HA*: TKeySym = 0x000004CA + XKc_kana_HI*: TKeySym = 0x000004CB + XKc_kana_FU*: TKeySym = 0x000004CC + XKc_kana_HU*: TKeySym = 0x000004CC # deprecated + XKc_kana_HE*: TKeySym = 0x000004CD + XKc_kana_HO*: TKeySym = 0x000004CE + XKc_kana_MA*: TKeySym = 0x000004CF + XKc_kana_MI*: TKeySym = 0x000004D0 + XKc_kana_MU*: TKeySym = 0x000004D1 + XKc_kana_ME*: TKeySym = 0x000004D2 + XKc_kana_MO*: TKeySym = 0x000004D3 + XKc_kana_YA*: TKeySym = 0x000004D4 + XKc_kana_YU*: TKeySym = 0x000004D5 + XKc_kana_YO*: TKeySym = 0x000004D6 + XKc_kana_RA*: TKeySym = 0x000004D7 + XKc_kana_RI*: TKeySym = 0x000004D8 + XKc_kana_RU*: TKeySym = 0x000004D9 + XKc_kana_RE*: TKeySym = 0x000004DA + XKc_kana_RO*: TKeySym = 0x000004DB + XKc_kana_WA*: TKeySym = 0x000004DC + XKc_kana_N*: TKeySym = 0x000004DD + XK_voicedsound*: TKeySym = 0x000004DE + XK_semivoicedsound*: TKeySym = 0x000004DF + XK_kana_switch*: TKeySym = 0x0000FF7E # Alias for mode_switch +# XK_KATAKANA +#* +# * Arabic +# * Byte 3 = 5 +# * + +when defined(XK_ARABIC) or true: + const + XK_Farsi_0*: TKeySym = 0x00000590 + XK_Farsi_1*: TKeySym = 0x00000591 + XK_Farsi_2*: TKeySym = 0x00000592 + XK_Farsi_3*: TKeySym = 0x00000593 + XK_Farsi_4*: TKeySym = 0x00000594 + XK_Farsi_5*: TKeySym = 0x00000595 + XK_Farsi_6*: TKeySym = 0x00000596 + XK_Farsi_7*: TKeySym = 0x00000597 + XK_Farsi_8*: TKeySym = 0x00000598 + XK_Farsi_9*: TKeySym = 0x00000599 + XK_Arabic_percent*: TKeySym = 0x000005A5 + XK_Arabic_superscript_alef*: TKeySym = 0x000005A6 + XK_Arabic_tteh*: TKeySym = 0x000005A7 + XK_Arabic_peh*: TKeySym = 0x000005A8 + XK_Arabic_tcheh*: TKeySym = 0x000005A9 + XK_Arabic_ddal*: TKeySym = 0x000005AA + XK_Arabic_rreh*: TKeySym = 0x000005AB + XK_Arabic_comma*: TKeySym = 0x000005AC + XK_Arabic_fullstop*: TKeySym = 0x000005AE + XK_Arabic_0*: TKeySym = 0x000005B0 + XK_Arabic_1*: TKeySym = 0x000005B1 + XK_Arabic_2*: TKeySym = 0x000005B2 + XK_Arabic_3*: TKeySym = 0x000005B3 + XK_Arabic_4*: TKeySym = 0x000005B4 + XK_Arabic_5*: TKeySym = 0x000005B5 + XK_Arabic_6*: TKeySym = 0x000005B6 + XK_Arabic_7*: TKeySym = 0x000005B7 + XK_Arabic_8*: TKeySym = 0x000005B8 + XK_Arabic_9*: TKeySym = 0x000005B9 + XK_Arabic_semicolon*: TKeySym = 0x000005BB + XK_Arabic_question_mark*: TKeySym = 0x000005BF + XK_Arabic_hamza*: TKeySym = 0x000005C1 + XK_Arabic_maddaonalef*: TKeySym = 0x000005C2 + XK_Arabic_hamzaonalef*: TKeySym = 0x000005C3 + XK_Arabic_hamzaonwaw*: TKeySym = 0x000005C4 + XK_Arabic_hamzaunderalef*: TKeySym = 0x000005C5 + XK_Arabic_hamzaonyeh*: TKeySym = 0x000005C6 + XK_Arabic_alef*: TKeySym = 0x000005C7 + XK_Arabic_beh*: TKeySym = 0x000005C8 + XK_Arabic_tehmarbuta*: TKeySym = 0x000005C9 + XK_Arabic_teh*: TKeySym = 0x000005CA + XK_Arabic_theh*: TKeySym = 0x000005CB + XK_Arabic_jeem*: TKeySym = 0x000005CC + XK_Arabic_hah*: TKeySym = 0x000005CD + XK_Arabic_khah*: TKeySym = 0x000005CE + XK_Arabic_dal*: TKeySym = 0x000005CF + XK_Arabic_thal*: TKeySym = 0x000005D0 + XK_Arabic_ra*: TKeySym = 0x000005D1 + XK_Arabic_zain*: TKeySym = 0x000005D2 + XK_Arabic_seen*: TKeySym = 0x000005D3 + XK_Arabic_sheen*: TKeySym = 0x000005D4 + XK_Arabic_sad*: TKeySym = 0x000005D5 + XK_Arabic_dad*: TKeySym = 0x000005D6 + XK_Arabic_tah*: TKeySym = 0x000005D7 + XK_Arabic_zah*: TKeySym = 0x000005D8 + XK_Arabic_ain*: TKeySym = 0x000005D9 + XK_Arabic_ghain*: TKeySym = 0x000005DA + XK_Arabic_tatweel*: TKeySym = 0x000005E0 + XK_Arabic_feh*: TKeySym = 0x000005E1 + XK_Arabic_qaf*: TKeySym = 0x000005E2 + XK_Arabic_kaf*: TKeySym = 0x000005E3 + XK_Arabic_lam*: TKeySym = 0x000005E4 + XK_Arabic_meem*: TKeySym = 0x000005E5 + XK_Arabic_noon*: TKeySym = 0x000005E6 + XK_Arabic_ha*: TKeySym = 0x000005E7 + XK_Arabic_heh*: TKeySym = 0x000005E7 # deprecated + XK_Arabic_waw*: TKeySym = 0x000005E8 + XK_Arabic_alefmaksura*: TKeySym = 0x000005E9 + XK_Arabic_yeh*: TKeySym = 0x000005EA + XK_Arabic_fathatan*: TKeySym = 0x000005EB + XK_Arabic_dammatan*: TKeySym = 0x000005EC + XK_Arabic_kasratan*: TKeySym = 0x000005ED + XK_Arabic_fatha*: TKeySym = 0x000005EE + XK_Arabic_damma*: TKeySym = 0x000005EF + XK_Arabic_kasra*: TKeySym = 0x000005F0 + XK_Arabic_shadda*: TKeySym = 0x000005F1 + XK_Arabic_sukun*: TKeySym = 0x000005F2 + XK_Arabic_madda_above*: TKeySym = 0x000005F3 + XK_Arabic_hamza_above*: TKeySym = 0x000005F4 + XK_Arabic_hamza_below*: TKeySym = 0x000005F5 + XK_Arabic_jeh*: TKeySym = 0x000005F6 + XK_Arabic_veh*: TKeySym = 0x000005F7 + XK_Arabic_keheh*: TKeySym = 0x000005F8 + XK_Arabic_gaf*: TKeySym = 0x000005F9 + XK_Arabic_noon_ghunna*: TKeySym = 0x000005FA + XK_Arabic_heh_doachashmee*: TKeySym = 0x000005FB + XK_Farsi_yeh*: TKeySym = 0x000005FC + XK_Arabic_farsi_yeh*: TKeySym = XK_Farsi_yeh + XK_Arabic_yeh_baree*: TKeySym = 0x000005FD + XK_Arabic_heh_goal*: TKeySym = 0x000005FE + XK_Arabic_switch*: TKeySym = 0x0000FF7E # Alias for mode_switch +# XK_ARABIC +#* +# * Cyrillic +# * Byte 3 = 6 +# * + +when defined(XK_CYRILLIC) or true: + const + XKc_Cyrillic_GHE_bar*: TKeySym = 0x00000680 + XK_Cyrillic_ghe_bar*: TKeySym = 0x00000690 + XKc_Cyrillic_ZHE_descender*: TKeySym = 0x00000681 + XK_Cyrillic_zhe_descender*: TKeySym = 0x00000691 + XKc_Cyrillic_KA_descender*: TKeySym = 0x00000682 + XK_Cyrillic_ka_descender*: TKeySym = 0x00000692 + XKc_Cyrillic_KA_vertstroke*: TKeySym = 0x00000683 + XK_Cyrillic_ka_vertstroke*: TKeySym = 0x00000693 + XKc_Cyrillic_EN_descender*: TKeySym = 0x00000684 + XK_Cyrillic_en_descender*: TKeySym = 0x00000694 + XKc_Cyrillic_U_straight*: TKeySym = 0x00000685 + XK_Cyrillic_u_straight*: TKeySym = 0x00000695 + XKc_Cyrillic_U_straight_bar*: TKeySym = 0x00000686 + XK_Cyrillic_u_straight_bar*: TKeySym = 0x00000696 + XKc_Cyrillic_HA_descender*: TKeySym = 0x00000687 + XK_Cyrillic_ha_descender*: TKeySym = 0x00000697 + XKc_Cyrillic_CHE_descender*: TKeySym = 0x00000688 + XK_Cyrillic_che_descender*: TKeySym = 0x00000698 + XKc_Cyrillic_CHE_vertstroke*: TKeySym = 0x00000689 + XK_Cyrillic_che_vertstroke*: TKeySym = 0x00000699 + XKc_Cyrillic_SHHA*: TKeySym = 0x0000068A + XK_Cyrillic_shha*: TKeySym = 0x0000069A + XKc_Cyrillic_SCHWA*: TKeySym = 0x0000068C + XK_Cyrillic_schwa*: TKeySym = 0x0000069C + XKc_Cyrillic_I_macron*: TKeySym = 0x0000068D + XK_Cyrillic_i_macron*: TKeySym = 0x0000069D + XKc_Cyrillic_O_bar*: TKeySym = 0x0000068E + XK_Cyrillic_o_bar*: TKeySym = 0x0000069E + XKc_Cyrillic_U_macron*: TKeySym = 0x0000068F + XK_Cyrillic_u_macron*: TKeySym = 0x0000069F + XK_Serbian_dje*: TKeySym = 0x000006A1 + XK_Macedonia_gje*: TKeySym = 0x000006A2 + XK_Cyrillic_io*: TKeySym = 0x000006A3 + XK_Ukrainian_ie*: TKeySym = 0x000006A4 + XK_Ukranian_je*: TKeySym = 0x000006A4 # deprecated + XK_Macedonia_dse*: TKeySym = 0x000006A5 + XK_Ukrainian_i*: TKeySym = 0x000006A6 + XK_Ukranian_i*: TKeySym = 0x000006A6 # deprecated + XK_Ukrainian_yi*: TKeySym = 0x000006A7 + XK_Ukranian_yi*: TKeySym = 0x000006A7 # deprecated + XK_Cyrillic_je*: TKeySym = 0x000006A8 + XK_Serbian_je*: TKeySym = 0x000006A8 # deprecated + XK_Cyrillic_lje*: TKeySym = 0x000006A9 + XK_Serbian_lje*: TKeySym = 0x000006A9 # deprecated + XK_Cyrillic_nje*: TKeySym = 0x000006AA + XK_Serbian_nje*: TKeySym = 0x000006AA # deprecated + XK_Serbian_tshe*: TKeySym = 0x000006AB + XK_Macedonia_kje*: TKeySym = 0x000006AC + XK_Ukrainian_ghe_with_upturn*: TKeySym = 0x000006AD + XK_Byelorussian_shortu*: TKeySym = 0x000006AE + XK_Cyrillic_dzhe*: TKeySym = 0x000006AF + XK_Serbian_dze*: TKeySym = 0x000006AF # deprecated + XK_numerosign*: TKeySym = 0x000006B0 + XKc_Serbian_DJE*: TKeySym = 0x000006B1 + XKc_Macedonia_GJE*: TKeySym = 0x000006B2 + XKc_Cyrillic_IO*: TKeySym = 0x000006B3 + XKc_Ukrainian_IE*: TKeySym = 0x000006B4 + XKc_Ukranian_JE*: TKeySym = 0x000006B4 # deprecated + XKc_Macedonia_DSE*: TKeySym = 0x000006B5 + XKc_Ukrainian_I*: TKeySym = 0x000006B6 + XKc_Ukranian_I*: TKeySym = 0x000006B6 # deprecated + XKc_Ukrainian_YI*: TKeySym = 0x000006B7 + XKc_Ukranian_YI*: TKeySym = 0x000006B7 # deprecated + XKc_Cyrillic_JE*: TKeySym = 0x000006B8 + XKc_Serbian_JE*: TKeySym = 0x000006B8 # deprecated + XKc_Cyrillic_LJE*: TKeySym = 0x000006B9 + XKc_Serbian_LJE*: TKeySym = 0x000006B9 # deprecated + XKc_Cyrillic_NJE*: TKeySym = 0x000006BA + XKc_Serbian_NJE*: TKeySym = 0x000006BA # deprecated + XKc_Serbian_TSHE*: TKeySym = 0x000006BB + XKc_Macedonia_KJE*: TKeySym = 0x000006BC + XKc_Ukrainian_GHE_WITH_UPTURN*: TKeySym = 0x000006BD + XKc_Byelorussian_SHORTU*: TKeySym = 0x000006BE + XKc_Cyrillic_DZHE*: TKeySym = 0x000006BF + XKc_Serbian_DZE*: TKeySym = 0x000006BF # deprecated + XK_Cyrillic_yu*: TKeySym = 0x000006C0 + XK_Cyrillic_a*: TKeySym = 0x000006C1 + XK_Cyrillic_be*: TKeySym = 0x000006C2 + XK_Cyrillic_tse*: TKeySym = 0x000006C3 + XK_Cyrillic_de*: TKeySym = 0x000006C4 + XK_Cyrillic_ie*: TKeySym = 0x000006C5 + XK_Cyrillic_ef*: TKeySym = 0x000006C6 + XK_Cyrillic_ghe*: TKeySym = 0x000006C7 + XK_Cyrillic_ha*: TKeySym = 0x000006C8 + XK_Cyrillic_i*: TKeySym = 0x000006C9 + XK_Cyrillic_shorti*: TKeySym = 0x000006CA + XK_Cyrillic_ka*: TKeySym = 0x000006CB + XK_Cyrillic_el*: TKeySym = 0x000006CC + XK_Cyrillic_em*: TKeySym = 0x000006CD + XK_Cyrillic_en*: TKeySym = 0x000006CE + XK_Cyrillic_o*: TKeySym = 0x000006CF + XK_Cyrillic_pe*: TKeySym = 0x000006D0 + XK_Cyrillic_ya*: TKeySym = 0x000006D1 + XK_Cyrillic_er*: TKeySym = 0x000006D2 + XK_Cyrillic_es*: TKeySym = 0x000006D3 + XK_Cyrillic_te*: TKeySym = 0x000006D4 + XK_Cyrillic_u*: TKeySym = 0x000006D5 + XK_Cyrillic_zhe*: TKeySym = 0x000006D6 + XK_Cyrillic_ve*: TKeySym = 0x000006D7 + XK_Cyrillic_softsign*: TKeySym = 0x000006D8 + XK_Cyrillic_yeru*: TKeySym = 0x000006D9 + XK_Cyrillic_ze*: TKeySym = 0x000006DA + XK_Cyrillic_sha*: TKeySym = 0x000006DB + XK_Cyrillic_e*: TKeySym = 0x000006DC + XK_Cyrillic_shcha*: TKeySym = 0x000006DD + XK_Cyrillic_che*: TKeySym = 0x000006DE + XK_Cyrillic_hardsign*: TKeySym = 0x000006DF + XKc_Cyrillic_YU*: TKeySym = 0x000006E0 + XKc_Cyrillic_A*: TKeySym = 0x000006E1 + XKc_Cyrillic_BE*: TKeySym = 0x000006E2 + XKc_Cyrillic_TSE*: TKeySym = 0x000006E3 + XKc_Cyrillic_DE*: TKeySym = 0x000006E4 + XKc_Cyrillic_IE*: TKeySym = 0x000006E5 + XKc_Cyrillic_EF*: TKeySym = 0x000006E6 + XKc_Cyrillic_GHE*: TKeySym = 0x000006E7 + XKc_Cyrillic_HA*: TKeySym = 0x000006E8 + XKc_Cyrillic_I*: TKeySym = 0x000006E9 + XKc_Cyrillic_SHORTI*: TKeySym = 0x000006EA + XKc_Cyrillic_KA*: TKeySym = 0x000006EB + XKc_Cyrillic_EL*: TKeySym = 0x000006EC + XKc_Cyrillic_EM*: TKeySym = 0x000006ED + XKc_Cyrillic_EN*: TKeySym = 0x000006EE + XKc_Cyrillic_O*: TKeySym = 0x000006EF + XKc_Cyrillic_PE*: TKeySym = 0x000006F0 + XKc_Cyrillic_YA*: TKeySym = 0x000006F1 + XKc_Cyrillic_ER*: TKeySym = 0x000006F2 + XKc_Cyrillic_ES*: TKeySym = 0x000006F3 + XKc_Cyrillic_TE*: TKeySym = 0x000006F4 + XKc_Cyrillic_U*: TKeySym = 0x000006F5 + XKc_Cyrillic_ZHE*: TKeySym = 0x000006F6 + XKc_Cyrillic_VE*: TKeySym = 0x000006F7 + XKc_Cyrillic_SOFTSIGN*: TKeySym = 0x000006F8 + XKc_Cyrillic_YERU*: TKeySym = 0x000006F9 + XKc_Cyrillic_ZE*: TKeySym = 0x000006FA + XKc_Cyrillic_SHA*: TKeySym = 0x000006FB + XKc_Cyrillic_E*: TKeySym = 0x000006FC + XKc_Cyrillic_SHCHA*: TKeySym = 0x000006FD + XKc_Cyrillic_CHE*: TKeySym = 0x000006FE + XKc_Cyrillic_HARDSIGN*: TKeySym = 0x000006FF +# XK_CYRILLIC +#* +# * Greek +# * Byte 3 = 7 +# * + +when defined(XK_GREEK) or true: + const + XKc_Greek_ALPHAaccent*: TKeySym = 0x000007A1 + XKc_Greek_EPSILONaccent*: TKeySym = 0x000007A2 + XKc_Greek_ETAaccent*: TKeySym = 0x000007A3 + XKc_Greek_IOTAaccent*: TKeySym = 0x000007A4 + XKc_Greek_IOTAdieresis*: TKeySym = 0x000007A5 + XKc_Greek_IOTAdiaeresis*: TKeySym = XKc_Greek_IOTAdieresis # old typo + XKc_Greek_OMICRONaccent*: TKeySym = 0x000007A7 + XKc_Greek_UPSILONaccent*: TKeySym = 0x000007A8 + XKc_Greek_UPSILONdieresis*: TKeySym = 0x000007A9 + XKc_Greek_OMEGAaccent*: TKeySym = 0x000007AB + XK_Greek_accentdieresis*: TKeySym = 0x000007AE + XK_Greek_horizbar*: TKeySym = 0x000007AF + XK_Greek_alphaaccent*: TKeySym = 0x000007B1 + XK_Greek_epsilonaccent*: TKeySym = 0x000007B2 + XK_Greek_etaaccent*: TKeySym = 0x000007B3 + XK_Greek_iotaaccent*: TKeySym = 0x000007B4 + XK_Greek_iotadieresis*: TKeySym = 0x000007B5 + XK_Greek_iotaaccentdieresis*: TKeySym = 0x000007B6 + XK_Greek_omicronaccent*: TKeySym = 0x000007B7 + XK_Greek_upsilonaccent*: TKeySym = 0x000007B8 + XK_Greek_upsilondieresis*: TKeySym = 0x000007B9 + XK_Greek_upsilonaccentdieresis*: TKeySym = 0x000007BA + XK_Greek_omegaaccent*: TKeySym = 0x000007BB + XKc_Greek_ALPHA*: TKeySym = 0x000007C1 + XKc_Greek_BETA*: TKeySym = 0x000007C2 + XKc_Greek_GAMMA*: TKeySym = 0x000007C3 + XKc_Greek_DELTA*: TKeySym = 0x000007C4 + XKc_Greek_EPSILON*: TKeySym = 0x000007C5 + XKc_Greek_ZETA*: TKeySym = 0x000007C6 + XKc_Greek_ETA*: TKeySym = 0x000007C7 + XKc_Greek_THETA*: TKeySym = 0x000007C8 + XKc_Greek_IOTA*: TKeySym = 0x000007C9 + XKc_Greek_KAPPA*: TKeySym = 0x000007CA + XKc_Greek_LAMDA*: TKeySym = 0x000007CB + XKc_Greek_LAMBDA*: TKeySym = 0x000007CB + XKc_Greek_MU*: TKeySym = 0x000007CC + XKc_Greek_NU*: TKeySym = 0x000007CD + XKc_Greek_XI*: TKeySym = 0x000007CE + XKc_Greek_OMICRON*: TKeySym = 0x000007CF + XKc_Greek_PI*: TKeySym = 0x000007D0 + XKc_Greek_RHO*: TKeySym = 0x000007D1 + XKc_Greek_SIGMA*: TKeySym = 0x000007D2 + XKc_Greek_TAU*: TKeySym = 0x000007D4 + XKc_Greek_UPSILON*: TKeySym = 0x000007D5 + XKc_Greek_PHI*: TKeySym = 0x000007D6 + XKc_Greek_CHI*: TKeySym = 0x000007D7 + XKc_Greek_PSI*: TKeySym = 0x000007D8 + XKc_Greek_OMEGA*: TKeySym = 0x000007D9 + XK_Greek_alpha*: TKeySym = 0x000007E1 + XK_Greek_beta*: TKeySym = 0x000007E2 + XK_Greek_gamma*: TKeySym = 0x000007E3 + XK_Greek_delta*: TKeySym = 0x000007E4 + XK_Greek_epsilon*: TKeySym = 0x000007E5 + XK_Greek_zeta*: TKeySym = 0x000007E6 + XK_Greek_eta*: TKeySym = 0x000007E7 + XK_Greek_theta*: TKeySym = 0x000007E8 + XK_Greek_iota*: TKeySym = 0x000007E9 + XK_Greek_kappa*: TKeySym = 0x000007EA + XK_Greek_lamda*: TKeySym = 0x000007EB + XK_Greek_lambda*: TKeySym = 0x000007EB + XK_Greek_mu*: TKeySym = 0x000007EC + XK_Greek_nu*: TKeySym = 0x000007ED + XK_Greek_xi*: TKeySym = 0x000007EE + XK_Greek_omicron*: TKeySym = 0x000007EF + XK_Greek_pi*: TKeySym = 0x000007F0 + XK_Greek_rho*: TKeySym = 0x000007F1 + XK_Greek_sigma*: TKeySym = 0x000007F2 + XK_Greek_finalsmallsigma*: TKeySym = 0x000007F3 + XK_Greek_tau*: TKeySym = 0x000007F4 + XK_Greek_upsilon*: TKeySym = 0x000007F5 + XK_Greek_phi*: TKeySym = 0x000007F6 + XK_Greek_chi*: TKeySym = 0x000007F7 + XK_Greek_psi*: TKeySym = 0x000007F8 + XK_Greek_omega*: TKeySym = 0x000007F9 + XK_Greek_switch*: TKeySym = 0x0000FF7E # Alias for mode_switch +# XK_GREEK +#* +# * Technical +# * Byte 3 = 8 +# * + +when defined(XK_TECHNICAL) or true: + const + XK_leftradical*: TKeySym = 0x000008A1 + XK_topleftradical*: TKeySym = 0x000008A2 + XK_horizconnector*: TKeySym = 0x000008A3 + XK_topintegral*: TKeySym = 0x000008A4 + XK_botintegral*: TKeySym = 0x000008A5 + XK_vertconnector*: TKeySym = 0x000008A6 + XK_topleftsqbracket*: TKeySym = 0x000008A7 + XK_botleftsqbracket*: TKeySym = 0x000008A8 + XK_toprightsqbracket*: TKeySym = 0x000008A9 + XK_botrightsqbracket*: TKeySym = 0x000008AA + XK_topleftparens*: TKeySym = 0x000008AB + XK_botleftparens*: TKeySym = 0x000008AC + XK_toprightparens*: TKeySym = 0x000008AD + XK_botrightparens*: TKeySym = 0x000008AE + XK_leftmiddlecurlybrace*: TKeySym = 0x000008AF + XK_rightmiddlecurlybrace*: TKeySym = 0x000008B0 + XK_topleftsummation*: TKeySym = 0x000008B1 + XK_botleftsummation*: TKeySym = 0x000008B2 + XK_topvertsummationconnector*: TKeySym = 0x000008B3 + XK_botvertsummationconnector*: TKeySym = 0x000008B4 + XK_toprightsummation*: TKeySym = 0x000008B5 + XK_botrightsummation*: TKeySym = 0x000008B6 + XK_rightmiddlesummation*: TKeySym = 0x000008B7 + XK_lessthanequal*: TKeySym = 0x000008BC + XK_notequal*: TKeySym = 0x000008BD + XK_greaterthanequal*: TKeySym = 0x000008BE + XK_integral*: TKeySym = 0x000008BF + XK_therefore*: TKeySym = 0x000008C0 + XK_variation*: TKeySym = 0x000008C1 + XK_infinity*: TKeySym = 0x000008C2 + XK_nabla*: TKeySym = 0x000008C5 + XK_approximate*: TKeySym = 0x000008C8 + XK_similarequal*: TKeySym = 0x000008C9 + XK_ifonlyif*: TKeySym = 0x000008CD + XK_implies*: TKeySym = 0x000008CE + XK_identical*: TKeySym = 0x000008CF + XK_radical*: TKeySym = 0x000008D6 + XK_includedin*: TKeySym = 0x000008DA + XK_includes*: TKeySym = 0x000008DB + XK_intersection*: TKeySym = 0x000008DC + XK_union*: TKeySym = 0x000008DD + XK_logicaland*: TKeySym = 0x000008DE + XK_logicalor*: TKeySym = 0x000008DF + XK_partialderivative*: TKeySym = 0x000008EF + XK_function*: TKeySym = 0x000008F6 + XK_leftarrow*: TKeySym = 0x000008FB + XK_uparrow*: TKeySym = 0x000008FC + XK_rightarrow*: TKeySym = 0x000008FD + XK_downarrow*: TKeySym = 0x000008FE +# XK_TECHNICAL +#* +# * Special +# * Byte 3 = 9 +# * + +when defined(XK_SPECIAL): + const + XK_blank*: TKeySym = 0x000009DF + XK_soliddiamond*: TKeySym = 0x000009E0 + XK_checkerboard*: TKeySym = 0x000009E1 + XK_ht*: TKeySym = 0x000009E2 + XK_ff*: TKeySym = 0x000009E3 + XK_cr*: TKeySym = 0x000009E4 + XK_lf*: TKeySym = 0x000009E5 + XK_nl*: TKeySym = 0x000009E8 + XK_vt*: TKeySym = 0x000009E9 + XK_lowrightcorner*: TKeySym = 0x000009EA + XK_uprightcorner*: TKeySym = 0x000009EB + XK_upleftcorner*: TKeySym = 0x000009EC + XK_lowleftcorner*: TKeySym = 0x000009ED + XK_crossinglines*: TKeySym = 0x000009EE + XK_horizlinescan1*: TKeySym = 0x000009EF + XK_horizlinescan3*: TKeySym = 0x000009F0 + XK_horizlinescan5*: TKeySym = 0x000009F1 + XK_horizlinescan7*: TKeySym = 0x000009F2 + XK_horizlinescan9*: TKeySym = 0x000009F3 + XK_leftt*: TKeySym = 0x000009F4 + XK_rightt*: TKeySym = 0x000009F5 + XK_bott*: TKeySym = 0x000009F6 + XK_topt*: TKeySym = 0x000009F7 + XK_vertbar*: TKeySym = 0x000009F8 +# XK_SPECIAL +#* +# * Publishing +# * Byte 3 = a +# * + +when defined(XK_PUBLISHING) or true: + const + XK_emspace*: TKeySym = 0x00000AA1 + XK_enspace*: TKeySym = 0x00000AA2 + XK_em3space*: TKeySym = 0x00000AA3 + XK_em4space*: TKeySym = 0x00000AA4 + XK_digitspace*: TKeySym = 0x00000AA5 + XK_punctspace*: TKeySym = 0x00000AA6 + XK_thinspace*: TKeySym = 0x00000AA7 + XK_hairspace*: TKeySym = 0x00000AA8 + XK_emdash*: TKeySym = 0x00000AA9 + XK_endash*: TKeySym = 0x00000AAA + XK_signifblank*: TKeySym = 0x00000AAC + XK_ellipsis*: TKeySym = 0x00000AAE + XK_doubbaselinedot*: TKeySym = 0x00000AAF + XK_onethird*: TKeySym = 0x00000AB0 + XK_twothirds*: TKeySym = 0x00000AB1 + XK_onefifth*: TKeySym = 0x00000AB2 + XK_twofifths*: TKeySym = 0x00000AB3 + XK_threefifths*: TKeySym = 0x00000AB4 + XK_fourfifths*: TKeySym = 0x00000AB5 + XK_onesixth*: TKeySym = 0x00000AB6 + XK_fivesixths*: TKeySym = 0x00000AB7 + XK_careof*: TKeySym = 0x00000AB8 + XK_figdash*: TKeySym = 0x00000ABB + XK_leftanglebracket*: TKeySym = 0x00000ABC + XK_decimalpoint*: TKeySym = 0x00000ABD + XK_rightanglebracket*: TKeySym = 0x00000ABE + XK_marker*: TKeySym = 0x00000ABF + XK_oneeighth*: TKeySym = 0x00000AC3 + XK_threeeighths*: TKeySym = 0x00000AC4 + XK_fiveeighths*: TKeySym = 0x00000AC5 + XK_seveneighths*: TKeySym = 0x00000AC6 + XK_trademark*: TKeySym = 0x00000AC9 + XK_signaturemark*: TKeySym = 0x00000ACA + XK_trademarkincircle*: TKeySym = 0x00000ACB + XK_leftopentriangle*: TKeySym = 0x00000ACC + XK_rightopentriangle*: TKeySym = 0x00000ACD + XK_emopencircle*: TKeySym = 0x00000ACE + XK_emopenrectangle*: TKeySym = 0x00000ACF + XK_leftsinglequotemark*: TKeySym = 0x00000AD0 + XK_rightsinglequotemark*: TKeySym = 0x00000AD1 + XK_leftdoublequotemark*: TKeySym = 0x00000AD2 + XK_rightdoublequotemark*: TKeySym = 0x00000AD3 + XK_prescription*: TKeySym = 0x00000AD4 + XK_minutes*: TKeySym = 0x00000AD6 + XK_seconds*: TKeySym = 0x00000AD7 + XK_latincross*: TKeySym = 0x00000AD9 + XK_hexagram*: TKeySym = 0x00000ADA + XK_filledrectbullet*: TKeySym = 0x00000ADB + XK_filledlefttribullet*: TKeySym = 0x00000ADC + XK_filledrighttribullet*: TKeySym = 0x00000ADD + XK_emfilledcircle*: TKeySym = 0x00000ADE + XK_emfilledrect*: TKeySym = 0x00000ADF + XK_enopencircbullet*: TKeySym = 0x00000AE0 + XK_enopensquarebullet*: TKeySym = 0x00000AE1 + XK_openrectbullet*: TKeySym = 0x00000AE2 + XK_opentribulletup*: TKeySym = 0x00000AE3 + XK_opentribulletdown*: TKeySym = 0x00000AE4 + XK_openstar*: TKeySym = 0x00000AE5 + XK_enfilledcircbullet*: TKeySym = 0x00000AE6 + XK_enfilledsqbullet*: TKeySym = 0x00000AE7 + XK_filledtribulletup*: TKeySym = 0x00000AE8 + XK_filledtribulletdown*: TKeySym = 0x00000AE9 + XK_leftpointer*: TKeySym = 0x00000AEA + XK_rightpointer*: TKeySym = 0x00000AEB + XK_club*: TKeySym = 0x00000AEC + XK_diamond*: TKeySym = 0x00000AED + XK_heart*: TKeySym = 0x00000AEE + XK_maltesecross*: TKeySym = 0x00000AF0 + XK_dagger*: TKeySym = 0x00000AF1 + XK_doubledagger*: TKeySym = 0x00000AF2 + XK_checkmark*: TKeySym = 0x00000AF3 + XK_ballotcross*: TKeySym = 0x00000AF4 + XK_musicalsharp*: TKeySym = 0x00000AF5 + XK_musicalflat*: TKeySym = 0x00000AF6 + XK_malesymbol*: TKeySym = 0x00000AF7 + XK_femalesymbol*: TKeySym = 0x00000AF8 + XK_telephone*: TKeySym = 0x00000AF9 + XK_telephonerecorder*: TKeySym = 0x00000AFA + XK_phonographcopyright*: TKeySym = 0x00000AFB + XK_caret*: TKeySym = 0x00000AFC + XK_singlelowquotemark*: TKeySym = 0x00000AFD + XK_doublelowquotemark*: TKeySym = 0x00000AFE + XK_cursor*: TKeySym = 0x00000AFF +# XK_PUBLISHING +#* +# * APL +# * Byte 3 = b +# * + +when defined(XK_APL) or true: + const + XK_leftcaret*: TKeySym = 0x00000BA3 + XK_rightcaret*: TKeySym = 0x00000BA6 + XK_downcaret*: TKeySym = 0x00000BA8 + XK_upcaret*: TKeySym = 0x00000BA9 + XK_overbar*: TKeySym = 0x00000BC0 + XK_downtack*: TKeySym = 0x00000BC2 + XK_upshoe*: TKeySym = 0x00000BC3 + XK_downstile*: TKeySym = 0x00000BC4 + XK_underbar*: TKeySym = 0x00000BC6 + XK_jot*: TKeySym = 0x00000BCA + XK_quad*: TKeySym = 0x00000BCC + XK_uptack*: TKeySym = 0x00000BCE + XK_circle*: TKeySym = 0x00000BCF + XK_upstile*: TKeySym = 0x00000BD3 + XK_downshoe*: TKeySym = 0x00000BD6 + XK_rightshoe*: TKeySym = 0x00000BD8 + XK_leftshoe*: TKeySym = 0x00000BDA + XK_lefttack*: TKeySym = 0x00000BDC + XK_righttack*: TKeySym = 0x00000BFC +# XK_APL +#* +# * Hebrew +# * Byte 3 = c +# * + +when defined(XK_HEBREW) or true: + const + XK_hebrew_doublelowline*: TKeySym = 0x00000CDF + XK_hebrew_aleph*: TKeySym = 0x00000CE0 + XK_hebrew_bet*: TKeySym = 0x00000CE1 + XK_hebrew_beth*: TKeySym = 0x00000CE1 # deprecated + XK_hebrew_gimel*: TKeySym = 0x00000CE2 + XK_hebrew_gimmel*: TKeySym = 0x00000CE2 # deprecated + XK_hebrew_dalet*: TKeySym = 0x00000CE3 + XK_hebrew_daleth*: TKeySym = 0x00000CE3 # deprecated + XK_hebrew_he*: TKeySym = 0x00000CE4 + XK_hebrew_waw*: TKeySym = 0x00000CE5 + XK_hebrew_zain*: TKeySym = 0x00000CE6 + XK_hebrew_zayin*: TKeySym = 0x00000CE6 # deprecated + XK_hebrew_chet*: TKeySym = 0x00000CE7 + XK_hebrew_het*: TKeySym = 0x00000CE7 # deprecated + XK_hebrew_tet*: TKeySym = 0x00000CE8 + XK_hebrew_teth*: TKeySym = 0x00000CE8 # deprecated + XK_hebrew_yod*: TKeySym = 0x00000CE9 + XK_hebrew_finalkaph*: TKeySym = 0x00000CEA + XK_hebrew_kaph*: TKeySym = 0x00000CEB + XK_hebrew_lamed*: TKeySym = 0x00000CEC + XK_hebrew_finalmem*: TKeySym = 0x00000CED + XK_hebrew_mem*: TKeySym = 0x00000CEE + XK_hebrew_finalnun*: TKeySym = 0x00000CEF + XK_hebrew_nun*: TKeySym = 0x00000CF0 + XK_hebrew_samech*: TKeySym = 0x00000CF1 + XK_hebrew_samekh*: TKeySym = 0x00000CF1 # deprecated + XK_hebrew_ayin*: TKeySym = 0x00000CF2 + XK_hebrew_finalpe*: TKeySym = 0x00000CF3 + XK_hebrew_pe*: TKeySym = 0x00000CF4 + XK_hebrew_finalzade*: TKeySym = 0x00000CF5 + XK_hebrew_finalzadi*: TKeySym = 0x00000CF5 # deprecated + XK_hebrew_zade*: TKeySym = 0x00000CF6 + XK_hebrew_zadi*: TKeySym = 0x00000CF6 # deprecated + XK_hebrew_qoph*: TKeySym = 0x00000CF7 + XK_hebrew_kuf*: TKeySym = 0x00000CF7 # deprecated + XK_hebrew_resh*: TKeySym = 0x00000CF8 + XK_hebrew_shin*: TKeySym = 0x00000CF9 + XK_hebrew_taw*: TKeySym = 0x00000CFA + XK_hebrew_taf*: TKeySym = 0x00000CFA # deprecated + XK_Hebrew_switch*: TKeySym = 0x0000FF7E # Alias for mode_switch +# XK_HEBREW +#* +# * Thai +# * Byte 3 = d +# * + +when defined(XK_THAI) or true: + const + XK_Thai_kokai*: TKeySym = 0x00000DA1 + XK_Thai_khokhai*: TKeySym = 0x00000DA2 + XK_Thai_khokhuat*: TKeySym = 0x00000DA3 + XK_Thai_khokhwai*: TKeySym = 0x00000DA4 + XK_Thai_khokhon*: TKeySym = 0x00000DA5 + XK_Thai_khorakhang*: TKeySym = 0x00000DA6 + XK_Thai_ngongu*: TKeySym = 0x00000DA7 + XK_Thai_chochan*: TKeySym = 0x00000DA8 + XK_Thai_choching*: TKeySym = 0x00000DA9 + XK_Thai_chochang*: TKeySym = 0x00000DAA + XK_Thai_soso*: TKeySym = 0x00000DAB + XK_Thai_chochoe*: TKeySym = 0x00000DAC + XK_Thai_yoying*: TKeySym = 0x00000DAD + XK_Thai_dochada*: TKeySym = 0x00000DAE + XK_Thai_topatak*: TKeySym = 0x00000DAF + XK_Thai_thothan*: TKeySym = 0x00000DB0 + XK_Thai_thonangmontho*: TKeySym = 0x00000DB1 + XK_Thai_thophuthao*: TKeySym = 0x00000DB2 + XK_Thai_nonen*: TKeySym = 0x00000DB3 + XK_Thai_dodek*: TKeySym = 0x00000DB4 + XK_Thai_totao*: TKeySym = 0x00000DB5 + XK_Thai_thothung*: TKeySym = 0x00000DB6 + XK_Thai_thothahan*: TKeySym = 0x00000DB7 + XK_Thai_thothong*: TKeySym = 0x00000DB8 + XK_Thai_nonu*: TKeySym = 0x00000DB9 + XK_Thai_bobaimai*: TKeySym = 0x00000DBA + XK_Thai_popla*: TKeySym = 0x00000DBB + XK_Thai_phophung*: TKeySym = 0x00000DBC + XK_Thai_fofa*: TKeySym = 0x00000DBD + XK_Thai_phophan*: TKeySym = 0x00000DBE + XK_Thai_fofan*: TKeySym = 0x00000DBF + XK_Thai_phosamphao*: TKeySym = 0x00000DC0 + XK_Thai_moma*: TKeySym = 0x00000DC1 + XK_Thai_yoyak*: TKeySym = 0x00000DC2 + XK_Thai_rorua*: TKeySym = 0x00000DC3 + XK_Thai_ru*: TKeySym = 0x00000DC4 + XK_Thai_loling*: TKeySym = 0x00000DC5 + XK_Thai_lu*: TKeySym = 0x00000DC6 + XK_Thai_wowaen*: TKeySym = 0x00000DC7 + XK_Thai_sosala*: TKeySym = 0x00000DC8 + XK_Thai_sorusi*: TKeySym = 0x00000DC9 + XK_Thai_sosua*: TKeySym = 0x00000DCA + XK_Thai_hohip*: TKeySym = 0x00000DCB + XK_Thai_lochula*: TKeySym = 0x00000DCC + XK_Thai_oang*: TKeySym = 0x00000DCD + XK_Thai_honokhuk*: TKeySym = 0x00000DCE + XK_Thai_paiyannoi*: TKeySym = 0x00000DCF + XK_Thai_saraa*: TKeySym = 0x00000DD0 + XK_Thai_maihanakat*: TKeySym = 0x00000DD1 + XK_Thai_saraaa*: TKeySym = 0x00000DD2 + XK_Thai_saraam*: TKeySym = 0x00000DD3 + XK_Thai_sarai*: TKeySym = 0x00000DD4 + XK_Thai_saraii*: TKeySym = 0x00000DD5 + XK_Thai_saraue*: TKeySym = 0x00000DD6 + XK_Thai_sarauee*: TKeySym = 0x00000DD7 + XK_Thai_sarau*: TKeySym = 0x00000DD8 + XK_Thai_sarauu*: TKeySym = 0x00000DD9 + XK_Thai_phinthu*: TKeySym = 0x00000DDA + XK_Thai_maihanakat_maitho*: TKeySym = 0x00000DDE + XK_Thai_baht*: TKeySym = 0x00000DDF + XK_Thai_sarae*: TKeySym = 0x00000DE0 + XK_Thai_saraae*: TKeySym = 0x00000DE1 + XK_Thai_sarao*: TKeySym = 0x00000DE2 + XK_Thai_saraaimaimuan*: TKeySym = 0x00000DE3 + XK_Thai_saraaimaimalai*: TKeySym = 0x00000DE4 + XK_Thai_lakkhangyao*: TKeySym = 0x00000DE5 + XK_Thai_maiyamok*: TKeySym = 0x00000DE6 + XK_Thai_maitaikhu*: TKeySym = 0x00000DE7 + XK_Thai_maiek*: TKeySym = 0x00000DE8 + XK_Thai_maitho*: TKeySym = 0x00000DE9 + XK_Thai_maitri*: TKeySym = 0x00000DEA + XK_Thai_maichattawa*: TKeySym = 0x00000DEB + XK_Thai_thanthakhat*: TKeySym = 0x00000DEC + XK_Thai_nikhahit*: TKeySym = 0x00000DED + XK_Thai_leksun*: TKeySym = 0x00000DF0 + XK_Thai_leknung*: TKeySym = 0x00000DF1 + XK_Thai_leksong*: TKeySym = 0x00000DF2 + XK_Thai_leksam*: TKeySym = 0x00000DF3 + XK_Thai_leksi*: TKeySym = 0x00000DF4 + XK_Thai_lekha*: TKeySym = 0x00000DF5 + XK_Thai_lekhok*: TKeySym = 0x00000DF6 + XK_Thai_lekchet*: TKeySym = 0x00000DF7 + XK_Thai_lekpaet*: TKeySym = 0x00000DF8 + XK_Thai_lekkao*: TKeySym = 0x00000DF9 +# XK_THAI +#* +# * Korean +# * Byte 3 = e +# * + +when defined(XK_KOREAN) or true: + const + XK_Hangul*: TKeySym = 0x0000FF31 # Hangul start/stop(toggle) + XK_Hangul_Start*: TKeySym = 0x0000FF32 # Hangul start + XK_Hangul_End*: TKeySym = 0x0000FF33 # Hangul end, English start + XK_Hangul_Hanja*: TKeySym = 0x0000FF34 # Start Hangul->Hanja Conversion + XK_Hangul_Jamo*: TKeySym = 0x0000FF35 # Hangul Jamo mode + XK_Hangul_Romaja*: TKeySym = 0x0000FF36 # Hangul Romaja mode + XK_Hangul_Codeinput*: TKeySym = 0x0000FF37 # Hangul code input mode + XK_Hangul_Jeonja*: TKeySym = 0x0000FF38 # Jeonja mode + XK_Hangul_Banja*: TKeySym = 0x0000FF39 # Banja mode + XK_Hangul_PreHanja*: TKeySym = 0x0000FF3A # Pre Hanja conversion + XK_Hangul_PostHanja*: TKeySym = 0x0000FF3B # Post Hanja conversion + XK_Hangul_SingleCandidate*: TKeySym = 0x0000FF3C # Single candidate + XK_Hangul_MultipleCandidate*: TKeySym = 0x0000FF3D # Multiple candidate + XK_Hangul_PreviousCandidate*: TKeySym = 0x0000FF3E # Previous candidate + XK_Hangul_Special*: TKeySym = 0x0000FF3F # Special symbols + XK_Hangul_switch*: TKeySym = 0x0000FF7E # Alias for mode_switch \ + # Hangul Consonant Characters + XK_Hangul_Kiyeog*: TKeySym = 0x00000EA1 + XK_Hangul_SsangKiyeog*: TKeySym = 0x00000EA2 + XK_Hangul_KiyeogSios*: TKeySym = 0x00000EA3 + XK_Hangul_Nieun*: TKeySym = 0x00000EA4 + XK_Hangul_NieunJieuj*: TKeySym = 0x00000EA5 + XK_Hangul_NieunHieuh*: TKeySym = 0x00000EA6 + XK_Hangul_Dikeud*: TKeySym = 0x00000EA7 + XK_Hangul_SsangDikeud*: TKeySym = 0x00000EA8 + XK_Hangul_Rieul*: TKeySym = 0x00000EA9 + XK_Hangul_RieulKiyeog*: TKeySym = 0x00000EAA + XK_Hangul_RieulMieum*: TKeySym = 0x00000EAB + XK_Hangul_RieulPieub*: TKeySym = 0x00000EAC + XK_Hangul_RieulSios*: TKeySym = 0x00000EAD + XK_Hangul_RieulTieut*: TKeySym = 0x00000EAE + XK_Hangul_RieulPhieuf*: TKeySym = 0x00000EAF + XK_Hangul_RieulHieuh*: TKeySym = 0x00000EB0 + XK_Hangul_Mieum*: TKeySym = 0x00000EB1 + XK_Hangul_Pieub*: TKeySym = 0x00000EB2 + XK_Hangul_SsangPieub*: TKeySym = 0x00000EB3 + XK_Hangul_PieubSios*: TKeySym = 0x00000EB4 + XK_Hangul_Sios*: TKeySym = 0x00000EB5 + XK_Hangul_SsangSios*: TKeySym = 0x00000EB6 + XK_Hangul_Ieung*: TKeySym = 0x00000EB7 + XK_Hangul_Jieuj*: TKeySym = 0x00000EB8 + XK_Hangul_SsangJieuj*: TKeySym = 0x00000EB9 + XK_Hangul_Cieuc*: TKeySym = 0x00000EBA + XK_Hangul_Khieuq*: TKeySym = 0x00000EBB + XK_Hangul_Tieut*: TKeySym = 0x00000EBC + XK_Hangul_Phieuf*: TKeySym = 0x00000EBD + XK_Hangul_Hieuh*: TKeySym = 0x00000EBE # Hangul Vowel Characters + XK_Hangul_A*: TKeySym = 0x00000EBF + XK_Hangul_AE*: TKeySym = 0x00000EC0 + XK_Hangul_YA*: TKeySym = 0x00000EC1 + XK_Hangul_YAE*: TKeySym = 0x00000EC2 + XK_Hangul_EO*: TKeySym = 0x00000EC3 + XK_Hangul_E*: TKeySym = 0x00000EC4 + XK_Hangul_YEO*: TKeySym = 0x00000EC5 + XK_Hangul_YE*: TKeySym = 0x00000EC6 + XK_Hangul_O*: TKeySym = 0x00000EC7 + XK_Hangul_WA*: TKeySym = 0x00000EC8 + XK_Hangul_WAE*: TKeySym = 0x00000EC9 + XK_Hangul_OE*: TKeySym = 0x00000ECA + XK_Hangul_YO*: TKeySym = 0x00000ECB + XK_Hangul_U*: TKeySym = 0x00000ECC + XK_Hangul_WEO*: TKeySym = 0x00000ECD + XK_Hangul_WE*: TKeySym = 0x00000ECE + XK_Hangul_WI*: TKeySym = 0x00000ECF + XK_Hangul_YU*: TKeySym = 0x00000ED0 + XK_Hangul_EU*: TKeySym = 0x00000ED1 + XK_Hangul_YI*: TKeySym = 0x00000ED2 + XK_Hangul_I*: TKeySym = 0x00000ED3 # Hangul syllable-final (JongSeong) Characters + XK_Hangul_J_Kiyeog*: TKeySym = 0x00000ED4 + XK_Hangul_J_SsangKiyeog*: TKeySym = 0x00000ED5 + XK_Hangul_J_KiyeogSios*: TKeySym = 0x00000ED6 + XK_Hangul_J_Nieun*: TKeySym = 0x00000ED7 + XK_Hangul_J_NieunJieuj*: TKeySym = 0x00000ED8 + XK_Hangul_J_NieunHieuh*: TKeySym = 0x00000ED9 + XK_Hangul_J_Dikeud*: TKeySym = 0x00000EDA + XK_Hangul_J_Rieul*: TKeySym = 0x00000EDB + XK_Hangul_J_RieulKiyeog*: TKeySym = 0x00000EDC + XK_Hangul_J_RieulMieum*: TKeySym = 0x00000EDD + XK_Hangul_J_RieulPieub*: TKeySym = 0x00000EDE + XK_Hangul_J_RieulSios*: TKeySym = 0x00000EDF + XK_Hangul_J_RieulTieut*: TKeySym = 0x00000EE0 + XK_Hangul_J_RieulPhieuf*: TKeySym = 0x00000EE1 + XK_Hangul_J_RieulHieuh*: TKeySym = 0x00000EE2 + XK_Hangul_J_Mieum*: TKeySym = 0x00000EE3 + XK_Hangul_J_Pieub*: TKeySym = 0x00000EE4 + XK_Hangul_J_PieubSios*: TKeySym = 0x00000EE5 + XK_Hangul_J_Sios*: TKeySym = 0x00000EE6 + XK_Hangul_J_SsangSios*: TKeySym = 0x00000EE7 + XK_Hangul_J_Ieung*: TKeySym = 0x00000EE8 + XK_Hangul_J_Jieuj*: TKeySym = 0x00000EE9 + XK_Hangul_J_Cieuc*: TKeySym = 0x00000EEA + XK_Hangul_J_Khieuq*: TKeySym = 0x00000EEB + XK_Hangul_J_Tieut*: TKeySym = 0x00000EEC + XK_Hangul_J_Phieuf*: TKeySym = 0x00000EED + XK_Hangul_J_Hieuh*: TKeySym = 0x00000EEE # Ancient Hangul Consonant Characters + XK_Hangul_RieulYeorinHieuh*: TKeySym = 0x00000EEF + XK_Hangul_SunkyeongeumMieum*: TKeySym = 0x00000EF0 + XK_Hangul_SunkyeongeumPieub*: TKeySym = 0x00000EF1 + XK_Hangul_PanSios*: TKeySym = 0x00000EF2 + XK_Hangul_KkogjiDalrinIeung*: TKeySym = 0x00000EF3 + XK_Hangul_SunkyeongeumPhieuf*: TKeySym = 0x00000EF4 + XK_Hangul_YeorinHieuh*: TKeySym = 0x00000EF5 # Ancient Hangul Vowel Characters + XK_Hangul_AraeA*: TKeySym = 0x00000EF6 + XK_Hangul_AraeAE*: TKeySym = 0x00000EF7 # Ancient Hangul syllable-final (JongSeong) Characters + XK_Hangul_J_PanSios*: TKeySym = 0x00000EF8 + XK_Hangul_J_KkogjiDalrinIeung*: TKeySym = 0x00000EF9 + XK_Hangul_J_YeorinHieuh*: TKeySym = 0x00000EFA # Korean currency symbol + XK_Korean_Won*: TKeySym = 0x00000EFF +# XK_KOREAN +#* +# * Armenian +# * Byte 3 = = $14 +# * + +when defined(XK_ARMENIAN) or true: + const + XK_Armenian_eternity*: TKeySym = 0x000014A1 + XK_Armenian_ligature_ew*: TKeySym = 0x000014A2 + XK_Armenian_full_stop*: TKeySym = 0x000014A3 + XK_Armenian_verjaket*: TKeySym = 0x000014A3 + XK_Armenian_parenright*: TKeySym = 0x000014A4 + XK_Armenian_parenleft*: TKeySym = 0x000014A5 + XK_Armenian_guillemotright*: TKeySym = 0x000014A6 + XK_Armenian_guillemotleft*: TKeySym = 0x000014A7 + XK_Armenian_em_dash*: TKeySym = 0x000014A8 + XK_Armenian_dot*: TKeySym = 0x000014A9 + XK_Armenian_mijaket*: TKeySym = 0x000014A9 + XK_Armenian_separation_mark*: TKeySym = 0x000014AA + XK_Armenian_but*: TKeySym = 0x000014AA + XK_Armenian_comma*: TKeySym = 0x000014AB + XK_Armenian_en_dash*: TKeySym = 0x000014AC + XK_Armenian_hyphen*: TKeySym = 0x000014AD + XK_Armenian_yentamna*: TKeySym = 0x000014AD + XK_Armenian_ellipsis*: TKeySym = 0x000014AE + XK_Armenian_exclam*: TKeySym = 0x000014AF + XK_Armenian_amanak*: TKeySym = 0x000014AF + XK_Armenian_accent*: TKeySym = 0x000014B0 + XK_Armenian_shesht*: TKeySym = 0x000014B0 + XK_Armenian_question*: TKeySym = 0x000014B1 + XK_Armenian_paruyk*: TKeySym = 0x000014B1 + XKc_Armenian_AYB*: TKeySym = 0x000014B2 + XK_Armenian_ayb*: TKeySym = 0x000014B3 + XKc_Armenian_BEN*: TKeySym = 0x000014B4 + XK_Armenian_ben*: TKeySym = 0x000014B5 + XKc_Armenian_GIM*: TKeySym = 0x000014B6 + XK_Armenian_gim*: TKeySym = 0x000014B7 + XKc_Armenian_DA*: TKeySym = 0x000014B8 + XK_Armenian_da*: TKeySym = 0x000014B9 + XKc_Armenian_YECH*: TKeySym = 0x000014BA + XK_Armenian_yech*: TKeySym = 0x000014BB + XKc_Armenian_ZA*: TKeySym = 0x000014BC + XK_Armenian_za*: TKeySym = 0x000014BD + XKc_Armenian_E*: TKeySym = 0x000014BE + XK_Armenian_e*: TKeySym = 0x000014BF + XKc_Armenian_AT*: TKeySym = 0x000014C0 + XK_Armenian_at*: TKeySym = 0x000014C1 + XKc_Armenian_TO*: TKeySym = 0x000014C2 + XK_Armenian_to*: TKeySym = 0x000014C3 + XKc_Armenian_ZHE*: TKeySym = 0x000014C4 + XK_Armenian_zhe*: TKeySym = 0x000014C5 + XKc_Armenian_INI*: TKeySym = 0x000014C6 + XK_Armenian_ini*: TKeySym = 0x000014C7 + XKc_Armenian_LYUN*: TKeySym = 0x000014C8 + XK_Armenian_lyun*: TKeySym = 0x000014C9 + XKc_Armenian_KHE*: TKeySym = 0x000014CA + XK_Armenian_khe*: TKeySym = 0x000014CB + XKc_Armenian_TSA*: TKeySym = 0x000014CC + XK_Armenian_tsa*: TKeySym = 0x000014CD + XKc_Armenian_KEN*: TKeySym = 0x000014CE + XK_Armenian_ken*: TKeySym = 0x000014CF + XKc_Armenian_HO*: TKeySym = 0x000014D0 + XK_Armenian_ho*: TKeySym = 0x000014D1 + XKc_Armenian_DZA*: TKeySym = 0x000014D2 + XK_Armenian_dza*: TKeySym = 0x000014D3 + XKc_Armenian_GHAT*: TKeySym = 0x000014D4 + XK_Armenian_ghat*: TKeySym = 0x000014D5 + XKc_Armenian_TCHE*: TKeySym = 0x000014D6 + XK_Armenian_tche*: TKeySym = 0x000014D7 + XKc_Armenian_MEN*: TKeySym = 0x000014D8 + XK_Armenian_men*: TKeySym = 0x000014D9 + XKc_Armenian_HI*: TKeySym = 0x000014DA + XK_Armenian_hi*: TKeySym = 0x000014DB + XKc_Armenian_NU*: TKeySym = 0x000014DC + XK_Armenian_nu*: TKeySym = 0x000014DD + XKc_Armenian_SHA*: TKeySym = 0x000014DE + XK_Armenian_sha*: TKeySym = 0x000014DF + XKc_Armenian_VO*: TKeySym = 0x000014E0 + XK_Armenian_vo*: TKeySym = 0x000014E1 + XKc_Armenian_CHA*: TKeySym = 0x000014E2 + XK_Armenian_cha*: TKeySym = 0x000014E3 + XKc_Armenian_PE*: TKeySym = 0x000014E4 + XK_Armenian_pe*: TKeySym = 0x000014E5 + XKc_Armenian_JE*: TKeySym = 0x000014E6 + XK_Armenian_je*: TKeySym = 0x000014E7 + XKc_Armenian_RA*: TKeySym = 0x000014E8 + XK_Armenian_ra*: TKeySym = 0x000014E9 + XKc_Armenian_SE*: TKeySym = 0x000014EA + XK_Armenian_se*: TKeySym = 0x000014EB + XKc_Armenian_VEV*: TKeySym = 0x000014EC + XK_Armenian_vev*: TKeySym = 0x000014ED + XKc_Armenian_TYUN*: TKeySym = 0x000014EE + XK_Armenian_tyun*: TKeySym = 0x000014EF + XKc_Armenian_RE*: TKeySym = 0x000014F0 + XK_Armenian_re*: TKeySym = 0x000014F1 + XKc_Armenian_TSO*: TKeySym = 0x000014F2 + XK_Armenian_tso*: TKeySym = 0x000014F3 + XKc_Armenian_VYUN*: TKeySym = 0x000014F4 + XK_Armenian_vyun*: TKeySym = 0x000014F5 + XKc_Armenian_PYUR*: TKeySym = 0x000014F6 + XK_Armenian_pyur*: TKeySym = 0x000014F7 + XKc_Armenian_KE*: TKeySym = 0x000014F8 + XK_Armenian_ke*: TKeySym = 0x000014F9 + XKc_Armenian_O*: TKeySym = 0x000014FA + XK_Armenian_o*: TKeySym = 0x000014FB + XKc_Armenian_FE*: TKeySym = 0x000014FC + XK_Armenian_fe*: TKeySym = 0x000014FD + XK_Armenian_apostrophe*: TKeySym = 0x000014FE + XK_Armenian_section_sign*: TKeySym = 0x000014FF +# XK_ARMENIAN +#* +# * Georgian +# * Byte 3 = = $15 +# * + +when defined(XK_GEORGIAN) or true: + const + XK_Georgian_an*: TKeySym = 0x000015D0 + XK_Georgian_ban*: TKeySym = 0x000015D1 + XK_Georgian_gan*: TKeySym = 0x000015D2 + XK_Georgian_don*: TKeySym = 0x000015D3 + XK_Georgian_en*: TKeySym = 0x000015D4 + XK_Georgian_vin*: TKeySym = 0x000015D5 + XK_Georgian_zen*: TKeySym = 0x000015D6 + XK_Georgian_tan*: TKeySym = 0x000015D7 + XK_Georgian_in*: TKeySym = 0x000015D8 + XK_Georgian_kan*: TKeySym = 0x000015D9 + XK_Georgian_las*: TKeySym = 0x000015DA + XK_Georgian_man*: TKeySym = 0x000015DB + XK_Georgian_nar*: TKeySym = 0x000015DC + XK_Georgian_on*: TKeySym = 0x000015DD + XK_Georgian_par*: TKeySym = 0x000015DE + XK_Georgian_zhar*: TKeySym = 0x000015DF + XK_Georgian_rae*: TKeySym = 0x000015E0 + XK_Georgian_san*: TKeySym = 0x000015E1 + XK_Georgian_tar*: TKeySym = 0x000015E2 + XK_Georgian_un*: TKeySym = 0x000015E3 + XK_Georgian_phar*: TKeySym = 0x000015E4 + XK_Georgian_khar*: TKeySym = 0x000015E5 + XK_Georgian_ghan*: TKeySym = 0x000015E6 + XK_Georgian_qar*: TKeySym = 0x000015E7 + XK_Georgian_shin*: TKeySym = 0x000015E8 + XK_Georgian_chin*: TKeySym = 0x000015E9 + XK_Georgian_can*: TKeySym = 0x000015EA + XK_Georgian_jil*: TKeySym = 0x000015EB + XK_Georgian_cil*: TKeySym = 0x000015EC + XK_Georgian_char*: TKeySym = 0x000015ED + XK_Georgian_xan*: TKeySym = 0x000015EE + XK_Georgian_jhan*: TKeySym = 0x000015EF + XK_Georgian_hae*: TKeySym = 0x000015F0 + XK_Georgian_he*: TKeySym = 0x000015F1 + XK_Georgian_hie*: TKeySym = 0x000015F2 + XK_Georgian_we*: TKeySym = 0x000015F3 + XK_Georgian_har*: TKeySym = 0x000015F4 + XK_Georgian_hoe*: TKeySym = 0x000015F5 + XK_Georgian_fi*: TKeySym = 0x000015F6 +# XK_GEORGIAN +#* +# * Azeri (and other Turkic or Caucasian languages of ex-USSR) +# * Byte 3 = = $16 +# * + +when defined(XK_CAUCASUS) or true: + # latin + const + XKc_Ccedillaabovedot*: TKeySym = 0x000016A2 + XKc_Xabovedot*: TKeySym = 0x000016A3 + XKc_Qabovedot*: TKeySym = 0x000016A5 + XKc_Ibreve*: TKeySym = 0x000016A6 + XKc_IE*: TKeySym = 0x000016A7 + XKc_UO*: TKeySym = 0x000016A8 + XKc_Zstroke*: TKeySym = 0x000016A9 + XKc_Gcaron*: TKeySym = 0x000016AA + XKc_Obarred*: TKeySym = 0x000016AF + XK_ccedillaabovedot*: TKeySym = 0x000016B2 + XK_xabovedot*: TKeySym = 0x000016B3 + XKc_Ocaron*: TKeySym = 0x000016B4 + XK_qabovedot*: TKeySym = 0x000016B5 + XK_ibreve*: TKeySym = 0x000016B6 + XK_ie*: TKeySym = 0x000016B7 + XK_uo*: TKeySym = 0x000016B8 + XK_zstroke*: TKeySym = 0x000016B9 + XK_gcaron*: TKeySym = 0x000016BA + XK_ocaron*: TKeySym = 0x000016BD + XK_obarred*: TKeySym = 0x000016BF + XKc_SCHWA*: TKeySym = 0x000016C6 + XK_schwa*: TKeySym = 0x000016F6 # those are not really Caucasus, but I put them here for now\ + # For Inupiak + XKc_Lbelowdot*: TKeySym = 0x000016D1 + XKc_Lstrokebelowdot*: TKeySym = 0x000016D2 + XK_lbelowdot*: TKeySym = 0x000016E1 + XK_lstrokebelowdot*: TKeySym = 0x000016E2 # For Guarani + XKc_Gtilde*: TKeySym = 0x000016D3 + XK_gtilde*: TKeySym = 0x000016E3 +# XK_CAUCASUS +#* +# * Vietnamese +# * Byte 3 = = $1e +# * + +when defined(XK_VIETNAMESE) or true: + const + XKc_Abelowdot*: TKeySym = 0x00001EA0 + XK_abelowdot*: TKeySym = 0x00001EA1 + XKc_Ahook*: TKeySym = 0x00001EA2 + XK_ahook*: TKeySym = 0x00001EA3 + XKc_Acircumflexacute*: TKeySym = 0x00001EA4 + XK_acircumflexacute*: TKeySym = 0x00001EA5 + XKc_Acircumflexgrave*: TKeySym = 0x00001EA6 + XK_acircumflexgrave*: TKeySym = 0x00001EA7 + XKc_Acircumflexhook*: TKeySym = 0x00001EA8 + XK_acircumflexhook*: TKeySym = 0x00001EA9 + XKc_Acircumflextilde*: TKeySym = 0x00001EAA + XK_acircumflextilde*: TKeySym = 0x00001EAB + XKc_Acircumflexbelowdot*: TKeySym = 0x00001EAC + XK_acircumflexbelowdot*: TKeySym = 0x00001EAD + XKc_Abreveacute*: TKeySym = 0x00001EAE + XK_abreveacute*: TKeySym = 0x00001EAF + XKc_Abrevegrave*: TKeySym = 0x00001EB0 + XK_abrevegrave*: TKeySym = 0x00001EB1 + XKc_Abrevehook*: TKeySym = 0x00001EB2 + XK_abrevehook*: TKeySym = 0x00001EB3 + XKc_Abrevetilde*: TKeySym = 0x00001EB4 + XK_abrevetilde*: TKeySym = 0x00001EB5 + XKc_Abrevebelowdot*: TKeySym = 0x00001EB6 + XK_abrevebelowdot*: TKeySym = 0x00001EB7 + XKc_Ebelowdot*: TKeySym = 0x00001EB8 + XK_ebelowdot*: TKeySym = 0x00001EB9 + XKc_Ehook*: TKeySym = 0x00001EBA + XK_ehook*: TKeySym = 0x00001EBB + XKc_Etilde*: TKeySym = 0x00001EBC + XK_etilde*: TKeySym = 0x00001EBD + XKc_Ecircumflexacute*: TKeySym = 0x00001EBE + XK_ecircumflexacute*: TKeySym = 0x00001EBF + XKc_Ecircumflexgrave*: TKeySym = 0x00001EC0 + XK_ecircumflexgrave*: TKeySym = 0x00001EC1 + XKc_Ecircumflexhook*: TKeySym = 0x00001EC2 + XK_ecircumflexhook*: TKeySym = 0x00001EC3 + XKc_Ecircumflextilde*: TKeySym = 0x00001EC4 + XK_ecircumflextilde*: TKeySym = 0x00001EC5 + XKc_Ecircumflexbelowdot*: TKeySym = 0x00001EC6 + XK_ecircumflexbelowdot*: TKeySym = 0x00001EC7 + XKc_Ihook*: TKeySym = 0x00001EC8 + XK_ihook*: TKeySym = 0x00001EC9 + XKc_Ibelowdot*: TKeySym = 0x00001ECA + XK_ibelowdot*: TKeySym = 0x00001ECB + XKc_Obelowdot*: TKeySym = 0x00001ECC + XK_obelowdot*: TKeySym = 0x00001ECD + XKc_Ohook*: TKeySym = 0x00001ECE + XK_ohook*: TKeySym = 0x00001ECF + XKc_Ocircumflexacute*: TKeySym = 0x00001ED0 + XK_ocircumflexacute*: TKeySym = 0x00001ED1 + XKc_Ocircumflexgrave*: TKeySym = 0x00001ED2 + XK_ocircumflexgrave*: TKeySym = 0x00001ED3 + XKc_Ocircumflexhook*: TKeySym = 0x00001ED4 + XK_ocircumflexhook*: TKeySym = 0x00001ED5 + XKc_Ocircumflextilde*: TKeySym = 0x00001ED6 + XK_ocircumflextilde*: TKeySym = 0x00001ED7 + XKc_Ocircumflexbelowdot*: TKeySym = 0x00001ED8 + XK_ocircumflexbelowdot*: TKeySym = 0x00001ED9 + XKc_Ohornacute*: TKeySym = 0x00001EDA + XK_ohornacute*: TKeySym = 0x00001EDB + XKc_Ohorngrave*: TKeySym = 0x00001EDC + XK_ohorngrave*: TKeySym = 0x00001EDD + XKc_Ohornhook*: TKeySym = 0x00001EDE + XK_ohornhook*: TKeySym = 0x00001EDF + XKc_Ohorntilde*: TKeySym = 0x00001EE0 + XK_ohorntilde*: TKeySym = 0x00001EE1 + XKc_Ohornbelowdot*: TKeySym = 0x00001EE2 + XK_ohornbelowdot*: TKeySym = 0x00001EE3 + XKc_Ubelowdot*: TKeySym = 0x00001EE4 + XK_ubelowdot*: TKeySym = 0x00001EE5 + XKc_Uhook*: TKeySym = 0x00001EE6 + XK_uhook*: TKeySym = 0x00001EE7 + XKc_Uhornacute*: TKeySym = 0x00001EE8 + XK_uhornacute*: TKeySym = 0x00001EE9 + XKc_Uhorngrave*: TKeySym = 0x00001EEA + XK_uhorngrave*: TKeySym = 0x00001EEB + XKc_Uhornhook*: TKeySym = 0x00001EEC + XK_uhornhook*: TKeySym = 0x00001EED + XKc_Uhorntilde*: TKeySym = 0x00001EEE + XK_uhorntilde*: TKeySym = 0x00001EEF + XKc_Uhornbelowdot*: TKeySym = 0x00001EF0 + XK_uhornbelowdot*: TKeySym = 0x00001EF1 + XKc_Ybelowdot*: TKeySym = 0x00001EF4 + XK_ybelowdot*: TKeySym = 0x00001EF5 + XKc_Yhook*: TKeySym = 0x00001EF6 + XK_yhook*: TKeySym = 0x00001EF7 + XKc_Ytilde*: TKeySym = 0x00001EF8 + XK_ytilde*: TKeySym = 0x00001EF9 + XKc_Ohorn*: TKeySym = 0x00001EFA # U+01a0 + XK_ohorn*: TKeySym = 0x00001EFB # U+01a1 + XKc_Uhorn*: TKeySym = 0x00001EFC # U+01af + XK_uhorn*: TKeySym = 0x00001EFD # U+01b0 + XK_combining_tilde*: TKeySym = 0x00001E9F # U+0303 + XK_combining_grave*: TKeySym = 0x00001EF2 # U+0300 + XK_combining_acute*: TKeySym = 0x00001EF3 # U+0301 + XK_combining_hook*: TKeySym = 0x00001EFE # U+0309 + XK_combining_belowdot*: TKeySym = 0x00001EFF # U+0323 +# XK_VIETNAMESE + +when defined(XK_CURRENCY) or true: + const + XK_EcuSign*: TKeySym = 0x000020A0 + XK_ColonSign*: TKeySym = 0x000020A1 + XK_CruzeiroSign*: TKeySym = 0x000020A2 + XK_FFrancSign*: TKeySym = 0x000020A3 + XK_LiraSign*: TKeySym = 0x000020A4 + XK_MillSign*: TKeySym = 0x000020A5 + XK_NairaSign*: TKeySym = 0x000020A6 + XK_PesetaSign*: TKeySym = 0x000020A7 + XK_RupeeSign*: TKeySym = 0x000020A8 + XK_WonSign*: TKeySym = 0x000020A9 + XK_NewSheqelSign*: TKeySym = 0x000020AA + XK_DongSign*: TKeySym = 0x000020AB + XK_EuroSign*: TKeySym = 0x000020AC +# implementation diff --git a/tests/deps/x11-1.0/x.nim b/tests/deps/x11-1.0/x.nim new file mode 100644 index 000000000..9d9df48bd --- /dev/null +++ b/tests/deps/x11-1.0/x.nim @@ -0,0 +1,400 @@ + +# +# Automatically converted by H2Pas 0.99.15 from x.h +# The following command line parameters were used: +# -p +# -T +# -S +# -d +# -c +# x.h +# +# Pointers to basic pascal types, inserted by h2pas conversion program. + +const + X_PROTOCOL* = 11 + X_PROTOCOL_REVISION* = 0 + +type + PXID* = ptr TXID + TXID* = culong + PMask* = ptr TMask + TMask* = culong + PPAtom* = ptr PAtom + PAtom* = ptr TAtom + TAtom* = culong + PVisualID* = ptr TVisualID + TVisualID* = culong + PTime* = ptr TTime + TTime* = culong + PPWindow* = ptr PWindow + PWindow* = ptr TWindow + TWindow* = TXID + PDrawable* = ptr TDrawable + TDrawable* = TXID + PFont* = ptr TFont + TFont* = TXID + PPixmap* = ptr TPixmap + TPixmap* = TXID + PCursor* = ptr TCursor + TCursor* = TXID + PColormap* = ptr TColormap + TColormap* = TXID + PGContext* = ptr TGContext + TGContext* = TXID + PKeySym* = ptr TKeySym + TKeySym* = TXID + PKeyCode* = ptr TKeyCode + TKeyCode* = cuchar + +proc `==`*(a, b: TAtom): bool = + return system.`==`(a,b) + +const + None* = 0 + ParentRelative* = 1 + CopyFromParent* = 0 + PointerWindow* = 0 + InputFocus* = 1 + PointerRoot* = 1 + AnyPropertyType* = 0 + AnyKey* = 0 + AnyButton* = 0 + AllTemporary* = 0 + CurrentTime* = 0 + NoSymbol* = 0 + NoEventMask* = 0 + KeyPressMask* = 1 shl 0 + KeyReleaseMask* = 1 shl 1 + ButtonPressMask* = 1 shl 2 + ButtonReleaseMask* = 1 shl 3 + EnterWindowMask* = 1 shl 4 + LeaveWindowMask* = 1 shl 5 + PointerMotionMask* = 1 shl 6 + PointerMotionHintMask* = 1 shl 7 + Button1MotionMask* = 1 shl 8 + Button2MotionMask* = 1 shl 9 + Button3MotionMask* = 1 shl 10 + Button4MotionMask* = 1 shl 11 + Button5MotionMask* = 1 shl 12 + ButtonMotionMask* = 1 shl 13 + KeymapStateMask* = 1 shl 14 + ExposureMask* = 1 shl 15 + VisibilityChangeMask* = 1 shl 16 + StructureNotifyMask* = 1 shl 17 + ResizeRedirectMask* = 1 shl 18 + SubstructureNotifyMask* = 1 shl 19 + SubstructureRedirectMask* = 1 shl 20 + FocusChangeMask* = 1 shl 21 + PropertyChangeMask* = 1 shl 22 + ColormapChangeMask* = 1 shl 23 + OwnerGrabButtonMask* = 1 shl 24 + KeyPress* = 2 + KeyRelease* = 3 + ButtonPress* = 4 + ButtonRelease* = 5 + MotionNotify* = 6 + EnterNotify* = 7 + LeaveNotify* = 8 + FocusIn* = 9 + FocusOut* = 10 + KeymapNotify* = 11 + Expose* = 12 + GraphicsExpose* = 13 + NoExpose* = 14 + VisibilityNotify* = 15 + CreateNotify* = 16 + DestroyNotify* = 17 + UnmapNotify* = 18 + MapNotify* = 19 + MapRequest* = 20 + ReparentNotify* = 21 + ConfigureNotify* = 22 + ConfigureRequest* = 23 + GravityNotify* = 24 + ResizeRequest* = 25 + CirculateNotify* = 26 + CirculateRequest* = 27 + PropertyNotify* = 28 + SelectionClear* = 29 + SelectionRequest* = 30 + SelectionNotify* = 31 + ColormapNotify* = 32 + ClientMessage* = 33 + MappingNotify* = 34 + LASTEvent* = 35 + ShiftMask* = 1 shl 0 + LockMask* = 1 shl 1 + ControlMask* = 1 shl 2 + Mod1Mask* = 1 shl 3 + Mod2Mask* = 1 shl 4 + Mod3Mask* = 1 shl 5 + Mod4Mask* = 1 shl 6 + Mod5Mask* = 1 shl 7 + ShiftMapIndex* = 0 + LockMapIndex* = 1 + ControlMapIndex* = 2 + Mod1MapIndex* = 3 + Mod2MapIndex* = 4 + Mod3MapIndex* = 5 + Mod4MapIndex* = 6 + Mod5MapIndex* = 7 + Button1Mask* = 1 shl 8 + Button2Mask* = 1 shl 9 + Button3Mask* = 1 shl 10 + Button4Mask* = 1 shl 11 + Button5Mask* = 1 shl 12 + AnyModifier* = 1 shl 15 + Button1* = 1 + Button2* = 2 + Button3* = 3 + Button4* = 4 + Button5* = 5 + NotifyNormal* = 0 + NotifyGrab* = 1 + NotifyUngrab* = 2 + NotifyWhileGrabbed* = 3 + NotifyHint* = 1 + NotifyAncestor* = 0 + NotifyVirtual* = 1 + NotifyInferior* = 2 + NotifyNonlinear* = 3 + NotifyNonlinearVirtual* = 4 + NotifyPointer* = 5 + NotifyPointerRoot* = 6 + NotifyDetailNone* = 7 + VisibilityUnobscured* = 0 + VisibilityPartiallyObscured* = 1 + VisibilityFullyObscured* = 2 + PlaceOnTop* = 0 + PlaceOnBottom* = 1 + FamilyInternet* = 0 + FamilyDECnet* = 1 + FamilyChaos* = 2 + FamilyInternet6* = 6 + FamilyServerInterpreted* = 5 + PropertyNewValue* = 0 + PropertyDelete* = 1 + ColormapUninstalled* = 0 + ColormapInstalled* = 1 + GrabModeSync* = 0 + GrabModeAsync* = 1 + GrabSuccess* = 0 + AlreadyGrabbed* = 1 + GrabInvalidTime* = 2 + GrabNotViewable* = 3 + GrabFrozen* = 4 + AsyncPointer* = 0 + SyncPointer* = 1 + ReplayPointer* = 2 + AsyncKeyboard* = 3 + SyncKeyboard* = 4 + ReplayKeyboard* = 5 + AsyncBoth* = 6 + SyncBoth* = 7 + RevertToNone* = None + RevertToPointerRoot* = PointerRoot + RevertToParent* = 2 + Success* = 0 + BadRequest* = 1 + BadValue* = 2 + BadWindow* = 3 + BadPixmap* = 4 + BadAtom* = 5 + BadCursor* = 6 + BadFont* = 7 + BadMatch* = 8 + BadDrawable* = 9 + BadAccess* = 10 + BadAlloc* = 11 + BadColor* = 12 + BadGC* = 13 + BadIDChoice* = 14 + BadName* = 15 + BadLength* = 16 + BadImplementation* = 17 + FirstExtensionError* = 128 + LastExtensionError* = 255 + InputOutput* = 1 + InputOnly* = 2 + CWBackPixmap* = 1 shl 0 + CWBackPixel* = 1 shl 1 + CWBorderPixmap* = 1 shl 2 + CWBorderPixel* = 1 shl 3 + CWBitGravity* = 1 shl 4 + CWWinGravity* = 1 shl 5 + CWBackingStore* = 1 shl 6 + CWBackingPlanes* = 1 shl 7 + CWBackingPixel* = 1 shl 8 + CWOverrideRedirect* = 1 shl 9 + CWSaveUnder* = 1 shl 10 + CWEventMask* = 1 shl 11 + CWDontPropagate* = 1 shl 12 + CWColormap* = 1 shl 13 + CWCursor* = 1 shl 14 + CWX* = 1 shl 0 + CWY* = 1 shl 1 + CWWidth* = 1 shl 2 + CWHeight* = 1 shl 3 + CWBorderWidth* = 1 shl 4 + CWSibling* = 1 shl 5 + CWStackMode* = 1 shl 6 + ForgetGravity* = 0 + NorthWestGravity* = 1 + NorthGravity* = 2 + NorthEastGravity* = 3 + WestGravity* = 4 + CenterGravity* = 5 + EastGravity* = 6 + SouthWestGravity* = 7 + SouthGravity* = 8 + SouthEastGravity* = 9 + StaticGravity* = 10 + UnmapGravity* = 0 + NotUseful* = 0 + WhenMapped* = 1 + Always* = 2 + IsUnmapped* = 0 + IsUnviewable* = 1 + IsViewable* = 2 + SetModeInsert* = 0 + SetModeDelete* = 1 + DestroyAll* = 0 + RetainPermanent* = 1 + RetainTemporary* = 2 + Above* = 0 + Below* = 1 + TopIf* = 2 + BottomIf* = 3 + Opposite* = 4 + RaiseLowest* = 0 + LowerHighest* = 1 + PropModeReplace* = 0 + PropModePrepend* = 1 + PropModeAppend* = 2 + GXclear* = 0x00000000 + GXand* = 0x00000001 + GXandReverse* = 0x00000002 + GXcopy* = 0x00000003 + GXandInverted* = 0x00000004 + GXnoop* = 0x00000005 + GXxor* = 0x00000006 + GXor* = 0x00000007 + GXnor* = 0x00000008 + GXequiv* = 0x00000009 + GXinvert* = 0x0000000A + GXorReverse* = 0x0000000B + GXcopyInverted* = 0x0000000C + GXorInverted* = 0x0000000D + GXnand* = 0x0000000E + GXset* = 0x0000000F + LineSolid* = 0 + LineOnOffDash* = 1 + LineDoubleDash* = 2 + CapNotLast* = 0 + CapButt* = 1 + CapRound* = 2 + CapProjecting* = 3 + JoinMiter* = 0 + JoinRound* = 1 + JoinBevel* = 2 + FillSolid* = 0 + FillTiled* = 1 + FillStippled* = 2 + FillOpaqueStippled* = 3 + EvenOddRule* = 0 + WindingRule* = 1 + ClipByChildren* = 0 + IncludeInferiors* = 1 + Unsorted* = 0 + YSorted* = 1 + YXSorted* = 2 + YXBanded* = 3 + CoordModeOrigin* = 0 + CoordModePrevious* = 1 + Complex* = 0 + Nonconvex* = 1 + Convex* = 2 + ArcChord* = 0 + ArcPieSlice* = 1 + GCFunction* = 1 shl 0 + GCPlaneMask* = 1 shl 1 + GCForeground* = 1 shl 2 + GCBackground* = 1 shl 3 + GCLineWidth* = 1 shl 4 + GCLineStyle* = 1 shl 5 + GCCapStyle* = 1 shl 6 + GCJoinStyle* = 1 shl 7 + GCFillStyle* = 1 shl 8 + GCFillRule* = 1 shl 9 + GCTile* = 1 shl 10 + GCStipple* = 1 shl 11 + GCTileStipXOrigin* = 1 shl 12 + GCTileStipYOrigin* = 1 shl 13 + GCFont* = 1 shl 14 + GCSubwindowMode* = 1 shl 15 + GCGraphicsExposures* = 1 shl 16 + GCClipXOrigin* = 1 shl 17 + GCClipYOrigin* = 1 shl 18 + GCClipMask* = 1 shl 19 + GCDashOffset* = 1 shl 20 + GCDashList* = 1 shl 21 + GCArcMode* = 1 shl 22 + GCLastBit* = 22 + FontLeftToRight* = 0 + FontRightToLeft* = 1 + FontChange* = 255 + XYBitmap* = 0 + XYPixmap* = 1 + ZPixmap* = 2 + AllocNone* = 0 + AllocAll* = 1 + DoRed* = 1 shl 0 + DoGreen* = 1 shl 1 + DoBlue* = 1 shl 2 + CursorShape* = 0 + TileShape* = 1 + StippleShape* = 2 + AutoRepeatModeOff* = 0 + AutoRepeatModeOn* = 1 + AutoRepeatModeDefault* = 2 + LedModeOff* = 0 + LedModeOn* = 1 + KBKeyClickPercent* = 1 shl 0 + KBBellPercent* = 1 shl 1 + KBBellPitch* = 1 shl 2 + KBBellDuration* = 1 shl 3 + KBLed* = 1 shl 4 + KBLedMode* = 1 shl 5 + KBKey* = 1 shl 6 + KBAutoRepeatMode* = 1 shl 7 + MappingSuccess* = 0 + MappingBusy* = 1 + MappingFailed* = 2 + MappingModifier* = 0 + MappingKeyboard* = 1 + MappingPointer* = 2 + DontPreferBlanking* = 0 + PreferBlanking* = 1 + DefaultBlanking* = 2 + DisableScreenSaver* = 0 + DisableScreenInterval* = 0 + DontAllowExposures* = 0 + AllowExposures* = 1 + DefaultExposures* = 2 + ScreenSaverReset* = 0 + ScreenSaverActive* = 1 + HostInsert* = 0 + HostDelete* = 1 + EnableAccess* = 1 + DisableAccess* = 0 + StaticGray* = 0 + GrayScale* = 1 + StaticColor* = 2 + PseudoColor* = 3 + TrueColor* = 4 + DirectColor* = 5 + LSBFirst* = 0 + MSBFirst* = 1 + +# implementation diff --git a/tests/deps/x11-1.0/x11.nimble b/tests/deps/x11-1.0/x11.nimble new file mode 100644 index 000000000..2f4385100 --- /dev/null +++ b/tests/deps/x11-1.0/x11.nimble @@ -0,0 +1,11 @@ +[Package] +name: "x11" +version: "1.0" +author: "Andreas Rumpf" +description: "Wrapper for X11" +license: "MIT" + +srcDir: "src" + +[Deps] +requires: "nimrod > 0.9.2" diff --git a/tests/deps/x11-1.0/x11pragma.nim b/tests/deps/x11-1.0/x11pragma.nim new file mode 100644 index 000000000..b4c876cf0 --- /dev/null +++ b/tests/deps/x11-1.0/x11pragma.nim @@ -0,0 +1,20 @@ +# included from xlib bindings + + +when defined(use_pkg_config) or defined(use_pkg_config_static): + {.pragma: libx11, cdecl, importc.} + {.pragma: libx11c, cdecl.} + when defined(use_pkg_config_static): + {.passl: gorge("pkg-config x11 --static --libs").} + else: + {.passl: gorge("pkg-config x11 --libs").} +else: + when defined(macosx): + const + libX11* = "libX11.dylib" + else: + const + libX11* = "libX11.so(|.6)" + + {.pragma: libx11, cdecl, dynlib: libX11, importc.} + {.pragma: libx11c, cdecl, dynlib: libX11.} diff --git a/tests/deps/x11-1.0/xatom.nim b/tests/deps/x11-1.0/xatom.nim new file mode 100644 index 000000000..b2e1dca91 --- /dev/null +++ b/tests/deps/x11-1.0/xatom.nim @@ -0,0 +1,81 @@ +# +# THIS IS A GENERATED FILE +# +# Do not change! Changing this file implies a protocol change! +# + +import + X + +const + XA_PRIMARY* = TAtom(1) + XA_SECONDARY* = TAtom(2) + XA_ARC* = TAtom(3) + XA_ATOM* = TAtom(4) + XA_BITMAP* = TAtom(5) + XA_CARDINAL* = TAtom(6) + XA_COLORMAP* = TAtom(7) + XA_CURSOR* = TAtom(8) + XA_CUT_BUFFER0* = TAtom(9) + XA_CUT_BUFFER1* = TAtom(10) + XA_CUT_BUFFER2* = TAtom(11) + XA_CUT_BUFFER3* = TAtom(12) + XA_CUT_BUFFER4* = TAtom(13) + XA_CUT_BUFFER5* = TAtom(14) + XA_CUT_BUFFER6* = TAtom(15) + XA_CUT_BUFFER7* = TAtom(16) + XA_DRAWABLE* = TAtom(17) + XA_FONT* = TAtom(18) + XA_INTEGER* = TAtom(19) + XA_PIXMAP* = TAtom(20) + XA_POINT* = TAtom(21) + XA_RECTANGLE* = TAtom(22) + XA_RESOURCE_MANAGER* = TAtom(23) + XA_RGB_COLOR_MAP* = TAtom(24) + XA_RGB_BEST_MAP* = TAtom(25) + XA_RGB_BLUE_MAP* = TAtom(26) + XA_RGB_DEFAULT_MAP* = TAtom(27) + XA_RGB_GRAY_MAP* = TAtom(28) + XA_RGB_GREEN_MAP* = TAtom(29) + XA_RGB_RED_MAP* = TAtom(30) + XA_STRING* = TAtom(31) + XA_VISUALID* = TAtom(32) + XA_WINDOW* = TAtom(33) + XA_WM_COMMAND* = TAtom(34) + XA_WM_HINTS* = TAtom(35) + XA_WM_CLIENT_MACHINE* = TAtom(36) + XA_WM_ICON_NAME* = TAtom(37) + XA_WM_ICON_SIZE* = TAtom(38) + XA_WM_NAME* = TAtom(39) + XA_WM_NORMAL_HINTS* = TAtom(40) + XA_WM_SIZE_HINTS* = TAtom(41) + XA_WM_ZOOM_HINTS* = TAtom(42) + XA_MIN_SPACE* = TAtom(43) + XA_NORM_SPACE* = TAtom(44) + XA_MAX_SPACE* = TAtom(45) + XA_END_SPACE* = TAtom(46) + XA_SUPERSCRIPT_X* = TAtom(47) + XA_SUPERSCRIPT_Y* = TAtom(48) + XA_SUBSCRIPT_X* = TAtom(49) + XA_SUBSCRIPT_Y* = TAtom(50) + XA_UNDERLINE_POSITION* = TAtom(51) + XA_UNDERLINE_THICKNESS* = TAtom(52) + XA_STRIKEOUT_ASCENT* = TAtom(53) + XA_STRIKEOUT_DESCENT* = TAtom(54) + XA_ITALIC_ANGLE* = TAtom(55) + XA_X_HEIGHT* = TAtom(56) + XA_QUAD_WIDTH* = TAtom(57) + XA_WEIGHT* = TAtom(58) + XA_POINT_SIZE* = TAtom(59) + XA_RESOLUTION* = TAtom(60) + XA_COPYRIGHT* = TAtom(61) + XA_NOTICE* = TAtom(62) + XA_FONT_NAME* = TAtom(63) + XA_FAMILY_NAME* = TAtom(64) + XA_FULL_NAME* = TAtom(65) + XA_CAP_HEIGHT* = TAtom(66) + XA_WM_CLASS* = TAtom(67) + XA_WM_TRANSIENT_FOR* = TAtom(68) + XA_LAST_PREDEFINED* = TAtom(68) + +# implementation diff --git a/tests/deps/x11-1.0/xcms.nim b/tests/deps/x11-1.0/xcms.nim new file mode 100644 index 000000000..659676c45 --- /dev/null +++ b/tests/deps/x11-1.0/xcms.nim @@ -0,0 +1,389 @@ + +import + x, xlib + +#const +# libX11* = "X11" + +# +# Automatically converted by H2Pas 0.99.15 from xcms.h +# The following command line parameters were used: +# -p +# -T +# -S +# -d +# -c +# xcms.h +# + +const + XcmsFailure* = 0 + XcmsSuccess* = 1 + XcmsSuccessWithCompression* = 2 + +type + PXcmsColorFormat* = ptr TXcmsColorFormat + TXcmsColorFormat* = int32 + +proc XcmsUndefinedFormat*(): TXcmsColorFormat +proc XcmsCIEXYZFormat*(): TXcmsColorFormat +proc XcmsCIEuvYFormat*(): TXcmsColorFormat +proc XcmsCIExyYFormat*(): TXcmsColorFormat +proc XcmsCIELabFormat*(): TXcmsColorFormat +proc XcmsCIELuvFormat*(): TXcmsColorFormat +proc XcmsTekHVCFormat*(): TXcmsColorFormat +proc XcmsRGBFormat*(): TXcmsColorFormat +proc XcmsRGBiFormat*(): TXcmsColorFormat +const + XcmsInitNone* = 0x00000000 + XcmsInitSuccess* = 0x00000001 + XcmsInitFailure* = 0x000000FF + +type + PXcmsFloat* = ptr TXcmsFloat + TXcmsFloat* = float64 + PXcmsRGB* = ptr TXcmsRGB + TXcmsRGB*{.final.} = object + red*: int16 + green*: int16 + blue*: int16 + + PXcmsRGBi* = ptr TXcmsRGBi + TXcmsRGBi*{.final.} = object + red*: TXcmsFloat + green*: TXcmsFloat + blue*: TXcmsFloat + + PXcmsCIEXYZ* = ptr TXcmsCIEXYZ + TXcmsCIEXYZ*{.final.} = object + X*: TXcmsFloat + Y*: TXcmsFloat + Z*: TXcmsFloat + + PXcmsCIEuvY* = ptr TXcmsCIEuvY + TXcmsCIEuvY*{.final.} = object + u_prime*: TXcmsFloat + v_prime*: TXcmsFloat + Y*: TXcmsFloat + + PXcmsCIExyY* = ptr TXcmsCIExyY + TXcmsCIExyY*{.final.} = object + x*: TXcmsFloat + y*: TXcmsFloat + theY*: TXcmsFloat + + PXcmsCIELab* = ptr TXcmsCIELab + TXcmsCIELab*{.final.} = object + L_star*: TXcmsFloat + a_star*: TXcmsFloat + b_star*: TXcmsFloat + + PXcmsCIELuv* = ptr TXcmsCIELuv + TXcmsCIELuv*{.final.} = object + L_star*: TXcmsFloat + u_star*: TXcmsFloat + v_star*: TXcmsFloat + + PXcmsTekHVC* = ptr TXcmsTekHVC + TXcmsTekHVC*{.final.} = object + H*: TXcmsFloat + V*: TXcmsFloat + C*: TXcmsFloat + + PXcmsPad* = ptr TXcmsPad + TXcmsPad*{.final.} = object + pad0*: TXcmsFloat + pad1*: TXcmsFloat + pad2*: TXcmsFloat + pad3*: TXcmsFloat + + PXcmsColor* = ptr TXcmsColor + TXcmsColor*{.final.} = object # spec : record + # case longint of + # 0 : ( RGB : TXcmsRGB ); + # 1 : ( RGBi : TXcmsRGBi ); + # 2 : ( CIEXYZ : TXcmsCIEXYZ ); + # 3 : ( CIEuvY : TXcmsCIEuvY ); + # 4 : ( CIExyY : TXcmsCIExyY ); + # 5 : ( CIELab : TXcmsCIELab ); + # 6 : ( CIELuv : TXcmsCIELuv ); + # 7 : ( TekHVC : TXcmsTekHVC ); + # 8 : ( Pad : TXcmsPad ); + # end; + pad*: TXcmsPad + pixel*: int32 + format*: TXcmsColorFormat + + PXcmsPerScrnInfo* = ptr TXcmsPerScrnInfo + TXcmsPerScrnInfo*{.final.} = object + screenWhitePt*: TXcmsColor + functionSet*: TXPointer + screenData*: TXPointer + state*: int8 + pad*: array[0..2, char] + + PXcmsCCC* = ptr TXcmsCCC + TXcmsCompressionProc* = proc (para1: PXcmsCCC, para2: PXcmsColor, + para3: int32, para4: int32, para5: PBool): TStatus{. + cdecl.} + TXcmsWhiteAdjustProc* = proc (para1: PXcmsCCC, para2: PXcmsColor, + para3: PXcmsColor, para4: TXcmsColorFormat, + para5: PXcmsColor, para6: int32, para7: PBool): TStatus{. + cdecl.} + TXcmsCCC*{.final.} = object + dpy*: PDisplay + screenNumber*: int32 + visual*: PVisual + clientWhitePt*: TXcmsColor + gamutCompProc*: TXcmsCompressionProc + gamutCompClientData*: TXPointer + whitePtAdjProc*: TXcmsWhiteAdjustProc + whitePtAdjClientData*: TXPointer + pPerScrnInfo*: PXcmsPerScrnInfo + + TXcmsCCCRec* = TXcmsCCC + PXcmsCCCRec* = ptr TXcmsCCCRec + TXcmsScreenInitProc* = proc (para1: PDisplay, para2: int32, + para3: PXcmsPerScrnInfo): TStatus{.cdecl.} + TXcmsScreenFreeProc* = proc (para1: TXPointer){.cdecl.} + TXcmsConversionProc* = proc (){.cdecl.} + PXcmsFuncListPtr* = ptr TXcmsFuncListPtr + TXcmsFuncListPtr* = TXcmsConversionProc + TXcmsParseStringProc* = proc (para1: cstring, para2: PXcmsColor): int32{.cdecl.} + PXcmsColorSpace* = ptr TXcmsColorSpace + TXcmsColorSpace*{.final.} = object + prefix*: cstring + id*: TXcmsColorFormat + parseString*: TXcmsParseStringProc + to_CIEXYZ*: TXcmsFuncListPtr + from_CIEXYZ*: TXcmsFuncListPtr + inverse_flag*: int32 + + PXcmsFunctionSet* = ptr TXcmsFunctionSet + TXcmsFunctionSet*{.final.} = object # error + #extern Status XcmsAddColorSpace ( + #in declaration at line 323 + DDColorSpaces*: ptr PXcmsColorSpace + screenInitProc*: TXcmsScreenInitProc + screenFreeProc*: TXcmsScreenFreeProc + + +proc XcmsAddFunctionSet*(para1: PXcmsFunctionSet): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsAllocColor*(para1: PDisplay, para2: TColormap, para3: PXcmsColor, + para4: TXcmsColorFormat): TStatus{.cdecl, dynlib: libX11, + importc.} +proc XcmsAllocNamedColor*(para1: PDisplay, para2: TColormap, para3: cstring, + para4: PXcmsColor, para5: PXcmsColor, + para6: TXcmsColorFormat): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsCCCOfColormap*(para1: PDisplay, para2: TColormap): TXcmsCCC{.cdecl, + dynlib: libX11, importc.} +proc XcmsCIELabClipab*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsCIELabClipL*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsCIELabClipLab*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsCIELabQueryMaxC*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, + para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, + importc.} +proc XcmsCIELabQueryMaxL*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, + para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, + importc.} +proc XcmsCIELabQueryMaxLC*(para1: TXcmsCCC, para2: TXcmsFloat, para3: PXcmsColor): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XcmsCIELabQueryMinL*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, + para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, + importc.} +proc XcmsCIELabToCIEXYZ*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): TStatus{.cdecl, dynlib: libX11, importc.} +proc XcmsCIELabWhiteShiftColors*(para1: TXcmsCCC, para2: PXcmsColor, + para3: PXcmsColor, para4: TXcmsColorFormat, + para5: PXcmsColor, para6: int32, para7: PBool): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XcmsCIELuvClipL*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsCIELuvClipLuv*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsCIELuvClipuv*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsCIELuvQueryMaxC*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, + para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, + importc.} +proc XcmsCIELuvQueryMaxL*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, + para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, + importc.} +proc XcmsCIELuvQueryMaxLC*(para1: TXcmsCCC, para2: TXcmsFloat, para3: PXcmsColor): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XcmsCIELuvQueryMinL*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, + para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, + importc.} +proc XcmsCIELuvToCIEuvY*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): TStatus{.cdecl, dynlib: libX11, importc.} +proc XcmsCIELuvWhiteShiftColors*(para1: TXcmsCCC, para2: PXcmsColor, + para3: PXcmsColor, para4: TXcmsColorFormat, + para5: PXcmsColor, para6: int32, para7: PBool): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XcmsCIEXYZToCIELab*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): TStatus{.cdecl, dynlib: libX11, importc.} +proc XcmsCIEXYZToCIEuvY*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): TStatus{.cdecl, dynlib: libX11, importc.} +proc XcmsCIEXYZToCIExyY*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): TStatus{.cdecl, dynlib: libX11, importc.} +proc XcmsCIEXYZToRGBi*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, + para4: PBool): TStatus{.cdecl, dynlib: libX11, importc.} +proc XcmsCIEuvYToCIELuv*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): TStatus{.cdecl, dynlib: libX11, importc.} +proc XcmsCIEuvYToCIEXYZ*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): TStatus{.cdecl, dynlib: libX11, importc.} +proc XcmsCIEuvYToTekHVC*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): TStatus{.cdecl, dynlib: libX11, importc.} +proc XcmsCIExyYToCIEXYZ*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): TStatus{.cdecl, dynlib: libX11, importc.} +proc XcmsClientWhitePointOfCCC*(para1: TXcmsCCC): PXcmsColor{.cdecl, + dynlib: libX11, importc.} +proc XcmsConvertColors*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, + para4: TXcmsColorFormat, para5: PBool): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsCreateCCC*(para1: PDisplay, para2: int32, para3: PVisual, + para4: PXcmsColor, para5: TXcmsCompressionProc, + para6: TXPointer, para7: TXcmsWhiteAdjustProc, + para8: TXPointer): TXcmsCCC{.cdecl, dynlib: libX11, importc.} +proc XcmsDefaultCCC*(para1: PDisplay, para2: int32): TXcmsCCC{.cdecl, + dynlib: libX11, importc.} +proc XcmsDisplayOfCCC*(para1: TXcmsCCC): PDisplay{.cdecl, dynlib: libX11, + importc.} +proc XcmsFormatOfPrefix*(para1: cstring): TXcmsColorFormat{.cdecl, + dynlib: libX11, importc.} +proc XcmsFreeCCC*(para1: TXcmsCCC){.cdecl, dynlib: libX11, importc.} +proc XcmsLookupColor*(para1: PDisplay, para2: TColormap, para3: cstring, + para4: PXcmsColor, para5: PXcmsColor, + para6: TXcmsColorFormat): TStatus{.cdecl, dynlib: libX11, + importc.} +proc XcmsPrefixOfFormat*(para1: TXcmsColorFormat): cstring{.cdecl, + dynlib: libX11, importc.} +proc XcmsQueryBlack*(para1: TXcmsCCC, para2: TXcmsColorFormat, para3: PXcmsColor): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XcmsQueryBlue*(para1: TXcmsCCC, para2: TXcmsColorFormat, para3: PXcmsColor): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XcmsQueryColor*(para1: PDisplay, para2: TColormap, para3: PXcmsColor, + para4: TXcmsColorFormat): TStatus{.cdecl, dynlib: libX11, + importc.} +proc XcmsQueryColors*(para1: PDisplay, para2: TColormap, para3: PXcmsColor, + para4: int32, para5: TXcmsColorFormat): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsQueryGreen*(para1: TXcmsCCC, para2: TXcmsColorFormat, para3: PXcmsColor): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XcmsQueryRed*(para1: TXcmsCCC, para2: TXcmsColorFormat, para3: PXcmsColor): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XcmsQueryWhite*(para1: TXcmsCCC, para2: TXcmsColorFormat, para3: PXcmsColor): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XcmsRGBiToCIEXYZ*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, + para4: PBool): TStatus{.cdecl, dynlib: libX11, importc.} +proc XcmsRGBiToRGB*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, + para4: PBool): TStatus{.cdecl, dynlib: libX11, importc.} +proc XcmsRGBToRGBi*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, + para4: PBool): TStatus{.cdecl, dynlib: libX11, importc.} +proc XcmsScreenNumberOfCCC*(para1: TXcmsCCC): int32{.cdecl, dynlib: libX11, + importc.} +proc XcmsScreenWhitePointOfCCC*(para1: TXcmsCCC): PXcmsColor{.cdecl, + dynlib: libX11, importc.} +proc XcmsSetCCCOfColormap*(para1: PDisplay, para2: TColormap, para3: TXcmsCCC): TXcmsCCC{. + cdecl, dynlib: libX11, importc.} +proc XcmsSetCompressionProc*(para1: TXcmsCCC, para2: TXcmsCompressionProc, + para3: TXPointer): TXcmsCompressionProc{.cdecl, + dynlib: libX11, importc.} +proc XcmsSetWhiteAdjustProc*(para1: TXcmsCCC, para2: TXcmsWhiteAdjustProc, + para3: TXPointer): TXcmsWhiteAdjustProc{.cdecl, + dynlib: libX11, importc.} +proc XcmsSetWhitePoint*(para1: TXcmsCCC, para2: PXcmsColor): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsStoreColor*(para1: PDisplay, para2: TColormap, para3: PXcmsColor): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XcmsStoreColors*(para1: PDisplay, para2: TColormap, para3: PXcmsColor, + para4: int32, para5: PBool): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsTekHVCClipC*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsTekHVCClipV*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsTekHVCClipVC*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, + para4: int32, para5: PBool): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XcmsTekHVCQueryMaxC*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, + para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, + importc.} +proc XcmsTekHVCQueryMaxV*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, + para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, + importc.} +proc XcmsTekHVCQueryMaxVC*(para1: TXcmsCCC, para2: TXcmsFloat, para3: PXcmsColor): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XcmsTekHVCQueryMaxVSamples*(para1: TXcmsCCC, para2: TXcmsFloat, + para3: PXcmsColor, para4: int32): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XcmsTekHVCQueryMinV*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, + para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, + importc.} +proc XcmsTekHVCToCIEuvY*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, + para4: int32): TStatus{.cdecl, dynlib: libX11, importc.} +proc XcmsTekHVCWhiteShiftColors*(para1: TXcmsCCC, para2: PXcmsColor, + para3: PXcmsColor, para4: TXcmsColorFormat, + para5: PXcmsColor, para6: int32, para7: PBool): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XcmsVisualOfCCC*(para1: TXcmsCCC): PVisual{.cdecl, dynlib: libX11, importc.} +# implementation + +proc XcmsUndefinedFormat(): TXcmsColorFormat = + result = 0x00000000'i32 + +proc XcmsCIEXYZFormat(): TXcmsColorFormat = + result = 0x00000001'i32 + +proc XcmsCIEuvYFormat(): TXcmsColorFormat = + result = 0x00000002'i32 + +proc XcmsCIExyYFormat(): TXcmsColorFormat = + result = 0x00000003'i32 + +proc XcmsCIELabFormat(): TXcmsColorFormat = + result = 0x00000004'i32 + +proc XcmsCIELuvFormat(): TXcmsColorFormat = + result = 0x00000005'i32 + +proc XcmsTekHVCFormat(): TXcmsColorFormat = + result = 0x00000006'i32 + +proc XcmsRGBFormat(): TXcmsColorFormat = + result = 0x80000000'i32 + +proc XcmsRGBiFormat(): TXcmsColorFormat = + result = 0x80000001'i32 + +#when defined(MACROS): +proc DisplayOfCCC(ccc: TXcmsCCC): PDisplay = + result = ccc.dpy + +proc ScreenNumberOfCCC(ccc: TXcmsCCC): int32 = + result = ccc.screenNumber + +proc VisualOfCCC(ccc: TXcmsCCC): PVisual = + result = ccc.visual + +proc ClientWhitePointOfCCC(ccc: var TXcmsCCC): ptr TXcmsColor = + result = addr(ccc.clientWhitePt) + +proc ScreenWhitePointOfCCC(ccc: var TXcmsCCC): ptr TXcmsColor = + result = addr(ccc.pPerScrnInfo.screenWhitePt) + +proc FunctionSetOfCCC(ccc: TXcmsCCC): TXpointer = + result = ccc.pPerScrnInfo.functionSet diff --git a/tests/deps/x11-1.0/xf86dga.nim b/tests/deps/x11-1.0/xf86dga.nim new file mode 100644 index 000000000..65e26df22 --- /dev/null +++ b/tests/deps/x11-1.0/xf86dga.nim @@ -0,0 +1,235 @@ +# +# Copyright (c) 1999 XFree86 Inc +# +# $XFree86: xc/include/extensions/xf86dga.h,v 3.20 1999/10/13 04:20:48 dawes Exp $ + +import + x, xlib + +const + libXxf86dga* = "libXxf86dga.so" + +#type +# cfloat* = float32 + +# $XFree86: xc/include/extensions/xf86dga1.h,v 1.2 1999/04/17 07:05:41 dawes Exp $ +# +# +#Copyright (c) 1995 Jon Tombs +#Copyright (c) 1995 XFree86 Inc +# +# +#************************************************************************ +# +# THIS IS THE OLD DGA API AND IS OBSOLETE. PLEASE DO NOT USE IT ANYMORE +# +#************************************************************************ + +type + PPcchar* = ptr ptr cstring + +const + X_XF86DGAQueryVersion* = 0 + X_XF86DGAGetVideoLL* = 1 + X_XF86DGADirectVideo* = 2 + X_XF86DGAGetViewPortSize* = 3 + X_XF86DGASetViewPort* = 4 + X_XF86DGAGetVidPage* = 5 + X_XF86DGASetVidPage* = 6 + X_XF86DGAInstallColormap* = 7 + X_XF86DGAQueryDirectVideo* = 8 + X_XF86DGAViewPortChanged* = 9 + XF86DGADirectPresent* = 0x00000001 + XF86DGADirectGraphics* = 0x00000002 + XF86DGADirectMouse* = 0x00000004 + XF86DGADirectKeyb* = 0x00000008 + XF86DGAHasColormap* = 0x00000100 + XF86DGADirectColormap* = 0x00000200 + +proc XF86DGAQueryVersion*(dpy: PDisplay, majorVersion: Pcint, + minorVersion: Pcint): TBool{.cdecl, + dynlib: libXxf86dga, importc.} +proc XF86DGAQueryExtension*(dpy: PDisplay, event_base: Pcint, error_base: Pcint): TBool{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAGetVideoLL*(dpy: PDisplay, screen: cint, base_addr: Pcint, + width: Pcint, bank_size: Pcint, ram_size: Pcint): TStatus{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAGetVideo*(dpy: PDisplay, screen: cint, base_addr: PPcchar, + width: Pcint, bank_size: Pcint, ram_size: Pcint): TStatus{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGADirectVideo*(dpy: PDisplay, screen: cint, enable: cint): TStatus{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGADirectVideoLL*(dpy: PDisplay, screen: cint, enable: cint): TStatus{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAGetViewPortSize*(dpy: PDisplay, screen: cint, width: Pcint, + height: Pcint): TStatus{.cdecl, + dynlib: libXxf86dga, importc.} +proc XF86DGASetViewPort*(dpy: PDisplay, screen: cint, x: cint, y: cint): TStatus{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAGetVidPage*(dpy: PDisplay, screen: cint, vid_page: Pcint): TStatus{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGASetVidPage*(dpy: PDisplay, screen: cint, vid_page: cint): TStatus{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAInstallColormap*(dpy: PDisplay, screen: cint, Colormap: TColormap): TStatus{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAForkApp*(screen: cint): cint{.cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAQueryDirectVideo*(dpy: PDisplay, screen: cint, flags: Pcint): TStatus{. + cdecl, dynlib: libXxf86dga, importc.} +proc XF86DGAViewPortChanged*(dpy: PDisplay, screen: cint, n: cint): TBool{. + cdecl, dynlib: libXxf86dga, importc.} +const + X_XDGAQueryVersion* = 0 # 1 through 9 are in xf86dga1.pp + # 10 and 11 are reserved to avoid conflicts with rogue DGA extensions + X_XDGAQueryModes* = 12 + X_XDGASetMode* = 13 + X_XDGASetViewport* = 14 + X_XDGAInstallColormap* = 15 + X_XDGASelectInput* = 16 + X_XDGAFillRectangle* = 17 + X_XDGACopyArea* = 18 + X_XDGACopyTransparentArea* = 19 + X_XDGAGetViewportStatus* = 20 + X_XDGASync* = 21 + X_XDGAOpenFramebuffer* = 22 + X_XDGACloseFramebuffer* = 23 + X_XDGASetClientVersion* = 24 + X_XDGAChangePixmapMode* = 25 + X_XDGACreateColormap* = 26 + XDGAConcurrentAccess* = 0x00000001 + XDGASolidFillRect* = 0x00000002 + XDGABlitRect* = 0x00000004 + XDGABlitTransRect* = 0x00000008 + XDGAPixmap* = 0x00000010 + XDGAInterlaced* = 0x00010000 + XDGADoublescan* = 0x00020000 + XDGAFlipImmediate* = 0x00000001 + XDGAFlipRetrace* = 0x00000002 + XDGANeedRoot* = 0x00000001 + XF86DGANumberEvents* = 7 + XDGAPixmapModeLarge* = 0 + XDGAPixmapModeSmall* = 1 + XF86DGAClientNotLocal* = 0 + XF86DGANoDirectVideoMode* = 1 + XF86DGAScreenNotActive* = 2 + XF86DGADirectNotActivated* = 3 + XF86DGAOperationNotSupported* = 4 + XF86DGANumberErrors* = (XF86DGAOperationNotSupported + 1) + +type + PXDGAMode* = ptr TXDGAMode + TXDGAMode*{.final.} = object + num*: cint # A unique identifier for the mode (num > 0) + name*: cstring # name of mode given in the XF86Config + verticalRefresh*: cfloat + flags*: cint # DGA_CONCURRENT_ACCESS, etc... + imageWidth*: cint # linear accessible portion (pixels) + imageHeight*: cint + pixmapWidth*: cint # Xlib accessible portion (pixels) + pixmapHeight*: cint # both fields ignored if no concurrent access + bytesPerScanline*: cint + byteOrder*: cint # MSBFirst, LSBFirst + depth*: cint + bitsPerPixel*: cint + redMask*: culong + greenMask*: culong + blueMask*: culong + visualClass*: cshort + viewportWidth*: cint + viewportHeight*: cint + xViewportStep*: cint # viewport position granularity + yViewportStep*: cint + maxViewportX*: cint # max viewport origin + maxViewportY*: cint + viewportFlags*: cint # types of page flipping possible + reserved1*: cint + reserved2*: cint + + PXDGADevice* = ptr TXDGADevice + TXDGADevice*{.final.} = object + mode*: TXDGAMode + data*: Pcuchar + pixmap*: TPixmap + + PXDGAButtonEvent* = ptr TXDGAButtonEvent + TXDGAButtonEvent*{.final.} = object + theType*: cint + serial*: culong + display*: PDisplay + screen*: cint + time*: TTime + state*: cuint + button*: cuint + + PXDGAKeyEvent* = ptr TXDGAKeyEvent + TXDGAKeyEvent*{.final.} = object + theType*: cint + serial*: culong + display*: PDisplay + screen*: cint + time*: TTime + state*: cuint + keycode*: cuint + + PXDGAMotionEvent* = ptr TXDGAMotionEvent + TXDGAMotionEvent*{.final.} = object + theType*: cint + serial*: culong + display*: PDisplay + screen*: cint + time*: TTime + state*: cuint + dx*: cint + dy*: cint + + PXDGAEvent* = ptr TXDGAEvent + TXDGAEvent*{.final.} = object + pad*: array[0..23, clong] # sorry you have to cast if you want access + #Case LongInt Of + # 0 : (_type : cint); + # 1 : (xbutton : TXDGAButtonEvent); + # 2 : (xkey : TXDGAKeyEvent); + # 3 : (xmotion : TXDGAMotionEvent); + # 4 : (pad : Array[0..23] Of clong); + + +proc XDGAQueryExtension*(dpy: PDisplay, eventBase: Pcint, erroBase: Pcint): TBool{. + cdecl, dynlib: libXxf86dga, importc.} +proc XDGAQueryVersion*(dpy: PDisplay, majorVersion: Pcint, minorVersion: Pcint): TBool{. + cdecl, dynlib: libXxf86dga, importc.} +proc XDGAQueryModes*(dpy: PDisplay, screen: cint, num: Pcint): PXDGAMode{.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGASetMode*(dpy: PDisplay, screen: cint, mode: cint): PXDGADevice{.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGAOpenFramebuffer*(dpy: PDisplay, screen: cint): TBool{.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGACloseFramebuffer*(dpy: PDisplay, screen: cint){.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGASetViewport*(dpy: PDisplay, screen: cint, x: cint, y: cint, flags: cint){. + cdecl, dynlib: libXxf86dga, importc.} +proc XDGAInstallColormap*(dpy: PDisplay, screen: cint, cmap: TColormap){.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGACreateColormap*(dpy: PDisplay, screen: cint, device: PXDGADevice, + alloc: cint): TColormap{.cdecl, dynlib: libXxf86dga, + importc.} +proc XDGASelectInput*(dpy: PDisplay, screen: cint, event_mask: clong){.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGAFillRectangle*(dpy: PDisplay, screen: cint, x: cint, y: cint, + width: cuint, height: cuint, color: culong){.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGACopyArea*(dpy: PDisplay, screen: cint, srcx: cint, srcy: cint, + width: cuint, height: cuint, dstx: cint, dsty: cint){.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGACopyTransparentArea*(dpy: PDisplay, screen: cint, srcx: cint, + srcy: cint, width: cuint, height: cuint, + dstx: cint, dsty: cint, key: culong){.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGAGetViewportStatus*(dpy: PDisplay, screen: cint): cint{.cdecl, + dynlib: libXxf86dga, importc.} +proc XDGASync*(dpy: PDisplay, screen: cint){.cdecl, dynlib: libXxf86dga, importc.} +proc XDGASetClientVersion*(dpy: PDisplay): TBool{.cdecl, dynlib: libXxf86dga, + importc.} +proc XDGAChangePixmapMode*(dpy: PDisplay, screen: cint, x: Pcint, y: Pcint, + mode: cint){.cdecl, dynlib: libXxf86dga, importc.} +proc XDGAKeyEventToXKeyEvent*(dk: PXDGAKeyEvent, xk: PXKeyEvent){.cdecl, + dynlib: libXxf86dga, importc.} +# implementation diff --git a/tests/deps/x11-1.0/xf86vmode.nim b/tests/deps/x11-1.0/xf86vmode.nim new file mode 100644 index 000000000..547f5cbd2 --- /dev/null +++ b/tests/deps/x11-1.0/xf86vmode.nim @@ -0,0 +1,229 @@ +# $XFree86: xc/include/extensions/xf86vmode.h,v 3.30 2001/05/07 20:09:50 mvojkovi Exp $ +# +# +#Copyright 1995 Kaleb S. KEITHLEY +# +#Permission is hereby granted, free of charge, to any person obtaining +#a copy of this software and associated documentation files (the +#"Software"), to deal in the Software without restriction, including +#without limitation the rights to use, copy, modify, merge, publish, +#distribute, sublicense, and/or sell copies of the Software, and to +#permit persons to whom the Software is 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 Software. +# +#THE SOFTWARE IS 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 Kaleb S. KEITHLEY 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 SOFTWARE OR THE USE OR +#OTHER DEALINGS IN THE SOFTWARE. +# +#Except as contained in this notice, the name of Kaleb S. KEITHLEY +#shall not be used in advertising or otherwise to promote the sale, use +#or other dealings in this Software without prior written authorization +#from Kaleb S. KEITHLEY +# +# +# $Xorg: xf86vmode.h,v 1.3 2000/08/18 04:05:46 coskrey Exp $ +# THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION + +import + x, xlib + +const + libXxf86vm* = "libXxf86vm.so" + +type + PINT32* = ptr int32 + +const + X_XF86VidModeQueryVersion* = 0 + X_XF86VidModeGetModeLine* = 1 + X_XF86VidModeModModeLine* = 2 + X_XF86VidModeSwitchMode* = 3 + X_XF86VidModeGetMonitor* = 4 + X_XF86VidModeLockModeSwitch* = 5 + X_XF86VidModeGetAllModeLines* = 6 + X_XF86VidModeAddModeLine* = 7 + X_XF86VidModeDeleteModeLine* = 8 + X_XF86VidModeValidateModeLine* = 9 + X_XF86VidModeSwitchToMode* = 10 + X_XF86VidModeGetViewPort* = 11 + X_XF86VidModeSetViewPort* = 12 # new for version 2.x of this extension + X_XF86VidModeGetDotClocks* = 13 + X_XF86VidModeSetClientVersion* = 14 + X_XF86VidModeSetGamma* = 15 + X_XF86VidModeGetGamma* = 16 + X_XF86VidModeGetGammaRamp* = 17 + X_XF86VidModeSetGammaRamp* = 18 + X_XF86VidModeGetGammaRampSize* = 19 + X_XF86VidModeGetPermissions* = 20 + CLKFLAG_PROGRAMABLE* = 1 + +when defined(XF86VIDMODE_EVENTS): + const + XF86VidModeNotify* = 0 + XF86VidModeNumberEvents* = (XF86VidModeNotify + 1) + XF86VidModeNotifyMask* = 0x00000001 + XF86VidModeNonEvent* = 0 + XF86VidModeModeChange* = 1 +else: + const + XF86VidModeNumberEvents* = 0 +const + XF86VidModeBadClock* = 0 + XF86VidModeBadHTimings* = 1 + XF86VidModeBadVTimings* = 2 + XF86VidModeModeUnsuitable* = 3 + XF86VidModeExtensionDisabled* = 4 + XF86VidModeClientNotLocal* = 5 + XF86VidModeZoomLocked* = 6 + XF86VidModeNumberErrors* = (XF86VidModeZoomLocked + 1) + XF86VM_READ_PERMISSION* = 1 + XF86VM_WRITE_PERMISSION* = 2 + +type + PXF86VidModeModeLine* = ptr TXF86VidModeModeLine + TXF86VidModeModeLine*{.final.} = object + hdisplay*: cushort + hsyncstart*: cushort + hsyncend*: cushort + htotal*: cushort + hskew*: cushort + vdisplay*: cushort + vsyncstart*: cushort + vsyncend*: cushort + vtotal*: cushort + flags*: cuint + privsize*: cint + c_private*: PINT32 + + PPPXF86VidModeModeInfo* = ptr PPXF86VidModeModeInfo + PPXF86VidModeModeInfo* = ptr PXF86VidModeModeInfo + PXF86VidModeModeInfo* = ptr TXF86VidModeModeInfo + TXF86VidModeModeInfo*{.final.} = object + dotclock*: cuint + hdisplay*: cushort + hsyncstart*: cushort + hsyncend*: cushort + htotal*: cushort + hskew*: cushort + vdisplay*: cushort + vsyncstart*: cushort + vsyncend*: cushort + vtotal*: cushort + flags*: cuint + privsize*: cint + c_private*: PINT32 + + PXF86VidModeSyncRange* = ptr TXF86VidModeSyncRange + TXF86VidModeSyncRange*{.final.} = object + hi*: cfloat + lo*: cfloat + + PXF86VidModeMonitor* = ptr TXF86VidModeMonitor + TXF86VidModeMonitor*{.final.} = object + vendor*: cstring + model*: cstring + EMPTY*: cfloat + nhsync*: cuchar + hsync*: PXF86VidModeSyncRange + nvsync*: cuchar + vsync*: PXF86VidModeSyncRange + + PXF86VidModeNotifyEvent* = ptr TXF86VidModeNotifyEvent + TXF86VidModeNotifyEvent*{.final.} = object + theType*: cint # of event + serial*: culong # # of last request processed by server + send_event*: TBool # true if this came from a SendEvent req + display*: PDisplay # Display the event was read from + root*: TWindow # root window of event screen + state*: cint # What happened + kind*: cint # What happened + forced*: TBool # extents of new region + time*: TTime # event timestamp + + PXF86VidModeGamma* = ptr TXF86VidModeGamma + TXF86VidModeGamma*{.final.} = object + red*: cfloat # Red Gamma value + green*: cfloat # Green Gamma value + blue*: cfloat # Blue Gamma value + + +when defined(MACROS): + proc XF86VidModeSelectNextMode*(disp: PDisplay, scr: cint): TBool + proc XF86VidModeSelectPrevMode*(disp: PDisplay, scr: cint): TBool +proc XF86VidModeQueryVersion*(dpy: PDisplay, majorVersion: Pcint, + minorVersion: Pcint): TBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeQueryExtension*(dpy: PDisplay, event_base: Pcint, + error_base: Pcint): TBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeSetClientVersion*(dpy: PDisplay): TBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeGetModeLine*(dpy: PDisplay, screen: cint, dotclock: Pcint, + modeline: PXF86VidModeModeLine): TBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeGetAllModeLines*(dpy: PDisplay, screen: cint, modecount: Pcint, + modelinesPtr: PPPXF86VidModeModeInfo): TBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeAddModeLine*(dpy: PDisplay, screen: cint, + new_modeline: PXF86VidModeModeInfo, + after_modeline: PXF86VidModeModeInfo): TBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeDeleteModeLine*(dpy: PDisplay, screen: cint, + modeline: PXF86VidModeModeInfo): TBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeModModeLine*(dpy: PDisplay, screen: cint, + modeline: PXF86VidModeModeLine): TBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeValidateModeLine*(dpy: PDisplay, screen: cint, + modeline: PXF86VidModeModeInfo): TStatus{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeSwitchMode*(dpy: PDisplay, screen: cint, zoom: cint): TBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeSwitchToMode*(dpy: PDisplay, screen: cint, + modeline: PXF86VidModeModeInfo): TBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeLockModeSwitch*(dpy: PDisplay, screen: cint, lock: cint): TBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeGetMonitor*(dpy: PDisplay, screen: cint, + monitor: PXF86VidModeMonitor): TBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeGetViewPort*(dpy: PDisplay, screen: cint, x_return: Pcint, + y_return: Pcint): TBool{.cdecl, dynlib: libXxf86vm, + importc.} +proc XF86VidModeSetViewPort*(dpy: PDisplay, screen: cint, x: cint, y: cint): TBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeGetDotClocks*(dpy: PDisplay, screen: cint, flags_return: Pcint, + number_of_clocks_return: Pcint, + max_dot_clock_return: Pcint, clocks_return: PPcint): TBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeGetGamma*(dpy: PDisplay, screen: cint, Gamma: PXF86VidModeGamma): TBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeSetGamma*(dpy: PDisplay, screen: cint, Gamma: PXF86VidModeGamma): TBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeSetGammaRamp*(dpy: PDisplay, screen: cint, size: cint, + red_array: Pcushort, green_array: Pcushort, + blue_array: Pcushort): TBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeGetGammaRamp*(dpy: PDisplay, screen: cint, size: cint, + red_array: Pcushort, green_array: Pcushort, + blue_array: Pcushort): TBool{.cdecl, + dynlib: libXxf86vm, importc.} +proc XF86VidModeGetGammaRampSize*(dpy: PDisplay, screen: cint, size: Pcint): TBool{. + cdecl, dynlib: libXxf86vm, importc.} +proc XF86VidModeGetPermissions*(dpy: PDisplay, screen: cint, permissions: Pcint): TBool{. + cdecl, dynlib: libXxf86vm, importc.} +# implementation + +#when defined(MACROS): +proc XF86VidModeSelectNextMode(disp: PDisplay, scr: cint): TBool = + XF86VidModeSwitchMode(disp, scr, 1) + +proc XF86VidModeSelectPrevMode(disp: PDisplay, scr: cint): TBool = + XF86VidModeSwitchMode(disp, scr, - 1) diff --git a/tests/deps/x11-1.0/xi.nim b/tests/deps/x11-1.0/xi.nim new file mode 100644 index 000000000..d1b9f7846 --- /dev/null +++ b/tests/deps/x11-1.0/xi.nim @@ -0,0 +1,307 @@ +# +# $Xorg: XI.h,v 1.4 2001/02/09 02:03:23 xorgcvs Exp $ +# +#************************************************************ +# +#Copyright 1989, 1998 The Open Group +# +#Permission to use, copy, modify, distribute, and sell this software and its +#documentation for any purpose is hereby granted without fee, provided that +#the above copyright notice appear in all copies and that both that +#copyright notice and this permission notice appear in supporting +#documentation. +# +#The above copyright notice and this permission notice shall be included in +#all copies or substantial portions of the Software. +# +#THE SOFTWARE IS 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 +#OPEN GROUP 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +#Except as contained in this notice, the name of The Open Group shall not be +#used in advertising or otherwise to promote the sale, use or other dealings +#in this Software without prior written authorization from The Open Group. +# +#Copyright 1989 by Hewlett-Packard Company, Palo Alto, California. +# +# All Rights Reserved +# +#Permission to use, copy, modify, and distribute this software and its +#documentation for any purpose and without fee is hereby granted, +#provided that the above copyright notice appear in all copies and that +#both that copyright notice and this permission notice appear in +#supporting documentation, and that the name of Hewlett-Packard not be +#used in advertising or publicity pertaining to distribution of the +#software without specific, written prior permission. +# +#HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +#ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +#HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +#ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +#WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +#ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +#SOFTWARE. +# +#********************************************************/ +# $XFree86: xc/include/extensions/XI.h,v 1.5 2001/12/14 19:53:28 dawes Exp $ +# +# Definitions used by the server, library and client +# +# Pascal Convertion was made by Ido Kannner - kanerido@actcom.net.il +# +#Histroy: +# 2004/10/15 - Fixed a bug of accessing second based records by removing "paced record" and chnaged it to +# "reocrd" only. +# 2004/10/07 - Removed the "uses X;" line. The unit does not need it. +# 2004/10/03 - Conversion from C header to Pascal unit. +# + +const + sz_xGetExtensionVersionReq* = 8 + sz_xGetExtensionVersionReply* = 32 + sz_xListInputDevicesReq* = 4 + sz_xListInputDevicesReply* = 32 + sz_xOpenDeviceReq* = 8 + sz_xOpenDeviceReply* = 32 + sz_xCloseDeviceReq* = 8 + sz_xSetDeviceModeReq* = 8 + sz_xSetDeviceModeReply* = 32 + sz_xSelectExtensionEventReq* = 12 + sz_xGetSelectedExtensionEventsReq* = 8 + sz_xGetSelectedExtensionEventsReply* = 32 + sz_xChangeDeviceDontPropagateListReq* = 12 + sz_xGetDeviceDontPropagateListReq* = 8 + sz_xGetDeviceDontPropagateListReply* = 32 + sz_xGetDeviceMotionEventsReq* = 16 + sz_xGetDeviceMotionEventsReply* = 32 + sz_xChangeKeyboardDeviceReq* = 8 + sz_xChangeKeyboardDeviceReply* = 32 + sz_xChangePointerDeviceReq* = 8 + sz_xChangePointerDeviceReply* = 32 + sz_xGrabDeviceReq* = 20 + sz_xGrabDeviceReply* = 32 + sz_xUngrabDeviceReq* = 12 + sz_xGrabDeviceKeyReq* = 20 + sz_xGrabDeviceKeyReply* = 32 + sz_xUngrabDeviceKeyReq* = 16 + sz_xGrabDeviceButtonReq* = 20 + sz_xGrabDeviceButtonReply* = 32 + sz_xUngrabDeviceButtonReq* = 16 + sz_xAllowDeviceEventsReq* = 12 + sz_xGetDeviceFocusReq* = 8 + sz_xGetDeviceFocusReply* = 32 + sz_xSetDeviceFocusReq* = 16 + sz_xGetFeedbackControlReq* = 8 + sz_xGetFeedbackControlReply* = 32 + sz_xChangeFeedbackControlReq* = 12 + sz_xGetDeviceKeyMappingReq* = 8 + sz_xGetDeviceKeyMappingReply* = 32 + sz_xChangeDeviceKeyMappingReq* = 8 + sz_xGetDeviceModifierMappingReq* = 8 + sz_xSetDeviceModifierMappingReq* = 8 + sz_xSetDeviceModifierMappingReply* = 32 + sz_xGetDeviceButtonMappingReq* = 8 + sz_xGetDeviceButtonMappingReply* = 32 + sz_xSetDeviceButtonMappingReq* = 8 + sz_xSetDeviceButtonMappingReply* = 32 + sz_xQueryDeviceStateReq* = 8 + sz_xQueryDeviceStateReply* = 32 + sz_xSendExtensionEventReq* = 16 + sz_xDeviceBellReq* = 8 + sz_xSetDeviceValuatorsReq* = 8 + sz_xSetDeviceValuatorsReply* = 32 + sz_xGetDeviceControlReq* = 8 + sz_xGetDeviceControlReply* = 32 + sz_xChangeDeviceControlReq* = 8 + sz_xChangeDeviceControlReply* = 32 + +const + INAME* = "XInputExtension" + +const + XI_KEYBOARD* = "KEYBOARD" + XI_MOUSE* = "MOUSE" + XI_TABLET* = "TABLET" + XI_TOUCHSCREEN* = "TOUCHSCREEN" + XI_TOUCHPAD* = "TOUCHPAD" + XI_BARCODE* = "BARCODE" + XI_BUTTONBOX* = "BUTTONBOX" + XI_KNOB_BOX* = "KNOB_BOX" + XI_ONE_KNOB* = "ONE_KNOB" + XI_NINE_KNOB* = "NINE_KNOB" + XI_TRACKBALL* = "TRACKBALL" + XI_QUADRATURE* = "QUADRATURE" + XI_ID_MODULE* = "ID_MODULE" + XI_SPACEBALL* = "SPACEBALL" + XI_DATAGLOVE* = "DATAGLOVE" + XI_EYETRACKER* = "EYETRACKER" + XI_CURSORKEYS* = "CURSORKEYS" + XI_FOOTMOUSE* = "FOOTMOUSE" + +const + Dont_Check* = 0 + XInput_Initial_Release* = 1 + XInput_Add_XDeviceBell* = 2 + XInput_Add_XSetDeviceValuators* = 3 + XInput_Add_XChangeDeviceControl* = 4 + +const + XI_Absent* = 0 + XI_Present* = 1 + +const + XI_Initial_Release_Major* = 1 + XI_Initial_Release_Minor* = 0 + +const + XI_Add_XDeviceBell_Major* = 1 + XI_Add_XDeviceBell_Minor* = 1 + +const + XI_Add_XSetDeviceValuators_Major* = 1 + XI_Add_XSetDeviceValuators_Minor* = 2 + +const + XI_Add_XChangeDeviceControl_Major* = 1 + XI_Add_XChangeDeviceControl_Minor* = 3 + +const + DEVICE_RESOLUTION* = 1 + +const + NoSuchExtension* = 1 + +const + COUNT* = 0 + CREATE* = 1 + +const + NewPointer* = 0 + NewKeyboard* = 1 + +const + XPOINTER* = 0 + XKEYBOARD* = 1 + +const + UseXKeyboard* = 0x000000FF + +const + IsXPointer* = 0 + IsXKeyboard* = 1 + IsXExtensionDevice* = 2 + +const + AsyncThisDevice* = 0 + SyncThisDevice* = 1 + ReplayThisDevice* = 2 + AsyncOtherDevices* = 3 + AsyncAll* = 4 + SyncAll* = 5 + +const + FollowKeyboard* = 3 + RevertToFollowKeyboard* = 3 + +const + DvAccelNum* = int(1) shl 0 + DvAccelDenom* = int(1) shl 1 + DvThreshold* = int(1) shl 2 + +const + DvKeyClickPercent* = int(1) shl 0 + DvPercent* = int(1) shl 1 + DvPitch* = int(1) shl 2 + DvDuration* = int(1) shl 3 + DvLed* = int(1) shl 4 + DvLedMode* = int(1) shl 5 + DvKey* = int(1) shl 6 + DvAutoRepeatMode* = 1 shl 7 + +const + DvString* = int(1) shl 0 + +const + DvInteger* = int(1) shl 0 + +const + DeviceMode* = int(1) shl 0 + Relative* = 0 + Absolute* = 1 # Merged from Metrolink tree for XINPUT stuff + TS_Raw* = 57 + TS_Scaled* = 58 + SendCoreEvents* = 59 + DontSendCoreEvents* = 60 # End of merged section + +const + ProximityState* = int(1) shl 1 + InProximity* = int(0) shl 1 + OutOfProximity* = int(1) shl 1 + +const + AddToList* = 0 + DeleteFromList* = 1 + +const + KeyClass* = 0 + ButtonClass* = 1 + ValuatorClass* = 2 + FeedbackClass* = 3 + ProximityClass* = 4 + FocusClass* = 5 + OtherClass* = 6 + +const + KbdFeedbackClass* = 0 + PtrFeedbackClass* = 1 + StringFeedbackClass* = 2 + IntegerFeedbackClass* = 3 + LedFeedbackClass* = 4 + BellFeedbackClass* = 5 + +const + devicePointerMotionHint* = 0 + deviceButton1Motion* = 1 + deviceButton2Motion* = 2 + deviceButton3Motion* = 3 + deviceButton4Motion* = 4 + deviceButton5Motion* = 5 + deviceButtonMotion* = 6 + deviceButtonGrab* = 7 + deviceOwnerGrabButton* = 8 + noExtensionEvent* = 9 + +const + XI_BadDevice* = 0 + XI_BadEvent* = 1 + XI_BadMode* = 2 + XI_DeviceBusy* = 3 + XI_BadClass* = 4 # Make XEventClass be a CARD32 for 64 bit servers. Don't affect client + # definition of XEventClass since that would be a library interface change. + # See the top of X.h for more _XSERVER64 magic. + # + +when defined(XSERVER64): + type + XEventClass* = CARD32 +else: + type + XEventClass* = int32 +#****************************************************************** +# * +# * Extension version structure. +# * +# + +type + PXExtensionVersion* = ptr TXExtensionVersion + TXExtensionVersion*{.final.} = object + present*: int16 + major_version*: int16 + minor_version*: int16 + + +# implementation diff --git a/tests/deps/x11-1.0/xinerama.nim b/tests/deps/x11-1.0/xinerama.nim new file mode 100644 index 000000000..96f5d7da3 --- /dev/null +++ b/tests/deps/x11-1.0/xinerama.nim @@ -0,0 +1,25 @@ +# Converted from X11/Xinerama.h +import + xlib + +const + xineramaLib = "libXinerama.so" + +type + PXineramaScreenInfo* = ptr TXineramaScreenInfo + TXineramaScreenInfo*{.final.} = object + screen_number*: cint + x_org*: int16 + y_org*: int16 + width*: int16 + height*: int16 + + +proc XineramaQueryExtension*(dpy: PDisplay, event_base: Pcint, error_base: Pcint): TBool{. + cdecl, dynlib: xineramaLib, importc.} +proc XineramaQueryVersion*(dpy: PDisplay, major: Pcint, minor: Pcint): TStatus{. + cdecl, dynlib: xineramaLib, importc.} +proc XineramaIsActive*(dpy: PDisplay): TBool{.cdecl, dynlib: xineramaLib, importc.} +proc XineramaQueryScreens*(dpy: PDisplay, number: Pcint): PXineramaScreenInfo{. + cdecl, dynlib: xineramaLib, importc.} + diff --git a/tests/deps/x11-1.0/xkb.nim b/tests/deps/x11-1.0/xkb.nim new file mode 100644 index 000000000..2cb95a9b0 --- /dev/null +++ b/tests/deps/x11-1.0/xkb.nim @@ -0,0 +1,2387 @@ +# +# $Xorg: XKB.h,v 1.3 2000/08/18 04:05:45 coskrey Exp $ +#************************************************************ +# $Xorg: XKBstr.h,v 1.3 2000/08/18 04:05:45 coskrey Exp $ +#************************************************************ +# $Xorg: XKBgeom.h,v 1.3 2000/08/18 04:05:45 coskrey Exp $ +#************************************************************ +# +#Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. +# +#Permission to use, copy, modify, and distribute this +#software and its documentation for any purpose and without +#fee is hereby granted, provided that the above copyright +#notice appear in all copies and that both that copyright +#notice and this permission notice appear in supporting +#documentation, and that the name of Silicon Graphics not be +#used in advertising or publicity pertaining to distribution +#of the software without specific prior written permission. +#Silicon Graphics makes no representation about the suitability +#of this software for any purpose. It is provided "as is" +#without any express or implied warranty. +# +#SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +#SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +#AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +#GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +#DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +#DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +#OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +#THE USE OR PERFORMANCE OF THIS SOFTWARE. +# +#******************************************************** +# $XFree86: xc/include/extensions/XKB.h,v 1.5 2002/11/20 04:49:01 dawes Exp $ +# $XFree86: xc/include/extensions/XKBgeom.h,v 3.9 2002/09/18 17:11:40 tsi Exp $ +# +# Pascal Convertion was made by Ido Kannner - kanerido@actcom.net.il +# +#Thanks: +# I want to thanks to oliebol for putting up with all of the problems that was found +# while translating this code. ;) +# +# I want to thanks #fpc channel in freenode irc, for helping me, and to put up with my +# wierd questions ;) +# +# Thanks for mmc in #xlib on freenode irc And so for the channel itself for the helping me to +# understanding some of the problems I had converting this headers and pointing me to resources +# that helped translating this headers. +# +# Ido +# +#History: +# 2004/10/15 - Fixed a bug of accessing second based records by removing "paced record" and +# chnaged it to "reocrd" only. +# 2004/10/04 - 06 - Convertion from the c header of XKBgeom.h. +# 2004/10/03 - Removed the XKBstr_UNIT compiler decleration. Afther the joined files, +# There is no need for it anymore. +# - There is a need to define (for now) XKBgeom (compiler define) in order +# to use the code of it. At this moment, I did not yet converted it to Pascal. +# +# 2004/09/17 - 10/04 - Convertion from the c header of XKBstr. +# +# 2004/10/03 - Joined xkbstr.pas into xkb.pas because of the circular calls problems. +# - Added the history of xkbstr.pas above this addition. +# +# 2004/09/17 - Fixed a wrong convertion number of XkbPerKeyBitArraySize, insted +# of float, it's now converted into integer (as it should have been). +# +# 2004/09/15 - 16 - Convertion from the c header of XKB.h. +# + +import + X, Xlib + +include "x11pragma.nim" + +proc XkbcharToInt*(v: int8): int16 +proc XkbIntTo2chars*(i: int16, h, L: var int8) +proc Xkb2charsToInt*(h, L: int8): int16 + # + # Common data structures and access macros + # +type + PWord* = ptr array[0..64_000, int16] + PByte* = ptr byte + PXkbStatePtr* = ptr TXkbStateRec + TXkbStateRec*{.final.} = object + group*: int8 + locked_group*: int8 + base_group*: int16 + latched_group*: int16 + mods*: int8 + base_mods*: int8 + latched_mods*: int8 + locked_mods*: int8 + compat_state*: int8 + grab_mods*: int8 + compat_grab_mods*: int8 + lookup_mods*: int8 + compat_lookup_mods*: int8 + ptr_buttons*: int16 + + +proc XkbModLocks*(s: PXkbStatePtr): int8 +proc XkbStateMods*(s: PXkbStatePtr): int16 +proc XkbGroupLock*(s: PXkbStatePtr): int8 +proc XkbStateGroup*(s: PXkbStatePtr): int16 +proc XkbStateFieldFromRec*(s: PXkbStatePtr): int +proc XkbGrabStateFromRec*(s: PXkbStatePtr): int +type + PXkbModsPtr* = ptr TXkbModsRec + TXkbModsRec*{.final.} = object + mask*: int8 # effective mods + real_mods*: int8 + vmods*: int16 + + +type + PXkbKTMapEntryPtr* = ptr TXkbKTMapEntryRec + TXkbKTMapEntryRec*{.final.} = object + active*: bool + level*: int8 + mods*: TXkbModsRec + + +type + PXkbKeyTypePtr* = ptr TXkbKeyTypeRec + TXkbKeyTypeRec*{.final.} = object + mods*: TXkbModsRec + num_levels*: int8 + map_count*: int8 + map*: PXkbKTMapEntryPtr + preserve*: PXkbModsPtr + name*: TAtom + level_names*: TAtom + + +proc XkbNumGroups*(g: int16): int16 +proc XkbOutOfRangeGroupInfo*(g: int16): int16 +proc XkbOutOfRangeGroupAction*(g: int16): int16 +proc XkbOutOfRangeGroupNumber*(g: int16): int16 +proc XkbSetGroupInfo*(g, w, n: int16): int16 +proc XkbSetNumGroups*(g, n: int16): int16 + # + # Structures and access macros used primarily by the server + # +type + PXkbBehavior* = ptr TXkbBehavior + TXkbBehavior*{.final.} = object + theType*: int8 + data*: int8 + + +type + PXkbModAction* = ptr TXkbModAction + TXkbModAction*{.final.} = object + theType*: int8 + flags*: int8 + mask*: int8 + real_mods*: int8 + vmods1*: int8 + vmods2*: int8 + + +proc XkbModActionVMods*(a: PXkbModAction): int16 +proc XkbSetModActionVMods*(a: PXkbModAction, v: int8) +type + PXkbGroupAction* = ptr TXkbGroupAction + TXkbGroupAction*{.final.} = object + theType*: int8 + flags*: int8 + group_XXX*: int8 + + +proc XkbSAGroup*(a: PXkbGroupAction): int8 +proc XkbSASetGroupProc*(a: PXkbGroupAction, g: int8) +type + PXkbISOAction* = ptr TXkbISOAction + TXkbISOAction*{.final.} = object + theType*: int8 + flags*: int8 + mask*: int8 + real_mods*: int8 + group_XXX*: int8 + affect*: int8 + vmods1*: int8 + vmods2*: int8 + + +type + PXkbPtrAction* = ptr TXkbPtrAction + TXkbPtrAction*{.final.} = object + theType*: int8 + flags*: int8 + high_XXX*: int8 + low_XXX*: int8 + high_YYY*: int8 + low_YYY*: int8 + + +proc XkbPtrActionX*(a: PXkbPtrAction): int16 +proc XkbPtrActionY*(a: PXkbPtrAction): int16 +proc XkbSetPtrActionX*(a: PXkbPtrAction, x: int8) +proc XkbSetPtrActionY*(a: PXkbPtrAction, y: int8) +type + PXkbPtrBtnAction* = ptr TXkbPtrBtnAction + TXkbPtrBtnAction*{.final.} = object + theType*: int8 + flags*: int8 + count*: int8 + button*: int8 + + +type + PXkbPtrDfltAction* = ptr TXkbPtrDfltAction + TXkbPtrDfltAction*{.final.} = object + theType*: int8 + flags*: int8 + affect*: int8 + valueXXX*: int8 + + +proc XkbSAPtrDfltValue*(a: PXkbPtrDfltAction): int8 +proc XkbSASetPtrDfltValue*(a: PXkbPtrDfltAction, c: pointer) +type + PXkbSwitchScreenAction* = ptr TXkbSwitchScreenAction + TXkbSwitchScreenAction*{.final.} = object + theType*: int8 + flags*: int8 + screenXXX*: int8 + + +proc XkbSAScreen*(a: PXkbSwitchScreenAction): int8 +proc XkbSASetScreen*(a: PXkbSwitchScreenAction, s: pointer) +type + PXkbCtrlsAction* = ptr TXkbCtrlsAction + TXkbCtrlsAction*{.final.} = object + theType*: int8 + flags*: int8 + ctrls3*: int8 + ctrls2*: int8 + ctrls1*: int8 + ctrls0*: int8 + + +proc XkbActionSetCtrls*(a: PXkbCtrlsAction, c: int8) +proc XkbActionCtrls*(a: PXkbCtrlsAction): int16 +type + PXkbMessageAction* = ptr TXkbMessageAction + TXkbMessageAction*{.final.} = object + theType*: int8 + flags*: int8 + message*: array[0..5, char] + + +type + PXkbRedirectKeyAction* = ptr TXkbRedirectKeyAction + TXkbRedirectKeyAction*{.final.} = object + theType*: int8 + new_key*: int8 + mods_mask*: int8 + mods*: int8 + vmods_mask0*: int8 + vmods_mask1*: int8 + vmods0*: int8 + vmods1*: int8 + + +proc XkbSARedirectVMods*(a: PXkbRedirectKeyAction): int16 +proc XkbSARedirectSetVMods*(a: PXkbRedirectKeyAction, m: int8) +proc XkbSARedirectVModsMask*(a: PXkbRedirectKeyAction): int16 +proc XkbSARedirectSetVModsMask*(a: PXkbRedirectKeyAction, m: int8) +type + PXkbDeviceBtnAction* = ptr TXkbDeviceBtnAction + TXkbDeviceBtnAction*{.final.} = object + theType*: int8 + flags*: int8 + count*: int8 + button*: int8 + device*: int8 + + +type + PXkbDeviceValuatorAction* = ptr TXkbDeviceValuatorAction + TXkbDeviceValuatorAction*{.final.} = object # + # Macros to classify key actions + # + theType*: int8 + device*: int8 + v1_what*: int8 + v1_ndx*: int8 + v1_value*: int8 + v2_what*: int8 + v2_ndx*: int8 + v2_value*: int8 + + +const + XkbAnyActionDataSize* = 7 + +type + PXkbAnyAction* = ptr TXkbAnyAction + TXkbAnyAction*{.final.} = object + theType*: int8 + data*: array[0..XkbAnyActionDataSize - 1, int8] + + +proc XkbIsModAction*(a: PXkbAnyAction): bool +proc XkbIsGroupAction*(a: PXkbAnyAction): bool +proc XkbIsPtrAction*(a: PXkbAnyAction): bool +type + PXkbAction* = ptr TXkbAction + TXkbAction*{.final.} = object # + # XKB request codes, used in: + # - xkbReqType field of all requests + # - requestMinor field of some events + # + any*: TXkbAnyAction + mods*: TXkbModAction + group*: TXkbGroupAction + iso*: TXkbISOAction + thePtr*: TXkbPtrAction + btn*: TXkbPtrBtnAction + dflt*: TXkbPtrDfltAction + screen*: TXkbSwitchScreenAction + ctrls*: TXkbCtrlsAction + msg*: TXkbMessageAction + redirect*: TXkbRedirectKeyAction + devbtn*: TXkbDeviceBtnAction + devval*: TXkbDeviceValuatorAction + theType*: int8 + + +const + X_kbUseExtension* = 0 + X_kbSelectEvents* = 1 + X_kbBell* = 3 + X_kbGetState* = 4 + X_kbLatchLockState* = 5 + X_kbGetControls* = 6 + X_kbSetControls* = 7 + X_kbGetMap* = 8 + X_kbSetMap* = 9 + X_kbGetCompatMap* = 10 + X_kbSetCompatMap* = 11 + X_kbGetIndicatorState* = 12 + X_kbGetIndicatorMap* = 13 + X_kbSetIndicatorMap* = 14 + X_kbGetNamedIndicator* = 15 + X_kbSetNamedIndicator* = 16 + X_kbGetNames* = 17 + X_kbSetNames* = 18 + X_kbGetGeometry* = 19 + X_kbSetGeometry* = 20 + X_kbPerClientFlags* = 21 + X_kbListComponents* = 22 + X_kbGetKbdByName* = 23 + X_kbGetDeviceInfo* = 24 + X_kbSetDeviceInfo* = 25 + X_kbSetDebuggingFlags* = 101 # + # In the X sense, XKB reports only one event. + # The type field of all XKB events is XkbEventCode + # + +const + XkbEventCode* = 0 + XkbNumberEvents* = XkbEventCode + 1 # + # XKB has a minor event code so it can use one X event code for + # multiple purposes. + # - reported in the xkbType field of all XKB events. + # - XkbSelectEventDetails: Indicates the event for which event details + # are being changed + # + +const + XkbNewKeyboardNotify* = 0 + XkbMapNotify* = 1 + XkbStateNotify* = 2 + XkbControlsNotify* = 3 + XkbIndicatorStateNotify* = 4 + XkbIndicatorMapNotify* = 5 + XkbNamesNotify* = 6 + XkbCompatMapNotify* = 7 + XkbBellNotify* = 8 + XkbActionMessage* = 9 + XkbAccessXNotify* = 10 + XkbExtensionDeviceNotify* = 11 # + # Event Mask: + # - XkbSelectEvents: Specifies event interest. + # + +const + XkbNewKeyboardNotifyMask* = int(1) shl 0 + XkbMapNotifyMask* = int(1) shl 1 + XkbStateNotifyMask* = int(1) shl 2 + XkbControlsNotifyMask* = int(1) shl 3 + XkbIndicatorStateNotifyMask* = int(1) shl 4 + XkbIndicatorMapNotifyMask* = int(1) shl 5 + XkbNamesNotifyMask* = int(1) shl 6 + XkbCompatMapNotifyMask* = int(1) shl 7 + XkbBellNotifyMask* = int(1) shl 8 + XkbActionMessageMask* = int(1) shl 9 + XkbAccessXNotifyMask* = int(1) shl 10 + XkbExtensionDeviceNotifyMask* = int(1) shl 11 + XkbAllEventsMask* = 0x00000FFF # + # NewKeyboardNotify event details: + # + +const + XkbNKN_KeycodesMask* = int(1) shl 0 + XkbNKN_GeometryMask* = int(1) shl 1 + XkbNKN_DeviceIDMask* = int(1) shl 2 + XkbAllNewKeyboardEventsMask* = 0x00000007 # + # AccessXNotify event types: + # - The 'what' field of AccessXNotify events reports the + # reason that the event was generated. + # + +const + XkbAXN_SKPress* = 0 + XkbAXN_SKAccept* = 1 + XkbAXN_SKReject* = 2 + XkbAXN_SKRelease* = 3 + XkbAXN_BKAccept* = 4 + XkbAXN_BKReject* = 5 + XkbAXN_AXKWarning* = 6 # + # AccessXNotify details: + # - Used as an event detail mask to limit the conditions under which + # AccessXNotify events are reported + # + +const + XkbAXN_SKPressMask* = int(1) shl 0 + XkbAXN_SKAcceptMask* = int(1) shl 1 + XkbAXN_SKRejectMask* = int(1) shl 2 + XkbAXN_SKReleaseMask* = int(1) shl 3 + XkbAXN_BKAcceptMask* = int(1) shl 4 + XkbAXN_BKRejectMask* = int(1) shl 5 + XkbAXN_AXKWarningMask* = int(1) shl 6 + XkbAllAccessXEventsMask* = 0x0000000F # + # State detail mask: + # - The 'changed' field of StateNotify events reports which of + # the keyboard state components have changed. + # - Used as an event detail mask to limit the conditions under + # which StateNotify events are reported. + # + +const + XkbModifierStateMask* = int(1) shl 0 + XkbModifierBaseMask* = int(1) shl 1 + XkbModifierLatchMask* = int(1) shl 2 + XkbModifierLockMask* = int(1) shl 3 + XkbGroupStateMask* = int(1) shl 4 + XkbGroupBaseMask* = int(1) shl 5 + XkbGroupLatchMask* = int(1) shl 6 + XkbGroupLockMask* = int(1) shl 7 + XkbCompatStateMask* = int(1) shl 8 + XkbGrabModsMask* = int(1) shl 9 + XkbCompatGrabModsMask* = int(1) shl 10 + XkbLookupModsMask* = int(1) shl 11 + XkbCompatLookupModsMask* = int(1) shl 12 + XkbPointerButtonMask* = int(1) shl 13 + XkbAllStateComponentsMask* = 0x00003FFF # + # Controls detail masks: + # The controls specified in XkbAllControlsMask: + # - The 'changed' field of ControlsNotify events reports which of + # the keyboard controls have changed. + # - The 'changeControls' field of the SetControls request specifies + # the controls for which values are to be changed. + # - Used as an event detail mask to limit the conditions under + # which ControlsNotify events are reported. + # + # The controls specified in the XkbAllBooleanCtrlsMask: + # - The 'enabledControls' field of ControlsNotify events reports the + # current status of the boolean controls. + # - The 'enabledControlsChanges' field of ControlsNotify events reports + # any boolean controls that have been turned on or off. + # - The 'affectEnabledControls' and 'enabledControls' fields of the + # kbSetControls request change the set of enabled controls. + # - The 'accessXTimeoutMask' and 'accessXTimeoutValues' fields of + # an XkbControlsRec specify the controls to be changed if the keyboard + # times out and the values to which they should be changed. + # - The 'autoCtrls' and 'autoCtrlsValues' fields of the PerClientFlags + # request specifies the specify the controls to be reset when the + # client exits and the values to which they should be reset. + # - The 'ctrls' field of an indicator map specifies the controls + # that drive the indicator. + # - Specifies the boolean controls affected by the SetControls and + # LockControls key actions. + # + +const + XkbRepeatKeysMask* = int(1) shl 0 + XkbSlowKeysMask* = int(1) shl 1 + XkbBounceKeysMask* = int(1) shl 2 + XkbStickyKeysMask* = int(1) shl 3 + XkbMouseKeysMask* = int(1) shl 4 + XkbMouseKeysAccelMask* = int(1) shl 5 + XkbAccessXKeysMask* = int(1) shl 6 + XkbAccessXTimeoutMask* = int(1) shl 7 + XkbAccessXFeedbackMask* = int(1) shl 8 + XkbAudibleBellMask* = int(1) shl 9 + XkbOverlay1Mask* = int(1) shl 10 + XkbOverlay2Mask* = int(1) shl 11 + XkbIgnoreGroupLockMask* = int(1) shl 12 + XkbGroupsWrapMask* = int(1) shl 27 + XkbInternalModsMask* = int(1) shl 28 + XkbIgnoreLockModsMask* = int(1) shl 29 + XkbPerKeyRepeatMask* = int(1) shl 30 + XkbControlsEnabledMask* = int(1) shl 31 + XkbAccessXOptionsMask* = XkbStickyKeysMask or XkbAccessXFeedbackMask + XkbAllBooleanCtrlsMask* = 0x00001FFF + XkbAllControlsMask* = 0xF8001FFF # + # Compatibility Map Compontents: + # - Specifies the components to be allocated in XkbAllocCompatMap. + # + +const + XkbSymInterpMask* = 1 shl 0 + XkbGroupCompatMask* = 1 shl 1 + XkbAllCompatMask* = 0x00000003 # + # Assorted constants and limits. + # + +const + XkbAllIndicatorsMask* = 0xFFFFFFFF # + # Map components masks: + # Those in AllMapComponentsMask: + # - Specifies the individual fields to be loaded or changed for the + # GetMap and SetMap requests. + # Those in ClientInfoMask: + # - Specifies the components to be allocated by XkbAllocClientMap. + # Those in ServerInfoMask: + # - Specifies the components to be allocated by XkbAllocServerMap. + # + +const + XkbKeyTypesMask* = 1 shl 0 + XkbKeySymsMask* = 1 shl 1 + XkbModifierMapMask* = 1 shl 2 + XkbExplicitComponentsMask* = 1 shl 3 + XkbKeyActionsMask* = 1 shl 4 + XkbKeyBehaviorsMask* = 1 shl 5 + XkbVirtualModsMask* = 1 shl 6 + XkbVirtualModMapMask* = 1 shl 7 + XkbAllClientInfoMask* = XkbKeyTypesMask or XkbKeySymsMask or + XkbModifierMapMask + XkbAllServerInfoMask* = XkbExplicitComponentsMask or XkbKeyActionsMask or + XkbKeyBehaviorsMask or XkbVirtualModsMask or XkbVirtualModMapMask + XkbAllMapComponentsMask* = XkbAllClientInfoMask or XkbAllServerInfoMask # + # Names component mask: + # - Specifies the names to be loaded or changed for the GetNames and + # SetNames requests. + # - Specifies the names that have changed in a NamesNotify event. + # - Specifies the names components to be allocated by XkbAllocNames. + # + +const + XkbKeycodesNameMask* = 1 shl 0 + XkbGeometryNameMask* = 1 shl 1 + XkbSymbolsNameMask* = 1 shl 2 + XkbPhysSymbolsNameMask* = 1 shl 3 + XkbTypesNameMask* = 1 shl 4 + XkbCompatNameMask* = 1 shl 5 + XkbKeyTypeNamesMask* = 1 shl 6 + XkbKTLevelNamesMask* = 1 shl 7 + XkbIndicatorNamesMask* = 1 shl 8 + XkbKeyNamesMask* = 1 shl 9 + XkbKeyAliasesMask* = 1 shl 10 + XkbVirtualModNamesMask* = 1 shl 11 + XkbGroupNamesMask* = 1 shl 12 + XkbRGNamesMask* = 1 shl 13 + XkbComponentNamesMask* = 0x0000003F + XkbAllNamesMask* = 0x00003FFF # + # Miscellaneous event details: + # - event detail masks for assorted events that don't reall + # have any details. + # + +const + XkbAllStateEventsMask* = XkbAllStateComponentsMask + XkbAllMapEventsMask* = XkbAllMapComponentsMask + XkbAllControlEventsMask* = XkbAllControlsMask + XkbAllIndicatorEventsMask* = XkbAllIndicatorsMask + XkbAllNameEventsMask* = XkbAllNamesMask + XkbAllCompatMapEventsMask* = XkbAllCompatMask + XkbAllBellEventsMask* = int(1) shl 0 + XkbAllActionMessagesMask* = int(1) shl 0 # + # XKB reports one error: BadKeyboard + # A further reason for the error is encoded into to most significant + # byte of the resourceID for the error: + # XkbErr_BadDevice - the device in question was not found + # XkbErr_BadClass - the device was found but it doesn't belong to + # the appropriate class. + # XkbErr_BadId - the device was found and belongs to the right + # class, but not feedback with a matching id was + # found. + # The low byte of the resourceID for this error contains the device + # id, class specifier or feedback id that failed. + # + +const + XkbKeyboard* = 0 + XkbNumberErrors* = 1 + XkbErr_BadDevice* = 0x000000FF + XkbErr_BadClass* = 0x000000FE + XkbErr_BadId* = 0x000000FD # + # Keyboard Components Mask: + # - Specifies the components that follow a GetKeyboardByNameReply + # + +const + XkbClientMapMask* = int(1) shl 0 + XkbServerMapMask* = int(1) shl 1 + XkbCompatMapMask* = int(1) shl 2 + XkbIndicatorMapMask* = int(1) shl 3 + XkbNamesMask* = int(1) shl 4 + XkbGeometryMask* = int(1) shl 5 + XkbControlsMask* = int(1) shl 6 + XkbAllComponentsMask* = 0x0000007F # + # AccessX Options Mask + # - The 'accessXOptions' field of an XkbControlsRec specifies the + # AccessX options that are currently in effect. + # - The 'accessXTimeoutOptionsMask' and 'accessXTimeoutOptionsValues' + # fields of an XkbControlsRec specify the Access X options to be + # changed if the keyboard times out and the values to which they + # should be changed. + # + +const + XkbAX_SKPressFBMask* = int(1) shl 0 + XkbAX_SKAcceptFBMask* = int(1) shl 1 + XkbAX_FeatureFBMask* = int(1) shl 2 + XkbAX_SlowWarnFBMask* = int(1) shl 3 + XkbAX_IndicatorFBMask* = int(1) shl 4 + XkbAX_StickyKeysFBMask* = int(1) shl 5 + XkbAX_TwoKeysMask* = int(1) shl 6 + XkbAX_LatchToLockMask* = int(1) shl 7 + XkbAX_SKReleaseFBMask* = int(1) shl 8 + XkbAX_SKRejectFBMask* = int(1) shl 9 + XkbAX_BKRejectFBMask* = int(1) shl 10 + XkbAX_DumbBellFBMask* = int(1) shl 11 + XkbAX_FBOptionsMask* = 0x00000F3F + XkbAX_SKOptionsMask* = 0x000000C0 + XkbAX_AllOptionsMask* = 0x00000FFF # + # XkbUseCoreKbd is used to specify the core keyboard without having + # to look up its X input extension identifier. + # XkbUseCorePtr is used to specify the core pointer without having + # to look up its X input extension identifier. + # XkbDfltXIClass is used to specify "don't care" any place that the + # XKB protocol is looking for an X Input Extension + # device class. + # XkbDfltXIId is used to specify "don't care" any place that the + # XKB protocol is looking for an X Input Extension + # feedback identifier. + # XkbAllXIClasses is used to get information about all device indicators, + # whether they're part of the indicator feedback class + # or the keyboard feedback class. + # XkbAllXIIds is used to get information about all device indicator + # feedbacks without having to list them. + # XkbXINone is used to indicate that no class or id has been specified. + # XkbLegalXILedClass(c) True if 'c' specifies a legal class with LEDs + # XkbLegalXIBellClass(c) True if 'c' specifies a legal class with bells + # XkbExplicitXIDevice(d) True if 'd' explicitly specifies a device + # XkbExplicitXIClass(c) True if 'c' explicitly specifies a device class + # XkbExplicitXIId(c) True if 'i' explicitly specifies a device id + # XkbSingleXIClass(c) True if 'c' specifies exactly one device class, + # including the default. + # XkbSingleXIId(i) True if 'i' specifies exactly one device + # identifier, including the default. + # + +const + XkbUseCoreKbd* = 0x00000100 + XkbUseCorePtr* = 0x00000200 + XkbDfltXIClass* = 0x00000300 + XkbDfltXIId* = 0x00000400 + XkbAllXIClasses* = 0x00000500 + XkbAllXIIds* = 0x00000600 + XkbXINone* = 0x0000FF00 + +proc XkbLegalXILedClass*(c: int): bool +proc XkbLegalXIBellClass*(c: int): bool +proc XkbExplicitXIDevice*(c: int): bool +proc XkbExplicitXIClass*(c: int): bool +proc XkbExplicitXIId*(c: int): bool +proc XkbSingleXIClass*(c: int): bool +proc XkbSingleXIId*(c: int): bool +const + XkbNoModifier* = 0x000000FF + XkbNoShiftLevel* = 0x000000FF + XkbNoShape* = 0x000000FF + XkbNoIndicator* = 0x000000FF + XkbNoModifierMask* = 0 + XkbAllModifiersMask* = 0x000000FF + XkbAllVirtualModsMask* = 0x0000FFFF + XkbNumKbdGroups* = 4 + XkbMaxKbdGroup* = XkbNumKbdGroups - 1 + XkbMaxMouseKeysBtn* = 4 # + # Group Index and Mask: + # - Indices into the kt_index array of a key type. + # - Mask specifies types to be changed for XkbChangeTypesOfKey + # + +const + XkbGroup1Index* = 0 + XkbGroup2Index* = 1 + XkbGroup3Index* = 2 + XkbGroup4Index* = 3 + XkbAnyGroup* = 254 + XkbAllGroups* = 255 + XkbGroup1Mask* = 1 shl 0 + XkbGroup2Mask* = 1 shl 1 + XkbGroup3Mask* = 1 shl 2 + XkbGroup4Mask* = 1 shl 3 + XkbAnyGroupMask* = 1 shl 7 + XkbAllGroupsMask* = 0x0000000F # + # BuildCoreState: Given a keyboard group and a modifier state, + # construct the value to be reported an event. + # GroupForCoreState: Given the state reported in an event, + # determine the keyboard group. + # IsLegalGroup: Returns TRUE if 'g' is a valid group index. + # + +proc XkbBuildCoreState*(m, g: int): int +proc XkbGroupForCoreState*(s: int): int +proc XkbIsLegalGroup*(g: int): bool + # + # GroupsWrap values: + # - The 'groupsWrap' field of an XkbControlsRec specifies the + # treatment of out of range groups. + # - Bits 6 and 7 of the group info field of a key symbol map + # specify the interpretation of out of range groups for the + # corresponding key. + # +const + XkbWrapIntoRange* = 0x00000000 + XkbClampIntoRange* = 0x00000040 + XkbRedirectIntoRange* = 0x00000080 # + # Action flags: Reported in the 'flags' field of most key actions. + # Interpretation depends on the type of the action; not all actions + # accept all flags. + # + # Option Used for Actions + # ------ ---------------- + # ClearLocks SetMods, LatchMods, SetGroup, LatchGroup + # LatchToLock SetMods, LatchMods, SetGroup, LatchGroup + # LockNoLock LockMods, ISOLock, LockPtrBtn, LockDeviceBtn + # LockNoUnlock LockMods, ISOLock, LockPtrBtn, LockDeviceBtn + # UseModMapMods SetMods, LatchMods, LockMods, ISOLock + # GroupAbsolute SetGroup, LatchGroup, LockGroup, ISOLock + # UseDfltButton PtrBtn, LockPtrBtn + # NoAcceleration MovePtr + # MoveAbsoluteX MovePtr + # MoveAbsoluteY MovePtr + # ISODfltIsGroup ISOLock + # ISONoAffectMods ISOLock + # ISONoAffectGroup ISOLock + # ISONoAffectPtr ISOLock + # ISONoAffectCtrls ISOLock + # MessageOnPress ActionMessage + # MessageOnRelease ActionMessage + # MessageGenKeyEvent ActionMessage + # AffectDfltBtn SetPtrDflt + # DfltBtnAbsolute SetPtrDflt + # SwitchApplication SwitchScreen + # SwitchAbsolute SwitchScreen + # + +const + XkbSA_ClearLocks* = int(1) shl 0 + XkbSA_LatchToLock* = int(1) shl 1 + XkbSA_LockNoLock* = int(1) shl 0 + XkbSA_LockNoUnlock* = int(1) shl 1 + XkbSA_UseModMapMods* = int(1) shl 2 + XkbSA_GroupAbsolute* = int(1) shl 2 + XkbSA_UseDfltButton* = 0 + XkbSA_NoAcceleration* = int(1) shl 0 + XkbSA_MoveAbsoluteX* = int(1) shl 1 + XkbSA_MoveAbsoluteY* = int(1) shl 2 + XkbSA_ISODfltIsGroup* = int(1) shl 7 + XkbSA_ISONoAffectMods* = int(1) shl 6 + XkbSA_ISONoAffectGroup* = int(1) shl 5 + XkbSA_ISONoAffectPtr* = int(1) shl 4 + XkbSA_ISONoAffectCtrls* = int(1) shl 3 + XkbSA_ISOAffectMask* = 0x00000078 + XkbSA_MessageOnPress* = int(1) shl 0 + XkbSA_MessageOnRelease* = int(1) shl 1 + XkbSA_MessageGenKeyEvent* = int(1) shl 2 + XkbSA_AffectDfltBtn* = 1 + XkbSA_DfltBtnAbsolute* = int(1) shl 2 + XkbSA_SwitchApplication* = int(1) shl 0 + XkbSA_SwitchAbsolute* = int(1) shl 2 # + # The following values apply to the SA_DeviceValuator + # action only. Valuator operations specify the action + # to be taken. Values specified in the action are + # multiplied by 2^scale before they are applied. + # + +const + XkbSA_IgnoreVal* = 0x00000000 + XkbSA_SetValMin* = 0x00000010 + XkbSA_SetValCenter* = 0x00000020 + XkbSA_SetValMax* = 0x00000030 + XkbSA_SetValRelative* = 0x00000040 + XkbSA_SetValAbsolute* = 0x00000050 + XkbSA_ValOpMask* = 0x00000070 + XkbSA_ValScaleMask* = 0x00000007 + +proc XkbSA_ValOp*(a: int): int +proc XkbSA_ValScale*(a: int): int + # + # Action types: specifies the type of a key action. Reported in the + # type field of all key actions. + # +const + XkbSA_NoAction* = 0x00000000 + XkbSA_SetMods* = 0x00000001 + XkbSA_LatchMods* = 0x00000002 + XkbSA_LockMods* = 0x00000003 + XkbSA_SetGroup* = 0x00000004 + XkbSA_LatchGroup* = 0x00000005 + XkbSA_LockGroup* = 0x00000006 + XkbSA_MovePtr* = 0x00000007 + XkbSA_PtrBtn* = 0x00000008 + XkbSA_LockPtrBtn* = 0x00000009 + XkbSA_SetPtrDflt* = 0x0000000A + XkbSA_ISOLock* = 0x0000000B + XkbSA_Terminate* = 0x0000000C + XkbSA_SwitchScreen* = 0x0000000D + XkbSA_SetControls* = 0x0000000E + XkbSA_LockControls* = 0x0000000F + XkbSA_ActionMessage* = 0x00000010 + XkbSA_RedirectKey* = 0x00000011 + XkbSA_DeviceBtn* = 0x00000012 + XkbSA_LockDeviceBtn* = 0x00000013 + XkbSA_DeviceValuator* = 0x00000014 + XkbSA_LastAction* = XkbSA_DeviceValuator + XkbSA_NumActions* = XkbSA_LastAction + 1 + +const + XkbSA_XFree86Private* = 0x00000086 +# +# Specifies the key actions that clear latched groups or modifiers. +# + +const ##define XkbSA_BreakLatch \ + # ((1<<XkbSA_NoAction)|(1<<XkbSA_PtrBtn)|(1<<XkbSA_LockPtrBtn)|\ + # (1<<XkbSA_Terminate)|(1<<XkbSA_SwitchScreen)|(1<<XkbSA_SetControls)|\ + # (1<<XkbSA_LockControls)|(1<<XkbSA_ActionMessage)|\ + # (1<<XkbSA_RedirectKey)|(1<<XkbSA_DeviceBtn)|(1<<XkbSA_LockDeviceBtn)) + # + XkbSA_BreakLatch* = (1 shl XkbSA_PtrBtn) or (1 shl XkbSA_LockPtrBtn) or + (1 shl XkbSA_Terminate) or (1 shl XkbSA_SwitchScreen) or + (1 shl XkbSA_SetControls) or (1 shl XkbSA_LockControls) or + (1 shl XkbSA_ActionMessage) or (1 shl XkbSA_RedirectKey) or + (1 shl XkbSA_DeviceBtn) or (1 shl XkbSA_LockDeviceBtn) # + # Key Behavior Qualifier: + # KB_Permanent indicates that the behavior describes an unalterable + # characteristic of the keyboard, not an XKB software-simulation of + # the listed behavior. + # Key Behavior Types: + # Specifies the behavior of the underlying key. + # + +const + XkbKB_Permanent* = 0x00000080 + XkbKB_OpMask* = 0x0000007F + XkbKB_Default* = 0x00000000 + XkbKB_Lock* = 0x00000001 + XkbKB_RadioGroup* = 0x00000002 + XkbKB_Overlay1* = 0x00000003 + XkbKB_Overlay2* = 0x00000004 + XkbKB_RGAllowNone* = 0x00000080 # + # Various macros which describe the range of legal keycodes. + # + +const + XkbMinLegalKeyCode* = 8 + XkbMaxLegalKeyCode* = 255 + XkbMaxKeyCount* = XkbMaxLegalKeyCode - XkbMinLegalKeyCode + 1 + XkbPerKeyBitArraySize* = (XkbMaxLegalKeyCode + 1) div 8 + +proc XkbIsLegalKeycode*(k: int): bool +type + PXkbControlsPtr* = ptr TXkbControlsRec + TXkbControlsRec*{.final.} = object + mk_dflt_btn*: int8 + num_groups*: int8 + groups_wrap*: int8 + internal*: TXkbModsRec + ignore_lock*: TXkbModsRec + enabled_ctrls*: int16 + repeat_delay*: int16 + repeat_interval*: int16 + slow_keys_delay*: int16 + debounce_delay*: int16 + mk_delay*: int16 + mk_interval*: int16 + mk_time_to_max*: int16 + mk_max_speed*: int16 + mk_curve*: int16 + ax_options*: int16 + ax_timeout*: int16 + axt_opts_mask*: int16 + axt_opts_values*: int16 + axt_ctrls_mask*: int16 + axt_ctrls_values*: int16 + per_key_repeat*: array[0..XkbPerKeyBitArraySize - 1, int8] + + +proc XkbAX_AnyFeedback*(c: PXkbControlsPtr): int16 +proc XkbAX_NeedOption*(c: PXkbControlsPtr, w: int16): int16 +proc XkbAX_NeedFeedback*(c: PXkbControlsPtr, w: int16): bool + # + # Assorted constants and limits. + # +const + XkbNumModifiers* = 8 + XkbNumVirtualMods* = 16 + XkbNumIndicators* = 32 + XkbMaxRadioGroups* = 32 + XkbAllRadioGroupsMask* = 0xFFFFFFFF + XkbMaxShiftLevel* = 63 + XkbMaxSymsPerKey* = XkbMaxShiftLevel * XkbNumKbdGroups + XkbRGMaxMembers* = 12 + XkbActionMessageLength* = 6 + XkbKeyNameLength* = 4 + XkbMaxRedirectCount* = 8 + XkbGeomPtsPerMM* = 10 + XkbGeomMaxColors* = 32 + XkbGeomMaxLabelColors* = 3 + XkbGeomMaxPriority* = 255 + +type + PXkbServerMapPtr* = ptr TXkbServerMapRec + TXkbServerMapRec*{.final.} = object + num_acts*: int16 + size_acts*: int16 + acts*: ptr array[0..0xfff, TXkbAction] + behaviors*: PXkbBehavior + key_acts*: PWord + explicit*: PByte + vmods*: array[0..XkbNumVirtualMods - 1, int8] + vmodmap*: PWord + + +proc XkbSMKeyActionsPtr*(m: PXkbServerMapPtr, k: int16): PXkbAction + # + # Structures and access macros used primarily by clients + # +type + PXkbSymMapPtr* = ptr TXkbSymMapRec + TXkbSymMapRec*{.final.} = object + kt_index*: array[0..XkbNumKbdGroups - 1, int8] + group_info*: int8 + width*: int8 + offset*: int8 + + +type + PXkbClientMapPtr* = ptr TXkbClientMapRec + TXkbClientMapRec*{.final.} = object + size_types*: int8 + num_types*: int8 + types*: ptr array[0..0xffff, TXkbKeyTypeRec] + size_syms*: int16 + num_syms*: int16 + syms*: ptr array[0..0xffff, TKeySym] + key_sym_map*: ptr array[0..0xffff, TXkbSymMapRec] + modmap*: PByte + + +proc XkbCMKeyGroupInfo*(m: PXkbClientMapPtr, k: int16): int8 +proc XkbCMKeyNumGroups*(m: PXkbClientMapPtr, k: int16): int8 +proc XkbCMKeyGroupWidth*(m: PXkbClientMapPtr, k: int16, g: int8): int8 +proc XkbCMKeyGroupsWidth*(m: PXkbClientMapPtr, k: int16): int8 +proc XkbCMKeyTypeIndex*(m: PXkbClientMapPtr, k: int16, g: int8): int8 +proc XkbCMKeyType*(m: PXkbClientMapPtr, k: int16, g: int8): PXkbKeyTypePtr +proc XkbCMKeyNumSyms*(m: PXkbClientMapPtr, k: int16): int16 +proc XkbCMKeySymsOffset*(m: PXkbClientMapPtr, k: int16): int8 + # + # Compatibility structures and access macros + # +type + PXkbSymInterpretPtr* = ptr TXkbSymInterpretRec + TXkbSymInterpretRec*{.final.} = object + sym*: TKeySym + flags*: int8 + match*: int8 + mods*: int8 + virtual_mod*: int8 + act*: TXkbAnyAction + + +type + PXkbCompatMapPtr* = ptr TXkbCompatMapRec + TXkbCompatMapRec*{.final.} = object + sym_interpret*: PXkbSymInterpretPtr + groups*: array[0..XkbNumKbdGroups - 1, TXkbModsRec] + num_si*: int16 + size_si*: int16 + + +type + PXkbIndicatorMapPtr* = ptr TXkbIndicatorMapRec + TXkbIndicatorMapRec*{.final.} = object + flags*: int8 + which_groups*: int8 + groups*: int8 + which_mods*: int8 + mods*: TXkbModsRec + ctrls*: int16 + + +proc XkbIM_IsAuto*(i: PXkbIndicatorMapPtr): bool +proc XkbIM_InUse*(i: PXkbIndicatorMapPtr): bool +type + PXkbIndicatorPtr* = ptr TXkbIndicatorRec + TXkbIndicatorRec*{.final.} = object + phys_indicators*: int32 + maps*: array[0..XkbNumIndicators - 1, TXkbIndicatorMapRec] + + +type + PXkbKeyNamePtr* = ptr TXkbKeyNameRec + TXkbKeyNameRec*{.final.} = object + name*: array[0..XkbKeyNameLength - 1, char] + + +type + PXkbKeyAliasPtr* = ptr TXkbKeyAliasRec + TXkbKeyAliasRec*{.final.} = object # + # Names for everything + # + float*: array[0..XkbKeyNameLength - 1, char] + alias*: array[0..XkbKeyNameLength - 1, char] + + +type + PXkbNamesPtr* = ptr TXkbNamesRec + TXkbNamesRec*{.final.} = object # + # Key Type index and mask for the four standard key types. + # + keycodes*: TAtom + geometry*: TAtom + symbols*: TAtom + types*: TAtom + compat*: TAtom + vmods*: array[0..XkbNumVirtualMods - 1, TAtom] + indicators*: array[0..XkbNumIndicators - 1, TAtom] + groups*: array[0..XkbNumKbdGroups - 1, TAtom] + keys*: PXkbKeyNamePtr + key_aliases*: PXkbKeyAliasPtr + radio_groups*: PAtom + phys_symbols*: TAtom + num_keys*: int8 + num_key_aliases*: int8 + num_rg*: int16 + + +const + XkbOneLevelIndex* = 0 + XkbTwoLevelIndex* = 1 + XkbAlphabeticIndex* = 2 + XkbKeypadIndex* = 3 + XkbLastRequiredType* = XkbKeypadIndex + XkbNumRequiredTypes* = XkbLastRequiredType + 1 + XkbMaxKeyTypes* = 255 + XkbOneLevelMask* = 1 shl 0 + XkbTwoLevelMask* = 1 shl 1 + XkbAlphabeticMask* = 1 shl 2 + XkbKeypadMask* = 1 shl 3 + XkbAllRequiredTypes* = 0x0000000F + +proc XkbShiftLevel*(n: int8): int8 +proc XkbShiftLevelMask*(n: int8): int8 + # + # Extension name and version information + # +const + XkbName* = "XKEYBOARD" + XkbMajorVersion* = 1 + XkbMinorVersion* = 0 # + # Explicit map components: + # - Used in the 'explicit' field of an XkbServerMap. Specifies + # the keyboard components that should _not_ be updated automatically + # in response to core protocol keyboard mapping requests. + # + +const + XkbExplicitKeyTypesMask* = 0x0000000F + XkbExplicitKeyType1Mask* = 1 shl 0 + XkbExplicitKeyType2Mask* = 1 shl 1 + XkbExplicitKeyType3Mask* = 1 shl 2 + XkbExplicitKeyType4Mask* = 1 shl 3 + XkbExplicitInterpretMask* = 1 shl 4 + XkbExplicitAutoRepeatMask* = 1 shl 5 + XkbExplicitBehaviorMask* = 1 shl 6 + XkbExplicitVModMapMask* = 1 shl 7 + XkbAllExplicitMask* = 0x000000FF # + # Symbol interpretations flags: + # - Used in the flags field of a symbol interpretation + # + +const + XkbSI_AutoRepeat* = 1 shl 0 + XkbSI_LockingKey* = 1 shl 1 # + # Symbol interpretations match specification: + # - Used in the match field of a symbol interpretation to specify + # the conditions under which an interpretation is used. + # + +const + XkbSI_LevelOneOnly* = 0x00000080 + XkbSI_OpMask* = 0x0000007F + XkbSI_NoneOf* = 0 + XkbSI_AnyOfOrNone* = 1 + XkbSI_AnyOf* = 2 + XkbSI_AllOf* = 3 + XkbSI_Exactly* = 4 # + # Indicator map flags: + # - Used in the flags field of an indicator map to indicate the + # conditions under which and indicator can be changed and the + # effects of changing the indicator. + # + +const + XkbIM_NoExplicit* = int(1) shl 7 + XkbIM_NoAutomatic* = int(1) shl 6 + XkbIM_LEDDrivesKB* = int(1) shl 5 # + # Indicator map component specifications: + # - Used by the 'which_groups' and 'which_mods' fields of an indicator + # map to specify which keyboard components should be used to drive + # the indicator. + # + +const + XkbIM_UseBase* = int(1) shl 0 + XkbIM_UseLatched* = int(1) shl 1 + XkbIM_UseLocked* = int(1) shl 2 + XkbIM_UseEffective* = int(1) shl 3 + XkbIM_UseCompat* = int(1) shl 4 + XkbIM_UseNone* = 0 + XkbIM_UseAnyGroup* = XkbIM_UseBase or XkbIM_UseLatched or XkbIM_UseLocked or + XkbIM_UseEffective + XkbIM_UseAnyMods* = XkbIM_UseAnyGroup or XkbIM_UseCompat # + # GetByName components: + # - Specifies desired or necessary components to GetKbdByName request. + # - Reports the components that were found in a GetKbdByNameReply + # + +const + XkbGBN_TypesMask* = int(1) shl 0 + XkbGBN_CompatMapMask* = int(1) shl 1 + XkbGBN_ClientSymbolsMask* = int(1) shl 2 + XkbGBN_ServerSymbolsMask* = int(1) shl 3 + XkbGBN_SymbolsMask* = XkbGBN_ClientSymbolsMask or XkbGBN_ServerSymbolsMask + XkbGBN_IndicatorMapMask* = int(1) shl 4 + XkbGBN_KeyNamesMask* = int(1) shl 5 + XkbGBN_GeometryMask* = int(1) shl 6 + XkbGBN_OtherNamesMask* = int(1) shl 7 + XkbGBN_AllComponentsMask* = 0x000000FF # + # ListComponents flags + # + +const + XkbLC_Hidden* = int(1) shl 0 + XkbLC_Default* = int(1) shl 1 + XkbLC_Partial* = int(1) shl 2 + XkbLC_AlphanumericKeys* = int(1) shl 8 + XkbLC_ModifierKeys* = int(1) shl 9 + XkbLC_KeypadKeys* = int(1) shl 10 + XkbLC_FunctionKeys* = int(1) shl 11 + XkbLC_AlternateGroup* = int(1) shl 12 # + # X Input Extension Interactions + # - Specifies the possible interactions between XKB and the X input + # extension + # - Used to request (XkbGetDeviceInfo) or change (XKbSetDeviceInfo) + # XKB information about an extension device. + # - Reports the list of supported optional features in the reply to + # XkbGetDeviceInfo or in an XkbExtensionDeviceNotify event. + # XkbXI_UnsupportedFeature is reported in XkbExtensionDeviceNotify + # events to indicate an attempt to use an unsupported feature. + # + +const + XkbXI_KeyboardsMask* = int(1) shl 0 + XkbXI_ButtonActionsMask* = int(1) shl 1 + XkbXI_IndicatorNamesMask* = int(1) shl 2 + XkbXI_IndicatorMapsMask* = int(1) shl 3 + XkbXI_IndicatorStateMask* = int(1) shl 4 + XkbXI_UnsupportedFeatureMask* = int(1) shl 15 + XkbXI_AllFeaturesMask* = 0x0000001F + XkbXI_AllDeviceFeaturesMask* = 0x0000001E + XkbXI_IndicatorsMask* = 0x0000001C + XkbAllExtensionDeviceEventsMask* = 0x0000801F # + # Per-Client Flags: + # - Specifies flags to be changed by the PerClientFlags request. + # + +const + XkbPCF_DetectableAutoRepeatMask* = int(1) shl 0 + XkbPCF_GrabsUseXKBStateMask* = int(1) shl 1 + XkbPCF_AutoResetControlsMask* = int(1) shl 2 + XkbPCF_LookupStateWhenGrabbed* = int(1) shl 3 + XkbPCF_SendEventUsesXKBState* = int(1) shl 4 + XkbPCF_AllFlagsMask* = 0x0000001F # + # Debugging flags and controls + # + +const + XkbDF_DisableLocks* = 1 shl 0 + +type + PXkbPropertyPtr* = ptr TXkbPropertyRec + TXkbPropertyRec*{.final.} = object + name*: cstring + value*: cstring + + +type + PXkbColorPtr* = ptr TXkbColorRec + TXkbColorRec*{.final.} = object + pixel*: int16 + spec*: cstring + + +type + PXkbPointPtr* = ptr TXkbPointRec + TXkbPointRec*{.final.} = object + x*: int16 + y*: int16 + + +type + PXkbBoundsPtr* = ptr TXkbBoundsRec + TXkbBoundsRec*{.final.} = object + x1*: int16 + y1*: int16 + x2*: int16 + y2*: int16 + + +proc XkbBoundsWidth*(b: PXkbBoundsPtr): int16 +proc XkbBoundsHeight*(b: PXkbBoundsPtr): int16 +type + PXkbOutlinePtr* = ptr TXkbOutlineRec + TXkbOutlineRec*{.final.} = object + num_points*: int16 + sz_points*: int16 + corner_radius*: int16 + points*: PXkbPointPtr + + +type + PXkbShapePtr* = ptr TXkbShapeRec + TXkbShapeRec*{.final.} = object + name*: TAtom + num_outlines*: int16 + sz_outlines*: int16 + outlines*: ptr array [0..0xffff, TXkbOutlineRec] + approx*: ptr array[0..0xffff, TXkbOutlineRec] + primary*: ptr array[0..0xffff, TXkbOutlineRec] + bounds*: TXkbBoundsRec + + +proc XkbOutlineIndex*(s: PXkbShapePtr, o: PXkbOutlinePtr): int32 +type + PXkbShapeDoodadPtr* = ptr TXkbShapeDoodadRec + TXkbShapeDoodadRec*{.final.} = object + name*: TAtom + theType*: int8 + priority*: int8 + top*: int16 + left*: int16 + angle*: int16 + color_ndx*: int16 + shape_ndx*: int16 + + +type + PXkbTextDoodadPtr* = ptr TXkbTextDoodadRec + TXkbTextDoodadRec*{.final.} = object + name*: TAtom + theType*: int8 + priority*: int8 + top*: int16 + left*: int16 + angle*: int16 + width*: int16 + height*: int16 + color_ndx*: int16 + text*: cstring + font*: cstring + + +type + PXkbIndicatorDoodadPtr* = ptr TXkbIndicatorDoodadRec + TXkbIndicatorDoodadRec*{.final.} = object + name*: TAtom + theType*: int8 + priority*: int8 + top*: int16 + left*: int16 + angle*: int16 + shape_ndx*: int16 + on_color_ndx*: int16 + off_color_ndx*: int16 + + +type + PXkbLogoDoodadPtr* = ptr TXkbLogoDoodadRec + TXkbLogoDoodadRec*{.final.} = object + name*: TAtom + theType*: int8 + priority*: int8 + top*: int16 + left*: int16 + angle*: int16 + color_ndx*: int16 + shape_ndx*: int16 + logo_name*: cstring + + +type + PXkbAnyDoodadPtr* = ptr TXkbAnyDoodadRec + TXkbAnyDoodadRec*{.final.} = object + name*: TAtom + theType*: int8 + priority*: int8 + top*: int16 + left*: int16 + angle*: int16 + + +type + PXkbDoodadPtr* = ptr TXkbDoodadRec + TXkbDoodadRec*{.final.} = object + any*: TXkbAnyDoodadRec + shape*: TXkbShapeDoodadRec + text*: TXkbTextDoodadRec + indicator*: TXkbIndicatorDoodadRec + logo*: TXkbLogoDoodadRec + + +const + XkbUnknownDoodad* = 0 + XkbOutlineDoodad* = 1 + XkbSolidDoodad* = 2 + XkbTextDoodad* = 3 + XkbIndicatorDoodad* = 4 + XkbLogoDoodad* = 5 + +type + PXkbKeyPtr* = ptr TXkbKeyRec + TXkbKeyRec*{.final.} = object + name*: TXkbKeyNameRec + gap*: int16 + shape_ndx*: int8 + color_ndx*: int8 + + +type + PXkbRowPtr* = ptr TXkbRowRec + TXkbRowRec*{.final.} = object + top*: int16 + left*: int16 + num_keys*: int16 + sz_keys*: int16 + vertical*: int16 + Keys*: PXkbKeyPtr + bounds*: TXkbBoundsRec + + +type + PXkbOverlayPtr* = ptr TXkbOverlayRec #forward for TXkbSectionRec use. + #Do not add more "type" + PXkbSectionPtr* = ptr TXkbSectionRec + TXkbSectionRec*{.final.} = object #Do not add more "type" + name*: TAtom + priority*: int8 + top*: int16 + left*: int16 + width*: int16 + height*: int16 + angle*: int16 + num_rows*: int16 + num_doodads*: int16 + num_overlays*: int16 + rows*: PXkbRowPtr + doodads*: PXkbDoodadPtr + bounds*: TXkbBoundsRec + overlays*: PXkbOverlayPtr + + PXkbOverlayKeyPtr* = ptr TXkbOverlayKeyRec + TXkbOverlayKeyRec*{.final.} = object #Do not add more "type" + over*: TXkbKeyNameRec + under*: TXkbKeyNameRec + + PXkbOverlayRowPtr* = ptr TXkbOverlayRowRec + TXkbOverlayRowRec*{.final.} = object #Do not add more "type" + row_under*: int16 + num_keys*: int16 + sz_keys*: int16 + keys*: PXkbOverlayKeyPtr + + TXkbOverlayRec*{.final.} = object + name*: TAtom + section_under*: PXkbSectionPtr + num_rows*: int16 + sz_rows*: int16 + rows*: PXkbOverlayRowPtr + bounds*: PXkbBoundsPtr + + +type + PXkbGeometryRec* = ptr TXkbGeometryRec + PXkbGeometryPtr* = PXkbGeometryRec + TXkbGeometryRec*{.final.} = object + name*: TAtom + width_mm*: int16 + height_mm*: int16 + label_font*: cstring + label_color*: PXkbColorPtr + base_color*: PXkbColorPtr + sz_properties*: int16 + sz_colors*: int16 + sz_shapes*: int16 + sz_sections*: int16 + sz_doodads*: int16 + sz_key_aliases*: int16 + num_properties*: int16 + num_colors*: int16 + num_shapes*: int16 + num_sections*: int16 + num_doodads*: int16 + num_key_aliases*: int16 + properties*: ptr array[0..0xffff, TXkbPropertyRec] + colors*: ptr array[0..0xffff, TXkbColorRec] + shapes*: ptr array[0..0xffff, TXkbShapeRec] + sections*: ptr array[0..0xffff, TXkbSectionRec] + key_aliases*: ptr array[0..0xffff, TXkbKeyAliasRec] + + +const + XkbGeomPropertiesMask* = 1 shl 0 + XkbGeomColorsMask* = 1 shl 1 + XkbGeomShapesMask* = 1 shl 2 + XkbGeomSectionsMask* = 1 shl 3 + XkbGeomDoodadsMask* = 1 shl 4 + XkbGeomKeyAliasesMask* = 1 shl 5 + XkbGeomAllMask* = 0x0000003F + +type + PXkbGeometrySizesPtr* = ptr TXkbGeometrySizesRec + TXkbGeometrySizesRec*{.final.} = object # + # Tie it all together into one big keyboard description + # + which*: int16 + num_properties*: int16 + num_colors*: int16 + num_shapes*: int16 + num_sections*: int16 + num_doodads*: int16 + num_key_aliases*: int16 + + +type + PXkbDescPtr* = ptr TXkbDescRec + TXkbDescRec*{.final.} = object + dpy*: PDisplay + flags*: int16 + device_spec*: int16 + min_key_code*: TKeyCode + max_key_code*: TKeyCode + ctrls*: PXkbControlsPtr + server*: PXkbServerMapPtr + map*: PXkbClientMapPtr + indicators*: PXkbIndicatorPtr + names*: PXkbNamesPtr + compat*: PXkbCompatMapPtr + geom*: PXkbGeometryPtr + + +proc XkbKeyKeyTypeIndex*(d: PXkbDescPtr, k: int16, g: int8): int8 +proc XkbKeyKeyType*(d: PXkbDescPtr, k: int16, g: int8): PXkbKeyTypePtr +proc XkbKeyGroupWidth*(d: PXkbDescPtr, k: int16, g: int8): int8 +proc XkbKeyGroupsWidth*(d: PXkbDescPtr, k: int16): int8 +proc XkbKeyGroupInfo*(d: PXkbDescPtr, k: int16): int8 +proc XkbKeyNumGroups*(d: PXkbDescPtr, k: int16): int8 +proc XkbKeyNumSyms*(d: PXkbDescPtr, k: int16): int16 +proc XkbKeySym*(d: PXkbDescPtr, k: int16, n: int16): TKeySym +proc XkbKeySymEntry*(d: PXkbDescPtr, k: int16, sl: int16, g: int8): TKeySym +proc XkbKeyAction*(d: PXkbDescPtr, k: int16, n: int16): PXkbAction +proc XkbKeyActionEntry*(d: PXkbDescPtr, k: int16, sl: int16, g: int8): int8 +proc XkbKeyHasActions*(d: PXkbDescPtr, k: int16): bool +proc XkbKeyNumActions*(d: PXkbDescPtr, k: int16): int16 +proc XkbKeyActionsPtr*(d: PXkbDescPtr, k: int16): PXkbAction +proc XkbKeycodeInRange*(d: PXkbDescPtr, k: int16): bool +proc XkbNumKeys*(d: PXkbDescPtr): int8 + # + # The following structures can be used to track changes + # to a keyboard device + # +type + PXkbMapChangesPtr* = ptr TXkbMapChangesRec + TXkbMapChangesRec*{.final.} = object + changed*: int16 + min_key_code*: TKeyCode + max_key_code*: TKeyCode + first_type*: int8 + num_types*: int8 + first_key_sym*: TKeyCode + num_key_syms*: int8 + first_key_act*: TKeyCode + num_key_acts*: int8 + first_key_behavior*: TKeyCode + num_key_behaviors*: int8 + first_key_explicit*: TKeyCode + num_key_explicit*: int8 + first_modmap_key*: TKeyCode + num_modmap_keys*: int8 + first_vmodmap_key*: TKeyCode + num_vmodmap_keys*: int8 + pad*: int8 + vmods*: int16 + + +type + PXkbControlsChangesPtr* = ptr TXkbControlsChangesRec + TXkbControlsChangesRec*{.final.} = object + changed_ctrls*: int16 + enabled_ctrls_changes*: int16 + num_groups_changed*: bool + + +type + PXkbIndicatorChangesPtr* = ptr TXkbIndicatorChangesRec + TXkbIndicatorChangesRec*{.final.} = object + state_changes*: int16 + map_changes*: int16 + + +type + PXkbNameChangesPtr* = ptr TXkbNameChangesRec + TXkbNameChangesRec*{.final.} = object + changed*: int16 + first_type*: int8 + num_types*: int8 + first_lvl*: int8 + num_lvls*: int8 + num_aliases*: int8 + num_rg*: int8 + first_key*: int8 + num_keys*: int8 + changed_vmods*: int16 + changed_indicators*: int32 + changed_groups*: int8 + + +type + PXkbCompatChangesPtr* = ptr TXkbCompatChangesRec + TXkbCompatChangesRec*{.final.} = object + changed_groups*: int8 + first_si*: int16 + num_si*: int16 + + +type + PXkbChangesPtr* = ptr TXkbChangesRec + TXkbChangesRec*{.final.} = object # + # These data structures are used to construct a keymap from + # a set of components or to list components in the server + # database. + # + device_spec*: int16 + state_changes*: int16 + map*: TXkbMapChangesRec + ctrls*: TXkbControlsChangesRec + indicators*: TXkbIndicatorChangesRec + names*: TXkbNameChangesRec + compat*: TXkbCompatChangesRec + + +type + PXkbComponentNamesPtr* = ptr TXkbComponentNamesRec + TXkbComponentNamesRec*{.final.} = object + keymap*: ptr int16 + keycodes*: ptr int16 + types*: ptr int16 + compat*: ptr int16 + symbols*: ptr int16 + geometry*: ptr int16 + + +type + PXkbComponentNamePtr* = ptr TXkbComponentNameRec + TXkbComponentNameRec*{.final.} = object + flags*: int16 + name*: cstring + + +type + PXkbComponentListPtr* = ptr TXkbComponentListRec + TXkbComponentListRec*{.final.} = object # + # The following data structures describe and track changes to a + # non-keyboard extension device + # + num_keymaps*: int16 + num_keycodes*: int16 + num_types*: int16 + num_compat*: int16 + num_symbols*: int16 + num_geometry*: int16 + keymaps*: PXkbComponentNamePtr + keycodes*: PXkbComponentNamePtr + types*: PXkbComponentNamePtr + compat*: PXkbComponentNamePtr + symbols*: PXkbComponentNamePtr + geometry*: PXkbComponentNamePtr + + +type + PXkbDeviceLedInfoPtr* = ptr TXkbDeviceLedInfoRec + TXkbDeviceLedInfoRec*{.final.} = object + led_class*: int16 + led_id*: int16 + phys_indicators*: int16 + maps_present*: int16 + names_present*: int16 + state*: int16 + names*: array[0..XkbNumIndicators - 1, TAtom] + maps*: array[0..XkbNumIndicators - 1, TXkbIndicatorMapRec] + + +type + PXkbDeviceInfoPtr* = ptr TXkbDeviceInfoRec + TXkbDeviceInfoRec*{.final.} = object + name*: cstring + theType*: TAtom + device_spec*: int16 + has_own_state*: bool + supported*: int16 + unsupported*: int16 + num_btns*: int16 + btn_acts*: PXkbAction + sz_leds*: int16 + num_leds*: int16 + dflt_kbd_fb*: int16 + dflt_led_fb*: int16 + leds*: PXkbDeviceLedInfoPtr + + +proc XkbXI_DevHasBtnActs*(d: PXkbDeviceInfoPtr): bool +proc XkbXI_LegalDevBtn*(d: PXkbDeviceInfoPtr, b: int16): bool +proc XkbXI_DevHasLeds*(d: PXkbDeviceInfoPtr): bool +type + PXkbDeviceLedChangesPtr* = ptr TXkbDeviceLedChangesRec + TXkbDeviceLedChangesRec*{.final.} = object + led_class*: int16 + led_id*: int16 + defined*: int16 #names or maps changed + next*: PXkbDeviceLedChangesPtr + + +type + PXkbDeviceChangesPtr* = ptr TXkbDeviceChangesRec + TXkbDeviceChangesRec*{.final.} = object + changed*: int16 + first_btn*: int16 + num_btns*: int16 + leds*: TXkbDeviceLedChangesRec + + +proc XkbShapeDoodadColor*(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr): PXkbColorPtr +proc XkbShapeDoodadShape*(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr): PXkbShapePtr +proc XkbSetShapeDoodadColor*(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr, + c: PXkbColorPtr) +proc XkbSetShapeDoodadShape*(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr, + s: PXkbShapePtr) +proc XkbTextDoodadColor*(g: PXkbGeometryPtr, d: PXkbTextDoodadPtr): PXkbColorPtr +proc XkbSetTextDoodadColor*(g: PXkbGeometryPtr, d: PXkbTextDoodadPtr, + c: PXkbColorPtr) +proc XkbIndicatorDoodadShape*(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbShapeDoodadPtr +proc XkbIndicatorDoodadOnColor*(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbColorPtr +proc XkbIndicatorDoodadOffColor*(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbColorPtr +proc XkbSetIndicatorDoodadOnColor*(g: PXkbGeometryPtr, + d: PXkbIndicatorDoodadPtr, c: PXkbColorPtr) +proc XkbSetIndicatorDoodadOffColor*(g: PXkbGeometryPtr, + d: PXkbIndicatorDoodadPtr, c: PXkbColorPtr) +proc XkbSetIndicatorDoodadShape*(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr, + s: PXkbShapeDoodadPtr) +proc XkbLogoDoodadColor*(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr): PXkbColorPtr +proc XkbLogoDoodadShape*(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr): PXkbShapeDoodadPtr +proc XkbSetLogoDoodadColor*(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr, + c: PXkbColorPtr) +proc XkbSetLogoDoodadShape*(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr, + s: PXkbShapeDoodadPtr) +proc XkbKeyShape*(g: PXkbGeometryPtr, k: PXkbKeyPtr): PXkbShapeDoodadPtr +proc XkbKeyColor*(g: PXkbGeometryPtr, k: PXkbKeyPtr): PXkbColorPtr +proc XkbSetKeyShape*(g: PXkbGeometryPtr, k: PXkbKeyPtr, s: PXkbShapeDoodadPtr) +proc XkbSetKeyColor*(g: PXkbGeometryPtr, k: PXkbKeyPtr, c: PXkbColorPtr) +proc XkbGeomColorIndex*(g: PXkbGeometryPtr, c: PXkbColorPtr): int32 +proc XkbAddGeomProperty*(geom: PXkbGeometryPtr, name: cstring, value: cstring): PXkbPropertyPtr{. + libx11c, importc: "XkbAddGeomProperty".} +proc XkbAddGeomKeyAlias*(geom: PXkbGeometryPtr, alias: cstring, float: cstring): PXkbKeyAliasPtr{. + libx11c, importc: "XkbAddGeomKeyAlias".} +proc XkbAddGeomColor*(geom: PXkbGeometryPtr, spec: cstring, pixel: int16): PXkbColorPtr{. + libx11c, importc: "XkbAddGeomColor".} +proc XkbAddGeomOutline*(shape: PXkbShapePtr, sz_points: int16): PXkbOutlinePtr{. + libx11c, importc: "XkbAddGeomOutline".} +proc XkbAddGeomShape*(geom: PXkbGeometryPtr, name: TAtom, sz_outlines: int16): PXkbShapePtr{. + libx11c, importc: "XkbAddGeomShape".} +proc XkbAddGeomKey*(row: PXkbRowPtr): PXkbKeyPtr{.libx11c, + importc: "XkbAddGeomKey".} +proc XkbAddGeomRow*(section: PXkbSectionPtr, sz_keys: int16): PXkbRowPtr{.libx11c, importc: "XkbAddGeomRow".} +proc XkbAddGeomSection*(geom: PXkbGeometryPtr, name: TAtom, sz_rows: int16, + sz_doodads: int16, sz_overlays: int16): PXkbSectionPtr{. + libx11c, importc: "XkbAddGeomSection".} +proc XkbAddGeomOverlay*(section: PXkbSectionPtr, name: TAtom, sz_rows: int16): PXkbOverlayPtr{. + libx11c, importc: "XkbAddGeomOverlay".} +proc XkbAddGeomOverlayRow*(overlay: PXkbOverlayPtr, row_under: int16, + sz_keys: int16): PXkbOverlayRowPtr{.libx11c, importc: "XkbAddGeomOverlayRow".} +proc XkbAddGeomOverlayKey*(overlay: PXkbOverlayPtr, row: PXkbOverlayRowPtr, + over: cstring, under: cstring): PXkbOverlayKeyPtr{. + libx11c, importc: "XkbAddGeomOverlayKey".} +proc XkbAddGeomDoodad*(geom: PXkbGeometryPtr, section: PXkbSectionPtr, + name: TAtom): PXkbDoodadPtr{.libx11c, + importc: "XkbAddGeomDoodad".} +proc XkbFreeGeomKeyAliases*(geom: PXkbGeometryPtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomKeyAliases".} +proc XkbFreeGeomColors*(geom: PXkbGeometryPtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomColors".} +proc XkbFreeGeomDoodads*(doodads: PXkbDoodadPtr, nDoodads: int16, freeAll: bool){. + libx11c, importc: "XkbFreeGeomDoodads".} +proc XkbFreeGeomProperties*(geom: PXkbGeometryPtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomProperties".} +proc XkbFreeGeomOverlayKeys*(row: PXkbOverlayRowPtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomOverlayKeys".} +proc XkbFreeGeomOverlayRows*(overlay: PXkbOverlayPtr, first: int16, + count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomOverlayRows".} +proc XkbFreeGeomOverlays*(section: PXkbSectionPtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomOverlays".} +proc XkbFreeGeomKeys*(row: PXkbRowPtr, first: int16, count: int16, freeAll: bool){. + libx11c, importc: "XkbFreeGeomKeys".} +proc XkbFreeGeomRows*(section: PXkbSectionPtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomRows".} +proc XkbFreeGeomSections*(geom: PXkbGeometryPtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomSections".} +proc XkbFreeGeomPoints*(outline: PXkbOutlinePtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomPoints".} +proc XkbFreeGeomOutlines*(shape: PXkbShapePtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomOutlines".} +proc XkbFreeGeomShapes*(geom: PXkbGeometryPtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomShapes".} +proc XkbFreeGeometry*(geom: PXkbGeometryPtr, which: int16, freeMap: bool){. + libx11c, importc: "XkbFreeGeometry".} +proc XkbAllocGeomProps*(geom: PXkbGeometryPtr, nProps: int16): TStatus{.libx11c, importc: "XkbAllocGeomProps".} +proc XkbAllocGeomKeyAliases*(geom: PXkbGeometryPtr, nAliases: int16): TStatus{. + libx11c, importc: "XkbAllocGeomKeyAliases".} +proc XkbAllocGeomColors*(geom: PXkbGeometryPtr, nColors: int16): TStatus{.libx11c, importc: "XkbAllocGeomColors".} +proc XkbAllocGeomShapes*(geom: PXkbGeometryPtr, nShapes: int16): TStatus{.libx11c, importc: "XkbAllocGeomShapes".} +proc XkbAllocGeomSections*(geom: PXkbGeometryPtr, nSections: int16): TStatus{. + libx11c, importc: "XkbAllocGeomSections".} +proc XkbAllocGeomOverlays*(section: PXkbSectionPtr, num_needed: int16): TStatus{. + libx11c, importc: "XkbAllocGeomOverlays".} +proc XkbAllocGeomOverlayRows*(overlay: PXkbOverlayPtr, num_needed: int16): TStatus{. + libx11c, importc: "XkbAllocGeomOverlayRows".} +proc XkbAllocGeomOverlayKeys*(row: PXkbOverlayRowPtr, num_needed: int16): TStatus{. + libx11c, importc: "XkbAllocGeomOverlayKeys".} +proc XkbAllocGeomDoodads*(geom: PXkbGeometryPtr, nDoodads: int16): TStatus{. + libx11c, importc: "XkbAllocGeomDoodads".} +proc XkbAllocGeomSectionDoodads*(section: PXkbSectionPtr, nDoodads: int16): TStatus{. + libx11c, importc: "XkbAllocGeomSectionDoodads".} +proc XkbAllocGeomOutlines*(shape: PXkbShapePtr, nOL: int16): TStatus{.libx11c, importc: "XkbAllocGeomOutlines".} +proc XkbAllocGeomRows*(section: PXkbSectionPtr, nRows: int16): TStatus{.libx11c, importc: "XkbAllocGeomRows".} +proc XkbAllocGeomPoints*(ol: PXkbOutlinePtr, nPts: int16): TStatus{.libx11c, importc: "XkbAllocGeomPoints".} +proc XkbAllocGeomKeys*(row: PXkbRowPtr, nKeys: int16): TStatus{.libx11c, importc: "XkbAllocGeomKeys".} +proc XkbAllocGeometry*(xkb: PXkbDescPtr, sizes: PXkbGeometrySizesPtr): TStatus{. + libx11c, importc: "XkbAllocGeometry".} +proc XkbSetGeometryProc*(dpy: PDisplay, deviceSpec: int16, geom: PXkbGeometryPtr): TStatus{. + libx11c, importc: "XkbSetGeometry".} +proc XkbComputeShapeTop*(shape: PXkbShapePtr, bounds: PXkbBoundsPtr): bool{. + libx11c, importc: "XkbComputeShapeTop".} +proc XkbComputeShapeBounds*(shape: PXkbShapePtr): bool{.libx11c, + importc: "XkbComputeShapeBounds".} +proc XkbComputeRowBounds*(geom: PXkbGeometryPtr, section: PXkbSectionPtr, + row: PXkbRowPtr): bool{.libx11c, + importc: "XkbComputeRowBounds".} +proc XkbComputeSectionBounds*(geom: PXkbGeometryPtr, section: PXkbSectionPtr): bool{. + libx11c, importc: "XkbComputeSectionBounds".} +proc XkbFindOverlayForKey*(geom: PXkbGeometryPtr, wanted: PXkbSectionPtr, + under: cstring): cstring{.libx11c, + importc: "XkbFindOverlayForKey".} +proc XkbGetGeometryProc*(dpy: PDisplay, xkb: PXkbDescPtr): TStatus{.libx11c, importc: "XkbGetGeometry".} +proc XkbGetNamedGeometry*(dpy: PDisplay, xkb: PXkbDescPtr, name: TAtom): TStatus{. + libx11c, importc: "XkbGetNamedGeometry".} +when defined(XKB_IN_SERVER): + proc SrvXkbAddGeomKeyAlias*(geom: PXkbGeometryPtr, alias: cstring, + float: cstring): PXkbKeyAliasPtr{.libx11c, importc: "XkbAddGeomKeyAlias".} + proc SrvXkbAddGeomColor*(geom: PXkbGeometryPtr, spec: cstring, pixel: int16): PXkbColorPtr{. + libx11c, importc: "XkbAddGeomColor".} + proc SrvXkbAddGeomDoodad*(geom: PXkbGeometryPtr, section: PXkbSectionPtr, + name: TAtom): PXkbDoodadPtr{.libx11c, + importc: "XkbAddGeomDoodad".} + proc SrvXkbAddGeomKey*(geom: PXkbGeometryPtr, alias: cstring, float: cstring): PXkbKeyAliasPtr{. + libx11c, importc: "XkbAddGeomKeyAlias".} + proc SrvXkbAddGeomOutline*(shape: PXkbShapePtr, sz_points: int16): PXkbOutlinePtr{. + libx11c, importc: "XkbAddGeomOutline".} + proc SrvXkbAddGeomOverlay*(overlay: PXkbOverlayPtr, row: PXkbOverlayRowPtr, + over: cstring, under: cstring): PXkbOverlayKeyPtr{. + libx11c, importc: "XkbAddGeomOverlayKey".} + proc SrvXkbAddGeomOverlayRow*(overlay: PXkbOverlayPtr, row_under: int16, + sz_keys: int16): PXkbOverlayRowPtr{.libx11c, importc: "XkbAddGeomOverlayRow".} + proc SrvXkbAddGeomOverlayKey*(overlay: PXkbOverlayPtr, row: PXkbOverlayRowPtr, + over: cstring, under: cstring): PXkbOverlayKeyPtr{. + libx11c, importc: "XkbAddGeomOverlayKey".} + proc SrvXkbAddGeomProperty*(geom: PXkbGeometryPtr, name: cstring, + value: cstring): PXkbPropertyPtr{.libx11c, importc: "XkbAddGeomProperty".} + proc SrvXkbAddGeomRow*(section: PXkbSectionPtr, sz_keys: int16): PXkbRowPtr{. + libx11c, importc: "XkbAddGeomRow".} + proc SrvXkbAddGeomSection*(geom: PXkbGeometryPtr, name: TAtom, sz_rows: int16, + sz_doodads: int16, sz_overlays: int16): PXkbSectionPtr{. + libx11c, importc: "XkbAddGeomSection".} + proc SrvXkbAddGeomShape*(geom: PXkbGeometryPtr, name: TAtom, + sz_outlines: int16): PXkbShapePtr{.libx11c, importc: "XkbAddGeomShape".} + proc SrvXkbAllocGeomKeyAliases*(geom: PXkbGeometryPtr, nAliases: int16): TStatus{. + libx11c, importc: "XkbAllocGeomKeyAliases".} + proc SrvXkbAllocGeomColors*(geom: PXkbGeometryPtr, nColors: int16): TStatus{. + libx11c, importc: "XkbAllocGeomColors".} + proc SrvXkbAllocGeomDoodads*(geom: PXkbGeometryPtr, nDoodads: int16): TStatus{. + libx11c, importc: "XkbAllocGeomDoodads".} + proc SrvXkbAllocGeomKeys*(row: PXkbRowPtr, nKeys: int16): TStatus{.libx11c, importc: "XkbAllocGeomKeys".} + proc SrvXkbAllocGeomOutlines*(shape: PXkbShapePtr, nOL: int16): TStatus{. + libx11c, importc: "XkbAllocGeomOutlines".} + proc SrvXkbAllocGeomPoints*(ol: PXkbOutlinePtr, nPts: int16): TStatus{.libx11c, importc: "XkbAllocGeomPoints".} + proc SrvXkbAllocGeomProps*(geom: PXkbGeometryPtr, nProps: int16): TStatus{. + libx11c, importc: "XkbAllocGeomProps".} + proc SrvXkbAllocGeomRows*(section: PXkbSectionPtr, nRows: int16): TStatus{. + libx11c, importc: "XkbAllocGeomRows".} + proc SrvXkbAllocGeomSectionDoodads*(section: PXkbSectionPtr, nDoodads: int16): TStatus{. + libx11c, importc: "XkbAllocGeomSectionDoodads".} + proc SrvXkbAllocGeomSections*(geom: PXkbGeometryPtr, nSections: int16): TStatus{. + libx11c, importc: "XkbAllocGeomSections".} + proc SrvXkbAllocGeomOverlays*(section: PXkbSectionPtr, num_needed: int16): TStatus{. + libx11c, importc: "XkbAllocGeomOverlays".} + proc SrvXkbAllocGeomOverlayRows*(overlay: PXkbOverlayPtr, num_needed: int16): TStatus{. + libx11c, importc: "XkbAllocGeomOverlayRows".} + proc SrvXkbAllocGeomOverlayKeys*(row: PXkbOverlayRowPtr, num_needed: int16): TStatus{. + libx11c, importc: "XkbAllocGeomOverlayKeys".} + proc SrvXkbAllocGeomShapes*(geom: PXkbGeometryPtr, nShapes: int16): TStatus{. + libx11c, importc: "XkbAllocGeomShapes".} + proc SrvXkbAllocGeometry*(xkb: PXkbDescPtr, sizes: PXkbGeometrySizesPtr): TStatus{. + libx11c, importc: "XkbAllocGeometry".} + proc SrvXkbFreeGeomKeyAliases*(geom: PXkbGeometryPtr, first: int16, + count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomKeyAliases".} + proc SrvXkbFreeGeomColors*(geom: PXkbGeometryPtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomColors".} + proc SrvXkbFreeGeomDoodads*(doodads: PXkbDoodadPtr, nDoodads: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomDoodads".} + proc SrvXkbFreeGeomProperties*(geom: PXkbGeometryPtr, first: int16, + count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomProperties".} + proc SrvXkbFreeGeomOverlayKeys*(row: PXkbOverlayRowPtr, first: int16, + count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomOverlayKeys".} + proc SrvXkbFreeGeomOverlayRows*(overlay: PXkbOverlayPtr, first: int16, + count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomOverlayRows".} + proc SrvXkbFreeGeomOverlays*(section: PXkbSectionPtr, first: int16, + count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomOverlays".} + proc SrvXkbFreeGeomKeys*(row: PXkbRowPtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomKeys".} + proc SrvXkbFreeGeomRows*(section: PXkbSectionPtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomRows".} + proc SrvXkbFreeGeomSections*(geom: PXkbGeometryPtr, first: int16, + count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomSections".} + proc SrvXkbFreeGeomPoints*(outline: PXkbOutlinePtr, first: int16, + count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomPoints".} + proc SrvXkbFreeGeomOutlines*(shape: PXkbShapePtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomOutlines".} + proc SrvXkbFreeGeomShapes*(geom: PXkbGeometryPtr, first: int16, count: int16, + freeAll: bool){.libx11c, + importc: "XkbFreeGeomShapes".} + proc SrvXkbFreeGeometry*(geom: PXkbGeometryPtr, which: int16, freeMap: bool){. + libx11c, importc: "XkbFreeGeometry".} +# implementation + +import #************************************ xkb ************************************ + xi + +proc XkbLegalXILedClass(c: int): bool = + ##define XkbLegalXILedClass(c) (((c)==KbdFeedbackClass)||((c)==LedFeedbackClass)|| + # ((c)==XkbDfltXIClass)||((c)==XkbAllXIClasses)) + result = (c == KbdFeedbackClass) or (c == LedFeedbackClass) or + (c == XkbDfltXIClass) or (c == XkbAllXIClasses) + +proc XkbLegalXIBellClass(c: int): bool = + ##define XkbLegalXIBellClass(c) (((c)==KbdFeedbackClass)||((c)==BellFeedbackClass)|| + # ((c)==XkbDfltXIClass)||((c)==XkbAllXIClasses)) + result = (c == KbdFeedbackClass) or (c == BellFeedbackClass) or + (c == XkbDfltXIClass) or (c == XkbAllXIClasses) + +proc XkbExplicitXIDevice(c: int): bool = + ##define XkbExplicitXIDevice(c) (((c)&(~0xff))==0) + result = (c and (not 0x000000FF)) == 0 + +proc XkbExplicitXIClass(c: int): bool = + ##define XkbExplicitXIClass(c) (((c)&(~0xff))==0) + result = (c and (not 0x000000FF)) == 0 + +proc XkbExplicitXIId(c: int): bool = + ##define XkbExplicitXIId(c) (((c)&(~0xff))==0) + result = (c and (not 0x000000FF)) == 0 + +proc XkbSingleXIClass(c: int): bool = + ##define XkbSingleXIClass(c) ((((c)&(~0xff))==0)||((c)==XkbDfltXIClass)) + result = ((c and (not 0x000000FF)) == 0) or (c == XkbDfltXIClass) + +proc XkbSingleXIId(c: int): bool = + ##define XkbSingleXIId(c) ((((c)&(~0xff))==0)||((c)==XkbDfltXIId)) + result = ((c and (not 0x000000FF)) == 0) or (c == XkbDfltXIId) + +proc XkbBuildCoreState(m, g: int): int = + ##define XkbBuildCoreState(m,g) ((((g)&0x3)<<13)|((m)&0xff)) + result = ((g and 0x00000003) shl 13) or (m and 0x000000FF) + +proc XkbGroupForCoreState(s: int): int = + ##define XkbGroupForCoreState(s) (((s)>>13)&0x3) + result = (s shr 13) and 0x00000003 + +proc XkbIsLegalGroup(g: int): bool = + ##define XkbIsLegalGroup(g) (((g)>=0)&&((g)<XkbNumKbdGroups)) + result = (g >= 0) and (g < XkbNumKbdGroups) + +proc XkbSA_ValOp(a: int): int = + ##define XkbSA_ValOp(a) ((a)&XkbSA_ValOpMask) + result = a and XkbSA_ValOpMask + +proc XkbSA_ValScale(a: int): int = + ##define XkbSA_ValScale(a) ((a)&XkbSA_ValScaleMask) + result = a and XkbSA_ValScaleMask + +proc XkbIsModAction(a: PXkbAnyAction): bool = + ##define XkbIsModAction(a) (((a)->type>=Xkb_SASetMods)&&((a)->type<=XkbSA_LockMods)) + result = (ze(a.theType) >= XkbSA_SetMods) and (ze(a.theType) <= XkbSA_LockMods) + +proc XkbIsGroupAction(a: PXkbAnyAction): bool = + ##define XkbIsGroupAction(a) (((a)->type>=XkbSA_SetGroup)&&((a)->type<=XkbSA_LockGroup)) + result = (ze(a.theType) >= XkbSA_SetGroup) or (ze(a.theType) <= XkbSA_LockGroup) + +proc XkbIsPtrAction(a: PXkbAnyAction): bool = + ##define XkbIsPtrAction(a) (((a)->type>=XkbSA_MovePtr)&&((a)->type<=XkbSA_SetPtrDflt)) + result = (ze(a.theType) >= XkbSA_MovePtr) and + (ze(a.theType) <= XkbSA_SetPtrDflt) + +proc XkbIsLegalKeycode(k: int): bool = + ##define XkbIsLegalKeycode(k) (((k)>=XkbMinLegalKeyCode)&&((k)<=XkbMaxLegalKeyCode)) + result = (k >= XkbMinLegalKeyCode) and (k <= XkbMaxLegalKeyCode) + +proc XkbShiftLevel(n: int8): int8 = + ##define XkbShiftLevel(n) ((n)-1) + result = n - 1'i8 + +proc XkbShiftLevelMask(n: int8): int8 = + ##define XkbShiftLevelMask(n) (1<<((n)-1)) + result = 1'i8 shl (n - 1'i8) + +proc XkbcharToInt(v: int8): int16 = + ##define XkbcharToInt(v) ((v)&0x80?(int)((v)|(~0xff)):(int)((v)&0x7f)) + if ((v and 0x80'i8) != 0'i8): result = v or (not 0xFF'i16) + else: result = int16(v and 0x7F'i8) + +proc XkbIntTo2chars(i: int16, h, L: var int8) = + ##define XkbIntTo2chars(i,h,l) (((h)=((i>>8)&0xff)),((l)=((i)&0xff))) + h = toU8((i shr 8'i16) and 0x00FF'i16) + L = toU8(i and 0xFF'i16) + +proc Xkb2charsToInt(h, L: int8): int16 = + when defined(cpu64): + ##define Xkb2charsToInt(h,l) ((h)&0x80?(int)(((h)<<8)|(l)|(~0xffff)): (int)(((h)<<8)|(l)&0x7fff)) + if (h and 0x80'i8) != 0'i8: + result = toU16((ze(h) shl 8) or ze(L) or not 0x0000FFFF) + else: + result = toU16((ze(h) shl 8) or ze(L) and 0x00007FFF) + else: + ##define Xkb2charsToInt(h,l) ((short)(((h)<<8)|(l))) + result = toU16(ze(h) shl 8 or ze(L)) + +proc XkbModLocks(s: PXkbStatePtr): int8 = + ##define XkbModLocks(s) ((s)->locked_mods) + result = s.locked_mods + +proc XkbStateMods(s: PXkbStatePtr): int16 = + ##define XkbStateMods(s) ((s)->base_mods|(s)->latched_mods|XkbModLocks(s)) + result = s.base_mods or s.latched_mods or XkbModLocks(s) + +proc XkbGroupLock(s: PXkbStatePtr): int8 = + ##define XkbGroupLock(s) ((s)->locked_group) + result = s.locked_group + +proc XkbStateGroup(s: PXkbStatePtr): int16 = + ##define XkbStateGroup(s) ((s)->base_group+(s)->latched_group+XkbGroupLock(s)) + result = s.base_group + (s.latched_group) + XkbGroupLock(s) + +proc XkbStateFieldFromRec(s: PXkbStatePtr): int = + ##define XkbStateFieldFromRec(s) XkbBuildCoreState((s)->lookup_mods,(s)->group) + result = XkbBuildCoreState(s.lookup_mods, s.group) + +proc XkbGrabStateFromRec(s: PXkbStatePtr): int = + ##define XkbGrabStateFromRec(s) XkbBuildCoreState((s)->grab_mods,(s)->group) + result = XkbBuildCoreState(s.grab_mods, s.group) + +proc XkbNumGroups(g: int16): int16 = + ##define XkbNumGroups(g) ((g)&0x0f) + result = g and 0x0000000F'i16 + +proc XkbOutOfRangeGroupInfo(g: int16): int16 = + ##define XkbOutOfRangeGroupInfo(g) ((g)&0xf0) + result = g and 0x000000F0'i16 + +proc XkbOutOfRangeGroupAction(g: int16): int16 = + ##define XkbOutOfRangeGroupAction(g) ((g)&0xc0) + result = g and 0x000000C0'i16 + +proc XkbOutOfRangeGroupNumber(g: int16): int16 = + ##define XkbOutOfRangeGroupNumber(g) (((g)&0x30)>>4) + result = (g and 0x00000030'i16) shr 4'i16 + +proc XkbSetGroupInfo(g, w, n: int16): int16 = + ##define XkbSetGroupInfo(g,w,n) (((w)&0xc0)|(((n)&3)<<4)|((g)&0x0f)) + result = (w and 0x000000C0'i16) or + ((n and 3'i16) shl 4'i16) or (g and 0x0000000F'i16) + +proc XkbSetNumGroups(g, n: int16): int16 = + ##define XkbSetNumGroups(g,n) (((g)&0xf0)|((n)&0x0f)) + result = (g and 0x000000F0'i16) or (n and 0x0000000F'i16) + +proc XkbModActionVMods(a: PXkbModAction): int16 = + ##define XkbModActionVMods(a) ((short)(((a)->vmods1<<8)|((a)->vmods2))) + result = toU16((ze(a.vmods1) shl 8) or ze(a.vmods2)) + +proc XkbSetModActionVMods(a: PXkbModAction, v: int8) = + ##define XkbSetModActionVMods(a,v) (((a)->vmods1=(((v)>>8)&0xff)),(a)->vmods2=((v)&0xff)) + a.vmods1 = toU8((ze(v) shr 8) and 0x000000FF) + a.vmods2 = toU8(ze(v) and 0x000000FF) + +proc XkbSAGroup(a: PXkbGroupAction): int8 = + ##define XkbSAGroup(a) (XkbcharToInt((a)->group_XXX)) + result = int8(XkbcharToInt(a.group_XXX)) + +proc XkbSASetGroupProc(a: PXkbGroupAction, g: int8) = + ##define XkbSASetGroup(a,g) ((a)->group_XXX=(g)) + a.group_XXX = g + +proc XkbPtrActionX(a: PXkbPtrAction): int16 = + ##define XkbPtrActionX(a) (Xkb2charsToInt((a)->high_XXX,(a)->low_XXX)) + result = int16(Xkb2charsToInt(a.high_XXX, a.low_XXX)) + +proc XkbPtrActionY(a: PXkbPtrAction): int16 = + ##define XkbPtrActionY(a) (Xkb2charsToInt((a)->high_YYY,(a)->low_YYY)) + result = int16(Xkb2charsToInt(a.high_YYY, a.low_YYY)) + +proc XkbSetPtrActionX(a: PXkbPtrAction, x: int8) = + ##define XkbSetPtrActionX(a,x) (XkbIntTo2chars(x,(a)->high_XXX,(a)->low_XXX)) + XkbIntTo2chars(x, a.high_XXX, a.low_XXX) + +proc XkbSetPtrActionY(a: PXkbPtrAction, y: int8) = + ##define XkbSetPtrActionY(a,y) (XkbIntTo2chars(y,(a)->high_YYY,(a)->low_YYY)) + XkbIntTo2chars(y, a.high_YYY, a.low_YYY) + +proc XkbSAPtrDfltValue(a: PXkbPtrDfltAction): int8 = + ##define XkbSAPtrDfltValue(a) (XkbcharToInt((a)->valueXXX)) + result = int8(XkbcharToInt(a.valueXXX)) + +proc XkbSASetPtrDfltValue(a: PXkbPtrDfltAction, c: pointer) = + ##define XkbSASetPtrDfltValue(a,c) ((a)->valueXXX= ((c)&0xff)) + a.valueXXX = toU8(cast[int](c)) + +proc XkbSAScreen(a: PXkbSwitchScreenAction): int8 = + ##define XkbSAScreen(a) (XkbcharToInt((a)->screenXXX)) + result = toU8(XkbcharToInt(a.screenXXX)) + +proc XkbSASetScreen(a: PXkbSwitchScreenAction, s: pointer) = + ##define XkbSASetScreen(a,s) ((a)->screenXXX= ((s)&0xff)) + a.screenXXX = toU8(cast[int](s)) + +proc XkbActionSetCtrls(a: PXkbCtrlsAction, c: int8) = + ##define XkbActionSetCtrls(a,c) (((a)->ctrls3=(((c)>>24)&0xff)),((a)->ctrls2=(((c)>>16)&0xff)), + # ((a)->ctrls1=(((c)>>8)&0xff)),((a)->ctrls0=((c)&0xff))) + a.ctrls3 = toU8((ze(c) shr 24) and 0x000000FF) + a.ctrls2 = toU8((ze(c) shr 16) and 0x000000FF) + a.ctrls1 = toU8((ze(c) shr 8) and 0x000000FF) + a.ctrls0 = toU8(ze(c) and 0x000000FF) + +proc XkbActionCtrls(a: PXkbCtrlsAction): int16 = + ##define XkbActionCtrls(a) ((((unsigned int)(a)->ctrls3)<<24)|(((unsigned int)(a)->ctrls2)<<16)| + # (((unsigned int)(a)->ctrls1)<<8)|((unsigned int)((a)->ctrls0))) + result = toU16((ze(a.ctrls3) shl 24) or (ze(a.ctrls2) shl 16) or + (ze(a.ctrls1) shl 8) or ze(a.ctrls0)) + +proc XkbSARedirectVMods(a: PXkbRedirectKeyAction): int16 = + ##define XkbSARedirectVMods(a) ((((unsigned int)(a)->vmods1)<<8)|((unsigned int)(a)->vmods0)) + result = toU16((ze(a.vmods1) shl 8) or ze(a.vmods0)) + +proc XkbSARedirectSetVMods(a: PXkbRedirectKeyAction, m: int8) = + ##define XkbSARedirectSetVMods(a,m) (((a)->vmods_mask1=(((m)>>8)&0xff)),((a)->vmods_mask0=((m)&0xff))) + a.vmods_mask1 = toU8((ze(m) shr 8) and 0x000000FF) + a.vmods_mask0 = toU8(ze(m) or 0x000000FF) + +proc XkbSARedirectVModsMask(a: PXkbRedirectKeyAction): int16 = + ##define XkbSARedirectVModsMask(a) ((((unsigned int)(a)->vmods_mask1)<<8)| + # ((unsigned int)(a)->vmods_mask0)) + result = toU16((ze(a.vmods_mask1) shl 8) or ze(a.vmods_mask0)) + +proc XkbSARedirectSetVModsMask(a: PXkbRedirectKeyAction, m: int8) = + ##define XkbSARedirectSetVModsMask(a,m) (((a)->vmods_mask1=(((m)>>8)&0xff)),((a)->vmods_mask0=((m)&0xff))) + a.vmods_mask1 = toU8(ze(m) shr 8 and 0x000000FF) + a.vmods_mask0 = toU8(ze(m) and 0x000000FF) + +proc XkbAX_AnyFeedback(c: PXkbControlsPtr): int16 = + ##define XkbAX_AnyFeedback(c) ((c)->enabled_ctrls&XkbAccessXFeedbackMask) + result = toU16(ze(c.enabled_ctrls) and XkbAccessXFeedbackMask) + +proc XkbAX_NeedOption(c: PXkbControlsPtr, w: int16): int16 = + ##define XkbAX_NeedOption(c,w) ((c)->ax_options&(w)) + result = toU16(ze(c.ax_options) and ze(w)) + +proc XkbAX_NeedFeedback(c: PXkbControlsPtr, w: int16): bool = + ##define XkbAX_NeedFeedback(c,w) (XkbAX_AnyFeedback(c)&&XkbAX_NeedOption(c,w)) + result = (XkbAX_AnyFeedback(c) > 0'i16) and (XkbAX_NeedOption(c, w) > 0'i16) + +proc XkbSMKeyActionsPtr(m: PXkbServerMapPtr, k: int16): PXkbAction = + ##define XkbSMKeyActionsPtr(m,k) (&(m)->acts[(m)->key_acts[k]]) + result = addr(m.acts[ze(m.key_acts[ze(k)])]) + +proc XkbCMKeyGroupInfo(m: PXkbClientMapPtr, k: int16): int8 = + ##define XkbCMKeyGroupInfo(m,k) ((m)->key_sym_map[k].group_info) + result = m.key_sym_map[ze(k)].group_info + +proc XkbCMKeyNumGroups(m: PXkbClientMapPtr, k: int16): int8 = + ##define XkbCMKeyNumGroups(m,k) (XkbNumGroups((m)->key_sym_map[k].group_info)) + result = toU8(XkbNumGroups(m.key_sym_map[ze(k)].group_info)) + +proc XkbCMKeyGroupWidth(m: PXkbClientMapPtr, k: int16, g: int8): int8 = + ##define XkbCMKeyGroupWidth(m,k,g) (XkbCMKeyType(m,k,g)->num_levels) + result = XkbCMKeyType(m, k, g).num_levels + +proc XkbCMKeyGroupsWidth(m: PXkbClientMapPtr, k: int16): int8 = + ##define XkbCMKeyGroupsWidth(m,k) ((m)->key_sym_map[k].width) + result = m.key_sym_map[ze(k)].width + +proc XkbCMKeyTypeIndex(m: PXkbClientMapPtr, k: int16, g: int8): int8 = + ##define XkbCMKeyTypeIndex(m,k,g) ((m)->key_sym_map[k].kt_index[g&0x3]) + result = m.key_sym_map[ze(k)].kt_index[ze(g) and 0x00000003] + +proc XkbCMKeyType(m: PXkbClientMapPtr, k: int16, g: int8): PXkbKeyTypePtr = + ##define XkbCMKeyType(m,k,g) (&(m)->types[XkbCMKeyTypeIndex(m,k,g)]) + result = addr(m.types[ze(XkbCMKeyTypeIndex(m, k, g))]) + +proc XkbCMKeyNumSyms(m: PXkbClientMapPtr, k: int16): int16 = + ##define XkbCMKeyNumSyms(m,k) (XkbCMKeyGroupsWidth(m,k)*XkbCMKeyNumGroups(m,k)) + result = toU16(ze(XkbCMKeyGroupsWidth(m, k)) or ze(XkbCMKeyNumGroups(m, k))) + +proc XkbCMKeySymsOffset(m: PXkbClientMapPtr, k: int16): int8 = + ##define XkbCMKeySymsOffset(m,k) ((m)->key_sym_map[k].offset) + result = m.key_sym_map[ze(k)].offset + +proc XkbCMKeySymsPtr*(m: PXkbClientMapPtr, k: int16): PKeySym = + ##define XkbCMKeySymsPtr(m,k) (&(m)->syms[XkbCMKeySymsOffset(m,k)]) + result = addr(m.syms[ze(XkbCMKeySymsOffset(m, k))]) + +proc XkbIM_IsAuto(i: PXkbIndicatorMapPtr): bool = + ##define XkbIM_IsAuto(i) ((((i)->flags&XkbIM_NoAutomatic)==0)&&(((i)->which_groups&&(i)->groups)|| + # ((i)->which_mods&&(i)->mods.mask)|| ((i)->ctrls))) + result = ((ze(i.flags) and XkbIM_NoAutomatic) == 0) and + (((i.which_groups > 0'i8) and (i.groups > 0'i8)) or + ((i.which_mods > 0'i8) and (i.mods.mask > 0'i8)) or (i.ctrls > 0'i8)) + +proc XkbIM_InUse(i: PXkbIndicatorMapPtr): bool = + ##define XkbIM_InUse(i) (((i)->flags)||((i)->which_groups)||((i)->which_mods)||((i)->ctrls)) + result = (i.flags > 0'i8) or (i.which_groups > 0'i8) or (i.which_mods > 0'i8) or + (i.ctrls > 0'i8) + +proc XkbKeyKeyTypeIndex(d: PXkbDescPtr, k: int16, g: int8): int8 = + ##define XkbKeyKeyTypeIndex(d,k,g) (XkbCMKeyTypeIndex((d)->map,k,g)) + result = XkbCMKeyTypeIndex(d.map, k, g) + +proc XkbKeyKeyType(d: PXkbDescPtr, k: int16, g: int8): PXkbKeyTypePtr = + ##define XkbKeyKeyType(d,k,g) (XkbCMKeyType((d)->map,k,g)) + result = XkbCMKeyType(d.map, k, g) + +proc XkbKeyGroupWidth(d: PXkbDescPtr, k: int16, g: int8): int8 = + ##define XkbKeyGroupWidth(d,k,g) (XkbCMKeyGroupWidth((d)->map,k,g)) + result = XkbCMKeyGroupWidth(d.map, k, g) + +proc XkbKeyGroupsWidth(d: PXkbDescPtr, k: int16): int8 = + ##define XkbKeyGroupsWidth(d,k) (XkbCMKeyGroupsWidth((d)->map,k)) + result = XkbCMKeyGroupsWidth(d.map, k) + +proc XkbKeyGroupInfo(d: PXkbDescPtr, k: int16): int8 = + ##define XkbKeyGroupInfo(d,k) (XkbCMKeyGroupInfo((d)->map,(k))) + result = XkbCMKeyGroupInfo(d.map, k) + +proc XkbKeyNumGroups(d: PXkbDescPtr, k: int16): int8 = + ##define XkbKeyNumGroups(d,k) (XkbCMKeyNumGroups((d)->map,(k))) + result = XkbCMKeyNumGroups(d.map, k) + +proc XkbKeyNumSyms(d: PXkbDescPtr, k: int16): int16 = + ##define XkbKeyNumSyms(d,k) (XkbCMKeyNumSyms((d)->map,(k))) + result = XkbCMKeyNumSyms(d.map, k) + +proc XkbKeySymsPtr*(d: PXkbDescPtr, k: int16): PKeySym = + ##define XkbKeySymsPtr(d,k) (XkbCMKeySymsPtr((d)->map,(k))) + result = XkbCMKeySymsPtr(d.map, k) + +proc XkbKeySym(d: PXkbDescPtr, k: int16, n: int16): TKeySym = + ##define XkbKeySym(d,k,n) (XkbKeySymsPtr(d,k)[n]) + result = cast[ptr array[0..0xffff, TKeySym]](XkbKeySymsPtr(d, k))[ze(n)] # XXX: this seems strange! + +proc XkbKeySymEntry(d: PXkbDescPtr, k: int16, sl: int16, g: int8): TKeySym = + ##define XkbKeySymEntry(d,k,sl,g) (XkbKeySym(d,k,((XkbKeyGroupsWidth(d,k)*(g))+(sl)))) + result = XkbKeySym(d, k, toU16(ze(XkbKeyGroupsWidth(d, k)) * ze(g) + ze(sl))) + +proc XkbKeyAction(d: PXkbDescPtr, k: int16, n: int16): PXkbAction = + ##define XkbKeyAction(d,k,n) (XkbKeyHasActions(d,k)?&XkbKeyActionsPtr(d,k)[n]:NULL) + #if (XkbKeyHasActions(d, k)): + # result = XkbKeyActionsPtr(d, k)[ze(n)] #Buggy !!! + assert(false) + result = nil + +proc XkbKeyActionEntry(d: PXkbDescPtr, k: int16, sl: int16, g: int8): int8 = + ##define XkbKeyActionEntry(d,k,sl,g) (XkbKeyHasActions(d,k) ? + # XkbKeyAction(d, k, ((XkbKeyGroupsWidth(d, k) * (g))+(sl))):NULL) + if XkbKeyHasActions(d, k): + result = XkbKeyGroupsWidth(d, k) *% g +% toU8(sl) + else: + result = 0'i8 + +proc XkbKeyHasActions(d: PXkbDescPtr, k: int16): bool = + ##define XkbKeyHasActions(d,k) ((d)->server->key_acts[k]!=0) + result = d.server.key_acts[ze(k)] != 0'i16 + +proc XkbKeyNumActions(d: PXkbDescPtr, k: int16): int16 = + ##define XkbKeyNumActions(d,k) (XkbKeyHasActions(d,k)?XkbKeyNumSyms(d,k):1) + if (XkbKeyHasActions(d, k)): result = XkbKeyNumSyms(d, k) + else: result = 1'i16 + +proc XkbKeyActionsPtr(d: PXkbDescPtr, k: int16): PXkbAction = + ##define XkbKeyActionsPtr(d,k) (XkbSMKeyActionsPtr((d)->server,k)) + result = XkbSMKeyActionsPtr(d.server, k) + +proc XkbKeycodeInRange(d: PXkbDescPtr, k: int16): bool = + ##define XkbKeycodeInRange(d,k) (((k)>=(d)->min_key_code)&& ((k)<=(d)->max_key_code)) + result = (char(toU8(k)) >= d.min_key_code) and (char(toU8(k)) <= d.max_key_code) + +proc XkbNumKeys(d: PXkbDescPtr): int8 = + ##define XkbNumKeys(d) ((d)->max_key_code-(d)->min_key_code+1) + result = toU8(ord(d.max_key_code) - ord(d.min_key_code) + 1) + +proc XkbXI_DevHasBtnActs(d: PXkbDeviceInfoPtr): bool = + ##define XkbXI_DevHasBtnActs(d) (((d)->num_btns>0)&&((d)->btn_acts!=NULL)) + result = (d.num_btns > 0'i16) and (not (d.btn_acts == nil)) + +proc XkbXI_LegalDevBtn(d: PXkbDeviceInfoPtr, b: int16): bool = + ##define XkbXI_LegalDevBtn(d,b) (XkbXI_DevHasBtnActs(d)&&((b)<(d)->num_btns)) + result = XkbXI_DevHasBtnActs(d) and (b <% d.num_btns) + +proc XkbXI_DevHasLeds(d: PXkbDeviceInfoPtr): bool = + ##define XkbXI_DevHasLeds(d) (((d)->num_leds>0)&&((d)->leds!=NULL)) + result = (d.num_leds > 0'i16) and (not (d.leds == nil)) + +proc XkbBoundsWidth(b: PXkbBoundsPtr): int16 = + ##define XkbBoundsWidth(b) (((b)->x2)-((b)->x1)) + result = (b.x2) - b.x1 + +proc XkbBoundsHeight(b: PXkbBoundsPtr): int16 = + ##define XkbBoundsHeight(b) (((b)->y2)-((b)->y1)) + result = (b.y2) - b.y1 + +proc XkbOutlineIndex(s: PXkbShapePtr, o: PXkbOutlinePtr): int32 = + ##define XkbOutlineIndex(s,o) ((int)((o)-&(s)->outlines[0])) + result = int32((cast[TAddress](o) - cast[TAddress](addr(s.outlines[0]))) div sizeof(PXkbOutlinePtr)) + +proc XkbShapeDoodadColor(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr): PXkbColorPtr = + ##define XkbShapeDoodadColor(g,d) (&(g)->colors[(d)->color_ndx]) + result = addr((g.colors[ze(d.color_ndx)])) + +proc XkbShapeDoodadShape(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr): PXkbShapePtr = + ##define XkbShapeDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx]) + result = addr(g.shapes[ze(d.shape_ndx)]) + +proc XkbSetShapeDoodadColor(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr, + c: PXkbColorPtr) = + ##define XkbSetShapeDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0]) + d.color_ndx = toU16((cast[TAddress](c) - cast[TAddress](addr(g.colors[0]))) div sizeof(TXkbColorRec)) + +proc XkbSetShapeDoodadShape(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr, + s: PXkbShapePtr) = + ##define XkbSetShapeDoodadShape(g,d,s) ((d)->shape_ndx= (s)-&(g)->shapes[0]) + d.shape_ndx = toU16((cast[TAddress](s) - cast[TAddress](addr(g.shapes[0]))) div sizeof(TXkbShapeRec)) + +proc XkbTextDoodadColor(g: PXkbGeometryPtr, d: PXkbTextDoodadPtr): PXkbColorPtr = + ##define XkbTextDoodadColor(g,d) (&(g)->colors[(d)->color_ndx]) + result = addr(g.colors[ze(d.color_ndx)]) + +proc XkbSetTextDoodadColor(g: PXkbGeometryPtr, d: PXkbTextDoodadPtr, + c: PXkbColorPtr) = + ##define XkbSetTextDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0]) + d.color_ndx = toU16((cast[TAddress](c) - cast[TAddress](addr(g.colors[0]))) div sizeof(TXkbColorRec)) + +proc XkbIndicatorDoodadShape(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbShapeDoodadPtr = + ##define XkbIndicatorDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx]) + result = cast[PXkbShapeDoodadPtr](addr(g.shapes[ze(d.shape_ndx)])) + +proc XkbIndicatorDoodadOnColor(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbColorPtr = + ##define XkbIndicatorDoodadOnColor(g,d) (&(g)->colors[(d)->on_color_ndx]) + result = addr(g.colors[ze(d.on_color_ndx)]) + +proc XkbIndicatorDoodadOffColor(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbColorPtr = + ##define XkbIndicatorDoodadOffColor(g,d) (&(g)->colors[(d)->off_color_ndx]) + result = addr(g.colors[ze(d.off_color_ndx)]) + +proc XkbSetIndicatorDoodadOnColor(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr, + c: PXkbColorPtr) = + ##define XkbSetIndicatorDoodadOnColor(g,d,c) ((d)->on_color_ndx= (c)-&(g)->colors[0]) + d.on_color_ndx = toU16((cast[TAddress](c) - cast[TAddress](addr(g.colors[0]))) div sizeof(TXkbColorRec)) + +proc XkbSetIndicatorDoodadOffColor(g: PXkbGeometryPtr, + d: PXkbIndicatorDoodadPtr, c: PXkbColorPtr) = + ##define XkbSetIndicatorDoodadOffColor(g,d,c) ((d)->off_color_ndx= (c)-&(g)->colors[0]) + d.off_color_ndx = toU16((cast[TAddress](c) - cast[TAddress](addr(g.colors[0]))) div sizeof(TxkbColorRec)) + +proc XkbSetIndicatorDoodadShape(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr, + s: PXkbShapeDoodadPtr) = + ##define XkbSetIndicatorDoodadShape(g,d,s) ((d)->shape_ndx= (s)-&(g)->shapes[0]) + d.shape_ndx = toU16((cast[TAddress](s) - (cast[TAddress](addr(g.shapes[0])))) div sizeof(TXkbShapeRec)) + +proc XkbLogoDoodadColor(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr): PXkbColorPtr = + ##define XkbLogoDoodadColor(g,d) (&(g)->colors[(d)->color_ndx]) + result = addr(g.colors[ze(d.color_ndx)]) + +proc XkbLogoDoodadShape(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr): PXkbShapeDoodadPtr = + ##define XkbLogoDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx]) + result = cast[PXkbShapeDoodadPtr](addr(g.shapes[ze(d.shape_ndx)])) + +proc XkbSetLogoDoodadColor(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr, + c: PXkbColorPtr) = + ##define XkbSetLogoDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0]) + d.color_ndx = toU16((cast[TAddress](c) - cast[TAddress](addr(g.colors[0]))) div sizeof(TXkbColorRec)) + +proc XkbSetLogoDoodadShape(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr, + s: PXkbShapeDoodadPtr) = + ##define XkbSetLogoDoodadShape(g,d,s) ((d)->shape_ndx= (s)-&(g)->shapes[0]) + d.shape_ndx = toU16((cast[TAddress](s) - cast[TAddress](addr(g.shapes[0]))) div sizeof(TXkbShapeRec)) + +proc XkbKeyShape(g: PXkbGeometryPtr, k: PXkbKeyPtr): PXkbShapeDoodadPtr = + ##define XkbKeyShape(g,k) (&(g)->shapes[(k)->shape_ndx]) + result = cast[PXkbShapeDoodadPtr](addr(g.shapes[ze(k.shape_ndx)])) + +proc XkbKeyColor(g: PXkbGeometryPtr, k: PXkbKeyPtr): PXkbColorPtr = + ##define XkbKeyColor(g,k) (&(g)->colors[(k)->color_ndx]) + result = addr(g.colors[ze(k.color_ndx)]) + +proc XkbSetKeyShape(g: PXkbGeometryPtr, k: PXkbKeyPtr, s: PXkbShapeDoodadPtr) = + ##define XkbSetKeyShape(g,k,s) ((k)->shape_ndx= (s)-&(g)->shapes[0]) + k.shape_ndx = toU8((cast[TAddress](s) - cast[TAddress](addr(g.shapes[0]))) div sizeof(TXkbShapeRec)) + +proc XkbSetKeyColor(g: PXkbGeometryPtr, k: PXkbKeyPtr, c: PXkbColorPtr) = + ##define XkbSetKeyColor(g,k,c) ((k)->color_ndx= (c)-&(g)->colors[0]) + k.color_ndx = toU8((cast[TAddress](c) - cast[TAddress](addr(g.colors[0]))) div sizeof(TxkbColorRec)) + +proc XkbGeomColorIndex(g: PXkbGeometryPtr, c: PXkbColorPtr): int32 = + ##define XkbGeomColorIndex(g,c) ((int)((c)-&(g)->colors[0])) + result = toU16((cast[TAddress](c) - (cast[TAddress](addr(g.colors[0])))) div sizeof(TxkbColorRec)) diff --git a/tests/deps/x11-1.0/xkblib.nim b/tests/deps/x11-1.0/xkblib.nim new file mode 100644 index 000000000..530ebbac5 --- /dev/null +++ b/tests/deps/x11-1.0/xkblib.nim @@ -0,0 +1,661 @@ +# $Xorg: XKBlib.h,v 1.6 2000/08/17 19:45:03 cpqbld Exp $ +#************************************************************ +#Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. +# +#Permission to use, copy, modify, and distribute this +#software and its documentation for any purpose and without +#fee is hereby granted, provided that the above copyright +#notice appear in all copies and that both that copyright +#notice and this permission notice appear in supporting +#documentation, and that the name of Silicon Graphics not be +#used in advertising or publicity pertaining to distribution +#of the software without specific prior written permission. +#Silicon Graphics makes no representation about the suitability +#of this software for any purpose. It is provided "as is" +#without any express or implied warranty. +# +#SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +#SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +#AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +#GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +#DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING `from` LOSS OF USE, +#DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +#OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +#THE USE OR PERFORMANCE OF THIS SOFTWARE. +# +#********************************************************/ +# $XFree86: xc/lib/X11/XKBlib.h,v 3.3 2001/08/01 00:44:38 tsi Exp $ +# +# Pascal Convertion was made by Ido Kannner - kanerido@actcom.net.il +# +#Thanks: +# I want to thanks to oliebol for putting up with all of the problems that was found +# while translating this code. ;) +# +# I want to thanks #fpc channel in freenode irc, for helping me, and to put up with my +# wierd questions ;) +# +# Thanks for mmc in #xlib on freenode irc And so for the channel itself for the helping me to +# understanding some of the problems I had converting this headers and pointing me to resources +# that helped translating this headers. +# +# Ido +# +#History: +# 2004/10/15 - Fixed a bug of accessing second based records by removing "paced record" and +# chnaged it to "reocrd" only. +# 2004/10/10 - Added to TXkbGetAtomNameFunc and TXkbInternAtomFunc the cdecl call. +# 2004/10/06 - 09 - Convertion `from` the c header of XKBlib.h +# +# + +import + X, Xlib, XKB + + +include "x11pragma.nim" + + +type + PXkbAnyEvent* = ptr TXkbAnyEvent + TXkbAnyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: TTime # milliseconds; + xkb_type*: int16 # XKB event minor code + device*: int16 # device ID + + +type + PXkbNewKeyboardNotifyEvent* = ptr TXkbNewKeyboardNotifyEvent + TXkbNewKeyboardNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: TTime # milliseconds + xkb_type*: int16 # XkbNewKeyboardNotify + device*: int16 # device ID + old_device*: int16 # device ID of previous keyboard + min_key_code*: int16 # minimum key code + max_key_code*: int16 # maximum key code + old_min_key_code*: int16 # min key code of previous kbd + old_max_key_code*: int16 # max key code of previous kbd + changed*: int16 # changed aspects of the keyboard + req_major*: int8 # major and minor opcode of req + req_minor*: int8 # that caused change, if applicable + + +type + PXkbMapNotifyEvent* = ptr TXkbMapNotifyEvent + TXkbMapNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request + display*: PDisplay # Display the event was read `from` + time*: TTime # milliseconds + xkb_type*: int16 # XkbMapNotify + device*: int16 # device ID + changed*: int16 # fields which have been changed + flags*: int16 # reserved + first_type*: int16 # first changed key type + num_types*: int16 # number of changed key types + min_key_code*: TKeyCode + max_key_code*: TKeyCode + first_key_sym*: TKeyCode + first_key_act*: TKeyCode + first_key_behavior*: TKeyCode + first_key_explicit*: TKeyCode + first_modmap_key*: TKeyCode + first_vmodmap_key*: TKeyCode + num_key_syms*: int16 + num_key_acts*: int16 + num_key_behaviors*: int16 + num_key_explicit*: int16 + num_modmap_keys*: int16 + num_vmodmap_keys*: int16 + vmods*: int16 # mask of changed virtual mods + + +type + PXkbStateNotifyEvent* = ptr TXkbStateNotifyEvent + TXkbStateNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: TTime # milliseconds + xkb_type*: int16 # XkbStateNotify + device*: int16 # device ID + changed*: int16 # mask of changed state components + group*: int16 # keyboard group + base_group*: int16 # base keyboard group + latched_group*: int16 # latched keyboard group + locked_group*: int16 # locked keyboard group + mods*: int16 # modifier state + base_mods*: int16 # base modifier state + latched_mods*: int16 # latched modifiers + locked_mods*: int16 # locked modifiers + compat_state*: int16 # compatibility state + grab_mods*: int8 # mods used for grabs + compat_grab_mods*: int8 # grab mods for non-XKB clients + lookup_mods*: int8 # mods sent to clients + compat_lookup_mods*: int8 # mods sent to non-XKB clients + ptr_buttons*: int16 # pointer button state + keycode*: TKeyCode # keycode that caused the change + event_type*: int8 # KeyPress or KeyRelease + req_major*: int8 # Major opcode of request + req_minor*: int8 # Minor opcode of request + + +type + PXkbControlsNotifyEvent* = ptr TXkbControlsNotifyEvent + TXkbControlsNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: TTime # milliseconds + xkb_type*: int16 # XkbControlsNotify + device*: int16 # device ID + changed_ctrls*: int16 # controls with changed sub-values + enabled_ctrls*: int16 # controls currently enabled + enabled_ctrl_changes*: int16 # controls just {en,dis}abled + num_groups*: int16 # total groups on keyboard + keycode*: TKeyCode # key that caused change or 0 + event_type*: int8 # type of event that caused change + req_major*: int8 # if keycode==0, major and minor + req_minor*: int8 # opcode of req that caused change + + +type + PXkbIndicatorNotifyEvent* = ptr TXkbIndicatorNotifyEvent + TXkbIndicatorNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: TTime # milliseconds + xkb_type*: int16 # XkbIndicatorNotify + device*: int16 # device + changed*: int16 # indicators with new state or map + state*: int16 # current state of all indicators + + +type + PXkbNamesNotifyEvent* = ptr TXkbNamesNotifyEvent + TXkbNamesNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: TTime # milliseconds + xkb_type*: int16 # XkbNamesNotify + device*: int16 # device ID + changed*: int32 # names that have changed + first_type*: int16 # first key type with new name + num_types*: int16 # number of key types with new names + first_lvl*: int16 # first key type new new level names + num_lvls*: int16 # # of key types w/new level names + num_aliases*: int16 # total number of key aliases + num_radio_groups*: int16 # total number of radio groups + changed_vmods*: int16 # virtual modifiers with new names + changed_groups*: int16 # groups with new names + changed_indicators*: int16 # indicators with new names + first_key*: int16 # first key with new name + num_keys*: int16 # number of keys with new names + + +type + PXkbCompatMapNotifyEvent* = ptr TXkbCompatMapNotifyEvent + TXkbCompatMapNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: TTime # milliseconds + xkb_type*: int16 # XkbCompatMapNotify + device*: int16 # device ID + changed_groups*: int16 # groups with new compat maps + first_si*: int16 # first new symbol interp + num_si*: int16 # number of new symbol interps + num_total_si*: int16 # total # of symbol interps + + +type + PXkbBellNotifyEvent* = ptr TXkbBellNotifyEvent + TXkbBellNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: TTime # milliseconds + xkb_type*: int16 # XkbBellNotify + device*: int16 # device ID + percent*: int16 # requested volume as a % of maximum + pitch*: int16 # requested pitch in Hz + duration*: int16 # requested duration in useconds + bell_class*: int16 # (input extension) feedback class + bell_id*: int16 # (input extension) ID of feedback + name*: TAtom # "name" of requested bell + window*: TWindow # window associated with event + event_only*: bool # "event only" requested + + +type + PXkbActionMessageEvent* = ptr TXkbActionMessageEvent + TXkbActionMessageEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: TTime # milliseconds + xkb_type*: int16 # XkbActionMessage + device*: int16 # device ID + keycode*: TKeyCode # key that generated the event + press*: bool # true if act caused by key press + key_event_follows*: bool # true if key event also generated + group*: int16 # effective group + mods*: int16 # effective mods + message*: array[0..XkbActionMessageLength, char] # message -- leave space for NUL + + +type + PXkbAccessXNotifyEvent* = ptr TXkbAccessXNotifyEvent + TXkbAccessXNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: TTime # milliseconds + xkb_type*: int16 # XkbAccessXNotify + device*: int16 # device ID + detail*: int16 # XkbAXN_* + keycode*: int16 # key of event + sk_delay*: int16 # current slow keys delay + debounce_delay*: int16 # current debounce delay + + +type + PXkbExtensionDeviceNotifyEvent* = ptr TXkbExtensionDeviceNotifyEvent + TXkbExtensionDeviceNotifyEvent*{.final.} = object + theType*: int16 # XkbAnyEvent + serial*: int32 # of last req processed by server + send_event*: bool # is this `from` a SendEvent request? + display*: PDisplay # Display the event was read `from` + time*: TTime # milliseconds + xkb_type*: int16 # XkbExtensionDeviceNotify + device*: int16 # device ID + reason*: int16 # reason for the event + supported*: int16 # mask of supported features + unsupported*: int16 # mask of unsupported features + # that some app tried to use + first_btn*: int16 # first button that changed + num_btns*: int16 # range of buttons changed + leds_defined*: int16 # indicators with names or maps + led_state*: int16 # current state of the indicators + led_class*: int16 # feedback class for led changes + led_id*: int16 # feedback id for led changes + + +type + PXkbEvent* = ptr TXkbEvent + TXkbEvent*{.final.} = object + theType*: int16 + any*: TXkbAnyEvent + new_kbd*: TXkbNewKeyboardNotifyEvent + map*: TXkbMapNotifyEvent + state*: TXkbStateNotifyEvent + ctrls*: TXkbControlsNotifyEvent + indicators*: TXkbIndicatorNotifyEvent + names*: TXkbNamesNotifyEvent + compat*: TXkbCompatMapNotifyEvent + bell*: TXkbBellNotifyEvent + message*: TXkbActionMessageEvent + accessx*: TXkbAccessXNotifyEvent + device*: TXkbExtensionDeviceNotifyEvent + core*: TXEvent + + +type + PXkbKbdDpyStatePtr* = ptr TXkbKbdDpyStateRec + TXkbKbdDpyStateRec*{.final.} = object # XkbOpenDisplay error codes + +const + XkbOD_Success* = 0 + XkbOD_BadLibraryVersion* = 1 + XkbOD_ConnectionRefused* = 2 + XkbOD_NonXkbServer* = 3 + XkbOD_BadServerVersion* = 4 # Values for XlibFlags + +const + XkbLC_ForceLatin1Lookup* = 1 shl 0 + XkbLC_ConsumeLookupMods* = 1 shl 1 + XkbLC_AlwaysConsumeShiftAndLock* = 1 shl 2 + XkbLC_IgnoreNewKeyboards* = 1 shl 3 + XkbLC_ControlFallback* = 1 shl 4 + XkbLC_ConsumeKeysOnComposeFail* = 1 shl 29 + XkbLC_ComposeLED* = 1 shl 30 + XkbLC_BeepOnComposeFail* = 1 shl 31 + XkbLC_AllComposeControls* = 0xC0000000 + XkbLC_AllControls* = 0xC000001F + +proc XkbIgnoreExtension*(ignore: bool): bool{.libx11c, + importc: "XkbIgnoreExtension".} +proc XkbOpenDisplay*(name: cstring, ev_rtrn, err_rtrn, major_rtrn, minor_rtrn, + reason: ptr int16): PDisplay{.libx11c, importc: "XkbOpenDisplay".} +proc XkbQueryExtension*(dpy: PDisplay, opcodeReturn, eventBaseReturn, + errorBaseReturn, majorRtrn, minorRtrn: ptr int16): bool{. + libx11c, importc: "XkbQueryExtension".} +proc XkbUseExtension*(dpy: PDisplay, major_rtrn, minor_rtrn: ptr int16): bool{. + libx11c, importc: "XkbUseExtension".} +proc XkbLibraryVersion*(libMajorRtrn, libMinorRtrn: ptr int16): bool{.libx11c, importc: "XkbLibraryVersion".} +proc XkbSetXlibControls*(dpy: PDisplay, affect, values: int16): int16{.libx11c, importc: "XkbSetXlibControls".} +proc XkbGetXlibControls*(dpy: PDisplay): int16{.libx11c, + importc: "XkbGetXlibControls".} +type + TXkbInternAtomFunc* = proc (dpy: PDisplay, name: cstring, only_if_exists: bool): TAtom{. + cdecl.} + +type + TXkbGetAtomNameFunc* = proc (dpy: PDisplay, atom: TAtom): cstring{.cdecl.} + +proc XkbSetAtomFuncs*(getAtom: TXkbInternAtomFunc, getName: TXkbGetAtomNameFunc){. + libx11c, importc: "XkbSetAtomFuncs".} +proc XkbKeycodeToKeysym*(dpy: PDisplay, kc: TKeyCode, group, level: int16): TKeySym{. + libx11c, importc: "XkbKeycodeToKeysym".} +proc XkbKeysymToModifiers*(dpy: PDisplay, ks: TKeySym): int16{.libx11c, importc: "XkbKeysymToModifiers".} +proc XkbLookupKeySym*(dpy: PDisplay, keycode: TKeyCode, + modifiers, modifiers_return: int16, keysym_return: PKeySym): bool{. + libx11c, importc: "XkbLookupKeySym".} +proc XkbLookupKeyBinding*(dpy: PDisplay, sym_rtrn: TKeySym, mods: int16, + buffer: cstring, nbytes: int16, extra_rtrn: ptr int16): int16{. + libx11c, importc: "XkbLookupKeyBinding".} +proc XkbTranslateKeyCode*(xkb: PXkbDescPtr, keycode: TKeyCode, + modifiers, modifiers_return: int16, + keysym_return: PKeySym): bool{.libx11c, + importc: "XkbTranslateKeyCode".} +proc XkbTranslateKeySym*(dpy: PDisplay, sym_return: TKeySym, modifiers: int16, + buffer: cstring, nbytes: int16, extra_rtrn: ptr int16): int16{. + libx11c, importc: "XkbTranslateKeySym".} +proc XkbSetAutoRepeatRate*(dpy: PDisplay, deviceSpec, delay, interval: int16): bool{. + libx11c, importc: "XkbSetAutoRepeatRate".} +proc XkbGetAutoRepeatRate*(dpy: PDisplay, deviceSpec: int16, + delayRtrn, intervalRtrn: PWord): bool{.libx11c, importc: "XkbGetAutoRepeatRate".} +proc XkbChangeEnabledControls*(dpy: PDisplay, deviceSpec, affect, values: int16): bool{. + libx11c, importc: "XkbChangeEnabledControls".} +proc XkbDeviceBell*(dpy: PDisplay, win: TWindow, + deviceSpec, bellClass, bellID, percent: int16, name: TAtom): bool{. + libx11c, importc: "XkbDeviceBell".} +proc XkbForceDeviceBell*(dpy: PDisplay, + deviceSpec, bellClass, bellID, percent: int16): bool{. + libx11c, importc: "XkbForceDeviceBell".} +proc XkbDeviceBellEvent*(dpy: PDisplay, win: TWindow, + deviceSpec, bellClass, bellID, percent: int16, + name: TAtom): bool{.libx11c, + importc: "XkbDeviceBellEvent".} +proc XkbBell*(dpy: PDisplay, win: TWindow, percent: int16, name: TAtom): bool{. + libx11c, importc: "XkbBell".} +proc XkbForceBell*(dpy: PDisplay, percent: int16): bool{.libx11c, + importc: "XkbForceBell".} +proc XkbBellEvent*(dpy: PDisplay, win: TWindow, percent: int16, name: TAtom): bool{. + libx11c, importc: "XkbBellEvent".} +proc XkbSelectEvents*(dpy: PDisplay, deviceID, affect, values: int16): bool{. + libx11c, importc: "XkbSelectEvents".} +proc XkbSelectEventDetails*(dpy: PDisplay, deviceID, eventType: int16, + affect, details: int32): bool{.libx11c, importc: "XkbSelectEventDetails".} +proc XkbNoteMapChanges*(old: PXkbMapChangesPtr, new: PXkbMapNotifyEvent, + wanted: int16){.libx11c, + importc: "XkbNoteMapChanges".} +proc XkbNoteNameChanges*(old: PXkbNameChangesPtr, new: PXkbNamesNotifyEvent, + wanted: int16){.libx11c, + importc: "XkbNoteNameChanges".} +proc XkbGetIndicatorState*(dpy: PDisplay, deviceSpec: int16, pStateRtrn: PWord): TStatus{. + libx11c, importc: "XkbGetIndicatorState".} +proc XkbGetDeviceIndicatorState*(dpy: PDisplay, + deviceSpec, ledClass, ledID: int16, + pStateRtrn: PWord): TStatus{.libx11c, importc: "XkbGetDeviceIndicatorState".} +proc XkbGetIndicatorMap*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): TStatus{. + libx11c, importc: "XkbGetIndicatorMap".} +proc XkbSetIndicatorMap*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): bool{. + libx11c, importc: "XkbSetIndicatorMap".} +proc XkbNoteIndicatorMapChanges*(o, n: PXkbIndicatorChangesPtr, w: int16) +proc XkbNoteIndicatorStateChanges*(o, n: PXkbIndicatorChangesPtr, w: int16) +proc XkbGetIndicatorMapChanges*(d: PDisplay, x: PXkbDescPtr, + c: PXkbIndicatorChangesPtr): TStatus +proc XkbChangeIndicatorMaps*(d: PDisplay, x: PXkbDescPtr, + c: PXkbIndicatorChangesPtr): bool +proc XkbGetNamedIndicator*(dpy: PDisplay, name: TAtom, pNdxRtrn: ptr int16, + pStateRtrn: ptr bool, pMapRtrn: PXkbIndicatorMapPtr, + pRealRtrn: ptr bool): bool{.libx11c, + importc: "XkbGetNamedIndicator".} +proc XkbGetNamedDeviceIndicator*(dpy: PDisplay, + deviceSpec, ledClass, ledID: int16, + name: TAtom, pNdxRtrn: ptr int16, + pStateRtrn: ptr bool, + pMapRtrn: PXkbIndicatorMapPtr, + pRealRtrn: ptr bool): bool{.libx11c, importc: "XkbGetNamedDeviceIndicator".} +proc XkbSetNamedIndicator*(dpy: PDisplay, name: TAtom, + changeState, state, createNewMap: bool, + pMap: PXkbIndicatorMapPtr): bool{.libx11c, importc: "XkbSetNamedIndicator".} +proc XkbSetNamedDeviceIndicator*(dpy: PDisplay, + deviceSpec, ledClass, ledID: int16, + name: TAtom, + changeState, state, createNewMap: bool, + pMap: PXkbIndicatorMapPtr): bool{.libx11c, importc: "XkbSetNamedDeviceIndicator".} +proc XkbLockModifiers*(dpy: PDisplay, deviceSpec, affect, values: int16): bool{. + libx11c, importc: "XkbLockModifiers".} +proc XkbLatchModifiers*(dpy: PDisplay, deviceSpec, affect, values: int16): bool{. + libx11c, importc: "XkbLatchModifiers".} +proc XkbLockGroup*(dpy: PDisplay, deviceSpec, group: int16): bool{.libx11c, importc: "XkbLockGroup".} +proc XkbLatchGroup*(dpy: PDisplay, deviceSpec, group: int16): bool{.libx11c, importc: "XkbLatchGroup".} +proc XkbSetServerInternalMods*(dpy: PDisplay, deviceSpec, affectReal, + realValues, affectVirtual, virtualValues: int16): bool{.libx11c, importc: "XkbSetServerInternalMods".} +proc XkbSetIgnoreLockMods*(dpy: PDisplay, deviceSpec, affectReal, realValues, + affectVirtual, virtualValues: int16): bool{.libx11c, + importc: "XkbSetIgnoreLockMods".} +proc XkbVirtualModsToReal*(dpy: PDisplay, virtual_mask: int16, mask_rtrn: PWord): bool{. + libx11c, importc: "XkbVirtualModsToReal".} +proc XkbComputeEffectiveMap*(xkb: PXkbDescPtr, theType: PXkbKeyTypePtr, + map_rtrn: PByte): bool{.libx11c, + importc: "XkbComputeEffectiveMap".} +proc XkbInitCanonicalKeyTypes*(xkb: PXkbDescPtr, which: int16, keypadVMod: int16): TStatus{. + libx11c, importc: "XkbInitCanonicalKeyTypes".} +proc XkbAllocKeyboard*(): PXkbDescPtr{.libx11c, + importc: "XkbAllocKeyboard".} +proc XkbFreeKeyboard*(xkb: PXkbDescPtr, which: int16, freeDesc: bool){.libx11c, importc: "XkbFreeKeyboard".} +proc XkbAllocClientMap*(xkb: PXkbDescPtr, which, nTypes: int16): TStatus{.libx11c, importc: "XkbAllocClientMap".} +proc XkbAllocServerMap*(xkb: PXkbDescPtr, which, nActions: int16): TStatus{. + libx11c, importc: "XkbAllocServerMap".} +proc XkbFreeClientMap*(xkb: PXkbDescPtr, what: int16, freeMap: bool){.libx11c, importc: "XkbFreeClientMap".} +proc XkbFreeServerMap*(xkb: PXkbDescPtr, what: int16, freeMap: bool){.libx11c, importc: "XkbFreeServerMap".} +proc XkbAddKeyType*(xkb: PXkbDescPtr, name: TAtom, map_count: int16, + want_preserve: bool, num_lvls: int16): PXkbKeyTypePtr{. + libx11c, importc: "XkbAddKeyType".} +proc XkbAllocIndicatorMaps*(xkb: PXkbDescPtr): TStatus{.libx11c, + importc: "XkbAllocIndicatorMaps".} +proc XkbFreeIndicatorMaps*(xkb: PXkbDescPtr){.libx11c, + importc: "XkbFreeIndicatorMaps".} +proc XkbGetMap*(dpy: PDisplay, which, deviceSpec: int16): PXkbDescPtr{.libx11c, importc: "XkbGetMap".} +proc XkbGetUpdatedMap*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): TStatus{. + libx11c, importc: "XkbGetUpdatedMap".} +proc XkbGetMapChanges*(dpy: PDisplay, xkb: PXkbDescPtr, + changes: PXkbMapChangesPtr): TStatus{.libx11c, importc: "XkbGetMapChanges".} +proc XkbRefreshKeyboardMapping*(event: PXkbMapNotifyEvent): TStatus{.libx11c, importc: "XkbRefreshKeyboardMapping".} +proc XkbGetKeyTypes*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): TStatus{. + libx11c, importc: "XkbGetKeyTypes".} +proc XkbGetKeySyms*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): TStatus{. + libx11c, importc: "XkbGetKeySyms".} +proc XkbGetKeyActions*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): TStatus{. + libx11c, importc: "XkbGetKeyActions".} +proc XkbGetKeyBehaviors*(dpy: PDisplay, firstKey, nKeys: int16, + desc: PXkbDescPtr): TStatus{.libx11c, + importc: "XkbGetKeyBehaviors".} +proc XkbGetVirtualMods*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): TStatus{. + libx11c, importc: "XkbGetVirtualMods".} +proc XkbGetKeyExplicitComponents*(dpy: PDisplay, firstKey, nKeys: int16, + desc: PXkbDescPtr): TStatus{.libx11c, importc: "XkbGetKeyExplicitComponents".} +proc XkbGetKeyModifierMap*(dpy: PDisplay, firstKey, nKeys: int16, + desc: PXkbDescPtr): TStatus{.libx11c, + importc: "XkbGetKeyModifierMap".} +proc XkbAllocControls*(xkb: PXkbDescPtr, which: int16): TStatus{.libx11c, importc: "XkbAllocControls".} +proc XkbFreeControls*(xkb: PXkbDescPtr, which: int16, freeMap: bool){.libx11c, importc: "XkbFreeControls".} +proc XkbGetControls*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): TStatus{. + libx11c, importc: "XkbGetControls".} +proc XkbSetControls*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): bool{. + libx11c, importc: "XkbSetControls".} +proc XkbNoteControlsChanges*(old: PXkbControlsChangesPtr, + new: PXkbControlsNotifyEvent, wanted: int16){. + libx11c, importc: "XkbNoteControlsChanges".} +proc XkbGetControlsChanges*(d: PDisplay, x: PXkbDescPtr, + c: PXkbControlsChangesPtr): TStatus +proc XkbChangeControls*(d: PDisplay, x: PXkbDescPtr, c: PXkbControlsChangesPtr): bool +proc XkbAllocCompatMap*(xkb: PXkbDescPtr, which, nInterpret: int16): TStatus{. + libx11c, importc: "XkbAllocCompatMap".} +proc XkbFreeCompatMap*(xkib: PXkbDescPtr, which: int16, freeMap: bool){.libx11c, importc: "XkbFreeCompatMap".} +proc XkbGetCompatMap*(dpy: PDisplay, which: int16, xkb: PXkbDescPtr): TStatus{. + libx11c, importc: "XkbGetCompatMap".} +proc XkbSetCompatMap*(dpy: PDisplay, which: int16, xkb: PXkbDescPtr, + updateActions: bool): bool{.libx11c, + importc: "XkbSetCompatMap".} +proc XkbAddSymInterpret*(xkb: PXkbDescPtr, si: PXkbSymInterpretPtr, + updateMap: bool, changes: PXkbChangesPtr): PXkbSymInterpretPtr{. + libx11c, importc: "XkbAddSymInterpret".} +proc XkbAllocNames*(xkb: PXkbDescPtr, which: int16, + nTotalRG, nTotalAliases: int16): TStatus{.libx11c, importc: "XkbAllocNames".} +proc XkbGetNames*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): TStatus{. + libx11c, importc: "XkbGetNames".} +proc XkbSetNames*(dpy: PDisplay, which, firstType, nTypes: int16, + desc: PXkbDescPtr): bool{.libx11c, + importc: "XkbSetNames".} +proc XkbChangeNames*(dpy: PDisplay, xkb: PXkbDescPtr, + changes: PXkbNameChangesPtr): bool{.libx11c, + importc: "XkbChangeNames".} +proc XkbFreeNames*(xkb: PXkbDescPtr, which: int16, freeMap: bool){.libx11c, importc: "XkbFreeNames".} +proc XkbGetState*(dpy: PDisplay, deviceSpec: int16, rtrnState: PXkbStatePtr): TStatus{. + libx11c, importc: "XkbGetState".} +proc XkbSetMap*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): bool{.libx11c, importc: "XkbSetMap".} +proc XkbChangeMap*(dpy: PDisplay, desc: PXkbDescPtr, changes: PXkbMapChangesPtr): bool{. + libx11c, importc: "XkbChangeMap".} +proc XkbSetDetectableAutoRepeat*(dpy: PDisplay, detectable: bool, + supported: ptr bool): bool{.libx11c, importc: "XkbSetDetectableAutoRepeat".} +proc XkbGetDetectableAutoRepeat*(dpy: PDisplay, supported: ptr bool): bool{. + libx11c, importc: "XkbGetDetectableAutoRepeat".} +proc XkbSetAutoResetControls*(dpy: PDisplay, changes: int16, + auto_ctrls, auto_values: PWord): bool{.libx11c, importc: "XkbSetAutoResetControls".} +proc XkbGetAutoResetControls*(dpy: PDisplay, auto_ctrls, auto_ctrl_values: PWord): bool{. + libx11c, importc: "XkbGetAutoResetControls".} +proc XkbSetPerClientControls*(dpy: PDisplay, change: int16, values: PWord): bool{. + libx11c, importc: "XkbSetPerClientControls".} +proc XkbGetPerClientControls*(dpy: PDisplay, ctrls: PWord): bool{.libx11c, importc: "XkbGetPerClientControls".} +proc XkbCopyKeyType*(`from`, into: PXkbKeyTypePtr): TStatus{.libx11c, importc: "XkbCopyKeyType".} +proc XkbCopyKeyTypes*(`from`, into: PXkbKeyTypePtr, num_types: int16): TStatus{. + libx11c, importc: "XkbCopyKeyTypes".} +proc XkbResizeKeyType*(xkb: PXkbDescPtr, type_ndx, map_count: int16, + want_preserve: bool, new_num_lvls: int16): TStatus{. + libx11c, importc: "XkbResizeKeyType".} +proc XkbResizeKeySyms*(desc: PXkbDescPtr, forKey, symsNeeded: int16): PKeySym{. + libx11c, importc: "XkbResizeKeySyms".} +proc XkbResizeKeyActions*(desc: PXkbDescPtr, forKey, actsNeeded: int16): PXkbAction{. + libx11c, importc: "XkbResizeKeyActions".} +proc XkbChangeTypesOfKey*(xkb: PXkbDescPtr, key, num_groups: int16, + groups: int16, newTypes: ptr int16, + pChanges: PXkbMapChangesPtr): TStatus{.libx11c, importc: "XkbChangeTypesOfKey".} + +proc XkbListComponents*(dpy: PDisplay, deviceSpec: int16, + ptrns: PXkbComponentNamesPtr, max_inout: ptr int16): PXkbComponentListPtr{. + libx11c, importc: "XkbListComponents".} +proc XkbFreeComponentList*(list: PXkbComponentListPtr){.libx11c, + importc: "XkbFreeComponentList".} +proc XkbGetKeyboard*(dpy: PDisplay, which, deviceSpec: int16): PXkbDescPtr{. + libx11c, importc: "XkbGetKeyboard".} +proc XkbGetKeyboardByName*(dpy: PDisplay, deviceSpec: int16, + names: PXkbComponentNamesPtr, want, need: int16, + load: bool): PXkbDescPtr{.libx11c, + importc: "XkbGetKeyboardByName".} + +proc XkbKeyTypesForCoreSymbols*(xkb: PXkbDescPtr, + map_width: int16, # keyboard device + core_syms: PKeySym, # always mapWidth symbols + protected: int16, # explicit key types + types_inout: ptr int16, # always four type indices + xkb_syms_rtrn: PKeySym): int16{.libx11c, importc: "XkbKeyTypesForCoreSymbols".} + # must have enough space +proc XkbApplyCompatMapToKey*(xkb: PXkbDescPtr, + key: TKeyCode, # key to be updated + changes: PXkbChangesPtr): bool{.libx11c, importc: "XkbApplyCompatMapToKey".} + # resulting changes to map +proc XkbUpdateMapFromCore*(xkb: PXkbDescPtr, + first_key: TKeyCode, # first changed key + num_keys, + map_width: int16, + core_keysyms: PKeySym, # symbols `from` core keymap + changes: PXkbChangesPtr): bool{.libx11c, importc: "XkbUpdateMapFromCore".} + +proc XkbAddDeviceLedInfo*(devi: PXkbDeviceInfoPtr, ledClass, ledId: int16): PXkbDeviceLedInfoPtr{. + libx11c, importc: "XkbAddDeviceLedInfo".} +proc XkbResizeDeviceButtonActions*(devi: PXkbDeviceInfoPtr, newTotal: int16): TStatus{. + libx11c, importc: "XkbResizeDeviceButtonActions".} +proc XkbAllocDeviceInfo*(deviceSpec, nButtons, szLeds: int16): PXkbDeviceInfoPtr{. + libx11c, importc: "XkbAllocDeviceInfo".} +proc XkbFreeDeviceInfo*(devi: PXkbDeviceInfoPtr, which: int16, freeDevI: bool){. + libx11c, importc: "XkbFreeDeviceInfo".} +proc XkbNoteDeviceChanges*(old: PXkbDeviceChangesPtr, + new: PXkbExtensionDeviceNotifyEvent, wanted: int16){. + libx11c, importc: "XkbNoteDeviceChanges".} +proc XkbGetDeviceInfo*(dpy: PDisplay, which, deviceSpec, ledClass, ledID: int16): PXkbDeviceInfoPtr{. + libx11c, importc: "XkbGetDeviceInfo".} +proc XkbGetDeviceInfoChanges*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, + changes: PXkbDeviceChangesPtr): TStatus{.libx11c, importc: "XkbGetDeviceInfoChanges".} +proc XkbGetDeviceButtonActions*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, + all: bool, first, nBtns: int16): TStatus{.libx11c, importc: "XkbGetDeviceButtonActions".} +proc XkbGetDeviceLedInfo*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, + ledClass, ledId, which: int16): TStatus{.libx11c, importc: "XkbGetDeviceLedInfo".} +proc XkbSetDeviceInfo*(dpy: PDisplay, which: int16, devi: PXkbDeviceInfoPtr): bool{. + libx11c, importc: "XkbSetDeviceInfo".} +proc XkbChangeDeviceInfo*(dpy: PDisplay, desc: PXkbDeviceInfoPtr, + changes: PXkbDeviceChangesPtr): bool{.libx11c, importc: "XkbChangeDeviceInfo".} +proc XkbSetDeviceLedInfo*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, + ledClass, ledID, which: int16): bool{.libx11c, importc: "XkbSetDeviceLedInfo".} +proc XkbSetDeviceButtonActions*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, + first, nBtns: int16): bool{.libx11c, importc: "XkbSetDeviceButtonActions".} + +proc XkbToControl*(c: int8): int8{.libx11c, + importc: "XkbToControl".} + +proc XkbSetDebuggingFlags*(dpy: PDisplay, mask, flags: int16, msg: cstring, + ctrls_mask, ctrls, rtrn_flags, rtrn_ctrls: int16): bool{. + libx11c, importc: "XkbSetDebuggingFlags".} +proc XkbApplyVirtualModChanges*(xkb: PXkbDescPtr, changed: int16, + changes: PXkbChangesPtr): bool{.libx11c, importc: "XkbApplyVirtualModChanges".} + +# implementation + +proc XkbNoteIndicatorMapChanges(o, n: PXkbIndicatorChangesPtr, w: int16) = + ##define XkbNoteIndicatorMapChanges(o,n,w) ((o)->map_changes|=((n)->map_changes&(w))) + o.map_changes = o.map_changes or (n.map_changes and w) + +proc XkbNoteIndicatorStateChanges(o, n: PXkbIndicatorChangesPtr, w: int16) = + ##define XkbNoteIndicatorStateChanges(o,n,w) ((o)->state_changes|=((n)->state_changes&(w))) + o.state_changes = o.state_changes or (n.state_changes and (w)) + +proc XkbGetIndicatorMapChanges(d: PDisplay, x: PXkbDescPtr, + c: PXkbIndicatorChangesPtr): TStatus = + ##define XkbGetIndicatorMapChanges(d,x,c) (XkbGetIndicatorMap((d),(c)->map_changes,x) + result = XkbGetIndicatorMap(d, c.map_changes, x) + +proc XkbChangeIndicatorMaps(d: PDisplay, x: PXkbDescPtr, + c: PXkbIndicatorChangesPtr): bool = + ##define XkbChangeIndicatorMaps(d,x,c) (XkbSetIndicatorMap((d),(c)->map_changes,x)) + result = XkbSetIndicatorMap(d, c.map_changes, x) + +proc XkbGetControlsChanges(d: PDisplay, x: PXkbDescPtr, + c: PXkbControlsChangesPtr): TStatus = + ##define XkbGetControlsChanges(d,x,c) XkbGetControls(d,(c)->changed_ctrls,x) + result = XkbGetControls(d, c.changed_ctrls, x) + +proc XkbChangeControls(d: PDisplay, x: PXkbDescPtr, c: PXkbControlsChangesPtr): bool = + ##define XkbChangeControls(d,x,c) XkbSetControls(d,(c)->changed_ctrls,x) + result = XkbSetControls(d, c.changed_ctrls, x) diff --git a/tests/deps/x11-1.0/xlib.nim b/tests/deps/x11-1.0/xlib.nim new file mode 100644 index 000000000..e9f211936 --- /dev/null +++ b/tests/deps/x11-1.0/xlib.nim @@ -0,0 +1,2026 @@ + +import + x + +include "x11pragma.nim" + +type + cunsigned* = cint + Pcint* = ptr cint + PPcint* = ptr Pcint + PPcuchar* = ptr ptr cuchar + PWideChar* = ptr int16 + PPChar* = ptr cstring + PPPChar* = ptr ptr cstring + Pculong* = ptr culong + Pcuchar* = cstring + Pcuint* = ptr cuint + Pcushort* = ptr uint16 +# Automatically converted by H2Pas 0.99.15 from xlib.h +# The following command line parameters were used: +# -p +# -T +# -S +# -d +# -c +# xlib.h + +const + XlibSpecificationRelease* = 6 + +type + PXPointer* = ptr TXPointer + TXPointer* = ptr char + PBool* = ptr TBool + TBool* = int #cint? + PStatus* = ptr TStatus + TStatus* = cint + +const + QueuedAlready* = 0 + QueuedAfterReading* = 1 + QueuedAfterFlush* = 2 + +type + PPXExtData* = ptr PXExtData + PXExtData* = ptr TXExtData + TXExtData*{.final.} = object + number*: cint + next*: PXExtData + free_private*: proc (extension: PXExtData): cint{.cdecl.} + private_data*: TXPointer + + PXExtCodes* = ptr TXExtCodes + TXExtCodes*{.final.} = object + extension*: cint + major_opcode*: cint + first_event*: cint + first_error*: cint + + PXPixmapFormatValues* = ptr TXPixmapFormatValues + TXPixmapFormatValues*{.final.} = object + depth*: cint + bits_per_pixel*: cint + scanline_pad*: cint + + PXGCValues* = ptr TXGCValues + TXGCValues*{.final.} = object + function*: cint + plane_mask*: culong + foreground*: culong + background*: culong + line_width*: cint + line_style*: cint + cap_style*: cint + join_style*: cint + fill_style*: cint + fill_rule*: cint + arc_mode*: cint + tile*: TPixmap + stipple*: TPixmap + ts_x_origin*: cint + ts_y_origin*: cint + font*: TFont + subwindow_mode*: cint + graphics_exposures*: TBool + clip_x_origin*: cint + clip_y_origin*: cint + clip_mask*: TPixmap + dash_offset*: cint + dashes*: cchar + + PXGC* = ptr TXGC + TXGC*{.final.} = object + TGC* = PXGC + PGC* = ptr TGC + PVisual* = ptr TVisual + TVisual*{.final.} = object + ext_data*: PXExtData + visualid*: TVisualID + c_class*: cint + red_mask*, green_mask*, blue_mask*: culong + bits_per_rgb*: cint + map_entries*: cint + + PDepth* = ptr TDepth + TDepth*{.final.} = object + depth*: cint + nvisuals*: cint + visuals*: PVisual + + PXDisplay* = ptr TXDisplay + TXDisplay*{.final.} = object + PScreen* = ptr TScreen + TScreen*{.final.} = object + ext_data*: PXExtData + display*: PXDisplay + root*: TWindow + width*, height*: cint + mwidth*, mheight*: cint + ndepths*: cint + depths*: PDepth + root_depth*: cint + root_visual*: PVisual + default_gc*: TGC + cmap*: TColormap + white_pixel*: culong + black_pixel*: culong + max_maps*, min_maps*: cint + backing_store*: cint + save_unders*: TBool + root_input_mask*: clong + + PScreenFormat* = ptr TScreenFormat + TScreenFormat*{.final.} = object + ext_data*: PXExtData + depth*: cint + bits_per_pixel*: cint + scanline_pad*: cint + + PXSetWindowAttributes* = ptr TXSetWindowAttributes + TXSetWindowAttributes*{.final.} = object + background_pixmap*: TPixmap + background_pixel*: culong + border_pixmap*: TPixmap + border_pixel*: culong + bit_gravity*: cint + win_gravity*: cint + backing_store*: cint + backing_planes*: culong + backing_pixel*: culong + save_under*: TBool + event_mask*: clong + do_not_propagate_mask*: clong + override_redirect*: TBool + colormap*: TColormap + cursor*: TCursor + + PXWindowAttributes* = ptr TXWindowAttributes + TXWindowAttributes*{.final.} = object + x*, y*: cint + width*, height*: cint + border_width*: cint + depth*: cint + visual*: PVisual + root*: TWindow + c_class*: cint + bit_gravity*: cint + win_gravity*: cint + backing_store*: cint + backing_planes*: culong + backing_pixel*: culong + save_under*: TBool + colormap*: TColormap + map_installed*: TBool + map_state*: cint + all_event_masks*: clong + your_event_mask*: clong + do_not_propagate_mask*: clong + override_redirect*: TBool + screen*: PScreen + + PXHostAddress* = ptr TXHostAddress + TXHostAddress*{.final.} = object + family*: cint + len*: cint + address*: cstring + + PXServerInterpretedAddress* = ptr TXServerInterpretedAddress + TXServerInterpretedAddress*{.final.} = object + typelength*: cint + valuelength*: cint + theType*: cstring + value*: cstring + + PXImage* = ptr TXImage + TF*{.final.} = object + create_image*: proc (para1: PXDisplay, para2: PVisual, para3: cuint, + para4: cint, para5: cint, para6: cstring, para7: cuint, + para8: cuint, para9: cint, para10: cint): PXImage{. + cdecl.} + destroy_image*: proc (para1: PXImage): cint{.cdecl.} + get_pixel*: proc (para1: PXImage, para2: cint, para3: cint): culong{.cdecl.} + put_pixel*: proc (para1: PXImage, para2: cint, para3: cint, para4: culong): cint{. + cdecl.} + sub_image*: proc (para1: PXImage, para2: cint, para3: cint, para4: cuint, + para5: cuint): PXImage{.cdecl.} + add_pixel*: proc (para1: PXImage, para2: clong): cint{.cdecl.} + + TXImage*{.final.} = object + width*, height*: cint + xoffset*: cint + format*: cint + data*: cstring + byte_order*: cint + bitmap_unit*: cint + bitmap_bit_order*: cint + bitmap_pad*: cint + depth*: cint + bytes_per_line*: cint + bits_per_pixel*: cint + red_mask*: culong + green_mask*: culong + blue_mask*: culong + obdata*: TXPointer + f*: TF + + PXWindowChanges* = ptr TXWindowChanges + TXWindowChanges*{.final.} = object + x*, y*: cint + width*, height*: cint + border_width*: cint + sibling*: TWindow + stack_mode*: cint + + PXColor* = ptr TXColor + TXColor*{.final.} = object + pixel*: culong + red*, green*, blue*: cushort + flags*: cchar + pad*: cchar + + PXSegment* = ptr TXSegment + TXSegment*{.final.} = object + x1*, y1*, x2*, y2*: cshort + + PXPoint* = ptr TXPoint + TXPoint*{.final.} = object + x*, y*: cshort + + PXRectangle* = ptr TXRectangle + TXRectangle*{.final.} = object + x*, y*: cshort + width*, height*: cushort + + PXArc* = ptr TXArc + TXArc*{.final.} = object + x*, y*: cshort + width*, height*: cushort + angle1*, angle2*: cshort + + PXKeyboardControl* = ptr TXKeyboardControl + TXKeyboardControl*{.final.} = object + key_click_percent*: cint + bell_percent*: cint + bell_pitch*: cint + bell_duration*: cint + led*: cint + led_mode*: cint + key*: cint + auto_repeat_mode*: cint + + PXKeyboardState* = ptr TXKeyboardState + TXKeyboardState*{.final.} = object + key_click_percent*: cint + bell_percent*: cint + bell_pitch*, bell_duration*: cuint + led_mask*: culong + global_auto_repeat*: cint + auto_repeats*: array[0..31, cchar] + + PXTimeCoord* = ptr TXTimeCoord + TXTimeCoord*{.final.} = object + time*: TTime + x*, y*: cshort + + PXModifierKeymap* = ptr TXModifierKeymap + TXModifierKeymap*{.final.} = object + max_keypermod*: cint + modifiermap*: PKeyCode + + PDisplay* = ptr TDisplay + TDisplay* = TXDisplay + PXPrivate* = ptr TXPrivate + TXPrivate*{.final.} = object + PXrmHashBucketRec* = ptr TXrmHashBucketRec + TXrmHashBucketRec*{.final.} = object + PXPrivDisplay* = ptr TXPrivDisplay + TXPrivDisplay*{.final.} = object + ext_data*: PXExtData + private1*: PXPrivate + fd*: cint + private2*: cint + proto_major_version*: cint + proto_minor_version*: cint + vendor*: cstring + private3*: TXID + private4*: TXID + private5*: TXID + private6*: cint + resource_alloc*: proc (para1: PXDisplay): TXID{.cdecl.} + byte_order*: cint + bitmap_unit*: cint + bitmap_pad*: cint + bitmap_bit_order*: cint + nformats*: cint + pixmap_format*: PScreenFormat + private8*: cint + release*: cint + private9*, private10*: PXPrivate + qlen*: cint + last_request_read*: culong + request*: culong + private11*: TXPointer + private12*: TXPointer + private13*: TXPointer + private14*: TXPointer + max_request_size*: cunsigned + db*: PXrmHashBucketRec + private15*: proc (para1: PXDisplay): cint{.cdecl.} + display_name*: cstring + default_screen*: cint + nscreens*: cint + screens*: PScreen + motion_buffer*: culong + private16*: culong + min_keycode*: cint + max_keycode*: cint + private17*: TXPointer + private18*: TXPointer + private19*: cint + xdefaults*: cstring + + PXKeyEvent* = ptr TXKeyEvent + TXKeyEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + root*: TWindow + subwindow*: TWindow + time*: TTime + x*, y*: cint + x_root*, y_root*: cint + state*: cuint + keycode*: cuint + same_screen*: TBool + + PXKeyPressedEvent* = ptr TXKeyPressedEvent + TXKeyPressedEvent* = TXKeyEvent + PXKeyReleasedEvent* = ptr TXKeyReleasedEvent + TXKeyReleasedEvent* = TXKeyEvent + PXButtonEvent* = ptr TXButtonEvent + TXButtonEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + root*: TWindow + subwindow*: TWindow + time*: TTime + x*, y*: cint + x_root*, y_root*: cint + state*: cuint + button*: cuint + same_screen*: TBool + + PXButtonPressedEvent* = ptr TXButtonPressedEvent + TXButtonPressedEvent* = TXButtonEvent + PXButtonReleasedEvent* = ptr TXButtonReleasedEvent + TXButtonReleasedEvent* = TXButtonEvent + PXMotionEvent* = ptr TXMotionEvent + TXMotionEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + root*: TWindow + subwindow*: TWindow + time*: TTime + x*, y*: cint + x_root*, y_root*: cint + state*: cuint + is_hint*: cchar + same_screen*: TBool + + PXPointerMovedEvent* = ptr TXPointerMovedEvent + TXPointerMovedEvent* = TXMotionEvent + PXCrossingEvent* = ptr TXCrossingEvent + TXCrossingEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + root*: TWindow + subwindow*: TWindow + time*: TTime + x*, y*: cint + x_root*, y_root*: cint + mode*: cint + detail*: cint + same_screen*: TBool + focus*: TBool + state*: cuint + + PXEnterWindowEvent* = ptr TXEnterWindowEvent + TXEnterWindowEvent* = TXCrossingEvent + PXLeaveWindowEvent* = ptr TXLeaveWindowEvent + TXLeaveWindowEvent* = TXCrossingEvent + PXFocusChangeEvent* = ptr TXFocusChangeEvent + TXFocusChangeEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + mode*: cint + detail*: cint + + PXFocusInEvent* = ptr TXFocusInEvent + TXFocusInEvent* = TXFocusChangeEvent + PXFocusOutEvent* = ptr TXFocusOutEvent + TXFocusOutEvent* = TXFocusChangeEvent + PXKeymapEvent* = ptr TXKeymapEvent + TXKeymapEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + key_vector*: array[0..31, cchar] + + PXExposeEvent* = ptr TXExposeEvent + TXExposeEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + x*, y*: cint + width*, height*: cint + count*: cint + + PXGraphicsExposeEvent* = ptr TXGraphicsExposeEvent + TXGraphicsExposeEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + drawable*: TDrawable + x*, y*: cint + width*, height*: cint + count*: cint + major_code*: cint + minor_code*: cint + + PXNoExposeEvent* = ptr TXNoExposeEvent + TXNoExposeEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + drawable*: TDrawable + major_code*: cint + minor_code*: cint + + PXVisibilityEvent* = ptr TXVisibilityEvent + TXVisibilityEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + state*: cint + + PXCreateWindowEvent* = ptr TXCreateWindowEvent + TXCreateWindowEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + parent*: TWindow + window*: TWindow + x*, y*: cint + width*, height*: cint + border_width*: cint + override_redirect*: TBool + + PXDestroyWindowEvent* = ptr TXDestroyWindowEvent + TXDestroyWindowEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + event*: TWindow + window*: TWindow + + PXUnmapEvent* = ptr TXUnmapEvent + TXUnmapEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + event*: TWindow + window*: TWindow + from_configure*: TBool + + PXMapEvent* = ptr TXMapEvent + TXMapEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + event*: TWindow + window*: TWindow + override_redirect*: TBool + + PXMapRequestEvent* = ptr TXMapRequestEvent + TXMapRequestEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + parent*: TWindow + window*: TWindow + + PXReparentEvent* = ptr TXReparentEvent + TXReparentEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + event*: TWindow + window*: TWindow + parent*: TWindow + x*, y*: cint + override_redirect*: TBool + + PXConfigureEvent* = ptr TXConfigureEvent + TXConfigureEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + event*: TWindow + window*: TWindow + x*, y*: cint + width*, height*: cint + border_width*: cint + above*: TWindow + override_redirect*: TBool + + PXGravityEvent* = ptr TXGravityEvent + TXGravityEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + event*: TWindow + window*: TWindow + x*, y*: cint + + PXResizeRequestEvent* = ptr TXResizeRequestEvent + TXResizeRequestEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + width*, height*: cint + + PXConfigureRequestEvent* = ptr TXConfigureRequestEvent + TXConfigureRequestEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + parent*: TWindow + window*: TWindow + x*, y*: cint + width*, height*: cint + border_width*: cint + above*: TWindow + detail*: cint + value_mask*: culong + + PXCirculateEvent* = ptr TXCirculateEvent + TXCirculateEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + event*: TWindow + window*: TWindow + place*: cint + + PXCirculateRequestEvent* = ptr TXCirculateRequestEvent + TXCirculateRequestEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + parent*: TWindow + window*: TWindow + place*: cint + + PXPropertyEvent* = ptr TXPropertyEvent + TXPropertyEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + atom*: TAtom + time*: TTime + state*: cint + + PXSelectionClearEvent* = ptr TXSelectionClearEvent + TXSelectionClearEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + selection*: TAtom + time*: TTime + + PXSelectionRequestEvent* = ptr TXSelectionRequestEvent + TXSelectionRequestEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + owner*: TWindow + requestor*: TWindow + selection*: TAtom + target*: TAtom + property*: TAtom + time*: TTime + + PXSelectionEvent* = ptr TXSelectionEvent + TXSelectionEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + requestor*: TWindow + selection*: TAtom + target*: TAtom + property*: TAtom + time*: TTime + + PXColormapEvent* = ptr TXColormapEvent + TXColormapEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + colormap*: TColormap + c_new*: TBool + state*: cint + + PXClientMessageEvent* = ptr TXClientMessageEvent + TXClientMessageEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + message_type*: TAtom + format*: cint + data*: array[0..4, clong] # using clong here to be 32/64-bit dependent + # as the original C union + + PXMappingEvent* = ptr TXMappingEvent + TXMappingEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + request*: cint + first_keycode*: cint + count*: cint + + PXErrorEvent* = ptr TXErrorEvent + TXErrorEvent*{.final.} = object + theType*: cint + display*: PDisplay + resourceid*: TXID + serial*: culong + error_code*: cuchar + request_code*: cuchar + minor_code*: cuchar + + PXAnyEvent* = ptr TXAnyEvent + TXAnyEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + window*: TWindow + + PXEvent* = ptr TXEvent + TXEvent*{.final.} = object + theType*: cint + pad*: array[0..22, clong] # + # case longint of + # 0 : ( theType : cint ); + # 1 : ( xany : TXAnyEvent ); + # 2 : ( xkey : TXKeyEvent ); + # 3 : ( xbutton : TXButtonEvent ); + # 4 : ( xmotion : TXMotionEvent ); + # 5 : ( xcrossing : TXCrossingEvent ); + # 6 : ( xfocus : TXFocusChangeEvent ); + # 7 : ( xexpose : TXExposeEvent ); + # 8 : ( xgraphicsexpose : TXGraphicsExposeEvent ); + # 9 : ( xnoexpose : TXNoExposeEvent ); + # 10 : ( xvisibility : TXVisibilityEvent ); + # 11 : ( xcreatewindow : TXCreateWindowEvent ); + # 12 : ( xdestroywindow : TXDestroyWindowEvent ); + # 13 : ( xunmap : TXUnmapEvent ); + # 14 : ( xmap : TXMapEvent ); + # 15 : ( xmaprequest : TXMapRequestEvent ); + # 16 : ( xreparent : TXReparentEvent ); + # 17 : ( xconfigure : TXConfigureEvent ); + # 18 : ( xgravity : TXGravityEvent ); + # 19 : ( xresizerequest : TXResizeRequestEvent ); + # 20 : ( xconfigurerequest : TXConfigureRequestEvent ); + # 21 : ( xcirculate : TXCirculateEvent ); + # 22 : ( xcirculaterequest : TXCirculateRequestEvent ); + # 23 : ( xproperty : TXPropertyEvent ); + # 24 : ( xselectionclear : TXSelectionClearEvent ); + # 25 : ( xselectionrequest : TXSelectionRequestEvent ); + # 26 : ( xselection : TXSelectionEvent ); + # 27 : ( xcolormap : TXColormapEvent ); + # 28 : ( xclient : TXClientMessageEvent ); + # 29 : ( xmapping : TXMappingEvent ); + # 30 : ( xerror : TXErrorEvent ); + # 31 : ( xkeymap : TXKeymapEvent ); + # 32 : ( pad : array[0..23] of clong ); + # + + +proc xclient*(e: PXEvent): PXClientMessageEvent = + ## Treats XEvent as XClientMessageEvent + return cast[PXClientMessageEvent](e) + +proc xclient*(e: var TXEvent): PXClientMessageEvent = + return xclient(PXEvent(e.addr)) + +type + PXCharStruct* = ptr TXCharStruct + TXCharStruct*{.final.} = object + lbearing*: cshort + rbearing*: cshort + width*: cshort + ascent*: cshort + descent*: cshort + attributes*: cushort + + PXFontProp* = ptr TXFontProp + TXFontProp*{.final.} = object + name*: TAtom + card32*: culong + + PPPXFontStruct* = ptr PPXFontStruct + PPXFontStruct* = ptr PXFontStruct + PXFontStruct* = ptr TXFontStruct + TXFontStruct*{.final.} = object + ext_data*: PXExtData + fid*: TFont + direction*: cunsigned + min_char_or_byte2*: cunsigned + max_char_or_byte2*: cunsigned + min_byte1*: cunsigned + max_byte1*: cunsigned + all_chars_exist*: TBool + default_char*: cunsigned + n_properties*: cint + properties*: PXFontProp + min_bounds*: TXCharStruct + max_bounds*: TXCharStruct + per_char*: PXCharStruct + ascent*: cint + descent*: cint + + PXTextItem* = ptr TXTextItem + TXTextItem*{.final.} = object + chars*: cstring + nchars*: cint + delta*: cint + font*: TFont + + PXChar2b* = ptr TXChar2b + TXChar2b*{.final.} = object + byte1*: cuchar + byte2*: cuchar + + PXTextItem16* = ptr TXTextItem16 + TXTextItem16*{.final.} = object + chars*: PXChar2b + nchars*: cint + delta*: cint + font*: TFont + + PXEDataObject* = ptr TXEDataObject + TXEDataObject*{.final.} = object + display*: PDisplay #case longint of + # 0 : ( display : PDisplay ); + # 1 : ( gc : TGC ); + # 2 : ( visual : PVisual ); + # 3 : ( screen : PScreen ); + # 4 : ( pixmap_format : PScreenFormat ); + # 5 : ( font : PXFontStruct ); + + PXFontSetExtents* = ptr TXFontSetExtents + TXFontSetExtents*{.final.} = object + max_ink_extent*: TXRectangle + max_logical_extent*: TXRectangle + + PXOM* = ptr TXOM + TXOM*{.final.} = object + PXOC* = ptr TXOC + TXOC*{.final.} = object + TXFontSet* = PXOC + PXFontSet* = ptr TXFontSet + PXmbTextItem* = ptr TXmbTextItem + TXmbTextItem*{.final.} = object + chars*: cstring + nchars*: cint + delta*: cint + font_set*: TXFontSet + + PXwcTextItem* = ptr TXwcTextItem + TXwcTextItem*{.final.} = object + chars*: PWideChar #wchar_t* + nchars*: cint + delta*: cint + font_set*: TXFontSet + + +const + XNRequiredCharSet* = "requiredCharSet" + XNQueryOrientation* = "queryOrientation" + XNBaseFontName* = "baseFontName" + XNOMAutomatic* = "omAutomatic" + XNMissingCharSet* = "missingCharSet" + XNDefaultString* = "defaultString" + XNOrientation* = "orientation" + XNDirectionalDependentDrawing* = "directionalDependentDrawing" + XNContextualDrawing* = "contextualDrawing" + XNFontInfo* = "fontInfo" + +type + PXOMCharSetList* = ptr TXOMCharSetList + TXOMCharSetList*{.final.} = object + charset_count*: cint + charset_list*: PPChar + + PXOrientation* = ptr TXOrientation + TXOrientation* = enum + XOMOrientation_LTR_TTB, XOMOrientation_RTL_TTB, XOMOrientation_TTB_LTR, + XOMOrientation_TTB_RTL, XOMOrientation_Context + PXOMOrientation* = ptr TXOMOrientation + TXOMOrientation*{.final.} = object + num_orientation*: cint + orientation*: PXOrientation + + PXOMFontInfo* = ptr TXOMFontInfo + TXOMFontInfo*{.final.} = object + num_font*: cint + font_struct_list*: ptr PXFontStruct + font_name_list*: PPChar + + PXIM* = ptr TXIM + TXIM*{.final.} = object + PXIC* = ptr TXIC + TXIC*{.final.} = object + TXIMProc* = proc (para1: TXIM, para2: TXPointer, para3: TXPointer){.cdecl.} + TXICProc* = proc (para1: TXIC, para2: TXPointer, para3: TXPointer): TBool{. + cdecl.} + TXIDProc* = proc (para1: PDisplay, para2: TXPointer, para3: TXPointer){.cdecl.} + PXIMStyle* = ptr TXIMStyle + TXIMStyle* = culong + PXIMStyles* = ptr TXIMStyles + TXIMStyles*{.final.} = object + count_styles*: cushort + supported_styles*: PXIMStyle + + +const + XIMPreeditArea* = 0x00000001 + XIMPreeditCallbacks* = 0x00000002 + XIMPreeditPosition* = 0x00000004 + XIMPreeditNothing* = 0x00000008 + XIMPreeditNone* = 0x00000010 + XIMStatusArea* = 0x00000100 + XIMStatusCallbacks* = 0x00000200 + XIMStatusNothing* = 0x00000400 + XIMStatusNone* = 0x00000800 + XNVaNestedList* = "XNVaNestedList" + XNQueryInputStyle* = "queryInputStyle" + XNClientWindow* = "clientWindow" + XNInputStyle* = "inputStyle" + XNFocusWindow* = "focusWindow" + XNResourceName* = "resourceName" + XNResourceClass* = "resourceClass" + XNGeometryCallback* = "geometryCallback" + XNDestroyCallback* = "destroyCallback" + XNFilterEvents* = "filterEvents" + XNPreeditStartCallback* = "preeditStartCallback" + XNPreeditDoneCallback* = "preeditDoneCallback" + XNPreeditDrawCallback* = "preeditDrawCallback" + XNPreeditCaretCallback* = "preeditCaretCallback" + XNPreeditStateNotifyCallback* = "preeditStateNotifyCallback" + XNPreeditAttributes* = "preeditAttributes" + XNStatusStartCallback* = "statusStartCallback" + XNStatusDoneCallback* = "statusDoneCallback" + XNStatusDrawCallback* = "statusDrawCallback" + XNStatusAttributes* = "statusAttributes" + XNArea* = "area" + XNAreaNeeded* = "areaNeeded" + XNSpotLocation* = "spotLocation" + XNColormap* = "colorMap" + XNStdColormap* = "stdColorMap" + XNForeground* = "foreground" + XNBackground* = "background" + XNBackgroundPixmap* = "backgroundPixmap" + XNFontSet* = "fontSet" + XNLineSpace* = "lineSpace" + XNCursor* = "cursor" + XNQueryIMValuesList* = "queryIMValuesList" + XNQueryICValuesList* = "queryICValuesList" + XNVisiblePosition* = "visiblePosition" + XNR6PreeditCallback* = "r6PreeditCallback" + XNStringConversionCallback* = "stringConversionCallback" + XNStringConversion* = "stringConversion" + XNResetState* = "resetState" + XNHotKey* = "hotKey" + XNHotKeyState* = "hotKeyState" + XNPreeditState* = "preeditState" + XNSeparatorofNestedList* = "separatorofNestedList" + XBufferOverflow* = - (1) + XLookupNone* = 1 + XLookupChars* = 2 + XLookupKeySymVal* = 3 + XLookupBoth* = 4 + +type + PXVaNestedList* = ptr TXVaNestedList + TXVaNestedList* = pointer + PXIMCallback* = ptr TXIMCallback + TXIMCallback*{.final.} = object + client_data*: TXPointer + callback*: TXIMProc + + PXICCallback* = ptr TXICCallback + TXICCallback*{.final.} = object + client_data*: TXPointer + callback*: TXICProc + + PXIMFeedback* = ptr TXIMFeedback + TXIMFeedback* = culong + +const + XIMReverse* = 1 + XIMUnderline* = 1 shl 1 + XIMHighlight* = 1 shl 2 + XIMPrimary* = 1 shl 5 + XIMSecondary* = 1 shl 6 + XIMTertiary* = 1 shl 7 + XIMVisibleToForward* = 1 shl 8 + XIMVisibleToBackword* = 1 shl 9 + XIMVisibleToCenter* = 1 shl 10 + +type + PXIMText* = ptr TXIMText + TXIMText*{.final.} = object + len*: cushort + feedback*: PXIMFeedback + encoding_is_wchar*: TBool + multi_byte*: cstring + + PXIMPreeditState* = ptr TXIMPreeditState + TXIMPreeditState* = culong + +const + XIMPreeditUnKnown* = 0 + XIMPreeditEnable* = 1 + XIMPreeditDisable* = 1 shl 1 + +type + PXIMPreeditStateNotifyCallbackStruct* = ptr TXIMPreeditStateNotifyCallbackStruct + TXIMPreeditStateNotifyCallbackStruct*{.final.} = object + state*: TXIMPreeditState + + PXIMResetState* = ptr TXIMResetState + TXIMResetState* = culong + +const + XIMInitialState* = 1 + XIMPreserveState* = 1 shl 1 + +type + PXIMStringConversionFeedback* = ptr TXIMStringConversionFeedback + TXIMStringConversionFeedback* = culong + +const + XIMStringConversionLeftEdge* = 0x00000001 + XIMStringConversionRightEdge* = 0x00000002 + XIMStringConversionTopEdge* = 0x00000004 + XIMStringConversionBottomEdge* = 0x00000008 + XIMStringConversionConcealed* = 0x00000010 + XIMStringConversionWrapped* = 0x00000020 + +type + PXIMStringConversionText* = ptr TXIMStringConversionText + TXIMStringConversionText*{.final.} = object + len*: cushort + feedback*: PXIMStringConversionFeedback + encoding_is_wchar*: TBool + mbs*: cstring + + PXIMStringConversionPosition* = ptr TXIMStringConversionPosition + TXIMStringConversionPosition* = cushort + PXIMStringConversionType* = ptr TXIMStringConversionType + TXIMStringConversionType* = cushort + +const + XIMStringConversionBuffer* = 0x00000001 + XIMStringConversionLine* = 0x00000002 + XIMStringConversionWord* = 0x00000003 + XIMStringConversionChar* = 0x00000004 + +type + PXIMStringConversionOperation* = ptr TXIMStringConversionOperation + TXIMStringConversionOperation* = cushort + +const + XIMStringConversionSubstitution* = 0x00000001 + XIMStringConversionRetrieval* = 0x00000002 + +type + PXIMCaretDirection* = ptr TXIMCaretDirection + TXIMCaretDirection* = enum + XIMForwardChar, XIMBackwardChar, XIMForwardWord, XIMBackwardWord, + XIMCaretUp, XIMCaretDown, XIMNextLine, XIMPreviousLine, XIMLineStart, + XIMLineEnd, XIMAbsolutePosition, XIMDontChange + PXIMStringConversionCallbackStruct* = ptr TXIMStringConversionCallbackStruct + TXIMStringConversionCallbackStruct*{.final.} = object + position*: TXIMStringConversionPosition + direction*: TXIMCaretDirection + operation*: TXIMStringConversionOperation + factor*: cushort + text*: PXIMStringConversionText + + PXIMPreeditDrawCallbackStruct* = ptr TXIMPreeditDrawCallbackStruct + TXIMPreeditDrawCallbackStruct*{.final.} = object + caret*: cint + chg_first*: cint + chg_length*: cint + text*: PXIMText + + PXIMCaretStyle* = ptr TXIMCaretStyle + TXIMCaretStyle* = enum + XIMIsInvisible, XIMIsPrimary, XIMIsSecondary + PXIMPreeditCaretCallbackStruct* = ptr TXIMPreeditCaretCallbackStruct + TXIMPreeditCaretCallbackStruct*{.final.} = object + position*: cint + direction*: TXIMCaretDirection + style*: TXIMCaretStyle + + PXIMStatusDataType* = ptr TXIMStatusDataType + TXIMStatusDataType* = enum + XIMTextType, XIMBitmapType + PXIMStatusDrawCallbackStruct* = ptr TXIMStatusDrawCallbackStruct + TXIMStatusDrawCallbackStruct*{.final.} = object + theType*: TXIMStatusDataType + bitmap*: TPixmap + + PXIMHotKeyTrigger* = ptr TXIMHotKeyTrigger + TXIMHotKeyTrigger*{.final.} = object + keysym*: TKeySym + modifier*: cint + modifier_mask*: cint + + PXIMHotKeyTriggers* = ptr TXIMHotKeyTriggers + TXIMHotKeyTriggers*{.final.} = object + num_hot_key*: cint + key*: PXIMHotKeyTrigger + + PXIMHotKeyState* = ptr TXIMHotKeyState + TXIMHotKeyState* = culong + +const + XIMHotKeyStateON* = 0x00000001 + XIMHotKeyStateOFF* = 0x00000002 + +type + PXIMValuesList* = ptr TXIMValuesList + TXIMValuesList*{.final.} = object + count_values*: cushort + supported_values*: PPChar + + +type + funcdisp* = proc (display: PDisplay): cint{.cdecl.} + funcifevent* = proc (display: PDisplay, event: PXEvent, p: TXPointer): TBool{. + cdecl.} + chararr32* = array[0..31, char] + +const + AllPlanes*: culong = culong(not 0) + +proc XLoadQueryFont*(para1: PDisplay, para2: cstring): PXFontStruct{.libx11.} +proc XQueryFont*(para1: PDisplay, para2: TXID): PXFontStruct{.libx11.} +proc XGetMotionEvents*(para1: PDisplay, para2: TWindow, para3: TTime, + para4: TTime, para5: Pcint): PXTimeCoord{.libx11.} +proc XDeleteModifiermapEntry*(para1: PXModifierKeymap, para2: TKeyCode, + para3: cint): PXModifierKeymap{.libx11.} +proc XGetModifierMapping*(para1: PDisplay): PXModifierKeymap{.libx11.} +proc XInsertModifiermapEntry*(para1: PXModifierKeymap, para2: TKeyCode, + para3: cint): PXModifierKeymap{.libx11.} +proc XNewModifiermap*(para1: cint): PXModifierKeymap{.libx11.} +proc XCreateImage*(para1: PDisplay, para2: PVisual, para3: cuint, para4: cint, + para5: cint, para6: cstring, para7: cuint, para8: cuint, + para9: cint, para10: cint): PXImage{.libx11.} +proc XInitImage*(para1: PXImage): TStatus{.libx11.} +proc XGetImage*(para1: PDisplay, para2: TDrawable, para3: cint, para4: cint, + para5: cuint, para6: cuint, para7: culong, para8: cint): PXImage{. + libx11.} +proc XGetSubImage*(para1: PDisplay, para2: TDrawable, para3: cint, para4: cint, + para5: cuint, para6: cuint, para7: culong, para8: cint, + para9: PXImage, para10: cint, para11: cint): PXImage{.libx11.} +proc XOpenDisplay*(para1: cstring): PDisplay{.libx11.} +proc XrmInitialize*(){.libx11.} +proc XFetchBytes*(para1: PDisplay, para2: Pcint): cstring{.libx11.} +proc XFetchBuffer*(para1: PDisplay, para2: Pcint, para3: cint): cstring{.libx11.} +proc XGetAtomName*(para1: PDisplay, para2: TAtom): cstring{.libx11.} +proc XGetAtomNames*(para1: PDisplay, para2: PAtom, para3: cint, para4: PPchar): TStatus{. + libx11.} +proc XGetDefault*(para1: PDisplay, para2: cstring, para3: cstring): cstring{. + libx11.} +proc XDisplayName*(para1: cstring): cstring{.libx11.} +proc XKeysymToString*(para1: TKeySym): cstring{.libx11.} +proc XSynchronize*(para1: PDisplay, para2: TBool): funcdisp{.libx11.} +proc XSetAfterFunction*(para1: PDisplay, para2: funcdisp): funcdisp{.libx11.} +proc XInternAtom*(para1: PDisplay, para2: cstring, para3: TBool): TAtom{.libx11.} +proc XInternAtoms*(para1: PDisplay, para2: PPchar, para3: cint, para4: TBool, + para5: PAtom): TStatus{.libx11.} +proc XCopyColormapAndFree*(para1: PDisplay, para2: TColormap): TColormap{.libx11.} +proc XCreateColormap*(para1: PDisplay, para2: TWindow, para3: PVisual, + para4: cint): TColormap{.libx11.} +proc XCreatePixmapCursor*(para1: PDisplay, para2: TPixmap, para3: TPixmap, + para4: PXColor, para5: PXColor, para6: cuint, + para7: cuint): TCursor{.libx11.} +proc XCreateGlyphCursor*(para1: PDisplay, para2: TFont, para3: TFont, + para4: cuint, para5: cuint, para6: PXColor, + para7: PXColor): TCursor{.libx11.} +proc XCreateFontCursor*(para1: PDisplay, para2: cuint): TCursor{.libx11.} +proc XLoadFont*(para1: PDisplay, para2: cstring): TFont{.libx11.} +proc XCreateGC*(para1: PDisplay, para2: TDrawable, para3: culong, + para4: PXGCValues): TGC{.libx11.} +proc XGContextFromGC*(para1: TGC): TGContext{.libx11.} +proc XFlushGC*(para1: PDisplay, para2: TGC){.libx11.} +proc XCreatePixmap*(para1: PDisplay, para2: TDrawable, para3: cuint, + para4: cuint, para5: cuint): TPixmap{.libx11.} +proc XCreateBitmapFromData*(para1: PDisplay, para2: TDrawable, para3: cstring, + para4: cuint, para5: cuint): TPixmap{.libx11.} +proc XCreatePixmapFromBitmapData*(para1: PDisplay, para2: TDrawable, + para3: cstring, para4: cuint, para5: cuint, + para6: culong, para7: culong, para8: cuint): TPixmap{. + libx11.} +proc XCreateSimpleWindow*(para1: PDisplay, para2: TWindow, para3: cint, + para4: cint, para5: cuint, para6: cuint, para7: cuint, + para8: culong, para9: culong): TWindow{.libx11.} +proc XGetSelectionOwner*(para1: PDisplay, para2: TAtom): TWindow{.libx11.} +proc XCreateWindow*(para1: PDisplay, para2: TWindow, para3: cint, para4: cint, + para5: cuint, para6: cuint, para7: cuint, para8: cint, + para9: cuint, para10: PVisual, para11: culong, + para12: PXSetWindowAttributes): TWindow{.libx11.} +proc XListInstalledColormaps*(para1: PDisplay, para2: TWindow, para3: Pcint): PColormap{. + libx11.} +proc XListFonts*(para1: PDisplay, para2: cstring, para3: cint, para4: Pcint): PPChar{. + libx11.} +proc XListFontsWithInfo*(para1: PDisplay, para2: cstring, para3: cint, + para4: Pcint, para5: PPXFontStruct): PPChar{.libx11.} +proc XGetFontPath*(para1: PDisplay, para2: Pcint): PPChar{.libx11.} +proc XListExtensions*(para1: PDisplay, para2: Pcint): PPChar{.libx11.} +proc XListProperties*(para1: PDisplay, para2: TWindow, para3: Pcint): PAtom{. + libx11.} +proc XListHosts*(para1: PDisplay, para2: Pcint, para3: PBool): PXHostAddress{. + libx11.} +proc XKeycodeToKeysym*(para1: PDisplay, para2: TKeyCode, para3: cint): TKeySym{. + libx11.} +proc XLookupKeysym*(para1: PXKeyEvent, para2: cint): TKeySym{.libx11.} +proc XGetKeyboardMapping*(para1: PDisplay, para2: TKeyCode, para3: cint, + para4: Pcint): PKeySym{.libx11.} +proc XStringToKeysym*(para1: cstring): TKeySym{.libx11.} +proc XMaxRequestSize*(para1: PDisplay): clong{.libx11.} +proc XExtendedMaxRequestSize*(para1: PDisplay): clong{.libx11.} +proc XResourceManagerString*(para1: PDisplay): cstring{.libx11.} +proc XScreenResourceString*(para1: PScreen): cstring{.libx11.} +proc XDisplayMotionBufferSize*(para1: PDisplay): culong{.libx11.} +proc XVisualIDFromVisual*(para1: PVisual): TVisualID{.libx11.} +proc XInitThreads*(): TStatus{.libx11.} +proc XLockDisplay*(para1: PDisplay){.libx11.} +proc XUnlockDisplay*(para1: PDisplay){.libx11.} +proc XInitExtension*(para1: PDisplay, para2: cstring): PXExtCodes{.libx11.} +proc XAddExtension*(para1: PDisplay): PXExtCodes{.libx11.} +proc XFindOnExtensionList*(para1: PPXExtData, para2: cint): PXExtData{.libx11.} +proc XEHeadOfExtensionList*(para1: TXEDataObject): PPXExtData{.libx11.} +proc XRootWindow*(para1: PDisplay, para2: cint): TWindow{.libx11.} +proc XDefaultRootWindow*(para1: PDisplay): TWindow{.libx11.} +proc XRootWindowOfScreen*(para1: PScreen): TWindow{.libx11.} +proc XDefaultVisual*(para1: PDisplay, para2: cint): PVisual{.libx11.} +proc XDefaultVisualOfScreen*(para1: PScreen): PVisual{.libx11.} +proc XDefaultGC*(para1: PDisplay, para2: cint): TGC{.libx11.} +proc XDefaultGCOfScreen*(para1: PScreen): TGC{.libx11.} +proc XBlackPixel*(para1: PDisplay, para2: cint): culong{.libx11.} +proc XWhitePixel*(para1: PDisplay, para2: cint): culong{.libx11.} +proc XAllPlanes*(): culong{.libx11.} +proc XBlackPixelOfScreen*(para1: PScreen): culong{.libx11.} +proc XWhitePixelOfScreen*(para1: PScreen): culong{.libx11.} +proc XNextRequest*(para1: PDisplay): culong{.libx11.} +proc XLastKnownRequestProcessed*(para1: PDisplay): culong{.libx11.} +proc XServerVendor*(para1: PDisplay): cstring{.libx11.} +proc XDisplayString*(para1: PDisplay): cstring{.libx11.} +proc XDefaultColormap*(para1: PDisplay, para2: cint): TColormap{.libx11.} +proc XDefaultColormapOfScreen*(para1: PScreen): TColormap{.libx11.} +proc XDisplayOfScreen*(para1: PScreen): PDisplay{.libx11.} +proc XScreenOfDisplay*(para1: PDisplay, para2: cint): PScreen{.libx11.} +proc XDefaultScreenOfDisplay*(para1: PDisplay): PScreen{.libx11.} +proc XEventMaskOfScreen*(para1: PScreen): clong{.libx11.} +proc XScreenNumberOfScreen*(para1: PScreen): cint{.libx11.} +type + TXErrorHandler* = proc (para1: PDisplay, para2: PXErrorEvent): cint{.cdecl.} + +proc XSetErrorHandler*(para1: TXErrorHandler): TXErrorHandler{.libx11.} +type + TXIOErrorHandler* = proc (para1: PDisplay): cint{.cdecl.} + +proc XSetIOErrorHandler*(para1: TXIOErrorHandler): TXIOErrorHandler{.libx11.} +proc XListPixmapFormats*(para1: PDisplay, para2: Pcint): PXPixmapFormatValues{. + libx11.} +proc XListDepths*(para1: PDisplay, para2: cint, para3: Pcint): Pcint{.libx11.} +proc XReconfigureWMWindow*(para1: PDisplay, para2: TWindow, para3: cint, + para4: cuint, para5: PXWindowChanges): TStatus{. + libx11.} +proc XGetWMProtocols*(para1: PDisplay, para2: TWindow, para3: PPAtom, + para4: Pcint): TStatus{.libx11.} +proc XSetWMProtocols*(para1: PDisplay, para2: TWindow, para3: PAtom, para4: cint): TStatus{. + libx11.} +proc XIconifyWindow*(para1: PDisplay, para2: TWindow, para3: cint): TStatus{. + libx11.} +proc XWithdrawWindow*(para1: PDisplay, para2: TWindow, para3: cint): TStatus{. + libx11.} +proc XGetCommand*(para1: PDisplay, para2: TWindow, para3: PPPchar, para4: Pcint): TStatus{. + libx11.} +proc XGetWMColormapWindows*(para1: PDisplay, para2: TWindow, para3: PPWindow, + para4: Pcint): TStatus{.libx11.} +proc XSetWMColormapWindows*(para1: PDisplay, para2: TWindow, para3: PWindow, + para4: cint): TStatus{.libx11.} +proc XFreeStringList*(para1: PPchar){.libx11.} +proc XSetTransientForHint*(para1: PDisplay, para2: TWindow, para3: TWindow): cint{. + libx11.} +proc XActivateScreenSaver*(para1: PDisplay): cint{.libx11.} +proc XAddHost*(para1: PDisplay, para2: PXHostAddress): cint{.libx11.} +proc XAddHosts*(para1: PDisplay, para2: PXHostAddress, para3: cint): cint{. + libx11.} +proc XAddToExtensionList*(para1: PPXExtData, para2: PXExtData): cint{.libx11.} +proc XAddToSaveSet*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XAllocColor*(para1: PDisplay, para2: TColormap, para3: PXColor): TStatus{. + libx11.} +proc XAllocColorCells*(para1: PDisplay, para2: TColormap, para3: TBool, + para4: Pculong, para5: cuint, para6: Pculong, + para7: cuint): TStatus{.libx11.} +proc XAllocColorPlanes*(para1: PDisplay, para2: TColormap, para3: TBool, + para4: Pculong, para5: cint, para6: cint, para7: cint, + para8: cint, para9: Pculong, para10: Pculong, + para11: Pculong): TStatus{.libx11.} +proc XAllocNamedColor*(para1: PDisplay, para2: TColormap, para3: cstring, + para4: PXColor, para5: PXColor): TStatus{.libx11.} +proc XAllowEvents*(para1: PDisplay, para2: cint, para3: TTime): cint{.libx11.} +proc XAutoRepeatOff*(para1: PDisplay): cint{.libx11.} +proc XAutoRepeatOn*(para1: PDisplay): cint{.libx11.} +proc XBell*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XBitmapBitOrder*(para1: PDisplay): cint{.libx11.} +proc XBitmapPad*(para1: PDisplay): cint{.libx11.} +proc XBitmapUnit*(para1: PDisplay): cint{.libx11.} +proc XCellsOfScreen*(para1: PScreen): cint{.libx11.} +proc XChangeActivePointerGrab*(para1: PDisplay, para2: cuint, para3: TCursor, + para4: TTime): cint{.libx11.} +proc XChangeGC*(para1: PDisplay, para2: TGC, para3: culong, para4: PXGCValues): cint{. + libx11.} +proc XChangeKeyboardControl*(para1: PDisplay, para2: culong, + para3: PXKeyboardControl): cint{.libx11.} +proc XChangeKeyboardMapping*(para1: PDisplay, para2: cint, para3: cint, + para4: PKeySym, para5: cint): cint{.libx11.} +proc XChangePointerControl*(para1: PDisplay, para2: TBool, para3: TBool, + para4: cint, para5: cint, para6: cint): cint{.libx11.} +proc XChangeProperty*(para1: PDisplay, para2: TWindow, para3: TAtom, + para4: TAtom, para5: cint, para6: cint, para7: Pcuchar, + para8: cint): cint{.libx11.} +proc XChangeSaveSet*(para1: PDisplay, para2: TWindow, para3: cint): cint{.libx11.} +proc XChangeWindowAttributes*(para1: PDisplay, para2: TWindow, para3: culong, + para4: PXSetWindowAttributes): cint{.libx11.} +proc XCheckIfEvent*(para1: PDisplay, para2: PXEvent, para3: funcifevent, + para4: TXPointer): TBool{.libx11.} +proc XCheckMaskEvent*(para1: PDisplay, para2: clong, para3: PXEvent): TBool{. + libx11.} +proc XCheckTypedEvent*(para1: PDisplay, para2: cint, para3: PXEvent): TBool{. + libx11.} +proc XCheckTypedWindowEvent*(para1: PDisplay, para2: TWindow, para3: cint, + para4: PXEvent): TBool{.libx11.} +proc XCheckWindowEvent*(para1: PDisplay, para2: TWindow, para3: clong, + para4: PXEvent): TBool{.libx11.} +proc XCirculateSubwindows*(para1: PDisplay, para2: TWindow, para3: cint): cint{. + libx11.} +proc XCirculateSubwindowsDown*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XCirculateSubwindowsUp*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XClearArea*(para1: PDisplay, para2: TWindow, para3: cint, para4: cint, + para5: cuint, para6: cuint, para7: TBool): cint{.libx11.} +proc XClearWindow*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XCloseDisplay*(para1: PDisplay): cint{.libx11.} +proc XConfigureWindow*(para1: PDisplay, para2: TWindow, para3: cuint, + para4: PXWindowChanges): cint{.libx11.} +proc XConnectionNumber*(para1: PDisplay): cint{.libx11.} +proc XConvertSelection*(para1: PDisplay, para2: TAtom, para3: TAtom, + para4: TAtom, para5: TWindow, para6: TTime): cint{. + libx11.} +proc XCopyArea*(para1: PDisplay, para2: TDrawable, para3: TDrawable, para4: TGC, + para5: cint, para6: cint, para7: cuint, para8: cuint, + para9: cint, para10: cint): cint{.libx11.} +proc XCopyGC*(para1: PDisplay, para2: TGC, para3: culong, para4: TGC): cint{. + libx11.} +proc XCopyPlane*(para1: PDisplay, para2: TDrawable, para3: TDrawable, + para4: TGC, para5: cint, para6: cint, para7: cuint, + para8: cuint, para9: cint, para10: cint, para11: culong): cint{. + libx11.} +proc XDefaultDepth*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XDefaultDepthOfScreen*(para1: PScreen): cint{.libx11.} +proc XDefaultScreen*(para1: PDisplay): cint{.libx11.} +proc XDefineCursor*(para1: PDisplay, para2: TWindow, para3: TCursor): cint{. + libx11.} +proc XDeleteProperty*(para1: PDisplay, para2: TWindow, para3: TAtom): cint{. + libx11.} +proc XDestroyWindow*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XDestroySubwindows*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XDoesBackingStore*(para1: PScreen): cint{.libx11.} +proc XDoesSaveUnders*(para1: PScreen): TBool{.libx11.} +proc XDisableAccessControl*(para1: PDisplay): cint{.libx11.} +proc XDisplayCells*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XDisplayHeight*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XDisplayHeightMM*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XDisplayKeycodes*(para1: PDisplay, para2: Pcint, para3: Pcint): cint{. + libx11.} +proc XDisplayPlanes*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XDisplayWidth*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XDisplayWidthMM*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XDrawArc*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, + para5: cint, para6: cuint, para7: cuint, para8: cint, para9: cint): cint{. + libx11.} +proc XDrawArcs*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: PXArc, + para5: cint): cint{.libx11.} +proc XDrawImageString*(para1: PDisplay, para2: TDrawable, para3: TGC, + para4: cint, para5: cint, para6: cstring, para7: cint): cint{. + libx11.} +proc XDrawImageString16*(para1: PDisplay, para2: TDrawable, para3: TGC, + para4: cint, para5: cint, para6: PXChar2b, para7: cint): cint{. + libx11.} +proc XDrawLine*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, + para5: cint, para6: cint, para7: cint): cint{.libx11.} +proc XDrawLines*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: PXPoint, + para5: cint, para6: cint): cint{.libx11.} +proc XDrawPoint*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, + para5: cint): cint{.libx11.} +proc XDrawPoints*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: PXPoint, + para5: cint, para6: cint): cint{.libx11.} +proc XDrawRectangle*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, + para5: cint, para6: cuint, para7: cuint): cint{.libx11.} +proc XDrawRectangles*(para1: PDisplay, para2: TDrawable, para3: TGC, + para4: PXRectangle, para5: cint): cint{.libx11.} +proc XDrawSegments*(para1: PDisplay, para2: TDrawable, para3: TGC, + para4: PXSegment, para5: cint): cint{.libx11.} +proc XDrawString*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, + para5: cint, para6: cstring, para7: cint): cint{.libx11.} +proc XDrawString16*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, + para5: cint, para6: PXChar2b, para7: cint): cint{.libx11.} +proc XDrawText*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, + para5: cint, para6: PXTextItem, para7: cint): cint{.libx11.} +proc XDrawText16*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, + para5: cint, para6: PXTextItem16, para7: cint): cint{.libx11.} +proc XEnableAccessControl*(para1: PDisplay): cint{.libx11.} +proc XEventsQueued*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XFetchName*(para1: PDisplay, para2: TWindow, para3: PPchar): TStatus{. + libx11.} +proc XFillArc*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, + para5: cint, para6: cuint, para7: cuint, para8: cint, para9: cint): cint{. + libx11.} +proc XFillArcs*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: PXArc, + para5: cint): cint{.libx11.} +proc XFillPolygon*(para1: PDisplay, para2: TDrawable, para3: TGC, + para4: PXPoint, para5: cint, para6: cint, para7: cint): cint{. + libx11.} +proc XFillRectangle*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, + para5: cint, para6: cuint, para7: cuint): cint{.libx11.} +proc XFillRectangles*(para1: PDisplay, para2: TDrawable, para3: TGC, + para4: PXRectangle, para5: cint): cint{.libx11.} +proc XFlush*(para1: PDisplay): cint{.libx11.} +proc XForceScreenSaver*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XFree*(para1: pointer): cint{.libx11.} +proc XFreeColormap*(para1: PDisplay, para2: TColormap): cint{.libx11.} +proc XFreeColors*(para1: PDisplay, para2: TColormap, para3: Pculong, + para4: cint, para5: culong): cint{.libx11.} +proc XFreeCursor*(para1: PDisplay, para2: TCursor): cint{.libx11.} +proc XFreeExtensionList*(para1: PPchar): cint{.libx11.} +proc XFreeFont*(para1: PDisplay, para2: PXFontStruct): cint{.libx11.} +proc XFreeFontInfo*(para1: PPchar, para2: PXFontStruct, para3: cint): cint{. + libx11.} +proc XFreeFontNames*(para1: PPchar): cint{.libx11.} +proc XFreeFontPath*(para1: PPchar): cint{.libx11.} +proc XFreeGC*(para1: PDisplay, para2: TGC): cint{.libx11.} +proc XFreeModifiermap*(para1: PXModifierKeymap): cint{.libx11.} +proc XFreePixmap*(para1: PDisplay, para2: TPixmap): cint{.libx11.} +proc XGeometry*(para1: PDisplay, para2: cint, para3: cstring, para4: cstring, + para5: cuint, para6: cuint, para7: cuint, para8: cint, + para9: cint, para10: Pcint, para11: Pcint, para12: Pcint, + para13: Pcint): cint{.libx11.} +proc XGetErrorDatabaseText*(para1: PDisplay, para2: cstring, para3: cstring, + para4: cstring, para5: cstring, para6: cint): cint{. + libx11.} +proc XGetErrorText*(para1: PDisplay, para2: cint, para3: cstring, para4: cint): cint{. + libx11.} +proc XGetFontProperty*(para1: PXFontStruct, para2: TAtom, para3: Pculong): TBool{. + libx11.} +proc XGetGCValues*(para1: PDisplay, para2: TGC, para3: culong, para4: PXGCValues): TStatus{. + libx11.} +proc XGetGeometry*(para1: PDisplay, para2: TDrawable, para3: PWindow, + para4: Pcint, para5: Pcint, para6: Pcuint, para7: Pcuint, + para8: Pcuint, para9: Pcuint): TStatus{.libx11.} +proc XGetIconName*(para1: PDisplay, para2: TWindow, para3: PPchar): TStatus{. + libx11.} +proc XGetInputFocus*(para1: PDisplay, para2: PWindow, para3: Pcint): cint{. + libx11.} +proc XGetKeyboardControl*(para1: PDisplay, para2: PXKeyboardState): cint{.libx11.} +proc XGetPointerControl*(para1: PDisplay, para2: Pcint, para3: Pcint, + para4: Pcint): cint{.libx11.} +proc XGetPointerMapping*(para1: PDisplay, para2: Pcuchar, para3: cint): cint{. + libx11.} +proc XGetScreenSaver*(para1: PDisplay, para2: Pcint, para3: Pcint, para4: Pcint, + para5: Pcint): cint{.libx11.} +proc XGetTransientForHint*(para1: PDisplay, para2: TWindow, para3: PWindow): TStatus{. + libx11.} +proc XGetWindowProperty*(para1: PDisplay, para2: TWindow, para3: TAtom, + para4: clong, para5: clong, para6: TBool, para7: TAtom, + para8: PAtom, para9: Pcint, para10: Pculong, + para11: Pculong, para12: PPcuchar): cint{.libx11.} +proc XGetWindowAttributes*(para1: PDisplay, para2: TWindow, + para3: PXWindowAttributes): TStatus{.libx11.} +proc XGrabButton*(para1: PDisplay, para2: cuint, para3: cuint, para4: TWindow, + para5: TBool, para6: cuint, para7: cint, para8: cint, + para9: TWindow, para10: TCursor): cint{.libx11.} +proc XGrabKey*(para1: PDisplay, para2: cint, para3: cuint, para4: TWindow, + para5: TBool, para6: cint, para7: cint): cint{.libx11.} +proc XGrabKeyboard*(para1: PDisplay, para2: TWindow, para3: TBool, para4: cint, + para5: cint, para6: TTime): cint{.libx11.} +proc XGrabPointer*(para1: PDisplay, para2: TWindow, para3: TBool, para4: cuint, + para5: cint, para6: cint, para7: TWindow, para8: TCursor, + para9: TTime): cint{.libx11.} +proc XGrabServer*(para1: PDisplay): cint{.libx11.} +proc XHeightMMOfScreen*(para1: PScreen): cint{.libx11.} +proc XHeightOfScreen*(para1: PScreen): cint{.libx11.} +proc XIfEvent*(para1: PDisplay, para2: PXEvent, para3: funcifevent, + para4: TXPointer): cint{.libx11.} +proc XImageByteOrder*(para1: PDisplay): cint{.libx11.} +proc XInstallColormap*(para1: PDisplay, para2: TColormap): cint{.libx11.} +proc XKeysymToKeycode*(para1: PDisplay, para2: TKeySym): TKeyCode{.libx11.} +proc XKillClient*(para1: PDisplay, para2: TXID): cint{.libx11.} +proc XLookupColor*(para1: PDisplay, para2: TColormap, para3: cstring, + para4: PXColor, para5: PXColor): TStatus{.libx11.} +proc XLowerWindow*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XMapRaised*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XMapSubwindows*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XMapWindow*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XMaskEvent*(para1: PDisplay, para2: clong, para3: PXEvent): cint{.libx11.} +proc XMaxCmapsOfScreen*(para1: PScreen): cint{.libx11.} +proc XMinCmapsOfScreen*(para1: PScreen): cint{.libx11.} +proc XMoveResizeWindow*(para1: PDisplay, para2: TWindow, para3: cint, + para4: cint, para5: cuint, para6: cuint): cint{.libx11.} +proc XMoveWindow*(para1: PDisplay, para2: TWindow, para3: cint, para4: cint): cint{. + libx11.} +proc XNextEvent*(para1: PDisplay, para2: PXEvent): cint{.libx11.} +proc XNoOp*(para1: PDisplay): cint{.libx11.} +proc XParseColor*(para1: PDisplay, para2: TColormap, para3: cstring, + para4: PXColor): TStatus{.libx11.} +proc XParseGeometry*(para1: cstring, para2: Pcint, para3: Pcint, para4: Pcuint, + para5: Pcuint): cint{.libx11.} +proc XPeekEvent*(para1: PDisplay, para2: PXEvent): cint{.libx11.} +proc XPeekIfEvent*(para1: PDisplay, para2: PXEvent, para3: funcifevent, + para4: TXPointer): cint{.libx11.} +proc XPending*(para1: PDisplay): cint{.libx11.} +proc XPlanesOfScreen*(para1: PScreen): cint{.libx11.} +proc XProtocolRevision*(para1: PDisplay): cint{.libx11.} +proc XProtocolVersion*(para1: PDisplay): cint{.libx11.} +proc XPutBackEvent*(para1: PDisplay, para2: PXEvent): cint{.libx11.} +proc XPutImage*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: PXImage, + para5: cint, para6: cint, para7: cint, para8: cint, + para9: cuint, para10: cuint): cint{.libx11.} +proc XQLength*(para1: PDisplay): cint{.libx11.} +proc XQueryBestCursor*(para1: PDisplay, para2: TDrawable, para3: cuint, + para4: cuint, para5: Pcuint, para6: Pcuint): TStatus{. + libx11.} +proc XQueryBestSize*(para1: PDisplay, para2: cint, para3: TDrawable, + para4: cuint, para5: cuint, para6: Pcuint, para7: Pcuint): TStatus{. + libx11.} +proc XQueryBestStipple*(para1: PDisplay, para2: TDrawable, para3: cuint, + para4: cuint, para5: Pcuint, para6: Pcuint): TStatus{. + libx11.} +proc XQueryBestTile*(para1: PDisplay, para2: TDrawable, para3: cuint, + para4: cuint, para5: Pcuint, para6: Pcuint): TStatus{. + libx11.} +proc XQueryColor*(para1: PDisplay, para2: TColormap, para3: PXColor): cint{. + libx11.} +proc XQueryColors*(para1: PDisplay, para2: TColormap, para3: PXColor, + para4: cint): cint{.libx11.} +proc XQueryExtension*(para1: PDisplay, para2: cstring, para3: Pcint, + para4: Pcint, para5: Pcint): TBool{.libx11.} + #? +proc XQueryKeymap*(para1: PDisplay, para2: chararr32): cint{.libx11.} +proc XQueryPointer*(para1: PDisplay, para2: TWindow, para3: PWindow, + para4: PWindow, para5: Pcint, para6: Pcint, para7: Pcint, + para8: Pcint, para9: Pcuint): TBool{.libx11.} +proc XQueryTextExtents*(para1: PDisplay, para2: TXID, para3: cstring, + para4: cint, para5: Pcint, para6: Pcint, para7: Pcint, + para8: PXCharStruct): cint{.libx11.} +proc XQueryTextExtents16*(para1: PDisplay, para2: TXID, para3: PXChar2b, + para4: cint, para5: Pcint, para6: Pcint, para7: Pcint, + para8: PXCharStruct): cint{.libx11.} +proc XQueryTree*(para1: PDisplay, para2: TWindow, para3: PWindow, + para4: PWindow, para5: PPWindow, para6: Pcuint): TStatus{. + libx11.} +proc XRaiseWindow*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XReadBitmapFile*(para1: PDisplay, para2: TDrawable, para3: cstring, + para4: Pcuint, para5: Pcuint, para6: PPixmap, + para7: Pcint, para8: Pcint): cint{.libx11.} +proc XReadBitmapFileData*(para1: cstring, para2: Pcuint, para3: Pcuint, + para4: PPcuchar, para5: Pcint, para6: Pcint): cint{. + libx11.} +proc XRebindKeysym*(para1: PDisplay, para2: TKeySym, para3: PKeySym, + para4: cint, para5: Pcuchar, para6: cint): cint{.libx11.} +proc XRecolorCursor*(para1: PDisplay, para2: TCursor, para3: PXColor, + para4: PXColor): cint{.libx11.} +proc XRefreshKeyboardMapping*(para1: PXMappingEvent): cint{.libx11.} +proc XRemoveFromSaveSet*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XRemoveHost*(para1: PDisplay, para2: PXHostAddress): cint{.libx11.} +proc XRemoveHosts*(para1: PDisplay, para2: PXHostAddress, para3: cint): cint{. + libx11.} +proc XReparentWindow*(para1: PDisplay, para2: TWindow, para3: TWindow, + para4: cint, para5: cint): cint{.libx11.} +proc XResetScreenSaver*(para1: PDisplay): cint{.libx11.} +proc XResizeWindow*(para1: PDisplay, para2: TWindow, para3: cuint, para4: cuint): cint{. + libx11.} +proc XRestackWindows*(para1: PDisplay, para2: PWindow, para3: cint): cint{. + libx11.} +proc XRotateBuffers*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XRotateWindowProperties*(para1: PDisplay, para2: TWindow, para3: PAtom, + para4: cint, para5: cint): cint{.libx11.} +proc XScreenCount*(para1: PDisplay): cint{.libx11.} +proc XSelectInput*(para1: PDisplay, para2: TWindow, para3: clong): cint{.libx11.} +proc XSendEvent*(para1: PDisplay, para2: TWindow, para3: TBool, para4: clong, + para5: PXEvent): TStatus{.libx11.} +proc XSetAccessControl*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XSetArcMode*(para1: PDisplay, para2: TGC, para3: cint): cint{.libx11.} +proc XSetBackground*(para1: PDisplay, para2: TGC, para3: culong): cint{.libx11.} +proc XSetClipMask*(para1: PDisplay, para2: TGC, para3: TPixmap): cint{.libx11.} +proc XSetClipOrigin*(para1: PDisplay, para2: TGC, para3: cint, para4: cint): cint{. + libx11.} +proc XSetClipRectangles*(para1: PDisplay, para2: TGC, para3: cint, para4: cint, + para5: PXRectangle, para6: cint, para7: cint): cint{. + libx11.} +proc XSetCloseDownMode*(para1: PDisplay, para2: cint): cint{.libx11.} +proc XSetCommand*(para1: PDisplay, para2: TWindow, para3: PPchar, para4: cint): cint{. + libx11.} +proc XSetDashes*(para1: PDisplay, para2: TGC, para3: cint, para4: cstring, + para5: cint): cint{.libx11.} +proc XSetFillRule*(para1: PDisplay, para2: TGC, para3: cint): cint{.libx11.} +proc XSetFillStyle*(para1: PDisplay, para2: TGC, para3: cint): cint{.libx11.} +proc XSetFont*(para1: PDisplay, para2: TGC, para3: TFont): cint{.libx11.} +proc XSetFontPath*(para1: PDisplay, para2: PPchar, para3: cint): cint{.libx11.} +proc XSetForeground*(para1: PDisplay, para2: TGC, para3: culong): cint{.libx11.} +proc XSetFunction*(para1: PDisplay, para2: TGC, para3: cint): cint{.libx11.} +proc XSetGraphicsExposures*(para1: PDisplay, para2: TGC, para3: TBool): cint{. + libx11.} +proc XSetIconName*(para1: PDisplay, para2: TWindow, para3: cstring): cint{. + libx11.} +proc XSetInputFocus*(para1: PDisplay, para2: TWindow, para3: cint, para4: TTime): cint{. + libx11.} +proc XSetLineAttributes*(para1: PDisplay, para2: TGC, para3: cuint, para4: cint, + para5: cint, para6: cint): cint{.libx11.} +proc XSetModifierMapping*(para1: PDisplay, para2: PXModifierKeymap): cint{. + libx11.} +proc XSetPlaneMask*(para1: PDisplay, para2: TGC, para3: culong): cint{.libx11.} +proc XSetPointerMapping*(para1: PDisplay, para2: Pcuchar, para3: cint): cint{. + libx11.} +proc XSetScreenSaver*(para1: PDisplay, para2: cint, para3: cint, para4: cint, + para5: cint): cint{.libx11.} +proc XSetSelectionOwner*(para1: PDisplay, para2: TAtom, para3: TWindow, + para4: TTime): cint{.libx11.} +proc XSetState*(para1: PDisplay, para2: TGC, para3: culong, para4: culong, + para5: cint, para6: culong): cint{.libx11.} +proc XSetStipple*(para1: PDisplay, para2: TGC, para3: TPixmap): cint{.libx11.} +proc XSetSubwindowMode*(para1: PDisplay, para2: TGC, para3: cint): cint{.libx11.} +proc XSetTSOrigin*(para1: PDisplay, para2: TGC, para3: cint, para4: cint): cint{. + libx11.} +proc XSetTile*(para1: PDisplay, para2: TGC, para3: TPixmap): cint{.libx11.} +proc XSetWindowBackground*(para1: PDisplay, para2: TWindow, para3: culong): cint{. + libx11.} +proc XSetWindowBackgroundPixmap*(para1: PDisplay, para2: TWindow, para3: TPixmap): cint{. + libx11.} +proc XSetWindowBorder*(para1: PDisplay, para2: TWindow, para3: culong): cint{. + libx11.} +proc XSetWindowBorderPixmap*(para1: PDisplay, para2: TWindow, para3: TPixmap): cint{. + libx11.} +proc XSetWindowBorderWidth*(para1: PDisplay, para2: TWindow, para3: cuint): cint{. + libx11.} +proc XSetWindowColormap*(para1: PDisplay, para2: TWindow, para3: TColormap): cint{. + libx11.} +proc XStoreBuffer*(para1: PDisplay, para2: cstring, para3: cint, para4: cint): cint{. + libx11.} +proc XStoreBytes*(para1: PDisplay, para2: cstring, para3: cint): cint{.libx11.} +proc XStoreColor*(para1: PDisplay, para2: TColormap, para3: PXColor): cint{. + libx11.} +proc XStoreColors*(para1: PDisplay, para2: TColormap, para3: PXColor, + para4: cint): cint{.libx11.} +proc XStoreName*(para1: PDisplay, para2: TWindow, para3: cstring): cint{.libx11.} +proc XStoreNamedColor*(para1: PDisplay, para2: TColormap, para3: cstring, + para4: culong, para5: cint): cint{.libx11.} +proc XSync*(para1: PDisplay, para2: TBool): cint{.libx11.} +proc XTextExtents*(para1: PXFontStruct, para2: cstring, para3: cint, + para4: Pcint, para5: Pcint, para6: Pcint, para7: PXCharStruct): cint{. + libx11.} +proc XTextExtents16*(para1: PXFontStruct, para2: PXChar2b, para3: cint, + para4: Pcint, para5: Pcint, para6: Pcint, + para7: PXCharStruct): cint{.libx11.} +proc XTextWidth*(para1: PXFontStruct, para2: cstring, para3: cint): cint{.libx11.} +proc XTextWidth16*(para1: PXFontStruct, para2: PXChar2b, para3: cint): cint{. + libx11.} +proc XTranslateCoordinates*(para1: PDisplay, para2: TWindow, para3: TWindow, + para4: cint, para5: cint, para6: Pcint, + para7: Pcint, para8: PWindow): TBool{.libx11.} +proc XUndefineCursor*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XUngrabButton*(para1: PDisplay, para2: cuint, para3: cuint, para4: TWindow): cint{. + libx11.} +proc XUngrabKey*(para1: PDisplay, para2: cint, para3: cuint, para4: TWindow): cint{. + libx11.} +proc XUngrabKeyboard*(para1: PDisplay, para2: TTime): cint{.libx11.} +proc XUngrabPointer*(para1: PDisplay, para2: TTime): cint{.libx11.} +proc XUngrabServer*(para1: PDisplay): cint{.libx11.} +proc XUninstallColormap*(para1: PDisplay, para2: TColormap): cint{.libx11.} +proc XUnloadFont*(para1: PDisplay, para2: TFont): cint{.libx11.} +proc XUnmapSubwindows*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XUnmapWindow*(para1: PDisplay, para2: TWindow): cint{.libx11.} +proc XVendorRelease*(para1: PDisplay): cint{.libx11.} +proc XWarpPointer*(para1: PDisplay, para2: TWindow, para3: TWindow, para4: cint, + para5: cint, para6: cuint, para7: cuint, para8: cint, + para9: cint): cint{.libx11.} +proc XWidthMMOfScreen*(para1: PScreen): cint{.libx11.} +proc XWidthOfScreen*(para1: PScreen): cint{.libx11.} +proc XWindowEvent*(para1: PDisplay, para2: TWindow, para3: clong, para4: PXEvent): cint{. + libx11.} +proc XWriteBitmapFile*(para1: PDisplay, para2: cstring, para3: TPixmap, + para4: cuint, para5: cuint, para6: cint, para7: cint): cint{. + libx11.} +proc XSupportsLocale*(): TBool{.libx11.} +proc XSetLocaleModifiers*(para1: cstring): cstring{.libx11.} +proc XOpenOM*(para1: PDisplay, para2: PXrmHashBucketRec, para3: cstring, + para4: cstring): TXOM{.libx11.} +proc XCloseOM*(para1: TXOM): TStatus{.libx11.} +proc XSetOMValues*(para1: TXOM): cstring{.varargs, libx11.} +proc XGetOMValues*(para1: TXOM): cstring{.varargs, libx11.} +proc XDisplayOfOM*(para1: TXOM): PDisplay{.libx11.} +proc XLocaleOfOM*(para1: TXOM): cstring{.libx11.} +proc XCreateOC*(para1: TXOM): TXOC{.varargs, libx11.} +proc XDestroyOC*(para1: TXOC){.libx11.} +proc XOMOfOC*(para1: TXOC): TXOM{.libx11.} +proc XSetOCValues*(para1: TXOC): cstring{.varargs, libx11.} +proc XGetOCValues*(para1: TXOC): cstring{.varargs, libx11.} +proc XCreateFontSet*(para1: PDisplay, para2: cstring, para3: PPPchar, + para4: Pcint, para5: PPchar): TXFontSet{.libx11.} +proc XFreeFontSet*(para1: PDisplay, para2: TXFontSet){.libx11.} +proc XFontsOfFontSet*(para1: TXFontSet, para2: PPPXFontStruct, para3: PPPchar): cint{. + libx11.} +proc XBaseFontNameListOfFontSet*(para1: TXFontSet): cstring{.libx11.} +proc XLocaleOfFontSet*(para1: TXFontSet): cstring{.libx11.} +proc XContextDependentDrawing*(para1: TXFontSet): TBool{.libx11.} +proc XDirectionalDependentDrawing*(para1: TXFontSet): TBool{.libx11.} +proc XContextualDrawing*(para1: TXFontSet): TBool{.libx11.} +proc XExtentsOfFontSet*(para1: TXFontSet): PXFontSetExtents{.libx11.} +proc XmbTextEscapement*(para1: TXFontSet, para2: cstring, para3: cint): cint{. + libx11.} +proc XwcTextEscapement*(para1: TXFontSet, para2: PWideChar, para3: cint): cint{. + libx11.} +proc Xutf8TextEscapement*(para1: TXFontSet, para2: cstring, para3: cint): cint{. + libx11.} +proc XmbTextExtents*(para1: TXFontSet, para2: cstring, para3: cint, + para4: PXRectangle, para5: PXRectangle): cint{.libx11.} +proc XwcTextExtents*(para1: TXFontSet, para2: PWideChar, para3: cint, + para4: PXRectangle, para5: PXRectangle): cint{.libx11.} +proc Xutf8TextExtents*(para1: TXFontSet, para2: cstring, para3: cint, + para4: PXRectangle, para5: PXRectangle): cint{.libx11.} +proc XmbTextPerCharExtents*(para1: TXFontSet, para2: cstring, para3: cint, + para4: PXRectangle, para5: PXRectangle, para6: cint, + para7: Pcint, para8: PXRectangle, para9: PXRectangle): TStatus{. + libx11.} +proc XwcTextPerCharExtents*(para1: TXFontSet, para2: PWideChar, para3: cint, + para4: PXRectangle, para5: PXRectangle, para6: cint, + para7: Pcint, para8: PXRectangle, para9: PXRectangle): TStatus{. + libx11.} +proc Xutf8TextPerCharExtents*(para1: TXFontSet, para2: cstring, para3: cint, + para4: PXRectangle, para5: PXRectangle, + para6: cint, para7: Pcint, para8: PXRectangle, + para9: PXRectangle): TStatus{.libx11.} +proc XmbDrawText*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, + para5: cint, para6: PXmbTextItem, para7: cint){.libx11.} +proc XwcDrawText*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, + para5: cint, para6: PXwcTextItem, para7: cint){.libx11.} +proc Xutf8DrawText*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, + para5: cint, para6: PXmbTextItem, para7: cint){.libx11.} +proc XmbDrawString*(para1: PDisplay, para2: TDrawable, para3: TXFontSet, + para4: TGC, para5: cint, para6: cint, para7: cstring, + para8: cint){.libx11.} +proc XwcDrawString*(para1: PDisplay, para2: TDrawable, para3: TXFontSet, + para4: TGC, para5: cint, para6: cint, para7: PWideChar, + para8: cint){.libx11.} +proc Xutf8DrawString*(para1: PDisplay, para2: TDrawable, para3: TXFontSet, + para4: TGC, para5: cint, para6: cint, para7: cstring, + para8: cint){.libx11.} +proc XmbDrawImageString*(para1: PDisplay, para2: TDrawable, para3: TXFontSet, + para4: TGC, para5: cint, para6: cint, para7: cstring, + para8: cint){.libx11.} +proc XwcDrawImageString*(para1: PDisplay, para2: TDrawable, para3: TXFontSet, + para4: TGC, para5: cint, para6: cint, para7: PWideChar, + para8: cint){.libx11.} +proc Xutf8DrawImageString*(para1: PDisplay, para2: TDrawable, para3: TXFontSet, + para4: TGC, para5: cint, para6: cint, para7: cstring, + para8: cint){.libx11.} +proc XOpenIM*(para1: PDisplay, para2: PXrmHashBucketRec, para3: cstring, + para4: cstring): TXIM{.libx11.} +proc XCloseIM*(para1: TXIM): TStatus{.libx11.} +proc XGetIMValues*(para1: TXIM): cstring{.varargs, libx11.} +proc XSetIMValues*(para1: TXIM): cstring{.varargs, libx11.} +proc XDisplayOfIM*(para1: TXIM): PDisplay{.libx11.} +proc XLocaleOfIM*(para1: TXIM): cstring{.libx11.} +proc XCreateIC*(para1: TXIM): TXIC{.varargs, libx11.} +proc XDestroyIC*(para1: TXIC){.libx11.} +proc XSetICFocus*(para1: TXIC){.libx11.} +proc XUnsetICFocus*(para1: TXIC){.libx11.} +proc XwcResetIC*(para1: TXIC): PWideChar{.libx11.} +proc XmbResetIC*(para1: TXIC): cstring{.libx11.} +proc Xutf8ResetIC*(para1: TXIC): cstring{.libx11.} +proc XSetICValues*(para1: TXIC): cstring{.varargs, libx11.} +proc XGetICValues*(para1: TXIC): cstring{.varargs, libx11.} +proc XIMOfIC*(para1: TXIC): TXIM{.libx11.} +proc XFilterEvent*(para1: PXEvent, para2: TWindow): TBool{.libx11.} +proc XmbLookupString*(para1: TXIC, para2: PXKeyPressedEvent, para3: cstring, + para4: cint, para5: PKeySym, para6: PStatus): cint{.libx11.} +proc XwcLookupString*(para1: TXIC, para2: PXKeyPressedEvent, para3: PWideChar, + para4: cint, para5: PKeySym, para6: PStatus): cint{.libx11.} +proc Xutf8LookupString*(para1: TXIC, para2: PXKeyPressedEvent, para3: cstring, + para4: cint, para5: PKeySym, para6: PStatus): cint{. + libx11.} +proc XVaCreateNestedList*(unused: cint): TXVaNestedList{.varargs, libx11.} +proc XRegisterIMInstantiateCallback*(para1: PDisplay, para2: PXrmHashBucketRec, + para3: cstring, para4: cstring, + para5: TXIDProc, para6: TXPointer): TBool{. + libx11.} +proc XUnregisterIMInstantiateCallback*(para1: PDisplay, + para2: PXrmHashBucketRec, para3: cstring, + para4: cstring, para5: TXIDProc, + para6: TXPointer): TBool{.libx11.} +type + TXConnectionWatchProc* = proc (para1: PDisplay, para2: TXPointer, para3: cint, + para4: TBool, para5: PXPointer){.cdecl.} + +proc XInternalConnectionNumbers*(para1: PDisplay, para2: PPcint, para3: Pcint): TStatus{. + libx11.} +proc XProcessInternalConnection*(para1: PDisplay, para2: cint){.libx11.} +proc XAddConnectionWatch*(para1: PDisplay, para2: TXConnectionWatchProc, + para3: TXPointer): TStatus{.libx11.} +proc XRemoveConnectionWatch*(para1: PDisplay, para2: TXConnectionWatchProc, + para3: TXPointer){.libx11.} +proc XSetAuthorization*(para1: cstring, para2: cint, para3: cstring, para4: cint){. + libx11.} + # + # _Xmbtowc? + # _Xwctomb? + # +#when defined(MACROS): +proc ConnectionNumber*(dpy: PDisplay): cint +proc RootWindow*(dpy: PDisplay, scr: cint): TWindow +proc DefaultScreen*(dpy: PDisplay): cint +proc DefaultRootWindow*(dpy: PDisplay): TWindow +proc DefaultVisual*(dpy: PDisplay, scr: cint): PVisual +proc DefaultGC*(dpy: PDisplay, scr: cint): TGC +proc BlackPixel*(dpy: PDisplay, scr: cint): culong +proc WhitePixel*(dpy: PDisplay, scr: cint): culong +proc QLength*(dpy: PDisplay): cint +proc DisplayWidth*(dpy: PDisplay, scr: cint): cint +proc DisplayHeight*(dpy: PDisplay, scr: cint): cint +proc DisplayWidthMM*(dpy: PDisplay, scr: cint): cint +proc DisplayHeightMM*(dpy: PDisplay, scr: cint): cint +proc DisplayPlanes*(dpy: PDisplay, scr: cint): cint +proc DisplayCells*(dpy: PDisplay, scr: cint): cint +proc ScreenCount*(dpy: PDisplay): cint +proc ServerVendor*(dpy: PDisplay): cstring +proc ProtocolVersion*(dpy: PDisplay): cint +proc ProtocolRevision*(dpy: PDisplay): cint +proc VendorRelease*(dpy: PDisplay): cint +proc DisplayString*(dpy: PDisplay): cstring +proc DefaultDepth*(dpy: PDisplay, scr: cint): cint +proc DefaultColormap*(dpy: PDisplay, scr: cint): TColormap +proc BitmapUnit*(dpy: PDisplay): cint +proc BitmapBitOrder*(dpy: PDisplay): cint +proc BitmapPad*(dpy: PDisplay): cint +proc ImageByteOrder*(dpy: PDisplay): cint +proc NextRequest*(dpy: PDisplay): culong +proc LastKnownRequestProcessed*(dpy: PDisplay): culong +proc ScreenOfDisplay*(dpy: PDisplay, scr: cint): PScreen +proc DefaultScreenOfDisplay*(dpy: PDisplay): PScreen +proc DisplayOfScreen*(s: PScreen): PDisplay +proc RootWindowOfScreen*(s: PScreen): TWindow +proc BlackPixelOfScreen*(s: PScreen): culong +proc WhitePixelOfScreen*(s: PScreen): culong +proc DefaultColormapOfScreen*(s: PScreen): TColormap +proc DefaultDepthOfScreen*(s: PScreen): cint +proc DefaultGCOfScreen*(s: PScreen): TGC +proc DefaultVisualOfScreen*(s: PScreen): PVisual +proc WidthOfScreen*(s: PScreen): cint +proc HeightOfScreen*(s: PScreen): cint +proc WidthMMOfScreen*(s: PScreen): cint +proc HeightMMOfScreen*(s: PScreen): cint +proc PlanesOfScreen*(s: PScreen): cint +proc CellsOfScreen*(s: PScreen): cint +proc MinCmapsOfScreen*(s: PScreen): cint +proc MaxCmapsOfScreen*(s: PScreen): cint +proc DoesSaveUnders*(s: PScreen): TBool +proc DoesBackingStore*(s: PScreen): cint +proc EventMaskOfScreen*(s: PScreen): clong +proc XAllocID*(dpy: PDisplay): TXID +# implementation + +#when defined(MACROS): +template privDisp : expr = cast[PXPrivDisplay](dpy) + +proc ConnectionNumber(dpy: PDisplay): cint = + privDisp.fd + +proc RootWindow(dpy: PDisplay, scr: cint): TWindow = + ScreenOfDisplay(dpy, scr).root + +proc DefaultScreen(dpy: PDisplay): cint = + privDisp.default_screen + +proc DefaultRootWindow(dpy: PDisplay): TWindow = + ScreenOfDisplay(dpy, DefaultScreen(dpy)).root + +proc DefaultVisual(dpy: PDisplay, scr: cint): PVisual = + ScreenOfDisplay(dpy, scr).root_visual + +proc DefaultGC(dpy: PDisplay, scr: cint): TGC = + ScreenOfDisplay(dpy, scr).default_gc + +proc BlackPixel(dpy: PDisplay, scr: cint): culong = + ScreenOfDisplay(dpy, scr).black_pixel + +proc WhitePixel(dpy: PDisplay, scr: cint): culong = + ScreenOfDisplay(dpy, scr).white_pixel + +proc QLength(dpy: PDisplay): cint = + privDisp.qlen + +proc DisplayWidth(dpy: PDisplay, scr: cint): cint = + ScreenOfDisplay(dpy, scr).width + +proc DisplayHeight(dpy: PDisplay, scr: cint): cint = + ScreenOfDisplay(dpy, scr).height + +proc DisplayWidthMM(dpy: PDisplay, scr: cint): cint = + ScreenOfDisplay(dpy, scr).mwidth + +proc DisplayHeightMM(dpy: PDisplay, scr: cint): cint = + ScreenOfDisplay(dpy, scr).mheight + +proc DisplayPlanes(dpy: PDisplay, scr: cint): cint = + ScreenOfDisplay(dpy, scr).root_depth + +proc DisplayCells(dpy: PDisplay, scr: cint): cint = + DefaultVisual(dpy, scr).map_entries + +proc ScreenCount(dpy: PDisplay): cint = + privDisp.nscreens + +proc ServerVendor(dpy: PDisplay): cstring = + privDisp.vendor + +proc ProtocolVersion(dpy: PDisplay): cint = + privDisp.proto_major_version + +proc ProtocolRevision(dpy: PDisplay): cint = + privDisp.proto_minor_version + +proc VendorRelease(dpy: PDisplay): cint = + privDisp.release + +proc DisplayString(dpy: PDisplay): cstring = + privDisp.display_name + +proc DefaultDepth(dpy: PDisplay, scr: cint): cint = + ScreenOfDisplay(dpy, scr).root_depth + +proc DefaultColormap(dpy: PDisplay, scr: cint): TColormap = + ScreenOfDisplay(dpy, scr).cmap + +proc BitmapUnit(dpy: PDisplay): cint = + privDisp.bitmap_unit + +proc BitmapBitOrder(dpy: PDisplay): cint = + privDisp.bitmap_bit_order + +proc BitmapPad(dpy: PDisplay): cint = + privDisp.bitmap_pad + +proc ImageByteOrder(dpy: PDisplay): cint = + privDisp.byte_order + +proc NextRequest(dpy: PDisplay): culong = + privDisp.request + 1.culong + +proc LastKnownRequestProcessed(dpy: PDisplay): culong = + privDisp.last_request_read + +# from fowltek/pointer_arithm, required for ScreenOfDisplay() +proc offset[A] (some: ptr A; b: int): ptr A = + cast[ptr A](cast[int](some) + (b * sizeof(A))) +proc ScreenOfDisplay(dpy: PDisplay, scr: cint): PScreen = + #addr(((privDisp.screens)[scr])) + privDisp.screens.offset(scr.int) + +proc DefaultScreenOfDisplay(dpy: PDisplay): PScreen = + ScreenOfDisplay(dpy, DefaultScreen(dpy)) + +proc DisplayOfScreen(s: PScreen): PDisplay = + s.display + +proc RootWindowOfScreen(s: PScreen): TWindow = + s.root + +proc BlackPixelOfScreen(s: PScreen): culong = + s.black_pixel + +proc WhitePixelOfScreen(s: PScreen): culong = + s.white_pixel + +proc DefaultColormapOfScreen(s: PScreen): TColormap = + s.cmap + +proc DefaultDepthOfScreen(s: PScreen): cint = + s.root_depth + +proc DefaultGCOfScreen(s: PScreen): TGC = + s.default_gc + +proc DefaultVisualOfScreen(s: PScreen): PVisual = + s.root_visual + +proc WidthOfScreen(s: PScreen): cint = + s.width + +proc HeightOfScreen(s: PScreen): cint = + s.height + +proc WidthMMOfScreen(s: PScreen): cint = + s.mwidth + +proc HeightMMOfScreen(s: PScreen): cint = + s.mheight + +proc PlanesOfScreen(s: PScreen): cint = + s.root_depth + +proc CellsOfScreen(s: PScreen): cint = + DefaultVisualOfScreen(s).map_entries + +proc MinCmapsOfScreen(s: PScreen): cint = + s.min_maps + +proc MaxCmapsOfScreen(s: PScreen): cint = + s.max_maps + +proc DoesSaveUnders(s: PScreen): TBool = + s.save_unders + +proc DoesBackingStore(s: PScreen): cint = + s.backing_store + +proc EventMaskOfScreen(s: PScreen): clong = + s.root_input_mask + +proc XAllocID(dpy: PDisplay): TXID = + privDisp.resource_alloc(dpy) diff --git a/tests/deps/x11-1.0/xrandr.nim b/tests/deps/x11-1.0/xrandr.nim new file mode 100644 index 000000000..ee6f1705b --- /dev/null +++ b/tests/deps/x11-1.0/xrandr.nim @@ -0,0 +1,194 @@ +# +# $XFree86: xc/lib/Xrandr/Xrandr.h,v 1.9 2002/09/29 23:39:44 keithp Exp $ +# +# Copyright (C) 2000 Compaq Computer Corporation, Inc. +# Copyright (C) 2002 Hewlett-Packard Company, Inc. +# +# Permission to use, copy, modify, distribute, and sell this software and its +# documentation for any purpose is hereby granted without fee, provided that +# the above copyright notice appear in all copies and that both that +# copyright notice and this permission notice appear in supporting +# documentation, and that the name of Compaq not be used in advertising or +# publicity pertaining to distribution of the software without specific, +# written prior permission. HP makes no representations about the +# suitability of this software for any purpose. It is provided "as is" +# without express or implied warranty. +# +# HP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL COMPAQ +# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +# +# Author: Jim Gettys, HP Labs, HP. +# + +import + x, xlib + +const + libXrandr* = "libXrandr.so" + +# * $XFree86: xc/include/extensions/randr.h,v 1.4 2001/11/24 07:24:58 keithp Exp $ +# * +# * Copyright (C) 2000, Compaq Computer Corporation, +# * Copyright (C) 2002, Hewlett Packard, Inc. +# * +# * Permission to use, copy, modify, distribute, and sell this software and its +# * documentation for any purpose is hereby granted without fee, provided that +# * the above copyright notice appear in all copies and that both that +# * copyright notice and this permission notice appear in supporting +# * documentation, and that the name of Compaq or HP not be used in advertising +# * or publicity pertaining to distribution of the software without specific, +# * written prior permission. HP makes no representations about the +# * suitability of this software for any purpose. It is provided "as is" +# * without express or implied warranty. +# * +# * HP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL +# * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL HP +# * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +# * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +# * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +# * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +# * +# * Author: Jim Gettys, HP Labs, Hewlett-Packard, Inc. +# * + +type + PRotation* = ptr TRotation + TRotation* = cushort + PSizeID* = ptr TSizeID + TSizeID* = cushort + PSubpixelOrder* = ptr TSubpixelOrder + TSubpixelOrder* = cushort + +const + RANDR_NAME* = "RANDR" + RANDR_MAJOR* = 1 + RANDR_MINOR* = 1 + RRNumberErrors* = 0 + RRNumberEvents* = 1 + constX_RRQueryVersion* = 0 # we skip 1 to make old clients fail pretty immediately + X_RROldGetScreenInfo* = 1 + X_RR1_0SetScreenConfig* = 2 # V1.0 apps share the same set screen config request id + constX_RRSetScreenConfig* = 2 + X_RROldScreenChangeSelectInput* = 3 # 3 used to be ScreenChangeSelectInput; deprecated + constX_RRSelectInput* = 4 + constX_RRGetScreenInfo* = 5 # used in XRRSelectInput + RRScreenChangeNotifyMask* = 1 shl 0 + RRScreenChangeNotify* = 0 # used in the rotation field; rotation and reflection in 0.1 proto. + RR_Rotate_0* = 1 + RR_Rotate_90* = 2 + RR_Rotate_180* = 4 + RR_Rotate_270* = 8 # new in 1.0 protocol, to allow reflection of screen + RR_Reflect_X* = 16 + RR_Reflect_Y* = 32 + RRSetConfigSuccess* = 0 + RRSetConfigInvalidConfigTime* = 1 + RRSetConfigInvalidTime* = 2 + RRSetConfigFailed* = 3 + +type + PXRRScreenSize* = ptr TXRRScreenSize + TXRRScreenSize*{.final.} = object # + # Events. + # + width*, height*: cint + mwidth*, mheight*: cint + + TXRRScreenChangeNotifyEvent*{.final.} = object # internal representation is private to the library + typ*: cint # event base + serial*: culong # # of last request processed by server + send_event*: TBool # true if this came from a SendEvent request + display*: PDisplay # Display the event was read from + window*: TWindow # window which selected for this event + root*: TWindow # Root window for changed screen + timestamp*: TTime # when the screen change occurred + config_timestamp*: TTime # when the last configuration change + size_index*: TSizeID + subpixel_order*: TSubpixelOrder + rotation*: TRotation + width*: cint + height*: cint + mwidth*: cint + mheight*: cint + + PXRRScreenConfiguration* = ptr TXRRScreenConfiguration + TXRRScreenConfiguration*{.final.} = object + +proc XRRQueryExtension*(dpy: PDisplay, event_basep, error_basep: Pcint): TBool{. + cdecl, dynlib: libXrandr, importc.} +proc XRRQueryVersion*(dpy: PDisplay, major_versionp: Pcint, + minor_versionp: Pcint): TStatus{.cdecl, dynlib: libXrandr, + importc.} +proc XRRGetScreenInfo*(dpy: PDisplay, draw: TDrawable): PXRRScreenConfiguration{. + cdecl, dynlib: libXrandr, importc.} +proc XRRFreeScreenConfigInfo*(config: PXRRScreenConfiguration){.cdecl, + dynlib: libXrandr, importc.} + # + # Note that screen configuration changes are only permitted if the client can + # prove it has up to date configuration information. We are trying to + # insist that it become possible for screens to change dynamically, so + # we want to ensure the client knows what it is talking about when requesting + # changes. + # +proc XRRSetScreenConfig*(dpy: PDisplay, config: PXRRScreenConfiguration, + draw: TDrawable, size_index: cint, rotation: TRotation, + timestamp: TTime): TStatus{.cdecl, dynlib: libXrandr, + importc.} + # added in v1.1, sorry for the lame name +proc XRRSetScreenConfigAndRate*(dpy: PDisplay, config: PXRRScreenConfiguration, + draw: TDrawable, size_index: cint, + rotation: TRotation, rate: cshort, + timestamp: TTime): TStatus{.cdecl, + dynlib: libXrandr, importc.} +proc XRRConfigRotations*(config: PXRRScreenConfiguration, + current_rotation: PRotation): TRotation{.cdecl, + dynlib: libXrandr, importc.} +proc XRRConfigTimes*(config: PXRRScreenConfiguration, config_timestamp: PTime): TTime{. + cdecl, dynlib: libXrandr, importc.} +proc XRRConfigSizes*(config: PXRRScreenConfiguration, nsizes: Pcint): PXRRScreenSize{. + cdecl, dynlib: libXrandr, importc.} +proc XRRConfigRates*(config: PXRRScreenConfiguration, sizeID: cint, + nrates: Pcint): ptr int16{.cdecl, dynlib: libXrandr, importc.} +proc XRRConfigCurrentConfiguration*(config: PXRRScreenConfiguration, + rotation: PRotation): TSizeID{.cdecl, + dynlib: libXrandr, importc.} +proc XRRConfigCurrentRate*(config: PXRRScreenConfiguration): cshort{.cdecl, + dynlib: libXrandr, importc.} +proc XRRRootToScreen*(dpy: PDisplay, root: TWindow): cint{.cdecl, + dynlib: libXrandr, importc.} + # + # returns the screen configuration for the specified screen; does a lazy + # evalution to delay getting the information, and caches the result. + # These routines should be used in preference to XRRGetScreenInfo + # to avoid unneeded round trips to the X server. These are new + # in protocol version 0.1. + # +proc XRRScreenConfig*(dpy: PDisplay, screen: cint): PXRRScreenConfiguration{. + cdecl, dynlib: libXrandr, importc.} +proc XRRConfig*(screen: PScreen): PXRRScreenConfiguration{.cdecl, + dynlib: libXrandr, importc.} +proc XRRSelectInput*(dpy: PDisplay, window: TWindow, mask: cint){.cdecl, + dynlib: libXrandr, importc.} + # + # the following are always safe to call, even if RandR is not implemented + # on a screen + # +proc XRRRotations*(dpy: PDisplay, screen: cint, current_rotation: PRotation): TRotation{. + cdecl, dynlib: libXrandr, importc.} +proc XRRSizes*(dpy: PDisplay, screen: cint, nsizes: Pcint): PXRRScreenSize{. + cdecl, dynlib: libXrandr, importc.} +proc XRRRates*(dpy: PDisplay, screen: cint, sizeID: cint, nrates: Pcint): ptr int16{. + cdecl, dynlib: libXrandr, importc.} +proc XRRTimes*(dpy: PDisplay, screen: cint, config_timestamp: PTime): TTime{. + cdecl, dynlib: libXrandr, importc.} + # + # intended to take RRScreenChangeNotify, or + # ConfigureNotify (on the root window) + # returns 1 if it is an event type it understands, 0 if not + # +proc XRRUpdateConfiguration*(event: PXEvent): cint{.cdecl, dynlib: libXrandr, + importc.} +# implementation diff --git a/tests/deps/x11-1.0/xrender.nim b/tests/deps/x11-1.0/xrender.nim new file mode 100644 index 000000000..c4b2b364d --- /dev/null +++ b/tests/deps/x11-1.0/xrender.nim @@ -0,0 +1,241 @@ + +import + x, xlib + +when defined(use_pkg_config) or defined(use_pkg_config_static): + {.pragma: libxrender, cdecl, importc.} + when defined(use_pkg_config): + {.passl: gorge("pkg-config xrender --libs").} + else: + {.passl: gorge("pkg-config xrender --static --libs").} +else: + when defined(macosx): + const + libXrender* = "libXrender.dylib" + else: + const + libXrender* = "libXrender.so" + + + {.pragma: libxrender, dynlib: libXrender, cdecl, importc.} +#const +# libXrender* = "libXrender.so" + +# +# Automatically converted by H2Pas 0.99.15 from xrender.h +# The following command line parameters were used: +# -p +# -T +# -S +# -d +# -c +# xrender.h +# + +type + PGlyph* = ptr TGlyph + TGlyph* = int32 + PGlyphSet* = ptr TGlyphSet + TGlyphSet* = int32 + PPicture* = ptr TPicture + TPicture* = int32 + PPictFormat* = ptr TPictFormat + TPictFormat* = int32 + +const + RENDER_NAME* = "RENDER" + RENDER_MAJOR* = 0 + RENDER_MINOR* = 0 + constX_RenderQueryVersion* = 0 + X_RenderQueryPictFormats* = 1 + X_RenderQueryPictIndexValues* = 2 + X_RenderQueryDithers* = 3 + constX_RenderCreatePicture* = 4 + constX_RenderChangePicture* = 5 + X_RenderSetPictureClipRectangles* = 6 + constX_RenderFreePicture* = 7 + constX_RenderComposite* = 8 + X_RenderScale* = 9 + X_RenderTrapezoids* = 10 + X_RenderTriangles* = 11 + X_RenderTriStrip* = 12 + X_RenderTriFan* = 13 + X_RenderColorTrapezoids* = 14 + X_RenderColorTriangles* = 15 + X_RenderTransform* = 16 + constX_RenderCreateGlyphSet* = 17 + constX_RenderReferenceGlyphSet* = 18 + constX_RenderFreeGlyphSet* = 19 + constX_RenderAddGlyphs* = 20 + constX_RenderAddGlyphsFromPicture* = 21 + constX_RenderFreeGlyphs* = 22 + constX_RenderCompositeGlyphs8* = 23 + constX_RenderCompositeGlyphs16* = 24 + constX_RenderCompositeGlyphs32* = 25 + BadPictFormat* = 0 + BadPicture* = 1 + BadPictOp* = 2 + BadGlyphSet* = 3 + BadGlyph* = 4 + RenderNumberErrors* = BadGlyph + 1 + PictTypeIndexed* = 0 + PictTypeDirect* = 1 + PictOpClear* = 0 + PictOpSrc* = 1 + PictOpDst* = 2 + PictOpOver* = 3 + PictOpOverReverse* = 4 + PictOpIn* = 5 + PictOpInReverse* = 6 + PictOpOut* = 7 + PictOpOutReverse* = 8 + PictOpAtop* = 9 + PictOpAtopReverse* = 10 + PictOpXor* = 11 + PictOpAdd* = 12 + PictOpSaturate* = 13 + PictOpMaximum* = 13 + PolyEdgeSharp* = 0 + PolyEdgeSmooth* = 1 + PolyModePrecise* = 0 + PolyModeImprecise* = 1 + CPRepeat* = 1 shl 0 + CPAlphaMap* = 1 shl 1 + CPAlphaXOrigin* = 1 shl 2 + CPAlphaYOrigin* = 1 shl 3 + CPClipXOrigin* = 1 shl 4 + CPClipYOrigin* = 1 shl 5 + CPClipMask* = 1 shl 6 + CPGraphicsExposure* = 1 shl 7 + CPSubwindowMode* = 1 shl 8 + CPPolyEdge* = 1 shl 9 + CPPolyMode* = 1 shl 10 + CPDither* = 1 shl 11 + CPLastBit* = 11 + +type + PXRenderDirectFormat* = ptr TXRenderDirectFormat + TXRenderDirectFormat*{.final.} = object + red*: int16 + redMask*: int16 + green*: int16 + greenMask*: int16 + blue*: int16 + blueMask*: int16 + alpha*: int16 + alphaMask*: int16 + + PXRenderPictFormat* = ptr TXRenderPictFormat + TXRenderPictFormat*{.final.} = object + id*: TPictFormat + thetype*: int32 + depth*: int32 + direct*: TXRenderDirectFormat + colormap*: TColormap + + +const + PictFormatID* = 1 shl 0 + PictFormatType* = 1 shl 1 + PictFormatDepth* = 1 shl 2 + PictFormatRed* = 1 shl 3 + PictFormatRedMask* = 1 shl 4 + PictFormatGreen* = 1 shl 5 + PictFormatGreenMask* = 1 shl 6 + PictFormatBlue* = 1 shl 7 + PictFormatBlueMask* = 1 shl 8 + PictFormatAlpha* = 1 shl 9 + PictFormatAlphaMask* = 1 shl 10 + PictFormatColormap* = 1 shl 11 + +type + PXRenderVisual* = ptr TXRenderVisual + TXRenderVisual*{.final.} = object + visual*: PVisual + format*: PXRenderPictFormat + + PXRenderDepth* = ptr TXRenderDepth + TXRenderDepth*{.final.} = object + depth*: int32 + nvisuals*: int32 + visuals*: PXRenderVisual + + PXRenderScreen* = ptr TXRenderScreen + TXRenderScreen*{.final.} = object + depths*: PXRenderDepth + ndepths*: int32 + fallback*: PXRenderPictFormat + + PXRenderInfo* = ptr TXRenderInfo + TXRenderInfo*{.final.} = object + format*: PXRenderPictFormat + nformat*: int32 + screen*: PXRenderScreen + nscreen*: int32 + depth*: PXRenderDepth + ndepth*: int32 + visual*: PXRenderVisual + nvisual*: int32 + + PXRenderPictureAttributes* = ptr TXRenderPictureAttributes + TXRenderPictureAttributes*{.final.} = object + repeat*: TBool + alpha_map*: TPicture + alpha_x_origin*: int32 + alpha_y_origin*: int32 + clip_x_origin*: int32 + clip_y_origin*: int32 + clip_mask*: TPixmap + graphics_exposures*: TBool + subwindow_mode*: int32 + poly_edge*: int32 + poly_mode*: int32 + dither*: TAtom + + PXGlyphInfo* = ptr TXGlyphInfo + TXGlyphInfo*{.final.} = object + width*: int16 + height*: int16 + x*: int16 + y*: int16 + xOff*: int16 + yOff*: int16 + + +proc XRenderQueryExtension*(dpy: PDisplay, event_basep: ptr int32, + error_basep: ptr int32): TBool{.libxrender.} +proc XRenderQueryVersion*(dpy: PDisplay, major_versionp: ptr int32, + minor_versionp: ptr int32): TStatus{.libxrender.} +proc XRenderQueryFormats*(dpy: PDisplay): TStatus{.libxrender.} +proc XRenderFindVisualFormat*(dpy: PDisplay, visual: PVisual): PXRenderPictFormat{. + libxrender.} +proc XRenderFindFormat*(dpy: PDisplay, mask: int32, + `template`: PXRenderPictFormat, count: int32): PXRenderPictFormat{. + libxrender.} +proc XRenderCreatePicture*(dpy: PDisplay, drawable: TDrawable, + format: PXRenderPictFormat, valuemask: int32, + attributes: PXRenderPictureAttributes): TPicture{. + libxrender.} +proc XRenderChangePicture*(dpy: PDisplay, picture: TPicture, valuemask: int32, + attributes: PXRenderPictureAttributes){.libxrender.} +proc XRenderFreePicture*(dpy: PDisplay, picture: TPicture){.libxrender.} +proc XRenderComposite*(dpy: PDisplay, op: int32, src: TPicture, mask: TPicture, + dst: TPicture, src_x: int32, src_y: int32, mask_x: int32, + mask_y: int32, dst_x: int32, dst_y: int32, width: int32, + height: int32){.libxrender.} +proc XRenderCreateGlyphSet*(dpy: PDisplay, format: PXRenderPictFormat): TGlyphSet{. + libxrender.} +proc XRenderReferenceGlyphSet*(dpy: PDisplay, existing: TGlyphSet): TGlyphSet{. + libxrender.} +proc XRenderFreeGlyphSet*(dpy: PDisplay, glyphset: TGlyphSet){.libxrender.} +proc XRenderAddGlyphs*(dpy: PDisplay, glyphset: TGlyphSet, gids: PGlyph, + glyphs: PXGlyphInfo, nglyphs: int32, images: cstring, + nbyte_images: int32){.libxrender.} +proc XRenderFreeGlyphs*(dpy: PDisplay, glyphset: TGlyphSet, gids: PGlyph, + nglyphs: int32){.libxrender.} +proc XRenderCompositeString8*(dpy: PDisplay, op: int32, src: TPicture, + dst: TPicture, maskFormat: PXRenderPictFormat, + glyphset: TGlyphSet, xSrc: int32, ySrc: int32, + xDst: int32, yDst: int32, str: cstring, + nchar: int32){.libxrender.} +# implementation diff --git a/tests/deps/x11-1.0/xresource.nim b/tests/deps/x11-1.0/xresource.nim new file mode 100644 index 000000000..c96fbbb52 --- /dev/null +++ b/tests/deps/x11-1.0/xresource.nim @@ -0,0 +1,201 @@ + +import + x, xlib + +#const +# libX11* = "libX11.so" + +# +# Automatically converted by H2Pas 0.99.15 from xresource.h +# The following command line parameters were used: +# -p +# -T +# -S +# -d +# -c +# xresource.h +# + +proc Xpermalloc*(para1: int32): cstring{.cdecl, dynlib: libX11, importc.} +type + PXrmQuark* = ptr TXrmQuark + TXrmQuark* = int32 + TXrmQuarkList* = PXrmQuark + PXrmQuarkList* = ptr TXrmQuarkList + +proc NULLQUARK*(): TXrmQuark +type + PXrmString* = ptr TXrmString + TXrmString* = ptr char + +proc NULLSTRING*(): TXrmString +proc XrmStringToQuark*(para1: cstring): TXrmQuark{.cdecl, dynlib: libX11, + importc.} +proc XrmPermStringToQuark*(para1: cstring): TXrmQuark{.cdecl, dynlib: libX11, + importc.} +proc XrmQuarkToString*(para1: TXrmQuark): TXrmString{.cdecl, dynlib: libX11, + importc.} +proc XrmUniqueQuark*(): TXrmQuark{.cdecl, dynlib: libX11, importc.} +#when defined(MACROS): +proc XrmStringsEqual*(a1, a2: cstring): bool +type + PXrmBinding* = ptr TXrmBinding + TXrmBinding* = enum + XrmBindTightly, XrmBindLoosely + TXrmBindingList* = PXrmBinding + PXrmBindingList* = ptr TXrmBindingList + +proc XrmStringToQuarkList*(para1: cstring, para2: TXrmQuarkList){.cdecl, + dynlib: libX11, importc.} +proc XrmStringToBindingQuarkList*(para1: cstring, para2: TXrmBindingList, + para3: TXrmQuarkList){.cdecl, dynlib: libX11, + importc.} +type + PXrmName* = ptr TXrmName + TXrmName* = TXrmQuark + PXrmNameList* = ptr TXrmNameList + TXrmNameList* = TXrmQuarkList + +#when defined(MACROS): +proc XrmNameToString*(name: int32): TXrmString +proc XrmStringToName*(str: cstring): int32 +proc XrmStringToNameList*(str: cstring, name: PXrmQuark) +type + PXrmClass* = ptr TXrmClass + TXrmClass* = TXrmQuark + PXrmClassList* = ptr TXrmClassList + TXrmClassList* = TXrmQuarkList + +#when defined(MACROS): +proc XrmClassToString*(c_class: int32): TXrmString +proc XrmStringToClass*(c_class: cstring): int32 +proc XrmStringToClassList*(str: cstring, c_class: PXrmQuark) +type + PXrmRepresentation* = ptr TXrmRepresentation + TXrmRepresentation* = TXrmQuark + +#when defined(MACROS): +proc XrmStringToRepresentation*(str: cstring): int32 +proc XrmRepresentationToString*(thetype: int32): TXrmString +type + PXrmValue* = ptr TXrmValue + TXrmValue*{.final.} = object + size*: int32 + address*: TXPointer + + TXrmValuePtr* = PXrmValue + PXrmValuePtr* = ptr TXrmValuePtr + PXrmHashBucketRec* = ptr TXrmHashBucketRec + TXrmHashBucketRec*{.final.} = object + TXrmHashBucket* = PXrmHashBucketRec + PXrmHashBucket* = ptr TXrmHashBucket + PXrmHashTable* = ptr TXrmHashTable + TXrmHashTable* = ptr TXrmHashBucket + TXrmDatabase* = PXrmHashBucketRec + PXrmDatabase* = ptr TXrmDatabase + +proc XrmDestroyDatabase*(para1: TXrmDatabase){.cdecl, dynlib: libX11, importc.} +proc XrmQPutResource*(para1: PXrmDatabase, para2: TXrmBindingList, + para3: TXrmQuarkList, para4: TXrmRepresentation, + para5: PXrmValue){.cdecl, dynlib: libX11, importc.} +proc XrmPutResource*(para1: PXrmDatabase, para2: cstring, para3: cstring, + para4: PXrmValue){.cdecl, dynlib: libX11, importc.} +proc XrmQPutStringResource*(para1: PXrmDatabase, para2: TXrmBindingList, + para3: TXrmQuarkList, para4: cstring){.cdecl, + dynlib: libX11, importc.} +proc XrmPutStringResource*(para1: PXrmDatabase, para2: cstring, para3: cstring){. + cdecl, dynlib: libX11, importc.} +proc XrmPutLineResource*(para1: PXrmDatabase, para2: cstring){.cdecl, + dynlib: libX11, importc.} +proc XrmQGetResource*(para1: TXrmDatabase, para2: TXrmNameList, + para3: TXrmClassList, para4: PXrmRepresentation, + para5: PXrmValue): TBool{.cdecl, dynlib: libX11, importc.} +proc XrmGetResource*(para1: TXrmDatabase, para2: cstring, para3: cstring, + para4: PPchar, para5: PXrmValue): TBool{.cdecl, + dynlib: libX11, importc.} + # There is no definition of TXrmSearchList + #function XrmQGetSearchList(para1:TXrmDatabase; para2:TXrmNameList; para3:TXrmClassList; para4:TXrmSearchList; para5:longint):TBool;cdecl;external libX11; + #function XrmQGetSearchResource(para1:TXrmSearchList; para2:TXrmName; para3:TXrmClass; para4:PXrmRepresentation; para5:PXrmValue):TBool;cdecl;external libX11; +proc XrmSetDatabase*(para1: PDisplay, para2: TXrmDatabase){.cdecl, + dynlib: libX11, importc.} +proc XrmGetDatabase*(para1: PDisplay): TXrmDatabase{.cdecl, dynlib: libX11, + importc.} +proc XrmGetFileDatabase*(para1: cstring): TXrmDatabase{.cdecl, dynlib: libX11, + importc.} +proc XrmCombineFileDatabase*(para1: cstring, para2: PXrmDatabase, para3: TBool): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XrmGetStringDatabase*(para1: cstring): TXrmDatabase{.cdecl, dynlib: libX11, + importc.} +proc XrmPutFileDatabase*(para1: TXrmDatabase, para2: cstring){.cdecl, + dynlib: libX11, importc.} +proc XrmMergeDatabases*(para1: TXrmDatabase, para2: PXrmDatabase){.cdecl, + dynlib: libX11, importc.} +proc XrmCombineDatabase*(para1: TXrmDatabase, para2: PXrmDatabase, para3: TBool){. + cdecl, dynlib: libX11, importc.} +const + XrmEnumAllLevels* = 0 + XrmEnumOneLevel* = 1 + +type + funcbool* = proc (): TBool {.cdecl.} + +proc XrmEnumerateDatabase*(para1: TXrmDatabase, para2: TXrmNameList, + para3: TXrmClassList, para4: int32, para5: funcbool, + para6: TXPointer): TBool{.cdecl, dynlib: libX11, + importc.} +proc XrmLocaleOfDatabase*(para1: TXrmDatabase): cstring{.cdecl, dynlib: libX11, + importc.} +type + PXrmOptionKind* = ptr TXrmOptionKind + TXrmOptionKind* = enum + XrmoptionNoArg, XrmoptionIsArg, XrmoptionStickyArg, XrmoptionSepArg, + XrmoptionResArg, XrmoptionSkipArg, XrmoptionSkipLine, XrmoptionSkipNArgs + PXrmOptionDescRec* = ptr TXrmOptionDescRec + TXrmOptionDescRec*{.final.} = object + option*: cstring + specifier*: cstring + argKind*: TXrmOptionKind + value*: TXPointer + + TXrmOptionDescList* = PXrmOptionDescRec + PXrmOptionDescList* = ptr TXrmOptionDescList + +proc XrmParseCommand*(para1: PXrmDatabase, para2: TXrmOptionDescList, + para3: int32, para4: cstring, para5: ptr int32, + para6: PPchar){.cdecl, dynlib: libX11, importc.} +# implementation + +proc NULLQUARK(): TXrmQuark = + result = TXrmQuark(0) + +proc NULLSTRING(): TXrmString = + result = nil + +#when defined(MACROS): +proc XrmStringsEqual(a1, a2: cstring): bool = + #result = (strcomp(a1, a2)) == 0 + $a1 == $a2 + +proc XrmNameToString(name: int32): TXrmString = + result = XrmQuarkToString(name) + +proc XrmStringToName(str: cstring): int32 = + result = XrmStringToQuark(str) + +proc XrmStringToNameList(str: cstring, name: PXrmQuark) = + XrmStringToQuarkList(str, name) + +proc XrmClassToString(c_class: int32): TXrmString = + result = XrmQuarkToString(c_class) + +proc XrmStringToClass(c_class: cstring): int32 = + result = XrmStringToQuark(c_class) + +proc XrmStringToClassList(str: cstring, c_class: PXrmQuark) = + XrmStringToQuarkList(str, c_class) + +proc XrmStringToRepresentation(str: cstring): int32 = + result = XrmStringToQuark(str) + +proc XrmRepresentationToString(thetype: int32): TXrmString = + result = XrmQuarkToString(thetype) diff --git a/tests/deps/x11-1.0/xshm.nim b/tests/deps/x11-1.0/xshm.nim new file mode 100644 index 000000000..e56bd87b1 --- /dev/null +++ b/tests/deps/x11-1.0/xshm.nim @@ -0,0 +1,77 @@ + +import + x, xlib + +#const +# libX11* = "libX11.so" + +# +# Automatically converted by H2Pas 0.99.15 from xshm.h +# The following command line parameters were used: +# -p +# -T +# -S +# -d +# -c +# xshm.h +# + +const + constX_ShmQueryVersion* = 0 + constX_ShmAttach* = 1 + constX_ShmDetach* = 2 + constX_ShmPutImage* = 3 + constX_ShmGetImage* = 4 + constX_ShmCreatePixmap* = 5 + ShmCompletion* = 0 + ShmNumberEvents* = ShmCompletion + 1 + BadShmSeg* = 0 + ShmNumberErrors* = BadShmSeg + 1 + +type + PShmSeg* = ptr TShmSeg + TShmSeg* = culong + PXShmCompletionEvent* = ptr TXShmCompletionEvent + TXShmCompletionEvent*{.final.} = object + theType*: cint + serial*: culong + send_event*: TBool + display*: PDisplay + drawable*: TDrawable + major_code*: cint + minor_code*: cint + shmseg*: TShmSeg + offset*: culong + + PXShmSegmentInfo* = ptr TXShmSegmentInfo + TXShmSegmentInfo*{.final.} = object + shmseg*: TShmSeg + shmid*: cint + shmaddr*: cstring + readOnly*: TBool + + +proc XShmQueryExtension*(para1: PDisplay): TBool{.cdecl, dynlib: libX11, importc.} +proc XShmGetEventBase*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.} +proc XShmQueryVersion*(para1: PDisplay, para2: Pcint, para3: Pcint, para4: PBool): TBool{. + cdecl, dynlib: libX11, importc.} +proc XShmPixmapFormat*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.} +proc XShmAttach*(para1: PDisplay, para2: PXShmSegmentInfo): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XShmDetach*(para1: PDisplay, para2: PXShmSegmentInfo): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XShmPutImage*(para1: PDisplay, para2: TDrawable, para3: TGC, + para4: PXImage, para5: cint, para6: cint, para7: cint, + para8: cint, para9: cuint, para10: cuint, para11: TBool): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XShmGetImage*(para1: PDisplay, para2: TDrawable, para3: PXImage, + para4: cint, para5: cint, para6: culong): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XShmCreateImage*(para1: PDisplay, para2: PVisual, para3: cuint, + para4: cint, para5: cstring, para6: PXShmSegmentInfo, + para7: cuint, para8: cuint): PXImage{.cdecl, + dynlib: libX11, importc.} +proc XShmCreatePixmap*(para1: PDisplay, para2: TDrawable, para3: cstring, + para4: PXShmSegmentInfo, para5: cuint, para6: cuint, + para7: cuint): TPixmap{.cdecl, dynlib: libX11, importc.} +# implementation diff --git a/tests/deps/x11-1.0/xutil.nim b/tests/deps/x11-1.0/xutil.nim new file mode 100644 index 000000000..b7de0ae3e --- /dev/null +++ b/tests/deps/x11-1.0/xutil.nim @@ -0,0 +1,412 @@ + +import + x, xlib, keysym + +#const +# libX11* = "libX11.so" + +# +# Automatically converted by H2Pas 0.99.15 from xutil.h +# The following command line parameters were used: +# -p +# -T +# -S +# -d +# -c +# xutil.h +# + +const + NoValue* = 0x00000000 + XValue* = 0x00000001 + YValue* = 0x00000002 + WidthValue* = 0x00000004 + HeightValue* = 0x00000008 + AllValues* = 0x0000000F + XNegative* = 0x00000010 + YNegative* = 0x00000020 + +type + TCPoint*{.final.} = object + x*: cint + y*: cint + + PXSizeHints* = ptr TXSizeHints + TXSizeHints*{.final.} = object + flags*: clong + x*, y*: cint + width*, height*: cint + min_width*, min_height*: cint + max_width*, max_height*: cint + width_inc*, height_inc*: cint + min_aspect*, max_aspect*: TCPoint + base_width*, base_height*: cint + win_gravity*: cint + + +const + USPosition* = 1 shl 0 + USSize* = 1 shl 1 + PPosition* = 1 shl 2 + PSize* = 1 shl 3 + PMinSize* = 1 shl 4 + PMaxSize* = 1 shl 5 + PResizeInc* = 1 shl 6 + PAspect* = 1 shl 7 + PBaseSize* = 1 shl 8 + PWinGravity* = 1 shl 9 + PAllHints* = PPosition or PSize or PMinSize or PMaxSize or PResizeInc or + PAspect + +type + PXWMHints* = ptr TXWMHints + TXWMHints*{.final.} = object + flags*: clong + input*: TBool + initial_state*: cint + icon_pixmap*: TPixmap + icon_window*: TWindow + icon_x*, icon_y*: cint + icon_mask*: TPixmap + window_group*: TXID + + +const + InputHint* = 1 shl 0 + StateHint* = 1 shl 1 + IconPixmapHint* = 1 shl 2 + IconWindowHint* = 1 shl 3 + IconPositionHint* = 1 shl 4 + IconMaskHint* = 1 shl 5 + WindowGroupHint* = 1 shl 6 + AllHints* = InputHint or StateHint or IconPixmapHint or IconWindowHint or + IconPositionHint or IconMaskHint or WindowGroupHint + XUrgencyHint* = 1 shl 8 + WithdrawnState* = 0 + NormalState* = 1 + IconicState* = 3 + DontCareState* = 0 + ZoomState* = 2 + InactiveState* = 4 + +type + PXTextProperty* = ptr TXTextProperty + TXTextProperty*{.final.} = object + value*: Pcuchar + encoding*: TAtom + format*: cint + nitems*: culong + + +const + XNoMemory* = - 1 + XLocaleNotSupported* = - 2 + XConverterNotFound* = - 3 + +type + PXICCEncodingStyle* = ptr TXICCEncodingStyle + TXICCEncodingStyle* = enum + XStringStyle, XCompoundTextStyle, XTextStyle, XStdICCTextStyle, + XUTF8StringStyle + PPXIconSize* = ptr PXIconSize + PXIconSize* = ptr TXIconSize + TXIconSize*{.final.} = object + min_width*, min_height*: cint + max_width*, max_height*: cint + width_inc*, height_inc*: cint + + PXClassHint* = ptr TXClassHint + TXClassHint*{.final.} = object + res_name*: cstring + res_class*: cstring + + +type + PXComposeStatus* = ptr TXComposeStatus + TXComposeStatus*{.final.} = object + compose_ptr*: TXPointer + chars_matched*: cint + + +type + PXRegion* = ptr TXRegion + TXRegion*{.final.} = object + TRegion* = PXRegion + PRegion* = ptr TRegion + +const + RectangleOut* = 0 + RectangleIn* = 1 + RectanglePart* = 2 + +type + PXVisualInfo* = ptr TXVisualInfo + TXVisualInfo*{.final.} = object + visual*: PVisual + visualid*: TVisualID + screen*: cint + depth*: cint + class*: cint + red_mask*: culong + green_mask*: culong + blue_mask*: culong + colormap_size*: cint + bits_per_rgb*: cint + + +const + VisualNoMask* = 0x00000000 + VisualIDMask* = 0x00000001 + VisualScreenMask* = 0x00000002 + VisualDepthMask* = 0x00000004 + VisualClassMask* = 0x00000008 + VisualRedMaskMask* = 0x00000010 + VisualGreenMaskMask* = 0x00000020 + VisualBlueMaskMask* = 0x00000040 + VisualColormapSizeMask* = 0x00000080 + VisualBitsPerRGBMask* = 0x00000100 + VisualAllMask* = 0x000001FF + +type + PPXStandardColormap* = ptr PXStandardColormap + PXStandardColormap* = ptr TXStandardColormap + TXStandardColormap*{.final.} = object + colormap*: TColormap + red_max*: culong + red_mult*: culong + green_max*: culong + green_mult*: culong + blue_max*: culong + blue_mult*: culong + base_pixel*: culong + visualid*: TVisualID + killid*: TXID + + +const + BitmapSuccess* = 0 + BitmapOpenFailed* = 1 + BitmapFileInvalid* = 2 + BitmapNoMemory* = 3 + XCSUCCESS* = 0 + XCNOMEM* = 1 + XCNOENT* = 2 + ReleaseByFreeingColormap*: TXID = TXID(1) + +type + PXContext* = ptr TXContext + TXContext* = cint + +proc XAllocClassHint*(): PXClassHint{.cdecl, dynlib: libX11, importc.} +proc XAllocIconSize*(): PXIconSize{.cdecl, dynlib: libX11, importc.} +proc XAllocSizeHints*(): PXSizeHints{.cdecl, dynlib: libX11, importc.} +proc XAllocStandardColormap*(): PXStandardColormap{.cdecl, dynlib: libX11, + importc.} +proc XAllocWMHints*(): PXWMHints{.cdecl, dynlib: libX11, importc.} +proc XClipBox*(para1: TRegion, para2: PXRectangle): cint{.cdecl, dynlib: libX11, + importc.} +proc XCreateRegion*(): TRegion{.cdecl, dynlib: libX11, importc.} +proc XDefaultString*(): cstring{.cdecl, dynlib: libX11, importc.} +proc XDeleteContext*(para1: PDisplay, para2: TXID, para3: TXContext): cint{. + cdecl, dynlib: libX11, importc.} +proc XDestroyRegion*(para1: TRegion): cint{.cdecl, dynlib: libX11, importc.} +proc XEmptyRegion*(para1: TRegion): cint{.cdecl, dynlib: libX11, importc.} +proc XEqualRegion*(para1: TRegion, para2: TRegion): cint{.cdecl, dynlib: libX11, + importc.} +proc XFindContext*(para1: PDisplay, para2: TXID, para3: TXContext, + para4: PXPointer): cint{.cdecl, dynlib: libX11, importc.} +proc XGetClassHint*(para1: PDisplay, para2: TWindow, para3: PXClassHint): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XGetIconSizes*(para1: PDisplay, para2: TWindow, para3: PPXIconSize, + para4: Pcint): TStatus{.cdecl, dynlib: libX11, importc.} +proc XGetNormalHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XGetRGBColormaps*(para1: PDisplay, para2: TWindow, + para3: PPXStandardColormap, para4: Pcint, para5: TAtom): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XGetSizeHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints, + para4: TAtom): TStatus{.cdecl, dynlib: libX11, importc.} +proc XGetStandardColormap*(para1: PDisplay, para2: TWindow, + para3: PXStandardColormap, para4: TAtom): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XGetTextProperty*(para1: PDisplay, para2: TWindow, para3: PXTextProperty, + para4: TAtom): TStatus{.cdecl, dynlib: libX11, importc.} +proc XGetVisualInfo*(para1: PDisplay, para2: clong, para3: PXVisualInfo, + para4: Pcint): PXVisualInfo{.cdecl, dynlib: libX11, importc.} +proc XGetWMClientMachine*(para1: PDisplay, para2: TWindow, para3: PXTextProperty): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XGetWMHints*(para1: PDisplay, para2: TWindow): PXWMHints{.cdecl, + dynlib: libX11, importc.} +proc XGetWMIconName*(para1: PDisplay, para2: TWindow, para3: PXTextProperty): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XGetWMName*(para1: PDisplay, para2: TWindow, para3: PXTextProperty): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XGetWMNormalHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints, + para4: ptr int): TStatus{.cdecl, dynlib: libX11, importc.} +proc XGetWMSizeHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints, + para4: ptr int, para5: TAtom): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XGetZoomHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints): TStatus{. + cdecl, dynlib: libX11, importc.} +proc XIntersectRegion*(para1: TRegion, para2: TRegion, para3: TRegion): cint{. + cdecl, dynlib: libX11, importc.} +proc XConvertCase*(para1: TKeySym, para2: PKeySym, para3: PKeySym){.cdecl, + dynlib: libX11, importc.} +proc XLookupString*(para1: PXKeyEvent, para2: cstring, para3: cint, + para4: PKeySym, para5: PXComposeStatus): cint{.cdecl, + dynlib: libX11, importc.} +proc XMatchVisualInfo*(para1: PDisplay, para2: cint, para3: cint, para4: cint, + para5: PXVisualInfo): TStatus{.cdecl, dynlib: libX11, + importc.} +proc XOffsetRegion*(para1: TRegion, para2: cint, para3: cint): cint{.cdecl, + dynlib: libX11, importc.} +proc XPointInRegion*(para1: TRegion, para2: cint, para3: cint): TBool{.cdecl, + dynlib: libX11, importc.} +proc XPolygonRegion*(para1: PXPoint, para2: cint, para3: cint): TRegion{.cdecl, + dynlib: libX11, importc.} +proc XRectInRegion*(para1: TRegion, para2: cint, para3: cint, para4: cuint, + para5: cuint): cint{.cdecl, dynlib: libX11, importc.} +proc XSaveContext*(para1: PDisplay, para2: TXID, para3: TXContext, + para4: cstring): cint{.cdecl, dynlib: libX11, importc.} +proc XSetClassHint*(para1: PDisplay, para2: TWindow, para3: PXClassHint): cint{. + cdecl, dynlib: libX11, importc.} +proc XSetIconSizes*(para1: PDisplay, para2: TWindow, para3: PXIconSize, + para4: cint): cint{.cdecl, dynlib: libX11, importc.} +proc XSetNormalHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints): cint{. + cdecl, dynlib: libX11, importc.} +proc XSetRGBColormaps*(para1: PDisplay, para2: TWindow, + para3: PXStandardColormap, para4: cint, para5: TAtom){. + cdecl, dynlib: libX11, importc.} +proc XSetSizeHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints, + para4: TAtom): cint{.cdecl, dynlib: libX11, importc.} +proc XSetStandardProperties*(para1: PDisplay, para2: TWindow, para3: cstring, + para4: cstring, para5: TPixmap, para6: PPchar, + para7: cint, para8: PXSizeHints): cint{.cdecl, + dynlib: libX11, importc.} +proc XSetTextProperty*(para1: PDisplay, para2: TWindow, para3: PXTextProperty, + para4: TAtom){.cdecl, dynlib: libX11, importc.} +proc XSetWMClientMachine*(para1: PDisplay, para2: TWindow, para3: PXTextProperty){. + cdecl, dynlib: libX11, importc.} +proc XSetWMHints*(para1: PDisplay, para2: TWindow, para3: PXWMHints): cint{. + cdecl, dynlib: libX11, importc.} +proc XSetWMIconName*(para1: PDisplay, para2: TWindow, para3: PXTextProperty){. + cdecl, dynlib: libX11, importc.} +proc XSetWMName*(para1: PDisplay, para2: TWindow, para3: PXTextProperty){.cdecl, + dynlib: libX11, importc.} +proc XSetWMNormalHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints){. + cdecl, dynlib: libX11, importc.} +proc XSetWMProperties*(para1: PDisplay, para2: TWindow, para3: PXTextProperty, + para4: PXTextProperty, para5: PPchar, para6: cint, + para7: PXSizeHints, para8: PXWMHints, para9: PXClassHint){. + cdecl, dynlib: libX11, importc.} +proc XmbSetWMProperties*(para1: PDisplay, para2: TWindow, para3: cstring, + para4: cstring, para5: PPchar, para6: cint, + para7: PXSizeHints, para8: PXWMHints, + para9: PXClassHint){.cdecl, dynlib: libX11, importc.} +proc Xutf8SetWMProperties*(para1: PDisplay, para2: TWindow, para3: cstring, + para4: cstring, para5: PPchar, para6: cint, + para7: PXSizeHints, para8: PXWMHints, + para9: PXClassHint){.cdecl, dynlib: libX11, importc.} +proc XSetWMSizeHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints, + para4: TAtom){.cdecl, dynlib: libX11, importc.} +proc XSetRegion*(para1: PDisplay, para2: TGC, para3: TRegion): cint{.cdecl, + dynlib: libX11, importc.} +proc XSetStandardColormap*(para1: PDisplay, para2: TWindow, + para3: PXStandardColormap, para4: TAtom){.cdecl, + dynlib: libX11, importc.} +proc XSetZoomHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints): cint{. + cdecl, dynlib: libX11, importc.} +proc XShrinkRegion*(para1: TRegion, para2: cint, para3: cint): cint{.cdecl, + dynlib: libX11, importc.} +proc XStringListToTextProperty*(para1: PPchar, para2: cint, + para3: PXTextProperty): TStatus{.cdecl, + dynlib: libX11, importc.} +proc XSubtractRegion*(para1: TRegion, para2: TRegion, para3: TRegion): cint{. + cdecl, dynlib: libX11, importc.} +proc XmbTextListToTextProperty*(para1: PDisplay, para2: PPchar, para3: cint, + para4: TXICCEncodingStyle, para5: PXTextProperty): cint{. + cdecl, dynlib: libX11, importc.} +proc XwcTextListToTextProperty*(para1: PDisplay, para2: ptr ptr int16, para3: cint, + para4: TXICCEncodingStyle, para5: PXTextProperty): cint{. + cdecl, dynlib: libX11, importc.} +proc Xutf8TextListToTextProperty*(para1: PDisplay, para2: PPchar, para3: cint, + para4: TXICCEncodingStyle, + para5: PXTextProperty): cint{.cdecl, + dynlib: libX11, importc.} +proc XwcFreeStringList*(para1: ptr ptr int16){.cdecl, dynlib: libX11, importc.} +proc XTextPropertyToStringList*(para1: PXTextProperty, para2: PPPchar, + para3: Pcint): TStatus{.cdecl, dynlib: libX11, + importc.} +proc XmbTextPropertyToTextList*(para1: PDisplay, para2: PXTextProperty, + para3: PPPchar, para4: Pcint): cint{.cdecl, + dynlib: libX11, importc.} +proc XwcTextPropertyToTextList*(para1: PDisplay, para2: PXTextProperty, + para3: ptr ptr ptr int16, para4: Pcint): cint{.cdecl, + dynlib: libX11, importc.} +proc Xutf8TextPropertyToTextList*(para1: PDisplay, para2: PXTextProperty, + para3: PPPchar, para4: Pcint): cint{.cdecl, + dynlib: libX11, importc.} +proc XUnionRectWithRegion*(para1: PXRectangle, para2: TRegion, para3: TRegion): cint{. + cdecl, dynlib: libX11, importc.} +proc XUnionRegion*(para1: TRegion, para2: TRegion, para3: TRegion): cint{.cdecl, + dynlib: libX11, importc.} +proc XWMGeometry*(para1: PDisplay, para2: cint, para3: cstring, para4: cstring, + para5: cuint, para6: PXSizeHints, para7: Pcint, para8: Pcint, + para9: Pcint, para10: Pcint, para11: Pcint): cint{.cdecl, + dynlib: libX11, importc.} +proc XXorRegion*(para1: TRegion, para2: TRegion, para3: TRegion): cint{.cdecl, + dynlib: libX11, importc.} +#when defined(MACROS): +proc XDestroyImage*(ximage: PXImage): cint +proc XGetPixel*(ximage: PXImage, x, y: cint): culong +proc XPutPixel*(ximage: PXImage, x, y: cint, pixel: culong): cint +proc XSubImage*(ximage: PXImage, x, y: cint, width, height: cuint): PXImage +proc XAddPixel*(ximage: PXImage, value: clong): cint +proc IsKeypadKey*(keysym: TKeySym): bool +proc IsPrivateKeypadKey*(keysym: TKeySym): bool +proc IsCursorKey*(keysym: TKeySym): bool +proc IsPFKey*(keysym: TKeySym): bool +proc IsFunctionKey*(keysym: TKeySym): bool +proc IsMiscFunctionKey*(keysym: TKeySym): bool +proc IsModifierKey*(keysym: TKeySym): bool + #function XUniqueContext : TXContext; + #function XStringToContext(_string : Pchar) : TXContext; +# implementation + +#when defined(MACROS): +proc XDestroyImage(ximage: PXImage): cint = + ximage.f.destroy_image(ximage) + +proc XGetPixel(ximage: PXImage, x, y: cint): culong = + ximage.f.get_pixel(ximage, x, y) + +proc XPutPixel(ximage: PXImage, x, y: cint, pixel: culong): cint = + ximage.f.put_pixel(ximage, x, y, pixel) + +proc XSubImage(ximage: PXImage, x, y: cint, width, height: cuint): PXImage = + ximage.f.sub_image(ximage, x, y, width, height) + +proc XAddPixel(ximage: PXImage, value: clong): cint = + ximage.f.add_pixel(ximage, value) + +proc IsKeypadKey(keysym: TKeySym): bool = + (keysym >= XK_KP_Space) and (keysym <= XK_KP_Equal) + +proc IsPrivateKeypadKey(keysym: TKeySym): bool = + (keysym >= 0x11000000.TKeySym) and (keysym <= 0x1100FFFF.TKeySym) + +proc IsCursorKey(keysym: TKeySym): bool = + (keysym >= XK_Home) and (keysym < XK_Select) + +proc IsPFKey(keysym: TKeySym): bool = + (keysym >= XK_KP_F1) and (keysym <= XK_KP_F4) + +proc IsFunctionKey(keysym: TKeySym): bool = + (keysym >= XK_F1) and (keysym <= XK_F35) + +proc IsMiscFunctionKey(keysym: TKeySym): bool = + (keysym >= XK_Select) and (keysym <= XK_Break) + +proc IsModifierKey(keysym: TKeySym): bool = + ((keysym >= XK_Shift_L) and (keysym <= XK_Hyper_R)) or + (keysym == XK_Mode_switch) or (keysym == XK_Num_Lock) diff --git a/tests/deps/x11-1.0/xv.nim b/tests/deps/x11-1.0/xv.nim new file mode 100644 index 000000000..45ab61418 --- /dev/null +++ b/tests/deps/x11-1.0/xv.nim @@ -0,0 +1,84 @@ +#*********************************************************** +#Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts, +#and the Massachusetts Institute of Technology, Cambridge, Massachusetts. +# +# All Rights Reserved +# +#Permission to use, copy, modify, and distribute this software and its +#documentation for any purpose and without fee is hereby granted, +#provided that the above copyright notice appear in all copies and that +#both that copyright notice and this permission notice appear in +#supporting documentation, and that the names of Digital or MIT not be +#used in advertising or publicity pertaining to distribution of the +#software without specific, written prior permission. +# +#DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +#ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +#DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +#ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +#WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +#ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +#SOFTWARE. +# +#****************************************************************** +# $XFree86: xc/include/extensions/Xv.h,v 1.3 1999/05/23 06:33:22 dawes Exp $ + +import + x + +const + XvName* = "libXVideo.so" + XvVersion* = 2 + XvRevision* = 2 # Symbols + +type + TXvPortID* = TXID + TXvEncodingID* = TXID + +const + XvNone* = 0 + XvInput* = 0 + XvOutput* = 1 + XvInputMask* = 1 shl XvInput + XvOutputMask* = 1 shl XvOutput + XvVideoMask* = 0x00000004 + XvStillMask* = 0x00000008 + XvImageMask* = 0x00000010 # These two are not client viewable + XvPixmapMask* = 0x00010000 + XvWindowMask* = 0x00020000 + XvGettable* = 0x00000001 + XvSettable* = 0x00000002 + XvRGB* = 0 + XvYUV* = 1 + XvPacked* = 0 + XvPlanar* = 1 + XvTopToBottom* = 0 + XvBottomToTop* = 1 # Events + XvVideoNotify* = 0 + XvPortNotify* = 1 + XvNumEvents* = 2 # Video Notify Reasons + XvStarted* = 0 + XvStopped* = 1 + XvBusy* = 2 + XvPreempted* = 3 + XvHardError* = 4 + XvLastReason* = 4 + XvNumReasons* = XvLastReason + 1 + XvStartedMask* = 1 shl XvStarted + XvStoppedMask* = 1 shl XvStopped + XvBusyMask* = 1 shl XvBusy + XvPreemptedMask* = 1 shl XvPreempted + XvHardErrorMask* = 1 shl XvHardError + XvAnyReasonMask* = (1 shl XvNumReasons) - 1 + XvNoReasonMask* = 0 # Errors + XvBadPort* = 0 + XvBadEncoding* = 1 + XvBadControl* = 2 + XvNumErrors* = 3 # Status + XvBadExtension* = 1 + XvAlreadyGrabbed* = 2 + XvInvalidTime* = 3 + XvBadReply* = 4 + XvBadAlloc* = 5 + +# implementation diff --git a/tests/deps/x11-1.0/xvlib.nim b/tests/deps/x11-1.0/xvlib.nim new file mode 100644 index 000000000..e642cb350 --- /dev/null +++ b/tests/deps/x11-1.0/xvlib.nim @@ -0,0 +1,234 @@ +#*********************************************************** +#Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts, +#and the Massachusetts Institute of Technology, Cambridge, Massachusetts. +# +# All Rights Reserved +# +#Permission to use, copy, modify, and distribute this software and its +#documentation for any purpose and without fee is hereby granted, +#provided that the above copyright notice appear in all copies and that +#both that copyright notice and this permission notice appear in +#supporting documentation, and that the names of Digital or MIT not be +#used in advertising or publicity pertaining to distribution of the +#software without specific, written prior permission. +# +#DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +#ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +#DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +#ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +#WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +#ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +#SOFTWARE. +# +#****************************************************************** +# $XFree86: xc/include/extensions/Xvlib.h,v 1.3 1999/12/11 19:28:48 mvojkovi Exp $ +#* +#** File: +#** +#** Xvlib.h --- Xv library public header file +#** +#** Author: +#** +#** David Carver (Digital Workstation Engineering/Project Athena) +#** +#** Revisions: +#** +#** 26.06.91 Carver +#** - changed XvFreeAdaptors to XvFreeAdaptorInfo +#** - changed XvFreeEncodings to XvFreeEncodingInfo +#** +#** 11.06.91 Carver +#** - changed SetPortControl to SetPortAttribute +#** - changed GetPortControl to GetPortAttribute +#** - changed QueryBestSize +#** +#** 05.15.91 Carver +#** - version 2.0 upgrade +#** +#** 01.24.91 Carver +#** - version 1.4 upgrade +#** +#* + +import + x, xlib, xshm, xv + +const + libXv* = "libXv.so" + +type + PXvRational* = ptr TXvRational + TXvRational*{.final.} = object + numerator*: cint + denominator*: cint + + PXvAttribute* = ptr TXvAttribute + TXvAttribute*{.final.} = object + flags*: cint # XvGettable, XvSettable + min_value*: cint + max_value*: cint + name*: cstring + + PPXvEncodingInfo* = ptr PXvEncodingInfo + PXvEncodingInfo* = ptr TXvEncodingInfo + TXvEncodingInfo*{.final.} = object + encoding_id*: TXvEncodingID + name*: cstring + width*: culong + height*: culong + rate*: TXvRational + num_encodings*: culong + + PXvFormat* = ptr TXvFormat + TXvFormat*{.final.} = object + depth*: cchar + visual_id*: culong + + PPXvAdaptorInfo* = ptr PXvAdaptorInfo + PXvAdaptorInfo* = ptr TXvAdaptorInfo + TXvAdaptorInfo*{.final.} = object + base_id*: TXvPortID + num_ports*: culong + thetype*: cchar + name*: cstring + num_formats*: culong + formats*: PXvFormat + num_adaptors*: culong + + PXvVideoNotifyEvent* = ptr TXvVideoNotifyEvent + TXvVideoNotifyEvent*{.final.} = object + theType*: cint + serial*: culong # # of last request processed by server + send_event*: TBool # true if this came from a SendEvent request + display*: PDisplay # Display the event was read from + drawable*: TDrawable # drawable + reason*: culong # what generated this event + port_id*: TXvPortID # what port + time*: TTime # milliseconds + + PXvPortNotifyEvent* = ptr TXvPortNotifyEvent + TXvPortNotifyEvent*{.final.} = object + theType*: cint + serial*: culong # # of last request processed by server + send_event*: TBool # true if this came from a SendEvent request + display*: PDisplay # Display the event was read from + port_id*: TXvPortID # what port + time*: TTime # milliseconds + attribute*: TAtom # atom that identifies attribute + value*: clong # value of attribute + + PXvEvent* = ptr TXvEvent + TXvEvent*{.final.} = object + pad*: array[0..23, clong] #case longint of + # 0 : ( + # theType : cint; + # ); + # 1 : ( + # xvvideo : TXvVideoNotifyEvent; + # ); + # 2 : ( + # xvport : TXvPortNotifyEvent; + # ); + # 3 : ( + # + # ); + + PXvImageFormatValues* = ptr TXvImageFormatValues + TXvImageFormatValues*{.final.} = object + id*: cint # Unique descriptor for the format + theType*: cint # XvRGB, XvYUV + byte_order*: cint # LSBFirst, MSBFirst + guid*: array[0..15, cchar] # Globally Unique IDentifier + bits_per_pixel*: cint + format*: cint # XvPacked, XvPlanar + num_planes*: cint # for RGB formats only + depth*: cint + red_mask*: cuint + green_mask*: cuint + blue_mask*: cuint # for YUV formats only + y_sample_bits*: cuint + u_sample_bits*: cuint + v_sample_bits*: cuint + horz_y_period*: cuint + horz_u_period*: cuint + horz_v_period*: cuint + vert_y_period*: cuint + vert_u_period*: cuint + vert_v_period*: cuint + component_order*: array[0..31, char] # eg. UYVY + scanline_order*: cint # XvTopToBottom, XvBottomToTop + + PXvImage* = ptr TXvImage + TXvImage*{.final.} = object + id*: cint + width*, height*: cint + data_size*: cint # bytes + num_planes*: cint + pitches*: cint # bytes + offsets*: cint # bytes + data*: pointer + obdata*: TXPointer + + +proc XvQueryExtension*(display: PDisplay, p_version, p_revision, p_requestBase, + p_eventBase, p_errorBase: cuint): cint{.cdecl, dynlib: libXv, importc.} +proc XvQueryAdaptors*(display: PDisplay, window: TWindow, p_nAdaptors: cuint, + p_pAdaptors: PPXvAdaptorInfo): cint{.cdecl, dynlib: libXv, + importc.} +proc XvQueryEncodings*(display: PDisplay, port: TXvPortID, p_nEncoding: cuint, + p_pEncoding: PPXvEncodingInfo): cint{.cdecl, + dynlib: libXv, importc.} +proc XvPutVideo*(display: PDisplay, port: TXvPortID, d: TDrawable, gc: TGC, + vx, vy: cint, vw, vh: cuint, dx, dy: cint, dw, dh: cuint): cint{. + cdecl, dynlib: libXv, importc.} +proc XvPutStill*(display: PDisplay, port: TXvPortID, d: TDrawable, gc: TGC, + vx, vy: cint, vw, vh: cuint, dx, dy: cint, dw, dh: cuint): cint{. + cdecl, dynlib: libXv, importc.} +proc XvGetVideo*(display: PDisplay, port: TXvPortID, d: TDrawable, gc: TGC, + vx, vy: cint, vw, vh: cuint, dx, dy: cint, dw, dh: cuint): cint{. + cdecl, dynlib: libXv, importc.} +proc XvGetStill*(display: PDisplay, port: TXvPortID, d: TDrawable, gc: TGC, + vx, vy: cint, vw, vh: cuint, dx, dy: cint, dw, dh: cuint): cint{. + cdecl, dynlib: libXv, importc.} +proc XvStopVideo*(display: PDisplay, port: TXvPortID, drawable: TDrawable): cint{. + cdecl, dynlib: libXv, importc.} +proc XvGrabPort*(display: PDisplay, port: TXvPortID, time: TTime): cint{.cdecl, + dynlib: libXv, importc.} +proc XvUngrabPort*(display: PDisplay, port: TXvPortID, time: TTime): cint{. + cdecl, dynlib: libXv, importc.} +proc XvSelectVideoNotify*(display: PDisplay, drawable: TDrawable, onoff: TBool): cint{. + cdecl, dynlib: libXv, importc.} +proc XvSelectPortNotify*(display: PDisplay, port: TXvPortID, onoff: TBool): cint{. + cdecl, dynlib: libXv, importc.} +proc XvSetPortAttribute*(display: PDisplay, port: TXvPortID, attribute: TAtom, + value: cint): cint{.cdecl, dynlib: libXv, importc.} +proc XvGetPortAttribute*(display: PDisplay, port: TXvPortID, attribute: TAtom, + p_value: cint): cint{.cdecl, dynlib: libXv, importc.} +proc XvQueryBestSize*(display: PDisplay, port: TXvPortID, motion: TBool, + vid_w, vid_h, drw_w, drw_h: cuint, + p_actual_width, p_actual_height: cuint): cint{.cdecl, + dynlib: libXv, importc.} +proc XvQueryPortAttributes*(display: PDisplay, port: TXvPortID, number: cint): PXvAttribute{. + cdecl, dynlib: libXv, importc.} +proc XvFreeAdaptorInfo*(adaptors: PXvAdaptorInfo){.cdecl, dynlib: libXv, importc.} +proc XvFreeEncodingInfo*(encodings: PXvEncodingInfo){.cdecl, dynlib: libXv, + importc.} +proc XvListImageFormats*(display: PDisplay, port_id: TXvPortID, + count_return: cint): PXvImageFormatValues{.cdecl, + dynlib: libXv, importc.} +proc XvCreateImage*(display: PDisplay, port: TXvPortID, id: cint, data: pointer, + width, height: cint): PXvImage{.cdecl, dynlib: libXv, + importc.} +proc XvPutImage*(display: PDisplay, id: TXvPortID, d: TDrawable, gc: TGC, + image: PXvImage, src_x, src_y: cint, src_w, src_h: cuint, + dest_x, dest_y: cint, dest_w, dest_h: cuint): cint{.cdecl, + dynlib: libXv, importc.} +proc XvShmPutImage*(display: PDisplay, id: TXvPortID, d: TDrawable, gc: TGC, + image: PXvImage, src_x, src_y: cint, src_w, src_h: cuint, + dest_x, dest_y: cint, dest_w, dest_h: cuint, + send_event: TBool): cint{.cdecl, dynlib: libXv, importc.} +proc XvShmCreateImage*(display: PDisplay, port: TXvPortID, id: cint, + data: pointer, width, height: cint, + shminfo: PXShmSegmentInfo): PXvImage{.cdecl, + dynlib: libXv, importc.} +# implementation diff --git a/tests/deps/zip-0.2.1/zip.nimble b/tests/deps/zip-0.2.1/zip.nimble new file mode 100644 index 000000000..561f1b9c9 --- /dev/null +++ b/tests/deps/zip-0.2.1/zip.nimble @@ -0,0 +1,18 @@ +# Package + +version = "0.2.1" +author = "Anonymous" +description = "Wrapper for the zip library" +license = "MIT" + +skipDirs = @["tests"] + +# Dependencies + +requires "nim >= 0.10.0" + +task tests, "Run lib tests": + withDir "tests": + exec "nim c -r ziptests" + exec "nim c -r zlibtests" + exec "nim c -r gziptests" diff --git a/tests/deps/zip-0.2.1/zip/gzipfiles.nim b/tests/deps/zip-0.2.1/zip/gzipfiles.nim new file mode 100644 index 000000000..82c412bc3 --- /dev/null +++ b/tests/deps/zip-0.2.1/zip/gzipfiles.nim @@ -0,0 +1,97 @@ +import os +import zlib +import streams +export streams + +## This module implements a gzipfile stream for reading, writing, appending. + +type + GzFileStream* = ref object of Stream + mode: FileMode + f: GzFile + +const SEEK_SET = 0.int32 # Seek from beginning of file. + +proc fsClose(s: Stream) = + if not GzFileStream(s).f.isNil: + discard gzclose(GzFileStream(s).f) + GzFileStream(s).f = nil + +proc fsFlush(s: Stream) = + # compiler flushFile also discard c_fflush + discard gzflush(GzFileStream(s).f, Z_FINISH) + +proc fsAtEnd(s: Stream): bool = + result = gzeof(GzFileStream(s).f) == 1 + +proc fsSetPosition(s: Stream, pos: int) = + if gzseek(GzFileStream(s).f, pos.ZOffT, SEEK_SET) == -1: + if GzFileStream(s).mode in {fmWrite, fmAppend}: + raise newException(IOError, "error in gzip stream while seeking! (file is in write/append mode!") + else: + raise newException(IOError, "error in gzip stream while seeking!") + +proc fsGetPosition(s: Stream): int = + result = gztell(GzFileStream(s).f).int + +proc fsReadData(s: Stream, buffer: pointer, bufLen: int): int = + result = gzread(GzFileStream(s).f, buffer, bufLen).int + if result == -1: + if GzFileStream(s).mode in {fmWrite, fmAppend}: + raise newException(IOError, "cannot read data from write-only gzip stream!") + else: + raise newException(IOError, "cannot read from stream!") + +proc fsPeekData(s: Stream, buffer: pointer, bufLen: int): int = + let gz = GzFileStream(s) + if gz.mode in {fmWrite, fmAppend}: + raise newException(IOError, "cannot peek data from write-only gzip stream!") + let pos = int(gztell(gz.f)) + result = fsReadData(s, buffer, bufLen) + fsSetPosition(s, pos) + +proc fsWriteData(s: Stream, buffer: pointer, bufLen: int) = + if gzwrite(GzFileStream(s).f, buffer, bufLen).int != bufLen: + if GzFileStream(s).mode in {fmWrite, fmAppend}: + raise newException(IOError, "cannot write data to gzip stream!") + else: + raise newException(IOError, "cannot write data to read-only gzip stream!") + + +proc newGzFileStream*(filename: string; mode=fmRead; level=Z_DEFAULT_COMPRESSION): GzFileStream = + ## Opens a Gzipfile as a file stream. `mode` can be + ## ``fmRead``, ``fmWrite`` or ``fmAppend``. + ## + ## Compression level can be set with ``level`` argument. Currently + ## ``Z_DEFAULT_COMPRESSION`` is 6. + ## + ## Note: ``level`` is ignored if ``mode`` is `fmRead` + ## + ## Note: There is only partial support for file seeking + ## - in fmRead mode, seeking randomly inside the gzip + ## file will lead to poor performance. + ## - in fmWrite, fmAppend mode, only forward seeking + ## is supported. + new(result) + case mode + of fmRead: result.f = gzopen(filename, "rb") + of fmWrite: result.f = gzopen(filename, "wb") + of fmAppend: result.f = gzopen(filename, "ab") + else: raise newException(IOError, "unsupported file mode '" & $mode & + "' for GzFileStream!") + if result.f.isNil: + let err = osLastError() + if err != OSErrorCode(0'i32): + raiseOSError(err) + if mode in {fmWrite, fmAppend}: + discard gzsetparams(result.f, level.int32, Z_DEFAULT_STRATEGY.int32) + + result.mode = mode + result.closeImpl = fsClose + result.atEndImpl = fsAtEnd + result.setPositionImpl = fsSetPosition + result.getPositionImpl = fsGetPosition + result.readDataImpl = fsReadData + result.peekDataImpl = fsPeekData + result.writeDataImpl = fsWriteData + result.flushImpl = fsFlush diff --git a/tests/deps/zip-0.2.1/zip/libzip.nim b/tests/deps/zip-0.2.1/zip/libzip.nim new file mode 100644 index 000000000..a2904cd2c --- /dev/null +++ b/tests/deps/zip-0.2.1/zip/libzip.nim @@ -0,0 +1,252 @@ +# +# +# Nim's Runtime Library +# (c) Copyright 2013 Andreas Rumpf +# +# See the file "copying.txt", included in this +# distribution, for details about the copyright. +# + +## Interface to the `libzip <http://www.nih.at/libzip/index.html>`_ library by +## Dieter Baron and Thomas Klausner. This version links +## against ``libzip2.so.2`` unless you define the symbol ``useLibzipSrc``; then +## it is compiled against some old ``libizp_all.c`` file. + +# +# zip.h -- exported declarations. +# Copyright (C) 1999-2008 Dieter Baron and Thomas Klausner +# +# This file is part of libzip, a library to manipulate ZIP archives. +# The authors can be contacted at <libzip@nih.at> +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# 3. The names of the authors may not be used to endorse or promote +# products derived from this software without specific prior +# written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS +# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE +# GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER +# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +# IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +import times + +when defined(unix) and not defined(useLibzipSrc): + when defined(macosx): + {.pragma: mydll, dynlib: "libzip(|2|4).dylib".} + else: + {.pragma: mydll, dynlib: "libzip(|2).so(|.4|.2|.1|.0)".} +else: + when defined(unix): + {.passl: "-lz".} + {.compile: "zip/private/libzip_all.c".} + {.pragma: mydll.} + +type + ZipSourceCmd* = int32 + + ZipSourceCallback* = proc (state: pointer, data: pointer, length: int, + cmd: ZipSourceCmd): int {.cdecl.} + PZipStat* = ptr ZipStat + ZipStat* = object ## the 'zip_stat' struct + name*: cstring ## name of the file + index*: int32 ## index within archive + crc*: int32 ## crc of file data + mtime*: Time ## modification time + size*: int ## size of file (uncompressed) + compSize*: int ## size of file (compressed) + compMethod*: int16 ## compression method used + encryptionMethod*: int16 ## encryption method used + + Zip = object + ZipSource = object + ZipFile = object + + PZip* = ptr Zip ## represents a zip archive + PZipFile* = ptr ZipFile ## represents a file within an archive + PZipSource* = ptr ZipSource ## represents a source for an archive +{.deprecated: [TZipSourceCmd: ZipSourceCmd, TZipStat: ZipStat, TZip: Zip, + TZipSourceCallback: ZipSourceCallback, TZipSource: ZipSource, + TZipFile: ZipFile].} + +# flags for zip_name_locate, zip_fopen, zip_stat, ... +const + ZIP_CREATE* = 1'i32 + ZIP_EXCL* = 2'i32 + ZIP_CHECKCONS* = 4'i32 + ZIP_FL_NOCASE* = 1'i32 ## ignore case on name lookup + ZIP_FL_NODIR* = 2'i32 ## ignore directory component + ZIP_FL_COMPRESSED* = 4'i32 ## read compressed data + ZIP_FL_UNCHANGED* = 8'i32 ## use original data, ignoring changes + ZIP_FL_RECOMPRESS* = 16'i32 ## force recompression of data + +const # archive global flags flags + ZIP_AFL_TORRENT* = 1'i32 ## torrent zipped + +const # libzip error codes + ZIP_ER_OK* = 0'i32 ## N No error + ZIP_ER_MULTIDISK* = 1'i32 ## N Multi-disk zip archives not supported + ZIP_ER_RENAME* = 2'i32 ## S Renaming temporary file failed + ZIP_ER_CLOSE* = 3'i32 ## S Closing zip archive failed + ZIP_ER_SEEK* = 4'i32 ## S Seek error + ZIP_ER_READ* = 5'i32 ## S Read error + ZIP_ER_WRITE* = 6'i32 ## S Write error + ZIP_ER_CRC* = 7'i32 ## N CRC error + ZIP_ER_ZIPCLOSED* = 8'i32 ## N Containing zip archive was closed + ZIP_ER_NOENT* = 9'i32 ## N No such file + ZIP_ER_EXISTS* = 10'i32 ## N File already exists + ZIP_ER_OPEN* = 11'i32 ## S Can't open file + ZIP_ER_TMPOPEN* = 12'i32 ## S Failure to create temporary file + ZIP_ER_ZLIB* = 13'i32 ## Z Zlib error + ZIP_ER_MEMORY* = 14'i32 ## N Malloc failure + ZIP_ER_CHANGED* = 15'i32 ## N Entry has been changed + ZIP_ER_COMPNOTSUPP* = 16'i32 ## N Compression method not supported + ZIP_ER_EOF* = 17'i32 ## N Premature EOF + ZIP_ER_INVAL* = 18'i32 ## N Invalid argument + ZIP_ER_NOZIP* = 19'i32 ## N Not a zip archive + ZIP_ER_INTERNAL* = 20'i32 ## N Internal error + ZIP_ER_INCONS* = 21'i32 ## N Zip archive inconsistent + ZIP_ER_REMOVE* = 22'i32 ## S Can't remove file + ZIP_ER_DELETED* = 23'i32 ## N Entry has been deleted + +const # type of system error value + ZIP_ET_NONE* = 0'i32 ## sys_err unused + ZIP_ET_SYS* = 1'i32 ## sys_err is errno + ZIP_ET_ZLIB* = 2'i32 ## sys_err is zlib error code + +const # compression methods + ZIP_CM_DEFAULT* = -1'i32 ## better of deflate or store + ZIP_CM_STORE* = 0'i32 ## stored (uncompressed) + ZIP_CM_SHRINK* = 1'i32 ## shrunk + ZIP_CM_REDUCE_1* = 2'i32 ## reduced with factor 1 + ZIP_CM_REDUCE_2* = 3'i32 ## reduced with factor 2 + ZIP_CM_REDUCE_3* = 4'i32 ## reduced with factor 3 + ZIP_CM_REDUCE_4* = 5'i32 ## reduced with factor 4 + ZIP_CM_IMPLODE* = 6'i32 ## imploded + ## 7 - Reserved for Tokenizing compression algorithm + ZIP_CM_DEFLATE* = 8'i32 ## deflated + ZIP_CM_DEFLATE64* = 9'i32 ## deflate64 + ZIP_CM_PKWARE_IMPLODE* = 10'i32 ## PKWARE imploding + ## 11 - Reserved by PKWARE + ZIP_CM_BZIP2* = 12'i32 ## compressed using BZIP2 algorithm + ## 13 - Reserved by PKWARE + ZIP_CM_LZMA* = 14'i32 ## LZMA (EFS) + ## 15-17 - Reserved by PKWARE + ZIP_CM_TERSE* = 18'i32 ## compressed using IBM TERSE (new) + ZIP_CM_LZ77* = 19'i32 ## IBM LZ77 z Architecture (PFS) + ZIP_CM_WAVPACK* = 97'i32 ## WavPack compressed data + ZIP_CM_PPMD* = 98'i32 ## PPMd version I, Rev 1 + +const # encryption methods + ZIP_EM_NONE* = 0'i32 ## not encrypted + ZIP_EM_TRAD_PKWARE* = 1'i32 ## traditional PKWARE encryption + +const + ZIP_EM_UNKNOWN* = 0x0000FFFF'i32 ## unknown algorithm + +const + ZIP_SOURCE_OPEN* = 0'i32 ## prepare for reading + ZIP_SOURCE_READ* = 1'i32 ## read data + ZIP_SOURCE_CLOSE* = 2'i32 ## reading is done + ZIP_SOURCE_STAT* = 3'i32 ## get meta information + ZIP_SOURCE_ERROR* = 4'i32 ## get error information + constZIP_SOURCE_FREE* = 5'i32 ## cleanup and free resources + ZIP_SOURCE_SUPPORTS* = 14'i32 ## check supported commands + +proc zip_add*(para1: PZip, para2: cstring, para3: PZipSource): int32 {.cdecl, + importc: "zip_add", mydll.} +proc zip_add_dir*(para1: PZip, para2: cstring): int32 {.cdecl, + importc: "zip_add_dir", mydll.} +proc zip_close*(para1: PZip) {.cdecl, importc: "zip_close", mydll.} +proc zip_delete*(para1: PZip, para2: int32): int32 {.cdecl, mydll, + importc: "zip_delete".} +proc zip_error_clear*(para1: PZip) {.cdecl, importc: "zip_error_clear", mydll.} +proc zip_error_get*(para1: PZip, para2: ptr int32, para3: ptr int32) {.cdecl, + importc: "zip_error_get", mydll.} +proc zip_error_get_sys_type*(para1: int32): int32 {.cdecl, mydll, + importc: "zip_error_get_sys_type".} +proc zip_error_to_str*(para1: cstring, para2: int, para3: int32, + para4: int32): int32 {.cdecl, mydll, + importc: "zip_error_to_str".} +proc zip_fclose*(para1: PZipFile) {.cdecl, mydll, + importc: "zip_fclose".} +proc zip_file_error_clear*(para1: PZipFile) {.cdecl, mydll, + importc: "zip_file_error_clear".} +proc zip_file_error_get*(para1: PZipFile, para2: ptr int32, para3: ptr int32) {. + cdecl, mydll, importc: "zip_file_error_get".} +proc zip_file_strerror*(para1: PZipFile): cstring {.cdecl, mydll, + importc: "zip_file_strerror".} +proc zip_fopen*(para1: PZip, para2: cstring, para3: int32): PZipFile {.cdecl, + mydll, importc: "zip_fopen".} +proc zip_fopen_index*(para1: PZip, para2: int32, para3: int32): PZipFile {. + cdecl, mydll, importc: "zip_fopen_index".} +proc zip_fread*(para1: PZipFile, para2: pointer, para3: int): int {. + cdecl, mydll, importc: "zip_fread".} +proc zip_get_archive_comment*(para1: PZip, para2: ptr int32, para3: int32): cstring {. + cdecl, mydll, importc: "zip_get_archive_comment".} +proc zip_get_archive_flag*(para1: PZip, para2: int32, para3: int32): int32 {. + cdecl, mydll, importc: "zip_get_archive_flag".} +proc zip_get_file_comment*(para1: PZip, para2: int32, para3: ptr int32, + para4: int32): cstring {.cdecl, mydll, + importc: "zip_get_file_comment".} +proc zip_get_name*(para1: PZip, para2: int32, para3: int32): cstring {.cdecl, + mydll, importc: "zip_get_name".} +proc zip_get_num_files*(para1: PZip): int32 {.cdecl, + mydll, importc: "zip_get_num_files".} +proc zip_name_locate*(para1: PZip, para2: cstring, para3: int32): int32 {.cdecl, + mydll, importc: "zip_name_locate".} +proc zip_open*(para1: cstring, para2: int32, para3: ptr int32): PZip {.cdecl, + mydll, importc: "zip_open".} +proc zip_rename*(para1: PZip, para2: int32, para3: cstring): int32 {.cdecl, + mydll, importc: "zip_rename".} +proc zip_replace*(para1: PZip, para2: int32, para3: PZipSource): int32 {.cdecl, + mydll, importc: "zip_replace".} +proc zip_set_archive_comment*(para1: PZip, para2: cstring, para3: int32): int32 {. + cdecl, mydll, importc: "zip_set_archive_comment".} +proc zip_set_archive_flag*(para1: PZip, para2: int32, para3: int32): int32 {. + cdecl, mydll, importc: "zip_set_archive_flag".} +proc zip_set_file_comment*(para1: PZip, para2: int32, para3: cstring, + para4: int32): int32 {.cdecl, mydll, + importc: "zip_set_file_comment".} +proc zip_source_buffer*(para1: PZip, para2: pointer, para3: int, para4: int32): PZipSource {. + cdecl, mydll, importc: "zip_source_buffer".} +proc zip_source_file*(para1: PZip, para2: cstring, para3: int, para4: int): PZipSource {. + cdecl, mydll, importc: "zip_source_file".} +proc zip_source_filep*(para1: PZip, para2: File, para3: int, para4: int): PZipSource {. + cdecl, mydll, importc: "zip_source_filep".} +proc zip_source_free*(para1: PZipSource) {.cdecl, mydll, + importc: "zip_source_free".} +proc zip_source_function*(para1: PZip, para2: ZipSourceCallback, + para3: pointer): PZipSource {.cdecl, mydll, + importc: "zip_source_function".} +proc zip_source_zip*(para1: PZip, para2: PZip, para3: int32, para4: int32, + para5: int, para6: int): PZipSource {.cdecl, mydll, + importc: "zip_source_zip".} +proc zip_stat*(para1: PZip, para2: cstring, para3: int32, para4: PZipStat): int32 {. + cdecl, mydll, importc: "zip_stat".} +proc zip_stat_index*(para1: PZip, para2: int32, para3: int32, para4: PZipStat): int32 {. + cdecl, mydll, importc: "zip_stat_index".} +proc zip_stat_init*(para1: PZipStat) {.cdecl, mydll, importc: "zip_stat_init".} +proc zip_strerror*(para1: PZip): cstring {.cdecl, mydll, importc: "zip_strerror".} +proc zip_unchange*(para1: PZip, para2: int32): int32 {.cdecl, mydll, + importc: "zip_unchange".} +proc zip_unchange_all*(para1: PZip): int32 {.cdecl, mydll, + importc: "zip_unchange_all".} +proc zip_unchange_archive*(para1: PZip): int32 {.cdecl, mydll, + importc: "zip_unchange_archive".} diff --git a/tests/deps/zip-0.2.1/zip/private/libzip_all.c b/tests/deps/zip-0.2.1/zip/private/libzip_all.c new file mode 100644 index 000000000..e0627a7eb --- /dev/null +++ b/tests/deps/zip-0.2.1/zip/private/libzip_all.c @@ -0,0 +1,4193 @@ +/* + zipint.h -- internal declarations. + Copyright (C) 1999-2008 Dieter Baron and Thomas Klausner + + This file is part of libzip, a library to manipulate ZIP archives. + The authors can be contacted at <libzip@nih.at> + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + 3. The names of the authors may not be used to endorse or promote + products derived from this software without specific prior + written permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include <zlib.h> + +/* +#ifdef _MSC_VER +#define ZIP_EXTERN __declspec(dllimport) +#endif +*/ + +/* + zip.h -- exported declarations. + Copyright (C) 1999-2008 Dieter Baron and Thomas Klausner + + This file is part of libzip, a library to manipulate ZIP archives. + The authors can be contacted at <libzip@nih.at> + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + 3. The names of the authors may not be used to endorse or promote + products derived from this software without specific prior + written permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + + +#ifndef ZIP_EXTERN +#define ZIP_EXTERN +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#include <sys/types.h> +#include <stdio.h> +#include <time.h> + +/* flags for zip_open */ + +#define ZIP_CREATE 1 +#define ZIP_EXCL 2 +#define ZIP_CHECKCONS 4 + + +/* flags for zip_name_locate, zip_fopen, zip_stat, ... */ + +#define ZIP_FL_NOCASE 1 /* ignore case on name lookup */ +#define ZIP_FL_NODIR 2 /* ignore directory component */ +#define ZIP_FL_COMPRESSED 4 /* read compressed data */ +#define ZIP_FL_UNCHANGED 8 /* use original data, ignoring changes */ +#define ZIP_FL_RECOMPRESS 16 /* force recompression of data */ + +/* archive global flags flags */ + +#define ZIP_AFL_TORRENT 1 /* torrent zipped */ + +/* libzip error codes */ + +#define ZIP_ER_OK 0 /* N No error */ +#define ZIP_ER_MULTIDISK 1 /* N Multi-disk zip archives not supported */ +#define ZIP_ER_RENAME 2 /* S Renaming temporary file failed */ +#define ZIP_ER_CLOSE 3 /* S Closing zip archive failed */ +#define ZIP_ER_SEEK 4 /* S Seek error */ +#define ZIP_ER_READ 5 /* S Read error */ +#define ZIP_ER_WRITE 6 /* S Write error */ +#define ZIP_ER_CRC 7 /* N CRC error */ +#define ZIP_ER_ZIPCLOSED 8 /* N Containing zip archive was closed */ +#define ZIP_ER_NOENT 9 /* N No such file */ +#define ZIP_ER_EXISTS 10 /* N File already exists */ +#define ZIP_ER_OPEN 11 /* S Can't open file */ +#define ZIP_ER_TMPOPEN 12 /* S Failure to create temporary file */ +#define ZIP_ER_ZLIB 13 /* Z Zlib error */ +#define ZIP_ER_MEMORY 14 /* N Malloc failure */ +#define ZIP_ER_CHANGED 15 /* N Entry has been changed */ +#define ZIP_ER_COMPNOTSUPP 16 /* N Compression method not supported */ +#define ZIP_ER_EOF 17 /* N Premature EOF */ +#define ZIP_ER_INVAL 18 /* N Invalid argument */ +#define ZIP_ER_NOZIP 19 /* N Not a zip archive */ +#define ZIP_ER_INTERNAL 20 /* N Internal error */ +#define ZIP_ER_INCONS 21 /* N Zip archive inconsistent */ +#define ZIP_ER_REMOVE 22 /* S Can't remove file */ +#define ZIP_ER_DELETED 23 /* N Entry has been deleted */ + + +/* type of system error value */ + +#define ZIP_ET_NONE 0 /* sys_err unused */ +#define ZIP_ET_SYS 1 /* sys_err is errno */ +#define ZIP_ET_ZLIB 2 /* sys_err is zlib error code */ + +/* compression methods */ + +#define ZIP_CM_DEFAULT -1 /* better of deflate or store */ +#define ZIP_CM_STORE 0 /* stored (uncompressed) */ +#define ZIP_CM_SHRINK 1 /* shrunk */ +#define ZIP_CM_REDUCE_1 2 /* reduced with factor 1 */ +#define ZIP_CM_REDUCE_2 3 /* reduced with factor 2 */ +#define ZIP_CM_REDUCE_3 4 /* reduced with factor 3 */ +#define ZIP_CM_REDUCE_4 5 /* reduced with factor 4 */ +#define ZIP_CM_IMPLODE 6 /* imploded */ +/* 7 - Reserved for Tokenizing compression algorithm */ +#define ZIP_CM_DEFLATE 8 /* deflated */ +#define ZIP_CM_DEFLATE64 9 /* deflate64 */ +#define ZIP_CM_PKWARE_IMPLODE 10 /* PKWARE imploding */ +/* 11 - Reserved by PKWARE */ +#define ZIP_CM_BZIP2 12 /* compressed using BZIP2 algorithm */ +/* 13 - Reserved by PKWARE */ +#define ZIP_CM_LZMA 14 /* LZMA (EFS) */ +/* 15-17 - Reserved by PKWARE */ +#define ZIP_CM_TERSE 18 /* compressed using IBM TERSE (new) */ +#define ZIP_CM_LZ77 19 /* IBM LZ77 z Architecture (PFS) */ +#define ZIP_CM_WAVPACK 97 /* WavPack compressed data */ +#define ZIP_CM_PPMD 98 /* PPMd version I, Rev 1 */ + +/* encryption methods */ + +#define ZIP_EM_NONE 0 /* not encrypted */ +#define ZIP_EM_TRAD_PKWARE 1 /* traditional PKWARE encryption */ +#if 0 /* Strong Encryption Header not parsed yet */ +#define ZIP_EM_DES 0x6601 /* strong encryption: DES */ +#define ZIP_EM_RC2_OLD 0x6602 /* strong encryption: RC2, version < 5.2 */ +#define ZIP_EM_3DES_168 0x6603 +#define ZIP_EM_3DES_112 0x6609 +#define ZIP_EM_AES_128 0x660e +#define ZIP_EM_AES_192 0x660f +#define ZIP_EM_AES_256 0x6610 +#define ZIP_EM_RC2 0x6702 /* strong encryption: RC2, version >= 5.2 */ +#define ZIP_EM_RC4 0x6801 +#endif +#define ZIP_EM_UNKNOWN 0xffff /* unknown algorithm */ + +typedef long myoff_t; /* XXX: 64 bit support */ + +enum zip_source_cmd { + ZIP_SOURCE_OPEN, /* prepare for reading */ + ZIP_SOURCE_READ, /* read data */ + ZIP_SOURCE_CLOSE, /* reading is done */ + ZIP_SOURCE_STAT, /* get meta information */ + ZIP_SOURCE_ERROR, /* get error information */ + ZIP_SOURCE_FREE /* cleanup and free resources */ +}; + +typedef ssize_t (*zip_source_callback)(void *state, void *data, + size_t len, enum zip_source_cmd cmd); + +struct zip_stat { + const char *name; /* name of the file */ + int index; /* index within archive */ + unsigned int crc; /* crc of file data */ + time_t mtime; /* modification time */ + myoff_t size; /* size of file (uncompressed) */ + myoff_t comp_size; /* size of file (compressed) */ + unsigned short comp_method; /* compression method used */ + unsigned short encryption_method; /* encryption method used */ +}; + +struct zip; +struct zip_file; +struct zip_source; + + +ZIP_EXTERN int zip_add(struct zip *, const char *, struct zip_source *); +ZIP_EXTERN int zip_add_dir(struct zip *, const char *); +ZIP_EXTERN int zip_close(struct zip *); +ZIP_EXTERN int zip_delete(struct zip *, int); +ZIP_EXTERN void zip_error_clear(struct zip *); +ZIP_EXTERN void zip_error_get(struct zip *, int *, int *); +ZIP_EXTERN int zip_error_get_sys_type(int); +ZIP_EXTERN int zip_error_to_str(char *, size_t, int, int); +ZIP_EXTERN int zip_fclose(struct zip_file *); +ZIP_EXTERN void zip_file_error_clear(struct zip_file *); +ZIP_EXTERN void zip_file_error_get(struct zip_file *, int *, int *); +ZIP_EXTERN const char *zip_file_strerror(struct zip_file *); +ZIP_EXTERN struct zip_file *zip_fopen(struct zip *, const char *, int); +ZIP_EXTERN struct zip_file *zip_fopen_index(struct zip *, int, int); +ZIP_EXTERN ssize_t zip_fread(struct zip_file *, void *, size_t); +ZIP_EXTERN const char *zip_get_archive_comment(struct zip *, int *, int); +ZIP_EXTERN int zip_get_archive_flag(struct zip *, int, int); +ZIP_EXTERN const char *zip_get_file_comment(struct zip *, int, int *, int); +ZIP_EXTERN const char *zip_get_name(struct zip *, int, int); +ZIP_EXTERN int zip_get_num_files(struct zip *); +ZIP_EXTERN int zip_name_locate(struct zip *, const char *, int); +ZIP_EXTERN struct zip *zip_open(const char *, int, int *); +ZIP_EXTERN int zip_rename(struct zip *, int, const char *); +ZIP_EXTERN int zip_replace(struct zip *, int, struct zip_source *); +ZIP_EXTERN int zip_set_archive_comment(struct zip *, const char *, int); +ZIP_EXTERN int zip_set_archive_flag(struct zip *, int, int); +ZIP_EXTERN int zip_set_file_comment(struct zip *, int, const char *, int); +ZIP_EXTERN struct zip_source *zip_source_buffer(struct zip *, const void *, + myoff_t, int); +ZIP_EXTERN struct zip_source *zip_source_file(struct zip *, const char *, + myoff_t, myoff_t); +ZIP_EXTERN struct zip_source *zip_source_filep(struct zip *, FILE *, + myoff_t, myoff_t); +ZIP_EXTERN void zip_source_free(struct zip_source *); +ZIP_EXTERN struct zip_source *zip_source_function(struct zip *, + zip_source_callback, void *); +ZIP_EXTERN struct zip_source *zip_source_zip(struct zip *, struct zip *, + int, int, myoff_t, myoff_t); +ZIP_EXTERN int zip_stat(struct zip *, const char *, int, struct zip_stat *); +ZIP_EXTERN int zip_stat_index(struct zip *, int, int, struct zip_stat *); +ZIP_EXTERN void zip_stat_init(struct zip_stat *); +ZIP_EXTERN const char *zip_strerror(struct zip *); +ZIP_EXTERN int zip_unchange(struct zip *, int); +ZIP_EXTERN int zip_unchange_all(struct zip *); +ZIP_EXTERN int zip_unchange_archive(struct zip *); + +#ifdef __cplusplus +} +#endif + + +/* config.h. Generated from config.h.in by configure. */ +/* config.h.in. Generated from configure.ac by autoheader. */ + +/* Define to 1 if you have the declaration of `tzname', and to 0 if you don't. + */ +/* #undef HAVE_DECL_TZNAME */ + +#define HAVE_CONFIG_H 1 + +/* Define to 1 if you have the <dlfcn.h> header file. */ +#define HAVE_DLFCN_H 1 + +/* Define to 1 if you have the `fseeko' function. */ +#define HAVE_FSEEKO 1 + +/* Define to 1 if you have the `ftello' function. */ +#define HAVE_FTELLO 1 + +/* Define to 1 if you have the <inttypes.h> header file. */ +#define HAVE_INTTYPES_H 1 + +/* Define to 1 if you have the `z' library (-lz). */ +#define HAVE_LIBZ 1 + +/* Define to 1 if you have the <memory.h> header file. */ +#define HAVE_MEMORY_H 1 + +/* Define to 1 if you have the `mkstemp' function. */ +#define HAVE_MKSTEMP 1 + +/* Define to 1 if you have the `MoveFileExA' function. */ +/* #undef HAVE_MOVEFILEEXA */ + +/* Define to 1 if you have the <stdint.h> header file. */ +#define HAVE_STDINT_H 1 + +/* Define to 1 if you have the <stdlib.h> header file. */ +#define HAVE_STDLIB_H 1 + +/* Define to 1 if you have the <strings.h> header file. */ +#define HAVE_STRINGS_H 1 + +/* Define to 1 if you have the <string.h> header file. */ +#define HAVE_STRING_H 1 + +/* Define to 1 if `tm_zone' is member of `struct tm'. */ +#ifdef WIN32 +#undef HAVE_STRUCT_TM_TM_ZONE +#else +#define HAVE_STRUCT_TM_TM_ZONE 1 +#endif + +/* Define to 1 if you have the <sys/stat.h> header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define to 1 if you have the <sys/types.h> header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define to 1 if your `struct tm' has `tm_zone'. Deprecated, use + `HAVE_STRUCT_TM_TM_ZONE' instead. */ +#define HAVE_TM_ZONE 1 + +/* Define to 1 if you don't have `tm_zone' but do have the external array + `tzname'. */ +/* #undef HAVE_TZNAME */ + +/* Define to 1 if you have the <unistd.h> header file. */ +#define HAVE_UNISTD_H 1 + +/* Define to 1 if your C compiler doesn't accept -c and -o together. */ +/* #undef NO_MINUS_C_MINUS_O */ + +/* Name of package */ +#define PACKAGE "libzip" + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "libzip@nih.at" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME "libzip" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING "libzip 0.9" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME "libzip" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION "0.9" + +/* Define to 1 if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Define to 1 if your <sys/time.h> declares `struct tm'. */ +/* #undef TM_IN_SYS_TIME */ + +/* Version number of package */ +#define VERSION "0.9" + + +#ifndef HAVE_MKSTEMP +int _zip_mkstemp(char *); +#define mkstemp _zip_mkstemp +#endif + +#ifdef HAVE_MOVEFILEEXA +#include <windows.h> +#define _zip_rename(s, t) \ + (!MoveFileExA((s), (t), \ + MOVEFILE_COPY_ALLOWED|MOVEFILE_REPLACE_EXISTING)) +#else +#define _zip_rename rename +#endif + +#ifndef HAVE_FSEEKO +#define fseeko(s, o, w) (fseek((s), (long int)(o), (w))) +#endif +#ifndef HAVE_FTELLO +#define ftello(s) ((long)ftell((s))) +#endif + + +#define CENTRAL_MAGIC "PK\1\2" +#define LOCAL_MAGIC "PK\3\4" +#define EOCD_MAGIC "PK\5\6" +#define DATADES_MAGIC "PK\7\8" +#define TORRENT_SIG "TORRENTZIPPED-" +#define TORRENT_SIG_LEN 14 +#define TORRENT_CRC_LEN 8 +#define TORRENT_MEM_LEVEL 8 +#define CDENTRYSIZE 46u +#define LENTRYSIZE 30 +#define MAXCOMLEN 65536 +#define EOCDLEN 22 +#define CDBUFSIZE (MAXCOMLEN+EOCDLEN) +#define BUFSIZE 8192 + + +/* state of change of a file in zip archive */ + +enum zip_state { ZIP_ST_UNCHANGED, ZIP_ST_DELETED, ZIP_ST_REPLACED, + ZIP_ST_ADDED, ZIP_ST_RENAMED }; + +/* constants for struct zip_file's member flags */ + +#define ZIP_ZF_EOF 1 /* EOF reached */ +#define ZIP_ZF_DECOMP 2 /* decompress data */ +#define ZIP_ZF_CRC 4 /* compute and compare CRC */ + +/* directory entry: general purpose bit flags */ + +#define ZIP_GPBF_ENCRYPTED 0x0001 /* is encrypted */ +#define ZIP_GPBF_DATA_DESCRIPTOR 0x0008 /* crc/size after file data */ +#define ZIP_GPBF_STRONG_ENCRYPTION 0x0040 /* uses strong encryption */ + +/* error information */ + +struct zip_error { + int zip_err; /* libzip error code (ZIP_ER_*) */ + int sys_err; /* copy of errno (E*) or zlib error code */ + char *str; /* string representation or NULL */ +}; + +/* zip archive, part of API */ + +struct zip { + char *zn; /* file name */ + FILE *zp; /* file */ + struct zip_error error; /* error information */ + + unsigned int flags; /* archive global flags */ + unsigned int ch_flags; /* changed archive global flags */ + + struct zip_cdir *cdir; /* central directory */ + char *ch_comment; /* changed archive comment */ + int ch_comment_len; /* length of changed zip archive + * comment, -1 if unchanged */ + int nentry; /* number of entries */ + int nentry_alloc; /* number of entries allocated */ + struct zip_entry *entry; /* entries */ + int nfile; /* number of opened files within archive */ + int nfile_alloc; /* number of files allocated */ + struct zip_file **file; /* opened files within archive */ +}; + +/* file in zip archive, part of API */ + +struct zip_file { + struct zip *za; /* zip archive containing this file */ + struct zip_error error; /* error information */ + int flags; /* -1: eof, >0: error */ + + int method; /* compression method */ + myoff_t fpos; /* position within zip file (fread/fwrite) */ + unsigned long bytes_left; /* number of bytes left to read */ + unsigned long cbytes_left; /* number of bytes of compressed data left */ + + unsigned long crc; /* CRC so far */ + unsigned long crc_orig; /* CRC recorded in archive */ + + char *buffer; + z_stream *zstr; +}; + +/* zip archive directory entry (central or local) */ + +struct zip_dirent { + unsigned short version_madeby; /* (c) version of creator */ + unsigned short version_needed; /* (cl) version needed to extract */ + unsigned short bitflags; /* (cl) general purpose bit flag */ + unsigned short comp_method; /* (cl) compression method used */ + time_t last_mod; /* (cl) time of last modification */ + unsigned int crc; /* (cl) CRC-32 of uncompressed data */ + unsigned int comp_size; /* (cl) size of commpressed data */ + unsigned int uncomp_size; /* (cl) size of uncommpressed data */ + char *filename; /* (cl) file name (NUL-terminated) */ + unsigned short filename_len; /* (cl) length of filename (w/o NUL) */ + char *extrafield; /* (cl) extra field */ + unsigned short extrafield_len; /* (cl) length of extra field */ + char *comment; /* (c) file comment */ + unsigned short comment_len; /* (c) length of file comment */ + unsigned short disk_number; /* (c) disk number start */ + unsigned short int_attrib; /* (c) internal file attributes */ + unsigned int ext_attrib; /* (c) external file attributes */ + unsigned int offset; /* (c) offset of local header */ +}; + +/* zip archive central directory */ + +struct zip_cdir { + struct zip_dirent *entry; /* directory entries */ + int nentry; /* number of entries */ + + unsigned int size; /* size of central direcotry */ + unsigned int offset; /* offset of central directory in file */ + char *comment; /* zip archive comment */ + unsigned short comment_len; /* length of zip archive comment */ +}; + + + +struct zip_source { + zip_source_callback f; + void *ud; +}; + +/* entry in zip archive directory */ + +struct zip_entry { + enum zip_state state; + struct zip_source *source; + char *ch_filename; + char *ch_comment; + int ch_comment_len; +}; + + + +extern const char * const _zip_err_str[]; +extern const int _zip_nerr_str; +extern const int _zip_err_type[]; + + + +#define ZIP_ENTRY_DATA_CHANGED(x) \ + ((x)->state == ZIP_ST_REPLACED \ + || (x)->state == ZIP_ST_ADDED) + + + +int _zip_cdir_compute_crc(struct zip *, uLong *); +void _zip_cdir_free(struct zip_cdir *); +struct zip_cdir *_zip_cdir_new(int, struct zip_error *); +int _zip_cdir_write(struct zip_cdir *, FILE *, struct zip_error *); + +void _zip_dirent_finalize(struct zip_dirent *); +void _zip_dirent_init(struct zip_dirent *); +int _zip_dirent_read(struct zip_dirent *, FILE *, + unsigned char **, unsigned int, int, struct zip_error *); +void _zip_dirent_torrent_normalize(struct zip_dirent *); +int _zip_dirent_write(struct zip_dirent *, FILE *, int, struct zip_error *); + +void _zip_entry_free(struct zip_entry *); +void _zip_entry_init(struct zip *, int); +struct zip_entry *_zip_entry_new(struct zip *); + +void _zip_error_clear(struct zip_error *); +void _zip_error_copy(struct zip_error *, struct zip_error *); +void _zip_error_fini(struct zip_error *); +void _zip_error_get(struct zip_error *, int *, int *); +void _zip_error_init(struct zip_error *); +void _zip_error_set(struct zip_error *, int, int); +const char *_zip_error_strerror(struct zip_error *); + +int _zip_file_fillbuf(void *, size_t, struct zip_file *); +unsigned int _zip_file_get_offset(struct zip *, int); + +int _zip_filerange_crc(FILE *, myoff_t, myoff_t, uLong *, struct zip_error *); + +struct zip_source *_zip_source_file_or_p(struct zip *, const char *, FILE *, + myoff_t, myoff_t); + +void _zip_free(struct zip *); +const char *_zip_get_name(struct zip *, int, int, struct zip_error *); +int _zip_local_header_read(struct zip *, int); +void *_zip_memdup(const void *, size_t, struct zip_error *); +int _zip_name_locate(struct zip *, const char *, int, struct zip_error *); +struct zip *_zip_new(struct zip_error *); +unsigned short _zip_read2(unsigned char **); +unsigned int _zip_read4(unsigned char **); +int _zip_replace(struct zip *, int, const char *, struct zip_source *); +int _zip_set_name(struct zip *, int, const char *); +int _zip_unchange(struct zip *, int, int); +void _zip_unchange_data(struct zip_entry *); + + +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +const char * +_zip_error_strerror(struct zip_error *err) +{ + const char *zs, *ss; + char buf[128], *s; + + _zip_error_fini(err); + + if (err->zip_err < 0 || err->zip_err >= _zip_nerr_str) { + sprintf(buf, "Unknown error %d", err->zip_err); + zs = NULL; + ss = buf; + } + else { + zs = _zip_err_str[err->zip_err]; + + switch (_zip_err_type[err->zip_err]) { + case ZIP_ET_SYS: + ss = strerror(err->sys_err); + break; + + case ZIP_ET_ZLIB: + ss = zError(err->sys_err); + break; + + default: + ss = NULL; + } + } + + if (ss == NULL) + return zs; + else { + if ((s=(char *)malloc(strlen(ss) + + (zs ? strlen(zs)+2 : 0) + 1)) == NULL) + return _zip_err_str[ZIP_ER_MEMORY]; + + sprintf(s, "%s%s%s", + (zs ? zs : ""), + (zs ? ": " : ""), + ss); + err->str = s; + + return s; + } +} + +#include <stdlib.h> + + + +void +_zip_error_clear(struct zip_error *err) +{ + err->zip_err = ZIP_ER_OK; + err->sys_err = 0; +} + + + +void +_zip_error_copy(struct zip_error *dst, struct zip_error *src) +{ + dst->zip_err = src->zip_err; + dst->sys_err = src->sys_err; +} + + + +void +_zip_error_fini(struct zip_error *err) +{ + free(err->str); + err->str = NULL; +} + + + +void +_zip_error_get(struct zip_error *err, int *zep, int *sep) +{ + if (zep) + *zep = err->zip_err; + if (sep) { + if (zip_error_get_sys_type(err->zip_err) != ZIP_ET_NONE) + *sep = err->sys_err; + else + *sep = 0; + } +} + + + +void +_zip_error_init(struct zip_error *err) +{ + err->zip_err = ZIP_ER_OK; + err->sys_err = 0; + err->str = NULL; +} + + + +void +_zip_error_set(struct zip_error *err, int ze, int se) +{ + if (err) { + err->zip_err = ze; + err->sys_err = se; + } +} + + +#include <sys/types.h> +#include <sys/stat.h> + +#include <assert.h> +#include <ctype.h> +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> + +#ifndef O_BINARY +#define O_BINARY 0 +#endif + + + +int +_zip_mkstemp(char *path) +{ + int fd; + char *start, *trv; + struct stat sbuf; + pid_t pid; + + /* To guarantee multiple calls generate unique names even if + the file is not created. 676 different possibilities with 7 + or more X's, 26 with 6 or less. */ + static char xtra[2] = "aa"; + int xcnt = 0; + + pid = getpid(); + + /* Move to end of path and count trailing X's. */ + for (trv = path; *trv; ++trv) + if (*trv == 'X') + xcnt++; + else + xcnt = 0; + + /* Use at least one from xtra. Use 2 if more than 6 X's. */ + if (*(trv - 1) == 'X') + *--trv = xtra[0]; + if (xcnt > 6 && *(trv - 1) == 'X') + *--trv = xtra[1]; + + /* Set remaining X's to pid digits with 0's to the left. */ + while (*--trv == 'X') { + *trv = (pid % 10) + '0'; + pid /= 10; + } + + /* update xtra for next call. */ + if (xtra[0] != 'z') + xtra[0]++; + else { + xtra[0] = 'a'; + if (xtra[1] != 'z') + xtra[1]++; + else + xtra[1] = 'a'; + } + + /* + * check the target directory; if you have six X's and it + * doesn't exist this runs for a *very* long time. + */ + for (start = trv + 1;; --trv) { + if (trv <= path) + break; + if (*trv == '/') { + *trv = '\0'; + if (stat(path, &sbuf)) + return (0); + if (!S_ISDIR(sbuf.st_mode)) { + errno = ENOTDIR; + return (0); + } + *trv = '/'; + break; + } + } + + for (;;) { + if ((fd=open(path, O_CREAT|O_EXCL|O_RDWR|O_BINARY, 0600)) >= 0) + return (fd); + if (errno != EEXIST) + return (0); + + /* tricky little algorithm for backward compatibility */ + for (trv = start;;) { + if (!*trv) + return (0); + if (*trv == 'z') + *trv++ = 'a'; + else { + if (isdigit((unsigned char)*trv)) + *trv = 'a'; + else + ++*trv; + break; + } + } + } + /*NOTREACHED*/ +} + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <sys/types.h> +#include <sys/stat.h> + +static time_t _zip_d2u_time(int, int); +static char *_zip_readfpstr(FILE *, unsigned int, int, struct zip_error *); +static char *_zip_readstr(unsigned char **, int, int, struct zip_error *); +static void _zip_u2d_time(time_t, unsigned short *, unsigned short *); +static void _zip_write2(unsigned short, FILE *); +static void _zip_write4(unsigned int, FILE *); + + + +void +_zip_cdir_free(struct zip_cdir *cd) +{ + int i; + + if (!cd) + return; + + for (i=0; i<cd->nentry; i++) + _zip_dirent_finalize(cd->entry+i); + free(cd->comment); + free(cd->entry); + free(cd); +} + + + +struct zip_cdir * +_zip_cdir_new(int nentry, struct zip_error *error) +{ + struct zip_cdir *cd; + + if ((cd=(struct zip_cdir *)malloc(sizeof(*cd))) == NULL) { + _zip_error_set(error, ZIP_ER_MEMORY, 0); + return NULL; + } + + if ((cd->entry=(struct zip_dirent *)malloc(sizeof(*(cd->entry))*nentry)) + == NULL) { + _zip_error_set(error, ZIP_ER_MEMORY, 0); + free(cd); + return NULL; + } + + /* entries must be initialized by caller */ + + cd->nentry = nentry; + cd->size = cd->offset = 0; + cd->comment = NULL; + cd->comment_len = 0; + + return cd; +} + + + +int +_zip_cdir_write(struct zip_cdir *cd, FILE *fp, struct zip_error *error) +{ + int i; + + cd->offset = ftello(fp); + + for (i=0; i<cd->nentry; i++) { + if (_zip_dirent_write(cd->entry+i, fp, 0, error) != 0) + return -1; + } + + cd->size = ftello(fp) - cd->offset; + + /* clearerr(fp); */ + fwrite(EOCD_MAGIC, 1, 4, fp); + _zip_write4(0, fp); + _zip_write2((unsigned short)cd->nentry, fp); + _zip_write2((unsigned short)cd->nentry, fp); + _zip_write4(cd->size, fp); + _zip_write4(cd->offset, fp); + _zip_write2(cd->comment_len, fp); + fwrite(cd->comment, 1, cd->comment_len, fp); + + if (ferror(fp)) { + _zip_error_set(error, ZIP_ER_WRITE, errno); + return -1; + } + + return 0; +} + + + +void +_zip_dirent_finalize(struct zip_dirent *zde) +{ + free(zde->filename); + zde->filename = NULL; + free(zde->extrafield); + zde->extrafield = NULL; + free(zde->comment); + zde->comment = NULL; +} + + + +void +_zip_dirent_init(struct zip_dirent *de) +{ + de->version_madeby = 0; + de->version_needed = 20; /* 2.0 */ + de->bitflags = 0; + de->comp_method = 0; + de->last_mod = 0; + de->crc = 0; + de->comp_size = 0; + de->uncomp_size = 0; + de->filename = NULL; + de->filename_len = 0; + de->extrafield = NULL; + de->extrafield_len = 0; + de->comment = NULL; + de->comment_len = 0; + de->disk_number = 0; + de->int_attrib = 0; + de->ext_attrib = 0; + de->offset = 0; +} + + + +/* _zip_dirent_read(zde, fp, bufp, left, localp, error): + Fills the zip directory entry zde. + + If bufp is non-NULL, data is taken from there and bufp is advanced + by the amount of data used; no more than left bytes are used. + Otherwise data is read from fp as needed. + + If localp != 0, it reads a local header instead of a central + directory entry. + + Returns 0 if successful. On error, error is filled in and -1 is + returned. +*/ + +int +_zip_dirent_read(struct zip_dirent *zde, FILE *fp, + unsigned char **bufp, unsigned int left, int localp, + struct zip_error *error) +{ + unsigned char buf[CDENTRYSIZE]; + unsigned char *cur; + unsigned short dostime, dosdate; + unsigned int size; + + if (localp) + size = LENTRYSIZE; + else + size = CDENTRYSIZE; + + if (bufp) { + /* use data from buffer */ + cur = *bufp; + if (left < size) { + _zip_error_set(error, ZIP_ER_NOZIP, 0); + return -1; + } + } + else { + /* read entry from disk */ + if ((fread(buf, 1, size, fp)<size)) { + _zip_error_set(error, ZIP_ER_READ, errno); + return -1; + } + left = size; + cur = buf; + } + + if (memcmp(cur, (localp ? LOCAL_MAGIC : CENTRAL_MAGIC), 4) != 0) { + _zip_error_set(error, ZIP_ER_NOZIP, 0); + return -1; + } + cur += 4; + + + /* convert buffercontents to zip_dirent */ + + if (!localp) + zde->version_madeby = _zip_read2(&cur); + else + zde->version_madeby = 0; + zde->version_needed = _zip_read2(&cur); + zde->bitflags = _zip_read2(&cur); + zde->comp_method = _zip_read2(&cur); + + /* convert to time_t */ + dostime = _zip_read2(&cur); + dosdate = _zip_read2(&cur); + zde->last_mod = _zip_d2u_time(dostime, dosdate); + + zde->crc = _zip_read4(&cur); + zde->comp_size = _zip_read4(&cur); + zde->uncomp_size = _zip_read4(&cur); + + zde->filename_len = _zip_read2(&cur); + zde->extrafield_len = _zip_read2(&cur); + + if (localp) { + zde->comment_len = 0; + zde->disk_number = 0; + zde->int_attrib = 0; + zde->ext_attrib = 0; + zde->offset = 0; + } else { + zde->comment_len = _zip_read2(&cur); + zde->disk_number = _zip_read2(&cur); + zde->int_attrib = _zip_read2(&cur); + zde->ext_attrib = _zip_read4(&cur); + zde->offset = _zip_read4(&cur); + } + + zde->filename = NULL; + zde->extrafield = NULL; + zde->comment = NULL; + + if (bufp) { + if (left < CDENTRYSIZE + (zde->filename_len+zde->extrafield_len + +zde->comment_len)) { + _zip_error_set(error, ZIP_ER_NOZIP, 0); + return -1; + } + + if (zde->filename_len) { + zde->filename = _zip_readstr(&cur, zde->filename_len, 1, error); + if (!zde->filename) + return -1; + } + + if (zde->extrafield_len) { + zde->extrafield = _zip_readstr(&cur, zde->extrafield_len, 0, + error); + if (!zde->extrafield) + return -1; + } + + if (zde->comment_len) { + zde->comment = _zip_readstr(&cur, zde->comment_len, 0, error); + if (!zde->comment) + return -1; + } + } + else { + if (zde->filename_len) { + zde->filename = _zip_readfpstr(fp, zde->filename_len, 1, error); + if (!zde->filename) + return -1; + } + + if (zde->extrafield_len) { + zde->extrafield = _zip_readfpstr(fp, zde->extrafield_len, 0, + error); + if (!zde->extrafield) + return -1; + } + + if (zde->comment_len) { + zde->comment = _zip_readfpstr(fp, zde->comment_len, 0, error); + if (!zde->comment) + return -1; + } + } + + if (bufp) + *bufp = cur; + + return 0; +} + + + +/* _zip_dirent_torrent_normalize(de); + Set values suitable for torrentzip. +*/ + +void +_zip_dirent_torrent_normalize(struct zip_dirent *de) +{ + static struct tm torrenttime; + static time_t last_mod = 0; + + if (last_mod == 0) { +#ifdef HAVE_STRUCT_TM_TM_ZONE + time_t now; + struct tm *l; +#endif + + torrenttime.tm_sec = 0; + torrenttime.tm_min = 32; + torrenttime.tm_hour = 23; + torrenttime.tm_mday = 24; + torrenttime.tm_mon = 11; + torrenttime.tm_year = 96; + torrenttime.tm_wday = 0; + torrenttime.tm_yday = 0; + torrenttime.tm_isdst = 0; + +#ifdef HAVE_STRUCT_TM_TM_ZONE + time(&now); + l = localtime(&now); + torrenttime.tm_gmtoff = l->tm_gmtoff; + torrenttime.tm_zone = l->tm_zone; +#endif + + last_mod = mktime(&torrenttime); + } + + de->version_madeby = 0; + de->version_needed = 20; /* 2.0 */ + de->bitflags = 2; /* maximum compression */ + de->comp_method = ZIP_CM_DEFLATE; + de->last_mod = last_mod; + + de->disk_number = 0; + de->int_attrib = 0; + de->ext_attrib = 0; + de->offset = 0; + + free(de->extrafield); + de->extrafield = NULL; + de->extrafield_len = 0; + free(de->comment); + de->comment = NULL; + de->comment_len = 0; +} + + + +/* _zip_dirent_write(zde, fp, localp, error): + Writes zip directory entry zde to file fp. + + If localp != 0, it writes a local header instead of a central + directory entry. + + Returns 0 if successful. On error, error is filled in and -1 is + returned. +*/ + +int +_zip_dirent_write(struct zip_dirent *zde, FILE *fp, int localp, + struct zip_error *error) +{ + unsigned short dostime, dosdate; + + fwrite(localp ? LOCAL_MAGIC : CENTRAL_MAGIC, 1, 4, fp); + + if (!localp) + _zip_write2(zde->version_madeby, fp); + _zip_write2(zde->version_needed, fp); + _zip_write2(zde->bitflags, fp); + _zip_write2(zde->comp_method, fp); + + _zip_u2d_time(zde->last_mod, &dostime, &dosdate); + _zip_write2(dostime, fp); + _zip_write2(dosdate, fp); + + _zip_write4(zde->crc, fp); + _zip_write4(zde->comp_size, fp); + _zip_write4(zde->uncomp_size, fp); + + _zip_write2(zde->filename_len, fp); + _zip_write2(zde->extrafield_len, fp); + + if (!localp) { + _zip_write2(zde->comment_len, fp); + _zip_write2(zde->disk_number, fp); + _zip_write2(zde->int_attrib, fp); + _zip_write4(zde->ext_attrib, fp); + _zip_write4(zde->offset, fp); + } + + if (zde->filename_len) + fwrite(zde->filename, 1, zde->filename_len, fp); + + if (zde->extrafield_len) + fwrite(zde->extrafield, 1, zde->extrafield_len, fp); + + if (!localp) { + if (zde->comment_len) + fwrite(zde->comment, 1, zde->comment_len, fp); + } + + if (ferror(fp)) { + _zip_error_set(error, ZIP_ER_WRITE, errno); + return -1; + } + + return 0; +} + + + +static time_t +_zip_d2u_time(int dtime, int ddate) +{ + struct tm *tm; + time_t now; + + now = time(NULL); + tm = localtime(&now); + /* let mktime decide if DST is in effect */ + tm->tm_isdst = -1; + + tm->tm_year = ((ddate>>9)&127) + 1980 - 1900; + tm->tm_mon = ((ddate>>5)&15) - 1; + tm->tm_mday = ddate&31; + + tm->tm_hour = (dtime>>11)&31; + tm->tm_min = (dtime>>5)&63; + tm->tm_sec = (dtime<<1)&62; + + return mktime(tm); +} + + + +unsigned short +_zip_read2(unsigned char **a) +{ + unsigned short ret; + + ret = (*a)[0]+((*a)[1]<<8); + *a += 2; + + return ret; +} + + + +unsigned int +_zip_read4(unsigned char **a) +{ + unsigned int ret; + + ret = ((((((*a)[3]<<8)+(*a)[2])<<8)+(*a)[1])<<8)+(*a)[0]; + *a += 4; + + return ret; +} + + + +static char * +_zip_readfpstr(FILE *fp, unsigned int len, int nulp, struct zip_error *error) +{ + char *r, *o; + + r = (char *)malloc(nulp ? len+1 : len); + if (!r) { + _zip_error_set(error, ZIP_ER_MEMORY, 0); + return NULL; + } + + if (fread(r, 1, len, fp)<len) { + free(r); + _zip_error_set(error, ZIP_ER_READ, errno); + return NULL; + } + + if (nulp) { + /* replace any in-string NUL characters with spaces */ + r[len] = 0; + for (o=r; o<r+len; o++) + if (*o == '\0') + *o = ' '; + } + + return r; +} + + + +static char * +_zip_readstr(unsigned char **buf, int len, int nulp, struct zip_error *error) +{ + char *r, *o; + + r = (char *)malloc(nulp ? len+1 : len); + if (!r) { + _zip_error_set(error, ZIP_ER_MEMORY, 0); + return NULL; + } + + memcpy(r, *buf, len); + *buf += len; + + if (nulp) { + /* replace any in-string NUL characters with spaces */ + r[len] = 0; + for (o=r; o<r+len; o++) + if (*o == '\0') + *o = ' '; + } + + return r; +} + + + +static void +_zip_write2(unsigned short i, FILE *fp) +{ + putc(i&0xff, fp); + putc((i>>8)&0xff, fp); + + return; +} + + + +static void +_zip_write4(unsigned int i, FILE *fp) +{ + putc(i&0xff, fp); + putc((i>>8)&0xff, fp); + putc((i>>16)&0xff, fp); + putc((i>>24)&0xff, fp); + + return; +} + + + +static void +_zip_u2d_time(time_t time, unsigned short *dtime, unsigned short *ddate) +{ + struct tm *tm; + + tm = localtime(&time); + *ddate = ((tm->tm_year+1900-1980)<<9) + ((tm->tm_mon+1)<<5) + + tm->tm_mday; + *dtime = ((tm->tm_hour)<<11) + ((tm->tm_min)<<5) + + ((tm->tm_sec)>>1); + + return; +} + + + +ZIP_EXTERN int +zip_delete(struct zip *za, int idx) +{ + if (idx < 0 || idx >= za->nentry) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return -1; + } + + /* allow duplicate file names, because the file will + * be removed directly afterwards */ + if (_zip_unchange(za, idx, 1) != 0) + return -1; + + za->entry[idx].state = ZIP_ST_DELETED; + + return 0; +} + + + +ZIP_EXTERN void +zip_error_clear(struct zip *za) +{ + _zip_error_clear(&za->error); +} + + +ZIP_EXTERN int +zip_add(struct zip *za, const char *name, struct zip_source *source) +{ + if (name == NULL || source == NULL) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return -1; + } + + return _zip_replace(za, -1, name, source); +} + + +ZIP_EXTERN int +zip_error_get_sys_type(int ze) +{ + if (ze < 0 || ze >= _zip_nerr_str) + return 0; + + return _zip_err_type[ze]; +} + + +ZIP_EXTERN void +zip_error_get(struct zip *za, int *zep, int *sep) +{ + _zip_error_get(&za->error, zep, sep); +} + + +const char * const _zip_err_str[] = { + "No error", + "Multi-disk zip archives not supported", + "Renaming temporary file failed", + "Closing zip archive failed", + "Seek error", + "Read error", + "Write error", + "CRC error", + "Containing zip archive was closed", + "No such file", + "File already exists", + "Can't open file", + "Failure to create temporary file", + "Zlib error", + "Malloc failure", + "Entry has been changed", + "Compression method not supported", + "Premature EOF", + "Invalid argument", + "Not a zip archive", + "Internal error", + "Zip archive inconsistent", + "Can't remove file", + "Entry has been deleted", +}; + +const int _zip_nerr_str = sizeof(_zip_err_str)/sizeof(_zip_err_str[0]); + +#define N ZIP_ET_NONE +#define S ZIP_ET_SYS +#define Z ZIP_ET_ZLIB + +const int _zip_err_type[] = { + N, + N, + S, + S, + S, + S, + S, + N, + N, + N, + N, + S, + S, + Z, + N, + N, + N, + N, + N, + N, + N, + N, + S, + N, +}; + + +struct zip_entry * +_zip_entry_new(struct zip *za) +{ + struct zip_entry *ze; + if (!za) { + ze = (struct zip_entry *)malloc(sizeof(struct zip_entry)); + if (!ze) { + _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); + return NULL; + } + } + else { + if (za->nentry >= za->nentry_alloc-1) { + za->nentry_alloc += 16; + za->entry = (struct zip_entry *)realloc(za->entry, + sizeof(struct zip_entry) + * za->nentry_alloc); + if (!za->entry) { + _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); + return NULL; + } + } + ze = za->entry+za->nentry; + } + + ze->state = ZIP_ST_UNCHANGED; + + ze->ch_filename = NULL; + ze->ch_comment = NULL; + ze->ch_comment_len = -1; + ze->source = NULL; + + if (za) + za->nentry++; + + return ze; +} + + +void +_zip_entry_free(struct zip_entry *ze) +{ + free(ze->ch_filename); + ze->ch_filename = NULL; + free(ze->ch_comment); + ze->ch_comment = NULL; + ze->ch_comment_len = -1; + + _zip_unchange_data(ze); +} + + +static int add_data(struct zip *, struct zip_source *, struct zip_dirent *, + FILE *); +static int add_data_comp(zip_source_callback, void *, struct zip_stat *, + FILE *, struct zip_error *); +static int add_data_uncomp(struct zip *, zip_source_callback, void *, + struct zip_stat *, FILE *); +static void ch_set_error(struct zip_error *, zip_source_callback, void *); +static int copy_data(FILE *, myoff_t, FILE *, struct zip_error *); +static int write_cdir(struct zip *, struct zip_cdir *, FILE *); +static int _zip_cdir_set_comment(struct zip_cdir *, struct zip *); +static int _zip_changed(struct zip *, int *); +static char *_zip_create_temp_output(struct zip *, FILE **); +static int _zip_torrentzip_cmp(const void *, const void *); + + + +struct filelist { + int idx; + const char *name; +}; + + + +ZIP_EXTERN int +zip_close(struct zip *za) +{ + int survivors; + int i, j, error; + char *temp; + FILE *out; + mode_t mask; + struct zip_cdir *cd; + struct zip_dirent de; + struct filelist *filelist; + int reopen_on_error; + int new_torrentzip; + + reopen_on_error = 0; + + if (za == NULL) + return -1; + + if (!_zip_changed(za, &survivors)) { + _zip_free(za); + return 0; + } + + /* don't create zip files with no entries */ + if (survivors == 0) { + if (za->zn && za->zp) { + if (remove(za->zn) != 0) { + _zip_error_set(&za->error, ZIP_ER_REMOVE, errno); + return -1; + } + } + _zip_free(za); + return 0; + } + + if ((filelist=(struct filelist *)malloc(sizeof(filelist[0])*survivors)) + == NULL) + return -1; + + if ((cd=_zip_cdir_new(survivors, &za->error)) == NULL) { + free(filelist); + return -1; + } + + for (i=0; i<survivors; i++) + _zip_dirent_init(&cd->entry[i]); + + /* archive comment is special for torrentzip */ + if (zip_get_archive_flag(za, ZIP_AFL_TORRENT, 0)) { + cd->comment = _zip_memdup(TORRENT_SIG "XXXXXXXX", + TORRENT_SIG_LEN + TORRENT_CRC_LEN, + &za->error); + if (cd->comment == NULL) { + _zip_cdir_free(cd); + free(filelist); + return -1; + } + cd->comment_len = TORRENT_SIG_LEN + TORRENT_CRC_LEN; + } + else if (zip_get_archive_flag(za, ZIP_AFL_TORRENT, ZIP_FL_UNCHANGED) == 0) { + if (_zip_cdir_set_comment(cd, za) == -1) { + _zip_cdir_free(cd); + free(filelist); + return -1; + } + } + + if ((temp=_zip_create_temp_output(za, &out)) == NULL) { + _zip_cdir_free(cd); + return -1; + } + + + /* create list of files with index into original archive */ + for (i=j=0; i<za->nentry; i++) { + if (za->entry[i].state == ZIP_ST_DELETED) + continue; + + filelist[j].idx = i; + filelist[j].name = zip_get_name(za, i, 0); + j++; + } + if (zip_get_archive_flag(za, ZIP_AFL_TORRENT, 0)) + qsort(filelist, survivors, sizeof(filelist[0]), + _zip_torrentzip_cmp); + + new_torrentzip = (zip_get_archive_flag(za, ZIP_AFL_TORRENT, 0) == 1 + && zip_get_archive_flag(za, ZIP_AFL_TORRENT, + ZIP_FL_UNCHANGED) == 0); + error = 0; + for (j=0; j<survivors; j++) { + i = filelist[j].idx; + + /* create new local directory entry */ + if (ZIP_ENTRY_DATA_CHANGED(za->entry+i) || new_torrentzip) { + _zip_dirent_init(&de); + + if (zip_get_archive_flag(za, ZIP_AFL_TORRENT, 0)) + _zip_dirent_torrent_normalize(&de); + + /* use it as central directory entry */ + memcpy(cd->entry+j, &de, sizeof(cd->entry[j])); + + /* set/update file name */ + if (za->entry[i].ch_filename == NULL) { + if (za->entry[i].state == ZIP_ST_ADDED) { + de.filename = strdup("-"); + de.filename_len = 1; + cd->entry[j].filename = "-"; + } + else { + de.filename = strdup(za->cdir->entry[i].filename); + de.filename_len = strlen(de.filename); + cd->entry[j].filename = za->cdir->entry[i].filename; + cd->entry[j].filename_len = de.filename_len; + } + } + } + else { + /* copy existing directory entries */ + if (fseeko(za->zp, za->cdir->entry[i].offset, SEEK_SET) != 0) { + _zip_error_set(&za->error, ZIP_ER_SEEK, errno); + error = 1; + break; + } + if (_zip_dirent_read(&de, za->zp, NULL, 0, 1, &za->error) != 0) { + error = 1; + break; + } + if (de.bitflags & ZIP_GPBF_DATA_DESCRIPTOR) { + de.crc = za->cdir->entry[i].crc; + de.comp_size = za->cdir->entry[i].comp_size; + de.uncomp_size = za->cdir->entry[i].uncomp_size; + de.bitflags &= ~ZIP_GPBF_DATA_DESCRIPTOR; + } + memcpy(cd->entry+j, za->cdir->entry+i, sizeof(cd->entry[j])); + } + + if (za->entry[i].ch_filename) { + free(de.filename); + if ((de.filename=strdup(za->entry[i].ch_filename)) == NULL) { + error = 1; + break; + } + de.filename_len = strlen(de.filename); + cd->entry[j].filename = za->entry[i].ch_filename; + cd->entry[j].filename_len = de.filename_len; + } + + if (zip_get_archive_flag(za, ZIP_AFL_TORRENT, 0) == 0 + && za->entry[i].ch_comment_len != -1) { + /* as the rest of cd entries, its malloc/free is done by za */ + cd->entry[j].comment = za->entry[i].ch_comment; + cd->entry[j].comment_len = za->entry[i].ch_comment_len; + } + + cd->entry[j].offset = ftello(out); + + if (ZIP_ENTRY_DATA_CHANGED(za->entry+i) || new_torrentzip) { + struct zip_source *zs; + + zs = NULL; + if (!ZIP_ENTRY_DATA_CHANGED(za->entry+i)) { + if ((zs=zip_source_zip(za, za, i, ZIP_FL_RECOMPRESS, 0, -1)) + == NULL) { + error = 1; + break; + } + } + + if (add_data(za, zs ? zs : za->entry[i].source, &de, out) < 0) { + error = 1; + break; + } + cd->entry[j].last_mod = de.last_mod; + cd->entry[j].comp_method = de.comp_method; + cd->entry[j].comp_size = de.comp_size; + cd->entry[j].uncomp_size = de.uncomp_size; + cd->entry[j].crc = de.crc; + } + else { + if (_zip_dirent_write(&de, out, 1, &za->error) < 0) { + error = 1; + break; + } + /* we just read the local dirent, file is at correct position */ + if (copy_data(za->zp, cd->entry[j].comp_size, out, + &za->error) < 0) { + error = 1; + break; + } + } + + _zip_dirent_finalize(&de); + } + + if (!error) { + if (write_cdir(za, cd, out) < 0) + error = 1; + } + + /* pointers in cd entries are owned by za */ + cd->nentry = 0; + _zip_cdir_free(cd); + + if (error) { + _zip_dirent_finalize(&de); + fclose(out); + remove(temp); + free(temp); + return -1; + } + + if (fclose(out) != 0) { + _zip_error_set(&za->error, ZIP_ER_CLOSE, errno); + remove(temp); + free(temp); + return -1; + } + + if (za->zp) { + fclose(za->zp); + za->zp = NULL; + reopen_on_error = 1; + } + if (_zip_rename(temp, za->zn) != 0) { + _zip_error_set(&za->error, ZIP_ER_RENAME, errno); + remove(temp); + free(temp); + if (reopen_on_error) { + /* ignore errors, since we're already in an error case */ + za->zp = fopen(za->zn, "rb"); + } + return -1; + } + mask = umask(0); + umask(mask); + chmod(za->zn, 0666&~mask); + + _zip_free(za); + free(temp); + + return 0; +} + + + +static int +add_data(struct zip *za, struct zip_source *zs, struct zip_dirent *de, FILE *ft) +{ + myoff_t offstart, offend; + zip_source_callback cb; + void *ud; + struct zip_stat st; + + cb = zs->f; + ud = zs->ud; + + if (cb(ud, &st, sizeof(st), ZIP_SOURCE_STAT) < (ssize_t)sizeof(st)) { + ch_set_error(&za->error, cb, ud); + return -1; + } + + if (cb(ud, NULL, 0, ZIP_SOURCE_OPEN) < 0) { + ch_set_error(&za->error, cb, ud); + return -1; + } + + offstart = ftello(ft); + + if (_zip_dirent_write(de, ft, 1, &za->error) < 0) + return -1; + + if (st.comp_method != ZIP_CM_STORE) { + if (add_data_comp(cb, ud, &st, ft, &za->error) < 0) + return -1; + } + else { + if (add_data_uncomp(za, cb, ud, &st, ft) < 0) + return -1; + } + + if (cb(ud, NULL, 0, ZIP_SOURCE_CLOSE) < 0) { + ch_set_error(&za->error, cb, ud); + return -1; + } + + offend = ftello(ft); + + if (fseeko(ft, offstart, SEEK_SET) < 0) { + _zip_error_set(&za->error, ZIP_ER_SEEK, errno); + return -1; + } + + + de->last_mod = st.mtime; + de->comp_method = st.comp_method; + de->crc = st.crc; + de->uncomp_size = st.size; + de->comp_size = st.comp_size; + + if (zip_get_archive_flag(za, ZIP_AFL_TORRENT, 0)) + _zip_dirent_torrent_normalize(de); + + if (_zip_dirent_write(de, ft, 1, &za->error) < 0) + return -1; + + if (fseeko(ft, offend, SEEK_SET) < 0) { + _zip_error_set(&za->error, ZIP_ER_SEEK, errno); + return -1; + } + + return 0; +} + + + +static int +add_data_comp(zip_source_callback cb, void *ud, struct zip_stat *st,FILE *ft, + struct zip_error *error) +{ + char buf[BUFSIZE]; + ssize_t n; + + st->comp_size = 0; + while ((n=cb(ud, buf, sizeof(buf), ZIP_SOURCE_READ)) > 0) { + if (fwrite(buf, 1, n, ft) != (size_t)n) { + _zip_error_set(error, ZIP_ER_WRITE, errno); + return -1; + } + + st->comp_size += n; + } + if (n < 0) { + ch_set_error(error, cb, ud); + return -1; + } + + return 0; +} + + + +static int +add_data_uncomp(struct zip *za, zip_source_callback cb, void *ud, + struct zip_stat *st, FILE *ft) +{ + char b1[BUFSIZE], b2[BUFSIZE]; + int end, flush, ret; + ssize_t n; + size_t n2; + z_stream zstr; + int mem_level; + + st->comp_method = ZIP_CM_DEFLATE; + st->comp_size = st->size = 0; + st->crc = crc32(0, NULL, 0); + + zstr.zalloc = Z_NULL; + zstr.zfree = Z_NULL; + zstr.opaque = NULL; + zstr.avail_in = 0; + zstr.avail_out = 0; + + if (zip_get_archive_flag(za, ZIP_AFL_TORRENT, 0)) + mem_level = TORRENT_MEM_LEVEL; + else + mem_level = MAX_MEM_LEVEL; + + /* -MAX_WBITS: undocumented feature of zlib to _not_ write a zlib header */ + deflateInit2(&zstr, Z_BEST_COMPRESSION, Z_DEFLATED, -MAX_WBITS, mem_level, + Z_DEFAULT_STRATEGY); + + zstr.next_out = (Bytef *)b2; + zstr.avail_out = sizeof(b2); + zstr.avail_in = 0; + + flush = 0; + end = 0; + while (!end) { + if (zstr.avail_in == 0 && !flush) { + if ((n=cb(ud, b1, sizeof(b1), ZIP_SOURCE_READ)) < 0) { + ch_set_error(&za->error, cb, ud); + deflateEnd(&zstr); + return -1; + } + if (n > 0) { + zstr.avail_in = n; + zstr.next_in = (Bytef *)b1; + st->size += n; + st->crc = crc32(st->crc, (Bytef *)b1, n); + } + else + flush = Z_FINISH; + } + + ret = deflate(&zstr, flush); + if (ret != Z_OK && ret != Z_STREAM_END) { + _zip_error_set(&za->error, ZIP_ER_ZLIB, ret); + return -1; + } + + if (zstr.avail_out != sizeof(b2)) { + n2 = sizeof(b2) - zstr.avail_out; + + if (fwrite(b2, 1, n2, ft) != n2) { + _zip_error_set(&za->error, ZIP_ER_WRITE, errno); + return -1; + } + + zstr.next_out = (Bytef *)b2; + zstr.avail_out = sizeof(b2); + st->comp_size += n2; + } + + if (ret == Z_STREAM_END) { + deflateEnd(&zstr); + end = 1; + } + } + + return 0; +} + + + +static void +ch_set_error(struct zip_error *error, zip_source_callback cb, void *ud) +{ + int e[2]; + + if ((cb(ud, e, sizeof(e), ZIP_SOURCE_ERROR)) < (ssize_t)sizeof(e)) { + error->zip_err = ZIP_ER_INTERNAL; + error->sys_err = 0; + } + else { + error->zip_err = e[0]; + error->sys_err = e[1]; + } +} + + + +static int +copy_data(FILE *fs, myoff_t len, FILE *ft, struct zip_error *error) +{ + char buf[BUFSIZE]; + int n, nn; + + if (len == 0) + return 0; + + while (len > 0) { + nn = len > sizeof(buf) ? sizeof(buf) : len; + if ((n=fread(buf, 1, nn, fs)) < 0) { + _zip_error_set(error, ZIP_ER_READ, errno); + return -1; + } + else if (n == 0) { + _zip_error_set(error, ZIP_ER_EOF, 0); + return -1; + } + + if (fwrite(buf, 1, n, ft) != (size_t)n) { + _zip_error_set(error, ZIP_ER_WRITE, errno); + return -1; + } + + len -= n; + } + + return 0; +} + + + +static int +write_cdir(struct zip *za, struct zip_cdir *cd, FILE *out) +{ + myoff_t offset; + uLong crc; + char buf[TORRENT_CRC_LEN+1]; + + if (_zip_cdir_write(cd, out, &za->error) < 0) + return -1; + + if (zip_get_archive_flag(za, ZIP_AFL_TORRENT, 0) == 0) + return 0; + + + /* fix up torrentzip comment */ + + offset = ftello(out); + + if (_zip_filerange_crc(out, cd->offset, cd->size, &crc, &za->error) < 0) + return -1; + + snprintf(buf, sizeof(buf), "%08lX", (long)crc); + + if (fseeko(out, offset-TORRENT_CRC_LEN, SEEK_SET) < 0) { + _zip_error_set(&za->error, ZIP_ER_SEEK, errno); + return -1; + } + + if (fwrite(buf, TORRENT_CRC_LEN, 1, out) != 1) { + _zip_error_set(&za->error, ZIP_ER_WRITE, errno); + return -1; + } + + return 0; +} + + + +static int +_zip_cdir_set_comment(struct zip_cdir *dest, struct zip *src) +{ + if (src->ch_comment_len != -1) { + dest->comment = _zip_memdup(src->ch_comment, + src->ch_comment_len, &src->error); + if (dest->comment == NULL) + return -1; + dest->comment_len = src->ch_comment_len; + } else { + if (src->cdir && src->cdir->comment) { + dest->comment = _zip_memdup(src->cdir->comment, + src->cdir->comment_len, &src->error); + if (dest->comment == NULL) + return -1; + dest->comment_len = src->cdir->comment_len; + } + } + + return 0; +} + + + +static int +_zip_changed(struct zip *za, int *survivorsp) +{ + int changed, i, survivors; + + changed = survivors = 0; + + if (za->ch_comment_len != -1 + || za->ch_flags != za->flags) + changed = 1; + + for (i=0; i<za->nentry; i++) { + if ((za->entry[i].state != ZIP_ST_UNCHANGED) + || (za->entry[i].ch_comment_len != -1)) + changed = 1; + if (za->entry[i].state != ZIP_ST_DELETED) + survivors++; + } + + *survivorsp = survivors; + + return changed; +} + + + +static char * +_zip_create_temp_output(struct zip *za, FILE **outp) +{ + char *temp; + int tfd; + FILE *tfp; + + if ((temp=(char *)malloc(strlen(za->zn)+8)) == NULL) { + _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); + return NULL; + } + + sprintf(temp, "%s.XXXXXX", za->zn); + + if ((tfd=mkstemp(temp)) == -1) { + _zip_error_set(&za->error, ZIP_ER_TMPOPEN, errno); + free(temp); + return NULL; + } + + if ((tfp=fdopen(tfd, "r+b")) == NULL) { + _zip_error_set(&za->error, ZIP_ER_TMPOPEN, errno); + close(tfd); + remove(temp); + free(temp); + return NULL; + } + + *outp = tfp; + return temp; +} + + + +static int +_zip_torrentzip_cmp(const void *a, const void *b) +{ + return strcasecmp(((const struct filelist *)a)->name, + ((const struct filelist *)b)->name); +} + + + +ZIP_EXTERN int +zip_add_dir(struct zip *za, const char *name) +{ + int len, ret; + char *s; + struct zip_source *source; + + if (name == NULL) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return -1; + } + + s = NULL; + len = strlen(name); + + if (name[len-1] != '/') { + if ((s=(char *)malloc(len+2)) == NULL) { + _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); + return -1; + } + strcpy(s, name); + s[len] = '/'; + s[len+1] = '\0'; + } + + if ((source=zip_source_buffer(za, NULL, 0, 0)) == NULL) { + free(s); + return -1; + } + + ret = _zip_replace(za, -1, s ? s : name, source); + + free(s); + if (ret < 0) + zip_source_free(source); + + return ret; +} + + +ZIP_EXTERN int +zip_error_to_str(char *buf, size_t len, int ze, int se) +{ + const char *zs, *ss; + + if (ze < 0 || ze >= _zip_nerr_str) + return snprintf(buf, len, "Unknown error %d", ze); + + zs = _zip_err_str[ze]; + + switch (_zip_err_type[ze]) { + case ZIP_ET_SYS: + ss = strerror(se); + break; + + case ZIP_ET_ZLIB: + ss = zError(se); + break; + + default: + ss = NULL; + } + + return snprintf(buf, len, "%s%s%s", + zs, (ss ? ": " : ""), (ss ? ss : "")); +} + + +ZIP_EXTERN void +zip_file_error_clear(struct zip_file *zf) +{ + _zip_error_clear(&zf->error); +} + + +ZIP_EXTERN int +zip_fclose(struct zip_file *zf) +{ + int i, ret; + + if (zf->zstr) + inflateEnd(zf->zstr); + free(zf->buffer); + free(zf->zstr); + + for (i=0; i<zf->za->nfile; i++) { + if (zf->za->file[i] == zf) { + zf->za->file[i] = zf->za->file[zf->za->nfile-1]; + zf->za->nfile--; + break; + } + } + + ret = 0; + if (zf->error.zip_err) + ret = zf->error.zip_err; + else if ((zf->flags & ZIP_ZF_CRC) && (zf->flags & ZIP_ZF_EOF)) { + /* if EOF, compare CRC */ + if (zf->crc_orig != zf->crc) + ret = ZIP_ER_CRC; + } + + free(zf); + return ret; +} + + +int +_zip_filerange_crc(FILE *fp, myoff_t start, myoff_t len, uLong *crcp, + struct zip_error *errp) +{ + Bytef buf[BUFSIZE]; + size_t n; + + *crcp = crc32(0L, Z_NULL, 0); + + if (fseeko(fp, start, SEEK_SET) != 0) { + _zip_error_set(errp, ZIP_ER_SEEK, errno); + return -1; + } + + while (len > 0) { + n = len > BUFSIZE ? BUFSIZE : len; + if ((n=fread(buf, 1, n, fp)) <= 0) { + _zip_error_set(errp, ZIP_ER_READ, errno); + return -1; + } + + *crcp = crc32(*crcp, buf, n); + + len-= n; + } + + return 0; +} + + +ZIP_EXTERN const char * +zip_file_strerror(struct zip_file *zf) +{ + return _zip_error_strerror(&zf->error); +} + + +/* _zip_file_get_offset(za, ze): + Returns the offset of the file data for entry ze. + + On error, fills in za->error and returns 0. +*/ + +unsigned int +_zip_file_get_offset(struct zip *za, int idx) +{ + struct zip_dirent de; + unsigned int offset; + + offset = za->cdir->entry[idx].offset; + + if (fseeko(za->zp, offset, SEEK_SET) != 0) { + _zip_error_set(&za->error, ZIP_ER_SEEK, errno); + return 0; + } + + if (_zip_dirent_read(&de, za->zp, NULL, 0, 1, &za->error) != 0) + return 0; + + offset += LENTRYSIZE + de.filename_len + de.extrafield_len; + + _zip_dirent_finalize(&de); + + return offset; +} + + +ZIP_EXTERN void +zip_file_error_get(struct zip_file *zf, int *zep, int *sep) +{ + _zip_error_get(&zf->error, zep, sep); +} + + +static struct zip_file *_zip_file_new(struct zip *za); + + + +ZIP_EXTERN struct zip_file * +zip_fopen_index(struct zip *za, int fileno, int flags) +{ + int len, ret; + int zfflags; + struct zip_file *zf; + + if ((fileno < 0) || (fileno >= za->nentry)) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return NULL; + } + + if ((flags & ZIP_FL_UNCHANGED) == 0 + && ZIP_ENTRY_DATA_CHANGED(za->entry+fileno)) { + _zip_error_set(&za->error, ZIP_ER_CHANGED, 0); + return NULL; + } + + if (fileno >= za->cdir->nentry) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return NULL; + } + + zfflags = 0; + switch (za->cdir->entry[fileno].comp_method) { + case ZIP_CM_STORE: + zfflags |= ZIP_ZF_CRC; + break; + + case ZIP_CM_DEFLATE: + if ((flags & ZIP_FL_COMPRESSED) == 0) + zfflags |= ZIP_ZF_CRC | ZIP_ZF_DECOMP; + break; + default: + if ((flags & ZIP_FL_COMPRESSED) == 0) { + _zip_error_set(&za->error, ZIP_ER_COMPNOTSUPP, 0); + return NULL; + } + break; + } + + zf = _zip_file_new(za); + + zf->flags = zfflags; + /* zf->name = za->cdir->entry[fileno].filename; */ + zf->method = za->cdir->entry[fileno].comp_method; + zf->bytes_left = za->cdir->entry[fileno].uncomp_size; + zf->cbytes_left = za->cdir->entry[fileno].comp_size; + zf->crc_orig = za->cdir->entry[fileno].crc; + + if ((zf->fpos=_zip_file_get_offset(za, fileno)) == 0) { + zip_fclose(zf); + return NULL; + } + + if ((zf->flags & ZIP_ZF_DECOMP) == 0) + zf->bytes_left = zf->cbytes_left; + else { + if ((zf->buffer=(char *)malloc(BUFSIZE)) == NULL) { + _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); + zip_fclose(zf); + return NULL; + } + + len = _zip_file_fillbuf(zf->buffer, BUFSIZE, zf); + if (len <= 0) { + _zip_error_copy(&za->error, &zf->error); + zip_fclose(zf); + return NULL; + } + + if ((zf->zstr = (z_stream *)malloc(sizeof(z_stream))) == NULL) { + _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); + zip_fclose(zf); + return NULL; + } + zf->zstr->zalloc = Z_NULL; + zf->zstr->zfree = Z_NULL; + zf->zstr->opaque = NULL; + zf->zstr->next_in = (Bytef *)zf->buffer; + zf->zstr->avail_in = len; + + /* negative value to tell zlib that there is no header */ + if ((ret=inflateInit2(zf->zstr, -MAX_WBITS)) != Z_OK) { + _zip_error_set(&za->error, ZIP_ER_ZLIB, ret); + zip_fclose(zf); + return NULL; + } + } + + return zf; +} + + + +int +_zip_file_fillbuf(void *buf, size_t buflen, struct zip_file *zf) +{ + int i, j; + + if (zf->error.zip_err != ZIP_ER_OK) + return -1; + + if ((zf->flags & ZIP_ZF_EOF) || zf->cbytes_left <= 0 || buflen <= 0) + return 0; + + if (fseeko(zf->za->zp, zf->fpos, SEEK_SET) < 0) { + _zip_error_set(&zf->error, ZIP_ER_SEEK, errno); + return -1; + } + if (buflen < zf->cbytes_left) + i = buflen; + else + i = zf->cbytes_left; + + j = fread(buf, 1, i, zf->za->zp); + if (j == 0) { + _zip_error_set(&zf->error, ZIP_ER_EOF, 0); + j = -1; + } + else if (j < 0) + _zip_error_set(&zf->error, ZIP_ER_READ, errno); + else { + zf->fpos += j; + zf->cbytes_left -= j; + } + + return j; +} + + + +static struct zip_file * +_zip_file_new(struct zip *za) +{ + struct zip_file *zf, **file; + int n; + + if ((zf=(struct zip_file *)malloc(sizeof(struct zip_file))) == NULL) { + _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); + return NULL; + } + + if (za->nfile >= za->nfile_alloc-1) { + n = za->nfile_alloc + 10; + file = (struct zip_file **)realloc(za->file, + n*sizeof(struct zip_file *)); + if (file == NULL) { + _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); + free(zf); + return NULL; + } + za->nfile_alloc = n; + za->file = file; + } + + za->file[za->nfile++] = zf; + + zf->za = za; + _zip_error_init(&zf->error); + zf->flags = 0; + zf->crc = crc32(0L, Z_NULL, 0); + zf->crc_orig = 0; + zf->method = -1; + zf->bytes_left = zf->cbytes_left = 0; + zf->fpos = 0; + zf->buffer = NULL; + zf->zstr = NULL; + + return zf; +} + + +ZIP_EXTERN struct zip_file * +zip_fopen(struct zip *za, const char *fname, int flags) +{ + int idx; + + if ((idx=zip_name_locate(za, fname, flags)) < 0) + return NULL; + + return zip_fopen_index(za, idx, flags); +} + + +ZIP_EXTERN int +zip_set_file_comment(struct zip *za, int idx, const char *comment, int len) +{ + char *tmpcom; + + if (idx < 0 || idx >= za->nentry + || len < 0 || len > MAXCOMLEN + || (len > 0 && comment == NULL)) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return -1; + } + + if (len > 0) { + if ((tmpcom=(char *)_zip_memdup(comment, len, &za->error)) == NULL) + return -1; + } + else + tmpcom = NULL; + + free(za->entry[idx].ch_comment); + za->entry[idx].ch_comment = tmpcom; + za->entry[idx].ch_comment_len = len; + + return 0; +} + + +ZIP_EXTERN struct zip_source * +zip_source_file(struct zip *za, const char *fname, myoff_t start, myoff_t len) +{ + if (za == NULL) + return NULL; + + if (fname == NULL || start < 0 || len < -1) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return NULL; + } + + return _zip_source_file_or_p(za, fname, NULL, start, len); +} + + +struct read_data { + const char *buf, *data, *end; + time_t mtime; + int freep; +}; + +static ssize_t read_data(void *state, void *data, size_t len, + enum zip_source_cmd cmd); + + + +ZIP_EXTERN struct zip_source * +zip_source_buffer(struct zip *za, const void *data, myoff_t len, int freep) +{ + struct read_data *f; + struct zip_source *zs; + + if (za == NULL) + return NULL; + + if (len < 0 || (data == NULL && len > 0)) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return NULL; + } + + if ((f=(struct read_data *)malloc(sizeof(*f))) == NULL) { + _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); + return NULL; + } + + f->data = (const char *)data; + f->end = ((const char *)data)+len; + f->freep = freep; + f->mtime = time(NULL); + + if ((zs=zip_source_function(za, read_data, f)) == NULL) { + free(f); + return NULL; + } + + return zs; +} + + + +static ssize_t +read_data(void *state, void *data, size_t len, enum zip_source_cmd cmd) +{ + struct read_data *z; + char *buf; + size_t n; + + z = (struct read_data *)state; + buf = (char *)data; + + switch (cmd) { + case ZIP_SOURCE_OPEN: + z->buf = z->data; + return 0; + + case ZIP_SOURCE_READ: + n = z->end - z->buf; + if (n > len) + n = len; + + if (n) { + memcpy(buf, z->buf, n); + z->buf += n; + } + + return n; + + case ZIP_SOURCE_CLOSE: + return 0; + + case ZIP_SOURCE_STAT: + { + struct zip_stat *st; + + if (len < sizeof(*st)) + return -1; + + st = (struct zip_stat *)data; + + zip_stat_init(st); + st->mtime = z->mtime; + st->size = z->end - z->data; + + return sizeof(*st); + } + + case ZIP_SOURCE_ERROR: + { + int *e; + + if (len < sizeof(int)*2) + return -1; + + e = (int *)data; + e[0] = e[1] = 0; + } + return sizeof(int)*2; + + case ZIP_SOURCE_FREE: + if (z->freep) { + free((void *)z->data); + z->data = NULL; + } + free(z); + return 0; + + default: + ; + } + + return -1; +} + + +int +_zip_set_name(struct zip *za, int idx, const char *name) +{ + char *s; + int i; + + if (idx < 0 || idx >= za->nentry || name == NULL) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return -1; + } + + if ((i=_zip_name_locate(za, name, 0, NULL)) != -1 && i != idx) { + _zip_error_set(&za->error, ZIP_ER_EXISTS, 0); + return -1; + } + + /* no effective name change */ + if (i == idx) + return 0; + + if ((s=strdup(name)) == NULL) { + _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); + return -1; + } + + if (za->entry[idx].state == ZIP_ST_UNCHANGED) + za->entry[idx].state = ZIP_ST_RENAMED; + + free(za->entry[idx].ch_filename); + za->entry[idx].ch_filename = s; + + return 0; +} + + +ZIP_EXTERN int +zip_set_archive_flag(struct zip *za, int flag, int value) +{ + if (value) + za->ch_flags |= flag; + else + za->ch_flags &= ~flag; + + return 0; +} + + +void +_zip_unchange_data(struct zip_entry *ze) +{ + if (ze->source) { + (void)ze->source->f(ze->source->ud, NULL, 0, ZIP_SOURCE_FREE); + free(ze->source); + ze->source = NULL; + } + + ze->state = ze->ch_filename ? ZIP_ST_RENAMED : ZIP_ST_UNCHANGED; +} + + +ZIP_EXTERN int +zip_unchange_archive(struct zip *za) +{ + free(za->ch_comment); + za->ch_comment = NULL; + za->ch_comment_len = -1; + + za->ch_flags = za->flags; + + return 0; +} + +ZIP_EXTERN int +zip_unchange(struct zip *za, int idx) +{ + return _zip_unchange(za, idx, 0); +} + + + +int +_zip_unchange(struct zip *za, int idx, int allow_duplicates) +{ + int i; + + if (idx < 0 || idx >= za->nentry) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return -1; + } + + if (za->entry[idx].ch_filename) { + if (!allow_duplicates) { + i = _zip_name_locate(za, + _zip_get_name(za, idx, ZIP_FL_UNCHANGED, NULL), + 0, NULL); + if (i != -1 && i != idx) { + _zip_error_set(&za->error, ZIP_ER_EXISTS, 0); + return -1; + } + } + + free(za->entry[idx].ch_filename); + za->entry[idx].ch_filename = NULL; + } + + free(za->entry[idx].ch_comment); + za->entry[idx].ch_comment = NULL; + za->entry[idx].ch_comment_len = -1; + + _zip_unchange_data(za->entry+idx); + + return 0; +} + +ZIP_EXTERN int +zip_unchange_all(struct zip *za) +{ + int ret, i; + + ret = 0; + for (i=0; i<za->nentry; i++) + ret |= _zip_unchange(za, i, 1); + + ret |= zip_unchange_archive(za); + + return ret; +} + + +ZIP_EXTERN int +zip_set_archive_comment(struct zip *za, const char *comment, int len) +{ + char *tmpcom; + + if (len < 0 || len > MAXCOMLEN + || (len > 0 && comment == NULL)) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return -1; + } + + if (len > 0) { + if ((tmpcom=(char *)_zip_memdup(comment, len, &za->error)) == NULL) + return -1; + } + else + tmpcom = NULL; + + free(za->ch_comment); + za->ch_comment = tmpcom; + za->ch_comment_len = len; + + return 0; +} + + +ZIP_EXTERN int +zip_replace(struct zip *za, int idx, struct zip_source *source) +{ + if (idx < 0 || idx >= za->nentry || source == NULL) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return -1; + } + + if (_zip_replace(za, idx, NULL, source) == -1) + return -1; + + return 0; +} + + + + +int +_zip_replace(struct zip *za, int idx, const char *name, + struct zip_source *source) +{ + if (idx == -1) { + if (_zip_entry_new(za) == NULL) + return -1; + + idx = za->nentry - 1; + } + + _zip_unchange_data(za->entry+idx); + + if (name && _zip_set_name(za, idx, name) != 0) + return -1; + + za->entry[idx].state = ((za->cdir == NULL || idx >= za->cdir->nentry) + ? ZIP_ST_ADDED : ZIP_ST_REPLACED); + za->entry[idx].source = source; + + return idx; +} + + +ZIP_EXTERN int +zip_rename(struct zip *za, int idx, const char *name) +{ + const char *old_name; + int old_is_dir, new_is_dir; + + if (idx >= za->nentry || idx < 0 || name[0] == '\0') { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return -1; + } + + if ((old_name=zip_get_name(za, idx, 0)) == NULL) + return -1; + + new_is_dir = (name[strlen(name)-1] == '/'); + old_is_dir = (old_name[strlen(old_name)-1] == '/'); + + if (new_is_dir != old_is_dir) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return -1; + } + + return _zip_set_name(za, idx, name); +} + +#include <sys/stat.h> +#include <errno.h> +#include <limits.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +static void set_error(int *, struct zip_error *, int); +static struct zip *_zip_allocate_new(const char *, int *); +static int _zip_checkcons(FILE *, struct zip_cdir *, struct zip_error *); +static void _zip_check_torrentzip(struct zip *); +static struct zip_cdir *_zip_find_central_dir(FILE *, int, int *, myoff_t); +static int _zip_file_exists(const char *, int, int *); +static int _zip_headercomp(struct zip_dirent *, int, + struct zip_dirent *, int); +static unsigned char *_zip_memmem(const unsigned char *, int, + const unsigned char *, int); +static struct zip_cdir *_zip_readcdir(FILE *, unsigned char *, unsigned char *, + int, int, struct zip_error *); + + + +ZIP_EXTERN struct zip * +zip_open(const char *fn, int flags, int *zep) +{ + FILE *fp; + struct zip *za; + struct zip_cdir *cdir; + int i; + myoff_t len; + + switch (_zip_file_exists(fn, flags, zep)) { + case -1: + return NULL; + case 0: + return _zip_allocate_new(fn, zep); + default: + break; + } + + if ((fp=fopen(fn, "rb")) == NULL) { + set_error(zep, NULL, ZIP_ER_OPEN); + return NULL; + } + + fseeko(fp, 0, SEEK_END); + len = ftello(fp); + + /* treat empty files as empty archives */ + if (len == 0) { + if ((za=_zip_allocate_new(fn, zep)) == NULL) + fclose(fp); + else + za->zp = fp; + return za; + } + + cdir = _zip_find_central_dir(fp, flags, zep, len); + if (cdir == NULL) { + fclose(fp); + return NULL; + } + + if ((za=_zip_allocate_new(fn, zep)) == NULL) { + _zip_cdir_free(cdir); + fclose(fp); + return NULL; + } + + za->cdir = cdir; + za->zp = fp; + + if ((za->entry=(struct zip_entry *)malloc(sizeof(*(za->entry)) + * cdir->nentry)) == NULL) { + set_error(zep, NULL, ZIP_ER_MEMORY); + _zip_free(za); + return NULL; + } + for (i=0; i<cdir->nentry; i++) + _zip_entry_new(za); + + _zip_check_torrentzip(za); + za->ch_flags = za->flags; + + return za; +} + + + +static void +set_error(int *zep, struct zip_error *err, int ze) +{ + int se; + + if (err) { + _zip_error_get(err, &ze, &se); + if (zip_error_get_sys_type(ze) == ZIP_ET_SYS) + errno = se; + } + + if (zep) + *zep = ze; +} + + + +/* _zip_readcdir: + tries to find a valid end-of-central-directory at the beginning of + buf, and then the corresponding central directory entries. + Returns a struct zip_cdir which contains the central directory + entries, or NULL if unsuccessful. */ + +static struct zip_cdir * +_zip_readcdir(FILE *fp, unsigned char *buf, unsigned char *eocd, int buflen, + int flags, struct zip_error *error) +{ + struct zip_cdir *cd; + unsigned char *cdp, **bufp; + int i, comlen, nentry; + + comlen = buf + buflen - eocd - EOCDLEN; + if (comlen < 0) { + /* not enough bytes left for comment */ + _zip_error_set(error, ZIP_ER_NOZIP, 0); + return NULL; + } + + /* check for end-of-central-dir magic */ + if (memcmp(eocd, EOCD_MAGIC, 4) != 0) { + _zip_error_set(error, ZIP_ER_NOZIP, 0); + return NULL; + } + + if (memcmp(eocd+4, "\0\0\0\0", 4) != 0) { + _zip_error_set(error, ZIP_ER_MULTIDISK, 0); + return NULL; + } + + cdp = eocd + 8; + /* number of cdir-entries on this disk */ + i = _zip_read2(&cdp); + /* number of cdir-entries */ + nentry = _zip_read2(&cdp); + + if ((cd=_zip_cdir_new(nentry, error)) == NULL) + return NULL; + + cd->size = _zip_read4(&cdp); + cd->offset = _zip_read4(&cdp); + cd->comment = NULL; + cd->comment_len = _zip_read2(&cdp); + + if ((comlen < cd->comment_len) || (cd->nentry != i)) { + _zip_error_set(error, ZIP_ER_NOZIP, 0); + free(cd); + return NULL; + } + if ((flags & ZIP_CHECKCONS) && comlen != cd->comment_len) { + _zip_error_set(error, ZIP_ER_INCONS, 0); + free(cd); + return NULL; + } + + if (cd->comment_len) { + if ((cd->comment=(char *)_zip_memdup(eocd+EOCDLEN, + cd->comment_len, error)) + == NULL) { + free(cd); + return NULL; + } + } + + cdp = eocd; + if (cd->size < (unsigned int)(eocd-buf)) { + /* if buffer already read in, use it */ + cdp = eocd - cd->size; + bufp = &cdp; + } + else { + /* go to start of cdir and read it entry by entry */ + bufp = NULL; + clearerr(fp); + fseeko(fp, cd->offset, SEEK_SET); + /* possible consistency check: cd->offset = + len-(cd->size+cd->comment_len+EOCDLEN) ? */ + if (ferror(fp) || ((unsigned long)ftello(fp) != cd->offset)) { + /* seek error or offset of cdir wrong */ + if (ferror(fp)) + _zip_error_set(error, ZIP_ER_SEEK, errno); + else + _zip_error_set(error, ZIP_ER_NOZIP, 0); + free(cd); + return NULL; + } + } + + for (i=0; i<cd->nentry; i++) { + if ((_zip_dirent_read(cd->entry+i, fp, bufp, eocd-cdp, 0, + error)) < 0) { + cd->nentry = i; + _zip_cdir_free(cd); + return NULL; + } + } + + return cd; +} + + + +/* _zip_checkcons: + Checks the consistency of the central directory by comparing central + directory entries with local headers and checking for plausible + file and header offsets. Returns -1 if not plausible, else the + difference between the lowest and the highest fileposition reached */ + +static int +_zip_checkcons(FILE *fp, struct zip_cdir *cd, struct zip_error *error) +{ + int i; + unsigned int min, max, j; + struct zip_dirent temp; + + if (cd->nentry) { + max = cd->entry[0].offset; + min = cd->entry[0].offset; + } + else + min = max = 0; + + for (i=0; i<cd->nentry; i++) { + if (cd->entry[i].offset < min) + min = cd->entry[i].offset; + if (min > cd->offset) { + _zip_error_set(error, ZIP_ER_NOZIP, 0); + return -1; + } + + j = cd->entry[i].offset + cd->entry[i].comp_size + + cd->entry[i].filename_len + LENTRYSIZE; + if (j > max) + max = j; + if (max > cd->offset) { + _zip_error_set(error, ZIP_ER_NOZIP, 0); + return -1; + } + + if (fseeko(fp, cd->entry[i].offset, SEEK_SET) != 0) { + _zip_error_set(error, ZIP_ER_SEEK, 0); + return -1; + } + + if (_zip_dirent_read(&temp, fp, NULL, 0, 1, error) == -1) + return -1; + + if (_zip_headercomp(cd->entry+i, 0, &temp, 1) != 0) { + _zip_error_set(error, ZIP_ER_INCONS, 0); + _zip_dirent_finalize(&temp); + return -1; + } + _zip_dirent_finalize(&temp); + } + + return max - min; +} + + + +/* _zip_check_torrentzip: + check wether ZA has a valid TORRENTZIP comment, i.e. is torrentzipped */ + +static void +_zip_check_torrentzip(struct zip *za) +{ + uLong crc_got, crc_should; + char buf[8+1]; + char *end; + + if (za->zp == NULL || za->cdir == NULL) + return; + + if (za->cdir->comment_len != TORRENT_SIG_LEN+8 + || strncmp(za->cdir->comment, TORRENT_SIG, TORRENT_SIG_LEN) != 0) + return; + + memcpy(buf, za->cdir->comment+TORRENT_SIG_LEN, 8); + buf[8] = '\0'; + errno = 0; + crc_should = strtoul(buf, &end, 16); + if ((crc_should == UINT_MAX && errno != 0) || (end && *end)) + return; + + if (_zip_filerange_crc(za->zp, za->cdir->offset, za->cdir->size, + &crc_got, NULL) < 0) + return; + + if (crc_got == crc_should) + za->flags |= ZIP_AFL_TORRENT; +} + + + + +/* _zip_headercomp: + compares two headers h1 and h2; if they are local headers, set + local1p or local2p respectively to 1, else 0. Return 0 if they + are identical, -1 if not. */ + +static int +_zip_headercomp(struct zip_dirent *h1, int local1p, struct zip_dirent *h2, + int local2p) +{ + if ((h1->version_needed != h2->version_needed) +#if 0 + /* some zip-files have different values in local + and global headers for the bitflags */ + || (h1->bitflags != h2->bitflags) +#endif + || (h1->comp_method != h2->comp_method) + || (h1->last_mod != h2->last_mod) + || (h1->filename_len != h2->filename_len) + || !h1->filename || !h2->filename + || strcmp(h1->filename, h2->filename)) + return -1; + + /* check that CRC and sizes are zero if data descriptor is used */ + if ((h1->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) && local1p + && (h1->crc != 0 + || h1->comp_size != 0 + || h1->uncomp_size != 0)) + return -1; + if ((h2->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) && local2p + && (h2->crc != 0 + || h2->comp_size != 0 + || h2->uncomp_size != 0)) + return -1; + + /* check that CRC and sizes are equal if no data descriptor is used */ + if (((h1->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) == 0 || local1p == 0) + && ((h2->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) == 0 || local2p == 0)) { + if ((h1->crc != h2->crc) + || (h1->comp_size != h2->comp_size) + || (h1->uncomp_size != h2->uncomp_size)) + return -1; + } + + if ((local1p == local2p) + && ((h1->extrafield_len != h2->extrafield_len) + || (h1->extrafield_len && h2->extrafield + && memcmp(h1->extrafield, h2->extrafield, + h1->extrafield_len)))) + return -1; + + /* if either is local, nothing more to check */ + if (local1p || local2p) + return 0; + + if ((h1->version_madeby != h2->version_madeby) + || (h1->disk_number != h2->disk_number) + || (h1->int_attrib != h2->int_attrib) + || (h1->ext_attrib != h2->ext_attrib) + || (h1->offset != h2->offset) + || (h1->comment_len != h2->comment_len) + || (h1->comment_len && h2->comment + && memcmp(h1->comment, h2->comment, h1->comment_len))) + return -1; + + return 0; +} + + + +static struct zip * +_zip_allocate_new(const char *fn, int *zep) +{ + struct zip *za; + struct zip_error error; + + if ((za=_zip_new(&error)) == NULL) { + set_error(zep, &error, 0); + return NULL; + } + + za->zn = strdup(fn); + if (!za->zn) { + _zip_free(za); + set_error(zep, NULL, ZIP_ER_MEMORY); + return NULL; + } + return za; +} + + + +static int +_zip_file_exists(const char *fn, int flags, int *zep) +{ + struct stat st; + + if (fn == NULL) { + set_error(zep, NULL, ZIP_ER_INVAL); + return -1; + } + + if (stat(fn, &st) != 0) { + if (flags & ZIP_CREATE) + return 0; + else { + set_error(zep, NULL, ZIP_ER_OPEN); + return -1; + } + } + else if ((flags & ZIP_EXCL)) { + set_error(zep, NULL, ZIP_ER_EXISTS); + return -1; + } + /* ZIP_CREATE gets ignored if file exists and not ZIP_EXCL, + just like open() */ + + return 1; +} + + + +static struct zip_cdir * +_zip_find_central_dir(FILE *fp, int flags, int *zep, myoff_t len) +{ + struct zip_cdir *cdir, *cdirnew; + unsigned char *buf, *match; + int a, best, buflen, i; + struct zip_error zerr; + + i = fseeko(fp, -(len < CDBUFSIZE ? len : CDBUFSIZE), SEEK_END); + if (i == -1 && errno != EFBIG) { + /* seek before start of file on my machine */ + set_error(zep, NULL, ZIP_ER_SEEK); + return NULL; + } + + /* 64k is too much for stack */ + if ((buf=(unsigned char *)malloc(CDBUFSIZE)) == NULL) { + set_error(zep, NULL, ZIP_ER_MEMORY); + return NULL; + } + + clearerr(fp); + buflen = fread(buf, 1, CDBUFSIZE, fp); + + if (ferror(fp)) { + set_error(zep, NULL, ZIP_ER_READ); + free(buf); + return NULL; + } + + best = -1; + cdir = NULL; + match = buf; + _zip_error_set(&zerr, ZIP_ER_NOZIP, 0); + + while ((match=_zip_memmem(match, buflen-(match-buf)-18, + (const unsigned char *)EOCD_MAGIC, 4))!=NULL) { + /* found match -- check, if good */ + /* to avoid finding the same match all over again */ + match++; + if ((cdirnew=_zip_readcdir(fp, buf, match-1, buflen, flags, + &zerr)) == NULL) + continue; + + if (cdir) { + if (best <= 0) + best = _zip_checkcons(fp, cdir, &zerr); + a = _zip_checkcons(fp, cdirnew, &zerr); + if (best < a) { + _zip_cdir_free(cdir); + cdir = cdirnew; + best = a; + } + else + _zip_cdir_free(cdirnew); + } + else { + cdir = cdirnew; + if (flags & ZIP_CHECKCONS) + best = _zip_checkcons(fp, cdir, &zerr); + else + best = 0; + } + cdirnew = NULL; + } + + free(buf); + + if (best < 0) { + set_error(zep, &zerr, 0); + _zip_cdir_free(cdir); + return NULL; + } + + return cdir; +} + + + +static unsigned char * +_zip_memmem(const unsigned char *big, int biglen, const unsigned char *little, + int littlelen) +{ + const unsigned char *p; + + if ((biglen < littlelen) || (littlelen == 0)) + return NULL; + p = big-1; + while ((p=(const unsigned char *) + memchr(p+1, little[0], (size_t)(big-(p+1)+biglen-littlelen+1))) + != NULL) { + if (memcmp(p+1, little+1, littlelen-1)==0) + return (unsigned char *)p; + } + + return NULL; +} + + +/* _zip_new: + creates a new zipfile struct, and sets the contents to zero; returns + the new struct. */ + +struct zip * +_zip_new(struct zip_error *error) +{ + struct zip *za; + + za = (struct zip *)malloc(sizeof(struct zip)); + if (!za) { + _zip_error_set(error, ZIP_ER_MEMORY, 0); + return NULL; + } + + za->zn = NULL; + za->zp = NULL; + _zip_error_init(&za->error); + za->cdir = NULL; + za->ch_comment = NULL; + za->ch_comment_len = -1; + za->nentry = za->nentry_alloc = 0; + za->entry = NULL; + za->nfile = za->nfile_alloc = 0; + za->file = NULL; + za->flags = za->ch_flags = 0; + + return za; +} + + +void * +_zip_memdup(const void *mem, size_t len, struct zip_error *error) +{ + void *ret; + + ret = malloc(len); + if (!ret) { + _zip_error_set(error, ZIP_ER_MEMORY, 0); + return NULL; + } + + memcpy(ret, mem, len); + + return ret; +} + + +ZIP_EXTERN int +zip_get_num_files(struct zip *za) +{ + if (za == NULL) + return -1; + + return za->nentry; +} + +ZIP_EXTERN const char * +zip_get_name(struct zip *za, int idx, int flags) +{ + return _zip_get_name(za, idx, flags, &za->error); +} + + + +const char * +_zip_get_name(struct zip *za, int idx, int flags, struct zip_error *error) +{ + if (idx < 0 || idx >= za->nentry) { + _zip_error_set(error, ZIP_ER_INVAL, 0); + return NULL; + } + + if ((flags & ZIP_FL_UNCHANGED) == 0) { + if (za->entry[idx].state == ZIP_ST_DELETED) { + _zip_error_set(error, ZIP_ER_DELETED, 0); + return NULL; + } + if (za->entry[idx].ch_filename) + return za->entry[idx].ch_filename; + } + + if (za->cdir == NULL || idx >= za->cdir->nentry) { + _zip_error_set(error, ZIP_ER_INVAL, 0); + return NULL; + } + + return za->cdir->entry[idx].filename; +} + + +ZIP_EXTERN const char * +zip_get_file_comment(struct zip *za, int idx, int *lenp, int flags) +{ + if (idx < 0 || idx >= za->nentry) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return NULL; + } + + if ((flags & ZIP_FL_UNCHANGED) + || (za->entry[idx].ch_comment_len == -1)) { + if (lenp != NULL) + *lenp = za->cdir->entry[idx].comment_len; + return za->cdir->entry[idx].comment; + } + + if (lenp != NULL) + *lenp = za->entry[idx].ch_comment_len; + return za->entry[idx].ch_comment; +} + + +ZIP_EXTERN int +zip_get_archive_flag(struct zip *za, int flag, int flags) +{ + int fl; + + fl = (flags & ZIP_FL_UNCHANGED) ? za->flags : za->ch_flags; + + return (fl & flag) ? 1 : 0; +} + + +ZIP_EXTERN const char * +zip_get_archive_comment(struct zip *za, int *lenp, int flags) +{ + if ((flags & ZIP_FL_UNCHANGED) + || (za->ch_comment_len == -1)) { + if (za->cdir) { + if (lenp != NULL) + *lenp = za->cdir->comment_len; + return za->cdir->comment; + } + else { + if (lenp != NULL) + *lenp = -1; + return NULL; + } + } + + if (lenp != NULL) + *lenp = za->ch_comment_len; + return za->ch_comment; +} + + +/* _zip_free: + frees the space allocated to a zipfile struct, and closes the + corresponding file. */ + +void +_zip_free(struct zip *za) +{ + int i; + + if (za == NULL) + return; + + if (za->zn) + free(za->zn); + + if (za->zp) + fclose(za->zp); + + _zip_cdir_free(za->cdir); + + if (za->entry) { + for (i=0; i<za->nentry; i++) { + _zip_entry_free(za->entry+i); + } + free(za->entry); + } + + for (i=0; i<za->nfile; i++) { + if (za->file[i]->error.zip_err == ZIP_ER_OK) { + _zip_error_set(&za->file[i]->error, ZIP_ER_ZIPCLOSED, 0); + za->file[i]->za = NULL; + } + } + + free(za->file); + + free(za); + + return; +} + + +ZIP_EXTERN ssize_t +zip_fread(struct zip_file *zf, void *outbuf, size_t toread) +{ + int ret; + size_t out_before, len; + int i; + + if (!zf) + return -1; + + if (zf->error.zip_err != 0) + return -1; + + if ((zf->flags & ZIP_ZF_EOF) || (toread == 0)) + return 0; + + if (zf->bytes_left == 0) { + zf->flags |= ZIP_ZF_EOF; + if (zf->flags & ZIP_ZF_CRC) { + if (zf->crc != zf->crc_orig) { + _zip_error_set(&zf->error, ZIP_ER_CRC, 0); + return -1; + } + } + return 0; + } + + if ((zf->flags & ZIP_ZF_DECOMP) == 0) { + ret = _zip_file_fillbuf(outbuf, toread, zf); + if (ret > 0) { + if (zf->flags & ZIP_ZF_CRC) + zf->crc = crc32(zf->crc, (Bytef *)outbuf, ret); + zf->bytes_left -= ret; + } + return ret; + } + + zf->zstr->next_out = (Bytef *)outbuf; + zf->zstr->avail_out = toread; + out_before = zf->zstr->total_out; + + /* endless loop until something has been accomplished */ + for (;;) { + ret = inflate(zf->zstr, Z_SYNC_FLUSH); + + switch (ret) { + case Z_OK: + case Z_STREAM_END: + /* all ok */ + /* Z_STREAM_END probably won't happen, since we didn't + have a header */ + len = zf->zstr->total_out - out_before; + if (len >= zf->bytes_left || len >= toread) { + if (zf->flags & ZIP_ZF_CRC) + zf->crc = crc32(zf->crc, (Bytef *)outbuf, len); + zf->bytes_left -= len; + return len; + } + break; + + case Z_BUF_ERROR: + if (zf->zstr->avail_in == 0) { + i = _zip_file_fillbuf(zf->buffer, BUFSIZE, zf); + if (i == 0) { + _zip_error_set(&zf->error, ZIP_ER_INCONS, 0); + return -1; + } + else if (i < 0) + return -1; + zf->zstr->next_in = (Bytef *)zf->buffer; + zf->zstr->avail_in = i; + continue; + } + /* fallthrough */ + case Z_NEED_DICT: + case Z_DATA_ERROR: + case Z_STREAM_ERROR: + case Z_MEM_ERROR: + _zip_error_set(&zf->error, ZIP_ER_ZLIB, ret); + return -1; + } + } +} + + +ZIP_EXTERN const char * +zip_strerror(struct zip *za) +{ + return _zip_error_strerror(&za->error); +} + + +ZIP_EXTERN void +zip_stat_init(struct zip_stat *st) +{ + st->name = NULL; + st->index = -1; + st->crc = 0; + st->mtime = (time_t)-1; + st->size = -1; + st->comp_size = -1; + st->comp_method = ZIP_CM_STORE; + st->encryption_method = ZIP_EM_NONE; +} + + +ZIP_EXTERN int +zip_stat_index(struct zip *za, int index, int flags, struct zip_stat *st) +{ + const char *name; + + if (index < 0 || index >= za->nentry) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return -1; + } + + if ((name=zip_get_name(za, index, flags)) == NULL) + return -1; + + + if ((flags & ZIP_FL_UNCHANGED) == 0 + && ZIP_ENTRY_DATA_CHANGED(za->entry+index)) { + if (za->entry[index].source->f(za->entry[index].source->ud, + st, sizeof(*st), ZIP_SOURCE_STAT) < 0) { + _zip_error_set(&za->error, ZIP_ER_CHANGED, 0); + return -1; + } + } + else { + if (za->cdir == NULL || index >= za->cdir->nentry) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return -1; + } + + st->crc = za->cdir->entry[index].crc; + st->size = za->cdir->entry[index].uncomp_size; + st->mtime = za->cdir->entry[index].last_mod; + st->comp_size = za->cdir->entry[index].comp_size; + st->comp_method = za->cdir->entry[index].comp_method; + if (za->cdir->entry[index].bitflags & ZIP_GPBF_ENCRYPTED) { + if (za->cdir->entry[index].bitflags & ZIP_GPBF_STRONG_ENCRYPTION) { + /* XXX */ + st->encryption_method = ZIP_EM_UNKNOWN; + } + else + st->encryption_method = ZIP_EM_TRAD_PKWARE; + } + else + st->encryption_method = ZIP_EM_NONE; + /* st->bitflags = za->cdir->entry[index].bitflags; */ + } + + st->index = index; + st->name = name; + + return 0; +} + + +ZIP_EXTERN int +zip_stat(struct zip *za, const char *fname, int flags, struct zip_stat *st) +{ + int idx; + + if ((idx=zip_name_locate(za, fname, flags)) < 0) + return -1; + + return zip_stat_index(za, idx, flags, st); +} + + +struct read_zip { + struct zip_file *zf; + struct zip_stat st; + myoff_t off, len; +}; + +static ssize_t read_zip(void *st, void *data, size_t len, + enum zip_source_cmd cmd); + + + +ZIP_EXTERN struct zip_source * +zip_source_zip(struct zip *za, struct zip *srcza, int srcidx, int flags, + myoff_t start, myoff_t len) +{ + struct zip_error error; + struct zip_source *zs; + struct read_zip *p; + + /* XXX: ZIP_FL_RECOMPRESS */ + + if (za == NULL) + return NULL; + + if (srcza == NULL || start < 0 || len < -1 || srcidx < 0 || srcidx >= srcza->nentry) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return NULL; + } + + if ((flags & ZIP_FL_UNCHANGED) == 0 + && ZIP_ENTRY_DATA_CHANGED(srcza->entry+srcidx)) { + _zip_error_set(&za->error, ZIP_ER_CHANGED, 0); + return NULL; + } + + if (len == 0) + len = -1; + + if (start == 0 && len == -1 && (flags & ZIP_FL_RECOMPRESS) == 0) + flags |= ZIP_FL_COMPRESSED; + else + flags &= ~ZIP_FL_COMPRESSED; + + if ((p=(struct read_zip *)malloc(sizeof(*p))) == NULL) { + _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); + return NULL; + } + + _zip_error_copy(&error, &srcza->error); + + if (zip_stat_index(srcza, srcidx, flags, &p->st) < 0 + || (p->zf=zip_fopen_index(srcza, srcidx, flags)) == NULL) { + free(p); + _zip_error_copy(&za->error, &srcza->error); + _zip_error_copy(&srcza->error, &error); + + return NULL; + } + p->off = start; + p->len = len; + + if ((flags & ZIP_FL_COMPRESSED) == 0) { + p->st.size = p->st.comp_size = len; + p->st.comp_method = ZIP_CM_STORE; + p->st.crc = 0; + } + + if ((zs=zip_source_function(za, read_zip, p)) == NULL) { + free(p); + return NULL; + } + + return zs; +} + + + +static ssize_t +read_zip(void *state, void *data, size_t len, enum zip_source_cmd cmd) +{ + struct read_zip *z; + char b[8192], *buf; + int i, n; + + z = (struct read_zip *)state; + buf = (char *)data; + + switch (cmd) { + case ZIP_SOURCE_OPEN: + for (n=0; n<z->off; n+= i) { + i = (z->off-n > sizeof(b) ? sizeof(b) : z->off-n); + if ((i=zip_fread(z->zf, b, i)) < 0) { + zip_fclose(z->zf); + z->zf = NULL; + return -1; + } + } + return 0; + + case ZIP_SOURCE_READ: + if (z->len != -1) + n = len > z->len ? z->len : len; + else + n = len; + + + if ((i=zip_fread(z->zf, buf, n)) < 0) + return -1; + + if (z->len != -1) + z->len -= i; + + return i; + + case ZIP_SOURCE_CLOSE: + return 0; + + case ZIP_SOURCE_STAT: + if (len < sizeof(z->st)) + return -1; + len = sizeof(z->st); + + memcpy(data, &z->st, len); + return len; + + case ZIP_SOURCE_ERROR: + { + int *e; + + if (len < sizeof(int)*2) + return -1; + + e = (int *)data; + zip_file_error_get(z->zf, e, e+1); + } + return sizeof(int)*2; + + case ZIP_SOURCE_FREE: + zip_fclose(z->zf); + free(z); + return 0; + + default: + ; + } + + return -1; +} + + +ZIP_EXTERN struct zip_source * +zip_source_function(struct zip *za, zip_source_callback zcb, void *ud) +{ + struct zip_source *zs; + + if (za == NULL) + return NULL; + + if ((zs=(struct zip_source *)malloc(sizeof(*zs))) == NULL) { + _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); + return NULL; + } + + zs->f = zcb; + zs->ud = ud; + + return zs; +} + + +ZIP_EXTERN void +zip_source_free(struct zip_source *source) +{ + if (source == NULL) + return; + + (void)source->f(source->ud, NULL, 0, ZIP_SOURCE_FREE); + + free(source); +} + + +struct read_file { + char *fname; /* name of file to copy from */ + FILE *f; /* file to copy from */ + myoff_t off; /* start offset of */ + myoff_t len; /* lengt of data to copy */ + myoff_t remain; /* bytes remaining to be copied */ + int e[2]; /* error codes */ +}; + +static ssize_t read_file(void *state, void *data, size_t len, + enum zip_source_cmd cmd); + + + +ZIP_EXTERN struct zip_source * +zip_source_filep(struct zip *za, FILE *file, myoff_t start, myoff_t len) +{ + if (za == NULL) + return NULL; + + if (file == NULL || start < 0 || len < -1) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return NULL; + } + + return _zip_source_file_or_p(za, NULL, file, start, len); +} + + + +struct zip_source * +_zip_source_file_or_p(struct zip *za, const char *fname, FILE *file, + myoff_t start, myoff_t len) +{ + struct read_file *f; + struct zip_source *zs; + + if (file == NULL && fname == NULL) { + _zip_error_set(&za->error, ZIP_ER_INVAL, 0); + return NULL; + } + + if ((f=(struct read_file *)malloc(sizeof(struct read_file))) == NULL) { + _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); + return NULL; + } + + f->fname = NULL; + if (fname) { + if ((f->fname=strdup(fname)) == NULL) { + _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); + free(f); + return NULL; + } + } + f->f = file; + f->off = start; + f->len = (len ? len : -1); + + if ((zs=zip_source_function(za, read_file, f)) == NULL) { + free(f); + return NULL; + } + + return zs; +} + + + +static ssize_t +read_file(void *state, void *data, size_t len, enum zip_source_cmd cmd) +{ + struct read_file *z; + char *buf; + int i, n; + + z = (struct read_file *)state; + buf = (char *)data; + + switch (cmd) { + case ZIP_SOURCE_OPEN: + if (z->fname) { + if ((z->f=fopen(z->fname, "rb")) == NULL) { + z->e[0] = ZIP_ER_OPEN; + z->e[1] = errno; + return -1; + } + } + + if (fseeko(z->f, z->off, SEEK_SET) < 0) { + z->e[0] = ZIP_ER_SEEK; + z->e[1] = errno; + return -1; + } + z->remain = z->len; + return 0; + + case ZIP_SOURCE_READ: + if (z->remain != -1) + n = len > z->remain ? z->remain : len; + else + n = len; + + if ((i=fread(buf, 1, n, z->f)) < 0) { + z->e[0] = ZIP_ER_READ; + z->e[1] = errno; + return -1; + } + + if (z->remain != -1) + z->remain -= i; + + return i; + + case ZIP_SOURCE_CLOSE: + if (z->fname) { + fclose(z->f); + z->f = NULL; + } + return 0; + + case ZIP_SOURCE_STAT: + { + struct zip_stat *st; + struct stat fst; + int err; + + if (len < sizeof(*st)) + return -1; + + if (z->f) + err = fstat(fileno(z->f), &fst); + else + err = stat(z->fname, &fst); + + if (err != 0) { + z->e[0] = ZIP_ER_READ; /* best match */ + z->e[1] = errno; + return -1; + } + + st = (struct zip_stat *)data; + + zip_stat_init(st); + st->mtime = fst.st_mtime; + if (z->len != -1) + st->size = z->len; + else if ((fst.st_mode&S_IFMT) == S_IFREG) + st->size = fst.st_size; + + return sizeof(*st); + } + + case ZIP_SOURCE_ERROR: + if (len < sizeof(int)*2) + return -1; + + memcpy(data, z->e, sizeof(int)*2); + return sizeof(int)*2; + + case ZIP_SOURCE_FREE: + free(z->fname); + if (z->f) + fclose(z->f); + free(z); + return 0; + + default: + ; + } + + return -1; +} + + +ZIP_EXTERN int +zip_name_locate(struct zip *za, const char *fname, int flags) +{ + return _zip_name_locate(za, fname, flags, &za->error); +} + + + +int +_zip_name_locate(struct zip *za, const char *fname, int flags, + struct zip_error *error) +{ + int (*cmp)(const char *, const char *); + const char *fn, *p; + int i, n; + + if (fname == NULL) { + _zip_error_set(error, ZIP_ER_INVAL, 0); + return -1; + } + + cmp = (flags & ZIP_FL_NOCASE) ? strcasecmp : strcmp; + + n = (flags & ZIP_FL_UNCHANGED) ? za->cdir->nentry : za->nentry; + for (i=0; i<n; i++) { + if (flags & ZIP_FL_UNCHANGED) + fn = za->cdir->entry[i].filename; + else + fn = _zip_get_name(za, i, flags, error); + + /* newly added (partially filled) entry */ + if (fn == NULL) + continue; + + if (flags & ZIP_FL_NODIR) { + p = strrchr(fn, '/'); + if (p) + fn = p+1; + } + + if (cmp(fname, fn) == 0) + return i; + } + + _zip_error_set(error, ZIP_ER_NOENT, 0); + return -1; +} + diff --git a/tests/deps/zip-0.2.1/zip/zipfiles.nim b/tests/deps/zip-0.2.1/zip/zipfiles.nim new file mode 100644 index 000000000..ca1979488 --- /dev/null +++ b/tests/deps/zip-0.2.1/zip/zipfiles.nim @@ -0,0 +1,193 @@ +# +# +# Nim's Runtime Library +# (c) Copyright 2012 Andreas Rumpf +# +# See the file "copying.txt", included in this +# distribution, for details about the copyright. +# + +## This module implements a zip archive creator/reader/modifier. + +import + streams, libzip, times, os, strutils + +const BufSize = 8 * 1024 + +type + ZipArchive* = object of RootObj ## represents a zip archive + mode: FileMode + w: PZip +{.deprecated: [TZipArchive: ZipArchive].} + +proc zipError(z: var ZipArchive) = + var e: ref IOError + new(e) + e.msg = $zip_strerror(z.w) + raise e + +proc open*(z: var ZipArchive, filename: string, mode: FileMode = fmRead): bool = + ## Opens a zip file for reading, writing or appending. All file modes are + ## supported. Returns true iff successful, false otherwise. + var err, flags: int32 + case mode + of fmRead, fmReadWriteExisting, fmAppend: flags = 0 + of fmWrite: + if existsFile(filename): removeFile(filename) + flags = ZIP_CREATE or ZIP_EXCL + of fmReadWrite: flags = ZIP_CREATE + z.w = zip_open(filename, flags, addr(err)) + z.mode = mode + result = z.w != nil + +proc close*(z: var ZipArchive) = + ## Closes a zip file. + zip_close(z.w) + +proc createDir*(z: var ZipArchive, dir: string) = + ## Creates a directory within the `z` archive. This does not fail if the + ## directory already exists. Note that for adding a file like + ## ``"path1/path2/filename"`` it is not necessary + ## to create the ``"path/path2"`` subdirectories - it will be done + ## automatically by ``addFile``. + assert(z.mode != fmRead) + discard zip_add_dir(z.w, dir) + zip_error_clear(z.w) + +proc addFile*(z: var ZipArchive, dest, src: string) = + ## Adds the file `src` to the archive `z` with the name `dest`. `dest` + ## may contain a path that will be created. + assert(z.mode != fmRead) + if not fileExists(src): + raise newException(IOError, "File '" & src & "' does not exist") + var zipsrc = zip_source_file(z.w, src, 0, -1) + if zipsrc == nil: + #echo("Dest: " & dest) + #echo("Src: " & src) + zipError(z) + if zip_add(z.w, dest, zipsrc) < 0'i32: + zip_source_free(zipsrc) + zipError(z) + +proc addFile*(z: var ZipArchive, file: string) = + ## A shortcut for ``addFile(z, file, file)``, i.e. the name of the source is + ## the name of the destination. + addFile(z, file, file) + +proc mySourceCallback(state, data: pointer, len: int, + cmd: ZipSourceCmd): int {.cdecl.} = + var src = cast[Stream](state) + case cmd + of ZIP_SOURCE_OPEN: + if src.setPositionImpl != nil: setPosition(src, 0) # reset + of ZIP_SOURCE_READ: + result = readData(src, data, len) + of ZIP_SOURCE_CLOSE: close(src) + of ZIP_SOURCE_STAT: + var stat = cast[PZipStat](data) + zip_stat_init(stat) + stat.size = high(int32)-1 # we don't know the size + stat.mtime = getTime() + result = sizeof(ZipStat) + of ZIP_SOURCE_ERROR: + var err = cast[ptr array[0..1, cint]](data) + err[0] = ZIP_ER_INTERNAL + err[1] = 0 + result = 2*sizeof(cint) + of constZIP_SOURCE_FREE: GC_unref(src) + of ZIP_SOURCE_SUPPORTS: + # By default a read-only source is supported, which suits us. + result = -1 + else: + # An unknown command, failing + result = -1 + +proc addFile*(z: var ZipArchive, dest: string, src: Stream) = + ## Adds a file named with `dest` to the archive `z`. `dest` + ## may contain a path. The file's content is read from the `src` stream. + assert(z.mode != fmRead) + GC_ref(src) + var zipsrc = zip_source_function(z.w, mySourceCallback, cast[pointer](src)) + if zipsrc == nil: zipError(z) + if zip_add(z.w, dest, zipsrc) < 0'i32: + zip_source_free(zipsrc) + zipError(z) + +# -------------- zip file stream --------------------------------------------- + +type + TZipFileStream = object of StreamObj + f: PZipFile + atEnd: bool + + PZipFileStream* = + ref TZipFileStream ## a reader stream of a file within a zip archive + +proc fsClose(s: Stream) = zip_fclose(PZipFileStream(s).f) +proc fsAtEnd(s: Stream): bool = PZipFileStream(s).atEnd +proc fsReadData(s: Stream, buffer: pointer, bufLen: int): int = + result = zip_fread(PZipFileStream(s).f, buffer, bufLen) + if result == 0: + PZipFileStream(s).atEnd = true + +proc newZipFileStream(f: PZipFile): PZipFileStream = + new(result) + result.f = f + result.atEnd = false + result.closeImpl = fsClose + result.readDataImpl = fsReadData + result.atEndImpl = fsAtEnd + # other methods are nil! + +# ---------------------------------------------------------------------------- + +proc getStream*(z: var ZipArchive, filename: string): PZipFileStream = + ## returns a stream that can be used to read the file named `filename` + ## from the archive `z`. Returns nil in case of an error. + ## The returned stream does not support the `setPosition`, `getPosition`, + ## `writeData` or `atEnd` methods. + var x = zip_fopen(z.w, filename, 0'i32) + if x != nil: result = newZipFileStream(x) + +iterator walkFiles*(z: var ZipArchive): string = + ## walks over all files in the archive `z` and returns the filename + ## (including the path). + var i = 0'i32 + var num = zip_get_num_files(z.w) + while i < num: + yield $zip_get_name(z.w, i, 0'i32) + inc(i) + +proc extractFile*(z: var ZipArchive, srcFile: string, dest: Stream) = + ## extracts a file from the zip archive `z` to the destination stream. + var buf: array[BufSize, byte] + var strm = getStream(z, srcFile) + while true: + let bytesRead = strm.readData(addr(buf[0]), buf.len) + if bytesRead <= 0: break + dest.writeData(addr(buf[0]), bytesRead) + + dest.flush() + strm.close() + +proc extractFile*(z: var ZipArchive, srcFile: string, dest: string) = + ## extracts a file from the zip archive `z` to the destination filename. + var file = newFileStream(dest, fmWrite) + if file.isNil: + raise newException(IOError, "Failed to create output file: " & dest) + extractFile(z, srcFile, file) + file.close() + +proc extractAll*(z: var ZipArchive, dest: string) = + ## extracts all files from archive `z` to the destination directory. + createDir(dest) + for file in walkFiles(z): + if file.contains("/"): + createDir(dest / file[0..file.rfind("/")]) + extractFile(z, file, dest / file) + +when not defined(testing) and isMainModule: + var zip: ZipArchive + if not zip.open("nim-0.11.0.zip"): + raise newException(IOError, "opening zip failed") + zip.extractAll("test") diff --git a/tests/deps/zip-0.2.1/zip/zlib.nim b/tests/deps/zip-0.2.1/zip/zlib.nim new file mode 100644 index 000000000..f41ed5cfe --- /dev/null +++ b/tests/deps/zip-0.2.1/zip/zlib.nim @@ -0,0 +1,425 @@ +# Converted from Pascal + +## Interface to the zlib http://www.zlib.net/ compression library. + +when defined(windows): + const libz = "zlib1.dll" +elif defined(macosx): + const libz = "libz.dylib" +else: + const libz = "libz.so.1" + +type + Uint* = int32 + Ulong* = int + Ulongf* = int + Pulongf* = ptr Ulongf + ZOffT* = int32 + Pbyte* = cstring + Pbytef* = cstring + Allocfunc* = proc (p: pointer, items: Uint, size: Uint): pointer{.cdecl.} + FreeFunc* = proc (p: pointer, address: pointer){.cdecl.} + InternalState*{.final, pure.} = object + PInternalState* = ptr InternalState + ZStream*{.final, pure.} = object + nextIn*: Pbytef + availIn*: Uint + totalIn*: Ulong + nextOut*: Pbytef + availOut*: Uint + totalOut*: Ulong + msg*: Pbytef + state*: PInternalState + zalloc*: Allocfunc + zfree*: FreeFunc + opaque*: pointer + dataType*: int32 + adler*: Ulong + reserved*: Ulong + + ZStreamRec* = ZStream + PZstream* = ptr ZStream + GzFile* = pointer + ZStreamHeader* = enum + DETECT_STREAM, + RAW_DEFLATE, + ZLIB_STREAM, + GZIP_STREAM + + ZlibStreamError* = object of Exception + +{.deprecated: [TInternalState: InternalState, TAllocfunc: Allocfunc, + TFreeFunc: FreeFunc, TZStream: ZStream, TZStreamRec: ZStreamRec].} + +const + Z_NO_FLUSH* = 0 + Z_PARTIAL_FLUSH* = 1 + Z_SYNC_FLUSH* = 2 + Z_FULL_FLUSH* = 3 + Z_FINISH* = 4 + Z_OK* = 0 + Z_STREAM_END* = 1 + Z_NEED_DICT* = 2 + Z_ERRNO* = -1 + Z_STREAM_ERROR* = -2 + Z_DATA_ERROR* = -3 + Z_MEM_ERROR* = -4 + Z_BUF_ERROR* = -5 + Z_VERSION_ERROR* = -6 + Z_NO_COMPRESSION* = 0 + Z_BEST_SPEED* = 1 + Z_BEST_COMPRESSION* = 9 + Z_DEFAULT_COMPRESSION* = -1 + Z_FILTERED* = 1 + Z_HUFFMAN_ONLY* = 2 + Z_DEFAULT_STRATEGY* = 0 + Z_BINARY* = 0 + Z_ASCII* = 1 + Z_UNKNOWN* = 2 + Z_DEFLATED* = 8 + Z_NULL* = 0 + Z_MEM_LEVEL* = 8 + MAX_WBITS* = 15 + +proc zlibVersion*(): cstring{.cdecl, dynlib: libz, importc: "zlibVersion".} +proc deflate*(strm: var ZStream, flush: int32): int32{.cdecl, dynlib: libz, + importc: "deflate".} +proc deflateEnd*(strm: var ZStream): int32{.cdecl, dynlib: libz, + importc: "deflateEnd".} +proc inflate*(strm: var ZStream, flush: int32): int32{.cdecl, dynlib: libz, + importc: "inflate".} +proc inflateEnd*(strm: var ZStream): int32{.cdecl, dynlib: libz, + importc: "inflateEnd".} +proc deflateSetDictionary*(strm: var ZStream, dictionary: Pbytef, + dictLength: Uint): int32{.cdecl, dynlib: libz, + importc: "deflateSetDictionary".} +proc deflateCopy*(dest, source: var ZStream): int32{.cdecl, dynlib: libz, + importc: "deflateCopy".} +proc deflateReset*(strm: var ZStream): int32{.cdecl, dynlib: libz, + importc: "deflateReset".} +proc deflateParams*(strm: var ZStream, level: int32, strategy: int32): int32{. + cdecl, dynlib: libz, importc: "deflateParams".} +proc inflateSetDictionary*(strm: var ZStream, dictionary: Pbytef, + dictLength: Uint): int32{.cdecl, dynlib: libz, + importc: "inflateSetDictionary".} +proc inflateSync*(strm: var ZStream): int32{.cdecl, dynlib: libz, + importc: "inflateSync".} +proc inflateReset*(strm: var ZStream): int32{.cdecl, dynlib: libz, + importc: "inflateReset".} +proc compress*(dest: Pbytef, destLen: Pulongf, source: Pbytef, sourceLen: Ulong): cint{. + cdecl, dynlib: libz, importc: "compress".} +proc compress2*(dest: Pbytef, destLen: Pulongf, source: Pbytef, + sourceLen: Ulong, level: cint): cint{.cdecl, dynlib: libz, + importc: "compress2".} +proc uncompress*(dest: Pbytef, destLen: Pulongf, source: Pbytef, + sourceLen: Ulong): cint{.cdecl, dynlib: libz, + importc: "uncompress".} +proc compressBound*(sourceLen: Ulong): Ulong {.cdecl, dynlib: libz, importc.} +proc gzopen*(path: cstring, mode: cstring): GzFile{.cdecl, dynlib: libz, + importc: "gzopen".} +proc gzdopen*(fd: int32, mode: cstring): GzFile{.cdecl, dynlib: libz, + importc: "gzdopen".} +proc gzsetparams*(thefile: GzFile, level: int32, strategy: int32): int32{.cdecl, + dynlib: libz, importc: "gzsetparams".} +proc gzread*(thefile: GzFile, buf: pointer, length: int): int32{.cdecl, + dynlib: libz, importc: "gzread".} +proc gzwrite*(thefile: GzFile, buf: pointer, length: int): int32{.cdecl, + dynlib: libz, importc: "gzwrite".} +proc gzprintf*(thefile: GzFile, format: Pbytef): int32{.varargs, cdecl, + dynlib: libz, importc: "gzprintf".} +proc gzputs*(thefile: GzFile, s: Pbytef): int32{.cdecl, dynlib: libz, + importc: "gzputs".} +proc gzgets*(thefile: GzFile, buf: Pbytef, length: int32): Pbytef{.cdecl, + dynlib: libz, importc: "gzgets".} +proc gzputc*(thefile: GzFile, c: char): char{.cdecl, dynlib: libz, + importc: "gzputc".} +proc gzgetc*(thefile: GzFile): char{.cdecl, dynlib: libz, importc: "gzgetc".} +proc gzflush*(thefile: GzFile, flush: int32): int32{.cdecl, dynlib: libz, + importc: "gzflush".} +proc gzseek*(thefile: GzFile, offset: ZOffT, whence: int32): ZOffT{.cdecl, + dynlib: libz, importc: "gzseek".} +proc gzrewind*(thefile: GzFile): int32{.cdecl, dynlib: libz, importc: "gzrewind".} +proc gztell*(thefile: GzFile): ZOffT{.cdecl, dynlib: libz, importc: "gztell".} +proc gzeof*(thefile: GzFile): int {.cdecl, dynlib: libz, importc: "gzeof".} +proc gzclose*(thefile: GzFile): int32{.cdecl, dynlib: libz, importc: "gzclose".} +proc gzerror*(thefile: GzFile, errnum: var int32): Pbytef{.cdecl, dynlib: libz, + importc: "gzerror".} +proc adler32*(adler: Ulong, buf: Pbytef, length: Uint): Ulong{.cdecl, + dynlib: libz, importc: "adler32".} + ## **Warning**: Adler-32 requires at least a few hundred bytes to get rolling. +proc crc32*(crc: Ulong, buf: Pbytef, length: Uint): Ulong{.cdecl, dynlib: libz, + importc: "crc32".} +proc deflateInitu*(strm: var ZStream, level: int32, version: cstring, + streamSize: int32): int32{.cdecl, dynlib: libz, + importc: "deflateInit_".} +proc inflateInitu*(strm: var ZStream, version: cstring, + streamSize: int32): int32 {. + cdecl, dynlib: libz, importc: "inflateInit_".} +proc deflateInit*(strm: var ZStream, level: int32): int32 +proc inflateInit*(strm: var ZStream): int32 +proc deflateInit2u*(strm: var ZStream, level: int32, `method`: int32, + windowBits: int32, memLevel: int32, strategy: int32, + version: cstring, streamSize: int32): int32 {.cdecl, + dynlib: libz, importc: "deflateInit2_".} +proc inflateInit2u*(strm: var ZStream, windowBits: int32, version: cstring, + streamSize: int32): int32{.cdecl, dynlib: libz, + importc: "inflateInit2_".} +proc deflateInit2*(strm: var ZStream, + level, `method`, windowBits, memLevel, + strategy: int32): int32 +proc inflateInit2*(strm: var ZStream, windowBits: int32): int32 +proc zError*(err: int32): cstring{.cdecl, dynlib: libz, importc: "zError".} +proc inflateSyncPoint*(z: PZstream): int32{.cdecl, dynlib: libz, + importc: "inflateSyncPoint".} +proc getCrcTable*(): pointer{.cdecl, dynlib: libz, importc: "get_crc_table".} + +proc deflateBound*(strm: var ZStream, sourceLen: ULong): ULong {.cdecl, + dynlib: libz, importc: "deflateBound".} + +proc deflateInit(strm: var ZStream, level: int32): int32 = + result = deflateInitu(strm, level, zlibVersion(), sizeof(ZStream).cint) + +proc inflateInit(strm: var ZStream): int32 = + result = inflateInitu(strm, zlibVersion(), sizeof(ZStream).cint) + +proc deflateInit2(strm: var ZStream, + level, `method`, windowBits, memLevel, + strategy: int32): int32 = + result = deflateInit2u(strm, level, `method`, windowBits, memLevel, + strategy, zlibVersion(), sizeof(ZStream).cint) + +proc inflateInit2(strm: var ZStream, windowBits: int32): int32 = + result = inflateInit2u(strm, windowBits, zlibVersion(), + sizeof(ZStream).cint) + +proc zlibAllocMem*(appData: pointer, items, size: int): pointer {.cdecl.} = + result = alloc(items * size) + +proc zlibFreeMem*(appData, `block`: pointer) {.cdecl.} = + dealloc(`block`) + + +proc compress*(sourceBuf: cstring; sourceLen: int; level=Z_DEFAULT_COMPRESSION; stream=GZIP_STREAM): string = + ## Given a cstring, returns its deflated version with an optional header. + ## + ## Valid argument for ``stream`` are + ## - ``ZLIB_STREAM`` - add a zlib header and footer. + ## - ``GZIP_STREAM`` - add a basic gzip header and footer. + ## - ``RAW_DEFLATE`` - no header is generated. + ## + ## Passing a nil cstring will crash this proc in release mode and assert in + ## debug mode. + ## + ## Compression level can be set with ``level`` argument. Currently + ## ``Z_DEFAULT_COMPRESSION`` is 6. + ## + ## Returns "" on failure. + assert(not sourceBuf.isNil) + assert(sourceLen >= 0) + + var z: ZStream + var windowBits = MAX_WBITS + case (stream) + of RAW_DEFLATE: windowBits = -MAX_WBITS + of GZIP_STREAM: windowBits = MAX_WBITS + 16 + of ZLIB_STREAM, DETECT_STREAM: + discard # DETECT_STREAM defaults to ZLIB_STREAM + + var status = deflateInit2(z, level.int32, Z_DEFLATED.int32, + windowBits.int32, Z_MEM_LEVEL.int32, + Z_DEFAULT_STRATEGY.int32) + case status + of Z_OK: discard + of Z_MEM_ERROR: raise newException(OutOfMemError, "") + of Z_STREAM_ERROR: raise newException(ZlibStreamError, "invalid zlib stream parameter!") + of Z_VERSION_ERROR: raise newException(ZlibStreamError, "zlib version mismatch!") + else: raise newException(ZlibStreamError, "Unkown error(" & $status & ") : " & $z.msg) + + let space = deflateBound(z, sourceLen) + var compressed = newStringOfCap(space) + z.next_in = sourceBuf + z.avail_in = sourceLen.Uint + z.next_out = addr(compressed[0]) + z.avail_out = space.Uint + + status = deflate(z, Z_FINISH) + if status != Z_STREAM_END: + discard deflateEnd(z) # cleanup allocated ressources + raise newException(ZlibStreamError, "Invalid stream state(" & $status & ") : " & $z.msg) + + status = deflateEnd(z) + if status != Z_OK: # cleanup allocated ressources + raise newException(ZlibStreamError, "Invalid stream state(" & $status & ") : " & $z.msg) + + compressed.setLen(z.total_out) + swap(result, compressed) + +proc compress*(input: string; level=Z_DEFAULT_COMPRESSION; stream=GZIP_STREAM): string = + ## Given a string, returns its deflated version with an optional header. + ## + ## Valid arguments for ``stream`` are + ## - ``ZLIB_STREAM`` - add a zlib header and footer. + ## - ``GZIP_STREAM`` - add a basic gzip header and footer. + ## - ``RAW_DEFLATE`` - no header is generated. + ## + ## Compression level can be set with ``level`` argument. Currently + ## ``Z_DEFAULT_COMPRESSION`` is 6. + ## + ## Returns "" on failure. + result = compress(input, input.len, level, stream) + +proc uncompress*(sourceBuf: cstring, sourceLen: Natural; stream=DETECT_STREAM): string = + ## Given a deflated buffer returns its inflated content as a string. + ## + ## Valid arguments for ``stream`` are + ## - ``DETECT_STREAM`` - detect if zlib or gzip header is present + ## and decompress stream. Fail on raw deflate stream. + ## - ``ZLIB_STREAM`` - decompress a zlib stream. + ## - ``GZIP_STREAM`` - decompress a gzip stream. + ## - ``RAW_DEFLATE`` - decompress a raw deflate stream. + ## + ## Passing a nil cstring will crash this proc in release mode and assert in + ## debug mode. + ## + ## Returns "" on problems. Failure is a very loose concept, it could be you + ## passing a non deflated string, or it could mean not having enough memory + ## for the inflated version. + ## + ## The uncompression algorithm is based on http://zlib.net/zpipe.c. + assert(not sourceBuf.isNil) + assert(sourceLen >= 0) + var z: ZStream + var decompressed: string = "" + var sbytes = 0 + var wbytes = 0 + ## allocate inflate state + + z.availIn = 0 + var wbits = case (stream) + of RAW_DEFLATE: -MAX_WBITS + of ZLIB_STREAM: MAX_WBITS + of GZIP_STREAM: MAX_WBITS + 16 + of DETECT_STREAM: MAX_WBITS + 32 + + var status = inflateInit2(z, wbits.int32) + + case status + of Z_OK: discard + of Z_MEM_ERROR: raise newException(OutOfMemError, "") + of Z_STREAM_ERROR: raise newException(ZlibStreamError, "invalid zlib stream parameter!") + of Z_VERSION_ERROR: raise newException(ZlibStreamError, "zlib version mismatch!") + else: raise newException(ZlibStreamError, "Unkown error(" & $status & ") : " & $z.msg) + + # run loop until all input is consumed. + # handle concatenated deflated stream with header. + while true: + z.availIn = (sourceLen - sbytes).int32 + + # no more input available + if (sourceLen - sbytes) <= 0: break + z.nextIn = sourceBuf[sbytes].unsafeaddr + + # run inflate() on available input until output buffer is full + while true: + # if written bytes >= output size : resize output + if wbytes >= decompressed.len: + let cur_outlen = decompressed.len + let new_outlen = if decompressed.len == 0: sourceLen*2 else: decompressed.len*2 + if new_outlen < cur_outlen: # unsigned integer overflow, buffer too large + discard inflateEnd(z); + raise newException(OverflowError, "zlib stream decompressed size is too large! (size > " & $int.high & ")") + + decompressed.setLen(new_outlen) + + # available space for decompression + let space = decompressed.len - wbytes + z.availOut = space.Uint + z.nextOut = decompressed[wbytes].addr + + status = inflate(z, Z_NO_FLUSH) + if status.int8 notin {Z_OK.int8, Z_STREAM_END.int8, Z_BUF_ERROR.int8}: + discard inflateEnd(z) + case status + of Z_MEM_ERROR: raise newException(OutOfMemError, "") + of Z_DATA_ERROR: raise newException(ZlibStreamError, "invalid zlib stream parameter!") + else: raise newException(ZlibStreamError, "Unkown error(" & $status & ") : " & $z.msg) + + # add written bytes, if any. + wbytes += space - z.availOut.int + + # may need more input + if not (z.availOut == 0): break + + # inflate() says stream is done + if (status == Z_STREAM_END): + # may have another stream concatenated + if z.availIn != 0: + sbytes = sourceLen - z.availIn # add consumed bytes + if inflateReset(z) != Z_OK: # reset zlib struct and try again + raise newException(ZlibStreamError, "Invalid stream state(" & $status & ") : " & $z.msg) + else: + break # end of decompression + + # clean up and don't care about any error + discard inflateEnd(z) + + if status != Z_STREAM_END: + raise newException(ZlibStreamError, "Invalid stream state(" & $status & ") : " & $z.msg) + + decompressed.setLen(wbytes) + swap(result, decompressed) + + +proc uncompress*(sourceBuf: string; stream=DETECT_STREAM): string = + ## Given a GZIP-ed string return its inflated content. + ## + ## Valid arguments for ``stream`` are + ## - ``DETECT_STREAM`` - detect if zlib or gzip header is present + ## and decompress stream. Fail on raw deflate stream. + ## - ``ZLIB_STREAM`` - decompress a zlib stream. + ## - ``GZIP_STREAM`` - decompress a gzip stream. + ## - ``RAW_DEFLATE`` - decompress a raw deflate stream. + ## + ## Returns "" on failure. + result = uncompress(sourceBuf, sourceBuf.len, stream) + + + +proc deflate*(buffer: var string; level=Z_DEFAULT_COMPRESSION; stream=GZIP_STREAM): bool {.discardable.} = + ## Convenience proc which deflates a string and insert an optional header/footer. + ## + ## Valid arguments for ``stream`` are + ## - ``ZLIB_STREAM`` - add a zlib header and footer. + ## - ``GZIP_STREAM`` - add a basic gzip header and footer. + ## - ``RAW_DEFLATE`` - no header is generated. + ## + ## Compression level can be set with ``level`` argument. Currently + ## ``Z_DEFAULT_COMPRESSION`` is 6. + ## + ## Returns true if `buffer` was successfully deflated otherwise the buffer is untouched. + + var temp = compress(addr(buffer[0]), buffer.len, level, stream) + if temp.len != 0: + swap(buffer, temp) + result = true + +proc inflate*(buffer: var string; stream=DETECT_STREAM): bool {.discardable.} = + ## Convenience proc which inflates a string containing compressed data + ## with an optional header. + ## + ## Valid argument for ``stream`` are: + ## - ``DETECT_STREAM`` - detect if zlib or gzip header is present + ## and decompress stream. Fail on raw deflate stream. + ## - ``ZLIB_STREAM`` - decompress a zlib stream. + ## - ``GZIP_STREAM`` - decompress a gzip stream. + ## - ``RAW_DEFLATE`` - decompress a raw deflate stream. + ## + ## It is ok to pass a buffer which doesn't contain deflated data, + ## in this case the proc won't modify the buffer. + ## + ## Returns true if `buffer` was successfully inflated. + + var temp = uncompress(addr(buffer[0]), buffer.len, stream) + if temp.len != 0: + swap(buffer, temp) + result = true diff --git a/tests/deps/zip-0.2.1/zip/zzip.nim b/tests/deps/zip-0.2.1/zip/zzip.nim new file mode 100644 index 000000000..553970e0c --- /dev/null +++ b/tests/deps/zip-0.2.1/zip/zzip.nim @@ -0,0 +1,176 @@ +# +# +# Nim's Runtime Library +# (c) Copyright 2008 Andreas Rumpf +# +# See the file "copying.txt", included in this +# distribution, for details about the copyright. +# + +## This module is an interface to the zzip library. + +# Author: +# Guido Draheim <guidod@gmx.de> +# Tomi Ollila <Tomi.Ollila@iki.fi> +# Copyright (c) 1999,2000,2001,2002,2003,2004 Guido Draheim +# All rights reserved, +# usage allowed under the restrictions of the +# Lesser GNU General Public License +# or alternatively the restrictions +# of the Mozilla Public License 1.1 + +when defined(windows): + const + dllname = "zzip.dll" +else: + const + dllname = "libzzip.so" + +type + TZZipError* = int32 # Name conflict if we drop the `T` + +const + ZZIP_ERROR* = -4096'i32 + ZZIP_NO_ERROR* = 0'i32 # no error, may be used if user sets it. + ZZIP_OUTOFMEM* = ZZIP_ERROR - 20'i32 # out of memory + ZZIP_DIR_OPEN* = ZZIP_ERROR - 21'i32 # failed to open zipfile, see errno for details + ZZIP_DIR_STAT* = ZZIP_ERROR - 22'i32 # failed to fstat zipfile, see errno for details + ZZIP_DIR_SEEK* = ZZIP_ERROR - 23'i32 # failed to lseek zipfile, see errno for details + ZZIP_DIR_READ* = ZZIP_ERROR - 24'i32 # failed to read zipfile, see errno for details + ZZIP_DIR_TOO_SHORT* = ZZIP_ERROR - 25'i32 + ZZIP_DIR_EDH_MISSING* = ZZIP_ERROR - 26'i32 + ZZIP_DIRSIZE* = ZZIP_ERROR - 27'i32 + ZZIP_ENOENT* = ZZIP_ERROR - 28'i32 + ZZIP_UNSUPP_COMPR* = ZZIP_ERROR - 29'i32 + ZZIP_CORRUPTED* = ZZIP_ERROR - 31'i32 + ZZIP_UNDEF* = ZZIP_ERROR - 32'i32 + ZZIP_DIR_LARGEFILE* = ZZIP_ERROR - 33'i32 + + ZZIP_CASELESS* = 1'i32 shl 12'i32 + ZZIP_NOPATHS* = 1'i32 shl 13'i32 + ZZIP_PREFERZIP* = 1'i32 shl 14'i32 + ZZIP_ONLYZIP* = 1'i32 shl 16'i32 + ZZIP_FACTORY* = 1'i32 shl 17'i32 + ZZIP_ALLOWREAL* = 1'i32 shl 18'i32 + ZZIP_THREADED* = 1'i32 shl 19'i32 + +type + ZZipDir* {.final, pure.} = object + ZZipFile* {.final, pure.} = object + ZZipPluginIO* {.final, pure.} = object + + ZZipDirent* {.final, pure.} = object + d_compr*: int32 ## compression method + d_csize*: int32 ## compressed size + st_size*: int32 ## file size / decompressed size + d_name*: cstring ## file name / strdupped name + + ZZipStat* = ZZipDirent +{.deprecated: [TZZipDir: ZzipDir, TZZipFile: ZzipFile, + TZZipPluginIO: ZzipPluginIO, TZZipDirent: ZzipDirent, + TZZipStat: ZZipStat].} + +proc zzip_strerror*(errcode: int32): cstring {.cdecl, dynlib: dllname, + importc: "zzip_strerror".} +proc zzip_strerror_of*(dir: ptr ZZipDir): cstring {.cdecl, dynlib: dllname, + importc: "zzip_strerror_of".} +proc zzip_errno*(errcode: int32): int32 {.cdecl, dynlib: dllname, + importc: "zzip_errno".} + +proc zzip_geterror*(dir: ptr ZZipDir): int32 {.cdecl, dynlib: dllname, + importc: "zzip_error".} +proc zzip_seterror*(dir: ptr ZZipDir, errcode: int32) {.cdecl, dynlib: dllname, + importc: "zzip_seterror".} +proc zzip_compr_str*(compr: int32): cstring {.cdecl, dynlib: dllname, + importc: "zzip_compr_str".} +proc zzip_dirhandle*(fp: ptr ZZipFile): ptr ZZipDir {.cdecl, dynlib: dllname, + importc: "zzip_dirhandle".} +proc zzip_dirfd*(dir: ptr ZZipDir): int32 {.cdecl, dynlib: dllname, + importc: "zzip_dirfd".} +proc zzip_dir_real*(dir: ptr ZZipDir): int32 {.cdecl, dynlib: dllname, + importc: "zzip_dir_real".} +proc zzip_file_real*(fp: ptr ZZipFile): int32 {.cdecl, dynlib: dllname, + importc: "zzip_file_real".} +proc zzip_realdir*(dir: ptr ZZipDir): pointer {.cdecl, dynlib: dllname, + importc: "zzip_realdir".} +proc zzip_realfd*(fp: ptr ZZipFile): int32 {.cdecl, dynlib: dllname, + importc: "zzip_realfd".} + +proc zzip_dir_alloc*(fileext: cstringArray): ptr ZZipDir {.cdecl, + dynlib: dllname, importc: "zzip_dir_alloc".} +proc zzip_dir_free*(para1: ptr ZZipDir): int32 {.cdecl, dynlib: dllname, + importc: "zzip_dir_free".} + +proc zzip_dir_fdopen*(fd: int32, errcode_p: ptr TZZipError): ptr ZZipDir {.cdecl, + dynlib: dllname, importc: "zzip_dir_fdopen".} +proc zzip_dir_open*(filename: cstring, errcode_p: ptr TZZipError): ptr ZZipDir {. + cdecl, dynlib: dllname, importc: "zzip_dir_open".} +proc zzip_dir_close*(dir: ptr ZZipDir) {.cdecl, dynlib: dllname, + importc: "zzip_dir_close".} +proc zzip_dir_read*(dir: ptr ZZipDir, dirent: ptr ZZipDirent): int32 {.cdecl, + dynlib: dllname, importc: "zzip_dir_read".} + +proc zzip_opendir*(filename: cstring): ptr ZZipDir {.cdecl, dynlib: dllname, + importc: "zzip_opendir".} +proc zzip_closedir*(dir: ptr ZZipDir) {.cdecl, dynlib: dllname, + importc: "zzip_closedir".} +proc zzip_readdir*(dir: ptr ZZipDir): ptr ZZipDirent {.cdecl, dynlib: dllname, + importc: "zzip_readdir".} +proc zzip_rewinddir*(dir: ptr ZZipDir) {.cdecl, dynlib: dllname, + importc: "zzip_rewinddir".} +proc zzip_telldir*(dir: ptr ZZipDir): int {.cdecl, dynlib: dllname, + importc: "zzip_telldir".} +proc zzip_seekdir*(dir: ptr ZZipDir, offset: int) {.cdecl, dynlib: dllname, + importc: "zzip_seekdir".} + +proc zzip_file_open*(dir: ptr ZZipDir, name: cstring, flags: int32): ptr ZZipFile {. + cdecl, dynlib: dllname, importc: "zzip_file_open".} +proc zzip_file_close*(fp: ptr ZZipFile) {.cdecl, dynlib: dllname, + importc: "zzip_file_close".} +proc zzip_file_read*(fp: ptr ZZipFile, buf: pointer, length: int): int {. + cdecl, dynlib: dllname, importc: "zzip_file_read".} +proc zzip_open*(name: cstring, flags: int32): ptr ZZipFile {.cdecl, + dynlib: dllname, importc: "zzip_open".} +proc zzip_close*(fp: ptr ZZipFile) {.cdecl, dynlib: dllname, + importc: "zzip_close".} +proc zzip_read*(fp: ptr ZZipFile, buf: pointer, length: int): int {. + cdecl, dynlib: dllname, importc: "zzip_read".} + +proc zzip_freopen*(name: cstring, mode: cstring, para3: ptr ZZipFile): ptr ZZipFile {. + cdecl, dynlib: dllname, importc: "zzip_freopen".} +proc zzip_fopen*(name: cstring, mode: cstring): ptr ZZipFile {.cdecl, + dynlib: dllname, importc: "zzip_fopen".} +proc zzip_fread*(p: pointer, size: int, nmemb: int, + file: ptr ZZipFile): int {.cdecl, dynlib: dllname, + importc: "zzip_fread".} +proc zzip_fclose*(fp: ptr ZZipFile) {.cdecl, dynlib: dllname, + importc: "zzip_fclose".} + +proc zzip_rewind*(fp: ptr ZZipFile): int32 {.cdecl, dynlib: dllname, + importc: "zzip_rewind".} +proc zzip_seek*(fp: ptr ZZipFile, offset: int, whence: int32): int {. + cdecl, dynlib: dllname, importc: "zzip_seek".} +proc zzip_tell*(fp: ptr ZZipFile): int {.cdecl, dynlib: dllname, + importc: "zzip_tell".} + +proc zzip_dir_stat*(dir: ptr ZZipDir, name: cstring, zs: ptr ZZipStat, + flags: int32): int32 {.cdecl, dynlib: dllname, + importc: "zzip_dir_stat".} +proc zzip_file_stat*(fp: ptr ZZipFile, zs: ptr ZZipStat): int32 {.cdecl, + dynlib: dllname, importc: "zzip_file_stat".} +proc zzip_fstat*(fp: ptr ZZipFile, zs: ptr ZZipStat): int32 {.cdecl, dynlib: dllname, + importc: "zzip_fstat".} + +proc zzip_open_shared_io*(stream: ptr ZZipFile, name: cstring, + o_flags: int32, o_modes: int32, ext: cstringArray, + io: ptr ZZipPluginIO): ptr ZZipFile {.cdecl, + dynlib: dllname, importc: "zzip_open_shared_io".} +proc zzip_open_ext_io*(name: cstring, o_flags: int32, o_modes: int32, + ext: cstringArray, io: ptr ZZipPluginIO): ptr ZZipFile {. + cdecl, dynlib: dllname, importc: "zzip_open_ext_io".} +proc zzip_opendir_ext_io*(name: cstring, o_modes: int32, + ext: cstringArray, io: ptr ZZipPluginIO): ptr ZZipDir {. + cdecl, dynlib: dllname, importc: "zzip_opendir_ext_io".} +proc zzip_dir_open_ext_io*(filename: cstring, errcode_p: ptr TZZipError, + ext: cstringArray, io: ptr ZZipPluginIO): ptr ZZipDir {. + cdecl, dynlib: dllname, importc: "zzip_dir_open_ext_io".} diff --git a/tests/generics/trtree.nim b/tests/generics/trtree.nim new file mode 100644 index 000000000..875b628ae --- /dev/null +++ b/tests/generics/trtree.nim @@ -0,0 +1,657 @@ +discard """ + output: '''1 [2, 3, 4, 7] +[0, 0]''' +""" + +# Nim RTree and R*Tree implementation +# S. Salewski, 06-JAN-2018 + +# http://www-db.deis.unibo.it/courses/SI-LS/papers/Gut84.pdf +# http://dbs.mathematik.uni-marburg.de/publications/myPapers/1990/BKSS90.pdf + +# RT: range type like float, int +# D: Dimension +# M: Max entries in one node +# LT: leaf type + +type + Dim* = static[int] + Ext[RT] = tuple[a, b: RT] # extend (range) + Box*[D: Dim; RT] = array[D, Ext[RT]] # Rectangle for 2D + BoxCenter*[D: Dim; RT] = array[D, RT] + L*[D: Dim; RT, LT] = tuple[b: Box[D, RT]; l: LT] # called Index Entry or index record in the Guttman paper + H[M, D: Dim; RT, LT] = ref object of RootRef + parent: H[M, D, RT, LT] + numEntries: int + level: int + N[M, D: Dim; RT, LT] = tuple[b: Box[D, RT]; n: H[M, D, RT, LT]] + LA[M, D: Dim; RT, LT] = array[M, L[D, RT, LT]] + NA[M, D: Dim; RT, LT] = array[M, N[M, D, RT, LT]] + Leaf[M, D: Dim; RT, LT] = ref object of H[M, D, RT, LT] + a: LA[M, D, RT, LT] + Node[M, D: Dim; RT, LT] = ref object of H[M, D, RT, LT] + a: NA[M, D, RT, LT] + + RTree*[M, D: Dim; RT, LT] = ref object of RootRef + root: H[M, D, RT, LT] + bigM: int + m: int + + RStarTree*[M, D: Dim; RT, LT] = ref object of RTree[M, D, RT, LT] + firstOverflow: array[32, bool] + p: int + +proc newLeaf[M, D: Dim; RT, LT](): Leaf[M, D, RT, LT] = + new result + +proc newNode[M, D: Dim; RT, LT](): Node[M, D, RT, LT] = + new result + +proc newRTree*[M, D: Dim; RT, LT](minFill: range[30 .. 50] = 40): RTree[M, D, RT, LT] = + assert(M > 1 and M < 101) + new result + result.bigM = M + result.m = M * minFill div 100 + result.root = newLeaf[M, D, RT, LT]() + +proc newRStarTree*[M, D: Dim; RT, LT](minFill: range[30 .. 50] = 40): RStarTree[M, D, RT, LT] = + assert(M > 1 and M < 101) + new result + result.bigM = M + result.m = M * minFill div 100 + result.p = M * 30 div 100 + result.root = newLeaf[M, D, RT, LT]() + +proc center(r: Box): auto =#BoxCenter[r.len, type(r[0].a)] = + var result: BoxCenter[r.len, type(r[0].a)] + for i in 0 .. r.high: + when r[0].a is SomeInteger: + result[i] = (r[i].a + r[i].b) div 2 + elif r[0].a is SomeReal: + result[i] = (r[i].a + r[i].b) / 2 + else: assert false + return result + +proc distance(c1, c2: BoxCenter): auto = + var result: type(c1[0]) + for i in 0 .. c1.high: + result += (c1[i] - c2[i]) * (c1[i] - c2[i]) + return result + +proc overlap(r1, r2: Box): auto = + result = type(r1[0].a)(1) + for i in 0 .. r1.high: + result *= (min(r1[i]. b, r2[i]. b) - max(r1[i]. a, r2[i]. a)) + if result <= 0: return 0 + +proc union(r1, r2: Box): Box = + for i in 0 .. r1.high: + result[i]. a = min(r1[i]. a, r2[i]. a) + result[i]. b = max(r1[i]. b, r2[i]. b) + +proc intersect(r1, r2: Box): bool = + for i in 0 .. r1.high: + if r1[i].b < r2[i].a or r1[i].a > r2[i].b: + return false + return true + +proc area(r: Box): auto = #type(r[0].a) = + result = type(r[0].a)(1) + for i in 0 .. r.high: + result *= r[i]. b - r[i]. a + +proc margin(r: Box): auto = #type(r[0].a) = + result = type(r[0].a)(0) + for i in 0 .. r.high: + result += r[i]. b - r[i]. a + +# how much enlargement does r1 need to include r2 +proc enlargement(r1, r2: Box): auto = + area(union(r1, r2)) - area(r1) + +proc search*[M, D: Dim; RT, LT](t: RTree[M, D, RT, LT]; b: Box[D, RT]): seq[LT] = + proc s[M, D: Dim; RT, LT](n: H[M, D, RT, LT]; b: Box[D, RT]; res: var seq[LT]) = + if n of Node[M, D, RT, LT]: + let h = Node[M, D, RT, LT](n) + for i in 0 ..< n.numEntries: + if intersect(h.a[i].b, b): + s(h.a[i].n, b, res) + elif n of Leaf[M, D, RT, LT]: + let h = Leaf[M, D, RT, LT](n) + for i in 0 ..< n.numEntries: + if intersect(h.a[i].b, b): + res.add(h.a[i].l) + else: assert false + result = newSeq[LT]() + s(t.root, b, result) + +# Insertion +# a R*TREE proc +proc chooseSubtree[M, D: Dim; RT, LT](t: RTree[M, D, RT, LT]; b: Box[D, RT]; level: int): H[M, D, RT, LT] = + assert level >= 0 + var n = t.root + while n.level > level: + let nn = Node[M, D, RT, LT](n) + var i0 = 0 # selected index + var minLoss = type(b[0].a).high + if n.level == 1: # childreen are leaves -- determine the minimum overlap costs + for i in 0 ..< n.numEntries: + let nx = union(nn.a[i].b, b) + var loss = 0 + for j in 0 ..< n.numEntries: + if i == j: continue + loss += (overlap(nx, nn.a[j].b) - overlap(nn.a[i].b, nn.a[j].b)) # overlap (i, j) == (j, i), so maybe cache that? + var rep = loss < minLoss + if loss == minLoss: + let l2 = enlargement(nn.a[i].b, b) - enlargement(nn.a[i0].b, b) + rep = l2 < 0 + if l2 == 0: + let l3 = area(nn.a[i].b) - area(nn.a[i0].b) + rep = l3 < 0 + if l3 == 0: + rep = nn.a[i].n.numEntries < nn.a[i0].n.numEntries + if rep: + i0 = i + minLoss = loss + else: + for i in 0 ..< n.numEntries: + let loss = enlargement(nn.a[i].b, b) + var rep = loss < minLoss + if loss == minLoss: + let l3 = area(nn.a[i].b) - area(nn.a[i0].b) + rep = l3 < 0 + if l3 == 0: + rep = nn.a[i].n.numEntries < nn.a[i0].n.numEntries + if rep: + i0 = i + minLoss = loss + n = nn.a[i0].n + return n + +proc chooseLeaf[M, D: Dim; RT, LT](t: RTree[M, D, RT, LT]; b: Box[D, RT]; level: int): H[M, D, RT, LT] = + assert level >= 0 + var n = t.root + while n.level > level: + var j = -1 # selected index + var x: type(b[0].a) + let nn = Node[M, D, RT, LT](n) + for i in 0 ..< n.numEntries: + let h = enlargement(nn.a[i].b, b) + if j < 0 or h < x or (x == h and area(nn.a[i].b) < area(nn.a[j].b)): + x = h + j = i + n = nn.a[j].n + return n + +proc pickSeeds[M, D: Dim; RT, LT](t: RTree[M, D, RT, LT]; n: Node[M, D, RT, LT] | Leaf[M, D, RT, LT]; bx: Box[D, RT]): (int, int) = + var i0, j0: int + var bi, bj: type(bx) + var largestWaste = type(bx[0].a).low + for i in -1 .. n.a.high: + for j in 0 .. n.a.high: + if unlikely(i == j): continue + if unlikely(i < 0): + bi = bx + else: + bi = n.a[i].b + bj = n.a[j].b + let b = union(bi, bj) + let h = area(b) - area(bi) - area(bj) + if h > largestWaste: + largestWaste = h + i0 = i + j0 = j + return (i0, j0) + +proc pickNext[M, D: Dim; RT, LT](t: RTree[M, D, RT, LT]; n0, n1, n2: Node[M, D, RT, LT] | Leaf[M, D, RT, LT]; b1, b2: Box[D, RT]): int = + let a1 = area(b1) + let a2 = area(b2) + var d = type(a1).low + for i in 0 ..< n0.numEntries: + let d1 = area(union(b1, n0.a[i].b)) - a1 + let d2 = area(union(b2, n0.a[i].b)) - a2 + if (d1 - d2) * (d1 - d2) > d: + result = i + d = (d1 - d2) * (d1 - d2) + +from algorithm import SortOrder, sort +proc sortPlus[T](a: var openArray[T], ax: var T, cmp: proc (x, y: T): int {.closure.}, order = algorithm.SortOrder.Ascending) = + var j = 0 + let sign = if order == algorithm.SortOrder.Ascending: 1 else: -1 + for i in 1 .. a.high: + if cmp(a[i], a[j]) * sign < 0: + j = i + if cmp(a[j], ax) * sign < 0: + swap(ax, a[j]) + a.sort(cmp, order) + +# R*TREE procs +proc rstarSplit[M, D: Dim; RT, LT](t: RStarTree[M, D, RT, LT]; n: var Node[M, D, RT, LT] | var Leaf[M, D, RT, LT]; lx: L[D, RT, LT] | N[M, D, RT, LT]): type(n) = + type NL = type(lx) + var nBest: type(n) + new nBest + var lx = lx + when n is Node[M, D, RT, LT]: + lx.n.parent = n + var lxbest: type(lx) + var m0 = lx.b[0].a.high + for d2 in 0 ..< 2 * D: + let d = d2 div 2 + if d2 mod 2 == 0: + sortPlus(n.a, lx, proc (x, y: NL): int = cmp(x.b[d].a, y.b[d].a)) + else: + sortPlus(n.a, lx, proc (x, y: NL): int = cmp(x.b[d].b, y.b[d].b)) + for i in t.m - 1 .. n.a.high - t.m + 1: + var b = lx.b + for j in 0 ..< i: # we can precalculate union() for range 0 .. t.m - 1, but that seems to give no real benefit. Maybe for very large M? + #echo "x",j + b = union(n.a[j].b, b) + var m = margin(b) + b = n.a[^1].b + for j in i ..< n.a.high: # again, precalculation of tail would be possible + #echo "y",j + b = union(n.a[j].b, b) + m += margin(b) + if m < m0: + nbest[] = n[] + lxbest = lx + m0 = m + var i0 = -1 + var o0 = lx.b[0].a.high + for i in t.m - 1 .. n.a.high - t.m + 1: + var b1 = lxbest.b + for j in 0 ..< i: + b1 = union(nbest.a[j].b, b1) + var b2 = nbest.a[^1].b + for j in i ..< n.a.high: + b2 = union(nbest.a[j].b, b2) + let o = overlap(b1, b2) + if o < o0: + i0 = i + o0 = o + n.a[0] = lxbest + for i in 0 ..< i0: + n.a[i + 1] = nbest.a[i] + new result + result.level = n.level + result.parent = n.parent + for i in i0 .. n.a.high: + result.a[i - i0] = nbest.a[i] + n.numEntries = i0 + 1 + result.numEntries = M - i0 + when n is Node[M, D, RT, LT]: + for i in 0 ..< result.numEntries: + result.a[i].n.parent = result + +proc quadraticSplit[M, D: Dim; RT, LT](t: RTree[M, D, RT, LT]; n: var Node[M, D, RT, LT] | var Leaf[M, D, RT, LT]; lx: L[D, RT, LT] | N[M, D, RT, LT]): type(n) = + var n1, n2: type(n) + var s1, s2: int + new n1 + new n2 + n1.parent = n.parent + n2.parent = n.parent + n1.level = n.level + n2.level = n.level + var lx = lx + when n is Node[M, D, RT, LT]: + lx.n.parent = n + (s1, s2) = pickSeeds(t, n, lx.b) + assert s1 >= -1 and s2 >= 0 + if unlikely(s1 < 0): + n1.a[0] = lx + else: + n1.a[0] = n.a[s1] + dec(n.numEntries) + if s2 == n.numEntries: # important fix + s2 = s1 + n.a[s1] = n.a[n.numEntries] + inc(n1.numEntries) + var b1 = n1.a[0].b + n2.a[0] = n.a[s2] + dec(n.numEntries) + n.a[s2] = n.a[n.numEntries] + inc(n2.numEntries) + var b2 = n2.a[0].b + if s1 >= 0: + n.a[n.numEntries] = lx + inc(n.numEntries) + while n.numEntries > 0 and n1.numEntries < (t.bigM + 1 - t.m) and n2.numEntries < (t.bigM + 1 - t.m): + let next = pickNext(t, n, n1, n2, b1, b2) + let d1 = area(union(b1, n.a[next].b)) - area(b1) + let d2 = area(union(b2, n.a[next].b)) - area(b2) + if (d1 < d2) or (d1 == d2 and ((area(b1) < area(b2)) or (area(b1) == area(b2) and n1.numEntries < n2.numEntries))): + n1.a[n1.numEntries] = n.a[next] + b1 = union(b1, n.a[next].b) + inc(n1.numEntries) + else: + n2.a[n2.numEntries] = n.a[next] + b2 = union(b2, n.a[next].b) + inc(n2.numEntries) + dec(n.numEntries) + n.a[next] = n.a[n.numEntries] + if n.numEntries == 0: + discard + elif n1.numEntries == (t.bigM + 1 - t.m): + while n.numEntries > 0: + dec(n.numEntries) + n2.a[n2.numEntries] = n.a[n.numEntries] + inc(n2.numEntries) + elif n2.numEntries == (t.bigM + 1 - t.m): + while n.numEntries > 0: + dec(n.numEntries) + n1.a[n1.numEntries] = n.a[n.numEntries] + inc(n1.numEntries) + when n is Node[M, D, RT, LT]: + for i in 0 ..< n2.numEntries: + n2.a[i].n.parent = n2 + n[] = n1[] + return n2 + +proc overflowTreatment[M, D: Dim; RT, LT](t: RStarTree[M, D, RT, LT]; n: var Node[M, D, RT, LT] | var Leaf[M, D, RT, LT]; lx: L[D, RT, LT] | N[M, D, RT, LT]): type(n) + +proc adjustTree[M, D: Dim; RT, LT](t: RTree[M, D, RT, LT]; l, ll: H[M, D, RT, LT]; hb: Box[D, RT]) = + var n = l + var nn = ll + assert n != nil + while true: + if n == t.root: + if nn == nil: + break + t.root = newNode[M, D, RT, LT]() + t.root.level = n.level + 1 + Node[M, D, RT, LT](t.root).a[0].n = n + n.parent = t.root + nn.parent = t.root + t.root.numEntries = 1 + let p = Node[M, D, RT, LT](n.parent) + var i = 0 + while p.a[i].n != n: + inc(i) + var b: type(p.a[0].b) + if n of Leaf[M, D, RT, LT]: + when false:#if likely(nn.isNil): # no performance gain + b = union(p.a[i].b, Leaf[M, D, RT, LT](n).a[n.numEntries - 1].b) + else: + b = Leaf[M, D, RT, LT](n).a[0].b + for j in 1 ..< n.numEntries: + b = trtree.union(b, Leaf[M, D, RT, LT](n).a[j].b) + elif n of Node[M, D, RT, LT]: + b = Node[M, D, RT, LT](n).a[0].b + for j in 1 ..< n.numEntries: + b = union(b, Node[M, D, RT, LT](n).a[j].b) + else: + assert false + #if nn.isNil and p.a[i].b == b: break # no performance gain + p.a[i].b = b + n = H[M, D, RT, LT](p) + if unlikely(nn != nil): + if nn of Leaf[M, D, RT, LT]: + b = Leaf[M, D, RT, LT](nn).a[0].b + for j in 1 ..< nn.numEntries: + b = union(b, Leaf[M, D, RT, LT](nn).a[j].b) + elif nn of Node[M, D, RT, LT]: + b = Node[M, D, RT, LT](nn).a[0].b + for j in 1 ..< nn.numEntries: + b = union(b, Node[M, D, RT, LT](nn).a[j].b) + else: + assert false + if p.numEntries < p.a.len: + p.a[p.numEntries].b = b + p.a[p.numEntries].n = nn + inc(p.numEntries) + assert n != nil + nn = nil + else: + let h: N[M, D, RT, LT] = (b, nn) + if t of RStarTree[M, D, RT, LT]: + nn = overflowTreatment(RStarTree[M, D, RT, LT](t), p, h) + elif t of RTree[M, D, RT, LT]: + nn = quadraticSplit(RTree[M, D, RT, LT](t), p, h) + else: + assert false + assert n == H[M, D, RT, LT](p) + assert n != nil + assert t.root != nil + +proc insert*[M, D: Dim; RT, LT](t: RTree[M, D, RT, LT]; leaf: N[M, D, RT, LT] | L[D, RT, LT]; level: int = 0) = + when leaf is N[M, D, RT, LT]: + assert level > 0 + type NodeLeaf = Node[M, D, RT, LT] + else: + assert level == 0 + type NodeLeaf = Leaf[M, D, RT, LT] + for d in leaf.b: + assert d.a <= d.b + let l = NodeLeaf(chooseSubtree(t, leaf.b, level)) + if l.numEntries < l.a.len: + l.a[l.numEntries] = leaf + inc(l.numEntries) + when leaf is N[M, D, RT, LT]: + leaf.n.parent = l + adjustTree(t, l, nil, leaf.b) + else: + let l2 = quadraticSplit(t, l, leaf) + assert l2.level == l.level + adjustTree(t, l, l2, leaf.b) + +# R*Tree insert procs +proc rsinsert[M, D: Dim; RT, LT](t: RStarTree[M, D, RT, LT]; leaf: N[M, D, RT, LT] | L[D, RT, LT]; level: int) + +proc reInsert[M, D: Dim; RT, LT](t: RStarTree[M, D, RT, LT]; n: var Node[M, D, RT, LT] | var Leaf[M, D, RT, LT]; lx: L[D, RT, LT] | N[M, D, RT, LT]) = + type NL = type(lx) + var lx = lx + var buf: type(n.a) + let p = Node[M, D, RT, LT](n.parent) + var i = 0 + while p.a[i].n != n: + inc(i) + let c = center(p.a[i].b) + sortPlus(n.a, lx, proc (x, y: NL): int = cmp(distance(center(x.b), c), distance(center(y.b), c))) + n.numEntries = M - t.p + swap(n.a[n.numEntries], lx) + inc n.numEntries + var b = n.a[0].b + for i in 1 ..< n.numEntries: + b = union(b, n.a[i].b) + p.a[i].b = b + for i in M - t.p + 1 .. n.a.high: + buf[i] = n.a[i] + rsinsert(t, lx, n.level) + for i in M - t.p + 1 .. n.a.high: + rsinsert(t, buf[i], n.level) + +proc overflowTreatment[M, D: Dim; RT, LT](t: RStarTree[M, D, RT, LT]; n: var Node[M, D, RT, LT] | var Leaf[M, D, RT, LT]; lx: L[D, RT, LT] | N[M, D, RT, LT]): type(n) = + if n.level != t.root.level and t.firstOverflow[n.level]: + t.firstOverflow[n.level] = false + reInsert(t, n, lx) + return nil + else: + let l2 = rstarSplit(t, n, lx) + assert l2.level == n.level + return l2 + +proc rsinsert[M, D: Dim; RT, LT](t: RStarTree[M, D, RT, LT]; leaf: N[M, D, RT, LT] | L[D, RT, LT]; level: int) = + when leaf is N[M, D, RT, LT]: + assert level > 0 + type NodeLeaf = Node[M, D, RT, LT] + else: + assert level == 0 + type NodeLeaf = Leaf[M, D, RT, LT] + let l = NodeLeaf(chooseSubtree(t, leaf.b, level)) + if l.numEntries < l.a.len: + l.a[l.numEntries] = leaf + inc(l.numEntries) + when leaf is N[M, D, RT, LT]: + leaf.n.parent = l + adjustTree(t, l, nil, leaf.b) + else: + when leaf is N[M, D, RT, LT]: # TODO do we need this? + leaf.n.parent = l + let l2 = overflowTreatment(t, l, leaf) + if l2 != nil: + assert l2.level == l.level + adjustTree(t, l, l2, leaf.b) + +proc insert*[M, D: Dim; RT, LT](t: RStarTree[M, D, RT, LT]; leaf: L[D, RT, LT]) = + for d in leaf.b: + assert d.a <= d.b + for i in mitems(t.firstOverflow): + i = true + rsinsert(t, leaf, 0) + +# delete +proc findLeaf[M, D: Dim; RT, LT](t: RTree[M, D, RT, LT]; leaf: L[D, RT, LT]): Leaf[M, D, RT, LT] = + proc fl[M, D: Dim; RT, LT](h: H[M, D, RT, LT]; leaf: L[D, RT, LT]): Leaf[M, D, RT, LT] = + var n = h + if n of Node[M, D, RT, LT]: + for i in 0 ..< n.numEntries: + if intersect(Node[M, D, RT, LT](n).a[i].b, leaf.b): + let l = fl(Node[M, D, RT, LT](n).a[i].n, leaf) + if l != nil: + return l + elif n of Leaf[M, D, RT, LT]: + for i in 0 ..< n.numEntries: + if Leaf[M, D, RT, LT](n).a[i] == leaf: + return Leaf[M, D, RT, LT](n) + else: + assert false + return nil + fl(t.root, leaf) + +proc condenseTree[M, D: Dim; RT, LT](t: RTree[M, D, RT, LT]; leaf: Leaf[M, D, RT, LT]) = + var n: H[M, D, RT, LT] = leaf + var q = newSeq[H[M, D, RT, LT]]() + var b: type(leaf.a[0].b) + while n != t.root: + let p = Node[M, D, RT, LT](n.parent) + var i = 0 + while p.a[i].n != n: + inc(i) + if n.numEntries < t.m: + dec(p.numEntries) + p.a[i] = p.a[p.numEntries] + q.add(n) + else: + if n of Leaf[M, D, RT, LT]: + b = Leaf[M, D, RT, LT](n).a[0].b + for j in 1 ..< n.numEntries: + b = union(b, Leaf[M, D, RT, LT](n).a[j].b) + elif n of Node[M, D, RT, LT]: + b = Node[M, D, RT, LT](n).a[0].b + for j in 1 ..< n.numEntries: + b = union(b, Node[M, D, RT, LT](n).a[j].b) + else: + assert false + p.a[i].b = b + n = n.parent + if t of RStarTree[M, D, RT, LT]: + for n in q: + if n of Leaf[M, D, RT, LT]: + for i in 0 ..< n.numEntries: + for i in mitems(RStarTree[M, D, RT, LT](t).firstOverflow): + i = true + rsinsert(RStarTree[M, D, RT, LT](t), Leaf[M, D, RT, LT](n).a[i], 0) + elif n of Node[M, D, RT, LT]: + for i in 0 ..< n.numEntries: + for i in mitems(RStarTree[M, D, RT, LT](t).firstOverflow): + i = true + rsinsert(RStarTree[M, D, RT, LT](t), Node[M, D, RT, LT](n).a[i], n.level) + else: + assert false + elif t of RTree[M, D, RT, LT]: + for n in q: + if n of Leaf[M, D, RT, LT]: + for i in 0 ..< n.numEntries: + insert(RTree[M, D, RT, LT](t), Leaf[M, D, RT, LT](n).a[i]) + elif n of Node[M, D, RT, LT]: + for i in 0 ..< n.numEntries: + insert(RTree[M, D, RT, LT](t), Node[M, D, RT, LT](n).a[i], n.level) + else: + assert false + else: + assert false + +proc delete*[M, D: Dim; RT, LT](t: RTree[M, D, RT, LT]; leaf: L[D, RT, LT]): bool {.discardable.} = + let l = findLeaf(t, leaf) + if l.isNil: + return false + else: + var i = 0 + while l.a[i] != leaf: + inc(i) + dec(l.numEntries) + l.a[i] = l.a[l.numEntries] + condenseTree(t, l) + if t.root.numEntries == 1: + if t.root of Node[M, D, RT, LT]: + t.root = Node[M, D, RT, LT](t.root).a[0].n + t.root.parent = nil + return true + +when isMainModule: + + var t = [4, 1, 3, 2] + var xt = 7 + sortPlus(t, xt, system.cmp, SortOrder.Ascending) + echo xt, " ", t + + type + RSE = L[2, int, int] + RSeq = seq[RSE] + + proc rseq_search(rs: RSeq; rse: RSE): seq[int] = + result = newSeq[int]() + for i in rs: + if intersect(i.b, rse.b): + result.add(i.l) + + proc rseq_delete(rs: var RSeq; rse: RSE): bool = + for i in 0 .. rs.high: + if rs[i] == rse: + #rs.delete(i) + rs[i] = rs[rs.high] + rs.setLen(rs.len - 1) + return true + + import random, algorithm + + proc test(n: int) = + var b: Box[2, int] + echo center(b) + var x1, x2, y1, y2: int + var t = newRStarTree[8, 2, int, int]() + #var t = newRTree[8, 2, int, int]() + var rs = newSeq[RSE]() + for i in 0 .. 5: + for i in 0 .. n - 1: + x1 = rand(1000) + y1 = rand(1000) + x2 = x1 + rand(25) + y2 = y1 + rand(25) + b = [(x1, x2), (y1, y2)] + let el: L[2, int, int] = (b, i + 7) + t.insert(el) + rs.add(el) + + for i in 0 .. (n div 4): + let j = rand(rs.high) + var el = rs[j] + assert t.delete(el) + assert rs.rseq_delete(el) + + for i in 0 .. n - 1: + x1 = rand(1000) + y1 = rand(1000) + x2 = x1 + rand(100) + y2 = y1 + rand(100) + b = [(x1, x2), (y1, y2)] + let el: L[2, int, int] = (b, i) + let r = search(t, b) + let r2 = rseq_search(rs, el) + assert r.len == r2.len + assert r.sorted(system.cmp) == r2.sorted(system.cmp) + + test(5500) + + # 651 lines + diff --git a/tests/iter/tyieldintry.nim b/tests/iter/tyieldintry.nim index 48d05e866..6d24417a6 100644 --- a/tests/iter/tyieldintry.nim +++ b/tests/iter/tyieldintry.nim @@ -416,5 +416,28 @@ block: #8851 test(it, 1) +block: # 8243 + iterator it(): int {.closure.} = + template yieldAndSeq: seq[int] = + yield 1 + @[123, 5, 123] + + checkpoint(yieldAndSeq[1]) + + test(it, 1, 5) + +block: + iterator it(): int {.closure.} = + template yieldAndSeq: seq[int] = + yield 1 + @[123, 5, 123] + + template yieldAndNum: int = + yield 2 + 1 + + checkpoint(yieldAndSeq[yieldAndNum]) + + test(it, 1, 2, 5) echo "ok" diff --git a/tests/js/t7224.nim b/tests/js/t7224.nim new file mode 100644 index 000000000..2d7ee1336 --- /dev/null +++ b/tests/js/t7224.nim @@ -0,0 +1,26 @@ +discard """ + cmd: "nim $target $options --stackTrace:on --lineTrace:on $file" + outputsub: ''' +t7224.aaa, line: 21 +t7224.bbb, line: 18 +t7224.ccc, line: 15 +t7224.ddd, line: 12 +''' +""" + +proc ddd() = + raise newException(IOError, "didn't do stuff") + +proc ccc() = + ddd() + +proc bbb() = + ccc() + +proc aaa() = + bbb() + +try: + aaa() +except IOError as e: + echo getStackTrace(e) diff --git a/tests/js/t7249.nim b/tests/js/t7249.nim new file mode 100644 index 000000000..52eee2f7c --- /dev/null +++ b/tests/js/t7249.nim @@ -0,0 +1,21 @@ +discard """ + output: ''' +a -> 2 +a <- 2 +''' +""" + +import jsffi + +var a = JsAssoc[cstring, int]{a: 2} + +for z, b in a: + echo z, " -> ", b + +proc f = + var a = JsAssoc[cstring, int]{a: 2} + + for z, b in a: + echo z, " <- ", b + +f() diff --git a/tests/js/t7534.nim b/tests/js/t7534.nim new file mode 100644 index 000000000..64aadb8d6 --- /dev/null +++ b/tests/js/t7534.nim @@ -0,0 +1,7 @@ +proc f(x: int): int = + result = case x + of 1: 2 + elif x == 2: 3 + else: 1 + +doAssert 2 == f(f(f(f(1)))) diff --git a/tests/js/t8914.nim b/tests/js/t8914.nim new file mode 100644 index 000000000..ff716b42a --- /dev/null +++ b/tests/js/t8914.nim @@ -0,0 +1,12 @@ +discard """ + output: ''' +@[42] +@[24, 42] +''' +""" + +var x = @[42,4242] +x.delete(1) +echo x +x.insert(24) +echo x diff --git a/tests/js/taddnilstr.nim b/tests/js/taddnilstr.nim new file mode 100644 index 000000000..f5b934fdd --- /dev/null +++ b/tests/js/taddnilstr.nim @@ -0,0 +1,4 @@ +var x = "foo".cstring +var y: string +add(y, x) +doAssert y == "foo" diff --git a/tests/js/tmangle.nim b/tests/js/tmangle.nim index c4167ba39..c97bf7029 100644 --- a/tests/js/tmangle.nim +++ b/tests/js/tmangle.nim @@ -27,10 +27,10 @@ block: var global = T(a: 11, b: "foo") proc test(): bool = var obj = T(a: 11, b: "foo") - {. emit: [result, " = (", obj.addr[], "[0].a == 11);"] .} - {. emit: [result, " = ", result, " && (", obj.addr[], "[0].b == \"foo\");"] .} - {. emit: [result, " = ", result, " && (", global, "[0].a == 11);"] .} - {. emit: [result, " = ", result, " && (", global, "[0].b == \"foo\");"] .} + {. emit: [result, " = (", obj.addr[], ".a == 11);"] .} + {. emit: [result, " = ", result, " && (", obj.addr[], ".b == \"foo\");"] .} + {. emit: [result, " = ", result, " && (", global, ".a == 11);"] .} + {. emit: [result, " = ", result, " && (", global, ".b == \"foo\");"] .} echo test() # Test addr of field: diff --git a/tests/js/tstrconcat.nim b/tests/js/tstrconcat.nim new file mode 100644 index 000000000..37c8db687 --- /dev/null +++ b/tests/js/tstrconcat.nim @@ -0,0 +1,5 @@ +var x: string +var y = "foo" +add(x, y) +y[0] = 'm' +doAssert y == "moo" and x == "foo" diff --git a/tests/js/tstringitems.nim b/tests/js/tstringitems.nim index ff016642e..f09793dde 100644 --- a/tests/js/tstringitems.nim +++ b/tests/js/tstringitems.nim @@ -45,7 +45,7 @@ block: # Test compile-time binary data generation, invalid unicode block: # Test unicode strings const constStr = "Привет!" var jsStr : cstring - {.emit: """`jsStr`[0] = "Привет!";""".} + {.emit: """`jsStr` = "Привет!";""".} doAssert($jsStr == constStr) var runtimeStr = "При" diff --git a/tests/macros/tcollect.nim b/tests/macros/tcollect.nim new file mode 100644 index 000000000..ae28ab61b --- /dev/null +++ b/tests/macros/tcollect.nim @@ -0,0 +1,63 @@ +discard """ + output: '''@[2, 3, 4, 2, 3, 4, 2, 3, 4, 2, 3, 4, 2, 3, 4] +@[0, 1, 2, 3]''' +""" + +const data = [1,2,3,4,5,6] + +import macros + +macro collect(body): untyped = + # analyse the body, find the deepest expression 'it' and replace it via + # 'result.add it' + let res = genSym(nskVar, "collectResult") + + when false: + proc detectForLoopVar(n: NimNode): NimNode = + if n.kind == nnkForStmt: + result = n[0] + else: + for x in n: + result = detectForLoopVar(x) + if result != nil: return result + return nil + + proc t(n, res: NimNode): NimNode = + case n.kind + of nnkStmtList, nnkStmtListExpr, nnkBlockStmt, nnkBlockExpr, + nnkWhileStmt, + nnkForStmt, nnkIfExpr, nnkIfStmt, nnkTryStmt, nnkCaseStmt, + nnkElifBranch, nnkElse, nnkElifExpr: + result = copyNimTree(n) + if n.len >= 1: + result[^1] = t(n[^1], res) + else: + if true: #n == it: + template adder(res, it) = + res.add it + result = getAst adder(res, n) + else: + result = n + + when false: + let it = detectForLoopVar(body) + if it == nil: error("no for loop in body", body) + + let v = newTree(nnkVarSection, + newTree(nnkIdentDefs, res, newTree(nnkBracketExpr, bindSym"seq", + newCall(bindSym"type", body)), newEmptyNode())) + + result = newTree(nnkStmtListExpr, v, t(body, res), res) + #echo repr result + +let stuff = collect: + var i = -1 + while i < 4: + inc i + for it in data: + if it < 5 and it > 1: + it + +echo stuff + +echo collect(for i in 0..3: i) diff --git a/tests/macros/tmacrostmt.nim b/tests/macros/tmacrostmt.nim index 9dbfbce43..c1f26e626 100644 --- a/tests/macros/tmacrostmt.nim +++ b/tests/macros/tmacrostmt.nim @@ -43,6 +43,10 @@ macro repr_and_parse(fn: typed): typed = echo fn_impl.repr result = parseStmt(fn_impl.repr) +macro repr_to_string(fn: typed): string = + let fn_impl = fn.getImpl + result = newStrLitNode(fn_impl.repr) + repr_and_parse(f) @@ -70,8 +74,49 @@ proc test_cond_stmtlist(x, y: int): int = result = x +#------------------------------------ +# bug #8762 +proc t2(a, b: int): int = + `+`(a, b) + + +#------------------------------------ +# bug #8761 + +proc fn1(x, y: int):int = + 2 * (x + y) + +proc fn2(x, y: float): float = + (y + 2 * x) / (x - y) + +proc fn3(x, y: int): bool = + (((x and 3) div 4) or (x mod (y xor -1))) == 0 or y notin [1,2] + +static: + let fn1s = "proc fn1(x, y: int): int =\n result = 2 * (x + y)\n" + let fn2s = "proc fn2(x, y: float): float =\n result = (y + 2.0 * x) / (x - y)\n" + let fn3s = "proc fn3(x, y: int): bool =\n result = ((x and 3) div 4 or x mod (y xor -1)) == 0 or not contains([1, 2], y)\n" + doAssert fn1.repr_to_string == fn1s + doAssert fn2.repr_to_string == fn2s + doAssert fn3.repr_to_string == fn3s + +#------------------------------------ +# bug #8763 + +type + A {.pure.} = enum + X, Y + B {.pure.} = enum + X, Y + +proc test_pure_enums(a: B) = + case a + of B.X: echo B.X + of B.Y: echo B.Y + repr_and_parse(one_if_proc) repr_and_parse(test_block) repr_and_parse(test_cond_stmtlist) - +repr_and_parse(t2) +repr_and_parse(test_pure_enums) diff --git a/tests/openarray/t6163.nim b/tests/openarray/t6163.nim new file mode 100644 index 000000000..ec8c3cd0b --- /dev/null +++ b/tests/openarray/t6163.nim @@ -0,0 +1,17 @@ +discard """ + exitcode: 0 + targets: "c cpp js" + output: '''19316 +''' +""" + +from future import `->`, `=>` +from math import `^`, sum +from sequtils import filter, map, toSeq + +proc f: int = + toSeq(10..<10_000).filter(a => a == ($a).map(d => (d.ord-'0'.ord).int^4).sum).sum + +var a = f() + +echo a \ No newline at end of file diff --git a/tests/seq/t7346.nim b/tests/seq/t7346.nim new file mode 100644 index 000000000..ef2fd5b79 --- /dev/null +++ b/tests/seq/t7346.nim @@ -0,0 +1,10 @@ +when not defined(nimNewRuntime): + {.error: "This bug could only be reproduced with --newruntime".} + +type + Obj = object + a: int + +proc `=`(a: var Obj, b: Obj) = discard + +let a: seq[Obj] = @[] \ No newline at end of file diff --git a/tests/stdlib/tio.nim b/tests/stdlib/tio.nim index 28e1881e8..b1057dee2 100644 --- a/tests/stdlib/tio.nim +++ b/tests/stdlib/tio.nim @@ -1,9 +1,12 @@ discard """ output: '''9 -b = false +b = true 123456789 Second readLine raised an exception 123456789 +1 +2aaaaaaaa +3bbbbbbb ''' """ # bug #5349 @@ -38,3 +41,9 @@ echo line f.close() removeFile(fn) + +# bug #8961 +writeFile("test.txt", "1\C\L2aaaaaaaa\C\L3bbbbbbb") + +for line in lines("test.txt"): + echo line diff --git a/tests/testament/specs.nim b/tests/testament/specs.nim index fbe930a4f..c51a3343e 100644 --- a/tests/testament/specs.nim +++ b/tests/testament/specs.nim @@ -16,7 +16,7 @@ let isTravis* = existsEnv("TRAVIS") let isAppVeyor* = existsEnv("APPVEYOR") proc cmdTemplate*(): string = - compilerPrefix & "$target --lib:lib --hints:on -d:testing $options $file" + compilerPrefix & "$target --lib:lib --hints:on -d:testing --nimblePath:tests/deps $options $file" type TTestAction* = enum diff --git a/tests/typerel/t8905.nim b/tests/typerel/t8905.nim new file mode 100644 index 000000000..9383962cf --- /dev/null +++ b/tests/typerel/t8905.nim @@ -0,0 +1,7 @@ +type + Foo[T] = distinct seq[T] + Bar[T] = object + +proc newFoo[T](): Foo[T] = Foo[T](newSeq[T]()) + +var x = newFoo[Bar[int]]() diff --git a/tests/types/t6969.nim b/tests/types/t6969.nim new file mode 100644 index 000000000..d6ce5e62a --- /dev/null +++ b/tests/types/t6969.nim @@ -0,0 +1,10 @@ +discard """ +errormsg: "invalid type: 'object' for var" +line: 6 +""" + +var a: object a: int +# or +var b: ref object a: int +# or +var c: ptr object a: int \ No newline at end of file diff --git a/tests/types/t7581.nim b/tests/types/t7581.nim new file mode 100644 index 000000000..796f30271 --- /dev/null +++ b/tests/types/t7581.nim @@ -0,0 +1 @@ +discard int -1 \ No newline at end of file |