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 - Zend - zend_ini_parser.y (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 144 155 92.9 %
Date: 2014-10-22 Functions: 8 8 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : %{
       2             : /*
       3             :    +----------------------------------------------------------------------+
       4             :    | Zend Engine                                                          |
       5             :    +----------------------------------------------------------------------+
       6             :    | Copyright (c) 1998-2014 Zend Technologies Ltd. (http://www.zend.com) |
       7             :    +----------------------------------------------------------------------+
       8             :    | This source file is subject to version 2.00 of the Zend license,     |
       9             :    | that is bundled with this package in the file LICENSE, and is        |
      10             :    | available through the world-wide-web at the following url:           |
      11             :    | http://www.zend.com/license/2_00.txt.                                |
      12             :    | If you did not receive a copy of the Zend license and are unable to  |
      13             :    | obtain it through the world-wide-web, please send a note to          |
      14             :    | license@zend.com so we can mail you a copy immediately.              |
      15             :    +----------------------------------------------------------------------+
      16             :    | Authors: Zeev Suraski <zeev@zend.com>                                |
      17             :    |          Jani Taskinen <jani@php.net>                                |
      18             :    +----------------------------------------------------------------------+
      19             : */
      20             : 
      21             : /* $Id$ */
      22             : 
      23             : #define DEBUG_CFG_PARSER 0
      24             : 
      25             : #include "zend.h"
      26             : #include "zend_API.h"
      27             : #include "zend_ini.h"
      28             : #include "zend_constants.h"
      29             : #include "zend_ini_scanner.h"
      30             : #include "zend_extensions.h"
      31             : 
      32             : #define YYERROR_VERBOSE
      33             : #define YYSTYPE zval
      34             : 
      35             : #ifdef ZTS
      36             : #define YYPARSE_PARAM tsrm_ls
      37             : #define YYLEX_PARAM tsrm_ls
      38             : int ini_parse(void *arg);
      39             : #else
      40             : int ini_parse(void);
      41             : #endif
      42             : 
      43             : #define ZEND_INI_PARSER_CB      (CG(ini_parser_param))->ini_parser_cb
      44             : #define ZEND_INI_PARSER_ARG     (CG(ini_parser_param))->arg
      45             : 
      46             : /* {{{ zend_ini_do_op()
      47             : */
      48         252 : static void zend_ini_do_op(char type, zval *result, zval *op1, zval *op2)
      49             : {
      50             :         int i_result;
      51             :         int i_op1, i_op2;
      52             :         int str_len;
      53             :         char str_result[MAX_LENGTH_OF_LONG];
      54             : 
      55         252 :         i_op1 = atoi(Z_STRVAL_P(op1));
      56         252 :         zend_string_free(Z_STR_P(op1));
      57         252 :         if (op2) {
      58         148 :                 i_op2 = atoi(Z_STRVAL_P(op2));
      59         148 :                 zend_string_free(Z_STR_P(op2));
      60             :         } else {
      61         104 :                 i_op2 = 0;
      62             :         }
      63             : 
      64         252 :         switch (type) {
      65             :                 case '|':
      66          40 :                         i_result = i_op1 | i_op2;
      67          40 :                         break;
      68             :                 case '&':
      69         104 :                         i_result = i_op1 & i_op2;
      70         104 :                         break;
      71             :                 case '^':
      72           4 :                         i_result = i_op1 ^ i_op2;
      73           4 :                         break;
      74             :                 case '~':
      75         103 :                         i_result = ~i_op1;
      76         103 :                         break;
      77             :                 case '!':
      78           1 :                         i_result = !i_op1;
      79           1 :                         break;
      80             :                 default:
      81           0 :                         i_result = 0;
      82             :                         break;
      83             :         }
      84             : 
      85         252 :         str_len = zend_sprintf(str_result, "%d", i_result);
      86         504 :         ZVAL_PSTRINGL(result, str_result, str_len);
      87         252 : }
      88             : /* }}} */
      89             : 
      90             : /* {{{ zend_ini_init_string()
      91             : */
      92      223735 : static void zend_ini_init_string(zval *result)
      93             : {
      94      447470 :         ZVAL_EMPTY_PSTRING(result);
      95      223735 : }
      96             : /* }}} */
      97             : 
      98             : /* {{{ zend_ini_add_string()
      99             : */
     100       62139 : static void zend_ini_add_string(zval *result, zval *op1, zval *op2)
     101             : {
     102       62139 :         int op1_len = Z_STRLEN_P(op1);
     103       62139 :         int length = op1_len + Z_STRLEN_P(op2);
     104             : 
     105      124278 :         ZVAL_NEW_STR(result, zend_string_realloc(Z_STR_P(op1), length, 1));
     106       62139 :         memcpy(Z_STRVAL_P(result)+op1_len, Z_STRVAL_P(op2), Z_STRLEN_P(op2));
     107       62139 :         Z_STRVAL_P(result)[length] = 0;
     108       62139 : }
     109             : /* }}} */
     110             : 
     111             : /* {{{ zend_ini_get_constant()
     112             : */
     113        1358 : static void zend_ini_get_constant(zval *result, zval *name TSRMLS_DC)
     114             : {
     115             :         zval *c, tmp;
     116             : 
     117             :         /* If name contains ':' it is not a constant. Bug #26893. */
     118        3067 :         if (!memchr(Z_STRVAL_P(name), ':', Z_STRLEN_P(name))
     119        1358 :                         && (c = zend_get_constant(Z_STR_P(name) TSRMLS_CC)) != 0) {
     120         351 :                 if (Z_TYPE_P(c) != IS_STRING) {
     121         336 :                         ZVAL_COPY_VALUE(&tmp, c);
     122         336 :                         if (Z_OPT_CONSTANT(tmp)) {
     123           0 :                                 zval_update_constant_ex(&tmp, 1, NULL TSRMLS_CC);
     124             :                         }
     125             :                         zval_opt_copy_ctor(&tmp);
     126         336 :                         convert_to_string(&tmp);
     127         336 :                         c = &tmp;
     128             :                 }
     129         702 :                 ZVAL_PSTRINGL(result, Z_STRVAL_P(c), Z_STRLEN_P(c));
     130         351 :                 if (c == &tmp) {
     131             :                         zval_dtor(&tmp);
     132             :                 }
     133         351 :                 zend_string_free(Z_STR_P(name));
     134             :         } else {
     135        1007 :                 *result = *name;
     136             :         }
     137        1358 : }
     138             : /* }}} */
     139             : 
     140             : /* {{{ zend_ini_get_var()
     141             : */
     142          26 : static void zend_ini_get_var(zval *result, zval *name TSRMLS_DC)
     143             : {
     144             :         zval *curval;
     145             :         char *envvar;
     146             : 
     147             :         /* Fetch configuration option value */
     148          26 :         if ((curval = zend_get_configuration_directive(Z_STR_P(name))) != NULL) {
     149           0 :                 ZVAL_PSTRINGL(result, Z_STRVAL_P(curval), Z_STRLEN_P(curval));
     150             :         /* ..or if not found, try ENV */
     151          78 :         } else if ((envvar = zend_getenv(Z_STRVAL_P(name), Z_STRLEN_P(name) TSRMLS_CC)) != NULL ||
     152          26 :                            (envvar = getenv(Z_STRVAL_P(name))) != NULL) {
     153          52 :                 ZVAL_PSTRING(result, envvar);
     154             :         } else {
     155           0 :                 zend_ini_init_string(result);
     156             :         }
     157          26 : }
     158             : /* }}} */
     159             : 
     160             : /* {{{ ini_error()
     161             : */
     162           4 : static void ini_error(const char *msg)
     163             : {
     164             :         char *error_buf;
     165             :         int error_buf_len;
     166             :         char *currently_parsed_filename;
     167             :         TSRMLS_FETCH();
     168             : 
     169           4 :         currently_parsed_filename = zend_ini_scanner_get_filename(TSRMLS_C);
     170           4 :         if (currently_parsed_filename) {
     171           4 :                 error_buf_len = 128 + strlen(msg) + strlen(currently_parsed_filename); /* should be more than enough */
     172           4 :                 error_buf = (char *) emalloc(error_buf_len);
     173             : 
     174           4 :                 sprintf(error_buf, "%s in %s on line %d\n", msg, currently_parsed_filename, zend_ini_scanner_get_lineno(TSRMLS_C));
     175             :         } else {
     176           0 :                 error_buf = estrdup("Invalid configuration directive\n");
     177             :         }
     178             : 
     179           4 :         if (CG(ini_parser_unbuffered_errors)) {
     180             : #ifdef PHP_WIN32
     181             :                 MessageBox(NULL, error_buf, "PHP Error", MB_OK|MB_TOPMOST|0x00200000L);
     182             : #else
     183           0 :                 fprintf(stderr, "PHP:  %s", error_buf);
     184             : #endif
     185             :         } else {
     186           4 :                 zend_error(E_WARNING, "%s", error_buf);
     187             :         }
     188           4 :         efree(error_buf);
     189           4 : }
     190             : /* }}} */
     191             : 
     192             : /* {{{ zend_parse_ini_file()
     193             : */
     194       20358 : ZEND_API int zend_parse_ini_file(zend_file_handle *fh, zend_bool unbuffered_errors, int scanner_mode, zend_ini_parser_cb_t ini_parser_cb, void *arg TSRMLS_DC)
     195             : {
     196             :         int retval;
     197             :         zend_ini_parser_param ini_parser_param;
     198             : 
     199       20358 :         ini_parser_param.ini_parser_cb = ini_parser_cb;
     200       20358 :         ini_parser_param.arg = arg;
     201       20358 :         CG(ini_parser_param) = &ini_parser_param;
     202             : 
     203       20358 :         if (zend_ini_open_file_for_scanning(fh, scanner_mode TSRMLS_CC) == FAILURE) {
     204          20 :                 return FAILURE;
     205             :         }
     206             : 
     207       20338 :         CG(ini_parser_unbuffered_errors) = unbuffered_errors;
     208       20338 :         retval = ini_parse(TSRMLS_C);
     209       20338 :         zend_file_handle_dtor(fh TSRMLS_CC);
     210             : 
     211       20338 :         shutdown_ini_scanner(TSRMLS_C);
     212             :         
     213       20338 :         if (retval == 0) {
     214       20336 :                 return SUCCESS;
     215             :         } else {
     216           2 :                 return FAILURE;
     217             :         }
     218             : }
     219             : /* }}} */
     220             : 
     221             : /* {{{ zend_parse_ini_string()
     222             : */
     223       20437 : ZEND_API int zend_parse_ini_string(char *str, zend_bool unbuffered_errors, int scanner_mode, zend_ini_parser_cb_t ini_parser_cb, void *arg TSRMLS_DC)
     224             : {
     225             :         int retval;
     226             :         zend_ini_parser_param ini_parser_param;
     227             : 
     228       20437 :         ini_parser_param.ini_parser_cb = ini_parser_cb;
     229       20437 :         ini_parser_param.arg = arg;
     230       20437 :         CG(ini_parser_param) = &ini_parser_param;
     231             : 
     232       20437 :         if (zend_ini_prepare_string_for_scanning(str, scanner_mode TSRMLS_CC) == FAILURE) {
     233           0 :                 return FAILURE;
     234             :         }
     235             : 
     236       20437 :         CG(ini_parser_unbuffered_errors) = unbuffered_errors;
     237       20437 :         retval = ini_parse(TSRMLS_C);
     238             : 
     239       20437 :         shutdown_ini_scanner(TSRMLS_C);
     240             : 
     241       20437 :         if (retval == 0) {
     242       20435 :                 return SUCCESS;
     243             :         } else {
     244           2 :                 return FAILURE;
     245             :         }
     246             : }
     247             : /* }}} */
     248             : 
     249             : %}
     250             : 
     251             : %expect 0
     252             : %pure_parser
     253             : 
     254             : %token TC_SECTION
     255             : %token TC_RAW
     256             : %token TC_CONSTANT
     257             : %token TC_NUMBER
     258             : %token TC_STRING
     259             : %token TC_WHITESPACE
     260             : %token TC_LABEL
     261             : %token TC_OFFSET
     262             : %token TC_DOLLAR_CURLY
     263             : %token TC_VARNAME
     264             : %token TC_QUOTED_STRING
     265             : %token BOOL_TRUE
     266             : %token BOOL_FALSE
     267             : %token NULL_NULL
     268             : %token END_OF_LINE
     269             : %token '=' ':' ',' '.' '"' '\'' '^' '+' '-' '/' '*' '%' '$' '~' '<' '>' '?' '@' '{' '}'
     270             : %left '|' '&' '^'
     271             : %right '~' '!'
     272             : 
     273             : %%
     274             : 
     275             : statement_list:
     276             :                 statement_list statement
     277             :         |       /* empty */
     278             : ;
     279             : 
     280             : statement:
     281             :                 TC_SECTION section_string_or_value ']' {
     282             : #if DEBUG_CFG_PARSER
     283             :                         printf("SECTION: [%s]\n", Z_STRVAL($2));
     284             : #endif
     285       19308 :                         ZEND_INI_PARSER_CB(&$2, NULL, NULL, ZEND_INI_PARSER_SECTION, ZEND_INI_PARSER_ARG TSRMLS_CC);
     286       19308 :                         zend_string_release(Z_STR($2));
     287             :                 }
     288       19308 :         |       TC_LABEL '=' string_or_value {
     289             : #if DEBUG_CFG_PARSER
     290             :                         printf("NORMAL: '%s' = '%s'\n", Z_STRVAL($1), Z_STRVAL($3));
     291             : #endif
     292      820802 :                         ZEND_INI_PARSER_CB(&$1, &$3, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC);
     293      820802 :                         zend_string_release(Z_STR($1));
     294      820802 :                         zval_ptr_dtor(&$3);
     295             :                 }
     296      820802 :         |       TC_OFFSET option_offset ']' '=' string_or_value {
     297             : #if DEBUG_CFG_PARSER
     298             :                         printf("OFFSET: '%s'[%s] = '%s'\n", Z_STRVAL($1), Z_STRVAL($2), Z_STRVAL($5));
     299             : #endif
     300          25 :                         ZEND_INI_PARSER_CB(&$1, &$5, &$2, ZEND_INI_PARSER_POP_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC);
     301          25 :                         zend_string_release(Z_STR($1));
     302          25 :                         zend_string_release(Z_STR($2));
     303          25 :                         zval_ptr_dtor(&$5);
     304             :                 }
     305          25 :         |       TC_LABEL        { ZEND_INI_PARSER_CB(&$1, NULL, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC); zend_string_release(Z_STR($1)); }
     306           1 :         |       END_OF_LINE
     307             : ;
     308             : 
     309             : section_string_or_value:
     310       19308 :                 var_string_list_section                 { $$ = $1; }
     311       19308 :         |       /* empty */                                             { zend_ini_init_string(&$$); }
     312           0 : ;
     313             : 
     314             : string_or_value:
     315      617828 :                 expr                                                    { $$ = $1; }
     316      617828 :         |       BOOL_TRUE                                               { $$ = $1; }
     317         167 :         |       BOOL_FALSE                                              { $$ = $1; }
     318       40535 :         |       NULL_NULL                                               { $$ = $1; }
     319          19 :         |       END_OF_LINE                                             { zend_ini_init_string(&$$); }
     320      162278 : ;
     321             : 
     322             : option_offset:
     323          14 :                 var_string_list                                 { $$ = $1; }
     324          14 :         |       /* empty */                                             { zend_ini_init_string(&$$); }
     325          11 : ;
     326             : 
     327             : encapsed_list:
     328          13 :                 encapsed_list cfg_var_ref               { zend_ini_add_string(&$$, &$1, &$2); zend_string_free(Z_STR($2)); }
     329          13 :         |       encapsed_list TC_QUOTED_STRING  { zend_ini_add_string(&$$, &$1, &$2); zend_string_free(Z_STR($2)); }
     330       61441 :         |       /* empty */                                             { zend_ini_init_string(&$$); }
     331       61446 : ;
     332             : 
     333             : var_string_list_section:
     334           2 :                 cfg_var_ref                                             { $$ = $1; }
     335           2 :         |       constant_literal                                { $$ = $1; }
     336       19300 :         |       '"' encapsed_list '"'                 { $$ = $2; }
     337           6 :         |       var_string_list_section cfg_var_ref     { zend_ini_add_string(&$$, &$1, &$2); zend_string_free(Z_STR($2)); }
     338           3 :         |       var_string_list_section constant_literal        { zend_ini_add_string(&$$, &$1, &$2); zend_string_free(Z_STR($2)); }
     339           3 :         |       var_string_list_section '"' encapsed_list '"'  { zend_ini_add_string(&$$, &$1, &$3); zend_string_free(Z_STR($3)); }
     340           0 : ;
     341             : 
     342             : var_string_list:
     343           4 :                 cfg_var_ref                                             { $$ = $1; }
     344           4 :         |       constant_string                                 { $$ = $1; }
     345      556552 :         |       '"' encapsed_list '"'                 { $$ = $2; }
     346       61434 :         |       var_string_list cfg_var_ref     { zend_ini_add_string(&$$, &$1, &$2); zend_string_free(Z_STR($2)); }
     347           4 :         |       var_string_list constant_string { zend_ini_add_string(&$$, &$1, &$2); zend_string_free(Z_STR($2)); }
     348         669 :         |       var_string_list '"' encapsed_list '"'  { zend_ini_add_string(&$$, &$1, &$3); zend_string_free(Z_STR($3)); }
     349           6 : ;
     350             : 
     351             : expr:
     352      617976 :                 var_string_list                                 { $$ = $1; }
     353      617976 :         |       expr '|' expr                                   { zend_ini_do_op('|', &$$, &$1, &$3); }
     354          40 :         |       expr '&' expr                                       { zend_ini_do_op('&', &$$, &$1, &$3); }
     355         104 :         |       expr '^' expr                                   { zend_ini_do_op('^', &$$, &$1, &$3); }
     356           4 :         |       '~' expr                                                { zend_ini_do_op('~', &$$, &$2, NULL); }
     357         103 :         |       '!'     expr                                            { zend_ini_do_op('!', &$$, &$2, NULL); }
     358           1 :         |       '(' expr ')'                                    { $$ = $2; }
     359           0 : ;
     360             : 
     361             : cfg_var_ref:
     362          26 :                 TC_DOLLAR_CURLY TC_VARNAME '}'  { zend_ini_get_var(&$$, &$2 TSRMLS_CC); zend_string_free(Z_STR($2)); }
     363          26 : ;
     364             : 
     365             : constant_literal:
     366          66 :                 TC_CONSTANT                                             { $$ = $1; }
     367          66 :         |       TC_RAW                                                  { $$ = $1; /*printf("TC_RAW: '%s'\n", Z_STRVAL($1));*/ }
     368       19190 :         |       TC_NUMBER                                               { $$ = $1; /*printf("TC_NUMBER: '%s'\n", Z_STRVAL($1));*/ }
     369          19 :         |       TC_STRING                                               { $$ = $1; /*printf("TC_STRING: '%s'\n", Z_STRVAL($1));*/ }
     370          28 :         |       TC_WHITESPACE                                   { $$ = $1; /*printf("TC_WHITESPACE: '%s'\n", Z_STRVAL($1));*/ }
     371           0 : ;
     372             : 
     373             : constant_string:
     374        1358 :                 TC_CONSTANT                                             { zend_ini_get_constant(&$$, &$1 TSRMLS_CC); }
     375        1358 :         |       TC_RAW                                                  { $$ = $1; /*printf("TC_RAW: '%s'\n", Z_STRVAL($1));*/ }
     376       60614 :         |       TC_NUMBER                                               { $$ = $1; /*printf("TC_NUMBER: '%s'\n", Z_STRVAL($1));*/ }
     377      473992 :         |       TC_STRING                                               { $$ = $1; /*printf("TC_STRING: '%s'\n", Z_STRVAL($1));*/ }
     378       20880 :         |       TC_WHITESPACE                                   { $$ = $1; /*printf("TC_WHITESPACE: '%s'\n", Z_STRVAL($1));*/ }
     379             : ;
     380             : 
     381             : /*
     382             :  * Local variables:
     383             :  * tab-width: 4
     384             :  * c-basic-offset: 4
     385             :  * indent-tabs-mode: t
     386             :  * End:
     387             :  */

Generated by: LCOV version 1.10

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

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