mirror of
https://github.com/HarbourMasters/Shipwright.git
synced 2024-11-29 21:02:18 -05:00
f52a2a6406
subrepo: subdir: "OTRGui" merged: "a6066a251" upstream: origin: "https://github.com/HarbourMasters/otrgui.git" branch: "master" commit: "a6066a251" git-subrepo: version: "0.4.1" origin: "???" commit: "???"
1303 lines
54 KiB
C
1303 lines
54 KiB
C
/**********************************************************************************************
|
|
|
|
raylib API parser
|
|
|
|
This parser scans raylib.h to get API information about structs, enums, functions and defines.
|
|
All data is divided into pieces, usually as strings. The following types are used for data:
|
|
|
|
- struct FunctionInfo
|
|
- struct StructInfo
|
|
- struct EnumInfo
|
|
- struct DefInfo
|
|
|
|
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
|
|
#include <ctype.h> // Required for: isdigit()
|
|
|
|
#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_DEFINES_TO_PARSE 2048 // Maximum number of defines to parse
|
|
|
|
#define MAX_LINE_LENGTH 512 // Maximum length of one line (including comments)
|
|
#define MAX_STRUCT_LINE_LENGTH 2048 // Maximum length of one struct (multiple lines)
|
|
|
|
#define MAX_FUNCTION_PARAMETERS 12 // Maximum number of function parameters
|
|
#define MAX_STRUCT_FIELDS 32 // Maximum number of struct fields
|
|
#define MAX_ENUM_VALUES 512 // Maximum number of enum values
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Types and Structures Definition
|
|
//----------------------------------------------------------------------------------
|
|
// Function info data
|
|
typedef struct FunctionInfo {
|
|
char name[64]; // Function name
|
|
char desc[128]; // Function description (comment at the end)
|
|
char retType[32]; // Return value type
|
|
int paramCount; // Number of function parameters
|
|
char paramType[MAX_FUNCTION_PARAMETERS][32]; // Parameters type
|
|
char paramName[MAX_FUNCTION_PARAMETERS][32]; // Parameters name
|
|
char paramDesc[MAX_FUNCTION_PARAMETERS][128]; // Parameters description
|
|
} FunctionInfo;
|
|
|
|
// Struct info data
|
|
typedef struct StructInfo {
|
|
char name[64]; // Struct name
|
|
char desc[128]; // Struct type description
|
|
int fieldCount; // Number of fields in the struct
|
|
char fieldType[MAX_STRUCT_FIELDS][64]; // Field type
|
|
char fieldName[MAX_STRUCT_FIELDS][64]; // Field name
|
|
char fieldDesc[MAX_STRUCT_FIELDS][128]; // Field description
|
|
} StructInfo;
|
|
|
|
// Enum info data
|
|
typedef struct EnumInfo {
|
|
char name[64]; // Enum name
|
|
char desc[128]; // Enum description
|
|
int valueCount; // Number of values in enumerator
|
|
char valueName[MAX_ENUM_VALUES][64]; // Value name definition
|
|
int valueInteger[MAX_ENUM_VALUES]; // Value integer
|
|
char valueDesc[MAX_ENUM_VALUES][128]; // Value description
|
|
} EnumInfo;
|
|
|
|
// Type of parsed define
|
|
typedef enum { UNKNOWN = 0, MACRO, GUARD, INT, LONG, FLOAT, DOUBLE, CHAR, STRING, COLOR } DefineType;
|
|
|
|
// Define info data
|
|
typedef struct DefineInfo {
|
|
char name[64]; // Define name
|
|
DefineType type; // Define type
|
|
char value[256]; // Define value
|
|
char desc[128]; // Define description
|
|
bool isHex; // Define is hex number (for types INT, LONG)
|
|
} DefineInfo;
|
|
|
|
// Output format for parsed data
|
|
typedef enum { DEFAULT = 0, JSON, XML, LUA } OutputFormat;
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Global Variables Definition
|
|
//----------------------------------------------------------------------------------
|
|
static int funcCount = 0;
|
|
static int structCount = 0;
|
|
static int enumCount = 0;
|
|
static int defineCount = 0;
|
|
static FunctionInfo *funcs = NULL;
|
|
static StructInfo *structs = NULL;
|
|
static EnumInfo *enums = NULL;
|
|
static DefineInfo *defines = NULL;
|
|
static char apiDefine[32] = "RLAPI\0";
|
|
|
|
// 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 *EscapeBackslashes(char *text); // Replace '\' by "\\" when exporting to JSON and XML
|
|
|
|
static void ExportParsedData(const char *fileName, int format); // Export parsed data in desired format
|
|
|
|
static const char *StrDefineType(DefineType type); // Get string of define type
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// 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"
|
|
int *structLines = (int *)malloc(MAX_STRUCTS_TO_PARSE*sizeof(int));
|
|
|
|
// Enums lines pointers, selected from buffer "lines"
|
|
int *enumLines = (int *)malloc(MAX_ENUMS_TO_PARSE*sizeof(int));
|
|
|
|
// Defines lines pointers, selected from buffer "lines"
|
|
int *defineLines = (int *)malloc(MAX_DEFINES_TO_PARSE*sizeof(int));
|
|
|
|
// Prepare required lines for parsing
|
|
//--------------------------------------------------------------------------------------------------
|
|
|
|
// Read function lines
|
|
for (int i = 0; i < linesCount; i++)
|
|
{
|
|
// Read function line (starting with `define`, i.e. for raylib.h "RLAPI")
|
|
if (IsTextEqual(lines[i], apiDefine, TextLength(apiDefine)))
|
|
{
|
|
// Keep a pointer to the function line
|
|
funcLines[funcCount] = lines[i];
|
|
funcCount++;
|
|
}
|
|
}
|
|
|
|
// Read struct lines
|
|
for (int i = 0; i < linesCount; i++)
|
|
{
|
|
// Find structs (starting with "typedef struct ... {", ending with '} ... ;')
|
|
if (IsTextEqual(lines[i], "typedef struct", 14))
|
|
{
|
|
int j = 0;
|
|
bool validStruct = false;
|
|
|
|
// WARNING: Typedefs between types: typedef Vector4 Quaternion;
|
|
// (maybe we could export these too?)
|
|
|
|
for (int c = 0; c < MAX_LINE_LENGTH; c++)
|
|
{
|
|
char v = lines[i][c];
|
|
if (v == '{') validStruct = true;
|
|
if (v == '{' || v == ';' || v == '\0')
|
|
{
|
|
// Not valid struct if it ends without '{':
|
|
// i.e typedef struct rAudioBuffer rAudioBuffer; -> Typedef and forward declaration
|
|
break;
|
|
}
|
|
}
|
|
if (!validStruct) continue;
|
|
structLines[structCount] = i;
|
|
while (lines[i][0] != '}') i++;
|
|
while (lines[i][0] != '\0') i++;
|
|
structCount++;
|
|
}
|
|
}
|
|
|
|
// Read enum lines
|
|
for (int i = 0; i < linesCount; i++)
|
|
{
|
|
// Read enum line
|
|
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++;
|
|
}
|
|
}
|
|
|
|
// Read const lines
|
|
for (int i = 0; i < linesCount; i++)
|
|
{
|
|
int j = 0;
|
|
while (lines[i][j] == ' ' || lines[i][j] == '\t') j++; // skip spaces and tabs in the begining
|
|
// Read define line
|
|
if (IsTextEqual(lines[i]+j, "#define ", 8))
|
|
{
|
|
// Keep the line position in the array of lines,
|
|
// so, we can scan that position and following lines
|
|
defineLines[defineCount] = i;
|
|
defineCount++;
|
|
}
|
|
}
|
|
|
|
// At this point we have all raylib structs, enums, functions, defines 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++)
|
|
{
|
|
char **linesPtr = &lines[structLines[i]];
|
|
|
|
// Parse struct description
|
|
if (linesPtr[-1][0] == '/')
|
|
{
|
|
MemoryCopy(structs[i].desc, linesPtr[-1], TextLength(linesPtr[-1]));
|
|
}
|
|
|
|
// Get struct name: typedef struct name {
|
|
const int TDS_LEN = 15; // length of "typedef struct "
|
|
for (int c = TDS_LEN; c < 64 + TDS_LEN; c++)
|
|
{
|
|
if (linesPtr[0][c] == '{')
|
|
{
|
|
MemoryCopy(structs[i].name, &linesPtr[0][TDS_LEN], c - TDS_LEN - 1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Get struct fields and count them -> fields finish with ;
|
|
int l = 1;
|
|
while (linesPtr[l][0] != '}')
|
|
{
|
|
// WARNING: Some structs have empty spaces and comments -> OK, processed
|
|
if ((linesPtr[l][0] != ' ') && (linesPtr[l][0] != '\0'))
|
|
{
|
|
// Scan one field line
|
|
char *fieldLine = linesPtr[l];
|
|
int fieldEndPos = 0;
|
|
while (fieldLine[fieldEndPos] != ';') fieldEndPos++;
|
|
|
|
if (fieldLine[0] != '/') // 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++;
|
|
}
|
|
}
|
|
|
|
l++;
|
|
}
|
|
|
|
}
|
|
|
|
free(structLines);
|
|
|
|
// Enum info data
|
|
enums = (EnumInfo *)calloc(MAX_ENUMS_TO_PARSE, sizeof(EnumInfo));
|
|
|
|
for (int i = 0; i < enumCount; i++)
|
|
{
|
|
|
|
// Parse enum description
|
|
// NOTE: This is not necessarily from the line immediately before,
|
|
// some of the enums have extra lines between the "description"
|
|
// and the typedef enum
|
|
for (int j = enumLines[i] - 1; j > 0; j--)
|
|
{
|
|
char *linePtr = lines[j];
|
|
if ((linePtr[0] != '/') || (linePtr[2] != ' '))
|
|
{
|
|
MemoryCopy(enums[i].desc, &lines[j + 1][0], sizeof(enums[i].desc) - 1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (int j = 1; j < MAX_ENUM_VALUES*2; j++) // Maximum number of lines following enum first line
|
|
{
|
|
char *linePtr = lines[enumLines[i] + j];
|
|
|
|
if ((linePtr[0] >= 'A') && (linePtr[0] <= 'Z'))
|
|
{
|
|
// Parse enum value line, possible options:
|
|
//ENUM_VALUE_NAME,
|
|
//ENUM_VALUE_NAME
|
|
//ENUM_VALUE_NAME = 99
|
|
//ENUM_VALUE_NAME = 99,
|
|
//ENUM_VALUE_NAME = 0x00000040, // Value description
|
|
|
|
// We start reading the value name
|
|
int c = 0;
|
|
while ((linePtr[c] != ',') &&
|
|
(linePtr[c] != ' ') &&
|
|
(linePtr[c] != '=') &&
|
|
(linePtr[c] != '\0')) { enums[i].valueName[enums[i].valueCount][c] = linePtr[c]; c++; }
|
|
|
|
// After the name we can have:
|
|
// '=' -> value is provided
|
|
// ',' -> value is equal to previous + 1, there could be a description if not '\0'
|
|
// ' ' -> value is equal to previous + 1, there could be a description if not '\0'
|
|
// '\0' -> value is equal to previous + 1
|
|
|
|
// Let's start checking if the line is not finished
|
|
if ((linePtr[c] != ',') && (linePtr[c] != '\0'))
|
|
{
|
|
// Two options:
|
|
// '=' -> value is provided
|
|
// ' ' -> value is equal to previous + 1, there could be a description if not '\0'
|
|
bool foundValue = false;
|
|
while ((linePtr[c] != '\0') && (linePtr[c] != '/'))
|
|
{
|
|
if (linePtr[c] == '=') { foundValue = true; break; }
|
|
c++;
|
|
}
|
|
|
|
if (foundValue)
|
|
{
|
|
if (linePtr[c + 1] == ' ') c += 2;
|
|
else c++;
|
|
|
|
// Parse integer value
|
|
int n = 0;
|
|
char integer[16] = { 0 };
|
|
|
|
while ((linePtr[c] != ',') && (linePtr[c] != ' ') && (linePtr[c] != '\0'))
|
|
{
|
|
integer[n] = linePtr[c];
|
|
c++; n++;
|
|
}
|
|
|
|
if (integer[1] == 'x') enums[i].valueInteger[enums[i].valueCount] = (int)strtol(integer, NULL, 16);
|
|
else enums[i].valueInteger[enums[i].valueCount] = atoi(integer);
|
|
}
|
|
else enums[i].valueInteger[enums[i].valueCount] = (enums[i].valueInteger[enums[i].valueCount - 1] + 1);
|
|
}
|
|
else enums[i].valueInteger[enums[i].valueCount] = (enums[i].valueInteger[enums[i].valueCount - 1] + 1);
|
|
|
|
// Look for description or end of line
|
|
while ((linePtr[c] != '/') && (linePtr[c] != '\0')) { c++; }
|
|
if (linePtr[c] == '/')
|
|
{
|
|
// Parse value description
|
|
MemoryCopy(enums[i].valueDesc[enums[i].valueCount], &linePtr[c], sizeof(enums[0].valueDesc[0]) - c - 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
|
|
}
|
|
}
|
|
}
|
|
free(enumLines);
|
|
|
|
// Define info data
|
|
defines = (DefineInfo *)calloc(MAX_DEFINES_TO_PARSE, sizeof(DefineInfo));
|
|
int defineIndex = 0;
|
|
|
|
for (int i = 0; i < defineCount; i++)
|
|
{
|
|
char *linePtr = lines[defineLines[i]];
|
|
int j = 0;
|
|
|
|
while (linePtr[j] == ' ' || linePtr[j] == '\t') j++; // Skip spaces and tabs in the begining
|
|
j += 8; // Skip "#define "
|
|
while (linePtr[j] == ' ' || linePtr[j] == '\t') j++; // Skip spaces and tabs after "#define "
|
|
|
|
// Extract name
|
|
int defineNameStart = j;
|
|
while (linePtr[j] != ' ' && linePtr[j] != '\t' && linePtr[j] != '\0') j++;
|
|
int defineNameEnd = j-1;
|
|
|
|
// Skip duplicates
|
|
int nameLen = defineNameEnd - defineNameStart + 1;
|
|
bool isDuplicate = false;
|
|
for (int k = 0; k < defineIndex; k++) {
|
|
if (nameLen == TextLength(defines[k].name) && IsTextEqual(defines[k].name, linePtr + defineNameStart, nameLen)) {
|
|
isDuplicate = true;
|
|
break;
|
|
}
|
|
}
|
|
if (isDuplicate) continue;
|
|
|
|
MemoryCopy(defines[defineIndex].name, linePtr + defineNameStart, nameLen);
|
|
|
|
// Determine type
|
|
if (linePtr[defineNameEnd] == ')') defines[defineIndex].type = MACRO;
|
|
|
|
while (linePtr[j] == ' ' || linePtr[j] == '\t') j++; // Skip spaces and tabs after name
|
|
|
|
int defineValueStart = j;
|
|
if (linePtr[j] == '\0' || linePtr == "/") defines[defineIndex].type = GUARD;
|
|
if (linePtr[j] == '"') defines[defineIndex].type = STRING;
|
|
else if (linePtr[j] == '\'') defines[defineIndex].type = CHAR;
|
|
else if (IsTextEqual(linePtr+j, "CLITERAL(Color)", 15)) defines[defineIndex].type = COLOR;
|
|
else if (isdigit(linePtr[j])) { // Parsing numbers
|
|
bool isFloat = false, isNumber = true, isHex = false;
|
|
while (linePtr[j] != ' ' && linePtr[j] != '\t' && linePtr[j] != '\0') {
|
|
char ch = linePtr[j];
|
|
if (ch == '.') isFloat = true;
|
|
if (ch == 'x') isHex = true;
|
|
if (!(isdigit(ch)||(ch >= 'a' && ch <= 'f')||(ch >= 'A' && ch <= 'F')||ch=='x'||ch=='L'||ch=='.'||ch=='+'||ch=='-')) isNumber = false;
|
|
j++;
|
|
}
|
|
if (isNumber) {
|
|
if (isFloat) {
|
|
defines[defineIndex].type = linePtr[j-1] == 'f' ? FLOAT : DOUBLE;
|
|
} else {
|
|
defines[defineIndex].type = linePtr[j-1] == 'L' ? LONG : INT;
|
|
defines[defineIndex].isHex = isHex;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Extracting value
|
|
while (linePtr[j] != '\\' && linePtr[j] != '\0' && !(linePtr[j] == '/' && linePtr[j+1] == '/')) j++;
|
|
int defineValueEnd = j-1;
|
|
while (linePtr[defineValueEnd] == ' ' || linePtr[defineValueEnd] == '\t') defineValueEnd--; // Remove trailing spaces and tabs
|
|
if (defines[defineIndex].type == LONG || defines[defineIndex].type == FLOAT) defineValueEnd--; // Remove number postfix
|
|
int valueLen = defineValueEnd - defineValueStart + 1;
|
|
if (valueLen > 255) valueLen = 255;
|
|
|
|
if (valueLen > 0) MemoryCopy(defines[defineIndex].value, linePtr + defineValueStart, valueLen);
|
|
|
|
// Extracting description
|
|
if (linePtr[j] == '/') {
|
|
int commentStart = j;
|
|
while (linePtr[j] != '\\' && linePtr[j] != '\0') j++;
|
|
int commentEnd = j-1;
|
|
int commentLen = commentEnd - commentStart + 1;
|
|
if (commentLen > 127) commentLen = 127;
|
|
|
|
MemoryCopy(defines[defineIndex].desc, linePtr + commentStart, commentLen);
|
|
}
|
|
|
|
defineIndex++;
|
|
}
|
|
defineCount = defineIndex;
|
|
free(defineLines);
|
|
|
|
// 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 dc = TextLength(apiDefine) + 1;
|
|
int funcRetTypeNameLen = c - dc; // Substract `define` ("RLAPI " for raylib.h)
|
|
MemoryCopy(funcRetTypeName, &funcLines[i][dc], funcRetTypeNameLen);
|
|
|
|
GetDataTypeAndName(funcRetTypeName, funcRetTypeNameLen, funcs[i].retType, funcs[i].name);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Get parameters from func line
|
|
for (int c = funcParamsStart; c < MAX_LINE_LENGTH; c++)
|
|
{
|
|
if (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
|
|
// defines[] -> We have all the defines 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");
|
|
else if (outputFormat == LUA) printf("\nOutput format: LUA\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>] [--define <DEF>]\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, LUA\n\n");
|
|
printf(" -d, --define <DEF> : Define functions define (i.e. RLAPI for raylib.h, RMDEF for raymath.h, etc\n");
|
|
printf(" NOTE: If not specified, defaults to: RLAPI\n\n");
|
|
|
|
printf("\nEXAMPLES:\n\n");
|
|
printf(" > raylib_parser --input raylib.h --output api.json\n");
|
|
printf(" Process <raylib.h> to generate <api.json>\n\n");
|
|
printf(" > raylib_parser --output raylib_data.info --format XML\n");
|
|
printf(" Process <raylib.h> to generate <raylib_data.info> as XML text data\n\n");
|
|
printf(" > raylib_parser --input raymath.h --output raymath_data.info --format XML\n");
|
|
printf(" Process <raymath.h> to generate <raymath_data.info> as XML text data\n\n");
|
|
}
|
|
|
|
// Process command line arguments
|
|
static void ProcessCommandLine(int argc, char *argv[])
|
|
{
|
|
for (int i = 1; i < argc; i++)
|
|
{
|
|
if (IsTextEqual(argv[i], "-h", 2) || IsTextEqual(argv[i], "--help", 6))
|
|
{
|
|
// Show info
|
|
ShowCommandLineInfo();
|
|
}
|
|
else if (IsTextEqual(argv[i], "-i", 2) || IsTextEqual(argv[i], "--input", 7))
|
|
{
|
|
// Check for valid argument and valid file extension
|
|
if (((i + 1) < argc) && (argv[i + 1][0] != '-'))
|
|
{
|
|
MemoryCopy(inFileName, argv[i + 1], TextLength(argv[i + 1])); // Read input filename
|
|
i++;
|
|
}
|
|
else printf("WARNING: No input file provided\n");
|
|
}
|
|
else if (IsTextEqual(argv[i], "-o", 2) || IsTextEqual(argv[i], "--output", 8))
|
|
{
|
|
if (((i + 1) < argc) && (argv[i + 1][0] != '-'))
|
|
{
|
|
MemoryCopy(outFileName, argv[i + 1], TextLength(argv[i + 1])); // Read output filename
|
|
i++;
|
|
}
|
|
else printf("WARNING: No output file provided\n");
|
|
}
|
|
else if (IsTextEqual(argv[i], "-f", 2) || IsTextEqual(argv[i], "--format", 8))
|
|
{
|
|
if (((i + 1) < argc) && (argv[i + 1][0] != '-'))
|
|
{
|
|
if (IsTextEqual(argv[i + 1], "DEFAULT\0", 8)) outputFormat = DEFAULT;
|
|
else if (IsTextEqual(argv[i + 1], "JSON\0", 5)) outputFormat = JSON;
|
|
else if (IsTextEqual(argv[i + 1], "XML\0", 4)) outputFormat = XML;
|
|
else if (IsTextEqual(argv[i + 1], "LUA\0", 4)) outputFormat = LUA;
|
|
}
|
|
else printf("WARNING: No format parameters provided\n");
|
|
}
|
|
else if (IsTextEqual(argv[i], "-d", 2) || IsTextEqual(argv[i], "--define", 8))
|
|
{
|
|
if (((i + 1) < argc) && (argv[i + 1][0] != '-'))
|
|
{
|
|
MemoryCopy(apiDefine, argv[i + 1], TextLength(argv[i + 1])); // Read functions define
|
|
apiDefine[TextLength(argv[i + 1])] = '\0';
|
|
i++;
|
|
}
|
|
else printf("WARNING: No define key provided\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
// Escape backslashes in a string, writing the escaped string into a static buffer
|
|
static char *EscapeBackslashes(char *text)
|
|
{
|
|
static char buffer[256] = { 0 };
|
|
|
|
int count = 0;
|
|
|
|
for (int i = 0; (text[i] != '\0') && (i < 255); i++, count++)
|
|
{
|
|
buffer[count] = text[i];
|
|
|
|
if (text[i] == '\\')
|
|
{
|
|
buffer[count + 1] = '\\';
|
|
count++;
|
|
}
|
|
}
|
|
|
|
buffer[count] = '\0';
|
|
|
|
return buffer;
|
|
}
|
|
|
|
// Get string of define type
|
|
static const char *StrDefineType(DefineType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case UNKNOWN: return "UNKNOWN";
|
|
case GUARD: return "GUARD";
|
|
case MACRO: return "MACRO";
|
|
case INT: return "INT";
|
|
case LONG: return "LONG";
|
|
case FLOAT: return "FLOAT";
|
|
case DOUBLE: return "DOUBLE";
|
|
case CHAR: return "CHAR";
|
|
case STRING: return "STRING";
|
|
case COLOR: return "COLOR";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
/*
|
|
// Replace text string
|
|
// REQUIRES: strlen(), strstr(), strncpy(), strcpy() -> TODO: Replace by custom implementations!
|
|
// WARNING: Returned buffer must be freed by the user (if return != NULL)
|
|
static char *TextReplace(char *text, const char *replace, const char *by)
|
|
{
|
|
// Sanity checks and initialization
|
|
if (!text || !replace || !by) return NULL;
|
|
|
|
char *result;
|
|
|
|
char *insertPoint; // Next insert point
|
|
char *temp; // Temp pointer
|
|
int replaceLen; // Replace string length of (the string to remove)
|
|
int byLen; // Replacement length (the string to replace replace by)
|
|
int lastReplacePos; // Distance between replace and end of last replace
|
|
int count; // Number of replacements
|
|
|
|
replaceLen = strlen(replace);
|
|
if (replaceLen == 0) return NULL; // Empty replace causes infinite loop during count
|
|
|
|
byLen = strlen(by);
|
|
|
|
// Count the number of replacements needed
|
|
insertPoint = text;
|
|
for (count = 0; (temp = strstr(insertPoint, replace)); count++) insertPoint = temp + replaceLen;
|
|
|
|
// Allocate returning string and point temp to it
|
|
temp = result = (char *)malloc(strlen(text) + (byLen - replaceLen)*count + 1);
|
|
|
|
if (!result) return NULL; // Memory could not be allocated
|
|
|
|
// First time through the loop, all the variable are set correctly from here on,
|
|
// - 'temp' points to the end of the result string
|
|
// - 'insertPoint' points to the next occurrence of replace in text
|
|
// - 'text' points to the remainder of text after "end of replace"
|
|
while (count--)
|
|
{
|
|
insertPoint = strstr(text, replace);
|
|
lastReplacePos = (int)(insertPoint - text);
|
|
temp = strncpy(temp, text, lastReplacePos) + lastReplacePos;
|
|
temp = strcpy(temp, by) + byLen;
|
|
text += lastReplacePos + replaceLen; // Move to next "end of replace"
|
|
}
|
|
|
|
// Copy remaind text part after replacement to result (pointed by moving temp)
|
|
strcpy(temp, text);
|
|
|
|
return result;
|
|
}
|
|
*/
|
|
|
|
// Export parsed data in desired format
|
|
static void ExportParsedData(const char *fileName, int format)
|
|
{
|
|
FILE *outFile = fopen(fileName, "wt");
|
|
|
|
switch (format)
|
|
{
|
|
case DEFAULT:
|
|
{
|
|
// Print 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");
|
|
}
|
|
|
|
fprintf(outFile, "\nDefines found: %i\n\n", defineCount);
|
|
for (int i = 0; i < defineCount; i++)
|
|
{
|
|
fprintf(outFile, "Define %03i: %s\n", i + 1, defines[i].name);
|
|
fprintf(outFile, " Name: %s\n", defines[i].name);
|
|
fprintf(outFile, " Type: %s\n", StrDefineType(defines[i].type));
|
|
fprintf(outFile, " Value: %s\n", defines[i].value);
|
|
fprintf(outFile, " Description: %s\n", defines[i].desc + 3);
|
|
}
|
|
} break;
|
|
case LUA:
|
|
{
|
|
fprintf(outFile, "return {\n");
|
|
|
|
// Print structs info
|
|
fprintf(outFile, " structs = {\n");
|
|
for (int i = 0; i < structCount; i++)
|
|
{
|
|
fprintf(outFile, " {\n");
|
|
fprintf(outFile, " name = \"%s\",\n", structs[i].name);
|
|
fprintf(outFile, " description = \"%s\",\n", EscapeBackslashes(structs[i].desc + 3));
|
|
fprintf(outFile, " fields = {\n");
|
|
for (int f = 0; f < structs[i].fieldCount; f++)
|
|
{
|
|
fprintf(outFile, " {\n");
|
|
fprintf(outFile, " type = \"%s\",\n", structs[i].fieldType[f]);
|
|
fprintf(outFile, " name = \"%s\",\n", structs[i].fieldName[f]);
|
|
fprintf(outFile, " description = \"%s\"\n", EscapeBackslashes(structs[i].fieldDesc[f] + 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", EscapeBackslashes(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", EscapeBackslashes(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 defines info
|
|
fprintf(outFile, " defines = {\n");
|
|
for (int i = 0; i < defineCount; i++)
|
|
{
|
|
fprintf(outFile, " {\n");
|
|
fprintf(outFile, " name = \"%s\",\n", defines[i].name);
|
|
fprintf(outFile, " type = \"%s\",\n", StrDefineType(defines[i].type));
|
|
if (defines[i].type == INT || defines[i].type == LONG || defines[i].type == FLOAT || defines[i].type == DOUBLE || defines[i].type == STRING) {
|
|
fprintf(outFile, " value = %s,\n", defines[i].value);
|
|
} else {
|
|
fprintf(outFile, " value = \"%s\",\n", defines[i].value);
|
|
}
|
|
fprintf(outFile, " description = \"%s\"\n", defines[i].desc + 3);
|
|
fprintf(outFile, " }");
|
|
|
|
if (i < defineCount - 1) fprintf(outFile, ",\n");
|
|
else fprintf(outFile, "\n");
|
|
}
|
|
fprintf(outFile, " },\n");
|
|
|
|
// Print functions info
|
|
fprintf(outFile, " functions = {\n");
|
|
for (int i = 0; i < funcCount; i++)
|
|
{
|
|
fprintf(outFile, " {\n");
|
|
fprintf(outFile, " name = \"%s\",\n", funcs[i].name);
|
|
fprintf(outFile, " description = \"%s\",\n", EscapeBackslashes(funcs[i].desc + 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, " {type = \"%s\", name = \"%s\"}", funcs[i].paramType[p], funcs[i].paramName[p]);
|
|
if (p < funcs[i].paramCount - 1) fprintf(outFile, ",\n");
|
|
else fprintf(outFile, "\n");
|
|
}
|
|
fprintf(outFile, " }\n");
|
|
}
|
|
fprintf(outFile, " }");
|
|
|
|
if (i < funcCount - 1) fprintf(outFile, ",\n");
|
|
else fprintf(outFile, "\n");
|
|
}
|
|
fprintf(outFile, " }\n");
|
|
fprintf(outFile, "}\n");
|
|
} break;
|
|
case 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", EscapeBackslashes(structs[i].desc + 3));
|
|
fprintf(outFile, " \"fields\": [\n");
|
|
for (int f = 0; f < structs[i].fieldCount; f++)
|
|
{
|
|
fprintf(outFile, " {\n");
|
|
fprintf(outFile, " \"type\": \"%s\",\n", structs[i].fieldType[f]);
|
|
fprintf(outFile, " \"name\": \"%s\",\n", structs[i].fieldName[f]);
|
|
fprintf(outFile, " \"description\": \"%s\"\n", EscapeBackslashes(structs[i].fieldDesc[f] + 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", EscapeBackslashes(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", EscapeBackslashes(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 defines info
|
|
fprintf(outFile, " \"defines\": [\n");
|
|
for (int i = 0; i < defineCount; i++)
|
|
{
|
|
fprintf(outFile, " {\n");
|
|
fprintf(outFile, " \"name\": \"%s\",\n", defines[i].name);
|
|
fprintf(outFile, " \"type\": \"%s\",\n", StrDefineType(defines[i].type));
|
|
if (defines[i].isHex) { // INT or LONG
|
|
fprintf(outFile, " \"value\": %ld,\n", strtol(defines[i].value, NULL, 16));
|
|
} else if (defines[i].type == INT || defines[i].type == LONG || defines[i].type == FLOAT || defines[i].type == DOUBLE || defines[i].type == STRING) {
|
|
fprintf(outFile, " \"value\": %s,\n", defines[i].value);
|
|
} else {
|
|
fprintf(outFile, " \"value\": \"%s\",\n", defines[i].value);
|
|
}
|
|
fprintf(outFile, " \"description\": \"%s\"\n", defines[i].desc + 3);
|
|
fprintf(outFile, " }");
|
|
|
|
if (i < defineCount - 1) fprintf(outFile, ",\n");
|
|
else fprintf(outFile, "\n");
|
|
}
|
|
fprintf(outFile, " ],\n");
|
|
|
|
// Print functions info
|
|
fprintf(outFile, " \"functions\": [\n");
|
|
for (int i = 0; i < funcCount; i++)
|
|
{
|
|
fprintf(outFile, " {\n");
|
|
fprintf(outFile, " \"name\": \"%s\",\n", funcs[i].name);
|
|
fprintf(outFile, " \"description\": \"%s\",\n", EscapeBackslashes(funcs[i].desc + 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, " {\n");
|
|
fprintf(outFile, " \"type\": \"%s\",\n", funcs[i].paramType[p]);
|
|
fprintf(outFile, " \"name\": \"%s\"\n", funcs[i].paramName[p]);
|
|
fprintf(outFile, " }");
|
|
if (p < funcs[i].paramCount - 1) fprintf(outFile, ",\n");
|
|
else fprintf(outFile, "\n");
|
|
}
|
|
fprintf(outFile, " ]\n");
|
|
}
|
|
fprintf(outFile, " }");
|
|
|
|
if (i < funcCount - 1) fprintf(outFile, ",\n");
|
|
else fprintf(outFile, "\n");
|
|
}
|
|
fprintf(outFile, " ]\n");
|
|
fprintf(outFile, "}\n");
|
|
} break;
|
|
case XML:
|
|
{
|
|
// XML format to export data:
|
|
/*
|
|
<?xml version="1.0" encoding="Windows-1252" ?>
|
|
<raylibAPI>
|
|
<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 defines info
|
|
fprintf(outFile, " <Defines count=\"%i\">\n", defineCount);
|
|
for (int i = 0; i < defineCount; i++)
|
|
{
|
|
fprintf(outFile, " <Define name=\"%s\" type=\"%s\" value=\"%s\" desc=\"%s\" />\n", defines[i].name, StrDefineType(defines[i].type), defines[i].value, defines[i].desc);
|
|
}
|
|
fprintf(outFile, " </Defines>\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);
|
|
}
|