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: 96 110 87.3 %
Date: 2014-10-22 Functions: 15 16 93.8 %
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: 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       55253 : static intl_error* intl_g_error_get( TSRMLS_D )
      38             : {
      39       55253 :         return &INTL_G( g_error );
      40             : }
      41             : /* }}} */
      42             : 
      43             : /* {{{ void intl_free_custom_error_msg( intl_error* err )
      44             :  * Free mem.
      45             :  */
      46       35004 : static void intl_free_custom_error_msg( intl_error* err TSRMLS_DC )
      47             : {
      48       35004 :         if( !err && !( err = intl_g_error_get( TSRMLS_C ) ) )
      49           0 :                 return;
      50             : 
      51       35004 :         if(err->free_custom_error_message ) {
      52         192 :                 efree( err->custom_error_message );
      53             :         }
      54             : 
      55       35004 :         err->custom_error_message      = NULL;
      56       35004 :         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       20799 : void intl_error_init( intl_error* err TSRMLS_DC )
      77             : {
      78       20799 :         if( !err && !( err = intl_g_error_get( TSRMLS_C ) ) )
      79           0 :                 return;
      80             : 
      81       20799 :         err->code                      = U_ZERO_ERROR;
      82       20799 :         err->custom_error_message      = NULL;
      83       20799 :         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       34042 : void intl_error_reset( intl_error* err TSRMLS_DC )
      91             : {
      92       34042 :         if( !err && !( err = intl_g_error_get( TSRMLS_C ) ) )
      93           0 :                 return;
      94             : 
      95       34042 :         err->code = U_ZERO_ERROR;
      96             : 
      97       34042 :         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         962 : void intl_error_set_custom_msg( intl_error* err, char* msg, int copyMsg TSRMLS_DC )
     105             : {
     106         962 :         if( !msg )
     107           0 :                 return;
     108             : 
     109         962 :         if( !err ) {
     110         738 :                 if( INTL_G( error_level ) )
     111         292 :                         php_error_docref( NULL TSRMLS_CC, INTL_G( error_level ), "%s", msg );
     112         738 :                 if( INTL_G( use_exceptions ) )
     113           1 :                         zend_throw_exception_ex( IntlException_ce_ptr, 0 TSRMLS_CC, "%s", msg );
     114             :         }
     115         962 :         if( !err && !( err = intl_g_error_get( TSRMLS_C ) ) )
     116           0 :                 return;
     117             : 
     118             :         /* Free previous message if any */
     119         962 :         intl_free_custom_error_msg( err TSRMLS_CC );
     120             : 
     121             :         /* Mark message copied if any */
     122         962 :         err->free_custom_error_message = copyMsg;
     123             : 
     124             :         /* Set user's error text message */
     125         962 :         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         303 : zend_string * intl_error_get_message( intl_error* err TSRMLS_DC )
     133             : {
     134         303 :         const char *uErrorName = NULL;
     135         303 :         zend_string *errMessage = 0;
     136             : 
     137         303 :         if( !err && !( err = intl_g_error_get( TSRMLS_C ) ) )
     138           0 :                 return STR_EMPTY_ALLOC();
     139             : 
     140         303 :         uErrorName = u_errorName( err->code );
     141             : 
     142             :         /* Format output string */
     143         303 :         if( err->custom_error_message )
     144             :         {
     145         183 :                 errMessage = strpprintf(0, "%s: %s", err->custom_error_message, uErrorName );
     146             :         }
     147             :         else
     148             :         {
     149         120 :                 errMessage = strpprintf(0, "%s", uErrorName );
     150             :         }
     151             : 
     152         303 :         return errMessage;
     153             : }
     154             : /* }}} */
     155             : 
     156             : /* {{{ void intl_error_set_code( intl_error* err, UErrorCode err_code )
     157             :  * Set last error code.
     158             :  */
     159        5208 : void intl_error_set_code( intl_error* err, UErrorCode err_code TSRMLS_DC )
     160             : {
     161        5208 :         if( !err && !( err = intl_g_error_get( TSRMLS_C ) ) )
     162           0 :                 return;
     163             : 
     164        5208 :         err->code = err_code;
     165             : }
     166             : /* }}} */
     167             : 
     168             : /* {{{ void intl_error_get_code( intl_error* err )
     169             :  * Return last error code.
     170             :  */
     171         699 : UErrorCode intl_error_get_code( intl_error* err TSRMLS_DC )
     172             : {
     173         699 :         if( !err && !( err = intl_g_error_get( TSRMLS_C ) ) )
     174           0 :                 return U_ZERO_ERROR;
     175             : 
     176         699 :         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         499 : void intl_error_set( intl_error* err, UErrorCode code, char* msg, int copyMsg TSRMLS_DC )
     184             : {
     185         499 :         intl_error_set_code( err, code TSRMLS_CC );
     186         499 :         intl_error_set_custom_msg( err, msg, copyMsg TSRMLS_CC );
     187         499 : }
     188             : /* }}} */
     189             : 
     190             : /* {{{ void intl_errors_set( intl_error* err, UErrorCode code, char* msg, int copyMsg )
     191             :  * Set error code and message.
     192             :  */
     193          61 : void intl_errors_set( intl_error* err, UErrorCode code, char* msg, int copyMsg TSRMLS_DC )
     194             : {
     195          61 :         intl_errors_set_code( err, code TSRMLS_CC );
     196          61 :         intl_errors_set_custom_msg( err, msg, copyMsg TSRMLS_CC );
     197          61 : }
     198             : /* }}} */
     199             : 
     200             : /* {{{ void intl_errors_reset( intl_error* err )
     201             :  */
     202          52 : void intl_errors_reset( intl_error* err TSRMLS_DC )
     203             : {
     204          52 :         if(err) {
     205          49 :                 intl_error_reset( err TSRMLS_CC );
     206             :         }
     207          52 :         intl_error_reset( NULL TSRMLS_CC );
     208          52 : }
     209             : /* }}} */
     210             : 
     211             : /* {{{ void intl_errors_set_custom_msg( intl_error* err, char* msg, int copyMsg )
     212             :  */
     213         233 : void intl_errors_set_custom_msg( intl_error* err, char* msg, int copyMsg TSRMLS_DC )
     214             : {
     215         233 :         if(err) {
     216         224 :                 intl_error_set_custom_msg( err, msg, copyMsg TSRMLS_CC );
     217             :         }
     218         233 :         intl_error_set_custom_msg( NULL, msg, copyMsg TSRMLS_CC );
     219         233 : }
     220             : /* }}} */
     221             : 
     222             : /* {{{ intl_errors_set_code( intl_error* err, UErrorCode err_code )
     223             :  */
     224          61 : void intl_errors_set_code( intl_error* err, UErrorCode err_code TSRMLS_DC )
     225             : {
     226          61 :         if(err) {
     227          52 :                 intl_error_set_code( err, err_code TSRMLS_CC );
     228             :         }
     229          61 :         intl_error_set_code( NULL, err_code TSRMLS_CC );
     230          61 : }
     231             : /* }}} */
     232             : 
     233       20423 : void intl_register_IntlException_class( TSRMLS_D )
     234             : {
     235             :         zend_class_entry ce,
     236             :                                          *default_exception_ce;
     237             : 
     238       20423 :         default_exception_ce = zend_exception_get_default( TSRMLS_C );
     239             : 
     240             :         /* Create and register 'IntlException' class. */
     241       20423 :         INIT_CLASS_ENTRY_EX( ce, "IntlException", sizeof( "IntlException" ) - 1, NULL );
     242       20423 :         IntlException_ce_ptr = zend_register_internal_class_ex( &ce,
     243             :                 default_exception_ce TSRMLS_CC );
     244       20423 :         IntlException_ce_ptr->create_object = default_exception_ce->create_object;
     245       20423 : }
     246             : 
     247           2 : smart_str intl_parse_error_to_string( UParseError* pe )
     248             : {
     249           2 :         smart_str  ret = {0};
     250             :         char       *buf;
     251             :         int        u8len;
     252             :         UErrorCode status;
     253           2 :         int        any = 0;
     254             : 
     255             :         assert( pe != NULL );
     256             : 
     257             :         smart_str_appends( &ret, "parse error " );
     258           2 :         if( pe->line > 0 )
     259             :         {
     260             :                 smart_str_appends( &ret, "on line " );
     261           0 :                 smart_str_append_long( &ret, (zend_long ) pe->line );
     262           0 :                 any = 1;
     263             :         }
     264           2 :         if( pe->offset >= 0 ) {
     265           1 :                 if( any )
     266             :                         smart_str_appends( &ret, ", " );
     267             :                 else
     268             :                         smart_str_appends( &ret, "at " );
     269             : 
     270             :                 smart_str_appends( &ret, "offset " );
     271           1 :                 smart_str_append_long( &ret, (zend_long ) pe->offset ); 
     272           1 :                 any = 1;
     273             :         }
     274             : 
     275           2 :         if (pe->preContext[0] != 0 ) {
     276           1 :                 if( any )
     277             :                         smart_str_appends( &ret, ", " );
     278             : 
     279             :                 smart_str_appends( &ret, "after \"" );
     280           1 :                 intl_convert_utf16_to_utf8( &buf, &u8len, pe->preContext, -1, &status );
     281           1 :                 if( U_FAILURE( status ) )
     282             :                 {
     283             :                         smart_str_appends( &ret, "(could not convert parser error pre-context to UTF-8)" );
     284             :                 }
     285             :                 else {
     286           1 :                         smart_str_appendl( &ret, buf, u8len );
     287           1 :                         efree( buf );
     288             :                 }
     289             :                 smart_str_appends( &ret, "\"" );
     290           1 :                 any = 1;
     291             :         }
     292             : 
     293           2 :         if( pe->postContext[0] != 0 )
     294             :         {
     295           2 :                 if( any )
     296             :                         smart_str_appends( &ret, ", " );
     297             : 
     298             :                 smart_str_appends( &ret, "before or at \"" );
     299           2 :                 intl_convert_utf16_to_utf8( &buf, &u8len, pe->postContext, -1, &status );
     300           2 :                 if( U_FAILURE( status ) )
     301             :                 {
     302             :                         smart_str_appends( &ret, "(could not convert parser error post-context to UTF-8)" );
     303             :                 }
     304             :                 else
     305             :                 {
     306           2 :                         smart_str_appendl( &ret, buf, u8len );
     307           2 :                         efree( buf );
     308             :                 }
     309             :                 smart_str_appends( &ret, "\"" );
     310           2 :                 any = 1;
     311             :         }
     312             : 
     313           2 :         if( !any )
     314             :         {
     315             :                 smart_str_free( &ret );
     316             :                 smart_str_appends( &ret, "no parse error" );
     317             :         }
     318             :         
     319             :         smart_str_0( &ret );
     320           2 :         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, 22 Oct 2014 07:24:49 +0000 (27 hours ago)

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