From ee1ed1ccb87effa403dc91603d452d4c98ed716f Mon Sep 17 00:00:00 2001 From: Joshua Haberman Date: Wed, 22 Jul 2009 19:49:53 -0700 Subject: Compiler finally works (except string arrays). Untested. Holy crap that was a lot of work. --- tools/upbc.c | 183 +++++++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 123 insertions(+), 60 deletions(-) (limited to 'tools') diff --git a/tools/upbc.c b/tools/upbc.c index 3a4de70..b0f6d6c 100644 --- a/tools/upbc.c +++ b/tools/upbc.c @@ -1,7 +1,11 @@ /* * upb - a minimalist implementation of protocol buffers. * - * upbc is the upb compiler. + * 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. + * + * TODO: compiler currently has memory leaks (trivial to fix with valgrind). * * Copyright (c) 2009 Joshua Haberman. See LICENSE for details. */ @@ -12,6 +16,7 @@ #include "upb_context.h" #include "upb_enum.h" #include "upb_msg.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). */ @@ -215,13 +220,15 @@ struct strtable_entry { struct typetable_entry { struct upb_strtable_entry e; - struct upb_msg *msg; - void **msgs; /* A list of all msgs of this type, in an established order. */ - int msgs_size, msgs_len; + struct upb_msg_field *field; + struct upb_string c_ident; /* Type name converted with to_cident(). */ + /* A list of all values of this type, in an established order. */ + union upb_value *values; + int values_size, values_len; struct array { int offset; int len; - void *elem0; + struct upb_array *ptr; /* So we can find it later. */ } *arrays; int arrays_size, arrays_len; }; @@ -264,7 +271,7 @@ static void add_strings_from_msg(void *data, struct upb_msg *m, { for(uint32_t i = 0; i < m->num_fields; i++) { struct upb_msg_field *f = &m->fields[i]; - if(!upb_msg_is_set(data, f)) continue; + if(!upb_msg_isset(data, f)) continue; union upb_value_ptr p = upb_msg_getptr(data, f); if(upb_isarray(f)) { struct upb_array *arr = *p.arr; @@ -283,59 +290,62 @@ static void add_strings_from_msg(void *data, struct upb_msg *m, struct typetable_entry *get_or_insert_typeentry(struct upb_strtable *t, - struct upb_msg *m) + struct upb_msg_field *f) { - struct typetable_entry *type_e = upb_strtable_lookup(t, &m->fqname); + struct upb_string type_name = upb_issubmsg(f) ? f->ref.msg->fqname : + upb_type_info[f->type].ctype; + struct typetable_entry *type_e = upb_strtable_lookup(t, &type_name); if(type_e == NULL) { - struct typetable_entry new_type_e = {.e = {.key = m->fqname}, - .msg = m, - .msgs = NULL, - .msgs_size = 0, .msgs_len = 0, - .arrays = NULL, - .arrays_size = 0, .arrays_len = 0}; + struct typetable_entry new_type_e = { + .e = {.key = type_name}, .field = f, .c_ident = upb_strdup(type_name), + .values = NULL, .values_size = 0, .values_len = 0, + .arrays = NULL, .arrays_size = 0, .arrays_len = 0 + }; + to_cident(new_type_e.c_ident); upb_strtable_insert(t, &new_type_e.e); - type_e = upb_strtable_lookup(t, &m->fqname); + type_e = upb_strtable_lookup(t, &type_name); assert(type_e); } return type_e; } -static void add_msg(void *data, struct upb_msg *m, struct upb_strtable *t) +static void add_value(union upb_value value, struct upb_msg_field *f, + struct upb_strtable *t) { - struct typetable_entry *type_e = get_or_insert_typeentry(t, m); - if(type_e->msgs_size == type_e->msgs_len) { - type_e->msgs_size = max(type_e->msgs_size * 2, 4); - type_e->msgs = realloc(type_e->msgs, sizeof(*type_e->msgs) * type_e->msgs_size); + struct typetable_entry *type_e = get_or_insert_typeentry(t, f); + if(type_e->values_len == type_e->values_size) { + type_e->values_size = max(type_e->values_size * 2, 4); + type_e->values = realloc(type_e->values, sizeof(*type_e->values) * type_e->values_size); } - type_e->msgs[type_e->msgs_len++] = data; + type_e->values[type_e->values_len++] = value; } static void add_submsgs(void *data, struct upb_msg *m, struct upb_strtable *t) { for(uint32_t i = 0; i < m->num_fields; i++) { struct upb_msg_field *f = &m->fields[i]; - if(!upb_issubmsg(f) || !upb_msg_is_set(data, f)) continue; + if(!upb_msg_isset(data, f)) continue; union upb_value_ptr p = upb_msg_getptr(data, f); if(upb_isarray(f)) { + if(upb_isstring(f)) continue; /* Handled by a different code-path. */ struct upb_array *arr = *p.arr; /* Add to our list of arrays for this type. */ struct typetable_entry *arr_type_e = - get_or_insert_typeentry(t, f->ref.msg); + get_or_insert_typeentry(t, f); if(arr_type_e->arrays_len == arr_type_e->arrays_size) { arr_type_e->arrays_size = 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->msgs_len; + 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 = arr->len; - arr_type_e->arrays[arr_type_e->arrays_len].elem0 = - *upb_array_getelementptr(arr, 0, f->type).msg; + arr_type_e->arrays[arr_type_e->arrays_len].ptr = *p.arr; arr_type_e->arrays_len++; - /* Add the individual messages in the array. */ + /* Add the individual values in the array. */ for(uint32_t j = 0; j < arr->len; j++) - add_msg(*upb_array_getelementptr(arr, j, f->type).msg, f->ref.msg, t); + add_value(upb_array_getelement(arr, j, f->type), 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 @@ -343,7 +353,8 @@ static void add_submsgs(void *data, struct upb_msg *m, struct upb_strtable *t) for(uint32_t j = 0; j < arr->len; j++) add_submsgs(*upb_array_getelementptr(arr, j, f->type).msg, f->ref.msg, t); } else { - add_msg(*p.msg, f->ref.msg, t); + if(!upb_issubmsg(f)) continue; + add_value(upb_deref(p, f->type), f, t); add_submsgs(*p.msg, f->ref.msg, t); } } @@ -399,65 +410,117 @@ static void write_messages_c(void *data, struct upb_msg *m, * a unique number within its type. */ struct upb_strtable types; upb_strtable_init(&types, 16, sizeof(struct typetable_entry)); - add_msg(data, m, &types); + union upb_value val = {.msg = data}; + /* A fake field to get the recursion going. */ + struct upb_msg_field fake_field = { + .type = GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_MESSAGE, + .ref = {.msg = m} + }; + add_value(val, &fake_field, &types); add_submsgs(data, m, &types); /* Emit foward declarations for all msgs of all types, and define arrays. */ fprintf(stream, "/* Forward declarations of messages, and array decls. */\n"); struct typetable_entry *e = upb_strtable_begin(&types); for(; e; e = upb_strtable_next(&types, &e->e)) { - struct upb_string s = upb_strdup(e->e.key); - to_cident(s); - fprintf(stream, "static " UPB_STRFMT " " UPB_STRFMT "_msgs[%d];\n\n", - UPB_STRARG(s), UPB_STRARG(s), e->msgs_len); + fprintf(stream, "static " UPB_STRFMT " " UPB_STRFMT "_values[%d];\n\n", + UPB_STRARG(e->c_ident), UPB_STRARG(e->c_ident), e->values_len); if(e->arrays_len > 0) { fprintf(stream, "static " UPB_STRFMT " *" UPB_STRFMT "_array_elems[] = {\n", - UPB_STRARG(s), UPB_STRARG(s)); + UPB_STRARG(e->c_ident), UPB_STRARG(e->c_ident)); 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 "_msgs[%d],\n", UPB_STRARG(s), arr->offset + j); + fprintf(stream, " &" UPB_STRFMT "_values[%d],\n", UPB_STRARG(e->c_ident), arr->offset + j); } fprintf(stream, "};\n"); int cum_offset = 0; fprintf(stream, "static UPB_MSG_ARRAY(" UPB_STRFMT ") " UPB_STRFMT "_arrays[%d] = {\n", - UPB_STRARG(s), UPB_STRARG(s), e->arrays_len); + UPB_STRARG(e->c_ident), UPB_STRARG(e->c_ident), e->arrays_len); for(int i = 0; i < e->arrays_len; i++) { struct array *arr = &e->arrays[i]; fprintf(stream, " {.elements = &" UPB_STRFMT "_array_elems[%d], .len=%d},\n", - UPB_STRARG(s), cum_offset, arr->len); + UPB_STRARG(e->c_ident), cum_offset, arr->len); cum_offset += arr->len; } fprintf(stream, "};\n"); } - upb_strfree(s); } /* Emit definitions. */ for(e = upb_strtable_begin(&types); e; e = upb_strtable_next(&types, &e->e)) { - struct upb_string s = upb_strdup(e->e.key); - to_cident(s); - fprintf(stream, "static " UPB_STRFMT " " UPB_STRFMT "_msgs[%d] = {\n\n", - UPB_STRARG(s), UPB_STRARG(s), e->msgs_len); - for(int i = 0; i < e->msgs_len; i++) { - void *msgdata = e->msgs[i]; - /* Print set flags. */ - fprintf(stream, " {.set_flags = {.bytes = {"); - for(unsigned int j = 0; j < e->msg->set_flags_bytes; j++) { - fprintf(stream, "0x%02hhx", *(uint8_t*)(msgdata + j)); - if(j < e->msg->set_flags_bytes - 1) fprintf(stream, ", "); - } - fprintf(stream, "}},\n"); - /* Print msg data. */ - for(unsigned int j = 0; j < e->msg->num_fields; j++) { - struct upb_msg_field *f = &e->msg->fields[j]; - struct google_protobuf_FieldDescriptorProto *fd = - e->msg->field_descriptors[j]; - fprintf(stream, " ." UPB_STRFMT " = ", UPB_STRARG(*fd->name)); - fprintf(stream, "\n"); + fprintf(stream, "static " UPB_STRFMT " " UPB_STRFMT "_values[%d] = {\n\n", + UPB_STRARG(e->c_ident), UPB_STRARG(e->c_ident), e->values_len); + for(int i = 0; i < e->values_len; i++) { + union upb_value val = e->values[i]; + if(upb_issubmsg(e->field)) { + struct upb_msg *m = e->field->ref.msg; + void *msgdata = val.msg; + /* Print set flags. */ + fprintf(stream, " {.set_flags = {.bytes = {"); + for(unsigned int j = 0; j < m->set_flags_bytes; j++) { + fprintf(stream, "0x%02hhx", *(uint8_t*)(val.msg + j)); + if(j < m->set_flags_bytes - 1) fprintf(stream, ", "); + } + fprintf(stream, "}},\n"); + /* Print msg data. */ + for(unsigned int j = 0; j < m->num_fields; j++) { + struct upb_msg_field *f = &m->fields[j]; + google_protobuf_FieldDescriptorProto *fd = m->field_descriptors[j]; + union upb_value val = upb_msg_get(msgdata, f); + fprintf(stream, " ." UPB_STRFMT " = ", UPB_STRARG(*fd->name)); + if(!upb_msg_isset(msgdata, f)) { + fprintf(stream, "0, /* Not set. */"); + } else if(upb_isstring(f)) { + if(upb_isarray(f)) { + fprintf(stderr, "Ack, string arrays are not supported yet!\n"); + exit(1); + } else { + struct strtable_entry *str_e = upb_strtable_lookup(&strings, val.str); + assert(str_e); + fprintf(stream, "&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. */ + struct 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(type_e->arrays[k].ptr == val.arr) { + arr_num = k; + break; + } + } + assert(arr_num != -1); + fprintf(stream, "&" UPB_STRFMT "_arrays[%d],", UPB_STRARG(type_e->c_ident), arr_num); + } else if(upb_issubmsg(f)) { + /* Find this submessage in the list of msgs for that type. */ + struct 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->c_ident), msg_num); + } else { + upb_text_printval(f->type, val, stream); + fprintf(stream, ","); + } + fprintf(stream, "\n"); + } + fprintf(stream, " },\n"); + } else if(upb_isstring(e->field)) { + + } else { + /* Non string, non-message data. */ + upb_text_printval(e->field->type, val, stream); } - fprintf(stream, " },\n"); } fprintf(stream, "};\n"); } -- cgit v1.2.3