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-07-13 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-2013 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        2519 : PHP_FUNCTION(gettype)
      27             : {
      28             :         zval **arg;
      29             : 
      30        2519 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
      31           2 :                 return;
      32             :         }
      33             : 
      34        2517 :         switch (Z_TYPE_PP(arg)) {
      35             :                 case IS_NULL:
      36         463 :                         RETVAL_STRING("NULL", 1);
      37         463 :                         break;
      38             : 
      39             :                 case IS_BOOL:
      40          92 :                         RETVAL_STRING("boolean", 1);
      41          92 :                         break;
      42             : 
      43             :                 case IS_LONG:
      44         277 :                         RETVAL_STRING("integer", 1);
      45         277 :                         break;
      46             : 
      47             :                 case IS_DOUBLE:
      48          62 :                         RETVAL_STRING("double", 1);
      49          62 :                         break;
      50             :         
      51             :                 case IS_STRING:
      52        1514 :                         RETVAL_STRING("string", 1);
      53        1514 :                         break;
      54             :         
      55             :                 case IS_ARRAY:
      56          82 :                         RETVAL_STRING("array", 1);
      57          82 :                         break;
      58             : 
      59             :                 case IS_OBJECT:
      60          21 :                         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          21 :                         break;
      72             : 
      73             :                 case IS_RESOURCE:
      74             :                         {
      75             :                                 char *type_name;
      76           6 :                                 type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(arg) TSRMLS_CC);
      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       36225 : PHP_FUNCTION(settype)
      92             : {
      93             :         zval **var;
      94             :         char *type;
      95       36225 :         int type_len = 0;
      96             : 
      97       36225 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zs", &var, &type, &type_len) == FAILURE) {
      98           2 :                 return;
      99             :         }
     100             : 
     101       36223 :         if (!strcasecmp(type, "integer")) {
     102          25 :                 convert_to_long(*var);
     103       36198 :         } else if (!strcasecmp(type, "int")) {
     104          27 :                 convert_to_long(*var);
     105       36171 :         } else if (!strcasecmp(type, "float")) {
     106          14 :                 convert_to_double(*var);
     107       36157 :         } else if (!strcasecmp(type, "double")) { /* deprecated */
     108          38 :                 convert_to_double(*var);
     109       36119 :         } else if (!strcasecmp(type, "string")) {
     110       35914 :                 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       36184 :         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        3705 : PHP_FUNCTION(intval)
     135             : {
     136             :         zval **num;
     137             :         long arg_base;
     138             :         int base;
     139             : 
     140        3705 :         switch (ZEND_NUM_ARGS()) {
     141             :                 case 1:
     142        3651 :                         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &num) == FAILURE) {
     143           0 :                                 return;
     144             :                         }
     145        3651 :                         base = 10;
     146        3651 :                         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        7386 :         RETVAL_ZVAL(*num, 1, 0);
     160        3693 :         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         290 :         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         114 :                 RETVAL_ZVAL(*num, 1, 0);
     197             :         }
     198             : }
     199             : /* }}} */
     200             : 
     201      873820 : static void php_is_type(INTERNAL_FUNCTION_PARAMETERS, int type)
     202             : {
     203             :         zval **arg;
     204             : 
     205      873820 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
     206          24 :                 RETURN_FALSE;
     207             :         }
     208             : 
     209      873796 :         if (Z_TYPE_PP(arg) == type) {
     210       49188 :                 if (type == IS_OBJECT) {
     211             :                         zend_class_entry *ce;
     212         823 :                         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         823 :                         ce = Z_OBJCE_PP(arg);
     217         823 :                         if (!strcmp(ce->name, INCOMPLETE_CLASS)) {
     218           1 :                                 RETURN_FALSE;
     219             :                         }
     220             :                 }
     221       49187 :                 if (type == IS_RESOURCE) {
     222             :                         char *type_name;
     223         110 :                         type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(arg) TSRMLS_CC);
     224         110 :                         if (!type_name) {
     225           2 :                                 RETURN_FALSE;
     226             :                         }
     227             :                 }
     228       49185 :                 RETURN_TRUE;
     229             :         } else {
     230      824608 :                 RETURN_FALSE;
     231             :         }
     232             : }
     233             : 
     234             : 
     235             : /* {{{ proto bool is_null(mixed var)
     236             :    Returns true if variable is null */
     237       21340 : PHP_FUNCTION(is_null)
     238             : {
     239       21340 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_NULL);
     240       21340 : }
     241             : /* }}} */
     242             : 
     243             : /* {{{ proto bool is_resource(mixed var)
     244             :    Returns true if variable is a resource */
     245         198 : PHP_FUNCTION(is_resource)
     246             : {
     247         198 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_RESOURCE);
     248         198 : }
     249             : /* }}} */
     250             : 
     251             : /* {{{ proto bool is_bool(mixed var)
     252             :    Returns true if variable is a boolean */
     253         601 : PHP_FUNCTION(is_bool)
     254             : {
     255         601 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_BOOL);
     256         601 : }
     257             : /* }}} */
     258             : 
     259             : /* {{{ proto bool is_long(mixed var)
     260             :    Returns true if variable is a long (integer) */
     261        3058 : PHP_FUNCTION(is_long)
     262             : {
     263        3058 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_LONG);
     264        3058 : }
     265             : /* }}} */
     266             : 
     267             : /* {{{ proto bool is_float(mixed var)
     268             :    Returns true if variable is float point*/
     269         372 : PHP_FUNCTION(is_float)
     270             : {
     271         372 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_DOUBLE);
     272         372 : }
     273             : /* }}} */
     274             : 
     275             : /* {{{ proto bool is_string(mixed var)
     276             :    Returns true if variable is a string */
     277       18090 : PHP_FUNCTION(is_string)
     278             : {
     279       18090 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_STRING);
     280       18090 : }
     281             : /* }}} */
     282             : 
     283             : /* {{{ proto bool is_array(mixed var)
     284             :    Returns true if variable is an array */
     285      829289 : PHP_FUNCTION(is_array)
     286             : {
     287      829289 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_ARRAY);
     288      829289 : }
     289             : /* }}} */
     290             : 
     291             : /* {{{ proto bool is_object(mixed var)
     292             :    Returns true if variable is an object */
     293         872 : PHP_FUNCTION(is_object)
     294             : {
     295         872 :         php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_OBJECT);
     296         872 : }
     297             : /* }}} */
     298             : 
     299             : /* {{{ proto bool is_numeric(mixed value)
     300             :    Returns true if value is a number or a numeric string */
     301         109 : PHP_FUNCTION(is_numeric)
     302             : {
     303             :         zval **arg;
     304             : 
     305         109 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
     306           2 :                 return;
     307             :         }
     308             : 
     309         107 :         switch (Z_TYPE_PP(arg)) {
     310             :                 case IS_LONG:
     311             :                 case IS_DOUBLE:
     312          58 :                         RETURN_TRUE;
     313             :                         break;
     314             : 
     315             :                 case IS_STRING:
     316          36 :                         if (is_numeric_string(Z_STRVAL_PP(arg), Z_STRLEN_PP(arg), NULL, NULL, 0)) {
     317          21 :                                 RETURN_TRUE;
     318             :                         } else {
     319          15 :                                 RETURN_FALSE;
     320             :                         }
     321             :                         break;
     322             : 
     323             :                 default:
     324          13 :                         RETURN_FALSE;
     325             :                         break;
     326             :         }
     327             : }
     328             : /* }}} */
     329             : 
     330             : /* {{{ proto bool is_scalar(mixed value)
     331             :    Returns true if value is a scalar */
     332          62 : PHP_FUNCTION(is_scalar)
     333             : {
     334             :         zval **arg;
     335             : 
     336          62 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
     337           3 :                 return;
     338             :         }
     339             : 
     340          59 :         switch (Z_TYPE_PP(arg)) {
     341             :                 case IS_BOOL:
     342             :                 case IS_DOUBLE:
     343             :                 case IS_LONG:
     344             :                 case IS_STRING:
     345          37 :                         RETURN_TRUE;
     346             :                         break;
     347             : 
     348             :                 default:
     349          22 :                         RETURN_FALSE;
     350             :                         break;
     351             :         }
     352             : }
     353             : /* }}} */
     354             : 
     355             : /* {{{ proto bool is_callable(mixed var [, bool syntax_only [, string callable_name]]) 
     356             :    Returns true if var is callable. */
     357         639 : PHP_FUNCTION(is_callable)
     358             : {
     359         639 :         zval *var, **callable_name = NULL;
     360             :         char *name;
     361             :         char *error;
     362             :         zend_bool retval;
     363         639 :         zend_bool syntax_only = 0;
     364         639 :         int check_flags = 0;
     365             : 
     366         639 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|bZ", &var,
     367             :                                                           &syntax_only, &callable_name) == FAILURE) {
     368           2 :                 return;
     369             :         }
     370             :         
     371         637 :         if (syntax_only) {
     372         233 :                 check_flags |= IS_CALLABLE_CHECK_SYNTAX_ONLY;
     373             :         }
     374         637 :         if (ZEND_NUM_ARGS() > 2) {
     375         236 :                 retval = zend_is_callable_ex(var, NULL, check_flags, &name, NULL, NULL, &error TSRMLS_CC);
     376         236 :                 zval_dtor(*callable_name);
     377         236 :                 ZVAL_STRING(*callable_name, name, 0);
     378             :         } else {
     379         401 :                 retval = zend_is_callable_ex(var, NULL, check_flags, NULL, NULL, NULL, &error TSRMLS_CC);
     380             :         }
     381         637 :         if (error) {
     382             :                 /* ignore errors */
     383         374 :                 efree(error);
     384             :         }
     385             : 
     386         637 :         RETURN_BOOL(retval);
     387             : }
     388             : /* }}} */
     389             : 
     390             : /*
     391             :  * Local variables:
     392             :  * tab-width: 4
     393             :  * c-basic-offset: 4
     394             :  * End:
     395             :  * vim600: sw=4 ts=4 fdm=marker
     396             :  * vim<600: sw=4 ts=4
     397             :  */

Generated by: LCOV version 1.10

Generated at Sun, 13 Jul 2014 23:57:58 +0000 (9 days ago)

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