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 - lcov_data/sapi/phpdbg - phpdbg_parser.y (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 47 100 47.0 %
Date: 2018-12-15 Functions: 1 2 50.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : %{
       2             : 
       3             : /*
       4             :  * phpdbg_parser.y
       5             :  * (from php-src root)
       6             :  * flex sapi/phpdbg/dev/phpdbg_lexer.l
       7             :  * bison sapi/phpdbg/dev/phpdbg_parser.y
       8             :  */
       9             : 
      10             : #include "phpdbg.h"
      11             : #include "phpdbg_cmd.h"
      12             : #include "phpdbg_utils.h"
      13             : #include "phpdbg_cmd.h"
      14             : #include "phpdbg_prompt.h"
      15             : 
      16             : #define YYSTYPE phpdbg_param_t
      17             : 
      18             : #include "phpdbg_parser.h"
      19             : #include "phpdbg_lexer.h"
      20             : 
      21             : #undef yyerror
      22             : static int yyerror(const char *msg);
      23             : 
      24             : ZEND_EXTERN_MODULE_GLOBALS(phpdbg)
      25             : 
      26             : #ifdef _MSC_VER
      27             : #define YYMALLOC malloc
      28             : #define YYFREE free
      29             : #endif
      30             : 
      31             : %}
      32             : 
      33             : %pure-parser
      34             : %error-verbose
      35             : 
      36             : %code requires {
      37             : #include "phpdbg.h"
      38             : #ifndef YY_TYPEDEF_YY_SCANNER_T
      39             : #define YY_TYPEDEF_YY_SCANNER_T
      40             : typedef void* yyscan_t;
      41             : #endif
      42             : }
      43             : 
      44             : %output  "sapi/phpdbg/phpdbg_parser.c"
      45             : %defines "sapi/phpdbg/phpdbg_parser.h"
      46             : 
      47             : %token T_EVAL       "eval"
      48             : %token T_RUN        "run"
      49             : %token T_SHELL      "shell"
      50             : %token T_IF         "if (condition)"
      51             : %token T_TRUTHY     "truthy (true, on, yes or enabled)"
      52             : %token T_FALSY      "falsy (false, off, no or disabled)"
      53             : %token T_STRING     "string (some input, perhaps)"
      54             : %token T_COLON      ": (colon)"
      55             : %token T_DCOLON     ":: (double colon)"
      56             : %token T_POUND      "# (pound sign followed by digits)"
      57             : %token T_SEPARATOR  "# (pound sign)"
      58             : %token T_PROTO      "protocol (file://)"
      59             : %token T_DIGITS     "digits (numbers)"
      60             : %token T_LITERAL    "literal (string)"
      61             : %token T_ADDR       "address"
      62             : %token T_OPCODE     "opcode"
      63             : %token T_ID         "identifier (command or function name)"
      64             : %token T_INPUT      "input (input string or data)"
      65             : %token T_UNEXPECTED "input"
      66             : %token T_REQ_ID     "request id (-r %d)"
      67             : 
      68             : %% /* Rules */
      69             : 
      70             : input
      71         237 :         : command { $$ = $1; }
      72         240 :         | input T_SEPARATOR command { phpdbg_stack_separate($1.top); $$ = $3; }
      73           3 :         | /* nothing */
      74           3 :         ;
      75         228 : 
      76             : command
      77         228 :         : parameters { $$.top = PHPDBG_G(parser_stack)->top; }
      78         240 :         | full_expression { phpdbg_stack_push(PHPDBG_G(parser_stack), &$1); $$.top = PHPDBG_G(parser_stack)->top; }
      79          12 :         ;
      80          12 : 
      81         228 : parameters
      82         228 :         : parameter { phpdbg_stack_push(PHPDBG_G(parser_stack), &$1); $$.top = PHPDBG_G(parser_stack)->top; }
      83         317 :         | parameters parameter { phpdbg_stack_push(PHPDBG_G(parser_stack), &$2); $$.top = PHPDBG_G(parser_stack)->top; }
      84          89 :         | parameters req_id { $$ = $1; }
      85          89 :         ;
      86           0 : 
      87          22 : parameter
      88             :         : T_ID T_COLON T_DIGITS {
      89          22 :                 $$.type = FILE_PARAM;
      90          22 :                 $$.file.name = $2.str;
      91          22 :                 $$.file.line = $3.num;
      92             :         }
      93          22 :         | T_ID T_COLON T_POUND T_DIGITS {
      94           0 :                 $$.type = NUMERIC_FILE_PARAM;
      95           0 :                 $$.file.name = $1.str;
      96           0 :                 $$.file.line = $4.num;
      97             :         }
      98           0 :         | T_PROTO T_ID T_COLON T_DIGITS {
      99           0 :                 $$.type = FILE_PARAM;
     100           0 :                 $$.file.name = malloc($1.len + $2.len + 1);
     101           0 :                 if ($$.file.name) {
     102           0 :                         memcpy(&$$.file.name[0], $1.str, $1.len);
     103           0 :                         memcpy(&$$.file.name[$1.len], $2.str, $2.len);
     104           0 :                         $$.file.name[$1.len + $2.len] = '\0';
     105             :                 }
     106           0 :                 $$.file.line = $4.num;
     107             :         }
     108           0 :         | T_PROTO T_ID T_COLON T_POUND T_DIGITS {
     109           0 :                 $$.type = NUMERIC_FILE_PARAM;
     110           0 :                 $$.file.name = malloc($1.len + $2.len + 1);
     111           0 :                 if ($$.file.name) {
     112           0 :                         memcpy(&$$.file.name[0], $1.str, $1.len);
     113           0 :                         memcpy(&$$.file.name[$1.len], $2.str, $2.len);
     114           0 :                         $$.file.name[$1.len + $2.len] = '\0';
     115             :                 }
     116           0 :                 $$.file.line = $5.num;
     117             :         }
     118           0 :         | T_ID T_DCOLON T_ID {
     119           4 :                 $$.type = METHOD_PARAM;
     120           8 :                 $$.method.class = $1.str;
     121           4 :                 $$.method.name = $3.str;
     122             :         }
     123           4 :         | T_ID T_DCOLON T_ID T_POUND T_DIGITS {
     124           0 :                 $$.type = NUMERIC_METHOD_PARAM;
     125           0 :                 $$.method.class = $1.str;
     126           0 :                 $$.method.name = $3.str;
     127           0 :                 $$.num = $5.num;
     128             :         }
     129           0 :         | T_ID T_POUND T_DIGITS {
     130           0 :                 $$.type = NUMERIC_FUNCTION_PARAM;
     131           0 :                 $$.str = $1.str;
     132           0 :                 $$.len = $1.len;
     133           0 :                 $$.num = $3.num;
     134             :         }
     135           0 :         | T_IF T_INPUT {
     136           0 :                 $$.type = COND_PARAM;
     137           0 :                 $$.str = $2.str;
     138           0 :                 $$.len = $2.len;
     139             :         }
     140           3 :         | T_OPCODE { $$ = $1; }
     141           3 :         | T_ADDR { $$ = $1; }
     142           3 :         | T_LITERAL { $$ = $1; }
     143           0 :         | T_TRUTHY { $$ = $1; }
     144           0 :         | T_FALSY { $$ = $1; }
     145          22 :         | T_DIGITS { $$ = $1; }
     146         288 :         | T_ID { $$ = $1; }
     147         288 :         ;
     148         266 : 
     149           0 : req_id
     150           0 :         : T_REQ_ID { PHPDBG_G(req_id) = $1.num; }
     151           0 :         | /* empty */
     152             : ;
     153           7 : 
     154             : full_expression
     155             :         : T_EVAL req_id T_INPUT {
     156           7 :                 $$.type = EVAL_PARAM;
     157           7 :                 $$.str = $3.str;
     158           7 :                 $$.len = $3.len;
     159             :         }
     160           7 :         | T_SHELL req_id T_INPUT {
     161           0 :                 $$.type = SHELL_PARAM;
     162           0 :                 $$.str = $3.str;
     163           0 :                 $$.len = $3.len;
     164             :         }
     165           0 :         | T_RUN req_id {
     166           0 :                 $$.type = RUN_PARAM;
     167           0 :                 $$.len = 0;
     168             :         }
     169           0 :         | T_RUN req_id T_INPUT {
     170           5 :                 $$.type = RUN_PARAM;
     171          10 :                 $$.str = $3.str;
     172           5 :                 $$.len = $3.len;
     173             :         }
     174           5 :         ;
     175             : 
     176             : %%
     177             : 
     178           0 : static int yyerror(const char *msg) {
     179           0 :         phpdbg_error("command", "type=\"parseerror\" msg=\"%s\"", "Parse Error: %s", msg);
     180             : 
     181             :         {
     182           0 :                 const phpdbg_param_t *top = PHPDBG_G(parser_stack);
     183             : 
     184           0 :                 while (top) {
     185           0 :                         phpdbg_param_debug(top, "--> ");
     186           0 :                         top = top->next;
     187             :                 }
     188             :         }
     189           0 :         return 0;
     190             : }
     191             : 
     192         238 : int phpdbg_do_parse(phpdbg_param_t *stack, char *input) {
     193         238 :         if (!*input) {
     194           1 :                 return 0;
     195             :         }
     196             : 
     197         237 :         if (PHPDBG_G(cur_command)) {
     198         161 :                 free(PHPDBG_G(cur_command));
     199             :         }
     200         237 :         PHPDBG_G(cur_command) = strdup(input);
     201             : 
     202         237 :         phpdbg_init_lexer(stack, input);
     203             : 
     204         237 :         return yyparse();
     205             : }

Generated by: LCOV version 1.10

Generated at Sun, 16 Dec 2018 02:09:28 +0000 (27 hours ago)

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