Mercurial > pub > dyncall > bindings
changeset 0:0cfcc391201f
initial from svn dyncall-1745
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/cocoa/DESCRIPTION Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,12 @@ +Package: cocoa +Version: 0.1 +Date: 2009-06-23 +Title: Cocoa NSAutoreleasePool Object - Mac OS X only +Author: Daniel Adler <dadler@uni-goettingen.de> +Maintainer: Daniel Adler <dadler@uni-goettingen.de> +Depends: R (>= 1.7) +Description: Run GUI applications on Mac OS X from the console +License: BSD +URL: http://dyncall.org +LazyLoad: no +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/cocoa/NAMESPACE Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,1 @@ +useDynLib(cocoa)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/cocoa/R/dummy.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,4 @@ + +dummy <- NULL + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/cocoa/src/package.m Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,29 @@ +/** =========================================================================== + ** R-Package: cocoa + ** File: coca/src/package.m + ** Description: R package registry and initialization of NSAutoreleasePool + ** + ** Copyright (C) 2009 Daniel Adler + **/ +#include <Rinternals.h> +#include <R_ext/Rdynload.h> +#include <stdio.h> +#import <Foundation/NSAutoreleasePool.h> +#import <AppKit/NSApplication.h> +NSAutoreleasePool* pool; + +void R_init_cocoa(DllInfo* info) +{ + [[NSAutoreleasePool alloc] init]; + NSApplicationLoad(); + // [NSApplication sharedApplication]; + // [NSApp run]; + printf("init\n"); + +} + +void R_unload_cocoa(DllInfo* info) +{ + [pool drain]; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/dynport.rnw Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,34 @@ +% \VignetteIndexEntry{Dynamic R Binding to shared C libraries in a portable way} +% \VignetteKeyword{dynport} +% \VignetteKeyword{bindings} +\documentclass{article} +\usepackage{url} +\begin{document} +\title{Dynports: Dynamic R Bindings of shared C libraries in a portable way} +\author{Daniel Adler} +\maketitle + +\section{Introduction} + +A \emph{dynport} is mapped in R as a dynamically created R namespace +containing wrapper functions, constants and type information objects +(used in conjunction with utility functions from the package) to gain +control over a large range of functionality offered by system service +and binary components. +These bindings can be written by hand but - as these are +very structured using formal signatures - this process +is also automated. +Here is a list of dynports for the initial release: + +\begin{tabular}{lll} +dynport & library & details\\ +\hline +GL & OpenGL 1.0 & Portable 3D Graphics System Library \\ +glew & GL Extension Wrangler & Provides OpenGL 3.0 \\ +SDL & Simple DirectMedia Layer & Multimedia and user-interface. \\ +SDL\_ttf & SDL Font Rendering Library & True Type Font Rendering \\ +SDL\_image & SDL Image I/O Library & Image Loading and Saving in many formats \\ +\end{tabular} + +\end{document} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/.project Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,18 @@ +<?xml version="1.0" encoding="UTF-8"?> +<projectDescription> + <name>rdc</name> + <comment></comment> + <projects> + </projects> + <buildSpec> + <buildCommand> + <name>de.walware.statet.r.builders.RSupport</name> + <arguments> + </arguments> + </buildCommand> + </buildSpec> + <natures> + <nature>de.walware.statet.base.StatetNature</nature> + <nature>de.walware.statet.r.RNature</nature> + </natures> +</projectDescription>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/DESCRIPTION Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,8 @@ +Package: rdc +Version: 0.1 +License: bsd +Description: flexible foreign function interface for direct and dynamic calls to arbitrary C libraries +Title: R bindings for dyncall library +Author: Daniel Adler <dadler@uni-goettingen.de> +Maintainer: Daniel Adler <dadler@uni-goettingen.de> +URL: http://dyncall.org
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/DEVELOPER.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,19 @@ +TODO +- helper utility "cocoa.m" for OS X - should be built on OS X + currently renamed to cocoa.m_off + configure should copy cocoa.m_off to cocoa.m on OS X + +BOOTSTRAP R PACKAGE + +Download DynCall C library zip package and unpack in rdc/src as "dyncall" folder. +For your convienience ... do + + cd rdc ; sh bootstrap + + +Then build + + cd .. + R CMD INSTALL rdc + +LazyLoad: yes
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/NAMESPACE Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,9 @@ +useDynLib(rdc) +export( + rdcLoad,rdcFree,rdcFind,rdcCall, + rdcPath,rdcUnpath,rdcShowPath, + rdcUnpack1,rdcDataPtr,rdcSizeOf, + rdcBind, + rdcMode, + dcNewCallVM, dcCall, dcMode +)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/R/api.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,121 @@ +# DynCall R bindings +# Copyright (C) 2007-2009 Daniel Adler +# TODO: +# - pointer arithmetic: == or identical, is.NULL or is.nil +# - pointer arrays + +rdcLoad <- function (libpath) +{ + .Call("rdcLoad", as.character(libpath) , PACKAGE="rdc") +} + +rdcFree <- function (libhandle) +{ + .Call("rdcFree", libhandle, PACKAGE="rdc") +} + +rdcFind <- function (libhandle, symbol) +{ + .Call("rdcFind", libhandle, as.character(symbol) ) +} + +rdcCall <- function (funcptr, signature, ...) +{ + .Call("rdcCall", funcptr, signature, list(...) ) +} + +rdcPath <- function (addpath) +{ + path <- Sys.getenv("PATH") + path <- paste(addpath,path,sep=.Platform$path.sep) + Sys.setenv(PATH=path) +} + +rdcUnpath <- function(delpath) +{ + path <- Sys.getenv("PATH") + path <- sub( paste(delpath,.Platform$path.sep,sep=""), "", path ) + Sys.setenv(PATH=path) +} + +rdcShowPath <- function() +{ + Sys.getenv("PATH") +} + +rdcUnpack1 <- function(ptr, offset, sigchar) +{ + .Call("rdcUnpack1", ptr, as.integer(offset), as.character(sigchar) ) +} + +rdcDataPtr <- function(data, offset=0L) +{ + .Call("rdcDataPtr", data, as.integer(offset) ) +} + +cleanup <- function() +{ + unloadNamespace("rdc") +} + +.sizes <- c( + logical=4L, + integer=4L, + double=8L, + complex=16L, + character=1L, + raw=1L, + externalptr=.Machine$sizeof.pointer +) + +rdcSizeOf <- function(x) +{ + .sizes[[ as.character(x) ]] +} + +DC_CALL_C_DEFAULT = 0 +DC_CALL_C_X86_CDECL = 1 +DC_CALL_C_X86_WIN32_STD = 2 +DC_CALL_C_X86_WIN32_FAST_MS = 3 +DC_CALL_C_X86_WIN32_FAST_GNU = 4 +DC_CALL_C_X86_WIN32_THIS_MS = 5 +DC_CALL_C_X86_WIN32_THIS_GNU = 6 +DC_CALL_C_X64_WIN64 = 7 +DC_CALL_C_X64_SYSV = 8 +DC_CALL_C_PPC32_DARWIN = 9 +DC_CALL_C_PPC32_OSX = 9 +DC_CALL_C_ARM_ARM =10 +DC_CALL_C_ARM_THUMB =11 +DC_CALL_C_MIPS32_EABI =12 +DC_CALL_C_MIPS32_PSPSDK =12 +DC_CALL_C_PPC32_SYSV =13 +DC_CALL_C_PPC32_LINUX =13 + +rdcMode <- function (mode) +{ + .Call("rdcMode", as.integer(mode), PACKAGE="rdc" ) +} + +dcFree <- function(callvm) +{ + .Call("dcFree", callvm, PACKAGE="rdc") +} + +dcNewCallVM <- function(size=1024L) +{ + x <- .Call("dcNewCallVM", as.integer(size), PACKAGE="rdc") + reg.finalizer(x, dcFree) + class(x) <- "dyncallvm" + return(x) +} + +dcMode <- function(callvm, mode) +{ + .Call("dcMode", callvm, as.integer(mode) ) +} + +dcCall <- function(callvm, funcptr, signature, ...) +{ + .Call("dcCall", callvm, funcptr, signature, list(...) ) +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/R/bind.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,22 @@ +# +# bind library by import string +# + +eatws <- function(x) gsub("[ \n\t]*","",x) + +bind1 <- function(symbol, signature, libh, callvm, envir=parent.frame() ) +{ + funcptr <- rdcFind(libh, symbol) + f <- function(...) NULL + body(f) <- substitute( dcCall( callvm, funcptr, signature, ... ), list(funcptr=funcptr, signature=signature) ) + assign( symbol, f, envir=envir ) +} + +rdcBind <- function(libname, sigs, callvm, envir=parent.frame() ) +{ + libh <- rdcLoad(libname) + sigs <- eatws(sigs) + sigs <- strsplit(sigs, ";")[[1]] + sigs <- strsplit(sigs, "\\(") + for (i in seq(along=sigs)) bind1(sigs[[i]][[1]], sigs[[i]][[2]], libh, callvm, envir ) +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/README.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,42 @@ +rdc package: dyncall R bindings +=============================== +(C) 2007-2009 Daniel Adler + + +Requirement +- dyncall >=0.1 (url: http://dyncall.org) + + +Status + unreleased + + +Building from source + + + 1. Check out source + + > svn checkout https://dyncall.org/svn/dyncall/trunk/bindings/R/rdc rdc + + + 2. Bootstrap dyncall source + + * Method A: download zip file method: + + > cd rdc + > sh bootstrap + > cd .. + + * Method B: checkout dyncall + + > svn checkout https://dyncall.org/svn/dyncall/trunk/dyncall rdc/src/dyncall + + * Method C: place dyncall source tree rooted at rdc/src/dyncall + + > cp -R /tmp/dyncall-0.3 rdc/src/dyncall + + + 3. Build R package from source + + > R CMD INSTALL rdc +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/bootstrap Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,15 @@ +download_zip() +{ + wget http://dyncall.org/r0.3/dyncall-0.3.zip + unzip dyncall-0.3 + mv dyncall-0.3 src/dyncall + rm -Rf dyncall-0.3.zip +} + +checkout_src() +{ + svn co http://dyncall.org/svn/dyncall/trunk/dyncall src/dyncall +} + +download_zip +# checkout_src
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/chm/00Index.html Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,36 @@ +<html><head><title>R bindings for dyncall library</title> +<link rel="stylesheet" type="text/css" href="Rchm.css"> +</head><body> +<h1>R bindings for dyncall library +<img class="toplogo" src="logo.jpg" alt="[R logo]"></h1> + +<hr> + +<object type="application/x-oleobject" classid="clsid:1e2a7bd0-dab9-11d0-b93a-00c04fc99f9e"> +<param name="keyword" value=".. contents"> +</object> + +<h2>Help pages for package ‘rdc’ version 0.1</h2> + + +<table width="100%"> +<tr><td width="25%"><a href="rdc.html">rdcCall</a></td> +<td>invoke dynamic calls to foreign code</td></tr> +<tr><td width="25%"><a href="rdc.html">rdcDataPtr</a></td> +<td>invoke dynamic calls to foreign code</td></tr> +<tr><td width="25%"><a href="rdc.html">rdcFind</a></td> +<td>invoke dynamic calls to foreign code</td></tr> +<tr><td width="25%"><a href="rdc.html">rdcFree</a></td> +<td>invoke dynamic calls to foreign code</td></tr> +<tr><td width="25%"><a href="rdc.html">rdcLoad</a></td> +<td>invoke dynamic calls to foreign code</td></tr> +<tr><td width="25%"><a href="rdc.html">rdcPath</a></td> +<td>invoke dynamic calls to foreign code</td></tr> +<tr><td width="25%"><a href="rdc.html">rdcShowPath</a></td> +<td>invoke dynamic calls to foreign code</td></tr> +<tr><td width="25%"><a href="rdc.html">rdcUnpack1</a></td> +<td>invoke dynamic calls to foreign code</td></tr> +<tr><td width="25%"><a href="rdc.html">rdcUnpath</a></td> +<td>invoke dynamic calls to foreign code</td></tr> +</table> +</body></html>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/cleanup Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,2 @@ +make -C src/dyncall clean +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/cleanup.win Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,3 @@ +make -C src/dyncall clean + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/configure Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,7 @@ +#!/bin/sh +# rdc package +# coonfigure script (unix style) +# (C) 2009 Daniel Adler +cd src/dyncall +sh ./configure --prefix=\$\(TOP\) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/configure.ac Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,8 @@ +AC_INIT([rdc], 0.1) +DC_PREFIX=/usr/local +AC_ARG_WITH([dc-prefix], AC_HELP_STRING([--with-dc-prefix=/usr/local],[specify dyncall installation prefix, (/usr/local)]), + [DC_PREFIX=$withval]) +AC_SUBST(DC_PREFIX) +AC_CONFIG_FILES([src/Makevars]) +AC_OUTPUT +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/configure.win Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,7 @@ +#!/bin/sh +# rdc package +# coonfigure script (for windows) +# (C) 2009 Daniel Adler +cd src/dyncall +sh ./configure --target-x86 --target-windows --tool-gcc --prefix=\$\(TOP\) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/demo/00Index Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,5 @@ +win32 demonstrates a win32 message box +darwin demonstrates a darwin specific example +w32PlaySound PlaySound on Win32 using dyn.load facility +linux demonstrates a linux specific example +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/demo/darwin.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,4 @@ +l <- rdcLoad("libc.dylib") +f <- rdcFind(l,"sqrt") +rdcCall(f, "d)d", 144) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/demo/linux.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,5 @@ +l <- rdcLoad("libm.so.6") +f <- rdcFind(l,"sqrt") +rdcCall(f, "d)d", 144) + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/demo/malloc.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,27 @@ +# File: rdc/demo/malloc.R +# Description: sample demo to get malloc/free functions + +if( .Platform$OS.type == "windows" ) { + .windir <- paste(Sys.getenv("windir")[[1]],"\\system32\\",sep="") + .libC <- paste(.windir,"msvcrt",sep="") +} else { + sysname <- Sys.info()[["sysname"]] + if (sysname == "Darwin") + { + .libC <- "/usr/lib/libc.dylib" + } else { + .libC <- "/lib/libc.so.6" + } +} + +dyn.load(.libC) + +bind <- function(name, signature) +{ + address <- getNativeSymbolInfo(name)$address + assign(name, function(...) rdcCall(address,signature,...), parent.frame() ) +} + +bind("malloc","i)p") +bind("free","p)v") +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/demo/sdl.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,443 @@ +library(rdc) +# ---------------------------------------------------------------------------- +# Platform specific issues + +if (.Platform$OS.type == "windows") { + OS <- "windows" +} else if ( Sys.info()[["sysname"]] == "Darwin" ) { + OS <- "darwin" +} else { + OS <- "unix" +} + +# ---------------------------------------------------------------------------- +# dynbind environment + +.cdecl <- dcNewCallVM(1024) +.stdcall <- dcNewCallVM(1024) +dcMode(.stdcall, rdc:::DC_CALL_C_X86_WIN32_STD ) + +# ---------------------------------------------------------------------------- +# C memory allocation +.callC <- .cdecl +.callSDL <- .cdecl +.callGL <- .cdecl +.callGLU <- .cdecl +.callR <- .cdecl +if (OS == "windows") { + .libC <- "/windows/system32/msvcrt" + .libSDL <- "/dll/sdl" + .libGL <- "/windows/system32/OPENGL32" + .libGLU <- "/windows/system32/GLU32" + .libR <- "R" + .callGL <- .stdcall +} else if (OS == "darwin") { + .libCocoa <- "/System/Library/Frameworks/Cocoa.framework/Cocoa" + dyn.load(.libCocoa) + .NSApplicationLoad <- getNativeSymbolInfo("NSApplicationLoad")$address + NSApplicationLoad <- function() rdcCall(.NSApplicationLoad, ")B" ) + # dyn.load("rdc") + .newPool <- getNativeSymbolInfo("newPool")$address + .releasePool <- getNativeSymbolInfo("releasePool")$address + releasePool <- function(x) + { + rdcCall( .releasePool, "p)v", x ) + } + newPool <- function() + { + x <- rdcCall( .newPool, ")p" ) + reg.finalizer( x, releasePool ) + return(x) + } + .pool <- newPool() + .libC <- "/usr/lib/libc.dylib" + .libSDL <- "/Library/Framworks/SDL.framework/SDL" + .libGL <- "/System/Library/Frameworks/OpenGL.framework/Libraries/libGL.dylib" + .libGLU <- "/System/Library/Frameworks/OpenGL.framework/Libraries/libGLU.dylib" + .libR <- Sys.getenv("R_HOME") + .libR <- paste(.libR,"/lib/libR.dylib",sep="") +} else { # unix + .libC <- "/lib/libc.so.6" + .libSDL <- "/usr/lib/libSDL.so" + .libGL <- "/usr/lib/libGL.so" + .libGLU <- "/usr/lib/libGLU.so" + .libR <- paste(R.home(),"/lib/libR.so",sep="") +} + +#dyn.load(.libC) +#.malloc <- getNativeSymbolInfo("malloc")$address +#.free <- getNativeSymbolInfo("free")$free +#malloc <- function(size) rdcCall(.malloc, "i)p", as.integer(size) ) +#free <- function(ptr) rdcCall(.free, "p)v", ptr) + +.importsR <- " +R_chk_calloc(ii)p; +R_chk_realloc(ii)p; +R_chk_free(p)v; +" + +rdcBind(.libR,.importsR,.callR) + +malloc <- function(size) R_chk_calloc(as.integer(size),1L) +free <- function(ptr) R_chk_free(ptr) + + +# ---------------------------------------------------------------------------- +# SDL library +dyn.load(.libSDL) + +.SDL_Init <- getNativeSymbolInfo("SDL_Init")$address +.SDL_Quit <- getNativeSymbolInfo("SDL_Quit")$address +.SDL_SetVideoMode <- getNativeSymbolInfo("SDL_SetVideoMode")$address +.SDL_WM_SetCaption <- getNativeSymbolInfo("SDL_WM_SetCaption")$address +.SDL_GL_SwapBuffers <- getNativeSymbolInfo("SDL_GL_SwapBuffers")$address +.SDL_PollEvent <- getNativeSymbolInfo("SDL_PollEvent")$address +.SDL_GetTicks <- getNativeSymbolInfo("SDL_GetTicks")$address +.SDL_Delay <- getNativeSymbolInfo("SDL_Delay")$address +# init flags: +SDL_INIT_TIMER = 0x00000001L +SDL_INIT_AUDIO = 0x00000010L +SDL_INIT_VIDEO = 0x00000020L +SDL_INIT_CDROM = 0x00000100L +SDL_INIT_JOYSTICK = 0x00000200L +SDL_INIT_NOPARACHUTE = 0x00100000L +SDL_INIT_EVENTTHREAD = 0x01000000L +SDL_INIT_EVERYTHING = 0x0000FFFFL +# SDL_Init(flags): +SDL_Init <- function(flags) rdcCall(.SDL_Init, "i)i", as.integer(flags) ) +# SDL_Quit(): +SDL_Quit <- function() rdcCall(.SDL_Quit, ")v" ) +# video flags: +SDL_SWSURFACE = 0x00000000L +SDL_HWSURFACE = 0x00000001L +SDL_ASYNCBLIT = 0x00000004L +SDL_ANYFORMAT = 0x10000000L +SDL_HWPALETTE = 0x20000000L +SDL_DOUBLEBUF = 0x40000000L +SDL_FULLSCREEN = 0x80000000 +SDL_OPENGL = 0x00000002L +SDL_OPENGLBLIT = 0x0000000AL +SDL_RESIZABLE = 0x00000010L +SDL_NOFRAME = 0x00000020L +SDL_HWACCEL = 0x00000100L +SDL_SRCCOLORKEY = 0x00001000L +SDL_RLEACCELOK = 0x00002000L +SDL_RLEACCEL = 0x00004000L +SDL_SRCALPHA = 0x00010000L +SDL_PREALLOC = 0x01000000L +# SDL_SetVideoMode(): +SDL_SetVideoMode <- function(width,height,bpp,flags) rdcCall(.SDL_SetVideoMode,"iiii)p",width,height,bpp,flags) +SDL_WM_SetCaption <- function(title, icon) rdcCall(.SDL_WM_SetCaption,"SS)v",as.character(title), as.character(icon)) +SDL_PollEvent <- function(eventptr) rdcCall(.SDL_PollEvent,"p)i", eventptr) +SDL_GL_SwapBuffers <- function() rdcCall(.SDL_GL_SwapBuffers,")v") +SDL_GetTicks <- function() rdcCall(.SDL_GetTicks,")i") +SDL_Delay <- function(ms) rdcCall(.SDL_Delay,"i)v",ms) + +SDL_NOEVENT = 0 +SDL_ACTIVEEVENT = 1 +SDL_KEYDOWN = 2 +SDL_KEYUP = 3 +SDL_MOUSEMOTION = 4 +SDL_MOUSEBUTTONDOWN = 5 +SDL_MOUSEBUTTONUP = 6 +SDL_JOYAXISMOTION = 7 +SDL_JOYBALLMOTION = 8 +SDL_JOYHATMOTION = 9 +SDL_JOYBUTTONDOWN = 10 +SDL_JOYBUTTONUP = 11 +SDL_QUIT = 12 +SDL_SYSWMEVENT = 13 +SDL_EVENT_RESERVEDA = 14 +SDL_EVENT_RESERVEDB = 15 +SDL_VIDEORESIZE = 16 +SDL_VIDEOEXPOSE = 17 +SDL_EVENT_RESERVED2 = 18 +SDL_EVENT_RESERVED3 = 19 +SDL_EVENT_RESERVED4 = 20 +SDL_EVENT_RESERVED5 = 21 +SDL_EVENT_RESERVED6 = 22 +SDL_EVENT_RESERVED7 = 23 +SDL_USEREVENT = 24 +SDL_NUMEVENTS = 32 + + +SDL_EventType <- function(event) offset(event, 0, "integer", 1) + + + +# ---------------------------------------------------------------------------- +# OpenGL bindings +dyn.load(.libGL) + +.importsGL <- " + glGetError()i; + glClearColor(ffff)v; + glClear(i)v; + glMatrixMode(i)v; + glLoadIdentity()v; + glBegin(i)v; + glEnd()v; + glVertex3d(ddd)v; + glRotated(dddd)v; + glGenLists(i)i; + glNewList(ii)v; + glEnableClientState(i)v; + glVertexPointer(iiip)v; + glColorPointer(iiip)v; + glDrawElements(iiip)v; + glDisableClientState(i)v; + glEndList()v; + glCallList(i)v; +" + +if (OS == "windows") { + .callGL <- .stdcall + .callGLU <- .stdcall +} else { + .callGL <- .cdecl + .callGLU <- .cdecl +} + +# Import OpenGL symbols +rdcBind(.libGL,.importsGL, .callGL) + +GL_FALSE = 0x0L +GL_TRUE = 0x1L + +GL_BYTE = 0x1400L +GL_UNSIGNED_BYTE = 0x1401L +GL_SHORT = 0x1402L +GL_UNSIGNED_SHORT = 0x1403L +GL_INT = 0x1404L +GL_UNSIGNED_INT = 0x1405L +GL_FLOAT = 0x1406L +GL_DOUBLE = 0x140AL +GL_2_BYTES = 0x1407L +GL_3_BYTES = 0x1408L +GL_4_BYTES = 0x1409L + + +GL_COMPILE = 0x1300L +GL_COMPILE_AND_EXECUTE = 0x1301L +GL_LIST_BASE = 0x0B32L +GL_LIST_INDEX = 0x0B33L +GL_LIST_MODE = 0x0B30L + +GL_VERTEX_ARRAY = 0x8074L + GL_NORMAL_ARRAY = 0x8075L + GL_COLOR_ARRAY = 0x8076L + GL_INDEX_ARRAY = 0x8077L + GL_TEXTURE_COORD_ARRAY = 0x8078L + GL_EDGE_FLAG_ARRAY = 0x8079L + GL_VERTEX_ARRAY_SIZE = 0x807AL + GL_VERTEX_ARRAY_TYPE = 0x807BL + GL_VERTEX_ARRAY_STRIDE = 0x807CL + GL_NORMAL_ARRAY_TYPE = 0x807EL + GL_NORMAL_ARRAY_STRIDE = 0x807FL + GL_COLOR_ARRAY_SIZE = 0x8081L + GL_COLOR_ARRAY_TYPE = 0x8082L + GL_COLOR_ARRAY_STRIDE = 0x8083L + GL_INDEX_ARRAY_TYPE = 0x8085L + GL_INDEX_ARRAY_STRIDE = 0x8086L + GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088L + GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089L + GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808AL + GL_EDGE_FLAG_ARRAY_STRIDE = 0x808CL + GL_VERTEX_ARRAY_POINTER = 0x808EL + GL_NORMAL_ARRAY_POINTER = 0x808FL + GL_COLOR_ARRAY_POINTER = 0x8090L + GL_INDEX_ARRAY_POINTER = 0x8091L + GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092L + GL_EDGE_FLAG_ARRAY_POINTER = 0x8093L + GL_V2F = 0x2A20L + GL_V3F = 0x2A21L + GL_C4UB_V2F = 0x2A22L + GL_C4UB_V3F = 0x2A23L + GL_C3F_V3F = 0x2A24L + GL_N3F_V3F = 0x2A25L + GL_C4F_N3F_V3F = 0x2A26L + GL_T2F_V3F = 0x2A27L + GL_T4F_V4F = 0x2A28L + GL_T2F_C4UB_V3F = 0x2A29L + GL_T2F_C3F_V3F = 0x2A2AL + GL_T2F_N3F_V3F = 0x2A2BL + GL_T2F_C4F_N3F_V3F = 0x2A2CL + GL_T4F_C4F_N3F_V4F = 0x2A2DL + + +GL_COLOR_BUFFER_BIT = 0x00004000L + +GL_MODELVIEW = 0x1700L +GL_PROJECTION = 0x1701L +GL_TEXTURE = 0x1702L + +GL_POINTS = 0x0000L +GL_LINES = 0x0001L +GL_LINE_LOOP = 0x0002L +GL_LINE_STRIP = 0x0003L +GL_TRIANGLES = 0x0004L +GL_TRIANGLE_STRIP = 0x0005L +GL_TRIANGLE_FAN = 0x0006L +GL_QUADS = 0x0007L +GL_QUAD_STRIP = 0x0008L +GL_POLYGON = 0x0009L + +# ---------------------------------------------------------------------------- +# OpenGL utility library + +.importsGLU <- " + gluLookAt(ddddddddd)v; + gluPerspective(dddd)v; +" +rdcBind(.libGLU,.importsGLU, .callGLU) + +#dyn.load(.libGLU) +#.gluLookAt <- getNativeSymbolInfo("gluLookAt")$address +#.gluPerspective <- getNativeSymbolInfo("gluPerspective")$address +#luLookAt <- function(eyeX,eyeY,eyeZ,centerX,centerY,centerZ,upX,upY,upZ) +# rdcCall(.gluLookAt,"ddddddddd)v", eyeX,eyeY,eyeZ,centerX,centerY,centerZ,upX,upY,upZ) +#gluPerspective <- function(fovy,aspect,znear,zfar) +# rdcCall(.gluPerspective,"dddd)v",fovy,aspect,znear,zfar) + +# ---------------------------------------------------------------------------- +# demo +init <- function() +{ + if (OS == "darwin") + { + NSApplicationLoad() + } + err <- SDL_Init(SDL_INIT_VIDEO) + if (err != 0) error("SDL_Init failed") + surface <- SDL_SetVideoMode(512,512,32,SDL_DOUBLEBUF+SDL_OPENGL) +} + +makeCubeDisplaylist <- function() +{ + vertices <- c( + -1,-1,-1, + 1,-1,-1, + -1, 1,-1, + 1, 1,-1, + -1,-1, 1, + 1,-1, 1, + -1, 1, 1, + 1, 1, 1 + ) + + colors <- as.raw( col2rgb( rainbow(8) ) ) + + triangleIndices <- as.integer(c( + 0, 2, 1, + 2, 3, 1, + 1, 3, 7, + 1, 7, 5, + 4, 5, 7, + 4, 7, 6, + 6, 2, 0, + 6, 0, 4, + 2, 7, 3, + 2, 6, 7, + 4, 0, 5, + 0, 1, 5 + )) + + glEnableClientState(GL_VERTEX_ARRAY) + glVertexPointer(3, GL_DOUBLE, 0, rdcDataPtr(vertices) ) + + glEnableClientState(GL_COLOR_ARRAY) + glColorPointer(3, GL_UNSIGNED_BYTE, 0, rdcDataPtr(colors) ) + + displaylistId <- glGenLists(1) + glNewList( displaylistId, GL_COMPILE ) + glDrawElements(GL_TRIANGLES, 36L, GL_UNSIGNED_INT, rdcDataPtr(triangleIndices)) + glEndList() + + glDisableClientState(GL_VERTEX_ARRAY) + glDisableClientState(GL_COLOR_ARRAY) + + return(displaylistId) +} +#buffers <- integer(2) +#glGenBuffersARG(length(buffers), rdcDataPtr(buffers)) +#glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffers[[1]] ) +#glBufferDataARB(GL_ARRAY_BUFFER_ARB, rdcSizeOf(typeof(vertices)) * length(vertices) , rdcDataPtr(vertices) ) + + +mainloop <- function() +{ + displaylistId <- makeCubeDisplaylist() + eventobj <- malloc(256) + blink <- 0 + tbase <- SDL_GetTicks() + quit <- FALSE + while(!quit) + { + tnow <- SDL_GetTicks() + tdemo <- ( tnow - tbase ) / 1000 + + glClearColor(0,0,blink,0) + glClear(GL_COLOR_BUFFER_BIT) + + glMatrixMode(GL_PROJECTION) + glLoadIdentity() + aspect <- 512/512 + gluPerspective(60, aspect, 3, 1000) + + glMatrixMode(GL_MODELVIEW) + glLoadIdentity() + gluLookAt(0,0,5,0,0,0,0,1,0) + glRotated(sin(tdemo)*60.0, 0, 1, 0); + glRotated(cos(tdemo)*90.0, 1, 0, 0); + + glCallList(displaylistId) + + #glBegin(GL_TRIANGLES) + #glVertex3d(-1,-1,-1) + #glVertex3d( 1,-1,-1) + #glVertex3d( 1, 1,-1) + #glVertex3d(-1,-1,-1) + #glVertex3d( 1, 1,-1) + #glVertex3d(-1, 1,-1) + #glEnd() + + SDL_GL_SwapBuffers() + + SDL_WM_SetCaption(paste("time:", tdemo),0) + blink <- blink + 0.01 + while (blink > 1) blink <- blink - 1 + while( SDL_PollEvent(eventobj) != 0 ) + { + eventType <- rdcUnpack1(eventobj, 0L, "c") + if (eventType == SDL_QUIT) + quit <- TRUE + else if (eventType == SDL_MOUSEBUTTONDOWN) + { + button <- rdcUnpack1(eventobj, 1L, "c") + cat("button down: ",button,"\n") + } + } + glerr <- glGetError() + if (glerr != 0) + { + cat("GL Error:", glerr) + quit <- 1 + } + SDL_Delay(30) + } + free(eventobj) + #glDeleteLists(displaylistId, 1) +} + +cleanup <- function() +{ + SDL_Quit() +} + +run <- function() +{ + init() + mainloop() +} +# run() +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/demo/sqrt.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,14 @@ +# File: rdc/demo/sqrt.R +# Description: call sqrt + +if (.Platform$OS.type == "unix") { + dyn.load("/lib/libc.so.6") +} else { + dyn.load("/windows/system32/msvcrt") +} + +sym.sqrt <- getNativeSymbolInfo("sqrt") + +x <- 144.0 +rdcCall( sym.sqrt$address, "d)d", x) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/demo/stdio.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,83 @@ +if (.Platform$OS.type == "windows") { + .libC <- "/windows/system32/msvcrt" +} else if ( Sys.info()[["sysname"]] == "Darwin" ) { + .libC <- "/usr/lib/libc.dylib" +} else { + .libC <- "/lib/libc.so.6" +} + +.libC <- rdcLoad(.libC) +.fopen <- rdcFind(.libC, "fopen") +.fwrite <- rdcFind(.libC, "fwrite") +.fread <- rdcFind(.libC, "fread") +.fclose <- rdcFind(.libC, "fclose") +.fprintf <- rdcFind(.libC, "fprintf") + +fopen <- function(name, mode) + rdcCall(.fopen, "SS)p",name,mode) +fread <- function(buf, size, count, fp) + rdcCall(.fread,"piip)i", buf, size, count, fp) +fwrite <- function(buf, size, count, fp) + rdcCall(.fwrite, "piip)i", buf, size, count, fp) +fclose <- function(fp) + rdcCall(.fclose, "p)i", fp) + + + +do.write <- function(filename, x) +{ + fh <- fopen(filename, "wb") + error <- FALSE + offset <- 0L + size <- rdcSizeOf("double") + count <- length(x) + while( count > 0 && !error ) + { + nwritten <- fwrite( rdcDataPtr(x,offset), size, count, fh ) + if (nwritten < 0) + { + error <- TRUE + } + else + { + count <- count - nwritten + offset <- offset + nwritten * size + } + } + fclose(fh) + if (error) + stop("fwrite error") +} + +do.read <- function(filename, x) +{ + fh <- fopen(filename, "rb") + error <- FALSE + offset <- 0L + size <- rdcSizeOf("double") + count <- length(x) + while (size > 0 && !error ) + { + nread <- fread( rdcDataPtr(x,offset), size, count, fh ) + if (nread < 0) + { + error <- TRUE + } + else + { + size <- size - nread + offset <- offset + nread * size + } + } + fclose(fh) + if (error) + stop("fread error") +} + +filename <- tempfile() +x <- rnorm(1000) +do.write(filename, x) +y <- numeric(1000) +do.read(filename,y) +identical(x,y) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/demo/w32PlaySound.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,8 @@ +# example: play sound + +lib.winmm <- dyn.load("\\windows\\system32\\winmm.dll") +PlaySoundA <- lib.winmm$PlaySoundA +playsound <- function(path) rdcCall(PlaySoundA$address,"pii)v",path,0,0) +sample <- "c:\\windows\\Media\\tada.wav" +playsound(sample) + \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/demo/win32.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,7 @@ +# example: message box on windows + +h <- rdcLoad("user32") +f <- rdcFind(h,"MessageBoxA") +rdcCall(f,"ippi)v",0,"hallo","welt",0) +rdcFree(h) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/man/rdc.Rd Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,111 @@ +\name{rdc} +\alias{rdcLoad} +\alias{rdcFree} +\alias{rdcFind} +\alias{rdcCall} +\alias{rdcPath} +\alias{rdcUnpath} +\alias{rdcShowPath} +\alias{rdcUnpack1} +\alias{rdcDataPtr} +\title{invoke dynamic calls to foreign code} +\description{ +Invoke foreign function calls with support for loading modules and resolving symbols. +} +\usage{ +libhandle <- rdcLoad(libpath) +rdcFree(libhandle) +funcptr <- rdcFind(libhandle, symbol) +result <- rdcCall(funcptr, signature, ...) +rdcPath(addpath) +rdcUnpath(delpath) +rdcShowPath() +rdcUnpack1(object, offset, sigchar) +rdcDataPtr(object, offset = 0) +} + +\arguments{ + \item{libpath}{a file path to dynamic linked library(DLL).} + \item{libhandle}{an external pointer representing an operating-system specific handle to an opened DLL.} + \item{symbol}{a character string, specifying a function name symbol in a DLL.} + \item{funcptr}{an external pointer representing a pointer to function resolved by a symbol} + \item{signature}{a character string specifying the argument and return type of a function call, see Details below for more information.} + \item{addpath,delpath}{a directory path from where dynamic linked libraries should be loaded.} + \item{object}{An atomic object (scalar, vector, matrix or array).} + \item{offset}{An integer specifying an offset from the start of the linear data memory in bytes.} +} + +\details{ +The rdc package provides tools to establish flexible function calls to low-level precompiled code. +It is more flexible than \code{\link{.C}} and has the same type-unsafety dangers. +One can make arbitrary C (and C++ member-) function calls. +The language binding was designed to help write glue code to low-level C libraries in R (if the target library function is compatible with +the supported typeset and calling convention). +It makes use of signature strings to specify +the function prototyp to call. +to providing a thin binding layer between the core +dyncall library and the R programming language. + +The loading and unloading of code modules (*.DLL files on windows, *.dylib files on darwin and *.so files on other *nix flavour OSs) +is done using rdcLoad, similar to \code{\link{dyn.load}}. While \code{\link{dyn.load}} loads a DLL to the R run-time process, +rdcLoad returns the module handle as an external pointer. + +Symbol lookup is done using \code{rdcFind} and returns an external pointer pointing to the foreign function. + +The \code{rdcCall} function does invoke the function call. +It requires the \code{signature} character string argument, which consists of a series of type codes (given as ordinary characters) to +specify the argument types and the expected return type of the foreign function call which are separated by an ')' character. + +\deqn{sigchar_{arg_0} sigchar_{arg_1} \ldots ')' sigchar_{return}}{<sigchar-arg0> <sigchar-arg1> \ldots ')' <sigchar-return>} + +A signature character encodes the C type at the given argument position or return-type. + +\tabular{cll}{ +Signature char \tab C type \tab accepted R data types\cr +\sQuote{B} \tab \code{bool} \tab coerced to logical vector, first item\cr +\sQuote{c} \tab \code{char} \tab not yet implemented\cr +\sQuote{s} \tab \code{short} \tab not yet implemented\cr +\sQuote{i} \tab \code{int} \tab coerced to integer vector, first item\cr +\sQuote{l} \tab \code{long} \tab not yet implemented\cr +\sQuote{f} \tab \code{float} \tab coerced to numeric, first item casted to float\cr +\sQuote{d} \tab \code{double} \tab coerced to numeric, first item\cr +\sQuote{L} \tab \code{long long} \tab coerced to numeric, first item casted to long long\cr +\sQuote{p} \tab \code{void*} \tab external pointer or coerced to string vector, first item\cr +\sQuote{S} \tab \code{char*} \tab coerced to string vector, first item\cr +\sQuote{v} \tab \code{void} \tab no return type\cr +} + +The order of the arguments is left-to-right according to the C prototyp function declaration. E.g. + +e.g. the signature string of the function \samp{double foobar(int a, long long b, float c);} is \code{"iLf)d"}. + +} +\examples{ + +# load platform-specific standard C DLL + +clibname <- "libc" +if (.Platform$OS.type == "windows") clibname <- "msvcrt" +if (.Platform$OS.type == "darwin") clibname <- "libc.dylib" + +clib <- rdcLoad(clibname) + +# call sqrt function + +sqrt.fp <- rdcFind(clib,"sqrt") +print( rdcCall(sqrt.fp, "d)d", 144) ) + +} +\references{ + Adler, D., Philipp, T. (2008) \emph{Dyncall Library}. + \url{http://dyncall.org} +} +\author { + Daniel Adler \email{dadler@uni-goettingen} +} +\examples { + # bla + +} +\keyword{programming::interface} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/src/Makevars Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,7 @@ +DC_PREFIX=dyncall +PKG_CPPFLAGS=-I$(DC_PREFIX)/include +PKG_LIBS=-L$(DC_PREFIX)/lib -ldyncall_s -ldynload_s +default: dyncall-install $(SHLIB) +dyncall-install: + make -C dyncall install +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/src/Makevars.in Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,3 @@ +PKG_CPPFLAGS=-I@DC_PREFIX@/include +PKG_LIBS=-L@DC_PREFIX@/lib -ldyncall_s -ldynload_s +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/src/Makevars.win Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,7 @@ +DC_PREFIX=dyncall +PKG_CPPFLAGS=-I$(DC_PREFIX)/include +PKG_LIBS=-L$(DC_PREFIX)/lib -ldyncall_s -ldynload_s +before: dyncall-install +dyncall-install: + make -C dyncall install +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/src/api.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,505 @@ +#include <R.h> +#define USE_RINTERNALS +#include <Rinternals.h> +#include <R_ext/Rdynload.h> +#include "dynload.h" +#include "dyncall.h" +#include "dyncall_signature.h" + + +/* rdcLoad */ + +SEXP rdcLoad(SEXP sLibPath) +{ + void* libHandle; + const char* libPath; + SEXP r; + libPath = CHAR(STRING_ELT(sLibPath,0)); + + libHandle = dlLoadLibrary(libPath); + + if (!libHandle) { + error("rdcLoad failed on path %s", libPath ); + } + + r = R_NilValue; + + PROTECT( r = R_MakeExternalPtr(libHandle, R_NilValue, R_NilValue) ); + UNPROTECT(1); + + return r; +} + +/* rdcFree */ + +SEXP rdcFree(SEXP sLibHandle) +{ + void* libHandle; + + libHandle = R_ExternalPtrAddr(sLibHandle); + dlFreeLibrary( libHandle ); + + R_SetExternalPtrAddr(sLibHandle, 0); + return R_NilValue; +} + +/* rdcFind */ + +SEXP rdcFind(SEXP sLibHandle, SEXP sSymbol) +{ + void* libHandle; + const char* symbol; + void* addr; + SEXP r; + libHandle = R_ExternalPtrAddr(sLibHandle); + symbol = CHAR(STRING_ELT(sSymbol,0) ); + addr = dlFindSymbol( libHandle, symbol ); + + r = R_NilValue; + + PROTECT( r = R_MakeExternalPtr(addr, R_NilValue, R_NilValue) ); + UNPROTECT(1); + + return r; +} + +SEXP r_dcCall(SEXP sCallVM, SEXP sFuncPtr, SEXP sSignature, SEXP sArgs) +{ + DCCallVM* pvm; + void* funcPtr; + const char* signature; + const char* ptr; + int i,l,protect_count; + SEXP r; + + pvm = R_ExternalPtrAddr(sCallVM); + if (!pvm) error("callvm is null"); + + funcPtr = R_ExternalPtrAddr(sFuncPtr); + if (!funcPtr) error("funcptr is null"); + + signature = CHAR(STRING_ELT(sSignature,0) ); + if (!signature) error("signature is null"); + + dcReset(pvm); + ptr = signature; + + l = LENGTH(sArgs); + i = 0; + protect_count = 0; + for(;;) { + char ch = *ptr++; + SEXP arg; + + if (ch == '\0') error("invalid signature - no return type specified"); + + if (ch == ')') break; + + if (i >= l) error("not enough arguments for given signature (arg length = %d %d %c)", l,i,ch ); + + arg = VECTOR_ELT(sArgs,i); + switch(ch) { + case DC_SIGCHAR_BOOL: + { + DCbool value; + if ( isLogical(arg) ) + { + value = ( LOGICAL(arg)[0] == 0 ) ? DC_FALSE : DC_TRUE; + } + else + { + value = LOGICAL( coerceVector(arg, LGLSXP) )[0] ? DC_FALSE : DC_TRUE; + } + dcArgBool(pvm, value ); + break; + } + case DC_SIGCHAR_INT: + { + int value; + if ( isInteger(arg) ) + { + value = INTEGER(arg)[0]; + } + else + { + value = INTEGER( coerceVector(arg, INTSXP) )[0]; + } + dcArgInt(pvm, value); + break; + } + case DC_SIGCHAR_FLOAT: + { + dcArgFloat( pvm, (float) REAL( coerceVector(arg, REALSXP) )[0] ); + break; + } + case DC_SIGCHAR_DOUBLE: + { + double value; + if ( isReal(arg) ) + { + value = REAL(arg)[0]; + } + else + { + value = REAL( coerceVector(arg,REALSXP) )[0]; + } + dcArgDouble( pvm, value ); + break; + } + /* + case DC_SIGCHAR_LONG: + { + PROTECT(arg = coerceVector(arg, REALSXP) ); + dcArgLong( pvm, (DClong) ( REAL(arg)[0] ) ); + UNPROTECT(1); + break; + } + */ + case DC_SIGCHAR_STRING: + { + DCpointer ptr; + if (arg == R_NilValue) ptr = (DCpointer) 0; + else if (isString(arg)) ptr = (DCpointer) CHAR( STRING_ELT(arg,0) ); + else { + if (protect_count) UNPROTECT(protect_count); + error("invalid value for C string argument"); break; + } + } + case DC_SIGCHAR_POINTER: + { + DCpointer ptr; + if ( arg == R_NilValue ) ptr = (DCpointer) 0; + else if (isString(arg) ) ptr = (DCpointer) CHAR( STRING_ELT(arg,0) ); + else if (isReal(arg) ) ptr = (DCpointer) REAL(arg); + else if (isInteger(arg) ) ptr = (DCpointer) INTEGER(arg); + else if (isLogical(arg) ) ptr = (DCpointer) LOGICAL(arg); + else if (TYPEOF(arg) == EXTPTRSXP) ptr = R_ExternalPtrAddr(arg); + else { + if (protect_count) UNPROTECT(protect_count); + error("invalid signature"); break; + } + dcArgPointer(pvm, ptr); + break; + } + } + ++i; + } + + if ( i != l ) + { + if (protect_count) + UNPROTECT(protect_count); + error ("signature claims to have %d arguments while %d arguments are given", i, l); + } + + switch(*ptr) { + case DC_SIGCHAR_BOOL: + PROTECT( r = allocVector(LGLSXP, 1) ); protect_count++; + LOGICAL(r)[0] = ( dcCallBool(pvm, funcPtr) == DC_FALSE ) ? FALSE : TRUE; + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_CHAR: + PROTECT( r = allocVector(INTSXP, 1) ); protect_count++; + INTEGER(r)[0] = dcCallChar(pvm, funcPtr); + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_SHORT: + PROTECT( r = allocVector(INTSXP, 1) ); protect_count++; + INTEGER(r)[0] = dcCallShort(pvm, funcPtr); + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_LONG: + PROTECT( r = allocVector(INTSXP, 1) ); protect_count++; + INTEGER(r)[0] = dcCallLong(pvm, funcPtr); + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_INT: + PROTECT( r = allocVector(INTSXP, 1) ); protect_count++; + INTEGER(r)[0] = dcCallInt(pvm, funcPtr); + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_LONGLONG: + PROTECT( r = allocVector(REALSXP, 1) ); protect_count++; + REAL(r)[0] = (double) ( dcCallLong(pvm, funcPtr) ); + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_FLOAT: + PROTECT( r = allocVector(REALSXP, 1) ); protect_count++; + REAL(r)[0] = (double) ( dcCallFloat(pvm, funcPtr) ); + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_DOUBLE: + PROTECT( r = allocVector(REALSXP, 1) ); + protect_count++; + REAL(r)[0] = dcCallDouble(pvm, funcPtr); + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_POINTER: + PROTECT( r = R_MakeExternalPtr( dcCallPointer(pvm,funcPtr), R_NilValue, R_NilValue ) ); + protect_count++; + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_VOID: + dcCallVoid(pvm,funcPtr); + if (protect_count) UNPROTECT(protect_count); + break; + default: + { + if (protect_count) + UNPROTECT(protect_count); + error("invalid return type signature"); + } + break; + } + return R_NilValue; + +} + +/* rdcCall */ + +DCCallVM* gCall; + +SEXP rdcCall(SEXP sFuncPtr, SEXP sSignature, SEXP sArgs) +{ + void* funcPtr; + const char* signature; + const char* ptr; + int i,l,protect_count; + SEXP r; + + funcPtr = R_ExternalPtrAddr(sFuncPtr); + + if (!funcPtr) error("funcptr is null"); + + signature = CHAR(STRING_ELT(sSignature,0) ); + + if (!signature) error("signature is null"); + + dcReset(gCall); + ptr = signature; + + l = LENGTH(sArgs); + i = 0; + protect_count = 0; + for(;;) { + char ch = *ptr++; + SEXP arg; + + if (ch == '\0') error("invalid signature - no return type specified"); + + if (ch == ')') break; + + if (i >= l) error("not enough arguments for given signature (arg length = %d %d %c)", l,i,ch ); + + arg = VECTOR_ELT(sArgs,i); + switch(ch) { + case DC_SIGCHAR_BOOL: + { + if ( !isLogical(arg) ) + { + PROTECT(arg = coerceVector(arg, LGLSXP)); + protect_count++; + } + dcArgBool(gCall, ( LOGICAL(arg)[0] == 0 ) ? DC_FALSE : DC_TRUE ); + // UNPROTECT(1); + break; + } + case DC_SIGCHAR_INT: + { + if ( !isInteger(arg) ) + { + PROTECT(arg = coerceVector(arg, INTSXP)); + protect_count++; + } + dcArgInt(gCall, INTEGER(arg)[0]); + // UNPROTECT(1); + break; + } + case DC_SIGCHAR_FLOAT: + { + PROTECT(arg = coerceVector(arg, REALSXP) ); + dcArgFloat( gCall, REAL(arg)[0] ); + UNPROTECT(1); + break; + } + case DC_SIGCHAR_DOUBLE: + { + if ( !isReal(arg) ) + { + PROTECT(arg = coerceVector(arg, REALSXP) ); + protect_count++; + } + dcArgDouble( gCall, REAL(arg)[0] ); + // UNPROTECT(1); + break; + } + /* + case DC_SIGCHAR_LONG: + { + PROTECT(arg = coerceVector(arg, REALSXP) ); + dcArgLong( gCall, (DClong) ( REAL(arg)[0] ) ); + UNPROTECT(1); + break; + } + */ + case DC_SIGCHAR_STRING: + { + DCpointer ptr; + if (arg == R_NilValue) ptr = (DCpointer) 0; + else if (isString(arg)) ptr = (DCpointer) CHAR( STRING_ELT(arg,0) ); + else { + if (protect_count) UNPROTECT(protect_count); + error("invalid value for C string argument"); break; + } + } + case DC_SIGCHAR_POINTER: + { + DCpointer ptr; + if ( arg == R_NilValue ) ptr = (DCpointer) 0; + else if (isString(arg) ) ptr = (DCpointer) CHAR( STRING_ELT(arg,0) ); + else if (isReal(arg) ) ptr = (DCpointer) REAL(arg); + else if (isInteger(arg) ) ptr = (DCpointer) INTEGER(arg); + else if (isLogical(arg) ) ptr = (DCpointer) LOGICAL(arg); + else if (TYPEOF(arg) == EXTPTRSXP) ptr = R_ExternalPtrAddr(arg); + else { + if (protect_count) UNPROTECT(protect_count); + error("invalid signature"); break; + } + dcArgPointer(gCall, ptr); + break; + } + } + ++i; + } + + if ( i != l ) + { + if (protect_count) + UNPROTECT(protect_count); + error ("signature claims to have %d arguments while %d arguments are given", i, l); + } + + switch(*ptr) { + case DC_SIGCHAR_BOOL: + PROTECT( r = allocVector(LGLSXP, 1) ); protect_count++; + LOGICAL(r)[0] = ( dcCallBool(gCall, funcPtr) == DC_FALSE ) ? FALSE : TRUE; + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_INT: + PROTECT( r = allocVector(INTSXP, 1) ); protect_count++; + INTEGER(r)[0] = dcCallInt(gCall, funcPtr); + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_LONG: + PROTECT( r = allocVector(REALSXP, 1) ); protect_count++; + REAL(r)[0] = (double) ( dcCallLong(gCall, funcPtr) ); + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_FLOAT: + PROTECT( r = allocVector(REALSXP, 1) ); protect_count++; + REAL(r)[0] = (double) ( dcCallFloat(gCall, funcPtr) ); + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_DOUBLE: + PROTECT( r = allocVector(REALSXP, 1) ); + protect_count++; + REAL(r)[0] = dcCallDouble(gCall, funcPtr); + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_POINTER: + PROTECT( r = R_MakeExternalPtr( dcCallPointer(gCall,funcPtr), R_NilValue, R_NilValue ) ); + protect_count++; + UNPROTECT(protect_count); + return r; + case DC_SIGCHAR_VOID: + dcCallVoid(gCall,funcPtr); + if (protect_count) UNPROTECT(protect_count); + break; + default: + { + if (protect_count) + UNPROTECT(protect_count); + error("invalid return type signature"); + } + } + return R_NilValue; +} + +SEXP rdcUnpack1(SEXP ptr_x, SEXP offset, SEXP sig_x) +{ + char* ptr = ( (char*) R_ExternalPtrAddr(ptr_x) ) + INTEGER(offset)[0]; + const char* sig = CHAR(STRING_ELT(sig_x,0) ); + switch(sig[0]) + { + case DC_SIGCHAR_CHAR: return ScalarInteger( ( (unsigned char*)ptr)[0] ); + case DC_SIGCHAR_INT: return ScalarInteger( ( (int*)ptr )[0] ); + case DC_SIGCHAR_FLOAT: return ScalarReal( (double) ( (float*) ptr )[0] ); + case DC_SIGCHAR_DOUBLE: return ScalarReal( ((double*)ptr)[0] ); + default: error("invalid signature"); + } + return R_NilValue; +} + +SEXP rdcDataPtr(SEXP x, SEXP offset) +{ + void* ptr = ( ( (unsigned char*) DATAPTR(x) ) + INTEGER(offset)[0] ); + return R_MakeExternalPtr( ptr, R_NilValue, R_NilValue ); +} + +SEXP rdcMode(SEXP id) +{ + dcMode( gCall, INTEGER(id)[0] ); + dcReset( gCall ); + return R_NilValue; +} + +SEXP r_dcNewCallVM(SEXP size) +{ + return R_MakeExternalPtr( dcNewCallVM( INTEGER(size)[0] ), R_NilValue, R_NilValue ); +} + +SEXP r_dcFree(SEXP callvm) +{ + DCCallVM* pvm = R_ExternalPtrAddr(callvm); + dcFree(pvm); + return R_NilValue; +} + +SEXP r_dcMode(SEXP callvm, SEXP id) +{ + DCCallVM* pvm = R_ExternalPtrAddr(callvm); + dcMode( pvm, INTEGER(id)[0] ); + dcReset( pvm ); + return R_NilValue; +} + +/* register R to C calls */ + +R_CallMethodDef callMethods[] = +{ + {"rdcLoad", (DL_FUNC) &rdcLoad, 1}, + {"rdcFree", (DL_FUNC) &rdcFree, 1}, + {"rdcFind", (DL_FUNC) &rdcFind, 2}, + {"rdcCall", (DL_FUNC) &rdcCall, 3}, + {"rdcUnpack1", (DL_FUNC) &rdcUnpack1, 3}, + {"rdcDataPtr", (DL_FUNC) &rdcDataPtr, 2}, + {"rdcMode", (DL_FUNC) &rdcMode, 1}, + + {"dcNewCallVM", (DL_FUNC) &r_dcNewCallVM, 1}, + {"dcFree", (DL_FUNC) &r_dcFree, 1}, + {"dcCall", (DL_FUNC) &r_dcCall, 4}, + {"dcMode", (DL_FUNC) &r_dcMode, 2}, + + {NULL, NULL, 0} +}; + +void R_init_rdc(DllInfo *info) +{ + R_registerRoutines(info, NULL, callMethods, NULL, NULL); + gCall = dcNewCallVM(4096); +} + +void R_unload_rdc(DllInfo *info) +{ +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdc/src/cocoa.m_off Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,15 @@ +#ifdef __APPLE__ +#import <Foundation/NSAutoreleasePool.h> + +NSAutoreleasePool* newPool() +{ + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + return(pool); +} + +void releasePool(NSAutoreleasePool* pool) +{ + [pool release]; +} +#endif +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/BUGS Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,7 @@ +* PowerPC/Mac OS X 10.4: Building Universal Binaries are broken.. in particular + the as for i386 assembler. + Workaround for PowerPC users: install with "--no-multiarch" or use prebuilt + binaries built on OS X >= 10.5. + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/ChangeLog Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,49 @@ +ChangeLog for R Package rdyncall +------------------------------------------------------------------------------- + +0.8 [2014-09-19]: + o reimplemented 'simplified' version of dynfind + o added dynports: pcap + o minor documentation update for SDL installation on Solaris/OpenCSW + o fixes for ARMv7 Thumb-2 ISA and SPARC-v7/v9, x86_64-x64 and mips-o32 ABIs + +0.7.5 [2012-09-12]: + o added: support for new ARM ABI 'armhf' (ARM hardfloat). + Tested on Raspberry Pi (armv6), Efika MX Smartbook (armv7) + o added: NULL is accepted for typed pointer arguments. + o added: support for '*v' (void*) return type signature in .dyncall + o added: support for '**c' and externalptr (to support strptrarray()). + o update: changed 'dynport' containers from R name spaces to environment objects + to get rid of .Internal calls; this removes usage of '::' operators on + dynports - dynports are unloaded via detach(dynport:<PORTNAME>). + o improved finalizer management of callbacks + o added backward compatibility with R 2.10 for leagacy Mac OS X 10.4/PowerPC + R port. + o new dynports: csound, GLUT, glfw, EGL, glpk + o new demos: glpk, gles (partial work) + +0.7.4: [2011-12-13] Minor bugfix and improvements + o update: dyncall support for SPARC 32/64 and SunPro with fixes for SPARC 64-bit + o added: dynport SDL_net + o added: public helper function offsetPtr + o bugfix for R 2.14: Namespace handling, missing 'lazyData' field in Env. + +0.7.3: [2011-07-18] Added vignette, new ports, new tool-chain an fixes for bugs + o bugfix for Fedora/x64: added search path 'lib64' folder for 'dynfind'. + o added support for Sun make, DynCall uses Makefile.embedded. + o added sparc and sparc64 support using gcc tool-chain. + o added support for amd64 using solaris tool-chain. + o added vignette "foreign library interface". + o bugfix for solaris/x64: added search path 'amd64' folder for 'dynfind'. + o bugfix in examples for libm using 'm.so.6' besides 'm' on unix + (needed by debian 6 sid unstable) + +0.7.2: [2011-04-27] Minor fixes + o added win64/mingw64 support. + +0.7.1: [2011-04-26] Minor fixes + o minor Makevars fix for parallel builds. + +0.7.0: [2011-04-20] Initial Release + o first upload to CRAN. +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/DESCRIPTION Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,14 @@ +Package: rdyncall +Version: 0.8.0 +Date: 2014-09-19 +Title: Improved Foreign Function Interface (FFI) and Dynamic Bindings to C Libraries (e.g. OpenGL) +Author: Daniel Adler <dadler@uni-goettingen.de> +Maintainer: Daniel Adler <dadler@uni-goettingen.de> +Depends: R (>= 2.4) +Description: The package provides a cross-platform framework for dynamic binding of C libraries using a flexible Foreign Function Interface (FFI). + The FFI supports almost all fundamental C types, multiple calling conventions, symbolic access to foreign C struct/union data types and wrapping of R functions as C callback function pointers. + Dynamic bindings to shared C libraries are data-driven by cross-platform binding specification using a compact plain text format ; an initial repository of bindings to a couple of common C libraries (OpenGL, SDL, Expat, glew, CUDA, OpenCL, ODE, R) comes with the package. + The package includes a variety of technology demos and OS-specific notes for installation of shared libraries. +License: file LICENSE +URL: http://dyncall.org +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/LICENSE Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,70 @@ +------------------------------------------------------------------------------- +License for rdyncall R Package + +Copyright (c) 2009-2011 Daniel Adler <dadler@uni-goettingen.de>, + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, 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. + +------------------------------------------------------------------------------- +Sub-directory: src/dyncall + +License for DynCall libraries (dynload,dyncall,dyncallback) + +Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>, + Tassilo Philipp <tphilipp@potion-studios.com> + +in addition, dynload has improvements from +Copyright (c) 2007-2011 Olivier Chafik <olivier.chafik@gmail.com> + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, 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. + +------------------------------------------------------------------------------- +File: inst/demo-files/external.xm + +Credits to Quazar of Sanxion for this great tune! + +Downloaded from modarchive.org (module id 66187) +Licensed under the Mod Archive Distrbution license + +Internal text: +- Funky Stars - + +Composed in jan. -96 +by: Quazar of Sanxion + + + +In these days of +1meg/32chnl/16bit- +tunes, we have to +preserve the memory +of the tiny-tunes, +from which we all +come from. + +------------------------------------------------------------------------------- +File : inst/demo-files/nuskool-krome-64x64.png + +Credits to the unknown artist. +Downloaded from a free font pack and available from various other sites as well. +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/NAMESPACE Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,36 @@ +useDynLib(rdyncall) +export( +# --- dyncall.R -------------------------------------------------------------- + .dyncall, + .dyncall.default, + .dyncall.cdecl, + .dyncall.stdcall, + .dyncall.thiscall, .dyncall.thiscall.gcc, .dyncall.thiscall.msvc, + .dyncall.fastcall, .dyncall.fastcall.gcc, .dyncall.fastcall.msvc, +# --- dynload.R -------------------------------------------------------------- + .dynload, .dynunload, .dynsym, +# --- dynfind.R -------------------------------------------------------------- + dynfind, +# --- dynbind.R -------------------------------------------------------------- + dynbind, +# --- dynstruct.R ------------------------------------------------------------ + new.struct, as.struct, + parseStructInfos, parseUnionInfos, +# --- pack.R ----------------------------------------------------------------- + .pack, .unpack, +# --- callback.R ------------------------------------------------------------- + new.callback, +# --- utils.R ---------------------------------------------------------------- + is.nullptr, as.extptr, is.externalptr, offsetPtr, +# --- utils_str.R ------------------------------------------------------------ + ptr2str, strarrayptr, strptr, +# --- utils_float.R ---------------------------------------------------------- + floatraw, as.floatraw, floatraw2numeric, +# --- dynport.R -------------------------------------------------------------- + dynport +) +# --- dynstruct.R ------------------------------------------------------------ +S3method("$<-", struct) +S3method("$", struct) +S3method(print,struct) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/R/callback.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,11 @@ +# Package: rdyncall +# File: R/callback.R +# Description: R Callbacks + +new.callback <- function(signature, fun, envir=new.env()) +{ + stopifnot( is.character(signature) ) + stopifnot( is.function(fun) ) + stopifnot( is.environment(envir) ) + .Call("new_callback", signature, fun, envir, PACKAGE="rdyncall") +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/R/dynbind.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,67 @@ +# Package: rdyncall +# File: R/dynbind.R +# Description: single-entry front-end to dynamic binding of library functions + +dynbind <- function(libnames, signature, envir=parent.frame(), callmode="default", pat=NULL, replace=NULL, funcptr=FALSE) +{ + # load shared library + libh <- dynfind(libnames) + if ( is.null(libh) ) + { + cat("dynbind error: Unable to find shared library '", libnames[[1]], "'.\n",sep="") + cat("For details how to install dynport shared libs, type: ?'rdyncall-demos' might help.\n") + cat("If there is no information about your OS, consult the projects page how to build and install the shared library for your operating-system.\n") + cat("Make sure the shared library can be found at the default system places or adjust environment variables (e.g. %PATH% or $LD_LIBRARY_PATH).\n") + stop("unable to find shared library '", libnames[[1]], "'.\n", call.=FALSE) + } + + # -- convert library signature to signature table + + # eat white spaces + sigtab <- gsub("[ \n\t]*","",signature) + # split functions at ';' + sigtab <- strsplit(sigtab, ";")[[1]] + # split name/call signature at '(' + sigtab <- strsplit(sigtab, "\\(") + + # -- install functions + + # make function call symbol + dyncallfunc <- as.symbol( paste(".dyncall.",callmode, sep="") ) + # report info + syms.failed <- character(0) + + for (i in seq(along=sigtab)) + { + symname <- sigtab[[i]][[1]] + rname <- if (!is.null(pat)) sub(pat, replace, symname) else symname + signature <- sigtab[[i]][[2]] + # lookup symbol + address <- .dynsym( libh, symname ) + + if (!is.null(address)) + { + # make call function f + f <- function(...) NULL + if (funcptr) + { + body(f) <- substitute( dyncallfunc( .unpack(address,0,"p"), signature,...), list(dyncallfunc=dyncallfunc,address=address,signature=signature) ) + } + else + { + body(f) <- substitute( dyncallfunc(address, signature,...), list(dyncallfunc=dyncallfunc,address=address,signature=signature) ) + } + environment(f) <- envir # NEW + # install symbol + assign( rname, f, envir=envir) + } + else + { + syms.failed <- c(syms.failed,symname) + } + } + # return dynbind.report + x <- list(libhandle=libh, unresolved.symbols=syms.failed) + class(x) <- "dynbind.report" + return(x) +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/R/dyncall.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,78 @@ +# Package: rdyncall +# File: R/dyncall.R +# Description: dyncall bindings for R + +# ---------------------------------------------------------------------------- +# call vm alloc/free (internal) + +new.callvm <- function( + callmode = c( + "cdecl", + "stdcall", + "thiscall","thiscall.gcc","thiscall.msvc", + "fastcall","fastcall.gcc","fastcall.msvc") +, size = 4096 ) +{ + callmode <- match.arg(callmode) + x <- .Call("new_callvm", callmode, as.integer(size), PACKAGE="rdyncall") + reg.finalizer(x, free.callvm) + return(x) +} + +free.callvm <- function(x) +{ + .Call("free_callvm", x, PACKAGE="rdyncall") +} + +# ---------------------------------------------------------------------------- +# CallVM's for calling conventions - will be initialized .onLoad + +callvm.default <- callvm.cdecl <- NULL +callvm.stdcall <- NULL +callvm.thiscall <- NULL +callvm.thiscall.gcc <- NULL +callvm.thiscall.msvc <- NULL +callvm.fastcall <- NULL +callvm.fastcall.gcc <- NULL +callvm.fastcall.msvc <- NULL + +# ---------------------------------------------------------------------------- +# public interface + +.dyncall <- function( address, signature, ... , callmode = "default" ) +{ + callvm <- switch(callmode, + default=callvm.default, + cdecl=callvm.cdecl, + stdcall=callvm.stdcall, + thiscall=,thiscall.gcc=callvm.thiscall.gcc, thiscall.msvc=callvm.thiscall.msvc, + fastcall=,fastcall.gcc=callvm.fastcall.gcc, fastcall.msvc=callvm.fastcall.msvc) + .External("dyncall", callvm, address, signature, ..., PACKAGE="rdyncall") +} + +.dyncall.cdecl <- function( address, signature, ... ) .External("dyncall", callvm.cdecl, address, signature, ..., PACKAGE="rdyncall") +.dyncall.default <- function( address, signature, ... ) .External("dyncall", callvm.default, address, signature, ..., PACKAGE="rdyncall") +.dyncall.stdcall <- function( address, signature, ... ) .External("dyncall", callvm.stdcall, address, signature, ..., PACKAGE="rdyncall") +.dyncall.thiscall.gcc <- function( address, signature, ... ) .External("dyncall", callvm.thiscall.gcc, address, signature, ..., PACKAGE="rdyncall") +.dyncall.thiscall.msvc <- function( address, signature, ... ) .External("dyncall", callvm.thiscall.msvc, address, signature, ..., PACKAGE="rdyncall") +.dyncall.fastcall.gcc <- function( address, signature, ... ) .External("dyncall", callvm.fastcall.gcc, address, signature, ..., PACKAGE="rdyncall") +.dyncall.fastcall.msvc <- function( address, signature, ... ) .External("dyncall", callvm.fastcall.msvc, address, signature, ..., PACKAGE="rdyncall") + +.dyncall.thiscall <- .dyncall.thiscall.gcc +.dyncall.fastcall <- .dyncall.fastcall.gcc + +# ---------------------------------------------------------------------------- +# initialize callvm's on load + +.onLoad <- function(libname,pkgname) +{ + callvm.cdecl <<- new.callvm("cdecl") + callvm.default <<- callvm.cdecl + callvm.stdcall <<- new.callvm("stdcall") + callvm.thiscall <<- new.callvm("thiscall") + callvm.thiscall.gcc <<- new.callvm("thiscall.gcc") + callvm.thiscall.msvc <<- new.callvm("thiscall.msvc") + callvm.fastcall <<- new.callvm("fastcall") + callvm.fastcall.gcc <<- new.callvm("fastcall.gcc") + callvm.fastcall.msvc <<- new.callvm("fastcall.msvc") +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/R/dynfind.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,32 @@ + +dynfind1 <- if (.Platform$OS.type == "windows") { + function(name, ...) { + handle <- .dynload(paste("lib",name,sep=""),...) + if (!is.null(handle)) return(handle) + .dynload(name,...) + } +} else { + if ( Sys.info()[["sysname"]] == "Darwin" ) { + function(name, ...) { + handle <- .dynload(paste(name,".framework/",name,sep=""),...) + if (!is.null(handle)) return(handle) + .dynload(paste("lib",name,".dylib",sep=""),...) + } + } else { + function(name, ...) { + handle <- .dynload(paste("lib",name,".so",sep=""),...) + if (!is.null(handle)) return(handle) + handle <- .dynload(paste("lib",name,sep=""),...) + if (!is.null(handle)) return(handle) + .dynload(paste(name,sep=""),...) # needed by Solaris to lookup 'R'. + } + } +} + +dynfind <- function(libnames, auto.unload = TRUE) { + for (libname in libnames) { + handle <- dynfind1(libname, auto.unload) + if (!is.null(handle)) return(handle) + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/R/dynload.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,30 @@ +# Package: rdyncall +# File: R/dyncall.R +# Description: R bindings for dynload library + +.dynload <- function(libname, auto.unload=TRUE) +{ + libname <- as.character(libname) + stopifnot( is.character(libname) ) + + libh <- .Call("dynload", libname, PACKAGE="rdyncall") + if (!is.null(libh)) { + attr(libh, "path") <- libname + attr(libh, "auto.unload") <- auto.unload + if (auto.unload) reg.finalizer(libh, .dynunload) + } + libh +} + +.dynunload <- function(libhandle) +{ + if (!is.externalptr(libhandle)) stop("libhandle argument must be of type 'externalptr'") + .Call("dynunload", libhandle, PACKAGE="rdyncall") +} + +.dynsym <- function(libhandle, symname, protect.lib=TRUE) +{ + if (!is.externalptr(libhandle)) stop("libh argument must be of type 'externalptr'") + .Call("dynsym", libhandle, as.character(symname), as.logical(protect.lib), PACKAGE="rdyncall") +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/R/dynport.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,36 @@ +# Project: rdyncall +# File: R/dynports.R +# Description: repository for multi-platform bindings to binary components. +# Author: Daniel Adler <dadler@uni-goettingen.de> + +dynport <- function(portname, portfile=NULL, repo=system.file("dynports", package="rdyncall")) +{ + # literate portname string + portname <- as.character(substitute(portname)) + if (missing(portfile)) + { + # search for portfile + portfile <- file.path( repo, paste(portname,".R",sep="") ) + if ( !file.exists(portfile) ) portfile <- file.path( repo, paste(portname,".json",sep="") ) + if ( !file.exists(portfile) ) stop("dynport '", portname, "' not found.") + } + loadDynportNamespace(portname, portfile) +} + +loadDynportNamespace <- function(name, portfile, do.attach=TRUE) +{ + name <- as.character(name) + portfile <- as.character(portfile) + if (do.attach) { + envname <- paste("dynport", name, sep=":") + if ( envname %in% search() ) return() + env <- new.env() + sys.source(portfile, envir=env) + attach(env, name=envname) + } else { + env <- new.env() + sys.source(portfile, envir=env) + return(env) + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/R/dynstruct.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,343 @@ +# Package: rdyncall +# File: R/dynstruct.R +# Description: Handling of aggregate (struct/union) C types + +# ---------------------------------------------------------------------------- +# dynport basetype sizes + +.basetypeSizes <- c( + B=.Machine$sizeof.long, + c=1, + C=1, + s=2, + S=2, + i=4, + I=4, + j=.Machine$sizeof.long, + J=.Machine$sizeof.long, + l=.Machine$sizeof.longlong, + L=.Machine$sizeof.longlong, + f=4, + d=8, + p=.Machine$sizeof.pointer, + x=.Machine$sizeof.pointer, + Z=.Machine$sizeof.pointer, + v=0 +) + +# ---------------------------------------------------------------------------- +# dynport type information +# + +TypeInfo <- function(name, type = c("base","pointer","struct","union"), size = NA, align = NA, basetype = NA, fields = NA, signature = NA) +{ + type <- match.arg(type) + x <- list(name = name, type = type, size = size, align = align, basetype = basetype, fields = fields, signature = signature) + class(x) <- "typeinfo" + return(x) +} + +is.TypeInfo <- function(x) +{ + inherits(x, "typeinfo") +} + +getTypeInfo <- function(name, envir=parent.frame()) +{ + if (is.character(name)) { + getTypeInfoByName(name, envir) + } else if (is.TypeInfo(name)) { + name + } else { + stop("unknown type") + } +} + +getTypeInfoByName <- function(typeName, envir=parent.frame()) +{ + char1 <- substr(typeName, 1, 1) + switch(char1, + "*"=TypeInfo(name=typeName, type="pointer", size=.Machine$sizeof.pointer, align=.Machine$sizeof.pointer, basetype=substr(typeName,2,nchar(typeName)), signature=typeName), + "<"={ + x <- getTypeInfo(substr(typeName, 2,nchar(typeName)-1), envir=envir) + if (!is.null(x)) + return(x) + else + return(TypeInfo(name=typeName, type="struct")) + }, + { + # try as basetype + basetypeSize <- unname(.basetypeSizes[typeName]) + if ( !is.na(basetypeSize) ) return(TypeInfo(name=typeName,type="base", size=basetypeSize, align=basetypeSize, signature=typeName)) + # try lookup symbol + else if (exists(typeName,envir=envir) ) { + info <- get(typeName,envir=envir) + if (!inherits(info, "typeinfo")) stop("not a type information symbol") + return(info) + } + # otherwise fail + else NULL + # else stop("unknown type info: ",typeName) + } + ) +} + +# ---------------------------------------------------------------------------- +# align C offsets + +align <- function(offset, alignment) +{ + as.integer( as.integer( (offset + alignment-1) / alignment ) * alignment ) +} + +# ---------------------------------------------------------------------------- +# field information (structures and unions) + +makeFieldInfo <- function(fieldNames, types, offsets) +{ + data.frame(type=I(types), offset=offsets, row.names=fieldNames) +} + +# ---------------------------------------------------------------------------- +# parse structure signature + +makeStructInfo <- function(name, signature, fieldNames, envir=parent.frame()) +{ + # computations: + types <- character() + offsets <- integer() + offset <- 0 + maxAlign <- 1 + # scan variables: + n <- nchar(signature) + i <- 1 + start <- i + while(i <= n) + { + char <- substr(signature,i,i) + if (char == "*") { + i <- i + 1 ; next + } else if (char == "<") { + i <- i + 1 + while (i < n) { + if ( substr(signature,i,i) == ">" ) break + i <- i + 1 + } + } + typeName <- substr(signature, start, i) + types <- c(types, typeName) + typeInfo <- getTypeInfo(typeName, envir=envir) + alignment <- typeInfo$align + maxAlign <- max(maxAlign, alignment) + offset <- align( offset, alignment ) + offsets <- c(offsets, offset) + + # increment offset by size + offset <- offset + typeInfo$size + + # next token + i <- i + 1 + start <- i + } + # align the structure size (compiler-specific?) + size <- align(offset, maxAlign) + # build field information + fields <- makeFieldInfo(fieldNames, types, offsets) + TypeInfo(name=name,type="struct",size=size,align=maxAlign,fields=fields) +} + +parseStructInfos <- function(sigs, envir=parent.frame()) +{ + # split functions at ';' + sigs <- unlist( strsplit(sigs, ";") ) + # split name/struct signature at '(' + sigs <- strsplit(sigs, "[{]") + infos <- list() + for (i in seq(along=sigs)) + { + n <- length(sigs[[i]]) + if ( n == 2 ) { + # parse structure name + name <- sigs[[i]][[1]] + name <- gsub("[ \n\t]*","",name) + # split struct signature and field names + tail <- unlist( strsplit(sigs[[i]][[2]], "[}]") ) + sig <- tail[[1]] + if (length(tail) == 2) + fields <- unlist( strsplit( tail[[2]], "[ \n\t]+" ) ) + else + fields <- NULL + assign(name, makeStructInfo(name, sig, fields, envir=envir), envir=envir) + } + } +} + +# ---------------------------------------------------------------------------- +# parse union signature + +makeUnionInfo <- function(name, signature, fieldNames, envir=parent.frame()) +{ + # computations: + types <- character() + maxSize <- 0 + maxAlign <- 1 + # scan variables: + i <- 1 + start <- i + n <- nchar(signature) + while(i <= n) { + char <- substr(signature,i,i) + if (char == "*") { + i <- i + 1 ; next + } else if (char == "<") { + i <- i + 1 + while (i < n) { + if ( substr(signature,i,i) == ">" ) break + i <- i + 1 + } + } + typeName <- substr(signature,start,i) + types <- c(types, typeName) + typeInfo <- getTypeInfo(typeName, envir) + maxSize <- max( maxSize, typeInfo$size ) + maxAlign <- max( maxAlign, typeInfo$align ) + # next token + i <- i + 1 + start <- i + } + offsets <- rep(0, length(types) ) + fields <- makeFieldInfo(fieldNames, types, offsets) + TypeInfo(name=name, type="union", fields=fields, size=maxSize, align=maxAlign) +} + +parseUnionInfos <- function(sigs, envir=parent.frame()) +{ + # split functions at ';' + sigs <- unlist( strsplit(sigs, ";") ) + # split name/union signature at '|' + sigs <- strsplit(sigs, "[|]") + infos <- list() + for (i in seq(along=sigs)) + { + n <- length(sigs[[i]]) + if ( n == 2 ) { + # parse union name + name <- sigs[[i]][[1]] + name <- gsub("[ \n\t]*","",name) + # split union signature and field names + tail <- unlist( strsplit(sigs[[i]][[2]], "[}]") ) + sig <- tail[[1]] + if (length(tail) == 2) + fields <- unlist( strsplit( tail[[2]], "[ \n\t]+" ) ) + else + fields <- NULL + assign( name, makeUnionInfo(name, sig, fields, envir=envir), envir=envir ) + } + } +} + + +# ---------------------------------------------------------------------------- +# raw backed struct's (S3 Class) + +as.struct <- function(x, type) +{ + if (is.TypeInfo(x)) structName <- type$name + attr(x, "struct") <- type + class(x) <- "struct" + return(x) +} + +new.struct <- function(type) +{ + if (is.character(type)) { + name <- type + type <- getTypeInfo(type) + } else if (is.TypeInfo(type)) { + name <- type$name + } else { + stop("type is not of class TypeInfo and no character string") + } + if (! type$type %in% c("struct","union") ) stop("type must be C struct or union.") + x <- raw( type$size ) + class(x) <- "struct" + attr(x, "struct") <- type$name + return(x) +} + +"$.struct" <- +unpack.struct <- function(x, index) +{ + structName <- attr(x, "struct") + structInfo <- getTypeInfo(structName) + fieldInfos <- structInfo$fields + offset <- fieldInfos[index,"offset"] + if (is.na(offset)) stop("unknown field index '", index ,"'") + fieldTypeName <- as.character(fieldInfos[[index,"type"]]) + fieldTypeInfo <- getTypeInfo(fieldTypeName) + if (fieldTypeInfo$type %in% c("base","pointer")) { + .unpack(x, offset, fieldTypeInfo$signature) + } else if ( !is.null(fieldTypeInfo$fields) ) { + if (is.raw(x)) { + size <- fieldTypeInfo$size + as.struct( x[(offset+1):(offset+1+size-1)], fieldTypeName) + } else if (is.externalptr(x)) { + as.struct( offsetPtr(x, offset), fieldTypeName) + } + } else { + stop("invalid field type '", fieldTypeName,"' at field '", index ) + } +} + +"$<-.struct" <- +pack.struct <- function( x, index, value ) +{ + structName <- attr(x, "struct") + structInfo <- getTypeInfo(structName) + fieldInfos <- structInfo$fields + offset <- fieldInfos[index,"offset"] + if (is.na(offset)) stop("unknown field index '", index ,"'") + fieldTypeName <- as.character(fieldInfos[index,"type"]) + fieldTypeInfo <- getTypeInfo(fieldTypeName) + if ( fieldTypeInfo$type %in% c("base","pointer") ) { + .pack( x, offset, fieldTypeInfo$signature, value ) + } + else if ( !is.null(fieldTypeInfo$fields) ) { + # substructure + size <- fieldTypeInfo$size + x[(offset+1):(offset+1+size-1)] <- as.raw(value) + } + else { + stop("invalid field type '", fieldTypeName,"' at field '", index ) + } + return(x) +} + +print.struct <- function(x, indent=0, ...) +{ + structName <- attr(x, "struct") + structInfo <- getTypeInfo(structName) + fieldInfos <- structInfo$fields + fieldNames <- rownames(fieldInfos) + + cat( "struct ", structName, " ") + if (typeof(x) == "externalptr") { + cat ("*") + if (is.nullptr(x)) { + cat("=NULL\n") + return() + } + } + cat("{\n") + # print data without last + for (i in seq(along=fieldNames)) + { + cat( rep(" ", indent+1), fieldNames[[i]] , ":" ) + val <- unpack.struct(x, fieldNames[[i]]) + if (typeof(val) == "externalptr") val <- "ptr" # .extptr2str(val) + if (class(val) == "struct") { print.struct(val, indent=indent+1) } + else cat( val, "\n" ) + } + cat( rep(" ", indent), "}\n") +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/R/pack.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,23 @@ +# Package: rdyncall +# File: R/pack.R +# Description: (un-)packing functions for access to C aggregate (struct/union) data types. + +.pack <- function(x, offset, sigchar, value) +{ + char1 <- substr(sigchar,1,1) + if (char1 == "*") char1 <- "p" + .Call("pack", x, as.integer(offset), char1, value, PACKAGE="rdyncall" ) +} + +.unpack <- function(x, offset, sigchar) +{ + sigchar <- char1 <- substr(sigchar,1,1) + if (char1 == "*") sigchar <- "p" + x <- .Call("unpack", x, as.integer(offset), sigchar, PACKAGE="rdyncall" ) + if (char1 == "*") + { + attr(x,"basetype") <- substr(sigchar,2,nchar(sigchar)) + } + return(x) +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/R/utils.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,9 @@ +# Package: rdyncall +# File: R/utils.R +# Description: Low-level external pointer utility functions + +is.nullptr <- function(x) .Call("isnullptr", x, PACKAGE="rdyncall") +as.extptr <- function(x) .Call("asextptr", x, PACKAGE="rdyncall") +offsetPtr <- function(x, offset) .Call("offsetPtr", x, offset, PACKAGE="rdyncall") +is.externalptr <- function(x) (typeof(x) == "externalptr") +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/R/utils_float.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,25 @@ +# Package: rdyncall +# File: R/utils_float.R +# Description: Support for C float vectors in R + +as.floatraw <- function(x) +{ + x <- .Call("r_as_floatraw", as.numeric(x), PACKAGE="rdyncall") + class(x) <- "floatraw" + x +} + +floatraw2numeric <- function(x) +{ + stopifnot(is.raw(x)) + stopifnot(class(x) == "floatraw") + stopifnot(length(x) >= 4) + .Call("r_floatraw2numeric", x, PACKAGE="rdyncall") +} + +floatraw <- function(n) +{ + x <- raw(n*4) + class(x) <- "floatraw" + x +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/R/utils_str.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,8 @@ +# Package: rdyncall +# File: R/utils_str.R +# Description: Support for (arrays of) C strings + +ptr2str <- function(x) .Call("r_ptr2str", x, PACKAGE="rdyncall") +strarrayptr <- function(x) .Call("r_strarrayptr", x, PACKAGE="rdyncall") +strptr <- function(x) .Call("r_strptr", x, PACKAGE="rdyncall") +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/README Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,17 @@ +See ANNOUNCEMENT.txt for an Introduction. + + +Building R package from subversion source tree +---------------------------------------------- + +1. install R package source from subversion + $ svn co http://dyncall.org/svn/dyncall/trunk/bindings/R/rdyncall + +2. install dyncall sources under rdyncall/src + $ ( cd rdyncall ; sh ./tools/bootstrap ) + +3. build & install it + $ R CMD build rdyncall + $ R CMD INSTALL rdyncall_<VERSION>.tar.gz + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/TODO Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,37 @@ +TODO: +- update manual + - document new dynports + - check signature format markup (.dyncall) + +- updates from dyncall (compare svn 1284 -> 1381) +- name mangling R <-> C ... exchange the first '_' in C -> '.' in R. +- feature: support for function pointers arguments, + if R closure is passed, auto wrap function a callback object + the callback object is appended in a global list +- bugfix for using callconv prefixes via .dyncall and not .dyncall.*. + using a different callvm for .dyncall that may be setup via prefixes and + resets to default always. +- test R build on solaris and sparc(64). +- document win32 expat binary installation +- callbacks should fail with "not yet implemented" on unsupported platforms +- use raw vectors for 1-to-1 bit encoding of values e.g. raw(8) for (u)int64 values +- handling of Csingle attribute on double vectors +- character encoding support, R supports UTF-8. +- Fortran calling conventions +- attr("struct") -> attr("CType") +- parseStructInfos -> cstruct +- parseUnionInfos -> cunion +- .dyncall typed pointer +- as.struct -> as.ctype +- new.struct -> cdata +- new.callback -> cfunction +- planed dynports:glut, curl, openal + +BUGS: +- OpenBSD 4.8/amd64: SDL failed due to pthread. + R version on OpenBSD does not provide a shared R library, thus + the symbols are not resolvable. + Additional Test for resolving self: + While .dynsym(as.extptr(NULL), "R_ShowMessage") works on Mac OS X, it fails on OpenBSD. +- demo(ttf) failed on Mac OS X 10.6 +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/cleanup Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,3 @@ +#!/bin/sh +cd src/dyncall && make -f Makefile.embedded clean +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/cleanup.win Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,3 @@ +#!/bin/sh +cd src/dyncall ; make -f Makefile.generic clean +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/00Index Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,20 @@ +R_ShowMessage Show R Dialog Message (dynbind demo) +R_malloc Using R's memory allocator directly in R (dynbind demo) +blink Simple SDL,OpenGL demonstration - a blinking screen (dynport demo) +SDL 3D Rotating Cube Demo using SDL,OpenGL and GLU. (dynport demo) +randomfield Scientific Computations using OpenGL: Rendering 512x512 random field by blending 5000 point sprites (dynport demo) +randomfield2 Scientific Computations using OpenGL: Rendering 512x512 random field by blending 5000 point sprites (dynport demo) +expat Parsing XML using expat and callbacks (callback demo) +callbacks Creating a callback and call it via .dyncall (dyncall and callback demo) +factorial Factorial computation via recursive .dyncall calls to callback objects. +stdio Direct I/O of R raw vectors using C stdio functions +sqrt C math library demo (dynbind demo) +Win32PlaySound Win32 Demo, playing a wav file (dynbind demo) +blink_gl3 Simple SDL,OpenGL 3 API demonstration. +ttf SDL true type font library example. +intro Texture-mapped scroller, playing XM music module. +qsort C standard library qsort C with a custom compare via callbacks (dyncallback demo). +playtune SDL audio-only and SDL_mixer demo: plays XM music module. +sdlnet SDL_net + OpenGL Demo, listens on socket for world country names and rotates map in OpenGL. +gles OpenGL ES Example. +glpk GLPK Example.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/R_ShowMessage.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,7 @@ +# Package: rdyncall +# File: demo/R_ShowMessage.R +# Description: Show R Dialog Message (dynbind demo) + +dynbind("R","R_ShowMessage(Z)v;") +R_ShowMessage("hello") +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/R_malloc.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,16 @@ +# Package: rdyncall +# File: demo/R_malloc.R +# Description: using R's memory allocator directly in R + +dynbind("R","R_chk_calloc(ii)p;R_chk_free(p)v;") +malloc <- function(size) +{ + x <- R_chk_calloc(as.integer(size),1L) + reg.finalizer(x, R_chk_free) + return(x) +} + +x <- malloc(1024) +x <- NULL +gc() +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/SDL.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,146 @@ +# Package: rdyncall +# File: demo/SDL.R +# Description: 3D Rotating Cube Demo using SDL,OpenGL and GLU. (dynport demo) + +dynport(SDL) +dynport(GL) +dynport(GLU) + +# Globals. + +surface <- NULL + +# Init. + +init <- function() +{ + err <- SDL_Init(SDL_INIT_VIDEO) + if (err != 0) error("SDL_Init failed") + surface <<- SDL_SetVideoMode(512,512,32,SDL_DOUBLEBUF+SDL_OPENGL) +} + +# GL Display Lists + +makeCubeDisplaylist <- function() +{ + vertices <- as.double(c( + -1,-1,-1, + 1,-1,-1, + -1, 1,-1, + 1, 1,-1, + -1,-1, 1, + 1,-1, 1, + -1, 1, 1, + 1, 1, 1 + )) + + colors <- as.raw( col2rgb( rainbow(8) ) ) + + triangleIndices <- as.integer(c( + 0, 2, 1, + 2, 3, 1, + 1, 3, 7, + 1, 7, 5, + 4, 5, 7, + 4, 7, 6, + 6, 2, 0, + 6, 0, 4, + 2, 7, 3, + 2, 6, 7, + 4, 0, 5, + 0, 1, 5 + )) + + glEnableClientState(GL_VERTEX_ARRAY) + glVertexPointer(3, GL_DOUBLE, 0, vertices ) + + glEnableClientState(GL_COLOR_ARRAY) + glColorPointer(3, GL_UNSIGNED_BYTE, 0, colors ) + + displaylistId <- glGenLists(1) + glNewList( displaylistId, GL_COMPILE ) + glPushAttrib(GL_ENABLE_BIT) + glEnable(GL_DEPTH_TEST) + glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, triangleIndices) + glPopAttrib() + glEndList() + + glDisableClientState(GL_VERTEX_ARRAY) + glDisableClientState(GL_COLOR_ARRAY) + + + return(displaylistId) +} + +# Mainloop. + +mainloop <- function() +{ + displaylistId <- makeCubeDisplaylist() + evt <- new.struct(SDL_Event) + blink <- 0 + tbase <- SDL_GetTicks() + quit <- FALSE + while(!quit) + { + tnow <- SDL_GetTicks() + tdemo <- ( tnow - tbase ) / 1000 + + glClearColor(0,0,blink,0) + glClear(GL_COLOR_BUFFER_BIT+GL_DEPTH_BUFFER_BIT) + + glMatrixMode(GL_PROJECTION) + glLoadIdentity() + aspect <- 512/512 + gluPerspective(60, aspect, 3, 1000) + + glMatrixMode(GL_MODELVIEW) + glLoadIdentity() + gluLookAt(0,0,5,0,0,0,0,1,0) + glRotated(sin(tdemo)*60.0, 0, 1, 0); + glRotated(cos(tdemo)*90.0, 1, 0, 0); + + glCallList(displaylistId) + + glCallList(displaylistId) + + SDL_GL_SwapBuffers() + + SDL_WM_SetCaption(paste("time:", tdemo),NULL) + blink <- blink + 0.01 + while (blink > 1) blink <- blink - 1 + while( SDL_PollEvent(evt) != 0 ) + { + if ( evt$type == SDL_QUIT ) quit <- TRUE + else if (evt$type == SDL_MOUSEBUTTONDOWN ) + { + button <- evt$button + cat("button ",button$button," at ",button$x,",",button$y,"\n") + } + } + glerr <- glGetError() + if (glerr != 0) + { + cat("GL Error:", gluErrorString(glerr) ) + quit <- 1 + } + SDL_Delay(30) + } + glDeleteLists(displaylistId, 1) +} + +cleanup <- function() +{ + SDL_Quit() +} + +run <- function() +{ + init() + mainloop() + cleanup() +} + +run() + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/Win32PlaySound.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,14 @@ +# Package: rdyncall +# File: demo/Win32PlaySound.R +# Description: Win32 Demo, playing a wav file (dynbind demo) + +if (.Platform$OS.type == "windows") { + + dynbind("winmm", "PlaySoundA(Zii)v;", callmode="stdcall") + tada <- paste( Sys.getenv("SystemRoot"), "\\Media\\tada.wav", sep="" ) + PlaySoundA(tada,0,0) + +} else { + cat("This demo is runnable on windows only.") +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/blink.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,75 @@ +# Package: rdyncall +# File: demo/blink.R +# Description: Simple SDL,OpenGL demonstration - a blinking screen + +dynport(SDL) +dynport(GL) + +blink <- 0 +surface <- NULL + +init <- function() +{ + SDL_Init(SDL_INIT_VIDEO) + surface <<- SDL_SetVideoMode(640,480,32,SDL_OPENGL+SDL_DOUBLEBUF) + blink <<- 0 +} + + +update <- function() +{ + glFinish() + glClearColor(0,0,blink,0) + glClear(GL_COLOR_BUFFER_BIT) + SDL_GL_SwapBuffers() + glFlush() + blink <<- ( blink + 0.01 ) %% 1 +} + +input <- function() +{ + return(TRUE) +} + +checkGL <- function() +{ + glerror <- glGetError() + if (glerror != 0) + { + cat("GL Error", glerror, "\n") + } + return(glerror == 0) +} + +mainloop <- function() +{ + sdlevent <- new.struct("SDL_Event") + quit <- FALSE + while(!quit) + { + update() + while( SDL_PollEvent(sdlevent) ) + { + if (sdlevent$type == SDL_QUIT ) { + quit <- TRUE + } else if (sdlevent$type == SDL_MOUSEBUTTONDOWN) { + cat("button ", sdlevent$button$button ,"\n") + } + } + if ( !checkGL() ) quit <- TRUE + } +} + +quit <- function() +{ + SDL_Quit() +} + +run <- function() +{ + init() + mainloop() + quit() +} + +run()
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/blink_gl3.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,76 @@ +# Package: rdyncall +# File: demo/blink.R +# Description: Simple SDL,OpenGL demonstration - a blinking screen + +require(rdyncall) +dynport(SDL) +dynport(gl3) + +blink <- 0 +surface <- NULL + +init <- function() +{ + SDL_Init(SDL_INIT_VIDEO) + SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 1 ) + surface <<- SDL_SetVideoMode(640,480,32,SDL_OPENGL+SDL_DOUBLEBUF) + blink <<- 0 +} + + +update <- function() +{ + glClearColor(0,0,blink,0) + glClear(GL_COLOR_BUFFER_BIT) + SDL_GL_SwapBuffers() + blink <<- ( blink + 0.01 ) %% 1 +} + +input <- function() +{ + return(TRUE) +} + +checkGL <- function() +{ + glerror <- glGetError() + if (glerror != 0) + { + cat("GL Error", glerror, "\n") + } + return(glerror == 0) +} + +mainloop <- function() +{ + sdlevent <- new.struct("SDL_Event") + quit <- FALSE + while(!quit) + { + update() + while( SDL_PollEvent(sdlevent) ) + { + if (sdlevent$type == SDL_QUIT ) { + quit <- TRUE + } else if (sdlevent$type == SDL_MOUSEBUTTONDOWN) { + cat("button ", sdlevent$button$button ,"\n") + } + } + if ( !checkGL() ) quit <- TRUE + # SDL_Delay(30) + } +} + +quit <- function() +{ + SDL_Quit() +} + +run <- function() +{ + init() + mainloop() + quit() +} + +run()
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/callbacks.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,27 @@ +# Package: rdyncall +# File: demo/callbacks.R +# Description: Creating a callback and call it via .dyncall + +# The function to wrap: +f <- function(x,y) x+y + +# Create the callback: +cb <- new.callback("ii)i", f) + +# Call the callback +r <- .dyncall(cb, "ii)i", 20, 3) +r == 23 + +# Recursive callback example: + +f <- function(x,y,f,i) +{ + if (i > 1) .dyncall(f, "iipi)i", x,y,f,i-1) + x+y +} + +cb <- new.callback("iipi)i", f) + +r <- .dyncall(cb, "iipi)i", 1,1,cb,100 ) +r == 2 +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/expat.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,33 @@ +# Package: rdyncall +# File: demo/expat.R +# Description: Parsing XML using expat and callbacks + +dynport(expat) + +parser <- XML_ParserCreate(NULL) + +onXMLStartTag <- function(user,tag,attr) +{ + # as.character( as.cstrptrarray(attr) ) + cat("Start tag:", tag, "\n") +} + +onXMLEndTag <- function(user,tag) +{ + cat("End tag:",tag, "\n") +} + +cb.onstart <- new.callback("pZp)v", onXMLStartTag ) +cb.onstop <- new.callback("pZ)v", onXMLEndTag ) + +XML_SetElementHandler( parser, cb.onstart, cb.onstop ) + +text <- " +<hello> + <world> + </world> +</hello> +" + +XML_Parse( parser, text, nchar(text), 1) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/factorial.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,13 @@ +f <- function(i,fun) +{ + if (i > 1) i * .dyncall(fun,"ip)i",i-1,fun) else i +} +e <- new.env() +cb <- new.callback("ip)i", f,e) +e <- NULL +f <- NULL +gc() +r <- .dyncall(cb,"ip)i",12,cb) +r == factorial(12) +cb <- NULL +gc()
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/gles.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,43 @@ +library(rdyncall) +dynport(SDL) +dynport(EGL) +dynbind("X11", "XOpenDisplay(Z)p;") + +init <- function() { +SDL_Init(SDL_INIT_VIDEO) +srf <- SDL_SetVideoMode(640,480,32,SDL_SWSURFACE) +dpy <- XOpenDisplay(NULL) +egl <- eglGetDisplay(dpy) +if (is.nullptr(egl)) { + error("failed: eglGetDisplay") +} +status <- eglInitialize(egl,NULL,NULL) +if (!status) { + error("failed: eglInitialize") +} +numConfigOuts <- integer(1) +g_configAttribs <- as.integer(c( + EGL_RED_SIZE, 5, + EGL_GREEN_SIZE, 6, + EGL_BLUE_SIZE, 5, + EGL_DEPTH_SIZE, 16, + EGL_SURFACE_TYPE, EGL_WINDOW_BIT, + EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT, + EGL_BIND_TO_TEXTURE_RGBA, EGL_TRUE, + EGL_NONE +)) + +g_eglConfig <- raw(4) + +s <- eglChooseConfig(egl, g_configAttribs, g_eglConfig, 1, numConfigOuts) +if (s != EGL_TRUE || numConfigOuts == 0) { + error("failed: eglChooseConfig") +} + + +} + +init() + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/glpk.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,53 @@ +# Example from GLPK Reference Manual.. rewritten to R. + +dynport(glpk) +lp = glp_create_prob(); +glp_set_prob_name(lp, "sample"); +glp_set_obj_dir(lp, GLP_MAX); +glp_add_rows(lp, 3); +glp_set_row_name(lp, 1, "p"); +glp_set_row_bnds(lp, 1, GLP_UP, 0.0, 100.0); +glp_set_row_name(lp, 2, "q"); +glp_set_row_bnds(lp, 2, GLP_UP, 0.0, 600.0); +glp_set_row_name(lp, 3, "r"); +glp_set_row_bnds(lp, 3, GLP_UP, 0.0, 300.0); +glp_add_cols(lp, 3); +glp_set_col_name(lp, 1, "x1"); +glp_set_col_bnds(lp, 1, GLP_LO, 0.0, 0.0); +glp_set_obj_coef(lp, 1, 10.0); +glp_set_col_name(lp, 2, "x2"); +glp_set_col_bnds(lp, 2, GLP_LO, 0.0, 0.0); +glp_set_obj_coef(lp, 2, 6.0); +glp_set_col_name(lp, 3, "x3"); +glp_set_col_bnds(lp, 3, GLP_LO, 0.0, 0.0); +glp_set_obj_coef(lp, 3, 4.0); + +ia = integer(1+1000) +ja = integer(1+1000) +ar = double(1+1000) + +#we index at 1 in C (second position).. but in R we start at initial position.. +ia[1]=1;ja[1]=1;ar[1]= 1.0; +ia[2]=1;ja[2]=2;ar[2]= 1.0; +ia[3]=1;ja[3]=3;ar[3]= 1.0; +ia[4]=2;ja[4]=1;ar[4]= 10.0; +ia[5]=3;ja[5]=1;ar[5]= 2.0; +ia[6]=2;ja[6]=2;ar[6]= 4.0; +ia[7]=3;ja[7]=2;ar[7]= 2.0; +ia[8]=2;ja[8]=3;ar[8]= 5.0; +ia[9]=3;ja[9]=3;ar[9]= 6.0; + +#now we prefix with '0' .. so that our values the above start at 1 in C. + +ia <- as.integer(c(0,ia)) +ja <- as.integer(c(0,ja)) + +glp_load_matrix(lp, 9, ia, ja, ar); +glp_simplex(lp, NULL); +z = glp_get_obj_val(lp); +x1 = glp_get_col_prim(lp, 1); +x2 = glp_get_col_prim(lp, 2); +x3 = glp_get_col_prim(lp, 3); + +print(list(z=z,x1=x1,x2=x2,x3=x3)) +glp_delete_prob(lp);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/intro.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,149 @@ +# Package: rdyncall +# File: demo/intro.R +# Description: Texture-mapped scroll-text, playing music 'Hybrid Song' composed in jan. -96 by Quazar of Sanxion + +s <- NULL +texId <- NULL +music <- NULL + +checkGL <- function() +{ + glerror <- glGetError() + if (glerror != 0) + { + cat("GL Error", glerror, "\n") + } + return(glerror == 0) +} + +init <- function() +{ + require(rdyncall) + dynport(SDL) + SDL_Init(SDL_INIT_VIDEO+SDL_INIT_AUDIO) + dynport(GL) + dynport(SDL_image) + s <<- SDL_SetVideoMode(640,480,32,SDL_OPENGL+SDL_DOUBLEBUF) + stopifnot( IMG_Init(IMG_INIT_PNG) == IMG_INIT_PNG ) + texId <<- loadTexture("chromefont.png") + # texId <<- loadTexture("nuskool_krome_64x64.png") + dynport(SDL_mixer) + # stopifnot( Mix_Init(MIX_INIT_MOD) == MIX_INIT_MOD ) + Mix_OpenAudio(MIX_DEFAULT_FREQUENCY, MIX_DEFAULT_FORMAT, 2, 4096) + music <<- Mix_LoadMUS(rsrc("external.xm")) +} + +rsrc <- function(name) system.file(paste("demo-files",name,sep=.Platform$file.sep), package="rdyncall") + +loadTexture <- function(name) +{ + checkGL() + glEnable(GL_TEXTURE_2D) + x <- rsrc(name) + img <- IMG_Load(x) +# glPixelStorei(GL_UNPACK_ALIGNMENT,4) + texid <- integer(1) + glGenTextures(1, texid) + glBindTexture(GL_TEXTURE_2D, texid) + SDL_LockSurface(img) + maxS <- integer(1) + glGetIntegerv(GL_MAX_TEXTURE_SIZE, maxS) + stopifnot( (img$w <= maxS) && (img$h <= maxS) ) + glTexImage2D(GL_TEXTURE_2D, 0, 4, img$w, img$h, 0, GL_BGRA, GL_UNSIGNED_BYTE, img$pixels) + SDL_UnlockSurface(img) + SDL_FreeSurface(img) +# gluBuild2DMipmaps(GL_TEXTURE_2D, 4, img$w, img$h) + return(texid) +} + +drawScroller <- function(codes,time) +{ + glBindTexture(GL_TEXTURE_2D, texId) + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT) + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT) + glEnable(GL_BLEND) + glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE) + + glMatrixMode(GL_MODELVIEW) + glLoadIdentity() + glMatrixMode(GL_PROJECTION) + glLoadIdentity() + + x <- 1-time*0.5 + y <- 0 + w <- 0.3+0.1*sin(6.24*time) + h <- 0.2 + for (i in 1:length(codes)) { + t <- codes[i] + s0 <- (t%%8)/8 + t0 <- as.integer(t/8)/8 + s1 <- s0+1/8 + t1 <- t0+1/8 + + # s0 <- 0 + # s1 <- 1 + # t0 <- 0 + # t1 <- 1 + + glBegin(GL_QUADS) + glTexCoord2f(s0,t1) ; glVertex3f(x ,y ,0) + glTexCoord2f(s1,t1) ; glVertex3f(x+w,y ,0) + glTexCoord2f(s1,t0) ; glVertex3f(x+w,y+h,0) + glTexCoord2f(s0,t0) ; glVertex3f(x ,y+h,0) + glEnd() + x <- x + w + } +} + +codes <- utf8ToInt("DO YOU SOMETIMES WANT FOR YOUR OLD HOME COMPUTER?! - I DO") - 32 + +mainloop <- function() +{ + Mix_PlayMusic(music, 1) + quit <- FALSE + blink <- 0 + tbase <- SDL_GetTicks() + evt <- new.struct(SDL_Event) + while(!quit) + { + tnow <- SDL_GetTicks() + tdemo <- ( tnow - tbase ) / 1000 + glClearColor(0,0,blink,0) + glClear(GL_COLOR_BUFFER_BIT+GL_DEPTH_BUFFER_BIT) + blink <- blink + 0.01 + drawScroller(codes,tdemo) + SDL_GL_SwapBuffers() + while( SDL_PollEvent(evt) != 0 ) + { + type <- evt$type + if ( + type == SDL_QUIT + || ( type == SDL_KEYDOWN && evt$key$keysym$sym == SDLK_ESCAPE ) + ) { + quit <- TRUE + } + } + SDL_Delay(20) + } +} + +cleanup <- function() +{ + Mix_CloseAudio() +# Mix_Quit() + IMG_Quit() + SDL_Quit() +} + +run <- function() +{ + init() + mainloop() + cleanup() +} + +run() +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/playtune.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,35 @@ + +# Package: rdyncall +# File: demo/playtune.R +# Description: play a nice oldsch00l tune. +# Uses: SDL/audio, SDL_mixer + +rsrc <- function(name) system.file(paste("demo-files",name,sep=.Platform$file.sep), package="rdyncall") +music <- NULL +init <- function() +{ + require(rdyncall) + dynport(SDL) + SDL_Init(SDL_INIT_AUDIO) + dynport(SDL_mixer) + Mix_OpenAudio(MIX_DEFAULT_FREQUENCY, MIX_DEFAULT_FORMAT, 2, 4096) + music <<- Mix_LoadMUS(rsrc("external.xm")) +} +cleanup <- function() +{ + stopTune() + Mix_FreeMusic(music) + Mix_CloseAudio() + SDL_Quit() +} + +playTune <- function() { + Mix_PlayMusic(music, 1) + cat("playing music... [to stop, call 'stopTune()']\n") +} +pauseTune <- function() Mix_PauseMusic() +stopTune <- function() Mix_HaltMusic() + +init() +playTune() +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/qsort.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,10 @@ +dynbind(c("msvcrt","c","c.so.6"), "qsort(piip)v;") +cb <- new.callback("pp)i",function(px,py){ + x <- .unpack(px, 0, "d") + y <- .unpack(py, 0, "d") + if (x > y) return(1) else if (x == y) return(0) else return(-1) +}) +x <- rnorm(100) +qsort(x,length(x),8,cb) + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/randomfield.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,201 @@ +# Package: rdyncall +# File: demo/randomfield.R +# Description: Scientific Computations using OpenGL: Rendering 512x512 random field by blending 5000 point sprites (dynport demo) + +dynport(SDL) +dynport(GL) + +# ---------------------------------------------------------------------------- +# Parameters: + +# framebuffer size +fb.size <- 512 + +# texture size +tex.size <- 512 + + +# ---------------------------------------------------------------------------- +# texture setup + +genTex.circle <- function(n) +{ + m <- matrix(data=FALSE,nr=n,nc=n) + r <- n/2 + for(i in 1:n) + { + for(j in 1:n) + { + m[[i,j]] <- ifelse((i-r)^2+(j-r)^2 > r^2,0L,255L) + } + } + return(m) +} + +genTex.bnorm <- function(n) +{ + x <- seq(-3,3,len=n) + y <- dnorm(x) + return( outer(y,y) ) +} + +# ---------------------------------------------------------------------------- +# draw circle using OpenGL Vertex Arrays + +drawTexCirclesVertexArray <- function(x,y,r) +{ + n <- max( length(x), length(y), length(r) ) + x1 <- x-r + x2 <- x+r + y1 <- y-r + y2 <- y+r + + vertexArray <- as.vector(rbind(x1,y1,x2, y1, x2, y2, x1, y2)) + texCoordArray <- rep( as.double(c(0,0,1,0,1,1,0,1)), n ) + + glEnableClientState(GL_VERTEX_ARRAY) + glEnableClientState(GL_TEXTURE_COORD_ARRAY) + glVertexPointer(2,GL_DOUBLE,0,vertexArray) + glTexCoordPointer(2,GL_DOUBLE,0,texCoordArray) + + glDrawArrays(GL_QUADS, 0, n*4) + + glDisableClientState(GL_VERTEX_ARRAY) + glDisableClientState(GL_TEXTURE_COORD_ARRAY) +} + +#drawPointSprite <- function() +#{ +# glEnable(GL_POINT_SPRITE) +# glTexEnvi(GL_POINT_SPRITE,GL_COORD_REPLACE,GL_TRUE) +# glPointParameter(GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT) +# glPointSize +#} + +# ---------------------------------------------------------------------------- +# initialize SDL, OpenGL + +max.tex.size <- integer(1) +max.tex.units <- integer(1) +tex.ids <- integer(1) +init <- function() +{ + # initialize SDL + + SDL_Init(SDL_INIT_VIDEO) + surface <<- SDL_SetVideoMode(fb.size,fb.size,32,SDL_OPENGL+SDL_DOUBLEBUF) + + # initialize OpenGL + + glGetIntegerv(GL_MAX_TEXTURE_SIZE, max.tex.size) + glGetIntegerv(GL_MAX_TEXTURE_UNITS, max.tex.units) + + glClearColor(0,0,0,0) + glColor4f(0.1,0.1,0.1,0) + + # img <- genTex.circle(tex.size) + # texdata <- as.raw(img) + + img <- genTex.bnorm(tex.size) + m <- max(img) + texdata <- as.raw( ( img/m ) * 255 ) + + + glGenTextures( length(tex.ids),tex.ids) + glBindTexture(GL_TEXTURE_2D, tex.ids[[1]]) + glPixelStorei(GL_UNPACK_ALIGNMENT, 1) + glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, tex.size, tex.size, 0, GL_ALPHA, GL_UNSIGNED_BYTE, texdata) + # glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, tex.size, tex.size, 0, GL_ALPHA, GL_DOUBLE, as.vector(img)) + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_CLAMP_TO_BORDER) + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_CLAMP_TO_BORDER) + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST) + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST) + + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE) + glEnable(GL_TEXTURE_2D) + + # blending setup + + glBlendFunc(GL_SRC_ALPHA, GL_ONE) + glEnable(GL_BLEND) +} + +cleanup <- function() +{ + glDeleteTextures( length(tex.ids), tex.ids) + SDL_Quit() +} + +pixels <- NULL + +main <- function() +{ + cat("Click on window to import current random field and plot in R.\nClose window to quit mainloop.\n") + N <- 5000 + colorunit <- 0.02 + glColor3d( colorunit,colorunit,colorunit ) + tbase <- SDL_GetTicks() + frames <- 0 + + x <- runif(N,-1.1,1.1) + y <- runif(N,-1.1,1.1) + r <- runif(N,0.1,0.2) + event <- new.struct("SDL_Event") + + # disable interactive plot device. + oldpars <- par(ask=FALSE,mfrow=c(1,1)) + + quit <- FALSE + while(!quit) + { + glClear(GL_COLOR_BUFFER_BIT) + drawTexCirclesVertexArray(x,y,r) + x <- runif(N,-1.1,1.1) + y <- runif(N,-1.1,1.1) + r <- runif(N,0.1,0.2) + glFinish() + SDL_GL_SwapBuffers() + tnow <- SDL_GetTicks() + if ((tnow - tbase) > 1000) + { + tbase <- tnow + SDL_WM_SetCaption(paste("FPS:", frames),NULL) + frames <- 0 + } + while( SDL_PollEvent(event) != 0 ) + { + type <- event$type + if (type == SDL_MOUSEBUTTONDOWN) { + cat("Read pixels via OpenGL into an R integer matrix..") + pixels <<- readpixels() + cat("done.\nPlot image results with R plotting device. This may take a while - please be patient..") + image(pixels) + cat("done.\nContinue..\n") + } else if (type == SDL_QUIT) { + cat("Read pixels via OpenGL into an R integer matrix 'pixels'..") + pixels <<- readpixels() + cat("done.\nRe-run by 'run()'\n") + quit <- TRUE + } + } + frames <- frames + 1 + } + par(oldpars) +} + +readpixels <- function() +{ + array <- matrix(NA_integer_,fb.size,fb.size) + glPixelStorei(GL_PACK_ALIGNMENT,1) + glReadPixels(0,0,fb.size,fb.size, GL_LUMINANCE, GL_INT, array) + return(array) +} + +run <- function() +{ + init() + main() +} + +run()
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/randomfield2.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,228 @@ +# Package: rdyncall +# File: demo/randomfield.R +# Description: Scientific Computations using OpenGL: Rendering 512x512 random field by blending 5000 point sprites (dynport demo) +require(rdyncall) +library(lattice) +dynport(SDL) +dynport(GL) + +# ---------------------------------------------------------------------------- +# Parameters: + +# Framebuffer size +fb.size <- 512 + +# Texture size +tex.size <- 512 + +# Blending color +colorunit <- 0.02 + +# ---------------------------------------------------------------------------- +# texture setup + +genTex.circle <- function(n) +{ + m <- matrix(data=FALSE,nr=n,nc=n) + r <- n/2 + for(i in 1:n) + { + for(j in 1:n) + { + m[[i,j]] <- ifelse((i-r)^2+(j-r)^2 > r^2,0L,255L) + } + } + return(m) +} + +genTex.bnorm <- function(n) +{ + x <- seq(-3,3,len=n) + y <- dnorm(x) + return( outer(y,y) ) +} + +# ---------------------------------------------------------------------------- +# draw circle using OpenGL Vertex Arrays + +drawTexCirclesVertexArray <- function(x,y,r) +{ + n <- max( length(x), length(y), length(r) ) + x1 <- x-r + x2 <- x+r + y1 <- y-r + y2 <- y+r + + vertexArray <- as.vector(rbind(x1,y1,x2, y1, x2, y2, x1, y2)) + texCoordArray <- rep( as.double(c(0,0,1,0,1,1,0,1)), n ) + + glEnableClientState(GL_VERTEX_ARRAY) + glEnableClientState(GL_TEXTURE_COORD_ARRAY) + glVertexPointer(2,GL_DOUBLE,0,vertexArray) + glTexCoordPointer(2,GL_DOUBLE,0,texCoordArray) + + glDrawArrays(GL_QUADS, 0, n*4) + + glDisableClientState(GL_VERTEX_ARRAY) + glDisableClientState(GL_TEXTURE_COORD_ARRAY) +} + +#drawPointSprite <- function() +#{ +# glEnable(GL_POINT_SPRITE) +# glTexEnvi(GL_POINT_SPRITE,GL_COORD_REPLACE,GL_TRUE) +# glPointParameter(GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT) +# glPointSize +#} + +# ---------------------------------------------------------------------------- +# initialize SDL, OpenGL + +max.tex.size <- integer(1) +max.tex.units <- integer(1) +tex.ids <- integer(1) + +init <- function() +{ + # initialize SDL + + SDL_Init(SDL_INIT_VIDEO) + surface <<- SDL_SetVideoMode(fb.size,fb.size,32,SDL_OPENGL+SDL_DOUBLEBUF) + + # initialize OpenGL + + glGetIntegerv(GL_MAX_TEXTURE_SIZE, max.tex.size) + glGetIntegerv(GL_MAX_TEXTURE_UNITS, max.tex.units) + + glClearColor(0,0,0,0) + glColor4f(0.1,0.1,0.1,0) + + # img <- genTex.circle(tex.size) + # texdata <- as.raw(img) + + img <- genTex.bnorm(tex.size) + m <- max(img) + texdata <- as.raw( ( img/m ) * 255 ) + + + glGenTextures( length(tex.ids),tex.ids) + glBindTexture(GL_TEXTURE_2D, tex.ids[[1]]) + glPixelStorei(GL_UNPACK_ALIGNMENT, 1) + glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, tex.size, tex.size, 0, GL_ALPHA, GL_UNSIGNED_BYTE, texdata) + # glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, tex.size, tex.size, 0, GL_ALPHA, GL_DOUBLE, as.vector(img)) + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_CLAMP_TO_BORDER) + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_CLAMP_TO_BORDER) + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST) + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST) + + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE) + glEnable(GL_TEXTURE_2D) + + # blending setup + + glBlendFunc(GL_SRC_ALPHA, GL_ONE) + glEnable(GL_BLEND) + + glColor3d( colorunit,colorunit,colorunit ) + +} + +cleanup <- function() +{ + glDeleteTextures( length(tex.ids), tex.ids) + SDL_Quit() +} + +sim <- function(N = 5000) + return(list( + x = runif(N,-1.1,+1.1), + y = runif(N,-1.1,+1.1), + r = runif(N, 0.1, 0.2) + )) + +render <- function(o) { + glClear(GL_COLOR_BUFFER_BIT) + drawTexCirclesVertexArray(o$x,o$y,o$r) + glFinish() + SDL_GL_SwapBuffers() +} + +event <- new.struct("SDL_Event") +quit <- FALSE +pollEvents <- function() { + while( SDL_PollEvent(event) != 0 ) + { + type <- event$type + if (type == SDL_MOUSEBUTTONDOWN) { + cat("Read pixels via OpenGL into an R integer matrix..") + pixels <<- readpixels() + cat("done.\nPlot image results with R plotting device. This may take a while - please be patient..") + image(pixels) + cat("done.\nContinue..\n") + } else if (type == SDL_QUIT) { + cat("Read pixels via OpenGL into an R integer matrix 'pixels'..") + pixels <<- readpixels() + cat("done.\nRe-run by 'run()'\n") + quit <<- TRUE + } + } +} + +# --- Read Pixels ------------------------------------------------------------ + +readpixels <- function() +{ + array <- matrix(NA_integer_,fb.size,fb.size) + glPixelStorei(GL_PACK_ALIGNMENT,1) + glReadPixels(0,0,fb.size,fb.size, GL_LUMINANCE, GL_INT, array) + return(array) +} + + +# --- FPS Counter ------------------------------------------------------------ + +fpsInit <- function() + return(list( + tbase = SDL_GetTicks(), + frames = 0 + )) + +fpsUpdate <- function(o) { + tnow <- SDL_GetTicks() + if ((tnow - o$tbase) > 1000) + { + o$tbase <- tnow + SDL_WM_SetCaption(paste("FPS:", o$frames),NULL) + o$frames <- 0 + } else { + o$frames <- o$frames + 1 + } + return(o) +} + +# --- Main Loop -------------------------------------------------------------- + +main <- function() +{ + init() + # disable interactive plot device. + oldpars <- par(ask=FALSE,mfrow=c(1,1)) + # user notice + cat("Click on window to import current random field and plot in R.\nClose window to quit mainloop.\n") + + fps <- fpsInit() + quit <<- FALSE + while(!quit) + { + sim <- sim(5000) + render(sim) + pollEvents() + fps <- fpsUpdate(fps) + } + + par(oldpars) +} + +main() +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/sdlnet.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,170 @@ +# BUGS: does not work on Mac OS X using R64, needs to use R32. + +library(rdyncall) +dynport(SDL) +dynport(GL) +dynport(SDL_net) +library(mapdata) + +db <- "worldHires" + +PORT <- 1234 +MAX_CLIENT_SOCKETS <- 3 + +tcp <- NULL +socket <- NULL +sockets <- NULL +ctcps <- NULL +csocks <- NULL +world <- NULL +glList <- NULL + +init <- function() { + + if ( SDL_Init(SDL_INIT_VIDEO) == -1 ) { + error("SDL_Init failed") + } + + if ( SDLNet_Init() == -1 ) { + error("SDLNet_Init failed") + } + + ip <- new.struct("IPaddress") + + if ( SDLNet_ResolveHost(ip,NULL,PORT) == -1 ) { + error("SDLNet_ResolveHost failed") + } + + tcp <<- SDLNet_TCP_Open(ip) + + socket <<- as.struct(offsetPtr(tcp,0),"SDLNet_GenericSocket_") + + sockets <<- SDLNet_AllocSocketSet(1+MAX_CLIENT_SOCKETS) + SDLNet_AddSocket(sockets, socket ) + + SDL_SetVideoMode(640,480,32,SDL_OPENGL+SDL_DOUBLEBUF) + + ctcps <<- list() + csocks <<- list() + world <<- map(db,"switzerland",plot=FALSE) + + glList <<- glGenLists(1) +} + + +drawMap3d <- function(m) { + glNewList(glList, GL_COMPILE) + x <- m$x + vb <- rbind(m$x,m$y) + glEnableClientState(GL_VERTEX_ARRAY) + glVertexPointer(2, GL_DOUBLE, 0, vb) + markers <- which(is.na(x)) + begin <- 1 + i <- 1 + while(i <= length(markers)) { + end <- markers[i] - 1 + glDrawArrays(GL_LINE_STRIP, begin - 1, (end-1) - (begin-1) + 1) + begin <- markers[i] + 1 + i <- i + 1 + } + end <- length(x) + glDrawArrays(GL_LINE_STRIP, begin - 1, (end-1) - (begin-1) + 1) + glDisableClientState(GL_VERTEX_ARRAY) + glEndList() +} + +loop <- function() { + drawMap3d(world) + do_loop <- TRUE + cnt <- 0 + evt <- new.struct("SDL_Event") + while(do_loop) { + glClearColor(0.2,0.3,0.1,0) + glClear(GL_COLOR_BUFFER_BIT) + r <- world$range + glMatrixMode(GL_PROJECTION) + glLoadIdentity() + glOrtho(r[[1]],r[[2]],r[[3]],r[[4]],-10000, 10000) + glMatrixMode(GL_MODELVIEW) + glLoadIdentity() + + cx <- r[[1]] + ( r[[2]] - r[[1]] ) * 0.5 + cy <- r[[3]] + ( r[[4]] - r[[3]] ) * 0.5 + + glTranslatef( cx, cy , 0 ) + glRotatef(cnt,0,1,0) ; cnt <- cnt + 1 + glTranslatef( -cx, -cy , 0 ) +#( r[[2]]-r[[1]] )*0.5, (r[[4]]-r[[3]]) *0.5,0) + # glTranslatef(-(r[[2]]-r[[1]])*0.5,-(r[[4]]-r[[3]])*0.5,0) + glEnable(GL_BLEND) + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) + glColor4f(1.0,0.8,0.5,0.2) + delta <- 0 + for(i in 1:10) { + glLoadIdentity() + glTranslatef( cx, cy , 0 ) + glRotatef(cnt+delta,0,1,0) ; + glTranslatef( -cx, -cy , 0 ) + glCallList(glList) + delta <- delta + 1.0 + } + glFinish() + SDL_GL_SwapBuffers() + + while( SDL_PollEvent(evt) ) { + if ( evt$type == SDL_QUIT ) { + do_loop <- FALSE + } + } + + numready <- SDLNet_CheckSockets(sockets, 0) + if (numready > 0) { + cat("ready\n") + if (socket$ready) { + cat("listener\n\n") + # tcp <- as.struct(tcp,"_TCPsocket") + ctcp <- SDLNet_TCP_Accept(tcp) + if (is.null(ctcp)) { + cat("warning: client is NULL\n") + } else { + csock <- as.struct(offsetPtr(ctcp,0),"SDLNet_GenericSocket_") + ctcps <- c(ctcps, ctcp) + csocks <- c(csocks, csock) + if ( SDLNet_AddSocket(sockets, csock) == -1 ) { + cat("warning: add socket failed\n") + } + } + numready <- numready - 1 + } + while(numready) { + i <- 1 + for(i in 1:length(csocks)) { + csock <- csocks[[i]] + if(csock$ready) { + cat("client ready") + numready <- numready - 1 + buf <- raw(1000) + result <- SDLNet_TCP_Recv(ctcps[[i]], buf, length(buf)) + if (result <= 0) { + cat("ERROR: SDLNet_TCP_Recv result <= 0.\n") + } else { + buf[result] <- as.raw(0) + txt <- ptr2str(offsetPtr(buf,0)) + cat("DATA:'",txt,"'\n") + + tryCatch({ + m <- map(db,txt,plot=FALSE) + world <<- m + drawMap3d(world) + },error= function(x) {}) + } + } + } + } + } + SDL_Delay(20) + } +} +init() +loop() +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/sqrt.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,8 @@ +# Package: rdyncall +# File: demo/sqrt.R +# Description: C math library demo (dynbind demo) + +dynbind( c("msvcrt","m","m.so.6"), "sqrt(d)d;" ) +print(sqrt) +sqrt(144) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/stdio.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,31 @@ +# Package: rdyncall +# File: demo/stdio.R +# Description: Direct I/O of R raw vectors using C stdio functions + +dynport(stdio) + +# test: fopen returns NULL pointer on error + +nonexisting <- "dummyname" +f <- fopen(nonexisting, "r") +is.nullptr(f) + +# test: R raw object read/write + +tempfile <- "bla" +f <- fopen(tempfile, "wb") +writebuf <- as.raw(0:255) +copy <- writebuf +copy[[1]] <- as.raw(0xFF) +fwrite(writebuf, 1, length(writebuf), f) +fclose(f) + +f <- fopen(tempfile, "rb") +readbuf <- raw(256) +copybuf <- readbuf +fread(readbuf, 1, length(readbuf), f) +copybuf[[1]] <- as.raw(0xFF) +fclose(f) + +identical(readbuf,writebuf) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/demo/ttf.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,92 @@ +# Package: rdyncall +# File: demo/ttf.R +# Description: TrueType Font loading and drawing via SDL and SDL_ttf. + +dynport(SDL_ttf) + +fbSurf <- NULL +textSurf <- NULL + +numTexts <- 10 + +init <- function() +{ + status <- TTF_Init() + + if (status != 0) { + stop(paste("TTF_Init failed: ", TTF_GetError(), sep="")) + } + + # tryPaths <- c("/Library/Fonts","/usr/X11R7","/usr/X11R6") + # tryFonts <- c("Sathu.ttf", "Vera.ttf") + + font <- TTF_OpenFont("/usr/X11R7/lib/X11/fonts/TTF/Vera.ttf",48) + # Library/Fonts/Sathu.ttf",48) + if (is.nullptr(font)) { + stop(paste("TTF_OpenFont failed: ", TTF_GetError(), sep="")) + } + + color <- new.struct(SDL_Color) + color$r <- color$g <- color$b <- 255 + textSurf <<- TTF_RenderText_Solid(font, "Hello World.") + + SDL_Init(SDL_INIT_VIDEO) + fbSurf <<- SDL_SetVideoMode(256,256,32,SDL_DOUBLEBUF) + + displace <<- rnorm(numTexts*2) +} + +main <- function() +{ + + rect <- new.struct(SDL_Rect) + + rect$x <- 0 + rect$y <- 0 + rect$w <- textSurf$w + rect$h <- textSurf$h + + rect2 <- rect + + evt <- new.struct(SDL_Event) + + quit <- FALSE + + distance <- 0 + + while(!quit) { + + SDL_FillRect(fbSurf, as.struct( as.extptr(NULL), "SDL_Rect" ), 0xFFFFFFL) + rect + i <- 1 + while(i < numTexts*2) { + rect2$x <- rect$x + distance * displace[i] + rect2$y <- rect$y + distance * displace[i+1] + i <- i + 2 + SDL_BlitSurface(textSurf, as.struct(as.extptr(NULL),"SDL_Rect"),fbSurf,rect2) + } + SDL_Flip(fbSurf) + + distance <- distance + 1 + + while ( SDL_PollEvent(evt) ) { + if ( evt$type == SDL_QUIT ) + quit <- TRUE + else if (evt$type == SDL_MOUSEBUTTONDOWN ) { + rect$x <- evt$button$x + rect$y <- evt$button$y + distance <- 0 + } + } + + } + +} + +run <- function() +{ + init() + main() +} + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/doc/ANNOUNCEMENT.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,284 @@ +Initial Announcement: Package rdyncall released on CRAN. (Version 0.7.3) + +Short Introduction +------------------ +The package facilities dynamic R bindings to the C interface of some common +shared libraries and a flexible Foreign Function Interface for the +interoperability between R and C. + +Since the initial presentation of the package at Use!R 2009, a number of +improvements have been done to rdyncall, the low-level DynCall libraries +and the build system for an official release on CRAN. + +Overview +-------- +The package comprises a toolkit to work with C interfaces to native code from +within the dynamic R interpreter without the need for C wrapper compilation: + + - Dynamic R bindings to some common C shared libraries, across platforms. + - Foreign Function Interface that supports almost all C arg/return types + and has built-in type-checking facility. + - Portable naming and loading of shared libraries across platforms. + - Handling of aggregate C struct and union data types. + - Wrapping of R functions as C callbacks. + - Binding of C functions to R in batches. + +The intended audience for this package are developers experienced with C, that + + .. need complete R bindings of C libraries. + .. want to write cross-platform portable system-level code in R. + .. need a FFI that supports almost all C fundamental types for arguments + and return types and thus does not need compilation of wrapper C code + .. want to work with C struct/union types directly in R + .. are interested in dynamic binding techniques between static and dynamic + languages and cross-platform binding strategies. + + +Brief Tour 1/2: Dynamic R Bindings to C Libraries +------------------------------------------------- + +The dynamic binding interface consists of a single function, similar to +'library' or 'require': + + > dynport(portname) + +portname refers to a 'DynPort' file name that represents an R binding to a +common C interface and library. +The function the above has the side effect of attaching a newly created R name +space, populated with thin R helper objects to C entities of the underlying +C library: + + - call wrapper to C functions + - symbolic constants of C macros and enums, + - type information objects for C struct and union data types. + +The package contains a repository of the following DynPort files: + + Port Name | Description of C Shared Library/API + ------------+------------------------------------------------- + expat | Expat XML Parser Library + GL | OpenGL 1.1 API + GLU | OpenGL Utility Library + SDL | Simple DirectMedia Layer library + SDL_image | Loading of image files (png,jpeg..) + SDL_mixer | Loading/Playing of ogg/mp3/mod music files. + SDL_ttf | Loading/Rendering of True Type Fonts. + glew | OpenGL Extension Wrangler (includes OpenGL 3.0) + gl3 | strict OpenGL 3 (untested) + R | R shared library + ode | Open Dynamics (Physics-) Engine (untested) + cuda | NVIDIA Cuda (untested) + opencl | OpenCL (untested) + stdio | C Standard Library I/O Functions + +In order to use a DynPort on a host system, the shared C libraries +need to be installed first. + +See manual page on 'rdyncall-demos' (type ?'rdyncall-demos') for a detailed +description of the installation notes for several libraries the above, +collected for a large range of operating-systems and OS distributions. + +Since the rdyncall package is alredy ported across major R platforms, code +that uses a DynPort can run cross-platform without compilation. + +Here is a small example for using the SDL and OpenGL for multimedia/3D: + +-- snip + +# load SDL and OpenGL bindings +dynport(SDL) +dynport(GL) + +# initialize video sub-system +SDL_Init(SDL_INIT_VIDEO) + +# open double-buffered OpenGL window surface +surface <- SDL_SetVideoMode(640,480,32,SDL_OPENGL+SDL_DOUBLEBUF) + +# print dimension by accessing fields external C pointer to struct SDL_Surface +print( paste("dimenstion:", surface$w, "x", surface$h )) + +# clear buffer +glClearColor(0.3,0.6,0.8,0) +glClear(GL_COLOR_BUFFER_BIT) + +# update display +SDL_GL_SwapBuffers() + +-- snap + +A more detailed version including user-interface handling is available +in 'demo(SDL)'. + + +Brief Tour 2/2: Alternative FFI via '.dyncall' +---------------------------------------------- + +The alternative foreign function interface offered by '.dyncal' has a similar +intend such as '.C'. It allows to call shared library functions directly from R, +but without additional wrapper C code needed, because it supports almost all +fundamental C data types and uses a function type signature text specification +for type-checking and flexible conversions between R and C values. + +The interface is as following: + + > .dyncall(address, signature, ...) + +'signature' is a character string that encodes the arguments and return-type of +a C function. +Here is an example of C function from the OpenGL API: + + void glClearColor(float red, float green, float blue, float alpha); + +one would specify the function type via "ffff)v" as type signature and +pass additional arguments for '...': + + > .dyncall(addressOf_glClearColor, "ffff)v", 0.3,0.7,1,0) + +Support for pointers (low-level void and typed pointers to struct/union) and +wrapping of R functions to first-level C function pointers is also available. + +-- snip + +# load C math library across major platforms (Windows,Mac OS X,Linux) +mathlib <- dynfind(c("msvcrt","m","m.so.6")) + +# resolve symbol 'sqrt' +x <- .dynsym(mathlib,"sqrt") + +# C function call 'double sqrt(double x)' with x=144 +.dyncall(x, "d)d", 144) + +# .dyncall uses complex mapping of types, same works with 'integer' argument: +.dyncall(x, "d)d", 144L) + +-- snap + + +Implementation Details +---------------------- + +This package contains low-level services related to the generic invocation +of machine-code functions using official calling convention specifications +as the binary interface. A similar service exists for the oppositve direction +in order to write R functions and wrap them as first-level C function callback +pointers. + +The implementation is based on libraries from the DynCall Project that +implement a small amount of code in Assembly and have to play closely +together with the calling conventions of various processor-architectures and +platforms. +The implementation can be tricky has to be done on a calling-convention +basis. The efforts legitimate this non-portsble approach due to a +very small code size and a generic machine-call solution designed for +dynamic interpreters. (total size of shared lib object in rdyncall is ~60kb ) + + +Portability and Platforms +------------------------- + +A large set of platforms and calling conventions are already supported and a +suite of testing tools ensure a stable implementation at low-level. + +Processor-Architectures: +- Intel i386 32-bit and AMD 64-bit Platforms +- PowerPC 32-bit (support for callbacks on System V systems not yet implemented) +- ARM 32-bit (with support for Thumb) +- MIPS 32- and 64-bit (support for callbacks not yet implemented) +- SPARC 32-bit and 64-bit (support for callbacks not yet implemented) + +The DynCall libraries are tested on Linux, Mac OS X, Windows, BSD derivates, +Solaris and more exotic platforms such as game consoles, Plan9, Haiku and Minix. +The R Package has been tested on several major 32- and 64-bit R platforms +including Windows 32/64-bit, Linux (i386,amd64,ppc,arm), NetBSD (i386,amd64), +Solaris (i386,amd64). + +As of this release, no support for callbacks is available on MIPS or SPARC. +Callbacks on PowerPC 32-bit for Mac OS X work fine, for other +ELF/System V-based PowerPC systems, callbacks are not yet implemented. + + +Known Bugs +---------- + +* PowerPC/Mac OS X 10.4: Building Universal Binaries are broken.. in particular + the as for i386 assembler. + Workaround for PowerPC users: install with "--no-multiarch" or use prebuilt + binaries built on OS X >= 10.5. + +* SPARC Assembly sources are currently implemented for GNU assembler and do + not assemble using the 'fbe' Assembler tool on Solaris. + + +More Information +---------------- + +More demos and examples are in the package. +A 20-page vignette with the title "Foreign Library Interface" is available via + > vignette("FLI") + +A cross-platform audio/visual OpenGL-based demo-scene production +written in 100% pure R is available here: + + http://dyncall.org/demos/soulsalicious/ + +A video of demo is also at the website. + + +The website of the DynCall Project is at + + http://dyncall.org/ + + +Help and Feedback +----------------- +The package contains new methods for dynamic binding of native code to R +that were designed to work cross-platform. Thus the package required intensive +testing on a large range of processor/OS/tool-chain combinations. +It was (and still is!) also very helpful to run tests on different +'distributions' of the same OS for checking e.g. the search algorithm for +locating shared libraries by a short name across operating-systems +(see '?dynfind' for details on this). + +I am very thankful for any feedback including bug-reports, success and +failure stories or ideas of improvements. If you feel that an important +architecture, platform or build-tool is missing here please let me know too. + +The DynCall authors appreciate any support for porting the DynCall libraries +and the R package e.g. remote development accounts, qemu/gxemul images, +hardware. In particular we are currently looking for the following +arch/os/compilers environment for porting the DynCall libraries and rdyncall: + + - Sparc/Solaris/SunPro + - PowerPC/AIX/XL C + - MIPS/IRIX/MIPSpro + +If you can help us out, please get in contact us. + + +ChangeLog +--------- + +0.7.3: [2011-07-19] Added vignette, new ports, new tool-chain an fixes for bugs + o bugfix for Fedora/x64: added search path 'lib64' folder for 'dynfind'. + o added support for Sun make, DynCall uses Makefile.embedded. + o added sparc and sparc64 support using gcc tool-chain. + o added support for amd64 using solaris tool-chain. + o added vignette "foreign library interface". + o bugfix for solaris/x64: added search path 'amd64' folder for 'dynfind'. + o bugfix in examples for libm using 'm.so.6' besides 'm' on unix + (needed by debian 6 sid unstable) + +0.7.2: [2011-04-27] Minor fixes + o added win64/mingw64 support. + +0.7.1: [2011-04-26] Minor fixes + o minor Makevars fix for parallel builds. + +0.7.0: [2011-04-20] Initial Release + o first upload to CRAN. + + +enjoy, +- Daniel +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/EGL.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,173 @@ +dynbind("EGL"," +eglBindAPI(I)I; +eglBindTexImage(*v*vi)I; +eglChooseConfig(*v*i**vi*i)I; +eglCopyBuffers(*v*v*v)I; +eglCreateContext(*v*v*v*i)*v; +eglCreatePbufferFromClientBuffer(*vI*v*v*i)*v; +eglCreatePbufferSurface(*v*v*i)*v; +eglCreatePixmapSurface(*v*v*v*i)*v; +eglCreateWindowSurface(*v*vi*i)*v; +eglDestroyContext(*v*v)I; +eglDestroySurface(*v*v)I; +eglGetConfigAttrib(*v*vi*i)I; +eglGetConfigs(*v**vi*i)I; +eglGetCurrentContext()*v; +eglGetCurrentDisplay()*v; +eglGetCurrentSurface(i)*v; +eglGetDisplay(*v)*v; +eglGetError()i; +eglGetProcAddress(*c)*p; +eglInitialize(*v*i*i)I; +eglMakeCurrent(*v*v*v*v)I; +eglQueryAPI()I; +eglQueryContext(*v*vi*i)I; +eglQueryString(*vi)*c; +eglQuerySurface(*v*vi*i)I; +eglReleaseTexImage(*v*vi)I; +eglReleaseThread()I; +eglSurfaceAttrib(*v*vii)I; +eglSwapBuffers(*v*v)I; +eglSwapInterval(*vi)I; +eglTerminate(*v)I; +eglWaitClient()I; +eglWaitGL()I; +eglWaitNative(i)I; +") +EGL_ALPHA_MASK_SIZE=0x303E +EGL_ALPHA_SIZE=0x3021 +#EGLAPI= +#EGLAPIENTRY= +#EGLAPIENTRYP=EGLAPIENTRY * +EGL_BACK_BUFFER=0x3084 +EGL_BAD_ACCESS=0x3002 +EGL_BAD_ALLOC=0x3003 +EGL_BAD_ATTRIBUTE=0x3004 +EGL_BAD_CONFIG=0x3005 +EGL_BAD_CONTEXT=0x3006 +EGL_BAD_CURRENT_SURFACE=0x3007 +EGL_BAD_DISPLAY=0x3008 +EGL_BAD_MATCH=0x3009 +EGL_BAD_NATIVE_PIXMAP=0x300A +EGL_BAD_NATIVE_WINDOW=0x300B +EGL_BAD_PARAMETER=0x300C +EGL_BAD_SURFACE=0x300D +EGL_BIND_TO_TEXTURE_RGB=0x3039 +EGL_BIND_TO_TEXTURE_RGBA=0x303A +EGL_BLUE_SIZE=0x3022 +EGL_BUFFER_DESTROYED=0x3095 +EGL_BUFFER_PRESERVED=0x3094 +EGL_BUFFER_SIZE=0x3020 +EGL_CLIENT_APIS=0x308D +EGL_COLOR_BUFFER_TYPE=0x303F +EGL_CONFIG_CAVEAT=0x3027 +EGL_CONFIG_ID=0x3028 +EGL_CONFORMANT=0x3042 +EGL_CONTEXT_CLIENT_TYPE=0x3097 +EGL_CONTEXT_CLIENT_VERSION=0x3098 +EGL_CONTEXT_LOST=0x300E +EGL_CORE_NATIVE_ENGINE=0x305B +#EGL_DEFAULT_DISPLAY=((EGLNativeDisplayType)0) +EGL_DEFAULT_DISPLAY=0 +EGL_DEPTH_SIZE=0x3025 +EGL_DISPLAY_SCALING=10000 +#EGL_DONT_CARE=((EGLint)-1) +EGL_DONT_CARE=-1 +EGL_DRAW=0x3059 +EGL_EXTENSIONS=0x3055 +EGL_FALSE=0 +EGL_GREEN_SIZE=0x3023 +EGL_HEIGHT=0x3056 +EGL_HORIZONTAL_RESOLUTION=0x3090 +EGL_LARGEST_PBUFFER=0x3058 +EGL_LEVEL=0x3029 +EGL_LUMINANCE_BUFFER=0x308F +EGL_LUMINANCE_SIZE=0x303D +EGL_MATCH_NATIVE_PIXMAP=0x3041 +EGL_MAX_PBUFFER_HEIGHT=0x302A +EGL_MAX_PBUFFER_PIXELS=0x302B +EGL_MAX_PBUFFER_WIDTH=0x302C +EGL_MAX_SWAP_INTERVAL=0x303C +EGL_MIN_SWAP_INTERVAL=0x303B +EGL_MIPMAP_LEVEL=0x3083 +EGL_MIPMAP_TEXTURE=0x3082 +EGL_MULTISAMPLE_RESOLVE=0x3099 +EGL_MULTISAMPLE_RESOLVE_BOX=0x309B +EGL_MULTISAMPLE_RESOLVE_BOX_BIT=0x0200 +EGL_MULTISAMPLE_RESOLVE_DEFAULT=0x309A +EGL_NATIVE_RENDERABLE=0x302D +EGL_NATIVE_VISUAL_ID=0x302E +EGL_NATIVE_VISUAL_TYPE=0x302F +#EGL_NO_CONTEXT=((EGLContext)0) +#EGL_NO_DISPLAY=((EGLDisplay)0) +EGL_NO_CONTEXT=0 +EGL_NO_DISPLAY=0 +EGL_NON_CONFORMANT_CONFIG=0x3051 +EGL_NONE=0x3038 +#EGL_NO_SURFACE=((EGLSurface)0) +EGL_NO_SURFACE=0 +EGL_NO_TEXTURE=0x305C +EGL_NOT_INITIALIZED=0x3001 +EGL_OPENGL_API=0x30A2 +EGL_OPENGL_BIT=0x0008 +EGL_OPENGL_ES2_BIT=0x0004 +EGL_OPENGL_ES_API=0x30A0 +EGL_OPENGL_ES_BIT=0x0001 +EGL_OPENVG_API=0x30A1 +EGL_OPENVG_BIT=0x0002 +EGL_OPENVG_IMAGE=0x3096 +EGL_PBUFFER_BIT=0x0001 +EGL_PIXEL_ASPECT_RATIO=0x3092 +EGL_PIXMAP_BIT=0x0002 +EGL_PRESERVED_RESOURCES=0x3030 +EGL_READ=0x305A +EGL_RED_SIZE=0x3024 +EGL_RENDERABLE_TYPE=0x3040 +EGL_RENDER_BUFFER=0x3086 +EGL_RGB_BUFFER=0x308E +EGL_SAMPLE_BUFFERS=0x3032 +EGL_SAMPLES=0x3031 +EGL_SINGLE_BUFFER=0x3085 +EGL_SLOW_CONFIG=0x3050 +EGL_STENCIL_SIZE=0x3026 +EGL_SUCCESS=0x3000 +EGL_SURFACE_TYPE=0x3033 +EGL_SWAP_BEHAVIOR=0x3093 +EGL_SWAP_BEHAVIOR_PRESERVED_BIT=0x0400 +EGL_TEXTURE_2D=0x305F +EGL_TEXTURE_FORMAT=0x3080 +EGL_TEXTURE_RGB=0x305D +EGL_TEXTURE_RGBA=0x305E +EGL_TEXTURE_TARGET=0x3081 +EGL_TRANSPARENT_BLUE_VALUE=0x3035 +EGL_TRANSPARENT_GREEN_VALUE=0x3036 +EGL_TRANSPARENT_RED_VALUE=0x3037 +EGL_TRANSPARENT_RGB=0x3052 +EGL_TRANSPARENT_TYPE=0x3034 +EGL_TRUE=1 +#EGL_UNKNOWN=((EGLint)-1) +EGL_UNKNOWN=-1 +EGL_VENDOR=0x3053 +EGL_VERSION=0x3054 +EGL_VERSION_1_0=1 +EGL_VERSION_1_1=1 +EGL_VERSION_1_2=1 +EGL_VERSION_1_3=1 +EGL_VERSION_1_4=1 +EGL_VERTICAL_RESOLUTION=0x3091 +EGL_VG_ALPHA_FORMAT=0x3088 +EGL_VG_ALPHA_FORMAT_NONPRE=0x308B +EGL_VG_ALPHA_FORMAT_PRE=0x308C +EGL_VG_ALPHA_FORMAT_PRE_BIT=0x0040 +EGL_VG_COLORSPACE=0x3087 +EGL_VG_COLORSPACE_LINEAR=0x308A +EGL_VG_COLORSPACE_LINEAR_BIT=0x0020 +EGL_VG_COLORSPACE_sRGB=0x3089 +EGL_WIDTH=0x3057 +EGL_WINDOW_BIT=0x0004 +EGL_COLORSPACE=EGL_VG_COLORSPACE +EGL_COLORSPACE_LINEAR=EGL_VG_COLORSPACE_LINEAR +EGL_COLORSPACE_sRGB=EGL_VG_COLORSPACE_sRGB +EGL_ALPHA_FORMAT=EGL_VG_ALPHA_FORMAT +EGL_ALPHA_FORMAT_NONPRE=EGL_VG_ALPHA_FORMAT_NONPRE +EGL_ALPHA_FORMAT_PRE=EGL_VG_ALPHA_FORMAT_PRE
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/GL.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,3592 @@ +dynbind(c("OPENGL32","OpenGL","GL","GL.so.1"),callmode="stdcall"," +glAccum(If)v; +glAlphaFunc(If)v; +glAreTexturesResident(i*I*C)C; +glArrayElement(i)v; +glBegin(I)v; +glBindTexture(II)v; +glBitmap(iiffff*C)v; +glBlendFunc(II)v; +glCallList(I)v; +glCallLists(iI*v)v; +glClear(I)v; +glClearAccum(ffff)v; +glClearColor(ffff)v; +glClearDepth(d)v; +glClearIndex(f)v; +glClearStencil(i)v; +glClipPlane(I*d)v; +glColor3b(ccc)v; +glColor3bv(*c)v; +glColor3d(ddd)v; +glColor3dv(*d)v; +glColor3f(fff)v; +glColor3fv(*f)v; +glColor3i(iii)v; +glColor3iv(*i)v; +glColor3s(sss)v; +glColor3sv(*s)v; +glColor3ub(CCC)v; +glColor3ubv(*C)v; +glColor3ui(III)v; +glColor3uiv(*I)v; +glColor3us(SSS)v; +glColor3usv(*S)v; +glColor4b(cccc)v; +glColor4bv(*c)v; +glColor4d(dddd)v; +glColor4dv(*d)v; +glColor4f(ffff)v; +glColor4fv(*f)v; +glColor4i(iiii)v; +glColor4iv(*i)v; +glColor4s(ssss)v; +glColor4sv(*s)v; +glColor4ub(CCCC)v; +glColor4ubv(*C)v; +glColor4ui(IIII)v; +glColor4uiv(*I)v; +glColor4us(SSSS)v; +glColor4usv(*S)v; +glColorMask(CCCC)v; +glColorMaterial(II)v; +glColorPointer(iIi*v)v; +glCopyPixels(iiiiI)v; +glCopyTexImage1D(IiIiiii)v; +glCopyTexImage2D(IiIiiiii)v; +glCopyTexSubImage1D(Iiiiii)v; +glCopyTexSubImage2D(Iiiiiiii)v; +glCullFace(I)v; +glDeleteLists(Ii)v; +glDeleteTextures(i*I)v; +glDepthFunc(I)v; +glDepthMask(C)v; +glDepthRange(dd)v; +glDisable(I)v; +glDisableClientState(I)v; +glDrawArrays(Iii)v; +glDrawBuffer(I)v; +glDrawElements(IiI*v)v; +glDrawPixels(iiII*v)v; +glEdgeFlag(C)v; +glEdgeFlagPointer(i*v)v; +glEdgeFlagv(*C)v; +glEnable(I)v; +glEnableClientState(I)v; +glEnd()v; +glEndList()v; +glEvalCoord1d(d)v; +glEvalCoord1dv(*d)v; +glEvalCoord1f(f)v; +glEvalCoord1fv(*f)v; +glEvalCoord2d(dd)v; +glEvalCoord2dv(*d)v; +glEvalCoord2f(ff)v; +glEvalCoord2fv(*f)v; +glEvalMesh1(Iii)v; +glEvalMesh2(Iiiii)v; +glEvalPoint1(i)v; +glEvalPoint2(ii)v; +glFeedbackBuffer(iI*f)v; +glFinish()v; +glFlush()v; +glFogf(If)v; +glFogfv(I*f)v; +glFogi(Ii)v; +glFogiv(I*i)v; +glFrontFace(I)v; +glFrustum(dddddd)v; +glGenLists(i)I; +glGenTextures(i*I)v; +glGetBooleanv(I*C)v; +glGetClipPlane(I*d)v; +glGetDoublev(I*d)v; +glGetError()I; +glGetFloatv(I*f)v; +glGetIntegerv(I*i)v; +glGetLightfv(II*f)v; +glGetLightiv(II*i)v; +glGetMapdv(II*d)v; +glGetMapfv(II*f)v; +glGetMapiv(II*i)v; +glGetMaterialfv(II*f)v; +glGetMaterialiv(II*i)v; +glGetPixelMapfv(I*f)v; +glGetPixelMapuiv(I*I)v; +glGetPixelMapusv(I*S)v; +glGetPointerv(I*)v; +glGetPolygonStipple(*C)v; +glGetString(I)*C; +glGetTexEnvfv(II*f)v; +glGetTexEnviv(II*i)v; +glGetTexGendv(II*d)v; +glGetTexGenfv(II*f)v; +glGetTexGeniv(II*i)v; +glGetTexImage(IiII*v)v; +glGetTexLevelParameterfv(IiI*f)v; +glGetTexLevelParameteriv(IiI*i)v; +glGetTexParameterfv(II*f)v; +glGetTexParameteriv(II*i)v; +glHint(II)v; +glIndexMask(I)v; +glIndexPointer(Ii*v)v; +glIndexd(d)v; +glIndexdv(*d)v; +glIndexf(f)v; +glIndexfv(*f)v; +glIndexi(i)v; +glIndexiv(*i)v; +glIndexs(s)v; +glIndexsv(*s)v; +glIndexub(C)v; +glIndexubv(*C)v; +glInitNames()v; +glInterleavedArrays(Ii*v)v; +glIsEnabled(I)C; +glIsList(I)C; +glIsTexture(I)C; +glLightModelf(If)v; +glLightModelfv(I*f)v; +glLightModeli(Ii)v; +glLightModeliv(I*i)v; +glLightf(IIf)v; +glLightfv(II*f)v; +glLighti(IIi)v; +glLightiv(II*i)v; +glLineStipple(iS)v; +glLineWidth(f)v; +glListBase(I)v; +glLoadIdentity()v; +glLoadMatrixd(*d)v; +glLoadMatrixf(*f)v; +glLoadName(I)v; +glLogicOp(I)v; +glMap1d(Iddii*d)v; +glMap1f(Iffii*f)v; +glMap2d(Iddiiddii*d)v; +glMap2f(Iffiiffii*f)v; +glMapGrid1d(idd)v; +glMapGrid1f(iff)v; +glMapGrid2d(iddidd)v; +glMapGrid2f(iffiff)v; +glMaterialf(IIf)v; +glMaterialfv(II*f)v; +glMateriali(IIi)v; +glMaterialiv(II*i)v; +glMatrixMode(I)v; +glMultMatrixd(*d)v; +glMultMatrixf(*f)v; +glNewList(II)v; +glNormal3b(ccc)v; +glNormal3bv(*c)v; +glNormal3d(ddd)v; +glNormal3dv(*d)v; +glNormal3f(fff)v; +glNormal3fv(*f)v; +glNormal3i(iii)v; +glNormal3iv(*i)v; +glNormal3s(sss)v; +glNormal3sv(*s)v; +glNormalPointer(Ii*v)v; +glOrtho(dddddd)v; +glPassThrough(f)v; +glPixelMapfv(Ii*f)v; +glPixelMapuiv(Ii*I)v; +glPixelMapusv(Ii*S)v; +glPixelStoref(If)v; +glPixelStorei(Ii)v; +glPixelTransferf(If)v; +glPixelTransferi(Ii)v; +glPixelZoom(ff)v; +glPointSize(f)v; +glPolygonMode(II)v; +glPolygonOffset(ff)v; +glPolygonStipple(*C)v; +glPopAttrib()v; +glPopClientAttrib()v; +glPopMatrix()v; +glPopName()v; +glPrioritizeTextures(i*I*f)v; +glPushAttrib(I)v; +glPushClientAttrib(I)v; +glPushMatrix()v; +glPushName(I)v; +glRasterPos2d(dd)v; +glRasterPos2dv(*d)v; +glRasterPos2f(ff)v; +glRasterPos2fv(*f)v; +glRasterPos2i(ii)v; +glRasterPos2iv(*i)v; +glRasterPos2s(ss)v; +glRasterPos2sv(*s)v; +glRasterPos3d(ddd)v; +glRasterPos3dv(*d)v; +glRasterPos3f(fff)v; +glRasterPos3fv(*f)v; +glRasterPos3i(iii)v; +glRasterPos3iv(*i)v; +glRasterPos3s(sss)v; +glRasterPos3sv(*s)v; +glRasterPos4d(dddd)v; +glRasterPos4dv(*d)v; +glRasterPos4f(ffff)v; +glRasterPos4fv(*f)v; +glRasterPos4i(iiii)v; +glRasterPos4iv(*i)v; +glRasterPos4s(ssss)v; +glRasterPos4sv(*s)v; +glReadBuffer(I)v; +glReadPixels(iiiiII*v)v; +glRectd(dddd)v; +glRectdv(*d*d)v; +glRectf(ffff)v; +glRectfv(*f*f)v; +glRecti(iiii)v; +glRectiv(*i*i)v; +glRects(ssss)v; +glRectsv(*s*s)v; +glRenderMode(I)i; +glRotated(dddd)v; +glRotatef(ffff)v; +glScaled(ddd)v; +glScalef(fff)v; +glScissor(iiii)v; +glSelectBuffer(i*I)v; +glShadeModel(I)v; +glStencilFunc(IiI)v; +glStencilMask(I)v; +glStencilOp(III)v; +glTexCoord1d(d)v; +glTexCoord1dv(*d)v; +glTexCoord1f(f)v; +glTexCoord1fv(*f)v; +glTexCoord1i(i)v; +glTexCoord1iv(*i)v; +glTexCoord1s(s)v; +glTexCoord1sv(*s)v; +glTexCoord2d(dd)v; +glTexCoord2dv(*d)v; +glTexCoord2f(ff)v; +glTexCoord2fv(*f)v; +glTexCoord2i(ii)v; +glTexCoord2iv(*i)v; +glTexCoord2s(ss)v; +glTexCoord2sv(*s)v; +glTexCoord3d(ddd)v; +glTexCoord3dv(*d)v; +glTexCoord3f(fff)v; +glTexCoord3fv(*f)v; +glTexCoord3i(iii)v; +glTexCoord3iv(*i)v; +glTexCoord3s(sss)v; +glTexCoord3sv(*s)v; +glTexCoord4d(dddd)v; +glTexCoord4dv(*d)v; +glTexCoord4f(ffff)v; +glTexCoord4fv(*f)v; +glTexCoord4i(iiii)v; +glTexCoord4iv(*i)v; +glTexCoord4s(ssss)v; +glTexCoord4sv(*s)v; +glTexCoordPointer(iIi*v)v; +glTexEnvf(IIf)v; +glTexEnvfv(II*f)v; +glTexEnvi(IIi)v; +glTexEnviv(II*i)v; +glTexGend(IId)v; +glTexGendv(II*d)v; +glTexGenf(IIf)v; +glTexGenfv(II*f)v; +glTexGeni(IIi)v; +glTexGeniv(II*i)v; +glTexImage1D(IiiiiII*v)v; +glTexImage2D(IiiiiiII*v)v; +glTexParameterf(IIf)v; +glTexParameterfv(II*f)v; +glTexParameteri(IIi)v; +glTexParameteriv(II*i)v; +glTexSubImage1D(IiiiII*v)v; +glTexSubImage2D(IiiiiiII*v)v; +glTranslated(ddd)v; +glTranslatef(fff)v; +glVertex2d(dd)v; +glVertex2dv(*d)v; +glVertex2f(ff)v; +glVertex2fv(*f)v; +glVertex2i(ii)v; +glVertex2iv(*i)v; +glVertex2s(ss)v; +glVertex2sv(*s)v; +glVertex3d(ddd)v; +glVertex3dv(*d)v; +glVertex3f(fff)v; +glVertex3fv(*f)v; +glVertex3i(iii)v; +glVertex3iv(*i)v; +glVertex3s(sss)v; +glVertex3sv(*s)v; +glVertex4d(dddd)v; +glVertex4dv(*d)v; +glVertex4f(ffff)v; +glVertex4fv(*f)v; +glVertex4i(iiii)v; +glVertex4iv(*i)v; +glVertex4s(ssss)v; +glVertex4sv(*s)v; +glVertexPointer(iIi*v)v; +glViewport(iiii)v; +") +GLEXT_64_TYPES_DEFINED= +GL_1PASS_EXT=0x80A1 +GL_1PASS_SGIS=0x80A1 +GL_2D=0x0600 +GL_2PASS_0_EXT=0x80A2 +GL_2PASS_0_SGIS=0x80A2 +GL_2PASS_1_EXT=0x80A3 +GL_2PASS_1_SGIS=0x80A3 +GL_2X_BIT_ATI=0x00000001 +GL_2_BYTES=0x1407 +GL_3D=0x0601 +GL_3DFX_multisample=1 +GL_3DFX_tbuffer=1 +GL_3DFX_texture_compression_FXT1=1 +GL_3D_COLOR=0x0602 +GL_3D_COLOR_TEXTURE=0x0603 +GL_3_BYTES=0x1408 +GL_422_AVERAGE_EXT=0x80CE +GL_422_EXT=0x80CC +GL_422_REV_AVERAGE_EXT=0x80CF +GL_422_REV_EXT=0x80CD +GL_4D_COLOR_TEXTURE=0x0604 +GL_4PASS_0_EXT=0x80A4 +GL_4PASS_0_SGIS=0x80A4 +GL_4PASS_1_EXT=0x80A5 +GL_4PASS_1_SGIS=0x80A5 +GL_4PASS_2_EXT=0x80A6 +GL_4PASS_2_SGIS=0x80A6 +GL_4PASS_3_EXT=0x80A7 +GL_4PASS_3_SGIS=0x80A7 +GL_4X_BIT_ATI=0x00000002 +GL_4_BYTES=0x1409 +GL_8X_BIT_ATI=0x00000004 +GL_ABGR_EXT=0x8000 +GL_ACCUM=0x0100 +GL_ACCUM_ALPHA_BITS=0x0D5B +GL_ACCUM_BLUE_BITS=0x0D5A +GL_ACCUM_BUFFER_BIT=0x00000200 +GL_ACCUM_CLEAR_VALUE=0x0B80 +GL_ACCUM_GREEN_BITS=0x0D59 +GL_ACCUM_RED_BITS=0x0D58 +GL_ACTIVE_ATTRIBUTES=0x8B89 +GL_ACTIVE_ATTRIBUTE_MAX_LENGTH=0x8B8A +GL_ACTIVE_STENCIL_FACE_EXT=0x8911 +GL_ACTIVE_TEXTURE=0x84E0 +GL_ACTIVE_TEXTURE_ARB=0x84E0 +GL_ACTIVE_UNIFORMS=0x8B86 +GL_ACTIVE_UNIFORM_MAX_LENGTH=0x8B87 +GL_ACTIVE_VARYINGS_NV=0x8C81 +GL_ACTIVE_VARYING_MAX_LENGTH_NV=0x8C82 +GL_ACTIVE_VERTEX_UNITS_ARB=0x86A5 +GL_ADD=0x0104 +GL_ADD_ATI=0x8963 +GL_ADD_SIGNED=0x8574 +GL_ADD_SIGNED_ARB=0x8574 +GL_ADD_SIGNED_EXT=0x8574 +GL_ALIASED_LINE_WIDTH_RANGE=0x846E +GL_ALIASED_POINT_SIZE_RANGE=0x846D +GL_ALLOW_DRAW_FRG_HINT_PGI=0x1A210 +GL_ALLOW_DRAW_MEM_HINT_PGI=0x1A211 +GL_ALLOW_DRAW_OBJ_HINT_PGI=0x1A20E +GL_ALLOW_DRAW_WIN_HINT_PGI=0x1A20F +GL_ALL_ATTRIB_BITS=0xFFFFFFFF +GL_ALL_COMPLETED_NV=0x84F2 +GL_ALPHA12=0x803D +GL_ALPHA12_EXT=0x803D +GL_ALPHA16=0x803E +GL_ALPHA16F_ARB=0x881C +GL_ALPHA16I_EXT=0x8D8A +GL_ALPHA16UI_EXT=0x8D78 +GL_ALPHA16_EXT=0x803E +GL_ALPHA32F_ARB=0x8816 +GL_ALPHA32I_EXT=0x8D84 +GL_ALPHA32UI_EXT=0x8D72 +GL_ALPHA4=0x803B +GL_ALPHA4_EXT=0x803B +GL_ALPHA8=0x803C +GL_ALPHA8I_EXT=0x8D90 +GL_ALPHA8UI_EXT=0x8D7E +GL_ALPHA8_EXT=0x803C +GL_ALPHA=0x1906 +GL_ALPHA_BIAS=0x0D1D +GL_ALPHA_BITS=0x0D55 +GL_ALPHA_FLOAT16_ATI=0x881C +GL_ALPHA_FLOAT32_ATI=0x8816 +GL_ALPHA_INTEGER_EXT=0x8D97 +GL_ALPHA_MAX_CLAMP_INGR=0x8567 +GL_ALPHA_MAX_SGIX=0x8321 +GL_ALPHA_MIN_CLAMP_INGR=0x8563 +GL_ALPHA_MIN_SGIX=0x8320 +GL_ALPHA_SCALE=0x0D1C +GL_ALPHA_TEST=0x0BC0 +GL_ALPHA_TEST_FUNC=0x0BC1 +GL_ALPHA_TEST_REF=0x0BC2 +GL_ALWAYS=0x0207 +GL_ALWAYS_FAST_HINT_PGI=0x1A20C +GL_ALWAYS_SOFT_HINT_PGI=0x1A20D +GL_AMBIENT=0x1200 +GL_AMBIENT_AND_DIFFUSE=0x1602 +GL_AND=0x1501 +GL_AND_INVERTED=0x1504 +GL_AND_REVERSE=0x1502 +GL_APPLE_client_storage=1 +GL_APPLE_element_array=1 +GL_APPLE_fence=1 +GL_APPLE_flush_buffer_range=1 +GL_APPLE_specular_vector=1 +GL_APPLE_transform_hint=1 +GL_APPLE_vertex_array_object=1 +GL_APPLE_vertex_array_range=1 +GL_APPLE_ycbcr_422=1 +GL_ARB_color_buffer_float=1 +GL_ARB_depth_texture=1 +GL_ARB_draw_buffers=1 +GL_ARB_fragment_program=1 +GL_ARB_fragment_program_shadow=1 +GL_ARB_fragment_shader=1 +GL_ARB_half_float_pixel=1 +GL_ARB_matrix_palette=1 +GL_ARB_multisample=1 +GL_ARB_multitexture=1 +GL_ARB_occlusion_query=1 +GL_ARB_pixel_buffer_object=1 +GL_ARB_point_parameters=1 +GL_ARB_point_sprite=1 +GL_ARB_shader_objects=1 +GL_ARB_shading_language_100=1 +GL_ARB_shadow=1 +GL_ARB_shadow_ambient=1 +GL_ARB_texture_border_clamp=1 +GL_ARB_texture_compression=1 +GL_ARB_texture_cube_map=1 +GL_ARB_texture_env_add=1 +GL_ARB_texture_env_combine=1 +GL_ARB_texture_env_crossbar=1 +GL_ARB_texture_env_dot3=1 +GL_ARB_texture_float=1 +GL_ARB_texture_mirrored_repeat=1 +GL_ARB_texture_non_power_of_two=1 +GL_ARB_texture_rectangle=1 +GL_ARB_transpose_matrix=1 +GL_ARB_vertex_blend=1 +GL_ARB_vertex_buffer_object=1 +GL_ARB_vertex_program=1 +GL_ARB_vertex_shader=1 +GL_ARB_window_pos=1 +GL_ARRAY_BUFFER=0x8892 +GL_ARRAY_BUFFER_ARB=0x8892 +GL_ARRAY_BUFFER_BINDING=0x8894 +GL_ARRAY_BUFFER_BINDING_ARB=0x8894 +GL_ARRAY_ELEMENT_LOCK_COUNT_EXT=0x81A9 +GL_ARRAY_ELEMENT_LOCK_FIRST_EXT=0x81A8 +GL_ARRAY_OBJECT_BUFFER_ATI=0x8766 +GL_ARRAY_OBJECT_OFFSET_ATI=0x8767 +GL_ASYNC_DRAW_PIXELS_SGIX=0x835D +GL_ASYNC_HISTOGRAM_SGIX=0x832C +GL_ASYNC_MARKER_SGIX=0x8329 +GL_ASYNC_READ_PIXELS_SGIX=0x835E +GL_ASYNC_TEX_IMAGE_SGIX=0x835C +GL_ATI_draw_buffers=1 +GL_ATI_element_array=1 +GL_ATI_envmap_bumpmap=1 +GL_ATI_fragment_shader=1 +GL_ATI_map_object_buffer=1 +GL_ATI_pixel_format_float=1 +GL_ATI_pn_triangles=1 +GL_ATI_separate_stencil=1 +GL_ATI_text_fragment_shader=1 +GL_ATI_texture_env_combine3=1 +GL_ATI_texture_float=1 +GL_ATI_texture_mirror_once=1 +GL_ATI_vertex_array_object=1 +GL_ATI_vertex_attrib_array_object=1 +GL_ATI_vertex_streams=1 +GL_ATTACHED_SHADERS=0x8B85 +GL_ATTENUATION_EXT=0x834D +GL_ATTRIB_ARRAY_POINTER_NV=0x8645 +GL_ATTRIB_ARRAY_SIZE_NV=0x8623 +GL_ATTRIB_ARRAY_STRIDE_NV=0x8624 +GL_ATTRIB_ARRAY_TYPE_NV=0x8625 +GL_ATTRIB_STACK_DEPTH=0x0BB0 +GL_AUTO_NORMAL=0x0D80 +GL_AUX0=0x0409 +GL_AUX1=0x040A +GL_AUX2=0x040B +GL_AUX3=0x040C +GL_AUX_BUFFERS=0x0C00 +GL_AVERAGE_EXT=0x8335 +GL_AVERAGE_HP=0x8160 +GL_BACK=0x0405 +GL_BACK_LEFT=0x0402 +GL_BACK_NORMALS_HINT_PGI=0x1A223 +GL_BACK_PRIMARY_COLOR_NV=0x8C77 +GL_BACK_RIGHT=0x0403 +GL_BACK_SECONDARY_COLOR_NV=0x8C78 +GL_BGR=0x80E0 +GL_BGRA=0x80E1 +GL_BGRA_EXT=0x80E1 +GL_BGRA_INTEGER_EXT=0x8D9B +GL_BGR_EXT=0x80E0 +GL_BGR_INTEGER_EXT=0x8D9A +GL_BIAS_BIT_ATI=0x00000008 +GL_BIAS_BY_NEGATIVE_ONE_HALF_NV=0x8541 +GL_BINORMAL_ARRAY_EXT=0x843A +GL_BINORMAL_ARRAY_POINTER_EXT=0x8443 +GL_BINORMAL_ARRAY_STRIDE_EXT=0x8441 +GL_BINORMAL_ARRAY_TYPE_EXT=0x8440 +GL_BITMAP=0x1A00 +GL_BITMAP_TOKEN=0x0704 +GL_BLEND=0x0BE2 +GL_BLEND_COLOR=0x8005 +GL_BLEND_COLOR_EXT=0x8005 +GL_BLEND_DST=0x0BE0 +GL_BLEND_DST_ALPHA=0x80CA +GL_BLEND_DST_ALPHA_EXT=0x80CA +GL_BLEND_DST_RGB=0x80C8 +GL_BLEND_DST_RGB_EXT=0x80C8 +GL_BLEND_EQUATION=0x8009 +GL_BLEND_EQUATION_ALPHA=0x883D +GL_BLEND_EQUATION_ALPHA_EXT=0x883D +GL_BLEND_EQUATION_EXT=0x8009 +GL_BLEND_EQUATION_RGB=0x8009 +GL_BLEND_EQUATION_RGB_EXT=0x8009 +GL_BLEND_SRC=0x0BE1 +GL_BLEND_SRC_ALPHA=0x80CB +GL_BLEND_SRC_ALPHA_EXT=0x80CB +GL_BLEND_SRC_RGB=0x80C9 +GL_BLEND_SRC_RGB_EXT=0x80C9 +GL_BLUE=0x1905 +GL_BLUE_BIAS=0x0D1B +GL_BLUE_BITS=0x0D54 +GL_BLUE_BIT_ATI=0x00000004 +GL_BLUE_INTEGER_EXT=0x8D96 +GL_BLUE_MAX_CLAMP_INGR=0x8566 +GL_BLUE_MIN_CLAMP_INGR=0x8562 +GL_BLUE_SCALE=0x0D1A +GL_BOOL=0x8B56 +GL_BOOL_ARB=0x8B56 +GL_BOOL_VEC2=0x8B57 +GL_BOOL_VEC2_ARB=0x8B57 +GL_BOOL_VEC3=0x8B58 +GL_BOOL_VEC3_ARB=0x8B58 +GL_BOOL_VEC4=0x8B59 +GL_BOOL_VEC4_ARB=0x8B59 +GL_BUFFER_ACCESS=0x88BB +GL_BUFFER_ACCESS_ARB=0x88BB +GL_BUFFER_FLUSHING_UNMAP_APPLE=0x8A13 +GL_BUFFER_MAPPED=0x88BC +GL_BUFFER_MAPPED_ARB=0x88BC +GL_BUFFER_MAP_POINTER=0x88BD +GL_BUFFER_MAP_POINTER_ARB=0x88BD +GL_BUFFER_SERIALIZED_MODIFY_APPLE=0x8A12 +GL_BUFFER_SIZE=0x8764 +GL_BUFFER_SIZE_ARB=0x8764 +GL_BUFFER_USAGE=0x8765 +GL_BUFFER_USAGE_ARB=0x8765 +GL_BUMP_ENVMAP_ATI=0x877B +GL_BUMP_NUM_TEX_UNITS_ATI=0x8777 +GL_BUMP_ROT_MATRIX_ATI=0x8775 +GL_BUMP_ROT_MATRIX_SIZE_ATI=0x8776 +GL_BUMP_TARGET_ATI=0x877C +GL_BUMP_TEX_UNITS_ATI=0x8778 +GL_BYTE=0x1400 +GL_C3F_V3F=0x2A24 +GL_C4F_N3F_V3F=0x2A26 +GL_C4UB_V2F=0x2A22 +GL_C4UB_V3F=0x2A23 +GL_CALLIGRAPHIC_FRAGMENT_SGIX=0x8183 +GL_CCW=0x0901 +GL_CLAMP=0x2900 +GL_CLAMP_FRAGMENT_COLOR_ARB=0x891B +GL_CLAMP_READ_COLOR_ARB=0x891C +GL_CLAMP_TO_BORDER=0x812D +GL_CLAMP_TO_BORDER_ARB=0x812D +GL_CLAMP_TO_BORDER_SGIS=0x812D +GL_CLAMP_TO_EDGE=0x812F +GL_CLAMP_TO_EDGE_SGIS=0x812F +GL_CLAMP_VERTEX_COLOR_ARB=0x891A +GL_CLEAR=0x1500 +GL_CLIENT_ACTIVE_TEXTURE=0x84E1 +GL_CLIENT_ACTIVE_TEXTURE_ARB=0x84E1 +GL_CLIENT_ALL_ATTRIB_BITS=0xFFFFFFFF +GL_CLIENT_ATTRIB_STACK_DEPTH=0x0BB1 +GL_CLIENT_PIXEL_STORE_BIT=0x00000001 +GL_CLIENT_VERTEX_ARRAY_BIT=0x00000002 +GL_CLIP_DISTANCE_NV=0x8C7A +GL_CLIP_FAR_HINT_PGI=0x1A221 +GL_CLIP_NEAR_HINT_PGI=0x1A220 +GL_CLIP_PLANE0=0x3000 +GL_CLIP_PLANE1=0x3001 +GL_CLIP_PLANE2=0x3002 +GL_CLIP_PLANE3=0x3003 +GL_CLIP_PLANE4=0x3004 +GL_CLIP_PLANE5=0x3005 +GL_CLIP_VOLUME_CLIPPING_HINT_EXT=0x80F0 +GL_CMYKA_EXT=0x800D +GL_CMYK_EXT=0x800C +GL_CND0_ATI=0x896B +GL_CND_ATI=0x896A +GL_COEFF=0x0A00 +GL_COLOR3_BIT_PGI=0x00010000 +GL_COLOR4_BIT_PGI=0x00020000 +GL_COLOR=0x1800 +GL_COLOR_ALPHA_PAIRING_ATI=0x8975 +GL_COLOR_ARRAY=0x8076 +GL_COLOR_ARRAY_BUFFER_BINDING=0x8898 +GL_COLOR_ARRAY_BUFFER_BINDING_ARB=0x8898 +GL_COLOR_ARRAY_COUNT_EXT=0x8084 +GL_COLOR_ARRAY_EXT=0x8076 +GL_COLOR_ARRAY_LIST_IBM=103072 +GL_COLOR_ARRAY_LIST_STRIDE_IBM=103082 +GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL=0x83F7 +GL_COLOR_ARRAY_POINTER=0x8090 +GL_COLOR_ARRAY_POINTER_EXT=0x8090 +GL_COLOR_ARRAY_SIZE=0x8081 +GL_COLOR_ARRAY_SIZE_EXT=0x8081 +GL_COLOR_ARRAY_STRIDE=0x8083 +GL_COLOR_ARRAY_STRIDE_EXT=0x8083 +GL_COLOR_ARRAY_TYPE=0x8082 +GL_COLOR_ARRAY_TYPE_EXT=0x8082 +GL_COLOR_ATTACHMENT0_EXT=0x8CE0 +GL_COLOR_ATTACHMENT10_EXT=0x8CEA +GL_COLOR_ATTACHMENT11_EXT=0x8CEB +GL_COLOR_ATTACHMENT12_EXT=0x8CEC +GL_COLOR_ATTACHMENT13_EXT=0x8CED +GL_COLOR_ATTACHMENT14_EXT=0x8CEE +GL_COLOR_ATTACHMENT15_EXT=0x8CEF +GL_COLOR_ATTACHMENT1_EXT=0x8CE1 +GL_COLOR_ATTACHMENT2_EXT=0x8CE2 +GL_COLOR_ATTACHMENT3_EXT=0x8CE3 +GL_COLOR_ATTACHMENT4_EXT=0x8CE4 +GL_COLOR_ATTACHMENT5_EXT=0x8CE5 +GL_COLOR_ATTACHMENT6_EXT=0x8CE6 +GL_COLOR_ATTACHMENT7_EXT=0x8CE7 +GL_COLOR_ATTACHMENT8_EXT=0x8CE8 +GL_COLOR_ATTACHMENT9_EXT=0x8CE9 +GL_COLOR_BUFFER_BIT=0x00004000 +GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI=0x8835 +GL_COLOR_CLEAR_VALUE=0x0C22 +GL_COLOR_INDEX12_EXT=0x80E6 +GL_COLOR_INDEX16_EXT=0x80E7 +GL_COLOR_INDEX1_EXT=0x80E2 +GL_COLOR_INDEX2_EXT=0x80E3 +GL_COLOR_INDEX4_EXT=0x80E4 +GL_COLOR_INDEX8_EXT=0x80E5 +GL_COLOR_INDEX=0x1900 +GL_COLOR_INDEXES=0x1603 +GL_COLOR_LOGIC_OP=0x0BF2 +GL_COLOR_MATERIAL=0x0B57 +GL_COLOR_MATERIAL_FACE=0x0B55 +GL_COLOR_MATERIAL_PARAMETER=0x0B56 +GL_COLOR_MATRIX=0x80B1 +GL_COLOR_MATRIX_SGI=0x80B1 +GL_COLOR_MATRIX_STACK_DEPTH=0x80B2 +GL_COLOR_MATRIX_STACK_DEPTH_SGI=0x80B2 +GL_COLOR_SUM=0x8458 +GL_COLOR_SUM_ARB=0x8458 +GL_COLOR_SUM_CLAMP_NV=0x854F +GL_COLOR_SUM_EXT=0x8458 +GL_COLOR_TABLE=0x80D0 +GL_COLOR_TABLE_ALPHA_SIZE=0x80DD +GL_COLOR_TABLE_ALPHA_SIZE_SGI=0x80DD +GL_COLOR_TABLE_BIAS=0x80D7 +GL_COLOR_TABLE_BIAS_SGI=0x80D7 +GL_COLOR_TABLE_BLUE_SIZE=0x80DC +GL_COLOR_TABLE_BLUE_SIZE_SGI=0x80DC +GL_COLOR_TABLE_FORMAT=0x80D8 +GL_COLOR_TABLE_FORMAT_SGI=0x80D8 +GL_COLOR_TABLE_GREEN_SIZE=0x80DB +GL_COLOR_TABLE_GREEN_SIZE_SGI=0x80DB +GL_COLOR_TABLE_INTENSITY_SIZE=0x80DF +GL_COLOR_TABLE_INTENSITY_SIZE_SGI=0x80DF +GL_COLOR_TABLE_LUMINANCE_SIZE=0x80DE +GL_COLOR_TABLE_LUMINANCE_SIZE_SGI=0x80DE +GL_COLOR_TABLE_RED_SIZE=0x80DA +GL_COLOR_TABLE_RED_SIZE_SGI=0x80DA +GL_COLOR_TABLE_SCALE=0x80D6 +GL_COLOR_TABLE_SCALE_SGI=0x80D6 +GL_COLOR_TABLE_SGI=0x80D0 +GL_COLOR_TABLE_WIDTH=0x80D9 +GL_COLOR_TABLE_WIDTH_SGI=0x80D9 +GL_COLOR_WRITEMASK=0x0C23 +GL_COMBINE4_NV=0x8503 +GL_COMBINE=0x8570 +GL_COMBINER0_NV=0x8550 +GL_COMBINER1_NV=0x8551 +GL_COMBINER2_NV=0x8552 +GL_COMBINER3_NV=0x8553 +GL_COMBINER4_NV=0x8554 +GL_COMBINER5_NV=0x8555 +GL_COMBINER6_NV=0x8556 +GL_COMBINER7_NV=0x8557 +GL_COMBINER_AB_DOT_PRODUCT_NV=0x8545 +GL_COMBINER_AB_OUTPUT_NV=0x854A +GL_COMBINER_BIAS_NV=0x8549 +GL_COMBINER_CD_DOT_PRODUCT_NV=0x8546 +GL_COMBINER_CD_OUTPUT_NV=0x854B +GL_COMBINER_COMPONENT_USAGE_NV=0x8544 +GL_COMBINER_INPUT_NV=0x8542 +GL_COMBINER_MAPPING_NV=0x8543 +GL_COMBINER_MUX_SUM_NV=0x8547 +GL_COMBINER_SCALE_NV=0x8548 +GL_COMBINER_SUM_OUTPUT_NV=0x854C +GL_COMBINE_ALPHA=0x8572 +GL_COMBINE_ALPHA_ARB=0x8572 +GL_COMBINE_ALPHA_EXT=0x8572 +GL_COMBINE_ARB=0x8570 +GL_COMBINE_EXT=0x8570 +GL_COMBINE_RGB=0x8571 +GL_COMBINE_RGB_ARB=0x8571 +GL_COMBINE_RGB_EXT=0x8571 +GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT=0x884E +GL_COMPARE_R_TO_TEXTURE=0x884E +GL_COMPARE_R_TO_TEXTURE_ARB=0x884E +GL_COMPILE=0x1300 +GL_COMPILE_AND_EXECUTE=0x1301 +GL_COMPILE_STATUS=0x8B81 +GL_COMPRESSED_ALPHA=0x84E9 +GL_COMPRESSED_ALPHA_ARB=0x84E9 +GL_COMPRESSED_INTENSITY=0x84EC +GL_COMPRESSED_INTENSITY_ARB=0x84EC +GL_COMPRESSED_LUMINANCE=0x84EA +GL_COMPRESSED_LUMINANCE_ALPHA=0x84EB +GL_COMPRESSED_LUMINANCE_ALPHA_ARB=0x84EB +GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT=0x8C72 +GL_COMPRESSED_LUMINANCE_ARB=0x84EA +GL_COMPRESSED_LUMINANCE_LATC1_EXT=0x8C70 +GL_COMPRESSED_RED_GREEN_RGTC2_EXT=0x8DBD +GL_COMPRESSED_RED_RGTC1_EXT=0x8DBB +GL_COMPRESSED_RGB=0x84ED +GL_COMPRESSED_RGBA=0x84EE +GL_COMPRESSED_RGBA_ARB=0x84EE +GL_COMPRESSED_RGBA_FXT1_3DFX=0x86B1 +GL_COMPRESSED_RGBA_S3TC_DXT1_EXT=0x83F1 +GL_COMPRESSED_RGBA_S3TC_DXT3_EXT=0x83F2 +GL_COMPRESSED_RGBA_S3TC_DXT5_EXT=0x83F3 +GL_COMPRESSED_RGB_ARB=0x84ED +GL_COMPRESSED_RGB_FXT1_3DFX=0x86B0 +GL_COMPRESSED_RGB_S3TC_DXT1_EXT=0x83F0 +GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT=0x8C73 +GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT=0x8C71 +GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT=0x8DBE +GL_COMPRESSED_SIGNED_RED_RGTC1_EXT=0x8DBC +GL_COMPRESSED_SLUMINANCE=0x8C4A +GL_COMPRESSED_SLUMINANCE_ALPHA=0x8C4B +GL_COMPRESSED_SLUMINANCE_ALPHA_EXT=0x8C4B +GL_COMPRESSED_SLUMINANCE_EXT=0x8C4A +GL_COMPRESSED_SRGB=0x8C48 +GL_COMPRESSED_SRGB_ALPHA=0x8C49 +GL_COMPRESSED_SRGB_ALPHA_EXT=0x8C49 +GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT=0x8C4D +GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT=0x8C4E +GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT=0x8C4F +GL_COMPRESSED_SRGB_EXT=0x8C48 +GL_COMPRESSED_SRGB_S3TC_DXT1_EXT=0x8C4C +GL_COMPRESSED_TEXTURE_FORMATS=0x86A3 +GL_COMPRESSED_TEXTURE_FORMATS_ARB=0x86A3 +GL_COMP_BIT_ATI=0x00000002 +GL_CONSERVE_MEMORY_HINT_PGI=0x1A1FD +GL_CONSTANT=0x8576 +GL_CONSTANT_ALPHA=0x8003 +GL_CONSTANT_ALPHA_EXT=0x8003 +GL_CONSTANT_ARB=0x8576 +GL_CONSTANT_ATTENUATION=0x1207 +GL_CONSTANT_BORDER=0x8151 +GL_CONSTANT_BORDER_HP=0x8151 +GL_CONSTANT_COLOR0_NV=0x852A +GL_CONSTANT_COLOR1_NV=0x852B +GL_CONSTANT_COLOR=0x8001 +GL_CONSTANT_COLOR_EXT=0x8001 +GL_CONSTANT_EXT=0x8576 +GL_CONST_EYE_NV=0x86E5 +GL_CONVOLUTION_1D=0x8010 +GL_CONVOLUTION_1D_EXT=0x8010 +GL_CONVOLUTION_2D=0x8011 +GL_CONVOLUTION_2D_EXT=0x8011 +GL_CONVOLUTION_BORDER_COLOR=0x8154 +GL_CONVOLUTION_BORDER_COLOR_HP=0x8154 +GL_CONVOLUTION_BORDER_MODE=0x8013 +GL_CONVOLUTION_BORDER_MODE_EXT=0x8013 +GL_CONVOLUTION_FILTER_BIAS=0x8015 +GL_CONVOLUTION_FILTER_BIAS_EXT=0x8015 +GL_CONVOLUTION_FILTER_SCALE=0x8014 +GL_CONVOLUTION_FILTER_SCALE_EXT=0x8014 +GL_CONVOLUTION_FORMAT=0x8017 +GL_CONVOLUTION_FORMAT_EXT=0x8017 +GL_CONVOLUTION_HEIGHT=0x8019 +GL_CONVOLUTION_HEIGHT_EXT=0x8019 +GL_CONVOLUTION_HINT_SGIX=0x8316 +GL_CONVOLUTION_WIDTH=0x8018 +GL_CONVOLUTION_WIDTH_EXT=0x8018 +GL_CON_0_ATI=0x8941 +GL_CON_10_ATI=0x894B +GL_CON_11_ATI=0x894C +GL_CON_12_ATI=0x894D +GL_CON_13_ATI=0x894E +GL_CON_14_ATI=0x894F +GL_CON_15_ATI=0x8950 +GL_CON_16_ATI=0x8951 +GL_CON_17_ATI=0x8952 +GL_CON_18_ATI=0x8953 +GL_CON_19_ATI=0x8954 +GL_CON_1_ATI=0x8942 +GL_CON_20_ATI=0x8955 +GL_CON_21_ATI=0x8956 +GL_CON_22_ATI=0x8957 +GL_CON_23_ATI=0x8958 +GL_CON_24_ATI=0x8959 +GL_CON_25_ATI=0x895A +GL_CON_26_ATI=0x895B +GL_CON_27_ATI=0x895C +GL_CON_28_ATI=0x895D +GL_CON_29_ATI=0x895E +GL_CON_2_ATI=0x8943 +GL_CON_30_ATI=0x895F +GL_CON_31_ATI=0x8960 +GL_CON_3_ATI=0x8944 +GL_CON_4_ATI=0x8945 +GL_CON_5_ATI=0x8946 +GL_CON_6_ATI=0x8947 +GL_CON_7_ATI=0x8948 +GL_CON_8_ATI=0x8949 +GL_CON_9_ATI=0x894A +GL_COORD_REPLACE=0x8862 +GL_COORD_REPLACE_ARB=0x8862 +GL_COORD_REPLACE_NV=0x8862 +GL_COPY=0x1503 +GL_COPY_INVERTED=0x150C +GL_COPY_PIXEL_TOKEN=0x0706 +GL_CUBIC_EXT=0x8334 +GL_CUBIC_HP=0x815F +GL_CULL_FACE=0x0B44 +GL_CULL_FACE_MODE=0x0B45 +GL_CULL_FRAGMENT_NV=0x86E7 +GL_CULL_MODES_NV=0x86E0 +GL_CULL_VERTEX_EXT=0x81AA +GL_CULL_VERTEX_EYE_POSITION_EXT=0x81AB +GL_CULL_VERTEX_IBM=103050 +GL_CULL_VERTEX_OBJECT_POSITION_EXT=0x81AC +GL_CURRENT_ATTRIB_NV=0x8626 +GL_CURRENT_BINORMAL_EXT=0x843C +GL_CURRENT_BIT=0x00000001 +GL_CURRENT_COLOR=0x0B00 +GL_CURRENT_FOG_COORD=0x8453 +GL_CURRENT_FOG_COORDINATE=0x8453 +GL_CURRENT_FOG_COORDINATE_EXT=0x8453 +GL_CURRENT_INDEX=0x0B01 +GL_CURRENT_MATRIX_ARB=0x8641 +GL_CURRENT_MATRIX_INDEX_ARB=0x8845 +GL_CURRENT_MATRIX_NV=0x8641 +GL_CURRENT_MATRIX_STACK_DEPTH_ARB=0x8640 +GL_CURRENT_MATRIX_STACK_DEPTH_NV=0x8640 +GL_CURRENT_NORMAL=0x0B02 +GL_CURRENT_OCCLUSION_QUERY_ID_NV=0x8865 +GL_CURRENT_PALETTE_MATRIX_ARB=0x8843 +GL_CURRENT_PROGRAM=0x8B8D +GL_CURRENT_QUERY=0x8865 +GL_CURRENT_QUERY_ARB=0x8865 +GL_CURRENT_RASTER_COLOR=0x0B04 +GL_CURRENT_RASTER_DISTANCE=0x0B09 +GL_CURRENT_RASTER_INDEX=0x0B05 +GL_CURRENT_RASTER_NORMAL_SGIX=0x8406 +GL_CURRENT_RASTER_POSITION=0x0B07 +GL_CURRENT_RASTER_POSITION_VALID=0x0B08 +GL_CURRENT_RASTER_SECONDARY_COLOR=0x845F +GL_CURRENT_RASTER_TEXTURE_COORDS=0x0B06 +GL_CURRENT_SECONDARY_COLOR=0x8459 +GL_CURRENT_SECONDARY_COLOR_EXT=0x8459 +GL_CURRENT_TANGENT_EXT=0x843B +GL_CURRENT_TEXTURE_COORDS=0x0B03 +GL_CURRENT_VERTEX_ATTRIB=0x8626 +GL_CURRENT_VERTEX_ATTRIB_ARB=0x8626 +GL_CURRENT_VERTEX_EXT=0x87E2 +GL_CURRENT_VERTEX_WEIGHT_EXT=0x850B +GL_CURRENT_WEIGHT_ARB=0x86A8 +GL_CW=0x0900 +GL_DECAL=0x2101 +GL_DECR=0x1E03 +GL_DECR_WRAP=0x8508 +GL_DECR_WRAP_EXT=0x8508 +GL_DEFORMATIONS_MASK_SGIX=0x8196 +GL_DELETE_STATUS=0x8B80 +GL_DEPENDENT_AR_TEXTURE_2D_NV=0x86E9 +GL_DEPENDENT_GB_TEXTURE_2D_NV=0x86EA +GL_DEPENDENT_HILO_TEXTURE_2D_NV=0x8858 +GL_DEPENDENT_RGB_TEXTURE_3D_NV=0x8859 +GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV=0x885A +GL_DEPTH24_STENCIL8_EXT=0x88F0 +GL_DEPTH32F_STENCIL8_NV=0x8DAC +GL_DEPTH=0x1801 +GL_DEPTH_ATTACHMENT_EXT=0x8D00 +GL_DEPTH_BIAS=0x0D1F +GL_DEPTH_BITS=0x0D56 +GL_DEPTH_BOUNDS_EXT=0x8891 +GL_DEPTH_BOUNDS_TEST_EXT=0x8890 +GL_DEPTH_BUFFER_BIT=0x00000100 +GL_DEPTH_BUFFER_FLOAT_MODE_NV=0x8DAF +GL_DEPTH_CLAMP_NV=0x864F +GL_DEPTH_CLEAR_VALUE=0x0B73 +GL_DEPTH_COMPONENT16=0x81A5 +GL_DEPTH_COMPONENT16_ARB=0x81A5 +GL_DEPTH_COMPONENT16_SGIX=0x81A5 +GL_DEPTH_COMPONENT24=0x81A6 +GL_DEPTH_COMPONENT24_ARB=0x81A6 +GL_DEPTH_COMPONENT24_SGIX=0x81A6 +GL_DEPTH_COMPONENT32=0x81A7 +GL_DEPTH_COMPONENT32F_NV=0x8DAB +GL_DEPTH_COMPONENT32_ARB=0x81A7 +GL_DEPTH_COMPONENT32_SGIX=0x81A7 +GL_DEPTH_COMPONENT=0x1902 +GL_DEPTH_FUNC=0x0B74 +GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX=0x8311 +GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX=0x8312 +GL_DEPTH_PASS_INSTRUMENT_SGIX=0x8310 +GL_DEPTH_RANGE=0x0B70 +GL_DEPTH_SCALE=0x0D1E +GL_DEPTH_STENCIL_EXT=0x84F9 +GL_DEPTH_STENCIL_NV=0x84F9 +GL_DEPTH_STENCIL_TO_BGRA_NV=0x886F +GL_DEPTH_STENCIL_TO_RGBA_NV=0x886E +GL_DEPTH_TEST=0x0B71 +GL_DEPTH_TEXTURE_MODE=0x884B +GL_DEPTH_TEXTURE_MODE_ARB=0x884B +GL_DEPTH_WRITEMASK=0x0B72 +GL_DETAIL_TEXTURE_2D_BINDING_SGIS=0x8096 +GL_DETAIL_TEXTURE_2D_SGIS=0x8095 +GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS=0x809C +GL_DETAIL_TEXTURE_LEVEL_SGIS=0x809A +GL_DETAIL_TEXTURE_MODE_SGIS=0x809B +GL_DIFFUSE=0x1201 +GL_DISCARD_ATI=0x8763 +GL_DISCARD_NV=0x8530 +GL_DISTANCE_ATTENUATION_EXT=0x8129 +GL_DISTANCE_ATTENUATION_SGIS=0x8129 +GL_DITHER=0x0BD0 +GL_DOMAIN=0x0A02 +GL_DONT_CARE=0x1100 +GL_DOT2_ADD_ATI=0x896C +GL_DOT3_ATI=0x8966 +GL_DOT3_RGB=0x86AE +GL_DOT3_RGBA=0x86AF +GL_DOT3_RGBA_ARB=0x86AF +GL_DOT3_RGBA_EXT=0x8741 +GL_DOT3_RGB_ARB=0x86AE +GL_DOT3_RGB_EXT=0x8740 +GL_DOT4_ATI=0x8967 +GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV=0x885D +GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV=0x86F3 +GL_DOT_PRODUCT_DEPTH_REPLACE_NV=0x86ED +GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV=0x86F1 +GL_DOT_PRODUCT_NV=0x86EC +GL_DOT_PRODUCT_PASS_THROUGH_NV=0x885B +GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV=0x86F2 +GL_DOT_PRODUCT_TEXTURE_1D_NV=0x885C +GL_DOT_PRODUCT_TEXTURE_2D_NV=0x86EE +GL_DOT_PRODUCT_TEXTURE_3D_NV=0x86EF +GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV=0x86F0 +GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV=0x864E +GL_DOUBLE=0x140A +GL_DOUBLEBUFFER=0x0C32 +GL_DOUBLE_EXT=0x140A +GL_DRAW_BUFFER0=0x8825 +GL_DRAW_BUFFER0_ARB=0x8825 +GL_DRAW_BUFFER0_ATI=0x8825 +GL_DRAW_BUFFER10=0x882F +GL_DRAW_BUFFER10_ARB=0x882F +GL_DRAW_BUFFER10_ATI=0x882F +GL_DRAW_BUFFER11=0x8830 +GL_DRAW_BUFFER11_ARB=0x8830 +GL_DRAW_BUFFER11_ATI=0x8830 +GL_DRAW_BUFFER12=0x8831 +GL_DRAW_BUFFER12_ARB=0x8831 +GL_DRAW_BUFFER12_ATI=0x8831 +GL_DRAW_BUFFER13=0x8832 +GL_DRAW_BUFFER13_ARB=0x8832 +GL_DRAW_BUFFER13_ATI=0x8832 +GL_DRAW_BUFFER14=0x8833 +GL_DRAW_BUFFER14_ARB=0x8833 +GL_DRAW_BUFFER14_ATI=0x8833 +GL_DRAW_BUFFER15=0x8834 +GL_DRAW_BUFFER15_ARB=0x8834 +GL_DRAW_BUFFER15_ATI=0x8834 +GL_DRAW_BUFFER1=0x8826 +GL_DRAW_BUFFER1_ARB=0x8826 +GL_DRAW_BUFFER1_ATI=0x8826 +GL_DRAW_BUFFER2=0x8827 +GL_DRAW_BUFFER2_ARB=0x8827 +GL_DRAW_BUFFER2_ATI=0x8827 +GL_DRAW_BUFFER3=0x8828 +GL_DRAW_BUFFER3_ARB=0x8828 +GL_DRAW_BUFFER3_ATI=0x8828 +GL_DRAW_BUFFER4=0x8829 +GL_DRAW_BUFFER4_ARB=0x8829 +GL_DRAW_BUFFER4_ATI=0x8829 +GL_DRAW_BUFFER5=0x882A +GL_DRAW_BUFFER5_ARB=0x882A +GL_DRAW_BUFFER5_ATI=0x882A +GL_DRAW_BUFFER6=0x882B +GL_DRAW_BUFFER6_ARB=0x882B +GL_DRAW_BUFFER6_ATI=0x882B +GL_DRAW_BUFFER7=0x882C +GL_DRAW_BUFFER7_ARB=0x882C +GL_DRAW_BUFFER7_ATI=0x882C +GL_DRAW_BUFFER8=0x882D +GL_DRAW_BUFFER8_ARB=0x882D +GL_DRAW_BUFFER8_ATI=0x882D +GL_DRAW_BUFFER9=0x882E +GL_DRAW_BUFFER9_ARB=0x882E +GL_DRAW_BUFFER9_ATI=0x882E +GL_DRAW_BUFFER=0x0C01 +GL_DRAW_FRAMEBUFFER_BINDING_EXT=0x8CAA +GL_DRAW_FRAMEBUFFER_EXT=0x8CA9 +GL_DRAW_PIXELS_APPLE=0x8A0A +GL_DRAW_PIXEL_TOKEN=0x0705 +GL_DSDT8_MAG8_INTENSITY8_NV=0x870B +GL_DSDT8_MAG8_NV=0x870A +GL_DSDT8_NV=0x8709 +GL_DSDT_MAG_INTENSITY_NV=0x86DC +GL_DSDT_MAG_NV=0x86F6 +GL_DSDT_MAG_VIB_NV=0x86F7 +GL_DSDT_NV=0x86F5 +GL_DST_ALPHA=0x0304 +GL_DST_COLOR=0x0306 +GL_DS_BIAS_NV=0x8716 +GL_DS_SCALE_NV=0x8710 +GL_DT_BIAS_NV=0x8717 +GL_DT_SCALE_NV=0x8711 +GL_DU8DV8_ATI=0x877A +GL_DUAL_ALPHA12_SGIS=0x8112 +GL_DUAL_ALPHA16_SGIS=0x8113 +GL_DUAL_ALPHA4_SGIS=0x8110 +GL_DUAL_ALPHA8_SGIS=0x8111 +GL_DUAL_INTENSITY12_SGIS=0x811A +GL_DUAL_INTENSITY16_SGIS=0x811B +GL_DUAL_INTENSITY4_SGIS=0x8118 +GL_DUAL_INTENSITY8_SGIS=0x8119 +GL_DUAL_LUMINANCE12_SGIS=0x8116 +GL_DUAL_LUMINANCE16_SGIS=0x8117 +GL_DUAL_LUMINANCE4_SGIS=0x8114 +GL_DUAL_LUMINANCE8_SGIS=0x8115 +GL_DUAL_LUMINANCE_ALPHA4_SGIS=0x811C +GL_DUAL_LUMINANCE_ALPHA8_SGIS=0x811D +GL_DUAL_TEXTURE_SELECT_SGIS=0x8124 +GL_DUDV_ATI=0x8779 +GL_DYNAMIC_ATI=0x8761 +GL_DYNAMIC_COPY=0x88EA +GL_DYNAMIC_COPY_ARB=0x88EA +GL_DYNAMIC_DRAW=0x88E8 +GL_DYNAMIC_DRAW_ARB=0x88E8 +GL_DYNAMIC_READ=0x88E9 +GL_DYNAMIC_READ_ARB=0x88E9 +GL_EDGEFLAG_BIT_PGI=0x00040000 +GL_EDGE_FLAG=0x0B43 +GL_EDGE_FLAG_ARRAY=0x8079 +GL_EDGE_FLAG_ARRAY_BUFFER_BINDING=0x889B +GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB=0x889B +GL_EDGE_FLAG_ARRAY_COUNT_EXT=0x808D +GL_EDGE_FLAG_ARRAY_EXT=0x8079 +GL_EDGE_FLAG_ARRAY_LIST_IBM=103075 +GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM=103085 +GL_EDGE_FLAG_ARRAY_POINTER=0x8093 +GL_EDGE_FLAG_ARRAY_POINTER_EXT=0x8093 +GL_EDGE_FLAG_ARRAY_STRIDE=0x808C +GL_EDGE_FLAG_ARRAY_STRIDE_EXT=0x808C +GL_EIGHTH_BIT_ATI=0x00000020 +GL_ELEMENT_ARRAY_APPLE=0x8768 +GL_ELEMENT_ARRAY_ATI=0x8768 +GL_ELEMENT_ARRAY_BUFFER=0x8893 +GL_ELEMENT_ARRAY_BUFFER_ARB=0x8893 +GL_ELEMENT_ARRAY_BUFFER_BINDING=0x8895 +GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB=0x8895 +GL_ELEMENT_ARRAY_POINTER_APPLE=0x876A +GL_ELEMENT_ARRAY_POINTER_ATI=0x876A +GL_ELEMENT_ARRAY_TYPE_APPLE=0x8769 +GL_ELEMENT_ARRAY_TYPE_ATI=0x8769 +GL_EMBOSS_CONSTANT_NV=0x855E +GL_EMBOSS_LIGHT_NV=0x855D +GL_EMBOSS_MAP_NV=0x855F +GL_EMISSION=0x1600 +GL_ENABLE_BIT=0x00002000 +GL_EQUAL=0x0202 +GL_EQUIV=0x1509 +GL_EVAL_2D_NV=0x86C0 +GL_EVAL_BIT=0x00010000 +GL_EVAL_FRACTIONAL_TESSELLATION_NV=0x86C5 +GL_EVAL_TRIANGULAR_2D_NV=0x86C1 +GL_EVAL_VERTEX_ATTRIB0_NV=0x86C6 +GL_EVAL_VERTEX_ATTRIB10_NV=0x86D0 +GL_EVAL_VERTEX_ATTRIB11_NV=0x86D1 +GL_EVAL_VERTEX_ATTRIB12_NV=0x86D2 +GL_EVAL_VERTEX_ATTRIB13_NV=0x86D3 +GL_EVAL_VERTEX_ATTRIB14_NV=0x86D4 +GL_EVAL_VERTEX_ATTRIB15_NV=0x86D5 +GL_EVAL_VERTEX_ATTRIB1_NV=0x86C7 +GL_EVAL_VERTEX_ATTRIB2_NV=0x86C8 +GL_EVAL_VERTEX_ATTRIB3_NV=0x86C9 +GL_EVAL_VERTEX_ATTRIB4_NV=0x86CA +GL_EVAL_VERTEX_ATTRIB5_NV=0x86CB +GL_EVAL_VERTEX_ATTRIB6_NV=0x86CC +GL_EVAL_VERTEX_ATTRIB7_NV=0x86CD +GL_EVAL_VERTEX_ATTRIB8_NV=0x86CE +GL_EVAL_VERTEX_ATTRIB9_NV=0x86CF +GL_EXP2=0x0801 +GL_EXP=0x0800 +GL_EXPAND_NEGATE_NV=0x8539 +GL_EXPAND_NORMAL_NV=0x8538 +GL_EXTENSIONS=0x1F03 +GL_EXT_422_pixels=1 +GL_EXT_abgr=1 +GL_EXT_bgra=1 +GL_EXT_bindable_uniform=1 +GL_EXT_blend_color=1 +GL_EXT_blend_equation_separate=1 +GL_EXT_blend_func_separate=1 +GL_EXT_blend_logic_op=1 +GL_EXT_blend_minmax=1 +GL_EXT_blend_subtract=1 +GL_EXT_clip_volume_hint=1 +GL_EXT_cmyka=1 +GL_EXT_color_subtable=1 +GL_EXT_compiled_vertex_array=1 +GL_EXT_convolution=1 +GL_EXT_coordinate_frame=1 +GL_EXT_copy_texture=1 +GL_EXT_cull_vertex=1 +GL_EXT_depth_bounds_test=1 +GL_EXT_draw_buffers2=1 +GL_EXT_draw_instanced=1 +GL_EXT_draw_range_elements=1 +GL_EXT_fog_coord=1 +GL_EXT_framebuffer_blit=1 +GL_EXT_framebuffer_multisample=1 +GL_EXT_framebuffer_object=1 +GL_EXT_framebuffer_sRGB=1 +GL_EXT_geometry_shader4=1 +GL_EXT_gpu_program_parameters=1 +GL_EXT_gpu_shader4=1 +GL_EXT_histogram=1 +GL_EXT_index_array_formats=1 +GL_EXT_index_func=1 +GL_EXT_index_material=1 +GL_EXT_index_texture=1 +GL_EXT_light_texture=1 +GL_EXT_misc_attribute=1 +GL_EXT_multi_draw_arrays=1 +GL_EXT_multisample=1 +GL_EXT_packed_depth_stencil=1 +GL_EXT_packed_float=1 +GL_EXT_packed_pixels=1 +GL_EXT_paletted_texture=1 +GL_EXT_pixel_buffer_object=1 +GL_EXT_pixel_transform=1 +GL_EXT_pixel_transform_color_table=1 +GL_EXT_point_parameters=1 +GL_EXT_polygon_offset=1 +GL_EXT_rescale_normal=1 +GL_EXT_secondary_color=1 +GL_EXT_separate_specular_color=1 +GL_EXT_shadow_funcs=1 +GL_EXT_shared_texture_palette=1 +GL_EXT_stencil_clear_tag=1 +GL_EXT_stencil_two_side=1 +GL_EXT_stencil_wrap=1 +GL_EXT_subtexture=1 +GL_EXT_texture3D=1 +GL_EXT_texture=1 +GL_EXT_texture_array=1 +GL_EXT_texture_buffer_object=1 +GL_EXT_texture_compression_latc=1 +GL_EXT_texture_compression_rgtc=1 +GL_EXT_texture_env_add=1 +GL_EXT_texture_env_combine=1 +GL_EXT_texture_env_dot3=1 +GL_EXT_texture_filter_anisotropic=1 +GL_EXT_texture_integer=1 +GL_EXT_texture_lod_bias=1 +GL_EXT_texture_mirror_clamp=1 +GL_EXT_texture_object=1 +GL_EXT_texture_perturb_normal=1 +GL_EXT_texture_sRGB=1 +GL_EXT_texture_shared_exponent=1 +GL_EXT_timer_query=1 +GL_EXT_vertex_array=1 +GL_EXT_vertex_shader=1 +GL_EXT_vertex_weighting=1 +GL_EYE_DISTANCE_TO_LINE_SGIS=0x81F2 +GL_EYE_DISTANCE_TO_POINT_SGIS=0x81F0 +GL_EYE_LINEAR=0x2400 +GL_EYE_LINE_SGIS=0x81F6 +GL_EYE_PLANE=0x2502 +GL_EYE_PLANE_ABSOLUTE_NV=0x855C +GL_EYE_POINT_SGIS=0x81F4 +GL_EYE_RADIAL_NV=0x855B +GL_E_TIMES_F_NV=0x8531 +GL_FALSE=0 +GL_FASTEST=0x1101 +GL_FEEDBACK=0x1C01 +GL_FEEDBACK_BUFFER_POINTER=0x0DF0 +GL_FEEDBACK_BUFFER_SIZE=0x0DF1 +GL_FEEDBACK_BUFFER_TYPE=0x0DF2 +GL_FENCE_APPLE=0x8A0B +GL_FENCE_CONDITION_NV=0x84F4 +GL_FENCE_STATUS_NV=0x84F3 +GL_FILL=0x1B02 +GL_FILTER4_SGIS=0x8146 +GL_FIXED_ONLY_ARB=0x891D +GL_FLAT=0x1D00 +GL_FLOAT=0x1406 +GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV=0x8DAD +GL_FLOAT_CLEAR_COLOR_VALUE_NV=0x888D +GL_FLOAT_MAT2=0x8B5A +GL_FLOAT_MAT2_ARB=0x8B5A +GL_FLOAT_MAT2x3=0x8B65 +GL_FLOAT_MAT2x4=0x8B66 +GL_FLOAT_MAT3=0x8B5B +GL_FLOAT_MAT3_ARB=0x8B5B +GL_FLOAT_MAT3x2=0x8B67 +GL_FLOAT_MAT3x4=0x8B68 +GL_FLOAT_MAT4=0x8B5C +GL_FLOAT_MAT4_ARB=0x8B5C +GL_FLOAT_MAT4x2=0x8B69 +GL_FLOAT_MAT4x3=0x8B6A +GL_FLOAT_R16_NV=0x8884 +GL_FLOAT_R32_NV=0x8885 +GL_FLOAT_RG16_NV=0x8886 +GL_FLOAT_RG32_NV=0x8887 +GL_FLOAT_RGB16_NV=0x8888 +GL_FLOAT_RGB32_NV=0x8889 +GL_FLOAT_RGBA16_NV=0x888A +GL_FLOAT_RGBA32_NV=0x888B +GL_FLOAT_RGBA_MODE_NV=0x888E +GL_FLOAT_RGBA_NV=0x8883 +GL_FLOAT_RGB_NV=0x8882 +GL_FLOAT_RG_NV=0x8881 +GL_FLOAT_R_NV=0x8880 +GL_FLOAT_VEC2=0x8B50 +GL_FLOAT_VEC2_ARB=0x8B50 +GL_FLOAT_VEC3=0x8B51 +GL_FLOAT_VEC3_ARB=0x8B51 +GL_FLOAT_VEC4=0x8B52 +GL_FLOAT_VEC4_ARB=0x8B52 +GL_FOG=0x0B60 +GL_FOG_BIT=0x00000080 +GL_FOG_COLOR=0x0B66 +GL_FOG_COORD=0x8451 +GL_FOG_COORDINATE=0x8451 +GL_FOG_COORDINATE_ARRAY=0x8457 +GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING=0x889D +GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB=0x889D +GL_FOG_COORDINATE_ARRAY_EXT=0x8457 +GL_FOG_COORDINATE_ARRAY_LIST_IBM=103076 +GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM=103086 +GL_FOG_COORDINATE_ARRAY_POINTER=0x8456 +GL_FOG_COORDINATE_ARRAY_POINTER_EXT=0x8456 +GL_FOG_COORDINATE_ARRAY_STRIDE=0x8455 +GL_FOG_COORDINATE_ARRAY_STRIDE_EXT=0x8455 +GL_FOG_COORDINATE_ARRAY_TYPE=0x8454 +GL_FOG_COORDINATE_ARRAY_TYPE_EXT=0x8454 +GL_FOG_COORDINATE_EXT=0x8451 +GL_FOG_COORDINATE_SOURCE=0x8450 +GL_FOG_COORDINATE_SOURCE_EXT=0x8450 +GL_FOG_COORD_ARRAY=0x8457 +GL_FOG_COORD_ARRAY_BUFFER_BINDING=0x889D +GL_FOG_COORD_ARRAY_POINTER=0x8456 +GL_FOG_COORD_ARRAY_STRIDE=0x8455 +GL_FOG_COORD_ARRAY_TYPE=0x8454 +GL_FOG_COORD_SRC=0x8450 +GL_FOG_DENSITY=0x0B62 +GL_FOG_DISTANCE_MODE_NV=0x855A +GL_FOG_END=0x0B64 +GL_FOG_FUNC_POINTS_SGIS=0x812B +GL_FOG_FUNC_SGIS=0x812A +GL_FOG_HINT=0x0C54 +GL_FOG_INDEX=0x0B61 +GL_FOG_MODE=0x0B65 +GL_FOG_OFFSET_SGIX=0x8198 +GL_FOG_OFFSET_VALUE_SGIX=0x8199 +GL_FOG_SCALE_SGIX=0x81FC +GL_FOG_SCALE_VALUE_SGIX=0x81FD +GL_FOG_SPECULAR_TEXTURE_WIN=0x80EC +GL_FOG_START=0x0B63 +GL_FORCE_BLUE_TO_ONE_NV=0x8860 +GL_FORMAT_SUBSAMPLE_244_244_OML=0x8983 +GL_FORMAT_SUBSAMPLE_24_24_OML=0x8982 +GL_FRAGMENT_COLOR_EXT=0x834C +GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX=0x8402 +GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX=0x8403 +GL_FRAGMENT_COLOR_MATERIAL_SGIX=0x8401 +GL_FRAGMENT_DEPTH=0x8452 +GL_FRAGMENT_DEPTH_EXT=0x8452 +GL_FRAGMENT_LIGHT0_SGIX=0x840C +GL_FRAGMENT_LIGHT1_SGIX=0x840D +GL_FRAGMENT_LIGHT2_SGIX=0x840E +GL_FRAGMENT_LIGHT3_SGIX=0x840F +GL_FRAGMENT_LIGHT4_SGIX=0x8410 +GL_FRAGMENT_LIGHT5_SGIX=0x8411 +GL_FRAGMENT_LIGHT6_SGIX=0x8412 +GL_FRAGMENT_LIGHT7_SGIX=0x8413 +GL_FRAGMENT_LIGHTING_SGIX=0x8400 +GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX=0x840A +GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX=0x8408 +GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX=0x840B +GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX=0x8409 +GL_FRAGMENT_MATERIAL_EXT=0x8349 +GL_FRAGMENT_NORMAL_EXT=0x834A +GL_FRAGMENT_PROGRAM_ARB=0x8804 +GL_FRAGMENT_PROGRAM_BINDING_NV=0x8873 +GL_FRAGMENT_PROGRAM_NV=0x8870 +GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV=0x8DA4 +GL_FRAGMENT_SHADER=0x8B30 +GL_FRAGMENT_SHADER_ARB=0x8B30 +GL_FRAGMENT_SHADER_ATI=0x8920 +GL_FRAGMENT_SHADER_DERIVATIVE_HINT=0x8B8B +GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB=0x8B8B +GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT=0x8DA7 +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT=0x8CD1 +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT=0x8CD0 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT=0x8CD4 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT=0x8CD3 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT=0x8CD4 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT=0x8CD2 +GL_FRAMEBUFFER_BINDING_EXT=0x8CA6 +GL_FRAMEBUFFER_COMPLETE_EXT=0x8CD5 +GL_FRAMEBUFFER_EXT=0x8D40 +GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT=0x8CD6 +GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT=0x8CD9 +GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT=0x8CDB +GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT=0x8CDA +GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT=0x8DA9 +GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT=0x8DA8 +GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT=0x8CD7 +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT=0x8D56 +GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT=0x8CDC +GL_FRAMEBUFFER_SRGB_CAPABLE_EXT=0x8DBA +GL_FRAMEBUFFER_SRGB_EXT=0x8DB9 +GL_FRAMEBUFFER_UNSUPPORTED_EXT=0x8CDD +GL_FRAMEZOOM_FACTOR_SGIX=0x818C +GL_FRAMEZOOM_SGIX=0x818B +GL_FRONT=0x0404 +GL_FRONT_AND_BACK=0x0408 +GL_FRONT_FACE=0x0B46 +GL_FRONT_LEFT=0x0400 +GL_FRONT_RIGHT=0x0401 +GL_FULL_RANGE_EXT=0x87E1 +GL_FULL_STIPPLE_HINT_PGI=0x1A219 +GL_FUNC_ADD=0x8006 +GL_FUNC_ADD_EXT=0x8006 +GL_FUNC_REVERSE_SUBTRACT=0x800B +GL_FUNC_REVERSE_SUBTRACT_EXT=0x800B +GL_FUNC_SUBTRACT=0x800A +GL_FUNC_SUBTRACT_EXT=0x800A +GL_GENERATE_MIPMAP=0x8191 +GL_GENERATE_MIPMAP_HINT=0x8192 +GL_GENERATE_MIPMAP_HINT_SGIS=0x8192 +GL_GENERATE_MIPMAP_SGIS=0x8191 +GL_GENERIC_ATTRIB_NV=0x8C7D +GL_GEOMETRY_DEFORMATION_BIT_SGIX=0x00000002 +GL_GEOMETRY_DEFORMATION_SGIX=0x8194 +GL_GEOMETRY_INPUT_TYPE_EXT=0x8DDB +GL_GEOMETRY_OUTPUT_TYPE_EXT=0x8DDC +GL_GEOMETRY_PROGRAM_NV=0x8C26 +GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV=0x8DA3 +GL_GEOMETRY_SHADER_EXT=0x8DD9 +GL_GEOMETRY_VERTICES_OUT_EXT=0x8DDA +GL_GEQUAL=0x0206 +GL_GLEXT_VERSION=39 +GL_GLOBAL_ALPHA_FACTOR_SUN=0x81DA +GL_GLOBAL_ALPHA_SUN=0x81D9 +GL_GREATER=0x0204 +GL_GREEN=0x1904 +GL_GREEN_BIAS=0x0D19 +GL_GREEN_BITS=0x0D53 +GL_GREEN_BIT_ATI=0x00000002 +GL_GREEN_INTEGER_EXT=0x8D95 +GL_GREEN_MAX_CLAMP_INGR=0x8565 +GL_GREEN_MIN_CLAMP_INGR=0x8561 +GL_GREEN_SCALE=0x0D18 +GL_GREMEDY_frame_terminator=1 +GL_GREMEDY_string_marker=1 +GL_HALF_BIAS_NEGATE_NV=0x853B +GL_HALF_BIAS_NORMAL_NV=0x853A +GL_HALF_BIT_ATI=0x00000008 +GL_HALF_FLOAT_ARB=0x140B +GL_HALF_FLOAT_NV=0x140B +GL_HILO16_NV=0x86F8 +GL_HILO8_NV=0x885E +GL_HILO_NV=0x86F4 +GL_HINT_BIT=0x00008000 +GL_HISTOGRAM=0x8024 +GL_HISTOGRAM_ALPHA_SIZE=0x802B +GL_HISTOGRAM_ALPHA_SIZE_EXT=0x802B +GL_HISTOGRAM_BLUE_SIZE=0x802A +GL_HISTOGRAM_BLUE_SIZE_EXT=0x802A +GL_HISTOGRAM_EXT=0x8024 +GL_HISTOGRAM_FORMAT=0x8027 +GL_HISTOGRAM_FORMAT_EXT=0x8027 +GL_HISTOGRAM_GREEN_SIZE=0x8029 +GL_HISTOGRAM_GREEN_SIZE_EXT=0x8029 +GL_HISTOGRAM_LUMINANCE_SIZE=0x802C +GL_HISTOGRAM_LUMINANCE_SIZE_EXT=0x802C +GL_HISTOGRAM_RED_SIZE=0x8028 +GL_HISTOGRAM_RED_SIZE_EXT=0x8028 +GL_HISTOGRAM_SINK=0x802D +GL_HISTOGRAM_SINK_EXT=0x802D +GL_HISTOGRAM_WIDTH=0x8026 +GL_HISTOGRAM_WIDTH_EXT=0x8026 +GL_HI_BIAS_NV=0x8714 +GL_HI_SCALE_NV=0x870E +GL_HP_convolution_border_modes=1 +GL_HP_image_transform=1 +GL_HP_occlusion_test=1 +GL_HP_texture_lighting=1 +GL_IBM_cull_vertex=1 +GL_IBM_multimode_draw_arrays=1 +GL_IBM_rasterpos_clip=1 +GL_IBM_vertex_array_lists=1 +GL_IDENTITY_NV=0x862A +GL_IGNORE_BORDER_HP=0x8150 +GL_IMAGE_CUBIC_WEIGHT_HP=0x815E +GL_IMAGE_MAG_FILTER_HP=0x815C +GL_IMAGE_MIN_FILTER_HP=0x815D +GL_IMAGE_ROTATE_ANGLE_HP=0x8159 +GL_IMAGE_ROTATE_ORIGIN_X_HP=0x815A +GL_IMAGE_ROTATE_ORIGIN_Y_HP=0x815B +GL_IMAGE_SCALE_X_HP=0x8155 +GL_IMAGE_SCALE_Y_HP=0x8156 +GL_IMAGE_TRANSFORM_2D_HP=0x8161 +GL_IMAGE_TRANSLATE_X_HP=0x8157 +GL_IMAGE_TRANSLATE_Y_HP=0x8158 +GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES=0x8B9B +GL_IMPLEMENTATION_COLOR_READ_TYPE_OES=0x8B9A +GL_INCR=0x1E02 +GL_INCR_WRAP=0x8507 +GL_INCR_WRAP_EXT=0x8507 +GL_INDEX_ARRAY=0x8077 +GL_INDEX_ARRAY_BUFFER_BINDING=0x8899 +GL_INDEX_ARRAY_BUFFER_BINDING_ARB=0x8899 +GL_INDEX_ARRAY_COUNT_EXT=0x8087 +GL_INDEX_ARRAY_EXT=0x8077 +GL_INDEX_ARRAY_LIST_IBM=103073 +GL_INDEX_ARRAY_LIST_STRIDE_IBM=103083 +GL_INDEX_ARRAY_POINTER=0x8091 +GL_INDEX_ARRAY_POINTER_EXT=0x8091 +GL_INDEX_ARRAY_STRIDE=0x8086 +GL_INDEX_ARRAY_STRIDE_EXT=0x8086 +GL_INDEX_ARRAY_TYPE=0x8085 +GL_INDEX_ARRAY_TYPE_EXT=0x8085 +GL_INDEX_BITS=0x0D51 +GL_INDEX_BIT_PGI=0x00080000 +GL_INDEX_CLEAR_VALUE=0x0C20 +GL_INDEX_LOGIC_OP=0x0BF1 +GL_INDEX_MATERIAL_EXT=0x81B8 +GL_INDEX_MATERIAL_FACE_EXT=0x81BA +GL_INDEX_MATERIAL_PARAMETER_EXT=0x81B9 +GL_INDEX_MODE=0x0C30 +GL_INDEX_OFFSET=0x0D13 +GL_INDEX_SHIFT=0x0D12 +GL_INDEX_TEST_EXT=0x81B5 +GL_INDEX_TEST_FUNC_EXT=0x81B6 +GL_INDEX_TEST_REF_EXT=0x81B7 +GL_INDEX_WRITEMASK=0x0C21 +GL_INFO_LOG_LENGTH=0x8B84 +GL_INGR_blend_func_separate=1 +GL_INGR_color_clamp=1 +GL_INGR_interlace_read=1 +GL_INSTRUMENT_BUFFER_POINTER_SGIX=0x8180 +GL_INSTRUMENT_MEASUREMENTS_SGIX=0x8181 +GL_INT=0x1404 +GL_INTEL_parallel_arrays=1 +GL_INTENSITY12=0x804C +GL_INTENSITY12_EXT=0x804C +GL_INTENSITY16=0x804D +GL_INTENSITY16F_ARB=0x881D +GL_INTENSITY16I_EXT=0x8D8B +GL_INTENSITY16UI_EXT=0x8D79 +GL_INTENSITY16_EXT=0x804D +GL_INTENSITY32F_ARB=0x8817 +GL_INTENSITY32I_EXT=0x8D85 +GL_INTENSITY32UI_EXT=0x8D73 +GL_INTENSITY4=0x804A +GL_INTENSITY4_EXT=0x804A +GL_INTENSITY8=0x804B +GL_INTENSITY8I_EXT=0x8D91 +GL_INTENSITY8UI_EXT=0x8D7F +GL_INTENSITY8_EXT=0x804B +GL_INTENSITY=0x8049 +GL_INTENSITY_EXT=0x8049 +GL_INTENSITY_FLOAT16_ATI=0x881D +GL_INTENSITY_FLOAT32_ATI=0x8817 +GL_INTERLACE_OML=0x8980 +GL_INTERLACE_READ_INGR=0x8568 +GL_INTERLACE_READ_OML=0x8981 +GL_INTERLACE_SGIX=0x8094 +GL_INTERLEAVED_ATTRIBS_NV=0x8C8C +GL_INTERPOLATE=0x8575 +GL_INTERPOLATE_ARB=0x8575 +GL_INTERPOLATE_EXT=0x8575 +GL_INT_SAMPLER_1D_ARRAY_EXT=0x8DCE +GL_INT_SAMPLER_1D_EXT=0x8DC9 +GL_INT_SAMPLER_2D_ARRAY_EXT=0x8DCF +GL_INT_SAMPLER_2D_EXT=0x8DCA +GL_INT_SAMPLER_2D_RECT_EXT=0x8DCD +GL_INT_SAMPLER_3D_EXT=0x8DCB +GL_INT_SAMPLER_BUFFER_EXT=0x8DD0 +GL_INT_SAMPLER_CUBE_EXT=0x8DCC +GL_INT_VEC2=0x8B53 +GL_INT_VEC2_ARB=0x8B53 +GL_INT_VEC3=0x8B54 +GL_INT_VEC3_ARB=0x8B54 +GL_INT_VEC4=0x8B55 +GL_INT_VEC4_ARB=0x8B55 +GL_INVALID_ENUM=0x0500 +GL_INVALID_FRAMEBUFFER_OPERATION_EXT=0x0506 +GL_INVALID_OPERATION=0x0502 +GL_INVALID_VALUE=0x0501 +GL_INVARIANT_DATATYPE_EXT=0x87EB +GL_INVARIANT_EXT=0x87C2 +GL_INVARIANT_VALUE_EXT=0x87EA +GL_INVERSE_NV=0x862B +GL_INVERSE_TRANSPOSE_NV=0x862D +GL_INVERT=0x150A +GL_INVERTED_SCREEN_W_REND=0x8491 +GL_IR_INSTRUMENT1_SGIX=0x817F +GL_IUI_N3F_V2F_EXT=0x81AF +GL_IUI_N3F_V3F_EXT=0x81B0 +GL_IUI_V2F_EXT=0x81AD +GL_IUI_V3F_EXT=0x81AE +GL_KEEP=0x1E00 +GL_LEFT=0x0406 +GL_LEQUAL=0x0203 +GL_LERP_ATI=0x8969 +GL_LESS=0x0201 +GL_LIGHT0=0x4000 +GL_LIGHT1=0x4001 +GL_LIGHT2=0x4002 +GL_LIGHT3=0x4003 +GL_LIGHT4=0x4004 +GL_LIGHT5=0x4005 +GL_LIGHT6=0x4006 +GL_LIGHT7=0x4007 +GL_LIGHTING=0x0B50 +GL_LIGHTING_BIT=0x00000040 +GL_LIGHT_ENV_MODE_SGIX=0x8407 +GL_LIGHT_MODEL_AMBIENT=0x0B53 +GL_LIGHT_MODEL_COLOR_CONTROL=0x81F8 +GL_LIGHT_MODEL_COLOR_CONTROL_EXT=0x81F8 +GL_LIGHT_MODEL_LOCAL_VIEWER=0x0B51 +GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE=0x85B0 +GL_LIGHT_MODEL_TWO_SIDE=0x0B52 +GL_LINE=0x1B01 +GL_LINEAR=0x2601 +GL_LINEAR_ATTENUATION=0x1208 +GL_LINEAR_CLIPMAP_LINEAR_SGIX=0x8170 +GL_LINEAR_CLIPMAP_NEAREST_SGIX=0x844F +GL_LINEAR_DETAIL_ALPHA_SGIS=0x8098 +GL_LINEAR_DETAIL_COLOR_SGIS=0x8099 +GL_LINEAR_DETAIL_SGIS=0x8097 +GL_LINEAR_MIPMAP_LINEAR=0x2703 +GL_LINEAR_MIPMAP_NEAREST=0x2701 +GL_LINEAR_SHARPEN_ALPHA_SGIS=0x80AE +GL_LINEAR_SHARPEN_COLOR_SGIS=0x80AF +GL_LINEAR_SHARPEN_SGIS=0x80AD +GL_LINES=0x0001 +GL_LINES_ADJACENCY_EXT=0x000A +GL_LINE_BIT=0x00000004 +GL_LINE_LOOP=0x0002 +GL_LINE_RESET_TOKEN=0x0707 +GL_LINE_SMOOTH=0x0B20 +GL_LINE_SMOOTH_HINT=0x0C52 +GL_LINE_STIPPLE=0x0B24 +GL_LINE_STIPPLE_PATTERN=0x0B25 +GL_LINE_STIPPLE_REPEAT=0x0B26 +GL_LINE_STRIP=0x0003 +GL_LINE_STRIP_ADJACENCY_EXT=0x000B +GL_LINE_TOKEN=0x0702 +GL_LINE_WIDTH=0x0B21 +GL_LINE_WIDTH_GRANULARITY=0x0B23 +GL_LINE_WIDTH_RANGE=0x0B22 +GL_LINK_STATUS=0x8B82 +GL_LIST_BASE=0x0B32 +GL_LIST_BIT=0x00020000 +GL_LIST_INDEX=0x0B33 +GL_LIST_MODE=0x0B30 +GL_LIST_PRIORITY_SGIX=0x8182 +GL_LOAD=0x0101 +GL_LOCAL_CONSTANT_DATATYPE_EXT=0x87ED +GL_LOCAL_CONSTANT_EXT=0x87C3 +GL_LOCAL_CONSTANT_VALUE_EXT=0x87EC +GL_LOCAL_EXT=0x87C4 +GL_LOGIC_OP=0x0BF1 +GL_LOGIC_OP_MODE=0x0BF0 +GL_LOWER_LEFT=0x8CA1 +GL_LO_BIAS_NV=0x8715 +GL_LO_SCALE_NV=0x870F +GL_LUMINANCE12=0x8041 +GL_LUMINANCE12_ALPHA12=0x8047 +GL_LUMINANCE12_ALPHA12_EXT=0x8047 +GL_LUMINANCE12_ALPHA4=0x8046 +GL_LUMINANCE12_ALPHA4_EXT=0x8046 +GL_LUMINANCE12_EXT=0x8041 +GL_LUMINANCE16=0x8042 +GL_LUMINANCE16F_ARB=0x881E +GL_LUMINANCE16I_EXT=0x8D8C +GL_LUMINANCE16UI_EXT=0x8D7A +GL_LUMINANCE16_ALPHA16=0x8048 +GL_LUMINANCE16_ALPHA16_EXT=0x8048 +GL_LUMINANCE16_EXT=0x8042 +GL_LUMINANCE32F_ARB=0x8818 +GL_LUMINANCE32I_EXT=0x8D86 +GL_LUMINANCE32UI_EXT=0x8D74 +GL_LUMINANCE4=0x803F +GL_LUMINANCE4_ALPHA4=0x8043 +GL_LUMINANCE4_ALPHA4_EXT=0x8043 +GL_LUMINANCE4_EXT=0x803F +GL_LUMINANCE6_ALPHA2=0x8044 +GL_LUMINANCE6_ALPHA2_EXT=0x8044 +GL_LUMINANCE8=0x8040 +GL_LUMINANCE8I_EXT=0x8D92 +GL_LUMINANCE8UI_EXT=0x8D80 +GL_LUMINANCE8_ALPHA8=0x8045 +GL_LUMINANCE8_ALPHA8_EXT=0x8045 +GL_LUMINANCE8_EXT=0x8040 +GL_LUMINANCE=0x1909 +GL_LUMINANCE_ALPHA16F_ARB=0x881F +GL_LUMINANCE_ALPHA16I_EXT=0x8D8D +GL_LUMINANCE_ALPHA16UI_EXT=0x8D7B +GL_LUMINANCE_ALPHA32F_ARB=0x8819 +GL_LUMINANCE_ALPHA32I_EXT=0x8D87 +GL_LUMINANCE_ALPHA32UI_EXT=0x8D75 +GL_LUMINANCE_ALPHA8I_EXT=0x8D93 +GL_LUMINANCE_ALPHA8UI_EXT=0x8D81 +GL_LUMINANCE_ALPHA=0x190A +GL_LUMINANCE_ALPHA_FLOAT16_ATI=0x881F +GL_LUMINANCE_ALPHA_FLOAT32_ATI=0x8819 +GL_LUMINANCE_ALPHA_INTEGER_EXT=0x8D9D +GL_LUMINANCE_FLOAT16_ATI=0x881E +GL_LUMINANCE_FLOAT32_ATI=0x8818 +GL_LUMINANCE_INTEGER_EXT=0x8D9C +GL_MAD_ATI=0x8968 +GL_MAGNITUDE_BIAS_NV=0x8718 +GL_MAGNITUDE_SCALE_NV=0x8712 +GL_MAP1_BINORMAL_EXT=0x8446 +GL_MAP1_COLOR_4=0x0D90 +GL_MAP1_GRID_DOMAIN=0x0DD0 +GL_MAP1_GRID_SEGMENTS=0x0DD1 +GL_MAP1_INDEX=0x0D91 +GL_MAP1_NORMAL=0x0D92 +GL_MAP1_TANGENT_EXT=0x8444 +GL_MAP1_TEXTURE_COORD_1=0x0D93 +GL_MAP1_TEXTURE_COORD_2=0x0D94 +GL_MAP1_TEXTURE_COORD_3=0x0D95 +GL_MAP1_TEXTURE_COORD_4=0x0D96 +GL_MAP1_VERTEX_3=0x0D97 +GL_MAP1_VERTEX_4=0x0D98 +GL_MAP1_VERTEX_ATTRIB0_4_NV=0x8660 +GL_MAP1_VERTEX_ATTRIB10_4_NV=0x866A +GL_MAP1_VERTEX_ATTRIB11_4_NV=0x866B +GL_MAP1_VERTEX_ATTRIB12_4_NV=0x866C +GL_MAP1_VERTEX_ATTRIB13_4_NV=0x866D +GL_MAP1_VERTEX_ATTRIB14_4_NV=0x866E +GL_MAP1_VERTEX_ATTRIB15_4_NV=0x866F +GL_MAP1_VERTEX_ATTRIB1_4_NV=0x8661 +GL_MAP1_VERTEX_ATTRIB2_4_NV=0x8662 +GL_MAP1_VERTEX_ATTRIB3_4_NV=0x8663 +GL_MAP1_VERTEX_ATTRIB4_4_NV=0x8664 +GL_MAP1_VERTEX_ATTRIB5_4_NV=0x8665 +GL_MAP1_VERTEX_ATTRIB6_4_NV=0x8666 +GL_MAP1_VERTEX_ATTRIB7_4_NV=0x8667 +GL_MAP1_VERTEX_ATTRIB8_4_NV=0x8668 +GL_MAP1_VERTEX_ATTRIB9_4_NV=0x8669 +GL_MAP2_BINORMAL_EXT=0x8447 +GL_MAP2_COLOR_4=0x0DB0 +GL_MAP2_GRID_DOMAIN=0x0DD2 +GL_MAP2_GRID_SEGMENTS=0x0DD3 +GL_MAP2_INDEX=0x0DB1 +GL_MAP2_NORMAL=0x0DB2 +GL_MAP2_TANGENT_EXT=0x8445 +GL_MAP2_TEXTURE_COORD_1=0x0DB3 +GL_MAP2_TEXTURE_COORD_2=0x0DB4 +GL_MAP2_TEXTURE_COORD_3=0x0DB5 +GL_MAP2_TEXTURE_COORD_4=0x0DB6 +GL_MAP2_VERTEX_3=0x0DB7 +GL_MAP2_VERTEX_4=0x0DB8 +GL_MAP2_VERTEX_ATTRIB0_4_NV=0x8670 +GL_MAP2_VERTEX_ATTRIB10_4_NV=0x867A +GL_MAP2_VERTEX_ATTRIB11_4_NV=0x867B +GL_MAP2_VERTEX_ATTRIB12_4_NV=0x867C +GL_MAP2_VERTEX_ATTRIB13_4_NV=0x867D +GL_MAP2_VERTEX_ATTRIB14_4_NV=0x867E +GL_MAP2_VERTEX_ATTRIB15_4_NV=0x867F +GL_MAP2_VERTEX_ATTRIB1_4_NV=0x8671 +GL_MAP2_VERTEX_ATTRIB2_4_NV=0x8672 +GL_MAP2_VERTEX_ATTRIB3_4_NV=0x8673 +GL_MAP2_VERTEX_ATTRIB4_4_NV=0x8674 +GL_MAP2_VERTEX_ATTRIB5_4_NV=0x8675 +GL_MAP2_VERTEX_ATTRIB6_4_NV=0x8676 +GL_MAP2_VERTEX_ATTRIB7_4_NV=0x8677 +GL_MAP2_VERTEX_ATTRIB8_4_NV=0x8678 +GL_MAP2_VERTEX_ATTRIB9_4_NV=0x8679 +GL_MAP_ATTRIB_U_ORDER_NV=0x86C3 +GL_MAP_ATTRIB_V_ORDER_NV=0x86C4 +GL_MAP_COLOR=0x0D10 +GL_MAP_STENCIL=0x0D11 +GL_MAP_TESSELLATION_NV=0x86C2 +GL_MATERIAL_SIDE_HINT_PGI=0x1A22C +GL_MATRIX0_ARB=0x88C0 +GL_MATRIX0_NV=0x8630 +GL_MATRIX10_ARB=0x88CA +GL_MATRIX11_ARB=0x88CB +GL_MATRIX12_ARB=0x88CC +GL_MATRIX13_ARB=0x88CD +GL_MATRIX14_ARB=0x88CE +GL_MATRIX15_ARB=0x88CF +GL_MATRIX16_ARB=0x88D0 +GL_MATRIX17_ARB=0x88D1 +GL_MATRIX18_ARB=0x88D2 +GL_MATRIX19_ARB=0x88D3 +GL_MATRIX1_ARB=0x88C1 +GL_MATRIX1_NV=0x8631 +GL_MATRIX20_ARB=0x88D4 +GL_MATRIX21_ARB=0x88D5 +GL_MATRIX22_ARB=0x88D6 +GL_MATRIX23_ARB=0x88D7 +GL_MATRIX24_ARB=0x88D8 +GL_MATRIX25_ARB=0x88D9 +GL_MATRIX26_ARB=0x88DA +GL_MATRIX27_ARB=0x88DB +GL_MATRIX28_ARB=0x88DC +GL_MATRIX29_ARB=0x88DD +GL_MATRIX2_ARB=0x88C2 +GL_MATRIX2_NV=0x8632 +GL_MATRIX30_ARB=0x88DE +GL_MATRIX31_ARB=0x88DF +GL_MATRIX3_ARB=0x88C3 +GL_MATRIX3_NV=0x8633 +GL_MATRIX4_ARB=0x88C4 +GL_MATRIX4_NV=0x8634 +GL_MATRIX5_ARB=0x88C5 +GL_MATRIX5_NV=0x8635 +GL_MATRIX6_ARB=0x88C6 +GL_MATRIX6_NV=0x8636 +GL_MATRIX7_ARB=0x88C7 +GL_MATRIX7_NV=0x8637 +GL_MATRIX8_ARB=0x88C8 +GL_MATRIX9_ARB=0x88C9 +GL_MATRIX_EXT=0x87C0 +GL_MATRIX_INDEX_ARRAY_ARB=0x8844 +GL_MATRIX_INDEX_ARRAY_POINTER_ARB=0x8849 +GL_MATRIX_INDEX_ARRAY_SIZE_ARB=0x8846 +GL_MATRIX_INDEX_ARRAY_STRIDE_ARB=0x8848 +GL_MATRIX_INDEX_ARRAY_TYPE_ARB=0x8847 +GL_MATRIX_MODE=0x0BA0 +GL_MATRIX_PALETTE_ARB=0x8840 +GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI=0x00200000 +GL_MAT_AMBIENT_BIT_PGI=0x00100000 +GL_MAT_COLOR_INDEXES_BIT_PGI=0x01000000 +GL_MAT_DIFFUSE_BIT_PGI=0x00400000 +GL_MAT_EMISSION_BIT_PGI=0x00800000 +GL_MAT_SHININESS_BIT_PGI=0x02000000 +GL_MAT_SPECULAR_BIT_PGI=0x04000000 +GL_MAX=0x8008 +GL_MAX_3D_TEXTURE_SIZE=0x8073 +GL_MAX_3D_TEXTURE_SIZE_EXT=0x8073 +GL_MAX_4D_TEXTURE_SIZE_SGIS=0x8138 +GL_MAX_ACTIVE_LIGHTS_SGIX=0x8405 +GL_MAX_ARRAY_TEXTURE_LAYERS_EXT=0x88FF +GL_MAX_ASYNC_DRAW_PIXELS_SGIX=0x8360 +GL_MAX_ASYNC_HISTOGRAM_SGIX=0x832D +GL_MAX_ASYNC_READ_PIXELS_SGIX=0x8361 +GL_MAX_ASYNC_TEX_IMAGE_SGIX=0x835F +GL_MAX_ATTRIB_STACK_DEPTH=0x0D35 +GL_MAX_BINDABLE_UNIFORM_SIZE_EXT=0x8DED +GL_MAX_CLIENT_ATTRIB_STACK_DEPTH=0x0D3B +GL_MAX_CLIPMAP_DEPTH_SGIX=0x8177 +GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX=0x8178 +GL_MAX_CLIP_PLANES=0x0D32 +GL_MAX_COLOR_ATTACHMENTS_EXT=0x8CDF +GL_MAX_COLOR_MATRIX_STACK_DEPTH=0x80B3 +GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI=0x80B3 +GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS=0x8B4D +GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB=0x8B4D +GL_MAX_CONVOLUTION_HEIGHT=0x801B +GL_MAX_CONVOLUTION_HEIGHT_EXT=0x801B +GL_MAX_CONVOLUTION_WIDTH=0x801A +GL_MAX_CONVOLUTION_WIDTH_EXT=0x801A +GL_MAX_CUBE_MAP_TEXTURE_SIZE=0x851C +GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB=0x851C +GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT=0x851C +GL_MAX_DEFORMATION_ORDER_SGIX=0x8197 +GL_MAX_DRAW_BUFFERS=0x8824 +GL_MAX_DRAW_BUFFERS_ARB=0x8824 +GL_MAX_DRAW_BUFFERS_ATI=0x8824 +GL_MAX_ELEMENTS_INDICES=0x80E9 +GL_MAX_ELEMENTS_INDICES_EXT=0x80E9 +GL_MAX_ELEMENTS_VERTICES=0x80E8 +GL_MAX_ELEMENTS_VERTICES_EXT=0x80E8 +GL_MAX_EVAL_ORDER=0x0D30 +GL_MAX_EXT=0x8008 +GL_MAX_FOG_FUNC_POINTS_SGIS=0x812C +GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT=0x8DE3 +GL_MAX_FRAGMENT_LIGHTS_SGIX=0x8404 +GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV=0x8868 +GL_MAX_FRAGMENT_UNIFORM_COMPONENTS=0x8B49 +GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB=0x8B49 +GL_MAX_FRAMEZOOM_FACTOR_SGIX=0x818D +GL_MAX_GENERAL_COMBINERS_NV=0x854D +GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT=0x8DE4 +GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT=0x8DE0 +GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT=0x8C29 +GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT=0x8DE1 +GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT=0x8DDF +GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT=0x8DDD +GL_MAX_LIGHTS=0x0D31 +GL_MAX_LIST_NESTING=0x0B31 +GL_MAX_MAP_TESSELLATION_NV=0x86D6 +GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB=0x8841 +GL_MAX_MODELVIEW_STACK_DEPTH=0x0D36 +GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV=0x8E11 +GL_MAX_NAME_STACK_DEPTH=0x0D37 +GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT=0x87CA +GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT=0x87CD +GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT=0x87CE +GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT=0x87CC +GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT=0x87CB +GL_MAX_PALETTE_MATRICES_ARB=0x8842 +GL_MAX_PIXEL_MAP_TABLE=0x0D34 +GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT=0x8337 +GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI=0x87F1 +GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB=0x88B1 +GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB=0x880B +GL_MAX_PROGRAM_ATTRIBS_ARB=0x88AD +GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV=0x8908 +GL_MAX_PROGRAM_CALL_DEPTH_NV=0x88F5 +GL_MAX_PROGRAM_ENV_PARAMETERS_ARB=0x88B5 +GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV=0x88F4 +GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV=0x8DA5 +GL_MAX_PROGRAM_GENERIC_RESULTS_NV=0x8DA6 +GL_MAX_PROGRAM_IF_DEPTH_NV=0x88F6 +GL_MAX_PROGRAM_INSTRUCTIONS_ARB=0x88A1 +GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB=0x88B4 +GL_MAX_PROGRAM_LOOP_COUNT_NV=0x88F8 +GL_MAX_PROGRAM_LOOP_DEPTH_NV=0x88F7 +GL_MAX_PROGRAM_MATRICES_ARB=0x862F +GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB=0x862E +GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB=0x88B3 +GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB=0x880E +GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB=0x88AF +GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB=0x88A3 +GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB=0x88AB +GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB=0x88A7 +GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB=0x8810 +GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB=0x880F +GL_MAX_PROGRAM_OUTPUT_VERTICES_NV=0x8C27 +GL_MAX_PROGRAM_PARAMETERS_ARB=0x88A9 +GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV=0x8DA0 +GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV=0x8DA1 +GL_MAX_PROGRAM_RESULT_COMPONENTS_NV=0x8909 +GL_MAX_PROGRAM_TEMPORARIES_ARB=0x88A5 +GL_MAX_PROGRAM_TEXEL_OFFSET_NV=0x8905 +GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB=0x880D +GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB=0x880C +GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV=0x8C28 +GL_MAX_PROJECTION_STACK_DEPTH=0x0D38 +GL_MAX_RATIONAL_EVAL_ORDER_NV=0x86D7 +GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB=0x84F8 +GL_MAX_RECTANGLE_TEXTURE_SIZE_NV=0x84F8 +GL_MAX_RENDERBUFFER_SIZE_EXT=0x84E8 +GL_MAX_SAMPLES_EXT=0x8D57 +GL_MAX_SHININESS_NV=0x8504 +GL_MAX_SPOT_EXPONENT_NV=0x8505 +GL_MAX_TEXTURE_BUFFER_SIZE_EXT=0x8C2B +GL_MAX_TEXTURE_COORDS=0x8871 +GL_MAX_TEXTURE_COORDS_ARB=0x8871 +GL_MAX_TEXTURE_COORDS_NV=0x8871 +GL_MAX_TEXTURE_IMAGE_UNITS=0x8872 +GL_MAX_TEXTURE_IMAGE_UNITS_ARB=0x8872 +GL_MAX_TEXTURE_IMAGE_UNITS_NV=0x8872 +GL_MAX_TEXTURE_LOD_BIAS=0x84FD +GL_MAX_TEXTURE_LOD_BIAS_EXT=0x84FD +GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT=0x84FF +GL_MAX_TEXTURE_SIZE=0x0D33 +GL_MAX_TEXTURE_STACK_DEPTH=0x0D39 +GL_MAX_TEXTURE_UNITS=0x84E2 +GL_MAX_TEXTURE_UNITS_ARB=0x84E2 +GL_MAX_TRACK_MATRICES_NV=0x862F +GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV=0x862E +GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_ATTRIBS_NV=0x8C8A +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV=0x8C8B +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV=0x8C80 +GL_MAX_VARYING_COMPONENTS_EXT=0x8B4B +GL_MAX_VARYING_FLOATS=0x8B4B +GL_MAX_VARYING_FLOATS_ARB=0x8B4B +GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV=0x8520 +GL_MAX_VERTEX_ATTRIBS=0x8869 +GL_MAX_VERTEX_ATTRIBS_ARB=0x8869 +GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT=0x8DE2 +GL_MAX_VERTEX_HINT_PGI=0x1A22D +GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT=0x87C5 +GL_MAX_VERTEX_SHADER_INVARIANTS_EXT=0x87C7 +GL_MAX_VERTEX_SHADER_LOCALS_EXT=0x87C9 +GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT=0x87C8 +GL_MAX_VERTEX_SHADER_VARIANTS_EXT=0x87C6 +GL_MAX_VERTEX_STREAMS_ATI=0x876B +GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS=0x8B4C +GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB=0x8B4C +GL_MAX_VERTEX_UNIFORM_COMPONENTS=0x8B4A +GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB=0x8B4A +GL_MAX_VERTEX_UNITS_ARB=0x86A4 +GL_MAX_VERTEX_VARYING_COMPONENTS_EXT=0x8DDE +GL_MAX_VIEWPORT_DIMS=0x0D3A +GL_MESAX_texture_stack=1 +GL_MESA_pack_invert=1 +GL_MESA_resize_buffers=1 +GL_MESA_window_pos=1 +GL_MESA_ycbcr_texture=1 +GL_MIN=0x8007 +GL_MINMAX=0x802E +GL_MINMAX_EXT=0x802E +GL_MINMAX_FORMAT=0x802F +GL_MINMAX_FORMAT_EXT=0x802F +GL_MINMAX_SINK=0x8030 +GL_MINMAX_SINK_EXT=0x8030 +GL_MIN_EXT=0x8007 +GL_MIN_PROGRAM_TEXEL_OFFSET_NV=0x8904 +GL_MIRRORED_REPEAT=0x8370 +GL_MIRRORED_REPEAT_ARB=0x8370 +GL_MIRRORED_REPEAT_IBM=0x8370 +GL_MIRROR_CLAMP_ATI=0x8742 +GL_MIRROR_CLAMP_EXT=0x8742 +GL_MIRROR_CLAMP_TO_BORDER_EXT=0x8912 +GL_MIRROR_CLAMP_TO_EDGE_ATI=0x8743 +GL_MIRROR_CLAMP_TO_EDGE_EXT=0x8743 +GL_MODELVIEW0_ARB=0x1700 +GL_MODELVIEW0_EXT=0x1700 +GL_MODELVIEW0_MATRIX_EXT=0x0BA6 +GL_MODELVIEW0_STACK_DEPTH_EXT=0x0BA3 +GL_MODELVIEW10_ARB=0x872A +GL_MODELVIEW11_ARB=0x872B +GL_MODELVIEW12_ARB=0x872C +GL_MODELVIEW13_ARB=0x872D +GL_MODELVIEW14_ARB=0x872E +GL_MODELVIEW15_ARB=0x872F +GL_MODELVIEW16_ARB=0x8730 +GL_MODELVIEW17_ARB=0x8731 +GL_MODELVIEW18_ARB=0x8732 +GL_MODELVIEW19_ARB=0x8733 +GL_MODELVIEW1_ARB=0x850A +GL_MODELVIEW1_EXT=0x850A +GL_MODELVIEW1_MATRIX_EXT=0x8506 +GL_MODELVIEW1_STACK_DEPTH_EXT=0x8502 +GL_MODELVIEW20_ARB=0x8734 +GL_MODELVIEW21_ARB=0x8735 +GL_MODELVIEW22_ARB=0x8736 +GL_MODELVIEW23_ARB=0x8737 +GL_MODELVIEW24_ARB=0x8738 +GL_MODELVIEW25_ARB=0x8739 +GL_MODELVIEW26_ARB=0x873A +GL_MODELVIEW27_ARB=0x873B +GL_MODELVIEW28_ARB=0x873C +GL_MODELVIEW29_ARB=0x873D +GL_MODELVIEW2_ARB=0x8722 +GL_MODELVIEW30_ARB=0x873E +GL_MODELVIEW31_ARB=0x873F +GL_MODELVIEW3_ARB=0x8723 +GL_MODELVIEW4_ARB=0x8724 +GL_MODELVIEW5_ARB=0x8725 +GL_MODELVIEW6_ARB=0x8726 +GL_MODELVIEW7_ARB=0x8727 +GL_MODELVIEW8_ARB=0x8728 +GL_MODELVIEW9_ARB=0x8729 +GL_MODELVIEW=0x1700 +GL_MODELVIEW_MATRIX=0x0BA6 +GL_MODELVIEW_PROJECTION_NV=0x8629 +GL_MODELVIEW_STACK_DEPTH=0x0BA3 +GL_MODULATE=0x2100 +GL_MODULATE_ADD_ATI=0x8744 +GL_MODULATE_SIGNED_ADD_ATI=0x8745 +GL_MODULATE_SUBTRACT_ATI=0x8746 +GL_MOV_ATI=0x8961 +GL_MULT=0x0103 +GL_MULTISAMPLE=0x809D +GL_MULTISAMPLE_3DFX=0x86B2 +GL_MULTISAMPLE_ARB=0x809D +GL_MULTISAMPLE_BIT=0x20000000 +GL_MULTISAMPLE_BIT_3DFX=0x20000000 +GL_MULTISAMPLE_BIT_ARB=0x20000000 +GL_MULTISAMPLE_BIT_EXT=0x20000000 +GL_MULTISAMPLE_COVERAGE_MODES_NV=0x8E12 +GL_MULTISAMPLE_EXT=0x809D +GL_MULTISAMPLE_FILTER_HINT_NV=0x8534 +GL_MULTISAMPLE_SGIS=0x809D +GL_MUL_ATI=0x8964 +GL_MVP_MATRIX_EXT=0x87E3 +GL_N3F_V3F=0x2A25 +GL_NAME_STACK_DEPTH=0x0D70 +GL_NAND=0x150E +GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI=0x1A203 +GL_NATIVE_GRAPHICS_END_HINT_PGI=0x1A204 +GL_NATIVE_GRAPHICS_HANDLE_PGI=0x1A202 +GL_NEAREST=0x2600 +GL_NEAREST_CLIPMAP_LINEAR_SGIX=0x844E +GL_NEAREST_CLIPMAP_NEAREST_SGIX=0x844D +GL_NEAREST_MIPMAP_LINEAR=0x2702 +GL_NEAREST_MIPMAP_NEAREST=0x2700 +GL_NEGATE_BIT_ATI=0x00000004 +GL_NEGATIVE_ONE_EXT=0x87DF +GL_NEGATIVE_W_EXT=0x87DC +GL_NEGATIVE_X_EXT=0x87D9 +GL_NEGATIVE_Y_EXT=0x87DA +GL_NEGATIVE_Z_EXT=0x87DB +GL_NEVER=0x0200 +GL_NICEST=0x1102 +GL_NONE=0 +GL_NOOP=0x1505 +GL_NOR=0x1508 +GL_NORMALIZE=0x0BA1 +GL_NORMALIZED_RANGE_EXT=0x87E0 +GL_NORMAL_ARRAY=0x8075 +GL_NORMAL_ARRAY_BUFFER_BINDING=0x8897 +GL_NORMAL_ARRAY_BUFFER_BINDING_ARB=0x8897 +GL_NORMAL_ARRAY_COUNT_EXT=0x8080 +GL_NORMAL_ARRAY_EXT=0x8075 +GL_NORMAL_ARRAY_LIST_IBM=103071 +GL_NORMAL_ARRAY_LIST_STRIDE_IBM=103081 +GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL=0x83F6 +GL_NORMAL_ARRAY_POINTER=0x808F +GL_NORMAL_ARRAY_POINTER_EXT=0x808F +GL_NORMAL_ARRAY_STRIDE=0x807F +GL_NORMAL_ARRAY_STRIDE_EXT=0x807F +GL_NORMAL_ARRAY_TYPE=0x807E +GL_NORMAL_ARRAY_TYPE_EXT=0x807E +GL_NORMAL_BIT_PGI=0x08000000 +GL_NORMAL_MAP=0x8511 +GL_NORMAL_MAP_ARB=0x8511 +GL_NORMAL_MAP_EXT=0x8511 +GL_NORMAL_MAP_NV=0x8511 +GL_NOTEQUAL=0x0205 +GL_NO_ERROR=0 +GL_NUM_COMPRESSED_TEXTURE_FORMATS=0x86A2 +GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB=0x86A2 +GL_NUM_FRAGMENT_CONSTANTS_ATI=0x896F +GL_NUM_FRAGMENT_REGISTERS_ATI=0x896E +GL_NUM_GENERAL_COMBINERS_NV=0x854E +GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI=0x8973 +GL_NUM_INSTRUCTIONS_PER_PASS_ATI=0x8971 +GL_NUM_INSTRUCTIONS_TOTAL_ATI=0x8972 +GL_NUM_LOOPBACK_COMPONENTS_ATI=0x8974 +GL_NUM_PASSES_ATI=0x8970 +GL_NV_blend_square=1 +GL_NV_copy_depth_to_color=1 +GL_NV_depth_buffer_float=1 +GL_NV_depth_clamp=1 +GL_NV_evaluators=1 +GL_NV_fence=1 +GL_NV_float_buffer=1 +GL_NV_fog_distance=1 +GL_NV_fragment_program2=1 +GL_NV_fragment_program4=1 +GL_NV_fragment_program=1 +GL_NV_fragment_program_option=1 +GL_NV_framebuffer_multisample_coverage=1 +GL_NV_geometry_program4=1 +GL_NV_geometry_shader4=1 +GL_NV_gpu_program4=1 +GL_NV_half_float=1 +GL_NV_light_max_exponent=1 +GL_NV_multisample_filter_hint=1 +GL_NV_occlusion_query=1 +GL_NV_packed_depth_stencil=1 +GL_NV_parameter_buffer_object=1 +GL_NV_pixel_data_range=1 +GL_NV_point_sprite=1 +GL_NV_primitive_restart=1 +GL_NV_register_combiners2=1 +GL_NV_register_combiners=1 +GL_NV_texgen_emboss=1 +GL_NV_texgen_reflection=1 +GL_NV_texture_compression_vtc=1 +GL_NV_texture_env_combine4=1 +GL_NV_texture_expand_normal=1 +GL_NV_texture_rectangle=1 +GL_NV_texture_shader2=1 +GL_NV_texture_shader3=1 +GL_NV_texture_shader=1 +GL_NV_transform_feedback=1 +GL_NV_vertex_array_range2=1 +GL_NV_vertex_array_range=1 +GL_NV_vertex_program1_1=1 +GL_NV_vertex_program2=1 +GL_NV_vertex_program2_option=1 +GL_NV_vertex_program3=1 +GL_NV_vertex_program4=1 +GL_NV_vertex_program=1 +GL_OBJECT_ACTIVE_ATTRIBUTES_ARB=0x8B89 +GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB=0x8B8A +GL_OBJECT_ACTIVE_UNIFORMS_ARB=0x8B86 +GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB=0x8B87 +GL_OBJECT_ATTACHED_OBJECTS_ARB=0x8B85 +GL_OBJECT_BUFFER_SIZE_ATI=0x8764 +GL_OBJECT_BUFFER_USAGE_ATI=0x8765 +GL_OBJECT_COMPILE_STATUS_ARB=0x8B81 +GL_OBJECT_DELETE_STATUS_ARB=0x8B80 +GL_OBJECT_DISTANCE_TO_LINE_SGIS=0x81F3 +GL_OBJECT_DISTANCE_TO_POINT_SGIS=0x81F1 +GL_OBJECT_INFO_LOG_LENGTH_ARB=0x8B84 +GL_OBJECT_LINEAR=0x2401 +GL_OBJECT_LINE_SGIS=0x81F7 +GL_OBJECT_LINK_STATUS_ARB=0x8B82 +GL_OBJECT_PLANE=0x2501 +GL_OBJECT_POINT_SGIS=0x81F5 +GL_OBJECT_SHADER_SOURCE_LENGTH_ARB=0x8B88 +GL_OBJECT_SUBTYPE_ARB=0x8B4F +GL_OBJECT_TYPE_ARB=0x8B4E +GL_OBJECT_VALIDATE_STATUS_ARB=0x8B83 +GL_OCCLUSION_TEST_HP=0x8165 +GL_OCCLUSION_TEST_RESULT_HP=0x8166 +GL_OES_read_format=1 +GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV=0x8856 +GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV=0x8857 +GL_OFFSET_HILO_TEXTURE_2D_NV=0x8854 +GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV=0x8855 +GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV=0x8850 +GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV=0x8851 +GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV=0x8852 +GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV=0x8853 +GL_OFFSET_TEXTURE_2D_BIAS_NV=0x86E3 +GL_OFFSET_TEXTURE_2D_MATRIX_NV=0x86E1 +GL_OFFSET_TEXTURE_2D_NV=0x86E8 +GL_OFFSET_TEXTURE_2D_SCALE_NV=0x86E2 +GL_OFFSET_TEXTURE_BIAS_NV=0x86E3 +GL_OFFSET_TEXTURE_MATRIX_NV=0x86E1 +GL_OFFSET_TEXTURE_RECTANGLE_NV=0x864C +GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV=0x864D +GL_OFFSET_TEXTURE_SCALE_NV=0x86E2 +GL_OML_interlace=1 +GL_OML_resample=1 +GL_OML_subsample=1 +GL_ONE=1 +GL_ONE_EXT=0x87DE +GL_ONE_MINUS_CONSTANT_ALPHA=0x8004 +GL_ONE_MINUS_CONSTANT_ALPHA_EXT=0x8004 +GL_ONE_MINUS_CONSTANT_COLOR=0x8002 +GL_ONE_MINUS_CONSTANT_COLOR_EXT=0x8002 +GL_ONE_MINUS_DST_ALPHA=0x0305 +GL_ONE_MINUS_DST_COLOR=0x0307 +GL_ONE_MINUS_SRC_ALPHA=0x0303 +GL_ONE_MINUS_SRC_COLOR=0x0301 +GL_OPERAND0_ALPHA=0x8598 +GL_OPERAND0_ALPHA_ARB=0x8598 +GL_OPERAND0_ALPHA_EXT=0x8598 +GL_OPERAND0_RGB=0x8590 +GL_OPERAND0_RGB_ARB=0x8590 +GL_OPERAND0_RGB_EXT=0x8590 +GL_OPERAND1_ALPHA=0x8599 +GL_OPERAND1_ALPHA_ARB=0x8599 +GL_OPERAND1_ALPHA_EXT=0x8599 +GL_OPERAND1_RGB=0x8591 +GL_OPERAND1_RGB_ARB=0x8591 +GL_OPERAND1_RGB_EXT=0x8591 +GL_OPERAND2_ALPHA=0x859A +GL_OPERAND2_ALPHA_ARB=0x859A +GL_OPERAND2_ALPHA_EXT=0x859A +GL_OPERAND2_RGB=0x8592 +GL_OPERAND2_RGB_ARB=0x8592 +GL_OPERAND2_RGB_EXT=0x8592 +GL_OPERAND3_ALPHA_NV=0x859B +GL_OPERAND3_RGB_NV=0x8593 +GL_OP_ADD_EXT=0x8787 +GL_OP_CLAMP_EXT=0x878E +GL_OP_CROSS_PRODUCT_EXT=0x8797 +GL_OP_DOT3_EXT=0x8784 +GL_OP_DOT4_EXT=0x8785 +GL_OP_EXP_BASE_2_EXT=0x8791 +GL_OP_FLOOR_EXT=0x878F +GL_OP_FRAC_EXT=0x8789 +GL_OP_INDEX_EXT=0x8782 +GL_OP_LOG_BASE_2_EXT=0x8792 +GL_OP_MADD_EXT=0x8788 +GL_OP_MAX_EXT=0x878A +GL_OP_MIN_EXT=0x878B +GL_OP_MOV_EXT=0x8799 +GL_OP_MULTIPLY_MATRIX_EXT=0x8798 +GL_OP_MUL_EXT=0x8786 +GL_OP_NEGATE_EXT=0x8783 +GL_OP_POWER_EXT=0x8793 +GL_OP_RECIP_EXT=0x8794 +GL_OP_RECIP_SQRT_EXT=0x8795 +GL_OP_ROUND_EXT=0x8790 +GL_OP_SET_GE_EXT=0x878C +GL_OP_SET_LT_EXT=0x878D +GL_OP_SUB_EXT=0x8796 +GL_OR=0x1507 +GL_ORDER=0x0A01 +GL_OR_INVERTED=0x150D +GL_OR_REVERSE=0x150B +GL_OUTPUT_COLOR0_EXT=0x879B +GL_OUTPUT_COLOR1_EXT=0x879C +GL_OUTPUT_FOG_EXT=0x87BD +GL_OUTPUT_TEXTURE_COORD0_EXT=0x879D +GL_OUTPUT_TEXTURE_COORD10_EXT=0x87A7 +GL_OUTPUT_TEXTURE_COORD11_EXT=0x87A8 +GL_OUTPUT_TEXTURE_COORD12_EXT=0x87A9 +GL_OUTPUT_TEXTURE_COORD13_EXT=0x87AA +GL_OUTPUT_TEXTURE_COORD14_EXT=0x87AB +GL_OUTPUT_TEXTURE_COORD15_EXT=0x87AC +GL_OUTPUT_TEXTURE_COORD16_EXT=0x87AD +GL_OUTPUT_TEXTURE_COORD17_EXT=0x87AE +GL_OUTPUT_TEXTURE_COORD18_EXT=0x87AF +GL_OUTPUT_TEXTURE_COORD19_EXT=0x87B0 +GL_OUTPUT_TEXTURE_COORD1_EXT=0x879E +GL_OUTPUT_TEXTURE_COORD20_EXT=0x87B1 +GL_OUTPUT_TEXTURE_COORD21_EXT=0x87B2 +GL_OUTPUT_TEXTURE_COORD22_EXT=0x87B3 +GL_OUTPUT_TEXTURE_COORD23_EXT=0x87B4 +GL_OUTPUT_TEXTURE_COORD24_EXT=0x87B5 +GL_OUTPUT_TEXTURE_COORD25_EXT=0x87B6 +GL_OUTPUT_TEXTURE_COORD26_EXT=0x87B7 +GL_OUTPUT_TEXTURE_COORD27_EXT=0x87B8 +GL_OUTPUT_TEXTURE_COORD28_EXT=0x87B9 +GL_OUTPUT_TEXTURE_COORD29_EXT=0x87BA +GL_OUTPUT_TEXTURE_COORD2_EXT=0x879F +GL_OUTPUT_TEXTURE_COORD30_EXT=0x87BB +GL_OUTPUT_TEXTURE_COORD31_EXT=0x87BC +GL_OUTPUT_TEXTURE_COORD3_EXT=0x87A0 +GL_OUTPUT_TEXTURE_COORD4_EXT=0x87A1 +GL_OUTPUT_TEXTURE_COORD5_EXT=0x87A2 +GL_OUTPUT_TEXTURE_COORD6_EXT=0x87A3 +GL_OUTPUT_TEXTURE_COORD7_EXT=0x87A4 +GL_OUTPUT_TEXTURE_COORD8_EXT=0x87A5 +GL_OUTPUT_TEXTURE_COORD9_EXT=0x87A6 +GL_OUTPUT_VERTEX_EXT=0x879A +GL_OUT_OF_MEMORY=0x0505 +GL_PACK_ALIGNMENT=0x0D05 +GL_PACK_CMYK_HINT_EXT=0x800E +GL_PACK_IMAGE_DEPTH_SGIS=0x8131 +GL_PACK_IMAGE_HEIGHT=0x806C +GL_PACK_IMAGE_HEIGHT_EXT=0x806C +GL_PACK_INVERT_MESA=0x8758 +GL_PACK_LSB_FIRST=0x0D01 +GL_PACK_RESAMPLE_OML=0x8984 +GL_PACK_RESAMPLE_SGIX=0x842C +GL_PACK_ROW_LENGTH=0x0D02 +GL_PACK_SKIP_IMAGES=0x806B +GL_PACK_SKIP_IMAGES_EXT=0x806B +GL_PACK_SKIP_PIXELS=0x0D04 +GL_PACK_SKIP_ROWS=0x0D03 +GL_PACK_SKIP_VOLUMES_SGIS=0x8130 +GL_PACK_SUBSAMPLE_RATE_SGIX=0x85A0 +GL_PACK_SWAP_BYTES=0x0D00 +GL_PARALLEL_ARRAYS_INTEL=0x83F4 +GL_PASS_THROUGH_NV=0x86E6 +GL_PASS_THROUGH_TOKEN=0x0700 +GL_PERSPECTIVE_CORRECTION_HINT=0x0C50 +GL_PERTURB_EXT=0x85AE +GL_PER_STAGE_CONSTANTS_NV=0x8535 +GL_PGI_misc_hints=1 +GL_PGI_vertex_hints=1 +GL_PHONG_HINT_WIN=0x80EB +GL_PHONG_WIN=0x80EA +GL_PIXEL_COUNTER_BITS_NV=0x8864 +GL_PIXEL_COUNT_AVAILABLE_NV=0x8867 +GL_PIXEL_COUNT_NV=0x8866 +GL_PIXEL_CUBIC_WEIGHT_EXT=0x8333 +GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS=0x8355 +GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS=0x8354 +GL_PIXEL_GROUP_COLOR_SGIS=0x8356 +GL_PIXEL_MAG_FILTER_EXT=0x8331 +GL_PIXEL_MAP_A_TO_A=0x0C79 +GL_PIXEL_MAP_A_TO_A_SIZE=0x0CB9 +GL_PIXEL_MAP_B_TO_B=0x0C78 +GL_PIXEL_MAP_B_TO_B_SIZE=0x0CB8 +GL_PIXEL_MAP_G_TO_G=0x0C77 +GL_PIXEL_MAP_G_TO_G_SIZE=0x0CB7 +GL_PIXEL_MAP_I_TO_A=0x0C75 +GL_PIXEL_MAP_I_TO_A_SIZE=0x0CB5 +GL_PIXEL_MAP_I_TO_B=0x0C74 +GL_PIXEL_MAP_I_TO_B_SIZE=0x0CB4 +GL_PIXEL_MAP_I_TO_G=0x0C73 +GL_PIXEL_MAP_I_TO_G_SIZE=0x0CB3 +GL_PIXEL_MAP_I_TO_I=0x0C70 +GL_PIXEL_MAP_I_TO_I_SIZE=0x0CB0 +GL_PIXEL_MAP_I_TO_R=0x0C72 +GL_PIXEL_MAP_I_TO_R_SIZE=0x0CB2 +GL_PIXEL_MAP_R_TO_R=0x0C76 +GL_PIXEL_MAP_R_TO_R_SIZE=0x0CB6 +GL_PIXEL_MAP_S_TO_S=0x0C71 +GL_PIXEL_MAP_S_TO_S_SIZE=0x0CB1 +GL_PIXEL_MIN_FILTER_EXT=0x8332 +GL_PIXEL_MODE_BIT=0x00000020 +GL_PIXEL_PACK_BUFFER=0x88EB +GL_PIXEL_PACK_BUFFER_ARB=0x88EB +GL_PIXEL_PACK_BUFFER_BINDING=0x88ED +GL_PIXEL_PACK_BUFFER_BINDING_ARB=0x88ED +GL_PIXEL_PACK_BUFFER_BINDING_EXT=0x88ED +GL_PIXEL_PACK_BUFFER_EXT=0x88EB +GL_PIXEL_SUBSAMPLE_2424_SGIX=0x85A3 +GL_PIXEL_SUBSAMPLE_4242_SGIX=0x85A4 +GL_PIXEL_SUBSAMPLE_4444_SGIX=0x85A2 +GL_PIXEL_TEXTURE_SGIS=0x8353 +GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX=0x8189 +GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX=0x818A +GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX=0x8188 +GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX=0x8187 +GL_PIXEL_TEX_GEN_MODE_SGIX=0x832B +GL_PIXEL_TEX_GEN_Q_CEILING_SGIX=0x8184 +GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX=0x8186 +GL_PIXEL_TEX_GEN_Q_ROUND_SGIX=0x8185 +GL_PIXEL_TEX_GEN_SGIX=0x8139 +GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX=0x813E +GL_PIXEL_TILE_CACHE_INCREMENT_SGIX=0x813F +GL_PIXEL_TILE_CACHE_SIZE_SGIX=0x8145 +GL_PIXEL_TILE_GRID_DEPTH_SGIX=0x8144 +GL_PIXEL_TILE_GRID_HEIGHT_SGIX=0x8143 +GL_PIXEL_TILE_GRID_WIDTH_SGIX=0x8142 +GL_PIXEL_TILE_HEIGHT_SGIX=0x8141 +GL_PIXEL_TILE_WIDTH_SGIX=0x8140 +GL_PIXEL_TRANSFORM_2D_EXT=0x8330 +GL_PIXEL_TRANSFORM_2D_MATRIX_EXT=0x8338 +GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT=0x8336 +GL_PIXEL_UNPACK_BUFFER=0x88EC +GL_PIXEL_UNPACK_BUFFER_ARB=0x88EC +GL_PIXEL_UNPACK_BUFFER_BINDING=0x88EF +GL_PIXEL_UNPACK_BUFFER_BINDING_ARB=0x88EF +GL_PIXEL_UNPACK_BUFFER_BINDING_EXT=0x88EF +GL_PIXEL_UNPACK_BUFFER_EXT=0x88EC +GL_PN_TRIANGLES_ATI=0x87F0 +GL_PN_TRIANGLES_NORMAL_MODE_ATI=0x87F3 +GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI=0x87F7 +GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI=0x87F8 +GL_PN_TRIANGLES_POINT_MODE_ATI=0x87F2 +GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI=0x87F6 +GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI=0x87F5 +GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI=0x87F4 +GL_POINT=0x1B00 +GL_POINTS=0x0000 +GL_POINT_BIT=0x00000002 +GL_POINT_DISTANCE_ATTENUATION=0x8129 +GL_POINT_DISTANCE_ATTENUATION_ARB=0x8129 +GL_POINT_FADE_THRESHOLD_SIZE=0x8128 +GL_POINT_FADE_THRESHOLD_SIZE_ARB=0x8128 +GL_POINT_FADE_THRESHOLD_SIZE_EXT=0x8128 +GL_POINT_FADE_THRESHOLD_SIZE_SGIS=0x8128 +GL_POINT_SIZE=0x0B11 +GL_POINT_SIZE_GRANULARITY=0x0B13 +GL_POINT_SIZE_MAX=0x8127 +GL_POINT_SIZE_MAX_ARB=0x8127 +GL_POINT_SIZE_MAX_EXT=0x8127 +GL_POINT_SIZE_MAX_SGIS=0x8127 +GL_POINT_SIZE_MIN=0x8126 +GL_POINT_SIZE_MIN_ARB=0x8126 +GL_POINT_SIZE_MIN_EXT=0x8126 +GL_POINT_SIZE_MIN_SGIS=0x8126 +GL_POINT_SIZE_RANGE=0x0B12 +GL_POINT_SMOOTH=0x0B10 +GL_POINT_SMOOTH_HINT=0x0C51 +GL_POINT_SPRITE=0x8861 +GL_POINT_SPRITE_ARB=0x8861 +GL_POINT_SPRITE_COORD_ORIGIN=0x8CA0 +GL_POINT_SPRITE_NV=0x8861 +GL_POINT_SPRITE_R_MODE_NV=0x8863 +GL_POINT_TOKEN=0x0701 +GL_POLYGON=0x0009 +GL_POLYGON_BIT=0x00000008 +GL_POLYGON_MODE=0x0B40 +GL_POLYGON_OFFSET_BIAS_EXT=0x8039 +GL_POLYGON_OFFSET_EXT=0x8037 +GL_POLYGON_OFFSET_FACTOR=0x8038 +GL_POLYGON_OFFSET_FACTOR_EXT=0x8038 +GL_POLYGON_OFFSET_FILL=0x8037 +GL_POLYGON_OFFSET_LINE=0x2A02 +GL_POLYGON_OFFSET_POINT=0x2A01 +GL_POLYGON_OFFSET_UNITS=0x2A00 +GL_POLYGON_SMOOTH=0x0B41 +GL_POLYGON_SMOOTH_HINT=0x0C53 +GL_POLYGON_STIPPLE=0x0B42 +GL_POLYGON_STIPPLE_BIT=0x00000010 +GL_POLYGON_TOKEN=0x0703 +GL_POSITION=0x1203 +GL_POST_COLOR_MATRIX_ALPHA_BIAS=0x80BB +GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI=0x80BB +GL_POST_COLOR_MATRIX_ALPHA_SCALE=0x80B7 +GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI=0x80B7 +GL_POST_COLOR_MATRIX_BLUE_BIAS=0x80BA +GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI=0x80BA +GL_POST_COLOR_MATRIX_BLUE_SCALE=0x80B6 +GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI=0x80B6 +GL_POST_COLOR_MATRIX_COLOR_TABLE=0x80D2 +GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI=0x80D2 +GL_POST_COLOR_MATRIX_GREEN_BIAS=0x80B9 +GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI=0x80B9 +GL_POST_COLOR_MATRIX_GREEN_SCALE=0x80B5 +GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI=0x80B5 +GL_POST_COLOR_MATRIX_RED_BIAS=0x80B8 +GL_POST_COLOR_MATRIX_RED_BIAS_SGI=0x80B8 +GL_POST_COLOR_MATRIX_RED_SCALE=0x80B4 +GL_POST_COLOR_MATRIX_RED_SCALE_SGI=0x80B4 +GL_POST_CONVOLUTION_ALPHA_BIAS=0x8023 +GL_POST_CONVOLUTION_ALPHA_BIAS_EXT=0x8023 +GL_POST_CONVOLUTION_ALPHA_SCALE=0x801F +GL_POST_CONVOLUTION_ALPHA_SCALE_EXT=0x801F +GL_POST_CONVOLUTION_BLUE_BIAS=0x8022 +GL_POST_CONVOLUTION_BLUE_BIAS_EXT=0x8022 +GL_POST_CONVOLUTION_BLUE_SCALE=0x801E +GL_POST_CONVOLUTION_BLUE_SCALE_EXT=0x801E +GL_POST_CONVOLUTION_COLOR_TABLE=0x80D1 +GL_POST_CONVOLUTION_COLOR_TABLE_SGI=0x80D1 +GL_POST_CONVOLUTION_GREEN_BIAS=0x8021 +GL_POST_CONVOLUTION_GREEN_BIAS_EXT=0x8021 +GL_POST_CONVOLUTION_GREEN_SCALE=0x801D +GL_POST_CONVOLUTION_GREEN_SCALE_EXT=0x801D +GL_POST_CONVOLUTION_RED_BIAS=0x8020 +GL_POST_CONVOLUTION_RED_BIAS_EXT=0x8020 +GL_POST_CONVOLUTION_RED_SCALE=0x801C +GL_POST_CONVOLUTION_RED_SCALE_EXT=0x801C +GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP=0x8162 +GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX=0x817B +GL_POST_TEXTURE_FILTER_BIAS_SGIX=0x8179 +GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX=0x817C +GL_POST_TEXTURE_FILTER_SCALE_SGIX=0x817A +GL_PREFER_DOUBLEBUFFER_HINT_PGI=0x1A1F8 +GL_PRESERVE_ATI=0x8762 +GL_PREVIOUS=0x8578 +GL_PREVIOUS_ARB=0x8578 +GL_PREVIOUS_EXT=0x8578 +GL_PREVIOUS_TEXTURE_INPUT_NV=0x86E4 +GL_PRIMARY_COLOR=0x8577 +GL_PRIMARY_COLOR_ARB=0x8577 +GL_PRIMARY_COLOR_EXT=0x8577 +GL_PRIMARY_COLOR_NV=0x852C +GL_PRIMITIVES_GENERATED_NV=0x8C87 +GL_PRIMITIVE_ID_NV=0x8C7C +GL_PRIMITIVE_RESTART_INDEX_NV=0x8559 +GL_PRIMITIVE_RESTART_NV=0x8558 +GL_PROGRAM_ADDRESS_REGISTERS_ARB=0x88B0 +GL_PROGRAM_ALU_INSTRUCTIONS_ARB=0x8805 +GL_PROGRAM_ATTRIBS_ARB=0x88AC +GL_PROGRAM_ATTRIB_COMPONENTS_NV=0x8906 +GL_PROGRAM_BINDING_ARB=0x8677 +GL_PROGRAM_ERROR_POSITION_ARB=0x864B +GL_PROGRAM_ERROR_POSITION_NV=0x864B +GL_PROGRAM_ERROR_STRING_ARB=0x8874 +GL_PROGRAM_ERROR_STRING_NV=0x8874 +GL_PROGRAM_FORMAT_ARB=0x8876 +GL_PROGRAM_FORMAT_ASCII_ARB=0x8875 +GL_PROGRAM_INSTRUCTIONS_ARB=0x88A0 +GL_PROGRAM_LENGTH_ARB=0x8627 +GL_PROGRAM_LENGTH_NV=0x8627 +GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB=0x88B2 +GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB=0x8808 +GL_PROGRAM_NATIVE_ATTRIBS_ARB=0x88AE +GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB=0x88A2 +GL_PROGRAM_NATIVE_PARAMETERS_ARB=0x88AA +GL_PROGRAM_NATIVE_TEMPORARIES_ARB=0x88A6 +GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB=0x880A +GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB=0x8809 +GL_PROGRAM_OBJECT_ARB=0x8B40 +GL_PROGRAM_PARAMETERS_ARB=0x88A8 +GL_PROGRAM_PARAMETER_NV=0x8644 +GL_PROGRAM_POINT_SIZE_EXT=0x8642 +GL_PROGRAM_RESIDENT_NV=0x8647 +GL_PROGRAM_RESULT_COMPONENTS_NV=0x8907 +GL_PROGRAM_STRING_ARB=0x8628 +GL_PROGRAM_STRING_NV=0x8628 +GL_PROGRAM_TARGET_NV=0x8646 +GL_PROGRAM_TEMPORARIES_ARB=0x88A4 +GL_PROGRAM_TEX_INDIRECTIONS_ARB=0x8807 +GL_PROGRAM_TEX_INSTRUCTIONS_ARB=0x8806 +GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB=0x88B6 +GL_PROJECTION=0x1701 +GL_PROJECTION_MATRIX=0x0BA7 +GL_PROJECTION_STACK_DEPTH=0x0BA4 +GL_PROXY_COLOR_TABLE=0x80D3 +GL_PROXY_COLOR_TABLE_SGI=0x80D3 +GL_PROXY_HISTOGRAM=0x8025 +GL_PROXY_HISTOGRAM_EXT=0x8025 +GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE=0x80D5 +GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI=0x80D5 +GL_PROXY_POST_CONVOLUTION_COLOR_TABLE=0x80D4 +GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI=0x80D4 +GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP=0x8163 +GL_PROXY_TEXTURE_1D=0x8063 +GL_PROXY_TEXTURE_1D_ARRAY_EXT=0x8C19 +GL_PROXY_TEXTURE_1D_EXT=0x8063 +GL_PROXY_TEXTURE_1D_STACK_MESAX=0x875B +GL_PROXY_TEXTURE_2D=0x8064 +GL_PROXY_TEXTURE_2D_ARRAY_EXT=0x8C1B +GL_PROXY_TEXTURE_2D_EXT=0x8064 +GL_PROXY_TEXTURE_2D_STACK_MESAX=0x875C +GL_PROXY_TEXTURE_3D=0x8070 +GL_PROXY_TEXTURE_3D_EXT=0x8070 +GL_PROXY_TEXTURE_4D_SGIS=0x8135 +GL_PROXY_TEXTURE_COLOR_TABLE_SGI=0x80BD +GL_PROXY_TEXTURE_CUBE_MAP=0x851B +GL_PROXY_TEXTURE_CUBE_MAP_ARB=0x851B +GL_PROXY_TEXTURE_CUBE_MAP_EXT=0x851B +GL_PROXY_TEXTURE_RECTANGLE_ARB=0x84F7 +GL_PROXY_TEXTURE_RECTANGLE_NV=0x84F7 +GL_Q=0x2003 +GL_QUADRATIC_ATTENUATION=0x1209 +GL_QUADS=0x0007 +GL_QUAD_ALPHA4_SGIS=0x811E +GL_QUAD_ALPHA8_SGIS=0x811F +GL_QUAD_INTENSITY4_SGIS=0x8122 +GL_QUAD_INTENSITY8_SGIS=0x8123 +GL_QUAD_LUMINANCE4_SGIS=0x8120 +GL_QUAD_LUMINANCE8_SGIS=0x8121 +GL_QUAD_MESH_SUN=0x8614 +GL_QUAD_STRIP=0x0008 +GL_QUAD_TEXTURE_SELECT_SGIS=0x8125 +GL_QUARTER_BIT_ATI=0x00000010 +GL_QUERY_COUNTER_BITS=0x8864 +GL_QUERY_COUNTER_BITS_ARB=0x8864 +GL_QUERY_RESULT=0x8866 +GL_QUERY_RESULT_ARB=0x8866 +GL_QUERY_RESULT_AVAILABLE=0x8867 +GL_QUERY_RESULT_AVAILABLE_ARB=0x8867 +GL_R11F_G11F_B10F_EXT=0x8C3A +GL_R1UI_C3F_V3F_SUN=0x85C6 +GL_R1UI_C4F_N3F_V3F_SUN=0x85C8 +GL_R1UI_C4UB_V3F_SUN=0x85C5 +GL_R1UI_N3F_V3F_SUN=0x85C7 +GL_R1UI_T2F_C4F_N3F_V3F_SUN=0x85CB +GL_R1UI_T2F_N3F_V3F_SUN=0x85CA +GL_R1UI_T2F_V3F_SUN=0x85C9 +GL_R1UI_V3F_SUN=0x85C4 +GL_R3_G3_B2=0x2A10 +GL_R=0x2002 +GL_RASTERIZER_DISCARD_NV=0x8C89 +GL_RASTER_POSITION_UNCLIPPED_IBM=0x19262 +GL_READ_BUFFER=0x0C02 +GL_READ_FRAMEBUFFER_BINDING_EXT=0x8CA6 +GL_READ_FRAMEBUFFER_EXT=0x8CA8 +GL_READ_ONLY=0x88B8 +GL_READ_ONLY_ARB=0x88B8 +GL_READ_PIXEL_DATA_RANGE_LENGTH_NV=0x887B +GL_READ_PIXEL_DATA_RANGE_NV=0x8879 +GL_READ_PIXEL_DATA_RANGE_POINTER_NV=0x887D +GL_READ_WRITE=0x88BA +GL_READ_WRITE_ARB=0x88BA +GL_RECLAIM_MEMORY_HINT_PGI=0x1A1FE +GL_RED=0x1903 +GL_REDUCE=0x8016 +GL_REDUCE_EXT=0x8016 +GL_RED_BIAS=0x0D15 +GL_RED_BITS=0x0D52 +GL_RED_BIT_ATI=0x00000001 +GL_RED_INTEGER_EXT=0x8D94 +GL_RED_MAX_CLAMP_INGR=0x8564 +GL_RED_MIN_CLAMP_INGR=0x8560 +GL_RED_SCALE=0x0D14 +GL_REFERENCE_PLANE_EQUATION_SGIX=0x817E +GL_REFERENCE_PLANE_SGIX=0x817D +GL_REFLECTION_MAP=0x8512 +GL_REFLECTION_MAP_ARB=0x8512 +GL_REFLECTION_MAP_EXT=0x8512 +GL_REFLECTION_MAP_NV=0x8512 +GL_REGISTER_COMBINERS_NV=0x8522 +GL_REG_0_ATI=0x8921 +GL_REG_10_ATI=0x892B +GL_REG_11_ATI=0x892C +GL_REG_12_ATI=0x892D +GL_REG_13_ATI=0x892E +GL_REG_14_ATI=0x892F +GL_REG_15_ATI=0x8930 +GL_REG_16_ATI=0x8931 +GL_REG_17_ATI=0x8932 +GL_REG_18_ATI=0x8933 +GL_REG_19_ATI=0x8934 +GL_REG_1_ATI=0x8922 +GL_REG_20_ATI=0x8935 +GL_REG_21_ATI=0x8936 +GL_REG_22_ATI=0x8937 +GL_REG_23_ATI=0x8938 +GL_REG_24_ATI=0x8939 +GL_REG_25_ATI=0x893A +GL_REG_26_ATI=0x893B +GL_REG_27_ATI=0x893C +GL_REG_28_ATI=0x893D +GL_REG_29_ATI=0x893E +GL_REG_2_ATI=0x8923 +GL_REG_30_ATI=0x893F +GL_REG_31_ATI=0x8940 +GL_REG_3_ATI=0x8924 +GL_REG_4_ATI=0x8925 +GL_REG_5_ATI=0x8926 +GL_REG_6_ATI=0x8927 +GL_REG_7_ATI=0x8928 +GL_REG_8_ATI=0x8929 +GL_REG_9_ATI=0x892A +GL_RENDER=0x1C00 +GL_RENDERBUFFER_ALPHA_SIZE_EXT=0x8D53 +GL_RENDERBUFFER_BINDING_EXT=0x8CA7 +GL_RENDERBUFFER_BLUE_SIZE_EXT=0x8D52 +GL_RENDERBUFFER_COLOR_SAMPLES_NV=0x8E10 +GL_RENDERBUFFER_COVERAGE_SAMPLES_NV=0x8CAB +GL_RENDERBUFFER_DEPTH_SIZE_EXT=0x8D54 +GL_RENDERBUFFER_EXT=0x8D41 +GL_RENDERBUFFER_GREEN_SIZE_EXT=0x8D51 +GL_RENDERBUFFER_HEIGHT_EXT=0x8D43 +GL_RENDERBUFFER_INTERNAL_FORMAT_EXT=0x8D44 +GL_RENDERBUFFER_RED_SIZE_EXT=0x8D50 +GL_RENDERBUFFER_SAMPLES_EXT=0x8CAB +GL_RENDERBUFFER_STENCIL_SIZE_EXT=0x8D55 +GL_RENDERBUFFER_WIDTH_EXT=0x8D42 +GL_RENDERER=0x1F01 +GL_RENDER_MODE=0x0C40 +GL_REND_screen_coordinates=1 +GL_REPEAT=0x2901 +GL_REPLACE=0x1E01 +GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN=0x85C3 +GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN=0x85C2 +GL_REPLACEMENT_CODE_ARRAY_SUN=0x85C0 +GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN=0x85C1 +GL_REPLACEMENT_CODE_SUN=0x81D8 +GL_REPLACE_EXT=0x8062 +GL_REPLACE_MIDDLE_SUN=0x0002 +GL_REPLACE_OLDEST_SUN=0x0003 +GL_REPLICATE_BORDER=0x8153 +GL_REPLICATE_BORDER_HP=0x8153 +GL_RESAMPLE_AVERAGE_OML=0x8988 +GL_RESAMPLE_DECIMATE_OML=0x8989 +GL_RESAMPLE_DECIMATE_SGIX=0x8430 +GL_RESAMPLE_REPLICATE_OML=0x8986 +GL_RESAMPLE_REPLICATE_SGIX=0x842E +GL_RESAMPLE_ZERO_FILL_OML=0x8987 +GL_RESAMPLE_ZERO_FILL_SGIX=0x842F +GL_RESCALE_NORMAL=0x803A +GL_RESCALE_NORMAL_EXT=0x803A +GL_RESTART_SUN=0x0001 +GL_RETURN=0x0102 +GL_RGB10=0x8052 +GL_RGB10_A2=0x8059 +GL_RGB10_A2_EXT=0x8059 +GL_RGB10_EXT=0x8052 +GL_RGB12=0x8053 +GL_RGB12_EXT=0x8053 +GL_RGB16=0x8054 +GL_RGB16F_ARB=0x881B +GL_RGB16I_EXT=0x8D89 +GL_RGB16UI_EXT=0x8D77 +GL_RGB16_EXT=0x8054 +GL_RGB2_EXT=0x804E +GL_RGB32F_ARB=0x8815 +GL_RGB32I_EXT=0x8D83 +GL_RGB32UI_EXT=0x8D71 +GL_RGB4=0x804F +GL_RGB4_EXT=0x804F +GL_RGB4_S3TC=0x83A1 +GL_RGB5=0x8050 +GL_RGB5_A1=0x8057 +GL_RGB5_A1_EXT=0x8057 +GL_RGB5_EXT=0x8050 +GL_RGB8=0x8051 +GL_RGB8I_EXT=0x8D8F +GL_RGB8UI_EXT=0x8D7D +GL_RGB8_EXT=0x8051 +GL_RGB9_E5_EXT=0x8C3D +GL_RGB=0x1907 +GL_RGBA12=0x805A +GL_RGBA12_EXT=0x805A +GL_RGBA16=0x805B +GL_RGBA16F_ARB=0x881A +GL_RGBA16I_EXT=0x8D88 +GL_RGBA16UI_EXT=0x8D76 +GL_RGBA16_EXT=0x805B +GL_RGBA2=0x8055 +GL_RGBA2_EXT=0x8055 +GL_RGBA32F_ARB=0x8814 +GL_RGBA32I_EXT=0x8D82 +GL_RGBA32UI_EXT=0x8D70 +GL_RGBA4=0x8056 +GL_RGBA4_EXT=0x8056 +GL_RGBA4_S3TC=0x83A3 +GL_RGBA8=0x8058 +GL_RGBA8I_EXT=0x8D8E +GL_RGBA8UI_EXT=0x8D7C +GL_RGBA8_EXT=0x8058 +GL_RGBA=0x1908 +GL_RGBA_FLOAT16_ATI=0x881A +GL_RGBA_FLOAT32_ATI=0x8814 +GL_RGBA_FLOAT_MODE_ARB=0x8820 +GL_RGBA_INTEGER_EXT=0x8D99 +GL_RGBA_INTEGER_MODE_EXT=0x8D9E +GL_RGBA_MODE=0x0C31 +GL_RGBA_S3TC=0x83A2 +GL_RGBA_SIGNED_COMPONENTS_EXT=0x8C3C +GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV=0x86D9 +GL_RGB_FLOAT16_ATI=0x881B +GL_RGB_FLOAT32_ATI=0x8815 +GL_RGB_INTEGER_EXT=0x8D98 +GL_RGB_S3TC=0x83A0 +GL_RGB_SCALE=0x8573 +GL_RGB_SCALE_ARB=0x8573 +GL_RGB_SCALE_EXT=0x8573 +GL_RIGHT=0x0407 +GL_S3_s3tc=1 +GL_S=0x2000 +GL_SAMPLER_1D=0x8B5D +GL_SAMPLER_1D_ARB=0x8B5D +GL_SAMPLER_1D_ARRAY_EXT=0x8DC0 +GL_SAMPLER_1D_ARRAY_SHADOW_EXT=0x8DC3 +GL_SAMPLER_1D_SHADOW=0x8B61 +GL_SAMPLER_1D_SHADOW_ARB=0x8B61 +GL_SAMPLER_2D=0x8B5E +GL_SAMPLER_2D_ARB=0x8B5E +GL_SAMPLER_2D_ARRAY_EXT=0x8DC1 +GL_SAMPLER_2D_ARRAY_SHADOW_EXT=0x8DC4 +GL_SAMPLER_2D_RECT_ARB=0x8B63 +GL_SAMPLER_2D_RECT_SHADOW_ARB=0x8B64 +GL_SAMPLER_2D_SHADOW=0x8B62 +GL_SAMPLER_2D_SHADOW_ARB=0x8B62 +GL_SAMPLER_3D=0x8B5F +GL_SAMPLER_3D_ARB=0x8B5F +GL_SAMPLER_BUFFER_EXT=0x8DC2 +GL_SAMPLER_CUBE=0x8B60 +GL_SAMPLER_CUBE_ARB=0x8B60 +GL_SAMPLER_CUBE_SHADOW_EXT=0x8DC5 +GL_SAMPLES=0x80A9 +GL_SAMPLES_3DFX=0x86B4 +GL_SAMPLES_ARB=0x80A9 +GL_SAMPLES_EXT=0x80A9 +GL_SAMPLES_PASSED=0x8914 +GL_SAMPLES_PASSED_ARB=0x8914 +GL_SAMPLES_SGIS=0x80A9 +GL_SAMPLE_ALPHA_TO_COVERAGE=0x809E +GL_SAMPLE_ALPHA_TO_COVERAGE_ARB=0x809E +GL_SAMPLE_ALPHA_TO_MASK_EXT=0x809E +GL_SAMPLE_ALPHA_TO_MASK_SGIS=0x809E +GL_SAMPLE_ALPHA_TO_ONE=0x809F +GL_SAMPLE_ALPHA_TO_ONE_ARB=0x809F +GL_SAMPLE_ALPHA_TO_ONE_EXT=0x809F +GL_SAMPLE_ALPHA_TO_ONE_SGIS=0x809F +GL_SAMPLE_BUFFERS=0x80A8 +GL_SAMPLE_BUFFERS_3DFX=0x86B3 +GL_SAMPLE_BUFFERS_ARB=0x80A8 +GL_SAMPLE_BUFFERS_EXT=0x80A8 +GL_SAMPLE_BUFFERS_SGIS=0x80A8 +GL_SAMPLE_COVERAGE=0x80A0 +GL_SAMPLE_COVERAGE_ARB=0x80A0 +GL_SAMPLE_COVERAGE_INVERT=0x80AB +GL_SAMPLE_COVERAGE_INVERT_ARB=0x80AB +GL_SAMPLE_COVERAGE_VALUE=0x80AA +GL_SAMPLE_COVERAGE_VALUE_ARB=0x80AA +GL_SAMPLE_MASK_EXT=0x80A0 +GL_SAMPLE_MASK_INVERT_EXT=0x80AB +GL_SAMPLE_MASK_INVERT_SGIS=0x80AB +GL_SAMPLE_MASK_SGIS=0x80A0 +GL_SAMPLE_MASK_VALUE_EXT=0x80AA +GL_SAMPLE_MASK_VALUE_SGIS=0x80AA +GL_SAMPLE_PATTERN_EXT=0x80AC +GL_SAMPLE_PATTERN_SGIS=0x80AC +GL_SATURATE_BIT_ATI=0x00000040 +GL_SCALAR_EXT=0x87BE +GL_SCALEBIAS_HINT_SGIX=0x8322 +GL_SCALE_BY_FOUR_NV=0x853F +GL_SCALE_BY_ONE_HALF_NV=0x8540 +GL_SCALE_BY_TWO_NV=0x853E +GL_SCISSOR_BIT=0x00080000 +GL_SCISSOR_BOX=0x0C10 +GL_SCISSOR_TEST=0x0C11 +GL_SCREEN_COORDINATES_REND=0x8490 +GL_SECONDARY_COLOR_ARRAY=0x845E +GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING=0x889C +GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB=0x889C +GL_SECONDARY_COLOR_ARRAY_EXT=0x845E +GL_SECONDARY_COLOR_ARRAY_LIST_IBM=103077 +GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM=103087 +GL_SECONDARY_COLOR_ARRAY_POINTER=0x845D +GL_SECONDARY_COLOR_ARRAY_POINTER_EXT=0x845D +GL_SECONDARY_COLOR_ARRAY_SIZE=0x845A +GL_SECONDARY_COLOR_ARRAY_SIZE_EXT=0x845A +GL_SECONDARY_COLOR_ARRAY_STRIDE=0x845C +GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT=0x845C +GL_SECONDARY_COLOR_ARRAY_TYPE=0x845B +GL_SECONDARY_COLOR_ARRAY_TYPE_EXT=0x845B +GL_SECONDARY_COLOR_NV=0x852D +GL_SECONDARY_INTERPOLATOR_ATI=0x896D +GL_SELECT=0x1C02 +GL_SELECTION_BUFFER_POINTER=0x0DF3 +GL_SELECTION_BUFFER_SIZE=0x0DF4 +GL_SEPARABLE_2D=0x8012 +GL_SEPARABLE_2D_EXT=0x8012 +GL_SEPARATE_ATTRIBS_NV=0x8C8D +GL_SEPARATE_SPECULAR_COLOR=0x81FA +GL_SEPARATE_SPECULAR_COLOR_EXT=0x81FA +GL_SET=0x150F +GL_SGIS_detail_texture=1 +GL_SGIS_fog_function=1 +GL_SGIS_generate_mipmap=1 +GL_SGIS_multisample=1 +GL_SGIS_pixel_texture=1 +GL_SGIS_point_line_texgen=1 +GL_SGIS_point_parameters=1 +GL_SGIS_sharpen_texture=1 +GL_SGIS_texture4D=1 +GL_SGIS_texture_border_clamp=1 +GL_SGIS_texture_color_mask=1 +GL_SGIS_texture_edge_clamp=1 +GL_SGIS_texture_filter4=1 +GL_SGIS_texture_lod=1 +GL_SGIX_async=1 +GL_SGIX_async_histogram=1 +GL_SGIX_async_pixel=1 +GL_SGIX_blend_alpha_minmax=1 +GL_SGIX_calligraphic_fragment=1 +GL_SGIX_clipmap=1 +GL_SGIX_convolution_accuracy=1 +GL_SGIX_depth_pass_instrument=1 +GL_SGIX_depth_texture=1 +GL_SGIX_flush_raster=1 +GL_SGIX_fog_offset=1 +GL_SGIX_fog_scale=1 +GL_SGIX_fragment_lighting=1 +GL_SGIX_framezoom=1 +GL_SGIX_igloo_interface=1 +GL_SGIX_instruments=1 +GL_SGIX_interlace=1 +GL_SGIX_ir_instrument1=1 +GL_SGIX_list_priority=1 +GL_SGIX_pixel_texture=1 +GL_SGIX_pixel_tiles=1 +GL_SGIX_polynomial_ffd=1 +GL_SGIX_reference_plane=1 +GL_SGIX_resample=1 +GL_SGIX_scalebias_hint=1 +GL_SGIX_shadow=1 +GL_SGIX_shadow_ambient=1 +GL_SGIX_sprite=1 +GL_SGIX_subsample=1 +GL_SGIX_tag_sample_buffer=1 +GL_SGIX_texture_add_env=1 +GL_SGIX_texture_coordinate_clamp=1 +GL_SGIX_texture_lod_bias=1 +GL_SGIX_texture_multi_buffer=1 +GL_SGIX_texture_scale_bias=1 +GL_SGIX_texture_select=1 +GL_SGIX_vertex_preclip=1 +GL_SGIX_ycrcb=1 +GL_SGIX_ycrcb_subsample=1 +GL_SGIX_ycrcba=1 +GL_SGI_color_matrix=1 +GL_SGI_color_table=1 +GL_SGI_texture_color_table=1 +GL_SHADER_CONSISTENT_NV=0x86DD +GL_SHADER_OBJECT_ARB=0x8B48 +GL_SHADER_OPERATION_NV=0x86DF +GL_SHADER_SOURCE_LENGTH=0x8B88 +GL_SHADER_TYPE=0x8B4F +GL_SHADE_MODEL=0x0B54 +GL_SHADING_LANGUAGE_VERSION=0x8B8C +GL_SHADING_LANGUAGE_VERSION_ARB=0x8B8C +GL_SHADOW_AMBIENT_SGIX=0x80BF +GL_SHADOW_ATTENUATION_EXT=0x834E +GL_SHARED_TEXTURE_PALETTE_EXT=0x81FB +GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS=0x80B0 +GL_SHININESS=0x1601 +GL_SHORT=0x1402 +GL_SIGNED_ALPHA8_NV=0x8706 +GL_SIGNED_ALPHA_NV=0x8705 +GL_SIGNED_HILO16_NV=0x86FA +GL_SIGNED_HILO8_NV=0x885F +GL_SIGNED_HILO_NV=0x86F9 +GL_SIGNED_IDENTITY_NV=0x853C +GL_SIGNED_INTENSITY8_NV=0x8708 +GL_SIGNED_INTENSITY_NV=0x8707 +GL_SIGNED_LUMINANCE8_ALPHA8_NV=0x8704 +GL_SIGNED_LUMINANCE8_NV=0x8702 +GL_SIGNED_LUMINANCE_ALPHA_NV=0x8703 +GL_SIGNED_LUMINANCE_NV=0x8701 +GL_SIGNED_NEGATE_NV=0x853D +GL_SIGNED_RGB8_NV=0x86FF +GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV=0x870D +GL_SIGNED_RGBA8_NV=0x86FC +GL_SIGNED_RGBA_NV=0x86FB +GL_SIGNED_RGB_NV=0x86FE +GL_SIGNED_RGB_UNSIGNED_ALPHA_NV=0x870C +GL_SINGLE_COLOR=0x81F9 +GL_SINGLE_COLOR_EXT=0x81F9 +GL_SLICE_ACCUM_SUN=0x85CC +GL_SLUMINANCE8=0x8C47 +GL_SLUMINANCE8_ALPHA8=0x8C45 +GL_SLUMINANCE8_ALPHA8_EXT=0x8C45 +GL_SLUMINANCE8_EXT=0x8C47 +GL_SLUMINANCE=0x8C46 +GL_SLUMINANCE_ALPHA=0x8C44 +GL_SLUMINANCE_ALPHA_EXT=0x8C44 +GL_SLUMINANCE_EXT=0x8C46 +GL_SMOOTH=0x1D01 +GL_SMOOTH_LINE_WIDTH_GRANULARITY=0x0B23 +GL_SMOOTH_LINE_WIDTH_RANGE=0x0B22 +GL_SMOOTH_POINT_SIZE_GRANULARITY=0x0B13 +GL_SMOOTH_POINT_SIZE_RANGE=0x0B12 +GL_SOURCE0_ALPHA=0x8588 +GL_SOURCE0_ALPHA_ARB=0x8588 +GL_SOURCE0_ALPHA_EXT=0x8588 +GL_SOURCE0_RGB=0x8580 +GL_SOURCE0_RGB_ARB=0x8580 +GL_SOURCE0_RGB_EXT=0x8580 +GL_SOURCE1_ALPHA=0x8589 +GL_SOURCE1_ALPHA_ARB=0x8589 +GL_SOURCE1_ALPHA_EXT=0x8589 +GL_SOURCE1_RGB=0x8581 +GL_SOURCE1_RGB_ARB=0x8581 +GL_SOURCE1_RGB_EXT=0x8581 +GL_SOURCE2_ALPHA=0x858A +GL_SOURCE2_ALPHA_ARB=0x858A +GL_SOURCE2_ALPHA_EXT=0x858A +GL_SOURCE2_RGB=0x8582 +GL_SOURCE2_RGB_ARB=0x8582 +GL_SOURCE2_RGB_EXT=0x8582 +GL_SOURCE3_ALPHA_NV=0x858B +GL_SOURCE3_RGB_NV=0x8583 +GL_SPARE0_NV=0x852E +GL_SPARE0_PLUS_SECONDARY_COLOR_NV=0x8532 +GL_SPARE1_NV=0x852F +GL_SPECULAR=0x1202 +GL_SPHERE_MAP=0x2402 +GL_SPOT_CUTOFF=0x1206 +GL_SPOT_DIRECTION=0x1204 +GL_SPOT_EXPONENT=0x1205 +GL_SPRITE_AXIAL_SGIX=0x814C +GL_SPRITE_AXIS_SGIX=0x814A +GL_SPRITE_EYE_ALIGNED_SGIX=0x814E +GL_SPRITE_MODE_SGIX=0x8149 +GL_SPRITE_OBJECT_ALIGNED_SGIX=0x814D +GL_SPRITE_SGIX=0x8148 +GL_SPRITE_TRANSLATION_SGIX=0x814B +GL_SRC0_ALPHA=0x8588 +GL_SRC0_RGB=0x8580 +GL_SRC1_ALPHA=0x8589 +GL_SRC1_RGB=0x8581 +GL_SRC2_ALPHA=0x858A +GL_SRC2_RGB=0x8582 +GL_SRC_ALPHA=0x0302 +GL_SRC_ALPHA_SATURATE=0x0308 +GL_SRC_COLOR=0x0300 +GL_SRGB8=0x8C41 +GL_SRGB8_ALPHA8=0x8C43 +GL_SRGB8_ALPHA8_EXT=0x8C43 +GL_SRGB8_EXT=0x8C41 +GL_SRGB=0x8C40 +GL_SRGB_ALPHA=0x8C42 +GL_SRGB_ALPHA_EXT=0x8C42 +GL_SRGB_EXT=0x8C40 +GL_STACK_OVERFLOW=0x0503 +GL_STACK_UNDERFLOW=0x0504 +GL_STATIC_ATI=0x8760 +GL_STATIC_COPY=0x88E6 +GL_STATIC_COPY_ARB=0x88E6 +GL_STATIC_DRAW=0x88E4 +GL_STATIC_DRAW_ARB=0x88E4 +GL_STATIC_READ=0x88E5 +GL_STATIC_READ_ARB=0x88E5 +GL_STENCIL=0x1802 +GL_STENCIL_ATTACHMENT_EXT=0x8D20 +GL_STENCIL_BACK_FAIL=0x8801 +GL_STENCIL_BACK_FAIL_ATI=0x8801 +GL_STENCIL_BACK_FUNC=0x8800 +GL_STENCIL_BACK_FUNC_ATI=0x8800 +GL_STENCIL_BACK_PASS_DEPTH_FAIL=0x8802 +GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI=0x8802 +GL_STENCIL_BACK_PASS_DEPTH_PASS=0x8803 +GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI=0x8803 +GL_STENCIL_BACK_REF=0x8CA3 +GL_STENCIL_BACK_VALUE_MASK=0x8CA4 +GL_STENCIL_BACK_WRITEMASK=0x8CA5 +GL_STENCIL_BITS=0x0D57 +GL_STENCIL_BUFFER_BIT=0x00000400 +GL_STENCIL_CLEAR_TAG_VALUE_EXT=0x88F3 +GL_STENCIL_CLEAR_VALUE=0x0B91 +GL_STENCIL_FAIL=0x0B94 +GL_STENCIL_FUNC=0x0B92 +GL_STENCIL_INDEX16_EXT=0x8D49 +GL_STENCIL_INDEX1_EXT=0x8D46 +GL_STENCIL_INDEX4_EXT=0x8D47 +GL_STENCIL_INDEX8_EXT=0x8D48 +GL_STENCIL_INDEX=0x1901 +GL_STENCIL_PASS_DEPTH_FAIL=0x0B95 +GL_STENCIL_PASS_DEPTH_PASS=0x0B96 +GL_STENCIL_REF=0x0B97 +GL_STENCIL_TAG_BITS_EXT=0x88F2 +GL_STENCIL_TEST=0x0B90 +GL_STENCIL_TEST_TWO_SIDE_EXT=0x8910 +GL_STENCIL_VALUE_MASK=0x0B93 +GL_STENCIL_WRITEMASK=0x0B98 +GL_STEREO=0x0C33 +GL_STORAGE_CACHED_APPLE=0x85BE +GL_STORAGE_SHARED_APPLE=0x85BF +GL_STREAM_COPY=0x88E2 +GL_STREAM_COPY_ARB=0x88E2 +GL_STREAM_DRAW=0x88E0 +GL_STREAM_DRAW_ARB=0x88E0 +GL_STREAM_READ=0x88E1 +GL_STREAM_READ_ARB=0x88E1 +GL_STRICT_DEPTHFUNC_HINT_PGI=0x1A216 +GL_STRICT_LIGHTING_HINT_PGI=0x1A217 +GL_STRICT_SCISSOR_HINT_PGI=0x1A218 +GL_SUBPIXEL_BITS=0x0D50 +GL_SUBTRACT=0x84E7 +GL_SUBTRACT_ARB=0x84E7 +GL_SUB_ATI=0x8965 +GL_SUNX_constant_data=1 +GL_SUN_convolution_border_modes=1 +GL_SUN_global_alpha=1 +GL_SUN_mesh_array=1 +GL_SUN_slice_accum=1 +GL_SUN_triangle_list=1 +GL_SUN_vertex=1 +GL_SWIZZLE_STQ_ATI=0x8977 +GL_SWIZZLE_STQ_DQ_ATI=0x8979 +GL_SWIZZLE_STRQ_ATI=0x897A +GL_SWIZZLE_STRQ_DQ_ATI=0x897B +GL_SWIZZLE_STR_ATI=0x8976 +GL_SWIZZLE_STR_DR_ATI=0x8978 +GL_T2F_C3F_V3F=0x2A2A +GL_T2F_C4F_N3F_V3F=0x2A2C +GL_T2F_C4UB_V3F=0x2A29 +GL_T2F_IUI_N3F_V2F_EXT=0x81B3 +GL_T2F_IUI_N3F_V3F_EXT=0x81B4 +GL_T2F_IUI_V2F_EXT=0x81B1 +GL_T2F_IUI_V3F_EXT=0x81B2 +GL_T2F_N3F_V3F=0x2A2B +GL_T2F_V3F=0x2A27 +GL_T4F_C4F_N3F_V4F=0x2A2D +GL_T4F_V4F=0x2A28 +GL_T=0x2001 +GL_TABLE_TOO_LARGE=0x8031 +GL_TABLE_TOO_LARGE_EXT=0x8031 +GL_TANGENT_ARRAY_EXT=0x8439 +GL_TANGENT_ARRAY_POINTER_EXT=0x8442 +GL_TANGENT_ARRAY_STRIDE_EXT=0x843F +GL_TANGENT_ARRAY_TYPE_EXT=0x843E +GL_TEXCOORD1_BIT_PGI=0x10000000 +GL_TEXCOORD2_BIT_PGI=0x20000000 +GL_TEXCOORD3_BIT_PGI=0x40000000 +GL_TEXCOORD4_BIT_PGI=0x80000000 +GL_TEXTURE0=0x84C0 +GL_TEXTURE0_ARB=0x84C0 +GL_TEXTURE10=0x84CA +GL_TEXTURE10_ARB=0x84CA +GL_TEXTURE11=0x84CB +GL_TEXTURE11_ARB=0x84CB +GL_TEXTURE12=0x84CC +GL_TEXTURE12_ARB=0x84CC +GL_TEXTURE13=0x84CD +GL_TEXTURE13_ARB=0x84CD +GL_TEXTURE14=0x84CE +GL_TEXTURE14_ARB=0x84CE +GL_TEXTURE15=0x84CF +GL_TEXTURE15_ARB=0x84CF +GL_TEXTURE16=0x84D0 +GL_TEXTURE16_ARB=0x84D0 +GL_TEXTURE17=0x84D1 +GL_TEXTURE17_ARB=0x84D1 +GL_TEXTURE18=0x84D2 +GL_TEXTURE18_ARB=0x84D2 +GL_TEXTURE19=0x84D3 +GL_TEXTURE19_ARB=0x84D3 +GL_TEXTURE1=0x84C1 +GL_TEXTURE1_ARB=0x84C1 +GL_TEXTURE20=0x84D4 +GL_TEXTURE20_ARB=0x84D4 +GL_TEXTURE21=0x84D5 +GL_TEXTURE21_ARB=0x84D5 +GL_TEXTURE22=0x84D6 +GL_TEXTURE22_ARB=0x84D6 +GL_TEXTURE23=0x84D7 +GL_TEXTURE23_ARB=0x84D7 +GL_TEXTURE24=0x84D8 +GL_TEXTURE24_ARB=0x84D8 +GL_TEXTURE25=0x84D9 +GL_TEXTURE25_ARB=0x84D9 +GL_TEXTURE26=0x84DA +GL_TEXTURE26_ARB=0x84DA +GL_TEXTURE27=0x84DB +GL_TEXTURE27_ARB=0x84DB +GL_TEXTURE28=0x84DC +GL_TEXTURE28_ARB=0x84DC +GL_TEXTURE29=0x84DD +GL_TEXTURE29_ARB=0x84DD +GL_TEXTURE2=0x84C2 +GL_TEXTURE2_ARB=0x84C2 +GL_TEXTURE30=0x84DE +GL_TEXTURE30_ARB=0x84DE +GL_TEXTURE31=0x84DF +GL_TEXTURE31_ARB=0x84DF +GL_TEXTURE3=0x84C3 +GL_TEXTURE3_ARB=0x84C3 +GL_TEXTURE4=0x84C4 +GL_TEXTURE4_ARB=0x84C4 +GL_TEXTURE5=0x84C5 +GL_TEXTURE5_ARB=0x84C5 +GL_TEXTURE6=0x84C6 +GL_TEXTURE6_ARB=0x84C6 +GL_TEXTURE7=0x84C7 +GL_TEXTURE7_ARB=0x84C7 +GL_TEXTURE8=0x84C8 +GL_TEXTURE8_ARB=0x84C8 +GL_TEXTURE9=0x84C9 +GL_TEXTURE9_ARB=0x84C9 +GL_TEXTURE=0x1702 +GL_TEXTURE_1D=0x0DE0 +GL_TEXTURE_1D_ARRAY_EXT=0x8C18 +GL_TEXTURE_1D_BINDING_EXT=0x8068 +GL_TEXTURE_1D_STACK_BINDING_MESAX=0x875D +GL_TEXTURE_1D_STACK_MESAX=0x8759 +GL_TEXTURE_2D=0x0DE1 +GL_TEXTURE_2D_ARRAY_EXT=0x8C1A +GL_TEXTURE_2D_BINDING_EXT=0x8069 +GL_TEXTURE_2D_STACK_BINDING_MESAX=0x875E +GL_TEXTURE_2D_STACK_MESAX=0x875A +GL_TEXTURE_3D=0x806F +GL_TEXTURE_3D_BINDING_EXT=0x806A +GL_TEXTURE_3D_EXT=0x806F +GL_TEXTURE_4DSIZE_SGIS=0x8136 +GL_TEXTURE_4D_BINDING_SGIS=0x814F +GL_TEXTURE_4D_SGIS=0x8134 +GL_TEXTURE_ALPHA_SIZE=0x805F +GL_TEXTURE_ALPHA_SIZE_EXT=0x805F +GL_TEXTURE_ALPHA_TYPE_ARB=0x8C13 +GL_TEXTURE_APPLICATION_MODE_EXT=0x834F +GL_TEXTURE_BASE_LEVEL=0x813C +GL_TEXTURE_BASE_LEVEL_SGIS=0x813C +GL_TEXTURE_BINDING_1D=0x8068 +GL_TEXTURE_BINDING_1D_ARRAY_EXT=0x8C1C +GL_TEXTURE_BINDING_2D=0x8069 +GL_TEXTURE_BINDING_2D_ARRAY_EXT=0x8C1D +GL_TEXTURE_BINDING_3D=0x806A +GL_TEXTURE_BINDING_BUFFER_EXT=0x8C2C +GL_TEXTURE_BINDING_CUBE_MAP=0x8514 +GL_TEXTURE_BINDING_CUBE_MAP_ARB=0x8514 +GL_TEXTURE_BINDING_CUBE_MAP_EXT=0x8514 +GL_TEXTURE_BINDING_RECTANGLE_ARB=0x84F6 +GL_TEXTURE_BINDING_RECTANGLE_NV=0x84F6 +GL_TEXTURE_BIT=0x00040000 +GL_TEXTURE_BLUE_SIZE=0x805E +GL_TEXTURE_BLUE_SIZE_EXT=0x805E +GL_TEXTURE_BLUE_TYPE_ARB=0x8C12 +GL_TEXTURE_BORDER=0x1005 +GL_TEXTURE_BORDER_COLOR=0x1004 +GL_TEXTURE_BORDER_VALUES_NV=0x871A +GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT=0x8C2D +GL_TEXTURE_BUFFER_EXT=0x8C2A +GL_TEXTURE_BUFFER_FORMAT_EXT=0x8C2E +GL_TEXTURE_CLIPMAP_CENTER_SGIX=0x8171 +GL_TEXTURE_CLIPMAP_DEPTH_SGIX=0x8176 +GL_TEXTURE_CLIPMAP_FRAME_SGIX=0x8172 +GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX=0x8175 +GL_TEXTURE_CLIPMAP_OFFSET_SGIX=0x8173 +GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX=0x8174 +GL_TEXTURE_COLOR_TABLE_SGI=0x80BC +GL_TEXTURE_COLOR_WRITEMASK_SGIS=0x81EF +GL_TEXTURE_COMPARE_FAIL_VALUE_ARB=0x80BF +GL_TEXTURE_COMPARE_FUNC=0x884D +GL_TEXTURE_COMPARE_FUNC_ARB=0x884D +GL_TEXTURE_COMPARE_MODE=0x884C +GL_TEXTURE_COMPARE_MODE_ARB=0x884C +GL_TEXTURE_COMPARE_OPERATOR_SGIX=0x819B +GL_TEXTURE_COMPARE_SGIX=0x819A +GL_TEXTURE_COMPONENTS=0x1003 +GL_TEXTURE_COMPRESSED=0x86A1 +GL_TEXTURE_COMPRESSED_ARB=0x86A1 +GL_TEXTURE_COMPRESSED_IMAGE_SIZE=0x86A0 +GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB=0x86A0 +GL_TEXTURE_COMPRESSION_HINT=0x84EF +GL_TEXTURE_COMPRESSION_HINT_ARB=0x84EF +GL_TEXTURE_CONSTANT_DATA_SUNX=0x81D6 +GL_TEXTURE_COORD_ARRAY=0x8078 +GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING=0x889A +GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB=0x889A +GL_TEXTURE_COORD_ARRAY_COUNT_EXT=0x808B +GL_TEXTURE_COORD_ARRAY_EXT=0x8078 +GL_TEXTURE_COORD_ARRAY_LIST_IBM=103074 +GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM=103084 +GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL=0x83F8 +GL_TEXTURE_COORD_ARRAY_POINTER=0x8092 +GL_TEXTURE_COORD_ARRAY_POINTER_EXT=0x8092 +GL_TEXTURE_COORD_ARRAY_SIZE=0x8088 +GL_TEXTURE_COORD_ARRAY_SIZE_EXT=0x8088 +GL_TEXTURE_COORD_ARRAY_STRIDE=0x808A +GL_TEXTURE_COORD_ARRAY_STRIDE_EXT=0x808A +GL_TEXTURE_COORD_ARRAY_TYPE=0x8089 +GL_TEXTURE_COORD_ARRAY_TYPE_EXT=0x8089 +GL_TEXTURE_COORD_NV=0x8C79 +GL_TEXTURE_CUBE_MAP=0x8513 +GL_TEXTURE_CUBE_MAP_ARB=0x8513 +GL_TEXTURE_CUBE_MAP_EXT=0x8513 +GL_TEXTURE_CUBE_MAP_NEGATIVE_X=0x8516 +GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB=0x8516 +GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT=0x8516 +GL_TEXTURE_CUBE_MAP_NEGATIVE_Y=0x8518 +GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB=0x8518 +GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT=0x8518 +GL_TEXTURE_CUBE_MAP_NEGATIVE_Z=0x851A +GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB=0x851A +GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT=0x851A +GL_TEXTURE_CUBE_MAP_POSITIVE_X=0x8515 +GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB=0x8515 +GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT=0x8515 +GL_TEXTURE_CUBE_MAP_POSITIVE_Y=0x8517 +GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB=0x8517 +GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT=0x8517 +GL_TEXTURE_CUBE_MAP_POSITIVE_Z=0x8519 +GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB=0x8519 +GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT=0x8519 +GL_TEXTURE_DEFORMATION_BIT_SGIX=0x00000001 +GL_TEXTURE_DEFORMATION_SGIX=0x8195 +GL_TEXTURE_DEPTH=0x8071 +GL_TEXTURE_DEPTH_EXT=0x8071 +GL_TEXTURE_DEPTH_SIZE=0x884A +GL_TEXTURE_DEPTH_SIZE_ARB=0x884A +GL_TEXTURE_DEPTH_TYPE_ARB=0x8C16 +GL_TEXTURE_DS_SIZE_NV=0x871D +GL_TEXTURE_DT_SIZE_NV=0x871E +GL_TEXTURE_ENV=0x2300 +GL_TEXTURE_ENV_BIAS_SGIX=0x80BE +GL_TEXTURE_ENV_COLOR=0x2201 +GL_TEXTURE_ENV_MODE=0x2200 +GL_TEXTURE_FILTER4_SIZE_SGIS=0x8147 +GL_TEXTURE_FILTER_CONTROL=0x8500 +GL_TEXTURE_FILTER_CONTROL_EXT=0x8500 +GL_TEXTURE_FLOAT_COMPONENTS_NV=0x888C +GL_TEXTURE_GEN_MODE=0x2500 +GL_TEXTURE_GEN_Q=0x0C63 +GL_TEXTURE_GEN_R=0x0C62 +GL_TEXTURE_GEN_S=0x0C60 +GL_TEXTURE_GEN_T=0x0C61 +GL_TEXTURE_GEQUAL_R_SGIX=0x819D +GL_TEXTURE_GREEN_SIZE=0x805D +GL_TEXTURE_GREEN_SIZE_EXT=0x805D +GL_TEXTURE_GREEN_TYPE_ARB=0x8C11 +GL_TEXTURE_HEIGHT=0x1001 +GL_TEXTURE_HI_SIZE_NV=0x871B +GL_TEXTURE_INDEX_SIZE_EXT=0x80ED +GL_TEXTURE_INTENSITY_SIZE=0x8061 +GL_TEXTURE_INTENSITY_SIZE_EXT=0x8061 +GL_TEXTURE_INTENSITY_TYPE_ARB=0x8C15 +GL_TEXTURE_INTERNAL_FORMAT=0x1003 +GL_TEXTURE_LEQUAL_R_SGIX=0x819C +GL_TEXTURE_LIGHTING_MODE_HP=0x8167 +GL_TEXTURE_LIGHT_EXT=0x8350 +GL_TEXTURE_LOD_BIAS=0x8501 +GL_TEXTURE_LOD_BIAS_EXT=0x8501 +GL_TEXTURE_LOD_BIAS_R_SGIX=0x8190 +GL_TEXTURE_LOD_BIAS_S_SGIX=0x818E +GL_TEXTURE_LOD_BIAS_T_SGIX=0x818F +GL_TEXTURE_LO_SIZE_NV=0x871C +GL_TEXTURE_LUMINANCE_SIZE=0x8060 +GL_TEXTURE_LUMINANCE_SIZE_EXT=0x8060 +GL_TEXTURE_LUMINANCE_TYPE_ARB=0x8C14 +GL_TEXTURE_MAG_FILTER=0x2800 +GL_TEXTURE_MAG_SIZE_NV=0x871F +GL_TEXTURE_MATERIAL_FACE_EXT=0x8351 +GL_TEXTURE_MATERIAL_PARAMETER_EXT=0x8352 +GL_TEXTURE_MATRIX=0x0BA8 +GL_TEXTURE_MAX_ANISOTROPY_EXT=0x84FE +GL_TEXTURE_MAX_CLAMP_R_SGIX=0x836B +GL_TEXTURE_MAX_CLAMP_S_SGIX=0x8369 +GL_TEXTURE_MAX_CLAMP_T_SGIX=0x836A +GL_TEXTURE_MAX_LEVEL=0x813D +GL_TEXTURE_MAX_LEVEL_SGIS=0x813D +GL_TEXTURE_MAX_LOD=0x813B +GL_TEXTURE_MAX_LOD_SGIS=0x813B +GL_TEXTURE_MIN_FILTER=0x2801 +GL_TEXTURE_MIN_LOD=0x813A +GL_TEXTURE_MIN_LOD_SGIS=0x813A +GL_TEXTURE_MULTI_BUFFER_HINT_SGIX=0x812E +GL_TEXTURE_NORMAL_EXT=0x85AF +GL_TEXTURE_POST_SPECULAR_HP=0x8168 +GL_TEXTURE_PRE_SPECULAR_HP=0x8169 +GL_TEXTURE_PRIORITY=0x8066 +GL_TEXTURE_PRIORITY_EXT=0x8066 +GL_TEXTURE_RECTANGLE_ARB=0x84F5 +GL_TEXTURE_RECTANGLE_NV=0x84F5 +GL_TEXTURE_RED_SIZE=0x805C +GL_TEXTURE_RED_SIZE_EXT=0x805C +GL_TEXTURE_RED_TYPE_ARB=0x8C10 +GL_TEXTURE_RESIDENT=0x8067 +GL_TEXTURE_RESIDENT_EXT=0x8067 +GL_TEXTURE_SHADER_NV=0x86DE +GL_TEXTURE_SHARED_SIZE_EXT=0x8C3F +GL_TEXTURE_STACK_DEPTH=0x0BA5 +GL_TEXTURE_STENCIL_SIZE_EXT=0x88F1 +GL_TEXTURE_TOO_LARGE_EXT=0x8065 +GL_TEXTURE_UNSIGNED_REMAP_MODE_NV=0x888F +GL_TEXTURE_WIDTH=0x1000 +GL_TEXTURE_WRAP_Q_SGIS=0x8137 +GL_TEXTURE_WRAP_R=0x8072 +GL_TEXTURE_WRAP_R_EXT=0x8072 +GL_TEXTURE_WRAP_S=0x2802 +GL_TEXTURE_WRAP_T=0x2803 +GL_TEXT_FRAGMENT_SHADER_ATI=0x8200 +GL_TIME_ELAPSED_EXT=0x88BF +GL_TRACK_MATRIX_NV=0x8648 +GL_TRACK_MATRIX_TRANSFORM_NV=0x8649 +GL_TRANSFORM_BIT=0x00001000 +GL_TRANSFORM_FEEDBACK_ATTRIBS_NV=0x8C7E +GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV=0x8C8F +GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV=0x8C7F +GL_TRANSFORM_FEEDBACK_BUFFER_NV=0x8C8E +GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV=0x8C85 +GL_TRANSFORM_FEEDBACK_BUFFER_START_NV=0x8C84 +GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV=0x8C88 +GL_TRANSFORM_FEEDBACK_RECORD_NV=0x8C86 +GL_TRANSFORM_FEEDBACK_VARYINGS_NV=0x8C83 +GL_TRANSFORM_HINT_APPLE=0x85B1 +GL_TRANSPOSE_COLOR_MATRIX=0x84E6 +GL_TRANSPOSE_COLOR_MATRIX_ARB=0x84E6 +GL_TRANSPOSE_CURRENT_MATRIX_ARB=0x88B7 +GL_TRANSPOSE_MODELVIEW_MATRIX=0x84E3 +GL_TRANSPOSE_MODELVIEW_MATRIX_ARB=0x84E3 +GL_TRANSPOSE_NV=0x862C +GL_TRANSPOSE_PROJECTION_MATRIX=0x84E4 +GL_TRANSPOSE_PROJECTION_MATRIX_ARB=0x84E4 +GL_TRANSPOSE_TEXTURE_MATRIX=0x84E5 +GL_TRANSPOSE_TEXTURE_MATRIX_ARB=0x84E5 +GL_TRIANGLES=0x0004 +GL_TRIANGLES_ADJACENCY_EXT=0x000C +GL_TRIANGLE_FAN=0x0006 +GL_TRIANGLE_LIST_SUN=0x81D7 +GL_TRIANGLE_MESH_SUN=0x8615 +GL_TRIANGLE_STRIP=0x0005 +GL_TRIANGLE_STRIP_ADJACENCY_EXT=0x000D +GL_TRUE=1 +GL_TYPE_RGBA_FLOAT_ATI=0x8820 +GL_UNIFORM_BUFFER_BINDING_EXT=0x8DEF +GL_UNIFORM_BUFFER_EXT=0x8DEE +GL_UNPACK_ALIGNMENT=0x0CF5 +GL_UNPACK_CLIENT_STORAGE_APPLE=0x85B2 +GL_UNPACK_CMYK_HINT_EXT=0x800F +GL_UNPACK_CONSTANT_DATA_SUNX=0x81D5 +GL_UNPACK_IMAGE_DEPTH_SGIS=0x8133 +GL_UNPACK_IMAGE_HEIGHT=0x806E +GL_UNPACK_IMAGE_HEIGHT_EXT=0x806E +GL_UNPACK_LSB_FIRST=0x0CF1 +GL_UNPACK_RESAMPLE_OML=0x8985 +GL_UNPACK_RESAMPLE_SGIX=0x842D +GL_UNPACK_ROW_LENGTH=0x0CF2 +GL_UNPACK_SKIP_IMAGES=0x806D +GL_UNPACK_SKIP_IMAGES_EXT=0x806D +GL_UNPACK_SKIP_PIXELS=0x0CF4 +GL_UNPACK_SKIP_ROWS=0x0CF3 +GL_UNPACK_SKIP_VOLUMES_SGIS=0x8132 +GL_UNPACK_SUBSAMPLE_RATE_SGIX=0x85A1 +GL_UNPACK_SWAP_BYTES=0x0CF0 +GL_UNSIGNED_BYTE=0x1401 +GL_UNSIGNED_BYTE_2_3_3_REV=0x8362 +GL_UNSIGNED_BYTE_3_3_2=0x8032 +GL_UNSIGNED_BYTE_3_3_2_EXT=0x8032 +GL_UNSIGNED_IDENTITY_NV=0x8536 +GL_UNSIGNED_INT=0x1405 +GL_UNSIGNED_INT_10F_11F_11F_REV_EXT=0x8C3B +GL_UNSIGNED_INT_10_10_10_2=0x8036 +GL_UNSIGNED_INT_10_10_10_2_EXT=0x8036 +GL_UNSIGNED_INT_24_8_EXT=0x84FA +GL_UNSIGNED_INT_24_8_NV=0x84FA +GL_UNSIGNED_INT_2_10_10_10_REV=0x8368 +GL_UNSIGNED_INT_5_9_9_9_REV_EXT=0x8C3E +GL_UNSIGNED_INT_8_8_8_8=0x8035 +GL_UNSIGNED_INT_8_8_8_8_EXT=0x8035 +GL_UNSIGNED_INT_8_8_8_8_REV=0x8367 +GL_UNSIGNED_INT_8_8_S8_S8_REV_NV=0x86DB +GL_UNSIGNED_INT_S8_S8_8_8_NV=0x86DA +GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT=0x8DD6 +GL_UNSIGNED_INT_SAMPLER_1D_EXT=0x8DD1 +GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT=0x8DD7 +GL_UNSIGNED_INT_SAMPLER_2D_EXT=0x8DD2 +GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT=0x8DD5 +GL_UNSIGNED_INT_SAMPLER_3D_EXT=0x8DD3 +GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT=0x8DD8 +GL_UNSIGNED_INT_SAMPLER_CUBE_EXT=0x8DD4 +GL_UNSIGNED_INT_VEC2_EXT=0x8DC6 +GL_UNSIGNED_INT_VEC3_EXT=0x8DC7 +GL_UNSIGNED_INT_VEC4_EXT=0x8DC8 +GL_UNSIGNED_INVERT_NV=0x8537 +GL_UNSIGNED_NORMALIZED_ARB=0x8C17 +GL_UNSIGNED_SHORT=0x1403 +GL_UNSIGNED_SHORT_1_5_5_5_REV=0x8366 +GL_UNSIGNED_SHORT_4_4_4_4=0x8033 +GL_UNSIGNED_SHORT_4_4_4_4_EXT=0x8033 +GL_UNSIGNED_SHORT_4_4_4_4_REV=0x8365 +GL_UNSIGNED_SHORT_5_5_5_1=0x8034 +GL_UNSIGNED_SHORT_5_5_5_1_EXT=0x8034 +GL_UNSIGNED_SHORT_5_6_5=0x8363 +GL_UNSIGNED_SHORT_5_6_5_REV=0x8364 +GL_UNSIGNED_SHORT_8_8_APPLE=0x85BA +GL_UNSIGNED_SHORT_8_8_MESA=0x85BA +GL_UNSIGNED_SHORT_8_8_REV_APPLE=0x85BB +GL_UNSIGNED_SHORT_8_8_REV_MESA=0x85BB +GL_UPPER_LEFT=0x8CA2 +GL_V2F=0x2A20 +GL_V3F=0x2A21 +GL_VALIDATE_STATUS=0x8B83 +GL_VARIABLE_A_NV=0x8523 +GL_VARIABLE_B_NV=0x8524 +GL_VARIABLE_C_NV=0x8525 +GL_VARIABLE_D_NV=0x8526 +GL_VARIABLE_E_NV=0x8527 +GL_VARIABLE_F_NV=0x8528 +GL_VARIABLE_G_NV=0x8529 +GL_VARIANT_ARRAY_EXT=0x87E8 +GL_VARIANT_ARRAY_POINTER_EXT=0x87E9 +GL_VARIANT_ARRAY_STRIDE_EXT=0x87E6 +GL_VARIANT_ARRAY_TYPE_EXT=0x87E7 +GL_VARIANT_DATATYPE_EXT=0x87E5 +GL_VARIANT_EXT=0x87C1 +GL_VARIANT_VALUE_EXT=0x87E4 +GL_VECTOR_EXT=0x87BF +GL_VENDOR=0x1F00 +GL_VERSION=0x1F02 +GL_VERSION_1_1=1 +GL_VERSION_1_2=1 +GL_VERSION_1_3=1 +GL_VERSION_1_4=1 +GL_VERSION_1_5=1 +GL_VERSION_2_0=1 +GL_VERSION_2_1=1 +GL_VERTEX23_BIT_PGI=0x00000004 +GL_VERTEX4_BIT_PGI=0x00000008 +GL_VERTEX_ARRAY=0x8074 +GL_VERTEX_ARRAY_BINDING_APPLE=0x85B5 +GL_VERTEX_ARRAY_BUFFER_BINDING=0x8896 +GL_VERTEX_ARRAY_BUFFER_BINDING_ARB=0x8896 +GL_VERTEX_ARRAY_COUNT_EXT=0x807D +GL_VERTEX_ARRAY_EXT=0x8074 +GL_VERTEX_ARRAY_LIST_IBM=103070 +GL_VERTEX_ARRAY_LIST_STRIDE_IBM=103080 +GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL=0x83F5 +GL_VERTEX_ARRAY_POINTER=0x808E +GL_VERTEX_ARRAY_POINTER_EXT=0x808E +GL_VERTEX_ARRAY_RANGE_APPLE=0x851D +GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE=0x851E +GL_VERTEX_ARRAY_RANGE_LENGTH_NV=0x851E +GL_VERTEX_ARRAY_RANGE_NV=0x851D +GL_VERTEX_ARRAY_RANGE_POINTER_APPLE=0x8521 +GL_VERTEX_ARRAY_RANGE_POINTER_NV=0x8521 +GL_VERTEX_ARRAY_RANGE_VALID_NV=0x851F +GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV=0x8533 +GL_VERTEX_ARRAY_SIZE=0x807A +GL_VERTEX_ARRAY_SIZE_EXT=0x807A +GL_VERTEX_ARRAY_STORAGE_HINT_APPLE=0x851F +GL_VERTEX_ARRAY_STRIDE=0x807C +GL_VERTEX_ARRAY_STRIDE_EXT=0x807C +GL_VERTEX_ARRAY_TYPE=0x807B +GL_VERTEX_ARRAY_TYPE_EXT=0x807B +GL_VERTEX_ATTRIB_ARRAY0_NV=0x8650 +GL_VERTEX_ATTRIB_ARRAY10_NV=0x865A +GL_VERTEX_ATTRIB_ARRAY11_NV=0x865B +GL_VERTEX_ATTRIB_ARRAY12_NV=0x865C +GL_VERTEX_ATTRIB_ARRAY13_NV=0x865D +GL_VERTEX_ATTRIB_ARRAY14_NV=0x865E +GL_VERTEX_ATTRIB_ARRAY15_NV=0x865F +GL_VERTEX_ATTRIB_ARRAY1_NV=0x8651 +GL_VERTEX_ATTRIB_ARRAY2_NV=0x8652 +GL_VERTEX_ATTRIB_ARRAY3_NV=0x8653 +GL_VERTEX_ATTRIB_ARRAY4_NV=0x8654 +GL_VERTEX_ATTRIB_ARRAY5_NV=0x8655 +GL_VERTEX_ATTRIB_ARRAY6_NV=0x8656 +GL_VERTEX_ATTRIB_ARRAY7_NV=0x8657 +GL_VERTEX_ATTRIB_ARRAY8_NV=0x8658 +GL_VERTEX_ATTRIB_ARRAY9_NV=0x8659 +GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING=0x889F +GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB=0x889F +GL_VERTEX_ATTRIB_ARRAY_ENABLED=0x8622 +GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB=0x8622 +GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV=0x88FD +GL_VERTEX_ATTRIB_ARRAY_NORMALIZED=0x886A +GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB=0x886A +GL_VERTEX_ATTRIB_ARRAY_POINTER=0x8645 +GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB=0x8645 +GL_VERTEX_ATTRIB_ARRAY_SIZE=0x8623 +GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB=0x8623 +GL_VERTEX_ATTRIB_ARRAY_STRIDE=0x8624 +GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB=0x8624 +GL_VERTEX_ATTRIB_ARRAY_TYPE=0x8625 +GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB=0x8625 +GL_VERTEX_BLEND_ARB=0x86A7 +GL_VERTEX_CONSISTENT_HINT_PGI=0x1A22B +GL_VERTEX_DATA_HINT_PGI=0x1A22A +GL_VERTEX_ID_NV=0x8C7B +GL_VERTEX_PRECLIP_HINT_SGIX=0x83EF +GL_VERTEX_PRECLIP_SGIX=0x83EE +GL_VERTEX_PROGRAM_ARB=0x8620 +GL_VERTEX_PROGRAM_BINDING_NV=0x864A +GL_VERTEX_PROGRAM_NV=0x8620 +GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV=0x8DA2 +GL_VERTEX_PROGRAM_POINT_SIZE=0x8642 +GL_VERTEX_PROGRAM_POINT_SIZE_ARB=0x8642 +GL_VERTEX_PROGRAM_POINT_SIZE_NV=0x8642 +GL_VERTEX_PROGRAM_TWO_SIDE=0x8643 +GL_VERTEX_PROGRAM_TWO_SIDE_ARB=0x8643 +GL_VERTEX_PROGRAM_TWO_SIDE_NV=0x8643 +GL_VERTEX_SHADER=0x8B31 +GL_VERTEX_SHADER_ARB=0x8B31 +GL_VERTEX_SHADER_BINDING_EXT=0x8781 +GL_VERTEX_SHADER_EXT=0x8780 +GL_VERTEX_SHADER_INSTRUCTIONS_EXT=0x87CF +GL_VERTEX_SHADER_INVARIANTS_EXT=0x87D1 +GL_VERTEX_SHADER_LOCALS_EXT=0x87D3 +GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT=0x87D2 +GL_VERTEX_SHADER_OPTIMIZED_EXT=0x87D4 +GL_VERTEX_SHADER_VARIANTS_EXT=0x87D0 +GL_VERTEX_SOURCE_ATI=0x8774 +GL_VERTEX_STATE_PROGRAM_NV=0x8621 +GL_VERTEX_STREAM0_ATI=0x876C +GL_VERTEX_STREAM1_ATI=0x876D +GL_VERTEX_STREAM2_ATI=0x876E +GL_VERTEX_STREAM3_ATI=0x876F +GL_VERTEX_STREAM4_ATI=0x8770 +GL_VERTEX_STREAM5_ATI=0x8771 +GL_VERTEX_STREAM6_ATI=0x8772 +GL_VERTEX_STREAM7_ATI=0x8773 +GL_VERTEX_WEIGHTING_EXT=0x8509 +GL_VERTEX_WEIGHT_ARRAY_EXT=0x850C +GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT=0x8510 +GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT=0x850D +GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT=0x850F +GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT=0x850E +GL_VIBRANCE_BIAS_NV=0x8719 +GL_VIBRANCE_SCALE_NV=0x8713 +GL_VIEWPORT=0x0BA2 +GL_VIEWPORT_BIT=0x00000800 +GL_WEIGHT_ARRAY_ARB=0x86AD +GL_WEIGHT_ARRAY_BUFFER_BINDING=0x889E +GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB=0x889E +GL_WEIGHT_ARRAY_POINTER_ARB=0x86AC +GL_WEIGHT_ARRAY_SIZE_ARB=0x86AB +GL_WEIGHT_ARRAY_STRIDE_ARB=0x86AA +GL_WEIGHT_ARRAY_TYPE_ARB=0x86A9 +GL_WEIGHT_SUM_UNITY_ARB=0x86A6 +GL_WIDE_LINE_HINT_PGI=0x1A222 +GL_WIN_phong_shading=1 +GL_WIN_specular_fog=1 +GL_WRAP_BORDER_SUN=0x81D4 +GL_WRITE_ONLY=0x88B9 +GL_WRITE_ONLY_ARB=0x88B9 +GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV=0x887A +GL_WRITE_PIXEL_DATA_RANGE_NV=0x8878 +GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV=0x887C +GL_W_EXT=0x87D8 +GL_XOR=0x1506 +GL_X_EXT=0x87D5 +GL_YCBCR_422_APPLE=0x85B9 +GL_YCBCR_MESA=0x8757 +GL_YCRCBA_SGIX=0x8319 +GL_YCRCB_422_SGIX=0x81BB +GL_YCRCB_444_SGIX=0x81BC +GL_YCRCB_SGIX=0x8318 +GL_Y_EXT=0x87D6 +GL_ZERO=0 +GL_ZERO_EXT=0x87DD +GL_ZOOM_X=0x0D16 +GL_ZOOM_Y=0x0D17 +GL_Z_EXT=0x87D7
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/GLU.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,217 @@ +dynbind(c("GLU32","OpenGL","GLU","GLU.so.1"),callmode="stdcall"," +gluBeginCurve(*<GLUnurbs>)v; +gluBeginPolygon(*<GLUtesselator>)v; +gluBeginSurface(*<GLUnurbs>)v; +gluBeginTrim(*<GLUnurbs>)v; +gluBuild1DMipmapLevels(IiiIIiii*v)i; +gluBuild1DMipmaps(IiiII*v)i; +gluBuild2DMipmapLevels(IiiiIIiii*v)i; +gluBuild2DMipmaps(IiiiII*v)i; +gluBuild3DMipmapLevels(IiiiiIIiii*v)i; +gluBuild3DMipmaps(IiiiiII*v)i; +gluCheckExtension(*C*C)C; +gluCylinder(*<GLUquadric>dddii)v; +gluDeleteNurbsRenderer(*<GLUnurbs>)v; +gluDeleteQuadric(*<GLUquadric>)v; +gluDeleteTess(*<GLUtesselator>)v; +gluDisk(*<GLUquadric>ddii)v; +gluEndCurve(*<GLUnurbs>)v; +gluEndPolygon(*<GLUtesselator>)v; +gluEndSurface(*<GLUnurbs>)v; +gluEndTrim(*<GLUnurbs>)v; +gluErrorString(I)*C; +gluGetNurbsProperty(*<GLUnurbs>I*f)v; +gluGetString(I)*C; +gluGetTessProperty(*<GLUtesselator>I*d)v; +gluLoadSamplingMatrices(*<GLUnurbs>*f*f*i)v; +gluLookAt(ddddddddd)v; +gluNewNurbsRenderer()*<GLUnurbs>; +gluNewQuadric()*<GLUquadric>; +gluNewTess()*<GLUtesselator>; +gluNextContour(*<GLUtesselator>I)v; +gluNurbsCallback(*<GLUnurbs>I*p)v; +gluNurbsCallbackData(*<GLUnurbs>*v)v; +gluNurbsCallbackDataEXT(*<GLUnurbs>*v)v; +gluNurbsCurve(*<GLUnurbs>i*fi*fiI)v; +gluNurbsProperty(*<GLUnurbs>If)v; +gluNurbsSurface(*<GLUnurbs>i*fi*fii*fiiI)v; +gluOrtho2D(dddd)v; +gluPartialDisk(*<GLUquadric>ddiidd)v; +gluPerspective(dddd)v; +gluPickMatrix(dddd*i)v; +gluProject(ddd*d*d*i*d*d*d)i; +gluPwlCurve(*<GLUnurbs>i*fiI)v; +gluQuadricCallback(*<GLUquadric>I*p)v; +gluQuadricDrawStyle(*<GLUquadric>I)v; +gluQuadricNormals(*<GLUquadric>I)v; +gluQuadricOrientation(*<GLUquadric>I)v; +gluQuadricTexture(*<GLUquadric>C)v; +gluScaleImage(IiiI*viiI*v)i; +gluSphere(*<GLUquadric>dii)v; +gluTessBeginContour(*<GLUtesselator>)v; +gluTessBeginPolygon(*<GLUtesselator>*v)v; +gluTessCallback(*<GLUtesselator>I*p)v; +gluTessEndContour(*<GLUtesselator>)v; +gluTessEndPolygon(*<GLUtesselator>)v; +gluTessNormal(*<GLUtesselator>ddd)v; +gluTessProperty(*<GLUtesselator>Id)v; +gluTessVertex(*<GLUtesselator>*d*v)v; +gluUnProject(ddd*d*d*i*d*d*d)i; +gluUnProject4(dddd*d*d*idd*d*d*d*d)i; +") +GLU_AUTO_LOAD_MATRIX=100200 +GLU_BEGIN=100100 +GLU_CCW=100121 +GLU_CULLING=100201 +GLU_CW=100120 +GLU_DISPLAY_MODE=100204 +GLU_DOMAIN_DISTANCE=100217 +GLU_EDGE_FLAG=100104 +GLU_END=100102 +GLU_ERROR=100103 +GLU_EXTENSIONS=100801 +GLU_EXTERIOR=100123 +GLU_EXT_nurbs_tessellator=1 +GLU_EXT_object_space_tess=1 +GLU_FALSE=0 +GLU_FILL=100012 +GLU_FLAT=100001 +GLU_INCOMPATIBLE_GL_VERSION=100903 +GLU_INSIDE=100021 +GLU_INTERIOR=100122 +GLU_INVALID_ENUM=100900 +GLU_INVALID_OPERATION=100904 +GLU_INVALID_VALUE=100901 +GLU_LINE=100011 +GLU_MAP1_TRIM_2=100210 +GLU_MAP1_TRIM_3=100211 +GLU_NONE=100002 +GLU_NURBS_BEGIN=100164 +GLU_NURBS_BEGIN_DATA=100170 +GLU_NURBS_BEGIN_DATA_EXT=100170 +GLU_NURBS_BEGIN_EXT=100164 +GLU_NURBS_COLOR=100167 +GLU_NURBS_COLOR_DATA=100173 +GLU_NURBS_COLOR_DATA_EXT=100173 +GLU_NURBS_COLOR_EXT=100167 +GLU_NURBS_END=100169 +GLU_NURBS_END_DATA=100175 +GLU_NURBS_END_DATA_EXT=100175 +GLU_NURBS_END_EXT=100169 +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_ERROR1=100251 +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_ERROR2=100252 +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 +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_ERROR=100103 +GLU_NURBS_MODE=100160 +GLU_NURBS_MODE_EXT=100160 +GLU_NURBS_NORMAL=100166 +GLU_NURBS_NORMAL_DATA=100172 +GLU_NURBS_NORMAL_DATA_EXT=100172 +GLU_NURBS_NORMAL_EXT=100166 +GLU_NURBS_RENDERER=100162 +GLU_NURBS_RENDERER_EXT=100162 +GLU_NURBS_TESSELLATOR=100161 +GLU_NURBS_TESSELLATOR_EXT=100161 +GLU_NURBS_TEXTURE_COORD=100168 +GLU_NURBS_TEXTURE_COORD_DATA=100174 +GLU_NURBS_TEX_COORD_DATA_EXT=100174 +GLU_NURBS_TEX_COORD_EXT=100168 +GLU_NURBS_VERTEX=100165 +GLU_NURBS_VERTEX_DATA=100171 +GLU_NURBS_VERTEX_DATA_EXT=100171 +GLU_NURBS_VERTEX_EXT=100165 +GLU_OBJECT_PARAMETRIC_ERROR=100208 +GLU_OBJECT_PARAMETRIC_ERROR_EXT=100208 +GLU_OBJECT_PATH_LENGTH=100209 +GLU_OBJECT_PATH_LENGTH_EXT=100209 +GLU_OUTLINE_PATCH=100241 +GLU_OUTLINE_POLYGON=100240 +GLU_OUTSIDE=100020 +GLU_OUT_OF_MEMORY=100902 +GLU_PARAMETRIC_ERROR=100216 +GLU_PARAMETRIC_TOLERANCE=100202 +GLU_PATH_LENGTH=100215 +GLU_POINT=100010 +GLU_SAMPLING_METHOD=100205 +GLU_SAMPLING_TOLERANCE=100203 +GLU_SILHOUETTE=100013 +GLU_SMOOTH=100000 +GLU_TESS_BEGIN=100100 +GLU_TESS_BEGIN_DATA=100106 +GLU_TESS_BOUNDARY_ONLY=100141 +GLU_TESS_COMBINE=100105 +GLU_TESS_COMBINE_DATA=100111 +GLU_TESS_COORD_TOO_LARGE=100155 +GLU_TESS_EDGE_FLAG=100104 +GLU_TESS_EDGE_FLAG_DATA=100110 +GLU_TESS_END=100102 +GLU_TESS_END_DATA=100108 +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_ERROR=100103 +GLU_TESS_ERROR_DATA=100109 +GLU_TESS_MAX_COORD=1.0e150 +GLU_TESS_MISSING_BEGIN_CONTOUR=100152 +GLU_TESS_MISSING_BEGIN_POLYGON=100151 +GLU_TESS_MISSING_END_CONTOUR=100154 +GLU_TESS_MISSING_END_POLYGON=100153 +GLU_TESS_NEED_COMBINE_CALLBACK=100156 +GLU_TESS_TOLERANCE=100142 +GLU_TESS_VERTEX=100101 +GLU_TESS_VERTEX_DATA=100107 +GLU_TESS_WINDING_ABS_GEQ_TWO=100134 +GLU_TESS_WINDING_NEGATIVE=100133 +GLU_TESS_WINDING_NONZERO=100131 +GLU_TESS_WINDING_ODD=100130 +GLU_TESS_WINDING_POSITIVE=100132 +GLU_TESS_WINDING_RULE=100140 +GLU_TRUE=1 +GLU_UNKNOWN=100124 +GLU_U_STEP=100206 +GLU_VERSION=100800 +GLU_VERSION_1_1=1 +GLU_VERSION_1_2=1 +GLU_VERSION_1_3=1 +GLU_VERTEX=100101 +GLU_V_STEP=100207 +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/GLUT.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,298 @@ + + +dynbind("GLUT", " +glutAddMenuEntry(*ci)v; +glutAddSubMenu(*ci)v; +glutAttachMenu(i)v; +glutBitmapCharacter(*vi)v; +glutBitmapLength(*v*C)i; +glutBitmapWidth(*vi)i; +glutButtonBoxFunc(*p)v; +glutChangeToMenuEntry(i*ci)v; +glutChangeToSubMenu(i*ci)v; +glutCheckLoop()v; +glutCopyColormap(i)v; +glutCreateMenu(*p)i; +glutCreateSubWindow(iiiii)i; +glutCreateWindow(*c)i; +glutDestroyMenu(i)v; +glutDestroyWindow(i)v; +glutDetachMenu(i)v; +glutDeviceGet(I)i; +glutDialsFunc(*p)v; +glutDisplayFunc(*p)v; +glutEnterGameMode()i; +glutEntryFunc(*p)v; +glutEstablishOverlay()v; +glutExtensionSupported(*c)i; +glutForceJoystickFunc()v; +glutFullScreen()v; +glutGameModeGet(I)i; +glutGameModeString(*c)v; +glutGet(I)i; +glutGetColor(ii)f; +glutGetMenu()i; +glutGetModifiers()i; +glutGetProcAddress(*c)*v; +glutGetWindow()i; +glutHideOverlay()v; +glutHideWindow()v; +glutIconifyWindow()v; +glutIdleFunc(*p)v; +glutIgnoreKeyRepeat(i)v; +glutInit(*i**c)v; +glutInitDisplayMode(I)v; +glutInitDisplayString(*c)v; +glutInitWindowPosition(ii)v; +glutInitWindowSize(ii)v; +glutJoystickFunc(*pi)v; +glutKeyboardFunc(*p)v; +glutKeyboardUpFunc(*p)v; +glutLayerGet(I)i; +glutLeaveGameMode()v; +glutMainLoop()v; +glutMenuStateFunc(*p)v; +glutMenuStatusFunc(*p)v; +glutMotionFunc(*p)v; +glutMouseFunc(*p)v; +glutOverlayDisplayFunc(*p)v; +glutPassiveMotionFunc(*p)v; +glutPopWindow()v; +glutPositionWindow(ii)v; +glutPostOverlayRedisplay()v; +glutPostRedisplay()v; +glutPostWindowOverlayRedisplay(i)v; +glutPostWindowRedisplay(i)v; +glutPushWindow()v; +glutRemoveMenuItem(i)v; +glutRemoveOverlay()v; +glutReportErrors()v; +glutReshapeFunc(*p)v; +glutReshapeWindow(ii)v; +glutSetColor(ifff)v; +glutSetCursor(i)v; +glutSetIconTitle(*c)v; +glutSetKeyRepeat(i)v; +glutSetMenu(i)v; +glutSetWindow(i)v; +glutSetWindowTitle(*c)v; +glutSetupVideoResizing()v; +glutShowOverlay()v; +glutShowWindow()v; +glutSolidCone(ddii)v; +glutSolidCube(d)v; +glutSolidDodecahedron()v; +glutSolidIcosahedron()v; +glutSolidOctahedron()v; +glutSolidSphere(dii)v; +glutSolidTeapot(d)v; +glutSolidTetrahedron()v; +glutSolidTorus(ddii)v; +glutSpaceballButtonFunc(*p)v; +glutSpaceballMotionFunc(*p)v; +glutSpaceballRotateFunc(*p)v; +glutSpecialFunc(*p)v; +glutSpecialUpFunc(*p)v; +glutStopVideoResizing()v; +glutStrokeCharacter(*vi)v; +glutStrokeLength(*v*C)i; +glutStrokeWidth(*vi)i; +glutSurfaceTexture(IIi)v; +glutSwapBuffers()v; +glutTabletButtonFunc(*p)v; +glutTabletMotionFunc(*p)v; +glutTimerFunc(I*pi)v; +glutUseLayer(I)v; +glutVideoPan(iiii)v; +glutVideoResize(iiii)v; +glutVideoResizeGet(I)i; +glutVisibilityFunc(*p)v; +glutWMCloseFunc(*p)v; +glutWarpPointer(ii)v; +glutWindowStatusFunc(*p)v; +glutWireCone(ddii)v; +glutWireCube(d)v; +glutWireDodecahedron()v; +glutWireIcosahedron()v; +glutWireOctahedron()v; +glutWireSphere(dii)v; +glutWireTeapot(d)v; +glutWireTetrahedron()v; +glutWireTorus(ddii)v; +") +GLUT_ACCUM=4 +GLUT_ACTIVE_ALT=4 +GLUT_ACTIVE_CTRL=2 +GLUT_ACTIVE_SHIFT=1 +GLUT_ALPHA=8 +GLUT_API_VERSION=5 +#GLUT_BITMAP_8_BY_13=(&glutBitmap8By13) +#GLUT_BITMAP_9_BY_15=(&glutBitmap9By15) +#GLUT_BITMAP_HELVETICA_10=(&glutBitmapHelvetica10) +#GLUT_BITMAP_HELVETICA_12=(&glutBitmapHelvetica12) +#GLUT_BITMAP_HELVETICA_18=(&glutBitmapHelvetica18) +#GLUT_BITMAP_TIMES_ROMAN_10=(&glutBitmapTimesRoman10) +#GLUT_BITMAP_TIMES_ROMAN_24=(&glutBitmapTimesRoman24) +GLUT_BLUE=2 +GLUT_CURSOR_BOTTOM_LEFT_CORNER=19 +GLUT_CURSOR_BOTTOM_RIGHT_CORNER=18 +GLUT_CURSOR_BOTTOM_SIDE=13 +GLUT_CURSOR_CROSSHAIR=9 +GLUT_CURSOR_CYCLE=5 +GLUT_CURSOR_DESTROY=3 +GLUT_CURSOR_FULL_CROSSHAIR=102 +GLUT_CURSOR_HELP=4 +GLUT_CURSOR_INFO=2 +GLUT_CURSOR_INHERIT=100 +GLUT_CURSOR_LEFT_ARROW=1 +GLUT_CURSOR_LEFT_RIGHT=11 +GLUT_CURSOR_LEFT_SIDE=14 +GLUT_CURSOR_NONE=101 +GLUT_CURSOR_RIGHT_ARROW=0 +GLUT_CURSOR_RIGHT_SIDE=15 +GLUT_CURSOR_SPRAY=6 +GLUT_CURSOR_TEXT=8 +GLUT_CURSOR_TOP_LEFT_CORNER=16 +GLUT_CURSOR_TOP_RIGHT_CORNER=17 +GLUT_CURSOR_TOP_SIDE=12 +GLUT_CURSOR_UP_DOWN=10 +GLUT_CURSOR_WAIT=7 +GLUT_DEPTH=16 +GLUT_DEVICE_IGNORE_KEY_REPEAT=610 +GLUT_DEVICE_KEY_REPEAT=611 +GLUT_DISPLAY_MODE_POSSIBLE=400 +GLUT_DOUBLE=2 +GLUT_DOWN=0 +GLUT_ELAPSED_TIME=700 +GLUT_ENTERED=1 +GLUT_FULLY_COVERED=3 +GLUT_FULLY_RETAINED=1 +GLUT_GAME_MODE_ACTIVE=0 +GLUT_GAME_MODE_DISPLAY_CHANGED=6 +GLUT_GAME_MODE_HEIGHT=3 +GLUT_GAME_MODE_PIXEL_DEPTH=4 +GLUT_GAME_MODE_POSSIBLE=1 +GLUT_GAME_MODE_REFRESH_RATE=5 +GLUT_GAME_MODE_WIDTH=2 +GLUT_GREEN=1 +GLUT_HAS_DIAL_AND_BUTTON_BOX=603 +GLUT_HAS_JOYSTICK=612 +GLUT_HAS_KEYBOARD=600 +GLUT_HAS_MOUSE=601 +GLUT_HAS_OVERLAY=802 +GLUT_HAS_SPACEBALL=602 +GLUT_HAS_TABLET=604 +GLUT_HIDDEN=0 +GLUT_INDEX=1 +GLUT_INIT_DISPLAY_MODE=504 +GLUT_INIT_WINDOW_HEIGHT=503 +GLUT_INIT_WINDOW_WIDTH=502 +GLUT_INIT_WINDOW_X=500 +GLUT_INIT_WINDOW_Y=501 +GLUT_JOYSTICK_AXES=615 +GLUT_JOYSTICK_BUTTONS=614 +GLUT_JOYSTICK_BUTTON_A=1 +GLUT_JOYSTICK_BUTTON_B=2 +GLUT_JOYSTICK_BUTTON_C=4 +GLUT_JOYSTICK_BUTTON_D=8 +GLUT_JOYSTICK_POLL_RATE=616 +GLUT_KEY_DOWN=103 +GLUT_KEY_END=107 +GLUT_KEY_F10=10 +GLUT_KEY_F11=11 +GLUT_KEY_F12=12 +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_HOME=106 +GLUT_KEY_INSERT=108 +GLUT_KEY_LEFT=100 +GLUT_KEY_PAGE_DOWN=105 +GLUT_KEY_PAGE_UP=104 +GLUT_KEY_REPEAT_DEFAULT=2 +GLUT_KEY_REPEAT_OFF=0 +GLUT_KEY_REPEAT_ON=1 +GLUT_KEY_RIGHT=102 +GLUT_KEY_UP=101 +GLUT_LAYER_IN_USE=801 +GLUT_LEFT=0 +GLUT_LEFT_BUTTON=0 +GLUT_LUMINANCE=512 +GLUT_MACOSX_IMPLEMENTATION=2 +GLUT_MENU_IN_USE=1 +GLUT_MENU_NOT_IN_USE=0 +GLUT_MENU_NUM_ITEMS=300 +GLUT_MIDDLE_BUTTON=1 +GLUT_MULTISAMPLE=128 +GLUT_NORMAL=0 +GLUT_NORMAL_DAMAGED=804 +GLUT_NOT_VISIBLE=0 +GLUT_NO_RECOVERY=1024 +GLUT_NUM_BUTTON_BOX_BUTTONS=607 +GLUT_NUM_DIALS=608 +GLUT_NUM_MOUSE_BUTTONS=605 +GLUT_NUM_SPACEBALL_BUTTONS=606 +GLUT_NUM_TABLET_BUTTONS=609 +GLUT_OVERLAY=1 +GLUT_OVERLAY_DAMAGED=805 +GLUT_OVERLAY_POSSIBLE=800 +GLUT_OWNS_JOYSTICK=613 +GLUT_PARTIALLY_RETAINED=2 +GLUT_RED=0 +GLUT_RGB=0 +GLUT_RGBA=GLUT_RGB +GLUT_RIGHT_BUTTON=2 +GLUT_SCREEN_HEIGHT=201 +GLUT_SCREEN_HEIGHT_MM=203 +GLUT_SCREEN_WIDTH=200 +GLUT_SCREEN_WIDTH_MM=202 +GLUT_SINGLE=0 +GLUT_STENCIL=32 +GLUT_STEREO=256 +#GLUT_STROKE_MONO_ROMAN=(&glutStrokeMonoRoman) +#GLUT_STROKE_ROMAN=(&glutStrokeRoman) +GLUT_TRANSPARENT_INDEX=803 +GLUT_UP=1 +GLUT_VIDEO_RESIZE_HEIGHT=909 +GLUT_VIDEO_RESIZE_HEIGHT_DELTA=905 +GLUT_VIDEO_RESIZE_IN_USE=901 +GLUT_VIDEO_RESIZE_POSSIBLE=900 +GLUT_VIDEO_RESIZE_WIDTH=908 +GLUT_VIDEO_RESIZE_WIDTH_DELTA=904 +GLUT_VIDEO_RESIZE_X=906 +GLUT_VIDEO_RESIZE_X_DELTA=902 +GLUT_VIDEO_RESIZE_Y=907 +GLUT_VIDEO_RESIZE_Y_DELTA=903 +GLUT_VISIBLE=1 +GLUT_WINDOW_ACCUM_ALPHA_SIZE=114 +GLUT_WINDOW_ACCUM_BLUE_SIZE=113 +GLUT_WINDOW_ACCUM_GREEN_SIZE=112 +GLUT_WINDOW_ACCUM_RED_SIZE=111 +GLUT_WINDOW_ALPHA_SIZE=110 +GLUT_WINDOW_BLUE_SIZE=109 +GLUT_WINDOW_BUFFER_SIZE=104 +GLUT_WINDOW_COLORMAP_SIZE=119 +GLUT_WINDOW_CURSOR=122 +GLUT_WINDOW_DEPTH_SIZE=106 +GLUT_WINDOW_DOUBLEBUFFER=115 +GLUT_WINDOW_FORMAT_ID=123 +GLUT_WINDOW_GREEN_SIZE=108 +GLUT_WINDOW_HEIGHT=103 +GLUT_WINDOW_NUM_CHILDREN=118 +GLUT_WINDOW_NUM_SAMPLES=120 +GLUT_WINDOW_PARENT=117 +GLUT_WINDOW_RED_SIZE=107 +GLUT_WINDOW_RGBA=116 +GLUT_WINDOW_STENCIL_SIZE=105 +GLUT_WINDOW_STEREO=121 +GLUT_WINDOW_WIDTH=102 +GLUT_WINDOW_X=100 +GLUT_WINDOW_Y=101 +GLUT_XLIB_IMPLEMENTATION=15 +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/R.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,792 @@ +dynbind("R", " +ATTRIB(*<SEXPREC>)*<SEXPREC>; +BODY(*<SEXPREC>)*<SEXPREC>; +CAAR(*<SEXPREC>)*<SEXPREC>; +CAD4R(*<SEXPREC>)*<SEXPREC>; +CADDDR(*<SEXPREC>)*<SEXPREC>; +CADDR(*<SEXPREC>)*<SEXPREC>; +CADR(*<SEXPREC>)*<SEXPREC>; +CAR(*<SEXPREC>)*<SEXPREC>; +CDAR(*<SEXPREC>)*<SEXPREC>; +CDDR(*<SEXPREC>)*<SEXPREC>; +CDR(*<SEXPREC>)*<SEXPREC>; +CLOENV(*<SEXPREC>)*<SEXPREC>; +COMPLEX(*<SEXPREC>)*<Rcomplex>; +DDVAL(*<SEXPREC>)i; +DEBUG(*<SEXPREC>)i; +DUPLICATE_ATTRIB(*<SEXPREC>*<SEXPREC>)v; +ENCLOS(*<SEXPREC>)*<SEXPREC>; +ENVFLAGS(*<SEXPREC>)i; +FORMALS(*<SEXPREC>)*<SEXPREC>; +FRAME(*<SEXPREC>)*<SEXPREC>; +GetRNGstate()v; +HASHASH(*<SEXPREC>)i; +HASHTAB(*<SEXPREC>)*<SEXPREC>; +HASHVALUE(*<SEXPREC>)i; +INTEGER(*<SEXPREC>)*i; +INTERNAL(*<SEXPREC>)*<SEXPREC>; +IS_S4_OBJECT(*<SEXPREC>)i; +LENGTH(*<SEXPREC>)i; +LEVELS(*<SEXPREC>)i; +LOGICAL(*<SEXPREC>)*i; +MARK(*<SEXPREC>)i; +MISSING(*<SEXPREC>)i; +NAMED(*<SEXPREC>)i; +OBJECT(*<SEXPREC>)i; +PRCODE(*<SEXPREC>)*<SEXPREC>; +PRENV(*<SEXPREC>)*<SEXPREC>; +PRINTNAME(*<SEXPREC>)*<SEXPREC>; +PRSEEN(*<SEXPREC>)i; +PRVALUE(*<SEXPREC>)*<SEXPREC>; +PutRNGstate()v; +RAW(*<SEXPREC>)*C; +REAL(*<SEXPREC>)*d; +REprintf(*c)v; +REvprintf(*c*c)v; +R_BindingIsActive(*<SEXPREC>*<SEXPREC>)i; +R_BindingIsLocked(*<SEXPREC>*<SEXPREC>)i; +R_CheckStack()v; +R_CheckUserInterrupt()v; +R_ClearExternalPtr(*<SEXPREC>)v; +R_EnvironmentIsLocked(*<SEXPREC>)i; +R_ExpandFileName(*c)*c; +R_ExternalPtrAddr(*<SEXPREC>)*v; +R_ExternalPtrProtected(*<SEXPREC>)*<SEXPREC>; +R_ExternalPtrTag(*<SEXPREC>)*<SEXPREC>; +R_FindNamespace(*<SEXPREC>)*<SEXPREC>; +R_FindPackageEnv(*<SEXPREC>)*<SEXPREC>; +R_FlushConsole()v; +R_HasFancyBindings(*<SEXPREC>)i; +R_InitFileInPStream(*<R_inpstream_st>*<__sFILE>i*p*<SEXPREC>)v; +R_InitFileOutPStream(*<R_outpstream_st>*<__sFILE>ii*p*<SEXPREC>)v; +R_InitInPStream(*<R_inpstream_st>*vi*p*p*p*<SEXPREC>)v; +R_InitOutPStream(*<R_outpstream_st>*vii*p*p*p*<SEXPREC>)v; +R_IsNA(d)i; +R_IsNaN(d)i; +R_IsNamespaceEnv(*<SEXPREC>)i; +R_IsPackageEnv(*<SEXPREC>)i; +R_LockBinding(*<SEXPREC>*<SEXPREC>)v; +R_LockEnvironment(*<SEXPREC>i)v; +R_MakeActiveBinding(*<SEXPREC>*<SEXPREC>*<SEXPREC>)v; +R_MakeExternalPtr(*v*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +R_MakeWeakRef(*<SEXPREC>*<SEXPREC>*<SEXPREC>i)*<SEXPREC>; +R_MakeWeakRefC(*<SEXPREC>*<SEXPREC>*pi)*<SEXPREC>; +R_NamespaceEnvSpec(*<SEXPREC>)*<SEXPREC>; +R_PackageEnvName(*<SEXPREC>)*<SEXPREC>; +R_PreserveObject(*<SEXPREC>)v; +R_ProcessEvents()v; +R_ProtectWithIndex(*<SEXPREC>*i)v; +R_RegisterCFinalizer(*<SEXPREC>*p)v; +R_RegisterCFinalizerEx(*<SEXPREC>*pi)v; +R_RegisterFinalizer(*<SEXPREC>*<SEXPREC>)v; +R_RegisterFinalizerEx(*<SEXPREC>*<SEXPREC>i)v; +R_ReleaseObject(*<SEXPREC>)v; +R_Reprotect(*<SEXPREC>i)v; +R_RestoreHashCount(*<SEXPREC>)v; +R_RunExitFinalizers()v; +R_RunWeakRefFinalizer(*<SEXPREC>)v; +R_Serialize(*<SEXPREC>*<R_outpstream_st>)v; +R_SetExternalPtrAddr(*<SEXPREC>*v)v; +R_SetExternalPtrProtected(*<SEXPREC>*<SEXPREC>)v; +R_SetExternalPtrTag(*<SEXPREC>*<SEXPREC>)v; +R_ShowMessage(*c)v; +R_ToplevelExec(*p*v)i; +R_Unserialize(*<R_inpstream_st>)*<SEXPREC>; +R_WeakRefKey(*<SEXPREC>)*<SEXPREC>; +R_WeakRefValue(*<SEXPREC>)*<SEXPREC>; +R_XDRDecodeDouble(*v)d; +R_XDRDecodeInteger(*v)i; +R_XDREncodeDouble(d*v)v; +R_XDREncodeInteger(i*v)v; +R_alloc(Ji)*c; +R_atof(*c)d; +R_chk_calloc(JJ)*v; +R_chk_free(*v)v; +R_chk_realloc(*vJ)*v; +R_csort(*<Rcomplex>i)v; +R_do_MAKE_CLASS(*c)*<SEXPREC>; +R_do_new_object(*<SEXPREC>)*<SEXPREC>; +R_do_slot(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +R_do_slot_assign(*<SEXPREC>*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +R_dot_Last()v; +R_finite(d)i; +R_gc()v; +R_getClassDef(*c)*<SEXPREC>; +R_has_slot(*<SEXPREC>*<SEXPREC>)i; +R_isort(*ii)v; +R_lsInternal(*<SEXPREC>i)*<SEXPREC>; +R_max_col(*d*i*i*i*i)v; +R_qsort(*dii)v; +R_qsort_I(*d*iii)v; +R_qsort_int(*iii)v; +R_qsort_int_I(*i*iii)v; +R_rsort(*di)v; +R_strtod(*c*)d; +R_system(*c)i; +R_tmpnam(*c*c)*c; +R_tryEval(*<SEXPREC>*<SEXPREC>*i)*<SEXPREC>; +R_unLockBinding(*<SEXPREC>*<SEXPREC>)v; +Rf_CreateTag(*<SEXPREC>)*<SEXPREC>; +Rf_DropDims(*<SEXPREC>)*<SEXPREC>; +Rf_EncodeComplex(iiiiiic)*c; +Rf_EncodeInteger(ii)*c; +Rf_EncodeLogical(ii)*c; +Rf_EncodeReal(diiic)*c; +Rf_GetArrayDimnames(*<SEXPREC>)*<SEXPREC>; +Rf_GetColNames(*<SEXPREC>)*<SEXPREC>; +Rf_GetMatrixDimnames(*<SEXPREC>****)v; +Rf_GetOption(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_GetOptionDigits(*<SEXPREC>)i; +Rf_GetOptionWidth(*<SEXPREC>)i; +Rf_GetRowNames(*<SEXPREC>)*<SEXPREC>; +Rf_IndexWidth(i)i; +Rf_NonNullStringMatch(*<SEXPREC>*<SEXPREC>)i; +Rf_PairToVectorList(*<SEXPREC>)*<SEXPREC>; +Rf_PrintValue(*<SEXPREC>)v; +Rf_S3Class(*<SEXPREC>)*<SEXPREC>; +Rf_ScalarComplex()*<SEXPREC>; +Rf_ScalarInteger(i)*<SEXPREC>; +Rf_ScalarLogical(i)*<SEXPREC>; +Rf_ScalarRaw(C)*<SEXPREC>; +Rf_ScalarReal(d)*<SEXPREC>; +Rf_ScalarString(*<SEXPREC>)*<SEXPREC>; +Rf_StringBlank(*<SEXPREC>)i; +Rf_StringFalse(*c)i; +Rf_StringTrue(*c)i; +Rf_VectorIndex(ii)v; +Rf_VectorToPairList(*<SEXPREC>)*<SEXPREC>; +Rf_acopy_string(*c)*c; +Rf_alloc3DArray(Iiii)*<SEXPREC>; +Rf_allocArray(I*<SEXPREC>)*<SEXPREC>; +Rf_allocList(i)*<SEXPREC>; +Rf_allocMatrix(Iii)*<SEXPREC>; +Rf_allocS4Object()*<SEXPREC>; +Rf_allocSExp(I)*<SEXPREC>; +Rf_allocVector(Ii)*<SEXPREC>; +Rf_applyClosure(*<SEXPREC>*<SEXPREC>*<SEXPREC>*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_arraySubscript(i*<SEXPREC>*<SEXPREC>*p*p*<SEXPREC>)*<SEXPREC>; +Rf_asChar(*<SEXPREC>)*<SEXPREC>; +Rf_asCharacterFactor(*<SEXPREC>)*<SEXPREC>; +Rf_asComplex(*<SEXPREC>); +Rf_asInteger(*<SEXPREC>)i; +Rf_asLogical(*<SEXPREC>)i; +Rf_asReal(*<SEXPREC>)d; +Rf_asS4(*<SEXPREC>ii)*<SEXPREC>; +Rf_cPsort(*<Rcomplex>ii)v; +Rf_classgets(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_coerceVector(*<SEXPREC>I)*<SEXPREC>; +Rf_conformable(*<SEXPREC>*<SEXPREC>)i; +Rf_cons(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_copyMatrix(*<SEXPREC>*<SEXPREC>i)v; +Rf_copyMostAttrib(*<SEXPREC>*<SEXPREC>)v; +Rf_copyVector(*<SEXPREC>*<SEXPREC>)v; +Rf_defineVar(*<SEXPREC>*<SEXPREC>*<SEXPREC>)v; +Rf_dimgets(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_dimnamesgets(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_duplicate(*<SEXPREC>)*<SEXPREC>; +Rf_duplicated(*<SEXPREC>i)*<SEXPREC>; +Rf_elt(*<SEXPREC>i)*<SEXPREC>; +Rf_error(*c)v; +Rf_errorcall(*<SEXPREC>*c)v; +Rf_eval(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_findFun(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_findVar(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_findVarInFrame(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_findVarInFrame3(*<SEXPREC>*<SEXPREC>i)*<SEXPREC>; +Rf_formatComplex(*<Rcomplex>i*i*i*i*i*i*ii)v; +Rf_formatInteger(*ii*i)v; +Rf_formatLogical(*ii*i)v; +Rf_formatReal(*di*i*i*ii)v; +Rf_getAttrib(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_getCharCE(*<SEXPREC>)i; +Rf_gsetVar(*<SEXPREC>*<SEXPREC>*<SEXPREC>)v; +Rf_hsv2rgb(ddd*d*d*d)v; +Rf_iPsort(*iii)v; +Rf_inherits(*<SEXPREC>*c)i; +Rf_install(*c)*<SEXPREC>; +Rf_isArray(*<SEXPREC>)i; +Rf_isBasicClass(*c)i; +Rf_isBlankString(*c)i; +Rf_isFactor(*<SEXPREC>)i; +Rf_isFrame(*<SEXPREC>)i; +Rf_isFree(*<SEXPREC>)i; +Rf_isFunction(*<SEXPREC>)i; +Rf_isInteger(*<SEXPREC>)i; +Rf_isLanguage(*<SEXPREC>)i; +Rf_isList(*<SEXPREC>)i; +Rf_isMatrix(*<SEXPREC>)i; +Rf_isNewList(*<SEXPREC>)i; +Rf_isNumeric(*<SEXPREC>)i; +Rf_isOrdered(*<SEXPREC>)i; +Rf_isPairList(*<SEXPREC>)i; +Rf_isPrimitive(*<SEXPREC>)i; +Rf_isS4(*<SEXPREC>)i; +Rf_isTs(*<SEXPREC>)i; +Rf_isUnordered(*<SEXPREC>)i; +Rf_isUnsorted(*<SEXPREC>i)i; +Rf_isUserBinop(*<SEXPREC>)i; +Rf_isValidString(*<SEXPREC>)i; +Rf_isValidStringF(*<SEXPREC>)i; +Rf_isVector(*<SEXPREC>)i; +Rf_isVectorAtomic(*<SEXPREC>)i; +Rf_isVectorList(*<SEXPREC>)i; +Rf_isVectorizable(*<SEXPREC>)i; +Rf_lang1(*<SEXPREC>)*<SEXPREC>; +Rf_lang2(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_lang3(*<SEXPREC>*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_lang4(*<SEXPREC>*<SEXPREC>*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_lastElt(*<SEXPREC>)*<SEXPREC>; +Rf_lcons(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_length(*<SEXPREC>)i; +Rf_lengthgets(*<SEXPREC>i)*<SEXPREC>; +Rf_list1(*<SEXPREC>)*<SEXPREC>; +Rf_list2(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_list3(*<SEXPREC>*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_list4(*<SEXPREC>*<SEXPREC>*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_listAppend(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_match(*<SEXPREC>*<SEXPREC>i)*<SEXPREC>; +Rf_mkChar(*c)*<SEXPREC>; +Rf_mkCharCE(*ci)*<SEXPREC>; +Rf_mkCharLen(*ci)*<SEXPREC>; +Rf_mkCharLenCE(*cii)*<SEXPREC>; +Rf_mkString(*c)*<SEXPREC>; +Rf_namesgets(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_ncols(*<SEXPREC>)i; +Rf_nlevels(*<SEXPREC>)i; +Rf_nrows(*<SEXPREC>)i; +Rf_nthcdr(*<SEXPREC>i)*<SEXPREC>; +Rf_pmatch(*<SEXPREC>*<SEXPREC>i)i; +Rf_printComplexVector(*<Rcomplex>ii)v; +Rf_printIntegerVector(*iii)v; +Rf_printRealVector(*dii)v; +Rf_protect(*<SEXPREC>)*<SEXPREC>; +Rf_psmatch(*c*ci)i; +Rf_rPsort(*dii)v; +Rf_reEnc(*ciii)*c; +Rf_revsort(*d*ii)v; +Rf_rgb2hsv(ddd*d*d*d)v; +Rf_setAttrib(*<SEXPREC>*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_setIVector(*iii)v; +Rf_setRVector(*did)v; +Rf_setSVector(*i*<SEXPREC>)v; +Rf_setVar(*<SEXPREC>*<SEXPREC>*<SEXPREC>)v; +Rf_str2type(*c)I; +Rf_substitute(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +Rf_translateChar(*<SEXPREC>)*c; +Rf_translateCharUTF8(*<SEXPREC>)*c; +Rf_type2char(I)*c; +Rf_type2str(I)*<SEXPREC>; +Rf_unprotect(i)v; +Rf_unprotect_ptr(*<SEXPREC>)v; +Rf_warning(*c)v; +Rf_warningcall(*<SEXPREC>*c)v; +Rf_warningcall_immediate(*<SEXPREC>*c)v; +Rprintf(*c)v; +Rvprintf(*c*c)v; +SETCAD4R(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +SETCADDDR(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +SETCADDR(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +SETCADR(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +SETCAR(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +SETCDR(*<SEXPREC>*<SEXPREC>)*<SEXPREC>; +SETLENGTH(*<SEXPREC>i)v; +SETLEVELS(*<SEXPREC>i)i; +SET_ATTRIB(*<SEXPREC>*<SEXPREC>)v; +SET_BODY(*<SEXPREC>*<SEXPREC>)v; +SET_CLOENV(*<SEXPREC>*<SEXPREC>)v; +SET_DDVAL(*<SEXPREC>i)v; +SET_DEBUG(*<SEXPREC>i)v; +SET_ENCLOS(*<SEXPREC>*<SEXPREC>)v; +SET_ENVFLAGS(*<SEXPREC>i)v; +SET_FORMALS(*<SEXPREC>*<SEXPREC>)v; +SET_FRAME(*<SEXPREC>*<SEXPREC>)v; +SET_HASHASH(*<SEXPREC>i)v; +SET_HASHTAB(*<SEXPREC>*<SEXPREC>)v; +SET_HASHVALUE(*<SEXPREC>i)v; +SET_INTERNAL(*<SEXPREC>*<SEXPREC>)v; +SET_MISSING(*<SEXPREC>i)v; +SET_NAMED(*<SEXPREC>i)v; +SET_OBJECT(*<SEXPREC>i)v; +SET_PRCODE(*<SEXPREC>*<SEXPREC>)v; +SET_PRENV(*<SEXPREC>*<SEXPREC>)v; +SET_PRINTNAME(*<SEXPREC>*<SEXPREC>)v; +SET_PRSEEN(*<SEXPREC>i)v; +SET_PRVALUE(*<SEXPREC>*<SEXPREC>)v; +SET_S4_OBJECT(*<SEXPREC>)v; +SET_STRING_ELT(*<SEXPREC>i*<SEXPREC>)v; +SET_SYMVALUE(*<SEXPREC>*<SEXPREC>)v; +SET_TAG(*<SEXPREC>*<SEXPREC>)v; +SET_TRACE(*<SEXPREC>i)v; +SET_TRUELENGTH(*<SEXPREC>i)v; +SET_TYPEOF(*<SEXPREC>i)v; +SET_VECTOR_ELT(*<SEXPREC>i*<SEXPREC>)*<SEXPREC>; +STRING_ELT(*<SEXPREC>i)*<SEXPREC>; +STRING_PTR(*<SEXPREC>)*; +SYMVALUE(*<SEXPREC>)*<SEXPREC>; +S_alloc(ji)*c; +S_realloc(*cjji)*c; +TAG(*<SEXPREC>)*<SEXPREC>; +TRACE(*<SEXPREC>)i; +TRUELENGTH(*<SEXPREC>)i; +TYPEOF(*<SEXPREC>)i; +UNIMPLEMENTED(*c)v; +UNSET_S4_OBJECT(*<SEXPREC>)v; +VECTOR_ELT(*<SEXPREC>i)*<SEXPREC>; +VECTOR_PTR(*<SEXPREC>)*; +WrongArgCount(*c)v; +a64l(*c)j; +abort()v; +abs(i)i; +acos(d)d; +acosf(f)f; +acosh(d)d; +acoshf(f)f; +acoshl(D)D; +acosl(D)D; +alloca(J)*v; +arc4random()I; +arc4random_addrandom(*Ci)v; +arc4random_stir()v; +asin(d)d; +asinf(f)f; +asinh(d)d; +asinhf(f)f; +asinhl(D)D; +asinl(D)D; +asprintf(**c)i; +atan(d)d; +atan2(dd)d; +atan2f(ff)f; +atan2l(DD)D; +atanf(f)f; +atanh(d)d; +atanhf(f)f; +atanhl(D)D; +atanl(D)D; +atexit(*p)i; +atof(*c)d; +atoi(*c)i; +atol(*c)j; +atoll(*c)l; +bcmp(*v*vJ)i; +bcopy(*v*vJ)v; +bsearch(*v*vJJ*p)*v; +bzero(*vJ)v; +call_R(*cj***j*j*)v; +calloc(JJ)*v; +cbrt(d)d; +cbrtf(f)f; +cbrtl(D)D; +ceil(d)d; +ceilf(f)f; +ceill(D)D; +cgetcap(*c*ci)*c; +cgetclose()i; +cgetent(***c)i; +cgetfirst(**)i; +cgetmatch(*c*c)i; +cgetnext(**)i; +cgetnum(*c*c*j)i; +cgetset(*c)i; +cgetstr(*c*c*)i; +cgetustr(*c*c*)i; +clearerr(*<__sFILE>)v; +copysign(dd)d; +copysignf(ff)f; +copysignl(DD)D; +cos(d)d; +cosf(f)f; +cosh(d)d; +coshf(f)f; +coshl(D)D; +cosl(D)D; +ctermid(*c)*c; +ctermid_r(*c)*c; +daemon(ii)i; +devname(iS)*c; +devname_r(iS*ci)*c; +div(ii); +drand48()d; +drem(dd)d; +ecvt(di*i*i)*c; +erand48(*S)d; +erf(d)d; +erfc(d)d; +erfcf(f)f; +erfcl(D)D; +erff(f)f; +erfl(D)D; +exit(i)v; +exp(d)d; +exp2(d)d; +exp2f(f)f; +exp2l(D)D; +exp_rand()d; +expf(f)f; +expl(D)D; +expm1(d)d; +expm1f(f)f; +expm1l(D)D; +fabs(d)d; +fabsf(f)f; +fabsl(D)D; +fclose(*<__sFILE>)i; +fcvt(di*i*i)*c; +fdim(dd)d; +fdimf(ff)f; +fdiml(DD)D; +fdopen(i*c)*<__sFILE>; +feof(*<__sFILE>)i; +ferror(*<__sFILE>)i; +fflush(*<__sFILE>)i; +ffs(i)i; +ffsl(j)i; +fgetc(*<__sFILE>)i; +fgetln(*<__sFILE>*J)*c; +fgetpos(*<__sFILE>*l)i; +fgets(*ci*<__sFILE>)*c; +fileno(*<__sFILE>)i; +findInterval(*didiii*i)i; +find_interv_vec(*d*i*d*i*i*i*i)v; +finite(d)i; +flockfile(*<__sFILE>)v; +floor(d)d; +floorf(f)f; +floorl(D)D; +fls(i)i; +flsl(j)i; +fma(ddd)d; +fmaf(fff)f; +fmal(DDD)D; +fmax(dd)d; +fmaxf(ff)f; +fmaxl(DD)D; +fmin(dd)d; +fminf(ff)f; +fminl(DD)D; +fmod(dd)d; +fmodf(ff)f; +fmodl(DD)D; +fmtcheck(*c*c)*c; +fopen(*c*c)*<__sFILE>; +fprintf(*<__sFILE>*c)i; +fpurge(*<__sFILE>)i; +fputc(i*<__sFILE>)i; +fputs(*c*<__sFILE>)i; +fread(*vJJ*<__sFILE>)J; +free(*v)v; +freopen(*c*c*<__sFILE>)*<__sFILE>; +frexp(d*i)d; +frexpf(f*i)f; +frexpl(D*i)D; +fscanf(*<__sFILE>*c)i; +fseek(*<__sFILE>ji)i; +fseeko(*<__sFILE>li)i; +fsetpos(*<__sFILE>*l)i; +ftell(*<__sFILE>)j; +ftello(*<__sFILE>)l; +ftrylockfile(*<__sFILE>)i; +funlockfile(*<__sFILE>)v; +funopen(*v*p*p*p*p)*<__sFILE>; +fwrite(*vJJ*<__sFILE>)J; +gamma(d)d; +gcvt(di*c)*c; +getbsize(*i*j)*c; +getc(*<__sFILE>)i; +getc_unlocked(*<__sFILE>)i; +getchar()i; +getchar_unlocked()i; +getenv(*c)*c; +getiopolicy_np(ii)i; +getloadavg(*di)i; +getpriority(iI)i; +getprogname()*c; +getrlimit(i*<rlimit>)i; +getrusage(i*<rusage>)i; +gets(*c)*c; +getsubopt(***)i; +getw(*<__sFILE>)i; +grantpt(i)i; +heapsort(*vJJ*p)i; +hypot(dd)d; +hypotf(ff)f; +hypotl(DD)D; +ilogb(d)i; +ilogbf(f)i; +ilogbl(D)i; +index(*ci)*c; +initstate(I*cJ)*c; +j0(d)d; +j1(d)d; +jn(id)d; +jrand48(*S)j; +l64a(j)*c; +labs(j)j; +lcong48(*S)v; +ldexp(di)d; +ldexpf(fi)f; +ldexpl(Di)D; +ldiv(jj); +lgamma(d)d; +lgammaf(f)f; +lgammal(D)D; +llabs(l)l; +lldiv(ll); +llrint(d)l; +llrintf(f)l; +llrintl(D)l; +llround(d)l; +llroundf(f)l; +llroundl(D)l; +log(d)d; +log10(d)d; +log10f(f)f; +log10l(D)D; +log1p(d)d; +log1pf(f)f; +log1pl(D)D; +log2(d)d; +log2f(f)f; +log2l(D)D; +logb(d)d; +logbf(f)f; +logbl(D)D; +logf(f)f; +logl(D)D; +lrand48()j; +lrint(d)j; +lrintf(f)j; +lrintl(D)j; +lround(d)j; +lroundf(f)j; +lroundl(D)j; +malloc(J)*v; +matherr(*<exception>)i; +mblen(*cJ)i; +mbstowcs(*p*cJ)J; +mbtowc(*p*cJ)i; +memccpy(*v*viJ)*v; +memchr(*viJ)*v; +memcmp(*v*vJ)i; +memcpy(*v*vJ)*v; +memmove(*v*vJ)*v; +memset(*viJ)*v; +memset_pattern16(*v*vJ)v; +memset_pattern4(*v*vJ)v; +memset_pattern8(*v*vJ)v; +mergesort(*vJJ*p)i; +mkstemp(*c)i; +mktemp(*c)*c; +modf(d*d)d; +modff(f*f)f; +modfl(D*D)D; +mrand48()j; +nan(*c)d; +nanf(*c)f; +nanl(*c)D; +nearbyint(d)d; +nearbyintf(f)f; +nearbyintl(D)D; +nextafter(dd)d; +nextafterf(ff)f; +nextafterl(DD)D; +nexttoward(dD)d; +nexttowardf(fD)f; +nexttowardl(DD)D; +norm_rand()d; +nrand48(*S)j; +pclose(*<__sFILE>)i; +perror(*c)v; +popen(*c*c)*<__sFILE>; +posix_openpt(i)i; +pow(dd)d; +powf(ff)f; +powl(DD)D; +printLogicalVector(*iii)v; +printf(*c)i; +ptsname(i)*c; +putc(i*<__sFILE>)i; +putc_unlocked(i*<__sFILE>)i; +putchar(i)i; +putchar_unlocked(i)i; +putenv(*c)i; +puts(*c)i; +putw(i*<__sFILE>)i; +qsort(*vJJ*p)v; +qsort_r(*vJJ*v*p)v; +radixsort(*i*CI)i; +rand()i; +rand_r(*I)i; +random()j; +realloc(*vJ)*v; +reallocf(*vJ)*v; +realpath(*c*c)*c; +remainder(dd)d; +remainderf(ff)f; +remainderl(DD)D; +remove(*c)i; +remquo(dd*i)d; +remquof(ff*i)f; +remquol(DD*i)D; +rename(*c*c)i; +rewind(*<__sFILE>)v; +rindex(*ci)*c; +rint(d)d; +rintf(f)f; +rintl(D)D; +rinttol(d)j; +round(d)d; +roundf(f)f; +roundl(D)D; +roundtol(d)j; +rsort_with_index(*d*ii)v; +scalb(dd)d; +scalbln(dj)d; +scalblnf(fj)f; +scalblnl(Dj)D; +scalbn(di)d; +scalbnf(fi)f; +scalbnl(Di)D; +scanf(*c)i; +seed48(*S)*S; +setbuf(*<__sFILE>*c)v; +setbuffer(*<__sFILE>*ci)v; +setenv(*c*ci)i; +setiopolicy_np(iii)i; +setkey(*c)v; +setlinebuf(*<__sFILE>)i; +setpriority(iIi)i; +setprogname(*c)v; +setrlimit(i*<rlimit>)i; +setstate(*c)*c; +setvbuf(*<__sFILE>*ciJ)i; +signal(i*p)*p; +significand(d)d; +sin(d)d; +sinf(f)f; +sinh(d)d; +sinhf(f)f; +sinhl(D)D; +sinl(D)D; +snprintf(*cJ*c)i; +sprintf(*c*c)i; +sqrt(d)d; +sqrtf(f)f; +sqrtl(D)D; +sradixsort(*i*CI)i; +srand(I)v; +srand48(j)v; +sranddev()v; +srandom(I)v; +srandomdev()v; +sscanf(*c*c)i; +stpcpy(*c*c)*c; +strcasecmp(*c*c)i; +strcasestr(*c*c)*c; +strcat(*c*c)*c; +strchr(*ci)*c; +strcmp(*c*c)i; +strcoll(*c*c)i; +strcpy(*c*c)*c; +strcspn(*c*c)J; +strdup(*c)*c; +strerror(i)*c; +strerror_r(i*cJ)i; +strlcat(*c*cJ)J; +strlcpy(*c*cJ)J; +strlen(*c)J; +strmode(i*c)v; +strncasecmp(*c*cJ)i; +strncat(*c*cJ)*c; +strncmp(*c*cJ)i; +strncpy(*c*cJ)*c; +strnstr(*c*cJ)*c; +strpbrk(*c*c)*c; +strrchr(*ci)*c; +strsep(**c)*c; +strsignal(i)*c; +strspn(*c*c)J; +strstr(*c*c)*c; +strtod(*c*)d; +strtof(*c*)f; +strtok(*c*c)*c; +strtok_r(*c*c*)*c; +strtol(*c*i)j; +strtold(*c*)D; +strtoll(*c*i)l; +strtoq(*c*i)l; +strtoul(*c*i)J; +strtoull(*c*i)L; +strtouq(*c*i)L; +strxfrm(*c*cJ)J; +swab(*v*vj)v; +system(*c)i; +tan(d)d; +tanf(f)f; +tanh(d)d; +tanhf(f)f; +tanhl(D)D; +tanl(D)D; +tempnam(*c*c)*c; +tgamma(d)d; +tgammaf(f)f; +tgammal(D)D; +tmpfile()*<__sFILE>; +tmpnam(*c)*c; +trunc(d)d; +truncf(f)f; +truncl(D)D; +ungetc(i*<__sFILE>)i; +unif_rand()d; +unlockpt(i)i; +unsetenv(*c)i; +user_norm_rand()*d; +user_unif_init(I)v; +user_unif_nseed()*i; +user_unif_rand()*d; +user_unif_seedloc()*i; +valloc(J)*v; +vasprintf(**c*c)i; +vfprintf(*<__sFILE>*c*c)i; +vfscanf(*<__sFILE>*c*c)i; +vmaxget()*v; +vmaxset(*v)v; +vprintf(*c*c)i; +vscanf(*c*c)i; +vsnprintf(*cJ*c*c)i; +vsprintf(*c*c*c)i; +vsscanf(*c*c*c)i; +wait(*i)i; +wait3(*ii*<rusage>)i; +wait4(i*ii*<rusage>)i; +waitid(iI*<__siginfo>i)i; +waitpid(i*ii)i; +wcstombs(*c*pJ)J; +wctomb(*cwchar_t)i; +y0(d)d; +y1(d)d; +yn(id)d; +zopen(*c*ci)*<__sFILE>; +") +R_pstream_any_format=0; +R_pstream_ascii_format=1; +R_pstream_binary_format=2; +R_pstream_xdr_format=3; +CE_NATIVE=0; +CE_UTF8=1; +CE_LATIN1=2; +CE_SYMBOL=5; +CE_ANY=99; +BUGGY_KINDERMAN_RAMAGE=0; +AHRENS_DIETER=1; +BOX_MULLER=2; +USER_NORM=3; +INVERSION=4; +KINDERMAN_RAMAGE=5; +WICHMANN_HILL=0; +MARSAGLIA_MULTICARRY=1; +SUPER_DUPER=2; +MERSENNE_TWISTER=3; +KNUTH_TAOCP=4; +USER_UNIF=5; +KNUTH_TAOCP2=6;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/SDL.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,760 @@ +# Mac OS X: this one is needed in case, we are running from Console +# and no initial event loop is available. + +# On Mac OS X Console, a Cocoa Environment is needed for SDL. +if ( Sys.info()[["sysname"]] == "Darwin" && .Platform$GUI != "AQUA") { + + # This seem to be the most practical solution for now: + # A dummy quartz device is created and closed again. + + quartz() + dev.off() + + # An alternative solution via R package 'cocoa' from dyncall site. + # source: http://dyncall.org/svn/trunk/bindings/R/cocoa + + # from: http://www.mail-archive.com/r-help@r-project.org/msg91375.html + # is.installed <- function(mypkg) is.element(mypkg, installed.packages()[,1]) + #if (!is.installed("cocoa")) { + # install.packages("cocoa",,"http://dyncall.org/r") + #} + #library(cocoa) + + # Probably on 10.3 using Carbon with older SDL: + # + # FIXME: Create NSAutoreleasePool + # if (!is.installed("CarbonEL")) { + # install.packages("CarbonEL",,"http://rforge.net") + # } + # library(CarbonEL) +} + +dynbind( c("SDL","SDL-1.2","SDL-1.2.so.0"), " +SDL_AddTimer(I*p*v)*<_SDL_TimerID>; +SDL_AllocRW()*<SDL_RWops>; +SDL_AudioDriverName(*ci)*c; +SDL_AudioInit(*c)i; +SDL_AudioQuit()v; +SDL_BuildAudioCVT(*<SDL_AudioCVT>SCiSCi)i; +SDL_CDClose(*<SDL_CD>)v; +SDL_CDEject(*<SDL_CD>)i; +SDL_CDName(i)*c; +SDL_CDNumDrives()i; +SDL_CDOpen(i)*<SDL_CD>; +SDL_CDPause(*<SDL_CD>)i; +SDL_CDPlay(*<SDL_CD>ii)i; +SDL_CDPlayTracks(*<SDL_CD>iiii)i; +SDL_CDResume(*<SDL_CD>)i; +SDL_CDStatus(*<SDL_CD>)i; +SDL_CDStop(*<SDL_CD>)i; +SDL_ClearError()v; +SDL_CloseAudio()v; +SDL_CondBroadcast(*<SDL_cond>)i; +SDL_CondSignal(*<SDL_cond>)i; +SDL_CondWait(*<SDL_cond>*<SDL_mutex>)i; +SDL_CondWaitTimeout(*<SDL_cond>*<SDL_mutex>I)i; +SDL_ConvertAudio(*<SDL_AudioCVT>)i; +SDL_ConvertSurface(*<SDL_Surface>*<SDL_PixelFormat>I)*<SDL_Surface>; +SDL_CreateCond()*<SDL_cond>; +SDL_CreateCursor(*C*Ciiii)*<SDL_Cursor>; +SDL_CreateMutex()*<SDL_mutex>; +SDL_CreateRGBSurface(IiiiIIII)*<SDL_Surface>; +SDL_CreateRGBSurfaceFrom(*viiiiIIII)*<SDL_Surface>; +SDL_CreateSemaphore(I)*<SDL_semaphore>; +SDL_CreateThread(*p*v)*<SDL_Thread>; +SDL_CreateYUVOverlay(iiI*<SDL_Surface>)*<SDL_Overlay>; +SDL_Delay(I)v; +SDL_DestroyCond(*<SDL_cond>)v; +SDL_DestroyMutex(*<SDL_mutex>)v; +SDL_DestroySemaphore(*<SDL_semaphore>)v; +SDL_DisplayFormat(*<SDL_Surface>)*<SDL_Surface>; +SDL_DisplayFormatAlpha(*<SDL_Surface>)*<SDL_Surface>; +SDL_DisplayYUVOverlay(*<SDL_Overlay>*<SDL_Rect>)i; +SDL_EnableKeyRepeat(ii)i; +SDL_EnableUNICODE(i)i; +SDL_Error(i)v; +SDL_EventState(Ci)C; +SDL_FillRect(*<SDL_Surface>*<SDL_Rect>I)i; +SDL_Flip(*<SDL_Surface>)i; +SDL_FreeCursor(*<SDL_Cursor>)v; +SDL_FreeRW(*<SDL_RWops>)v; +SDL_FreeSurface(*<SDL_Surface>)v; +SDL_FreeWAV(*C)v; +SDL_FreeYUVOverlay(*<SDL_Overlay>)v; +SDL_GL_GetAttribute(i*i)i; +SDL_GL_GetProcAddress(*c)*v; +SDL_GL_LoadLibrary(*c)i; +SDL_GL_Lock()v; +SDL_GL_SetAttribute(ii)i; +SDL_GL_SwapBuffers()v; +SDL_GL_Unlock()v; +SDL_GL_UpdateRects(i*<SDL_Rect>)v; +SDL_GetAppState()C; +SDL_GetAudioStatus()i; +SDL_GetClipRect(*<SDL_Surface>*<SDL_Rect>)v; +SDL_GetCursor()*<SDL_Cursor>; +SDL_GetError()*c; +SDL_GetEventFilter()*p; +SDL_GetGammaRamp(*S*S*S)i; +SDL_GetKeyName(i)*c; +SDL_GetKeyRepeat(*i*i)v; +SDL_GetKeyState(*i)*C; +SDL_GetModState()i; +SDL_GetMouseState(*i*i)C; +SDL_GetRGB(I*<SDL_PixelFormat>*C*C*C)v; +SDL_GetRGBA(I*<SDL_PixelFormat>*C*C*C*C)v; +SDL_GetRelativeMouseState(*i*i)C; +SDL_GetThreadID(*<SDL_Thread>)I; +SDL_GetTicks()I; +SDL_GetVideoInfo()*<SDL_VideoInfo>; +SDL_GetVideoSurface()*<SDL_Surface>; +SDL_Has3DNow()i; +SDL_Has3DNowExt()i; +SDL_HasAltiVec()i; +SDL_HasMMX()i; +SDL_HasMMXExt()i; +SDL_HasRDTSC()i; +SDL_HasSSE()i; +SDL_HasSSE2()i; +SDL_Init(I)i; +SDL_InitSubSystem(I)i; +SDL_JoystickClose(*<_SDL_Joystick>)v; +SDL_JoystickEventState(i)i; +SDL_JoystickGetAxis(*<_SDL_Joystick>i)s; +SDL_JoystickGetBall(*<_SDL_Joystick>i*i*i)i; +SDL_JoystickGetButton(*<_SDL_Joystick>i)C; +SDL_JoystickGetHat(*<_SDL_Joystick>i)C; +SDL_JoystickIndex(*<_SDL_Joystick>)i; +SDL_JoystickName(i)*c; +SDL_JoystickNumAxes(*<_SDL_Joystick>)i; +SDL_JoystickNumBalls(*<_SDL_Joystick>)i; +SDL_JoystickNumButtons(*<_SDL_Joystick>)i; +SDL_JoystickNumHats(*<_SDL_Joystick>)i; +SDL_JoystickOpen(i)*<_SDL_Joystick>; +SDL_JoystickOpened(i)i; +SDL_JoystickUpdate()v; +SDL_KillThread(*<SDL_Thread>)v; +SDL_Linked_Version()*<SDL_version>; +SDL_ListModes(*<SDL_PixelFormat>I)*; +SDL_LoadBMP_RW(*<SDL_RWops>i)*<SDL_Surface>; +SDL_LoadFunction(*v*c)*v; +SDL_LoadObject(*c)*v; +SDL_LoadWAV_RW(*<SDL_RWops>i*<SDL_AudioSpec>**I)*<SDL_AudioSpec>; +SDL_LockAudio()v; +SDL_LockSurface(*<SDL_Surface>)i; +SDL_LockYUVOverlay(*<SDL_Overlay>)i; +SDL_LowerBlit(*<SDL_Surface>*<SDL_Rect>*<SDL_Surface>*<SDL_Rect>)i; +SDL_MapRGB(*<SDL_PixelFormat>CCC)I; +SDL_MapRGBA(*<SDL_PixelFormat>CCCC)I; +SDL_MixAudio(*C*CIi)v; +SDL_NumJoysticks()i; +SDL_OpenAudio(*<SDL_AudioSpec>*<SDL_AudioSpec>)i; +SDL_PauseAudio(i)v; +SDL_PeepEvents(*<SDL_Event>iiI)i; +SDL_PollEvent(*<SDL_Event>)i; +SDL_PumpEvents()v; +SDL_PushEvent(*<SDL_Event>)i; +SDL_Quit()v; +SDL_QuitSubSystem(I)v; +SDL_RWFromConstMem(*vi)*<SDL_RWops>; +SDL_RWFromFP(*<__sFILE>i)*<SDL_RWops>; +SDL_RWFromFile(*c*c)*<SDL_RWops>; +SDL_RWFromMem(*vi)*<SDL_RWops>; +SDL_ReadBE16(*<SDL_RWops>)S; +SDL_ReadBE32(*<SDL_RWops>)I; +SDL_ReadBE64(*<SDL_RWops>)L; +SDL_ReadLE16(*<SDL_RWops>)S; +SDL_ReadLE32(*<SDL_RWops>)I; +SDL_ReadLE64(*<SDL_RWops>)L; +SDL_RemoveTimer(*<_SDL_TimerID>)i; +SDL_SaveBMP_RW(*<SDL_Surface>*<SDL_RWops>i)i; +SDL_SemPost(*<SDL_semaphore>)i; +SDL_SemTryWait(*<SDL_semaphore>)i; +SDL_SemValue(*<SDL_semaphore>)I; +SDL_SemWait(*<SDL_semaphore>)i; +SDL_SemWaitTimeout(*<SDL_semaphore>I)i; +SDL_SetAlpha(*<SDL_Surface>IC)i; +SDL_SetClipRect(*<SDL_Surface>*<SDL_Rect>)i; +SDL_SetColorKey(*<SDL_Surface>II)i; +SDL_SetColors(*<SDL_Surface>*<SDL_Color>ii)i; +SDL_SetCursor(*<SDL_Cursor>)v; +SDL_SetError(*c)v; +SDL_SetEventFilter(*p)v; +SDL_SetGamma(fff)i; +SDL_SetGammaRamp(*S*S*S)i; +SDL_SetModState(i)v; +SDL_SetPalette(*<SDL_Surface>i*<SDL_Color>ii)i; +SDL_SetTimer(I*p)i; +SDL_SetVideoMode(iiiI)*<SDL_Surface>; +SDL_ShowCursor(i)i; +SDL_SoftStretch(*<SDL_Surface>*<SDL_Rect>*<SDL_Surface>*<SDL_Rect>)i; +SDL_Swap16(S)S; +SDL_Swap32(I)I; +SDL_Swap64(L)L; +SDL_ThreadID()I; +SDL_UnloadObject(*v)v; +SDL_UnlockAudio()v; +SDL_UnlockSurface(*<SDL_Surface>)v; +SDL_UnlockYUVOverlay(*<SDL_Overlay>)v; +SDL_UpdateRect(*<SDL_Surface>iiII)v; +SDL_UpdateRects(*<SDL_Surface>i*<SDL_Rect>)v; +SDL_UpperBlit(*<SDL_Surface>*<SDL_Rect>*<SDL_Surface>*<SDL_Rect>)i; +SDL_VideoDriverName(*ci)*c; +SDL_VideoInit(*cI)i; +SDL_VideoModeOK(iiiI)i; +SDL_VideoQuit()v; +SDL_WM_GetCaption(**)v; +SDL_WM_GrabInput(i)i; +SDL_WM_IconifyWindow()i; +SDL_WM_SetCaption(*c*c)v; +SDL_WM_SetIcon(*<SDL_Surface>*C)v; +SDL_WM_ToggleFullScreen(*<SDL_Surface>)i; +SDL_WaitEvent(*<SDL_Event>)i; +SDL_WaitThread(*<SDL_Thread>*i)v; +SDL_WarpMouse(SS)v; +SDL_WasInit(I)I; +SDL_WriteBE16(*<SDL_RWops>S)i; +SDL_WriteBE32(*<SDL_RWops>I)i; +SDL_WriteBE64(*<SDL_RWops>L)i; +SDL_WriteLE16(*<SDL_RWops>S)i; +SDL_WriteLE32(*<SDL_RWops>I)i; +SDL_WriteLE64(*<SDL_RWops>L)i; +SDL_iconv(*<_SDL_iconv_t>**J**J)J; +SDL_iconv_close(*<_SDL_iconv_t>)i; +SDL_iconv_open(*c*c)*<_SDL_iconv_t>; +SDL_iconv_string(*c*c*cJ)*c; +SDL_lltoa(l*ci)*c; +SDL_ltoa(j*ci)*c; +SDL_main(i*)i; +SDL_mutexP(*<SDL_mutex>)i; +SDL_mutexV(*<SDL_mutex>)i; +SDL_strlwr(*c)*c; +SDL_strrev(*c)*c; +SDL_strupr(*c)*c; +SDL_ulltoa(L*ci)*c; +SDL_ultoa(J*ci)*c; +") +parseStructInfos(" +SDL_Rect{ssSS}x y w h ; +SDL_version{CCC}major minor patch ; +SDL_SysWMEvent{C*<SDL_SysWMmsg>}type msg ; +SDL_SysWMmsg{}; +SDL_UserEvent{Ci*v*v}type code data1 data2 ; +SDL_QuitEvent{C}type ; +SDL_ExposeEvent{C}type ; +SDL_ResizeEvent{Cii}type w h ; +SDL_JoyButtonEvent{CCCC}type which button state ; +SDL_JoyHatEvent{CCCC}type which hat value ; +SDL_JoyBallEvent{CCCss}type which ball xrel yrel ; +SDL_JoyAxisEvent{CCCs}type which axis value ; +SDL_MouseButtonEvent{CCCCSS}type which button state x y ; +SDL_MouseMotionEvent{CCCSSss}type which state x y xrel yrel ; +SDL_keysym{CiiS}scancode sym mod unicode ; +SDL_KeyboardEvent{CCC<SDL_keysym>}type which state keysym ; +SDL_ActiveEvent{CCC}type gain state ; +WMcursor{}; +private_yuvhwdata{}; +private_yuvhwfuncs{}; +SDL_VideoInfo{IIIIIIIIIIIII*<SDL_PixelFormat>ii}hw_available wm_available UnusedBits1 UnusedBits2 blit_hw blit_hw_CC blit_hw_A blit_sw blit_sw_CC blit_sw_A blit_fill UnusedBits3 video_mem vfmt current_w current_h ; +SDL_Surface{I*<SDL_PixelFormat>iiS*vi*<private_hwdata><SDL_Rect>II*<SDL_BlitMap>Ii}flags format w h pitch pixels offset hwdata clip_rect unused1 locked map format_version refcount ; +SDL_BlitMap{}; +private_hwdata{}; +SDL_PixelFormat{*<SDL_Palette>CCCCCCCCCCIIIIIC}palette BitsPerPixel BytesPerPixel Rloss Gloss Bloss Aloss Rshift Gshift Bshift Ashift Rmask Gmask Bmask Amask colorkey alpha ; +SDL_Palette{i*<SDL_Color>}ncolors colors ; +SDL_Color{CCCC}r g b unused ; +SDL_CDtrack{CCSII}id type unused length offset ; +SDL_Thread{}; +SDL_cond{}; +SDL_semaphore{}; +SDL_mutex{}; +") +.deactivated <- "SDL_AudioCVT{iSSd*Ciiidi}needed src_format dst_format rate_incr buf len len_cvt len_mult len_ratio filters filter_index ; +SDL_Overlay{Iiii*S**<private_yuvhwfuncs>*<private_yuvhwdata>II}format w h planes pitches pixels hwfuncs hwdata hw_overlay UnusedBits ; +SDL_Cursor{<SDL_Rect>ss*C*C*<WMcursor>}area hot_x hot_y data mask save wm_cursor ; +SDL_CD{iiiii}id status numtracks cur_track cur_frame track ; +SDL_AudioSpec{iSCCSSI*p*v}freq format channels silence samples padding size callback userdata ; +SDL_RWops{*p*p*p*pI<$_16>}seek read write close type hidden ; +imaxdiv_t{ll}quot rem ; +lldiv_t{ll}quot rem ; +ldiv_t{jj}quot rem ; +div_t{ii}quot rem ; +rlimit{LL}rlim_cur rlim_max ; +rusage{<timeval><timeval>jjjjjjjjjjjjjj}ru_utime ru_stime ru_maxrss ru_ixrss ru_idrss ru_isrss ru_minflt ru_majflt ru_nswap ru_inblock ru_oublock ru_msgsnd ru_msgrcv ru_nsignals ru_nvcsw ru_nivcsw ; +timeval{ji}tv_sec tv_usec ; +sigstack{*ci}ss_sp ss_onstack ; +sigvec{*pii}sv_handler sv_mask sv_flags ; +sigaction{<__sigaction_u>Ii}__sigaction_u sa_mask sa_flags ; +sigevent{ii<sigval>*p*<_opaque_pthread_attr_t>}sigev_notify sigev_signo sigev_value sigev_notify_function sigev_notify_attributes ; +fd_set{}fds_bits ; +" +parseUnionInfos(" +SDL_Event|C<SDL_ActiveEvent><SDL_KeyboardEvent><SDL_MouseMotionEvent><SDL_MouseButtonEvent><SDL_JoyAxisEvent><SDL_JoyBallEvent><SDL_JoyHatEvent><SDL_JoyButtonEvent><SDL_ResizeEvent><SDL_ExposeEvent><SDL_QuitEvent><SDL_UserEvent><SDL_SysWMEvent>}type active key motion button jaxis jball jhat jbutton resize expose quit user syswm ; +") +AUDIO_S16=0x8010 +AUDIO_S16LSB=0x8010 +AUDIO_S16MSB=0x9010 +AUDIO_S16SYS=0x8010 +AUDIO_S8=0x8008 +AUDIO_U16=0x0010 +AUDIO_U16LSB=0x0010 +AUDIO_U16MSB=0x1010 +AUDIO_U16SYS=0x0010 +AUDIO_U8=0x0008 +SDLCALL= +SDL_ALLEVENTS=0xFFFFFFFF +SDL_ALL_HOTKEYS=0xFFFFFFFF +SDL_ALPHA_OPAQUE=255 +SDL_ALPHA_TRANSPARENT=0 +SDL_ANYFORMAT=0x10000000 +SDL_APPACTIVE=0x04 +SDL_APPINPUTFOCUS=0x02 +SDL_APPMOUSEFOCUS=0x01 +SDL_ASSEMBLY_ROUTINES=1 +SDL_ASYNCBLIT=0x00000004 +SDL_AUDIO_DRIVER_COREAUDIO=1 +SDL_AUDIO_DRIVER_DISK=1 +SDL_AUDIO_DRIVER_DUMMY=1 +SDL_AUDIO_DRIVER_SNDMGR=1 +SDL_AUDIO_TRACK=0x00 +SDL_AllocSurface=SDL_CreateRGBSurface +SDL_BIG_ENDIAN=4321 +SDL_BUTTON_LEFT=1 +# SDL_BUTTON_LMASK=(1 << ((1)-1)) +SDL_BUTTON_MIDDLE=2 +# SDL_BUTTON_MMASK=(1 << ((2)-1)) +SDL_BUTTON_RIGHT=3 +# SDL_BUTTON_RMASK=(1 << ((3)-1)) +SDL_BUTTON_WHEELDOWN=5 +SDL_BUTTON_WHEELUP=4 +SDL_BUTTON_X1=6 +# SDL_BUTTON_X1MASK=(1 << ((6)-1)) +SDL_BUTTON_X2=7 +# SDL_BUTTON_X2MASK=(1 << ((7)-1)) +SDL_BYTEORDER=1234 +SDL_BlitSurface=SDL_UpperBlit +SDL_CDROM_MACOSX=1 +# SDL_COMPILEDVERSION=((1)*1000 + (2)*100 + (13)) +SDL_Colour=SDL_Color +SDL_DATA_TRACK=0x04 +SDL_DEFAULT_REPEAT_DELAY=500 +SDL_DEFAULT_REPEAT_INTERVAL=30 +SDL_DISABLE=0 +SDL_DOUBLEBUF=0x40000000 +SDL_ENABLE=1 +SDL_FULLSCREEN=0x80000000 +SDL_HAS_64BIT_TYPE=1 +SDL_HAT_CENTERED=0x00 +SDL_HAT_DOWN=0x04 +SDL_HAT_LEFT=0x08 +# SDL_HAT_LEFTDOWN=(0x08|0x04) +# SDL_HAT_LEFTUP=(0x08|0x01) +SDL_HAT_RIGHT=0x02 +# SDL_HAT_RIGHTDOWN=(0x02|0x04) +# SDL_HAT_RIGHTUP=(0x02|0x01) +SDL_HAT_UP=0x01 +SDL_HWACCEL=0x00000100 +SDL_HWPALETTE=0x20000000 +SDL_HWSURFACE=0x00000001 +# SDL_ICONV_E2BIG=(size_t)-2 +# SDL_ICONV_EILSEQ=(size_t)-3 +# SDL_ICONV_EINVAL=(size_t)-4 +# SDL_ICONV_ERROR=(size_t)-1 +SDL_IGNORE=0 +SDL_INIT_AUDIO=0x00000010 +SDL_INIT_CDROM=0x00000100 +SDL_INIT_EVENTTHREAD=0x01000000 +SDL_INIT_EVERYTHING=0x0000FFFF +SDL_INIT_JOYSTICK=0x00000200 +SDL_INIT_NOPARACHUTE=0x00100000 +SDL_INIT_TIMER=0x00000001 +SDL_INIT_VIDEO=0x00000020 +SDL_INLINE_OKAY= +SDL_IYUV_OVERLAY=0x56555949 +SDL_JOYSTICK_IOKIT=1 +SDL_LIL_ENDIAN=1234 +SDL_LOADSO_DLOPEN=1 +SDL_LOGPAL=0x01 +SDL_MAJOR_VERSION=1 +SDL_MAX_TRACKS=99 +SDL_MINOR_VERSION=2 +SDL_MIX_MAXVOLUME=128 +# SDL_MUTEX_MAXWAIT=(~(Uint32)0) +SDL_MUTEX_TIMEDOUT=1 +SDL_NOFRAME=0x00000020 +SDL_OPENGL=0x00000002 +SDL_OPENGLBLIT=0x0000000A +SDL_PATCHLEVEL=13 +SDL_PHYSPAL=0x02 +SDL_PREALLOC=0x01000000 +SDL_PRESSED=1 +SDL_QUERY=-1 +SDL_RELEASED=0 +SDL_RESIZABLE=0x00000010 +SDL_RLEACCEL=0x00004000 +SDL_RLEACCELOK=0x00002000 +SDL_SRCALPHA=0x00010000 +SDL_SRCCOLORKEY=0x00001000 +SDL_SWSURFACE=0x00000000 +SDL_THREAD_PTHREAD=1 +SDL_THREAD_PTHREAD_RECURSIVE_MUTEX=1 +SDL_TIMER_UNIX=1 +SDL_TIMESLICE=10 +SDL_UYVY_OVERLAY=0x59565955 +SDL_VIDEO_DRIVER_DUMMY=1 +SDL_VIDEO_DRIVER_QUARTZ=1 +SDL_VIDEO_OPENGL=1 +SDL_YUY2_OVERLAY=0x32595559 +SDL_YV12_OVERLAY=0x32315659 +SDL_YVYU_OVERLAY=0x55595659 +#SDL_abs=abs +#SDL_atof=atof +#SDL_atoi=atoi +#SDL_calloc=calloc +#SDL_free=free +#SDL_getenv=getenv +#SDL_malloc=malloc +#SDL_memcmp=memcmp +#SDL_memmove=memmove +#SDL_memset=memset +#SDL_putenv=putenv +#SDL_qsort=qsort +#SDL_realloc=realloc +#SDL_snprintf=snprintf +#SDL_sscanf=sscanf +#SDL_strcasecmp=strcasecmp +#SDL_strchr=strchr +#SDL_strcmp=strcmp +#SDL_strdup=strdup +#SDL_strlcat=strlcat +#SDL_strlcpy=strlcpy +#SDL_strlen=strlen +#SDL_strncasecmp=strncasecmp +#SDL_strncmp=strncmp +#SDL_strrchr=strrchr +#SDL_strstr=strstr +#SDL_strtod=strtod +#SDL_strtol=strtol +#SDL_strtoll=strtoll +#SDL_strtoul=strtoul +#SDL_strtoull=strtoull +#SDL_vsnprintf=vsnprintf + + +SDL_ADDEVENT=0; +SDL_PEEKEVENT=1; +SDL_GETEVENT=2; +SDL_ACTIVEEVENTMASK=2; +SDL_KEYDOWNMASK=4; +SDL_KEYUPMASK=8; +SDL_KEYEVENTMASK=12; +SDL_MOUSEMOTIONMASK=16; +SDL_MOUSEBUTTONDOWNMASK=32; +SDL_MOUSEBUTTONUPMASK=64; +SDL_MOUSEEVENTMASK=112; +SDL_JOYAXISMOTIONMASK=128; +SDL_JOYBALLMOTIONMASK=256; +SDL_JOYHATMOTIONMASK=512; +SDL_JOYBUTTONDOWNMASK=1024; +SDL_JOYBUTTONUPMASK=2048; +SDL_JOYEVENTMASK=3968; +SDL_VIDEORESIZEMASK=65536; +SDL_VIDEOEXPOSEMASK=131072; +SDL_QUITMASK=4096; +SDL_SYSWMEVENTMASK=8192; +SDL_NOEVENT=0; +SDL_ACTIVEEVENT=1; +SDL_KEYDOWN=2; +SDL_KEYUP=3; +SDL_MOUSEMOTION=4; +SDL_MOUSEBUTTONDOWN=5; +SDL_MOUSEBUTTONUP=6; +SDL_JOYAXISMOTION=7; +SDL_JOYBALLMOTION=8; +SDL_JOYHATMOTION=9; +SDL_JOYBUTTONDOWN=10; +SDL_JOYBUTTONUP=11; +SDL_QUIT=12; +SDL_SYSWMEVENT=13; +SDL_EVENT_RESERVEDA=14; +SDL_EVENT_RESERVEDB=15; +SDL_VIDEORESIZE=16; +SDL_VIDEOEXPOSE=17; +SDL_EVENT_RESERVED2=18; +SDL_EVENT_RESERVED3=19; +SDL_EVENT_RESERVED4=20; +SDL_EVENT_RESERVED5=21; +SDL_EVENT_RESERVED6=22; +SDL_EVENT_RESERVED7=23; +SDL_USEREVENT=24; +SDL_NUMEVENTS=32; +SDL_GRAB_QUERY=-1; +SDL_GRAB_OFF=0; +SDL_GRAB_ON=1; +SDL_GRAB_FULLSCREEN=2; +SDL_GL_RED_SIZE=0; +SDL_GL_GREEN_SIZE=1; +SDL_GL_BLUE_SIZE=2; +SDL_GL_ALPHA_SIZE=3; +SDL_GL_BUFFER_SIZE=4; +SDL_GL_DOUBLEBUFFER=5; +SDL_GL_DEPTH_SIZE=6; +SDL_GL_STENCIL_SIZE=7; +SDL_GL_ACCUM_RED_SIZE=8; +SDL_GL_ACCUM_GREEN_SIZE=9; +SDL_GL_ACCUM_BLUE_SIZE=10; +SDL_GL_ACCUM_ALPHA_SIZE=11; +SDL_GL_STEREO=12; +SDL_GL_MULTISAMPLEBUFFERS=13; +SDL_GL_MULTISAMPLESAMPLES=14; +SDL_GL_ACCELERATED_VISUAL=15; +SDL_GL_SWAP_CONTROL=16; +SDLK_UNKNOWN=0; +SDLK_FIRST=0; +SDLK_BACKSPACE=8; +SDLK_TAB=9; +SDLK_CLEAR=12; +SDLK_RETURN=13; +SDLK_PAUSE=19; +SDLK_ESCAPE=27; +SDLK_SPACE=32; +SDLK_EXCLAIM=33; +SDLK_QUOTEDBL=34; +SDLK_HASH=35; +SDLK_DOLLAR=36; +SDLK_AMPERSAND=38; +SDLK_QUOTE=39; +SDLK_LEFTPAREN=40; +SDLK_RIGHTPAREN=41; +SDLK_ASTERISK=42; +SDLK_PLUS=43; +SDLK_COMMA=44; +SDLK_MINUS=45; +SDLK_PERIOD=46; +SDLK_SLASH=47; +SDLK_0=48; +SDLK_1=49; +SDLK_2=50; +SDLK_3=51; +SDLK_4=52; +SDLK_5=53; +SDLK_6=54; +SDLK_7=55; +SDLK_8=56; +SDLK_9=57; +SDLK_COLON=58; +SDLK_SEMICOLON=59; +SDLK_LESS=60; +SDLK_EQUALS=61; +SDLK_GREATER=62; +SDLK_QUESTION=63; +SDLK_AT=64; +SDLK_LEFTBRACKET=91; +SDLK_BACKSLASH=92; +SDLK_RIGHTBRACKET=93; +SDLK_CARET=94; +SDLK_UNDERSCORE=95; +SDLK_BACKQUOTE=96; +SDLK_a=97; +SDLK_b=98; +SDLK_c=99; +SDLK_d=100; +SDLK_e=101; +SDLK_f=102; +SDLK_g=103; +SDLK_h=104; +SDLK_i=105; +SDLK_j=106; +SDLK_k=107; +SDLK_l=108; +SDLK_m=109; +SDLK_n=110; +SDLK_o=111; +SDLK_p=112; +SDLK_q=113; +SDLK_r=114; +SDLK_s=115; +SDLK_t=116; +SDLK_u=117; +SDLK_v=118; +SDLK_w=119; +SDLK_x=120; +SDLK_y=121; +SDLK_z=122; +SDLK_DELETE=127; +SDLK_WORLD_0=160; +SDLK_WORLD_1=161; +SDLK_WORLD_2=162; +SDLK_WORLD_3=163; +SDLK_WORLD_4=164; +SDLK_WORLD_5=165; +SDLK_WORLD_6=166; +SDLK_WORLD_7=167; +SDLK_WORLD_8=168; +SDLK_WORLD_9=169; +SDLK_WORLD_10=170; +SDLK_WORLD_11=171; +SDLK_WORLD_12=172; +SDLK_WORLD_13=173; +SDLK_WORLD_14=174; +SDLK_WORLD_15=175; +SDLK_WORLD_16=176; +SDLK_WORLD_17=177; +SDLK_WORLD_18=178; +SDLK_WORLD_19=179; +SDLK_WORLD_20=180; +SDLK_WORLD_21=181; +SDLK_WORLD_22=182; +SDLK_WORLD_23=183; +SDLK_WORLD_24=184; +SDLK_WORLD_25=185; +SDLK_WORLD_26=186; +SDLK_WORLD_27=187; +SDLK_WORLD_28=188; +SDLK_WORLD_29=189; +SDLK_WORLD_30=190; +SDLK_WORLD_31=191; +SDLK_WORLD_32=192; +SDLK_WORLD_33=193; +SDLK_WORLD_34=194; +SDLK_WORLD_35=195; +SDLK_WORLD_36=196; +SDLK_WORLD_37=197; +SDLK_WORLD_38=198; +SDLK_WORLD_39=199; +SDLK_WORLD_40=200; +SDLK_WORLD_41=201; +SDLK_WORLD_42=202; +SDLK_WORLD_43=203; +SDLK_WORLD_44=204; +SDLK_WORLD_45=205; +SDLK_WORLD_46=206; +SDLK_WORLD_47=207; +SDLK_WORLD_48=208; +SDLK_WORLD_49=209; +SDLK_WORLD_50=210; +SDLK_WORLD_51=211; +SDLK_WORLD_52=212; +SDLK_WORLD_53=213; +SDLK_WORLD_54=214; +SDLK_WORLD_55=215; +SDLK_WORLD_56=216; +SDLK_WORLD_57=217; +SDLK_WORLD_58=218; +SDLK_WORLD_59=219; +SDLK_WORLD_60=220; +SDLK_WORLD_61=221; +SDLK_WORLD_62=222; +SDLK_WORLD_63=223; +SDLK_WORLD_64=224; +SDLK_WORLD_65=225; +SDLK_WORLD_66=226; +SDLK_WORLD_67=227; +SDLK_WORLD_68=228; +SDLK_WORLD_69=229; +SDLK_WORLD_70=230; +SDLK_WORLD_71=231; +SDLK_WORLD_72=232; +SDLK_WORLD_73=233; +SDLK_WORLD_74=234; +SDLK_WORLD_75=235; +SDLK_WORLD_76=236; +SDLK_WORLD_77=237; +SDLK_WORLD_78=238; +SDLK_WORLD_79=239; +SDLK_WORLD_80=240; +SDLK_WORLD_81=241; +SDLK_WORLD_82=242; +SDLK_WORLD_83=243; +SDLK_WORLD_84=244; +SDLK_WORLD_85=245; +SDLK_WORLD_86=246; +SDLK_WORLD_87=247; +SDLK_WORLD_88=248; +SDLK_WORLD_89=249; +SDLK_WORLD_90=250; +SDLK_WORLD_91=251; +SDLK_WORLD_92=252; +SDLK_WORLD_93=253; +SDLK_WORLD_94=254; +SDLK_WORLD_95=255; +SDLK_KP0=256; +SDLK_KP1=257; +SDLK_KP2=258; +SDLK_KP3=259; +SDLK_KP4=260; +SDLK_KP5=261; +SDLK_KP6=262; +SDLK_KP7=263; +SDLK_KP8=264; +SDLK_KP9=265; +SDLK_KP_PERIOD=266; +SDLK_KP_DIVIDE=267; +SDLK_KP_MULTIPLY=268; +SDLK_KP_MINUS=269; +SDLK_KP_PLUS=270; +SDLK_KP_ENTER=271; +SDLK_KP_EQUALS=272; +SDLK_UP=273; +SDLK_DOWN=274; +SDLK_RIGHT=275; +SDLK_LEFT=276; +SDLK_INSERT=277; +SDLK_HOME=278; +SDLK_END=279; +SDLK_PAGEUP=280; +SDLK_PAGEDOWN=281; +SDLK_F1=282; +SDLK_F2=283; +SDLK_F3=284; +SDLK_F4=285; +SDLK_F5=286; +SDLK_F6=287; +SDLK_F7=288; +SDLK_F8=289; +SDLK_F9=290; +SDLK_F10=291; +SDLK_F11=292; +SDLK_F12=293; +SDLK_F13=294; +SDLK_F14=295; +SDLK_F15=296; +SDLK_NUMLOCK=300; +SDLK_CAPSLOCK=301; +SDLK_SCROLLOCK=302; +SDLK_RSHIFT=303; +SDLK_LSHIFT=304; +SDLK_RCTRL=305; +SDLK_LCTRL=306; +SDLK_RALT=307; +SDLK_LALT=308; +SDLK_RMETA=309; +SDLK_LMETA=310; +SDLK_LSUPER=311; +SDLK_RSUPER=312; +SDLK_MODE=313; +SDLK_COMPOSE=314; +SDLK_HELP=315; +SDLK_PRINT=316; +SDLK_SYSREQ=317; +SDLK_BREAK=318; +SDLK_MENU=319; +SDLK_POWER=320; +SDLK_EURO=321; +SDLK_UNDO=322; +SDLK_LAST=323; +CD_TRAYEMPTY=0; +CD_STOPPED=1; +CD_PLAYING=2; +CD_PAUSED=3; +CD_ERROR=-1; +SDL_AUDIO_STOPPED=0; +SDL_AUDIO_PLAYING=1; +SDL_AUDIO_PAUSED=2; +SDL_ENOMEM=0; +SDL_EFREAD=1; +SDL_EFWRITE=2; +SDL_EFSEEK=3; +SDL_UNSUPPORTED=4; +SDL_LASTERROR=5; +SDL_FALSE=0; +SDL_TRUE=1;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/SDL_image.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,41 @@ +dynbind(c("SDL_image","SDL_image-1.2","SDL_image-1.2.so.0"), " +IMG_Init(i)i; +IMG_InvertAlpha(i)i; +IMG_Linked_Version()*<SDL_version>; +IMG_Load(*c)*<SDL_Surface>; +IMG_LoadBMP_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadCUR_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadGIF_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadICO_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadJPG_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadLBM_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadPCX_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadPNG_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadPNM_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadTGA_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadTIF_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadTyped_RW(*<SDL_RWops>i*c)*<SDL_Surface>; +IMG_LoadXCF_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadXPM_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadXV_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_Load_RW(*<SDL_RWops>i)*<SDL_Surface>; +IMG_Quit()v; +IMG_ReadXPMFromArray(**c)*<SDL_Surface>; +IMG_isBMP(*<SDL_RWops>)i; +IMG_isCUR(*<SDL_RWops>)i; +IMG_isGIF(*<SDL_RWops>)i; +IMG_isICO(*<SDL_RWops>)i; +IMG_isJPG(*<SDL_RWops>)i; +IMG_isLBM(*<SDL_RWops>)i; +IMG_isPCX(*<SDL_RWops>)i; +IMG_isPNG(*<SDL_RWops>)i; +IMG_isPNM(*<SDL_RWops>)i; +IMG_isTIF(*<SDL_RWops>)i; +IMG_isXCF(*<SDL_RWops>)i; +IMG_isXPM(*<SDL_RWops>)i; +IMG_isXV(*<SDL_RWops>)i; +") +IMG_INIT_JPG=1; +IMG_INIT_PNG=2; +IMG_INIT_TIF=4; +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/SDL_mixer.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,103 @@ + + +dynbind(c("SDL_mixer","SDL_mixer-1.2","SDL_mixer-1.2.so.0"), " +Mix_AllocateChannels(i)i; +Mix_ChannelFinished(*p)v; +Mix_CloseAudio()v; +Mix_ExpireChannel(ii)i; +Mix_FadeInChannelTimed(i*<Mix_Chunk>iii)i; +Mix_FadeInMusic(*<_Mix_Music>ii)i; +Mix_FadeInMusicPos(*<_Mix_Music>iid)i; +Mix_FadeOutChannel(ii)i; +Mix_FadeOutGroup(ii)i; +Mix_FadeOutMusic(i)i; +Mix_FadingChannel(i)i; +Mix_FadingMusic()i; +Mix_FreeChunk(*<Mix_Chunk>)v; +Mix_FreeMusic(*<_Mix_Music>)v; +Mix_GetChunk(i)*<Mix_Chunk>; +Mix_GetChunkDecoder(i)*c; +Mix_GetMusicDecoder(i)*c; +Mix_GetMusicHookData()*v; +Mix_GetMusicType(*<_Mix_Music>)i; +Mix_GetNumChunkDecoders()i; +Mix_GetNumMusicDecoders()i; +Mix_GetSynchroValue()i; +Mix_GroupAvailable(i)i; +Mix_GroupChannel(ii)i; +Mix_GroupChannels(iii)i; +Mix_GroupCount(i)i; +Mix_GroupNewer(i)i; +Mix_GroupOldest(i)i; +Mix_HaltChannel(i)i; +Mix_HaltGroup(i)i; +Mix_HaltMusic()i; +Mix_HookMusic(*p*v)v; +Mix_HookMusicFinished(*p)v; +Mix_Init(i)i; +Mix_Linked_Version()*<SDL_version>; +Mix_LoadMUS(*c)*<_Mix_Music>; +Mix_LoadMUS_RW(*<SDL_RWops>)*<_Mix_Music>; +Mix_LoadWAV_RW(*<SDL_RWops>i)*<Mix_Chunk>; +Mix_OpenAudio(iSii)i; +Mix_Pause(i)v; +Mix_PauseMusic()v; +Mix_Paused(i)i; +Mix_PausedMusic()i; +Mix_PlayChannelTimed(i*<Mix_Chunk>ii)i; +Mix_PlayMusic(*<_Mix_Music>i)i; +Mix_Playing(i)i; +Mix_PlayingMusic()i; +Mix_QuerySpec(*i*S*i)i; +Mix_QuickLoad_RAW(*CI)*<Mix_Chunk>; +Mix_QuickLoad_WAV(*C)*<Mix_Chunk>; +Mix_Quit()v; +Mix_RegisterEffect(i*p*p*v)i; +Mix_ReserveChannels(i)i; +Mix_Resume(i)v; +Mix_ResumeMusic()v; +Mix_RewindMusic()v; +Mix_SetDistance(iC)i; +Mix_SetMusicCMD(*c)i; +Mix_SetMusicPosition(d)i; +Mix_SetPanning(iCC)i; +Mix_SetPosition(isC)i; +Mix_SetPostMix(*p*v)v; +Mix_SetReverseStereo(ii)i; +Mix_SetSynchroValue(i)i; +Mix_UnregisterAllEffects(i)i; +Mix_UnregisterEffect(i*p)i; +Mix_Volume(ii)i; +Mix_VolumeChunk(*<Mix_Chunk>i)i; +Mix_VolumeMusic(i)i; +") +MIX_FADING_IN=2; +MIX_FADING_OUT=1; +MIX_INIT_FLAC=1; +MIX_INIT_MOD=2; +MIX_INIT_MP3=4; +MIX_INIT_OGG=8; +MIX_NO_FADING=0; +AUDIO_S16=0x8010 +AUDIO_S16LSB=0x8010 +AUDIO_S16MSB=0x9010 +AUDIO_S16SYS=0x8010 +AUDIO_S8=0x8008 +AUDIO_U16=0x0010 +AUDIO_U16LSB=0x0010 +AUDIO_U16MSB=0x1010 +AUDIO_U16SYS=0x0010 +AUDIO_U8=0x0008 +MIX_CHANNELS=8 +MIX_CHANNEL_POST=-2 +MIX_DEFAULT_CHANNELS=2 +MIX_DEFAULT_FORMAT=0x8010 +MIX_DEFAULT_FREQUENCY=22050 +MIX_EFFECTSMAXSPEED="MIX_EFFECTSMAXSPEED" +MIX_MAJOR_VERSION=1 +MIX_MAX_VOLUME=128 +MIX_MINOR_VERSION=2 +MIX_PATCHLEVEL=11 +Mix_GetError=SDL_GetError +Mix_SetError=SDL_SetError +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/SDL_net.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,51 @@ + + +dynbind("SDL_net", " +SDLNet_AddSocket(*<_SDLNet_SocketSet>*<SDLNet_GenericSocket_>)i; +SDLNet_AllocPacket(i)*<UDPpacket>; +SDLNet_AllocPacketV(ii)**<UDPpacket>; +SDLNet_AllocSocketSet(i)*<_SDLNet_SocketSet>; +SDLNet_CheckSockets(*<_SDLNet_SocketSet>I)i; +SDLNet_DelSocket(*<_SDLNet_SocketSet>*<SDLNet_GenericSocket_>)i; +SDLNet_FreePacket(*<UDPpacket>)v; +SDLNet_FreePacketV(**<UDPpacket>)v; +SDLNet_FreeSocketSet(*<_SDLNet_SocketSet>)v; +SDLNet_Init()i; +SDLNet_Linked_Version()*<SDL_version>; +SDLNet_Quit()v; +SDLNet_Read16(*v)S; +SDLNet_Read32(*v)I; +SDLNet_ResizePacket(*<UDPpacket>i)i; +SDLNet_ResolveHost(*<IPaddress>*cS)i; +SDLNet_ResolveIP(*<IPaddress>)*c; +SDLNet_TCP_Accept(*<_TCPsocket>)*<_TCPsocket>; +SDLNet_TCP_Close(*<_TCPsocket>)v; +SDLNet_TCP_GetPeerAddress(*<_TCPsocket>)*<IPaddress>; +SDLNet_TCP_Open(*<IPaddress>)*<_TCPsocket>; +SDLNet_TCP_Recv(*<_TCPsocket>*vi)i; +SDLNet_TCP_Send(*<_TCPsocket>*vi)i; +SDLNet_UDP_Bind(*<_UDPsocket>i*<IPaddress>)i; +SDLNet_UDP_Close(*<_UDPsocket>)v; +SDLNet_UDP_GetPeerAddress(*<_UDPsocket>i)*<IPaddress>; +SDLNet_UDP_Open(S)*<_UDPsocket>; +SDLNet_UDP_Recv(*<_UDPsocket>*<UDPpacket>)i; +SDLNet_UDP_RecvV(*<_UDPsocket>**<UDPpacket>)i; +SDLNet_UDP_Send(*<_UDPsocket>i*<UDPpacket>)i; +SDLNet_UDP_SendV(*<_UDPsocket>**<UDPpacket>i)i; +SDLNet_UDP_Unbind(*<_UDPsocket>i)v; +SDLNet_Write16(S*v)v; +SDLNet_Write32(I*v)v; +") +parseStructInfos(" +IPaddress{IS}host port ; +SDLNet_GenericSocket_{i}ready ; +UDPpacket{i*Ciii<IPaddress>}channel data len maxlen status address ; +") +INADDR_ANY=0x00000000 +INADDR_BROADCAST=0xFFFFFFFF +INADDR_NONE=0xFFFFFFFF +SDLNET_MAX_UDPADDRESSES=4 +SDLNET_MAX_UDPCHANNELS=32 +#SDLNet_GetError=SDL_GetError +#SDLNet_SetError=SDL_SetError +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/SDL_ttf.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,49 @@ +dynport("SDL") +dynbind("SDL_ttf", " +TTF_ByteSwappedUNICODE(i)v; +TTF_CloseFont(*<_TTF_Font>)v; +TTF_FontAscent(*<_TTF_Font>)i; +TTF_FontDescent(*<_TTF_Font>)i; +TTF_FontFaceFamilyName(*<_TTF_Font>)*c; +TTF_FontFaceIsFixedWidth(*<_TTF_Font>)i; +TTF_FontFaceStyleName(*<_TTF_Font>)*c; +TTF_FontFaces(*<_TTF_Font>)j; +TTF_FontHeight(*<_TTF_Font>)i; +TTF_FontLineSkip(*<_TTF_Font>)i; +TTF_GetFontStyle(*<_TTF_Font>)i; +TTF_GlyphMetrics(*<_TTF_Font>S*i*i*i*i*i)i; +TTF_Init()i; +TTF_Linked_Version()*<SDL_version>; +TTF_OpenFont(*ci)*<_TTF_Font>; +TTF_OpenFontIndex(*cij)*<_TTF_Font>; +TTF_OpenFontIndexRW(*<SDL_RWops>iij)*<_TTF_Font>; +TTF_OpenFontRW(*<SDL_RWops>ii)*<_TTF_Font>; +TTF_Quit()v; +TTF_RenderGlyph_Blended(*<_TTF_Font>S)*<SDL_Surface>; +TTF_RenderGlyph_Shaded(*<_TTF_Font>S)*<SDL_Surface>; +TTF_RenderGlyph_Solid(*<_TTF_Font>S)*<SDL_Surface>; +TTF_RenderText_Blended(*<_TTF_Font>*c)*<SDL_Surface>; +TTF_RenderText_Shaded(*<_TTF_Font>*c)*<SDL_Surface>; +TTF_RenderText_Solid(*<_TTF_Font>*c)*<SDL_Surface>; +TTF_RenderUNICODE_Blended(*<_TTF_Font>*S)*<SDL_Surface>; +TTF_RenderUNICODE_Shaded(*<_TTF_Font>*S)*<SDL_Surface>; +TTF_RenderUNICODE_Solid(*<_TTF_Font>*S)*<SDL_Surface>; +TTF_RenderUTF8_Blended(*<_TTF_Font>*c)*<SDL_Surface>; +TTF_RenderUTF8_Shaded(*<_TTF_Font>*c)*<SDL_Surface>; +TTF_RenderUTF8_Solid(*<_TTF_Font>*c)*<SDL_Surface>; +TTF_SetFontStyle(*<_TTF_Font>i)v; +TTF_SizeText(*<_TTF_Font>*c*i*i)i; +TTF_SizeUNICODE(*<_TTF_Font>*S*i*i)i; +TTF_SizeUTF8(*<_TTF_Font>*c*i*i)i; +TTF_WasInit()i; +") +TTF_GetError=SDL_GetError +TTF_MAJOR_VERSION=2 +TTF_MINOR_VERSION=0 +TTF_PATCHLEVEL=9 +TTF_STYLE_BOLD=0x01 +TTF_STYLE_ITALIC=0x02 +TTF_STYLE_NORMAL=0x00 +TTF_STYLE_UNDERLINE=0x04 +TTF_SetError=SDL_SetError +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/csound.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,396 @@ + + +dynbind( c("csound64","csound","csnd64","lib_csnd64.dylib","csound64Lib","csoundLib"), " +csoundAddSpinSample(*<CSOUND_>iif)v; +csoundAppendOpcode(*<CSOUND_>*cii*c*c*p*p*p)i; +csoundCfgErrorCodeToString(i)*c; +csoundChanIASet(*<CSOUND_>*fi)i; +csoundChanIASetSample(*<CSOUND_>iif)i; +csoundChanIKSet(*<CSOUND_>fi)i; +csoundChanIKSetValue(*<CSOUND_>if)i; +csoundChanOAGet(*<CSOUND_>*fi)i; +csoundChanOAGetSample(*<CSOUND_>ii)f; +csoundChanOKGet(*<CSOUND_>*fi)i; +csoundChanOKGetValue(*<CSOUND_>i)f; +csoundCleanup(*<CSOUND_>)i; +csoundCloseLibrary(*v)i; +csoundCompile(*<CSOUND_>i**c)i; +csoundCreate(*v)*<CSOUND_>; +csoundCreateBarrier(I)*v; +csoundCreateConfigurationVariable(*<CSOUND_>*c*vii*v*v*c*c)i; +csoundCreateGlobalVariable(*<CSOUND_>*cJ)i; +csoundCreateMutex(i)*v; +csoundCreateThread(*p*v)*v; +csoundCreateThreadLock()*v; +csoundDeleteCfgVarList(**<csCfgVariable_u>)v; +csoundDeleteChannelList(*<CSOUND_>*<CsoundChannelListEntry_>)v; +csoundDeleteConfigurationVariable(*<CSOUND_>*c)i; +csoundDeleteUtilityList(*<CSOUND_>**c)v; +csoundDestroy(*<CSOUND_>)v; +csoundDestroyBarrier(*v)i; +csoundDestroyGlobalVariable(*<CSOUND_>*c)i; +csoundDestroyMessageBuffer(*<CSOUND_>)v; +csoundDestroyMutex(*v)v; +csoundDestroyThreadLock(*v)v; +csoundDisposeOpcodeList(*<CSOUND_>*<opcodeListEntry>)v; +csoundEnableMessageBuffer(*<CSOUND_>i)v; +csoundGet0dBFS(*<CSOUND_>)f; +csoundGetAPIVersion()i; +csoundGetCPUTime(*<RTCLOCK_S>)d; +csoundGetChannelLock(*<CSOUND_>*ci)*i; +csoundGetChannelPtr(*<CSOUND_>**f*ci)i; +csoundGetControlChannelParams(*<CSOUND_>*c*f*f*f)i; +csoundGetCurrentThreadId()*v; +csoundGetDebug(*<CSOUND_>)i; +csoundGetEnv(*<CSOUND_>*c)*c; +csoundGetFirstMessage(*<CSOUND_>)*c; +csoundGetFirstMessageAttr(*<CSOUND_>)i; +csoundGetHostData(*<CSOUND_>)*v; +csoundGetInputBuffer(*<CSOUND_>)*f; +csoundGetInputBufferSize(*<CSOUND_>)j; +csoundGetKr(*<CSOUND_>)f; +csoundGetKsmps(*<CSOUND_>)i; +csoundGetLibrarySymbol(*v*c)*v; +csoundGetMessageCnt(*<CSOUND_>)i; +csoundGetMessageLevel(*<CSOUND_>)i; +csoundGetNamedGens(*<CSOUND_>)*v; +csoundGetNchnls(*<CSOUND_>)i; +csoundGetOutputBuffer(*<CSOUND_>)*f; +csoundGetOutputBufferSize(*<CSOUND_>)j; +csoundGetOutputFileName(*<CSOUND_>)*c; +csoundGetRandomSeedFromTime()I; +csoundGetRealTime(*<RTCLOCK_S>)d; +csoundGetRtPlayUserData(*<CSOUND_>)**v; +csoundGetRtRecordUserData(*<CSOUND_>)**v; +csoundGetSampleFormat(*<CSOUND_>)i; +csoundGetSampleSize(*<CSOUND_>)i; +csoundGetScoreOffsetSeconds(*<CSOUND_>)f; +csoundGetScoreTime(*<CSOUND_>)d; +csoundGetSizeOfMYFLT()i; +csoundGetSpin(*<CSOUND_>)*f; +csoundGetSpout(*<CSOUND_>)*f; +csoundGetSpoutSample(*<CSOUND_>ii)f; +csoundGetSr(*<CSOUND_>)f; +csoundGetStrVarMaxLen(*<CSOUND_>)i; +csoundGetTable(*<CSOUND_>**fi)i; +csoundGetUtilityDescription(*<CSOUND_>*c)*c; +csoundGetVersion()i; +csoundInitTimerStruct(*<RTCLOCK_S>)v; +csoundInitialize(*i***ci)i; +csoundInitializeCscore(*<CSOUND_>*<__sFILE>*<__sFILE>)i; +csoundInputMessage(*<CSOUND_>*c)v; +csoundIsScorePending(*<CSOUND_>)i; +csoundJoinThread(*v)J; +csoundKeyPress(*<CSOUND_>c)v; +csoundListChannels(*<CSOUND_>**<CsoundChannelListEntry_>)i; +csoundListConfigurationVariables(*<CSOUND_>)**<csCfgVariable_u>; +csoundListUtilities(*<CSOUND_>)**c; +csoundLocalizeString(*c)*c; +csoundLockMutex(*v)v; +csoundLockMutexNoWait(*v)i; +csoundMessage(*<CSOUND_>*c?)v; +csoundMessageS(*<CSOUND_>i*c?)v; +csoundMessageV(*<CSOUND_>i*c*c)v; +csoundNewOpcodeList(*<CSOUND_>**<opcodeListEntry>)i; +csoundNotifyThreadLock(*v)v; +csoundOpenLibrary(**v*c)i; +csoundParseConfigurationVariable(*<CSOUND_>*c*c)i; +csoundPerform(*<CSOUND_>)i; +csoundPerformBuffer(*<CSOUND_>)i; +csoundPerformKsmps(*<CSOUND_>)i; +csoundPerformKsmpsAbsolute(*<CSOUND_>)i; +csoundPopFirstMessage(*<CSOUND_>)v; +csoundPreCompile(*<CSOUND_>)i; +csoundPvsinSet(*<CSOUND_>*<pvsdat_ext>i)i; +csoundPvsoutGet(*<CSOUND_>*<pvsdat_ext>i)i; +csoundQueryConfigurationVariable(*<CSOUND_>*c)*<csCfgVariable_u>; +csoundQueryGlobalVariable(*<CSOUND_>*c)*v; +csoundQueryGlobalVariableNoCheck(*<CSOUND_>*c)*v; +csoundQueryInterface(*c**v*i)i; +csoundRand31(*i)i; +csoundRandMT(*<CsoundRandMTState_>)I; +csoundRegisterSenseEventCallback(*<CSOUND_>*p*v)i; +csoundRemoveCallback(*<CSOUND_>*p)v; +csoundReset(*<CSOUND_>)v; +csoundRewindScore(*<CSOUND_>)v; +csoundRunCommand(**ci)j; +csoundRunUtility(*<CSOUND_>*ci**c)i; +csoundScoreEvent(*<CSOUND_>c*fj)i; +csoundScoreExtract(*<CSOUND_>*<__sFILE>*<__sFILE>*<__sFILE>)i; +csoundScoreSort(*<CSOUND_>*<__sFILE>*<__sFILE>)i; +csoundSeedRandMT(*<CsoundRandMTState_>*II)v; +csoundSetCallback(*<CSOUND_>*p*vI)i; +csoundSetChannelIOCallback(*<CSOUND_>*p)v; +csoundSetConfigurationVariable(*<CSOUND_>*c*v)i; +csoundSetControlChannelParams(*<CSOUND_>*cifff)i; +csoundSetCscoreCallback(*<CSOUND_>*p)v; +csoundSetDebug(*<CSOUND_>i)v; +csoundSetDrawGraphCallback(*<CSOUND_>*p)v; +csoundSetExitGraphCallback(*<CSOUND_>*p)v; +csoundSetExternalMidiErrorStringCallback(*<CSOUND_>*p)v; +csoundSetExternalMidiInCloseCallback(*<CSOUND_>*p)v; +csoundSetExternalMidiInOpenCallback(*<CSOUND_>*p)v; +csoundSetExternalMidiOutCloseCallback(*<CSOUND_>*p)v; +csoundSetExternalMidiOutOpenCallback(*<CSOUND_>*p)v; +csoundSetExternalMidiReadCallback(*<CSOUND_>*p)v; +csoundSetExternalMidiWriteCallback(*<CSOUND_>*p)v; +csoundSetFileOpenCallback(*<CSOUND_>*p)v; +csoundSetGlobalEnv(*c*c)i; +csoundSetHostData(*<CSOUND_>*v)v; +csoundSetHostImplementedAudioIO(*<CSOUND_>ii)v; +csoundSetInputValueCallback(*<CSOUND_>*p)v; +csoundSetIsGraphable(*<CSOUND_>i)i; +csoundSetKillGraphCallback(*<CSOUND_>*p)v; +csoundSetKillXYinCallback(*<CSOUND_>*p)v; +csoundSetLanguage(i)v; +csoundSetMakeGraphCallback(*<CSOUND_>*p)v; +csoundSetMakeXYinCallback(*<CSOUND_>*p)v; +csoundSetMessageCallback(*<CSOUND_>*p)v; +csoundSetMessageLevel(*<CSOUND_>i)v; +csoundSetOutputValueCallback(*<CSOUND_>*p)v; +csoundSetPlayopenCallback(*<CSOUND_>*p)v; +csoundSetReadXYinCallback(*<CSOUND_>*p)v; +csoundSetRecopenCallback(*<CSOUND_>*p)v; +csoundSetRtcloseCallback(*<CSOUND_>*p)v; +csoundSetRtplayCallback(*<CSOUND_>*p)v; +csoundSetRtrecordCallback(*<CSOUND_>*p)v; +csoundSetScoreOffsetSeconds(*<CSOUND_>f)v; +csoundSetScorePending(*<CSOUND_>i)v; +csoundSetYieldCallback(*<CSOUND_>*p)v; +csoundSleep(J)v; +csoundStop(*<CSOUND_>)v; +csoundTableGet(*<CSOUND_>ii)f; +csoundTableLength(*<CSOUND_>i)i; +csoundTableSet(*<CSOUND_>iif)v; +csoundUnlockMutex(*v)v; +csoundWaitBarrier(*v)i; +csoundWaitThreadLock(*vJ)i; +csoundWaitThreadLockNoTimeout(*v)v; +") +parseStructInfos(" +CSOUND_{}; +RTCLOCK_S{ll}starttime_real starttime_CPU ; +csCfgVariableBoolean_s{*<csCfgVariable_u>*C*iii*C*C}nxt name p type flags shortDesc longDesc ; +csCfgVariableDouble_s{*<csCfgVariable_u>*C*dii*C*Cdd}nxt name p type flags shortDesc longDesc min max ; +csCfgVariableFloat_s{*<csCfgVariable_u>*C*fii*C*Cff}nxt name p type flags shortDesc longDesc min max ; +csCfgVariableHead_s{*<csCfgVariable_u>*C*vii*C*C}nxt name p type flags shortDesc longDesc ; +csCfgVariableInt_s{*<csCfgVariable_u>*C*iii*C*Cii}nxt name p type flags shortDesc longDesc min max ; +csCfgVariableMYFLT_s{*<csCfgVariable_u>*C*fii*C*Cff}nxt name p type flags shortDesc longDesc min max ; +csCfgVariableString_s{*<csCfgVariable_u>*C*cii*C*Ci}nxt name p type flags shortDesc longDesc maxlen ; +csRtAudioParams{*ciiiiif}devName devNum bufSamp_SW bufSamp_HW nChannels sampleFormat sampleRate ; +opcodeListEntry{*c*c*c}opname outypes intypes ; +pvsdat_ext{iiiiiiiI*f}N sliding NB overlap winsize wintype format framecount frame ; +") +parseUnionInfos(" +csCfgVariable_u|<csCfgVariableHead_s><csCfgVariableInt_s><csCfgVariableBoolean_s><csCfgVariableFloat_s><csCfgVariableDouble_s><csCfgVariableMYFLT_s><csCfgVariableString_s>}h i b f d m s ; +") +CSFTYPE_AIFC=13; +CSFTYPE_AIFF=12; +CSFTYPE_ATS=41; +CSFTYPE_AU=15; +CSFTYPE_AVR=21; +CSFTYPE_CAF=20; +CSFTYPE_CVANAL=39; +CSFTYPE_EXTRACT_PARMS=9; +CSFTYPE_FLAC=19; +CSFTYPE_FLOATS_BINARY=52; +CSFTYPE_FLOATS_TEXT=51; +CSFTYPE_FTABLES_BINARY=49; +CSFTYPE_FTABLES_TEXT=48; +CSFTYPE_HETRO=36; +CSFTYPE_HRTF=44; +CSFTYPE_HTK=22; +CSFTYPE_IMAGE_PNG=59; +CSFTYPE_INTEGER_BINARY=54; +CSFTYPE_INTEGER_TEXT=53; +CSFTYPE_IRCAM=11; +CSFTYPE_LADSPA_PLUGIN=46; +CSFTYPE_LORIS=42; +CSFTYPE_LPC=40; +CSFTYPE_MAT4=23; +CSFTYPE_MAT5=24; +CSFTYPE_MIDI_SYSEX=35; +CSFTYPE_NIST=25; +CSFTYPE_OPTIONS=8; +CSFTYPE_ORCHESTRA=2; +CSFTYPE_ORC_INCLUDE=4; +CSFTYPE_OTHER_BINARY=58; +CSFTYPE_OTHER_TEXT=57; +CSFTYPE_PAF=26; +CSFTYPE_POSTSCRIPT=55; +CSFTYPE_PVC=37; +CSFTYPE_PVCEX=38; +CSFTYPE_PVF=27; +CSFTYPE_RAW_AUDIO=10; +CSFTYPE_SCORE=3; +CSFTYPE_SCORE_OUT=6; +CSFTYPE_SCOT=7; +CSFTYPE_SCO_INCLUDE=5; +CSFTYPE_SCRIPT_TEXT=56; +CSFTYPE_SD2=16; +CSFTYPE_SDIF=43; +CSFTYPE_SDS=28; +CSFTYPE_SNAPSHOT=47; +CSFTYPE_SOUNDFONT=33; +CSFTYPE_STD_MIDI=34; +CSFTYPE_SVX=29; +CSFTYPE_UNIFIED_CSD=1; +CSFTYPE_UNKNOWN=0; +CSFTYPE_UNKNOWN_AUDIO=32; +CSFTYPE_VOC=30; +CSFTYPE_VST_PLUGIN=45; +CSFTYPE_W64=17; +CSFTYPE_WAVE=14; +CSFTYPE_WAVEX=18; +CSFTYPE_XI=31; +CSFTYPE_XSCANU_MATRIX=50; +CSLANGUAGE_AFRIKAANS=1; +CSLANGUAGE_ALBANIAN=2; +CSLANGUAGE_ARABIC=3; +CSLANGUAGE_ARMENIAN=4; +CSLANGUAGE_ASSAMESE=5; +CSLANGUAGE_AZERI=6; +CSLANGUAGE_BASQUE=7; +CSLANGUAGE_BELARUSIAN=8; +CSLANGUAGE_BENGALI=9; +CSLANGUAGE_BULGARIAN=10; +CSLANGUAGE_CATALAN=11; +CSLANGUAGE_CHINESE=12; +CSLANGUAGE_COLUMBIAN=72; +CSLANGUAGE_CROATIAN=13; +CSLANGUAGE_CZECH=14; +CSLANGUAGE_DANISH=15; +CSLANGUAGE_DEFAULT=0; +CSLANGUAGE_DUTCH=16; +CSLANGUAGE_ENGLISH_UK=17; +CSLANGUAGE_ENGLISH_US=18; +CSLANGUAGE_ESTONIAN=19; +CSLANGUAGE_FAEROESE=20; +CSLANGUAGE_FARSI=21; +CSLANGUAGE_FINNISH=22; +CSLANGUAGE_FRENCH=23; +CSLANGUAGE_GEORGIAN=24; +CSLANGUAGE_GERMAN=25; +CSLANGUAGE_GREEK=26; +CSLANGUAGE_GUJARATI=27; +CSLANGUAGE_HEBREW=28; +CSLANGUAGE_HINDI=29; +CSLANGUAGE_HUNGARIAN=30; +CSLANGUAGE_ICELANDIC=31; +CSLANGUAGE_INDONESIAN=32; +CSLANGUAGE_ITALIAN=33; +CSLANGUAGE_JAPANESE=34; +CSLANGUAGE_KANNADA=35; +CSLANGUAGE_KASHMIRI=36; +CSLANGUAGE_KAZAK=37; +CSLANGUAGE_KONKANI=38; +CSLANGUAGE_KOREAN=39; +CSLANGUAGE_LATVIAN=40; +CSLANGUAGE_LITHUANIAN=41; +CSLANGUAGE_MACEDONIAN=42; +CSLANGUAGE_MALAY=43; +CSLANGUAGE_MALAYALAM=44; +CSLANGUAGE_MANIPURI=45; +CSLANGUAGE_MARATHI=46; +CSLANGUAGE_NEPALI=47; +CSLANGUAGE_NORWEGIAN=48; +CSLANGUAGE_ORIYA=49; +CSLANGUAGE_POLISH=50; +CSLANGUAGE_PORTUGUESE=51; +CSLANGUAGE_PUNJABI=52; +CSLANGUAGE_ROMANIAN=53; +CSLANGUAGE_RUSSIAN=54; +CSLANGUAGE_SANSKRIT=55; +CSLANGUAGE_SERBIAN=56; +CSLANGUAGE_SINDHI=57; +CSLANGUAGE_SLOVAK=58; +CSLANGUAGE_SLOVENIAN=59; +CSLANGUAGE_SPANISH=60; +CSLANGUAGE_SWAHILI=61; +CSLANGUAGE_SWEDISH=62; +CSLANGUAGE_TAMIL=63; +CSLANGUAGE_TATAR=64; +CSLANGUAGE_TELUGU=65; +CSLANGUAGE_THAI=66; +CSLANGUAGE_TURKISH=67; +CSLANGUAGE_UKRAINIAN=68; +CSLANGUAGE_URDU=69; +CSLANGUAGE_UZBEK=70; +CSLANGUAGE_VIETNAMESE=71; +CSOUND_ERROR=-1; +CSOUND_INITIALIZATION=-2; +CSOUND_MEMORY=-4; +CSOUND_PERFORMANCE=-3; +CSOUND_SIGNAL=-5; +CSOUND_SUCCESS=0; +CSOUNDCFG_BOOLEAN=2 +CSOUNDCFG_DOUBLE=4 +CSOUNDCFG_FLOAT=3 +CSOUNDCFG_INTEGER=1 +CSOUNDCFG_INVALID_BOOLEAN=-8 +CSOUNDCFG_INVALID_FLAG=-3 +CSOUNDCFG_INVALID_NAME=-1 +CSOUNDCFG_INVALID_TYPE=-2 +CSOUNDCFG_LASTERROR=-10 +CSOUNDCFG_MEMORY=-9 +CSOUNDCFG_MYFLT=5 +CSOUNDCFG_NOT_POWOFTWO=-7 +CSOUNDCFG_NULL_POINTER=-4 +CSOUNDCFG_POWOFTWO=0x00000001 +CSOUNDCFG_STRING=6 +CSOUNDCFG_STRING_LENGTH=-10 +CSOUNDCFG_SUCCESS=0 +CSOUNDCFG_TOO_HIGH=-5 +CSOUNDCFG_TOO_LOW=-6 +CSOUNDINIT_NO_ATEXIT=2 +CSOUNDINIT_NO_SIGNAL_HANDLER=1 +CSOUNDMSG_BG_BLACK=(0x0200) +CSOUNDMSG_BG_BLUE=(0x0240) +CSOUNDMSG_BG_COLOR_MASK=(0x0270) +CSOUNDMSG_BG_CYAN=(0x0260) +CSOUNDMSG_BG_GREEN=(0x0220) +CSOUNDMSG_BG_GREY=(0x0270) +CSOUNDMSG_BG_MAGENTA=(0x0250) +CSOUNDMSG_BG_ORANGE=(0x0230) +CSOUNDMSG_BG_RED=(0x0210) +CSOUNDMSG_DEFAULT=(0x0000) +CSOUNDMSG_ERROR=(0x1000) +CSOUNDMSG_FG_ATTR_MASK=(0x0088) +CSOUNDMSG_FG_BLACK=(0x0100) +CSOUNDMSG_FG_BLUE=(0x0104) +CSOUNDMSG_FG_BOLD=(0x0008) +CSOUNDMSG_FG_COLOR_MASK=(0x0107) +CSOUNDMSG_FG_CYAN=(0x0106) +CSOUNDMSG_FG_GREEN=(0x0102) +CSOUNDMSG_FG_MAGENTA=(0x0105) +CSOUNDMSG_FG_RED=(0x0101) +CSOUNDMSG_FG_UNDERLINE=(0x0080) +CSOUNDMSG_FG_WHITE=(0x0107) +CSOUNDMSG_FG_YELLOW=(0x0103) +CSOUNDMSG_ORCH=(0x2000) +CSOUNDMSG_REALTIME=(0x3000) +CSOUNDMSG_TYPE_MASK=(0x7000) +CSOUNDMSG_WARNING=(0x4000) +CSOUND_AUDIO_CHANNEL=2 +#CSOUND_CALLBACK_KBD_EVENT=(0x00000001U) +#CSOUND_CALLBACK_KBD_TEXT=(0x00000002U) +CSOUND_CALLBACK_KBD_EVENT=(0x00000001) +CSOUND_CALLBACK_KBD_TEXT=(0x00000002) +CSOUND_CFGVAR_H= +CSOUND_CHANNEL_TYPE_MASK=15 +CSOUND_CONTROL_CHANNEL=1 +CSOUND_CONTROL_CHANNEL_EXP=3 +CSOUND_CONTROL_CHANNEL_INT=1 +CSOUND_CONTROL_CHANNEL_LIN=2 +CSOUND_EXITJMP_SUCCESS=(256) +#CSOUND_H= +CSOUND_INPUT_CHANNEL=16 +#CSOUND_MSG_ATTR_H= +CSOUND_OUTPUT_CHANNEL=32 +#CSOUND_SPIN_LOCK= +#CSOUND_SPIN_UNLOCK= +CSOUND_STRING_CHANNEL=3 +#CSOUND_SYSDEP_H= +#CSOUND_TEXT_H= +#CSOUND_VERSION_H= +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/cuda.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,175 @@ +dynbind("cuda", " +cuArray3DCreate(**<CUarray_st>*<CUDA_ARRAY3D_DESCRIPTOR>)i; +cuArray3DGetDescriptor(*<CUDA_ARRAY3D_DESCRIPTOR>*<CUarray_st>)i; +cuArrayCreate(**<CUarray_st>*<CUDA_ARRAY_DESCRIPTOR>)i; +cuArrayDestroy(*<CUarray_st>)i; +cuArrayGetDescriptor(*<CUDA_ARRAY_DESCRIPTOR>*<CUarray_st>)i; +cuCtxAttach(**<CUctx_st>I)i; +cuCtxCreate(**<CUctx_st>Ii)i; +cuCtxDestroy(*<CUctx_st>)i; +cuCtxDetach(*<CUctx_st>)i; +cuCtxGetDevice(*i)i; +cuCtxPopCurrent(**<CUctx_st>)i; +cuCtxPushCurrent(*<CUctx_st>)i; +cuCtxSynchronize()i; +cuDeviceComputeCapability(*i*ii)i; +cuDeviceGet(*ii)i; +cuDeviceGetAttribute(*iii)i; +cuDeviceGetCount(*i)i; +cuDeviceGetName(*cii)i; +cuDeviceGetProperties(*<CUdevprop_st>i)i; +cuDeviceTotalMem(*Ii)i; +cuEventCreate(**<CUevent_st>I)i; +cuEventDestroy(*<CUevent_st>)i; +cuEventElapsedTime(*f*<CUevent_st>*<CUevent_st>)i; +cuEventQuery(*<CUevent_st>)i; +cuEventRecord(*<CUevent_st>*<CUstream_st>)i; +cuEventSynchronize(*<CUevent_st>)i; +cuFuncSetBlockShape(*<CUfunc_st>iii)i; +cuFuncSetSharedSize(*<CUfunc_st>I)i; +cuInit(I)i; +cuLaunch(*<CUfunc_st>)i; +cuLaunchGrid(*<CUfunc_st>ii)i; +cuLaunchGridAsync(*<CUfunc_st>ii*<CUstream_st>)i; +cuMemAlloc(*II)i; +cuMemAllocHost(**vI)i; +cuMemAllocPitch(*I*IIII)i; +cuMemFree(I)i; +cuMemFreeHost(*v)i; +cuMemGetAddressRange(*I*II)i; +cuMemGetInfo(*I*I)i; +cuMemcpy2D(*<CUDA_MEMCPY2D_st>)i; +cuMemcpy2DAsync(*<CUDA_MEMCPY2D_st>*<CUstream_st>)i; +cuMemcpy2DUnaligned(*<CUDA_MEMCPY2D_st>)i; +cuMemcpy3D(*<CUDA_MEMCPY3D_st>)i; +cuMemcpy3DAsync(*<CUDA_MEMCPY3D_st>*<CUstream_st>)i; +cuMemcpyAtoA(*<CUarray_st>I*<CUarray_st>II)i; +cuMemcpyAtoD(I*<CUarray_st>II)i; +cuMemcpyAtoH(*v*<CUarray_st>II)i; +cuMemcpyAtoHAsync(*v*<CUarray_st>II*<CUstream_st>)i; +cuMemcpyDtoA(*<CUarray_st>III)i; +cuMemcpyDtoD(III)i; +cuMemcpyDtoH(*vII)i; +cuMemcpyDtoHAsync(*vII*<CUstream_st>)i; +cuMemcpyHtoA(*<CUarray_st>I*vI)i; +cuMemcpyHtoAAsync(*<CUarray_st>I*vI*<CUstream_st>)i; +cuMemcpyHtoD(I*vI)i; +cuMemcpyHtoDAsync(I*vI*<CUstream_st>)i; +cuMemsetD16(ISI)i; +cuMemsetD2D16(IISII)i; +cuMemsetD2D32(IIIII)i; +cuMemsetD2D8(IICII)i; +cuMemsetD32(III)i; +cuMemsetD8(ICI)i; +cuModuleGetFunction(**<CUfunc_st>*<CUmod_st>*c)i; +cuModuleGetGlobal(*I*I*<CUmod_st>*c)i; +cuModuleGetTexRef(**<CUtexref_st>*<CUmod_st>*c)i; +cuModuleLoad(**<CUmod_st>*c)i; +cuModuleLoadData(**<CUmod_st>*v)i; +cuModuleLoadFatBinary(**<CUmod_st>*v)i; +cuModuleUnload(*<CUmod_st>)i; +cuParamSetSize(*<CUfunc_st>I)i; +cuParamSetTexRef(*<CUfunc_st>i*<CUtexref_st>)i; +cuParamSetf(*<CUfunc_st>if)i; +cuParamSeti(*<CUfunc_st>iI)i; +cuParamSetv(*<CUfunc_st>i*vI)i; +cuStreamCreate(**<CUstream_st>I)i; +cuStreamDestroy(*<CUstream_st>)i; +cuStreamQuery(*<CUstream_st>)i; +cuStreamSynchronize(*<CUstream_st>)i; +cuTexRefCreate(**<CUtexref_st>)i; +cuTexRefDestroy(*<CUtexref_st>)i; +cuTexRefGetAddress(*I*<CUtexref_st>)i; +cuTexRefGetAddressMode(*p*<CUtexref_st>i)i; +cuTexRefGetArray(**<CUarray_st>*<CUtexref_st>)i; +cuTexRefGetFilterMode(*p*<CUtexref_st>)i; +cuTexRefGetFlags(*I*<CUtexref_st>)i; +cuTexRefGetFormat(*p*i*<CUtexref_st>)i; +cuTexRefSetAddress(*I*<CUtexref_st>II)i; +cuTexRefSetAddressMode(*<CUtexref_st>ii)i; +cuTexRefSetArray(*<CUtexref_st>*<CUarray_st>I)i; +cuTexRefSetFilterMode(*<CUtexref_st>i)i; +cuTexRefSetFlags(*<CUtexref_st>I)i; +cuTexRefSetFormat(*<CUtexref_st>ii)i; +") + +# CUdevprop_st{i[2]i[2]iiiiiiii}maxThreadsPerBlock maxThreadsDim maxGridSize sharedMemPerBlock totalConstantMemory SIMDWidth memPitch regsPerBlock clockRate textureAlign ; +parseStructInfos(" +CUDA_MEMCPY2D_st{IIi*vI*<CUarray_st>IIIi*vI*<CUarray_st>III}srcXInBytes srcY srcMemoryType srcHost srcDevice srcArray srcPitch dstXInBytes dstY dstMemoryType dstHost dstDevice dstArray dstPitch WidthInBytes Height ; +CUDA_MEMCPY3D_st{IIIIi*vI*<CUarray_st>*vIIIIIIi*vI*<CUarray_st>*vIIIII}srcXInBytes srcY srcZ srcLOD srcMemoryType srcHost srcDevice srcArray reserved0 srcPitch srcHeight dstXInBytes dstY dstZ dstLOD dstMemoryType dstHost dstDevice dstArray reserved1 dstPitch dstHeight WidthInBytes Height Depth ; +CUarray_st{}; +CUfunc_st{}; +CUevent_st{}; +CUDA_ARRAY_DESCRIPTOR{IIiI}Width Height Format NumChannels ; +CUDA_ARRAY3D_DESCRIPTOR{IIIiII}Width Height Depth Format NumChannels Flags ; +CUtexref_st{}; +CUctx_st{}; +CUstream_st{}; +CUmod_st{}; +") +CUDA_ERROR_ALREADY_ACQUIRED=210; +CUDA_ERROR_ALREADY_MAPPED=208; +CUDA_ERROR_ARRAY_IS_MAPPED=207; +CUDA_ERROR_CONTEXT_ALREADY_CURRENT=202; +CUDA_ERROR_DEINITIALIZED=4; +CUDA_ERROR_FILE_NOT_FOUND=301; +CUDA_ERROR_INVALID_CONTEXT=201; +CUDA_ERROR_INVALID_DEVICE=101; +CUDA_ERROR_INVALID_HANDLE=400; +CUDA_ERROR_INVALID_IMAGE=200; +CUDA_ERROR_INVALID_SOURCE=300; +CUDA_ERROR_INVALID_VALUE=1; +CUDA_ERROR_LAUNCH_FAILED=700; +CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING=703; +CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES=701; +CUDA_ERROR_LAUNCH_TIMEOUT=702; +CUDA_ERROR_MAP_FAILED=205; +CUDA_ERROR_NOT_FOUND=500; +CUDA_ERROR_NOT_INITIALIZED=3; +CUDA_ERROR_NOT_MAPPED=211; +CUDA_ERROR_NOT_READY=600; +CUDA_ERROR_NO_BINARY_FOR_GPU=209; +CUDA_ERROR_NO_DEVICE=100; +CUDA_ERROR_OUT_OF_MEMORY=2; +CUDA_ERROR_UNKNOWN=999; +CUDA_ERROR_UNMAP_FAILED=206; +CUDA_SUCCESS=0; +CU_AD_FORMAT_FLOAT=32; +CU_AD_FORMAT_HALF=16; +CU_AD_FORMAT_SIGNED_INT16=9; +CU_AD_FORMAT_SIGNED_INT32=10; +CU_AD_FORMAT_SIGNED_INT8=8; +CU_AD_FORMAT_UNSIGNED_INT16=2; +CU_AD_FORMAT_UNSIGNED_INT32=3; +CU_AD_FORMAT_UNSIGNED_INT8=1; +CU_CTX_FLAGS_MASK=3; +CU_CTX_SCHED_AUTO=0; +CU_CTX_SCHED_MASK=3; +CU_CTX_SCHED_SPIN=1; +CU_CTX_SCHED_YIELD=2; +CU_DEVICE_ATTRIBUTE_CLOCK_RATE=13; +CU_DEVICE_ATTRIBUTE_GPU_OVERLAP=15; +CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X=2; +CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y=3; +CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z=4; +CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X=5; +CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y=6; +CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z=7; +CU_DEVICE_ATTRIBUTE_MAX_PITCH=11; +CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK=12; +CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK=8; +CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK=1; +CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT=16; +CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK=12; +CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK=8; +CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT=14; +CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY=9; +CU_DEVICE_ATTRIBUTE_WARP_SIZE=10; +CU_MEMORYTYPE_ARRAY=3; +CU_MEMORYTYPE_DEVICE=2; +CU_MEMORYTYPE_HOST=1; +CU_TR_ADDRESS_MODE_CLAMP=1; +CU_TR_ADDRESS_MODE_MIRROR=2; +CU_TR_ADDRESS_MODE_WRAP=0; +CU_TR_FILTER_MODE_LINEAR=1; +CU_TR_FILTER_MODE_POINT=0;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/expat.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,138 @@ +dynbind( c("expat","expat.so.1"), " +XML_DefaultCurrent(*<XML_ParserStruct>)v; +XML_ErrorString(i)*c; +XML_ExpatVersion()*c; +XML_ExpatVersionInfo(); +XML_ExternalEntityParserCreate(*<XML_ParserStruct>*c*c)*<XML_ParserStruct>; +XML_FreeContentModel(*<XML_ParserStruct>*<XML_cp>)v; +XML_GetBase(*<XML_ParserStruct>)*c; +XML_GetBuffer(*<XML_ParserStruct>i)*v; +XML_GetCurrentByteCount(*<XML_ParserStruct>)i; +XML_GetCurrentByteIndex(*<XML_ParserStruct>)j; +XML_GetCurrentColumnNumber(*<XML_ParserStruct>)J; +XML_GetCurrentLineNumber(*<XML_ParserStruct>)J; +XML_GetErrorCode(*<XML_ParserStruct>)i; +XML_GetFeatureList()*<XML_Feature>; +XML_GetIdAttributeIndex(*<XML_ParserStruct>)i; +XML_GetInputContext(*<XML_ParserStruct>*i*i)*c; +XML_GetParsingStatus(*<XML_ParserStruct>*<XML_ParsingStatus>)v; +XML_GetSpecifiedAttributeCount(*<XML_ParserStruct>)i; +XML_MemFree(*<XML_ParserStruct>*v)v; +XML_MemMalloc(*<XML_ParserStruct>J)*v; +XML_MemRealloc(*<XML_ParserStruct>*vJ)*v; +XML_Parse(*<XML_ParserStruct>*cii)i; +XML_ParseBuffer(*<XML_ParserStruct>ii)i; +XML_ParserCreate(*c)*<XML_ParserStruct>; +XML_ParserCreateNS(*cc)*<XML_ParserStruct>; +XML_ParserCreate_MM(*c*<XML_Memory_Handling_Suite>*c)*<XML_ParserStruct>; +XML_ParserFree(*<XML_ParserStruct>)v; +XML_ParserReset(*<XML_ParserStruct>*c)C; +XML_ResumeParser(*<XML_ParserStruct>)i; +XML_SetAttlistDeclHandler(*<XML_ParserStruct>*p)v; +XML_SetBase(*<XML_ParserStruct>*c)i; +XML_SetCdataSectionHandler(*<XML_ParserStruct>*p*p)v; +XML_SetCharacterDataHandler(*<XML_ParserStruct>*p)v; +XML_SetCommentHandler(*<XML_ParserStruct>*p)v; +XML_SetDefaultHandler(*<XML_ParserStruct>*p)v; +XML_SetDefaultHandlerExpand(*<XML_ParserStruct>*p)v; +XML_SetDoctypeDeclHandler(*<XML_ParserStruct>*p*p)v; +XML_SetElementDeclHandler(*<XML_ParserStruct>*p)v; +XML_SetElementHandler(*<XML_ParserStruct>*p*p)v; +XML_SetEncoding(*<XML_ParserStruct>*c)i; +XML_SetEndCdataSectionHandler(*<XML_ParserStruct>*p)v; +XML_SetEndDoctypeDeclHandler(*<XML_ParserStruct>*p)v; +XML_SetEndElementHandler(*<XML_ParserStruct>*p)v; +XML_SetEndNamespaceDeclHandler(*<XML_ParserStruct>*p)v; +XML_SetEntityDeclHandler(*<XML_ParserStruct>*p)v; +XML_SetExternalEntityRefHandler(*<XML_ParserStruct>*p)v; +XML_SetExternalEntityRefHandlerArg(*<XML_ParserStruct>*v)v; +XML_SetNamespaceDeclHandler(*<XML_ParserStruct>*p*p)v; +XML_SetNotStandaloneHandler(*<XML_ParserStruct>*p)v; +XML_SetNotationDeclHandler(*<XML_ParserStruct>*p)v; +XML_SetParamEntityParsing(*<XML_ParserStruct>i)i; +XML_SetProcessingInstructionHandler(*<XML_ParserStruct>*p)v; +XML_SetReturnNSTriplet(*<XML_ParserStruct>i)v; +XML_SetSkippedEntityHandler(*<XML_ParserStruct>*p)v; +XML_SetStartCdataSectionHandler(*<XML_ParserStruct>*p)v; +XML_SetStartDoctypeDeclHandler(*<XML_ParserStruct>*p)v; +XML_SetStartElementHandler(*<XML_ParserStruct>*p)v; +XML_SetStartNamespaceDeclHandler(*<XML_ParserStruct>*p)v; +XML_SetUnknownEncodingHandler(*<XML_ParserStruct>*p*v)v; +XML_SetUnparsedEntityDeclHandler(*<XML_ParserStruct>*p)v; +XML_SetUserData(*<XML_ParserStruct>*v)v; +XML_SetXmlDeclHandler(*<XML_ParserStruct>*p)v; +XML_StopParser(*<XML_ParserStruct>C)i; +XML_UseForeignDTD(*<XML_ParserStruct>C)i; +XML_UseParserAsHandlerArg(*<XML_ParserStruct>)v; +") +XML_FEATURE_END=0; +XML_FEATURE_UNICODE=1; +XML_FEATURE_UNICODE_WCHAR_T=2; +XML_FEATURE_DTD=3; +XML_FEATURE_CONTEXT_BYTES=4; +XML_FEATURE_MIN_SIZE=5; +XML_FEATURE_SIZEOF_XML_CHAR=6; +XML_FEATURE_SIZEOF_XML_LCHAR=7; +XML_FEATURE_NS=8; +XML_PARAM_ENTITY_PARSING_NEVER=0; +XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE=1; +XML_PARAM_ENTITY_PARSING_ALWAYS=2; +XML_INITIALIZED=0; +XML_PARSING=1; +XML_FINISHED=2; +XML_SUSPENDED=3; +XML_CQUANT_NONE=0; +XML_CQUANT_OPT=1; +XML_CQUANT_REP=2; +XML_CQUANT_PLUS=3; +XML_CTYPE_EMPTY=1; +XML_CTYPE_ANY=2; +XML_CTYPE_MIXED=3; +XML_CTYPE_NAME=4; +XML_CTYPE_CHOICE=5; +XML_CTYPE_SEQ=6; +XML_ERROR_NONE=0; +XML_ERROR_NO_MEMORY=1; +XML_ERROR_SYNTAX=2; +XML_ERROR_NO_ELEMENTS=3; +XML_ERROR_INVALID_TOKEN=4; +XML_ERROR_UNCLOSED_TOKEN=5; +XML_ERROR_PARTIAL_CHAR=6; +XML_ERROR_TAG_MISMATCH=7; +XML_ERROR_DUPLICATE_ATTRIBUTE=8; +XML_ERROR_JUNK_AFTER_DOC_ELEMENT=9; +XML_ERROR_PARAM_ENTITY_REF=10; +XML_ERROR_UNDEFINED_ENTITY=11; +XML_ERROR_RECURSIVE_ENTITY_REF=12; +XML_ERROR_ASYNC_ENTITY=13; +XML_ERROR_BAD_CHAR_REF=14; +XML_ERROR_BINARY_ENTITY_REF=15; +XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF=16; +XML_ERROR_MISPLACED_XML_PI=17; +XML_ERROR_UNKNOWN_ENCODING=18; +XML_ERROR_INCORRECT_ENCODING=19; +XML_ERROR_UNCLOSED_CDATA_SECTION=20; +XML_ERROR_EXTERNAL_ENTITY_HANDLING=21; +XML_ERROR_NOT_STANDALONE=22; +XML_ERROR_UNEXPECTED_STATE=23; +XML_ERROR_ENTITY_DECLARED_IN_PE=24; +XML_ERROR_FEATURE_REQUIRES_XML_DTD=25; +XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING=26; +XML_ERROR_UNBOUND_PREFIX=27; +XML_ERROR_UNDECLARING_PREFIX=28; +XML_ERROR_INCOMPLETE_PE=29; +XML_ERROR_XML_DECL=30; +XML_ERROR_TEXT_DECL=31; +XML_ERROR_PUBLICID=32; +XML_ERROR_SUSPENDED=33; +XML_ERROR_NOT_SUSPENDED=34; +XML_ERROR_ABORTED=35; +XML_ERROR_FINISHED=36; +XML_ERROR_SUSPEND_PE=37; +XML_ERROR_RESERVED_PREFIX_XML=38; +XML_ERROR_RESERVED_PREFIX_XMLNS=39; +XML_ERROR_RESERVED_NAMESPACE_URI=40; +XML_STATUS_ERROR=0; +XML_STATUS_OK=1; +XML_STATUS_SUSPENDED=2; +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/gl3.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,1167 @@ +dynbind(c("OPENGL32","OpenGL","GL","GL.so.1"),callmode="stdcall"," +glActiveTexture(I)v; +glAttachShader(II)v; +glBeginConditionalRender(II)v; +glBeginQuery(II)v; +glBeginTransformFeedback(I)v; +glBindAttribLocation(II*c)v; +glBindBuffer(II)v; +glBindBufferBase(III)v; +glBindBufferRange(IIIjj)v; +glBindFragDataLocation(II*c)v; +glBindFramebuffer(II)v; +glBindRenderbuffer(II)v; +glBindTexture(II)v; +glBindVertexArray(I)v; +glBlendColor(ffff)v; +glBlendEquation(I)v; +glBlendEquationSeparate(II)v; +glBlendEquationSeparatei(III)v; +glBlendEquationi(II)v; +glBlendFunc(II)v; +glBlendFuncSeparate(IIII)v; +glBlendFuncSeparatei(IIIII)v; +glBlendFunci(III)v; +glBlitFramebuffer(iiiiiiiiII)v; +glBufferData(Ij*vI)v; +glBufferSubData(Ijj*v)v; +glCheckFramebufferStatus(I)I; +glClampColor(II)v; +glClear(I)v; +glClearBufferfi(Iifi)v; +glClearBufferfv(Ii*f)v; +glClearBufferiv(Ii*i)v; +glClearBufferuiv(Ii*I)v; +glClearColor(ffff)v; +glClearDepth(d)v; +glClearStencil(i)v; +glClientWaitSync(*<__GLsync>IJ)I; +glColorMask(CCCC)v; +glColorMaski(ICCCC)v; +glCompileShader(I)v; +glCompressedTexImage1D(IiIiii*v)v; +glCompressedTexImage2D(IiIiiii*v)v; +glCompressedTexImage3D(IiIiiiii*v)v; +glCompressedTexSubImage1D(IiiiIi*v)v; +glCompressedTexSubImage2D(IiiiiiIi*v)v; +glCompressedTexSubImage3D(IiiiiiiiIi*v)v; +glCopyBufferSubData(IIjjj)v; +glCopyTexImage1D(IiIiiii)v; +glCopyTexImage2D(IiIiiiii)v; +glCopyTexSubImage1D(Iiiiii)v; +glCopyTexSubImage2D(Iiiiiiii)v; +glCopyTexSubImage3D(Iiiiiiiii)v; +glCreateProgram()I; +glCreateShader(I)I; +glCullFace(I)v; +glDeleteBuffers(i*I)v; +glDeleteFramebuffers(i*I)v; +glDeleteProgram(I)v; +glDeleteQueries(i*I)v; +glDeleteRenderbuffers(i*I)v; +glDeleteShader(I)v; +glDeleteSync(*<__GLsync>)v; +glDeleteTextures(i*I)v; +glDeleteVertexArrays(i*I)v; +glDepthFunc(I)v; +glDepthMask(C)v; +glDepthRange(dd)v; +glDetachShader(II)v; +glDisable(I)v; +glDisableVertexAttribArray(I)v; +glDisablei(II)v; +glDrawArrays(Iii)v; +glDrawArraysInstanced(Iiii)v; +glDrawBuffer(I)v; +glDrawBuffers(i*I)v; +glDrawElements(IiI*v)v; +glDrawElementsBaseVertex(IiI*vi)v; +glDrawElementsInstanced(IiI*vi)v; +glDrawElementsInstancedBaseVertex(IiI*vii)v; +glDrawRangeElements(IIIiI*v)v; +glDrawRangeElementsBaseVertex(IIIiI*vi)v; +glEnable(I)v; +glEnableVertexAttribArray(I)v; +glEnablei(II)v; +glEndConditionalRender()v; +glEndQuery(I)v; +glEndTransformFeedback()v; +glFenceSync(II)*<__GLsync>; +glFinish()v; +glFlush()v; +glFlushMappedBufferRange(Ijj)v; +glFramebufferRenderbuffer(IIII)v; +glFramebufferTexture(IIIi)v; +glFramebufferTexture1D(IIIIi)v; +glFramebufferTexture2D(IIIIi)v; +glFramebufferTexture3D(IIIIii)v; +glFramebufferTextureFace(IIIiI)v; +glFramebufferTextureLayer(IIIii)v; +glFrontFace(I)v; +glGenBuffers(i*I)v; +glGenFramebuffers(i*I)v; +glGenQueries(i*I)v; +glGenRenderbuffers(i*I)v; +glGenTextures(i*I)v; +glGenVertexArrays(i*I)v; +glGenerateMipmap(I)v; +glGetActiveAttrib(IIi*i*i*I*c)v; +glGetActiveUniform(IIi*i*i*I*c)v; +glGetActiveUniformBlockName(IIi*i*c)v; +glGetActiveUniformBlockiv(III*i)v; +glGetActiveUniformName(IIi*i*c)v; +glGetActiveUniformsiv(Ii*II*i)v; +glGetAttachedShaders(Ii*i*I)v; +glGetAttribLocation(I*c)i; +glGetBooleani_v(II*C)v; +glGetBooleanv(I*C)v; +glGetBufferParameteri64v(II*j)v; +glGetBufferParameteriv(II*i)v; +glGetBufferPointerv(II**v)v; +glGetBufferSubData(Ijj*v)v; +glGetCompressedTexImage(Ii*v)v; +glGetDoublev(I*d)v; +glGetError()I; +glGetFloatv(I*f)v; +glGetFragDataLocation(I*c)i; +glGetFramebufferAttachmentParameteriv(III*i)v; +glGetInteger64i_v(II*j)v; +glGetInteger64v(I*j)v; +glGetIntegeri_v(II*i)v; +glGetIntegerv(I*i)v; +glGetMultisamplefv(II*f)v; +glGetPointerv(I**v)v; +glGetProgramInfoLog(Ii*i*c)v; +glGetProgramiv(II*i)v; +glGetQueryObjectiv(II*i)v; +glGetQueryObjectuiv(II*I)v; +glGetQueryiv(II*i)v; +glGetRenderbufferParameteriv(II*i)v; +glGetShaderInfoLog(Ii*i*c)v; +glGetShaderSource(Ii*i*c)v; +glGetShaderiv(II*i)v; +glGetString(I)*C; +glGetStringi(II)*C; +glGetSynciv(*<__GLsync>Ii*i*i)v; +glGetTexImage(IiII*v)v; +glGetTexLevelParameterfv(IiI*f)v; +glGetTexLevelParameteriv(IiI*i)v; +glGetTexParameterIiv(II*i)v; +glGetTexParameterIuiv(II*I)v; +glGetTexParameterfv(II*f)v; +glGetTexParameteriv(II*i)v; +glGetTransformFeedbackVarying(IIi*i*i*I*c)v; +glGetUniformBlockIndex(I*c)I; +glGetUniformIndices(Ii**c*I)v; +glGetUniformLocation(I*c)i; +glGetUniformfv(Ii*f)v; +glGetUniformiv(Ii*i)v; +glGetUniformuiv(Ii*I)v; +glGetVertexAttribIiv(II*i)v; +glGetVertexAttribIuiv(II*I)v; +glGetVertexAttribPointerv(II**v)v; +glGetVertexAttribdv(II*d)v; +glGetVertexAttribfv(II*f)v; +glGetVertexAttribiv(II*i)v; +glHint(II)v; +glIsBuffer(I)C; +glIsEnabled(I)C; +glIsEnabledi(II)C; +glIsFramebuffer(I)C; +glIsProgram(I)C; +glIsQuery(I)C; +glIsRenderbuffer(I)C; +glIsShader(I)C; +glIsSync(*<__GLsync>)C; +glIsTexture(I)C; +glIsVertexArray(I)C; +glLineWidth(f)v; +glLinkProgram(I)v; +glLogicOp(I)v; +glMapBuffer(II)*v; +glMapBufferRange(IjjI)*v; +glMinSampleShading(f)v; +glMultiDrawArrays(I*i*ii)v; +glMultiDrawElements(I*iI**vi)v; +glMultiDrawElementsBaseVertex(I*iI**vi*i)v; +glPixelStoref(If)v; +glPixelStorei(Ii)v; +glPointParameterf(If)v; +glPointParameterfv(I*f)v; +glPointParameteri(Ii)v; +glPointParameteriv(I*i)v; +glPointSize(f)v; +glPolygonMode(II)v; +glPolygonOffset(ff)v; +glPrimitiveRestartIndex(I)v; +glProgramParameteri(IIi)v; +glProvokingVertex(I)v; +glReadBuffer(I)v; +glReadPixels(iiiiII*v)v; +glRenderbufferStorage(IIii)v; +glRenderbufferStorageMultisample(IiIii)v; +glSampleCoverage(fC)v; +glSampleMaski(II)v; +glScissor(iiii)v; +glShaderSource(Ii**c*i)v; +glStencilFunc(IiI)v; +glStencilFuncSeparate(IIiI)v; +glStencilMask(I)v; +glStencilMaskSeparate(II)v; +glStencilOp(III)v; +glStencilOpSeparate(IIII)v; +glTexBuffer(III)v; +glTexImage1D(IiiiiII*v)v; +glTexImage2D(IiiiiiII*v)v; +glTexImage2DMultisample(IiiiiC)v; +glTexImage3D(IiiiiiiII*v)v; +glTexImage3DMultisample(IiiiiiC)v; +glTexParameterIiv(II*i)v; +glTexParameterIuiv(II*I)v; +glTexParameterf(IIf)v; +glTexParameterfv(II*f)v; +glTexParameteri(IIi)v; +glTexParameteriv(II*i)v; +glTexSubImage1D(IiiiII*v)v; +glTexSubImage2D(IiiiiiII*v)v; +glTexSubImage3D(IiiiiiiiII*v)v; +glTransformFeedbackVaryings(Ii**cI)v; +glUniform1f(if)v; +glUniform1fv(ii*f)v; +glUniform1i(ii)v; +glUniform1iv(ii*i)v; +glUniform1ui(iI)v; +glUniform1uiv(ii*I)v; +glUniform2f(iff)v; +glUniform2fv(ii*f)v; +glUniform2i(iii)v; +glUniform2iv(ii*i)v; +glUniform2ui(iII)v; +glUniform2uiv(ii*I)v; +glUniform3f(ifff)v; +glUniform3fv(ii*f)v; +glUniform3i(iiii)v; +glUniform3iv(ii*i)v; +glUniform3ui(iIII)v; +glUniform3uiv(ii*I)v; +glUniform4f(iffff)v; +glUniform4fv(ii*f)v; +glUniform4i(iiiii)v; +glUniform4iv(ii*i)v; +glUniform4ui(iIIII)v; +glUniform4uiv(ii*I)v; +glUniformBlockBinding(III)v; +glUniformMatrix2fv(iiC*f)v; +glUniformMatrix2x3fv(iiC*f)v; +glUniformMatrix2x4fv(iiC*f)v; +glUniformMatrix3fv(iiC*f)v; +glUniformMatrix3x2fv(iiC*f)v; +glUniformMatrix3x4fv(iiC*f)v; +glUniformMatrix4fv(iiC*f)v; +glUniformMatrix4x2fv(iiC*f)v; +glUniformMatrix4x3fv(iiC*f)v; +glUnmapBuffer(I)C; +glUseProgram(I)v; +glValidateProgram(I)v; +glVertexAttrib1d(Id)v; +glVertexAttrib1dv(I*d)v; +glVertexAttrib1f(If)v; +glVertexAttrib1fv(I*f)v; +glVertexAttrib1s(Is)v; +glVertexAttrib1sv(I*s)v; +glVertexAttrib2d(Idd)v; +glVertexAttrib2dv(I*d)v; +glVertexAttrib2f(Iff)v; +glVertexAttrib2fv(I*f)v; +glVertexAttrib2s(Iss)v; +glVertexAttrib2sv(I*s)v; +glVertexAttrib3d(Iddd)v; +glVertexAttrib3dv(I*d)v; +glVertexAttrib3f(Ifff)v; +glVertexAttrib3fv(I*f)v; +glVertexAttrib3s(Isss)v; +glVertexAttrib3sv(I*s)v; +glVertexAttrib4Nbv(I*c)v; +glVertexAttrib4Niv(I*i)v; +glVertexAttrib4Nsv(I*s)v; +glVertexAttrib4Nub(ICCCC)v; +glVertexAttrib4Nubv(I*C)v; +glVertexAttrib4Nuiv(I*I)v; +glVertexAttrib4Nusv(I*S)v; +glVertexAttrib4bv(I*c)v; +glVertexAttrib4d(Idddd)v; +glVertexAttrib4dv(I*d)v; +glVertexAttrib4f(Iffff)v; +glVertexAttrib4fv(I*f)v; +glVertexAttrib4iv(I*i)v; +glVertexAttrib4s(Issss)v; +glVertexAttrib4sv(I*s)v; +glVertexAttrib4ubv(I*C)v; +glVertexAttrib4uiv(I*I)v; +glVertexAttrib4usv(I*S)v; +glVertexAttribI1i(Ii)v; +glVertexAttribI1iv(I*i)v; +glVertexAttribI1ui(II)v; +glVertexAttribI1uiv(I*I)v; +glVertexAttribI2i(Iii)v; +glVertexAttribI2iv(I*i)v; +glVertexAttribI2ui(III)v; +glVertexAttribI2uiv(I*I)v; +glVertexAttribI3i(Iiii)v; +glVertexAttribI3iv(I*i)v; +glVertexAttribI3ui(IIII)v; +glVertexAttribI3uiv(I*I)v; +glVertexAttribI4bv(I*c)v; +glVertexAttribI4i(Iiiii)v; +glVertexAttribI4iv(I*i)v; +glVertexAttribI4sv(I*s)v; +glVertexAttribI4ubv(I*C)v; +glVertexAttribI4ui(IIIII)v; +glVertexAttribI4uiv(I*I)v; +glVertexAttribI4usv(I*S)v; +glVertexAttribIPointer(IiIi*v)v; +glVertexAttribPointer(IiICi*v)v; +glViewport(iiii)v; +glWaitSync(*<__GLsync>IJ)v; +") +GL_ACTIVE_ATTRIBUTES=0x8B89 +GL_ACTIVE_ATTRIBUTE_MAX_LENGTH=0x8B8A +GL_ACTIVE_TEXTURE=0x84E0 +GL_ACTIVE_UNIFORMS=0x8B86 +GL_ACTIVE_UNIFORM_BLOCKS=0x8A36 +GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH=0x8A35 +GL_ACTIVE_UNIFORM_MAX_LENGTH=0x8B87 +GL_ALIASED_LINE_WIDTH_RANGE=0x846E +GL_ALPHA=0x1906 +GL_ALREADY_SIGNALED=0x911A +GL_ALWAYS=0x0207 +GL_AND=0x1501 +GL_AND_INVERTED=0x1504 +GL_AND_REVERSE=0x1502 +GL_ARB_copy_buffer=1 +GL_ARB_depth_buffer_float=1 +GL_ARB_depth_clamp=1 +GL_ARB_draw_buffers_blend=1 +GL_ARB_draw_elements_base_vertex=1 +GL_ARB_fragment_coord_conventions=1 +GL_ARB_framebuffer_object=1 +GL_ARB_framebuffer_sRGB=1 +GL_ARB_half_float_vertex=1 +GL_ARB_map_buffer_range=1 +GL_ARB_provoking_vertex=1 +GL_ARB_sample_shading=1 +GL_ARB_seamless_cube_map=1 +GL_ARB_sync=1 +GL_ARB_texture_compression_rgtc=1 +GL_ARB_texture_cube_map_array=1 +GL_ARB_texture_gather=1 +GL_ARB_texture_multisample=1 +GL_ARB_texture_query_lod=1 +GL_ARB_texture_rg=1 +GL_ARB_uniform_buffer_object=1 +GL_ARB_vertex_array_bgra=1 +GL_ARB_vertex_array_object=1 +GL_ARRAY_BUFFER=0x8892 +GL_ARRAY_BUFFER_BINDING=0x8894 +GL_ATTACHED_SHADERS=0x8B85 +GL_BACK=0x0405 +GL_BACK_LEFT=0x0402 +GL_BACK_RIGHT=0x0403 +GL_BGR=0x80E0 +GL_BGRA=0x80E1 +GL_BGRA_INTEGER=0x8D9B +GL_BGR_INTEGER=0x8D9A +GL_BLEND=0x0BE2 +GL_BLEND_COLOR=0x8005 +GL_BLEND_DST=0x0BE0 +GL_BLEND_DST_ALPHA=0x80CA +GL_BLEND_DST_RGB=0x80C8 +GL_BLEND_EQUATION=0x8009 +GL_BLEND_EQUATION_ALPHA=0x883D +GL_BLEND_EQUATION_RGB=0x8009 +GL_BLEND_SRC=0x0BE1 +GL_BLEND_SRC_ALPHA=0x80CB +GL_BLEND_SRC_RGB=0x80C9 +GL_BLUE=0x1905 +GL_BLUE_INTEGER=0x8D96 +GL_BOOL=0x8B56 +GL_BOOL_VEC2=0x8B57 +GL_BOOL_VEC3=0x8B58 +GL_BOOL_VEC4=0x8B59 +GL_BUFFER_ACCESS=0x88BB +GL_BUFFER_ACCESS_FLAGS=0x911F +GL_BUFFER_MAPPED=0x88BC +GL_BUFFER_MAP_LENGTH=0x9120 +GL_BUFFER_MAP_OFFSET=0x9121 +GL_BUFFER_MAP_POINTER=0x88BD +GL_BUFFER_SIZE=0x8764 +GL_BUFFER_USAGE=0x8765 +GL_BYTE=0x1400 +GL_CCW=0x0901 +GL_CLAMP_READ_COLOR=0x891C +GL_CLAMP_TO_BORDER=0x812D +GL_CLAMP_TO_EDGE=0x812F +GL_CLEAR=0x1500 +GL_CLIP_DISTANCE0=0x3000 +GL_CLIP_DISTANCE1=0x3001 +GL_CLIP_DISTANCE2=0x3002 +GL_CLIP_DISTANCE3=0x3003 +GL_CLIP_DISTANCE4=0x3004 +GL_CLIP_DISTANCE5=0x3005 +GL_CLIP_DISTANCE6=0x3006 +GL_CLIP_DISTANCE7=0x3007 +GL_COLOR=0x1800 +GL_COLOR_ATTACHMENT0=0x8CE0 +GL_COLOR_ATTACHMENT10=0x8CEA +GL_COLOR_ATTACHMENT11=0x8CEB +GL_COLOR_ATTACHMENT12=0x8CEC +GL_COLOR_ATTACHMENT13=0x8CED +GL_COLOR_ATTACHMENT14=0x8CEE +GL_COLOR_ATTACHMENT15=0x8CEF +GL_COLOR_ATTACHMENT1=0x8CE1 +GL_COLOR_ATTACHMENT2=0x8CE2 +GL_COLOR_ATTACHMENT3=0x8CE3 +GL_COLOR_ATTACHMENT4=0x8CE4 +GL_COLOR_ATTACHMENT5=0x8CE5 +GL_COLOR_ATTACHMENT6=0x8CE6 +GL_COLOR_ATTACHMENT7=0x8CE7 +GL_COLOR_ATTACHMENT8=0x8CE8 +GL_COLOR_ATTACHMENT9=0x8CE9 +GL_COLOR_BUFFER_BIT=0x00004000 +GL_COLOR_CLEAR_VALUE=0x0C22 +GL_COLOR_LOGIC_OP=0x0BF2 +GL_COLOR_WRITEMASK=0x0C23 +GL_COMPARE_REF_TO_TEXTURE=0x884E +GL_COMPILE_STATUS=0x8B81 +GL_COMPRESSED_RED=0x8225 +GL_COMPRESSED_RED_RGTC1=0x8DBB +GL_COMPRESSED_RG=0x8226 +GL_COMPRESSED_RGB=0x84ED +GL_COMPRESSED_RGBA=0x84EE +GL_COMPRESSED_RG_RGTC2=0x8DBD +GL_COMPRESSED_SIGNED_RED_RGTC1=0x8DBC +GL_COMPRESSED_SIGNED_RG_RGTC2=0x8DBE +GL_COMPRESSED_SRGB=0x8C48 +GL_COMPRESSED_SRGB_ALPHA=0x8C49 +GL_COMPRESSED_TEXTURE_FORMATS=0x86A3 +GL_CONDITION_SATISFIED=0x911C +GL_CONSTANT_ALPHA=0x8003 +GL_CONSTANT_COLOR=0x8001 +GL_CONTEXT_COMPATIBILITY_PROFILE_BIT=0x00000002 +GL_CONTEXT_CORE_PROFILE_BIT=0x00000001 +GL_CONTEXT_FLAGS=0x821E +GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT=0x0001 +GL_CONTEXT_PROFILE_MASK=0x9126 +GL_COPY=0x1503 +GL_COPY_INVERTED=0x150C +GL_COPY_READ_BUFFER=0x8F36 +GL_COPY_WRITE_BUFFER=0x8F37 +GL_CULL_FACE=0x0B44 +GL_CULL_FACE_MODE=0x0B45 +GL_CURRENT_PROGRAM=0x8B8D +GL_CURRENT_QUERY=0x8865 +GL_CURRENT_VERTEX_ATTRIB=0x8626 +GL_CW=0x0900 +GL_DECR=0x1E03 +GL_DECR_WRAP=0x8508 +GL_DELETE_STATUS=0x8B80 +GL_DEPTH24_STENCIL8=0x88F0 +GL_DEPTH32F_STENCIL8=0x8CAD +GL_DEPTH=0x1801 +GL_DEPTH_ATTACHMENT=0x8D00 +GL_DEPTH_BUFFER=0x8223 +GL_DEPTH_BUFFER_BIT=0x00000100 +GL_DEPTH_CLAMP=0x864F +GL_DEPTH_CLEAR_VALUE=0x0B73 +GL_DEPTH_COMPONENT16=0x81A5 +GL_DEPTH_COMPONENT24=0x81A6 +GL_DEPTH_COMPONENT32=0x81A7 +GL_DEPTH_COMPONENT32F=0x8CAC +GL_DEPTH_COMPONENT=0x1902 +GL_DEPTH_FUNC=0x0B74 +GL_DEPTH_RANGE=0x0B70 +GL_DEPTH_STENCIL=0x84F9 +GL_DEPTH_STENCIL_ATTACHMENT=0x821A +GL_DEPTH_TEST=0x0B71 +GL_DEPTH_WRITEMASK=0x0B72 +GL_DITHER=0x0BD0 +GL_DONT_CARE=0x1100 +GL_DOUBLE=0x140A +GL_DOUBLEBUFFER=0x0C32 +GL_DRAW_BUFFER0=0x8825 +GL_DRAW_BUFFER10=0x882F +GL_DRAW_BUFFER11=0x8830 +GL_DRAW_BUFFER12=0x8831 +GL_DRAW_BUFFER13=0x8832 +GL_DRAW_BUFFER14=0x8833 +GL_DRAW_BUFFER15=0x8834 +GL_DRAW_BUFFER1=0x8826 +GL_DRAW_BUFFER2=0x8827 +GL_DRAW_BUFFER3=0x8828 +GL_DRAW_BUFFER4=0x8829 +GL_DRAW_BUFFER5=0x882A +GL_DRAW_BUFFER6=0x882B +GL_DRAW_BUFFER7=0x882C +GL_DRAW_BUFFER8=0x882D +GL_DRAW_BUFFER9=0x882E +GL_DRAW_BUFFER=0x0C01 +GL_DRAW_FRAMEBUFFER=0x8CA9 +GL_DRAW_FRAMEBUFFER_BINDING=0x8CA6 +GL_DST_ALPHA=0x0304 +GL_DST_COLOR=0x0306 +GL_DYNAMIC_COPY=0x88EA +GL_DYNAMIC_DRAW=0x88E8 +GL_DYNAMIC_READ=0x88E9 +GL_ELEMENT_ARRAY_BUFFER=0x8893 +GL_ELEMENT_ARRAY_BUFFER_BINDING=0x8895 +GL_EQUAL=0x0202 +GL_EQUIV=0x1509 +GL_EXTENSIONS=0x1F03 +GL_FALSE=0 +GL_FASTEST=0x1101 +GL_FILL=0x1B02 +GL_FIRST_VERTEX_CONVENTION=0x8E4D +GL_FIXED_ONLY=0x891D +GL_FLOAT=0x1406 +GL_FLOAT_32_UNSIGNED_INT_24_8_REV=0x8DAD +GL_FLOAT_MAT2=0x8B5A +GL_FLOAT_MAT2x3=0x8B65 +GL_FLOAT_MAT2x4=0x8B66 +GL_FLOAT_MAT3=0x8B5B +GL_FLOAT_MAT3x2=0x8B67 +GL_FLOAT_MAT3x4=0x8B68 +GL_FLOAT_MAT4=0x8B5C +GL_FLOAT_MAT4x2=0x8B69 +GL_FLOAT_MAT4x3=0x8B6A +GL_FLOAT_VEC2=0x8B50 +GL_FLOAT_VEC3=0x8B51 +GL_FLOAT_VEC4=0x8B52 +GL_FRAGMENT_SHADER=0x8B30 +GL_FRAGMENT_SHADER_DERIVATIVE_HINT=0x8B8B +GL_FRAMEBUFFER=0x8D40 +GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE=0x8215 +GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE=0x8214 +GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING=0x8210 +GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE=0x8211 +GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE=0x8216 +GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE=0x8213 +GL_FRAMEBUFFER_ATTACHMENT_LAYERED=0x8DA7 +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME=0x8CD1 +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE=0x8CD0 +GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE=0x8212 +GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE=0x8217 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE=0x8CD3 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER=0x8CD4 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL=0x8CD2 +GL_FRAMEBUFFER_BINDING=0x8CA6 +GL_FRAMEBUFFER_COMPLETE=0x8CD5 +GL_FRAMEBUFFER_DEFAULT=0x8218 +GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT=0x8CD6 +GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER=0x8CDB +GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS=0x8DA8 +GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT=0x8CD7 +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE=0x8D56 +GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER=0x8CDC +GL_FRAMEBUFFER_SRGB=0x8DB9 +GL_FRAMEBUFFER_UNDEFINED=0x8219 +GL_FRAMEBUFFER_UNSUPPORTED=0x8CDD +GL_FRONT=0x0404 +GL_FRONT_AND_BACK=0x0408 +GL_FRONT_FACE=0x0B46 +GL_FRONT_LEFT=0x0400 +GL_FRONT_RIGHT=0x0401 +GL_FUNC_ADD=0x8006 +GL_FUNC_REVERSE_SUBTRACT=0x800B +GL_FUNC_SUBTRACT=0x800A +GL_GEOMETRY_INPUT_TYPE=0x8917 +GL_GEOMETRY_OUTPUT_TYPE=0x8918 +GL_GEOMETRY_SHADER=0x8DD9 +GL_GEOMETRY_VERTICES_OUT=0x8916 +GL_GEQUAL=0x0206 +GL_GREATER=0x0204 +GL_GREEN=0x1904 +GL_GREEN_INTEGER=0x8D95 +GL_HALF_FLOAT=0x140B +GL_INCR=0x1E02 +GL_INCR_WRAP=0x8507 +GL_INFO_LOG_LENGTH=0x8B84 +GL_INT=0x1404 +GL_INTERLEAVED_ATTRIBS=0x8C8C +GL_INT_SAMPLER_1D=0x8DC9 +GL_INT_SAMPLER_1D_ARRAY=0x8DCE +GL_INT_SAMPLER_2D=0x8DCA +GL_INT_SAMPLER_2D_ARRAY=0x8DCF +GL_INT_SAMPLER_2D_MULTISAMPLE=0x9109 +GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY=0x910C +GL_INT_SAMPLER_2D_RECT=0x8DCD +GL_INT_SAMPLER_3D=0x8DCB +GL_INT_SAMPLER_BUFFER=0x8DD0 +GL_INT_SAMPLER_CUBE=0x8DCC +GL_INT_SAMPLER_CUBE_MAP_ARRAY=0x900E +GL_INT_VEC2=0x8B53 +GL_INT_VEC3=0x8B54 +GL_INT_VEC4=0x8B55 +GL_INVALID_ENUM=0x0500 +GL_INVALID_FRAMEBUFFER_OPERATION=0x0506 +GL_INVALID_INDEX=0xFFFFFFFF +GL_INVALID_OPERATION=0x0502 +GL_INVALID_VALUE=0x0501 +GL_INVERT=0x150A +GL_KEEP=0x1E00 +GL_LAST_VERTEX_CONVENTION=0x8E4E +GL_LEFT=0x0406 +GL_LEQUAL=0x0203 +GL_LESS=0x0201 +GL_LINE=0x1B01 +GL_LINEAR=0x2601 +GL_LINEAR_MIPMAP_LINEAR=0x2703 +GL_LINEAR_MIPMAP_NEAREST=0x2701 +GL_LINES=0x0001 +GL_LINES_ADJACENCY=0x000A +GL_LINE_LOOP=0x0002 +GL_LINE_SMOOTH=0x0B20 +GL_LINE_SMOOTH_HINT=0x0C52 +GL_LINE_STRIP=0x0003 +GL_LINE_STRIP_ADJACENCY=0x000B +GL_LINE_WIDTH=0x0B21 +GL_LINE_WIDTH_GRANULARITY=0x0B23 +GL_LINE_WIDTH_RANGE=0x0B22 +GL_LINK_STATUS=0x8B82 +GL_LOGIC_OP_MODE=0x0BF0 +GL_LOWER_LEFT=0x8CA1 +GL_MAJOR_VERSION=0x821B +GL_MAP_FLUSH_EXPLICIT_BIT=0x0010 +GL_MAP_INVALIDATE_BUFFER_BIT=0x0008 +GL_MAP_INVALIDATE_RANGE_BIT=0x0004 +GL_MAP_READ_BIT=0x0001 +GL_MAP_UNSYNCHRONIZED_BIT=0x0020 +GL_MAP_WRITE_BIT=0x0002 +GL_MAX=0x8008 +GL_MAX_3D_TEXTURE_SIZE=0x8073 +GL_MAX_ARRAY_TEXTURE_LAYERS=0x88FF +GL_MAX_CLIP_DISTANCES=0x0D32 +GL_MAX_COLOR_ATTACHMENTS=0x8CDF +GL_MAX_COLOR_TEXTURE_SAMPLES=0x910E +GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS=0x8A33 +GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS=0x8A32 +GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS=0x8B4D +GL_MAX_COMBINED_UNIFORM_BLOCKS=0x8A2E +GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS=0x8A31 +GL_MAX_CUBE_MAP_TEXTURE_SIZE=0x851C +GL_MAX_DEPTH_TEXTURE_SAMPLES=0x910F +GL_MAX_DRAW_BUFFERS=0x8824 +GL_MAX_ELEMENTS_INDICES=0x80E9 +GL_MAX_ELEMENTS_VERTICES=0x80E8 +GL_MAX_FRAGMENT_INPUT_COMPONENTS=0x9125 +GL_MAX_FRAGMENT_UNIFORM_BLOCKS=0x8A2D +GL_MAX_FRAGMENT_UNIFORM_COMPONENTS=0x8B49 +GL_MAX_GEOMETRY_INPUT_COMPONENTS=0x9123 +GL_MAX_GEOMETRY_OUTPUT_COMPONENTS=0x9124 +GL_MAX_GEOMETRY_OUTPUT_VERTICES=0x8DE0 +GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS=0x8C29 +GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS=0x8DE1 +GL_MAX_GEOMETRY_UNIFORM_BLOCKS=0x8A2C +GL_MAX_GEOMETRY_UNIFORM_COMPONENTS=0x8DDF +GL_MAX_INTEGER_SAMPLES=0x9110 +GL_MAX_PROGRAM_TEXEL_OFFSET=0x8905 +GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS=0x8F9F +GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET=0x8E5F +GL_MAX_RECTANGLE_TEXTURE_SIZE=0x84F8 +GL_MAX_RENDERBUFFER_SIZE=0x84E8 +GL_MAX_SAMPLES=0x8D57 +GL_MAX_SAMPLE_MASK_WORDS=0x8E59 +GL_MAX_SERVER_WAIT_TIMEOUT=0x9111 +GL_MAX_TEXTURE_BUFFER_SIZE=0x8C2B +GL_MAX_TEXTURE_IMAGE_UNITS=0x8872 +GL_MAX_TEXTURE_LOD_BIAS=0x84FD +GL_MAX_TEXTURE_SIZE=0x0D33 +GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS=0x8C8A +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS=0x8C8B +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS=0x8C80 +GL_MAX_UNIFORM_BLOCK_SIZE=0x8A30 +GL_MAX_UNIFORM_BUFFER_BINDINGS=0x8A2F +GL_MAX_VARYING_COMPONENTS=0x8B4B +GL_MAX_VARYING_FLOATS=0x8B4B +GL_MAX_VERTEX_ATTRIBS=0x8869 +GL_MAX_VERTEX_OUTPUT_COMPONENTS=0x9122 +GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS=0x8B4C +GL_MAX_VERTEX_UNIFORM_BLOCKS=0x8A2B +GL_MAX_VERTEX_UNIFORM_COMPONENTS=0x8B4A +GL_MAX_VIEWPORT_DIMS=0x0D3A +GL_MIN=0x8007 +GL_MINOR_VERSION=0x821C +GL_MIN_PROGRAM_TEXEL_OFFSET=0x8904 +GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET=0x8E5E +GL_MIN_SAMPLE_SHADING_VALUE=0x8C37 +GL_MIRRORED_REPEAT=0x8370 +GL_MULTISAMPLE=0x809D +GL_NAND=0x150E +GL_NEAREST=0x2600 +GL_NEAREST_MIPMAP_LINEAR=0x2702 +GL_NEAREST_MIPMAP_NEAREST=0x2700 +GL_NEVER=0x0200 +GL_NICEST=0x1102 +GL_NONE=0 +GL_NOOP=0x1505 +GL_NOR=0x1508 +GL_NOTEQUAL=0x0205 +GL_NO_ERROR=0 +GL_NUM_COMPRESSED_TEXTURE_FORMATS=0x86A2 +GL_NUM_EXTENSIONS=0x821D +GL_OBJECT_TYPE=0x9112 +GL_ONE=1 +GL_ONE_MINUS_CONSTANT_ALPHA=0x8004 +GL_ONE_MINUS_CONSTANT_COLOR=0x8002 +GL_ONE_MINUS_DST_ALPHA=0x0305 +GL_ONE_MINUS_DST_COLOR=0x0307 +GL_ONE_MINUS_SRC_ALPHA=0x0303 +GL_ONE_MINUS_SRC_COLOR=0x0301 +GL_OR=0x1507 +GL_OR_INVERTED=0x150D +GL_OR_REVERSE=0x150B +GL_OUT_OF_MEMORY=0x0505 +GL_PACK_ALIGNMENT=0x0D05 +GL_PACK_IMAGE_HEIGHT=0x806C +GL_PACK_LSB_FIRST=0x0D01 +GL_PACK_ROW_LENGTH=0x0D02 +GL_PACK_SKIP_IMAGES=0x806B +GL_PACK_SKIP_PIXELS=0x0D04 +GL_PACK_SKIP_ROWS=0x0D03 +GL_PACK_SWAP_BYTES=0x0D00 +GL_PIXEL_PACK_BUFFER=0x88EB +GL_PIXEL_PACK_BUFFER_BINDING=0x88ED +GL_PIXEL_UNPACK_BUFFER=0x88EC +GL_PIXEL_UNPACK_BUFFER_BINDING=0x88EF +GL_POINT=0x1B00 +GL_POINTS=0x0000 +GL_POINT_FADE_THRESHOLD_SIZE=0x8128 +GL_POINT_SIZE=0x0B11 +GL_POINT_SIZE_GRANULARITY=0x0B13 +GL_POINT_SIZE_RANGE=0x0B12 +GL_POINT_SPRITE_COORD_ORIGIN=0x8CA0 +GL_POLYGON_OFFSET_FACTOR=0x8038 +GL_POLYGON_OFFSET_FILL=0x8037 +GL_POLYGON_OFFSET_LINE=0x2A02 +GL_POLYGON_OFFSET_POINT=0x2A01 +GL_POLYGON_OFFSET_UNITS=0x2A00 +GL_POLYGON_SMOOTH=0x0B41 +GL_POLYGON_SMOOTH_HINT=0x0C53 +GL_PRIMITIVES_GENERATED=0x8C87 +GL_PRIMITIVE_RESTART=0x8F9D +GL_PRIMITIVE_RESTART_INDEX=0x8F9E +GL_PROGRAM_POINT_SIZE=0x8642 +GL_PROVOKING_VERTEX=0x8E4F +GL_PROXY_TEXTURE_1D=0x8063 +GL_PROXY_TEXTURE_1D_ARRAY=0x8C19 +GL_PROXY_TEXTURE_2D=0x8064 +GL_PROXY_TEXTURE_2D_ARRAY=0x8C1B +GL_PROXY_TEXTURE_2D_MULTISAMPLE=0x9101 +GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY=0x9103 +GL_PROXY_TEXTURE_3D=0x8070 +GL_PROXY_TEXTURE_CUBE_MAP=0x851B +GL_PROXY_TEXTURE_CUBE_MAP_ARRAY=0x900B +GL_PROXY_TEXTURE_RECTANGLE=0x84F7 +GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION=0x8E4C +GL_QUERY_BY_REGION_NO_WAIT=0x8E16 +GL_QUERY_BY_REGION_WAIT=0x8E15 +GL_QUERY_COUNTER_BITS=0x8864 +GL_QUERY_NO_WAIT=0x8E14 +GL_QUERY_RESULT=0x8866 +GL_QUERY_RESULT_AVAILABLE=0x8867 +GL_QUERY_WAIT=0x8E13 +GL_R11F_G11F_B10F=0x8C3A +GL_R16=0x822A +GL_R16F=0x822D +GL_R16I=0x8233 +GL_R16UI=0x8234 +GL_R16_SNORM=0x8F98 +GL_R32F=0x822E +GL_R32I=0x8235 +GL_R32UI=0x8236 +GL_R3_G3_B2=0x2A10 +GL_R8=0x8229 +GL_R8I=0x8231 +GL_R8UI=0x8232 +GL_R8_SNORM=0x8F94 +GL_RASTERIZER_DISCARD=0x8C89 +GL_READ_BUFFER=0x0C02 +GL_READ_FRAMEBUFFER=0x8CA8 +GL_READ_FRAMEBUFFER_BINDING=0x8CAA +GL_READ_ONLY=0x88B8 +GL_READ_WRITE=0x88BA +GL_RED=0x1903 +GL_RED_INTEGER=0x8D94 +GL_RED_SNORM=0x8F90 +GL_RENDERBUFFER=0x8D41 +GL_RENDERBUFFER_ALPHA_SIZE=0x8D53 +GL_RENDERBUFFER_BINDING=0x8CA7 +GL_RENDERBUFFER_BLUE_SIZE=0x8D52 +GL_RENDERBUFFER_DEPTH_SIZE=0x8D54 +GL_RENDERBUFFER_GREEN_SIZE=0x8D51 +GL_RENDERBUFFER_HEIGHT=0x8D43 +GL_RENDERBUFFER_INTERNAL_FORMAT=0x8D44 +GL_RENDERBUFFER_RED_SIZE=0x8D50 +GL_RENDERBUFFER_SAMPLES=0x8CAB +GL_RENDERBUFFER_STENCIL_SIZE=0x8D55 +GL_RENDERBUFFER_WIDTH=0x8D42 +GL_RENDERER=0x1F01 +GL_REPEAT=0x2901 +GL_REPLACE=0x1E01 +GL_RG16=0x822C +GL_RG16F=0x822F +GL_RG16I=0x8239 +GL_RG16UI=0x823A +GL_RG16_SNORM=0x8F99 +GL_RG32F=0x8230 +GL_RG32I=0x823B +GL_RG32UI=0x823C +GL_RG8=0x822B +GL_RG8I=0x8237 +GL_RG8UI=0x8238 +GL_RG8_SNORM=0x8F95 +GL_RG=0x8227 +GL_RGB10=0x8052 +GL_RGB10_A2=0x8059 +GL_RGB12=0x8053 +GL_RGB16=0x8054 +GL_RGB16F=0x881B +GL_RGB16I=0x8D89 +GL_RGB16UI=0x8D77 +GL_RGB16_SNORM=0x8F9A +GL_RGB32F=0x8815 +GL_RGB32I=0x8D83 +GL_RGB32UI=0x8D71 +GL_RGB4=0x804F +GL_RGB5=0x8050 +GL_RGB5_A1=0x8057 +GL_RGB8=0x8051 +GL_RGB8I=0x8D8F +GL_RGB8UI=0x8D7D +GL_RGB8_SNORM=0x8F96 +GL_RGB9_E5=0x8C3D +GL_RGB=0x1907 +GL_RGBA12=0x805A +GL_RGBA16=0x805B +GL_RGBA16F=0x881A +GL_RGBA16I=0x8D88 +GL_RGBA16UI=0x8D76 +GL_RGBA16_SNORM=0x8F9B +GL_RGBA2=0x8055 +GL_RGBA32F=0x8814 +GL_RGBA32I=0x8D82 +GL_RGBA32UI=0x8D70 +GL_RGBA4=0x8056 +GL_RGBA8=0x8058 +GL_RGBA8I=0x8D8E +GL_RGBA8UI=0x8D7C +GL_RGBA8_SNORM=0x8F97 +GL_RGBA=0x1908 +GL_RGBA_INTEGER=0x8D99 +GL_RGBA_SNORM=0x8F93 +GL_RGB_INTEGER=0x8D98 +GL_RGB_SNORM=0x8F92 +GL_RG_INTEGER=0x8228 +GL_RG_SNORM=0x8F91 +GL_RIGHT=0x0407 +GL_SAMPLER_1D=0x8B5D +GL_SAMPLER_1D_ARRAY=0x8DC0 +GL_SAMPLER_1D_ARRAY_SHADOW=0x8DC3 +GL_SAMPLER_1D_SHADOW=0x8B61 +GL_SAMPLER_2D=0x8B5E +GL_SAMPLER_2D_ARRAY=0x8DC1 +GL_SAMPLER_2D_ARRAY_SHADOW=0x8DC4 +GL_SAMPLER_2D_MULTISAMPLE=0x9108 +GL_SAMPLER_2D_MULTISAMPLE_ARRAY=0x910B +GL_SAMPLER_2D_RECT=0x8B63 +GL_SAMPLER_2D_RECT_SHADOW=0x8B64 +GL_SAMPLER_2D_SHADOW=0x8B62 +GL_SAMPLER_3D=0x8B5F +GL_SAMPLER_BUFFER=0x8DC2 +GL_SAMPLER_CUBE=0x8B60 +GL_SAMPLER_CUBE_MAP_ARRAY=0x900C +GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW=0x900D +GL_SAMPLER_CUBE_SHADOW=0x8DC5 +GL_SAMPLES=0x80A9 +GL_SAMPLES_PASSED=0x8914 +GL_SAMPLE_ALPHA_TO_COVERAGE=0x809E +GL_SAMPLE_ALPHA_TO_ONE=0x809F +GL_SAMPLE_BUFFERS=0x80A8 +GL_SAMPLE_COVERAGE=0x80A0 +GL_SAMPLE_COVERAGE_INVERT=0x80AB +GL_SAMPLE_COVERAGE_VALUE=0x80AA +GL_SAMPLE_MASK=0x8E51 +GL_SAMPLE_MASK_VALUE=0x8E52 +GL_SAMPLE_POSITION=0x8E50 +GL_SAMPLE_SHADING=0x8C36 +GL_SCISSOR_BOX=0x0C10 +GL_SCISSOR_TEST=0x0C11 +GL_SEPARATE_ATTRIBS=0x8C8D +GL_SET=0x150F +GL_SHADER_SOURCE_LENGTH=0x8B88 +GL_SHADER_TYPE=0x8B4F +GL_SHADING_LANGUAGE_VERSION=0x8B8C +GL_SHORT=0x1402 +GL_SIGNALED=0x9119 +GL_SIGNED_NORMALIZED=0x8F9C +GL_SMOOTH_LINE_WIDTH_GRANULARITY=0x0B23 +GL_SMOOTH_LINE_WIDTH_RANGE=0x0B22 +GL_SMOOTH_POINT_SIZE_GRANULARITY=0x0B13 +GL_SMOOTH_POINT_SIZE_RANGE=0x0B12 +GL_SRC_ALPHA=0x0302 +GL_SRC_ALPHA_SATURATE=0x0308 +GL_SRC_COLOR=0x0300 +GL_SRGB8=0x8C41 +GL_SRGB8_ALPHA8=0x8C43 +GL_SRGB=0x8C40 +GL_SRGB_ALPHA=0x8C42 +GL_STATIC_COPY=0x88E6 +GL_STATIC_DRAW=0x88E4 +GL_STATIC_READ=0x88E5 +GL_STENCIL=0x1802 +GL_STENCIL_ATTACHMENT=0x8D20 +GL_STENCIL_BACK_FAIL=0x8801 +GL_STENCIL_BACK_FUNC=0x8800 +GL_STENCIL_BACK_PASS_DEPTH_FAIL=0x8802 +GL_STENCIL_BACK_PASS_DEPTH_PASS=0x8803 +GL_STENCIL_BACK_REF=0x8CA3 +GL_STENCIL_BACK_VALUE_MASK=0x8CA4 +GL_STENCIL_BACK_WRITEMASK=0x8CA5 +GL_STENCIL_BUFFER=0x8224 +GL_STENCIL_BUFFER_BIT=0x00000400 +GL_STENCIL_CLEAR_VALUE=0x0B91 +GL_STENCIL_FAIL=0x0B94 +GL_STENCIL_FUNC=0x0B92 +GL_STENCIL_INDEX16=0x8D49 +GL_STENCIL_INDEX1=0x8D46 +GL_STENCIL_INDEX4=0x8D47 +GL_STENCIL_INDEX8=0x8D48 +GL_STENCIL_INDEX=0x1901 +GL_STENCIL_PASS_DEPTH_FAIL=0x0B95 +GL_STENCIL_PASS_DEPTH_PASS=0x0B96 +GL_STENCIL_REF=0x0B97 +GL_STENCIL_TEST=0x0B90 +GL_STENCIL_VALUE_MASK=0x0B93 +GL_STENCIL_WRITEMASK=0x0B98 +GL_STEREO=0x0C33 +GL_STREAM_COPY=0x88E2 +GL_STREAM_DRAW=0x88E0 +GL_STREAM_READ=0x88E1 +GL_SUBPIXEL_BITS=0x0D50 +GL_SYNC_CONDITION=0x9113 +GL_SYNC_FENCE=0x9116 +GL_SYNC_FLAGS=0x9115 +GL_SYNC_FLUSH_COMMANDS_BIT=0x00000001 +GL_SYNC_GPU_COMMANDS_COMPLETE=0x9117 +GL_SYNC_STATUS=0x9114 +GL_TEXTURE0=0x84C0 +GL_TEXTURE10=0x84CA +GL_TEXTURE11=0x84CB +GL_TEXTURE12=0x84CC +GL_TEXTURE13=0x84CD +GL_TEXTURE14=0x84CE +GL_TEXTURE15=0x84CF +GL_TEXTURE16=0x84D0 +GL_TEXTURE17=0x84D1 +GL_TEXTURE18=0x84D2 +GL_TEXTURE19=0x84D3 +GL_TEXTURE1=0x84C1 +GL_TEXTURE20=0x84D4 +GL_TEXTURE21=0x84D5 +GL_TEXTURE22=0x84D6 +GL_TEXTURE23=0x84D7 +GL_TEXTURE24=0x84D8 +GL_TEXTURE25=0x84D9 +GL_TEXTURE26=0x84DA +GL_TEXTURE27=0x84DB +GL_TEXTURE28=0x84DC +GL_TEXTURE29=0x84DD +GL_TEXTURE2=0x84C2 +GL_TEXTURE30=0x84DE +GL_TEXTURE31=0x84DF +GL_TEXTURE3=0x84C3 +GL_TEXTURE4=0x84C4 +GL_TEXTURE5=0x84C5 +GL_TEXTURE6=0x84C6 +GL_TEXTURE7=0x84C7 +GL_TEXTURE8=0x84C8 +GL_TEXTURE9=0x84C9 +GL_TEXTURE=0x1702 +GL_TEXTURE_1D=0x0DE0 +GL_TEXTURE_1D_ARRAY=0x8C18 +GL_TEXTURE_2D=0x0DE1 +GL_TEXTURE_2D_ARRAY=0x8C1A +GL_TEXTURE_2D_MULTISAMPLE=0x9100 +GL_TEXTURE_2D_MULTISAMPLE_ARRAY=0x9102 +GL_TEXTURE_3D=0x806F +GL_TEXTURE_ALPHA_SIZE=0x805F +GL_TEXTURE_ALPHA_TYPE=0x8C13 +GL_TEXTURE_BASE_LEVEL=0x813C +GL_TEXTURE_BINDING_1D=0x8068 +GL_TEXTURE_BINDING_1D_ARRAY=0x8C1C +GL_TEXTURE_BINDING_2D=0x8069 +GL_TEXTURE_BINDING_2D_ARRAY=0x8C1D +GL_TEXTURE_BINDING_2D_MULTISAMPLE=0x9104 +GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY=0x9105 +GL_TEXTURE_BINDING_3D=0x806A +GL_TEXTURE_BINDING_BUFFER=0x8C2C +GL_TEXTURE_BINDING_CUBE_MAP=0x8514 +GL_TEXTURE_BINDING_CUBE_MAP_ARRAY=0x900A +GL_TEXTURE_BINDING_RECTANGLE=0x84F6 +GL_TEXTURE_BLUE_SIZE=0x805E +GL_TEXTURE_BLUE_TYPE=0x8C12 +GL_TEXTURE_BORDER=0x1005 +GL_TEXTURE_BORDER_COLOR=0x1004 +GL_TEXTURE_BUFFER=0x8C2A +GL_TEXTURE_BUFFER_DATA_STORE_BINDING=0x8C2D +GL_TEXTURE_BUFFER_FORMAT=0x8C2E +GL_TEXTURE_COMPARE_FUNC=0x884D +GL_TEXTURE_COMPARE_MODE=0x884C +GL_TEXTURE_COMPRESSED=0x86A1 +GL_TEXTURE_COMPRESSED_IMAGE_SIZE=0x86A0 +GL_TEXTURE_COMPRESSION_HINT=0x84EF +GL_TEXTURE_CUBE_MAP=0x8513 +GL_TEXTURE_CUBE_MAP_ARRAY=0x9009 +GL_TEXTURE_CUBE_MAP_NEGATIVE_X=0x8516 +GL_TEXTURE_CUBE_MAP_NEGATIVE_Y=0x8518 +GL_TEXTURE_CUBE_MAP_NEGATIVE_Z=0x851A +GL_TEXTURE_CUBE_MAP_POSITIVE_X=0x8515 +GL_TEXTURE_CUBE_MAP_POSITIVE_Y=0x8517 +GL_TEXTURE_CUBE_MAP_POSITIVE_Z=0x8519 +GL_TEXTURE_CUBE_MAP_SEAMLESS=0x884F +GL_TEXTURE_DEPTH=0x8071 +GL_TEXTURE_DEPTH_SIZE=0x884A +GL_TEXTURE_DEPTH_TYPE=0x8C16 +GL_TEXTURE_FIXED_SAMPLE_LOCATIONS=0x9107 +GL_TEXTURE_GREEN_SIZE=0x805D +GL_TEXTURE_GREEN_TYPE=0x8C11 +GL_TEXTURE_HEIGHT=0x1001 +GL_TEXTURE_INTERNAL_FORMAT=0x1003 +GL_TEXTURE_LOD_BIAS=0x8501 +GL_TEXTURE_MAG_FILTER=0x2800 +GL_TEXTURE_MAX_LEVEL=0x813D +GL_TEXTURE_MAX_LOD=0x813B +GL_TEXTURE_MIN_FILTER=0x2801 +GL_TEXTURE_MIN_LOD=0x813A +GL_TEXTURE_RECTANGLE=0x84F5 +GL_TEXTURE_RED_SIZE=0x805C +GL_TEXTURE_RED_TYPE=0x8C10 +GL_TEXTURE_SAMPLES=0x9106 +GL_TEXTURE_SHARED_SIZE=0x8C3F +GL_TEXTURE_STENCIL_SIZE=0x88F1 +GL_TEXTURE_WIDTH=0x1000 +GL_TEXTURE_WRAP_R=0x8072 +GL_TEXTURE_WRAP_S=0x2802 +GL_TEXTURE_WRAP_T=0x2803 +GL_TIMEOUT_EXPIRED=0x911B +GL_TIMEOUT_IGNORED=0xFFFFFFFFFFFFFFFF +GL_TRANSFORM_FEEDBACK_BUFFER=0x8C8E +GL_TRANSFORM_FEEDBACK_BUFFER_BINDING=0x8C8F +GL_TRANSFORM_FEEDBACK_BUFFER_MODE=0x8C7F +GL_TRANSFORM_FEEDBACK_BUFFER_SIZE=0x8C85 +GL_TRANSFORM_FEEDBACK_BUFFER_START=0x8C84 +GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN=0x8C88 +GL_TRANSFORM_FEEDBACK_VARYINGS=0x8C83 +GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH=0x8C76 +GL_TRIANGLES=0x0004 +GL_TRIANGLES_ADJACENCY=0x000C +GL_TRIANGLE_FAN=0x0006 +GL_TRIANGLE_STRIP=0x0005 +GL_TRIANGLE_STRIP_ADJACENCY=0x000D +GL_TRUE=1 +GL_UNIFORM_ARRAY_STRIDE=0x8A3C +GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS=0x8A42 +GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES=0x8A43 +GL_UNIFORM_BLOCK_BINDING=0x8A3F +GL_UNIFORM_BLOCK_DATA_SIZE=0x8A40 +GL_UNIFORM_BLOCK_INDEX=0x8A3A +GL_UNIFORM_BLOCK_NAME_LENGTH=0x8A41 +GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER=0x8A46 +GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER=0x8A45 +GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER=0x8A44 +GL_UNIFORM_BUFFER=0x8A11 +GL_UNIFORM_BUFFER_BINDING=0x8A28 +GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT=0x8A34 +GL_UNIFORM_BUFFER_SIZE=0x8A2A +GL_UNIFORM_BUFFER_START=0x8A29 +GL_UNIFORM_IS_ROW_MAJOR=0x8A3E +GL_UNIFORM_MATRIX_STRIDE=0x8A3D +GL_UNIFORM_NAME_LENGTH=0x8A39 +GL_UNIFORM_OFFSET=0x8A3B +GL_UNIFORM_SIZE=0x8A38 +GL_UNIFORM_TYPE=0x8A37 +GL_UNPACK_ALIGNMENT=0x0CF5 +GL_UNPACK_IMAGE_HEIGHT=0x806E +GL_UNPACK_LSB_FIRST=0x0CF1 +GL_UNPACK_ROW_LENGTH=0x0CF2 +GL_UNPACK_SKIP_IMAGES=0x806D +GL_UNPACK_SKIP_PIXELS=0x0CF4 +GL_UNPACK_SKIP_ROWS=0x0CF3 +GL_UNPACK_SWAP_BYTES=0x0CF0 +GL_UNSIGNALED=0x9118 +GL_UNSIGNED_BYTE=0x1401 +GL_UNSIGNED_BYTE_2_3_3_REV=0x8362 +GL_UNSIGNED_BYTE_3_3_2=0x8032 +GL_UNSIGNED_INT=0x1405 +GL_UNSIGNED_INT_10F_11F_11F_REV=0x8C3B +GL_UNSIGNED_INT_10_10_10_2=0x8036 +GL_UNSIGNED_INT_24_8=0x84FA +GL_UNSIGNED_INT_2_10_10_10_REV=0x8368 +GL_UNSIGNED_INT_5_9_9_9_REV=0x8C3E +GL_UNSIGNED_INT_8_8_8_8=0x8035 +GL_UNSIGNED_INT_8_8_8_8_REV=0x8367 +GL_UNSIGNED_INT_SAMPLER_1D=0x8DD1 +GL_UNSIGNED_INT_SAMPLER_1D_ARRAY=0x8DD6 +GL_UNSIGNED_INT_SAMPLER_2D=0x8DD2 +GL_UNSIGNED_INT_SAMPLER_2D_ARRAY=0x8DD7 +GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE=0x910A +GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY=0x910D +GL_UNSIGNED_INT_SAMPLER_2D_RECT=0x8DD5 +GL_UNSIGNED_INT_SAMPLER_3D=0x8DD3 +GL_UNSIGNED_INT_SAMPLER_BUFFER=0x8DD8 +GL_UNSIGNED_INT_SAMPLER_CUBE=0x8DD4 +GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY=0x900F +GL_UNSIGNED_INT_VEC2=0x8DC6 +GL_UNSIGNED_INT_VEC3=0x8DC7 +GL_UNSIGNED_INT_VEC4=0x8DC8 +GL_UNSIGNED_NORMALIZED=0x8C17 +GL_UNSIGNED_SHORT=0x1403 +GL_UNSIGNED_SHORT_1_5_5_5_REV=0x8366 +GL_UNSIGNED_SHORT_4_4_4_4=0x8033 +GL_UNSIGNED_SHORT_4_4_4_4_REV=0x8365 +GL_UNSIGNED_SHORT_5_5_5_1=0x8034 +GL_UNSIGNED_SHORT_5_6_5=0x8363 +GL_UNSIGNED_SHORT_5_6_5_REV=0x8364 +GL_UPPER_LEFT=0x8CA2 +GL_VALIDATE_STATUS=0x8B83 +GL_VENDOR=0x1F00 +GL_VERSION=0x1F02 +GL_VERSION_1_0=1 +GL_VERSION_1_1=1 +GL_VERSION_1_2=1 +GL_VERSION_1_3=1 +GL_VERSION_1_4=1 +GL_VERSION_1_5=1 +GL_VERSION_2_0=1 +GL_VERSION_2_1=1 +GL_VERSION_3_0=1 +GL_VERSION_3_1=1 +GL_VERSION_3_2=1 +GL_VERTEX_ARRAY_BINDING=0x85B5 +GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING=0x889F +GL_VERTEX_ATTRIB_ARRAY_ENABLED=0x8622 +GL_VERTEX_ATTRIB_ARRAY_INTEGER=0x88FD +GL_VERTEX_ATTRIB_ARRAY_NORMALIZED=0x886A +GL_VERTEX_ATTRIB_ARRAY_POINTER=0x8645 +GL_VERTEX_ATTRIB_ARRAY_SIZE=0x8623 +GL_VERTEX_ATTRIB_ARRAY_STRIDE=0x8624 +GL_VERTEX_ATTRIB_ARRAY_TYPE=0x8625 +GL_VERTEX_PROGRAM_POINT_SIZE=0x8642 +GL_VERTEX_SHADER=0x8B31 +GL_VIEWPORT=0x0BA2 +GL_WAIT_FAILED=0x911D +GL_WRITE_ONLY=0x88B9 +GL_XOR=0x1506 +GL_ZERO=0 +parseStructInfos(" +__GLsync{}; +")
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/glew.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,1869 @@ +dynbind(c("glew","glew32")," +__glewActiveStencilFaceEXT(i)v; +__glewActiveTexture(i)v; +__glewActiveTextureARB(i)v; +__glewActiveVaryingNV(ip)v; +__glewAddSwapHintRectWIN(IIII)v; +__glewAlphaFragmentOp1ATI(iiiiii)v; +__glewAlphaFragmentOp2ATI(iiiiiiiii)v; +__glewAlphaFragmentOp3ATI(iiiiiiiiiiii)v; +__glewApplyTextureEXT(i)v; +__glewAreProgramsResidentNV(Ipp)c; +__glewAreTexturesResidentEXT(Ipp)c; +__glewArrayElementEXT(I)v; +__glewArrayObjectATI(iIiIii)v; +__glewAsyncMarkerSGIX(i)v; +__glewAttachObjectARB(ii)v; +__glewAttachShader(ii)v; +__glewBeginConditionalRender(ii)v; +__glewBeginConditionalRenderNV(ii)v; +__glewBeginFragmentShaderATI()v; +__glewBeginOcclusionQueryNV(i)v; +__glewBeginQuery(ii)v; +__glewBeginQueryARB(ii)v; +__glewBeginSceneEXT()v; +__glewBeginTransformFeedback(i)v; +__glewBeginTransformFeedbackEXT(i)v; +__glewBeginTransformFeedbackNV(i)v; +__glewBeginVertexShaderEXT()v; +__glewBindAttribLocation(iip)v; +__glewBindAttribLocationARB(iip)v; +__glewBindBuffer(ii)v; +__glewBindBufferARB(ii)v; +__glewBindBufferBase(iii)v; +__glewBindBufferBaseEXT(iii)v; +__glewBindBufferBaseNV(iii)v; +__glewBindBufferOffsetEXT(iiiI)v; +__glewBindBufferOffsetNV(iiiI)v; +__glewBindBufferRange(iiiII)v; +__glewBindBufferRangeEXT(iiiII)v; +__glewBindBufferRangeNV(iiiII)v; +__glewBindFragDataLocation(iip)v; +__glewBindFragDataLocationEXT(iip)v; +__glewBindFragmentShaderATI(i)v; +__glewBindFramebuffer(ii)v; +__glewBindFramebufferEXT(ii)v; +__glewBindLightParameterEXT(ii)i; +__glewBindMaterialParameterEXT(ii)i; +__glewBindMultiTextureEXT(iii)v; +__glewBindParameterEXT(i)i; +__glewBindProgramARB(ii)v; +__glewBindProgramNV(ii)v; +__glewBindRenderbuffer(ii)v; +__glewBindRenderbufferEXT(ii)v; +__glewBindTexGenParameterEXT(iii)i; +__glewBindTextureEXT(ii)v; +__glewBindTextureUnitParameterEXT(ii)i; +__glewBindVertexArray(i)v; +__glewBindVertexArrayAPPLE(i)v; +__glewBindVertexShaderEXT(i)v; +__glewBinormalPointerEXT(iIp)v; +__glewBlendColor(ffff)v; +__glewBlendColorEXT(ffff)v; +__glewBlendEquation(i)v; +__glewBlendEquationEXT(i)v; +__glewBlendEquationSeparate(ii)v; +__glewBlendEquationSeparateEXT(ii)v; +__glewBlendFuncSeparate(iiii)v; +__glewBlendFuncSeparateEXT(iiii)v; +__glewBlitFramebuffer(IIIIIIIIii)v; +__glewBlitFramebufferEXT(IIIIIIIIii)v; +__glewBufferData(iIpi)v; +__glewBufferDataARB(iIpi)v; +__glewBufferParameteriAPPLE(iiI)v; +__glewBufferRegionEnabledEXT()i; +__glewBufferSubData(iIIp)v; +__glewBufferSubDataARB(iIIp)v; +__glewCheckFramebufferStatus(i)i; +__glewCheckFramebufferStatusEXT(i)i; +__glewCheckNamedFramebufferStatusEXT(ii)i; +__glewClampColor(ii)v; +__glewClampColorARB(ii)v; +__glewClearBufferfi(iIfI)v; +__glewClearBufferfv(iIp)v; +__glewClearBufferiv(iIp)v; +__glewClearBufferuiv(iIp)v; +__glewClearColorIiEXT(IIII)v; +__glewClearColorIuiEXT(iiii)v; +__glewClearDepthdNV(d)v; +__glewClearDepthfOES(d)v; +__glewClientActiveTexture(i)v; +__glewClientActiveTextureARB(i)v; +__glewClientActiveVertexStreamATI(i)v; +__glewClientAttribDefaultEXT(i)v; +__glewClipPlanefOES(ip)v; +__glewColor3fVertex3fSUN(ffffff)v; +__glewColor3fVertex3fvSUN(pp)v; +__glewColor3hNV(sss)v; +__glewColor3hvNV(p)v; +__glewColor4fNormal3fVertex3fSUN(ffffffffff)v; +__glewColor4fNormal3fVertex3fvSUN(ppp)v; +__glewColor4hNV(ssss)v; +__glewColor4hvNV(p)v; +__glewColor4ubVertex2fSUN(ccccff)v; +__glewColor4ubVertex2fvSUN(pp)v; +__glewColor4ubVertex3fSUN(ccccfff)v; +__glewColor4ubVertex3fvSUN(pp)v; +__glewColorFragmentOp1ATI(iiiiiii)v; +__glewColorFragmentOp2ATI(iiiiiiiiii)v; +__glewColorFragmentOp3ATI(iiiiiiiiiiiii)v; +__glewColorMaskIndexedEXT(icccc)v; +__glewColorMaski(icccc)v; +__glewColorPointerEXT(IiIIp)v; +__glewColorPointerListIBM(IiIpI)v; +__glewColorPointervINTEL(Iip)v; +__glewColorSubTable(iIIiip)v; +__glewColorSubTableEXT(iIIiip)v; +__glewColorTable(iiIiip)v; +__glewColorTableEXT(iiIiip)v; +__glewColorTableParameterfv(iip)v; +__glewColorTableParameterfvSGI(iip)v; +__glewColorTableParameteriv(iip)v; +__glewColorTableParameterivSGI(iip)v; +__glewColorTableSGI(iiIiip)v; +__glewCombinerInputNV(iiiiii)v; +__glewCombinerOutputNV(iiiiiiiccc)v; +__glewCombinerParameterfNV(if)v; +__glewCombinerParameterfvNV(ip)v; +__glewCombinerParameteriNV(iI)v; +__glewCombinerParameterivNV(ip)v; +__glewCombinerStageParameterfvNV(iip)v; +__glewCompileShader(i)v; +__glewCompileShaderARB(i)v; +__glewCompressedMultiTexImage1DEXT(iiIiIIIp)v; +__glewCompressedMultiTexImage2DEXT(iiIiIIIIp)v; +__glewCompressedMultiTexImage3DEXT(iiIiIIIIIp)v; +__glewCompressedMultiTexSubImage1DEXT(iiIIIiIp)v; +__glewCompressedMultiTexSubImage2DEXT(iiIIIIIiIp)v; +__glewCompressedMultiTexSubImage3DEXT(iiIIIIIIIiIp)v; +__glewCompressedTexImage1D(iIiIIIp)v; +__glewCompressedTexImage1DARB(iIiIIIp)v; +__glewCompressedTexImage2D(iIiIIIIp)v; +__glewCompressedTexImage2DARB(iIiIIIIp)v; +__glewCompressedTexImage3D(iIiIIIIIp)v; +__glewCompressedTexImage3DARB(iIiIIIIIp)v; +__glewCompressedTexSubImage1D(iIIIiIp)v; +__glewCompressedTexSubImage1DARB(iIIIiIp)v; +__glewCompressedTexSubImage2D(iIIIIIiIp)v; +__glewCompressedTexSubImage2DARB(iIIIIIiIp)v; +__glewCompressedTexSubImage3D(iIIIIIIIiIp)v; +__glewCompressedTexSubImage3DARB(iIIIIIIIiIp)v; +__glewCompressedTextureImage1DEXT(iiIiIIIp)v; +__glewCompressedTextureImage2DEXT(iiIiIIIIp)v; +__glewCompressedTextureImage3DEXT(iiIiIIIIIp)v; +__glewCompressedTextureSubImage1DEXT(iiIIIiIp)v; +__glewCompressedTextureSubImage2DEXT(iiIIIIIiIp)v; +__glewCompressedTextureSubImage3DEXT(iiIIIIIIIiIp)v; +__glewConvolutionFilter1D(iiIiip)v; +__glewConvolutionFilter1DEXT(iiIiip)v; +__glewConvolutionFilter2D(iiIIiip)v; +__glewConvolutionFilter2DEXT(iiIIiip)v; +__glewConvolutionParameterf(iif)v; +__glewConvolutionParameterfEXT(iif)v; +__glewConvolutionParameterfv(iip)v; +__glewConvolutionParameterfvEXT(iip)v; +__glewConvolutionParameteri(iiI)v; +__glewConvolutionParameteriEXT(iiI)v; +__glewConvolutionParameteriv(iip)v; +__glewConvolutionParameterivEXT(iip)v; +__glewCopyColorSubTable(iIIII)v; +__glewCopyColorSubTableEXT(iIIII)v; +__glewCopyColorTable(iiIII)v; +__glewCopyColorTableSGI(iiIII)v; +__glewCopyConvolutionFilter1D(iiIII)v; +__glewCopyConvolutionFilter1DEXT(iiIII)v; +__glewCopyConvolutionFilter2D(iiIIII)v; +__glewCopyConvolutionFilter2DEXT(iiIIII)v; +__glewCopyMultiTexImage1DEXT(iiIiIIII)v; +__glewCopyMultiTexImage2DEXT(iiIiIIIII)v; +__glewCopyMultiTexSubImage1DEXT(iiIIIII)v; +__glewCopyMultiTexSubImage2DEXT(iiIIIIIII)v; +__glewCopyMultiTexSubImage3DEXT(iiIIIIIIII)v; +__glewCopyTexImage1DEXT(iIiIIII)v; +__glewCopyTexImage2DEXT(iIiIIIII)v; +__glewCopyTexSubImage1DEXT(iIIIII)v; +__glewCopyTexSubImage2DEXT(iIIIIIII)v; +__glewCopyTexSubImage3D(iIIIIIIII)v; +__glewCopyTexSubImage3DEXT(iIIIIIIII)v; +__glewCopyTextureImage1DEXT(iiIiIIII)v; +__glewCopyTextureImage2DEXT(iiIiIIIII)v; +__glewCopyTextureSubImage1DEXT(iiIIIII)v; +__glewCopyTextureSubImage2DEXT(iiIIIIIII)v; +__glewCopyTextureSubImage3DEXT(iiIIIIIIII)v; +__glewCreateProgram()i; +__glewCreateProgramObjectARB()i; +__glewCreateShader(i)i; +__glewCreateShaderObjectARB(i)i; +__glewCullParameterdvEXT(ip)v; +__glewCullParameterfvEXT(ip)v; +__glewCurrentPaletteMatrixARB(I)v; +__glewDeleteAsyncMarkersSGIX(iI)v; +__glewDeleteBufferRegionEXT(i)v; +__glewDeleteBuffers(Ip)v; +__glewDeleteBuffersARB(Ip)v; +__glewDeleteFencesAPPLE(Ip)v; +__glewDeleteFencesNV(Ip)v; +__glewDeleteFragmentShaderATI(i)v; +__glewDeleteFramebuffers(Ip)v; +__glewDeleteFramebuffersEXT(Ip)v; +__glewDeleteObjectARB(i)v; +__glewDeleteOcclusionQueriesNV(Ip)v; +__glewDeleteProgram(i)v; +__glewDeleteProgramsARB(Ip)v; +__glewDeleteProgramsNV(Ip)v; +__glewDeleteQueries(Ip)v; +__glewDeleteQueriesARB(Ip)v; +__glewDeleteRenderbuffers(Ip)v; +__glewDeleteRenderbuffersEXT(Ip)v; +__glewDeleteShader(i)v; +__glewDeleteTexturesEXT(Ip)v; +__glewDeleteVertexArrays(Ip)v; +__glewDeleteVertexArraysAPPLE(Ip)v; +__glewDeleteVertexShaderEXT(i)v; +__glewDepthBoundsEXT(dd)v; +__glewDepthBoundsdNV(dd)v; +__glewDepthRangedNV(dd)v; +__glewDepthRangefOES(ff)v; +__glewDetachObjectARB(ii)v; +__glewDetachShader(ii)v; +__glewDetailTexFuncSGIS(iIp)v; +__glewDisableClientStateIndexedEXT(ii)v; +__glewDisableIndexedEXT(ii)v; +__glewDisableVariantClientStateEXT(i)v; +__glewDisableVertexAttribArray(i)v; +__glewDisableVertexAttribArrayARB(i)v; +__glewDisablei(ii)v; +__glewDrawArraysEXT(iII)v; +__glewDrawArraysInstancedARB(iIII)v; +__glewDrawArraysInstancedEXT(iIII)v; +__glewDrawBufferRegionEXT(iIIIIII)v; +__glewDrawBuffers(Ip)v; +__glewDrawBuffersARB(Ip)v; +__glewDrawBuffersATI(Ip)v; +__glewDrawElementArrayAPPLE(iII)v; +__glewDrawElementArrayATI(iI)v; +__glewDrawElementsInstancedARB(iIipI)v; +__glewDrawElementsInstancedEXT(iIipI)v; +__glewDrawRangeElementArrayAPPLE(iiiII)v; +__glewDrawRangeElementArrayATI(iiiI)v; +__glewDrawRangeElements(iiiIip)v; +__glewDrawRangeElementsEXT(iiiIip)v; +__glewEdgeFlagPointerEXT(IIp)v; +__glewEdgeFlagPointerListIBM(IpI)v; +__glewElementPointerAPPLE(ip)v; +__glewElementPointerATI(ip)v; +__glewEnableClientStateIndexedEXT(ii)v; +__glewEnableIndexedEXT(ii)v; +__glewEnableVariantClientStateEXT(i)v; +__glewEnableVertexAttribArray(i)v; +__glewEnableVertexAttribArrayARB(i)v; +__glewEnablei(ii)v; +__glewEndConditionalRender()v; +__glewEndConditionalRenderNV()v; +__glewEndFragmentShaderATI()v; +__glewEndOcclusionQueryNV()v; +__glewEndQuery(i)v; +__glewEndQueryARB(i)v; +__glewEndSceneEXT()v; +__glewEndTransformFeedback()v; +__glewEndTransformFeedbackEXT()v; +__glewEndTransformFeedbackNV()v; +__glewEndVertexShaderEXT()v; +__glewEvalMapsNV(ii)v; +__glewExecuteProgramNV(iip)v; +__glewExtractComponentEXT(iii)v; +__glewFinalCombinerInputNV(iiii)v; +__glewFinishAsyncSGIX(p)I; +__glewFinishFenceAPPLE(i)v; +__glewFinishFenceNV(i)v; +__glewFinishObjectAPPLE(iI)v; +__glewFinishTextureSUNX()v; +__glewFlushMappedBufferRange(iII)v; +__glewFlushMappedBufferRangeAPPLE(iII)v; +__glewFlushPixelDataRangeNV(i)v; +__glewFlushRasterSGIX()v; +__glewFlushVertexArrayRangeAPPLE(Ip)v; +__glewFlushVertexArrayRangeNV()v; +__glewFogCoordPointer(iIp)v; +__glewFogCoordPointerEXT(iIp)v; +__glewFogCoordPointerListIBM(iIpI)v; +__glewFogCoordd(d)v; +__glewFogCoorddEXT(d)v; +__glewFogCoorddv(p)v; +__glewFogCoorddvEXT(p)v; +__glewFogCoordf(f)v; +__glewFogCoordfEXT(f)v; +__glewFogCoordfv(p)v; +__glewFogCoordfvEXT(p)v; +__glewFogCoordhNV(s)v; +__glewFogCoordhvNV(p)v; +__glewFogFuncSGIS(Ip)v; +__glewFragmentColorMaterialEXT(ii)v; +__glewFragmentColorMaterialSGIX(ii)v; +__glewFragmentLightModelfEXT(if)v; +__glewFragmentLightModelfSGIX(if)v; +__glewFragmentLightModelfvEXT(ip)v; +__glewFragmentLightModelfvSGIX(ip)v; +__glewFragmentLightModeliEXT(iI)v; +__glewFragmentLightModeliSGIX(iI)v; +__glewFragmentLightModelivEXT(ip)v; +__glewFragmentLightModelivSGIX(ip)v; +__glewFragmentLightfEXT(iif)v; +__glewFragmentLightfSGIX(iif)v; +__glewFragmentLightfvEXT(iip)v; +__glewFragmentLightfvSGIX(iip)v; +__glewFragmentLightiEXT(iiI)v; +__glewFragmentLightiSGIX(iiI)v; +__glewFragmentLightivEXT(iip)v; +__glewFragmentLightivSGIX(iip)v; +__glewFragmentMaterialfEXT(iif)v; +__glewFragmentMaterialfSGIX(iif)v; +__glewFragmentMaterialfvEXT(iip)v; +__glewFragmentMaterialfvSGIX(iip)v; +__glewFragmentMaterialiEXT(iiI)v; +__glewFragmentMaterialiSGIX(iiI)v; +__glewFragmentMaterialivEXT(iip)v; +__glewFragmentMaterialivSGIX(iip)v; +__glewFrameTerminatorGREMEDY()v; +__glewFrameZoomSGIX(I)v; +__glewFramebufferDrawBufferEXT(ii)v; +__glewFramebufferDrawBuffersEXT(iIp)v; +__glewFramebufferReadBufferEXT(ii)v; +__glewFramebufferRenderbuffer(iiii)v; +__glewFramebufferRenderbufferEXT(iiii)v; +__glewFramebufferTexturLayer(iiiII)v; +__glewFramebufferTexture1D(iiiiI)v; +__glewFramebufferTexture1DEXT(iiiiI)v; +__glewFramebufferTexture2D(iiiiI)v; +__glewFramebufferTexture2DEXT(iiiiI)v; +__glewFramebufferTexture3D(iiiiII)v; +__glewFramebufferTexture3DEXT(iiiiII)v; +__glewFramebufferTextureARB(iiiI)v; +__glewFramebufferTextureEXT(iiiI)v; +__glewFramebufferTextureFaceARB(iiiIi)v; +__glewFramebufferTextureFaceEXT(iiiIi)v; +__glewFramebufferTextureLayerARB(iiiII)v; +__glewFramebufferTextureLayerEXT(iiiII)v; +__glewFreeObjectBufferATI(i)v; +__glewFrustumfOES(ffffff)v; +__glewGenAsyncMarkersSGIX(I)i; +__glewGenBuffers(Ip)v; +__glewGenBuffersARB(Ip)v; +__glewGenFencesAPPLE(Ip)v; +__glewGenFencesNV(Ip)v; +__glewGenFragmentShadersATI(i)i; +__glewGenFramebuffers(Ip)v; +__glewGenFramebuffersEXT(Ip)v; +__glewGenOcclusionQueriesNV(Ip)v; +__glewGenProgramsARB(Ip)v; +__glewGenProgramsNV(Ip)v; +__glewGenQueries(Ip)v; +__glewGenQueriesARB(Ip)v; +__glewGenRenderbuffers(Ip)v; +__glewGenRenderbuffersEXT(Ip)v; +__glewGenSymbolsEXT(iiii)i; +__glewGenTexturesEXT(Ip)v; +__glewGenVertexArrays(Ip)v; +__glewGenVertexArraysAPPLE(Ip)v; +__glewGenVertexShadersEXT(i)i; +__glewGenerateMipmap(i)v; +__glewGenerateMipmapEXT(i)v; +__glewGenerateMultiTexMipmapEXT(ii)v; +__glewGenerateTextureMipmapEXT(ii)v; +__glewGetActiveAttrib(iiIpppp)v; +__glewGetActiveAttribARB(iiIpppp)v; +__glewGetActiveUniform(iiIpppp)v; +__glewGetActiveUniformARB(iiIpppp)v; +__glewGetActiveVaryingNV(iiIpppp)v; +__glewGetArrayObjectfvATI(iip)v; +__glewGetArrayObjectivATI(iip)v; +__glewGetAttachedObjectsARB(iIpp)v; +__glewGetAttachedShaders(iIpp)v; +__glewGetAttribLocation(ip)I; +__glewGetAttribLocationARB(ip)I; +__glewGetBooleanIndexedvEXT(iip)v; +__glewGetBooleani_v(iip)v; +__glewGetBufferParameteriv(iip)v; +__glewGetBufferParameterivARB(iip)v; +__glewGetBufferPointerv(iip)v; +__glewGetBufferPointervARB(iip)v; +__glewGetBufferSubData(iIIp)v; +__glewGetBufferSubDataARB(iIIp)v; +__glewGetClipPlanefOES(ip)v; +__glewGetColorTable(iiip)v; +__glewGetColorTableEXT(iiip)v; +__glewGetColorTableParameterfv(iip)v; +__glewGetColorTableParameterfvEXT(iip)v; +__glewGetColorTableParameterfvSGI(iip)v; +__glewGetColorTableParameteriv(iip)v; +__glewGetColorTableParameterivEXT(iip)v; +__glewGetColorTableParameterivSGI(iip)v; +__glewGetColorTableSGI(iiip)v; +__glewGetCombinerInputParameterfvNV(iiiip)v; +__glewGetCombinerInputParameterivNV(iiiip)v; +__glewGetCombinerOutputParameterfvNV(iiip)v; +__glewGetCombinerOutputParameterivNV(iiip)v; +__glewGetCombinerStageParameterfvNV(iip)v; +__glewGetCompressedMultiTexImageEXT(iiIp)v; +__glewGetCompressedTexImage(iIp)v; +__glewGetCompressedTexImageARB(iIp)v; +__glewGetCompressedTextureImageEXT(iiIp)v; +__glewGetConvolutionFilter(iiip)v; +__glewGetConvolutionFilterEXT(iiip)v; +__glewGetConvolutionParameterfv(iip)v; +__glewGetConvolutionParameterfvEXT(iip)v; +__glewGetConvolutionParameteriv(iip)v; +__glewGetConvolutionParameterivEXT(iip)v; +__glewGetDetailTexFuncSGIS(ip)v; +__glewGetDoubleIndexedvEXT(iip)v; +__glewGetFenceivNV(iip)v; +__glewGetFinalCombinerInputParameterfvNV(iip)v; +__glewGetFinalCombinerInputParameterivNV(iip)v; +__glewGetFloatIndexedvEXT(iip)v; +__glewGetFogFuncSGIS(p)v; +__glewGetFragDataLocation(ip)I; +__glewGetFragDataLocationEXT(ip)I; +__glewGetFragmentLightfvEXT(iip)v; +__glewGetFragmentLightfvSGIX(iip)v; +__glewGetFragmentLightivEXT(iip)v; +__glewGetFragmentLightivSGIX(iip)v; +__glewGetFragmentMaterialfvEXT(iip)v; +__glewGetFragmentMaterialfvSGIX(iip)v; +__glewGetFragmentMaterialivEXT(iip)v; +__glewGetFragmentMaterialivSGIX(iip)v; +__glewGetFramebufferAttachmentParameteriv(iiip)v; +__glewGetFramebufferAttachmentParameterivEXT(iiip)v; +__glewGetFramebufferParameterivEXT(iip)v; +__glewGetHandleARB(i)i; +__glewGetHistogram(iciip)v; +__glewGetHistogramEXT(iciip)v; +__glewGetHistogramParameterfv(iip)v; +__glewGetHistogramParameterfvEXT(iip)v; +__glewGetHistogramParameteriv(iip)v; +__glewGetHistogramParameterivEXT(iip)v; +__glewGetImageTransformParameterfvHP(iip)v; +__glewGetImageTransformParameterivHP(iip)v; +__glewGetInfoLogARB(iIpp)v; +__glewGetIntegerIndexedvEXT(iip)v; +__glewGetIntegeri_v(iip)v; +__glewGetInvariantBooleanvEXT(iip)v; +__glewGetInvariantFloatvEXT(iip)v; +__glewGetInvariantIntegervEXT(iip)v; +__glewGetLocalConstantBooleanvEXT(iip)v; +__glewGetLocalConstantFloatvEXT(iip)v; +__glewGetLocalConstantIntegervEXT(iip)v; +__glewGetMapAttribParameterfvNV(iiip)v; +__glewGetMapAttribParameterivNV(iiip)v; +__glewGetMapControlPointsNV(iiiIIcp)v; +__glewGetMapParameterfvNV(iip)v; +__glewGetMapParameterivNV(iip)v; +__glewGetMinmax(iciip)v; +__glewGetMinmaxEXT(iciip)v; +__glewGetMinmaxParameterfv(iip)v; +__glewGetMinmaxParameterfvEXT(iip)v; +__glewGetMinmaxParameteriv(iip)v; +__glewGetMinmaxParameterivEXT(iip)v; +__glewGetMultiTexEnvfvEXT(iiip)v; +__glewGetMultiTexEnvivEXT(iiip)v; +__glewGetMultiTexGendvEXT(iiip)v; +__glewGetMultiTexGenfvEXT(iiip)v; +__glewGetMultiTexGenivEXT(iiip)v; +__glewGetMultiTexImageEXT(iiIiip)v; +__glewGetMultiTexLevelParameterfvEXT(iiIip)v; +__glewGetMultiTexLevelParameterivEXT(iiIip)v; +__glewGetMultiTexParameterIivEXT(iiip)v; +__glewGetMultiTexParameterIuivEXT(iiip)v; +__glewGetMultiTexParameterfvEXT(iiip)v; +__glewGetMultiTexParameterivEXT(iiip)v; +__glewGetMultisamplefvNV(iip)v; +__glewGetNamedBufferParameterivEXT(iip)v; +__glewGetNamedBufferPointervEXT(iip)v; +__glewGetNamedBufferSubDataEXT(iIIp)v; +__glewGetNamedFramebufferAttachmentParameterivEXT(iiip)v; +__glewGetNamedProgramLocalParameterIivEXT(iiip)v; +__glewGetNamedProgramLocalParameterIuivEXT(iiip)v; +__glewGetNamedProgramLocalParameterdvEXT(iiip)v; +__glewGetNamedProgramLocalParameterfvEXT(iiip)v; +__glewGetNamedProgramStringEXT(iiip)v; +__glewGetNamedProgramivEXT(iiip)v; +__glewGetNamedRenderbufferParameterivEXT(iip)v; +__glewGetObjectBufferfvATI(iip)v; +__glewGetObjectBufferivATI(iip)v; +__glewGetObjectParameterfvARB(iip)v; +__glewGetObjectParameterivARB(iip)v; +__glewGetOcclusionQueryivNV(iip)v; +__glewGetOcclusionQueryuivNV(iip)v; +__glewGetPixelTransformParameterfvEXT(iip)v; +__glewGetPixelTransformParameterivEXT(iip)v; +__glewGetPointerIndexedvEXT(iip)v; +__glewGetPointervEXT(ip)v; +__glewGetProgramEnvParameterdvARB(iip)v; +__glewGetProgramEnvParameterfvARB(iip)v; +__glewGetProgramInfoLog(iIpp)v; +__glewGetProgramLocalParameterdvARB(iip)v; +__glewGetProgramLocalParameterfvARB(iip)v; +__glewGetProgramNamedParameterdvNV(iIpp)v; +__glewGetProgramNamedParameterfvNV(iIpp)v; +__glewGetProgramParameterdvNV(iiip)v; +__glewGetProgramParameterfvNV(iiip)v; +__glewGetProgramStringARB(iip)v; +__glewGetProgramStringNV(iip)v; +__glewGetProgramiv(iip)v; +__glewGetProgramivARB(iip)v; +__glewGetProgramivNV(iip)v; +__glewGetQueryObjecti64vEXT(iip)v; +__glewGetQueryObjectiv(iip)v; +__glewGetQueryObjectivARB(iip)v; +__glewGetQueryObjectui64vEXT(iip)v; +__glewGetQueryObjectuiv(iip)v; +__glewGetQueryObjectuivARB(iip)v; +__glewGetQueryiv(iip)v; +__glewGetQueryivARB(iip)v; +__glewGetRenderbufferParameteriv(iip)v; +__glewGetRenderbufferParameterivEXT(iip)v; +__glewGetSeparableFilter(iiippp)v; +__glewGetSeparableFilterEXT(iiippp)v; +__glewGetShaderInfoLog(iIpp)v; +__glewGetShaderSource(IIpp)v; +__glewGetShaderSourceARB(iIpp)v; +__glewGetShaderiv(iip)v; +__glewGetSharpenTexFuncSGIS(ip)v; +__glewGetStringi(ii)p; +__glewGetTexBumpParameterfvATI(ip)v; +__glewGetTexBumpParameterivATI(ip)v; +__glewGetTexFilterFuncSGIS(iip)v; +__glewGetTexParameterIiv(iip)v; +__glewGetTexParameterIivEXT(iip)v; +__glewGetTexParameterIuiv(iip)v; +__glewGetTexParameterIuivEXT(iip)v; +__glewGetTexParameterPointervAPPLE(iip)v; +__glewGetTextureImageEXT(iiIiip)v; +__glewGetTextureLevelParameterfvEXT(iiIip)v; +__glewGetTextureLevelParameterivEXT(iiIip)v; +__glewGetTextureParameterIivEXT(iiip)v; +__glewGetTextureParameterIuivEXT(iiip)v; +__glewGetTextureParameterfvEXT(iiip)v; +__glewGetTextureParameterivEXT(iiip)v; +__glewGetTrackMatrixivNV(iiip)v; +__glewGetTransformFeedbackVarying(iip)v; +__glewGetTransformFeedbackVaryingEXT(iiIpppp)v; +__glewGetTransformFeedbackVaryingNV(iip)v; +__glewGetUniformBufferSizeEXT(iI)I; +__glewGetUniformLocation(ip)I; +__glewGetUniformLocationARB(ip)I; +__glewGetUniformOffsetEXT(iI)I; +__glewGetUniformfv(iIp)v; +__glewGetUniformfvARB(iIp)v; +__glewGetUniformiv(iIp)v; +__glewGetUniformivARB(iIp)v; +__glewGetUniformuiv(iIp)v; +__glewGetUniformuivEXT(iIp)v; +__glewGetVariantArrayObjectfvATI(iip)v; +__glewGetVariantArrayObjectivATI(iip)v; +__glewGetVariantBooleanvEXT(iip)v; +__glewGetVariantFloatvEXT(iip)v; +__glewGetVariantIntegervEXT(iip)v; +__glewGetVariantPointervEXT(iip)v; +__glewGetVaryingLocationNV(ip)I; +__glewGetVertexAttribArrayObjectfvATI(iip)v; +__glewGetVertexAttribArrayObjectivATI(iip)v; +__glewGetVertexAttribIiv(iip)v; +__glewGetVertexAttribIivEXT(iip)v; +__glewGetVertexAttribIuiv(iip)v; +__glewGetVertexAttribIuivEXT(iip)v; +__glewGetVertexAttribPointerv(iip)v; +__glewGetVertexAttribPointervARB(iip)v; +__glewGetVertexAttribPointervNV(iip)v; +__glewGetVertexAttribdv(iip)v; +__glewGetVertexAttribdvARB(iip)v; +__glewGetVertexAttribdvNV(iip)v; +__glewGetVertexAttribfv(iip)v; +__glewGetVertexAttribfvARB(iip)v; +__glewGetVertexAttribfvNV(iip)v; +__glewGetVertexAttribiv(iip)v; +__glewGetVertexAttribivARB(iip)v; +__glewGetVertexAttribivNV(iip)v; +__glewGetVideoi64vNV(iip)v; +__glewGetVideoivNV(iip)v; +__glewGetVideoui64vNV(iip)v; +__glewGetVideouivNV(iip)v; +__glewGlobalAlphaFactorbSUN(C)v; +__glewGlobalAlphaFactordSUN(d)v; +__glewGlobalAlphaFactorfSUN(f)v; +__glewGlobalAlphaFactoriSUN(I)v; +__glewGlobalAlphaFactorsSUN(S)v; +__glewGlobalAlphaFactorubSUN(c)v; +__glewGlobalAlphaFactoruiSUN(i)v; +__glewGlobalAlphaFactorusSUN(s)v; +__glewHistogram(iIic)v; +__glewHistogramEXT(iIic)v; +__glewImageTransformParameterfHP(iif)v; +__glewImageTransformParameterfvHP(iip)v; +__glewImageTransformParameteriHP(iiI)v; +__glewImageTransformParameterivHP(iip)v; +__glewIndexFuncEXT(if)v; +__glewIndexMaterialEXT(ii)v; +__glewIndexPointerEXT(iIIp)v; +__glewIndexPointerListIBM(iIpI)v; +__glewInsertComponentEXT(iii)v; +__glewIsAsyncMarkerSGIX(i)c; +__glewIsBuffer(i)c; +__glewIsBufferARB(i)c; +__glewIsEnabledIndexedEXT(ii)c; +__glewIsEnabledi(ii)c; +__glewIsFenceAPPLE(i)c; +__glewIsFenceNV(i)c; +__glewIsFramebuffer(i)c; +__glewIsFramebufferEXT(i)c; +__glewIsObjectBufferATI(i)c; +__glewIsOcclusionQueryNV(i)c; +__glewIsProgram(i)c; +__glewIsProgramARB(i)c; +__glewIsProgramNV(i)c; +__glewIsQuery(i)c; +__glewIsQueryARB(i)c; +__glewIsRenderbuffer(i)c; +__glewIsRenderbufferEXT(i)c; +__glewIsShader(i)c; +__glewIsTextureEXT(i)c; +__glewIsVariantEnabledEXT(ii)c; +__glewIsVertexArray(i)c; +__glewIsVertexArrayAPPLE(i)c; +__glewLightEnviEXT(iI)v; +__glewLinkProgram(i)v; +__glewLinkProgramARB(i)v; +__glewLoadProgramNV(iiIp)v; +__glewLoadTransposeMatrixd(p)v; +__glewLoadTransposeMatrixdARB(p)v; +__glewLoadTransposeMatrixf(p)v; +__glewLoadTransposeMatrixfARB(p)v; +__glewLockArraysEXT(II)v; +__glewMapBuffer(ii)p; +__glewMapBufferARB(ii)p; +__glewMapBufferRange(iIIi)p; +__glewMapControlPointsNV(iiiIIIIcp)v; +__glewMapNamedBufferEXT(ii)p; +__glewMapObjectBufferATI(i)p; +__glewMapParameterfvNV(iip)v; +__glewMapParameterivNV(iip)v; +__glewMatrixFrustumEXT(idddddd)v; +__glewMatrixIndexPointerARB(IiIp)v; +__glewMatrixIndexubvARB(Ip)v; +__glewMatrixIndexuivARB(Ip)v; +__glewMatrixIndexusvARB(Ip)v; +__glewMatrixLoadIdentityEXT(i)v; +__glewMatrixLoadTransposedEXT(ip)v; +__glewMatrixLoadTransposefEXT(ip)v; +__glewMatrixLoaddEXT(ip)v; +__glewMatrixLoadfEXT(ip)v; +__glewMatrixMultTransposedEXT(ip)v; +__glewMatrixMultTransposefEXT(ip)v; +__glewMatrixMultdEXT(ip)v; +__glewMatrixMultfEXT(ip)v; +__glewMatrixOrthoEXT(idddddd)v; +__glewMatrixPopEXT(i)v; +__glewMatrixPushEXT(i)v; +__glewMatrixRotatedEXT(idddd)v; +__glewMatrixRotatefEXT(iffff)v; +__glewMatrixScaledEXT(iddd)v; +__glewMatrixScalefEXT(ifff)v; +__glewMatrixTranslatedEXT(iddd)v; +__glewMatrixTranslatefEXT(ifff)v; +__glewMinmax(iic)v; +__glewMinmaxEXT(iic)v; +__glewMultTransposeMatrixd(p)v; +__glewMultTransposeMatrixdARB(p)v; +__glewMultTransposeMatrixf(p)v; +__glewMultTransposeMatrixfARB(p)v; +__glewMultiDrawArrays(ippI)v; +__glewMultiDrawArraysEXT(ippI)v; +__glewMultiDrawElementArrayAPPLE(ippI)v; +__glewMultiDrawElements(ipipI)v; +__glewMultiDrawElementsEXT(ipipI)v; +__glewMultiDrawRangeElementArrayAPPLE(iiippI)v; +__glewMultiModeDrawArraysIBM(pppII)v; +__glewMultiModeDrawElementsIBM(ppipII)v; +__glewMultiTexBufferEXT(iiii)v; +__glewMultiTexCoord1d(id)v; +__glewMultiTexCoord1dARB(id)v; +__glewMultiTexCoord1dv(ip)v; +__glewMultiTexCoord1dvARB(ip)v; +__glewMultiTexCoord1f(if)v; +__glewMultiTexCoord1fARB(if)v; +__glewMultiTexCoord1fv(ip)v; +__glewMultiTexCoord1fvARB(ip)v; +__glewMultiTexCoord1hNV(is)v; +__glewMultiTexCoord1hvNV(ip)v; +__glewMultiTexCoord1i(iI)v; +__glewMultiTexCoord1iARB(iI)v; +__glewMultiTexCoord1iv(ip)v; +__glewMultiTexCoord1ivARB(ip)v; +__glewMultiTexCoord1s(iS)v; +__glewMultiTexCoord1sARB(iS)v; +__glewMultiTexCoord1sv(ip)v; +__glewMultiTexCoord1svARB(ip)v; +__glewMultiTexCoord2d(idd)v; +__glewMultiTexCoord2dARB(idd)v; +__glewMultiTexCoord2dv(ip)v; +__glewMultiTexCoord2dvARB(ip)v; +__glewMultiTexCoord2f(iff)v; +__glewMultiTexCoord2fARB(iff)v; +__glewMultiTexCoord2fv(ip)v; +__glewMultiTexCoord2fvARB(ip)v; +__glewMultiTexCoord2hNV(iss)v; +__glewMultiTexCoord2hvNV(ip)v; +__glewMultiTexCoord2i(iII)v; +__glewMultiTexCoord2iARB(iII)v; +__glewMultiTexCoord2iv(ip)v; +__glewMultiTexCoord2ivARB(ip)v; +__glewMultiTexCoord2s(iSS)v; +__glewMultiTexCoord2sARB(iSS)v; +__glewMultiTexCoord2sv(ip)v; +__glewMultiTexCoord2svARB(ip)v; +__glewMultiTexCoord3d(iddd)v; +__glewMultiTexCoord3dARB(iddd)v; +__glewMultiTexCoord3dv(ip)v; +__glewMultiTexCoord3dvARB(ip)v; +__glewMultiTexCoord3f(ifff)v; +__glewMultiTexCoord3fARB(ifff)v; +__glewMultiTexCoord3fv(ip)v; +__glewMultiTexCoord3fvARB(ip)v; +__glewMultiTexCoord3hNV(isss)v; +__glewMultiTexCoord3hvNV(ip)v; +__glewMultiTexCoord3i(iIII)v; +__glewMultiTexCoord3iARB(iIII)v; +__glewMultiTexCoord3iv(ip)v; +__glewMultiTexCoord3ivARB(ip)v; +__glewMultiTexCoord3s(iSSS)v; +__glewMultiTexCoord3sARB(iSSS)v; +__glewMultiTexCoord3sv(ip)v; +__glewMultiTexCoord3svARB(ip)v; +__glewMultiTexCoord4d(idddd)v; +__glewMultiTexCoord4dARB(idddd)v; +__glewMultiTexCoord4dv(ip)v; +__glewMultiTexCoord4dvARB(ip)v; +__glewMultiTexCoord4f(iffff)v; +__glewMultiTexCoord4fARB(iffff)v; +__glewMultiTexCoord4fv(ip)v; +__glewMultiTexCoord4fvARB(ip)v; +__glewMultiTexCoord4hNV(issss)v; +__glewMultiTexCoord4hvNV(ip)v; +__glewMultiTexCoord4i(iIIII)v; +__glewMultiTexCoord4iARB(iIIII)v; +__glewMultiTexCoord4iv(ip)v; +__glewMultiTexCoord4ivARB(ip)v; +__glewMultiTexCoord4s(iSSSS)v; +__glewMultiTexCoord4sARB(iSSSS)v; +__glewMultiTexCoord4sv(ip)v; +__glewMultiTexCoord4svARB(ip)v; +__glewMultiTexCoordPointerEXT(iIiIp)v; +__glewMultiTexEnvfEXT(iiif)v; +__glewMultiTexEnvfvEXT(iiip)v; +__glewMultiTexEnviEXT(iiiI)v; +__glewMultiTexEnvivEXT(iiip)v; +__glewMultiTexGendEXT(iiid)v; +__glewMultiTexGendvEXT(iiip)v; +__glewMultiTexGenfEXT(iiif)v; +__glewMultiTexGenfvEXT(iiip)v; +__glewMultiTexGeniEXT(iiiI)v; +__glewMultiTexGenivEXT(iiip)v; +__glewMultiTexImage1DEXT(iiIIIIiip)v; +__glewMultiTexImage2DEXT(iiIIIIIiip)v; +__glewMultiTexImage3DEXT(iiIIIIIIiip)v; +__glewMultiTexParameterIivEXT(iiip)v; +__glewMultiTexParameterIuivEXT(iiip)v; +__glewMultiTexParameterfEXT(iiif)v; +__glewMultiTexParameterfvEXT(iiip)v; +__glewMultiTexParameteriEXT(iiiI)v; +__glewMultiTexParameterivEXT(iiip)v; +__glewMultiTexRenderbufferEXT(iii)v; +__glewMultiTexSubImage1DEXT(iiIIIiip)v; +__glewMultiTexSubImage2DEXT(iiIIIIIiip)v; +__glewMultiTexSubImage3DEXT(iiIIIIIIIiip)v; +__glewNamedBufferDataEXT(iIpi)v; +__glewNamedBufferSubDataEXT(iIIp)v; +__glewNamedFramebufferRenderbufferEXT(iiii)v; +__glewNamedFramebufferTexture1DEXT(iiiiI)v; +__glewNamedFramebufferTexture2DEXT(iiiiI)v; +__glewNamedFramebufferTexture3DEXT(iiiiII)v; +__glewNamedFramebufferTextureEXT(iiiI)v; +__glewNamedFramebufferTextureFaceEXT(iiiIi)v; +__glewNamedFramebufferTextureLayerEXT(iiiII)v; +__glewNamedProgramLocalParameter4dEXT(iiidddd)v; +__glewNamedProgramLocalParameter4dvEXT(iiip)v; +__glewNamedProgramLocalParameter4fEXT(iiiffff)v; +__glewNamedProgramLocalParameter4fvEXT(iiip)v; +__glewNamedProgramLocalParameterI4iEXT(iiiIIII)v; +__glewNamedProgramLocalParameterI4ivEXT(iiip)v; +__glewNamedProgramLocalParameterI4uiEXT(iiiiiii)v; +__glewNamedProgramLocalParameterI4uivEXT(iiip)v; +__glewNamedProgramLocalParameters4fvEXT(iiiIp)v; +__glewNamedProgramLocalParametersI4ivEXT(iiiIp)v; +__glewNamedProgramLocalParametersI4uivEXT(iiiIp)v; +__glewNamedProgramStringEXT(iiiIp)v; +__glewNamedRenderbufferStorageEXT(iiII)v; +__glewNamedRenderbufferStorageMultisampleCoverageEXT(iIIiII)v; +__glewNamedRenderbufferStorageMultisampleEXT(iIiII)v; +__glewNewBufferRegionEXT(i)i; +__glewNewObjectBufferATI(Ipi)i; +__glewNormal3fVertex3fSUN(ffffff)v; +__glewNormal3fVertex3fvSUN(pp)v; +__glewNormal3hNV(sss)v; +__glewNormal3hvNV(p)v; +__glewNormalPointerEXT(iIIp)v; +__glewNormalPointerListIBM(iIpI)v; +__glewNormalPointervINTEL(ip)v; +__glewNormalStream3bATI(iCCC)v; +__glewNormalStream3bvATI(ip)v; +__glewNormalStream3dATI(iddd)v; +__glewNormalStream3dvATI(ip)v; +__glewNormalStream3fATI(ifff)v; +__glewNormalStream3fvATI(ip)v; +__glewNormalStream3iATI(iIII)v; +__glewNormalStream3ivATI(ip)v; +__glewNormalStream3sATI(iSSS)v; +__glewNormalStream3svATI(ip)v; +__glewOrthofOES(ffffff)v; +__glewPassTexCoordATI(iii)v; +__glewPixelDataRangeNV(iIp)v; +__glewPixelTexGenSGIX(i)v; +__glewPixelTransformParameterfEXT(iif)v; +__glewPixelTransformParameterfvEXT(iip)v; +__glewPixelTransformParameteriEXT(iiI)v; +__glewPixelTransformParameterivEXT(iip)v; +__glewPointParameterf(if)v; +__glewPointParameterfARB(if)v; +__glewPointParameterfEXT(if)v; +__glewPointParameterfv(ip)v; +__glewPointParameterfvARB(ip)v; +__glewPointParameterfvEXT(ip)v; +__glewPointParameteri(iI)v; +__glewPointParameteriNV(iI)v; +__glewPointParameteriv(ip)v; +__glewPointParameterivNV(ip)v; +__glewPollAsyncSGIX(p)I; +__glewPolygonOffsetEXT(ff)v; +__glewPresentFrameDualFillNV(iliiiiiiiiiii)v; +__glewPresentFrameKeyedNV(iliiiiiiiii)v; +__glewPrimitiveRestartIndexNV(i)v; +__glewPrimitiveRestartNV()v; +__glewPrioritizeTexturesEXT(Ipp)v; +__glewProgramBufferParametersIivNV(iiiIp)v; +__glewProgramBufferParametersIuivNV(iiiIp)v; +__glewProgramBufferParametersfvNV(iiiIp)v; +__glewProgramEnvParameter4dARB(iidddd)v; +__glewProgramEnvParameter4dvARB(iip)v; +__glewProgramEnvParameter4fARB(iiffff)v; +__glewProgramEnvParameter4fvARB(iip)v; +__glewProgramEnvParameterI4iNV(iiIIII)v; +__glewProgramEnvParameterI4ivNV(iip)v; +__glewProgramEnvParameterI4uiNV(iiiiii)v; +__glewProgramEnvParameterI4uivNV(iip)v; +__glewProgramEnvParameters4fvEXT(iiIp)v; +__glewProgramEnvParametersI4ivNV(iiIp)v; +__glewProgramEnvParametersI4uivNV(iiIp)v; +__glewProgramLocalParameter4dARB(iidddd)v; +__glewProgramLocalParameter4dvARB(iip)v; +__glewProgramLocalParameter4fARB(iiffff)v; +__glewProgramLocalParameter4fvARB(iip)v; +__glewProgramLocalParameterI4iNV(iiIIII)v; +__glewProgramLocalParameterI4ivNV(iip)v; +__glewProgramLocalParameterI4uiNV(iiiiii)v; +__glewProgramLocalParameterI4uivNV(iip)v; +__glewProgramLocalParameters4fvEXT(iiIp)v; +__glewProgramLocalParametersI4ivNV(iiIp)v; +__glewProgramLocalParametersI4uivNV(iiIp)v; +__glewProgramNamedParameter4dNV(iIpdddd)v; +__glewProgramNamedParameter4dvNV(iIpp)v; +__glewProgramNamedParameter4fNV(iIpffff)v; +__glewProgramNamedParameter4fvNV(iIpp)v; +__glewProgramParameter4dNV(iidddd)v; +__glewProgramParameter4dvNV(iip)v; +__glewProgramParameter4fNV(iiffff)v; +__glewProgramParameter4fvNV(iip)v; +__glewProgramParameteriARB(iiI)v; +__glewProgramParameteriEXT(iiI)v; +__glewProgramParameters4dvNV(iiip)v; +__glewProgramParameters4fvNV(iiip)v; +__glewProgramStringARB(iiIp)v; +__glewProgramUniform1fEXT(iIf)v; +__glewProgramUniform1fvEXT(iIIp)v; +__glewProgramUniform1iEXT(iII)v; +__glewProgramUniform1ivEXT(iIIp)v; +__glewProgramUniform1uiEXT(iIi)v; +__glewProgramUniform1uivEXT(iIIp)v; +__glewProgramUniform2fEXT(iIff)v; +__glewProgramUniform2fvEXT(iIIp)v; +__glewProgramUniform2iEXT(iIII)v; +__glewProgramUniform2ivEXT(iIIp)v; +__glewProgramUniform2uiEXT(iIii)v; +__glewProgramUniform2uivEXT(iIIp)v; +__glewProgramUniform3fEXT(iIfff)v; +__glewProgramUniform3fvEXT(iIIp)v; +__glewProgramUniform3iEXT(iIIII)v; +__glewProgramUniform3ivEXT(iIIp)v; +__glewProgramUniform3uiEXT(iIiii)v; +__glewProgramUniform3uivEXT(iIIp)v; +__glewProgramUniform4fEXT(iIffff)v; +__glewProgramUniform4fvEXT(iIIp)v; +__glewProgramUniform4iEXT(iIIIII)v; +__glewProgramUniform4ivEXT(iIIp)v; +__glewProgramUniform4uiEXT(iIiiii)v; +__glewProgramUniform4uivEXT(iIIp)v; +__glewProgramUniformMatrix2fvEXT(iIIcp)v; +__glewProgramUniformMatrix2x3fvEXT(iIIcp)v; +__glewProgramUniformMatrix2x4fvEXT(iIIcp)v; +__glewProgramUniformMatrix3fvEXT(iIIcp)v; +__glewProgramUniformMatrix3x2fvEXT(iIIcp)v; +__glewProgramUniformMatrix3x4fvEXT(iIIcp)v; +__glewProgramUniformMatrix4fvEXT(iIIcp)v; +__glewProgramUniformMatrix4x2fvEXT(iIIcp)v; +__glewProgramUniformMatrix4x3fvEXT(iIIcp)v; +__glewProgramVertexLimitNV(iI)v; +__glewPushClientAttribDefaultEXT(i)v; +__glewReadBufferRegionEXT(iIIII)v; +__glewReadVideoPixelsSUN(IIIIiip)v; +__glewReferencePlaneSGIX(p)v; +__glewRenderbufferStorage(iiII)v; +__glewRenderbufferStorageEXT(iiII)v; +__glewRenderbufferStorageMultisample(iIiII)v; +__glewRenderbufferStorageMultisampleCoverageNV(iIIiII)v; +__glewRenderbufferStorageMultisampleEXT(iIiII)v; +__glewReplacementCodePointerSUN(iIp)v; +__glewReplacementCodeubSUN(c)v; +__glewReplacementCodeubvSUN(p)v; +__glewReplacementCodeuiColor3fVertex3fSUN(iffffff)v; +__glewReplacementCodeuiColor3fVertex3fvSUN(ppp)v; +__glewReplacementCodeuiColor4fNormal3fVertex3fSUN(iffffffffff)v; +__glewReplacementCodeuiColor4fNormal3fVertex3fvSUN(pppp)v; +__glewReplacementCodeuiColor4ubVertex3fSUN(iccccfff)v; +__glewReplacementCodeuiColor4ubVertex3fvSUN(ppp)v; +__glewReplacementCodeuiNormal3fVertex3fSUN(iffffff)v; +__glewReplacementCodeuiNormal3fVertex3fvSUN(ppp)v; +__glewReplacementCodeuiSUN(i)v; +__glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(iffffffffffff)v; +__glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ppppp)v; +__glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(iffffffff)v; +__glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(pppp)v; +__glewReplacementCodeuiTexCoord2fVertex3fSUN(ifffff)v; +__glewReplacementCodeuiTexCoord2fVertex3fvSUN(ppp)v; +__glewReplacementCodeuiVertex3fSUN(ifff)v; +__glewReplacementCodeuiVertex3fvSUN(pp)v; +__glewReplacementCodeuivSUN(p)v; +__glewReplacementCodeusSUN(s)v; +__glewReplacementCodeusvSUN(p)v; +__glewRequestResidentProgramsNV(Ip)v; +__glewResetHistogram(i)v; +__glewResetHistogramEXT(i)v; +__glewResetMinmax(i)v; +__glewResetMinmaxEXT(i)v; +__glewResizeBuffersMESA()v; +__glewSampleCoverage(fc)v; +__glewSampleCoverageARB(fc)v; +__glewSampleMapATI(iii)v; +__glewSampleMaskEXT(fc)v; +__glewSampleMaskIndexedNV(ii)v; +__glewSampleMaskSGIS(fc)v; +__glewSamplePatternEXT(i)v; +__glewSamplePatternSGIS(i)v; +__glewSecondaryColor3b(CCC)v; +__glewSecondaryColor3bEXT(CCC)v; +__glewSecondaryColor3bv(p)v; +__glewSecondaryColor3bvEXT(p)v; +__glewSecondaryColor3d(ddd)v; +__glewSecondaryColor3dEXT(ddd)v; +__glewSecondaryColor3dv(p)v; +__glewSecondaryColor3dvEXT(p)v; +__glewSecondaryColor3f(fff)v; +__glewSecondaryColor3fEXT(fff)v; +__glewSecondaryColor3fv(p)v; +__glewSecondaryColor3fvEXT(p)v; +__glewSecondaryColor3hNV(sss)v; +__glewSecondaryColor3hvNV(p)v; +__glewSecondaryColor3i(III)v; +__glewSecondaryColor3iEXT(III)v; +__glewSecondaryColor3iv(p)v; +__glewSecondaryColor3ivEXT(p)v; +__glewSecondaryColor3s(SSS)v; +__glewSecondaryColor3sEXT(SSS)v; +__glewSecondaryColor3sv(p)v; +__glewSecondaryColor3svEXT(p)v; +__glewSecondaryColor3ub(ccc)v; +__glewSecondaryColor3ubEXT(ccc)v; +__glewSecondaryColor3ubv(p)v; +__glewSecondaryColor3ubvEXT(p)v; +__glewSecondaryColor3ui(iii)v; +__glewSecondaryColor3uiEXT(iii)v; +__glewSecondaryColor3uiv(p)v; +__glewSecondaryColor3uivEXT(p)v; +__glewSecondaryColor3us(sss)v; +__glewSecondaryColor3usEXT(sss)v; +__glewSecondaryColor3usv(p)v; +__glewSecondaryColor3usvEXT(p)v; +__glewSecondaryColorPointer(IiIp)v; +__glewSecondaryColorPointerEXT(IiIp)v; +__glewSecondaryColorPointerListIBM(IiIpI)v; +__glewSeparableFilter2D(iiIIiipp)v; +__glewSeparableFilter2DEXT(iiIIiipp)v; +__glewSetFenceAPPLE(i)v; +__glewSetFenceNV(ii)v; +__glewSetFragmentShaderConstantATI(ip)v; +__glewSetInvariantEXT(iip)v; +__glewSetLocalConstantEXT(iip)v; +__glewShaderOp1EXT(iii)v; +__glewShaderOp2EXT(iiii)v; +__glewShaderOp3EXT(iiiii)v; +__glewShaderSource(iIpp)v; +__glewShaderSourceARB(iIpp)v; +__glewSharpenTexFuncSGIS(iIp)v; +__glewSpriteParameterfSGIX(if)v; +__glewSpriteParameterfvSGIX(ip)v; +__glewSpriteParameteriSGIX(iI)v; +__glewSpriteParameterivSGIX(ip)v; +__glewStencilFuncSeparate(iiIi)v; +__glewStencilFuncSeparateATI(iiIi)v; +__glewStencilMaskSeparate(ii)v; +__glewStencilOpSeparate(iiii)v; +__glewStencilOpSeparateATI(iiii)v; +__glewStringMarkerGREMEDY(Ip)v; +__glewSwizzleEXT(iiiiii)v; +__glewTagSampleBufferSGIX()v; +__glewTangentPointerEXT(iIp)v; +__glewTbufferMask3DFX(i)v; +__glewTestFenceAPPLE(i)c; +__glewTestFenceNV(i)c; +__glewTestObjectAPPLE(ii)c; +__glewTexBufferARB(iii)v; +__glewTexBufferEXT(iii)v; +__glewTexBumpParameterfvATI(ip)v; +__glewTexBumpParameterivATI(ip)v; +__glewTexCoord1hNV(s)v; +__glewTexCoord1hvNV(p)v; +__glewTexCoord2fColor3fVertex3fSUN(ffffffff)v; +__glewTexCoord2fColor3fVertex3fvSUN(ppp)v; +__glewTexCoord2fColor4fNormal3fVertex3fSUN(ffffffffffff)v; +__glewTexCoord2fColor4fNormal3fVertex3fvSUN(pppp)v; +__glewTexCoord2fColor4ubVertex3fSUN(ffccccfff)v; +__glewTexCoord2fColor4ubVertex3fvSUN(ppp)v; +__glewTexCoord2fNormal3fVertex3fSUN(ffffffff)v; +__glewTexCoord2fNormal3fVertex3fvSUN(ppp)v; +__glewTexCoord2fVertex3fSUN(fffff)v; +__glewTexCoord2fVertex3fvSUN(pp)v; +__glewTexCoord2hNV(ss)v; +__glewTexCoord2hvNV(p)v; +__glewTexCoord3hNV(sss)v; +__glewTexCoord3hvNV(p)v; +__glewTexCoord4fColor4fNormal3fVertex4fSUN(fffffffffffffff)v; +__glewTexCoord4fColor4fNormal3fVertex4fvSUN(pppp)v; +__glewTexCoord4fVertex4fSUN(ffffffff)v; +__glewTexCoord4fVertex4fvSUN(pp)v; +__glewTexCoord4hNV(ssss)v; +__glewTexCoord4hvNV(p)v; +__glewTexCoordPointerEXT(IiIIp)v; +__glewTexCoordPointerListIBM(IiIpI)v; +__glewTexCoordPointervINTEL(Iip)v; +__glewTexFilterFuncSGIS(iiIp)v; +__glewTexImage3D(iIIIIIIiip)v; +__glewTexImage3DEXT(iIiIIIIiip)v; +__glewTexImage4DSGIS(iIiIIIIIiip)v; +__glewTexParameterIiv(iip)v; +__glewTexParameterIivEXT(iip)v; +__glewTexParameterIuiv(iip)v; +__glewTexParameterIuivEXT(iip)v; +__glewTexRenderbufferNV(ii)v; +__glewTexScissorFuncINTEL(iii)v; +__glewTexScissorINTEL(iff)v; +__glewTexSubImage1DEXT(iIIIiip)v; +__glewTexSubImage2DEXT(iIIIIIiip)v; +__glewTexSubImage3D(iIIIIIIIiip)v; +__glewTexSubImage3DEXT(iIIIIIIIiip)v; +__glewTexSubImage4DSGIS(iIIIIIIIIIiip)v; +__glewTextureBufferEXT(iiii)v; +__glewTextureFogSGIX(i)v; +__glewTextureImage1DEXT(iiIIIIiip)v; +__glewTextureImage2DEXT(iiIIIIIiip)v; +__glewTextureImage3DEXT(iiIIIIIIiip)v; +__glewTextureLightEXT(i)v; +__glewTextureMaterialEXT(ii)v; +__glewTextureNormalEXT(i)v; +__glewTextureParameterIivEXT(iiip)v; +__glewTextureParameterIuivEXT(iiip)v; +__glewTextureParameterfEXT(iiif)v; +__glewTextureParameterfvEXT(iiip)v; +__glewTextureParameteriEXT(iiiI)v; +__glewTextureParameterivEXT(iiip)v; +__glewTextureRangeAPPLE(iIp)v; +__glewTextureRenderbufferEXT(iii)v; +__glewTextureSubImage1DEXT(iiIIIiip)v; +__glewTextureSubImage2DEXT(iiIIIIIiip)v; +__glewTextureSubImage3DEXT(iiIIIIIIIiip)v; +__glewTrackMatrixNV(iiii)v; +__glewTransformFeedbackAttribsNV(ipi)v; +__glewTransformFeedbackVaryings(iIpi)v; +__glewTransformFeedbackVaryingsEXT(iIpi)v; +__glewTransformFeedbackVaryingsNV(iIpi)v; +__glewUniform1f(If)v; +__glewUniform1fARB(If)v; +__glewUniform1fv(IIp)v; +__glewUniform1fvARB(IIp)v; +__glewUniform1i(II)v; +__glewUniform1iARB(II)v; +__glewUniform1iv(IIp)v; +__glewUniform1ivARB(IIp)v; +__glewUniform1ui(Ii)v; +__glewUniform1uiEXT(Ii)v; +__glewUniform1uiv(IIp)v; +__glewUniform1uivEXT(IIp)v; +__glewUniform2f(Iff)v; +__glewUniform2fARB(Iff)v; +__glewUniform2fv(IIp)v; +__glewUniform2fvARB(IIp)v; +__glewUniform2i(III)v; +__glewUniform2iARB(III)v; +__glewUniform2iv(IIp)v; +__glewUniform2ivARB(IIp)v; +__glewUniform2ui(Iii)v; +__glewUniform2uiEXT(Iii)v; +__glewUniform2uiv(IIp)v; +__glewUniform2uivEXT(IIp)v; +__glewUniform3f(Ifff)v; +__glewUniform3fARB(Ifff)v; +__glewUniform3fv(IIp)v; +__glewUniform3fvARB(IIp)v; +__glewUniform3i(IIII)v; +__glewUniform3iARB(IIII)v; +__glewUniform3iv(IIp)v; +__glewUniform3ivARB(IIp)v; +__glewUniform3ui(Iiii)v; +__glewUniform3uiEXT(Iiii)v; +__glewUniform3uiv(IIp)v; +__glewUniform3uivEXT(IIp)v; +__glewUniform4f(Iffff)v; +__glewUniform4fARB(Iffff)v; +__glewUniform4fv(IIp)v; +__glewUniform4fvARB(IIp)v; +__glewUniform4i(IIIII)v; +__glewUniform4iARB(IIIII)v; +__glewUniform4iv(IIp)v; +__glewUniform4ivARB(IIp)v; +__glewUniform4ui(Iiiii)v; +__glewUniform4uiEXT(Iiiii)v; +__glewUniform4uiv(IIp)v; +__glewUniform4uivEXT(IIp)v; +__glewUniformBufferEXT(iIi)v; +__glewUniformMatrix2fv(IIcp)v; +__glewUniformMatrix2fvARB(IIcp)v; +__glewUniformMatrix2x3fv(IIcp)v; +__glewUniformMatrix2x4fv(IIcp)v; +__glewUniformMatrix3fv(IIcp)v; +__glewUniformMatrix3fvARB(IIcp)v; +__glewUniformMatrix3x2fv(IIcp)v; +__glewUniformMatrix3x4fv(IIcp)v; +__glewUniformMatrix4fv(IIcp)v; +__glewUniformMatrix4fvARB(IIcp)v; +__glewUniformMatrix4x2fv(IIcp)v; +__glewUniformMatrix4x3fv(IIcp)v; +__glewUnlockArraysEXT()v; +__glewUnmapBuffer(i)c; +__glewUnmapBufferARB(i)c; +__glewUnmapNamedBufferEXT(i)c; +__glewUnmapObjectBufferATI(i)v; +__glewUpdateObjectBufferATI(iiIpi)v; +__glewUseProgram(i)v; +__glewUseProgramObjectARB(i)v; +__glewValidateProgram(i)v; +__glewValidateProgramARB(i)v; +__glewVariantArrayObjectATI(iiIii)v; +__glewVariantPointerEXT(iiip)v; +__glewVariantbvEXT(ip)v; +__glewVariantdvEXT(ip)v; +__glewVariantfvEXT(ip)v; +__glewVariantivEXT(ip)v; +__glewVariantsvEXT(ip)v; +__glewVariantubvEXT(ip)v; +__glewVariantuivEXT(ip)v; +__glewVariantusvEXT(ip)v; +__glewVertex2hNV(ss)v; +__glewVertex2hvNV(p)v; +__glewVertex3hNV(sss)v; +__glewVertex3hvNV(p)v; +__glewVertex4hNV(ssss)v; +__glewVertex4hvNV(p)v; +__glewVertexArrayParameteriAPPLE(iI)v; +__glewVertexArrayRangeAPPLE(Ip)v; +__glewVertexArrayRangeNV(Ip)v; +__glewVertexAttrib1d(id)v; +__glewVertexAttrib1dARB(id)v; +__glewVertexAttrib1dNV(id)v; +__glewVertexAttrib1dv(ip)v; +__glewVertexAttrib1dvARB(ip)v; +__glewVertexAttrib1dvNV(ip)v; +__glewVertexAttrib1f(if)v; +__glewVertexAttrib1fARB(if)v; +__glewVertexAttrib1fNV(if)v; +__glewVertexAttrib1fv(ip)v; +__glewVertexAttrib1fvARB(ip)v; +__glewVertexAttrib1fvNV(ip)v; +__glewVertexAttrib1hNV(is)v; +__glewVertexAttrib1hvNV(ip)v; +__glewVertexAttrib1s(iS)v; +__glewVertexAttrib1sARB(iS)v; +__glewVertexAttrib1sNV(iS)v; +__glewVertexAttrib1sv(ip)v; +__glewVertexAttrib1svARB(ip)v; +__glewVertexAttrib1svNV(ip)v; +__glewVertexAttrib2d(idd)v; +__glewVertexAttrib2dARB(idd)v; +__glewVertexAttrib2dNV(idd)v; +__glewVertexAttrib2dv(ip)v; +__glewVertexAttrib2dvARB(ip)v; +__glewVertexAttrib2dvNV(ip)v; +__glewVertexAttrib2f(iff)v; +__glewVertexAttrib2fARB(iff)v; +__glewVertexAttrib2fNV(iff)v; +__glewVertexAttrib2fv(ip)v; +__glewVertexAttrib2fvARB(ip)v; +__glewVertexAttrib2fvNV(ip)v; +__glewVertexAttrib2hNV(iss)v; +__glewVertexAttrib2hvNV(ip)v; +__glewVertexAttrib2s(iSS)v; +__glewVertexAttrib2sARB(iSS)v; +__glewVertexAttrib2sNV(iSS)v; +__glewVertexAttrib2sv(ip)v; +__glewVertexAttrib2svARB(ip)v; +__glewVertexAttrib2svNV(ip)v; +__glewVertexAttrib3d(iddd)v; +__glewVertexAttrib3dARB(iddd)v; +__glewVertexAttrib3dNV(iddd)v; +__glewVertexAttrib3dv(ip)v; +__glewVertexAttrib3dvARB(ip)v; +__glewVertexAttrib3dvNV(ip)v; +__glewVertexAttrib3f(ifff)v; +__glewVertexAttrib3fARB(ifff)v; +__glewVertexAttrib3fNV(ifff)v; +__glewVertexAttrib3fv(ip)v; +__glewVertexAttrib3fvARB(ip)v; +__glewVertexAttrib3fvNV(ip)v; +__glewVertexAttrib3hNV(isss)v; +__glewVertexAttrib3hvNV(ip)v; +__glewVertexAttrib3s(iSSS)v; +__glewVertexAttrib3sARB(iSSS)v; +__glewVertexAttrib3sNV(iSSS)v; +__glewVertexAttrib3sv(ip)v; +__glewVertexAttrib3svARB(ip)v; +__glewVertexAttrib3svNV(ip)v; +__glewVertexAttrib4Nbv(ip)v; +__glewVertexAttrib4NbvARB(ip)v; +__glewVertexAttrib4Niv(ip)v; +__glewVertexAttrib4NivARB(ip)v; +__glewVertexAttrib4Nsv(ip)v; +__glewVertexAttrib4NsvARB(ip)v; +__glewVertexAttrib4Nub(icccc)v; +__glewVertexAttrib4NubARB(icccc)v; +__glewVertexAttrib4Nubv(ip)v; +__glewVertexAttrib4NubvARB(ip)v; +__glewVertexAttrib4Nuiv(ip)v; +__glewVertexAttrib4NuivARB(ip)v; +__glewVertexAttrib4Nusv(ip)v; +__glewVertexAttrib4NusvARB(ip)v; +__glewVertexAttrib4bv(ip)v; +__glewVertexAttrib4bvARB(ip)v; +__glewVertexAttrib4d(idddd)v; +__glewVertexAttrib4dARB(idddd)v; +__glewVertexAttrib4dNV(idddd)v; +__glewVertexAttrib4dv(ip)v; +__glewVertexAttrib4dvARB(ip)v; +__glewVertexAttrib4dvNV(ip)v; +__glewVertexAttrib4f(iffff)v; +__glewVertexAttrib4fARB(iffff)v; +__glewVertexAttrib4fNV(iffff)v; +__glewVertexAttrib4fv(ip)v; +__glewVertexAttrib4fvARB(ip)v; +__glewVertexAttrib4fvNV(ip)v; +__glewVertexAttrib4hNV(issss)v; +__glewVertexAttrib4hvNV(ip)v; +__glewVertexAttrib4iv(ip)v; +__glewVertexAttrib4ivARB(ip)v; +__glewVertexAttrib4s(iSSSS)v; +__glewVertexAttrib4sARB(iSSSS)v; +__glewVertexAttrib4sNV(iSSSS)v; +__glewVertexAttrib4sv(ip)v; +__glewVertexAttrib4svARB(ip)v; +__glewVertexAttrib4svNV(ip)v; +__glewVertexAttrib4ubNV(icccc)v; +__glewVertexAttrib4ubv(ip)v; +__glewVertexAttrib4ubvARB(ip)v; +__glewVertexAttrib4ubvNV(ip)v; +__glewVertexAttrib4uiv(ip)v; +__glewVertexAttrib4uivARB(ip)v; +__glewVertexAttrib4usv(ip)v; +__glewVertexAttrib4usvARB(ip)v; +__glewVertexAttribArrayObjectATI(iIicIii)v; +__glewVertexAttribDivisorARB(ii)v; +__glewVertexAttribI1i(iI)v; +__glewVertexAttribI1iEXT(iI)v; +__glewVertexAttribI1iv(ip)v; +__glewVertexAttribI1ivEXT(ip)v; +__glewVertexAttribI1ui(ii)v; +__glewVertexAttribI1uiEXT(ii)v; +__glewVertexAttribI1uiv(ip)v; +__glewVertexAttribI1uivEXT(ip)v; +__glewVertexAttribI2i(iII)v; +__glewVertexAttribI2iEXT(iII)v; +__glewVertexAttribI2iv(ip)v; +__glewVertexAttribI2ivEXT(ip)v; +__glewVertexAttribI2ui(iii)v; +__glewVertexAttribI2uiEXT(iii)v; +__glewVertexAttribI2uiv(ip)v; +__glewVertexAttribI2uivEXT(ip)v; +__glewVertexAttribI3i(iIII)v; +__glewVertexAttribI3iEXT(iIII)v; +__glewVertexAttribI3iv(ip)v; +__glewVertexAttribI3ivEXT(ip)v; +__glewVertexAttribI3ui(iiii)v; +__glewVertexAttribI3uiEXT(iiii)v; +__glewVertexAttribI3uiv(ip)v; +__glewVertexAttribI3uivEXT(ip)v; +__glewVertexAttribI4bv(ip)v; +__glewVertexAttribI4bvEXT(ip)v; +__glewVertexAttribI4i(iIIII)v; +__glewVertexAttribI4iEXT(iIIII)v; +__glewVertexAttribI4iv(ip)v; +__glewVertexAttribI4ivEXT(ip)v; +__glewVertexAttribI4sv(ip)v; +__glewVertexAttribI4svEXT(ip)v; +__glewVertexAttribI4ubv(ip)v; +__glewVertexAttribI4ubvEXT(ip)v; +__glewVertexAttribI4ui(iiiii)v; +__glewVertexAttribI4uiEXT(iiiii)v; +__glewVertexAttribI4uiv(ip)v; +__glewVertexAttribI4uivEXT(ip)v; +__glewVertexAttribI4usv(ip)v; +__glewVertexAttribI4usvEXT(ip)v; +__glewVertexAttribIPointer(iIiIp)v; +__glewVertexAttribIPointerEXT(iIiIp)v; +__glewVertexAttribPointer(iIicIp)v; +__glewVertexAttribPointerARB(iIicIp)v; +__glewVertexAttribPointerNV(iIiIp)v; +__glewVertexAttribs1dvNV(iIp)v; +__glewVertexAttribs1fvNV(iIp)v; +__glewVertexAttribs1hvNV(iIp)v; +__glewVertexAttribs1svNV(iIp)v; +__glewVertexAttribs2dvNV(iIp)v; +__glewVertexAttribs2fvNV(iIp)v; +__glewVertexAttribs2hvNV(iIp)v; +__glewVertexAttribs2svNV(iIp)v; +__glewVertexAttribs3dvNV(iIp)v; +__glewVertexAttribs3fvNV(iIp)v; +__glewVertexAttribs3hvNV(iIp)v; +__glewVertexAttribs3svNV(iIp)v; +__glewVertexAttribs4dvNV(iIp)v; +__glewVertexAttribs4fvNV(iIp)v; +__glewVertexAttribs4hvNV(iIp)v; +__glewVertexAttribs4svNV(iIp)v; +__glewVertexAttribs4ubvNV(iIp)v; +__glewVertexBlendARB(I)v; +__glewVertexBlendEnvfATI(if)v; +__glewVertexBlendEnviATI(iI)v; +__glewVertexPointerEXT(IiIIp)v; +__glewVertexPointerListIBM(IiIpI)v; +__glewVertexPointervINTEL(Iip)v; +__glewVertexStream2dATI(idd)v; +__glewVertexStream2dvATI(ip)v; +__glewVertexStream2fATI(iff)v; +__glewVertexStream2fvATI(ip)v; +__glewVertexStream2iATI(iII)v; +__glewVertexStream2ivATI(ip)v; +__glewVertexStream2sATI(iSS)v; +__glewVertexStream2svATI(ip)v; +__glewVertexStream3dATI(iddd)v; +__glewVertexStream3dvATI(ip)v; +__glewVertexStream3fATI(ifff)v; +__glewVertexStream3fvATI(ip)v; +__glewVertexStream3iATI(iIII)v; +__glewVertexStream3ivATI(ip)v; +__glewVertexStream3sATI(iSSS)v; +__glewVertexStream3svATI(ip)v; +__glewVertexStream4dATI(idddd)v; +__glewVertexStream4dvATI(ip)v; +__glewVertexStream4fATI(iffff)v; +__glewVertexStream4fvATI(ip)v; +__glewVertexStream4iATI(iIIII)v; +__glewVertexStream4ivATI(ip)v; +__glewVertexStream4sATI(iSSSS)v; +__glewVertexStream4svATI(ip)v; +__glewVertexWeightPointerEXT(IiIp)v; +__glewVertexWeightfEXT(f)v; +__glewVertexWeightfvEXT(p)v; +__glewVertexWeighthNV(s)v; +__glewVertexWeighthvNV(p)v; +__glewVideoParameterivNV(iip)v; +__glewWeightPointerARB(IiIp)v; +__glewWeightbvARB(Ip)v; +__glewWeightdvARB(Ip)v; +__glewWeightfvARB(Ip)v; +__glewWeightivARB(Ip)v; +__glewWeightsvARB(Ip)v; +__glewWeightubvARB(Ip)v; +__glewWeightuivARB(Ip)v; +__glewWeightusvARB(Ip)v; +__glewWindowPos2d(dd)v; +__glewWindowPos2dARB(dd)v; +__glewWindowPos2dMESA(dd)v; +__glewWindowPos2dv(p)v; +__glewWindowPos2dvARB(p)v; +__glewWindowPos2dvMESA(p)v; +__glewWindowPos2f(ff)v; +__glewWindowPos2fARB(ff)v; +__glewWindowPos2fMESA(ff)v; +__glewWindowPos2fv(p)v; +__glewWindowPos2fvARB(p)v; +__glewWindowPos2fvMESA(p)v; +__glewWindowPos2i(II)v; +__glewWindowPos2iARB(II)v; +__glewWindowPos2iMESA(II)v; +__glewWindowPos2iv(p)v; +__glewWindowPos2ivARB(p)v; +__glewWindowPos2ivMESA(p)v; +__glewWindowPos2s(SS)v; +__glewWindowPos2sARB(SS)v; +__glewWindowPos2sMESA(SS)v; +__glewWindowPos2sv(p)v; +__glewWindowPos2svARB(p)v; +__glewWindowPos2svMESA(p)v; +__glewWindowPos3d(ddd)v; +__glewWindowPos3dARB(ddd)v; +__glewWindowPos3dMESA(ddd)v; +__glewWindowPos3dv(p)v; +__glewWindowPos3dvARB(p)v; +__glewWindowPos3dvMESA(p)v; +__glewWindowPos3f(fff)v; +__glewWindowPos3fARB(fff)v; +__glewWindowPos3fMESA(fff)v; +__glewWindowPos3fv(p)v; +__glewWindowPos3fvARB(p)v; +__glewWindowPos3fvMESA(p)v; +__glewWindowPos3i(III)v; +__glewWindowPos3iARB(III)v; +__glewWindowPos3iMESA(III)v; +__glewWindowPos3iv(p)v; +__glewWindowPos3ivARB(p)v; +__glewWindowPos3ivMESA(p)v; +__glewWindowPos3s(SSS)v; +__glewWindowPos3sARB(SSS)v; +__glewWindowPos3sMESA(SSS)v; +__glewWindowPos3sv(p)v; +__glewWindowPos3svARB(p)v; +__glewWindowPos3svMESA(p)v; +__glewWindowPos4dMESA(dddd)v; +__glewWindowPos4dvMESA(p)v; +__glewWindowPos4fMESA(ffff)v; +__glewWindowPos4fvMESA(p)v; +__glewWindowPos4iMESA(IIII)v; +__glewWindowPos4ivMESA(p)v; +__glewWindowPos4sMESA(SSSS)v; +__glewWindowPos4svMESA(p)v; +__glewWriteMaskEXT(iiiiii)v; +",funcptr=TRUE, pat="__glew", replace="gl") +dynbind(c("glew","glew32")," +glAccum(If)v; +glAlphaFunc(If)v; +glAreTexturesResident(ipp)C; +glArrayElement(i)v; +glBegin(I)v; +glBindTexture(II)v; +glBitmap(iiffffp)v; +glBlendFunc(II)v; +glCallList(I)v; +glCallLists(iIp)v; +glClear(I)v; +glClearAccum(ffff)v; +glClearColor(ffff)v; +glClearDepth(d)v; +glClearIndex(f)v; +glClearStencil(i)v; +glClipPlane(Ip)v; +glColor3b(ccc)v; +glColor3bv(p)v; +glColor3d(ddd)v; +glColor3dv(p)v; +glColor3f(fff)v; +glColor3fv(p)v; +glColor3i(iii)v; +glColor3iv(p)v; +glColor3s(sss)v; +glColor3sv(p)v; +glColor3ub(CCC)v; +glColor3ubv(p)v; +glColor3ui(III)v; +glColor3uiv(p)v; +glColor3us(SSS)v; +glColor3usv(p)v; +glColor4b(cccc)v; +glColor4bv(p)v; +glColor4d(dddd)v; +glColor4dv(p)v; +glColor4f(ffff)v; +glColor4fv(p)v; +glColor4i(iiii)v; +glColor4iv(p)v; +glColor4s(ssss)v; +glColor4sv(p)v; +glColor4ub(CCCC)v; +glColor4ubv(p)v; +glColor4ui(IIII)v; +glColor4uiv(p)v; +glColor4us(SSSS)v; +glColor4usv(p)v; +glColorMask(CCCC)v; +glColorMaterial(II)v; +glColorPointer(iIip)v; +glCopyPixels(iiiiI)v; +glCopyTexImage1D(IiIiiii)v; +glCopyTexImage2D(IiIiiiii)v; +glCopyTexSubImage1D(Iiiiii)v; +glCopyTexSubImage2D(Iiiiiiii)v; +glCullFace(I)v; +glDeleteLists(Ii)v; +glDeleteTextures(ip)v; +glDepthFunc(I)v; +glDepthMask(C)v; +glDepthRange(dd)v; +glDisable(I)v; +glDisableClientState(I)v; +glDrawArrays(Iii)v; +glDrawBuffer(I)v; +glDrawElements(IiIp)v; +glDrawPixels(iiIIp)v; +glEdgeFlag(C)v; +glEdgeFlagPointer(ip)v; +glEdgeFlagv(p)v; +glEnable(I)v; +glEnableClientState(I)v; +glEnd()v; +glEndList()v; +glEvalCoord1d(d)v; +glEvalCoord1dv(p)v; +glEvalCoord1f(f)v; +glEvalCoord1fv(p)v; +glEvalCoord2d(dd)v; +glEvalCoord2dv(p)v; +glEvalCoord2f(ff)v; +glEvalCoord2fv(p)v; +glEvalMesh1(Iii)v; +glEvalMesh2(Iiiii)v; +glEvalPoint1(i)v; +glEvalPoint2(ii)v; +glFeedbackBuffer(iIp)v; +glFinish()v; +glFlush()v; +glFogf(If)v; +glFogfv(Ip)v; +glFogi(Ii)v; +glFogiv(Ip)v; +glFrontFace(I)v; +glFrustum(dddddd)v; +glGenLists(i)I; +glGenTextures(ip)v; +glGetBooleanv(Ip)v; +glGetClipPlane(Ip)v; +glGetDoublev(Ip)v; +glGetError()I; +glGetFloatv(Ip)v; +glGetIntegerv(Ip)v; +glGetLightfv(IIp)v; +glGetLightiv(IIp)v; +glGetMapdv(IIp)v; +glGetMapfv(IIp)v; +glGetMapiv(IIp)v; +glGetMaterialfv(IIp)v; +glGetMaterialiv(IIp)v; +glGetPixelMapfv(Ip)v; +glGetPixelMapuiv(Ip)v; +glGetPixelMapusv(Ip)v; +glGetPointerv(Ip)v; +glGetPolygonStipple(p)v; +glGetString(I)p; +glGetTexEnvfv(IIp)v; +glGetTexEnviv(IIp)v; +glGetTexGendv(IIp)v; +glGetTexGenfv(IIp)v; +glGetTexGeniv(IIp)v; +glGetTexImage(IiIIp)v; +glGetTexLevelParameterfv(IiIp)v; +glGetTexLevelParameteriv(IiIp)v; +glGetTexParameterfv(IIp)v; +glGetTexParameteriv(IIp)v; +glHint(II)v; +glIndexMask(I)v; +glIndexPointer(Iip)v; +glIndexd(d)v; +glIndexdv(p)v; +glIndexf(f)v; +glIndexfv(p)v; +glIndexi(i)v; +glIndexiv(p)v; +glIndexs(s)v; +glIndexsv(p)v; +glIndexub(C)v; +glIndexubv(p)v; +glInitNames()v; +glInterleavedArrays(Iip)v; +glIsEnabled(I)C; +glIsList(I)C; +glIsTexture(I)C; +glLightModelf(If)v; +glLightModelfv(Ip)v; +glLightModeli(Ii)v; +glLightModeliv(Ip)v; +glLightf(IIf)v; +glLightfv(IIp)v; +glLighti(IIi)v; +glLightiv(IIp)v; +glLineStipple(iS)v; +glLineWidth(f)v; +glListBase(I)v; +glLoadIdentity()v; +glLoadMatrixd(p)v; +glLoadMatrixf(p)v; +glLoadName(I)v; +glLogicOp(I)v; +glMap1d(Iddiip)v; +glMap1f(Iffiip)v; +glMap2d(Iddiiddiip)v; +glMap2f(Iffiiffiip)v; +glMapGrid1d(idd)v; +glMapGrid1f(iff)v; +glMapGrid2d(iddidd)v; +glMapGrid2f(iffiff)v; +glMaterialf(IIf)v; +glMaterialfv(IIp)v; +glMateriali(IIi)v; +glMaterialiv(IIp)v; +glMatrixMode(I)v; +glMultMatrixd(p)v; +glMultMatrixf(p)v; +glNewList(II)v; +glNormal3b(ccc)v; +glNormal3bv(p)v; +glNormal3d(ddd)v; +glNormal3dv(p)v; +glNormal3f(fff)v; +glNormal3fv(p)v; +glNormal3i(iii)v; +glNormal3iv(p)v; +glNormal3s(sss)v; +glNormal3sv(p)v; +glNormalPointer(Iip)v; +glOrtho(dddddd)v; +glPassThrough(f)v; +glPixelMapfv(Iip)v; +glPixelMapuiv(Iip)v; +glPixelMapusv(Iip)v; +glPixelStoref(If)v; +glPixelStorei(Ii)v; +glPixelTransferf(If)v; +glPixelTransferi(Ii)v; +glPixelZoom(ff)v; +glPointSize(f)v; +glPolygonMode(II)v; +glPolygonOffset(ff)v; +glPolygonStipple(p)v; +glPopAttrib()v; +glPopClientAttrib()v; +glPopMatrix()v; +glPopName()v; +glPrioritizeTextures(ipp)v; +glPushAttrib(I)v; +glPushClientAttrib(I)v; +glPushMatrix()v; +glPushName(I)v; +glRasterPos2d(dd)v; +glRasterPos2dv(p)v; +glRasterPos2f(ff)v; +glRasterPos2fv(p)v; +glRasterPos2i(ii)v; +glRasterPos2iv(p)v; +glRasterPos2s(ss)v; +glRasterPos2sv(p)v; +glRasterPos3d(ddd)v; +glRasterPos3dv(p)v; +glRasterPos3f(fff)v; +glRasterPos3fv(p)v; +glRasterPos3i(iii)v; +glRasterPos3iv(p)v; +glRasterPos3s(sss)v; +glRasterPos3sv(p)v; +glRasterPos4d(dddd)v; +glRasterPos4dv(p)v; +glRasterPos4f(ffff)v; +glRasterPos4fv(p)v; +glRasterPos4i(iiii)v; +glRasterPos4iv(p)v; +glRasterPos4s(ssss)v; +glRasterPos4sv(p)v; +glReadBuffer(I)v; +glReadPixels(iiiiIIp)v; +glRectd(dddd)v; +glRectdv(pp)v; +glRectf(ffff)v; +glRectfv(pp)v; +glRecti(iiii)v; +glRectiv(pp)v; +glRects(ssss)v; +glRectsv(pp)v; +glRenderMode(I)i; +glRotated(dddd)v; +glRotatef(ffff)v; +glScaled(ddd)v; +glScalef(fff)v; +glScissor(iiii)v; +glSelectBuffer(ip)v; +glShadeModel(I)v; +glStencilFunc(IiI)v; +glStencilMask(I)v; +glStencilOp(III)v; +glTexCoord1d(d)v; +glTexCoord1dv(p)v; +glTexCoord1f(f)v; +glTexCoord1fv(p)v; +glTexCoord1i(i)v; +glTexCoord1iv(p)v; +glTexCoord1s(s)v; +glTexCoord1sv(p)v; +glTexCoord2d(dd)v; +glTexCoord2dv(p)v; +glTexCoord2f(ff)v; +glTexCoord2fv(p)v; +glTexCoord2i(ii)v; +glTexCoord2iv(p)v; +glTexCoord2s(ss)v; +glTexCoord2sv(p)v; +glTexCoord3d(ddd)v; +glTexCoord3dv(p)v; +glTexCoord3f(fff)v; +glTexCoord3fv(p)v; +glTexCoord3i(iii)v; +glTexCoord3iv(p)v; +glTexCoord3s(sss)v; +glTexCoord3sv(p)v; +glTexCoord4d(dddd)v; +glTexCoord4dv(p)v; +glTexCoord4f(ffff)v; +glTexCoord4fv(p)v; +glTexCoord4i(iiii)v; +glTexCoord4iv(p)v; +glTexCoord4s(ssss)v; +glTexCoord4sv(p)v; +glTexCoordPointer(iIip)v; +glTexEnvf(IIf)v; +glTexEnvfv(IIp)v; +glTexEnvi(IIi)v; +glTexEnviv(IIp)v; +glTexGend(IId)v; +glTexGendv(IIp)v; +glTexGenf(IIf)v; +glTexGenfv(IIp)v; +glTexGeni(IIi)v; +glTexGeniv(IIp)v; +glTexImage1D(IiiiiIIp)v; +glTexImage2D(IiiiiiIIp)v; +glTexParameterf(IIf)v; +glTexParameterfv(IIp)v; +glTexParameteri(IIi)v; +glTexParameteriv(IIp)v; +glTexSubImage1D(IiiiIIp)v; +glTexSubImage2D(IiiiiiIIp)v; +glTranslated(ddd)v; +glTranslatef(fff)v; +glVertex2d(dd)v; +glVertex2dv(p)v; +glVertex2f(ff)v; +glVertex2fv(p)v; +glVertex2i(ii)v; +glVertex2iv(p)v; +glVertex2s(ss)v; +glVertex2sv(p)v; +glVertex3d(ddd)v; +glVertex3dv(p)v; +glVertex3f(fff)v; +glVertex3fv(p)v; +glVertex3i(iii)v; +glVertex3iv(p)v; +glVertex3s(sss)v; +glVertex3sv(p)v; +glVertex4d(dddd)v; +glVertex4dv(p)v; +glVertex4f(ffff)v; +glVertex4fv(p)v; +glVertex4i(iiii)v; +glVertex4iv(p)v; +glVertex4s(ssss)v; +glVertex4sv(p)v; +glVertexPointer(iIip)v; +glViewport(iiii)v; +glewGetErrorString(I)p; +glewGetExtension(p)C; +glewGetString(I)p; +glewInit()I; +glewIsSupported(p)C; +gluBeginCurve(p)v; +gluBeginPolygon(p)v; +gluBeginSurface(p)v; +gluBeginTrim(p)v; +gluBuild1DMipmapLevels(IiiIIiiip)i; +gluBuild1DMipmaps(IiiIIp)i; +gluBuild2DMipmapLevels(IiiiIIiiip)i; +gluBuild2DMipmaps(IiiiIIp)i; +gluBuild3DMipmapLevels(IiiiiIIiiip)i; +gluBuild3DMipmaps(IiiiiIIp)i; +gluCheckExtension(pp)C; +gluCylinder(pdddii)v; +gluDeleteNurbsRenderer(p)v; +gluDeleteQuadric(p)v; +gluDeleteTess(p)v; +gluDisk(pddii)v; +gluEndCurve(p)v; +gluEndPolygon(p)v; +gluEndSurface(p)v; +gluEndTrim(p)v; +gluErrorString(I)p; +gluGetNurbsProperty(pIp)v; +gluGetString(I)p; +gluGetTessProperty(pIp)v; +gluLoadSamplingMatrices(pppp)v; +gluLookAt(ddddddddd)v; +gluNewNurbsRenderer()p; +gluNewQuadric()p; +gluNewTess()p; +gluNextContour(pI)v; +gluNurbsCallback(pIp)v; +gluNurbsCallbackData(pp)v; +gluNurbsCallbackDataEXT(pp)v; +gluNurbsCurve(pipipiI)v; +gluNurbsProperty(pIf)v; +gluNurbsSurface(pipipiipiiI)v; +gluOrtho2D(dddd)v; +gluPartialDisk(pddiidd)v; +gluPerspective(dddd)v; +gluPickMatrix(ddddp)v; +gluProject(dddpppppp)i; +gluPwlCurve(pipiI)v; +gluQuadricCallback(pIp)v; +gluQuadricDrawStyle(pI)v; +gluQuadricNormals(pI)v; +gluQuadricOrientation(pI)v; +gluQuadricTexture(pC)v; +gluScaleImage(IiiIpiiIp)i; +gluSphere(pdii)v; +gluTessBeginContour(p)v; +gluTessBeginPolygon(pp)v; +gluTessCallback(pIp)v; +gluTessEndContour(p)v; +gluTessEndPolygon(p)v; +gluTessNormal(pddd)v; +gluTessProperty(pId)v; +gluTessVertex(ppp)v; +gluUnProject(dddpppppp)i; +gluUnProject4(ddddpppddpppp)i; +")
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/glfw.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,227 @@ + + +dynbind("glfw", " +glfwBroadcastCond(*v)v; +glfwCloseWindow()v; +glfwCreateCond()*v; +glfwCreateMutex()*v; +glfwCreateThread(*p*v)i; +glfwDestroyCond(*v)v; +glfwDestroyMutex(*v)v; +glfwDestroyThread(i)v; +glfwDisable(i)v; +glfwEnable(i)v; +glfwExtensionSupported(*c)i; +glfwFreeImage(*<GLFWimage>)v; +glfwGetDesktopMode(*<GLFWvidmode>)v; +glfwGetGLVersion(*i*i*i)v; +glfwGetJoystickButtons(i*Ci)i; +glfwGetJoystickParam(ii)i; +glfwGetJoystickPos(i*fi)i; +glfwGetKey(i)i; +glfwGetMouseButton(i)i; +glfwGetMousePos(*i*i)v; +glfwGetMouseWheel()i; +glfwGetNumberOfProcessors()i; +glfwGetProcAddress(*c)*v; +glfwGetThreadID()i; +glfwGetTime()d; +glfwGetVersion(*i*i*i)v; +glfwGetVideoModes(*<GLFWvidmode>i)i; +glfwGetWindowParam(i)i; +glfwGetWindowSize(*i*i)v; +glfwIconifyWindow()v; +glfwInit()i; +glfwLoadMemoryTexture2D(*vji)i; +glfwLoadTexture2D(*ci)i; +glfwLoadTextureImage2D(*<GLFWimage>i)i; +glfwLockMutex(*v)v; +glfwOpenWindow(iiiiiiiii)i; +glfwOpenWindowHint(ii)v; +glfwPollEvents()v; +glfwReadImage(*c*<GLFWimage>i)i; +glfwReadMemoryImage(*vj*<GLFWimage>i)i; +glfwRestoreWindow()v; +glfwSetCharCallback(*p)v; +glfwSetKeyCallback(*p)v; +glfwSetMouseButtonCallback(*p)v; +glfwSetMousePos(ii)v; +glfwSetMousePosCallback(*p)v; +glfwSetMouseWheel(i)v; +glfwSetMouseWheelCallback(*p)v; +glfwSetTime(d)v; +glfwSetWindowCloseCallback(*p)v; +glfwSetWindowPos(ii)v; +glfwSetWindowRefreshCallback(*p)v; +glfwSetWindowSize(ii)v; +glfwSetWindowSizeCallback(*p)v; +glfwSetWindowTitle(*c)v; +glfwSignalCond(*v)v; +glfwSleep(d)v; +glfwSwapBuffers()v; +glfwSwapInterval(i)v; +glfwTerminate()v; +glfwUnlockMutex(*v)v; +glfwWaitCond(*v*vd)v; +glfwWaitEvents()v; +glfwWaitThread(ii)i; +") +parseStructInfos(" +GLFWimage{iiii*C}Width Height Format BytesPerPixel Data ; +GLFWvidmode{iiiii}Width Height RedBits BlueBits GreenBits ; +") +#GLFWAPI= +#GLFWAPIENTRY= +#GLFWCALL= +GLFW_ACCELERATED=0x00020004 +GLFW_ACCUM_ALPHA_BITS=0x0002000F +GLFW_ACCUM_BLUE_BITS=0x0002000E +GLFW_ACCUM_GREEN_BITS=0x0002000D +GLFW_ACCUM_RED_BITS=0x0002000C +GLFW_ACTIVE=0x00020002 +GLFW_ALPHA_BITS=0x00020008 +GLFW_ALPHA_MAP_BIT=0x00000008 +GLFW_AUTO_POLL_EVENTS=0x00030006 +GLFW_AUX_BUFFERS=0x00020010 +GLFW_AXES=0x00050002 +GLFW_BLUE_BITS=0x00020007 +GLFW_BUILD_MIPMAPS_BIT=0x00000004 +GLFW_BUTTONS=0x00050003 +GLFW_DEPTH_BITS=0x00020009 +GLFW_FSAA_SAMPLES=0x00020013 +GLFW_FULLSCREEN=0x00010002 +GLFW_GREEN_BITS=0x00020006 +GLFW_ICONIFIED=0x00020003 +GLFW_INFINITY=100000.0 +GLFW_JOYSTICK_10=9 +GLFW_JOYSTICK_11=10 +GLFW_JOYSTICK_12=11 +GLFW_JOYSTICK_13=12 +GLFW_JOYSTICK_14=13 +GLFW_JOYSTICK_15=14 +GLFW_JOYSTICK_16=15 +GLFW_JOYSTICK_1=0 +GLFW_JOYSTICK_2=1 +GLFW_JOYSTICK_3=2 +GLFW_JOYSTICK_4=3 +GLFW_JOYSTICK_5=4 +GLFW_JOYSTICK_6=5 +GLFW_JOYSTICK_7=6 +GLFW_JOYSTICK_8=7 +GLFW_JOYSTICK_9=8 +GLFW_JOYSTICK_LAST=GLFW_JOYSTICK_16 +GLFW_KEY_SPECIAL=256 +GLFW_KEY_BACKSPACE=(GLFW_KEY_SPECIAL+39) +GLFW_KEY_CAPS_LOCK=(GLFW_KEY_SPECIAL+64) +GLFW_KEY_DEL=(GLFW_KEY_SPECIAL+41) +GLFW_KEY_DOWN=(GLFW_KEY_SPECIAL+28) +GLFW_KEY_END=(GLFW_KEY_SPECIAL+45) +GLFW_KEY_ENTER=(GLFW_KEY_SPECIAL+38) +GLFW_KEY_ESC=(GLFW_KEY_SPECIAL+1) +GLFW_KEY_F10=(GLFW_KEY_SPECIAL+11) +GLFW_KEY_F11=(GLFW_KEY_SPECIAL+12) +GLFW_KEY_F12=(GLFW_KEY_SPECIAL+13) +GLFW_KEY_F13=(GLFW_KEY_SPECIAL+14) +GLFW_KEY_F14=(GLFW_KEY_SPECIAL+15) +GLFW_KEY_F15=(GLFW_KEY_SPECIAL+16) +GLFW_KEY_F16=(GLFW_KEY_SPECIAL+17) +GLFW_KEY_F17=(GLFW_KEY_SPECIAL+18) +GLFW_KEY_F18=(GLFW_KEY_SPECIAL+19) +GLFW_KEY_F19=(GLFW_KEY_SPECIAL+20) +GLFW_KEY_F1=(GLFW_KEY_SPECIAL+2) +GLFW_KEY_F20=(GLFW_KEY_SPECIAL+21) +GLFW_KEY_F21=(GLFW_KEY_SPECIAL+22) +GLFW_KEY_F22=(GLFW_KEY_SPECIAL+23) +GLFW_KEY_F23=(GLFW_KEY_SPECIAL+24) +GLFW_KEY_F24=(GLFW_KEY_SPECIAL+25) +GLFW_KEY_F25=(GLFW_KEY_SPECIAL+26) +GLFW_KEY_F2=(GLFW_KEY_SPECIAL+3) +GLFW_KEY_F3=(GLFW_KEY_SPECIAL+4) +GLFW_KEY_F4=(GLFW_KEY_SPECIAL+5) +GLFW_KEY_F5=(GLFW_KEY_SPECIAL+6) +GLFW_KEY_F6=(GLFW_KEY_SPECIAL+7) +GLFW_KEY_F7=(GLFW_KEY_SPECIAL+8) +GLFW_KEY_F8=(GLFW_KEY_SPECIAL+9) +GLFW_KEY_F9=(GLFW_KEY_SPECIAL+10) +GLFW_KEY_HOME=(GLFW_KEY_SPECIAL+44) +GLFW_KEY_INSERT=(GLFW_KEY_SPECIAL+40) +GLFW_KEY_KP_0=(GLFW_KEY_SPECIAL+46) +GLFW_KEY_KP_1=(GLFW_KEY_SPECIAL+47) +GLFW_KEY_KP_2=(GLFW_KEY_SPECIAL+48) +GLFW_KEY_KP_3=(GLFW_KEY_SPECIAL+49) +GLFW_KEY_KP_4=(GLFW_KEY_SPECIAL+50) +GLFW_KEY_KP_5=(GLFW_KEY_SPECIAL+51) +GLFW_KEY_KP_6=(GLFW_KEY_SPECIAL+52) +GLFW_KEY_KP_7=(GLFW_KEY_SPECIAL+53) +GLFW_KEY_KP_8=(GLFW_KEY_SPECIAL+54) +GLFW_KEY_KP_9=(GLFW_KEY_SPECIAL+55) +GLFW_KEY_KP_ADD=(GLFW_KEY_SPECIAL+59) +GLFW_KEY_KP_DECIMAL=(GLFW_KEY_SPECIAL+60) +GLFW_KEY_KP_DIVIDE=(GLFW_KEY_SPECIAL+56) +GLFW_KEY_KP_ENTER=(GLFW_KEY_SPECIAL+62) +GLFW_KEY_KP_EQUAL=(GLFW_KEY_SPECIAL+61) +GLFW_KEY_KP_MULTIPLY=(GLFW_KEY_SPECIAL+57) +GLFW_KEY_KP_NUM_LOCK=(GLFW_KEY_SPECIAL+63) +GLFW_KEY_KP_SUBTRACT=(GLFW_KEY_SPECIAL+58) +GLFW_KEY_LALT=(GLFW_KEY_SPECIAL+35) +GLFW_KEY_LCTRL=(GLFW_KEY_SPECIAL+33) +GLFW_KEY_LEFT=(GLFW_KEY_SPECIAL+29) +GLFW_KEY_LSHIFT=(GLFW_KEY_SPECIAL+31) +GLFW_KEY_LSUPER=(GLFW_KEY_SPECIAL+67) +GLFW_KEY_MENU=(GLFW_KEY_SPECIAL+69) +GLFW_KEY_PAGEDOWN=(GLFW_KEY_SPECIAL+43) +GLFW_KEY_PAGEUP=(GLFW_KEY_SPECIAL+42) +GLFW_KEY_PAUSE=(GLFW_KEY_SPECIAL+66) +GLFW_KEY_RALT=(GLFW_KEY_SPECIAL+36) +GLFW_KEY_RCTRL=(GLFW_KEY_SPECIAL+34) +GLFW_KEY_REPEAT=0x00030005 +GLFW_KEY_RIGHT=(GLFW_KEY_SPECIAL+30) +GLFW_KEY_RSHIFT=(GLFW_KEY_SPECIAL+32) +GLFW_KEY_RSUPER=(GLFW_KEY_SPECIAL+68) +GLFW_KEY_SCROLL_LOCK=(GLFW_KEY_SPECIAL+65) +GLFW_KEY_SPACE=32 +GLFW_KEY_TAB=(GLFW_KEY_SPECIAL+37) +GLFW_KEY_UNKNOWN=-1 +GLFW_KEY_UP=(GLFW_KEY_SPECIAL+27) +GLFW_KEY_LAST=GLFW_KEY_MENU +GLFW_MOUSE_BUTTON_1=0 +GLFW_MOUSE_BUTTON_2=1 +GLFW_MOUSE_BUTTON_3=2 +GLFW_MOUSE_BUTTON_4=3 +GLFW_MOUSE_BUTTON_5=4 +GLFW_MOUSE_BUTTON_6=5 +GLFW_MOUSE_BUTTON_7=6 +GLFW_MOUSE_BUTTON_8=7 +GLFW_MOUSE_BUTTON_LAST=GLFW_MOUSE_BUTTON_8 +GLFW_MOUSE_BUTTON_LEFT=GLFW_MOUSE_BUTTON_1 +GLFW_MOUSE_BUTTON_MIDDLE=GLFW_MOUSE_BUTTON_3 +GLFW_MOUSE_BUTTON_RIGHT=GLFW_MOUSE_BUTTON_2 +GLFW_MOUSE_CURSOR=0x00030001 +GLFW_NOWAIT=0x00040002 +GLFW_NO_RESCALE_BIT=0x00000001 +GLFW_OPENED=0x00020001 +GLFW_OPENGL_COMPAT_PROFILE=0x00050002 +GLFW_OPENGL_CORE_PROFILE=0x00050001 +GLFW_OPENGL_DEBUG_CONTEXT=0x00020017 +GLFW_OPENGL_FORWARD_COMPAT=0x00020016 +GLFW_OPENGL_PROFILE=0x00020018 +GLFW_OPENGL_VERSION_MAJOR=0x00020014 +GLFW_OPENGL_VERSION_MINOR=0x00020015 +GLFW_ORIGIN_UL_BIT=0x00000002 +GLFW_PRESENT=0x00050001 +GLFW_PRESS=1 +GLFW_RED_BITS=0x00020005 +GLFW_REFRESH_RATE=0x0002000B +GLFW_RELEASE=0 +GLFW_STENCIL_BITS=0x0002000A +GLFW_STEREO=0x00020011 +GLFW_STICKY_KEYS=0x00030002 +GLFW_STICKY_MOUSE_BUTTONS=0x00030003 +GLFW_SYSTEM_KEYS=0x00030004 +GLFW_VERSION_MAJOR=2 +GLFW_VERSION_MINOR=7 +GLFW_VERSION_REVISION=3 +GLFW_WAIT=0x00040001 +GLFW_WINDOW=0x00010001 +GLFW_WINDOW_NO_RESIZE=0x00020012 +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/glpk.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,346 @@ + + +dynbind("glpk", " +glp_add_arc(*<_glp_graph>ii)*<_glp_arc>; +glp_add_cols(*<glp_prob>i)i; +glp_add_rows(*<glp_prob>i)i; +glp_add_vertices(*<_glp_graph>i)i; +glp_adv_basis(*<glp_prob>i)v; +glp_analyze_bound(*<glp_prob>i*d*i*d*i)v; +glp_analyze_coef(*<glp_prob>i*d*i*d*d*i*d)v; +glp_asnprob_hall(*<_glp_graph>ii)i; +glp_asnprob_lp(*<glp_prob>i*<_glp_graph>iii)i; +glp_asnprob_okalg(i*<_glp_graph>ii*di)i; +glp_assert_(*c*ci)v; +glp_bf_exists(*<glp_prob>)i; +glp_bf_updated(*<glp_prob>)i; +glp_btran(*<glp_prob>*d)v; +glp_calloc(ii)*v; +glp_check_asnprob(*<_glp_graph>i)i; +glp_check_cnfsat(*<glp_prob>)i; +glp_check_dup(iii*i*i)i; +glp_close_tee()i; +glp_copy_prob(*<glp_prob>*<glp_prob>i)v; +glp_cpp(*<_glp_graph>iii)d; +glp_cpx_basis(*<glp_prob>)v; +glp_create_graph(ii)*<_glp_graph>; +glp_create_index(*<glp_prob>)v; +glp_create_prob()*<glp_prob>; +glp_create_v_index(*<_glp_graph>)v; +glp_del_arc(*<_glp_graph>*<_glp_arc>)v; +glp_del_cols(*<glp_prob>i*i)v; +glp_del_rows(*<glp_prob>i*i)v; +glp_del_vertices(*<_glp_graph>i*i)v; +glp_delete_graph(*<_glp_graph>)v; +glp_delete_index(*<glp_prob>)v; +glp_delete_prob(*<glp_prob>)v; +glp_delete_v_index(*<_glp_graph>)v; +glp_difftime()d; +glp_dual_rtest(*<glp_prob>i*i*did)i; +glp_erase_graph(*<_glp_graph>ii)v; +glp_erase_prob(*<glp_prob>)v; +glp_error_(*ci)*p; +glp_error_hook(*p*v)v; +glp_eval_tab_col(*<glp_prob>i*i*d)i; +glp_eval_tab_row(*<glp_prob>i*i*d)i; +glp_exact(*<glp_prob>*<glp_smcp>)i; +glp_factorize(*<glp_prob>)i; +glp_find_col(*<glp_prob>*c)i; +glp_find_row(*<glp_prob>*c)i; +glp_find_vertex(*<_glp_graph>*c)i; +glp_free(*v)v; +glp_free_env()i; +glp_ftran(*<glp_prob>*d)v; +glp_get_bfcp(*<glp_prob>*<glp_bfcp>)v; +glp_get_bhead(*<glp_prob>i)i; +glp_get_col_bind(*<glp_prob>i)i; +glp_get_col_dual(*<glp_prob>i)d; +glp_get_col_kind(*<glp_prob>i)i; +glp_get_col_lb(*<glp_prob>i)d; +glp_get_col_name(*<glp_prob>i)*c; +glp_get_col_prim(*<glp_prob>i)d; +glp_get_col_stat(*<glp_prob>i)i; +glp_get_col_type(*<glp_prob>i)i; +glp_get_col_ub(*<glp_prob>i)d; +glp_get_dual_stat(*<glp_prob>)i; +glp_get_mat_col(*<glp_prob>i*i*d)i; +glp_get_mat_row(*<glp_prob>i*i*d)i; +glp_get_num_bin(*<glp_prob>)i; +glp_get_num_cols(*<glp_prob>)i; +glp_get_num_int(*<glp_prob>)i; +glp_get_num_nz(*<glp_prob>)i; +glp_get_num_rows(*<glp_prob>)i; +glp_get_obj_coef(*<glp_prob>i)d; +glp_get_obj_dir(*<glp_prob>)i; +glp_get_obj_name(*<glp_prob>)*c; +glp_get_obj_val(*<glp_prob>)d; +glp_get_prim_stat(*<glp_prob>)i; +glp_get_prob_name(*<glp_prob>)*c; +glp_get_rii(*<glp_prob>i)d; +glp_get_row_bind(*<glp_prob>i)i; +glp_get_row_dual(*<glp_prob>i)d; +glp_get_row_lb(*<glp_prob>i)d; +glp_get_row_name(*<glp_prob>i)*c; +glp_get_row_prim(*<glp_prob>i)d; +glp_get_row_stat(*<glp_prob>i)i; +glp_get_row_type(*<glp_prob>i)i; +glp_get_row_ub(*<glp_prob>i)d; +glp_get_sjj(*<glp_prob>i)d; +glp_get_status(*<glp_prob>)i; +glp_get_unbnd_ray(*<glp_prob>)i; +glp_gridgen(*<_glp_graph>iii*i)i; +glp_init_cpxcp(*<glp_cpxcp>)v; +glp_init_env()i; +glp_init_iocp(*<glp_iocp>)v; +glp_init_iptcp(*<glp_iptcp>)v; +glp_init_mpscp(*<glp_mpscp>)v; +glp_init_smcp(*<glp_smcp>)v; +glp_interior(*<glp_prob>*<glp_iptcp>)i; +glp_intfeas1(*<glp_prob>ii)i; +glp_intopt(*<glp_prob>*<glp_iocp>)i; +glp_ios_add_row(*<glp_tree>*ciii*i*did)i; +glp_ios_best_node(*<glp_tree>)i; +glp_ios_branch_upon(*<glp_tree>ii)v; +glp_ios_can_branch(*<glp_tree>i)i; +glp_ios_clear_pool(*<glp_tree>)v; +glp_ios_curr_node(*<glp_tree>)i; +glp_ios_del_row(*<glp_tree>i)v; +glp_ios_get_prob(*<glp_tree>)*<glp_prob>; +glp_ios_heur_sol(*<glp_tree>*d)i; +glp_ios_mip_gap(*<glp_tree>)d; +glp_ios_next_node(*<glp_tree>i)i; +glp_ios_node_bound(*<glp_tree>i)d; +glp_ios_node_data(*<glp_tree>i)*v; +glp_ios_node_level(*<glp_tree>i)i; +glp_ios_pool_size(*<glp_tree>)i; +glp_ios_prev_node(*<glp_tree>i)i; +glp_ios_reason(*<glp_tree>)i; +glp_ios_row_attr(*<glp_tree>i*<glp_attr>)v; +glp_ios_select_node(*<glp_tree>i)v; +glp_ios_terminate(*<glp_tree>)v; +glp_ios_tree_size(*<glp_tree>*i*i*i)v; +glp_ios_up_node(*<glp_tree>i)i; +glp_ipt_col_dual(*<glp_prob>i)d; +glp_ipt_col_prim(*<glp_prob>i)d; +glp_ipt_obj_val(*<glp_prob>)d; +glp_ipt_row_dual(*<glp_prob>i)d; +glp_ipt_row_prim(*<glp_prob>i)d; +glp_ipt_status(*<glp_prob>)i; +glp_load_matrix(*<glp_prob>i*i*i*d)v; +glp_main(i**c)i; +glp_malloc(i)*v; +glp_maxflow_ffalg(*<_glp_graph>iii*dii)i; +glp_maxflow_lp(*<glp_prob>*<_glp_graph>iiii)v; +glp_mem_limit(i)v; +glp_mem_usage(*i*i*<glp_long>*<glp_long>)v; +glp_mincost_lp(*<glp_prob>*<_glp_graph>iiiii)v; +glp_mincost_okalg(*<_glp_graph>iiii*dii)i; +glp_minisat1(*<glp_prob>)i; +glp_mip_col_val(*<glp_prob>i)d; +glp_mip_obj_val(*<glp_prob>)d; +glp_mip_row_val(*<glp_prob>i)d; +glp_mip_status(*<glp_prob>)i; +glp_mpl_alloc_wksp()*<glp_tran>; +glp_mpl_build_prob(*<glp_tran>*<glp_prob>)v; +glp_mpl_free_wksp(*<glp_tran>)v; +glp_mpl_generate(*<glp_tran>*c)i; +glp_mpl_postsolve(*<glp_tran>*<glp_prob>i)i; +glp_mpl_read_data(*<glp_tran>*c)i; +glp_mpl_read_model(*<glp_tran>*ci)i; +glp_netgen(*<_glp_graph>iii*i)i; +glp_open_tee(*c)i; +glp_prim_rtest(*<glp_prob>i*i*did)i; +glp_print_ipt(*<glp_prob>*c)i; +glp_print_mip(*<glp_prob>*c)i; +glp_print_ranges(*<glp_prob>i*ii*c)i; +glp_print_sol(*<glp_prob>*c)i; +glp_printf(*c?)v; +glp_read_asnprob(*<_glp_graph>ii*c)i; +glp_read_ccdata(*<_glp_graph>i*c)i; +glp_read_cnfsat(*<glp_prob>*c)i; +glp_read_graph(*<_glp_graph>*c)i; +glp_read_ipt(*<glp_prob>*c)i; +glp_read_lp(*<glp_prob>*<glp_cpxcp>*c)i; +glp_read_maxflow(*<_glp_graph>*i*ii*c)i; +glp_read_mincost(*<_glp_graph>iiii*c)i; +glp_read_mip(*<glp_prob>*c)i; +glp_read_mps(*<glp_prob>i*<glp_mpscp>*c)i; +glp_read_prob(*<glp_prob>i*c)i; +glp_read_sol(*<glp_prob>*c)i; +glp_rmfgen(*<_glp_graph>*i*ii*i)i; +glp_scale_prob(*<glp_prob>i)v; +glp_sdf_close_file(*<glp_data>)v; +glp_sdf_error(*<glp_data>*c?)v; +glp_sdf_line(*<glp_data>)i; +glp_sdf_open_file(*c)*<glp_data>; +glp_sdf_read_int(*<glp_data>)i; +glp_sdf_read_item(*<glp_data>)*c; +glp_sdf_read_num(*<glp_data>)d; +glp_sdf_read_text(*<glp_data>)*c; +glp_sdf_set_jump(*<glp_data>*v)v; +glp_sdf_warning(*<glp_data>*c?)v; +glp_set_bfcp(*<glp_prob>*<glp_bfcp>)v; +glp_set_col_bnds(*<glp_prob>iidd)v; +glp_set_col_kind(*<glp_prob>ii)v; +glp_set_col_name(*<glp_prob>i*c)v; +glp_set_col_stat(*<glp_prob>ii)v; +glp_set_graph_name(*<_glp_graph>*c)v; +glp_set_mat_col(*<glp_prob>ii*i*d)v; +glp_set_mat_row(*<glp_prob>ii*i*d)v; +glp_set_obj_coef(*<glp_prob>id)v; +glp_set_obj_dir(*<glp_prob>i)v; +glp_set_obj_name(*<glp_prob>*c)v; +glp_set_prob_name(*<glp_prob>*c)v; +glp_set_rii(*<glp_prob>id)v; +glp_set_row_bnds(*<glp_prob>iidd)v; +glp_set_row_name(*<glp_prob>i*c)v; +glp_set_row_stat(*<glp_prob>ii)v; +glp_set_sjj(*<glp_prob>id)v; +glp_set_vertex_name(*<_glp_graph>i*c)v; +glp_simplex(*<glp_prob>*<glp_smcp>)i; +glp_sort_matrix(*<glp_prob>)v; +glp_std_basis(*<glp_prob>)v; +glp_strong_comp(*<_glp_graph>i)i; +glp_term_hook(*p*v)v; +glp_term_out(i)i; +glp_time(); +glp_top_sort(*<_glp_graph>i)i; +glp_transform_col(*<glp_prob>i*i*d)i; +glp_transform_row(*<glp_prob>i*i*d)i; +glp_unscale_prob(*<glp_prob>)v; +glp_version()*c; +glp_vprintf(*c*c)v; +glp_warm_up(*<glp_prob>)i; +glp_wclique_exact(*<_glp_graph>i*di)i; +glp_weak_comp(*<_glp_graph>i)i; +glp_write_asnprob(*<_glp_graph>ii*c)i; +glp_write_ccdata(*<_glp_graph>i*c)i; +glp_write_cnfsat(*<glp_prob>*c)i; +glp_write_graph(*<_glp_graph>*c)i; +glp_write_ipt(*<glp_prob>*c)i; +glp_write_lp(*<glp_prob>*<glp_cpxcp>*c)i; +glp_write_maxflow(*<_glp_graph>iii*c)i; +glp_write_mincost(*<_glp_graph>iiii*c)i; +glp_write_mip(*<glp_prob>*c)i; +glp_write_mps(*<glp_prob>i*<glp_mpscp>*c)i; +glp_write_prob(*<glp_prob>i*c)i; +glp_write_sol(*<glp_prob>*c)i; +") +GLPK_H= +GLP_ASN_MAX=2 +GLP_ASN_MIN=1 +GLP_ASN_MMP=3 +GLP_BF_BG=2 +GLP_BF_FT=1 +GLP_BF_GR=3 +GLP_BR_DTH=4 +GLP_BR_FFV=1 +GLP_BR_LFV=2 +GLP_BR_MFV=3 +GLP_BR_PCH=5 +GLP_BS=1 +GLP_BT_BFS=2 +GLP_BT_BLB=3 +GLP_BT_BPH=4 +GLP_BT_DFS=1 +GLP_BV=3 +GLP_CV=1 +GLP_DATA_DEFINED= +GLP_DB=4 +GLP_DN_BRNCH=1 +GLP_DUAL=3 +GLP_DUALP=2 +GLP_EBADB=0x01 +GLP_EBOUND=0x04 +GLP_ECOND=0x03 +GLP_EDATA=0x12 +GLP_EFAIL=0x05 +GLP_EINSTAB=0x11 +GLP_EITLIM=0x08 +GLP_EMIPGAP=0x0E +GLP_ENOCVG=0x10 +GLP_ENODFS=0x0B +GLP_ENOFEAS=0x0F +GLP_ENOPFS=0x0A +GLP_EOBJLL=0x06 +GLP_EOBJUL=0x07 +GLP_ERANGE=0x13 +GLP_EROOT=0x0C +GLP_ERROR_DEFINED= +GLP_ESING=0x02 +GLP_ESTOP=0x0D +GLP_ETMLIM=0x09 +GLP_FEAS=2 +GLP_FR=1 +GLP_FX=5 +GLP_IBINGO=0x02 +GLP_IBRANCH=0x05 +GLP_ICUTGEN=0x04 +GLP_IHEUR=0x03 +GLP_INFEAS=3 +GLP_IPREPRO=0x07 +GLP_IPT=2 +GLP_IROWGEN=0x01 +GLP_ISELECT=0x06 +GLP_IV=2 +GLP_KKT_CS=5 +GLP_KKT_DB=4 +GLP_KKT_DE=3 +GLP_KKT_PB=2 +GLP_KKT_PE=1 +GLP_LO=2 +GLP_LONG_DEFINED= +GLP_MAJOR_VERSION=4 +GLP_MAX=2 +GLP_MIN=1 +GLP_MINOR_VERSION=47 +GLP_MIP=3 +GLP_MPS_DECK=1 +GLP_MPS_FILE=2 +GLP_MSG_ALL=3 +GLP_MSG_DBG=4 +GLP_MSG_ERR=1 +GLP_MSG_OFF=0 +GLP_MSG_ON=2 +GLP_NF=4 +GLP_NL=2 +GLP_NOFEAS=4 +GLP_NO_BRNCH=0 +GLP_NS=5 +GLP_NU=3 +GLP_OFF=0 +GLP_ON=1 +GLP_OPT=5 +GLP_ORD_AMD=2 +GLP_ORD_NONE=0 +GLP_ORD_QMD=1 +GLP_ORD_SYMAMD=3 +GLP_PP_ALL=2 +GLP_PP_NONE=0 +GLP_PP_ROOT=1 +GLP_PRIMAL=1 +GLP_PROB_DEFINED= +GLP_PT_PSE=0x22 +GLP_PT_STD=0x11 +GLP_RF_CLQ=4 +GLP_RF_COV=3 +GLP_RF_CUT=2 +GLP_RF_GMI=1 +GLP_RF_LAZY=1 +GLP_RF_MIR=2 +GLP_RF_REG=0 +GLP_RT_HAR=0x22 +GLP_RT_STD=0x11 +GLP_SF_2N=0x20 +GLP_SF_AUTO=0x80 +GLP_SF_EQ=0x10 +GLP_SF_GM=0x01 +GLP_SF_SKIP=0x40 +GLP_SOL=1 +GLP_TRAN_DEFINED= +GLP_TREE_DEFINED= +GLP_UNBND=6 +GLP_UNDEF=1 +GLP_UP=3 +GLP_UP_BRNCH=2 +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/ode.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,682 @@ + + +dynbind("ode", " +dAlloc(J)*v; +dAllocateODEDataForThread(I)i; +dAreConnected(*<dxBody>*<dxBody>)i; +dAreConnectedExcluding(*<dxBody>*<dxBody>i)i; +dBodyAddForce(*<dxBody>fff)v; +dBodyAddForceAtPos(*<dxBody>ffffff)v; +dBodyAddForceAtRelPos(*<dxBody>ffffff)v; +dBodyAddRelForce(*<dxBody>fff)v; +dBodyAddRelForceAtPos(*<dxBody>ffffff)v; +dBodyAddRelForceAtRelPos(*<dxBody>ffffff)v; +dBodyAddRelTorque(*<dxBody>fff)v; +dBodyAddTorque(*<dxBody>fff)v; +dBodyCopyPosition(*<dxBody>*f)v; +dBodyCopyQuaternion(*<dxBody>*f)v; +dBodyCopyRotation(*<dxBody>*f)v; +dBodyCreate(*<dxWorld>)*<dxBody>; +dBodyDestroy(*<dxBody>)v; +dBodyDisable(*<dxBody>)v; +dBodyEnable(*<dxBody>)v; +dBodyGetAngularDamping(*<dxBody>)f; +dBodyGetAngularDampingThreshold(*<dxBody>)f; +dBodyGetAngularVel(*<dxBody>)*f; +dBodyGetAutoDisableAngularThreshold(*<dxBody>)f; +dBodyGetAutoDisableAverageSamplesCount(*<dxBody>)i; +dBodyGetAutoDisableFlag(*<dxBody>)i; +dBodyGetAutoDisableLinearThreshold(*<dxBody>)f; +dBodyGetAutoDisableSteps(*<dxBody>)i; +dBodyGetAutoDisableTime(*<dxBody>)f; +dBodyGetData(*<dxBody>)*v; +dBodyGetFiniteRotationAxis(*<dxBody>*f)v; +dBodyGetFiniteRotationMode(*<dxBody>)i; +dBodyGetFirstGeom(*<dxBody>)*<dxGeom>; +dBodyGetForce(*<dxBody>)*f; +dBodyGetGravityMode(*<dxBody>)i; +dBodyGetGyroscopicMode(*<dxBody>)i; +dBodyGetJoint(*<dxBody>i)*<dxJoint>; +dBodyGetLinearDamping(*<dxBody>)f; +dBodyGetLinearDampingThreshold(*<dxBody>)f; +dBodyGetLinearVel(*<dxBody>)*f; +dBodyGetMass(*<dxBody>*<dMass>)v; +dBodyGetMaxAngularSpeed(*<dxBody>)f; +dBodyGetNextGeom(*<dxGeom>)*<dxGeom>; +dBodyGetNumJoints(*<dxBody>)i; +dBodyGetPointVel(*<dxBody>fff*f)v; +dBodyGetPosRelPoint(*<dxBody>fff*f)v; +dBodyGetPosition(*<dxBody>)*f; +dBodyGetQuaternion(*<dxBody>)*f; +dBodyGetRelPointPos(*<dxBody>fff*f)v; +dBodyGetRelPointVel(*<dxBody>fff*f)v; +dBodyGetRotation(*<dxBody>)*f; +dBodyGetTorque(*<dxBody>)*f; +dBodyGetWorld(*<dxBody>)*<dxWorld>; +dBodyIsEnabled(*<dxBody>)i; +dBodyIsKinematic(*<dxBody>)i; +dBodySetAngularDamping(*<dxBody>f)v; +dBodySetAngularDampingThreshold(*<dxBody>f)v; +dBodySetAngularVel(*<dxBody>fff)v; +dBodySetAutoDisableAngularThreshold(*<dxBody>f)v; +dBodySetAutoDisableAverageSamplesCount(*<dxBody>I)v; +dBodySetAutoDisableDefaults(*<dxBody>)v; +dBodySetAutoDisableFlag(*<dxBody>i)v; +dBodySetAutoDisableLinearThreshold(*<dxBody>f)v; +dBodySetAutoDisableSteps(*<dxBody>i)v; +dBodySetAutoDisableTime(*<dxBody>f)v; +dBodySetDamping(*<dxBody>ff)v; +dBodySetDampingDefaults(*<dxBody>)v; +dBodySetData(*<dxBody>*v)v; +dBodySetDynamic(*<dxBody>)v; +dBodySetFiniteRotationAxis(*<dxBody>fff)v; +dBodySetFiniteRotationMode(*<dxBody>i)v; +dBodySetForce(*<dxBody>fff)v; +dBodySetGravityMode(*<dxBody>i)v; +dBodySetGyroscopicMode(*<dxBody>i)v; +dBodySetKinematic(*<dxBody>)v; +dBodySetLinearDamping(*<dxBody>f)v; +dBodySetLinearDampingThreshold(*<dxBody>f)v; +dBodySetLinearVel(*<dxBody>fff)v; +dBodySetMass(*<dxBody>*<dMass>)v; +dBodySetMaxAngularSpeed(*<dxBody>f)v; +dBodySetMovedCallback(*<dxBody>*p)v; +dBodySetPosition(*<dxBody>fff)v; +dBodySetQuaternion(*<dxBody>*f)v; +dBodySetRotation(*<dxBody>*f)v; +dBodySetTorque(*<dxBody>fff)v; +dBodyVectorFromWorld(*<dxBody>fff*f)v; +dBodyVectorToWorld(*<dxBody>fff*f)v; +dBoxBox(*f*f*f*f*f*f*f*f*ii*<dContactGeom>i)i; +dBoxTouchesBox(*f*f*f*f*f*f)i; +dCheckConfiguration(*c)i; +dCleanupODEAllDataForThread()v; +dClearUpperTriangle(*fi)v; +dCloseODE()v; +dClosestLineSegmentPoints(*f*f*f*f*f*f)v; +dCollide(*<dxGeom>*<dxGeom>i*<dContactGeom>i)i; +dConnectingJoint(*<dxBody>*<dxBody>)*<dxJoint>; +dConnectingJointList(*<dxBody>*<dxBody>*)i; +dCreateBox(*<dxSpace>fff)*<dxGeom>; +dCreateCapsule(*<dxSpace>ff)*<dxGeom>; +dCreateConvex(*<dxSpace>*fI*fI*I)*<dxGeom>; +dCreateCylinder(*<dxSpace>ff)*<dxGeom>; +dCreateGeom(i)*<dxGeom>; +dCreateGeomClass(*<dGeomClass>)i; +dCreateGeomTransform(*<dxSpace>)*<dxGeom>; +dCreateHeightfield(*<dxSpace>*<dxHeightfieldData>i)*<dxGeom>; +dCreatePlane(*<dxSpace>ffff)*<dxGeom>; +dCreateRay(*<dxSpace>f)*<dxGeom>; +dCreateSphere(*<dxSpace>f)*<dxGeom>; +dCreateTriMesh(*<dxSpace>*<dxTriMeshData>*p*p*p)*<dxGeom>; +dDQfromW(*f*f*f)v; +dDebug(i*c)v; +dDot(*f*fi)f; +dError(i*c)v; +dFactorCholesky(*fi)i; +dFactorLDLT(*f*fii)v; +dFree(*vJ)v; +dGeomBoxGetLengths(*<dxGeom>*f)v; +dGeomBoxPointDepth(*<dxGeom>fff)f; +dGeomBoxSetLengths(*<dxGeom>fff)v; +dGeomCapsuleGetParams(*<dxGeom>*f*f)v; +dGeomCapsulePointDepth(*<dxGeom>fff)f; +dGeomCapsuleSetParams(*<dxGeom>ff)v; +dGeomClearOffset(*<dxGeom>)v; +dGeomCopyOffsetPosition(*<dxGeom>*f)v; +dGeomCopyOffsetRotation(*<dxGeom>*f)v; +dGeomCopyPosition(*<dxGeom>*f)v; +dGeomCopyRotation(*<dxGeom>*f)v; +dGeomCylinderGetParams(*<dxGeom>*f*f)v; +dGeomCylinderSetParams(*<dxGeom>ff)v; +dGeomDestroy(*<dxGeom>)v; +dGeomDisable(*<dxGeom>)v; +dGeomEnable(*<dxGeom>)v; +dGeomGetAABB(*<dxGeom>*f)v; +dGeomGetBody(*<dxGeom>)*<dxBody>; +dGeomGetBodyNext(*<dxGeom>)*<dxGeom>; +dGeomGetCategoryBits(*<dxGeom>)J; +dGeomGetClass(*<dxGeom>)i; +dGeomGetClassData(*<dxGeom>)*v; +dGeomGetCollideBits(*<dxGeom>)J; +dGeomGetData(*<dxGeom>)*v; +dGeomGetOffsetPosition(*<dxGeom>)*f; +dGeomGetOffsetQuaternion(*<dxGeom>*f)v; +dGeomGetOffsetRotation(*<dxGeom>)*f; +dGeomGetPosition(*<dxGeom>)*f; +dGeomGetQuaternion(*<dxGeom>*f)v; +dGeomGetRotation(*<dxGeom>)*f; +dGeomGetSpace(*<dxGeom>)*<dxSpace>; +dGeomHeightfieldDataBuildByte(*<dxHeightfieldData>*Ciffiifffi)v; +dGeomHeightfieldDataBuildCallback(*<dxHeightfieldData>*v*pffiifffi)v; +dGeomHeightfieldDataBuildDouble(*<dxHeightfieldData>*diffiifffi)v; +dGeomHeightfieldDataBuildShort(*<dxHeightfieldData>*siffiifffi)v; +dGeomHeightfieldDataBuildSingle(*<dxHeightfieldData>*fiffiifffi)v; +dGeomHeightfieldDataCreate()*<dxHeightfieldData>; +dGeomHeightfieldDataDestroy(*<dxHeightfieldData>)v; +dGeomHeightfieldDataSetBounds(*<dxHeightfieldData>ff)v; +dGeomHeightfieldGetHeightfieldData(*<dxGeom>)*<dxHeightfieldData>; +dGeomHeightfieldSetHeightfieldData(*<dxGeom>*<dxHeightfieldData>)v; +dGeomIsEnabled(*<dxGeom>)i; +dGeomIsOffset(*<dxGeom>)i; +dGeomIsSpace(*<dxGeom>)i; +dGeomMoved(*<dxGeom>)v; +dGeomPlaneGetParams(*<dxGeom>*f)v; +dGeomPlanePointDepth(*<dxGeom>fff)f; +dGeomPlaneSetParams(*<dxGeom>ffff)v; +dGeomRayGet(*<dxGeom>*f*f)v; +dGeomRayGetClosestHit(*<dxGeom>)i; +dGeomRayGetLength(*<dxGeom>)f; +dGeomRayGetParams(*<dxGeom>*i*i)v; +dGeomRaySet(*<dxGeom>ffffff)v; +dGeomRaySetClosestHit(*<dxGeom>i)v; +dGeomRaySetLength(*<dxGeom>f)v; +dGeomRaySetParams(*<dxGeom>ii)v; +dGeomSetBody(*<dxGeom>*<dxBody>)v; +dGeomSetCategoryBits(*<dxGeom>J)v; +dGeomSetCollideBits(*<dxGeom>J)v; +dGeomSetConvex(*<dxGeom>*fI*fI*I)v; +dGeomSetData(*<dxGeom>*v)v; +dGeomSetOffsetPosition(*<dxGeom>fff)v; +dGeomSetOffsetQuaternion(*<dxGeom>*f)v; +dGeomSetOffsetRotation(*<dxGeom>*f)v; +dGeomSetOffsetWorldPosition(*<dxGeom>fff)v; +dGeomSetOffsetWorldQuaternion(*<dxGeom>*f)v; +dGeomSetOffsetWorldRotation(*<dxGeom>*f)v; +dGeomSetPosition(*<dxGeom>fff)v; +dGeomSetQuaternion(*<dxGeom>*f)v; +dGeomSetRotation(*<dxGeom>*f)v; +dGeomSphereGetRadius(*<dxGeom>)f; +dGeomSpherePointDepth(*<dxGeom>fff)f; +dGeomSphereSetRadius(*<dxGeom>f)v; +dGeomTransformGetCleanup(*<dxGeom>)i; +dGeomTransformGetGeom(*<dxGeom>)*<dxGeom>; +dGeomTransformGetInfo(*<dxGeom>)i; +dGeomTransformSetCleanup(*<dxGeom>i)v; +dGeomTransformSetGeom(*<dxGeom>*<dxGeom>)v; +dGeomTransformSetInfo(*<dxGeom>i)v; +dGeomTriMeshClearTCCache(*<dxGeom>)v; +dGeomTriMeshDataBuildDouble(*<dxTriMeshData>*vii*vii)v; +dGeomTriMeshDataBuildDouble1(*<dxTriMeshData>*vii*vii*v)v; +dGeomTriMeshDataBuildSimple(*<dxTriMeshData>*fi*Ii)v; +dGeomTriMeshDataBuildSimple1(*<dxTriMeshData>*fi*Ii*i)v; +dGeomTriMeshDataBuildSingle(*<dxTriMeshData>*vii*vii)v; +dGeomTriMeshDataBuildSingle1(*<dxTriMeshData>*vii*vii*v)v; +dGeomTriMeshDataCreate()*<dxTriMeshData>; +dGeomTriMeshDataDestroy(*<dxTriMeshData>)v; +dGeomTriMeshDataGet(*<dxTriMeshData>i)*v; +dGeomTriMeshDataGetBuffer(*<dxTriMeshData>**i)v; +dGeomTriMeshDataPreprocess(*<dxTriMeshData>)v; +dGeomTriMeshDataSet(*<dxTriMeshData>i*v)v; +dGeomTriMeshDataSetBuffer(*<dxTriMeshData>*C)v; +dGeomTriMeshDataUpdate(*<dxTriMeshData>)v; +dGeomTriMeshEnableTC(*<dxGeom>ii)v; +dGeomTriMeshGetArrayCallback(*<dxGeom>)*p; +dGeomTriMeshGetCallback(*<dxGeom>)*p; +dGeomTriMeshGetData(*<dxGeom>)*<dxTriMeshData>; +dGeomTriMeshGetLastTransform(*<dxGeom>)*f; +dGeomTriMeshGetPoint(*<dxGeom>iff*f)v; +dGeomTriMeshGetRayCallback(*<dxGeom>)*p; +dGeomTriMeshGetTriMergeCallback(*<dxGeom>)*p; +dGeomTriMeshGetTriMeshDataID(*<dxGeom>)*<dxTriMeshData>; +dGeomTriMeshGetTriangle(*<dxGeom>i***)v; +dGeomTriMeshGetTriangleCount(*<dxGeom>)i; +dGeomTriMeshIsTCEnabled(*<dxGeom>i)i; +dGeomTriMeshSetArrayCallback(*<dxGeom>*p)v; +dGeomTriMeshSetCallback(*<dxGeom>*p)v; +dGeomTriMeshSetData(*<dxGeom>*<dxTriMeshData>)v; +dGeomTriMeshSetLastTransform(*<dxGeom>*f)v; +dGeomTriMeshSetRayCallback(*<dxGeom>*p)v; +dGeomTriMeshSetTriMergeCallback(*<dxGeom>*p)v; +dGetAllocHandler()*p; +dGetConfiguration()*c; +dGetDebugHandler()*p; +dGetErrorHandler()*p; +dGetFreeHandler()*p; +dGetMessageHandler()*p; +dGetReallocHandler()*p; +dHashSpaceCreate(*<dxSpace>)*<dxSpace>; +dHashSpaceGetLevels(*<dxSpace>*i*i)v; +dHashSpaceSetLevels(*<dxSpace>ii)v; +dInfiniteAABB(*<dxGeom>*f)v; +dInitODE()v; +dInitODE2(I)i; +dInvertPDMatrix(*f*fi)i; +dIsPositiveDefinite(*fi)i; +dJointAddAMotorTorques(*<dxJoint>fff)v; +dJointAddHinge2Torques(*<dxJoint>ff)v; +dJointAddHingeTorque(*<dxJoint>f)v; +dJointAddPRTorque(*<dxJoint>f)v; +dJointAddPUTorque(*<dxJoint>f)v; +dJointAddPistonForce(*<dxJoint>f)v; +dJointAddSliderForce(*<dxJoint>f)v; +dJointAddUniversalTorques(*<dxJoint>ff)v; +dJointAttach(*<dxJoint>*<dxBody>*<dxBody>)v; +dJointCreateAMotor(*<dxWorld>*<dxJointGroup>)*<dxJoint>; +dJointCreateBall(*<dxWorld>*<dxJointGroup>)*<dxJoint>; +dJointCreateContact(*<dxWorld>*<dxJointGroup>*<dContact>)*<dxJoint>; +dJointCreateFixed(*<dxWorld>*<dxJointGroup>)*<dxJoint>; +dJointCreateHinge(*<dxWorld>*<dxJointGroup>)*<dxJoint>; +dJointCreateHinge2(*<dxWorld>*<dxJointGroup>)*<dxJoint>; +dJointCreateLMotor(*<dxWorld>*<dxJointGroup>)*<dxJoint>; +dJointCreateNull(*<dxWorld>*<dxJointGroup>)*<dxJoint>; +dJointCreatePR(*<dxWorld>*<dxJointGroup>)*<dxJoint>; +dJointCreatePU(*<dxWorld>*<dxJointGroup>)*<dxJoint>; +dJointCreatePiston(*<dxWorld>*<dxJointGroup>)*<dxJoint>; +dJointCreatePlane2D(*<dxWorld>*<dxJointGroup>)*<dxJoint>; +dJointCreateSlider(*<dxWorld>*<dxJointGroup>)*<dxJoint>; +dJointCreateUniversal(*<dxWorld>*<dxJointGroup>)*<dxJoint>; +dJointDestroy(*<dxJoint>)v; +dJointDisable(*<dxJoint>)v; +dJointEnable(*<dxJoint>)v; +dJointGetAMotorAngle(*<dxJoint>i)f; +dJointGetAMotorAngleRate(*<dxJoint>i)f; +dJointGetAMotorAxis(*<dxJoint>i*f)v; +dJointGetAMotorAxisRel(*<dxJoint>i)i; +dJointGetAMotorMode(*<dxJoint>)i; +dJointGetAMotorNumAxes(*<dxJoint>)i; +dJointGetAMotorParam(*<dxJoint>i)f; +dJointGetBallAnchor(*<dxJoint>*f)v; +dJointGetBallAnchor2(*<dxJoint>*f)v; +dJointGetBallParam(*<dxJoint>i)f; +dJointGetBody(*<dxJoint>i)*<dxBody>; +dJointGetData(*<dxJoint>)*v; +dJointGetFeedback(*<dxJoint>)*<dJointFeedback>; +dJointGetFixedParam(*<dxJoint>i)f; +dJointGetHinge2Anchor(*<dxJoint>*f)v; +dJointGetHinge2Anchor2(*<dxJoint>*f)v; +dJointGetHinge2Angle1(*<dxJoint>)f; +dJointGetHinge2Angle1Rate(*<dxJoint>)f; +dJointGetHinge2Angle2Rate(*<dxJoint>)f; +dJointGetHinge2Axis1(*<dxJoint>*f)v; +dJointGetHinge2Axis2(*<dxJoint>*f)v; +dJointGetHinge2Param(*<dxJoint>i)f; +dJointGetHingeAnchor(*<dxJoint>*f)v; +dJointGetHingeAnchor2(*<dxJoint>*f)v; +dJointGetHingeAngle(*<dxJoint>)f; +dJointGetHingeAngleRate(*<dxJoint>)f; +dJointGetHingeAxis(*<dxJoint>*f)v; +dJointGetHingeParam(*<dxJoint>i)f; +dJointGetLMotorAxis(*<dxJoint>i*f)v; +dJointGetLMotorNumAxes(*<dxJoint>)i; +dJointGetLMotorParam(*<dxJoint>i)f; +dJointGetNumBodies(*<dxJoint>)i; +dJointGetPRAnchor(*<dxJoint>*f)v; +dJointGetPRAngle(*<dxJoint>)f; +dJointGetPRAngleRate(*<dxJoint>)f; +dJointGetPRAxis1(*<dxJoint>*f)v; +dJointGetPRAxis2(*<dxJoint>*f)v; +dJointGetPRParam(*<dxJoint>i)f; +dJointGetPRPosition(*<dxJoint>)f; +dJointGetPRPositionRate(*<dxJoint>)f; +dJointGetPUAnchor(*<dxJoint>*f)v; +dJointGetPUAngle1(*<dxJoint>)f; +dJointGetPUAngle1Rate(*<dxJoint>)f; +dJointGetPUAngle2(*<dxJoint>)f; +dJointGetPUAngle2Rate(*<dxJoint>)f; +dJointGetPUAngles(*<dxJoint>*f*f)v; +dJointGetPUAxis1(*<dxJoint>*f)v; +dJointGetPUAxis2(*<dxJoint>*f)v; +dJointGetPUAxis3(*<dxJoint>*f)v; +dJointGetPUAxisP(*<dxJoint>*f)v; +dJointGetPUParam(*<dxJoint>i)f; +dJointGetPUPosition(*<dxJoint>)f; +dJointGetPUPositionRate(*<dxJoint>)f; +dJointGetPistonAnchor(*<dxJoint>*f)v; +dJointGetPistonAnchor2(*<dxJoint>*f)v; +dJointGetPistonAngle(*<dxJoint>)f; +dJointGetPistonAngleRate(*<dxJoint>)f; +dJointGetPistonAxis(*<dxJoint>*f)v; +dJointGetPistonParam(*<dxJoint>i)f; +dJointGetPistonPosition(*<dxJoint>)f; +dJointGetPistonPositionRate(*<dxJoint>)f; +dJointGetSliderAxis(*<dxJoint>*f)v; +dJointGetSliderParam(*<dxJoint>i)f; +dJointGetSliderPosition(*<dxJoint>)f; +dJointGetSliderPositionRate(*<dxJoint>)f; +dJointGetType(*<dxJoint>)i; +dJointGetUniversalAnchor(*<dxJoint>*f)v; +dJointGetUniversalAnchor2(*<dxJoint>*f)v; +dJointGetUniversalAngle1(*<dxJoint>)f; +dJointGetUniversalAngle1Rate(*<dxJoint>)f; +dJointGetUniversalAngle2(*<dxJoint>)f; +dJointGetUniversalAngle2Rate(*<dxJoint>)f; +dJointGetUniversalAngles(*<dxJoint>*f*f)v; +dJointGetUniversalAxis1(*<dxJoint>*f)v; +dJointGetUniversalAxis2(*<dxJoint>*f)v; +dJointGetUniversalParam(*<dxJoint>i)f; +dJointGroupCreate(i)*<dxJointGroup>; +dJointGroupDestroy(*<dxJointGroup>)v; +dJointGroupEmpty(*<dxJointGroup>)v; +dJointIsEnabled(*<dxJoint>)i; +dJointSetAMotorAngle(*<dxJoint>if)v; +dJointSetAMotorAxis(*<dxJoint>iifff)v; +dJointSetAMotorMode(*<dxJoint>i)v; +dJointSetAMotorNumAxes(*<dxJoint>i)v; +dJointSetAMotorParam(*<dxJoint>if)v; +dJointSetBallAnchor(*<dxJoint>fff)v; +dJointSetBallAnchor2(*<dxJoint>fff)v; +dJointSetBallParam(*<dxJoint>if)v; +dJointSetData(*<dxJoint>*v)v; +dJointSetFeedback(*<dxJoint>*<dJointFeedback>)v; +dJointSetFixed(*<dxJoint>)v; +dJointSetFixedParam(*<dxJoint>if)v; +dJointSetHinge2Anchor(*<dxJoint>fff)v; +dJointSetHinge2Axis1(*<dxJoint>fff)v; +dJointSetHinge2Axis2(*<dxJoint>fff)v; +dJointSetHinge2Param(*<dxJoint>if)v; +dJointSetHingeAnchor(*<dxJoint>fff)v; +dJointSetHingeAnchorDelta(*<dxJoint>ffffff)v; +dJointSetHingeAxis(*<dxJoint>fff)v; +dJointSetHingeAxisOffset(*<dxJoint>ffff)v; +dJointSetHingeParam(*<dxJoint>if)v; +dJointSetLMotorAxis(*<dxJoint>iifff)v; +dJointSetLMotorNumAxes(*<dxJoint>i)v; +dJointSetLMotorParam(*<dxJoint>if)v; +dJointSetPRAnchor(*<dxJoint>fff)v; +dJointSetPRAxis1(*<dxJoint>fff)v; +dJointSetPRAxis2(*<dxJoint>fff)v; +dJointSetPRParam(*<dxJoint>if)v; +dJointSetPUAnchor(*<dxJoint>fff)v; +dJointSetPUAnchorDelta(*<dxJoint>ffffff)v; +dJointSetPUAnchorOffset(*<dxJoint>ffffff)v; +dJointSetPUAxis1(*<dxJoint>fff)v; +dJointSetPUAxis2(*<dxJoint>fff)v; +dJointSetPUAxis3(*<dxJoint>fff)v; +dJointSetPUAxisP(*<dxJoint>fff)v; +dJointSetPUParam(*<dxJoint>if)v; +dJointSetPistonAnchor(*<dxJoint>fff)v; +dJointSetPistonAnchorOffset(*<dxJoint>ffffff)v; +dJointSetPistonAxis(*<dxJoint>fff)v; +dJointSetPistonAxisDelta(*<dxJoint>ffffff)v; +dJointSetPistonParam(*<dxJoint>if)v; +dJointSetPlane2DAngleParam(*<dxJoint>if)v; +dJointSetPlane2DXParam(*<dxJoint>if)v; +dJointSetPlane2DYParam(*<dxJoint>if)v; +dJointSetSliderAxis(*<dxJoint>fff)v; +dJointSetSliderAxisDelta(*<dxJoint>ffffff)v; +dJointSetSliderParam(*<dxJoint>if)v; +dJointSetUniversalAnchor(*<dxJoint>fff)v; +dJointSetUniversalAxis1(*<dxJoint>fff)v; +dJointSetUniversalAxis1Offset(*<dxJoint>fffff)v; +dJointSetUniversalAxis2(*<dxJoint>fff)v; +dJointSetUniversalAxis2Offset(*<dxJoint>fffff)v; +dJointSetUniversalParam(*<dxJoint>if)v; +dLDLTAddTL(*f*f*fii)v; +dLDLTRemove(**i*f*fiiii)v; +dMakeRandomMatrix(*fiif)v; +dMakeRandomVector(*fif)v; +dMassAdd(*<dMass>*<dMass>)v; +dMassAdjust(*<dMass>f)v; +dMassCheck(*<dMass>)i; +dMassRotate(*<dMass>*f)v; +dMassSetBox(*<dMass>ffff)v; +dMassSetBoxTotal(*<dMass>ffff)v; +dMassSetCappedCylinder(*<dMass>fiff)v; +dMassSetCappedCylinderTotal(*<dMass>fiff)v; +dMassSetCapsule(*<dMass>fiff)v; +dMassSetCapsuleTotal(*<dMass>fiff)v; +dMassSetCylinder(*<dMass>fiff)v; +dMassSetCylinderTotal(*<dMass>fiff)v; +dMassSetParameters(*<dMass>ffffffffff)v; +dMassSetSphere(*<dMass>ff)v; +dMassSetSphereTotal(*<dMass>ff)v; +dMassSetTrimesh(*<dMass>f*<dxGeom>)v; +dMassSetTrimeshTotal(*<dMass>f*<dxGeom>)v; +dMassSetZero(*<dMass>)v; +dMassTranslate(*<dMass>fff)v; +dMaxDifference(*f*fii)f; +dMaxDifferenceLowerTriangle(*f*fi)f; +dMessage(i*c)v; +dMultiply0(*f*f*fiii)v; +dMultiply1(*f*f*fiii)v; +dMultiply2(*f*f*fiii)v; +dNormalize3(*f)v; +dNormalize4(*f)v; +dOrthogonalizeR(*f)v; +dPlaneSpace(*f*f*f)v; +dPrintMatrix(*fii*c*<__sFILE>)v; +dQFromAxisAndAngle(*fffff)v; +dQMultiply0(*f*f*f)v; +dQMultiply1(*f*f*f)v; +dQMultiply2(*f*f*f)v; +dQMultiply3(*f*f*f)v; +dQSetIdentity(*f)v; +dQfromR(*f*f)v; +dQuadTreeSpaceCreate(*<dxSpace>*f*fi)*<dxSpace>; +dRFrom2Axes(*fffffff)v; +dRFromAxisAndAngle(*fffff)v; +dRFromEulerAngles(*ffff)v; +dRFromZAxis(*ffff)v; +dRSetIdentity(*f)v; +dRand()J; +dRandGetSeed()J; +dRandInt(i)i; +dRandReal()f; +dRandSetSeed(J)v; +dRealloc(*vJJ)*v; +dRemoveRowCol(*fiii)v; +dRfromQ(*f*f)v; +dSafeNormalize3(*f)i; +dSafeNormalize4(*f)i; +dSetAllocHandler(*p)v; +dSetColliderOverride(ii*p)v; +dSetDebugHandler(*p)v; +dSetErrorHandler(*p)v; +dSetFreeHandler(*p)v; +dSetMessageHandler(*p)v; +dSetReallocHandler(*p)v; +dSetValue(*fif)v; +dSetZero(*fi)v; +dSimpleSpaceCreate(*<dxSpace>)*<dxSpace>; +dSolveCholesky(*f*fi)v; +dSolveL1(*f*fii)v; +dSolveL1T(*f*fii)v; +dSolveLDLT(*f*f*fii)v; +dSpaceAdd(*<dxSpace>*<dxGeom>)v; +dSpaceClean(*<dxSpace>)v; +dSpaceCollide(*<dxSpace>*v*p)v; +dSpaceCollide2(*<dxGeom>*<dxGeom>*v*p)v; +dSpaceDestroy(*<dxSpace>)v; +dSpaceGetClass(*<dxSpace>)i; +dSpaceGetCleanup(*<dxSpace>)i; +dSpaceGetGeom(*<dxSpace>i)*<dxGeom>; +dSpaceGetManualCleanup(*<dxSpace>)i; +dSpaceGetNumGeoms(*<dxSpace>)i; +dSpaceGetSublevel(*<dxSpace>)i; +dSpaceQuery(*<dxSpace>*<dxGeom>)i; +dSpaceRemove(*<dxSpace>*<dxGeom>)v; +dSpaceSetCleanup(*<dxSpace>i)v; +dSpaceSetManualCleanup(*<dxSpace>i)v; +dSpaceSetSublevel(*<dxSpace>i)v; +dStopwatchReset(*<dStopwatch>)v; +dStopwatchStart(*<dStopwatch>)v; +dStopwatchStop(*<dStopwatch>)v; +dStopwatchTime(*<dStopwatch>)d; +dSweepAndPruneSpaceCreate(*<dxSpace>i)*<dxSpace>; +dTestRand()i; +dTimerEnd()v; +dTimerNow(*c)v; +dTimerReport(*<__sFILE>i)v; +dTimerResolution()d; +dTimerStart(*c)v; +dTimerTicksPerSecond()d; +dVectorScale(*f*fi)v; +dWorldCreate()*<dxWorld>; +dWorldDestroy(*<dxWorld>)v; +dWorldExportDIF(*<dxWorld>*<__sFILE>*c)v; +dWorldGetAngularDamping(*<dxWorld>)f; +dWorldGetAngularDampingThreshold(*<dxWorld>)f; +dWorldGetAutoDisableAngularAverageThreshold(*<dxWorld>)f; +dWorldGetAutoDisableAngularThreshold(*<dxWorld>)f; +dWorldGetAutoDisableAverageSamplesCount(*<dxWorld>)i; +dWorldGetAutoDisableFlag(*<dxWorld>)i; +dWorldGetAutoDisableLinearAverageThreshold(*<dxWorld>)f; +dWorldGetAutoDisableLinearThreshold(*<dxWorld>)f; +dWorldGetAutoDisableSteps(*<dxWorld>)i; +dWorldGetAutoDisableTime(*<dxWorld>)f; +dWorldGetAutoEnableDepthSF1(*<dxWorld>)i; +dWorldGetCFM(*<dxWorld>)f; +dWorldGetContactMaxCorrectingVel(*<dxWorld>)f; +dWorldGetContactSurfaceLayer(*<dxWorld>)f; +dWorldGetERP(*<dxWorld>)f; +dWorldGetGravity(*<dxWorld>*f)v; +dWorldGetLinearDamping(*<dxWorld>)f; +dWorldGetLinearDampingThreshold(*<dxWorld>)f; +dWorldGetMaxAngularSpeed(*<dxWorld>)f; +dWorldGetQuickStepNumIterations(*<dxWorld>)i; +dWorldGetQuickStepW(*<dxWorld>)f; +dWorldImpulseToForce(*<dxWorld>ffff*f)v; +dWorldQuickStep(*<dxWorld>f)v; +dWorldSetAngularDamping(*<dxWorld>f)v; +dWorldSetAngularDampingThreshold(*<dxWorld>f)v; +dWorldSetAutoDisableAngularAverageThreshold(*<dxWorld>f)v; +dWorldSetAutoDisableAngularThreshold(*<dxWorld>f)v; +dWorldSetAutoDisableAverageSamplesCount(*<dxWorld>I)v; +dWorldSetAutoDisableFlag(*<dxWorld>i)v; +dWorldSetAutoDisableLinearAverageThreshold(*<dxWorld>f)v; +dWorldSetAutoDisableLinearThreshold(*<dxWorld>f)v; +dWorldSetAutoDisableSteps(*<dxWorld>i)v; +dWorldSetAutoDisableTime(*<dxWorld>f)v; +dWorldSetAutoEnableDepthSF1(*<dxWorld>i)v; +dWorldSetCFM(*<dxWorld>f)v; +dWorldSetContactMaxCorrectingVel(*<dxWorld>f)v; +dWorldSetContactSurfaceLayer(*<dxWorld>f)v; +dWorldSetDamping(*<dxWorld>ff)v; +dWorldSetERP(*<dxWorld>f)v; +dWorldSetGravity(*<dxWorld>fff)v; +dWorldSetLinearDamping(*<dxWorld>f)v; +dWorldSetLinearDampingThreshold(*<dxWorld>f)v; +dWorldSetMaxAngularSpeed(*<dxWorld>f)v; +dWorldSetQuickStepNumIterations(*<dxWorld>i)v; +dWorldSetQuickStepW(*<dxWorld>f)v; +dWorldStep(*<dxWorld>f)v; +dWorldStepFast1(*<dxWorld>fi)v; +") +parseStructInfos(" +dGeomClass{i*p*p*p*p}bytes collider aabb aabb_test dtor ; +dxHeightfieldData{}; +dxTriMeshData{}; +dSurfaceParameters{ifffffffffff}mode mu mu2 bounce bounce_vel soft_erp soft_cfm motion1 motion2 motionN slip1 slip2 ; +dxJointGroup{}; +dxJointNode{}; +dxJoint{}; +dxGeom{}; +dxBody{}; +dxSpace{}; +dxWorld{}; +") +dSphereClass=0; +dBoxClass=1; +dCapsuleClass=2; +dCylinderClass=3; +dPlaneClass=4; +dRayClass=5; +dConvexClass=6; +dGeomTransformClass=7; +dTriMeshClass=8; +dHeightfieldClass=9; +dFirstSpaceClass=10; +dSimpleSpaceClass=10; +dHashSpaceClass=11; +dSweepAndPruneSpaceClass=12; +dQuadTreeSpaceClass=13; +dLastSpaceClass=13; +dFirstUserClass=14; +dLastUserClass=17; +dGeomNumClasses=18; +dMaxUserClasses=4; +dContactMu2=1; +dContactFDir1=2; +dContactBounce=4; +dContactSoftERP=8; +dContactSoftCFM=16; +dContactMotion1=32; +dContactMotion2=64; +dContactMotionN=128; +dContactSlip1=256; +dContactSlip2=512; +dContactApprox0=0; +dContactApprox1_1=4096; +dContactApprox1_2=8192; +dContactApprox1=12288; +dAllocateFlagBasicData=0; +dAllocateFlagCollisionData=1; +dAllocateMaskAll=-1; +dInitFlagManualThreadCleanup=1; +dAMotorUser=0; +dAMotorEuler=1; +dParamLoStop=0; +dParamHiStop=1; +dParamVel=2; +dParamFMax=3; +dParamFudgeFactor=4; +dParamBounce=5; +dParamCFM=6; +dParamStopERP=7; +dParamStopCFM=8; +dParamSuspensionERP=9; +dParamSuspensionCFM=10; +dParamERP=11; +dParamsInGroup=12; +dParamGroup1=0; +dParamLoStop1=0; +dParamHiStop1=1; +dParamVel1=2; +dParamFMax1=3; +dParamFudgeFactor1=4; +dParamBounce1=5; +dParamCFM1=6; +dParamStopERP1=7; +dParamStopCFM1=8; +dParamSuspensionERP1=9; +dParamSuspensionCFM1=10; +dParamERP1=11; +dParamGroup2=256; +dParamLoStop2=256; +dParamHiStop2=257; +dParamVel2=258; +dParamFMax2=259; +dParamFudgeFactor2=260; +dParamBounce2=261; +dParamCFM2=262; +dParamStopERP2=263; +dParamStopCFM2=264; +dParamSuspensionERP2=265; +dParamSuspensionCFM2=266; +dParamERP2=267; +dParamGroup3=512; +dParamLoStop3=512; +dParamHiStop3=513; +dParamVel3=514; +dParamFMax3=515; +dParamFudgeFactor3=516; +dParamBounce3=517; +dParamCFM3=518; +dParamStopERP3=519; +dParamStopCFM3=520; +dParamSuspensionERP3=521; +dParamSuspensionCFM3=522; +dParamERP3=523; +dParamGroup=256; +dJointTypeNone=0; +dJointTypeBall=1; +dJointTypeHinge=2; +dJointTypeSlider=3; +dJointTypeContact=4; +dJointTypeUniversal=5; +dJointTypeHinge2=6; +dJointTypeFixed=7; +dJointTypeNull=8; +dJointTypeAMotor=9; +dJointTypeLMotor=10; +dJointTypePlane2D=11; +dJointTypePR=12; +dJointTypePU=13; +dJointTypePiston=14; +dCCylinderClass=dCapsuleClass +dCreateCCylinder=dCreateCapsule +dGeomCCylinderGetParams=dGeomCapsuleGetParams +dGeomCCylinderPointDepth=dGeomCapsulePointDepth +dGeomCCylinderSetParams=dGeomCapsuleSetParams +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/opencl.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,368 @@ + + +dynbind("OpenCL", " +clBuildProgram(*<_cl_program>I**<_cl_device_id>*c*p*v)i; +clCreateBuffer(*<_cl_context>LJ*v*i)*<_cl_mem>; +clCreateCommandQueue(*<_cl_context>*<_cl_device_id>L*i)*<_cl_command_queue>; +clCreateContext(*jI**<_cl_device_id>*p*v*i)*<_cl_context>; +clCreateContextFromType(*jL*p*v*i)*<_cl_context>; +clCreateFromGLBuffer(*<_cl_context>LI*i)*<_cl_mem>; +clCreateFromGLRenderbuffer(*<_cl_context>LI*i)*<_cl_mem>; +clCreateFromGLTexture2D(*<_cl_context>LIiI*i)*<_cl_mem>; +clCreateFromGLTexture3D(*<_cl_context>LIiI*i)*<_cl_mem>; +clCreateImage2D(*<_cl_context>L*<_cl_image_format>JJJ*v*i)*<_cl_mem>; +clCreateImage3D(*<_cl_context>L*<_cl_image_format>JJJJJ*v*i)*<_cl_mem>; +clCreateKernel(*<_cl_program>*c*i)*<_cl_kernel>; +clCreateKernelsInProgram(*<_cl_program>I**<_cl_kernel>*I)i; +clCreateProgramWithBinary(*<_cl_context>I**<_cl_device_id>*J**C*i*i)*<_cl_program>; +clCreateProgramWithSource(*<_cl_context>I**c*J*i)*<_cl_program>; +clCreateSampler(*<_cl_context>III*i)*<_cl_sampler>; +clEnqueueAcquireGLObjects(*<_cl_command_queue>I**<_cl_mem>I**<_cl_event>**<_cl_event>)i; +clEnqueueBarrier(*<_cl_command_queue>)i; +clEnqueueCopyBuffer(*<_cl_command_queue>*<_cl_mem>*<_cl_mem>JJJI**<_cl_event>**<_cl_event>)i; +clEnqueueCopyBufferToImage(*<_cl_command_queue>*<_cl_mem>*<_cl_mem>J*J*JI**<_cl_event>**<_cl_event>)i; +clEnqueueCopyImage(*<_cl_command_queue>*<_cl_mem>*<_cl_mem>*J*J*JI**<_cl_event>**<_cl_event>)i; +clEnqueueCopyImageToBuffer(*<_cl_command_queue>*<_cl_mem>*<_cl_mem>*J*JJI**<_cl_event>**<_cl_event>)i; +clEnqueueMapBuffer(*<_cl_command_queue>*<_cl_mem>ILJJI**<_cl_event>**<_cl_event>*i)*v; +clEnqueueMapImage(*<_cl_command_queue>*<_cl_mem>IL*J*J*J*JI**<_cl_event>**<_cl_event>*i)*v; +clEnqueueMarker(*<_cl_command_queue>**<_cl_event>)i; +clEnqueueNDRangeKernel(*<_cl_command_queue>*<_cl_kernel>I*J*J*JI**<_cl_event>**<_cl_event>)i; +clEnqueueNativeKernel(*<_cl_command_queue>*p*vJI**<_cl_mem>**vI**<_cl_event>**<_cl_event>)i; +clEnqueueReadBuffer(*<_cl_command_queue>*<_cl_mem>IJJ*vI**<_cl_event>**<_cl_event>)i; +clEnqueueReadImage(*<_cl_command_queue>*<_cl_mem>I*J*JJJ*vI**<_cl_event>**<_cl_event>)i; +clEnqueueReleaseGLObjects(*<_cl_command_queue>I**<_cl_mem>I**<_cl_event>**<_cl_event>)i; +clEnqueueTask(*<_cl_command_queue>*<_cl_kernel>I**<_cl_event>**<_cl_event>)i; +clEnqueueUnmapMemObject(*<_cl_command_queue>*<_cl_mem>*vI**<_cl_event>**<_cl_event>)i; +clEnqueueWaitForEvents(*<_cl_command_queue>I**<_cl_event>)i; +clEnqueueWriteBuffer(*<_cl_command_queue>*<_cl_mem>IJJ*vI**<_cl_event>**<_cl_event>)i; +clEnqueueWriteImage(*<_cl_command_queue>*<_cl_mem>I*J*JJJ*vI**<_cl_event>**<_cl_event>)i; +clFinish(*<_cl_command_queue>)i; +clFlush(*<_cl_command_queue>)i; +clGetCommandQueueInfo(*<_cl_command_queue>IJ*v*J)i; +clGetContextInfo(*<_cl_context>IJ*v*J)i; +clGetDeviceIDs(*<_cl_platform_id>LI**<_cl_device_id>*I)i; +clGetDeviceInfo(*<_cl_device_id>IJ*v*J)i; +clGetEventInfo(*<_cl_event>IJ*v*J)i; +clGetEventProfilingInfo(*<_cl_event>IJ*v*J)i; +clGetExtensionFunctionAddress(*c)*v; +clGetGLContextInfoAPPLE(*<_cl_context>*vIJ*v*J)i; +clGetGLObjectInfo(*<_cl_mem>*I*I)i; +clGetGLTextureInfo(*<_cl_mem>IJ*v*J)i; +clGetImageInfo(*<_cl_mem>IJ*v*J)i; +clGetKernelInfo(*<_cl_kernel>IJ*v*J)i; +clGetKernelWorkGroupInfo(*<_cl_kernel>*<_cl_device_id>IJ*v*J)i; +clGetMemObjectInfo(*<_cl_mem>IJ*v*J)i; +clGetPlatformIDs(I**<_cl_platform_id>*I)i; +clGetPlatformInfo(*<_cl_platform_id>IJ*v*J)i; +clGetProgramBuildInfo(*<_cl_program>*<_cl_device_id>IJ*v*J)i; +clGetProgramInfo(*<_cl_program>IJ*v*J)i; +clGetSamplerInfo(*<_cl_sampler>IJ*v*J)i; +clGetSupportedImageFormats(*<_cl_context>LII*<_cl_image_format>*I)i; +clLogMessagesToStderrAPPLE(*c*vJ*v)v; +clLogMessagesToStdoutAPPLE(*c*vJ*v)v; +clLogMessagesToSystemLogAPPLE(*c*vJ*v)v; +clReleaseCommandQueue(*<_cl_command_queue>)i; +clReleaseContext(*<_cl_context>)i; +clReleaseEvent(*<_cl_event>)i; +clReleaseKernel(*<_cl_kernel>)i; +clReleaseMemObject(*<_cl_mem>)i; +clReleaseProgram(*<_cl_program>)i; +clReleaseSampler(*<_cl_sampler>)i; +clRetainCommandQueue(*<_cl_command_queue>)i; +clRetainContext(*<_cl_context>)i; +clRetainEvent(*<_cl_event>)i; +clRetainKernel(*<_cl_kernel>)i; +clRetainMemObject(*<_cl_mem>)i; +clRetainProgram(*<_cl_program>)i; +clRetainSampler(*<_cl_sampler>)i; +clSetCommandQueueProperty(*<_cl_command_queue>LI*L)i; +clSetKernelArg(*<_cl_kernel>IJ*v)i; +clSetMemObjectDestructorAPPLE(*<_cl_mem>*p*v)i; +clUnloadCompiler()i; +clWaitForEvents(I**<_cl_event>)i; +") +parseStructInfos(" +_cl_image_format{II}image_channel_order image_channel_data_type ; +_cl_sampler{}; +_cl_event{}; +_cl_kernel{}; +_cl_program{}; +_cl_mem{}; +_cl_command_queue{}; +_cl_context{}; +_cl_device_id{}; +_cl_platform_id{}; +") +CL_A=0x10B1 +CL_ADDRESS_CLAMP=0x1132 +CL_ADDRESS_CLAMP_TO_EDGE=0x1131 +CL_ADDRESS_NONE=0x1130 +CL_ADDRESS_REPEAT=0x1133 +CL_API_CALL= +CL_API_ENTRY= +CL_API_SUFFIX__VERSION_1_0= +CL_ARGB=0x10B7 +CL_BGRA=0x10B6 +CL_BUILD_ERROR=-2 +CL_BUILD_IN_PROGRESS=-3 +CL_BUILD_NONE=-1 +CL_BUILD_PROGRAM_FAILURE=-11 +CL_BUILD_SUCCESS=0 +CL_CGL_DEVICES_FOR_SUPPORTED_VIRTUAL_SCREENS_APPLE=0x10000003 +CL_CGL_DEVICE_FOR_CURRENT_VIRTUAL_SCREEN_APPLE=0x10000002 +CL_CHAR_BIT=8 +CL_CHAR_MAX=127 +CL_CHAR_MIN=(-127-1) +CL_COMMAND_ACQUIRE_GL_OBJECTS=0x11FF +CL_COMMAND_COPY_BUFFER=0x11F5 +CL_COMMAND_COPY_BUFFER_TO_IMAGE=0x11FA +CL_COMMAND_COPY_IMAGE=0x11F8 +CL_COMMAND_COPY_IMAGE_TO_BUFFER=0x11F9 +CL_COMMAND_MAP_BUFFER=0x11FB +CL_COMMAND_MAP_IMAGE=0x11FC +CL_COMMAND_MARKER=0x11FE +CL_COMMAND_NATIVE_KERNEL=0x11F2 +CL_COMMAND_NDRANGE_KERNEL=0x11F0 +CL_COMMAND_READ_BUFFER=0x11F3 +CL_COMMAND_READ_IMAGE=0x11F6 +CL_COMMAND_RELEASE_GL_OBJECTS=0x1200 +CL_COMMAND_TASK=0x11F1 +CL_COMMAND_UNMAP_MEM_OBJECT=0x11FD +CL_COMMAND_WRITE_BUFFER=0x11F4 +CL_COMMAND_WRITE_IMAGE=0x11F7 +CL_COMPILER_NOT_AVAILABLE=-3 +CL_COMPLETE=0x0 +CL_CONTEXT_DEVICES=0x1081 +CL_CONTEXT_PLATFORM=0x1084 +CL_CONTEXT_PROPERTIES=0x1082 +CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE=0x10000000 +CL_CONTEXT_REFERENCE_COUNT=0x1080 +CL_DBL_DIG=15 +# CL_DBL_EPSILON=0x1.0p-52 +CL_DBL_MANT_DIG=53 +CL_DBL_MAX=0x1.fffffffffffffp1023 +CL_DBL_MAX_10_EXP=+308 +CL_DBL_MAX_EXP=+1024 +CL_DBL_MIN=0x1.0p-1022 +CL_DBL_MIN_10_EXP=-307 +CL_DBL_MIN_EXP=-1021 +CL_DBL_RADIX=2 +CL_DEVICE_ADDRESS_BITS=0x100D +CL_DEVICE_AVAILABLE=0x1027 +CL_DEVICE_COMPILER_AVAILABLE=0x1028 +CL_DEVICE_COMPILER_NOT_AVAILABLE=-3 +CL_DEVICE_ENDIAN_LITTLE=0x1026 +CL_DEVICE_ERROR_CORRECTION_SUPPORT=0x1024 +CL_DEVICE_EXECUTION_CAPABILITIES=0x1029 +CL_DEVICE_EXTENSIONS=0x1030 +CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE=0x101D +CL_DEVICE_GLOBAL_MEM_CACHE_SIZE=0x101E +CL_DEVICE_GLOBAL_MEM_CACHE_TYPE=0x101C +CL_DEVICE_GLOBAL_MEM_SIZE=0x101F +CL_DEVICE_IMAGE2D_MAX_HEIGHT=0x1012 +CL_DEVICE_IMAGE2D_MAX_WIDTH=0x1011 +CL_DEVICE_IMAGE3D_MAX_DEPTH=0x1015 +CL_DEVICE_IMAGE3D_MAX_HEIGHT=0x1014 +CL_DEVICE_IMAGE3D_MAX_WIDTH=0x1013 +CL_DEVICE_IMAGE_SUPPORT=0x1016 +CL_DEVICE_LOCAL_MEM_SIZE=0x1023 +CL_DEVICE_LOCAL_MEM_TYPE=0x1022 +CL_DEVICE_MAX_CLOCK_FREQUENCY=0x100C +CL_DEVICE_MAX_COMPUTE_UNITS=0x1002 +CL_DEVICE_MAX_CONSTANT_ARGS=0x1021 +CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE=0x1020 +CL_DEVICE_MAX_MEM_ALLOC_SIZE=0x1010 +CL_DEVICE_MAX_PARAMETER_SIZE=0x1017 +CL_DEVICE_MAX_READ_IMAGE_ARGS=0x100E +CL_DEVICE_MAX_SAMPLERS=0x1018 +CL_DEVICE_MAX_WORK_GROUP_SIZE=0x1004 +CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS=0x1003 +CL_DEVICE_MAX_WORK_ITEM_SIZES=0x1005 +CL_DEVICE_MAX_WRITE_IMAGE_ARGS=0x100F +CL_DEVICE_MEM_BASE_ADDR_ALIGN=0x1019 +CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE=0x101A +CL_DEVICE_NAME=0x102B +CL_DEVICE_NOT_AVAILABLE=-2 +CL_DEVICE_NOT_FOUND=-1 +CL_DEVICE_PLATFORM=0x1031 +CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR=0x1006 +CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE=0x100B +CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT=0x100A +CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT=0x1008 +CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG=0x1009 +CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT=0x1007 +CL_DEVICE_PROFILE=0x102E +CL_DEVICE_PROFILING_TIMER_RESOLUTION=0x1025 +CL_DEVICE_QUEUE_PROPERTIES=0x102A +CL_DEVICE_SINGLE_FP_CONFIG=0x101B +CL_DEVICE_TYPE=0x1000 +CL_DEVICE_TYPE_ALL=0xFFFFFFFF +CL_DEVICE_VENDOR=0x102C +CL_DEVICE_VENDOR_ID=0x1001 +CL_DEVICE_VERSION=0x102F +CL_DRIVER_VERSION=0x102D +CL_EVENT_COMMAND_EXECUTION_STATUS=0x11D3 +CL_EVENT_COMMAND_QUEUE=0x11D0 +CL_EVENT_COMMAND_TYPE=0x11D1 +CL_EVENT_REFERENCE_COUNT=0x11D2 +# CL_EXTENSION_WEAK_LINK=__attribute__((weak_import)) +CL_FALSE=0 +CL_FILTER_LINEAR=0x1141 +CL_FILTER_NEAREST=0x1140 +CL_FLOAT=0x10DE +CL_FLT_DIG=6 +# CL_FLT_EPSILON=0x1.0p-23f +CL_FLT_MANT_DIG=24 +# CL_FLT_MAX=0x1.fffffep127f +CL_FLT_MAX_10_EXP=+38 +CL_FLT_MAX_EXP=+128 +# CL_FLT_MIN=0x1.0p-126f +CL_FLT_MIN_10_EXP=-37 +CL_FLT_MIN_EXP=-125 +CL_FLT_RADIX=2 +CL_GLOBAL=0x2 +CL_GL_MIPMAP_LEVEL=0x2005 +CL_GL_OBJECT_BUFFER=0x2000 +CL_GL_OBJECT_RENDERBUFFER=0x2003 +CL_GL_OBJECT_TEXTURE2D=0x2001 +CL_GL_OBJECT_TEXTURE3D=0x2002 +CL_GL_TEXTURE_TARGET=0x2004 +CL_HALF_FLOAT=0x10DD +CL_IMAGE_DEPTH=0x1116 +CL_IMAGE_ELEMENT_SIZE=0x1111 +CL_IMAGE_FORMAT=0x1110 +CL_IMAGE_FORMAT_MISMATCH=-9 +CL_IMAGE_FORMAT_NOT_SUPPORTED=-10 +CL_IMAGE_HEIGHT=0x1115 +CL_IMAGE_ROW_PITCH=0x1112 +CL_IMAGE_SLICE_PITCH=0x1113 +CL_IMAGE_WIDTH=0x1114 +CL_INTENSITY=0x10B8 +CL_INT_MAX=2147483647 +CL_INT_MIN=(-2147483647-1) +CL_INVALID_ARG_INDEX=-49 +CL_INVALID_ARG_SIZE=-51 +CL_INVALID_ARG_VALUE=-50 +CL_INVALID_BINARY=-42 +CL_INVALID_BUFFER_SIZE=-61 +CL_INVALID_BUILD_OPTIONS=-43 +CL_INVALID_COMMAND_QUEUE=-36 +CL_INVALID_CONTEXT=-34 +CL_INVALID_DEVICE=-33 +CL_INVALID_DEVICE_TYPE=-31 +CL_INVALID_EVENT=-58 +CL_INVALID_EVENT_WAIT_LIST=-57 +CL_INVALID_GLOBAL_OFFSET=-56 +CL_INVALID_GL_CONTEXT_APPLE=-1000 +CL_INVALID_GL_OBJECT=-60 +CL_INVALID_HOST_PTR=-37 +CL_INVALID_IMAGE_FORMAT_DESCRIPTOR=-39 +CL_INVALID_IMAGE_SIZE=-40 +CL_INVALID_KERNEL=-48 +CL_INVALID_KERNEL_ARGS=-52 +CL_INVALID_KERNEL_DEFINITION=-47 +CL_INVALID_KERNEL_NAME=-46 +CL_INVALID_MEM_OBJECT=-38 +CL_INVALID_MIP_LEVEL=-62 +CL_INVALID_OPERATION=-59 +CL_INVALID_PLATFORM=-32 +CL_INVALID_PROGRAM=-44 +CL_INVALID_PROGRAM_EXECUTABLE=-45 +CL_INVALID_QUEUE_PROPERTIES=-35 +CL_INVALID_SAMPLER=-41 +CL_INVALID_VALUE=-30 +CL_INVALID_WORK_DIMENSION=-53 +CL_INVALID_WORK_GROUP_SIZE=-54 +CL_INVALID_WORK_ITEM_SIZE=-55 +CL_KERNEL_COMPILE_WORK_GROUP_SIZE=0x11B1 +CL_KERNEL_CONTEXT=0x1193 +CL_KERNEL_FUNCTION_NAME=0x1190 +CL_KERNEL_LOCAL_MEM_SIZE=0x11B2 +CL_KERNEL_NUM_ARGS=0x1191 +CL_KERNEL_PROGRAM=0x1194 +CL_KERNEL_REFERENCE_COUNT=0x1192 +CL_KERNEL_WORK_GROUP_SIZE=0x11B0 +CL_LOCAL=0x1 +# CL_LONG_MAX=((cl_long) 0x7FFFFFFFFFFFFFFFLL) +# CL_LONG_MIN=((cl_long) -0x7FFFFFFFFFFFFFFFLL - 1LL) +CL_LUMINANCE=0x10B9 +CL_MAP_FAILURE=-12 +CL_MEM_CONTEXT=0x1106 +CL_MEM_COPY_OVERLAP=-8 +CL_MEM_FLAGS=0x1101 +CL_MEM_HOST_PTR=0x1103 +CL_MEM_MAP_COUNT=0x1104 +CL_MEM_OBJECT_ALLOCATION_FAILURE=-4 +CL_MEM_OBJECT_BUFFER=0x10F0 +CL_MEM_OBJECT_IMAGE2D=0x10F1 +CL_MEM_OBJECT_IMAGE3D=0x10F2 +CL_MEM_REFERENCE_COUNT=0x1105 +CL_MEM_SIZE=0x1102 +CL_MEM_TYPE=0x1100 +CL_NONE=0x0 +CL_OUT_OF_HOST_MEMORY=-6 +CL_OUT_OF_RESOURCES=-5 +CL_PLATFORM_EXTENSIONS=0x0904 +CL_PLATFORM_NAME=0x0902 +CL_PLATFORM_PROFILE=0x0900 +CL_PLATFORM_VENDOR=0x0903 +CL_PLATFORM_VERSION=0x0901 +CL_PROFILING_COMMAND_END=0x1283 +CL_PROFILING_COMMAND_QUEUED=0x1280 +CL_PROFILING_COMMAND_START=0x1282 +CL_PROFILING_COMMAND_SUBMIT=0x1281 +CL_PROFILING_INFO_NOT_AVAILABLE=-7 +CL_PROGRAM_BINARIES=0x1166 +CL_PROGRAM_BINARY_SIZES=0x1165 +CL_PROGRAM_BUILD_LOG=0x1183 +CL_PROGRAM_BUILD_OPTIONS=0x1182 +CL_PROGRAM_BUILD_STATUS=0x1181 +CL_PROGRAM_CONTEXT=0x1161 +CL_PROGRAM_DEVICES=0x1163 +CL_PROGRAM_NUM_DEVICES=0x1162 +CL_PROGRAM_REFERENCE_COUNT=0x1160 +CL_PROGRAM_SOURCE=0x1164 +CL_QUEUED=0x3 +CL_QUEUE_CONTEXT=0x1090 +CL_QUEUE_DEVICE=0x1091 +CL_QUEUE_PROPERTIES=0x1093 +CL_QUEUE_REFERENCE_COUNT=0x1092 +CL_R=0x10B0 +CL_RA=0x10B3 +CL_READ_ONLY_CACHE=0x1 +CL_READ_WRITE_CACHE=0x2 +CL_RG=0x10B2 +CL_RGB=0x10B4 +CL_RGBA=0x10B5 +CL_RUNNING=0x1 +CL_SAMPLER_ADDRESSING_MODE=0x1153 +CL_SAMPLER_CONTEXT=0x1151 +CL_SAMPLER_FILTER_MODE=0x1154 +CL_SAMPLER_NORMALIZED_COORDS=0x1152 +CL_SAMPLER_REFERENCE_COUNT=0x1150 +CL_SCHAR_MAX=127 +CL_SCHAR_MIN=(-127-1) +CL_SHRT_MAX=32767 +CL_SHRT_MIN=(-32767-1) +CL_SIGNED_INT16=0x10D8 +CL_SIGNED_INT32=0x10D9 +CL_SIGNED_INT8=0x10D7 +CL_SNORM_INT16=0x10D1 +CL_SNORM_INT8=0x10D0 +CL_SUBMITTED=0x2 +CL_SUCCESS=0 +CL_TRUE=1 +CL_UCHAR_MAX=255 +# CL_UINT_MAX=0xffffffffU +# CL_ULONG_MAX=((cl_ulong) 0xFFFFFFFFFFFFFFFFULL) +CL_UNORM_INT16=0x10D3 +CL_UNORM_INT8=0x10D2 +CL_UNORM_INT_101010=0x10D6 +CL_UNORM_SHORT_555=0x10D5 +CL_UNORM_SHORT_565=0x10D4 +CL_UNSIGNED_INT16=0x10DB +CL_UNSIGNED_INT32=0x10DC +CL_UNSIGNED_INT8=0x10DA +CL_USHRT_MAX=65535 +CL_VERSION_1_0=1 +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/pcap.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,120 @@ + + +dynbind( c("pcap","pcap.so.0.8") , " +pcap_activate(*<pcap>)i; +pcap_breakloop(*<pcap>)v; +pcap_can_set_rfmon(*<pcap>)i; +pcap_close(*<pcap>)v; +pcap_compile(*<pcap>*<bpf_program>*ciI)i; +pcap_compile_nopcap(ii*<bpf_program>*ciI)i; +pcap_create(*c*c)*<pcap>; +pcap_datalink(*<pcap>)i; +pcap_datalink_ext(*<pcap>)i; +pcap_datalink_name_to_val(*c)i; +pcap_datalink_val_to_description(i)*c; +pcap_datalink_val_to_name(i)*c; +pcap_dispatch(*<pcap>i*p*C)i; +pcap_dump(*C*<pcap_pkthdr>*C)v; +pcap_dump_close(*<pcap_dumper>)v; +pcap_dump_file(*<pcap_dumper>)*<__sFILE>; +pcap_dump_flush(*<pcap_dumper>)i; +pcap_dump_fopen(*<pcap>*<__sFILE>)*<pcap_dumper>; +pcap_dump_ftell(*<pcap_dumper>)j; +pcap_dump_open(*<pcap>*c)*<pcap_dumper>; +pcap_file(*<pcap>)*<__sFILE>; +pcap_fileno(*<pcap>)i; +pcap_findalldevs(**<pcap_if>*c)i; +pcap_fopen_offline(*<__sFILE>*c)*<pcap>; +pcap_fopen_offline_with_tstamp_precision(*<__sFILE>I*c)*<pcap>; +pcap_free_datalinks(*i)v; +pcap_free_tstamp_types(*i)v; +pcap_freealldevs(*<pcap_if>)v; +pcap_freecode(*<bpf_program>)v; +pcap_get_selectable_fd(*<pcap>)i; +pcap_get_tstamp_precision(*<pcap>)i; +pcap_geterr(*<pcap>)*c; +pcap_getnonblock(*<pcap>*c)i; +pcap_inject(*<pcap>*vJ)i; +pcap_is_swapped(*<pcap>)i; +pcap_lib_version()*c; +pcap_list_datalinks(*<pcap>**i)i; +pcap_list_tstamp_types(*<pcap>**i)i; +pcap_lookupdev(*c)*c; +pcap_lookupnet(*c*I*I*c)i; +pcap_loop(*<pcap>i*p*C)i; +pcap_major_version(*<pcap>)i; +pcap_minor_version(*<pcap>)i; +pcap_next(*<pcap>*<pcap_pkthdr>)*C; +pcap_next_ex(*<pcap>**<pcap_pkthdr>**C)i; +pcap_offline_filter(*<bpf_program>*<pcap_pkthdr>*C)i; +pcap_open_dead(ii)*<pcap>; +pcap_open_dead_with_tstamp_precision(iiI)*<pcap>; +pcap_open_live(*ciii*c)*<pcap>; +pcap_open_offline(*c*c)*<pcap>; +pcap_open_offline_with_tstamp_precision(*cI*c)*<pcap>; +pcap_perror(*<pcap>*c)v; +pcap_sendpacket(*<pcap>*Ci)i; +pcap_set_buffer_size(*<pcap>i)i; +pcap_set_datalink(*<pcap>i)i; +pcap_set_immediate_mode(*<pcap>i)i; +pcap_set_promisc(*<pcap>i)i; +pcap_set_rfmon(*<pcap>i)i; +pcap_set_snaplen(*<pcap>i)i; +pcap_set_timeout(*<pcap>i)i; +pcap_set_tstamp_precision(*<pcap>i)i; +pcap_set_tstamp_type(*<pcap>i)i; +pcap_setdirection(*<pcap>i)i; +pcap_setfilter(*<pcap>*<bpf_program>)i; +pcap_setnonblock(*<pcap>i*c)i; +pcap_snapshot(*<pcap>)i; +pcap_stats(*<pcap>*<pcap_stat>)i; +pcap_statustostr(i)*c; +pcap_strerror(i)*c; +pcap_tstamp_type_name_to_val(*c)i; +pcap_tstamp_type_val_to_description(i)*c; +pcap_tstamp_type_val_to_name(i)*c; +") +parseStructInfos(" +bpf_insn{SCCI}code jt jf k ; +bpf_program{I*<bpf_insn>}bf_len bf_insns ; +pcap_addr{*<pcap_addr>*<sockaddr>*<sockaddr>*<sockaddr>*<sockaddr>}next addr netmask broadaddr dstaddr ; +pcap_dumper{}; +pcap_file_header{ISSiIII}magic version_major version_minor thiszone sigfigs snaplen linktype ; +pcap_if{*<pcap_if>*c*c*<pcap_addr>I}next name description addresses flags ; +pcap_pkthdr{<timeval>II}ts caplen len ; +pcap_stat{III}ps_recv ps_drop ps_ifdrop ; +pcap{}; +sockaddr{}; +timeval{ji}tv_sec tv_usec ; +") +PCAP_D_IN=1; +PCAP_D_INOUT=0; +PCAP_D_OUT=2; +PCAP_ERRBUF_SIZE=256 +PCAP_ERROR=-1 +PCAP_ERROR_ACTIVATED=-4 +PCAP_ERROR_BREAK=-2 +PCAP_ERROR_CANTSET_TSTAMP_TYPE=-10 +PCAP_ERROR_IFACE_NOT_UP=-9 +PCAP_ERROR_NOT_ACTIVATED=-3 +PCAP_ERROR_NOT_RFMON=-7 +PCAP_ERROR_NO_SUCH_DEVICE=-5 +PCAP_ERROR_PERM_DENIED=-8 +PCAP_ERROR_PROMISC_PERM_DENIED=-11 +PCAP_ERROR_RFMON_NOTSUP=-6 +PCAP_ERROR_TSTAMP_PRECISION_NOTSUP=-12 +PCAP_IF_LOOPBACK=0x00000001 +PCAP_NETMASK_UNKNOWN=0xffffffff +PCAP_TSTAMP_ADAPTER=3 +PCAP_TSTAMP_ADAPTER_UNSYNCED=4 +PCAP_TSTAMP_HOST=0 +PCAP_TSTAMP_HOST_HIPREC=2 +PCAP_TSTAMP_HOST_LOWPREC=1 +PCAP_TSTAMP_PRECISION_MICRO=0 +PCAP_TSTAMP_PRECISION_NANO=1 +PCAP_VERSION_MAJOR=2 +PCAP_VERSION_MINOR=4 +PCAP_WARNING=1 +PCAP_WARNING_PROMISC_NOTSUP=2 +PCAP_WARNING_TSTAMP_TYPE_NOTSUP=3 +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/inst/dynports/stdio.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,84 @@ + + +dynbind( c("msvcrt","c","c.so.6"), " +__sputc(i*<__sFILE>)i; +__srget(*<__sFILE>)i; +__svfscanf(*<__sFILE>*c*c)i; +__swbuf(i*<__sFILE>)i; +asprintf(**c)i; +clearerr(*<__sFILE>)v; +ctermid(*c)*c; +ctermid_r(*c)*c; +fclose(*<__sFILE>)i; +fdopen(i*c)*<__sFILE>; +feof(*<__sFILE>)i; +ferror(*<__sFILE>)i; +fflush(*<__sFILE>)i; +fgetc(*<__sFILE>)i; +fgetln(*<__sFILE>*J)*c; +fgetpos(*<__sFILE>*l)i; +fgets(*ci*<__sFILE>)*c; +fileno(*<__sFILE>)i; +flockfile(*<__sFILE>)v; +fmtcheck(*c*c)*c; +fopen(*c*c)*<__sFILE>; +fprintf(*<__sFILE>*c)i; +fpurge(*<__sFILE>)i; +fputc(i*<__sFILE>)i; +fputs(*c*<__sFILE>)i; +fread(*vJJ*<__sFILE>)J; +freopen(*c*c*<__sFILE>)*<__sFILE>; +fscanf(*<__sFILE>*c)i; +fseek(*<__sFILE>ji)i; +fseeko(*<__sFILE>li)i; +fsetpos(*<__sFILE>*l)i; +ftell(*<__sFILE>)j; +ftello(*<__sFILE>)l; +ftrylockfile(*<__sFILE>)i; +funlockfile(*<__sFILE>)v; +funopen(*v*p*p*p*p)*<__sFILE>; +fwrite(*vJJ*<__sFILE>)J; +getc(*<__sFILE>)i; +getc_unlocked(*<__sFILE>)i; +getchar()i; +getchar_unlocked()i; +gets(*c)*c; +getw(*<__sFILE>)i; +pclose(*<__sFILE>)i; +perror(*c)v; +popen(*c*c)*<__sFILE>; +printf(_e*c)i; +putc(i*<__sFILE>)i; +putc_unlocked(i*<__sFILE>)i; +putchar(i)i; +putchar_unlocked(i)i; +puts(*c)i; +putw(i*<__sFILE>)i; +remove(*c)i; +rename(*c*c)i; +rewind(*<__sFILE>)v; +scanf(*c)i; +setbuf(*<__sFILE>*c)v; +setbuffer(*<__sFILE>*ci)v; +setlinebuf(*<__sFILE>)i; +setvbuf(*<__sFILE>*ciJ)i; +snprintf(*cJ*c)i; +sprintf(*c*c)i; +sscanf(*c*c)i; +tempnam(*c*c)*c; +tmpfile()*<__sFILE>; +tmpnam(*c)*c; +ungetc(i*<__sFILE>)i; +vasprintf(**c*c)i; +vfprintf(*<__sFILE>*c*c)i; +vfscanf(*<__sFILE>*c*c)i; +vprintf(*c*c)i; +vscanf(*c*c)i; +vsnprintf(*cJ*c*c)i; +vsprintf(*c*c*c)i; +vsscanf(*c*c*c)i; +zopen(*c*ci)*<__sFILE>; +") +SEEK_CUR=1 +SEEK_END=2 +SEEK_SET=0
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/man/dynbind.Rd Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,78 @@ +\name{dynbind} +\alias{dynbind} +\title{Binding C library functions via thin call wrappers} +\description{Function to bind several foreign functions of a C library via installation of thin R call wrappers.} +\usage{ +dynbind(libnames, signature, + envir=parent.frame(), callmode="default", + pat=NULL, replace=NULL, funcptr=FALSE) +} +\arguments{ + \item{libnames}{vector of character strings giving short library names of the shared library to be loaded. See \code{\link{dynfind}} for details.} + \item{signature}{character string specifying the \emph{library signature} that determines the set of foreign function names and types. See details.} + \item{envir}{the environment to use for installation of call wrappers.} + \item{callmode}{character string specifying the calling convention, see details.} + \item{pat}{NULL or regular expression character string applied to symbolic names.} + \item{replace}{NULL or replacement character string applied to \code{pat} part of symbolic names.} + \item{funcptr}{logical, that indicates whether foreign objects refer to functions (\code{FALSE}, default) or to function poiner variables (\code{TRUE} rarely needed).} +} +\details{ +\code{dynbind} makes a set of C functions available to R through installation of thin call wrappers. +The set of functions, including the symbolic name and function type, is specified by \code{signature} ; a character string that encodes a +library signature: + +The \strong{library signature} is a compact plain-text format to specify a set of function bindings. +It consists of function names and corresponding \link[=call signature]{call signatures}. Function bindings are separated +by \sQuote{;} (semicolon) ; white spaces (including tab and new line) are allowed before and after semicolon. + +\tabular{c}{ +\emph{function-name} \code{(} \emph{call-signature} \code{;} \ldots \cr +} + +Here is an example that specifies three function bindings to the OpenGL library: +\preformatted{"glAccum(If)v ; glClear(I)v ; glClearColor(ffff)v ;"} + +Symbolic names are resolved using the library specified by \code{libnames} using \code{\link{dynfind}} for loading. +For each function, a thin call wrapper function is created using the following template: + +\preformatted{ function(...) .dyncall.<MODE> ( <TARGET>, <SIGNATURE>, ... ) } + +\code{<MODE>} is replaced by \code{callmode} argument, see \code{\link{.dyncall}} for details on calling conventions. +\code{<TARGET>} is replaced by the external pointer, resolved by the \sQuote{function-name}. +\code{<SIGNATURE>} is replaced by the call signature string contained in \code{signature}. + +The call wrapper is installed in the environment given by \code{envir}. +The assignment name is obtained from the function signature. +If \code{pat} and \code{replace} is given, a text replacement is applied to the name before assignment, useful for basic C name space mangling such as exchanging the prefix. + +As a special case, \code{dynbind} supports binding of pointer-to-function variables, indicated by setting \code{funcptr} to \code{TRUE}, in which case \code{<TARGET>} +is replaced with the expression \code{.unpack(<TARGET>,"p",0)} in order to dereference \code{<TARGET>} as a pointer-to-function variable at call-time. +} + +\value{ +The function returns a list with two fields: +\item{libhandle}{External pointer returned by \code{\link{.dynload}}.} +\item{unresolved.symbols}{vector of character strings, the names of unresolved symbols.} + +As a side effect, for each wrapper, \code{dynbind} assigns the \sQuote{function-name} to the corresponding call wrapper function in the environment given by \code{envir}. + +If no shared library is found, an error is reported. +} +\examples{ +\donttest{ +# Install two wrappers to functions of the R shared C library. +info <- dynbind("R"," +R_ShowMessage(Z)v; +R_rsort(pi)v; +") +R_ShowMessage("hello") +} +} +\seealso{ +\code{\link{.dyncall}} for details on call signatures and calling conventions, +\code{\link{dynfind}} for details on short library names, +\code{\link{.unpack}} for details on reading low-level memory (e.g. dereferencing of (function) pointer variables). +} +\keyword{programming} +\keyword{interface} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/man/dyncall.Rd Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,209 @@ +\name{dyncall} +\alias{.dyncall} +\alias{dyncall} +\alias{.dyncall.default} +\alias{.dyncall.cdecl} +\alias{.dyncall.stdcall} +\alias{.dyncall.thiscall} +\alias{.dyncall.thiscall.msvc} +\alias{.dyncall.thiscall.gcc} +\alias{.dyncall.fastcall.msvc} +\alias{.dyncall.fastcall.gcc} +\alias{signature} +\alias{call signature} +\alias{type signature} +\title{Foreign Function Interface with support for almost all C types} +\description{ +Functions to call pre-compiled code with support for most C argument and return types. +} +\usage{ +.dyncall( address, signature, ... , callmode = "default" ) +.dyncall.default ( address, signature, ... ) +.dyncall.cdecl ( address, signature, ... ) +.dyncall.stdcall ( address, signature, ... ) +.dyncall.thiscall ( address, signature, ... ) +.dyncall.thiscall.msvc( address, signature, ... ) +.dyncall.thiscall.gcc ( address, signature, ... ) +.dyncall.fastcall.msvc( address, signature, ... ) +.dyncall.fastcall.gcc ( address, signature, ... ) +} +\arguments{ + \item{address}{external pointer to foreign function.} + \item{signature}{character string specifying the \emph{call signature} that describes the foreign function type. See details.} + \item{callmode}{character string specifying the \emph{calling convention}. This argument has no effect on most platforms, but on Microsoft Windows 32-Bit Intel/x86 platforms. See details.} + \item{...}{arguments to be passed to the foreign function. Arguments are converted from R to C values according to the \emph{call signature}. See details.} +} +\details{ +\code{.dyncall} offers a flexible Foreign Function Interface (FFI) for +the C language with support for calls to arbitrary pre-compiled +C function types at run-time. Almost all C fundamental +argument- and return types are supported including extended support for +pointers. No limitations is given for arity as well. +In addition, on the Microsoft Windows 32-Bit Intel/x86 platform, it supports multiple calling conventions to +interoperate with System DLLs. +Foreign C function types are specified via plain text \emph{type signatures}. +The foreign C function type of the target function is known to the FFI +in advance, before preparation of the foreign call via plain text +\emph{type signature} information. +This has several advantages: R arguments do not need to match exactly. +Although R lacks some fundamental C value types, they are supported via +coercion at this interface (e.g. C \code{float} and 64-bit integer). +Arity and argument type checks help make this interface type-safe +to a certain degree and encourage end-users to use interface from +the interpreter prompt for rapid application development. + +The foreign function to be called is specified by \code{address}, which is an external pointer that is obtained from \code{\link{.dynsym}} or \code{\link{getNativeSymbolInfo}}. + +\code{signature} is a character string that specifies the formal argument-and-return types of the +foreign function using a \emph{call signature} string. It should match the function type of the foreign function given by \code{address}, +otherwise this can lead to a \strong{fatal R process crash}. + +The calling convention is specified \emph{explicitly} via function \code{.dyncall} +using the \code{callmode} argument or \emph{implicitly} by using \code{.dyncall.*} +functions. See details below. + +Arguments passed via \code{...} are converted to C according to \code{signature} ; see below for details. + +Given that the \code{signature} matches the foreign function type, the FFI provides a certain level of type-safety to users, when +exposing foreign functions via call wrappers such as done in \code{\link{dynbind}} and \code{\link{dynport}}. +Several basic argument type-safety checks are done during preparation of the foreign function call: +The arity of formals and actual arguments must match and they must be compatible as well. +Otherwise, the foreign function call is aborted with an error before risking a fatal system crash. +} +\value{ +Functions return the received C return value converted to an R value. See section \sQuote{Call Signature} below for details. +} +\section{Type Signature}{ +Type signatures are used by almost all other signature formats (call, library, structure and union signature) and also by the low-level (un)-\code{\link{packing}} functions. + +The following table gives a list of valid type signatures for all supported C types. + +\tabular{clll}{ +\strong{Type Signature} \tab \strong{C type} \tab \strong{valid R argument types} \tab \strong{R return type}\cr +'\code{B}' \tab bool \tab raw,logical,integer,double \tab logical\cr +'\code{c}' \tab char \tab raw,logical,integer,double \tab integer\cr +'\code{C}' \tab unsigned char \tab raw,logical,integer,double \tab integer\cr +'\code{s}' \tab short \tab raw,logical,integer,double \tab integer\cr +'\code{S}' \tab unsigned short \tab raw,logical,integer,double \tab integer\cr +'\code{i}' \tab int \tab raw,logical,integer,double \tab integer\cr +'\code{I}' \tab unsigned int \tab raw,logical,integer,double \tab double\cr +'\code{j}' \tab long \tab raw,logical,integer,double \tab double\cr +'\code{J}' \tab unsigned long \tab raw,logical,integer,double \tab double\cr +'\code{l}' \tab long long \tab raw,logical,integer,double \tab double\cr +'\code{L}' \tab unsigned long long \tab raw,logical,integer,double \tab double\cr +'\code{f}' \tab float \tab raw,logical,integer,double \tab double\cr +'\code{d}' \tab double \tab raw,logical,integer,double \tab double\cr +'\code{p}' \tab \emph{C pointer} \tab \emph{any vector},externalptr,NULL \tab externalptr\cr +'\code{Z}' \tab char* \tab character,NULL \tab character or NULL\cr +'\code{x}' \tab SEXP \tab \emph{any} \tab \emph{any}\cr +'\code{v}' \tab void \tab \emph{invalid} \tab NULL\cr +'\code{*}' \ldots \tab \emph{C type}* (pointer) \tab \emph{any vector},externalptr,NULL \tab externalptr\cr +"\code{*<}" \emph{typename} '\code{>}' \tab \emph{typename}* (pointer) \tab raw,externalptr \tab externalptr\cr +} + +The last two rows of the table the above refer to \emph{typed pointer} signatures. +If they appear as a return type signature, the external pointer returned is +a S3 \code{struct} object. See \code{\link{new.struct}} for details. + +} +\section{Call Signatures}{ +Call Signatures are used by \code{\link{.dyncall}} and \code{\link{new.callback}} to describe foreign C function types. +The general form of a call signature is as following: + +\tabular{lll}{ +(\emph{argument-type})* \tab \code{')'} \tab \emph{return-type} \cr +} + +The calling sequence given by the \bold{argument types signature} is specified in direct \emph{left-to-right} order of the formal argument types defined in C. +The type signatures are put in sequence without any white space in between. +A closing bracket character '\code{)}' marks the end of argument types, followed by a +single \bold{return type signature}. + +Derived pointer types can be specified as untyped pointers via \code{'p'} +or via prefix \code{'*'} following the underlying base type (e.g. \code{'*d'} for \code{double *}) +which is more type-safe. For example, this can prevent users from passing a \code{numeric} R atomic as \code{int*} if using \code{'*i'} instead of \code{'p'}. + +Dervied pointer types to aggregate \code{union} or \code{struct} types are +supported in combination with the framework for handling foreign data types. +See \code{\link{new.struct}} for details. Once a C type is registered, +the signature \code{*<}\emph{typename}\code{>} can be used to refer to a pointer to an aggregate C object \emph{type}\code{*}. +If typed pointers to aggregate objects are used as a return type and the corresponding type information exists, the returned value can be printed and accessed symbolically. + +Here are some examples of C function prototypes and corresponding call signatures: + +\tabular{rll}{ + \tab \emph{C Function Prototype} \tab \emph{Call Signature} \cr +\code{double} \tab \code{sqrt(double);} \tab \code{"d)d"} \cr +\code{double} \tab \code{dnorm(double,double,double,int);} \tab \code{"dddi)d"} \cr +\code{void} \tab \code{R_isort(int*,int);} \tab \code{"pi)v"} or \code{"*ii)v"} \cr +\code{void} \tab \code{revsort(double*,int*,int);} \tab \code{"ppi)v"} or \code{"*d*ii)v"}\cr +\code{int} \tab \code{SDL_PollEvents(SDL_Event *);} \tab \code{"p)i"} or \code{"*<SDL_Event>)i"} \cr +\code{SDL_Surface*} \tab \code{SDL_SetVideoMode(int,int,int,int);} \tab \code{"iiii)p"} or \code{"iiii)*<SDL_Surface>"} \cr +} + +} + +\section{Calling convention}{ +Calling Conventions specify \sQuote{how} sub-routine calls are performed, and, \sQuote{how} arguments and results are passed, +on machine-level. They differ significantly among families of CPU Architectures +as well as OS and Compiler implementations. + +On most platforms, a single \code{"default"} C Calling Convention is used. +As an exception, on the Microsoft Windows 32-Bit Intel/x86 platform several calling conventions are common. +Most of the C libraries still use a \code{"default"} C ( also known as \code{"cdecl"} ) +calling convention, but when working with Microsoft System APIs and DLLs, the \code{"stdcall"} +calling convention must be used. + +It follows a description of supported Win32 Calling Conventions: + +\describe{ +\item{\code{"cdecl"}}{Dummy alias to \emph{default}} +\item{\code{"stdcall"}}{C functions with \emph{stdcall} calling convention. Useful for all Microsoft Windows System Libraries (e.g. KERNEL32.DLL, USER32.DLL, OPENGL32.DLL ...). Third-party libraries usually prefer the default C \emph{cdecl} calling convention. } +\item{\code{"fastcall.msvc"}}{C functions with \emph{fastcall} calling convention compiled with Microsoft Visual C++ Compiler. Very rare usage.} +\item{\code{"fastcall.gcc"}}{C functions with \emph{fastcall} calling convention compiled with GNU C Compiler. Very rare usage.} +\item{\code{"thiscall"}}{C++ member functions.} +\item{\code{"thiscall.gcc"}}{C++ member functions compiled with GNU C Compiler.} +\item{\code{"thiscall.msvc"}}{C++ member functions compiled with Microsoft Visual C++ Compiler.} +} + +As of the current version of this package and for practical reasons, the \code{callmode} argument does not have an effect on almost +all platforms, except that if R is running on Microsoft Windows 32-Bit Intel/x86 platform, \code{.dyncall} uses the specified calling convention. +For example, when loading OpenGL across platforms, \code{"stdcall"} should be used instead of \code{"default"}, +because on Windows, OpenGL is a System DLL. This is very exceptional, as in most other cases, \code{"default"} (or \code{"cdecl"}, the alias) need to be used +for normal C shared libraries on Windows. + +At this stage of development, support for C++ calls should be considered experimental. +Support for Fortran is planed but not yet implemented in dyncall. +} +\section{Portability}{ +The implementation is based on the \emph{dyncall} library (part of the DynCall project). + +The following processor architectures are supported: X86 32- and 64-bit, ARM v4t-v7 oabi/eabi (aapcs) and armhf including support for Thumb ISA, PowerPC 32-bit, MIPS 32- and 64-Bit, SPARC 32- and 64-bit; The library +has been built and tested to work on various OSs: Linux, Mac OS X, Windows 32/64-bit, BSDs, Haiku, Nexenta/Open Solaris, Solaris, Minix and Plan9, +as well as embedded platforms such as Linux/ARM (OpenMoko, Beagleboard, Gumstix, Efika MX, Raspberry Pi), Nintendo DS (ARM), Sony Playstation Portable (MIPS 32-bit/eabi) and iOS (ARM - armv6 mode ok, armv7 unstable). +In the context of R, dyncall has currently no support for PowerPC 64-Bit. +} +\note{ +The target address, calling convention and call signature \strong{MUST} match foreign function type, otherwise the invocation could lead to a \strong{fatal R process crash}. +} +\examples{ +\donttest{ +mathlib <- dynfind(c("msvcrt","m","m.so.6")) +x <- .dynsym(mathlib,"sqrt") +.dyncall(x, "d)d", 144L) +} +} +\references{ + Adler, D. (2012) \dQuote{Foreign Library Interface}, \emph{The R Journal}, \bold{4(1)}, 30--40, June 2012. + \url{http://journal.r-project.org/archive/2012-1/RJournal_2012-1_Adler.pdf} + + Adler, D., Philipp, T. (2008) \emph{DynCall Project}. + \url{http://dyncall.org} +} +\seealso{ +\code{\link{.dynsym}} and \code{\link[base]{getNativeSymbolInfo}} for resolving symbols, +\code{\link{dynbind}} for binding several foreign functions via thin call wrappers, +\code{\link[base]{.C}} for the traditional FFI to C. +} +\keyword{programming} +\keyword{interface}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/man/dyncallback.Rd Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,85 @@ +\name{callback} +\alias{new.callback} +\alias{callback} +\alias{dyncallback} +\title{Dynamic wrapping of R functions as C callbacks} +\description{ +Function to wrap R functions as C function pointers. +} +\usage{ +new.callback( signature, fun, envir = new.env() ) +} +\arguments{ + \item{signature}{character string specifying the \link[=signature]{call signature} of the C function callback type.} + \item{fun}{R function to be wrapped as a C function pointer.} + \item{envir}{the environment in which to evaluate the call to \code{fun}. } +} +\details{ +Callbacks are user-defined functions that are registered in a foreign library and that are executed at a later time from within that library. +Examples include user-interface event handlers that are registered in GUI toolkits, and, comparison functions for custom data types to be passed to generic sort algorithm. + +The function \code{new.callback} wraps an R function \code{fun} as a C function pointer and returns an external pointer. The foreign C function type of the wrapped +R function is specified by a \link{call signature} given by \code{signature}. + +When the C function pointer is called, a global callback handler (implemented in C) is executed first, that dynamically creates an R call expression to \code{fun} +using the arguments, passed from C and converted to R, according to the \emph{argument types signature} within the \link{call signature} specified. See +\code{\link{.dyncall}} for details on the format. +Finally, the handler evaluates the R call expression within the environment given by \code{envir}. +On return, the R return value of \code{fun} is coerced to the C value, according to the return type signature specified in \code{signature}. +If an error occurs during the evaluation, the callback will be disabled for further invocations. (This behaviour might change in the future.) + +} +\value{ +\code{new.callback} returns an external pointer to a synthetically generated C function. +} + +\section{Portability}{ +The implementation is based on the \emph{dyncallback} library (part of the DynCall project). + +The following processor architectures are supported: X86, X64, ARM (including Thumb) and partial stable support for PowerPC 32-bit; The library +has been built and tested to work on various OSs: Linux, Mac OS X, Windows 32/64-bit, BSDs, Haiku, Nexenta/Open Solaris, Minix and Plan9, +as well as embedded platforms such as Linux/ARM (OpenMoko, Beagleboard, Gumstix, Efika MX, Raspberry Pi), Nintendo DS (ARM), Sony Playstation Portable (MIPS 32-bit/eabi) and iOS (ARM - armv6 mode ok, armv7 unstable). +Special notes for PowerPC 32-Bit: Callbacks for System V (Linux/BSD) are unstable in this release; MacOS X/Darwin works fine. +In the context of R, dyncallback has currently no support for callbacks on MIPS, SPARC and PowerPC 64-Bit. +Using dyncallback to implement non-default calling conventions is not supported yet. (e.g. Window Procedures on Win32/X86). +} +\note{ +The call signature \strong{MUST} match the foreign C callback function type, otherwise an activated callback call from C can lead to a \strong{fatal R process crash}. + +A small amount of memory is allocated with each wrapper. +A finalizer function that frees the allocated memory is registered at the external pointer. +If the external callback function pointer is registered in a C library, a reference should also be held in R as long as the callback can be activated from a foreign C run-time context, +otherwise the garbage collector might call the finalizer and the next invocation of the callback could lead to a \strong{fatal R process crash} as well. +} + +\references{ + Adler, D. (2012) \dQuote{Foreign Library Interface}, \emph{The R Journal}, \bold{4(1)}, 30--40, June 2012. + \url{http://journal.r-project.org/archive/2012-1/RJournal_2012-1_Adler.pdf} + + Adler, D., Philipp, T. (2008) \emph{DynCall Project}. + \url{http://dyncall.org} +} +\seealso{ +See \code{\link{signature}} for details on call signatures, +\code{\link{reg.finalizer}} for details on finalizers. +} +\examples{ +\donttest{ +# Create a function, wrap it to a callback and call it via .dyncall: +f <- function(x,y) x+y +cb <- new.callback("ii)i", f) +r <- .dyncall(cb, "ii)i", 20, 3) + +# Sort vectors directly via 'qsort' C library function using an R callback: +dynbind(c("msvcrt","c","c.so.6"), "qsort(piip)v;") +cb <- new.callback("pp)i",function(px,py){ + x <- .unpack(px, 0, "d") + y <- .unpack(py, 0, "d") + if (x > y) return(1) else if (x == y) return(0) else return(-1) +}) +x <- rnorm(100) +qsort(x,length(x),8,cb) +} +} +\keyword{programming} +\keyword{interface}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/man/dynfind.Rd Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,79 @@ +\name{dynfind} +\alias{dynfind} +\title{Portable searching and loading of shared libraries} +\description{Function to load shared libraries using a platform-portable interface.} +\usage{ +dynfind(libnames, auto.unload=TRUE) +} +\arguments{ + \item{libnames}{vector of character strings specifying several short library names.} + \item{auto.unload}{logical: if \code{TRUE} then a finalizer is registered that closes the library on garbage collection. See \code{\link{.dynload}} for details.} +} +\details{ +\code{dynfind} offers a platform-portable naming interface for loading a specific shared library. + +The naming scheme and standard locations of shared libraries are OS-specific. +When loading a shared library dynamically at run-time across platforms via standard interfaces such as \code{\link{.dynload}} or \code{\link{dyn.load}}, +a platform-test is usually needed to specify the OS-dependant library file path. + +This \emph{library name problem} is encountered via breaking up the library file path into several abstract components: + +\tabular{cccc}{ + \emph{<location>} \tab \emph{<prefix>} \tab \emph{<libname>} \tab \emph{<suffix>} \cr +} + +By permutation of values in each component and concatenation, a list of possible file paths can be derived. +\code{dynfind} goes through this list to try opening a library. On the first success, the search is stopped and the function returns. + +Given that the three components \sQuote{location}, \sQuote{prefix} and \sQuote{suffix} are set up properly on a per OS basis, +the unique identification of a library is given by \sQuote{libname} - the short library name. + +For some libraries, multiple \sQuote{short library name} are needed to make this mechanism work across all major platforms. +For example, to load the Standard C Library across major R platforms: + +\preformatted{ +lib <- dynfind(c("msvcrt","c","c.so.6")) +} + +On Windows \code{MSVCRT.dll} would be loaded; \code{libc.dylib} on Mac OS X; \code{libc.so.6} on Linux and \code{libc.so} on BSD. + +Here is a sample list of values for the three other components: + +\itemize{ + \item \sQuote{location}: \dQuote{/usr/local/lib/}, \dQuote{/Windows/System32/}. + \item \sQuote{prefix}: \dQuote{lib} (common), \dQuote{} (empty - common on Windows). + \item \sQuote{suffix}: \dQuote{.dll} (Windows), \dQuote{.so} (ELF), \dQuote{.dylib} (Mac OS X) and \dQuote{} (empty - useful for all platforms). +} + +The vector of \sQuote{locations} is initialized by environment variables such as '\code{PATH}' on Windows and +\code{LD_LIBRARY_PATH} on Unix-flavour systems in additional to some hardcoded locations: +\file{/opt/local/lib}, +\file{/usr/local/lib}, +\file{/usr/lib} and +\file{/lib}. +(The set of hardcoded locations might expand and change within the next minor releases). + +The file extension depends on the OS: '\code{.dll}' (Windows), '\code{.dylib}' (Mac OS X), '\code{.so}' (all others). + +On Mac OS X, the search for a library includes the \sQuote{Frameworks} folders as well. This happens before the normal library search procedure and uses a slightly different naming pattern +in a separate search phase: + +\tabular{c}{ +\emph{<frameworksLocation>} \bold{Frameworks/} \emph{<libname>} \bold{.framework/} \emph{<libname>} +} + +The \sQuote{frameworksLocation} is a vector of locations such as \code{/System/Library/} and \code{/Library/}. + +\code{dynfind} loads a library via \code{\link{.dynload}} passing over the parameter \code{auto.unload}. + +} +\value{ +\code{dynfind} returns an external pointer (library handle), if search was successful. +Otherwise, if no library is located, a \code{NULL} is returned. +} +\seealso{ +See \code{\link{.dynload}} for details on the loader interface to the OS-specific dynamic linker. +} +\keyword{programming} +\keyword{interface} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/man/dynload.Rd Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,145 @@ +\name{dynload} +\alias{dynload} +\alias{.dynload} +\alias{.dynunload} +\alias{.dynsym} +\title{Loading of shared libraries and resolving of symbols (Alternative Framework)} +\description{Alternative framework for loading of shared libraries and resolving of symbols. +The framework offers \emph{automatic unload management} of shared libraries and +provides a direct interface to the dynamic linker of the OS. +} +\usage{ +.dynload(libname, auto.unload=TRUE) +.dynsym(libhandle, symname, protect.lib=TRUE) +.dynunload(libhandle) +} +\arguments{ + \item{libname}{character string giving the pathname to a shared library in OS-specific notation.} + \item{libhandle}{external pointer representing a handle to an opened library.} + \item{symname}{character string specifying a symbolic name to be resolved.} + \item{auto.unload}{logical, if \code{TRUE} a finalizer will be registered that will automatically unload the library.} + \item{protect.lib}{logical, if \code{TRUE} resolved external pointers protect library handles from finalization.} +} +\value{ +\code{.dynload} returns an external pointer \code{libhandle} on success. Otherwise NULL is returned, if the library is not found or the linkage failed. + +\code{.dynsym} returns an external pointer \code{address} on success. Otherwise NULL is returned, if the address was invalid or the symbol has not been found. + +\code{.dynunload} always returns \code{NULL}. +} +\details{ +\code{.dynload} loads a shared library into the current R process using the OS-specific dynamic linker interface. +The \code{libname} is passed \emph{as-is} directly to the dynamic linker and thus is given in OS-specific notation - see below for details. +On success, a handle to the library represented as an external pointer R objects is returned, otherwise \code{NULL}. +If \code{auto.unload} is \code{TRUE}, a finalizer function is registered that will unload the library on garbage collection via \code{.dynunload}. + +\code{.dynsym} looks up symbol names in loaded libraries and resolves them to memory addresses returned as external pointer R objects. +Otherwise \code{NULL} is returned. +If \code{protect.lib} is \code{TRUE}, the library handle is \emph{protected} by resolved address external pointers from unloading. + +\code{.dynunload} explicitly unreferences the loaded library specified by \code{libhandle}. + +Setting both \code{auto.unload} and \code{protect.lib} to \code{TRUE}, libraries remain loaded as long as resolved symbols are in use, and they get automatic unloaded +when no resolved symbols remain. + +Dynamic linkers usually hold an internal link count, such that a library can be opened multiple times via \code{.dynload} +- with a balanced number of calls to \code{.dynunload} that decreases the link count to unload the library again. + +Similar functionality is available via \code{\link[base]{dyn.load}} and \code{getNativeSymbolInfo}, +except that path names are filtered and no automatic unloading of libraries is supported. +} + +\section{Shared library}{ + +Shared libraries are single files that contain compiled code, data and meta-information. +The code and data can be loaded and mapped to a process at run-time once. +Operating system platforms have slightly different schemes for naming, +searching and linking options. + +\tabular{lll}{ +\strong{Platform} \tab \strong{Binary format} \tab \strong{File Extension} \cr +Linux, BSD derivates and Sun Solaris \tab ELF format \tab \code{so} \cr +Darwin / Apple Mac OS X \tab Mach-O format \tab \code{dylib} \cr +Microsoft Windows \tab PE format \tab \code{dll} \cr +} + +} + +\section{Library search on Posix platforms (Linux,BSD,Sun Solaris)}{ + +The following text is taken from the Linux \code{dlopen} manual page: + +These search rules will only be applied to path names that do not contain an embedded '/'. +\itemize{ +\item If the \code{LD_LIBRARY_PATH} environment variable is defined to contain a colon-separated list of +directories, then these are searched. + +\item The cache file \code{/etc/ld.so.cache} is checked to see whether it contains an entry for filename. + +\item The directories \code{/lib} and \code{/usr/lib} are searched (in that order). +} +If the library has dependencies on other shared libraries, then these are also automatically +loaded by the dynamic linker using the same rules. +} +\section{Library search on Darwin (Mac OS X) platforms}{ + +The following text is taken from the Mac OS X dlopen manual page: + +\code{dlopen()} searches for a compatible Mach-O file in the directories specified by a set of environment +variables and the process's current working directory. When set, the environment variables must contain +a colon-separated list of directory paths, which can be absolute or relative to the current working +directory. The environment variables are $LD_LIBRARY_PATH, $DYLD_LIBRARY_PATH, and $DYLD_FALLBACK_LIBRARY_PATH. +The first two variables have no default value. The default value of $DYLD_FALLBACK_LIBRARY_PATH +is $HOME/lib;/usr/local/lib;/usr/lib. \code{dlopen()} searches the directories specified in +the environment variables in the order they are listed. + +When path doesn't contain a slash character (i.e. it is just a leaf name), \code{dlopen()} searches the following +until it finds a compatible Mach-O file: $LD_LIBRARY_PATH, $DYLD_LIBRARY_PATH, +current working directory, $DYLD_FALLBACK_LIBRARY_PATH. + +When path contains a slash (i.e. a full path or a partial path) \code{dlopen()} searches the following the +following until it finds a compatible Mach-O file: $DYLD_LIBRARY_PATH (with leaf name from path ), current +working directory (for partial paths), $DYLD_FALLBACK_LIBRARY_PATH (with leaf name from path ). +} +\section{Library search on Microsoft Windows platforms}{ + +The following text is taken from the Window SDK Documentation: + +If no file name extension is specified [...], the default library extension +\code{.dll} is appended. However, the file name string can include a trailing point character (.) to +indicate that the [shared library] module name has no extension. When no path is specified, the function searches +for loaded modules whose base name matches the base name of the module to be loaded. +If the name matches, the load succeeds. Otherwise, the function searches for the file in the +following sequence: + +\itemize{ + +\item The directory from which the application loaded. +\item The current directory. +\item The system directory. Use the GetSystemDirectory Win32 API function to get the path of this directory. +\item The 16-bit system directory. There is no function that obtains the path of this directory, but it is searched. Windows Me/98/95: This directory does not exist. +\item The Windows directory. Use the GetWindowsDirectory Win32 API function to get the path of this directory. +\item The directories that are listed in the PATH environment variable. +} + +Windows Server 2003, Windows XP SP1: The default value of \preformatted{HKLM\\System\\CurrentControlSet\\Control\\Session Manager\\SafeDllSearchMode} is 1 (current directory is searched after the system and Windows directories). + +Windows XP: If \preformatted{HKLM\\System\\CurrentControlSet\\Control\\Session Manager\\SafeDllSearchMode} is 1, the current directory is searched after the system and Windows directories, but before the directories in the PATH environment variable. The default value is 0 (current directory is searched before the system and Windows directories). + + +The first directory searched is the one directory containing the image file used to create the calling process. Doing this allows private dynamic-link library (DLL) files associated with a process to be found without adding the process's installed directory to the PATH environment variable. + +The search path can be altered using the \code{SetDllDirectory} function. This solution is recommended instead of using \code{SetCurrentDirectory} or hard-coding the full path to the DLL. + +If a path is specified and there is a redirection file for the application, the function searches for the module in the application's directory. If the module exists in the application's directory, the LoadLibrary function ignores the specified path and loads the module from the application's directory. If the module does not exist in the application's directory, LoadLibrary loads the module from the specified directory. For more information, see Dynamic Link Library Redirection from the Windows SDK Documentation. +} +\section{Portability}{ +The implementation is based on the \emph{dynload} library (part of the DynCall project) which has been ported +to all major R platforms (ELF (Linux,BSD,Solaris), Mach-O (Mac OS X) and Portable Executable (Win32/64)). +} +\seealso{ + This facility is used by \code{\link{dynfind}} and \code{\link{dynbind}}. + Similar functionality is available from \code{\link[base]{dyn.load}} and \code{\link[base]{getNativeSymbolInfo}}. +} +\keyword{programming} +\keyword{interface}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/man/dynport.Rd Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,122 @@ +\name{dynport} +\alias{dynport} +\alias{loadDynportNamespace} +\title{Dynamic R Bindings to standard and common C libraries} +\description{Function to bind APIs of standard and common C libraries to R via dynamically created interface environment objects +comprising R wrappers for C functions, object-like macros, enums and data types. +} +\usage{ +dynport(portname, portfile=NULL, + repo=system.file("dynports",package="rdyncall") ) +} +\arguments{ +\item{portname}{the name of a dynport, given as a literal or character string.} +\item{portfile}{\code{NULL} or character string giving a script file to parse ; \code{portname} and \code{repo} are .} +\item{repo}{character string giving the path to the root of the \emph{dynport} repository.} +} +\details{ +\code{dynport} offers a convenient method for binding entire C libraries to R. +This mechanism runs cross-platform and uses dynamic linkage but it implies +that the run-time library of a choosen binding need to be preinstalled in the system. +Depending on the OS, the run-time libraries may be preinstalled or require manual installation. +See \link{rdyncall-demos} for OS-specific installation notes for several C libraries. + +The binding method is data-driven using platform-portable specifications named \emph{DynPort} files. +DynPort files are stored in a repository that is installed as part of the package installation. +When \code{dynport} processes a \emph{DynPort} file given by \code{portname}, +an environment object is created, populated with R wrapper and helper objects +that make up the interface to the C library, and attached to the search path with the name \code{dynport:<PORTNAME>}. +Unloading of previously loaded dynport environments is achieved via \code{detach(dynport:<PORTNAME>)}. + +Up to \pkg{rdyncall} version 0.7.4, R name space objects were used as containers as described in the article \emph{Foreign Library Interface}, thus +dynport \sQuote{packages} appeared as \code{"package:<PORTNAME>"} on the search path. The mechanism to create synthesized R packages at run-time +required the use of \code{.Internal} calls. +But since the use of internal R functions is not permitted for packages distributed on CRAN we downgraded the package to use ordinary environment +objects starting with version 0.7.5 until a public interface for the creation of R namespace objects is available. + +The following gives a list of currently available \emph{DynPorts}: +\tabular{ll}{ +\strong{DynPort name/C Library} \tab \strong{Description} \cr +\code{expat} \tab Expat XML Parser Library \cr +\code{GL} \tab OpenGL 1.1 API \cr +\code{GLU} \tab OpenGL Utility Library \cr +\code{GLUT} \tab OpenGL Utility Toolkit Library \cr +\code{SDL} \tab Simple DirectMedia Layer library \cr +\code{SDL_image} \tab Loading of image files (png,jpeg..) \cr +\code{SDL_mixer} \tab Loading/Playing of ogg/mp3/mod music files. \cr +\code{SDL_ttf} \tab Loading/Rendering of True Type Fonts. \cr +\code{SDL_net} \tab Networking library. \cr +\code{glew} \tab OpenGL Extension Wrangler (includes OpenGL 3.0) \cr +\code{glfw} \tab OpenGL Windowing/Setup Library \cr +\code{gl3} \tab strict OpenGL 3 (untested) \cr +\code{R} \tab R shared library \cr +\code{ode} \tab Open Dynamics (Physics-) Engine (untested) \cr +\code{cuda} \tab NVIDIA Cuda (untested) \cr +\code{csound} \tab Sound programming language and library \cr +\code{opencl} \tab OpenCL (untested) \cr +\code{stdio} \tab C Standard Library I/O Functions \cr +\code{glpk} \tab GNU Linear Programming Kit \cr +\code{EGL} \tab Embedded Systems Graphics Library \cr +} + +As of the current implementation \emph{DynPort} files are R scripts +that perform up to three tasks: + +\itemize{ +\item Functions (and pointer-to-function variables) are mapped via \code{\link{dynbind}} and a description of the C library using a \emph{library signatures}. +\item Symbolic names are assigned to its values for object-like macro defines and C enum types. +\item Run-time type-information objects for aggregate C data types (struct and union) are registered via \code{\link{parseStructInfos}} and \code{\link{parseUnionInfos}}. +} + +The file path to the \emph{DynPort} file is derived from +\code{portname} per default. This would refer to \code{"<repo>/<portname>.R"} +where \code{repo} usually refers to the initial \emph{DynPort} repository +located at the sub-folder \code{"dynports/"} of the package. +If \code{portfile} is given, then this value is taken as file path (usually +for testing purpose). + +A tool suite, comprising AWK (was boost wave), GCC Preprocessor, GCC-XML and XSLT, was used to generate the available \emph{DynPort} files automatically +by extracting type information from C library header files. + +In a future release, the DynPort format will be changed to +a language-neutral text file document. For the interested reader: +A first prototyp is currently available in an FFI extension to the Lua +programming language (see \code{luadyncall} subversion sub-tree). +A third revision (including function types in call signatures, bitfields, arrays, etc..) +is currently in development. +} +\references{ + Adler, D. (2012) \dQuote{Foreign Library Interface}, \emph{The R Journal}, \bold{4(1)}, 30--40, June 2012. + \url{http://journal.r-project.org/archive/2012-1/RJournal_2012-1_Adler.pdf} + + Adler, D., Philipp, T. (2008) \emph{DynCall Project}. \url{http://dyncall.org} + + Clark, J. (1998). expat - XML Parser Toolkit. \url{http://expat.sourceforge.net} + + Ikits, M. and Magallon, M. (2002). The OpenGL Extension Wrangler Library. \url{http://glew.sourceforge.net} + + Latinga, S. (1998). The Simple DirectMedia Layer Library. \url{http://www.libsdl.org} + + Segal, M. and Akeley, K. (1992). The OpenGL Graphics System. A Specification, Version 1.0. \url{http://www.opengl.org} + + Smith, R. (2001). Open Dynamics Engine. \url{http://www.ode.org} +} +\examples{ +\donttest{ +# Using SDL and OpenGL in R +dynport(SDL) +dynport(GL) +# Initialize Video Sub-system +SDL_Init(SDL_INIT_VIDEO) +# Initialize Screen with OpenGL Context and Double Buffering +SDL_SetVideoMode(320,256,32,SDL_OPENGL+SDL_DOUBLEBUF) +# Clear Color and Clear Screen +glClearColor(0,0,1,0) # blue +glClear(GL_COLOR_BUFFER_BIT) +# Flip Double-Buffer +SDL_GL_SwapBuffers() +} +} +\keyword{programming} +\keyword{interface} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/man/packing.Rd Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,49 @@ +\name{packing} +\alias{.pack} +\alias{packing} +\alias{.unpack} +\title{Handling of foreign C fundamental data types} +\description{Functions to unpack/pack (read/write) foreign C data types from/to R atomic vectors and C data objects such as arrays and pointers to structures.} +\usage{ +.pack(x, offset, sigchar, value) +.unpack(x, offset, sigchar) +} +\arguments{ +\item{x}{atomic vector (logical, raw, integer or double) or external pointer.} +\item{offset}{integer specifying \emph{byte offset} starting at 0.} +\item{sigchar}{character string specifying the C data type by a \link{type signature}.} +\item{value}{R object value to be coerced and packed to a foreign C data type.} +} +\details{ +The function \code{.pack} converts an R \code{value} into a C data type specified by the \link{signature} \code{sigchar} +and it writes the raw C foreign data value at byte position \code{offset} into the object \code{x}. +The function \code{.unpack} extracts a C data type according to the \link{signature} \code{sigchar} +at byte position \code{offset} from the object \code{x} and converts the C value to an R value and returns it. + +Byte \code{offset} calculations start at 0 relative to the first byte in an atomic vectors data area. + +If \code{x} is an atomic vector, a bound check is carried out before read/write access. +Otherwise, if \code{x} is an external pointer, there is only a C NULL pointer check. +} +\value{ +\code{.unpack} returns a read C data type coerced to an R value. +} +\seealso{ +\code{\link{.dyncall}} for details on type signatures. +} +\examples{ +# transfer double to array of floats and back, compare precision: +n <- 6 +input <- rnorm(n) +buf <- raw(n*4) +for (i in 1:n) { + .pack(buf, 4*(i-1), "f", input[i]) +} +output <- numeric(n) +for (i in 1:n) { + output[i] <- .unpack(buf, 4*(i-1), "f") +} +# difference between double and float +difference <- output-input +print( cbind(input,output,difference) ) +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/man/rdyncall-demos.Rd Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,222 @@ +\name{rdyncall-demos} +\alias{rdyncall-demos} +\title{rdyncall demos: Platform installation notes for required libraries} +\description{ +The demos of the \pkg{rdyncall} package (see \code{demo(package="rdyncall")}) +use shared libraries such as SDL, OpenGL and Expat via \code{\link{dynport}}s - +a dynamic binding approach which requires, that prebuilt binary shared library +files are already installed. + +Depending on the host system, some libraries are officially a part of the +OS or Distribution, some others need to be installed to get the demos running. + +As of the current version of this package, the installation of additional +shared C libraries need to be done manually. It follows an overview of +the required libraries and installation notes for various operating-systems and distributions. +} +\section{Overview of Libraries}{ +The following Libraries are used as 'run-time' pre-compiled binaries +for the particular target OS and Hardware platform. +Some notes on installation of additional run-time libraries +required for some rdyncall demos: + +\tabular{lll}{ +\strong{Lib} \tab \strong{Description} \tab \strong{URL} \cr +\code{expat} \tab XML Parser \tab \url{http://www.libexpat.org} \cr +\code{GL} \tab Open Graphics Library \tab \url{http://opengl.org}, \url{http://www.mesa3d.org} \cr +\code{GLU} \tab OpenGL Utility Library \tab see links above\cr +\code{glew} \tab OpenGL Extension Wrangler Library \tab \url{http://glew.sourceforge.net/} \cr +\code{SDL} \tab Multimedia Framework \tab \url{http://libsdl.org/} \cr +\code{SDL_mixer} \tab Music Format playing \tab \url{http://www.libsdl.org/projects/SDL_mixer/} \cr +\code{SDL_image} \tab Image Format loading \tab \url{http://www.libsdl.org/projects/SDL_image/} \cr +\code{SDL_ttf} \tab True Type Font rendering \tab \url{http://www.libsdl.org/projects/SDL_ttf/} \cr +\code{SDL_net} \tab Network I/O \tab \url{http://www.libsdl.org/projects/SDL_net/} \cr +} + +In short: Place the shared libraries ( \code{*.DLL}, \code{*.so} or \code{*.dylib}) in a \emph{standard location} or +modify LD_LIBRARY_PATH(unix) or PATH(windows) so that \code{\link{dynfind}} can find the libraries. + +On Mac OS X framework folders are supported as well. +Place the \code{*.framework} folder at \code{/Library/Frameworks}. + +Detailed platform-specific installation instructions follow up. +} +\section{Windows Installation Notes}{ +Download the \code{*.zip} files, unpack them and place the \code{*.DLL} files to a place within \code{PATH}. + +32-Bit versions: + +\tabular{ll}{ +\strong{Lib} \tab \strong{Download Link} \cr +\code{expat} \tab \url{http://expat.sourceforge.net} (TODO:test installer) \cr +\code{GL} \tab pre-installed \cr +\code{GLU} \tab pre-installed \cr +\code{glew} \tab \url{http://sourceforge.net/projects/glew/files/glew/1.7.0/glew-1.7.0-win32.zip/download} \cr +\code{SDL} \tab \url{http://www.libsdl.org/release/SDL-1.2.14-win32.zip} \cr +\code{SDL_image} \tab \url{http://www.libsdl.org/projects/SDL_image/release/SDL_image-1.2.10-win32.zip} \cr +\code{SDL_mixer} \tab \url{http://www.libsdl.org/projects/SDL_mixer/release/SDL_mixer-1.2.11-win32.zip} \cr +\code{SDL_ttf} \tab \url{http://www.libsdl.org/projects/SDL_ttf/release/SDL_ttf-2.0.10-win32.zip} \cr +\code{SDL_net} \tab \url{http://www.libsdl.org/projects/SDL_net/release/SDL_net-1.2.7-win32.zip} \cr +} + +64-Bit version: + +\tabular{ll}{ +\strong{Lib} \tab \strong{Downdload Link} \cr +\code{expat} \tab no prebuilt found (TODO: build) \cr +\code{GL} \tab pre-installed \cr +\code{GLU} \tab pre-installed \cr +\code{glew} \tab \url{http://sourceforge.net/projects/glew/files/glew/1.7.0/glew-1.7.0-win64.zip/download} \cr +\code{SDL} \tab \url{http://mamedev.org/tools/20100102/sdl-1.2.14-r5428-w64.zip} \cr +\code{SDL_image} \tab pre-built n/a \cr +\code{SDL_mixer} \tab pre-built n/a \cr +\code{SDL_ttf} \tab pre-built n/a \cr +\code{SDL_net} \tab pre-built n/a \cr +} + +The prebuilt version of SDL from \url{http://www.drangon.org/mingw} did not work (exiting with OpenGL errors). +If you know of other resources for prebuilt 64-bit packages for SDL and expat, please report. +} +\section{Mac OS X Installation Notes}{ +Download the \code{*.dmg} files, mount them (by double-click) and copy \code{*.framework} folders to \code{/Library/Frameworks}. +\tabular{ll}{ +\strong{Lib} \tab \strong{Download link} \cr +\code{expat} \tab pre-installed \cr +\code{GL} \tab pre-installed \cr +\code{GLU} \tab pre-installed \cr +\code{glew} \tab \code{port install glew} \cr +\code{SDL} \tab \url{http://www.libsdl.org/release/SDL-1.2.14.dmg} \cr +\code{SDL_image} \tab \url{http://www.libsdl.org/projects/SDL_image/release/SDL_image-1.2.10.dmg} \cr +\code{SDL_mixer} \tab \url{http://www.libsdl.org/projects/SDL_mixer/release/SDL_mixer-1.2.11.dmg} \cr +\code{SDL_ttf} \tab \url{http://www.libsdl.org/projects/SDL_ttf/release/SDL_ttf-2.0.10.dmg} \cr +\code{SDL_net} \tab \url{http://www.libsdl.org/projects/SDL_net/release/SDL_net-1.2.7.dmg} \cr +} +} +\section{Linux/Debian Installation Notes}{ + +Debian Package installation via aptitude + +\preformatted{aptitude install <pkg-names>..} + +\tabular{ll}{ +\strong{Lib} \tab \strong{Debian Package name(s)} \cr +\code{expat} \tab \code{libexpat1} (version 1.5.2 - already installed?)\cr +\code{GL} \tab \code{libgl1-mesa-glx} and \code{libgl1-mesa-dri} \cr +\code{GLU} \tab \code{libglu1-mesa} \cr +\code{glew} \tab \code{libglew1.5} \cr +\code{SDL} \tab \code{libsdl1.2debian} and \code{libsdl1.2debian-<SOUNDSYS>} \cr +\code{SDL_image} \tab \code{libsdl-image1.2} \cr +\code{SDL_mixer} \tab \code{libsdl-mixer1.2} \cr +\code{SDL_ttf} \tab \code{libsdl-ttf2.0} \cr +\code{SDL_net} \tab \code{libsdl-net1.2} \cr +} +Depending on your sound system, \code{<SOUNDSYS>} should be explaced with one of the following: alsa, all, esd, arts, oss, nas or pulseaudio. +Tested with Debian 5 and 6 (lenny and squeeze). +} +\section{Linux/Fedora Installation Notes}{ +\preformatted{pkcon install <pkgname>..} +\tabular{ll}{ +\strong{Lib} \tab \strong{RPM Package name} \cr +\code{expat} \tab \code{expat} \cr +\code{GL} \tab \code{mesa-libGL} \cr +\code{GLU} \tab \code{mesa-libGLU} \cr +\code{glew} \tab \code{glew} \cr +\code{SDL} \tab \code{SDL} \cr +\code{SDL_image} \tab \code{SDL_image} \cr +\code{SDL_mixer} \tab \code{SDL_mixer} \cr +\code{SDL_ttf} \tab \code{SDL_ttf} \cr +\code{SDL_net} \tab \code{SDL_net} \cr +} +Tested with Fedora 13 and 14 on x86 and x86_64. +} +\section{Linux/openSUSE Installation Notes}{ +\preformatted{zypper in <pkgname>..} +\tabular{ll}{ +\strong{Lib} \tab \strong{Package Name} \cr +\code{SDL} \tab \code{libSDL} \cr +\code{SDL_image} \tab \code{libSDL_image} \cr +\code{SDL_mixer} \tab \code{libSDL_mixer} \cr +\code{SDL_net} \tab \code{libSDL_net} \cr +\code{SDL_ttf} \tab \code{libSDL_ttf} \cr +\code{glew} \tab \code{libGLEW1_6} \cr +} +openSUSE installation notes have not been confirmed. +} +\section{NetBSD Installation Notes}{ + +Installation via pkgsrc: + +\preformatted{pkg_add <pkgname>..} + +\tabular{ll}{ +\strong{Lib} \tab \strong{pkgsrc name} \cr +\code{expat} \tab \code{expat} \cr +\code{GL} \tab \code{Mesa} \cr +\code{GLU} \tab \code{glu} \cr +\code{glew} \tab \code{glew} \cr +\code{SDL} \tab \code{SDL} \cr +\code{SDL_image} \tab \code{SDL_image} \cr +\code{SDL_mixer} \tab \code{SDL_mixer} \cr +\code{SDL_ttf} \tab \code{SDL_ttf} \cr +\code{SDL_net} \tab \code{SDL_net} \cr +} +} +\section{OpenBSD Installation Notes}{ +Using packages: + +\preformatted{pkg_add <pkgname>..} + +\tabular{ll}{ +\strong{Lib} \tab \strong{port name} \cr +\code{expat} \tab \code{expat} \cr +\code{SDL} \tab \code{SDL} \cr +\code{SDL_image} \tab \code{sdl-image} \cr +\code{SDL_mixer} \tab \code{sdl-mixer} \cr +\code{SDL_ttf} \tab not available \cr +\code{SDL_net} \tab \code{sdl-net} \cr +} + +The SDL dynport failed on OpenBSD 4.8 - so no multimedia demos here - using the R 2.7 from the ports tree. +This must have been something to do with pthread discrepancies between SDL and R. +} +\section{FreeBSD Installation Notes}{ +Using packages: + +\preformatted{pkg_add -r <pkgname>..} + +\tabular{ll}{ +\strong{Lib} \tab \strong{pkgname} \cr +\code{expat} \tab \code{expat2} \cr +\code{GL} \tab \code{xorg} \cr +\code{glew} \tab \code{glew} \cr +\code{SDL} \tab \code{sdl} \cr +\code{SDL_image} \tab \code{sdl_image} \cr +\code{SDL_mixer} \tab \code{sdl_mixer} \cr +\code{SDL_ttf} \tab \code{sdl_ttf} \cr +\code{SDL_net} \tab \code{sdl_net} \cr +} + +} +\section{Solaris Installation Notes}{ + +OpenCSW offers prebuilt binaries for Solaris. +The installation of OpenCSW packages is done via \code{pkgutil}. + +\preformatted{pkgutil -i <pkgname>..} + +See \url{http://www.opencsw.org} for details on the OpenCSW project. + +\tabular{ll}{ +\strong{Lib} \tab \strong{pkgname} \cr +\code{expat} \tab \code{expat} \cr +\code{GL} \tab \code{mesalibs} \cr +\code{GLU} \tab \code{mesalibs} \cr +\code{glew} \tab \code{glew} \cr +\code{SDL} \tab \code{libsdl1_2_0} \cr +\code{SDL_image} \tab \code{sdlimage} \cr +\code{SDL_mixer} \tab \code{sdlmixer} \cr +\code{SDL_net} \tab \code{sdlnet} \cr +\code{SDL_ttf} \tab \code{sdlttf} \cr +} + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/man/rdyncall.Rd Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,161 @@ +\name{rdyncall} +\docType{package} +\alias{rdyncall} +\alias{rdyncall-package} +\title{Improved Foreign Function Interface (FFI) and Dynamic Bindings to C Libraries (e.g. OpenGL) } +\description{The package provides a cross-platform framework for dynamic binding of + C libraries using a flexible Foreign Function Interface (FFI). + The FFI supports almost all fundamental C types, multiple calling conventions, + symbolic access to foreign C struct/union data types and wrapping of R functions + as C callback function pointers. + Dynamic bindings to shared C libraries are data-driven by cross-platform binding specification + using a compact plain text format ; an initial repository of bindings to a couple of + common C libraries (OpenGL, SDL, Expat, glew, CUDA, OpenCL, ODE, R) comes with the package. + The package includes a variety of technology demos and OS-specific notes for installation of shared libraries. +} +\details{ +\pkg{rdyncall} offers a stack of interoperability technologies for working +with foreign compiled languages using cross-platform portable abstraction +methods. + +For R application development, the package facilitates direct access from R +to the C Application Programming Interface (API) of common libraries. +This enables a new style of development: R applications can use +low-level services of portable C libraries. +System-level code can be implemented in R without leaving the language. +C APIs can be explored from within the R interpreter. +Moving the R code from one platform to the other does not involve +recompilation. +Ofcourse, the run-time libraries need to be installed using a standard +procedure of the target Operating-System Distribution. +See \link{rdyncall-demos} for details on this. + +For R core development and research, the package provides an improved Foreign +Function Interface (FFI) that can be used to call arbitrary +foreign precompiled C code without the need for additional +compilation of wrapper code. The back-end library is extendable with new +calling conventions (such as Fortran,Pascal,COM,etc.. - which has not been +the focus as of this release, but might be supported officially in the near +futurue). +Basic type-safety checks for argument passing and framework support for +working with foreign C data types such as pointers, arrays, structs and +wrapping of R functions into first-level C callback function pointers +round up this framework. +} +\section{Overview}{ +\itemize{ +\item Flexible FFI with support for almost all C types, type-safety checks and multiple calling conventions. See \code{\link{.dyncall}}. +\item Loading of shared libraries with \emph{automatic unload management} and using direct access to OS linker. See \code{\link{.dynload}}. +\item Cross-platform naming and loading of shared libraries. See \code{\link{dynfind}}. +\item Binding C library functions via thin call wrappers. See \code{\link{dynbind}}. +\item Handling of foreign C pointer, array and struct/union data types. See \code{\link{packing}} and \code{\link{struct}}. +\item Dynamic wrapping of R functions as C function pointers to be used in C callbacks. See \code{\link{new.callback}}. +\item Dynamic bindings to standard and common C libraries and APIs (functions, variables, macro constants, enums, struct and union types). See \code{\link{dynport}}. +} +} +\section{Getting Started}{ +Several demos ranging from simple FFI calls to the C standard math library up to more complex 3D OpenGL/SDL Applications are available. +See \code{demos(package="rdyncall")} for an overview. +Some demos require shared C libraries to be installed in the system. Please read \link{rdyncall-demos} for details. +} +\section{Supported Platforms}{ +The low-level implementation is mainly based on libraries from the DynCall +Project (\url{http://dyncall.org}). The library suite is distributed +as part of the package source tree. + +The dyncall and dyncallback libraries implement generic low-level services +with the help of a small amount of hand-written assembly code and +careful modeling of the target machine's calling sequence +for each platform to support. + +As of version 0.6, the following processor architectures are supported: + +\itemize{ +\item Intel i386 32-bit and AMD 64-bit Platforms +\item ARM 32-bit (OABI, EABI and ARMHF ABI with support for Thumb) +\item PowerPC 32-bit (support for callbacks not implemented for Linux/BSD) +\item MIPS 32- and 64-bit (support for callbacks not yet implemented) +\item SPARC 32- and 64-bit (support for callbacks not yet implemented) +} + +The DynCall libraries are tested on Linux, Mac OS X, Windows, BSD derivates +and more exotic platforms such as game consoles and Plan9. +Please see the details on portability for \link{dyncall}, \link{dyncallback} and \link{dynload} +and the official DynCall manual for full details of the back-end. +The R Package has been tested on several major R platforms. +The following gives a list of comments on platforms about the status of this package. + +\tabular{l}{ +\cr +Linux Debian 4/ppc32 , R-2.4.0 : ok, but no callbacks. \cr +Linux Debian 5/arm , R-2.7.0 : ok, SDL not tested. \cr +Linux Debian 6/x86 , R-2.12.2: ok. \cr +Linux Debian 6/x64 , R-2.12.2: ok. \cr +Linux Ubuntu 10/armv7, R-2.14 : ok. \cr +Linux Fedora 14/x86 : ok. \cr +Linux Ubuntu 12/i386 , R-2.15.1: ok. \cr +Mac OS X 10.4/ppc , R-2.10.0: ok. \cr +Mac OS X 10.6/x86 , R-2.12.2: ok. \cr +Mac OS X 10.6/x64 , R-2.12.2: ok. \cr +Mac OS X 10.7/x64 , R-2.15.1: ok. \cr +NetBSD 5.0/x86 : ok. \cr +NetBSD 5.1/x64 : ok. \cr +OpenBSD 4.8/x64 , R-2.7.0 : SDL failed. \cr +Windows XP/x86 , R-2.12.2: ok. \cr +Windows 7/x86 , R-2.12.2: ok. \cr +Windows 7/x64 , R-2.12.2: ok, use correct 64-bit SDL DLL, SDL extension not tested - see \link{rdyncall-demos}) \cr +FreeBSD 8.2/x86 : build ok, no tests made for X11. \cr +} +} +\references{ + Adler, D. (2012) \dQuote{Foreign Library Interface}, \emph{The R Journal}, \bold{4(1)}, 30--40, June 2012. + \url{http://journal.r-project.org/archive/2012-1/RJournal_2012-1_Adler.pdf} + + Adler, D., Philipp, T. (2008) \emph{DynCall Project}. + \url{http://dyncall.org} +} +\examples{ +\donttest{ +# multimedia example +# load dynports for OpenGL, Simple DirectMedia library +# globals: +surface <- NULL +# init SDL and OpenGL +init <- function() +{ + dynport(SDL) + dynport(GL) + if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) stop("SDL_Init failed") + surface <<- SDL_SetVideoMode(320,240,32,SDL_DOUBLEBUF+SDL_OPENGL) + cat("surface dimension:", surface$w, "x",surface$h,sep="") +} +# draw blue screen +updateSurface <- function(t) +{ + glClearColor(0,0,t \%\% 1,0) + glClear(GL_COLOR_BUFFER_BIT+GL_DEPTH_BUFFER_BIT) + SDL_GL_SwapBuffers() +} +# wait till close +mainloop <- function() +{ + quit <- FALSE + evt <- new.struct(SDL_Event) + base <- SDL_GetTicks() / 1000 + t <- 0 + while(!quit) { + updateSurface(t) + while(SDL_PollEvent(evt)) { + if ( evt$type == SDL_QUIT ) quit <- TRUE + } + now <- SDL_GetTicks() / 1000 + t <- now - base + } +} +init() +mainloop() +} +} +\keyword{programming} +\keyword{interface} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/man/struct.Rd Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,120 @@ +\name{struct} +\alias{struct} +\alias{new.struct} +\alias{as.struct} +\alias{parseStructInfos} +\alias{parseUnionInfos} +\alias{$.struct} +\alias{print.struct} +\alias{$<-.struct} +\title{Allocation and handling of foreign C aggregate data types} +\description{Functions for allocation, access and registration of foreign C \code{struct} and \code{union} data type.} +\usage{ +new.struct(type) +as.struct(x, type) +parseStructInfos(sigs, envir=parent.frame()) +parseUnionInfos(sigs, envir=parent.frame()) +\S3method{$}{struct}(x, index) +\S3method{$}{struct}(x, index) <- value +\S3method{print}{struct}(x, indent=0, \ldots) +} +\arguments{ + \item{x}{external pointer or atomic raw vector of S3 class 'struct'.} + \item{type}{S3 \link{TypeInfo} Object or character string that names the structure type.} + \item{sigs}{character string that specifies several C struct/union type \link{signature}s.} + \item{envir}{the environment to install S3 type information object(s).} + \item{index}{character string specifying the field name.} + \item{indent}{indentation level for pretty printing structures.} + \item{value}{value to be converted according to struct/union field type given by field index.} + \item{...}{additional arguments to be passed to \code{\link[base]{print}} method.} +} +\details{ +References to foreign C data objects are represented by objects of class 'struct'. + +Two reference types are supported: + +\itemize{ + \item \emph{External pointers} returned by \code{\link{.dyncall}} using a call signature with a \emph{typed pointer} return type signature + and pointers extracted as a result of \code{\link{.unpack}} and S3 \code{struct} \code{$}-operators. + \item \emph{Internal objects}, memory-managed by R, are allocated by \code{new.struct}: +An atomic \code{raw} storage object is returned, initialized with length equal to the byte size of the +foreign C data type. +} + +In order to access and manipulate the data fields of foreign C aggregate data objects, the \dQuote{$} and \dQuote{$<-} S3 operator methods +can be used. + +S3 objects of class \code{struct} have an attribute \code{struct} set to the name of a \code{\link{TypeInfo}} object, which provides the +run-time type information of a particular foreign C type. + +The run-time type information for foreign C \code{struct} and \code{union} types need to be registered once via +\code{parseStructInfos} and \code{parseUnionInfos} functions. +The C data types are specified by \code{sigs}, a signature character string. The formats for both types are described next: + +\strong{Structure type signatures} describe the layout of aggregate \code{struct} C data types. +Type Signatures are used within the \sQuote{field-types}. \sQuote{field-names} consists of space separated identifier names and +should match the number of fields. + +\tabular{c}{ +\emph{struct-name} '\code{\{}' \emph{field-types} '\code{\}}' \emph{field-names} '\code{;}' \cr +} + +Here is an example of a C \code{struct} type: + +\preformatted{ +struct Rect \{ + signed short x, y; + unsigned short w, h; +\}; +} + +The corresponding structure type signature is: + +\preformatted{"Rect\{ssSS\}x y w h;"} + +\strong{Union type signatures} describe the components of the \code{union} C data type. +Type signatures are used within the \sQuote{field-types}. \sQuote{field-names} consists of space separated identifier names and +should match the number of fields. + +\tabular{c}{ +\emph{union-name} '\code{|}' \emph{field-types} '\code{\}}' \emph{field-names} '\code{;}' \cr +} + +Here is an example of a C \code{union} type, + +\preformatted{ +union Value \{ + int anInt; + float aFloat; + struct LongValue aStruct +\}; +} + +The corresponding union type signature is: + +\code{"Value|if<LongValue>}anInt aFloat aStruct;"} + +\code{as.struct} can be used to \emph{cast} a foreign C data reference to a different type. +When using an external pointer reference, this can lead quickly to a \strong{fatal R process crash} - like in C. +} +\seealso{ +\code{\link{.dyncall}} for type signatures and \code{\link{TypeInfo}} for details on run-time type information S3 objects. +} +\examples{ +# Specify the following foreign type: +# struct Rect { +# short x, y; +# unsigned short w, h; +# } +parseStructInfos("Rect{ssSS}x y w h;") +r <- new.struct(Rect) +print(r) +r$x <- 40 +r$y <- 60 +r$w <- 10 +r$h <- 15 +print(r) +str(r) +} +\keyword{programming} +\keyword{interface}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/man/typeinfo.Rd Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,45 @@ +\name{typeinfo} +\alias{TypeInfo} +\alias{getTypeInfo} +\alias{type information} +\title{S3 class for run-time type information of foreign C data types} +\description{S3 class for run-time type information of foreign C data types.} +\usage{ +TypeInfo(name, type = c("base","pointer","struct","union"), + size = NA, align = NA, basetype = NA, fields = NA, + signature = NA) +getTypeInfo(name, envir = parent.frame()) +} +\arguments{ + \item{name}{character string specifying the type name.} + \item{type}{character string specifying the type.} + \item{size}{integer, size of type in bytes.} + \item{align}{integer, alignment of type in bytes.} + \item{basetype}{character string, base type of 'pointer' types.} + \item{signature}{character string specifying the struct/union type \link{signature}.} + \item{envir}{the environment to look for type object.} + \item{fields}{data frame with type and offset information that specifies aggregate struct and union types.} +} +\details{ +Type information objects are created at run-time to describe the concrete +layout of foreign C data types on the host machine. While \link{type signature}s +give an abstract information on e.g. the field types and names of +aggregate structure types, these objects store concrete memory size, alignment and layout information +about C data types. +} +\value{ +List object tagged as S3 class 'TypeInfo' with the following named entries +\item{type}{Type name.} +\item{size}{Size in bytes.} +\item{align}{Alignment in bytes.} +\item{fields}{Data frame for field information with the following columns: + \tabular{ll}{ + \code{type} \tab type name\cr + \code{offset} \tab byte offset (starts counted from 0)\cr + } +} +} +\seealso{ +\code{\link{parseStructInfos}} for details on the framework for handling foreign C data types. +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/man/utils.Rd Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,67 @@ +\name{utils} +\alias{is.nullptr} +\alias{as.extptr} +\alias{is.externalptr} +\alias{floatraw} +\alias{as.floatraw} +\alias{floatraw2numeric} +\alias{ptr2str} +\alias{strarrayptr} +\alias{strptr} +\alias{offsetPtr} +\title{Utility functions for working with foreign C data types} +\description{Functions for low-level operations on C pointers as well as +helper functions and objects to handle C \code{float} arrays and strings.} +\usage{ +is.nullptr(x) +as.extptr(x) +is.externalptr(x) +floatraw(n) +as.floatraw(x) +floatraw2numeric(x) +ptr2str(x) +strarrayptr(x) +strptr(x) +offsetPtr(x, offset) +} +\arguments{ +\item{x}{an R object.} +\item{n}{number of elements to allocate.} +\item{offset}{a offset given in bytes.} +} +\details{ + +\code{is.nullptr} tests if the external pointer given by \code{x} represents a C \code{NULL} pointer. + +\code{as.extptr} returns an external pointer to the data area of atomic +vector given by \code{x}. The external pointer holds an additional reference +to the \code{x} R object to prevent it from garbage collection. + +\code{is.externalptr} tests if the object given by \code{x} is an external pointer. + +\code{floatraw} creates an array with a capacity to store \code{n} single-precision C \code{float} values. +The array is implemented via a \code{\link[base]{raw}} vector. + +\code{as.floatraw} coerces a numeric vector into a single-precision C \code{float} vector. +Values given by \code{x} are converted to C \code{float} values and stored in the R raw vector via \code{.pack}. +This function is useful when calling foreign functions that expeect a C \code{float} pointer via \code{\link{.dyncall}}. + +\code{floatraw2numeric} coerces a C \code{float} (raw) vector to a numeric vector. + +\code{ptr2str}, \code{strarrayptr}, \code{strptr} are currently experimental. + +\code{offsetPtr} creates a new external pointer pointing to \code{x} plus the byte \code{offset}. +If \code{x} is given as an external pointer, the address is increased by the \code{offset}, +or, if \code{x} is given as a atomic vector, the address of the data (pointing to offset zero) is taken as basis +and increased by the \code{offset}. +The returned external pointer is protected (as offered by the C function \code{R_MakeExternalPtr}) by the external pointer \code{x}. +} +\value{ +A logical value is returned by \code{is.nullptr} and \code{is.externalptr}. +\code{as.extptr} returns an external pointer value. +\code{floatraw} and \code{as.floatraw} return an atomic vector of type \code{raw} +tagged with class \code{'floatraw'}. +\code{floatraw2numeric} returns a \code{numeric} atomic vector. +} +\keyword{programming} +\keyword{interface}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/src/Makevars Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,11 @@ +PKG_CPPFLAGS=-Idyncall/dyncall -Idyncall/dynload -Idyncall/dyncallback +PKG_LIBS=dyncall/dyncall/libdyncall_s.a dyncall/dynload/libdynload_s.a dyncall/dyncallback/libdyncallback_s.a + +.PHONY: all mylibs + +all: $(SHLIB) +$(SHLIB): mylibs + +mylibs: + (cd dyncall ; CC="$(CC)" AR="$(AR)" CFLAGS="-fPIC $(CFLAGS)" CPPFLAGS="-DNDEBUG ${CPPFLAGS}" make -f Makefile.embedded) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/src/Makevars.win Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,11 @@ +PKG_CPPFLAGS=-Idyncall/dyncall -Idyncall/dynload -Idyncall/dyncallback +PKG_LIBS=dyncall/dyncall/libdyncall_s.a dyncall/dynload/libdynload_s.a dyncall/dyncallback/libdyncallback_s.a + +.PHONY: all mylibs + +all: $(SHLIB) +$(SHLIB): mylibs + +mylibs: + (cd dyncall ; CC="$(CC)" AR="$(AR)" CFLAGS="$(CFLAGS)" CPPFLAGS="-DNDEBUG ${CPPFLAGS}" make -f Makefile.embedded) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/src/rcallback.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,222 @@ +/** =========================================================================== + ** R-Package: rdyncall + ** File: src/rcallback.c + ** Description: dyncall callback R backend + **/ + +#include "Rinternals.h" +#include "Rdefines.h" +#include "dyncall_callback.h" + +typedef struct +{ + int disabled; + SEXP fun; + SEXP rho; + int nargs; + const char* signature; /* argument signature without call mode prefix */ +} R_Callback; + +char dcCallbackHandler_R( DCCallback* pcb, DCArgs* args, DCValue* result, void* userdata ) +{ + R_Callback* rdata; + const char* ptr; + int i,n; + SEXP s, x, ans, item; + char ch; + + rdata = (R_Callback*) userdata; + + if (rdata->disabled) return DC_SIGCHAR_VOID; + + ptr = rdata->signature; + + // allocate an nargs + 1 'call' language object + // first argument is function + // rest is arguments from callback + n = 1 + rdata->nargs; + + PROTECT( s = allocList(n) ); + SET_TYPEOF(s, LANGSXP); + SETCAR( s, rdata->fun ); x = CDR(s); + + // fill up call object + + i = 1; + for( ;; ++i) { + ch = *ptr++; + if (ch == ')') break; + if (i >= n) { + warning("invalid signature."); + rdata->disabled = 1; + UNPROTECT(1); + return DC_SIGCHAR_VOID; + } + switch(ch) { + case DC_SIGCHAR_BOOL: item = ScalarLogical( ( dcbArgBool(args) == DC_FALSE ) ? FALSE : TRUE ); break; + case DC_SIGCHAR_CHAR: item = ScalarInteger( (int) dcbArgChar(args) ); break; + case DC_SIGCHAR_UCHAR: item = ScalarInteger( (int) dcbArgUChar(args) ); break; + case DC_SIGCHAR_SHORT: item = ScalarInteger( (int) dcbArgShort(args) ); break; + case DC_SIGCHAR_USHORT: item = ScalarInteger( (int) dcbArgUShort(args) ); break; + case DC_SIGCHAR_INT: item = ScalarInteger( (int) dcbArgInt(args) ); break; + case DC_SIGCHAR_UINT: item = ScalarReal( (double) dcbArgUInt(args) ); break; + case DC_SIGCHAR_LONG: item = ScalarReal( (double) dcbArgLong(args) ); break; + case DC_SIGCHAR_ULONG: item = ScalarReal( (double) dcbArgULong(args) ); break; + case DC_SIGCHAR_LONGLONG: item = ScalarReal( (double) dcbArgLongLong(args) ); break; + case DC_SIGCHAR_ULONGLONG: item = ScalarReal( (double) dcbArgULongLong(args) ); break; + case DC_SIGCHAR_FLOAT: item = ScalarReal( (double) dcbArgFloat(args) ); break; + case DC_SIGCHAR_DOUBLE: item = ScalarReal( dcbArgDouble(args) ); break; + case DC_SIGCHAR_POINTER: item = R_MakeExternalPtr( dcbArgPointer(args), R_NilValue, R_NilValue ); break; + case DC_SIGCHAR_STRING: item = mkString( dcbArgPointer(args) ); break; + default: + case '\0': + warning("invalid signature"); + rdata->disabled = 1; + UNPROTECT(1); + return DC_SIGCHAR_VOID; + } + SETCAR( x, item); + x = CDR(x); + } + + /* evaluate expression */ + + int error = 0; + + PROTECT( ans = R_tryEval( s, rdata->rho, &error ) ); + + if (error) + { + warning("an error occurred during callback invocation in R. Callback disabled."); + rdata->disabled = 1; + UNPROTECT(2); + return DC_SIGCHAR_VOID; + } + + /* propagate return value */ + + ch = *ptr; /* scan return value type character */ + + /* handle NULL and len(x) == 0 expressions special */ + if ( (ans == R_NilValue) || (LENGTH(ans) == 0) ) + { + /* handle NULL */ + result->L = 0; + } + else + { + switch(ch) + { + case DC_SIGCHAR_VOID: + break; + case DC_SIGCHAR_BOOL: + switch( TYPEOF(ans) ) + { + case INTSXP: result->B = (INTEGER(ans)[0] == 0 ) ? DC_FALSE : DC_TRUE; break; + case LGLSXP: result->B = (LOGICAL(ans)[0] == FALSE ) ? DC_FALSE : DC_TRUE; break; + default: result->B = DC_FALSE; break; + } + break; + case DC_SIGCHAR_CHAR: + case DC_SIGCHAR_UCHAR: + case DC_SIGCHAR_SHORT: + case DC_SIGCHAR_USHORT: + case DC_SIGCHAR_INT: + case DC_SIGCHAR_UINT: + case DC_SIGCHAR_LONG: + case DC_SIGCHAR_ULONG: + switch( TYPEOF(ans) ) + { + case INTSXP: result->i = INTEGER(ans)[0]; break; + case REALSXP: result->i = (int) REAL(ans)[0]; break; + default: result->i = 0; break; + } + break; + case DC_SIGCHAR_ULONGLONG: + case DC_SIGCHAR_LONGLONG: + switch( TYPEOF(ans) ) + { + case INTSXP: result->L = (long long) INTEGER(ans)[0]; break; + case REALSXP: result->L = (long long) REAL(ans)[0]; break; + default: result->L = 0; break; + } + break; + case DC_SIGCHAR_FLOAT: + switch( TYPEOF(ans) ) + { + case INTSXP: result->f = (float) INTEGER(ans)[0]; break; + case REALSXP: result->f = (float) REAL(ans)[0]; break; + default: result->f = 0.0f; break; + } + break; + case DC_SIGCHAR_DOUBLE: + switch( TYPEOF(ans) ) + { + case INTSXP: result->d = (double) INTEGER(ans)[0]; break; + case REALSXP: result->d = REAL(ans)[0]; break; + default: result->d = 0.0; break; + } + break; + case DC_SIGCHAR_POINTER: + switch( TYPEOF(ans) ) + { + case EXTPTRSXP: result->p = R_ExternalPtrAddr(ans); break; + case INTSXP : result->p = (DCpointer) (ptrdiff_t) (unsigned long long int) INTEGER(ans)[0]; break; + case REALSXP : result->p = (DCpointer) (ptrdiff_t) (unsigned long long int) REAL(ans)[0]; break; + default: result->p = NULL; break; + } + break; + case DC_SIGCHAR_STRING: + warning("not implemented"); + rdata->disabled = 1; + break; + } + } + UNPROTECT(2); + return ch; +} + +void R_callback_finalizer(SEXP x); + +SEXP r_new_callback(SEXP sig_x, SEXP fun_x, SEXP rho_x) +{ + const char* signature; + R_Callback* rdata; + const char* ptr; + char ch; + signature = CHAR( STRING_ELT( sig_x, 0 ) ); + rdata = Calloc(1, R_Callback); + rdata->disabled = 0; + rdata->fun = fun_x; + rdata->rho = rho_x; + R_PreserveObject(rdata->fun); + R_PreserveObject(rdata->rho); + ptr = signature; + // skip call mode signature + if ( (ch=*ptr) == '_') { + ptr += 2; + ch=*ptr; + } + rdata->signature = ptr++; + int nargs = 0; + while( ch != ')') { + nargs ++; + ch = *ptr++; + } + rdata->nargs = nargs; + DCCallback* cb = dcbNewCallback( signature, dcCallbackHandler_R, rdata); + SEXP ans = R_MakeExternalPtr( cb, R_NilValue, R_NilValue ); + R_RegisterCFinalizerEx(ans, R_callback_finalizer, TRUE); + return ans; +} + +void R_callback_finalizer(SEXP x) +{ + DCCallback* cb = R_ExternalPtrAddr(x); + R_Callback* rdata = dcbGetUserData(cb); + R_ReleaseObject(rdata->fun); + R_ReleaseObject(rdata->rho); + Free(rdata); + dcbFreeCallback(cb); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/src/rdyncall.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,601 @@ +/** =========================================================================== + ** R-Package: rdyncall + ** File: src/rdyncall.c + ** Description: R bindings to dyncall + **/ + +#include <Rinternals.h> +#include "dyncall.h" +#include "rdyncall_signature.h" +#include <string.h> +#include <ctype.h> + +/** --------------------------------------------------------------------------- + ** C-Function: new_callvm + ** R-Interface: .Call + **/ + +SEXP r_new_callvm(SEXP mode_x, SEXP size_x) +{ + /* default call mode is "cdecl" */ + int size_i = INTEGER(size_x)[0]; + + const char* mode_S = CHAR( STRING_ELT( mode_x, 0 ) ); + + int mode_i = DC_CALL_C_DEFAULT; + if (strcmp(mode_S,"default") == 0 || strcmp(mode_S,"cdecl") == 0) mode_i = DC_CALL_C_DEFAULT; +#if WIN32 + else if (strcmp(mode_S,"stdcall") == 0) mode_i = DC_CALL_C_X86_WIN32_STD; + else if (strcmp(mode_S,"thiscall") == 0) mode_i = DC_CALL_C_X86_WIN32_THIS_GNU; + else if (strcmp(mode_S,"thiscall.gcc") == 0) mode_i = DC_CALL_C_X86_WIN32_THIS_GNU; + else if (strcmp(mode_S,"thiscall.msvc") == 0) mode_i = DC_CALL_C_X86_WIN32_THIS_MS; + else if (strcmp(mode_S,"fastcall") == 0) mode_i = DC_CALL_C_X86_WIN32_FAST_GNU; + else if (strcmp(mode_S,"fastcall.msvc") == 0) mode_i = DC_CALL_C_X86_WIN32_FAST_MS; + else if (strcmp(mode_S,"fastcall.gcc") == 0) mode_i = DC_CALL_C_X86_WIN32_FAST_GNU; +#endif +/* + else { error("invalid 'callmode'"); return R_NilValue; } +*/ + + DCCallVM* pvm = dcNewCallVM(size_i); + dcMode( pvm, mode_i ); + return R_MakeExternalPtr( pvm, R_NilValue, R_NilValue ); +} + +/** --------------------------------------------------------------------------- + ** C-Function: free_callvm + ** R-Interface: .Call + **/ + +SEXP r_free_callvm(SEXP callvm_x) +{ + DCCallVM* callvm_p = (DCCallVM*) R_ExternalPtrAddr( callvm_x ); + dcFree( callvm_p ); + return R_NilValue; +} + +/** --------------------------------------------------------------------------- + ** C-Function: r_dyncall + ** R-Interface: .External + **/ + +SEXP r_dyncall(SEXP args) /* callvm, address, signature, args ... */ +{ + DCCallVM* pvm; + void* addr; + const char* signature; + const char* sig; + SEXP arg; + int ptrcnt; + int argpos; + + args = CDR(args); + + /* extract CallVM reference, address and signature */ + + pvm = (DCCallVM*) R_ExternalPtrAddr( CAR(args) ); args = CDR(args); + + switch(TYPEOF(CAR(args))) { + case EXTPTRSXP: + addr = R_ExternalPtrAddr( CAR(args) ); args = CDR(args); + if (!addr) { + error("Target address is null-pointer."); + return R_NilValue; /* dummy */ + } + break; + default: + error("Target address must be external pointer."); + return R_NilValue; /* dummy */ + } + signature = CHAR( STRING_ELT( CAR(args), 0 ) ); args = CDR(args); + sig = signature; + + if (!pvm) { + error("Argument 'callvm' is null"); + /* dummy */ return R_NilValue; + } + if (!addr) { + error("Argument 'addr' is null"); + /* dummy */ return R_NilValue; + } + /* reset CallVM to initial state */ + + dcReset(pvm); + ptrcnt = 0; + argpos = 0; + + /* function calling convention prefix '_' */ + if (*sig == DC_SIGCHAR_CC_PREFIX) { + /* specify calling convention by signature prefix hint */ + ++sig; + char ch = *sig++; + int mode = DC_CALL_C_DEFAULT; + switch(ch) + { + case DC_SIGCHAR_CC_STDCALL: + mode = DC_CALL_C_X86_WIN32_STD; break; + case DC_SIGCHAR_CC_FASTCALL_GNU: + mode = DC_CALL_C_X86_WIN32_FAST_GNU; break; + case DC_SIGCHAR_CC_FASTCALL_MS: + mode = DC_CALL_C_X86_WIN32_FAST_MS; break; + default: + error("Unknown calling convention prefix hint signature character '%c'", ch ); + /* dummy */ return R_NilValue; + } + dcMode(pvm, mode); + } + + /* load arguments */ + for(;;) { + + char ch = *sig++; + + if (ch == '\0') { + error("Function-call signature '%s' is invalid - missing argument terminator character ')' and return type signature.", signature); + /* dummy */ return R_NilValue; + } + /* argument terminator */ + if (ch == ')') break; + + /* end of arguments? */ + if (args == R_NilValue) { + error("Not enough arguments for function-call signature '%s'.", signature); + /* dummy */ return R_NilValue; + } + /* pointer counter */ + else if (ch == '*') { ptrcnt++; continue; } + + /* unpack next argument */ + arg = CAR(args); args = CDR(args); + argpos++; + + int type_id = TYPEOF(arg); + + if (ptrcnt == 0) { /* base types */ + + /* 'x' signature for passing language objects 'as-is' */ + if (ch == DC_SIGCHAR_SEXP) { + dcArgPointer(pvm, (void*)arg); + continue; + } + + if ( type_id != NILSXP && type_id != EXTPTRSXP && LENGTH(arg) == 0 ) { + error("Argument type mismatch at position %d: expected length greater zero.", argpos); + /* dummy */ return R_NilValue; + } + switch(ch) { + case DC_SIGCHAR_BOOL: + { + DCbool boolValue; + switch(type_id) + { + case LGLSXP: boolValue = ( LOGICAL(arg)[0] == 0 ) ? DC_FALSE : DC_TRUE; break; + case INTSXP: boolValue = ( INTEGER(arg)[0] == 0 ) ? DC_FALSE : DC_TRUE; break; + case REALSXP: boolValue = ( REAL(arg)[0] == 0.0 ) ? DC_FALSE : DC_TRUE; break; + case RAWSXP: boolValue = ( RAW(arg)[0] == 0 ) ? DC_FALSE : DC_TRUE; break; + default: error("Argument type mismatch at position %d: expected C bool convertable value", argpos); /* dummy */ return R_NilValue; + } + dcArgBool(pvm, boolValue ); + } + break; + case DC_SIGCHAR_CHAR: + { + char charValue; + switch(type_id) + { + case LGLSXP: charValue = (char) LOGICAL(arg)[0]; break; + case INTSXP: charValue = (char) INTEGER(arg)[0]; break; + case REALSXP: charValue = (char) REAL(arg)[0]; break; + case RAWSXP: charValue = (char) RAW(arg)[0]; break; + default: error("Argument type mismatch at position %d: expected C char convertable value", argpos); /* dummy */ return R_NilValue; + } + dcArgChar(pvm, charValue); + } + break; + case DC_SIGCHAR_UCHAR: + { + unsigned char charValue; + switch(type_id) + { + case LGLSXP: charValue = (unsigned char) LOGICAL(arg)[0]; break; + case INTSXP: charValue = (unsigned char) INTEGER(arg)[0]; break; + case REALSXP: charValue = (unsigned char) REAL(arg)[0]; break; + case RAWSXP: charValue = (unsigned char) RAW(arg)[0]; break; + default: error("Argument type mismatch at position %d: expected C unsigned char convertable value", argpos); /* dummy */ return R_NilValue; + } + dcArgChar(pvm, *( (char*) &charValue )); + } + break; + case DC_SIGCHAR_SHORT: + { + short shortValue; + switch(type_id) + { + case LGLSXP: shortValue = (short) LOGICAL(arg)[0]; break; + case INTSXP: shortValue = (short) INTEGER(arg)[0]; break; + case REALSXP: shortValue = (short) REAL(arg)[0]; break; + case RAWSXP: shortValue = (short) RAW(arg)[0]; break; + default: error("Argument type mismatch at position %d: expected C short convertable value", argpos); /* dummy */ return R_NilValue; + } + dcArgShort(pvm, shortValue); + } + break; + case DC_SIGCHAR_USHORT: + { + unsigned short shortValue; + switch(type_id) + { + case LGLSXP: shortValue = (unsigned short) LOGICAL(arg)[0]; break; + case INTSXP: shortValue = (unsigned short) INTEGER(arg)[0]; break; + case REALSXP: shortValue = (unsigned short) REAL(arg)[0]; break; + case RAWSXP: shortValue = (unsigned short) RAW(arg)[0]; break; + default: error("Argument type mismatch at position %d: expected C unsigned short convertable value", argpos); /* dummy */ return R_NilValue; + } + dcArgShort(pvm, *( (short*) &shortValue ) ); + } + break; + case DC_SIGCHAR_LONG: + { + long longValue; + switch(type_id) + { + case LGLSXP: longValue = (long) LOGICAL(arg)[0]; break; + case INTSXP: longValue = (long) INTEGER(arg)[0]; break; + case REALSXP: longValue = (long) REAL(arg)[0]; break; + case RAWSXP: longValue = (long) RAW(arg)[0]; break; + default: error("Argument type mismatch at position %d: expected C long convertable value", argpos); /* dummy */ return R_NilValue; + } + dcArgLong(pvm, longValue); + } + break; + case DC_SIGCHAR_ULONG: + { + unsigned long ulongValue; + switch(type_id) + { + case LGLSXP: ulongValue = (unsigned long) LOGICAL(arg)[0]; break; + case INTSXP: ulongValue = (unsigned long) INTEGER(arg)[0]; break; + case REALSXP: ulongValue = (unsigned long) REAL(arg)[0]; break; + case RAWSXP: ulongValue = (unsigned long) RAW(arg)[0]; break; + default: error("Argument type mismatch at position %d: expected C unsigned long convertable value", argpos); /* dummy */ return R_NilValue; + } + dcArgLong(pvm, (unsigned long) ulongValue); + } + break; + case DC_SIGCHAR_INT: + { + int intValue; + switch(type_id) + { + case LGLSXP: intValue = (int) LOGICAL(arg)[0]; break; + case INTSXP: intValue = INTEGER(arg)[0]; break; + case REALSXP: intValue = (int) REAL(arg)[0]; break; + case RAWSXP: intValue = (int) RAW(arg)[0]; break; + default: error("Argument type mismatch at position %d: expected C int convertable value", argpos); /*dummy*/ return R_NilValue; + } + dcArgInt(pvm, intValue); + } + break; + case DC_SIGCHAR_UINT: + { + unsigned int intValue; + switch(type_id) + { + case LGLSXP: intValue = (unsigned int) LOGICAL(arg)[0]; break; + case INTSXP: intValue = (unsigned int) INTEGER(arg)[0]; break; + case REALSXP: intValue = (unsigned int) REAL(arg)[0]; break; + case RAWSXP: intValue = (unsigned int) RAW(arg)[0]; break; + default: error("Argument type mismatch at position %d: expected C unsigned int convertable value", argpos); /* dummy */ return R_NilValue; + } + dcArgInt(pvm, * (int*) &intValue); + } + break; + case DC_SIGCHAR_FLOAT: + { + float floatValue; + switch(type_id) + { + case LGLSXP: floatValue = (float) LOGICAL(arg)[0]; break; + case INTSXP: floatValue = (float) INTEGER(arg)[0]; break; + case REALSXP: floatValue = (float) REAL(arg)[0]; break; + case RAWSXP: floatValue = (float) RAW(arg)[0]; break; + default: error("Argument type mismatch at position %d: expected C float convertable value", argpos); /* dummy */ return R_NilValue; + } + dcArgFloat( pvm, floatValue ); + } + break; + case DC_SIGCHAR_DOUBLE: + { + DCdouble doubleValue; + switch(type_id) + { + case LGLSXP: doubleValue = (double) LOGICAL(arg)[0]; break; + case INTSXP: doubleValue = (double) INTEGER(arg)[0]; break; + case REALSXP: doubleValue = REAL(arg)[0]; break; + case RAWSXP: doubleValue = (double) RAW(arg)[0]; break; + default: error("Argument type mismatch at position %d: expected C double convertable value", argpos); /* dummy */ return R_NilValue; + } + dcArgDouble( pvm, doubleValue ); + } + break; + case DC_SIGCHAR_LONGLONG: + { + DClonglong longlongValue; + switch(type_id) + { + case LGLSXP: longlongValue = (DClonglong) LOGICAL(arg)[0]; break; + case INTSXP: longlongValue = (DClonglong) INTEGER(arg)[0]; break; + case REALSXP: longlongValue = (DClonglong) REAL(arg)[0]; break; + case RAWSXP: longlongValue = (DClonglong) RAW(arg)[0]; break; + default: error("Argument type mismatch at position %d: expected C long long (int64_t) convertable value", argpos); /* dummy */ return R_NilValue; + } + dcArgLongLong( pvm, longlongValue ); + } + break; + case DC_SIGCHAR_ULONGLONG: + { + DCulonglong ulonglongValue; + switch(type_id) + { + case LGLSXP: ulonglongValue = (DCulonglong) LOGICAL(arg)[0]; break; + case INTSXP: ulonglongValue = (DCulonglong) INTEGER(arg)[0]; break; + case REALSXP: ulonglongValue = (DCulonglong) REAL(arg)[0]; break; + case RAWSXP: ulonglongValue = (DCulonglong) RAW(arg)[0]; break; + default: error("Argument type mismatch at position %d: expected C unsigned long long (uint64_t) convertable value", argpos); /* dummy */ return R_NilValue; + } + dcArgLongLong( pvm, *( (DClonglong*)&ulonglongValue ) ); + } + break; + case DC_SIGCHAR_POINTER: + { + DCpointer ptrValue; + switch(type_id) + { + case NILSXP: ptrValue = (DCpointer) 0; break; + case CHARSXP: ptrValue = (DCpointer) CHAR(arg); break; + case SYMSXP: ptrValue = (DCpointer) PRINTNAME(arg); break; + case STRSXP: ptrValue = (DCpointer) CHAR(STRING_ELT(arg,0)); break; + case LGLSXP: ptrValue = (DCpointer) LOGICAL(arg); break; + case INTSXP: ptrValue = (DCpointer) INTEGER(arg); break; + case REALSXP: ptrValue = (DCpointer) REAL(arg); break; + case CPLXSXP: ptrValue = (DCpointer) COMPLEX(arg); break; + case RAWSXP: ptrValue = (DCpointer) RAW(arg); break; + case EXTPTRSXP: ptrValue = R_ExternalPtrAddr(arg); break; + // case ENVSXP: ptrValue = (DCpointer) arg; break; + default: error("Argument type mismatch at position %d: expected C pointer convertable value", argpos); /* dummy */ return R_NilValue; + } + dcArgPointer(pvm, ptrValue); + } + break; + case DC_SIGCHAR_STRING: + { + DCpointer cstringValue; + switch(type_id) + { + case NILSXP: cstringValue = (DCpointer) 0; break; + case CHARSXP: cstringValue = (DCpointer) CHAR(arg); break; + case SYMSXP: cstringValue = (DCpointer) PRINTNAME(arg); break; + case STRSXP: cstringValue = (DCpointer) CHAR( STRING_ELT(arg,0) ); break; + case EXTPTRSXP: cstringValue = R_ExternalPtrAddr(arg); break; + default: error("Argument type mismatch at position %d: expected C string pointer convertable value", argpos); /* dummy */ return R_NilValue; + } + dcArgPointer(pvm, cstringValue); + } + break; + default: error("Signature type mismatch at position %d: Unknown token '%c' at argument %d.", ch, argpos); /* dummy */ return R_NilValue; + } + } else { /* ptrcnt > 0 */ + DCpointer ptrValue; + if (ch == '<') { /* typed high-level struct/union pointer */ + char const * e; + char const * b; + char const * n; + int l; + b = sig; + while( isalnum(*sig) || *sig == '_' ) sig++; + if (*sig != '>') { + error("Invalid signature '%s' - missing '>' marker for structure at argument %d.", signature, argpos); + return R_NilValue; /* Dummy */ + } + sig++; + /* check pointer type */ + if (type_id != NILSXP) { + SEXP structName = getAttrib(arg, install("struct")); + if (structName == R_NilValue) { + error("typed pointer needed here"); + return R_NilValue; /* Dummy */ + } + e = sig-1; + l = e - b; + n = CHAR(STRING_ELT(structName,0)); + if ( (strlen(n) != l) || (strncmp(b,n,l) != 0) ) { + error("incompatible pointer types"); + return R_NilValue; /* Dummy */ + } + } + switch(type_id) { + case NILSXP: ptrValue = (DCpointer) 0; break; + case EXTPTRSXP: ptrValue = R_ExternalPtrAddr(arg); break; + case RAWSXP: ptrValue = (DCpointer) RAW(arg); break; + default: error("internal error: typed-pointer can be external pointers or raw only."); + return R_NilValue; /* Dummy */ + } + dcArgPointer(pvm, ptrValue); + ptrcnt = 0; + } else { /* typed low-level pointers */ + switch(ch) { + case DC_SIGCHAR_VOID: + switch(type_id) + { + case NILSXP: ptrValue = (DCpointer) 0; break; + case STRSXP: ptrValue = (DCpointer) CHAR(STRING_ELT(arg,0)); break; + case LGLSXP: ptrValue = (DCpointer) LOGICAL(arg); break; + case INTSXP: ptrValue = (DCpointer) INTEGER(arg); break; + case REALSXP: ptrValue = (DCpointer) REAL(arg); break; + case CPLXSXP: ptrValue = (DCpointer) COMPLEX(arg); break; + case RAWSXP: ptrValue = (DCpointer) RAW(arg); break; + case EXTPTRSXP: ptrValue = R_ExternalPtrAddr(arg); break; + default: error("Argument type mismatch at position %d: expected pointer convertable value", argpos); + return R_NilValue; /* dummy */ + } + break; + case DC_SIGCHAR_CHAR: + case DC_SIGCHAR_UCHAR: + switch(type_id) + { + case NILSXP: ptrValue = (DCpointer) 0; break; + case STRSXP: + if (ptrcnt == 1) { + ptrValue = (DCpointer) CHAR( STRING_ELT(arg,0) ); + } else { + error("Argument type mismatch at position %d: expected 'C string' convertable value", argpos); + return R_NilValue; /* dummy */ + } + break; + case RAWSXP: + if (ptrcnt == 1) { + ptrValue = RAW(arg); + } else { + error("Argument type mismatch at position %d: expected 'C string' convertable value", argpos); + return R_NilValue; /* dummy */ + } + break; + case EXTPTRSXP: ptrValue = R_ExternalPtrAddr(arg); break; + default: + error("Argument type mismatch at position %d: expected 'C string' convertable value", argpos); + return R_NilValue; /* dummy */ + } + break; + case DC_SIGCHAR_USHORT: + case DC_SIGCHAR_SHORT: + error("Signature '*[sS]' not implemented"); + return R_NilValue; /* dummy */ + case DC_SIGCHAR_UINT: + case DC_SIGCHAR_INT: + switch(type_id) + { + case NILSXP: ptrValue = (DCpointer) 0; break; + case INTSXP: ptrValue = (DCpointer) INTEGER(arg); break; + default: error("Argument type mismatch at position %d: expected 'pointer to C integer' convertable value", argpos); + return R_NilValue; /* dummy */ + } + break; + case DC_SIGCHAR_ULONG: + case DC_SIGCHAR_LONG: + error("Signature '*[jJ]' not implemented"); + return R_NilValue; /* dummy */ + case DC_SIGCHAR_ULONGLONG: + case DC_SIGCHAR_LONGLONG: + error("Signature '*[lJ]' not implemented"); + return R_NilValue; /* dummy */ + case DC_SIGCHAR_FLOAT: + switch(type_id) + { + case NILSXP: ptrValue = (DCpointer) 0; break; + case RAWSXP: + if ( strcmp( CHAR(STRING_ELT(getAttrib(arg, install("class")),0)),"floatraw") == 0 ) { + ptrValue = (DCpointer) RAW(arg); + } else { + error("Argument type mismatch at position %d: expected 'pointer to C double' convertable value", argpos); + return R_NilValue; /* dummy */ + } + break; + default: error("Argument type mismatch at position %d: expected 'pointer to C double' convertable value", argpos); + return R_NilValue; /* dummy */ + } + break; + case DC_SIGCHAR_DOUBLE: + switch(type_id) + { + case NILSXP: ptrValue = (DCpointer) 0; break; + case REALSXP: ptrValue = (DCpointer) REAL(arg); break; + default: error("Argument type mismatch at position %d: expected 'pointer to C double' convertable value", argpos); + return R_NilValue; /* dummy */ + } + break; + case DC_SIGCHAR_POINTER: + case DC_SIGCHAR_STRING: + switch(type_id) + { + case EXTPTRSXP: + ptrValue = R_ExternalPtrAddr( arg ); break; + default: error("low-level typed pointer on pointer not implemented"); + return R_NilValue; /* dummy */ + } + break; + default: + error("low-level typed pointer on C char pointer not implemented"); + return R_NilValue; /* dummy */ + } + dcArgPointer(pvm, ptrValue); + ptrcnt = 0; + } + } + } + + + if (args != R_NilValue) { + error ("Too many arguments for signature '%s'.", signature); + return R_NilValue; /* dummy */ + } + /* process return type, invoke call and return R value */ + + switch(*sig++) { + case DC_SIGCHAR_BOOL: return ScalarLogical( ( dcCallBool(pvm, addr) == DC_FALSE ) ? FALSE : TRUE ); + + case DC_SIGCHAR_CHAR: return ScalarInteger( (int) dcCallChar(pvm, addr) ); + case DC_SIGCHAR_UCHAR: return ScalarInteger( (int) ( (unsigned char) dcCallChar(pvm, addr ) ) ); + + case DC_SIGCHAR_SHORT: return ScalarInteger( (int) dcCallShort(pvm,addr) ); + case DC_SIGCHAR_USHORT: return ScalarInteger( (int) ( (unsigned short) dcCallShort(pvm,addr) ) ); + + case DC_SIGCHAR_INT: return ScalarInteger( dcCallInt(pvm,addr) ); + case DC_SIGCHAR_UINT: return ScalarReal( (double) (unsigned int) dcCallInt(pvm, addr) ); + + case DC_SIGCHAR_LONG: return ScalarReal( (double) dcCallLong(pvm, addr) ); + case DC_SIGCHAR_ULONG: return ScalarReal( (double) ( (unsigned long) dcCallLong(pvm, addr) ) ); + + case DC_SIGCHAR_LONGLONG: return ScalarReal( (double) dcCallLongLong(pvm, addr) ); + case DC_SIGCHAR_ULONGLONG: return ScalarReal( (double) dcCallLongLong(pvm, addr) ); + + case DC_SIGCHAR_FLOAT: return ScalarReal( (double) dcCallFloat(pvm,addr) ); + case DC_SIGCHAR_DOUBLE: return ScalarReal( dcCallDouble(pvm,addr) ); + case DC_SIGCHAR_POINTER: return R_MakeExternalPtr( dcCallPointer(pvm,addr), R_NilValue, R_NilValue ); + case DC_SIGCHAR_STRING: return mkString( dcCallPointer(pvm, addr) ); + case DC_SIGCHAR_VOID: dcCallVoid(pvm,addr); /* TODO: return invisible */ return R_NilValue; + case '*': + { + SEXP ans; + ptrcnt = 1; + while (*sig == '*') { ptrcnt++; sig++; } + switch(*sig) { + case '<': { + /* struct/union pointers */ + PROTECT(ans = R_MakeExternalPtr( dcCallPointer(pvm, addr), R_NilValue, R_NilValue ) ); + char buf[128]; + const char* begin = ++sig; + const char* end = strchr(sig, '>'); + size_t n = end - begin; + strncpy(buf, begin, n); + buf[n] = '\0'; + setAttrib(ans, install("struct"), mkString(buf) ); + setAttrib(ans, install("class"), mkString("struct") ); + } break; + case 'C': + case 'c': { + PROTECT(ans = mkString( dcCallPointer(pvm, addr) ) ); + } break; + case 'v': { + PROTECT(ans = R_MakeExternalPtr( dcCallPointer(pvm, addr), R_NilValue, R_NilValue ) ); + } break; + default: error("Unsupported return type signature"); return R_NilValue; + } + UNPROTECT(1); + return(ans); + } + default: error("Unknown return type specification for signature '%s'.", signature); + return R_NilValue; /* dummy */ + } + +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/src/rdyncall_signature.h Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,14 @@ +#ifndef R_DYNCALL_H +#define R_DYNCALL_H + +/** =========================================================================== + ** R-Package: rdyncall + ** File: rdyncall/src/rdyncall_signature.h + ** Description: R additions to dyncall signatures + **/ + +#include "dyncall_signature.h" + +#define DC_SIGCHAR_SEXP 'x' + +#endif // R_DYNCALL_H
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/src/rdynload.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,71 @@ +/** =========================================================================== + ** R-Package: rdyncall + ** File: src/rdynload.c + ** Description: R bindings to dynload + **/ + +#include <Rinternals.h> +#include "dynload.h" + +/** --------------------------------------------------------------------------- + ** C-Function: r_dynload + ** Description: load shared library and return lib handle + ** R-Calling Convention: .Call + ** + **/ + +SEXP r_dynload(SEXP libpath_x) +{ + const char* libpath_S; + void* libHandle; + + libpath_S = CHAR(STRING_ELT(libpath_x,0)); + libHandle = dlLoadLibrary(libpath_S); + + if (!libHandle) + return R_NilValue; + + return R_MakeExternalPtr(libHandle, R_NilValue, R_NilValue); +} + +/** --------------------------------------------------------------------------- + ** C-Function: r_dynunload + ** Description: unload shared library + ** R-Calling Convention: .Call + ** + **/ + +SEXP r_dynunload(SEXP libobj_x) +{ + void* libHandle; + + if (TYPEOF(libobj_x) != EXTPTRSXP) error("first argument is not of type external ptr."); + + libHandle = R_ExternalPtrAddr(libobj_x); + + if (!libHandle) error("not a lib handle"); + + dlFreeLibrary( libHandle ); + + return R_NilValue; +} + +/** --------------------------------------------------------------------------- + ** C-Function: r_dynsym + ** Description: resolve symbol + ** R-Calling Convention: .Call + ** + **/ + +SEXP r_dynsym(SEXP libh, SEXP symname_x, SEXP protectlib) +{ + void* libHandle; + const char* symbol; + void* addr; + SEXP protect; + libHandle = R_ExternalPtrAddr(libh); + symbol = CHAR(STRING_ELT(symname_x,0) ); + addr = dlFindSymbol( libHandle, symbol ); + protect = (LOGICAL(protectlib)[0]) ? libh : R_NilValue; + return (addr) ? R_MakeExternalPtr(addr, R_NilValue, protect) : R_NilValue; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/src/rpack.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,336 @@ +/** =========================================================================== + ** R-Package: rdyncall + ** File: src/rpack.c + ** Description: (un-)packing of C structure data + ** TODO + ** - support for bitfields + **/ + +// #define USE_RINTERNALS +#include <Rinternals.h> +#include <string.h> +#include <stddef.h> +#include "rdyncall_signature.h" +/** --------------------------------------------------------------------------- + ** C-Function: r_dataptr + ** Description: retrieve the 'data' pointer on an R expression. + ** R-Calling Convention: .Call + ** + **/ + +static char* r_dataptr(SEXP x, SEXP off, size_t element_size) +{ + if ( LENGTH(off) == 0 ) error("missing offset"); + char* p = NULL; + ptrdiff_t o = INTEGER(off)[0], s = 0; + + switch(TYPEOF(x)) + { + case CHARSXP: p = (char*) CHAR(x); s = LENGTH(x)*sizeof(char); break; + case LGLSXP: p = (char*) LOGICAL(x); s = LENGTH(x)*sizeof(Rboolean); break; + case INTSXP: p = (char*) INTEGER(x); s = LENGTH(x)*sizeof(int); break; + case REALSXP: p = (char*) REAL(x); s = LENGTH(x)*sizeof(double); break; + case CPLXSXP: p = (char*) COMPLEX(x); s = LENGTH(x)*sizeof(Rcomplex); break; + case STRSXP: p = (char*) CHAR( STRING_ELT(x,0) ); s = strlen(p)*sizeof(char); break; + case RAWSXP: p = (char*) RAW(x); s = LENGTH(x)*sizeof(char); break; + case EXTPTRSXP: return (char*) R_ExternalPtrAddr(x) + o; break; + default: error("invalid object type"); break; + } + if (p == NULL) error("NULL address pointer"); + if (o < 0 || o+element_size > s) error("offset %d is out-of-bounds of the R object (max size %d)", o, s); + return p + o; +} + + + +/** --------------------------------------------------------------------------- + ** C-Function: r_pack + ** Description: pack R data type into a C data type + ** R-Calling Convention: .Call + ** + **/ +SEXP r_pack(SEXP ptr_x, SEXP offset, SEXP sig_x, SEXP value_x) +{ + int type_of = TYPEOF(value_x); + const char* sig = CHAR(STRING_ELT(sig_x,0) ); + switch(sig[0]) + { + case DC_SIGCHAR_BOOL: + { + int* Bp = (int*) r_dataptr(ptr_x, offset, sizeof(Rboolean)); + switch(type_of) + { + case LGLSXP: *Bp = (int) LOGICAL(value_x)[0]; break; + case INTSXP: *Bp = (int) ( INTEGER(value_x)[0] == 0) ? 0 : 1; break; + case REALSXP: *Bp = (int) ( REAL(value_x)[0] == 0.0) ? 0 : 1; break; + case RAWSXP: *Bp = (int) ( RAW(value_x)[0] == 0) ? 0 : 1; break; + default: error("value mismatch with 'B' pack type"); + } + } + break; + case DC_SIGCHAR_CHAR: + { + char* cp = (char*) r_dataptr(ptr_x, offset, sizeof(char)); + switch(type_of) + { + case LGLSXP: *cp = (char) LOGICAL(value_x)[0]; break; + case INTSXP: *cp = (char) INTEGER(value_x)[0]; break; + case REALSXP: *cp = (char) REAL(value_x)[0]; break; + case RAWSXP: *cp = (char) RAW(value_x)[0]; break; + default: error("value mismatch with 'c' pack type"); + } + } + break; + case DC_SIGCHAR_UCHAR: + { + unsigned char* cp = (unsigned char*) r_dataptr(ptr_x,offset,sizeof(unsigned char)); + switch(type_of) + { + case LGLSXP: *cp = (unsigned char) LOGICAL(value_x)[0]; break; + case INTSXP: *cp = (unsigned char) INTEGER(value_x)[0]; break; + case REALSXP: *cp = (unsigned char) REAL(value_x)[0]; break; + case RAWSXP: *cp = (unsigned char) RAW(value_x)[0]; break; + default: error("value mismatch with 'C' pack type"); + } + } + break; + case DC_SIGCHAR_SHORT: + { + short* sp = (short*) r_dataptr(ptr_x,offset,sizeof(short)); + switch(type_of) + { + case LGLSXP: *sp = (short) LOGICAL(value_x)[0]; break; + case INTSXP: *sp = (short) INTEGER(value_x)[0]; break; + case REALSXP: *sp = (short) REAL(value_x)[0]; break; + case RAWSXP: *sp = (short) RAW(value_x)[0]; break; + default: error("value mismatch with 's' pack type"); + } + } + break; + case DC_SIGCHAR_USHORT: + { + unsigned short* sp = (unsigned short*) r_dataptr(ptr_x,offset,sizeof(unsigned short)); + switch(type_of) + { + case LGLSXP: *sp = (unsigned short) LOGICAL(value_x)[0]; break; + case INTSXP: *sp = (unsigned short) INTEGER(value_x)[0]; break; + case REALSXP: *sp = (unsigned short) REAL(value_x)[0]; break; + case RAWSXP: *sp = (unsigned short) RAW(value_x)[0]; break; + default: error("value mismatch with 'S' pack type"); + } + } + break; + case DC_SIGCHAR_INT: + { + int* ip = (int*) r_dataptr(ptr_x,offset,sizeof(int)); + switch(type_of) + { + case LGLSXP: *ip = (int) LOGICAL(value_x)[0]; break; + case INTSXP: *ip = (int) INTEGER(value_x)[0]; break; + case REALSXP: *ip = (int) REAL(value_x)[0]; break; + case RAWSXP: *ip = (int) RAW(value_x)[0]; break; + default: error("value mismatch with 'i' pack type"); + } + } + break; + case DC_SIGCHAR_UINT: + { + unsigned int* ip = (unsigned int*) r_dataptr(ptr_x,offset,sizeof(unsigned int)); + switch(type_of) + { + case LGLSXP: *ip = (unsigned int) LOGICAL(value_x)[0]; break; + case INTSXP: *ip = (unsigned int) INTEGER(value_x)[0]; break; + case REALSXP: *ip = (unsigned int) REAL(value_x)[0]; break; + case RAWSXP: *ip = (unsigned int) RAW(value_x)[0]; break; + default: error("value mismatch with 'I' pack type"); + } + } + break; + case DC_SIGCHAR_LONG: + { + long* ip = (long*) r_dataptr(ptr_x,offset,sizeof(long)); + switch(type_of) + { + case LGLSXP: *ip = (long) LOGICAL(value_x)[0]; break; + case INTSXP: *ip = (long) INTEGER(value_x)[0]; break; + case REALSXP: *ip = (long) REAL(value_x)[0]; break; + case RAWSXP: *ip = (long) RAW(value_x)[0]; break; + default: error("value mismatch with 'j' pack type"); + } + } + break; + case DC_SIGCHAR_ULONG: + { + unsigned long* ip = (unsigned long*) r_dataptr(ptr_x,offset,sizeof(unsigned long)); + switch(type_of) + { + case LGLSXP: *ip = (unsigned long) LOGICAL(value_x)[0]; break; + case INTSXP: *ip = (unsigned long) INTEGER(value_x)[0]; break; + case REALSXP: *ip = (unsigned long) REAL(value_x)[0]; break; + case RAWSXP: *ip = (unsigned long) RAW(value_x)[0]; break; + default: error("value mismatch with 'J' pack type"); + } + } + break; + case DC_SIGCHAR_LONGLONG: + { + long long* Lp = (long long*) r_dataptr(ptr_x,offset,sizeof(long long)); + switch(type_of) + { + case LGLSXP: *Lp = (long long) LOGICAL(value_x)[0]; break; + case INTSXP: *Lp = (long long) INTEGER(value_x)[0]; break; + case REALSXP: *Lp = (long long) REAL(value_x)[0]; break; + case RAWSXP: *Lp = (long long) RAW(value_x)[0]; break; + default: error("value mismatch with 'l' pack type"); + } + } + break; + case DC_SIGCHAR_ULONGLONG: + { + unsigned long long* Lp = (unsigned long long*) r_dataptr(ptr_x,offset,sizeof(unsigned long long)); + switch(type_of) + { + case LGLSXP: *Lp = (unsigned long long) LOGICAL(value_x)[0]; break; + case INTSXP: *Lp = (unsigned long long) INTEGER(value_x)[0]; break; + case REALSXP: *Lp = (unsigned long long) REAL(value_x)[0]; break; + case RAWSXP: *Lp = (unsigned long long) RAW(value_x)[0]; break; + default: error("value mismatch with 'L' pack type"); + } + } + break; + case DC_SIGCHAR_FLOAT: + { + float* fp = (float*) r_dataptr(ptr_x,offset,sizeof(float)); + switch(type_of) + { + case LGLSXP: *fp = (float) LOGICAL(value_x)[0]; break; + case INTSXP: *fp = (float) INTEGER(value_x)[0]; break; + case REALSXP: *fp = (float) REAL(value_x)[0]; break; + case RAWSXP: *fp = (float) RAW(value_x)[0]; break; + default: error("value mismatch with 'f' pack type"); + } + } + break; + case DC_SIGCHAR_DOUBLE: + { + double* dp = (double*) r_dataptr(ptr_x,offset,sizeof(double)); + switch(type_of) + { + case LGLSXP: *dp = (double) LOGICAL(value_x)[0]; break; + case INTSXP: *dp = (double) INTEGER(value_x)[0]; break; + case REALSXP: *dp = (double) REAL(value_x)[0]; break; + case RAWSXP: *dp = (double) RAW(value_x)[0]; break; + default: error("value mismatch with 'd' pack type"); + } + } + break; + case DC_SIGCHAR_POINTER: + case '*': + { + void** pp = (void**) r_dataptr(ptr_x,offset,sizeof(void*)); + switch(type_of) + { + case NILSXP: *pp = (void*) 0; break; + case CHARSXP: *pp = (void*) CHAR(value_x); break; + case LGLSXP: *pp = (void*) LOGICAL(value_x); break; + case INTSXP: *pp = (void*) INTEGER(value_x); break; + case REALSXP: *pp = (void*) REAL(value_x); break; + case CPLXSXP: *pp = (void*) COMPLEX(value_x); break; + case STRSXP: *pp = (void*) CHAR( STRING_ELT(value_x,0) ); break; + case EXTPTRSXP:*pp = (void*) R_ExternalPtrAddr(value_x); break; + case RAWSXP: *pp = (void*) RAW(value_x); break; + default: error("value type mismatch with 'p' pack type"); + } + } + break; + case DC_SIGCHAR_STRING: + { + char** Sp = (char**) r_dataptr(ptr_x,offset,sizeof(char*)); + switch(type_of) + { + case NILSXP: *Sp = (char*) NULL; break; + case CHARSXP: *Sp = (char*) CHAR(value_x); break; + case STRSXP: *Sp = (char*) CHAR( STRING_ELT(value_x,0) ); break; + case EXTPTRSXP:*Sp = (char*) R_ExternalPtrAddr(value_x); break; + default: error("value type mismatch with 'Z' pack type"); + } + } + break; + case DC_SIGCHAR_SEXP: + { + SEXP* px = (SEXP*) r_dataptr(ptr_x,offset,sizeof(SEXP*)); + *px = value_x; + } + break; + default: error("invalid signature"); + } + return R_NilValue; +} + +/** --------------------------------------------------------------------------- + ** C-Function: r_unpack + ** Description: unpack elements from C-like structures to R values. + ** R-Calling Convention: .Call + ** + **/ +SEXP r_unpack(SEXP ptr_x, SEXP offset, SEXP sig_x) +{ + char* ptr = NULL; + const char* sig = CHAR(STRING_ELT(sig_x,0) ); + switch(sig[0]) + { + case DC_SIGCHAR_BOOL: + ptr = r_dataptr(ptr_x,offset,sizeof(Rboolean)); + return ScalarLogical( ((int*)ptr)[0] ); + case DC_SIGCHAR_CHAR: + ptr = r_dataptr(ptr_x,offset,sizeof(char)); + return ScalarInteger( ( (char*)ptr)[0] ); + case DC_SIGCHAR_UCHAR: + ptr = r_dataptr(ptr_x,offset,sizeof(unsigned char)); + return ScalarInteger( ( (unsigned char*)ptr)[0] ); + case DC_SIGCHAR_SHORT: + ptr = r_dataptr(ptr_x,offset,sizeof(short)); + return ScalarInteger( ( (short*)ptr)[0] ); + case DC_SIGCHAR_USHORT: + ptr = r_dataptr(ptr_x,offset,sizeof(unsigned short)); + return ScalarInteger( ( (unsigned short*)ptr)[0] ); + case DC_SIGCHAR_INT: + ptr = r_dataptr(ptr_x,offset,sizeof(int)); + return ScalarInteger( ( (int*)ptr )[0] ); + case DC_SIGCHAR_UINT: + ptr = r_dataptr(ptr_x,offset,sizeof(unsigned int)); + return ScalarReal( (double) ( (unsigned int*)ptr )[0] ); + case DC_SIGCHAR_LONG: + ptr = r_dataptr(ptr_x,offset,sizeof(long)); + return ScalarReal( (double) ( (long*)ptr )[0] ); + case DC_SIGCHAR_ULONG: + ptr = r_dataptr(ptr_x,offset,sizeof(unsigned long)); + return ScalarReal( (double) ( (unsigned long*) ptr )[0] ); + case DC_SIGCHAR_FLOAT: + ptr = r_dataptr(ptr_x,offset,sizeof(float)); + return ScalarReal( (double) ( (float*) ptr )[0] ); + case DC_SIGCHAR_DOUBLE: + ptr = r_dataptr(ptr_x,offset,sizeof(double)); + return ScalarReal( ((double*)ptr)[0] ); + case DC_SIGCHAR_LONGLONG: + ptr = r_dataptr(ptr_x,offset,sizeof(long long)); + return ScalarReal( (double) ( ((long long*)ptr)[0] ) ); + case DC_SIGCHAR_ULONGLONG: + ptr = r_dataptr(ptr_x,offset,sizeof(unsigned long long)); + return ScalarReal( (double) ( ((unsigned long long*)ptr)[0] ) ); + case '*': + case DC_SIGCHAR_POINTER: + ptr = r_dataptr(ptr_x,offset,sizeof(void*)); + return R_MakeExternalPtr( ((void**)ptr)[0] , R_NilValue, R_NilValue ); + case DC_SIGCHAR_STRING: { + ptr = r_dataptr(ptr_x,offset,sizeof(char*)); + char* s = ( (char**) ptr )[0]; + if (s == NULL) return R_MakeExternalPtr( 0, R_NilValue, R_NilValue ); + return mkString(s); + } + case DC_SIGCHAR_SEXP: + return (SEXP) ptr; + default: error("invalid signature"); + } + return R_NilValue; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/src/rpackage.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,101 @@ +/** =========================================================================== + ** R-Package: rdyncall + ** File: src/rpackage.c + ** Description: R package registry + **/ + +#include <Rinternals.h> +#include <R_ext/Rdynload.h> + +/** --------------------------------------------------------------------------- + ** Package contents: + */ + +/* rdyncall.c */ +SEXP r_new_callvm(SEXP callmode, SEXP size); +SEXP r_free_callvm(SEXP callvm); +SEXP r_dyncall(SEXP args); /* .External() with args = callvm, address, signature, args */ + +/* rdynload.c */ +SEXP r_dynload(SEXP libpath); +SEXP r_dynsym(SEXP libobj, SEXP symname, SEXP protectlib); +SEXP r_dynunload(SEXP libobj); + +/* rpack.c */ +SEXP r_pack(SEXP ptr, SEXP offset, SEXP sig, SEXP value); +SEXP r_unpack(SEXP ptr, SEXP offset, SEXP sig); + +/* rcallback.c */ +SEXP r_new_callback(SEXP sig, SEXP fun, SEXP rho, SEXP mode); + +/* rutils.c */ +SEXP r_asextptr(SEXP v); +SEXP r_isnullptr(SEXP x); +SEXP r_offsetPtr(SEXP x, SEXP offset); + +/* rutils_str.c */ +SEXP r_ptr2str(SEXP ptr); +SEXP r_strarrayptr(SEXP ptr); +SEXP r_strptr(SEXP x); + +/* rutils_float.c */ +SEXP r_as_floatraw(SEXP real); +SEXP r_floatraw2numeric(SEXP floatraw); + +/** --------------------------------------------------------------------------- + ** R Interface .External registry + */ + +R_ExternalMethodDef externalMethods[] = +{ + /* --- rdyncall.c -------------------------------------------------------- */ + {"dyncall", (DL_FUNC) &r_dyncall, -1}, + /* --- end (sentinel) ---------------------------------------------------- */ + {NULL,NULL,0} +}; + +/** --------------------------------------------------------------------------- + ** R Interface .Call registry + */ + +R_CallMethodDef callMethods[] = +{ + /* --- rdyncall.c -------------------------------------------------------- */ + {"new_callvm" , (DL_FUNC) &r_new_callvm , 2}, + {"free_callvm" , (DL_FUNC) &r_free_callvm , 1}, + /* --- rdynload.c -------------------------------------------------------- */ + {"dynload" , (DL_FUNC) &r_dynload , 1}, + {"dynsym" , (DL_FUNC) &r_dynsym , 3}, + {"dynunload" , (DL_FUNC) &r_dynunload , 1}, + /* --- rcallback.c ------------------------------------------------------- */ + {"new_callback" , (DL_FUNC) &r_new_callback , 3}, + /* --- rpack.c ----------------------------------------------------------- */ + {"pack" , (DL_FUNC) &r_pack , 4}, + {"unpack" , (DL_FUNC) &r_unpack , 3}, + /* --- rutils.c ---------------------------------------------------------- */ + {"asextptr" , (DL_FUNC) &r_asextptr , 1}, + {"isnullptr" , (DL_FUNC) &r_isnullptr , 1}, + {"offsetPtr" , (DL_FUNC) &r_offsetPtr , 2}, + /* --- rutils_str.c ------------------------------------------------------ */ + {"r_ptr2str" , (DL_FUNC) &r_ptr2str , 1}, + {"r_strarrayptr" , (DL_FUNC) &r_strarrayptr , 1}, + {"r_strptr" , (DL_FUNC) &r_strptr , 1}, + /* --- rutils_float.c ---------------------------------------------------- */ + {"r_as_floatraw" , (DL_FUNC) &r_as_floatraw , 1}, + {"r_floatraw2numeric" , (DL_FUNC) &r_floatraw2numeric , 1}, + /* --- end (sentinel) ---------------------------------------------------- */ + {NULL,NULL, 0} +}; + +/** --------------------------------------------------------------------------- + ** R Library entry: + */ + +void R_init_rdyncall(DllInfo *info) +{ + R_registerRoutines(info, NULL, callMethods, NULL, externalMethods); +} + +void R_unload_rdyncall(DllInfo *info) +{ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/src/rutils.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,40 @@ +/** =========================================================================== + ** R-Package: rdyncall + ** File: src/rutils.c + ** Description: misc utility functions to work with low-level data structures in R + **/ + +// uses: DATAPTR macro +#define USE_RINTERNALS +#include <Rinternals.h> +#include <stddef.h> + +SEXP r_isnullptr(SEXP x) +{ + return ScalarLogical( ( R_ExternalPtrAddr(x) == NULL ) ? TRUE : FALSE ); +} + +SEXP r_asextptr(SEXP x) +{ + if (isVector(x)) { + return R_MakeExternalPtr( DATAPTR(x), R_NilValue, x ); + } + error("expected a vector type"); + return R_NilValue; /* dummy */ +} + +SEXP r_offsetPtr(SEXP x, SEXP offset) +{ + if ( LENGTH(offset) == 0 ) error("offset is missing"); + ptrdiff_t offsetval = INTEGER(offset)[0]; + unsigned char* ptr = 0; + if (isVector(x)) { + ptr = (unsigned char*) DATAPTR(x); + } else if (TYPEOF(x) == EXTPTRSXP ) { + ptr = (unsigned char*) R_ExternalPtrAddr(x); + } else { + error("unsupported type"); + } + return R_MakeExternalPtr( ptr + offsetval , R_NilValue, x ); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/src/rutils_float.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,61 @@ +/** =========================================================================== + ** R-Package: rdyncall + ** File: src/rutils_float.c + ** Description: Utility functions for handling C float data types. + **/ + +#define USE_RINTERNALS +#include <Rdefines.h> +#include <Rinternals.h> +#include <R_ext/RS.h> + +/* Float utils */ + +SEXP r_as_floatraw(SEXP x) +{ + SEXP ans; + int i, n; + double *dp; + float *fp; + + dp = (double*) REAL(x); + + n = LENGTH(x); + if (n < 1) { + error("length of x should be >= 1"); + return R_NilValue; + } + + ans = PROTECT( Rf_allocVector(RAWSXP, sizeof(float)*n) ); + + fp = (float*) RAW(ans); + + for(i = 0 ; i < n ; ++i ) + fp[i] = (float) dp[i]; + + UNPROTECT(1); + return ans; +} + +SEXP r_floatraw2numeric(SEXP x) +{ + SEXP ans; + int i, n; + float *fp; + double *dp; + + fp = (float*) RAW(x); + + n = LENGTH(x) / sizeof(float); + ans = PROTECT( Rf_allocVector(REALSXP, n) ); + + dp = (double*) REAL(ans); + + for(i = 0 ; i < n ; ++i ) + dp[i] = (double) fp[i]; + + UNPROTECT(1); + return ans; + +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/src/rutils_str.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,53 @@ +/** =========================================================================== + ** R-Package: rdyncall + ** File: src/rutils_str.c + ** Description: Support functions for handling C string data types. + **/ + +#define USE_RINTERNALS +#include <Rdefines.h> +#include <Rinternals.h> +#include <R_ext/RS.h> + +/* String utils */ + +SEXP r_ptr2str(SEXP extptr) +{ + void* addr = R_ExternalPtrAddr(extptr); + if (addr == NULL) { + return R_NilValue; + } + return mkString(addr); +} + +SEXP r_strptr(SEXP x) +{ + return R_MakeExternalPtr( (void*) CHAR(STRING_ELT(x, 0)), R_NilValue, x ); +} + +void do_free(SEXP x) +{ + void* addr = R_ExternalPtrAddr(x); + R_Free(addr); +} + +SEXP r_strarrayptr(SEXP s) +{ + int i; + int n; + const char ** ptrs; + + n = LENGTH(s); + + // allocate array + ptrs = R_Calloc(n, const char*); + + // copy cstring pointers into array + for( i=0 ; i<n ; ++i ) ptrs[i] = CHAR( STRING_ELT(s, i) ); + + // create external pointer pointing to array + SEXP x = PROTECT( R_MakeExternalPtr( ptrs, R_NilValue, s ) ); + R_RegisterCFinalizerEx( x, do_free, TRUE ); + UNPROTECT(1); + return x; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/tools/bootstrap Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,36 @@ +download_zip() +{ + VERSION=0.6 + NAME=dyncall-${VERSION} + ZIP=${NAME}.zip + wget http://dyncall.org/r${VERSION}/${ZIP} + unzip ${ZIP} + mv ${NAME} src/dyncall + rm ${ZIP} +} + +checkout_src() +{ + svn co https://dyncall.org/svn/dyncall/trunk/dyncall src/dyncall + svnversion src/dyncall >src/dyncall/SVNVERSION +} + +configure_dyncall() +{ +cat <<EOF >src/dyncall/ConfigVars +#auto-generated by dyncall/configure +CONFIG_PACKAGE=dyncall +CONFIG_ARCH=universal +CONFIG_TOOL=gcc +CONFIG_ASM=gcc +CONFIG_CONFIG=release +CONFIG_BUILDPREFIX=. +EOF +} + +# choose between 'checkout_src' or 'download_zip' + +checkout_src +# download_zip +# configure_dyncall +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/vignettes/FLI.Rnw Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,1187 @@ +\documentclass[11pt]{article} +\usepackage[round]{natbib} +\usepackage{hyperref} +\usepackage{amsmath} +\usepackage{fancyvrb} +\usepackage{verbatim} +\usepackage{alltt,graphicx} +\usepackage{fullpage} +\bibliographystyle{abbrvnat} +\newcommand{\file}[1]{{`\normalfont\textsf{#1}'}} +\newcommand{\strong}[1]{\texorpdfstring% +{{\normalfont\fontseries{b}\selectfont #1}}% +{#1}} +\let\pkg=\strong +\newcommand\code{\bgroup\@codex} +\def\@codex#1{\texorpdfstring% +{{\normalfont\ttfamily\hyphenchar\font=-1 #1}}% +{#1}\egroup} +\newenvironment{smallverbatim}{\small\verbatim}{\endverbatim} +\newenvironment{example}{\begin{alltt}}{\end{alltt}} +\newenvironment{smallexample}{\begin{alltt}\small}{\end{alltt}} + +\begin{document} + + +\title{Foreign Library Interface} +%\VignetteIndexEntry{Foreign Library Interface} +\author{by Daniel Adler} +\maketitle +\abstract{ +We present an improved Foreign Function Interface (FFI) for R to +call arbitary native functions without the need for C wrapper code. +Further we discuss a dynamic linkage +framework for binding standard C libraries to R across platforms using a +universal type information format. +The package \pkg{rdyncall} comprises the framework +and an initial repository of cross-platform bindings for standard libraries such as +(legacy and modern) \emph{OpenGL}, the family of \emph{SDL} libraries and \emph{Expat}. +The package enables system-level programming using the R language; +sample applications are given in the article. +We outline the underlying automation tool-chain that extracts +cross-platform bindings from C headers, making the +repository extendable and open for library developers. +} +\section{Introduction} + +\begin{table*} +\centering +\label{tab:libs} +\begin{tabular}{l|l|c|c|c} +lib/dynport & description & functions & constants & aggregate types \\ +\hline +\code{gl} & opengl & 337 & 3253 & - \\ +\code{glu} & opengl utility & 59 & 154 & - \\ +\code{r} & r library & 238 & 700 & 27 \\ +\code{sdl} & audio/video/ui abstraction & 203 & 465 & 51 \\ +\code{sdl\_image} & pixel format loaders & 29 & - & - \\ +\code{sdl\_mixer} & music format loaders and playing & 63 & 12 & - \\ +\code{sdl\_ttf} & font format loaders & 35 & 9 & - \\ +\code{cuda} & gpu programming & 387 & 665 & 84 \\ +\code{expat} & xml parsing framework & 65 & 70 & - \\ +\code{glew} & gl extensions & 1465 & - & - \\ +\code{gl3} & opengl 3 (strict) & 324 & 838 & 1 \\ +\code{opencl} & gpu programming & 78 & 260 & 10 \\ +\code{stdio} & standard i/o & 76 & 3 & - \\ +\end{tabular} +\caption{overview of available dynports for portable c libraries} +\end{table*} + +We present an improved Foreign Function Interface (FFI) for R that +significantly reduces the amount of C wrapper code needed to interface with C. +We also introduce a \emph{dynamic} linkage that binds the C +interface of a pre-compiled library (\emph{as a whole}) to an +interpreted programming environment \citep{Oust97a} such as R - hence th name +\emph{Foreign Library Interface}. Table 1 gives a list +of the C libraries currently supported across major R platforms. +For each library supported, abstract interface specifications are declared +in a compact platform-neutral text-based format stored in so-called +\emph{DynPort} files on a local repository. + +%between high-level interpreted programming environments +%and native pre-compiled C libraries that uses a compact text-based +%interface and type information format that makes this method work across platforms. + +R \citep{R:Ihaka+Gentleman:1996} was choosen as the first language +to implement a proof-of-concept implementation for this approach. +This article describes the \pkg{rdyncall} package which +implements a complete toolkit of low-level facilities that can be used as an +alternative FFI to interface with the C programming language. +And further, it enables direct and quick access to +the common C libraries from R without compilation. + +The project was motivated by the fact that +high-quality software solutions implemented in portable C +are often not available in interpreter-based languages such as R. +The pool of freely available C libraries is quite large and +represents an invaluable resource for software development. +For example, OpenGL \citep{Board05} is the most portable and standard interface to +accelerated graphics hardware for developing real-time graphics software. +The combination of OpenGL with the \emph{Simple DirectMedia Layer} (SDL) \citep{SDL} +core and extension libraries offers a foundation framework for +developing interactive multimedia applications that can run on a +multitude of platforms. +Other libraries such as the Expat XML Parser \citep{www:expat} provide a parser framework +for processing very large XML documents. +And even the C library of R contains high-quality statistical +functions that are useful in context of other languages as well. + +To make use of these libraries within high-level languages, \emph{language bindings} +to the library must be written as an extension to the language, a task that +requires deep familiarity of the internals of both the library and the interpreter. +Depending on the complexity of the library, the amount of work needed to wrap +the interface can be very large (Table \ref{tab:libs} gives the counts of +functions, constants and types that need to be wrapped). +Rather than having to write a separate binding for each \emph{library and language} +combination, we research a dynamic binding approach that +is adaptable to interpreters and works cross-platform without additional +compilation of wrapper layers. +Once the binding specification for a library has been specified, that +library becomes automatically accessible to all interpreters that +implement such a framework outlined here. +Extension techniques offered by the language interpreter, such as a +\emph{Foreign Function Interface} (FFI), are the fundamental technology +for bridging the dynamic interpreter with statically pre-compiled code. + +In the case of R the built-in FFI function \code{.C} provides a fairly +basic call gate to C code with strong limitations; additional wrapper code has +to be written in addition to interface with standard C libraries. +\pkg{rdyncall} contributes an improved FFI for R that offers a \emph{flexible} +and \emph{type-safe} interface with support for almost all C types without +requiring additional C wrappers. + +Based on this FFI, the package contains a proof-of-concept implementation of a \emph{Foreign Library Interface} that enables +\emph{direct} and \emph{dynamic} interoperability with foreign C Libraries +(including shared library code and the Application Programming Interface +specified in C headers) from within the R interpreter. +For each C library supported, abstract interface specification are declared in a +compact platform-neutral text-based format stored in a so-called \emph{DynPort} file +located in a local repository within the package. +Table \ref{tab:libs} gives a sample list of available bindings that come with the package. + +Users gain access to C libraries from R using the front-end function \code{dynport(}\emph{portname}\code{)}, +which processes a \emph{DynPort} file to load the C library\footnote{Pre-compiled libraries need to be installed, OS-specific installation notes are given in the documentation of the package.}, +and wrap the C interface as a newly attached R environment +\footnote{Note \pkg{rdyncall} version 0.7.4 and below uses R name space objects \citep{RNameSpace} as dynport containers. This has changed starting with version 0.7.5 due to restrictions for packages hosted on CRAN not to use internal functions. Since there is no public interface for the creation of name space objects currently in R, \pkg{rdyncall} uses ordinary environment objects for now. +This disables the use of the double colon operator (\code{::}) to refer to dynport objects; unloading is done using \code{detach(dynport:<PORTNAME>)}.} +that uses the same symbolic names of the C API. +R code that uses C interfaces via \emph{DynPort}s might look very familiar to C user code. + +This article motivates the topic with a comparison of the built-in and +contributed FFI by means of a simple use case. This leads to a detailed description of the improved FFI. +Then follows an overview of the package and a brief tour through the framework +with details on the handling of foreign C data types and wrapping R functions as callbacks. +Two sample applications are given using OpenGL, SDL and Expat. +The article ends with a brief description of the implementation based on C libraries from the \emph{DynCall} project \citep{dyncall} +and the tool-chain that was used to create the repository of \emph{DynPort} files. + +\section{Foreign Function Interfaces} + +FFIs provide the backbone of a language to interface with foreign code. +Depending on the design of this service, +it can largely unburden developers from writing additional wrapper code. +In this section, we compare the built-in FFI with the improved +FFI provided by \pkg{rdyncall} using a simple example that sketches +the different work flow paths for making an R binding to a function +from a foreign C library. + +\subsection{FFI of base R} + +Suppose that we wish to invoke the C function \code{sqrt} of the +C Standard Math library. The function is declared as follows in C: +\begin{verbatim} +double sqrt(double x); +\end{verbatim} + +R offers a number of functions to call pre-compiled code from +within the R interpreter. While \code{.Call} and \code{.External} +are designed for interoperability with \emph{extension} code, \code{.C} +and \code{.Fortran} seem to offer the most low-level interoperability with +\emph{foreign} code. +But \code{.C} has also very strict conversion rules and strong limitations +regarding argument and return-types: +\code{.C} passes R arguments as C pointers and +C return types are not supported, so only C \code{void} functions, +which are procedures, can be called. +Given these limitations, we are not able to invoke the foreign +\code{sqrt} function directly and need some intermediate wrapper code +written in C that obeys the rules of the \code{.C} interface: + +\begin{smallverbatim} +#include <math.h> +void R_C_sqrt(double * ptr_to_x) +{ + double x = ptr_to_x[0], ans; + ans = sqrt(x); + ptr_to_x[0] = ans; +} +\end{smallverbatim} + + +We assume that the wrapper code is deployed as a shared library +in a package named \emph{testsqrt} which links to the C math library. +\footnote{We omit here the details such as registering C functions which is +described in detail in the R Manual '\emph{Writing R Extensions}' \citep{RExt}.}. +Then we load the \emph{testsqrt} package and call the C wrapper function directly +via \code{.C}. + +\begin{example} +> library(testsqrt) +> .C("R_C_sqrt", 144, PACKAGE="testsqrt") +[[1]] +[1] 12 +\end{example} + +To make \code{sqrt} available as a public function, an additional +R wrapper layer is added, that does type-safety checks before +issuing the \code{.C} call. + +\begin{smallverbatim} +sqrtViaC <- function(x) +{ + x <- as.numeric(x) # type(x) should be C double. + # make sure length > 0: + length(x) <- max(1, length(x)) + .C("R_C_sqrt", x, PACKAGE="example") +} +\end{smallverbatim} + +As an alternative, R also provides high-level C extension interfaces +such as \code{.Call} and \code{.External}, that give access to R internals +at C level and enable to make type-safety checks within C: + +\begin{smallverbatim} +#include <R.h> +#include <Rinternals.h> +#include <math.h> +SEXP R_Call_sqrt(SEXP x) +{ + SEXP ans = R_NilValue, tmp; + PROTECT( tmp = coerceVector(x, REALSXP) ); + if (LENGTH(tmp) > 0) { + double y = REAL(tmp)[0], result; + result = sqrt(y); + ans = ScalarReal(result); + } + UNPROTECT(1); + return ans; +} +\end{smallverbatim} + +Now the corresponding R wrapper shrinks into a simple delegate: + +\begin{example} +> sqrtViaCall <- function(x) ++ .Call("R_Call_sqrt", x, PACKAGE="example") +\end{example} + +The third alternative, via \code{.External}, is omitted here; +it has a different argument passing scheme, but the C and R wrapper +implementations would look very similar. + +We can conclude that - in realistic settings - the built-in FFI of R +almost always needs support by a wrapper layer written in C. +The "foreign" in FFI is in fact relegated to the C wrapper layer. + +Moreover the R FFI can be viewed as an \emph{extension} interface for +calling pre-compiled code written in a \emph{foreign} language within +the context of the R implementation, rather than a direct invocation +interface for code from a \emph{foreign} context such as an +ordinary C library. + +\subsection{FFI of rdyncall} + +\begin{table*} +\begin{center} +\begin{tabular}{ll|ll} +\hline \hline +Type& Sign. & Type & Sign. \\ +\hline +\verb@void@ & \verb@v@ & \verb@bool@ & \verb@B@ \\ +\verb@char@ & \verb@c@ & \verb@unsigned char@ & \verb@C@ \\ +\verb@short@ & \verb@s@ & \verb@unsigned short@ & \verb@S@ \\ +\verb@int@ & \verb@i@ & \verb@unsigned int@ & \verb@I@ \\ +\verb@long@ & \verb@j@ & \verb@unsigned long@ & \verb@J@ \\ +\verb@long long@ & \verb@l@ & \verb@unsigned long long@ & \verb@L@ \\ +\verb@float@ & \verb@f@ & \verb@double@ & \verb@d@ \\ +\verb@void*@ & \verb@p@ & \verb@struct@ \emph{name} \verb@*@ & \verb@*<@\emph{name}\verb@>@ \\ +\emph{type}\verb@*@ & \verb@*@... & \verb@const char*@ & \verb@Z@ \\ +\hline \hline +\end{tabular} +\end{center} +\caption{\label{tab:signature} C/C++ Types and Signatures} +\end{table*} + +\pkg{rdyncall} provides an improved FFI for R +that is accessible via the function \code{.dyncall}. +In contrast to the built-in R FFI which uses a C wrapper layer, +the \code{sqrt} function is invoked dynamically and directly +by the interpreter at run-time. +Whereas the C math library was loaded implicitly via the +example package, it now has to be loaded explicitly. + +R offers functions to deal with shared libraries at run-time, +but the location has to be specified as an absolute pathname which +is platform-specific. +For now, let us assume that the example is done on +Mac OS X where the C math library is located +at \file{/usr/lib/libm.dylib}. A platform-portable solution +is discussed in the next section on \emph{Portable loading of shared library}. + +\begin{example} +> libm <- dyn.load("/usr/lib/libm.dylib") +> sqrtAddr <- libm$sqrt$address +\end{example} + +We first need to load the R package \pkg{rdyncall}: + +\begin{example} +> library(rdyncall) +\end{example} + +Finally, we invoke the foreign C function \code{sqrt} \emph{directly} via +\code{.dyncall}: + +\begin{example} +> .dyncall(sqrtAddr, "d)d", 144) +[1] 12 +\end{example} + +Let us review the last call, as it pinpoints the core solution for a direct +invocation of foreign code within R: +The first argument specifies the address of the foreign code, given as an +external pointer. +The second argument is a \emph{call signature} +that specifies the argument- and return types of the target C function. +This string \verb@"d)d"@ specifies that the foreign function +expects a \code{double} scalar argument and returns a \code{double} scalar value +in correspondence to the C declaration of \code{sqrt}. +Arguments following the call signature are passed to the +foreign function using the call signature for type-safe conversion to C types. +In this case we pass \code{144} as a C \code{double} argument type as first +argument and receive a C \code{double} value converted to an R \code{numeric}. + +\subsection{Call Signatures} + +The introduction of a type descriptor for foreign functions is a key +component that makes the FFI flexible and type-safe. +The format of the call signature has the following pattern: + +\begin{center} +\emph{argument-types} \verb@')'@ \emph{return-type} +\end{center} + +The signature can be derived from the C function declaration: +Argument types are specified first, in a left-to-right order, and are +terminated by the \verb@')'@ symbol followed by a single return type signature. + +Almost all fundamental C types are supported and there is no real +restriction regarding the number of arguments supported to issue +a call. +Table \ref{tab:signature} gives an overview of supported C types and +the corresponding text encoding; Table \ref{tab:signature_examples} +provides some examples of C functions and call signatures. + +\begin{table*} +\center +\begin{tabular}{l|l} +C function declaration & dyncall type signature \\ +\hline +\verb@void rsort_with_index(double*,int*,int n)@ & \verb@*d*ii)v@ \\ +\verb@SDL_Surface * SDL_SetVideoMode(int,int,int,Uint32_t)@ & \verb@iiiI)*<SDL_Surface>@ \\ +\verb@void glClear(GLfloat,GLfloat,GLfloat,GLfloat)@ & \verb@ffff)v@ \\ +\end{tabular} +\caption{\label{tab:signature_examples} +Some examples of C functions and corresponding signatures} +\end{table*} + +Now, let us define a public and type-safe R wrapper function that +hides the details of the foreign function call by passing the formal +argument place holder "\code{...}" as third argument to \code{.dyncall}: + +\begin{example} +> sqrtViaDynCall <- function(...) ++ .dyncall(sqrtAddress, "d)d", ...) +\end{example} + +Although there is no further guard code, this interface is type-safe and +the user can do no harm by inadvertently using a wrong set and/or type +of arguments due to the built-in type-checks. +Compared to the R wrapper code using \code{.C}, no explicit cast of the +arguments via \code{as.numeric} is required, because +automatic coercion rules for fundamental types are implemented as dictated +by the call signature. For example, \code{integer} R values are +implicitly casted to \code{double} automatically: + +\begin{smallverbatim} +> sqrtViaDyncall(144L) +[1] 12 +\end{smallverbatim} + +A certain level of type-safety is achieved here as well: +All arguments to be passed to C are first checked against the call signature. +If any incompatibility is detected, such as a wrong number of arguments, +empty atomic vectors or incompatible type mappings, the invocation is aborted +and an error is reported before risking an application crash: + +\begin{smallverbatim} +> sqrtViaDyncall(1,2) +Error in .dyncall(sqrtAddress, "d)d", ...) : + Too many arguments for signature 'd)d'. +> sqrtViaDyncall() +Error in .dyncall(sqrtAddress, "d)d", ...) : + Not enough arguments + for function-call signature 'd)d'. +> sqrtViaDyncall(NULL) +Error in .dyncall(sqrtAddress, "d)d", ...) : + Argument type mismatch at position 1: + expected double convertible value +> sqrtViaDyncall("144") +Error in .dyncall(sqrtAddress, "d)d", ...) : + Argument type mismatch at position 1: + expected double convertible value +\end{smallverbatim} + +In contrast to the R FFI, where the argument conversion is +dictated solely by the R argument type at call-time in a one-way fashion, +the introduction of an additional specification with a call signature gives +several advantages. + +\begin{itemize} +\item Almost all possible C functions can be invoked by a single interface; +no additional C wrapper is required. +\item The built-in type-safety checks of passed arguments enhance stability +and reduce assertion code in R wrappers significantly. +\item A single call signature can work across platforms, +given that the C function type remains constant across platforms. +\item Given that our FFI is implemented in multiple languages, +call signatures represent a portable type description for C libraries. +\end{itemize} + +\section{Package Overview} + +Besides dynamic calling of foreign code, the package provides essential +facilities for interoperability between the R and C programming languages. +A high-level overview of components that make up the +package is given in Figure \ref{fig:pkg_overview}. + +\begin{figure}[h] +\centering +\includegraphics[scale=0.44]{img_overview.pdf} +\caption{\label{fig:pkg_overview} +Package Overview} +\end{figure} + +We already described the \code{.dyncall} FFI. It follows a +brief description of portable loading of +shared libraries using \code{dynfind}, installation of wrappers via \code{dynbind}, +handling of foreign data types via \code{new.struct} and wrapping of R functions as C callbacks via \code{new.callback}. +Finally the high-level \code{dynport} interface for accessing \emph{whole} C libraries is briefly discussed. +The technical details at low-level of some components are described briefly in the +section \emph{Architecture}. + +\subsection{Portable loading of shared libraries} + +The \emph{portable} loading of shared libraries across platforms is not +trivial because the file path is different in Operating-Systems (OS). +Referring back to the previous example, to load a particular library +in a portable fashion, one would have to check the platform to +locate the C library.\footnote{Possible C math library names are \file{libm.so}, \file{libm.so.6} and \file{MSVCRT.DLL} +in locations such as \file{/lib}, \file{/usr/lib}, \file{/lib64}, \file{/lib/sparcv9}, \file{/usr/lib64}, \file{C:\textbackslash WINDOWS\textbackslash SYSTEM32} etc..} + +Although there is variation among the OSs, library file paths and +search patterns have common structures. +For example, among +all the different locations, prefixes and suffixes, there is a part within +a full library filename that can be taken as a \emph{short library name} or +label. + +The function \code{dynfind} takes a list of short library names to +locate a library using common search heuristics. +For example, to load the Standard C Math library, one would either use +the Microsoft Visual C Run-Time library labeled \file{msvcrt} on Windows +or the C Math library labeled \file{m} or \file{m.so.6} otherwise. + +\begin{example} +> mLib <- dynfind(c("msvcrt","m","m.so.6")) +\end{example} + +\code{dynfind} also supports more exotic schemes, such as the Mac OS X Framework folders. +Depending on the library, +it is sometimes enough to have a single short filename - e.g. \code{"expat"} for +the \emph{Expat} library. + +Internally, the dynamic linker interface of the OS is used via +\code{.dynload} and symbols get resolved via \code{.dynsym}: + +\begin{example} +> sqrtAddr <- .dynsym(mLib, "sqrt") +\end{example} + +Although R already contains support for loading shared libraries +and resolving of symbols, several issues have led to a reimplementation +of this part: + +\begin{itemize} +\item System paths are not considered when loading libraries via +\code{dyn.load} of the package \pkg{base} but this is one part of the +search heuristics. +\item Automatic life-cycle management for loading and unloading of libraries +is a desired goal. Unloading of libraries should be done automatically +via finalizer code when no symbols are used anymore. External pointers +resolved via \code{.dynsym} hold a reference to the loaded library. +When all external pointers are garbage collected, the library handle is +not referenced anymore and the finalizer can unload the library. +\end{itemize} + +\subsection{Wrapping C libraries} + +Functional R interfaces to foreign code can be defined with small +R wrapper functions, which effectively delegates to \code{.dyncall}. +Each function interface is parameterized by a target address and +a matching call signature. + +Since APIs often consist of hundreds of functions (see Table \ref{tab:libs}), +\code{dynbind} can create and install a batch of function wrappers for a library +with a single call by using a \emph{library signature} that +consists of concatenated function names and signatures separated by semicolons. + +For example, to install wrappers to the C functions +\code{sqrt}, \code{sin} and \code{cos} from the math library, one +could use: + +\begin{example} +> dynbind( c("msvcrt","m","m.so.6"), ++ "sqrt(d)d;sin(d)d);cos(d)d;" ) +\end{example} + +The function call has the side-effect that three R wrapper functions are +created and stored in an environment which defaults to the global environment. +Let us review the \code{sin} wrapper (on the 64-bit Version of R running +on Mac OS X 10.6): +\begin{example} +> sin +function (...) +.dyncall.default(<pointer: 0x7fff81fd13f0>, + "d)d)", ...) +\end{example} + +The wrapper directly uses the address of the resolved \code{sin} symbol. +In addition, the wrappers uses \code{.dyncall.default}, which is a +concrete selector of a particular calling convention, as outlined below. + +\subsection{Calling Conventions} + +Calling conventions specify how arguments and return values are passed +across sub-routines and functions at machine level. This information +is vital for interfacing with the binary interface of C libraries. +The package has support for multiple calling conventions. +Calling conventions are controlled by \code{.dyncall} via the named argument +\code{callmode} to specify a non-default calling convention. +Most current OSs and platforms only have support for a single \code{"default"} calling convention +at run-time. + +An important exception is the Microsoft Windows platform +on the 32-bit \emph{i386} processor architecture: +While the default C calling convention on \emph{i386} is \code{"cdecl"} (which is the \code{"default"} on \emph{i386}), +system shared libraries from Microsoft such as \file{KERNEL32.DLL}, +\file{USER32.DLL} and the OpenGL library \file{OPENGL32.DLL} +use the \code{"stdcall"} calling convention. +Only on this platform, the \code{callmode} argument has an effect and +selects the calling convention to be used when working on Microsoft Windows 32-Bit. +All other platforms currently ignore this argument. + +\subsection{Handling of C Types in R} + +C APIs often make use of high-level C \verb@struct@ +and \verb@union@ types for exchanging information. +Thus, to make interoperability work at that level the handling of C +type information is addressed by the package. + +Let us consider the following hypothetical example: +A user-interface library has a function to set the 2D coordinates +and dimension of a graphical output window. The coordinates are specified using a C +\code{struct Rect} data type and the C function receives a +pointer on that object: + +\begin{smallverbatim} +void setWindowRect(struct Rect *pRect); +\end{smallverbatim} + +The structure type is defined as follows: + +\begin{smallverbatim} +struct Rect { + short x, y; + unsigned short w, h; +}; +\end{smallverbatim} + +Before we can issue a call, we have to allocate an object of that size and +initialize the fields with values encoded in C types, which are not +part of R data types. +The framework provides helper functions and objects to deal with C data types +in R. Type information objects can be created with a description of the +C aggregate structure. +First, we create a type information object in R for the \code{struct Rect} +C data type via \code{parseStructInfos} using a \emph{structure type signature}. + +\begin{smallverbatim} +> parserStructInfos("Rect{ssSS}x y w h;") +\end{smallverbatim} + +After registration, an R object named \code{Rect} is installed, which +contains C type information that corresponds to \code{struct Rect}. +The format of a \emph{structure type signature} has the following +pattern: + +\begin{center} +\emph{Struct-name} \verb@'{'@ \emph{Field-types} \verb@'}'@ \emph{Field-names} \verb@';'@ +\end{center} + +\emph{Field-types} use the same type signature encoding as that of +\emph{call signatures} for argument and return types (Table \ref{tab:signature}). +\emph{Field-names} consist of a list of white-space separated names, +labeling each field component. + +An instance of a C type can be allocated via \code{new.struct}: + +\begin{smallverbatim} +> r <- new.struct(Rect) +\end{smallverbatim} + +Finally, the extraction (\verb@'$'@, \verb@'['@) and +replacement(\verb@'$<-'@, \verb@'[<-'@) operators can be used to access +structure fields symbolically. During value transfer between R and C, +automatic conversion of values with respect to the underlying C field +type takes place. + +\begin{smallverbatim} +> r$x <- -10 ; r$y <- -20 ; r$w <- 40 ; r$h <- 30 +\end{smallverbatim} + +In this example, R \code{numeric} values are converted on the fly to \code{signed}- and +\code{unsigned short} integers (usually 16-bit values). When the object gets printed on the prompt, +a detailed picture of the data object is given: + +\begin{smallverbatim} +> r +struct Rect { + x: -10 + y: -20 + w: 40 + h: 30 +} +\end{smallverbatim} + +At low-level, one can see that \code{r} is stored as an R \code{raw} vector object: + +\begin{smallverbatim} +> r[] +[1] f6 ff ec ff 28 00 1e 00 +attr(,"struct") +[1] "Rect" +\end{smallverbatim} + +To follow the example, we issue a foreign function call to \code{setRect} +via \code{.dyncall} and pass in the \code{r} object, +assuming the library is loaded and the symbol is resolved and +stored in an external pointer object named \code{setWindowRectAddr}: + +\begin{smallverbatim} +> .dyncall( setWindowRectAddr, "*<Rect>)v", r) +\end{smallverbatim} + +We make use of a typed pointer expression \code{'*<Rect>'} +instead of the untyped pointer signature \code{'p'}, which would +also work but does not prevent users from passing other objects +that do not reference a \code{struct Rect} data object. +Typed pointer expressions increase type-safety and use the +pattern \verb@'*<@\emph{Type-Name}\verb@>'@. +The invocation will be rejected if the argument passed in is not +of C type \code{Rect}. As \code{r} is tagged with an attribute +\code{struct} that refers to \code{Rect}, the call will be issued. + +Typed pointers can also occur as return types that - once the +type information is available - permit the manipulation of returned objects +in the same symbolic manner as above. + +C \verb@union@ types are supported as well but use the \code{parseUnionInfos} +function instead for registration and a slightly different signature format: + +\begin{center} +\emph{Union-name} \verb@'|'@ \emph{Field-types} \verb@'}'@ \emph{Field-names} \verb@';'@ +\end{center} + +The underlying low-level C type read- and write operations and conversions +from R data types are performed by the functions \code{.pack} and +\code{.unpack}. These can be used for various low-level operations as well, +such as dereferencing of pointers on pointers. + +R objects such as external pointers and atomic raw, integer and numeric +vectors can be used as aggregate C types via the attribute \code{struct}. +To \emph{cast} a type in the style of C, one can use \code{as.struct}. + +\subsection{Wrapping R functions as C callbacks} + +Some C libraries, such as user-interface toolkits and I/O processing +frameworks, use \emph{callbacks} as part of their interface to enable +registration and activation of user-supplied event handlers. +A callback is a user-defined function that has a library-defined +function type. Call-backs are usually registered via a registration function +offered by the library interface and are activated later from within +a library run-time context. + +\pkg{rdyncall} has support for wrapping ordinary R +functions as C callbacks via the function +\code{new.callback}. Callback wrappers are defined by a \emph{callback +signature} and the user-supplied R function to be wrapped. \emph{Callback signatures} look very +similar to \emph{call signatures} and should match the +functional type of the underlying C callback. +\code{new.callback} returns an external pointer that can +be used as a low-level function pointer for the registration as a C callback. +See Section \emph{Parsing XML using Expat} below for +applications of callback. + +\subsection{Foreign Library Interface} + +At the highest level, \pkg{rdyncall} provides the front-end function +\code{dynport} to dynamically setup an interface to a C Application +Programming Interface. This includes loading of the corresponding +shared C library and resolving of symbols. During the binding process, +a new R environment (this was a name space \citep{RNameSpace} till version 0.7.4) will be populated with thin R wrapper +objects that represent abstractions to C counter-parts such as +functions, pointer-to-functions, type-information objects for C struct and union +types and symbolic constant equivalents of C enums and macro defines. +The mechanism aims to work across platforms, given that the corresponding +shared libraries of a \emph{DynPort} have been installed in a +system standard location on the host. + +An initial repository of \emph{DynPorts} is available in the package +that provides bindings for several popular C APIs, see Table \ref{tab:libs} +for examples of available bindings. + +\section{Sample Applications} + +We give two examples with different application contexts that demonstrate +the direct usage of C APIs from within R through the \pkg{rdyncall} package. +The R interface to C libraries looks very +similar to the actual C API. For details on the usage of a particular +C library, the programming manuals and documentation of the libraries +should be consulted. + +Before loading R bindings via \code{dynport}, the shared library should +have been installed onto the system. Currently this is +to be done manually and the installation method depends on the target OS (See the manual +page about the 'rdyncall-demos' for details on this). +While \emph{OpenGL} is most often pre-installed on typical desktop-systems, +\emph{SDL} and \emph{Expat} sometimes have to be installed explicitly. + +\subsection{OpenGL Programming in R} + + +In the first example, we make use of the Simple DirectMedia Layer library (SDL) +\citep{SDL} \citep{Pendleton:2003:GPS} \citep{www:sdl-alternative} and +the Open Graphics Library (OpenGL) \citep{Board05} to implement +a portable multimedia application skeleton in R. + +We first need to load bindings to SDL and OpenGL via dynports: + +\begin{example} +> dynport(SDL) +> dynport(GL) +\end{example} + +Now we initialize the SDL library - in particular the video subsystem, and +open a window surface with a dimension of $640 x 480$ in 32-bit color +depths that has support for OpenGL rendering: + +\begin{smallverbatim} +> SDL_Init(SDL_INIT_VIDEO) +> surface <- SDL_SetVideoMode(640,480,32,SDL_OPENGL) +\end{smallverbatim} + +Next, we implement the application loop which updates the display repeatedly +and processes the event queue until a \emph{quit} request is +issued by the user via the window close button. + +\begin{smallverbatim} +> mainloop <- function() +{ + ev <- new.struct(SDL_Event) + quit <- FALSE + while(!quit) { + draw() + while(SDL_PollEvent(ev)) { + if (ev$type == SDL_QUIT) { + quit <- TRUE + } + } + } +} +\end{smallverbatim} + +SDL event processing is implemented by collecting events that occur in a +queue. +Once per update frame, typical SDL applications poll the queue by +calling \code{SDL\_PollEvent} with a pointer to a user-allocated buffer +of C type \code{union SDL\_Event}. +Event records have a common type identifier which is set to \code{SDL\_QUIT} +when a quit event has occurred e.g. when users press a close button on a window. + +Next, we implement our \code{draw} function making use of +the OpenGL 1.1 API. We clear the background with a blue color +and draw a light-green rectangle. + +\begin{smallverbatim} +> draw <- function() +{ + glClearColor(0,0,1,0) + glClear(GL_COLOR_BUFFER_BIT) + glColor3f(0.5,1,0.5) + glRectf(-0.5,-0.5,0.5,0.5) + SDL_GL_SwapBuffers() +} +\end{smallverbatim} + +Now we can run the application mainloop. + +\begin{smallverbatim} +> mainloop() +\end{smallverbatim} + +To stop the application, we hit the close button of the window. +A similar example is also available via \code{demo(SDL)}. Here the \code{draw} function +displays a rotating 3D cube depict in Figure \ref{fig:demo_SDL}. + +\begin{figure} +\centering +\includegraphics[scale=0.35]{img_SDL.png} +\caption{\label{fig:demo_SDL} +\code{demo(SDL)}} +\end{figure} + +\code{demo(randomfield)} gives a slightly more scientific application of OpenGL and R: +Random fields of 512x512 size are generated via blending of 5000 texture mapped 2D gaussian kernels. +The \emph{frames per second} counter in the window title gives the number of matrices generated per second (see Figure \ref{fig:demo_randomfield}). +When clicking on the animation window, the current frame and matrix is passed to R and plotted. +While several dozens of matrices are computed per second using OpenGL, +it takes several seconds to plot a single matrix in R using \code{image()}. + +\begin{figure} +\centering +\includegraphics[scale=0.35]{img_randomfield.png} +\caption{\label{fig:demo_randomfield} +\code{demo(randomfield)}} +\end{figure} + +\subsection{Parsing XML using Expat} + +In the second example, we use the Expat XML Parser library \citep{www:expat} +\citep{Kim:2001:TSJ} to implement a stream-oriented XML parser suitable +for very large documents. + +The library, being very popular, is very likely to be +already installed on many OS distributions - otherwise it is +available from package repositories or can be built as a shared library +from source. + +In Expat, custom XML parsers are implemented by defining +functions that are registered as callbacks to be invoked on +events that occur during parsing, such as the start and end of XML tags. +In our second example, we create a simple parser skeleton that +prints the start and end tag names. + +First we load R bindings for Expat via \code{dynport}. + +\begin{smallverbatim} +> dynport(expat) +\end{smallverbatim} + +Next we create an abstract parser object via the C function +\code{XML\_ParserCreate} that receives one argument of type C string +to specify a desired character encoding that overrides the document +encoding declaration. We want to pass a null pointer (\code{NULL}) here. +In the \code{.dyncall} FFI C null pointer values for pointer types are +expressed via the R \code{NULL} value: + +\begin{smallverbatim} +> p <- XML_ParserCreate(NULL) +\end{smallverbatim} + +The C interface for registration of start and end-tag event handler +callbacks is given below: + +\begin{smallverbatim} +/* Language C, from file expat.h: */ +typedef void (*XML_StartElementHandler) + (void *userData, const XML_Char *name, + const XML_Char **atts); +typedef void (*XML_EndElementHandler) + (void *userData, const XML_Char *name); +void XML_SetElementHandler(XML_Parser parser, + XML_StartElementHandler start, + XML_EndElementHandler end); +\end{smallverbatim} + +We implement the callbacks as R functions which print the event and +tag name. They are wrapped as C callback pointers via \code{new.callback} +using a matching \emph{callback signature}. +The second argument \code{name} of type C string in both callbacks, \code{XML\_StartElementHandler} and \code{XML\_EndElementHandler}, +is of primnary interest ; this argument passes over the XML tag name. +C strings are handled in a special way by the \code{.dyncall} FFI, because they +have to be copied as R \code{character} objects. +The special type signature \code{'Z'} is used to denote a +C string type. +The other arguments are simply denoted as untyped pointers using \code{'p'}: + +\begin{smallverbatim} +> start <- new.callback("pZp)v", + function(ignored1,tag,ignored2) + cat("Start tag:", tag, "\n") +) +> end <- new.callback("pZ)v", + function(ignored,tag) + cat("Stop tag:", tag, "\n") +) +> XML_SetElementHandler(p, start, end) +\end{smallverbatim} + +To test the parser, we create a sample document stored in a \code{character} +object named \code{text} and pass it to the parse function \code{XML\_Parse}: + +\begin{smallverbatim} +> text <- "<hello> <world> </world> </hello>" +> XML_Parse( p, text, nchar(text), 1) +\end{smallverbatim} + +The resulting output is given below: + +\begin{smallverbatim} +Start tag: hello +Start tag: world +End tag: world +End tag: hello +\end{smallverbatim} + +Expat supports processing of very large XML documents in a chunk-based manner by +calling \code{XML\_Parse} several times, where the last argument is used +as indicator for the final chunk of the document. + +\section{Architecture} + +The core implementation of the FFI, callbacks and loading of +code are mainly based on the suite of libraries of the \emph{DynCall} +project \citep{dyncall}. + +\subsection{Dynamic calls} + +The FFI offered by \pkg{rdyncall} is based on the \pkg{dyncall} +library, which provides an abstraction for making arbitrary +machine-level calls with support for multiple calling conventions +and most C argument- and return-types. \footnote{\emph{Inline} structure types are currently not fully supported.} + +For each processor architecture, the supported calling conventions +are abstracted in a \emph{Call Virtual Machine} (CallVM) +object. The \pkg{dyncall} library offers a universal C interface that can +be used from within scripting language interpreter contexts to build +up a machine-level call in a structured manner. + +A CallVM comprises a state machine and a call kernel. The state machine +is implemented in C and keeps track of internal buffers for pre-loading argument +values that get arranged for specific storage locations, such as stack or +special register sets according to the processor architecture and the chosen +calling conventions. +The actual invocation of a foreign function call is conducted by +the Call Kernel - a small piece of code that is implemented in +Assembly and that provides a generic call facility for a particular +calling convention. +It prepares machine-level calls by copying data to registers and to the +call stack according to the relevant calling convention, and finally +executes the machine call to a target address. + +From a scripting language interpreter perspective, the invocation of a +foreign function call through the CallVM is conducted in three consecutive +phases using the \pkg{dyncall} C API: + +\begin{enumerate} +\item \emph{Setup Phase:} The desired calling convention has to be +chosen which, in most cases, is just the \emph{default C} calling convention. +However, more specialized and platform-specific calling conventions are +available as well, in particular for the 32-Bit Windows OS. +\item \emph{Argument Loading Phase:} Arguments are passed in a +\emph{left-to-right} order according to the declaration of the C/C++ +function/method type declaration. Argument values are stored in buffers +according to the processor architecture and selected calling convention. +\item \emph{Call and Return-Value Receive Phase:} +A return-type specific call function is chosen and the target address +of the foreign code is passed, which gets called via the Call Kernel. +\end{enumerate} + +The architecture makes it straight-forward to implement a FFI +for a dynamic language interpreter using a text parser for call signatures +to drive the conversion of arguments and results. +Similar FFIs with a text-based interface have been implemented for other language +interpreters such as Ruby, Python and Lua. See the DynCall source repository \citep{dyncall}. + +Both the C interface of dyncall and the signature format use the abstract +C/C++ type system and give no indication about the effective size of +a particular type. In experiments with several C APIs bound via \pkg{rdyncall} +it turns out that the signatures do work cross-platform, +if the fundamental type definitions of the C API do not change across platforms. +In our tests and the presented examples, a wide range of +C APIs have this property and type signatures are valid across +platforms even when switching between 32- and 64-bit platforms. + +\subsection{Dynamic callbacks} + +The \pkg{dyncallback} library provides a framework to implement +dynamic callbacks for language interpreters to wrap scripting functions +as C function pointers. +The framework offers a universal C interface for callback handler that +is implemented once for a particular interpreter. +The handler receives callback calls from C and forwards the call, +including conversion of arguments, to a scripting function. + +Handlers need to access machine-level arguments whose location +can be on the stack, or in registers, +depending on the processor architecture and calling convention. +For that reason, the handler interface receives an abstract argument +iterator that gives structured access to the arguments for +passing over to the high-level language. +Call-backs are created via an interface that pools a handler, +language context, scripting function reference, +callback type-information and other user data into a +\emph{single} native C function pointer, such that even very +low-level C callbacks without user-supplied user-data can be +addressed with the underlying technique. \footnote{This includes +callbacks for sort routines of the Standard C library which lack user-data.} + +\subsection{Portability and Stability} + +The requirements for porting the \emph{DynCall} libraries to +a new processor and/or platform are high: The calling conventions of a target processor platform have to be studied in detail, +state machines have to be implemented in C and a small amount of code has to be written in +Assembly which can be even non-portable across build tools on the same platform. +Nevertheless \pkg{dyncall} (as of version 0.7) has support for many processor architectures such as +Intel i386 (x86), AMD 64 (x64), PowerPC 32-bit,ARM (including Thumb extension), MIPS 32/64-bit and SPARC 32/64-bit +including support for several platform-, processor- and compiler-specific calling conventions. +\pkg{dyncallback} also supports major processor architectures such as Intel i386 (x86), AMD 64 (x64) and ARM and offers +partial support for PowerPC 32-bit (support for Mac OS X/Darwin). +Besides the processor architecture, the libraries are also explicitly ported and tested on +various OS such as Linux, Mac OS X, Windows, the BSD family, Solaris, Haiku, Minix and Plan9. +Support for embedded platforms such as Playstation Portable, Nintendo DS and iPhone OS is available as well. + +\emph{DynCall} contains a suite of testing tools for quality assurance. Included are test-case generators written in +Lua and Python. Extreme call and callback scenarios are tested here to ensure correct passing of arguments and results. +Before a release, the libraries and tests are built for a large set of architectures on +\pkg{DynOS} \citep{dynos} - a batch-build system using full system emulators such as +\pkg{QEmu}\citep{qemu} and \pkg{GXEmul}\citep{gxemul} and various operating-system images +to test release candidates and create pre-built binary releases of the library. + +\subsection{Text-based Signature Interfaces} + +A common property of the service interface presented here is the use of +signature text formats. Signatures are used +as descriptors for types, such as foreign function calls, callbacks and +aggregate data types. +The reasons that lead to the use of signatures as a high-level user-interface +to interact with such services are given next: + +\begin{enumerate} +\item Cross-language interface: Text format interfaces are available across +high-level languages. Examples for cross-language text-based +interfaces include regular expressions or \code{printf}-style formatted output +descriptions. + +\item Developer-friendly: +The simplicity and compactness of the text-format enables developers +to bridge with foreign code in interactive and rapid development +sessions. +C type signatures can be derived by hand with minimum effort: +Fundamental types are encoded with a single character and the +upper-case encodes an \code{unsigned} type. + +\item Machine-neutral: +In contrast to binary encoded type libraries, the data format is not affected +by the endian model of the underlying platform. + +\item Parser-friendly: +The signature format can be used as driver code to perform foreign function +calls. Implementations of parsers match the sequential +design of \pkg{dyncall}'s CallVM and \pkg{dyncallback}'s argument iterator interface. +\end{enumerate} + +\subsection{Creation of DynPort files} + +In this section we describe the tool-chain that creates the +universal bindings called \emph{DynPort}. The process described +here is applied once on a build machine, the generated output +is used later at run-time across platforms to drive the +dynamic linkage and binding procedure. +\emph{DynPort} files can be created automatically from +C header files using a tool-chain as depicted in +Figure \ref{fig:gen_dynport}. + +\begin{figure} +\centering +\includegraphics[scale=0.45]{img_gen_dynport.pdf} +\caption{\label{fig:gen_dynport} +Tool-chain to create \emph{DynPort} files from C headers} +\end{figure} + +The tool-chain comprises several freely available components that +are briefly described next: +\pkg{GCC-XML} \citep{gccxml} is a modified version of the GCC compiler +which translates C sources to XML document. +\pkg{xsltproc}, distributed as part of the \pkg{libxslt} library +\citep{libxslt}, is a XSLT processor that transforms XML documents to +XML, text or binary formats according to style-sheets written in +the \emph{XSL Transformations} \citep{Clark:01:XTV} language. + +To extract library binding specifications, a main C source file is created that +consists of one or more \code{\#include} statements that +reference library and/or system header files to process. +The header files should have been previously installed on +the build machine. +In a preprocessing phase, the GNU C Macro Processor is used to process +all \code{\#include} statements using standard system search paths +to create a concatenated \emph{All-In-One} source file free of any +\code{\#include} statements. +GCC-XML transforms C header declarations to XML. +A XSL style-sheet implements the transformation of XML to +type signature formats using a XSLT processor. +C Macro \code{\#define} statements are handled separately by a custom +C Preprocessor implemented in C++ using the boost wave library \citep{boostwave}. +An optional filter stage is used to include only elements with +a certain pattern such as a common prefix usually found in many +libraries e.g. '\code{SDL\_}'. +In a last step, the various fragments are assembled into a single +text-file which represents the \emph{DynPort} file. +The overall build process is managed by \emph{make} files and a repository of recipes +has been setup to extend support for additional +dynports and libraries in a structured and coordinated way. + + +\section{Summary and Outlook} + +This paper introduces the \pkg{rdyncall} package (Version 0.7.3 on CRAN as of this writing) that contributes an improved Foreign Function Interface for R. +The FFI facilitates \emph{direct} invocation of foreign functions \emph{without} the need to compile additional wrapper in C. +Based on the FFI, a dynamic cross-platform linkage framework to wrap and access \emph{whole} C interfaces of native libraries from R +is discussed. +Instead of \emph{compiling} bindings for every library-and-language combination, +R bindings of a library are created dynamically at run-time in a data-driven manner via +\emph{DynPort} files - a cross-platform universal type information format. +C libraries are made accessible in R as though they were extension packages and +the R interface looks very similar to that of C. +This enables system-level programming in R and brings a new wave of possibilities for R developers +such as using OpenGL directly in R across platforms as described in the example. +An initial repository of \emph{DynPort}s for standard cross-platform portable +C libraries comes with the package. + +The implementation is based on libraries from the \emph{DynCall} project that implement non-trivial +facilities such as an abstraction to machine-level function calls supporting +multiple calling conventions and the handling of C callbacks from within scripting language interpreter environments. +The libraries have been ported across major R platforms. +Work is in progress to support missing architectures in \pkg{dyncallback} such as PowerPC System V 32-bit, PowerPC 64-bit, and, 32/64-bit MIPS and SPARC architectures. +The handling of foreign aggregate data types, which is currently implemented in R and C, +is planned to be reimplemented in portable C as part of \emph{DynCall}, in cooperation with the developers of \emph{BridJ}\citep{bridj}. +Currently, \emph{DynPort} files are written as R scripts with +inline text chunks created from the \emph{DynPort} tool chain. +For the Lua Programming Language \citep{SPE::IerusalimschyFF1996}, a similar framework named \pkg{luadyncall} is in +development using a language-neutral format for \emph{DynPort} files. +The need to install additional shared libraries still represents a hurdle for ordinary R users. +We plan to find a common abstraction layer for installation systems, package managers and software distribution services +across OS-distributions, and to integrate meta installation information into the \emph{DynPort} file format. + +The \emph{DynPort} facility in \pkg{rdyncall} consitutes an initial step in building up an infrastructure between +scripting languages and C libraries. +Analogous to the way in which R users enjoy quick access to the large pool of R software +managed by CRAN, we envision an archive network in which C library developers can distribute +their work across languages, and users get quick access to the pool of C libraries from within +scripting languages via automatic installation of precompiled components and using +universal type information for cross-platform and cross-language dynamic bindings. + +\bibliography{FLI} + +\end{document}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/rdyncall/vignettes/FLI.bib Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,352 @@ +@ARTICLE{R:Ihaka+Gentleman:1996, + AUTHOR = "{Ross Ihaka and Robert Gentleman}", + TITLE = "{R: A Language for Data Analysis and Graphics}", + JOURNAL = {Journal of Computational and Graphical Statistics}, + YEAR = 1996, + VOLUME = 5, + NUMBER = 3, + PAGES = {299--314}, + URL = {http://www.amstat.org/publications/jcgs/} +} +@Article{Kim:2001:TSJ, + author = "Eugene Eric Kim", + title = "{A Triumph of Simplicity: James Clark on Markup + Languages and XML}", + journal = "Dr. Dobb's Journal of Software Tools", + volume = "26", + number = "7", + pages = "56, 58--60", + month = jul, + year = "2001", + CODEN = "DDJOEB", + ISSN = "1044-789X", + bibdate = "Thu Jun 7 06:07:17 MDT 2001", + URL = "http://www.ddj.com/", + abstract = "Whether you know it or not, James Clark has made your + life easier by creating a number of open-source tools + such as expat (an XML parser), groff (a GNU version of + troff), TREX (an XML schema language), and more.", + acknowledgement = "Nelson H. F. Beebe, University of Utah, Department + of Mathematics, 110 LCB, 155 S 1400 E RM 233, Salt Lake + City, UT 84112-0090, USA, Tel: +1 801 581 5254, FAX: +1 + 801 581 4148, e-mail: \path|beebe@math.utah.edu|, + \path|beebe@acm.org|, \path|beebe@computer.org| + (Internet), URL: + \path|http://www.math.utah.edu/~beebe/|", +} +@Article{ihaka1996r, + author = "Ross Ihaka and Robert Gentleman", + title = "{R}: {A} Language for Data Analysis and Graphics", + journal = "Journal of Computational and Graphical Statistics", + year = "1996", + volume = "5", + number = "3", + pages = "299--314", +} + +@Article{Pendleton:2003:GPS, + author = "Bob Pendleton", + title = {{Game Programming with the {Simple DirectMedia Layer} + ({SDL})}}, + journal = "Linux Journal", + volume = "110", + pages = "42, 44, 46, 48", + month = jun, + year = "2003", + CODEN = "LIJOFX", + ISSN = "1075-3583", + bibdate = "Sat May 10 16:56:52 MDT 2003", + bibsource = "http://noframes.linuxjournal.com/lj-issues/issue110/index.html", + abstract = "With this well-tested library, you can easily develop + games for Linux and non-Linux platforms.", + acknowledgement = "Nelson H. F. Beebe, University of Utah, Department + of Mathematics, 110 LCB, 155 S 1400 E RM 233, Salt Lake + City, UT 84112-0090, USA, Tel: +1 801 581 5254, FAX: +1 + 801 581 4148, e-mail: \path|beebe@math.utah.edu|, + \path|beebe@acm.org|, \path|beebe@computer.org| + (Internet), URL: + \path|http://www.math.utah.edu/~beebe/|", +} +@Manual{Rext, + title = {Writing R Extesions}, + author = {{R Development Core Team}}, + organization = {R Foundation for Statistical Computing}, + address = {Vienna, Austria}, + year = {2010}, + note = {{ISBN} 3-900051-11-9}, + url = {http://www.R-project.org}, +} +@Manual{R, + title = {R: A Language and Environment for Statistical Computing}, + author = {{R Development Core Team}}, + organization = {R Foundation for Statistical Computing}, + address = {Vienna, Austria}, + year = {2010}, + note = {{ISBN} 3-900051-07-0}, + url = {http://www.R-project.org}, +} +@Manual{rdyncall, + title = {rdyncall: Improved foreign function interface with support for low-level C structure/union data type access.}, + author = {Daniel Adler}, + year = {2010}, + note = {R package version 0.1}, + url = {http://dyncall.org}, +} + +@Book{CLang, + author = "{Kernigham, B. W.} and {Ritchie, D. M.}", + title = "The ${C}$ Programming Language", + publisher = "Prentice-Hall", + year = "1978", +} + +@MISC{www:expat, + AUTHOR = "James Clark", + TITLE = {{The Expat XML Parser}}, + MONTH = "May", + YEAR = "2011", + HOWPUBLISHED = "URL \url{http://expat.sourceforge.net/}" +} + +@MISC{www:sdl-alternative, + AUTHOR = "Howard Wen", + TITLE = {{SDL: The DirectX Alternative}}, + MONTH = "September", + YEAR = "2001", + publisher = "O'Reilly", + HOWPUBLISHED = "URL \url{http://linuxdevcenter.com/pub/a/linux/2001/09/21/sdl.html}" +} + +@MISC{SDL, + author = "Sam Lantinga and et al", + title = {{libSDL: Simple DirectMedia Layer}}, + year = "2011", + month = "May", + howpublished = {URL \url{http://www.libsdl.org/}} +} + +@MISC{RNameSpace, + AUTHOR = "Luke Tierney", + TITLE = "{A Simple Implementation of Name Spaces for R}", + MONTH = "May", + YEAR = "2011", + HOWPUBLISHED = "URL \url{http://www.stat.uiowa.edu/~luke/R/namespaces/morenames.pdf}" +} + +@MISC{SWIG, + author = {The SWIG Developers}, + TITLE = {{SWIG}: {Simplified} {Wrapper} and {Interface} {Generator}}, + MONTH = "October", + YEAR = "1995--2010", + URL = {http://www.swig.org/} +} + +@Misc{Oust97a, + author = "John K. Ousterhout", + title = "{Scripting: Higher Level Programming for the 21st Century}", + month = may, + year = "1997", + keywords = "tcl tcltk scripting", + URL = "http://www.sunlabs.com/people/john.ousterhout/scripting.ps", + note = "White Paper", +} + +@article{Beazley:2003:ASS:860016.860018, + author = {Beazley, D. M.}, + title = {Automated scientific software scripting with SWIG}, + journal = {Future Gener. Comput. Syst.}, + volume = {19}, + issue = {5}, + month = {July}, + year = {2003}, + issn = {0167-739X}, + pages = {599--609}, + numpages = {11}, + url = {http://portal.acm.org/citation.cfm?id=860016.860018}, + doi = {10.1016/S0167-739X(02)00171-1}, + acmid = {860018}, + publisher = {Elsevier Science Publishers B. V.}, + address = {Amsterdam, The Netherlands, The Netherlands}, + keywords = {SWIG, interface compiler, python, scientific software, scripting languages}, +} + +@InProceedings{tcl_tk96*129, + author = "David M. Beazley", + title = "{SWIG}: An Easy to Use Tool for Integrating Scripting + Languages with {C} and {C++}", + pages = "129--140", + ISBN = "1-880446-78-2", + booktitle = "Proceedings of the Fourth Annual Tcl/Tk Workshop", + month = jul # "~10--13", + publisher = "Usenix", + address = "Berkeley", + year = "1996" +} + +@misc{UsingExpat, + title = "Using Expat", + author = "Clark Copper", + publisher ="O'Reilly", + month = "September", + year = "1999", + howpublished = "URL \url{http://www.xml.com/pub/a/1999/09/expat/index.html}" +} + +@Book{Board05, + author = "OpenGL Architecture Review Board and D. Shreiner and et al", + title = "Open{GL}({R}) Programming Guide: The Official Guide to Learning Open{GL}({R}), Version 2", + pages = "896", + publisher = "Addison Wesley", + year = "2005", + keywords = "book, text, c2005, c200x, c20xx, computer graphics, + open GL R, openGL, OpenGL2, OpenGLR", + abstract = "5th ed, pb, us\$48, + http://www.amazon.com/gp/product/0321335732/?tag=fourwheeldrivein + ; .", +} + +@misc{dyncall, + title = {{DynCall Project}}, + author = "Daniel Adler and Tassilo Philipp", + month = "May", + year = "2011", + howpublished = "URL \url{http://dyncall.org}" +} + +@misc{gccxml, + title = {{GCC-XML}}, + author = "Brad King", + month = "May", + year = "2011", + howpublished = "URL \url{http://www.gccxml.org}" +} + +@Article{SPE::IerusalimschyFF1996, + title = "Lua---An Extensible Extension Language", + author = "Roberto Ierusalimschy and Luiz Henrique de Figueiredo + and Waldemar Celes Filho", + journal = "Software---Practice and Experience", + pages = "635--652", + month = jun, + year = "1996", + volume = "26", + number = "6", +} + +@InProceedings{conf/hopl/IerusalimschyFF07, + title = "The evolution of Lua", + author = "Roberto Ierusalimschy and Luiz Henrique de Figueiredo + and Waldemar Celes Filho", + bibdate = "2007-06-13", + bibsource = "DBLP, + http://dblp.uni-trier.de/db/conf/hopl/hopl2007.html#IerusalimschyFF07", + booktitle = "HOPL", + booktitle = "Proceedings of the Third {ACM} {SIGPLAN} History of + Programming Languages Conference ({HOPL}-{III}), San + Diego, California, {USA}, 9-10 June 2007", + publisher = "ACM", + year = "2007", + editor = "Barbara G. Ryder and Brent Hailpern", + pages = "1--26", + URL = "http://doi.acm.org/10.1145/1238844.1238846", +} + +@TechReport{Clark:01:XTV, + author = "James Clark", + title = "{XSL} Transformations ({XSLT}) Version {1.1}", + month = aug, + note = "http://www.w3.org/TR/2001/WD-xslt11-20010824/", + year = "2001", + bibsource = "http://w2.syronex.com/jmr/w3c-biblio", + type = "{W3C} Working Draft", + institution = "W3C", +} + + + + +@misc{boostwave, + title = {{Wave V2.0 - Boost C++ Libraries}}, + author = "Hartmut Kaiser", + month = "May", + year = "2011", + howpublished = "URL \url{http://www.boost.org/doc/libs/release/libs/wave/index.html}" +} + +@misc{libxslt, + title = {{The XSLT C library for GNOME}}, + author = "Daniel Veillard and Bjorn Reese and et al", + month = "May", + year = "2011", + howpublished = "URL \url{http://xmlsoft.org/XSLT/}" +} + +@misc{bridj, + title = {{BridJ: Let Java \& Scala call C, C++, Objective-C, C\#...}}, + author = "Olivier Chafik", + month = "May", + year = "2011", + howpublished = "URL \url{http://code.google.com/p/bridj/}" +} + +@InProceedings{qemu, + title = "{QEMU}, a Fast and Portable Dynamic Translator", + author = "Fabrice Bellard", + publisher = "USENIX", + year = "2005", + bibdate = "2007-05-07", + bibsource = "DBLP, + http://dblp.uni-trier.de/db/conf/usenix/usenix2005f.html#Bellard05", + booktitle = "USENIX Annual Technical Conference, FREENIX Track", + pages = "41--46", + URL = "http://www.usenix.org/events/usenix05/tech/freenix/bellard.html", +} + +@misc{gxemul, + title = {{GXEmul}: a framework for full-system computer architecture emulation.}, + author = "Anders Gavare", + month = "May", + year = "2011", + howpublished = "URL \url{http://gxemul.sourceforge.net/}" +} + +@misc{dynos, + title = {{DynOS Project}}, + author = {Tassilo Philipp}, + month = "May", + year = "2011", + howpublished = "URL \url{http://dyncall.org/dynos}" +} + +@Book{vanRossum:2005:PLR, + author = "Guido van Rossum and Fred L. {Drake, Jr.}", + title = "{Python} Language Reference Manual", + publisher = "Network Theory Ltd.", + address = "pub-NETWORK-THEORY:adr", + pages = "ii + 112", + year = "2005", + ISBN = "0-9541617-8-5", + isbn-13 = "978-0-9541617-8-1", + LCCN = "QA76.73.P98", + bibdate = "Mon Jul 04 16:02:34 2005", + bibsource = "library.ox.ac.uk:210/ADVANCE", + URL = "http://www.network-theory.co.uk/python/language/", + acknowledgement = "Nelson H. F. Beebe, University of Utah, Department + of Mathematics, 110 LCB, 155 S 1400 E RM 233, Salt Lake + City, UT 84112-0090, USA, Tel: +1 801 581 5254, FAX: +1 + 801 581 4148, e-mail: \path|beebe@math.utah.edu|, + \path|beebe@acm.org|, \path|beebe@computer.org| + (Internet), URL: + \path|http://www.math.utah.edu/~beebe/|", + subject = "Python (Computer program language)", +} + +@Book{Flanagan-Matsumoto08, + author = "David Flanagan and Yukihiro Matsumoto", + title = "The {Ruby} Programming Language", + publisher = "O'Reilly", + year = "2008", + address = "Cambridge", + annote = "Ruby 1.8 and 1.9.", +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/bugfix.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,26 @@ + + +x <- rdyncall:::makeNamespace("bla") +sys.source("/lab/eclipse/dyncall/rdyncall/scratch/script.R", envir=x) + +quote({ +parseStructInfos(" +SDL_keysym{CiiS}scancode sym mod unicode ; +SDL_KeyboardEvent{CCC<SDL_keysym>}type which state keysym ; +", envir=x) +}) + +f <- function() +{ + parent.frame() +} + +g <- function(envir=parent.frame()) +{ + envir +} + +f <- function(envir=parent.frame()) +{ + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/callbacks.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,83 @@ + + +dynbind("user32","RegisterClassEx(p)p;") + + +C.struct <- function(signature) { + map <- strsplit(signature,'[; \t\n]+')[[1]] + if (map[1] == "") + map <- map[-1] + n <- length(map) + types <- map[seq(1,n,by=2)] + ids <- map[seq(2,n,by=2)] + sizes <- C.sizes[types] + offsets <- c(0,cumsum(sizes)) + ids <- c(ids,".sizeof") + types <- c(types,"") + sizes <- c(sizes,"") + data.frame( + id=ids, + type=types, + size=sizes, + offset=offsets, + row.names=1 + ) +} + +WNDCLASSEX <- " +UINT cbSize; +UINT style; +WNDPROC lpfnWndProc; +int cbClsExtra; +int cbWndExtra; +HINSTANCE hInstance; +HICON hIcon; +HCURSOR hCursor; +HBRUSH hbrBackground; +LPCTSTR lpszMenuName; +LPCTSTR lpszClassName; +HICON hIconSm; +" + +WNDCLASSEX <- C.struct(" +UINT cbSize; +UINT style; +WNDPROC lpfnWndProc; +int cbClsExtra; +int cbWndExtra; +HINSTANCE hInstance; +HICON hIcon; +HCURSOR hCursor; +HBRUSH hbrBackground; +LPCTSTR lpszMenuName; +LPCTSTR lpszClassName; +HICON hIconSm; +") + +library(rdyncall) + +allocC <- function(info) +{ + x <- malloc(sizeof(info)) + attr(x, "cstruct") <- info + class(x) <- "cstruct" + return(x) +} + +packC <- function( address, offset, type, value ) +{ + +} + + +"$.Cstruct<-" <- function (cstruct, name, value) +{ + info <- attr(x, "cstruct") + element <- info[name,] + packC( cstruct, element$offset, sigchar(element$type), value ) + return(value) +} + +winclass <- allocC(WNDCLASS) +winclass$cbSize <- sizeofC(WNDCLASS) +RegisterClassEx(winclass)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/dynamic_loading.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,27 @@ +# +# GOAL: +# automatic unloading when all symbols from a library are free'ed. +# +# +# +# loading a shared library + +# low-level R +x <- dyn.load("/lib/libc.so.6") +handle <- x[["handle"]] + + + + +# high-level R in conjunction with R packages +library.dynam() + +prot = library +R_MakeExternalPtr(addr, tag, prot) + + + + +x <- .dynload("/lib/libc.so.6") +y <- .dynsym(x, "glBegin") +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/dynport_dyp.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,50 @@ +# +# 1. install functions +# 2. install function variables +# 3. install enums +# 4. install defines +# + + + +begin.info <- function() +{ +} + +begin.funs <- function() +{ + +} + +parse.funs <- function(line) +{ + +} + + +parse <- function(path) +{ + file <- file(path) + eof <- FALSE + while(!eof) + { + line <- readLines(file, 1) + } +} + +parse("rdyncall/scratch/test.dyp") + +currentSection <- "" + + +if ( substr(line, 1, 1) == "!" ) { + paste("end.", currentSection) + do.call( paste("end.", currentSection, sep="") ) + type <- substr(line,2) + handler <- paste("begin.",type,sep="") + envs <- find(handler) + if (length(envs) == 1) + do.call(handler) + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/installation.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,68 @@ + +# ----------------------------------------------------------------------------- +# dynport configuration +.installdir <- "c:\\dynports" +# ----------------------------------------------------------------------------- + +# installation: +.libname <- "SDL" +.sysname <- Sys.info()[["sysname"]] +if (.sysname == "Windows") { + + dynports.ui.init <- function() + { + winMenuAdd("Dynports") + winMenuAdd("Dynports/Install dynport(s) ...") + } + + + dynport.sdl.is.installed <- function() { + x <- .dynload(.libname) + if (is.null(x)) return(FALSE) + return(TRUE) + } + + dynport.sdl.install <- function() { + + sysname <- Sys.info()[["sysname"]] + + .prebuilt <- c( + Windows.zip="http://www.libsdl.org/release/SDL-1.2.13-win32.zip", + Linux.rpm.x86="http://www.libsdl.org/release/SDL-1.2.13-1.i386.rpm", + Linux.rpm.x86_64="http://www.libsdl.org/release/SDL-1.2.13-1.x86_64.rpm", + MacOSX="http://www.libsdl.org/release/SDL-1.2.13.dmg" + ) + + if (sysname == "Windows") { + + # install.windows.zip to .dyncall.bindir + + package <- "SDL" + version <- "1.2.13" + arch <- "win32" + rooturl <- "http://www.libsdl.org/release/" + zipname <- "SDL-1.2.13-win32.zip" + tempdir <- tempdir() + zipfile <- file.path( tempdir, zipname ) + url <- paste( rooturl , zipname, sep="/" ) + method <- "internal" + download.file(url, zipfile, method) + zip.unpack( zipfile, tempdir ) + dllname <- "SDL.dll" + dllfile <- file.path( tempdir, dllname ) + file.copy(dllfile, .installdir) + + } else if (sysname == "Linux") { + + + + } else if (sysname == "Darwin") { + + + + } + + } + + + \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/lib_life_cycle.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,9 @@ +# manage by auto-reference? + +# package foo uses dynport bar +# +# 1. dynport bar loaded - loads bar shared library +# 2. package foo uses bar +# 3. copy function from dynport +# 3. detach dynport bar +# 4.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/namespaces.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,72 @@ + +makeNamespace <- function(name, version = NULL, lib = NULL) { + impenv <- new.env(parent = .BaseNamespaceEnv, hash = TRUE) + attr(impenv, "name") <- paste("imports", name, sep = ":") + env <- new.env(parent = impenv, hash = TRUE) + name <- as.character(as.name(name)) + version <- as.character(version) + info <- new.env(hash = TRUE, parent = baseenv()) + assign(".__NAMESPACE__.", info, envir = env) + assign("spec", c(name = name, version = version), + envir = info) + setNamespaceInfo(env, "exports", new.env(hash = TRUE, + parent = baseenv())) + setNamespaceInfo(env, "imports", list(base = TRUE)) + setNamespaceInfo(env, "path", file.path(lib, name)) + setNamespaceInfo(env, "dynlibs", NULL) + setNamespaceInfo(env, "S3methods", matrix(NA_character_, + 0L, 3L)) + assign(".__S3MethodsTable__.", new.env(hash = TRUE, + parent = baseenv()), envir = env) + .Internal(registerNamespace(name, env)) + env +} + +install <- function() +{ + name <- "GL" + ns <- makeNamespace(name) + info <- ns$.__NAMESPACE__. + # info$DLLs <- dyn.load("") + with(ns, + { + dynbind("GL","glBegin()v;") + .onUnload <- function() + { + .dynunload(.lib) + } + } + ) + # ns$.packageName <- "stdio" + namespaceExport( ns, ls(ns) ) + # attach(ns, name="dynport:GL") + attachNamespace(ns) +} +install() + + +unloadNamespace("stdio") + + +# retrieve list of shared libraries loaded + +library.dynam() +.dynLibs() +# load a specified library + +.sys.lib.loc <- c("/opt/local/lib", "/opt/lib", "/usr/local/lib", "/usr/lib") + +findLibPath <- function(name, lib.loc=.sys.lib.loc) +{ + for(i in lib.loc) { + trypath <- file.path(i, paste("lib", name,.Platform$dynlib.ext,sep="") ) + if ( file.exists(trypath) ) return(trypath) + } + NULL +} + +tests <- c("GL","SDL","expat") + +sapply( tests, findLibPath ) + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/preprocess.c.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,21 @@ +# TODO: Add comment +# +# Author: dadler +############################################################################### + + + +x <- " +#define AUDIO_S16 AUDIO_S16LSB +#define AUDIO_S16LSB 0x8010 +#define AUDIO_S16MSB 0x9010 +" + + + + +cpreprocessor <- function(text) +{ + grep(text) +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/script.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,5 @@ + +parseStructInfos(" +SDL_keysym{CiiS}scancode sym mod unicode ; +SDL_KeyboardEvent{CCC<SDL_keysym>}type which state keysym ; +")
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/stdio.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,25 @@ +# Dynport: stdio +# Description: Standard I/O C library +# Dynport-Maintainer: dadler@uni-goettingen.de +# ----------------------------------------------------------------------------- + +.sysname <- Sys.info()[["sysname"]] +if (.sysname == "Windows") { + .libNameC <- "msvcrt" +} else { + .libNameC <- "c" +} + +dynbind(.libNameC," +fopen(ZZ)p; +fread(piip)i; +fwrite(piip)i; +fseek(pli)i; +fclose(p)i; +memcpy(ppi)p; +memset(pii)p; +") + +SEEK_SET = 0 +SEEK_CUR = 1 +SEEK_END = 2
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/structs.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,321 @@ +# struct tests: + + +# test embedded structures and inline assignments + +parseStructInfos(" +SDL_Rect{ssSS}x y w h ; +Test{II<SDL_Rect>II}a b rect c d; +") +x <- new.struct("Test") +print(x) + +r <- new.struct("SDL_Rect") +r$x <- 1 +r$y <- 2 +r$w <- 3 +r$h <- 4 +x$rect <- r + +# + +parseStructInfos(" +SDL_ActiveEvent{CCC}type gain state ; +SDL_keysym{CiiS}scancode sym mod unicode ; +SDL_KeyboardEvent{CCC<SDL_keysym>}type which state keysym ; +SDL_MouseMotionEvent{CCCSSss}type which state x y xrel yrel ; +SDL_MouseButtonEvent{CCCCSS}type which button state x y ; +") + +g + +new <- function() +{ + x <- list() + class(x) <- "test" + return(x) +} + +"$<-.test" <- function(x, index, value) +{ + cat("$<-\n") + cat("nargs:", nargs(), "\n" ) + x[index] <- value + return(x) +} + +"$.test" <- function(x, index) +{ + cat("$\n") + x[index] +} + +x <- new() +x$a <- 23 + +x$a$b <- 23 + + + + +str(x) + +x$rect + +registerStructInfos(" +SDL_Rect{ssSS}x y w h ; +SDL_Surface{I*<SDL_PixelFormat>iiS*vi*<private_hwdata><SDL_Rect>II*<SDL_BlitMap>Ii}flags format w h pitch pixels offset hwdata clip_rect unused1 locked map format_version refcount ; +") + + +x <- new.struct("SDL_Rect") +x$x <- 10 +x$y <- 10 +x$w <- 100 +x$h <- 100 +str(x) + +# ---------------------------------------------------------------------------- +# tests + + +registerStructInfos("SDL_SysWMmsg{}; + SDL_SysWMEvent{C*<SDL_SysWMmsg>}type msg ; + ") + +registerStructInfos(sdlStructs) +parseStructInfos("SDL_UserEvent{Ci*v*v}type code data1 data2 ;SDL_QuitEvent{C}type ;") +sigs <- "SDL_UserEvent{Ci*v*v}type code data1 data2 ;SDL_QuitEvent{C}type ;" + +for (i in seq(along=sigs)) +{ + if ( length(sigs[[i]]) < 2 ) next + name <- sigs[[i]][[1]] + # eat white spaces + name <- gsub("[ \n\t]*","",name) + tail <- unlist( strsplit(sigs[[i]][[2]], "\\}") ) + sig <- tail[[1]] + fields <- unlist( strsplit( tail[[2]], "[ \n\t]+" ) ) + infos[[name]] <- list(sig, fields) + infos[[name]] <- makeStructInfo(sig, fields) +} +return(infos) +} + + + + +registerStructInfos("SDL_version{CCC}major minor patch ; + _SDL_TimerID{}; + SDL_SysWMmsg{}; + SDL_SysWMEvent{C*<SDL_SysWMmsg>}type msg ; + SDL_UserEvent{Ci*v*v}type code data1 data2 ; + SDL_QuitEvent{C}type ; + SDL_ExposeEvent{C}type ; + SDL_ResizeEvent{Cii}type w h ; + SDL_JoyButtonEvent{CCCC}type which button state ; + SDL_JoyHatEvent{CCCC}type which hat value ; + SDL_JoyBallEvent{CCCss}type which ball xrel yrel ; + SDL_JoyAxisEvent{CCCs}type which axis value ; + SDL_MouseButtonEvent{CCCCSS}type which button state x y ; + SDL_MouseMotionEvent{CCCSSss}type which state x y xrel yrel ; + SDL_keysym{CiiS}scancode sym mod unicode ; + SDL_KeyboardEvent{CCC<SDL_keysym>}type which state keysym ; + SDL_ActiveEvent{CCC}type gain state ; + SDL_Rect{ssSS}x y w h ; + SDL_Surface{I*<SDL_PixelFormat>iiS*vi*<private_hwdata><SDL_Rect>II*<SDL_BlitMap>Ii}flags format w h pitch pixels offset hwdata clip_rect unused1 locked map format_version refcount ; + ") + + + +sigs <- "SDL_ActiveEvent{CCC}type gain state ;SDL_AudioCVT{iSSd*Ciiidi}needed src_format dst_format rate_incr buf len len_cvt len_mult len_ratio filters filter_index ;" +sigs <- "SDL_AudioCVT{iSSd*Ciiidi}needed src_format dst_format rate_incr buf len len_cvt len_mult len_ratio filters filter_index ;" +parseStructInfos(sigs) +dsadsigs <- sdlStructs +sdlStructs <- " + SDL_version{CCC}major minor patch ; + _SDL_TimerID{}; + SDL_SysWMmsg{}; + SDL_SysWMEvent{C*<SDL_SysWMmsg>}type msg ; + SDL_UserEvent{Ci*v*v}type code data1 data2 ; + SDL_QuitEvent{C}type ; + SDL_ExposeEvent{C}type ; + SDL_ResizeEvent{Cii}type w h ; + SDL_JoyButtonEvent{CCCC}type which button state ; + SDL_JoyHatEvent{CCCC}type which hat value ; + SDL_JoyBallEvent{CCCss}type which ball xrel yrel ; + SDL_JoyAxisEvent{CCCs}type which axis value ; + SDL_MouseButtonEvent{CCCCSS}type which button state x y ; + SDL_MouseMotionEvent{CCCSSss}type which state x y xrel yrel ; + SDL_keysym{CiiS}scancode sym mod unicode ; + SDL_KeyboardEvent{CCC<SDL_keysym>}type which state keysym ; + SDL_ActiveEvent{CCC}type gain state ; + _SDL_Joystick{}; + SDL_Rect{ssSS}x y w h ; + WMcursor{}; + SDL_Cursor{<SDL_Rect>ss*C*C*<WMcursor>}area hot_x hot_y data mask save wm_cursor ; + SDL_Overlay{Iiii*S**<private_yuvhwfuncs>*<private_yuvhwdata>II}format w h planes pitches pixels hwfuncs hwdata hw_overlay UnusedBits ; + private_yuvhwdata{}; + private_yuvhwfuncs{}; + SDL_VideoInfo{IIIIIIIIIIIII*<SDL_PixelFormat>ii}hw_available wm_available UnusedBits1 UnusedBits2 blit_hw blit_hw_CC blit_hw_A blit_sw blit_sw_CC blit_sw_A blit_fill UnusedBits3 video_mem vfmt current_w current_h ; + SDL_BlitMap{}; + private_hwdata{}; + SDL_Color{CCCC}r g b unused ; + SDL_Palette{i*<SDL_Color>}ncolors colors ; + SDL_PixelFormat{*<SDL_Palette>CCCCCCCCCCIIIIIC}palette BitsPerPixel BytesPerPixel Rloss Gloss Bloss Aloss Rshift Gshift Bshift Ashift Rmask Gmask Bmask Amask colorkey alpha ; + SDL_CD{iiiii}id status numtracks cur_track cur_frame track ; + SDL_CDtrack{CCSII}id type unused length offset ; + SDL_AudioCVT{iSSd*Ciiidi}needed src_format dst_format rate_incr buf len len_cvt len_mult len_ratio filters filter_index ; + SDL_AudioSpec{iSCCSSI*p*v}freq format channels silence samples padding size callback userdata ; + " + + + +old <- "SDL_version{CCC}major minor patch ; + _SDL_TimerID{}; + SDL_SysWMEvent{C*<SDL_SysWMmsg>}type msg ; + SDL_SysWMmsg{}; + SDL_UserEvent{Ci*v*v}type code data1 data2 ; + SDL_QuitEvent{C}type ; + SDL_ExposeEvent{C}type ; + SDL_ResizeEvent{Cii}type w h ; + SDL_JoyButtonEvent{CCCC}type which button state ; + SDL_JoyHatEvent{CCCC}type which hat value ; + SDL_JoyBallEvent{CCCss}type which ball xrel yrel ; + SDL_JoyAxisEvent{CCCs}type which axis value ; + SDL_MouseButtonEvent{CCCCSS}type which button state x y ; + SDL_MouseMotionEvent{CCCSSss}type which state x y xrel yrel ; + SDL_KeyboardEvent{CCC<SDL_keysym>}type which state keysym ; + SDL_ActiveEvent{CCC}type gain state ; + _SDL_Joystick{}; + SDL_Cursor{<SDL_Rect>ss*C*C*<WMcursor>}area hot_x hot_y data mask save wm_cursor ; + WMcursor{}; + SDL_Overlay{Iiii*S**<private_yuvhwfuncs>*<private_yuvhwdata>II}format w h planes pitches pixels hwfuncs hwdata hw_overlay UnusedBits ; + private_yuvhwdata{}; + private_yuvhwfuncs{}; + SDL_VideoInfo{IIIIIIIIIIIII*<SDL_PixelFormat>ii}hw_available wm_available UnusedBits1 UnusedBits2 blit_hw blit_hw_CC blit_hw_A blit_sw blit_sw_CC blit_sw_A blit_fill UnusedBits3 video_mem vfmt current_w current_h ; + SDL_Surface{I*<SDL_PixelFormat>iiS*vi*<private_hwdata><SDL_Rect>II*<SDL_BlitMap>Ii}flags format w h pitch pixels offset hwdata clip_rect unused1 locked map format_version refcount ; + SDL_BlitMap{}; + private_hwdata{}; + SDL_PixelFormat{*<SDL_Palette>CCCCCCCCCCIIIIIC}palette BitsPerPixel BytesPerPixel Rloss Gloss Bloss Aloss Rshift Gshift Bshift Ashift Rmask Gmask Bmask Amask colorkey alpha ; + SDL_Palette{i*<SDL_Color>}ncolors colors ; + SDL_Color{CCCC}r g b unused ; + SDL_Rect{ssSS}x y w h ; + SDL_keysym{CiiS}scancode sym mod unicode ; + SDL_CD{iiiii}id status numtracks cur_track cur_frame track ; + SDL_CDtrack{CCSII}id type unused length offset ; + SDL_AudioCVT{iSSd*Ciiidi}needed src_format dst_format rate_incr buf len len_cvt len_mult len_ratio filters filter_index ; + SDL_AudioSpec{iSCCSSI*p*v}freq format channels silence samples padding size callback userdata ; + SDL_RWops{*p*p*p*pI<$_7>}seek read write close type hidden ; + SDL_Thread{}; + SDL_cond{}; + SDL_semaphore{}; + SDL_mutex{}; + _SDL_iconv_t{}; + lldiv_t{ll}quot rem ; + ldiv_t{jj}quot rem ; + div_t{ii}quot rem ; + _iobuf{*ci*ciiii*c}_ptr _cnt _base _flag _file _charbuf _bufsiz _tmpfname ; + $_8{i*v<$_9>}append h buffer ; + $_10{i*<_iobuf>}autoclose fp ; + $_11{*C*C*C}base here stop ; + $_12{*v}data1 ; + $_9{*vii}data size left ; + " + + +.types <- list() + +setStruct <- function(name, ...) +{ + x <- list(...) + class(x) <- c("struct","type") + .types[[name]] <<- x +} + +setUnion <- function(name, ...) +{ + x <- list(...) + class(x) <- c("union","type") + .types[[name]] <<- x +} + +getType <- function(name) +{ + .types[[name]] +} + + +setStruct("SDL_keysym", scancode="C", sym="i", mod="i", unicode="S" ) +setStruct("SDL_KeyboardEvent", type="C", which="C", state="C", keysym="{SDL_keysym}") + +parseTypeSignature("SDL_Event|C<SDL_ActiveEvent><SDL_KeyboardEvent><SDL_MouseMotionEvent><SDL_MouseButtonEvent><SDL_JoyAxisEvent><SDL_JoyBallEvent><SDL_JoyHatEvent><SDL_JoyButtonEvent><SDL_ResizeEvent><SDL_ExposeEvent><SDL_QuitEvent><SDL_UserEvent><SDL_SysWMEvent>|type active key motion button jaxis jball jhat jbutton resize expose quit user syswm ;") + +setUnion("SDL_Event", + type="uchar", + action="SDL_ActiveEvent", + key="SDL_KeyboardEvent", + motion="SDL_MouseMotionEvent", + button="SDL_MouseButtonEvent", + jaxis="SDL_JoyAxisEvent", + jball="SDL_JoyBallEvent", + jbutton="SDL_JoyButtonEvent", + resize="SDL_ResizeEvent", + expose="SDL_ExposeEvent", + quit="SDL_QuitEvent", + user="SDL_UserEvent", + syswm="SDL_SysWMEvent") + +.sizeof <- c( + B=.Machine$sizeof.long, + c=1L, + C=1L, + s=2L, + S=2L, + i=.Machine$sizeof.long, + I=.Machine$sizeof.long, + j=.Machine$sizeof.long, + J=.Machine$sizeof.long, + l=.Machine$sizeof.longlong, + L=.Machine$sizeof.longlong, + f=4L, + d=8L, + "*"=.Machine$sizeof.pointer, + p=.Machine$sizeof.pointer, + x=.Machine$sizeof.pointer, + Z=.Machine$sizeof.pointer, + v=0L +) + +align <- function(start, type) +{ + start %% sizeof(x) +} + +sizeof <- function(x) +{ + first <- substr(x,1,1) + if (first == "<") { + if ( substr(x, nchar(x), nchar(x) ) != ">" ) stop("invalid signature") + typeName <- substr(x,2,nchar(x)-2) + sizeof(getType(typeName)) + } else { + .sizeof[[substr(x, 1,1)]] + } +} + +sizeof.struct <- function(x) +{ + total <- 0L + for(i in x) + { + size <- sizeof(i) + total <- total + total %% size + size + } + return(total) +} + + +sizeof(struct("iii")) +sizeof(union("iii")) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/test.dyp Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,11 @@ +!info +!lib +win32=OpenGL +!funs +a(); +b(); +c(); +!enums +a=a,b,c,d,e,f +b=d,f,g,h,h,f +!funvars
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/test.json Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,39 @@ + +{ + "name": "gl", + "meta": { + } + "bind": { + "libs": { + "windows": "OpenGL", + + }, + + # or + + #"libs": "GL", + + "functions": { + "hallo": "iii)v", + "SDL_SetVideoMode": { "x": "int", "y": "int", "z": "int" } + } + "structures": { + "SDL_Surface": { + "x": "i", + "y": "i", + } + "SDL_Surface{ii<sub>i}x y z;" + }, + "unions": { + "SDL_Event": { + "x": "i", + "y": "i" + } + }, + "enums": { + }, + "defines": { + " + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/test_cstructs.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,6 @@ +sdlLib <- dynload("SDL") +._SDL_SetVideoMode <- sdlLib$SDL_SetVideoMode +._SDL_Init <- sdlLib$SDL_Init +err <- .dyncall.cdecl(._SDL_Init, "i)i", SDL_INIT_VIDEO) +surf <- .dyncall.cdecl(._SDL_SetVideoMode, "iiii)*<SDL_Surface>", 640,480,32,SDL_DOUBLEBUF+SDL_OPENGL) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/test_json.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,20 @@ +library(rjson) + +parseJSON <- function(path) +{ + parser <- newJSONParser() + f <- file(path) + open(f) + while(TRUE) + { + aLine <- readLines(f, 1) + if (length(aLine) == 0) break + parser$addData( aLine ) + } + close(f) + parser$getObject() +} +# TEST: +testfile <- "/lab/eclipse/dyncall/rdyncall/inst/dynports/GL.json" +x <- parseJSON(testfile) +# print(glinfo)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/scratch/win32.R Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,502 @@ +# ---------------------------------------------------------------------------- +# constants + +CS_BYTEALIGNCLIENT = 4096 +CS_BYTEALIGNWINDOW = 8192 +CS_CLASSDC = 64 +CS_DBLCLKS = 8 +CS_DELETE_TRANSFORM = 0x00000003 +CS_DISABLE = 0x00000002 +CS_ENABLE = 0x00000001 +CS_GLOBALCLASS = 16384 +CS_HREDRAW = 2 +CS_IME = 0x10000 +CS_INSERTCHAR = 0x2000 +CS_KEYCVTWINDOW = 4 +CS_NOCLOSE = 512 +CS_NOKEYCVT = 256 +CS_NOMOVECARET = 0x4000 +CS_OWNDC = 32 +CS_PARENTDC = 128 +CS_SAVEBITS = 2048 +CS_VREDRAW = 1 +WM_USER = 1024 +WM_ACTIVATE = 6 +WM_ACTIVATEAPP = 28 +WM_AFXFIRST = 864 +WM_AFXLAST = 895 +WM_APP = 32768 +WM_ASKCBFORMATNAME = 780 +WM_CANCELJOURNAL = 75 +WM_CANCELMODE = 31 +WM_CAPTURECHANGED = 533 +WM_CHANGECBCHAIN = 781 +WM_CHAR = 258 +WM_CHARTOITEM = 47 +WM_CHILDACTIVATE = 34 +WM_CHOOSEFONT_GETLOGFONT = (WM_USER+1) +WM_CHOOSEFONT_SETFLAGS = (WM_USER+102) +WM_CHOOSEFONT_SETLOGFONT = (WM_USER+101) +WM_CLEAR = 771 +WM_CLOSE = 16 +WM_COMMAND = 273 +WM_COMMNOTIFY = 68 +WM_COMPACTING = 65 +WM_COMPAREITEM = 57 +WM_CONTEXTMENU = 123 +WM_CONVERTREQUESTEX = 0x108 +WM_COPY = 769 +WM_COPYDATA = 74 +WM_CREATE = 1 +WM_CTLCOLORBTN = 309 +WM_CTLCOLORDLG = 310 +WM_CTLCOLOREDIT = 307 +WM_CTLCOLORLISTBOX = 308 +WM_CTLCOLORMSGBOX = 306 +WM_CTLCOLORSCROLLBAR = 311 +WM_CTLCOLORSTATIC = 312 +WM_CUT = 768 +WM_DDE_FIRST = 0x03E0 +WM_DDE_ACK = (WM_DDE_FIRST+4) +WM_DDE_ADVISE = (WM_DDE_FIRST+2) +WM_DDE_DATA = (WM_DDE_FIRST+5) +WM_DDE_EXECUTE = (WM_DDE_FIRST+8) +WM_DDE_INITIATE = (WM_DDE_FIRST) +WM_DDE_LAST = (WM_DDE_FIRST+8) +WM_DDE_POKE = (WM_DDE_FIRST+7) +WM_DDE_REQUEST = (WM_DDE_FIRST+6) +WM_DDE_TERMINATE = (WM_DDE_FIRST+1) +WM_DDE_UNADVISE = (WM_DDE_FIRST+3) +WM_DEADCHAR = 259 +WM_DELETEITEM = 45 +WM_DESTROY = 2 +WM_DESTROYCLIPBOARD = 775 +WM_DEVICECHANGE = 537 +WM_DEVMODECHANGE = 27 +WM_DISPLAYCHANGE = 126 +WM_DRAWCLIPBOARD = 776 +WM_DRAWITEM = 43 +WM_DROPFILES = 563 +WM_ENABLE = 10 +WM_ENDSESSION = 22 +WM_ENTERIDLE = 289 +WM_ENTERMENULOOP = 529 +WM_ENTERSIZEMOVE = 561 +WM_ERASEBKGND = 20 +WM_EXITMENULOOP = 530 +WM_EXITSIZEMOVE = 562 +WM_FONTCHANGE = 29 +WM_GETDLGCODE = 135 +WM_GETFONT = 49 +WM_GETHOTKEY = 51 +WM_GETICON = 127 +WM_GETMINMAXINFO = 36 +WM_GETTEXT = 13 +WM_GETTEXTLENGTH = 14 +WM_HANDHELDFIRST = 856 +WM_HANDHELDLAST = 863 +WM_HELP = 83 +WM_HOTKEY = 786 +WM_HSCROLL = 276 +WM_HSCROLLCLIPBOARD = 782 +WM_ICONERASEBKGND = 39 +WM_IME_CHAR = 0x286 +WM_IME_COMPOSITION = 0x10F +WM_IME_COMPOSITIONFULL = 0x284 +WM_IME_CONTROL = 0x283 +WM_IME_ENDCOMPOSITION = 0x10E +WM_IME_KEYDOWN = 0x290 +WM_IME_KEYLAST = 0x10F +WM_IME_KEYUP = 0x291 +WM_IME_NOTIFY = 0x282 +WM_IME_SELECT = 0x285 +WM_IME_SETCONTEXT = 0x281 +WM_IME_STARTCOMPOSITION = 0x10D +WM_INITDIALOG = 272 +WM_INITMENU = 278 +WM_INITMENUPOPUP = 279 +WM_INPUTLANGCHANGE = 81 +WM_INPUTLANGCHANGEREQUEST = 80 +WM_KEYDOWN = 256 +WM_KEYFIRST = 256 +WM_KEYLAST = 264 +WM_KEYUP = 257 +WM_KILLFOCUS = 8 +WM_LBUTTONDBLCLK = 515 +WM_LBUTTONDOWN = 513 +WM_LBUTTONUP = 514 +WM_MBUTTONDBLCLK = 521 +WM_MBUTTONDOWN = 519 +WM_MBUTTONUP = 520 +WM_MDIACTIVATE = 546 +WM_MDICASCADE = 551 +WM_MDICREATE = 544 +WM_MDIDESTROY = 545 +WM_MDIGETACTIVE = 553 +WM_MDIICONARRANGE = 552 +WM_MDIMAXIMIZE = 549 +WM_MDINEXT = 548 +WM_MDIREFRESHMENU = 564 +WM_MDIRESTORE = 547 +WM_MDISETMENU = 560 +WM_MDITILE = 550 +WM_MEASUREITEM = 44 +WM_MENUCHAR = 288 +WM_MENUSELECT = 287 +WM_MOUSEACTIVATE = 33 +WM_MOUSEFIRST = 512 +WM_MOUSEHOVER = 0x2A1 +WM_MOUSELAST = 522 +WM_MOUSELEAVE = 0x2A3 +WM_MOUSEMOVE = 512 +WM_MOUSEWHEEL = 522 +WM_MOVE = 3 +WM_MOVING = 534 +WM_NCACTIVATE = 134 +WM_NCCALCSIZE = 131 +WM_NCCREATE = 129 +WM_NCDESTROY = 130 +WM_NCHITTEST = 132 +WM_NCLBUTTONDBLCLK = 163 +WM_NCLBUTTONDOWN = 161 +WM_NCLBUTTONUP = 162 +WM_NCMBUTTONDBLCLK = 169 +WM_NCMBUTTONDOWN = 167 +WM_NCMBUTTONUP = 168 +WM_NCMOUSEMOVE = 160 +WM_NCPAINT = 133 +WM_NCRBUTTONDBLCLK = 166 +WM_NCRBUTTONDOWN = 164 +WM_NCRBUTTONUP = 165 +WM_NEXTDLGCTL = 40 +WM_NEXTMENU = 531 +WM_NOTIFY = 78 +WM_NOTIFYFORMAT = 85 +WM_NULL = 0 +WM_PAINT = 15 +WM_PAINTCLIPBOARD = 777 +WM_PAINTICON = 38 +WM_PALETTECHANGED = 785 +WM_PALETTEISCHANGING = 784 +WM_PARENTNOTIFY = 528 +WM_PASTE = 770 +WM_PENWINFIRST = 896 +WM_PENWINLAST = 911 +WM_POWER = 72 +WM_POWERBROADCAST = 536 +WM_PRINT = 791 +WM_PRINTCLIENT = 792 +WM_PSD_ENVSTAMPRECT = (WM_USER+5) +WM_PSD_FULLPAGERECT = (WM_USER+1) +WM_PSD_GREEKTEXTRECT = (WM_USER+4) +WM_PSD_MARGINRECT = (WM_USER+3) +WM_PSD_MINMARGINRECT = (WM_USER+2) +WM_PSD_PAGESETUPDLG = WM_USER +WM_PSD_YAFULLPAGERECT = (WM_USER+6) +WM_QUERYDRAGICON = 55 +WM_QUERYENDSESSION = 17 +WM_QUERYNEWPALETTE = 783 +WM_QUERYOPEN = 19 +WM_QUEUESYNC = 35 +WM_QUIT = 18 +WM_RBUTTONDBLCLK = 518 +WM_RBUTTONDOWN = 516 +WM_RBUTTONUP = 517 +WM_RENDERALLFORMATS = 774 +WM_RENDERFORMAT = 773 +WM_SETCURSOR = 32 +WM_SETFOCUS = 7 +WM_SETFONT = 48 +WM_SETHOTKEY = 50 +WM_SETICON = 128 +WM_SETREDRAW = 11 +WM_SETTEXT = 12 +WM_SETTINGCHANGE = 26 +WM_SHOWWINDOW = 24 +WM_SIZE = 5 +WM_SIZECLIPBOARD = 779 +WM_SIZING = 532 +WM_SPOOLERSTATUS = 42 +WM_STYLECHANGED = 125 +WM_STYLECHANGING = 124 +WM_SYNCPAINT = 136 +WM_SYSCHAR = 262 +WM_SYSCOLORCHANGE = 21 +WM_SYSCOMMAND = 274 +WM_SYSDEADCHAR = 263 +WM_SYSKEYDOWN = 260 +WM_SYSKEYUP = 261 +WM_TCARD = 82 +WM_THEMECHANGED = 794 +WM_TIMECHANGE = 30 +WM_TIMER = 275 +WM_UNDO = 772 +WM_USERCHANGED = 84 +WM_VKEYTOITEM = 46 +WM_VSCROLL = 277 +WM_VSCROLLCLIPBOARD = 778 +WM_WINDOWPOSCHANGED = 71 +WM_WINDOWPOSCHANGING = 70 +WM_WININICHANGE = 26 +WS_ACTIVECAPTION = 0x00000001 +WS_BORDER = 0x800000 +WS_CAPTION = 0xc00000 +WS_CHILD = 0x40000000 +WS_CHILDWINDOW = 0x40000000 +WS_CLIPCHILDREN = 0x2000000 +WS_CLIPSIBLINGS = 0x4000000 +WS_DISABLED = 0x8000000 +WS_DLGFRAME = 0x400000 +WS_EX_ACCEPTFILES = 16 +WS_EX_APPWINDOW = 0x40000 +WS_EX_CLIENTEDGE = 512 +WS_EX_COMPOSITED = 0x2000000 +WS_EX_CONTEXTHELP = 0x400 +WS_EX_CONTROLPARENT = 0x10000 +WS_EX_DLGMODALFRAME = 1 +WS_EX_LAYERED = 0x80000 +WS_EX_LAYOUTRTL = 0x400000 +WS_EX_LEFT = 0 +WS_EX_LEFTSCROLLBAR = 0x4000 +WS_EX_LTRREADING = 0 +WS_EX_MDICHILD = 64 +WS_EX_NOACTIVATE = 0x8000000 +WS_EX_NOINHERITLAYOUT = 0x100000 +WS_EX_NOPARENTNOTIFY = 4 +WS_EX_OVERLAPPEDWINDOW = 0x300 +WS_EX_PALETTEWINDOW = 0x188 +WS_EX_RIGHT = 0x1000 +WS_EX_RIGHTSCROLLBAR = 0 +WS_EX_RTLREADING = 0x2000 +WS_EX_STATICEDGE = 0x20000 +WS_EX_TOOLWINDOW = 128 +WS_EX_TOPMOST = 8 +WS_EX_TRANSPARENT = 32 +WS_EX_WINDOWEDGE = 256 +WS_GROUP = 0x20000 +WS_HSCROLL = 0x100000 +WS_ICONIC = 0x20000000 +WS_MAXIMIZE = 0x1000000 +WS_MAXIMIZEBOX = 0x10000 +WS_MINIMIZE = 0x20000000 +WS_MINIMIZEBOX = 0x20000 +WS_OVERLAPPED = 0 +WS_OVERLAPPEDWINDOW = 0xcf0000 +WS_POPUP = 0x80000000 +WS_POPUPWINDOW = 0x80880000 +WS_SIZEBOX = 0x40000 +WS_SYSMENU = 0x80000 +WS_TABSTOP = 0x10000 +WS_THICKFRAME = 0x40000 +WS_TILED = 0 +WS_TILEDWINDOW = 0xcf0000 +WS_VISIBLE = 0x10000000 +WS_VSCROLL = 0x200000 +SM_ARRANGE = 56 +SM_CLEANBOOT = 67 +SM_CMETRICS = 88 +SM_CMONITORS = 80 +SM_CMOUSEBUTTONS = 43 +SM_CXBORDER = 5 +SM_CXCURSOR = 13 +SM_CXDLGFRAME = 7 +SM_CXDOUBLECLK = 36 +SM_CXDRAG = 68 +SM_CXEDGE = 45 +SM_CXFIXEDFRAME = 7 +SM_CXFOCUSBORDER = 83 +SM_CXFRAME = 32 +SM_CXFULLSCREEN = 16 +SM_CXHSCROLL = 21 +SM_CXHTHUMB = 10 +SM_CXICON = 11 +SM_CXICONSPACING = 38 +SM_CXMAXIMIZED = 61 +SM_CXMAXTRACK = 59 +SM_CXMENUCHECK = 71 +SM_CXMENUSIZE = 54 +SM_CXMIN = 28 +SM_CXMINIMIZED = 57 +SM_CXMINSPACING = 47 +SM_CXMINTRACK = 34 +SM_CXSCREEN = 0 +SM_CXSIZE = 30 +SM_CXSIZEFRAME = 32 +SM_CXSMICON = 49 +SM_CXSMSIZE = 52 +SM_CXVIRTUALSCREEN = 78 +SM_CXVSCROLL = 2 +SM_CYBORDER = 6 +SM_CYCAPTION = 4 +SM_CYCURSOR = 14 +SM_CYDLGFRAME = 8 +SM_CYDOUBLECLK = 37 +SM_CYDRAG = 69 +SM_CYEDGE = 46 +SM_CYFIXEDFRAME = 8 +SM_CYFOCUSBORDER = 84 +SM_CYFRAME = 33 +SM_CYFULLSCREEN = 17 +SM_CYHSCROLL = 3 +SM_CYICON = 12 +SM_CYICONSPACING = 39 +SM_CYKANJIWINDOW = 18 +SM_CYMAXIMIZED = 62 +SM_CYMAXTRACK = 60 +SM_CYMENU = 15 +SM_CYMENUCHECK = 72 +SM_CYMENUSIZE = 55 +SM_CYMIN = 29 +SM_CYMINIMIZED = 58 +SM_CYMINSPACING = 48 +SM_CYMINTRACK = 35 +SM_CYSCREEN = 1 +SM_CYSIZE = 31 +SM_CYSIZEFRAME = 33 +SM_CYSMCAPTION = 51 +SM_CYSMICON = 50 +SM_CYSMSIZE = 53 +SM_CYVIRTUALSCREEN = 79 +SM_CYVSCROLL = 20 +SM_CYVTHUMB = 9 +SM_DBCSENABLED = 42 +SM_DEBUG = 22 +SM_IMMENABLED = 82 +SM_MEDIACENTER = 87 +SM_MENUDROPALIGNMENT = 40 +SM_MIDEASTENABLED = 74 +SM_MOUSEPRESENT = 19 +SM_MOUSEWHEELPRESENT = 75 +SM_NETWORK = 63 +SM_PENWINDOWS = 41 +SM_REMOTESESSION = 0X1000 +SM_RESERVED1 = 24 +SM_RESERVED2 = 25 +SM_RESERVED3 = 26 +SM_RESERVED4 = 27 +SM_SAMEDISPLAYFORMAT = 81 +SM_SECURE = 44 +SM_SERVERR2 = 89 +SM_SHOWSOUNDS = 70 +SM_SLOWMACHINE = 73 +SM_STARTER = 88 +SM_SWAPBUTTON = 23 +SM_TABLETPC = 86 +SM_XVIRTUALSCREEN = 76 +SM_YVIRTUALSCREEN = 77 +AF_12844 = 25 +AF_APPLETALK = 16 +AF_ATM = 22 +AF_BAN = 21 +AF_CCITT = 10 +AF_CHAOS = 5 +AF_CLUSTER = 24 +AF_DATAKIT = 9 +AF_DECnet = 12 +AF_DLI = 13 +AF_ECMA = 8 +AF_FIREFOX = 19 +AF_HYLINK = 15 +AF_IMPLINK = 3 +AF_INET = 2 +AF_INET6 = 23 +AF_IPX = 6 +AF_IRDA = 26 +AF_ISO = 7 +AF_LAT = 14 +AF_MAX = 29 +AF_NETBIOS = 17 +AF_NETDES = 28 +AF_NS = 6 +AF_OSI = AF_ISO +AF_PUP = 4 +AF_SNA = 11 +AF_UNIX = 1 +AF_UNKNOWN1 = 20 +AF_UNSPEC = 0 +AF_VOICEVIEW = 18 +COLOR_3DDKSHADOW = 21 +COLOR_3DFACE = 15 +COLOR_3DHIGHLIGHT = 20 +COLOR_3DHILIGHT = 20 +COLOR_3DLIGHT = 22 +COLOR_3DSHADOW = 16 +COLOR_ACTIVEBORDER = 10 +COLOR_ACTIVECAPTION = 2 +COLOR_ADJ_MAX = 100 +COLOR_ADJ_MIN = (-100) +COLOR_APPWORKSPACE = 12 +COLOR_BACKGROUND = 1 +COLOR_BTNFACE = 15 +COLOR_BTNHIGHLIGHT = 20 +COLOR_BTNHILIGHT = 20 +COLOR_BTNSHADOW = 16 +COLOR_BTNTEXT = 18 +COLOR_CAPTIONTEXT = 9 +COLOR_DESKTOP = 1 +COLOR_GRADIENTACTIVECAPTION = 27 +COLOR_GRADIENTINACTIVECAPTION = 28 +COLOR_GRAYTEXT = 17 +COLOR_HIGHLIGHT = 13 +COLOR_HIGHLIGHTTEXT = 14 +COLOR_HOTLIGHT = 26 +COLOR_INACTIVEBORDER = 11 +COLOR_INACTIVECAPTION = 3 +COLOR_INACTIVECAPTIONTEXT = 19 +COLOR_INFOBK = 24 +COLOR_INFOTEXT = 23 +COLOR_MENU = 4 +COLOR_MENUTEXT = 7 +COLOR_SCROLLBAR = 0 +COLOR_WINDOW = 5 +COLOR_WINDOWFRAME = 6 +COLOR_WINDOWTEXT = 8 +# ---------------------------------------------------------------------------- +# types + +types <- c( +UINT='i', +WNDPROC='p', +int='i', +HINSTANCE='p', +HICON='p', +HCURSOR='p', +HBRUSH='p', +LPCTSTR='S', +LPCTSTR='S', +void='v' +) + +# ---------------------------------------------------------------------------- +# structures + +WNDCLASSEXA <- structinfo(" + UINT cbSize; + UINT style; + WNDPROC lpfnWndProc; + int cbClsExtra; + int cbWndExtra; + HINSTANCE hInstance; + HICON hIcon; + HCURSOR hCursor; + HBRUSH hbrBackground; + LPCTSTR lpszMenuName; + LPCTSTR lpszClassName; + HICON hIconSm; +", types) + +# ---------------------------------------------------------------------------- +# functions + +.kernel32 <- dynbind("kernel32"," + GetTickCount()i; + GetLastError()i; +",callmode="stdcall") + +.user32 <- dynbind("user32"," + RegisterClassExA(p)n; + CreateWindowExA(iSSiiiiipppp)p; + DefWindowProcA(pppp)p; +",callmode="stdcall") + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/R/sdl.rnw Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,244 @@ +% \VignetteIndexEntry{Multimedia programming with R, rdyncall, libSDL and OpenGL} +% \VignetteKeyword{low-level} +% \VignetteKeyword{rdyncall} +% \VignetteKeyword{dyncall} +% \VignetteKeyword{multimedia} +\documentclass{article} +\usepackage{url} +\begin{document} +\title{Multimedia programming with R, rdyncall, libSDL and OpenGL} +\author{Daniel Adler} +\maketitle +\section{Introduction} + +Via the rdyncall package it is possible to write system-level +software in R. In this vignette we focus on multimedia programming +in R using the SDL and OpenGL shared libraries. +This vignette describes several issues involved in using the rdyncall +package with C level interfaces of OpenGL and SDL. This text is +not at all a reference to OpenGL or SDL. There are other much better +text books and tutorials available. + +See \url{http://www.libsdl.org} and \url{http://www.opengl.org} for further +links to tutorials. + +\section{Dynamic R bindings of shared libraries} + +Initially, one needs to dynamically link SDL, OpenGL and OpenGL Utility +Library to the R session. +This can be done using the rdyncall package and the dynports. + +<<>>= +library(rdyncall) +dynport(SDL) +dynport(GL) +dynport(GLU) +@ + +\section{Initialize SDL} + +We need to initialize the SDL library using the \verb@SDL_Init()@ function +giving a bitmask of subsystems to be enabled (such as Video, Audio, Joystick etc.). + +<<>>= +subsystems <- SDL_INIT_VIDEO +SDL_Init(subsystems) +@ + +The variable subsystem is a bitmask encoded in a double constant, also +the C API expects to have an unsigned int. rdyncall cares for a correct +coercion to unsigned int. By addition of several double constants, +we can initialize multiple subsystems. + +To see what subsystems SDL offers, we can explore the SDL dynport using e.g. +the apropos base R command: + +<<>>= +apropos("SDL_INIT_") +@ + +\section{Opening an SDL/OpenGL Video Surface} + +Let us open a new OpenGL Display using \verb@SDL_SetVideoMode()@. The parameters are: + +\begin{description} +\item[width] The width in pixel. +\item[height] The height in pixel +\item[bpp] +\item[flags] Bit flags to be combined with '+'. \verb@SDL_OPENGL@ and \verb@SDL_DOUBLEBUF@ are typical for OpenGL real-time applications. +\end{description} + +Some useful Flags: + +\begin{description} +\item[SDL\_OPENGL] Request an OpenGL context to be initialized for this surfacce. +\item[SDL\_DOUBLEBUF] Rendering into a back buffer and allow to flip the surfaces in one shot. +\item[SDL\_FULLSCREEN] Put the display in fullscreen mode. +\end{description} + +<<eval=FALSE>>= +width <- 640 +height <- 480 +bitsperpixel <- 32 +flags <- SDL_OPENGL+SDL_DOUBLEBUF +surface <- SDL_SetVideoMode(width,height,bitsperpixel,flags) +@ + +The surface object can be printed in R: + +<<eval=FALSE>>= +print(surface) +@ + +\section{Clear the screen and update} + +To clear the display with a constant color value, one needs to specifying the +\emph{clear color} first and then clear the \emph{color buffer}. + +<<eval=FALSE>>= +glClearColor(0.1,0.2,0.3,0.0) +glClear(GL_COLOR_BUFFER_BIT) +@ + +To see the results, we need to flip the surface - all operations in +\emph{double buffering} graphics mode are done in the back and will +be presented in one shot to prevent semi-finished drawing artefacts. + +<<eval=FALSE>>= +SDL_GL_SwapBuffers() +@ + +\section{Writing the mainloop} + +This was interactive, but SDL and OpenGL are designed for writing +multimedia applications and we do this in R. + +These types of applications run a simple loop such as the interactive +loop of R (read-evaluate-print loop). +The loop will run until the application should quit. A reference play time +will be computed for each loop iteration using \verb@SDL_GetTicks()@ (divided by 1000 +gives seconds). +We will clear our display using a blinking color which changes intensity from +black to a specified color. We drop the loop after 3 seconds. + +<<eval=FALSE>>= +blinkspeed <- 2.0 + +draw <- function(t) { + intensity <- t %% blinkspeed / blinkspeed + glClearColor(0.8*intensity,0.6*intensity,1.0*intensity,0.0) + glClear(GL_COLOR_BUFFER_BIT) +} + +mainloop <- function() +{ + quit <- FALSE + + starttime <- SDL_GetTicks() / 1000 + + playtime <- 0 + while(!quit) { + # blink the screen using an intensity blending from 0 to 1 + + draw(playtime) + + SDL_GL_SwapBuffers() + + # update playtime: + now <- SDL_GetTicks() / 1000.0 + playtime <- now - starttime + + # stop after three seconds + if (playtime > 3.0) quit <- TRUE + } +} +# run the loop +mainloop() +@ + +\section{Rendering 3D graphics} + +To render a 3D scene, one specifies the 3D projection first, sets up the +camera position in space and then specifies the positions and primitive +geometries such as points, lines and triangles. + +First we specify the attributes of our virtual camera, that is +the field of view angle, the aspect ratio between width and height (which +should match the one of our surface) and the near and far z-plane orthogonal +to the camera center projection vector. + +<<eval=FALSE>>= +setupProjection <- function() +{ + glMatrixMode(GL_PROJECTION) + glLoadIdentity() + fovy <- 60.0 + aspect <- width / height + znear <- 10 + zfar <- 100 + gluPerspective(fovy, aspect, znear, zfar) +} +@ + +Next, we need to setup the position of our camera in space using +the gluLookAt API which gets three vectors eye, center and up. + +<<eval=FALSE>>= +setupCamera <- function(eye=c(0,0,-2),center=c(0,0,0),up=c(0,1,0)) +{ + glMatrixMode(GL_MODELVIEW) + glLoadIdentity() + gluLookAt(eye[[1]],eye[[2]],eye[[3]],center[[1]],center[[2]],center[[3]],up[[1]],up[[2]],up[[3]]) +} +@ + +What follows is a short routine to draw a million 3D coordinates generated +by rnorm. + +<<eval=FALSE>>= +draw <- function() +{ + npoints <- 1000000 + dims <- 3 + data <- rnorm(npoints*dims) + type <- GL_DOUBLE + stride <- 0 + glEnableClientState(GL_VERTEX_ARRAY_POINTER) + glVertexPointer(dims,type,stride,data) + stgrtindex <- 0 + glDrawArrays(GL_POINTS, startindex, npoints) + glDisableClientState(GL_VERTEX_ARRAY_POINTER) +} +@ + +\section{Handling User-Input Events} + +We will exchange the default behaviour of stopping after three seconds +with processing user-input events such as mouse, keyboard and joystick input +or pressing the close window button. + +SDL uses a C structure to report user-interface events. One calls +a function called \verb@SDL_PollEvent()@ given the reference of this structure. + +<<eval=FALSE>>= +processEvents <- function(env) +{ + evt <- new.struct(SDL_Event) + quit <- FALSE + while(!quit) { + while( SDL_PollEvent(evt) ) { + type <- evt$type + if (type == SDL_QUIT) { + env$quit <- TRUE + } else if (type == SDL_MOUSEMOTION) { + motion <- evt$motion + cat(motion$xrel,",",motion$yrel,"\n") + } + } + } +} +@ + +\end{document} + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/README.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,56 @@ +This document intends to layout a style to follow for language bindings, +depending on the nature of the language. + + +Naming +------ + +If possible and no name clashes exist with other bindings, use the language's +shortest name or file suffix and append 'dc' or 'dyncall'. E.g.: + Ruby: rbdc + Go: godc + ... + + +Code style +---------- + +* Imperative: + + - Object oriented or prototype: + + Create 2 objects, one as a handle to each external library (e.g. extlib), one as a handle to a callvm + + - Without objects: + + Wrap dyncall as close as direct + + - Statically typed (and no direct way wrap types in a generic way and or RTTI): + + Expose all dcArg, etc. calls + Expose formatted call ('...') if possible, but as ArgF (instead of CallF), b/c return type is statically typed + + - with RTTI: + + Write a single call function and let users pass arguments, directly - if needed for type-conversion, this + should be done via call signature + + + +* Functional: + + @@@ ToDo + + + +* Other language features + + - Namespaces/modules/packages + + Use and name dyncall or dc (@@@ choose one) + Use casing depending on language requirements (e.g. 'Dyncall' for ruby as modules are const) + + - Function overloading or default arguments + + Use if available to define things like CallVM stack size; use independently named functions, otherwise +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/erlang/erldc/Makefile Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,73 @@ +# ERLANG_INC is used for -I, below, so add paths where it might be on linux, freebsd, etc. +ERLANG_INC=-I /usr/lib64/erlang/usr/include -I /usr/local/lib/erlang/usr/include +DYNCALL_SRC_PATH=../../../dyncall + +# Be sure to 'make clean' after changing the version +VERSION=0.1 + +OUTPUTS = priv/erldc.so ebin/dyncall.beam ebin/erldc.app + +# Used by install target. Default empty DESTDIR is for a real install to root filesystem (/). +# Override DESTDIR for testing or for a staged install +DESTDIR= +ERLANG_INST_DIR=/usr/lib64/erlang + +all: $(OUTPUTS) + +priv/erldc.so: c_src/dyncallnif.c + [ -d priv ] || mkdir priv + cc -o $@ -fPIC -shared \ + $(ERLANG_INC) -I $(DYNCALL_SRC_PATH) \ + $(DYNCALL_SRC_PATH)/dyncall/*.o \ + c_src/dyncallnif.c + +priv/erldc_testtargets.so: c_src/erldctesttargets.c + [ -d priv ] || mkdir priv + cc -o $@ -shared -fPIC c_src/erldctesttargets.c + +ebin/dyncall.beam: src/dyncall.erl + erlc +debug_info -o ebin src/dyncall.erl + +ebin/erldc.app: src/erldc.app.src + sed -e 's/---VERSION---/$(VERSION)/' src/erldc.app.src >$@ + +# Dialyzer, credit to erlang.mk +DIALYZER_OPTS ?= -Werror_handling -Wrace_conditions \ + -Wunmatched_returns # -Wunderspecs + +build-plt: + rm -f test/*.beam + dialyzer --build_plt --output_plt dyncall.plt \ + --apps erts kernel stdlib . + +dialyze: $(OUTPUTS) + dialyzer --src src --plt dyncall.plt --no_native $(DIALYZER_OPTS) + +tests: $(OUTPUTS) priv/erldc_testtargets.so + mkdir -p log + # Add priv to runtime ld path so we get test targets + export LD_LIBRARY_PATH=$$(pwd)/priv:${LD_LIBRARY_PATH}; \ + ct_run -pa ebin -logdir log \ + -suite linkload_SUITE call_SUITE \ + misc_SUITE callf_SUITE + rm -f test/*.beam + +clean: + rm -rf priv ebin/* test/*.beam log + +# Convention appears to be install binaries and source, but not tests or build-related things +install: $(OUTPUTS) + appdir=$(DESTDIR)$(ERLANG_INST_DIR)/lib/erldc-$(VERSION); \ + install -d $$appdir $$appdir/ebin $$appdir/priv $$appdir/src $$appdir/c_src $$appdir/include; \ + install README.txt $$appdir; \ + install src/*.erl $$appdir/src; \ + install include/*.hrl $$appdir/include; \ + install c_src/*.c $$appdir/c_src; \ + install ebin/* $$appdir/ebin; \ + install priv/erldc.so $$appdir/priv + +uninstall: + appdir=$(DESTDIR)$(ERLANG_INST_DIR)/lib/erldc-$(VERSION); \ + rm -rf $$appdir + +.PHONY: clean all tests build-plt dialyze install uninstall
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/erlang/erldc/README.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,39 @@ +BUILDING +======== + +To build erldc: + + make DYNCALL_SRC_PATH=../dyncall ERLANG_INST_DIR=/erlang/in/this/dir all + sudo make ERLANG_INST_DIR=/erlang/in/this/dir install + +Erlang doesn't use pkg-config, so you must specify ERLANG_INC (and +ERLANG_INST_DIR at install-time). + +The makefile is meant to be portable, at least across *nix. + +RUNNING TESTS +============= + +Unit tests (via common test): + + make tests + +Static analysis (via dialyzer): + + make build-plt + make dialyze + +USING +===== +Examine the test suites for several examples. + +Dyncall is built as an OTP library application, so there's nothing +to start or stop. + +TODO +==== + + +AUTHORS +======= +Erik Mackdanz <erikmack@gmail.com>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/erlang/erldc/c_src/dyncallnif.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,690 @@ +/* + Copyright (c) 2014 Erik Mackdanz <erikmack@gmail.com> + + Permission to use, copy, modify, and distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, 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. +*/ + +#include "erl_nif.h" +#include "dyncall/dyncall.h" +#include "dyncall/dyncall_signature.h" + +#include <string.h> +#include <stdio.h> + +/************ Begin NIF initialization *******/ + +#define MAX_LIBPATH_SZ 128 +#define MAX_SYMBOL_NAME_SZ 32 +#define MAX_FORMAT_STRING_SZ 100 +#define MAX_STRING_ARG_SZ 1024 + +ErlNifResourceType *g_ptrrestype, *g_vmrestype; + +static void noop_dtor(ErlNifEnv* env, void* obj) { + // When erlang gc's a ptr, no-op since we can't know how to free it. + // Likewise with symbols, etc. +} +static void vm_dtor(ErlNifEnv* env, void* obj) { + void** ptr = (void**)obj; + dcFree(*ptr); +} + +static int nifload(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) { + + // Allows us to have a native pointer (to vm, lib, symbol, or user-defined) and + // pass a safe opaque handle into erlang + g_ptrrestype = enif_open_resource_type(env,"dyncall","pointer", + noop_dtor,ERL_NIF_RT_CREATE, + NULL); + + // Works like g_ptrrestype, but requires a dtor that calls dcFree + g_vmrestype = enif_open_resource_type(env,"dyncall","vmpointer", + vm_dtor,ERL_NIF_RT_CREATE, + NULL); + + return 0; +} + +/************ End NIF initialization *******/ + +#define ATOM_OK "ok" +#define ATOM_ERROR "error" + +#define ATOM_LIB_NOT_FOUND "lib_not_found" +#define ATOM_SYMBOL_NOT_FOUND "symbol_not_found" +#define ATOM_BADSZ "bad_vm_size" +#define ATOM_INVALID_VM "invalid_vm" +#define ATOM_INVALID_LIB "invalid_lib" +#define ATOM_INVALID_SYMBOL "invalid_symbol" +#define ATOM_INVALID_FORMAT "invalid_format" +#define ATOM_INVALID_ARG "invalid_arg" +#define ATOM_NOT_IMPLEMENTED "not_implemented" + +static ERL_NIF_TERM new_call_vm(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + + long vmsz = 0; + if(!enif_get_long(env, argv[0], &vmsz)) { + return enif_make_tuple2(env, + enif_make_atom(env,ATOM_ERROR), + enif_make_atom(env,ATOM_BADSZ) + ); + } + + DCCallVM* vm = dcNewCallVM( vmsz ); + + size_t sz = sizeof(DCCallVM*); + DCpointer ptr_persistent_vm = enif_alloc_resource(g_vmrestype,sz); + memcpy(ptr_persistent_vm,&vm,sz); + ERL_NIF_TERM retterm = enif_make_resource(env,ptr_persistent_vm); + enif_release_resource(ptr_persistent_vm); + + return enif_make_tuple2(env, + enif_make_atom(env,ATOM_OK), + retterm + ); +} + +#define MAYBE_RET_BAD_STRING_ARG(indexvar,argi,limit,retatom) \ + char indexvar[limit]; \ + indexvar[limit-1] = 0; \ + if(enif_get_string(env, argv[argi], indexvar, limit, ERL_NIF_LATIN1) <= 0) { \ + return enif_make_tuple2(env, \ + enif_make_atom(env,ATOM_ERROR), \ + enif_make_atom(env,retatom) \ + ); \ + } + +#define RETURN_ERROR(code) return enif_make_tuple2(env, \ + enif_make_atom(env,ATOM_ERROR), \ + enif_make_atom(env,code) \ + ); + +static ERL_NIF_TERM load_library(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + MAYBE_RET_BAD_STRING_ARG(path,0,MAX_LIBPATH_SZ,ATOM_INVALID_LIB) + + void* libptr = enif_dlopen(path, NULL, NULL); + + // Error if dlLoadLibrary returned NULL + if(!libptr) RETURN_ERROR(ATOM_LIB_NOT_FOUND) + + size_t sz = sizeof(void*); + DCpointer ptr_persistent_lib = enif_alloc_resource(g_ptrrestype,sz); + memcpy(ptr_persistent_lib,&libptr,sz); + ERL_NIF_TERM retterm = enif_make_resource(env,ptr_persistent_lib); + enif_release_resource(ptr_persistent_lib); + + return enif_make_tuple2(env, + enif_make_atom(env,ATOM_OK), + retterm + ); +} + +static ERL_NIF_TERM find_symbol(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + MAYBE_RET_BAD_STRING_ARG(path,1,MAX_SYMBOL_NAME_SZ,ATOM_INVALID_SYMBOL) + + void** libptr; + if(!enif_get_resource(env, argv[0], g_ptrrestype, (void**)&libptr)) RETURN_ERROR(ATOM_INVALID_LIB) + + void* symptr = enif_dlsym(*libptr,path,NULL,NULL); + + size_t sz = sizeof(void*); + DCpointer ptr_persistent_symbol = enif_alloc_resource(g_ptrrestype,sz); + memcpy(ptr_persistent_symbol,&symptr,sz); + ERL_NIF_TERM retterm = enif_make_resource(env,ptr_persistent_symbol); + enif_release_resource(ptr_persistent_symbol); + + // Error if enif_dlsym returned NULL + if(!symptr) RETURN_ERROR(ATOM_SYMBOL_NOT_FOUND) + + return enif_make_tuple2(env, + enif_make_atom(env,ATOM_OK), + retterm + ); +} + +#define BOOL_BUF_SZ 6 +#define ATOM_TRUE "true" +#define ATOM_FALSE "false" + +static void exec_call(ErlNifEnv* env, void* vm, void* sym, char rettype,ERL_NIF_TERM *retvalue, char** error_atom) { + if(!sym) { + *error_atom = ATOM_INVALID_SYMBOL; + return; + } + + DCpointer pret; + DCfloat fret; + DCdouble dret; + DCint iret; + DCbool bret; + DCshort sret; + DClong lret; + DClonglong llret; + + char* tmpstr; + size_t sz; + DCpointer ptr_persistent; + + switch(rettype) { + case DC_SIGCHAR_VOID: + dcCallVoid(vm,sym); + return; + case DC_SIGCHAR_BOOL: + bret = dcCallBool(vm,sym); + tmpstr = bret ? ATOM_TRUE : ATOM_FALSE; + *retvalue = enif_make_atom(env,tmpstr); + return; + case DC_SIGCHAR_CHAR: + iret = dcCallChar(vm,sym); + *retvalue = enif_make_int(env,(char)iret); + return; + case DC_SIGCHAR_UCHAR: + iret = dcCallChar(vm,sym); + *retvalue = enif_make_int(env,(unsigned char)iret); + return; + case DC_SIGCHAR_SHORT: + sret = dcCallShort(vm,sym); + *retvalue = enif_make_int(env,sret); + return; + case DC_SIGCHAR_USHORT: + sret = dcCallShort(vm,sym); + *retvalue = enif_make_int(env,(unsigned short)sret); + return; + case DC_SIGCHAR_INT: + iret = dcCallInt(vm,sym); + *retvalue = enif_make_int(env,iret); + return; + case DC_SIGCHAR_UINT: + iret = dcCallInt(vm,sym); + *retvalue = enif_make_int(env,(unsigned int)iret); + return; + case DC_SIGCHAR_LONG: + lret = dcCallLong(vm,sym); + *retvalue = enif_make_long(env,lret); + return; + case DC_SIGCHAR_ULONG: + lret = dcCallLong(vm,sym); + *retvalue = enif_make_long(env,(unsigned long)lret); + return; + case DC_SIGCHAR_LONGLONG: + llret = dcCallLongLong(vm,sym); + *retvalue = enif_make_int64(env,llret); + return; + case DC_SIGCHAR_ULONGLONG: + llret = dcCallLongLong(vm,sym); + *retvalue = enif_make_int64(env,(unsigned long long)llret); + return; + case DC_SIGCHAR_FLOAT: + fret = dcCallFloat(vm,sym); + *retvalue = enif_make_double(env,fret); + return; + case DC_SIGCHAR_DOUBLE: + dret = dcCallDouble(vm,sym); + *retvalue = enif_make_double(env,dret); + return; + case DC_SIGCHAR_POINTER: + pret = dcCallPointer(vm,sym); + sz = sizeof(DCpointer); + + ptr_persistent = enif_alloc_resource(g_ptrrestype,sz); + memcpy(ptr_persistent,&pret,sz); + *retvalue = enif_make_resource(env,ptr_persistent); + enif_release_resource(ptr_persistent); + return; + case DC_SIGCHAR_STRING: + pret = dcCallPointer(vm,sym); + *retvalue = enif_make_string(env,pret,ERL_NIF_LATIN1); + break; + case DC_SIGCHAR_STRUCT: + *error_atom=ATOM_NOT_IMPLEMENTED; + return; + default: + *error_atom=ATOM_INVALID_FORMAT; + return; + } +} + + +static void exec_arg(ErlNifEnv* env,void* vm,char argtype,ERL_NIF_TERM argterm,char** error_atom) { + char carg; + long int larg = -1; + int iarg = -1; + char sarg[MAX_STRING_ARG_SZ]; + double darg = -1.0; + char barg[BOOL_BUF_SZ]; + ErlNifSInt64 llarg = -1; + void** parg; + + switch(argtype) { + case DC_SIGCHAR_BOOL: + if(!enif_get_atom(env, argterm, barg, BOOL_BUF_SZ, ERL_NIF_LATIN1)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgBool(vm,!strcmp(barg,ATOM_TRUE)); + break; + case DC_SIGCHAR_CHAR: + if(!enif_get_int(env, argterm, &iarg)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgChar(vm,(char)iarg); + break; + case DC_SIGCHAR_UCHAR: + if(!enif_get_int(env, argterm, &iarg)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgInt(vm,(unsigned char)iarg); + break; + case DC_SIGCHAR_SHORT: + if(!enif_get_int(env, argterm, &iarg)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgShort(vm,(short)iarg); + break; + case DC_SIGCHAR_USHORT: + if(!enif_get_int(env, argterm, &iarg)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgShort(vm,(unsigned short)iarg); + break; + case DC_SIGCHAR_INT: + if(!enif_get_int(env, argterm, &iarg)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgInt(vm,iarg); + break; + case DC_SIGCHAR_UINT: + if(!enif_get_int(env, argterm, &iarg)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgInt(vm,(unsigned int)iarg); + break; + case DC_SIGCHAR_LONG: + if(!enif_get_long(env, argterm, &larg)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgLong(vm,larg); + break; + case DC_SIGCHAR_ULONG: + if(!enif_get_long(env, argterm, &larg)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgLong(vm,(unsigned long)larg); + break; + case DC_SIGCHAR_LONGLONG: + if(!enif_get_int64(env, argterm, &llarg)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgLongLong(vm,llarg); + break; + case DC_SIGCHAR_ULONGLONG: + if(!enif_get_int64(env, argterm, &llarg)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgLongLong(vm,(unsigned long long)llarg); + break; + case DC_SIGCHAR_FLOAT: + if(!enif_get_double(env, argterm, &darg)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgFloat(vm,(float)darg); + break; + case DC_SIGCHAR_DOUBLE: + if(!enif_get_double(env, argterm, &darg)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgDouble(vm,darg); + break; + case DC_SIGCHAR_POINTER: + if(!enif_get_resource(env, argterm, g_ptrrestype, (void**)&parg)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgPointer(vm,*parg); + break; + case DC_SIGCHAR_STRING: + if(!enif_get_string(env, argterm, sarg, MAX_STRING_ARG_SZ, ERL_NIF_LATIN1)) { + *error_atom = ATOM_INVALID_ARG; + return; + } + dcArgPointer(vm,sarg); + break; + case DC_SIGCHAR_STRUCT: + *error_atom = ATOM_NOT_IMPLEMENTED; + return; + default: + *error_atom = ATOM_INVALID_FORMAT; + return; + } +} + +#define GET_VM void** vmptr; \ + if(!enif_get_resource(env, argv[0], g_vmrestype, (void**)&vmptr)) RETURN_ERROR(ATOM_INVALID_VM); \ + if(!*vmptr) RETURN_ERROR(ATOM_INVALID_VM); + +#define GET_SYM void** symptr; \ + if(!enif_get_resource(env, argv[1], g_ptrrestype, (void**)&symptr)) RETURN_ERROR(ATOM_INVALID_ARG); + +#define EXEC_CALL(typechar) ERL_NIF_TERM retvalue; \ + char* error_atom = NULL; \ + exec_call(env,*vmptr,*symptr,typechar,&retvalue,&error_atom); + +#define MAKE_CALL_RETURN if(error_atom) RETURN_ERROR(error_atom); \ + return enif_make_tuple2(env, \ + enif_make_atom(env,ATOM_OK), \ + retvalue \ + ); + +#define EXEC_ARG(typechar) char* error_atom = NULL; \ + exec_arg(env,*vmptr,typechar,argv[1],&error_atom); + +#define MAKE_ARG_RETURN if(error_atom) RETURN_ERROR(error_atom); \ + return enif_make_atom(env,ATOM_OK); + + +static ERL_NIF_TERM arg_double(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + EXEC_ARG(DC_SIGCHAR_DOUBLE); + MAKE_ARG_RETURN; +} + +static ERL_NIF_TERM call_double(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + GET_SYM; + EXEC_CALL(DC_SIGCHAR_DOUBLE); + MAKE_CALL_RETURN; +} + +static ERL_NIF_TERM arg_float(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + EXEC_ARG(DC_SIGCHAR_FLOAT); + MAKE_ARG_RETURN; +} + +static ERL_NIF_TERM call_float(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + GET_SYM; + EXEC_CALL(DC_SIGCHAR_FLOAT); + MAKE_CALL_RETURN; +} + +static ERL_NIF_TERM arg_int(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + EXEC_ARG(DC_SIGCHAR_INT); + MAKE_ARG_RETURN; +} + +static ERL_NIF_TERM call_int(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + GET_SYM; + EXEC_CALL(DC_SIGCHAR_INT); + MAKE_CALL_RETURN; +} + +static ERL_NIF_TERM arg_char(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + EXEC_ARG(DC_SIGCHAR_CHAR); + MAKE_ARG_RETURN; +} + +static ERL_NIF_TERM call_char(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + GET_SYM; + EXEC_CALL(DC_SIGCHAR_CHAR); + MAKE_CALL_RETURN; +} + +static ERL_NIF_TERM arg_bool(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + EXEC_ARG(DC_SIGCHAR_BOOL); + MAKE_ARG_RETURN; +} + +static ERL_NIF_TERM call_bool(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + GET_SYM; + EXEC_CALL(DC_SIGCHAR_BOOL); + MAKE_CALL_RETURN; +} + +static ERL_NIF_TERM arg_short(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + EXEC_ARG(DC_SIGCHAR_SHORT); + MAKE_ARG_RETURN; +} + +static ERL_NIF_TERM call_short(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + GET_SYM; + EXEC_CALL(DC_SIGCHAR_SHORT); + MAKE_CALL_RETURN; +} + +static ERL_NIF_TERM arg_long(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + EXEC_ARG(DC_SIGCHAR_LONG); + MAKE_ARG_RETURN; +} + +static ERL_NIF_TERM call_long(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + GET_SYM; + EXEC_CALL(DC_SIGCHAR_LONG); + MAKE_CALL_RETURN; +} + +static ERL_NIF_TERM arg_longlong(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + EXEC_ARG(DC_SIGCHAR_LONGLONG); + MAKE_ARG_RETURN; +} + +static ERL_NIF_TERM call_longlong(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + GET_SYM; + EXEC_CALL(DC_SIGCHAR_LONGLONG); + MAKE_CALL_RETURN; +} + +static ERL_NIF_TERM arg_ptr(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + EXEC_ARG(DC_SIGCHAR_POINTER); + MAKE_ARG_RETURN; +} + +static ERL_NIF_TERM call_ptr(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + GET_SYM; + EXEC_CALL(DC_SIGCHAR_POINTER); + MAKE_CALL_RETURN; +} + +static ERL_NIF_TERM call_void(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + GET_SYM; + EXEC_CALL(DC_SIGCHAR_VOID); + + if(error_atom) RETURN_ERROR(error_atom); + return enif_make_atom(env,ATOM_OK); +} + +static ERL_NIF_TERM arg_string(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + EXEC_ARG(DC_SIGCHAR_STRING); + MAKE_ARG_RETURN; +} + +static ERL_NIF_TERM call_string(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + GET_SYM; + EXEC_CALL(DC_SIGCHAR_STRING); + MAKE_CALL_RETURN; +} + +static ERL_NIF_TERM mode(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + + int mode = -1; + if(!enif_get_int(env, argv[1], &mode)) RETURN_ERROR(ATOM_INVALID_ARG) + + dcMode(*vmptr,mode); + return enif_make_atom(env,ATOM_OK); +} + +static ERL_NIF_TERM get_error(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + + DCint ret = dcGetError(*vmptr); + + return enif_make_tuple2(env, + enif_make_atom(env,ATOM_OK), + enif_make_int(env,ret) + ); +} + +static ERL_NIF_TERM reset(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + + dcReset(*vmptr); + return enif_make_atom(env,ATOM_OK); +} + +static void process_formatted_args(ErlNifEnv* env,void* vm,char** format,ERL_NIF_TERM arglist,char** error_atom) { + + ERL_NIF_TERM remaining = arglist; + + char sigchar; + char* onechar = *format; + while((sigchar=*onechar)) { + if(sigchar==DC_SIGCHAR_ENDARG) break; + + // If the format has more items than the arg list, + // fail and call it a bad format. + ERL_NIF_TERM first, rest; + if(!enif_get_list_cell(env, remaining, &first, &rest)) { + *error_atom = ATOM_INVALID_FORMAT; + return; + } + + exec_arg(env,vm,sigchar,first,error_atom); + + remaining = rest; + onechar++; + } + + // There are more args, but the format was exhausted + if(!enif_is_empty_list(env,remaining)) { + *error_atom = ATOM_INVALID_FORMAT; + return; + } + + *format = onechar; +} + +static ERL_NIF_TERM argf(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + MAYBE_RET_BAD_STRING_ARG(format,1,MAX_FORMAT_STRING_SZ,ATOM_INVALID_FORMAT); + + char* formatretyped = format; + char* error_atom = NULL; + process_formatted_args(env,*vmptr,&formatretyped, argv[2], &error_atom); + + if(error_atom) { + RETURN_ERROR(error_atom); + } else return enif_make_atom(env,ATOM_OK); +} + +static ERL_NIF_TERM callf(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { + GET_VM; + + void** symptr; + if(!enif_get_resource(env, argv[1], g_ptrrestype, (void**)&symptr)) RETURN_ERROR(ATOM_INVALID_ARG) + if(!*symptr) RETURN_ERROR(ATOM_INVALID_SYMBOL) + + MAYBE_RET_BAD_STRING_ARG(format,2,MAX_FORMAT_STRING_SZ,ATOM_INVALID_FORMAT); + + char* formatretyped = format; + char* error_atom = NULL; + process_formatted_args(env,*vmptr,&formatretyped, argv[3], &error_atom); + + if(error_atom) { + RETURN_ERROR(error_atom); + } + + // Get return type char, skip ) + char rettypechar = *(formatretyped+1); + + ERL_NIF_TERM retval; + + exec_call(env,*vmptr,*symptr,rettypechar,&retval,&error_atom); + + if(error_atom) { + RETURN_ERROR(error_atom); + } + + if(rettypechar == DC_SIGCHAR_VOID) { + return enif_make_atom(env,ATOM_OK); + } + + return enif_make_tuple2(env, + enif_make_atom(env,ATOM_OK), + retval + ); +} + +static ErlNifFunc nif_funcs[] = { + {"new_call_vm", 1, new_call_vm}, + {"mode", 2, mode}, + {"get_error", 1, get_error}, + {"reset", 1, reset}, + {"load_library", 1, load_library}, + {"find_symbol", 2, find_symbol}, + {"arg_double", 2, arg_double}, + {"call_double", 2, call_double}, + {"arg_float", 2, arg_float}, + {"call_float", 2, call_float}, + {"arg_int", 2, arg_int}, + {"call_int", 2, call_int}, + {"arg_char", 2, arg_char}, + {"call_char", 2, call_char}, + {"arg_bool", 2, arg_bool}, + {"call_bool", 2, call_bool}, + {"arg_short", 2, arg_short}, + {"call_short", 2, call_short}, + {"arg_long", 2, arg_long}, + {"call_long", 2, call_long}, + {"arg_longlong", 2, arg_longlong}, + {"call_longlong", 2, call_longlong}, + {"arg_ptr", 2, arg_ptr}, + {"call_ptr", 2, call_ptr}, + {"call_void", 2, call_void}, + {"arg_string", 2, arg_string}, + {"call_string", 2, call_string}, + + {"argf", 3, argf}, + {"callf", 4, callf} +}; + +ERL_NIF_INIT(dyncall,nif_funcs,&nifload,NULL,NULL,NULL)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/erlang/erldc/c_src/erldctesttargets.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,112 @@ +/* + Copyright (c) 2014 Erik Mackdanz <erikmack@gmail.com> + + Permission to use, copy, modify, and distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, 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. +*/ + +#include <stdlib.h> +#include <stdio.h> + +char get_next_char(char in) { + return in+1; +} + +unsigned char get_next_char_u(unsigned char in) { + /* printf("In c, sum is %d\n",in+1); */ + return in+1; +} + +int is_false(int in) { + return !in; +} + +unsigned int dual_increment_u(unsigned int in) { + in++; + in++; + return in; +} + +short times_three(short in) { + return in * 3; +} + +unsigned short times_three_u(unsigned short in) { + return in * 3; +} + +long add_nineteen(long in) { + return in + 19; +} + +unsigned long add_nineteen_u(unsigned long in) { + return in + 19; +} + +long long subtract_four(long long in) { + return in - 4; +} + +unsigned long long subtract_four_u(unsigned long long in) { + return in - 4; +} + +int add_seven(int in) { + return in + 7; +} + +int add_one(int in) { + return in + 1; +} + +void* coolmalloc(int sz) { + void* ptr = malloc(sz); + /* printf("I've allocated at addr %p\n",ptr); */ + return ptr; +} + +void* coolidentity(void* in) { + return in; +} + +void coolsetstr(void* buf, char* val) { + sprintf(buf,"%s",val); +} + +void coolfree(void* ptr) { + /* printf("The value to free is %s\n", ptr); */ + free(ptr); +} + +void noop() {} + +float calculate_pi(float precision) { + return 21.0 / (7.0 * precision); // closer... +} + +double times_pi(double multiplicand) { + return multiplicand * 3.1; // nerd rage! +} + +char* interested_reply(char* yourname) { + int totalmax = 256; + char* buf = malloc(totalmax); + snprintf(buf,totalmax,"Really, %s? My name is Erik.",yourname); + return buf; +} + +char* several_args(long one, char two, char* three, float four) { + char* reply = malloc(100); + snprintf(reply, 100,"Your args were %ld, %c, %s, %.1f", + one,two,three,four); + return reply; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/erlang/erldc/include/dyncall.hrl Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,48 @@ +%% Copyright (c) 2014 Erik Mackdanz <erikmack@gmail.com> + +%% Permission to use, copy, modify, and distribute this software for any +%% purpose with or without fee is hereby granted, provided that the above +%% copyright notice and this permission notice appear in all copies. + +%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +%% ANY SPECIAL, DIRECT, 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. + +-define(DC_CALL_C_DEFAULT, 0). +-define(DC_CALL_C_ELLIPSIS, 100). +-define(DC_CALL_C_ELLIPSIS_VARARGS, 101). +-define(DC_CALL_C_X86_CDECL, 1). +-define(DC_CALL_C_X86_WIN32_STD, 2). +-define(DC_CALL_C_X86_WIN32_FAST_MS, 3). +-define(DC_CALL_C_X86_WIN32_FAST_GNU, 4). +-define(DC_CALL_C_X86_WIN32_THIS_MS, 5). +-define(DC_CALL_C_X86_WIN32_THIS_GNU, 6). +-define(DC_CALL_C_X64_WIN64, 7). +-define(DC_CALL_C_X64_SYSV, 8). +-define(DC_CALL_C_PPC32_DARWIN, 9). +-define(DC_CALL_C_PPC32_OSX, ?DC_CALL_C_PPC32_DARWIN). +-define(DC_CALL_C_ARM_ARM_EABI, 10). +-define(DC_CALL_C_ARM_THUMB_EABI, 11). +-define(DC_CALL_C_ARM_ARMHF, 30). +-define(DC_CALL_C_MIPS32_EABI, 12). +-define(DC_CALL_C_MIPS32_PSPSDK, ?DC_CALL_C_MIPS32_EABI). +-define(DC_CALL_C_PPC32_SYSV, 13). +-define(DC_CALL_C_PPC32_LINUX, ?DC_CALL_C_PPC32_SYSV). +-define(DC_CALL_C_ARM_ARM, 14). +-define(DC_CALL_C_ARM_THUMB, 15). +-define(DC_CALL_C_MIPS32_O32, 16). +-define(DC_CALL_C_MIPS64_N32, 17). +-define(DC_CALL_C_MIPS64_N64, 18). +-define(DC_CALL_C_X86_PLAN9, 19). +-define(DC_CALL_C_SPARC32, 20). +-define(DC_CALL_C_SPARC64, 21). +-define(DC_CALL_SYS_DEFAULT, 200). +-define(DC_CALL_SYS_X86_INT80H_LINUX, 201). +-define(DC_CALL_SYS_X86_INT80H_BSD, 202). + +-define(DC_ERROR_NONE, 0). +-define(DC_ERROR_UNSUPPORTED_MODE, -1).
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/erlang/erldc/src/dyncall.erl Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,175 @@ +%% Copyright (c) 2014 Erik Mackdanz <erikmack@gmail.com> + +%% Permission to use, copy, modify, and distribute this software for any +%% purpose with or without fee is hereby granted, provided that the above +%% copyright notice and this permission notice appear in all copies. + +%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +%% ANY SPECIAL, DIRECT, 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. + +-module(dyncall). + +-export([ + mode/2, + get_error/1, + reset/1, + load_library/1, + find_symbol/2, + new_call_vm/1, + arg_double/2, + call_double/2, + arg_float/2, + call_float/2, + arg_int/2, + call_int/2, + arg_char/2, + call_char/2, + arg_bool/2, + call_bool/2, + arg_short/2, + call_short/2, + arg_long/2, + call_long/2, + arg_longlong/2, + call_longlong/2, + arg_ptr/2, + call_ptr/2, + call_void/2, + arg_string/2, + call_string/2, + argf/3, + callf/4 + ]). + +-on_load(load_nif/0). + +load_nif() -> + Dir = case code:priv_dir(dyncall) of + {error, bad_name} -> + filename:dirname(code:which(?MODULE)) ++ "/../priv"; + OtherDir -> OtherDir + end, + erlang:load_nif(Dir ++ "/erldc", 0). + +-spec load_library(LibPath :: string()) -> {ok,Lib :: binary()} | {error,_Reason}. +load_library(_LibPath) -> + {error,"NIF library not loaded"}. + +-spec find_symbol(Lib :: binary(), SymName :: string()) -> {ok,Sym :: binary()} | {error,_Reason}. +find_symbol(_Lib, _SymName) -> + {error,"NIF library not loaded"}. + +-spec new_call_vm(Size :: pos_integer()) -> {ok,Vm :: binary()} | {error,_Reason}. +new_call_vm(_Size) -> + {error,"NIF library not loaded"}. + +-spec arg_double(Vm :: binary(), Double :: float()) -> ok | {error, _Reason}. +arg_double(_Vm, _Double) -> + {error,"NIF library not loaded"}. + +-spec call_double(Vm :: binary(), Sym :: binary()) -> {ok, Result :: float()} | {error, _Reason}. +call_double(_Vm, _Sym) -> + {error,"NIF library not loaded"}. + +-spec arg_float(Vm :: binary(), Float :: float()) -> ok | {error, _Reason}. +arg_float(_Vm, _Float) -> + {error,"NIF library not loaded"}. + +-spec call_float(Vm :: binary(), Sym :: binary()) -> {ok, Result :: float()} | {error, _Reason}. +call_float(_Vm, _Sym) -> + {error,"NIF library not loaded"}. + +-spec arg_int(Vm :: binary(), Int :: integer()) -> ok | {error, _Reason}. +arg_int(_Vm, _Int) -> + {error,"NIF library not loaded"}. + +-spec call_int(Vm :: binary(), Sym :: binary()) -> {ok, Result :: integer()} | {error, _Reason}. +call_int(_Vm, _Sym) -> + {error,"NIF library not loaded"}. + +-spec arg_char(Vm :: binary(), Char :: char()) -> ok | {error, _Reason}. +arg_char(_Vm, _Char) -> + {error,"NIF library not loaded"}. + +-spec call_char(Vm :: binary(), Sym :: binary()) -> {ok, Result :: char()} | {error, _Reason}. +call_char(_Vm, _Sym) -> + {error,"NIF library not loaded"}. + +-spec arg_bool(Vm :: binary(), Bool :: boolean()) -> ok | {error, _Reason}. +arg_bool(_Vm, _Bool) -> + {error,"NIF library not loaded"}. + +-spec call_bool(Vm :: binary(), Sym :: binary()) -> {ok, Result :: boolean()} | {error, _Reason}. +call_bool(_Vm, _Sym) -> + {error,"NIF library not loaded"}. + +-spec arg_short(Vm :: binary(), Short :: integer()) -> ok | {error, _Reason}. +arg_short(_Vm, _Short) -> + {error,"NIF library not loaded"}. + +-spec call_short(Vm :: binary(), Sym :: binary()) -> {ok, Result :: integer()} | {error, _Reason}. +call_short(_Vm, _Sym) -> + {error,"NIF library not loaded"}. + +-spec arg_long(Vm :: binary(), Long :: integer()) -> ok | {error, _Reason}. +arg_long(_Vm, _Long) -> + {error,"NIF library not loaded"}. + +-spec call_long(Vm :: binary(), Sym :: binary()) -> {ok, Result :: integer()} | {error, _Reason}. +call_long(_Vm, _Sym) -> + {error,"NIF library not loaded"}. + +-spec arg_longlong(Vm :: binary(), Longlong :: integer()) -> ok | {error, _Reason}. +arg_longlong(_Vm, _Longlong) -> + {error,"NIF library not loaded"}. + +-spec call_longlong(Vm :: binary(), Sym :: binary()) -> {ok, Result :: integer()} | {error, _Reason}. +call_longlong(_Vm, _Sym) -> + {error,"NIF library not loaded"}. + + +-spec arg_ptr(Vm :: binary(), Ptr :: binary()) -> ok | {error, _Reason}. +arg_ptr(_Vm, _Ptr) -> + {error,"NIF library not loaded"}. + +-spec call_ptr(Vm :: binary(), Sym :: binary()) -> {ok, Result :: binary()} | {error, _Reason}. +call_ptr(_Vm, _Sym) -> + {error,"NIF library not loaded"}. + +-spec call_void(Vm :: binary(), Sym :: binary()) -> ok | {error, _Reason}. +call_void(_Vm, _Sym) -> + {error,"NIF library not loaded"}. + +-spec arg_string(Vm :: binary(), String :: string()) -> ok | {error, _Reason}. +arg_string(_Vm, _String) -> + {error,"NIF library not loaded"}. + +-spec call_string(Vm :: binary(), Sym :: binary()) -> {ok, Result :: string()} | {error, _Reason}. +call_string(_Vm, _Sym) -> + {error,"NIF library not loaded"}. + +-spec mode(Vm :: binary(), Mode :: pos_integer()) -> ok | {error, _Reason}. +mode(_Vm, _Mode) -> + {error,"NIF library not loaded"}. + +-spec get_error(Vm :: binary()) -> {ok, ErrorCode :: pos_integer()} | {error, _Reason}. +get_error(_Vm) -> + {error,"NIF library not loaded"}. + +-spec reset(Vm :: binary()) -> ok | {error, _Reason}. +reset(_Vm) -> + {error,"NIF library not loaded"}. + +-spec argf(Vm :: binary(), Format :: string(), Args :: [term()]) -> ok | {error, _Reason}. +argf(_Vm,_Format,_Args) -> + {error,"NIF library not loaded"}. + +-spec callf(Vm :: binary(), Sym :: binary(), Format :: string(), Args :: [term()]) -> ok | {error, _Reason}. +callf(_Vm,_Sym,_Format,_Args) -> + {error,"NIF library not loaded"}. +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/erlang/erldc/src/erldc.app.src Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,7 @@ +{application, erldc, + [{description, "Call native functions dynamically"}, + {vsn, "---VERSION---"}, + {modules, [dyncall]} + ]}. + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/erlang/erldc/test/call_SUITE.erl Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,193 @@ +%% Copyright (c) 2014 Erik Mackdanz <erikmack@gmail.com> + +%% Permission to use, copy, modify, and distribute this software for any +%% purpose with or without fee is hereby granted, provided that the above +%% copyright notice and this permission notice appear in all copies. + +%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +%% ANY SPECIAL, DIRECT, 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. + +-module(call_SUITE). +-compile(export_all). + +-define(VMSZ, 1024). + +all() -> + [ + ret_double_arg_double, + arg_double_bad_vm, + arg_double_bad_vm_2, + arg_double_bad_vm_3, + arg_double_bad_arg, + call_double_bad_vm, + call_double_bad_sym, + + ret_float_arg_float, + + ret_int, + arg_int, + + ret_char_arg_char, + ret_bool_arg_bool, + ret_bool_arg_bool_2, + bad_bool_arg, + ret_short_arg_short, + ret_long_arg_long, + ret_longlong_arg_longlong, + + ret_ptr_arg_int__ret_void_arg_ptr, + ret_string_arg_string + ]. + +%% Tests on sqrt + +ret_double_arg_double(_) -> + {ok,Libm} = dyncall:load_library("libm"), + {ok,Sqrt} = dyncall:find_symbol(Libm, "sqrt"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_double(CallVm,49.0), + {ok,7.0} = dyncall:call_double(CallVm,Sqrt). + +arg_double_bad_vm(_) -> + {error,invalid_vm} = dyncall:arg_double(1000,49.0). + +arg_double_bad_vm_2(_) -> + {error,invalid_vm} = dyncall:arg_double("Not an int",49.0). + +arg_double_bad_vm_3(_) -> + {error,invalid_vm} = dyncall:arg_double(-4,49.0). + +arg_double_bad_arg(_) -> + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {error,invalid_arg} = dyncall:arg_double(CallVm,"Not a double"). + +call_double_bad_vm(_) -> + {ok,Libm} = dyncall:load_library("libm"), + {ok,Sqrt} = dyncall:find_symbol(Libm, "sqrt"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_double(CallVm,49.0), + {error,invalid_vm} = dyncall:call_double(12,Sqrt). %% assuming 12 is bad after preceding tests + +call_double_bad_sym(_) -> + {ok,Libm} = dyncall:load_library("libm"), + {ok,_Sqrt} = dyncall:find_symbol(Libm, "sqrt"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_double(CallVm,49.0), + {error,invalid_arg} = dyncall:call_double(CallVm,12). %% assuming 12 is bad after preceding tests + + +%% Tests on sqrtf + +ret_float_arg_float(_) -> + {ok,Libm} = dyncall:load_library("libm"), + {ok,Sqrt} = dyncall:find_symbol(Libm, "sqrtf"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_float(CallVm,49.0), + {ok,7.0} = dyncall:call_float(CallVm,Sqrt). + +%% Tests on ilogb +ret_int(_) -> + {ok,Libm} = dyncall:load_library("libm"), + {ok,Exp} = dyncall:find_symbol(Libm, "ilogb"), + {ok,CallVm} = dyncall:new_call_vm(4096), + ok = dyncall:arg_double(CallVm,1024.0), + {ok,10} = dyncall:call_int(CallVm,Exp). + +%% Tests on ldexp +arg_int(_) -> + {ok,Libm} = dyncall:load_library("libm"), + {ok,Exp} = dyncall:find_symbol(Libm, "ldexp"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_double(CallVm,3.0), + ok = dyncall:arg_int(CallVm,2), + {ok,12.0} = dyncall:call_double(CallVm,Exp). + +%% Tests on get_next_char +ret_char_arg_char(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "get_next_char"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_char(CallVm,$e), + {ok,$f} = dyncall:call_char(CallVm,Sym). + +%% Tests on is_false +ret_bool_arg_bool(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "is_false"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_bool(CallVm,true), + {ok,false} = dyncall:call_bool(CallVm,Sym). + +ret_bool_arg_bool_2(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "is_false"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_bool(CallVm,false), + {ok,true} = dyncall:call_bool(CallVm,Sym). + +bad_bool_arg(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,_Sym} = dyncall:find_symbol(Libm, "is_false"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {error,invalid_arg} = dyncall:arg_bool(CallVm,foobar). + +%% Tests on times_three +ret_short_arg_short(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "times_three"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_short(CallVm,7), + {ok,21} = dyncall:call_short(CallVm,Sym). + +%% Tests on add_nineteen +ret_long_arg_long(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "add_nineteen"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_long(CallVm,12), + {ok,31} = dyncall:call_long(CallVm,Sym). + +%% Tests on subtract_four +ret_longlong_arg_longlong(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "subtract_four"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_longlong(CallVm,15), + {ok,11} = dyncall:call_longlong(CallVm,Sym). + +%% Tests on coolmalloc/coolfree +ret_ptr_arg_int__ret_void_arg_ptr(_) -> + {ok,Lib} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Lib, "coolmalloc"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_int(CallVm,100), + {ok,Ptr} = dyncall:call_ptr(CallVm,Sym), + + %% Comes out as <<>> (opaque) + %% io:format("Pointer in erl is ~p~n",[Ptr]), + + {ok,Sym2} = dyncall:find_symbol(Lib, "coolsetstr"), + {ok,CallVm2} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_ptr(CallVm2,Ptr), + ok = dyncall:arg_string(CallVm2,"Barbaz"), + ok = dyncall:call_void(CallVm2,Sym2), + + {ok,Sym3} = dyncall:find_symbol(Lib, "coolfree"), + {ok,CallVm3} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_ptr(CallVm3,Ptr), + ok = dyncall:call_void(CallVm3,Sym3). + +%% Tests on interested_reply +ret_string_arg_string(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "interested_reply"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_string(CallVm,"Georg"), + {ok,"Really, Georg? My name is Erik."} = dyncall:call_string(CallVm,Sym). + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/erlang/erldc/test/callf_SUITE.erl Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,192 @@ +%% Copyright (c) 2014 Erik Mackdanz <erikmack@gmail.com> + +%% Permission to use, copy, modify, and distribute this software for any +%% purpose with or without fee is hereby granted, provided that the above +%% copyright notice and this permission notice appear in all copies. + +%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +%% ANY SPECIAL, DIRECT, 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. + +-module(callf_SUITE). +-compile(export_all). +-define(VMSZ, 1024). + +all() -> + [ + argf_one, + argf_excessive_format, + argf_excessive_args, + argf_struct, + callf_one, + callf_bool, + callf_void, + callf_char, + callf_uchar, + callf_short, + callf_ushort, + callf_int, + callf_uint, + callf_long, + callf_ulong, + callf_longlong, + callf_ulonglong, + callf_float, + callf_double, + callf_pointer, + callf_struct + ]. + +argf_one(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "several_args"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:argf(CallVm,"jcZf)Z",[-125,$[,"foo",6.2]), + {ok,"Your args were -125, [, foo, 6.2"} = dyncall:call_string(CallVm,Sym). + +argf_excessive_format(_) -> + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {error,invalid_format} = dyncall:argf(CallVm,"jjjjjjjjcZf)Z",[-125,91,"foo",6.2]). + +argf_excessive_args(_) -> + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {error,invalid_format} = dyncall:argf(CallVm,"jcZf)Z",[-125,91,"foo",6.2,7,7,7,7,7,7]). + +argf_struct(_) -> + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {error,not_implemented} = dyncall:argf(CallVm,"jTZf)Z",[-125,91,"foo",6.2]). + +callf_one(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "several_args"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,"Your args were -125, [, foo, 6.2"} = + dyncall:callf(CallVm,Sym,"jcZf)Z",[-125,91,"foo",6.2]). + +callf_bool(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "is_false"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,true} = + dyncall:callf(CallVm,Sym,"B)B",[false]). + +callf_void(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "noop"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:callf(CallVm,Sym,")v",[]). + +callf_struct(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "several_args"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {error,not_implemented} = + dyncall:callf(CallVm,Sym,"jcZf)T",[-125,91,"foo",6.2]). + +callf_char(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "get_next_char"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,120} = + dyncall:callf(CallVm,Sym,"c)c",[119]). + +callf_uchar(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "get_next_char_u"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,222} = + dyncall:callf(CallVm,Sym,"C)C",[221]). + +callf_short(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "times_three"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,-12} = + dyncall:callf(CallVm,Sym,"s)s",[-4]). + +callf_ushort(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "times_three_u"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,12} = + dyncall:callf(CallVm,Sym,"S)S",[4]). + +callf_int(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "is_false"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,1} = + dyncall:callf(CallVm,Sym,"i)i",[0]). + +callf_uint(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "dual_increment_u"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,6} = + dyncall:callf(CallVm,Sym,"I)I",[4]). + +callf_long(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "add_nineteen"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,19} = + dyncall:callf(CallVm,Sym,"j)j",[0]). + +callf_ulong(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "add_nineteen_u"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,23} = + dyncall:callf(CallVm,Sym,"J)J",[4]). + +callf_longlong(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "subtract_four"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,-1} = + dyncall:callf(CallVm,Sym,"l)l",[3]). + +callf_ulonglong(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "subtract_four_u"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,5} = + dyncall:callf(CallVm,Sym,"L)L",[9]). + +callf_float(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "calculate_pi"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,3.0} = + dyncall:callf(CallVm,Sym,"f)f",[1.0]). + +callf_double(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "times_pi"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,6.2} = + dyncall:callf(CallVm,Sym,"d)d",[2.0]). + +callf_pointer(_) -> + {ok,Libm} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Libm, "coolmalloc"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + {ok,MyMemory} = + dyncall:callf(CallVm,Sym,"j)p",[42]), + ok = dyncall:reset(CallVm), + {ok,Sym2} = dyncall:find_symbol(Libm, "coolidentity"), + %% Surprisingly, this works. The _resource handle + %% returned to erlang from callf compares equal in + %% erlang to the _resource handle passed as an arg. + {ok,MyMemory} = + dyncall:callf(CallVm,Sym2,"p)p",[MyMemory]). + + + + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/erlang/erldc/test/linkload_SUITE.erl Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,61 @@ +%% Copyright (c) 2014 Erik Mackdanz <erikmack@gmail.com> + +%% Permission to use, copy, modify, and distribute this software for any +%% purpose with or without fee is hereby granted, provided that the above +%% copyright notice and this permission notice appear in all copies. + +%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +%% ANY SPECIAL, DIRECT, 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. + +-module(linkload_SUITE). +-compile(export_all). + +-define(VMSZ, 1024). + +all() -> + [create_vm, + create_vm_badsz, + load_lib, + no_such_lib, + bad_lib, + bad_sym, + bad_sym_2, + load_sym + ]. + +create_vm(_) -> + {ok,Vm} = dyncall:new_call_vm(?VMSZ), + true = is_binary(Vm). + +create_vm_badsz(_) -> + {error,bad_vm_size} = dyncall:new_call_vm("Hello badarg"). + +load_lib(_) -> + {ok,Lib} = dyncall:load_library("libm"), + true = is_binary(Lib). + +no_such_lib(_) -> + {error,lib_not_found} = dyncall:load_library("foobarbaz"). + +bad_lib(_) -> + {error,invalid_lib} = dyncall:load_library(12). + +bad_sym(_) -> + {ok,Lib} = dyncall:load_library("libm"), + {error,symbol_not_found} = dyncall:find_symbol(Lib,"bogussymbol"). + +bad_sym_2(_) -> + {ok,Lib} = dyncall:load_library("libm"), + {error,invalid_symbol} = dyncall:find_symbol(Lib,9). + +load_sym(_) -> + {ok,Lib} = dyncall:load_library("libm"), + {ok,_Partner} = dyncall:find_symbol(Lib,"sqrt"). + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/erlang/erldc/test/misc_SUITE.erl Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,63 @@ +%% Copyright (c) 2014 Erik Mackdanz <erikmack@gmail.com> + +%% Permission to use, copy, modify, and distribute this software for any +%% purpose with or without fee is hereby granted, provided that the above +%% copyright notice and this permission notice appear in all copies. + +%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +%% ANY SPECIAL, DIRECT, 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. + +-module(misc_SUITE). +-compile(export_all). +-include("../include/dyncall.hrl"). + +-define(VMSZ, 1024). + +all() -> + [ + set_mode, + set_bad_mode, + reset_after_call, + reset_before_call + ]. + +set_mode(_) -> + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + dyncall:mode(CallVm,?DC_CALL_C_DEFAULT), + {ok,?DC_ERROR_NONE} = dyncall:get_error(CallVm). + +set_bad_mode(_) -> + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + dyncall:mode(CallVm,?DC_CALL_C_X86_WIN32_FAST_MS), + {ok,?DC_ERROR_UNSUPPORTED_MODE} = dyncall:get_error(CallVm). + +reset_after_call(_) -> + {ok,Lib} = dyncall:load_library("erldc_testtargets"), + {ok,Sym} = dyncall:find_symbol(Lib, "add_one"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_int(CallVm,100), + {ok,101} = dyncall:call_int(CallVm,Sym), + + ok = dyncall:reset(CallVm), + + {ok,Sym2} = dyncall:find_symbol(Lib, "add_seven"), + {ok,107} = dyncall:call_int(CallVm,Sym2). + +reset_before_call(_) -> + {ok,Lib} = dyncall:load_library("erldc_testtargets"), + {ok,_Sym} = dyncall:find_symbol(Lib, "add_one"), + {ok,CallVm} = dyncall:new_call_vm(?VMSZ), + ok = dyncall:arg_int(CallVm,100), + + ok = dyncall:reset(CallVm), + + {ok,Sym2} = dyncall:find_symbol(Lib, "add_seven"), + ok = dyncall:arg_int(CallVm,200), + {ok,207} = dyncall:call_int(CallVm,Sym2). + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/go/godc/README.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,30 @@ +dyncall go bindings +Copyright 2014 Tassilo Philipp +February 23, 2014 + + +TYPE CONVERSIONS (and reserved signature char) + + SIG | FROM GO | C/C++ | TO GO + ----+---------------------+--------------------+---------------- + 'v' | | void | + 'B' | bool | bool | bool + 'c' | int8,C.schar | char | int8 + 'C' | uint8,byte,C.uchar | unsigned char | uint8,byte + 's' | int16,C.sshort | short | int16 + 'S' | uint16,C.ushort | unsigned short | uint16 + 'i' | int32,C.sint | int | int32 + 'I' | uint32,C.uint | unsigned int | uint32 + 'j' | int32,rune,C.slong | long | int32,rune + 'J' | uint32,C.ulong | unsigned long | uint32 + 'l' | int64,C.slonglong | long long | int64 + 'L' | uint64,C.ulonglong | unsigned long long | uint64 + 'f' | float32,C.float | float | float32 + 'd' | float64,C.double | double | float64 + 'p' | *,[],unsafe.Pointer | void* | unsafe.Pointer + 'Z' | string | void* | string + + +ToDo: +- structs +- callf wrap
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/go/godc/godc.go Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,282 @@ +/* + + godc.go + Copyright (c) 2014 Tassilo Philipp <tphilipp@potion-studios.com> + + Permission to use, copy, modify, and distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, 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. + +*/ + + +// Go/dyncall extension implementation. +package godc + +// #cgo LDFLAGS: -L../../../dyncall/ -ldyncall_s +// #cgo LDFLAGS: -L../../../dynload/ -ldynload_s +// #cgo LDFLAGS: -L../../../dyncallback/ -ldyncallback_s +// #include <stdlib.h> +// #include "../../../dyncall/dyncall/dyncall.h" +// #include "../../../dyncall/dynload/dynload.h" +// #include "../../../dyncall/dyncall/dyncall_signature.h" +import "C" +import ( + "unsafe" + "fmt" + "reflect" +) + +type ExtLib struct { + lib *C.DLLib + syms *C.DLSyms +} + +type CallVM struct { + cvm *C.DCCallVM +} + + +// dynload +func (p *ExtLib) Load(path string) error { + s := C.CString(path) + defer C.free(unsafe.Pointer(s)) + p.lib = C.dlLoadLibrary(s) + if p.lib != nil { return nil } + return fmt.Errorf("Can't load %s", path) +} + +func (p *ExtLib) Free() { + C.dlFreeLibrary(p.lib) +} + +func (p *ExtLib) FindSymbol(name string) unsafe.Pointer { + s := C.CString(name) + defer C.free(unsafe.Pointer(s)) + return unsafe.Pointer(C.dlFindSymbol(p.lib, s)) +} + + +// dynload Syms +func (p *ExtLib) SymsInit(path string) error { + s := C.CString(path) + defer C.free(unsafe.Pointer(s)) + p.syms = C.dlSymsInit(s) + if p.syms != nil { return nil } + return fmt.Errorf("Can't load %s", path) +} + +func (p *ExtLib) SymsCleanup() { + C.dlSymsCleanup(p.syms) +} + +func (p *ExtLib) SymsCount() int { + return int(C.dlSymsCount(p.syms)) +} + +func (p *ExtLib) SymsName(i int) string { + return C.GoString(C.dlSymsName(p.syms, C.int(i))) +} + +func (p *ExtLib) SymsNameFromValue(v unsafe.Pointer) string { + return C.GoString(C.dlSymsNameFromValue(p.syms, v)) +} + + +// dyncall +func (p *CallVM) InitCallVM() error { + return p.InitCallVMWithStackSize(4096) +} + +func (p *CallVM) InitCallVMWithStackSize(stackSize int) error { + p.cvm = C.dcNewCallVM(C.DCsize(stackSize)) + if p.cvm != nil { return nil } + return fmt.Errorf("Can't create CallVM") +} + +func (p *CallVM) Free() { + C.dcFree(p.cvm) +} + +func (p *CallVM) Reset() { + C.dcReset(p.cvm) +} + + + +// Modes +const ( + DC_CALL_C_DEFAULT = C.DC_CALL_C_DEFAULT + DC_CALL_C_ELLIPSIS = C.DC_CALL_C_ELLIPSIS + DC_CALL_C_ELLIPSIS_VARARGS = C.DC_CALL_C_ELLIPSIS_VARARGS + DC_CALL_C_X86_CDECL = C.DC_CALL_C_X86_CDECL + DC_CALL_C_X86_WIN32_STD = C.DC_CALL_C_X86_WIN32_STD + DC_CALL_C_X86_WIN32_FAST_MS = C.DC_CALL_C_X86_WIN32_FAST_MS + DC_CALL_C_X86_WIN32_FAST_GNU = C.DC_CALL_C_X86_WIN32_FAST_GNU + DC_CALL_C_X86_WIN32_THIS_MS = C.DC_CALL_C_X86_WIN32_THIS_MS + DC_CALL_C_X86_WIN32_THIS_GNU = C.DC_CALL_C_X86_WIN32_THIS_GNU + DC_CALL_C_X64_WIN64 = C.DC_CALL_C_X64_WIN64 + DC_CALL_C_X64_SYSV = C.DC_CALL_C_X64_SYSV + DC_CALL_C_PPC32_DARWIN = C.DC_CALL_C_PPC32_DARWIN + DC_CALL_C_PPC32_OSX = C.DC_CALL_C_PPC32_OSX + DC_CALL_C_ARM_ARM_EABI = C.DC_CALL_C_ARM_ARM_EABI + DC_CALL_C_ARM_THUMB_EABI = C.DC_CALL_C_ARM_THUMB_EABI + DC_CALL_C_ARM_ARMHF = C.DC_CALL_C_ARM_ARMHF + DC_CALL_C_MIPS32_EABI = C.DC_CALL_C_MIPS32_EABI + DC_CALL_C_MIPS32_PSPSDK = C.DC_CALL_C_MIPS32_PSPSDK + DC_CALL_C_PPC32_SYSV = C.DC_CALL_C_PPC32_SYSV + DC_CALL_C_PPC32_LINUX = C.DC_CALL_C_PPC32_LINUX + DC_CALL_C_ARM_ARM = C.DC_CALL_C_ARM_ARM + DC_CALL_C_ARM_THUMB = C.DC_CALL_C_ARM_THUMB + DC_CALL_C_MIPS32_O32 = C.DC_CALL_C_MIPS32_O32 + DC_CALL_C_MIPS64_N32 = C.DC_CALL_C_MIPS64_N32 + DC_CALL_C_MIPS64_N64 = C.DC_CALL_C_MIPS64_N64 + DC_CALL_C_X86_PLAN9 = C.DC_CALL_C_X86_PLAN9 + DC_CALL_C_SPARC32 = C.DC_CALL_C_SPARC32 + DC_CALL_C_SPARC64 = C.DC_CALL_C_SPARC64 + DC_CALL_SYS_DEFAULT = C.DC_CALL_SYS_DEFAULT + DC_CALL_SYS_X86_INT80H_LINUX = C.DC_CALL_SYS_X86_INT80H_LINUX + DC_CALL_SYS_X86_INT80H_BSD = C.DC_CALL_SYS_X86_INT80H_BSD +) + + +func (p *CallVM) Mode(mode int) { + C.dcMode(p.cvm, C.DCint(mode)) +} + +// Error codes +const ( + DC_ERROR_NONE = C.DC_ERROR_NONE + DC_ERROR_UNSUPPORTED_MODE = C.DC_ERROR_UNSUPPORTED_MODE +) + + +func (p *CallVM) GetError() int { + return int(C.dcGetError(p.cvm)) +} + + +// Helper for string/pointer conversion, needed as low-level string alloc needs to be freed in different scope +func (p *CallVM) AllocCString(value string) unsafe.Pointer { s := C.CString(value); return unsafe.Pointer(s) } +func (p *CallVM) FreeCString (value unsafe.Pointer) { C.free(value) } + +// Args +func (p *CallVM) ArgBool (value bool) { if value==true { C.dcArgBool(p.cvm, C.DC_TRUE) } else { C.dcArgBool(p.cvm, C.DC_FALSE) } } +func (p *CallVM) ArgChar (value int8) { C.dcArgChar (p.cvm, C.DCchar (value)) } +func (p *CallVM) ArgShort (value int16) { C.dcArgShort (p.cvm, C.DCshort (value)) } +func (p *CallVM) ArgInt (value int) { C.dcArgInt (p.cvm, C.DCint (value)) } +func (p *CallVM) ArgLong (value int32) { C.dcArgLong (p.cvm, C.DClong (value)) } +func (p *CallVM) ArgLongLong (value int64) { C.dcArgLongLong(p.cvm, C.DClonglong(value)) } +func (p *CallVM) ArgFloat (value float32) { C.dcArgFloat (p.cvm, C.DCfloat (value)) } +func (p *CallVM) ArgDouble (value float64) { C.dcArgDouble (p.cvm, C.DCdouble (value)) } +func (p *CallVM) ArgPointer (value unsafe.Pointer) { C.dcArgPointer (p.cvm, C.DCpointer (value)) } +//@@@func (p *CallVM) ArgStruct (s C.DCstruct*, value unsafe.Pointer) + +// "Formatted" args +// - first takes Go's types (as they cover all C types dyncall supports) and pushes values accordingly +// - second uses a dyncall signature for implicit type conversion/casting, however it uses reflect package and is slower +// Note that first version doesn't feature calling convention mode switching. +func (p *CallVM) ArgF_Go(args ...interface{}) error { + + for i, n := 0, len(args); i<n; i++ { + switch args[i].(type) { + case bool: p.ArgBool ( (args[i].(bool ))) + case int8: p.ArgChar ( (args[i].(int8 ))) + case uint8/*byte*/: p.ArgChar (int8 (args[i].(uint8 ))) + case int16: p.ArgShort ( (args[i].(int16 ))) + case uint16: p.ArgShort (int16 (args[i].(uint16 ))) + case int: p.ArgInt ( (args[i].(int ))) + case uint: p.ArgInt (int (args[i].(uint ))) + case int32/*rune*/: p.ArgLong ( (args[i].(int32 ))) + case uint32: p.ArgLong (int32 (args[i].(uint32 ))) + case int64: p.ArgLongLong( (args[i].(int64 ))) + case uint64: p.ArgLongLong(int64 (args[i].(uint64 ))) + case float32: p.ArgFloat ( (args[i].(float32 ))) + case float64: p.ArgDouble ( (args[i].(float64 ))) + case uintptr: p.ArgPointer (unsafe.Pointer(args[i].(unsafe.Pointer))) + case unsafe.Pointer: p.ArgPointer ( (args[i].(unsafe.Pointer))) + default: return fmt.Errorf("Unknown type passed to ArgF_Go") + } + } + return nil +} + +func (p *CallVM) ArgF(signature string, args ...interface{}) { + + tb := reflect.TypeOf((*bool )(nil)).Elem() + ti := reflect.TypeOf((*int64 )(nil)).Elem() + tf := reflect.TypeOf((*float64)(nil)).Elem() + tp := reflect.TypeOf((*uintptr)(nil)).Elem() + + for i, n := 0, len(signature); i<n; i++ { + //@@@ add support for calling convention mode(s) + switch s := signature[i]; s { + case C.DC_SIGCHAR_BOOL: p.ArgBool (bool (reflect.ValueOf(args[i]).Convert(tb).Bool ())) + case C.DC_SIGCHAR_CHAR, C.DC_SIGCHAR_UCHAR: p.ArgChar (int8 (reflect.ValueOf(args[i]).Convert(ti).Int ())) + case C.DC_SIGCHAR_INT, C.DC_SIGCHAR_UINT: p.ArgInt (int (reflect.ValueOf(args[i]).Convert(ti).Int ())) + case C.DC_SIGCHAR_LONG, C.DC_SIGCHAR_ULONG: p.ArgLong (int32 (reflect.ValueOf(args[i]).Convert(ti).Int ())) + case C.DC_SIGCHAR_LONGLONG, C.DC_SIGCHAR_ULONGLONG: p.ArgLongLong(int64 (reflect.ValueOf(args[i]).Convert(ti).Int ())) + case C.DC_SIGCHAR_FLOAT: p.ArgFloat (float32 (reflect.ValueOf(args[i]).Convert(tf).Float ())) + case C.DC_SIGCHAR_DOUBLE: p.ArgDouble (float64 (reflect.ValueOf(args[i]).Convert(tf).Float ())) + case C.DC_SIGCHAR_POINTER, C.DC_SIGCHAR_STRING: p.ArgPointer (unsafe.Pointer(reflect.ValueOf(args[i]).Convert(tp).Pointer())) + case C.DC_SIGCHAR_ENDARG: return + } + // Faster, but doesn't do cross-type conversions. + //switch s := signature[i]; s { + // case C.DC_SIGCHAR_BOOL: p.ArgBool (args[i].(bool )) + // case C.DC_SIGCHAR_CHAR, C.DC_SIGCHAR_UCHAR: p.ArgChar (args[i].(int8 )) + // case C.DC_SIGCHAR_SHORT, C.DC_SIGCHAR_USHORT: p.ArgShort (args[i].(int16 )) + // case C.DC_SIGCHAR_INT, C.DC_SIGCHAR_UINT: p.ArgInt (args[i].(int )) + // case C.DC_SIGCHAR_LONG, C.DC_SIGCHAR_ULONG: p.ArgLong (args[i].(int32 )) + // case C.DC_SIGCHAR_LONGLONG, C.DC_SIGCHAR_ULONGLONG: p.ArgLongLong(args[i].(int64 )) + // case C.DC_SIGCHAR_FLOAT: p.ArgFloat (args[i].(float32 )) + // case C.DC_SIGCHAR_DOUBLE: p.ArgDouble (args[i].(float64 )) + // case C.DC_SIGCHAR_POINTER, C.DC_SIGCHAR_STRING: p.ArgPointer (args[i].(unsafe.Pointer)) + // case C.DC_SIGCHAR_ENDARG: return + //} + } +} + + +// Calls +func (p *CallVM) CallVoid (funcptr unsafe.Pointer) { C.dcCallVoid (p.cvm, C.DCpointer(funcptr)) } +func (p *CallVM) CallBool (funcptr unsafe.Pointer) bool { b := (C.dcCallBool(p.cvm, C.DCpointer(funcptr))); if b==C.DC_TRUE { return true } else { return false } } +func (p *CallVM) CallChar (funcptr unsafe.Pointer) int8 { return int8 (C.dcCallChar (p.cvm, C.DCpointer(funcptr))) } +func (p *CallVM) CallShort (funcptr unsafe.Pointer) int16 { return int16 (C.dcCallShort (p.cvm, C.DCpointer(funcptr))) } +func (p *CallVM) CallInt (funcptr unsafe.Pointer) int { return int (C.dcCallInt (p.cvm, C.DCpointer(funcptr))) } +func (p *CallVM) CallLong (funcptr unsafe.Pointer) int32 { return int32 (C.dcCallLong (p.cvm, C.DCpointer(funcptr))) } +func (p *CallVM) CallLongLong (funcptr unsafe.Pointer) int64 { return int64 (C.dcCallLongLong(p.cvm, C.DCpointer(funcptr))) } +func (p *CallVM) CallFloat (funcptr unsafe.Pointer) float32 { return float32 (C.dcCallFloat (p.cvm, C.DCpointer(funcptr))) } +func (p *CallVM) CallDouble (funcptr unsafe.Pointer) float64 { return float64 (C.dcCallDouble (p.cvm, C.DCpointer(funcptr))) } +func (p *CallVM) CallPointer (funcptr unsafe.Pointer) unsafe.Pointer { return unsafe.Pointer(C.dcCallPointer (p.cvm, C.DCpointer(funcptr))) } +func (p *CallVM) CallPointerToStr(funcptr unsafe.Pointer) string { return C.GoString((*C.char)(C.dcCallPointer (p.cvm, C.DCpointer(funcptr)))) } // For convenience +//@@@func (p *CallVM) CallStruct (funcptr unsafe.Pointer, s C.DCstruct* s, returnValue unsafe.Pointer) + +// "Formatted" calls +//@@@func (p *CallVM) Call(result, funcptr unsafe.Pointer, signature string, args ...interface{}) { +//@@@... +//@@@} + + +//void dcCallF (DCCallVM* vm, DCValue* result, DCpointer funcptr, const DCsigchar* signature, ...); + +/* +DC_API DCstruct* dcNewStruct (DCsize fieldCount, DCint alignment); +DC_API void dcStructField (DCstruct* s, DCint type, DCint alignment, DCsize arrayLength); +DC_API void dcSubStruct (DCstruct* s, DCsize fieldCount, DCint alignment, DCsize arrayLength); +DC_API void dcCloseStruct (DCstruct* s); +DC_API DCsize dcStructSize (DCstruct* s); +DC_API DCsize dcStructAlignment(DCstruct* s); +DC_API void dcFreeStruct (DCstruct* s); + +DC_API DCstruct* dcDefineStruct (const char* signature); +*/ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/go/godc/godc_test.go Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,229 @@ +/* + + godc_test.go + Copyright (c) 2014 Tassilo Philipp <tphilipp@potion-studios.com> + + Permission to use, copy, modify, and distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, 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. + +*/ + + +package godc + +import ( + "testing" + "fmt" + "unsafe" + "math" +) + +func TestGoDC(t *testing.T) { + lm := new(ExtLib) + if err := lm.Load("/usr/lib/libm.so"); err != nil { + t.FailNow() + } + defer lm.Free() + + if err := lm.SymsInit("/usr/lib/libm.so"); err != nil { + t.FailNow() + } + defer lm.SymsCleanup() + + fmt.Printf("Testing dl:\n") + fmt.Printf("-----------\n") + fmt.Printf("Loaded library at address: %p\n", lm.lib) + fmt.Printf("C sqrt function at address: %p\n", lm.FindSymbol("sqrt")) + fmt.Printf("C pow function at address: %p\n\n", lm.FindSymbol("pow")) + + fmt.Printf("Testing dlSyms:\n") + fmt.Printf("---------------\n") + fmt.Printf("Symbols in libm: %d\n", lm.SymsCount()) + fmt.Printf("Symbol name for address %p: %s\n", lm.FindSymbol("pow"), lm.SymsNameFromValue(lm.FindSymbol("pow"))) + fmt.Printf("All symbol names in libm:\n") + for i, n := 0, lm.SymsCount(); i<n; i++ { + fmt.Printf(" %s\n", lm.SymsName(i)) + } + fmt.Printf("\n") + + + + // Another lib + lc := new(ExtLib) + if err := lc.Load("/usr/lib/libc.so"); err != nil { + t.FailNow() + } + defer lc.Free() + + if err := lc.SymsInit("/usr/lib/libc.so"); err != nil { + t.FailNow() + } + defer lc.SymsCleanup() + + fmt.Printf("Symbols in libc: %d (not listing them here, too many)\n\n", lc.SymsCount()) + + + + // Call some functions + fmt.Printf("Testing dc:\n") + fmt.Printf("-----------\n") + vm := new(CallVM) + if err := vm.InitCallVM(); err != nil { + t.FailNow() + } + defer vm.Free() + + vm.Mode(DC_CALL_C_DEFAULT) + + + // Float + vm.Reset() + vm.ArgFloat(36) + rf := vm.CallFloat(lm.FindSymbol("sqrtf")) + fmt.Printf("sqrtf(36) = %f\n", rf) + if(rf != 6.0) { t.FailNow() } + + vm.Reset() // Test reset, reusing VM + vm.ArgDouble(3.6) + rd := vm.CallDouble(lm.FindSymbol("floor")) + fmt.Printf("floor(3.6) = %f\n", rd) + if(rd != 3.0) { t.FailNow() } + + + // Double + vm.Reset() + vm.ArgDouble(4.2373) + rd = vm.CallDouble(lm.FindSymbol("sqrt")) + fmt.Printf("sqrt(4.2373) = %f\n", rd) + if(math.Abs(rd - 2.05847) > 0.00001) { t.FailNow() } + + vm.Reset() + vm.ArgDouble(2.373) + vm.ArgDouble(-1000) // 2 args + rd = vm.CallDouble(lm.FindSymbol("copysign")) + fmt.Printf("copysign(2.373, -1000) = %f\n", rd) + if(rd != -2.373) { t.FailNow() } + + + // Strings + vm.Reset() + cs1 := vm.AllocCString("/return/only/this_here") + defer vm.FreeCString(cs1) + + vm.ArgPointer(cs1) + rs := vm.CallPointerToStr(lc.FindSymbol("basename")) + fmt.Printf("basename(\"/return/only/this_here\") = %s\n", rs) + if(rs != "this_here") { t.FailNow() } + // Reuse path + rs = vm.CallPointerToStr(lc.FindSymbol("dirname")) + fmt.Printf("dirname(\"/return/only/this_here\") = %s\n", rs) + if(rs != "/return/only") { t.FailNow() } + + + // Integer + vm.Reset() + vm.ArgInt('a') + ri := vm.CallInt(lc.FindSymbol("toupper")) + fmt.Printf("toupper('a') = %c\n", ri) + if(ri != 'A') { t.FailNow() } + + vm.Reset() + vm.ArgInt('a') + ri = vm.CallInt(lc.FindSymbol("tolower")) + fmt.Printf("tolower('a') = %c\n", ri) + if(ri != 'a') { t.FailNow() } + + vm.Reset() + vm.ArgInt('R') + ri = vm.CallInt(lc.FindSymbol("toupper")) + fmt.Printf("toupper('R') = %c\n", vm.CallInt(lc.FindSymbol("toupper"))) + if(ri != 'R') { t.FailNow() } + + vm.Reset() + vm.ArgInt('R') + ri = vm.CallInt(lc.FindSymbol("tolower")) + fmt.Printf("tolower('R') = %c\n", vm.CallInt(lc.FindSymbol("tolower"))) + if(ri != 'r') { t.FailNow() } + + + // Integer return + vm.Reset() + cs2 := vm.AllocCString("Tassilo") + defer vm.FreeCString(cs2) + + fmt.Printf("rand() = %d\n", vm.CallInt(lc.FindSymbol("rand"))) + fmt.Printf("rand() = %d\n", vm.CallInt(lc.FindSymbol("rand"))) + fmt.Printf("rand() = %d\n", vm.CallInt(lc.FindSymbol("rand"))) + fmt.Printf("rand() = %d\n", vm.CallInt(lc.FindSymbol("rand"))) + fmt.Printf("rand() = %d\n", vm.CallInt(lc.FindSymbol("rand"))) + vm.ArgPointer(cs2) + ri = vm.CallInt(lc.FindSymbol("strlen")) + fmt.Printf("strlen(\"Tassilo\") = %d\n", ri) + if(ri != 7) { t.FailNow() } + + + // Formatted - with signature/conversion + vm.Reset() + vm.ArgF("dd)d", 3.14, -2000) // 2 args, second passed as int, but ArgF will convert + rd = vm.CallDouble(lm.FindSymbol("copysign")) + fmt.Printf("dd)d: copysign(3.14, -2000) = %f\n", rd) + if(rd != -3.14) { t.FailNow() } + + // Formatted - without signature/conversion + vm.Reset() + vm.ArgF("dd)d", -31.4, 42.4) // 2 args, second passed as int, but ArgF will convert + rd = vm.CallDouble(lm.FindSymbol("copysign")) + fmt.Printf("dd)d: copysign(-31.4, 42.4) = %f\n", rd) + if(rd != 31.4) { t.FailNow() } + + // Formatted - use Go's types, pass unsupported type, should return an error + vm.Reset() + err := vm.ArgF_Go(6.14, vm) + fmt.Printf("ArgF_Go: copysign(6.14, <unsupported type>) should return error: %t\n", err != nil) + if(err == nil) { t.FailNow() } + + // Formatted - use Go's types + vm.Reset() + vm.ArgF_Go(-61.4, 42.4) // 2 args, both need to be correct or undefined behaviour + rd = vm.CallDouble(lm.FindSymbol("copysign")) + fmt.Printf("copysign(-61.4, 42.4) = %f\n", rd) + if(rd != 61.4) { t.FailNow() } + + + // Ellipse + vm.Mode(DC_CALL_C_ELLIPSIS) + vm.Reset() + buf := make([]byte, 1000) + bufPtr := unsafe.Pointer(&buf[0]) + cs3 := vm.AllocCString("Four:%d | \"Hello\":%s | Pi:%f") + cs4 := vm.AllocCString("Hello") + defer vm.FreeCString(cs4) + defer vm.FreeCString(cs3) + + vm.ArgPointer(bufPtr) + vm.ArgPointer(cs3) + vm.Mode(DC_CALL_C_ELLIPSIS_VARARGS) + vm.ArgInt(4) + vm.ArgPointer(cs4) + vm.ArgDouble(3.14) // Double, b/c of ... promotion rules + ri = vm.CallInt(lc.FindSymbol("sprintf")) + fmt.Printf("sprintf(bufPtr, \"Four:%%d | \\\"Hello\\\":%%s | Pi:%%f\", 4, \"Hello\", 3.14) = %d:\n", ri) + fmt.Printf(" bufPtr: %s\n", string(buf[/*slice printed bytes*/:ri])) + if(ri != 36) { t.FailNow() } + + +//@@@ untested: +// - ArgF and ArgF_Go with strings +// - ArgF and ArgF_Go with bools +// - ... +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/java/jdc/.classpath Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,6 @@ +<?xml version="1.0" encoding="UTF-8"?> +<classpath> + <classpathentry kind="src" path="src"/> + <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/> + <classpathentry kind="output" path="bin"/> +</classpath>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/java/jdc/.project Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,17 @@ +<?xml version="1.0" encoding="UTF-8"?> +<projectDescription> + <name>jdc</name> + <comment></comment> + <projects> + </projects> + <buildSpec> + <buildCommand> + <name>org.eclipse.jdt.core.javabuilder</name> + <arguments> + </arguments> + </buildCommand> + </buildSpec> + <natures> + <nature>org.eclipse.jdt.core.javanature</nature> + </natures> +</projectDescription>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/java/jdc/GNUmakefile Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,9 @@ +TOP = ../../.. + +include $(TOP)/build/gmake/prolog.gmake + +JAVA_PACKAGE = jdc +AUTO_DIRS = bin + +include $(TOP)/build/gmake/epilog.gmake +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/java/jdc/org_dyncall_DC.h Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,21 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class org_dyncall_DC */ + +#ifndef _Included_org_dyncall_DC +#define _Included_org_dyncall_DC +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_dyncall_DC + * Method: newCallVM + * Signature: (II)Lorg/dyncall/callvm; + */ +JNIEXPORT jobject JNICALL Java_org_dyncall_DC_newCallVM + (JNIEnv *, jclass, jint, jint); + +#ifdef __cplusplus +} +#endif +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/java/jdc/org_dyncall_callvm.h Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,125 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class org_dyncall_callvm */ + +#ifndef _Included_org_dyncall_callvm +#define _Included_org_dyncall_callvm +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: org_dyncall_callvm + * Method: reset + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_dyncall_callvm_reset + (JNIEnv *, jobject); + +/* + * Class: org_dyncall_callvm + * Method: argBool + * Signature: (Z)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_callvm_argBool + (JNIEnv *, jobject, jboolean); + +/* + * Class: org_dyncall_callvm + * Method: argByte + * Signature: (B)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_callvm_argByte + (JNIEnv *, jobject, jbyte); + +/* + * Class: org_dyncall_callvm + * Method: argShort + * Signature: (S)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_callvm_argShort + (JNIEnv *, jobject, jshort); + +/* + * Class: org_dyncall_callvm + * Method: argInt + * Signature: (I)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_callvm_argInt + (JNIEnv *, jobject, jint); + +/* + * Class: org_dyncall_callvm + * Method: argLong + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_callvm_argLong + (JNIEnv *, jobject, jlong); + +/* + * Class: org_dyncall_callvm + * Method: argChar + * Signature: (C)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_callvm_argChar + (JNIEnv *, jobject, jchar); + +/* + * Class: org_dyncall_callvm + * Method: argFloat + * Signature: (F)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_callvm_argFloat + (JNIEnv *, jobject, jfloat); + +/* + * Class: org_dyncall_callvm + * Method: argDouble + * Signature: (D)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_callvm_argDouble + (JNIEnv *, jobject, jdouble); + +/* + * Class: org_dyncall_callvm + * Method: argPointer + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_callvm_argPointer__J + (JNIEnv *, jobject, jlong); + +/* + * Class: org_dyncall_callvm + * Method: argPointer + * Signature: (Ljava/lang/Object;)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_callvm_argPointer__Ljava_lang_Object_2 + (JNIEnv *, jobject, jobject); + +/* + * Class: org_dyncall_callvm + * Method: argString + * Signature: (Ljava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_callvm_argString + (JNIEnv *, jobject, jstring); + +/* + * Class: org_dyncall_callvm + * Method: callVoid + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_callvm_callVoid + (JNIEnv *, jobject, jlong); + +/* + * Class: org_dyncall_callvm + * Method: callInt + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_dyncall_callvm_callInt + (JNIEnv *, jobject, jlong); + +#ifdef __cplusplus +} +#endif +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/java/jdc/src/GNUmakefile Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,11 @@ +TOP = ../../../.. + +include $(TOP)/build/gmake/prolog.gmake + +DLL = jdc +MODS = org_dyncall_DC +LDFLAGS = -L $(TOP)/dyncall +LIBS = -ldyncall_s + +include $(TOP)/build/gmake/epilog.gmake +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/java/jdc/src/org/dyncall/DC.java Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,47 @@ +package org.dyncall; + +public class DC +{ + static + { + System.loadLibrary("jdc"); + } + + public static final int + DEFAULT_C = 0 + , X86_WIN32_FAST = 1 + , X86_WIN32_STD = 2 + , X86_WIN32_THIS_MS = 3 + ; + + public static native long newCallVM(int type, int size); + public static native long load(String libname); + public static native long addpath(String dirpath); + public static native long rempath(String dirpath); + public static native long find(long libhandle, String symbol); + + public static native void reset (long vmhandle); + public static native void argBool (long vmhandle, boolean b); + public static native void argChar (long vmhandle, char c); + public static native void argByte (long vmhandle, byte b); + public static native void argShort (long vmhandle, short s); + public static native void argInt (long vmhandle, int i); + public static native void argLong (long vmhandle, long l); + public static native void argFloat (long vmhandle, float f); + public static native void argDouble (long vmhandle, double d); + public static native void argPointer(long vmhandle, long l); + public static native void argPointer(long vmhandle, Object o); + public static native void argString (long vmhandle, String s); + + public static native void callVoid (long vmhandle, long funcpointer); + public static native boolean callBoolean (long vmhandle, long funcpointer); + public static native char callChar (long vmhandle, long funcpointer); + public static native byte callByte (long vmhandle, long funcpointer); + public static native short callShort (long vmhandle, long funcpointer); + public static native int callInt (long vmhandle, long funcpointer); + public static native long callLong (long vmhandle, long funcpointer); + public static native float callFloat (long vmhandle, long funcpointer); + public static native double callDouble (long vmhandle, long funcpointer); + public static native long callPointer (long vmhandle, long funcpointer); +}; +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/java/jdc/src/org_dyncall_DC.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,112 @@ +#include "org_dyncall_DC.h" +#include "../../../../dyncall/dyncall.h" +jlong JNICALL Java_org_dyncall_DC_newCallVM + (JNIEnv *pEnv, jclass clazz, jint mode, jint size) +{ + return (jlong) dcNewCallVM(mode,size); +} + +void JNICALL Java_org_dyncall_DC_reset (JNIEnv *, jclass, jlong vm) +{ + DCCallVM* vm = (DCCallVM*) in_vm; + dcReset(vm); +} + +void JNICALL Java_org_dyncall_DC_argBool(JNIEnv *, jclass, jlong vm, jboolean b) +{ + DCCallVM* vm = (DCCallVM*) in_vm; + dcPushBool(vm,b); +} + +void JNICALL Java_org_dyncall_DC_argByte (JNIEnv *, jclass, jlong in_vm, jbyte b) +{ + DCCallVM* vm = (DCCallVM*) in_vm; + dcPushChar(vm,b); +} +void JNICALL Java_org_dyncall_DC_argShort(JNIEnv *, jclass, jlong in_vm, jshort s) +{ + DCCallVM* vm = (DCCallVM*) in_vm; + dcPushShort(vm,s); +} + +void JNICALL Java_org_dyncall_DC_argInt(JNIEnv *, jclass, jlong in_vm, jint i) +{ + DCCallVM* vm = (DCCallVM*) in_vm; + dcPushInt(vm,i); + +} +void JNICALL Java_org_dyncall_DC_argLong (JNIEnv *, jclass, jlong in_vm, jlong l) +{ + DCCallVM* vm = (DCCallVM*) in_vm; + dcPushLong(vm,l); +} + +void JNICALL Java_org_dyncall_DC_argChar(JNIEnv *, jclass, jlong in_vm, jchar c) +{ + DCCallVM* vm = (DCCallVM*) in_vm; + dcPushChar(vm,c); +} + +void JNICALL Java_org_dyncall_DC_argFloat(JNIEnv *, jclass, jlong in_vm, jfloat f) +{ + DCCallVM* vm = (DCCallVM*) in_vm; + dcPushFloat(vm,f); +} + +void JNICALL Java_org_dyncall_DC_argDouble(JNIEnv *, jclass, jlong in_vm, jdouble d) +{ + DCCallVM* vm = (DCCallVM*) in_vm; + dcPushDouble(vm,d); +} + +void JNICALL Java_org_dyncall_DC_argPointer__JJ(JNIEnv *, jclass, jlong in_vm, jlong l) +{ + DCCallVM* vm = (DCCallVM*) in_vm; + dcPushPointer(vm, (DCpointer) l ); +} + +void JNICALL Java_org_dyncall_DC_argPointer__JLjava_lang_Object_2(JNIEnv *, jclass, jlong in_vm, jobject o) +{ + DCCallVM* vm = (DCCallVM*) in_vm; + dcPushPointer(vm, (DCpointer) o ); +} + +void JNICALL Java_org_dyncall_DC_argString(JNIEnv *, jclass, jlong, jstring) +{ + DCCallVM* vm = (DCCallVM*) in_vm; + dcPushPointer(vm, (DCpointer) o ); +} + +void JNICALL Java_org_dyncall_DC_callVoid (JNIEnv *, jclass, jlong in_vm, jlong in_target) +{ + DCCallVM* vm = (DCCallVM*) in_vm; + dcCallVoid(vm, (DCpointer) target) +} + +/* + * Class: org_dyncall_DC + * Method: callBoolean + * Signature: (JJ)Z + */ +jboolean JNICALL Java_org_dyncall_DC_callBoolean(JNIEnv *, jclass, jlong in_vm, jlong target) +{ + DCCallVM* vm = (DCCallVM*) in_vm; + dcCallBoolean(vm, (DCpointer) target) +} + +/* + * Class: org_dyncall_DC + * Method: callInt + * Signature: (JJ)I + */ +JNIEXPORT jint JNICALL Java_org_dyncall_DC_callInt + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_dyncall_DC + * Method: callLong + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_dyncall_DC_callLong + (JNIEnv *, jclass, jlong, jlong); +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/java/jdc/src/org_dyncall_DC.h Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,157 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class org_dyncall_DC */ + +#ifndef _Included_org_dyncall_DC +#define _Included_org_dyncall_DC +#ifdef __cplusplus +extern "C" { +#endif +#undef org_dyncall_DC_DEFAULT_C +#define org_dyncall_DC_DEFAULT_C 0L +#undef org_dyncall_DC_X86_WIN32_FAST +#define org_dyncall_DC_X86_WIN32_FAST 1L +#undef org_dyncall_DC_X86_WIN32_STD +#define org_dyncall_DC_X86_WIN32_STD 2L +#undef org_dyncall_DC_X86_WIN32_THIS_MS +#define org_dyncall_DC_X86_WIN32_THIS_MS 3L +/* + * Class: org_dyncall_DC + * Method: newCallVM + * Signature: (II)J + */ +JNIEXPORT jlong JNICALL Java_org_dyncall_DC_newCallVM + (JNIEnv *, jclass, jint, jint); + +/* + * Class: org_dyncall_DC + * Method: reset + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_DC_reset + (JNIEnv *, jclass, jlong); + +/* + * Class: org_dyncall_DC + * Method: argBool + * Signature: (JZ)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_DC_argBool + (JNIEnv *, jclass, jlong, jboolean); + +/* + * Class: org_dyncall_DC + * Method: argByte + * Signature: (JB)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_DC_argByte + (JNIEnv *, jclass, jlong, jbyte); + +/* + * Class: org_dyncall_DC + * Method: argShort + * Signature: (JS)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_DC_argShort + (JNIEnv *, jclass, jlong, jshort); + +/* + * Class: org_dyncall_DC + * Method: argInt + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_DC_argInt + (JNIEnv *, jclass, jlong, jint); + +/* + * Class: org_dyncall_DC + * Method: argLong + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_DC_argLong + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_dyncall_DC + * Method: argChar + * Signature: (JC)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_DC_argChar + (JNIEnv *, jclass, jlong, jchar); + +/* + * Class: org_dyncall_DC + * Method: argFloat + * Signature: (JF)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_DC_argFloat + (JNIEnv *, jclass, jlong, jfloat); + +/* + * Class: org_dyncall_DC + * Method: argDouble + * Signature: (JD)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_DC_argDouble + (JNIEnv *, jclass, jlong, jdouble); + +/* + * Class: org_dyncall_DC + * Method: argPointer + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_DC_argPointer__JJ + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_dyncall_DC + * Method: argPointer + * Signature: (JLjava/lang/Object;)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_DC_argPointer__JLjava_lang_Object_2 + (JNIEnv *, jclass, jlong, jobject); + +/* + * Class: org_dyncall_DC + * Method: argString + * Signature: (JLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_DC_argString + (JNIEnv *, jclass, jlong, jstring); + +/* + * Class: org_dyncall_DC + * Method: callVoid + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_org_dyncall_DC_callVoid + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_dyncall_DC + * Method: callBoolean + * Signature: (JJ)Z + */ +JNIEXPORT jboolean JNICALL Java_org_dyncall_DC_callBoolean + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_dyncall_DC + * Method: callInt + * Signature: (JJ)I + */ +JNIEXPORT jint JNICALL Java_org_dyncall_DC_callInt + (JNIEnv *, jclass, jlong, jlong); + +/* + * Class: org_dyncall_DC + * Method: callLong + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_dyncall_DC_callLong + (JNIEnv *, jclass, jlong, jlong); + +#ifdef __cplusplus +} +#endif +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadc/Makefile Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,12 @@ +DC_TOP = ../../../dyncall +CC = gcc +LUA_INCDIR = ../lua-5.1.3/src +LUA_LIBDIR = ../lua-5.1.3/src +CFLAGS = -I$(LUA_INCDIR) -I$(DC_TOP)/include +LIBS = -L$(LUA_LIBDIR) $(LUA_LIBDIR)/lua51.dll -L$(DC_TOP)/lib -ldynload_s -ldyncall_s + +all: luadc.dll + +luadc.dll: luadc.o + gcc --shared $^ $(LIBS) $(OUTPUT_OPTION) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadc/README.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,27 @@ +lua bindings for dyncall +======================== + +1. loading the lua C extension + + require "package" + f = package.loadlib("luadc","luadc_open") + f() + +2. using the C extension + + libhandle = dc.load("libname") + f = dc.find(libhandle,"symbol") + +3. change calling convention mode + + dc.mode(mode) + + mode is dc.C_DEFAULT, dc.C_X86_WIN32_STD, dc.C_X86_WIN32_FAST, ... + +4. make a call + + dc.call(f, signature, args... ) + + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadc/luadc.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,184 @@ +#include <lua.h> +#include <lauxlib.h> +#include <dyncall.h> +#include <dyncall_signature.h> +#include <dynload.h> + +#define LUA_DCLIBNAME "dc" + +DCCallVM* g_pCallVM; + +int luaDC_load(lua_State* L) +{ + void* handle; + if (lua_gettop(L) != 1) return luaL_error(L,"wrong number of arguments"); + handle = dlLoadLibrary( lua_tostring(L,1) ); + if (!handle) return luaL_error(L,"library not found"); + lua_pushlightuserdata(L, handle); + return 1; +} + +int luaDC_find(lua_State* L) +{ + void* h; + const char* s; + void* f; + if (lua_gettop(L) != 2) return luaL_error(L,"wrong number of arguments"); + h = lua_touserdata(L, 1); + s = lua_tostring(L, 2); + f = dlFindSymbol(h, s); + if (!f) return luaL_error(L,"symbol not found"); + lua_pushlightuserdata(L, f); + return 1; +} + +int luaDC_mode(lua_State* L) +{ + if (lua_gettop(L) < 1) return luaL_error(L,"missing arguments"); + dcMode(g_pCallVM, (DCint) lua_tonumber(L, 1) ); + return 0; +} + +int luaDC_call(lua_State* L) +{ + void* f; + const char* s; + if (lua_gettop(L) < 2) return luaL_error(L,"missing arguments"); + + if ( lua_iscfunction(L,1) ) + f = (void*) lua_tocfunction(L,1); + else if (lua_islightuserdata(L,1) ) + f = lua_touserdata(L, 1); + else + return luaL_error(L,"argument #1 mismatch: expected userdata"); + + s = lua_tostring(L,2); + + // dcMode( g_pCallVM, DC_CALL_C_DEFAULT ); + dcReset( g_pCallVM ); + + char ch; + int p = 3; + while ( (ch = *s++) != DC_SIGCHAR_ENDARG) + { + switch(ch) + { + case DC_SIGCHAR_BOOL: + dcArgBool(g_pCallVM, (DCbool) lua_toboolean(L, p) ); + break; + case DC_SIGCHAR_CHAR: + dcArgChar(g_pCallVM, (DCchar) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_SHORT: + dcArgShort(g_pCallVM, (DCshort) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_INT: + dcArgInt(g_pCallVM, (DCint) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_LONG: + dcArgLong(g_pCallVM, (DClong) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_LONGLONG: + dcArgLongLong(g_pCallVM, (DClonglong) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_FLOAT: + dcArgFloat(g_pCallVM, (DCfloat) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_DOUBLE: + dcArgDouble(g_pCallVM, (DCdouble) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_POINTER: + dcArgPointer(g_pCallVM, (DCpointer) lua_topointer(L, p) ); + break; + case DC_SIGCHAR_STRING: + dcArgPointer(g_pCallVM, (DCpointer) lua_tostring(L, p) ); + break; + } + ++p; + } + + switch(*s) + { + case DC_SIGCHAR_VOID: + dcCallVoid(g_pCallVM, f); + return 0; + case DC_SIGCHAR_BOOL: + lua_pushboolean( L, (int) dcCallBool(g_pCallVM, f) ); + break; + case DC_SIGCHAR_CHAR: + lua_pushnumber( L, (lua_Number) ( dcCallChar(g_pCallVM,f) ) ); + break; + case DC_SIGCHAR_SHORT: + lua_pushnumber( L, (lua_Number)( dcCallShort(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_INT: + lua_pushnumber( L, (lua_Number)( dcCallInt(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_LONG: + lua_pushnumber( L, (lua_Number)( dcCallLong(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_LONGLONG: + lua_pushnumber( L, (lua_Number)( dcCallLongLong(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_FLOAT: + lua_pushnumber( L, (lua_Number) dcCallFloat(g_pCallVM, f) ); + break; + case DC_SIGCHAR_DOUBLE: + lua_pushnumber( L, (lua_Number) dcCallDouble(g_pCallVM, f) ); + break; + case DC_SIGCHAR_STRING: + lua_pushstring( L, (const char*) dcCallPointer(g_pCallVM, f) ); + break; + case DC_SIGCHAR_POINTER: + lua_pushlightuserdata( L, dcCallPointer(g_pCallVM, f) ); + break; + } + return 1; +} + +static const luaL_Reg dclib[] = +{ + {"load", luaDC_load}, + {"find", luaDC_find}, + {"mode", luaDC_mode}, + {"call", luaDC_call}, + {NULL,NULL} +}; + +typedef struct +{ + const char* name; + int value; +} ModeEnum; + +ModeEnum gModeEnums[] = +{ + "C_DEFAULT", DC_CALL_C_DEFAULT, + "C_X86_CDECL", DC_CALL_C_X86_CDECL, + "C_X86_WIN32_STD", DC_CALL_C_X86_WIN32_STD, + "C_X86_FAST_MS", DC_CALL_C_X86_WIN32_FAST_MS, + "C_X86_WIN32_THIS_MS", DC_CALL_C_X86_WIN32_THIS_MS, + "C_X86_WIN32_THIS_GNU", DC_CALL_C_X86_WIN32_THIS_GNU, + "C_X86_WIN32_FAST_GNU", DC_CALL_C_X86_WIN32_FAST_GNU, + "C_X64_WIN64", DC_CALL_C_X64_WIN64, + "C_PPC32_DARWIN", DC_CALL_C_PPC32_DARWIN, + "C_ARM", DC_CALL_C_ARM, + "C_MIPS_EABI", DC_CALL_C_MIPS32_EABI, + "C_MIPS_PSPSDK", DC_CALL_C_MIPS32_PSPSDK +}; + +LUA_API int luadc_open (lua_State* L) +{ + int i = 0, n = sizeof(gModeEnums)/sizeof(ModeEnum); + g_pCallVM = dcNewCallVM(256); + luaL_register(L, LUA_DCLIBNAME, dclib); + + for (i = 0; i < n ; ++i ) + { + lua_pushnumber(L, gModeEnums[i].value); + lua_setfield(L, -2, gModeEnums[i].name); + + } + return 1; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadc/test.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,22 @@ +require "package" +pf = package.loadlib("luadc","luadc_open") +pf() + +print(dc.C_DEFAULT) +print(dc.C_X86_WIN32_STD) + +dc.mode(dc.C_DEFAULT) + +clib = dc.load("msvcrt") +f = dc.find(clib,"sqrt") +x = dc.call(f,"d)d",144) +print(x) + + +dc.mode(dc.C_X86_WIN32_STD) + +user32 = dc.load("user32") +f = dc.find(user32,"MessageBoxA") +x = dc.call(f,"iSSi)v", 0, "Hello", "World", 0) + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/CMakeLists.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,8 @@ +cmake_minimum_required (VERSION 2.8) +project(LuaDynCall) +find_package(Lua51 REQUIRED) +add_subdirectory(dyncall) +add_subdirectory(src) +add_subdirectory(share/dynport) +# install(DIRECTORY share/dynport/ DESTINATION share/dynport FILES_MATCHING PATTERN "*.dynport") +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/INSTALL.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,5 @@ +CMake and Unix Makefiles + + $ cmake -DCMAKE_INSTALL_PREFIX=<path> + $ make install +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/README.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,52 @@ +luadyncall - lua dyncall bindings +== (C) 2010 Daniel Adler ======== + + +Build +----- +./bootstrap +./configure +make +make install + + +Package contents +---------------- + +dynload dynamic loading of code and resolving of symbols +dyncall dynamic call to code +dynport dynamic shared library linker +dynstruct C structure support (experimental) +dyntype C type information (experimental) +smartptr smart pointer +int64 64-bit signed and unsigned integer data type +array C arrays +path search and open resources by name along a path +ldynguess system-information + + + + +Build with Makefile.custom +=========================== +$EDITOR ./config +specify dyncall and lua prefix paths + + +Build with luarocks +=================== +cd src +luarocks make + + +Build using GNU Make +==================== +make + + +Build source package (maintainers only) +======================================= +make srcpkg + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/bin/luadyncall Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,7 @@ +#!/bin/sh +TOP=`dirname $0`/.. +export LUA_PATH="${TOP}/src/?.lua;${TOP}/src/?/init.lua;;" +export LUA_CPATH="${TOP}/src/?.so;;" +export LDP_PATH="${TOP}/share/dynport/?.dynport;" +lua $* +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/bootstrap Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,6 @@ +#!/bin/bash +svn co https://dyncall.org/svn/dyncall/trunk/dyncall +pushd dyncall 1>/dev/null +svn update +popd 1>/dev/null +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/buildsys/cmake/Modules/FindDynCall.cmake Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,12 @@ +find_path(DYNCALL_INCLUDE_DIR NAMES dyncall.h) +find_library(DYNCALL_LIBRARY dyncall_s) +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(DYNCALL DEFAULT_MSG DYNCALL_LIBRARY DYNCALL_INCLUDE_DIR) +if(DYNCALL_FOUND) + set(DYNCALL_LIBRARIES ${DYNCALL_LIBRARY}) + set(DYNCALL_INCLUDE_DIRS ${DYNCALL_INCLUDE_DIR}) +endif(DYNCALL_FOUND) +mark_as_advanced(DYNCALL_INCLUDE_DIR DYNCALL_LIBRARY) + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/buildsys/cmake/Modules/FindDynLoad.cmake Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,12 @@ +find_path(DYNLOAD_INCLUDE_DIR NAMES dynload.h) +find_library(DYNLOAD_LIBRARY dynload_s) +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(DYNLOAD DEFAULT_MSG DYNLOAD_LIBRARY DYNLOAD_INCLUDE_DIR) +if(DYNLOAD_FOUND) + set(DYNLOAD_LIBRARIES ${DYNLOAD_LIBRARY}) + set(DYNLOAD_INCLUDE_DIRS ${DYNLOAD_INCLUDE_DIR}) +endif(DYNLOAD_FOUND) +mark_as_advanced(DYNLOAD_INCLUDE_DIR DYNLOAD_LIBRARY) + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/config Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,6 @@ +DYNCALL ?=/usr/local +LUA ?=/opt/local +BOOST ?=/opt/local +BOOST_INCDIR ?=$(BOOST)/include +CC ?=gcc +LINKCMD ?=$(CC) $(CFLAGS) -dynamiclib
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/doc/README.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,4 @@ +LuaDoc will generate files here.. + +cd ../src and run makedoc.sh. +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/doc/guide.tex Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,45 @@ +\documentclass{article} +\begin{document} +\section{Introduction} + +The luadyncall package is a framework for writing system-level software +using lua. + +It uses the libraries from the DynCall Project for the low-level implementation +such as code loading, symbol resolving and invocation of function calls. + +It implements the portable dynamic linkage system 'dynport' for lua which +allows to bind whole shared C libraries with a single command. + +\section{Overview} + +This package provides the following extensions: + +\begin{description} +\item [dynload] dynamic loading of code and resolving of C functions +\item [dyncall] dynamic calling of loaded C functions +\item [dynport] dynamic binding of whole shared C libraries +\item [array] allocate and access C-typed arrays +\item [smartptr] smart pointer utility +\item [int64] 64-bit (unsigned) integer datatype for lua +\item [ldynguess] guess the operating system +\end{description} + +\section{C Pointers} + +One major issue was to decide how to handle pointer values and in +particular NULL pointers using dynports. + +Lua can compare pointer-values. The current dyncall implementation comes with +a function \verb@topointer(value)@ which makes a pointer value from an integer +value. There is also a \verb@NULL@ variable which holds a pointer value of 0. + +\section{Dynport} + +\subsection {The LDP\_PATH environment variable} + +The variable contains the patterns to search for dynport files when +\verb@dynport("someport")@ is called. + +\end{document} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/rockspec/Makefile Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,20 @@ +NAME =luadyncall +VERSION =0.1 +TOP =.. +TMPDIR =/tmp +DIR =$(NAME)-$(VERSION) + +.PHONY: all srcpkg srcdir clean + +all: srcpkg + +srcpkg: srcdir + tar -C $(TMPDIR) -czvpf $(TMPDIR)/$(DIR).tar.gz $(DIR) + +srcdir: + mkdir -p $(TMPDIR)/$(DIR) + cp -R $(TOP) $(TMPDIR)/$(DIR) + +clean: + rm -Rf $(TMPDIR)/$(DIR) $(TMPDIR)/$(DIR).tar.gz +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/rockspec/luadyncall-0.1-1.rockspec Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,50 @@ +package = "luadyncall" +version = "0.1-1" +source = { + url = "http://..." +} +description = { + summary = "Lua DynCall Bindings variant 2.", + detailed = [[ + Foreign Function Interface - variant 2 (built-in rock) + ]], + homepage = "http://dyncall.org", + license = "ISC" +} +dependencies = { + "lua >= 5.1" +} +external_dependencies = { + DYNCALL = { + header = "dyncall.h" + } +} +build = { + type = "builtin", + modules = { + ldynload = { + sources = "src/ldynload.c", + libraries = {"dynload_s"}, + libdirs = {"$(DYNCALL_LIBDIR)"}, + incdirs = {"$(DYNCALL_INCDIR)"} + }, + ldyncall = { + sources = "src/ldyncall.c", + libraries = {"dyncall_s"}, + libdirs = {"$(DYNCALL_LIBDIR)"}, + incdirs = {"$(DYNCALL_INCDIR)"} + }, + larray = { + sources = "src/larray.c", + incdirs = {"$(DYNCALL_INCDIR)"} + }, + dynload = "src/dynload.lua", + dyncall = "src/dyncall.lua", + dynport = "src/dynport.lua", + smartptr= "src/smartptr.lua", + path = "src/path.lua", + array = "src/array.c", + intutils= "src/intutils.lua" + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/share/dynport/AppKit.dynport Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,8 @@ +:lib +AppKit +. +:fun +NSApplicationLoad()B; +NSApplicationMain(ip)i; +. +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/share/dynport/CMakeLists.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,14 @@ + +install(FILES AppKit.dynport +CocoaEssentials.dynport +GL.dynport +GLU.dynport +SDL.dynport +SDL_image.dynport +SDL_mixer.dynport +cmath.dynport +cocoautil.dynport +gl3.dynport +stdlib.dynport +DESTINATION share/dynport +)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/share/dynport/CocoaEssentials.dynport Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,7 @@ +:lib +AppKit +. +:fun +NSApplicationLoad()B; +. +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/share/dynport/GL.dynport Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,3907 @@ +:lib +OpenGL|GL +. +:fun +glAccum(If)v; +glAlphaFunc(If)v; +glAreTexturesResident(i*I*C)C; +glArrayElement(i)v; +glBegin(I)v; +glBindTexture(II)v; +glBitmap(iiffff*C)v; +glBlendFunc(II)v; +glCallList(I)v; +glCallLists(iI*v)v; +glClear(I)v; +glClearAccum(ffff)v; +glClearColor(ffff)v; +glClearDepth(d)v; +glClearIndex(f)v; +glClearStencil(i)v; +glClipPlane(I*d)v; +glColor3b(ccc)v; +glColor3bv(*c)v; +glColor3d(ddd)v; +glColor3dv(*d)v; +glColor3f(fff)v; +glColor3fv(*f)v; +glColor3i(iii)v; +glColor3iv(*i)v; +glColor3s(sss)v; +glColor3sv(*s)v; +glColor3ub(CCC)v; +glColor3ubv(*C)v; +glColor3ui(III)v; +glColor3uiv(*I)v; +glColor3us(SSS)v; +glColor3usv(*S)v; +glColor4b(cccc)v; +glColor4bv(*c)v; +glColor4d(dddd)v; +glColor4dv(*d)v; +glColor4f(ffff)v; +glColor4fv(*f)v; +glColor4i(iiii)v; +glColor4iv(*i)v; +glColor4s(ssss)v; +glColor4sv(*s)v; +glColor4ub(CCCC)v; +glColor4ubv(*C)v; +glColor4ui(IIII)v; +glColor4uiv(*I)v; +glColor4us(SSSS)v; +glColor4usv(*S)v; +glColorMask(CCCC)v; +glColorMaterial(II)v; +glColorPointer(iIi*v)v; +glCopyPixels(iiiiI)v; +glCopyTexImage1D(IiIiiii)v; +glCopyTexImage2D(IiIiiiii)v; +glCopyTexSubImage1D(Iiiiii)v; +glCopyTexSubImage2D(Iiiiiiii)v; +glCullFace(I)v; +glDeleteLists(Ii)v; +glDeleteTextures(i*I)v; +glDepthFunc(I)v; +glDepthMask(C)v; +glDepthRange(dd)v; +glDisable(I)v; +glDisableClientState(I)v; +glDrawArrays(Iii)v; +glDrawBuffer(I)v; +glDrawElements(IiI*v)v; +glDrawPixels(iiII*v)v; +glEdgeFlag(C)v; +glEdgeFlagPointer(i*v)v; +glEdgeFlagv(*C)v; +glEnable(I)v; +glEnableClientState(I)v; +glEnd()v; +glEndList()v; +glEvalCoord1d(d)v; +glEvalCoord1dv(*d)v; +glEvalCoord1f(f)v; +glEvalCoord1fv(*f)v; +glEvalCoord2d(dd)v; +glEvalCoord2dv(*d)v; +glEvalCoord2f(ff)v; +glEvalCoord2fv(*f)v; +glEvalMesh1(Iii)v; +glEvalMesh2(Iiiii)v; +glEvalPoint1(i)v; +glEvalPoint2(ii)v; +glFeedbackBuffer(iI*f)v; +glFinish()v; +glFlush()v; +glFogf(If)v; +glFogfv(I*f)v; +glFogi(Ii)v; +glFogiv(I*i)v; +glFrontFace(I)v; +glFrustum(dddddd)v; +glGenLists(i)I; +glGenTextures(i*I)v; +glGetBooleanv(I*C)v; +glGetClipPlane(I*d)v; +glGetDoublev(I*d)v; +glGetError()I; +glGetFloatv(I*f)v; +glGetIntegerv(I*i)v; +glGetLightfv(II*f)v; +glGetLightiv(II*i)v; +glGetMapdv(II*d)v; +glGetMapfv(II*f)v; +glGetMapiv(II*i)v; +glGetMaterialfv(II*f)v; +glGetMaterialiv(II*i)v; +glGetPixelMapfv(I*f)v; +glGetPixelMapuiv(I*I)v; +glGetPixelMapusv(I*S)v; +glGetPointerv(I**v)v; +glGetPolygonStipple(*C)v; +glGetString(I)*C; +glGetTexEnvfv(II*f)v; +glGetTexEnviv(II*i)v; +glGetTexGendv(II*d)v; +glGetTexGenfv(II*f)v; +glGetTexGeniv(II*i)v; +glGetTexImage(IiII*v)v; +glGetTexLevelParameterfv(IiI*f)v; +glGetTexLevelParameteriv(IiI*i)v; +glGetTexParameterfv(II*f)v; +glGetTexParameteriv(II*i)v; +glHint(II)v; +glIndexMask(I)v; +glIndexPointer(Ii*v)v; +glIndexd(d)v; +glIndexdv(*d)v; +glIndexf(f)v; +glIndexfv(*f)v; +glIndexi(i)v; +glIndexiv(*i)v; +glIndexs(s)v; +glIndexsv(*s)v; +glIndexub(C)v; +glIndexubv(*C)v; +glInitNames()v; +glInterleavedArrays(Ii*v)v; +glIsEnabled(I)C; +glIsList(I)C; +glIsTexture(I)C; +glLightModelf(If)v; +glLightModelfv(I*f)v; +glLightModeli(Ii)v; +glLightModeliv(I*i)v; +glLightf(IIf)v; +glLightfv(II*f)v; +glLighti(IIi)v; +glLightiv(II*i)v; +glLineStipple(iS)v; +glLineWidth(f)v; +glListBase(I)v; +glLoadIdentity()v; +glLoadMatrixd(*d)v; +glLoadMatrixf(*f)v; +glLoadName(I)v; +glLogicOp(I)v; +glMap1d(Iddii*d)v; +glMap1f(Iffii*f)v; +glMap2d(Iddiiddii*d)v; +glMap2f(Iffiiffii*f)v; +glMapGrid1d(idd)v; +glMapGrid1f(iff)v; +glMapGrid2d(iddidd)v; +glMapGrid2f(iffiff)v; +glMaterialf(IIf)v; +glMaterialfv(II*f)v; +glMateriali(IIi)v; +glMaterialiv(II*i)v; +glMatrixMode(I)v; +glMultMatrixd(*d)v; +glMultMatrixf(*f)v; +glNewList(II)v; +glNormal3b(ccc)v; +glNormal3bv(*c)v; +glNormal3d(ddd)v; +glNormal3dv(*d)v; +glNormal3f(fff)v; +glNormal3fv(*f)v; +glNormal3i(iii)v; +glNormal3iv(*i)v; +glNormal3s(sss)v; +glNormal3sv(*s)v; +glNormalPointer(Ii*v)v; +glOrtho(dddddd)v; +glPassThrough(f)v; +glPixelMapfv(Ii*f)v; +glPixelMapuiv(Ii*I)v; +glPixelMapusv(Ii*S)v; +glPixelStoref(If)v; +glPixelStorei(Ii)v; +glPixelTransferf(If)v; +glPixelTransferi(Ii)v; +glPixelZoom(ff)v; +glPointSize(f)v; +glPolygonMode(II)v; +glPolygonOffset(ff)v; +glPolygonStipple(*C)v; +glPopAttrib()v; +glPopClientAttrib()v; +glPopMatrix()v; +glPopName()v; +glPrioritizeTextures(i*I*f)v; +glPushAttrib(I)v; +glPushClientAttrib(I)v; +glPushMatrix()v; +glPushName(I)v; +glRasterPos2d(dd)v; +glRasterPos2dv(*d)v; +glRasterPos2f(ff)v; +glRasterPos2fv(*f)v; +glRasterPos2i(ii)v; +glRasterPos2iv(*i)v; +glRasterPos2s(ss)v; +glRasterPos2sv(*s)v; +glRasterPos3d(ddd)v; +glRasterPos3dv(*d)v; +glRasterPos3f(fff)v; +glRasterPos3fv(*f)v; +glRasterPos3i(iii)v; +glRasterPos3iv(*i)v; +glRasterPos3s(sss)v; +glRasterPos3sv(*s)v; +glRasterPos4d(dddd)v; +glRasterPos4dv(*d)v; +glRasterPos4f(ffff)v; +glRasterPos4fv(*f)v; +glRasterPos4i(iiii)v; +glRasterPos4iv(*i)v; +glRasterPos4s(ssss)v; +glRasterPos4sv(*s)v; +glReadBuffer(I)v; +glReadPixels(iiiiII*v)v; +glRectd(dddd)v; +glRectdv(*d*d)v; +glRectf(ffff)v; +glRectfv(*f*f)v; +glRecti(iiii)v; +glRectiv(*i*i)v; +glRects(ssss)v; +glRectsv(*s*s)v; +glRenderMode(I)i; +glRotated(dddd)v; +glRotatef(ffff)v; +glScaled(ddd)v; +glScalef(fff)v; +glScissor(iiii)v; +glSelectBuffer(i*I)v; +glShadeModel(I)v; +glStencilFunc(IiI)v; +glStencilMask(I)v; +glStencilOp(III)v; +glTexCoord1d(d)v; +glTexCoord1dv(*d)v; +glTexCoord1f(f)v; +glTexCoord1fv(*f)v; +glTexCoord1i(i)v; +glTexCoord1iv(*i)v; +glTexCoord1s(s)v; +glTexCoord1sv(*s)v; +glTexCoord2d(dd)v; +glTexCoord2dv(*d)v; +glTexCoord2f(ff)v; +glTexCoord2fv(*f)v; +glTexCoord2i(ii)v; +glTexCoord2iv(*i)v; +glTexCoord2s(ss)v; +glTexCoord2sv(*s)v; +glTexCoord3d(ddd)v; +glTexCoord3dv(*d)v; +glTexCoord3f(fff)v; +glTexCoord3fv(*f)v; +glTexCoord3i(iii)v; +glTexCoord3iv(*i)v; +glTexCoord3s(sss)v; +glTexCoord3sv(*s)v; +glTexCoord4d(dddd)v; +glTexCoord4dv(*d)v; +glTexCoord4f(ffff)v; +glTexCoord4fv(*f)v; +glTexCoord4i(iiii)v; +glTexCoord4iv(*i)v; +glTexCoord4s(ssss)v; +glTexCoord4sv(*s)v; +glTexCoordPointer(iIi*v)v; +glTexEnvf(IIf)v; +glTexEnvfv(II*f)v; +glTexEnvi(IIi)v; +glTexEnviv(II*i)v; +glTexGend(IId)v; +glTexGendv(II*d)v; +glTexGenf(IIf)v; +glTexGenfv(II*f)v; +glTexGeni(IIi)v; +glTexGeniv(II*i)v; +glTexImage1D(IiiiiII*v)v; +glTexImage2D(IiiiiiII*v)v; +glTexParameterf(IIf)v; +glTexParameterfv(II*f)v; +glTexParameteri(IIi)v; +glTexParameteriv(II*i)v; +glTexSubImage1D(IiiiII*v)v; +glTexSubImage2D(IiiiiiII*v)v; +glTranslated(ddd)v; +glTranslatef(fff)v; +glVertex2d(dd)v; +glVertex2dv(*d)v; +glVertex2f(ff)v; +glVertex2fv(*f)v; +glVertex2i(ii)v; +glVertex2iv(*i)v; +glVertex2s(ss)v; +glVertex2sv(*s)v; +glVertex3d(ddd)v; +glVertex3dv(*d)v; +glVertex3f(fff)v; +glVertex3fv(*f)v; +glVertex3i(iii)v; +glVertex3iv(*i)v; +glVertex3s(sss)v; +glVertex3sv(*s)v; +glVertex4d(dddd)v; +glVertex4dv(*d)v; +glVertex4f(ffff)v; +glVertex4fv(*f)v; +glVertex4i(iiii)v; +glVertex4iv(*i)v; +glVertex4s(ssss)v; +glVertex4sv(*s)v; +glVertexPointer(iIi*v)v; +glViewport(iiii)v; +. +:const +GLAPI=extern +GL_1PASS_EXT=0x80A1 +GL_1PASS_SGIS=0x80A1 +GL_2D=0x0600 +GL_2PASS_0_EXT=0x80A2 +GL_2PASS_0_SGIS=0x80A2 +GL_2PASS_1_EXT=0x80A3 +GL_2PASS_1_SGIS=0x80A3 +GL_2X_BIT_ATI=0x00000001 +GL_2_BYTES=0x1407 +GL_3D=0x0601 +GL_3DFX_multisample=1 +GL_3DFX_tbuffer=1 +GL_3DFX_texture_compression_FXT1=1 +GL_3D_COLOR=0x0602 +GL_3D_COLOR_TEXTURE=0x0603 +GL_3_BYTES=0x1408 +GL_422_AVERAGE_EXT=0x80CE +GL_422_EXT=0x80CC +GL_422_REV_AVERAGE_EXT=0x80CF +GL_422_REV_EXT=0x80CD +GL_4D_COLOR_TEXTURE=0x0604 +GL_4PASS_0_EXT=0x80A4 +GL_4PASS_0_SGIS=0x80A4 +GL_4PASS_1_EXT=0x80A5 +GL_4PASS_1_SGIS=0x80A5 +GL_4PASS_2_EXT=0x80A6 +GL_4PASS_2_SGIS=0x80A6 +GL_4PASS_3_EXT=0x80A7 +GL_4PASS_3_SGIS=0x80A7 +GL_4X_BIT_ATI=0x00000002 +GL_4_BYTES=0x1409 +GL_8X_BIT_ATI=0x00000004 +GL_ABGR_EXT=0x8000 +GL_ACCUM=0x0100 +GL_ACCUM_ALPHA_BITS=0x0D5B +GL_ACCUM_BLUE_BITS=0x0D5A +GL_ACCUM_BUFFER_BIT=0x00000200 +GL_ACCUM_CLEAR_VALUE=0x0B80 +GL_ACCUM_GREEN_BITS=0x0D59 +GL_ACCUM_RED_BITS=0x0D58 +GL_ACTIVE_ATTRIBUTES=0x8B89 +GL_ACTIVE_ATTRIBUTE_MAX_LENGTH=0x8B8A +GL_ACTIVE_STENCIL_FACE_EXT=0x8911 +GL_ACTIVE_TEXTURE=0x84E0 +GL_ACTIVE_TEXTURE_ARB=0x84E0 +GL_ACTIVE_UNIFORMS=0x8B86 +GL_ACTIVE_UNIFORM_MAX_LENGTH=0x8B87 +GL_ACTIVE_VARYINGS_NV=0x8C81 +GL_ACTIVE_VARYING_MAX_LENGTH_NV=0x8C82 +GL_ACTIVE_VERTEX_UNITS_ARB=0x86A5 +GL_ADD=0x0104 +GL_ADD_ATI=0x8963 +GL_ADD_SIGNED=0x8574 +GL_ADD_SIGNED_ARB=0x8574 +GL_ADD_SIGNED_EXT=0x8574 +GL_ALIASED_LINE_WIDTH_RANGE=0x846E +GL_ALIASED_POINT_SIZE_RANGE=0x846D +GL_ALLOW_DRAW_FRG_HINT_PGI=0x1A210 +GL_ALLOW_DRAW_MEM_HINT_PGI=0x1A211 +GL_ALLOW_DRAW_OBJ_HINT_PGI=0x1A20E +GL_ALLOW_DRAW_WIN_HINT_PGI=0x1A20F +GL_ALL_ATTRIB_BITS=0xFFFFFFFF +GL_ALL_COMPLETED_NV=0x84F2 +GL_ALPHA12=0x803D +GL_ALPHA12_EXT=0x803D +GL_ALPHA16=0x803E +GL_ALPHA16F_ARB=0x881C +GL_ALPHA16I_EXT=0x8D8A +GL_ALPHA16UI_EXT=0x8D78 +GL_ALPHA16_EXT=0x803E +GL_ALPHA32F_ARB=0x8816 +GL_ALPHA32I_EXT=0x8D84 +GL_ALPHA32UI_EXT=0x8D72 +GL_ALPHA4=0x803B +GL_ALPHA4_EXT=0x803B +GL_ALPHA8=0x803C +GL_ALPHA8I_EXT=0x8D90 +GL_ALPHA8UI_EXT=0x8D7E +GL_ALPHA8_EXT=0x803C +GL_ALPHA=0x1906 +GL_ALPHA_BIAS=0x0D1D +GL_ALPHA_BITS=0x0D55 +GL_ALPHA_FLOAT16_ATI=0x881C +GL_ALPHA_FLOAT32_ATI=0x8816 +GL_ALPHA_INTEGER=0x8D97 +GL_ALPHA_INTEGER_EXT=0x8D97 +GL_ALPHA_MAX_CLAMP_INGR=0x8567 +GL_ALPHA_MAX_SGIX=0x8321 +GL_ALPHA_MIN_CLAMP_INGR=0x8563 +GL_ALPHA_MIN_SGIX=0x8320 +GL_ALPHA_SCALE=0x0D1C +GL_ALPHA_TEST=0x0BC0 +GL_ALPHA_TEST_FUNC=0x0BC1 +GL_ALPHA_TEST_REF=0x0BC2 +GL_ALWAYS=0x0207 +GL_ALWAYS_FAST_HINT_PGI=0x1A20C +GL_ALWAYS_SOFT_HINT_PGI=0x1A20D +GL_AMBIENT=0x1200 +GL_AMBIENT_AND_DIFFUSE=0x1602 +GL_AND=0x1501 +GL_AND_INVERTED=0x1504 +GL_AND_REVERSE=0x1502 +GL_APPLE_client_storage=1 +GL_APPLE_element_array=1 +GL_APPLE_fence=1 +GL_APPLE_specular_vector=1 +GL_APPLE_transform_hint=1 +GL_APPLE_vertex_array_object=1 +GL_APPLE_vertex_array_range=1 +GL_APPLE_ycbcr_422=1 +GL_ARB_color_buffer_float=1 +GL_ARB_depth_buffer_float=1 +GL_ARB_depth_texture=1 +GL_ARB_draw_buffers=1 +GL_ARB_draw_instanced=1 +GL_ARB_fragment_program=1 +GL_ARB_fragment_program_shadow=1 +GL_ARB_fragment_shader=1 +GL_ARB_framebuffer_object=1 +GL_ARB_framebuffer_sRGB=1 +GL_ARB_geometry_shader4=1 +GL_ARB_half_float_pixel=1 +GL_ARB_half_float_vertex=1 +GL_ARB_instanced_arrays=1 +GL_ARB_map_buffer_range=1 +GL_ARB_matrix_palette=1 +GL_ARB_multisample=1 +GL_ARB_multitexture=1 +GL_ARB_occlusion_query=1 +GL_ARB_pixel_buffer_object=1 +GL_ARB_point_parameters=1 +GL_ARB_point_sprite=1 +GL_ARB_shader_objects=1 +GL_ARB_shading_language_100=1 +GL_ARB_shadow=1 +GL_ARB_shadow_ambient=1 +GL_ARB_texture_border_clamp=1 +GL_ARB_texture_buffer_object=1 +GL_ARB_texture_compression=1 +GL_ARB_texture_compression_rgtc=1 +GL_ARB_texture_cube_map=1 +GL_ARB_texture_env_add=1 +GL_ARB_texture_env_combine=1 +GL_ARB_texture_env_crossbar=1 +GL_ARB_texture_env_dot3=1 +GL_ARB_texture_float=1 +GL_ARB_texture_mirrored_repeat=1 +GL_ARB_texture_non_power_of_two=1 +GL_ARB_texture_rectangle=1 +GL_ARB_texture_rg=1 +GL_ARB_transpose_matrix=1 +GL_ARB_vertex_array_object=1 +GL_ARB_vertex_blend=1 +GL_ARB_vertex_buffer_object=1 +GL_ARB_vertex_program=1 +GL_ARB_vertex_shader=1 +GL_ARB_window_pos=1 +GL_ARRAY_BUFFER=0x8892 +GL_ARRAY_BUFFER_ARB=0x8892 +GL_ARRAY_BUFFER_BINDING=0x8894 +GL_ARRAY_BUFFER_BINDING_ARB=0x8894 +GL_ARRAY_ELEMENT_LOCK_COUNT_EXT=0x81A9 +GL_ARRAY_ELEMENT_LOCK_FIRST_EXT=0x81A8 +GL_ARRAY_OBJECT_BUFFER_ATI=0x8766 +GL_ARRAY_OBJECT_OFFSET_ATI=0x8767 +GL_ASYNC_DRAW_PIXELS_SGIX=0x835D +GL_ASYNC_HISTOGRAM_SGIX=0x832C +GL_ASYNC_MARKER_SGIX=0x8329 +GL_ASYNC_READ_PIXELS_SGIX=0x835E +GL_ASYNC_TEX_IMAGE_SGIX=0x835C +GL_ATI_draw_buffers=1 +GL_ATI_element_array=1 +GL_ATI_envmap_bumpmap=1 +GL_ATI_fragment_shader=1 +GL_ATI_map_object_buffer=1 +GL_ATI_pixel_format_float=1 +GL_ATI_pn_triangles=1 +GL_ATI_separate_stencil=1 +GL_ATI_text_fragment_shader=1 +GL_ATI_texture_env_combine3=1 +GL_ATI_texture_float=1 +GL_ATI_texture_mirror_once=1 +GL_ATI_vertex_array_object=1 +GL_ATI_vertex_attrib_array_object=1 +GL_ATI_vertex_streams=1 +GL_ATTACHED_SHADERS=0x8B85 +GL_ATTENUATION_EXT=0x834D +GL_ATTRIB_ARRAY_POINTER_NV=0x8645 +GL_ATTRIB_ARRAY_SIZE_NV=0x8623 +GL_ATTRIB_ARRAY_STRIDE_NV=0x8624 +GL_ATTRIB_ARRAY_TYPE_NV=0x8625 +GL_ATTRIB_STACK_DEPTH=0x0BB0 +GL_AUTO_NORMAL=0x0D80 +GL_AUX0=0x0409 +GL_AUX1=0x040A +GL_AUX2=0x040B +GL_AUX3=0x040C +GL_AUX_BUFFERS=0x0C00 +GL_AVERAGE_EXT=0x8335 +GL_AVERAGE_HP=0x8160 +GL_BACK=0x0405 +GL_BACK_LEFT=0x0402 +GL_BACK_NORMALS_HINT_PGI=0x1A223 +GL_BACK_PRIMARY_COLOR_NV=0x8C77 +GL_BACK_RIGHT=0x0403 +GL_BACK_SECONDARY_COLOR_NV=0x8C78 +GL_BGR=0x80E0 +GL_BGRA=0x80E1 +GL_BGRA_EXT=0x80E1 +GL_BGRA_INTEGER=0x8D9B +GL_BGRA_INTEGER_EXT=0x8D9B +GL_BGR_EXT=0x80E0 +GL_BGR_INTEGER=0x8D9A +GL_BGR_INTEGER_EXT=0x8D9A +GL_BIAS_BIT_ATI=0x00000008 +GL_BIAS_BY_NEGATIVE_ONE_HALF_NV=0x8541 +GL_BINORMAL_ARRAY_EXT=0x843A +GL_BINORMAL_ARRAY_POINTER_EXT=0x8443 +GL_BINORMAL_ARRAY_STRIDE_EXT=0x8441 +GL_BINORMAL_ARRAY_TYPE_EXT=0x8440 +GL_BITMAP=0x1A00 +GL_BITMAP_TOKEN=0x0704 +GL_BLEND=0x0BE2 +GL_BLEND_COLOR=0x8005 +GL_BLEND_COLOR_EXT=0x8005 +GL_BLEND_DST=0x0BE0 +GL_BLEND_DST_ALPHA=0x80CA +GL_BLEND_DST_ALPHA_EXT=0x80CA +GL_BLEND_DST_RGB=0x80C8 +GL_BLEND_DST_RGB_EXT=0x80C8 +GL_BLEND_EQUATION=0x8009 +GL_BLEND_EQUATION_ALPHA=0x883D +GL_BLEND_EQUATION_ALPHA_EXT=0x883D +GL_BLEND_EQUATION_EXT=0x8009 +GL_BLEND_EQUATION_RGB=0x8009 +GL_BLEND_EQUATION_RGB_EXT=0x8009 +GL_BLEND_SRC=0x0BE1 +GL_BLEND_SRC_ALPHA=0x80CB +GL_BLEND_SRC_ALPHA_EXT=0x80CB +GL_BLEND_SRC_RGB=0x80C9 +GL_BLEND_SRC_RGB_EXT=0x80C9 +GL_BLUE=0x1905 +GL_BLUE_BIAS=0x0D1B +GL_BLUE_BITS=0x0D54 +GL_BLUE_BIT_ATI=0x00000004 +GL_BLUE_INTEGER=0x8D96 +GL_BLUE_INTEGER_EXT=0x8D96 +GL_BLUE_MAX_CLAMP_INGR=0x8566 +GL_BLUE_MIN_CLAMP_INGR=0x8562 +GL_BLUE_SCALE=0x0D1A +GL_BOOL=0x8B56 +GL_BOOL_ARB=0x8B56 +GL_BOOL_VEC2=0x8B57 +GL_BOOL_VEC2_ARB=0x8B57 +GL_BOOL_VEC3=0x8B58 +GL_BOOL_VEC3_ARB=0x8B58 +GL_BOOL_VEC4=0x8B59 +GL_BOOL_VEC4_ARB=0x8B59 +GL_BUFFER_ACCESS=0x88BB +GL_BUFFER_ACCESS_ARB=0x88BB +GL_BUFFER_GPU_ADDRESS_NV=0x8F1D +GL_BUFFER_MAPPED=0x88BC +GL_BUFFER_MAPPED_ARB=0x88BC +GL_BUFFER_MAP_POINTER=0x88BD +GL_BUFFER_MAP_POINTER_ARB=0x88BD +GL_BUFFER_SIZE=0x8764 +GL_BUFFER_SIZE_ARB=0x8764 +GL_BUFFER_USAGE=0x8765 +GL_BUFFER_USAGE_ARB=0x8765 +GL_BUMP_ENVMAP_ATI=0x877B +GL_BUMP_NUM_TEX_UNITS_ATI=0x8777 +GL_BUMP_ROT_MATRIX_ATI=0x8775 +GL_BUMP_ROT_MATRIX_SIZE_ATI=0x8776 +GL_BUMP_TARGET_ATI=0x877C +GL_BUMP_TEX_UNITS_ATI=0x8778 +GL_BYTE=0x1400 +GL_C3F_V3F=0x2A24 +GL_C4F_N3F_V3F=0x2A26 +GL_C4UB_V2F=0x2A22 +GL_C4UB_V3F=0x2A23 +GL_CALLIGRAPHIC_FRAGMENT_SGIX=0x8183 +GL_CCW=0x0901 +GL_CG_FRAGMENT_SHADER_EXT=0x890F +GL_CG_VERTEX_SHADER_EXT=0x890E +GL_CLAMP=0x2900 +GL_CLAMP_FRAGMENT_COLOR=0x891B +GL_CLAMP_FRAGMENT_COLOR_ARB=0x891B +GL_CLAMP_READ_COLOR=0x891C +GL_CLAMP_READ_COLOR_ARB=0x891C +GL_CLAMP_TO_BORDER=0x812D +GL_CLAMP_TO_BORDER_ARB=0x812D +GL_CLAMP_TO_BORDER_SGIS=0x812D +GL_CLAMP_TO_EDGE=0x812F +GL_CLAMP_TO_EDGE_SGIS=0x812F +GL_CLAMP_VERTEX_COLOR=0x891A +GL_CLAMP_VERTEX_COLOR_ARB=0x891A +GL_CLEAR=0x1500 +GL_CLIENT_ACTIVE_TEXTURE=0x84E1 +GL_CLIENT_ACTIVE_TEXTURE_ARB=0x84E1 +GL_CLIENT_ALL_ATTRIB_BITS=0xFFFFFFFF +GL_CLIENT_ATTRIB_STACK_DEPTH=0x0BB1 +GL_CLIENT_PIXEL_STORE_BIT=0x00000001 +GL_CLIENT_VERTEX_ARRAY_BIT=0x00000002 +GL_CLIP_DISTANCE0=0x3000 +GL_CLIP_DISTANCE1=0x3001 +GL_CLIP_DISTANCE2=0x3002 +GL_CLIP_DISTANCE3=0x3003 +GL_CLIP_DISTANCE4=0x3004 +GL_CLIP_DISTANCE5=0x3005 +GL_CLIP_DISTANCE_NV=0x8C7A +GL_CLIP_FAR_HINT_PGI=0x1A221 +GL_CLIP_NEAR_HINT_PGI=0x1A220 +GL_CLIP_PLANE0=0x3000 +GL_CLIP_PLANE1=0x3001 +GL_CLIP_PLANE2=0x3002 +GL_CLIP_PLANE3=0x3003 +GL_CLIP_PLANE4=0x3004 +GL_CLIP_PLANE5=0x3005 +GL_CLIP_VOLUME_CLIPPING_HINT_EXT=0x80F0 +GL_CMYKA_EXT=0x800D +GL_CMYK_EXT=0x800C +GL_CND0_ATI=0x896B +GL_CND_ATI=0x896A +GL_COEFF=0x0A00 +GL_COLOR3_BIT_PGI=0x00010000 +GL_COLOR4_BIT_PGI=0x00020000 +GL_COLOR=0x1800 +GL_COLOR_ALPHA_PAIRING_ATI=0x8975 +GL_COLOR_ARRAY=0x8076 +GL_COLOR_ARRAY_ADDRESS_NV=0x8F23 +GL_COLOR_ARRAY_BUFFER_BINDING=0x8898 +GL_COLOR_ARRAY_BUFFER_BINDING_ARB=0x8898 +GL_COLOR_ARRAY_COUNT_EXT=0x8084 +GL_COLOR_ARRAY_EXT=0x8076 +GL_COLOR_ARRAY_LENGTH_NV=0x8F2D +GL_COLOR_ARRAY_LIST_IBM=103072 +GL_COLOR_ARRAY_LIST_STRIDE_IBM=103082 +GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL=0x83F7 +GL_COLOR_ARRAY_POINTER=0x8090 +GL_COLOR_ARRAY_POINTER_EXT=0x8090 +GL_COLOR_ARRAY_SIZE=0x8081 +GL_COLOR_ARRAY_SIZE_EXT=0x8081 +GL_COLOR_ARRAY_STRIDE=0x8083 +GL_COLOR_ARRAY_STRIDE_EXT=0x8083 +GL_COLOR_ARRAY_TYPE=0x8082 +GL_COLOR_ARRAY_TYPE_EXT=0x8082 +GL_COLOR_ATTACHMENT0=0x8CE0 +GL_COLOR_ATTACHMENT0_EXT=0x8CE0 +GL_COLOR_ATTACHMENT10=0x8CEA +GL_COLOR_ATTACHMENT10_EXT=0x8CEA +GL_COLOR_ATTACHMENT11=0x8CEB +GL_COLOR_ATTACHMENT11_EXT=0x8CEB +GL_COLOR_ATTACHMENT12=0x8CEC +GL_COLOR_ATTACHMENT12_EXT=0x8CEC +GL_COLOR_ATTACHMENT13=0x8CED +GL_COLOR_ATTACHMENT13_EXT=0x8CED +GL_COLOR_ATTACHMENT14=0x8CEE +GL_COLOR_ATTACHMENT14_EXT=0x8CEE +GL_COLOR_ATTACHMENT15=0x8CEF +GL_COLOR_ATTACHMENT15_EXT=0x8CEF +GL_COLOR_ATTACHMENT1=0x8CE1 +GL_COLOR_ATTACHMENT1_EXT=0x8CE1 +GL_COLOR_ATTACHMENT2=0x8CE2 +GL_COLOR_ATTACHMENT2_EXT=0x8CE2 +GL_COLOR_ATTACHMENT3=0x8CE3 +GL_COLOR_ATTACHMENT3_EXT=0x8CE3 +GL_COLOR_ATTACHMENT4=0x8CE4 +GL_COLOR_ATTACHMENT4_EXT=0x8CE4 +GL_COLOR_ATTACHMENT5=0x8CE5 +GL_COLOR_ATTACHMENT5_EXT=0x8CE5 +GL_COLOR_ATTACHMENT6=0x8CE6 +GL_COLOR_ATTACHMENT6_EXT=0x8CE6 +GL_COLOR_ATTACHMENT7=0x8CE7 +GL_COLOR_ATTACHMENT7_EXT=0x8CE7 +GL_COLOR_ATTACHMENT8=0x8CE8 +GL_COLOR_ATTACHMENT8_EXT=0x8CE8 +GL_COLOR_ATTACHMENT9=0x8CE9 +GL_COLOR_ATTACHMENT9_EXT=0x8CE9 +GL_COLOR_BUFFER_BIT=0x00004000 +GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI=0x8835 +GL_COLOR_CLEAR_VALUE=0x0C22 +GL_COLOR_INDEX12_EXT=0x80E6 +GL_COLOR_INDEX16_EXT=0x80E7 +GL_COLOR_INDEX1_EXT=0x80E2 +GL_COLOR_INDEX2_EXT=0x80E3 +GL_COLOR_INDEX4_EXT=0x80E4 +GL_COLOR_INDEX8_EXT=0x80E5 +GL_COLOR_INDEX=0x1900 +GL_COLOR_INDEXES=0x1603 +GL_COLOR_LOGIC_OP=0x0BF2 +GL_COLOR_MATERIAL=0x0B57 +GL_COLOR_MATERIAL_FACE=0x0B55 +GL_COLOR_MATERIAL_PARAMETER=0x0B56 +GL_COLOR_MATRIX=0x80B1 +GL_COLOR_MATRIX_SGI=0x80B1 +GL_COLOR_MATRIX_STACK_DEPTH=0x80B2 +GL_COLOR_MATRIX_STACK_DEPTH_SGI=0x80B2 +GL_COLOR_SUM=0x8458 +GL_COLOR_SUM_ARB=0x8458 +GL_COLOR_SUM_CLAMP_NV=0x854F +GL_COLOR_SUM_EXT=0x8458 +GL_COLOR_TABLE=0x80D0 +GL_COLOR_TABLE_ALPHA_SIZE=0x80DD +GL_COLOR_TABLE_ALPHA_SIZE_SGI=0x80DD +GL_COLOR_TABLE_BIAS=0x80D7 +GL_COLOR_TABLE_BIAS_SGI=0x80D7 +GL_COLOR_TABLE_BLUE_SIZE=0x80DC +GL_COLOR_TABLE_BLUE_SIZE_SGI=0x80DC +GL_COLOR_TABLE_FORMAT=0x80D8 +GL_COLOR_TABLE_FORMAT_SGI=0x80D8 +GL_COLOR_TABLE_GREEN_SIZE=0x80DB +GL_COLOR_TABLE_GREEN_SIZE_SGI=0x80DB +GL_COLOR_TABLE_INTENSITY_SIZE=0x80DF +GL_COLOR_TABLE_INTENSITY_SIZE_SGI=0x80DF +GL_COLOR_TABLE_LUMINANCE_SIZE=0x80DE +GL_COLOR_TABLE_LUMINANCE_SIZE_SGI=0x80DE +GL_COLOR_TABLE_RED_SIZE=0x80DA +GL_COLOR_TABLE_RED_SIZE_SGI=0x80DA +GL_COLOR_TABLE_SCALE=0x80D6 +GL_COLOR_TABLE_SCALE_SGI=0x80D6 +GL_COLOR_TABLE_SGI=0x80D0 +GL_COLOR_TABLE_WIDTH=0x80D9 +GL_COLOR_TABLE_WIDTH_SGI=0x80D9 +GL_COLOR_WRITEMASK=0x0C23 +GL_COMBINE4_NV=0x8503 +GL_COMBINE=0x8570 +GL_COMBINER0_NV=0x8550 +GL_COMBINER1_NV=0x8551 +GL_COMBINER2_NV=0x8552 +GL_COMBINER3_NV=0x8553 +GL_COMBINER4_NV=0x8554 +GL_COMBINER5_NV=0x8555 +GL_COMBINER6_NV=0x8556 +GL_COMBINER7_NV=0x8557 +GL_COMBINER_AB_DOT_PRODUCT_NV=0x8545 +GL_COMBINER_AB_OUTPUT_NV=0x854A +GL_COMBINER_BIAS_NV=0x8549 +GL_COMBINER_CD_DOT_PRODUCT_NV=0x8546 +GL_COMBINER_CD_OUTPUT_NV=0x854B +GL_COMBINER_COMPONENT_USAGE_NV=0x8544 +GL_COMBINER_INPUT_NV=0x8542 +GL_COMBINER_MAPPING_NV=0x8543 +GL_COMBINER_MUX_SUM_NV=0x8547 +GL_COMBINER_SCALE_NV=0x8548 +GL_COMBINER_SUM_OUTPUT_NV=0x854C +GL_COMBINE_ALPHA=0x8572 +GL_COMBINE_ALPHA_ARB=0x8572 +GL_COMBINE_ALPHA_EXT=0x8572 +GL_COMBINE_ARB=0x8570 +GL_COMBINE_EXT=0x8570 +GL_COMBINE_RGB=0x8571 +GL_COMBINE_RGB_ARB=0x8571 +GL_COMBINE_RGB_EXT=0x8571 +GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT=0x884E +GL_COMPARE_REF_TO_TEXTURE=0x884E +GL_COMPARE_R_TO_TEXTURE=0x884E +GL_COMPARE_R_TO_TEXTURE_ARB=0x884E +GL_COMPILE=0x1300 +GL_COMPILE_AND_EXECUTE=0x1301 +GL_COMPILE_STATUS=0x8B81 +GL_COMPRESSED_ALPHA=0x84E9 +GL_COMPRESSED_ALPHA_ARB=0x84E9 +GL_COMPRESSED_INTENSITY=0x84EC +GL_COMPRESSED_INTENSITY_ARB=0x84EC +GL_COMPRESSED_LUMINANCE=0x84EA +GL_COMPRESSED_LUMINANCE_ALPHA=0x84EB +GL_COMPRESSED_LUMINANCE_ALPHA_ARB=0x84EB +GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT=0x8C72 +GL_COMPRESSED_LUMINANCE_ARB=0x84EA +GL_COMPRESSED_LUMINANCE_LATC1_EXT=0x8C70 +GL_COMPRESSED_RED=0x8225 +GL_COMPRESSED_RED_GREEN_RGTC2_EXT=0x8DBD +GL_COMPRESSED_RED_RGTC1=0x8DBB +GL_COMPRESSED_RED_RGTC1_EXT=0x8DBB +GL_COMPRESSED_RG=0x8226 +GL_COMPRESSED_RGB=0x84ED +GL_COMPRESSED_RGBA=0x84EE +GL_COMPRESSED_RGBA_ARB=0x84EE +GL_COMPRESSED_RGBA_FXT1_3DFX=0x86B1 +GL_COMPRESSED_RGBA_S3TC_DXT1_EXT=0x83F1 +GL_COMPRESSED_RGBA_S3TC_DXT3_EXT=0x83F2 +GL_COMPRESSED_RGBA_S3TC_DXT5_EXT=0x83F3 +GL_COMPRESSED_RGB_ARB=0x84ED +GL_COMPRESSED_RGB_FXT1_3DFX=0x86B0 +GL_COMPRESSED_RGB_S3TC_DXT1_EXT=0x83F0 +GL_COMPRESSED_RG_RGTC2=0x8DBD +GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT=0x8C73 +GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT=0x8C71 +GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT=0x8DBE +GL_COMPRESSED_SIGNED_RED_RGTC1=0x8DBC +GL_COMPRESSED_SIGNED_RED_RGTC1_EXT=0x8DBC +GL_COMPRESSED_SIGNED_RG_RGTC2=0x8DBE +GL_COMPRESSED_SLUMINANCE=0x8C4A +GL_COMPRESSED_SLUMINANCE_ALPHA=0x8C4B +GL_COMPRESSED_SRGB=0x8C48 +GL_COMPRESSED_SRGB_ALPHA=0x8C49 +GL_COMPRESSED_TEXTURE_FORMATS=0x86A3 +GL_COMPRESSED_TEXTURE_FORMATS_ARB=0x86A3 +GL_COMP_BIT_ATI=0x00000002 +GL_CONSERVE_MEMORY_HINT_PGI=0x1A1FD +GL_CONSTANT=0x8576 +GL_CONSTANT_ALPHA=0x8003 +GL_CONSTANT_ALPHA_EXT=0x8003 +GL_CONSTANT_ARB=0x8576 +GL_CONSTANT_ATTENUATION=0x1207 +GL_CONSTANT_BORDER=0x8151 +GL_CONSTANT_BORDER_HP=0x8151 +GL_CONSTANT_COLOR0_NV=0x852A +GL_CONSTANT_COLOR1_NV=0x852B +GL_CONSTANT_COLOR=0x8001 +GL_CONSTANT_COLOR_EXT=0x8001 +GL_CONSTANT_EXT=0x8576 +GL_CONST_EYE_NV=0x86E5 +GL_CONTEXT_FLAGS=0x821E +GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT=0x0001 +GL_CONVOLUTION_1D=0x8010 +GL_CONVOLUTION_1D_EXT=0x8010 +GL_CONVOLUTION_2D=0x8011 +GL_CONVOLUTION_2D_EXT=0x8011 +GL_CONVOLUTION_BORDER_COLOR=0x8154 +GL_CONVOLUTION_BORDER_COLOR_HP=0x8154 +GL_CONVOLUTION_BORDER_MODE=0x8013 +GL_CONVOLUTION_BORDER_MODE_EXT=0x8013 +GL_CONVOLUTION_FILTER_BIAS=0x8015 +GL_CONVOLUTION_FILTER_BIAS_EXT=0x8015 +GL_CONVOLUTION_FILTER_SCALE=0x8014 +GL_CONVOLUTION_FILTER_SCALE_EXT=0x8014 +GL_CONVOLUTION_FORMAT=0x8017 +GL_CONVOLUTION_FORMAT_EXT=0x8017 +GL_CONVOLUTION_HEIGHT=0x8019 +GL_CONVOLUTION_HEIGHT_EXT=0x8019 +GL_CONVOLUTION_HINT_SGIX=0x8316 +GL_CONVOLUTION_WIDTH=0x8018 +GL_CONVOLUTION_WIDTH_EXT=0x8018 +GL_CON_0_ATI=0x8941 +GL_CON_10_ATI=0x894B +GL_CON_11_ATI=0x894C +GL_CON_12_ATI=0x894D +GL_CON_13_ATI=0x894E +GL_CON_14_ATI=0x894F +GL_CON_15_ATI=0x8950 +GL_CON_16_ATI=0x8951 +GL_CON_17_ATI=0x8952 +GL_CON_18_ATI=0x8953 +GL_CON_19_ATI=0x8954 +GL_CON_1_ATI=0x8942 +GL_CON_20_ATI=0x8955 +GL_CON_21_ATI=0x8956 +GL_CON_22_ATI=0x8957 +GL_CON_23_ATI=0x8958 +GL_CON_24_ATI=0x8959 +GL_CON_25_ATI=0x895A +GL_CON_26_ATI=0x895B +GL_CON_27_ATI=0x895C +GL_CON_28_ATI=0x895D +GL_CON_29_ATI=0x895E +GL_CON_2_ATI=0x8943 +GL_CON_30_ATI=0x895F +GL_CON_31_ATI=0x8960 +GL_CON_3_ATI=0x8944 +GL_CON_4_ATI=0x8945 +GL_CON_5_ATI=0x8946 +GL_CON_6_ATI=0x8947 +GL_CON_7_ATI=0x8948 +GL_CON_8_ATI=0x8949 +GL_CON_9_ATI=0x894A +GL_COORD_REPLACE=0x8862 +GL_COORD_REPLACE_ARB=0x8862 +GL_COORD_REPLACE_NV=0x8862 +GL_COPY=0x1503 +GL_COPY_INVERTED=0x150C +GL_COPY_PIXEL_TOKEN=0x0706 +GL_CUBIC_EXT=0x8334 +GL_CUBIC_HP=0x815F +GL_CULL_FACE=0x0B44 +GL_CULL_FACE_MODE=0x0B45 +GL_CULL_FRAGMENT_NV=0x86E7 +GL_CULL_MODES_NV=0x86E0 +GL_CULL_VERTEX_EXT=0x81AA +GL_CULL_VERTEX_EYE_POSITION_EXT=0x81AB +GL_CULL_VERTEX_IBM=103050 +GL_CULL_VERTEX_OBJECT_POSITION_EXT=0x81AC +GL_CURRENT_ATTRIB_NV=0x8626 +GL_CURRENT_BINORMAL_EXT=0x843C +GL_CURRENT_BIT=0x00000001 +GL_CURRENT_COLOR=0x0B00 +GL_CURRENT_FOG_COORD=0x8453 +GL_CURRENT_FOG_COORDINATE=0x8453 +GL_CURRENT_FOG_COORDINATE_EXT=0x8453 +GL_CURRENT_INDEX=0x0B01 +GL_CURRENT_MATRIX_ARB=0x8641 +GL_CURRENT_MATRIX_INDEX_ARB=0x8845 +GL_CURRENT_MATRIX_NV=0x8641 +GL_CURRENT_MATRIX_STACK_DEPTH_ARB=0x8640 +GL_CURRENT_MATRIX_STACK_DEPTH_NV=0x8640 +GL_CURRENT_NORMAL=0x0B02 +GL_CURRENT_OCCLUSION_QUERY_ID_NV=0x8865 +GL_CURRENT_PALETTE_MATRIX_ARB=0x8843 +GL_CURRENT_PROGRAM=0x8B8D +GL_CURRENT_QUERY=0x8865 +GL_CURRENT_QUERY_ARB=0x8865 +GL_CURRENT_RASTER_COLOR=0x0B04 +GL_CURRENT_RASTER_DISTANCE=0x0B09 +GL_CURRENT_RASTER_INDEX=0x0B05 +GL_CURRENT_RASTER_NORMAL_SGIX=0x8406 +GL_CURRENT_RASTER_POSITION=0x0B07 +GL_CURRENT_RASTER_POSITION_VALID=0x0B08 +GL_CURRENT_RASTER_SECONDARY_COLOR=0x845F +GL_CURRENT_RASTER_TEXTURE_COORDS=0x0B06 +GL_CURRENT_SECONDARY_COLOR=0x8459 +GL_CURRENT_SECONDARY_COLOR_EXT=0x8459 +GL_CURRENT_TANGENT_EXT=0x843B +GL_CURRENT_TEXTURE_COORDS=0x0B03 +GL_CURRENT_TIME_NV=0x8E28 +GL_CURRENT_VERTEX_ATTRIB=0x8626 +GL_CURRENT_VERTEX_ATTRIB_ARB=0x8626 +GL_CURRENT_VERTEX_EXT=0x87E2 +GL_CURRENT_VERTEX_WEIGHT_EXT=0x850B +GL_CURRENT_WEIGHT_ARB=0x86A8 +GL_CW=0x0900 +GL_DECAL=0x2101 +GL_DECR=0x1E03 +GL_DECR_WRAP=0x8508 +GL_DECR_WRAP_EXT=0x8508 +GL_DEFORMATIONS_MASK_SGIX=0x8196 +GL_DELETE_STATUS=0x8B80 +GL_DEPENDENT_AR_TEXTURE_2D_NV=0x86E9 +GL_DEPENDENT_GB_TEXTURE_2D_NV=0x86EA +GL_DEPENDENT_HILO_TEXTURE_2D_NV=0x8858 +GL_DEPENDENT_RGB_TEXTURE_3D_NV=0x8859 +GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV=0x885A +GL_DEPTH24_STENCIL8=0x88F0 +GL_DEPTH24_STENCIL8_EXT=0x88F0 +GL_DEPTH32F_STENCIL8=0x8CAD +GL_DEPTH32F_STENCIL8_NV=0x8DAC +GL_DEPTH=0x1801 +GL_DEPTH_ATTACHMENT=0x8D00 +GL_DEPTH_ATTACHMENT_EXT=0x8D00 +GL_DEPTH_BIAS=0x0D1F +GL_DEPTH_BITS=0x0D56 +GL_DEPTH_BOUNDS_EXT=0x8891 +GL_DEPTH_BOUNDS_TEST_EXT=0x8890 +GL_DEPTH_BUFFER=0x8223 +GL_DEPTH_BUFFER_BIT=0x00000100 +GL_DEPTH_BUFFER_FLOAT_MODE_NV=0x8DAF +GL_DEPTH_CLAMP_NV=0x864F +GL_DEPTH_CLEAR_VALUE=0x0B73 +GL_DEPTH_COMPONENT16=0x81A5 +GL_DEPTH_COMPONENT16_ARB=0x81A5 +GL_DEPTH_COMPONENT16_SGIX=0x81A5 +GL_DEPTH_COMPONENT24=0x81A6 +GL_DEPTH_COMPONENT24_ARB=0x81A6 +GL_DEPTH_COMPONENT24_SGIX=0x81A6 +GL_DEPTH_COMPONENT32=0x81A7 +GL_DEPTH_COMPONENT32F=0x8CAC +GL_DEPTH_COMPONENT32F_NV=0x8DAB +GL_DEPTH_COMPONENT32_ARB=0x81A7 +GL_DEPTH_COMPONENT32_SGIX=0x81A7 +GL_DEPTH_COMPONENT=0x1902 +GL_DEPTH_FUNC=0x0B74 +GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX=0x8311 +GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX=0x8312 +GL_DEPTH_PASS_INSTRUMENT_SGIX=0x8310 +GL_DEPTH_RANGE=0x0B70 +GL_DEPTH_SCALE=0x0D1E +GL_DEPTH_STENCIL=0x84F9 +GL_DEPTH_STENCIL_ATTACHMENT=0x821A +GL_DEPTH_STENCIL_EXT=0x84F9 +GL_DEPTH_STENCIL_NV=0x84F9 +GL_DEPTH_STENCIL_TO_BGRA_NV=0x886F +GL_DEPTH_STENCIL_TO_RGBA_NV=0x886E +GL_DEPTH_TEST=0x0B71 +GL_DEPTH_TEXTURE_MODE=0x884B +GL_DEPTH_TEXTURE_MODE_ARB=0x884B +GL_DEPTH_WRITEMASK=0x0B72 +GL_DETAIL_TEXTURE_2D_BINDING_SGIS=0x8096 +GL_DETAIL_TEXTURE_2D_SGIS=0x8095 +GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS=0x809C +GL_DETAIL_TEXTURE_LEVEL_SGIS=0x809A +GL_DETAIL_TEXTURE_MODE_SGIS=0x809B +GL_DIFFUSE=0x1201 +GL_DISCARD_ATI=0x8763 +GL_DISCARD_NV=0x8530 +GL_DISTANCE_ATTENUATION_EXT=0x8129 +GL_DISTANCE_ATTENUATION_SGIS=0x8129 +GL_DITHER=0x0BD0 +GL_DOMAIN=0x0A02 +GL_DONT_CARE=0x1100 +GL_DOT2_ADD_ATI=0x896C +GL_DOT3_ATI=0x8966 +GL_DOT3_RGB=0x86AE +GL_DOT3_RGBA=0x86AF +GL_DOT3_RGBA_ARB=0x86AF +GL_DOT3_RGBA_EXT=0x8741 +GL_DOT3_RGB_ARB=0x86AE +GL_DOT3_RGB_EXT=0x8740 +GL_DOT4_ATI=0x8967 +GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV=0x885D +GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV=0x86F3 +GL_DOT_PRODUCT_DEPTH_REPLACE_NV=0x86ED +GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV=0x86F1 +GL_DOT_PRODUCT_NV=0x86EC +GL_DOT_PRODUCT_PASS_THROUGH_NV=0x885B +GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV=0x86F2 +GL_DOT_PRODUCT_TEXTURE_1D_NV=0x885C +GL_DOT_PRODUCT_TEXTURE_2D_NV=0x86EE +GL_DOT_PRODUCT_TEXTURE_3D_NV=0x86EF +GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV=0x86F0 +GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV=0x864E +GL_DOUBLE=0x140A +GL_DOUBLEBUFFER=0x0C32 +GL_DOUBLE_EXT=0x140A +GL_DRAW_BUFFER0=0x8825 +GL_DRAW_BUFFER0_ARB=0x8825 +GL_DRAW_BUFFER0_ATI=0x8825 +GL_DRAW_BUFFER10=0x882F +GL_DRAW_BUFFER10_ARB=0x882F +GL_DRAW_BUFFER10_ATI=0x882F +GL_DRAW_BUFFER11=0x8830 +GL_DRAW_BUFFER11_ARB=0x8830 +GL_DRAW_BUFFER11_ATI=0x8830 +GL_DRAW_BUFFER12=0x8831 +GL_DRAW_BUFFER12_ARB=0x8831 +GL_DRAW_BUFFER12_ATI=0x8831 +GL_DRAW_BUFFER13=0x8832 +GL_DRAW_BUFFER13_ARB=0x8832 +GL_DRAW_BUFFER13_ATI=0x8832 +GL_DRAW_BUFFER14=0x8833 +GL_DRAW_BUFFER14_ARB=0x8833 +GL_DRAW_BUFFER14_ATI=0x8833 +GL_DRAW_BUFFER15=0x8834 +GL_DRAW_BUFFER15_ARB=0x8834 +GL_DRAW_BUFFER15_ATI=0x8834 +GL_DRAW_BUFFER1=0x8826 +GL_DRAW_BUFFER1_ARB=0x8826 +GL_DRAW_BUFFER1_ATI=0x8826 +GL_DRAW_BUFFER2=0x8827 +GL_DRAW_BUFFER2_ARB=0x8827 +GL_DRAW_BUFFER2_ATI=0x8827 +GL_DRAW_BUFFER3=0x8828 +GL_DRAW_BUFFER3_ARB=0x8828 +GL_DRAW_BUFFER3_ATI=0x8828 +GL_DRAW_BUFFER4=0x8829 +GL_DRAW_BUFFER4_ARB=0x8829 +GL_DRAW_BUFFER4_ATI=0x8829 +GL_DRAW_BUFFER5=0x882A +GL_DRAW_BUFFER5_ARB=0x882A +GL_DRAW_BUFFER5_ATI=0x882A +GL_DRAW_BUFFER6=0x882B +GL_DRAW_BUFFER6_ARB=0x882B +GL_DRAW_BUFFER6_ATI=0x882B +GL_DRAW_BUFFER7=0x882C +GL_DRAW_BUFFER7_ARB=0x882C +GL_DRAW_BUFFER7_ATI=0x882C +GL_DRAW_BUFFER8=0x882D +GL_DRAW_BUFFER8_ARB=0x882D +GL_DRAW_BUFFER8_ATI=0x882D +GL_DRAW_BUFFER9=0x882E +GL_DRAW_BUFFER9_ARB=0x882E +GL_DRAW_BUFFER9_ATI=0x882E +GL_DRAW_BUFFER=0x0C01 +GL_DRAW_FRAMEBUFFER=0x8CA9 +GL_DRAW_FRAMEBUFFER_BINDING=0x8CA6 +GL_DRAW_FRAMEBUFFER_BINDING_EXT=0x8CA6 +GL_DRAW_FRAMEBUFFER_EXT=0x8CA9 +GL_DRAW_PIXELS_APPLE=0x8A0A +GL_DRAW_PIXEL_TOKEN=0x0705 +GL_DSDT8_MAG8_INTENSITY8_NV=0x870B +GL_DSDT8_MAG8_NV=0x870A +GL_DSDT8_NV=0x8709 +GL_DSDT_MAG_INTENSITY_NV=0x86DC +GL_DSDT_MAG_NV=0x86F6 +GL_DSDT_MAG_VIB_NV=0x86F7 +GL_DSDT_NV=0x86F5 +GL_DST_ALPHA=0x0304 +GL_DST_COLOR=0x0306 +GL_DS_BIAS_NV=0x8716 +GL_DS_SCALE_NV=0x8710 +GL_DT_BIAS_NV=0x8717 +GL_DT_SCALE_NV=0x8711 +GL_DU8DV8_ATI=0x877A +GL_DUAL_ALPHA12_SGIS=0x8112 +GL_DUAL_ALPHA16_SGIS=0x8113 +GL_DUAL_ALPHA4_SGIS=0x8110 +GL_DUAL_ALPHA8_SGIS=0x8111 +GL_DUAL_INTENSITY12_SGIS=0x811A +GL_DUAL_INTENSITY16_SGIS=0x811B +GL_DUAL_INTENSITY4_SGIS=0x8118 +GL_DUAL_INTENSITY8_SGIS=0x8119 +GL_DUAL_LUMINANCE12_SGIS=0x8116 +GL_DUAL_LUMINANCE16_SGIS=0x8117 +GL_DUAL_LUMINANCE4_SGIS=0x8114 +GL_DUAL_LUMINANCE8_SGIS=0x8115 +GL_DUAL_LUMINANCE_ALPHA4_SGIS=0x811C +GL_DUAL_LUMINANCE_ALPHA8_SGIS=0x811D +GL_DUAL_TEXTURE_SELECT_SGIS=0x8124 +GL_DUDV_ATI=0x8779 +GL_DYNAMIC_ATI=0x8761 +GL_DYNAMIC_COPY=0x88EA +GL_DYNAMIC_COPY_ARB=0x88EA +GL_DYNAMIC_DRAW=0x88E8 +GL_DYNAMIC_DRAW_ARB=0x88E8 +GL_DYNAMIC_READ=0x88E9 +GL_DYNAMIC_READ_ARB=0x88E9 +GL_EDGEFLAG_BIT_PGI=0x00040000 +GL_EDGE_FLAG=0x0B43 +GL_EDGE_FLAG_ARRAY=0x8079 +GL_EDGE_FLAG_ARRAY_ADDRESS_NV=0x8F26 +GL_EDGE_FLAG_ARRAY_BUFFER_BINDING=0x889B +GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB=0x889B +GL_EDGE_FLAG_ARRAY_COUNT_EXT=0x808D +GL_EDGE_FLAG_ARRAY_EXT=0x8079 +GL_EDGE_FLAG_ARRAY_LENGTH_NV=0x8F30 +GL_EDGE_FLAG_ARRAY_LIST_IBM=103075 +GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM=103085 +GL_EDGE_FLAG_ARRAY_POINTER=0x8093 +GL_EDGE_FLAG_ARRAY_POINTER_EXT=0x8093 +GL_EDGE_FLAG_ARRAY_STRIDE=0x808C +GL_EDGE_FLAG_ARRAY_STRIDE_EXT=0x808C +GL_EIGHTH_BIT_ATI=0x00000020 +GL_ELEMENT_ARRAY_ADDRESS_NV=0x8F29 +GL_ELEMENT_ARRAY_APPLE=0x8768 +GL_ELEMENT_ARRAY_ATI=0x8768 +GL_ELEMENT_ARRAY_BUFFER=0x8893 +GL_ELEMENT_ARRAY_BUFFER_ARB=0x8893 +GL_ELEMENT_ARRAY_BUFFER_BINDING=0x8895 +GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB=0x8895 +GL_ELEMENT_ARRAY_LENGTH_NV=0x8F33 +GL_ELEMENT_ARRAY_POINTER_APPLE=0x876A +GL_ELEMENT_ARRAY_POINTER_ATI=0x876A +GL_ELEMENT_ARRAY_TYPE_APPLE=0x8769 +GL_ELEMENT_ARRAY_TYPE_ATI=0x8769 +GL_ELEMENT_ARRAY_UNIFIED_NV=0x8F1F +GL_EMBOSS_CONSTANT_NV=0x855E +GL_EMBOSS_LIGHT_NV=0x855D +GL_EMBOSS_MAP_NV=0x855F +GL_EMISSION=0x1600 +GL_ENABLE_BIT=0x00002000 +GL_EQUAL=0x0202 +GL_EQUIV=0x1509 +GL_EVAL_2D_NV=0x86C0 +GL_EVAL_BIT=0x00010000 +GL_EVAL_FRACTIONAL_TESSELLATION_NV=0x86C5 +GL_EVAL_TRIANGULAR_2D_NV=0x86C1 +GL_EVAL_VERTEX_ATTRIB0_NV=0x86C6 +GL_EVAL_VERTEX_ATTRIB10_NV=0x86D0 +GL_EVAL_VERTEX_ATTRIB11_NV=0x86D1 +GL_EVAL_VERTEX_ATTRIB12_NV=0x86D2 +GL_EVAL_VERTEX_ATTRIB13_NV=0x86D3 +GL_EVAL_VERTEX_ATTRIB14_NV=0x86D4 +GL_EVAL_VERTEX_ATTRIB15_NV=0x86D5 +GL_EVAL_VERTEX_ATTRIB1_NV=0x86C7 +GL_EVAL_VERTEX_ATTRIB2_NV=0x86C8 +GL_EVAL_VERTEX_ATTRIB3_NV=0x86C9 +GL_EVAL_VERTEX_ATTRIB4_NV=0x86CA +GL_EVAL_VERTEX_ATTRIB5_NV=0x86CB +GL_EVAL_VERTEX_ATTRIB6_NV=0x86CC +GL_EVAL_VERTEX_ATTRIB7_NV=0x86CD +GL_EVAL_VERTEX_ATTRIB8_NV=0x86CE +GL_EVAL_VERTEX_ATTRIB9_NV=0x86CF +GL_EXP2=0x0801 +GL_EXP=0x0800 +GL_EXPAND_NEGATE_NV=0x8539 +GL_EXPAND_NORMAL_NV=0x8538 +GL_EXTENSIONS=0x1F03 +GL_EXT_422_pixels=1 +GL_EXT_Cg_shader=1 +GL_EXT_abgr=1 +GL_EXT_bgra=1 +GL_EXT_bindable_uniform=1 +GL_EXT_blend_color=1 +GL_EXT_blend_equation_separate=1 +GL_EXT_blend_func_separate=1 +GL_EXT_blend_logic_op=1 +GL_EXT_blend_minmax=1 +GL_EXT_blend_subtract=1 +GL_EXT_clip_volume_hint=1 +GL_EXT_cmyka=1 +GL_EXT_color_matrix=1 +GL_EXT_color_subtable=1 +GL_EXT_compiled_vertex_array=1 +GL_EXT_convolution=1 +GL_EXT_coordinate_frame=1 +GL_EXT_copy_texture=1 +GL_EXT_cull_vertex=1 +GL_EXT_depth_bounds_test=1 +GL_EXT_direct_state_access=1 +GL_EXT_draw_buffers2=1 +GL_EXT_draw_instanced=1 +GL_EXT_draw_range_elements=1 +GL_EXT_fog_coord=1 +GL_EXT_framebuffer_blit=1 +GL_EXT_framebuffer_multisample=1 +GL_EXT_framebuffer_object=1 +GL_EXT_framebuffer_sRGB=1 +GL_EXT_geometry_shader4=1 +GL_EXT_gpu_shader4=1 +GL_EXT_histogram=1 +GL_EXT_index_array_formats=1 +GL_EXT_index_func=1 +GL_EXT_index_material=1 +GL_EXT_index_texture=1 +GL_EXT_light_texture=1 +GL_EXT_misc_attribute=1 +GL_EXT_multi_draw_arrays=1 +GL_EXT_multisample=1 +GL_EXT_packed_depth_stencil=1 +GL_EXT_packed_float=1 +GL_EXT_packed_pixels=1 +GL_EXT_paletted_texture=1 +GL_EXT_pixel_buffer_object=1 +GL_EXT_pixel_transform=1 +GL_EXT_pixel_transform_color_table=1 +GL_EXT_point_parameters=1 +GL_EXT_polygon_offset=1 +GL_EXT_rescale_normal=1 +GL_EXT_secondary_color=1 +GL_EXT_separate_specular_color=1 +GL_EXT_shadow_funcs=1 +GL_EXT_shared_texture_palette=1 +GL_EXT_stencil_two_side=1 +GL_EXT_stencil_wrap=1 +GL_EXT_subtexture=1 +GL_EXT_texture3D=1 +GL_EXT_texture=1 +GL_EXT_texture_array=1 +GL_EXT_texture_buffer_object=1 +GL_EXT_texture_compression_latc=1 +GL_EXT_texture_compression_rgtc=1 +GL_EXT_texture_compression_s3tc=1 +GL_EXT_texture_env_add=1 +GL_EXT_texture_env_combine=1 +GL_EXT_texture_env_dot3=1 +GL_EXT_texture_filter_anisotropic=1 +GL_EXT_texture_integer=1 +GL_EXT_texture_lod_bias=1 +GL_EXT_texture_mirror_clamp=1 +GL_EXT_texture_object=1 +GL_EXT_texture_perturb_normal=1 +GL_EXT_texture_shared_exponent=1 +GL_EXT_texture_swizzle=1 +GL_EXT_timer_query=1 +GL_EXT_transform_feedback=1 +GL_EXT_vertex_array=1 +GL_EXT_vertex_array_bgra=1 +GL_EXT_vertex_shader=1 +GL_EXT_vertex_weighting=1 +GL_EYE_DISTANCE_TO_LINE_SGIS=0x81F2 +GL_EYE_DISTANCE_TO_POINT_SGIS=0x81F0 +GL_EYE_LINEAR=0x2400 +GL_EYE_LINE_SGIS=0x81F6 +GL_EYE_PLANE=0x2502 +GL_EYE_PLANE_ABSOLUTE_NV=0x855C +GL_EYE_POINT_SGIS=0x81F4 +GL_EYE_RADIAL_NV=0x855B +GL_E_TIMES_F_NV=0x8531 +GL_FALSE=0 +GL_FASTEST=0x1101 +GL_FEEDBACK=0x1C01 +GL_FEEDBACK_BUFFER_POINTER=0x0DF0 +GL_FEEDBACK_BUFFER_SIZE=0x0DF1 +GL_FEEDBACK_BUFFER_TYPE=0x0DF2 +GL_FENCE_APPLE=0x8A0B +GL_FENCE_CONDITION_NV=0x84F4 +GL_FENCE_STATUS_NV=0x84F3 +GL_FIELDS_NV=0x8E27 +GL_FILL=0x1B02 +GL_FILTER4_SGIS=0x8146 +GL_FIXED_ONLY=0x891D +GL_FIXED_ONLY_ARB=0x891D +GL_FLAT=0x1D00 +GL_FLOAT=0x1406 +GL_FLOAT_32_UNSIGNED_INT_24_8_REV=0x8DAD +GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV=0x8DAD +GL_FLOAT_CLEAR_COLOR_VALUE_NV=0x888D +GL_FLOAT_MAT2=0x8B5A +GL_FLOAT_MAT2_ARB=0x8B5A +GL_FLOAT_MAT2x3=0x8B65 +GL_FLOAT_MAT2x4=0x8B66 +GL_FLOAT_MAT3=0x8B5B +GL_FLOAT_MAT3_ARB=0x8B5B +GL_FLOAT_MAT3x2=0x8B67 +GL_FLOAT_MAT3x4=0x8B68 +GL_FLOAT_MAT4=0x8B5C +GL_FLOAT_MAT4_ARB=0x8B5C +GL_FLOAT_MAT4x2=0x8B69 +GL_FLOAT_MAT4x3=0x8B6A +GL_FLOAT_R16_NV=0x8884 +GL_FLOAT_R32_NV=0x8885 +GL_FLOAT_RG16_NV=0x8886 +GL_FLOAT_RG32_NV=0x8887 +GL_FLOAT_RGB16_NV=0x8888 +GL_FLOAT_RGB32_NV=0x8889 +GL_FLOAT_RGBA16_NV=0x888A +GL_FLOAT_RGBA32_NV=0x888B +GL_FLOAT_RGBA_MODE_NV=0x888E +GL_FLOAT_RGBA_NV=0x8883 +GL_FLOAT_RGB_NV=0x8882 +GL_FLOAT_RG_NV=0x8881 +GL_FLOAT_R_NV=0x8880 +GL_FLOAT_VEC2=0x8B50 +GL_FLOAT_VEC2_ARB=0x8B50 +GL_FLOAT_VEC3=0x8B51 +GL_FLOAT_VEC3_ARB=0x8B51 +GL_FLOAT_VEC4=0x8B52 +GL_FLOAT_VEC4_ARB=0x8B52 +GL_FOG=0x0B60 +GL_FOG_BIT=0x00000080 +GL_FOG_COLOR=0x0B66 +GL_FOG_COORD=0x8451 +GL_FOG_COORDINATE=0x8451 +GL_FOG_COORDINATE_ARRAY=0x8457 +GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING=0x889D +GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB=0x889D +GL_FOG_COORDINATE_ARRAY_EXT=0x8457 +GL_FOG_COORDINATE_ARRAY_LIST_IBM=103076 +GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM=103086 +GL_FOG_COORDINATE_ARRAY_POINTER=0x8456 +GL_FOG_COORDINATE_ARRAY_POINTER_EXT=0x8456 +GL_FOG_COORDINATE_ARRAY_STRIDE=0x8455 +GL_FOG_COORDINATE_ARRAY_STRIDE_EXT=0x8455 +GL_FOG_COORDINATE_ARRAY_TYPE=0x8454 +GL_FOG_COORDINATE_ARRAY_TYPE_EXT=0x8454 +GL_FOG_COORDINATE_EXT=0x8451 +GL_FOG_COORDINATE_SOURCE=0x8450 +GL_FOG_COORDINATE_SOURCE_EXT=0x8450 +GL_FOG_COORD_ARRAY=0x8457 +GL_FOG_COORD_ARRAY_ADDRESS_NV=0x8F28 +GL_FOG_COORD_ARRAY_BUFFER_BINDING=0x889D +GL_FOG_COORD_ARRAY_LENGTH_NV=0x8F32 +GL_FOG_COORD_ARRAY_POINTER=0x8456 +GL_FOG_COORD_ARRAY_STRIDE=0x8455 +GL_FOG_COORD_ARRAY_TYPE=0x8454 +GL_FOG_COORD_SRC=0x8450 +GL_FOG_DENSITY=0x0B62 +GL_FOG_DISTANCE_MODE_NV=0x855A +GL_FOG_END=0x0B64 +GL_FOG_FUNC_POINTS_SGIS=0x812B +GL_FOG_FUNC_SGIS=0x812A +GL_FOG_HINT=0x0C54 +GL_FOG_INDEX=0x0B61 +GL_FOG_MODE=0x0B65 +GL_FOG_OFFSET_SGIX=0x8198 +GL_FOG_OFFSET_VALUE_SGIX=0x8199 +GL_FOG_SCALE_SGIX=0x81FC +GL_FOG_SCALE_VALUE_SGIX=0x81FD +GL_FOG_SPECULAR_TEXTURE_WIN=0x80EC +GL_FOG_START=0x0B63 +GL_FORCE_BLUE_TO_ONE_NV=0x8860 +GL_FORMAT_SUBSAMPLE_244_244_OML=0x8983 +GL_FORMAT_SUBSAMPLE_24_24_OML=0x8982 +GL_FRAGMENT_COLOR_EXT=0x834C +GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX=0x8402 +GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX=0x8403 +GL_FRAGMENT_COLOR_MATERIAL_SGIX=0x8401 +GL_FRAGMENT_DEPTH=0x8452 +GL_FRAGMENT_DEPTH_EXT=0x8452 +GL_FRAGMENT_LIGHT0_SGIX=0x840C +GL_FRAGMENT_LIGHT1_SGIX=0x840D +GL_FRAGMENT_LIGHT2_SGIX=0x840E +GL_FRAGMENT_LIGHT3_SGIX=0x840F +GL_FRAGMENT_LIGHT4_SGIX=0x8410 +GL_FRAGMENT_LIGHT5_SGIX=0x8411 +GL_FRAGMENT_LIGHT6_SGIX=0x8412 +GL_FRAGMENT_LIGHT7_SGIX=0x8413 +GL_FRAGMENT_LIGHTING_SGIX=0x8400 +GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX=0x840A +GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX=0x8408 +GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX=0x840B +GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX=0x8409 +GL_FRAGMENT_MATERIAL_EXT=0x8349 +GL_FRAGMENT_NORMAL_EXT=0x834A +GL_FRAGMENT_PROGRAM_ARB=0x8804 +GL_FRAGMENT_PROGRAM_BINDING_NV=0x8873 +GL_FRAGMENT_PROGRAM_NV=0x8870 +GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV=0x8DA4 +GL_FRAGMENT_SHADER=0x8B30 +GL_FRAGMENT_SHADER_ARB=0x8B30 +GL_FRAGMENT_SHADER_ATI=0x8920 +GL_FRAGMENT_SHADER_DERIVATIVE_HINT=0x8B8B +GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB=0x8B8B +GL_FRAMEBUFFER=0x8D40 +GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE=0x8215 +GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE=0x8214 +GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING=0x8210 +GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE=0x8211 +GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE=0x8216 +GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE=0x8213 +GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB=0x8DA7 +GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT=0x8DA7 +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME=0x8CD1 +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT=0x8CD1 +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE=0x8CD0 +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT=0x8CD0 +GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE=0x8212 +GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE=0x8217 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT=0x8CD4 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE=0x8CD3 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT=0x8CD3 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER=0x8CD4 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT=0x8CD4 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL=0x8CD2 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT=0x8CD2 +GL_FRAMEBUFFER_BINDING=0x8CA6 +GL_FRAMEBUFFER_BINDING_EXT=0x8CA6 +GL_FRAMEBUFFER_COMPLETE=0x8CD5 +GL_FRAMEBUFFER_COMPLETE_EXT=0x8CD5 +GL_FRAMEBUFFER_DEFAULT=0x8218 +GL_FRAMEBUFFER_EXT=0x8D40 +GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT=0x8CD6 +GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT=0x8CD6 +GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT=0x8CD9 +GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER=0x8CDB +GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT=0x8CDB +GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT=0x8CD8 +GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT=0x8CDA +GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB=0x8DA9 +GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT=0x8DA9 +GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB=0x8DA8 +GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT=0x8DA8 +GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT=0x8CD7 +GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT=0x8CD7 +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE=0x8D56 +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT=0x8D56 +GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER=0x8CDC +GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT=0x8CDC +GL_FRAMEBUFFER_SRGB=0x8DB9 +GL_FRAMEBUFFER_SRGB_CAPABLE_EXT=0x8DBA +GL_FRAMEBUFFER_SRGB_EXT=0x8DB9 +GL_FRAMEBUFFER_UNDEFINED=0x8219 +GL_FRAMEBUFFER_UNSUPPORTED=0x8CDD +GL_FRAMEBUFFER_UNSUPPORTED_EXT=0x8CDD +GL_FRAMEZOOM_FACTOR_SGIX=0x818C +GL_FRAMEZOOM_SGIX=0x818B +GL_FRAME_NV=0x8E26 +GL_FRONT=0x0404 +GL_FRONT_AND_BACK=0x0408 +GL_FRONT_FACE=0x0B46 +GL_FRONT_LEFT=0x0400 +GL_FRONT_RIGHT=0x0401 +GL_FULL_RANGE_EXT=0x87E1 +GL_FULL_STIPPLE_HINT_PGI=0x1A219 +GL_FUNC_ADD=0x8006 +GL_FUNC_ADD_EXT=0x8006 +GL_FUNC_REVERSE_SUBTRACT=0x800B +GL_FUNC_REVERSE_SUBTRACT_EXT=0x800B +GL_FUNC_SUBTRACT=0x800A +GL_FUNC_SUBTRACT_EXT=0x800A +GL_GENERATE_MIPMAP=0x8191 +GL_GENERATE_MIPMAP_HINT=0x8192 +GL_GENERATE_MIPMAP_HINT_SGIS=0x8192 +GL_GENERATE_MIPMAP_SGIS=0x8191 +GL_GENERIC_ATTRIB_NV=0x8C7D +GL_GEOMETRY_DEFORMATION_BIT_SGIX=0x00000002 +GL_GEOMETRY_DEFORMATION_SGIX=0x8194 +GL_GEOMETRY_INPUT_TYPE_ARB=0x8DDB +GL_GEOMETRY_INPUT_TYPE_EXT=0x8DDB +GL_GEOMETRY_OUTPUT_TYPE_ARB=0x8DDC +GL_GEOMETRY_OUTPUT_TYPE_EXT=0x8DDC +GL_GEOMETRY_PROGRAM_NV=0x8C26 +GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV=0x8DA3 +GL_GEOMETRY_SHADER_ARB=0x8DD9 +GL_GEOMETRY_SHADER_EXT=0x8DD9 +GL_GEOMETRY_VERTICES_OUT_ARB=0x8DDA +GL_GEOMETRY_VERTICES_OUT_EXT=0x8DDA +GL_GEQUAL=0x0206 +GL_GLEXT_VERSION=44 +GL_GLOBAL_ALPHA_FACTOR_SUN=0x81DA +GL_GLOBAL_ALPHA_SUN=0x81D9 +GL_GPU_ADDRESS_NV=0x8F34 +GL_GREATER=0x0204 +GL_GREEN=0x1904 +GL_GREEN_BIAS=0x0D19 +GL_GREEN_BITS=0x0D53 +GL_GREEN_BIT_ATI=0x00000002 +GL_GREEN_INTEGER=0x8D95 +GL_GREEN_INTEGER_EXT=0x8D95 +GL_GREEN_MAX_CLAMP_INGR=0x8565 +GL_GREEN_MIN_CLAMP_INGR=0x8561 +GL_GREEN_SCALE=0x0D18 +GL_GREMEDY_string_marker=1 +GL_HALF_BIAS_NEGATE_NV=0x853B +GL_HALF_BIAS_NORMAL_NV=0x853A +GL_HALF_BIT_ATI=0x00000008 +GL_HALF_FLOAT=0x140B +GL_HALF_FLOAT_ARB=0x140B +GL_HALF_FLOAT_NV=0x140B +GL_HILO16_NV=0x86F8 +GL_HILO8_NV=0x885E +GL_HILO_NV=0x86F4 +GL_HINT_BIT=0x00008000 +GL_HISTOGRAM=0x8024 +GL_HISTOGRAM_ALPHA_SIZE=0x802B +GL_HISTOGRAM_ALPHA_SIZE_EXT=0x802B +GL_HISTOGRAM_BLUE_SIZE=0x802A +GL_HISTOGRAM_BLUE_SIZE_EXT=0x802A +GL_HISTOGRAM_EXT=0x8024 +GL_HISTOGRAM_FORMAT=0x8027 +GL_HISTOGRAM_FORMAT_EXT=0x8027 +GL_HISTOGRAM_GREEN_SIZE=0x8029 +GL_HISTOGRAM_GREEN_SIZE_EXT=0x8029 +GL_HISTOGRAM_LUMINANCE_SIZE=0x802C +GL_HISTOGRAM_LUMINANCE_SIZE_EXT=0x802C +GL_HISTOGRAM_RED_SIZE=0x8028 +GL_HISTOGRAM_RED_SIZE_EXT=0x8028 +GL_HISTOGRAM_SINK=0x802D +GL_HISTOGRAM_SINK_EXT=0x802D +GL_HISTOGRAM_WIDTH=0x8026 +GL_HISTOGRAM_WIDTH_EXT=0x8026 +GL_HI_BIAS_NV=0x8714 +GL_HI_SCALE_NV=0x870E +GL_HP_convolution_border_modes=1 +GL_HP_image_transform=1 +GL_HP_occlusion_test=1 +GL_HP_texture_lighting=1 +GL_IBM_cull_vertex=1 +GL_IBM_multimode_draw_arrays=1 +GL_IBM_rasterpos_clip=1 +GL_IBM_vertex_array_lists=1 +GL_IDENTITY_NV=0x862A +GL_IGNORE_BORDER_HP=0x8150 +GL_IMAGE_CUBIC_WEIGHT_HP=0x815E +GL_IMAGE_MAG_FILTER_HP=0x815C +GL_IMAGE_MIN_FILTER_HP=0x815D +GL_IMAGE_ROTATE_ANGLE_HP=0x8159 +GL_IMAGE_ROTATE_ORIGIN_X_HP=0x815A +GL_IMAGE_ROTATE_ORIGIN_Y_HP=0x815B +GL_IMAGE_SCALE_X_HP=0x8155 +GL_IMAGE_SCALE_Y_HP=0x8156 +GL_IMAGE_TRANSFORM_2D_HP=0x8161 +GL_IMAGE_TRANSLATE_X_HP=0x8157 +GL_IMAGE_TRANSLATE_Y_HP=0x8158 +GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES=0x8B9B +GL_IMPLEMENTATION_COLOR_READ_TYPE_OES=0x8B9A +GL_INCR=0x1E02 +GL_INCR_WRAP=0x8507 +GL_INCR_WRAP_EXT=0x8507 +GL_INDEX=0x8222 +GL_INDEX_ARRAY=0x8077 +GL_INDEX_ARRAY_ADDRESS_NV=0x8F24 +GL_INDEX_ARRAY_BUFFER_BINDING=0x8899 +GL_INDEX_ARRAY_BUFFER_BINDING_ARB=0x8899 +GL_INDEX_ARRAY_COUNT_EXT=0x8087 +GL_INDEX_ARRAY_EXT=0x8077 +GL_INDEX_ARRAY_LENGTH_NV=0x8F2E +GL_INDEX_ARRAY_LIST_IBM=103073 +GL_INDEX_ARRAY_LIST_STRIDE_IBM=103083 +GL_INDEX_ARRAY_POINTER=0x8091 +GL_INDEX_ARRAY_POINTER_EXT=0x8091 +GL_INDEX_ARRAY_STRIDE=0x8086 +GL_INDEX_ARRAY_STRIDE_EXT=0x8086 +GL_INDEX_ARRAY_TYPE=0x8085 +GL_INDEX_ARRAY_TYPE_EXT=0x8085 +GL_INDEX_BITS=0x0D51 +GL_INDEX_BIT_PGI=0x00080000 +GL_INDEX_CLEAR_VALUE=0x0C20 +GL_INDEX_LOGIC_OP=0x0BF1 +GL_INDEX_MATERIAL_EXT=0x81B8 +GL_INDEX_MATERIAL_FACE_EXT=0x81BA +GL_INDEX_MATERIAL_PARAMETER_EXT=0x81B9 +GL_INDEX_MODE=0x0C30 +GL_INDEX_OFFSET=0x0D13 +GL_INDEX_SHIFT=0x0D12 +GL_INDEX_TEST_EXT=0x81B5 +GL_INDEX_TEST_FUNC_EXT=0x81B6 +GL_INDEX_TEST_REF_EXT=0x81B7 +GL_INDEX_WRITEMASK=0x0C21 +GL_INFO_LOG_LENGTH=0x8B84 +GL_INGR_blend_func_separate=1 +GL_INGR_color_clamp=1 +GL_INGR_interlace_read=1 +GL_INSTRUMENT_BUFFER_POINTER_SGIX=0x8180 +GL_INSTRUMENT_MEASUREMENTS_SGIX=0x8181 +GL_INT=0x1404 +GL_INTEL_parallel_arrays=1 +GL_INTENSITY12=0x804C +GL_INTENSITY12_EXT=0x804C +GL_INTENSITY16=0x804D +GL_INTENSITY16F_ARB=0x881D +GL_INTENSITY16I_EXT=0x8D8B +GL_INTENSITY16UI_EXT=0x8D79 +GL_INTENSITY16_EXT=0x804D +GL_INTENSITY32F_ARB=0x8817 +GL_INTENSITY32I_EXT=0x8D85 +GL_INTENSITY32UI_EXT=0x8D73 +GL_INTENSITY4=0x804A +GL_INTENSITY4_EXT=0x804A +GL_INTENSITY8=0x804B +GL_INTENSITY8I_EXT=0x8D91 +GL_INTENSITY8UI_EXT=0x8D7F +GL_INTENSITY8_EXT=0x804B +GL_INTENSITY=0x8049 +GL_INTENSITY_EXT=0x8049 +GL_INTENSITY_FLOAT16_ATI=0x881D +GL_INTENSITY_FLOAT32_ATI=0x8817 +GL_INTERLACE_OML=0x8980 +GL_INTERLACE_READ_INGR=0x8568 +GL_INTERLACE_READ_OML=0x8981 +GL_INTERLACE_SGIX=0x8094 +GL_INTERLEAVED_ATTRIBS=0x8C8C +GL_INTERLEAVED_ATTRIBS_EXT=0x8C8C +GL_INTERLEAVED_ATTRIBS_NV=0x8C8C +GL_INTERPOLATE=0x8575 +GL_INTERPOLATE_ARB=0x8575 +GL_INTERPOLATE_EXT=0x8575 +GL_INT_SAMPLER_1D=0x8DC9 +GL_INT_SAMPLER_1D_ARRAY=0x8DCE +GL_INT_SAMPLER_1D_ARRAY_EXT=0x8DCE +GL_INT_SAMPLER_1D_EXT=0x8DC9 +GL_INT_SAMPLER_2D=0x8DCA +GL_INT_SAMPLER_2D_ARRAY=0x8DCF +GL_INT_SAMPLER_2D_ARRAY_EXT=0x8DCF +GL_INT_SAMPLER_2D_EXT=0x8DCA +GL_INT_SAMPLER_2D_RECT_EXT=0x8DCD +GL_INT_SAMPLER_3D=0x8DCB +GL_INT_SAMPLER_3D_EXT=0x8DCB +GL_INT_SAMPLER_BUFFER_EXT=0x8DD0 +GL_INT_SAMPLER_CUBE=0x8DCC +GL_INT_SAMPLER_CUBE_EXT=0x8DCC +GL_INT_SAMPLER_RENDERBUFFER_NV=0x8E57 +GL_INT_VEC2=0x8B53 +GL_INT_VEC2_ARB=0x8B53 +GL_INT_VEC3=0x8B54 +GL_INT_VEC3_ARB=0x8B54 +GL_INT_VEC4=0x8B55 +GL_INT_VEC4_ARB=0x8B55 +GL_INVALID_ENUM=0x0500 +GL_INVALID_FRAMEBUFFER_OPERATION=0x0506 +GL_INVALID_FRAMEBUFFER_OPERATION_EXT=0x0506 +GL_INVALID_OPERATION=0x0502 +GL_INVALID_VALUE=0x0501 +GL_INVARIANT_DATATYPE_EXT=0x87EB +GL_INVARIANT_EXT=0x87C2 +GL_INVARIANT_VALUE_EXT=0x87EA +GL_INVERSE_NV=0x862B +GL_INVERSE_TRANSPOSE_NV=0x862D +GL_INVERT=0x150A +GL_INVERTED_SCREEN_W_REND=0x8491 +GL_IR_INSTRUMENT1_SGIX=0x817F +GL_IUI_N3F_V2F_EXT=0x81AF +GL_IUI_N3F_V3F_EXT=0x81B0 +GL_IUI_V2F_EXT=0x81AD +GL_IUI_V3F_EXT=0x81AE +GL_KEEP=0x1E00 +GL_LEFT=0x0406 +GL_LEQUAL=0x0203 +GL_LERP_ATI=0x8969 +GL_LESS=0x0201 +GL_LIGHT0=0x4000 +GL_LIGHT1=0x4001 +GL_LIGHT2=0x4002 +GL_LIGHT3=0x4003 +GL_LIGHT4=0x4004 +GL_LIGHT5=0x4005 +GL_LIGHT6=0x4006 +GL_LIGHT7=0x4007 +GL_LIGHTING=0x0B50 +GL_LIGHTING_BIT=0x00000040 +GL_LIGHT_ENV_MODE_SGIX=0x8407 +GL_LIGHT_MODEL_AMBIENT=0x0B53 +GL_LIGHT_MODEL_COLOR_CONTROL=0x81F8 +GL_LIGHT_MODEL_COLOR_CONTROL_EXT=0x81F8 +GL_LIGHT_MODEL_LOCAL_VIEWER=0x0B51 +GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE=0x85B0 +GL_LIGHT_MODEL_TWO_SIDE=0x0B52 +GL_LINE=0x1B01 +GL_LINEAR=0x2601 +GL_LINEAR_ATTENUATION=0x1208 +GL_LINEAR_CLIPMAP_LINEAR_SGIX=0x8170 +GL_LINEAR_CLIPMAP_NEAREST_SGIX=0x844F +GL_LINEAR_DETAIL_ALPHA_SGIS=0x8098 +GL_LINEAR_DETAIL_COLOR_SGIS=0x8099 +GL_LINEAR_DETAIL_SGIS=0x8097 +GL_LINEAR_MIPMAP_LINEAR=0x2703 +GL_LINEAR_MIPMAP_NEAREST=0x2701 +GL_LINEAR_SHARPEN_ALPHA_SGIS=0x80AE +GL_LINEAR_SHARPEN_COLOR_SGIS=0x80AF +GL_LINEAR_SHARPEN_SGIS=0x80AD +GL_LINES=0x0001 +GL_LINES_ADJACENCY_ARB=0x000A +GL_LINES_ADJACENCY_EXT=0xA +GL_LINE_BIT=0x00000004 +GL_LINE_LOOP=0x0002 +GL_LINE_RESET_TOKEN=0x0707 +GL_LINE_SMOOTH=0x0B20 +GL_LINE_SMOOTH_HINT=0x0C52 +GL_LINE_STIPPLE=0x0B24 +GL_LINE_STIPPLE_PATTERN=0x0B25 +GL_LINE_STIPPLE_REPEAT=0x0B26 +GL_LINE_STRIP=0x0003 +GL_LINE_STRIP_ADJACENCY_ARB=0x000B +GL_LINE_STRIP_ADJACENCY_EXT=0xB +GL_LINE_TOKEN=0x0702 +GL_LINE_WIDTH=0x0B21 +GL_LINE_WIDTH_GRANULARITY=0x0B23 +GL_LINE_WIDTH_RANGE=0x0B22 +GL_LINK_STATUS=0x8B82 +GL_LIST_BASE=0x0B32 +GL_LIST_BIT=0x00020000 +GL_LIST_INDEX=0x0B33 +GL_LIST_MODE=0x0B30 +GL_LIST_PRIORITY_SGIX=0x8182 +GL_LOAD=0x0101 +GL_LOCAL_CONSTANT_DATATYPE_EXT=0x87ED +GL_LOCAL_CONSTANT_EXT=0x87C3 +GL_LOCAL_CONSTANT_VALUE_EXT=0x87EC +GL_LOCAL_EXT=0x87C4 +GL_LOGIC_OP=0x0BF1 +GL_LOGIC_OP_MODE=0x0BF0 +GL_LOWER_LEFT=0x8CA1 +GL_LO_BIAS_NV=0x8715 +GL_LO_SCALE_NV=0x870F +GL_LUMINANCE12=0x8041 +GL_LUMINANCE12_ALPHA12=0x8047 +GL_LUMINANCE12_ALPHA12_EXT=0x8047 +GL_LUMINANCE12_ALPHA4=0x8046 +GL_LUMINANCE12_ALPHA4_EXT=0x8046 +GL_LUMINANCE12_EXT=0x8041 +GL_LUMINANCE16=0x8042 +GL_LUMINANCE16F_ARB=0x881E +GL_LUMINANCE16I_EXT=0x8D8C +GL_LUMINANCE16UI_EXT=0x8D7A +GL_LUMINANCE16_ALPHA16=0x8048 +GL_LUMINANCE16_ALPHA16_EXT=0x8048 +GL_LUMINANCE16_EXT=0x8042 +GL_LUMINANCE32F_ARB=0x8818 +GL_LUMINANCE32I_EXT=0x8D86 +GL_LUMINANCE32UI_EXT=0x8D74 +GL_LUMINANCE4=0x803F +GL_LUMINANCE4_ALPHA4=0x8043 +GL_LUMINANCE4_ALPHA4_EXT=0x8043 +GL_LUMINANCE4_EXT=0x803F +GL_LUMINANCE6_ALPHA2=0x8044 +GL_LUMINANCE6_ALPHA2_EXT=0x8044 +GL_LUMINANCE8=0x8040 +GL_LUMINANCE8I_EXT=0x8D92 +GL_LUMINANCE8UI_EXT=0x8D80 +GL_LUMINANCE8_ALPHA8=0x8045 +GL_LUMINANCE8_ALPHA8_EXT=0x8045 +GL_LUMINANCE8_EXT=0x8040 +GL_LUMINANCE=0x1909 +GL_LUMINANCE_ALPHA16F_ARB=0x881F +GL_LUMINANCE_ALPHA16I_EXT=0x8D8D +GL_LUMINANCE_ALPHA16UI_EXT=0x8D7B +GL_LUMINANCE_ALPHA32F_ARB=0x8819 +GL_LUMINANCE_ALPHA32I_EXT=0x8D87 +GL_LUMINANCE_ALPHA32UI_EXT=0x8D75 +GL_LUMINANCE_ALPHA8I_EXT=0x8D93 +GL_LUMINANCE_ALPHA8UI_EXT=0x8D81 +GL_LUMINANCE_ALPHA=0x190A +GL_LUMINANCE_ALPHA_FLOAT16_ATI=0x881F +GL_LUMINANCE_ALPHA_FLOAT32_ATI=0x8819 +GL_LUMINANCE_ALPHA_INTEGER_EXT=0x8D9D +GL_LUMINANCE_FLOAT16_ATI=0x881E +GL_LUMINANCE_FLOAT32_ATI=0x8818 +GL_LUMINANCE_INTEGER_EXT=0x8D9C +GL_MAD_ATI=0x8968 +GL_MAGNITUDE_BIAS_NV=0x8718 +GL_MAGNITUDE_SCALE_NV=0x8712 +GL_MAJOR_VERSION=0x821B +GL_MAP1_BINORMAL_EXT=0x8446 +GL_MAP1_COLOR_4=0x0D90 +GL_MAP1_GRID_DOMAIN=0x0DD0 +GL_MAP1_GRID_SEGMENTS=0x0DD1 +GL_MAP1_INDEX=0x0D91 +GL_MAP1_NORMAL=0x0D92 +GL_MAP1_TANGENT_EXT=0x8444 +GL_MAP1_TEXTURE_COORD_1=0x0D93 +GL_MAP1_TEXTURE_COORD_2=0x0D94 +GL_MAP1_TEXTURE_COORD_3=0x0D95 +GL_MAP1_TEXTURE_COORD_4=0x0D96 +GL_MAP1_VERTEX_3=0x0D97 +GL_MAP1_VERTEX_4=0x0D98 +GL_MAP1_VERTEX_ATTRIB0_4_NV=0x8660 +GL_MAP1_VERTEX_ATTRIB10_4_NV=0x866A +GL_MAP1_VERTEX_ATTRIB11_4_NV=0x866B +GL_MAP1_VERTEX_ATTRIB12_4_NV=0x866C +GL_MAP1_VERTEX_ATTRIB13_4_NV=0x866D +GL_MAP1_VERTEX_ATTRIB14_4_NV=0x866E +GL_MAP1_VERTEX_ATTRIB15_4_NV=0x866F +GL_MAP1_VERTEX_ATTRIB1_4_NV=0x8661 +GL_MAP1_VERTEX_ATTRIB2_4_NV=0x8662 +GL_MAP1_VERTEX_ATTRIB3_4_NV=0x8663 +GL_MAP1_VERTEX_ATTRIB4_4_NV=0x8664 +GL_MAP1_VERTEX_ATTRIB5_4_NV=0x8665 +GL_MAP1_VERTEX_ATTRIB6_4_NV=0x8666 +GL_MAP1_VERTEX_ATTRIB7_4_NV=0x8667 +GL_MAP1_VERTEX_ATTRIB8_4_NV=0x8668 +GL_MAP1_VERTEX_ATTRIB9_4_NV=0x8669 +GL_MAP2_BINORMAL_EXT=0x8447 +GL_MAP2_COLOR_4=0x0DB0 +GL_MAP2_GRID_DOMAIN=0x0DD2 +GL_MAP2_GRID_SEGMENTS=0x0DD3 +GL_MAP2_INDEX=0x0DB1 +GL_MAP2_NORMAL=0x0DB2 +GL_MAP2_TANGENT_EXT=0x8445 +GL_MAP2_TEXTURE_COORD_1=0x0DB3 +GL_MAP2_TEXTURE_COORD_2=0x0DB4 +GL_MAP2_TEXTURE_COORD_3=0x0DB5 +GL_MAP2_TEXTURE_COORD_4=0x0DB6 +GL_MAP2_VERTEX_3=0x0DB7 +GL_MAP2_VERTEX_4=0x0DB8 +GL_MAP2_VERTEX_ATTRIB0_4_NV=0x8670 +GL_MAP2_VERTEX_ATTRIB10_4_NV=0x867A +GL_MAP2_VERTEX_ATTRIB11_4_NV=0x867B +GL_MAP2_VERTEX_ATTRIB12_4_NV=0x867C +GL_MAP2_VERTEX_ATTRIB13_4_NV=0x867D +GL_MAP2_VERTEX_ATTRIB14_4_NV=0x867E +GL_MAP2_VERTEX_ATTRIB15_4_NV=0x867F +GL_MAP2_VERTEX_ATTRIB1_4_NV=0x8671 +GL_MAP2_VERTEX_ATTRIB2_4_NV=0x8672 +GL_MAP2_VERTEX_ATTRIB3_4_NV=0x8673 +GL_MAP2_VERTEX_ATTRIB4_4_NV=0x8674 +GL_MAP2_VERTEX_ATTRIB5_4_NV=0x8675 +GL_MAP2_VERTEX_ATTRIB6_4_NV=0x8676 +GL_MAP2_VERTEX_ATTRIB7_4_NV=0x8677 +GL_MAP2_VERTEX_ATTRIB8_4_NV=0x8678 +GL_MAP2_VERTEX_ATTRIB9_4_NV=0x8679 +GL_MAP_ATTRIB_U_ORDER_NV=0x86C3 +GL_MAP_ATTRIB_V_ORDER_NV=0x86C4 +GL_MAP_COLOR=0x0D10 +GL_MAP_FLUSH_EXPLICIT_BIT=0x0010 +GL_MAP_INVALIDATE_BUFFER_BIT=0x0008 +GL_MAP_INVALIDATE_RANGE_BIT=0x0004 +GL_MAP_READ_BIT=0x0001 +GL_MAP_STENCIL=0x0D11 +GL_MAP_TESSELLATION_NV=0x86C2 +GL_MAP_UNSYNCHRONIZED_BIT=0x0020 +GL_MAP_WRITE_BIT=0x0002 +GL_MATERIAL_SIDE_HINT_PGI=0x1A22C +GL_MATRIX0_ARB=0x88C0 +GL_MATRIX0_NV=0x8630 +GL_MATRIX10_ARB=0x88CA +GL_MATRIX11_ARB=0x88CB +GL_MATRIX12_ARB=0x88CC +GL_MATRIX13_ARB=0x88CD +GL_MATRIX14_ARB=0x88CE +GL_MATRIX15_ARB=0x88CF +GL_MATRIX16_ARB=0x88D0 +GL_MATRIX17_ARB=0x88D1 +GL_MATRIX18_ARB=0x88D2 +GL_MATRIX19_ARB=0x88D3 +GL_MATRIX1_ARB=0x88C1 +GL_MATRIX1_NV=0x8631 +GL_MATRIX20_ARB=0x88D4 +GL_MATRIX21_ARB=0x88D5 +GL_MATRIX22_ARB=0x88D6 +GL_MATRIX23_ARB=0x88D7 +GL_MATRIX24_ARB=0x88D8 +GL_MATRIX25_ARB=0x88D9 +GL_MATRIX26_ARB=0x88DA +GL_MATRIX27_ARB=0x88DB +GL_MATRIX28_ARB=0x88DC +GL_MATRIX29_ARB=0x88DD +GL_MATRIX2_ARB=0x88C2 +GL_MATRIX2_NV=0x8632 +GL_MATRIX30_ARB=0x88DE +GL_MATRIX31_ARB=0x88DF +GL_MATRIX3_ARB=0x88C3 +GL_MATRIX3_NV=0x8633 +GL_MATRIX4_ARB=0x88C4 +GL_MATRIX4_NV=0x8634 +GL_MATRIX5_ARB=0x88C5 +GL_MATRIX5_NV=0x8635 +GL_MATRIX6_ARB=0x88C6 +GL_MATRIX6_NV=0x8636 +GL_MATRIX7_ARB=0x88C7 +GL_MATRIX7_NV=0x8637 +GL_MATRIX8_ARB=0x88C8 +GL_MATRIX9_ARB=0x88C9 +GL_MATRIX_EXT=0x87C0 +GL_MATRIX_INDEX_ARRAY_ARB=0x8844 +GL_MATRIX_INDEX_ARRAY_POINTER_ARB=0x8849 +GL_MATRIX_INDEX_ARRAY_SIZE_ARB=0x8846 +GL_MATRIX_INDEX_ARRAY_STRIDE_ARB=0x8848 +GL_MATRIX_INDEX_ARRAY_TYPE_ARB=0x8847 +GL_MATRIX_MODE=0x0BA0 +GL_MATRIX_PALETTE_ARB=0x8840 +GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI=0x00200000 +GL_MAT_AMBIENT_BIT_PGI=0x00100000 +GL_MAT_COLOR_INDEXES_BIT_PGI=0x01000000 +GL_MAT_DIFFUSE_BIT_PGI=0x00400000 +GL_MAT_EMISSION_BIT_PGI=0x00800000 +GL_MAT_SHININESS_BIT_PGI=0x02000000 +GL_MAT_SPECULAR_BIT_PGI=0x04000000 +GL_MAX=0x8008 +GL_MAX_3D_TEXTURE_SIZE=0x8073 +GL_MAX_3D_TEXTURE_SIZE_EXT=0x8073 +GL_MAX_4D_TEXTURE_SIZE_SGIS=0x8138 +GL_MAX_ACTIVE_LIGHTS_SGIX=0x8405 +GL_MAX_ARRAY_TEXTURE_LAYERS=0x88FF +GL_MAX_ARRAY_TEXTURE_LAYERS_EXT=0x88FF +GL_MAX_ASYNC_DRAW_PIXELS_SGIX=0x8360 +GL_MAX_ASYNC_HISTOGRAM_SGIX=0x832D +GL_MAX_ASYNC_READ_PIXELS_SGIX=0x8361 +GL_MAX_ASYNC_TEX_IMAGE_SGIX=0x835F +GL_MAX_ATTRIB_STACK_DEPTH=0x0D35 +GL_MAX_BINDABLE_UNIFORM_SIZE_EXT=0x8DED +GL_MAX_CLIENT_ATTRIB_STACK_DEPTH=0x0D3B +GL_MAX_CLIPMAP_DEPTH_SGIX=0x8177 +GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX=0x8178 +GL_MAX_CLIP_DISTANCES=0x0D32 +GL_MAX_CLIP_PLANES=0x0D32 +GL_MAX_COLOR_ATTACHMENTS=0x8CDF +GL_MAX_COLOR_ATTACHMENTS_EXT=0x8CDF +GL_MAX_COLOR_MATRIX_STACK_DEPTH=0x80B3 +GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI=0x80B3 +GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS=0x8B4D +GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB=0x8B4D +GL_MAX_CONVOLUTION_HEIGHT=0x801B +GL_MAX_CONVOLUTION_HEIGHT_EXT=0x801B +GL_MAX_CONVOLUTION_WIDTH=0x801A +GL_MAX_CONVOLUTION_WIDTH_EXT=0x801A +GL_MAX_CUBE_MAP_TEXTURE_SIZE=0x851C +GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB=0x851C +GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT=0x851C +GL_MAX_DEFORMATION_ORDER_SGIX=0x8197 +GL_MAX_DRAW_BUFFERS=0x8824 +GL_MAX_DRAW_BUFFERS_ARB=0x8824 +GL_MAX_DRAW_BUFFERS_ATI=0x8824 +GL_MAX_ELEMENTS_INDICES=0x80E9 +GL_MAX_ELEMENTS_INDICES_EXT=0x80E9 +GL_MAX_ELEMENTS_VERTICES=0x80E8 +GL_MAX_ELEMENTS_VERTICES_EXT=0x80E8 +GL_MAX_EVAL_ORDER=0x0D30 +GL_MAX_EXT=0x8008 +GL_MAX_FOG_FUNC_POINTS_SGIS=0x812C +GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT=0x8DE3 +GL_MAX_FRAGMENT_LIGHTS_SGIX=0x8404 +GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV=0x8868 +GL_MAX_FRAGMENT_UNIFORM_COMPONENTS=0x8B49 +GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB=0x8B49 +GL_MAX_FRAMEZOOM_FACTOR_SGIX=0x818D +GL_MAX_GENERAL_COMBINERS_NV=0x854D +GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT=0x8DE4 +GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB=0x8DE0 +GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT=0x8DE0 +GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB=0x8C29 +GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT=0x8C29 +GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB=0x8DE1 +GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT=0x8DE1 +GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB=0x8DDF +GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT=0x8DDF +GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB=0x8DDD +GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT=0x8DDD +GL_MAX_LIGHTS=0x0D31 +GL_MAX_LIST_NESTING=0x0B31 +GL_MAX_MAP_TESSELLATION_NV=0x86D6 +GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB=0x8841 +GL_MAX_MODELVIEW_STACK_DEPTH=0x0D36 +GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV=0x8E12 +GL_MAX_NAME_STACK_DEPTH=0x0D37 +GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT=0x87CA +GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT=0x87CD +GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT=0x87CE +GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT=0x87CC +GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT=0x87CB +GL_MAX_PALETTE_MATRICES_ARB=0x8842 +GL_MAX_PIXEL_MAP_TABLE=0x0D34 +GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT=0x8337 +GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI=0x87F1 +GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB=0x88B1 +GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB=0x880B +GL_MAX_PROGRAM_ATTRIBS_ARB=0x88AD +GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV=0x8908 +GL_MAX_PROGRAM_CALL_DEPTH_NV=0x88F5 +GL_MAX_PROGRAM_ENV_PARAMETERS_ARB=0x88B5 +GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV=0x88F4 +GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV=0x8DA5 +GL_MAX_PROGRAM_GENERIC_RESULTS_NV=0x8DA6 +GL_MAX_PROGRAM_IF_DEPTH_NV=0x88F6 +GL_MAX_PROGRAM_INSTRUCTIONS_ARB=0x88A1 +GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB=0x88B4 +GL_MAX_PROGRAM_LOOP_COUNT_NV=0x88F8 +GL_MAX_PROGRAM_LOOP_DEPTH_NV=0x88F7 +GL_MAX_PROGRAM_MATRICES_ARB=0x862F +GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB=0x862E +GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB=0x88B3 +GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB=0x880E +GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB=0x88AF +GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB=0x88A3 +GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB=0x88AB +GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB=0x88A7 +GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB=0x8810 +GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB=0x880F +GL_MAX_PROGRAM_OUTPUT_VERTICES_NV=0x8C27 +GL_MAX_PROGRAM_PARAMETERS_ARB=0x88A9 +GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV=0x8DA0 +GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV=0x8DA1 +GL_MAX_PROGRAM_RESULT_COMPONENTS_NV=0x8909 +GL_MAX_PROGRAM_TEMPORARIES_ARB=0x88A5 +GL_MAX_PROGRAM_TEXEL_OFFSET=0x8905 +GL_MAX_PROGRAM_TEXEL_OFFSET_NV=0x8905 +GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB=0x880D +GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB=0x880C +GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV=0x8C28 +GL_MAX_PROJECTION_STACK_DEPTH=0x0D38 +GL_MAX_RATIONAL_EVAL_ORDER_NV=0x86D7 +GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB=0x84F8 +GL_MAX_RECTANGLE_TEXTURE_SIZE_NV=0x84F8 +GL_MAX_RENDERBUFFER_COLOR_SAMPLES_NV=0x8E11 +GL_MAX_RENDERBUFFER_COVERAGE_SAMPLES_NV=0x8D57 +GL_MAX_RENDERBUFFER_SIZE=0x84E8 +GL_MAX_RENDERBUFFER_SIZE_EXT=0x84E8 +GL_MAX_SAMPLES=0x8D57 +GL_MAX_SAMPLES_EXT=0x8D57 +GL_MAX_SAMPLE_MASK_WORDS_NV=0x8E59 +GL_MAX_SHADER_BUFFER_ADDRESS_NV=0x8F35 +GL_MAX_SHININESS_NV=0x8504 +GL_MAX_SPOT_EXPONENT_NV=0x8505 +GL_MAX_TEXTURE_BUFFER_SIZE_ARB=0x8C2B +GL_MAX_TEXTURE_BUFFER_SIZE_EXT=0x8C2B +GL_MAX_TEXTURE_COORDS=0x8871 +GL_MAX_TEXTURE_COORDS_ARB=0x8871 +GL_MAX_TEXTURE_COORDS_NV=0x8871 +GL_MAX_TEXTURE_IMAGE_UNITS=0x8872 +GL_MAX_TEXTURE_IMAGE_UNITS_ARB=0x8872 +GL_MAX_TEXTURE_IMAGE_UNITS_NV=0x8872 +GL_MAX_TEXTURE_LOD_BIAS=0x84FD +GL_MAX_TEXTURE_LOD_BIAS_EXT=0x84FD +GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT=0x84FF +GL_MAX_TEXTURE_SIZE=0x0D33 +GL_MAX_TEXTURE_STACK_DEPTH=0x0D39 +GL_MAX_TEXTURE_UNITS=0x84E2 +GL_MAX_TEXTURE_UNITS_ARB=0x84E2 +GL_MAX_TRACK_MATRICES_NV=0x862F +GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV=0x862E +GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_ATTRIBS_NV=0x8C8A +GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS=0x8C8A +GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT=0x8C8A +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS=0x8C8B +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT=0x8C8B +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV=0x8C8B +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS=0x8C80 +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT=0x8C80 +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV=0x8C80 +GL_MAX_VARYING_COMPONENTS=0x8B4B +GL_MAX_VARYING_COMPONENTS_EXT=0x8B4B +GL_MAX_VARYING_FLOATS=0x8B4B +GL_MAX_VARYING_FLOATS_ARB=0x8B4B +GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV=0x8520 +GL_MAX_VERTEX_ATTRIBS=0x8869 +GL_MAX_VERTEX_ATTRIBS_ARB=0x8869 +GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT=0x8DE2 +GL_MAX_VERTEX_HINT_PGI=0x1A22D +GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT=0x87C5 +GL_MAX_VERTEX_SHADER_INVARIANTS_EXT=0x87C7 +GL_MAX_VERTEX_SHADER_LOCALS_EXT=0x87C9 +GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT=0x87C8 +GL_MAX_VERTEX_SHADER_VARIANTS_EXT=0x87C6 +GL_MAX_VERTEX_STREAMS_ATI=0x876B +GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS=0x8B4C +GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB=0x8B4C +GL_MAX_VERTEX_UNIFORM_COMPONENTS=0x8B4A +GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB=0x8B4A +GL_MAX_VERTEX_UNITS_ARB=0x86A4 +GL_MAX_VERTEX_VARYING_COMPONENTS_ARB=0x8DDE +GL_MAX_VERTEX_VARYING_COMPONENTS_EXT=0x8DDE +GL_MAX_VIEWPORT_DIMS=0x0D3A +GL_MESA_pack_invert=1 +GL_MESA_resize_buffers=1 +GL_MESA_window_pos=1 +GL_MESA_ycbcr_texture=1 +GL_MIN=0x8007 +GL_MINMAX=0x802E +GL_MINMAX_EXT=0x802E +GL_MINMAX_FORMAT=0x802F +GL_MINMAX_FORMAT_EXT=0x802F +GL_MINMAX_SINK=0x8030 +GL_MINMAX_SINK_EXT=0x8030 +GL_MINOR_VERSION=0x821C +GL_MIN_EXT=0x8007 +GL_MIN_PROGRAM_TEXEL_OFFSET=0x8904 +GL_MIN_PROGRAM_TEXEL_OFFSET_NV=0x8904 +GL_MIRRORED_REPEAT=0x8370 +GL_MIRRORED_REPEAT_ARB=0x8370 +GL_MIRRORED_REPEAT_IBM=0x8370 +GL_MIRROR_CLAMP_ATI=0x8742 +GL_MIRROR_CLAMP_EXT=0x8742 +GL_MIRROR_CLAMP_TO_BORDER_EXT=0x8912 +GL_MIRROR_CLAMP_TO_EDGE_ATI=0x8743 +GL_MIRROR_CLAMP_TO_EDGE_EXT=0x8743 +GL_MODELVIEW0_ARB=0x1700 +GL_MODELVIEW0_EXT=0x1700 +GL_MODELVIEW0_MATRIX_EXT=0x0BA6 +GL_MODELVIEW0_STACK_DEPTH_EXT=0x0BA3 +GL_MODELVIEW10_ARB=0x872A +GL_MODELVIEW11_ARB=0x872B +GL_MODELVIEW12_ARB=0x872C +GL_MODELVIEW13_ARB=0x872D +GL_MODELVIEW14_ARB=0x872E +GL_MODELVIEW15_ARB=0x872F +GL_MODELVIEW16_ARB=0x8730 +GL_MODELVIEW17_ARB=0x8731 +GL_MODELVIEW18_ARB=0x8732 +GL_MODELVIEW19_ARB=0x8733 +GL_MODELVIEW1_ARB=0x850A +GL_MODELVIEW1_EXT=0x850A +GL_MODELVIEW1_MATRIX_EXT=0x8506 +GL_MODELVIEW1_STACK_DEPTH_EXT=0x8502 +GL_MODELVIEW20_ARB=0x8734 +GL_MODELVIEW21_ARB=0x8735 +GL_MODELVIEW22_ARB=0x8736 +GL_MODELVIEW23_ARB=0x8737 +GL_MODELVIEW24_ARB=0x8738 +GL_MODELVIEW25_ARB=0x8739 +GL_MODELVIEW26_ARB=0x873A +GL_MODELVIEW27_ARB=0x873B +GL_MODELVIEW28_ARB=0x873C +GL_MODELVIEW29_ARB=0x873D +GL_MODELVIEW2_ARB=0x8722 +GL_MODELVIEW30_ARB=0x873E +GL_MODELVIEW31_ARB=0x873F +GL_MODELVIEW3_ARB=0x8723 +GL_MODELVIEW4_ARB=0x8724 +GL_MODELVIEW5_ARB=0x8725 +GL_MODELVIEW6_ARB=0x8726 +GL_MODELVIEW7_ARB=0x8727 +GL_MODELVIEW8_ARB=0x8728 +GL_MODELVIEW9_ARB=0x8729 +GL_MODELVIEW=0x1700 +GL_MODELVIEW_MATRIX=0x0BA6 +GL_MODELVIEW_PROJECTION_NV=0x8629 +GL_MODELVIEW_STACK_DEPTH=0x0BA3 +GL_MODULATE=0x2100 +GL_MODULATE_ADD_ATI=0x8744 +GL_MODULATE_SIGNED_ADD_ATI=0x8745 +GL_MODULATE_SUBTRACT_ATI=0x8746 +GL_MOV_ATI=0x8961 +GL_MULT=0x0103 +GL_MULTISAMPLE=0x809D +GL_MULTISAMPLE_3DFX=0x86B2 +GL_MULTISAMPLE_ARB=0x809D +GL_MULTISAMPLE_BIT=0x20000000 +GL_MULTISAMPLE_BIT_3DFX=0x20000000 +GL_MULTISAMPLE_BIT_ARB=0x20000000 +GL_MULTISAMPLE_BIT_EXT=0x20000000 +GL_MULTISAMPLE_COVERAGE_MODES_NV=0x8E13 +GL_MULTISAMPLE_EXT=0x809D +GL_MULTISAMPLE_FILTER_HINT_NV=0x8534 +GL_MULTISAMPLE_SGIS=0x809D +GL_MUL_ATI=0x8964 +GL_MVP_MATRIX_EXT=0x87E3 +GL_N3F_V3F=0x2A25 +GL_NAME_STACK_DEPTH=0x0D70 +GL_NAND=0x150E +GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI=0x1A203 +GL_NATIVE_GRAPHICS_END_HINT_PGI=0x1A204 +GL_NATIVE_GRAPHICS_HANDLE_PGI=0x1A202 +GL_NEAREST=0x2600 +GL_NEAREST_CLIPMAP_LINEAR_SGIX=0x844E +GL_NEAREST_CLIPMAP_NEAREST_SGIX=0x844D +GL_NEAREST_MIPMAP_LINEAR=0x2702 +GL_NEAREST_MIPMAP_NEAREST=0x2700 +GL_NEGATE_BIT_ATI=0x00000004 +GL_NEGATIVE_ONE_EXT=0x87DF +GL_NEGATIVE_W_EXT=0x87DC +GL_NEGATIVE_X_EXT=0x87D9 +GL_NEGATIVE_Y_EXT=0x87DA +GL_NEGATIVE_Z_EXT=0x87DB +GL_NEVER=0x0200 +GL_NICEST=0x1102 +GL_NONE=0 +GL_NOOP=0x1505 +GL_NOR=0x1508 +GL_NORMALIZE=0x0BA1 +GL_NORMALIZED_RANGE_EXT=0x87E0 +GL_NORMAL_ARRAY=0x8075 +GL_NORMAL_ARRAY_ADDRESS_NV=0x8F22 +GL_NORMAL_ARRAY_BUFFER_BINDING=0x8897 +GL_NORMAL_ARRAY_BUFFER_BINDING_ARB=0x8897 +GL_NORMAL_ARRAY_COUNT_EXT=0x8080 +GL_NORMAL_ARRAY_EXT=0x8075 +GL_NORMAL_ARRAY_LENGTH_NV=0x8F2C +GL_NORMAL_ARRAY_LIST_IBM=103071 +GL_NORMAL_ARRAY_LIST_STRIDE_IBM=103081 +GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL=0x83F6 +GL_NORMAL_ARRAY_POINTER=0x808F +GL_NORMAL_ARRAY_POINTER_EXT=0x808F +GL_NORMAL_ARRAY_STRIDE=0x807F +GL_NORMAL_ARRAY_STRIDE_EXT=0x807F +GL_NORMAL_ARRAY_TYPE=0x807E +GL_NORMAL_ARRAY_TYPE_EXT=0x807E +GL_NORMAL_BIT_PGI=0x08000000 +GL_NORMAL_MAP=0x8511 +GL_NORMAL_MAP_ARB=0x8511 +GL_NORMAL_MAP_EXT=0x8511 +GL_NORMAL_MAP_NV=0x8511 +GL_NOTEQUAL=0x0205 +GL_NO_ERROR=0 +GL_NUM_COMPRESSED_TEXTURE_FORMATS=0x86A2 +GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB=0x86A2 +GL_NUM_EXTENSIONS=0x821D +GL_NUM_FILL_STREAMS_NV=0x8E29 +GL_NUM_FRAGMENT_CONSTANTS_ATI=0x896F +GL_NUM_FRAGMENT_REGISTERS_ATI=0x896E +GL_NUM_GENERAL_COMBINERS_NV=0x854E +GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI=0x8973 +GL_NUM_INSTRUCTIONS_PER_PASS_ATI=0x8971 +GL_NUM_INSTRUCTIONS_TOTAL_ATI=0x8972 +GL_NUM_LOOPBACK_COMPONENTS_ATI=0x8974 +GL_NUM_PASSES_ATI=0x8970 +GL_NV_blend_square=1 +GL_NV_conditional_render=1 +GL_NV_copy_depth_to_color=1 +GL_NV_depth_buffer_float=1 +GL_NV_depth_clamp=1 +GL_NV_evaluators=1 +GL_NV_explicit_multisample=1 +GL_NV_fence=1 +GL_NV_float_buffer=1 +GL_NV_fog_distance=1 +GL_NV_fragment_program2=1 +GL_NV_fragment_program=1 +GL_NV_fragment_program_option=1 +GL_NV_framebuffer_multisample_coverage=1 +GL_NV_geometry_program4=1 +GL_NV_gpu_program4=1 +GL_NV_half_float=1 +GL_NV_light_max_exponent=1 +GL_NV_multisample_filter_hint=1 +GL_NV_occlusion_query=1 +GL_NV_packed_depth_stencil=1 +GL_NV_parameter_buffer_object=1 +GL_NV_pixel_data_range=1 +GL_NV_point_sprite=1 +GL_NV_present_video=1 +GL_NV_primitive_restart=1 +GL_NV_register_combiners2=1 +GL_NV_register_combiners=1 +GL_NV_shader_buffer_load=1 +GL_NV_texgen_emboss=1 +GL_NV_texgen_reflection=1 +GL_NV_texture_compression_vtc=1 +GL_NV_texture_env_combine4=1 +GL_NV_texture_expand_normal=1 +GL_NV_texture_rectangle=1 +GL_NV_texture_shader2=1 +GL_NV_texture_shader3=1 +GL_NV_texture_shader=1 +GL_NV_transform_feedback2=1 +GL_NV_transform_feedback=1 +GL_NV_vertex_array_range2=1 +GL_NV_vertex_array_range=1 +GL_NV_vertex_buffer_unified_memory=1 +GL_NV_vertex_program1_1=1 +GL_NV_vertex_program2=1 +GL_NV_vertex_program2_option=1 +GL_NV_vertex_program3=1 +GL_NV_vertex_program=1 +GL_OBJECT_ACTIVE_ATTRIBUTES_ARB=0x8B89 +GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB=0x8B8A +GL_OBJECT_ACTIVE_UNIFORMS_ARB=0x8B86 +GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB=0x8B87 +GL_OBJECT_ATTACHED_OBJECTS_ARB=0x8B85 +GL_OBJECT_BUFFER_SIZE_ATI=0x8764 +GL_OBJECT_BUFFER_USAGE_ATI=0x8765 +GL_OBJECT_COMPILE_STATUS_ARB=0x8B81 +GL_OBJECT_DELETE_STATUS_ARB=0x8B80 +GL_OBJECT_DISTANCE_TO_LINE_SGIS=0x81F3 +GL_OBJECT_DISTANCE_TO_POINT_SGIS=0x81F1 +GL_OBJECT_INFO_LOG_LENGTH_ARB=0x8B84 +GL_OBJECT_LINEAR=0x2401 +GL_OBJECT_LINE_SGIS=0x81F7 +GL_OBJECT_LINK_STATUS_ARB=0x8B82 +GL_OBJECT_PLANE=0x2501 +GL_OBJECT_POINT_SGIS=0x81F5 +GL_OBJECT_SHADER_SOURCE_LENGTH_ARB=0x8B88 +GL_OBJECT_SUBTYPE_ARB=0x8B4F +GL_OBJECT_TYPE_ARB=0x8B4E +GL_OBJECT_VALIDATE_STATUS_ARB=0x8B83 +GL_OCCLUSION_TEST_HP=0x8165 +GL_OCCLUSION_TEST_RESULT_HP=0x8166 +GL_OES_read_format=1 +GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV=0x8856 +GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV=0x8857 +GL_OFFSET_HILO_TEXTURE_2D_NV=0x8854 +GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV=0x8855 +GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV=0x8850 +GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV=0x8851 +GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV=0x8852 +GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV=0x8853 +GL_OFFSET_TEXTURE_2D_BIAS_NV=0x86E3 +GL_OFFSET_TEXTURE_2D_MATRIX_NV=0x86E1 +GL_OFFSET_TEXTURE_2D_NV=0x86E8 +GL_OFFSET_TEXTURE_2D_SCALE_NV=0x86E2 +GL_OFFSET_TEXTURE_BIAS_NV=0x86E3 +GL_OFFSET_TEXTURE_MATRIX_NV=0x86E1 +GL_OFFSET_TEXTURE_RECTANGLE_NV=0x864C +GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV=0x864D +GL_OFFSET_TEXTURE_SCALE_NV=0x86E2 +GL_OML_interlace=1 +GL_OML_resample=1 +GL_OML_subsample=1 +GL_ONE=1 +GL_ONE_EXT=0x87DE +GL_ONE_MINUS_CONSTANT_ALPHA=0x8004 +GL_ONE_MINUS_CONSTANT_ALPHA_EXT=0x8004 +GL_ONE_MINUS_CONSTANT_COLOR=0x8002 +GL_ONE_MINUS_CONSTANT_COLOR_EXT=0x8002 +GL_ONE_MINUS_DST_ALPHA=0x0305 +GL_ONE_MINUS_DST_COLOR=0x0307 +GL_ONE_MINUS_SRC_ALPHA=0x0303 +GL_ONE_MINUS_SRC_COLOR=0x0301 +GL_OPERAND0_ALPHA=0x8598 +GL_OPERAND0_ALPHA_ARB=0x8598 +GL_OPERAND0_ALPHA_EXT=0x8598 +GL_OPERAND0_RGB=0x8590 +GL_OPERAND0_RGB_ARB=0x8590 +GL_OPERAND0_RGB_EXT=0x8590 +GL_OPERAND1_ALPHA=0x8599 +GL_OPERAND1_ALPHA_ARB=0x8599 +GL_OPERAND1_ALPHA_EXT=0x8599 +GL_OPERAND1_RGB=0x8591 +GL_OPERAND1_RGB_ARB=0x8591 +GL_OPERAND1_RGB_EXT=0x8591 +GL_OPERAND2_ALPHA=0x859A +GL_OPERAND2_ALPHA_ARB=0x859A +GL_OPERAND2_ALPHA_EXT=0x859A +GL_OPERAND2_RGB=0x8592 +GL_OPERAND2_RGB_ARB=0x8592 +GL_OPERAND2_RGB_EXT=0x8592 +GL_OPERAND3_ALPHA_NV=0x859B +GL_OPERAND3_RGB_NV=0x8593 +GL_OP_ADD_EXT=0x8787 +GL_OP_CLAMP_EXT=0x878E +GL_OP_CROSS_PRODUCT_EXT=0x8797 +GL_OP_DOT3_EXT=0x8784 +GL_OP_DOT4_EXT=0x8785 +GL_OP_EXP_BASE_2_EXT=0x8791 +GL_OP_FLOOR_EXT=0x878F +GL_OP_FRAC_EXT=0x8789 +GL_OP_INDEX_EXT=0x8782 +GL_OP_LOG_BASE_2_EXT=0x8792 +GL_OP_MADD_EXT=0x8788 +GL_OP_MAX_EXT=0x878A +GL_OP_MIN_EXT=0x878B +GL_OP_MOV_EXT=0x8799 +GL_OP_MULTIPLY_MATRIX_EXT=0x8798 +GL_OP_MUL_EXT=0x8786 +GL_OP_NEGATE_EXT=0x8783 +GL_OP_POWER_EXT=0x8793 +GL_OP_RECIP_EXT=0x8794 +GL_OP_RECIP_SQRT_EXT=0x8795 +GL_OP_ROUND_EXT=0x8790 +GL_OP_SET_GE_EXT=0x878C +GL_OP_SET_LT_EXT=0x878D +GL_OP_SUB_EXT=0x8796 +GL_OR=0x1507 +GL_ORDER=0x0A01 +GL_OR_INVERTED=0x150D +GL_OR_REVERSE=0x150B +GL_OUTPUT_COLOR0_EXT=0x879B +GL_OUTPUT_COLOR1_EXT=0x879C +GL_OUTPUT_FOG_EXT=0x87BD +GL_OUTPUT_TEXTURE_COORD0_EXT=0x879D +GL_OUTPUT_TEXTURE_COORD10_EXT=0x87A7 +GL_OUTPUT_TEXTURE_COORD11_EXT=0x87A8 +GL_OUTPUT_TEXTURE_COORD12_EXT=0x87A9 +GL_OUTPUT_TEXTURE_COORD13_EXT=0x87AA +GL_OUTPUT_TEXTURE_COORD14_EXT=0x87AB +GL_OUTPUT_TEXTURE_COORD15_EXT=0x87AC +GL_OUTPUT_TEXTURE_COORD16_EXT=0x87AD +GL_OUTPUT_TEXTURE_COORD17_EXT=0x87AE +GL_OUTPUT_TEXTURE_COORD18_EXT=0x87AF +GL_OUTPUT_TEXTURE_COORD19_EXT=0x87B0 +GL_OUTPUT_TEXTURE_COORD1_EXT=0x879E +GL_OUTPUT_TEXTURE_COORD20_EXT=0x87B1 +GL_OUTPUT_TEXTURE_COORD21_EXT=0x87B2 +GL_OUTPUT_TEXTURE_COORD22_EXT=0x87B3 +GL_OUTPUT_TEXTURE_COORD23_EXT=0x87B4 +GL_OUTPUT_TEXTURE_COORD24_EXT=0x87B5 +GL_OUTPUT_TEXTURE_COORD25_EXT=0x87B6 +GL_OUTPUT_TEXTURE_COORD26_EXT=0x87B7 +GL_OUTPUT_TEXTURE_COORD27_EXT=0x87B8 +GL_OUTPUT_TEXTURE_COORD28_EXT=0x87B9 +GL_OUTPUT_TEXTURE_COORD29_EXT=0x87BA +GL_OUTPUT_TEXTURE_COORD2_EXT=0x879F +GL_OUTPUT_TEXTURE_COORD30_EXT=0x87BB +GL_OUTPUT_TEXTURE_COORD31_EXT=0x87BC +GL_OUTPUT_TEXTURE_COORD3_EXT=0x87A0 +GL_OUTPUT_TEXTURE_COORD4_EXT=0x87A1 +GL_OUTPUT_TEXTURE_COORD5_EXT=0x87A2 +GL_OUTPUT_TEXTURE_COORD6_EXT=0x87A3 +GL_OUTPUT_TEXTURE_COORD7_EXT=0x87A4 +GL_OUTPUT_TEXTURE_COORD8_EXT=0x87A5 +GL_OUTPUT_TEXTURE_COORD9_EXT=0x87A6 +GL_OUTPUT_VERTEX_EXT=0x879A +GL_OUT_OF_MEMORY=0x0505 +GL_PACK_ALIGNMENT=0x0D05 +GL_PACK_CMYK_HINT_EXT=0x800E +GL_PACK_IMAGE_DEPTH_SGIS=0x8131 +GL_PACK_IMAGE_HEIGHT=0x806C +GL_PACK_IMAGE_HEIGHT_EXT=0x806C +GL_PACK_INVERT_MESA=0x8758 +GL_PACK_LSB_FIRST=0x0D01 +GL_PACK_RESAMPLE_OML=0x8984 +GL_PACK_RESAMPLE_SGIX=0x842C +GL_PACK_ROW_LENGTH=0x0D02 +GL_PACK_SKIP_IMAGES=0x806B +GL_PACK_SKIP_IMAGES_EXT=0x806B +GL_PACK_SKIP_PIXELS=0x0D04 +GL_PACK_SKIP_ROWS=0x0D03 +GL_PACK_SKIP_VOLUMES_SGIS=0x8130 +GL_PACK_SUBSAMPLE_RATE_SGIX=0x85A0 +GL_PACK_SWAP_BYTES=0x0D00 +GL_PARALLEL_ARRAYS_INTEL=0x83F4 +GL_PASS_THROUGH_NV=0x86E6 +GL_PASS_THROUGH_TOKEN=0x0700 +GL_PERSPECTIVE_CORRECTION_HINT=0x0C50 +GL_PERTURB_EXT=0x85AE +GL_PER_STAGE_CONSTANTS_NV=0x8535 +GL_PGI_misc_hints=1 +GL_PGI_vertex_hints=1 +GL_PHONG_HINT_WIN=0x80EB +GL_PHONG_WIN=0x80EA +GL_PIXEL_COUNTER_BITS_NV=0x8864 +GL_PIXEL_COUNT_AVAILABLE_NV=0x8867 +GL_PIXEL_COUNT_NV=0x8866 +GL_PIXEL_CUBIC_WEIGHT_EXT=0x8333 +GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS=0x8355 +GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS=0x8354 +GL_PIXEL_GROUP_COLOR_SGIS=0x8356 +GL_PIXEL_MAG_FILTER_EXT=0x8331 +GL_PIXEL_MAP_A_TO_A=0x0C79 +GL_PIXEL_MAP_A_TO_A_SIZE=0x0CB9 +GL_PIXEL_MAP_B_TO_B=0x0C78 +GL_PIXEL_MAP_B_TO_B_SIZE=0x0CB8 +GL_PIXEL_MAP_G_TO_G=0x0C77 +GL_PIXEL_MAP_G_TO_G_SIZE=0x0CB7 +GL_PIXEL_MAP_I_TO_A=0x0C75 +GL_PIXEL_MAP_I_TO_A_SIZE=0x0CB5 +GL_PIXEL_MAP_I_TO_B=0x0C74 +GL_PIXEL_MAP_I_TO_B_SIZE=0x0CB4 +GL_PIXEL_MAP_I_TO_G=0x0C73 +GL_PIXEL_MAP_I_TO_G_SIZE=0x0CB3 +GL_PIXEL_MAP_I_TO_I=0x0C70 +GL_PIXEL_MAP_I_TO_I_SIZE=0x0CB0 +GL_PIXEL_MAP_I_TO_R=0x0C72 +GL_PIXEL_MAP_I_TO_R_SIZE=0x0CB2 +GL_PIXEL_MAP_R_TO_R=0x0C76 +GL_PIXEL_MAP_R_TO_R_SIZE=0x0CB6 +GL_PIXEL_MAP_S_TO_S=0x0C71 +GL_PIXEL_MAP_S_TO_S_SIZE=0x0CB1 +GL_PIXEL_MIN_FILTER_EXT=0x8332 +GL_PIXEL_MODE_BIT=0x00000020 +GL_PIXEL_PACK_BUFFER=0x88EB +GL_PIXEL_PACK_BUFFER_ARB=0x88EB +GL_PIXEL_PACK_BUFFER_BINDING=0x88ED +GL_PIXEL_PACK_BUFFER_BINDING_ARB=0x88ED +GL_PIXEL_PACK_BUFFER_BINDING_EXT=0x88ED +GL_PIXEL_PACK_BUFFER_EXT=0x88EB +GL_PIXEL_SUBSAMPLE_2424_SGIX=0x85A3 +GL_PIXEL_SUBSAMPLE_4242_SGIX=0x85A4 +GL_PIXEL_SUBSAMPLE_4444_SGIX=0x85A2 +GL_PIXEL_TEXTURE_SGIS=0x8353 +GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX=0x8189 +GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX=0x818A +GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX=0x8188 +GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX=0x8187 +GL_PIXEL_TEX_GEN_MODE_SGIX=0x832B +GL_PIXEL_TEX_GEN_Q_CEILING_SGIX=0x8184 +GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX=0x8186 +GL_PIXEL_TEX_GEN_Q_ROUND_SGIX=0x8185 +GL_PIXEL_TEX_GEN_SGIX=0x8139 +GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX=0x813E +GL_PIXEL_TILE_CACHE_INCREMENT_SGIX=0x813F +GL_PIXEL_TILE_CACHE_SIZE_SGIX=0x8145 +GL_PIXEL_TILE_GRID_DEPTH_SGIX=0x8144 +GL_PIXEL_TILE_GRID_HEIGHT_SGIX=0x8143 +GL_PIXEL_TILE_GRID_WIDTH_SGIX=0x8142 +GL_PIXEL_TILE_HEIGHT_SGIX=0x8141 +GL_PIXEL_TILE_WIDTH_SGIX=0x8140 +GL_PIXEL_TRANSFORM_2D_EXT=0x8330 +GL_PIXEL_TRANSFORM_2D_MATRIX_EXT=0x8338 +GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT=0x8336 +GL_PIXEL_UNPACK_BUFFER=0x88EC +GL_PIXEL_UNPACK_BUFFER_ARB=0x88EC +GL_PIXEL_UNPACK_BUFFER_BINDING=0x88EF +GL_PIXEL_UNPACK_BUFFER_BINDING_ARB=0x88EF +GL_PIXEL_UNPACK_BUFFER_BINDING_EXT=0x88EF +GL_PIXEL_UNPACK_BUFFER_EXT=0x88EC +GL_PN_TRIANGLES_ATI=0x87F0 +GL_PN_TRIANGLES_NORMAL_MODE_ATI=0x87F3 +GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI=0x87F7 +GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI=0x87F8 +GL_PN_TRIANGLES_POINT_MODE_ATI=0x87F2 +GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI=0x87F6 +GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI=0x87F5 +GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI=0x87F4 +GL_POINT=0x1B00 +GL_POINTS=0x0000 +GL_POINT_BIT=0x00000002 +GL_POINT_DISTANCE_ATTENUATION=0x8129 +GL_POINT_DISTANCE_ATTENUATION_ARB=0x8129 +GL_POINT_FADE_THRESHOLD_SIZE=0x8128 +GL_POINT_FADE_THRESHOLD_SIZE_ARB=0x8128 +GL_POINT_FADE_THRESHOLD_SIZE_EXT=0x8128 +GL_POINT_FADE_THRESHOLD_SIZE_SGIS=0x8128 +GL_POINT_SIZE=0x0B11 +GL_POINT_SIZE_GRANULARITY=0x0B13 +GL_POINT_SIZE_MAX=0x8127 +GL_POINT_SIZE_MAX_ARB=0x8127 +GL_POINT_SIZE_MAX_EXT=0x8127 +GL_POINT_SIZE_MAX_SGIS=0x8127 +GL_POINT_SIZE_MIN=0x8126 +GL_POINT_SIZE_MIN_ARB=0x8126 +GL_POINT_SIZE_MIN_EXT=0x8126 +GL_POINT_SIZE_MIN_SGIS=0x8126 +GL_POINT_SIZE_RANGE=0x0B12 +GL_POINT_SMOOTH=0x0B10 +GL_POINT_SMOOTH_HINT=0x0C51 +GL_POINT_SPRITE=0x8861 +GL_POINT_SPRITE_ARB=0x8861 +GL_POINT_SPRITE_COORD_ORIGIN=0x8CA0 +GL_POINT_SPRITE_NV=0x8861 +GL_POINT_SPRITE_R_MODE_NV=0x8863 +GL_POINT_TOKEN=0x0701 +GL_POLYGON=0x0009 +GL_POLYGON_BIT=0x00000008 +GL_POLYGON_MODE=0x0B40 +GL_POLYGON_OFFSET_BIAS_EXT=0x8039 +GL_POLYGON_OFFSET_EXT=0x8037 +GL_POLYGON_OFFSET_FACTOR=0x8038 +GL_POLYGON_OFFSET_FACTOR_EXT=0x8038 +GL_POLYGON_OFFSET_FILL=0x8037 +GL_POLYGON_OFFSET_LINE=0x2A02 +GL_POLYGON_OFFSET_POINT=0x2A01 +GL_POLYGON_OFFSET_UNITS=0x2A00 +GL_POLYGON_SMOOTH=0x0B41 +GL_POLYGON_SMOOTH_HINT=0x0C53 +GL_POLYGON_STIPPLE=0x0B42 +GL_POLYGON_STIPPLE_BIT=0x00000010 +GL_POLYGON_TOKEN=0x0703 +GL_POSITION=0x1203 +GL_POST_COLOR_MATRIX_ALPHA_BIAS=0x80BB +GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI=0x80BB +GL_POST_COLOR_MATRIX_ALPHA_SCALE=0x80B7 +GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI=0x80B7 +GL_POST_COLOR_MATRIX_BLUE_BIAS=0x80BA +GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI=0x80BA +GL_POST_COLOR_MATRIX_BLUE_SCALE=0x80B6 +GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI=0x80B6 +GL_POST_COLOR_MATRIX_COLOR_TABLE=0x80D2 +GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI=0x80D2 +GL_POST_COLOR_MATRIX_GREEN_BIAS=0x80B9 +GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI=0x80B9 +GL_POST_COLOR_MATRIX_GREEN_SCALE=0x80B5 +GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI=0x80B5 +GL_POST_COLOR_MATRIX_RED_BIAS=0x80B8 +GL_POST_COLOR_MATRIX_RED_BIAS_SGI=0x80B8 +GL_POST_COLOR_MATRIX_RED_SCALE=0x80B4 +GL_POST_COLOR_MATRIX_RED_SCALE_SGI=0x80B4 +GL_POST_CONVOLUTION_ALPHA_BIAS=0x8023 +GL_POST_CONVOLUTION_ALPHA_BIAS_EXT=0x8023 +GL_POST_CONVOLUTION_ALPHA_SCALE=0x801F +GL_POST_CONVOLUTION_ALPHA_SCALE_EXT=0x801F +GL_POST_CONVOLUTION_BLUE_BIAS=0x8022 +GL_POST_CONVOLUTION_BLUE_BIAS_EXT=0x8022 +GL_POST_CONVOLUTION_BLUE_SCALE=0x801E +GL_POST_CONVOLUTION_BLUE_SCALE_EXT=0x801E +GL_POST_CONVOLUTION_COLOR_TABLE=0x80D1 +GL_POST_CONVOLUTION_COLOR_TABLE_SGI=0x80D1 +GL_POST_CONVOLUTION_GREEN_BIAS=0x8021 +GL_POST_CONVOLUTION_GREEN_BIAS_EXT=0x8021 +GL_POST_CONVOLUTION_GREEN_SCALE=0x801D +GL_POST_CONVOLUTION_GREEN_SCALE_EXT=0x801D +GL_POST_CONVOLUTION_RED_BIAS=0x8020 +GL_POST_CONVOLUTION_RED_BIAS_EXT=0x8020 +GL_POST_CONVOLUTION_RED_SCALE=0x801C +GL_POST_CONVOLUTION_RED_SCALE_EXT=0x801C +GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP=0x8162 +GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX=0x817B +GL_POST_TEXTURE_FILTER_BIAS_SGIX=0x8179 +GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX=0x817C +GL_POST_TEXTURE_FILTER_SCALE_SGIX=0x817A +GL_PREFER_DOUBLEBUFFER_HINT_PGI=0x1A1F8 +GL_PRESENT_DURATION_NV=0x8E2B +GL_PRESENT_TIME_NV=0x8E2A +GL_PRESERVE_ATI=0x8762 +GL_PREVIOUS=0x8578 +GL_PREVIOUS_ARB=0x8578 +GL_PREVIOUS_EXT=0x8578 +GL_PREVIOUS_TEXTURE_INPUT_NV=0x86E4 +GL_PRIMARY_COLOR=0x8577 +GL_PRIMARY_COLOR_ARB=0x8577 +GL_PRIMARY_COLOR_EXT=0x8577 +GL_PRIMARY_COLOR_NV=0x852C +GL_PRIMITIVES_GENERATED=0x8C87 +GL_PRIMITIVES_GENERATED_EXT=0x8C87 +GL_PRIMITIVES_GENERATED_NV=0x8C87 +GL_PRIMITIVE_ID_NV=0x8C7C +GL_PRIMITIVE_RESTART_INDEX_NV=0x8559 +GL_PRIMITIVE_RESTART_NV=0x8558 +GL_PROGRAM_ADDRESS_REGISTERS_ARB=0x88B0 +GL_PROGRAM_ALU_INSTRUCTIONS_ARB=0x8805 +GL_PROGRAM_ATTRIBS_ARB=0x88AC +GL_PROGRAM_ATTRIB_COMPONENTS_NV=0x8906 +GL_PROGRAM_BINDING_ARB=0x8677 +GL_PROGRAM_ERROR_POSITION_ARB=0x864B +GL_PROGRAM_ERROR_POSITION_NV=0x864B +GL_PROGRAM_ERROR_STRING_ARB=0x8874 +GL_PROGRAM_ERROR_STRING_NV=0x8874 +GL_PROGRAM_FORMAT_ARB=0x8876 +GL_PROGRAM_FORMAT_ASCII_ARB=0x8875 +GL_PROGRAM_INSTRUCTIONS_ARB=0x88A0 +GL_PROGRAM_LENGTH_ARB=0x8627 +GL_PROGRAM_LENGTH_NV=0x8627 +GL_PROGRAM_MATRIX_EXT=0x8E2D +GL_PROGRAM_MATRIX_STACK_DEPTH_EXT=0x8E2F +GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB=0x88B2 +GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB=0x8808 +GL_PROGRAM_NATIVE_ATTRIBS_ARB=0x88AE +GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB=0x88A2 +GL_PROGRAM_NATIVE_PARAMETERS_ARB=0x88AA +GL_PROGRAM_NATIVE_TEMPORARIES_ARB=0x88A6 +GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB=0x880A +GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB=0x8809 +GL_PROGRAM_OBJECT_ARB=0x8B40 +GL_PROGRAM_PARAMETERS_ARB=0x88A8 +GL_PROGRAM_PARAMETER_NV=0x8644 +GL_PROGRAM_POINT_SIZE_ARB=0x8642 +GL_PROGRAM_POINT_SIZE_EXT=0x8642 +GL_PROGRAM_RESIDENT_NV=0x8647 +GL_PROGRAM_RESULT_COMPONENTS_NV=0x8907 +GL_PROGRAM_STRING_ARB=0x8628 +GL_PROGRAM_STRING_NV=0x8628 +GL_PROGRAM_TARGET_NV=0x8646 +GL_PROGRAM_TEMPORARIES_ARB=0x88A4 +GL_PROGRAM_TEX_INDIRECTIONS_ARB=0x8807 +GL_PROGRAM_TEX_INSTRUCTIONS_ARB=0x8806 +GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB=0x88B6 +GL_PROJECTION=0x1701 +GL_PROJECTION_MATRIX=0x0BA7 +GL_PROJECTION_STACK_DEPTH=0x0BA4 +GL_PROXY_COLOR_TABLE=0x80D3 +GL_PROXY_COLOR_TABLE_SGI=0x80D3 +GL_PROXY_HISTOGRAM=0x8025 +GL_PROXY_HISTOGRAM_EXT=0x8025 +GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE=0x80D5 +GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI=0x80D5 +GL_PROXY_POST_CONVOLUTION_COLOR_TABLE=0x80D4 +GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI=0x80D4 +GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP=0x8163 +GL_PROXY_TEXTURE_1D=0x8063 +GL_PROXY_TEXTURE_1D_ARRAY=0x8C19 +GL_PROXY_TEXTURE_1D_ARRAY_EXT=0x8C19 +GL_PROXY_TEXTURE_1D_EXT=0x8063 +GL_PROXY_TEXTURE_2D=0x8064 +GL_PROXY_TEXTURE_2D_ARRAY=0x8C1B +GL_PROXY_TEXTURE_2D_ARRAY_EXT=0x8C1B +GL_PROXY_TEXTURE_2D_EXT=0x8064 +GL_PROXY_TEXTURE_3D=0x8070 +GL_PROXY_TEXTURE_3D_EXT=0x8070 +GL_PROXY_TEXTURE_4D_SGIS=0x8135 +GL_PROXY_TEXTURE_COLOR_TABLE_SGI=0x80BD +GL_PROXY_TEXTURE_CUBE_MAP=0x851B +GL_PROXY_TEXTURE_CUBE_MAP_ARB=0x851B +GL_PROXY_TEXTURE_CUBE_MAP_EXT=0x851B +GL_PROXY_TEXTURE_RECTANGLE_ARB=0x84F7 +GL_PROXY_TEXTURE_RECTANGLE_NV=0x84F7 +GL_Q=0x2003 +GL_QUADRATIC_ATTENUATION=0x1209 +GL_QUADS=0x0007 +GL_QUAD_ALPHA4_SGIS=0x811E +GL_QUAD_ALPHA8_SGIS=0x811F +GL_QUAD_INTENSITY4_SGIS=0x8122 +GL_QUAD_INTENSITY8_SGIS=0x8123 +GL_QUAD_LUMINANCE4_SGIS=0x8120 +GL_QUAD_LUMINANCE8_SGIS=0x8121 +GL_QUAD_MESH_SUN=0x8614 +GL_QUAD_STRIP=0x0008 +GL_QUAD_TEXTURE_SELECT_SGIS=0x8125 +GL_QUARTER_BIT_ATI=0x00000010 +GL_QUERY_BY_REGION_NO_WAIT=0x8E16 +GL_QUERY_BY_REGION_NO_WAIT_NV=0x8E16 +GL_QUERY_BY_REGION_WAIT=0x8E15 +GL_QUERY_BY_REGION_WAIT_NV=0x8E15 +GL_QUERY_COUNTER_BITS=0x8864 +GL_QUERY_COUNTER_BITS_ARB=0x8864 +GL_QUERY_NO_WAIT=0x8E14 +GL_QUERY_NO_WAIT_NV=0x8E14 +GL_QUERY_RESULT=0x8866 +GL_QUERY_RESULT_ARB=0x8866 +GL_QUERY_RESULT_AVAILABLE=0x8867 +GL_QUERY_RESULT_AVAILABLE_ARB=0x8867 +GL_QUERY_WAIT=0x8E13 +GL_QUERY_WAIT_NV=0x8E13 +GL_R11F_G11F_B10F=0x8C3A +GL_R11F_G11F_B10F_EXT=0x8C3A +GL_R16=0x822A +GL_R16F=0x822D +GL_R16I=0x8233 +GL_R16UI=0x8234 +GL_R1UI_C3F_V3F_SUN=0x85C6 +GL_R1UI_C4F_N3F_V3F_SUN=0x85C8 +GL_R1UI_C4UB_V3F_SUN=0x85C5 +GL_R1UI_N3F_V3F_SUN=0x85C7 +GL_R1UI_T2F_C4F_N3F_V3F_SUN=0x85CB +GL_R1UI_T2F_N3F_V3F_SUN=0x85CA +GL_R1UI_T2F_V3F_SUN=0x85C9 +GL_R1UI_V3F_SUN=0x85C4 +GL_R32F=0x822E +GL_R32I=0x8235 +GL_R32UI=0x8236 +GL_R3_G3_B2=0x2A10 +GL_R8=0x8229 +GL_R8I=0x8231 +GL_R8UI=0x8232 +GL_R=0x2002 +GL_RASTERIZER_DISCARD=0x8C89 +GL_RASTERIZER_DISCARD_EXT=0x8C89 +GL_RASTERIZER_DISCARD_NV=0x8C89 +GL_RASTER_POSITION_UNCLIPPED_IBM=0x19262 +GL_READ_BUFFER=0x0C02 +GL_READ_FRAMEBUFFER=0x8CA8 +GL_READ_FRAMEBUFFER_BINDING=0x8CAA +GL_READ_FRAMEBUFFER_BINDING_EXT=0x8CAA +GL_READ_FRAMEBUFFER_EXT=0x8CA8 +GL_READ_ONLY=0x88B8 +GL_READ_ONLY_ARB=0x88B8 +GL_READ_PIXEL_DATA_RANGE_LENGTH_NV=0x887B +GL_READ_PIXEL_DATA_RANGE_NV=0x8879 +GL_READ_PIXEL_DATA_RANGE_POINTER_NV=0x887D +GL_READ_WRITE=0x88BA +GL_READ_WRITE_ARB=0x88BA +GL_RECLAIM_MEMORY_HINT_PGI=0x1A1FE +GL_RED=0x1903 +GL_REDUCE=0x8016 +GL_REDUCE_EXT=0x8016 +GL_RED_BIAS=0x0D15 +GL_RED_BITS=0x0D52 +GL_RED_BIT_ATI=0x00000001 +GL_RED_INTEGER=0x8D94 +GL_RED_INTEGER_EXT=0x8D94 +GL_RED_MAX_CLAMP_INGR=0x8564 +GL_RED_MIN_CLAMP_INGR=0x8560 +GL_RED_SCALE=0x0D14 +GL_REFERENCE_PLANE_EQUATION_SGIX=0x817E +GL_REFERENCE_PLANE_SGIX=0x817D +GL_REFLECTION_MAP=0x8512 +GL_REFLECTION_MAP_ARB=0x8512 +GL_REFLECTION_MAP_EXT=0x8512 +GL_REFLECTION_MAP_NV=0x8512 +GL_REGISTER_COMBINERS_NV=0x8522 +GL_REG_0_ATI=0x8921 +GL_REG_10_ATI=0x892B +GL_REG_11_ATI=0x892C +GL_REG_12_ATI=0x892D +GL_REG_13_ATI=0x892E +GL_REG_14_ATI=0x892F +GL_REG_15_ATI=0x8930 +GL_REG_16_ATI=0x8931 +GL_REG_17_ATI=0x8932 +GL_REG_18_ATI=0x8933 +GL_REG_19_ATI=0x8934 +GL_REG_1_ATI=0x8922 +GL_REG_20_ATI=0x8935 +GL_REG_21_ATI=0x8936 +GL_REG_22_ATI=0x8937 +GL_REG_23_ATI=0x8938 +GL_REG_24_ATI=0x8939 +GL_REG_25_ATI=0x893A +GL_REG_26_ATI=0x893B +GL_REG_27_ATI=0x893C +GL_REG_28_ATI=0x893D +GL_REG_29_ATI=0x893E +GL_REG_2_ATI=0x8923 +GL_REG_30_ATI=0x893F +GL_REG_31_ATI=0x8940 +GL_REG_3_ATI=0x8924 +GL_REG_4_ATI=0x8925 +GL_REG_5_ATI=0x8926 +GL_REG_6_ATI=0x8927 +GL_REG_7_ATI=0x8928 +GL_REG_8_ATI=0x8929 +GL_REG_9_ATI=0x892A +GL_RENDER=0x1C00 +GL_RENDERBUFFER=0x8D41 +GL_RENDERBUFFER_ALPHA_SIZE=0x8D53 +GL_RENDERBUFFER_ALPHA_SIZE_EXT=0x8D53 +GL_RENDERBUFFER_BINDING=0x8CA7 +GL_RENDERBUFFER_BINDING_EXT=0x8CA7 +GL_RENDERBUFFER_BLUE_SIZE=0x8D52 +GL_RENDERBUFFER_BLUE_SIZE_EXT=0x8D52 +GL_RENDERBUFFER_COLOR_SAMPLES_NV=0x8E10 +GL_RENDERBUFFER_COVERAGE_SAMPLES_NV=0x8CAB +GL_RENDERBUFFER_DEPTH_SIZE=0x8D54 +GL_RENDERBUFFER_DEPTH_SIZE_EXT=0x8D54 +GL_RENDERBUFFER_EXT=0x8D41 +GL_RENDERBUFFER_GREEN_SIZE=0x8D51 +GL_RENDERBUFFER_GREEN_SIZE_EXT=0x8D51 +GL_RENDERBUFFER_HEIGHT=0x8D43 +GL_RENDERBUFFER_HEIGHT_EXT=0x8D43 +GL_RENDERBUFFER_INTERNAL_FORMAT=0x8D44 +GL_RENDERBUFFER_INTERNAL_FORMAT_EXT=0x8D44 +GL_RENDERBUFFER_RED_SIZE=0x8D50 +GL_RENDERBUFFER_RED_SIZE_EXT=0x8D50 +GL_RENDERBUFFER_SAMPLES=0x8CAB +GL_RENDERBUFFER_SAMPLES_EXT=0x8CAB +GL_RENDERBUFFER_STENCIL_SIZE=0x8D55 +GL_RENDERBUFFER_STENCIL_SIZE_EXT=0x8D55 +GL_RENDERBUFFER_WIDTH=0x8D42 +GL_RENDERBUFFER_WIDTH_EXT=0x8D42 +GL_RENDERER=0x1F01 +GL_RENDER_MODE=0x0C40 +GL_REND_screen_coordinates=1 +GL_REPEAT=0x2901 +GL_REPLACE=0x1E01 +GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN=0x85C3 +GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN=0x85C2 +GL_REPLACEMENT_CODE_ARRAY_SUN=0x85C0 +GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN=0x85C1 +GL_REPLACEMENT_CODE_SUN=0x81D8 +GL_REPLACE_EXT=0x8062 +GL_REPLACE_MIDDLE_SUN=0x0002 +GL_REPLACE_OLDEST_SUN=0x0003 +GL_REPLICATE_BORDER=0x8153 +GL_REPLICATE_BORDER_HP=0x8153 +GL_RESAMPLE_AVERAGE_OML=0x8988 +GL_RESAMPLE_DECIMATE_OML=0x8989 +GL_RESAMPLE_DECIMATE_SGIX=0x8430 +GL_RESAMPLE_REPLICATE_OML=0x8986 +GL_RESAMPLE_REPLICATE_SGIX=0x842E +GL_RESAMPLE_ZERO_FILL_OML=0x8987 +GL_RESAMPLE_ZERO_FILL_SGIX=0x842F +GL_RESCALE_NORMAL=0x803A +GL_RESCALE_NORMAL_EXT=0x803A +GL_RESTART_SUN=0x0001 +GL_RETURN=0x0102 +GL_RG16=0x822C +GL_RG16F=0x822F +GL_RG16I=0x8239 +GL_RG16UI=0x823A +GL_RG32F=0x8230 +GL_RG32I=0x823B +GL_RG32UI=0x823C +GL_RG8=0x822B +GL_RG8I=0x8237 +GL_RG8UI=0x8238 +GL_RG=0x8227 +GL_RGB10=0x8052 +GL_RGB10_A2=0x8059 +GL_RGB10_A2_EXT=0x8059 +GL_RGB10_EXT=0x8052 +GL_RGB12=0x8053 +GL_RGB12_EXT=0x8053 +GL_RGB16=0x8054 +GL_RGB16F=0x881B +GL_RGB16F_ARB=0x881B +GL_RGB16I=0x8D89 +GL_RGB16I_EXT=0x8D89 +GL_RGB16UI=0x8D77 +GL_RGB16UI_EXT=0x8D77 +GL_RGB16_EXT=0x8054 +GL_RGB2_EXT=0x804E +GL_RGB32F=0x8815 +GL_RGB32F_ARB=0x8815 +GL_RGB32I=0x8D83 +GL_RGB32I_EXT=0x8D83 +GL_RGB32UI=0x8D71 +GL_RGB32UI_EXT=0x8D71 +GL_RGB4=0x804F +GL_RGB4_EXT=0x804F +GL_RGB4_S3TC=0x83A1 +GL_RGB5=0x8050 +GL_RGB5_A1=0x8057 +GL_RGB5_A1_EXT=0x8057 +GL_RGB5_EXT=0x8050 +GL_RGB8=0x8051 +GL_RGB8I=0x8D8F +GL_RGB8I_EXT=0x8D8F +GL_RGB8UI=0x8D7D +GL_RGB8UI_EXT=0x8D7D +GL_RGB8_EXT=0x8051 +GL_RGB9_E5=0x8C3D +GL_RGB9_E5_EXT=0x8C3D +GL_RGB=0x1907 +GL_RGBA12=0x805A +GL_RGBA12_EXT=0x805A +GL_RGBA16=0x805B +GL_RGBA16F=0x881A +GL_RGBA16F_ARB=0x881A +GL_RGBA16I=0x8D88 +GL_RGBA16I_EXT=0x8D88 +GL_RGBA16UI=0x8D76 +GL_RGBA16UI_EXT=0x8D76 +GL_RGBA16_EXT=0x805B +GL_RGBA2=0x8055 +GL_RGBA2_EXT=0x8055 +GL_RGBA32F=0x8814 +GL_RGBA32F_ARB=0x8814 +GL_RGBA32I=0x8D82 +GL_RGBA32I_EXT=0x8D82 +GL_RGBA32UI=0x8D70 +GL_RGBA32UI_EXT=0x8D70 +GL_RGBA4=0x8056 +GL_RGBA4_EXT=0x8056 +GL_RGBA4_S3TC=0x83A3 +GL_RGBA8=0x8058 +GL_RGBA8I=0x8D8E +GL_RGBA8I_EXT=0x8D8E +GL_RGBA8UI=0x8D7C +GL_RGBA8UI_EXT=0x8D7C +GL_RGBA8_EXT=0x8058 +GL_RGBA=0x1908 +GL_RGBA_FLOAT16_ATI=0x881A +GL_RGBA_FLOAT32_ATI=0x8814 +GL_RGBA_FLOAT_MODE_ARB=0x8820 +GL_RGBA_INTEGER=0x8D99 +GL_RGBA_INTEGER_EXT=0x8D99 +GL_RGBA_INTEGER_MODE_EXT=0x8D9E +GL_RGBA_MODE=0x0C31 +GL_RGBA_S3TC=0x83A2 +GL_RGBA_SIGNED_COMPONENTS_EXT=0x8C3C +GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV=0x86D9 +GL_RGB_FLOAT16_ATI=0x881B +GL_RGB_FLOAT32_ATI=0x8815 +GL_RGB_INTEGER=0x8D98 +GL_RGB_INTEGER_EXT=0x8D98 +GL_RGB_S3TC=0x83A0 +GL_RGB_SCALE=0x8573 +GL_RGB_SCALE_ARB=0x8573 +GL_RGB_SCALE_EXT=0x8573 +GL_RG_INTEGER=0x8228 +GL_RIGHT=0x0407 +GL_S3_s3tc=1 +GL_S=0x2000 +GL_SAMPLER_1D=0x8B5D +GL_SAMPLER_1D_ARB=0x8B5D +GL_SAMPLER_1D_ARRAY=0x8DC0 +GL_SAMPLER_1D_ARRAY_EXT=0x8DC0 +GL_SAMPLER_1D_ARRAY_SHADOW=0x8DC3 +GL_SAMPLER_1D_ARRAY_SHADOW_EXT=0x8DC3 +GL_SAMPLER_1D_SHADOW=0x8B61 +GL_SAMPLER_1D_SHADOW_ARB=0x8B61 +GL_SAMPLER_2D=0x8B5E +GL_SAMPLER_2D_ARB=0x8B5E +GL_SAMPLER_2D_ARRAY=0x8DC1 +GL_SAMPLER_2D_ARRAY_EXT=0x8DC1 +GL_SAMPLER_2D_ARRAY_SHADOW=0x8DC4 +GL_SAMPLER_2D_ARRAY_SHADOW_EXT=0x8DC4 +GL_SAMPLER_2D_RECT_ARB=0x8B63 +GL_SAMPLER_2D_RECT_SHADOW_ARB=0x8B64 +GL_SAMPLER_2D_SHADOW=0x8B62 +GL_SAMPLER_2D_SHADOW_ARB=0x8B62 +GL_SAMPLER_3D=0x8B5F +GL_SAMPLER_3D_ARB=0x8B5F +GL_SAMPLER_BUFFER_EXT=0x8DC2 +GL_SAMPLER_CUBE=0x8B60 +GL_SAMPLER_CUBE_ARB=0x8B60 +GL_SAMPLER_CUBE_SHADOW=0x8DC5 +GL_SAMPLER_CUBE_SHADOW_EXT=0x8DC5 +GL_SAMPLER_RENDERBUFFER_NV=0x8E56 +GL_SAMPLES=0x80A9 +GL_SAMPLES_3DFX=0x86B4 +GL_SAMPLES_ARB=0x80A9 +GL_SAMPLES_EXT=0x80A9 +GL_SAMPLES_PASSED=0x8914 +GL_SAMPLES_PASSED_ARB=0x8914 +GL_SAMPLES_SGIS=0x80A9 +GL_SAMPLE_ALPHA_TO_COVERAGE=0x809E +GL_SAMPLE_ALPHA_TO_COVERAGE_ARB=0x809E +GL_SAMPLE_ALPHA_TO_MASK_EXT=0x809E +GL_SAMPLE_ALPHA_TO_MASK_SGIS=0x809E +GL_SAMPLE_ALPHA_TO_ONE=0x809F +GL_SAMPLE_ALPHA_TO_ONE_ARB=0x809F +GL_SAMPLE_ALPHA_TO_ONE_EXT=0x809F +GL_SAMPLE_ALPHA_TO_ONE_SGIS=0x809F +GL_SAMPLE_BUFFERS=0x80A8 +GL_SAMPLE_BUFFERS_3DFX=0x86B3 +GL_SAMPLE_BUFFERS_ARB=0x80A8 +GL_SAMPLE_BUFFERS_EXT=0x80A8 +GL_SAMPLE_BUFFERS_SGIS=0x80A8 +GL_SAMPLE_COVERAGE=0x80A0 +GL_SAMPLE_COVERAGE_ARB=0x80A0 +GL_SAMPLE_COVERAGE_INVERT=0x80AB +GL_SAMPLE_COVERAGE_INVERT_ARB=0x80AB +GL_SAMPLE_COVERAGE_VALUE=0x80AA +GL_SAMPLE_COVERAGE_VALUE_ARB=0x80AA +GL_SAMPLE_MASK_EXT=0x80A0 +GL_SAMPLE_MASK_INVERT_EXT=0x80AB +GL_SAMPLE_MASK_INVERT_SGIS=0x80AB +GL_SAMPLE_MASK_NV=0x8E51 +GL_SAMPLE_MASK_SGIS=0x80A0 +GL_SAMPLE_MASK_VALUE_EXT=0x80AA +GL_SAMPLE_MASK_VALUE_NV=0x8E52 +GL_SAMPLE_MASK_VALUE_SGIS=0x80AA +GL_SAMPLE_PATTERN_EXT=0x80AC +GL_SAMPLE_PATTERN_SGIS=0x80AC +GL_SAMPLE_POSITION_NV=0x8E50 +GL_SATURATE_BIT_ATI=0x00000040 +GL_SCALAR_EXT=0x87BE +GL_SCALEBIAS_HINT_SGIX=0x8322 +GL_SCALE_BY_FOUR_NV=0x853F +GL_SCALE_BY_ONE_HALF_NV=0x8540 +GL_SCALE_BY_TWO_NV=0x853E +GL_SCISSOR_BIT=0x00080000 +GL_SCISSOR_BOX=0x0C10 +GL_SCISSOR_TEST=0x0C11 +GL_SCREEN_COORDINATES_REND=0x8490 +GL_SECONDARY_COLOR_ARRAY=0x845E +GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV=0x8F27 +GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING=0x889C +GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB=0x889C +GL_SECONDARY_COLOR_ARRAY_EXT=0x845E +GL_SECONDARY_COLOR_ARRAY_LENGTH_NV=0x8F31 +GL_SECONDARY_COLOR_ARRAY_LIST_IBM=103077 +GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM=103087 +GL_SECONDARY_COLOR_ARRAY_POINTER=0x845D +GL_SECONDARY_COLOR_ARRAY_POINTER_EXT=0x845D +GL_SECONDARY_COLOR_ARRAY_SIZE=0x845A +GL_SECONDARY_COLOR_ARRAY_SIZE_EXT=0x845A +GL_SECONDARY_COLOR_ARRAY_STRIDE=0x845C +GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT=0x845C +GL_SECONDARY_COLOR_ARRAY_TYPE=0x845B +GL_SECONDARY_COLOR_ARRAY_TYPE_EXT=0x845B +GL_SECONDARY_COLOR_NV=0x852D +GL_SECONDARY_INTERPOLATOR_ATI=0x896D +GL_SELECT=0x1C02 +GL_SELECTION_BUFFER_POINTER=0x0DF3 +GL_SELECTION_BUFFER_SIZE=0x0DF4 +GL_SEPARABLE_2D=0x8012 +GL_SEPARABLE_2D_EXT=0x8012 +GL_SEPARATE_ATTRIBS=0x8C8D +GL_SEPARATE_ATTRIBS_EXT=0x8C8D +GL_SEPARATE_ATTRIBS_NV=0x8C8D +GL_SEPARATE_SPECULAR_COLOR=0x81FA +GL_SEPARATE_SPECULAR_COLOR_EXT=0x81FA +GL_SET=0x150F +GL_SGIS_detail_texture=1 +GL_SGIS_fog_function=1 +GL_SGIS_generate_mipmap=1 +GL_SGIS_multisample=1 +GL_SGIS_pixel_texture=1 +GL_SGIS_point_line_texgen=1 +GL_SGIS_point_parameters=1 +GL_SGIS_sharpen_texture=1 +GL_SGIS_texture4D=1 +GL_SGIS_texture_border_clamp=1 +GL_SGIS_texture_color_mask=1 +GL_SGIS_texture_edge_clamp=1 +GL_SGIS_texture_filter4=1 +GL_SGIS_texture_lod=1 +GL_SGIX_async=1 +GL_SGIX_async_histogram=1 +GL_SGIX_async_pixel=1 +GL_SGIX_blend_alpha_minmax=1 +GL_SGIX_calligraphic_fragment=1 +GL_SGIX_clipmap=1 +GL_SGIX_convolution_accuracy=1 +GL_SGIX_depth_pass_instrument=1 +GL_SGIX_depth_texture=1 +GL_SGIX_flush_raster=1 +GL_SGIX_fog_offset=1 +GL_SGIX_fog_scale=1 +GL_SGIX_fragment_lighting=1 +GL_SGIX_framezoom=1 +GL_SGIX_igloo_interface=1 +GL_SGIX_instruments=1 +GL_SGIX_interlace=1 +GL_SGIX_ir_instrument1=1 +GL_SGIX_list_priority=1 +GL_SGIX_pixel_texture=1 +GL_SGIX_pixel_tiles=1 +GL_SGIX_polynomial_ffd=1 +GL_SGIX_reference_plane=1 +GL_SGIX_resample=1 +GL_SGIX_scalebias_hint=1 +GL_SGIX_shadow=1 +GL_SGIX_shadow_ambient=1 +GL_SGIX_sprite=1 +GL_SGIX_subsample=1 +GL_SGIX_tag_sample_buffer=1 +GL_SGIX_texture_add_env=1 +GL_SGIX_texture_coordinate_clamp=1 +GL_SGIX_texture_lod_bias=1 +GL_SGIX_texture_multi_buffer=1 +GL_SGIX_texture_scale_bias=1 +GL_SGIX_texture_select=1 +GL_SGIX_vertex_preclip=1 +GL_SGIX_ycrcb=1 +GL_SGIX_ycrcb_subsample=1 +GL_SGIX_ycrcba=1 +GL_SGI_color_table=1 +GL_SGI_texture_color_table=1 +GL_SHADER_CONSISTENT_NV=0x86DD +GL_SHADER_OBJECT_ARB=0x8B48 +GL_SHADER_OPERATION_NV=0x86DF +GL_SHADER_SOURCE_LENGTH=0x8B88 +GL_SHADER_TYPE=0x8B4F +GL_SHADE_MODEL=0x0B54 +GL_SHADING_LANGUAGE_VERSION=0x8B8C +GL_SHADING_LANGUAGE_VERSION_ARB=0x8B8C +GL_SHADOW_AMBIENT_SGIX=0x80BF +GL_SHADOW_ATTENUATION_EXT=0x834E +GL_SHARED_TEXTURE_PALETTE_EXT=0x81FB +GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS=0x80B0 +GL_SHININESS=0x1601 +GL_SHORT=0x1402 +GL_SIGNED_ALPHA8_NV=0x8706 +GL_SIGNED_ALPHA_NV=0x8705 +GL_SIGNED_HILO16_NV=0x86FA +GL_SIGNED_HILO8_NV=0x885F +GL_SIGNED_HILO_NV=0x86F9 +GL_SIGNED_IDENTITY_NV=0x853C +GL_SIGNED_INTENSITY8_NV=0x8708 +GL_SIGNED_INTENSITY_NV=0x8707 +GL_SIGNED_LUMINANCE8_ALPHA8_NV=0x8704 +GL_SIGNED_LUMINANCE8_NV=0x8702 +GL_SIGNED_LUMINANCE_ALPHA_NV=0x8703 +GL_SIGNED_LUMINANCE_NV=0x8701 +GL_SIGNED_NEGATE_NV=0x853D +GL_SIGNED_RGB8_NV=0x86FF +GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV=0x870D +GL_SIGNED_RGBA8_NV=0x86FC +GL_SIGNED_RGBA_NV=0x86FB +GL_SIGNED_RGB_NV=0x86FE +GL_SIGNED_RGB_UNSIGNED_ALPHA_NV=0x870C +GL_SINGLE_COLOR=0x81F9 +GL_SINGLE_COLOR_EXT=0x81F9 +GL_SLICE_ACCUM_SUN=0x85CC +GL_SLUMINANCE8=0x8C47 +GL_SLUMINANCE8_ALPHA8=0x8C45 +GL_SLUMINANCE=0x8C46 +GL_SLUMINANCE_ALPHA=0x8C44 +GL_SMOOTH=0x1D01 +GL_SMOOTH_LINE_WIDTH_GRANULARITY=0x0B23 +GL_SMOOTH_LINE_WIDTH_RANGE=0x0B22 +GL_SMOOTH_POINT_SIZE_GRANULARITY=0x0B13 +GL_SMOOTH_POINT_SIZE_RANGE=0x0B12 +GL_SOURCE0_ALPHA=0x8588 +GL_SOURCE0_ALPHA_ARB=0x8588 +GL_SOURCE0_ALPHA_EXT=0x8588 +GL_SOURCE0_RGB=0x8580 +GL_SOURCE0_RGB_ARB=0x8580 +GL_SOURCE0_RGB_EXT=0x8580 +GL_SOURCE1_ALPHA=0x8589 +GL_SOURCE1_ALPHA_ARB=0x8589 +GL_SOURCE1_ALPHA_EXT=0x8589 +GL_SOURCE1_RGB=0x8581 +GL_SOURCE1_RGB_ARB=0x8581 +GL_SOURCE1_RGB_EXT=0x8581 +GL_SOURCE2_ALPHA=0x858A +GL_SOURCE2_ALPHA_ARB=0x858A +GL_SOURCE2_ALPHA_EXT=0x858A +GL_SOURCE2_RGB=0x8582 +GL_SOURCE2_RGB_ARB=0x8582 +GL_SOURCE2_RGB_EXT=0x8582 +GL_SOURCE3_ALPHA_NV=0x858B +GL_SOURCE3_RGB_NV=0x8583 +GL_SPARE0_NV=0x852E +GL_SPARE0_PLUS_SECONDARY_COLOR_NV=0x8532 +GL_SPARE1_NV=0x852F +GL_SPECULAR=0x1202 +GL_SPHERE_MAP=0x2402 +GL_SPOT_CUTOFF=0x1206 +GL_SPOT_DIRECTION=0x1204 +GL_SPOT_EXPONENT=0x1205 +GL_SPRITE_AXIAL_SGIX=0x814C +GL_SPRITE_AXIS_SGIX=0x814A +GL_SPRITE_EYE_ALIGNED_SGIX=0x814E +GL_SPRITE_MODE_SGIX=0x8149 +GL_SPRITE_OBJECT_ALIGNED_SGIX=0x814D +GL_SPRITE_SGIX=0x8148 +GL_SPRITE_TRANSLATION_SGIX=0x814B +GL_SRC0_ALPHA=0x8588 +GL_SRC0_RGB=0x8580 +GL_SRC1_ALPHA=0x8589 +GL_SRC1_RGB=0x8581 +GL_SRC2_ALPHA=0x858A +GL_SRC2_RGB=0x8582 +GL_SRC_ALPHA=0x0302 +GL_SRC_ALPHA_SATURATE=0x0308 +GL_SRC_COLOR=0x0300 +GL_SRGB8=0x8C41 +GL_SRGB8_ALPHA8=0x8C43 +GL_SRGB=0x8C40 +GL_SRGB_ALPHA=0x8C42 +GL_STACK_OVERFLOW=0x0503 +GL_STACK_UNDERFLOW=0x0504 +GL_STATIC_ATI=0x8760 +GL_STATIC_COPY=0x88E6 +GL_STATIC_COPY_ARB=0x88E6 +GL_STATIC_DRAW=0x88E4 +GL_STATIC_DRAW_ARB=0x88E4 +GL_STATIC_READ=0x88E5 +GL_STATIC_READ_ARB=0x88E5 +GL_STENCIL=0x1802 +GL_STENCIL_ATTACHMENT=0x8D20 +GL_STENCIL_ATTACHMENT_EXT=0x8D20 +GL_STENCIL_BACK_FAIL=0x8801 +GL_STENCIL_BACK_FAIL_ATI=0x8801 +GL_STENCIL_BACK_FUNC=0x8800 +GL_STENCIL_BACK_FUNC_ATI=0x8800 +GL_STENCIL_BACK_PASS_DEPTH_FAIL=0x8802 +GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI=0x8802 +GL_STENCIL_BACK_PASS_DEPTH_PASS=0x8803 +GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI=0x8803 +GL_STENCIL_BACK_REF=0x8CA3 +GL_STENCIL_BACK_VALUE_MASK=0x8CA4 +GL_STENCIL_BACK_WRITEMASK=0x8CA5 +GL_STENCIL_BITS=0x0D57 +GL_STENCIL_BUFFER=0x8224 +GL_STENCIL_BUFFER_BIT=0x00000400 +GL_STENCIL_CLEAR_VALUE=0x0B91 +GL_STENCIL_FAIL=0x0B94 +GL_STENCIL_FUNC=0x0B92 +GL_STENCIL_INDEX16=0x8D49 +GL_STENCIL_INDEX16_EXT=0x8D49 +GL_STENCIL_INDEX1=0x8D46 +GL_STENCIL_INDEX1_EXT=0x8D46 +GL_STENCIL_INDEX4=0x8D47 +GL_STENCIL_INDEX4_EXT=0x8D47 +GL_STENCIL_INDEX8=0x8D48 +GL_STENCIL_INDEX8_EXT=0x8D48 +GL_STENCIL_INDEX=0x1901 +GL_STENCIL_INDEX_EXT=0x8D45 +GL_STENCIL_PASS_DEPTH_FAIL=0x0B95 +GL_STENCIL_PASS_DEPTH_PASS=0x0B96 +GL_STENCIL_REF=0x0B97 +GL_STENCIL_TEST=0x0B90 +GL_STENCIL_TEST_TWO_SIDE_EXT=0x8910 +GL_STENCIL_VALUE_MASK=0x0B93 +GL_STENCIL_WRITEMASK=0x0B98 +GL_STEREO=0x0C33 +GL_STORAGE_CACHED_APPLE=0x85BE +GL_STORAGE_SHARED_APPLE=0x85BF +GL_STREAM_COPY=0x88E2 +GL_STREAM_COPY_ARB=0x88E2 +GL_STREAM_DRAW=0x88E0 +GL_STREAM_DRAW_ARB=0x88E0 +GL_STREAM_READ=0x88E1 +GL_STREAM_READ_ARB=0x88E1 +GL_STRICT_DEPTHFUNC_HINT_PGI=0x1A216 +GL_STRICT_LIGHTING_HINT_PGI=0x1A217 +GL_STRICT_SCISSOR_HINT_PGI=0x1A218 +GL_SUBPIXEL_BITS=0x0D50 +GL_SUBTRACT=0x84E7 +GL_SUBTRACT_ARB=0x84E7 +GL_SUB_ATI=0x8965 +GL_SUNX_constant_data=1 +GL_SUN_convolution_border_modes=1 +GL_SUN_global_alpha=1 +GL_SUN_mesh_array=1 +GL_SUN_slice_accum=1 +GL_SUN_triangle_list=1 +GL_SUN_vertex=1 +GL_SWIZZLE_STQ_ATI=0x8977 +GL_SWIZZLE_STQ_DQ_ATI=0x8979 +GL_SWIZZLE_STRQ_ATI=0x897A +GL_SWIZZLE_STRQ_DQ_ATI=0x897B +GL_SWIZZLE_STR_ATI=0x8976 +GL_SWIZZLE_STR_DR_ATI=0x8978 +GL_T2F_C3F_V3F=0x2A2A +GL_T2F_C4F_N3F_V3F=0x2A2C +GL_T2F_C4UB_V3F=0x2A29 +GL_T2F_IUI_N3F_V2F_EXT=0x81B3 +GL_T2F_IUI_N3F_V3F_EXT=0x81B4 +GL_T2F_IUI_V2F_EXT=0x81B1 +GL_T2F_IUI_V3F_EXT=0x81B2 +GL_T2F_N3F_V3F=0x2A2B +GL_T2F_V3F=0x2A27 +GL_T4F_C4F_N3F_V4F=0x2A2D +GL_T4F_V4F=0x2A28 +GL_T=0x2001 +GL_TABLE_TOO_LARGE=0x8031 +GL_TABLE_TOO_LARGE_EXT=0x8031 +GL_TANGENT_ARRAY_EXT=0x8439 +GL_TANGENT_ARRAY_POINTER_EXT=0x8442 +GL_TANGENT_ARRAY_STRIDE_EXT=0x843F +GL_TANGENT_ARRAY_TYPE_EXT=0x843E +GL_TEXCOORD1_BIT_PGI=0x10000000 +GL_TEXCOORD2_BIT_PGI=0x20000000 +GL_TEXCOORD3_BIT_PGI=0x40000000 +GL_TEXCOORD4_BIT_PGI=0x80000000 +GL_TEXTURE0=0x84C0 +GL_TEXTURE0_ARB=0x84C0 +GL_TEXTURE10=0x84CA +GL_TEXTURE10_ARB=0x84CA +GL_TEXTURE11=0x84CB +GL_TEXTURE11_ARB=0x84CB +GL_TEXTURE12=0x84CC +GL_TEXTURE12_ARB=0x84CC +GL_TEXTURE13=0x84CD +GL_TEXTURE13_ARB=0x84CD +GL_TEXTURE14=0x84CE +GL_TEXTURE14_ARB=0x84CE +GL_TEXTURE15=0x84CF +GL_TEXTURE15_ARB=0x84CF +GL_TEXTURE16=0x84D0 +GL_TEXTURE16_ARB=0x84D0 +GL_TEXTURE17=0x84D1 +GL_TEXTURE17_ARB=0x84D1 +GL_TEXTURE18=0x84D2 +GL_TEXTURE18_ARB=0x84D2 +GL_TEXTURE19=0x84D3 +GL_TEXTURE19_ARB=0x84D3 +GL_TEXTURE1=0x84C1 +GL_TEXTURE1_ARB=0x84C1 +GL_TEXTURE20=0x84D4 +GL_TEXTURE20_ARB=0x84D4 +GL_TEXTURE21=0x84D5 +GL_TEXTURE21_ARB=0x84D5 +GL_TEXTURE22=0x84D6 +GL_TEXTURE22_ARB=0x84D6 +GL_TEXTURE23=0x84D7 +GL_TEXTURE23_ARB=0x84D7 +GL_TEXTURE24=0x84D8 +GL_TEXTURE24_ARB=0x84D8 +GL_TEXTURE25=0x84D9 +GL_TEXTURE25_ARB=0x84D9 +GL_TEXTURE26=0x84DA +GL_TEXTURE26_ARB=0x84DA +GL_TEXTURE27=0x84DB +GL_TEXTURE27_ARB=0x84DB +GL_TEXTURE28=0x84DC +GL_TEXTURE28_ARB=0x84DC +GL_TEXTURE29=0x84DD +GL_TEXTURE29_ARB=0x84DD +GL_TEXTURE2=0x84C2 +GL_TEXTURE2_ARB=0x84C2 +GL_TEXTURE30=0x84DE +GL_TEXTURE30_ARB=0x84DE +GL_TEXTURE31=0x84DF +GL_TEXTURE31_ARB=0x84DF +GL_TEXTURE3=0x84C3 +GL_TEXTURE3_ARB=0x84C3 +GL_TEXTURE4=0x84C4 +GL_TEXTURE4_ARB=0x84C4 +GL_TEXTURE5=0x84C5 +GL_TEXTURE5_ARB=0x84C5 +GL_TEXTURE6=0x84C6 +GL_TEXTURE6_ARB=0x84C6 +GL_TEXTURE7=0x84C7 +GL_TEXTURE7_ARB=0x84C7 +GL_TEXTURE8=0x84C8 +GL_TEXTURE8_ARB=0x84C8 +GL_TEXTURE9=0x84C9 +GL_TEXTURE9_ARB=0x84C9 +GL_TEXTURE=0x1702 +GL_TEXTURE_1D=0x0DE0 +GL_TEXTURE_1D_ARRAY=0x8C18 +GL_TEXTURE_1D_ARRAY_EXT=0x8C18 +GL_TEXTURE_1D_BINDING_EXT=0x8068 +GL_TEXTURE_2D=0x0DE1 +GL_TEXTURE_2D_ARRAY=0x8C1A +GL_TEXTURE_2D_ARRAY_EXT=0x8C1A +GL_TEXTURE_2D_BINDING_EXT=0x8069 +GL_TEXTURE_3D=0x806F +GL_TEXTURE_3D_BINDING_EXT=0x806A +GL_TEXTURE_3D_EXT=0x806F +GL_TEXTURE_4DSIZE_SGIS=0x8136 +GL_TEXTURE_4D_BINDING_SGIS=0x814F +GL_TEXTURE_4D_SGIS=0x8134 +GL_TEXTURE_ALPHA_SIZE=0x805F +GL_TEXTURE_ALPHA_SIZE_EXT=0x805F +GL_TEXTURE_ALPHA_TYPE=0x8C13 +GL_TEXTURE_ALPHA_TYPE_ARB=0x8C13 +GL_TEXTURE_APPLICATION_MODE_EXT=0x834F +GL_TEXTURE_BASE_LEVEL=0x813C +GL_TEXTURE_BASE_LEVEL_SGIS=0x813C +GL_TEXTURE_BINDING_1D=0x8068 +GL_TEXTURE_BINDING_1D_ARRAY=0x8C1C +GL_TEXTURE_BINDING_1D_ARRAY_EXT=0x8C1C +GL_TEXTURE_BINDING_2D=0x8069 +GL_TEXTURE_BINDING_2D_ARRAY=0x8C1D +GL_TEXTURE_BINDING_2D_ARRAY_EXT=0x8C1D +GL_TEXTURE_BINDING_3D=0x806A +GL_TEXTURE_BINDING_BUFFER_ARB=0x8C2C +GL_TEXTURE_BINDING_BUFFER_EXT=0x8C2C +GL_TEXTURE_BINDING_CUBE_MAP=0x8514 +GL_TEXTURE_BINDING_CUBE_MAP_ARB=0x8514 +GL_TEXTURE_BINDING_CUBE_MAP_EXT=0x8514 +GL_TEXTURE_BINDING_RECTANGLE_ARB=0x84F6 +GL_TEXTURE_BINDING_RECTANGLE_NV=0x84F6 +GL_TEXTURE_BINDING_RENDERBUFFER_NV=0x8E53 +GL_TEXTURE_BIT=0x00040000 +GL_TEXTURE_BLUE_SIZE=0x805E +GL_TEXTURE_BLUE_SIZE_EXT=0x805E +GL_TEXTURE_BLUE_TYPE=0x8C12 +GL_TEXTURE_BLUE_TYPE_ARB=0x8C12 +GL_TEXTURE_BORDER=0x1005 +GL_TEXTURE_BORDER_COLOR=0x1004 +GL_TEXTURE_BORDER_VALUES_NV=0x871A +GL_TEXTURE_BUFFER_ARB=0x8C2A +GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB=0x8C2D +GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT=0x8C2D +GL_TEXTURE_BUFFER_EXT=0x8C2A +GL_TEXTURE_BUFFER_FORMAT_ARB=0x8C2E +GL_TEXTURE_BUFFER_FORMAT_EXT=0x8C2E +GL_TEXTURE_CLIPMAP_CENTER_SGIX=0x8171 +GL_TEXTURE_CLIPMAP_DEPTH_SGIX=0x8176 +GL_TEXTURE_CLIPMAP_FRAME_SGIX=0x8172 +GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX=0x8175 +GL_TEXTURE_CLIPMAP_OFFSET_SGIX=0x8173 +GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX=0x8174 +GL_TEXTURE_COLOR_TABLE_SGI=0x80BC +GL_TEXTURE_COLOR_WRITEMASK_SGIS=0x81EF +GL_TEXTURE_COMPARE_FAIL_VALUE_ARB=0x80BF +GL_TEXTURE_COMPARE_FUNC=0x884D +GL_TEXTURE_COMPARE_FUNC_ARB=0x884D +GL_TEXTURE_COMPARE_MODE=0x884C +GL_TEXTURE_COMPARE_MODE_ARB=0x884C +GL_TEXTURE_COMPARE_OPERATOR_SGIX=0x819B +GL_TEXTURE_COMPARE_SGIX=0x819A +GL_TEXTURE_COMPONENTS=0x1003 +GL_TEXTURE_COMPRESSED=0x86A1 +GL_TEXTURE_COMPRESSED_ARB=0x86A1 +GL_TEXTURE_COMPRESSED_IMAGE_SIZE=0x86A0 +GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB=0x86A0 +GL_TEXTURE_COMPRESSION_HINT=0x84EF +GL_TEXTURE_COMPRESSION_HINT_ARB=0x84EF +GL_TEXTURE_CONSTANT_DATA_SUNX=0x81D6 +GL_TEXTURE_COORD_ARRAY=0x8078 +GL_TEXTURE_COORD_ARRAY_ADDRESS_NV=0x8F25 +GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING=0x889A +GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB=0x889A +GL_TEXTURE_COORD_ARRAY_COUNT_EXT=0x808B +GL_TEXTURE_COORD_ARRAY_EXT=0x8078 +GL_TEXTURE_COORD_ARRAY_LENGTH_NV=0x8F2F +GL_TEXTURE_COORD_ARRAY_LIST_IBM=103074 +GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM=103084 +GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL=0x83F8 +GL_TEXTURE_COORD_ARRAY_POINTER=0x8092 +GL_TEXTURE_COORD_ARRAY_POINTER_EXT=0x8092 +GL_TEXTURE_COORD_ARRAY_SIZE=0x8088 +GL_TEXTURE_COORD_ARRAY_SIZE_EXT=0x8088 +GL_TEXTURE_COORD_ARRAY_STRIDE=0x808A +GL_TEXTURE_COORD_ARRAY_STRIDE_EXT=0x808A +GL_TEXTURE_COORD_ARRAY_TYPE=0x8089 +GL_TEXTURE_COORD_ARRAY_TYPE_EXT=0x8089 +GL_TEXTURE_COORD_NV=0x8C79 +GL_TEXTURE_CUBE_MAP=0x8513 +GL_TEXTURE_CUBE_MAP_ARB=0x8513 +GL_TEXTURE_CUBE_MAP_EXT=0x8513 +GL_TEXTURE_CUBE_MAP_NEGATIVE_X=0x8516 +GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB=0x8516 +GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT=0x8516 +GL_TEXTURE_CUBE_MAP_NEGATIVE_Y=0x8518 +GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB=0x8518 +GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT=0x8518 +GL_TEXTURE_CUBE_MAP_NEGATIVE_Z=0x851A +GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB=0x851A +GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT=0x851A +GL_TEXTURE_CUBE_MAP_POSITIVE_X=0x8515 +GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB=0x8515 +GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT=0x8515 +GL_TEXTURE_CUBE_MAP_POSITIVE_Y=0x8517 +GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB=0x8517 +GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT=0x8517 +GL_TEXTURE_CUBE_MAP_POSITIVE_Z=0x8519 +GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB=0x8519 +GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT=0x8519 +GL_TEXTURE_DEFORMATION_BIT_SGIX=0x00000001 +GL_TEXTURE_DEFORMATION_SGIX=0x8195 +GL_TEXTURE_DEPTH=0x8071 +GL_TEXTURE_DEPTH_EXT=0x8071 +GL_TEXTURE_DEPTH_SIZE=0x884A +GL_TEXTURE_DEPTH_SIZE_ARB=0x884A +GL_TEXTURE_DEPTH_TYPE=0x8C16 +GL_TEXTURE_DEPTH_TYPE_ARB=0x8C16 +GL_TEXTURE_DS_SIZE_NV=0x871D +GL_TEXTURE_DT_SIZE_NV=0x871E +GL_TEXTURE_ENV=0x2300 +GL_TEXTURE_ENV_BIAS_SGIX=0x80BE +GL_TEXTURE_ENV_COLOR=0x2201 +GL_TEXTURE_ENV_MODE=0x2200 +GL_TEXTURE_FILTER4_SIZE_SGIS=0x8147 +GL_TEXTURE_FILTER_CONTROL=0x8500 +GL_TEXTURE_FILTER_CONTROL_EXT=0x8500 +GL_TEXTURE_FLOAT_COMPONENTS_NV=0x888C +GL_TEXTURE_GEN_MODE=0x2500 +GL_TEXTURE_GEN_Q=0x0C63 +GL_TEXTURE_GEN_R=0x0C62 +GL_TEXTURE_GEN_S=0x0C60 +GL_TEXTURE_GEN_T=0x0C61 +GL_TEXTURE_GEQUAL_R_SGIX=0x819D +GL_TEXTURE_GREEN_SIZE=0x805D +GL_TEXTURE_GREEN_SIZE_EXT=0x805D +GL_TEXTURE_GREEN_TYPE=0x8C11 +GL_TEXTURE_GREEN_TYPE_ARB=0x8C11 +GL_TEXTURE_HEIGHT=0x1001 +GL_TEXTURE_HI_SIZE_NV=0x871B +GL_TEXTURE_INDEX_SIZE_EXT=0x80ED +GL_TEXTURE_INTENSITY_SIZE=0x8061 +GL_TEXTURE_INTENSITY_SIZE_EXT=0x8061 +GL_TEXTURE_INTENSITY_TYPE=0x8C15 +GL_TEXTURE_INTENSITY_TYPE_ARB=0x8C15 +GL_TEXTURE_INTERNAL_FORMAT=0x1003 +GL_TEXTURE_LEQUAL_R_SGIX=0x819C +GL_TEXTURE_LIGHTING_MODE_HP=0x8167 +GL_TEXTURE_LIGHT_EXT=0x8350 +GL_TEXTURE_LOD_BIAS=0x8501 +GL_TEXTURE_LOD_BIAS_EXT=0x8501 +GL_TEXTURE_LOD_BIAS_R_SGIX=0x8190 +GL_TEXTURE_LOD_BIAS_S_SGIX=0x818E +GL_TEXTURE_LOD_BIAS_T_SGIX=0x818F +GL_TEXTURE_LO_SIZE_NV=0x871C +GL_TEXTURE_LUMINANCE_SIZE=0x8060 +GL_TEXTURE_LUMINANCE_SIZE_EXT=0x8060 +GL_TEXTURE_LUMINANCE_TYPE=0x8C14 +GL_TEXTURE_LUMINANCE_TYPE_ARB=0x8C14 +GL_TEXTURE_MAG_FILTER=0x2800 +GL_TEXTURE_MAG_SIZE_NV=0x871F +GL_TEXTURE_MATERIAL_FACE_EXT=0x8351 +GL_TEXTURE_MATERIAL_PARAMETER_EXT=0x8352 +GL_TEXTURE_MATRIX=0x0BA8 +GL_TEXTURE_MAX_ANISOTROPY_EXT=0x84FE +GL_TEXTURE_MAX_CLAMP_R_SGIX=0x836B +GL_TEXTURE_MAX_CLAMP_S_SGIX=0x8369 +GL_TEXTURE_MAX_CLAMP_T_SGIX=0x836A +GL_TEXTURE_MAX_LEVEL=0x813D +GL_TEXTURE_MAX_LEVEL_SGIS=0x813D +GL_TEXTURE_MAX_LOD=0x813B +GL_TEXTURE_MAX_LOD_SGIS=0x813B +GL_TEXTURE_MIN_FILTER=0x2801 +GL_TEXTURE_MIN_LOD=0x813A +GL_TEXTURE_MIN_LOD_SGIS=0x813A +GL_TEXTURE_MULTI_BUFFER_HINT_SGIX=0x812E +GL_TEXTURE_NORMAL_EXT=0x85AF +GL_TEXTURE_POST_SPECULAR_HP=0x8168 +GL_TEXTURE_PRE_SPECULAR_HP=0x8169 +GL_TEXTURE_PRIORITY=0x8066 +GL_TEXTURE_PRIORITY_EXT=0x8066 +GL_TEXTURE_RECTANGLE_ARB=0x84F5 +GL_TEXTURE_RECTANGLE_NV=0x84F5 +GL_TEXTURE_RED_SIZE=0x805C +GL_TEXTURE_RED_SIZE_EXT=0x805C +GL_TEXTURE_RED_TYPE=0x8C10 +GL_TEXTURE_RED_TYPE_ARB=0x8C10 +GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV=0x8E54 +GL_TEXTURE_RENDERBUFFER_NV=0x8E55 +GL_TEXTURE_RESIDENT=0x8067 +GL_TEXTURE_RESIDENT_EXT=0x8067 +GL_TEXTURE_SHADER_NV=0x86DE +GL_TEXTURE_SHARED_SIZE=0x8C3F +GL_TEXTURE_SHARED_SIZE_EXT=0x8C3F +GL_TEXTURE_STACK_DEPTH=0x0BA5 +GL_TEXTURE_STENCIL_SIZE=0x88F1 +GL_TEXTURE_STENCIL_SIZE_EXT=0x88F1 +GL_TEXTURE_SWIZZLE_A_EXT=0x8E45 +GL_TEXTURE_SWIZZLE_B_EXT=0x8E44 +GL_TEXTURE_SWIZZLE_G_EXT=0x8E43 +GL_TEXTURE_SWIZZLE_RGBA_EXT=0x8E46 +GL_TEXTURE_SWIZZLE_R_EXT=0x8E42 +GL_TEXTURE_TOO_LARGE_EXT=0x8065 +GL_TEXTURE_UNSIGNED_REMAP_MODE_NV=0x888F +GL_TEXTURE_WIDTH=0x1000 +GL_TEXTURE_WRAP_Q_SGIS=0x8137 +GL_TEXTURE_WRAP_R=0x8072 +GL_TEXTURE_WRAP_R_EXT=0x8072 +GL_TEXTURE_WRAP_S=0x2802 +GL_TEXTURE_WRAP_T=0x2803 +GL_TEXT_FRAGMENT_SHADER_ATI=0x8200 +GL_TIME_ELAPSED_EXT=0x88BF +GL_TRACK_MATRIX_NV=0x8648 +GL_TRACK_MATRIX_TRANSFORM_NV=0x8649 +GL_TRANSFORM_BIT=0x00001000 +GL_TRANSFORM_FEEDBACK_ATTRIBS_NV=0x8C7E +GL_TRANSFORM_FEEDBACK_BINDING_NV=0x8E25 +GL_TRANSFORM_FEEDBACK_BUFFER=0x8C8E +GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV=0x8E24 +GL_TRANSFORM_FEEDBACK_BUFFER_BINDING=0x8C8F +GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT=0x8C8F +GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV=0x8C8F +GL_TRANSFORM_FEEDBACK_BUFFER_EXT=0x8C8E +GL_TRANSFORM_FEEDBACK_BUFFER_MODE=0x8C7F +GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT=0x8C7F +GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV=0x8C7F +GL_TRANSFORM_FEEDBACK_BUFFER_NV=0x8C8E +GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV=0x8E23 +GL_TRANSFORM_FEEDBACK_BUFFER_SIZE=0x8C85 +GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT=0x8C85 +GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV=0x8C85 +GL_TRANSFORM_FEEDBACK_BUFFER_START=0x8C84 +GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT=0x8C84 +GL_TRANSFORM_FEEDBACK_BUFFER_START_NV=0x8C84 +GL_TRANSFORM_FEEDBACK_NV=0x8E22 +GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN=0x8C88 +GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT=0x8C88 +GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV=0x8C88 +GL_TRANSFORM_FEEDBACK_RECORD_NV=0x8C86 +GL_TRANSFORM_FEEDBACK_VARYINGS=0x8C83 +GL_TRANSFORM_FEEDBACK_VARYINGS_EXT=0x8C83 +GL_TRANSFORM_FEEDBACK_VARYINGS_NV=0x8C83 +GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH=0x8C76 +GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT=0x8C76 +GL_TRANSFORM_HINT_APPLE=0x85B1 +GL_TRANSPOSE_COLOR_MATRIX=0x84E6 +GL_TRANSPOSE_COLOR_MATRIX_ARB=0x84E6 +GL_TRANSPOSE_CURRENT_MATRIX_ARB=0x88B7 +GL_TRANSPOSE_MODELVIEW_MATRIX=0x84E3 +GL_TRANSPOSE_MODELVIEW_MATRIX_ARB=0x84E3 +GL_TRANSPOSE_NV=0x862C +GL_TRANSPOSE_PROGRAM_MATRIX_EXT=0x8E2E +GL_TRANSPOSE_PROJECTION_MATRIX=0x84E4 +GL_TRANSPOSE_PROJECTION_MATRIX_ARB=0x84E4 +GL_TRANSPOSE_TEXTURE_MATRIX=0x84E5 +GL_TRANSPOSE_TEXTURE_MATRIX_ARB=0x84E5 +GL_TRIANGLES=0x0004 +GL_TRIANGLES_ADJACENCY_ARB=0x000C +GL_TRIANGLES_ADJACENCY_EXT=0xC +GL_TRIANGLE_FAN=0x0006 +GL_TRIANGLE_LIST_SUN=0x81D7 +GL_TRIANGLE_MESH_SUN=0x8615 +GL_TRIANGLE_STRIP=0x0005 +GL_TRIANGLE_STRIP_ADJACENCY_ARB=0x000D +GL_TRIANGLE_STRIP_ADJACENCY_EXT=0xD +GL_TRUE=1 +GL_TYPE_RGBA_FLOAT_ATI=0x8820 +GL_UNIFORM_BUFFER_BINDING_EXT=0x8DEF +GL_UNIFORM_BUFFER_EXT=0x8DEE +GL_UNPACK_ALIGNMENT=0x0CF5 +GL_UNPACK_CLIENT_STORAGE_APPLE=0x85B2 +GL_UNPACK_CMYK_HINT_EXT=0x800F +GL_UNPACK_CONSTANT_DATA_SUNX=0x81D5 +GL_UNPACK_IMAGE_DEPTH_SGIS=0x8133 +GL_UNPACK_IMAGE_HEIGHT=0x806E +GL_UNPACK_IMAGE_HEIGHT_EXT=0x806E +GL_UNPACK_LSB_FIRST=0x0CF1 +GL_UNPACK_RESAMPLE_OML=0x8985 +GL_UNPACK_RESAMPLE_SGIX=0x842D +GL_UNPACK_ROW_LENGTH=0x0CF2 +GL_UNPACK_SKIP_IMAGES=0x806D +GL_UNPACK_SKIP_IMAGES_EXT=0x806D +GL_UNPACK_SKIP_PIXELS=0x0CF4 +GL_UNPACK_SKIP_ROWS=0x0CF3 +GL_UNPACK_SKIP_VOLUMES_SGIS=0x8132 +GL_UNPACK_SUBSAMPLE_RATE_SGIX=0x85A1 +GL_UNPACK_SWAP_BYTES=0x0CF0 +GL_UNSIGNED_BYTE=0x1401 +GL_UNSIGNED_BYTE_2_3_3_REV=0x8362 +GL_UNSIGNED_BYTE_3_3_2=0x8032 +GL_UNSIGNED_BYTE_3_3_2_EXT=0x8032 +GL_UNSIGNED_IDENTITY_NV=0x8536 +GL_UNSIGNED_INT=0x1405 +GL_UNSIGNED_INT_10F_11F_11F_REV=0x8C3B +GL_UNSIGNED_INT_10F_11F_11F_REV_EXT=0x8C3B +GL_UNSIGNED_INT_10_10_10_2=0x8036 +GL_UNSIGNED_INT_10_10_10_2_EXT=0x8036 +GL_UNSIGNED_INT_24_8=0x84FA +GL_UNSIGNED_INT_24_8_EXT=0x84FA +GL_UNSIGNED_INT_24_8_NV=0x84FA +GL_UNSIGNED_INT_2_10_10_10_REV=0x8368 +GL_UNSIGNED_INT_5_9_9_9_REV=0x8C3E +GL_UNSIGNED_INT_5_9_9_9_REV_EXT=0x8C3E +GL_UNSIGNED_INT_8_8_8_8=0x8035 +GL_UNSIGNED_INT_8_8_8_8_EXT=0x8035 +GL_UNSIGNED_INT_8_8_8_8_REV=0x8367 +GL_UNSIGNED_INT_8_8_S8_S8_REV_NV=0x86DB +GL_UNSIGNED_INT_S8_S8_8_8_NV=0x86DA +GL_UNSIGNED_INT_SAMPLER_1D=0x8DD1 +GL_UNSIGNED_INT_SAMPLER_1D_ARRAY=0x8DD6 +GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT=0x8DD6 +GL_UNSIGNED_INT_SAMPLER_1D_EXT=0x8DD1 +GL_UNSIGNED_INT_SAMPLER_2D=0x8DD2 +GL_UNSIGNED_INT_SAMPLER_2D_ARRAY=0x8DD7 +GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT=0x8DD7 +GL_UNSIGNED_INT_SAMPLER_2D_EXT=0x8DD2 +GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT=0x8DD5 +GL_UNSIGNED_INT_SAMPLER_3D=0x8DD3 +GL_UNSIGNED_INT_SAMPLER_3D_EXT=0x8DD3 +GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT=0x8DD8 +GL_UNSIGNED_INT_SAMPLER_CUBE=0x8DD4 +GL_UNSIGNED_INT_SAMPLER_CUBE_EXT=0x8DD4 +GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV=0x8E58 +GL_UNSIGNED_INT_VEC2=0x8DC6 +GL_UNSIGNED_INT_VEC2_EXT=0x8DC6 +GL_UNSIGNED_INT_VEC3=0x8DC7 +GL_UNSIGNED_INT_VEC3_EXT=0x8DC7 +GL_UNSIGNED_INT_VEC4=0x8DC8 +GL_UNSIGNED_INT_VEC4_EXT=0x8DC8 +GL_UNSIGNED_INVERT_NV=0x8537 +GL_UNSIGNED_NORMALIZED=0x8C17 +GL_UNSIGNED_NORMALIZED_ARB=0x8C17 +GL_UNSIGNED_SHORT=0x1403 +GL_UNSIGNED_SHORT_1_5_5_5_REV=0x8366 +GL_UNSIGNED_SHORT_4_4_4_4=0x8033 +GL_UNSIGNED_SHORT_4_4_4_4_EXT=0x8033 +GL_UNSIGNED_SHORT_4_4_4_4_REV=0x8365 +GL_UNSIGNED_SHORT_5_5_5_1=0x8034 +GL_UNSIGNED_SHORT_5_5_5_1_EXT=0x8034 +GL_UNSIGNED_SHORT_5_6_5=0x8363 +GL_UNSIGNED_SHORT_5_6_5_REV=0x8364 +GL_UNSIGNED_SHORT_8_8_APPLE=0x85BA +GL_UNSIGNED_SHORT_8_8_MESA=0x85BA +GL_UNSIGNED_SHORT_8_8_REV_APPLE=0x85BB +GL_UNSIGNED_SHORT_8_8_REV_MESA=0x85BB +GL_UPPER_LEFT=0x8CA2 +GL_V2F=0x2A20 +GL_V3F=0x2A21 +GL_VALIDATE_STATUS=0x8B83 +GL_VARIABLE_A_NV=0x8523 +GL_VARIABLE_B_NV=0x8524 +GL_VARIABLE_C_NV=0x8525 +GL_VARIABLE_D_NV=0x8526 +GL_VARIABLE_E_NV=0x8527 +GL_VARIABLE_F_NV=0x8528 +GL_VARIABLE_G_NV=0x8529 +GL_VARIANT_ARRAY_EXT=0x87E8 +GL_VARIANT_ARRAY_POINTER_EXT=0x87E9 +GL_VARIANT_ARRAY_STRIDE_EXT=0x87E6 +GL_VARIANT_ARRAY_TYPE_EXT=0x87E7 +GL_VARIANT_DATATYPE_EXT=0x87E5 +GL_VARIANT_EXT=0x87C1 +GL_VARIANT_VALUE_EXT=0x87E4 +GL_VECTOR_EXT=0x87BF +GL_VENDOR=0x1F00 +GL_VERSION=0x1F02 +GL_VERSION_1_1=1 +GL_VERSION_1_2=1 +GL_VERSION_1_3=1 +GL_VERSION_1_4=1 +GL_VERSION_1_5=1 +GL_VERSION_2_0=1 +GL_VERSION_2_1=1 +GL_VERSION_3_0=1 +GL_VERTEX23_BIT_PGI=0x00000004 +GL_VERTEX4_BIT_PGI=0x00000008 +GL_VERTEX_ARRAY=0x8074 +GL_VERTEX_ARRAY_ADDRESS_NV=0x8F21 +GL_VERTEX_ARRAY_BINDING=0x85B5 +GL_VERTEX_ARRAY_BINDING_APPLE=0x85B5 +GL_VERTEX_ARRAY_BUFFER_BINDING=0x8896 +GL_VERTEX_ARRAY_BUFFER_BINDING_ARB=0x8896 +GL_VERTEX_ARRAY_COUNT_EXT=0x807D +GL_VERTEX_ARRAY_EXT=0x8074 +GL_VERTEX_ARRAY_LENGTH_NV=0x8F2B +GL_VERTEX_ARRAY_LIST_IBM=103070 +GL_VERTEX_ARRAY_LIST_STRIDE_IBM=103080 +GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL=0x83F5 +GL_VERTEX_ARRAY_POINTER=0x808E +GL_VERTEX_ARRAY_POINTER_EXT=0x808E +GL_VERTEX_ARRAY_RANGE_APPLE=0x851D +GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE=0x851E +GL_VERTEX_ARRAY_RANGE_LENGTH_NV=0x851E +GL_VERTEX_ARRAY_RANGE_NV=0x851D +GL_VERTEX_ARRAY_RANGE_POINTER_APPLE=0x8521 +GL_VERTEX_ARRAY_RANGE_POINTER_NV=0x8521 +GL_VERTEX_ARRAY_RANGE_VALID_NV=0x851F +GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV=0x8533 +GL_VERTEX_ARRAY_SIZE=0x807A +GL_VERTEX_ARRAY_SIZE_EXT=0x807A +GL_VERTEX_ARRAY_STORAGE_HINT_APPLE=0x851F +GL_VERTEX_ARRAY_STRIDE=0x807C +GL_VERTEX_ARRAY_STRIDE_EXT=0x807C +GL_VERTEX_ARRAY_TYPE=0x807B +GL_VERTEX_ARRAY_TYPE_EXT=0x807B +GL_VERTEX_ATTRIB_ARRAY0_NV=0x8650 +GL_VERTEX_ATTRIB_ARRAY10_NV=0x865A +GL_VERTEX_ATTRIB_ARRAY11_NV=0x865B +GL_VERTEX_ATTRIB_ARRAY12_NV=0x865C +GL_VERTEX_ATTRIB_ARRAY13_NV=0x865D +GL_VERTEX_ATTRIB_ARRAY14_NV=0x865E +GL_VERTEX_ATTRIB_ARRAY15_NV=0x865F +GL_VERTEX_ATTRIB_ARRAY1_NV=0x8651 +GL_VERTEX_ATTRIB_ARRAY2_NV=0x8652 +GL_VERTEX_ATTRIB_ARRAY3_NV=0x8653 +GL_VERTEX_ATTRIB_ARRAY4_NV=0x8654 +GL_VERTEX_ATTRIB_ARRAY5_NV=0x8655 +GL_VERTEX_ATTRIB_ARRAY6_NV=0x8656 +GL_VERTEX_ATTRIB_ARRAY7_NV=0x8657 +GL_VERTEX_ATTRIB_ARRAY8_NV=0x8658 +GL_VERTEX_ATTRIB_ARRAY9_NV=0x8659 +GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV=0x8F20 +GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING=0x889F +GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB=0x889F +GL_VERTEX_ATTRIB_ARRAY_ENABLED=0x8622 +GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB=0x8622 +GL_VERTEX_ATTRIB_ARRAY_INTEGER=0x88FD +GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT=0x88FD +GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV=0x8F2A +GL_VERTEX_ATTRIB_ARRAY_NORMALIZED=0x886A +GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB=0x886A +GL_VERTEX_ATTRIB_ARRAY_POINTER=0x8645 +GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB=0x8645 +GL_VERTEX_ATTRIB_ARRAY_SIZE=0x8623 +GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB=0x8623 +GL_VERTEX_ATTRIB_ARRAY_STRIDE=0x8624 +GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB=0x8624 +GL_VERTEX_ATTRIB_ARRAY_TYPE=0x8625 +GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB=0x8625 +GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV=0x8F1E +GL_VERTEX_BLEND_ARB=0x86A7 +GL_VERTEX_CONSISTENT_HINT_PGI=0x1A22B +GL_VERTEX_DATA_HINT_PGI=0x1A22A +GL_VERTEX_ID_NV=0x8C7B +GL_VERTEX_PRECLIP_HINT_SGIX=0x83EF +GL_VERTEX_PRECLIP_SGIX=0x83EE +GL_VERTEX_PROGRAM_ARB=0x8620 +GL_VERTEX_PROGRAM_BINDING_NV=0x864A +GL_VERTEX_PROGRAM_NV=0x8620 +GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV=0x8DA2 +GL_VERTEX_PROGRAM_POINT_SIZE=0x8642 +GL_VERTEX_PROGRAM_POINT_SIZE_ARB=0x8642 +GL_VERTEX_PROGRAM_POINT_SIZE_NV=0x8642 +GL_VERTEX_PROGRAM_TWO_SIDE=0x8643 +GL_VERTEX_PROGRAM_TWO_SIDE_ARB=0x8643 +GL_VERTEX_PROGRAM_TWO_SIDE_NV=0x8643 +GL_VERTEX_SHADER=0x8B31 +GL_VERTEX_SHADER_ARB=0x8B31 +GL_VERTEX_SHADER_BINDING_EXT=0x8781 +GL_VERTEX_SHADER_EXT=0x8780 +GL_VERTEX_SHADER_INSTRUCTIONS_EXT=0x87CF +GL_VERTEX_SHADER_INVARIANTS_EXT=0x87D1 +GL_VERTEX_SHADER_LOCALS_EXT=0x87D3 +GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT=0x87D2 +GL_VERTEX_SHADER_OPTIMIZED_EXT=0x87D4 +GL_VERTEX_SHADER_VARIANTS_EXT=0x87D0 +GL_VERTEX_SOURCE_ATI=0x8774 +GL_VERTEX_STATE_PROGRAM_NV=0x8621 +GL_VERTEX_STREAM0_ATI=0x876C +GL_VERTEX_STREAM1_ATI=0x876D +GL_VERTEX_STREAM2_ATI=0x876E +GL_VERTEX_STREAM3_ATI=0x876F +GL_VERTEX_STREAM4_ATI=0x8770 +GL_VERTEX_STREAM5_ATI=0x8771 +GL_VERTEX_STREAM6_ATI=0x8772 +GL_VERTEX_STREAM7_ATI=0x8773 +GL_VERTEX_WEIGHTING_EXT=0x8509 +GL_VERTEX_WEIGHT_ARRAY_EXT=0x850C +GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT=0x8510 +GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT=0x850D +GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT=0x850F +GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT=0x850E +GL_VIBRANCE_BIAS_NV=0x8719 +GL_VIBRANCE_SCALE_NV=0x8713 +GL_VIEWPORT=0x0BA2 +GL_VIEWPORT_BIT=0x00000800 +GL_WEIGHT_ARRAY_ARB=0x86AD +GL_WEIGHT_ARRAY_BUFFER_BINDING=0x889E +GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB=0x889E +GL_WEIGHT_ARRAY_POINTER_ARB=0x86AC +GL_WEIGHT_ARRAY_SIZE_ARB=0x86AB +GL_WEIGHT_ARRAY_STRIDE_ARB=0x86AA +GL_WEIGHT_ARRAY_TYPE_ARB=0x86A9 +GL_WEIGHT_SUM_UNITY_ARB=0x86A6 +GL_WIDE_LINE_HINT_PGI=0x1A222 +GL_WIN_phong_shading=1 +GL_WIN_specular_fog=1 +GL_WRAP_BORDER_SUN=0x81D4 +GL_WRITE_ONLY=0x88B9 +GL_WRITE_ONLY_ARB=0x88B9 +GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV=0x887A +GL_WRITE_PIXEL_DATA_RANGE_NV=0x8878 +GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV=0x887C +GL_W_EXT=0x87D8 +GL_XOR=0x1506 +GL_X_EXT=0x87D5 +GL_YCBCR_422_APPLE=0x85B9 +GL_YCBCR_MESA=0x8757 +GL_YCRCBA_SGIX=0x8319 +GL_YCRCB_422_SGIX=0x81BB +GL_YCRCB_444_SGIX=0x81BC +GL_YCRCB_SGIX=0x8318 +GL_Y_EXT=0x87D6 +GL_ZERO=0 +GL_ZERO_EXT=0x87DD +GL_ZOOM_X=0x0D16 +GL_ZOOM_Y=0x0D17 +GL_Z_EXT=0x87D7 +. +.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/share/dynport/GLU.dynport Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,224 @@ + + +:lib +GLU|OpenGL|OpenGL32 +. +:fun +gluBeginCurve(*<GLUnurbs>)v; +gluBeginPolygon(*<GLUtesselator>)v; +gluBeginSurface(*<GLUnurbs>)v; +gluBeginTrim(*<GLUnurbs>)v; +gluBuild1DMipmapLevels(IiiIIiii*v)i; +gluBuild1DMipmaps(IiiII*v)i; +gluBuild2DMipmapLevels(IiiiIIiii*v)i; +gluBuild2DMipmaps(IiiiII*v)i; +gluBuild3DMipmapLevels(IiiiiIIiii*v)i; +gluBuild3DMipmaps(IiiiiII*v)i; +gluCheckExtension(*C*C)C; +gluCylinder(*<GLUquadric>dddii)v; +gluDeleteNurbsRenderer(*<GLUnurbs>)v; +gluDeleteQuadric(*<GLUquadric>)v; +gluDeleteTess(*<GLUtesselator>)v; +gluDisk(*<GLUquadric>ddii)v; +gluEndCurve(*<GLUnurbs>)v; +gluEndPolygon(*<GLUtesselator>)v; +gluEndSurface(*<GLUnurbs>)v; +gluEndTrim(*<GLUnurbs>)v; +gluErrorString(I)*C; +gluGetNurbsProperty(*<GLUnurbs>I*f)v; +gluGetString(I)*C; +gluGetTessProperty(*<GLUtesselator>I*d)v; +gluLoadSamplingMatrices(*<GLUnurbs>*f*f*i)v; +gluLookAt(ddddddddd)v; +gluNewNurbsRenderer()*<GLUnurbs>; +gluNewQuadric()*<GLUquadric>; +gluNewTess()*<GLUtesselator>; +gluNextContour(*<GLUtesselator>I)v; +gluNurbsCallback(*<GLUnurbs>I*p)v; +gluNurbsCallbackData(*<GLUnurbs>*v)v; +gluNurbsCallbackDataEXT(*<GLUnurbs>*v)v; +gluNurbsCurve(*<GLUnurbs>i*fi*fiI)v; +gluNurbsProperty(*<GLUnurbs>If)v; +gluNurbsSurface(*<GLUnurbs>i*fi*fii*fiiI)v; +gluOrtho2D(dddd)v; +gluPartialDisk(*<GLUquadric>ddiidd)v; +gluPerspective(dddd)v; +gluPickMatrix(dddd*i)v; +gluProject(ddd*d*d*i*d*d*d)i; +gluPwlCurve(*<GLUnurbs>i*fiI)v; +gluQuadricCallback(*<GLUquadric>I*p)v; +gluQuadricDrawStyle(*<GLUquadric>I)v; +gluQuadricNormals(*<GLUquadric>I)v; +gluQuadricOrientation(*<GLUquadric>I)v; +gluQuadricTexture(*<GLUquadric>C)v; +gluScaleImage(IiiI*viiI*v)i; +gluSphere(*<GLUquadric>dii)v; +gluTessBeginContour(*<GLUtesselator>)v; +gluTessBeginPolygon(*<GLUtesselator>*v)v; +gluTessCallback(*<GLUtesselator>I*p)v; +gluTessEndContour(*<GLUtesselator>)v; +gluTessEndPolygon(*<GLUtesselator>)v; +gluTessNormal(*<GLUtesselator>ddd)v; +gluTessProperty(*<GLUtesselator>Id)v; +gluTessVertex(*<GLUtesselator>*d*v)v; +gluUnProject(ddd*d*d*i*d*d*d)i; +gluUnProject4(dddd*d*d*idd*d*d*d*d)i; +. +:const +GLU_AUTO_LOAD_MATRIX=100200 +GLU_BEGIN=100100 +GLU_CCW=100121 +GLU_CULLING=100201 +GLU_CW=100120 +GLU_DISPLAY_MODE=100204 +GLU_DOMAIN_DISTANCE=100217 +GLU_EDGE_FLAG=100104 +GLU_END=100102 +GLU_ERROR=100103 +GLU_EXTENSIONS=100801 +GLU_EXTERIOR=100123 +GLU_EXT_nurbs_tessellator=1 +GLU_EXT_object_space_tess=1 +GLU_FALSE=0 +GLU_FILL=100012 +GLU_FLAT=100001 +GLU_INCOMPATIBLE_GL_VERSION=100903 +GLU_INSIDE=100021 +GLU_INTERIOR=100122 +GLU_INVALID_ENUM=100900 +GLU_INVALID_OPERATION=100904 +GLU_INVALID_VALUE=100901 +GLU_LINE=100011 +GLU_MAP1_TRIM_2=100210 +GLU_MAP1_TRIM_3=100211 +GLU_NONE=100002 +GLU_NURBS_BEGIN=100164 +GLU_NURBS_BEGIN_DATA=100170 +GLU_NURBS_BEGIN_DATA_EXT=100170 +GLU_NURBS_BEGIN_EXT=100164 +GLU_NURBS_COLOR=100167 +GLU_NURBS_COLOR_DATA=100173 +GLU_NURBS_COLOR_DATA_EXT=100173 +GLU_NURBS_COLOR_EXT=100167 +GLU_NURBS_END=100169 +GLU_NURBS_END_DATA=100175 +GLU_NURBS_END_DATA_EXT=100175 +GLU_NURBS_END_EXT=100169 +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_ERROR1=100251 +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_ERROR2=100252 +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 +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_ERROR=100103 +GLU_NURBS_MODE=100160 +GLU_NURBS_MODE_EXT=100160 +GLU_NURBS_NORMAL=100166 +GLU_NURBS_NORMAL_DATA=100172 +GLU_NURBS_NORMAL_DATA_EXT=100172 +GLU_NURBS_NORMAL_EXT=100166 +GLU_NURBS_RENDERER=100162 +GLU_NURBS_RENDERER_EXT=100162 +GLU_NURBS_TESSELLATOR=100161 +GLU_NURBS_TESSELLATOR_EXT=100161 +GLU_NURBS_TEXTURE_COORD=100168 +GLU_NURBS_TEXTURE_COORD_DATA=100174 +GLU_NURBS_TEX_COORD_DATA_EXT=100174 +GLU_NURBS_TEX_COORD_EXT=100168 +GLU_NURBS_VERTEX=100165 +GLU_NURBS_VERTEX_DATA=100171 +GLU_NURBS_VERTEX_DATA_EXT=100171 +GLU_NURBS_VERTEX_EXT=100165 +GLU_OBJECT_PARAMETRIC_ERROR=100208 +GLU_OBJECT_PARAMETRIC_ERROR_EXT=100208 +GLU_OBJECT_PATH_LENGTH=100209 +GLU_OBJECT_PATH_LENGTH_EXT=100209 +GLU_OUTLINE_PATCH=100241 +GLU_OUTLINE_POLYGON=100240 +GLU_OUTSIDE=100020 +GLU_OUT_OF_MEMORY=100902 +GLU_PARAMETRIC_ERROR=100216 +GLU_PARAMETRIC_TOLERANCE=100202 +GLU_PATH_LENGTH=100215 +GLU_POINT=100010 +GLU_SAMPLING_METHOD=100205 +GLU_SAMPLING_TOLERANCE=100203 +GLU_SILHOUETTE=100013 +GLU_SMOOTH=100000 +GLU_TESS_BEGIN=100100 +GLU_TESS_BEGIN_DATA=100106 +GLU_TESS_BOUNDARY_ONLY=100141 +GLU_TESS_COMBINE=100105 +GLU_TESS_COMBINE_DATA=100111 +GLU_TESS_COORD_TOO_LARGE=100155 +GLU_TESS_EDGE_FLAG=100104 +GLU_TESS_EDGE_FLAG_DATA=100110 +GLU_TESS_END=100102 +GLU_TESS_END_DATA=100108 +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_ERROR=100103 +GLU_TESS_ERROR_DATA=100109 +GLU_TESS_MAX_COORD=1.0e150 +GLU_TESS_MISSING_BEGIN_CONTOUR=100152 +GLU_TESS_MISSING_BEGIN_POLYGON=100151 +GLU_TESS_MISSING_END_CONTOUR=100154 +GLU_TESS_MISSING_END_POLYGON=100153 +GLU_TESS_NEED_COMBINE_CALLBACK=100156 +GLU_TESS_TOLERANCE=100142 +GLU_TESS_VERTEX=100101 +GLU_TESS_VERTEX_DATA=100107 +GLU_TESS_WINDING_ABS_GEQ_TWO=100134 +GLU_TESS_WINDING_NEGATIVE=100133 +GLU_TESS_WINDING_NONZERO=100131 +GLU_TESS_WINDING_ODD=100130 +GLU_TESS_WINDING_POSITIVE=100132 +GLU_TESS_WINDING_RULE=100140 +GLU_TRUE=1 +GLU_UNKNOWN=100124 +GLU_U_STEP=100206 +GLU_VERSION=100800 +GLU_VERSION_1_1=1 +GLU_VERSION_1_2=1 +GLU_VERSION_1_3=1 +GLU_VERTEX=100101 +GLU_V_STEP=100207 +. +.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/share/dynport/SDL.dynport Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,303 @@ +:lib +SDL +. +:fun +SDL_AddTimer(I*p*v)*<_SDL_TimerID>; +SDL_AllocRW()*<SDL_RWops>; +SDL_AudioDriverName(*ci)*c; +SDL_AudioInit(*c)i; +SDL_AudioQuit()v; +SDL_BuildAudioCVT(*<SDL_AudioCVT>SCiSCi)i; +SDL_CDClose(*<SDL_CD>)v; +SDL_CDEject(*<SDL_CD>)i; +SDL_CDName(i)*c; +SDL_CDNumDrives()i; +SDL_CDOpen(i)*<SDL_CD>; +SDL_CDPause(*<SDL_CD>)i; +SDL_CDPlay(*<SDL_CD>ii)i; +SDL_CDPlayTracks(*<SDL_CD>iiii)i; +SDL_CDResume(*<SDL_CD>)i; +SDL_CDStatus(*<SDL_CD>)i; +SDL_CDStop(*<SDL_CD>)i; +SDL_ClearError()v; +SDL_CloseAudio()v; +SDL_CondBroadcast(*<SDL_cond>)i; +SDL_CondSignal(*<SDL_cond>)i; +SDL_CondWait(*<SDL_cond>*<SDL_mutex>)i; +SDL_CondWaitTimeout(*<SDL_cond>*<SDL_mutex>I)i; +SDL_ConvertAudio(*<SDL_AudioCVT>)i; +SDL_ConvertSurface(*<SDL_Surface>*<SDL_PixelFormat>I)*<SDL_Surface>; +SDL_CreateCond()*<SDL_cond>; +SDL_CreateCursor(*C*Ciiii)*<SDL_Cursor>; +SDL_CreateMutex()*<SDL_mutex>; +SDL_CreateRGBSurface(IiiiIIII)*<SDL_Surface>; +SDL_CreateRGBSurfaceFrom(*viiiiIIII)*<SDL_Surface>; +SDL_CreateSemaphore(I)*<SDL_semaphore>; +SDL_CreateThread(*p*v)*<SDL_Thread>; +SDL_CreateYUVOverlay(iiI*<SDL_Surface>)*<SDL_Overlay>; +SDL_Delay(I)v; +SDL_DestroyCond(*<SDL_cond>)v; +SDL_DestroyMutex(*<SDL_mutex>)v; +SDL_DestroySemaphore(*<SDL_semaphore>)v; +SDL_DisplayFormat(*<SDL_Surface>)*<SDL_Surface>; +SDL_DisplayFormatAlpha(*<SDL_Surface>)*<SDL_Surface>; +SDL_DisplayYUVOverlay(*<SDL_Overlay>*<SDL_Rect>)i; +SDL_EnableKeyRepeat(ii)i; +SDL_EnableUNICODE(i)i; +SDL_Error(i)v; +SDL_EventState(Ci)C; +SDL_FillRect(*<SDL_Surface>*<SDL_Rect>I)i; +SDL_Flip(*<SDL_Surface>)i; +SDL_FreeCursor(*<SDL_Cursor>)v; +SDL_FreeRW(*<SDL_RWops>)v; +SDL_FreeSurface(*<SDL_Surface>)v; +SDL_FreeWAV(*C)v; +SDL_FreeYUVOverlay(*<SDL_Overlay>)v; +SDL_GL_GetAttribute(i*i)i; +SDL_GL_GetProcAddress(*c)*v; +SDL_GL_LoadLibrary(*c)i; +SDL_GL_Lock()v; +SDL_GL_SetAttribute(ii)i; +SDL_GL_SwapBuffers()v; +SDL_GL_Unlock()v; +SDL_GL_UpdateRects(i*<SDL_Rect>)v; +SDL_GetAppState()C; +SDL_GetAudioStatus()i; +SDL_GetClipRect(*<SDL_Surface>*<SDL_Rect>)v; +SDL_GetCursor()*<SDL_Cursor>; +SDL_GetError()*c; +SDL_GetEventFilter()*p; +SDL_GetGammaRamp(*S*S*S)i; +SDL_GetKeyName(i)*c; +SDL_GetKeyRepeat(*i*i)v; +SDL_GetKeyState(*i)*C; +SDL_GetModState()i; +SDL_GetMouseState(*i*i)C; +SDL_GetRGB(I*<SDL_PixelFormat>*C*C*C)v; +SDL_GetRGBA(I*<SDL_PixelFormat>*C*C*C*C)v; +SDL_GetRelativeMouseState(*i*i)C; +SDL_GetThreadID(*<SDL_Thread>)I; +SDL_GetTicks()I; +SDL_GetVideoInfo()*<SDL_VideoInfo>; +SDL_GetVideoSurface()*<SDL_Surface>; +SDL_Has3DNow()i; +SDL_Has3DNowExt()i; +SDL_HasAltiVec()i; +SDL_HasMMX()i; +SDL_HasMMXExt()i; +SDL_HasRDTSC()i; +SDL_HasSSE()i; +SDL_HasSSE2()i; +SDL_Init(I)i; +SDL_InitSubSystem(I)i; +SDL_JoystickClose(*<_SDL_Joystick>)v; +SDL_JoystickEventState(i)i; +SDL_JoystickGetAxis(*<_SDL_Joystick>i)s; +SDL_JoystickGetBall(*<_SDL_Joystick>i*i*i)i; +SDL_JoystickGetButton(*<_SDL_Joystick>i)C; +SDL_JoystickGetHat(*<_SDL_Joystick>i)C; +SDL_JoystickIndex(*<_SDL_Joystick>)i; +SDL_JoystickName(i)*c; +SDL_JoystickNumAxes(*<_SDL_Joystick>)i; +SDL_JoystickNumBalls(*<_SDL_Joystick>)i; +SDL_JoystickNumButtons(*<_SDL_Joystick>)i; +SDL_JoystickNumHats(*<_SDL_Joystick>)i; +SDL_JoystickOpen(i)*<_SDL_Joystick>; +SDL_JoystickOpened(i)i; +SDL_JoystickUpdate()v; +SDL_KillThread(*<SDL_Thread>)v; +SDL_Linked_Version()*<SDL_version>; +SDL_ListModes(*<SDL_PixelFormat>I)*; +SDL_LoadBMP_RW(*<SDL_RWops>i)*<SDL_Surface>; +SDL_LoadFunction(*v*c)*v; +SDL_LoadObject(*c)*v; +SDL_LoadWAV_RW(*<SDL_RWops>i*<SDL_AudioSpec>**I)*<SDL_AudioSpec>; +SDL_LockAudio()v; +SDL_LockSurface(*<SDL_Surface>)i; +SDL_LockYUVOverlay(*<SDL_Overlay>)i; +SDL_LowerBlit(*<SDL_Surface>*<SDL_Rect>*<SDL_Surface>*<SDL_Rect>)i; +SDL_MapRGB(*<SDL_PixelFormat>CCC)I; +SDL_MapRGBA(*<SDL_PixelFormat>CCCC)I; +SDL_MixAudio(*C*CIi)v; +SDL_NumJoysticks()i; +SDL_OpenAudio(*<SDL_AudioSpec>*<SDL_AudioSpec>)i; +SDL_PauseAudio(i)v; +SDL_PeepEvents(*<SDL_Event>iiI)i; +SDL_PollEvent(*<SDL_Event>)i; +SDL_PumpEvents()v; +SDL_PushEvent(*<SDL_Event>)i; +SDL_Quit()v; +SDL_QuitSubSystem(I)v; +SDL_RWFromConstMem(*vi)*<SDL_RWops>; +SDL_RWFromFP(*<__sFILE>i)*<SDL_RWops>; +SDL_RWFromFile(*c*c)*<SDL_RWops>; +SDL_RWFromMem(*vi)*<SDL_RWops>; +SDL_ReadBE16(*<SDL_RWops>)S; +SDL_ReadBE32(*<SDL_RWops>)I; +SDL_ReadBE64(*<SDL_RWops>)L; +SDL_ReadLE16(*<SDL_RWops>)S; +SDL_ReadLE32(*<SDL_RWops>)I; +SDL_ReadLE64(*<SDL_RWops>)L; +SDL_RemoveTimer(*<_SDL_TimerID>)i; +SDL_SaveBMP_RW(*<SDL_Surface>*<SDL_RWops>i)i; +SDL_SemPost(*<SDL_semaphore>)i; +SDL_SemTryWait(*<SDL_semaphore>)i; +SDL_SemValue(*<SDL_semaphore>)I; +SDL_SemWait(*<SDL_semaphore>)i; +SDL_SemWaitTimeout(*<SDL_semaphore>I)i; +SDL_SetAlpha(*<SDL_Surface>IC)i; +SDL_SetClipRect(*<SDL_Surface>*<SDL_Rect>)i; +SDL_SetColorKey(*<SDL_Surface>II)i; +SDL_SetColors(*<SDL_Surface>*<SDL_Color>ii)i; +SDL_SetCursor(*<SDL_Cursor>)v; +SDL_SetError(*c)v; +SDL_SetEventFilter(*p)v; +SDL_SetGamma(fff)i; +SDL_SetGammaRamp(*S*S*S)i; +SDL_SetModState(i)v; +SDL_SetPalette(*<SDL_Surface>i*<SDL_Color>ii)i; +SDL_SetTimer(I*p)i; +SDL_SetVideoMode(iiiI)*<SDL_Surface>; +SDL_ShowCursor(i)i; +SDL_SoftStretch(*<SDL_Surface>*<SDL_Rect>*<SDL_Surface>*<SDL_Rect>)i; +SDL_Swap16(S)S; +SDL_Swap32(I)I; +SDL_Swap64(L)L; +SDL_ThreadID()I; +SDL_UnloadObject(*v)v; +SDL_UnlockAudio()v; +SDL_UnlockSurface(*<SDL_Surface>)v; +SDL_UnlockYUVOverlay(*<SDL_Overlay>)v; +SDL_UpdateRect(*<SDL_Surface>iiII)v; +SDL_UpdateRects(*<SDL_Surface>i*<SDL_Rect>)v; +SDL_UpperBlit(*<SDL_Surface>*<SDL_Rect>*<SDL_Surface>*<SDL_Rect>)i; +SDL_VideoDriverName(*ci)*c; +SDL_VideoInit(*cI)i; +SDL_VideoModeOK(iiiI)i; +SDL_VideoQuit()v; +SDL_WM_GetCaption(**)v; +SDL_WM_GrabInput(i)i; +SDL_WM_IconifyWindow()i; +SDL_WM_SetCaption(*c*c)v; +SDL_WM_SetIcon(*<SDL_Surface>*C)v; +SDL_WM_ToggleFullScreen(*<SDL_Surface>)i; +SDL_WaitEvent(*<SDL_Event>)i; +SDL_WaitThread(*<SDL_Thread>*i)v; +SDL_WarpMouse(SS)v; +SDL_WasInit(I)I; +SDL_WriteBE16(*<SDL_RWops>S)i; +SDL_WriteBE32(*<SDL_RWops>I)i; +SDL_WriteBE64(*<SDL_RWops>L)i; +SDL_WriteLE16(*<SDL_RWops>S)i; +SDL_WriteLE32(*<SDL_RWops>I)i; +SDL_WriteLE64(*<SDL_RWops>L)i; +SDL_iconv(*<_SDL_iconv_t>**J**J)J; +SDL_iconv_close(*<_SDL_iconv_t>)i; +SDL_iconv_open(*c*c)*<_SDL_iconv_t>; +SDL_iconv_string(*c*c*cJ)*c; +SDL_lltoa(l*ci)*c; +SDL_ltoa(j*ci)*c; +SDL_main(i*)i; +SDL_mutexP(*<SDL_mutex>)i; +SDL_mutexV(*<SDL_mutex>)i; +SDL_strlwr(*c)*c; +SDL_strrev(*c)*c; +SDL_strupr(*c)*c; +SDL_ulltoa(L*ci)*c; +SDL_ultoa(J*ci)*c; +. +:const +AUDIO_S16=0x8010 +AUDIO_S16LSB=0x8010 +AUDIO_S16MSB=0x9010 +AUDIO_S16SYS=0x8010 +AUDIO_S8=0x8008 +AUDIO_U16=0x0010 +AUDIO_U16LSB=0x0010 +AUDIO_U16MSB=0x1010 +AUDIO_U16SYS=0x0010 +AUDIO_U8=0x0008 +SDL_ALLEVENTS=0xFFFFFFFF +SDL_ALL_HOTKEYS=0xFFFFFFFF +SDL_ALPHA_OPAQUE=255 +SDL_ALPHA_TRANSPARENT=0 +SDL_ANYFORMAT=0x10000000 +SDL_APPACTIVE=0x04 +SDL_APPINPUTFOCUS=0x02 +SDL_APPMOUSEFOCUS=0x01 +SDL_ASSEMBLY_ROUTINES=1 +SDL_ASYNCBLIT=0x00000004 +SDL_AUDIO_DRIVER_COREAUDIO=1 +SDL_AUDIO_DRIVER_DISK=1 +SDL_AUDIO_DRIVER_DUMMY=1 +SDL_AUDIO_DRIVER_SNDMGR=1 +SDL_AUDIO_TRACK=0x00 +SDL_INIT_AUDIO=0x00000010 +SDL_INIT_CDROM=0x00000100 +SDL_INIT_EVENTTHREAD=0x01000000 +SDL_INIT_EVERYTHING=0x0000FFFF +SDL_INIT_JOYSTICK=0x00000200 +SDL_INIT_NOPARACHUTE=0x00100000 +SDL_INIT_TIMER=0x00000001 +SDL_INIT_VIDEO=0x00000020 +SDL_OPENGL=0x00000002 +SDL_OPENGLBLIT=0x0000000A +SDL_NOFRAME=0x00000020 +SDL_FULLSCREEN=0x80000000 +SDL_RESIZABLE=0x00000010 +SDL_RLEACCEL=0x00004000 +SDL_RLEACCELOK=0x00002000 +SDL_SRCALPHA=0x00010000 +SDL_SRCCOLORKEY=0x00001000 +SDL_SWSURFACE=0x00000000 +SDL_BUTTON_LEFT=1 +SDL_BUTTON_MIDDLE=2 +SDL_BUTTON_RIGHT=3 +SDL_BUTTON_WHEELDOWN=5 +SDL_BUTTON_WHEELUP=4 +SDL_DOUBLEBUF=0x40000000 +SDL_FULLSCREEN=0x80000000 +. +:struct +SDL_version{CCC}major minor patch ; +SDL_SysWMEvent{C*<SDL_SysWMmsg>}type msg ; +SDL_SysWMmsg{}; +SDL_UserEvent{Ci*v*v}type code data1 data2 ; +SDL_QuitEvent{C}type ; +SDL_ExposeEvent{C}type ; +SDL_ResizeEvent{Cii}type w h ; +SDL_JoyButtonEvent{CCCC}type which button state ; +SDL_JoyHatEvent{CCCC}type which hat value ; +SDL_JoyBallEvent{CCCss}type which ball xrel yrel ; +SDL_JoyAxisEvent{CCCs}type which axis value ; +SDL_MouseButtonEvent{CCCCSS}type which button state x y ; +SDL_MouseMotionEvent{CCCSSss}type which state x y xrel yrel ; +SDL_KeyboardEvent{CCC<SDL_keysym>}type which state keysym ; +SDL_ActiveEvent{CCC}type gain state ; +SDL_Cursor{<SDL_Rect>ss*C*C[2]*C*<WMcursor>}area hot_x hot_y data mask save wm_cursor ; +WMcursor{}; +SDL_Overlay{Iiii*S**C*<private_yuvhwfuncs>*<private_yuvhwdata>II}format w h planes pitches pixels hwfuncs hwdata hw_overlay UnusedBits ; +private_yuvhwdata{}; +private_yuvhwfuncs{}; +SDL_VideoInfo{IIIIIIIIIIIII*<SDL_PixelFormat>ii}hw_available wm_available UnusedBits1 UnusedBits2 blit_hw blit_hw_CC blit_hw_A blit_sw blit_sw_CC blit_sw_A blit_fill UnusedBits3 video_mem vfmt current_w current_h ; +SDL_Surface{I*<SDL_PixelFormat>iiS*vi*<private_hwdata><SDL_Rect>II*<SDL_BlitMap>Ii}flags format w h pitch pixels offset hwdata clip_rect unused1 locked map format_version refcount ; +SDL_BlitMap{}; +private_hwdata{}; +SDL_PixelFormat{*<SDL_Palette>CCCCCCCCCCIIIIIC}palette BitsPerPixel BytesPerPixel Rloss Gloss Bloss Aloss Rshift Gshift Bshift Ashift Rmask Gmask Bmask Amask colorkey alpha ; +SDL_Palette{i*<SDL_Color>}ncolors colors ; +SDL_Color{CCCC}r g b unused ; +SDL_Rect{ssSS}x y w h ; +SDL_keysym{CiiS}scancode sym mod unicode ; +SDL_CD{iiiii[100]<SDL_CDtrack>}id status numtracks cur_track cur_frame track ; +SDL_CDtrack{CCSII}id type unused length offset ; +SDL_AudioCVT{iSSd*Ciiid[10]*pi}needed src_format dst_format rate_incr buf len len_cvt len_mult len_ratio filters filter_index ; +SDL_AudioSpec{iSCCSSI*p*v}freq format channels silence samples padding size callback userdata ; +SDL_RWops{*p*p*p*pI<$_16>}seek read write close type hidden ; +SDL_Thread{}; +SDL_cond{}; +SDL_semaphore{}; +SDL_mutex{}; +. +:union +. +.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/share/dynport/SDL_image.dynport Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,35 @@ +:lib +SDL_image|SDL_image-1.2 +. +:fun +IMG_InvertAlpha(i)i; +IMG_Linked_Version()*<SDL_version>; +IMG_Load(*c)*<SDL_Surface>; +IMG_LoadBMP_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadGIF_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadJPG_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadLBM_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadPCX_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadPNG_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadPNM_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadTGA_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadTIF_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadTyped_RW(*<SDL_RWops>i*c)*<SDL_Surface>; +IMG_LoadXCF_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadXPM_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_LoadXV_RW(*<SDL_RWops>)*<SDL_Surface>; +IMG_Load_RW(*<SDL_RWops>i)*<SDL_Surface>; +IMG_ReadXPMFromArray(*)*<SDL_Surface>; +IMG_isBMP(*<SDL_RWops>)i; +IMG_isGIF(*<SDL_RWops>)i; +IMG_isJPG(*<SDL_RWops>)i; +IMG_isLBM(*<SDL_RWops>)i; +IMG_isPCX(*<SDL_RWops>)i; +IMG_isPNG(*<SDL_RWops>)i; +IMG_isPNM(*<SDL_RWops>)i; +IMG_isTIF(*<SDL_RWops>)i; +IMG_isXCF(*<SDL_RWops>)i; +IMG_isXPM(*<SDL_RWops>)i; +IMG_isXV(*<SDL_RWops>)i; +. +.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/share/dynport/SDL_mixer.dynport Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,96 @@ +:lib +SDL_mixer|SDL_mixer-1.2 +. +:fun +Mix_AllocateChannels(i)i; +Mix_ChannelFinished(*p)v; +Mix_CloseAudio()v; +Mix_ExpireChannel(ii)i; +Mix_FadeInChannelTimed(i*<Mix_Chunk>iii)i; +Mix_FadeInMusic(*<_Mix_Music>ii)i; +Mix_FadeInMusicPos(*<_Mix_Music>iid)i; +Mix_FadeOutChannel(ii)i; +Mix_FadeOutGroup(ii)i; +Mix_FadeOutMusic(i)i; +Mix_FadingChannel(i)i; +Mix_FadingMusic()i; +Mix_FreeChunk(*<Mix_Chunk>)v; +Mix_FreeMusic(*<_Mix_Music>)v; +Mix_GetChunk(i)*<Mix_Chunk>; +Mix_GetChunkDecoder(i)*c; +Mix_GetMusicDecoder(i)*c; +Mix_GetMusicHookData()*v; +Mix_GetMusicType(*<_Mix_Music>)i; +Mix_GetNumChunkDecoders()i; +Mix_GetNumMusicDecoders()i; +Mix_GetSynchroValue()i; +Mix_GroupAvailable(i)i; +Mix_GroupChannel(ii)i; +Mix_GroupChannels(iii)i; +Mix_GroupCount(i)i; +Mix_GroupNewer(i)i; +Mix_GroupOldest(i)i; +Mix_HaltChannel(i)i; +Mix_HaltGroup(i)i; +Mix_HaltMusic()i; +Mix_HookMusic(*p*v)v; +Mix_HookMusicFinished(*p)v; +Mix_Init(i)i; +Mix_Linked_Version()*<SDL_version>; +Mix_LoadMUS(*c)*<_Mix_Music>; +Mix_LoadMUS_RW(*<SDL_RWops>)*<_Mix_Music>; +Mix_LoadWAV_RW(*<SDL_RWops>i)*<Mix_Chunk>; +Mix_OpenAudio(iSii)i; +Mix_Pause(i)v; +Mix_PauseMusic()v; +Mix_Paused(i)i; +Mix_PausedMusic()i; +Mix_PlayChannelTimed(i*<Mix_Chunk>ii)i; +Mix_PlayMusic(*<_Mix_Music>i)i; +Mix_Playing(i)i; +Mix_PlayingMusic()i; +Mix_QuerySpec(*i*S*i)i; +Mix_QuickLoad_RAW(*CI)*<Mix_Chunk>; +Mix_QuickLoad_WAV(*C)*<Mix_Chunk>; +Mix_Quit()v; +Mix_RegisterEffect(i*p*p*v)i; +Mix_ReserveChannels(i)i; +Mix_Resume(i)v; +Mix_ResumeMusic()v; +Mix_RewindMusic()v; +Mix_SetDistance(iC)i; +Mix_SetMusicCMD(*c)i; +Mix_SetMusicPosition(d)i; +Mix_SetPanning(iCC)i; +Mix_SetPosition(isC)i; +Mix_SetPostMix(*p*v)v; +Mix_SetReverseStereo(ii)i; +Mix_SetSynchroValue(i)i; +Mix_UnregisterAllEffects(i)i; +Mix_UnregisterEffect(i*p)i; +Mix_Volume(ii)i; +Mix_VolumeChunk(*<Mix_Chunk>i)i; +Mix_VolumeMusic(i)i; +. +:const +MIX_CHANNELS=8 +MIX_CHANNEL_POST=-2 +MIX_DEFAULT_CHANNELS=2 +MIX_DEFAULT_FORMAT=0x8010 +MIX_DEFAULT_FREQUENCY=22050 +MIX_EFFECTSMAXSPEED="MIX_EFFECTSMAXSPEED" +MIX_MAJOR_VERSION=1 +MIX_MAX_VOLUME=128 +MIX_MINOR_VERSION=2 +MIX_PATCHLEVEL=11 +Mix_GetError=SDL_GetError +Mix_SetError=SDL_SetError +MIX_FADING_IN=2 +MIX_FADING_OUT=1 +MIX_INIT_FLAC=1 +MIX_INIT_MOD=2 +MIX_INIT_MP3=4 +MIX_INIT_OGG=8 +MIX_NO_FADING=0 +. +.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/share/dynport/cmath.dynport Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,7 @@ +:lib +c +. +:fun +sqrt(d)d; +. +.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/share/dynport/cocoautil.dynport Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,8 @@ +:lib +cocoautil +. +:fun +CocoaInit()v; +CocoaQuit()v; +. +.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/share/dynport/gl3.dynport Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,1173 @@ +:lib +OpenGL|GL +. +:fun +glActiveTexture(I)v; +glAttachShader(II)v; +glBeginConditionalRender(II)v; +glBeginQuery(II)v; +glBeginTransformFeedback(I)v; +glBindAttribLocation(II*c)v; +glBindBuffer(II)v; +glBindBufferBase(III)v; +glBindBufferRange(IIIii)v; +glBindFragDataLocation(II*c)v; +glBindFramebuffer(II)v; +glBindRenderbuffer(II)v; +glBindTexture(II)v; +glBindVertexArray(I)v; +glBlendColor(ffff)v; +glBlendEquation(I)v; +glBlendEquationSeparate(II)v; +glBlendEquationSeparatei(III)v; +glBlendEquationi(II)v; +glBlendFunc(II)v; +glBlendFuncSeparate(IIII)v; +glBlendFuncSeparatei(IIIII)v; +glBlendFunci(III)v; +glBlitFramebuffer(iiiiiiiiII)v; +glBufferData(Ii*vI)v; +glBufferSubData(Iii*v)v; +glCheckFramebufferStatus(I)I; +glClampColor(II)v; +glClear(I)v; +glClearBufferfi(Iifi)v; +glClearBufferfv(Ii*f)v; +glClearBufferiv(Ii*i)v; +glClearBufferuiv(Ii*I)v; +glClearColor(ffff)v; +glClearDepth(d)v; +glClearStencil(i)v; +glClientWaitSync(*<__GLsync>IL)I; +glColorMask(CCCC)v; +glColorMaski(ICCCC)v; +glCompileShader(I)v; +glCompressedTexImage1D(IiIiii*v)v; +glCompressedTexImage2D(IiIiiii*v)v; +glCompressedTexImage3D(IiIiiiii*v)v; +glCompressedTexSubImage1D(IiiiIi*v)v; +glCompressedTexSubImage2D(IiiiiiIi*v)v; +glCompressedTexSubImage3D(IiiiiiiiIi*v)v; +glCopyBufferSubData(IIiii)v; +glCopyTexImage1D(IiIiiii)v; +glCopyTexImage2D(IiIiiiii)v; +glCopyTexSubImage1D(Iiiiii)v; +glCopyTexSubImage2D(Iiiiiiii)v; +glCopyTexSubImage3D(Iiiiiiiii)v; +glCreateProgram()I; +glCreateShader(I)I; +glCullFace(I)v; +glDeleteBuffers(i*I)v; +glDeleteFramebuffers(i*I)v; +glDeleteProgram(I)v; +glDeleteQueries(i*I)v; +glDeleteRenderbuffers(i*I)v; +glDeleteShader(I)v; +glDeleteSync(*<__GLsync>)v; +glDeleteTextures(i*I)v; +glDeleteVertexArrays(i*I)v; +glDepthFunc(I)v; +glDepthMask(C)v; +glDepthRange(dd)v; +glDetachShader(II)v; +glDisable(I)v; +glDisableVertexAttribArray(I)v; +glDisablei(II)v; +glDrawArrays(Iii)v; +glDrawArraysInstanced(Iiii)v; +glDrawBuffer(I)v; +glDrawBuffers(i*I)v; +glDrawElements(IiI*v)v; +glDrawElementsBaseVertex(IiI*vi)v; +glDrawElementsInstanced(IiI*vi)v; +glDrawElementsInstancedBaseVertex(IiI*vii)v; +glDrawRangeElements(IIIiI*v)v; +glDrawRangeElementsBaseVertex(IIIiI*vi)v; +glEnable(I)v; +glEnableVertexAttribArray(I)v; +glEnablei(II)v; +glEndConditionalRender()v; +glEndQuery(I)v; +glEndTransformFeedback()v; +glFenceSync(II)*<__GLsync>; +glFinish()v; +glFlush()v; +glFlushMappedBufferRange(Iii)v; +glFramebufferRenderbuffer(IIII)v; +glFramebufferTexture(IIIi)v; +glFramebufferTexture1D(IIIIi)v; +glFramebufferTexture2D(IIIIi)v; +glFramebufferTexture3D(IIIIii)v; +glFramebufferTextureFace(IIIiI)v; +glFramebufferTextureLayer(IIIii)v; +glFrontFace(I)v; +glGenBuffers(i*I)v; +glGenFramebuffers(i*I)v; +glGenQueries(i*I)v; +glGenRenderbuffers(i*I)v; +glGenTextures(i*I)v; +glGenVertexArrays(i*I)v; +glGenerateMipmap(I)v; +glGetActiveAttrib(IIi*i*i*I*c)v; +glGetActiveUniform(IIi*i*i*I*c)v; +glGetActiveUniformBlockName(IIi*i*c)v; +glGetActiveUniformBlockiv(III*i)v; +glGetActiveUniformName(IIi*i*c)v; +glGetActiveUniformsiv(Ii*II*i)v; +glGetAttachedShaders(Ii*i*I)v; +glGetAttribLocation(I*c)i; +glGetBooleani_v(II*C)v; +glGetBooleanv(I*C)v; +glGetBufferParameteri64v(II*l)v; +glGetBufferParameteriv(II*i)v; +glGetBufferPointerv(II**v)v; +glGetBufferSubData(Iii*v)v; +glGetCompressedTexImage(Ii*v)v; +glGetDoublev(I*d)v; +glGetError()I; +glGetFloatv(I*f)v; +glGetFragDataLocation(I*c)i; +glGetFramebufferAttachmentParameteriv(III*i)v; +glGetInteger64i_v(II*l)v; +glGetInteger64v(I*l)v; +glGetIntegeri_v(II*i)v; +glGetIntegerv(I*i)v; +glGetMultisamplefv(II*f)v; +glGetPointerv(I**v)v; +glGetProgramInfoLog(Ii*i*c)v; +glGetProgramiv(II*i)v; +glGetQueryObjectiv(II*i)v; +glGetQueryObjectuiv(II*I)v; +glGetQueryiv(II*i)v; +glGetRenderbufferParameteriv(II*i)v; +glGetShaderInfoLog(Ii*i*c)v; +glGetShaderSource(Ii*i*c)v; +glGetShaderiv(II*i)v; +glGetString(I)*C; +glGetStringi(II)*C; +glGetSynciv(*<__GLsync>Ii*i*i)v; +glGetTexImage(IiII*v)v; +glGetTexLevelParameterfv(IiI*f)v; +glGetTexLevelParameteriv(IiI*i)v; +glGetTexParameterIiv(II*i)v; +glGetTexParameterIuiv(II*I)v; +glGetTexParameterfv(II*f)v; +glGetTexParameteriv(II*i)v; +glGetTransformFeedbackVarying(IIi*i*i*I*c)v; +glGetUniformBlockIndex(I*c)I; +glGetUniformIndices(Ii**c*I)v; +glGetUniformLocation(I*c)i; +glGetUniformfv(Ii*f)v; +glGetUniformiv(Ii*i)v; +glGetUniformuiv(Ii*I)v; +glGetVertexAttribIiv(II*i)v; +glGetVertexAttribIuiv(II*I)v; +glGetVertexAttribPointerv(II**v)v; +glGetVertexAttribdv(II*d)v; +glGetVertexAttribfv(II*f)v; +glGetVertexAttribiv(II*i)v; +glHint(II)v; +glIsBuffer(I)C; +glIsEnabled(I)C; +glIsEnabledi(II)C; +glIsFramebuffer(I)C; +glIsProgram(I)C; +glIsQuery(I)C; +glIsRenderbuffer(I)C; +glIsShader(I)C; +glIsSync(*<__GLsync>)C; +glIsTexture(I)C; +glIsVertexArray(I)C; +glLineWidth(f)v; +glLinkProgram(I)v; +glLogicOp(I)v; +glMapBuffer(II)*v; +glMapBufferRange(IiiI)*v; +glMinSampleShading(f)v; +glMultiDrawArrays(I*i*ii)v; +glMultiDrawElements(I*iI**vi)v; +glMultiDrawElementsBaseVertex(I*iI**vi*i)v; +glPixelStoref(If)v; +glPixelStorei(Ii)v; +glPointParameterf(If)v; +glPointParameterfv(I*f)v; +glPointParameteri(Ii)v; +glPointParameteriv(I*i)v; +glPointSize(f)v; +glPolygonMode(II)v; +glPolygonOffset(ff)v; +glPrimitiveRestartIndex(I)v; +glProgramParameteri(IIi)v; +glProvokingVertex(I)v; +glReadBuffer(I)v; +glReadPixels(iiiiII*v)v; +glRenderbufferStorage(IIii)v; +glRenderbufferStorageMultisample(IiIii)v; +glSampleCoverage(fC)v; +glSampleMaski(II)v; +glScissor(iiii)v; +glShaderSource(Ii**c*i)v; +glStencilFunc(IiI)v; +glStencilFuncSeparate(IIiI)v; +glStencilMask(I)v; +glStencilMaskSeparate(II)v; +glStencilOp(III)v; +glStencilOpSeparate(IIII)v; +glTexBuffer(III)v; +glTexImage1D(IiiiiII*v)v; +glTexImage2D(IiiiiiII*v)v; +glTexImage2DMultisample(IiiiiC)v; +glTexImage3D(IiiiiiiII*v)v; +glTexImage3DMultisample(IiiiiiC)v; +glTexParameterIiv(II*i)v; +glTexParameterIuiv(II*I)v; +glTexParameterf(IIf)v; +glTexParameterfv(II*f)v; +glTexParameteri(IIi)v; +glTexParameteriv(II*i)v; +glTexSubImage1D(IiiiII*v)v; +glTexSubImage2D(IiiiiiII*v)v; +glTexSubImage3D(IiiiiiiiII*v)v; +glTransformFeedbackVaryings(Ii**cI)v; +glUniform1f(if)v; +glUniform1fv(ii*f)v; +glUniform1i(ii)v; +glUniform1iv(ii*i)v; +glUniform1ui(iI)v; +glUniform1uiv(ii*I)v; +glUniform2f(iff)v; +glUniform2fv(ii*f)v; +glUniform2i(iii)v; +glUniform2iv(ii*i)v; +glUniform2ui(iII)v; +glUniform2uiv(ii*I)v; +glUniform3f(ifff)v; +glUniform3fv(ii*f)v; +glUniform3i(iiii)v; +glUniform3iv(ii*i)v; +glUniform3ui(iIII)v; +glUniform3uiv(ii*I)v; +glUniform4f(iffff)v; +glUniform4fv(ii*f)v; +glUniform4i(iiiii)v; +glUniform4iv(ii*i)v; +glUniform4ui(iIIII)v; +glUniform4uiv(ii*I)v; +glUniformBlockBinding(III)v; +glUniformMatrix2fv(iiC*f)v; +glUniformMatrix2x3fv(iiC*f)v; +glUniformMatrix2x4fv(iiC*f)v; +glUniformMatrix3fv(iiC*f)v; +glUniformMatrix3x2fv(iiC*f)v; +glUniformMatrix3x4fv(iiC*f)v; +glUniformMatrix4fv(iiC*f)v; +glUniformMatrix4x2fv(iiC*f)v; +glUniformMatrix4x3fv(iiC*f)v; +glUnmapBuffer(I)C; +glUseProgram(I)v; +glValidateProgram(I)v; +glVertexAttrib1d(Id)v; +glVertexAttrib1dv(I*d)v; +glVertexAttrib1f(If)v; +glVertexAttrib1fv(I*f)v; +glVertexAttrib1s(Is)v; +glVertexAttrib1sv(I*s)v; +glVertexAttrib2d(Idd)v; +glVertexAttrib2dv(I*d)v; +glVertexAttrib2f(Iff)v; +glVertexAttrib2fv(I*f)v; +glVertexAttrib2s(Iss)v; +glVertexAttrib2sv(I*s)v; +glVertexAttrib3d(Iddd)v; +glVertexAttrib3dv(I*d)v; +glVertexAttrib3f(Ifff)v; +glVertexAttrib3fv(I*f)v; +glVertexAttrib3s(Isss)v; +glVertexAttrib3sv(I*s)v; +glVertexAttrib4Nbv(I*c)v; +glVertexAttrib4Niv(I*i)v; +glVertexAttrib4Nsv(I*s)v; +glVertexAttrib4Nub(ICCCC)v; +glVertexAttrib4Nubv(I*C)v; +glVertexAttrib4Nuiv(I*I)v; +glVertexAttrib4Nusv(I*S)v; +glVertexAttrib4bv(I*c)v; +glVertexAttrib4d(Idddd)v; +glVertexAttrib4dv(I*d)v; +glVertexAttrib4f(Iffff)v; +glVertexAttrib4fv(I*f)v; +glVertexAttrib4iv(I*i)v; +glVertexAttrib4s(Issss)v; +glVertexAttrib4sv(I*s)v; +glVertexAttrib4ubv(I*C)v; +glVertexAttrib4uiv(I*I)v; +glVertexAttrib4usv(I*S)v; +glVertexAttribI1i(Ii)v; +glVertexAttribI1iv(I*i)v; +glVertexAttribI1ui(II)v; +glVertexAttribI1uiv(I*I)v; +glVertexAttribI2i(Iii)v; +glVertexAttribI2iv(I*i)v; +glVertexAttribI2ui(III)v; +glVertexAttribI2uiv(I*I)v; +glVertexAttribI3i(Iiii)v; +glVertexAttribI3iv(I*i)v; +glVertexAttribI3ui(IIII)v; +glVertexAttribI3uiv(I*I)v; +glVertexAttribI4bv(I*c)v; +glVertexAttribI4i(Iiiii)v; +glVertexAttribI4iv(I*i)v; +glVertexAttribI4sv(I*s)v; +glVertexAttribI4ubv(I*C)v; +glVertexAttribI4ui(IIIII)v; +glVertexAttribI4uiv(I*I)v; +glVertexAttribI4usv(I*S)v; +glVertexAttribIPointer(IiIi*v)v; +glVertexAttribPointer(IiICi*v)v; +glViewport(iiii)v; +glWaitSync(*<__GLsync>IL)v; +. +:const +GL_ACTIVE_ATTRIBUTES=0x8B89 +GL_ACTIVE_ATTRIBUTE_MAX_LENGTH=0x8B8A +GL_ACTIVE_TEXTURE=0x84E0 +GL_ACTIVE_UNIFORMS=0x8B86 +GL_ACTIVE_UNIFORM_BLOCKS=0x8A36 +GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH=0x8A35 +GL_ACTIVE_UNIFORM_MAX_LENGTH=0x8B87 +GL_ALIASED_LINE_WIDTH_RANGE=0x846E +GL_ALPHA=0x1906 +GL_ALREADY_SIGNALED=0x911A +GL_ALWAYS=0x0207 +GL_AND=0x1501 +GL_AND_INVERTED=0x1504 +GL_AND_REVERSE=0x1502 +GL_ARB_copy_buffer=1 +GL_ARB_depth_buffer_float=1 +GL_ARB_depth_clamp=1 +GL_ARB_draw_buffers_blend=1 +GL_ARB_draw_elements_base_vertex=1 +GL_ARB_fragment_coord_conventions=1 +GL_ARB_framebuffer_object=1 +GL_ARB_framebuffer_sRGB=1 +GL_ARB_half_float_vertex=1 +GL_ARB_map_buffer_range=1 +GL_ARB_provoking_vertex=1 +GL_ARB_sample_shading=1 +GL_ARB_seamless_cube_map=1 +GL_ARB_sync=1 +GL_ARB_texture_compression_rgtc=1 +GL_ARB_texture_cube_map_array=1 +GL_ARB_texture_gather=1 +GL_ARB_texture_multisample=1 +GL_ARB_texture_query_lod=1 +GL_ARB_texture_rg=1 +GL_ARB_uniform_buffer_object=1 +GL_ARB_vertex_array_bgra=1 +GL_ARB_vertex_array_object=1 +GL_ARRAY_BUFFER=0x8892 +GL_ARRAY_BUFFER_BINDING=0x8894 +GL_ATTACHED_SHADERS=0x8B85 +GL_BACK=0x0405 +GL_BACK_LEFT=0x0402 +GL_BACK_RIGHT=0x0403 +GL_BGR=0x80E0 +GL_BGRA=0x80E1 +GL_BGRA_INTEGER=0x8D9B +GL_BGR_INTEGER=0x8D9A +GL_BLEND=0x0BE2 +GL_BLEND_COLOR=0x8005 +GL_BLEND_DST=0x0BE0 +GL_BLEND_DST_ALPHA=0x80CA +GL_BLEND_DST_RGB=0x80C8 +GL_BLEND_EQUATION=0x8009 +GL_BLEND_EQUATION_ALPHA=0x883D +GL_BLEND_EQUATION_RGB=0x8009 +GL_BLEND_SRC=0x0BE1 +GL_BLEND_SRC_ALPHA=0x80CB +GL_BLEND_SRC_RGB=0x80C9 +GL_BLUE=0x1905 +GL_BLUE_INTEGER=0x8D96 +GL_BOOL=0x8B56 +GL_BOOL_VEC2=0x8B57 +GL_BOOL_VEC3=0x8B58 +GL_BOOL_VEC4=0x8B59 +GL_BUFFER_ACCESS=0x88BB +GL_BUFFER_ACCESS_FLAGS=0x911F +GL_BUFFER_MAPPED=0x88BC +GL_BUFFER_MAP_LENGTH=0x9120 +GL_BUFFER_MAP_OFFSET=0x9121 +GL_BUFFER_MAP_POINTER=0x88BD +GL_BUFFER_SIZE=0x8764 +GL_BUFFER_USAGE=0x8765 +GL_BYTE=0x1400 +GL_CCW=0x0901 +GL_CLAMP_READ_COLOR=0x891C +GL_CLAMP_TO_BORDER=0x812D +GL_CLAMP_TO_EDGE=0x812F +GL_CLEAR=0x1500 +GL_CLIP_DISTANCE0=0x3000 +GL_CLIP_DISTANCE1=0x3001 +GL_CLIP_DISTANCE2=0x3002 +GL_CLIP_DISTANCE3=0x3003 +GL_CLIP_DISTANCE4=0x3004 +GL_CLIP_DISTANCE5=0x3005 +GL_CLIP_DISTANCE6=0x3006 +GL_CLIP_DISTANCE7=0x3007 +GL_COLOR=0x1800 +GL_COLOR_ATTACHMENT0=0x8CE0 +GL_COLOR_ATTACHMENT10=0x8CEA +GL_COLOR_ATTACHMENT11=0x8CEB +GL_COLOR_ATTACHMENT12=0x8CEC +GL_COLOR_ATTACHMENT13=0x8CED +GL_COLOR_ATTACHMENT14=0x8CEE +GL_COLOR_ATTACHMENT15=0x8CEF +GL_COLOR_ATTACHMENT1=0x8CE1 +GL_COLOR_ATTACHMENT2=0x8CE2 +GL_COLOR_ATTACHMENT3=0x8CE3 +GL_COLOR_ATTACHMENT4=0x8CE4 +GL_COLOR_ATTACHMENT5=0x8CE5 +GL_COLOR_ATTACHMENT6=0x8CE6 +GL_COLOR_ATTACHMENT7=0x8CE7 +GL_COLOR_ATTACHMENT8=0x8CE8 +GL_COLOR_ATTACHMENT9=0x8CE9 +GL_COLOR_BUFFER_BIT=0x00004000 +GL_COLOR_CLEAR_VALUE=0x0C22 +GL_COLOR_LOGIC_OP=0x0BF2 +GL_COLOR_WRITEMASK=0x0C23 +GL_COMPARE_REF_TO_TEXTURE=0x884E +GL_COMPILE_STATUS=0x8B81 +GL_COMPRESSED_RED=0x8225 +GL_COMPRESSED_RED_RGTC1=0x8DBB +GL_COMPRESSED_RG=0x8226 +GL_COMPRESSED_RGB=0x84ED +GL_COMPRESSED_RGBA=0x84EE +GL_COMPRESSED_RG_RGTC2=0x8DBD +GL_COMPRESSED_SIGNED_RED_RGTC1=0x8DBC +GL_COMPRESSED_SIGNED_RG_RGTC2=0x8DBE +GL_COMPRESSED_SRGB=0x8C48 +GL_COMPRESSED_SRGB_ALPHA=0x8C49 +GL_COMPRESSED_TEXTURE_FORMATS=0x86A3 +GL_CONDITION_SATISFIED=0x911C +GL_CONSTANT_ALPHA=0x8003 +GL_CONSTANT_COLOR=0x8001 +GL_CONTEXT_COMPATIBILITY_PROFILE_BIT=0x00000002 +GL_CONTEXT_CORE_PROFILE_BIT=0x00000001 +GL_CONTEXT_FLAGS=0x821E +GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT=0x0001 +GL_CONTEXT_PROFILE_MASK=0x9126 +GL_COPY=0x1503 +GL_COPY_INVERTED=0x150C +GL_COPY_READ_BUFFER=0x8F36 +GL_COPY_WRITE_BUFFER=0x8F37 +GL_CULL_FACE=0x0B44 +GL_CULL_FACE_MODE=0x0B45 +GL_CURRENT_PROGRAM=0x8B8D +GL_CURRENT_QUERY=0x8865 +GL_CURRENT_VERTEX_ATTRIB=0x8626 +GL_CW=0x0900 +GL_DECR=0x1E03 +GL_DECR_WRAP=0x8508 +GL_DELETE_STATUS=0x8B80 +GL_DEPTH24_STENCIL8=0x88F0 +GL_DEPTH32F_STENCIL8=0x8CAD +GL_DEPTH=0x1801 +GL_DEPTH_ATTACHMENT=0x8D00 +GL_DEPTH_BUFFER=0x8223 +GL_DEPTH_BUFFER_BIT=0x00000100 +GL_DEPTH_CLAMP=0x864F +GL_DEPTH_CLEAR_VALUE=0x0B73 +GL_DEPTH_COMPONENT16=0x81A5 +GL_DEPTH_COMPONENT24=0x81A6 +GL_DEPTH_COMPONENT32=0x81A7 +GL_DEPTH_COMPONENT32F=0x8CAC +GL_DEPTH_COMPONENT=0x1902 +GL_DEPTH_FUNC=0x0B74 +GL_DEPTH_RANGE=0x0B70 +GL_DEPTH_STENCIL=0x84F9 +GL_DEPTH_STENCIL_ATTACHMENT=0x821A +GL_DEPTH_TEST=0x0B71 +GL_DEPTH_WRITEMASK=0x0B72 +GL_DITHER=0x0BD0 +GL_DONT_CARE=0x1100 +GL_DOUBLE=0x140A +GL_DOUBLEBUFFER=0x0C32 +GL_DRAW_BUFFER0=0x8825 +GL_DRAW_BUFFER10=0x882F +GL_DRAW_BUFFER11=0x8830 +GL_DRAW_BUFFER12=0x8831 +GL_DRAW_BUFFER13=0x8832 +GL_DRAW_BUFFER14=0x8833 +GL_DRAW_BUFFER15=0x8834 +GL_DRAW_BUFFER1=0x8826 +GL_DRAW_BUFFER2=0x8827 +GL_DRAW_BUFFER3=0x8828 +GL_DRAW_BUFFER4=0x8829 +GL_DRAW_BUFFER5=0x882A +GL_DRAW_BUFFER6=0x882B +GL_DRAW_BUFFER7=0x882C +GL_DRAW_BUFFER8=0x882D +GL_DRAW_BUFFER9=0x882E +GL_DRAW_BUFFER=0x0C01 +GL_DRAW_FRAMEBUFFER=0x8CA9 +GL_DRAW_FRAMEBUFFER_BINDING=0x8CA6 +GL_DST_ALPHA=0x0304 +GL_DST_COLOR=0x0306 +GL_DYNAMIC_COPY=0x88EA +GL_DYNAMIC_DRAW=0x88E8 +GL_DYNAMIC_READ=0x88E9 +GL_ELEMENT_ARRAY_BUFFER=0x8893 +GL_ELEMENT_ARRAY_BUFFER_BINDING=0x8895 +GL_EQUAL=0x0202 +GL_EQUIV=0x1509 +GL_EXTENSIONS=0x1F03 +GL_FALSE=0 +GL_FASTEST=0x1101 +GL_FILL=0x1B02 +GL_FIRST_VERTEX_CONVENTION=0x8E4D +GL_FIXED_ONLY=0x891D +GL_FLOAT=0x1406 +GL_FLOAT_32_UNSIGNED_INT_24_8_REV=0x8DAD +GL_FLOAT_MAT2=0x8B5A +GL_FLOAT_MAT2x3=0x8B65 +GL_FLOAT_MAT2x4=0x8B66 +GL_FLOAT_MAT3=0x8B5B +GL_FLOAT_MAT3x2=0x8B67 +GL_FLOAT_MAT3x4=0x8B68 +GL_FLOAT_MAT4=0x8B5C +GL_FLOAT_MAT4x2=0x8B69 +GL_FLOAT_MAT4x3=0x8B6A +GL_FLOAT_VEC2=0x8B50 +GL_FLOAT_VEC3=0x8B51 +GL_FLOAT_VEC4=0x8B52 +GL_FRAGMENT_SHADER=0x8B30 +GL_FRAGMENT_SHADER_DERIVATIVE_HINT=0x8B8B +GL_FRAMEBUFFER=0x8D40 +GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE=0x8215 +GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE=0x8214 +GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING=0x8210 +GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE=0x8211 +GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE=0x8216 +GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE=0x8213 +GL_FRAMEBUFFER_ATTACHMENT_LAYERED=0x8DA7 +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME=0x8CD1 +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE=0x8CD0 +GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE=0x8212 +GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE=0x8217 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE=0x8CD3 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER=0x8CD4 +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL=0x8CD2 +GL_FRAMEBUFFER_BINDING=0x8CA6 +GL_FRAMEBUFFER_COMPLETE=0x8CD5 +GL_FRAMEBUFFER_DEFAULT=0x8218 +GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT=0x8CD6 +GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER=0x8CDB +GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS=0x8DA8 +GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT=0x8CD7 +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE=0x8D56 +GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER=0x8CDC +GL_FRAMEBUFFER_SRGB=0x8DB9 +GL_FRAMEBUFFER_UNDEFINED=0x8219 +GL_FRAMEBUFFER_UNSUPPORTED=0x8CDD +GL_FRONT=0x0404 +GL_FRONT_AND_BACK=0x0408 +GL_FRONT_FACE=0x0B46 +GL_FRONT_LEFT=0x0400 +GL_FRONT_RIGHT=0x0401 +GL_FUNC_ADD=0x8006 +GL_FUNC_REVERSE_SUBTRACT=0x800B +GL_FUNC_SUBTRACT=0x800A +GL_GEOMETRY_INPUT_TYPE=0x8917 +GL_GEOMETRY_OUTPUT_TYPE=0x8918 +GL_GEOMETRY_SHADER=0x8DD9 +GL_GEOMETRY_VERTICES_OUT=0x8916 +GL_GEQUAL=0x0206 +GL_GREATER=0x0204 +GL_GREEN=0x1904 +GL_GREEN_INTEGER=0x8D95 +GL_HALF_FLOAT=0x140B +GL_INCR=0x1E02 +GL_INCR_WRAP=0x8507 +GL_INFO_LOG_LENGTH=0x8B84 +GL_INT=0x1404 +GL_INTERLEAVED_ATTRIBS=0x8C8C +GL_INT_SAMPLER_1D=0x8DC9 +GL_INT_SAMPLER_1D_ARRAY=0x8DCE +GL_INT_SAMPLER_2D=0x8DCA +GL_INT_SAMPLER_2D_ARRAY=0x8DCF +GL_INT_SAMPLER_2D_MULTISAMPLE=0x9109 +GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY=0x910C +GL_INT_SAMPLER_2D_RECT=0x8DCD +GL_INT_SAMPLER_3D=0x8DCB +GL_INT_SAMPLER_BUFFER=0x8DD0 +GL_INT_SAMPLER_CUBE=0x8DCC +GL_INT_SAMPLER_CUBE_MAP_ARRAY=0x900E +GL_INT_VEC2=0x8B53 +GL_INT_VEC3=0x8B54 +GL_INT_VEC4=0x8B55 +GL_INVALID_ENUM=0x0500 +GL_INVALID_FRAMEBUFFER_OPERATION=0x0506 +GL_INVALID_INDEX=0xFFFFFFFF +GL_INVALID_OPERATION=0x0502 +GL_INVALID_VALUE=0x0501 +GL_INVERT=0x150A +GL_KEEP=0x1E00 +GL_LAST_VERTEX_CONVENTION=0x8E4E +GL_LEFT=0x0406 +GL_LEQUAL=0x0203 +GL_LESS=0x0201 +GL_LINE=0x1B01 +GL_LINEAR=0x2601 +GL_LINEAR_MIPMAP_LINEAR=0x2703 +GL_LINEAR_MIPMAP_NEAREST=0x2701 +GL_LINES=0x0001 +GL_LINES_ADJACENCY=0x000A +GL_LINE_LOOP=0x0002 +GL_LINE_SMOOTH=0x0B20 +GL_LINE_SMOOTH_HINT=0x0C52 +GL_LINE_STRIP=0x0003 +GL_LINE_STRIP_ADJACENCY=0x000B +GL_LINE_WIDTH=0x0B21 +GL_LINE_WIDTH_GRANULARITY=0x0B23 +GL_LINE_WIDTH_RANGE=0x0B22 +GL_LINK_STATUS=0x8B82 +GL_LOGIC_OP_MODE=0x0BF0 +GL_LOWER_LEFT=0x8CA1 +GL_MAJOR_VERSION=0x821B +GL_MAP_FLUSH_EXPLICIT_BIT=0x0010 +GL_MAP_INVALIDATE_BUFFER_BIT=0x0008 +GL_MAP_INVALIDATE_RANGE_BIT=0x0004 +GL_MAP_READ_BIT=0x0001 +GL_MAP_UNSYNCHRONIZED_BIT=0x0020 +GL_MAP_WRITE_BIT=0x0002 +GL_MAX=0x8008 +GL_MAX_3D_TEXTURE_SIZE=0x8073 +GL_MAX_ARRAY_TEXTURE_LAYERS=0x88FF +GL_MAX_CLIP_DISTANCES=0x0D32 +GL_MAX_COLOR_ATTACHMENTS=0x8CDF +GL_MAX_COLOR_TEXTURE_SAMPLES=0x910E +GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS=0x8A33 +GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS=0x8A32 +GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS=0x8B4D +GL_MAX_COMBINED_UNIFORM_BLOCKS=0x8A2E +GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS=0x8A31 +GL_MAX_CUBE_MAP_TEXTURE_SIZE=0x851C +GL_MAX_DEPTH_TEXTURE_SAMPLES=0x910F +GL_MAX_DRAW_BUFFERS=0x8824 +GL_MAX_ELEMENTS_INDICES=0x80E9 +GL_MAX_ELEMENTS_VERTICES=0x80E8 +GL_MAX_FRAGMENT_INPUT_COMPONENTS=0x9125 +GL_MAX_FRAGMENT_UNIFORM_BLOCKS=0x8A2D +GL_MAX_FRAGMENT_UNIFORM_COMPONENTS=0x8B49 +GL_MAX_GEOMETRY_INPUT_COMPONENTS=0x9123 +GL_MAX_GEOMETRY_OUTPUT_COMPONENTS=0x9124 +GL_MAX_GEOMETRY_OUTPUT_VERTICES=0x8DE0 +GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS=0x8C29 +GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS=0x8DE1 +GL_MAX_GEOMETRY_UNIFORM_BLOCKS=0x8A2C +GL_MAX_GEOMETRY_UNIFORM_COMPONENTS=0x8DDF +GL_MAX_INTEGER_SAMPLES=0x9110 +GL_MAX_PROGRAM_TEXEL_OFFSET=0x8905 +GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS=0x8F9F +GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET=0x8E5F +GL_MAX_RECTANGLE_TEXTURE_SIZE=0x84F8 +GL_MAX_RENDERBUFFER_SIZE=0x84E8 +GL_MAX_SAMPLES=0x8D57 +GL_MAX_SAMPLE_MASK_WORDS=0x8E59 +GL_MAX_SERVER_WAIT_TIMEOUT=0x9111 +GL_MAX_TEXTURE_BUFFER_SIZE=0x8C2B +GL_MAX_TEXTURE_IMAGE_UNITS=0x8872 +GL_MAX_TEXTURE_LOD_BIAS=0x84FD +GL_MAX_TEXTURE_SIZE=0x0D33 +GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS=0x8C8A +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS=0x8C8B +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS=0x8C80 +GL_MAX_UNIFORM_BLOCK_SIZE=0x8A30 +GL_MAX_UNIFORM_BUFFER_BINDINGS=0x8A2F +GL_MAX_VARYING_COMPONENTS=0x8B4B +GL_MAX_VARYING_FLOATS=0x8B4B +GL_MAX_VERTEX_ATTRIBS=0x8869 +GL_MAX_VERTEX_OUTPUT_COMPONENTS=0x9122 +GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS=0x8B4C +GL_MAX_VERTEX_UNIFORM_BLOCKS=0x8A2B +GL_MAX_VERTEX_UNIFORM_COMPONENTS=0x8B4A +GL_MAX_VIEWPORT_DIMS=0x0D3A +GL_MIN=0x8007 +GL_MINOR_VERSION=0x821C +GL_MIN_PROGRAM_TEXEL_OFFSET=0x8904 +GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET=0x8E5E +GL_MIN_SAMPLE_SHADING_VALUE=0x8C37 +GL_MIRRORED_REPEAT=0x8370 +GL_MULTISAMPLE=0x809D +GL_NAND=0x150E +GL_NEAREST=0x2600 +GL_NEAREST_MIPMAP_LINEAR=0x2702 +GL_NEAREST_MIPMAP_NEAREST=0x2700 +GL_NEVER=0x0200 +GL_NICEST=0x1102 +GL_NONE=0 +GL_NOOP=0x1505 +GL_NOR=0x1508 +GL_NOTEQUAL=0x0205 +GL_NO_ERROR=0 +GL_NUM_COMPRESSED_TEXTURE_FORMATS=0x86A2 +GL_NUM_EXTENSIONS=0x821D +GL_OBJECT_TYPE=0x9112 +GL_ONE=1 +GL_ONE_MINUS_CONSTANT_ALPHA=0x8004 +GL_ONE_MINUS_CONSTANT_COLOR=0x8002 +GL_ONE_MINUS_DST_ALPHA=0x0305 +GL_ONE_MINUS_DST_COLOR=0x0307 +GL_ONE_MINUS_SRC_ALPHA=0x0303 +GL_ONE_MINUS_SRC_COLOR=0x0301 +GL_OR=0x1507 +GL_OR_INVERTED=0x150D +GL_OR_REVERSE=0x150B +GL_OUT_OF_MEMORY=0x0505 +GL_PACK_ALIGNMENT=0x0D05 +GL_PACK_IMAGE_HEIGHT=0x806C +GL_PACK_LSB_FIRST=0x0D01 +GL_PACK_ROW_LENGTH=0x0D02 +GL_PACK_SKIP_IMAGES=0x806B +GL_PACK_SKIP_PIXELS=0x0D04 +GL_PACK_SKIP_ROWS=0x0D03 +GL_PACK_SWAP_BYTES=0x0D00 +GL_PIXEL_PACK_BUFFER=0x88EB +GL_PIXEL_PACK_BUFFER_BINDING=0x88ED +GL_PIXEL_UNPACK_BUFFER=0x88EC +GL_PIXEL_UNPACK_BUFFER_BINDING=0x88EF +GL_POINT=0x1B00 +GL_POINTS=0x0000 +GL_POINT_FADE_THRESHOLD_SIZE=0x8128 +GL_POINT_SIZE=0x0B11 +GL_POINT_SIZE_GRANULARITY=0x0B13 +GL_POINT_SIZE_RANGE=0x0B12 +GL_POINT_SPRITE_COORD_ORIGIN=0x8CA0 +GL_POLYGON_OFFSET_FACTOR=0x8038 +GL_POLYGON_OFFSET_FILL=0x8037 +GL_POLYGON_OFFSET_LINE=0x2A02 +GL_POLYGON_OFFSET_POINT=0x2A01 +GL_POLYGON_OFFSET_UNITS=0x2A00 +GL_POLYGON_SMOOTH=0x0B41 +GL_POLYGON_SMOOTH_HINT=0x0C53 +GL_PRIMITIVES_GENERATED=0x8C87 +GL_PRIMITIVE_RESTART=0x8F9D +GL_PRIMITIVE_RESTART_INDEX=0x8F9E +GL_PROGRAM_POINT_SIZE=0x8642 +GL_PROVOKING_VERTEX=0x8E4F +GL_PROXY_TEXTURE_1D=0x8063 +GL_PROXY_TEXTURE_1D_ARRAY=0x8C19 +GL_PROXY_TEXTURE_2D=0x8064 +GL_PROXY_TEXTURE_2D_ARRAY=0x8C1B +GL_PROXY_TEXTURE_2D_MULTISAMPLE=0x9101 +GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY=0x9103 +GL_PROXY_TEXTURE_3D=0x8070 +GL_PROXY_TEXTURE_CUBE_MAP=0x851B +GL_PROXY_TEXTURE_CUBE_MAP_ARRAY=0x900B +GL_PROXY_TEXTURE_RECTANGLE=0x84F7 +GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION=0x8E4C +GL_QUERY_BY_REGION_NO_WAIT=0x8E16 +GL_QUERY_BY_REGION_WAIT=0x8E15 +GL_QUERY_COUNTER_BITS=0x8864 +GL_QUERY_NO_WAIT=0x8E14 +GL_QUERY_RESULT=0x8866 +GL_QUERY_RESULT_AVAILABLE=0x8867 +GL_QUERY_WAIT=0x8E13 +GL_R11F_G11F_B10F=0x8C3A +GL_R16=0x822A +GL_R16F=0x822D +GL_R16I=0x8233 +GL_R16UI=0x8234 +GL_R16_SNORM=0x8F98 +GL_R32F=0x822E +GL_R32I=0x8235 +GL_R32UI=0x8236 +GL_R3_G3_B2=0x2A10 +GL_R8=0x8229 +GL_R8I=0x8231 +GL_R8UI=0x8232 +GL_R8_SNORM=0x8F94 +GL_RASTERIZER_DISCARD=0x8C89 +GL_READ_BUFFER=0x0C02 +GL_READ_FRAMEBUFFER=0x8CA8 +GL_READ_FRAMEBUFFER_BINDING=0x8CAA +GL_READ_ONLY=0x88B8 +GL_READ_WRITE=0x88BA +GL_RED=0x1903 +GL_RED_INTEGER=0x8D94 +GL_RED_SNORM=0x8F90 +GL_RENDERBUFFER=0x8D41 +GL_RENDERBUFFER_ALPHA_SIZE=0x8D53 +GL_RENDERBUFFER_BINDING=0x8CA7 +GL_RENDERBUFFER_BLUE_SIZE=0x8D52 +GL_RENDERBUFFER_DEPTH_SIZE=0x8D54 +GL_RENDERBUFFER_GREEN_SIZE=0x8D51 +GL_RENDERBUFFER_HEIGHT=0x8D43 +GL_RENDERBUFFER_INTERNAL_FORMAT=0x8D44 +GL_RENDERBUFFER_RED_SIZE=0x8D50 +GL_RENDERBUFFER_SAMPLES=0x8CAB +GL_RENDERBUFFER_STENCIL_SIZE=0x8D55 +GL_RENDERBUFFER_WIDTH=0x8D42 +GL_RENDERER=0x1F01 +GL_REPEAT=0x2901 +GL_REPLACE=0x1E01 +GL_RG16=0x822C +GL_RG16F=0x822F +GL_RG16I=0x8239 +GL_RG16UI=0x823A +GL_RG16_SNORM=0x8F99 +GL_RG32F=0x8230 +GL_RG32I=0x823B +GL_RG32UI=0x823C +GL_RG8=0x822B +GL_RG8I=0x8237 +GL_RG8UI=0x8238 +GL_RG8_SNORM=0x8F95 +GL_RG=0x8227 +GL_RGB10=0x8052 +GL_RGB10_A2=0x8059 +GL_RGB12=0x8053 +GL_RGB16=0x8054 +GL_RGB16F=0x881B +GL_RGB16I=0x8D89 +GL_RGB16UI=0x8D77 +GL_RGB16_SNORM=0x8F9A +GL_RGB32F=0x8815 +GL_RGB32I=0x8D83 +GL_RGB32UI=0x8D71 +GL_RGB4=0x804F +GL_RGB5=0x8050 +GL_RGB5_A1=0x8057 +GL_RGB8=0x8051 +GL_RGB8I=0x8D8F +GL_RGB8UI=0x8D7D +GL_RGB8_SNORM=0x8F96 +GL_RGB9_E5=0x8C3D +GL_RGB=0x1907 +GL_RGBA12=0x805A +GL_RGBA16=0x805B +GL_RGBA16F=0x881A +GL_RGBA16I=0x8D88 +GL_RGBA16UI=0x8D76 +GL_RGBA16_SNORM=0x8F9B +GL_RGBA2=0x8055 +GL_RGBA32F=0x8814 +GL_RGBA32I=0x8D82 +GL_RGBA32UI=0x8D70 +GL_RGBA4=0x8056 +GL_RGBA8=0x8058 +GL_RGBA8I=0x8D8E +GL_RGBA8UI=0x8D7C +GL_RGBA8_SNORM=0x8F97 +GL_RGBA=0x1908 +GL_RGBA_INTEGER=0x8D99 +GL_RGBA_SNORM=0x8F93 +GL_RGB_INTEGER=0x8D98 +GL_RGB_SNORM=0x8F92 +GL_RG_INTEGER=0x8228 +GL_RG_SNORM=0x8F91 +GL_RIGHT=0x0407 +GL_SAMPLER_1D=0x8B5D +GL_SAMPLER_1D_ARRAY=0x8DC0 +GL_SAMPLER_1D_ARRAY_SHADOW=0x8DC3 +GL_SAMPLER_1D_SHADOW=0x8B61 +GL_SAMPLER_2D=0x8B5E +GL_SAMPLER_2D_ARRAY=0x8DC1 +GL_SAMPLER_2D_ARRAY_SHADOW=0x8DC4 +GL_SAMPLER_2D_MULTISAMPLE=0x9108 +GL_SAMPLER_2D_MULTISAMPLE_ARRAY=0x910B +GL_SAMPLER_2D_RECT=0x8B63 +GL_SAMPLER_2D_RECT_SHADOW=0x8B64 +GL_SAMPLER_2D_SHADOW=0x8B62 +GL_SAMPLER_3D=0x8B5F +GL_SAMPLER_BUFFER=0x8DC2 +GL_SAMPLER_CUBE=0x8B60 +GL_SAMPLER_CUBE_MAP_ARRAY=0x900C +GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW=0x900D +GL_SAMPLER_CUBE_SHADOW=0x8DC5 +GL_SAMPLES=0x80A9 +GL_SAMPLES_PASSED=0x8914 +GL_SAMPLE_ALPHA_TO_COVERAGE=0x809E +GL_SAMPLE_ALPHA_TO_ONE=0x809F +GL_SAMPLE_BUFFERS=0x80A8 +GL_SAMPLE_COVERAGE=0x80A0 +GL_SAMPLE_COVERAGE_INVERT=0x80AB +GL_SAMPLE_COVERAGE_VALUE=0x80AA +GL_SAMPLE_MASK=0x8E51 +GL_SAMPLE_MASK_VALUE=0x8E52 +GL_SAMPLE_POSITION=0x8E50 +GL_SAMPLE_SHADING=0x8C36 +GL_SCISSOR_BOX=0x0C10 +GL_SCISSOR_TEST=0x0C11 +GL_SEPARATE_ATTRIBS=0x8C8D +GL_SET=0x150F +GL_SHADER_SOURCE_LENGTH=0x8B88 +GL_SHADER_TYPE=0x8B4F +GL_SHADING_LANGUAGE_VERSION=0x8B8C +GL_SHORT=0x1402 +GL_SIGNALED=0x9119 +GL_SIGNED_NORMALIZED=0x8F9C +GL_SMOOTH_LINE_WIDTH_GRANULARITY=0x0B23 +GL_SMOOTH_LINE_WIDTH_RANGE=0x0B22 +GL_SMOOTH_POINT_SIZE_GRANULARITY=0x0B13 +GL_SMOOTH_POINT_SIZE_RANGE=0x0B12 +GL_SRC_ALPHA=0x0302 +GL_SRC_ALPHA_SATURATE=0x0308 +GL_SRC_COLOR=0x0300 +GL_SRGB8=0x8C41 +GL_SRGB8_ALPHA8=0x8C43 +GL_SRGB=0x8C40 +GL_SRGB_ALPHA=0x8C42 +GL_STATIC_COPY=0x88E6 +GL_STATIC_DRAW=0x88E4 +GL_STATIC_READ=0x88E5 +GL_STENCIL=0x1802 +GL_STENCIL_ATTACHMENT=0x8D20 +GL_STENCIL_BACK_FAIL=0x8801 +GL_STENCIL_BACK_FUNC=0x8800 +GL_STENCIL_BACK_PASS_DEPTH_FAIL=0x8802 +GL_STENCIL_BACK_PASS_DEPTH_PASS=0x8803 +GL_STENCIL_BACK_REF=0x8CA3 +GL_STENCIL_BACK_VALUE_MASK=0x8CA4 +GL_STENCIL_BACK_WRITEMASK=0x8CA5 +GL_STENCIL_BUFFER=0x8224 +GL_STENCIL_BUFFER_BIT=0x00000400 +GL_STENCIL_CLEAR_VALUE=0x0B91 +GL_STENCIL_FAIL=0x0B94 +GL_STENCIL_FUNC=0x0B92 +GL_STENCIL_INDEX16=0x8D49 +GL_STENCIL_INDEX1=0x8D46 +GL_STENCIL_INDEX4=0x8D47 +GL_STENCIL_INDEX8=0x8D48 +GL_STENCIL_INDEX=0x1901 +GL_STENCIL_PASS_DEPTH_FAIL=0x0B95 +GL_STENCIL_PASS_DEPTH_PASS=0x0B96 +GL_STENCIL_REF=0x0B97 +GL_STENCIL_TEST=0x0B90 +GL_STENCIL_VALUE_MASK=0x0B93 +GL_STENCIL_WRITEMASK=0x0B98 +GL_STEREO=0x0C33 +GL_STREAM_COPY=0x88E2 +GL_STREAM_DRAW=0x88E0 +GL_STREAM_READ=0x88E1 +GL_SUBPIXEL_BITS=0x0D50 +GL_SYNC_CONDITION=0x9113 +GL_SYNC_FENCE=0x9116 +GL_SYNC_FLAGS=0x9115 +GL_SYNC_FLUSH_COMMANDS_BIT=0x00000001 +GL_SYNC_GPU_COMMANDS_COMPLETE=0x9117 +GL_SYNC_STATUS=0x9114 +GL_TEXTURE0=0x84C0 +GL_TEXTURE10=0x84CA +GL_TEXTURE11=0x84CB +GL_TEXTURE12=0x84CC +GL_TEXTURE13=0x84CD +GL_TEXTURE14=0x84CE +GL_TEXTURE15=0x84CF +GL_TEXTURE16=0x84D0 +GL_TEXTURE17=0x84D1 +GL_TEXTURE18=0x84D2 +GL_TEXTURE19=0x84D3 +GL_TEXTURE1=0x84C1 +GL_TEXTURE20=0x84D4 +GL_TEXTURE21=0x84D5 +GL_TEXTURE22=0x84D6 +GL_TEXTURE23=0x84D7 +GL_TEXTURE24=0x84D8 +GL_TEXTURE25=0x84D9 +GL_TEXTURE26=0x84DA +GL_TEXTURE27=0x84DB +GL_TEXTURE28=0x84DC +GL_TEXTURE29=0x84DD +GL_TEXTURE2=0x84C2 +GL_TEXTURE30=0x84DE +GL_TEXTURE31=0x84DF +GL_TEXTURE3=0x84C3 +GL_TEXTURE4=0x84C4 +GL_TEXTURE5=0x84C5 +GL_TEXTURE6=0x84C6 +GL_TEXTURE7=0x84C7 +GL_TEXTURE8=0x84C8 +GL_TEXTURE9=0x84C9 +GL_TEXTURE=0x1702 +GL_TEXTURE_1D=0x0DE0 +GL_TEXTURE_1D_ARRAY=0x8C18 +GL_TEXTURE_2D=0x0DE1 +GL_TEXTURE_2D_ARRAY=0x8C1A +GL_TEXTURE_2D_MULTISAMPLE=0x9100 +GL_TEXTURE_2D_MULTISAMPLE_ARRAY=0x9102 +GL_TEXTURE_3D=0x806F +GL_TEXTURE_ALPHA_SIZE=0x805F +GL_TEXTURE_ALPHA_TYPE=0x8C13 +GL_TEXTURE_BASE_LEVEL=0x813C +GL_TEXTURE_BINDING_1D=0x8068 +GL_TEXTURE_BINDING_1D_ARRAY=0x8C1C +GL_TEXTURE_BINDING_2D=0x8069 +GL_TEXTURE_BINDING_2D_ARRAY=0x8C1D +GL_TEXTURE_BINDING_2D_MULTISAMPLE=0x9104 +GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY=0x9105 +GL_TEXTURE_BINDING_3D=0x806A +GL_TEXTURE_BINDING_BUFFER=0x8C2C +GL_TEXTURE_BINDING_CUBE_MAP=0x8514 +GL_TEXTURE_BINDING_CUBE_MAP_ARRAY=0x900A +GL_TEXTURE_BINDING_RECTANGLE=0x84F6 +GL_TEXTURE_BLUE_SIZE=0x805E +GL_TEXTURE_BLUE_TYPE=0x8C12 +GL_TEXTURE_BORDER=0x1005 +GL_TEXTURE_BORDER_COLOR=0x1004 +GL_TEXTURE_BUFFER=0x8C2A +GL_TEXTURE_BUFFER_DATA_STORE_BINDING=0x8C2D +GL_TEXTURE_BUFFER_FORMAT=0x8C2E +GL_TEXTURE_COMPARE_FUNC=0x884D +GL_TEXTURE_COMPARE_MODE=0x884C +GL_TEXTURE_COMPRESSED=0x86A1 +GL_TEXTURE_COMPRESSED_IMAGE_SIZE=0x86A0 +GL_TEXTURE_COMPRESSION_HINT=0x84EF +GL_TEXTURE_CUBE_MAP=0x8513 +GL_TEXTURE_CUBE_MAP_ARRAY=0x9009 +GL_TEXTURE_CUBE_MAP_NEGATIVE_X=0x8516 +GL_TEXTURE_CUBE_MAP_NEGATIVE_Y=0x8518 +GL_TEXTURE_CUBE_MAP_NEGATIVE_Z=0x851A +GL_TEXTURE_CUBE_MAP_POSITIVE_X=0x8515 +GL_TEXTURE_CUBE_MAP_POSITIVE_Y=0x8517 +GL_TEXTURE_CUBE_MAP_POSITIVE_Z=0x8519 +GL_TEXTURE_CUBE_MAP_SEAMLESS=0x884F +GL_TEXTURE_DEPTH=0x8071 +GL_TEXTURE_DEPTH_SIZE=0x884A +GL_TEXTURE_DEPTH_TYPE=0x8C16 +GL_TEXTURE_FIXED_SAMPLE_LOCATIONS=0x9107 +GL_TEXTURE_GREEN_SIZE=0x805D +GL_TEXTURE_GREEN_TYPE=0x8C11 +GL_TEXTURE_HEIGHT=0x1001 +GL_TEXTURE_INTERNAL_FORMAT=0x1003 +GL_TEXTURE_LOD_BIAS=0x8501 +GL_TEXTURE_MAG_FILTER=0x2800 +GL_TEXTURE_MAX_LEVEL=0x813D +GL_TEXTURE_MAX_LOD=0x813B +GL_TEXTURE_MIN_FILTER=0x2801 +GL_TEXTURE_MIN_LOD=0x813A +GL_TEXTURE_RECTANGLE=0x84F5 +GL_TEXTURE_RED_SIZE=0x805C +GL_TEXTURE_RED_TYPE=0x8C10 +GL_TEXTURE_SAMPLES=0x9106 +GL_TEXTURE_SHARED_SIZE=0x8C3F +GL_TEXTURE_STENCIL_SIZE=0x88F1 +GL_TEXTURE_WIDTH=0x1000 +GL_TEXTURE_WRAP_R=0x8072 +GL_TEXTURE_WRAP_S=0x2802 +GL_TEXTURE_WRAP_T=0x2803 +GL_TIMEOUT_EXPIRED=0x911B +GL_TIMEOUT_IGNORED=0xFFFFFFFFFFFFFFFF +GL_TRANSFORM_FEEDBACK_BUFFER=0x8C8E +GL_TRANSFORM_FEEDBACK_BUFFER_BINDING=0x8C8F +GL_TRANSFORM_FEEDBACK_BUFFER_MODE=0x8C7F +GL_TRANSFORM_FEEDBACK_BUFFER_SIZE=0x8C85 +GL_TRANSFORM_FEEDBACK_BUFFER_START=0x8C84 +GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN=0x8C88 +GL_TRANSFORM_FEEDBACK_VARYINGS=0x8C83 +GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH=0x8C76 +GL_TRIANGLES=0x0004 +GL_TRIANGLES_ADJACENCY=0x000C +GL_TRIANGLE_FAN=0x0006 +GL_TRIANGLE_STRIP=0x0005 +GL_TRIANGLE_STRIP_ADJACENCY=0x000D +GL_TRUE=1 +GL_UNIFORM_ARRAY_STRIDE=0x8A3C +GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS=0x8A42 +GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES=0x8A43 +GL_UNIFORM_BLOCK_BINDING=0x8A3F +GL_UNIFORM_BLOCK_DATA_SIZE=0x8A40 +GL_UNIFORM_BLOCK_INDEX=0x8A3A +GL_UNIFORM_BLOCK_NAME_LENGTH=0x8A41 +GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER=0x8A46 +GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER=0x8A45 +GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER=0x8A44 +GL_UNIFORM_BUFFER=0x8A11 +GL_UNIFORM_BUFFER_BINDING=0x8A28 +GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT=0x8A34 +GL_UNIFORM_BUFFER_SIZE=0x8A2A +GL_UNIFORM_BUFFER_START=0x8A29 +GL_UNIFORM_IS_ROW_MAJOR=0x8A3E +GL_UNIFORM_MATRIX_STRIDE=0x8A3D +GL_UNIFORM_NAME_LENGTH=0x8A39 +GL_UNIFORM_OFFSET=0x8A3B +GL_UNIFORM_SIZE=0x8A38 +GL_UNIFORM_TYPE=0x8A37 +GL_UNPACK_ALIGNMENT=0x0CF5 +GL_UNPACK_IMAGE_HEIGHT=0x806E +GL_UNPACK_LSB_FIRST=0x0CF1 +GL_UNPACK_ROW_LENGTH=0x0CF2 +GL_UNPACK_SKIP_IMAGES=0x806D +GL_UNPACK_SKIP_PIXELS=0x0CF4 +GL_UNPACK_SKIP_ROWS=0x0CF3 +GL_UNPACK_SWAP_BYTES=0x0CF0 +GL_UNSIGNALED=0x9118 +GL_UNSIGNED_BYTE=0x1401 +GL_UNSIGNED_BYTE_2_3_3_REV=0x8362 +GL_UNSIGNED_BYTE_3_3_2=0x8032 +GL_UNSIGNED_INT=0x1405 +GL_UNSIGNED_INT_10F_11F_11F_REV=0x8C3B +GL_UNSIGNED_INT_10_10_10_2=0x8036 +GL_UNSIGNED_INT_24_8=0x84FA +GL_UNSIGNED_INT_2_10_10_10_REV=0x8368 +GL_UNSIGNED_INT_5_9_9_9_REV=0x8C3E +GL_UNSIGNED_INT_8_8_8_8=0x8035 +GL_UNSIGNED_INT_8_8_8_8_REV=0x8367 +GL_UNSIGNED_INT_SAMPLER_1D=0x8DD1 +GL_UNSIGNED_INT_SAMPLER_1D_ARRAY=0x8DD6 +GL_UNSIGNED_INT_SAMPLER_2D=0x8DD2 +GL_UNSIGNED_INT_SAMPLER_2D_ARRAY=0x8DD7 +GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE=0x910A +GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY=0x910D +GL_UNSIGNED_INT_SAMPLER_2D_RECT=0x8DD5 +GL_UNSIGNED_INT_SAMPLER_3D=0x8DD3 +GL_UNSIGNED_INT_SAMPLER_BUFFER=0x8DD8 +GL_UNSIGNED_INT_SAMPLER_CUBE=0x8DD4 +GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY=0x900F +GL_UNSIGNED_INT_VEC2=0x8DC6 +GL_UNSIGNED_INT_VEC3=0x8DC7 +GL_UNSIGNED_INT_VEC4=0x8DC8 +GL_UNSIGNED_NORMALIZED=0x8C17 +GL_UNSIGNED_SHORT=0x1403 +GL_UNSIGNED_SHORT_1_5_5_5_REV=0x8366 +GL_UNSIGNED_SHORT_4_4_4_4=0x8033 +GL_UNSIGNED_SHORT_4_4_4_4_REV=0x8365 +GL_UNSIGNED_SHORT_5_5_5_1=0x8034 +GL_UNSIGNED_SHORT_5_6_5=0x8363 +GL_UNSIGNED_SHORT_5_6_5_REV=0x8364 +GL_UPPER_LEFT=0x8CA2 +GL_VALIDATE_STATUS=0x8B83 +GL_VENDOR=0x1F00 +GL_VERSION=0x1F02 +GL_VERSION_1_0=1 +GL_VERSION_1_1=1 +GL_VERSION_1_2=1 +GL_VERSION_1_3=1 +GL_VERSION_1_4=1 +GL_VERSION_1_5=1 +GL_VERSION_2_0=1 +GL_VERSION_2_1=1 +GL_VERSION_3_0=1 +GL_VERSION_3_1=1 +GL_VERSION_3_2=1 +GL_VERTEX_ARRAY_BINDING=0x85B5 +GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING=0x889F +GL_VERTEX_ATTRIB_ARRAY_ENABLED=0x8622 +GL_VERTEX_ATTRIB_ARRAY_INTEGER=0x88FD +GL_VERTEX_ATTRIB_ARRAY_NORMALIZED=0x886A +GL_VERTEX_ATTRIB_ARRAY_POINTER=0x8645 +GL_VERTEX_ATTRIB_ARRAY_SIZE=0x8623 +GL_VERTEX_ATTRIB_ARRAY_STRIDE=0x8624 +GL_VERTEX_ATTRIB_ARRAY_TYPE=0x8625 +GL_VERTEX_PROGRAM_POINT_SIZE=0x8642 +GL_VERTEX_SHADER=0x8B31 +GL_VIEWPORT=0x0BA2 +GL_WAIT_FAILED=0x911D +GL_WRITE_ONLY=0x88B9 +GL_XOR=0x1506 +GL_ZERO=0 +. +:struct +__GLsync{}; +. +.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/share/dynport/stdlib.dynport Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,8 @@ +:lib + +. +:fun +getenv(Z)Z; +malloc(i)p; +. +.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/CMakeLists.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,53 @@ +# use lua +include_directories(${LUA_INCLUDE_DIR}) + +# Lua Module Names: +set(CMAKE_SHARED_MODULE_PREFIX "") + +# DynLoad and DynCall: +include_directories( ${DynCall_SOURCE_DIR}/dyncall ${DynCall_SOURCE_DIR}/dynload ${DynCall_SOURCE_DIR}/dyncallback ) + +# Fix arch x86_64: force PIC always (even in static libraries) + +if("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "x86_64") +add_definitions("-fPIC") +endif() + +add_library(smartptr MODULE smartptr.c) +add_library(intutils MODULE intutils.cpp) +add_library(ldynload MODULE ldynload.c) +add_library(ldyncall MODULE ldyncall.c) +add_library(ldynguess MODULE ldynguess.c) +add_library(ldynstruct MODULE ldynstruct.c) +add_library(ldyntype MODULE ldyntype.c) +add_library(larray MODULE larray.c dyntype.c) + +target_link_libraries(ldynload dynload_s) +target_link_libraries(ldyncall dyncall_s) + +install(TARGETS + ldynload smartptr + ldyncall + larray + intutils + ldynguess + # ldynstruct ldyntype + LIBRARY DESTINATION lib/lua +) + +install(FILES + dynload.lua + dyncall.lua + dynport.lua path.lua + array.lua + # dynstruct.lua + # dyntype.lua + DESTINATION lib/lua +) + +if(APPLE) + set(CMAKE_MODULE_LINKER_FLAGS "-bundle -undefined dynamic_lookup") + # build cocoautil library on mac os x + add_library(cocoautil MODULE cocoautil.m) +endif() +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/Makefile.custom Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,36 @@ +TOP =.. +include $(TOP)/config +INSTALL_PREFIX ?=../../../src +INSTALL_LUA =$(INSTALL_PREFIX) +INSTALL_LIB =$(INSTALL_PREFIX) +CPPFLAGS =-I$(LUA)/include -I$(DYNCALL)/include -I$(BOOST_INCDIR) +CXXFLAGS =-fno-exceptions -fno-rtti +DYNTYPE =dyntype_boost.o +# LDFLAGS =-L$(LUA)/lib -llua -L$(DYNCALL)/lib -ldynload_s -ldyncall_s -ldyncallback_s $(DYNTYPE) +# MAC OS X: +LDFLAGS =-bundle -undefined dynamic_lookup +LD =gcc +all: intutils.so smartptr.so ldynload.so ldyncall.so cocoautil.dylib +# ldynguess.so +# $(DYNTYPE) smartptr.so ldynguess.so ldyntype.so ldynload.so ldyncall.so ldynstruct.so # TODO: ldyncallback.so +# lsmartptr.so $(DYNTYPE) ldynguess.so ldyntype.so ldynload.so ldyncall.so ldynstruct.so # TODO: ldyncallback.so + +%.so: %.o + $(LD) $(LDFLAGS) -o $@ $^ + +ldynload.so: ldynload.o + $(LD) $(LDFLAGS) -o $@ $^ -L$(DYNCALL)/lib -ldynload_s + +ldyncall.so: ldyncall.o + $(LD) $(LDFLAGS) -o $@ $^ -L$(DYNCALL)/lib -ldyncall_s + +cocoa.dylib: cocoa.o + gcc -dynamiclib -o $@ $^ -framework AppKit + +clean: + rm -f *.so *.o + +install: + cp intutils.so smartptr.so ldynload.so ldyncall.so $(INSTALL_LIB) + cp dynload.lua dyncall.lua dynport.lua $(INSTALL_LUA) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/README.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,12 @@ +luadyncall 0.1 + +Dyncall bindings for Lua programming language C implementation. + +CONTENTS +******** +- smart pointer utility library (smartptr.so) +- dynload.lua, ldynload.so (dynload library) +- dyncall.lua (front end for Version 2 dyncall API), ldyncall.so (low-level lua dyncall bindings) +- dyncallback.lua, ldyncallback.so + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/array.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,64 @@ +require"larray" +-- typesignature = require"typesignature" +local array_mt = { + __index = function(t,i) + if type(i) == "number" then + return larray.peek( t.pointer, t.typesize * (i-1), t.typeinfo ) + else + local result = rawget(t,i) + if not result then + return getmetatable(t)[i] + end + end + end, + __newindex = function(t,i,v) + if type(i) == "number" then + return larray.poke( t.pointer, t.typesize * (i-1), t.typeinfo, v) + else + return rawset(t,i,v) + end + end, + copy = function(array,src,nelements) + return larray.copy( array.pointer, 0, src, 0, array.typesize * nelements) + end +} + +--- Get type information from type signature. +-- +-- @param signature string representing type informations. Fundamental type signatures are represented by characters such as 'c' for C char, 's' for C short, 'i' for C int, 'j' for C long +-- 'l' for C long long, 'f' for C float, 'd' for C double, 'p' for C pointer, +-- 'B' for ISO C99 _Bool_t/C++ bool, 'v' for C void. Upper-case characters 'CSIJL' refer to the corresponding unsigned C type. +-- Function signature syntax: 'name(argtypes..)resulttypes..;' +-- Structure signature syntax: 'name{fieldtypes..)fieldnames..;' the fieldnames are space separated text tokens. +-- Named objects can be refered using '<name>' syntax. +-- pointer types can be specified by prefixing multiple '*'. +-- function typesignature(signature) +-- end + +--- Get size of fundamental C types. +-- @param typeinfo a simple C type signature string. +-- @see typesignature +function typesize(typesignature) + return typesizes[typesignature] +end + +--- Create a lua-memory managed C array. +-- Arrays are represented as a table with fields. +-- @field pointer holds the address represented by a lua userdata object. +-- @return array object +function array(typeinfo, length) + local typesize = larray.sizeof(typeinfo) + local size = typesize * length + local pointer = larray.newudata(size) + local o = { + pointer = pointer, + size = size, + length = length, + typesize = typesize, + typeinfo = typeinfo, + } + setmetatable(o, array_mt) + return o +end + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/cocoautil.m Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,24 @@ +#import <Foundation/NSAutoreleasePool.h> +#import <AppKit/NSApplication.h> +NSAutoreleasePool* pool; + +#ifdef __cplusplus +extern "C" { +#endif + void CocoaInit(); + void CocoaQuit(); +#ifdef __cplusplus +} +#endif + +void CocoaInit() +{ + [[NSAutoreleasePool alloc] init]; + NSApplicationLoad(); +} + +void CocoaQuit() +{ + [pool drain]; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/dyncall.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,27 @@ +require "ldyncall" +require "dynload" + +--- invoke dynamic foreign function call +-- This is a front-end function that provides several interfaces +-- @param target Target signature +-- @param ... if target is a string, then the arguments follow. +-- @see dodyncall for details + +function dyncall(target, ...) + local t = type(target) + if t == "string" then + local libnames, sym, sig = target:match("^@(.+)/(.+)%((.+)") + local lib = dynload(libnames) -- hold reference as long as the call + return ldyncall.dodyncall( dynsym( lib,sym ), sig, ...) + else + return ldyncall.dodyncall( target, ...) + end +end + +-- pointer utilities +-- + +topointer = ldyncall.topointer +NULL = topointer(0) + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/dynguess.h Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,45 @@ +#ifndef DYNGUESS_H +#define DYNGUESS_H + +/* guess architecture (ARCH) */ + +#if defined __i386__ +#define DG_ARCH_x86 1 +#define DG_ARCH "x86" +#elif defined __x86_64__ +#define DG_ARCH_x64 1 +#define DG_ARCH "x64" +#elif defined __ppc__ +#define DG_ARCH_ppc32 1 +#define DG_ARCH "ppc32" +#elif defined __ppc64__ +#define DG_ARCH_ppc64 1 +#define DG_ARCH "ppc64" +#elif defined __arm__ +#define DG_ARCH_arm 1 +#define DG_ARCH "arm" +#elif defined __mips__ +#define DG_ARCH_mips 1 +#define DG_ARCH "mips" +#endif + +/* guess operating system (OS) */ + +#if defined __APPLE__ +#define DG_OS_osx 1 +#define DG_OS "osx" +#elif defined __linux__ +#define DG_OS_linux 1 +#define DG_OS "linux" +#endif + +/* guess compiler (CC) */ + +#if defined __GNUC__ +#define DG_CC_gcc 1 +#define DG_CC "gcc" +#define DG_CC_VERSION __VERSION__ +#endif + +#endif /* DYNGUESS_H */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/dynload.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,77 @@ +require "smartptr" + +local dl = require "ldynload" + +--- load library given by name using operating-system level service. +-- @return smartptr that will free library if the object gets garbage collected. + +function loadlib(name) + local handle = dl.dlLoadLibrary(name) + if handle then return smartptr.new( handle, dl.dlFreeLibrary ) end +end + +--- resolve symbols +-- @param lib smartptr +-- @param name symbol to resolve to address +-- @return address light userpointer +function dynsym(lib, name) + local handle = lib() + return dl.dlFindSymbol( handle, name ) +end + +--- load shared library code +-- This mechanism uses a platform-independent interface to search for +-- the libraries. +-- On Linux, BSD, UNIX and Mac OS X the standard places such as "/", "/lib" are searched. +-- @param libnames a string separated by '|' (pipe) for the pure library name without prefix/suffixes. + + +function dynload(libnames) + + local lib + + if libnames == "" then + return loadlib(nil) + end + + -- Unix search paths + + local paths = { "", "./", "/lib/", "/usr/lib/", "/usr/local/lib/", "/opt/lib/", "/opt/local/lib/" } + local prefixes = { "", "lib" } + local suffixes = { "", ".dylib", ".so", ".so.0", ".dll" } + + -- Mac OS X Framework search paths + -- local fwpaths = { "", "/System" } + + for libname in libnames:gmatch("[^|]+") do + + for k,path in pairs(paths) do + for k,prefix in pairs(prefixes) do + for k,suffix in pairs(suffixes) do + local libpath = path .. prefix .. libname .. suffix + lib = loadlib(libpath) + if lib then return lib end + end + end + end + + -- search Mac OS X frameworks: + + lib = loadlib( libname .. ".framework/" .. libname ) + + --[[ + for k,fwpath in pairs(fwpaths) do + local libpath = fwpath .. "/Library/Frameworks/" .. libname .. ".framework/" .. libname + lib = ldynload.dlLoadLibrary(libpath) + if libhandle then break end + end + ]] + + if lib then return lib end + + end + + if not lib then error("unable to locate library "..libnames) end + +end +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/dynport.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,163 @@ +require "dynload" +require "dyncall" +require "path" + +local function makewrapper(addr, signature) + return function(...) return dyncall(addr, signature, ...) end +end + +loaded = { } + +--- The dynport path is initialized by LDP_PATH environment. +-- @usage Defaults to dynport_syspath. +dynport_path = pathinit("LDP_PATH","?.dynport;/usr/local/share/dynport/?.dynport;/opt/local/share/dynport/?.dynport") + +local function find(name) + return pathfind( dynport_path, name, io.open ) +end + +--[[ +local LDP_PATH = "?.dynport;/usr/local/share/dynport/?.dynport;/opt/local/share/dynport/?.dynport" +local path = os.getenv("LDP_PATH") or LDP_PATH + +local function find(name) + local replaced = path:gsub("?", name) + local f = nil + local hist = {} + for filename in replaced:gmatch("([^;]+)") do + f = io.open(filename) + if f then break else + table.insert(hist, "\tno file '") + table.insert(hist, filename) + table.insert(hist, "'\n") + end + end + if f then + return f + else + error("dynport '"..name.."' not found:\n"..table.concat(hist), 3) + end +end +]] + + +--- Process dynport files. +-- Files will be opened and processed according to the dynport format. +-- Function wrappers and constants will be installed. +-- Structure/Union type information have not been implemented yet. +-- @param name dynport name to lookup. +-- @unit table to use for import. +-- @field _dynport_libs contains. +-- @return unit table with imports. + +function dynport_NEW(portname, t) + local t = t or _G + local port = loaded[portname] + if port then return port end + local file, errmsg = searchpath(portname, path) + if not file then error(errmsg) end +end + +function dynportImport(name, unit) + + local file = find(name) + + if not unit._dynport_libs then + unit._dynport_libs = { } + end + + local cached = unit._dynport_libs[name] + if cached then return unit end + + if not file then + error("dynport "..name.. " not found") + end + + local iter = file:lines() + + local libs = { } + + function dolib() + local libnames = "" + for line in iter do + if line == "." then break end + libnames = line + end + libs[#libs+1] = dynload(libnames) + end + + function dofun() + local index = 1 + local unresolved = {} + for line in iter do + + if line == "." then break end + + local pos = line:find("[(]") + local symbol = line:sub(1, pos-1) + local stop = line:find("[;]", pos+1) + local signature = line:sub(pos+1,stop-1) + + local addr = dynsym(libs[#libs], symbol) + + if type(addr) == "userdata" then + rawset(unit, symbol, makewrapper(addr, signature) ) + -- module[symbol] = makewrapper(addr, signature) + else + unresolved[#unresolved] = symbol + end + + end + + if #unresolved ~= 0 then + print("unresolved symbols:") + print(table.concat(unresolved,"\n")) + end + end + + function doconst() + for line in iter do + if line == "." then break end + local pos = line:find("=") + local key = line:sub(1, pos-1) + local value = line:sub(pos+1) + -- module[key] = tonumber(value) + rawset( unit, key, tonumber(value) ) + end + end + + function dostruct() + for line in iter do + if line == "." then break end + end + end + + function dounion() + for line in iter do + if line == "." then break end + end + end + + for line in iter do + if line == "." then break + elseif line == ":lib" then dolib() + elseif line == ":fun" then dofun() + elseif line == ":const" then doconst() + elseif line == ":struct" then dostruct() + elseif line == ":union" then dounion() + end + end + + unit._dynport_libs[name] = libs + + return unit + +end + +--- Dynamic bind C library Interfaces. +-- @param name dynport name which will be searched by +function dynport(portname) + return dynportImport(portname, _G) +end + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/dynstruct.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,37 @@ +require "ldynstruct" +require "dyntype" + +dynstruct_metatable = { + __index = function(s, f) + local typeinfo = rawget(s, "typeinfo") + local fieldinfo = typeinfo.fields[f] + if not fieldinfo then error("unknown field "..f.." for type "..typeinfo.name) end + return ldynstruct.dynpeek( rawget(s, "pointer"), fieldinfo.offset, fieldinfo.typeinfo.signature ) + end, + __newindex = function(s, f, v) + local typeinfo = rawget(s, "typeinfo") + local fieldinfo = typeinfo.fields[f] + if not fieldinfo then error("unknown field "..f.." for type "..typeinfo.name) end + ldynstruct.dynpoke( rawget(s, "pointer"), fieldinfo.offset, fieldinfo.typeinfo.signature, v ) + end +} + +function newdynstruct(typename) + local typeinfo = gettypeinfo(typename) + local object = { pointer = ldynstruct.newstruct( typeinfo.size ), typeinfo = typeinfo } + setmetatable(object, dynstruct_metatable) + return object +end + +function dyncast(object, typeinfo) + local pointer + if type(object) == "userdata" then + pointer = object + elseif type(object) == "table" then + pointer = rawgeti(object, "pointer") + end + local object = { pointer = pointer, typeinfo = gettypeinfo(typeinfo) } + setmetatable(object, dynstruct_metatable) + return object +end +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/dyntype.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,34 @@ +#include "dyncall.h" +#include "dyncall_signature.h" + +size_t dtSize(const char* signature) +{ + char ch = *signature; + switch(ch) + { + case DC_SIGCHAR_BOOL: return sizeof(DCbool); + case DC_SIGCHAR_CHAR: return sizeof(DCchar); + case DC_SIGCHAR_UCHAR: return sizeof(DCuchar); + case DC_SIGCHAR_SHORT: return sizeof(DCshort); + case DC_SIGCHAR_USHORT: return sizeof(DCushort); + case DC_SIGCHAR_INT: return sizeof(DCint); + case DC_SIGCHAR_UINT: return sizeof(DCuint); + case DC_SIGCHAR_LONG: return sizeof(DClong); + case DC_SIGCHAR_ULONG: return sizeof(DCulong); + case DC_SIGCHAR_LONGLONG: return sizeof(DClonglong); + case DC_SIGCHAR_ULONGLONG: return sizeof(DCulonglong); + case DC_SIGCHAR_FLOAT: return sizeof(DCfloat); + case DC_SIGCHAR_DOUBLE: return sizeof(DCdouble); + case DC_SIGCHAR_POINTER: return sizeof(DCpointer); + case DC_SIGCHAR_STRING: return sizeof(DCstring); + case DC_SIGCHAR_VOID: return sizeof(DCvoid); + default: return 0; + } +} + +size_t dtAlign(const char* signature) +{ + return dtSize(signature); +} + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/dyntype.h Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,18 @@ +#ifndef DYNTYPE_H +#define DYNTYPE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "stddef.h" + +size_t dtSize (const char* signature); +size_t dtAlign (const char* signature); + +#ifdef __cplusplus +} +#endif + +#endif /* DYNTYPE_H */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/dyntype.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,173 @@ +require "ldyntype" + +-- utilities + +local function align(x, align) + return math.floor( ( x + (align-1) ) / align ) * align +end + +-- typeinfo table constructors + +function typeinfo_base(signature, size, align) + return { name = signature, signature = signature, class = "base", size = size, align = align } +end + +function typeinfo_ptr(signature, basetypeinfo, ptrlevels) + return { name = signature, signature = signature, class = "ptr", basetypeinfo = basetypeinfo, ptrlevels = ptrlevels, size = _TI.p.size, align = _TI.p.align } +end + +function typeinfo_struct(name, signature, size, align, fields) + return { name = name, signature = signature, class = "struct" , size = size, align = align , fields = fields } +end + +local function istypeinfo(typespec) + return type(typespec) == "table" +end + +function typeinfo_tostring(typename) + local ti = gettypeinfo(typename) + local s = ti.name .. "\tsize=" .. ti.size .. "\talign=" .. ti.align + if ti.basetypeinfo then + local baseti = gettypeinfo(ti.basetypeinfo) + if baseti.name then + s = s .. "\tbase=" .. baseti.name + else + s = s .. "\tbase=" .. baseti + end + end + if ti.fields then + for k, v in pairs(ti.fields) do + s = s .. "\n- "..k .. ":\toffset=" .. v.offset + end + end + return s +end + + +-- typeinfo registry + +_TI = { } + +function settypeinfo(name,info) + _TI[name] = info +end + +function gettypeinfo(typespec) + if istypeinfo(typespec) then return typespec end + local typeinfo = _TI[typespec] + if not typeinfo then -- pointer type ? + local ptrs, basename = typespec:match("(%**)<(%a+)>") + if ptrs and basename then -- pointer type signature: + typeinfo = typeinfo_ptr( typespec, gettypeinfo(basename), #ptrs) + settypeinfo(typespec, typeinfo) + end -- else, typespec remains a string (unknown type) + end + return typeinfo +end + +function dumptypeinfos() + for k,v in pairs(_TI) do + print(typeinfo_tostring(v)) + end +end + +function dumptypeinfo(x) + print(typeinfo_tostring(x)) +end + +-- + +local function regbasetypes() + local sigs = "BcCsSiIjJlLpZ" + for typechar in sigs:gmatch(".") do + settypeinfo(typechar, typeinfo_base( typechar, ldyntype.dtSize(typechar), ldyntype.dtAlign(typechar) ) ) + end +end + +function regstructinfo(structsignature) + local name, typeclass, signature, fieldnames = structsignature:match("(%a+)([{|])(.+)%}(.+)") + + if name and type and signature then + local offset = 0 + local maxalign = 0 + local maxsize = 0 + local fields = { } + + local fieldname = signature:gmatch("(%S+)") + + for typespec, fieldname in signature:gmatch("(%S)") do + + local typeinfo = gettypeinfo(typespec) + + offset = align(offset, typeinfo.align) + maxalign = math.max(typeinfo.align,maxalign) + maxsize = math.max(typeinfo.size, maxsize) + + fields[fieldname] = { offset = offset, typeinfo = typeinfo } + + if typeclass == "{" then -- structure + offset = offset + typeinfo.size + end + + end + + local structsize + + if typeclass == "|" then + structsize = maxsize + else + structsize = offset + end + + settypeinfo(name, typeinfo_struct(name, signature, structsize, maxalign, fields) ) + end + +end + +function regstructinfo_backup(structsignature) + local name, typeclass, signature = structsignature:match("(%a+)([{|])(.+)%}") + + if name and type and signature then + local offset = 0 + local maxalign = 0 + local maxsize = 0 + local fields = { } + for typespec, fieldname in signature:gmatch("(%S+)%s+(%S+)") do + + local typeinfo = gettypeinfo(typespec) + + offset = align(offset, typeinfo.align) + maxalign = math.max(typeinfo.align,maxalign) + maxsize = math.max(typeinfo.size, maxsize) + + fields[fieldname] = { offset = offset, typeinfo = typeinfo } + + if typeclass == "{" then -- structure + offset = offset + typeinfo.size + end + + end + + local structsize + + if typeclass == "|" then + structsize = maxsize + else + structsize = offset + end + + settypeinfo(name, typeinfo_struct(name, signature, structsize, maxalign, fields) ) + end + +end + +function parsebasetypes(basetypesignature) + for type,size,align in basetypesignature:gmatch("(%a+)%s+(%d)%s+(%d)%s*") do + settypeinfo(type, {signature=type,base=type,class="storage",size=size,align=align}) + end +end + +-- initialize typeinfo registry + +regbasetypes() +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/dyntype_boost.cpp Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,57 @@ +#include "dyntype.h" +#include "dyncall.h" +#include "dyncall_signature.h" +#include <boost/type_traits/alignment_of.hpp> + +using namespace boost; + +extern "C" size_t dtAlign(const char* signature) +{ + char ch = *signature; + switch(ch) + { + case DC_SIGCHAR_BOOL: return alignment_of<DCbool>::value; + case DC_SIGCHAR_CHAR: return alignment_of<DCchar>::value; + case DC_SIGCHAR_UCHAR: return alignment_of<DCuchar>::value; + case DC_SIGCHAR_SHORT: return alignment_of<DCshort>::value; + case DC_SIGCHAR_USHORT: return alignment_of<DCushort>::value; + case DC_SIGCHAR_INT: return alignment_of<DCint>::value; + case DC_SIGCHAR_UINT: return alignment_of<DCuint>::value; + case DC_SIGCHAR_LONG: return alignment_of<DClong>::value; + case DC_SIGCHAR_ULONG: return alignment_of<DCulong>::value; + case DC_SIGCHAR_LONGLONG: return alignment_of<DClonglong>::value; + case DC_SIGCHAR_ULONGLONG: return alignment_of<DCulonglong>::value; + case DC_SIGCHAR_FLOAT: return alignment_of<DCfloat>::value; + case DC_SIGCHAR_DOUBLE: return alignment_of<DCdouble>::value; + case DC_SIGCHAR_POINTER: return alignment_of<DCpointer>::value; + case DC_SIGCHAR_STRING: return alignment_of<DCstring>::value; + case DC_SIGCHAR_VOID: return alignment_of<DCvoid>::value; + default: return 0; + } +} + +extern "C" size_t dtSize(const char* signature) +{ + char ch = *signature; + switch(ch) + { + case DC_SIGCHAR_BOOL: return sizeof(DCbool); + case DC_SIGCHAR_CHAR: return sizeof(DCchar); + case DC_SIGCHAR_UCHAR: return sizeof(DCuchar); + case DC_SIGCHAR_SHORT: return sizeof(DCshort); + case DC_SIGCHAR_USHORT: return sizeof(DCushort); + case DC_SIGCHAR_INT: return sizeof(DCint); + case DC_SIGCHAR_UINT: return sizeof(DCuint); + case DC_SIGCHAR_LONG: return sizeof(DClong); + case DC_SIGCHAR_ULONG: return sizeof(DCulong); + case DC_SIGCHAR_LONGLONG: return sizeof(DClonglong); + case DC_SIGCHAR_ULONGLONG: return sizeof(DCulonglong); + case DC_SIGCHAR_FLOAT: return sizeof(DCfloat); + case DC_SIGCHAR_DOUBLE: return sizeof(DCdouble); + case DC_SIGCHAR_POINTER: return sizeof(DCpointer); + case DC_SIGCHAR_STRING: return sizeof(DCstring); + case DC_SIGCHAR_VOID: return 0; + default: return 0; + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/intutils.cpp Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,178 @@ +/* intutils lua library to support various types such as i64 and u64 */ +/* critical to dyncall: needed to interact with C systems using long long */ + +#include "lua.hpp" +#include <cstdlib> +#include <cstdio> + +typedef long long i64; +typedef unsigned long long u64; + +template<typename T> const char* get_typename(); + +template<> inline const char* get_typename<u64>() { return "u64"; } +template<> inline const char* get_typename<i64>() { return "i64"; } + +template<typename T> inline void lua_push(lua_State *L, T x) +{ + T *ptr = (T*) lua_newuserdata(L, sizeof(T)); + * ptr = x; + luaL_getmetatable(L, get_typename<T>() ); + lua_setmetatable(L, -2); +} + +template<typename T> int tostring(lua_State *L); + +template<> int tostring<u64>(lua_State *L) +{ + char buf[1024]; + u64 v = * (u64*) lua_topointer(L, 1); + sprintf(buf, "%016llx", v); + lua_pushstring(L, buf); + return 1; +} + +template<> int tostring<i64>(lua_State *L) +{ + char buf[1024]; + i64 v = * (i64*) lua_topointer(L, 1); + sprintf(buf, "%016llx", v); + lua_pushstring(L, buf); + return 1; +} + +template<typename T> +struct lua_ops +{ + template<typename OP> + static int binop(lua_State *L) + { + T op1; + switch( lua_type(L, 1) ) { + case LUA_TNUMBER: op1 = (T) lua_tonumber(L, 1); break; + case LUA_TUSERDATA: op1 = * (T*) lua_touserdata(L, 1); break; + default: luaL_error(L, "invalid left-hand side operand"); + } + T op2; + switch( lua_type(L, 2) ) { + case LUA_TNUMBER: op2 = (T) lua_tonumber(L, 2); break; + case LUA_TUSERDATA: op2 = * (T*) lua_touserdata(L, 2); break; + default: luaL_error(L, "invalid right-hand side operand"); + } + lua_push(L, OP(op1,op2) ); + } + static T add1(T op1, T op2) { return op1 + op2 ; } + static int add(lua_State *L) + { + T op1; + switch( lua_type(L, 1) ) { + case LUA_TNUMBER: op1 = (T) lua_tonumber(L, 1); break; + case LUA_TUSERDATA: op1 = * (T*) lua_touserdata(L, 1); break; + default: luaL_error(L, "invalid left-hand side operand"); + } + T op2; + switch( lua_type(L, 2) ) { + case LUA_TNUMBER: op2 = (T) lua_tonumber(L, 2); break; + case LUA_TUSERDATA: op2 = * (T*) lua_touserdata(L, 2); break; + default: luaL_error(L, "invalid right-hand side operand"); + } + lua_push(L, op1 + op2); + return 1; + } + static int sub(lua_State *L) + { + T op1 = * (T*) lua_topointer(L, 1); + T op2 = * (T*) lua_topointer(L, 2); + lua_push(L, op1 - op2); + return 1; + } +}; +#define OPS(X) lua_ops<X> +template<typename T> +void register_type(lua_State *L, const char *tname) +{ + luaL_newmetatable(L, tname); + const char* names[] = { + "__add", "__sub", "__tostring" // , "__mul", "__div", "__mod", "__unm", "__eq", "__lt" + }; + lua_CFunction funs[] = { + OPS(T)::add, OPS(T)::sub, tostring<T> // , T::mul, T::div, T::mod, T::unm, T::eq, T::lt + }; + size_t n = sizeof(names)/sizeof(const char*); + for (int i = 0; i < n ; ++i ) { + lua_pushstring(L, names[i]); + lua_pushcfunction(L, funs[i]); + lua_settable(L, -3); + } +} + +// conversion utilities: l_to* + +template<typename T> T to_string(const char* s); + +int l_u64(lua_State *L) +{ + switch( lua_type(L, 1) ) { + case LUA_TNIL: lua_push(L, (u64) 0 ); break; + case LUA_TNUMBER: lua_push(L, (u64) lua_tonumber(L, 1) ); break; + case LUA_TBOOLEAN: lua_push(L, (u64) lua_toboolean(L,1) ); break; + case LUA_TLIGHTUSERDATA: lua_push(L, (u64) lua_topointer(L, 1) ); break; + case LUA_TSTRING: + { + const char* ptr = lua_tostring(L, 1); + int base = 10; + if ( ptr[0] == '0' && ptr[1] == 'x' ) { + base = 16; + ptr += 2; + } + lua_push(L, (u64) strtoull( lua_tostring(L, 1), NULL, base ) ); + break; + } + case LUA_TTABLE: + case LUA_TFUNCTION: + case LUA_TUSERDATA: + case LUA_TTHREAD: + return 0; + } + return 1; +} + +int l_i64(lua_State *L) +{ + switch( lua_type(L, 1) ) { + case LUA_TNIL: lua_push(L, (i64) 0 ); break; + case LUA_TNUMBER: lua_push(L, (i64) lua_tonumber(L, 1) ); break; + case LUA_TBOOLEAN: lua_push(L, (i64) lua_toboolean(L,1) ); break; + case LUA_TLIGHTUSERDATA: lua_push(L, (i64) lua_topointer(L, 1) ); break; + case LUA_TSTRING: + { + const char* ptr = lua_tostring(L, 1); + int base = 10; + if ( ptr[0] == '0' && ptr[1] == 'x' ) { + base = 16; + ptr += 2; + } + lua_push(L, (i64) strtoll( lua_tostring(L, 1), NULL, base ) ); + break; + } + case LUA_TTABLE: + case LUA_TFUNCTION: + case LUA_TUSERDATA: + case LUA_TTHREAD: + return 0; + } + return 1; +} + +extern "C" int luaopen_intutils(lua_State *L) +{ + static luaL_Reg intutils[] = { + { "u64", l_u64 }, + { "i64", l_i64 }, + { NULL, NULL } + }; + register_type<u64>(L, "u64"); + register_type<i64>(L, "i64"); + luaL_register(L, "intutils", intutils); + return 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/larray.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,129 @@ +#include "lua.h" +#include "lauxlib.h" +#include "dyncall.h" +#include "dyncall_signature.h" +#include "dyntype.h" + +int newudata(lua_State* L) +{ + size_t size = luaL_checkint(L, 1); + void * pointer = lua_newuserdata(L, size); + return 1; +} + +int newudata2(lua_State* L) +{ + size_t size = luaL_checkint(L, 1); + void * pointer = lua_newuserdata(L, size); + lua_pushvalue(L,-2); + lua_setmetatable(L,-2); + return 1; +} + + +int peek(lua_State* L) +{ + char* pointer = (char*) lua_topointer(L, 1); + int offset = luaL_checkint(L, 2); + const char* typeinfo = luaL_checkstring(L, 3); + pointer += offset; + switch( *typeinfo ) + { + case DC_SIGCHAR_BOOL: lua_pushboolean(L, (int) * ( (DCbool*) pointer ) ); break; + case DC_SIGCHAR_CHAR: lua_pushnumber(L, (lua_Number) * ( (DCchar*) pointer ) ); break; + case DC_SIGCHAR_UCHAR: lua_pushnumber(L, (lua_Number) * ( (DCuchar*) pointer ) ); break; + case DC_SIGCHAR_SHORT: lua_pushnumber(L, (lua_Number) * ( (DCshort*) pointer ) ); break; + case DC_SIGCHAR_USHORT: lua_pushnumber(L, (lua_Number) * ( (DCushort*) pointer ) ); break; + case DC_SIGCHAR_INT: lua_pushnumber(L, (lua_Number) * ( (DCint*) pointer ) ); break; + case DC_SIGCHAR_UINT: lua_pushnumber(L, (lua_Number) * ( (DCuint*) pointer ) ); break; + case DC_SIGCHAR_LONG: lua_pushnumber(L, (lua_Number) * ( (DClong*) pointer ) ); break; + case DC_SIGCHAR_ULONG: lua_pushnumber(L, (lua_Number) * ( (DCulong*) pointer ) ); break; + case DC_SIGCHAR_LONGLONG: lua_pushnumber(L, (lua_Number) * ( (DClonglong*) pointer ) ); break; + case DC_SIGCHAR_ULONGLONG: lua_pushnumber(L, (lua_Number) * ( (DCulonglong*) pointer ) ); break; + case DC_SIGCHAR_FLOAT: lua_pushnumber(L, (lua_Number) * ( (DCfloat*) pointer ) ); break; + case DC_SIGCHAR_DOUBLE: lua_pushnumber(L, (lua_Number) * ( (DCdouble*) pointer ) ); break; + case DC_SIGCHAR_POINTER: lua_pushlightuserdata(L, * ( (DCpointer*) pointer ) ); break; + default: luaL_error(L, "invalid type signature: %s\n", typeinfo); break; + } + return 1; +} + +int poke(lua_State* L) +{ + char* pointer = (char*) lua_topointer(L, 1); + int offset = luaL_checkint(L, 2); + const char* typeinfo = luaL_checkstring(L, 3); + pointer += offset; + switch( *typeinfo ) + { + case DC_SIGCHAR_BOOL: * ( (DCbool*) pointer ) = lua_toboolean(L, 4); break; + case DC_SIGCHAR_CHAR: * ( (DCchar*) pointer ) = (DCchar) luaL_checkint(L, 4); break; + case DC_SIGCHAR_UCHAR: * ( (DCuchar*) pointer ) = (DCuchar) luaL_checkint(L, 4); break; + case DC_SIGCHAR_SHORT: * ( (DCshort*) pointer ) = (DCshort) luaL_checkint(L, 4); break; + case DC_SIGCHAR_USHORT: * ( (DCushort*) pointer ) = (DCushort) luaL_checkint(L, 4); break; + case DC_SIGCHAR_INT: * ( (DCint*) pointer ) = (DCint) luaL_checkint(L, 4); break; + case DC_SIGCHAR_UINT: * ( (DCuint*) pointer ) = (DCuint) luaL_checknumber(L, 4); break; + case DC_SIGCHAR_LONG: * ( (DClong*) pointer ) = (DClong) luaL_checknumber(L, 4); break; + case DC_SIGCHAR_ULONG: * ( (DCulong*) pointer ) = (DCulong) luaL_checknumber(L, 4); break; + case DC_SIGCHAR_LONGLONG: * ( (DClonglong*) pointer ) = (DClonglong) luaL_checknumber(L,4); break; + case DC_SIGCHAR_ULONGLONG: * ( (DCulonglong*) pointer ) = (DCulonglong) luaL_checknumber(L,4); break; + case DC_SIGCHAR_FLOAT: * ( (DCfloat*) pointer ) = (DCfloat) luaL_checknumber(L,4); break; + case DC_SIGCHAR_DOUBLE: * ( (DCdouble*) pointer ) = (DCdouble) luaL_checknumber(L,4); break; + case DC_SIGCHAR_POINTER: + { + switch(lua_type(L,4)) { + case LUA_TUSERDATA: + case LUA_TLIGHTUSERDATA: + * ( (DCpointer*) pointer ) = (DCpointer) lua_topointer(L,4); break; + case LUA_TSTRING: + * ( (DCpointer*) pointer ) = (DCpointer) lua_tostring(L,4); break; + default: + luaL_error(L, "invalid argument for signature : %s\n", typeinfo); break; + } + break; + } + default: luaL_error(L, "invalid type signature: %s\n", typeinfo); break; + } + return 0; +} + +int lua_sizeof(lua_State *L) +{ + const char* typeinfo = luaL_checkstring(L, 1); + lua_pushinteger(L, dtSize(typeinfo) ); + return 1; +} + +int copy(lua_State *L) +{ + char* dstptr = (char*) lua_topointer(L, 1); + int dstoffset = luaL_checkint(L, 2); + const char* srcptr = lua_topointer(L, 3); + int srcoffset = luaL_checkint(L, 4); + int copysize = luaL_checkint(L, 5); + dstptr += dstoffset; + srcptr += srcoffset; + int i; + for(i=0;i<copysize;++i) + { + *dstptr++ = *srcptr++; + } + return 0; +} + +static const struct luaL_Reg luareg_larray[] = +{ + {"newudata" ,newudata}, + {"newudata2", newudata2}, + {"peek" ,peek}, + {"poke" ,poke}, + {"sizeof" ,lua_sizeof}, + {"copy" ,copy}, + {NULL ,NULL} +}; + +LUA_API int luaopen_larray(lua_State* L) +{ + luaL_register(L, "larray", luareg_larray); + return 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/ldyncall.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,263 @@ +#include <stddef.h> +#include "lua.h" +#include "lauxlib.h" +#include "dyncall.h" +#include "dyncall_signature.h" + +DCCallVM* g_pCallVM = NULL; + +/** + * lua syntax: + * + * dodyncall( address, signature, ... ) + * + **/ + +int lua_dodyncall(lua_State *L) +{ + void* f; + const char *callsignature, *s; + int top = lua_gettop(L); + if (top < 2) return luaL_error(L,"missing arguments #1 'addr' and #2 'signature'"); + + if ( lua_iscfunction(L,1) ) f = (void*) lua_tocfunction(L, 1); + else if (lua_islightuserdata(L,1) ) f = lua_touserdata(L, 1); + else if (lua_isnumber(L,1) ) f = (void*) lua_tointeger(L, 1); + else return luaL_argerror(L, 1, "expected a cfunction, userdata or number"); + + s = callsignature = luaL_checkstring(L,2); + + /* parse mode */ + + // dcMode( g_pCallVM, DC_CALL_C_DEFAULT ); + dcReset( g_pCallVM ); + + char ch; + int p = 3; + int ptr = 0; + while ( (ch = *s++) != DC_SIGCHAR_ENDARG) + { + if (p > top) return luaL_error(L,"need more arguments (call signature is '%s')", callsignature ); + if (ptr == 0) { + switch(ch) + { + case '*': + ptr++; + continue; + case DC_SIGCHAR_BOOL: + dcArgBool(g_pCallVM, (DCbool) luaL_checkint(L, p) ); + break; + case DC_SIGCHAR_CHAR: + case DC_SIGCHAR_UCHAR: + dcArgChar(g_pCallVM, (DCchar) luaL_checkint(L, p) ); + break; + case DC_SIGCHAR_SHORT: + case DC_SIGCHAR_USHORT: + dcArgShort(g_pCallVM, (DCshort) luaL_checkint(L, p) ); + break; + case DC_SIGCHAR_INT: + case DC_SIGCHAR_UINT: + dcArgInt(g_pCallVM, (DCint) luaL_checknumber(L, p) ); + break; + case DC_SIGCHAR_LONG: + case DC_SIGCHAR_ULONG: + dcArgLong(g_pCallVM, (DClong) luaL_checknumber(L, p) ); + break; + case DC_SIGCHAR_LONGLONG: + case DC_SIGCHAR_ULONGLONG: + dcArgLongLong(g_pCallVM, (DClonglong) luaL_checknumber(L, p) ); + break; + case DC_SIGCHAR_FLOAT: + dcArgFloat(g_pCallVM, (DCfloat) luaL_checknumber(L, p) ); + break; + case DC_SIGCHAR_DOUBLE: + dcArgDouble(g_pCallVM, (DCdouble) luaL_checknumber(L, p) ); + break; + case DC_SIGCHAR_POINTER: + dcArgPointer(g_pCallVM, (DCpointer) lua_topointer(L, p) ); + break; + case DC_SIGCHAR_STRING: + dcArgPointer(g_pCallVM, (DCpointer) lua_tostring(L, p) ); + break; + default: + return luaL_error(L, "invalid typecode '%c' in call signature '%s'", s[0], callsignature); + } + } else { /* pointer types */ + switch(ch) + { + case '*': + ptr++; + continue; + case '<': + { + const char* begin = s; + while ( (ch = *s++) != '>' ) ; + const char* end = s; + switch( lua_type(L,p) ) { + case LUA_TNUMBER: + dcArgPointer(g_pCallVM, (DCpointer) (ptrdiff_t) lua_tonumber(L, p) ); + break; + case LUA_TTABLE: + lua_pushvalue(L, p); // 1 + lua_pushliteral(L, "pointer"); + lua_gettable(L, -2); // 2 + if ( !lua_isuserdata(L, -1) ) + luaL_error(L, "pointer type mismatch at argument #%d", p); + dcArgPointer(g_pCallVM, (DCpointer) lua_touserdata(L, -1) ); + lua_pop(L, 2); + break; + case LUA_TLIGHTUSERDATA: + case LUA_TUSERDATA: + dcArgPointer(g_pCallVM, (DCpointer) lua_topointer(L, p) ); + break; + default: + luaL_error(L, "pointer type mismatch at argument #%d", p); + break; + } + } + break; + case DC_SIGCHAR_BOOL: + case DC_SIGCHAR_CHAR: + if ( lua_isstring(L, p) ) { + dcArgPointer(g_pCallVM, (DCpointer) lua_tostring(L, p) ); + break; + } + case DC_SIGCHAR_UCHAR: + case DC_SIGCHAR_SHORT: + case DC_SIGCHAR_USHORT: + case DC_SIGCHAR_INT: + case DC_SIGCHAR_UINT: + case DC_SIGCHAR_LONG: + case DC_SIGCHAR_ULONG: + case DC_SIGCHAR_LONGLONG: + case DC_SIGCHAR_ULONGLONG: + case DC_SIGCHAR_FLOAT: + case DC_SIGCHAR_DOUBLE: + case DC_SIGCHAR_POINTER: + case DC_SIGCHAR_STRING: + case DC_SIGCHAR_VOID: + if ( lua_istable(L, p) ) { + lua_pushvalue(L, p); // 1 + lua_pushliteral(L, "pointer"); + lua_gettable(L, -2); // 2 + if ( !lua_isuserdata(L, -1) ) + luaL_error(L, "pointer type mismatch at argument #%d", p); + dcArgPointer(g_pCallVM, (DCpointer) lua_touserdata(L, -1) ); + lua_pop(L, 2); + } else + dcArgPointer(g_pCallVM, (DCpointer) lua_topointer(L, p) ); + ptr = 0; + break; + default: + return luaL_error(L, "invalid signature"); + } + } + + ++p; + } + + if (top >= p) + luaL_error(L,"too many arguments for given signature, expected %d but received %d" , p-3, top-2 ); + + switch(*s++) + { + case DC_SIGCHAR_VOID: + dcCallVoid(g_pCallVM, f); + return 0; + case DC_SIGCHAR_BOOL: + lua_pushboolean( L, (int) dcCallBool(g_pCallVM, f) ); + break; + case DC_SIGCHAR_CHAR: + case DC_SIGCHAR_UCHAR: + lua_pushnumber( L, (lua_Number) ( dcCallChar(g_pCallVM,f) ) ); + break; + case DC_SIGCHAR_SHORT: + case DC_SIGCHAR_USHORT: + lua_pushnumber( L, (lua_Number)( dcCallShort(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_INT: + case DC_SIGCHAR_UINT: + lua_pushnumber( L, (lua_Number)( dcCallInt(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_LONG: + case DC_SIGCHAR_ULONG: + lua_pushnumber( L, (lua_Number)( dcCallLong(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_LONGLONG: + case DC_SIGCHAR_ULONGLONG: + lua_pushnumber( L, (lua_Number)( dcCallLongLong(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_FLOAT: + lua_pushnumber( L, (lua_Number) dcCallFloat(g_pCallVM, f) ); + break; + case DC_SIGCHAR_DOUBLE: + lua_pushnumber( L, (lua_Number) dcCallDouble(g_pCallVM, f) ); + break; + case DC_SIGCHAR_STRING: + lua_pushstring( L, (const char*) dcCallPointer(g_pCallVM, f) ); + break; + case DC_SIGCHAR_POINTER: + lua_pushlightuserdata( L, dcCallPointer(g_pCallVM, f) ); + break; + case '*': + switch(*s++) { + case DC_SIGCHAR_UCHAR: + case DC_SIGCHAR_CHAR: + lua_pushstring( L, dcCallPointer(g_pCallVM, f) ); + break; + default: + lua_pushlightuserdata( L, dcCallPointer(g_pCallVM, f) ); + break; + } + break; + default: + return luaL_error(L, "invalid signature"); + } + return 1; +} + +int topointer(lua_State* L) +{ + lua_pushlightuserdata(L, (void*) (ptrdiff_t) luaL_checkint(L, 1) ); + return 1; +} + +static const struct luaL_Reg luareg_dyncall[] = +{ + { "dodyncall", lua_dodyncall }, + { "topointer", topointer }, + { NULL, NULL } +/* + { "NewCallVM", lua_dcNewCallVM }, + { "Mode", lua_dcMode }, + { "Reset", lua_dcReset }, + { "ArgBool", lua_dcBool }, + { "ArgChar", lua_dcChar }, + { "ArgShort", lua_dcShort }, + { "ArgInt", lua_dcInt }, + { "ArgLong", lua_dcLong }, + { "ArgLongLong", lua_dcLongLong }, +*/ +}; + +void lua_setmetainfo(lua_State *L) +{ + lua_pushliteral(L, "_COPYRIGHT"); + lua_pushliteral(L, "Copyright (C) 2010 Dyncall Project"); + lua_settable(L, -3); + lua_pushliteral(L, "_DESCRIPTION"); + lua_pushliteral(L, "lua bindings for dyncall libraries"); + lua_settable(L, -3); + lua_pushliteral(L, "_VERSION"); + lua_pushliteral(L, "0.1"); + lua_settable(L, -3); +} + +LUA_API int luaopen_ldyncall(lua_State* L) +{ + g_pCallVM = dcNewCallVM(4096); + luaL_register(L, "ldyncall", luareg_dyncall); + lua_setmetainfo(L); + return 1; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/ldynguess.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,19 @@ +#include "dynguess.h" +#include "lua.h" +#include "lauxlib.h" + +int luaopen_ldynguess(lua_State *L) +{ + lua_newtable(L); + lua_pushliteral(L, "arch"); + lua_pushliteral(L, DG_ARCH); + lua_settable(L, -3); + lua_pushliteral(L, "os"); + lua_pushliteral(L, DG_OS); + lua_settable(L, -3); + lua_pushliteral(L, "cc"); + lua_pushliteral(L, DG_CC); + lua_settable(L, -3); + return 1; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/ldynload.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,51 @@ +#include "lua.h" +#include "lauxlib.h" +#include "dynload.h" + +int lua_dlLoadLibrary(lua_State *L) +{ + const char* libpath; + if ( lua_isnoneornil(L, 1) ) + libpath = NULL; + else + libpath = lua_tostring(L, 1); + DLLib* pLib; + pLib = dlLoadLibrary(libpath); + if (pLib == NULL) return 0; + lua_pushlightuserdata(L, pLib); + return 1; +} + +int lua_dlFreeLibrary(lua_State *L) +{ + DLLib* pLib = (DLLib*) lua_touserdata(L, 1); + dlFreeLibrary(pLib); + return 0; +} + +int lua_dlFindSymbol(lua_State *L) +{ + DLLib* pLib = (void*) lua_touserdata(L, 1); + const char* pSymbolName = (const char*) lua_tostring(L, 2); + void* addr = dlFindSymbol(pLib, pSymbolName); + if (addr == NULL) return 0; + lua_pushlightuserdata(L, addr); + return 1; +} + +static const struct luaL_Reg luareg_dynload[] = +{ + { "dlLoadLibrary", lua_dlLoadLibrary }, + { "dlFreeLibrary", lua_dlFreeLibrary }, + { "dlFindSymbol", lua_dlFindSymbol }, + { NULL, NULL } +}; + +// LUALIB_API +int luaopen_ldynload(lua_State *L) +{ + lua_createtable(L, 0, 0); + luaL_register(L, NULL, luareg_dynload); + return 1; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/ldynstruct.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,111 @@ +#include "lua.h" +#include "lauxlib.h" +#include "dyncall.h" +#include "dyncall_signature.h" +#include <stddef.h> + +static int lua_newstruct(lua_State *L) +{ + size_t size; + void *addr; + size = (size_t) luaL_checkinteger(L, 1); + addr = lua_newuserdata(L, size); + return 1; +} + +static int lua_aslightuserdata(lua_State *L) +{ + lua_pushlightuserdata(L, (void*) (ptrdiff_t) luaL_checkinteger(L, 1) ); + return 1; +} + +/* +static int lua_newdynstruct(lua_State *L) +{ + size_t size; + void *addr; + size = (size_t) luaL_checkinteger(L, 1); + luaL_checktype(L, 2, LUA_TTABLE); + addr = lua_newuserdata(L, size); + lua_pushvalue(L, 2); + lua_setmetatable(L, 3); + return 1; +} +*/ + +int lua_dynpoke(lua_State *L) +{ + const char *ptr = (const char *) lua_touserdata(L, 1); + size_t offset = (ptrdiff_t) lua_tointeger(L, 2); + const char *typesig = (const char*) lua_tostring(L, 3); + const char *sig = typesig; + char ch; + ptr += offset; + while ((ch=*sig++) != '\0') { + switch(ch) { + case DC_SIGCHAR_BOOL: *((int*)ptr) = lua_toboolean(L, 4); break; + case DC_SIGCHAR_CHAR: *((char*)ptr) = (char) lua_tointeger(L, 4); break; + case DC_SIGCHAR_UCHAR: *((unsigned char*)ptr) = (unsigned char) lua_tointeger(L, 4); break; + case DC_SIGCHAR_SHORT: *((short*)ptr) = (short) lua_tointeger(L, 4); break; + case DC_SIGCHAR_USHORT: *((unsigned short*)ptr) = (unsigned short) lua_tointeger(L, 4); break; + case DC_SIGCHAR_INT: *((int*)ptr) = lua_tointeger(L, 4); break; + case DC_SIGCHAR_UINT: *((unsigned int*)ptr) = (unsigned int) lua_tonumber(L, 4); break; + case DC_SIGCHAR_LONG: *((long*)ptr) = (long) lua_tonumber(L, 4); break; + case DC_SIGCHAR_ULONG: *((unsigned long*)ptr) = (unsigned long) lua_tonumber(L, 4); break; + case DC_SIGCHAR_LONGLONG: *((DClonglong*)ptr) = (long long) lua_tonumber(L, 4); break; + case DC_SIGCHAR_ULONGLONG: *((DCulonglong*)ptr) = (unsigned long long) lua_tonumber(L, 4); break; + case DC_SIGCHAR_FLOAT: *((float*)ptr) = (float) lua_tonumber(L, 4); break; + case DC_SIGCHAR_DOUBLE: *((double*)ptr) = (double) lua_tonumber(L, 4); break; + case DC_SIGCHAR_POINTER: *((const void**)ptr) = lua_topointer(L, 4); break; + case DC_SIGCHAR_STRING: *((const char**)ptr) = lua_topointer(L, 4); break; + default: luaL_error(L, "invalid type signature %s", typesig); return 0; + } + } + return 0; +} + +int lua_dynpeek(lua_State *L) +{ + const char *ptr = (const char *) lua_touserdata(L, 1); + size_t offset = (ptrdiff_t) lua_tointeger(L, 2); + const char *typesig = (const char*) lua_tostring(L, 3); + const char* sig = typesig; + char ch; + ptr += offset; + while ((ch = *sig++) != '\0') { + switch(ch) { + case DC_SIGCHAR_BOOL: lua_pushboolean(L, *((int*)ptr)); break; + case DC_SIGCHAR_CHAR: lua_pushinteger(L, (int) *((char*)ptr)); break; + case DC_SIGCHAR_UCHAR: lua_pushinteger(L, (int) *((unsigned char*)ptr)); break; + case DC_SIGCHAR_SHORT: lua_pushinteger(L, (int) *((short*)ptr)); break; + case DC_SIGCHAR_USHORT: lua_pushinteger(L, (int) *((unsigned short*)ptr)); break; + case DC_SIGCHAR_INT: lua_pushinteger(L, *((int*)ptr)); break; + case DC_SIGCHAR_UINT: lua_pushnumber(L, (lua_Number) *((unsigned int*)ptr)); break; + case DC_SIGCHAR_LONG: lua_pushnumber(L, (lua_Number) *((long*)ptr)); break; + case DC_SIGCHAR_ULONG: lua_pushnumber(L, (lua_Number) *((unsigned long*)ptr)); break; + case DC_SIGCHAR_LONGLONG: lua_pushnumber(L, (lua_Number) *((DClonglong*)ptr)); break; + case DC_SIGCHAR_ULONGLONG: lua_pushnumber(L, (lua_Number) *((DCulonglong*)ptr)); break; + case DC_SIGCHAR_FLOAT: lua_pushnumber(L, (lua_Number) *((float*)ptr)); break; + case DC_SIGCHAR_DOUBLE: lua_pushnumber(L, (lua_Number) *((double*)ptr)); break; + case DC_SIGCHAR_POINTER: lua_pushlightuserdata(L, *((void**)ptr) ); break; + case DC_SIGCHAR_STRING: lua_pushstring(L, (const char*)ptr); break; + default: luaL_error(L, "invalid type signature %s", typesig); return 0; + } + } + return 1; +} + +static const struct luaL_Reg luareg_dynstruct[] = +{ + { "newstruct", lua_newstruct }, + { "aslightuserdata", lua_aslightuserdata }, + { "dynpoke", lua_dynpoke }, + { "dynpeek", lua_dynpeek }, + { NULL, NULL } +}; + +LUA_API int luaopen_ldynstruct(lua_State *L) +{ + luaL_register(L, "ldynstruct", luareg_dynstruct); + return 1; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/ldyntype.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,64 @@ +#include "lua.h" +#include "lauxlib.h" +#include "dyncall.h" +#include "dyncall_signature.h" + +size_t dtSize(const char* signature) +{ + char ch = *signature; + switch(ch) + { + case DC_SIGCHAR_BOOL: return sizeof(DCbool); + case DC_SIGCHAR_CHAR: return sizeof(DCchar); + case DC_SIGCHAR_UCHAR: return sizeof(DCuchar); + case DC_SIGCHAR_SHORT: return sizeof(DCshort); + case DC_SIGCHAR_USHORT: return sizeof(DCushort); + case DC_SIGCHAR_INT: return sizeof(DCint); + case DC_SIGCHAR_UINT: return sizeof(DCuint); + case DC_SIGCHAR_LONG: return sizeof(DClong); + case DC_SIGCHAR_ULONG: return sizeof(DCulong); + case DC_SIGCHAR_LONGLONG: return sizeof(DClonglong); + case DC_SIGCHAR_ULONGLONG: return sizeof(DCulonglong); + case DC_SIGCHAR_FLOAT: return sizeof(DCfloat); + case DC_SIGCHAR_DOUBLE: return sizeof(DCdouble); + case DC_SIGCHAR_POINTER: return sizeof(DCpointer); + case DC_SIGCHAR_STRING: return sizeof(DCstring); + case DC_SIGCHAR_VOID: return sizeof(DCvoid); + default: return 0; + } +} + +size_t dtAlign(const char* signature) +{ + return dtSize(signature); +} + + +int lua_dtSize(lua_State *L) +{ + const char* signature = luaL_checkstring(L, 1); + lua_pushinteger(L, dtSize(signature)); + return 1; +} + +int lua_dtAlign(lua_State *L) +{ + const char* signature = luaL_checkstring(L, 1); + lua_pushinteger(L, dtAlign(signature)); + return 1; +} + + +static const struct luaL_Reg luareg_ldyntype[] = +{ + { "dtSize", lua_dtSize }, + { "dtAlign", lua_dtAlign }, + { NULL, NULL } +}; + +LUA_API int luaopen_ldyntype(lua_State *L) +{ + luaL_register(L, "ldyntype", luareg_ldyntype); + return 1; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/makedoc.sh Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,5 @@ +# TODO: +# - how to handle C files? such as intutils.cpp and ldynguess.c +TOP=.. +SRCS="typesignature.lua array.lua dynload.lua dyncall.lua dynport.lua path.lua" +luadoc -d "${TOP}/doc" ${SRCS}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/path.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,38 @@ +-- functions to initialize and search through paths. +-- path strings specify a set of directory patterns separated by ';'. +-- the searchpath function + +--- Initialize lua-style paths. +-- Looks up environment variable envname and substitute all ';;' by syspath +-- @param envname name of environment variable +-- @param syspath default value if envname is not set and substitution for all ';;'. +-- @return value from env variable or syspath. ';;' in env will be substituted by syspath. + +function pathinit(envname, syspath) + local envvar = os.getenv(envname) + local path + if envvar then + path = envvar:gsub(";;",syspath) + else + path = syspath + end + return path +end + + +--- find object by searching through the path +-- @param openfun function(expanded) +-- @return found, expanded + +function pathfind(path,name,openfun) + local replaced = path:gsub("?", name) + local found = nil + local fails = {} + for expanded in replaced:gmatch("([^;]+)") do + found = openfun(expanded) + if found then return found, expanded end + table.insert(fails, expanded) + end + return nil, fails +end +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/smartptr.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,158 @@ +/* lua smart pointers - version 0.2 (C only version) */ +/* (C) 2010 Daniel Adler */ + +#include "lua.h" +#include "lauxlib.h" + +#define LUA_SMARTPTR_LIBNAME "smartptr" +#define LUA_SMARTPTR_TNAME "SmartPtr" + +/* +** lua smart pointer +** +** DESCRIPTION +** the smart pointer wraps lightuserdata (lua's object type for carrying raw pointer values) +** into a userdata structure where it also references a finalizer function, which will be called +** with the lightuserdata (not the userdata!) as an argument. +** +** +** LUA INTERFACE +** smartptr = newsmartptr(lightuserdata, function) +** setfinalizer(smartptr, function) +** lightuserdata = tolightuserdata(integer) +** +*/ + +typedef struct +{ + const void* pointer; + int finalizer; /* lua reference */ +} lua_SmartPtr; + +/* +** constructs a SmartPtr userdata lua object. +** +** smartptr.new( pointer, finalizer ) +** +** @param pointer +** @param finalizer function ( to be called with pointer ) or nil +** @return SmartPtr userdata object +*/ + +int lua_smartptr_new(lua_State *L) +{ + const void *ptr; + int ref; + lua_SmartPtr *sptr; + + if (lua_gettop(L) != 2) + luaL_error(L, "argument mismatch, usage:\n\tnewsmartptr( lightuserdata [, finalizer] )"); + + ptr = lua_topointer(L, 1); + luaL_argcheck(L, lua_isfunction(L, 2), 2, "must be a finalizer function"); + + ref = luaL_ref(L, LUA_REGISTRYINDEX); + + sptr = (lua_SmartPtr*) lua_newuserdata(L, sizeof(lua_SmartPtr) ); + + sptr->pointer = ptr; + sptr->finalizer = ref; + + luaL_getmetatable(L, LUA_SMARTPTR_TNAME); + lua_setmetatable(L, -2); + + return 1; +} + +/* +** update finalizer value on SmartPtr object +** +** smartptr.setfinalizer(smartptr, newfinalizer) +** +** @param smartptr object +** @param newfinalizer function or nil +*/ + +int lua_smartptr_setfinalizer(lua_State *L) +{ + lua_SmartPtr* sptr = (lua_SmartPtr*) luaL_checkudata(L, 1, LUA_SMARTPTR_TNAME); + if (lua_isnil(L, 2)) sptr->finalizer = LUA_REFNIL; + lua_rawseti(L, LUA_REGISTRYINDEX, sptr->finalizer); + return 0; +} + +/* +** call finalizer (internal through __gc event) +** +*/ + +int lua_smartptr_callfinalizer(lua_State *L) +{ + lua_SmartPtr* sptr = (lua_SmartPtr*) lua_topointer(L,1); + int r = sptr->finalizer; + if (r != LUA_REFNIL) { + lua_rawgeti(L, LUA_REGISTRYINDEX, r); + lua_pushlightuserdata(L, (void*) sptr->pointer); + lua_call(L, 1, 0); + luaL_unref(L, LUA_REGISTRYINDEX, r); + } +} + +/* +** get pointer value +** +** lua_smartptr_get(smartptr) +** +** @return lightuserdata +** +*/ + +int lua_smartptr_get(lua_State *L) +{ + lua_SmartPtr* sptr = (lua_SmartPtr*) lua_topointer(L,1); + lua_pushlightuserdata(L, (void*) sptr->pointer); + return 1; +} + +/* +** lua c function tolightuserdata(integer) +** +** @return lightuserdata +** +*/ + +int lua_tolightuserdata(lua_State *L) +{ + lua_Number number = lua_tonumber(L, 1); + lua_pushlightuserdata(L, (void*) ( (unsigned long) number ) ); + return 1; +} + +void lua_smartptr_installmetatable(lua_State *L) +{ + if ( luaL_newmetatable(L,LUA_SMARTPTR_TNAME) ) { + lua_pushliteral(L, "__gc"); + lua_pushcfunction(L, lua_smartptr_callfinalizer); + lua_settable(L, -3); + lua_pushliteral(L, "__call"); + lua_pushcfunction(L, lua_smartptr_get); + lua_settable(L, -3); + lua_pop(L,1); + } +} + +static const struct luaL_Reg luareg_smartptr[] = +{ + { "new", lua_smartptr_new }, + { "setfinalizer", lua_smartptr_setfinalizer }, + { "tolightuserdata", lua_tolightuserdata }, + { NULL, NULL } +}; + +LUALIB_API int luaopen_smartptr(lua_State *L) +{ + lua_smartptr_installmetatable(L); + luaL_register(L, LUA_SMARTPTR_LIBNAME, luareg_smartptr); + return 0; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/src/typesignature.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,13 @@ +--- Get type information from type signature. +-- +-- @param typesignature string representing type informations. Fundamental type signatures are represented by characters such as 'c' for C char, 's' for C short, 'i' for C int, 'j' for C long +-- 'l' for C long long, 'f' for C float, 'd' for C double, 'p' for C pointer, +-- 'B' for ISO C99 _Bool_t/C++ bool, 'v' for C void. Upper-case characters 'CSIJL' refer to the corresponding unsigned C type. +-- Function signature syntax: 'name(argtypes..)resulttypes..;' +-- Structure signature syntax: 'name{fieldtypes..)fieldnames..;' the fieldnames are space separated text tokens. +-- Named objects can be refered using '<name>' syntax. +-- pointer types can be specified by prefixing multiple '*'. +function typeinfo(typesignature) +end + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/sqrt.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,3 @@ +require "dyncall" +print( dyncall("@c/sqrt(d)d;", 144) ) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_CocoaEssentials.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,14 @@ +require"dynport" +dynport("CocoaEssentials") +NSApplicationLoad () +dynport("SDL") +SDL_Init(SDL_INIT_VIDEO) +SDL_SetVideoMode(640,480,32,SDL_OPENGL) +dynport("GL") +quit = false +while not quit do + glClearColor(0,0,1,1) + glClear(GL.GL_COLOR_BUFFER_BIT) + SDL_GL_SwapBuffers() +end +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_SDL.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,7 @@ +DG = require "ldynguess" +require "dynport" +if DG.os == "osx" then + dynport "cocoautil" + CocoaInit() +end +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_array.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,8 @@ +require"array" + +x = array("i",10) +print(x.pointer) +x[1] = 23 +print(x[1]) +print(#x) +print(x.length)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_cocoautil.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,14 @@ +require"dynport" +dynport("Cocoa") +CocoaInit() +dynport("SDL") +SDL_Init(SDL_INIT_VIDEO) +SDL_SetVideoMode(640,480,32,SDL_OPENGL) +dynport("GL") +quit = false +while not quit do + glClearColor(0,0,1,1) + glClear(GL.GL_COLOR_BUFFER_BIT) + SDL_GL_SwapBuffers() +end +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_dump_env.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,4 @@ +print("LUA_PATH = ".. ( os.getenv("LUA_PATH") or "<undefined>" ) ) +print("package.path = "..package.path) +-- print("LUA_CPATH = ".. ( os.getenv("LUA_CPATH") or "<undefined>" ) ) +-- print("package.cpath = "..package.cpath)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_dyncall_sqrt.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,4 @@ +require "dyncall" + +print( dyncall("@c/sqrt(d)d;", 144) ) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_dynload.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,5 @@ +require "dynload" + +x = dynload("GL|OpenGL") +print( dynsym(x, "glClear") ) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_dynload_self.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,5 @@ +require"dynload" + +x = dynload("") +print(x) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_dynport_AppKit.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,5 @@ +require"dynport" +AppKit = dynport("AppKit") +local success = AppKit.NSApplicationLoad() +print("success="..tostring(success)) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_dynport_SDL.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,4 @@ +require"dynport" +dynport("SDL") +while true do print( SDL_GetTicks() ) end +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_dynport_cmath.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,5 @@ +require"dynport" +local cmath = dynportImport("cmath", { }) +print(cmath) +print( cmath.sqrt(144) ) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_dynstruct.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,8 @@ +require "dynstruct" + +regstructinfo("Rect{cccc}x y z w;") +x = newdynstruct("Rect") +print(x.x) +x.x = -34 +print(x.x) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_dyntype.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,6 @@ +require "dynstruct" +regstructinfo("Rect{i x i y i w i h}") +x = gettypeinfo("Rect") +dumptypeinfo(x) +-- dumptypeinfos() +y = newdynstruct("Rect")
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_intutils.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,29 @@ +require "intutils" +u64 = intutils.u64 +i64 = intutils.i64 +local _print = print + +local function print(x) + local mt = getmetatable(x) + local tostring = mt.__tostring + if tostring then + _print( tostring(x) ) + else + _print(x) + end +end + +x = u64("0x00FFFFFFFFFFFF00") +y = u64("0xCA000000000000FE") +z = x + y +print(x) +print(y) +print(z) + +x = i64("0x00FFFFFFFFFFFF00") +y = i64("0xCA000000000000FE") +z = x + y +print(x) +print(y) +print(z) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_ldynguess.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,6 @@ +guess = require "ldynguess" + +print("arch = "..guess.arch) +print("os = "..guess.os) +print("cc = "..guess.cc) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_luapath.sh Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,17 @@ +test_unset() { + echo "TEST: <unset>" + lua test_luapath.lua + echo +} + +test_set() { + echo "TEST: LUA_PATH=$1" + LUA_PATH=$1 lua test_luapath.lua + echo +} + +test_unset +test_set "" +test_set ";;" +test_set "AA;;BB" +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_path.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,36 @@ +require "path" +require "dynload" + +function init(env,syspath) + local env = env or "LIBPATH" + local syspath = syspath or ";?.framework/?;lib?.dylib;" + print("env\t="..env) + print("syspath\t="..syspath) + local path = pathinit(env,syspath) + print("path\t="..path) + return(path) +end + +local mypath = init() + +function findlib(name) + local found, location = pathfind(mypath, name, loadlib) + if found then + print("found at " .. location .. " ( object= " .. tostring(found) .. " )" ) + else + print("FAILED: findlib('"..name.."'). tried:\n - " .. table.concat(location,"\n - ") .. "\n" ) + end +end + +function trylib(name) + print("trylib",name) + local status, msg = pcall( findlib, name ) + print(status,msg) +end + +trylib("GL") +trylib("OpenGL") +trylib("SDL") +trylib("Bla") + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_smartptr.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,29 @@ +require "smartptr" + +-- test tolightuserdata + +x = smartptr.tolightuserdata(0xCAFEbabe) +print(x) + +-- test newsmartptr and finalizer + +function finalizer(x) + print("finalizer:"..tostring(x) ) +end + +y = smartptr.new(x, finalizer) +print("dump smartptr : ".. tostring(y) ) +print("dump address : " .. tostring(y())) +y = nil -- should print FINALIZER +collectgarbage("collect") +-- test setfinalizer + +y = smartptr.new( smartptr.tolightuserdata(0xdeadc0de), finalizer) +print("smartptr : ".. tostring(y) ) +print("address : " .. tostring(y())) +function newfinalizer(x) + print("newfinalizer:"..tostring(x)) +end +smartptr.setfinalizer(y, newfinalizer) +y = nil +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/luadyncall/test/test_stdlib.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,16 @@ +require "dynport" +dynport("stdlib") + +function checkmalloc(size) + local ptr = malloc(size) + if ptr == NULL then + print("FAILED") + else + print("SUCCESS",ptr) + end +end +checkmalloc(-1) +checkmalloc(0) +checkmalloc(10) + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/test/Makefile Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,17 @@ +DC_TOP = ../../../dyncall +CC = gcc +LUA_INCDIR = ../lua-5.1.3/src +LUA_LIBDIR = ../lua-5.1.3/src +CFLAGS = -I$(LUA_INCDIR) -I$(DC_TOP)/include +LIBS = -L$(LUA_LIBDIR) -llua -L$(DC_TOP)/lib -ldynload_s -ldyncall_s + +all: test luadc + +test: main.o + $(LINK.c) $^ $(LIBS) $(OUTPUT_OPTION) + +LINK.DLL = gcc --shared + +luadc.dll: luadc.o + $(LINK.DLL) $^ $(LIBS) $(OUTPUT_OPTION) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/test/README Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,17 @@ + +1. library resource management + + lib + + funcs ref libs + +2. mode selection + + + +callvm = dc.newCallVM() + +callvm:mode(dc.DEFAULT_C) +callvm:call(f, "iSSi)v", 1, 2, 3, 4) + +callvm:call
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/test/design.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,17 @@ + +-- loading libraries and resolve symbols in lua + +local path = "/usr/local/lua/lib/libluadc.so" +dclib = loadlib("luadc", "luaopen_dc") +dclib() + + +dc.load("bla") +dc.find("hallo") + +callpad = dc.newcallvm(4096) +callpad.mode("__cdecl") +callpad(f,"iSSi)v",0,"hello","world",0) + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/test/loadlib.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,9 @@ +require"package" +msgbox = package.loadlib("user32","MessageBoxA") +print(msgbox) +dcCall(msgbox,"iSSi)v",0,"hello","world",0) +sqrt = package.loadlib("msvcrt","sqrt") +print(sqrt) +x = dcCall(sqrt,"d)d",144) +-- print(x) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/test/luadc.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,146 @@ +#include <lua.h> +#include <lauxlib.h> +#include <dyncall.h> +#include <dyncall_signature.h> +#include <dynload.h> + +#define LUA_DCLIBNAME "dc" + +DCCallVM* g_pCallVM; + +int luaDC_load(lua_State* L) +{ + void* handle; + if (lua_gettop(L) != 1) return luaL_error(L,"wrong number of arguments"); + handle = dlLoadLibrary( lua_tostring(L,1) ); + if (!handle) return luaL_error(L,"library not found"); + lua_pushlightuserdata(L, handle); + return 1; +} + +int luaDC_find(lua_State* L) +{ + void* h; + const char* s; + void* f; + if (lua_gettop(L) != 2) return luaL_error(L,"wrong number of arguments"); + h = lua_touserdata(L, 1); + s = lua_tostring(L, 2); + f = dlFindSymbol(h, s); + if (!f) return luaL_error(L,"symbol not found"); + lua_pushlightuserdata(L, f); + return 1; +} + +int luaDC_call(lua_State* L) +{ + void* f; + const char* s; + if (lua_gettop(L) < 2) return luaL_error(L,"missing arguments"); + + if ( lua_iscfunction(L,1) ) + f = (void*) lua_tocfunction(L,1); + else if (lua_islightuserdata(L,1) ) + f = lua_touserdata(L, 1); + else + return luaL_error(L,"argument #1 mismatch: expected userdata"); + + s = lua_tostring(L,2); + + dcMode( g_pCallVM, DC_CALL_C_DEFAULT ); + dcReset( g_pCallVM ); + + char ch; + int p = 3; + while ( (ch = *s++) != DC_SIGCHAR_ENDARG) + { + switch(ch) + { + case DC_SIGCHAR_BOOL: + dcArgBool(g_pCallVM, (DCbool) lua_toboolean(L, p) ); + break; + case DC_SIGCHAR_CHAR: + dcArgChar(g_pCallVM, (DCchar) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_SHORT: + dcArgShort(g_pCallVM, (DCshort) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_INT: + dcArgInt(g_pCallVM, (DCint) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_LONG: + dcArgLong(g_pCallVM, (DClong) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_LONGLONG: + dcArgLongLong(g_pCallVM, (DClonglong) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_FLOAT: + dcArgFloat(g_pCallVM, (DCfloat) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_DOUBLE: + dcArgDouble(g_pCallVM, (DCdouble) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_POINTER: + dcArgPointer(g_pCallVM, (DCpointer) lua_topointer(L, p) ); + break; + case DC_SIGCHAR_STRING: + dcArgPointer(g_pCallVM, (DCpointer) lua_tostring(L, p) ); + break; + } + ++p; + } + + switch(*s) + { + case DC_SIGCHAR_VOID: + dcCallVoid(g_pCallVM, f); + return 0; + case DC_SIGCHAR_BOOL: + lua_pushboolean( L, (int) dcCallBool(g_pCallVM, f) ); + break; + case DC_SIGCHAR_CHAR: + lua_pushnumber( L, (lua_Number) ( dcCallChar(g_pCallVM,f) ) ); + break; + case DC_SIGCHAR_SHORT: + lua_pushnumber( L, (lua_Number)( dcCallShort(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_INT: + lua_pushnumber( L, (lua_Number)( dcCallInt(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_LONG: + lua_pushnumber( L, (lua_Number)( dcCallLong(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_LONGLONG: + lua_pushnumber( L, (lua_Number)( dcCallLongLong(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_FLOAT: + lua_pushnumber( L, (lua_Number) dcCallFloat(g_pCallVM, f) ); + break; + case DC_SIGCHAR_DOUBLE: + lua_pushnumber( L, (lua_Number) dcCallDouble(g_pCallVM, f) ); + break; + case DC_SIGCHAR_STRING: + lua_pushstring( L, (const char*) dcCallPointer(g_pCallVM, f) ); + break; + case DC_SIGCHAR_POINTER: + lua_pushlightuserdata( L, dcCallPointer(g_pCallVM, f) ); + break; + } + return 1; +} + +static const luaL_Reg dclib[] = +{ + {"load", luaDC_load}, + {"find", luaDC_find}, + {"call", luaDC_call}, + {NULL,NULL} +}; + +LUA_API int luadc_open (lua_State* L) +{ + g_pCallVM = dcNewCallVM(256); + luaL_register(L, LUA_DCLIBNAME, dclib); + return 1; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/test/main.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,163 @@ +#include <lua.h> +#include <assert.h> +#include <dynload.h> +#include <dyncall.h> +#include <dyncall_signature.h> + +int lua_dcload(lua_State* L) +{ + void* handle; + if (lua_gettop(L) != 1) return luaL_error(L,"wrong number of arguments"); + handle = dlLoadLibrary( lua_tostring(L,1) ); + if (!handle) return luaL_error(L,"library not found"); + lua_pushlightuserdata(L, handle); + return 1; +} + +int lua_dcfind(lua_State* L) +{ + void* h; + const char* s; + void* f; + if (lua_gettop(L) != 2) return luaL_error(L,"wrong number of arguments"); + h = lua_touserdata(L, 1); + s = lua_tostring(L, 2); + f = dlFindSymbol(h, s); + if (!f) return luaL_error(L,"symbol not found"); + lua_pushlightuserdata(L, f); + return 1; +} + +DCCallVM* g_pCallVM; + +int lua_dccall(lua_State* L) +{ + void* f; + const char* s; + if (lua_gettop(L) < 2) return luaL_error(L,"missing arguments"); + + if ( lua_iscfunction(L,1) ) + f = (void*) lua_tocfunction(L,1); + else if (lua_islightuserdata(L,1) ) + f = lua_touserdata(L, 1); + else + return luaL_error(L,"argument #1 mismatch: expected userdata"); + + s = lua_tostring(L,2); + + // dcMode( g_pCallVM, DC_CALL_C_X86_WIN32_STD ); + dcReset( g_pCallVM ); + + char ch; + int p = 3; + while ( (ch = *s++) != DC_SIGCHAR_ENDARG) + { + switch(ch) + { + case DC_SIGCHAR_BOOL: + dcArgBool(g_pCallVM, (DCbool) lua_toboolean(L, p) ); + break; + case DC_SIGCHAR_CHAR: + dcArgChar(g_pCallVM, (DCchar) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_SHORT: + dcArgShort(g_pCallVM, (DCshort) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_INT: + dcArgInt(g_pCallVM, (DCint) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_LONG: + dcArgLong(g_pCallVM, (DClong) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_LONGLONG: + dcArgLongLong(g_pCallVM, (DClonglong) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_FLOAT: + dcArgFloat(g_pCallVM, (DCfloat) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_DOUBLE: + dcArgDouble(g_pCallVM, (DCdouble) lua_tonumber(L, p) ); + break; + case DC_SIGCHAR_POINTER: + dcArgPointer(g_pCallVM, (DCpointer) lua_topointer(L, p) ); + break; + case DC_SIGCHAR_STRING: + dcArgPointer(g_pCallVM, (DCpointer) lua_tostring(L, p) ); + break; + } + ++p; + } + + switch(*s) + { + case DC_SIGCHAR_VOID: + dcCallVoid(g_pCallVM, f); + return 0; + case DC_SIGCHAR_BOOL: + lua_pushboolean( L, (int) dcCallBool(g_pCallVM, f) ); + break; + case DC_SIGCHAR_CHAR: + lua_pushnumber( L, (lua_Number) ( dcCallChar(g_pCallVM,f) ) ); + break; + case DC_SIGCHAR_SHORT: + lua_pushnumber( L, (lua_Number)( dcCallShort(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_INT: + lua_pushnumber( L, (lua_Number)( dcCallInt(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_LONG: + lua_pushnumber( L, (lua_Number)( dcCallLong(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_LONGLONG: + lua_pushnumber( L, (lua_Number)( dcCallLongLong(g_pCallVM, f) ) ); + break; + case DC_SIGCHAR_FLOAT: + lua_pushnumber( L, (lua_Number) dcCallFloat(g_pCallVM, f) ); + break; + case DC_SIGCHAR_DOUBLE: + lua_pushnumber( L, (lua_Number) dcCallDouble(g_pCallVM, f) ); + break; + case DC_SIGCHAR_STRING: + lua_pushstring( L, (const char*) dcCallPointer(g_pCallVM, f) ); + break; + case DC_SIGCHAR_POINTER: + lua_pushlightuserdata( L, dcCallPointer(g_pCallVM, f) ); + break; + } + return 1; +} + +int main(int argc, char* argv[]) +{ + lua_State* L; + lua_Debug d; + int status; + const char* scriptFilename = argv[1]; + + L = lua_open(); + assert(L); + luaL_openlibs(L); + luaopen_base(L); + + g_pCallVM = dcNewCallVM(256); + + lua_register(L, "dcLoad", lua_dcload); + lua_register(L, "dcFind", lua_dcfind); + lua_register(L, "dcCall", lua_dccall); + + status = luaL_loadfile(L, scriptFilename); + + if (status == 0) + { + status = lua_pcall(L, 0, LUA_MULTRET, 0); + } + if (status) + { + printf("error: %s\n", lua_tostring(L,-1)); + lua_pop(L, 1); + } + + dcFree(g_pCallVM); + + lua_close(L); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/test/msgbox.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,8 @@ +user32 = dcLoad("user32") +msgbox = dcFind(user32,"MessageBoxA") +print(msgbox) +dcCall(msgbox, "iSSi)v", 0, "hello", "world", 0) + +dcCall(msgbox, "iSSi)v", 0, "hello", "world2", 0) + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lua/test/sqrt.lua Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,15 @@ +clib = dcLoad("msvcrt") +f = dcFind(clib,"sqrt") + +x = dcCall(f,"d)d",144) +io.write("result ",x,"\n") + +x = dcCall(f,"d)d",225) +io.write("result ",x,"\n") + + +f = dc("msvcrt:sqrt(d)d") +f() + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/python/pydc/GNUmakefile Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,6 @@ +TOP = ../../.. +include $(TOP)/build/gmake/prolog.gmake +PYSETUPFLAGS = -I $(TOP)/dyncall:$(TOP)/dynload -L $(TOP)/dyncall/$(BUILD_DIR):$(TOP)/dynload/$(BUILD_DIR) +PYTHON_SETUP = setup.py +include $(TOP)/build/gmake/epilog.gmake +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/python/pydc/README.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,60 @@ +dyncall python bindings +(C) 2007 Daniel Adler. +2007 04. December + +API + +libhandle = load(libpath) +funcptr = find(libhandle, symbolname ) +call( funcptr,signature, ... ) + +SIGNATURE FORMAT + + is a formated string + + format: "xxxxx)y" + + x is positional parameter-type charcode + + 'b' C++: bool <- Python: PyBool + 'i' C: int <- Python: PyInt + 'l' C: long long <- Python: PyLongLong + 'p' C: void* <- Python: PyCObject + 's' C: const char* <- Python: PyString + + y is result-type charcode + + 'v' void + 'i' int -> PyInt + 'l' long -> PyLong + 'p' ptr -> PyCObject encapsulating a void* + 'f' float -> PyFloat (upcast to double) + 'd' double -> PyFloat + +BUGS + +* build on osx/ppc - link error i386 something... [MacPython 2.4] + + solution: + installation of latest pytho for os x (MacPython 2.5) + + build log: + + python setup.py install + running install + running build + running build_py + creating build + creating build/lib.macosx-10.3-fat-2.4 + copying pydc.py -> build/lib.macosx-10.3-fat-2.4 + running build_ext + building 'pydcext' extension + creating build/temp.macosx-10.3-fat-2.4 + gcc -arch ppc -arch i386 -isysroot /Developer/SDKs/MacOSX10.4u.sdk -fno-strict-aliasing -Wno-long-double -no-cpp-precomp -mno-fused-madd -fno-common -dynamic -DNDEBUG -g -O3 -I../../../dyncall -I../../../dynload -I/Library/Frameworks/Python.framework/Versions/2.4/include/python2.4 -c pydcext.c -o build/temp.macosx-10.3-fat-2.4/pydcext.o + gcc -arch i386 -arch ppc -isysroot /Developer/SDKs/MacOSX10.4u.sdk -g -bundle -undefined dynamic_lookup build/temp.macosx-10.3-fat-2.4/pydcext.o -L../../../dyncall -L../../../dynload -ldyncall_s -ldynload_s -lstdc++ -o build/lib.macosx-10.3-fat-2.4/pydcext.so + /usr/bin/ld: for architecture i386 + /usr/bin/ld: warning ../../../dyncall/libdyncall_s.a archive's cputype (18, architecture ppc) does not match cputype (7) for specified -arch flag: i386 (can't load from it) + /usr/bin/ld: warning ../../../dynload/libdynload_s.a archive's cputype (18, architecture ppc) does not match cputype (7) for specified -arch flag: i386 (can't load from it) + running install_lib + copying build/lib.macosx-10.3-fat-2.4/pydcext.so -> /Library/Frameworks/Python.framework/Versions/2.4/lib/python2.4/site-packages +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/python/pydc/examples/atoi.py Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,19 @@ +from pydc import * +from sys import platform + +if platform == "win32": + libc = load("msvcrt") +elif platform == "darwin": + libc = load("/usr/lib/libc.dylib") +else: + libc = load("/lib/libc.so.6") + +fp_atoi = find(libc,"atoi") +fp_atof = find(libc,"atof") + +def atoi(s): return call(fp_atoi,"p)i",s) +def atod(s): return call(fp_atof,"p)d",s) + +print atoi( "3".join(["12","45"]) ) +print atod( "3".join(["12","45"]) ) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/python/pydc/examples/sintest.py Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,33 @@ +import math +import os +import pydc + +def f1(n): + for x in xrange(n): + math.sin(x) +# filter( math.sin, range(0,n) ) + + +libc = pydc.load("msvcrt") +fpsin = pydc.find(libc,"sin") + +def libcsin(x): pass + +def f2(n): + for x in xrange(n): + pydc.call(fpsin,"d)d",float(x)) +# libcsin(i) + +# filter( libcsin , range(0,n) ) + + +#b = os.times() +f1(10000000) +#f2(10000000) +e = os.times() + +print e + + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/python/pydc/examples/win32msgbox.py Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,11 @@ +from pydc import * + +""" show message box on windows """ + +user32 = load("user32") +fpMessageBoxA = find(user32,"MessageBoxA") +def showMessage(name,title="dyncall demo",type=0): + call(fpMessageBoxA,"ippi)v",0,name,title,type) + +showMessage("hello") +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/python/pydc/pydc.py Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,14 @@ +import pydcext + +def load(libpath): + return pydcext.load(libpath) + +def find(libhandle,symbol): + return pydcext.find(libhandle,symbol) + +def free(libhandle): + pydcext.free(libhandle) + +def call(funcptr,signature,*arguments): + return pydcext.call(funcptr,signature,arguments) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/python/pydc/pydcext.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,278 @@ +/****************************************************************************** + ** + ** pydc - python dyncall package + ** + ** python extension package in C + ** Copyright 2007 Daniel Adler. + ** + ** December 04, 2007 + ** + *****************************************************************************/ + +#include <Python.h> +#include "dynload.h" +#include <limits.h> + +/* PyCObject destructor callback for libhandle */ + +void free_library(void* libhandle) +{ + if (libhandle != 0) + dlFreeLibrary(libhandle); +} + +/* load function */ + +static PyObject* +pydc_load(PyObject* self, PyObject* args) +{ + const char* libpath; + void* libhandle; + + if ( !PyArg_ParseTuple(args,"s", &libpath) ) return PyErr_Format(PyExc_RuntimeError, "libpath argument (string) missing"); + + libhandle = dlLoadLibrary(libpath); + + if (!libhandle) return PyErr_Format(PyExc_RuntimeError, "dlLoadLibrary('%s') failed", libpath); + + return PyCObject_FromVoidPtr(libhandle, &free_library); +} + +/* find function */ + +static PyObject* +pydc_find(PyObject* self, PyObject* args) +{ + PyObject* pcobj; + const char* symbol; + void* libhandle; + void* funcptr; + + if ( !PyArg_ParseTuple(args,"Os", &pcobj, &symbol) ) return PyErr_Format(PyExc_RuntimeError, "argument mismatch"); + + libhandle = PyCObject_AsVoidPtr(pcobj); + + if (!libhandle) return PyErr_Format(PyExc_RuntimeError, "libhandle is null"); + + funcptr = dlFindSymbol(libhandle, symbol); + if (!funcptr) + return PyErr_Format(PyExc_RuntimeError, "symbol '%s' not found", symbol); + + return PyCObject_FromVoidPtr(funcptr, NULL); +} + +/* free function */ + +static PyObject* +pydc_free(PyObject* self, PyObject* args) +{ + PyObject* pcobj; + void* libhandle; + + if ( !PyArg_ParseTuple(args,"o", &pcobj) ) return PyErr_Format(PyExc_RuntimeError, "argument mismatch"); + + libhandle = PyCObject_AsVoidPtr(pcobj); + + if (!libhandle) return PyErr_Format(PyExc_RuntimeError, "libhandle is NULL"); + + dlFreeLibrary(libhandle); + PyCObject_SetVoidPtr(pcobj,0); + Py_RETURN_NONE; +} + +#include "dyncall.h" +#include "dyncall_signature.h" + +DCCallVM* gpCall; + +/* call function */ + +static PyObject* +pydc_call(PyObject* self, PyObject* in_args) +{ + PyObject* pcobj_funcptr; + const char* signature; + PyObject* args; + int l; + const char* ptr; + char ch; + int pos; + void* pfunc; + + if ( !PyArg_ParseTuple(in_args,"OsO", &pcobj_funcptr, &signature, &args) ) return PyErr_Format(PyExc_RuntimeError, "argument mismatch"); + pfunc = PyCObject_AsVoidPtr(pcobj_funcptr); + if ( !pfunc ) return PyErr_Format( PyExc_RuntimeError, "function pointer is NULL" ); + l = PyTuple_Size(args); + + ptr = signature; + pos = 0; + + dcReset(gpCall); + + while ( (ch = *ptr) != '\0' && ch != ')' ) + { + PyObject* po; + + int index = pos+1; + + if (pos > l) return PyErr_Format( PyExc_RuntimeError, "expecting more arguments" ); + + po = PyTuple_GetItem(args,pos); + + switch(ch) + { + case DC_SIGCHAR_BOOL: + { + DCbool b; + if ( !PyBool_Check(po) ) return PyErr_Format( PyExc_RuntimeError, "argument mismatch at pos %d - expecting a bool", index ); + b = (Py_True == po) ? DC_TRUE : DC_FALSE; + dcArgBool(gpCall, b); + } + break; + case DC_SIGCHAR_CHAR: + { + DCchar c; + if ( PyString_Check(po) ) + { + // Py_ssize_t l; + size_t l; + char* s; + l = PyString_GET_SIZE(po); + if (l != 1) return PyErr_Format( PyExc_RuntimeError, "argument mismatch at pos %d - expecting a string with length of 1 (a char string)", index ); + s = PyString_AsString(po); + c = (DCchar) s[0]; + } + else if ( PyInt_Check(po) ) + { + long l; + l = PyInt_AsLong(po); + if ( (l > CHAR_MAX) || (l < CHAR_MIN)) return PyErr_Format( PyExc_RuntimeError, "value out of range at argument %d - expecting a char code", index ); + c = (DCchar) l; + } + else return PyErr_Format( PyExc_RuntimeError, "argument mismatch at pos %d - expecting a char", index ); + dcArgChar(gpCall, c); + } + break; + case DC_SIGCHAR_SHORT: + { + DCshort s; + long v; + if ( !PyInt_Check(po) ) + return PyErr_Format( PyExc_RuntimeError, "argument mismatch at pos %d - expecting a short int", index ); + v = PyInt_AS_LONG(po); + if ( (v < SHRT_MIN) || (v > SHRT_MAX) ) + return PyErr_Format( PyExc_RuntimeError, "value out of range at argument %d - expecting a short value", index ); + s = (DCshort) v; + dcArgShort(gpCall, s); + } + break; + case DC_SIGCHAR_INT: + { + long v; + if ( !PyInt_Check(po) ) return PyErr_Format( PyExc_RuntimeError, "argument mismatch at pos %d - expecting an int", index ); + v = PyInt_AS_LONG(po); + dcArgInt(gpCall, (DCint) v ); + } + break; + case DC_SIGCHAR_LONG: + { + long v; + if ( !PyInt_Check(po) ) return PyErr_Format( PyExc_RuntimeError, "argument mismatch at pos %d - expecting an int", index ); + v = PyInt_AsLong(po); + + } + break; + case DC_SIGCHAR_LONGLONG: + { + PY_LONG_LONG pl; + DClonglong dl; + if ( !PyLong_Check(po) ) return PyErr_Format( PyExc_RuntimeError, "argument mismatch at pos %d - expecting a long long", index ); + pl = PyLong_AsLongLong(po); + dl = (DClonglong) pl; + dcArgLongLong(gpCall, dl ); + } + break; + case DC_SIGCHAR_FLOAT: + { + DCfloat f; + if (!PyFloat_Check(po)) return PyErr_Format( PyExc_RuntimeError, "argument mismatch at pos %d - expeecting a float", index ); + f = (float) PyFloat_AsDouble(po); + dcArgFloat(gpCall, f); + } + break; + case DC_SIGCHAR_DOUBLE: + { + double d; + if (!PyFloat_Check(po)) return PyErr_Format( PyExc_RuntimeError, "argument mismatch at pos %d - expeecting a float", index ); + d = PyFloat_AsDouble(po); + dcArgDouble(gpCall, d); + } + break; + case DC_SIGCHAR_POINTER: + { + DCpointer ptr; + if ( PyString_Check(po) ) { + ptr = (DCpointer) PyString_AsString(po); + } else if ( PyLong_Check(po) ) { + ptr = (DCpointer) ( (DCint) PyLong_AsLongLong(po) ); + } else { + return PyErr_Format( PyExc_RuntimeError, "argument mismatch at pos %d - expecting a promoting pointer-type (int,string)", index ); + } + dcArgPointer(gpCall, ptr ); + } + break; + case 'S': + { + char* p; + if (!PyString_Check(po) ) return PyErr_Format( PyExc_RuntimeError, "argument mismatch at pos %d - expecting a string", index ); + p = PyString_AsString(po); + dcArgPointer(gpCall, (DCpointer) p ); + } + break; + default: return PyErr_Format( PyExc_RuntimeError, "unknown signature character '%c'", ch); + } + + ++pos; ++ptr; + + } + + if (pos != l) return PyErr_Format( PyExc_RuntimeError, "too many arguments"); + + if (ch == '\0') return PyErr_Format( PyExc_RuntimeError, "return value missing in signature"); + + ch = *++ptr; + + switch(ch) + { + case DC_SIGCHAR_VOID: dcCallVoid(gpCall, pfunc); Py_RETURN_NONE; + case DC_SIGCHAR_BOOL: return Py_BuildValue("i", dcCallBool(gpCall, pfunc) ); + case DC_SIGCHAR_INT: return Py_BuildValue("i", dcCallInt(gpCall, pfunc) ); + case DC_SIGCHAR_LONGLONG: return Py_BuildValue("L", (unsigned long long) dcCallLongLong(gpCall, pfunc) ); + case DC_SIGCHAR_FLOAT: return Py_BuildValue("f", dcCallFloat(gpCall, pfunc) ); + case DC_SIGCHAR_DOUBLE: return Py_BuildValue("d", dcCallDouble(gpCall, pfunc) ); + case 's': return Py_BuildValue("s", dcCallPointer(gpCall, pfunc) ); + case DC_SIGCHAR_POINTER: return Py_BuildValue("p", dcCallPointer(gpCall, pfunc) ); + default: return PyErr_Format( PyExc_RuntimeError, "invalid return type signature" ); + } +} + + +static PyMethodDef pydcMethods[] = { + {"load", pydc_load, METH_VARARGS, "load library"}, + {"find", pydc_find, METH_VARARGS, "find symbols"}, + {"free", pydc_free, METH_VARARGS, "free library"}, + {"call", pydc_call, METH_VARARGS, "call function"}, + {NULL,NULL,0,NULL} +}; + +PyMODINIT_FUNC +initpydcext(void) +{ + PyObject* m; + m = Py_InitModule("pydcext", pydcMethods); + if (m == NULL) + return; + gpCall = dcNewCallVM(4096); +} + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/python/pydc/setup.py Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,32 @@ +from distutils.core import setup, Extension + +dctop = '../../..' + +pydcext = Extension('pydcext', + sources = ['pydcext.c'] +#,include_dirs=[ "/".join([dctop,'dyncall']), "/".join([dctop,'dynload']) ] +#,library_dirs=[ "/".join([dctop,'dyncall']), "/".join([dctop,'dynload']) ] +,libraries=['dyncall_s','dynload_s'] +) + +setup( + name='pydc' +, version='0.1' +, author = 'Daniel Adler' +, author_email = 'dadler@uni-goettingen.de' +, maintainer = 'Daniel Adler' +, maintainer_email = 'dadler@uni-goettingen.de' +, url = 'http://dyncall.org' +, description = 'dynamic call bindings for python' +, long_description = ''' +dynamic call library allows to call arbitrary library functions +with a single call code (written in assembly) +''' +, download_url = 'http://dyncall.org/download' +, classifiers=[] +#, packages=['pydc'] +#, package_dir['dir'] +, ext_modules = [pydcext] +, py_modules = ['pydc'] +) +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/python/pydc/sintest-timings.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,16 @@ +sintest.py! +==========! + + +* f2 + + C:\lab\dyncall\bindings\python\pydc\examples>sintest.py + (0.1875, 26.265625, 0.0, 0.0, 0.0) + + +* f1 + + C:\lab\dyncall\bindings\python\pydc\examples>sintest.py + (0.171875, 4.1875, 0.0, 0.0, 0.0) + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ruby/rbdc/README.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,54 @@ +dyncall ruby bindings +Copyright 2007-2014 Tassilo Philipp + + +BUILD + + Build and install this gem with: + (cd ../../../dyncall; make distclean) || (gem build rbdc.gemspec && gem install ../../../rbdc-*.gem) + + +SIGNATURE FORMAT + + format: "xxxxx)y" + + x is positional parameter-type charcode + + 'B' C++: bool <- Ruby: TrueClass, FalseClass, NilClass, Fixnum + 'c' C: char <- Ruby: Fixnum + 'C' C: unsigned char <- Ruby: Fixnum + 's' C: short <- Ruby: Fixnum + 'S' C: unsigned short <- Ruby: Fixnum + 'i' C: int <- Ruby: Fixnum + 'I' C: unsigned int <- Ruby: Fixnum + 'j' C: long <- Ruby: Fixnum + 'J' C: unsigned long <- Ruby: Fixnum + 'l' C: long long <- Ruby: Fixnum + 'L' C: unsigned long long <- Ruby: Fixnum + 'f' C: float <- Ruby: Float + 'd' C: double <- Ruby: Float + 'p' C: void* <- Ruby: String (check if there are other pointer-convertible ruby types @@@) + 'Z' C: void* <- Ruby: String + + y is result-type charcode + + 'v' C: void -> Ruby: NilClass + 'B' C: bool -> Ruby: TrueClass, FalseClass + 'c' C: char -> Ruby: Fixnum + 'C' C: unsigned char -> Ruby: Fixnum + 's' C: short -> Ruby: Fixnum + 'S' C: unsigned short -> Ruby: Fixnum + 'i' C: int -> Ruby: Fixnum + 'I' C: unsigned int -> Ruby: Fixnum + 'j' C: long -> Ruby: Fixnum + 'J' C: unsigned long -> Ruby: Fixnum + 'l' C: long long -> Ruby: Fixnum + 'L' C: unsigned long long -> Ruby: Fixnum + 'f' C: float -> Ruby: Float + 'd' C: double -> Ruby: Float + 'p' C: void* -> unsupported at the moment @@@ + 'Z' C: void* -> Ruby: String + + +-> Note that signature suffixes used to indicate calling +-> conventions, are not supported yet! @@@
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ruby/rbdc/examples/unix_math.rb Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,25 @@ +#////////////////////////////////////////////////////////////////////// +# +# unix_math.rb +# Copyright 2014 Tassilo Philipp +# +# Dyncall sample loading libm and calling functions +# +#/////////////////////////////////////////////////////////////////////// + +require 'rbdc' + +l = Dyncall::ExtLib.new +if l.load('/usr/lib/libm.so') != nil and l.syms_init('/usr/lib/libm.so') != nil + puts 'Symbols in libm: '+l.syms_count.to_s + puts 'All symbol names in libm:' + l.syms_each { |s| puts s } + + puts 'libm has sqrtf()? ' + l.exists?(:sqrtf) .to_s + puts 'libm has pow()? ' + l.exists?(:pow) .to_s + puts 'libm has not_in_libm()? ' + l.exists?(:not_in_libm).to_s + + puts 'sqrtf(36.f) = ' + l.call(:sqrtf, 'f)f', 36.0) .to_s + puts 'pow(2.0, 10.0) = ' + l.call(:pow, 'dd)d', 2.0, 10.0).to_s +end +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ruby/rbdc/examples/win32msgbox.rb Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,22 @@ +#////////////////////////////////////////////////////////////////////// +# +# win32msgbox.rb +# Copyright 2007-2014 Tassilo Philipp +# +# Dyncall sample loading user32.dll on windows, listing all user32 +# symbols and displaying a # native windows message box by calling +# MessageBoxA(...). +# +#/////////////////////////////////////////////////////////////////////// + +require 'rbdc' + +l = Dyncall::ExtLib.new +if l.load('user32') != nil and l.syms_init('user32') + l.syms_each { |s| puts s } + puts l.syms_count + puts l.exists?(:NonExistant) + puts l.exists?(:MessageBoxA) + puts l.call(:MessageBoxA, 'IZZI)i', 0, 'Hello world from dyncall!', 'dyncall demo', 0) + # @@@ check puts on dyncall called function returning a void... crashes e.g. change above signature to IZZI)v +end
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ruby/rbdc/examples/win32screenres.rb Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,18 @@ +#////////////////////////////////////////////////////////////////////// +# +# win32screeninfo.rb +# Copyright 2007 Tassilo Philipp +# +# Dyncall sample loading user32.dll on windows and displaying a +# native windows message box by calling MessageBoxA(...). +# +#/////////////////////////////////////////////////////////////////////// + +require 'rbdc' + +l = Dyncall::ExtLib.new +if l.load('user32') != nil + puts 'width: ' + l.call(:GetSystemMetrics, 'i)i', 0).to_s + puts 'height: ' + l.call(:GetSystemMetrics, 'i)i', 1).to_s + puts 'number of monitors: ' + l.call(:GetSystemMetrics, 'i)i', 80).to_s +end
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ruby/rbdc/extconf.rb Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,59 @@ +#////////////////////////////////////////////////////////////////////// +# +# extconf.rb +# Copyright (c) 2007-2014 Daniel Adler <dadler@uni-goettingen.de>, +# Tassilo Philipp <tphilipp@potion-studios.com> +# +# Permission to use, copy, modify, and distribute this software for any +# purpose with or without fee is hereby granted, provided that the above +# copyright notice and this permission notice appear in all copies. +# +# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +# ANY SPECIAL, DIRECT, 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. +# +# Configuration file for dyncall/ruby extension. This script creates +# a makefile that can be used to compile the C-extension. It is +# configured such that every .c file in this directory will be used +# for compilation. +# +#/////////////////////////////////////////////////////////////////////// + +require 'mkmf' + +dir_config 'rbdc' +base_dir = '../../../dyncall/' + +$CFLAGS << ' -I../../../dyncall/dyncall ' + +# Build dyncall libs. +puts 'Building dyncall libraries:' +Dir.chdir(base_dir) do + cmd = case + when RUBY_PLATFORM =~ /mswin/ then 'configure.bat && nmake /f Nmakefile' + else './configure && env CFLAGS="-fPIC" make' + end + puts cmd + raise "'#{cmd}' failed" unless system(cmd) +end + +# Search for dyncall libs. +puts 'Using the following dyncall libraries to build native ruby extension:' +Dir[base_dir+'**/*'].each { |d| + if d =~ /(lib)?dyn(call(back)?|load)_s\./ + $LOCAL_LIBS << '"'+d+'" ' + puts d + end +} + +if($LOCAL_LIBS.size > 0) then + # Write out a makefile for our dyncall extension. + create_makefile 'rbdc' +else + puts "Couldn't find dyncall and dynload libraries - dyncall build seems to have failed!" +end +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ruby/rbdc/rbdc.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,306 @@ +/* + + rbdc.c + Copyright (c) 2007-2014 Daniel Adler <dadler@uni-goettingen.de>, + Tassilo Philipp <tphilipp@potion-studios.com> + + Permission to use, copy, modify, and distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, 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. + + Ruby/dyncall extension implementation. + +*/ + + +#include <ruby.h> +#include "../../../dyncall/dyncall/dyncall.h" +#include "../../../dyncall/dyncallback/dyncall_callback.h" +#include "../../../dyncall/dynload/dynload.h" +#include "../../../dyncall/dyncall/dyncall_signature.h" + +/* Our ruby module and its classes. */ +static VALUE rb_dcModule; +static VALUE rb_dcExtLib; + + +typedef struct { + void* lib; + void* syms; + DCCallVM* cvm; +} rb_dcLibHandle; + + +/* Allocator for handle and mark-and-sweep GC handlers. */ +static void GCMark_ExtLib(rb_dcLibHandle* h) +{ +} + +static void GCSweep_ExtLib(rb_dcLibHandle* h) +{ + if(h->lib != NULL) dlFreeLibrary(h->lib); + if(h->syms != NULL) dlSymsCleanup(h->syms); + + dcFree(h->cvm); + free(h); +} + +static VALUE AllocExtLib(VALUE cl) +{ + rb_dcLibHandle* h = malloc(sizeof(rb_dcLibHandle)); + h->lib = NULL; + h->syms = NULL; + h->cvm = dcNewCallVM(4096/*@@@*/); + return Data_Wrap_Struct(cl, GCMark_ExtLib, GCSweep_ExtLib, h); +} + + +/* Helpers */ +static void ExtLib_SecCheckLib(rb_dcLibHandle* h) +{ + if(h->lib == NULL) + rb_raise(rb_eRuntimeError, "no library loaded - use ExtLib#load"); +} + +static void ExtLib_SecCheckSyms(rb_dcLibHandle* h) +{ + if(h->syms == NULL) + rb_raise(rb_eRuntimeError, "no symbol table initialized - use ExtLib#symsInit"); +} + + + +/* Methods for lib access */ +static VALUE ExtLib_Load(VALUE self, VALUE path) +{ + void* newLib; + rb_dcLibHandle* h; + + if(TYPE(path) != T_STRING) + rb_raise(rb_eRuntimeError, "argument must be of type 'String'");/*@@@ respond to to_s*/ + + Data_Get_Struct(self, rb_dcLibHandle, h); + newLib = dlLoadLibrary(RSTRING_PTR(path)); + if(newLib) { + dlFreeLibrary(h->lib); + h->lib = newLib; + + return self; + } + + return Qnil; +} + +static VALUE ExtLib_ExistsQ(VALUE self, VALUE sym) +{ + rb_dcLibHandle* h; + + Data_Get_Struct(self, rb_dcLibHandle, h); + ExtLib_SecCheckLib(h); + + return dlFindSymbol(h->lib, rb_id2name(SYM2ID(sym))) ? Qtrue : Qfalse; +} + + +/* Methods for syms parsing */ +static VALUE ExtLib_SymsInit(VALUE self, VALUE path) +{ + void* newSyms; + rb_dcLibHandle* h; + + if(TYPE(path) != T_STRING) + rb_raise(rb_eRuntimeError, "argument must be of type 'String'");/*@@@ respond to to_s*/ + + Data_Get_Struct(self, rb_dcLibHandle, h); + newSyms = dlSymsInit(RSTRING_PTR(path)); + + if(newSyms) { + dlSymsCleanup(h->syms); + h->syms = newSyms; + + return self; + } + + return Qnil; +} + + +static VALUE ExtLib_SymsCount(VALUE self) +{ + rb_dcLibHandle* h; + + Data_Get_Struct(self, rb_dcLibHandle, h); + ExtLib_SecCheckSyms(h); + + return LONG2NUM(dlSymsCount(h->syms)); +} + + +static VALUE ExtLib_SymsEach(int argc, VALUE* argv, VALUE self) +{ + rb_dcLibHandle* h; + size_t i, c; + + if(!rb_block_given_p()) + rb_raise(rb_eRuntimeError, "no block given"); + + Data_Get_Struct(self, rb_dcLibHandle, h); + ExtLib_SecCheckSyms(h); + + c = dlSymsCount(h->syms); + for(i=0; i<c; ++i) + rb_yield(ID2SYM(rb_intern(dlSymsName(h->syms, i)))); + + return self; +} + +/* expose dlSymsName @@@ */ + + +/* Methods interfacing with dyncall */ +static VALUE ExtLib_Call(int argc, VALUE* argv, VALUE self) +{ + /* argv[0] - symbol to call * + * argv[1] - signature * + * argv[2] - first parameter * + * argv[x] - parameter x-2 */ + + rb_dcLibHandle* h; + DCpointer fptr; + int i, t, b; + VALUE r; + DCCallVM* cvm; + const char* sig; + + + /* Security checks. */ + if(argc < 2) + rb_raise(rb_eRuntimeError, "wrong number of arguments for function call"); + + if(TYPE(argv[0]) != T_SYMBOL) + rb_raise(rb_eRuntimeError, "syntax error - argument 0 must be of type 'Symbol'"); + + if(TYPE(argv[1]) != T_STRING) + rb_raise(rb_eRuntimeError, "syntax error - argument 1 must be of type 'String'"); + + Data_Get_Struct(self, rb_dcLibHandle, h); + cvm = h->cvm; + + if(argc != RSTRING_LEN(argv[1])) /* Don't count the return value in the signature @@@ write something more secure */ + rb_raise(rb_eRuntimeError, "number of provided arguments doesn't match signature"); + + ExtLib_SecCheckLib(h); + + + /* Flush old arguments. */ + dcReset(cvm); + + + /* Get a pointer to the function and start pushing. */ + fptr = (DCpointer)dlFindSymbol(h->lib, rb_id2name(SYM2ID(argv[0]))); + sig = RSTRING_PTR(argv[1]); + + for(i=2; i<argc; ++i) { + t = TYPE(argv[i]); + + //@@@ add support for calling convention mode(s) + + switch(sig[i-2]) { + case DC_SIGCHAR_BOOL: + b = 1; + switch(t) { + case T_TRUE: dcArgBool(cvm, DC_TRUE); break; /* TrueClass. */ + case T_FALSE: /* FalseClass. */ + case T_NIL: dcArgBool(cvm, DC_FALSE); break; /* NilClass. */ + case T_FIXNUM: dcArgBool(cvm, FIX2LONG(argv[i]) != 0); break; /* Fixnum. */ + default: b = 0; break; + } + break; + + case DC_SIGCHAR_CHAR: + case DC_SIGCHAR_UCHAR: if(b = (t == T_FIXNUM)) dcArgChar (cvm, (DCchar) FIX2LONG(argv[i])); break; + case DC_SIGCHAR_SHORT: + case DC_SIGCHAR_USHORT: if(b = (t == T_FIXNUM)) dcArgShort (cvm, (DCshort) FIX2LONG(argv[i])); break; + case DC_SIGCHAR_INT: + case DC_SIGCHAR_UINT: if(b = (t == T_FIXNUM)) dcArgInt (cvm, (DCint) FIX2LONG(argv[i])); break; + case DC_SIGCHAR_LONG: + case DC_SIGCHAR_ULONG: if(b = (t == T_FIXNUM)) dcArgLong (cvm, (DClong) FIX2LONG(argv[i])); break; + case DC_SIGCHAR_LONGLONG: + case DC_SIGCHAR_ULONGLONG: if(b = (t == T_FIXNUM)) dcArgLongLong(cvm, (DClonglong)FIX2LONG(argv[i])); break; + case DC_SIGCHAR_FLOAT: if(b = (t == T_FLOAT)) dcArgFloat (cvm, (DCfloat) RFLOAT_VALUE(argv[i])); break; + case DC_SIGCHAR_DOUBLE: if(b = (t == T_FLOAT)) dcArgDouble (cvm, (DCdouble) RFLOAT_VALUE(argv[i])); break; + + case DC_SIGCHAR_POINTER: + case DC_SIGCHAR_STRING: + b = 1; + switch(t) { + case T_STRING: dcArgPointer(cvm, RSTRING_PTR(argv[i])); break; /* String. */ + default: b = 0; break; + } + break; + + default: + b = 0; + break; + } + + + if(!b) + rb_raise(rb_eRuntimeError, "syntax error in signature or type mismatch at argument %d", i-2); + } + + + /* Get the return type and call the function. */ + switch(sig[i-1]) { + case DC_SIGCHAR_VOID: r = Qnil; dcCallVoid (cvm, fptr); break; + case DC_SIGCHAR_BOOL: r = dcCallBool (cvm, fptr) ? Qtrue : Qfalse; break; + case DC_SIGCHAR_CHAR: + case DC_SIGCHAR_UCHAR: r = CHR2FIX( dcCallChar (cvm, fptr)); break; + case DC_SIGCHAR_SHORT: + case DC_SIGCHAR_USHORT: r = INT2FIX( dcCallShort (cvm, fptr)); break; + case DC_SIGCHAR_INT: + case DC_SIGCHAR_UINT: r = INT2FIX( dcCallInt (cvm, fptr)); break; + case DC_SIGCHAR_LONG: + case DC_SIGCHAR_ULONG: r = INT2FIX( dcCallLong (cvm, fptr)); break; + case DC_SIGCHAR_LONGLONG: + case DC_SIGCHAR_ULONGLONG: r = INT2FIX( dcCallLongLong(cvm, fptr)); break; + case DC_SIGCHAR_FLOAT: r = rb_float_new(dcCallFloat (cvm, fptr)); break; + case DC_SIGCHAR_DOUBLE: r = rb_float_new(dcCallDouble (cvm, fptr)); break; + case DC_SIGCHAR_STRING: r = rb_str_new2( dcCallPointer (cvm, fptr)); break; + case DC_SIGCHAR_POINTER: + default: + rb_raise(rb_eRuntimeError, "unsupported return type or syntax error in signature"); + } + + return r; +} + + +/* Main initialization. */ +void Init_rbdc() +{ + rb_dcModule = rb_define_module("Dyncall"); + + /* Handle to the external dynamic library. */ + rb_dcExtLib = rb_define_class_under(rb_dcModule, "ExtLib", rb_cObject); + + /* Class allocators. */ + rb_define_alloc_func(rb_dcExtLib, AllocExtLib); + + /* Methods. */ + rb_define_method(rb_dcExtLib, "load", &ExtLib_Load, 1); + rb_define_method(rb_dcExtLib, "exists?", &ExtLib_ExistsQ, 1); + rb_define_method(rb_dcExtLib, "syms_init", &ExtLib_SymsInit, 1); + rb_define_method(rb_dcExtLib, "syms_count", &ExtLib_SymsCount, 0); + rb_define_method(rb_dcExtLib, "syms_each", &ExtLib_SymsEach, -1); + rb_define_method(rb_dcExtLib, "call", &ExtLib_Call, -1); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ruby/rbdc/rbdc.gemspec Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,42 @@ +#////////////////////////////////////////////////////////////////////// +# +# rbdc.gemspec +# Copyright (c) 2007-2009 Daniel Adler <dadler@uni-goettingen.de>, +# Tassilo Philipp <tphilipp@potion-studios.com> +# +# Permission to use, copy, modify, and distribute this software for any +# purpose with or without fee is hereby granted, provided that the above +# copyright notice and this permission notice appear in all copies. +# +# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +# ANY SPECIAL, DIRECT, 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. +# +# Ruby gems specification file. +# +#/////////////////////////////////////////////////////////////////////// + +require 'rake' +base_dir = '../../..' +Dir.chdir(base_dir) + +Gem::Specification.new do |spec| + spec.name = 'rbdc' + spec.author = 'Tassilo Philipp' + spec.email = 'tphilipp@potion-studios.com' + spec.homepage = 'http://www.dyncall.org' + + spec.summary = 'foreign function interface for C calls' + spec.description = 'Ruby interface to dyncall, allowing programmers to call C functions in shared libraries from ruby without writing any glue code at all (e.g. "l.load(\'/usr/lib/libm.so\'); puts \'pow(2.0, 10.0) = \' + l.call(:pow, \'dd)d\', 2.0, 10.0).to_s")' + + spec.version = '0.8.7' + spec.required_ruby_version = '>= 1.9.1' + spec.license = 'ISC' + + spec.files = FileList['dyncall/**/*', 'bindings/ruby/rbdc/rbdc.c'].exclude('dyncall/doc/**/*').exclude('dyncall/test/**/*').to_a + spec.extensions << 'bindings/ruby/rbdc/extconf.rb' +end
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/shell/shdc/build.gcc.sh Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,2 @@ +#!/bin/sh +gcc -I../../../dyncall/dyncall shdc.c ../../../dyncall/dyncall/libdyncall_s.a ../../../dyncall/dynload/libdynload_s.a -o ./shdc
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/shell/shdc/examples.txt Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,12 @@ +Call: +----- +$ ./shdc -c /usr/lib/libm.so sqrt "d)d" 3 +1.73205 +$ ./shdc -c /usr/lib/libm.so powf "ff)f" 3 2.5 +15.5885 +$ ./shdc -c /usr/lib/libc.so printf "_eZZi)v" "Hi! Say hi to %s, l%ier!" "Daniel" 8 +Hi! Say hi to Daniel, l8er! + +List: +----- +$ ./shdc -l /usr/lib/libm.so
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/shell/shdc/shdc.c Thu Mar 19 22:26:28 2015 +0100 @@ -0,0 +1,187 @@ +/* + Package: dyncall + File: bindings/shell.c + Description: printf(1) style function call mechanism + License: + Copyright (c) 2007-2014 Daniel Adler <dadler@uni-goettingen.de>, + Tassilo Philipp <tphilipp@potion-studios.com> + + Permission to use, copy, modify, and distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, 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. + +*/ + +#include "../../dyncall/dyncall/dyncall.h" +#include "../../dyncall/dynload/dynload.h" +#include "../../dyncall/dyncall/dyncall_signature.h" +#include <stdio.h> +#include <stdlib.h> /* needed on some platforms to make atof work _at_runtime_ */ + +#define SHDC_VERSION "0.8" + + +void usage(const char* s) +{ + printf( + "Usage: %s -l SO\n" + " %s -c SO SYM SIG [ARGS]\n" + " %s -v\n" + " where SO is the name of the shared object.\n" + "\n" + " -l lists all symbol names in the shared object\n" + " -c calls function in the shared object, where SYM is the symbol name,\n" + " SIG the symbol's type signature, and ARGS the arguments.\n" + " -v displays the binding's version\n", + s, s, s + ); +} + + +int main(int argc, char* argv[]) +{ + const char* libPath; + const char* symName; + const DCsigchar* sig; + const DCsigchar* i; + void* sym; + DCCallVM* vm; + DLLib* dlLib; + DLSyms* dlSyms; + int c, l; + + if(argc == 2 && strcmp(argv[1], "-v") == 0) { + printf(SHDC_VERSION"\n"); + return 0; + } + + /* Parse arguments and check validity. */ + /* Need at least shared object name and action, and symbol name and signature string for call. */ + if(argc < 2) { + usage(argv[0]); + return 1; + } + + c = strcmp(argv[1], "-c"); + l = strcmp(argv[1], "-l"); + if((c != 0 && l != 0) || (c == 0 && argc < 4)) { + usage(argv[0]); + return 1; + } + + + libPath = argv[2]; + + /* List symbols, if 'ls', else it must be 'call', so proceed to call. */ + if(l == 0) { + dlSyms = dlSymsInit(libPath); + if(!dlSyms) { + printf("Can't load \"%s\".\n", libPath); + usage(argv[0]); + return 1; + } + + /* hacky: reuse c and l */ + for(c=dlSymsCount(dlSyms), l=0; l<c; ++l) + printf("%s\n", dlSymsName(dlSyms, l)); + + dlSymsCleanup(dlSyms); + } + else { + /* Check if number of arguments matches sigstring spec. */ + /*if(n != argc-4)@@@*/ /* 0 is prog, 1 is flag, 2 is lib, 3 is symbol name, 4 is sig */ + + /* Load library and get a pointer to the symbol to call. */ + dlLib = dlLoadLibrary(libPath); + if(!dlLib) { + printf("Can't load \"%s\".\n", libPath); + usage(argv[0]); + return 1; + } + + symName = argv[3]; + sig = i = argv[4]; + + sym = dlFindSymbol(dlLib, symName); + if(!sym) { + printf("Can't find symbol \"%s\".\n", symName); + dlFreeLibrary(dlLib); + usage(argv[0]); + return 1; + } + + + vm = dcNewCallVM(4096/*@@@*/);/*@@@ error checking */ + dcReset(vm); + + while(*i != '\0' && *i != DC_SIGCHAR_ENDARG) { + switch(*i) { + case DC_SIGCHAR_CC_PREFIX: + switch(*++i) { + case DC_SIGCHAR_CC_ELLIPSIS: dcMode(vm, DC_CALL_C_ELLIPSIS); break; + case DC_SIGCHAR_CC_STDCALL: dcMode(vm, DC_CALL_C_X86_WIN32_STD); break; + case DC_SIGCHAR_CC_FASTCALL_GNU: dcMode(vm, DC_CALL_C_X86_WIN32_FAST_GNU); break; + case DC_SIGCHAR_CC_FASTCALL_MS: dcMode(vm, DC_CALL_C_X86_WIN32_FAST_MS); break; + case DC_SIGCHAR_CC_THISCALL_MS: dcMode(vm, DC_CALL_C_X86_WIN32_THIS_MS); break; + /* @@@ extend with other modes when they become available */ + } + sig += 2; + break; + + case DC_SIGCHAR_BOOL: dcArgBool (vm, (DCbool) atoi (argv[5+i-sig] )); break; + case DC_SIGCHAR_CHAR: dcArgChar (vm, (DCchar) atoi (argv[5+i-sig] )); break; + case DC_SIGCHAR_UCHAR: dcArgChar (vm, (DCchar)(DCuchar) atoi (argv[5+i-sig] )); break; + case DC_SIGCHAR_SHORT: dcArgShort (vm, (DCshort) atoi (argv[5+i-sig] )); break; + case DC_SIGCHAR_USHORT: dcArgShort (vm, (DCshort)(DCushort)atoi (argv[5+i-sig] )); break; + case DC_SIGCHAR_INT: dcArgInt (vm, (DCint) strtol (argv[5+i-sig],NULL,10)); break; + case DC_SIGCHAR_UINT: dcArgInt (vm, (DCint)(DCuint) strtoul (argv[5+i-sig],NULL,10)); break; + case DC_SIGCHAR_LONG: dcArgLong (vm, (DClong) strtol (argv[5+i-sig],NULL,10)); break; + case DC_SIGCHAR_ULONG: dcArgLong (vm, (DCulong) strtoul (argv[5+i-sig],NULL,10)); break; + case DC_SIGCHAR_LONGLONG: dcArgLongLong(vm, (DClonglong) strtoll (argv[5+i-sig],NULL,10)); break; + case DC_SIGCHAR_ULONGLONG: dcArgLongLong(vm, (DCulonglong) strtoull(argv[5+i-sig],NULL,10)); break; + case DC_SIGCHAR_FLOAT: dcArgFloat (vm, (DCfloat) atof (argv[5+i-sig] )); break; + case DC_SIGCHAR_DOUBLE: dcArgDouble (vm, (DCdouble) atof (argv[5+i-sig] )); break; + case DC_SIGCHAR_POINTER: dcArgPointer (vm, (DCpointer) argv[5+i-sig] ); break; + case DC_SIGCHAR_STRING: dcArgPointer (vm, (DCpointer) argv[5+i-sig] ); break; + } + ++i; + } + + if(*i == DC_SIGCHAR_ENDARG) + ++i; + + switch(*i) { + case '\0': + case DC_SIGCHAR_VOID: dcCallVoid (vm,sym) ; break; + case DC_SIGCHAR_BOOL: printf("%d\n", dcCallBool (vm,sym)); break; + case DC_SIGCHAR_CHAR: printf("%d\n", dcCallChar (vm,sym)); break; + case DC_SIGCHAR_UCHAR: printf("%d\n", dcCallChar (vm,sym)); break; + case DC_SIGCHAR_SHORT: printf("%d\n", dcCallShort (vm,sym)); break; + case DC_SIGCHAR_USHORT: printf("%d\n", dcCallShort (vm,sym)); break; + case DC_SIGCHAR_INT: printf("%d\n", dcCallInt (vm,sym)); break; + case DC_SIGCHAR_UINT: printf("%d\n", dcCallInt (vm,sym)); break; + case DC_SIGCHAR_LONG: printf("%d\n", dcCallLong (vm,sym)); break; + case DC_SIGCHAR_ULONG: printf("%d\n", dcCallLong (vm,sym)); break; + case DC_SIGCHAR_LONGLONG: printf("%lld\n", dcCallLongLong(vm,sym)); break; + case DC_SIGCHAR_ULONGLONG: printf("%lld\n", dcCallLongLong(vm,sym)); break; + case DC_SIGCHAR_FLOAT: printf("%g\n", dcCallFloat (vm,sym)); break; + case DC_SIGCHAR_DOUBLE: printf("%g\n", dcCallDouble (vm,sym)); break; + case DC_SIGCHAR_POINTER: printf("%x\n", dcCallPointer (vm,sym)); break; + case DC_SIGCHAR_STRING: printf( dcCallPointer (vm,sym)); break; + } + + dlFreeLibrary(dlLib); + dcFree(vm); + } + + return 0; +} +