feat: generate code in itself
This commit is contained in:
377
cmeta.h
Normal file
377
cmeta.h
Normal file
@@ -0,0 +1,377 @@
|
||||
#ifndef CMETA_H
|
||||
#define CMETA_H
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
typedef struct {
|
||||
const char* type;
|
||||
const char* name;
|
||||
} Field_Info;
|
||||
|
||||
typedef struct {
|
||||
const char* name;
|
||||
size_t fields_count;
|
||||
Field_Info *fields;
|
||||
} Struct_Info;
|
||||
|
||||
// AUTO GENERATED CODE //
|
||||
static Struct_Info foo_struct_info = { // cmeta.h:214
|
||||
.name = "Foo_Struct", // cmeta.h:215
|
||||
.fields_count = 1, // cmeta.h:216
|
||||
.fields = (Field_Info[1]) { // cmeta.h:217
|
||||
{ .type = "int", .name = "int_field" }, // cmeta.h:219
|
||||
}, // cmeta.h:221
|
||||
}; // cmeta.h:222
|
||||
static Struct_Info bar_struct_info = { // cmeta.h:214
|
||||
.name = "Bar_Struct", // cmeta.h:215
|
||||
.fields_count = 2, // cmeta.h:216
|
||||
.fields = (Field_Info[2]) { // cmeta.h:217
|
||||
{ .type = "int", .name = "int_field" }, // cmeta.h:219
|
||||
{ .type = "long", .name = "long_fields" }, // cmeta.h:219
|
||||
}, // cmeta.h:221
|
||||
}; // cmeta.h:222
|
||||
// AUTO GENERATED CODE //
|
||||
|
||||
// #define CMETA_COMPTIME
|
||||
#ifdef CMETA_COMPTIME
|
||||
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#define STB_C_LEXER_IMPLEMENTATION
|
||||
#include "stb_c_lexer.h"
|
||||
|
||||
stb_lexer lexer = {0};
|
||||
|
||||
typedef struct {
|
||||
char* type;
|
||||
char* name;
|
||||
} Parsed_Field_Info;
|
||||
|
||||
typedef struct {
|
||||
char* name;
|
||||
size_t fields_count;
|
||||
Parsed_Field_Info *fields;
|
||||
} Parsed_Struct_Info;
|
||||
|
||||
typedef struct {
|
||||
char* data;
|
||||
size_t capacity;
|
||||
size_t length;
|
||||
} String_Builder;
|
||||
|
||||
void sb_append(String_Builder* sb, const char* data) {
|
||||
size_t data_len = strlen(data);
|
||||
size_t total_len = sb->length + data_len;
|
||||
|
||||
if(total_len + 1 > sb->capacity) {
|
||||
size_t new_capacity = sb->capacity == 0 ? 64 : sb->capacity * 2;
|
||||
while(new_capacity < total_len + 1) {
|
||||
new_capacity *= 2;
|
||||
}
|
||||
sb->data = (char*) realloc(sb->data, new_capacity);
|
||||
sb->capacity = new_capacity;
|
||||
}
|
||||
|
||||
memcpy(sb->data + sb->length, data, data_len);
|
||||
sb->length = total_len;
|
||||
sb->data[sb->length] = '\0';
|
||||
}
|
||||
|
||||
bool lexer_expect_keyword(const char* expected) {
|
||||
stb_c_lexer_get_token(&lexer);
|
||||
|
||||
if (lexer.token != CLEX_id) {
|
||||
// TODO: map lexer.token to readable name
|
||||
fprintf(stderr, "ERROR: expected `%s` but got `%ld`\n", expected, lexer.token);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (strcmp(lexer.string, expected) != 0) {
|
||||
fprintf(stderr, "ERROR: expected `%s` but got `%s`\n", expected, lexer.string);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool lexer_expect(long expected, const char* expected_str) {
|
||||
stb_c_lexer_get_token(&lexer);
|
||||
|
||||
if (lexer.token != expected) {
|
||||
// TODO: map lexer.token to readable name
|
||||
if(expected_str != NULL) {
|
||||
fprintf(stderr, "ERROR: expected %s but got `%ld`\n", expected_str, lexer.token);
|
||||
} else {
|
||||
fprintf(stderr, "ERROR: expected `%ld` but got `%ld`\n", expected, lexer.token);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
long lexer_peek() {
|
||||
char* mark = lexer.parse_point;
|
||||
if (!stb_c_lexer_get_token(&lexer)) {
|
||||
lexer.parse_point = mark;
|
||||
return CLEX_eof;
|
||||
}
|
||||
|
||||
long token = lexer.token;
|
||||
lexer.parse_point = mark;
|
||||
|
||||
return token;
|
||||
}
|
||||
|
||||
// parses typedef struct { FIELDS } TYPE_NAME
|
||||
bool parse_struct(Parsed_Struct_Info* info) {
|
||||
bool result = false;
|
||||
char* name = NULL;
|
||||
|
||||
size_t fields_count = 0;
|
||||
Parsed_Field_Info fields[16] = {0}; // TODO: use dynamic array
|
||||
|
||||
if (!lexer_expect_keyword("typedef")) goto fail;
|
||||
if (!lexer_expect_keyword("struct")) goto fail;
|
||||
if (!lexer_expect('{', NULL)) goto fail;
|
||||
|
||||
while (true) {
|
||||
char* mark = lexer.parse_point;
|
||||
if (!stb_c_lexer_get_token(&lexer)) {
|
||||
fprintf(stderr, "ERROR: expected struct fields but got EOF\n");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (lexer.token == '}') break;
|
||||
lexer.parse_point = mark;
|
||||
|
||||
if (!lexer_expect(CLEX_id, "field type")) goto fail;
|
||||
char* field_type = strdup(lexer.string);
|
||||
|
||||
if (!lexer_expect(CLEX_id, "field name")) goto fail;
|
||||
char* field_name = strdup(lexer.string);
|
||||
|
||||
fields[fields_count].type = field_type;
|
||||
fields[fields_count].name = field_name;
|
||||
fields_count += 1;
|
||||
|
||||
if(!lexer_expect(';', NULL)) goto fail;
|
||||
}
|
||||
|
||||
if (!lexer_expect(CLEX_id, "type name")) goto fail;
|
||||
name = strdup(lexer.string);
|
||||
|
||||
info->name = name;
|
||||
info->fields_count = fields_count;
|
||||
info->fields = (Parsed_Field_Info*)calloc(fields_count, sizeof(Parsed_Field_Info));
|
||||
for(size_t i = 0; i < fields_count; i += 1) {
|
||||
info->fields[i].type = fields[i].type;
|
||||
info->fields[i].name = fields[i].name;
|
||||
}
|
||||
|
||||
result = true;
|
||||
fail:
|
||||
if(!result) {
|
||||
free(name);
|
||||
for(size_t i = 0; i < fields_count; i += 1) {
|
||||
free(fields[i].name);
|
||||
free(fields[i].type);
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void print_struct(Parsed_Struct_Info info) {
|
||||
printf("struct_name = %s\n", info.name);
|
||||
printf("fields[%zu] = [\n", info.fields_count);
|
||||
for (size_t i = 0; i < info.fields_count; i += 1) {
|
||||
printf(" { type = %s, name = %s },\n", info.fields[i].type, info.fields[i].name);
|
||||
}
|
||||
printf("]\n");
|
||||
}
|
||||
|
||||
#define gen(...) do { \
|
||||
fprintf(stream, __VA_ARGS__); \
|
||||
fprintf(stream, " // %s:%d\n", __FILE__, __LINE__); \
|
||||
} while(0)
|
||||
|
||||
char* to_lowercase(char* str) {
|
||||
size_t len = strlen(str);
|
||||
for(size_t i = 0; i < len; i += 1) {
|
||||
str[i] = tolower(str[i]);
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
void generate_struct_info(FILE* stream, Parsed_Struct_Info info) {
|
||||
char* lowercase_name = to_lowercase(strdup(info.name));
|
||||
|
||||
gen("static Struct_Info %s_info = {", lowercase_name);
|
||||
gen(" .name = \"%s\",", info.name);
|
||||
gen(" .fields_count = %zu,", info.fields_count);
|
||||
gen(" .fields = (Field_Info[%zu]) {", info.fields_count);
|
||||
for (size_t i = 0; i < info.fields_count; i += 1) {
|
||||
gen(" { .type = \"%s\", .name = \"%s\" },", info.fields[i].type, info.fields[i].name);
|
||||
}
|
||||
gen(" },");
|
||||
gen("};");
|
||||
|
||||
free(lowercase_name);
|
||||
}
|
||||
|
||||
bool read_entire_file(const char* file_path, char** content) {
|
||||
bool result = false;
|
||||
FILE* file = fopen(file_path, "rb");
|
||||
if(file == NULL) goto fail;
|
||||
|
||||
if(fseek(file, 0, SEEK_END) < 0) goto fail;
|
||||
|
||||
long length = ftell(file);
|
||||
if(length < 0) goto fail;
|
||||
|
||||
if(fseek(file, 0, SEEK_SET) < 0) goto fail;
|
||||
|
||||
*content = (char*) malloc((length + 1) * sizeof(char));
|
||||
fread(*content, 1, length, file);
|
||||
|
||||
// TODO: will not set errno
|
||||
if (ferror(file)) goto fail;
|
||||
|
||||
(*content)[length] = '\0';
|
||||
|
||||
result = true;
|
||||
fail:
|
||||
if (!result) {
|
||||
free(*content);
|
||||
fprintf(stderr, "ERROR: Could not read `%s`: %s\n", file_path, strerror(errno));
|
||||
}
|
||||
if (file) fclose(file);
|
||||
return result;
|
||||
}
|
||||
|
||||
bool generate_output_file(const char* output_path, Parsed_Struct_Info *struct_infos, size_t struct_infos_count) {
|
||||
const char* GENERATION_MARK = "// AUTO GENERATED CODE //\n";
|
||||
const size_t GENERATION_MARK_LEN = strlen(GENERATION_MARK);
|
||||
|
||||
bool result = false;
|
||||
|
||||
char* header_content;
|
||||
if (!read_entire_file(__FILE__, &header_content)) goto fail;
|
||||
|
||||
// 1. find BEGIN an END
|
||||
char* generate_begin = strstr(header_content, GENERATION_MARK);
|
||||
if (generate_begin == NULL) {
|
||||
fprintf(stderr, "ERROR: could not found generation mark in cmeta.h\n");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
char* generate_end = strstr(generate_begin + GENERATION_MARK_LEN, GENERATION_MARK);
|
||||
if (generate_end == NULL) {
|
||||
fprintf(stderr, "ERROR: could not found generation mark in cmeta.h\n");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
FILE* output_file = fopen(output_path, "wb");
|
||||
if (!output_file) {
|
||||
fprintf(stderr, "ERROR: could not write to %s: %s\n", output_path, strerror(errno));
|
||||
goto fail;
|
||||
}
|
||||
|
||||
FILE* stream = output_file;
|
||||
|
||||
// write up to the generation mark, including it
|
||||
fwrite(header_content, generate_begin + GENERATION_MARK_LEN - header_content, 1, stream);
|
||||
|
||||
for (size_t i = 0; i < struct_infos_count; i += 1) {
|
||||
generate_struct_info(stream, struct_infos[i]);
|
||||
}
|
||||
|
||||
fwrite(generate_end, strlen(generate_end), 1, stream);
|
||||
|
||||
result = true;
|
||||
fail:
|
||||
free(header_content);
|
||||
if (output_file) fclose(output_file);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
bool preprocess_file(const char* file_path, String_Builder* result) {
|
||||
char command[256] = {0};
|
||||
sprintf(command, "gcc -E %s", file_path);
|
||||
|
||||
FILE* fp = popen(command, "r");
|
||||
if (fp == NULL) {
|
||||
fprintf(stderr, "ERROR: Failed to run command: %s\n", strerror(errno));
|
||||
return false;
|
||||
}
|
||||
|
||||
char line[512];
|
||||
size_t line_num = 0;
|
||||
char file_name[512];
|
||||
|
||||
// TODO: use dynamic array instead
|
||||
size_t cursor = 0;
|
||||
result->length = 0;
|
||||
|
||||
bool collecting_content = false;
|
||||
|
||||
while (fgets(line, sizeof(line), fp) != NULL) {
|
||||
if (sscanf(line, "# %zu \"%s\"", &line_num, file_name) == 2) {
|
||||
// remove trailing "
|
||||
file_name[strlen(file_name) - 1] = '\0';
|
||||
|
||||
if (strcmp(file_name, file_path) == 0) {
|
||||
collecting_content = true;
|
||||
continue;
|
||||
}
|
||||
} else if(collecting_content) {
|
||||
sb_append(result, line);
|
||||
cursor += strlen(line);
|
||||
}
|
||||
}
|
||||
|
||||
pclose(fp);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool process_file(const char* input_file) {
|
||||
// read input file
|
||||
String_Builder input_content = {0};
|
||||
if (!preprocess_file(input_file, &input_content)) return false;
|
||||
|
||||
// init lexer
|
||||
char string_store[1024] = {0};
|
||||
stb_c_lexer_init(&lexer, input_content.data, input_content.data + input_content.length, string_store, sizeof(string_store) / sizeof(char));
|
||||
|
||||
// find and parse all structs
|
||||
size_t struct_infos_count = 0;
|
||||
Parsed_Struct_Info struct_infos[16]; // TODO: use dynamic array
|
||||
|
||||
while (true) {
|
||||
char* mark = lexer.parse_point;
|
||||
|
||||
if (!stb_c_lexer_get_token(&lexer)) break;
|
||||
if (lexer.token == CLEX_id && strcmp(lexer.string, "typedef") == 0) {
|
||||
lexer.parse_point = mark;
|
||||
|
||||
if (parse_struct(&struct_infos[struct_infos_count])) {
|
||||
struct_infos_count += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!generate_output_file(__FILE__, struct_infos, struct_infos_count)) return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif // CMETA_COMPTIME
|
||||
|
||||
#endif // CMETA_H
|
||||
Reference in New Issue
Block a user