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: 150 161 93.2 %
Date: 2015-08-29 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-2015 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             : #ifdef ZEND_WIN32
      33             : #include "win32/syslog.h"
      34             : #endif
      35             : 
      36             : #define YYERROR_VERBOSE
      37             : #define YYSTYPE zval
      38             : 
      39             : int ini_parse(void);
      40             : 
      41             : #define ZEND_INI_PARSER_CB      (CG(ini_parser_param))->ini_parser_cb
      42             : #define ZEND_INI_PARSER_ARG     (CG(ini_parser_param))->arg
      43             : 
      44             : #ifdef _MSC_VER
      45             : #define YYMALLOC malloc
      46             : #define YYFREE free
      47             : #endif
      48             : 
      49             : /* {{{ zend_ini_do_op()
      50             : */
      51         232 : static void zend_ini_do_op(char type, zval *result, zval *op1, zval *op2)
      52             : {
      53             :         int i_result;
      54             :         int i_op1, i_op2;
      55             :         int str_len;
      56             :         char str_result[MAX_LENGTH_OF_LONG];
      57             : 
      58         232 :         i_op1 = atoi(Z_STRVAL_P(op1));
      59         232 :         zend_string_free(Z_STR_P(op1));
      60         232 :         if (op2) {
      61         131 :                 i_op2 = atoi(Z_STRVAL_P(op2));
      62         131 :                 zend_string_free(Z_STR_P(op2));
      63             :         } else {
      64         101 :                 i_op2 = 0;
      65             :         }
      66             : 
      67         232 :         switch (type) {
      68             :                 case '|':
      69          26 :                         i_result = i_op1 | i_op2;
      70          26 :                         break;
      71             :                 case '&':
      72         101 :                         i_result = i_op1 & i_op2;
      73         101 :                         break;
      74             :                 case '^':
      75           4 :                         i_result = i_op1 ^ i_op2;
      76           4 :                         break;
      77             :                 case '~':
      78         100 :                         i_result = ~i_op1;
      79         100 :                         break;
      80             :                 case '!':
      81           1 :                         i_result = !i_op1;
      82           1 :                         break;
      83             :                 default:
      84           0 :                         i_result = 0;
      85             :                         break;
      86             :         }
      87             : 
      88         232 :         str_len = zend_sprintf(str_result, "%d", i_result);
      89         464 :         ZVAL_PSTRINGL(result, str_result, str_len);
      90         232 : }
      91             : /* }}} */
      92             : 
      93             : /* {{{ zend_ini_init_string()
      94             : */
      95      241335 : static void zend_ini_init_string(zval *result)
      96             : {
      97      482670 :         ZVAL_EMPTY_PSTRING(result);
      98      241335 : }
      99             : /* }}} */
     100             : 
     101             : /* {{{ zend_ini_add_string()
     102             : */
     103       64735 : static void zend_ini_add_string(zval *result, zval *op1, zval *op2)
     104             : {
     105             :         int length, op1_len;
     106             : 
     107       64735 :         if (Z_TYPE_P(op1) != IS_STRING) {
     108           1 :                 zend_string *str = zval_get_string(op1);
     109           2 :                 ZVAL_PSTRINGL(op1, str->val, str->len);
     110             :                 zend_string_release(str);
     111             :         }
     112             : 
     113       64735 :         op1_len = (int)Z_STRLEN_P(op1);
     114       64735 :         length = op1_len + (int)Z_STRLEN_P(op2);
     115             : 
     116      129470 :         ZVAL_NEW_STR(result, zend_string_extend(Z_STR_P(op1), length, 1));
     117       64735 :         memcpy(Z_STRVAL_P(result)+op1_len, Z_STRVAL_P(op2), Z_STRLEN_P(op2));
     118       64735 :         Z_STRVAL_P(result)[length] = 0;
     119       64735 : }
     120             : /* }}} */
     121             : 
     122             : /* {{{ zend_ini_get_constant()
     123             : */
     124        1376 : static void zend_ini_get_constant(zval *result, zval *name)
     125             : {
     126             :         zval *c, tmp;
     127             : 
     128             :         /* If name contains ':' it is not a constant. Bug #26893. */
     129        3083 :         if (!memchr(Z_STRVAL_P(name), ':', Z_STRLEN_P(name))
     130        1376 :                         && (c = zend_get_constant(Z_STR_P(name))) != 0) {
     131         331 :                 if (Z_TYPE_P(c) != IS_STRING) {
     132         316 :                         ZVAL_COPY_VALUE(&tmp, c);
     133         316 :                         if (Z_OPT_CONSTANT(tmp)) {
     134           0 :                                 zval_update_constant_ex(&tmp, 1, NULL);
     135             :                         }
     136             :                         zval_opt_copy_ctor(&tmp);
     137         316 :                         convert_to_string(&tmp);
     138         316 :                         c = &tmp;
     139             :                 }
     140         662 :                 ZVAL_PSTRINGL(result, Z_STRVAL_P(c), Z_STRLEN_P(c));
     141         331 :                 if (c == &tmp) {
     142         316 :                         zend_string_release(Z_STR(tmp));
     143             :                 }
     144         331 :                 zend_string_free(Z_STR_P(name));
     145             :         } else {
     146        1045 :                 *result = *name;
     147             :         }
     148        1376 : }
     149             : /* }}} */
     150             : 
     151             : /* {{{ zend_ini_get_var()
     152             : */
     153          26 : static void zend_ini_get_var(zval *result, zval *name)
     154             : {
     155             :         zval *curval;
     156             :         char *envvar;
     157             : 
     158             :         /* Fetch configuration option value */
     159          26 :         if ((curval = zend_get_configuration_directive(Z_STR_P(name))) != NULL) {
     160           0 :                 ZVAL_PSTRINGL(result, Z_STRVAL_P(curval), Z_STRLEN_P(curval));
     161             :         /* ..or if not found, try ENV */
     162          78 :         } else if ((envvar = zend_getenv(Z_STRVAL_P(name), Z_STRLEN_P(name))) != NULL ||
     163          26 :                            (envvar = getenv(Z_STRVAL_P(name))) != NULL) {
     164          52 :                 ZVAL_PSTRING(result, envvar);
     165             :         } else {
     166           0 :                 zend_ini_init_string(result);
     167             :         }
     168          26 : }
     169             : /* }}} */
     170             : 
     171             : /* {{{ ini_error()
     172             : */
     173           5 : static ZEND_COLD void ini_error(const char *msg)
     174             : {
     175             :         char *error_buf;
     176             :         int error_buf_len;
     177             :         char *currently_parsed_filename;
     178             : 
     179           5 :         currently_parsed_filename = zend_ini_scanner_get_filename();
     180           5 :         if (currently_parsed_filename) {
     181           5 :                 error_buf_len = 128 + (int)strlen(msg) + (int)strlen(currently_parsed_filename); /* should be more than enough */
     182           5 :                 error_buf = (char *) emalloc(error_buf_len);
     183             : 
     184           5 :                 sprintf(error_buf, "%s in %s on line %d\n", msg, currently_parsed_filename, zend_ini_scanner_get_lineno());
     185             :         } else {
     186           0 :                 error_buf = estrdup("Invalid configuration directive\n");
     187             :         }
     188             : 
     189           5 :         if (CG(ini_parser_unbuffered_errors)) {
     190             : #ifdef ZEND_WIN32
     191             :                 syslog(LOG_ALERT, "PHP: %s (%s)", error_buf, GetCommandLine());
     192             : #endif
     193           0 :                 fprintf(stderr, "PHP:  %s", error_buf);
     194             :         } else {
     195           5 :                 zend_error(E_WARNING, "%s", error_buf);
     196             :         }
     197           5 :         efree(error_buf);
     198           5 : }
     199             : /* }}} */
     200             : 
     201             : /* {{{ zend_parse_ini_file()
     202             : */
     203       21217 : 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)
     204             : {
     205             :         int retval;
     206             :         zend_ini_parser_param ini_parser_param;
     207             : 
     208       21217 :         ini_parser_param.ini_parser_cb = ini_parser_cb;
     209       21217 :         ini_parser_param.arg = arg;
     210       21217 :         CG(ini_parser_param) = &ini_parser_param;
     211             : 
     212       21217 :         if (zend_ini_open_file_for_scanning(fh, scanner_mode) == FAILURE) {
     213          20 :                 return FAILURE;
     214             :         }
     215             : 
     216       21197 :         CG(ini_parser_unbuffered_errors) = unbuffered_errors;
     217       21197 :         retval = ini_parse();
     218       21197 :         zend_file_handle_dtor(fh);
     219             : 
     220       21197 :         shutdown_ini_scanner();
     221             : 
     222       21197 :         if (retval == 0) {
     223       21195 :                 return SUCCESS;
     224             :         } else {
     225           2 :                 return FAILURE;
     226             :         }
     227             : }
     228             : /* }}} */
     229             : 
     230             : /* {{{ zend_parse_ini_string()
     231             : */
     232       21307 : 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)
     233             : {
     234             :         int retval;
     235             :         zend_ini_parser_param ini_parser_param;
     236             : 
     237       21307 :         ini_parser_param.ini_parser_cb = ini_parser_cb;
     238       21307 :         ini_parser_param.arg = arg;
     239       21307 :         CG(ini_parser_param) = &ini_parser_param;
     240             : 
     241       21307 :         if (zend_ini_prepare_string_for_scanning(str, scanner_mode) == FAILURE) {
     242           0 :                 return FAILURE;
     243             :         }
     244             : 
     245       21307 :         CG(ini_parser_unbuffered_errors) = unbuffered_errors;
     246       21307 :         retval = ini_parse();
     247             : 
     248       21307 :         shutdown_ini_scanner();
     249             : 
     250       21307 :         if (retval == 0) {
     251       21304 :                 return SUCCESS;
     252             :         } else {
     253           3 :                 return FAILURE;
     254             :         }
     255             : }
     256             : /* }}} */
     257             : 
     258             : %}
     259             : 
     260             : %expect 0
     261             : %pure_parser
     262             : 
     263             : %token TC_SECTION
     264             : %token TC_RAW
     265             : %token TC_CONSTANT
     266             : %token TC_NUMBER
     267             : %token TC_STRING
     268             : %token TC_WHITESPACE
     269             : %token TC_LABEL
     270             : %token TC_OFFSET
     271             : %token TC_DOLLAR_CURLY
     272             : %token TC_VARNAME
     273             : %token TC_QUOTED_STRING
     274             : %token BOOL_TRUE
     275             : %token BOOL_FALSE
     276             : %token NULL_NULL
     277             : %token END_OF_LINE
     278             : %token '=' ':' ',' '.' '"' '\'' '^' '+' '-' '/' '*' '%' '$' '~' '<' '>' '?' '@' '{' '}'
     279             : %left '|' '&' '^'
     280             : %right '~' '!'
     281             : 
     282             : %%
     283             : 
     284             : statement_list:
     285             :                 statement_list statement
     286             :         |       /* empty */
     287             : ;
     288             : 
     289             : statement:
     290             :                 TC_SECTION section_string_or_value ']' {
     291             : #if DEBUG_CFG_PARSER
     292             :                         printf("SECTION: [%s]\n", Z_STRVAL($2));
     293             : #endif
     294       22508 :                         ZEND_INI_PARSER_CB(&$2, NULL, NULL, ZEND_INI_PARSER_SECTION, ZEND_INI_PARSER_ARG);
     295       22508 :                         zend_string_release(Z_STR($2));
     296             :                 }
     297       22508 :         |       TC_LABEL '=' string_or_value {
     298             : #if DEBUG_CFG_PARSER
     299             :                         printf("NORMAL: '%s' = '%s'\n", Z_STRVAL($1), Z_STRVAL($3));
     300             : #endif
     301      879358 :                         ZEND_INI_PARSER_CB(&$1, &$3, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG);
     302      879358 :                         zend_string_release(Z_STR($1));
     303      879358 :                         zval_ptr_dtor(&$3);
     304             :                 }
     305      879358 :         |       TC_OFFSET option_offset ']' '=' string_or_value {
     306             : #if DEBUG_CFG_PARSER
     307             :                         printf("OFFSET: '%s'[%s] = '%s'\n", Z_STRVAL($1), Z_STRVAL($2), Z_STRVAL($5));
     308             : #endif
     309          27 :                         ZEND_INI_PARSER_CB(&$1, &$5, &$2, ZEND_INI_PARSER_POP_ENTRY, ZEND_INI_PARSER_ARG);
     310          27 :                         zend_string_release(Z_STR($1));
     311          54 :                         if (Z_TYPE($2) == IS_STRING) {
     312          25 :                                 zend_string_release(Z_STR($2));
     313             :                         } else {
     314           2 :                                 zval_dtor(&$2);
     315             :                         }
     316          27 :                         zval_ptr_dtor(&$5);
     317             :                 }
     318          27 :         |       TC_LABEL        { ZEND_INI_PARSER_CB(&$1, NULL, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG); zend_string_release(Z_STR($1)); }
     319           1 :         |       END_OF_LINE
     320             : ;
     321             : 
     322             : section_string_or_value:
     323       22508 :                 var_string_list_section                 { $$ = $1; }
     324       22508 :         |       /* empty */                                             { zend_ini_init_string(&$$); }
     325           0 : ;
     326             : 
     327             : string_or_value:
     328      659642 :                 expr                                                    { $$ = $1; }
     329      659642 :         |       BOOL_TRUE                                               { $$ = $1; }
     330         171 :         |       BOOL_FALSE                                              { $$ = $1; }
     331       42257 :         |       NULL_NULL                                               { $$ = $1; }
     332          19 :         |       END_OF_LINE                                             { zend_ini_init_string(&$$); }
     333      177296 : ;
     334             : 
     335             : option_offset:
     336          16 :                 var_string_list                                 { $$ = $1; }
     337          16 :         |       /* empty */                                             { zend_ini_init_string(&$$); }
     338          11 : ;
     339             : 
     340             : encapsed_list:
     341          13 :                 encapsed_list cfg_var_ref               { zend_ini_add_string(&$$, &$1, &$2); zend_string_free(Z_STR($2)); }
     342          13 :         |       encapsed_list TC_QUOTED_STRING  { zend_ini_add_string(&$$, &$1, &$2); zend_string_free(Z_STR($2)); }
     343       64023 :         |       /* empty */                                             { zend_ini_init_string(&$$); }
     344       64028 : ;
     345             : 
     346             : var_string_list_section:
     347           2 :                 cfg_var_ref                                             { $$ = $1; }
     348           2 :         |       constant_literal                                { $$ = $1; }
     349       22500 :         |       '"' encapsed_list '"'                 { $$ = $2; }
     350           6 :         |       var_string_list_section cfg_var_ref     { zend_ini_add_string(&$$, &$1, &$2); zend_string_free(Z_STR($2)); }
     351           3 :         |       var_string_list_section constant_literal        { zend_ini_add_string(&$$, &$1, &$2); zend_string_free(Z_STR($2)); }
     352           3 :         |       var_string_list_section '"' encapsed_list '"'  { zend_ini_add_string(&$$, &$1, &$3); zend_string_free(Z_STR($3)); }
     353           0 : ;
     354             : 
     355             : var_string_list:
     356           4 :                 cfg_var_ref                                             { $$ = $1; }
     357           4 :         |       constant_string                                 { $$ = $1; }
     358      595769 :         |       '"' encapsed_list '"'                 { $$ = $2; }
     359       64016 :         |       var_string_list cfg_var_ref     { zend_ini_add_string(&$$, &$1, &$2); zend_string_free(Z_STR($2)); }
     360           4 :         |       var_string_list constant_string { zend_ini_add_string(&$$, &$1, &$2); zend_string_free(Z_STR($2)); }
     361         683 :         |       var_string_list '"' encapsed_list '"'  { zend_ini_add_string(&$$, &$1, &$3); zend_string_free(Z_STR($3)); }
     362           6 : ;
     363             : 
     364             : expr:
     365      659773 :                 var_string_list                                 { $$ = $1; }
     366      659773 :         |       expr '|' expr                                   { zend_ini_do_op('|', &$$, &$1, &$3); }
     367          26 :         |       expr '&' expr                                       { zend_ini_do_op('&', &$$, &$1, &$3); }
     368         101 :         |       expr '^' expr                                   { zend_ini_do_op('^', &$$, &$1, &$3); }
     369           4 :         |       '~' expr                                                { zend_ini_do_op('~', &$$, &$2, NULL); }
     370         100 :         |       '!'     expr                                            { zend_ini_do_op('!', &$$, &$2, NULL); }
     371           1 :         |       '(' expr ')'                                    { $$ = $2; }
     372           0 : ;
     373             : 
     374             : cfg_var_ref:
     375          26 :                 TC_DOLLAR_CURLY TC_VARNAME '}'  { zend_ini_get_var(&$$, &$2); zend_string_free(Z_STR($2)); }
     376          26 : ;
     377             : 
     378             : constant_literal:
     379          66 :                 TC_CONSTANT                                             { $$ = $1; }
     380          66 :         |       TC_RAW                                                  { $$ = $1; /*printf("TC_RAW: '%s'\n", Z_STRVAL($1));*/ }
     381       22389 :         |       TC_NUMBER                                               { $$ = $1; /*printf("TC_NUMBER: '%s'\n", Z_STRVAL($1));*/ }
     382          19 :         |       TC_STRING                                               { $$ = $1; /*printf("TC_STRING: '%s'\n", Z_STRVAL($1));*/ }
     383          29 :         |       TC_WHITESPACE                                   { $$ = $1; /*printf("TC_WHITESPACE: '%s'\n", Z_STRVAL($1));*/ }
     384           0 : ;
     385             : 
     386             : constant_string:
     387        1376 :                 TC_CONSTANT                                             { zend_ini_get_constant(&$$, &$1); }
     388        1376 :         |       TC_RAW                                                  { $$ = $1; /*printf("TC_RAW: '%s'\n", Z_STRVAL($1));*/ }
     389       70713 :         |       TC_NUMBER                                               { $$ = $1; /*printf("TC_NUMBER: '%s'\n", Z_STRVAL($1));*/ }
     390      502226 :         |       TC_STRING                                               { $$ = $1; /*printf("TC_STRING: '%s'\n", Z_STRVAL($1));*/ }
     391       21760 :         |       TC_WHITESPACE                                   { $$ = $1; /*printf("TC_WHITESPACE: '%s'\n", Z_STRVAL($1));*/ }
     392             : ;
     393             : 
     394             : /*
     395             :  * Local variables:
     396             :  * tab-width: 4
     397             :  * c-basic-offset: 4
     398             :  * indent-tabs-mode: t
     399             :  * End:
     400             :  */

Generated by: LCOV version 1.10

Generated at Sat, 29 Aug 2015 10:22:10 +0000 (2 hours ago)

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