php 词法分析，语法分析

　　php的词法分析 可以理解为 通过一定的规则，把输入的代码 区分出哪些是 是$开头的变量， 哪些是 以两个单引号括起来的字符串，哪些是以两个双引号括起来的字符串 等等， 这些区分出来的东西 称为token ,token 之间的联系 是由语法分析来完成的， 比如 赋值，加减乘除;

　

　　语法分析详见这里

　　语法分析的驱动程序 yyparse() 调用yylex()这个函数 ， 这个函数 可以由flex生成，也可以人为编写，在php中，属于后者;

每次执行yylex()函数，会返回一个token, 每个token都会有类型和相应的值 ， 类型一般在zend_language_parse.y中的%token表示，这些类型其实是数值，存放于zend_language_parse.h

　　token的值通过yylval供bison使用,在php中其实是zendlval,zendlval的类型是一个zval的结构体

#define YYSTYPE zval

YYSTYPE yylval;

#define yylval  zendlval

　　把分析好的yytext , 通过zend_copy_value将其拷贝到zval这个结构体中去

　  zend_language_parse.y中的token 例如下面的

%token T_INCLUDE      "include (T_INCLUDE)"

　　bison官网有一段关于%token的使用的描述：

　　yylex函数其实就是zendlex函数

这个yyparse会循环调用lex_scan,lex_scan定义在zend_language_scanning.l中 ， 这个函数体大部分是一些正则表达式，以区分出代码中哪些是变量，哪些是字符串，哪些是数组等等

　

int lex_scan(zval *zendlval TSRMLS_DC)
{

....

}

下面举例说明：

<?php
$name='taek';
?>

下面的关于上面 $name='taek'; 的巴斯科范式

start:
top_statement_list { zend_do_end_compilation(TSRMLS_C); }
;

top_statement_list:
top_statement_list { zend_do_extended_info(TSRMLS_C); } top_statement { HANDLE_INTERACTIVE(); }
| /* empty */
;

top_statement:
statement
;

statement:
unticked_statement { DO_TICKS(); }
;

unticked_statement:
| expr ';' { zend_do_free(&$1 TSRMLS_CC); }
;
expr:
r_variable { $$ = $1; }
| expr_without_variable { $$ = $1; }
;

expr_without_variable:
| variable '=' expr { zend_check_writable_variable(&$1); zend_do_assign(&$$, &$1, &$3 TSRMLS_CC); }
| scalar { $$ = $1; }
| expr '.' expr { zend_do_binary_op(ZEND_CONCAT, &$$, &$1, &$3 TSRMLS_CC); }
;

scalar:
| common_scalar { $$ = $1; }
;

common_scalar:
T_LNUMBER { $$ = $1; }
| T_DNUMBER { $$ = $1; }
| T_CONSTANT_ENCAPSED_STRING { $$ = $1; }
;

variable:
| base_variable_with_function_calls { $$ = $1; }
;

base_variable_with_function_calls:
base_variable { $$ = $1; }
;

base_variable:
reference_variable { $$ = $1; $$.EA = ZEND_PARSED_VARIABLE; }
;

reference_variable:
| compound_variable { zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$$, &$1, 1 TSRMLS_CC); }
;

compound_variable:
T_VARIABLE { $$ = $1; }
| '$' '{' expr '}' { $$ = $3; }
;

　　1)发现第一个字符(这里先不考虑空白)为$开头，第二个字符为n ,符合 LABEL这个正则，接着继续扫描，直到= ,使用下面的规则 将变量名存储到zendlval中

<ST_IN_SCRIPTING,ST_DOUBLE_QUOTES,ST_HEREDOC,ST_BACKQUOTE,ST_VAR_OFFSET>"$"{LABEL} {
    zend_copy_value(zendlval, (yytext+1), (yyleng-1));
    zendlval->type = IS_STRING;
    return T_VARIABLE;
}

　　返回token的类型是 T_VARIABLE , 值为$name放入zendlval中，yylex()返回的yychar就是这个T_VARIABLE,经过处理,分析器经过yytable的返回，这是一个移进操作，便将T_VARIABLE 放入状态栈，$name放入符号栈 ， yyparse()继续执行yylex()函数,因为这里返回的是T_VARIABLE，经过yytable查找，发现是归约操作，即把$name替换为

　　注意：LABEL 是一个正则表达式  LABEL [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*  其中 \x7f-\xff 这个是识别utf8下面汉字的16进制，也就 是说，php的变量名称里面可以有汉字

<?php
$我的名字叫='taek';
echo $我的名字叫;

　　上面的代码是可以正常运行的，估计是易语言出现后，才增加的功能吧

　　2)扫描到=这个符号

<ST_IN_SCRIPTING>{TOKENS} {
    return yytext[];
}

此时的yychar接收 = 这个符号的ASICII的值，并放入状态栈，且将空值放入符号栈

　　这里面的TOKENS也是一个正则表达式  TOKENS [;:,.\[\]()|^&+-/*=%!~$<>?@],[]括号里的字符只允许出现一次，正好=这个符号在里面，正好匹配

　　

　　3)接着扫描到'， 这个单引号

 <ST_IN_SCRIPTING>b?['] {
     register char *s, *t;
     char *end;
     int bprefix = (yytext[] != '\'') ?  : ;

     while () {
         if (YYCURSOR < YYLIMIT) {
             if (*YYCURSOR == '\'') {
                 YYCURSOR++;
                 yyleng = YYCURSOR - SCNG(yy_text);

                 break;
             } else if (*YYCURSOR++ == '\\' && YYCURSOR < YYLIMIT) {
                 YYCURSOR++;
             }
         } else {
             yyleng = YYLIMIT - SCNG(yy_text);

             /* Unclosed single quotes; treat similar to double quotes, but without a separate token
              * for ' (unrecognized by parser), instead of old flex fallback to "Unexpected character..."
              * rule, which continued in ST_IN_SCRIPTING state after the quote */
             return T_ENCAPSED_AND_WHITESPACE;
         }
     }

     zendlval->value.str.val = estrndup(yytext+bprefix+, yyleng-bprefix-);
     zendlval->value.str.len = yyleng-bprefix-;
     zendlval->type = IS_STRING;

     /* convert escape sequences */
     s = t = zendlval->value.str.val;
     end = s+zendlval->value.str.len;
     while (s<end) {
         if (*s=='\\') {
             s++;

             switch(*s) {
                 case '\\':
                 case '\'':
                     *t++ = *s;
                     zendlval->value.str.len--;
                     break;
                 default:
                     *t++ = '\\';
                     *t++ = *s;
                     break;
             }
         } else {
             *t++ = *s;
         }

         if (*s == '\n' || (*s == '\r' && (*(s+) != '\n'))) {
             CG(zend_lineno)++;
         }
         s++;
     }
     *t = ;

     if (SCNG(output_filter)) {
         size_t sz = ;
         s = zendlval->value.str.val;
         SCNG(output_filter)((unsigned char **)&(zendlval->value.str.val), &sz, (unsigned char *)s, (size_t)zendlval->value.str.len TSRMLS_CC);
         zendlval->value.str.len = sz;
         efree(s);
     }
     return T_CONSTANT_ENCAPSED_STRING;
 }

　　上面的YYCURSOR会随时变化的，当遇到 第二个单引号时，它会认为扫描过的符号就是字符串了，注意：如果扫描到\'时，会自动跨过，要不然后面的字符会被截掉，最终把字符串放到zendlval中，并返回TOKEN T_CONSTANT_ENCAPSED_STRING

<ST_IN_SCRIPTING>b?['] {
    register char *s, *t;
    char *end;
    int bprefix = (yytext[] != '\'') ?  : ;

    while () {
        if (YYCURSOR < YYLIMIT) {
            if (*YYCURSOR == '\'') {
                YYCURSOR++;
                yyleng = YYCURSOR - SCNG(yy_text);

                break;
            } else if (*YYCURSOR++ == '\\' && YYCURSOR < YYLIMIT) {
                YYCURSOR++;
            }
        } else {
            yyleng = YYLIMIT - SCNG(yy_text);

            /* Unclosed single quotes; treat similar to double quotes, but without a separate token
             * for ' (unrecognized by parser), instead of old flex fallback to "Unexpected character..."
             * rule, which continued in ST_IN_SCRIPTING state after the quote */
            return T_ENCAPSED_AND_WHITESPACE;
        }
    }

    zendlval->value.str.val = estrndup(yytext+bprefix+, yyleng-bprefix-);
    zendlval->value.str.len = yyleng-bprefix-;
    zendlval->type = IS_STRING;

    /* convert escape sequences */
    s = t = zendlval->value.str.val;
    end = s+zendlval->value.str.len;
    while (s<end) {
        if (*s=='\\') {
            s++;

            switch(*s) {
                case '\\':
                case '\'':
                    *t++ = *s;
                    zendlval->value.str.len--;
                    break;
                default:
                    *t++ = '\\';
                    *t++ = *s;
                    break;
            }
        } else {
            *t++ = *s;
        }

        if (*s == '\n' || (*s == '\r' && (*(s+) != '\n'))) {
            CG(zend_lineno)++;
        }
        s++;
    }
    *t = ;

    if (SCNG(output_filter)) {
        size_t sz = ;
        s = zendlval->value.str.val;
        SCNG(output_filter)((unsigned char **)&(zendlval->value.str.val), &sz, (unsigned char *)s, (size_t)zendlval->value.str.len TSRMLS_CC);
        zendlval->value.str.len = sz;
        efree(s);
    }
    return T_CONSTANT_ENCAPSED_STRING;
}

<ST_IN_SCRIPTING>b?['] { 中的b ，全称为binary ,即可定义 二进制的字符串，见下图

我在php 5.4.12 版本中 ，是可以运行的，不像上面黑框中所说的effect on of PHP 6.0.0, 但不知道什么情况下会定义一个二进制的字符串？

if (*YYCURSOR == '\'') {
YYCURSOR++;
yyleng = YYCURSOR - SCNG(yy_text);

break;
}

这段代码的意思是 如果 碰上第二个单引号，那么跳过，不然这就意味着结束了

1)yylex扫描 $name后，yychar 值为 T_VARIABLE 这个token , 经过yytable运算，执行移进操作，将得到的状态值放入状态栈，同时将$name放入符号栈

　　然后根据 产生式

　　compound_variable:
　　|　　T_VARIABLE { $$ = $1; }
　　| '$' '{' expr '}' { $$ = $3; }
　　;

　　进行归约，先把状态栈pop出一个元素，也就是T_VARIABLE，接着符号栈pop出一个元素，也就是$name, 最后yygogo这个数组计算出新的状态，这个状态就是上面产生式的编号，将此编号放入着状态栈，$name再入符号栈

　　接着经过下列几个产生式的归约

　　reference_variable:
　　| compound_variable { zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$$, &$1, 1 TSRMLS_CC); }
　　;

　　base_variable:
　　　　reference_variable { $$ = $1; $$.EA = ZEND_PARSED_VARIABLE; }
　　;

　　base_variable_with_function_calls:
　　　　base_variable { $$ = $1; }
　　;

　　variable:

　　| base_variable_with_function_calls { $$ = $1; }
　　;

　　最终将variable这个产生式的编号入状态栈　　　

4)yylex扫描'taek'后，yychar 的值为T_CONSTANT_ENCAPSED_STRING 这个token,经yytable数组计算出的值，执行移进操作，此值入状态栈 ， 将'taek' 放入 符号栈 ，程序又回到yybackup:执行这里的代码

yyn = yypact[yystate];
if (yyn == YYPACT_NINF)
goto yydefault;

yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
goto yyreduce;

如果yyn不为0，则由产生式

common_scalar:
T_LNUMBER { $$ = $1; }
| T_DNUMBER { $$ = $1; }
| T_CONSTANT_ENCAPSED_STRING { $$ = $1; }
;

进行归约，将状态栈，符号栈pop出若干元素，再将该产生式编号 放入状态栈，'taek'经处理(可能)后，再放入符合栈，接着再次进行归约，通过下面几个产生式

expr:
r_variable { $$ = $1; }
| expr_without_variable { $$ = $1; }
;

expr_without_variable:
| variable '=' expr { zend_check_writable_variable(&$1); zend_do_assign(&$$, &$1, &$3 TSRMLS_CC); }
| scalar { $$ = $1; }
| expr '.' expr { zend_do_binary_op(ZEND_CONCAT, &$$, &$1, &$3 TSRMLS_CC); }
;

scalar:
| common_scalar { $$ = $1; }
;

进行归约，最终将expr这个并产生式的编号入状态栈, 至此'taek'归约成功

5）yylex扫描 . 这个连接符，并将其ASICII返回给zendparse中的yychar, 执行移进操作， 将ASICII值放入状态栈中，符号栈放一个空元素

6)  yylex接着扫描 'world' ，流程跟4一样,符号栈中的'world',在状态栈 对应的是expr(数字而已)

7）再次归约，也就是说expr . expr  可由产生式

expr_without_variable:
| variable '=' expr { zend_check_writable_variable(&$1); zend_do_assign(&$$, &$1, &$3 TSRMLS_CC); }
| scalar { $$ = $1; }
| expr '.' expr { zend_do_binary_op(ZEND_CONCAT, &$$, &$1, &$3 TSRMLS_CC); }
;

进行归约，状态栈,符号栈 pop出三个元素， expr_without_variable 这个产生式

8)  variable = expr ,由产生式

　　expr_without_variable:
　　| variable '=' expr { zend_check_writable_variable(&$1); zend_do_assign(&$$, &$1, &$3 TSRMLS_CC); }
　　| scalar { $$ = $1; }
　　| expr '.' expr { zend_do_binary_op(ZEND_CONCAT, &$$, &$1, &$3 TSRMLS_CC); }
　　;

　　进行归约，将状态栈，符号栈pop出若干元素， 再将该产生式编号入状态栈，同时将yylval入符号栈，

8) yylex扫描到;这个符号，将其ASICII值传给yychar, 入状态栈，符号栈入一个空元素

9)expr ; 由产生式

unticked_statement:
| expr ';' { zend_do_free(&$1 TSRMLS_CC); }
;

进行归约，状态栈，符合栈pop出若干个元素， 再将该产生式编号 放入状态栈，同时将

8)

common_scalar

4) 接着是分号的asicII进入状态栈，空值进入符号栈, 此时进行归约操作，并产生opcode代码，

5) 结束

双引号：

<ST_IN_SCRIPTING>b?["] {
    int bprefix = (yytext[] != '"') ?  : ;

    while (YYCURSOR < YYLIMIT) {
        switch (*YYCURSOR++) {
            case '"':
                yyleng = YYCURSOR - SCNG(yy_text);
                zend_scan_escape_string(zendlval, yytext+bprefix+, yyleng-bprefix-, '"' TSRMLS_CC);
                return T_CONSTANT_ENCAPSED_STRING;
            case '$':
                if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
                    break;
                }
                continue;
            case '{':
                if (*YYCURSOR == '$') {
                    break;
                }
                continue;
            case '\\':
                if (YYCURSOR < YYLIMIT) {
                    YYCURSOR++;
                }
                /* fall through */
            default:
                continue;
        }

        YYCURSOR--;
        break;
    }

    /* Remember how much was scanned to save rescanning */
    SET_DOUBLE_QUOTES_SCANNED_LENGTH(YYCURSOR - SCNG(yy_text) - yyleng);

    YYCURSOR = SCNG(yy_text) + yyleng;

    BEGIN(ST_DOUBLE_QUOTES);
    return '"';
}

对于双引号括起来的字符串，会对里面的字符进行判断

1）发现 $符号，记录已扫描过字符的位置，然后设置新条件：BEGIN(ST_DOUBLE_QUOTES);可以理解为在ST_DOUBLE_QUOTES的规则中寻找一个恰当的规则 ，接着 继续 执行lex_scan,最终找到的是

　　

<ST_DOUBLE_QUOTES>{ANY_CHAR} {
    if (GET_DOUBLE_QUOTES_SCANNED_LENGTH()) {
        YYCURSOR += GET_DOUBLE_QUOTES_SCANNED_LENGTH() - ;
        SET_DOUBLE_QUOTES_SCANNED_LENGTH();

        goto double_quotes_scan_done;
    }

    if (YYCURSOR > YYLIMIT) {
        return ;
    }
    if (yytext[] == '\\' && YYCURSOR < YYLIMIT) {
        YYCURSOR++;
    }

    while (YYCURSOR < YYLIMIT) {
        switch (*YYCURSOR++) {
            case '"':
                break;
            case '$':
                if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
                    break;
                }
                continue;
            case '{':
                if (*YYCURSOR == '$') {
                    break;
                }
                continue;
            case '\\':
                if (YYCURSOR < YYLIMIT) {
                    YYCURSOR++;
                }
                /* fall through */
            default:
                continue;
        }

        YYCURSOR--;
        break;
    }

double_quotes_scan_done:
    yyleng = YYCURSOR - SCNG(yy_text);

    zend_scan_escape_string(zendlval, yytext, yyleng, '"' TSRMLS_CC);
    return T_ENCAPSED_AND_WHITESPACE;
}

最终返回T_ENCAPSED_AND_WHITESPACE 标签，并将 字符串放入zendval中

2）再次循环执行lex_scan , 因为全局变量已保存了前面扫描过的字符了，所以从那之后进行扫描 ，

　　如果 发现 $, 如果$后面的字符在 a-z , A-Z , _ , \x7f-\xff 的范围内，或者$后面是一个左括号 { , 那么说明$后面的将是一个变量，跳转到ST_DOUBLE_QUOTES，进入

　　

<ST_IN_SCRIPTING,ST_DOUBLE_QUOTES,ST_HEREDOC,ST_BACKQUOTE,ST_VAR_OFFSET>"$"{LABEL} {
　　zend_copy_value(zendlval, (yytext+), (yyleng-));
　　zendlval->type = IS_STRING;
　　return T_VARIABLE;
}

　　详见这个例子

<?php
$ABC='ABC';
$name="taek$ABC#";
echo $name;

结果是 taekABC#

PHP记法分析把 $ABC当作一个变量，而没有把$ABC#当作变量，因为ABC#不符合 LABEL [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]* 这个规则

2)发现{,如果紧接其后是一个$,则

　　

<ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"{$" {
    zendlval->value.lval = (long) '{';
    yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
    yyless();
    return T_CURLY_OPEN;
}

#define IS_LABEL_START(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || (c) == '_' || (c) >= 0x7F)