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/ctype - ctype.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 27 27 100.0 %
Date: 2014-10-22 Functions: 12 12 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2014 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Author: Hartmut Holzgraefe <hholzgra@php.net>                        |
      16             :    +----------------------------------------------------------------------+
      17             :  */
      18             : 
      19             : #ifdef HAVE_CONFIG_H
      20             : #include "config.h"
      21             : #endif
      22             : 
      23             : #include "php.h"
      24             : #include "php_ini.h"
      25             : #include "php_ctype.h"
      26             : #include "SAPI.h"
      27             : #include "ext/standard/info.h"
      28             : 
      29             : #include <ctype.h>
      30             : 
      31             : #if HAVE_CTYPE
      32             : 
      33             : static PHP_MINFO_FUNCTION(ctype);
      34             : 
      35             : static PHP_FUNCTION(ctype_alnum);
      36             : static PHP_FUNCTION(ctype_alpha);
      37             : static PHP_FUNCTION(ctype_cntrl);
      38             : static PHP_FUNCTION(ctype_digit);
      39             : static PHP_FUNCTION(ctype_lower);
      40             : static PHP_FUNCTION(ctype_graph);
      41             : static PHP_FUNCTION(ctype_print);
      42             : static PHP_FUNCTION(ctype_punct);
      43             : static PHP_FUNCTION(ctype_space);
      44             : static PHP_FUNCTION(ctype_upper);
      45             : static PHP_FUNCTION(ctype_xdigit);
      46             : 
      47             : /* {{{ arginfo */
      48             : ZEND_BEGIN_ARG_INFO(arginfo_ctype_alnum, 0)
      49             :         ZEND_ARG_INFO(0, text)
      50             : ZEND_END_ARG_INFO()
      51             : 
      52             : ZEND_BEGIN_ARG_INFO(arginfo_ctype_alpha, 0)
      53             :         ZEND_ARG_INFO(0, text)
      54             : ZEND_END_ARG_INFO()
      55             : 
      56             : ZEND_BEGIN_ARG_INFO(arginfo_ctype_cntrl, 0)
      57             :         ZEND_ARG_INFO(0, text)
      58             : ZEND_END_ARG_INFO()
      59             : 
      60             : ZEND_BEGIN_ARG_INFO(arginfo_ctype_digit, 0)
      61             :         ZEND_ARG_INFO(0, text)
      62             : ZEND_END_ARG_INFO()
      63             : 
      64             : ZEND_BEGIN_ARG_INFO(arginfo_ctype_lower, 0)
      65             :         ZEND_ARG_INFO(0, text)
      66             : ZEND_END_ARG_INFO()
      67             : 
      68             : ZEND_BEGIN_ARG_INFO(arginfo_ctype_graph, 0)
      69             :         ZEND_ARG_INFO(0, text)
      70             : ZEND_END_ARG_INFO()
      71             : 
      72             : ZEND_BEGIN_ARG_INFO(arginfo_ctype_print, 0)
      73             :         ZEND_ARG_INFO(0, text)
      74             : ZEND_END_ARG_INFO()
      75             : 
      76             : ZEND_BEGIN_ARG_INFO(arginfo_ctype_punct, 0)
      77             :         ZEND_ARG_INFO(0, text)
      78             : ZEND_END_ARG_INFO()
      79             : 
      80             : ZEND_BEGIN_ARG_INFO(arginfo_ctype_space, 0)
      81             :         ZEND_ARG_INFO(0, text)
      82             : ZEND_END_ARG_INFO()
      83             : 
      84             : ZEND_BEGIN_ARG_INFO(arginfo_ctype_upper, 0)
      85             :         ZEND_ARG_INFO(0, text)
      86             : ZEND_END_ARG_INFO()
      87             : 
      88             : ZEND_BEGIN_ARG_INFO(arginfo_ctype_xdigit, 0)
      89             :         ZEND_ARG_INFO(0, text)
      90             : ZEND_END_ARG_INFO()
      91             : 
      92             : /* }}} */
      93             : 
      94             : /* {{{ ctype_functions[]
      95             :  * Every user visible function must have an entry in ctype_functions[].
      96             :  */
      97             : static const zend_function_entry ctype_functions[] = {
      98             :         PHP_FE(ctype_alnum,     arginfo_ctype_alnum)
      99             :         PHP_FE(ctype_alpha,     arginfo_ctype_alpha)
     100             :         PHP_FE(ctype_cntrl,     arginfo_ctype_cntrl)
     101             :         PHP_FE(ctype_digit,     arginfo_ctype_digit)
     102             :         PHP_FE(ctype_lower,     arginfo_ctype_lower)
     103             :         PHP_FE(ctype_graph,     arginfo_ctype_graph)
     104             :         PHP_FE(ctype_print,     arginfo_ctype_print)
     105             :         PHP_FE(ctype_punct,     arginfo_ctype_punct)
     106             :         PHP_FE(ctype_space,     arginfo_ctype_space)
     107             :         PHP_FE(ctype_upper,     arginfo_ctype_upper)
     108             :         PHP_FE(ctype_xdigit,    arginfo_ctype_xdigit)
     109             :         PHP_FE_END
     110             : };
     111             : /* }}} */
     112             : 
     113             : /* {{{ ctype_module_entry
     114             :  */
     115             : zend_module_entry ctype_module_entry = {
     116             :         STANDARD_MODULE_HEADER,
     117             :         "ctype",
     118             :         ctype_functions,
     119             :         NULL,
     120             :         NULL,
     121             :         NULL,
     122             :         NULL,
     123             :         PHP_MINFO(ctype),
     124             :     NO_VERSION_YET,
     125             :         STANDARD_MODULE_PROPERTIES
     126             : };
     127             : /* }}} */
     128             : 
     129             : #ifdef COMPILE_DL_CTYPE
     130             : ZEND_GET_MODULE(ctype)
     131             : #endif
     132             : 
     133             : /* {{{ PHP_MINFO_FUNCTION
     134             :  */
     135         143 : static PHP_MINFO_FUNCTION(ctype)
     136             : {
     137         143 :         php_info_print_table_start();
     138         143 :         php_info_print_table_row(2, "ctype functions", "enabled");
     139         143 :         php_info_print_table_end();
     140         143 : }
     141             : /* }}} */
     142             : 
     143             : /* {{{ ctype
     144             :  */
     145             : #define CTYPE(iswhat) \
     146             :         zval *c, tmp; \
     147             :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &c) == FAILURE) \
     148             :                 return; \
     149             :         if (Z_TYPE_P(c) == IS_LONG) { \
     150             :                 if (Z_LVAL_P(c) <= 255 && Z_LVAL_P(c) >= 0) { \
     151             :                         RETURN_BOOL(iswhat(Z_LVAL_P(c))); \
     152             :                 } else if (Z_LVAL_P(c) >= -128 && Z_LVAL_P(c) < 0) { \
     153             :                         RETURN_BOOL(iswhat(Z_LVAL_P(c) + 256)); \
     154             :                 } \
     155             :                 tmp = *c; \
     156             :                 zval_copy_ctor(&tmp); \
     157             :                 convert_to_string(&tmp); \
     158             :         } else { \
     159             :                 tmp = *c; \
     160             :         } \
     161             :         if (Z_TYPE(tmp) == IS_STRING) { \
     162             :                 char *p = Z_STRVAL(tmp), *e = Z_STRVAL(tmp) + Z_STRLEN(tmp); \
     163             :                 if (e == p) {   \
     164             :                         if (Z_TYPE_P(c) == IS_LONG) zval_dtor(&tmp); \
     165             :                         RETURN_FALSE;   \
     166             :                 }       \
     167             :                 while (p < e) { \
     168             :                         if(!iswhat((int)*(unsigned char *)(p++))) { \
     169             :                                 if (Z_TYPE_P(c) == IS_LONG) zval_dtor(&tmp); \
     170             :                                 RETURN_FALSE; \
     171             :                         } \
     172             :                 } \
     173             :                 if (Z_TYPE_P(c) == IS_LONG) zval_dtor(&tmp); \
     174             :                 RETURN_TRUE; \
     175             :         } else { \
     176             :                 RETURN_FALSE; \
     177             :         } \
     178             : 
     179             : /* }}} */
     180             : 
     181             : /* {{{ proto bool ctype_alnum(mixed c)
     182             :    Checks for alphanumeric character(s) */
     183        1468 : static PHP_FUNCTION(ctype_alnum)
     184             : {
     185        4584 :         CTYPE(isalnum);
     186             : }
     187             : /* }}} */
     188             : 
     189             : /* {{{ proto bool ctype_alpha(mixed c)
     190             :    Checks for alphabetic character(s) */
     191        1468 : static PHP_FUNCTION(ctype_alpha)
     192             : {
     193        4584 :         CTYPE(isalpha);
     194             : }
     195             : /* }}} */
     196             : 
     197             : /* {{{ proto bool ctype_cntrl(mixed c)
     198             :    Checks for control character(s) */
     199        1475 : static PHP_FUNCTION(ctype_cntrl)
     200             : {
     201        4619 :         CTYPE(iscntrl);
     202             : }
     203             : /* }}} */
     204             : 
     205             : /* {{{ proto bool ctype_digit(mixed c)
     206             :    Checks for numeric character(s) */
     207        1477 : static PHP_FUNCTION(ctype_digit)
     208             : {
     209        4630 :         CTYPE(isdigit);
     210             : }
     211             : /* }}} */
     212             : 
     213             : /* {{{ proto bool ctype_lower(mixed c)
     214             :    Checks for lowercase character(s)  */
     215        1471 : static PHP_FUNCTION(ctype_lower)
     216             : {
     217        4599 :         CTYPE(islower);
     218             : }
     219             : /* }}} */
     220             : 
     221             : /* {{{ proto bool ctype_graph(mixed c)
     222             :    Checks for any printable character(s) except space */
     223        1473 : static PHP_FUNCTION(ctype_graph)
     224             : {
     225        4609 :         CTYPE(isgraph);
     226             : }
     227             : /* }}} */
     228             : 
     229             : /* {{{ proto bool ctype_print(mixed c)
     230             :    Checks for printable character(s) */
     231        1468 : static PHP_FUNCTION(ctype_print)
     232             : {
     233        4582 :         CTYPE(isprint);
     234             : }
     235             : /* }}} */
     236             : 
     237             : /* {{{ proto bool ctype_punct(mixed c)
     238             :    Checks for any printable character which is not whitespace or an alphanumeric character */
     239        1470 : static PHP_FUNCTION(ctype_punct)
     240             : {
     241        4597 :         CTYPE(ispunct);
     242             : }
     243             : /* }}} */
     244             : 
     245             : /* {{{ proto bool ctype_space(mixed c)
     246             :    Checks for whitespace character(s)*/
     247        1474 : static PHP_FUNCTION(ctype_space)
     248             : {
     249        4605 :         CTYPE(isspace);
     250             : }
     251             : /* }}} */
     252             : 
     253             : /* {{{ proto bool ctype_upper(mixed c)
     254             :    Checks for uppercase character(s) */
     255        1471 : static PHP_FUNCTION(ctype_upper)
     256             : {
     257        4599 :         CTYPE(isupper);
     258             : }
     259             : /* }}} */
     260             : 
     261             : /* {{{ proto bool ctype_xdigit(mixed c)
     262             :    Checks for character(s) representing a hexadecimal digit */
     263        1478 : static PHP_FUNCTION(ctype_xdigit)
     264             : {
     265        4613 :         CTYPE(isxdigit);
     266             : }
     267             : /* }}} */
     268             : 
     269             : #endif  /* HAVE_CTYPE */
     270             : 
     271             : /*
     272             :  * Local variables:
     273             :  * tab-width: 4
     274             :  * c-basic-offset: 4
     275             :  * End:
     276             :  * vim600: sw=4 ts=4 fdm=marker
     277             :  * vim<600: sw=4 ts=4
     278             :  */

Generated by: LCOV version 1.10

Generated at Wed, 22 Oct 2014 07:24:46 +0000 (33 hours ago)

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