- Added extra parameter to count() that recursively counts elements in an

  array and added is_array_multidimensional(). (patch by Vlad Bosinceanu
  <glipy@fx.ro>)

diff --git a/ext/standard/array.c b/ext/standard/array.c
index 653851b4c8f121aa1c1b51471258eb99ed40eb62..3ce6d17cc03273d0d0fefc0b4584f9767bc8ab59 100644 (file)
--- a/ext/standard/array.c
+++ b/ext/standard/array.c
@@ -25,7 +25,6 @@
 
 #include "php.h"
 #include "php_ini.h"
-#include "zend_operators.h"
 #include <stdarg.h>
 #include <stdlib.h>
 #include <math.h>
@@ -68,6 +67,8 @@ php_array_globals array_globals;
 #define CASE_LOWER          0
 #define CASE_UPPER          1
 
+#define COUNT_NORMAL           0
+#define COUNT_RECURSIVE                1
 
 PHP_MINIT_FUNCTION(array)
 {
@@ -90,6 +91,9 @@ PHP_MINIT_FUNCTION(array)
        REGISTER_LONG_CONSTANT("CASE_LOWER", CASE_LOWER, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("CASE_UPPER", CASE_UPPER, CONST_CS | CONST_PERSISTENT);
 
+       REGISTER_LONG_CONSTANT("COUNT_NORMAL", COUNT_NORMAL, CONST_CS | CONST_PERSISTENT);
+       REGISTER_LONG_CONSTANT("COUNT_RECURSIVE", COUNT_RECURSIVE, CONST_CS | CONST_PERSISTENT);
+       
        return SUCCESS;
 }
 
@@ -223,26 +227,45 @@ PHP_FUNCTION(ksort)
 }
 /* }}} */
 
-/* {{{ proto int count(mixed var)
-   Count the number of elements in a variable (usually an array) */
-PHP_FUNCTION(count)
+
+int php_count_recursive(zval *array, long mode)
 {
-       pval **array;
+       long cnt = 0, i;
+       zval **element;
+       
        HashTable *target_hash;
+       target_hash = HASH_OF(array);
 
-       if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &array) == FAILURE) {
-               WRONG_PARAM_COUNT;
-       }
-       target_hash = HASH_OF(*array);
-       if (!target_hash) {
-               if (Z_TYPE_PP(array) == IS_NULL) {
-                       RETURN_LONG(0);
-               } else {
-                       RETURN_LONG(1);
+       if (Z_TYPE_P(array) == IS_ARRAY)
+       {
+               cnt += zend_hash_num_elements(target_hash);
+               if (mode == COUNT_RECURSIVE) {
+                       for(i = 0; i < zend_hash_num_elements(target_hash); i++) {
+                               if (zend_hash_index_find (Z_ARRVAL_P(array), i, (void **) &element) == SUCCESS) {
+                                       cnt += php_count_recursive(*element, COUNT_RECURSIVE);
+                               }
+                       }
                }
        }
+       return cnt;
+}
 
-       RETURN_LONG(zend_hash_num_elements(target_hash));
+/* {{{ proto int count(mixed var [, int mode])
+   Count the number of elements in a variable (usually an array) */
+PHP_FUNCTION(count)
+{
+       zval *array;
+       long mode = COUNT_NORMAL;
+       
+       if (zend_parse_parameters (ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &array, &mode) == FAILURE)
+               return;
+       
+       if (Z_TYPE_P(array) == IS_ARRAY) {
+               RETURN_LONG (php_count_recursive (array, mode));
+       } else {
+               /* return 1 for non-array arguments */
+               RETURN_LONG(1);
+       }
 }
 /* }}} */
 

diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c
index 5d637198e7dab8665186697ac56aedd71d680013..9337df331ba4cbdcd46ca4ffdf84fbe8967d0477 100644 (file)
--- a/ext/standard/basic_functions.c
+++ b/ext/standard/basic_functions.c
@@ -520,6 +520,7 @@ function_entry basic_functions[] = {
        PHP_FE(is_numeric,                                                                                                              NULL)
        PHP_FE(is_string,                                                                                                               NULL)
        PHP_FE(is_array,                                                                                                                NULL)
+       PHP_FE(is_array_multidimensional,                                                                               NULL)
        PHP_FE(is_object,                                                                                                               NULL)
        PHP_FE(is_scalar,                                                                                                               NULL)
        PHP_FE(is_callable,                             third_arg_force_ref)
@@ -1633,6 +1634,31 @@ PHP_FUNCTION(is_array)
 }
 /* }}} */
 
+/* {{{ proto bool is_array_multidimensional(mixed var)
+       Returns true if variable is a multidimensional array */
+PHP_FUNCTION(is_array_multidimensional)
+{
+       zval *var, **element;
+       int i = 0;
+       
+       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &var) == FAILURE) {
+               return;
+       }
+       
+       if (Z_TYPE_P(var) == IS_ARRAY) {
+               while (zend_hash_num_elements (HASH_OF(var)) > i) {
+                       if (zend_hash_index_find (Z_ARRVAL_P(var), i, (void **) &element) == SUCCESS) {
+                               if(Z_TYPE_PP(element) == IS_ARRAY) {
+                                       RETURN_TRUE;
+                               }
+                       }
+                       i++;
+               }
+               RETURN_FALSE;
+       }
+}
+/* }}} */
+
 /* {{{ proto bool is_object(mixed var)
    Returns true if variable is an object */
 PHP_FUNCTION(is_object)

diff --git a/ext/standard/basic_functions.h b/ext/standard/basic_functions.h
index 7472a6790a9d9ad2ecd5c1463d1f14b7354ab7da..a69185c5dc38c9819e3397884a7a249d6b979ca0 100644 (file)
--- a/ext/standard/basic_functions.h
+++ b/ext/standard/basic_functions.h
@@ -72,6 +72,7 @@ PHP_FUNCTION(is_float);
 PHP_FUNCTION(is_numeric);
 PHP_FUNCTION(is_string);
 PHP_FUNCTION(is_array);
+PHP_FUNCTION(is_array_multidimensional);
 PHP_FUNCTION(is_object);
 PHP_FUNCTION(is_scalar);
 PHP_FUNCTION(is_callable);