php字符串小bug探究

今天翻阅手册,发现了一个有趣的问题

字符串的替换规则有哪些呢?

按照手册描述,对字符串的替换所要满足的要求可以转换为对于字符串数组下标的条件

1.对于下标小于字符串长度且不为负数的情况,和数组一致

2.对于下标大于字符串长度的,则会将下标之前用空字符填充

3.下标为负数的情况,php不会做任何处理。

做个实验看看

$a = "a";
var_dump($a);
$a[20] = "b";
$a[0] = "c";
$b="";
$b[-2] = "e";
var_dump($a,$b);

结果

php7.2

PHP Warning:  Illegal string offset:  -2 *** in on line 7

Warning: Illegal string offset:  -2 in *** on line 7
string(21) "c                   b"
string(0) ""
负数下标的情况直接报错了,再看看5.6是啥情况

php5.6

string(21) "c                   b"
array(1) {
  [-2]=>
  string(1) "e"
}

PHP Warning:  Illegal string offset:  -2 in F:\phplearn\string.php on line 8

Warning: Illegal string offset:  -2 in F:\phplearn\string.php on line 8
string(21) "c                   b"
string(2) "22"

追查源码

首先通过'['在zend_language_parse.y搜索
expr_without_variable
接着找到

    |    combined_scalar_offset { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); }
    |    combined_scalar { $$ = $1; }
    
    combined_scalar_offset:
        combined_scalar '[' dim_offset ']' { zend_do_begin_variable_parse(TSRMLS_C); fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
    |    combined_scalar_offset '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
    |    T_CONSTANT_ENCAPSED_STRING '[' dim_offset ']' { $1.EA = 0; zend_do_begin_variable_parse(TSRMLS_C); fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
    |    general_constant '[' dim_offset ']' { zend_do_begin_variable_parse(TSRMLS_C); fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
;

知道fetch_array_dim为下标解析函数

void fetch_array_dim(znode *result, const znode *parent, const znode *dim TSRMLS_DC) /* {{{ */
{
    zend_op opline;
    zend_llist *fetch_list_ptr;

    zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);

    if (zend_is_function_or_method_call(parent)) {
        init_op(&opline TSRMLS_CC);
        opline.opcode = ZEND_SEPARATE;
        SET_NODE(opline.op1, parent);
        SET_UNUSED(opline.op2);
        opline.result_type = IS_VAR;
        opline.result.var = opline.op1.var;
        zend_llist_add_element(fetch_list_ptr, &opline);
    }

    init_op(&opline TSRMLS_CC);
    opline.opcode = ZEND_FETCH_DIM_W;    /* the backpatching routine assumes W */
    opline.result_type = IS_VAR;
    opline.result.var = get_temporary_variable(CG(active_op_array));
    SET_NODE(opline.op1, parent);
    SET_NODE(opline.op2, dim);
    
    //这里针对key为字符串的情况会做转换
    if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) {
        ulong index;
        int numeric = 0;

        ZEND_HANDLE_NUMERIC_EX(Z_STRVAL(CONSTANT(opline.op2.constant)), Z_STRLEN(CONSTANT(opline.op2.constant))+1, index, numeric = 1);
        if (numeric) {
            zval_dtor(&CONSTANT(opline.op2.constant));
            ZVAL_LONG(&CONSTANT(opline.op2.constant), index);
        } else {
            CALCULATE_LITERAL_HASH(opline.op2.constant);
        }
    }

    GET_NODE(result, opline.result);

    zend_llist_add_element(fetch_list_ptr, &opline);
}

通过代码看到是通过ZEND_FETCH_DIM_W 这条opcode执行的

ZEND_VM_HANDLER(84, ZEND_FETCH_DIM_W, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
{
    USE_OPLINE
    zend_free_op free_op1, free_op2;
    zval **container;

    SAVE_OPLINE();
    container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);

    if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
    }
    zend_fetch_dimension_address(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_W TSRMLS_CC);
    FREE_OP2();
    if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
        EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
    }
    FREE_OP1_VAR_PTR();

    /* We are going to assign the result by reference */
    if (UNEXPECTED(opline->extended_value != 0)) {
        zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;

        if (retval_ptr) {
            Z_DELREF_PP(retval_ptr);
            SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
            Z_ADDREF_PP(retval_ptr);
        }
    }

    CHECK_EXCEPTION();
    ZEND_VM_NEXT_OPCODE();
}

这里看见实际执行函数为
zend_fetch_dimension_address

这里我们就可以看到为什么5.6在空字符串中修改负值下标的值会变成数组了

//这里就是读取字符串下标的地方
        case IS_STRING: {
                zval tmp;
                //重点
                if (type != BP_VAR_UNSET && Z_STRLEN_P(container)==0) {
                    goto convert_to_array;
                }
                if (dim == NULL) {
                    zend_error_noreturn(E_ERROR, "[] operator not supported for strings");
                }

                if (type != BP_VAR_UNSET) {
                    SEPARATE_ZVAL_IF_NOT_REF(container_ptr);
                }

                if (Z_TYPE_P(dim) != IS_LONG) {

                    switch(Z_TYPE_P(dim)) {
                        /* case IS_LONG: */
                        case IS_STRING:
                            if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) {
                                break;
                            }
                            if (type != BP_VAR_UNSET) {
                                zend_error(E_WARNING, "Illegal string offset '%s'", dim->value.str.val);
                            }

                            break;
                        case IS_DOUBLE:
                        case IS_NULL:
                        case IS_BOOL:
                            zend_error(E_NOTICE, "String offset cast occurred");
                            break;
                        default:
                            zend_error(E_WARNING, "Illegal offset type");
                            break;
                    }

                    tmp = *dim;
                    zval_copy_ctor(&tmp);
                    convert_to_long(&tmp);
                    dim = &tmp;
                }
                container = *container_ptr;
                result->str_offset.str = container;
                PZVAL_LOCK(container);
                result->str_offset.offset = Z_LVAL_P(dim);
                result->str_offset.ptr_ptr = NULL;
                return;
            }
            break;

评论

暂无评论