第二节 语法的实现

re2c [-bdefFghisuvVw1] [-o output] [-c [-t header]] file

#include <stdio.h>
 
char *scan(char *p){
#define YYCTYPE char
#define YYCURSOR p
#define YYLIMIT p
#define YYMARKER q
#define YYFILL(n)
    /*!re2c
      [0-9]+ {return "number";}
      [a-z]+ {return "lower";}
      [A-Z]+ {return "upper";}
      [^] {return "unkown";}
     */
}
 
int main(int argc, char* argv[])
{
    printf("%s\n", scan(argv[1]));
 
    return 0;
}

re2c -o a.c a.l
gcc a.c -o a
chmod +x a
./a 1000

• YYCTYPE 用于保存输入符号的类型，通常为char型和unsigned char型
• YYCURSOR 指向当前输入标记， -当开始时，它指向当前标记的第一个字符，当结束时，它指向下一个标记的第一个字符
• YYFILL(n) 当生成的代码需要重新加载缓存的标记时，则会调用YYFILL(n)。
• YYLIMIT 缓存的最后一个字符，生成的代码会反复比较YYCURSOR和YYLIMIT，以确定是否需要重新填充缓冲区。 参照如上几个标识的说明，可以较清楚的理解生成的a.c文件，当然，re2c不会仅仅只有上面代码所显示的标记，这只是一个简单示例，更多的标识说明和帮助信息请移步 re2c帮助文档：http://re2c.org/manual.html。

NOTE re2c中条件表达式相关的宏为YYSETCONDITION和YYGETCONDITION，分别表示设置条件范围和获取条件范围。 在PHP的词法规则中共有10种，其全部在zend_language_scanner_def.h文件中。此文件并非手写， 而是re2c自动生成的。如果需要生成和使用条件表达式，在编译成c时需要添加-c 和-t参数。

#ifdef ZTS
ZEND_API ts_rsrc_id language_scanner_globals_id;
#else
ZEND_API zend_php_scanner_globals language_scanner_globals;
#endif

//  存在于zend_language_scanner.l文件中
#define YYGETCONDITION()  SCNG(yy_state)
#define YYSETCONDITION(s) SCNG(yy_state) = s
#define SCNG    LANG_SCNG
 
//  存在于zend_globals_macros.h文件中
# define LANG_SCNG(v) (language_scanner_globals.v)

#include <stdio.h>
#include "demo_def.h"
#include "demo.h"
 
Scanner scanner_globals;
 
#define YYCTYPE char
#define YYFILL(n) 
#define STATE(name)  yyc##name
#define BEGIN(state) YYSETCONDITION(STATE(state))
#define LANG_SCNG(v) (scanner_globals.v)
#define SCNG    LANG_SCNG
 
#define YYGETCONDITION()  SCNG(yy_state)
#define YYSETCONDITION(s) SCNG(yy_state) = s
#define YYCURSOR  SCNG(yy_cursor)
#define YYLIMIT   SCNG(yy_limit)
#define YYMARKER  SCNG(yy_marker)
 
int scan(){
    /*!re2c
      <INITIAL>"<?php" {BEGIN(ST_IN_SCRIPTING); return T_BEGIN;}
      <ST_IN_SCRIPTING>[0-9]+ {return T_NUMBER;}
      <ST_IN_SCRIPTING>[ \n\t\r]+ {return T_WHITESPACE;}
      <ST_IN_SCRIPTING>"exit" { return T_EXIT; }
      <ST_IN_SCRIPTING>[a-z]+ {return T_LOWER_CHAR;}
      <ST_IN_SCRIPTING>[A-Z]+ {return T_UPPER_CHAR;}
      <ST_IN_SCRIPTING>"?>" {return T_END;}
      <ST_IN_SCRIPTING>[^] {return T_UNKNOWN;}
      <*>[^] {return T_INPUT_ERROR;}
     */
}
 
void print_token(int token) {
    switch (token) {
        case T_BEGIN: printf("%s\n", "begin");break;
        case T_NUMBER: printf("%s\n", "number");break;
        case T_LOWER_CHAR: printf("%s\n", "lower char");break;
        case T_UPPER_CHAR: printf("%s\n", "upper char");break;
        case T_EXIT: printf("%s\n", "exit");break;
        case T_UNKNOWN: printf("%s\n", "unknown");break;
        case T_INPUT_ERROR: printf("%s\n", "input error");break;
        case T_END: printf("%s\n", "end");break;
    }
}
 
int main(int argc, char* argv[])
{
    int token;
    BEGIN(INITIAL); //  全局初始化，需要放在scan调用之前
    scanner_globals.yy_cursor = argv[1];    //将输入的第一个参数作为要解析的字符串
 
    while(token = scan()) {
        if (token == T_INPUT_ERROR) {
            printf("%s\n", "input error");
            break;
        }
        if (token == T_END) {
            printf("%s\n", "end");
            break;
        }
        print_token(token);
    }
 
    return 0;
}

re2c -o demo.c -c -t demo_def.h demo.l
gcc demo.c -o demo -g
chmod +x demo

int scan(){
 
#line 25 "demo.c"
{
    YYCTYPE yych;
    switch (YYGETCONDITION()) {
    case yycINITIAL: goto yyc_INITIAL;
    case yycST_IN_SCRIPTING: goto yyc_ST_IN_SCRIPTING;
    }
...
}

%{
#define YYSTYPE double
#include <stdio.h>
#include <math.h>
#include <ctype.h>
int yylex (void);
void yyerror (char const *);
%}
 
%token NUM
 
%%
input:    /* empty */
     | input line
    ;
 
line:     '\n'
    | exp '\n'      { printf ("\t%.10g\n", $1); }
;
 
exp:      NUM           { $$ = $1;           }
   | exp exp '+'   { $$ = $1 + $2;      }
    | exp exp '-'   { $$ = $1 - $2;      }
    | exp exp '*'   { $$ = $1 * $2;      }
    | exp exp '/'   { $$ = $1 / $2;      }
     /* Exponentiation */
    | exp exp '^'   { $$ = pow($1, $2); }
    /* Unary minus    */
    | exp 'n'       { $$ = -$1;          }
;
%%
 
#include <ctype.h>
 
int yylex (void) {
       int c;
 
/* Skip white space.  */
       while ((c = getchar ()) == ' ' || c == '\t') ;
 
/* Process numbers.  */
       if (c == '.' || isdigit (c)) {
       ungetc (c, stdin);
       scanf ("%lf", &yylval);
       return NUM;
     }
 
       /* Return end-of-input.  */
       if (c == EOF) return 0;
 
       /* Return a single char.  */
       return c;
}
 
void yyerror (char const *s) {
    fprintf (stderr, "%s\n", s); 
}
 
int main (void) {
    return yyparse ();
}

bison demo.y
gcc -o test -lm test.tab.c
chmod +x test
./test

gcc命令需要添加-lm参数。因为头文件仅对接口进行描述，但头文件不是负责进行符号解析的实体。此时需要告诉编译器应该使用哪个函数库来完成对符号的解析。 　GCC的命令参数中，-l参数就是用来指定程序要链接的库，-l参数紧接着就是库名，这里我们在-l后面接的是m，即数学库，他的库名是m，他的库文件名是libm.so。

• 以Bison可识别的格式正式地描述语法。对每一个语法规则，描述当这个规则被识别时相应的执行动作，动作由C语句序列。即我们在示例中看到的%%和%%这间的内容。
• 描述编写一个词法分析器处理输入并将记号传递给语法分析器（即yylex函数一定要存在）。词法分析器既可是手工编写的C代码, 也可以由lex产生，后面我们会讨论如何将re2c与bison结合使用。上面的示例中是直接手工编写C代码实现一个命令行读取内容的词法分析器。
• 编写一个调用Bison产生的分析器的控制函数，在示例中是main函数直接调用。编写错误报告函数（即yyerror函数）。 将这些源代码转换成可执行程序，需要按以下步骤进行：
• 按语法运行Bison产生分析器。对应示例中的命令，bison demo.y
• 同其它源代码一样编译Bison输出的代码，链接目标文件以产生最终的产品。即对应示例中的命令　gcc -o test -lm test.tab.c 我们可以将整个Ｂison语法文件划分为四个部分。这三个部分的划分通过%%',%{' 和`%}'符号实现。一般来说，Bison语法文件结构如下：

%{
这里可以用来定义在动作中使用类型和变量，或者使用预处理器命令在那里来定义宏, 或者使用#include包含需要的文件。
如在示例中我们声明了YYSTYPE，包含了头文件math.h等，还声明了词法分析器yylex和错误打印程序yyerror。
%}
 
Bison 的一些声明
在这里声明终结符和非终结符以及操作符的优先级和各种符号语义值的各种类型
如示例中的%token　NUM。我们在PHP的源码中可以看到更多的类型和符号声明，如%left，%right的使用
 
%%
在这里定义如何从每一个非终结符的部分构建其整体的语法规则。
%%
 
这里存放附加的内容
这里就比较自由了，你可以放任何你想放的代码。
在开始声明的函数，如yylex等，经常是在这里实现的，我们的示例就是这么搞的。

%{
#include <stdio.h>
#include "demo_scanner.h"
extern int yylex(znode *zendlval);
void yyerror(char const *);
 
#define YYSTYPE znode   //关键点一，znode定义在demo_scanner.h   
%}
 
%pure_parser    //  关键点二
 
%token T_BEGIN
%token T_NUMBER
%token T_LOWER_CHAR
%token T_UPPER_CHAR 
%token T_EXIT
%token T_UNKNOWN
%token T_INPUT_ERROR
%token T_END
%token T_WHITESPACE
 
%%
 
begin: T_BEGIN {printf("begin:\ntoken=%d\n", $1.op_type);}
     | begin variable {
        printf("token=%d ", $2.op_type);
        if ($2.constant.value.str.len > 0) {
            printf("text=%s", $2.constant.value.str.val);
        }
        printf("\n");
}
 
variable: T_NUMBER {$$ = $1;}
|T_LOWER_CHAR {$$ = $1;}
|T_UPPER_CHAR {$$ = $1;}
|T_EXIT {$$ = $1;}
|T_UNKNOWN {$$ = $1;}
|T_INPUT_ERROR {$$ = $1;}
|T_END {$$ = $1;}
|T_WHITESPACE {$$ = $1;}
 
%%
 
void yyerror(char const *s) {
    printf("%s\n", s);  
}

typedef union _zvalue_value {
    long lval;                  /* long value */
    double dval;                /* double value */
    struct {
        char *val;
        int len;
    } str;
} zvalue_value;
 
typedef struct _zval_struct {
    /* Variable information */
    zvalue_value value;     /* value */
    int type;    /* active type */
}zval;
 
typedef struct _znode {
    int op_type;
    zval constant;
}znode;

#define YYSTYPE znode

一个可重入(reentrant)程序是在执行过程中不变更的程序；换句话说,它全部由纯(pure)(只读)代码构成。 当可异步执行的时候，可重入特性非常重要。例如，从一个句柄调用不可重入程序可能是不安全的。 在带有多线程控制的系统中，一个非可重入程序必须只能被互锁(interlocks)调用。

SCNG(yy_text) = YYCURSOR;   //  记录当前字符串所在位置
/*!re2c
  <!*> {yyleng = YYCURSOR - SCNG(yy_text);} //  记录字符串长度　

int main(int argc, char* argv[])
{
    BEGIN(INITIAL); //  全局初始化，需要放在scan调用之前
    scanner_globals.yy_cursor = argv[1];    //将输入的第一个参数作为要解析的字符串
 
    yyparse();
    return 0;
}

re2c -o demo_scanner.c -c -t demo_scanner_def.h demo_scanner.l
bison -d demo.y
gcc -o t demo.tab.c demo_scanner.c
chmod +x t
./t "<?php tipi2011"

#0  lex_scan (zendlval=0xbfffccbc) at Zend/zend_language_scanner.c:841
#1  0x082bab51 in zendlex (zendlval=0xbfffccb8)
    at /home/martin/project/c/phpsrc/Zend/zend_compile.c:4930
#2  0x082a43be in zendparse ()
    at /home/martin/project/c/phpsrc/Zend/zend_language_parser.c:3280
#3  0x082b040f in compile_file (file_handle=0xbffff2b0, type=8)
    at Zend/zend_language_scanner.l:343
#4  0x08186d15 in phar_compile_file (file_handle=0xbffff2b0, type=8)
    at /home/martin/project/c/phpsrc/ext/phar/phar.c:3390
#5  0x082d234f in zend_execute_scripts (type=8, retval=0x0, file_count=3)
    at /home/martin/project/c/phpsrc/Zend/zend.c:1186
#6  0x08281b70 in php_execute_script (primary_file=0xbffff2b0)
    at /home/martin/project/c/phpsrc/main/main.c:2225
#7  0x08351b97 in main (argc=4, argv=0xbffff424)
    at /home/martin/project/c/phpsrc/sapi/cli/php_cli.c:1190

 [php]
 <?php 
 $demo = 'tipi';
 echo var_name($demo);   //执行结果，输出： demo
 ?>

在PHP中，可以使用token_get_all()函数来查看一段PHP代码生成的Tokens。

"var_name" {
    return T_VARIABLE_NAME;
}

| T_VARIABLE_NAME '(' T_VARIABLE ')' { zend_do_variable_name(&$$, &$3 TSRMLS_CC); }
| T_VARIABLE_NAME T_VARIABLE { zend_do_variable_name(&$$, &$2 TSRMLS_CC); }

<?php
echo var_name($varname);
echo var_name $varname;

#define ZEND_VARIABLE_NAME 154

void zend_do_variable_name(znode *result, znode *variable TSRMLS_DC)
{
    // 生成一条zend_op
    zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
    // 因为我们需要有返回值, 并且返回值只作为中间值.所以就是一个临时变量
    opline->result.op_type = IS_TMP_VAR;
    opline->result.u.var = get_temporary_variable(CG(active_op_array));
 
    opline->opcode = ZEND_VARIABLE_NAME;
    opline->op1 = *variable;
 
    // 我们只需要一个操作数就好了
    SET_UNUSED(opline->op2);
    *result = opline->result;
}

return zend_opcode_handlers[opcode * 25 + zend_vm_decode[op->op1.op_type] * 5 
    + zend_vm_decode[op->op2.op_type]];

void zend_init_opcodes_handlers(void)
{
    static const opcode_handler_t labels[] = {
    ....
    ZEND_VARIABLE_NAME_HANDLER,
    ....
    ZEND_VARIABLE_NAME_HANDLER
｝

和对语法的修改一样，opcode处理函数也不是直接修改Zend/zend_vm_execute.h文件的， 这是因为PHP提供了3种opcode分发的机制： 1. CALL 函数调用的方式分发 1. SWITCH 使用SWITCH case 进行分发 1. GOTO 使用goto语句进行分发 之所以提供3中方式主要是从性能出发的，可能在不同的CPU上这几种调用方式的效率并不一样。 默认采用的是CALL

static int ZEND_FASTCALL ZEND_VARIABLE_NAME_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{   
    zend_op *opline = EX(opline);
 
    // PHP中所有的变量在内部都是存储在zval结构中的. 
    zval *result = &EX_T(opline->result.u.var).tmp_var;
 
    // 把变量的名字赋给临时返回值
    Z_STRVAL(*result) = estrndup(opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len);
    Z_STRLEN(*result) = opline->op1.u.constant.value.str.len;
    Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_STRING;
 
    ZEND_VM_NEXT_OPCODE();
}

• 提出需求，并说明该语法的作用，以及具体的应用场景，这个语法带来的好处
• 大家讨论这个需求是否合理，实现起来是否有困难，对现有的语法是否造成影响
• 如果大部分人都认可这个需求最好，那么提出该需求的人可以自己来实现，并让大家review，如果没有问题则就可以进入版本库了。
• 如果比较有争议，那可能需要进行投票了。 更多内容请参考附录：怎么样为PHP做贡献小节。