koffi 2.1.1 → 2.1.2

package/vendor/raylib/parser/raylib_parser.c

@@ -2,12 +2,14 @@
 
     raylib API parser
 
-    This parser scans raylib.h to get API information about structs, enums and functions.
+    This parser scans raylib.h to get API information about defines, structs, aliases, enums, callbacks and functions.
     All data is divided into pieces, usually as strings. The following types are used for data:
 
-     - struct FunctionInfo
+     - struct DefineInfo
      - struct StructInfo
+     - struct AliasInfo
      - struct EnumInfo
+     - struct FunctionInfo
 
     CONSTRAINTS:
 
@@ -45,7 +47,6 @@
     OTHER NOTES:
 
      - This parser could work with other C header files if mentioned constraints are followed.
-
      - This parser does not require <string.h> library, all data is parsed directly from char buffers.
 
     LICENSE: zlib/libpng
@@ -53,7 +54,7 @@
     raylib-parser is licensed under an unmodified zlib/libpng license, which is an OSI-certified,
     BSD-like license that allows static linking with closed source software:
 
-    Copyright (c) 2021 Ramon Santamaria (@raysan5)
+    Copyright (c) 2021-2022 Ramon Santamaria (@raysan5)
 
 **********************************************************************************************/
 
@@ -62,67 +63,112 @@
 #include <stdlib.h>             // Required for: malloc(), calloc(), realloc(), free(), atoi(), strtol()
 #include <stdio.h>              // Required for: printf(), fopen(), fseek(), ftell(), fread(), fclose()
 #include <stdbool.h>            // Required for: bool
+#include <ctype.h>              // Required for: isdigit()
 
-#define MAX_FUNCS_TO_PARSE       512    // Maximum number of functions to parse
+#define MAX_DEFINES_TO_PARSE    2048    // Maximum number of defines to parse
 #define MAX_STRUCTS_TO_PARSE      64    // Maximum number of structures to parse
+#define MAX_ALIASES_TO_PARSE      64    // Maximum number of aliases to parse
 #define MAX_ENUMS_TO_PARSE        64    // Maximum number of enums to parse
+#define MAX_CALLBACKS_TO_PARSE    64    // Maximum number of callbacks to parse
+#define MAX_FUNCS_TO_PARSE       512    // Maximum number of functions to parse
 
 #define MAX_LINE_LENGTH          512    // Maximum length of one line (including comments)
-#define MAX_STRUCT_LINE_LENGTH  2048    // Maximum length of one struct (multiple lines)
 
-#define MAX_FUNCTION_PARAMETERS   12    // Maximum number of function parameters
-#define MAX_STRUCT_FIELDS         32    // Maximum number of struct fields
+#define MAX_STRUCT_FIELDS         64    // Maximum number of struct fields
 #define MAX_ENUM_VALUES          512    // Maximum number of enum values
+#define MAX_FUNCTION_PARAMETERS   12    // Maximum number of function parameters
 
 //----------------------------------------------------------------------------------
 // Types and Structures Definition
 //----------------------------------------------------------------------------------
-// Function info data
-typedef struct FunctionInfo {
-    char name[64];              // Function name
-    char desc[128];             // Function description (comment at the end)
-    char retType[32];           // Return value type
-    int paramCount;             // Number of function parameters
-    char paramType[MAX_FUNCTION_PARAMETERS][32];   // Parameters type
-    char paramName[MAX_FUNCTION_PARAMETERS][32];   // Parameters name
-    char paramDesc[MAX_FUNCTION_PARAMETERS][8];    // Parameters description
-} FunctionInfo;
+
+// Type of parsed define
+typedef enum {
+    UNKNOWN = 0,
+    MACRO,
+    GUARD,
+    INT,
+    INT_MATH,
+    LONG,
+    LONG_MATH,
+    FLOAT,
+    FLOAT_MATH,
+    DOUBLE,
+    DOUBLE_MATH,
+    CHAR,
+    STRING,
+    COLOR
+} DefineType;
+
+// Define info data
+typedef struct DefineInfo {
+    char name[64];              // Define name
+    int type;                   // Define type
+    char value[256];            // Define value
+    char desc[128];             // Define description
+    bool isHex;                 // Define is hex number (for types INT, LONG)
+} DefineInfo;
 
 // Struct info data
 typedef struct StructInfo {
     char name[64];              // Struct name
-    char desc[64];              // Struct type description
+    char desc[128];             // Struct type description
     int fieldCount;             // Number of fields in the struct
     char fieldType[MAX_STRUCT_FIELDS][64];     // Field type
     char fieldName[MAX_STRUCT_FIELDS][64];     // Field name
     char fieldDesc[MAX_STRUCT_FIELDS][128];    // Field description
 } StructInfo;
 
+// Alias info data
+typedef struct AliasInfo {
+    char type[64];              // Alias type
+    char name[64];              // Alias name
+    char desc[128];             // Alias description
+} AliasInfo;
+
 // Enum info data
 typedef struct EnumInfo {
     char name[64];              // Enum name
-    char desc[64];              // Enum description
+    char desc[128];             // Enum description
     int valueCount;             // Number of values in enumerator
     char valueName[MAX_ENUM_VALUES][64];    // Value name definition
     int valueInteger[MAX_ENUM_VALUES];      // Value integer
-    char valueDesc[MAX_ENUM_VALUES][64];    // Value description
+    char valueDesc[MAX_ENUM_VALUES][128];   // Value description
 } EnumInfo;
 
+// Function info data
+typedef struct FunctionInfo {
+    char name[64];              // Function name
+    char desc[128];             // Function description (comment at the end)
+    char retType[32];           // Return value type
+    int paramCount;             // Number of function parameters
+    char paramType[MAX_FUNCTION_PARAMETERS][32];   // Parameters type
+    char paramName[MAX_FUNCTION_PARAMETERS][32];   // Parameters name
+    char paramDesc[MAX_FUNCTION_PARAMETERS][128];  // Parameters description
+} FunctionInfo;
+
 // Output format for parsed data
-typedef enum { DEFAULT = 0, JSON, XML } OutputFormat;
+typedef enum { DEFAULT = 0, JSON, XML, LUA } OutputFormat;
 
 //----------------------------------------------------------------------------------
 // Global Variables Definition
 //----------------------------------------------------------------------------------
-static int funcCount = 0;
+static int defineCount = 0;
 static int structCount = 0;
+static int aliasCount = 0;
 static int enumCount = 0;
-static FunctionInfo *funcs = NULL;
+static int callbackCount = 0;
+static int funcCount = 0;
+static DefineInfo *defines = NULL;
 static StructInfo *structs = NULL;
+static AliasInfo *aliases = NULL;
 static EnumInfo *enums = NULL;
-static char apiDefine[32] = "RLAPI\0";
+static FunctionInfo *callbacks = NULL;
+static FunctionInfo *funcs = NULL;
 
 // Command line variables
+static char apiDefine[32] = { 0 };         // Functions define (i.e. RLAPI for raylib.h, RMDEF for raymath.h, etc.)
+static char truncAfter[32] = { 0 };        // Truncate marker (i.e. "RLGL IMPLEMENTATION" for rlgl.h)
 static char inFileName[512] = { 0 };       // Input file name (required in case of provided through CLI)
 static char outFileName[512] = { 0 };      // Output file name (required for file save/export)
 static int outputFormat = DEFAULT;
@@ -136,21 +182,27 @@ static void ProcessCommandLine(int argc, char *argv[]);     // Process command l
 static char *LoadFileText(const char *fileName, int *length);
 static char **GetTextLines(const char *buffer, int length, int *linesCount);
 static void GetDataTypeAndName(const char *typeName, int typeNameLen, char *type, char *name);
+static void GetDescription(const char *source, char *description);
+static void MoveArraySize(char *name, char *type);          // Move array size from name to type
 static unsigned int TextLength(const char *text);           // Get text length in bytes, check for \0 character
 static bool IsTextEqual(const char *text1, const char *text2, unsigned int count);
+static int TextFindIndex(const char *text, const char *find); // Find first text occurrence within a string
 static void MemoryCopy(void *dest, const void *src, unsigned int count);
-static char* CharReplace(char* text, char search, char replace);
+static char *EscapeBackslashes(char *text);                 // Replace '\' by "\\" when exporting to JSON and XML
+static const char *StrDefineType(DefineType type);          // Get string of define type
 
 static void ExportParsedData(const char *fileName, int format); // Export parsed data in desired format
 
-//------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------
 // Program main entry point
-//------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------
 int main(int argc, char* argv[])
 {
     if (argc > 1) ProcessCommandLine(argc, argv);
 
     if (inFileName[0] == '\0') MemoryCopy(inFileName, "../src/raylib.h\0", 16);
+    if (outFileName[0] == '\0') MemoryCopy(outFileName, "raylib_api.txt\0", 15);
+    if (apiDefine[0] == '\0') MemoryCopy(apiDefine, "RLAPI\0", 6);
 
     int length = 0;
     char *buffer = LoadFileText(inFileName, &length);
@@ -160,77 +212,101 @@ int main(int argc, char* argv[])
     int linesCount = 0;
     char **lines = GetTextLines(buffer, length, &linesCount);
 
-    // Function lines pointers, selected from buffer "lines"
-    char **funcLines = (char **)malloc(MAX_FUNCS_TO_PARSE*sizeof(char *));
+    // Truncate lines
+    if (truncAfter[0] != '\0')
+    {
+        int newCount = -1;
+        for (int i = 0; i < linesCount; i++)
+        {
+            if (newCount > -1) free(lines[i]);
+            else if (TextFindIndex(lines[i], truncAfter) > -1) newCount = i;
+        }
+        if (newCount > -1) linesCount = newCount;
+        printf("Number of truncated text lines: %i\n", linesCount);
+    }
+
+    // Defines line indices
+    int *defineLines = (int *)malloc(MAX_DEFINES_TO_PARSE*sizeof(int));
 
-    // Structs data (multiple lines), selected from "buffer"
-    char **structLines = (char **)malloc(MAX_STRUCTS_TO_PARSE*sizeof(char *));
-    for (int i = 0; i < MAX_STRUCTS_TO_PARSE; i++) structLines[i] = (char *)calloc(MAX_STRUCT_LINE_LENGTH, sizeof(char));
+    // Structs line indices
+    int *structLines = (int *)malloc(MAX_STRUCTS_TO_PARSE*sizeof(int));
 
-    // Enums lines pointers, selected from buffer "lines"
+    // Aliases line indices
+    int *aliasLines = (int *)malloc(MAX_ALIASES_TO_PARSE*sizeof(int));
+
+    // Enums line indices
     int *enumLines = (int *)malloc(MAX_ENUMS_TO_PARSE*sizeof(int));
 
+    // Callbacks line indices
+    int *callbackLines = (int *)malloc(MAX_CALLBACKS_TO_PARSE*sizeof(int));
+
+    // Function line indices
+    int *funcLines = (int *)malloc(MAX_FUNCS_TO_PARSE*sizeof(int));
+
     // Prepare required lines for parsing
-    //--------------------------------------------------------------------------------------------------
+    //----------------------------------------------------------------------------------
 
-    // Read function lines
+    // Read define lines
     for (int i = 0; i < linesCount; i++)
     {
-        // Read function line (starting with `define`, i.e. for raylib.h "RLAPI")
-        if (IsTextEqual(lines[i], apiDefine, TextLength(apiDefine)))
+        int j = 0;
+        while ((lines[i][j] == ' ') || (lines[i][j] == '\t')) j++; // skip spaces and tabs in the begining
+        // Read define line
+        if (IsTextEqual(lines[i]+j, "#define ", 8))
         {
-            // Keep a pointer to the function line
-            funcLines[funcCount] = lines[i];
-            funcCount++;
+            // Keep the line position in the array of lines,
+            // so, we can scan that position and following lines
+            defineLines[defineCount] = i;
+            defineCount++;
         }
     }
 
-    // Read structs data (multiple lines, read directly from buffer)
-    // TODO: Parse structs data from "lines" instead of "buffer" -> Easier to get struct definition
-    for (int i = 0; i < length; i++)
+    // Read struct lines
+    for (int i = 0; i < linesCount; i++)
     {
-        // Read struct data (starting with "typedef struct", ending with '} ... ;')
-        // NOTE: We read it directly from buffer
-        if (IsTextEqual(buffer + i, "typedef struct", 14))
+        // Find structs
+        // starting with "typedef struct ... {" or "typedef struct ... ; \n struct ... {"
+        // ending with "} ... ;"
+        // i.e. excluding "typedef struct rAudioBuffer rAudioBuffer;" -> Typedef and forward declaration only
+        if (IsTextEqual(lines[i], "typedef struct", 14))
         {
-            int j = 0;
-            bool validStruct = false;
-
-            // WARNING: Typedefs between types: typedef Vector4 Quaternion;
-
-            for (int c = 0; c < 128; c++)
+            bool validStruct = IsTextEqual(lines[i + 1], "struct", 6);
+            if (!validStruct)
             {
-                if (buffer[i + c] == '{')
-                {
-                    validStruct = true;
-                    break;
-                }
-                else if (buffer[i + c] == ';')
+                for (int c = 0; c < MAX_LINE_LENGTH; c++)
                 {
-                    // Not valid struct:
-                    // i.e typedef struct rAudioBuffer rAudioBuffer; -> Typedef and forward declaration
-                    i += c;
-                    break;
+                    char v = lines[i][c];
+                    if (v == '{') validStruct = true;
+                    if ((v == '{') || (v == ';') || (v == '\0')) break;
                 }
             }
+            if (!validStruct) continue;
+            structLines[structCount] = i;
+            while (lines[i][0] != '}') i++;
+            while (lines[i][0] != '\0') i++;
+            structCount++;
+        }
+    }
 
-            if (validStruct)
-            {
-                while (buffer[i + j] != '}')
-                {
-                    structLines[structCount][j] = buffer[i + j];
-                    j++;
-                }
-
-                while (buffer[i + j] != '\n')
-                {
-                    structLines[structCount][j] = buffer[i + j];
-                    j++;
-                }
+    // Read alias lines
+    for (int i = 0; i < linesCount; i++)
+    {
+        // Find aliases (lines with "typedef ... ...;")
+        if (IsTextEqual(lines[i], "typedef", 7))
+        {
+            int spaceCount = 0;
+            bool validAlias = false;
 
-                i += j;
-                structCount++;
+            for (int c = 0; c < MAX_LINE_LENGTH; c++)
+            {
+                char v = lines[i][c];
+                if (v == ' ') spaceCount++;
+                if ((v == ';') && (spaceCount == 2)) validAlias = true;
+                if ((v == ';') || (v == '(') || (v == '\0')) break;
             }
+            if (!validAlias) continue;
+            aliasLines[aliasCount] = i;
+            aliasCount++;
         }
     }
 
@@ -238,7 +314,7 @@ int main(int argc, char* argv[])
     for (int i = 0; i < linesCount; i++)
     {
         // Read enum line
-        if (IsTextEqual(lines[i], "typedef enum {", 14))
+        if (IsTextEqual(lines[i], "typedef enum {", 14) && (lines[i][TextLength(lines[i])-1] != ';')) // ignore inline enums
         {
             // Keep the line position in the array of lines,
             // so, we can scan that position and following lines
@@ -247,56 +323,313 @@ int main(int argc, char* argv[])
         }
     }
 
-    // At this point we have all raylib structs, enums, functions lines data to start parsing
+    // Read callback lines
+    for (int i = 0; i < linesCount; i++)
+    {
+        // Find callbacks (lines with "typedef ... (* ... )( ... );")
+        if (IsTextEqual(lines[i], "typedef", 7))
+        {
+            bool hasBeginning = false;
+            bool hasMiddle = false;
+            bool hasEnd = false;
+
+            for (int c = 0; c < MAX_LINE_LENGTH; c++)
+            {
+                if ((lines[i][c] == '(') && (lines[i][c + 1] == '*')) hasBeginning = true;
+                if ((lines[i][c] == ')') && (lines[i][c + 1] == '(')) hasMiddle = true;
+                if ((lines[i][c] == ')') && (lines[i][c + 1] == ';')) hasEnd = true;
+                if (hasEnd) break;
+            }
+
+            if (hasBeginning && hasMiddle && hasEnd)
+            {
+                callbackLines[callbackCount] = i;
+                callbackCount++;
+            }
+        }
+    }
+
+    // Read function lines
+    for (int i = 0; i < linesCount; i++)
+    {
+        // Read function line (starting with `define`, i.e. for raylib.h "RLAPI")
+        if (IsTextEqual(lines[i], apiDefine, TextLength(apiDefine)))
+        {
+            funcLines[funcCount] = i;
+            funcCount++;
+        }
+    }
+
+    // At this point we have all raylib defines, structs, aliases, enums, callbacks, functions lines data to start parsing
 
     free(buffer);       // Unload text buffer
 
     // Parsing raylib data
-    //--------------------------------------------------------------------------------------------------
+    //----------------------------------------------------------------------------------
+
+    // Define info data
+    defines = (DefineInfo *)calloc(MAX_DEFINES_TO_PARSE, sizeof(DefineInfo));
+    int defineIndex = 0;
+
+    for (int i = 0; i < defineCount; i++)
+    {
+        char *linePtr = lines[defineLines[i]];
+        int j = 0;
+
+        while ((linePtr[j] == ' ') || (linePtr[j] == '\t')) j++; // Skip spaces and tabs in the begining
+        j += 8;                                                  // Skip "#define "
+        while ((linePtr[j] == ' ') || (linePtr[j] == '\t')) j++; // Skip spaces and tabs after "#define "
+
+        // Extract name
+        int defineNameStart = j;
+        int openBraces = 0;
+        while (linePtr[j] != '\0')
+        {
+            if (((linePtr[j] == ' ') || (linePtr[j] == '\t')) && (openBraces == 0)) break;
+            if (linePtr[j] == '(') openBraces++;
+            if (linePtr[j] == ')') openBraces--;
+            j++;
+        }
+        int defineNameEnd = j-1;
+
+        // Skip duplicates
+        unsigned int nameLen = defineNameEnd - defineNameStart + 1;
+        bool isDuplicate = false;
+        for (int k = 0; k < defineIndex; k++)
+        {
+            if ((nameLen == TextLength(defines[k].name)) && IsTextEqual(defines[k].name, &linePtr[defineNameStart], nameLen))
+            {
+                isDuplicate = true;
+                break;
+            }
+        }
+        if (isDuplicate) continue;
+
+        MemoryCopy(defines[defineIndex].name, &linePtr[defineNameStart], nameLen);
+
+        // Determine type
+        if (linePtr[defineNameEnd] == ')') defines[defineIndex].type = MACRO;
+
+        while ((linePtr[j] == ' ') || (linePtr[j] == '\t')) j++; // Skip spaces and tabs after name
+
+        int defineValueStart = j;
+        if ((linePtr[j] == '\0') || (linePtr[j] == '/')) defines[defineIndex].type = GUARD;
+        if (linePtr[j] == '"') defines[defineIndex].type = STRING;
+        else if (linePtr[j] == '\'') defines[defineIndex].type = CHAR;
+        else if (IsTextEqual(linePtr+j, "CLITERAL(Color)", 15)) defines[defineIndex].type = COLOR;
+        else if (isdigit(linePtr[j])) // Parsing numbers
+        {
+            bool isFloat = false, isNumber = true, isHex = false;
+            while ((linePtr[j] != ' ') && (linePtr[j] != '\t') && (linePtr[j] != '\0'))
+            {
+                char ch = linePtr[j];
+                if (ch == '.') isFloat = true;
+                if (ch == 'x') isHex = true;
+                if (!(isdigit(ch) ||
+                      ((ch >= 'a') && (ch <= 'f')) ||
+                      ((ch >= 'A') && (ch <= 'F')) ||
+                      (ch == 'x') ||
+                      (ch == 'L') ||
+                      (ch == '.') ||
+                      (ch == '+') ||
+                      (ch == '-'))) isNumber = false;
+                j++;
+            }
+            if (isNumber)
+            {
+                if (isFloat)
+                {
+                    defines[defineIndex].type = linePtr[j-1] == 'f' ? FLOAT : DOUBLE;
+                }
+                else
+                {
+                    defines[defineIndex].type = linePtr[j-1] == 'L' ? LONG : INT;
+                    defines[defineIndex].isHex = isHex;
+                }
+            }
+        }
+
+        // Extracting value
+        while ((linePtr[j] != '\\') && (linePtr[j] != '\0') && !((linePtr[j] == '/') && (linePtr[j+1] == '/'))) j++;
+        int defineValueEnd = j-1;
+        while ((linePtr[defineValueEnd] == ' ') || (linePtr[defineValueEnd] == '\t')) defineValueEnd--; // Remove trailing spaces and tabs
+        if ((defines[defineIndex].type == LONG) || (defines[defineIndex].type == FLOAT)) defineValueEnd--; // Remove number postfix
+        int valueLen = defineValueEnd - defineValueStart + 1;
+        if (valueLen > 255) valueLen = 255;
+
+        if (valueLen > 0) MemoryCopy(defines[defineIndex].value, &linePtr[defineValueStart], valueLen);
+
+        // Extracting description
+        if ((linePtr[j] == '/') && linePtr[j + 1] == '/')
+        {
+            j += 2;
+            while (linePtr[j] == ' ') j++;
+            int commentStart = j;
+            while ((linePtr[j] != '\\') && (linePtr[j] != '\0')) j++;
+            int commentEnd = j-1;
+            int commentLen = commentEnd - commentStart + 1;
+            if (commentLen > 127) commentLen = 127;
+
+            MemoryCopy(defines[defineIndex].desc, &linePtr[commentStart], commentLen);
+        }
+
+        // Parse defines of type UNKNOWN to find calculated numbers
+        if (defines[defineIndex].type == UNKNOWN)
+        {
+            int largestType = UNKNOWN;
+            bool isMath = true;
+            char *valuePtr = defines[defineIndex].value;
+
+            for (unsigned int c = 0; c < TextLength(valuePtr); c++)
+            {
+                char ch = valuePtr[c];
+
+                // Skip operators and whitespace
+                if ((ch == '(') ||
+                    (ch == ')') ||
+                    (ch == '+') ||
+                    (ch == '-') ||
+                    (ch == '*') ||
+                    (ch == '/') ||
+                    (ch == ' ') ||
+                    (ch == '\t')) continue;
+                
+                // Read number operand
+                else if (isdigit(ch))
+                {
+                    bool isNumber = true, isFloat = false;
+                    while (!((ch == '(') ||
+                             (ch == ')') ||
+                             (ch == '*') ||
+                             (ch == '/') ||
+                             (ch == ' ') ||
+                             (ch == '\t') ||
+                             (ch == '\0')))
+                    {
+                        if (ch == '.') isFloat = true;
+                        if (!(isdigit(ch) ||
+                            ((ch >= 'a') && (ch <= 'f')) ||
+                            ((ch >= 'A') && (ch <= 'F')) ||
+                            (ch == 'x') ||
+                            (ch == 'L') ||
+                            (ch == '.') ||
+                            (ch == '+') ||
+                            (ch == '-')))
+                        {
+                            isNumber = false;
+                            break;
+                        }
+                        c++;
+                        ch = valuePtr[c];
+                    }
+                    if (isNumber)
+                    {
+                        // Found a valid number -> update largestType
+                        int numberType;
+                        if (isFloat) numberType = valuePtr[c - 1] == 'f' ? FLOAT_MATH : DOUBLE_MATH;
+                        else numberType = valuePtr[c - 1] == 'L' ? LONG_MATH : INT_MATH;
+                        
+                        if (numberType > largestType) largestType = numberType;
+                    }
+                    else
+                    {
+                        isMath = false;
+                        break;
+                    }
+                }
+                else    // Read string operand
+                {
+                    int operandStart = c;
+                    while (!((ch == '\0') ||
+                             (ch == ' ') ||
+                             (ch == '(') ||
+                             (ch == ')') ||
+                             (ch == '+') ||
+                             (ch == '-') ||
+                             (ch == '*') ||
+                             (ch == '/')))
+                    {
+                        c++;
+                        ch = valuePtr[c];
+                    }
+                    int operandEnd = c;
+                    int operandLength = operandEnd - operandStart;
+
+                    // Search previous defines for operand
+                    bool foundOperand = false;
+                    for (int previousDefineIndex = 0; previousDefineIndex < defineIndex; previousDefineIndex++)
+                    {
+                        if (IsTextEqual(defines[previousDefineIndex].name, &valuePtr[operandStart], operandLength))
+                        {
+                            if ((defines[previousDefineIndex].type >= INT) && (defines[previousDefineIndex].type <= DOUBLE_MATH))
+                            {
+                                // Found operand and it's a number -> update largestType
+                                if (defines[previousDefineIndex].type > largestType) largestType = defines[previousDefineIndex].type;
+                                foundOperand = true;
+                            }
+                            break;
+                        }
+                    }
+                    if (!foundOperand)
+                    {
+                        isMath = false;
+                        break;
+                    }
+                }
+            }
+
+            if (isMath)
+            {
+                // Define is a calculated number -> update type
+                if (largestType == INT) largestType = INT_MATH;
+                else if (largestType == LONG) largestType = LONG_MATH;
+                else if (largestType == FLOAT) largestType = FLOAT_MATH;
+                else if (largestType == DOUBLE) largestType = DOUBLE_MATH;
+                defines[defineIndex].type = largestType;
+            }
+        }
+
+        defineIndex++;
+    }
+    defineCount = defineIndex;
+    free(defineLines);
 
     // Structs info data
     structs = (StructInfo *)calloc(MAX_STRUCTS_TO_PARSE, sizeof(StructInfo));
 
     for (int i = 0; i < structCount; i++)
     {
-        int structLineOffset = 0;
+        char **linesPtr = &lines[structLines[i]];
+
+        // Parse struct description
+        GetDescription(linesPtr[-1], structs[i].desc);
 
         // Get struct name: typedef struct name {
-        for (int c = 15; c < 64 + 15; c++)
+        const int TDS_LEN = 15; // length of "typedef struct "
+        for (int c = TDS_LEN; c < 64 + TDS_LEN; c++)
         {
-            if (structLines[i][c] == '{')
+            if ((linesPtr[0][c] == '{') || (linesPtr[0][c] == ' '))
             {
-                structLineOffset = c + 2;
-
-                MemoryCopy(structs[i].name, &structLines[i][15], c - 15 - 1);
+                int nameLen = c - TDS_LEN;
+                while (linesPtr[0][TDS_LEN + nameLen - 1] == ' ') nameLen--;
+                MemoryCopy(structs[i].name, &linesPtr[0][TDS_LEN], nameLen);
                 break;
             }
         }
 
         // Get struct fields and count them -> fields finish with ;
-        int j = 0;
-        while (structLines[i][structLineOffset + j] != '}')
+        int l = 1;
+        while (linesPtr[l][0] != '}')
         {
             // WARNING: Some structs have empty spaces and comments -> OK, processed
-
-            int fieldStart = 0;
-            if ((structLines[i][structLineOffset + j] != ' ') && (structLines[i][structLineOffset + j] != '\n')) fieldStart = structLineOffset + j;
-
-            if (fieldStart != 0)
+            if ((linesPtr[l][0] != ' ') && (linesPtr[l][0] != '\0'))
             {
                 // Scan one field line
-                int c = 0;
+                char *fieldLine = linesPtr[l];
                 int fieldEndPos = 0;
-                char fieldLine[256] = { 0 };
-
-                while (structLines[i][structLineOffset + j] != '\n')
-                {
-                    if (structLines[i][structLineOffset + j] == ';') fieldEndPos = c;
-                    fieldLine[c] = structLines[i][structLineOffset + j];
-                    c++; j++;
-                }
+                while (fieldLine[fieldEndPos] != ';') fieldEndPos++;
 
-                if (fieldLine[0] != '/')    // Field line is not a comment
+                if ((fieldLine[0] != '/') && !IsTextEqual(fieldLine, "struct", 6)) // Field line is not a comment and not a struct declaration
                 {
                     //printf("Struct field: %s_\n", fieldLine);     // OK!
 
@@ -304,35 +637,172 @@ int main(int argc, char* argv[])
                     GetDataTypeAndName(fieldLine, fieldEndPos, structs[i].fieldType[structs[i].fieldCount], structs[i].fieldName[structs[i].fieldCount]);
 
                     // Get the field description
-                    // We start skipping spaces in front of description comment
-                    int descStart = fieldEndPos;
-                    while ((fieldLine[descStart] != '/') && (fieldLine[descStart] != '\0')) descStart++;
+                    GetDescription(&fieldLine[fieldEndPos], structs[i].fieldDesc[structs[i].fieldCount]);
 
-                    int k = 0;
-                    while ((fieldLine[descStart + k] != '\0') && (fieldLine[descStart + k] != '\n'))
+                    structs[i].fieldCount++;
+
+                    // Split field names containing multiple fields (like Matrix)
+                    int additionalFields = 0;
+                    int originalIndex = structs[i].fieldCount - 1;
+                    for (unsigned int c = 0; c < TextLength(structs[i].fieldName[originalIndex]); c++)
+                    {
+                        if (structs[i].fieldName[originalIndex][c] == ',') additionalFields++;
+                    }
+                    
+                    if (additionalFields > 0)
                     {
-                        structs[i].fieldDesc[structs[i].fieldCount][k] = fieldLine[descStart + k];
-                        k++;
+                        int originalLength = -1;
+                        int lastStart;
+                        for (unsigned int c = 0; c < TextLength(structs[i].fieldName[originalIndex]) + 1; c++)
+                        {
+                            char v = structs[i].fieldName[originalIndex][c];
+                            bool isEndOfString = (v == '\0');
+                            if ((v == ',') || isEndOfString)
+                            {
+                                if (originalLength == -1)
+                                {
+                                    // Save length of original field name
+                                    // Don't truncate yet, still needed for copying
+                                    originalLength = c;
+                                }
+                                else
+                                {
+                                    // Copy field data from original field
+                                    int nameLength = c - lastStart;
+                                    MemoryCopy(structs[i].fieldName[structs[i].fieldCount], &structs[i].fieldName[originalIndex][lastStart], nameLength);
+                                    MemoryCopy(structs[i].fieldType[structs[i].fieldCount], &structs[i].fieldType[originalIndex][0], TextLength(structs[i].fieldType[originalIndex]));
+                                    MemoryCopy(structs[i].fieldDesc[structs[i].fieldCount], &structs[i].fieldDesc[originalIndex][0], TextLength(structs[i].fieldDesc[originalIndex]));
+                                    structs[i].fieldCount++;
+                                }
+                                if (!isEndOfString)
+                                {
+                                    // Skip comma and spaces
+                                    c++;
+                                    while (structs[i].fieldName[originalIndex][c] == ' ') c++;
+
+                                    // Save position for next field
+                                    lastStart = c;
+                                }
+                            }
+                        }
+                        // Set length of original field to truncate the first field name
+                        structs[i].fieldName[originalIndex][originalLength] = '\0';
                     }
 
-                    structs[i].fieldCount++;
+                    // Split field types containing multiple fields (like MemNode)
+                    additionalFields = 0;
+                    originalIndex = structs[i].fieldCount - 1;
+                    for (unsigned int c = 0; c < TextLength(structs[i].fieldType[originalIndex]); c++)
+                    {
+                        if (structs[i].fieldType[originalIndex][c] == ',') additionalFields++;
+                    }
+                    
+                    if (additionalFields > 0)
+                    {
+                        // Copy original name to last additional field
+                        structs[i].fieldCount += additionalFields;
+                        MemoryCopy(structs[i].fieldName[originalIndex + additionalFields], &structs[i].fieldName[originalIndex][0], TextLength(structs[i].fieldName[originalIndex]));
+
+                        // Copy names from type to additional fields
+                        int fieldsRemaining = additionalFields;
+                        int nameStart = -1;
+                        int nameEnd = -1;
+                        for (int k = TextLength(structs[i].fieldType[originalIndex]); k > 0; k--)
+                        {
+                            char v = structs[i].fieldType[originalIndex][k];
+                            if ((v == '*') || (v == ' ') || (v == ','))
+                            {
+                                if (nameEnd != -1) {
+                                    // Don't copy to last additional field
+                                    if (fieldsRemaining != additionalFields)
+                                    {
+                                        nameStart = k + 1;
+                                        MemoryCopy(structs[i].fieldName[originalIndex + fieldsRemaining], &structs[i].fieldType[originalIndex][nameStart], nameEnd - nameStart + 1);
+                                    }
+                                    nameEnd = -1;
+                                    fieldsRemaining--;
+                                }
+                            }
+                            else if (nameEnd == -1) nameEnd = k;
+                        }
+
+                        // Truncate original field type
+                        int fieldTypeLength = nameStart;
+                        structs[i].fieldType[originalIndex][fieldTypeLength] = '\0';
+
+                        // Set field type and description of additional fields
+                        for (int j = 1; j <= additionalFields; j++)
+                        {
+                            MemoryCopy(structs[i].fieldType[originalIndex + j], &structs[i].fieldType[originalIndex][0], fieldTypeLength);
+                            MemoryCopy(structs[i].fieldDesc[originalIndex + j], &structs[i].fieldDesc[originalIndex][0], TextLength(structs[i].fieldDesc[originalIndex]));
+                        }
+                    }
                 }
             }
 
-            j++;
+            l++;
         }
 
+        // Move array sizes from name to type
+        for (int j = 0; j < structs[i].fieldCount; j++)
+        {
+            MoveArraySize(structs[i].fieldName[j], structs[i].fieldType[j]);
+        }
     }
-
-    for (int i = 0; i < MAX_STRUCTS_TO_PARSE; i++) free(structLines[i]);
     free(structLines);
 
+    // Alias info data
+    aliases = (AliasInfo *)calloc(MAX_ALIASES_TO_PARSE, sizeof(AliasInfo));
+
+    for (int i = 0; i < aliasCount; i++)
+    {
+        // Description from previous line
+        GetDescription(lines[aliasLines[i] - 1], aliases[i].desc);
+
+        char *linePtr = lines[aliasLines[i]];
+
+        // Skip "typedef "
+        int c = 8;
+
+        // Type
+        int typeStart = c;
+        while(linePtr[c] != ' ') c++;
+        int typeLen = c - typeStart;
+        MemoryCopy(aliases[i].type, &linePtr[typeStart], typeLen);
+
+        // Skip space
+        c++;
+
+        // Name
+        int nameStart = c;
+        while(linePtr[c] != ';') c++;
+        int nameLen = c - nameStart;
+        MemoryCopy(aliases[i].name, &linePtr[nameStart], nameLen);
+
+        // Description
+        GetDescription(&linePtr[c], aliases[i].desc);
+    }
+    free(aliasLines);
+
     // Enum info data
     enums = (EnumInfo *)calloc(MAX_ENUMS_TO_PARSE, sizeof(EnumInfo));
 
     for (int i = 0; i < enumCount; i++)
     {
-        // TODO: Get enum description from lines[enumLines[i] - 1]
+
+        // Parse enum description
+        // NOTE: This is not necessarily from the line immediately before,
+        // some of the enums have extra lines between the "description"
+        // and the typedef enum
+        for (int j = enumLines[i] - 1; j > 0; j--)
+        {
+            char *linePtr = lines[j];
+            if ((linePtr[0] != '/') || (linePtr[2] != ' '))
+            {
+                GetDescription(&lines[j + 1][0], enums[i].desc);
+                break;
+            }
+        }
 
         for (int j = 1; j < MAX_ENUM_VALUES*2; j++)   // Maximum number of lines following enum first line
         {
@@ -352,7 +822,11 @@ int main(int argc, char* argv[])
                 while ((linePtr[c] != ',') &&
                        (linePtr[c] != ' ') &&
                        (linePtr[c] != '=') &&
-                       (linePtr[c] != '\0')) { enums[i].valueName[enums[i].valueCount][c] = linePtr[c]; c++; }
+                       (linePtr[c] != '\0'))
+                {
+                    enums[i].valueName[enums[i].valueCount][c] = linePtr[c];
+                    c++;
+                }
 
                 // After the name we can have:
                 //  '='  -> value is provided
@@ -367,9 +841,13 @@ int main(int argc, char* argv[])
                     //  '='  -> value is provided
                     //  ' '  -> value is equal to previous + 1, there could be a description if not '\0'
                     bool foundValue = false;
-                    while (linePtr[c] != '\0')
+                    while ((linePtr[c] != '\0') && (linePtr[c] != '/'))
                     {
-                        if (linePtr[c] == '=') { foundValue = true; break; }
+                        if (linePtr[c] == '=')
+                        {
+                            foundValue = true;
+                            break;
+                        }
                         c++;
                     }
 
@@ -377,51 +855,115 @@ int main(int argc, char* argv[])
                     {
                         if (linePtr[c + 1] == ' ') c += 2;
                         else c++;
-  
+
                         // Parse integer value
                         int n = 0;
                         char integer[16] = { 0 };
-  
+
                         while ((linePtr[c] != ',') && (linePtr[c] != ' ') && (linePtr[c] != '\0'))
                         {
                             integer[n] = linePtr[c];
                             c++; n++;
                         }
-  
+
                         if (integer[1] == 'x') enums[i].valueInteger[enums[i].valueCount] = (int)strtol(integer, NULL, 16);
                         else enums[i].valueInteger[enums[i].valueCount] = atoi(integer);
                     }
                     else enums[i].valueInteger[enums[i].valueCount] = (enums[i].valueInteger[enums[i].valueCount - 1] + 1);
-
-                    // TODO: Parse value description if any
                 }
                 else enums[i].valueInteger[enums[i].valueCount] = (enums[i].valueInteger[enums[i].valueCount - 1] + 1);
 
+                // Parse value description
+                GetDescription(&linePtr[c], enums[i].valueDesc[enums[i].valueCount]);
+
                 enums[i].valueCount++;
             }
             else if (linePtr[0] == '}')
             {
                 // Get enum name from typedef
                 int c = 0;
-                while (linePtr[2 + c] != ';') { enums[i].name[c] = linePtr[2 + c]; c++; }
+                while (linePtr[2 + c] != ';')
+                {
+                    enums[i].name[c] = linePtr[2 + c];
+                    c++;
+                }
 
                 break;  // Enum ended, break for() loop
             }
         }
     }
+    free(enumLines);
+
+    // Callback info data
+    callbacks = (FunctionInfo *)calloc(MAX_CALLBACKS_TO_PARSE, sizeof(FunctionInfo));
+
+    for (int i = 0; i < callbackCount; i++)
+    {
+        char *linePtr = lines[callbackLines[i]];
+
+        // Skip "typedef "
+        unsigned int c = 8;
+
+        // Return type
+        int retTypeStart = c;
+        while(linePtr[c] != '(') c++;
+        int retTypeLen = c - retTypeStart;
+        while(linePtr[retTypeStart + retTypeLen - 1] == ' ') retTypeLen--;
+        MemoryCopy(callbacks[i].retType, &linePtr[retTypeStart], retTypeLen);
+
+        // Skip "(*"
+        c += 2;
+
+        // Name
+        int nameStart = c;
+        while(linePtr[c] != ')') c++;
+        int nameLen = c - nameStart;
+        MemoryCopy(callbacks[i].name, &linePtr[nameStart], nameLen);
+
+        // Skip ")("
+        c += 2;
+
+        // Params
+        int paramStart = c;
+        for (; c < MAX_LINE_LENGTH; c++)
+        {
+            if ((linePtr[c] == ',') || (linePtr[c] == ')'))
+            {
+                // Get parameter type + name, extract info
+                int paramLen = c - paramStart;
+                GetDataTypeAndName(&linePtr[paramStart], paramLen, callbacks[i].paramType[callbacks[i].paramCount], callbacks[i].paramName[callbacks[i].paramCount]);
+                callbacks[i].paramCount++;
+                paramStart = c + 1;
+                while(linePtr[paramStart] == ' ') paramStart++;
+            }
+            if (linePtr[c] == ')') break;
+        }
+
+        // Description
+        GetDescription(&linePtr[c], callbacks[i].desc);
+
+        // Move array sizes from name to type
+        for (int j = 0; j < callbacks[i].paramCount; j++)
+        {
+            MoveArraySize(callbacks[i].paramName[j], callbacks[i].paramType[j]);
+        }
+    }
+    free(callbackLines);
 
     // Functions info data
     funcs = (FunctionInfo *)calloc(MAX_FUNCS_TO_PARSE, sizeof(FunctionInfo));
 
     for (int i = 0; i < funcCount; i++)
     {
+        char *linePtr = lines[funcLines[i]];
+
         int funcParamsStart = 0;
         int funcEnd = 0;
 
         // Get return type and function name from func line
-        for (int c = 0; (c < MAX_LINE_LENGTH) && (funcLines[i][c] != '\n'); c++)
+        for (int c = 0; (c < MAX_LINE_LENGTH) && (linePtr[c] != '\n'); c++)
         {
-            if (funcLines[i][c] == '(')     // Starts function parameters
+            if (linePtr[c] == '(')     // Starts function parameters
             {
                 funcParamsStart = c + 1;
 
@@ -429,7 +971,7 @@ int main(int argc, char* argv[])
                 char funcRetTypeName[128] = { 0 };
                 int dc = TextLength(apiDefine) + 1;
                 int funcRetTypeNameLen = c - dc;     // Substract `define` ("RLAPI " for raylib.h)
-                MemoryCopy(funcRetTypeName, &funcLines[i][dc], funcRetTypeNameLen);
+                MemoryCopy(funcRetTypeName, &linePtr[dc], funcRetTypeNameLen);
 
                 GetDataTypeAndName(funcRetTypeName, funcRetTypeNameLen, funcs[i].retType, funcs[i].name);
                 break;
@@ -439,30 +981,30 @@ int main(int argc, char* argv[])
         // Get parameters from func line
         for (int c = funcParamsStart; c < MAX_LINE_LENGTH; c++)
         {
-            if (funcLines[i][c] == ',')     // Starts function parameters
+            if (linePtr[c] == ',')     // Starts function parameters
             {
                 // Get parameter type + name, extract info
                 char funcParamTypeName[128] = { 0 };
                 int funcParamTypeNameLen = c - funcParamsStart;
-                MemoryCopy(funcParamTypeName, &funcLines[i][funcParamsStart], funcParamTypeNameLen);
+                MemoryCopy(funcParamTypeName, &linePtr[funcParamsStart], funcParamTypeNameLen);
 
                 GetDataTypeAndName(funcParamTypeName, funcParamTypeNameLen, funcs[i].paramType[funcs[i].paramCount], funcs[i].paramName[funcs[i].paramCount]);
 
                 funcParamsStart = c + 1;
-                if (funcLines[i][c + 1] == ' ') funcParamsStart += 1;
+                if (linePtr[c + 1] == ' ') funcParamsStart += 1;
                 funcs[i].paramCount++;      // Move to next parameter
             }
-            else if (funcLines[i][c] == ')')
+            else if (linePtr[c] == ')')
             {
                 funcEnd = c + 2;
 
                 // Check if previous word is void
-                if ((funcLines[i][c - 4] == 'v') && (funcLines[i][c - 3] == 'o') && (funcLines[i][c - 2] == 'i') && (funcLines[i][c - 1] == 'd')) break;
+                if ((linePtr[c - 4] == 'v') && (linePtr[c - 3] == 'o') && (linePtr[c - 2] == 'i') && (linePtr[c - 1] == 'd')) break;
 
                 // Get parameter type + name, extract info
                 char funcParamTypeName[128] = { 0 };
                 int funcParamTypeNameLen = c - funcParamsStart;
-                MemoryCopy(funcParamTypeName, &funcLines[i][funcParamsStart], funcParamTypeNameLen);
+                MemoryCopy(funcParamTypeName, &linePtr[funcParamsStart], funcParamTypeNameLen);
 
                 GetDataTypeAndName(funcParamTypeName, funcParamTypeNameLen, funcs[i].paramType[funcs[i].paramCount], funcs[i].paramName[funcs[i].paramCount]);
 
@@ -472,45 +1014,50 @@ int main(int argc, char* argv[])
         }
 
         // Get function description
-        for (int c = funcEnd; c < MAX_LINE_LENGTH; c++)
+        GetDescription(&linePtr[funcEnd], funcs[i].desc);
+
+        // Move array sizes from name to type
+        for (int j = 0; j < funcs[i].paramCount; j++)
         {
-            if (funcLines[i][c] == '/')
-            {
-                MemoryCopy(funcs[i].desc, &funcLines[i][c], 127);   // WARNING: Size could be too long for funcLines[i][c]?
-                break;
-            }
+            MoveArraySize(funcs[i].paramName[j], funcs[i].paramType[j]);
         }
     }
+    free(funcLines);
 
     for (int i = 0; i < linesCount; i++) free(lines[i]);
     free(lines);
-    free(funcLines);
 
     // At this point, all raylib data has been parsed!
-    //-----------------------------------------------------------------------------------------
-    // structs[] -> We have all the structs decomposed into pieces for further analysis
-    // enums[]   -> We have all the enums decomposed into pieces for further analysis
-    // funcs[]   -> We have all the functions decomposed into pieces for further analysis
-
-    // Process input file to output
-    if (outFileName[0] == '\0') MemoryCopy(outFileName, "raylib_api.txt\0", 15);
+    //----------------------------------------------------------------------------------
+    // defines[]   -> We have all the defines decomposed into pieces for further analysis
+    // structs[]   -> We have all the structs decomposed into pieces for further analysis
+    // aliases[]   -> We have all the aliases decomposed into pieces for further analysis
+    // enums[]     -> We have all the enums decomposed into pieces for further analysis
+    // callbacks[] -> We have all the callbacks decomposed into pieces for further analysis
+    // funcs[]     -> We have all the functions decomposed into pieces for further analysis
 
     printf("\nInput file:       %s", inFileName);
     printf("\nOutput file:      %s", outFileName);
     if (outputFormat == DEFAULT) printf("\nOutput format:    DEFAULT\n\n");
     else if (outputFormat == JSON) printf("\nOutput format:    JSON\n\n");
     else if (outputFormat == XML) printf("\nOutput format:    XML\n\n");
+    else if (outputFormat == LUA) printf("\nOutput format:    LUA\n\n");
+    else if (outputFormat == CODE) printf("\nOutput format:    CODE\n\n");
 
     ExportParsedData(outFileName, outputFormat);
 
-    free(funcs);
+    free(defines);
     free(structs);
+    free(aliases);
     free(enums);
+    free(callbacks);
+    free(funcs);
 }
 
 //----------------------------------------------------------------------------------
 // Module Functions Definition
 //----------------------------------------------------------------------------------
+
 // Show command line usage info
 static void ShowCommandLineInfo(void)
 {
@@ -520,24 +1067,26 @@ static void ShowCommandLineInfo(void)
     printf("//                                                                              //\n");
     printf("// more info and bugs-report: github.com/raysan5/raylib/parser                  //\n");
     printf("//                                                                              //\n");
-    printf("// Copyright (c) 2021 Ramon Santamaria (@raysan5)                               //\n");
+    printf("// Copyright (c) 2021-2022 Ramon Santamaria (@raysan5)                          //\n");
     printf("//                                                                              //\n");
     printf("//////////////////////////////////////////////////////////////////////////////////\n\n");
 
     printf("USAGE:\n\n");
-    printf("    > raylib_parser [--help] [--input <filename.h>] [--output <filename.ext>] [--format <type>] [--define <DEF>]\n");
+    printf("    > raylib_parser [--help] [--input <filename.h>] [--output <filename.ext>] [--format <type>]\n");
 
     printf("\nOPTIONS:\n\n");
     printf("    -h, --help                      : Show tool version and command line usage help\n\n");
     printf("    -i, --input <filename.h>        : Define input header file to parse.\n");
     printf("                                      NOTE: If not specified, defaults to: raylib.h\n\n");
     printf("    -o, --output <filename.ext>     : Define output file and format.\n");
-    printf("                                      Supported extensions: .txt, .json, .xml, .h\n");
+    printf("                                      Supported extensions: .txt, .json, .xml, .lua, .h\n");
     printf("                                      NOTE: If not specified, defaults to: raylib_api.txt\n\n");
     printf("    -f, --format <type>             : Define output format for parser data.\n");
-    printf("                                      Supported types: DEFAULT, JSON, XML\n\n");
-    printf("    -d, --define <DEF>              : Define functions define (i.e. RLAPI for raylib.h, RMDEF for raymath.h, etc\n");
-    printf("                                      NOTE: If not specified, defaults to: RLAPI\n\n");
+    printf("                                      Supported types: DEFAULT, JSON, XML, LUA, CODE\n\n");
+    printf("    -d, --define <DEF>              : Define functions specifiers (i.e. RLAPI for raylib.h, RMDEF for raymath.h, etc.)\n");
+    printf("                                      NOTE: If no specifier defined, defaults to: RLAPI\n\n");
+    printf("    -t, --truncate <after>          : Define string to truncate input after (i.e. \"RLGL IMPLEMENTATION\" for rlgl.h)\n");
+    printf("                                      NOTE: If not specified, the full input file is parsed.\n\n");
 
     printf("\nEXAMPLES:\n\n");
     printf("    > raylib_parser --input raylib.h --output api.json\n");
@@ -557,6 +1106,7 @@ static void ProcessCommandLine(int argc, char *argv[])
         {
             // Show info
             ShowCommandLineInfo();
+            exit(0);
         }
         else if (IsTextEqual(argv[i], "-i", 2) || IsTextEqual(argv[i], "--input", 7))
         {
@@ -584,6 +1134,8 @@ static void ProcessCommandLine(int argc, char *argv[])
                 if (IsTextEqual(argv[i + 1], "DEFAULT\0", 8)) outputFormat = DEFAULT;
                 else if (IsTextEqual(argv[i + 1], "JSON\0", 5)) outputFormat = JSON;
                 else if (IsTextEqual(argv[i + 1], "XML\0", 4)) outputFormat = XML;
+                else if (IsTextEqual(argv[i + 1], "LUA\0", 4)) outputFormat = LUA;
+                else if (IsTextEqual(argv[i + 1], "CODE\0", 4)) outputFormat = CODE;
             }
             else printf("WARNING: No format parameters provided\n");
         }
@@ -597,6 +1149,15 @@ static void ProcessCommandLine(int argc, char *argv[])
             }
             else printf("WARNING: No define key provided\n");
         }
+        else if (IsTextEqual(argv[i], "-t", 2) || IsTextEqual(argv[i], "--truncate", 10))
+        {
+            if (((i + 1) < argc) && (argv[i + 1][0] != '-'))
+            {
+                MemoryCopy(truncAfter, argv[i + 1], TextLength(argv[i + 1])); // Read truncate marker
+                truncAfter[TextLength(argv[i + 1])] = '\0';
+                i++;
+            }
+        }
     }
 }
 
@@ -687,7 +1248,7 @@ static void GetDataTypeAndName(const char *typeName, int typeNameLen, char *type
 {
     for (int k = typeNameLen; k > 0; k--)
     {
-        if (typeName[k] == ' ' && typeName[k - 1] != ',')
+        if ((typeName[k] == ' ') && (typeName[k - 1] != ','))
         {
             // Function name starts at this point (and ret type finishes at this point)
             MemoryCopy(type, typeName, k);
@@ -700,6 +1261,50 @@ static void GetDataTypeAndName(const char *typeName, int typeNameLen, char *type
             MemoryCopy(name, typeName + k + 1, typeNameLen - k - 1);
             break;
         }
+        else if ((typeName[k] == '.') && (typeNameLen == 3)) // Handle varargs ...);
+        {
+            MemoryCopy(type, "...", 3);
+            MemoryCopy(name, "args", 4);
+            break;
+        }
+    }
+}
+
+// Get comment from a line, do nothing if no comment in line
+static void GetDescription(const char *line, char *description)
+{
+    int c = 0;
+    int descStart = -1;
+    int lastSlash = -2;
+    bool isValid = false;
+    while (line[c] != '\0')
+    {
+        if (isValid && (descStart == -1) && (line[c] != ' ')) descStart = c;
+        else if (line[c] == '/')
+        {
+            if (lastSlash == c - 1) isValid = true;
+            lastSlash = c;
+        }
+        c++;
+    }
+    if (descStart != -1) MemoryCopy(description, &line[descStart], c - descStart);
+}
+
+// Move array size from name to type
+static void MoveArraySize(char *name, char *type)
+{
+    int nameLength = TextLength(name);
+    if (name[nameLength - 1] == ']')
+    {
+        for (int k = nameLength; k > 0; k--)
+        {
+            if (name[k] == '[')
+            {
+                int sizeLength = nameLength - k;
+                MemoryCopy(&type[TextLength(type)], &name[k], sizeLength);
+                name[k] = '\0';
+            }
+        }
     }
 }
 
@@ -713,6 +1318,37 @@ static unsigned int TextLength(const char *text)
     return length;
 }
 
+// Compare two text strings, requires number of characters to compare
+static bool IsTextEqual(const char *text1, const char *text2, unsigned int count)
+{
+    bool result = true;
+
+    for (unsigned int i = 0; i < count; i++)
+    {
+        if (text1[i] != text2[i])
+        {
+            result = false;
+            break;
+        }
+    }
+
+    return result;
+}
+
+// Find first text occurrence within a string
+int TextFindIndex(const char *text, const char *find)
+{
+    int textLen = TextLength(text);
+    int findLen = TextLength(find);
+
+    for (int i = 0; i <= textLen - findLen; i++)
+    {
+        if (IsTextEqual(&text[i], find, findLen)) return i;
+    }
+
+    return -1;
+}
+
 // Custom memcpy() to avoid <string.h>
 static void MemoryCopy(void *dest, const void *src, unsigned int count)
 {
@@ -722,30 +1358,50 @@ static void MemoryCopy(void *dest, const void *src, unsigned int count)
     for (unsigned int i = 0; i < count; i++) destPtr[i] = srcPtr[i];
 }
 
-// Compare two text strings, requires number of characters to compare
-static bool IsTextEqual(const char *text1, const char *text2, unsigned int count)
+// Escape backslashes in a string, writing the escaped string into a static buffer
+static char *EscapeBackslashes(char *text)
 {
-    bool result = true;
+    static char buffer[256] = { 0 };
 
-    for (unsigned int i = 0; i < count; i++)
+    int count = 0;
+
+    for (int i = 0; (text[i] != '\0') && (i < 255); i++, count++)
     {
-        if (text1[i] != text2[i])
+        buffer[count] = text[i];
+
+        if (text[i] == '\\')
         {
-            result = false;
-            break;
+            buffer[count + 1] = '\\';
+            count++;
         }
     }
 
-    return result;
+    buffer[count] = '\0';
+
+    return buffer;
 }
 
-// Search and replace a character within a string.
-static char* CharReplace(char* text, char search, char replace)
+// Get string of define type
+static const char *StrDefineType(DefineType type)
 {
-    for (int i = 0; text[i] != '\0'; i++)
-        if (text[i] == search)
-            text[i] = replace;
-    return text;
+    switch (type)
+    {
+        case UNKNOWN:     return "UNKNOWN";
+        case GUARD:       return "GUARD";
+        case MACRO:       return "MACRO";
+        case INT:         return "INT";
+        case INT_MATH:    return "INT_MATH";
+        case LONG:        return "LONG";
+        case LONG_MATH:   return "LONG_MATH";
+        case FLOAT:       return "FLOAT";
+        case FLOAT_MATH:  return "FLOAT_MATH";
+        case DOUBLE:      return "DOUBLE";
+        case DOUBLE_MATH: return "DOUBLE_MATH";
+        case CHAR:        return "CHAR";
+        case STRING:      return "STRING";
+        case COLOR:       return "COLOR";
+    }
+    return "";
 }
 
 /*
@@ -809,14 +1465,40 @@ static void ExportParsedData(const char *fileName, int format)
     {
         case DEFAULT:
         {
+            // Print defines info
+            fprintf(outFile, "\nDefines found: %i\n\n", defineCount);
+            for (int i = 0; i < defineCount; i++)
+            {
+                fprintf(outFile, "Define %03i: %s\n", i + 1, defines[i].name);
+                fprintf(outFile, "  Name: %s\n", defines[i].name);
+                fprintf(outFile, "  Type: %s\n", StrDefineType(defines[i].type));
+                fprintf(outFile, "  Value: %s\n", defines[i].value);
+                fprintf(outFile, "  Description: %s\n", defines[i].desc);
+            }
+
             // Print structs info
             fprintf(outFile, "\nStructures found: %i\n\n", structCount);
             for (int i = 0; i < structCount; i++)
             {
                 fprintf(outFile, "Struct %02i: %s (%i fields)\n", i + 1, structs[i].name, structs[i].fieldCount);
                 fprintf(outFile, "  Name: %s\n", structs[i].name);
-                fprintf(outFile, "  Description: %s\n", structs[i].desc + 3);
-                for (int f = 0; f < structs[i].fieldCount; f++) fprintf(outFile, "  Field[%i]: %s %s %s\n", f + 1, structs[i].fieldType[f], structs[i].fieldName[f], structs[i].fieldDesc[f]);
+                fprintf(outFile, "  Description: %s\n", structs[i].desc);
+                for (int f = 0; f < structs[i].fieldCount; f++)
+                {
+                    fprintf(outFile, "  Field[%i]: %s %s ", f + 1, structs[i].fieldType[f], structs[i].fieldName[f]);
+                    if (structs[i].fieldDesc[f][0]) fprintf(outFile, "// %s\n", structs[i].fieldDesc[f]);
+                    else fprintf(outFile, "\n");
+                }
+            }
+
+            // Print aliases info
+            fprintf(outFile, "\nAliases found: %i\n\n", aliasCount);
+            for (int i = 0; i < aliasCount; i++)
+            {
+                fprintf(outFile, "Alias %03i: %s\n", i + 1, aliases[i].name);
+                fprintf(outFile, "  Type: %s\n", aliases[i].type);
+                fprintf(outFile, "  Name: %s\n", aliases[i].name);
+                fprintf(outFile, "  Description: %s\n", aliases[i].desc);
             }
 
             // Print enums info
@@ -825,10 +1507,22 @@ static void ExportParsedData(const char *fileName, int format)
             {
                 fprintf(outFile, "Enum %02i: %s (%i values)\n", i + 1, enums[i].name, enums[i].valueCount);
                 fprintf(outFile, "  Name: %s\n", enums[i].name);
-                fprintf(outFile, " Description: %s\n", enums[i].desc + 3);
+                fprintf(outFile, "  Description: %s\n", enums[i].desc);
                 for (int e = 0; e < enums[i].valueCount; e++) fprintf(outFile, "  Value[%s]: %i\n", enums[i].valueName[e], enums[i].valueInteger[e]);
             }
 
+            // Print callbacks info
+            fprintf(outFile, "\nCallbacks found: %i\n\n", callbackCount);
+            for (int i = 0; i < callbackCount; i++)
+            {
+                fprintf(outFile, "Callback %03i: %s() (%i input parameters)\n", i + 1, callbacks[i].name, callbacks[i].paramCount);
+                fprintf(outFile, "  Name: %s\n", callbacks[i].name);
+                fprintf(outFile, "  Return type: %s\n", callbacks[i].retType);
+                fprintf(outFile, "  Description: %s\n", callbacks[i].desc);
+                for (int p = 0; p < callbacks[i].paramCount; p++) fprintf(outFile, "  Param[%i]: %s (type: %s)\n", p + 1, callbacks[i].paramName[p], callbacks[i].paramType[p]);
+                if (callbacks[i].paramCount == 0) fprintf(outFile, "  No input parameters\n");
+            }
+
             // Print functions info
             fprintf(outFile, "\nFunctions found: %i\n\n", funcCount);
             for (int i = 0; i < funcCount; i++)
@@ -836,7 +1530,7 @@ static void ExportParsedData(const char *fileName, int format)
                 fprintf(outFile, "Function %03i: %s() (%i input parameters)\n", i + 1, funcs[i].name, funcs[i].paramCount);
                 fprintf(outFile, "  Name: %s\n", funcs[i].name);
                 fprintf(outFile, "  Return type: %s\n", funcs[i].retType);
-                fprintf(outFile, "  Description: %s\n", funcs[i].desc + 3);
+                fprintf(outFile, "  Description: %s\n", funcs[i].desc);
                 for (int p = 0; p < funcs[i].paramCount; p++) fprintf(outFile, "  Param[%i]: %s (type: %s)\n", p + 1, funcs[i].paramName[p], funcs[i].paramType[p]);
                 if (funcs[i].paramCount == 0) fprintf(outFile, "  No input parameters\n");
             }
@@ -845,20 +1539,51 @@ static void ExportParsedData(const char *fileName, int format)
         {
             fprintf(outFile, "{\n");
 
+            // Print defines info
+            fprintf(outFile, "  \"defines\": [\n");
+            for (int i = 0; i < defineCount; i++)
+            {
+                fprintf(outFile, "    {\n");
+                fprintf(outFile, "      \"name\": \"%s\",\n", defines[i].name);
+                fprintf(outFile, "      \"type\": \"%s\",\n", StrDefineType(defines[i].type));
+                if (defines[i].isHex) // INT or LONG
+                {
+                    fprintf(outFile, "      \"value\": %ld,\n", strtol(defines[i].value, NULL, 16));
+                }
+                else if ((defines[i].type == INT) ||
+                         (defines[i].type == LONG) ||
+                         (defines[i].type == FLOAT) ||
+                         (defines[i].type == DOUBLE) ||
+                         (defines[i].type == STRING))
+                {
+                    fprintf(outFile, "      \"value\": %s,\n", defines[i].value);
+                }
+                else
+                {
+                    fprintf(outFile, "      \"value\": \"%s\",\n", defines[i].value);
+                }
+                fprintf(outFile, "      \"description\": \"%s\"\n", defines[i].desc);
+                fprintf(outFile, "    }");
+
+                if (i < defineCount - 1) fprintf(outFile, ",\n");
+                else fprintf(outFile, "\n");
+            }
+            fprintf(outFile, "  ],\n");
+
             // Print structs info
             fprintf(outFile, "  \"structs\": [\n");
             for (int i = 0; i < structCount; i++)
             {
                 fprintf(outFile, "    {\n");
                 fprintf(outFile, "      \"name\": \"%s\",\n", structs[i].name);
-                fprintf(outFile, "      \"description\": \"%s\",\n", structs[i].desc);
+                fprintf(outFile, "      \"description\": \"%s\",\n", EscapeBackslashes(structs[i].desc));
                 fprintf(outFile, "      \"fields\": [\n");
                 for (int f = 0; f < structs[i].fieldCount; f++)
                 {
                     fprintf(outFile, "        {\n");
-                    fprintf(outFile, "          \"name\": \"%s\",\n", structs[i].fieldName[f]),
-                    fprintf(outFile, "          \"type\": \"%s\",\n", structs[i].fieldType[f]),
-                    fprintf(outFile, "          \"description\": \"%s\"\n", structs[i].fieldDesc[f] + 3),
+                    fprintf(outFile, "          \"type\": \"%s\",\n", structs[i].fieldType[f]);
+                    fprintf(outFile, "          \"name\": \"%s\",\n", structs[i].fieldName[f]);
+                    fprintf(outFile, "          \"description\": \"%s\"\n", EscapeBackslashes(structs[i].fieldDesc[f]));
                     fprintf(outFile, "        }");
                     if (f < structs[i].fieldCount - 1) fprintf(outFile, ",\n");
                     else fprintf(outFile, "\n");
@@ -870,20 +1595,35 @@ static void ExportParsedData(const char *fileName, int format)
             }
             fprintf(outFile, "  ],\n");
 
+            // Print aliases info
+            fprintf(outFile, "  \"aliases\": [\n");
+            for (int i = 0; i < aliasCount; i++)
+            {
+                fprintf(outFile, "    {\n");
+                fprintf(outFile, "      \"type\": \"%s\",\n", aliases[i].type);
+                fprintf(outFile, "      \"name\": \"%s\",\n", aliases[i].name);
+                fprintf(outFile, "      \"description\": \"%s\"\n", aliases[i].desc);
+                fprintf(outFile, "    }");
+
+                if (i < aliasCount - 1) fprintf(outFile, ",\n");
+                else fprintf(outFile, "\n");
+            }
+            fprintf(outFile, "  ],\n");
+
             // Print enums info
             fprintf(outFile, "  \"enums\": [\n");
             for (int i = 0; i < enumCount; i++)
             {
                 fprintf(outFile, "    {\n");
                 fprintf(outFile, "      \"name\": \"%s\",\n", enums[i].name);
-                fprintf(outFile, "      \"description\": \"%s\",\n", enums[i].desc + 3);
+                fprintf(outFile, "      \"description\": \"%s\",\n", EscapeBackslashes(enums[i].desc));
                 fprintf(outFile, "      \"values\": [\n");
                 for (int e = 0; e < enums[i].valueCount; e++)
                 {
                     fprintf(outFile, "        {\n");
-                    fprintf(outFile, "          \"name\": \"%s\",\n", enums[i].valueName[e]),
-                    fprintf(outFile, "          \"value\": %i,\n", enums[i].valueInteger[e]),
-                    fprintf(outFile, "          \"description\": \"%s\"\n", enums[i].valueDesc[e] + 3),
+                    fprintf(outFile, "          \"name\": \"%s\",\n", enums[i].valueName[e]);
+                    fprintf(outFile, "          \"value\": %i,\n", enums[i].valueInteger[e]);
+                    fprintf(outFile, "          \"description\": \"%s\"\n", EscapeBackslashes(enums[i].valueDesc[e]));
                     fprintf(outFile, "        }");
                     if (e < enums[i].valueCount - 1) fprintf(outFile, ",\n");
                     else fprintf(outFile, "\n");
@@ -895,26 +1635,60 @@ static void ExportParsedData(const char *fileName, int format)
             }
             fprintf(outFile, "  ],\n");
 
+            // Print callbacks info
+            fprintf(outFile, "  \"callbacks\": [\n");
+            for (int i = 0; i < callbackCount; i++)
+            {
+                fprintf(outFile, "    {\n");
+                fprintf(outFile, "      \"name\": \"%s\",\n", callbacks[i].name);
+                fprintf(outFile, "      \"description\": \"%s\",\n", EscapeBackslashes(callbacks[i].desc));
+                fprintf(outFile, "      \"returnType\": \"%s\"", callbacks[i].retType);
+
+                if (callbacks[i].paramCount == 0) fprintf(outFile, "\n");
+                else
+                {
+                    fprintf(outFile, ",\n      \"params\": [\n");
+                    for (int p = 0; p < callbacks[i].paramCount; p++)
+                    {
+                        fprintf(outFile, "        {\n");
+                        fprintf(outFile, "          \"type\": \"%s\",\n", callbacks[i].paramType[p]);
+                        fprintf(outFile, "          \"name\": \"%s\"\n", callbacks[i].paramName[p]);
+                        fprintf(outFile, "        }");
+                        if (p < callbacks[i].paramCount - 1) fprintf(outFile, ",\n");
+                        else fprintf(outFile, "\n");
+                    }
+                    fprintf(outFile, "      ]\n");
+                }
+                fprintf(outFile, "    }");
+
+                if (i < callbackCount - 1) fprintf(outFile, ",\n");
+                else fprintf(outFile, "\n");
+            }
+            fprintf(outFile, "  ],\n");
+
             // Print functions info
             fprintf(outFile, "  \"functions\": [\n");
             for (int i = 0; i < funcCount; i++)
             {
                 fprintf(outFile, "    {\n");
                 fprintf(outFile, "      \"name\": \"%s\",\n", funcs[i].name);
-                fprintf(outFile, "      \"description\": \"%s\",\n", CharReplace(funcs[i].desc, '\\', ' ') + 3);
+                fprintf(outFile, "      \"description\": \"%s\",\n", EscapeBackslashes(funcs[i].desc));
                 fprintf(outFile, "      \"returnType\": \"%s\"", funcs[i].retType);
 
                 if (funcs[i].paramCount == 0) fprintf(outFile, "\n");
                 else
                 {
-                    fprintf(outFile, ",\n      \"params\": {\n");
+                    fprintf(outFile, ",\n      \"params\": [\n");
                     for (int p = 0; p < funcs[i].paramCount; p++)
                     {
-                        fprintf(outFile, "        \"%s\": \"%s\"", funcs[i].paramName[p], funcs[i].paramType[p]);
+                        fprintf(outFile, "        {\n");
+                        fprintf(outFile, "          \"type\": \"%s\",\n", funcs[i].paramType[p]);
+                        fprintf(outFile, "          \"name\": \"%s\"\n", funcs[i].paramName[p]);
+                        fprintf(outFile, "        }");
                         if (p < funcs[i].paramCount - 1) fprintf(outFile, ",\n");
                         else fprintf(outFile, "\n");
                     }
-                    fprintf(outFile, "      }\n");
+                    fprintf(outFile, "      ]\n");
                 }
                 fprintf(outFile, "    }");
 
@@ -930,18 +1704,30 @@ static void ExportParsedData(const char *fileName, int format)
             /*
             <?xml version="1.0" encoding="Windows-1252" ?>
             <raylibAPI>
+                <Defines count="">
+                    <Define name="" type="" value="" desc="" />
+                </Defines>
                 <Structs count="">
                     <Struct name="" fieldCount="" desc="">
-                        <Field type="" name="" desc="">
-                        <Field type="" name="" desc="">
+                        <Field type="" name="" desc="" />
+                        <Field type="" name="" desc="" />
                     </Struct>
                 <Structs>
+                <Aliases count="">
+                    <Alias type="" name="" desc="" />
+                </Aliases>
                 <Enums count="">
                     <Enum name="" valueCount="" desc="">
-                        <Value name="" integer="" desc="">
-                        <Value name="" integer="" desc="">
+                        <Value name="" integer="" desc="" />
+                        <Value name="" integer="" desc="" />
                     </Enum>
                 </Enums>
+                <Callbacks count="">
+                    <Callback name="" retType="" paramCount="" desc="">
+                        <Param type="" name="" desc="" />
+                        <Param type="" name="" desc="" />
+                    </Callback>
+                </Callbacks>
                 <Functions count="">
                     <Function name="" retType="" paramCount="" desc="">
                         <Param type="" name="" desc="" />
@@ -954,40 +1740,78 @@ static void ExportParsedData(const char *fileName, int format)
             fprintf(outFile, "<?xml version=\"1.0\" encoding=\"Windows-1252\" ?>\n");
             fprintf(outFile, "<raylibAPI>\n");
 
+            // Print defines info
+            fprintf(outFile, "    <Defines count=\"%i\">\n", defineCount);
+            for (int i = 0; i < defineCount; i++)
+            {
+                fprintf(outFile, "        <Define name=\"%s\" type=\"%s\" ", defines[i].name, StrDefineType(defines[i].type));
+                if (defines[i].type == STRING)
+                {
+                    fprintf(outFile, "value=%s", defines[i].value);
+                }
+                else
+                {
+                    fprintf(outFile, "value=\"%s\"", defines[i].value);
+                }
+                fprintf(outFile, " desc=\"%s\" />\n", defines[i].desc);
+            }
+            fprintf(outFile, "    </Defines>\n");
+
             // Print structs info
             fprintf(outFile, "    <Structs count=\"%i\">\n", structCount);
             for (int i = 0; i < structCount; i++)
             {
-                fprintf(outFile, "        <Struct name=\"%s\" fieldCount=\"%i\" desc=\"%s\">\n", structs[i].name, structs[i].fieldCount, structs[i].desc + 3);
+                fprintf(outFile, "        <Struct name=\"%s\" fieldCount=\"%i\" desc=\"%s\">\n", structs[i].name, structs[i].fieldCount, structs[i].desc);
                 for (int f = 0; f < structs[i].fieldCount; f++)
                 {
-                    fprintf(outFile, "            <Field type=\"%s\" name=\"%s\" desc=\"%s\" />\n", structs[i].fieldType[f], structs[i].fieldName[f], structs[i].fieldDesc[f] + 3);
+                    fprintf(outFile, "            <Field type=\"%s\" name=\"%s\" desc=\"%s\" />\n", structs[i].fieldType[f], structs[i].fieldName[f], structs[i].fieldDesc[f]);
                 }
                 fprintf(outFile, "        </Struct>\n");
             }
             fprintf(outFile, "    </Structs>\n");
 
+            // Print aliases info
+            fprintf(outFile, "    <Aliases count=\"%i\">\n", aliasCount);
+            for (int i = 0; i < aliasCount; i++)
+            {
+                fprintf(outFile, "        <Alias type=\"%s\" name=\"%s\" desc=\"%s\" />\n", aliases[i].name, aliases[i].type, aliases[i].desc);
+            }
+            fprintf(outFile, "    </Aliases>\n");
+
             // Print enums info
             fprintf(outFile, "    <Enums count=\"%i\">\n", enumCount);
             for (int i = 0; i < enumCount; i++)
             {
-                fprintf(outFile, "        <Enum name=\"%s\" valueCount=\"%i\" desc=\"%s\">\n", enums[i].name, enums[i].valueCount, enums[i].desc + 3);
+                fprintf(outFile, "        <Enum name=\"%s\" valueCount=\"%i\" desc=\"%s\">\n", enums[i].name, enums[i].valueCount, enums[i].desc);
                 for (int v = 0; v < enums[i].valueCount; v++)
                 {
-                    fprintf(outFile, "            <Value name=\"%s\" integer=\"%i\" desc=\"%s\" />\n", enums[i].valueName[v], enums[i].valueInteger[v], enums[i].valueDesc[v] + 3);
+                    fprintf(outFile, "            <Value name=\"%s\" integer=\"%i\" desc=\"%s\" />\n", enums[i].valueName[v], enums[i].valueInteger[v], enums[i].valueDesc[v]);
                 }
                 fprintf(outFile, "        </Enum>\n");
             }
             fprintf(outFile, "    </Enums>\n");
 
+            // Print callbacks info
+            fprintf(outFile, "    <Callbacks count=\"%i\">\n", callbackCount);
+            for (int i = 0; i < callbackCount; i++)
+            {
+                fprintf(outFile, "        <Callback name=\"%s\" retType=\"%s\" paramCount=\"%i\" desc=\"%s\">\n", callbacks[i].name, callbacks[i].retType, callbacks[i].paramCount, callbacks[i].desc);
+                for (int p = 0; p < callbacks[i].paramCount; p++)
+                {
+                    fprintf(outFile, "            <Param type=\"%s\" name=\"%s\" desc=\"%s\" />\n", callbacks[i].paramType[p], callbacks[i].paramName[p], callbacks[i].paramDesc[p]);
+                }
+                fprintf(outFile, "        </Callback>\n");
+            }
+            fprintf(outFile, "    </Callbacks>\n");
+
             // Print functions info
             fprintf(outFile, "    <Functions count=\"%i\">\n", funcCount);
             for (int i = 0; i < funcCount; i++)
             {
-                fprintf(outFile, "        <Function name=\"%s\" retType=\"%s\" paramCount=\"%i\" desc=\"%s\">\n", funcs[i].name, funcs[i].retType, funcs[i].paramCount, funcs[i].desc + 3);
+                fprintf(outFile, "        <Function name=\"%s\" retType=\"%s\" paramCount=\"%i\" desc=\"%s\">\n", funcs[i].name, funcs[i].retType, funcs[i].paramCount, funcs[i].desc);
                 for (int p = 0; p < funcs[i].paramCount; p++)
                 {
-                    fprintf(outFile, "            <Param type=\"%s\" name=\"%s\" desc=\"%s\" />\n", funcs[i].paramType[p], funcs[i].paramName[p], funcs[i].paramDesc[p] + 3);
+                    fprintf(outFile, "            <Param type=\"%s\" name=\"%s\" desc=\"%s\" />\n", funcs[i].paramType[p], funcs[i].paramName[p], funcs[i].paramDesc[p]);
                 }
                 fprintf(outFile, "        </Function>\n");
             }
@@ -996,6 +1820,160 @@ static void ExportParsedData(const char *fileName, int format)
             fprintf(outFile, "</raylibAPI>\n");
 
         } break;
+        case LUA:
+        {
+            fprintf(outFile, "return {\n");
+
+            // Print defines info
+            fprintf(outFile, "  defines = {\n");
+            for (int i = 0; i < defineCount; i++)
+            {
+                fprintf(outFile, "    {\n");
+                fprintf(outFile, "      name = \"%s\",\n", defines[i].name);
+                fprintf(outFile, "      type = \"%s\",\n", StrDefineType(defines[i].type));
+                if ((defines[i].type == INT) ||
+                    (defines[i].type == LONG) ||
+                    (defines[i].type == FLOAT) ||
+                    (defines[i].type == DOUBLE) ||
+                    (defines[i].type == STRING))
+                {
+                    fprintf(outFile, "      value = %s,\n", defines[i].value);
+                }
+                else
+                {
+                    fprintf(outFile, "      value = \"%s\",\n", defines[i].value);
+                }
+                fprintf(outFile, "      description = \"%s\"\n", defines[i].desc);
+                fprintf(outFile, "    }");
+
+                if (i < defineCount - 1) fprintf(outFile, ",\n");
+                else fprintf(outFile, "\n");
+            }
+            fprintf(outFile, "  },\n");
+
+            // Print structs info
+            fprintf(outFile, "  structs = {\n");
+            for (int i = 0; i < structCount; i++)
+            {
+                fprintf(outFile, "    {\n");
+                fprintf(outFile, "      name = \"%s\",\n", structs[i].name);
+                fprintf(outFile, "      description = \"%s\",\n", EscapeBackslashes(structs[i].desc));
+                fprintf(outFile, "      fields = {\n");
+                for (int f = 0; f < structs[i].fieldCount; f++)
+                {
+                    fprintf(outFile, "        {\n");
+                    fprintf(outFile, "          type = \"%s\",\n", structs[i].fieldType[f]);
+                    fprintf(outFile, "          name = \"%s\",\n", structs[i].fieldName[f]);
+                    fprintf(outFile, "          description = \"%s\"\n", EscapeBackslashes(structs[i].fieldDesc[f]));
+                    fprintf(outFile, "        }");
+                    if (f < structs[i].fieldCount - 1) fprintf(outFile, ",\n");
+                    else fprintf(outFile, "\n");
+                }
+                fprintf(outFile, "      }\n");
+                fprintf(outFile, "    }");
+                if (i < structCount - 1) fprintf(outFile, ",\n");
+                else fprintf(outFile, "\n");
+            }
+            fprintf(outFile, "  },\n");
+
+            // Print aliases info
+            fprintf(outFile, "  aliases = {\n");
+            for (int i = 0; i < aliasCount; i++)
+            {
+                fprintf(outFile, "    {\n");
+                fprintf(outFile, "      type = \"%s\",\n", aliases[i].type);
+                fprintf(outFile, "      name = \"%s\",\n", aliases[i].name);
+                fprintf(outFile, "      description = \"%s\"\n", aliases[i].desc);
+                fprintf(outFile, "    }");
+
+                if (i < aliasCount - 1) fprintf(outFile, ",\n");
+                else fprintf(outFile, "\n");
+            }
+            fprintf(outFile, "  },\n");
+
+            // Print enums info
+            fprintf(outFile, "  enums = {\n");
+            for (int i = 0; i < enumCount; i++)
+            {
+                fprintf(outFile, "    {\n");
+                fprintf(outFile, "      name = \"%s\",\n", enums[i].name);
+                fprintf(outFile, "      description = \"%s\",\n", EscapeBackslashes(enums[i].desc));
+                fprintf(outFile, "      values = {\n");
+                for (int e = 0; e < enums[i].valueCount; e++)
+                {
+                    fprintf(outFile, "        {\n");
+                    fprintf(outFile, "          name = \"%s\",\n", enums[i].valueName[e]);
+                    fprintf(outFile, "          value = %i,\n", enums[i].valueInteger[e]);
+                    fprintf(outFile, "          description = \"%s\"\n", EscapeBackslashes(enums[i].valueDesc[e]));
+                    fprintf(outFile, "        }");
+                    if (e < enums[i].valueCount - 1) fprintf(outFile, ",\n");
+                    else fprintf(outFile, "\n");
+                }
+                fprintf(outFile, "      }\n");
+                fprintf(outFile, "    }");
+                if (i < enumCount - 1) fprintf(outFile, ",\n");
+                else fprintf(outFile, "\n");
+            }
+            fprintf(outFile, "  },\n");
+
+            // Print callbacks info
+            fprintf(outFile, "  callbacks = {\n");
+            for (int i = 0; i < callbackCount; i++)
+            {
+                fprintf(outFile, "    {\n");
+                fprintf(outFile, "      name = \"%s\",\n", callbacks[i].name);
+                fprintf(outFile, "      description = \"%s\",\n", EscapeBackslashes(callbacks[i].desc));
+                fprintf(outFile, "      returnType = \"%s\"", callbacks[i].retType);
+
+                if (callbacks[i].paramCount == 0) fprintf(outFile, "\n");
+                else
+                {
+                    fprintf(outFile, ",\n      params = {\n");
+                    for (int p = 0; p < callbacks[i].paramCount; p++)
+                    {
+                        fprintf(outFile, "        {type = \"%s\", name = \"%s\"}", callbacks[i].paramType[p], callbacks[i].paramName[p]);
+                        if (p < callbacks[i].paramCount - 1) fprintf(outFile, ",\n");
+                        else fprintf(outFile, "\n");
+                    }
+                    fprintf(outFile, "      }\n");
+                }
+                fprintf(outFile, "    }");
+
+                if (i < callbackCount - 1) fprintf(outFile, ",\n");
+                else fprintf(outFile, "\n");
+            }
+            fprintf(outFile, "  },\n");
+
+            // Print functions info
+            fprintf(outFile, "  functions = {\n");
+            for (int i = 0; i < funcCount; i++)
+            {
+                fprintf(outFile, "    {\n");
+                fprintf(outFile, "      name = \"%s\",\n", funcs[i].name);
+                fprintf(outFile, "      description = \"%s\",\n", EscapeBackslashes(funcs[i].desc));
+                fprintf(outFile, "      returnType = \"%s\"", funcs[i].retType);
+
+                if (funcs[i].paramCount == 0) fprintf(outFile, "\n");
+                else
+                {
+                    fprintf(outFile, ",\n      params = {\n");
+                    for (int p = 0; p < funcs[i].paramCount; p++)
+                    {
+                        fprintf(outFile, "        {type = \"%s\", name = \"%s\"}", funcs[i].paramType[p], funcs[i].paramName[p]);
+                        if (p < funcs[i].paramCount - 1) fprintf(outFile, ",\n");
+                        else fprintf(outFile, "\n");
+                    }
+                    fprintf(outFile, "      }\n");
+                }
+                fprintf(outFile, "    }");
+
+                if (i < funcCount - 1) fprintf(outFile, ",\n");
+                else fprintf(outFile, "\n");
+            }
+            fprintf(outFile, "  }\n");
+            fprintf(outFile, "}\n");
+        } break;
+        case CODE:
         default: break;
     }