| /* |
| * upb - a minimalist implementation of protocol buffers. |
| * |
| * upbc is the upb compiler. This is some deep code that I wish could be |
| * easier to understand, but by its nature it is doing some very "meta" |
| * kinds of things. |
| * |
| * Copyright (c) 2009 Joshua Haberman. See LICENSE for details. |
| */ |
| |
| #include <ctype.h> |
| #include <inttypes.h> |
| #include <stdarg.h> |
| #include <stdlib.h> |
| #include "descriptor.h" |
| #include "upb_data.h" |
| #include "upb_def.h" |
| #include "upb_text.h" |
| |
| /* These are in-place string transformations that do not change the length of |
| * the string (and thus never need to re-allocate). */ |
| |
| // Convert to C identifier: foo.bar.Baz -> foo_bar_Baz. |
| static void to_cident(upb_strptr str) |
| { |
| upb_strlen_t len = upb_strlen(str); |
| char *buf = upb_string_getrwbuf(str, len); |
| for(uint32_t i = 0; i < len; i++) |
| if(buf[i] == '.' || buf[i] == '/') |
| buf[i] = '_'; |
| } |
| |
| // Convert to C proprocessor identifier: foo.bar.Baz -> FOO_BAR_BAZ. |
| static void to_preproc(upb_strptr str) |
| { |
| to_cident(str); |
| upb_strlen_t len = upb_strlen(str); |
| char *buf = upb_string_getrwbuf(str, len); |
| for(uint32_t i = 0; i < len; i++) |
| buf[i] = toupper(buf[i]); |
| } |
| |
| static int my_memrchr(const char *data, char c, size_t len) |
| { |
| int off = len-1; |
| while(off > 0 && data[off] != c) --off; |
| return off; |
| } |
| |
| void *strtable_to_array(upb_strtable *t, int *size) |
| { |
| *size = t->t.count; |
| void **array = malloc(*size * sizeof(void*)); |
| upb_strtable_entry *e; |
| int i = 0; |
| for(e = upb_strtable_begin(t); e && i < *size; e = upb_strtable_next(t, e)) |
| array[i++] = e; |
| assert(i == *size && e == NULL); |
| return array; |
| } |
| |
| /* The _const.h file defines the constants (enums) defined in the .proto |
| * file. */ |
| static void write_const_h(upb_def *defs[], int num_entries, char *outfile_name, |
| FILE *stream) |
| { |
| /* Header file prologue. */ |
| upb_strptr include_guard_name = upb_strdupc(outfile_name); |
| to_preproc(include_guard_name); |
| /* A bit cheesy, but will do the job. */ |
| upb_strlen_t len = upb_strlen(include_guard_name); |
| char *buf = upb_string_getrwbuf(include_guard_name, len); |
| buf[len-1] = 'C'; |
| |
| fputs("/* This file was generated by upbc (the upb compiler). " |
| "Do not edit. */\n\n", stream), |
| fprintf(stream, "#ifndef " UPB_STRFMT "\n", UPB_STRARG(include_guard_name)); |
| fprintf(stream, "#define " UPB_STRFMT "\n\n", UPB_STRARG(include_guard_name)); |
| fputs("#ifdef __cplusplus\n", stream); |
| fputs("extern \"C\" {\n", stream); |
| fputs("#endif\n\n", stream); |
| |
| /* Enums. */ |
| fprintf(stream, "/* Enums. */\n\n"); |
| for(int i = 0; i < num_entries; i++) { /* Foreach enum */ |
| if(defs[i]->type != UPB_DEF_ENUM) continue; |
| upb_enumdef *enumdef = upb_downcast_enumdef(defs[i]); |
| upb_strptr enum_name = upb_strdup(UPB_UPCAST(enumdef)->fqname); |
| upb_strptr enum_val_prefix = upb_strdup(enum_name); |
| to_cident(enum_name); |
| |
| const char *data = upb_string_getrobuf(enum_val_prefix); |
| upb_strlen_t len = upb_strlen(enum_val_prefix); |
| upb_strlen_t lastsep = my_memrchr(data, UPB_SYMBOL_SEPARATOR, len); |
| upb_string_resize(enum_val_prefix, lastsep + 1); |
| to_preproc(enum_val_prefix); |
| |
| fprintf(stream, "typedef enum " UPB_STRFMT " {\n", UPB_STRARG(enum_name)); |
| upb_enum_iter iter; |
| bool first = true; |
| /* Foreach enum value. */ |
| for(upb_enum_begin(&iter, enumdef); !upb_enum_done(&iter); upb_enum_next(&iter)) { |
| upb_strptr value_name = upb_strdup(iter.name); |
| to_preproc(value_name); |
| /* " GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_UINT32 = 13," */ |
| if (!first) fputs(",\n", stream); |
| first = false; |
| fprintf(stream, " " UPB_STRFMT UPB_STRFMT " = %" PRIu32, |
| UPB_STRARG(enum_val_prefix), UPB_STRARG(value_name), iter.val); |
| upb_string_unref(value_name); |
| } |
| fprintf(stream, "\n} " UPB_STRFMT ";\n\n", UPB_STRARG(enum_name)); |
| upb_string_unref(enum_name); |
| upb_string_unref(enum_val_prefix); |
| } |
| |
| /* Epilogue. */ |
| fputs("#ifdef __cplusplus\n", stream); |
| fputs("} /* extern \"C\" */\n", stream); |
| fputs("#endif\n\n", stream); |
| fprintf(stream, "#endif /* " UPB_STRFMT " */\n", UPB_STRARG(include_guard_name)); |
| upb_string_unref(include_guard_name); |
| } |
| |
| /* The .h file defines structs for the types defined in the .proto file. It |
| * also defines constants for the enum values. |
| * |
| * Assumes that d has been validated. */ |
| static void write_h(upb_def *defs[], int num_defs, char *outfile_name, |
| char *descriptor_cident, FILE *stream) |
| { |
| /* Header file prologue. */ |
| upb_strptr include_guard_name = upb_strdupc(outfile_name); |
| to_preproc(include_guard_name); |
| fputs("/* This file was generated by upbc (the upb compiler). " |
| "Do not edit. */\n\n", stream), |
| fprintf(stream, "#ifndef " UPB_STRFMT "\n", UPB_STRARG(include_guard_name)); |
| fprintf(stream, "#define " UPB_STRFMT "\n\n", UPB_STRARG(include_guard_name)); |
| fputs("#include <upb_data.h>\n\n", stream); |
| fputs("#ifdef __cplusplus\n", stream); |
| fputs("extern \"C\" {\n", stream); |
| fputs("#endif\n\n", stream); |
| |
| if(descriptor_cident) { |
| fputs("struct google_protobuf_FileDescriptorSet;\n", stream); |
| fprintf(stream, "extern struct google_protobuf_FileDescriptorSet *%s;\n\n", |
| descriptor_cident); |
| } |
| |
| /* Forward declarations. */ |
| fputs("/* Forward declarations of all message types.\n", stream); |
| fputs(" * So they can refer to each other in ", stream); |
| fputs("possibly-recursive ways. */\n\n", stream); |
| |
| for(int i = 0; i < num_defs; i++) { /* Foreach message */ |
| upb_msgdef *m = upb_dyncast_msgdef(defs[i]); |
| if(!m) continue; |
| upb_strptr msg_name = upb_strdup(UPB_UPCAST(m)->fqname); |
| to_cident(msg_name); |
| fprintf(stream, "struct " UPB_STRFMT ";\n", UPB_STRARG(msg_name)); |
| fprintf(stream, "typedef struct " UPB_STRFMT "\n " UPB_STRFMT ";\n", |
| UPB_STRARG(msg_name), UPB_STRARG(msg_name)); |
| fprintf(stream, "UPB_DEFINE_MSG_ARRAY(" UPB_STRFMT ")\n\n", |
| UPB_STRARG(msg_name)); |
| upb_string_unref(msg_name); |
| } |
| |
| /* Message Declarations. */ |
| fputs("/* The message definitions themselves. */\n\n", stream); |
| for(int i = 0; i < num_defs; i++) { /* Foreach message */ |
| upb_msgdef *m = upb_dyncast_msgdef(defs[i]); |
| if(!m) continue; |
| upb_strptr msg_name = upb_strdup(UPB_UPCAST(m)->fqname); |
| to_cident(msg_name); |
| fprintf(stream, "struct " UPB_STRFMT " {\n", UPB_STRARG(msg_name)); |
| fputs(" upb_data base;\n", stream); |
| fputs(" union {\n", stream); |
| fprintf(stream, " uint8_t bytes[%" PRIu32 "];\n", m->set_flags_bytes); |
| fputs(" struct {\n", stream); |
| for(upb_field_count_t j = 0; j < m->num_fields; j++) { |
| static char* labels[] = {"", "optional", "required", "repeated"}; |
| upb_fielddef *f = &m->fields[j]; |
| fprintf(stream, " bool " UPB_STRFMT ":1; /* = %" PRIu32 ", %s. */\n", |
| UPB_STRARG(f->name), f->number, labels[f->label]); |
| } |
| fputs(" } has;\n", stream); |
| fputs(" } set_flags;\n", stream); |
| for(upb_field_count_t j = 0; j < m->num_fields; j++) { |
| upb_fielddef *f = &m->fields[j]; |
| if(upb_issubmsg(f)) { |
| upb_strptr type_name = upb_strdup(f->def->fqname); |
| to_cident(type_name); |
| if(f->label == UPB_LABEL(REPEATED)) { |
| fprintf(stream, " UPB_MSG_ARRAYPTR(" UPB_STRFMT ") " UPB_STRFMT ";\n", |
| UPB_STRARG(type_name), UPB_STRARG(f->name)); |
| } else { |
| fprintf(stream, " " UPB_STRFMT "* " UPB_STRFMT ";\n", |
| UPB_STRARG(type_name), UPB_STRARG(f->name)); |
| } |
| upb_string_unref(type_name); |
| } else if(f->label == UPB_LABEL(REPEATED)) { |
| fprintf(stream, " upb_arrayptr " UPB_STRFMT ";\n", UPB_STRARG(f->name)); |
| } else { |
| static char* c_types[] = { |
| "", "double", "float", "int64_t", "uint64_t", "int32_t", "uint64_t", |
| "uint32_t", "bool", "upb_strptr", "", "", |
| "upb_strptr", "uint32_t", "int32_t", "int32_t", "int64_t", |
| "int32_t", "int64_t" |
| }; |
| fprintf(stream, " %s " UPB_STRFMT ";\n", |
| c_types[f->type], UPB_STRARG(f->name)); |
| } |
| } |
| fputs("};\n\n", stream); |
| upb_string_unref(msg_name); |
| } |
| |
| /* Epilogue. */ |
| fputs("#ifdef __cplusplus\n", stream); |
| fputs("} /* extern \"C\" */\n", stream); |
| fputs("#endif\n\n", stream); |
| fprintf(stream, "#endif /* " UPB_STRFMT " */\n", UPB_STRARG(include_guard_name)); |
| upb_string_unref(include_guard_name); |
| } |
| |
| /* Format of table entries that we use when analyzing data structures for |
| * write_messages_c. */ |
| typedef struct { |
| upb_strtable_entry e; |
| int offset; |
| int num; |
| } strtable_entry; |
| |
| typedef struct { |
| upb_strtable_entry e; |
| upb_fielddef *field; |
| upb_strptr cident; /* Type name converted with to_cident(). */ |
| /* A list of all values of this type, in an established order. */ |
| upb_value *values; |
| int values_size, values_len; |
| struct array { |
| int offset; |
| int len; |
| upb_arrayptr ptr; /* So we can find it later. */ |
| } *arrays; |
| int arrays_size, arrays_len; |
| } typetable_entry; |
| |
| typedef struct { |
| upb_inttable_entry e; |
| void *msg; |
| int num; /* Unique offset into the list of all msgs of this type. */ |
| } msgtable_entry; |
| |
| int compare_entries(const void *_e1, const void *_e2) |
| { |
| strtable_entry *const*e1 = _e1, *const*e2 = _e2; |
| return upb_strcmp((*e1)->e.key, (*e2)->e.key); |
| } |
| |
| /* Mutually recursive functions to recurse over a set of possibly nested |
| * messages and extract all the strings. |
| * |
| * TODO: make these use a generic msg visitor. */ |
| |
| static void add_strings_from_msg(upb_msg *msg, upb_msgdef *md, upb_strtable *t); |
| |
| static void add_strings_from_value(upb_value p, upb_fielddef *f, |
| upb_strtable *t) |
| { |
| if(upb_isstringtype(f->type)) { |
| strtable_entry e = {.e = {.key = p.str}}; |
| if(upb_strtable_lookup(t, e.e.key) == NULL) |
| upb_strtable_insert(t, &e.e); |
| } else if(upb_issubmsg(f)) { |
| add_strings_from_msg(p.msg, upb_downcast_msgdef(f->def), t); |
| } |
| } |
| |
| static void add_strings_from_msg(upb_msg *msg, upb_msgdef *md, upb_strtable *t) |
| { |
| for(upb_field_count_t i = 0; i < md->num_fields; i++) { |
| upb_fielddef *f = &md->fields[i]; |
| if(!upb_msg_has(msg, f)) continue; |
| upb_value p = upb_msg_get(msg, f); |
| if(upb_isarray(f)) { |
| upb_arrayptr arr = p.arr; |
| for(uint32_t j = 0; j < upb_array_len(arr); j++) |
| add_strings_from_value(upb_array_get(arr, f, j), f, t); |
| } else { |
| add_strings_from_value(p, f, t); |
| } |
| } |
| } |
| |
| /* Mutually recursive functions to recurse over a set of possibly nested |
| * messages and extract all the messages (keyed by type). |
| * |
| * TODO: make these use a generic msg visitor. */ |
| |
| typetable_entry *get_or_insert_typeentry(upb_strtable *t, upb_fielddef *f) |
| { |
| upb_strptr type_name = upb_issubmsg(f) ? |
| upb_strdup(f->def->fqname) : upb_strdupc(upb_types[f->type].ctype); |
| typetable_entry *type_e = upb_strtable_lookup(t, type_name); |
| if(type_e == NULL) { |
| upb_strptr cident = upb_strdup(type_name); |
| to_cident(cident); |
| typetable_entry new_type_e = { |
| .e = {.key = type_name}, .field = f, .cident = cident, |
| .values = NULL, .values_size = 0, .values_len = 0, |
| .arrays = NULL, .arrays_size = 0, .arrays_len = 0 |
| }; |
| assert(upb_strtable_lookup(t, type_name) == NULL); |
| assert(upb_strtable_lookup(t, new_type_e.e.key) == NULL); |
| upb_strtable_insert(t, &new_type_e.e); |
| type_e = upb_strtable_lookup(t, type_name); |
| assert(type_e); |
| } |
| upb_string_unref(type_name); |
| return type_e; |
| } |
| |
| static void add_value(upb_value v, upb_fielddef *f, upb_strtable *t) |
| { |
| typetable_entry *type_e = get_or_insert_typeentry(t, f); |
| if(type_e->values_len == type_e->values_size) { |
| type_e->values_size = UPB_MAX(type_e->values_size * 2, 4); |
| type_e->values = realloc(type_e->values, sizeof(*type_e->values) * type_e->values_size); |
| } |
| type_e->values[type_e->values_len++] = v; |
| } |
| |
| static void add_submsgs(upb_msg *msg, upb_msgdef *md, upb_strtable *t) |
| { |
| for(upb_field_count_t i = 0; i < md->num_fields; i++) { |
| upb_fielddef *f = &md->fields[i]; |
| if(!upb_msg_has(msg, f)) continue; |
| upb_value v = upb_msg_get(msg, f); |
| if(upb_isarray(f)) { |
| if(upb_isstring(f)) continue; /* Handled by a different code-path. */ |
| upb_arrayptr arr = v.arr; |
| |
| /* Add to our list of arrays for this type. */ |
| typetable_entry *arr_type_e = get_or_insert_typeentry(t, f); |
| if(arr_type_e->arrays_len == arr_type_e->arrays_size) { |
| arr_type_e->arrays_size = UPB_MAX(arr_type_e->arrays_size * 2, 4); |
| arr_type_e->arrays = realloc(arr_type_e->arrays, |
| sizeof(*arr_type_e->arrays)*arr_type_e->arrays_size); |
| } |
| arr_type_e->arrays[arr_type_e->arrays_len].offset = arr_type_e->values_len; |
| arr_type_e->arrays[arr_type_e->arrays_len].len = upb_array_len(arr); |
| arr_type_e->arrays[arr_type_e->arrays_len].ptr = v.arr; |
| arr_type_e->arrays_len++; |
| |
| /* Add the individual values in the array. */ |
| for(uint32_t j = 0; j < upb_array_len(arr); j++) |
| add_value(upb_array_get(arr, f, j), f, t); |
| |
| /* Add submsgs. We must do this separately so that the msgs in this |
| * array are contiguous (and don't have submsgs of the same type |
| * interleaved). */ |
| for(uint32_t j = 0; j < upb_array_len(arr); j++) |
| add_submsgs(upb_array_get(arr, f, j).msg, upb_downcast_msgdef(f->def), t); |
| } else { |
| if(!upb_issubmsg(f)) continue; |
| add_value(v, f, t); |
| add_submsgs(v.msg, upb_downcast_msgdef(f->def), t); |
| } |
| } |
| } |
| |
| /* write_messages_c emits a .c file that contains the data of a protobuf, |
| * serialized as C structures. */ |
| static void write_message_c(upb_msg *msg, upb_msgdef *md, |
| char *cident, char *hfile_name, |
| int argc, char *argv[], char *infile_name, |
| FILE *stream) |
| { |
| fputs( |
| "/*\n" |
| " * This file is a data dump of a protocol buffer into a C structure.\n" |
| " * It was created by the upb compiler (upbc) with the following\n" |
| " * command-line:\n" |
| " *\n", stream); |
| fputs(" * ", stream); |
| for(int i = 0; i < argc; i++) { |
| fputs(argv[i], stream); |
| if(i < argc-1) fputs(" ", stream); |
| } |
| fputs("\n *\n", stream); |
| fprintf(stream, " * This file is a dump of '%s'.\n", infile_name); |
| fputs( |
| " * It contains exactly the same data, but in a C structure form\n" |
| " * instead of a serialized protobuf. This file contains no code,\n" |
| " * only data.\n" |
| " *\n" |
| " * This file was auto-generated. Do not edit. */\n\n", stream); |
| |
| fprintf(stream, "#include \"%s\"\n\n", hfile_name); |
| |
| /* Gather all strings into a giant string. Use a hash to prevent adding the |
| * same string more than once. */ |
| upb_strtable strings; |
| upb_strtable_init(&strings, 16, sizeof(strtable_entry)); |
| add_strings_from_msg(msg, md, &strings); |
| |
| int size; |
| strtable_entry **str_entries = strtable_to_array(&strings, &size); |
| /* Sort for nice size and reproduceability. */ |
| qsort(str_entries, size, sizeof(void*), compare_entries); |
| |
| /* Emit strings. */ |
| fputs("static char strdata[] =\n \"", stream); |
| int col = 2; |
| int offset = 0; |
| for(int i = 0; i < size; i++) { |
| upb_strptr s = str_entries[i]->e.key; |
| str_entries[i]->offset = offset; |
| str_entries[i]->num = i; |
| const char *buf = upb_string_getrobuf(s); |
| for(uint32_t j = 0; j < upb_strlen(s); j++) { |
| if(++col == 80) { |
| fputs("\"\n \"", stream); |
| col = 3; |
| } |
| fputc(buf[j], stream); |
| } |
| offset += upb_strlen(s); |
| } |
| fputs("\";\n\n", stream); |
| |
| fputs("static upb_static_string strings[] = {\n", stream); |
| for(int i = 0; i < size; i++) { |
| strtable_entry *e = str_entries[i]; |
| fprintf(stream, " UPB_STATIC_STRING_INIT_LEN(&strdata[%d], %d),\n", e->offset, upb_strlen(e->e.key)); |
| } |
| fputs("};\n\n", stream); |
| free(str_entries); |
| |
| /* Gather a list of types for which we are emitting data, and give each msg |
| * a unique number within its type. */ |
| upb_strtable types; |
| upb_strtable_init(&types, 16, sizeof(typetable_entry)); |
| upb_value val = {.msg = msg}; |
| /* A fake field to get the recursion going. */ |
| upb_fielddef fake_field = { |
| .type = UPB_TYPE(MESSAGE), |
| .def = UPB_UPCAST(md), |
| }; |
| add_value(val, &fake_field, &types); |
| add_submsgs(msg, md, &types); |
| |
| /* Emit foward declarations for all msgs of all types, and define arrays. */ |
| fprintf(stream, "/* Forward declarations of messages, and array decls. */\n"); |
| typetable_entry *e = upb_strtable_begin(&types); |
| for(; e; e = upb_strtable_next(&types, &e->e)) { |
| fprintf(stream, "static " UPB_STRFMT " " UPB_STRFMT "_values[%d];\n\n", |
| UPB_STRARG(e->cident), UPB_STRARG(e->cident), e->values_len); |
| if(e->arrays_len > 0) { |
| fprintf(stream, "static " UPB_STRFMT " *" UPB_STRFMT "_array_elems[] = {\n", |
| UPB_STRARG(e->cident), UPB_STRARG(e->cident)); |
| for(int i = 0; i < e->arrays_len; i++) { |
| struct array *arr = &e->arrays[i]; |
| for(int j = 0; j < arr->len; j++) |
| fprintf(stream, " &" UPB_STRFMT "_values[%d],\n", UPB_STRARG(e->cident), arr->offset + j); |
| } |
| fprintf(stream, "};\n"); |
| |
| int cum_offset = 0; |
| fprintf(stream, "static upb_static_array " UPB_STRFMT "_arrays[%d] = {\n", |
| UPB_STRARG(e->cident), e->arrays_len); |
| for(int i = 0; i < e->arrays_len; i++) { |
| struct array *arr = &e->arrays[i]; |
| fprintf(stream, " UPB_STATIC_ARRAY_INIT(&" UPB_STRFMT "_array_elems[%d], %d),\n", |
| UPB_STRARG(e->cident), cum_offset, arr->len); |
| cum_offset += arr->len; |
| } |
| fprintf(stream, "};\n"); |
| } |
| } |
| |
| /* Emit definitions. */ |
| for(e = upb_strtable_begin(&types); e; e = upb_strtable_next(&types, &e->e)) { |
| fprintf(stream, "static " UPB_STRFMT " " UPB_STRFMT "_values[%d] = {\n\n", |
| UPB_STRARG(e->cident), UPB_STRARG(e->cident), e->values_len); |
| for(int i = 0; i < e->values_len; i++) { |
| upb_value val = e->values[i]; |
| if(upb_issubmsg(e->field)) { |
| upb_msgdef *m = upb_downcast_msgdef(e->field->def); |
| void *msgdata = val.msg; |
| fputs(" {.base = {UPB_DATA_FROZEN},\n", stream); |
| /* Print set flags. */ |
| fputs(" .set_flags = {.has = {\n", stream); |
| for(upb_field_count_t j = 0; j < m->num_fields; j++) { |
| upb_fielddef *f = &m->fields[j]; |
| fprintf(stream, " ." UPB_STRFMT " = ", UPB_STRARG(f->name)); |
| if(upb_msg_has(msgdata, f)) |
| fprintf(stream, "true"); |
| else |
| fprintf(stream, "false"); |
| fputs(",\n", stream); |
| } |
| fputs(" }},\n", stream); |
| /* Print msg data. */ |
| for(upb_field_count_t j = 0; j < m->num_fields; j++) { |
| upb_fielddef *f = &m->fields[j]; |
| upb_value val = upb_msg_get(msgdata, f); |
| fprintf(stream, " ." UPB_STRFMT " = ", UPB_STRARG(f->name)); |
| if(!upb_msg_has(msgdata, f)) { |
| if(upb_isarray(f) && upb_issubmsg(f)) { |
| // This is gross and needs cleanup. |
| fputs("{UPB_ARRAY_NULL_INITIALIZER}, /* Not set. */", stream); |
| } else if(upb_isarray(f)) { |
| fputs("UPB_ARRAY_NULL_INITIALIZER, /* Not set. */", stream); |
| } else if(upb_isstring(f)) { |
| fputs("UPB_STRING_NULL_INITIALIZER, /* Not set. */", stream); |
| } else { |
| fputs("0, /* Not set. */", stream); |
| } |
| } else if(upb_isstring(f)) { |
| if(upb_isarray(f)) { |
| fputs("Ack, string arrays are not supported yet!\n", stderr); |
| exit(1); |
| } else { |
| strtable_entry *str_e = upb_strtable_lookup(&strings, val.str); |
| assert(str_e); |
| fprintf(stream, "UPB_STATIC_STRING_PTR_INIT(strings[%d]), /* \"" UPB_STRFMT "\" */", |
| str_e->num, UPB_STRARG(val.str)); |
| } |
| } else if(upb_isarray(f)) { |
| /* Find this submessage in the list of msgs for that type. */ |
| typetable_entry *type_e = get_or_insert_typeentry(&types, f); |
| assert(type_e); |
| int arr_num = -1; |
| for(int k = 0; k < type_e->arrays_len; k++) { |
| if(upb_array_ptreql(type_e->arrays[k].ptr, val.arr)) { |
| arr_num = k; |
| break; |
| } |
| } |
| assert(arr_num != -1); |
| fprintf(stream, "UPB_STATIC_ARRAY_PTR_TYPED_INIT(" UPB_STRFMT "_arrays[%d]),", UPB_STRARG(type_e->cident), arr_num); |
| } else if(upb_issubmsg(f)) { |
| /* Find this submessage in the list of msgs for that type. */ |
| typetable_entry *type_e = get_or_insert_typeentry(&types, f); |
| assert(type_e); |
| int msg_num = -1; |
| for(int k = 0; k < type_e->values_len; k++) { |
| if(type_e->values[k].msg == val.msg) { |
| msg_num = k; |
| break; |
| } |
| } |
| assert(msg_num != -1); |
| fprintf(stream, "&" UPB_STRFMT "_values[%d],", UPB_STRARG(type_e->cident), msg_num); |
| } else { |
| upb_text_printval(f->type, val, stream); |
| fputs(",", stream); |
| } |
| fputs("\n", stream); |
| } |
| fputs(" },\n", stream); |
| } else if(upb_isstring(e->field)) { |
| |
| } else { |
| /* Non string, non-message data. */ |
| upb_text_printval(e->field->type, val, stream); |
| } |
| } |
| fputs("};\n", stream); |
| } |
| |
| typetable_entry *toplevel_type = get_or_insert_typeentry(&types, &fake_field); |
| assert(toplevel_type); |
| fputs("/* The externally-visible definition. */\n", stream); |
| /* It is always at offset zero, because we add it first. */ |
| fprintf(stream, UPB_STRFMT " *%s = &" UPB_STRFMT "_values[0];\n", |
| UPB_STRARG(toplevel_type->cident), cident, |
| UPB_STRARG(toplevel_type->cident)); |
| |
| /* Free tables. */ |
| for(e = upb_strtable_begin(&types); e; e = upb_strtable_next(&types, &e->e)) { |
| upb_string_unref(e->cident); |
| free(e->values); |
| free(e->arrays); |
| } |
| upb_strtable_free(&types); |
| upb_strtable_free(&strings); |
| } |
| |
| const char usage[] = |
| "upbc -- upb compiler.\n" |
| "upb v0.1 http://blog.reverberate.org/upb/\n" |
| "\n" |
| "Usage: upbc [options] descriptor-file\n" |
| "\n" |
| " -i C-IDENFITER Output the descriptor as a C data structure with the\n" |
| " given identifier (otherwise only a header will be\n" |
| " generated\n" |
| "\n" |
| " -o OUTFILE-BASE Write to OUTFILE-BASE.h and OUTFILE-BASE.c instead\n" |
| " of using the input file as a basename.\n" |
| ; |
| |
| void usage_err(char *err) |
| { |
| fprintf(stderr, "upbc: %s\n\n", err); |
| fputs(usage, stderr); |
| exit(1); |
| } |
| |
| void error(char *err, ...) |
| { |
| va_list args; |
| va_start(args, err); |
| fprintf(stderr, "upbc: "); |
| vfprintf(stderr, err, args); |
| va_end(args); |
| exit(1); |
| } |
| |
| void sort_fields_in_descriptor(google_protobuf_DescriptorProto *d) |
| { |
| // XXX: modifying the array in place is totally not allowed. |
| if(d->set_flags.has.field) { |
| upb_fielddef_sortfds(_upb_array_getptr_raw(d->field.ptr, 0, 0)._void, |
| google_protobuf_FieldDescriptorProto_array_len(d->field)); |
| } |
| if(d->set_flags.has.nested_type) |
| for(uint32_t i = 0; i < google_protobuf_DescriptorProto_array_len(d->nested_type); i++) |
| sort_fields_in_descriptor(google_protobuf_DescriptorProto_array_get(d->nested_type, i)); |
| } |
| |
| int main(int argc, char *argv[]) |
| { |
| /* Parse arguments. */ |
| char *outfile_base = NULL, *input_file = NULL, *cident = NULL; |
| for(int i = 1; i < argc; i++) { |
| if(strcmp(argv[i], "-o") == 0) { |
| if(++i == argc) |
| usage_err("-o must be followed by a FILE-BASE."); |
| else if(outfile_base) |
| usage_err("-o was specified multiple times."); |
| outfile_base = argv[i]; |
| } else if(strcmp(argv[i], "-i") == 0) { |
| if(++i == argc) |
| usage_err("-i must be followed by a C-IDENTIFIER."); |
| else if(cident) |
| usage_err("-i was specified multiple times."); |
| cident = argv[i]; |
| } else { |
| if(input_file) |
| usage_err("You can only specify one input file."); |
| input_file = argv[i]; |
| } |
| } |
| if(!input_file) usage_err("You must specify an input file."); |
| if(!outfile_base) outfile_base = input_file; |
| |
| // Read and parse input file. |
| upb_strptr descriptor = upb_strreadfile(input_file); |
| if(upb_string_isnull(descriptor)) |
| error("Couldn't read input file."); |
| upb_symtab *s = upb_symtab_new(); |
| upb_msg *fds_msg = upb_msg_new(s->fds_msgdef); |
| upb_status status = UPB_STATUS_INIT; |
| upb_msg_decodestr(fds_msg, s->fds_msgdef, descriptor, &status); |
| if(!upb_ok(&status)) |
| error("Failed to parse input file descriptor: %s", status.msg); |
| google_protobuf_FileDescriptorSet *fds = (void*)fds_msg; |
| |
| upb_symtab_add_desc(s, descriptor, &status); |
| if(!upb_ok(&status)) |
| error("Failed to add descriptor: %s", status.msg); |
| |
| // We need to sort the fields of all the descriptors. This is currently |
| // somewhat special-cased to when we are emitting a descriptor for |
| // FileDescriptorProto, which is used internally for bootstrapping. |
| // |
| // The fundamental issue is that we will be parsing descriptors into memory |
| // using a reflection-based code-path, but upb then reads the descriptors |
| // from memory using the C structs emitted by upbc. This means that the |
| // msgdef we will use internally to parse the descriptors must use the same |
| // field order as the .h files we are about to generate. But the msgdefs we |
| // will use to generate those .h files have already been sorted according to |
| // this scheme. |
| // |
| // If/when we ever make upbc more general, we'll have to revisit this. |
| for(uint32_t i = 0; i < google_protobuf_FileDescriptorProto_array_len(fds->file); i++) { |
| google_protobuf_FileDescriptorProto *fd = google_protobuf_FileDescriptorProto_array_get(fds->file, i); |
| if(!fd->set_flags.has.message_type) continue; |
| for(uint32_t j = 0; j < google_protobuf_DescriptorProto_array_len(fd->message_type); j++) |
| sort_fields_in_descriptor(google_protobuf_DescriptorProto_array_get(fd->message_type, j)); |
| } |
| |
| /* Emit output files. */ |
| const int maxsize = 256; |
| char h_filename[maxsize], h_const_filename[maxsize], c_filename[maxsize]; |
| if(snprintf(h_filename, maxsize, "%s.h", outfile_base) >= maxsize || |
| snprintf(c_filename, maxsize, "%s.c", outfile_base) >= maxsize || |
| snprintf(h_const_filename, maxsize, "%s_const.h", outfile_base) >= maxsize) |
| error("File base too long.\n"); |
| |
| FILE *h_file = fopen(h_filename, "w"); |
| if(!h_file) error("Failed to open .h output file"); |
| FILE *h_const_file = fopen(h_const_filename, "w"); |
| if(!h_const_file) error("Failed to open _const.h output file"); |
| |
| int symcount; |
| upb_def **defs = upb_symtab_getdefs(s, &symcount, UPB_DEF_ANY); |
| write_h(defs, symcount, h_filename, cident, h_file); |
| write_const_h(defs, symcount, h_filename, h_const_file); |
| for (int i = 0; i < symcount; i++) upb_def_unref(defs[i]); |
| free(defs); |
| if(cident) { |
| FILE *c_file = fopen(c_filename, "w"); |
| if(!c_file) error("Failed to open .h output file"); |
| write_message_c(fds_msg, s->fds_msgdef, cident, h_filename, argc, argv, input_file, c_file); |
| fclose(c_file); |
| } |
| upb_msg_unref(fds_msg, s->fds_msgdef); |
| upb_string_unref(descriptor); |
| upb_symtab_unref(s); |
| fclose(h_file); |
| fclose(h_const_file); |
| |
| return 0; |
| } |
