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 157 93.6 %
Date: 2016-08-31 Functions: 19 19 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2016 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        2692 : PHP_FUNCTION(gettype)
      27             : {
      28             :         zval *arg;
      29             : 
      30        2692 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &arg) == FAILURE) {
      31           2 :                 return;
      32             :         }
      33             : 
      34        5380 :         switch (Z_TYPE_P(arg)) {
      35             :                 case IS_NULL:
      36         852 :                         RETVAL_STRING("NULL");
      37         426 :                         break;
      38             : 
      39             :                 case IS_FALSE:
      40             :                 case IS_TRUE:
      41         162 :                         RETVAL_STRING("boolean");
      42          81 :                         break;
      43             : 
      44             :                 case IS_LONG:
      45         568 :                         RETVAL_STRING("integer");
      46         284 :                         break;
      47             : 
      48             :                 case IS_DOUBLE:
      49         124 :                         RETVAL_STRING("double");
      50          62 :                         break;
      51             : 
      52             :                 case IS_STRING:
      53        3378 :                         RETVAL_STRING("string");
      54        1689 :                         break;
      55             : 
      56             :                 case IS_ARRAY:
      57         218 :                         RETVAL_STRING("array");
      58         109 :                         break;
      59             : 
      60             :                 case IS_OBJECT:
      61          58 :                         RETVAL_STRING("object");
      62          29 :                         break;
      63             : 
      64             :                 case IS_RESOURCE:
      65             :                         {
      66          10 :                                 const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(arg));
      67             : 
      68          10 :                                 if (type_name) {
      69          18 :                                         RETVAL_STRING("resource");
      70             :                                 } else {
      71           2 :                                         RETVAL_STRING("resource (closed)");
      72             :                                 }
      73          10 :                                 break;
      74             :                         }
      75             : 
      76             :                 default:
      77           0 :                         RETVAL_STRING("unknown type");
      78             :         }
      79             : }
      80             : /* }}} */
      81             : 
      82             : /* {{{ proto bool settype(mixed var, string type)
      83             :    Set the type of the variable */
      84       45136 : PHP_FUNCTION(settype)
      85             : {
      86             :         zval *var;
      87             :         char *type;
      88       45136 :         size_t type_len = 0;
      89             : 
      90       45136 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "zs", &var, &type, &type_len) == FAILURE) {
      91           2 :                 return;
      92             :         }
      93             : 
      94       90268 :         ZVAL_DEREF(var);
      95       45134 :         if (!strcasecmp(type, "integer")) {
      96          25 :                 convert_to_long(var);
      97       45109 :         } else if (!strcasecmp(type, "int")) {
      98          27 :                 convert_to_long(var);
      99       45082 :         } else if (!strcasecmp(type, "float")) {
     100          14 :                 convert_to_double(var);
     101       45068 :         } else if (!strcasecmp(type, "double")) { /* deprecated */
     102          38 :                 convert_to_double(var);
     103       45030 :         } else if (!strcasecmp(type, "string")) {
     104       89650 :                 convert_to_string(var);
     105         205 :         } else if (!strcasecmp(type, "array")) {
     106          38 :                 convert_to_array(var);
     107         167 :         } else if (!strcasecmp(type, "object")) {
     108          38 :                 convert_to_object(var);
     109         129 :         } else if (!strcasecmp(type, "bool")) {
     110          27 :                 convert_to_boolean(var);
     111         102 :         } else if (!strcasecmp(type, "boolean")) {
     112          25 :                 convert_to_boolean(var);
     113          77 :         } else if (!strcasecmp(type, "null")) {
     114          38 :                 convert_to_null(var);
     115          39 :         } else if (!strcasecmp(type, "resource")) {
     116          38 :                 php_error_docref(NULL, E_WARNING, "Cannot convert to resource type");
     117          38 :                 RETURN_FALSE;
     118             :         } else {
     119           1 :                 php_error_docref(NULL, E_WARNING, "Invalid type");
     120           1 :                 RETURN_FALSE;
     121             :         }
     122       45095 :         RETVAL_TRUE;
     123             : }
     124             : /* }}} */
     125             : 
     126             : /* {{{ proto int intval(mixed var [, int base])
     127             :    Get the integer value of a variable using the optional base for the conversion */
     128        4513 : PHP_FUNCTION(intval)
     129             : {
     130             :         zval *num;
     131        4513 :         zend_long base = 10;
     132             : 
     133        4513 :         if (ZEND_NUM_ARGS() != 1 && ZEND_NUM_ARGS() != 2) {
     134           0 :                 WRONG_PARAM_COUNT;
     135             :         }
     136             : #ifndef FAST_ZPP
     137             :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|l", &num, &base) == FAILURE) {
     138             :                 return;
     139             :         }
     140             : #else
     141        4513 :         ZEND_PARSE_PARAMETERS_START(1, 2)
     142        4513 :                 Z_PARAM_ZVAL(num)
     143        4513 :                 Z_PARAM_OPTIONAL
     144        4571 :                 Z_PARAM_LONG(base)
     145        4513 :         ZEND_PARSE_PARAMETERS_END();
     146             : #endif
     147             : 
     148       13539 :         if (Z_TYPE_P(num) != IS_STRING || base == 10) {
     149        9026 :                 RETVAL_LONG(zval_get_long(num));
     150             :         } else {
     151           0 :                 RETVAL_LONG(ZEND_STRTOL(Z_STRVAL_P(num), NULL, base));
     152             :         }
     153             : }
     154             : /* }}} */
     155             : 
     156             : /* {{{ proto float floatval(mixed var)
     157             :    Get the float value of a variable */
     158         153 : PHP_FUNCTION(floatval)
     159             : {
     160             :         zval *num;
     161             : 
     162         153 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &num) == FAILURE) {
     163           8 :                 return;
     164             :         }
     165             : 
     166         290 :         RETURN_DOUBLE(zval_get_double(num));
     167             : }
     168             : /* }}} */
     169             : 
     170             : /* {{{ proto bool boolval(mixed var)
     171             :    Get the boolean value of a variable */
     172          11 : PHP_FUNCTION(boolval)
     173             : {
     174             :         zval *val;
     175             : 
     176          11 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &val) == FAILURE) {
     177           0 :                 return;
     178             :         }
     179             : 
     180          11 :         RETURN_BOOL(zend_is_true(val));
     181             : }
     182             : /* }}} */
     183             : 
     184             : /* {{{ proto string strval(mixed var)
     185             :    Get the string value of a variable */
     186      101103 : PHP_FUNCTION(strval)
     187             : {
     188             :         zval *num;
     189             : 
     190             : #ifndef FAST_ZPP
     191             :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &num) == FAILURE) {
     192             :                 return;
     193             :         }
     194             : #else
     195      101103 :         ZEND_PARSE_PARAMETERS_START(1, 1)
     196      101099 :                 Z_PARAM_ZVAL(num)
     197      101103 :         ZEND_PARSE_PARAMETERS_END();
     198             : #endif
     199             : 
     200      202197 :         RETVAL_STR(zval_get_string(num));
     201             : }
     202             : /* }}} */
     203             : 
     204          30 : static inline void php_is_type(INTERNAL_FUNCTION_PARAMETERS, int type)
     205             : {
     206             :         zval *arg;
     207             : 
     208             : #ifndef FAST_ZPP
     209             :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &arg) == FAILURE) {
     210             :                 RETURN_FALSE;
     211             :         }
     212             :         ZVAL_DEREF(arg);
     213             : #else
     214          30 :         ZEND_PARSE_PARAMETERS_START(1, 1)
     215          16 :                 Z_PARAM_ZVAL_DEREF(arg)
     216          30 :         ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
     217             : #endif
     218             : 
     219          16 :         if (Z_TYPE_P(arg) == type) {
     220           6 :                 if (type == IS_RESOURCE) {
     221           0 :                         const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(arg));
     222           0 :                         if (!type_name) {
     223           0 :                                 RETURN_FALSE;
     224             :                         }
     225             :                 }
     226           6 :                 RETURN_TRUE;
     227             :         } else {
     228           2 :                 RETURN_FALSE;
     229             :         }
     230             : }
     231             : 
     232             : 
     233             : /* {{{ proto bool is_null(mixed var)
     234             :    Returns true if variable is null
     235             :    Warning: This function is special-cased by zend_compile.c and so is usually bypassed */
     236           2 : PHP_FUNCTION(is_null)
     237             : {
     238           2 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_NULL);
     239           2 : }
     240             : /* }}} */
     241             : 
     242             : /* {{{ proto bool is_resource(mixed var)
     243             :    Returns true if variable is a resource
     244             :    Warning: This function is special-cased by zend_compile.c and so is usually bypassed */
     245           2 : PHP_FUNCTION(is_resource)
     246             : {
     247           2 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_RESOURCE);
     248           2 : }
     249             : /* }}} */
     250             : 
     251             : /* {{{ proto bool is_bool(mixed var)
     252             :    Returns true if variable is a boolean
     253             :    Warning: This function is special-cased by zend_compile.c and so is usually bypassed */
     254           2 : PHP_FUNCTION(is_bool)
     255             : {
     256             :         zval *arg;
     257             : 
     258           2 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &arg) == FAILURE) {
     259           2 :                 RETURN_FALSE;
     260             :         }
     261             : 
     262           0 :         ZVAL_DEREF(arg);
     263           0 :         RETURN_BOOL(Z_TYPE_P(arg) == IS_FALSE || Z_TYPE_P(arg) == IS_TRUE);
     264             : }
     265             : /* }}} */
     266             : 
     267             : /* {{{ proto bool is_int(mixed var)
     268             :    Returns true if variable is an integer
     269             :    Warning: This function is special-cased by zend_compile.c and so is usually bypassed */
     270          14 : PHP_FUNCTION(is_int)
     271             : {
     272          14 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_LONG);
     273          14 : }
     274             : /* }}} */
     275             : 
     276             : /* {{{ proto bool is_float(mixed var)
     277             :    Returns true if variable is float point
     278             :    Warning: This function is special-cased by zend_compile.c and so is usually bypassed */
     279           6 : PHP_FUNCTION(is_float)
     280             : {
     281           6 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_DOUBLE);
     282           6 : }
     283             : /* }}} */
     284             : 
     285             : /* {{{ proto bool is_string(mixed var)
     286             :    Returns true if variable is a string
     287             :    Warning: This function is special-cased by zend_compile.c and so is usually bypassed */
     288           2 : PHP_FUNCTION(is_string)
     289             : {
     290           2 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_STRING);
     291           2 : }
     292             : /* }}} */
     293             : 
     294             : /* {{{ proto bool is_array(mixed var)
     295             :    Returns true if variable is an array
     296             :    Warning: This function is special-cased by zend_compile.c and so is usually bypassed */
     297           2 : PHP_FUNCTION(is_array)
     298             : {
     299           2 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_ARRAY);
     300           2 : }
     301             : /* }}} */
     302             : 
     303             : /* {{{ proto bool is_object(mixed var)
     304             :    Returns true if variable is an object
     305             :    Warning: This function is special-cased by zend_compile.c and so is usually bypassed */
     306           2 : PHP_FUNCTION(is_object)
     307             : {
     308           2 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_OBJECT);
     309           2 : }
     310             : /* }}} */
     311             : 
     312             : /* {{{ proto bool is_numeric(mixed value)
     313             :    Returns true if value is a number or a numeric string */
     314         130 : PHP_FUNCTION(is_numeric)
     315             : {
     316             :         zval *arg;
     317             : 
     318             : #ifndef FAST_ZPP
     319             :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &arg) == FAILURE) {
     320             :                 return;
     321             :         }
     322             : #else
     323         130 :         ZEND_PARSE_PARAMETERS_START(1, 1)
     324         124 :                 Z_PARAM_ZVAL(arg)
     325         130 :         ZEND_PARSE_PARAMETERS_END();
     326             : #endif
     327             : 
     328         248 :         switch (Z_TYPE_P(arg)) {
     329             :                 case IS_LONG:
     330             :                 case IS_DOUBLE:
     331          62 :                         RETURN_TRUE;
     332             :                         break;
     333             : 
     334             :                 case IS_STRING:
     335          98 :                         if (is_numeric_string(Z_STRVAL_P(arg), Z_STRLEN_P(arg), NULL, NULL, 0)) {
     336          18 :                                 RETURN_TRUE;
     337             :                         } else {
     338          31 :                                 RETURN_FALSE;
     339             :                         }
     340             :                         break;
     341             : 
     342             :                 default:
     343          13 :                         RETURN_FALSE;
     344             :                         break;
     345             :         }
     346             : }
     347             : /* }}} */
     348             : 
     349             : /* {{{ proto bool is_scalar(mixed value)
     350             :    Returns true if value is a scalar */
     351          62 : PHP_FUNCTION(is_scalar)
     352             : {
     353             :         zval *arg;
     354             : 
     355             : #ifndef FAST_ZPP
     356             :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &arg) == FAILURE) {
     357             :                 return;
     358             :         }
     359             : #else
     360          62 :         ZEND_PARSE_PARAMETERS_START(1, 1)
     361          59 :                 Z_PARAM_ZVAL(arg)
     362          62 :         ZEND_PARSE_PARAMETERS_END();
     363             : #endif
     364             : 
     365         118 :         switch (Z_TYPE_P(arg)) {
     366             :                 case IS_FALSE:
     367             :                 case IS_TRUE:
     368             :                 case IS_DOUBLE:
     369             :                 case IS_LONG:
     370             :                 case IS_STRING:
     371          37 :                         RETURN_TRUE;
     372             :                         break;
     373             : 
     374             :                 default:
     375          22 :                         RETURN_FALSE;
     376             :                         break;
     377             :         }
     378             : }
     379             : /* }}} */
     380             : 
     381             : /* {{{ proto bool is_callable(mixed var [, bool syntax_only [, string callable_name]])
     382             :    Returns true if var is callable. */
     383         644 : PHP_FUNCTION(is_callable)
     384             : {
     385         644 :         zval *var, *callable_name = NULL;
     386             :         zend_string *name;
     387             :         char *error;
     388             :         zend_bool retval;
     389         644 :         zend_bool syntax_only = 0;
     390         644 :         int check_flags = 0;
     391             : 
     392         644 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|bz/", &var,
     393             :                                                           &syntax_only, &callable_name) == FAILURE) {
     394           2 :                 return;
     395             :         }
     396             : 
     397         642 :         if (syntax_only) {
     398         233 :                 check_flags |= IS_CALLABLE_CHECK_SYNTAX_ONLY;
     399             :         }
     400         642 :         if (ZEND_NUM_ARGS() > 2) {
     401         236 :                 retval = zend_is_callable_ex(var, NULL, check_flags, &name, NULL, &error);
     402         236 :                 zval_dtor(callable_name);
     403             :                 //??? is it necessary to be consistent with old PHP ("\0" support)
     404         236 :                 if (UNEXPECTED(ZSTR_LEN(name) != strlen(ZSTR_VAL(name)))) {
     405           8 :                         ZVAL_STRINGL(callable_name, ZSTR_VAL(name), strlen(ZSTR_VAL(name)));
     406           4 :                         zend_string_release(name);
     407             :                 } else {
     408         232 :                         ZVAL_STR(callable_name, name);
     409             :                 }
     410             :         } else {
     411         406 :                 retval = zend_is_callable_ex(var, NULL, check_flags, NULL, NULL, &error);
     412             :         }
     413         642 :         if (error) {
     414             :                 /* ignore errors */
     415         377 :                 efree(error);
     416             :         }
     417             : 
     418         642 :         RETURN_BOOL(retval);
     419             : }
     420             : /* }}} */
     421             : 
     422             : /* {{{ proto bool is_iterable(mixed var)
     423             :    Returns true if var is iterable (array or instance of Traversable). */
     424           6 : PHP_FUNCTION(is_iterable)
     425             : {
     426             :         zval *var;
     427             :         
     428           6 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &var) == FAILURE) {
     429           0 :                 return;
     430             :         }
     431             :         
     432           6 :         RETURN_BOOL(zend_is_iterable(var));
     433             : }
     434             : /* }}} */
     435             : 
     436             : /*
     437             :  * Local variables:
     438             :  * tab-width: 4
     439             :  * c-basic-offset: 4
     440             :  * End:
     441             :  * vim600: sw=4 ts=4 fdm=marker
     442             :  * vim<600: sw=4 ts=4
     443             :  */

Generated by: LCOV version 1.10

Generated at Wed, 31 Aug 2016 04:11:16 +0000 (19 hours ago)

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