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/breakiterator - breakiterator_methods.cpp (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 159 196 81.1 %
Date: 2014-09-27 Functions: 21 24 87.5 %
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: Gustavo Lopes <cataphract@php.net>                          |
      14             :    +----------------------------------------------------------------------+
      15             : */
      16             : 
      17             : #ifdef HAVE_CONFIG_H
      18             : #include "config.h"
      19             : #endif
      20             : 
      21             : #include <unicode/brkiter.h>
      22             : #include "codepointiterator_internal.h"
      23             : 
      24             : #include "breakiterator_iterators.h"
      25             : 
      26             : extern "C" {
      27             : #include "../php_intl.h"
      28             : #define USE_BREAKITERATOR_POINTER 1
      29             : #include "breakiterator_class.h"
      30             : #include "../locale/locale.h"
      31             : #include <zend_exceptions.h>
      32             : }
      33             : 
      34             : using PHP::CodePointBreakIterator;
      35             : 
      36           0 : U_CFUNC PHP_METHOD(BreakIterator, __construct)
      37             : {
      38             :         zend_throw_exception( NULL,
      39             :                 "An object of this type cannot be created with the new operator",
      40           0 :                 0 TSRMLS_CC );
      41           0 : }
      42             : 
      43          29 : static void _breakiter_factory(const char *func_name,
      44             :                                                            BreakIterator *(*func)(const Locale&, UErrorCode&),
      45             :                                                            INTERNAL_FUNCTION_PARAMETERS)
      46             : {
      47             :         BreakIterator   *biter;
      48          29 :         const char              *locale_str = NULL;
      49             :         size_t                          dummy;
      50             :         char                    *msg;
      51          29 :         UErrorCode              status = UErrorCode();
      52          29 :         intl_error_reset(NULL TSRMLS_CC);
      53             : 
      54          29 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s!",
      55             :                         &locale_str, &dummy) == FAILURE) {
      56           5 :                 spprintf(&msg, 0, "%s: bad arguments", func_name);
      57           5 :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, msg, 1 TSRMLS_CC);
      58           5 :                 efree(msg);
      59           5 :                 RETURN_NULL();
      60             :         }
      61             : 
      62          24 :         if (locale_str == NULL) {
      63           7 :                 locale_str = intl_locale_get_default(TSRMLS_C);
      64             :         }
      65             : 
      66          24 :         biter = func(Locale::createFromName(locale_str), status);
      67          24 :         intl_error_set_code(NULL, status TSRMLS_CC);
      68          24 :         if (U_FAILURE(status)) {
      69             :                 spprintf(&msg, 0, "%s: error creating BreakIterator",
      70           0 :                                 func_name);
      71           0 :                 intl_error_set_custom_msg(NULL, msg, 1 TSRMLS_CC);
      72           0 :                 efree(msg);
      73           0 :                 RETURN_NULL();
      74             :         }
      75             : 
      76          24 :         breakiterator_object_create(return_value, biter, 1 TSRMLS_CC);
      77             : }
      78             : 
      79          16 : U_CFUNC PHP_FUNCTION(breakiter_create_word_instance)
      80             : {
      81             :         _breakiter_factory("breakiter_create_word_instance",
      82             :                         &BreakIterator::createWordInstance,
      83          16 :                         INTERNAL_FUNCTION_PARAM_PASSTHRU);
      84          16 : }
      85             : 
      86           3 : U_CFUNC PHP_FUNCTION(breakiter_create_line_instance)
      87             : {
      88             :         _breakiter_factory("breakiter_create_line_instance",
      89             :                         &BreakIterator::createLineInstance,
      90           3 :                         INTERNAL_FUNCTION_PARAM_PASSTHRU);
      91           3 : }
      92             : 
      93           3 : U_CFUNC PHP_FUNCTION(breakiter_create_character_instance)
      94             : {
      95             :         _breakiter_factory("breakiter_create_character_instance",
      96             :                         &BreakIterator::createCharacterInstance,
      97           3 :                         INTERNAL_FUNCTION_PARAM_PASSTHRU);
      98           3 : }
      99             : 
     100           4 : U_CFUNC PHP_FUNCTION(breakiter_create_sentence_instance)
     101             : {
     102             :         _breakiter_factory("breakiter_create_sentence_instance",
     103             :                         &BreakIterator::createSentenceInstance,
     104           4 :                         INTERNAL_FUNCTION_PARAM_PASSTHRU);
     105           4 : }
     106             : 
     107           3 : U_CFUNC PHP_FUNCTION(breakiter_create_title_instance)
     108             : {
     109             :         _breakiter_factory("breakiter_create_title_instance",
     110             :                         &BreakIterator::createTitleInstance,
     111           3 :                         INTERNAL_FUNCTION_PARAM_PASSTHRU);
     112           3 : }
     113             : 
     114           6 : U_CFUNC PHP_FUNCTION(breakiter_create_code_point_instance)
     115             : {
     116           6 :         UErrorCode status = UErrorCode();
     117           6 :         intl_error_reset(NULL TSRMLS_CC);
     118             : 
     119           6 :         if (zend_parse_parameters_none() == FAILURE) {
     120             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     121           1 :                         "breakiter_create_code_point_instance: bad arguments", 0 TSRMLS_CC);
     122           1 :                 RETURN_NULL();
     123             :         }
     124             : 
     125           5 :         CodePointBreakIterator *cpbi = new CodePointBreakIterator();
     126           5 :         breakiterator_object_create(return_value, cpbi, 1 TSRMLS_CC);
     127             : }
     128             : 
     129           6 : U_CFUNC PHP_FUNCTION(breakiter_get_text)
     130             : {
     131           6 :         BREAKITER_METHOD_INIT_VARS;
     132           6 :         object = getThis();
     133             : 
     134           6 :         if (zend_parse_parameters_none() == FAILURE) {
     135             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     136           1 :                         "breakiter_get_text: bad arguments", 0 TSRMLS_CC);
     137           1 :                 RETURN_FALSE;
     138             :         }
     139             : 
     140           5 :         BREAKITER_METHOD_FETCH_OBJECT;
     141             : 
     142          10 :         if (Z_ISUNDEF(bio->text)) {
     143           1 :                 RETURN_NULL();
     144             :         } else {
     145           4 :                 ZVAL_COPY(return_value, &bio->text);
     146             :         }
     147             : }
     148             : 
     149          32 : U_CFUNC PHP_FUNCTION(breakiter_set_text)
     150             : {
     151             :         char    *text;
     152             :         size_t          text_len;
     153          32 :         UText   *ut = NULL;
     154             :         zval    *textzv;
     155          32 :         BREAKITER_METHOD_INIT_VARS;
     156          32 :         object = getThis();
     157             : 
     158          32 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
     159             :                         &text, &text_len) == FAILURE) {
     160             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     161           3 :                         "breakiter_set_text: bad arguments", 0 TSRMLS_CC);
     162           3 :                 RETURN_FALSE;
     163             :         }
     164             : 
     165          29 :         int res = zend_get_parameters_ex(1, &textzv);
     166             :         assert(res == SUCCESS);
     167             : 
     168          29 :         BREAKITER_METHOD_FETCH_OBJECT;
     169             : 
     170             :         /* assert it's safe to use text and text_len because zpp changes the
     171             :          * arguments in the stack */
     172             :         assert(text == Z_STRVAL_P(textzv));
     173             : 
     174          29 :         ut = utext_openUTF8(ut, text, text_len, BREAKITER_ERROR_CODE_P(bio));
     175          29 :         INTL_CTOR_CHECK_STATUS(bio, "breakiter_set_text: error opening UText");
     176             : 
     177          29 :         bio->biter->setText(ut, BREAKITER_ERROR_CODE(bio));
     178          29 :         utext_close(ut); /* ICU shallow clones the UText */
     179          29 :         INTL_CTOR_CHECK_STATUS(bio, "breakiter_set_text: error calling "
     180             :                 "BreakIterator::setText()");
     181             : 
     182             :         /* When ICU clones the UText, it does not copy the buffer, so we have to
     183             :          * keep the string buffer around by holding a reference to its zval. This
     184             :          * also allows a faste implementation of getText() */
     185          29 :         zval_ptr_dtor(&bio->text);
     186          29 :         ZVAL_COPY(&bio->text, textzv);
     187             : 
     188          29 :         RETURN_TRUE;
     189             : }
     190             : 
     191          57 : static void _breakiter_no_args_ret_int32(
     192             :                 const char *func_name,
     193             :                 int32_t (BreakIterator::*func)(),
     194             :                 INTERNAL_FUNCTION_PARAMETERS)
     195             : {
     196             :         char    *msg;
     197          57 :         BREAKITER_METHOD_INIT_VARS;
     198          57 :         object = getThis();
     199             : 
     200          57 :         if (zend_parse_parameters_none() == FAILURE) {
     201           3 :                 spprintf(&msg, 0, "%s: bad arguments", func_name);
     202           3 :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, msg, 1 TSRMLS_CC);
     203           3 :                 efree(msg);
     204           3 :                 RETURN_FALSE;
     205             :         }
     206             : 
     207          54 :         BREAKITER_METHOD_FETCH_OBJECT;
     208             : 
     209          54 :         int32_t res = (bio->biter->*func)();
     210             : 
     211          54 :         RETURN_LONG((zend_long)res);
     212             : }
     213             : 
     214          15 : static void _breakiter_int32_ret_int32(
     215             :                 const char *func_name,
     216             :                 int32_t (BreakIterator::*func)(int32_t),
     217             :                 INTERNAL_FUNCTION_PARAMETERS)
     218             : {
     219             :         char    *msg;
     220             :         zend_long       arg;
     221          15 :         BREAKITER_METHOD_INIT_VARS;
     222          15 :         object = getThis();
     223             : 
     224          15 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &arg) == FAILURE) {
     225           6 :                 spprintf(&msg, 0, "%s: bad arguments", func_name);
     226           6 :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, msg, 1 TSRMLS_CC);
     227           6 :                 efree(msg);
     228           6 :                 RETURN_FALSE;
     229             :         }
     230             : 
     231           9 :         BREAKITER_METHOD_FETCH_OBJECT;
     232             : 
     233           9 :         if (arg < INT32_MIN || arg > INT32_MAX) {
     234             :                 spprintf(&msg, 0, "%s: offset argument is outside bounds of "
     235           0 :                                 "a 32-bit wide integer", func_name);
     236           0 :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, msg, 1 TSRMLS_CC);
     237           0 :                 efree(msg);
     238           0 :                 RETURN_FALSE;
     239             :         }
     240             : 
     241           9 :         int32_t res = (bio->biter->*func)((int32_t)arg);
     242             : 
     243           9 :         RETURN_LONG((zend_long)res);
     244             : }
     245             : 
     246           5 : U_CFUNC PHP_FUNCTION(breakiter_first)
     247             : {
     248             :         _breakiter_no_args_ret_int32("breakiter_first",
     249             :                         &BreakIterator::first,
     250           5 :                         INTERNAL_FUNCTION_PARAM_PASSTHRU);
     251           5 : }
     252             : 
     253           4 : U_CFUNC PHP_FUNCTION(breakiter_last)
     254             : {
     255             :         _breakiter_no_args_ret_int32("breakiter_last",
     256             :                         &BreakIterator::last,
     257           4 :                         INTERNAL_FUNCTION_PARAM_PASSTHRU);
     258           4 : }
     259             : 
     260          18 : U_CFUNC PHP_FUNCTION(breakiter_previous)
     261             : {
     262             :         _breakiter_no_args_ret_int32("breakiter_previous",
     263             :                         &BreakIterator::previous,
     264          18 :                         INTERNAL_FUNCTION_PARAM_PASSTHRU);
     265          18 : }
     266             : 
     267          35 : U_CFUNC PHP_FUNCTION(breakiter_next)
     268             : {
     269          35 :         bool no_arg_version = false;
     270             : 
     271          35 :         if (ZEND_NUM_ARGS() == 0) {
     272          29 :                 no_arg_version = true;
     273           6 :         } else if (ZEND_NUM_ARGS() == 1) {
     274             :                 zval *arg;
     275           5 :                 int res = zend_get_parameters_ex(1, &arg);
     276             :                 assert(res == SUCCESS);
     277          10 :                 if (Z_TYPE_P(arg) == IS_NULL) {
     278           1 :                         no_arg_version = true;
     279           1 :                         ZEND_NUM_ARGS() = 0; /* pretend we don't have any argument */
     280             :                 } else {
     281           4 :                         no_arg_version = false;
     282             :                 }
     283             :         }
     284             : 
     285          35 :         if (no_arg_version) {
     286             :                 _breakiter_no_args_ret_int32("breakiter_next",
     287             :                                 &BreakIterator::next,
     288          30 :                                 INTERNAL_FUNCTION_PARAM_PASSTHRU);
     289             :         } else {
     290             :                 _breakiter_int32_ret_int32("breakiter_next",
     291             :                                 &BreakIterator::next,
     292           5 :                                 INTERNAL_FUNCTION_PARAM_PASSTHRU);
     293             :         }
     294          35 : }
     295             : 
     296          33 : U_CFUNC PHP_FUNCTION(breakiter_current)
     297             : {
     298          33 :         BREAKITER_METHOD_INIT_VARS;
     299          33 :         object = getThis();
     300             : 
     301          33 :         if (zend_parse_parameters_none() == FAILURE) {
     302             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     303           1 :                                 "breakiter_current: bad arguments", 0 TSRMLS_CC);
     304           1 :                 RETURN_FALSE;
     305             :         }
     306             : 
     307          32 :         BREAKITER_METHOD_FETCH_OBJECT;
     308             : 
     309          32 :         int32_t res = bio->biter->current();
     310             : 
     311          32 :         RETURN_LONG((zend_long)res);
     312             : }
     313             : 
     314           5 : U_CFUNC PHP_FUNCTION(breakiter_following)
     315             : {
     316             :         _breakiter_int32_ret_int32("breakiter_following",
     317             :                         &BreakIterator::following,
     318           5 :                         INTERNAL_FUNCTION_PARAM_PASSTHRU);
     319           5 : }
     320             : 
     321           5 : U_CFUNC PHP_FUNCTION(breakiter_preceding)
     322             : {
     323             :         _breakiter_int32_ret_int32("breakiter_preceding",
     324             :                         &BreakIterator::preceding,
     325           5 :                         INTERNAL_FUNCTION_PARAM_PASSTHRU);
     326           5 : }
     327             : 
     328           7 : U_CFUNC PHP_FUNCTION(breakiter_is_boundary)
     329             : {
     330             :         zend_long offset;
     331           7 :         BREAKITER_METHOD_INIT_VARS;
     332           7 :         object = getThis();
     333             : 
     334           7 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
     335             :                         &offset) == FAILURE) {
     336             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     337           2 :                                 "breakiter_is_boundary: bad arguments", 0 TSRMLS_CC);
     338           2 :                 RETURN_FALSE;
     339             :         }
     340             : 
     341           5 :         if (offset < INT32_MIN || offset > INT32_MAX) {
     342             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     343             :                                 "breakiter_is_boundary: offset argument is outside bounds of "
     344           0 :                                 "a 32-bit wide integer", 0 TSRMLS_CC);
     345           0 :                 RETURN_FALSE;
     346             :         }
     347             : 
     348           5 :         BREAKITER_METHOD_FETCH_OBJECT;
     349             : 
     350           5 :         UBool res = bio->biter->isBoundary((int32_t)offset);
     351             : 
     352           5 :         RETURN_BOOL((zend_long)res);
     353             : }
     354             : 
     355           5 : U_CFUNC PHP_FUNCTION(breakiter_get_locale)
     356             : {
     357             :         zend_long       locale_type;
     358           5 :         BREAKITER_METHOD_INIT_VARS;
     359           5 :         object = getThis();
     360             : 
     361           5 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &locale_type) == FAILURE) {
     362             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     363           3 :                         "breakiter_get_locale: bad arguments", 0 TSRMLS_CC);
     364           3 :                 RETURN_FALSE;
     365             :         }
     366             : 
     367           2 :         if (locale_type != ULOC_ACTUAL_LOCALE && locale_type != ULOC_VALID_LOCALE) {
     368             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     369           0 :                         "breakiter_get_locale: invalid locale type", 0 TSRMLS_CC);
     370           0 :                 RETURN_FALSE;
     371             :         }
     372             : 
     373           2 :         BREAKITER_METHOD_FETCH_OBJECT;
     374             : 
     375             :         Locale locale = bio->biter->getLocale((ULocDataLocaleType)locale_type,
     376           2 :                 BREAKITER_ERROR_CODE(bio));
     377           2 :         INTL_METHOD_CHECK_STATUS(bio,
     378             :                 "breakiter_get_locale: Call to ICU method has failed");
     379             : 
     380           4 :         RETURN_STRING(locale.getName());
     381             : }
     382             : 
     383           9 : U_CFUNC PHP_FUNCTION(breakiter_get_parts_iterator)
     384             : {
     385           9 :         zend_long key_type = 0;
     386           9 :         BREAKITER_METHOD_INIT_VARS;
     387           9 :         object = getThis();
     388             : 
     389           9 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &key_type) == FAILURE) {
     390             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     391           2 :                         "breakiter_get_parts_iterator: bad arguments", 0 TSRMLS_CC);
     392           2 :                 RETURN_FALSE;
     393             :         }
     394             : 
     395           7 :         if (key_type != PARTS_ITERATOR_KEY_SEQUENTIAL
     396             :                         && key_type != PARTS_ITERATOR_KEY_LEFT
     397             :                         && key_type != PARTS_ITERATOR_KEY_RIGHT) {
     398             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     399           1 :                         "breakiter_get_parts_iterator: bad key type", 0 TSRMLS_CC);
     400           1 :                 RETURN_FALSE;
     401             :         }
     402             : 
     403           6 :         BREAKITER_METHOD_FETCH_OBJECT;
     404             : 
     405             :         IntlIterator_from_BreakIterator_parts(
     406           6 :                 object, return_value, (parts_iter_key_type)key_type TSRMLS_CC);
     407             : }
     408             : 
     409           0 : U_CFUNC PHP_FUNCTION(breakiter_get_error_code)
     410             : {
     411           0 :         BREAKITER_METHOD_INIT_VARS;
     412           0 :         object = getThis();
     413             : 
     414           0 :         if (zend_parse_parameters_none() == FAILURE) {
     415             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     416           0 :                         "breakiter_get_error_code: bad arguments", 0 TSRMLS_CC);
     417           0 :                 RETURN_FALSE;
     418             :         }
     419             : 
     420             :         /* Fetch the object (without resetting its last error code ). */
     421           0 :         bio = Z_INTL_BREAKITERATOR_P(object);
     422           0 :         if (bio == NULL)
     423           0 :                 RETURN_FALSE;
     424             : 
     425           0 :         RETURN_LONG((zend_long)BREAKITER_ERROR_CODE(bio));
     426             : }
     427             : 
     428           0 : U_CFUNC PHP_FUNCTION(breakiter_get_error_message)
     429             : {
     430           0 :         zend_string* message = NULL;
     431           0 :         BREAKITER_METHOD_INIT_VARS;
     432           0 :         object = getThis();
     433             : 
     434           0 :         if (zend_parse_parameters_none() == FAILURE) {
     435             :                 intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
     436           0 :                         "breakiter_get_error_message: bad arguments", 0 TSRMLS_CC );
     437           0 :                 RETURN_FALSE;
     438             :         }
     439             : 
     440             : 
     441             :         /* Fetch the object (without resetting its last error code ). */
     442           0 :         bio = Z_INTL_BREAKITERATOR_P(object);
     443           0 :         if (bio == NULL)
     444           0 :                 RETURN_FALSE;
     445             : 
     446             :         /* Return last error message. */
     447           0 :         message = intl_error_get_message(BREAKITER_ERROR_P(bio) TSRMLS_CC);
     448           0 :         RETURN_STR(message);
     449             : }

Generated by: LCOV version 1.10

Generated at Sat, 27 Sep 2014 16:43:10 +0000 (4 days ago)

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