Added upb::FileDef, which represents the file defs are declared in.

It is entirely optional: MessageDef/EnumDef can still exist
on their own.  But this can represent a def's file when it is
desirable to do so (eg. for code generators).

This approach will require that we change the way we handle
extensions.  But I think it will be a good change overall.

Specifically, we previously handled extensions by duplicating
the extended message and then adding the extension as a regular
field to the duplicated message.  This required also duplicating
any messages that could reach the extended message.

In the new world we will need a way of declaring and looking up
extensions separately from the message being extended.

This change also involves some notable changes to the generated
code:

- files are now called foo.upbdefs.h instead of foo.upb.h.
  This reflects the fact that we might possibly generate several
  different output files for a .proto file, and this one is just
  for defs.

- we no longer generate selectors in the .h file.

- the upbdefs.c no longer vends a SymbolTable.  Now it vends the
  individual messages (and possibly a FileDef later).  I think this
  will compose better once we can generate files where one
  generated files imports another.

We also make the descriptor reader vend a list of FileDefs now.
This is the best conceptual match for parsing a FileDescriptorSet.

2 files changed, 44 insertions, 83 deletions

diff --git a/upb/pb/glue.c b/upb/pb/glue.c
index d6faeff..5583f6e 100644
--- a/upb/pb/glue.c
+++ b/upb/pb/glue.c
@@ -7,8 +7,8 @@
 #include "upb/descriptor/reader.h"
 #include "upb/pb/decoder.h"
 
-upb_def **upb_load_defs_from_descriptor(const char *str, size_t len, int *n,
-                                        void *owner, upb_status *status) {
+upb_filedef **upb_loaddescriptor(const char *buf, size_t n, const void *owner,
+                                 upb_status *status) {
   /* Create handlers. */
   const upb_pbdecodermethod *decoder_m;
   const upb_handlers *reader_h = upb_descreader_newhandlers(&reader_h);
@@ -17,8 +17,8 @@ upb_def **upb_load_defs_from_descriptor(const char *str, size_t len, int *n,
   upb_pbdecoder *decoder;
   upb_descreader *reader;
   bool ok;
-  upb_def **ret = NULL;
-  upb_def **defs;
+  size_t i;
+  upb_filedef **ret = NULL;
 
   upb_pbdecodermethodopts_init(&opts, reader_h);
   decoder_m = upb_pbdecodermethod_new(&opts, &decoder_m);
@@ -30,12 +30,24 @@ upb_def **upb_load_defs_from_descriptor(const char *str, size_t len, int *n,
   decoder = upb_pbdecoder_create(&env, decoder_m, upb_descreader_input(reader));
 
   /* Push input data. */
-  ok = upb_bufsrc_putbuf(str, len, upb_pbdecoder_input(decoder));
+  ok = upb_bufsrc_putbuf(buf, n, upb_pbdecoder_input(decoder));
 
-  if (!ok) goto cleanup;
-  defs = upb_descreader_getdefs(reader, owner, n);
-  ret = malloc(sizeof(upb_def*) * (*n));
-  memcpy(ret, defs, sizeof(upb_def*) * (*n));
+  if (!ok) {
+    goto cleanup;
+  }
+
+  ret = malloc(sizeof (*ret) * (upb_descreader_filecount(reader) + 1));
+
+  if (!ret) {
+    goto cleanup;
+  }
+
+  for (i = 0; i < upb_descreader_filecount(reader); i++) {
+    ret[i] = upb_descreader_file(reader, i);
+    upb_filedef_ref(ret[i], owner);
+  }
+
+  ret[i] = NULL;
 
 cleanup:
   upb_env_uninit(&env);
@@ -43,48 +55,3 @@ cleanup:
   upb_pbdecodermethod_unref(decoder_m, &decoder_m);
   return ret;
 }
-
-bool upb_load_descriptor_into_symtab(upb_symtab *s, const char *str, size_t len,
-                                     upb_status *status) {
-  int n;
-  bool success;
-  upb_def **defs = upb_load_defs_from_descriptor(str, len, &n, &defs, status);
-  if (!defs) return false;
-  success = upb_symtab_add(s, defs, n, &defs, status);
-  free(defs);
-  return success;
-}
-
-char *upb_readfile(const char *filename, size_t *len) {
-  long size;
-  char *buf;
-  FILE *f = fopen(filename, "rb");
-  if(!f) return NULL;
-  if(fseek(f, 0, SEEK_END) != 0) goto error;
-  size = ftell(f);
-  if(size < 0) goto error;
-  if(fseek(f, 0, SEEK_SET) != 0) goto error;
-  buf = malloc(size + 1);
-  if(size && fread(buf, size, 1, f) != 1) goto error;
-  fclose(f);
-  if (len) *len = size;
-  return buf;
-
-error:
-  fclose(f);
-  return NULL;
-}
-
-bool upb_load_descriptor_file_into_symtab(upb_symtab *symtab, const char *fname,
-                                          upb_status *status) {
-  size_t len;
-  bool success;
-  char *data = upb_readfile(fname, &len);
-  if (!data) {
-    if (status) upb_status_seterrf(status, "Couldn't read file: %s", fname);
-    return false;
-  }
-  success = upb_load_descriptor_into_symtab(symtab, data, len, status);
-  free(data);
-  return success;
-}
diff --git a/upb/pb/glue.h b/upb/pb/glue.h
index f65753c..014562b 100644
--- a/upb/pb/glue.h
+++ b/upb/pb/glue.h
@@ -25,49 +25,43 @@
 #include "upb/symtab.h"
 
 #ifdef __cplusplus
+#include <vector>
+
 extern "C" {
 #endif
 
-/* Loads all defs from the given protobuf binary descriptor, setting default
- * accessors and a default layout on all messages.  The caller owns the
- * returned array of defs, which will be of length *n.  On error NULL is
- * returned and status is set (if non-NULL). */
-upb_def **upb_load_defs_from_descriptor(const char *str, size_t len, int *n,
-                                        void *owner, upb_status *status);
-
-/* Like the previous but also adds the loaded defs to the given symtab. */
-bool upb_load_descriptor_into_symtab(upb_symtab *symtab, const char *str,
-                                     size_t len, upb_status *status);
-
-/* Like the previous but also reads the descriptor from the given filename. */
-bool upb_load_descriptor_file_into_symtab(upb_symtab *symtab, const char *fname,
-                                          upb_status *status);
-
-/* Reads the given filename into a character string, returning NULL if there
- * was an error. */
-char *upb_readfile(const char *filename, size_t *len);
+/* Loads a binary descriptor and returns a NULL-terminated array of unfrozen
+ * filedefs.  The caller owns the returned array. */
+upb_filedef **upb_loaddescriptor(const char *buf, size_t n, const void *owner,
+                                 upb_status *status);
 
 #ifdef __cplusplus
 }  /* extern "C" */
 
 namespace upb {
 
-/* All routines that load descriptors expect the descriptor to be a
- * FileDescriptorSet. */
-inline bool LoadDescriptorFileIntoSymtab(SymbolTable* s, const char *fname,
-                                         Status* status) {
-  return upb_load_descriptor_file_into_symtab(s, fname, status);
-}
+inline bool LoadDescriptor(const char* buf, size_t n, Status* status,
+                           std::vector<reffed_ptr<FileDef> >* files) {
+  FileDef** parsed_files = upb_loaddescriptor(buf, n, &parsed_files, status);
 
-inline bool LoadDescriptorIntoSymtab(SymbolTable* s, const char* str,
-                                     size_t len, Status* status) {
-  return upb_load_descriptor_into_symtab(s, str, len, status);
+  if (parsed_files) {
+    FileDef** p = parsed_files;
+    while (*p) {
+      files->push_back(reffed_ptr<FileDef>(*p, &parsed_files));
+      ++p;
+    }
+    free(parsed_files);
+    return true;
+  } else {
+    return false;
+  }
 }
 
 /* Templated so it can accept both string and std::string. */
 template <typename T>
-bool LoadDescriptorIntoSymtab(SymbolTable* s, const T& desc, Status* status) {
-  return upb_load_descriptor_into_symtab(s, desc.c_str(), desc.size(), status);
+bool LoadDescriptor(const T& desc, Status* status,
+                    std::vector<reffed_ptr<FileDef> >* files) {
+  return LoadDescriptor(desc.c_str(), desc.size(), status, files);
 }
 
 }  /* namespace upb */