#include char * __ClassNames[TOTAL_CLASS_COUNT] = { "opengl", "event", "keyboard", "screen", "mouse", "vector2", "vector", "int", "quadMesh", "element", "vector4", "windowManager", "Hints", "resourceManager", "texture2D", "tesselation", "mesh", "unsignedIntegerArray", "floatArray", "program", "shader", "attribute", "sampler2D", "vector3", "array", "text", "char", "fileSystem", "consoleManager", "http", "headerManager", "header", "request", "cache", "file", "mimeTypes", "uniform", "member", "block", "fontRenderer", "renderPass", "compute2", "compute", "font", "quads", "pipeline", "eventManger", "vector_char_pointer", "vector_quadMesh", "vector_element", "vector_int", "vector_vector2" }; int __ClassMethodCount[TOTAL_CLASS_COUNT] = { 14, 0, 0, 0, 0, 6, 8, 2, 0, 14, 4, 2, 0, 1, 0, 3, 9, 11, 11, 14, 3, 0, 4, 4, 12, 12, 12, 8, 5, 7, 7, 0, 2, 3, 0, 3, 0, 0, 12, 3, 2, 2, 2, 3, 8, 2, 2, 8, 8, 8, 8, 8 }; int __ClassPropertyCount[TOTAL_CLASS_COUNT] = { 11, 3, 5, 2, 3, 2, 3, 0, 8, 14, 4, 4, 5, 0, 5, 4, 14, 3, 3, 6, 1, 3, 19, 3, 3, 4, 0, 0, 0, 9, 1, 2, 9, 1, 2, 2, 6, 7, 9, 1, 3, 2, 2, 4, 7, 3, 5, 3, 3, 3, 3, 3 }; char * __ClassPropertyNames[TOTAL_CLASS_COUNT][30] = { { "mainDisplay" , "mainWindow" , "MainScreen" , "RootWindow" , "lastTime" , "startTime" , "frameCount" , "testSampler" , "windowManager" , "eventManger" , "pipeline" }, { "mouse" , "screen" , "keyboard" }, { "keyCode" , "shiftKey" , "ctrlKey" , "altKey" , "metaKey" }, { "size" , "position" }, { "position" , "button" , "eventTypes" }, { "x" , "y" }, { "capacity" , "total" , "items" }, { }, { "position" , "size" , "color" , "zIndex" , "opacity" , "textureIndex" , "features" , "elementIndex" }, { "index" , "position" , "size" , "backgroundColor" , "originalPosition" , "originalSize" , "originalBackgroundColor" , "opacity" , "backgroundImagePath" , "useBackgroundImage" , "features" , "featureNames" , "textureIndex" , "background" }, { "x" , "y" , "z" , "w" }, { "mainDisplay" , "mainWindow" , "MainScreen" , "RootWindow" }, { "flags" , "functions" , "decorations" , "inputMode" , "status" }, { }, { "data" , "width" , "height" , "hasAlpha" , "offset" }, { "program" , "mesh" , "font" , "samplerArray" }, { "program" , "indices" , "textureCoordinates" , "vertexCoordinates" , "normalCoordinates" , "blocks" , "vertexArrayObject" , "uniformBuffer" , "indexBuffer" , "vertexbuffer" , "textureCoordinateBuffer" , "meshIndexBuffer" , "uvBuffer" , "uniformBuffers" }, { "capacity" , "total" , "items" }, { "capacity" , "total" , "items" }, { "samplerIndex" , "uniforms" , "attributes" , "blocks" , "shaders" , "glProgram" }, { "glShader" }, { "name[64]" , "location" , "type" }, { "texture" , "textures" , "glTexture" , "binded" , "filter" , "MIN_FILTER" , "MAG_FILTER" , "WRAP_S" , "WRAP_T" , "datatype" , "format" , "internalFormat" , "target" , "type" , "cubeSize" , "border" , "generateMipmap" , "UNPACK_ALIGNMENT" , "index" }, { "x" , "y" , "z" }, { "capacity" , "total" , "items" }, { "value" , "usevalue" , "length" , "capacity" }, { }, { }, { }, { "socket" , "hostAddress" , "hostAddresslength" , "filesystem" , "mimetypes" , "headers" , "useSSL" , "sslContext" , "requestCallback" }, { "headers" }, { "name" , "value" }, { "connection" , "address" , "port" , "url" , "method" , "version" , "mimeType" , "extension" , "headers" }, { "files" }, { "filePath" , "content" }, { "extensions" , "mimeTypes" }, { "name[64]" , "index" , "location" , "offset" , "size" , "type" }, { "name" , "index" , "offset" , "size" , "type" , "arrayStride" , "topLevelSize" }, { "members" , "buffer" , "index" , "bufferType" , "bufferSize" , "bindingPoint" , "name" , "data" , "autoUpload" }, { "data" }, { "enabled" , "shader" , "mesh" }, { "program" , "active" }, { "program" , "active" }, { "program" , "mesh" , "font" , "samplerArray" }, { "mesh" , "font" , "samplerArray" , "program" , "meshes" , "elements" , "mouseOverElements" }, { "renderPasses" , "classIndices" , "methodIndices" }, { "mainDisplay" , "mainWindow" , "RootWindow" , "lastEvent" , "lastMouseDownTime" }, { "capacity" , "total" , "items" }, { "capacity" , "total" , "items" }, { "capacity" , "total" , "items" }, { "capacity" , "total" , "items" }, { "capacity" , "total" , "items" } }; char * __ClassMethodNames[TOTAL_CLASS_COUNT][30] = { { "initialize" , "showExtensions" , "showVersion" , "setupTime" , "setupManagers" , "setupWindow" , "setupRenderLoop" , "setupPipeline" , "clockToMilliseconds" , "render" , "displayFPS" , "clear" , "clearColor" , "swapBuffers" }, { }, { }, { }, { }, { "constructor" , "operator_plus" , "operator_add" , "add" , "subtract" , "length" }, { "length" , "get" , "set" , "resize" , "add" , "delete" , "array_push" , "unshift" }, { "toText" , "negative" }, { }, { "constructor" , "colorConverter" , "setOriginal" , "setter_size" , "setter_position" , "featureIsEnabled" , "getFeatureValueByFeatureName" , "updateFeature" , "setter_background" , "click" , "mousedown" , "mouseup" , "mouseover" , "mouseleave" }, { "constructor" , "operator_plus" , "operator_add" , "add" }, { "setupDisplay" , "setupWindow" }, { }, { "loadPngImage" }, { }, { "textFromNumber" , "prepare" , "render" }, { "getUniformBlock" , "bindBlock" , "setProgram" , "getGLTypeSize" , "getComponentType" , "getItemSize" , "createBuffer" , "createBuffers" , "createOrderedTriangleStripQuad" }, { "length" , "get" , "set" , "resize" , "addVector2" , "addVector3" , "add" , "delete" , "array_push" , "unshift" , "pop" }, { "length" , "get" , "set" , "resize" , "addVector2" , "addVector3" , "add" , "delete" , "array_push" , "unshift" , "pop" }, { "addShader" , "glGetProgramResourceiv" , "glGetProgramResourceName" , "extractBlocks" , "createNewBlock" , "getBlock" , "create" , "bindBlock" , "use" , "extractUniforms" , "extractAttributes" , "getAttributeByName" , "setUniform" , "updateSampler2D" }, { "constructor" , "loadFromFile" , "checkShaderForErrors" }, { }, { "constructor" , "addTexture" , "getTextureIndex" , "bind" }, { "constructor" , "operator_plus" , "operator_add" , "add" }, { "length" , "data" , "get" , "set" , "resize" , "add" , "join" , "delete" , "array_push" , "unshift" , "pop" , "includes" }, { "operator_compare" , "operator_add" , "constructor" , "get" , "resize" , "append" , "appendBinary" , "appendObject" , "concatenate" , "toNative" , "whiteSpace" , "free" }, { "operator_compare" , "operator_add" , "operator_plus" , "compare" , "concatenate" , "includes" , "clone" , "copy" , "split" , "removeWhitespaceLeft" , "removeWhitespaceRight" , "removeWhitespace" }, { "writeFile" , "readDir" , "readFile" , "readBinaryFile" , "ensureDirectory" , "makeDirectory" , "exists" , "isDirectory" }, { "whiteSpace" , "logObject" , "log" , "error" , "createHorisontalLine" }, { "createServer" , "initializeOpenSSL" , "listen" , "getExtension" , "logRequest" , "acceptConnection" , "dump_buffer" }, { "parse" , "display" , "add" , "set" , "getHeaderIndex" , "getValue" , "get" }, { }, { "constructor" , "free" }, { "getFile" , "addFile" , "getCachedFileByPath" }, { }, { "constructor" , "add" , "getByExtension" }, { }, { }, { "add" , "enableAutoUpload" , "getBufferTypeText" , "createBuffer" , "upload" , "mapBufferError" , "getMemberArray" , "setMemberArrayRow" , "setMemberArray" , "setMemberItem" , "setData" , "setMember" }, { "loadFont" , "draw_bitmap" , "show_image" }, { "prepare" , "render" }, { "prepare" , "render" }, { "prepare" , "render" }, { "textFromNumber" , "prepare" , "render" }, { "textFromNumber" , "prepare" , "sortOpacity" , "createMeshes" , "updateMesh" , "callElementEvents" , "integerContains" , "render" }, { "addRenderPass" , "render" }, { "constructor" , "fetchEvent" }, { "length" , "get" , "set" , "resize" , "add" , "delete" , "array_push" , "unshift" }, { "length" , "get" , "set" , "resize" , "add" , "delete" , "array_push" , "unshift" }, { "length" , "get" , "set" , "resize" , "add" , "delete" , "array_push" , "unshift" }, { "length" , "get" , "set" , "resize" , "add" , "delete" , "array_push" , "unshift" }, { "length" , "get" , "set" , "resize" , "add" , "delete" , "array_push" , "unshift" } }; int __ClassPropertyOffsets[TOTAL_CLASS_COUNT][30] = { { offsetof( opengl, mainDisplay ) , offsetof( opengl, mainWindow ) , offsetof( opengl, MainScreen ) , offsetof( opengl, RootWindow ) , offsetof( opengl, lastTime ) , offsetof( opengl, startTime ) , offsetof( opengl, frameCount ) , offsetof( opengl, testSampler ) , offsetof( opengl, windowManager ) , offsetof( opengl, eventManger ) , offsetof( opengl, pipeline ) }, { offsetof( event, mouse ) , offsetof( event, screen ) , offsetof( event, keyboard ) }, { offsetof( keyboard, keyCode ) , offsetof( keyboard, shiftKey ) , offsetof( keyboard, ctrlKey ) , offsetof( keyboard, altKey ) , offsetof( keyboard, metaKey ) }, { offsetof( screen, size ) , offsetof( screen, position ) }, { offsetof( mouse, position ) , offsetof( mouse, button ) , offsetof( mouse, eventTypes ) }, { offsetof( vector2, x ) , offsetof( vector2, y ) }, { }, { offsetof( quadMesh, position ) , offsetof( quadMesh, size ) , offsetof( quadMesh, color ) , offsetof( quadMesh, zIndex ) , offsetof( quadMesh, opacity ) , offsetof( quadMesh, textureIndex ) , offsetof( quadMesh, features ) , offsetof( quadMesh, elementIndex ) }, { offsetof( element, index ) , offsetof( element, position ) , offsetof( element, size ) , offsetof( element, backgroundColor ) , offsetof( element, originalPosition ) , offsetof( element, originalSize ) , offsetof( element, originalBackgroundColor ) , offsetof( element, opacity ) , offsetof( element, backgroundImagePath ) , offsetof( element, useBackgroundImage ) , offsetof( element, features ) , offsetof( element, featureNames ) , offsetof( element, textureIndex ) , offsetof( element, background ) }, { offsetof( vector4, x ) , offsetof( vector4, y ) , offsetof( vector4, z ) , offsetof( vector4, w ) }, { offsetof( windowManager, mainDisplay ) , offsetof( windowManager, mainWindow ) , offsetof( windowManager, MainScreen ) , offsetof( windowManager, RootWindow ) }, { offsetof( Hints, flags ) , offsetof( Hints, functions ) , offsetof( Hints, decorations ) , offsetof( Hints, inputMode ) , offsetof( Hints, status ) }, { }, { offsetof( texture2D, data ) , offsetof( texture2D, width ) , offsetof( texture2D, height ) , offsetof( texture2D, hasAlpha ) , offsetof( texture2D, offset ) }, { offsetof( tesselation, program ) , offsetof( tesselation, mesh ) , offsetof( tesselation, font ) , offsetof( tesselation, samplerArray ) }, { offsetof( mesh, program ) , offsetof( mesh, indices ) , offsetof( mesh, textureCoordinates ) , offsetof( mesh, vertexCoordinates ) , offsetof( mesh, normalCoordinates ) , offsetof( mesh, blocks ) , offsetof( mesh, vertexArrayObject ) , offsetof( mesh, uniformBuffer ) , offsetof( mesh, indexBuffer ) , offsetof( mesh, vertexbuffer ) , offsetof( mesh, textureCoordinateBuffer ) , offsetof( mesh, meshIndexBuffer ) , offsetof( mesh, uvBuffer ) , offsetof( mesh, uniformBuffers ) }, { offsetof( unsignedIntegerArray, capacity ) , offsetof( unsignedIntegerArray, total ) , offsetof( unsignedIntegerArray, items ) }, { offsetof( floatArray, capacity ) , offsetof( floatArray, total ) , offsetof( floatArray, items ) }, { offsetof( program, samplerIndex ) , offsetof( program, uniforms ) , offsetof( program, attributes ) , offsetof( program, blocks ) , offsetof( program, shaders ) , offsetof( program, glProgram ) }, { offsetof( shader, glShader ) }, { offsetof( attribute, name[64] ) , offsetof( attribute, location ) , offsetof( attribute, type ) }, { offsetof( sampler2D, texture ) , offsetof( sampler2D, textures ) , offsetof( sampler2D, glTexture ) , offsetof( sampler2D, binded ) , offsetof( sampler2D, filter ) , offsetof( sampler2D, MIN_FILTER ) , offsetof( sampler2D, MAG_FILTER ) , offsetof( sampler2D, WRAP_S ) , offsetof( sampler2D, WRAP_T ) , offsetof( sampler2D, datatype ) , offsetof( sampler2D, format ) , offsetof( sampler2D, internalFormat ) , offsetof( sampler2D, target ) , offsetof( sampler2D, type ) , offsetof( sampler2D, cubeSize ) , offsetof( sampler2D, border ) , offsetof( sampler2D, generateMipmap ) , offsetof( sampler2D, UNPACK_ALIGNMENT ) , offsetof( sampler2D, index ) }, { offsetof( vector3, x ) , offsetof( vector3, y ) , offsetof( vector3, z ) }, { offsetof( array, capacity ) , offsetof( array, total ) , offsetof( array, items ) }, { offsetof( text, value ) , offsetof( text, usevalue ) , offsetof( text, length ) , offsetof( text, capacity ) }, { }, { }, { }, { offsetof( http, socket ) , offsetof( http, hostAddress ) , offsetof( http, hostAddresslength ) , offsetof( http, filesystem ) , offsetof( http, mimetypes ) , offsetof( http, headers ) , offsetof( http, useSSL ) , offsetof( http, sslContext ) }, { offsetof( headerManager, headers ) }, { offsetof( header, name ) , offsetof( header, value ) }, { offsetof( request, connection ) , offsetof( request, address ) , offsetof( request, port ) , offsetof( request, url ) , offsetof( request, method ) , offsetof( request, version ) , offsetof( request, mimeType ) , offsetof( request, extension ) , offsetof( request, headers ) }, { offsetof( cache, files ) }, { offsetof( file, filePath ) , offsetof( file, content ) }, { offsetof( mimeTypes, extensions ) , offsetof( mimeTypes, mimeTypes ) }, { offsetof( uniform, name[64] ) , offsetof( uniform, index ) , offsetof( uniform, location ) , offsetof( uniform, offset ) , offsetof( uniform, size ) , offsetof( uniform, type ) }, { offsetof( member, name ) , offsetof( member, index ) , offsetof( member, offset ) , offsetof( member, size ) , offsetof( member, type ) , offsetof( member, arrayStride ) , offsetof( member, topLevelSize ) }, { offsetof( block, members ) , offsetof( block, buffer ) , offsetof( block, index ) , offsetof( block, bufferType ) , offsetof( block, bufferSize ) , offsetof( block, bindingPoint ) , offsetof( block, name ) , offsetof( block, data ) , offsetof( block, autoUpload ) }, { offsetof( fontRenderer, data ) }, { offsetof( renderPass, enabled ) , offsetof( renderPass, shader ) , offsetof( renderPass, mesh ) }, { offsetof( compute2, program ) , offsetof( compute2, active ) }, { offsetof( compute, program ) , offsetof( compute, active ) }, { offsetof( font, program ) , offsetof( font, mesh ) , offsetof( font, font ) , offsetof( font, samplerArray ) }, { offsetof( quads, mesh ) , offsetof( quads, font ) , offsetof( quads, samplerArray ) , offsetof( quads, program ) , offsetof( quads, meshes ) , offsetof( quads, elements ) , offsetof( quads, mouseOverElements ) }, { offsetof( pipeline, renderPasses ) , offsetof( pipeline, classIndices ) , offsetof( pipeline, methodIndices ) }, { offsetof( eventManger, mainDisplay ) , offsetof( eventManger, mainWindow ) , offsetof( eventManger, RootWindow ) , offsetof( eventManger, lastEvent ) , offsetof( eventManger, lastMouseDownTime ) } }; int __ClassPropertyDatatypeIndices[TOTAL_CLASS_COUNT][30] = { {1 , 1 , -5 , 1 , -5 , 1 , -5 , 22 , 11 , 46 , 45 }, {4 , 3 , 2 }, {-5 , 1 , 1 , 1 , 1 }, {5 , 5 }, {5 , -5 , 6 }, {1 , 1 }, {-5 , -5 , 1 }, { }, {5 , 5 , 23 , 1 , 1 , -5 , -5 , -5 }, {-5 , 23 , 5 , 23 , 23 , 5 , 23 , 1 , -3 , 1 , -5 , 6 , -5 , 1 }, {1 , 1 , 1 , 1 }, {1 , 1 , -5 , 1 }, {-6 , -6 , -6 , -6 , -6 }, { }, {1 , -5 , -5 , -5 , 5 }, {19 , 16 , 39 , 22 }, {19 , 17 , 18 , 18 , 18 , 24 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 17 }, {-5 , -5 , -5 }, {-5 , -5 , 1 }, {1 , 24 , 24 , 24 , 24 , 1 }, {1 }, {1 , 1 , 1 }, {14 , 24 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 23 , 1 , 1 , 1 , 1 }, {1 , 1 , 1 }, {-5 , -5 , 1 }, {-3 , -5 , -5 , -5 }, { }, { }, { }, {-5 , 1 , -5 , 27 , 35 , 30 , -5 , 1 , 1 }, {24 }, {-3 , -3 }, {-3 , -3 , -5 , -3 , -3 , -3 , -3 , -3 , 30 }, {24 }, {-3 , 25 }, {24 , 24 }, {-2 , 1 , 1 , 1 , 1 , 1 }, {-3 , 1 , 1 , 1 , 1 , 1 , 1 }, {24 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 }, {1 }, {1 , 20 , 16 }, {19 , -5 }, {19 , -5 }, {19 , 16 , 39 , 22 }, {16 , 39 , 22 , 19 , 6 , 6 , 6 }, {24 , 6 , 6 }, {1 , 1 , 1 , 1 , 1 }, {-5 , -5 , 1 }, {-5 , -5 , 8 }, {-5 , -5 , 9 }, {-5 , -5 , -5 }, {-5 , -5 , 5 } }; void getArrayByClassIndex( int size, void * * voidArray, int * structByteSize, int classIndex ) { switch( classIndex ) { case 0: voidArray = ( void ** ) ( struct opengl * ) malloc( sizeof( struct opengl ) * size ); *structByteSize = sizeof( struct opengl ); break; case 1: voidArray = ( void ** ) ( struct event * ) malloc( sizeof( struct event ) * size ); *structByteSize = sizeof( struct event ); break; case 2: voidArray = ( void ** ) ( struct keyboard * ) malloc( sizeof( struct keyboard ) * size ); *structByteSize = sizeof( struct keyboard ); break; case 3: voidArray = ( void ** ) ( struct screen * ) malloc( sizeof( struct screen ) * size ); *structByteSize = sizeof( struct screen ); break; case 4: voidArray = ( void ** ) ( struct mouse * ) malloc( sizeof( struct mouse ) * size ); *structByteSize = sizeof( struct mouse ); break; case 5: voidArray = ( void ** ) ( struct vector2 * ) malloc( sizeof( struct vector2 ) * size ); *structByteSize = sizeof( struct vector2 ); break; case 8: voidArray = ( void ** ) ( struct quadMesh * ) malloc( sizeof( struct quadMesh ) * size ); *structByteSize = sizeof( struct quadMesh ); break; case 9: voidArray = ( void ** ) ( struct element * ) malloc( sizeof( struct element ) * size ); *structByteSize = sizeof( struct element ); break; case 10: voidArray = ( void ** ) ( struct vector4 * ) malloc( sizeof( struct vector4 ) * size ); *structByteSize = sizeof( struct vector4 ); break; case 11: voidArray = ( void ** ) ( struct windowManager * ) malloc( sizeof( struct windowManager ) * size ); *structByteSize = sizeof( struct windowManager ); break; case 12: voidArray = ( void ** ) ( struct Hints * ) malloc( sizeof( struct Hints ) * size ); *structByteSize = sizeof( struct Hints ); break; case 13: voidArray = ( void ** ) ( struct resourceManager * ) malloc( sizeof( struct resourceManager ) * size ); *structByteSize = sizeof( struct resourceManager ); break; case 14: voidArray = ( void ** ) ( struct texture2D * ) malloc( sizeof( struct texture2D ) * size ); *structByteSize = sizeof( struct texture2D ); break; case 15: voidArray = ( void ** ) ( struct tesselation * ) malloc( sizeof( struct tesselation ) * size ); *structByteSize = sizeof( struct tesselation ); break; case 16: voidArray = ( void ** ) ( struct mesh * ) malloc( sizeof( struct mesh ) * size ); *structByteSize = sizeof( struct mesh ); break; case 17: voidArray = ( void ** ) ( struct unsignedIntegerArray * ) malloc( sizeof( struct unsignedIntegerArray ) * size ); *structByteSize = sizeof( struct unsignedIntegerArray ); break; case 18: voidArray = ( void ** ) ( struct floatArray * ) malloc( sizeof( struct floatArray ) * size ); *structByteSize = sizeof( struct floatArray ); break; case 19: voidArray = ( void ** ) ( struct program * ) malloc( sizeof( struct program ) * size ); *structByteSize = sizeof( struct program ); break; case 20: voidArray = ( void ** ) ( struct shader * ) malloc( sizeof( struct shader ) * size ); *structByteSize = sizeof( struct shader ); break; case 21: voidArray = ( void ** ) ( struct attribute * ) malloc( sizeof( struct attribute ) * size ); *structByteSize = sizeof( struct attribute ); break; case 22: voidArray = ( void ** ) ( struct sampler2D * ) malloc( sizeof( struct sampler2D ) * size ); *structByteSize = sizeof( struct sampler2D ); break; case 23: voidArray = ( void ** ) ( struct vector3 * ) malloc( sizeof( struct vector3 ) * size ); *structByteSize = sizeof( struct vector3 ); break; case 24: voidArray = ( void ** ) ( struct array * ) malloc( sizeof( struct array ) * size ); *structByteSize = sizeof( struct array ); break; case 25: voidArray = ( void ** ) ( struct text * ) malloc( sizeof( struct text ) * size ); *structByteSize = sizeof( struct text ); break; case 27: voidArray = ( void ** ) ( struct fileSystem * ) malloc( sizeof( struct fileSystem ) * size ); *structByteSize = sizeof( struct fileSystem ); break; case 28: voidArray = ( void ** ) ( struct consoleManager * ) malloc( sizeof( struct consoleManager ) * size ); *structByteSize = sizeof( struct consoleManager ); break; case 29: voidArray = ( void ** ) ( struct http * ) malloc( sizeof( struct http ) * size ); *structByteSize = sizeof( struct http ); break; case 30: voidArray = ( void ** ) ( struct headerManager * ) malloc( sizeof( struct headerManager ) * size ); *structByteSize = sizeof( struct headerManager ); break; case 31: voidArray = ( void ** ) ( struct header * ) malloc( sizeof( struct header ) * size ); *structByteSize = sizeof( struct header ); break; case 32: voidArray = ( void ** ) ( struct request * ) malloc( sizeof( struct request ) * size ); *structByteSize = sizeof( struct request ); break; case 33: voidArray = ( void ** ) ( struct cache * ) malloc( sizeof( struct cache ) * size ); *structByteSize = sizeof( struct cache ); break; case 34: voidArray = ( void ** ) ( struct file * ) malloc( sizeof( struct file ) * size ); *structByteSize = sizeof( struct file ); break; case 35: voidArray = ( void ** ) ( struct mimeTypes * ) malloc( sizeof( struct mimeTypes ) * size ); *structByteSize = sizeof( struct mimeTypes ); break; case 36: voidArray = ( void ** ) ( struct uniform * ) malloc( sizeof( struct uniform ) * size ); *structByteSize = sizeof( struct uniform ); break; case 37: voidArray = ( void ** ) ( struct member * ) malloc( sizeof( struct member ) * size ); *structByteSize = sizeof( struct member ); break; case 38: voidArray = ( void ** ) ( struct block * ) malloc( sizeof( struct block ) * size ); *structByteSize = sizeof( struct block ); break; case 39: voidArray = ( void ** ) ( struct fontRenderer * ) malloc( sizeof( struct fontRenderer ) * size ); *structByteSize = sizeof( struct fontRenderer ); break; case 40: voidArray = ( void ** ) ( struct renderPass * ) malloc( sizeof( struct renderPass ) * size ); *structByteSize = sizeof( struct renderPass ); break; case 41: voidArray = ( void ** ) ( struct compute2 * ) malloc( sizeof( struct compute2 ) * size ); *structByteSize = sizeof( struct compute2 ); break; case 42: voidArray = ( void ** ) ( struct compute * ) malloc( sizeof( struct compute ) * size ); *structByteSize = sizeof( struct compute ); break; case 43: voidArray = ( void ** ) ( struct font * ) malloc( sizeof( struct font ) * size ); *structByteSize = sizeof( struct font ); break; case 44: voidArray = ( void ** ) ( struct quads * ) malloc( sizeof( struct quads ) * size ); *structByteSize = sizeof( struct quads ); break; case 45: voidArray = ( void ** ) ( struct pipeline * ) malloc( sizeof( struct pipeline ) * size ); *structByteSize = sizeof( struct pipeline ); break; case 46: voidArray = ( void ** ) ( struct eventManger * ) malloc( sizeof( struct eventManger ) * size ); *structByteSize = sizeof( struct eventManger ); break; } } void callMethodOfClass( int classIndex, int methodIndex, void * object ) { switch( classIndex ) { case 0: switch( methodIndex ) { case 0: opengl_initialize( object ); break; case 1: opengl_showExtensions( object ); break; case 2: opengl_showVersion( object ); break; case 3: opengl_setupTime( object ); break; case 4: opengl_setupManagers( object ); break; case 5: opengl_setupWindow( object ); break; case 6: opengl_setupRenderLoop( object ); break; case 7: opengl_setupPipeline( object ); break; case 9: opengl_render( object ); break; case 10: opengl_displayFPS( object ); break; case 13: opengl_swapBuffers( object ); break; } break; case 1: switch( methodIndex ) { } break; case 2: switch( methodIndex ) { } break; case 3: switch( methodIndex ) { } break; case 4: switch( methodIndex ) { } break; case 5: switch( methodIndex ) { case 5: vector2_length( object ); break; } break; case 8: switch( methodIndex ) { } break; case 9: switch( methodIndex ) { case 0: element_constructor( object ); break; case 2: element_setOriginal( object ); break; case 7: element_updateFeature( object ); break; case 9: element_click( object ); break; case 10: element_mousedown( object ); break; case 11: element_mouseup( object ); break; case 12: element_mouseover( object ); break; case 13: element_mouseleave( object ); break; } break; case 10: switch( methodIndex ) { } break; case 11: switch( methodIndex ) { case 0: windowManager_setupDisplay( object ); break; case 1: windowManager_setupWindow( object ); break; } break; case 12: switch( methodIndex ) { } break; case 13: switch( methodIndex ) { } break; case 14: switch( methodIndex ) { } break; case 15: switch( methodIndex ) { case 1: tesselation_prepare( object ); break; case 2: tesselation_render( object ); break; } break; case 16: switch( methodIndex ) { case 7: mesh_createBuffers( object ); break; case 8: mesh_createOrderedTriangleStripQuad( object ); break; } break; case 17: switch( methodIndex ) { case 0: unsignedIntegerArray_length( object ); break; case 10: unsignedIntegerArray_pop( object ); break; } break; case 18: switch( methodIndex ) { case 0: floatArray_length( object ); break; case 10: floatArray_pop( object ); break; } break; case 19: switch( methodIndex ) { case 3: program_extractBlocks( object ); break; case 6: program_create( object ); break; case 8: program_use( object ); break; case 9: program_extractUniforms( object ); break; case 10: program_extractAttributes( object ); break; } break; case 20: switch( methodIndex ) { } break; case 21: switch( methodIndex ) { } break; case 22: switch( methodIndex ) { case 0: sampler2D_constructor( object ); break; case 2: sampler2D_getTextureIndex( object ); break; case 3: sampler2D_bind( object ); break; } break; case 23: switch( methodIndex ) { } break; case 24: switch( methodIndex ) { case 0: array_length( object ); break; case 1: array_data( object ); break; case 10: array_pop( object ); break; } break; case 25: switch( methodIndex ) { case 9: text_toNative( object ); break; case 11: text_free( object ); break; } break; case 27: switch( methodIndex ) { } break; case 28: switch( methodIndex ) { case 4: consoleManager_createHorisontalLine( object ); break; } break; case 29: switch( methodIndex ) { case 1: http_initializeOpenSSL( object ); break; case 5: http_acceptConnection( object ); break; } break; case 30: switch( methodIndex ) { case 1: headerManager_display( object ); break; } break; case 31: switch( methodIndex ) { } break; case 32: switch( methodIndex ) { case 0: request_constructor( object ); break; case 1: request_free( object ); break; } break; case 33: switch( methodIndex ) { } break; case 34: switch( methodIndex ) { } break; case 35: switch( methodIndex ) { case 0: mimeTypes_constructor( object ); break; } break; case 36: switch( methodIndex ) { } break; case 37: switch( methodIndex ) { } break; case 38: switch( methodIndex ) { case 1: block_enableAutoUpload( object ); break; case 2: block_getBufferTypeText( object ); break; case 3: block_createBuffer( object ); break; case 4: block_upload( object ); break; } break; case 39: switch( methodIndex ) { } break; case 40: switch( methodIndex ) { case 0: renderPass_prepare( object ); break; case 1: renderPass_render( object ); break; } break; case 41: switch( methodIndex ) { case 0: compute2_prepare( object ); break; case 1: compute2_render( object ); break; } break; case 42: switch( methodIndex ) { case 0: compute_prepare( object ); break; case 1: compute_render( object ); break; } break; case 43: switch( methodIndex ) { case 1: font_prepare( object ); break; case 2: font_render( object ); break; } break; case 44: switch( methodIndex ) { case 1: quads_prepare( object ); break; case 3: quads_createMeshes( object ); break; case 7: quads_render( object ); break; } break; case 45: switch( methodIndex ) { case 1: pipeline_render( object ); break; } break; case 46: switch( methodIndex ) { case 0: eventManger_constructor( object ); break; case 1: eventManger_fetchEvent( object ); break; } break; } } // #include "sqlite.h" int getPropertyIndexOfClassIndex( int propertyCount, char ** propertyNames ) { int propertyIdOfIndex = -1; for ( int i = 0; i < propertyCount; ++i ) { char * propertyName = propertyNames[i]; //printf("propertyName: %s\n", propertyName); if( strcmp( propertyName, "id" ) == 0 ) { propertyIdOfIndex = i; break; } } return propertyIdOfIndex; } /* void getArrayByClassIndex( int items, void * * voidArray, int * structByteSize, int classIndex ) { struct user * array; switch( classIndex ) { case 8: array = ( struct user * ) malloc( sizeof( struct user ) * 1000 ); voidArray = ( void ** ) array; *structByteSize = sizeof( struct user ); break; default: array = ( struct user * ) malloc( sizeof( struct user ) * 1000 ); voidArray = ( void ** ) array; *structByteSize = sizeof( struct user ); } }*/ char * getClassName( int classIndex ) { return __ClassNames[ classIndex ]; } int getClassIndexByClassName( char * className ) { for (int i = 0; i < TOTAL_CLASS_COUNT; ++i) { char * currentClassName = __ClassNames[ i ]; if( strcmp( className, currentClassName ) == 0 ) { //printf("find classname: %s\n", className); return i; } } return -1; } int getPropertyCountByClassIndex( int classIndex ) { return __ClassPropertyCount[ classIndex ]; } char * * getPropertiesByClassIndex( int classIndex ) { return __ClassPropertyNames[ classIndex ]; } int * getPropertyOffsetsByClassIndex( int classIndex ) { return __ClassPropertyOffsets[ classIndex ]; } int getPropertyOffsetByPropertyIndex( int * propertyOffsets, int propertyIndex ) { return propertyOffsets[ propertyIndex ]; } int * getPropertyDatatypeIndexesByClassIndex( int classIndex ) { return __ClassPropertyDatatypeIndices[ classIndex ]; } int getPropertyDatatypeIndex( int * propertyDatatypeIndices, int propertyIndex ) { return propertyDatatypeIndices[ propertyIndex ]; } int getPropertyIndexByPropertyName( int classID, char * propertyName ) { int propertyCount = getPropertyCountByClassIndex( classID ); char * * propertyNames = getPropertiesByClassIndex( classID ); for (int i = 0; i < propertyCount; ++i) { char * propertyNameCompare = propertyNames[i]; if( strcmp( propertyName, propertyNameCompare ) == 0 ) { return i; } } return -1; } int getMethodCountByClassIndex( int classIndex ) { return __ClassMethodCount[ classIndex ]; } char * * getMethodNamesByClassIndex( int classIndex ) { return __ClassMethodNames[ classIndex ]; } int getMethodIndexByPropertyName( int classID, char * propertyName ) { int methodCount = getMethodCountByClassIndex( classID ); char * * methodNames = getMethodNamesByClassIndex( classID ); for (int i = 0; i < methodCount; ++i) { char * propertyNameCompare = methodNames[i]; if( strcmp( propertyName, propertyNameCompare ) == 0 ) { return i; } } return -1; }