Init commit v1.0

1 files changed, 2000 insertions, 0 deletions

diff --git a/deps/raylib/parser/raylib_parser.c b/deps/raylib/parser/raylib_parser.c
new file mode 100644
index 0000000..94a7155
--- /dev/null
+++ b/deps/raylib/parser/raylib_parser.c
@@ -0,0 +1,2000 @@
+/**********************************************************************************************
+
+    raylib API parser
+
+    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 DefineInfo
+     - struct StructInfo
+     - struct AliasInfo
+     - struct EnumInfo
+     - struct FunctionInfo
+
+    CONSTRAINTS:
+
+    This parser is specifically designed to work with raylib.h, so, it has some constraints:
+
+     - Functions are expected as a single line with the following structure:
+
+       <retType> <name>(<paramType[0]> <paramName[0]>, <paramType[1]> <paramName[1]>);  <desc>
+
+       Be careful with functions broken into several lines, it breaks the process!
+
+     - Structures are expected as several lines with the following form:
+
+       <desc>
+       typedef struct <name> {
+           <fieldType[0]> <fieldName[0]>;  <fieldDesc[0]>
+           <fieldType[1]> <fieldName[1]>;  <fieldDesc[1]>
+           <fieldType[2]> <fieldName[2]>;  <fieldDesc[2]>
+       } <name>;
+
+     - Enums are expected as several lines with the following form:
+
+       <desc>
+       typedef enum {
+           <valueName[0]> = <valueInteger[0]>, <valueDesc[0]>
+           <valueName[1]>,
+           <valueName[2]>, <valueDesc[2]>
+           <valueName[3]>  <valueDesc[3]>
+       } <name>;
+
+       NOTE: Multiple options are supported for enums:
+          - If value is not provided, (<valueInteger[i -1]> + 1) is assigned
+          - Value description can be provided or not
+
+    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
+
+    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-2024 Ramon Santamaria (@raysan5)
+
+**********************************************************************************************/
+
+#define _CRT_SECURE_NO_WARNINGS
+
+#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_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      1024    // Maximum number of functions to parse
+
+#define MAX_LINE_LENGTH         1024    // Maximum length of one line (including comments)
+
+#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
+//----------------------------------------------------------------------------------
+
+// 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[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[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][128];   // Value description
+} EnumInfo;
+
+// Function info data
+typedef struct FunctionInfo {
+    char name[64];              // Function name
+    char desc[512];             // 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, LUA, CODE } OutputFormat;
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+static int defineCount = 0;
+static int structCount = 0;
+static int aliasCount = 0;
+static int enumCount = 0;
+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 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 int outputFormat = DEFAULT;
+
+// NOTE: Max length depends on OS, in Windows MAX_PATH = 256
+static char inFileName[512] = { 0 };        // Input file name (required in case of drag & drop over executable)
+static char outFileName[512] = { 0 };       // Output file name (required for file save/export)
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+static void ShowCommandLineInfo(void);                      // Show command line usage info
+static void ProcessCommandLine(int argc, char *argv[]);     // Process command line input
+
+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 *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);
+
+    const char *raylibhPath = "../src/raylib.h\0";
+    const char *raylibapiPath = "raylib_api.txt\0";
+    const char *rlapiPath = "RLAPI\0";
+    if (inFileName[0] == '\0') MemoryCopy(inFileName, raylibhPath, TextLength(raylibhPath) + 1);
+    if (outFileName[0] == '\0') MemoryCopy(outFileName, raylibapiPath, TextLength(raylibapiPath) + 1);
+    if (apiDefine[0] == '\0') MemoryCopy(apiDefine, rlapiPath, TextLength(rlapiPath) + 1);
+
+    int length = 0;
+    char *buffer = LoadFileText(inFileName, &length);
+
+    if (buffer == NULL)
+    {
+        printf("Could not read input file: %s\n", inFileName);
+        return 1;
+    }
+
+    // Preprocess buffer to get separate lines
+    // NOTE: GetTextLines() also removes leading spaces/tabs
+    int linesCount = 0;
+    char **lines = GetTextLines(buffer, length, &linesCount);
+
+    // 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 line indices
+    int *structLines = (int *)malloc(MAX_STRUCTS_TO_PARSE*sizeof(int));
+
+    // 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 define lines
+    for (int i = 0; i < linesCount; i++)
+    {
+        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 the line position in the array of lines,
+            // so, we can scan that position and following lines
+            defineLines[defineCount] = i;
+            defineCount++;
+        }
+    }
+
+    // Read struct lines
+    for (int i = 0; i < linesCount; i++)
+    {
+        // 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))
+        {
+            bool validStruct = IsTextEqual(lines[i + 1], "struct", 6);
+            if (!validStruct)
+            {
+                for (int c = 0; c < MAX_LINE_LENGTH; c++)
+                {
+                    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++;
+        }
+    }
+
+    // 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;
+
+            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++;
+        }
+    }
+
+    // Read enum lines
+    for (int i = 0; i < linesCount; i++)
+    {
+        // Read enum line
+        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
+            enumLines[enumCount] = i;
+            enumCount++;
+        }
+    }
+
+    // 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++)
+    {
+        char **linesPtr = &lines[structLines[i]];
+
+        // Parse struct description
+        GetDescription(linesPtr[-1], structs[i].desc);
+
+        // Get struct name: typedef struct name {
+        const int TDS_LEN = 15; // length of "typedef struct "
+        for (int c = TDS_LEN; c < 64 + TDS_LEN; c++)
+        {
+            if ((linesPtr[0][c] == '{') || (linesPtr[0][c] == ' '))
+            {
+                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 l = 1;
+        while (linesPtr[l][0] != '}')
+        {
+            // WARNING: Some structs have empty spaces and comments -> OK, processed
+            if ((linesPtr[l][0] != ' ') && (linesPtr[l][0] != '\0'))
+            {
+                // Scan one field line
+                char *fieldLine = linesPtr[l];
+                int fieldEndPos = 0;
+                while (fieldLine[fieldEndPos] != ';') fieldEndPos++;
+
+                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!
+
+                    // Get struct field type and name
+                    GetDataTypeAndName(fieldLine, fieldEndPos, structs[i].fieldType[structs[i].fieldCount], structs[i].fieldName[structs[i].fieldCount]);
+
+                    // Get the field description
+                    GetDescription(&fieldLine[fieldEndPos], structs[i].fieldDesc[structs[i].fieldCount]);
+
+                    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)
+                    {
+                        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';
+                    }
+
+                    // 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]));
+                        }
+                    }
+                }
+            }
+
+            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]);
+        }
+    }
+    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++)
+    {
+
+        // 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
+        {
+            char *linePtr = lines[enumLines[i] + j];
+
+            if ((linePtr[0] >= 'A') && (linePtr[0] <= 'Z'))
+            {
+                // Parse enum value line, possible options:
+                //ENUM_VALUE_NAME,
+                //ENUM_VALUE_NAME
+                //ENUM_VALUE_NAME     = 99
+                //ENUM_VALUE_NAME     = 99,
+                //ENUM_VALUE_NAME     = 0x00000040,   // Value description
+
+                // We start reading the value name
+                int c = 0;
+                while ((linePtr[c] != ',') &&
+                       (linePtr[c] != ' ') &&
+                       (linePtr[c] != '=') &&
+                       (linePtr[c] != '\0'))
+                {
+                    enums[i].valueName[enums[i].valueCount][c] = linePtr[c];
+                    c++;
+                }
+
+                // After the name we can have:
+                //  '='  -> value is provided
+                //  ','  -> value is equal to previous + 1, there could be a description if not '\0'
+                //  ' '  -> value is equal to previous + 1, there could be a description if not '\0'
+                //  '\0' -> value is equal to previous + 1
+
+                // Let's start checking if the line is not finished
+                if ((linePtr[c] != ',') && (linePtr[c] != '\0'))
+                {
+                    // Two options:
+                    //  '='  -> value is provided
+                    //  ' '  -> value is equal to previous + 1, there could be a description if not '\0'
+                    bool foundValue = false;
+                    while ((linePtr[c] != '\0') && (linePtr[c] != '/'))
+                    {
+                        if (linePtr[c] == '=')
+                        {
+                            foundValue = true;
+                            break;
+                        }
+                        c++;
+                    }
+
+                    if (foundValue)
+                    {
+                        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);
+                }
+                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++;
+                }
+
+                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) && (linePtr[c] != '\n'); c++)
+        {
+            if (linePtr[c] == '(')     // Starts function parameters
+            {
+                funcParamsStart = c + 1;
+
+                // At this point we have function return type and function name
+                char funcRetTypeName[128] = { 0 };
+                int dc = TextLength(apiDefine) + 1;
+                int funcRetTypeNameLen = c - dc;     // Substract `define` ("RLAPI " for raylib.h)
+                MemoryCopy(funcRetTypeName, &linePtr[dc], funcRetTypeNameLen);
+
+                GetDataTypeAndName(funcRetTypeName, funcRetTypeNameLen, funcs[i].retType, funcs[i].name);
+                break;
+            }
+        }
+
+        // Get parameters from func line
+        for (int c = funcParamsStart; c < MAX_LINE_LENGTH; c++)
+        {
+            if (linePtr[c] == ',')     // Starts function parameters
+            {
+                // Get parameter type + name, extract info
+                char funcParamTypeName[128] = { 0 };
+                int funcParamTypeNameLen = c - funcParamsStart;
+                MemoryCopy(funcParamTypeName, &linePtr[funcParamsStart], funcParamTypeNameLen);
+
+                GetDataTypeAndName(funcParamTypeName, funcParamTypeNameLen, funcs[i].paramType[funcs[i].paramCount], funcs[i].paramName[funcs[i].paramCount]);
+
+                funcParamsStart = c + 1;
+                if (linePtr[c + 1] == ' ') funcParamsStart += 1;
+                funcs[i].paramCount++;      // Move to next parameter
+            }
+            else if (linePtr[c] == ')')
+            {
+                funcEnd = c + 2;
+
+                // Check if there are no parameters
+                if ((funcEnd - funcParamsStart == 2) ||
+                    ((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, &linePtr[funcParamsStart], funcParamTypeNameLen);
+
+                GetDataTypeAndName(funcParamTypeName, funcParamTypeNameLen, funcs[i].paramType[funcs[i].paramCount], funcs[i].paramName[funcs[i].paramCount]);
+
+                funcs[i].paramCount++;      // Move to next parameter
+                break;
+            }
+        }
+
+        // Get function description
+        GetDescription(&linePtr[funcEnd], funcs[i].desc);
+
+        // Move array sizes from name to type
+        for (int j = 0; j < funcs[i].paramCount; j++)
+        {
+            MoveArraySize(funcs[i].paramName[j], funcs[i].paramType[j]);
+        }
+    }
+    free(funcLines);
+
+    for (int i = 0; i < linesCount; i++) free(lines[i]);
+    free(lines);
+
+    // At this point, all raylib data has been parsed!
+    //----------------------------------------------------------------------------------
+    // 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(defines);
+    free(structs);
+    free(aliases);
+    free(enums);
+    free(callbacks);
+    free(funcs);
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition
+//----------------------------------------------------------------------------------
+
+// Show command line usage info
+static void ShowCommandLineInfo(void)
+{
+    printf("\n//////////////////////////////////////////////////////////////////////////////////\n");
+    printf("//                                                                              //\n");
+    printf("// raylib API parser                                                            //\n");
+    printf("//                                                                              //\n");
+    printf("// more info and bugs-report: github.com/raysan5/raylib/parser                  //\n");
+    printf("//                                                                              //\n");
+    printf("// Copyright (c) 2021-2024 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>]\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, .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, LUA, CODE\n\n");
+    printf("    -d, --define <DEF>              : Define functions specifiers (i.e. RLAPI for raylib.h, RMAPI 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");
+    printf("        Process <raylib.h> to generate <api.json>\n\n");
+    printf("    > raylib_parser --output raylib_data.info --format XML\n");
+    printf("        Process <raylib.h> to generate <raylib_data.info> as XML text data\n\n");
+    printf("    > raylib_parser --input raymath.h --output raymath_data.info --format XML --define RMAPI\n");
+    printf("        Process <raymath.h> to generate <raymath_data.info> as XML text data\n\n");
+}
+
+// Process command line arguments
+static void ProcessCommandLine(int argc, char *argv[])
+{
+    for (int i = 1; i < argc; i++)
+    {
+        if (IsTextEqual(argv[i], "-h", 2) || IsTextEqual(argv[i], "--help", 6))
+        {
+            // Show info
+            ShowCommandLineInfo();
+            exit(0);
+        }
+        else if (IsTextEqual(argv[i], "-i", 2) || IsTextEqual(argv[i], "--input", 7))
+        {
+            // Check for valid argument and valid file extension
+            if (((i + 1) < argc) && (argv[i + 1][0] != '-'))
+            {
+                MemoryCopy(inFileName, argv[i + 1], TextLength(argv[i + 1])); // Read input filename
+                i++;
+            }
+            else printf("WARNING: No input file provided\n");
+        }
+        else if (IsTextEqual(argv[i], "-o", 2) || IsTextEqual(argv[i], "--output", 8))
+        {
+            if (((i + 1) < argc) && (argv[i + 1][0] != '-'))
+            {
+                MemoryCopy(outFileName, argv[i + 1], TextLength(argv[i + 1])); // Read output filename
+                i++;
+            }
+            else printf("WARNING: No output file provided\n");
+        }
+        else if (IsTextEqual(argv[i], "-f", 2) || IsTextEqual(argv[i], "--format", 8))
+        {
+            if (((i + 1) < argc) && (argv[i + 1][0] != '-'))
+            {
+                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");
+        }
+        else if (IsTextEqual(argv[i], "-d", 2) || IsTextEqual(argv[i], "--define", 8))
+        {
+            if (((i + 1) < argc) && (argv[i + 1][0] != '-'))
+            {
+                MemoryCopy(apiDefine, argv[i + 1], TextLength(argv[i + 1])); // Read functions define
+                apiDefine[TextLength(argv[i + 1])] = '\0';
+                i++;
+            }
+            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++;
+            }
+        }
+    }
+}
+
+// Load text data from file, returns a '\0' terminated string
+// NOTE: text chars array should be freed manually
+static char *LoadFileText(const char *fileName, int *length)
+{
+    char *text = NULL;
+
+    if (fileName != NULL)
+    {
+        FILE *file = fopen(fileName, "rt");
+
+        if (file != NULL)
+        {
+            // WARNING: When reading a file as 'text' file,
+            // text mode causes carriage return-linefeed translation...
+            // ...but using fseek() should return correct byte-offset
+            fseek(file, 0, SEEK_END);
+            int size = ftell(file);
+            fseek(file, 0, SEEK_SET);
+
+            if (size > 0)
+            {
+                text = (char *)calloc((size + 1), sizeof(char));
+                unsigned int count = (unsigned int)fread(text, sizeof(char), size, file);
+
+                // WARNING: \r\n is converted to \n on reading, so,
+                // read bytes count gets reduced by the number of lines
+                if (count < (unsigned int)size)
+                {
+                    text = realloc(text, count + 1);
+                    *length = count;
+                }
+                else *length = size;
+
+                // Zero-terminate the string
+                text[count] = '\0';
+            }
+
+            fclose(file);
+        }
+    }
+
+    return text;
+}
+
+// Get all lines from a text buffer (expecting lines ending with '\n')
+static char **GetTextLines(const char *buffer, int length, int *linesCount)
+{
+    // Get the number of lines in the text
+    int count = 0;
+    for (int i = 0; i < length; i++) if (buffer[i] == '\n') count++;
+
+    printf("Number of text lines in buffer: %i\n", count);
+
+    // Allocate as many pointers as lines
+    char **lines = (char **)malloc(count*sizeof(char **));
+
+    char *bufferPtr = (char *)buffer;
+
+    for (int i = 0; (i < count) || (bufferPtr[0] != '\0'); i++)
+    {
+        lines[i] = (char *)calloc(MAX_LINE_LENGTH, sizeof(char));
+
+        // Remove line leading spaces
+        // Find last index of space/tab character
+        int index = 0;
+        while ((bufferPtr[index] == ' ') || (bufferPtr[index] == '\t')) index++;
+
+        int j = 0;
+        while (bufferPtr[index + j] != '\n' && bufferPtr[index + j] != '\0')
+        {
+            lines[i][j] = bufferPtr[index + j];
+            j++;
+        }
+
+        bufferPtr += (index + j + 1);
+    }
+
+    *linesCount = count;
+    return lines;
+}
+
+// Get data type and name from a string containing both
+// NOTE: Useful to parse function parameters and struct fields
+static void GetDataTypeAndName(const char *typeName, int typeNameLen, char *type, char *name)
+{
+    for (int k = typeNameLen; k > 0; k--)
+    {
+        if ((typeName[k] == ' ') && (typeName[k - 1] != ','))
+        {
+            // Function name starts at this point (and ret type finishes at this point)
+            MemoryCopy(type, typeName, k);
+            MemoryCopy(name, typeName + k + 1, typeNameLen - k - 1);
+            break;
+        }
+        else if (typeName[k] == '*')
+        {
+            MemoryCopy(type, typeName, k + 1);
+            MemoryCopy(name, typeName + k + 1, typeNameLen - k - 1);
+            break;
+        }
+        else if ((typeName[k] == '.') && (typeNameLen == 3)) // Handle varargs ...);
+        {
+	    const char *varargsDots = "...";
+	    const char *varargsArg = "args";
+            MemoryCopy(type, varargsDots, TextLength(varargsDots));
+            MemoryCopy(name, varargsArg, TextLength(varargsArg));
+            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';
+            }
+        }
+    }
+}
+
+// Get text length in bytes, check for \0 character
+static unsigned int TextLength(const char *text)
+{
+    unsigned int length = 0;
+
+    if (text != NULL) while (*text++) length++;
+
+    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)
+{
+    char *srcPtr = (char *)src;
+    char *destPtr = (char *)dest;
+
+    for (unsigned int i = 0; i < count; i++) destPtr[i] = srcPtr[i];
+}
+
+// Escape backslashes in a string, writing the escaped string into a static buffer
+static char *EscapeBackslashes(char *text)
+{
+    static char buffer[256] = { 0 };
+
+    int count = 0;
+
+    for (int i = 0; (text[i] != '\0') && (i < 255); i++, count++)
+    {
+        buffer[count] = text[i];
+
+        if (text[i] == '\\')
+        {
+            buffer[count + 1] = '\\';
+            count++;
+        }
+    }
+
+    buffer[count] = '\0';
+
+    return buffer;
+}
+
+// Get string of define type
+static const char *StrDefineType(DefineType type)
+{
+    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 "";
+}
+
+/*
+// Replace text string
+// REQUIRES: strlen(), strstr(), strncpy(), strcpy() -> TODO: Replace by custom implementations!
+// WARNING: Returned buffer must be freed by the user (if return != NULL)
+static char *TextReplace(char *text, const char *replace, const char *by)
+{
+    // Sanity checks and initialization
+    if (!text || !replace || !by) return NULL;
+
+    char *result;
+
+    char *insertPoint;      // Next insert point
+    char *temp;             // Temp pointer
+    int replaceLen;         // Replace string length of (the string to remove)
+    int byLen;              // Replacement length (the string to replace replace by)
+    int lastReplacePos;     // Distance between replace and end of last replace
+    int count;              // Number of replacements
+
+    replaceLen = strlen(replace);
+    if (replaceLen == 0) return NULL;  // Empty replace causes infinite loop during count
+
+    byLen = strlen(by);
+
+    // Count the number of replacements needed
+    insertPoint = text;
+    for (count = 0; (temp = strstr(insertPoint, replace)); count++) insertPoint = temp + replaceLen;
+
+    // Allocate returning string and point temp to it
+    temp = result = (char *)malloc(strlen(text) + (byLen - replaceLen)*count + 1);
+
+    if (!result) return NULL;   // Memory could not be allocated
+
+    // First time through the loop, all the variable are set correctly from here on,
+    //  - 'temp' points to the end of the result string
+    //  - 'insertPoint' points to the next occurrence of replace in text
+    //  - 'text' points to the remainder of text after "end of replace"
+    while (count--)
+    {
+        insertPoint = strstr(text, replace);
+        lastReplacePos = (int)(insertPoint - text);
+        temp = strncpy(temp, text, lastReplacePos) + lastReplacePos;
+        temp = strcpy(temp, by) + byLen;
+        text += lastReplacePos + replaceLen; // Move to next "end of replace"
+    }
+
+    // Copy remaind text part after replacement to result (pointed by moving temp)
+    strcpy(temp, text);
+
+    return result;
+}
+*/
+
+// Export parsed data in desired format
+static void ExportParsedData(const char *fileName, int format)
+{
+    FILE *outFile = fopen(fileName, "wt");
+
+    switch (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);
+                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
+            fprintf(outFile, "\nEnums found: %i\n\n", enumCount);
+            for (int i = 0; i < enumCount; i++)
+            {
+                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);
+                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++)
+            {
+                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);
+                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");
+            }
+        } break;
+        case JSON:
+        {
+            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", 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, "        {\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", 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, "        {\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, "    }");
+
+                if (i < funcCount - 1) fprintf(outFile, ",\n");
+                else fprintf(outFile, "\n");
+            }
+            fprintf(outFile, "  ]\n");
+            fprintf(outFile, "}\n");
+        } break;
+        case XML:
+        {
+            // XML format to export data:
+            /*
+            <?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="" />
+                    </Struct>
+                <Structs>
+                <Aliases count="">
+                    <Alias type="" name="" desc="" />
+                </Aliases>
+                <Enums count="">
+                    <Enum name="" valueCount="" 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="" />
+                        <Param type="" name="" desc="" />
+                    </Function>
+                </Functions>
+            </raylibAPI>
+            */
+
+            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);
+                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]);
+                }
+                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);
+                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]);
+                }
+                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);
+                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]);
+                }
+                fprintf(outFile, "        </Function>\n");
+            }
+            fprintf(outFile, "    </Functions>\n");
+
+            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;
+    }
+
+    fclose(outFile);
+}