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 - intl_error.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 0 126 0.0 %
Date: 2014-04-16 Functions: 0 16 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       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: Vadim Savchuk <vsavchuk@productengine.com>                  |
      14             :    |          Dmitry Lakhtyuk <dlakhtyuk@productengine.com>               |
      15             :    |          Stanislav Malyshev <stas@zend.com>                          |
      16             :    +----------------------------------------------------------------------+
      17             :  */
      18             : 
      19             : #ifdef HAVE_CONFIG_H
      20             : #include "config.h"
      21             : #endif
      22             : 
      23             : #include <php.h>
      24             : #include <zend_exceptions.h>
      25             : 
      26             : #include "php_intl.h"
      27             : #include "intl_error.h"
      28             : #include "intl_convert.h"
      29             : 
      30             : ZEND_EXTERN_MODULE_GLOBALS( intl )
      31             : 
      32             : static zend_class_entry *IntlException_ce_ptr;
      33             : 
      34             : /* {{{ intl_error* intl_g_error_get()
      35             :  * Return global error structure.
      36             :  */
      37           0 : static intl_error* intl_g_error_get( TSRMLS_D )
      38             : {
      39           0 :         return &INTL_G( g_error );
      40             : }
      41             : /* }}} */
      42             : 
      43             : /* {{{ void intl_free_custom_error_msg( intl_error* err )
      44             :  * Free mem.
      45             :  */
      46           0 : static void intl_free_custom_error_msg( intl_error* err TSRMLS_DC )
      47             : {
      48           0 :         if( !err && !( err = intl_g_error_get( TSRMLS_C ) ) )
      49           0 :                 return;
      50             : 
      51           0 :         if(err->free_custom_error_message ) {
      52           0 :                 efree( err->custom_error_message );
      53             :         }
      54             : 
      55           0 :         err->custom_error_message      = NULL;
      56           0 :         err->free_custom_error_message = 0;
      57             : }
      58             : /* }}} */
      59             : 
      60             : /* {{{ intl_error* intl_error_create()
      61             :  * Create and initialize  internals of 'intl_error'.
      62             :  */
      63           0 : intl_error* intl_error_create( TSRMLS_D )
      64             : {
      65           0 :         intl_error* err = ecalloc( 1, sizeof( intl_error ) );
      66             : 
      67           0 :         intl_error_init( err TSRMLS_CC );
      68             : 
      69           0 :         return err;
      70             : }
      71             : /* }}} */
      72             : 
      73             : /* {{{ void intl_error_init( intl_error* coll_error )
      74             :  * Initialize internals of 'intl_error'.
      75             :  */
      76           0 : void intl_error_init( intl_error* err TSRMLS_DC )
      77             : {
      78           0 :         if( !err && !( err = intl_g_error_get( TSRMLS_C ) ) )
      79           0 :                 return;
      80             : 
      81           0 :         err->code                      = U_ZERO_ERROR;
      82           0 :         err->custom_error_message      = NULL;
      83           0 :         err->free_custom_error_message = 0;
      84             : }
      85             : /* }}} */
      86             : 
      87             : /* {{{ void intl_error_reset( intl_error* err )
      88             :  * Set last error code to 0 and unset last error message
      89             :  */
      90           0 : void intl_error_reset( intl_error* err TSRMLS_DC )
      91             : {
      92           0 :         if( !err && !( err = intl_g_error_get( TSRMLS_C ) ) )
      93           0 :                 return;
      94             : 
      95           0 :         err->code = U_ZERO_ERROR;
      96             : 
      97           0 :         intl_free_custom_error_msg( err TSRMLS_CC );
      98             : }
      99             : /* }}} */
     100             : 
     101             : /* {{{ void intl_error_set_custom_msg( intl_error* err, char* msg, int copyMsg )
     102             :  * Set last error message to msg copying it if needed.
     103             :  */
     104           0 : void intl_error_set_custom_msg( intl_error* err, char* msg, int copyMsg TSRMLS_DC )
     105             : {
     106           0 :         if( !msg )
     107           0 :                 return;
     108             : 
     109           0 :         if( !err ) {
     110           0 :                 if( INTL_G( error_level ) )
     111           0 :                         php_error_docref( NULL TSRMLS_CC, INTL_G( error_level ), "%s", msg );
     112           0 :                 if( INTL_G( use_exceptions ) )
     113           0 :                         zend_throw_exception_ex( IntlException_ce_ptr, 0 TSRMLS_CC, "%s", msg );
     114             :         }
     115           0 :         if( !err && !( err = intl_g_error_get( TSRMLS_C ) ) )
     116           0 :                 return;
     117             : 
     118             :         /* Free previous message if any */
     119           0 :         intl_free_custom_error_msg( err TSRMLS_CC );
     120             : 
     121             :         /* Mark message copied if any */
     122           0 :         err->free_custom_error_message = copyMsg;
     123             : 
     124             :         /* Set user's error text message */
     125           0 :         err->custom_error_message = copyMsg ? estrdup( msg ) : msg;
     126             : }
     127             : /* }}} */
     128             : 
     129             : /* {{{ const char* intl_error_get_message( intl_error* err )
     130             :  * Create output message in format "<intl_error_text>: <extra_user_error_text>".
     131             :  */
     132           0 : char* intl_error_get_message( intl_error* err TSRMLS_DC )
     133             : {
     134           0 :         const char* uErrorName = NULL;
     135           0 :         char*       errMessage = 0;
     136             : 
     137           0 :         if( !err && !( err = intl_g_error_get( TSRMLS_C ) ) )
     138           0 :                 return estrdup( "" );
     139             : 
     140           0 :         uErrorName = u_errorName( err->code );
     141             : 
     142             :         /* Format output string */
     143           0 :         if( err->custom_error_message )
     144             :         {
     145           0 :                 spprintf( &errMessage, 0, "%s: %s", err->custom_error_message, uErrorName );
     146             :         }
     147             :         else
     148             :         {
     149           0 :                 spprintf( &errMessage, 0, "%s", uErrorName );
     150             :         }
     151             : 
     152           0 :         return errMessage;
     153             : }
     154             : /* }}} */
     155             : 
     156             : /* {{{ void intl_error_set_code( intl_error* err, UErrorCode err_code )
     157             :  * Set last error code.
     158             :  */
     159           0 : void intl_error_set_code( intl_error* err, UErrorCode err_code TSRMLS_DC )
     160             : {
     161           0 :         if( !err && !( err = intl_g_error_get( TSRMLS_C ) ) )
     162           0 :                 return;
     163             : 
     164           0 :         err->code = err_code;
     165             : }
     166             : /* }}} */
     167             : 
     168             : /* {{{ void intl_error_get_code( intl_error* err )
     169             :  * Return last error code.
     170             :  */
     171           0 : UErrorCode intl_error_get_code( intl_error* err TSRMLS_DC )
     172             : {
     173           0 :         if( !err && !( err = intl_g_error_get( TSRMLS_C ) ) )
     174           0 :                 return U_ZERO_ERROR;
     175             : 
     176           0 :         return err->code;
     177             : }
     178             : /* }}} */
     179             : 
     180             : /* {{{ void intl_error_set( intl_error* err, UErrorCode code, char* msg, int copyMsg )
     181             :  * Set error code and message.
     182             :  */
     183           0 : void intl_error_set( intl_error* err, UErrorCode code, char* msg, int copyMsg TSRMLS_DC )
     184             : {
     185           0 :         intl_error_set_code( err, code TSRMLS_CC );
     186           0 :         intl_error_set_custom_msg( err, msg, copyMsg TSRMLS_CC );
     187           0 : }
     188             : /* }}} */
     189             : 
     190             : /* {{{ void intl_errors_set( intl_error* err, UErrorCode code, char* msg, int copyMsg )
     191             :  * Set error code and message.
     192             :  */
     193           0 : void intl_errors_set( intl_error* err, UErrorCode code, char* msg, int copyMsg TSRMLS_DC )
     194             : {
     195           0 :         intl_errors_set_code( err, code TSRMLS_CC );
     196           0 :         intl_errors_set_custom_msg( err, msg, copyMsg TSRMLS_CC );
     197           0 : }
     198             : /* }}} */
     199             : 
     200             : /* {{{ void intl_errors_reset( intl_error* err )
     201             :  */
     202           0 : void intl_errors_reset( intl_error* err TSRMLS_DC )
     203             : {
     204           0 :         if(err) {
     205           0 :                 intl_error_reset( err TSRMLS_CC );
     206             :         }
     207           0 :         intl_error_reset( NULL TSRMLS_CC );
     208           0 : }
     209             : /* }}} */
     210             : 
     211             : /* {{{ void intl_errors_set_custom_msg( intl_error* err, char* msg, int copyMsg )
     212             :  */
     213           0 : void intl_errors_set_custom_msg( intl_error* err, char* msg, int copyMsg TSRMLS_DC )
     214             : {
     215           0 :         if(err) {
     216           0 :                 intl_error_set_custom_msg( err, msg, copyMsg TSRMLS_CC );
     217             :         }
     218           0 :         intl_error_set_custom_msg( NULL, msg, copyMsg TSRMLS_CC );
     219           0 : }
     220             : /* }}} */
     221             : 
     222             : /* {{{ intl_errors_set_code( intl_error* err, UErrorCode err_code )
     223             :  */
     224           0 : void intl_errors_set_code( intl_error* err, UErrorCode err_code TSRMLS_DC )
     225             : {
     226           0 :         if(err) {
     227           0 :                 intl_error_set_code( err, err_code TSRMLS_CC );
     228             :         }
     229           0 :         intl_error_set_code( NULL, err_code TSRMLS_CC );
     230           0 : }
     231             : /* }}} */
     232             : 
     233           0 : void intl_register_IntlException_class( TSRMLS_D )
     234             : {
     235             :         zend_class_entry ce,
     236             :                                          *default_exception_ce;
     237             : 
     238           0 :         default_exception_ce = zend_exception_get_default( TSRMLS_C );
     239             : 
     240             :         /* Create and register 'IntlException' class. */
     241           0 :         INIT_CLASS_ENTRY_EX( ce, "IntlException", sizeof( "IntlException" ) - 1, NULL );
     242           0 :         IntlException_ce_ptr = zend_register_internal_class_ex( &ce,
     243             :                 default_exception_ce, NULL TSRMLS_CC );
     244           0 :         IntlException_ce_ptr->create_object = default_exception_ce->create_object;
     245           0 : }
     246             : 
     247           0 : smart_str intl_parse_error_to_string( UParseError* pe )
     248             : {
     249           0 :         smart_str  ret = {0};
     250             :         char       *buf;
     251             :         int        u8len;
     252             :         UErrorCode status;
     253           0 :         int        any = 0;
     254             : 
     255             :         assert( pe != NULL );
     256             : 
     257           0 :         smart_str_appends( &ret, "parse error " );
     258           0 :         if( pe->line > 0 )
     259             :         {
     260           0 :                 smart_str_appends( &ret, "on line " );
     261           0 :                 smart_str_append_long( &ret, (long ) pe->line );
     262           0 :                 any = 1;
     263             :         }
     264           0 :         if( pe->offset >= 0 ) {
     265           0 :                 if( any )
     266           0 :                         smart_str_appends( &ret, ", " );
     267             :                 else
     268           0 :                         smart_str_appends( &ret, "at " );
     269             : 
     270           0 :                 smart_str_appends( &ret, "offset " );
     271           0 :                 smart_str_append_long( &ret, (long ) pe->offset ); 
     272           0 :                 any = 1;
     273             :         }
     274             : 
     275           0 :         if (pe->preContext[0] != 0 ) {
     276           0 :                 if( any )
     277           0 :                         smart_str_appends( &ret, ", " );
     278             : 
     279           0 :                 smart_str_appends( &ret, "after \"" );
     280           0 :                 intl_convert_utf16_to_utf8( &buf, &u8len, pe->preContext, -1, &status );
     281           0 :                 if( U_FAILURE( status ) )
     282             :                 {
     283           0 :                         smart_str_appends( &ret, "(could not convert parser error pre-context to UTF-8)" );
     284             :                 }
     285             :                 else {
     286           0 :                         smart_str_appendl( &ret, buf, u8len );
     287           0 :                         efree( buf );
     288             :                 }
     289           0 :                 smart_str_appends( &ret, "\"" );
     290           0 :                 any = 1;
     291             :         }
     292             : 
     293           0 :         if( pe->postContext[0] != 0 )
     294             :         {
     295           0 :                 if( any )
     296           0 :                         smart_str_appends( &ret, ", " );
     297             : 
     298           0 :                 smart_str_appends( &ret, "before or at \"" );
     299           0 :                 intl_convert_utf16_to_utf8( &buf, &u8len, pe->postContext, -1, &status );
     300           0 :                 if( U_FAILURE( status ) )
     301             :                 {
     302           0 :                         smart_str_appends( &ret, "(could not convert parser error post-context to UTF-8)" );
     303             :                 }
     304             :                 else
     305             :                 {
     306           0 :                         smart_str_appendl( &ret, buf, u8len );
     307           0 :                         efree( buf );
     308             :                 }
     309           0 :                 smart_str_appends( &ret, "\"" );
     310           0 :                 any = 1;
     311             :         }
     312             : 
     313           0 :         if( !any )
     314             :         {
     315           0 :                 smart_str_free( &ret );
     316           0 :                 smart_str_appends( &ret, "no parse error" );
     317             :         }
     318             :         
     319           0 :         smart_str_0( &ret );
     320           0 :         return ret;
     321             : }
     322             : 
     323             : /*
     324             :  * Local variables:
     325             :  * tab-width: 4
     326             :  * c-basic-offset: 4
     327             :  * End:
     328             :  * vim600: noet sw=4 ts=4 fdm=marker
     329             :  * vim<600: noet sw=4 ts=4
     330             :  */

Generated by: LCOV version 1.10

Generated at Wed, 16 Apr 2014 12:47:48 +0000 (4 days ago)

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