PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/intl/resourcebundle - resourcebundle_class.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 141 172 82.0 %
Date: 2019-03-05 Functions: 14 14 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | This source file is subject to version 3.01 of the PHP license,      |
       6             :    | that is bundled with this package in the file LICENSE, and is        |
       7             :    | available through the world-wide-web at the following url:           |
       8             :    | http://www.php.net/license/3_01.txt                                  |
       9             :    | If you did not receive a copy of the PHP license and are unable to   |
      10             :    | obtain it through the world-wide-web, please send a note to          |
      11             :    | license@php.net so we can mail you a copy immediately.               |
      12             :    +----------------------------------------------------------------------+
      13             :    | Authors: Hans-Peter Oeri (University of St.Gallen) <hp@oeri.ch>      |
      14             :    +----------------------------------------------------------------------+
      15             :  */
      16             : 
      17             : #include <stdlib.h>
      18             : #include <unicode/ures.h>
      19             : #include <unicode/uenum.h>
      20             : 
      21             : #include <zend.h>
      22             : #include <Zend/zend_exceptions.h>
      23             : #include <Zend/zend_interfaces.h>
      24             : #include <php.h>
      25             : 
      26             : #include "php_intl.h"
      27             : #include "intl_data.h"
      28             : #include "intl_common.h"
      29             : 
      30             : #include "resourcebundle/resourcebundle.h"
      31             : #include "resourcebundle/resourcebundle_iterator.h"
      32             : #include "resourcebundle/resourcebundle_class.h"
      33             : 
      34             : zend_class_entry *ResourceBundle_ce_ptr = NULL;
      35             : 
      36             : static zend_object_handlers ResourceBundle_object_handlers;
      37             : 
      38             : /* {{{ ResourceBundle_object_free */
      39          38 : static void ResourceBundle_object_free( zend_object *object )
      40             : {
      41          38 :         ResourceBundle_object *rb = php_intl_resourcebundle_fetch_object(object);
      42             : 
      43             :         // only free local errors
      44          38 :         intl_error_reset( INTL_DATA_ERROR_P(rb) );
      45             : 
      46          38 :         if (rb->me) {
      47          33 :                 ures_close( rb->me );
      48             :         }
      49          38 :         if (rb->child) {
      50          17 :                 ures_close( rb->child );
      51             :         }
      52             : 
      53          38 :         zend_object_std_dtor( &rb->zend );
      54          38 : }
      55             : /* }}} */
      56             : 
      57             : /* {{{ ResourceBundle_object_create */
      58          38 : static zend_object *ResourceBundle_object_create( zend_class_entry *ce )
      59             : {
      60             :         ResourceBundle_object *rb;
      61             : 
      62          38 :         rb = zend_object_alloc(sizeof(ResourceBundle_object), ce);
      63             : 
      64          38 :         zend_object_std_init( &rb->zend, ce );
      65          38 :         object_properties_init( &rb->zend, ce);
      66             : 
      67          38 :         intl_error_init( INTL_DATA_ERROR_P(rb) );
      68          38 :         rb->me = NULL;
      69          38 :         rb->child = NULL;
      70             : 
      71          38 :         rb->zend.handlers = &ResourceBundle_object_handlers;
      72             : 
      73          38 :         return &rb->zend;
      74             : }
      75             : /* }}} */
      76             : 
      77             : /* {{{ ResourceBundle_ctor */
      78          21 : static int resourcebundle_ctor(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_constructor)
      79             : {
      80             :         const char *bundlename;
      81          21 :         size_t          bundlename_len = 0;
      82             :         const char *locale;
      83          21 :         size_t          locale_len = 0;
      84          21 :         zend_bool       fallback = 1;
      85          21 :         int         zpp_flags = is_constructor ? ZEND_PARSE_PARAMS_THROW : 0;
      86             : 
      87          21 :         zval                  *object = return_value;
      88          21 :         ResourceBundle_object *rb = Z_INTL_RESOURCEBUNDLE_P( object );
      89             : 
      90          21 :         intl_error_reset( NULL );
      91             : 
      92          21 :         if( zend_parse_parameters_ex( zpp_flags, ZEND_NUM_ARGS(), "s!s!|b",
      93             :                 &locale, &locale_len, &bundlename, &bundlename_len, &fallback ) == FAILURE )
      94             :         {
      95           1 :                 intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
      96             :                         "resourcebundle_ctor: unable to parse input parameters", 0 );
      97           1 :                 return FAILURE;
      98             :         }
      99             : 
     100          20 :         INTL_CHECK_LOCALE_LEN_OR_FAILURE(locale_len);
     101             : 
     102          20 :         if (locale == NULL) {
     103           1 :                 locale = intl_locale_get_default();
     104             :         }
     105             : 
     106          20 :         if (bundlename_len >= MAXPATHLEN) {
     107           0 :                 intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "Bundle name too long", 0 );
     108           0 :                 zval_ptr_dtor(return_value);
     109           0 :                 ZVAL_NULL(return_value);
     110           0 :                 return FAILURE;
     111             :         }
     112             : 
     113          20 :         if (fallback) {
     114          17 :                 rb->me = ures_open(bundlename, locale, &INTL_DATA_ERROR_CODE(rb));
     115             :         } else {
     116           3 :                 rb->me = ures_openDirect(bundlename, locale, &INTL_DATA_ERROR_CODE(rb));
     117             :         }
     118             : 
     119          20 :         INTL_CTOR_CHECK_STATUS(rb, "resourcebundle_ctor: Cannot load libICU resource bundle");
     120             : 
     121          17 :         if (!fallback && (INTL_DATA_ERROR_CODE(rb) == U_USING_FALLBACK_WARNING ||
     122           1 :                         INTL_DATA_ERROR_CODE(rb) == U_USING_DEFAULT_WARNING)) {
     123             :                 char *pbuf;
     124           0 :                 intl_errors_set_code(NULL, INTL_DATA_ERROR_CODE(rb));
     125           0 :                 spprintf(&pbuf, 0, "resourcebundle_ctor: Cannot load libICU resource "
     126             :                                 "'%s' without fallback from %s to %s",
     127           0 :                                 bundlename ? bundlename : "(default data)", locale,
     128             :                                 ures_getLocaleByType(
     129           0 :                                         rb->me, ULOC_ACTUAL_LOCALE, &INTL_DATA_ERROR_CODE(rb)));
     130           0 :                 intl_errors_set_custom_msg(INTL_DATA_ERROR_P(rb), pbuf, 1);
     131           0 :                 efree(pbuf);
     132           0 :                 return FAILURE;
     133             :         }
     134             : 
     135          16 :         return SUCCESS;
     136             : }
     137             : /* }}} */
     138             : 
     139             : /* {{{ arginfo_resourcebundle__construct */
     140             : ZEND_BEGIN_ARG_INFO_EX( arginfo_resourcebundle___construct, 0, 0, 2 )
     141             :         ZEND_ARG_INFO( 0, locale )
     142             :         ZEND_ARG_INFO( 0, bundlename )
     143             :         ZEND_ARG_INFO( 0, fallback )
     144             : ZEND_END_ARG_INFO()
     145             : /* }}} */
     146             : 
     147             : /* {{{ proto ResourceBundle::__construct( string $locale [, string $bundlename [, bool $fallback = true ]] )
     148             :  * ResourceBundle object constructor
     149             :  */
     150          14 : PHP_METHOD( ResourceBundle, __construct )
     151             : {
     152             :         zend_error_handling error_handling;
     153             : 
     154          14 :         zend_replace_error_handling(EH_THROW, IntlException_ce_ptr, &error_handling);
     155          14 :         return_value = ZEND_THIS;
     156          14 :         if (resourcebundle_ctor(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1) == FAILURE) {
     157           2 :                 if (!EG(exception)) {
     158           2 :                         zend_throw_exception(IntlException_ce_ptr, "Constructor failed", 0);
     159             :                 }
     160             :         }
     161          14 :         zend_restore_error_handling(&error_handling);
     162          14 : }
     163             : /* }}} */
     164             : 
     165             : /* {{{ proto ResourceBundle ResourceBundle::create( string $locale [, string $bundlename [, bool $fallback = true ]] )
     166             : proto ResourceBundle resourcebundle_create( string $locale [, string $bundlename [, bool $fallback = true ]] )
     167             : */
     168           7 : PHP_FUNCTION( resourcebundle_create )
     169             : {
     170           7 :         object_init_ex( return_value, ResourceBundle_ce_ptr );
     171           7 :         if (resourcebundle_ctor(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0) == FAILURE) {
     172           3 :                 zval_ptr_dtor(return_value);
     173           3 :                 RETURN_NULL();
     174             :         }
     175             : }
     176             : /* }}} */
     177             : 
     178             : /* {{{ resourcebundle_array_fetch */
     179          47 : static void resourcebundle_array_fetch(zend_object *object, zval *offset, zval *return_value, int fallback)
     180             : {
     181          47 :         int32_t     meindex = 0;
     182          47 :         char *      mekey = NULL;
     183          47 :     zend_bool    is_numeric = 0;
     184             :         char         *pbuf;
     185             :         ResourceBundle_object *rb;
     186             : 
     187          47 :         intl_error_reset( NULL );
     188          47 :         rb = php_intl_resourcebundle_fetch_object(object);
     189             : 
     190          47 :         if(Z_TYPE_P(offset) == IS_LONG) {
     191           5 :                 is_numeric = 1;
     192           5 :                 meindex = (int32_t)Z_LVAL_P(offset);
     193           5 :                 rb->child = ures_getByIndex( rb->me, meindex, rb->child, &INTL_DATA_ERROR_CODE(rb) );
     194          42 :         } else if(Z_TYPE_P(offset) == IS_STRING) {
     195          42 :                 mekey = Z_STRVAL_P(offset);
     196          42 :                 rb->child = ures_getByKey(rb->me, mekey, rb->child, &INTL_DATA_ERROR_CODE(rb) );
     197             :         } else {
     198           0 :                 intl_errors_set(INTL_DATA_ERROR_P(rb), U_ILLEGAL_ARGUMENT_ERROR,
     199             :                         "resourcebundle_get: index should be integer or string", 0);
     200           5 :                 RETURN_NULL();
     201             :         }
     202             : 
     203          47 :         intl_error_set_code( NULL, INTL_DATA_ERROR_CODE(rb) );
     204          47 :         if (U_FAILURE(INTL_DATA_ERROR_CODE(rb))) {
     205           5 :                 if (is_numeric) {
     206           0 :                         spprintf( &pbuf, 0, "Cannot load resource element %d", meindex );
     207             :                 } else {
     208           5 :                         spprintf( &pbuf, 0, "Cannot load resource element '%s'", mekey );
     209             :                 }
     210           5 :                 intl_errors_set_custom_msg( INTL_DATA_ERROR_P(rb), pbuf, 1 );
     211           5 :                 efree(pbuf);
     212           5 :                 RETURN_NULL();
     213             :         }
     214             : 
     215          42 :         if (!fallback && (INTL_DATA_ERROR_CODE(rb) == U_USING_FALLBACK_WARNING || INTL_DATA_ERROR_CODE(rb) == U_USING_DEFAULT_WARNING)) {
     216             :                 UErrorCode icuerror;
     217           0 :                 const char * locale = ures_getLocaleByType( rb->me, ULOC_ACTUAL_LOCALE, &icuerror );
     218           0 :                 if (is_numeric) {
     219           0 :                         spprintf( &pbuf, 0, "Cannot load element %d without fallback from to %s", meindex, locale );
     220             :                 } else {
     221           0 :                         spprintf( &pbuf, 0, "Cannot load element '%s' without fallback from to %s", mekey, locale );
     222             :                 }
     223           0 :                 intl_errors_set_custom_msg( INTL_DATA_ERROR_P(rb), pbuf, 1 );
     224           0 :                 efree(pbuf);
     225           0 :                 RETURN_NULL();
     226             :         }
     227             : 
     228          42 :         resourcebundle_extract_value( return_value, rb );
     229             : }
     230             : /* }}} */
     231             : 
     232             : /* {{{ resourcebundle_array_get */
     233          15 : zval *resourcebundle_array_get(zend_object *object, zval *offset, int type, zval *rv)
     234             : {
     235          15 :         if(offset == NULL) {
     236           0 :                 php_error( E_ERROR, "Cannot apply [] to ResourceBundle object" );
     237             :         }
     238          15 :         ZVAL_NULL(rv);
     239          15 :         resourcebundle_array_fetch(object, offset, rv, 1);
     240          15 :         return rv;
     241             : }
     242             : /* }}} */
     243             : 
     244             : /* {{{ arginfo_resourcebundle_get */
     245             : ZEND_BEGIN_ARG_INFO_EX( arginfo_resourcebundle_get, 0, 0, 1 )
     246             :         ZEND_ARG_INFO( 0, index )
     247             :         ZEND_ARG_INFO( 0, fallback )
     248             : ZEND_END_ARG_INFO()
     249             : /* }}} */
     250             : 
     251             : /* {{{ proto mixed ResourceBundle::get( int|string $resindex [, bool $fallback = true ] )
     252             :  * proto mixed resourcebundle_get( ResourceBundle $rb, int|string $resindex [, bool $fallback = true ] )
     253             :  * Get resource identified by numerical index or key name.
     254             :  */
     255          33 : PHP_FUNCTION( resourcebundle_get )
     256             : {
     257          33 :         zend_bool   fallback = 1;
     258             :         zval *          offset;
     259             :         zval *      object;
     260             : 
     261          66 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "Oz|b",  &object, ResourceBundle_ce_ptr, &offset, &fallback ) == FAILURE) {
     262           1 :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     263             :                         "resourcebundle_get: unable to parse input params", 0);
     264           1 :                 RETURN_FALSE;
     265             :         }
     266             : 
     267          32 :         resourcebundle_array_fetch(Z_OBJ_P(object), offset, return_value, fallback);
     268             : }
     269             : /* }}} */
     270             : 
     271             : /* {{{ resourcebundle_array_count */
     272           1 : int resourcebundle_array_count(zend_object *object, zend_long *count)
     273             : {
     274           1 :         ResourceBundle_object *rb = php_intl_resourcebundle_fetch_object(object);
     275             : 
     276           1 :         if (rb->me == NULL) {
     277           0 :                 intl_errors_set(&rb->error, U_ILLEGAL_ARGUMENT_ERROR,
     278             :                                 "Found unconstructed ResourceBundle", 0);
     279           0 :                 return 0;
     280             :         }
     281             : 
     282           1 :         *count = ures_getSize( rb->me );
     283             : 
     284           1 :         return SUCCESS;
     285             : }
     286             : /* }}} */
     287             : 
     288             : /* {{{ arginfo_resourcebundle_count */
     289             : ZEND_BEGIN_ARG_INFO_EX( arginfo_resourcebundle_count, 0, 0, 0 )
     290             : ZEND_END_ARG_INFO()
     291             : /* }}} */
     292             : 
     293             : /* {{{ proto int ResourceBundle::count()
     294             :  * proto int resourcebundle_count( ResourceBundle $bundle )
     295             :  * Get resources count
     296             :  */
     297           3 : PHP_FUNCTION( resourcebundle_count )
     298             : {
     299             :         int32_t                len;
     300           3 :         RESOURCEBUNDLE_METHOD_INIT_VARS;
     301             : 
     302           6 :         if( zend_parse_method_parameters( ZEND_NUM_ARGS(), getThis(), "O", &object, ResourceBundle_ce_ptr ) == FAILURE ) {
     303           1 :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     304             :                         "resourcebundle_count: unable to parse input params", 0);
     305           1 :                 RETURN_FALSE;
     306             :         }
     307             : 
     308           2 :         RESOURCEBUNDLE_METHOD_FETCH_OBJECT;
     309             : 
     310           2 :         len = ures_getSize( rb->me );
     311           2 :         RETURN_LONG( len );
     312             : }
     313             : 
     314             : /* {{{ arginfo_resourcebundle_getlocales */
     315             : ZEND_BEGIN_ARG_INFO_EX( arginfo_resourcebundle_getlocales, 0, 0, 1 )
     316             :         ZEND_ARG_INFO( 0, bundlename )
     317             : ZEND_END_ARG_INFO()
     318             : /* }}} */
     319             : 
     320             : /* {{{ proto array ResourceBundle::getLocales( string $bundlename )
     321             :  * proto array resourcebundle_locales( string $bundlename )
     322             :  * Get available locales from ResourceBundle name
     323             :  */
     324           3 : PHP_FUNCTION( resourcebundle_locales )
     325             : {
     326             :         char * bundlename;
     327           3 :         size_t    bundlename_len = 0;
     328             :         const char * entry;
     329             :         int entry_len;
     330             :         UEnumeration *icuenum;
     331           3 :         UErrorCode   icuerror = U_ZERO_ERROR;
     332             : 
     333           3 :         intl_errors_reset( NULL );
     334             : 
     335           3 :         if( zend_parse_parameters(ZEND_NUM_ARGS(), "s", &bundlename, &bundlename_len ) == FAILURE )
     336             :         {
     337           1 :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     338             :                         "resourcebundle_locales: unable to parse input params", 0);
     339           2 :                 RETURN_FALSE;
     340             :         }
     341             : 
     342           2 :         if (bundlename_len >= MAXPATHLEN) {
     343           0 :                 intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "resourcebundle_locales: bundle name too long", 0 );
     344           0 :                 RETURN_FALSE;
     345             :         }
     346             : 
     347           2 :         if(bundlename_len == 0) {
     348             :                 // fetch default locales list
     349           0 :                 bundlename = NULL;
     350             :         }
     351             : 
     352           2 :         icuenum = ures_openAvailableLocales( bundlename, &icuerror );
     353           2 :         INTL_CHECK_STATUS(icuerror, "Cannot fetch locales list");
     354             : 
     355           2 :         uenum_reset( icuenum, &icuerror );
     356           2 :         INTL_CHECK_STATUS(icuerror, "Cannot iterate locales list");
     357             : 
     358           2 :         array_init( return_value );
     359           8 :         while ((entry = uenum_next( icuenum, &entry_len, &icuerror ))) {
     360           4 :                 add_next_index_stringl( return_value, (char *) entry, entry_len);
     361             :         }
     362           2 :         uenum_close( icuenum );
     363             : }
     364             : /* }}} */
     365             : 
     366             : /* {{{ arginfo_resourcebundle_get_error_code */
     367             : ZEND_BEGIN_ARG_INFO_EX( arginfo_resourcebundle_get_error_code, 0, 0, 0 )
     368             : ZEND_END_ARG_INFO()
     369             : /* }}} */
     370             : 
     371             : /* {{{ proto string ResourceBundle::getErrorCode( )
     372             :  * proto string resourcebundle_get_error_code( ResourceBundle $bundle )
     373             :  * Get text description for ResourceBundle's last error code.
     374             :  */
     375           1 : PHP_FUNCTION( resourcebundle_get_error_code )
     376             : {
     377           1 :         RESOURCEBUNDLE_METHOD_INIT_VARS;
     378             : 
     379           2 :         if( zend_parse_method_parameters( ZEND_NUM_ARGS(), getThis(), "O",
     380             :                 &object, ResourceBundle_ce_ptr ) == FAILURE )
     381             :         {
     382           1 :                 intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
     383             :                         "resourcebundle_get_error_code: unable to parse input params", 0 );
     384           1 :                 RETURN_FALSE;
     385             :         }
     386             : 
     387           0 :         rb = Z_INTL_RESOURCEBUNDLE_P( object );
     388             : 
     389           0 :         RETURN_LONG(INTL_DATA_ERROR_CODE(rb));
     390             : }
     391             : /* }}} */
     392             : 
     393             : /* {{{ arginfo_resourcebundle_get_error_message */
     394             : ZEND_BEGIN_ARG_INFO_EX( arginfo_resourcebundle_get_error_message, 0, 0, 0 )
     395             : ZEND_END_ARG_INFO()
     396             : /* }}} */
     397             : 
     398             : /* {{{ proto string ResourceBundle::getErrorMessage( )
     399             :  * proto string resourcebundle_get_error_message( ResourceBundle $bundle )
     400             :  * Get text description for ResourceBundle's last error.
     401             :  */
     402           1 : PHP_FUNCTION( resourcebundle_get_error_message )
     403             : {
     404           1 :         zend_string* message = NULL;
     405           1 :         RESOURCEBUNDLE_METHOD_INIT_VARS;
     406             : 
     407           2 :         if( zend_parse_method_parameters( ZEND_NUM_ARGS(), getThis(), "O",
     408             :                 &object, ResourceBundle_ce_ptr ) == FAILURE )
     409             :         {
     410           1 :                 intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
     411             :                         "resourcebundle_get_error_message: unable to parse input params", 0 );
     412           1 :                 RETURN_FALSE;
     413             :         }
     414             : 
     415           0 :         rb = Z_INTL_RESOURCEBUNDLE_P( object );
     416           0 :         message = intl_error_get_message(INTL_DATA_ERROR_P(rb));
     417           0 :         RETURN_STR(message);
     418             : }
     419             : /* }}} */
     420             : 
     421             : /* {{{ ResourceBundle_class_functions
     422             :  * Every 'ResourceBundle' class method has an entry in this table
     423             :  */
     424             : static const zend_function_entry ResourceBundle_class_functions[] = {
     425             :         PHP_ME( ResourceBundle, __construct, arginfo_resourcebundle___construct, ZEND_ACC_PUBLIC )
     426             :         ZEND_NAMED_ME( create, ZEND_FN( resourcebundle_create ), arginfo_resourcebundle___construct, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC )
     427             :         ZEND_NAMED_ME( get, ZEND_FN(resourcebundle_get), arginfo_resourcebundle_get, ZEND_ACC_PUBLIC )
     428             :         ZEND_NAMED_ME( count, ZEND_FN(resourcebundle_count), arginfo_resourcebundle_count, ZEND_ACC_PUBLIC )
     429             :         ZEND_NAMED_ME( getLocales, ZEND_FN(resourcebundle_locales), arginfo_resourcebundle_getlocales, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC )
     430             :         ZEND_NAMED_ME( getErrorCode, ZEND_FN(resourcebundle_get_error_code), arginfo_resourcebundle_get_error_code, ZEND_ACC_PUBLIC )
     431             :         ZEND_NAMED_ME( getErrorMessage, ZEND_FN(resourcebundle_get_error_message), arginfo_resourcebundle_get_error_message, ZEND_ACC_PUBLIC )
     432             :         PHP_FE_END
     433             : };
     434             : /* }}} */
     435             : 
     436             : /* {{{ resourcebundle_register_class
     437             :  * Initialize 'ResourceBundle' class
     438             :  */
     439       24325 : void resourcebundle_register_class( void )
     440             : {
     441             :         zend_class_entry ce;
     442             : 
     443       24325 :         INIT_CLASS_ENTRY( ce, "ResourceBundle", ResourceBundle_class_functions );
     444             : 
     445       24325 :         ce.create_object = ResourceBundle_object_create;
     446       24325 :         ce.get_iterator = resourcebundle_get_iterator;
     447             : 
     448       24325 :         ResourceBundle_ce_ptr = zend_register_internal_class( &ce );
     449             : 
     450       24325 :         ResourceBundle_object_handlers = std_object_handlers;
     451       24325 :         ResourceBundle_object_handlers.offset = XtOffsetOf(ResourceBundle_object, zend);
     452       24325 :         ResourceBundle_object_handlers.clone_obj          = NULL; /* ICU ResourceBundle has no clone implementation */
     453       24325 :         ResourceBundle_object_handlers.free_obj = ResourceBundle_object_free;
     454       24325 :         ResourceBundle_object_handlers.read_dimension = resourcebundle_array_get;
     455       24325 :         ResourceBundle_object_handlers.count_elements = resourcebundle_array_count;
     456             : 
     457       24325 :         zend_class_implements(ResourceBundle_ce_ptr, 1, zend_ce_traversable);
     458       24325 : }
     459             : /* }}} */

Generated by: LCOV version 1.10

Generated at Tue, 05 Mar 2019 22:11:03 +0000 (12 days ago)

Copyright © 2005-2019 The PHP Group
All rights reserved.