parser.h

Go to the documentation of this file.

/*
MIT License
 
Copyright (c) 2026 NorbCodes
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

 
#ifndef BPARSER_PARSER
#define BPARSER_PARSER
 
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
 
#include "binaryparser/version.h"
 
#if (BPARSER_VERSION_DEV == 1) && !defined(BPARSER_DEV_WARN)
#error You're using a dev build of BinaryParser. It is still in development and it's VERY volatile! Use with caution.
#endif // BPARSER_VERSION_DEV

#define BPARSER_UINT8 0

#define BPARSER_UINT16 1

#define BPARSER_UINT24 2

#define BPARSER_UINT32 3

#define BPARSER_UINT64 4

#define BPARSER_UINT128 5

#define BPARSER_INT8 6

#define BPARSER_INT16 7

#define BPARSER_INT24 8

#define BPARSER_INT32 9

#define BPARSER_INT64 10

#define BPARSER_INT128 11

#define BPARSER_STR 12

#define BPARSER_N_BYTES 13

#define BPARSER_FIXED_STR 14

#define BPARSER_FLOAT 15

#define BPARSER_DOUBLE 16

#define BPARSER_UNIX_TIME 17

#define BPARSER_UNICODE_FROM_UTF8_STR 18

#define BPARSER_UNICODE_FROM_UTF8_F_STR 19

#define BPARSER_UTF8_STR 20

#define BPARSER_UTF8_F_STR 21

#define BPARSER_BOOLS 22

#define BPARSER_BOOL_RUN 23
 
// Seek modes

#define BPARSER_SEEK_TO 150

#define BPARSER_SEEK_FORWARD 151

#define BPARSER_SEEK_BACKWARD 152

#define BPARSER_SEEK_FROM_END 153

#define BPARSER_NO_SEEK 154
 
// Error codes

#define BPARSER_RO_ARRAY_ERROR -20

#define BPARSER_MALLOC_ERROR -21

#define BPARSER_NO_FUNC_PASSED -22

#define BPARSER_SPRINTF_ERROR -23

#define BPARSER_BACKWARD_SEEK_ERROR -24

#define BPARSER_SEEK_FROM_END_ERROR -25

#define BPARSER_EOF_ERROR -26

#define BPARSER_CALLOC_ERROR -27

#define BPARSER_UNKNOWN_ENDIAN -28

#define BPARSER_UNKNOWN_READ_TYPE -29

#define BPARSER_FOPEN_ERROR -30

#define BPARSER_FSEEK_ERROR -31

#define BPARSER_FTELL_ERROR -32

#define BPARSER_FREAD_EOF_ERROR -33

#define BPARSER_SEEK_ERROR -34

#define BPARSER_BAD_INTEGRAL_TYPE -35

#define BPARSER_BAD_REALLOC_METHOD -36

#define BPARSER_REALLOC_FACTOR_TOO_SMALL -37

#define BPARSER_RENAME_NOT_FOUND -38

#define BPARSER_PDC_INIT_ERROR -39

#define BPARSER_PDC_RO_COPY_ERROR -40

#define BPARSER_NULL_NAME -41

#define BPARSER_SHORT_NAME -42

#define BPARSER_NO_PARSER -43

#define BPARSER_ZERO_LENGTH -44

#define BPARSER_NAME_IS_NOT_UNIQUE -45

#define BPARSER_NO_BOOLS_TO_READ -46

#define BPARSER_PDC_DATA_COPY_ERROR -47

#define BPARSER_FREAD_ERROR -48

#define BPARSER_FREAD_UNKNOWN_ERROR -49

#define BPARSER_NULL_DATA -50

#define BPARSER_NOTHING_TO_PARSE -51

#define BPARSER_EMPTY_FILE -52

#define BPARSER_BAD_OVERRIDE -53

#define BPARSER_OK(expr) ((expr)>=(BPARSER_RO_ARRAY_ERROR))

#define BPARSER_LITTLE_ENDIAN 0

#define BPARSER_BIG_ENDIAN 1

#define BPARSER_DEFAULT_ENDIAN 2

#define BPARSER_REALLOC_METHOD_PLUS 240

#define BPARSER_REALLOC_METHOD_MULT 241

#define bparser_read_uint8(Parser, Name) bparser_read_integral(Parser, Name, BPARSER_UINT8, BPARSER_DEFAULT_ENDIAN)

#define bparser_read_int8(Parser, Name) bparser_read_integral(Parser, Name, BPARSER_INT8, BPARSER_DEFAULT_ENDIAN)

#define bparser_read_uint16(Parser, Name) bparser_read_integral(Parser, Name, BPARSER_UINT16, BPARSER_DEFAULT_ENDIAN)

#define bparser_read_int16(Parser, Name) bparser_read_integral(Parser, Name, BPARSER_INT16, BPARSER_DEFAULT_ENDIAN)

#define bparser_read_uint24(Parser, Name) bparser_read_integral(Parser, Name, BPARSER_UINT24, BPARSER_DEFAULT_ENDIAN)

#define bparser_read_int24(Parser, Name) bparser_read_integral(Parser, Name, BPARSER_INT24, BPARSER_DEFAULT_ENDIAN)

#define bparser_read_uint32(Parser, Name) bparser_read_integral(Parser, Name, BPARSER_UINT32, BPARSER_DEFAULT_ENDIAN)

#define bparser_read_int32(Parser, Name) bparser_read_integral(Parser, Name, BPARSER_INT32, BPARSER_DEFAULT_ENDIAN)

#define bparser_read_uint64(Parser, Name) bparser_read_integral(Parser, Name, BPARSER_UINT64, BPARSER_DEFAULT_ENDIAN)

#define bparser_read_int64(Parser, Name) bparser_read_integral(Parser, Name, BPARSER_INT64, BPARSER_DEFAULT_ENDIAN)

#define bparser_read_uint128(Parser, Name) bparser_read_integral(Parser, Name, BPARSER_UINT128, BPARSER_DEFAULT_ENDIAN)

#define bparser_read_int128(Parser, Name) bparser_read_integral(Parser, Name, BPARSER_INT128, BPARSER_DEFAULT_ENDIAN)
 
#ifdef __cplusplus
extern "C"
{
#endif // __cplusplus
 
struct bparser_parser_s;  // Forward declare

#define BPARSER_BYTES_F_ARGS struct bparser_parser_s* MParser, uint8_t* Bytes, size_t Length

#define BPARSER_BYTES_SEQ_F_ARGS struct bparser_parser_s* MParser, uint8_t Byte, size_t Index

#define BPARSER_OVERRIDE_ERROR 99

#define BPARSER_OVERRIDE_TRUE 100

#define BPARSER_OVERRIDE_SKIP 101

#define BPARSER_OVERRIDE_DO_NOTHING 102

typedef void (*bparser_bytes_f)(BPARSER_BYTES_F_ARGS);

typedef void (*bparser_bytes_seq_f)(BPARSER_BYTES_SEQ_F_ARGS);

#define BPARSER_BOOL_HANDLER_F_ARGS uint8_t Boolean

#define BPARSER_BOOL_F_ARGS struct bparser_parser_s* MParser

typedef char (*bparser_bool_handler_f)(BPARSER_BOOL_HANDLER_F_ARGS);

typedef void (*bparser_bool_f)(BPARSER_BOOL_F_ARGS);

typedef struct bparser_bool_funcs_s
{
    bparser_bool_handler_f HFunc;
    bparser_bool_f Func;
}
bparser_bool_funcs_t;

typedef struct bparser_seek_data_s
{
    uint64_t Pos;
    uint8_t Mode;
}
bparser_seek_data_t;

typedef struct bparser_read_s
{
    uint8_t Type;
    char* Name;
    size_t Parameter1;
    bparser_bytes_f Parameter2;
    uint8_t Endian;
    bparser_bool_funcs_t Parameter3;
    bparser_seek_data_t Seek;
    bparser_bytes_seq_f Parameter4;
}
bparser_read_t;

typedef struct bparser_data_s
{
    void* DataPtr;
    uint8_t Type;
    char* Name;
    size_t NBytesLength;
}
bparser_data_t;

typedef void* (*bparser_calloc_like_f)(size_t num, size_t size);

typedef void (*bparser_free_like_f)(void* ptr);

typedef void* (*bparser_malloc_like_f)(size_t size);

typedef void* (*bparser_realloc_like_f)(void* ptr, size_t size);

typedef struct bparser_parser_s
{
    // Read order and data arrays
    bparser_read_t* ReadOrder;
    size_t ReadOrderLength;
    size_t ReadOrderMaxLength;
    bparser_data_t* Data;
    size_t DataCount;
    // Callbacks
    bparser_calloc_like_f CallocF;
    bparser_free_like_f FreeF;
    bparser_malloc_like_f MallocF;
    bparser_realloc_like_f ReallocF;
    // Endianess
    uint8_t Endian;
    // Position changeable with seek
    bparser_seek_data_t Seek;
    // Realloc method/factor
    double ReallocFactor;
    uint8_t ReallocMethod;
    // Override behaviour
    uint8_t Override;
}
bparser_parser_t;

bparser_parser_t* bparser_init(bparser_malloc_like_f MallocLikeFunc, bparser_calloc_like_f CallocLikeFunc, bparser_realloc_like_f ReallocLikeFunc, bparser_free_like_f FreeLikeFunc);

void bparser_destroy(bparser_parser_t* MParser);

void bparser_shallow_destroy(bparser_parser_t* MParser);

void* bparser_set_malloc(bparser_parser_t* MParser, bparser_malloc_like_f Malloc);

void* bparser_set_calloc(bparser_parser_t* MParser, bparser_calloc_like_f Calloc);

void* bparser_set_realloc(bparser_parser_t* MParser, bparser_realloc_like_f Realloc);

void* bparser_set_free(bparser_parser_t* MParser, bparser_free_like_f Free);

char bparser_read_integral(bparser_parser_t* MParser, const char* Name, uint8_t Type, uint8_t Endian);

char bparser_read_null_str(bparser_parser_t* MParser, const char* Name);

char bparser_read_unicode_from_utf8_null_str(bparser_parser_t* MParser, const char* Name);

char bparser_read_utf8_null_str(bparser_parser_t* MParser, const char* Name);

char bparser_read_fixed_len_str(bparser_parser_t* MParser, const char* Name, size_t Length);

char bparser_read_unicode_from_utf8_fixed_str(bparser_parser_t* MParser, const char* Name, size_t Length);

char bparser_read_utf8_fixed_len_str(bparser_parser_t* MParser, const char* Name, size_t Length);

char bparser_read_bytes(bparser_parser_t* MParser, const char* Name, size_t NBytes);

char bparser_read_bytes_and_run(bparser_parser_t* MParser, size_t NBytes, bparser_bytes_f Func);

char bparser_read_bytes_and_run_sequential(bparser_parser_t* MParser, size_t NBytes, bparser_bytes_seq_f Func);

char bparser_read_array(bparser_parser_t* MParser, const char* Name, size_t Items, uint8_t ItemType);

char bparser_read_2d_array(bparser_parser_t* MParser, const char* Name, size_t Cols, size_t Rows, uint8_t ItemType);

char bparser_read_float(bparser_parser_t* MParser, const char* Name);

char bparser_read_double(bparser_parser_t* MParser, const char* Name);

char bparser_read_unix_time(bparser_parser_t* MParser, const char* Name);

char bparser_read_8_booleans(bparser_parser_t* MParser, const char* Name);

char bparser_read_16_booleans(bparser_parser_t* MParser, const char* Name);

char bparser_read_24_booleans(bparser_parser_t* MParser, const char* Name);

char bparser_read_32_booleans(bparser_parser_t* MParser, const char* Name);

char bparser_read_64_booleans(bparser_parser_t* MParser, const char* Name);

char bparser_read_128_booleans(bparser_parser_t* MParser, const char* Name);

char bparser_read_bool_and_run(bparser_parser_t* MParser, bparser_bool_handler_f HFunc, bparser_bool_f Func);

char bparser_read(bparser_parser_t* MParser, uint8_t* Data, size_t Size);

char bparser_fread(bparser_parser_t* MParser, const char* Filename);

char bparser_check_magic_num(const uint8_t* Data, const uint8_t* MagicNum, size_t Length);

char bparser_check_magic_num_char(const uint8_t* Data, const char* MagicNum, size_t Length);

void* bparser_get(const bparser_parser_t* MParser, const char* Name);

void bparser_use_little_endian(bparser_parser_t* MParser);

void bparser_use_big_endian(bparser_parser_t* MParser);

char bparser_seek(bparser_parser_t* MParser, uint64_t Pos, uint8_t Mode);

char bparser_rewind(bparser_parser_t* MParser);

char bparser_unwind(bparser_parser_t* MParser);

const char* bparser_error_str(char Error);

size_t bparser_get_data_count(const bparser_parser_t* MParser);

size_t bparser_get_read_order_count(const bparser_parser_t* MParser);

bparser_read_t* bparser_get_read_order_at(const bparser_parser_t* MParser, size_t Index);

void* bparser_read_order_shallow_copy(const bparser_parser_t* MParser, bparser_read_t* Dest);

void* bparser_read_order_deep_copy(const bparser_parser_t* MParser, bparser_read_t* Dest);

char bparser_parser_set_realloc_method(bparser_parser_t* MParser, double N, uint8_t ReallocMethod);

void* bparser_data_shallow_copy(const bparser_parser_t* MParser, bparser_data_t* Dest);

void* bparser_data_deep_copy(const bparser_parser_t* MParser, bparser_data_t* Dest, char* Failure);

const bparser_data_t* bparser_get_data_at(const bparser_parser_t* MParser, size_t Indx);

void bparser_destroy_read_order(bparser_read_t* Array, size_t Length, bparser_free_like_f FreeCallback);

void bparser_destroy_data(bparser_data_t* Array, size_t Length, bparser_free_like_f FreeCallback);

char bparser_rename(bparser_parser_t* MParser, const char* Src, const char* New);

void* bparser_parser_shallow_copy(bparser_parser_t* Src, bparser_parser_t* Dest);

void* bparser_parser_deep_copy(bparser_parser_t* Src, bparser_parser_t* Dest, char* Error);

void* bparser_parser_move(bparser_parser_t* Src, bparser_parser_t* Dest);

char bparser_set_override(bparser_parser_t* MParser, uint8_t Override);
 
#ifdef BPARSER_IMPLEMENTATION
 
bparser_parser_t* bparser_init(bparser_malloc_like_f MallocLikeFunc, bparser_calloc_like_f CallocLikeFunc, bparser_realloc_like_f ReallocLikeFunc, bparser_free_like_f FreeLikeFunc)
{
    bparser_malloc_like_f _M = (MallocLikeFunc) ? MallocLikeFunc : malloc;
    bparser_calloc_like_f _C = (CallocLikeFunc) ? CallocLikeFunc : calloc;
    bparser_realloc_like_f _R = (ReallocLikeFunc) ? ReallocLikeFunc : realloc;
    bparser_free_like_f _F = (FreeLikeFunc) ? FreeLikeFunc : free;
 
    void* _1 = _M(sizeof(bparser_parser_t));
    void* _2 = _C(2, sizeof(bparser_read_t));
 
    if (!_1 || !_2)
    {
        return NULL;
    }
 
    bparser_parser_t* _New = (bparser_parser_t*)_1;
    _New->ReadOrder = (bparser_read_t*)_2;
    _New->ReadOrderLength = 0;
    _New->ReadOrderMaxLength = 2;
    _New->Data = NULL;
    _New->DataCount = 0;
 
    // Set callbacks
    _New->MallocF = _M;
    _New->CallocF = _C;
    _New->ReallocF = _R;
    _New->FreeF = _F;
 
    _New->Endian = BPARSER_BIG_ENDIAN;
 
    _New->Seek.Pos = 0;
    _New->Seek.Mode = BPARSER_NO_SEEK;
 
    _New->ReallocMethod = BPARSER_REALLOC_METHOD_MULT;
    _New->ReallocFactor = 2.0;
 
    _New->Override = BPARSER_OVERRIDE_ERROR;
 
    return _New;
}
 
void bparser_destroy(bparser_parser_t* MParser)
{
    if (!MParser)
    {
        return;
    }
    bparser_destroy_read_order(MParser->ReadOrder, MParser->ReadOrderLength, MParser->FreeF);
    bparser_destroy_data(MParser->Data, MParser->DataCount, MParser->FreeF);
    MParser->FreeF(MParser);
}
 
void bparser_shallow_destroy(bparser_parser_t* MParser)
{
    if (!MParser)
    {
        return;
    }
    MParser->FreeF(MParser);
}
 
void* bparser_set_malloc(bparser_parser_t* MParser, bparser_malloc_like_f Malloc)
{
    if (!MParser) { return NULL; }
    MParser->MallocF = (Malloc) ? Malloc : malloc;
    return (MParser->MallocF);
}
 
void* bparser_set_calloc(bparser_parser_t* MParser, bparser_calloc_like_f Calloc)
{
    if (!MParser) { return NULL; }
    MParser->CallocF = (Calloc) ? Calloc : calloc;
    return (MParser->CallocF);
}
 
void* bparser_set_realloc(bparser_parser_t* MParser, bparser_realloc_like_f Realloc)
{
    if (!MParser) { return NULL; }
    MParser->ReallocF = (Realloc) ? Realloc : realloc;
    return (MParser->ReallocF);
}
 
void* bparser_set_free(bparser_parser_t* MParser, bparser_free_like_f Free)
{
    if (!MParser) { return NULL; }
    MParser->FreeF = (Free) ? Free : free;
    return (MParser->FreeF);
}
 
char _resize_ro_array(bparser_parser_t* MParser)
{
    if (MParser->ReadOrderLength + 1 > MParser->ReadOrderMaxLength)
    {
        size_t NewSize = 0;
 
        switch (MParser->ReallocMethod)
        {
            case BPARSER_REALLOC_METHOD_MULT:
                NewSize = (size_t)(((double)MParser->ReadOrderMaxLength) * MParser->ReallocFactor);
                break;
 
            case BPARSER_REALLOC_METHOD_PLUS:
                NewSize = (size_t)(((double)MParser->ReadOrderMaxLength) + MParser->ReallocFactor);
                break;
        }
 
        void* _New = MParser->ReallocF(MParser->ReadOrder, sizeof(bparser_read_t) * (NewSize));
        if (_New)
        {
            MParser->ReadOrder = _New;
            MParser->ReadOrderMaxLength = NewSize;
            return 1;
        }
        return 0;
    }
    return 1;
}
 
bparser_read_t* _init_read(bparser_parser_t* MParser)
{
    bparser_read_t* _Temp = &( MParser->ReadOrder[MParser->ReadOrderLength] );
    _Temp->Name = NULL;
    _Temp->Endian = MParser->Endian;
    _Temp->Parameter1 = 0;
    _Temp->Parameter2 = NULL;
    _Temp->Parameter3 = (bparser_bool_funcs_t){NULL, NULL};
    _Temp->Parameter4 = NULL;
    _Temp->Seek = MParser->Seek;
    _Temp->Type = 0xFF;
    return _Temp;
}
 
bparser_read_t* _find_collision(bparser_parser_t* MParser, const char* Name)
{
    for (size_t I = 0; I < MParser->ReadOrderLength; I++)
    {
        if (!MParser->ReadOrder[I].Name)
        {
            continue;
        }
 
        if ( strcmp(MParser->ReadOrder[I].Name, Name) == 0 )
        {
            return &(MParser->ReadOrder[I]);
        }
    }
    return NULL;
}
 
bparser_read_t* _get_read_rule_to_set(bparser_parser_t* MParser, const char* Name, char* Error)
{
    bparser_read_t* _CollidedWith = NULL;
 
    if (MParser->Override != BPARSER_OVERRIDE_DO_NOTHING)
    {
        _CollidedWith = _find_collision(MParser, Name);
    }
 
    if (_CollidedWith)
    {
        switch (MParser->Override)
        {
            case BPARSER_OVERRIDE_ERROR:
                *Error = BPARSER_NAME_IS_NOT_UNIQUE;
                return NULL;
 
            case BPARSER_OVERRIDE_TRUE:
                return _CollidedWith;
 
            case BPARSER_OVERRIDE_SKIP:
                *Error = 1;
                return NULL;
        }
    }
 
    bparser_read_t* _Temp = _init_read(MParser);
    MParser->ReadOrderLength++;
    return _Temp;
}
 
char bparser_read_integral(bparser_parser_t* MParser, const char* Name, uint8_t Type, uint8_t Endian)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Name)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Name) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    if (Type > BPARSER_INT128)
    {
        return BPARSER_BAD_INTEGRAL_TYPE;
    }
 
    if (Endian != BPARSER_BIG_ENDIAN && Endian != BPARSER_LITTLE_ENDIAN && Endian != BPARSER_DEFAULT_ENDIAN)
    {
        return BPARSER_UNKNOWN_ENDIAN;
    }
 
    if(!_resize_ro_array(MParser))
    {
        return BPARSER_RO_ARRAY_ERROR;
    }
 
    void* _Name = MParser->MallocF( strlen(Name) + 1 );
 
    if (!_Name)
    {
        return BPARSER_MALLOC_ERROR;
    }
 
    char Error = 0;
    bparser_read_t* _Temp = _get_read_rule_to_set(MParser, Name, &Error);
 
    if (!_Temp)
    {
        return Error;
    }
 
    _Temp->Name = (char*)_Name;
    strcpy(_Temp->Name, Name);
    _Temp->Type = Type;
 
    if (Endian != BPARSER_DEFAULT_ENDIAN)
    {
        _Temp->Endian = Endian;
    }
 
    // Reset seek
    MParser->Seek.Pos = 0;
    MParser->Seek.Mode = BPARSER_NO_SEEK;
    return 1;
}
 
char bparser_read_null_str(bparser_parser_t* MParser, const char* Name)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Name)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Name) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    if(!_resize_ro_array(MParser))
    {
        return BPARSER_RO_ARRAY_ERROR;
    }
 
    void* _Name = MParser->MallocF( strlen(Name) + 1 );
 
    if (!_Name)
    {
        return BPARSER_MALLOC_ERROR;
    }
 
    char Error = 0;
    bparser_read_t* _Temp = _get_read_rule_to_set(MParser, Name, &Error);
 
    if (!_Temp)
    {
        return Error;
    }
 
    _Temp->Name = (char*)_Name;
    strcpy(_Temp->Name, Name);
    _Temp->Type = BPARSER_STR;
    MParser->Seek.Pos = 0;
    MParser->Seek.Mode = BPARSER_NO_SEEK;
    return 1;
}
 
char bparser_read_unicode_from_utf8_null_str(bparser_parser_t* MParser, const char* Name)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Name)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Name) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    if(!_resize_ro_array(MParser))
    {
        return BPARSER_RO_ARRAY_ERROR;
    }
 
    void* _Name = MParser->MallocF( strlen(Name) + 1 );
 
    if (!_Name)
    {
        return BPARSER_MALLOC_ERROR;
    }
 
    char Error = 0;
    bparser_read_t* _Temp = _get_read_rule_to_set(MParser, Name, &Error);
 
    if (!_Temp)
    {
        return Error;
    }
 
    _Temp->Name = (char*)_Name;
    strcpy(_Temp->Name, Name);
    _Temp->Type = BPARSER_UNICODE_FROM_UTF8_STR;
    MParser->Seek.Pos = 0;
    MParser->Seek.Mode = BPARSER_NO_SEEK;
    return 1;
}
 
char bparser_read_utf8_null_str(bparser_parser_t* MParser, const char* Name)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Name)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Name) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    if(!_resize_ro_array(MParser))
    {
        return BPARSER_RO_ARRAY_ERROR;
    }
 
    void* _Name = MParser->MallocF( strlen(Name) + 1 );
 
    if (!_Name)
    {
        return BPARSER_MALLOC_ERROR;
    }
 
    char Error = 0;
    bparser_read_t* _Temp = _get_read_rule_to_set(MParser, Name, &Error);
 
    if (!_Temp)
    {
        return Error;
    }
 
    _Temp->Name = (char*)_Name;
    strcpy(_Temp->Name, Name);
    _Temp->Type = BPARSER_UTF8_STR;
    MParser->Seek.Pos = 0;
    MParser->Seek.Mode = BPARSER_NO_SEEK;
    return 1;
}
 
char bparser_read_fixed_len_str(bparser_parser_t* MParser, const char* Name, size_t Length)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Name)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Name) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    if (Length == 0)
    {
        return BPARSER_ZERO_LENGTH;
    }
 
    if(!_resize_ro_array(MParser))
    {
        return BPARSER_RO_ARRAY_ERROR;
    }
 
    void* _Name = MParser->MallocF( strlen(Name) + 1 );
 
    if (!_Name)
    {
        return BPARSER_MALLOC_ERROR;
    }
 
    char Error = 0;
    bparser_read_t* _Temp = _get_read_rule_to_set(MParser, Name, &Error);
 
    if (!_Temp)
    {
        return Error;
    }
 
    _Temp->Name = (char*)_Name;
    strcpy(_Temp->Name, Name);
    _Temp->Type = BPARSER_FIXED_STR;
    _Temp->Parameter1 = Length;
    MParser->Seek.Pos = 0;
    MParser->Seek.Mode = BPARSER_NO_SEEK;
    return 1;
}
 
char bparser_read_unicode_from_utf8_fixed_str(bparser_parser_t* MParser, const char* Name, size_t Length)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Name)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Name) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    if (Length == 0)
    {
        return BPARSER_ZERO_LENGTH;
    }
 
    if(!_resize_ro_array(MParser))
    {
        return BPARSER_RO_ARRAY_ERROR;
    }
 
    void* _Name = MParser->MallocF( strlen(Name) + 1 );
 
    if (!_Name)
    {
        return BPARSER_MALLOC_ERROR;
    }
 
    char Error = 0;
    bparser_read_t* _Temp = _get_read_rule_to_set(MParser, Name, &Error);
 
    if (!_Temp)
    {
        return Error;
    }
 
    _Temp->Name = (char*)_Name;
    strcpy(_Temp->Name, Name);
    _Temp->Type = BPARSER_UNICODE_FROM_UTF8_F_STR;
    _Temp->Parameter1 = Length;
    MParser->Seek.Pos = 0;
    MParser->Seek.Mode = BPARSER_NO_SEEK;
    return 1;
}
 
char bparser_read_utf8_fixed_len_str(bparser_parser_t* MParser, const char* Name, size_t Length)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Name)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Name) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    if (Length == 0)
    {
        return BPARSER_ZERO_LENGTH;
    }
 
    if(!_resize_ro_array(MParser))
    {
        return BPARSER_RO_ARRAY_ERROR;
    }
 
    void* _Name = MParser->MallocF( strlen(Name) + 1 );
 
    if (!_Name)
    {
        return BPARSER_MALLOC_ERROR;
    }
 
    char Error = 0;
    bparser_read_t* _Temp = _get_read_rule_to_set(MParser, Name, &Error);
 
    if (!_Temp)
    {
        return Error;
    }
 
    _Temp->Name = (char*)_Name;
    strcpy(_Temp->Name, Name);
    _Temp->Type = BPARSER_UTF8_F_STR;
    _Temp->Parameter1 = Length;
    MParser->Seek.Pos = 0;
    MParser->Seek.Mode = BPARSER_NO_SEEK;
    return 1;
}
 
char bparser_read_bytes(bparser_parser_t* MParser, const char* Name, size_t NBytes)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Name)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Name) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    if (NBytes == 0)
    {
        return BPARSER_ZERO_LENGTH;
    }
 
    if(!_resize_ro_array(MParser))
    {
        return BPARSER_RO_ARRAY_ERROR;
    }
 
    void* _Name = MParser->MallocF( strlen(Name) + 1 );
 
    if (!_Name)
    {
        return BPARSER_MALLOC_ERROR;
    }
 
    char Error = 0;
    bparser_read_t* _Temp = _get_read_rule_to_set(MParser, Name, &Error);
 
    if (!_Temp)
    {
        return Error;
    }
 
    _Temp->Name = (char*)_Name;
    strcpy(_Temp->Name, Name);
    _Temp->Type = BPARSER_N_BYTES;
    _Temp->Parameter1 = NBytes;
    MParser->Seek.Pos = 0;
    MParser->Seek.Mode = BPARSER_NO_SEEK;
    return 1;
}
 
char bparser_read_bytes_and_run(bparser_parser_t* MParser, size_t NBytes, bparser_bytes_f Func)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (NBytes == 0)
    {
        return BPARSER_ZERO_LENGTH;
    }
 
    if(!_resize_ro_array(MParser))
    {
        return BPARSER_RO_ARRAY_ERROR;
    }
 
    bparser_read_t* _Temp = _init_read(MParser);
    _Temp->Type = BPARSER_N_BYTES;
    _Temp->Parameter1 = NBytes;
 
    if (Func == NULL)
    {
        return BPARSER_NO_FUNC_PASSED;
    }
    _Temp->Parameter2 = Func;
 
    MParser->Seek.Pos = 0;
    MParser->Seek.Mode = BPARSER_NO_SEEK;
    MParser->ReadOrderLength++;
    return 1;
}
 
char bparser_read_bytes_and_run_sequential(bparser_parser_t* MParser, size_t NBytes, bparser_bytes_seq_f Func)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (NBytes == 0)
    {
        return BPARSER_ZERO_LENGTH;
    }
 
    if(!_resize_ro_array(MParser))
    {
        return BPARSER_RO_ARRAY_ERROR;
    }
 
    bparser_read_t* _Temp = _init_read(MParser);
    _Temp->Type = BPARSER_N_BYTES;
    _Temp->Parameter1 = NBytes;
 
    if (Func == NULL)
    {
        return BPARSER_NO_FUNC_PASSED;
    }
    _Temp->Parameter4 = Func;
 
    MParser->Seek.Pos = 0;
    MParser->Seek.Mode = BPARSER_NO_SEEK;
    MParser->ReadOrderLength++;
    return 1;
}
 
char bparser_read_array(bparser_parser_t* MParser, const char* Name, size_t Items, uint8_t ItemType)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Name)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Name) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    if (Items == 0)
    {
        return BPARSER_ZERO_LENGTH;
    }
 
    if (ItemType > BPARSER_BOOL_RUN)
    {
        return BPARSER_UNKNOWN_READ_TYPE;
    }
 
    for (size_t Item = 0; Item < Items; Item++)
    {
        if(!_resize_ro_array(MParser))
        {
            return BPARSER_RO_ARRAY_ERROR;
        }
 
        void* _Name = MParser->MallocF( strlen(Name) + 16 );
 
        if (!_Name)
        {
            return BPARSER_MALLOC_ERROR;
        }
 
        if(sprintf((char*)_Name, "%s[%lld]", Name, Item) < 0)
        {
            return BPARSER_SPRINTF_ERROR;
        }
 
        char Error = 0;
        bparser_read_t* _Temp = _get_read_rule_to_set(MParser, (char*)_Name, &Error);
 
        if (!_Temp)
        {
            return Error;
        }
 
        _Temp->Name = (char*)_Name;
        _Temp->Type = ItemType;
        MParser->Seek.Pos = 0;
        MParser->Seek.Mode = BPARSER_NO_SEEK;
    }
    return 1;
}
 
char bparser_read_2d_array(bparser_parser_t* MParser, const char* Name, size_t Cols, size_t Rows, uint8_t ItemType)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Name)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Name) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    if ((!Cols) || (!Rows))
    {
        return BPARSER_ZERO_LENGTH;
    }
 
    if (ItemType > BPARSER_BOOL_RUN)
    {
        return BPARSER_UNKNOWN_READ_TYPE;
    }
 
    for (size_t Y = 0; Y < Rows; Y++)
    {
        for (size_t X = 0; X < Cols; X++)
        {
            if(!_resize_ro_array(MParser))
            {
                return BPARSER_RO_ARRAY_ERROR;
            }
 
            void* _Name = MParser->MallocF( strlen(Name) + 16 );
 
            if (!_Name)
            {
                return BPARSER_MALLOC_ERROR;
            }
 
            if(sprintf((char*)_Name, "%s[%lld][%lld]", Name, Y, X) < 0)
            {
                return BPARSER_SPRINTF_ERROR;
            }
 
            char Error = 0;
            bparser_read_t* _Temp = _get_read_rule_to_set(MParser, (char*)_Name, &Error);
 
            if (!_Temp)
            {
                return Error;
            }
 
            _Temp->Name = _Name;
            _Temp->Type = ItemType;
            MParser->Seek.Pos = 0;
            MParser->Seek.Mode = BPARSER_NO_SEEK;
        }
    }
    return 1;
}
 
char bparser_read_float(bparser_parser_t* MParser, const char* Name)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Name)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Name) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    if(!_resize_ro_array(MParser))
    {
        return BPARSER_RO_ARRAY_ERROR;
    }
 
    void* _Name = MParser->MallocF( strlen(Name) + 1 );
 
    if (!_Name)
    {
        return BPARSER_MALLOC_ERROR;
    }
 
    char Error = 0;
    bparser_read_t* _Temp = _get_read_rule_to_set(MParser, Name, &Error);
 
    if (!_Temp)
    {
        return Error;
    }
 
    _Temp->Name = (char*)_Name;
    strcpy(_Temp->Name, Name);
    _Temp->Type = BPARSER_FLOAT;
    MParser->Seek.Pos = 0;
    MParser->Seek.Mode = BPARSER_NO_SEEK;
    return 1;
}
 
char bparser_read_double(bparser_parser_t* MParser, const char* Name)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Name)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Name) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    if(!_resize_ro_array(MParser))
    {
        return BPARSER_RO_ARRAY_ERROR;
    }
 
    void* _Name = MParser->MallocF( strlen(Name) + 1 );
 
    if (!_Name)
    {
        return BPARSER_MALLOC_ERROR;
    }
 
    char Error = 0;
    bparser_read_t* _Temp = _get_read_rule_to_set(MParser, Name, &Error);
 
    if (!_Temp)
    {
        return Error;
    }
 
    _Temp->Name = (char*)_Name;
    strcpy(_Temp->Name, Name);
    _Temp->Type = BPARSER_DOUBLE;
    MParser->Seek.Pos = 0;
    MParser->Seek.Mode = BPARSER_NO_SEEK;
    return 1;
}
 
char bparser_read_unix_time(bparser_parser_t* MParser, const char* Name)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Name)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Name) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    if(!_resize_ro_array(MParser))
    {
        return BPARSER_RO_ARRAY_ERROR;
    }
 
    void* _Name = MParser->MallocF( strlen(Name) + 1 );
 
    if (!_Name)
    {
        return BPARSER_MALLOC_ERROR;
    }
 
    char Error = 0;
    bparser_read_t* _Temp = _get_read_rule_to_set(MParser, Name, &Error);
 
    if (!_Temp)
    {
        return Error;
    }
 
    _Temp->Name = (char*)_Name;
    strcpy(_Temp->Name, Name);
    _Temp->Type = BPARSER_UNIX_TIME;
    MParser->Seek.Pos = 0;
    MParser->Seek.Mode = BPARSER_NO_SEEK;
    return 1;
}
 
char _bparser_bool(bparser_parser_t* MParser, const char* Name, size_t A)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Name)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Name) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    if (A == 0)
    {
        return BPARSER_NO_BOOLS_TO_READ;
    }
 
    for (size_t U = 0; U < A; U++)
    {
        for (size_t W = 0; W < 8; W++)
        {
            if(!_resize_ro_array(MParser))
            {
                return BPARSER_RO_ARRAY_ERROR;
            }
 
            void* _Name = MParser->MallocF( strlen(Name) + 16 );
 
            if (!_Name)
            {
                return BPARSER_MALLOC_ERROR;
            }
 
            if(sprintf((char*)_Name, "%s[%lld]", Name, W + (U * 8)) < 0)
            {
                return BPARSER_SPRINTF_ERROR;
            }
 
            char Error = 0;
            bparser_read_t* _Temp = _get_read_rule_to_set(MParser, _Name, &Error);
 
            if (!_Temp)
            {
                return Error;
            }
 
            _Temp->Name = _Name;
            _Temp->Type = BPARSER_BOOLS;
            _Temp->Parameter1 = W;
            MParser->Seek.Pos = 0;
            MParser->Seek.Mode = BPARSER_NO_SEEK;
        }
    }
 
    return 1;
}
 
char bparser_read_8_booleans(bparser_parser_t* MParser, const char* Name)
{
    return _bparser_bool(MParser, Name, 1);
}
 
char bparser_read_16_booleans(bparser_parser_t* MParser, const char* Name)
{
    return _bparser_bool(MParser, Name, 2);
}
 
char bparser_read_24_booleans(bparser_parser_t* MParser, const char* Name)
{
    return _bparser_bool(MParser, Name, 3);
}
 
char bparser_read_32_booleans(bparser_parser_t* MParser, const char* Name)
{
    return _bparser_bool(MParser, Name, 4);
}
 
char bparser_read_64_booleans(bparser_parser_t* MParser, const char* Name)
{
    return _bparser_bool(MParser, Name, 8);
}
 
char bparser_read_128_booleans(bparser_parser_t* MParser, const char* Name)
{
    return _bparser_bool(MParser, Name, 16);
}
 
char _bparser_default_hfunc(uint8_t Boolean)
{
    return (Boolean > 0);
}
 
char bparser_read_bool_and_run(bparser_parser_t* MParser, bparser_bool_handler_f HFunc, bparser_bool_f Func)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if(!_resize_ro_array(MParser))
    {
        return BPARSER_RO_ARRAY_ERROR;
    }
 
    bparser_read_t* _Temp = _init_read(MParser);
    _Temp->Type = BPARSER_BOOL_RUN;
 
    _Temp->Parameter3.HFunc = (HFunc) ? HFunc : _bparser_default_hfunc;
    if (Func == NULL)
    {
        return BPARSER_NO_FUNC_PASSED;
    }
    _Temp->Parameter3.Func = Func;
 
    MParser->Seek.Pos = 0;
    MParser->Seek.Mode = BPARSER_NO_SEEK;
    MParser->ReadOrderLength++;
    return 1;
}
 
void _utf8_get_length(const uint8_t* Data, size_t* Chars, size_t* LengthInBytes, size_t FixedLen)
{
    size_t Pos = 0;
    size_t Char = 0;
 
    while (Char < FixedLen)
    {
        uint8_t Curr = *(Data + Pos);
 
        if ( Curr == 0 )
        {
            *LengthInBytes += 1;
            break;
        }
 
        if ( Curr <= 127 )
        {
            // byte starts with 0, which means no further bytes are read
            Pos += 1;
            *LengthInBytes += 1;
        }
        else if ( Curr >= 192 && Curr <= 223 )
        {
            // byte starts with 110, which means the UTF8 char is encoded in 2 bytes
            Pos += 2;
            *LengthInBytes += 2;
        }
        else if ( Curr >= 224 && Curr <= 239 )
        {
            // byte starts with 1110, which means the UTF8 char is encoded in 3 bytes
            Pos += 3;
            *LengthInBytes += 3;
        }
        else if ( Curr >= 240 && Curr <= 247 )
        {
            // byte starts with 11110, which means the UTF8 char is encoded in 4 bytes
            Pos += 4;
            *LengthInBytes += 4;
        }
 
        if (Chars)
        {
            (*Chars) += 1;
        }
 
        Char++;
    }
}
 
uint32_t _utf8_read(const uint8_t* Data, size_t* Offset)
{
    uint8_t First = *(Data);
 
    if ( First >= 128 && First <= 191 )
    {
        // Continuation byte at the beginning, abort
        (*Offset)++;
        return 0xFFFD;
    }
 
    if ( First <= 127 )
    {
        // byte starts with 0, which means no further bytes are read
        (*Offset)++;
        return (uint32_t)First;
    }
 
    uint8_t Second = *(Data + 1);
 
    if ( First >= 192 && First <= 223 )
    {
        // byte starts with 110, which means the UTF8 char is encoded in 2 bytes
 
        // Check overlong
        if ( (First == 0xC0 || First == 0xC1) && Second < 0xA0)
        {
            return 0xFFFD;
        }
 
        if ( Second >= 128 && Second <= 191 )
        {
            // Second byte starts with bits 10, continue
            (*Offset) += 2;
            uint32_t _1 = (((uint32_t)First) & 31) << 6;
            uint32_t _2 = ((uint32_t)Second) & 63;
            uint32_t _F = (_1 | _2);
 
            // utf16 surrogate range
            if (_F >= 0xD800 && _F <= 0xDFFF)
            {
                return 0xFFFD;
            }
 
            return _F;
        }
        else
        {
            (*Offset) += 2;
            return 0xFFFD;
        }
    }
 
    uint8_t Third = *(Data + 2);
 
    if ( First >= 224 && First <= 239 )
    {
        // byte starts with 1110, which means the UTF8 char is encoded in 3 bytes
 
        // Check overlong
        if ( First == 0xE0 && Second < 0xA0 )
        {
            return 0xFFFD;
        }
 
        (*Offset) += 3;
        if ( Second < 128 || Second > 191 )
        {
            return 0xFFFD;
        }
        if ( Third < 128 || Third > 191 )
        {
            return 0xFFFD;
        }
        // `Second` and `Third` bytes are valid continuation bytes
        uint32_t _1 = (((uint32_t)First) & 15) << 12;
        uint32_t _2 = (((uint32_t)Second) & 63) << 6;
        uint32_t _3 = ((uint32_t)Third) & 63;
        return (_1 | _2 | _3);
    }
 
    uint8_t Fourth = *(Data + 3);
 
    if ( First >= 240 && First <= 247 )
    {
        // byte starts with 11110, which means the UTF8 char is encoded in 4 bytes
 
        // Check if less than 0x90 because
        // hello
        // i've been waiting here for you
        // everlong (encoding)
        if (First == 0xF0 && Second < 0x90)
        {
            return 0xFFFD;
        }
 
        (*Offset) += 4;
        if ( Second < 128 || Second > 191 )
        {
            return 0xFFFD;
        }
        if ( Third < 128 || Third > 191 )
        {
            return 0xFFFD;
        }
        if ( Fourth < 128 || Fourth > 191 )
        {
            return 0xFFFD;
        }
        // `Second` and `Third` and `Fourth` bytes are valid continuation bytes, proceed
        uint32_t _1 = (((uint32_t)First) & 7) << 18;
        uint32_t _2 = (((uint32_t)Second) & 63) << 12;
        uint32_t _3 = (((uint32_t)Third) & 63) << 6;
        uint32_t _4 = ((uint32_t)Fourth) & 63;
        uint32_t _F = (_1 | _2 | _3 | _4);
 
        if (_F > 0x10FFFF)
        {
            return 0xFFFD;
        }
 
        return _F;
    }
 
    (*Offset)++;
    return 0xFFFD;
}
 
char bparser_read(bparser_parser_t* MParser, uint8_t* Data, size_t Size)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Data)
    {
        return BPARSER_NULL_DATA;
    }
 
    if (Size == 0)
    {
        return BPARSER_NOTHING_TO_PARSE;
    }
 
    bparser_destroy_data(MParser->Data, MParser->DataCount, MParser->FreeF);
    MParser->Data = NULL;
 
    void* _DataPtr = MParser->MallocF( sizeof(bparser_data_t) * MParser->ReadOrderLength );
 
    if (!_DataPtr)
    {
        return BPARSER_MALLOC_ERROR;
    }
 
    memset(_DataPtr, 0, sizeof(bparser_data_t) * MParser->ReadOrderLength);
    MParser->Data = (bparser_data_t*)_DataPtr;
    MParser->DataCount = MParser->ReadOrderLength;
    MParser->Seek = (bparser_seek_data_t){0, BPARSER_NO_SEEK};
    size_t Pos = 0;
 
    for (size_t ReadPos = 0; ReadPos < MParser->ReadOrderLength; ReadPos++)
    {
        uint8_t ReadType = MParser->ReadOrder[ReadPos].Type;
        size_t Parameter1 = MParser->ReadOrder[ReadPos].Parameter1;
        bparser_bytes_f Parameter2 = MParser->ReadOrder[ReadPos].Parameter2;
        uint8_t Endianess = MParser->ReadOrder[ReadPos].Endian;
        bparser_bool_funcs_t* Parameter3 = &( MParser->ReadOrder[ReadPos].Parameter3 );
        bparser_seek_data_t* SeekData = &( MParser->ReadOrder[ReadPos].Seek );
        bparser_bytes_seq_f Parameter4 = MParser->ReadOrder[ReadPos].Parameter4;
 
        MParser->Data[ReadPos].Name = NULL;
        MParser->Data[ReadPos].Type = 0;
        MParser->Data[ReadPos].DataPtr = NULL;
        MParser->Data[ReadPos].NBytesLength = 0;
 
        if (SeekData->Mode == BPARSER_SEEK_TO)
        {
            Pos = SeekData->Pos;
        }
        else if (SeekData->Mode == BPARSER_SEEK_FORWARD)
        {
            Pos += SeekData->Pos;
        }
        else if (SeekData->Mode == BPARSER_SEEK_BACKWARD)
        {
            if (SeekData->Pos > Pos)
            {
                return BPARSER_BACKWARD_SEEK_ERROR;
            }
            Pos -= SeekData->Pos;
        }
        else if (SeekData->Mode == BPARSER_SEEK_FROM_END)
        {
            if ( ((int64_t)Size) - ((int64_t)SeekData->Pos + 1) < 0 )
            {
                return BPARSER_SEEK_FROM_END_ERROR;
            }
            Pos = Size - (SeekData->Pos + 1);
        }
 
        if (Pos >= Size)
        {
            return BPARSER_EOF_ERROR;
        }
 
        void* _DataTypePtr = NULL;
 
        if (ReadType == BPARSER_UINT8 || ReadType == BPARSER_INT8)
        {
            _DataTypePtr = MParser->MallocF(1);
 
            if (!_DataTypePtr)
            {
                return BPARSER_MALLOC_ERROR;
            }
 
            uint8_t* _Temp = (uint8_t*)_DataTypePtr;
            *_Temp = *(Data + Pos);
            MParser->Data[ReadPos].DataPtr = (void*)_Temp;
            Pos += 1;
        }
        else if (ReadType == BPARSER_UINT16 || ReadType == BPARSER_INT16)
        {
            _DataTypePtr = MParser->MallocF(2);
 
            if (!_DataTypePtr)
            {
                return BPARSER_MALLOC_ERROR;
            }
 
            uint16_t* _Temp = (uint16_t*)_DataTypePtr;
            uint16_t B1 = *(Data + Pos);
            uint16_t B2 = *(Data + Pos + 1);
 
            if (Endianess == BPARSER_BIG_ENDIAN)
            {
                *_Temp = (B1 << 8) + B2;
            }
            else if (Endianess == BPARSER_LITTLE_ENDIAN)
            {
                *_Temp = (B2 << 8) + B1;
            }
            else
            {
                return BPARSER_UNKNOWN_ENDIAN;
            }
 
            MParser->Data[ReadPos].DataPtr = (void*)_Temp;
            Pos += 2;
        }
        else if (ReadType == BPARSER_UINT32 || ReadType == BPARSER_INT32)
        {
            _DataTypePtr = MParser->MallocF(4);
 
            if (!_DataTypePtr)
            {
                return BPARSER_MALLOC_ERROR;
            }
 
            uint32_t* _Temp = (uint32_t*)_DataTypePtr;
            uint32_t B1 = *(Data + Pos);
            uint32_t B2 = *(Data + Pos + 1);
            uint32_t B3 = *(Data + Pos + 2);
            uint32_t B4 = *(Data + Pos + 3);
 
            if (Endianess == BPARSER_BIG_ENDIAN)
            {
                *_Temp = (B1 << 24) + (B2 << 16) + (B3 << 8) + B4;
            }
            else if (Endianess == BPARSER_LITTLE_ENDIAN)
            {
                *_Temp = (B4 << 24) + (B3 << 16) + (B2 << 8) + B1;
            }
            else
            {
                return BPARSER_UNKNOWN_ENDIAN;
            }
 
            MParser->Data[ReadPos].DataPtr = (void*)_Temp;
            Pos += 4;
        }
        else if (ReadType == BPARSER_UINT64 || ReadType == BPARSER_INT64)
        {
            _DataTypePtr = MParser->MallocF(8);
 
            if (!_DataTypePtr)
            {
                return BPARSER_MALLOC_ERROR;
            }
 
            uint64_t* _Temp = (uint64_t*)_DataTypePtr;
            uint64_t B1 = *(Data + Pos);
            uint64_t B2 = *(Data + Pos + 1);
            uint64_t B3 = *(Data + Pos + 2);
            uint64_t B4 = *(Data + Pos + 3);
            uint64_t B5 = *(Data + Pos + 4);
            uint64_t B6 = *(Data + Pos + 5);
            uint64_t B7 = *(Data + Pos + 6);
            uint64_t B8 = *(Data + Pos + 7);
 
            if (Endianess == BPARSER_BIG_ENDIAN)
            {
                *_Temp = (B1 << 56) + (B2 << 48) + (B3 << 40) + (B4 << 32) + (B5 << 24) + (B6 << 16) + (B7 << 8) + B8;
            }
            else if (Endianess == BPARSER_LITTLE_ENDIAN)
            {
                *_Temp = (B8 << 56) + (B7 << 48) + (B6 << 40) + (B5 << 32) + (B4 << 24) + (B3 << 16) + (B2 << 8) + B1;
            }
            else
            {
                return BPARSER_UNKNOWN_ENDIAN;
            }
 
            MParser->Data[ReadPos].DataPtr = (void*)_Temp;
            Pos += 8;
        }
        else if (ReadType == BPARSER_UINT128 || ReadType == BPARSER_INT128)
        {
            _DataTypePtr = MParser->MallocF(16);
 
            if (!_DataTypePtr)
            {
                return BPARSER_MALLOC_ERROR;
            }
 
            uint64_t _1 = 0;
            uint64_t _2 = 0;
 
            uint64_t B1 = *(Data + Pos);
            uint64_t B2 = *(Data + Pos + 1);
            uint64_t B3 = *(Data + Pos + 2);
            uint64_t B4 = *(Data + Pos + 3);
            uint64_t B5 = *(Data + Pos + 4);
            uint64_t B6 = *(Data + Pos + 5);
            uint64_t B7 = *(Data + Pos + 6);
            uint64_t B8 = *(Data + Pos + 7);
            uint64_t B9 = *(Data + Pos + 8);  // 8 as in, size of uint64 in bytes
            uint64_t B10 = *(Data + Pos + 8 + 1);
            uint64_t B11 = *(Data + Pos + 8 + 2);
            uint64_t B12 = *(Data + Pos + 8 + 3);
            uint64_t B13 = *(Data + Pos + 8 + 4);
            uint64_t B14 = *(Data + Pos + 8 + 5);
            uint64_t B15 = *(Data + Pos + 8 + 6);
            uint64_t B16 = *(Data + Pos + 8 + 7);
 
            if (Endianess == BPARSER_BIG_ENDIAN)
            {
                _1 = (B1 << 56) + (B2 << 48) + (B3 << 40) + (B4 << 32) + (B5 << 24) + (B6 << 16) + (B7 << 8) + B8;
                _2 = (B9 << 56) + (B10 << 48) + (B11 << 40) + (B12 << 32) + (B13 << 24) + (B14 << 16) + (B15 << 8) + B16;
            }
            else if (Endianess == BPARSER_LITTLE_ENDIAN)
            {
                _1 = (B16 << 56) + (B15 << 48) + (B14 << 40) + (B13 << 32) + (B12 << 24) + (B11 << 16) + (B10 << 8) + B9;
                _2 = (B8 << 56) + (B7 << 48) + (B6 << 40) + (B5 << 32) + (B4 << 24) + (B3 << 16) + (B2 << 8) + B1;
            }
            else
            {
                return BPARSER_UNKNOWN_ENDIAN;
            }
 
            memcpy(((uint64_t*)_DataTypePtr), &_1, 8);
            memcpy(((uint64_t*)_DataTypePtr) + 1, &_2, 8);
 
            MParser->Data[ReadPos].DataPtr = (void*)_DataTypePtr;
            Pos += 16;
        }
        else if (ReadType == BPARSER_STR || ReadType == BPARSER_UTF8_STR)
        {
            size_t Length = strlen( (const char*)(Data + Pos) ) + 1;
 
            _DataTypePtr = MParser->CallocF(Length, 1);
 
            if (!_DataTypePtr)
            {
                return BPARSER_CALLOC_ERROR;
            }
 
            strcpy(_DataTypePtr, (const char*)(Data + Pos));
 
            MParser->Data[ReadPos].DataPtr = _DataTypePtr;
            Pos += Length;
        }
        else if (ReadType == BPARSER_UNICODE_FROM_UTF8_STR || ReadType == BPARSER_UNICODE_FROM_UTF8_F_STR)
        {
            size_t LengthInBytes = 0;
            size_t Chars = 0;
 
            _utf8_get_length(Data + Pos, &Chars, &LengthInBytes, (ReadType == BPARSER_UNICODE_FROM_UTF8_F_STR) ? Parameter1 : UINT64_MAX);
 
            _DataTypePtr = MParser->CallocF(Chars + 1, sizeof(uint32_t));
            // Chars + 1 because of that extra null char
 
            if (!_DataTypePtr)
            {
                return BPARSER_CALLOC_ERROR;
            }
 
            uint32_t* String = (uint32_t*)_DataTypePtr;
 
            size_t Offset = 0;
            for (size_t Char = 0; Char < Chars; Char++)
            {
                String[Char] = _utf8_read(Data + Pos + Offset, &Offset);
            }
 
            MParser->Data[ReadPos].DataPtr = _DataTypePtr;
            Pos += LengthInBytes;
        }
        else if (ReadType == BPARSER_FIXED_STR)
        {
            void* _DataTypePtr = MParser->CallocF(Parameter1 + 1, 1);
            memcpy(_DataTypePtr, Data + Pos, Parameter1);
            MParser->Data[ReadPos].DataPtr = _DataTypePtr;
            Pos += Parameter1;
        }
        else if (ReadType == BPARSER_UTF8_F_STR)
        {
            size_t Bytes = 0;
            _utf8_get_length(Data + Pos, NULL, &Bytes, Parameter1);
            void* _DataTypePtr = MParser->CallocF(Bytes + 1, 1);
            memcpy(_DataTypePtr, Data + Pos, Bytes);
            MParser->Data[ReadPos].DataPtr = _DataTypePtr;
            Pos += Bytes;
        }
        else if (ReadType == BPARSER_N_BYTES)
        {
            void* _DataTypePtr = MParser->CallocF(Parameter1, 1);
 
            if (!_DataTypePtr)
            {
                return BPARSER_CALLOC_ERROR;
            }
 
            uint8_t* Bytes = (uint8_t*)_DataTypePtr;
            memcpy(Bytes, Data + Pos, Parameter1); // how was this uncaught for so long?
            // is supposed to be Data + Pos, not just Data!
 
            if (Parameter2)
            {
                ((bparser_bytes_f)Parameter2)(MParser, Bytes, Parameter1);
                MParser->Data[ReadPos].DataPtr = NULL;
                MParser->FreeF(_DataTypePtr);  // oops
            }
            else if (Parameter4)
            {
                for (size_t I = 0; I < Parameter1; I++)
                {
                    ((bparser_bytes_seq_f)Parameter4)(MParser, Bytes[I], I);
                }
                MParser->Data[ReadPos].DataPtr = NULL;
                MParser->FreeF(_DataTypePtr);  // oops
            }
            else
            {
                MParser->Data[ReadPos].DataPtr = _DataTypePtr;
                MParser->Data[ReadPos].NBytesLength = Parameter1;
            }
 
            Pos += Parameter1;
        }
        else if (ReadType == BPARSER_FLOAT)
        {
            _DataTypePtr = MParser->MallocF(4);
 
            if (!_DataTypePtr)
            {
                return BPARSER_MALLOC_ERROR;
            }
 
            uint32_t Temp = 0;
            uint32_t B1 = *(Data + Pos);
            uint32_t B2 = *(Data + Pos + 1);
            uint32_t B3 = *(Data + Pos + 2);
            uint32_t B4 = *(Data + Pos + 3);
 
            if (Endianess == BPARSER_BIG_ENDIAN)
            {
                Temp = (B1 << 24) + (B2 << 16) + (B3 << 8) + B4;
            }
            else if (Endianess == BPARSER_LITTLE_ENDIAN)
            {
                Temp = (B4 << 24) + (B3 << 16) + (B2 << 8) + B1;
            }
            else
            {
                return BPARSER_UNKNOWN_ENDIAN;
            }
 
            memcpy(_DataTypePtr, &Temp, 4);
 
            MParser->Data[ReadPos].DataPtr = _DataTypePtr;
            Pos += 4;
        }
        else if (ReadType == BPARSER_DOUBLE)
        {
            _DataTypePtr = MParser->MallocF(8);
 
            if (!_DataTypePtr)
            {
                return BPARSER_MALLOC_ERROR;
            }
 
            uint64_t Temp = 0;
            uint64_t B1 = *(Data + Pos);
            uint64_t B2 = *(Data + Pos + 1);
            uint64_t B3 = *(Data + Pos + 2);
            uint64_t B4 = *(Data + Pos + 3);
            uint64_t B5 = *(Data + Pos + 4);
            uint64_t B6 = *(Data + Pos + 5);
            uint64_t B7 = *(Data + Pos + 6);
            uint64_t B8 = *(Data + Pos + 7);
 
            if (Endianess == BPARSER_BIG_ENDIAN)
            {
                Temp = (B1 << 56) + (B2 << 48) + (B3 << 40) + (B4 << 32) + (B5 << 24) + (B6 << 16) + (B7 << 8) + B8;
            }
            else if (Endianess == BPARSER_LITTLE_ENDIAN)
            {
                Temp = (B8 << 56) + (B7 << 48) + (B6 << 40) + (B5 << 32) + (B4 << 24) + (B3 << 16) + (B2 << 8) + B1;
            }
            else
            {
                return BPARSER_UNKNOWN_ENDIAN;
            }
 
            memcpy(_DataTypePtr, &Temp, 8);
 
            MParser->Data[ReadPos].DataPtr = _DataTypePtr;
            Pos += 8;
        }
        else if (ReadType == BPARSER_UNIX_TIME)
        {
            _DataTypePtr = MParser->MallocF( sizeof(time_t) );
 
            if (!_DataTypePtr)
            {
                return BPARSER_MALLOC_ERROR;
            }
 
            time_t* Temp = (time_t*)_DataTypePtr;
            uint32_t B1 = *(Data + Pos);
            uint32_t B2 = *(Data + Pos + 1);
            uint32_t B3 = *(Data + Pos + 2);
            uint32_t B4 = *(Data + Pos + 3);
 
            if (Endianess == BPARSER_BIG_ENDIAN)
            {
                *Temp = (B1 << 24) + (B2 << 16) + (B3 << 8) + B4;
            }
            else if (Endianess == BPARSER_LITTLE_ENDIAN)
            {
                *Temp = (B4 << 24) + (B3 << 16) + (B2 << 8) + B1;
            }
            else
            {
                return BPARSER_UNKNOWN_ENDIAN;
            }
 
            MParser->Data[ReadPos].DataPtr = (void*)Temp;
            Pos += 4;
        }
        else if (ReadType == BPARSER_UINT24 || ReadType == BPARSER_INT24)
        {
            _DataTypePtr = MParser->MallocF(4);
 
            if (!_DataTypePtr)
            {
                return BPARSER_MALLOC_ERROR;
            }
 
            uint32_t* _Temp = (uint32_t*)_DataTypePtr;
            uint32_t B1 = *(Data + Pos);
            uint32_t B2 = *(Data + Pos + 1);
            uint32_t B3 = *(Data + Pos + 2);
 
            if (Endianess == BPARSER_BIG_ENDIAN)
            {
                *_Temp = (B1 << 16) + (B2 << 8) + B3;
            }
            else if (Endianess == BPARSER_LITTLE_ENDIAN)
            {
                *_Temp = (B3 << 16) + (B2 << 8) + B1;
            }
            else
            {
                return BPARSER_UNKNOWN_ENDIAN;
            }
 
            if (ReadType == BPARSER_INT24 && (*_Temp) > 0x800000)
            {
                *_Temp -= (0x1000000);
            }
 
            MParser->Data[ReadPos].DataPtr = (void*)_Temp;
            Pos += 3;
        }
        else if (ReadType == BPARSER_BOOLS)
        {
            _DataTypePtr = MParser->MallocF(1);
 
            if (!_DataTypePtr)
            {
                return BPARSER_MALLOC_ERROR;
            }
 
            if (*(Data + Pos) & (1 << (7 - Parameter1)))
            {
                *((uint8_t*)_DataTypePtr) = 1;
            }
            else
            {
                *((uint8_t*)_DataTypePtr) = 0;
            }
 
            MParser->Data[ReadPos].DataPtr = _DataTypePtr;
 
            if (Parameter1 == 7)
            {
                Pos += 1;
            }
        }
        else if (ReadType == BPARSER_BOOL_RUN)
        {
            if ( Parameter3->HFunc(*(Data + Pos)) )
            {
                Parameter3->Func(MParser);
            }
            Pos += 1;
        }
        else
        {
            return BPARSER_UNKNOWN_READ_TYPE;
        }
 
        if (MParser->ReadOrder[ReadPos].Name)
        {
            void* _Name = MParser->MallocF(strlen(MParser->ReadOrder[ReadPos].Name) + 1);
 
            if (!_Name)
            {
                return BPARSER_MALLOC_ERROR;
            }
 
            MParser->Data[ReadPos].Name = (char*)_Name;
            strcpy(MParser->Data[ReadPos].Name, MParser->ReadOrder[ReadPos].Name);
        }
        else
        {
            MParser->Data[ReadPos].Name = NULL;
        }
 
        MParser->Data[ReadPos].Type = ReadType;
    }
 
    return 1;
}
 
char bparser_fread(bparser_parser_t* MParser, const char* Filename)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (!Filename)
    {
        return BPARSER_NULL_NAME;
    }
 
    if (strlen(Filename) < 1)
    {
        return BPARSER_SHORT_NAME;
    }
 
    FILE* _F = fopen(Filename, "rb");
 
    if (!_F)
    {
        return BPARSER_FOPEN_ERROR;
    }
 
    if( fseek(_F, 0, SEEK_END) )
    {
        fclose(_F);
        return BPARSER_FSEEK_ERROR;
    }
 
    long Size = ftell(_F);
    if (Size == 0)
    {
        return BPARSER_EMPTY_FILE;
    }
    rewind(_F);
 
    if (Size < 0)
    {
        fclose(_F);
        return BPARSER_FTELL_ERROR;
    }
 
    uint8_t* Data = calloc(Size + 1, 1);
 
    if (!Data)
    {
        fclose(_F);
        return BPARSER_CALLOC_ERROR;
    }
 
    if ( fread(Data, 1, Size, _F) != Size )
    {
        fclose(_F);
 
        if (feof(_F)) { return BPARSER_FREAD_EOF_ERROR; }
        else if (ferror(_F)) { return BPARSER_FREAD_ERROR; }
        else { return BPARSER_FREAD_UNKNOWN_ERROR; }
    }
 
    fclose(_F);
    char Res = bparser_read(MParser, Data, Size);
    free(Data);
    return Res;
}
 
char bparser_check_magic_num(const uint8_t* Data, const uint8_t* MagicNum, size_t Length)
{
    if ( (!Data) || (!MagicNum) )
    {
        return BPARSER_NULL_DATA;
    }
 
    if (Length < 1)
    {
        return BPARSER_ZERO_LENGTH;
    }
 
    for (size_t N = 0; N < Length; N++)
    {
        if ( *(Data + N) != *(MagicNum + N) )
        {
            return 0;
        }
    }
    return 1;
}
 
char bparser_check_magic_num_char(const uint8_t* Data, const char* MagicNum, size_t Length)
{
    if ( (!Data) || (!MagicNum) )
    {
        return BPARSER_NULL_DATA;
    }
 
    if (Length < 1)
    {
        return BPARSER_ZERO_LENGTH;
    }
 
    for (size_t N = 0; N < Length; N++)
    {
        if ( *(Data + N) != (uint8_t)(*(MagicNum + N)) )
        {
            return 0;
        }
    }
    return 1;
}
 
void* bparser_get(const bparser_parser_t* MParser, const char* Name)
{
    if (!MParser)
    {
        return NULL;
    }
 
    if (!Name)
    {
        return NULL;
    }
 
    if (strlen(Name) < 1)
    {
        return NULL;
    }
 
    for (size_t D = 0; D < MParser->ReadOrderLength; D++)
    {
        if (!MParser->Data[D].Name)
        {
            continue;
        }
 
        if ( strcmp(MParser->Data[D].Name, Name) == 0 )
        {
            return MParser->Data[D].DataPtr;
        }
    }
    return NULL;
}
 
void bparser_use_little_endian(bparser_parser_t* MParser)
{
    if (!MParser) { return; }
    MParser->Endian = BPARSER_LITTLE_ENDIAN;
}
 
void bparser_use_big_endian(bparser_parser_t* MParser)
{
    if (!MParser) { return; }
    MParser->Endian = BPARSER_BIG_ENDIAN;
}
 
char bparser_seek(bparser_parser_t* MParser, uint64_t Pos, uint8_t Mode)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (Mode >= BPARSER_SEEK_TO && Mode < BPARSER_NO_SEEK)
    {
        MParser->Seek.Pos = Pos;
        MParser->Seek.Mode = Mode;
        return 1;
    }
 
    return BPARSER_SEEK_ERROR;
}
 
char bparser_rewind(bparser_parser_t* MParser)
{
    return bparser_seek(MParser, 0, BPARSER_SEEK_TO);
}
 
char bparser_unwind(bparser_parser_t* MParser)
{
    return bparser_seek(MParser, 0, BPARSER_SEEK_FROM_END);
}
 
const char* bparser_error_str(char Error)
{
    switch (Error)
    {
        case BPARSER_RO_ARRAY_ERROR:
            return "realloc (or user-defined function replacing realloc) has errored out and caused the Read Order array not to resize.";
 
        case BPARSER_MALLOC_ERROR:
            return "malloc (or user-defined function replacing malloc) has returned NULLPTR.";
 
        case BPARSER_NO_FUNC_PASSED:
            return "Either bparser_read_bytes_and_run or bparser_read_bool_and_run have been called with their Func parameter set to NULLPTR.";
 
        case BPARSER_SPRINTF_ERROR:
            return "When reading array, 2D array or bool array, sprintf has errored out when creating name string.";
 
        case BPARSER_BACKWARD_SEEK_ERROR:
            return "Seeking backward caused the position marker to go into negative range.";
 
        case BPARSER_SEEK_FROM_END_ERROR:
            return "Seeking from the end caused the position marker to go into negative range.";
 
        case BPARSER_EOF_ERROR:
            return "Position marker reached EOF when there was more data instructed to read.";
 
        case BPARSER_CALLOC_ERROR:
            return "calloc (or user-defined function replacing calloc) has returned NULLPTR.";
 
        case BPARSER_UNKNOWN_ENDIAN:
            return "When reading an integer, unknown endianess was detected.";
 
        case BPARSER_UNKNOWN_READ_TYPE:
            return "Unknown read type.";
 
        case BPARSER_FOPEN_ERROR:
            return "In bparser_fread(), fopen() errored out.";
 
        case BPARSER_FSEEK_ERROR:
            return "In bparser_fread(), fseek() errored out.";
 
        case BPARSER_FTELL_ERROR:
            return "In bparser_fread(), ftell() errored out.";
 
        case BPARSER_FREAD_EOF_ERROR:
            return "In bparser_fread(), fread() errored out on an unexpected EOF.";
 
        case BPARSER_SEEK_ERROR:
            return "Seeking mode out of range.";
 
        case BPARSER_BAD_INTEGRAL_TYPE:
            return "bparser_read_integral() was supplied with an illegal integral type.";
 
        case BPARSER_BAD_REALLOC_METHOD:
            return "bparser_parser_set_realloc_method() was supplied with an illegal realloc method (neither BPARSER_REALLOC_METHOD_PLUS or BPARSER_REALLOC_METHOD_MULT).";
 
        case BPARSER_REALLOC_FACTOR_TOO_SMALL:
            return "bparser_parser_set_realloc_method() was supplied with a realloc factor smaller than 1.0.";
 
        case BPARSER_RENAME_NOT_FOUND:
            return "bparser_rename() cannot find data object of name supplied by `Src` argument.";
 
        case BPARSER_PDC_INIT_ERROR:
            return "bparser_init() has failed when called in bparser_parser_deep_copy().";
 
        case BPARSER_PDC_RO_COPY_ERROR:
            return "bparser_read_order_deep_copy() has failed when called in bparser_parser_deep_copy().";
 
        case BPARSER_NULL_NAME:
            return "A string argument of the function is a NULL pointer.";
 
        case BPARSER_SHORT_NAME:
            return "A string argument of the function is too short.";
 
        case BPARSER_NO_PARSER:
            return "A function that changes or reads a parser instance, has no parser instance specified.";
 
        case BPARSER_ZERO_LENGTH:
            return "`Size`, `Length`, `Count` or the like are too low.";
 
        case BPARSER_NAME_IS_NOT_UNIQUE:
            return "A read rule that was about to be created was given a name that is in use by another read rule. Use `bparser_set_override()` to disable this error.";
 
        case BPARSER_NO_BOOLS_TO_READ:
            return "Argument `A` of `_bparser_bool` is zero.";
 
        case BPARSER_PDC_DATA_COPY_ERROR:
            return "bparser_data_deep_copy() has failed when called in bparser_parser_deep_copy().";
 
        case BPARSER_FREAD_ERROR:
            return "In bparser_fread(), fread() errored out.";
 
        case BPARSER_FREAD_UNKNOWN_ERROR:
            return "In bparser_fread(), fread() returned an unknown error...";
 
        case BPARSER_NULL_DATA:
            return "bparser_read() argument `Data` is NULL!";
 
        case BPARSER_NOTHING_TO_PARSE:
            return "bparser_read() argument `Size` is zero!";
 
        case BPARSER_EMPTY_FILE:
            return "bparser_fread() tried to read an empty file!";
 
        case BPARSER_BAD_OVERRIDE:
            return "bparser_set_override() has been specified with an unknown override method.";
 
        default:
            return "No error.";
    }
}
 
size_t bparser_get_data_count(const bparser_parser_t* MParser)
{
    return (MParser->DataCount);
}
 
size_t bparser_get_read_order_count(const bparser_parser_t* MParser)
{
    return (MParser->ReadOrderLength);
}
 
bparser_read_t* bparser_get_read_order_at(const bparser_parser_t* MParser, size_t Index)
{
    if (!MParser)
    {
        return NULL;
    }
 
    if (Index > MParser->ReadOrderLength)
    {
        return NULL;
    }
    return &(MParser->ReadOrder[Index]);
}
 
void* bparser_read_order_shallow_copy(const bparser_parser_t* MParser, bparser_read_t* Dest)
{
    if (!MParser)
    {
        return NULL;
    }
 
    bparser_read_t* _D = Dest;
 
    if (!Dest)
    {
        void* Placeholder = MParser->CallocF(MParser->ReadOrderMaxLength, sizeof(bparser_read_t));
 
        if (!Placeholder)
        {
            return NULL;
        }
 
        _D = (bparser_read_t*)Placeholder;
    }
 
    memcpy(_D, MParser->ReadOrder, sizeof(bparser_read_t) * MParser->ReadOrderLength);
    return _D;
}
 
void* bparser_read_order_deep_copy(const bparser_parser_t* MParser, bparser_read_t* Dest)
{
    if (!MParser)
    {
        return NULL;
    }
 
    bparser_read_t* _D = Dest;
 
    if (!Dest)
    {
        void* Placeholder = MParser->CallocF(MParser->ReadOrderMaxLength, sizeof(bparser_read_t));
 
        if (!Placeholder)
        {
            return NULL;
        }
 
        _D = (bparser_read_t*)Placeholder;
    }
 
    for (size_t Indx = 0; Indx < MParser->ReadOrderLength; Indx++)
    {
        // Copy name
        if (MParser->ReadOrder[Indx].Name)
        {
            _D[Indx].Name = MParser->CallocF(strlen(MParser->ReadOrder[Indx].Name) + 1, sizeof(char));
            strcpy(_D[Indx].Name, MParser->ReadOrder[Indx].Name);
        }
        else
        {
            _D[Indx].Name = NULL;
        }
 
        // Literals / func ptrs
        _D[Indx].Endian = MParser->ReadOrder[Indx].Endian;
        _D[Indx].Type = MParser->ReadOrder[Indx].Type;
        _D[Indx].Seek = MParser->ReadOrder[Indx].Seek;
        _D[Indx].Parameter1 = MParser->ReadOrder[Indx].Parameter1;
        _D[Indx].Parameter2 = MParser->ReadOrder[Indx].Parameter2;
        _D[Indx].Parameter3 = MParser->ReadOrder[Indx].Parameter3;
        _D[Indx].Parameter4 = MParser->ReadOrder[Indx].Parameter4;
    }
 
    return _D;
}
 
char bparser_parser_set_realloc_method(bparser_parser_t* MParser, double N, uint8_t ReallocMethod)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if ((ReallocMethod != BPARSER_REALLOC_METHOD_PLUS) && (ReallocMethod != BPARSER_REALLOC_METHOD_MULT))
    {
        return BPARSER_BAD_REALLOC_METHOD;
    }
 
    if (N < 1.0)
    {
        return BPARSER_REALLOC_FACTOR_TOO_SMALL;
    }
 
    MParser->ReallocFactor = N;
    MParser->ReallocMethod = ReallocMethod;
    return 1;
}
 
void* bparser_data_shallow_copy(const bparser_parser_t* MParser, bparser_data_t* Dest)
{
    if (!MParser)
    {
        return NULL;
    }
 
    bparser_data_t* _D = Dest;
    if (!Dest)
    {
        void* Placeholder = MParser->CallocF(MParser->DataCount, sizeof(bparser_data_t));
 
        if (!Placeholder)
        {
            return NULL;
        }
 
        _D = (bparser_data_t*)Placeholder;
    }
    memcpy(_D, MParser->Data, sizeof(bparser_data_t) * MParser->DataCount);
    return _D;
}
 
void* bparser_data_deep_copy(const bparser_parser_t* MParser, bparser_data_t* Dest, char* Failure)
{
    char _Temp = 0;
    char* _F = (Failure) ? Failure : &_Temp;
 
    if (!MParser)
    {
        *_F = BPARSER_NO_PARSER;
        return NULL;
    }
 
    bparser_data_t* _D = Dest;
 
    if (!Dest)
    {
        void* Placeholder = MParser->CallocF(MParser->DataCount, sizeof(bparser_data_t));
 
        if (!Placeholder)
        {
            *_F = BPARSER_CALLOC_ERROR;
            return NULL;
        }
 
        _D = (bparser_data_t*)Placeholder;
    }
 
    for (size_t Indx = 0; Indx < bparser_get_data_count(MParser); Indx++)
    {
        // Copy name
        _D[Indx].Name = MParser->CallocF(strlen(MParser->Data[Indx].Name) + 1, sizeof(char));
 
        if (!(_D[Indx].Name))
        {
            *_F = BPARSER_CALLOC_ERROR;
            return NULL;
        }
 
        strcpy(_D[Indx].Name, MParser->Data[Indx].Name);
 
        _D[Indx].Type = MParser->Data[Indx].Type;
        _D[Indx].NBytesLength = 0;
 
        // Now for the tiresome type checking...
        switch (_D[Indx].Type)
        {
            case BPARSER_UINT8:
            case BPARSER_INT8:
            {
                _D[Indx].DataPtr = MParser->MallocF(1);
                if (!(_D[Indx].DataPtr))
                {
                    *_F = BPARSER_MALLOC_ERROR;
                    return NULL;
                }
                *((uint8_t*)_D[Indx].DataPtr) = *((uint8_t*)MParser->Data[Indx].DataPtr);
            }
            break;
 
            case BPARSER_UINT16:
            case BPARSER_INT16:
            {
                _D[Indx].DataPtr = MParser->MallocF(2);
                if (!(_D[Indx].DataPtr))
                {
                    *_F = BPARSER_MALLOC_ERROR;
                    return NULL;
                }
                *((uint16_t*)_D[Indx].DataPtr) = *((uint16_t*)MParser->Data[Indx].DataPtr);
            }
            break;
 
            case BPARSER_UINT32:
            case BPARSER_INT32:
            {
                _D[Indx].DataPtr = MParser->MallocF(4);
                if (!(_D[Indx].DataPtr))
                {
                    *_F = BPARSER_MALLOC_ERROR;
                    return NULL;
                }
                *((uint32_t*)_D[Indx].DataPtr) = *((uint32_t*)MParser->Data[Indx].DataPtr);
            }
            break;
 
            case BPARSER_UINT64:
            case BPARSER_INT64:
            {
                _D[Indx].DataPtr = MParser->MallocF(8);
                if (!(_D[Indx].DataPtr))
                {
                    *_F = BPARSER_MALLOC_ERROR;
                    return NULL;
                }
                *((uint64_t*)_D[Indx].DataPtr) = *((uint64_t*)MParser->Data[Indx].DataPtr);
            }
            break;
 
            case BPARSER_UINT128:
            case BPARSER_INT128:
            {
                _D[Indx].DataPtr = MParser->MallocF(16);
                if (!(_D[Indx].DataPtr))
                {
                    *_F = BPARSER_MALLOC_ERROR;
                    return NULL;
                }
                *((uint64_t*)_D[Indx].DataPtr) = *((uint64_t*)MParser->Data[Indx].DataPtr);
                *((uint64_t*)_D[Indx].DataPtr + 1) = *((uint64_t*)MParser->Data[Indx].DataPtr + 1);
            }
            break;
 
            case BPARSER_STR:
            case BPARSER_UTF8_STR:
            case BPARSER_FIXED_STR:
            case BPARSER_UTF8_F_STR:
            {
                _D[Indx].DataPtr = MParser->CallocF(strlen( (const char*)MParser->Data[Indx].DataPtr ) + 1, 1);
                if (!(_D[Indx].DataPtr))
                {
                    *_F = BPARSER_CALLOC_ERROR;
                    return NULL;
                }
                strcpy((char*)_D[Indx].DataPtr, (const char*)MParser->Data[Indx].DataPtr);
            }
            break;
 
            case BPARSER_UNICODE_FROM_UTF8_STR:
            case BPARSER_UNICODE_FROM_UTF8_F_STR:
            {
                size_t Count = 0;
 
                // this will count all the uint32's including the null one
                do
                {
                    Count++;
                }
                while ( *(((uint32_t*)(MParser->Data[Indx].DataPtr) + Count)) != 0 );
 
                _D[Indx].DataPtr = MParser->CallocF(Count, sizeof(uint32_t));
                if (!(_D[Indx].DataPtr))
                {
                    *_F = BPARSER_CALLOC_ERROR;
                    return NULL;
                }
                memcpy(_D[Indx].DataPtr, MParser->Data[Indx].DataPtr, sizeof(uint32_t) * Count);
            }
            break;
 
            case BPARSER_N_BYTES:
            {
                _D[Indx].DataPtr = MParser->CallocF(MParser->Data[Indx].NBytesLength, 1);
                if (!(_D[Indx].DataPtr))
                {
                    *_F = BPARSER_CALLOC_ERROR;
                    return NULL;
                }
                memcpy(_D[Indx].DataPtr, MParser->Data[Indx].DataPtr, MParser->Data[Indx].NBytesLength);
                _D[Indx].NBytesLength = MParser->Data[Indx].NBytesLength;
            }
            break;
 
            case BPARSER_FLOAT:
            {
                _D[Indx].DataPtr = MParser->MallocF(4);
                if (!(_D[Indx].DataPtr))
                {
                    *_F = BPARSER_MALLOC_ERROR;
                    return NULL;
                }
                *((float*)_D[Indx].DataPtr) = *((float*)MParser->Data[Indx].DataPtr);
            }
            break;
 
            case BPARSER_DOUBLE:
            {
                _D[Indx].DataPtr = MParser->MallocF(8);
                if (!(_D[Indx].DataPtr))
                {
                    *_F = BPARSER_MALLOC_ERROR;
                    return NULL;
                }
                *((double*)_D[Indx].DataPtr) = *((double*)MParser->Data[Indx].DataPtr);
            }
            break;
 
            case BPARSER_UNIX_TIME:
            {
                _D[Indx].DataPtr = MParser->MallocF( sizeof(time_t) );
                if (!(_D[Indx].DataPtr))
                {
                    *_F = BPARSER_MALLOC_ERROR;
                    return NULL;
                }
                *((time_t*)_D[Indx].DataPtr) = *((time_t*)MParser->Data[Indx].DataPtr);
            }
            break;
 
            case BPARSER_UINT24:
            case BPARSER_INT24:
            {
                _D[Indx].DataPtr = MParser->MallocF(4);
                if (!(_D[Indx].DataPtr))
                {
                    *_F = BPARSER_MALLOC_ERROR;
                    return NULL;
                }
                *((uint32_t*)_D[Indx].DataPtr) = *((uint32_t*)MParser->Data[Indx].DataPtr);
            }
            break;
 
            case BPARSER_BOOLS:
            {
                _D[Indx].DataPtr = MParser->MallocF(1);
                if (!(_D[Indx].DataPtr))
                {
                    *_F = BPARSER_MALLOC_ERROR;
                    return NULL;
                }
                *((uint8_t*)_D[Indx].DataPtr) = *((uint8_t*)MParser->Data[Indx].DataPtr);
            }
            break;
 
            default:
            {
                *_F = BPARSER_UNKNOWN_READ_TYPE;
                return NULL;
            }
        }
    }
 
    return _D;
}
 
const bparser_data_t* bparser_get_data_at(const bparser_parser_t* MParser, size_t Indx)
{
    if (!MParser)
    {
        return NULL;
    }
 
    if (Indx >= bparser_get_data_count(MParser))
    {
        return NULL;
    }
 
    return &(MParser->Data[Indx]);
}
 
void bparser_destroy_read_order(bparser_read_t* Array, size_t Length, bparser_free_like_f FreeCallback)
{
    bparser_free_like_f FreeF = (FreeCallback) ? FreeCallback : free;
 
    if (Array)
    {
        for (size_t I = 0; I < Length; I++)
        {
            if (Array[I].Name)
            {
                FreeF(Array[I].Name);
            }
        }
        FreeF(Array);
    }
}
 
void bparser_destroy_data(bparser_data_t* Array, size_t Length, bparser_free_like_f FreeCallback)
{
    bparser_free_like_f FreeF = (FreeCallback) ? FreeCallback : free;
 
    if (Array)
    {
        for (size_t D = 0; D < Length; D++)
        {
            // holy shit horrible bug there was (don't check commit history)
            if (Array[D].DataPtr)
            {
                FreeF(Array[D].DataPtr);
            }
 
            if (Array[D].Name)
            {
                FreeF(Array[D].Name);
            }
        }
        FreeF(Array);
    }
}
 
char bparser_rename(bparser_parser_t* MParser, const char* Src, const char* New)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if ( (!Src) || (!New) )
    {
        return BPARSER_NULL_NAME;
    }
 
    if ( (strlen(Src) < 1) || (strlen(New) < 1) )
    {
        return BPARSER_SHORT_NAME;
    }
 
    for (size_t D = 0; D < MParser->ReadOrderLength; D++)
    {
        if ( strcmp(MParser->Data[D].Name, Src) == 0 )
        {
            void* _Temp = MParser->CallocF( strlen(New) + 1, 1 );
 
            if (!_Temp)
            {
                return BPARSER_CALLOC_ERROR;
            }
 
            // if calloc was to fail, we still preserve the name
            if (MParser->Data[D].Name)
            {
                MParser->FreeF(MParser->Data[D].Name);
            }
 
            MParser->Data[D].Name = _Temp;
 
            strcpy(MParser->Data[D].Name, New);
            return 1;
        }
    }
    return BPARSER_RENAME_NOT_FOUND;
}
 
void* bparser_parser_shallow_copy(bparser_parser_t* Src, bparser_parser_t* Dest)
{
    if (!Src)
    {
        return NULL;
    }
 
    bparser_parser_t* _Dest = Dest;
 
    if (!_Dest)
    {
        _Dest = bparser_init(Src->MallocF, Src->CallocF, Src->ReallocF, Src->FreeF);
 
        if (!_Dest)
        {
            // check again, if _Dest is NULL, bparser_init failed
            return NULL;
        }
    }
 
    memcpy(_Dest, Src, sizeof(bparser_parser_t));
    return _Dest;
}
 
void* bparser_parser_deep_copy(bparser_parser_t* Src, bparser_parser_t* Dest, char* Error)
{
    char _Temp = 0;
    char* _E = (Error) ? Error : &_Temp;
 
    if (!Src)
    {
        *_E = BPARSER_NO_PARSER;
        return NULL;
    }
 
    // Before overwritting, make sure to free the pointer...
    if (Dest)
    {
        if (Dest->ReadOrder)
        {
            bparser_destroy_read_order(Dest->ReadOrder, Dest->ReadOrderMaxLength, Dest->FreeF);
        }
 
        if (Dest->Data)
        {
            bparser_destroy_data(Dest->Data, Dest->DataCount, Dest->FreeF);
        }
    }
 
    // deep copying a parser instance is essentially just shallow copying
    // and then deeply copying the RO and data array
    bparser_parser_t* _Dest = bparser_parser_shallow_copy(Src, Dest);
 
    if (!_Dest)
    {
        *_E = BPARSER_PDC_INIT_ERROR;
        return NULL;
    }
 
    if (Src->ReadOrder)
    {
        bparser_read_t* _RO = (bparser_read_t*)bparser_read_order_deep_copy(Src, NULL);
        if ( !_RO )
        {
            *_E = BPARSER_PDC_RO_COPY_ERROR;
            return NULL;
        }
 
        _Dest->ReadOrder = _RO;
        _Dest->ReadOrderLength = Src->ReadOrderLength;
        _Dest->ReadOrderMaxLength = Src->ReadOrderMaxLength;
    }
 
    if (Src->Data)
    {
        bparser_data_t* _D = (bparser_data_t*)bparser_data_deep_copy(Src, NULL, _E);
        if ( !_D )
        {
            *_E = BPARSER_PDC_DATA_COPY_ERROR;
            return NULL;
        }
 
        _Dest->Data = _D;
        _Dest->DataCount = Src->DataCount;
    }
 
    return _Dest;
}
 
void* bparser_parser_move(bparser_parser_t* Src, bparser_parser_t* Dest)
{
    // THIS IS SUPPOSED TO BE && NOT || YOU STUPID FUCK @norbcodes
    if (Src && Dest)
    {
        if (Dest)
        {
            if (Dest->ReadOrder)
            {
                bparser_destroy_read_order(Dest->ReadOrder, Dest->ReadOrderMaxLength, Dest->FreeF);
            }
 
            if (Dest->Data)
            {
                bparser_destroy_data(Dest->Data, Dest->DataCount, Dest->FreeF);
            }
        }
 
        return memmove(Dest, Src, sizeof(bparser_parser_t));
    }
    return NULL;
}
 
char bparser_set_override(bparser_parser_t* MParser, uint8_t Override)
{
    if (!MParser)
    {
        return BPARSER_NO_PARSER;
    }
 
    if (Override >= BPARSER_OVERRIDE_ERROR && Override <= BPARSER_OVERRIDE_DO_NOTHING)
    {
        MParser->Override = Override;
    }
    else
    {
        return BPARSER_BAD_OVERRIDE;
    }
 
    return 1;
}
 
#endif // BPARSER_IMPLEMENTATION
 
#undef _BPARSER_INIT_ARGS
 
#ifdef __cplusplus
}
#endif // __cplusplus
 
#endif // BPARSER_PARSER