Ported upb to C89, for greater portability.

A large part of this change contains surface-level
porting, like moving variable declarations to the
top of the block.

However there are a few more substantial things too:

- moved internal-only struct definitions to a separate
  file (structdefs.int.h), for greater encapsulation
  and ABI compatibility.

- removed the UPB_UPCAST macro, since it requires access
  to the internal-only struct definitions.  Replaced uses
  with calls to inline, type-safe casting functions.

- removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros.
  Class and struct definitions are now more explicit -- you
  get to see the actual class/struct keywords in the source.
  The casting convenience functions have been moved into
  UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2().

- the new way that we duplicate base methods in derived types
  is also more convenient and requires less duplication.
  It is also less greppable, but hopefully that is not
  too big a problem.

Compiler flags (-std=c89 -pedantic) should help to rigorously
enforce that the code is free of C99-isms.

A few functions are not available in C89 (strtoll).  There
are temporary, hacky solutions in place.

1 files changed, 127 insertions, 124 deletions

diff --git a/upb/handlers.c b/upb/handlers.c
index 5a253f1..64f8595 100644
--- a/upb/handlers.c
+++ b/upb/handlers.c
@@ -9,14 +9,16 @@
  */
 
 #include "upb/handlers.h"
+#include "upb/structdefs.int.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include "upb/sink.h"
 
-// Defined for the sole purpose of having a unique pointer value for
-// UPB_NO_CLOSURE.
+
+/* Defined for the sole purpose of having a unique pointer value for
+ * UPB_NO_CLOSURE. */
 char _upb_noclosure;
 
 static void freehandlers(upb_refcounted *r) {
@@ -45,42 +47,45 @@ static void visithandlers(const upb_refcounted *r, upb_refcounted_visit *visit,
       !upb_msg_field_done(&i);
       upb_msg_field_next(&i)) {
     upb_fielddef *f = upb_msg_iter_field(&i);
+    const upb_handlers *sub;
     if (!upb_fielddef_issubmsg(f)) continue;
-    const upb_handlers *sub = upb_handlers_getsubhandlers(h, f);
-    if (sub) visit(r, UPB_UPCAST(sub), closure);
+    sub = upb_handlers_getsubhandlers(h, f);
+    if (sub) visit(r, upb_handlers_upcast(sub), closure);
   }
 }
 
 static const struct upb_refcounted_vtbl vtbl = {visithandlers, freehandlers};
 
 typedef struct {
-  upb_inttable tab;  // maps upb_msgdef* -> upb_handlers*.
+  upb_inttable tab;  /* maps upb_msgdef* -> upb_handlers*. */
   upb_handlers_callback *callback;
   const void *closure;
 } dfs_state;
 
-// TODO(haberman): discard upb_handlers* objects that do not actually have any
-// handlers set and cannot reach any upb_handlers* object that does.  This is
-// slightly tricky to do correctly.
+/* TODO(haberman): discard upb_handlers* objects that do not actually have any
+ * handlers set and cannot reach any upb_handlers* object that does.  This is
+ * slightly tricky to do correctly. */
 static upb_handlers *newformsg(const upb_msgdef *m, const void *owner,
                                dfs_state *s) {
+  upb_msg_field_iter i;
   upb_handlers *h = upb_handlers_new(m, owner);
   if (!h) return NULL;
   if (!upb_inttable_insertptr(&s->tab, m, upb_value_ptr(h))) goto oom;
 
   s->callback(s->closure, h);
 
-  // For each submessage field, get or create a handlers object and set it as
-  // the subhandlers.
-  upb_msg_field_iter i;
+  /* For each submessage field, get or create a handlers object and set it as
+   * the subhandlers. */
   for(upb_msg_field_begin(&i, m);
       !upb_msg_field_done(&i);
       upb_msg_field_next(&i)) {
     upb_fielddef *f = upb_msg_iter_field(&i);
+    const upb_msgdef *subdef;
+    upb_value subm_ent;
+
     if (!upb_fielddef_issubmsg(f)) continue;
 
-    const upb_msgdef *subdef = upb_downcast_msgdef(upb_fielddef_subdef(f));
-    upb_value subm_ent;
+    subdef = upb_downcast_msgdef(upb_fielddef_subdef(f));
     if (upb_inttable_lookupptr(&s->tab, subdef, &subm_ent)) {
       upb_handlers_setsubhandlers(h, f, upb_value_getptr(subm_ent));
     } else {
@@ -97,11 +102,11 @@ oom:
   return NULL;
 }
 
-// Given a selector for a STARTSUBMSG handler, resolves to a pointer to the
-// subhandlers for this submessage field.
+/* Given a selector for a STARTSUBMSG handler, resolves to a pointer to the
+ * subhandlers for this submessage field. */
 #define SUBH(h, selector) (h->sub[selector])
 
-// The selector for a submessage field is the field index.
+/* The selector for a submessage field is the field index. */
 #define SUBH_F(h, f) SUBH(h, f->index_)
 
 static int32_t trygetsel(upb_handlers *h, const upb_fielddef *f,
@@ -139,6 +144,10 @@ static const void **returntype(upb_handlers *h, const upb_fielddef *f,
 static bool doset(upb_handlers *h, int32_t sel, const upb_fielddef *f,
                   upb_handlertype_t type, upb_func *func,
                   upb_handlerattr *attr) {
+  upb_handlerattr set_attr = UPB_HANDLERATTR_INITIALIZER;
+  const void *closure_type;
+  const void **context_closure_type;
+
   assert(!upb_handlers_isfrozen(h));
 
   if (sel < 0) {
@@ -153,15 +162,13 @@ static bool doset(upb_handlers *h, int32_t sel, const upb_fielddef *f,
     return false;
   }
 
-  upb_handlerattr set_attr = UPB_HANDLERATTR_INITIALIZER;
   if (attr) {
     set_attr = *attr;
   }
 
-  // Check that the given closure type matches the closure type that has been
-  // established for this context (if any).
-  const void *closure_type = upb_handlerattr_closuretype(&set_attr);
-  const void **context_closure_type;
+  /* Check that the given closure type matches the closure type that has been
+   * established for this context (if any). */
+  closure_type = upb_handlerattr_closuretype(&set_attr);
 
   if (type == UPB_HANDLER_STRING) {
     context_closure_type = returntype(h, f, UPB_HANDLER_STARTSTR);
@@ -175,7 +182,7 @@ static bool doset(upb_handlers *h, int32_t sel, const upb_fielddef *f,
 
   if (closure_type && *context_closure_type &&
       closure_type != *context_closure_type) {
-    // TODO(haberman): better message for debugging.
+    /* TODO(haberman): better message for debugging. */
     if (f) {
       upb_status_seterrf(&h->status_,
                          "closure type does not match for field %s",
@@ -190,8 +197,8 @@ static bool doset(upb_handlers *h, int32_t sel, const upb_fielddef *f,
   if (closure_type)
     *context_closure_type = closure_type;
 
-  // If this is a STARTSEQ or STARTSTR handler, check that the returned pointer
-  // matches any pre-existing expectations about what type is expected.
+  /* If this is a STARTSEQ or STARTSTR handler, check that the returned pointer
+   * matches any pre-existing expectations about what type is expected. */
   if (type == UPB_HANDLER_STARTSEQ || type == UPB_HANDLER_STARTSTR) {
     const void *return_type = upb_handlerattr_returnclosuretype(&set_attr);
     const void *table_return_type =
@@ -210,17 +217,20 @@ static bool doset(upb_handlers *h, int32_t sel, const upb_fielddef *f,
   return true;
 }
 
-// Returns the effective closure type for this handler (which will propagate
-// from outer frames if this frame has no START* handler).  Not implemented for
-// UPB_HANDLER_STRING at the moment since this is not needed.  Returns NULL is
-// the effective closure type is unspecified (either no handler was registered
-// to specify it or the handler that was registered did not specify the closure
-// type).
+/* Returns the effective closure type for this handler (which will propagate
+ * from outer frames if this frame has no START* handler).  Not implemented for
+ * UPB_HANDLER_STRING at the moment since this is not needed.  Returns NULL is
+ * the effective closure type is unspecified (either no handler was registered
+ * to specify it or the handler that was registered did not specify the closure
+ * type). */
 const void *effective_closure_type(upb_handlers *h, const upb_fielddef *f,
                                    upb_handlertype_t type) {
-  assert(type != UPB_HANDLER_STRING);
-  const void *ret = h->top_closure_type;
+  const void *ret;
   upb_selector_t sel;
+
+  assert(type != UPB_HANDLER_STRING);
+  ret = h->top_closure_type;
+
   if (upb_fielddef_isseq(f) &&
       type != UPB_HANDLER_STARTSEQ &&
       type != UPB_HANDLER_ENDSEQ &&
@@ -233,26 +243,30 @@ const void *effective_closure_type(upb_handlers *h, const upb_fielddef *f,
     ret = upb_handlerattr_returnclosuretype(&h->table[sel].attr);
   }
 
-  // The effective type of the submessage; not used yet.
-  // if (type == SUBMESSAGE &&
-  //     h->table[sel = handlers_getsel(h, f, UPB_HANDLER_STARTSUBMSG)].func) {
-  //   ret = upb_handlerattr_returnclosuretype(&h->table[sel].attr);
-  // }
+  /* The effective type of the submessage; not used yet.
+   * if (type == SUBMESSAGE &&
+   *     h->table[sel = handlers_getsel(h, f, UPB_HANDLER_STARTSUBMSG)].func) {
+   *   ret = upb_handlerattr_returnclosuretype(&h->table[sel].attr);
+   * } */
 
   return ret;
 }
 
-// Checks whether the START* handler specified by f & type is missing even
-// though it is required to convert the established type of an outer frame
-// ("closure_type") into the established type of an inner frame (represented in
-// the return closure type of this handler's attr.
+/* Checks whether the START* handler specified by f & type is missing even
+ * though it is required to convert the established type of an outer frame
+ * ("closure_type") into the established type of an inner frame (represented in
+ * the return closure type of this handler's attr. */
 bool checkstart(upb_handlers *h, const upb_fielddef *f, upb_handlertype_t type,
                 upb_status *status) {
+  const void *closure_type;
+  const upb_handlerattr *attr;
+  const void *return_closure_type;
+
   upb_selector_t sel = handlers_getsel(h, f, type);
   if (h->table[sel].func) return true;
-  const void *closure_type = effective_closure_type(h, f, type);
-  const upb_handlerattr *attr = &h->table[sel].attr;
-  const void *return_closure_type = upb_handlerattr_returnclosuretype(attr);
+  closure_type = effective_closure_type(h, f, type);
+  attr = &h->table[sel].attr;
+  return_closure_type = upb_handlerattr_returnclosuretype(attr);
   if (closure_type && return_closure_type &&
       closure_type != return_closure_type) {
     upb_status_seterrf(status,
@@ -265,32 +279,14 @@ bool checkstart(upb_handlers *h, const upb_fielddef *f, upb_handlertype_t type,
 
 /* Public interface ***********************************************************/
 
-bool upb_handlers_isfrozen(const upb_handlers *h) {
-  return upb_refcounted_isfrozen(UPB_UPCAST(h));
-}
-
-void upb_handlers_ref(const upb_handlers *h, const void *owner) {
-  upb_refcounted_ref(UPB_UPCAST(h), owner);
-}
-
-void upb_handlers_unref(const upb_handlers *h, const void *owner) {
-  upb_refcounted_unref(UPB_UPCAST(h), owner);
-}
-
-void upb_handlers_donateref(
-    const upb_handlers *h, const void *from, const void *to) {
-  upb_refcounted_donateref(UPB_UPCAST(h), from, to);
-}
-
-void upb_handlers_checkref(const upb_handlers *h, const void *owner) {
-  upb_refcounted_checkref(UPB_UPCAST(h), owner);
-}
-
 upb_handlers *upb_handlers_new(const upb_msgdef *md, const void *owner) {
+  int extra;
+  upb_handlers *h;
+
   assert(upb_msgdef_isfrozen(md));
 
-  int extra = sizeof(upb_handlers_tabent) * (md->selector_count - 1);
-  upb_handlers *h = calloc(sizeof(*h) + extra, 1);
+  extra = sizeof(upb_handlers_tabent) * (md->selector_count - 1);
+  h = calloc(sizeof(*h) + extra, 1);
   if (!h) return NULL;
 
   h->msg = md;
@@ -298,14 +294,15 @@ upb_handlers *upb_handlers_new(const upb_msgdef *md, const void *owner) {
   upb_status_clear(&h->status_);
   h->sub = calloc(md->submsg_field_count, sizeof(*h->sub));
   if (!h->sub) goto oom;
-  if (!upb_refcounted_init(UPB_UPCAST(h), &vtbl, owner)) goto oom;
+  if (!upb_refcounted_init(upb_handlers_upcast_mutable(h), &vtbl, owner))
+    goto oom;
   if (!upb_inttable_init(&h->cleanup_, UPB_CTYPE_FPTR)) goto oom;
 
-  // calloc() above initialized all handlers to NULL.
+  /* calloc() above initialized all handlers to NULL. */
   return h;
 
 oom:
-  freehandlers(UPB_UPCAST(h));
+  freehandlers(upb_handlers_upcast_mutable(h));
   return NULL;
 }
 
@@ -314,17 +311,21 @@ const upb_handlers *upb_handlers_newfrozen(const upb_msgdef *m,
                                            upb_handlers_callback *callback,
                                            const void *closure) {
   dfs_state state;
+  upb_handlers *ret;
+  bool ok;
+  upb_refcounted *r;
+
   state.callback = callback;
   state.closure = closure;
   if (!upb_inttable_init(&state.tab, UPB_CTYPE_PTR)) return NULL;
 
-  upb_handlers *ret = newformsg(m, owner, &state);
+  ret = newformsg(m, owner, &state);
 
   upb_inttable_uninit(&state.tab);
   if (!ret) return NULL;
 
-  upb_refcounted *r = UPB_UPCAST(ret);
-  bool ok = upb_refcounted_freeze(&r, 1, NULL, UPB_MAX_HANDLER_DEPTH);
+  r = upb_handlers_upcast_mutable(ret);
+  ok = upb_refcounted_freeze(&r, 1, NULL, UPB_MAX_HANDLER_DEPTH);
   UPB_ASSERT_VAR(ok, ok);
 
   return ret;
@@ -347,20 +348,20 @@ void upb_handlers_clearerr(upb_handlers *h) {
     return doset(h, sel, f, handlertype, (upb_func*)func, attr); \
   }
 
-SETTER(int32,       upb_int32_handlerfunc*,       UPB_HANDLER_INT32);
-SETTER(int64,       upb_int64_handlerfunc*,       UPB_HANDLER_INT64);
-SETTER(uint32,      upb_uint32_handlerfunc*,      UPB_HANDLER_UINT32);
-SETTER(uint64,      upb_uint64_handlerfunc*,      UPB_HANDLER_UINT64);
-SETTER(float,       upb_float_handlerfunc*,       UPB_HANDLER_FLOAT);
-SETTER(double,      upb_double_handlerfunc*,      UPB_HANDLER_DOUBLE);
-SETTER(bool,        upb_bool_handlerfunc*,        UPB_HANDLER_BOOL);
-SETTER(startstr,    upb_startstr_handlerfunc*,    UPB_HANDLER_STARTSTR);
-SETTER(string,      upb_string_handlerfunc*,      UPB_HANDLER_STRING);
-SETTER(endstr,      upb_endfield_handlerfunc*,    UPB_HANDLER_ENDSTR);
-SETTER(startseq,    upb_startfield_handlerfunc*,  UPB_HANDLER_STARTSEQ);
-SETTER(startsubmsg, upb_startfield_handlerfunc*,  UPB_HANDLER_STARTSUBMSG);
-SETTER(endsubmsg,   upb_endfield_handlerfunc*,    UPB_HANDLER_ENDSUBMSG);
-SETTER(endseq,      upb_endfield_handlerfunc*,    UPB_HANDLER_ENDSEQ);
+SETTER(int32,       upb_int32_handlerfunc*,       UPB_HANDLER_INT32)
+SETTER(int64,       upb_int64_handlerfunc*,       UPB_HANDLER_INT64)
+SETTER(uint32,      upb_uint32_handlerfunc*,      UPB_HANDLER_UINT32)
+SETTER(uint64,      upb_uint64_handlerfunc*,      UPB_HANDLER_UINT64)
+SETTER(float,       upb_float_handlerfunc*,       UPB_HANDLER_FLOAT)
+SETTER(double,      upb_double_handlerfunc*,      UPB_HANDLER_DOUBLE)
+SETTER(bool,        upb_bool_handlerfunc*,        UPB_HANDLER_BOOL)
+SETTER(startstr,    upb_startstr_handlerfunc*,    UPB_HANDLER_STARTSTR)
+SETTER(string,      upb_string_handlerfunc*,      UPB_HANDLER_STRING)
+SETTER(endstr,      upb_endfield_handlerfunc*,    UPB_HANDLER_ENDSTR)
+SETTER(startseq,    upb_startfield_handlerfunc*,  UPB_HANDLER_STARTSEQ)
+SETTER(startsubmsg, upb_startfield_handlerfunc*,  UPB_HANDLER_STARTSUBMSG)
+SETTER(endsubmsg,   upb_endfield_handlerfunc*,    UPB_HANDLER_ENDSUBMSG)
+SETTER(endseq,      upb_endfield_handlerfunc*,    UPB_HANDLER_ENDSEQ)
 
 #undef SETTER
 
@@ -382,8 +383,8 @@ bool upb_handlers_setsubhandlers(upb_handlers *h, const upb_fielddef *f,
   assert(sub);
   assert(!upb_handlers_isfrozen(h));
   assert(upb_fielddef_issubmsg(f));
-  if (SUBH_F(h, f)) return false;  // Can't reset.
-  if (UPB_UPCAST(upb_handlers_msgdef(sub)) != upb_fielddef_subdef(f)) {
+  if (SUBH_F(h, f)) return false;  /* Can't reset. */
+  if (upb_msgdef_upcast(upb_handlers_msgdef(sub)) != upb_fielddef_subdef(f)) {
     return false;
   }
   SUBH_F(h, f) = sub;
@@ -407,17 +408,18 @@ bool upb_handlers_getattr(const upb_handlers *h, upb_selector_t sel,
 
 const upb_handlers *upb_handlers_getsubhandlers_sel(const upb_handlers *h,
                                                     upb_selector_t sel) {
-  // STARTSUBMSG selector in sel is the field's selector base.
+  /* STARTSUBMSG selector in sel is the field's selector base. */
   return SUBH(h, sel - UPB_STATIC_SELECTOR_COUNT);
 }
 
 const upb_msgdef *upb_handlers_msgdef(const upb_handlers *h) { return h->msg; }
 
 bool upb_handlers_addcleanup(upb_handlers *h, void *p, upb_handlerfree *func) {
+  bool ok;
   if (upb_inttable_lookupptr(&h->cleanup_, p, NULL)) {
     return false;
   }
-  bool ok = upb_inttable_insertptr(&h->cleanup_, p, upb_value_fptr(func));
+  ok = upb_inttable_insertptr(&h->cleanup_, p, upb_value_fptr(func));
   UPB_ASSERT_VAR(ok, ok);
   return true;
 }
@@ -426,8 +428,10 @@ bool upb_handlers_addcleanup(upb_handlers *h, void *p, upb_handlerfree *func) {
 /* "Static" methods ***********************************************************/
 
 bool upb_handlers_freeze(upb_handlers *const*handlers, int n, upb_status *s) {
-  // TODO: verify we have a transitive closure.
-  for (int i = 0; i < n; i++) {
+  /* TODO: verify we have a transitive closure. */
+  int i;
+  for (i = 0; i < n; i++) {
+    upb_msg_field_iter j;
     upb_handlers *h = handlers[i];
 
     if (!upb_ok(&h->status_)) {
@@ -437,9 +441,8 @@ bool upb_handlers_freeze(upb_handlers *const*handlers, int n, upb_status *s) {
       return false;
     }
 
-    // Check that there are no closure mismatches due to missing Start* handlers
-    // or subhandlers with different type-level types.
-    upb_msg_field_iter j;
+    /* Check that there are no closure mismatches due to missing Start* handlers
+     * or subhandlers with different type-level types. */
     for(upb_msg_field_begin(&j, h->msg);
         !upb_msg_field_done(&j);
         upb_msg_field_next(&j)) {
@@ -473,29 +476,29 @@ bool upb_handlers_freeze(upb_handlers *const*handlers, int n, upb_status *s) {
         }
 
         if (hashandler && !upb_handlers_getsubhandlers(h, f)) {
-          // For now we add an empty subhandlers in this case.  It makes the
-          // decoder code generator simpler, because it only has to handle two
-          // cases (submessage has handlers or not) as opposed to three
-          // (submessage has handlers in enclosing message but no subhandlers).
-          //
-          // This makes parsing less efficient in the case that we want to
-          // notice a submessage but skip its contents (like if we're testing
-          // for submessage presence or counting the number of repeated
-          // submessages).  In this case we will end up parsing the submessage
-          // field by field and throwing away the results for each, instead of
-          // skipping the whole delimited thing at once.  If this is an issue we
-          // can revisit it, but do remember that this only arises when you have
-          // handlers (startseq/startsubmsg/endsubmsg/endseq) set for the
-          // submessage but no subhandlers.  The uses cases for this are
-          // limited.
+          /* For now we add an empty subhandlers in this case.  It makes the
+           * decoder code generator simpler, because it only has to handle two
+           * cases (submessage has handlers or not) as opposed to three
+           * (submessage has handlers in enclosing message but no subhandlers).
+           *
+           * This makes parsing less efficient in the case that we want to
+           * notice a submessage but skip its contents (like if we're testing
+           * for submessage presence or counting the number of repeated
+           * submessages).  In this case we will end up parsing the submessage
+           * field by field and throwing away the results for each, instead of
+           * skipping the whole delimited thing at once.  If this is an issue we
+           * can revisit it, but do remember that this only arises when you have
+           * handlers (startseq/startsubmsg/endsubmsg/endseq) set for the
+           * submessage but no subhandlers.  The uses cases for this are
+           * limited. */
           upb_handlers *sub = upb_handlers_new(upb_fielddef_msgsubdef(f), &sub);
           upb_handlers_setsubhandlers(h, f, sub);
           upb_handlers_unref(sub, &sub);
         }
 
-        // TODO(haberman): check type of submessage.
-        // This is slightly tricky; also consider whether we should check that
-        // they match at setsubhandlers time.
+        /* TODO(haberman): check type of submessage.
+         * This is slightly tricky; also consider whether we should check that
+         * they match at setsubhandlers time. */
       }
     }
   }
@@ -518,7 +521,7 @@ upb_handlertype_t upb_handlers_getprimitivehandlertype(const upb_fielddef *f) {
     case UPB_TYPE_FLOAT: return UPB_HANDLER_FLOAT;
     case UPB_TYPE_DOUBLE: return UPB_HANDLER_DOUBLE;
     case UPB_TYPE_BOOL: return UPB_HANDLER_BOOL;
-    default: assert(false); return -1;  // Invalid input.
+    default: assert(false); return -1;  /* Invalid input. */
   }
 }
 
@@ -570,10 +573,10 @@ bool upb_handlers_getselector(const upb_fielddef *f, upb_handlertype_t type,
       break;
     case UPB_HANDLER_STARTSUBMSG:
       if (!upb_fielddef_issubmsg(f)) return false;
-      // Selectors for STARTSUBMSG are at the beginning of the table so that the
-      // selector can also be used as an index into the "sub" array of
-      // subhandlers.  The indexes for the two into these two tables are the
-      // same, except that in the handler table the static selectors come first.
+      /* Selectors for STARTSUBMSG are at the beginning of the table so that the
+       * selector can also be used as an index into the "sub" array of
+       * subhandlers.  The indexes for the two into these two tables are the
+       * same, except that in the handler table the static selectors come first. */
       *s = f->index_ + UPB_STATIC_SELECTOR_COUNT;
       break;
     case UPB_HANDLER_ENDSUBMSG:
@@ -591,13 +594,13 @@ uint32_t upb_handlers_selectorbaseoffset(const upb_fielddef *f) {
 
 uint32_t upb_handlers_selectorcount(const upb_fielddef *f) {
   uint32_t ret = 1;
-  if (upb_fielddef_isseq(f)) ret += 2;    // STARTSEQ/ENDSEQ
-  if (upb_fielddef_isstring(f)) ret += 2; // [STRING]/STARTSTR/ENDSTR
+  if (upb_fielddef_isseq(f)) ret += 2;    /* STARTSEQ/ENDSEQ */
+  if (upb_fielddef_isstring(f)) ret += 2; /* [STRING]/STARTSTR/ENDSTR */
   if (upb_fielddef_issubmsg(f)) {
-    // ENDSUBMSG (STARTSUBMSG is at table beginning)
+    /* ENDSUBMSG (STARTSUBMSG is at table beginning) */
     ret += 0;
     if (upb_fielddef_lazy(f)) {
-      // STARTSTR/ENDSTR/STRING (for lazy)
+      /* STARTSTR/ENDSTR/STRING (for lazy) */
       ret += 3;
     }
   }
@@ -661,7 +664,7 @@ void upb_byteshandler_init(upb_byteshandler* h) {
   memset(h, 0, sizeof(*h));
 }
 
-// For when we support handlerfree callbacks.
+/* For when we support handlerfree callbacks. */
 void upb_byteshandler_uninit(upb_byteshandler* h) {
   UPB_UNUSED(h);
 }