path: root/parser/raylib_parser.c

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

    raylib API parser

    This parser scans raylib.h to get API information about structs, enums and functions.
    All data is divided into pieces, usually as strings. The following types are used for data:

     - struct FunctionInfo
     - struct StructInfo
     - struct EnumInfo

    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 Ramon Santamaria (@raysan5)

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

#define _CRT_SECURE_NO_WARNINGS

#include <stdlib.h>             // Required for: malloc(), calloc(), realloc(), free(), atoi(), strtol()
#include <stdio.h>              // Required for: printf(), fopen(), fseek(), ftell(), fread(), fclose()
#include <stdbool.h>            // Required for: bool

#define MAX_FUNCS_TO_PARSE       512    // Maximum number of functions to parse
#define MAX_STRUCTS_TO_PARSE      64    // Maximum number of structures to parse
#define MAX_ENUMS_TO_PARSE        64    // Maximum number of enums to parse

#define MAX_LINE_LENGTH          512    // Maximum length of one line (including comments)
#define MAX_STRUCT_LINE_LENGTH  2048    // Maximum length of one struct (multiple lines)

//----------------------------------------------------------------------------------
// Types and Structures Definition
//----------------------------------------------------------------------------------
// Function info data
typedef struct FunctionInfo {
    char name[64];              // Function name
    char desc[128];             // Function description (comment at the end)
    char retType[32];           // Return value type
    int paramCount;             // Number of function parameters
    char paramType[12][32];     // Parameters type (max: 12 parameters)
    char paramName[12][32];     // Parameters name (max: 12 parameters)
    char paramDesc[12][8];    // Parameters description (max: 12 parameters)
} FunctionInfo;

// Struct info data
typedef struct StructInfo {
    char name[64];              // Struct name
    char desc[64];              // Struct type description
    int fieldCount;             // Number of fields in the struct
    char fieldType[16][32];     // Field type (max: 16 fields)
    char fieldName[16][32];     // Field name (max: 16 fields)
    char fieldDesc[16][128];    // Field description (max: 16 fields)
} StructInfo;

// Enum info data
typedef struct EnumInfo {
    char name[64];              // Enum name
    char desc[64];              // Enum description
    int valueCount;             // Number of values in enumerator
    char valueName[128][64];    // Value name definition (max: 128 values)
    int valueInteger[128];      // Value integer (max: 128 values)
    char valueDesc[128][64];    // Value description (max: 128 values)
} EnumInfo;

// Output format for parsed data
typedef enum { DEFAULT = 0, JSON, XML } OutputFormat;

//----------------------------------------------------------------------------------
// Global Variables Definition
//----------------------------------------------------------------------------------
static int funcCount = 0;
static int structCount = 0;
static int enumCount = 0;
static FunctionInfo *funcs = NULL;
static StructInfo *structs = NULL;
static EnumInfo *enums = NULL;

// Command line variables
static char inFileName[512] = { 0 };       // Input file name (required in case of provided through CLI)
static char outFileName[512] = { 0 };      // Output file name (required for file save/export)
static int outputFormat = DEFAULT;

//----------------------------------------------------------------------------------
// 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 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 void MemoryCopy(void *dest, const void *src, unsigned int count);
static char* CharReplace(char* text, char search, char replace);

static void ExportParsedData(const char *fileName, int format); // Export parsed data in desired format

//------------------------------------------------------------------------------------
// Program main entry point
//------------------------------------------------------------------------------------
int main(int argc, char* argv[])
{
    if (argc > 1) ProcessCommandLine(argc, argv);

    if (inFileName[0] == '\0') MemoryCopy(inFileName, "../src/raylib.h\0", 16);

    int length = 0;
    char *buffer = LoadFileText(inFileName, &length);

    // Preprocess buffer to get separate lines
    // NOTE: GetTextLines() also removes leading spaces/tabs
    int linesCount = 0;
    char **lines = GetTextLines(buffer, length, &linesCount);

    // Function lines pointers, selected from buffer "lines"
    char **funcLines = (char **)malloc(MAX_FUNCS_TO_PARSE*sizeof(char *));

    // Structs data (multiple lines), selected from "buffer"
    char **structLines = (char **)malloc(MAX_STRUCTS_TO_PARSE*sizeof(char *));
    for (int i = 0; i < MAX_STRUCTS_TO_PARSE; i++) structLines[i] = (char *)calloc(MAX_STRUCT_LINE_LENGTH, sizeof(char));

    // Enums lines pointers, selected from buffer "lines"
    int *enumLines = (int *)malloc(MAX_ENUMS_TO_PARSE*sizeof(int));

    // Prepare required lines for parsing
    //--------------------------------------------------------------------------------------------------

    // Read function lines
    for (int i = 0; i < linesCount; i++)
    {
        // Read function line (starting with "RLAPI")
        if (IsTextEqual(lines[i], "RLAPI", 5))
        {
            // Keep a pointer to the function line
            funcLines[funcCount] = lines[i];
            funcCount++;
        }
    }

    // Read structs data (multiple lines, read directly from buffer)
    // TODO: Parse structs data from "lines" instead of "buffer" -> Easier to get struct definition
    for (int i = 0; i < length; i++)
    {
        // Read struct data (starting with "typedef struct", ending with '} ... ;')
        // NOTE: We read it directly from buffer
        if (IsTextEqual(buffer + i, "typedef struct", 14))
        {
            int j = 0;
            bool validStruct = false;

            // WARNING: Typedefs between types: typedef Vector4 Quaternion;

            for (int c = 0; c < 128; c++)
            {
                if (buffer[i + c] == '{')
                {
                    validStruct = true;
                    break;
                }
                else if (buffer[i + c] == ';')
                {
                    // Not valid struct:
                    // i.e typedef struct rAudioBuffer rAudioBuffer; -> Typedef and forward declaration
                    i += c;
                    break;
                }
            }

            if (validStruct)
            {
                while (buffer[i + j] != '}')
                {
                    structLines[structCount][j] = buffer[i + j];
                    j++;
                }

                while (buffer[i + j] != '}')
                {
                    structLines[structCount][j] = buffer[i + j];
                    j++;
                }

                while (buffer[i + j] != '\n')
                {
                    structLines[structCount][j] = buffer[i + j];
                    j++;
                }

                i += j;
                structCount++;
            }
        }
    }

    // Read enum lines
    for (int i = 0; i < linesCount; i++)
    {
        // Read function line (starting with "RLAPI")
        if (IsTextEqual(lines[i], "typedef enum {", 14))
        {
            // Keep the line position in the array of lines,
            // so, we can scan that position and following lines
            enumLines[enumCount] = i;
            enumCount++;
        }
    }

    // At this point we have all raylib structs, enums, functions lines data to start parsing

    free(buffer);       // Unload text buffer

    // Parsing raylib data
    //--------------------------------------------------------------------------------------------------

    // Structs info data
    structs = (StructInfo *)calloc(MAX_STRUCTS_TO_PARSE, sizeof(StructInfo));

    for (int i = 0; i < structCount; i++)
    {
        int structLineOffset = 0;

        // Get struct name: typedef struct name {
        for (int c = 15; c < 64 + 15; c++)
        {
            if (structLines[i][c] == '{')
            {
                structLineOffset = c + 2;

                MemoryCopy(structs[i].name, &structLines[i][15], c - 15 - 1);
                break;
            }
        }

        // Get struct fields and count them -> fields finish with ;
        int j = 0;
        while (structLines[i][structLineOffset + j] != '}')
        {
            // WARNING: Some structs have empty spaces and comments -> OK, processed

            int fieldStart = 0;
            if ((structLines[i][structLineOffset + j] != ' ') && (structLines[i][structLineOffset + j] != '\n')) fieldStart = structLineOffset + j;

            if (fieldStart != 0)
            {
                // Scan one field line
                int c = 0;
                int fieldEndPos = 0;
                char fieldLine[256] = { 0 };

                while (structLines[i][structLineOffset + j] != '\n')
                {
                    if (structLines[i][structLineOffset + j] == ';') fieldEndPos = c;
                    fieldLine[c] = structLines[i][structLineOffset + j];
                    c++; j++;
                }

                if (fieldLine[0] != '/')    // Field line is not a comment
                {
                    //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
                    // We start skipping spaces in front of description comment
                    int descStart = fieldEndPos;
                    while ((fieldLine[descStart] != '/') && (fieldLine[descStart] != '\0')) descStart++;

                    int k = 0;
                    while ((fieldLine[descStart + k] != '\0') && (fieldLine[descStart + k] != '\n'))
                    {
                        structs[i].fieldDesc[structs[i].fieldCount][k] = fieldLine[descStart + k];
                        k++;
                    }

                    structs[i].fieldCount++;
                }
            }

            j++;
        }

    }

    for (int i = 0; i < MAX_STRUCTS_TO_PARSE; i++) free(structLines[i]);
    free(structLines);

    // Enum info data
    enums = (EnumInfo *)calloc(MAX_ENUMS_TO_PARSE, sizeof(EnumInfo));

    for (int i = 0; i < enumCount; i++)
    {
        // TODO: Get enum description from lines[enumLines[i] - 1]

        for (int j = 1; j < 256; 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')
                    {
                        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);

                    // TODO: Parse value description if any
                }
                else enums[i].valueInteger[enums[i].valueCount] = (enums[i].valueInteger[enums[i].valueCount - 1] + 1);

                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
            }
        }
    }

    // Functions info data
    funcs = (FunctionInfo *)calloc(MAX_FUNCS_TO_PARSE, sizeof(FunctionInfo));

    for (int i = 0; i < funcCount; i++)
    {
        int funcParamsStart = 0;
        int funcEnd = 0;

        // Get return type and function name from func line
        for (int c = 0; (c < MAX_LINE_LENGTH) && (funcLines[i][c] != '\n'); c++)
        {
            if (funcLines[i][c] == '(')     // Starts function parameters
            {
                funcParamsStart = c + 1;

                // At this point we have function return type and function name
                char funcRetTypeName[128] = { 0 };
                int funcRetTypeNameLen = c - 6;     // Substract "RLAPI "
                MemoryCopy(funcRetTypeName, &funcLines[i][6], 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 (funcLines[i][c] == ',')     // Starts function parameters
            {
                // Get parameter type + name, extract info
                char funcParamTypeName[128] = { 0 };
                int funcParamTypeNameLen = c - funcParamsStart;
                MemoryCopy(funcParamTypeName, &funcLines[i][funcParamsStart], funcParamTypeNameLen);

                GetDataTypeAndName(funcParamTypeName, funcParamTypeNameLen, funcs[i].paramType[funcs[i].paramCount], funcs[i].paramName[funcs[i].paramCount]);

                funcParamsStart = c + 1;
                if (funcLines[i][c + 1] == ' ') funcParamsStart += 1;
                funcs[i].paramCount++;      // Move to next parameter
            }
            else if (funcLines[i][c] == ')')
            {
                funcEnd = c + 2;

                // Check if previous word is void
                if ((funcLines[i][c - 4] == 'v') && (funcLines[i][c - 3] == 'o') && (funcLines[i][c - 2] == 'i') && (funcLines[i][c - 1] == 'd')) break;

                // Get parameter type + name, extract info
                char funcParamTypeName[128] = { 0 };
                int funcParamTypeNameLen = c - funcParamsStart;
                MemoryCopy(funcParamTypeName, &funcLines[i][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
        for (int c = funcEnd; c < MAX_LINE_LENGTH; c++)
        {
            if (funcLines[i][c] == '/')
            {
                MemoryCopy(funcs[i].desc, &funcLines[i][c], 127);   // WARNING: Size could be too long for funcLines[i][c]?
                break;
            }
        }
    }

    //for (int i = 0; i < linesCount; i++) free(lines[i]);
    free(lines);
    free(funcLines);

    // At this point, all raylib data has been parsed!
    //-----------------------------------------------------------------------------------------
    // structs[] -> We have all the structs decomposed into pieces for further analysis
    // enums[]   -> We have all the enums decomposed into pieces for further analysis
    // funcs[]   -> We have all the functions decomposed into pieces for further analysis

    // Process input file to output
    if (outFileName[0] == '\0') MemoryCopy(outFileName, "raylib_api.txt\0", 15);

    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");

    ExportParsedData(outFileName, outputFormat);

    free(funcs);
    free(structs);
    free(enums);
}

//----------------------------------------------------------------------------------
// 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 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, .h\n");
    printf("                                      NOTE: If not specified, defaults to: raylib_api.txt\n\n");
    printf("    -f, --format <type>             : Define output format for parser data.\n");
    printf("                                      Supported types: DEFAULT, JSON, XML\n\n");

    printf("\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");
}

// 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();
        }
        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 printf("WARNING: No format parameters provided\n");
        }
    }
}

// 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')
        {
            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;
        }
    }
}

// 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;
}

// 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];
}

// 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;
}

// Search and replace a character within a string.
static char* CharReplace(char* text, char search, char replace)
{
    for (int i = 0; text[i] != '\0'; i++)
        if (text[i] == search)
            text[i] = replace;
    return text;
}

/*
// 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 structs info
            fprintf(outFile, "\nStructures found: %i\n\n", structCount);
            for (int i = 0; i < structCount; i++)
            {
                fprintf(outFile, "Struct %02i: %s (%i fields)\n", i + 1, structs[i].name, structs[i].fieldCount);
                fprintf(outFile, "  Name: %s\n", structs[i].name);
                fprintf(outFile, "  Description: %s\n", structs[i].desc + 3);
                for (int f = 0; f < structs[i].fieldCount; f++) fprintf(outFile, "  Field[%i]: %s %s %s\n", f + 1, structs[i].fieldType[f], structs[i].fieldName[f], structs[i].fieldDesc[f]);
            }

            // 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 + 3);
                for (int e = 0; e < enums[i].valueCount; e++) fprintf(outFile, "  Value[%s]: %i\n", enums[i].valueName[e], enums[i].valueInteger[e]);
            }

            // 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 + 3);
                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 structs info
            fprintf(outFile, "  \"structs\": [\n");
            for (int i = 0; i < structCount; i++)
            {
                fprintf(outFile, "    {\n");
                fprintf(outFile, "      \"name\": \"%s\",\n", structs[i].name);
                fprintf(outFile, "      \"description\": \"%s\",\n", structs[i].desc);
                fprintf(outFile, "      \"fields\": [\n");
                for (int f = 0; f < structs[i].fieldCount; f++)
                {
                    fprintf(outFile, "        {\n");
                    fprintf(outFile, "          \"name\": \"%s\",\n", structs[i].fieldName[f]),
                    fprintf(outFile, "          \"type\": \"%s\",\n", structs[i].fieldType[f]),
                    fprintf(outFile, "          \"description\": \"%s\"\n", structs[i].fieldDesc[f] + 3),
                    fprintf(outFile, "        }");
                    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 enums info
            fprintf(outFile, "  \"enums\": [\n");
            for (int i = 0; i < enumCount; i++)
            {
                fprintf(outFile, "    {\n");
                fprintf(outFile, "      \"name\": \"%s\",\n", enums[i].name);
                fprintf(outFile, "      \"description\": \"%s\",\n", enums[i].desc + 3);
                fprintf(outFile, "      \"values\": [\n");
                for (int e = 0; e < enums[i].valueCount; e++)
                {
                    fprintf(outFile, "        {\n");
                    fprintf(outFile, "          \"name\": \"%s\",\n", enums[i].valueName[e]),
                    fprintf(outFile, "          \"value\": %i,\n", enums[i].valueInteger[e]),
                    fprintf(outFile, "          \"description\": \"%s\"\n", enums[i].valueDesc[e] + 3),
                    fprintf(outFile, "        }");
                    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 functions info
            fprintf(outFile, "  \"functions\": [\n");
            for (int i = 0; i < funcCount; i++)
            {
                fprintf(outFile, "    {\n");
                fprintf(outFile, "      \"name\": \"%s\",\n", funcs[i].name);
                fprintf(outFile, "      \"description\": \"%s\",\n", CharReplace(funcs[i].desc, '\\', ' ') + 3);
                fprintf(outFile, "      \"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, "        \"%s\": \"%s\"", funcs[i].paramName[p], funcs[i].paramType[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 XML:
        {
            // XML format to export data:
            /*
            <?xml version="1.0" encoding="Windows-1252" ?>
            <raylibAPI>
                <Structs count="">
                    <Struct name="" fieldCount="" desc="">
                        <Field type="" name="" desc="">
                        <Field type="" name="" desc="">
                    </Struct>
                <Structs>
                <Enums count="">
                    <Enum name="" valueCount="" desc="">
                        <Value name="" integer="" desc="">
                        <Value name="" integer="" desc="">
                    </Enum>
                </Enums>
                <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 structs info
            fprintf(outFile, "    <Structs count=\"%i\">\n", structCount);
            for (int i = 0; i < structCount; i++)
            {
                fprintf(outFile, "        <Struct name=\"%s\" fieldCount=\"%i\" desc=\"%s\">\n", structs[i].name, structs[i].fieldCount, structs[i].desc + 3);
                for (int f = 0; f < structs[i].fieldCount; f++)
                {
                    fprintf(outFile, "            <Field type=\"%s\" name=\"%s\" desc=\"%s\" />\n", structs[i].fieldType[f], structs[i].fieldName[f], structs[i].fieldDesc[f] + 3);
                }
                fprintf(outFile, "        </Struct>\n");
            }
            fprintf(outFile, "    </Structs>\n");

            // Print enums info
            fprintf(outFile, "    <Enums count=\"%i\">\n", enumCount);
            for (int i = 0; i < enumCount; i++)
            {
                fprintf(outFile, "        <Enum name=\"%s\" valueCount=\"%i\" desc=\"%s\">\n", enums[i].name, enums[i].valueCount, enums[i].desc + 3);
                for (int v = 0; v < enums[i].valueCount; v++)
                {
                    fprintf(outFile, "            <Value name=\"%s\" integer=\"%i\" desc=\"%s\" />\n", enums[i].valueName[v], enums[i].valueInteger[v], enums[i].valueDesc[v] + 3);
                }
                fprintf(outFile, "        </Enum>\n");
            }
            fprintf(outFile, "    </Enums>\n");

            // Print functions info
            fprintf(outFile, "    <Functions count=\"%i\">\n", funcCount);
            for (int i = 0; i < funcCount; i++)
            {
                fprintf(outFile, "        <Function name=\"%s\" retType=\"%s\" paramCount=\"%i\" desc=\"%s\">\n", funcs[i].name, funcs[i].retType, funcs[i].paramCount, funcs[i].desc + 3);
                for (int p = 0; p < funcs[i].paramCount; p++)
                {
                    fprintf(outFile, "            <Param type=\"%s\" name=\"%s\" desc=\"%s\" />\n", funcs[i].paramType[p], funcs[i].paramName[p], funcs[i].paramDesc[p] + 3);
                }
                fprintf(outFile, "        </Function>\n");
            }
            fprintf(outFile, "    </Functions>\n");

            fprintf(outFile, "</raylibAPI>\n");

        } break;
        default: break;
    }

    fclose(outFile);
}