third_party/protobuf: Update to HEAD (83d681ee2c)

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 c062d665ab32670534d7b0d5a3c5faaa3ea92268..16e397f5349e3ac6079851da6de5fe9ff7ab2c2f 100644
--- a/third_party/protobuf/php/ext/google/protobuf/message.c
+++ b/third_party/protobuf/php/ext/google/protobuf/message.c
@@ -29,245 +29,232 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <php.h>
+#include <stdlib.h>
 
 #include "protobuf.h"
 
-// -----------------------------------------------------------------------------
-// Class/module creation from msgdefs and enumdefs, respectively.
-// -----------------------------------------------------------------------------
-
-void* message_data(void* msg) {
-  return ((uint8_t *)msg) + sizeof(MessageHeader);
-}
-
-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) {
-    return EG(uninitialized_zval_ptr);
-  }
-  zval* retval = layout_get(self->descriptor->layout, message_data(self), field TSRMLS_CC);
-  return retval;
-}
+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}
 };
 
-/* stringsink *****************************************************************/
+// Forward declare static functions.
 
-// This should probably be factored into a common upb component.
+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);
 
-typedef struct {
-  upb_byteshandler handler;
-  upb_bytessink sink;
-  char *ptr;
-  size_t len, size;
-} stringsink;
+static zend_object_value message_create(zend_class_entry* ce TSRMLS_DC);
+static void message_free(void* object TSRMLS_DC);
 
-static void *stringsink_start(void *_sink, const void *hd, size_t size_hint) {
-  stringsink *sink = _sink;
-  sink->len = 0;
-  return sink;
-}
-
-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;
+// -----------------------------------------------------------------------------
+// PHP Message Handlers
+// -----------------------------------------------------------------------------
 
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
+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;
+}
 
-  while (sink->len + len > new_size) {
-    new_size *= 2;
+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 (new_size != sink->size) {
-    sink->ptr = realloc(sink->ptr, new_size);
-    sink->size = new_size;
+  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;
   }
 
-  memcpy(sink->ptr + sink->len, ptr, len);
-  sink->len += len;
+  const upb_fielddef* field;
+
+  MessageHeader* self = zend_object_store_get_object(object TSRMLS_CC);
+
+  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 len;
+  layout_set(self->descriptor->layout, self, field, value 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);
+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);
+  }
 
-  upb_bytessink_reset(&sink->sink, &sink->handler, sink);
+  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);
+  }
 
-  sink->size = 32;
-  sink->ptr = malloc(sink->size);
-  sink->len = 0;
-}
+  zend_property_info* property_info = 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;
-}
+  // 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);
+  }
+
+  MessageHeader* self =
+      (MessageHeader*)zend_object_store_get_object(object TSRMLS_CC);
 
-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);
+  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);
 }
 
-static void stackenv_uninit(stackenv* se) {
-  upb_env_uninit(&se->env);
-  upb_seededalloc_uninit(&se->alloc);
+static zval** message_get_property_ptr_ptr(zval* object, zval* member, int type,
+                                           const zend_literal* key TSRMLS_DC) {
+  return NULL;
 }
 
 // -----------------------------------------------------------------------------
-// Message
+// C Message Utilities
 // -----------------------------------------------------------------------------
 
-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;
+void* message_data(void* msg) {
+  return ((uint8_t*)msg) + sizeof(MessageHeader);
 }
 
-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);
+static void message_free(void* object TSRMLS_DC) {
+  MessageHeader* msg = (MessageHeader*)object;
+  int i;
 
-    putmsg(getThis(), desc, upb_pb_encoder_input(encoder), 0);
-
-    RETVAL_STRINGL(sink.ptr, sink.len, 1);
-
-    stackenv_uninit(&se);
-    stringsink_uninit(&sink);
+  for (i = 0; i < msg->std.ce->default_properties_count; i++) {
+    zval_ptr_dtor(&msg->std.properties_table[i]);
   }
+  efree(msg->std.properties_table);
+  efree(msg);
 }
 
-void message_free(void * object TSRMLS_DC) {
-  FREE(object);
-}
-
-zend_object_value message_create(zend_class_entry* ce TSRMLS_DC) {
+static zend_object_value message_create(zend_class_entry* ce TSRMLS_DC) {
   zend_object_value return_value;
 
-  zval* php_descriptor = get_def_obj(ce);
+  zval* php_descriptor = get_ce_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 = PROTOBUF_G(message_handlers);
+  return_value.handlers = message_handlers;
   return return_value;
 }
 
-const zend_class_entry* build_class_from_descriptor(
-    zval* php_descriptor TSRMLS_DC) {
-  Descriptor* desc = php_to_descriptor(php_descriptor);
+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;
+
   if (desc->layout == NULL) {
     MessageLayout* layout = create_layout(desc->msgdef);
     desc->layout = layout;
   }
-  // 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.");
+
+  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;
   }
 
-  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);
+  MessageHeader* msg =
+      (MessageHeader*)zend_object_store_get_object(getThis() TSRMLS_CC);
+
+  const upb_fielddef* field = upb_msgdef_itof(msg->descriptor->msgdef, index);
 
-  add_def_obj(registered_ce, php_descriptor);
+  int property_cache_index =
+      msg->descriptor->layout->fields[upb_fielddef_index(field)].cache_index;
+  zval** cache_ptr = &(msg->std.properties_table)[property_cache_index];
 
-  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;
+  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;
   }
 
-  registered_ce->create_object = message_create;
+  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);
 }