avoid last , in enums parsing

Make names visible when using gcc/clang

.github/workflows/build.yml

@@ -0,0 +1,76 @@
+name: Build
+
+on:
+  push: {}
+  pull_request: {}
+  schedule:
+    - cron:  '0 9 * * 1'
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macOS-latest, windows-latest]
+
+    steps:
+    - uses: actions/checkout@v1
+
+    - name: Install Dependencies
+      shell: bash
+      env:
+        GITHUB_OS: ${{ matrix.os }}
+      run: |
+        if [ "$GITHUB_OS" == "macOS-latest" ];
+        then
+          brew install luajit
+        elif [ "$GITHUB_OS" == "ubuntu-latest" ];
+        then
+          sudo apt-get install -y luajit
+        elif [ "$GITHUB_OS" == "windows-latest" ];
+        then
+          vcpkg install luajit
+        fi
+
+    - name: Download Submodules
+      run: |
+        git submodule update --init --recursive
+      if: github.event_name != 'schedule'
+
+    - name: Download Latest ImGui
+      shell: bash
+      run: |
+        rm -rf imgui
+        git clone https://github.com/ocornut/imgui.git
+      if: github.event_name == 'schedule'
+
+    - name: Generate Bindings
+      shell: bash
+      run: |
+        export PATH=$PATH:/C/vcpkg/packages/luajit_x86-windows/tools/:/C/vcpkg/packages/luajit_x86-windows/bin/
+        cd ./generator
+        bash ./generator.sh
+
+    - name: CMake
+      run: |
+        mkdir cmake-build
+        cd cmake-build
+        cmake -DCIMGUI_TEST=1 ..
+
+    - name: Build
+      working-directory: cmake-build
+      run: |
+        cmake --build .
+
+    - name: Test
+      shell: bash
+      env:
+        GITHUB_OS: ${{ matrix.os }}
+      working-directory: cmake-build
+      run: |
+        if [ "$GITHUB_OS" == "windows-latest" ];
+        then
+          ./Debug/cimgui_test.exe
+        else
+          ./cimgui_test
+        fi

.gitignore

@@ -32,7 +32,10 @@ cimgui/cimgui.sdf
 cimgui/cimgui.v12.suo
 cimgui/Release/
 .idea
-CMakeLists.txt
 cimgui/.vs/
 cimgui/cimgui.vcxproj.user
 cimgui/x64/
+
+# Test / Build
+bld/
+build/

.travis.yml

@@ -1,11 +1,32 @@
 language: cpp
+dist: trusty
 
 os:
   - linux
+  - osx
+  - windows
 
 compiler:
   - gcc
   - clang
 
+env:
+  - MSBUILD_PATH="c:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\MSBuild\15.0\Bin"
+
 script:
+  - mkdir bld
+  - cd bld
+  - cmake -D CIMGUI_TEST=1 ..
+  - |
+    if [ "$TRAVIS_OS_NAME" == "windows" ]; then
+      export PATH=$MSBUILD_PATH:$PATH
+      MSBuild.exe cimgui.sln
+    else
       make
+    fi
+  - |
+    if [ "$TRAVIS_OS_NAME" == "windows" ]; then
+      ./Debug/cimgui_test.exe
+    else
+      ./cimgui_test
+    fi

CMakeLists.txt

@@ -1,20 +1,15 @@
-Project(cimgui)
-cmake_minimum_required(VERSION 2.8)
+cmake_minimum_required(VERSION 3.1)
+
+project(cimgui)
 
 #general settings
-include_directories(imgui)
-add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
-
-include_directories(.)
-set(IMGUI_SOURCES ./cimgui.cpp ./imgui/imgui.cpp ./imgui/imgui_draw.cpp ./imgui/imgui_demo.cpp ./imgui/imgui_widgets.cpp)
-
-set(IMGUI_LIBRARIES )
-
-if (WIN32)
-    add_definitions("-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
-else(WIN32)
-    add_definitions("-DIMGUI_IMPL_API=extern \"C\" ")
-endif(WIN32)
+file(GLOB IMGUI_SOURCES
+    cimgui.cpp
+    imgui/imgui.cpp
+    imgui/imgui_draw.cpp
+    imgui/imgui_demo.cpp
+    imgui/imgui_widgets.cpp
+)
 
 set(IMGUI_STATIC "no" CACHE STRING "Build as a static library")
 
@@ -25,7 +20,15 @@ else (IMGUI_STATIC)
     add_library(cimgui SHARED ${IMGUI_SOURCES})
 endif (IMGUI_STATIC)
 
-target_link_libraries(cimgui ${IMGUI_LIBRARIES})
+target_compile_definitions(cimgui PUBLIC IMGUI_DISABLE_OBSOLETE_FUNCTIONS=1)
+if (WIN32)
+    target_compile_definitions(cimgui PUBLIC IMGUI_IMPL_API="extern \"C\" __declspec\(dllexport\)")
+else (WIN32)
+    target_compile_definitions(cimgui PUBLIC IMGUI_IMPL_API="extern \"C\" ")
+endif (WIN32)
+
+target_include_directories(cimgui PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+target_include_directories(cimgui PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/imgui)
 set_target_properties(cimgui PROPERTIES PREFIX "")
 
 #install
@@ -34,3 +37,10 @@ install(TARGETS cimgui
     LIBRARY DESTINATION  .
     ARCHIVE DESTINATION  .
 )
+
+#test
+set(CIMGUI_TEST "no" CACHE STRING "Enable compilation of a test unit based on imgui null")
+
+if (CIMGUI_TEST)
+  add_subdirectory(test)
+endif ()

Makefile

@@ -8,7 +8,7 @@ OBJS += ./imgui/imgui_draw.o
 OBJS += ./imgui/imgui_demo.o
 OBJS += ./imgui/imgui_widgets.o
 
-CXXFLAGS=-O2
+CXXFLAGS=-O2 -fno-exceptions -fno-rtti
 
 UNAME_S := $(shell uname -s)
 
@@ -46,11 +46,18 @@ endif
 .cpp.o:
 	$(CXX) $(CXXFLAGS) -c -o $@ $<
 
-all:imgui_example
+all:$(OUTPUTNAME)
 	@echo Build complete for $(ECHO_MESSAGE)
 
-imgui_example:$(OBJS)
+$(OUTPUTNAME):$(OBJS)
 	$(CXX) -o $(OUTPUTNAME) $(OBJS) $(CXXFLAGS) $(LINKFLAGS)
 
 clean:
-	rm $(OBJS)
+	rm -f $(OBJS)
+
+fclean: clean
+	rm -f $(OUTPUTNAME)
+
+re: fclean all
+
+.PHONY: all clean fclean re

README.md

@@ -1,4 +1,4 @@
-# cimgui [![Build Status](https://travis-ci.org/sonoro1234/cimgui.svg?branch=master)](https://travis-ci.org/sonoro1234/cimgui)
+# cimgui [![Build Status](https://travis-ci.org/cimgui/cimgui.svg?branch=master)](https://travis-ci.org/cimgui/cimgui)
 
 
 This is a thin c-api wrapper programmatically generated for the excellent C++ immediate mode gui [Dear ImGui](https://github.com/ocornut/imgui).
@@ -11,10 +11,11 @@ History:
 Initially cimgui was developed by Stephan Dilly as hand-written code but lately turned into an auto-generated version by sonoro1234 in order to keep up with imgui more easily (letting the user select the desired branch and commit)
 
 Notes:
-* currently this wrapper is based on version [1.68 of Dear ImGui]
-* only functions, structs and enums from imgui.h are wrapped.
-* if you are interested in imgui implementations you should look LuaJIT-ImGui project.
-* overloaded function names try to be the most compatible with traditional cimgui names. So all naming is algorithmic except for those names that were in conflict with widely used cimgui names and were thus coded in a table (https://github.com/cimgui/cimgui/blob/master/generator/generator.lua#L58). Current overloaded function names can be found in (https://github.com/cimgui/cimgui/blob/master/generator/output/overloads.txt)
+* currently this wrapper is based on version [1.76 of Dear ImGui with internal api]
+* only functions, structs and enums from imgui.h (an optionally imgui_internal.h) are wrapped.
+* if you are interested in imgui implementations you should look [LuaJIT-ImGui](https://github.com/sonoro1234/LuaJIT-ImGui) project.
+* All naming is algorithmic except for those names that were coded in cimgui_overloads table (https://github.com/cimgui/cimgui/blob/master/generator/generator.lua#L60). In the official version this table is empty.
+* Current overloaded function names can be found in (https://github.com/cimgui/cimgui/blob/master/generator/output/overloads.txt)
 
 # compilation
 
@@ -23,21 +24,23 @@ Notes:
   * git submodule update
 * compile 
   * using makefile on linux/macOS/mingw (Or use CMake to generate project)
-  * or as in https://github.com/sonoro1234/LuaJIT-ImGui/tree/master_auto_implementations/build
+  * or as in https://github.com/sonoro1234/LuaJIT-ImGui/tree/master/build
 
 # using generator
 
-* this is only needed if you want an imgui version different from the one provided, otherwise generation is already done.
+* this is only needed (before compilation) if you want an imgui version different from the one provided, otherwise generation is already done.
 * you will need LuaJIT (https://github.com/LuaJIT/LuaJIT.git better 2.1 branch) or precompiled for linux/macOS/windows in https://luapower.com/luajit/download
-* you can use also a C++ compiler for doing preprocessing: gcc (In windows MinGW-W64-builds for example), clang or cl (MSVC) or not use a compiler (experimental nocompiler option) at all. (this repo was done with gcc)
+* you need to use also a C++ compiler for doing preprocessing: gcc (In windows MinGW-W64-builds for example), clang or cl (MSVC). (this repo was done with gcc)
 * update `imgui` folder to the version you desire.
-* edit `generator/generator.bat` (or make a .sh version and please PR) to choose between gcc, clang, cl or nocompiler. Run it with gcc, clang or cl and LuaJIT on your PATH.
+* edit `generator/generator.bat` on windows, or `generator/generator.sh` on linux, to choose between gcc, clang, or cl and to choose desired implementations and whether imgui_internal is generated or not. 
+* edit config_generator.lua for adding includes needed by your chosen implementations (vulkan needs that).
+* Run generator.bat or generator.sh with gcc, clang or cl and LuaJIT on your PATH.
 * as a result some files are generated: `cimgui.cpp` and `cimgui.h` for compiling and some lua/json files with information about the binding: `definitions.json` with function info, `structs_and_enums.json` with struct and enum info, `impl_definitions.json` with functions from the implementations info. 
 
 # generate binding
 * C interface is exposed by cimgui.h when you define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 * with your prefered language you can use the lua or json files generated as in:
-  * https://github.com/sonoro1234/LuaJIT-ImGui/blob/master_auto_implementations/lua/build.bat (with lua code generation in https://github.com/sonoro1234/LuaJIT-ImGui/blob/master_auto_implementations/lua/class_gen.lua)
+  * https://github.com/sonoro1234/LuaJIT-ImGui/blob/master/lua/build.bat (with lua code generation in https://github.com/sonoro1234/LuaJIT-ImGui/blob/master/lua/class_gen.lua)
   * https://github.com/mellinoe/ImGui.NET/tree/autogen/src/CodeGenerator
 ### definitions description
 * It is a collection in which key is the cimgui name that would result without overloadings and the value is an array of overloadings (may be only one overloading)
@@ -46,18 +49,18 @@ Notes:
   * ov_cimguiname : the overloaded cimgui name (if absent it would be taken from cimguiname)
   * cimguiname : the name without overloading (this should be used if there is not ov_cimguiname)
   * ret : the return type
-  * retref : is setted if original return type is a reference. (will be a pointer in cimgui)
+  * retref : is set if original return type is a reference. (will be a pointer in cimgui)
   * argsT : an array of collections (each one with type: argument type and name: the argument name)
   * args : a string of argsT concatenated and separated by commas
   * call_args : a string with the argument names separated by commas for calling imgui function
   * defaults : a collection in which key is argument name and value is the default value.
   * manual : will be true if this function is hand-written (not generated)
-  * isvararg : is setted if some argument is a vararg
-  * constructor : is setted if the function is a constructor for a class
-  * destructor : is setted if the function is a destructor for a class
-  * templated : is setted if the function belongs to a templated class (ImVector)
-  * templatedgen: is setted if the function belongs to a struct generated from template (ImVector_ImWchar)
-  * nonUDT : if present can be 1 or 2 (explained meaning in usage) if return type was a user defined type
+  * isvararg : is set if some argument is a vararg
+  * constructor : is set if the function is a constructor for a class
+  * destructor : is set if the function is a destructor for a class
+  * templated : is set if the function belongs to a templated class (ImVector)
+  * templatedgen: is set if the function belongs to a struct generated from template (ImVector_ImWchar)
+  * nonUDT : if present the original function was returning a user defined type so that signature has been changed to accept a pointer to the UDT as first argument.
 ### structs_and_enums description
 * Is is a collection with two items:
   * under key enums we get the enums collection in which each key is the enum tagname and the value is an array of the ordered values represented as a collection with keys
@@ -68,13 +71,13 @@ Notes:
     * type : the type of the struct member
     * template_type : if type has a template argument (as ImVector) here will be
     * name : the name of the struct member
+	* bitfield : the bitfield width (in case it is a bitfield)
 # usage
 
 * use whatever method is in ImGui c++ namespace in the original [imgui.h](https://github.com/ocornut/imgui/blob/master/imgui.h) by prepending `ig`
 * methods have the same parameter list and return values (where possible)
 * functions that belong to a struct have an extra first argument with a pointer to the struct.
-* where a function returns UDT (user defined type) by value some compilers complain so another function with the name `function_name_nonUDT` is generated accepting a pointer to the UDT type as the first argument.
-* also is generated `function_name_nonUDT2` which instead of returning the UDT type returns a simple version (without functions) called `UDTType_Simple` (`ImVec2_Simple` for `ImVec2`)
+* where a function returns UDT (user defined type) by value some compilers complain so the function is generated accepting a pointer to the UDT type as the first argument (or second if belongs to a struct).
 
 # example bindings based on cimgui
 
@@ -84,4 +87,10 @@ Notes:
 * [imgui-rs](https://github.com/Gekkio/imgui-rs)
 * [imgui-pas](https://github.com/dpethes/imgui-pas)
 * [odin-imgui](https://github.com/ThisDrunkDane/odin-imgui)
-* [LuaJIT-imgui](https://github.com/sonoro1234/LuaJIT-ImGui)
+* [LuaJIT-ImGui](https://github.com/sonoro1234/LuaJIT-ImGui)
+
+# C examples based on cimgui
+
+* [sdl2-cimgui-demo](https://github.com/haxpor/sdl2-cimgui-demo)
+* [cimgui_c_sdl2_example](https://github.com/canoi12/cimgui_c_sdl2_example/)
+* [cimgui-c-example](https://github.com/peko/cimgui-c-example) with GLFW

generator/cimgui_template.cpp

@@ -1,8 +1,9 @@
 
 #include "./imgui/imgui.h"
+#include "./imgui/imgui_internal.h"
 #include "cimgui.h"
 
-#include "./imgui/imgui_internal.h"
+
 
 #include "auto_funcs.cpp"
 
@@ -44,6 +45,11 @@ CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create()
 	return IM_NEW(ImVector<ImWchar>) ();
 }
 
+CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self)
+{
+    IM_DELETE(self);
+}
+
 CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p)
 {
 	IM_PLACEMENT_NEW(p) ImVector<ImWchar>();
@@ -53,3 +59,63 @@ CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p)
 	p->~ImVector<ImWchar>();
 }
 
+
+#ifdef IMGUI_HAS_DOCK
+
+// NOTE: Some function pointers in the ImGuiPlatformIO structure are not C-compatible because of their
+// use of a complex return type. To work around this, we store a custom CimguiStorage object inside
+// ImGuiIO::BackendLanguageUserData, which contains C-compatible function pointer variants for these
+// functions. When a user function pointer is provided, we hook up the underlying ImGuiPlatformIO
+// function pointer to a thunk which accesses the user function pointer through CimguiStorage.
+
+struct CimguiStorage
+{
+    void(*Platform_GetWindowPos)(ImGuiViewport* vp, ImVec2* out_pos);
+    void(*Platform_GetWindowSize)(ImGuiViewport* vp, ImVec2* out_pos);
+};
+
+// Gets a reference to the CimguiStorage object stored in the current ImGui context's BackendLanguageUserData.
+CimguiStorage& GetCimguiStorage()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    if (io.BackendLanguageUserData == NULL)
+    {
+        io.BackendLanguageUserData = new CimguiStorage();
+    }
+
+    return *(CimguiStorage*)io.BackendLanguageUserData;
+}
+
+// Thunk satisfying the signature of ImGuiPlatformIO::Platform_GetWindowPos.
+ImVec2 Platform_GetWindowPos_hook(ImGuiViewport* vp)
+{
+    ImVec2 pos;
+    GetCimguiStorage().Platform_GetWindowPos(vp, &pos);
+    return pos;
+};
+
+// Fully C-compatible function pointer setter for ImGuiPlatformIO::Platform_GetWindowPos.
+CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowPos(ImGuiPlatformIO* platform_io, void(*user_callback)(ImGuiViewport* vp, ImVec2* out_pos))
+{
+    CimguiStorage& storage = GetCimguiStorage();
+    storage.Platform_GetWindowPos = user_callback;
+    platform_io->Platform_GetWindowPos = &Platform_GetWindowPos_hook;
+}
+
+// Thunk satisfying the signature of ImGuiPlatformIO::Platform_GetWindowSize.
+ImVec2 Platform_GetWindowSize_hook(ImGuiViewport* vp)
+{
+    ImVec2 size;
+    GetCimguiStorage().Platform_GetWindowSize(vp, &size);
+    return size;
+};
+
+// Fully C-compatible function pointer setter for ImGuiPlatformIO::Platform_GetWindowSize.
+CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowSize(ImGuiPlatformIO* platform_io, void(*user_callback)(ImGuiViewport* vp, ImVec2* out_size))
+{
+    CimguiStorage& storage = GetCimguiStorage();
+    storage.Platform_GetWindowSize = user_callback;
+    platform_io->Platform_GetWindowSize = &Platform_GetWindowSize_hook;
+}
+
+#endif

generator/cimgui_template.h

@@ -11,9 +11,13 @@
     #ifndef __GNUC__
     #define snprintf sprintf_s
     #endif
+#else
+    #ifdef __GNUC__
+        #define API  __attribute__((__visibility__("default")))
     #else
         #define API
     #endif
+#endif
 
 #if defined __cplusplus
     #define EXTERN extern "C"
@@ -33,11 +37,6 @@ typedef unsigned __int64 ImU64;
 //typedef unsigned long long ImU64;
 #endif
 
-//UDT stuff
-typedef struct ImVec2_Simple { float x; float y; } ImVec2_Simple;
-typedef struct ImVec4_Simple { float x; float y; float z; float w;} ImVec4_Simple;
-typedef struct ImColor_Simple { ImVec4_Simple Value;} ImColor_Simple;
-
 
 #ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 #include "imgui_structs.h"
@@ -45,28 +44,6 @@ typedef struct ImColor_Simple { ImVec4_Simple Value;} ImColor_Simple;
 struct GLFWwindow;
 struct SDL_Window;
 typedef union SDL_Event SDL_Event;
-inline ImVec2_Simple ImVec2ToSimple(ImVec2 vec)
-{
-	ImVec2_Simple result;
-    result.x = vec.x;
-    result.y = vec.y;
-    return result;
-}
-inline ImVec4_Simple ImVec4ToSimple(ImVec4 vec)
-{
-	ImVec4_Simple result;
-    result.x = vec.x;
-    result.y = vec.y;
-	result.z = vec.z;
-    result.w = vec.w;
-    return result;
-}
-inline ImColor_Simple ImColorToSimple(ImColor col)
-{
-	ImColor_Simple result;
-    result.Value = ImVec4ToSimple(col.Value);
-    return result;
-}
 #endif // CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 
 #include "auto_funcs.h"
@@ -82,9 +59,13 @@ CIMGUI_API float igGET_FLT_MAX();
 CIMGUI_API void igColorConvertRGBtoHSV(float r,float g,float b,float *out_h,float *out_s,float *out_v);
 CIMGUI_API void igColorConvertHSVtoRGB(float h,float s,float v,float *out_r,float *out_g,float *out_b);
 
+
 CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create();
+CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self);
 CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p);
 CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p);
+
+
 #endif //CIMGUI_INCLUDED
 
 

generator/config_generator.lua

@@ -0,0 +1,3 @@
+return {
+	vulkan = {[[C:\VulkanSDK\1.1.130.0\Include]]}
+}

generator/cpp2ffi.lua

@@ -93,6 +93,26 @@ local function str_split(str, pat)
 	end
 	return t
 end
+local function strsplit(str, pat)
+    local t = {} 
+	local t2 = {}
+    local fpat = "(.-)" .. pat
+    local last_end = 1
+    local s, e, cap, cap2 = str:find(fpat, 1)
+    while s do
+        table.insert(t,cap)
+		table.insert(t2,cap2)
+        last_end = e+1
+        s, e, cap, cap2 = str:find(fpat, last_end)
+    end
+    if last_end <= #str then
+        cap = str:sub(last_end)
+        table.insert(t, cap)
+    elseif str:sub(-1)==pat then
+        table.insert(t, "")
+    end
+    return t,t2
+end
 local function split_comment(line)
     local comment = line:match("(%s*//.*)") or ""
     line = line:gsub("%s*//.*","")
@@ -104,31 +124,93 @@ local function strip(cad)
     return cad:gsub("^%s*(.-)%s*$","%1") --remove initial and final spaces
 end
 local function strip_end(cad)
-    return cad:gsub("^(.-)%s*$","%1") --remove initial and final spaces
+    return cad:gsub("^(.-)%s*$","%1") --remove  final spaces
 end
 local function clean_spaces(cad)
     cad = strip(cad)
     cad = cad:gsub("%s+"," ") --not more than one space
-    cad = cad:gsub("%s*([%(%),=])%s*","%1") --not spaces with ( , )
+    cad = cad:gsub("%s*([%(%),=:%+])%s*","%1") --not spaces with ( , ) or ( = ) or ( : ) or + 
+	--clean %d * %d (could be done above but type*name should be treated different in other places)
+	cad = cad:gsub("(%d)%s*(%*)%s*(%d)","%1%2%3")
     return cad
 end
-function strsplit(str, pat)
-    local t = {} 
-    local fpat = "(.-)" .. pat
-    local last_end = 1
-    local s, e, cap = str:find(fpat, 1)
-    while s do
-        table.insert(t,cap)
-        last_end = e+1
-        s, e, cap = str:find(fpat, last_end)
+
+------------------------------------
+local function parse_enum_value(enline, allenums)
+	local value = enline.value
+	local function clean(val)
+		if type(val)=="string" then
+			return clean_spaces(val)
+		else
+			return val
 		end
-    if last_end <= #str then
-        cap = str:sub(last_end)
-        table.insert(t, cap)
-    elseif str:sub(-1)==pat then
-        table.insert(t, "")
 	end
-    return t
+	
+	if type(value)=="number" then
+		return value
+	elseif type(value)=="string" then 
+		--numbers
+		local numval = tonumber(value)
+		if numval then return numval end 
+		--already in allenums
+		if allenums[clean(value)] then return allenums[clean(value)] end
+		--must be several and operators
+		--precedence order (hope not ())
+		assert(not value:match("[%(%)]"))
+		local several,seps = strsplit(value,"([<>&|~%+]+)") 
+		--M.prtable(value,several,seps)
+		assert(#seps+1==#several)
+		
+		local i = 1
+		local ik = 1
+		local sepk = {"~","<<",">>","&","^","|","+"}
+		while(#seps>0) do
+			local sep = sepk[ik]
+			local v = seps[i]
+			if sep==v then
+				local val1 = clean(several[i])
+				local val2 = clean(several[i+1])
+				if allenums[val1] then val1 = allenums[val1] end
+				if allenums[val2] then val2 = allenums[val2] end
+				if v=="~" then
+					assert(several[i]==" " or several[i]=="")
+					several[i] = bit.bnot(val2)
+				elseif v=="<<" then
+					several[i] = bit.lshift(val1,val2)
+				elseif v==">>" then
+					several[i] = bit.rshift(val1,val2)
+				elseif v=="&" then
+					several[i] = bit.band(val1,val2)
+				elseif v=="^" then
+					error"^ operator still not done"
+				elseif v=="|" then
+					several[i] = bit.bor(val1,val2)
+				elseif v=="+" then
+					several[i] = val1 + val2
+				else
+					error("unknown operator "..v)
+				end
+				table.remove(several,i+1)
+				table.remove(seps,i)
+			else
+				i = i + 1
+			end				
+
+			if i>#seps then
+				ik = ik + 1 --next operator
+				if ik > #sepk then break end
+				i = 1
+			end
+		end
+		if #seps>0 or type(several[1])~="number" then
+			M.prtable("enline",enline)
+			M.prtable(several,seps)
+			M.prtable(allenums)
+		end
+		assert(#seps==0)
+		assert(type(several[1])=="number")
+		return several[1]
+	end
 end
 --------------------------------------------------------------------------
 local function save_data(filename,...)
@@ -180,15 +262,19 @@ local function getRE()
 	namespace_re = "^([^;{}]-namespace[^;{}]-%b{})",
 	class_re = "^([^;{}]-class[^;{}]-%b{}%s*;)",
 	typedef_re = "^\n*(typedef[^;]+;)",
+	typedef_st_re = "^\n*(typedef%s+struct%s*%b{}.+;)",
 	functypedef_re = "^\n*%s*(typedef[%w%s%*_]+%(%s*%*%s*[%w_]+%s*%)%s*%b()%s*;)",
 	functypedef_re = "^\n*%s*(typedef[%w%s%*_]+%([^*]*%*%s*[%w_]+%s*%)%s*%b()%s*;)",
-	vardef_re = "^\n*([^;{}%(%)]+;)",
+	--vardef_re = "^\n*([^;{}%(%)]+;)",
+	--change for things as
+	--[[ImU8 Used4kPagesMap[((sizeof(ImWchar16) == 2 ? 0xFFFF : 0x10FFFF)+1)/4096/8];]]
+	vardef_re = "^\n*([^;{}]+;)",
 	functionD_re = "^([^;{}]-%b()[\n%s%w]*%b{})",
 	--functionD_re = "^([^;{}]-%b()[^{}%(%)]*%b{})",
 	functype_re = "^%s*[%w%s%*]+%(%*[%w_]+%)%([^%(%)]*%)%s*;"
 	}
 	
-	local resN = {"functypedef_re","functype_re","function_re","functionD_re","struct_re","enum_re","union_re","namespace_re","class_re","typedef_re","vardef_re"}
+	local resN = {"functypedef_re","functype_re","function_re","functionD_re","typedef_st_re","struct_re","enum_re","union_re","namespace_re","class_re","typedef_re","vardef_re"}
 	
 	return res,resN
 end
@@ -219,7 +305,7 @@ local function parseItems(txt,dumpit)
 				ini = e + 1
 				if dumpit then
 					print(item)
-					print(ire,"------------------------------------------------------")
+					print(ire,re_name,"------------------------------------------------------")
 				end
 				break
 			end
@@ -231,6 +317,7 @@ local function parseItems(txt,dumpit)
 				if not onlyspaces then
 					print(ini,#txt);
 					print(txt);
+					print"item:"
 					print(item)
 					error"parseItems error"
 				end
@@ -300,6 +387,8 @@ local function name_overloadsAlgo(v)
             end
         end
     end
+	--avoid empty postfix which will be reserved to generic
+	for i,v in ipairs(bb) do if v=="" then bb[i]="Nil" end end
     return aa,bb
 end
 local function typetoStr(typ)
@@ -342,7 +431,7 @@ local function parseFunction(self,stname,lineorig,namespace)
 	--skip template
 	if line:match("template") then return end
     
-    local ret = line:match("([^%(%)]+[%*%s])%s?~?[_%w]+%b()")
+    local ret = line:match("([^%(%):,]+[%*%s])%s?~?[_%w]+%b()")
     --local funcname, args = line:match("(~?[_%w]+)%s*(%b())")
 	local funcname, args, extraconst = line:match("(~?[_%w]+)%s*(%b())(.*)")
 	extraconst = extraconst:match("const")
@@ -373,14 +462,15 @@ local function parseFunction(self,stname,lineorig,namespace)
 		if self.typenames[stname] ~= template then --rule out template typename
 		te = template:gsub("%s","_")
         te = te:gsub("%*","Ptr")
-		te = "_"..te
 
 		self.templates[ttype] = self.templates[ttype] or {}
 		self.templates[ttype][template] = te
+		te = "_"..te
 		end
 	end
 	--end
-    argscsinpars = argscsinpars:gsub("<([%w_%*]+)>",te) --ImVector
+
+	argscsinpars = argscsinpars:gsub("<([%w_%*%s]+)>",te) --ImVector
 
     local argsArr = {}
     local functype_re =       "^%s*[%w%s%*]+%(%*[%w_]+%)%([^%(%)]*%)"
@@ -432,7 +522,7 @@ local function parseFunction(self,stname,lineorig,namespace)
             --only post error if not manual
             local cname = self.getCname(stname,funcname) --cimguiname
             if not self.manuals[cname] then
-                print("reference to no const arg in",funcname,argscsinpars)
+                print("reference to no const arg in",funcname,argscsinpars,arg)
             end
         end
     end
@@ -466,7 +556,7 @@ local function parseFunction(self,stname,lineorig,namespace)
     defT.defaults = {}
     --for k,def in args:gmatch("([%w%s%*_]+)=([%w_%(%)%s,%*]+)[,%)]") do
     --for k,def in args:gmatch("([%w_]+)=([%w_%(%)%s,%*%.%-]+)[,%)]") do
-    for k,def in args:gmatch('([%w_]+)=([%w_%(%)%s,%*%.%-%+%%"]+)[,%)]') do
+    for k,def in args:gmatch('([%w_]+)=([|<%w_%(%)%s,%*%.%-%+%%"]+)[,%)]') do
         defT.defaults[k]=def
     end
 	defT.templated = self.typenames[stname] and true
@@ -519,14 +609,16 @@ local function AdjustArguments(FP)
 end
 local function ADDnonUDT(FP)
     local defsT = FP.defsT
-    local newcdefs = {}
-    --for cimguiname,defs in pairs(defsT) do
-    --for i,defT in ipairs(defs) do
-		--local t = {cimguiname=cimguiname,signature=defT.signature,ret=defT.ret}
+    --local newcdefs = {}
     for numcdef,t in ipairs(FP.funcdefs) do
         if t.cimguiname then
         local cimf = defsT[t.cimguiname]
         local defT = cimf[t.signature]
+		--find index
+		local index
+		for ind,ddd in ipairs(cimf) do
+			if ddd == defT then index=ind; break end
+		end
         --if UDT return generate nonUDT version
 		local isUDT = false
 		for _,udt_ret in ipairs(FP.UDTs) do
@@ -548,41 +640,26 @@ local function ADDnonUDT(FP)
             local comma = (#defT.argsT > 0) and "," or ""
             defT2.args = "("..defT.ret.." *pOut"..comma..defT.args:sub(2)
             defT2.ret = "void"
-            defT2.ov_cimguiname = (defT2.ov_cimguiname or defT2.cimguiname).."_nonUDT"
+            defT2.ov_cimguiname = (defT2.ov_cimguiname or defT2.cimguiname) --.."_nonUDT"
             defT2.nonUDT = 1
             defT2.retref = nil
-            defsT[t.cimguiname][#defsT[t.cimguiname] + 1] = defT2
-            defsT[t.cimguiname][t.signature.."nonUDT"] = defT2
-            table.insert(newcdefs,{stname=t.stname,funcname=t.funcname,args=args,argsc=argscsinpars,signature=t.signature.."nonUDT",cimguiname=t.cimguiname,call_args=call_args,ret =t.ret})
-            --converting to Simple type----------------------------------------------------
-            local defT3 = {}
-            --first strings
-            for k,v in pairs(defT) do
-                defT3[k] = v
+			
+			--replace
+			cimf[index] = defT2
+			cimf[t.signature] = defT2
+			FP.funcdefs[numcdef] = {stname=t.stname,funcname=t.funcname,args=args,argsc=argscsinpars,signature=t.signature,cimguiname=t.cimguiname,call_args=call_args,ret =t.ret}
+			
+            -- defsT[t.cimguiname][#defsT[t.cimguiname] + 1] = defT2
+            -- defsT[t.cimguiname][t.signature.."nonUDT"] = defT2
+            -- table.insert(newcdefs,{stname=t.stname,funcname=t.funcname,args=args,argsc=argscsinpars,signature=t.signature.."nonUDT",cimguiname=t.cimguiname,call_args=call_args,ret =t.ret})
         end
-            --then argsT table
-            defT3.argsT = {}
-            for k,v in ipairs(defT.argsT) do
-                table.insert(defT3.argsT,{type=v.type,name=v.name})
-            end
-            local comma = (#defT.argsT > 0) and "," or ""
-            --defT3.args = "("..defT.ret.." *pOut"..comma..defT.args:sub(2)
-            defT3.ret = defT.ret.."_Simple"
-            defT3.retorig = defT.ret
-            defT3.ov_cimguiname = (defT3.ov_cimguiname or defT3.cimguiname).."_nonUDT2"
-            defT3.nonUDT = 2
-            defT3.retref = nil
-            defsT[t.cimguiname][#defsT[t.cimguiname] + 1] = defT3
-            defsT[t.cimguiname][t.signature.."nonUDT2"] = defT3
-            table.insert(newcdefs,{stname=t.stname,funcname=t.funcname,args=args,argsc=argscsinpars,signature=t.signature.."nonUDT2",cimguiname=t.cimguiname,call_args=call_args,ret =t.ret})
+		else print("not cimguiname in");M.prtable(t)
         end
     end
+    -- for i,v in ipairs(newcdefs) do
+        -- table.insert(FP.funcdefs,v)
     -- end
 end
-    for i,v in ipairs(newcdefs) do
-        table.insert(FP.funcdefs,v)
-    end
-end
 
 local function ADDdestructors(FP)
     local defsT = FP.defsT
@@ -630,6 +707,7 @@ end
 
 --only basic ending
 local c_types = {
+    ["bool"]=true,
     ["char"]=true,
     ["int"]=true,
     ["float"]=true,
@@ -641,6 +719,7 @@ local c_types = {
     ["size_t"]=true,
     ["ptrdiff_t"]=true,
 }
+M.c_types = c_types
 local function check_arg_detection(fdefs,typedefs)
     print"-----------------check arg detection---------------------------"
     for k,defT in pairs(fdefs) do
@@ -709,7 +788,7 @@ function M.Parser()
 		self:parseFunctions()
 		self:compute_overloads()
 		self:gen_structs_and_enums()
-		self:compute_templated()
+		--self:compute_templated()
 		ADDdestructors(self)
 	end
 	function par:parseItems()
@@ -727,8 +806,8 @@ function M.Parser()
 						linet = linet:gsub("typedef ","")
 						linet = linet:gsub("%(%*("..key..")%)","(*)")
 						self.typedefs_dict[key] = linet
-					else
-						print("not found function typedef")
+					elseif not line:match"typedef%s*struct" then --discard typedef struct
+						print("typedef not found")
 						print(key,value,line)
 					end
 				end
@@ -792,14 +871,29 @@ function M.Parser()
 	function par:clean_struct(stru)
 		local outtab = {}
 		local iner = strip_end(stru:match("%b{}"):sub(2,-2))
-		local stname = stru:match("struct%s*(%S+)%s*%b{}")
+		local inistruct = clean_spaces(stru:match("(.-)%b{}"))
+		--local stname = stru:match("struct%s*(%S+)%s*%b{}")
+		local stname, derived
+		if inistruct:match":" then
+			stname,derived = inistruct:match"struct%s*([^%s:]+):(.+)"
+			derived = derived:match"(%S+)$"
+		else
+			stname = inistruct:match"struct%s(%S+)"
+		end
+
+		if derived then print(stname,"derived from",derived) end
+		
 		if not stname then
 			print(stru)
 			error"could not get stname"
 		end
 		--initial
-		table.insert(outtab,stru:match("(.-)%b{}"))
+		--table.insert(outtab,stru:match("(.-)%b{}"))
+		table.insert(outtab,"\nstruct "..stname.."\n")
 		table.insert(outtab,"{")
+		if derived then
+			table.insert(outtab,"\n    "..derived.." _"..derived..";")
+		end
 		local itlist,itemsin = parseItems(iner)
 		if #itlist == 0 then return "" end --here we avoid empty structs
 		for j,it in ipairs(itlist) do
@@ -808,14 +902,18 @@ function M.Parser()
 				--local ttype,template = it.item:match("([^%s,%(%)]+)%s*<(.+)>")
 				local ttype,template =    it.item:match"([^%s,%(%)]+)%s*<(.+)>"
 				if template then
+					--if template=="T" then print("T found in---------");print(stru) end
 					local te = template:gsub("%s","_")
 					te = te:gsub("%*","Ptr")
 					self.templates[ttype] = self.templates[ttype] or {}
 					self.templates[ttype][template] = te
+					it2 = it2:gsub("(<[%w_%*%s]+>)([^%s])","%1 %2") --add if not present space after <>
 					it2 = it2:gsub("<([%w_%*%s]+)>","_"..te)
 				end
 				--clean mutable
 				it2 = it2:gsub("mutable","")
+				--clean namespaces
+				it2 = it2:gsub("%w+::","")
 				--skip static variables
 				if not (it.re_name == "vardef_re" and it2:match"static") then
 					table.insert(outtab,it2)
@@ -846,12 +944,31 @@ function M.Parser()
 				end
 			end
 		end
+		--get structs in namespace
+		for i,it in ipairs(itemsarr) do
+			if it.re_name == "namespace_re" then
+				local nsp = it.item:match("%b{}"):sub(2,-2)
+				local namespace = it.item:match("namespace%s+(%S+)")
+				local nspparr,itemsnsp = parseItems(nsp)
+				for insp,itnsp in ipairs(nspparr) do
+					if itnsp.re_name == "struct_re"  or itnsp.re_name == "typedef_st_re" then
+						--print("in mamespace",itnsp.item,namespace)
+						table.insert(outtab,itnsp.item)
+					end
+				end
+			end
+		end
 		--then structs and enums
 		for i,it in ipairs(itemsarr) do
 			if it.re_name == "enum_re" then
-				table.insert(outtab,it.item)
+				local enumname, enumbody = it.item:match"^%s*enum%s+([^%s;{}]+)[%s\n\r]*(%b{})"
+				--print("enum is:",enumname, enumbody)
+				table.insert(outtab,"\ntypedef enum ".. enumbody..enumname..";")
 			elseif it.re_name == "struct_re" then
 				local cleanst,structname = self:clean_struct(it.item)
+				
+				--if not structname then print("NO NAME",cleanst,it.item) end
+				
 				--if not void stname or templated
 				if structname and not self.typenames[structname] then
 				table.insert(outtab,cleanst)
@@ -906,21 +1023,59 @@ function M.Parser()
 				template_type = template_type:gsub("Ptr","%*")
 			end
 			for name in rest:gmatch("([^%s,;]+)%s?[,;]") do
-				table.insert(outtab,{type=typen,template_type=template_type,name=name})
+				--unnamed unions
+				local union_re = "^([^;{}]-union[^;{}]-%b{}[%s%w_%(%)]*;)"
+				if line:match(union_re) and name == "}" then
+					typen = typen..name
+					name = ""
+				end
+				local namebitfield,bitfield = name:match("([^:]+):(%d+)") --take care of bitfields
+				table.insert(outtab,{type=typen,template_type=template_type,name=namebitfield or name,bitfield=bitfield})
 			end
 		end
 	end
 	function par:gen_structs_and_enums_table()
 		local outtab = {enums={},structs={}}
-		local outtabpre = {}
-		local typedefs_table = {}
+		self.typedefs_table = {}
+		self.vardefs = {}
 
 		self.inerstructs = {}
+		self.order = {}
+		
+		--first typedefs
+		for i,it in ipairs(itemsarr) do
+			if it.re_name == "typedef_re" then --or it.re_name == "functypedef_re" or it.re_name == "vardef_re" then
+				local typedefdef,typedefname = it.item:match"typedef(.+)%s([^%s;]+);$"
+				typedefname = strip(typedefname)
+				self.typedefs_table[typedefname] = strip(typedefdef)
+				self.order[typedefname] = i
+				-- add typedef after struct name
+				-- if it.re_name == "vardef_re" and it.item:match"struct" then
+					-- local stname = it.item:match("struct%s*(%S+)%s*;")
+					-- table.insert(typedefs_table,"typedef struct "..stname.." "..stname..";\n")
+					-- self.typedefs_dict[stname]="struct "..stname
+				-- end
+			end
+		end
+		--vardefs
+		for i,it in ipairs(itemsarr) do
+			if it.re_name == "vardef_re" then 
+				local stname = it.item:match"struct%s(%S+)$"
+				if stname then
+					stname = strip(stname)
+					self.vardefs[stname] = true
+					self.order[stname] = i
+				end
+			end
+		end
 		--then structs and enums
+		local enumsordered = {}
 		for i,it in ipairs(itemsarr) do
 			if it.re_name == "enum_re" then
 				local enumname = it.item:match"^%s*enum%s+([^%s;{}]+)"
 				outtab.enums[enumname] = {}
+				table.insert(enumsordered,enumname)
+				self.order[enumname] = i
 				local inner = strip_end(it.item:match("%b{}"):sub(2,-2))
 				local enumarr = str_split(inner,",")
 				for j,line in ipairs(enumarr) do
@@ -930,15 +1085,27 @@ function M.Parser()
 					else --increment by one
 						local name = line:match("%s*([^,]+)")
 						local enum_table = outtab.enums[enumname]
-						local value = enum_table[#enum_table] and (enum_table[#enum_table].value + 1) or 0
+						local prevvalue = enum_table[#enum_table] and enum_table[#enum_table].value
+						local value --= enum_table[#enum_table] and (enum_table[#enum_table].value + 1) or 0
+						if not prevvalue then
+							value = 0
+						elseif tonumber(prevvalue) then
+							value = prevvalue +1
+						else --should be string
+							value = prevvalue .. "+1"
+						end
+						if name then --avoid last , if present
 						table.insert(outtab.enums[enumname],{name=name,value=value})
 						end
 					end
+				end
 			elseif it.re_name == "struct_re" then
 				local cleanst,structname,strtab = self:clean_struct(it.item)
 				--if not void stname or templated
+				--M.prtable(cleanst,structname,strtab)
 				if structname and not self.typenames[structname] then
 					outtab.structs[structname] = {}
+					self.order[structname]=i
 					for j=3,#strtab-1 do
 						self:parse_struct_line(strtab[j],outtab.structs[structname])
 					end
@@ -968,24 +1135,11 @@ function M.Parser()
 		--calcule size of name[16+1] [xxx_COUNT]
 		local allenums = {}
 		--first calc_value in enums
-		for enumname,enum in pairs(outtab.enums) do
+		for i,enumname in ipairs(enumsordered) do
+		--for enumname,enum in pairs(outtab.enums) do
+			local enum = outtab.enums[enumname]
 			for i,t in ipairs(enum) do
-				local val = tonumber(t.value)
-				if val then
-					t.calc_value = val
-				elseif t.value:match"<<" then
-					local v1,v2 = t.value:match("(%d+)%s*<<%s*(%d+)")
-					t.calc_value = bit.lshift(v1,v2)
-				elseif t.value:match"|" then --or several enums
-					local ens = t.value
-					ens = strsplit(ens,"|")
-					for i,v in ipairs(ens) do ens[i] = allenums[clean_spaces(v)] end
-					t.calc_value = bit.bor(unpack(ens))
-				elseif allenums[t.value] then
-					t.calc_value = allenums[t.value]
-				else
-					print("Error unknown value in enums",t.value)
-				end
+				t.calc_value = parse_enum_value(t,allenums)
 				assert(t.calc_value)
 				allenums[t.name] = t.calc_value
 			end
@@ -999,13 +1153,13 @@ function M.Parser()
 						t.size = tonumber(val)
 					elseif allenums[val] then
 						t.size = allenums[val]
-					elseif val:match"%+" then
-						local s1,s2 = val:match("(%d+)%s*%+%s*(%d+)")
-						t.size = s1+s2
 					else
-						print("Error size is",val)
+						local f,err = loadstring("estevalor="..val)
+						if not f then print("error on loadstring",err,"with val:",val) end
+						f()
+						t.size = estevalor
 					end
-					assert(t.size)
+					assert(t.size,val)
 				end
 			end
 		end
@@ -1041,7 +1195,7 @@ function M.Parser()
                     --take overloaded name from manual table or algorythm
                     t.ov_cimguiname = self.getCname_overload(t.stname,t.funcname,t.signature) or k..typetoStr(post[i])
                     table.insert(strt,string.format("%d\t%s\t%s %s",i,t.ret,t.ov_cimguiname,t.signature))
-                    --prtable(typesc[i])
+                    --M.prtable(typesc[i],post)
                 end
                 --check not two names are equal (produced by bad cimguiname_overload)
                 for i=1,#v-1 do 
@@ -1237,7 +1391,7 @@ M.serializeTableF = function(t)
 	return M.serializeTable("defs",t).."\nreturn defs"
 end
 --iterates lines from a gcc/clang -E in a specific location
-local function location(file,locpathT,defines)
+local function location(file,locpathT,defines,COMPILER)
 	local define_re = "^#define%s+([^%s]+)%s+([^%s]+)$"
 	local number_re = "^-?[0-9]+u*$"
 	local hex_re = "0x[0-9a-fA-F]+u*$"
@@ -1247,6 +1401,7 @@ local function location(file,locpathT,defines)
     else --gcc, clang
         location_re = '^# (%d+) "([^"]*)"'
     end
+
     local path_reT = {}
     for i,locpath in ipairs(locpathT) do
         table.insert(path_reT,'^.*[\\/]('..locpath..')%.h$')
@@ -1272,6 +1427,7 @@ local function location(file,locpathT,defines)
             if #line==0 then --nothing on emptyline
             elseif not line:match("%S") then --nothing if only spaces
             elseif line:sub(1,1) == "#" then
+			--elseif line:match"^%s*#" then
                 -- Is this a location pragma?
                 local loc_num_t,location_match = line:match(location_re)
                 if location_match then
@@ -1317,4 +1473,29 @@ local function location(file,locpathT,defines)
     return location_it
 end
 M.location = location
+
+--[=[
+-- tests
+local line = [[struct ImDrawListSharedData
+{
+    ImVec2 TexUvWhitePixel;
+    ImFont* Font;
+    float FontSize;
+    float CurveTessellationTol;
+    float CircleSegmentMaxError;
+    ImVec4 ClipRectFullscreen;
+    ImDrawListFlags InitialFlags;
+    ImVec2 ArcFastVtx[12 * 1];
+    ImU8 CircleSegmentCounts[64];
+    ImDrawListSharedData();
+    void SetCircleSegmentMaxError(float max_error);
+};]]
+local parser = M.Parser()
+parser:insert(line)
+parser:do_parse()
+--M.prtable(parser)
+M.prtable(parser:gen_structs_and_enums_table())
+--]=]
+--print(clean_spaces[[ImVec2 ArcFastVtx[12 * 1];]])
+
 return M

generator/generator.bat

@@ -10,13 +10,14 @@
 :: impl_definitions.lua for implementation function definitions
 
 :: set your PATH if necessary for LuaJIT or Lua5.1 or luajit with: (for example)
-set PATH=%PATH%;C:\luaGL;C:\mingw32\bin;
+set PATH=%PATH%;C:\anima;C:\mingws\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\mingw32\bin;
 :: set PATH=%PATH%;C:\luaGL;C:\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\mingw32\bin;
 :: set PATH=%PATH%;C:\luaGL\sources\luajit-master\luajit-master\bin\mingw32;C:\mingw32\bin;
 ::process  files
-:: arg[1] compiler name gcc, clang, cl or nocompiler
-:: arg[2..n] name of implementations to generate
-luajit ./generator.lua gcc glfw opengl3 opengl2 sdl
+:: arg[1] compiler name gcc, clang or cl
+:: arg[2] imgui_internal functions generation: true or false
+:: arg[3..n] name of implementations to generate
+luajit ./generator.lua gcc true glfw opengl3 opengl2 sdl
 
 ::leave console open
 cmd /k

generator/generator.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/sh
+
+# this script must be executed in this directory
+# all the output goes to generator/output folder
+# .cpp and .h files:
+# cimgui.h and cimgui.cpp with gcc preprocess
+# cimgui_nopreprocess.h and cimgui_nopreprocess.cpp generated without preprocess
+# cimgui_impl.h with implementation function cdefs
+# lua and json files:
+# definitions.lua for function definitions
+# structs_and_enums.lua with struct and enum information-definitions
+# impl_definitions.lua for implementation function definitions
+
+#process  files
+# arg[1] compiler name gcc, clang, or cl
+# arg[2] imgui_internal functions generation: true or false
+# arg[3..n] name of implementations to generate
+luajit ./generator.lua gcc true glfw opengl3 opengl2 sdl

generator/generator2.bat

@@ -1,23 +0,0 @@
-:: this script must be executed in this directory
-:: all the output goes to generator/output folder
-:: .cpp and .h files:
-:: cimgui.h and cimgui.cpp with gcc preprocess
-:: cimgui_nopreprocess.h and cimgui_nopreprocess.cpp generated without preprocess
-:: cimgui_impl.h with implementation function cdefs
-:: lua and json files:
-:: definitions.lua for function definitions
-:: structs_and_enums.lua with struct and enum information-definitions
-:: impl_definitions.lua for implementation function definitions
-
-:: set your PATH if necessary for LuaJIT or Lua5.1 or luajit with: (for example)
-set PATH=%PATH%;C:\luaGL;C:\mingw32\bin;
-:: set PATH=%PATH%;C:\luaGL;C:\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\mingw32\bin;
-:: set PATH=%PATH%;C:\luaGL\sources\luajit-master\luajit-master\bin\mingw32;C:\mingw32\bin;
-::process  files
-:: arg[1] compiler name gcc, clang, cl or nocompiler
-:: arg[2..n] name of implementations to generate
-luajit ./generator2.lua gcc glfw opengl3 opengl2 sdl
-
-::leave console open
-cmd /k
-

generator/generator2.lua

@@ -1,641 +0,0 @@
---------------------------------------------------------------------------
---script for auto_funcs.h and auto_funcs.cpp generation
---expects LuaJIT
---------------------------------------------------------------------------
-assert(_VERSION=='Lua 5.1',"Must use LuaJIT")
-assert(bit,"Must use LuaJIT")
-local script_args = {...}
-local COMPILER = script_args[1]
-local CPRE,CTEST
-if COMPILER == "gcc" or COMPILER == "clang" then
-    CPRE = COMPILER..[[ -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ]]
-    CTEST = COMPILER.." --version"
-elseif COMPILER == "cl" then
-    CPRE = COMPILER..[[ /E /DIMGUI_DISABLE_OBSOLETE_FUNCTIONS /DIMGUI_API="" /DIMGUI_IMPL_API="" ]]
-    CTEST = COMPILER
-else
-    print("Working without compiler ")
-end
---test compiler present
-local HAVE_COMPILER = false
-if CTEST then
-    local pipe,err = io.popen(CTEST,"r")
-    if pipe then
-        local str = pipe:read"*a"
-        print(str)
-        pipe:close()
-        if str=="" then
-            HAVE_COMPILER = false
-        else
-            HAVE_COMPILER = true
-        end
-    else
-        HAVE_COMPILER = false
-        print(err)
-    end
-    assert(HAVE_COMPILER,"gcc, clang or cl needed to run script")
-end --CTEST
-
-print("HAVE_COMPILER",HAVE_COMPILER)
---get implementations
-local implementations = {}
-for i=2,#script_args do table.insert(implementations,script_args[i]) end
-
---------------------------------------------------------------------------
---this table has the functions to be skipped in generation
---------------------------------------------------------------------------
-local cimgui_manuals = {
-    igLogText = true,
-    ImGuiTextBuffer_appendf = true,
-    igColorConvertRGBtoHSV = true,
-    igColorConvertHSVtoRGB = true
-}
---------------------------------------------------------------------------
---this table is a dictionary to force a naming of function overloading (instead of algorythmic generated)
---first level is cimguiname without postfix, second level is the signature of the function, value is the
---desired name
----------------------------------------------------------------------------
-local cimgui_overloads = {
-    igPushID = {
-        --["(const char*)"] =           "igPushIDStr",
-        ["(const char*,const char*)"] = "igPushIDRange",
-        --["(const void*)"] =           "igPushIDPtr",
-        --["(int)"] =                   "igPushIDInt"
-    },
-    igGetID = {
-        ["(const char*,const char*)"] = "igGetIDRange",
-    },
-    ImDrawList_AddText = {
-        ["(const ImVec2,ImU32,const char*,const char*)"] = "ImDrawList_AddText",
-    },
-    igGetColorU32 = {
-        ["(ImGuiCol,float)"] = "igGetColorU32",
-    },
-    igCollapsingHeader = {
-        ["(const char*,ImGuiTreeNodeFlags)"] =  "igCollapsingHeader",
-    },
-    igCombo = {
-        ["(const char*,int*,const char* const[],int,int)"] = "igCombo",
-    },
-    igPlotLines = {
-        ["(const char*,const float*,int,int,const char*,float,float,ImVec2,int)"] = "igPlotLines",
-    },
-    igBeginChild = {
-        ["(const char*,const ImVec2,bool,ImGuiWindowFlags)"] = "igBeginChild",
-    },
-    igSelectable = {
-        ["(const char*,bool,ImGuiSelectableFlags,const ImVec2)"] = "igSelectable"
-    },
-    igPushStyleColor = {
-        ["(ImGuiCol,const ImVec4)"] = "igPushStyleColor"
-    }
-}
-
---------------------------header definitions
-local cimgui_header = 
-[[//This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
-//based on imgui.h file version XXX from Dear ImGui https://github.com/ocornut/imgui
-]]
-local gdefines = {} --for FLT_MAX and others
---------------------------------------------------------------------------
---helper functions
-
-
----------------------------minimal preprocessor without compiler for ImGui.h
-local function filelines(file,locats)
-    local split_comment = require"cpp2ffi".split_comment
-    local iflevels = {}
-   --generated known prepros
-local prepro = {
-["#if"]={
-    [   "defined(__clang__) || defined(__GNUC__)"       ]=false,
-    [   "defined(__clang__)"    ]=false,
-    [   "defined(_MSC_VER) && !defined(__clang__)"      ]=false,
-    [   "!defined(IMGUI_DISABLE_INCLUDE_IMCONFIG_H) || defined(IMGUI_INCLUDE_IMCONFIG_H)"       ]=false,
-    [   "!defined(IMGUI_IMPL_OPENGL_LOADER_GL3W)     \\"        ]=false,
-},
-["#elif"]={
-    [   "defined(__GNUC__) && __GNUC__ >= 8"    ]=false,
-    [   "(defined(__clang__) || defined(__GNUC__)) && (__cplusplus < 201100)"   ]=false,
-},
-["#ifdef"]={
-    [   "IM_VEC4_CLASS_EXTRA"   ]=false,
-    [   "IMGUI_USER_CONFIG"     ]=false,
-    [   "IMGUI_INCLUDE_IMGUI_USER_H"    ]=false,
-    [   "IMGUI_USE_BGRA_PACKED_COLOR"   ]=false,
-    [   "IM_VEC2_CLASS_EXTRA"   ]=false,
-},
-["#ifndef"]={
-    [   "IMGUI_API"     ]=false,
-    [   "IMGUI_IMPL_API"        ]=false,
-    [   "IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT" ]=true,
-    [   "IM_ASSERT"     ]=false,
-    [   "ImTextureID"   ]=true,
-    [   "ImDrawIdx"     ]=true,
-    [   "IMGUI_DISABLE_OBSOLETE_FUNCTIONS"      ]=false,
-},
-}
-
-    local function prepro_boolif(pre,cond)
-        local conds = prepro[pre]
-        assert(conds,pre.." has no conds-----------------------------")
-        local res = conds[cond]
-        --assert(type(res)~="nil",cond.." not found")
-        if type(res)=="nil" then
-            print(pre,cond,"not found in precompiler database, returning false.")
-            res = false
-        end
-        return res
-    end
-    local function location_it()
-        repeat
-            local line = file:read"*l"
-
-            if not line then return nil end
-            line,_ = split_comment(line)
-            --if line:sub(1,1) == "#" then
-            if line:match("^%s*#") then
-                
-                local pre,cond = line:match("^%s*(#%S*)%s+(.*)%s*$")
-                if line:match("#if") then 
-                    iflevels[#iflevels +1 ] = prepro_boolif(pre,cond)
-                elseif line:match("#endif") then
-                    iflevels[#iflevels] = nil
-                elseif line:match("#elif") then
-                    if not iflevels[#iflevels] then
-                        iflevels[#iflevels] = prepro_boolif(pre,cond)
-                    else --was true
-                        iflevels[#iflevels] = false
-                    end
-                elseif line:match("#else") then
-                    iflevels[#iflevels] = not iflevels[#iflevels]
-                else
-                    if not (pre:match("#define") or pre:match"#include" or pre:match"#pragma") then
-                        print("not expected preprocessor directive ",pre)
-                    end
-                end
-                -- skip
-            elseif #iflevels == 0 or iflevels[#iflevels] then
-                -- drop IMGUI_APIX
-                line = line:gsub("IMGUI_IMPL_API","")
-                -- drop IMGUI_API
-                line = line:gsub("IMGUI_API","")
-                return line,locats[1]
-            end
-        until false
-    end
-    return location_it
-end
-
-
---------------------------------functions for C generation
-local function func_header_impl_generate(FP)
-
-    local outtab = {}
-    
-    for _,t in ipairs(FP.funcdefs) do
-        if t.cimguiname then
-            local cimf = FP.defsT[t.cimguiname]
-            local def = cimf[t.signature]
-            if def.ret then --not constructor
-                local addcoment = def.comment or ""
-                if def.stname == "" then --ImGui namespace or top level
-                    table.insert(outtab,"CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
-                else
-                    error("class function in implementations")
-                end
-            end
-        else --not cimguiname
-            table.insert(outtab,t.comment:gsub("%%","%%%%").."\n")-- %% substitution for gsub
-        end
-    end
-    local cfuncsstr = table.concat(outtab)
-    cfuncsstr = cfuncsstr:gsub("\n+","\n") --several empty lines to one empty line
-    return cfuncsstr
-end
-local function func_header_generate(FP)
-
-    local outtab = {}
-    table.insert(outtab,"#ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n")
-    for k,v in pairs(FP.embeded_structs) do
-        table.insert(outtab,"typedef "..v.." "..k..";\n")
-    end
-    for ttype,v in pairs(FP.templates) do
-		for ttypein,_ in pairs(v) do
-			local te = ttypein:gsub("%s","_")
-			te = te:gsub("%*","Ptr")
-        table.insert(outtab,"typedef "..ttype.."<"..ttypein.."> "..ttype.."_"..te..";\n")
-		end
-    end
-
-    table.insert(outtab,"#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n")
-    for _,t in ipairs(FP.funcdefs) do
-
-        if t.cimguiname then
-        local cimf = FP.defsT[t.cimguiname]
-        local def = cimf[t.signature]
-        assert(def,t.signature..t.cimguiname)
-        local manual = FP.get_manuals(def)
-        if not manual and not def.templated then
-
-            local addcoment = def.comment or ""
-            local empty = def.args:match("^%(%)") --no args
-            if def.constructor then
-                assert(def.stname ~= "","constructor without struct")
-                table.insert(outtab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname ..(empty and "(void)" or def.args)..";"..addcoment.."\n")
-            elseif def.destructor then
-                table.insert(outtab,"CIMGUI_API void "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
-            else --not constructor
-
-                if def.stname == "" then --ImGui namespace or top level
-                    table.insert(outtab,"CIMGUI_API "..def.ret.." ".. def.ov_cimguiname ..(empty and "(void)" or def.args)..";"..addcoment.."\n")
-                else
-                    table.insert(outtab,"CIMGUI_API "..def.ret.." "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
-                end
-            end 
-        end
-        else --not cimguiname
-            table.insert(outtab,t.comment:gsub("%%","%%%%").."\n")-- %% substitution for gsub
-        end
-    end
-
-    local cfuncsstr = table.concat(outtab)
-    cfuncsstr = cfuncsstr:gsub("\n+","\n") --several empty lines to one empty line
-    return cfuncsstr
-end
-
-
-local function ImGui_f_implementation(outtab,def)
-    local ptret = def.retref and "&" or ""
-    table.insert(outtab,"CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname..def.args.."\n")
-    table.insert(outtab,"{\n")
-    if def.isvararg then
-        local call_args = def.call_args:gsub("%.%.%.","args")
-        table.insert(outtab,"    va_list args;\n")
-        table.insert(outtab,"    va_start(args, fmt);\n")
-        if def.ret~="void" then
-            table.insert(outtab,"    "..def.ret.." ret = ImGui::"..def.funcname.."V"..call_args..";\n")
-        else
-            table.insert(outtab,"    ImGui::"..def.funcname.."V"..call_args..";\n")
-        end
-        table.insert(outtab,"    va_end(args);\n")
-        if def.ret~="void" then
-            table.insert(outtab,"    return ret;\n")
-        end
-    elseif def.nonUDT then
-        if def.nonUDT == 1 then
-            table.insert(outtab,"    *pOut = ImGui::"..def.funcname..def.call_args..";\n")
-        else --nonUDT==2
-            table.insert(outtab,"    "..def.retorig.." ret = ImGui::"..def.funcname..def.call_args..";\n")
-            table.insert(outtab,"    "..def.ret.." ret2 = "..def.retorig.."ToSimple(ret);\n")
-            table.insert(outtab,"    return ret2;\n")
-        end
-    else --standard ImGui
-        table.insert(outtab,"    return "..ptret.."ImGui::"..def.funcname..def.call_args..";\n")
-    end
-    table.insert(outtab,"}\n")
-end
-local function struct_f_implementation(outtab,def)
-    local empty = def.args:match("^%(%)") --no args
-    local ptret = def.retref and "&" or ""
-
-    local imgui_stname = def.stname
-
-    table.insert(outtab,"CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname..def.args.."\n")
-    table.insert(outtab,"{\n")
-    if def.isvararg then
-        local call_args = def.call_args:gsub("%.%.%.","args")
-        table.insert(outtab,"    va_list args;\n")
-        table.insert(outtab,"    va_start(args, fmt);\n")
-        if def.ret~="void" then
-            table.insert(outtab,"    "..def.ret.." ret = self->"..def.funcname.."V"..call_args..";\n")
-        else
-            table.insert(outtab,"    self->"..def.funcname.."V"..call_args..";\n")
-        end
-        table.insert(outtab,"    va_end(args);\n")
-        if def.ret~="void" then
-            table.insert(outtab,"    return ret;\n")
-        end
-    elseif def.nonUDT then
-        if def.nonUDT == 1 then
-            table.insert(outtab,"    *pOut = self->"..def.funcname..def.call_args..";\n")
-        else --nonUDT==2
-            table.insert(outtab,"    "..def.retorig.." ret = self->"..def.funcname..def.call_args..";\n")
-            table.insert(outtab,"    "..def.ret.." ret2 = "..def.retorig.."ToSimple(ret);\n")
-            table.insert(outtab,"    return ret2;\n")
-        end
-    else --standard struct
-        table.insert(outtab,"    return "..ptret.."self->"..def.funcname..def.call_args..";\n")
-    end
-    table.insert(outtab,"}\n")
-end
-local function func_implementation(FP)
-
-    local outtab = {}
-    for _,t in ipairs(FP.funcdefs) do
-        repeat -- continue simulation
-        if not t.cimguiname then break end
-        local cimf = FP.defsT[t.cimguiname]
-        local def = cimf[t.signature]
-        assert(def)
-        local manual = FP.get_manuals(def)
-        if not manual and not def.templated then 
-            if def.constructor then
-                assert(def.stname ~= "","constructor without struct")
-                local empty = def.args:match("^%(%)") --no args
-                table.insert(outtab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname..(empty and "(void)" or def.args).."\n")
-                table.insert(outtab,"{\n")
-                table.insert(outtab,"    return IM_NEW("..def.stname..")"..def.call_args..";\n")
-                table.insert(outtab,"}\n")
-            elseif def.destructor then
-                local args = "("..def.stname.."* self)"
-                local fname = def.stname.."_destroy" 
-                table.insert(outtab,"CIMGUI_API void "..fname..args.."\n")
-                table.insert(outtab,"{\n")
-                table.insert(outtab,"    IM_DELETE(self);\n")
-                table.insert(outtab,"}\n")
-            elseif def.stname == "" then
-                ImGui_f_implementation(outtab,def)
-            else -- stname
-                struct_f_implementation(outtab,def)
-            end
-        end
-        until true
-    end
-    return table.concat(outtab)
-end
--------------------functions for getting and setting defines
-local function get_defines(t)
-    if COMPILER == "cl" then print"can't get defines with cl compiler"; return {} end
-    local pipe,err = io.popen(COMPILER..[[ -E -dM -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ../imgui/imgui.h]],"r")
-    local defines = {}
-    while true do
-        local line = pipe:read"*l"
-        if not line then break end
-        local key,value = line:match([[#define%s+(%S+)%s+(.+)]])
-        if not key or not value then 
-            --print(line)
-        else
-            defines[key]=value
-        end
-    end
-    pipe:close()
-    --require"anima.utils"
-    --prtable(defines)
-    --FLT_MAX
-    local ret = {}
-    for i,v in ipairs(t) do
-        local aa = defines[v]
-        while true do
-            local tmp = defines[aa]
-            if not tmp then 
-                break
-            else
-                aa = tmp
-            end
-        end
-        ret[v] = aa
-    end
-    return ret
-end
-  --subtitution of FLT_MAX value for FLT_MAX 
-local function set_defines(fdefs)
-    for k,defT in pairs(fdefs) do
-        for i,def in ipairs(defT) do
-            for name,default in pairs(def.defaults) do
-                if default == gdefines.FLT_MAX then
-                    def.defaults[name] = "FLT_MAX"
-                end
-            end
-        end
-    end
-end 
---this creates defsBystruct in case you need to list by struct container
-local function DefsByStruct(FP)
-    local structs = {}
-    for fun,defs in pairs(FP.defsT) do
-        local stname = defs[1].stname
-        structs[stname] = structs[stname] or {}
-        table.insert(structs[stname],defs)--fun)
-    end
-    FP.defsBystruct = structs
-end  
-
-
---load parser module
-local cpp2ffi = require"cpp2ffi"
-local read_data = cpp2ffi.read_data
-local save_data = cpp2ffi.save_data
-local copyfile = cpp2ffi.copyfile
-local serializeTableF = cpp2ffi.serializeTableF
-
-----------custom ImVector templates
-local function generate_templates(code,templates)
-    table.insert(code,[[typedef struct ImVector{int Size;int Capacity;void* Data;} ImVector;]].."\n")
-    for ttype,v in pairs(templates) do
-        --local te = k:gsub("%s","_")
-        --te = te:gsub("%*","Ptr")
-		if ttype == "ImVector" then
-		for te,newte in pairs(v) do
-        table.insert(code,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
-		end
-		end
-    end
-end
---generate cimgui.cpp cimgui.h 
-local function cimgui_generation(parser)
-	cpp2ffi.prtable(parser.templates)
-	cpp2ffi.prtable(parser.typenames)
-	-- clean ImVector:contains() for not applicable types
-	local clean_f = {}
-	for k,v in pairs(parser.defsT) do
-		if k:match"ImVector" and k:match"contains" then
-			--cpp2ffi.prtable(k,v)
-			local stname = v[1].stname
-			if not(stname:match"float" or stname:match"int" or stname:match"char") then
-				parser.defsT[k] = nil
-				--delete also from funcdefs
-				for i,t in ipairs(parser.funcdefs) do
-					if t.cimguiname == k then
-						table.remove(parser.funcdefs, i)
-						break
-					end
-				end
-			end
-		end
-	end
-	
-	--------------------------------------------------
-    local hstrfile = read_data"./cimgui_template.h"
-
-	local outpre,outpost = parser:gen_structs_and_enums()
-	--parser.templates get completely defined here
-	--cpp2ffi.prtable(parser.templates)
-	
-	local outtab = {}
-    generate_templates(outtab,parser.templates)
-	local cstructsstr = outpre..table.concat(outtab,"")..outpost
-
-    hstrfile = hstrfile:gsub([[#include "imgui_structs%.h"]],cstructsstr)
-    local cfuncsstr = func_header_generate(parser)
-    hstrfile = hstrfile:gsub([[#include "auto_funcs%.h"]],cfuncsstr)
-    save_data("./output/cimgui.h",cimgui_header,hstrfile)
-    
-    --merge it in cimgui_template.cpp to cimgui.cpp
-    local cimplem = func_implementation(parser)
-
-    local hstrfile = read_data"./cimgui_template.cpp"
-
-    hstrfile = hstrfile:gsub([[#include "auto_funcs%.cpp"]],cimplem)
-    save_data("./output/cimgui.cpp",cimgui_header,hstrfile)
-
-end
---------------------------------------------------------
------------------------------do it----------------------
---------------------------------------------------------
---get imgui.h version--------------------------
-local pipe,err = io.open("../imgui/imgui.h","r")
-if not pipe then
-    error("could not open file:"..err)
-end
-local imgui_version
-while true do
-    local line = pipe:read"*l"
-    imgui_version = line:match([[#define%s+IMGUI_VERSION%s+(".+")]])
-    if imgui_version then break end
-end
-pipe:close()
-cimgui_header = cimgui_header:gsub("XXX",imgui_version)
-print("IMGUI_VERSION",imgui_version)
---get some defines----------------------------
-if HAVE_COMPILER then
-    gdefines = get_defines{"IMGUI_VERSION","FLT_MAX"}
-end                                 
-
---generation
-print("------------------generation with "..COMPILER.."------------------------")
-local typedefs_dict2
---prepare parser
-local parser1 = cpp2ffi.Parser()
-parser1.getCname = function(stname,funcname)
-    local pre = (stname == "") and "ig" or stname.."_"
-    return pre..funcname
-end
-parser1.cname_overloads = cimgui_overloads
-parser1.manuals = cimgui_manuals
-parser1.UDTs = {"ImVec2","ImVec4","ImColor"}
-
-local pipe,err
-if HAVE_COMPILER then
-    pipe,err = io.popen(CPRE..[[../imgui/imgui.h]],"r")
-else
-    pipe,err = io.open([[../imgui/imgui.h]],"r")
-end
-
-if not pipe then
-    error("could not execute gcc "..err)
-end
-
-local iterator = (HAVE_COMPILER and cpp2ffi.location) or filelines
-
-for line in iterator(pipe,{"imgui"},{}) do
-	parser1:insert(line)
-end
-pipe:close()
-
-parser1:do_parse()
---table.sort(parser1.funcdefs, function(a,b) return a.cimguiname < b.cimguiname end)
---parser1:dump_alltypes()
---parser1:printItems()
-
-save_data("./output/overloads.txt",parser1.overloadstxt)
-cimgui_generation(parser1)
-
-----------save fundefs in definitions.lua for using in bindings
---DefsByStruct(pFP)
-set_defines(parser1.defsT) 
-save_data("./output/definitions.lua",serializeTableF(parser1.defsT))
-
-----------save struct and enums lua table in structs_and_enums.lua for using in bindings
-local structs_and_enums_table = parser1:gen_structs_and_enums_table()
---correct Pair union member
-structs_and_enums_table["structs"]["Pair"][2]["name"] = ""
-structs_and_enums_table["structs"]["Pair"][2]["type"] = structs_and_enums_table["structs"]["Pair"][2]["type"] .. "}"
------------------------
-save_data("./output/structs_and_enums.lua",serializeTableF(structs_and_enums_table))
-save_data("./output/typedefs_dict.lua",serializeTableF(parser1.typedefs_dict))
-
---check every function has ov_cimguiname
--- for k,v in pairs(parser1.defsT) do
-	-- for _,def in ipairs(v) do
-		-- assert(def.ov_cimguiname)
-	-- end
--- end
---=================================Now implementations
-
-local parser2
-
-if #implementations > 0 then
-
-    parser2 = cpp2ffi.Parser()
-
-    
-    for i,impl in ipairs(implementations) do
-        local source = [[../imgui/examples/imgui_impl_]].. impl .. ".h "
-        local locati = [[imgui_impl_]].. impl
-        local pipe,err
-        if HAVE_COMPILER then
-            pipe,err = io.popen(CPRE..source,"r")
-        else
-            pipe,err = io.open(source,"r")
-        end
-        if not pipe then
-            error("could not get file: "..err)
-        end
-        
-        local iterator = (HAVE_COMPILER and cpp2ffi.location) or filelines
-        
-        for line,locat in iterator(pipe,{locati},{}) do
-            --local line, comment = split_comment(line)
-			parser2:insert(line)
-        end
-        pipe:close()
-    end
-    parser2:do_parse()
-
-    -- save ./cimgui_impl.h
-    local cfuncsstr = func_header_impl_generate(parser2) 
-    local cstructstr1,cstructstr2 = parser2:gen_structs_and_enums()
-    save_data("./output/cimgui_impl.h",cstructstr1,cstructstr2,cfuncsstr)
-
-    ----------save fundefs in impl_definitions.lua for using in bindings
-    save_data("./output/impl_definitions.lua",serializeTableF(parser2.defsT))
-
-end -- #implementations > 0 then
-
--------------------------------json saving
---avoid mixed tables (with string and integer keys)
-local function json_prepare(defs)
-    --delete signatures in function
-    for k,def in pairs(defs) do
-        for k2,v in pairs(def) do
-            if type(k2)=="string" then
-                def[k2] = nil
-            end
-        end
-    end
-    return defs
-end
----[[
-local json = require"json"
-save_data("./output/definitions.json",json.encode(json_prepare(parser1.defsT)))
-save_data("./output/structs_and_enums.json",json.encode(structs_and_enums_table))
-save_data("./output/typedefs_dict.json",json.encode(parser1.typedefs_dict))
-if parser2 then
-    save_data("./output/impl_definitions.json",json.encode(json_prepare(parser2.defsT)))
-end
---]]
--------------------copy C files to repo root
-copyfile("./output/cimgui.h", "../cimgui.h")
-copyfile("./output/cimgui.cpp", "../cimgui.cpp")
-print"all done!!"

generator/output/cimgui_impl.h

@@ -30,6 +30,8 @@ CIMGUI_API bool ImGui_ImplOpenGL2_CreateDeviceObjects();
 CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects();
 CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
 CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
 CIMGUI_API void ImGui_ImplSDL2_Shutdown();
 CIMGUI_API void ImGui_ImplSDL2_NewFrame(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);

generator/output/impl_definitions.json

@@ -391,11 +391,11 @@
           "type": "const char*"
         }
       ],
-      "argsoriginal": "(const char* glsl_version=NULL)",
+      "argsoriginal": "(const char* glsl_version=((void*)0))",
       "call_args": "(glsl_version)",
       "cimguiname": "ImGui_ImplOpenGL3_Init",
       "defaults": {
-        "glsl_version": "NULL"
+        "glsl_version": "((void*)0)"
       },
       "funcname": "ImGui_ImplOpenGL3_Init",
       "ov_cimguiname": "ImGui_ImplOpenGL3_Init",
@@ -454,6 +454,46 @@
       "stname": ""
     }
   ],
+  "ImGui_ImplSDL2_InitForD3D": [
+    {
+      "args": "(SDL_Window* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplSDL2_InitForD3D",
+      "defaults": [],
+      "funcname": "ImGui_ImplSDL2_InitForD3D",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForD3D",
+      "ret": "bool",
+      "signature": "(SDL_Window*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_InitForMetal": [
+    {
+      "args": "(SDL_Window* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplSDL2_InitForMetal",
+      "defaults": [],
+      "funcname": "ImGui_ImplSDL2_InitForMetal",
+      "ov_cimguiname": "ImGui_ImplSDL2_InitForMetal",
+      "ret": "bool",
+      "signature": "(SDL_Window*)",
+      "stname": ""
+    }
+  ],
   "ImGui_ImplSDL2_InitForOpenGL": [
     {
       "args": "(SDL_Window* window,void* sdl_gl_context)",

generator/output/impl_definitions.lua

@@ -343,11 +343,11 @@ defs["ImGui_ImplOpenGL3_Init"][1]["argsT"] = {}
 defs["ImGui_ImplOpenGL3_Init"][1]["argsT"][1] = {}
 defs["ImGui_ImplOpenGL3_Init"][1]["argsT"][1]["name"] = "glsl_version"
 defs["ImGui_ImplOpenGL3_Init"][1]["argsT"][1]["type"] = "const char*"
-defs["ImGui_ImplOpenGL3_Init"][1]["argsoriginal"] = "(const char* glsl_version=NULL)"
+defs["ImGui_ImplOpenGL3_Init"][1]["argsoriginal"] = "(const char* glsl_version=((void*)0))"
 defs["ImGui_ImplOpenGL3_Init"][1]["call_args"] = "(glsl_version)"
 defs["ImGui_ImplOpenGL3_Init"][1]["cimguiname"] = "ImGui_ImplOpenGL3_Init"
 defs["ImGui_ImplOpenGL3_Init"][1]["defaults"] = {}
-defs["ImGui_ImplOpenGL3_Init"][1]["defaults"]["glsl_version"] = "NULL"
+defs["ImGui_ImplOpenGL3_Init"][1]["defaults"]["glsl_version"] = "((void*)0)"
 defs["ImGui_ImplOpenGL3_Init"][1]["funcname"] = "ImGui_ImplOpenGL3_Init"
 defs["ImGui_ImplOpenGL3_Init"][1]["ov_cimguiname"] = "ImGui_ImplOpenGL3_Init"
 defs["ImGui_ImplOpenGL3_Init"][1]["ret"] = "bool"
@@ -399,6 +399,40 @@ defs["ImGui_ImplOpenGL3_Shutdown"][1]["ret"] = "void"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["signature"] = "()"
 defs["ImGui_ImplOpenGL3_Shutdown"][1]["stname"] = ""
 defs["ImGui_ImplOpenGL3_Shutdown"]["()"] = defs["ImGui_ImplOpenGL3_Shutdown"][1]
+defs["ImGui_ImplSDL2_InitForD3D"] = {}
+defs["ImGui_ImplSDL2_InitForD3D"][1] = {}
+defs["ImGui_ImplSDL2_InitForD3D"][1]["args"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsT"][1] = {}
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsT"][1]["type"] = "SDL_Window*"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["argsoriginal"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["call_args"] = "(window)"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForD3D"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["defaults"] = {}
+defs["ImGui_ImplSDL2_InitForD3D"][1]["funcname"] = "ImGui_ImplSDL2_InitForD3D"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForD3D"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["ret"] = "bool"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["signature"] = "(SDL_Window*)"
+defs["ImGui_ImplSDL2_InitForD3D"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_InitForD3D"]["(SDL_Window*)"] = defs["ImGui_ImplSDL2_InitForD3D"][1]
+defs["ImGui_ImplSDL2_InitForMetal"] = {}
+defs["ImGui_ImplSDL2_InitForMetal"][1] = {}
+defs["ImGui_ImplSDL2_InitForMetal"][1]["args"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["argsT"] = {}
+defs["ImGui_ImplSDL2_InitForMetal"][1]["argsT"][1] = {}
+defs["ImGui_ImplSDL2_InitForMetal"][1]["argsT"][1]["name"] = "window"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["argsT"][1]["type"] = "SDL_Window*"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["argsoriginal"] = "(SDL_Window* window)"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["call_args"] = "(window)"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["cimguiname"] = "ImGui_ImplSDL2_InitForMetal"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["defaults"] = {}
+defs["ImGui_ImplSDL2_InitForMetal"][1]["funcname"] = "ImGui_ImplSDL2_InitForMetal"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["ov_cimguiname"] = "ImGui_ImplSDL2_InitForMetal"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["ret"] = "bool"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["signature"] = "(SDL_Window*)"
+defs["ImGui_ImplSDL2_InitForMetal"][1]["stname"] = ""
+defs["ImGui_ImplSDL2_InitForMetal"]["(SDL_Window*)"] = defs["ImGui_ImplSDL2_InitForMetal"][1]
 defs["ImGui_ImplSDL2_InitForOpenGL"] = {}
 defs["ImGui_ImplSDL2_InitForOpenGL"][1] = {}
 defs["ImGui_ImplSDL2_InitForOpenGL"][1]["args"] = "(SDL_Window* window,void* sdl_gl_context)"

generator/output/overloads.txt

@@ -1,132 +1,214 @@
 ----------------overloadings---------------------------
-igCombo	3
-1	bool	igCombo (const char*,int*,const char* const[],int,int)
-2	bool	igComboStr (const char*,int*,const char*,int)
-3	bool	igComboFnPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
-TextRange_TextRange	2
-1	nil	TextRange_TextRange ()
-2	nil	TextRange_TextRangeStr (const char*,const char*)
+ImVector_resize	2
+1	void	ImVector_resizeNil (int)
+2	void	ImVector_resizeT (int,const T)
+igSetScrollFromPosY	2
+1	void	igSetScrollFromPosYFloat (float,float)
+2	void	igSetScrollFromPosYWindowPtr (ImGuiWindow*,float,float)
 ImVec4_ImVec4	2
-1	nil	ImVec4_ImVec4 ()
+1	nil	ImVec4_ImVec4Nil ()
 2	nil	ImVec4_ImVec4Float (float,float,float,float)
-igSetWindowFocus	2
-1	void	igSetWindowFocus ()
-2	void	igSetWindowFocusStr (const char*)
 igValue	4
 1	void	igValueBool (const char*,bool)
 2	void	igValueInt (const char*,int)
 3	void	igValueUint (const char*,unsigned int)
 4	void	igValueFloat (const char*,float,const char*)
-igPushStyleVar	2
-1	void	igPushStyleVarFloat (ImGuiStyleVar,float)
-2	void	igPushStyleVarVec2 (ImGuiStyleVar,const ImVec2)
-ImVector_end	2
-1	T*	ImVector_end ()
-2	const T*	ImVector_end_const ()const
 igIsRectVisible	2
-1	bool	igIsRectVisible (const ImVec2)
+1	bool	igIsRectVisibleNil (const ImVec2)
 2	bool	igIsRectVisibleVec2 (const ImVec2,const ImVec2)
 igRadioButton	2
 1	bool	igRadioButtonBool (const char*,bool)
 2	bool	igRadioButtonIntPtr (const char*,int*,int)
-igSetWindowSize	2
-1	void	igSetWindowSizeVec2 (const ImVec2,ImGuiCond)
-2	void	igSetWindowSizeStr (const char*,const ImVec2,ImGuiCond)
-ImVector_ImVector	2
-1	nil	ImVector_ImVector ()
-2	nil	ImVector_ImVectorVector (const ImVector)
-igSetWindowCollapsed	2
-1	void	igSetWindowCollapsedBool (bool,ImGuiCond)
-2	void	igSetWindowCollapsedStr (const char*,bool,ImGuiCond)
-igPlotLines	2
-1	void	igPlotLines (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
-2	void	igPlotLinesFnPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
+ImGuiTextRange_ImGuiTextRange	2
+1	nil	ImGuiTextRange_ImGuiTextRangeNil ()
+2	nil	ImGuiTextRange_ImGuiTextRangeStr (const char*,const char*)
 ImVec2_ImVec2	2
-1	nil	ImVec2_ImVec2 ()
+1	nil	ImVec2_ImVec2Nil ()
 2	nil	ImVec2_ImVec2Float (float,float)
 ImVector_back	2
-1	T*	ImVector_back ()
+1	T*	ImVector_backNil ()
 2	const T*	ImVector_back_const ()const
 igPlotHistogram	2
 1	void	igPlotHistogramFloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
 2	void	igPlotHistogramFnPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
+igGetID	3
+1	ImGuiID	igGetIDStr (const char*)
+2	ImGuiID	igGetIDStrStr (const char*,const char*)
+3	ImGuiID	igGetIDPtr (const void*)
+ImVec1_ImVec1	2
+1	nil	ImVec1_ImVec1Nil ()
+2	nil	ImVec1_ImVec1Float (float)
+igImPow	2
+1	float	igImPowFloat (float,float)
+2	double	igImPowdouble (double,double)
+igSetWindowPos	3
+1	void	igSetWindowPosVec2 (const ImVec2,ImGuiCond)
+2	void	igSetWindowPosStr (const char*,const ImVec2,ImGuiCond)
+3	void	igSetWindowPosWindowPtr (ImGuiWindow*,const ImVec2,ImGuiCond)
+igBeginChild	2
+1	bool	igBeginChildStr (const char*,const ImVec2,bool,ImGuiWindowFlags)
+2	bool	igBeginChildID (ImGuiID,const ImVec2,bool,ImGuiWindowFlags)
+igPushID	4
+1	void	igPushIDStr (const char*)
+2	void	igPushIDStrStr (const char*,const char*)
+3	void	igPushIDPtr (const void*)
+4	void	igPushIDInt (int)
+ImRect_Contains	2
+1	bool	ImRect_ContainsVec2 (const ImVec2)const
+2	bool	ImRect_ContainsRect (const ImRect)const
+ImRect_Add	2
+1	void	ImRect_AddVec2 (const ImVec2)
+2	void	ImRect_AddRect (const ImRect)
+ImGuiStoragePair_ImGuiStoragePair	3
+1	nil	ImGuiStoragePair_ImGuiStoragePairInt (ImGuiID,int)
+2	nil	ImGuiStoragePair_ImGuiStoragePairFloat (ImGuiID,float)
+3	nil	ImGuiStoragePair_ImGuiStoragePairPtr (ImGuiID,void*)
+igSetScrollFromPosX	2
+1	void	igSetScrollFromPosXFloat (float,float)
+2	void	igSetScrollFromPosXWindowPtr (ImGuiWindow*,float,float)
+igGetForegroundDrawList	2
+1	ImDrawList*	igGetForegroundDrawListNil ()
+2	ImDrawList*	igGetForegroundDrawListWindowPtr (ImGuiWindow*)
+igTreeNodeEx	3
+1	bool	igTreeNodeExStr (const char*,ImGuiTreeNodeFlags)
+2	bool	igTreeNodeExStrStr (const char*,ImGuiTreeNodeFlags,const char*,...)
+3	bool	igTreeNodeExPtr (const void*,ImGuiTreeNodeFlags,const char*,...)
+igImLengthSqr	2
+1	float	igImLengthSqrVec2 (const ImVec2)
+2	float	igImLengthSqrVec4 (const ImVec4)
+igImFloor	2
+1	float	igImFloorFloat (float)
+2	ImVec2	igImFloorVec2 (const ImVec2)
+igTreeNode	3
+1	bool	igTreeNodeStr (const char*)
+2	bool	igTreeNodeStrStr (const char*,const char*,...)
+3	bool	igTreeNodePtr (const void*,const char*,...)
+igItemSize	2
+1	void	igItemSizeVec2 (const ImVec2,float)
+2	void	igItemSizeRect (const ImRect,float)
+igCombo	3
+1	bool	igComboStr_arr (const char*,int*,const char* const[],int,int)
+2	bool	igComboStr (const char*,int*,const char*,int)
+3	bool	igComboFnPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
+igSetScrollY	2
+1	void	igSetScrollYFloat (float)
+2	void	igSetScrollYWindowPtr (ImGuiWindow*,float)
+ImVector_erase	2
+1	T*	ImVector_eraseNil (const T*)
+2	T*	ImVector_eraseTPtr (const T*,const T*)
+ImDrawList_AddText	2
+1	void	ImDrawList_AddTextVec2 (const ImVec2,ImU32,const char*,const char*)
+2	void	ImDrawList_AddTextFontPtr (const ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)
+igPushStyleVar	2
+1	void	igPushStyleVarFloat (ImGuiStyleVar,float)
+2	void	igPushStyleVarVec2 (ImGuiStyleVar,const ImVec2)
+igSetWindowFocus	2
+1	void	igSetWindowFocusNil ()
+2	void	igSetWindowFocusStr (const char*)
+igImLerp	3
+1	ImVec2	igImLerpVec2Float (const ImVec2,const ImVec2,float)
+2	ImVec2	igImLerpVec2Vec2 (const ImVec2,const ImVec2,const ImVec2)
+3	ImVec4	igImLerpVec4 (const ImVec4,const ImVec4,float)
+ImVector_end	2
+1	T*	ImVector_endNil ()
+2	const T*	ImVector_end_const ()const
+igMarkIniSettingsDirty	2
+1	void	igMarkIniSettingsDirtyNil ()
+2	void	igMarkIniSettingsDirtyWindowPtr (ImGuiWindow*)
+igSetWindowSize	3
+1	void	igSetWindowSizeVec2 (const ImVec2,ImGuiCond)
+2	void	igSetWindowSizeStr (const char*,const ImVec2,ImGuiCond)
+3	void	igSetWindowSizeWindowPtr (ImGuiWindow*,const ImVec2,ImGuiCond)
+igIsPopupOpen	2
+1	bool	igIsPopupOpenStr (const char*)
+2	bool	igIsPopupOpenID (ImGuiID)
+ImVector_ImVector	2
+1	nil	ImVector_ImVectorNil ()
+2	nil	ImVector_ImVectorVector (const ImVector)
+igSetWindowCollapsed	3
+1	void	igSetWindowCollapsedBool (bool,ImGuiCond)
+2	void	igSetWindowCollapsedStr (const char*,bool,ImGuiCond)
+3	void	igSetWindowCollapsedWindowPtr (ImGuiWindow*,bool,ImGuiCond)
+igPlotLines	2
+1	void	igPlotLinesFloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
+2	void	igPlotLinesFnPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
+igPushStyleColor	2
+1	void	igPushStyleColorU32 (ImGuiCol,ImU32)
+2	void	igPushStyleColorVec4 (ImGuiCol,const ImVec4)
+ImGuiWindow_GetIDNoKeepAlive	3
+1	ImGuiID	ImGuiWindow_GetIDNoKeepAliveStr (const char*,const char*)
+2	ImGuiID	ImGuiWindow_GetIDNoKeepAlivePtr (const void*)
+3	ImGuiID	ImGuiWindow_GetIDNoKeepAliveInt (int)
+ImGuiWindow_GetID	3
+1	ImGuiID	ImGuiWindow_GetIDStr (const char*,const char*)
+2	ImGuiID	ImGuiWindow_GetIDPtr (const void*)
+3	ImGuiID	ImGuiWindow_GetIDInt (int)
 igTreeNodeExV	2
 1	bool	igTreeNodeExVStr (const char*,ImGuiTreeNodeFlags,const char*,va_list)
 2	bool	igTreeNodeExVPtr (const void*,ImGuiTreeNodeFlags,const char*,va_list)
-igGetID	3
-1	ImGuiID	igGetIDStr (const char*)
-2	ImGuiID	igGetIDRange (const char*,const char*)
-3	ImGuiID	igGetIDPtr (const void*)
-ImDrawList_AddText	2
-1	void	ImDrawList_AddText (const ImVec2,ImU32,const char*,const char*)
-2	void	ImDrawList_AddTextFontPtr (const ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)
-ImVector_begin	2
-1	T*	ImVector_begin ()
-2	const T*	ImVector_begin_const ()const
-igBeginChild	2
-1	bool	igBeginChild (const char*,const ImVec2,bool,ImGuiWindowFlags)
-2	bool	igBeginChildID (ImGuiID,const ImVec2,bool,ImGuiWindowFlags)
-igPushStyleColor	2
-1	void	igPushStyleColorU32 (ImGuiCol,ImU32)
-2	void	igPushStyleColor (ImGuiCol,const ImVec4)
-igSelectable	2
-1	bool	igSelectable (const char*,bool,ImGuiSelectableFlags,const ImVec2)
-2	bool	igSelectableBoolPtr (const char*,bool*,ImGuiSelectableFlags,const ImVec2)
+ImVec2ih_ImVec2ih	3
+1	nil	ImVec2ih_ImVec2ihNil ()
+2	nil	ImVec2ih_ImVec2ihshort (short,short)
+3	explicit	ImVec2ih_ImVec2ihVec2 (const ImVec2)
+ImGuiStyleMod_ImGuiStyleMod	3
+1	nil	ImGuiStyleMod_ImGuiStyleModInt (ImGuiStyleVar,int)
+2	nil	ImGuiStyleMod_ImGuiStyleModFloat (ImGuiStyleVar,float)
+3	nil	ImGuiStyleMod_ImGuiStyleModVec2 (ImGuiStyleVar,ImVec2)
+ImRect_Expand	2
+1	void	ImRect_ExpandFloat (const float)
+2	void	ImRect_ExpandVec2 (const ImVec2)
+ImPool_Remove	2
+1	void	ImPool_RemoveTPtr (ImGuiID,const T*)
+2	void	ImPool_RemovePoolIdx (ImGuiID,ImPoolIdx)
 igListBox	2
 1	bool	igListBoxStr_arr (const char*,int*,const char* const[],int,int)
 2	bool	igListBoxFnPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
-Pair_Pair	3
-1	nil	Pair_PairInt (ImGuiID,int)
-2	nil	Pair_PairFloat (ImGuiID,float)
-3	nil	Pair_PairPtr (ImGuiID,void*)
-igPushID	4
-1	void	igPushIDStr (const char*)
-2	void	igPushIDRange (const char*,const char*)
-3	void	igPushIDPtr (const void*)
-4	void	igPushIDInt (int)
-igSetWindowPos	2
-1	void	igSetWindowPosVec2 (const ImVec2,ImGuiCond)
-2	void	igSetWindowPosStr (const char*,const ImVec2,ImGuiCond)
-igListBoxHeader	2
-1	bool	igListBoxHeaderVec2 (const char*,const ImVec2)
-2	bool	igListBoxHeaderInt (const char*,int,int)
-ImVector_erase	2
-1	T*	ImVector_erase (const T*)
-2	T*	ImVector_eraseTPtr (const T*,const T*)
-ImVector_resize	2
-1	void	ImVector_resize (int)
-2	void	ImVector_resizeT (int,const T)
-ImVector_front	2
-1	T*	ImVector_front ()
-2	const T*	ImVector_front_const ()const
+ImGuiPtrOrIndex_ImGuiPtrOrIndex	2
+1	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndexPtr (void*)
+2	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndexInt (int)
+ImRect_ImRect	4
+1	nil	ImRect_ImRectNil ()
+2	nil	ImRect_ImRectVec2 (const ImVec2,const ImVec2)
+3	nil	ImRect_ImRectVec4 (const ImVec4)
+4	nil	ImRect_ImRectFloat (float,float,float,float)
 igTreePush	2
 1	void	igTreePushStr (const char*)
 2	void	igTreePushPtr (const void*)
+igSelectable	2
+1	bool	igSelectableBool (const char*,bool,ImGuiSelectableFlags,const ImVec2)
+2	bool	igSelectableBoolPtr (const char*,bool*,ImGuiSelectableFlags,const ImVec2)
+igGetColorU32	3
+1	ImU32	igGetColorU32Col (ImGuiCol,float)
+2	ImU32	igGetColorU32Vec4 (const ImVec4)
+3	ImU32	igGetColorU32U32 (ImU32)
+ImVector_begin	2
+1	T*	ImVector_beginNil ()
+2	const T*	ImVector_begin_const ()const
 ImColor_ImColor	5
-1	nil	ImColor_ImColor ()
+1	nil	ImColor_ImColorNil ()
 2	nil	ImColor_ImColorInt (int,int,int,int)
 3	nil	ImColor_ImColorU32 (ImU32)
 4	nil	ImColor_ImColorFloat (float,float,float,float)
 5	nil	ImColor_ImColorVec4 (const ImVec4)
 igCollapsingHeader	2
-1	bool	igCollapsingHeader (const char*,ImGuiTreeNodeFlags)
+1	bool	igCollapsingHeaderTreeNodeFlags (const char*,ImGuiTreeNodeFlags)
 2	bool	igCollapsingHeaderBoolPtr (const char*,bool*,ImGuiTreeNodeFlags)
+ImVector_front	2
+1	T*	ImVector_frontNil ()
+2	const T*	ImVector_front_const ()const
+ImVector_find	2
+1	T*	ImVector_findNil (const T)
+2	const T*	ImVector_find_const (const T)const
+igListBoxHeader	2
+1	bool	igListBoxHeaderVec2 (const char*,const ImVec2)
+2	bool	igListBoxHeaderInt (const char*,int,int)
+igSetScrollX	2
+1	void	igSetScrollXFloat (float)
+2	void	igSetScrollXWindowPtr (ImGuiWindow*,float)
 igMenuItem	2
 1	bool	igMenuItemBool (const char*,const char*,bool,bool)
 2	bool	igMenuItemBoolPtr (const char*,const char*,bool*,bool)
-igTreeNodeEx	3
-1	bool	igTreeNodeExStr (const char*,ImGuiTreeNodeFlags)
-2	bool	igTreeNodeExStrStr (const char*,ImGuiTreeNodeFlags,const char*,...)
-3	bool	igTreeNodeExPtr (const void*,ImGuiTreeNodeFlags,const char*,...)
-igGetColorU32	3
-1	ImU32	igGetColorU32 (ImGuiCol,float)
-2	ImU32	igGetColorU32Vec4 (const ImVec4)
-3	ImU32	igGetColorU32U32 (ImU32)
-igTreeNode	3
-1	bool	igTreeNodeStr (const char*)
-2	bool	igTreeNodeStrStr (const char*,const char*,...)
-3	bool	igTreeNodePtr (const void*,const char*,...)
 igTreeNodeV	2
 1	bool	igTreeNodeVStr (const char*,const char*,va_list)
 2	bool	igTreeNodeVPtr (const void*,const char*,va_list)
-91 overloaded
+149 overloaded

generator/output/typedefs_dict.json

@@ -1,68 +1,119 @@
 {
-  "CustomRect": "struct CustomRect",
+  "ImBitVector": "struct ImBitVector",
   "ImColor": "struct ImColor",
   "ImDrawCallback": "void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);",
   "ImDrawChannel": "struct ImDrawChannel",
   "ImDrawCmd": "struct ImDrawCmd",
   "ImDrawCornerFlags": "int",
   "ImDrawData": "struct ImDrawData",
+  "ImDrawDataBuilder": "struct ImDrawDataBuilder",
   "ImDrawIdx": "unsigned short",
   "ImDrawList": "struct ImDrawList",
   "ImDrawListFlags": "int",
   "ImDrawListSharedData": "struct ImDrawListSharedData",
+  "ImDrawListSplitter": "struct ImDrawListSplitter",
   "ImDrawVert": "struct ImDrawVert",
+  "ImFileHandle": "FILE*",
   "ImFont": "struct ImFont",
   "ImFontAtlas": "struct ImFontAtlas",
+  "ImFontAtlasCustomRect": "struct ImFontAtlasCustomRect",
   "ImFontAtlasFlags": "int",
   "ImFontConfig": "struct ImFontConfig",
   "ImFontGlyph": "struct ImFontGlyph",
   "ImFontGlyphRangesBuilder": "struct ImFontGlyphRangesBuilder",
   "ImGuiBackendFlags": "int",
+  "ImGuiButtonFlags": "int",
   "ImGuiCol": "int",
   "ImGuiColorEditFlags": "int",
+  "ImGuiColorMod": "struct ImGuiColorMod",
+  "ImGuiColumnData": "struct ImGuiColumnData",
+  "ImGuiColumns": "struct ImGuiColumns",
   "ImGuiColumnsFlags": "int",
   "ImGuiComboFlags": "int",
   "ImGuiCond": "int",
   "ImGuiConfigFlags": "int",
   "ImGuiContext": "struct ImGuiContext",
   "ImGuiDataType": "int",
+  "ImGuiDataTypeInfo": "struct ImGuiDataTypeInfo",
   "ImGuiDir": "int",
   "ImGuiDragDropFlags": "int",
+  "ImGuiDragFlags": "int",
   "ImGuiFocusedFlags": "int",
+  "ImGuiGroupData": "struct ImGuiGroupData",
   "ImGuiHoveredFlags": "int",
   "ImGuiID": "unsigned int",
   "ImGuiIO": "struct ImGuiIO",
   "ImGuiInputTextCallback": "int(*)(ImGuiInputTextCallbackData *data);",
   "ImGuiInputTextCallbackData": "struct ImGuiInputTextCallbackData",
   "ImGuiInputTextFlags": "int",
+  "ImGuiInputTextState": "struct ImGuiInputTextState",
+  "ImGuiItemFlags": "int",
+  "ImGuiItemHoveredDataBackup": "struct ImGuiItemHoveredDataBackup",
+  "ImGuiItemStatusFlags": "int",
   "ImGuiKey": "int",
+  "ImGuiKeyModFlags": "int",
+  "ImGuiLayoutType": "int",
   "ImGuiListClipper": "struct ImGuiListClipper",
+  "ImGuiMenuColumns": "struct ImGuiMenuColumns",
+  "ImGuiMouseButton": "int",
   "ImGuiMouseCursor": "int",
+  "ImGuiNavDirSourceFlags": "int",
+  "ImGuiNavHighlightFlags": "int",
   "ImGuiNavInput": "int",
+  "ImGuiNavMoveFlags": "int",
+  "ImGuiNavMoveResult": "struct ImGuiNavMoveResult",
+  "ImGuiNextItemData": "struct ImGuiNextItemData",
+  "ImGuiNextItemDataFlags": "int",
+  "ImGuiNextWindowData": "struct ImGuiNextWindowData",
+  "ImGuiNextWindowDataFlags": "int",
   "ImGuiOnceUponAFrame": "struct ImGuiOnceUponAFrame",
   "ImGuiPayload": "struct ImGuiPayload",
+  "ImGuiPopupData": "struct ImGuiPopupData",
+  "ImGuiPtrOrIndex": "struct ImGuiPtrOrIndex",
   "ImGuiSelectableFlags": "int",
+  "ImGuiSeparatorFlags": "int",
+  "ImGuiSettingsHandler": "struct ImGuiSettingsHandler",
+  "ImGuiShrinkWidthItem": "struct ImGuiShrinkWidthItem",
   "ImGuiSizeCallback": "void(*)(ImGuiSizeCallbackData* data);",
   "ImGuiSizeCallbackData": "struct ImGuiSizeCallbackData",
+  "ImGuiSliderFlags": "int",
   "ImGuiStorage": "struct ImGuiStorage",
+  "ImGuiStoragePair": "struct ImGuiStoragePair",
   "ImGuiStyle": "struct ImGuiStyle",
+  "ImGuiStyleMod": "struct ImGuiStyleMod",
   "ImGuiStyleVar": "int",
+  "ImGuiTabBar": "struct ImGuiTabBar",
   "ImGuiTabBarFlags": "int",
+  "ImGuiTabItem": "struct ImGuiTabItem",
   "ImGuiTabItemFlags": "int",
   "ImGuiTextBuffer": "struct ImGuiTextBuffer",
   "ImGuiTextFilter": "struct ImGuiTextFilter",
+  "ImGuiTextFlags": "int",
+  "ImGuiTextRange": "struct ImGuiTextRange",
+  "ImGuiTooltipFlags": "int",
   "ImGuiTreeNodeFlags": "int",
+  "ImGuiWindow": "struct ImGuiWindow",
   "ImGuiWindowFlags": "int",
+  "ImGuiWindowSettings": "struct ImGuiWindowSettings",
+  "ImGuiWindowTempData": "struct ImGuiWindowTempData",
+  "ImPoolIdx": "int",
+  "ImRect": "struct ImRect",
+  "ImS16": "signed short",
   "ImS32": "signed int",
   "ImS64": "int64_t",
+  "ImS8": "signed char",
   "ImTextureID": "void*",
+  "ImU16": "unsigned short",
   "ImU32": "unsigned int",
   "ImU64": "uint64_t",
+  "ImU8": "unsigned char",
+  "ImVec1": "struct ImVec1",
   "ImVec2": "struct ImVec2",
+  "ImVec2ih": "struct ImVec2ih",
   "ImVec4": "struct ImVec4",
-  "ImWchar": "unsigned short",
-  "Pair": "struct Pair",
-  "TextRange": "struct TextRange",
+  "ImWchar": "ImWchar16",
+  "ImWchar16": "unsigned short",
+  "ImWchar32": "unsigned int",
   "const_iterator": "const value_type*",
   "iterator": "value_type*",
   "value_type": "T"

generator/output/typedefs_dict.lua

@@ -1,68 +1,119 @@
 local defs = {}
-defs["CustomRect"] = "struct CustomRect"
+defs["ImBitVector"] = "struct ImBitVector"
 defs["ImColor"] = "struct ImColor"
 defs["ImDrawCallback"] = "void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);"
 defs["ImDrawChannel"] = "struct ImDrawChannel"
 defs["ImDrawCmd"] = "struct ImDrawCmd"
 defs["ImDrawCornerFlags"] = "int"
 defs["ImDrawData"] = "struct ImDrawData"
+defs["ImDrawDataBuilder"] = "struct ImDrawDataBuilder"
 defs["ImDrawIdx"] = "unsigned short"
 defs["ImDrawList"] = "struct ImDrawList"
 defs["ImDrawListFlags"] = "int"
 defs["ImDrawListSharedData"] = "struct ImDrawListSharedData"
+defs["ImDrawListSplitter"] = "struct ImDrawListSplitter"
 defs["ImDrawVert"] = "struct ImDrawVert"
+defs["ImFileHandle"] = "FILE*"
 defs["ImFont"] = "struct ImFont"
 defs["ImFontAtlas"] = "struct ImFontAtlas"
+defs["ImFontAtlasCustomRect"] = "struct ImFontAtlasCustomRect"
 defs["ImFontAtlasFlags"] = "int"
 defs["ImFontConfig"] = "struct ImFontConfig"
 defs["ImFontGlyph"] = "struct ImFontGlyph"
 defs["ImFontGlyphRangesBuilder"] = "struct ImFontGlyphRangesBuilder"
 defs["ImGuiBackendFlags"] = "int"
+defs["ImGuiButtonFlags"] = "int"
 defs["ImGuiCol"] = "int"
 defs["ImGuiColorEditFlags"] = "int"
+defs["ImGuiColorMod"] = "struct ImGuiColorMod"
+defs["ImGuiColumnData"] = "struct ImGuiColumnData"
+defs["ImGuiColumns"] = "struct ImGuiColumns"
 defs["ImGuiColumnsFlags"] = "int"
 defs["ImGuiComboFlags"] = "int"
 defs["ImGuiCond"] = "int"
 defs["ImGuiConfigFlags"] = "int"
 defs["ImGuiContext"] = "struct ImGuiContext"
 defs["ImGuiDataType"] = "int"
+defs["ImGuiDataTypeInfo"] = "struct ImGuiDataTypeInfo"
 defs["ImGuiDir"] = "int"
 defs["ImGuiDragDropFlags"] = "int"
+defs["ImGuiDragFlags"] = "int"
 defs["ImGuiFocusedFlags"] = "int"
+defs["ImGuiGroupData"] = "struct ImGuiGroupData"
 defs["ImGuiHoveredFlags"] = "int"
 defs["ImGuiID"] = "unsigned int"
 defs["ImGuiIO"] = "struct ImGuiIO"
 defs["ImGuiInputTextCallback"] = "int(*)(ImGuiInputTextCallbackData *data);"
 defs["ImGuiInputTextCallbackData"] = "struct ImGuiInputTextCallbackData"
 defs["ImGuiInputTextFlags"] = "int"
+defs["ImGuiInputTextState"] = "struct ImGuiInputTextState"
+defs["ImGuiItemFlags"] = "int"
+defs["ImGuiItemHoveredDataBackup"] = "struct ImGuiItemHoveredDataBackup"
+defs["ImGuiItemStatusFlags"] = "int"
 defs["ImGuiKey"] = "int"
+defs["ImGuiKeyModFlags"] = "int"
+defs["ImGuiLayoutType"] = "int"
 defs["ImGuiListClipper"] = "struct ImGuiListClipper"
+defs["ImGuiMenuColumns"] = "struct ImGuiMenuColumns"
+defs["ImGuiMouseButton"] = "int"
 defs["ImGuiMouseCursor"] = "int"
+defs["ImGuiNavDirSourceFlags"] = "int"
+defs["ImGuiNavHighlightFlags"] = "int"
 defs["ImGuiNavInput"] = "int"
+defs["ImGuiNavMoveFlags"] = "int"
+defs["ImGuiNavMoveResult"] = "struct ImGuiNavMoveResult"
+defs["ImGuiNextItemData"] = "struct ImGuiNextItemData"
+defs["ImGuiNextItemDataFlags"] = "int"
+defs["ImGuiNextWindowData"] = "struct ImGuiNextWindowData"
+defs["ImGuiNextWindowDataFlags"] = "int"
 defs["ImGuiOnceUponAFrame"] = "struct ImGuiOnceUponAFrame"
 defs["ImGuiPayload"] = "struct ImGuiPayload"
+defs["ImGuiPopupData"] = "struct ImGuiPopupData"
+defs["ImGuiPtrOrIndex"] = "struct ImGuiPtrOrIndex"
 defs["ImGuiSelectableFlags"] = "int"
+defs["ImGuiSeparatorFlags"] = "int"
+defs["ImGuiSettingsHandler"] = "struct ImGuiSettingsHandler"
+defs["ImGuiShrinkWidthItem"] = "struct ImGuiShrinkWidthItem"
 defs["ImGuiSizeCallback"] = "void(*)(ImGuiSizeCallbackData* data);"
 defs["ImGuiSizeCallbackData"] = "struct ImGuiSizeCallbackData"
+defs["ImGuiSliderFlags"] = "int"
 defs["ImGuiStorage"] = "struct ImGuiStorage"
+defs["ImGuiStoragePair"] = "struct ImGuiStoragePair"
 defs["ImGuiStyle"] = "struct ImGuiStyle"
+defs["ImGuiStyleMod"] = "struct ImGuiStyleMod"
 defs["ImGuiStyleVar"] = "int"
+defs["ImGuiTabBar"] = "struct ImGuiTabBar"
 defs["ImGuiTabBarFlags"] = "int"
+defs["ImGuiTabItem"] = "struct ImGuiTabItem"
 defs["ImGuiTabItemFlags"] = "int"
 defs["ImGuiTextBuffer"] = "struct ImGuiTextBuffer"
 defs["ImGuiTextFilter"] = "struct ImGuiTextFilter"
+defs["ImGuiTextFlags"] = "int"
+defs["ImGuiTextRange"] = "struct ImGuiTextRange"
+defs["ImGuiTooltipFlags"] = "int"
 defs["ImGuiTreeNodeFlags"] = "int"
+defs["ImGuiWindow"] = "struct ImGuiWindow"
 defs["ImGuiWindowFlags"] = "int"
+defs["ImGuiWindowSettings"] = "struct ImGuiWindowSettings"
+defs["ImGuiWindowTempData"] = "struct ImGuiWindowTempData"
+defs["ImPoolIdx"] = "int"
+defs["ImRect"] = "struct ImRect"
+defs["ImS16"] = "signed short"
 defs["ImS32"] = "signed int"
 defs["ImS64"] = "int64_t"
+defs["ImS8"] = "signed char"
 defs["ImTextureID"] = "void*"
+defs["ImU16"] = "unsigned short"
 defs["ImU32"] = "unsigned int"
 defs["ImU64"] = "uint64_t"
+defs["ImU8"] = "unsigned char"
+defs["ImVec1"] = "struct ImVec1"
 defs["ImVec2"] = "struct ImVec2"
+defs["ImVec2ih"] = "struct ImVec2ih"
 defs["ImVec4"] = "struct ImVec4"
-defs["ImWchar"] = "unsigned short"
-defs["Pair"] = "struct Pair"
-defs["TextRange"] = "struct TextRange"
+defs["ImWchar"] = "ImWchar16"
+defs["ImWchar16"] = "unsigned short"
+defs["ImWchar32"] = "unsigned int"
 defs["const_iterator"] = "const value_type*"
 defs["iterator"] = "value_type*"
 defs["value_type"] = "T"

test/CMakeLists.txt

@@ -0,0 +1,11 @@
+file(GLOB CIMGUI_TEST_SOURCES
+    main.c
+)
+
+add_executable(cimgui_test ${CIMGUI_TEST_SOURCES})
+
+set_target_properties(cimgui_test PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+set_property(TARGET cimgui_test PROPERTY C_STANDARD 99)
+
+target_compile_definitions(cimgui_test PRIVATE CIMGUI_DEFINE_ENUMS_AND_STRUCTS=1)
+target_link_libraries(cimgui_test PRIVATE cimgui)

test/main.c

@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <assert.h>
+#include "../cimgui.h"
+
+int main(void)
+{
+  assert(igDebugCheckVersionAndDataLayout(igGetVersion(), sizeof(ImGuiIO), sizeof(ImGuiStyle),
+                                          sizeof(ImVec2), sizeof(ImVec4), sizeof(ImDrawVert),
+                                          sizeof(ImDrawIdx)));
+  printf("CreateContext() - v%s\n", igGetVersion());
+  igCreateContext(NULL);
+  ImGuiIO *io = igGetIO();
+
+  unsigned char *text_pixels = NULL;
+  int text_w, text_h;
+  ImFontAtlas_GetTexDataAsRGBA32(io->Fonts, &text_pixels, &text_w, &text_h, NULL);
+
+  for (int n = 0; n < 20; n++) {
+    printf("NewFrame() %d\n", n);
+
+    ImVec2 display_size;
+    display_size.x = 1920;
+    display_size.y = 1080;
+    io->DisplaySize = display_size;
+    io->DeltaTime = 1.0f / 60.0f;
+    igNewFrame();
+
+    static float f = 0.0f;
+    igText("Hello World!");
+    igSliderFloat("float", &f, 0.0f, 1.0f, "%.3f", 1.0f);
+    igText("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io->Framerate, io->Framerate);
+    igShowDemoWindow(NULL);
+
+    igRender();
+  }
+
+  printf("DestroyContext()\n");
+  igDestroyContext(NULL);
+
+  return 0;
+}

testbuildc/build.bat

@@ -1,6 +0,0 @@
-:: set PATH=%PATH%;C:\mingw32\bin;
-set PATH=%PATH%;C:\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\mingw32\bin;
-::gcc -std=c99 -DCIMGUI_DEFINE_ENUMS_AND_STRUCTS cimgui.h
-::gcc  -DCIMGUI_DEFINE_ENUMS_AND_STRUCTS cimgui.h
-gcc  -std=c99 -Wall -Wpedantic -DCIMGUI_DEFINE_ENUMS_AND_STRUCTS cimguitest.c
-cmd /k

testbuildc/cimguitest.c

@@ -1,6 +0,0 @@
-#include "../cimgui.h"
-
-int main(void)
-{
-	return 0;
-}

testbuildc/testcl.bat

@@ -1,13 +0,0 @@
-::set PATH=%PATH%;C:\luaGL;C:\mingw32\bin;
-::gcc -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ../imgui/imgui.h > 11.txt
-
-::set PATH=%PATH%;C:\luaGL;
-::set PATH=%PATH%;C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.15.26726\bin\Hostx64\x64;
-
-::ejecutar en cmd esto 
-::"C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat"
-
-::cl /P /DIMGUI_DISABLE_OBSOLETE_FUNCTIONS /DIMGUI_API="" /DIMGUI_IMPL_API="" ../imgui/imgui.h 
-:: > clout.txt
-cl  /P /DCIMGUI_DEFINE_ENUMS_AND_STRUCTS cimguitest.c
-cmd /k