1. Joseph Marshall
  2. rust-gl

Commits

Joseph Marshall  committed 3c62eed Draft

void* parameters are now interpreted as *u8.

  • Participants
  • Parent commits 49127c3
  • Branches default

Comments (0)

Files changed (2)

File gen.py

View file
         type = type.replace('const', '').strip()
         if type == 'GLsync':
             continue
-        r.append(name+': '+ptr+types[type])
+        if not ptr:
+            t = types[type]
+        else:
+            t = ptr+types[type]
+            if t == '*()':
+                # HACK *u8 are used for strings.
+                t = '* u8'
+        r.append(name+': '+t)
     return ', '.join(r)
 
 output_funcs = []

File gl.rs

View file
     fn glNewList(list: u32, mode: u32) -> ();
     fn glEndList() -> ();
     fn glCallList(list: u32) -> ();
-    fn glCallLists(n: i32, type_: u32, lists: *()) -> ();
+    fn glCallLists(n: i32, type_: u32, lists: * u8) -> ();
     fn glListBase(base: u32) -> ();
     fn glBegin(mode: u32) -> ();
     fn glEnd() -> ();
     fn glRectfv(v1: *f32, v2: *f32) -> ();
     fn glRectiv(v1: *i32, v2: *i32) -> ();
     fn glRectsv(v1: *i16, v2: *i16) -> ();
-    fn glVertexPointer(size: i32, type_: u32, stride: i32, ptr: *()) -> ();
-    fn glNormalPointer(type_: u32, stride: i32, ptr: *()) -> ();
-    fn glColorPointer(size: i32, type_: u32, stride: i32, ptr: *()) -> ();
-    fn glIndexPointer(type_: u32, stride: i32, ptr: *()) -> ();
-    fn glTexCoordPointer(size: i32, type_: u32, stride: i32, ptr: *()) -> ();
-    fn glEdgeFlagPointer(stride: i32, ptr: *()) -> ();
+    fn glVertexPointer(size: i32, type_: u32, stride: i32, ptr: * u8) -> ();
+    fn glNormalPointer(type_: u32, stride: i32, ptr: * u8) -> ();
+    fn glColorPointer(size: i32, type_: u32, stride: i32, ptr: * u8) -> ();
+    fn glIndexPointer(type_: u32, stride: i32, ptr: * u8) -> ();
+    fn glTexCoordPointer(size: i32, type_: u32, stride: i32, ptr: * u8) -> ();
+    fn glEdgeFlagPointer(stride: i32, ptr: * u8) -> ();
     fn glGetPointerv(pname: u32, params: **()) -> ();
     fn glArrayElement(i: i32) -> ();
     fn glDrawArrays(mode: u32, first: i32, count: i32) -> ();
-    fn glDrawElements(mode: u32, count: i32, type_: u32, indices: *()) -> ();
-    fn glInterleavedArrays(format: u32, stride: i32, pointer: *()) -> ();
+    fn glDrawElements(mode: u32, count: i32, type_: u32, indices: * u8) -> ();
+    fn glInterleavedArrays(format: u32, stride: i32, pointer: * u8) -> ();
     fn glShadeModel(mode: u32) -> ();
     fn glLightf(light: u32, pname: u32, param: f32) -> ();
     fn glLighti(light: u32, pname: u32, param: i32) -> ();
     fn glGetPixelMapuiv(map: u32, values: *u32) -> ();
     fn glGetPixelMapusv(map: u32, values: *u16) -> ();
     fn glBitmap(width: i32, height: i32, xorig: f32, yorig: f32, xmove: f32, ymove: f32, bitmap: *u8) -> ();
-    fn glReadPixels(x: i32, y: i32, width: i32, height: i32, format: u32, type_: u32, pixels: *()) -> ();
-    fn glDrawPixels(width: i32, height: i32, format: u32, type_: u32, pixels: *()) -> ();
+    fn glReadPixels(x: i32, y: i32, width: i32, height: i32, format: u32, type_: u32, pixels: * u8) -> ();
+    fn glDrawPixels(width: i32, height: i32, format: u32, type_: u32, pixels: * u8) -> ();
     fn glCopyPixels(x: i32, y: i32, width: i32, height: i32, type_: u32) -> ();
     fn glStencilFunc(func: u32, ref: i32, mask: u32) -> ();
     fn glStencilMask(mask: u32) -> ();
     fn glGetTexParameteriv(target: u32, pname: u32, params: *i32) -> ();
     fn glGetTexLevelParameterfv(target: u32, level: i32, pname: u32, params: *f32) -> ();
     fn glGetTexLevelParameteriv(target: u32, level: i32, pname: u32, params: *i32) -> ();
-    fn glTexImage1D(target: u32, level: i32, internalFormat: i32, width: i32, border: i32, format: u32, type_: u32, pixels: *()) -> ();
-    fn glTexImage2D(target: u32, level: i32, internalFormat: i32, width: i32, height: i32, border: i32, format: u32, type_: u32, pixels: *()) -> ();
-    fn glGetTexImage(target: u32, level: i32, format: u32, type_: u32, pixels: *()) -> ();
+    fn glTexImage1D(target: u32, level: i32, internalFormat: i32, width: i32, border: i32, format: u32, type_: u32, pixels: * u8) -> ();
+    fn glTexImage2D(target: u32, level: i32, internalFormat: i32, width: i32, height: i32, border: i32, format: u32, type_: u32, pixels: * u8) -> ();
+    fn glGetTexImage(target: u32, level: i32, format: u32, type_: u32, pixels: * u8) -> ();
     fn glGenTextures(n: i32, textures: *u32) -> ();
     fn glDeleteTextures(n: i32, textures: *u32) -> ();
     fn glBindTexture(target: u32, texture: u32) -> ();
     fn glPrioritizeTextures(n: i32, textures: *u32, priorities: *f32) -> ();
     fn glAreTexturesResident(n: i32, textures: *u32, residences: *u8) -> u8;
     fn glIsTexture(texture: u32) -> u8;
-    fn glTexSubImage1D(target: u32, level: i32, xoffset: i32, width: i32, format: u32, type_: u32, pixels: *()) -> ();
-    fn glTexSubImage2D(target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type_: u32, pixels: *()) -> ();
+    fn glTexSubImage1D(target: u32, level: i32, xoffset: i32, width: i32, format: u32, type_: u32, pixels: * u8) -> ();
+    fn glTexSubImage2D(target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type_: u32, pixels: * u8) -> ();
     fn glCopyTexImage1D(target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, border: i32) -> ();
     fn glCopyTexImage2D(target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, height: i32, border: i32) -> ();
     fn glCopyTexSubImage1D(target: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32) -> ();
     fn glLoadName(name: u32) -> ();
     fn glPushName(name: u32) -> ();
     fn glPopName() -> ();
-    fn glDrawRangeElements(mode: u32, start: u32, end: u32, count: i32, type_: u32, indices: *()) -> ();
-    fn glTexImage3D(target: u32, level: i32, internalFormat: i32, width: i32, height: i32, depth: i32, border: i32, format: u32, type_: u32, pixels: *()) -> ();
-    fn glTexSubImage3D(target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type_: u32, pixels: *()) -> ();
+    fn glDrawRangeElements(mode: u32, start: u32, end: u32, count: i32, type_: u32, indices: * u8) -> ();
+    fn glTexImage3D(target: u32, level: i32, internalFormat: i32, width: i32, height: i32, depth: i32, border: i32, format: u32, type_: u32, pixels: * u8) -> ();
+    fn glTexSubImage3D(target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type_: u32, pixels: * u8) -> ();
     fn glCopyTexSubImage3D(target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, x: i32, y: i32, width: i32, height: i32) -> ();
-    fn glColorTable(target: u32, internalformat: u32, width: i32, format: u32, type_: u32, table: *()) -> ();
-    fn glColorSubTable(target: u32, start: i32, count: i32, format: u32, type_: u32, data: *()) -> ();
+    fn glColorTable(target: u32, internalformat: u32, width: i32, format: u32, type_: u32, table: * u8) -> ();
+    fn glColorSubTable(target: u32, start: i32, count: i32, format: u32, type_: u32, data: * u8) -> ();
     fn glColorTableParameteriv(target: u32, pname: u32, params: *i32) -> ();
     fn glColorTableParameterfv(target: u32, pname: u32, params: *f32) -> ();
     fn glCopyColorSubTable(target: u32, start: i32, x: i32, y: i32, width: i32) -> ();
     fn glCopyColorTable(target: u32, internalformat: u32, x: i32, y: i32, width: i32) -> ();
-    fn glGetColorTable(target: u32, format: u32, type_: u32, table: *()) -> ();
+    fn glGetColorTable(target: u32, format: u32, type_: u32, table: * u8) -> ();
     fn glGetColorTableParameterfv(target: u32, pname: u32, params: *f32) -> ();
     fn glGetColorTableParameteriv(target: u32, pname: u32, params: *i32) -> ();
     fn glBlendEquation(mode: u32) -> ();
     fn glBlendColor(red: f32, green: f32, blue: f32, alpha: f32) -> ();
     fn glHistogram(target: u32, width: i32, internalformat: u32, sink: u8) -> ();
     fn glResetHistogram(target: u32) -> ();
-    fn glGetHistogram(target: u32, reset: u8, format: u32, type_: u32, values: *()) -> ();
+    fn glGetHistogram(target: u32, reset: u8, format: u32, type_: u32, values: * u8) -> ();
     fn glGetHistogramParameterfv(target: u32, pname: u32, params: *f32) -> ();
     fn glGetHistogramParameteriv(target: u32, pname: u32, params: *i32) -> ();
     fn glMinmax(target: u32, internalformat: u32, sink: u8) -> ();
     fn glResetMinmax(target: u32) -> ();
-    fn glGetMinmax(target: u32, reset: u8, format: u32, types: u32, values: *()) -> ();
+    fn glGetMinmax(target: u32, reset: u8, format: u32, types: u32, values: * u8) -> ();
     fn glGetMinmaxParameterfv(target: u32, pname: u32, params: *f32) -> ();
     fn glGetMinmaxParameteriv(target: u32, pname: u32, params: *i32) -> ();
-    fn glConvolutionFilter1D(target: u32, internalformat: u32, width: i32, format: u32, type_: u32, image: *()) -> ();
-    fn glConvolutionFilter2D(target: u32, internalformat: u32, width: i32, height: i32, format: u32, type_: u32, image: *()) -> ();
+    fn glConvolutionFilter1D(target: u32, internalformat: u32, width: i32, format: u32, type_: u32, image: * u8) -> ();
+    fn glConvolutionFilter2D(target: u32, internalformat: u32, width: i32, height: i32, format: u32, type_: u32, image: * u8) -> ();
     fn glConvolutionParameterf(target: u32, pname: u32, params: f32) -> ();
     fn glConvolutionParameterfv(target: u32, pname: u32, params: *f32) -> ();
     fn glConvolutionParameteri(target: u32, pname: u32, params: i32) -> ();
     fn glConvolutionParameteriv(target: u32, pname: u32, params: *i32) -> ();
     fn glCopyConvolutionFilter1D(target: u32, internalformat: u32, x: i32, y: i32, width: i32) -> ();
     fn glCopyConvolutionFilter2D(target: u32, internalformat: u32, x: i32, y: i32, width: i32, height: i32) -> ();
-    fn glGetConvolutionFilter(target: u32, format: u32, type_: u32, image: *()) -> ();
+    fn glGetConvolutionFilter(target: u32, format: u32, type_: u32, image: * u8) -> ();
     fn glGetConvolutionParameterfv(target: u32, pname: u32, params: *f32) -> ();
     fn glGetConvolutionParameteriv(target: u32, pname: u32, params: *i32) -> ();
-    fn glSeparableFilter2D(target: u32, internalformat: u32, width: i32, height: i32, format: u32, type_: u32, row: *(), column: *()) -> ();
-    fn glGetSeparableFilter(target: u32, format: u32, type_: u32, row: *(), column: *(), span: *()) -> ();
+    fn glSeparableFilter2D(target: u32, internalformat: u32, width: i32, height: i32, format: u32, type_: u32, row: * u8, column: * u8) -> ();
+    fn glGetSeparableFilter(target: u32, format: u32, type_: u32, row: * u8, column: * u8, span: * u8) -> ();
     fn glActiveTexture(texture: u32) -> ();
     fn glClientActiveTexture(texture: u32) -> ();
-    fn glCompressedTexImage1D(target: u32, level: i32, internalformat: u32, width: i32, border: i32, imageSize: i32, data: *()) -> ();
-    fn glCompressedTexImage2D(target: u32, level: i32, internalformat: u32, width: i32, height: i32, border: i32, imageSize: i32, data: *()) -> ();
-    fn glCompressedTexImage3D(target: u32, level: i32, internalformat: u32, width: i32, height: i32, depth: i32, border: i32, imageSize: i32, data: *()) -> ();
-    fn glCompressedTexSubImage1D(target: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: *()) -> ();
-    fn glCompressedTexSubImage2D(target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: *()) -> ();
-    fn glCompressedTexSubImage3D(target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: *()) -> ();
-    fn glGetCompressedTexImage(target: u32, lod: i32, img: *()) -> ();
+    fn glCompressedTexImage1D(target: u32, level: i32, internalformat: u32, width: i32, border: i32, imageSize: i32, data: * u8) -> ();
+    fn glCompressedTexImage2D(target: u32, level: i32, internalformat: u32, width: i32, height: i32, border: i32, imageSize: i32, data: * u8) -> ();
+    fn glCompressedTexImage3D(target: u32, level: i32, internalformat: u32, width: i32, height: i32, depth: i32, border: i32, imageSize: i32, data: * u8) -> ();
+    fn glCompressedTexSubImage1D(target: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: * u8) -> ();
+    fn glCompressedTexSubImage2D(target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: * u8) -> ();
+    fn glCompressedTexSubImage3D(target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: * u8) -> ();
+    fn glGetCompressedTexImage(target: u32, lod: i32, img: * u8) -> ();
     fn glMultiTexCoord1d(target: u32, s: f64) -> ();
     fn glMultiTexCoord1dv(target: u32, v: *f64) -> ();
     fn glMultiTexCoord1f(target: u32, s: f32) -> ();
     fn glDeleteBuffers(n: i32, buffers: *u32) -> ();
     fn glGenBuffers(n: i32, buffers: *u32) -> ();
     fn glIsBuffer(buffer: u32) -> u8;
-    fn glBufferData(target: u32, size: libc::ptrdiff_t, data: *(), usage: u32) -> ();
-    fn glBufferSubData(target: u32, offset: libc::intptr_t, size: libc::ptrdiff_t, data: *()) -> ();
-    fn glGetBufferSubData(target: u32, offset: libc::intptr_t, size: libc::ptrdiff_t, data: *()) -> ();
+    fn glBufferData(target: u32, size: libc::ptrdiff_t, data: * u8, usage: u32) -> ();
+    fn glBufferSubData(target: u32, offset: libc::intptr_t, size: libc::ptrdiff_t, data: * u8) -> ();
+    fn glGetBufferSubData(target: u32, offset: libc::intptr_t, size: libc::ptrdiff_t, data: * u8) -> ();
     fn glMapBuffer(target: u32, access: u32) -> *();
     fn glUnmapBuffer(target: u32) -> u8;
     fn glGetBufferParameteriv(target: u32, pname: u32, params: *i32) -> ();
     fn glVertexAttrib4ubv(index: u32, v: *u8) -> ();
     fn glVertexAttrib4uiv(index: u32, v: *u32) -> ();
     fn glVertexAttrib4usv(index: u32, v: *u16) -> ();
-    fn glVertexAttribPointer(index: u32, size: i32, type_: u32, normalized: u8, stride: i32, pointer: *()) -> ();
+    fn glVertexAttribPointer(index: u32, size: i32, type_: u32, normalized: u8, stride: i32, pointer: * u8) -> ();
     fn glUniformMatrix2x3fv(location: i32, count: i32, transpose: u8, value: *f32) -> ();
     fn glUniformMatrix3x2fv(location: i32, count: i32, transpose: u8, value: *f32) -> ();
     fn glUniformMatrix2x4fv(location: i32, count: i32, transpose: u8, value: *f32) -> ();
     fn glClampColor(target: u32, clamp: u32) -> ();
     fn glBeginConditionalRender(id: u32, mode: u32) -> ();
     fn glEndConditionalRender() -> ();
-    fn glVertexAttribIPointer(index: u32, size: i32, type_: u32, stride: i32, pointer: *()) -> ();
+    fn glVertexAttribIPointer(index: u32, size: i32, type_: u32, stride: i32, pointer: * u8) -> ();
     fn glGetVertexAttribIiv(index: u32, pname: u32, params: *i32) -> ();
     fn glGetVertexAttribIuiv(index: u32, pname: u32, params: *u32) -> ();
     fn glVertexAttribI1i(index: u32, x: i32) -> ();
     fn glClearBufferfi(buffer: u32, drawbuffer: i32, depth: f32, stencil: i32) -> ();
     fn glGetStringi(name: u32, index: u32) -> *u8;
     fn glDrawArraysInstanced(mode: u32, first: i32, count: i32, primcount: i32) -> ();
-    fn glDrawElementsInstanced(mode: u32, count: i32, type_: u32, indices: *(), primcount: i32) -> ();
+    fn glDrawElementsInstanced(mode: u32, count: i32, type_: u32, indices: * u8, primcount: i32) -> ();
     fn glTexBuffer(target: u32, internalformat: u32, buffer: u32) -> ();
     fn glPrimitiveRestartIndex(index: u32) -> ();
     fn glGetInteger64i_v(target: u32, index: u32, data: *i64) -> ();
     fn glGetActiveUniformBlockName(program: u32, uniformBlockIndex: u32, bufSize: i32, length: *i32, uniformBlockName: *u8) -> ();
     fn glUniformBlockBinding(program: u32, uniformBlockIndex: u32, uniformBlockBinding: u32) -> ();
     fn glCopyBufferSubData(readTarget: u32, writeTarget: u32, readOffset: libc::intptr_t, writeOffset: libc::intptr_t, size: libc::ptrdiff_t) -> ();
-    fn glDrawElementsBaseVertex(mode: u32, count: i32, type_: u32, indices: *(), basevertex: i32) -> ();
-    fn glDrawRangeElementsBaseVertex(mode: u32, start: u32, end: u32, count: i32, type_: u32, indices: *(), basevertex: i32) -> ();
-    fn glDrawElementsInstancedBaseVertex(mode: u32, count: i32, type_: u32, indices: *(), primcount: i32, basevertex: i32) -> ();
+    fn glDrawElementsBaseVertex(mode: u32, count: i32, type_: u32, indices: * u8, basevertex: i32) -> ();
+    fn glDrawRangeElementsBaseVertex(mode: u32, start: u32, end: u32, count: i32, type_: u32, indices: * u8, basevertex: i32) -> ();
+    fn glDrawElementsInstancedBaseVertex(mode: u32, count: i32, type_: u32, indices: * u8, primcount: i32, basevertex: i32) -> ();
     fn glMultiDrawElementsBaseVertex(mode: u32, count: *i32, type_: u32, indices: **(), primcount: i32, basevertex: *i32) -> ();
     fn glProvokingVertex(mode: u32) -> ();
     fn glIsSync() -> u8;
     fn glVertexAttribP3uiv(index: u32, type_: u32, normalized: u8, value: *u32) -> ();
     fn glVertexAttribP4ui(index: u32, type_: u32, normalized: u8, value: u32) -> ();
     fn glVertexAttribP4uiv(index: u32, type_: u32, normalized: u8, value: *u32) -> ();
-    fn glDrawArraysIndirect(mode: u32, indirect: *()) -> ();
-    fn glDrawElementsIndirect(mode: u32, type_: u32, indirect: *()) -> ();
+    fn glDrawArraysIndirect(mode: u32, indirect: * u8) -> ();
+    fn glDrawElementsIndirect(mode: u32, type_: u32, indirect: * u8) -> ();
     fn glUniform1d(location: i32, x: f64) -> ();
     fn glUniform2d(location: i32, x: f64, y: f64) -> ();
     fn glUniform3d(location: i32, x: f64, y: f64, z: f64) -> ();
     fn glEndQueryIndexed(target: u32, index: u32) -> ();
     fn glGetQueryIndexediv(target: u32, index: u32, pname: u32, params: *i32) -> ();
     fn glReleaseShaderCompiler() -> ();
-    fn glShaderBinary(count: i32, shaders: *u32, binaryformat: u32, binary: *(), length: i32) -> ();
+    fn glShaderBinary(count: i32, shaders: *u32, binaryformat: u32, binary: * u8, length: i32) -> ();
     fn glGetShaderPrecisionFormat(shadertype: u32, precisiontype: u32, range: *i32, precision: *i32) -> ();
     fn glDepthRangef(n: f32, f: f32) -> ();
     fn glClearDepthf(d: f32) -> ();
-    fn glGetProgramBinary(program: u32, bufSize: i32, length: *i32, binaryFormat: *u32, binary: *()) -> ();
-    fn glProgramBinary(program: u32, binaryFormat: u32, binary: *(), length: i32) -> ();
+    fn glGetProgramBinary(program: u32, bufSize: i32, length: *i32, binaryFormat: *u32, binary: * u8) -> ();
+    fn glProgramBinary(program: u32, binaryFormat: u32, binary: * u8, length: i32) -> ();
     fn glProgramParameteri(program: u32, pname: u32, value: i32) -> ();
     fn glUseProgramStages(pipeline: u32, stages: u32, program: u32) -> ();
     fn glActiveShaderProgram(pipeline: u32, program: u32) -> ();
     fn glVertexAttribL2dv(index: u32, v: *f64) -> ();
     fn glVertexAttribL3dv(index: u32, v: *f64) -> ();
     fn glVertexAttribL4dv(index: u32, v: *f64) -> ();
-    fn glVertexAttribLPointer(index: u32, size: i32, type_: u32, stride: i32, pointer: *()) -> ();
+    fn glVertexAttribLPointer(index: u32, size: i32, type_: u32, stride: i32, pointer: * u8) -> ();
     fn glGetVertexAttribLdv(index: u32, pname: u32, params: *f64) -> ();
     fn glViewportArrayv(first: u32, count: i32, v: *f32) -> ();
     fn glViewportIndexedf(index: u32, x: f32, y: f32, w: f32, h: f32) -> ();
     fn glGetFloati_v(target: u32, index: u32, data: *f32) -> ();
     fn glGetDoublei_v(target: u32, index: u32, data: *f64) -> ();
     fn glDrawArraysInstancedBaseInstance(mode: u32, first: i32, count: i32, primcount: i32, baseinstance: u32) -> ();
-    fn glDrawElementsInstancedBaseInstance(mode: u32, count: i32, type_: u32, indices: *(), primcount: i32, baseinstance: u32) -> ();
-    fn glDrawElementsInstancedBaseVertexBaseInstance(mode: u32, count: i32, type_: u32, indices: *(), primcount: i32, basevertex: i32, baseinstance: u32) -> ();
+    fn glDrawElementsInstancedBaseInstance(mode: u32, count: i32, type_: u32, indices: * u8, primcount: i32, baseinstance: u32) -> ();
+    fn glDrawElementsInstancedBaseVertexBaseInstance(mode: u32, count: i32, type_: u32, indices: * u8, primcount: i32, basevertex: i32, baseinstance: u32) -> ();
     fn glDrawTransformFeedbackInstanced(mode: u32, id: u32, primcount: i32) -> ();
     fn glDrawTransformFeedbackStreamInstanced(mode: u32, id: u32, stream: u32, primcount: i32) -> ();
     fn glGetInternalformativ(target: u32, internalformat: u32, pname: u32, bufSize: i32, params: *i32) -> ();
 fn glCallList(list: uint) -> () unsafe {
     ret GL::glCallList(list as u32);
 }
-fn glCallLists(n: int, type_: uint, lists: *()) -> () unsafe {
+fn glCallLists(n: int, type_: uint, lists: * u8) -> () unsafe {
     ret GL::glCallLists(n as i32, type_ as u32, lists);
 }
 fn glListBase(base: uint) -> () unsafe {
 fn glRectsv(v1: *i16, v2: *i16) -> () unsafe {
     ret GL::glRectsv(v1, v2);
 }
-fn glVertexPointer(size: int, type_: uint, stride: int, ptr: *()) -> () unsafe {
+fn glVertexPointer(size: int, type_: uint, stride: int, ptr: * u8) -> () unsafe {
     ret GL::glVertexPointer(size as i32, type_ as u32, stride as i32, ptr);
 }
-fn glNormalPointer(type_: uint, stride: int, ptr: *()) -> () unsafe {
+fn glNormalPointer(type_: uint, stride: int, ptr: * u8) -> () unsafe {
     ret GL::glNormalPointer(type_ as u32, stride as i32, ptr);
 }
-fn glColorPointer(size: int, type_: uint, stride: int, ptr: *()) -> () unsafe {
+fn glColorPointer(size: int, type_: uint, stride: int, ptr: * u8) -> () unsafe {
     ret GL::glColorPointer(size as i32, type_ as u32, stride as i32, ptr);
 }
-fn glIndexPointer(type_: uint, stride: int, ptr: *()) -> () unsafe {
+fn glIndexPointer(type_: uint, stride: int, ptr: * u8) -> () unsafe {
     ret GL::glIndexPointer(type_ as u32, stride as i32, ptr);
 }
-fn glTexCoordPointer(size: int, type_: uint, stride: int, ptr: *()) -> () unsafe {
+fn glTexCoordPointer(size: int, type_: uint, stride: int, ptr: * u8) -> () unsafe {
     ret GL::glTexCoordPointer(size as i32, type_ as u32, stride as i32, ptr);
 }
-fn glEdgeFlagPointer(stride: int, ptr: *()) -> () unsafe {
+fn glEdgeFlagPointer(stride: int, ptr: * u8) -> () unsafe {
     ret GL::glEdgeFlagPointer(stride as i32, ptr);
 }
 fn glGetPointerv(pname: uint, params: **()) -> () unsafe {
 fn glDrawArrays(mode: uint, first: int, count: int) -> () unsafe {
     ret GL::glDrawArrays(mode as u32, first as i32, count as i32);
 }
-fn glDrawElements(mode: uint, count: int, type_: uint, indices: *()) -> () unsafe {
+fn glDrawElements(mode: uint, count: int, type_: uint, indices: * u8) -> () unsafe {
     ret GL::glDrawElements(mode as u32, count as i32, type_ as u32, indices);
 }
-fn glInterleavedArrays(format: uint, stride: int, pointer: *()) -> () unsafe {
+fn glInterleavedArrays(format: uint, stride: int, pointer: * u8) -> () unsafe {
     ret GL::glInterleavedArrays(format as u32, stride as i32, pointer);
 }
 fn glShadeModel(mode: uint) -> () unsafe {
     let bitmap_c_str = str::as_c_str(bitmap) { |bitmap_| bitmap_ };
     ret GL::glBitmap(width as i32, height as i32, xorig as f32, yorig as f32, xmove as f32, ymove as f32, bitmap_c_str as *u8);
 }
-fn glReadPixels(x: int, y: int, width: int, height: int, format: uint, type_: uint, pixels: *()) -> () unsafe {
+fn glReadPixels(x: int, y: int, width: int, height: int, format: uint, type_: uint, pixels: * u8) -> () unsafe {
     ret GL::glReadPixels(x as i32, y as i32, width as i32, height as i32, format as u32, type_ as u32, pixels);
 }
-fn glDrawPixels(width: int, height: int, format: uint, type_: uint, pixels: *()) -> () unsafe {
+fn glDrawPixels(width: int, height: int, format: uint, type_: uint, pixels: * u8) -> () unsafe {
     ret GL::glDrawPixels(width as i32, height as i32, format as u32, type_ as u32, pixels);
 }
 fn glCopyPixels(x: int, y: int, width: int, height: int, type_: uint) -> () unsafe {
 fn glGetTexLevelParameteriv(target: uint, level: int, pname: uint, params: *i32) -> () unsafe {
     ret GL::glGetTexLevelParameteriv(target as u32, level as i32, pname as u32, params);
 }
-fn glTexImage1D(target: uint, level: int, internalFormat: int, width: int, border: int, format: uint, type_: uint, pixels: *()) -> () unsafe {
+fn glTexImage1D(target: uint, level: int, internalFormat: int, width: int, border: int, format: uint, type_: uint, pixels: * u8) -> () unsafe {
     ret GL::glTexImage1D(target as u32, level as i32, internalFormat as i32, width as i32, border as i32, format as u32, type_ as u32, pixels);
 }
-fn glTexImage2D(target: uint, level: int, internalFormat: int, width: int, height: int, border: int, format: uint, type_: uint, pixels: *()) -> () unsafe {
+fn glTexImage2D(target: uint, level: int, internalFormat: int, width: int, height: int, border: int, format: uint, type_: uint, pixels: * u8) -> () unsafe {
     ret GL::glTexImage2D(target as u32, level as i32, internalFormat as i32, width as i32, height as i32, border as i32, format as u32, type_ as u32, pixels);
 }
-fn glGetTexImage(target: uint, level: int, format: uint, type_: uint, pixels: *()) -> () unsafe {
+fn glGetTexImage(target: uint, level: int, format: uint, type_: uint, pixels: * u8) -> () unsafe {
     ret GL::glGetTexImage(target as u32, level as i32, format as u32, type_ as u32, pixels);
 }
 fn glGenTextures(n: int, textures: *u32) -> () unsafe {
 fn glIsTexture(texture: uint) -> uint unsafe {
     ret GL::glIsTexture(texture as u32) as uint;
 }
-fn glTexSubImage1D(target: uint, level: int, xoffset: int, width: int, format: uint, type_: uint, pixels: *()) -> () unsafe {
+fn glTexSubImage1D(target: uint, level: int, xoffset: int, width: int, format: uint, type_: uint, pixels: * u8) -> () unsafe {
     ret GL::glTexSubImage1D(target as u32, level as i32, xoffset as i32, width as i32, format as u32, type_ as u32, pixels);
 }
-fn glTexSubImage2D(target: uint, level: int, xoffset: int, yoffset: int, width: int, height: int, format: uint, type_: uint, pixels: *()) -> () unsafe {
+fn glTexSubImage2D(target: uint, level: int, xoffset: int, yoffset: int, width: int, height: int, format: uint, type_: uint, pixels: * u8) -> () unsafe {
     ret GL::glTexSubImage2D(target as u32, level as i32, xoffset as i32, yoffset as i32, width as i32, height as i32, format as u32, type_ as u32, pixels);
 }
 fn glCopyTexImage1D(target: uint, level: int, internalformat: uint, x: int, y: int, width: int, border: int) -> () unsafe {
 fn glPopName() -> () unsafe {
     ret GL::glPopName();
 }
-fn glDrawRangeElements(mode: uint, start: uint, end: uint, count: int, type_: uint, indices: *()) -> () unsafe {
+fn glDrawRangeElements(mode: uint, start: uint, end: uint, count: int, type_: uint, indices: * u8) -> () unsafe {
     ret GL::glDrawRangeElements(mode as u32, start as u32, end as u32, count as i32, type_ as u32, indices);
 }
-fn glTexImage3D(target: uint, level: int, internalFormat: int, width: int, height: int, depth: int, border: int, format: uint, type_: uint, pixels: *()) -> () unsafe {
+fn glTexImage3D(target: uint, level: int, internalFormat: int, width: int, height: int, depth: int, border: int, format: uint, type_: uint, pixels: * u8) -> () unsafe {
     ret GL::glTexImage3D(target as u32, level as i32, internalFormat as i32, width as i32, height as i32, depth as i32, border as i32, format as u32, type_ as u32, pixels);
 }
-fn glTexSubImage3D(target: uint, level: int, xoffset: int, yoffset: int, zoffset: int, width: int, height: int, depth: int, format: uint, type_: uint, pixels: *()) -> () unsafe {
+fn glTexSubImage3D(target: uint, level: int, xoffset: int, yoffset: int, zoffset: int, width: int, height: int, depth: int, format: uint, type_: uint, pixels: * u8) -> () unsafe {
     ret GL::glTexSubImage3D(target as u32, level as i32, xoffset as i32, yoffset as i32, zoffset as i32, width as i32, height as i32, depth as i32, format as u32, type_ as u32, pixels);
 }
 fn glCopyTexSubImage3D(target: uint, level: int, xoffset: int, yoffset: int, zoffset: int, x: int, y: int, width: int, height: int) -> () unsafe {
     ret GL::glCopyTexSubImage3D(target as u32, level as i32, xoffset as i32, yoffset as i32, zoffset as i32, x as i32, y as i32, width as i32, height as i32);
 }
-fn glColorTable(target: uint, internalformat: uint, width: int, format: uint, type_: uint, table: *()) -> () unsafe {
+fn glColorTable(target: uint, internalformat: uint, width: int, format: uint, type_: uint, table: * u8) -> () unsafe {
     ret GL::glColorTable(target as u32, internalformat as u32, width as i32, format as u32, type_ as u32, table);
 }
-fn glColorSubTable(target: uint, start: int, count: int, format: uint, type_: uint, data: *()) -> () unsafe {
+fn glColorSubTable(target: uint, start: int, count: int, format: uint, type_: uint, data: * u8) -> () unsafe {
     ret GL::glColorSubTable(target as u32, start as i32, count as i32, format as u32, type_ as u32, data);
 }
 fn glColorTableParameteriv(target: uint, pname: uint, params: *i32) -> () unsafe {
 fn glCopyColorTable(target: uint, internalformat: uint, x: int, y: int, width: int) -> () unsafe {
     ret GL::glCopyColorTable(target as u32, internalformat as u32, x as i32, y as i32, width as i32);
 }
-fn glGetColorTable(target: uint, format: uint, type_: uint, table: *()) -> () unsafe {
+fn glGetColorTable(target: uint, format: uint, type_: uint, table: * u8) -> () unsafe {
     ret GL::glGetColorTable(target as u32, format as u32, type_ as u32, table);
 }
 fn glGetColorTableParameterfv(target: uint, pname: uint, params: *f32) -> () unsafe {
 fn glResetHistogram(target: uint) -> () unsafe {
     ret GL::glResetHistogram(target as u32);
 }
-fn glGetHistogram(target: uint, reset: uint, format: uint, type_: uint, values: *()) -> () unsafe {
+fn glGetHistogram(target: uint, reset: uint, format: uint, type_: uint, values: * u8) -> () unsafe {
     ret GL::glGetHistogram(target as u32, reset as u8, format as u32, type_ as u32, values);
 }
 fn glGetHistogramParameterfv(target: uint, pname: uint, params: *f32) -> () unsafe {
 fn glResetMinmax(target: uint) -> () unsafe {
     ret GL::glResetMinmax(target as u32);
 }
-fn glGetMinmax(target: uint, reset: uint, format: uint, types: uint, values: *()) -> () unsafe {
+fn glGetMinmax(target: uint, reset: uint, format: uint, types: uint, values: * u8) -> () unsafe {
     ret GL::glGetMinmax(target as u32, reset as u8, format as u32, types as u32, values);
 }
 fn glGetMinmaxParameterfv(target: uint, pname: uint, params: *f32) -> () unsafe {
 fn glGetMinmaxParameteriv(target: uint, pname: uint, params: *i32) -> () unsafe {
     ret GL::glGetMinmaxParameteriv(target as u32, pname as u32, params);
 }
-fn glConvolutionFilter1D(target: uint, internalformat: uint, width: int, format: uint, type_: uint, image: *()) -> () unsafe {
+fn glConvolutionFilter1D(target: uint, internalformat: uint, width: int, format: uint, type_: uint, image: * u8) -> () unsafe {
     ret GL::glConvolutionFilter1D(target as u32, internalformat as u32, width as i32, format as u32, type_ as u32, image);
 }
-fn glConvolutionFilter2D(target: uint, internalformat: uint, width: int, height: int, format: uint, type_: uint, image: *()) -> () unsafe {
+fn glConvolutionFilter2D(target: uint, internalformat: uint, width: int, height: int, format: uint, type_: uint, image: * u8) -> () unsafe {
     ret GL::glConvolutionFilter2D(target as u32, internalformat as u32, width as i32, height as i32, format as u32, type_ as u32, image);
 }
 fn glConvolutionParameterf(target: uint, pname: uint, params: float) -> () unsafe {
 fn glCopyConvolutionFilter2D(target: uint, internalformat: uint, x: int, y: int, width: int, height: int) -> () unsafe {
     ret GL::glCopyConvolutionFilter2D(target as u32, internalformat as u32, x as i32, y as i32, width as i32, height as i32);
 }
-fn glGetConvolutionFilter(target: uint, format: uint, type_: uint, image: *()) -> () unsafe {
+fn glGetConvolutionFilter(target: uint, format: uint, type_: uint, image: * u8) -> () unsafe {
     ret GL::glGetConvolutionFilter(target as u32, format as u32, type_ as u32, image);
 }
 fn glGetConvolutionParameterfv(target: uint, pname: uint, params: *f32) -> () unsafe {
 fn glGetConvolutionParameteriv(target: uint, pname: uint, params: *i32) -> () unsafe {
     ret GL::glGetConvolutionParameteriv(target as u32, pname as u32, params);
 }
-fn glSeparableFilter2D(target: uint, internalformat: uint, width: int, height: int, format: uint, type_: uint, row: *(), column: *()) -> () unsafe {
+fn glSeparableFilter2D(target: uint, internalformat: uint, width: int, height: int, format: uint, type_: uint, row: * u8, column: * u8) -> () unsafe {
     ret GL::glSeparableFilter2D(target as u32, internalformat as u32, width as i32, height as i32, format as u32, type_ as u32, row, column);
 }
-fn glGetSeparableFilter(target: uint, format: uint, type_: uint, row: *(), column: *(), span: *()) -> () unsafe {
+fn glGetSeparableFilter(target: uint, format: uint, type_: uint, row: * u8, column: * u8, span: * u8) -> () unsafe {
     ret GL::glGetSeparableFilter(target as u32, format as u32, type_ as u32, row, column, span);
 }
 fn glActiveTexture(texture: uint) -> () unsafe {
 fn glClientActiveTexture(texture: uint) -> () unsafe {
     ret GL::glClientActiveTexture(texture as u32);
 }
-fn glCompressedTexImage1D(target: uint, level: int, internalformat: uint, width: int, border: int, imageSize: int, data: *()) -> () unsafe {
+fn glCompressedTexImage1D(target: uint, level: int, internalformat: uint, width: int, border: int, imageSize: int, data: * u8) -> () unsafe {
     ret GL::glCompressedTexImage1D(target as u32, level as i32, internalformat as u32, width as i32, border as i32, imageSize as i32, data);
 }
-fn glCompressedTexImage2D(target: uint, level: int, internalformat: uint, width: int, height: int, border: int, imageSize: int, data: *()) -> () unsafe {
+fn glCompressedTexImage2D(target: uint, level: int, internalformat: uint, width: int, height: int, border: int, imageSize: int, data: * u8) -> () unsafe {
     ret GL::glCompressedTexImage2D(target as u32, level as i32, internalformat as u32, width as i32, height as i32, border as i32, imageSize as i32, data);
 }
-fn glCompressedTexImage3D(target: uint, level: int, internalformat: uint, width: int, height: int, depth: int, border: int, imageSize: int, data: *()) -> () unsafe {
+fn glCompressedTexImage3D(target: uint, level: int, internalformat: uint, width: int, height: int, depth: int, border: int, imageSize: int, data: * u8) -> () unsafe {
     ret GL::glCompressedTexImage3D(target as u32, level as i32, internalformat as u32, width as i32, height as i32, depth as i32, border as i32, imageSize as i32, data);
 }
-fn glCompressedTexSubImage1D(target: uint, level: int, xoffset: int, width: int, format: uint, imageSize: int, data: *()) -> () unsafe {
+fn glCompressedTexSubImage1D(target: uint, level: int, xoffset: int, width: int, format: uint, imageSize: int, data: * u8) -> () unsafe {
     ret GL::glCompressedTexSubImage1D(target as u32, level as i32, xoffset as i32, width as i32, format as u32, imageSize as i32, data);
 }
-fn glCompressedTexSubImage2D(target: uint, level: int, xoffset: int, yoffset: int, width: int, height: int, format: uint, imageSize: int, data: *()) -> () unsafe {
+fn glCompressedTexSubImage2D(target: uint, level: int, xoffset: int, yoffset: int, width: int, height: int, format: uint, imageSize: int, data: * u8) -> () unsafe {
     ret GL::glCompressedTexSubImage2D(target as u32, level as i32, xoffset as i32, yoffset as i32, width as i32, height as i32, format as u32, imageSize as i32, data);
 }
-fn glCompressedTexSubImage3D(target: uint, level: int, xoffset: int, yoffset: int, zoffset: int, width: int, height: int, depth: int, format: uint, imageSize: int, data: *()) -> () unsafe {
+fn glCompressedTexSubImage3D(target: uint, level: int, xoffset: int, yoffset: int, zoffset: int, width: int, height: int, depth: int, format: uint, imageSize: int, data: * u8) -> () unsafe {
     ret GL::glCompressedTexSubImage3D(target as u32, level as i32, xoffset as i32, yoffset as i32, zoffset as i32, width as i32, height as i32, depth as i32, format as u32, imageSize as i32, data);
 }
-fn glGetCompressedTexImage(target: uint, lod: int, img: *()) -> () unsafe {
+fn glGetCompressedTexImage(target: uint, lod: int, img: * u8) -> () unsafe {
     ret GL::glGetCompressedTexImage(target as u32, lod as i32, img);
 }
 fn glMultiTexCoord1d(target: uint, s: float) -> () unsafe {
 fn glIsBuffer(buffer: uint) -> uint unsafe {
     ret GL::glIsBuffer(buffer as u32) as uint;
 }
-fn glBufferData(target: uint, size: libc::ptrdiff_t, data: *(), usage: uint) -> () unsafe {
+fn glBufferData(target: uint, size: libc::ptrdiff_t, data: * u8, usage: uint) -> () unsafe {
     ret GL::glBufferData(target as u32, size, data, usage as u32);
 }
-fn glBufferSubData(target: uint, offset: libc::intptr_t, size: libc::ptrdiff_t, data: *()) -> () unsafe {
+fn glBufferSubData(target: uint, offset: libc::intptr_t, size: libc::ptrdiff_t, data: * u8) -> () unsafe {
     ret GL::glBufferSubData(target as u32, offset, size, data);
 }
-fn glGetBufferSubData(target: uint, offset: libc::intptr_t, size: libc::ptrdiff_t, data: *()) -> () unsafe {
+fn glGetBufferSubData(target: uint, offset: libc::intptr_t, size: libc::ptrdiff_t, data: * u8) -> () unsafe {
     ret GL::glGetBufferSubData(target as u32, offset, size, data);
 }
 fn glMapBuffer(target: uint, access: uint) -> *() unsafe {
 fn glVertexAttrib4usv(index: uint, v: *u16) -> () unsafe {
     ret GL::glVertexAttrib4usv(index as u32, v);
 }
-fn glVertexAttribPointer(index: uint, size: int, type_: uint, normalized: uint, stride: int, pointer: *()) -> () unsafe {
+fn glVertexAttribPointer(index: uint, size: int, type_: uint, normalized: uint, stride: int, pointer: * u8) -> () unsafe {
     ret GL::glVertexAttribPointer(index as u32, size as i32, type_ as u32, normalized as u8, stride as i32, pointer);
 }
 fn glUniformMatrix2x3fv(location: int, count: int, transpose: uint, value: *f32) -> () unsafe {
 fn glEndConditionalRender() -> () unsafe {
     ret GL::glEndConditionalRender();
 }
-fn glVertexAttribIPointer(index: uint, size: int, type_: uint, stride: int, pointer: *()) -> () unsafe {
+fn glVertexAttribIPointer(index: uint, size: int, type_: uint, stride: int, pointer: * u8) -> () unsafe {
     ret GL::glVertexAttribIPointer(index as u32, size as i32, type_ as u32, stride as i32, pointer);
 }
 fn glGetVertexAttribIiv(index: uint, pname: uint, params: *i32) -> () unsafe {
 fn glDrawArraysInstanced(mode: uint, first: int, count: int, primcount: int) -> () unsafe {
     ret GL::glDrawArraysInstanced(mode as u32, first as i32, count as i32, primcount as i32);
 }
-fn glDrawElementsInstanced(mode: uint, count: int, type_: uint, indices: *(), primcount: int) -> () unsafe {
+fn glDrawElementsInstanced(mode: uint, count: int, type_: uint, indices: * u8, primcount: int) -> () unsafe {
     ret GL::glDrawElementsInstanced(mode as u32, count as i32, type_ as u32, indices, primcount as i32);
 }
 fn glTexBuffer(target: uint, internalformat: uint, buffer: uint) -> () unsafe {
 fn glCopyBufferSubData(readTarget: uint, writeTarget: uint, readOffset: libc::intptr_t, writeOffset: libc::intptr_t, size: libc::ptrdiff_t) -> () unsafe {
     ret GL::glCopyBufferSubData(readTarget as u32, writeTarget as u32, readOffset, writeOffset, size);
 }
-fn glDrawElementsBaseVertex(mode: uint, count: int, type_: uint, indices: *(), basevertex: int) -> () unsafe {
+fn glDrawElementsBaseVertex(mode: uint, count: int, type_: uint, indices: * u8, basevertex: int) -> () unsafe {
     ret GL::glDrawElementsBaseVertex(mode as u32, count as i32, type_ as u32, indices, basevertex as i32);
 }
-fn glDrawRangeElementsBaseVertex(mode: uint, start: uint, end: uint, count: int, type_: uint, indices: *(), basevertex: int) -> () unsafe {
+fn glDrawRangeElementsBaseVertex(mode: uint, start: uint, end: uint, count: int, type_: uint, indices: * u8, basevertex: int) -> () unsafe {
     ret GL::glDrawRangeElementsBaseVertex(mode as u32, start as u32, end as u32, count as i32, type_ as u32, indices, basevertex as i32);
 }
-fn glDrawElementsInstancedBaseVertex(mode: uint, count: int, type_: uint, indices: *(), primcount: int, basevertex: int) -> () unsafe {
+fn glDrawElementsInstancedBaseVertex(mode: uint, count: int, type_: uint, indices: * u8, primcount: int, basevertex: int) -> () unsafe {
     ret GL::glDrawElementsInstancedBaseVertex(mode as u32, count as i32, type_ as u32, indices, primcount as i32, basevertex as i32);
 }
 fn glMultiDrawElementsBaseVertex(mode: uint, count: *i32, type_: uint, indices: **(), primcount: int, basevertex: *i32) -> () unsafe {
 fn glVertexAttribP4uiv(index: uint, type_: uint, normalized: uint, value: *u32) -> () unsafe {
     ret GL::glVertexAttribP4uiv(index as u32, type_ as u32, normalized as u8, value);
 }
-fn glDrawArraysIndirect(mode: uint, indirect: *()) -> () unsafe {
+fn glDrawArraysIndirect(mode: uint, indirect: * u8) -> () unsafe {
     ret GL::glDrawArraysIndirect(mode as u32, indirect);
 }
-fn glDrawElementsIndirect(mode: uint, type_: uint, indirect: *()) -> () unsafe {
+fn glDrawElementsIndirect(mode: uint, type_: uint, indirect: * u8) -> () unsafe {
     ret GL::glDrawElementsIndirect(mode as u32, type_ as u32, indirect);
 }
 fn glUniform1d(location: int, x: float) -> () unsafe {
 fn glReleaseShaderCompiler() -> () unsafe {
     ret GL::glReleaseShaderCompiler();
 }
-fn glShaderBinary(count: int, shaders: *u32, binaryformat: uint, binary: *(), length: int) -> () unsafe {
+fn glShaderBinary(count: int, shaders: *u32, binaryformat: uint, binary: * u8, length: int) -> () unsafe {
     ret GL::glShaderBinary(count as i32, shaders, binaryformat as u32, binary, length as i32);
 }
 fn glGetShaderPrecisionFormat(shadertype: uint, precisiontype: uint, range: *i32, precision: *i32) -> () unsafe {
 fn glClearDepthf(d: float) -> () unsafe {
     ret GL::glClearDepthf(d as f32);
 }
-fn glGetProgramBinary(program: uint, bufSize: int, length: *i32, binaryFormat: *u32, binary: *()) -> () unsafe {
+fn glGetProgramBinary(program: uint, bufSize: int, length: *i32, binaryFormat: *u32, binary: * u8) -> () unsafe {
     ret GL::glGetProgramBinary(program as u32, bufSize as i32, length, binaryFormat, binary);
 }
-fn glProgramBinary(program: uint, binaryFormat: uint, binary: *(), length: int) -> () unsafe {
+fn glProgramBinary(program: uint, binaryFormat: uint, binary: * u8, length: int) -> () unsafe {
     ret GL::glProgramBinary(program as u32, binaryFormat as u32, binary, length as i32);
 }
 fn glProgramParameteri(program: uint, pname: uint, value: int) -> () unsafe {
 fn glVertexAttribL4dv(index: uint, v: *f64) -> () unsafe {
     ret GL::glVertexAttribL4dv(index as u32, v);
 }
-fn glVertexAttribLPointer(index: uint, size: int, type_: uint, stride: int, pointer: *()) -> () unsafe {
+fn glVertexAttribLPointer(index: uint, size: int, type_: uint, stride: int, pointer: * u8) -> () unsafe {
     ret GL::glVertexAttribLPointer(index as u32, size as i32, type_ as u32, stride as i32, pointer);
 }
 fn glGetVertexAttribLdv(index: uint, pname: uint, params: *f64) -> () unsafe {
 fn glDrawArraysInstancedBaseInstance(mode: uint, first: int, count: int, primcount: int, baseinstance: uint) -> () unsafe {
     ret GL::glDrawArraysInstancedBaseInstance(mode as u32, first as i32, count as i32, primcount as i32, baseinstance as u32);
 }
-fn glDrawElementsInstancedBaseInstance(mode: uint, count: int, type_: uint, indices: *(), primcount: int, baseinstance: uint) -> () unsafe {
+fn glDrawElementsInstancedBaseInstance(mode: uint, count: int, type_: uint, indices: * u8, primcount: int, baseinstance: uint) -> () unsafe {
     ret GL::glDrawElementsInstancedBaseInstance(mode as u32, count as i32, type_ as u32, indices, primcount as i32, baseinstance as u32);
 }
-fn glDrawElementsInstancedBaseVertexBaseInstance(mode: uint, count: int, type_: uint, indices: *(), primcount: int, basevertex: int, baseinstance: uint) -> () unsafe {
+fn glDrawElementsInstancedBaseVertexBaseInstance(mode: uint, count: int, type_: uint, indices: * u8, primcount: int, basevertex: int, baseinstance: uint) -> () unsafe {
     ret GL::glDrawElementsInstancedBaseVertexBaseInstance(mode as u32, count as i32, type_ as u32, indices, primcount as i32, basevertex as i32, baseinstance as u32);
 }
 fn glDrawTransformFeedbackInstanced(mode: uint, id: uint, primcount: int) -> () unsafe {