doylet
/
Dqn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add ability to auto generate function prototypes

This commit is contained in:
Doyle 2019-02-26 02:15:51 +11:00
parent bdb6ca3352
commit b298eae175
3 changed files with 487 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

670
Code/DqnInspect.h
View File

@ -503,6 +503,8 @@ b32 StrCmp(StringLiteral a, StringLiteral b)
X(Identifier, "Identifier") \
X(Number, "[0-9]") \
X(Asterisks, "*") \
X(InspectCode, "DQN_INSPECT") \
X(InspectGeneratePrototype, "DQN_INSPECT_GENERATE_PROTOTYPE") \
X(Hash, "#")
#define X(decl, str) decl,
@ -548,6 +550,7 @@ struct CPPVariableDecl
StringLiteral name;
StringLiteral template_expr;
int array_dimensions;
StringLiteral default_value;
};
struct CPPTokeniser
@ -957,6 +960,105 @@ b32 ConsumeConstIdentifier(CPPTokeniser *tokeniser)
return result;
}
// NOTE(doyle): Doesn't parse the ending semicolon so we can reuse this function for parsing function arguments
CPPDeclLinkedList<CPPVariableDecl> *ParseCPPTypeAndVariableDecl(CPPTokeniser *tokeniser, b32 parse_function_param)
{
CPPDeclLinkedList<CPPVariableDecl> *result = nullptr;
CPPDeclLinkedList<CPPVariableDecl> *link_iterator = nullptr;
CPPToken token = CPPTokeniser_NextToken(tokeniser);
if (!ExpectToken(token, CPPTokenType::Identifier))
return result;
ConsumeConstIdentifier(tokeniser);
CPPToken variable_type = token;
for (int total_asterisks_count = 0;;)
{
CPPToken peek_token = CPPTokeniser_PeekToken(tokeniser);
StringLiteral variable_template_expr = {};
if (peek_token.type == CPPTokenType::LessThan)
{
token = CPPTokeniser_NextToken(tokeniser);
int template_depth = 1;
while (template_depth != 0 && token.type != CPPTokenType::EndOfStream)
{
token = CPPTokeniser_NextToken(tokeniser);
if (token.type == CPPTokenType::LessThan)
template_depth++;
else if (token.type == CPPTokenType::GreaterThan)
template_depth--;
}
if (template_depth == 0)
{
char *expr_start = peek_token.str + 1;
char *expr_end = token.str - 1;
int expr_len = static_cast<int>(expr_end - expr_start);
variable_template_expr.str = expr_start;
variable_template_expr.len = expr_len;
}
}
total_asterisks_count = ConsumeAsterisks(tokeniser);
if (ConsumeConstIdentifier(tokeniser))
{
total_asterisks_count += ConsumeAsterisks(tokeniser);
ConsumeConstIdentifier(tokeniser);
}
peek_token = CPPTokeniser_PeekToken(tokeniser);
CPPToken variable_name = peek_token;
if (variable_name.type != CPPTokenType::Identifier)
break;
// Allocate A Member Declaration
auto *link = MEM_ARENA_ALLOC_STRUCT(&global_main_arena, CPPDeclLinkedList<CPPVariableDecl>);
*link = {};
if (!result) result = link; // Set result to first linked list entry
else link_iterator->next = link;
link_iterator = link;
link->value.type = StringLiteral(variable_type.str, variable_type.len);
link->value.name = StringLiteral(variable_name.str, variable_name.len);
link->value.template_expr = variable_template_expr;
link->value.array_dimensions = total_asterisks_count;
CPPTokeniser_NextToken(tokeniser);
for (peek_token = CPPTokeniser_PeekToken(tokeniser);
peek_token.type == CPPTokenType::LeftSqBracket && peek_token.type != CPPTokenType::EndOfStream;
peek_token = CPPTokeniser_NextToken(tokeniser))
{
// TODO(doyle): Parsing array size is difficult if it's an expression, so maybe don't do it at all
++link->value.array_dimensions;
while (token.type != CPPTokenType::RightSqBracket && token.type != CPPTokenType::EndOfStream)
token = CPPTokeniser_NextToken(tokeniser);
}
if (IsIdentifierToken(peek_token, STR_LITERAL("DQN_INSPECT_META")))
{
link->metadata_array = ParseCPPInspectMeta(tokeniser);
peek_token = CPPTokeniser_PeekToken(tokeniser);
}
if (peek_token.type == CPPTokenType::Comma)
{
if (parse_function_param)
{
CPPTokeniser_NextToken(tokeniser);
variable_type = CPPTokeniser_PeekToken(tokeniser);
}
token = CPPTokeniser_NextToken(tokeniser);
}
else
{
break;
}
}
return result;
}
void ParseCPPStruct(CPPTokeniser *tokeniser)
{
CPPToken token = CPPTokeniser_NextToken(tokeniser);
@ -985,85 +1087,15 @@ void ParseCPPStruct(CPPTokeniser *tokeniser)
{
if (token.type == CPPTokenType::Identifier)
{
ConsumeConstIdentifier(tokeniser);
CPPToken const variable_type = token;
for (int total_asterisks_count = 0;;)
CPPTokeniser_RewindToken(tokeniser);
CPPDeclLinkedList<CPPVariableDecl> *link = ParseCPPTypeAndVariableDecl(tokeniser, false);
if (!struct_members) struct_members = link;
if (!link_iterator) link_iterator = link;
else
{
CPPToken peek_token = CPPTokeniser_PeekToken(tokeniser);
StringLiteral variable_template_expr = {};
if (peek_token.type == CPPTokenType::LessThan)
{
token = CPPTokeniser_NextToken(tokeniser);
int template_depth = 1;
while (template_depth != 0 && token.type != CPPTokenType::EndOfStream)
{
token = CPPTokeniser_NextToken(tokeniser);
if (token.type == CPPTokenType::LessThan)
template_depth++;
else if (token.type == CPPTokenType::GreaterThan)
template_depth--;
}
if (template_depth == 0)
{
char *expr_start = peek_token.str + 1;
char *expr_end = token.str - 1;
int expr_len = static_cast<int>(expr_end - expr_start);
variable_template_expr.str = expr_start;
variable_template_expr.len = expr_len;
}
}
total_asterisks_count = ConsumeAsterisks(tokeniser);
if (ConsumeConstIdentifier(tokeniser))
{
total_asterisks_count += ConsumeAsterisks(tokeniser);
ConsumeConstIdentifier(tokeniser);
}
peek_token = CPPTokeniser_PeekToken(tokeniser);
CPPToken variable_name = peek_token;
if (variable_name.type != CPPTokenType::Identifier)
break;
// Allocate A Member Declaration
auto *link = MEM_ARENA_ALLOC_STRUCT(&global_main_arena, CPPDeclLinkedList<CPPVariableDecl>);
*link = {};
if (!link_iterator) struct_members = link; // Set struct_members to first linked list entry
else link_iterator->next = link;
link_iterator = link;
link->value.type = StringLiteral(variable_type.str, variable_type.len);
link->value.name = StringLiteral(variable_name.str, variable_name.len);
link->value.template_expr = variable_template_expr;
link->value.array_dimensions = total_asterisks_count;
CPPTokeniser_NextToken(tokeniser);
for (peek_token = CPPTokeniser_PeekToken(tokeniser);
peek_token.type == CPPTokenType::LeftSqBracket && peek_token.type != CPPTokenType::EndOfStream;
peek_token = CPPTokeniser_NextToken(tokeniser))
{
// TODO(doyle): Parsing array size is difficult if it's an expression, so maybe don't do it at all
++link->value.array_dimensions;
while (token.type != CPPTokenType::RightSqBracket && token.type != CPPTokenType::EndOfStream)
token = CPPTokeniser_NextToken(tokeniser);
}
if (IsIdentifierToken(peek_token, STR_LITERAL("DQN_INSPECT_META")))
{
link->metadata_array = ParseCPPInspectMeta(tokeniser);
peek_token = CPPTokeniser_PeekToken(tokeniser);
}
if (peek_token.type == CPPTokenType::Comma)
{
CPPTokeniser_NextToken(tokeniser);
}
else
{
break;
}
for (;link_iterator->next; link_iterator = link_iterator->next) // TODO(doyle): Meh
;
link_iterator->next = link;
}
}
}
@ -1183,14 +1215,326 @@ void ParseCPPStruct(CPPTokeniser *tokeniser)
(void)break_here;
}
void SkipFunctionParam(CPPTokeniser *tokeniser)
{
CPPToken token = CPPTokeniser_PeekToken(tokeniser);
while (token.type != CPPTokenType::EndOfStream && token.type != CPPTokenType::Comma &&
token.type != CPPTokenType::CloseParen)
{
CPPTokeniser_NextToken(tokeniser);
token = CPPTokeniser_PeekToken(tokeniser);
}
}
void ParseCPPInspectPrototype(CPPTokeniser *tokeniser)
{
CPPToken token = CPPTokeniser_NextToken(tokeniser);
if (!ExpectToken(token, CPPTokenType::InspectGeneratePrototype))
return;
struct FunctionDefaultParam
{
StringLiteral name;
StringLiteral value;
};
LinkedList<FunctionDefaultParam> *default_param_list = nullptr;
MemArenaScopedRegion mem_region = MemArena_MakeScopedRegion(&global_main_arena);
{
LinkedList<FunctionDefaultParam> *link_iterator = nullptr;
token = CPPTokeniser_PeekToken(tokeniser);
if (!ExpectToken(token, CPPTokenType::OpenParen)) return;
token = CPPTokeniser_NextToken(tokeniser);
for (token = CPPTokeniser_NextToken(tokeniser);
token.type != CPPTokenType::CloseParen && token.type != CPPTokenType::EndOfStream;
token = CPPTokeniser_NextToken(tokeniser))
{
if (token.type == CPPTokenType::Comma)
continue;
StringLiteral default_param_name = StringLiteral(token.str, token.len);
if (token.type != CPPTokenType::Identifier)
{
SkipFunctionParam(tokeniser);
continue;
}
token = CPPTokeniser_NextToken(tokeniser);
if (token.type != CPPTokenType::Equals)
{
SkipFunctionParam(tokeniser);
continue;
}
token = CPPTokeniser_NextToken(tokeniser);
char *default_param_start = token.str;
SkipFunctionParam(tokeniser);
CPPToken peek_token = CPPTokeniser_PeekToken(tokeniser);
if (peek_token.type != CPPTokenType::Comma && peek_token.type != CPPTokenType::CloseParen)
continue;
char *default_param_end = peek_token.str;
auto *link = MEM_ARENA_ALLOC_STRUCT(&global_main_arena, LinkedList<FunctionDefaultParam>);
*link = {};
if (!default_param_list) default_param_list = link;
else link_iterator->next = link;
link_iterator = link;
link->value.name = default_param_name;
link->value.value = StringLiteral(default_param_start, static_cast<int>(default_param_end - default_param_start));
}
}
struct FunctionParam
{
StringLiteral type;
StringLiteral name;
// NOTE(doyle): This is resolved after function parsing, iterate over
// the default params specified in the macro and match them to the
// first param that has the same name
StringLiteral default_value;
};
StringLiteral return_type = {};
StringLiteral function_name = {};
// Grab return type token
{
token = CPPTokeniser_PeekToken(tokeniser);
if (!ExpectToken(token, CPPTokenType::Identifier))
return;
token = CPPTokeniser_NextToken(tokeniser);
return_type = StringLiteral(token.str, token.len);
}
// Grab function name token
{
token = CPPTokeniser_PeekToken(tokeniser);
if (!ExpectToken(token, CPPTokenType::Identifier))
return;
token = CPPTokeniser_NextToken(tokeniser);
function_name = StringLiteral(token.str, token.len);
}
token = CPPTokeniser_PeekToken(tokeniser);
if (!ExpectToken(token, CPPTokenType::OpenParen))
return;
CPPDeclLinkedList<CPPVariableDecl> *param_list = nullptr;
{
CPPDeclLinkedList<CPPVariableDecl> *link_iterator = nullptr;
token = CPPTokeniser_NextToken(tokeniser);
for (token = CPPTokeniser_NextToken(tokeniser);
token.type != CPPTokenType::CloseParen && token.type != CPPTokenType::EndOfStream;
token = CPPTokeniser_NextToken(tokeniser))
{
if (token.type == CPPTokenType::Identifier)
{
CPPTokeniser_RewindToken(tokeniser);
CPPDeclLinkedList<CPPVariableDecl> *link = ParseCPPTypeAndVariableDecl(tokeniser, true);
if (!param_list) param_list = link;
if (!link_iterator) link_iterator = link;
else
{
for (;link_iterator->next; link_iterator = link_iterator->next) // TODO(doyle): Meh
;
link_iterator->next = link;
}
}
}
}
for (LinkedList<FunctionDefaultParam> const *default_link = default_param_list; default_link; default_link = default_link->next)
{
FunctionDefaultParam const *default_param = &default_link->value;
for (CPPDeclLinkedList<CPPVariableDecl> *param_link = param_list; param_link; param_link = param_link->next)
{
CPPVariableDecl *decl = &param_link->value;
if (StrCmp(decl->name, default_param->name))
{
decl->default_value = default_param->value;
break;
}
}
}
CPPTokeniser_SprintfToFile(tokeniser, "%.*s %.*s(", return_type.len, return_type.str, function_name.len, function_name.str);
for (CPPDeclLinkedList<CPPVariableDecl> const *param_link = param_list; param_link; param_link = param_link->next)
{
// TODO(doyle): HACK. We should parse ptrs into the CPPVariableDecl, fixed size arrays into the name and const-ness into the type
CPPVariableDecl const *decl = &param_link->value;
char *name_start = decl->type.str + (decl->type.len + 1);
char *name_end = decl->name.str + decl->name.len;
StringLiteral hack_decl_name = StringLiteral(name_start, static_cast<int>(name_end - name_start));
CPPTokeniser_SprintfToFileNoIndenting(tokeniser, "%.*s %.*s", decl->type.len, decl->type.str, hack_decl_name.len, hack_decl_name.str);
if (decl->default_value.len > 0)
CPPTokeniser_SprintfToFileNoIndenting(tokeniser, " = %.*s", decl->default_value.len, decl->default_value.str);
if (param_link->next)
CPPTokeniser_SprintfToFileNoIndenting(tokeniser, ", ", return_type.len, return_type.str, function_name.len, function_name.str);
}
CPPTokeniser_SprintfToFileNoIndenting(tokeniser, ");\n");
}
enum struct InspectMode
{
All,
Code,
GenerateProtypes
};
char *EnumOrStructOrFunctionLexer(CPPTokeniser *tokeniser, char *ptr, b32 lexing_function)
{
int indent_level = 0;
bool started_lexing_brace_scope = false;
bool started_lexing_function = false;
int open_paren_level = 0;
int close_paren_level = 0;
for (; ptr;)
{
while (CharIsWhitespace(ptr[0])) ptr++;
if (!ptr[0]) break;
CPPToken *token = CPPTokeniser_MakeToken(tokeniser);
token->str = ptr++;
token->len = 1;
switch(token->str[0])
{
case '{': { token->type = CPPTokenType::LeftBrace; started_lexing_brace_scope = true; indent_level++; } break;
case '}': { token->type = CPPTokenType::RightBrace; indent_level--; } break;
case '[': { token->type = CPPTokenType::LeftSqBracket; } break;
case ']': { token->type = CPPTokenType::RightSqBracket; } break;
case '(': { token->type = CPPTokenType::OpenParen; started_lexing_function = true; open_paren_level++; } break;
case ')': { token->type = CPPTokenType::CloseParen; close_paren_level++; } break;
case ',': { token->type = CPPTokenType::Comma; } break;
case ';': { token->type = CPPTokenType::SemiColon; } break;
case '=': { token->type = CPPTokenType::Equals; } break;
case '<': { token->type = CPPTokenType::LessThan; } break;
case '>': { token->type = CPPTokenType::GreaterThan; } break;
case ':': { token->type = CPPTokenType::Colon; } break;
case '*': { token->type = CPPTokenType::Asterisks; } break;
case '/':
{
token->type = CPPTokenType::FwdSlash;
if (ptr[0] == '/' || ptr[0] == '*')
{
token->type = CPPTokenType::Comment;
if (ptr[0] == '/')
{
while (ptr[0] == ' ' || ptr[0] == '\t') ptr++;
token->str = ptr;
while (ptr[0] != '\n') ptr++;
}
else
{
for (;;)
{
while (ptr[0] != '*') ptr++;
ptr++;
if (ptr[0] == '\\') break;
token->len = static_cast<int>(ptr - token->str);
}
}
token->len = static_cast<int>(ptr - token->str);
}
}
break;
default:
{
ptr--;
if (ptr[0] == '"')
{
token->type = CPPTokenType::String;
for (token->str = ++ptr;;)
{
while (ptr[0] != '"') ptr++;
token->len = static_cast<int>(ptr - token->str);
if (ptr[-1] != '\\')
{
ptr++;
break;
}
}
}
else
{
if (CharIsDigit(ptr[0]))
{
while (CharIsDigit(ptr[0]) || ptr[0] == 'x' || ptr[0] == 'b' || ptr[0] == 'e' || ptr[0] == '.' || ptr[0] == 'f')
ptr++;
token->type = CPPTokenType::Number;
}
else
{
token->type = CPPTokenType::Identifier;
if (CharIsAlpha(ptr[0]) || ptr[0] == '_')
{
ptr++;
while (CharIsAlphaNum(ptr[0]) || ptr[0] == '_') ptr++;
}
}
token->len = static_cast<int>(ptr - token->str);
}
}
break;
}
if (token->len == 0)
{
*token = {};
tokeniser->tokens_len--;
}
else
{
if (lexing_function)
{
if (started_lexing_function && open_paren_level == close_paren_level && open_paren_level == 2)
return ptr;
}
else
{
if (started_lexing_brace_scope && indent_level == 0)
return ptr;
}
}
}
return ptr;
}
int main(int argc, char *argv[])
{
if (argc < 1)
{
fprintf(stdout, "Usage: %s [<filename>, ...]", argv[0]);
fprintf(stdout,
"Usage: %s [code|generate_prototypes] [<source code filename>, ...]\n"
"Options: If ommitted, both modes are run\n"
" code Only generate the inspection data for structs/enums marked with DQN_INSPECT\n"
" generate_prototypes Only generate the function prototypes for functions marked with DQN_INSPECT_GENERATE_PROTOTYPE\n",
argv[0]);
return 0;
}
usize starting_arg_index = 1;
char const *mode_str = argv[1];
InspectMode mode = InspectMode::All;
if (strcmp(mode_str, "code") == 0) mode = InspectMode::Code;
else if (strcmp(mode_str, "generate_prototypes") == 0) mode = InspectMode::GenerateProtypes;
if (mode != InspectMode::All)
starting_arg_index++;
usize main_arena_mem_size = MEGABYTE(2);
void *main_arena_mem = malloc(main_arena_mem_size);
global_main_arena = MemArena_Init(main_arena_mem, main_arena_mem_size);
@ -1200,10 +1544,11 @@ int main(int argc, char *argv[])
FILE *output_file = stdout;
#endif
fprintf(output_file,
"// This is an auto generated file using Dqn_Inspect\n\n");
for (usize arg_index = 1; arg_index < argc; ++arg_index)
for (usize arg_index = starting_arg_index; arg_index < argc; ++arg_index)
{
MemArenaScopedRegion mem_region = MemArena_MakeScopedRegion(&global_main_arena);
char *file_name = argv[arg_index];
@ -1272,112 +1617,47 @@ int main(int argc, char *argv[])
tokeniser.tokens_max = 16384;
tokeniser.tokens = MEM_ARENA_ALLOC_ARRAY(&global_main_arena, CPPToken, tokeniser.tokens_max);
StringLiteral const INSPECT_MARKER = STR_LITERAL("DQN_INSPECT");
char *file_buf_end = file_buf + file_size;
StringLiteral buffer = StringLiteral(file_buf, static_cast<int>(file_size));
StringLiteral const INSPECT_PROTOTYPE = STR_LITERAL("DQN_INSPECT_GENERATE_PROTOTYPE");
StringLiteral const INSPECT_PREFIX = STR_LITERAL("DQN_INSPECT");
char *file_buf_end = file_buf + file_size;
StringLiteral buffer = StringLiteral(file_buf, static_cast<int>(file_size));
for (char *ptr = StrFind(buffer, INSPECT_MARKER);
for (char *ptr = StrFind(buffer, INSPECT_PREFIX);
ptr;
ptr = StrFind(buffer, INSPECT_MARKER))
ptr = StrFind(buffer, INSPECT_PREFIX))
{
ptr += INSPECT_MARKER.len;
int indent_level = 0;
bool started_lexing_scope = false;
for (; ptr;)
char *marker_str = ptr;
int marker_len = static_cast<int>(file_buf_end - ptr);
DEFER
{
while (CharIsWhitespace(ptr[0])) ptr++;
if (!ptr[0]) break;
buffer.str = ptr;
buffer.len = static_cast<int>(file_buf_end - ptr);
};
CPPToken *token = CPPTokeniser_MakeToken(&tokeniser);
token->str = ptr++;
token->len = 1;
switch(token->str[0])
{
case '{': { token->type = CPPTokenType::LeftBrace; started_lexing_scope = true; indent_level++; } break;
case '}': { token->type = CPPTokenType::RightBrace; indent_level--; } break;
case '[': { token->type = CPPTokenType::LeftSqBracket; } break;
case ']': { token->type = CPPTokenType::RightSqBracket; } break;
case '(': { token->type = CPPTokenType::OpenParen; } break;
case ')': { token->type = CPPTokenType::CloseParen; } break;
case ',': { token->type = CPPTokenType::Comma; } break;
case ';': { token->type = CPPTokenType::SemiColon; } break;
case '=': { token->type = CPPTokenType::Equals; } break;
case '<': { token->type = CPPTokenType::LessThan; } break;
case '>': { token->type = CPPTokenType::GreaterThan; } break;
case ':': { token->type = CPPTokenType::Colon; } break;
case '*': { token->type = CPPTokenType::Asterisks; } break;
case '/':
{
token->type = CPPTokenType::FwdSlash;
if (ptr[0] == '/')
{
ptr++;
while (ptr[0] == ' ' || ptr[0] == '\t') ptr++;
token->str = ptr;
while (ptr[0] != '\n') ptr++;
token->type = CPPTokenType::Comment;
token->len = static_cast<int>(ptr - token->str);
}
}
break;
default:
{
ptr--;
if (ptr[0] == '"')
{
token->type = CPPTokenType::String;
for (token->str = ++ptr;;)
{
while (ptr[0] != '"') ptr++;
token->len = static_cast<int>(ptr - token->str);
if (ptr[-1] != '\\')
{
ptr++;
break;
}
}
}
else
{
if (CharIsDigit(ptr[0]))
{
while (CharIsDigit(ptr[0]) || ptr[0] == 'x' || ptr[0] == 'b' || ptr[0] == 'e' || ptr[0] == '.' || ptr[0] == 'f')
ptr++;
token->type = CPPTokenType::Number;
}
else
{
token->type = CPPTokenType::Identifier;
if (CharIsAlpha(ptr[0]) || ptr[0] == '_')
{
ptr++;
while (CharIsAlphaNum(ptr[0]) || ptr[0] == '_') ptr++;
}
}
token->len = static_cast<int>(ptr - token->str);
}
}
break;
}
if (token->len == 0)
{
*token = {};
tokeniser.tokens_len--;
}
else
{
if (started_lexing_scope && indent_level == 0)
break;
}
CPPTokenType inspect_type = CPPTokenType::InspectCode;
if (StrCmp(StringLiteral(ptr, INSPECT_PROTOTYPE.len), INSPECT_PROTOTYPE))
{
inspect_type = CPPTokenType::InspectGeneratePrototype;
}
buffer.str = ptr;
buffer.len = static_cast<int>(file_buf_end - ptr);
if (inspect_type == CPPTokenType::InspectCode)
{
ptr += INSPECT_PREFIX.len;
if (mode == InspectMode::GenerateProtypes) continue;
}
else
{
ptr += INSPECT_PROTOTYPE.len;
if (mode == InspectMode::Code) continue;
}
CPPToken *inspect_token = CPPTokeniser_MakeToken(&tokeniser);
inspect_token->type = inspect_type;
inspect_token->str = marker_str;
inspect_token->len = marker_len;
ptr = EnumOrStructOrFunctionLexer(&tokeniser, ptr, inspect_type == CPPTokenType::InspectGeneratePrototype);
}
CPPToken *sentinel = CPPTokeniser_MakeToken(&tokeniser);
@ -1387,18 +1667,26 @@ int main(int argc, char *argv[])
;
token = CPPTokeniser_PeekToken(&tokeniser))
{
#if 0
Token const *token = tokens + index;
fprintf(stdout, "%.*s", token->len, token->str);
if (index < (tokens_index - 1)) fprintf(stdout, " -> ");
#endif
if (IsIdentifierToken(token, STR_LITERAL("enum")))
if (token.type == CPPTokenType::InspectCode || token.type == CPPTokenType::InspectGeneratePrototype)
{
ParseCPPEnum(&tokeniser);
}
else if (IsIdentifierToken(token, STR_LITERAL("struct")) || IsIdentifierToken(token, STR_LITERAL("class")))
{
ParseCPPStruct(&tokeniser);
if (token.type == CPPTokenType::InspectCode)
{
token = CPPTokeniser_NextToken(&tokeniser);
token = CPPTokeniser_PeekToken(&tokeniser);
if (IsIdentifierToken(token, STR_LITERAL("enum")))
{
ParseCPPEnum(&tokeniser);
}
else if (IsIdentifierToken(token, STR_LITERAL("struct")) || IsIdentifierToken(token, STR_LITERAL("class")))
{
ParseCPPStruct(&tokeniser);
}
}
else
{
ParseCPPInspectPrototype(&tokeniser);
}
}
else
{
@ -1410,7 +1698,7 @@ int main(int argc, char *argv[])
}
fprintf(output_file,
"#undef ARRAY_COUNT\n"
"\n#undef ARRAY_COUNT\n"
"#undef CHAR_COUNT\n"
"#undef STR_AND_LEN\n"
"#endif // DQN_INSPECT_%.*s\n\n",

6
Data/DqnInspect_TestData.h
View File

@ -45,3 +45,9 @@ DQN_INSPECT struct OpenGLState
int const* i;
int *********const j, k, ******l, *m;
};
DQN_INSPECT_GENERATE_PROTOTYPE(texture = nullptr, size = {}, depth_test = false, type = 1, user_msg = "Hello world")
void RenderRect(V3 pos, V2 size, char const *texture, bool depth_test, int type, char *user_msg)
{
(void)pos; void(size); (void)texture; (void)depth_test;
}

2
Data/DqnInspect_TestDataGenerated.cpp
View File

@ -233,6 +233,8 @@ DqnInspect_Struct const *DqnInspect_GetStruct(OpenGLState const *val)
return result;
}
void RenderRect(V3 pos, V2 size = {}, char const *texture = nullptr, bool depth_test = false, int type = 1, char *user_msg = Hello world");
#undef ARRAY_COUNT
#undef CHAR_COUNT
#undef STR_AND_LEN