php内置函数分析range()

 PHP_FUNCTION(range)
 {
     zval *zlow, *zhigh, *zstep = NULL, tmp;
     int err = , is_step_double = ;
     double step = 1.0; // 步长默认为1

     if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz|z", &zlow, &zhigh, &zstep) == FAILURE) {
         RETURN_FALSE;
     }

     // 步长
     if (zstep) {
         if (Z_TYPE_P(zstep) == IS_DOUBLE ||
             (Z_TYPE_P(zstep) == IS_STRING && is_numeric_string(Z_STRVAL_P(zstep), Z_STRLEN_P(zstep), NULL, NULL, ) == IS_DOUBLE)
         ) {
             is_step_double = ;
         }

         step = zval_get_double(zstep);

         // 步长可以为负数。取绝对值
         /* We only want positive step values. */
         if (step < 0.0) {
             step *= -;
         }
     }

     /* If the range is given as strings, generate an array of characters. */
     /* start、end是字符串 */
     if (Z_TYPE_P(zlow) == IS_STRING && Z_TYPE_P(zhigh) == IS_STRING && Z_STRLEN_P(zlow) >=  && Z_STRLEN_P(zhigh) >= ) {
         int type1, type2;
         unsigned char low, high;
         zend_long lstep = (zend_long) step;

         type1 = is_numeric_string(Z_STRVAL_P(zlow), Z_STRLEN_P(zlow), NULL, NULL, );
         type2 = is_numeric_string(Z_STRVAL_P(zhigh), Z_STRLEN_P(zhigh), NULL, NULL, );

         /* 填充数字 */
         if (type1 == IS_DOUBLE || type2 == IS_DOUBLE || is_step_double) {
             goto double_str;
         } else if (type1 == IS_LONG || type2 == IS_LONG) {
             goto long_str;
         }

         /* 填充字符，只取字符串start和字符串end的第一个字符 */
         low = (unsigned char)Z_STRVAL_P(zlow)[];
         high = (unsigned char)Z_STRVAL_P(zhigh)[];

         if (low > high) {        /* Negative Steps */
             if (lstep <= ) {
                 err = ;
                 goto err;
             }
             /* Initialize the return_value as an array. */
             array_init_size(return_value, (uint32_t)(((low - high) / lstep) + ));
             zend_hash_real_init(Z_ARRVAL_P(return_value), );
             ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) {
                 for (; low >= high; low -= (unsigned int)lstep) {
                     if (CG(one_char_string)[low]) {
                         ZVAL_INTERNED_STR(&tmp, CG(one_char_string)[low]);
                     } else {
                         ZVAL_STRINGL(&tmp, (char*)&low, );
                     }
                     ZEND_HASH_FILL_ADD(&tmp);
                     if (((signed int)low - lstep) < ) {
                         break;
                     }
                 }
             } ZEND_HASH_FILL_END();
         } else if (high > low) {    /* Positive Steps */
             if (lstep <= ) {
                 err = ;
                 goto err;
             }
             // 初始化返回的数组
             array_init_size(return_value, (uint32_t)(((high - low) / lstep) + ));
             zend_hash_real_init(Z_ARRVAL_P(return_value), );
             ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) {
                 // 将字符插入返回的数组
                 for (; low <= high; low += (unsigned int)lstep) {
                     if (CG(one_char_string)[low]) {
                         ZVAL_INTERNED_STR(&tmp, CG(one_char_string)[low]);
                     } else {
                         ZVAL_STRINGL(&tmp, (char*)&low, );
                     }
                     ZEND_HASH_FILL_ADD(&tmp);
                     if (((signed int)low + lstep) > ) {
                         break;
                     }
                 }
             } ZEND_HASH_FILL_END();
         } else {
             array_init(return_value);
             if (CG(one_char_string)[low]) {
                 ZVAL_INTERNED_STR(&tmp, CG(one_char_string)[low]);
             } else {
                 ZVAL_STRINGL(&tmp, (char*)&low, );
             }
             zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &tmp);
         }
     } else if (Z_TYPE_P(zlow) == IS_DOUBLE || Z_TYPE_P(zhigh) == IS_DOUBLE || is_step_double) { // start、end是浮点数
         double low, high, value;
         zend_long i;
 double_str:
         low = zval_get_double(zlow);
         high = zval_get_double(zhigh);
         i = ;

         // 浮点数范围检查
         if (zend_isinf(high) || zend_isinf(low)) {
             php_error_docref(NULL, E_WARNING, "Invalid range supplied: start=%0.0f end=%0.0f", low, high);
             RETURN_FALSE;
         }

         Z_TYPE_INFO(tmp) = IS_DOUBLE;
         if (low > high) {         /* Negative steps 第一个参数比第二大*/
             if (low - high < step || step <= ) { // 范围差小于步长或步长取绝对值之后仍小于0。则报WARNING错误。
                 err = ;
                 goto err;
             }

             // 检查并初始化返回的数组
             RANGE_CHECK_INIT_ARRAY(low, high);
             // 向返回的数组中填充值，降序
             ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) {
             for (value = low; value >= (high - DOUBLE_DRIFT_FIX); value = low - (++i * step)) {
                 Z_DVAL(tmp) = value;
                 ZEND_HASH_FILL_ADD(&tmp);
             }
             } ZEND_HASH_FILL_END();
         } else if (high > low) {     /* Positive steps 第一个参数比第二个小*/
             if (high - low < step || step <= ) {
                 err = ;
                 goto err;
             }

             // 检查并初始化返回的数组
             RANGE_CHECK_INIT_ARRAY(high, low);
             // 向返回的数组中填充值，升序
             ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) {
                 for (value = low; value <= (high + DOUBLE_DRIFT_FIX); value = low + (++i * step)) {
                     Z_DVAL(tmp) = value;
                     ZEND_HASH_FILL_ADD(&tmp);
                 }
             } ZEND_HASH_FILL_END();
         } else { // low == high。则返回的数组只用一个元素：array(0=>low)
             array_init(return_value);
             Z_DVAL(tmp) = low;
             zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &tmp);
         }
     } else { // start、end是整数
         double low, high;
         zend_long lstep;
 long_str:
         low = zval_get_double(zlow);
         high = zval_get_double(zhigh);
         lstep = (zend_long) step;

         Z_TYPE_INFO(tmp) = IS_LONG;
         if (low > high) {         /* Negative steps */
             if (low - high < lstep || lstep <= ) {
                 err = ;
                 goto err;
             }

             RANGE_CHECK_INIT_ARRAY(low, high);
             ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) {
                 for (; low >= high; low -= lstep) {
                     Z_LVAL(tmp) = (zend_long)low;
                     ZEND_HASH_FILL_ADD(&tmp);
                 }
             } ZEND_HASH_FILL_END();
         } else if (high > low) {     /* Positive steps */
             if (high - low < lstep || lstep <= ) {
                 err = ;
                 goto err;
             }

             RANGE_CHECK_INIT_ARRAY(high, low);
             ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) {
                 for (; low <= high; low += lstep) {
                     Z_LVAL(tmp) = (zend_long)low;
                     ZEND_HASH_FILL_ADD(&tmp);
                 }
             } ZEND_HASH_FILL_END();
         } else {
             array_init(return_value);
             Z_LVAL(tmp) = (zend_long)low;
             zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &tmp);
         }
     }
 err:
     if (err) {
         php_error_docref(NULL, E_WARNING, "step exceeds the specified range");
         RETURN_FALSE;
     }
 }