Reverts third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/php/ext/google/protobuf/message.c

Index: third_party/protobuf/php/ext/google/protobuf/message.c
diff --git a/third_party/protobuf/php/ext/google/protobuf/message.c b/third_party/protobuf/php/ext/google/protobuf/message.c
index 16e397f5349e3ac6079851da6de5fe9ff7ab2c2f..c062d665ab32670534d7b0d5a3c5faaa3ea92268 100644
--- a/third_party/protobuf/php/ext/google/protobuf/message.c
+++ b/third_party/protobuf/php/ext/google/protobuf/message.c
@@ -29,232 +29,245 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <php.h>
-#include <stdlib.h>
 
 #include "protobuf.h"
 
-static zend_class_entry* message_type;
-zend_object_handlers* message_handlers;
-
-static  zend_function_entry message_methods[] = {
-  PHP_ME(Message, encode, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Message, decode, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Message, readOneof, NULL, ZEND_ACC_PROTECTED)
-  PHP_ME(Message, writeOneof, NULL, ZEND_ACC_PROTECTED)
-  PHP_ME(Message, __construct, NULL, ZEND_ACC_PROTECTED)
-  {NULL, NULL, NULL}
-};
-
-// Forward declare static functions.
-
-static void message_set_property(zval* object, zval* member, zval* value,
-                                 const zend_literal* key TSRMLS_DC);
-static zval* message_get_property(zval* object, zval* member, int type,
-                                  const zend_literal* key TSRMLS_DC);
-static zval** message_get_property_ptr_ptr(zval* object, zval* member, int type,
-                                           const zend_literal* key TSRMLS_DC);
-
-static zend_object_value message_create(zend_class_entry* ce TSRMLS_DC);
-static void message_free(void* object TSRMLS_DC);
-
 // -----------------------------------------------------------------------------
-// PHP Message Handlers
+// Class/module creation from msgdefs and enumdefs, respectively.
 // -----------------------------------------------------------------------------
 
-void message_init(TSRMLS_D) {
-  zend_class_entry class_type;
-  INIT_CLASS_ENTRY(class_type, "Google\\Protobuf\\Internal\\Message",
-                   message_methods);
-  message_type = zend_register_internal_class(&class_type TSRMLS_CC);
-
-  message_handlers = PEMALLOC(zend_object_handlers);
-  memcpy(message_handlers, zend_get_std_object_handlers(),
-         sizeof(zend_object_handlers));
-  message_handlers->write_property = message_set_property;
-  message_handlers->read_property = message_get_property;
-  message_handlers->get_property_ptr_ptr = message_get_property_ptr_ptr;
+void* message_data(void* msg) {
+  return ((uint8_t *)msg) + sizeof(MessageHeader);
 }
 
-static void message_set_property(zval* object, zval* member, zval* value,
-                                 const zend_literal* key TSRMLS_DC) {
-  if (Z_TYPE_P(member) != IS_STRING) {
-    zend_error(E_USER_ERROR, "Unexpected type for field name");
-    return;
-  }
-
-  if (Z_OBJCE_P(object) != EG(scope)) {
-    // User cannot set property directly (e.g., $m->a = 1)
-    zend_error(E_USER_ERROR, "Cannot access private property.");
-    return;
-  }
-
+void message_set_property(zval* object, zval* field_name, zval* value,
+                          const zend_literal* key TSRMLS_DC) {
   const upb_fielddef* field;
 
   MessageHeader* self = zend_object_store_get_object(object TSRMLS_CC);
 
+  CHECK_TYPE(field_name, IS_STRING);
+  field = upb_msgdef_ntofz(self->descriptor->msgdef, Z_STRVAL_P(field_name));
+  if (field == NULL) {
+    zend_error(E_ERROR, "Unknown field: %s", Z_STRVAL_P(field_name));
+  }
+  layout_set(self->descriptor->layout, message_data(self), field, value);
+}
+
+zval* message_get_property(zval* object, zval* member, int type,
+                             const zend_literal* key TSRMLS_DC) {
+  MessageHeader* self =
+      (MessageHeader*)zend_object_store_get_object(object TSRMLS_CC);
+  CHECK_TYPE(member, IS_STRING);
+
+  const upb_fielddef* field;
   field = upb_msgdef_ntofz(self->descriptor->msgdef, Z_STRVAL_P(member));
   if (field == NULL) {
-    zend_error(E_USER_ERROR, "Unknown field: %s", Z_STRVAL_P(member));
+    return EG(uninitialized_zval_ptr);
   }
+  zval* retval = layout_get(self->descriptor->layout, message_data(self), field TSRMLS_CC);
+  return retval;
+}
+
+static  zend_function_entry message_methods[] = {
+  PHP_ME(Message, encode, NULL, ZEND_ACC_PUBLIC)
+  {NULL, NULL, NULL}
+};
+
+/* stringsink *****************************************************************/
+
+// This should probably be factored into a common upb component.
 
-  layout_set(self->descriptor->layout, self, field, value TSRMLS_CC);
+typedef struct {
+  upb_byteshandler handler;
+  upb_bytessink sink;
+  char *ptr;
+  size_t len, size;
+} stringsink;
+
+static void *stringsink_start(void *_sink, const void *hd, size_t size_hint) {
+  stringsink *sink = _sink;
+  sink->len = 0;
+  return sink;
 }
 
-static zval* message_get_property(zval* object, zval* member, int type,
-                                  const zend_literal* key TSRMLS_DC) {
-  if (Z_TYPE_P(member) != IS_STRING) {
-    zend_error(E_USER_ERROR, "Property name has to be a string.");
-    return EG(uninitialized_zval_ptr);
+static size_t stringsink_string(void *_sink, const void *hd, const char *ptr,
+                                size_t len, const upb_bufhandle *handle) {
+  stringsink *sink = _sink;
+  size_t new_size = sink->size;
+
+  UPB_UNUSED(hd);
+  UPB_UNUSED(handle);
+
+  while (sink->len + len > new_size) {
+    new_size *= 2;
   }
 
-  if (Z_OBJCE_P(object) != EG(scope)) {
-    // User cannot get property directly (e.g., $a = $m->a)
-    zend_error(E_USER_ERROR, "Cannot access private property.");
-    return EG(uninitialized_zval_ptr);
+  if (new_size != sink->size) {
+    sink->ptr = realloc(sink->ptr, new_size);
+    sink->size = new_size;
   }
 
-  zend_property_info* property_info = NULL;
+  memcpy(sink->ptr + sink->len, ptr, len);
+  sink->len += len;
 
-  // All properties should have been declared in the generated code and have
-  // corresponding zvals in properties_table.
-  ulong h = zend_get_hash_value(Z_STRVAL_P(member), Z_STRLEN_P(member) + 1);
-  if (zend_hash_quick_find(&Z_OBJCE_P(object)->properties_info,
-                           Z_STRVAL_P(member), Z_STRLEN_P(member) + 1, h,
-                           (void**)&property_info) != SUCCESS) {
-    zend_error(E_USER_ERROR, "Property does not exist.");
-    return EG(uninitialized_zval_ptr);
-  }
+  return len;
+}
 
-  MessageHeader* self =
-      (MessageHeader*)zend_object_store_get_object(object TSRMLS_CC);
+void stringsink_init(stringsink *sink) {
+  upb_byteshandler_init(&sink->handler);
+  upb_byteshandler_setstartstr(&sink->handler, stringsink_start, NULL);
+  upb_byteshandler_setstring(&sink->handler, stringsink_string, NULL);
 
-  const upb_fielddef* field;
-  field = upb_msgdef_ntofz(self->descriptor->msgdef, Z_STRVAL_P(member));
-  if (field == NULL) {
-    return EG(uninitialized_zval_ptr);
-  }
-  return layout_get(
-      self->descriptor->layout, message_data(self), field,
-      &Z_OBJ_P(object)->properties_table[property_info->offset] TSRMLS_CC);
+  upb_bytessink_reset(&sink->sink, &sink->handler, sink);
+
+  sink->size = 32;
+  sink->ptr = malloc(sink->size);
+  sink->len = 0;
 }
 
-static zval** message_get_property_ptr_ptr(zval* object, zval* member, int type,
-                                           const zend_literal* key TSRMLS_DC) {
-  return NULL;
+void stringsink_uninit(stringsink *sink) { free(sink->ptr); }
+
+// Stack-allocated context during an encode/decode operation. Contains the upb
+// environment and its stack-based allocator, an initial buffer for allocations
+// to avoid malloc() when possible, and a template for PHP exception messages
+// if any error occurs.
+#define STACK_ENV_STACKBYTES 4096
+typedef struct {
+  upb_env env;
+  upb_seededalloc alloc;
+  const char *php_error_template;
+  char allocbuf[STACK_ENV_STACKBYTES];
+} stackenv;
+
+static void stackenv_init(stackenv* se, const char* errmsg);
+static void stackenv_uninit(stackenv* se);
+
+// Callback invoked by upb if any error occurs during parsing or serialization.
+static bool env_error_func(void* ud, const upb_status* status) {
+    stackenv* se = ud;
+    // Free the env -- rb_raise will longjmp up the stack past the encode/decode
+    // function so it would not otherwise have been freed.
+    stackenv_uninit(se);
+
+    // TODO(teboring): have a way to verify that this is actually a parse error,
+    // instead of just throwing "parse error" unconditionally.
+    zend_error(E_ERROR, se->php_error_template);
+    // Never reached.
+    return false;
+}
+
+static void stackenv_init(stackenv* se, const char* errmsg) {
+  se->php_error_template = errmsg;
+  upb_env_init(&se->env);
+  upb_seededalloc_init(&se->alloc, &se->allocbuf, STACK_ENV_STACKBYTES);
+  upb_env_setallocfunc(&se->env, upb_seededalloc_getallocfunc(&se->alloc),
+                       &se->alloc);
+  upb_env_seterrorfunc(&se->env, env_error_func, se);
+}
+
+static void stackenv_uninit(stackenv* se) {
+  upb_env_uninit(&se->env);
+  upb_seededalloc_uninit(&se->alloc);
 }
 
 // -----------------------------------------------------------------------------
-// C Message Utilities
+// Message
 // -----------------------------------------------------------------------------
 
-void* message_data(void* msg) {
-  return ((uint8_t*)msg) + sizeof(MessageHeader);
+static const upb_handlers* msgdef_pb_serialize_handlers(Descriptor* desc) {
+  if (desc->pb_serialize_handlers == NULL) {
+    desc->pb_serialize_handlers =
+        upb_pb_encoder_newhandlers(desc->msgdef, &desc->pb_serialize_handlers);
+  }
+  return desc->pb_serialize_handlers;
 }
 
-static void message_free(void* object TSRMLS_DC) {
-  MessageHeader* msg = (MessageHeader*)object;
-  int i;
+PHP_METHOD(Message, encode) {
+  Descriptor* desc = (Descriptor*)zend_object_store_get_object(
+      CE_STATIC_MEMBERS(Z_OBJCE_P(getThis()))[0] TSRMLS_CC);
+
+  stringsink sink;
+  stringsink_init(&sink);
+
+  {
+    const upb_handlers* serialize_handlers = msgdef_pb_serialize_handlers(desc);
+
+    stackenv se;
+    upb_pb_encoder* encoder;
+
+    stackenv_init(&se, "Error occurred during encoding: %s");
+    encoder = upb_pb_encoder_create(&se.env, serialize_handlers, &sink.sink);
 
-  for (i = 0; i < msg->std.ce->default_properties_count; i++) {
-    zval_ptr_dtor(&msg->std.properties_table[i]);
+    putmsg(getThis(), desc, upb_pb_encoder_input(encoder), 0);
+
+    RETVAL_STRINGL(sink.ptr, sink.len, 1);
+
+    stackenv_uninit(&se);
+    stringsink_uninit(&sink);
   }
-  efree(msg->std.properties_table);
-  efree(msg);
 }
 
-static zend_object_value message_create(zend_class_entry* ce TSRMLS_DC) {
+void message_free(void * object TSRMLS_DC) {
+  FREE(object);
+}
+
+zend_object_value message_create(zend_class_entry* ce TSRMLS_DC) {
   zend_object_value return_value;
 
-  zval* php_descriptor = get_ce_obj(ce);
+  zval* php_descriptor = get_def_obj(ce);
 
   Descriptor* desc = zend_object_store_get_object(php_descriptor TSRMLS_CC);
   MessageHeader* msg = (MessageHeader*)ALLOC_N(
       uint8_t, sizeof(MessageHeader) + desc->layout->size);
   memset(message_data(msg), 0, desc->layout->size);
 
-  // We wrap first so that everything in the message object is GC-rooted in
-  // case a collection happens during object creation in layout_init().
+  // We wrap first so that everything in the message object is GC-rooted in case
+  // a collection happens during object creation in layout_init().
   msg->descriptor = desc;
 
+  layout_init(desc->layout, message_data(msg));
   zend_object_std_init(&msg->std, ce TSRMLS_CC);
-  object_properties_init(&msg->std, ce);
-  layout_init(desc->layout, message_data(msg),
-              msg->std.properties_table TSRMLS_CC);
 
   return_value.handle = zend_objects_store_put(
-      msg, (zend_objects_store_dtor_t)zend_objects_destroy_object, message_free,
-      NULL TSRMLS_CC);
+      msg, (zend_objects_store_dtor_t)zend_objects_destroy_object,
+      message_free, NULL TSRMLS_CC);
 
-  return_value.handlers = message_handlers;
+  return_value.handlers = PROTOBUF_G(message_handlers);
   return return_value;
 }
 
-void build_class_from_descriptor(zval* php_descriptor TSRMLS_DC) {
-  Descriptor* desc = UNBOX(Descriptor, php_descriptor);
-
-  // Map entries don't have existing php class.
-  if (upb_msgdef_mapentry(desc->msgdef)) {
-    return;
-  }
-
-  zend_class_entry* registered_ce = desc->klass;
-
+const zend_class_entry* build_class_from_descriptor(
+    zval* php_descriptor TSRMLS_DC) {
+  Descriptor* desc = php_to_descriptor(php_descriptor);
   if (desc->layout == NULL) {
     MessageLayout* layout = create_layout(desc->msgdef);
     desc->layout = layout;
   }
-
-  registered_ce->create_object = message_create;
-}
-
-// -----------------------------------------------------------------------------
-// PHP Methods
-// -----------------------------------------------------------------------------
-
-// At the first time the message is created, the class entry hasn't been
-// modified. As a result, the first created instance will be a normal zend
-// object. Here, we manually modify it to our message in such a case.
-PHP_METHOD(Message, __construct) {
-  if (Z_OBJVAL_P(getThis()).handlers != message_handlers) {
-    zend_class_entry* ce = Z_OBJCE_P(getThis());
-    zval_dtor(getThis());
-    Z_OBJVAL_P(getThis()) = message_create(ce TSRMLS_CC);
-  }
-}
-
-PHP_METHOD(Message, readOneof) {
-  long index;
-
-  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) ==
-      FAILURE) {
-    return;
+  // TODO(teboring): Add it back.
+  // if (desc->fill_method == NULL) {
+  //   desc->fill_method = new_fillmsg_decodermethod(desc, &desc->fill_method);
+  // }
+
+  const char* name = upb_msgdef_fullname(desc->msgdef);
+  if (name == NULL) {
+    zend_error(E_ERROR, "Descriptor does not have assigned name.");
   }
 
-  MessageHeader* msg =
-      (MessageHeader*)zend_object_store_get_object(getThis() TSRMLS_CC);
-
-  const upb_fielddef* field = upb_msgdef_itof(msg->descriptor->msgdef, index);
+  zend_class_entry class_entry;
+  INIT_CLASS_ENTRY_EX(class_entry, name, strlen(name), message_methods);
+  zend_class_entry* registered_ce =
+      zend_register_internal_class(&class_entry TSRMLS_CC);
 
-  int property_cache_index =
-      msg->descriptor->layout->fields[upb_fielddef_index(field)].cache_index;
-  zval** cache_ptr = &(msg->std.properties_table)[property_cache_index];
+  add_def_obj(registered_ce, php_descriptor);
 
-  layout_get(msg->descriptor->layout, message_data(msg), field,
-             &return_value TSRMLS_CC);
-}
-
-PHP_METHOD(Message, writeOneof) {
-  long index;
-  zval* value;
-  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz", &index, &value) ==
-      FAILURE) {
-    return;
+  if (PROTOBUF_G(message_handlers) == NULL) {
+    PROTOBUF_G(message_handlers) = ALLOC(zend_object_handlers);
+    memcpy(PROTOBUF_G(message_handlers), zend_get_std_object_handlers(),
+           sizeof(zend_object_handlers));
+    PROTOBUF_G(message_handlers)->write_property = message_set_property;
+    PROTOBUF_G(message_handlers)->read_property = message_get_property;
   }
 
-  MessageHeader* msg =
-      (MessageHeader*)zend_object_store_get_object(getThis() TSRMLS_CC);
-
-  const upb_fielddef* field = upb_msgdef_itof(msg->descriptor->msgdef, index);
-
-  layout_set(msg->descriptor->layout, msg, field, value TSRMLS_CC);
+  registered_ce->create_object = message_create;
 }