static zend_always_inline zend_uint zval_addref_p(zval* pz) {
ZEND_ASSERT(Z_REFCOUNTED_P(pz));
-//??? if (Z_TYPE_P(pz) == IS_STRING && IS_INTERNED(Z_STR_P(pz))) return 1;
return ++Z_COUNTED_P(pz)->refcount;
}
static zend_always_inline zend_uint zval_delref_p(zval* pz) {
ZEND_ASSERT(Z_REFCOUNTED_P(pz));
-//??? if (Z_TYPE_P(pz) == IS_STRING && IS_INTERNED(Z_STR_P(pz))) return 1;
return --Z_COUNTED_P(pz)->refcount;
}
#define COPY_PZVAL_TO_ZVAL(zv, pzv) \
ZVAL_COPY_VALUE(&(zv), (pzv)); \
- if (IS_REFCOUNTED(Z_TYPE_P(pzv))) { \
+ if (Z_REFCOUNTED_P(pzv)) { \
if (Z_REFCOUNT_P(pzv)>1) { \
zval_copy_ctor(&(zv)); \
Z_DELREF_P((pzv)); \
zval *_varptr = (varptr); \
if (Z_ISREF_P(_varptr)) { \
ZVAL_DUP(_varptr, Z_REFVAL_P(_varptr)); \
- } else if (IS_REFCOUNTED(Z_TYPE_P(_varptr))) { \
+ } else if (Z_REFCOUNTED_P(_varptr)) { \
Z_ADDREF_P(_varptr); \
} \
} while (0)
while (param_count-->0) {
param_ptr = (p-arg_count);
- if (!Z_ISREF_P(param_ptr) && Z_REFCOUNT_P(param_ptr) > 1) {
+ if (Z_REFCOUNTED_P(param_ptr) &&
+ !Z_ISREF_P(param_ptr) &&
+ Z_REFCOUNT_P(param_ptr) > 1) {
zval new_tmp;
ZVAL_DUP(&new_tmp, param_ptr);
arg = p-(arg_count-i);
if (!Z_ISREF_P(arg)) {
element = arg;
- if (IS_REFCOUNTED(Z_TYPE_P(element))) Z_ADDREF_P(element);
+ if (Z_REFCOUNTED_P(element)) Z_ADDREF_P(element);
} else {
ZVAL_DUP(&tmp, Z_REFVAL_P(arg));
element = &tmp;
/* add value elements */
if (Z_ISREF_P(entry)) {
ZVAL_DUP(&tmp, Z_REFVAL_P(entry));
- if (IS_REFCOUNTED(Z_TYPE(tmp))) Z_SET_REFCOUNT(tmp, 0);
+//??? if (Z_REFCOUNTED(tmp)) Z_SET_REFCOUNT(tmp, 0);
entry = &tmp;
}
zend_hash_index_update(Z_ARRVAL_P(return_value), 1, entry);
- if (IS_REFCOUNTED(Z_TYPE_P(entry))) Z_ADDREF_P(entry);
+ if (Z_REFCOUNTED_P(entry)) Z_ADDREF_P(entry);
zend_hash_str_update(Z_ARRVAL_P(return_value), "value", sizeof("value")-1, entry);
- if (IS_REFCOUNTED(Z_TYPE_P(entry))) Z_ADDREF_P(entry);
+ if (Z_REFCOUNTED_P(entry)) Z_ADDREF_P(entry);
/* add the key elements */
switch (zend_hash_get_current_key_ex(target_hash, &key, &num_key, 0, NULL)) {
break;
}
zend_hash_str_update(Z_ARRVAL_P(return_value), "key", sizeof("key")-1, inserted_pointer);
- if (IS_REFCOUNTED(Z_TYPE_P(inserted_pointer))) Z_ADDREF_P(inserted_pointer);
+ if (Z_REFCOUNTED_P(inserted_pointer)) Z_ADDREF_P(inserted_pointer);
zend_hash_move_forward(target_hash);
}
/* }}} */
if (zend_check_property_access(zobj, key TSRMLS_CC) == SUCCESS) {
zend_unmangle_property_name_ex(key->val, key->len, &class_name, &prop_name, (int*) &prop_len);
/* Not separating references */
- if (IS_REFCOUNTED(Z_TYPE_P(value))) Z_ADDREF_P(value);
+ if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
add_assoc_zval_ex(return_value, prop_name, prop_len, value);
}
}
//??? if (Z_TYPE_P(arg) != IS_OBJECT) {
//??? SEPARATE_ZVAL_TO_MAKE_IS_REF(arg);
//??? }
- if (IS_REFCOUNTED(Z_TYPE_P(arg))) Z_ADDREF_P(arg);
+ if (Z_REFCOUNTED_P(arg)) Z_ADDREF_P(arg);
add_next_index_zval(arg_array, arg);
} else {
add_next_index_null(arg_array);
}
for (i = 0; i < parent_ce->default_properties_count; i++) {
ZVAL_COPY_VALUE(&ce->default_properties_table[i], &parent_ce->default_properties_table[i]);
- if (IS_REFCOUNTED(Z_TYPE(ce->default_properties_table[i]))) {
+ if (Z_REFCOUNTED(ce->default_properties_table[i])) {
#ifdef ZTS
if (parent_ce->type != ce->type) {
zval *p;
{
zval garbage;
- if (EXPECTED(!IS_REFCOUNTED(Z_TYPE_P(variable_ptr)))) {
+ if (EXPECTED(!Z_REFCOUNTED_P(variable_ptr))) {
if (EXPECTED(!Z_ISREF_P(value))) {
ZVAL_COPY(variable_ptr, value);
} else {
variable_ptr = Z_REFVAL_P(variable_ptr);
}
- if (EXPECTED(!IS_REFCOUNTED(Z_TYPE_P(variable_ptr)))) {
+ if (EXPECTED(!Z_REFCOUNTED_P(variable_ptr))) {
if (EXPECTED(!Z_ISREF_P(value))) {
ZVAL_COPY(variable_ptr, value);
} else {
Z_OBJ_HANDLER_P(variable_ptr, set)(variable_ptr, value TSRMLS_CC);
} else if (EXPECTED(variable_ptr != value)) {
if (Z_REFCOUNT_P(variable_ptr)==1) {
-//??? if (EXPECTED(!IS_REFCOUNTED(Z_TYPE_P(value)))) {
+//??? if (EXPECTED(!Z_REFCOUNTED_P(value))) {
//??? _zval_dtor_func(variable_ptr ZEND_FILE_LINE_CC);
//??? ZVAL_COPY(variable_ptr, value);
//??? } else if (EXPECTED(!Z_ISREF_P(value))) {
container = Z_INDIRECT_P(container);
}
ZVAL_STR_OFFSET(result, container, Z_LVAL_P(dim));
- Z_ADDREF_P(container);
+ if (!IS_INTERNED(Z_STR_P(container))) STR_ADDREF(Z_STR_P(container));
return;
}
break;
static zend_always_inline void i_zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC TSRMLS_DC)
{
//??? IS_CONSTANT_TYPE_MASK used only for some rare cases
- if (IS_REFCOUNTED(Z_TYPE_P(zval_ptr) & IS_CONSTANT_TYPE_MASK)) {
+ zend_uchar type = Z_TYPE_P(zval_ptr) & IS_CONSTANT_TYPE_MASK;
+
+ if (IS_REFCOUNTED(type) &&
+ (type != IS_STRING || !IS_INTERNED(Z_STR_P(zval_ptr)))) {
if (!Z_DELREF_P(zval_ptr)) {
ZEND_ASSERT(zval_ptr != &EG(uninitialized_zval));
GC_REMOVE_ZVAL_FROM_BUFFER(zval_ptr);
static zend_always_inline void i_zval_ptr_dtor_nogc(zval *zval_ptr ZEND_FILE_LINE_DC TSRMLS_DC)
{
- if (IS_REFCOUNTED(Z_TYPE_P(zval_ptr))) {
+ if (Z_REFCOUNTED_P(zval_ptr)) {
if (!Z_DELREF_P(zval_ptr)) {
ZEND_ASSERT(zval_ptr != &EG(uninitialized_zval));
GC_REMOVE_ZVAL_FROM_BUFFER(zval_ptr);
ZEND_API void _zval_internal_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC) /* {{{ */
{
- if (IS_REFCOUNTED(Z_TYPE_P(zval_ptr))) {
+ if (Z_REFCOUNTED_P(zval_ptr)) {
Z_DELREF_P(zval_ptr);
if (Z_REFCOUNT_P(zval_ptr) == 0) {
_zval_internal_dtor_for_ptr(zval_ptr ZEND_FILE_LINE_CC);
ZVAL_COPY_VALUE(p, &const_value);
}
- if (IS_REFCOUNTED(Z_TYPE_P(p))) Z_SET_REFCOUNT_P(p, refcount);
+ if (Z_REFCOUNTED_P(p)) Z_SET_REFCOUNT_P(p, refcount);
//??? Z_SET_ISREF_TO_P(p, is_ref);
} else if (Z_TYPE_P(p) == IS_CONSTANT_ARRAY) {
zval *element, new_val;
yy3:
YYDEBUG(3, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1764 "Zend/zend_language_scanner.l"
+#line 1762 "Zend/zend_language_scanner.l"
{
if (YYCURSOR > YYLIMIT) {
return 0;
yy6:
YYDEBUG(6, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1754 "Zend/zend_language_scanner.l"
+#line 1752 "Zend/zend_language_scanner.l"
{
if (CG(short_tags)) {
ZVAL_STRINGL(zendlval, yytext, yyleng);
if ((yych = *YYCURSOR) == '=') goto yy43;
YYDEBUG(8, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1733 "Zend/zend_language_scanner.l"
+#line 1731 "Zend/zend_language_scanner.l"
{
if (CG(asp_tags)) {
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
++YYCURSOR;
YYDEBUG(38, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1696 "Zend/zend_language_scanner.l"
+#line 1694 "Zend/zend_language_scanner.l"
{
YYCTYPE *bracket = (YYCTYPE*)zend_memrchr(yytext, '<', yyleng - (sizeof("script language=php>") - 1));
++YYCURSOR;
YYDEBUG(44, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1713 "Zend/zend_language_scanner.l"
+#line 1711 "Zend/zend_language_scanner.l"
{
if (CG(asp_tags)) {
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
++YYCURSOR;
YYDEBUG(46, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1725 "Zend/zend_language_scanner.l"
+#line 1723 "Zend/zend_language_scanner.l"
{
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
yy51:
YYDEBUG(51, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1745 "Zend/zend_language_scanner.l"
+#line 1743 "Zend/zend_language_scanner.l"
{
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way, no copying intentional */
yy56:
YYDEBUG(56, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2204 "Zend/zend_language_scanner.l"
+#line 2202 "Zend/zend_language_scanner.l"
{
if (YYCURSOR > YYLIMIT) {
return 0;
++YYCURSOR;
YYDEBUG(59, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2148 "Zend/zend_language_scanner.l"
+#line 2146 "Zend/zend_language_scanner.l"
{
BEGIN(ST_IN_SCRIPTING);
return '`';
++YYCURSOR;
YYDEBUG(62, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2135 "Zend/zend_language_scanner.l"
+#line 2133 "Zend/zend_language_scanner.l"
{
Z_LVAL_P(zendlval) = (long) '{';
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
yy65:
YYDEBUG(65, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1843 "Zend/zend_language_scanner.l"
+#line 1841 "Zend/zend_language_scanner.l"
{
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
++YYCURSOR;
YYDEBUG(71, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1836 "Zend/zend_language_scanner.l"
+#line 1834 "Zend/zend_language_scanner.l"
{
yyless(yyleng - 1);
yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
++YYCURSOR;
YYDEBUG(74, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1827 "Zend/zend_language_scanner.l"
+#line 1825 "Zend/zend_language_scanner.l"
{
yyless(yyleng - 3);
yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
yy78:
YYDEBUG(78, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2154 "Zend/zend_language_scanner.l"
+#line 2152 "Zend/zend_language_scanner.l"
{
if (GET_DOUBLE_QUOTES_SCANNED_LENGTH()) {
YYCURSOR += GET_DOUBLE_QUOTES_SCANNED_LENGTH() - 1;
++YYCURSOR;
YYDEBUG(81, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2143 "Zend/zend_language_scanner.l"
+#line 2141 "Zend/zend_language_scanner.l"
{
BEGIN(ST_IN_SCRIPTING);
return '"';
++YYCURSOR;
YYDEBUG(84, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2135 "Zend/zend_language_scanner.l"
+#line 2133 "Zend/zend_language_scanner.l"
{
Z_LVAL_P(zendlval) = (long) '{';
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
yy87:
YYDEBUG(87, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1843 "Zend/zend_language_scanner.l"
+#line 1841 "Zend/zend_language_scanner.l"
{
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
++YYCURSOR;
YYDEBUG(93, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1836 "Zend/zend_language_scanner.l"
+#line 1834 "Zend/zend_language_scanner.l"
{
yyless(yyleng - 1);
yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
++YYCURSOR;
YYDEBUG(96, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1827 "Zend/zend_language_scanner.l"
+#line 1825 "Zend/zend_language_scanner.l"
{
yyless(yyleng - 3);
yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
++YYCURSOR;
YYDEBUG(100, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2121 "Zend/zend_language_scanner.l"
+#line 2119 "Zend/zend_language_scanner.l"
{
zend_heredoc_label *heredoc_label = zend_ptr_stack_pop(&SCNG(heredoc_label_stack));
yy104:
YYDEBUG(104, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2246 "Zend/zend_language_scanner.l"
+#line 2244 "Zend/zend_language_scanner.l"
{
int newline = 0;
++YYCURSOR;
YYDEBUG(108, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2135 "Zend/zend_language_scanner.l"
+#line 2133 "Zend/zend_language_scanner.l"
{
Z_LVAL_P(zendlval) = (long) '{';
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
yy111:
YYDEBUG(111, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1843 "Zend/zend_language_scanner.l"
+#line 1841 "Zend/zend_language_scanner.l"
{
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
++YYCURSOR;
YYDEBUG(117, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1836 "Zend/zend_language_scanner.l"
+#line 1834 "Zend/zend_language_scanner.l"
{
yyless(yyleng - 1);
yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
++YYCURSOR;
YYDEBUG(120, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1827 "Zend/zend_language_scanner.l"
+#line 1825 "Zend/zend_language_scanner.l"
{
yyless(yyleng - 3);
yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
yy124:
YYDEBUG(124, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1865 "Zend/zend_language_scanner.l"
+#line 1863 "Zend/zend_language_scanner.l"
{
zend_copy_value(zendlval, yytext, yyleng);
return T_STRING;
yy177:
YYDEBUG(177, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1871 "Zend/zend_language_scanner.l"
+#line 1869 "Zend/zend_language_scanner.l"
{
while (YYCURSOR < YYLIMIT) {
switch (*YYCURSOR++) {
yy179:
YYDEBUG(179, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1958 "Zend/zend_language_scanner.l"
+#line 1956 "Zend/zend_language_scanner.l"
{
register char *s, *t;
char *end;
yy181:
YYDEBUG(181, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2025 "Zend/zend_language_scanner.l"
+#line 2023 "Zend/zend_language_scanner.l"
{
int bprefix = (yytext[0] != '"') ? 1 : 0;
++YYCURSOR;
YYDEBUG(183, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2115 "Zend/zend_language_scanner.l"
+#line 2113 "Zend/zend_language_scanner.l"
{
BEGIN(ST_BACKQUOTE);
return '`';
++YYCURSOR;
YYDEBUG(185, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2377 "Zend/zend_language_scanner.l"
+#line 2375 "Zend/zend_language_scanner.l"
{
if (YYCURSOR > YYLIMIT) {
return 0;
yy207:
YYDEBUG(207, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1938 "Zend/zend_language_scanner.l"
+#line 1936 "Zend/zend_language_scanner.l"
{
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
yy212:
YYDEBUG(212, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1843 "Zend/zend_language_scanner.l"
+#line 1841 "Zend/zend_language_scanner.l"
{
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
yy229:
YYDEBUG(229, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1946 "Zend/zend_language_scanner.l"
+#line 1944 "Zend/zend_language_scanner.l"
{
if (CG(asp_tags)) {
BEGIN(INITIAL);
yy235:
YYDEBUG(235, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1905 "Zend/zend_language_scanner.l"
+#line 1903 "Zend/zend_language_scanner.l"
{
int doc_com;
yy276:
YYDEBUG(276, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2067 "Zend/zend_language_scanner.l"
+#line 2065 "Zend/zend_language_scanner.l"
{
char *s;
int bprefix = (yytext[0] != '<') ? 1 : 0;
}
YYDEBUG(316, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1687 "Zend/zend_language_scanner.l"
+#line 1685 "Zend/zend_language_scanner.l"
{
if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
ZVAL_DUP(zendlval, &CG(current_namespace));
}
YYDEBUG(321, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1662 "Zend/zend_language_scanner.l"
+#line 1660 "Zend/zend_language_scanner.l"
{
zend_string *filename = zend_get_compiled_filename(TSRMLS_C);
zend_string *dirname;
}
YYDEBUG(327, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1647 "Zend/zend_language_scanner.l"
+#line 1645 "Zend/zend_language_scanner.l"
{
ZVAL_LONG(zendlval, CG(zend_lineno));
return T_LINE;
}
YYDEBUG(335, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1616 "Zend/zend_language_scanner.l"
+#line 1614 "Zend/zend_language_scanner.l"
{
if (CG(active_class_entry)) {
int len = 2;
}
YYDEBUG(346, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1606 "Zend/zend_language_scanner.l"
+#line 1604 "Zend/zend_language_scanner.l"
{
zend_op_array *op_array = CG(active_op_array);
if (op_array && op_array->function_name) {
}
YYDEBUG(351, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1652 "Zend/zend_language_scanner.l"
+#line 1650 "Zend/zend_language_scanner.l"
{
zend_string *filename = zend_get_compiled_filename(TSRMLS_C);
}
YYDEBUG(358, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1595 "Zend/zend_language_scanner.l"
+#line 1594 "Zend/zend_language_scanner.l"
{
zend_class_entry *ce = CG(active_class_entry);
if (ce && ce->name && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {
- ZVAL_STR(zendlval, ce->name);
- Z_ADDREF_P(zendlval);
+ ZVAL_STR(zendlval, STR_COPY(ce->name));
} else {
ZVAL_EMPTY_STRING(zendlval);
}
return T_TRAIT_C;
}
-#line 4421 "Zend/zend_language_scanner.c"
+#line 4420 "Zend/zend_language_scanner.c"
yy359:
YYDEBUG(359, *YYCURSOR);
yych = *++YYCURSOR;
Z_TYPE_P(zendlval) = IS_CONSTANT;
} else {
if (ce && ce->name) {
- ZVAL_STR(zendlval, ce->name);
- Z_ADDREF_P(zendlval);
+ ZVAL_STR(zendlval, STR_COPY(ce->name));
} else {
ZVAL_EMPTY_STRING(zendlval);
}
}
return T_CLASS_C;
}
-#line 4469 "Zend/zend_language_scanner.c"
+#line 4467 "Zend/zend_language_scanner.c"
yy366:
YYDEBUG(366, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_HALT_COMPILER;
}
-#line 4535 "Zend/zend_language_scanner.c"
+#line 4533 "Zend/zend_language_scanner.c"
yy379:
YYDEBUG(379, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_USE;
}
-#line 4559 "Zend/zend_language_scanner.c"
+#line 4557 "Zend/zend_language_scanner.c"
yy383:
YYDEBUG(383, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_UNSET;
}
-#line 4582 "Zend/zend_language_scanner.c"
+#line 4580 "Zend/zend_language_scanner.c"
yy387:
YYDEBUG(387, *YYCURSOR);
++YYCURSOR;
{
return T_INT_CAST;
}
-#line 4758 "Zend/zend_language_scanner.c"
+#line 4756 "Zend/zend_language_scanner.c"
yy405:
YYDEBUG(405, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_DOUBLE_CAST;
}
-#line 4806 "Zend/zend_language_scanner.c"
+#line 4804 "Zend/zend_language_scanner.c"
yy414:
YYDEBUG(414, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_STRING_CAST;
}
-#line 4880 "Zend/zend_language_scanner.c"
+#line 4878 "Zend/zend_language_scanner.c"
yy428:
YYDEBUG(428, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_ARRAY_CAST;
}
-#line 4917 "Zend/zend_language_scanner.c"
+#line 4915 "Zend/zend_language_scanner.c"
yy435:
YYDEBUG(435, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_OBJECT_CAST;
}
-#line 4959 "Zend/zend_language_scanner.c"
+#line 4957 "Zend/zend_language_scanner.c"
yy443:
YYDEBUG(443, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_BOOL_CAST;
}
-#line 5004 "Zend/zend_language_scanner.c"
+#line 5002 "Zend/zend_language_scanner.c"
yy451:
YYDEBUG(451, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_UNSET_CAST;
}
-#line 5068 "Zend/zend_language_scanner.c"
+#line 5066 "Zend/zend_language_scanner.c"
yy463:
YYDEBUG(463, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_VAR;
}
-#line 5086 "Zend/zend_language_scanner.c"
+#line 5084 "Zend/zend_language_scanner.c"
yy466:
YYDEBUG(466, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_NEW;
}
-#line 5110 "Zend/zend_language_scanner.c"
+#line 5108 "Zend/zend_language_scanner.c"
yy470:
YYDEBUG(470, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_NAMESPACE;
}
-#line 5153 "Zend/zend_language_scanner.c"
+#line 5151 "Zend/zend_language_scanner.c"
yy478:
YYDEBUG(478, *YYCURSOR);
yyaccept = 3;
{
return T_CONCAT_EQUAL;
}
-#line 5179 "Zend/zend_language_scanner.c"
+#line 5177 "Zend/zend_language_scanner.c"
yy482:
YYDEBUG(482, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_ELLIPSIS;
}
-#line 5192 "Zend/zend_language_scanner.c"
+#line 5190 "Zend/zend_language_scanner.c"
yy485:
YYDEBUG(485, *YYCURSOR);
++YYCURSOR;
{
return T_PAAMAYIM_NEKUDOTAYIM;
}
-#line 5202 "Zend/zend_language_scanner.c"
+#line 5200 "Zend/zend_language_scanner.c"
yy487:
YYDEBUG(487, *YYCURSOR);
++YYCURSOR;
{
return T_MINUS_EQUAL;
}
-#line 5228 "Zend/zend_language_scanner.c"
+#line 5226 "Zend/zend_language_scanner.c"
yy491:
YYDEBUG(491, *YYCURSOR);
++YYCURSOR;
{
return T_DEC;
}
-#line 5238 "Zend/zend_language_scanner.c"
+#line 5236 "Zend/zend_language_scanner.c"
yy493:
YYDEBUG(493, *YYCURSOR);
++YYCURSOR;
yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
return T_OBJECT_OPERATOR;
}
-#line 5249 "Zend/zend_language_scanner.c"
+#line 5247 "Zend/zend_language_scanner.c"
yy495:
YYDEBUG(495, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_PUBLIC;
}
-#line 5298 "Zend/zend_language_scanner.c"
+#line 5296 "Zend/zend_language_scanner.c"
yy502:
YYDEBUG(502, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_PROTECTED;
}
-#line 5357 "Zend/zend_language_scanner.c"
+#line 5355 "Zend/zend_language_scanner.c"
yy511:
YYDEBUG(511, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_PRIVATE;
}
-#line 5391 "Zend/zend_language_scanner.c"
+#line 5389 "Zend/zend_language_scanner.c"
yy517:
YYDEBUG(517, *YYCURSOR);
++YYCURSOR;
{
return T_PRINT;
}
-#line 5404 "Zend/zend_language_scanner.c"
+#line 5402 "Zend/zend_language_scanner.c"
yy519:
YYDEBUG(519, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_GOTO;
}
-#line 5433 "Zend/zend_language_scanner.c"
+#line 5431 "Zend/zend_language_scanner.c"
yy524:
YYDEBUG(524, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_GLOBAL;
}
-#line 5461 "Zend/zend_language_scanner.c"
+#line 5459 "Zend/zend_language_scanner.c"
yy529:
YYDEBUG(529, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_BREAK;
}
-#line 5502 "Zend/zend_language_scanner.c"
+#line 5500 "Zend/zend_language_scanner.c"
yy537:
YYDEBUG(537, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_SWITCH;
}
-#line 5546 "Zend/zend_language_scanner.c"
+#line 5544 "Zend/zend_language_scanner.c"
yy545:
YYDEBUG(545, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_STATIC;
}
-#line 5574 "Zend/zend_language_scanner.c"
+#line 5572 "Zend/zend_language_scanner.c"
yy550:
YYDEBUG(550, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_AS;
}
-#line 5605 "Zend/zend_language_scanner.c"
+#line 5603 "Zend/zend_language_scanner.c"
yy555:
YYDEBUG(555, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_ARRAY;
}
-#line 5628 "Zend/zend_language_scanner.c"
+#line 5626 "Zend/zend_language_scanner.c"
yy559:
YYDEBUG(559, *YYCURSOR);
++YYCURSOR;
{
return T_LOGICAL_AND;
}
-#line 5641 "Zend/zend_language_scanner.c"
+#line 5639 "Zend/zend_language_scanner.c"
yy561:
YYDEBUG(561, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_ABSTRACT;
}
-#line 5679 "Zend/zend_language_scanner.c"
+#line 5677 "Zend/zend_language_scanner.c"
yy568:
YYDEBUG(568, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_WHILE;
}
-#line 5707 "Zend/zend_language_scanner.c"
+#line 5705 "Zend/zend_language_scanner.c"
yy573:
YYDEBUG(573, *YYCURSOR);
++YYCURSOR;
{
return T_IF;
}
-#line 5720 "Zend/zend_language_scanner.c"
+#line 5718 "Zend/zend_language_scanner.c"
yy575:
YYDEBUG(575, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_ISSET;
}
-#line 5776 "Zend/zend_language_scanner.c"
+#line 5774 "Zend/zend_language_scanner.c"
yy582:
YYDEBUG(582, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_INCLUDE;
}
-#line 5834 "Zend/zend_language_scanner.c"
+#line 5832 "Zend/zend_language_scanner.c"
yy590:
YYDEBUG(590, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_INCLUDE_ONCE;
}
-#line 5867 "Zend/zend_language_scanner.c"
+#line 5865 "Zend/zend_language_scanner.c"
yy596:
YYDEBUG(596, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_INTERFACE;
}
-#line 5905 "Zend/zend_language_scanner.c"
+#line 5903 "Zend/zend_language_scanner.c"
yy603:
YYDEBUG(603, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_INSTEADOF;
}
-#line 5959 "Zend/zend_language_scanner.c"
+#line 5957 "Zend/zend_language_scanner.c"
yy611:
YYDEBUG(611, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_INSTANCEOF;
}
-#line 5992 "Zend/zend_language_scanner.c"
+#line 5990 "Zend/zend_language_scanner.c"
yy617:
YYDEBUG(617, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_IMPLEMENTS;
}
-#line 6040 "Zend/zend_language_scanner.c"
+#line 6038 "Zend/zend_language_scanner.c"
yy626:
YYDEBUG(626, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_TRY;
}
-#line 6072 "Zend/zend_language_scanner.c"
+#line 6070 "Zend/zend_language_scanner.c"
yy630:
YYDEBUG(630, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_TRAIT;
}
-#line 6095 "Zend/zend_language_scanner.c"
+#line 6093 "Zend/zend_language_scanner.c"
yy634:
YYDEBUG(634, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_THROW;
}
-#line 6118 "Zend/zend_language_scanner.c"
+#line 6116 "Zend/zend_language_scanner.c"
yy638:
YYDEBUG(638, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_YIELD;
}
-#line 6146 "Zend/zend_language_scanner.c"
+#line 6144 "Zend/zend_language_scanner.c"
yy643:
YYDEBUG(643, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_REQUIRE;
}
-#line 6211 "Zend/zend_language_scanner.c"
+#line 6209 "Zend/zend_language_scanner.c"
yy651:
YYDEBUG(651, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_REQUIRE_ONCE;
}
-#line 6244 "Zend/zend_language_scanner.c"
+#line 6242 "Zend/zend_language_scanner.c"
yy657:
YYDEBUG(657, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_RETURN;
}
-#line 6267 "Zend/zend_language_scanner.c"
+#line 6265 "Zend/zend_language_scanner.c"
yy661:
YYDEBUG(661, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_CONTINUE;
}
-#line 6361 "Zend/zend_language_scanner.c"
+#line 6359 "Zend/zend_language_scanner.c"
yy672:
YYDEBUG(672, *YYCURSOR);
++YYCURSOR;
{
return T_CONST;
}
-#line 6374 "Zend/zend_language_scanner.c"
+#line 6372 "Zend/zend_language_scanner.c"
yy674:
YYDEBUG(674, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_CLONE;
}
-#line 6403 "Zend/zend_language_scanner.c"
+#line 6401 "Zend/zend_language_scanner.c"
yy679:
YYDEBUG(679, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_CLASS;
}
-#line 6421 "Zend/zend_language_scanner.c"
+#line 6419 "Zend/zend_language_scanner.c"
yy682:
YYDEBUG(682, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_CALLABLE;
}
-#line 6471 "Zend/zend_language_scanner.c"
+#line 6469 "Zend/zend_language_scanner.c"
yy691:
YYDEBUG(691, *YYCURSOR);
++YYCURSOR;
{
return T_CASE;
}
-#line 6484 "Zend/zend_language_scanner.c"
+#line 6482 "Zend/zend_language_scanner.c"
yy693:
YYDEBUG(693, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_CATCH;
}
-#line 6502 "Zend/zend_language_scanner.c"
+#line 6500 "Zend/zend_language_scanner.c"
yy696:
YYDEBUG(696, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_FUNCTION;
}
-#line 6557 "Zend/zend_language_scanner.c"
+#line 6555 "Zend/zend_language_scanner.c"
yy706:
YYDEBUG(706, *YYCURSOR);
++YYCURSOR;
{
return T_FOR;
}
-#line 6585 "Zend/zend_language_scanner.c"
+#line 6583 "Zend/zend_language_scanner.c"
yy708:
YYDEBUG(708, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_FOREACH;
}
-#line 6613 "Zend/zend_language_scanner.c"
+#line 6611 "Zend/zend_language_scanner.c"
yy713:
YYDEBUG(713, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_FINAL;
}
-#line 6651 "Zend/zend_language_scanner.c"
+#line 6649 "Zend/zend_language_scanner.c"
yy717:
YYDEBUG(717, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_FINALLY;
}
-#line 6669 "Zend/zend_language_scanner.c"
+#line 6667 "Zend/zend_language_scanner.c"
yy720:
YYDEBUG(720, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_DO;
}
-#line 6704 "Zend/zend_language_scanner.c"
+#line 6702 "Zend/zend_language_scanner.c"
yy724:
YYDEBUG(724, *YYCURSOR);
++YYCURSOR;
{
return T_EXIT;
}
-#line 6717 "Zend/zend_language_scanner.c"
+#line 6715 "Zend/zend_language_scanner.c"
yy726:
YYDEBUG(726, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_DEFAULT;
}
-#line 6756 "Zend/zend_language_scanner.c"
+#line 6754 "Zend/zend_language_scanner.c"
yy733:
YYDEBUG(733, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_DECLARE;
}
-#line 6784 "Zend/zend_language_scanner.c"
+#line 6782 "Zend/zend_language_scanner.c"
yy738:
YYDEBUG(738, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_EXTENDS;
}
-#line 6868 "Zend/zend_language_scanner.c"
+#line 6866 "Zend/zend_language_scanner.c"
yy751:
YYDEBUG(751, *YYCURSOR);
++YYCURSOR;
{
return T_EXIT;
}
-#line 6881 "Zend/zend_language_scanner.c"
+#line 6879 "Zend/zend_language_scanner.c"
yy753:
YYDEBUG(753, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_EVAL;
}
-#line 6899 "Zend/zend_language_scanner.c"
+#line 6897 "Zend/zend_language_scanner.c"
yy756:
YYDEBUG(756, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_ENDWHILE;
}
-#line 6973 "Zend/zend_language_scanner.c"
+#line 6971 "Zend/zend_language_scanner.c"
yy767:
YYDEBUG(767, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_ENDSWITCH;
}
-#line 7006 "Zend/zend_language_scanner.c"
+#line 7004 "Zend/zend_language_scanner.c"
yy773:
YYDEBUG(773, *YYCURSOR);
++YYCURSOR;
{
return T_ENDIF;
}
-#line 7019 "Zend/zend_language_scanner.c"
+#line 7017 "Zend/zend_language_scanner.c"
yy775:
YYDEBUG(775, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_ENDFOR;
}
-#line 7052 "Zend/zend_language_scanner.c"
+#line 7050 "Zend/zend_language_scanner.c"
yy778:
YYDEBUG(778, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_ENDFOREACH;
}
-#line 7080 "Zend/zend_language_scanner.c"
+#line 7078 "Zend/zend_language_scanner.c"
yy783:
YYDEBUG(783, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_ENDDECLARE;
}
-#line 7118 "Zend/zend_language_scanner.c"
+#line 7116 "Zend/zend_language_scanner.c"
yy790:
YYDEBUG(790, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_EMPTY;
}
-#line 7141 "Zend/zend_language_scanner.c"
+#line 7139 "Zend/zend_language_scanner.c"
yy794:
YYDEBUG(794, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_ELSE;
}
-#line 7174 "Zend/zend_language_scanner.c"
+#line 7172 "Zend/zend_language_scanner.c"
yy797:
YYDEBUG(797, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_ELSEIF;
}
-#line 7192 "Zend/zend_language_scanner.c"
+#line 7190 "Zend/zend_language_scanner.c"
yy800:
YYDEBUG(800, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_ECHO;
}
-#line 7210 "Zend/zend_language_scanner.c"
+#line 7208 "Zend/zend_language_scanner.c"
}
/* *********************************** */
yyc_ST_LOOKING_FOR_PROPERTY:
HANDLE_NEWLINES(yytext, yyleng);
return T_WHITESPACE;
}
-#line 7290 "Zend/zend_language_scanner.c"
+#line 7288 "Zend/zend_language_scanner.c"
yy807:
YYDEBUG(807, *YYCURSOR);
++YYCURSOR;
yy_pop_state(TSRMLS_C);
goto restart;
}
-#line 7304 "Zend/zend_language_scanner.c"
+#line 7302 "Zend/zend_language_scanner.c"
yy809:
YYDEBUG(809, *YYCURSOR);
++YYCURSOR;
zend_copy_value(zendlval, yytext, yyleng);
return T_STRING;
}
-#line 7319 "Zend/zend_language_scanner.c"
+#line 7317 "Zend/zend_language_scanner.c"
yy811:
YYDEBUG(811, *YYCURSOR);
yych = *++YYCURSOR;
{
return T_OBJECT_OPERATOR;
}
-#line 7344 "Zend/zend_language_scanner.c"
+#line 7342 "Zend/zend_language_scanner.c"
yy816:
YYDEBUG(816, *YYCURSOR);
++YYCURSOR;
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
goto restart;
}
-#line 7436 "Zend/zend_language_scanner.c"
+#line 7434 "Zend/zend_language_scanner.c"
yy822:
YYDEBUG(822, *YYCURSOR);
yych = *++YYCURSOR;
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
return T_STRING_VARNAME;
}
-#line 7469 "Zend/zend_language_scanner.c"
+#line 7467 "Zend/zend_language_scanner.c"
}
/* *********************************** */
yyc_ST_NOWDOC:
++YYCURSOR;
YYDEBUG(831, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2320 "Zend/zend_language_scanner.l"
+#line 2318 "Zend/zend_language_scanner.l"
{
int newline = 0;
HANDLE_NEWLINES(yytext, yyleng - newline);
return T_ENCAPSED_AND_WHITESPACE;
}
-#line 7536 "Zend/zend_language_scanner.c"
+#line 7534 "Zend/zend_language_scanner.c"
/* *********************************** */
yyc_ST_VAR_OFFSET:
{
}
return T_NUM_STRING;
}
-#line 7652 "Zend/zend_language_scanner.c"
+#line 7650 "Zend/zend_language_scanner.c"
yy836:
YYDEBUG(836, *YYCURSOR);
yych = *++YYCURSOR;
yy838:
YYDEBUG(838, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1853 "Zend/zend_language_scanner.l"
+#line 1851 "Zend/zend_language_scanner.l"
{
/* Only '[' can be valid, but returning other tokens will allow a more explicit parse error */
return yytext[0];
}
-#line 7677 "Zend/zend_language_scanner.c"
+#line 7675 "Zend/zend_language_scanner.c"
yy839:
YYDEBUG(839, *YYCURSOR);
++YYCURSOR;
YYDEBUG(840, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1848 "Zend/zend_language_scanner.l"
+#line 1846 "Zend/zend_language_scanner.l"
{
yy_pop_state(TSRMLS_C);
return ']';
}
-#line 7688 "Zend/zend_language_scanner.c"
+#line 7686 "Zend/zend_language_scanner.c"
yy841:
YYDEBUG(841, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(843, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1858 "Zend/zend_language_scanner.l"
+#line 1856 "Zend/zend_language_scanner.l"
{
/* Invalid rule to return a more explicit parse error with proper line number */
yyless(0);
yy_pop_state(TSRMLS_C);
return T_ENCAPSED_AND_WHITESPACE;
}
-#line 7705 "Zend/zend_language_scanner.c"
+#line 7703 "Zend/zend_language_scanner.c"
yy844:
YYDEBUG(844, *YYCURSOR);
++YYCURSOR;
yy845:
YYDEBUG(845, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1865 "Zend/zend_language_scanner.l"
+#line 1863 "Zend/zend_language_scanner.l"
{
zend_copy_value(zendlval, yytext, yyleng);
return T_STRING;
}
-#line 7719 "Zend/zend_language_scanner.c"
+#line 7717 "Zend/zend_language_scanner.c"
yy846:
YYDEBUG(846, *YYCURSOR);
++YYCURSOR;
YYDEBUG(847, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2377 "Zend/zend_language_scanner.l"
+#line 2375 "Zend/zend_language_scanner.l"
{
if (YYCURSOR > YYLIMIT) {
return 0;
zend_error(E_COMPILE_WARNING,"Unexpected character in input: '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
goto restart;
}
-#line 7734 "Zend/zend_language_scanner.c"
+#line 7732 "Zend/zend_language_scanner.c"
yy848:
YYDEBUG(848, *YYCURSOR);
++YYCURSOR;
yy852:
YYDEBUG(852, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1843 "Zend/zend_language_scanner.l"
+#line 1841 "Zend/zend_language_scanner.l"
{
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
}
-#line 7775 "Zend/zend_language_scanner.c"
+#line 7773 "Zend/zend_language_scanner.c"
yy853:
YYDEBUG(853, *YYCURSOR);
++YYCURSOR;
ZVAL_STRINGL(zendlval, yytext, yyleng);
return T_NUM_STRING;
}
-#line 7820 "Zend/zend_language_scanner.c"
+#line 7818 "Zend/zend_language_scanner.c"
yy861:
YYDEBUG(861, *YYCURSOR);
++YYCURSOR;
goto yy860;
}
}
-#line 2386 "Zend/zend_language_scanner.l"
+#line 2384 "Zend/zend_language_scanner.l"
}
Z_TYPE_P(zendlval) = IS_CONSTANT;
} else {
if (ce && ce->name) {
- ZVAL_STR(zendlval, ce->name);
- Z_ADDREF_P(zendlval);
+ ZVAL_STR(zendlval, STR_COPY(ce->name));
} else {
ZVAL_EMPTY_STRING(zendlval);
}
<ST_IN_SCRIPTING>"__TRAIT__" {
zend_class_entry *ce = CG(active_class_entry);
if (ce && ce->name && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {
- ZVAL_STR(zendlval, ce->name);
- Z_ADDREF_P(zendlval);
+ ZVAL_STR(zendlval, STR_COPY(ce->name));
} else {
ZVAL_EMPTY_STRING(zendlval);
}
ZVAL_COPY_VALUE(&garbage, variable_ptr);
/* if we assign referenced variable, we should separate it */
- if (IS_REFCOUNTED(Z_TYPE_P(value))) {
+ if (Z_REFCOUNTED_P(value)) {
Z_ADDREF_P(value);
if (Z_ISREF_P(value)) {
SEPARATE_ZVAL(value);
}
} else if (EXPECTED(property_info != NULL)) {
/* if we assign referenced variable, we should separate it */
- if (IS_REFCOUNTED(Z_TYPE_P(value))) {
+ if (Z_REFCOUNTED_P(value)) {
if (Z_ISREF_P(value)) {
ZVAL_DUP(value, Z_REFVAL_P(value));
} else {
zend_std_call_getter(object, member, &rv TSRMLS_CC);
(*guard) &= ~IN_GET;
if (Z_TYPE(rv) != IS_UNDEF) {
- Z_ADDREF(rv);
+ if (Z_REFCOUNTED(rv)) Z_ADDREF(rv);
result = i_zend_is_true(&rv TSRMLS_CC);
zval_ptr_dtor(&rv);
} else {
#define Z_OBJ_INC_APPLY_COUNT_P(zv) Z_OBJ_INC_APPLY_COUNT(*(zv))
#define Z_OBJ_DEC_APPLY_COUNT_P(zv) Z_OBJ_DEC_APPLY_COUNT(*(zv))
-#define Z_REFCOUNTED(zval) IS_REFCOUNTED(Z_TYPE(zval))
+#define Z_REFCOUNTED(zval) (IS_REFCOUNTED(Z_TYPE(zval)) && \
+ (Z_TYPE(zval) != IS_STRING || \
+ !IS_INTERNED(Z_STR(zval))))
#define Z_REFCOUNTED_P(zval_p) Z_REFCOUNTED(*(zval_p))
#define Z_ISREF(zval) (Z_TYPE(zval) == IS_REFERENCE)
SEPARATE_ZVAL_TO_MAKE_IS_REF(p);
/*
if (!Z_ISREF_P(p)) {
- if (IS_REFCOUNTED(Z_TYPE_P(p)) && Z_REFCOUNT_P(p) > 1) {
+ if (Z_REFCOUNTED_P(p) && Z_REFCOUNT_P(p) > 1) {
Z_DELREF_P(p);
ZVAL_NEW_REF(p, p);
zval_copy_ctor(Z_REFVAL_P(p));
}
if (EXPECTED(retval != NULL)) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval))) Z_ADDREF_P(retval);
+ if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
switch (type) {
case BP_VAR_R:
case BP_VAR_IS:
} else {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
if (OP1_TYPE == IS_CV) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval_ptr))) Z_ADDREF_P(retval_ptr);
+ if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr);
}
}
}
//??? varptr = Z_REFVAL_P(varptr);
//??? }
} else if (OP1_TYPE == IS_CV) {
- if (IS_REFCOUNTED(Z_TYPE_P(varptr))) Z_ADDREF_P(varptr);
+ if (Z_REFCOUNTED_P(varptr)) Z_ADDREF_P(varptr);
}
zend_vm_stack_push(varptr TSRMLS_CC);
zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, param, opline->extended_value TSRMLS_CC);
var_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
- if (IS_REFCOUNTED(Z_TYPE_P(var_ptr))) Z_DELREF_P(var_ptr);
+ if (Z_REFCOUNTED_P(var_ptr)) Z_DELREF_P(var_ptr);
ZVAL_COPY(var_ptr, param);
}
convert_to_string(&tmp);
varname = &tmp;
} else if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
- Z_ADDREF_P(varname);
+ if (Z_REFCOUNTED_P(varname)) Z_ADDREF_P(varname);
}
if (OP2_TYPE != IS_UNUSED) {
break;
case IS_STRING:
if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
- Z_ADDREF_P(offset);
+ if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
}
if (OP2_TYPE != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, ZEND_VM_C_GOTO(num_index_dim));
zval tmp;
if (Z_TYPE_P(offset) != IS_LONG) {
- if (!Z_REFCOUNTED_P(offset) /* simple scalar types */
+ if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
value = GET_OP1_ZVAL_PTR(BP_VAR_R);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!IS_OP1_TMP_FREE()) {
zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, param, opline->extended_value TSRMLS_CC);
var_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
- if (IS_REFCOUNTED(Z_TYPE_P(var_ptr))) Z_DELREF_P(var_ptr);
+ if (Z_REFCOUNTED_P(var_ptr)) Z_DELREF_P(var_ptr);
ZVAL_COPY(var_ptr, param);
}
} else {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
if (IS_CONST == IS_CV) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval_ptr))) Z_ADDREF_P(retval_ptr);
+ if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr);
}
}
}
}
if (EXPECTED(retval != NULL)) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval))) Z_ADDREF_P(retval);
+ if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
switch (type) {
case BP_VAR_R:
case BP_VAR_IS:
convert_to_string(&tmp);
varname = &tmp;
} else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
- Z_ADDREF_P(varname);
+ if (Z_REFCOUNTED_P(varname)) Z_ADDREF_P(varname);
}
if (IS_CONST != IS_UNUSED) {
value = opline->op1.zv;
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
value = opline->op1.zv;
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
}
if (EXPECTED(retval != NULL)) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval))) Z_ADDREF_P(retval);
+ if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
switch (type) {
case BP_VAR_R:
case BP_VAR_IS:
convert_to_string(&tmp);
varname = &tmp;
} else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
- Z_ADDREF_P(varname);
+ if (Z_REFCOUNTED_P(varname)) Z_ADDREF_P(varname);
}
if (IS_VAR != IS_UNUSED) {
value = opline->op1.zv;
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
}
if (EXPECTED(retval != NULL)) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval))) Z_ADDREF_P(retval);
+ if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
switch (type) {
case BP_VAR_R:
case BP_VAR_IS:
convert_to_string(&tmp);
varname = &tmp;
} else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
- Z_ADDREF_P(varname);
+ if (Z_REFCOUNTED_P(varname)) Z_ADDREF_P(varname);
}
if (IS_UNUSED != IS_UNUSED) {
value = opline->op1.zv;
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
value = opline->op1.zv;
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
} else {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
if (IS_TMP_VAR == IS_CV) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval_ptr))) Z_ADDREF_P(retval_ptr);
+ if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr);
}
}
}
}
if (EXPECTED(retval != NULL)) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval))) Z_ADDREF_P(retval);
+ if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
switch (type) {
case BP_VAR_R:
case BP_VAR_IS:
convert_to_string(&tmp);
varname = &tmp;
} else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
- Z_ADDREF_P(varname);
+ if (Z_REFCOUNTED_P(varname)) Z_ADDREF_P(varname);
}
if (IS_CONST != IS_UNUSED) {
value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!1) {
value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!1) {
}
if (EXPECTED(retval != NULL)) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval))) Z_ADDREF_P(retval);
+ if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
switch (type) {
case BP_VAR_R:
case BP_VAR_IS:
convert_to_string(&tmp);
varname = &tmp;
} else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
- Z_ADDREF_P(varname);
+ if (Z_REFCOUNTED_P(varname)) Z_ADDREF_P(varname);
}
if (IS_VAR != IS_UNUSED) {
value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!1) {
}
if (EXPECTED(retval != NULL)) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval))) Z_ADDREF_P(retval);
+ if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
switch (type) {
case BP_VAR_R:
case BP_VAR_IS:
convert_to_string(&tmp);
varname = &tmp;
} else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
- Z_ADDREF_P(varname);
+ if (Z_REFCOUNTED_P(varname)) Z_ADDREF_P(varname);
}
if (IS_UNUSED != IS_UNUSED) {
value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!1) {
value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!1) {
} else {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
if (IS_VAR == IS_CV) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval_ptr))) Z_ADDREF_P(retval_ptr);
+ if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr);
}
}
}
//??? varptr = Z_REFVAL_P(varptr);
//??? }
} else if (IS_VAR == IS_CV) {
- if (IS_REFCOUNTED(Z_TYPE_P(varptr))) Z_ADDREF_P(varptr);
+ if (Z_REFCOUNTED_P(varptr)) Z_ADDREF_P(varptr);
}
zend_vm_stack_push(varptr TSRMLS_CC);
}
if (EXPECTED(retval != NULL)) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval))) Z_ADDREF_P(retval);
+ if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
switch (type) {
case BP_VAR_R:
case BP_VAR_IS:
convert_to_string(&tmp);
varname = &tmp;
} else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
- Z_ADDREF_P(varname);
+ if (Z_REFCOUNTED_P(varname)) Z_ADDREF_P(varname);
}
if (IS_CONST != IS_UNUSED) {
break;
case IS_STRING:
if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
- Z_ADDREF_P(offset);
+ if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
}
if (IS_CONST != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
zval tmp;
if (Z_TYPE_P(offset) != IS_LONG) {
- if (!Z_REFCOUNTED_P(offset) /* simple scalar types */
+ if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
break;
case IS_STRING:
if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
- Z_ADDREF_P(offset);
+ if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
}
if (IS_TMP_VAR != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
zval tmp;
if (Z_TYPE_P(offset) != IS_LONG) {
- if (!Z_REFCOUNTED_P(offset) /* simple scalar types */
+ if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
}
if (EXPECTED(retval != NULL)) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval))) Z_ADDREF_P(retval);
+ if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
switch (type) {
case BP_VAR_R:
case BP_VAR_IS:
convert_to_string(&tmp);
varname = &tmp;
} else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
- Z_ADDREF_P(varname);
+ if (Z_REFCOUNTED_P(varname)) Z_ADDREF_P(varname);
}
if (IS_VAR != IS_UNUSED) {
break;
case IS_STRING:
if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
- Z_ADDREF_P(offset);
+ if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
}
if (IS_VAR != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
zval tmp;
if (Z_TYPE_P(offset) != IS_LONG) {
- if (!Z_REFCOUNTED_P(offset) /* simple scalar types */
+ if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
}
if (EXPECTED(retval != NULL)) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval))) Z_ADDREF_P(retval);
+ if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
switch (type) {
case BP_VAR_R:
case BP_VAR_IS:
convert_to_string(&tmp);
varname = &tmp;
} else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
- Z_ADDREF_P(varname);
+ if (Z_REFCOUNTED_P(varname)) Z_ADDREF_P(varname);
}
if (IS_UNUSED != IS_UNUSED) {
value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
break;
case IS_STRING:
if (IS_CV == IS_CV || IS_CV == IS_VAR) {
- Z_ADDREF_P(offset);
+ if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
}
if (IS_CV != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
zval tmp;
if (Z_TYPE_P(offset) != IS_LONG) {
- if (!Z_REFCOUNTED_P(offset) /* simple scalar types */
+ if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
break;
case IS_STRING:
if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
- Z_ADDREF_P(offset);
+ if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
}
if (IS_CONST != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
zval tmp;
if (Z_TYPE_P(offset) != IS_LONG) {
- if (!Z_REFCOUNTED_P(offset) /* simple scalar types */
+ if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
value = NULL;
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
break;
case IS_STRING:
if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
- Z_ADDREF_P(offset);
+ if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
}
if (IS_TMP_VAR != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
zval tmp;
if (Z_TYPE_P(offset) != IS_LONG) {
- if (!Z_REFCOUNTED_P(offset) /* simple scalar types */
+ if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
value = NULL;
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
break;
case IS_STRING:
if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
- Z_ADDREF_P(offset);
+ if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
}
if (IS_VAR != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
zval tmp;
if (Z_TYPE_P(offset) != IS_LONG) {
- if (!Z_REFCOUNTED_P(offset) /* simple scalar types */
+ if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
value = NULL;
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
value = NULL;
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
break;
case IS_STRING:
if (IS_CV == IS_CV || IS_CV == IS_VAR) {
- Z_ADDREF_P(offset);
+ if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
}
if (IS_CV != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
zval tmp;
if (Z_TYPE_P(offset) != IS_LONG) {
- if (!Z_REFCOUNTED_P(offset) /* simple scalar types */
+ if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
value = NULL;
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
} else {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
if (IS_CV == IS_CV) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval_ptr))) Z_ADDREF_P(retval_ptr);
+ if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr);
}
}
}
//??? varptr = Z_REFVAL_P(varptr);
//??? }
} else if (IS_CV == IS_CV) {
- if (IS_REFCOUNTED(Z_TYPE_P(varptr))) Z_ADDREF_P(varptr);
+ if (Z_REFCOUNTED_P(varptr)) Z_ADDREF_P(varptr);
}
zend_vm_stack_push(varptr TSRMLS_CC);
}
if (EXPECTED(retval != NULL)) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval))) Z_ADDREF_P(retval);
+ if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
switch (type) {
case BP_VAR_R:
case BP_VAR_IS:
convert_to_string(&tmp);
varname = &tmp;
} else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
- Z_ADDREF_P(varname);
+ if (Z_REFCOUNTED_P(varname)) Z_ADDREF_P(varname);
}
if (IS_CONST != IS_UNUSED) {
break;
case IS_STRING:
if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
- Z_ADDREF_P(offset);
+ if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
}
if (IS_CONST != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
zval tmp;
if (Z_TYPE_P(offset) != IS_LONG) {
- if (!Z_REFCOUNTED_P(offset) /* simple scalar types */
+ if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
break;
case IS_STRING:
if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
- Z_ADDREF_P(offset);
+ if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
}
if (IS_TMP_VAR != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
zval tmp;
if (Z_TYPE_P(offset) != IS_LONG) {
- if (!Z_REFCOUNTED_P(offset) /* simple scalar types */
+ if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
}
if (EXPECTED(retval != NULL)) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval))) Z_ADDREF_P(retval);
+ if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
switch (type) {
case BP_VAR_R:
case BP_VAR_IS:
convert_to_string(&tmp);
varname = &tmp;
} else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
- Z_ADDREF_P(varname);
+ if (Z_REFCOUNTED_P(varname)) Z_ADDREF_P(varname);
}
if (IS_VAR != IS_UNUSED) {
break;
case IS_STRING:
if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
- Z_ADDREF_P(offset);
+ if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
}
if (IS_VAR != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
zval tmp;
if (Z_TYPE_P(offset) != IS_LONG) {
- if (!Z_REFCOUNTED_P(offset) /* simple scalar types */
+ if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
}
if (EXPECTED(retval != NULL)) {
- if (IS_REFCOUNTED(Z_TYPE_P(retval))) Z_ADDREF_P(retval);
+ if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
switch (type) {
case BP_VAR_R:
case BP_VAR_IS:
convert_to_string(&tmp);
varname = &tmp;
} else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
- Z_ADDREF_P(varname);
+ if (Z_REFCOUNTED_P(varname)) Z_ADDREF_P(varname);
}
if (IS_UNUSED != IS_UNUSED) {
value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
break;
case IS_STRING:
if (IS_CV == IS_CV || IS_CV == IS_VAR) {
- Z_ADDREF_P(offset);
+ if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
}
if (IS_CV != IS_CONST) {
ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
zval tmp;
if (Z_TYPE_P(offset) != IS_LONG) {
- if (!Z_REFCOUNTED_P(offset) /* simple scalar types */
+ if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
ZVAL_COPY_VALUE(&generator->value, value);
- Z_SET_REFCOUNT(generator->value, 1);
+ if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
/* Temporary variables don't need ctor copying */
if (!0) {
zval member; \
ZVAL_STRINGL(&member, name, sizeof(name)-1); \
zend_std_write_property(object, &member, value, NULL TSRMLS_CC); \
- Z_DELREF_P(value); \
+ if (Z_REFCOUNTED_P(value)) Z_DELREF_P(value); \
zval_ptr_dtor(&member); \
} while (0)
/* ..for each one, create a new zval, copy entry into it and copy it into the output hash */
for (i = 0; i < list_count; i++) {
entry = &list[i];
- if (IS_REFCOUNTED(Z_TYPE_P(entry))) Z_ADDREF_P(entry);
+ if (Z_REFCOUNTED_P(entry)) Z_ADDREF_P(entry);
zend_hash_next_index_insert(out_hash, entry);
}
}
p = in_hash->arData + idx;
if (Z_TYPE(p->val) == IS_UNDEF) continue;
entry = &p->val;
- if (IS_REFCOUNTED(Z_TYPE_P(entry))) Z_ADDREF_P(entry);
+ if (Z_REFCOUNTED_P(entry)) Z_ADDREF_P(entry);
if (p->key == NULL) {
zend_hash_next_index_insert(out_hash, entry);
} else {
}
for (i = 0; i < shutdown_function_entry.arg_count; i++) {
- Z_ADDREF(shutdown_function_entry.arguments[i]);
+ if (Z_REFCOUNTED(shutdown_function_entry.arguments[i])) Z_ADDREF(shutdown_function_entry.arguments[i]);
}
zend_hash_next_index_insert_mem(BG(user_shutdown_function_names), &shutdown_function_entry, sizeof(php_shutdown_function_entry));
}
projects / php / commitdiff