Merge v1.19 into master

src/BSON/Int64.c

@@ -265,11 +265,23 @@ static zend_object* php_phongo_int64_clone_object(phongo_compat_object_handler_t
  return new_object;
 }
 
-static int php_phongo_int64_compare_objects(zval* o1, zval* o2)
+static bool php_phongo_int64_is_int64_object(zval* object)
 {
- php_phongo_int64_t *intern1, *intern2;
+ if (Z_TYPE_P(object) != IS_OBJECT) {
+ return false;
+ }
 
- ZEND_COMPARE_OBJECTS_FALLBACK(o1, o2);
+ return Z_OBJ_P(object)->ce == php_phongo_int64_ce;
+}
+
+static bool php_phongo_int64_is_long_or_double(zval* value)
+{
+ return Z_TYPE_P(value) == IS_LONG || Z_TYPE_P(value) == IS_DOUBLE;
+}
+
+static int php_phongo_int64_compare_int64_objects(zval* o1, zval* o2)
+{
+ php_phongo_int64_t *intern1, *intern2;
 
  intern1 = Z_INT64_OBJ_P(o1);
  intern2 = Z_INT64_OBJ_P(o2);
@@ -281,6 +293,105 @@ static int php_phongo_int64_compare_objects(zval* o1, zval* o2)
  return 0;
 }
 
+static int php_phongo_int64_compare_with_long_or_float(zval* object, zval* value)
+{
+ php_phongo_int64_t* intern;
+ int64_t long_value;
+ double double_value;
+
+ intern = Z_INT64_OBJ_P(object);
+
+ assert(php_phongo_int64_is_long_or_double(value));
+
+ switch (Z_TYPE_P(value)) {
+ case IS_LONG:
+ long_value = Z_LVAL_P(value);
+ if (intern->integer != long_value) {
+ return intern->integer < long_value ? -1 : 1;
+ }
+ break;
+
+ case IS_DOUBLE:
+ double_value = Z_DVAL_P(value);
+ if (intern->integer != double_value) {
+ return intern->integer < double_value ? -1 : 1;
+ }
+ break;
+
+ default:
+ return 0;
+ }
+
+ return 0;
+}
+
+static int php_phongo_int64_compare_objects(zval* o1, zval* o2)
+{
+ if (php_phongo_int64_is_int64_object(o1) && php_phongo_int64_is_int64_object(o2)) {
+ return php_phongo_int64_compare_int64_objects(o1, o2);
+ }
+
+ if (php_phongo_int64_is_int64_object(o1) && php_phongo_int64_is_long_or_double(o2)) {
+ return php_phongo_int64_compare_with_long_or_float(o1, o2);
+ }
+
+ if (php_phongo_int64_is_long_or_double(o1) && php_phongo_int64_is_int64_object(o2)) {
+ // Invert the result as we're flipping the values used for comparison
+ return -1 * php_phongo_int64_compare_with_long_or_float(o2, o1);
+ }
+
+ ZEND_COMPARE_OBJECTS_FALLBACK(o1, o2);
+
+ return 0;
+}
+
+#if PHP_VERSION_ID < 80000
+static int php_phongo_int64_compare_with_other_type(zval* object, zval* value)
+{
+ zval tmp_value;
+ zval result;
+ int ret;
+
+ if (Z_OBJ_HT_P(object)->cast_object(object, &tmp_value, ((Z_TYPE_P(value) == IS_FALSE || Z_TYPE_P(value) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(value))) == FAILURE) {
+ zval_ptr_dtor(&tmp_value);
+ return 1;
+ }
+
+ compare_function(&result, &tmp_value, value);
+
+ ret = Z_LVAL(result);
+ zval_ptr_dtor(&tmp_value);
+ zval_ptr_dtor(&result);
+
+ return ret;
+}
+
+static int php_phongo_int64_compare_zvals(zval* result, zval* op1, zval* op2)
+{
+ /* Happy case: compare an int64 object with another object, long, or double */
+ if ((php_phongo_int64_is_int64_object(op1) || php_phongo_int64_is_long_or_double(op1)) && (php_phongo_int64_is_int64_object(op2) || php_phongo_int64_is_long_or_double(op2))) {
+ ZVAL_LONG(result, php_phongo_int64_compare_objects(op1, op2));
+ return SUCCESS;
+ }
+
+ /* When comparing an int64 object with any other type, cast the int64 object to the desired type.
+ * We know that if op1 is an object, op2 has to be the other type and vice versa. For op2 being
+ * the object, we can again flip the values used for comparison and multiply the result with -1. */
+
+ if (php_phongo_int64_is_int64_object(op1)) {
+ ZVAL_LONG(result, php_phongo_int64_compare_with_other_type(op1, op2));
+ return SUCCESS;
+ }
+
+ if (php_phongo_int64_is_int64_object(op2)) {
+ ZVAL_LONG(result, -1 * php_phongo_int64_compare_with_other_type(op2, op1));
+ return SUCCESS;
+ }
+
+ return FAILURE;
+}
+#endif
+
 static zend_result php_phongo_int64_cast_object(phongo_compat_object_handler_type* readobj, zval* retval, int type)
 {
  php_phongo_int64_t* intern;
@@ -563,6 +674,12 @@ void php_phongo_int64_init_ce(INIT_FUNC_ARGS)
  php_phongo_handler_int64.offset = XtOffsetOf(php_phongo_int64_t, std);
  php_phongo_handler_int64.cast_object = php_phongo_int64_cast_object;
  php_phongo_handler_int64.do_operation = php_phongo_int64_do_operation;
+
+ /* On PHP 7.4, compare_objects is only used when comparing two objects.
+ * Use the compare handler to compare an object with any other zval */
+#if PHP_VERSION_ID < 80000
+ php_phongo_handler_int64.compare = php_phongo_int64_compare_zvals;
+#endif
 }
 
 bool phongo_int64_new(zval* object, int64_t integer)

tests/bson/bson-int64-compare-004.phpt

@@ -1,26 +1,27 @@
 --TEST--
-MongoDB\BSON\Int64 comparisons with scalars (64-bit values, 64-bit platforms only)
---SKIPIF--
-<?php if (8 !== PHP_INT_SIZE) { die('skip Only for 64-bit platform'); } ?>
+MongoDB\BSON\Int64 comparisons with scalars (64-bit values, all platforms)
 --FILE--
 <?php
 
 // Use 2**33 to ensure it still fits in a float
 $int64 = new MongoDB\BSON\Int64('8589934592');
 
 $tests = [
- 'matching int' => 8589934592,
- 'wrong int' => 8589934593,
+ 'matching float' => (float) 2**33,
+ 'wrong int' => 0,
 ];
 
 foreach ($tests as $name => $value) {
  printf('Testing %s: %s' . PHP_EOL, $name, var_export($int64 == $value, true));
 }
 
+var_dump($int64 > 123);
+
 ?>
 ===DONE===
 <?php exit(0); ?>
 --EXPECT--
-Testing matching int: true
+Testing matching float: true
 Testing wrong int: false
+bool(true)
 ===DONE===

tests/bson/bson-int64-compare-005.phpt

@@ -0,0 +1,26 @@
+--TEST--
+MongoDB\BSON\Int64 comparisons with scalars (64-bit values, 64-bit platforms only)
+--SKIPIF--
+<?php if (8 !== PHP_INT_SIZE) { die('skip Only for 64-bit platform'); } ?>
+--FILE--
+<?php
+
+// Use 2**33 to ensure it still fits in a float
+$int64 = new MongoDB\BSON\Int64('8589934592');
+
+$tests = [
+ 'matching int' => 8589934592,
+ 'wrong int' => 8589934593,
+];
+
+foreach ($tests as $name => $value) {
+ printf('Testing %s: %s' . PHP_EOL, $name, var_export($int64 == $value, true));
+}
+
+?>
+===DONE===
+<?php exit(0); ?>
+--EXPECT--
+Testing matching int: true
+Testing wrong int: false
+===DONE===