/*
|
* Copyright (c) 2020, Rockchip Electronics Co., Ltd
|
*
|
* This program is free software; you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation; either version 2 of the License, or
|
* (at your option) any later version.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*/
|
#define _GNU_SOURCE
|
|
#include "common.h"
|
|
#include <time.h>
|
#include <string.h>
|
|
/* j2s list helpers */
|
typedef struct {
|
void *data;
|
void *next;
|
void *prev;
|
} j2s_list;
|
|
void j2s_list_add(j2s_list *head, void *data) {
|
j2s_list *entry = malloc(sizeof(j2s_list));
|
DASSERT(entry, exit(-1));
|
|
entry->data = data;
|
|
entry->prev = head->prev;
|
entry->next = head;
|
((j2s_list *)head->prev)->next = entry;
|
head->prev = entry;
|
}
|
|
void j2s_list_del(j2s_list *entry) {
|
((j2s_list *)entry->prev)->next = entry->next;
|
((j2s_list *)entry->next)->prev = entry->prev;
|
free(entry);
|
}
|
|
#define j2s_list_init(head) \
|
(head)->prev = (head)->next = head; (head)->data = NULL;
|
|
#define j2s_list_empty(head) \
|
((head)->prev == head)
|
|
#define j2s_list_walk_safe(head, entry, next, obj) \
|
for (entry = (head)->next, next = entry->next, obj = entry->data; \
|
entry != head; \
|
entry = next, next = entry->next, obj = entry->data)
|
|
#define j2s_list_walk(head, entry, obj) \
|
for (entry = (head)->next, obj = entry->data; entry != head; \
|
entry = entry->next, obj = entry->data)
|
|
#define j2s_list_free(head, entry, free_data) \
|
for (entry = (head)->next; entry != head; \
|
entry = entry->next, free(entry->prev)) \
|
if (free_data) free(entry->data)
|
|
#define j2s_list_find(head, entry, obj, s) \
|
j2s_list_walk(head, entry, obj) \
|
if (!strcmp(obj->name, s)) break; \
|
if (entry == head) obj = NULL;
|
|
/* Info about each enums */
|
typedef struct {
|
int id;
|
char name[MAX_NAME]; /* Enum name */
|
j2s_list values; /* value list */
|
int value_id; /* Id of the first enum value */
|
int num_value; /* Number of enum values */
|
} j2s_enum;
|
|
/* Info about each enum values */
|
typedef struct {
|
int id;
|
char name[MAX_NAME]; /* Value name */
|
} j2s_enum_value;
|
|
/* Info about each structs */
|
typedef struct {
|
int id;
|
char name[MAX_NAME]; /* Struct name */
|
j2s_list child; /* Child list */
|
int child_id; /* Id of the first child */
|
} j2s_struct;
|
|
/* Info about each struct members */
|
typedef struct {
|
int id;
|
char name[MAX_NAME]; /* Member name */
|
char type_name[MAX_NAME]; /* Origin type name */
|
j2s_type type;
|
j2s_flag flags;
|
|
char *desc; /* Optional desc string */
|
|
void *next; /* Next child of the parent */
|
j2s_struct *parent; /* Parent struct */
|
|
j2s_struct *struct_obj; /* Struct info(if type is struct) */
|
j2s_enum *enum_obj; /* Enum info(if type is enum) */
|
void *len_obj; /* Dynamic array needs a @<name>_len obj to store len */
|
|
int line; /* Line of the header file */
|
} j2s_obj;
|
|
/* J2S parsing context */
|
typedef struct {
|
j2s_list structs;
|
j2s_list enums;
|
j2s_list objs;
|
|
int num_enum_value;
|
int num_struct;
|
int num_enum;
|
int num_obj;
|
|
int depth;
|
|
bool pending_bool;
|
bool pending_enum;
|
bool pending_struct;
|
bool pending_comment;
|
|
j2s_struct *struct_obj;
|
j2s_enum *enum_obj;
|
|
char *desc;
|
|
j2s_struct *root_struct;
|
|
FILE *fp; /* Input file */
|
int line; /* Line of the header file */
|
} j2s_ctx;
|
|
#define J2S_TYPE(t) [t] = #t
|
const char j2s_types[][MAX_NAME] = {
|
J2S_TYPE(J2S_TYPE_INT_8),
|
J2S_TYPE(J2S_TYPE_UINT_8),
|
J2S_TYPE(J2S_TYPE_INT_16),
|
J2S_TYPE(J2S_TYPE_UINT_16),
|
J2S_TYPE(J2S_TYPE_INT_32),
|
J2S_TYPE(J2S_TYPE_UINT_32),
|
J2S_TYPE(J2S_TYPE_INT_64),
|
J2S_TYPE(J2S_TYPE_UINT_64),
|
J2S_TYPE(J2S_TYPE_FLOAT),
|
J2S_TYPE(J2S_TYPE_DOUBLE),
|
J2S_TYPE(J2S_TYPE_STRING),
|
J2S_TYPE(J2S_TYPE_STRUCT),
|
};
|
|
static inline
|
j2s_type j2s_parse_type(const char *type, j2s_flag flags) {
|
if (!strcmp(type, "char") &&
|
(flags & (J2S_FLAG_ARRAY | J2S_FLAG_POINTER)))
|
return J2S_TYPE_STRING;
|
if (!strcmp(type, "char") || !strcmp(type, "bool") ||
|
!strcmp(type, "int8_t"))
|
return J2S_TYPE_INT_8;
|
if (!strcmp(type, "unsigned char") || !strcmp(type, "uint8_t"))
|
return J2S_TYPE_UINT_8;
|
if (!strcmp(type, "short") || !strcmp(type, "int16_t"))
|
return J2S_TYPE_INT_16;
|
if (!strcmp(type, "unsigned short") || !strcmp(type, "uint16_t"))
|
return J2S_TYPE_UINT_16;
|
if (!strcmp(type, "int") || !strcmp(type, "int32_t"))
|
return J2S_TYPE_INT_32;
|
if (!strcmp(type, "unsigned int") || !strcmp(type, "uint32_t"))
|
return J2S_TYPE_UINT_32;
|
if (!strcmp(type, "long") || !strcmp(type, "long long") ||
|
!strcmp(type, "int64_t"))
|
return J2S_TYPE_INT_64;
|
if (!strcmp(type, "unsigned long") ||
|
!strcmp(type, "unsigned long long") || !strcmp(type, "uint64_t"))
|
return J2S_TYPE_UINT_64;
|
if (!strcmp(type, "float"))
|
return J2S_TYPE_FLOAT;
|
if (!strcmp(type, "double"))
|
return J2S_TYPE_DOUBLE;
|
|
/* Fallback to struct, unsupported types would be catched later */
|
return J2S_TYPE_STRUCT;
|
}
|
|
static inline
|
void strip_spaces(char **buf, bool strip_tails) {
|
if (!buf || !*buf)
|
return;
|
|
#define IS_SPACE(c) ((c) == '\t' || (c) == ' ' || (c) == ',' || \
|
(c) == '\'' || (c) == ';' || (c) == '\n' || (c) == '\r')
|
|
/* Strip leading spaces */
|
while (IS_SPACE(*buf[0]))
|
(*buf)++;
|
|
if (!strip_tails)
|
return;
|
|
/* Strip tail spaces */
|
for (int i = strlen(*buf) - 1; i >= 0 && IS_SPACE((*buf)[i]); i--)
|
(*buf)[i] = '\0';
|
}
|
|
/* Strip spaces and compare and eat pattern */
|
static inline
|
int parse_pattern(char **buf, const char *pattern) {
|
int ret = -1;
|
|
if (!buf || !*buf)
|
return -1;
|
|
/* Strip spaces */
|
strip_spaces(buf, false);
|
|
/* Compare and eat pattern */
|
if (pattern && !strncmp(*buf, pattern, strlen(pattern))) {
|
*buf += strlen(pattern);
|
ret = 0;
|
}
|
|
/* Strip spaces */
|
strip_spaces(buf, false);
|
|
return ret;
|
}
|
|
/* Return the first pos of a or b */
|
static inline
|
char *strchr_first(const char *buf, const char a, const char b) {
|
char *p1, *p2;
|
|
if (a == b)
|
return strchr(buf, a);
|
|
p1 = strchrnul(buf, a);
|
p2 = strchrnul(buf, b);
|
|
if (p1 == p2)
|
return NULL;
|
|
return p1 < p2 ? p1 : p2;
|
}
|
|
static inline
|
void j2s_handle_comment(j2s_ctx *ctx, char *buf) {
|
int size;
|
|
strip_spaces(&buf, true);
|
DBG("comment: %s\n", buf);
|
|
if (!ctx->struct_obj)
|
return;
|
|
if (parse_pattern(&buf, J2S_DESC_MAGIC) < 0)
|
return;
|
|
/* Handle member desc (comments started with magic) */
|
|
if (!ctx->desc)
|
ctx->desc = strdup("");
|
else
|
strcat(ctx->desc, ", ");
|
|
size = strlen(ctx->desc) + strlen(buf) + 10;
|
|
ctx->desc = realloc(ctx->desc, size);
|
DASSERT_MSG(ctx->desc, exit(-1), "desc size too large: %d\n", size);
|
|
strcat(ctx->desc, buf);
|
|
DBG("new desc: %s\n", ctx->desc);
|
}
|
|
static inline
|
int j2s_parse(j2s_ctx *ctx, char *buf) {
|
j2s_enum_value *enum_value = NULL;
|
j2s_struct *struct_obj = NULL;
|
j2s_enum *enum_obj = NULL;
|
j2s_obj *obj = NULL;
|
j2s_flag flags;
|
|
char pending[MAX_LINE] = {0};
|
char *ptr, *type, *name;
|
|
DBG("parsing '%s' at %d\n", buf, ctx->line);
|
|
strip_spaces(&buf, true);
|
|
/* 1. Handle multiline comments */
|
if (ctx->pending_comment) {
|
ptr = strstr(buf, "*/");
|
if (ptr) {
|
/* End of multiline comment */
|
*ptr = '\0';
|
|
j2s_handle_comment(ctx, buf);
|
|
buf = ptr + 2;
|
ctx->pending_comment = false;
|
} else {
|
/* Multiline comments */
|
strip_spaces(&buf, true);
|
while (buf[0] == '*')
|
buf++;
|
|
j2s_handle_comment(ctx, buf);
|
return 0;
|
}
|
}
|
|
/* 2. Handle new comments */
|
ptr = strstr(buf, "/*");
|
if (ptr) {
|
/* Start of comment */
|
char *start = ptr + 2;
|
|
*ptr = '\0';
|
ptr = strstr(start, "*/");
|
if (ptr) {
|
/* Inline comment */
|
*ptr = '\0';
|
ptr += 2;
|
|
j2s_handle_comment(ctx, start);
|
|
/* Remove inline comment */
|
start = buf + strlen(buf);
|
for (int i = 0; i < strlen(ptr) + 1; i++)
|
start[i] = ptr[i];
|
|
return j2s_parse(ctx, buf);
|
} else {
|
/* Start of multiline comments */
|
ctx->pending_comment = true;
|
j2s_handle_comment(ctx, start);
|
}
|
}
|
|
ptr = strstr(buf, "//");
|
if (ptr) {
|
/* One line comment */
|
*ptr = '\0';
|
ptr += 2;
|
|
j2s_handle_comment(ctx, ptr);
|
}
|
|
/* 3. Split buf */
|
strip_spaces(&buf, true);
|
ptr = strchr_first(buf, ';', '{');
|
if (ptr) {
|
ptr++;
|
|
if (*ptr) {
|
strcpy(pending, ptr);
|
*ptr = '\0';
|
strip_spaces(&buf, true);
|
|
DBG("parsing '%s', pending '%s'\n",
|
buf, pending);
|
}
|
}
|
|
/* 4. Filter out empty lines */
|
if (buf[0] == '\0' || buf[0] == '#')
|
goto out;
|
|
/* 5. Handle enum definations */
|
if (!parse_pattern(&buf, "typedef enum")) {
|
DASSERT_MSG(!ctx->struct_obj && !ctx->enum_obj && \
|
!ctx->pending_enum && !ctx->pending_struct && \
|
!ctx->depth, exit(-1),
|
"failed to parse enum at %d\n", ctx->line);
|
|
ctx->pending_enum = true;
|
}
|
|
if (ctx->pending_enum) {
|
if (!strchr(buf, '{')) {
|
DBG("waiting for '{', skip \"%s\"\n", buf);
|
goto out;
|
}
|
|
ctx->depth++;
|
|
/* Handle new enum */
|
DBG("found enum\n");
|
|
ctx->pending_enum = false;
|
ctx->enum_obj = malloc(sizeof(*enum_obj));
|
DASSERT(ctx->enum_obj, exit(-1));
|
|
j2s_list_init(&ctx->enum_obj->values);
|
ctx->enum_obj->value_id = -1;
|
ctx->enum_obj->num_value = 0;
|
goto out;
|
}
|
|
if (ctx->enum_obj) {
|
j2s_enum_value *enum_value;
|
|
if (!parse_pattern(&buf, "}")) {
|
ctx->depth--;
|
|
/* End of enum defination */
|
strip_spaces(&buf, true);
|
|
INFO("adding enum %s\n", buf);
|
|
/* Add to enum list */
|
strncpy(ctx->enum_obj->name, buf,
|
sizeof(ctx->enum_obj->name));
|
ctx->enum_obj->id = ctx->num_enum++;
|
j2s_list_add(&ctx->enums, ctx->enum_obj);
|
|
ctx->enum_obj = NULL;
|
goto out;
|
}
|
|
/* Parsing enum value */
|
|
/* The first word is enum value name */
|
strip_spaces(&buf, true);
|
name = buf;
|
ptr = strchr_first(name, ' ', '=');
|
if (ptr)
|
*ptr = '\0';
|
|
/* Add enum value */
|
enum_value = malloc(sizeof(*enum_value));
|
DASSERT(enum_value, exit(-1));
|
|
enum_value->id = ctx->num_enum_value++;
|
strncpy(enum_value->name, buf,
|
sizeof(enum_value->name));
|
j2s_list_add(&ctx->enum_obj->values, enum_value);
|
|
ctx->enum_obj->num_value++;
|
|
if (ctx->enum_obj->value_id < 0)
|
ctx->enum_obj->value_id = enum_value->id;
|
|
DBG("adding enum value %s\n", enum_value->name);
|
goto out;
|
}
|
|
/* 6. Handle struct definations */
|
if (!parse_pattern(&buf, "typedef struct")) {
|
DASSERT_MSG(!ctx->depth && !ctx->struct_obj, exit(-1),
|
"failed to parse struct at %d\n", ctx->line);
|
ctx->pending_struct = true;
|
}
|
|
/* Waiting for struct defination */
|
if (ctx->depth) {
|
if (!ctx->struct_obj) {
|
if (strchr(buf, '}'))
|
ctx->depth--;
|
|
DBG("waiting for struct, skip \"%s\"\n", buf);
|
goto out;
|
}
|
} else {
|
if (!strchr(buf, '{')) {
|
DBG("waiting for '{', skip \"%s\"\n", buf);
|
goto out;
|
}
|
|
ctx->depth++;
|
|
if (!ctx->pending_struct) {
|
DBG("waiting for struct, skip \"%s\"\n", buf);
|
goto out;
|
}
|
|
/* Handle new struct */
|
DBG("found struct\n");
|
|
ctx->pending_struct = false;
|
ctx->struct_obj = malloc(sizeof(*struct_obj));
|
DASSERT(ctx->struct_obj, exit(-1));
|
|
j2s_list_init(&ctx->struct_obj->child);
|
ctx->struct_obj->child_id = -1;
|
goto out;
|
}
|
|
/* Skip union's { */
|
if (!parse_pattern(&buf, "union {")) {
|
ctx->depth++;
|
goto out;
|
}
|
|
/* union's } or end of struct defination */
|
if (!parse_pattern(&buf, "}")) {
|
DASSERT_MSG(ctx->depth > 0, exit(-1),
|
"} not paired at %d\n", ctx->line);
|
|
ctx->depth--;
|
|
/* End of struct defination */
|
if (!ctx->depth && ctx->struct_obj) {
|
/* Skip packed attribute */
|
parse_pattern(&buf, "__attribute__((packed))");
|
|
/* Parse struct name */
|
strip_spaces(&buf, true);
|
name = buf;
|
ptr = strrchr(name, ' ');
|
if (ptr)
|
name = ptr + 1;
|
|
INFO("adding struct %s\n", name);
|
|
/* Add to struct list */
|
strncpy(ctx->struct_obj->name, name,
|
sizeof(ctx->struct_obj->name));
|
ctx->struct_obj->id = ctx->num_struct++;
|
j2s_list_add(&ctx->structs, ctx->struct_obj);
|
|
/* Using the last struct as root struct */
|
ctx->root_struct = ctx->struct_obj;
|
|
ctx->struct_obj = NULL;
|
|
DASSERT_MSG(!ctx->desc,
|
free(ctx->desc); ctx->desc = NULL,
|
"unhandled desc: '%s'\n", ctx->desc);
|
}
|
goto out;
|
}
|
|
/* 7. Handle struct members */
|
|
/* Handle special bool defination */
|
if (!strcmp(buf, "_Bool")) {
|
DASSERT_MSG(!ctx->pending_bool, exit(-1),
|
"failed to parse bool at %d\n", ctx->line);
|
|
ctx->pending_bool = true;
|
goto out;
|
}
|
|
flags = 0;
|
|
/* Detect array and strip it */
|
ptr = strrchr(buf, '[');
|
if (ptr) {
|
DBG("'%s' is an array\n", buf);
|
|
*ptr = '\0';
|
flags |= J2S_FLAG_ARRAY;
|
|
/* Detect dep array */
|
ptr = strrchr(buf, '[');
|
if (ptr) {
|
DBG("\tand a dep array %s\n", buf);
|
|
*ptr = '\0';
|
flags |= J2S_FLAG_DEP_ARRAY;
|
|
DASSERT_MSG(!strrchr(buf, '['), return -1,
|
"array too dep at %d\n", ctx->line);
|
}
|
}
|
|
/* Detect pointer */
|
ptr = strrchr(buf, '*');
|
if (ptr) {
|
DBG("'%s' is a pointer\n", buf);
|
|
*ptr = ' '; /* Would be stripped later */
|
flags |= J2S_FLAG_POINTER;
|
|
ptr = strrchr(buf, '*');
|
if (ptr) {
|
DBG("\tand a dep pointer %s\n", buf);
|
|
*ptr = ' '; /* Would be stripped later */
|
flags |= J2S_FLAG_DEP_POINTER;
|
|
DASSERT_MSG(!strrchr(buf, '*'), return -1,
|
"pointer too dep at %d\n", ctx->line);
|
}
|
}
|
|
/* Extract type and name */
|
ptr = strrchr(buf, ' ');
|
if (ctx->pending_bool) {
|
DASSERT_MSG(!ptr, exit(-1),
|
"failed to parse bool at %d\n", ctx->line);
|
ctx->pending_bool = false;
|
type = "bool";
|
name = buf;
|
} else {
|
DASSERT_MSG(ptr, exit(-1),
|
"parse member error from '%s' at %d\n",
|
buf, ctx->line);
|
*ptr = '\0';
|
type = buf;
|
name = ptr + 1;
|
}
|
|
parse_pattern(&type, "const");
|
strip_spaces(&type, true);
|
strip_spaces(&name, true);
|
|
/* Detect typedef array pointer */
|
if (!parse_pattern(&type, "array_ptr_")) {
|
DBG("'%s' is an array pointer\n", name);
|
|
/* Remove member desc */
|
if (type[0] <= '9' && type[0] >= '0')
|
type = strchr(type, '_') + 1;
|
|
flags |= J2S_FLAG_ARRAY_POINTER;
|
}
|
|
/* Detect typedef array */
|
if (!parse_pattern(&type, "array_")) {
|
DBG("'%s' is an array\n", name);
|
|
DASSERT_MSG(!(flags & J2S_FLAG_DEP_ARRAY), return -1,
|
"array too dep at %d\n", ctx->line);
|
DASSERT_MSG(!(flags & J2S_FLAG_DEP_POINTER), return -1,
|
"pointer too dep at %d\n", ctx->line);
|
|
/* Remove member desc */
|
if (type[0] <= '9' && type[0] >= '0')
|
type = strchr(type, '_') + 1;
|
|
if (flags & J2S_FLAG_ARRAY) {
|
flags |= J2S_FLAG_DEP_ARRAY;
|
} else if (flags & J2S_FLAG_POINTER) {
|
flags |= J2S_FLAG_ARRAY_POINTER;
|
|
/* Set it later */
|
flags &= ~J2S_FLAG_POINTER;
|
} else {
|
flags |= J2S_FLAG_ARRAY;
|
}
|
}
|
|
/* Check for dep type limits */
|
if (flags & J2S_FLAG_ARRAY_POINTER) {
|
DASSERT_MSG(!(flags & J2S_FLAG_ARRAY), return -1,
|
"array too dep at %d\n", ctx->line);
|
DASSERT_MSG(!(flags & J2S_FLAG_POINTER), return -1,
|
"pointer too dep at %d\n", ctx->line);
|
DASSERT_MSG(!(flags & J2S_FLAG_DEP_ARRAY), return -1,
|
"array too dep at %d\n", ctx->line);
|
DASSERT_MSG(!(flags & J2S_FLAG_DEP_POINTER), return -1,
|
"pointer too dep at %d\n", ctx->line);
|
|
flags |= J2S_FLAG_ARRAY;
|
flags |= J2S_FLAG_POINTER;
|
} else if (flags & J2S_FLAG_DEP_ARRAY) {
|
DASSERT_MSG(!(flags & J2S_FLAG_POINTER), return -1,
|
"array too dep at %d\n", ctx->line);
|
} else if (flags & J2S_FLAG_DEP_POINTER) {
|
DASSERT_MSG(!(flags & J2S_FLAG_ARRAY), return -1,
|
"pointer too dep at %d\n", ctx->line);
|
}
|
|
/* Prepare member obj */
|
obj = calloc(1, sizeof(*obj));
|
DASSERT(obj, exit(-1));
|
|
obj->id = ctx->num_obj++;
|
obj->line = ctx->line;
|
|
strncpy(obj->type_name, type, sizeof(obj->type_name));
|
strncpy(obj->name, name, sizeof(obj->name));
|
obj->flags = flags;
|
obj->desc = ctx->desc;
|
ctx->desc = NULL;
|
|
/* Parse obj type and check type limits */
|
obj->type = j2s_parse_type(type, flags);
|
|
static bool type_warn_once = false;
|
if (!type_warn_once &&
|
(obj->type == J2S_TYPE_INT_64 ||
|
obj->type == J2S_TYPE_UINT_64)) {
|
type_warn_once = true;
|
|
WARN("64 bit type might have precision issue!\n");
|
}
|
|
if (obj->type != J2S_TYPE_STRING) {
|
DASSERT_MSG(!(flags & J2S_FLAG_DEP_POINTER), return -1,
|
"dep pointer only for string at %d\n", ctx->line);
|
|
if (flags & J2S_FLAG_ARRAY &&
|
flags & J2S_FLAG_POINTER)
|
DASSERT_MSG(flags & J2S_FLAG_ARRAY_POINTER,
|
return -1,
|
"pointer array only for string at %d\n",
|
ctx->line);
|
}
|
|
obj->parent = ctx->struct_obj;
|
|
j2s_list_add(&ctx->objs, obj);
|
|
/* Link with prev child */
|
if (ctx->struct_obj->child_id < 0) {
|
ctx->struct_obj->child_id = obj->id;
|
} else {
|
j2s_obj *tmp_obj =
|
((j2s_list *)ctx->struct_obj->child.prev)->data;
|
tmp_obj->next = obj;
|
}
|
|
j2s_list_add(&ctx->struct_obj->child, obj);
|
|
if (obj->desc) {
|
DBG("adding member %s with desc: %s\n",
|
obj->name, obj->desc);
|
} else {
|
DBG("adding member %s\n", obj->name);
|
}
|
|
out:
|
if (pending[0])
|
return j2s_parse(ctx, pending);
|
|
return 0;
|
}
|
|
/* Dump parsed header */
|
static inline
|
void j2s_dump(j2s_ctx *ctx) {
|
j2s_list *entry, *next;
|
j2s_enum_value *enum_value;
|
j2s_struct *struct_obj;
|
j2s_enum *enum_obj;
|
j2s_obj *obj;
|
int magic;
|
|
srand(time(NULL));
|
magic = rand();
|
|
printf("#include <stdint.h>\n");
|
printf("#include \"j2s.h\"\n\n");
|
|
printf("#define J2S_MAGIC %d\n", magic);
|
printf("#define J2S_NUM_OBJ %d\n", ctx->num_obj);
|
printf("#define J2S_NUM_STRUCT %d\n", ctx->num_struct);
|
printf("#define J2S_NUM_ENUM %d\n", ctx->num_enum);
|
printf("#define J2S_NUM_ENUM_VALUE %d\n\n", ctx->num_enum_value);
|
|
printf("static void _j2s_init(j2s_ctx *ctx) {\n");
|
printf("\tj2s_obj *obj;\n\n");
|
|
printf("\tstatic j2s_obj objs[J2S_NUM_OBJ];\n");
|
printf("\tstatic j2s_struct structs[J2S_NUM_STRUCT];\n");
|
printf("\tstatic j2s_enum enums[J2S_NUM_ENUM];\n");
|
printf("\tstatic j2s_enum_value enum_values[J2S_NUM_ENUM_VALUE];\n\n");
|
|
printf("\tctx->magic = J2S_MAGIC;\n");
|
printf("\tctx->priv = NULL;\n");
|
|
printf("\tctx->objs = (j2s_obj *)&objs;\n");
|
printf("\tctx->structs = (j2s_struct *)&structs;\n");
|
printf("\tctx->enums = (j2s_enum *)&enums;\n");
|
printf("\tctx->enum_values = (j2s_enum_value *)&enum_values;\n\n");
|
|
printf("\tctx->num_obj = J2S_NUM_OBJ;\n");
|
printf("\tctx->num_struct = J2S_NUM_STRUCT;\n");
|
printf("\tctx->num_enum = J2S_NUM_ENUM;\n");
|
printf("\tctx->num_enum_value = J2S_NUM_ENUM_VALUE;\n\n");
|
|
printf("\n#ifndef J2S_ENABLE_DESC\n");
|
printf("\tctx->num_desc = 0;\n");
|
printf("#else\n");
|
printf("\tstatic const char *descs[J2S_NUM_OBJ];\n");
|
printf("\tctx->descs = (const char **)descs;\n");
|
printf("\tctx->num_desc = J2S_NUM_OBJ;\n");
|
printf("#endif\n\n");
|
|
struct_obj = ctx->root_struct;
|
INFO("root struct: %s\n", struct_obj->name);
|
|
printf("\tctx->root_index = %d;\n\n", struct_obj->id);
|
|
/* Dump obj list */
|
j2s_list_walk_safe(&ctx->objs, entry, next, obj) {
|
printf("\tobj = &ctx->objs[%d];\n", obj->id);
|
|
printf("\tstrcpy(obj->name, \"%s\");\n", obj->name);
|
printf("\tobj->type = %s;\n", j2s_types[obj->type]);
|
|
#define DUMP_FLAG(flags, FLAG) \
|
if (flags & FLAG) printf("| "#FLAG)
|
|
printf("\tobj->flags = 0 ");
|
DUMP_FLAG(obj->flags, J2S_FLAG_ARRAY);
|
DUMP_FLAG(obj->flags, J2S_FLAG_POINTER);
|
DUMP_FLAG(obj->flags, J2S_FLAG_DEP_ARRAY);
|
DUMP_FLAG(obj->flags, J2S_FLAG_DEP_POINTER);
|
DUMP_FLAG(obj->flags, J2S_FLAG_ARRAY_POINTER);
|
printf(";\n");
|
|
#define MEMBER_DEP_0 "((%s*)0)->%s"
|
#define MEMBER_DEP_1 MEMBER_DEP_0 "[0]"
|
#define MEMBER_DEP_2 MEMBER_DEP_1 "[0]"
|
|
printf("\tobj->offset = (uintptr_t)&" MEMBER_DEP_0 ";\n",
|
obj->parent->name, obj->name);
|
|
if (obj->flags & (J2S_FLAG_ARRAY | J2S_FLAG_POINTER)) {
|
printf("\tobj->elem_size = sizeof(" MEMBER_DEP_1 ");\n",
|
obj->parent->name, obj->name);
|
|
} else {
|
printf("\tobj->elem_size = sizeof(" MEMBER_DEP_0 ");\n",
|
obj->parent->name, obj->name);
|
}
|
|
if ((obj->flags & J2S_FLAG_ARRAY &&
|
obj->flags & J2S_FLAG_POINTER) ||
|
obj->flags & J2S_FLAG_DEP_ARRAY ||
|
obj->flags & J2S_FLAG_DEP_POINTER) {
|
printf("\tobj->base_elem_size = "
|
"sizeof(" MEMBER_DEP_2 ");\n",
|
obj->parent->name, obj->name);
|
} else {
|
printf("\tobj->base_elem_size = obj->elem_size;\n");
|
}
|
|
if (J2S_IS_ARRAY(obj)) {
|
printf("\tobj->num_elem = (sizeof(" MEMBER_DEP_0 ") / "
|
"obj->elem_size);\n",
|
obj->parent->name, obj->name);
|
} else {
|
printf("\tobj->num_elem = 1;\n");
|
}
|
|
/* Dynamic array needs a "<name>_len" sibling */
|
if ((obj->type != J2S_TYPE_STRING &&
|
obj->flags & J2S_FLAG_POINTER) ||
|
(obj->type == J2S_TYPE_STRING &&
|
(obj->flags & J2S_FLAG_DEP_POINTER ||
|
obj->flags & J2S_FLAG_ARRAY_POINTER))) {
|
j2s_obj *len_obj;
|
char len_name[MAX_NAME + 5];
|
snprintf(len_name, MAX_NAME + 5, "%s_len", obj->name);
|
|
j2s_list_find(&obj->parent->child, entry,
|
len_obj, len_name);
|
|
DASSERT_MSG(len_obj, exit(-1),
|
"missing %s\n", len_name);
|
DASSERT_MSG(len_obj->type <= J2S_TYPE_UINT_64 &&
|
!len_obj->flags,
|
exit(-1), "%s should be int\n", len_name);
|
|
obj->len_obj = len_obj;
|
}
|
|
printf("\tobj->len_index = %d;\n",
|
obj->len_obj ? ((j2s_obj *)obj->len_obj)->id : -1);
|
printf("\tobj->next_index = %d;\n",
|
obj->next ? ((j2s_obj *)obj->next)->id : -1);
|
printf("\tobj->struct_index = %d;\n",
|
obj->struct_obj ? obj->struct_obj->id : -1);
|
printf("\tobj->enum_index = %d;\n",
|
obj->enum_obj ? obj->enum_obj->id : -1);
|
|
if (obj->desc) {
|
char *ptr;
|
|
while (ptr = strchr(obj->desc, '"'))
|
*ptr = '\'';
|
|
/* Check default value for enum in desc */
|
if (obj->enum_obj) {
|
ptr = strstr(obj->desc, "default=");
|
if (ptr) {
|
char buf[MAX_LINE];
|
char *name = buf;
|
|
strcpy(name, ptr + strlen("default="));
|
ptr = strchr_first(name, ' ', ',');
|
if (ptr)
|
*ptr = '\0';
|
|
strip_spaces(&name, true);
|
|
j2s_list_find(&obj->enum_obj->values,
|
entry, enum_value, name);
|
|
DASSERT_MSG(enum_value, exit(-1),
|
"invalid default enum "
|
"%s for %s\n",
|
name, obj->name);
|
}
|
}
|
|
printf("#ifdef J2S_ENABLE_DESC\n");
|
printf("\tctx->descs[%d] = \"%s\";\n",
|
obj->id, obj->desc);
|
printf("#endif\n");
|
}
|
|
printf("\n");
|
}
|
|
/* Dump struct list */
|
j2s_list_walk_safe(&ctx->structs, entry, next, struct_obj) {
|
printf("\tstrcpy(ctx->structs[%d].name, \"%s\");\n",
|
struct_obj->id, struct_obj->name);
|
printf("\tctx->structs[%d].child_index = %d;\n",
|
struct_obj->id, struct_obj->child_id);
|
}
|
|
/* Dump enum list */
|
j2s_list_walk_safe(&ctx->enums, entry, next, enum_obj) {
|
printf("\n\tstrcpy(ctx->enums[%d].name, \"%s\");\n",
|
enum_obj->id, enum_obj->name);
|
printf("\tctx->enums[%d].value_index = %d;\n",
|
enum_obj->id, enum_obj->value_id);
|
printf("\tctx->enums[%d].num_value = %d;\n\n",
|
enum_obj->id, enum_obj->num_value);
|
|
j2s_list_walk(&enum_obj->values, entry, enum_value) {
|
printf("\tstrcpy(ctx->enum_values[%d].name, \"%s\");\n",
|
enum_value->id, enum_value->name);
|
printf("\tctx->enum_values[%d].value = %s;\n",
|
enum_value->id, enum_value->name);
|
}
|
}
|
|
printf("}\n");
|
}
|
|
int main(int argc, char** argv) {
|
j2s_list *entry, *next;
|
j2s_struct *struct_obj;
|
j2s_enum *enum_obj;
|
j2s_obj *obj;
|
j2s_ctx ctx = {0};
|
char buf[MAX_LINE];
|
|
j2s_list_init(&ctx.objs);
|
j2s_list_init(&ctx.structs);
|
j2s_list_init(&ctx.enums);
|
|
DASSERT_MSG(argc > 1, return -1,
|
"usage: %s <input header> [root struct]\n", argv[0]);
|
|
INFO("start parsing %s\n", argv[1]);
|
ctx.fp = fopen(argv[1],"r");
|
DASSERT_MSG(ctx.fp, return -1, "failed to open %s\n", argv[1]);
|
|
while (fgets(buf, MAX_LINE, ctx.fp)) {
|
ctx.line++;
|
j2s_parse(&ctx, buf);
|
}
|
|
INFO("finished parsing %s\n", argv[1]);
|
fclose(ctx.fp);
|
|
/* Set objs' struct/enum obj and check unsupported type */
|
j2s_list_walk_safe(&ctx.objs, entry, next, obj) {
|
if (obj->type != J2S_TYPE_STRUCT)
|
continue;
|
|
j2s_list_find(&ctx.structs, entry, struct_obj, obj->type_name);
|
|
if (struct_obj) {
|
obj->struct_obj = struct_obj;
|
} else {
|
j2s_list_find(&ctx.enums, entry,
|
enum_obj, obj->type_name);
|
|
DASSERT_MSG(enum_obj, exit(-1),
|
"unknown type '%s' at %d\n",
|
obj->type_name, obj->line);
|
|
obj->type = J2S_TYPE_INT_32;
|
obj->enum_obj = enum_obj;
|
}
|
}
|
|
/* Handle specified root struct */
|
if (argc > 2) {
|
INFO("specified root struct: %s\n", argv[2]);
|
|
j2s_list_find(&ctx.structs, entry, struct_obj, argv[2]);
|
ctx.root_struct = struct_obj;
|
}
|
|
DASSERT_MSG(ctx.root_struct, exit(-1), "no root struct!\n");
|
|
/* Dump parsed header */
|
j2s_dump(&ctx);
|
|
/* Free lists */
|
j2s_list_walk_safe(&ctx.structs, entry, next, struct_obj)
|
j2s_list_free(&struct_obj->child, entry, false);
|
j2s_list_free(&ctx.structs, entry, true);
|
|
j2s_list_walk(&ctx.objs, entry, obj)
|
free(obj->desc);
|
j2s_list_free(&ctx.objs, entry, true);
|
|
j2s_list_walk_safe(&ctx.enums, entry, next, enum_obj)
|
j2s_list_free(&enum_obj->values, entry, true);
|
j2s_list_free(&ctx.enums, entry, true);
|
|
return 0;
|
}
|
