raylib_parser.c

// Modified version of the original raylib_parser.c from Raylib 5.5 extended to generate SML bindings.
// Modifications are made by Alexey Kutepov (@rexim)

/**********************************************************************************************

    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-2025 Ramon Santamaria (@raysan5)
    Copyright (c) 2026      Alexey Kutepov (@rexim)

**********************************************************************************************/

#define _CRT_SECURE_NO_WARNINGS

#include <assert.h>             // Required for: assert()
#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 NOB_IMPLEMENTATION
#include "nob.h"

#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, SML } 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");
    else if (outputFormat == SML) printf("\nOutput format:    SML\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", 5)) outputFormat = CODE;
                else if (IsTextEqual(argv[i + 1], "SML\0", 4)) outputFormat = SML;
            }
            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 SML: {
            const char *dll_name = "./libmraylib.so";
            FILE *outCFile = fopen(temp_sprintf("%s.c", fileName), "wt");

            typedef struct {
                const char *c_type;
                const char *sml_type;
                const char *value_to_c;
                const char *c_to_value;
            } Type;

            static Type types[] = {
                {
                    .c_type     = "const char *",
                    .sml_type   = "string",
                    .value_to_c = "String_val",
                    .c_to_value = "Val_string",
                },
                {
                    .c_type     = "void",
                    .sml_type   = "unit",
                    .value_to_c = "NA",
                    .c_to_value = "NA",
                },
                {
                    .c_type     = "int",
                    .sml_type   = "int",
                    .value_to_c = "Int_val",
                    .c_to_value = "Val_int",
                },
                {
                    .c_type     = "float",
                    .sml_type   = "real",
                    .value_to_c = "Double_val",
                    .c_to_value = "copy_double",
                },
                {
                    .c_type     = "unsigned int",
                    .sml_type   = "word",
                },
                {
                    .c_type     = "bool",
                    .sml_type   = "bool",
                    .value_to_c = "Bool_val",
                    .c_to_value = "Val_bool",
                },
                {
                    .c_type     = "Color",
                    .sml_type   = "int",
                    .value_to_c = "Color_val",
                    .c_to_value = "Val_color",
                },
            };

            Type *get_c_type(const char *c_type)
            {
                for (size_t i = 0; i < ARRAY_LEN(types); ++i) {
                    if (strcmp(c_type, types[i].c_type) == 0) {
                        return &types[i];
                    }
                }
                return NULL;
            }

            const char *translate_type_c_to_sml(const char *c_type)
            {
                Type *type = get_c_type(c_type);
                if (type == NULL) return temp_sprintf("UNKNOWN[%s]", c_type);
                return type->sml_type;
            }

            // SML header
            {
                fprintf(outFile, "open Dynlib;\n");
                fprintf(outFile, "\n");
                fprintf(outFile, "val dlh = dlopen { lib = \"%s\", flag = RTLD_LAZY, global = false }\n", dll_name);
                fprintf(outFile, "\n");
            }

            // C header
            {
                fprintf(outCFile, "#include <string.h>\n");
                fprintf(outCFile, "#include \"mlvalues.h\"\n");
                fprintf(outCFile, "#include \"alloc.h\"\n");
                fprintf(outCFile, "#include \"raylib.h\"\n");
                fprintf(outCFile, "\n");
                fprintf(outCFile, "static inline value Val_string(const char *s)\n");
                fprintf(outCFile, "{\n");
                fprintf(outCFile, "    int len = strlen(s);\n");
                fprintf(outCFile, "    value res = alloc_string(len);\n");
                fprintf(outCFile, "    bcopy(s, &Byte(res, 0), len);\n");
                fprintf(outCFile, "    return res;\n");
                fprintf(outCFile, "}\n");
                fprintf(outCFile, "\n");
                fprintf(outCFile, "static inline value Val_color(Color c)\n");
                fprintf(outCFile, "{\n");
                fprintf(outCFile, "    return Val_int(*(int*)&c);\n");
                fprintf(outCFile, "}\n");
                fprintf(outCFile, "\n");
                fprintf(outCFile, "static inline Color Color_val(value v)\n");
                fprintf(outCFile, "{\n");
                fprintf(outCFile, "    int c = Int_val(v);\n");
                fprintf(outCFile, "    return *(Color*)&c;\n");
                fprintf(outCFile, "}\n");
                fprintf(outCFile, "\n");
                fprintf(outCFile, "static inline value Val_double(double x)\n");
                fprintf(outCFile, "{\n");
                fprintf(outCFile, "    value res = alloc_string(8);\n");
                fprintf(outCFile, "    Store_double_val(res, x);\n");
                fprintf(outCFile, "    return res;\n");
                fprintf(outCFile, "}\n");
                fprintf(outCFile, "\n");
            }

            for (int i = 0; i < enumCount; ++i) {
                fprintf(outFile, "type %s = int\n", enums[i].name);
                for (int j = 0; j < enums[i].valueCount; ++j) {
                    fprintf(outFile, "val %s: %s = %d\n", enums[i].valueName[j], enums[i].name, enums[i].valueInteger[j]);
                }
                fprintf(outFile, "\n");
            }

            size_t mark = temp_save();
            size_t generated = 0;
            size_t skipped = 0;
            for (int i = 0; i < funcCount; i++) {
                temp_rewind(mark);
                bool skip_for_now = false;
                Type *retType = get_c_type(funcs[i].retType);
                skip_for_now = skip_for_now || funcs[i].paramCount > 5;
                skip_for_now = skip_for_now || retType ==  NULL || retType->value_to_c == NULL || retType->c_to_value == NULL;
                for (int p = 0; !skip_for_now && p < funcs[i].paramCount; p++) {
                    Type *type = get_c_type(funcs[i].paramType[p]);
                    if (type == NULL || type->value_to_c == NULL || type->c_to_value == NULL) {
                        skip_for_now = true;
                    }
                }

                if (skip_for_now) {
                    skipped += 1;
                } else {
                    generated += 1;
                }

                // SML
                {
                    if (skip_for_now) fprintf(outFile, "(* ");

                    fprintf(outFile, "val %s: ", funcs[i].name);
                    if (funcs[i].paramCount == 0) {
                        fprintf(outFile, "unit");
                    } else {
                        for (int p = 0; p < funcs[i].paramCount; p++) {
                            if (p > 0) fprintf(outFile, " -> ");
                            fprintf(outFile, "%s", translate_type_c_to_sml(funcs[i].paramType[p]));
                        }
                    }
                    fprintf(outFile, " -> %s", translate_type_c_to_sml(funcs[i].retType));
                    if (funcs[i].paramCount == 0) {
                        fprintf(outFile, " = app1 (dlsym dlh \"raylib_%s\")", funcs[i].name);
                    } else {
                        fprintf(outFile, " = app%d (dlsym dlh \"raylib_%s\")", funcs[i].paramCount, funcs[i].name);
                    }

                    if (skip_for_now) fprintf(outFile, " *)");
                    fprintf(outFile, "\n");
                }

                // C
                {
                    if (skip_for_now) fprintf(outCFile, "/*\n");
                    fprintf(outCFile, "value raylib_%s(", funcs[i].name);
                    if (funcs[i].paramCount == 0) {
                        fprintf(outCFile, "value unit");
                    } else {
                        for (int p = 0; p < funcs[i].paramCount; p++) {
                            if (p > 0) fprintf(outCFile, ", ");
                            fprintf(outCFile, "value %s", funcs[i].paramName[p]);
                        }
                    }
                    fprintf(outCFile, ")\n");
                    fprintf(outCFile, "{\n");
                    if (strcmp(funcs[i].retType, "void") != 0) {
                        fprintf(outCFile, "    %s result = ", funcs[i].retType);
                    } else {
                        fprintf(outCFile, "    ");
                    }
                    fprintf(outCFile, "%s(", funcs[i].name);
                    for (int p = 0; p < funcs[i].paramCount; p++) {
                        if (p > 0) fprintf(outCFile, ", ");
                        Type *type = get_c_type(funcs[i].paramType[p]);
                        const char *value_to_c = type == NULL || type->value_to_c == NULL ? "UNKNOWN" : type->value_to_c;
                        fprintf(outCFile, "%s(%s)", value_to_c, funcs[i].paramName[p]);
                    }
                    fprintf(outCFile, ");\n");
                    if (strcmp(funcs[i].retType, "void") != 0) {
                        Type *type = get_c_type(funcs[i].retType);
                        const char *c_to_value = type == NULL || type->c_to_value == NULL ? "UNKNOWN" : type->c_to_value;
                        fprintf(outCFile, "    return %s(result);\n", c_to_value);
                    } else {
                        fprintf(outCFile, "    return Val_unit;\n");
                    }
                    fprintf(outCFile, "}\n");
                    if (skip_for_now) fprintf(outCFile, "*/\n");
                    fprintf(outCFile, "\n");
                }
            }

            size_t total = generated + skipped;
            printf("generated function %zu/%zu (%zu%%)\n", generated, total, generated*100/total);

            fclose(outCFile);
        } break;
        case CODE:
        default: break;
    }

    fclose(outFile);
}