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/standard - type.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 147 150 98.0 %
Date: 2014-09-21 Functions: 17 17 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       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: Rasmus Lerdorf <rasmus@php.net>                              |
      16             :    +----------------------------------------------------------------------+
      17             : */
      18             : 
      19             : /* $Id$ */
      20             : 
      21             : #include "php.h"
      22             : #include "php_incomplete_class.h"
      23             : 
      24             : /* {{{ proto string gettype(mixed var)
      25             :    Returns the type of the variable */
      26        2685 : PHP_FUNCTION(gettype)
      27             : {
      28             :         zval **arg;
      29             : 
      30        2685 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
      31           2 :                 return;
      32             :         }
      33             : 
      34        2683 :         switch (Z_TYPE_PP(arg)) {
      35             :                 case IS_NULL:
      36         459 :                         RETVAL_STRING("NULL", 1);
      37         459 :                         break;
      38             : 
      39             :                 case IS_BOOL:
      40          91 :                         RETVAL_STRING("boolean", 1);
      41          91 :                         break;
      42             : 
      43             :                 case IS_LONG:
      44         280 :                         RETVAL_STRING("integer", 1);
      45         280 :                         break;
      46             : 
      47             :                 case IS_DOUBLE:
      48          62 :                         RETVAL_STRING("double", 1);
      49          62 :                         break;
      50             :         
      51             :                 case IS_STRING:
      52        1659 :                         RETVAL_STRING("string", 1);
      53        1659 :                         break;
      54             :         
      55             :                 case IS_ARRAY:
      56         101 :                         RETVAL_STRING("array", 1);
      57         101 :                         break;
      58             : 
      59             :                 case IS_OBJECT:
      60          25 :                         RETVAL_STRING("object", 1);
      61             :                 /*
      62             :                    {
      63             :                    char *result;
      64             :                    int res_len;
      65             : 
      66             :                    res_len = sizeof("object of type ")-1 + Z_OBJCE_P(arg)->name_length;
      67             :                    spprintf(&result, 0, "object of type %s", Z_OBJCE_P(arg)->name);
      68             :                    RETVAL_STRINGL(result, res_len, 0);
      69             :                    }
      70             :                  */
      71          25 :                         break;
      72             : 
      73             :                 case IS_RESOURCE:
      74             :                         {
      75           6 :                                 const char *type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(arg) TSRMLS_CC);
      76             : 
      77           6 :                                 if (type_name) {
      78           5 :                                         RETVAL_STRING("resource", 1);
      79           5 :                                         break;
      80             :                                 }
      81             :                         }
      82             : 
      83             :                 default:
      84           1 :                         RETVAL_STRING("unknown type", 1);
      85             :         }
      86             : }
      87             : /* }}} */
      88             : 
      89             : /* {{{ proto bool settype(mixed var, string type)
      90             :    Set the type of the variable */
      91       38089 : PHP_FUNCTION(settype)
      92             : {
      93             :         zval **var;
      94             :         char *type;
      95       38089 :         int type_len = 0;
      96             : 
      97       38089 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zs", &var, &type, &type_len) == FAILURE) {
      98           2 :                 return;
      99             :         }
     100             : 
     101       38087 :         if (!strcasecmp(type, "integer")) {
     102          25 :                 convert_to_long(*var);
     103       38062 :         } else if (!strcasecmp(type, "int")) {
     104          27 :                 convert_to_long(*var);
     105       38035 :         } else if (!strcasecmp(type, "float")) {
     106          14 :                 convert_to_double(*var);
     107       38021 :         } else if (!strcasecmp(type, "double")) { /* deprecated */
     108          38 :                 convert_to_double(*var);
     109       37983 :         } else if (!strcasecmp(type, "string")) {
     110       37778 :                 convert_to_string(*var);
     111         205 :         } else if (!strcasecmp(type, "array")) {
     112          38 :                 convert_to_array(*var);
     113         167 :         } else if (!strcasecmp(type, "object")) {
     114          38 :                 convert_to_object(*var);
     115         129 :         } else if (!strcasecmp(type, "bool")) {
     116          27 :                 convert_to_boolean(*var);
     117         102 :         } else if (!strcasecmp(type, "boolean")) {
     118          25 :                 convert_to_boolean(*var);
     119          77 :         } else if (!strcasecmp(type, "null")) {
     120          38 :                 convert_to_null(*var);
     121          39 :         } else if (!strcasecmp(type, "resource")) {
     122          38 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot convert to resource type");
     123          38 :                 RETURN_FALSE;
     124             :         } else {
     125           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid type");
     126           1 :                 RETURN_FALSE;
     127             :         }
     128       38048 :         RETVAL_TRUE;
     129             : }
     130             : /* }}} */
     131             : 
     132             : /* {{{ proto int intval(mixed var [, int base])
     133             :    Get the integer value of a variable using the optional base for the conversion */
     134        3729 : PHP_FUNCTION(intval)
     135             : {
     136             :         zval **num;
     137             :         long arg_base;
     138             :         int base;
     139             : 
     140        3729 :         switch (ZEND_NUM_ARGS()) {
     141             :                 case 1:
     142        3675 :                         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &num) == FAILURE) {
     143           0 :                                 return;
     144             :                         }
     145        3675 :                         base = 10;
     146        3675 :                         break;
     147             : 
     148             :                 case 2:
     149          54 :                         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zl", &num, &arg_base) == FAILURE) {
     150          12 :                                 return;
     151             :                         }
     152          42 :                         base = arg_base;
     153          42 :                         break;
     154             : 
     155             :                 default:
     156           0 :                         WRONG_PARAM_COUNT;
     157             :         }
     158             : 
     159       11151 :         RETVAL_ZVAL(*num, 1, 0);
     160        3717 :         convert_to_long_base(return_value, base);
     161             : }
     162             : /* }}} */
     163             : 
     164             : /* {{{ proto float floatval(mixed var)
     165             :    Get the float value of a variable */
     166         153 : PHP_FUNCTION(floatval)
     167             : {
     168             :         zval **num;
     169             : 
     170         153 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &num) == FAILURE) {
     171           8 :                 return;
     172             :         }
     173             : 
     174         435 :         RETVAL_ZVAL(*num, 1, 0);
     175         145 :         convert_to_double(return_value);
     176             : }
     177             : /* }}} */
     178             : 
     179             : /* {{{ proto string strval(mixed var)
     180             :    Get the string value of a variable */
     181      100729 : PHP_FUNCTION(strval)
     182             : {
     183             :         zval **num, *tmp;
     184             :         zval expr_copy;
     185             :         int use_copy;
     186             : 
     187      100729 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &num) == FAILURE) {
     188           4 :                 return;
     189             :         }
     190             : 
     191      100725 :         zend_make_printable_zval(*num, &expr_copy, &use_copy);
     192      100724 :         if (use_copy) {
     193      100667 :                 tmp = &expr_copy;
     194      201334 :                 RETVAL_ZVAL(tmp, 0, 0);
     195             :         } else {
     196         171 :                 RETVAL_ZVAL(*num, 1, 0);
     197             :         }
     198             : }
     199             : /* }}} */
     200             : 
     201      970166 : static void php_is_type(INTERNAL_FUNCTION_PARAMETERS, int type)
     202             : {
     203             :         zval **arg;
     204             : 
     205      970166 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
     206          24 :                 RETURN_FALSE;
     207             :         }
     208             : 
     209      970142 :         if (Z_TYPE_PP(arg) == type) {
     210       49602 :                 if (type == IS_OBJECT) {
     211             :                         zend_class_entry *ce;
     212         822 :                         if(Z_OBJ_HT_PP(arg)->get_class_entry == NULL) {
     213             :                         /* if there's no get_class_entry it's not a PHP object, so it can't be INCOMPLETE_CLASS */
     214           0 :                                 RETURN_TRUE;
     215             :                         }
     216         822 :                         ce = Z_OBJCE_PP(arg);
     217         822 :                         if (!strcmp(ce->name, INCOMPLETE_CLASS)) {
     218           1 :                                 RETURN_FALSE;
     219             :                         }
     220             :                 }
     221       49601 :                 if (type == IS_RESOURCE) {
     222         114 :                         const char *type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(arg) TSRMLS_CC);
     223         114 :                         if (!type_name) {
     224           2 :                                 RETURN_FALSE;
     225             :                         }
     226             :                 }
     227       49599 :                 RETURN_TRUE;
     228             :         } else {
     229      920540 :                 RETURN_FALSE;
     230             :         }
     231             : }
     232             : 
     233             : 
     234             : /* {{{ proto bool is_null(mixed var)
     235             :    Returns true if variable is null */
     236       22290 : PHP_FUNCTION(is_null)
     237             : {
     238       22290 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_NULL);
     239       22290 : }
     240             : /* }}} */
     241             : 
     242             : /* {{{ proto bool is_resource(mixed var)
     243             :    Returns true if variable is a resource */
     244         202 : PHP_FUNCTION(is_resource)
     245             : {
     246         202 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_RESOURCE);
     247         202 : }
     248             : /* }}} */
     249             : 
     250             : /* {{{ proto bool is_bool(mixed var)
     251             :    Returns true if variable is a boolean */
     252         601 : PHP_FUNCTION(is_bool)
     253             : {
     254         601 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_BOOL);
     255         601 : }
     256             : /* }}} */
     257             : 
     258             : /* {{{ proto bool is_long(mixed var)
     259             :    Returns true if variable is a long (integer) */
     260        3058 : PHP_FUNCTION(is_long)
     261             : {
     262        3058 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_LONG);
     263        3058 : }
     264             : /* }}} */
     265             : 
     266             : /* {{{ proto bool is_float(mixed var)
     267             :    Returns true if variable is float point*/
     268         372 : PHP_FUNCTION(is_float)
     269             : {
     270         372 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_DOUBLE);
     271         372 : }
     272             : /* }}} */
     273             : 
     274             : /* {{{ proto bool is_string(mixed var)
     275             :    Returns true if variable is a string */
     276       19058 : PHP_FUNCTION(is_string)
     277             : {
     278       19058 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_STRING);
     279       19058 : }
     280             : /* }}} */
     281             : 
     282             : /* {{{ proto bool is_array(mixed var)
     283             :    Returns true if variable is an array */
     284      923718 : PHP_FUNCTION(is_array)
     285             : {
     286      923718 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_ARRAY);
     287      923718 : }
     288             : /* }}} */
     289             : 
     290             : /* {{{ proto bool is_object(mixed var)
     291             :    Returns true if variable is an object */
     292         867 : PHP_FUNCTION(is_object)
     293             : {
     294         867 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_OBJECT);
     295         867 : }
     296             : /* }}} */
     297             : 
     298             : /* {{{ proto bool is_numeric(mixed value)
     299             :    Returns true if value is a number or a numeric string */
     300         109 : PHP_FUNCTION(is_numeric)
     301             : {
     302             :         zval **arg;
     303             : 
     304         109 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
     305           2 :                 return;
     306             :         }
     307             : 
     308         107 :         switch (Z_TYPE_PP(arg)) {
     309             :                 case IS_LONG:
     310             :                 case IS_DOUBLE:
     311          58 :                         RETURN_TRUE;
     312             :                         break;
     313             : 
     314             :                 case IS_STRING:
     315          36 :                         if (is_numeric_string(Z_STRVAL_PP(arg), Z_STRLEN_PP(arg), NULL, NULL, 0)) {
     316          20 :                                 RETURN_TRUE;
     317             :                         } else {
     318          16 :                                 RETURN_FALSE;
     319             :                         }
     320             :                         break;
     321             : 
     322             :                 default:
     323          13 :                         RETURN_FALSE;
     324             :                         break;
     325             :         }
     326             : }
     327             : /* }}} */
     328             : 
     329             : /* {{{ proto bool is_scalar(mixed value)
     330             :    Returns true if value is a scalar */
     331          62 : PHP_FUNCTION(is_scalar)
     332             : {
     333             :         zval **arg;
     334             : 
     335          62 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
     336           3 :                 return;
     337             :         }
     338             : 
     339          59 :         switch (Z_TYPE_PP(arg)) {
     340             :                 case IS_BOOL:
     341             :                 case IS_DOUBLE:
     342             :                 case IS_LONG:
     343             :                 case IS_STRING:
     344          37 :                         RETURN_TRUE;
     345             :                         break;
     346             : 
     347             :                 default:
     348          22 :                         RETURN_FALSE;
     349             :                         break;
     350             :         }
     351             : }
     352             : /* }}} */
     353             : 
     354             : /* {{{ proto bool is_callable(mixed var [, bool syntax_only [, string callable_name]]) 
     355             :    Returns true if var is callable. */
     356         641 : PHP_FUNCTION(is_callable)
     357             : {
     358         641 :         zval *var, **callable_name = NULL;
     359             :         char *name;
     360             :         char *error;
     361             :         zend_bool retval;
     362         641 :         zend_bool syntax_only = 0;
     363         641 :         int check_flags = 0;
     364             : 
     365         641 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|bZ", &var,
     366             :                                                           &syntax_only, &callable_name) == FAILURE) {
     367           2 :                 return;
     368             :         }
     369             :         
     370         639 :         if (syntax_only) {
     371         233 :                 check_flags |= IS_CALLABLE_CHECK_SYNTAX_ONLY;
     372             :         }
     373         639 :         if (ZEND_NUM_ARGS() > 2) {
     374         236 :                 retval = zend_is_callable_ex(var, NULL, check_flags, &name, NULL, NULL, &error TSRMLS_CC);
     375         236 :                 zval_dtor(*callable_name);
     376         236 :                 ZVAL_STRING(*callable_name, name, 0);
     377             :         } else {
     378         403 :                 retval = zend_is_callable_ex(var, NULL, check_flags, NULL, NULL, NULL, &error TSRMLS_CC);
     379             :         }
     380         639 :         if (error) {
     381             :                 /* ignore errors */
     382         376 :                 efree(error);
     383             :         }
     384             : 
     385         639 :         RETURN_BOOL(retval);
     386             : }
     387             : /* }}} */
     388             : 
     389             : /*
     390             :  * Local variables:
     391             :  * tab-width: 4
     392             :  * c-basic-offset: 4
     393             :  * End:
     394             :  * vim600: sw=4 ts=4 fdm=marker
     395             :  * vim<600: sw=4 ts=4
     396             :  */

Generated by: LCOV version 1.10

Generated at Sun, 21 Sep 2014 15:27:45 +0000 (26 hours ago)

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