%token T_PAAMAYIM_NEKUDOTAYIM ":: (T_PAAMAYIM_NEKUDOTAYIM)"%token T_EXTENDS    "extends (T_EXTENDS)"

unticked_class_declaration_statement:        class_entry_type T_STRING extends_from            { zend_do_begin_class_declaration(&$1, &$2, &$3 TSRMLS_CC); }            implements_list            ‘{‘                class_statement_list            ‘}‘ { zend_do_end_class_declaration(&$1, &$3 TSRMLS_CC); }    |    interface_entry T_STRING            { zend_do_begin_class_declaration(&$1, &$2, NULL TSRMLS_CC); }            interface_extends_list            ‘{‘                class_statement_list            ‘}‘ { zend_do_end_class_declaration(&$1, NULL TSRMLS_CC); };

class_entry_type:
        T_CLASS            { $$.u.op.opline_num = CG(zend_lineno); $$.EA = 0; }
    |    T_ABSTRACT T_CLASS { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; }
    |    T_TRAIT { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_TRAIT; }
    |    T_FINAL T_CLASS { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_FINAL_CLASS; }
;

extends_from:
        /* empty */                    { $$.op_type = IS_UNUSED; }
    |    T_EXTENDS fully_qualified_class_name    { zend_do_fetch_class(&$$, &$2 TSRMLS_CC); }
;

class_statement_list:        class_statement_list class_statement    |    /* empty */;class_statement:        variable_modifiers { CG(access_type) = Z_LVAL($1.u.constant); } class_variable_declaration ‘;‘    |    class_constant_declaration ‘;‘    |    trait_use_statement    |    method_modifiers function is_reference T_STRING { zend_do_begin_function_declaration(&$2, &$4, 1, $3.op_type, &$1 TSRMLS_CC); } ‘(‘            parameter_list ‘)‘ method_body { zend_do_abstract_method(&$4, &$1, &$9 TSRMLS_CC); zend_do_end_function_declaration(&$2 TSRMLS_CC); };variable_modifiers:        non_empty_member_modifiers        { $$ = $1; }    |    T_VAR                            { Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; };

method_modifiers:        /* empty */                            { Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; }    |    non_empty_member_modifiers            { $$ = $1;  if (!(Z_LVAL($$.u.constant) & ZEND_ACC_PPP_MASK)) { Z_LVAL($$.u.constant) |= ZEND_ACC_PUBLIC; } };

non_empty_member_modifiers:
member_modifier { $$ = $1; }
| non_empty_member_modifiers member_modifier { Z_LVAL($$.u.constant) = zend_do_verify_access_types(&$1, &$2); }
;

member_modifier:
T_PUBLIC { Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; }
| T_PROTECTED { Z_LVAL($$.u.constant) = ZEND_ACC_PROTECTED; }
| T_PRIVATE { Z_LVAL($$.u.constant) = ZEND_ACC_PRIVATE; }
| T_STATIC { Z_LVAL($$.u.constant) = ZEND_ACC_STATIC; }
| T_ABSTRACT { Z_LVAL($$.u.constant) = ZEND_ACC_ABSTRACT; }
| T_FINAL { Z_LVAL($$.u.constant) = ZEND_ACC_FINAL; }
;

method_body:        ‘;‘ /* abstract method */        { Z_LVAL($$.u.constant) = ZEND_ACC_ABSTRACT; }    |    ‘{‘ inner_statement_list ‘}‘    { Z_LVAL($$.u.constant) = 0;    };inner_statement_list:        inner_statement_list  { zend_do_extended_info(TSRMLS_C); } inner_statement { HANDLE_INTERACTIVE(); }    |    /* empty */;inner_statement:        statement    |    function_declaration_statement    |    class_declaration_statement    |    T_HALT_COMPILER ‘(‘ ‘)‘ ‘;‘   { zend_error(E_COMPILE_ERROR, "__HALT_COMPILER() can only be used from the outermost scope"); };statement:        unticked_statement { DO_TICKS(); }    |    T_STRING ‘:‘ { zend_do_label(&$1 TSRMLS_CC); };unticked_statement:    |    T_STATIC static_var_list ‘;‘        |    expr ‘;‘                { zend_do_free(&$1 TSRMLS_CC); };expr:        r_variable                    { $$ = $1; };r_variable:    variable { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); $$ = $1; };variable:        base_variable_with_function_calls T_OBJECT_OPERATOR { zend_do_push_object(&$1 TSRMLS_CC); }            object_property { zend_do_push_object(&$4 TSRMLS_CC); } method_or_not variable_properties            { zend_do_pop_object(&$$ TSRMLS_CC); $$.EA = $1.EA | ($7.EA ? $7.EA : $6.EA); }    |    base_variable_with_function_calls { $$ = $1; };base_variable_with_function_calls:        base_variable                { $$ = $1; }    |    array_function_dereference    { $$ = $1; }    |    function_call { zend_do_begin_variable_parse(TSRMLS_C); $$ = $1; $$.EA = ZEND_PARSED_FUNCTION_CALL; };base_variable:        reference_variable { $$ = $1; $$.EA = ZEND_PARSED_VARIABLE; }    |    simple_indirect_reference reference_variable { zend_do_indirect_references(&$$, &$1, &$2 TSRMLS_CC); $$.EA = ZEND_PARSED_VARIABLE; }    |    static_member { $$ = $1; $$.EA = ZEND_PARSED_STATIC_MEMBER; };
//类名::$静态成员变量名字static_member:        class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects { $$ = $3; zend_do_fetch_static_member(&$$, &$1 TSRMLS_CC); }    |    variable_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects { $$ = $3; zend_do_fetch_static_member(&$$, &$1 TSRMLS_CC); };static_var_list:        static_var_list ‘,‘ T_VARIABLE { zend_do_fetch_static_variable(&$3, NULL, ZEND_FETCH_STATIC TSRMLS_CC); }    |    static_var_list ‘,‘ T_VARIABLE ‘=‘ static_scalar { zend_do_fetch_static_variable(&$3, &$5, ZEND_FETCH_STATIC TSRMLS_CC); }    |    T_VARIABLE  { zend_do_fetch_static_variable(&$1, NULL, ZEND_FETCH_STATIC TSRMLS_CC); }    |    T_VARIABLE ‘=‘ static_scalar { zend_do_fetch_static_variable(&$1, &$3, ZEND_FETCH_STATIC TSRMLS_CC); };function_declaration_statement:        unticked_function_declaration_statement    { DO_TICKS(); };class_declaration_statement:        unticked_class_declaration_statement    { DO_TICKS(); };non_empty_member_modifiers:        member_modifier                        { $$ = $1; }    |    non_empty_member_modifiers member_modifier    { Z_LVAL($$.u.constant) = zend_do_verify_access_types(&$1, &$2); };member_modifier:        T_PUBLIC                { Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; }    |    T_PROTECTED                { Z_LVAL($$.u.constant) = ZEND_ACC_PROTECTED; }    |    T_PRIVATE                { Z_LVAL($$.u.constant) = ZEND_ACC_PRIVATE; }    |    T_STATIC                { Z_LVAL($$.u.constant) = ZEND_ACC_STATIC; }    |    T_ABSTRACT                { Z_LVAL($$.u.constant) = ZEND_ACC_ABSTRACT; }    |    T_FINAL                    { Z_LVAL($$.u.constant) = ZEND_ACC_FINAL; };class_variable_declaration:        class_variable_declaration ‘,‘ T_VARIABLE                    { zend_do_declare_property(&$3, NULL, CG(access_type) TSRMLS_CC); }    |    class_variable_declaration ‘,‘ T_VARIABLE ‘=‘ static_scalar    { zend_do_declare_property(&$3, &$5, CG(access_type) TSRMLS_CC); }    |    T_VARIABLE                        { zend_do_declare_property(&$1, NULL, CG(access_type) TSRMLS_CC); }    |    T_VARIABLE ‘=‘ static_scalar    { zend_do_declare_property(&$1, &$3, CG(access_type) TSRMLS_CC); };static_scalar: /* compile-time evaluated scalars */        common_scalar        { $$ = $1; }    |    namespace_name         { zend_do_fetch_constant(&$$, NULL, &$1, ZEND_CT, 1 TSRMLS_CC); }    |    T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); $3 = $$; zend_do_fetch_constant(&$$, NULL, &$3, ZEND_CT, 0 TSRMLS_CC); }    |    T_NS_SEPARATOR namespace_name { char *tmp = estrndup(Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); memcpy(&(tmp[1]), Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); tmp[0] = ‘\\‘; efree(Z_STRVAL($2.u.constant)); Z_STRVAL($2.u.constant) = tmp; ++Z_STRLEN($2.u.constant); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_CT, 0 TSRMLS_CC); }    |    ‘+‘ static_scalar { ZVAL_LONG(&$1.u.constant, 0); add_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; }    |    ‘-‘ static_scalar { ZVAL_LONG(&$1.u.constant, 0); sub_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; }    |    T_ARRAY ‘(‘ static_array_pair_list ‘)‘ { $$ = $3; Z_TYPE($$.u.constant) = IS_CONSTANT_ARRAY; }    |    ‘[‘ static_array_pair_list ‘]‘ { $$ = $2; Z_TYPE($$.u.constant) = IS_CONSTANT_ARRAY; }    |    static_class_constant { $$ = $1; }    |    T_CLASS_C            { $$ = $1; };common_scalar:        T_LNUMBER                     { $$ = $1; }    |    T_DNUMBER                     { $$ = $1; }    |    T_CONSTANT_ENCAPSED_STRING    { $$ = $1; }    |    T_LINE                         { $$ = $1; }    |    T_FILE                         { $$ = $1; }    |    T_DIR                       { $$ = $1; }    |    T_TRAIT_C                    { $$ = $1; }    |    T_METHOD_C                    { $$ = $1; }    |    T_FUNC_C                    { $$ = $1; }    |    T_NS_C                        { $$ = $1; }    |    T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC { $$ = $2; CG(heredoc) = Z_STRVAL($1.u.constant); CG(heredoc_len) = Z_STRLEN($1.u.constant); }    |    T_START_HEREDOC T_END_HEREDOC { ZVAL_EMPTY_STRING(&$$.u.constant); INIT_PZVAL(&$$.u.constant); $$.op_type = IS_CONST; CG(heredoc) = Z_STRVAL($1.u.constant); CG(heredoc_len) = Z_STRLEN($1.u.constant); };

void zend_do_begin_class_declaration(const znode *class_token, znode *class_name, const znode *parent_class_name TSRMLS_DC) /* {{{ */{    zend_op *opline;    int doing_inheritance = 0;    zend_class_entry *new_class_entry;    char *lcname;    int error = 0;    zval **ns_name, key;    if (CG(active_class_entry)) {        zend_error(E_COMPILE_ERROR, "Class declarations may not be nested");        return;    }    lcname = zend_str_tolower_dup(class_name->u.constant.value.str.val, class_name->u.constant.value.str.len);    if (!(strcmp(lcname, "self") && strcmp(lcname, "parent"))) {        efree(lcname);        zend_error(E_COMPILE_ERROR, "Cannot use ‘%s‘ as class name as it is reserved", Z_STRVAL(class_name->u.constant));    }    /* Class name must not conflict with import names */    if (CG(current_import) &&        zend_hash_find(CG(current_import), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&ns_name) == SUCCESS) {        error = 1;    }    if (CG(current_namespace)) {        /* Prefix class name with name of current namespace */        znode tmp;        tmp.op_type = IS_CONST;        tmp.u.constant = *CG(current_namespace);        zval_copy_ctor(&tmp.u.constant);        zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);        *class_name = tmp;        efree(lcname);        lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));    }    if (error) {        char *tmp = zend_str_tolower_dup(Z_STRVAL_PP(ns_name), Z_STRLEN_PP(ns_name));        if (Z_STRLEN_PP(ns_name) != Z_STRLEN(class_name->u.constant) ||            memcmp(tmp, lcname, Z_STRLEN(class_name->u.constant))) {            zend_error(E_COMPILE_ERROR, "Cannot declare class %s because the name is already in use", Z_STRVAL(class_name->u.constant));        }        efree(tmp);    }    new_class_entry = emalloc(sizeof(zend_class_entry));    new_class_entry->type = ZEND_USER_CLASS;    new_class_entry->name = zend_new_interned_string(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant) + 1, 1 TSRMLS_CC);    new_class_entry->name_length = Z_STRLEN(class_name->u.constant);    zend_initialize_class_data(new_class_entry, 1 TSRMLS_CC);    new_class_entry->info.user.filename = zend_get_compiled_filename(TSRMLS_C);    new_class_entry->info.user.line_start = class_token->u.op.opline_num;    new_class_entry->ce_flags |= class_token->EA;    if (parent_class_name && parent_class_name->op_type != IS_UNUSED) {        switch (parent_class_name->EA) {            case ZEND_FETCH_CLASS_SELF:                zend_error(E_COMPILE_ERROR, "Cannot use ‘self‘ as class name as it is reserved");                break;            case ZEND_FETCH_CLASS_PARENT:                zend_error(E_COMPILE_ERROR, "Cannot use ‘parent‘ as class name as it is reserved");                break;            case ZEND_FETCH_CLASS_STATIC:                zend_error(E_COMPILE_ERROR, "Cannot use ‘static‘ as class name as it is reserved");                break;            default:                break;        }        doing_inheritance = 1;    }    opline = get_next_op(CG(active_op_array) TSRMLS_CC);    opline->op1_type = IS_CONST;    build_runtime_defined_function_key(&key, lcname, new_class_entry->name_length TSRMLS_CC);    opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);    Z_HASH_P(&CONSTANT(opline->op1.constant)) = zend_hash_func(Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant)));        opline->op2_type = IS_CONST;    if (doing_inheritance) {        /* Make sure a trait does not try to extend a class */        if ((new_class_entry->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {            zend_error(E_COMPILE_ERROR, "A trait (%s) cannot extend a class. Traits can only be composed from other traits with the ‘use‘ keyword. Error", new_class_entry->name);        }        opline->extended_value = http://www.mamicode.com/parent_class_name->u.op.var;        opline->opcode = ZEND_DECLARE_INHERITED_CLASS;    } else {        opline->opcode = ZEND_DECLARE_CLASS;    }    LITERAL_STRINGL(opline->op2, lcname, new_class_entry->name_length, 0);    CALCULATE_LITERAL_HASH(opline->op2.constant);        zend_hash_quick_update(CG(class_table), Z_STRVAL(key), Z_STRLEN(key), Z_HASH_P(&CONSTANT(opline->op1.constant)), &new_class_entry, sizeof(zend_class_entry *), NULL);    CG(active_class_entry) = new_class_entry;    opline->result.var = get_temporary_variable(CG(active_op_array));    opline->result_type = IS_VAR;    GET_NODE(&CG(implementing_class), opline->result);    if (CG(doc_comment)) {        CG(active_class_entry)->info.user.doc_comment = CG(doc_comment);        CG(active_class_entry)->info.user.doc_comment_len = CG(doc_comment_len);        CG(doc_comment) = NULL;        CG(doc_comment_len) = 0;    }}

void zend_do_declare_property(const znode *var_name, const znode *value, zend_uint access_type TSRMLS_DC) /* {{{ */{    zval *property;    zend_property_info *existing_property_info;    char *comment = NULL;    int comment_len = 0;    
　　 //接口不能包含变量    if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {        zend_error(E_COMPILE_ERROR, "Interfaces may not include member variables");    }
　　 //属性不能定义为抽象    if (access_type & ZEND_ACC_ABSTRACT) {        zend_error(E_COMPILE_ERROR, "Properties cannot be declared abstract");    }
　　 //变量前面的修饰符不能为final    if (access_type & ZEND_ACC_FINAL) {        zend_error(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, the final modifier is allowed only for methods and classes",                   CG(active_class_entry)->name, var_name->u.constant.value.str.val);    }　　
    //不能多次定义同一变量    if (zend_hash_find(&CG(active_class_entry)->properties_info, var_name->u.constant.value.str.val, var_name->u.constant.value.str.len+1, (void **) &existing_property_info)==SUCCESS) {        zend_error(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", CG(active_class_entry)->name, var_name->u.constant.value.str.val);    }    ALLOC_ZVAL(property);    if (value) {        *property = value->u.constant;    } else {        INIT_PZVAL(property);        Z_TYPE_P(property) = IS_NULL;    }    if (CG(doc_comment)) {        comment = CG(doc_comment);        comment_len = CG(doc_comment_len);        CG(doc_comment) = NULL;        CG(doc_comment_len) = 0;    }    zend_declare_property_ex(CG(active_class_entry), zend_new_interned_string(var_name->u.constant.value.str.val, var_name->u.constant.value.str.len + 1, 0 TSRMLS_CC), var_name->u.constant.value.str.len, property, access_type, comment, comment_len TSRMLS_CC);    efree(var_name->u.constant.value.str.val);}

ZEND_API int zend_declare_property_ex(zend_class_entry *ce, const char *name, int name_length, zval *property, int access_type, const char *doc_comment, int doc_comment_len TSRMLS_DC) /* {{{ */{    zend_property_info property_info, *property_info_ptr;    const char *interned_name;    ulong h = zend_get_hash_value(name, name_length+1);    if (!(access_type & ZEND_ACC_PPP_MASK)) {        access_type |= ZEND_ACC_PUBLIC;    }    if (access_type & ZEND_ACC_STATIC) {        //修饰符为static的，例如 public static $xxx        if (zend_hash_quick_find(&ce->properties_info, name, name_length + 1, h, (void**)&property_info_ptr) == SUCCESS &&            (property_info_ptr->flags & ZEND_ACC_STATIC) != 0) {            property_info.offset = property_info_ptr->offset;            zval_ptr_dtor(&ce->default_static_members_table[property_info.offset]);            zend_hash_quick_del(&ce->properties_info, name, name_length + 1, h);        } else {            property_info.offset = ce->default_static_members_count++;            ce->default_static_members_table = perealloc(ce->default_static_members_table, sizeof(zval*) * ce->default_static_members_count, ce->type == ZEND_INTERNAL_CLASS);        }        ce->default_static_members_table[property_info.offset] = property;        if (ce->type == ZEND_USER_CLASS) {            ce->static_members_table = ce->default_static_members_table;        }    } else {        //这里应该是public $xxx这样的变量        if (zend_hash_quick_find(&ce->properties_info, name, name_length + 1, h, (void**)&property_info_ptr) == SUCCESS &&            (property_info_ptr->flags & ZEND_ACC_STATIC) == 0) {            property_info.offset = property_info_ptr->offset;            zval_ptr_dtor(&ce->default_properties_table[property_info.offset]);            zend_hash_quick_del(&ce->properties_info, name, name_length + 1, h);        } else {            property_info.offset = ce->default_properties_count++;            ce->default_properties_table = perealloc(ce->default_properties_table, sizeof(zval*) * ce->default_properties_count, ce->type == ZEND_INTERNAL_CLASS);        }        ce->default_properties_table[property_info.offset] = property;    }    if (ce->type & ZEND_INTERNAL_CLASS) {        switch(Z_TYPE_P(property)) {            case IS_ARRAY:            case IS_CONSTANT_ARRAY:            case IS_OBJECT:            case IS_RESOURCE:                zend_error(E_CORE_ERROR, "Internal zval‘s can‘t be arrays, objects or resources");                break;            default:                break;        }    }    switch (access_type & ZEND_ACC_PPP_MASK) {        case ZEND_ACC_PRIVATE: {                char *priv_name;                int priv_name_length;                zend_mangle_property_name(&priv_name, &priv_name_length, ce->name, ce->name_length, name, name_length, ce->type & ZEND_INTERNAL_CLASS);                property_info.name = priv_name;                property_info.name_length = priv_name_length;            }            break;        case ZEND_ACC_PROTECTED: {                char *prot_name;                int prot_name_length;                zend_mangle_property_name(&prot_name, &prot_name_length, "*", 1, name, name_length, ce->type & ZEND_INTERNAL_CLASS);                property_info.name = prot_name;                property_info.name_length = prot_name_length;            }            break;        case ZEND_ACC_PUBLIC:            if (IS_INTERNED(name)) {                property_info.name = (char*)name;            } else {                property_info.name = ce->type & ZEND_INTERNAL_CLASS ? zend_strndup(name, name_length) : estrndup(name, name_length);            }            property_info.name_length = name_length;            break;    }    interned_name = zend_new_interned_string(property_info.name, property_info.name_length+1, 0 TSRMLS_CC);    if (interned_name != property_info.name) {        if (ce->type == ZEND_USER_CLASS) {            efree((char*)property_info.name);        } else {            free((char*)property_info.name);        }        property_info.name = interned_name;    }    property_info.flags = access_type;    property_info.h = (access_type & ZEND_ACC_PUBLIC) ? h : zend_get_hash_value(property_info.name, property_info.name_length+1);    property_info.doc_comment = doc_comment;    property_info.doc_comment_len = doc_comment_len;    property_info.ce = ce;    zend_hash_quick_update(&ce->properties_info, name, name_length+1, h, &property_info, sizeof(zend_property_info), NULL);    return SUCCESS;}

void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /* {{{ */{    znode class_node;    zend_llist *fetch_list_ptr;    zend_llist_element *le;    zend_op *opline_ptr;    zend_op opline;    if (class_name->op_type == IS_CONST &&        ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {        zend_resolve_class_name(class_name, ZEND_FETCH_CLASS_GLOBAL, 1 TSRMLS_CC);        class_node = *class_name;    } else {        zend_do_fetch_class(&class_node, class_name TSRMLS_CC);    }    zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);    if (result->op_type == IS_CV) {        init_op(&opline TSRMLS_CC);        opline.opcode = ZEND_FETCH_W;        opline.result_type = IS_VAR;        opline.result.var = get_temporary_variable(CG(active_op_array));        opline.op1_type = IS_CONST;        LITERAL_STRINGL(opline.op1, estrdup(CG(active_op_array)->vars[result->u.op.var].name), CG(active_op_array)->vars[result->u.op.var].name_len, 0);        CALCULATE_LITERAL_HASH(opline.op1.constant);        GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant);        if (class_node.op_type == IS_CONST) {            opline.op2_type = IS_CONST;            opline.op2.constant =                zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);        } else {            SET_NODE(opline.op2, &class_node);        }        GET_NODE(result,opline.result);        opline.extended_value |= ZEND_FETCH_STATIC_MEMBER;        opline_ptr = &opline;        zend_llist_add_element(fetch_list_ptr, &opline);    } else {        le = fetch_list_ptr->head;        opline_ptr = (zend_op *)le->data;        if (opline_ptr->opcode != ZEND_FETCH_W && opline_ptr->op1_type == IS_CV) {            init_op(&opline TSRMLS_CC);            opline.opcode = ZEND_FETCH_W;            opline.result_type = IS_VAR;            opline.result.var = get_temporary_variable(CG(active_op_array));            opline.op1_type = IS_CONST;            LITERAL_STRINGL(opline.op1, estrdup(CG(active_op_array)->vars[opline_ptr->op1.var].name), CG(active_op_array)->vars[opline_ptr->op1.var].name_len, 0);            CALCULATE_LITERAL_HASH(opline.op1.constant);            GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant);            if (class_node.op_type == IS_CONST) {                opline.op2_type = IS_CONST;                opline.op2.constant =                    zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);            } else {                SET_NODE(opline.op2, &class_node);            }            opline.extended_value |= ZEND_FETCH_STATIC_MEMBER;            COPY_NODE(opline_ptr->op1, opline.result);            zend_llist_prepend_element(fetch_list_ptr, &opline);        } else {            if (opline_ptr->op1_type == IS_CONST) {                GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op1.constant);            }            if (class_node.op_type == IS_CONST) {                opline_ptr->op2_type = IS_CONST;                opline_ptr->op2.constant =                    zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);            } else {                SET_NODE(opline_ptr->op2, &class_node);            }            opline_ptr->extended_value |= ZEND_FETCH_STATIC_MEMBER;        }    }}

static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type, ZEND_OPCODE_HANDLER_ARGS){    USE_OPLINE    zend_free_op free_op1;    zval *varname;    zval **retval;    zval tmp_varname;    HashTable *target_symbol_table;    ulong hash_value;    SAVE_OPLINE();    varname = opline->op1.zv;    if (IS_CONST != IS_UNUSED) {        zend_class_entry *ce;        if (IS_CONST == IS_CONST) {            if (CACHED_PTR(opline->op2.literal->cache_slot)) {                ce = CACHED_PTR(opline->op2.literal->cache_slot);            } else {                ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);                if (UNEXPECTED(ce == NULL)) {                    if (IS_CONST != IS_CONST && varname == &tmp_varname) {                        zval_dtor(&tmp_varname);                    }                    CHECK_EXCEPTION();                    ZEND_VM_NEXT_OPCODE();                }                CACHE_PTR(opline->op2.literal->cache_slot, ce);            }        } else {            ce = EX_T(opline->op2.var).class_entry;        }        retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);    } else {    //代码省略}zend_class_entry *zend_fetch_class_by_name(const char *class_name, uint class_name_len, const zend_literal *key, int fetch_type TSRMLS_DC) /* {{{ */{    zend_class_entry **pce;    int use_autoload = (fetch_type & ZEND_FETCH_CLASS_NO_AUTOLOAD) == 0;    if (zend_lookup_class_ex(class_name, class_name_len, key, use_autoload, &pce TSRMLS_CC) == FAILURE) {        if (use_autoload) {            if ((fetch_type & ZEND_FETCH_CLASS_SILENT) == 0 && !EG(exception)) {                if ((fetch_type & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_INTERFACE) {                    zend_error(E_ERROR, "Interface ‘%s‘ not found", class_name);                } else if ((fetch_type & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_TRAIT) {                    zend_error(E_ERROR, "Trait ‘%s‘ not found", class_name);                } else {                    zend_error(E_ERROR, "Class ‘%s‘ not found", class_name);                }                }        }        return NULL;    }    return *pce;}ZEND_API zval **zend_std_get_static_property(zend_class_entry *ce, const char *property_name, int property_name_len, zend_bool silent, const zend_literal *key TSRMLS_DC) /* {{{ */{    zend_property_info *property_info;    ulong hash_value;    if (UNEXPECTED(!key) ||        (property_info = CACHED_POLYMORPHIC_PTR(key->cache_slot, ce)) == NULL) {        if (EXPECTED(key != NULL)) {            hash_value = key->hash_value;        } else {            hash_value = zend_hash_func(property_name, property_name_len+1);        }        if (UNEXPECTED(zend_hash_quick_find(&ce->properties_info, property_name, property_name_len+1, hash_value, (void **) &property_info)==FAILURE)) {            if (!silent) {                zend_error_noreturn(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name, property_name);            }            return NULL;        }#if DEBUG_OBJECT_HANDLERS        zend_printf("Access type for %s::%s is %s\n", ce->name, property_name, zend_visibility_string(property_info->flags));#endif        if (UNEXPECTED(!zend_verify_property_access(property_info, ce TSRMLS_CC))) {            if (!silent) {                zend_error_noreturn(E_ERROR, "Cannot access %s property %s::$%s", zend_visibility_string(property_info->flags), ce->name, property_name);            }            return NULL;        }        if (UNEXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0)) {            if (!silent) {                zend_error_noreturn(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name, property_name);            }            return NULL;        }        zend_update_class_constants(ce TSRMLS_CC); //不知道为什么这里update?        if (EXPECTED(key != NULL)) {            CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);        }    }    return &CE_STATIC_MEMBERS(ce)[property_info->offset];}