again:
switch (Z_TYPE_P(expr)) {
case IS_NULL:
- Z_STR_P(expr_copy) = STR_EMPTY_ALLOC();
+ ZVAL_EMPTY_STRING(expr_copy);
break;
case IS_BOOL:
if (Z_LVAL_P(expr)) {
// TODO: ??? use interned string
- Z_STR_P(expr_copy) = STR_INIT("1", 1, 0);
+ ZVAL_NEW_STR(expr_copy, STR_INIT("1", 1, 0));
} else {
- Z_STR_P(expr_copy) = STR_EMPTY_ALLOC();
+ ZVAL_EMPTY_STRING(expr_copy);
}
break;
case IS_RESOURCE: {
int len;
len = snprintf(buf, sizeof(buf), "Resource id #%ld", Z_RES_HANDLE_P(expr));
- Z_STR_P(expr_copy) = STR_INIT(buf, len, 0);
+ ZVAL_NEW_STR(expr_copy, STR_INIT(buf, len, 0));
}
break;
case IS_ARRAY:
zend_error(E_NOTICE, "Array to string conversion");
// TODO: ??? use interned string
- Z_STR_P(expr_copy) = STR_INIT("Array", sizeof("Array") - 1, 0);
+ ZVAL_NEW_STR(expr_copy, STR_INIT("Array", sizeof("Array") - 1, 0));
break;
case IS_OBJECT:
{
zval_ptr_dtor(z);
}
zend_error(EG(exception) ? E_ERROR : E_RECOVERABLE_ERROR, "Object of class %s could not be converted to string", Z_OBJCE_P(expr)->name->val);
- Z_STR_P(expr_copy) = STR_EMPTY_ALLOC();
+ ZVAL_EMPTY_STRING(expr_copy);
}
break;
case IS_DOUBLE:
convert_to_string(expr_copy);
break;
}
- Z_TYPE_P(expr_copy) = IS_STRING;
*use_copy = 1;
}
/* }}} */
#endif
va_copy(usr_copy, args);
len = zend_vspprintf(&str, 0, format, usr_copy);
- ZVAL_STR(¶ms[1], STR_INIT(str, len, 0));
+ ZVAL_NEW_STR(¶ms[1], STR_INIT(str, len, 0));
efree(str);
#ifdef va_copy
va_end(usr_copy);
zval *_z1 = (z); \
zval *_z2 = (v); \
(_z1)->value = (_z2)->value; \
- Z_TYPE_P(_z1) = Z_TYPE_P(_z2); \
+ Z_TYPE_INFO_P(_z1) = Z_TYPE_INFO_P(_z2); \
} while (0)
#define ZVAL_COPY(z, v) \
ZEND_ASSERT(Z_ISREF_P(_z)); \
ref = Z_REF_P(_z); \
ZVAL_COPY_VALUE(_z, &ref->val); \
- GC_REMOVE_FROM_BUFFER(ref); \
efree(ref); \
} while (0)
Z_UNSET_ISREF_P(z); \
} while (0)
-// TODO: support objects and resources in more optimal way ???
-#define SEPARATE_ZVAL(zv) do { \
- zval *_zv = (zv); \
- if (Z_REFCOUNTED_P(_zv)) { \
- if (Z_REFCOUNT_P(_zv) > 1) { \
- if (Z_ISREF_P(_zv)) { \
- Z_DELREF_P(_zv); \
- ZVAL_DUP(_zv, Z_REFVAL_P(_zv)); \
- } else if (Z_TYPE_P(_zv) != IS_OBJECT &&\
- Z_TYPE_P(_zv) != IS_RESOURCE) { \
- Z_DELREF_P(_zv); \
- zval_copy_ctor(_zv); \
- } \
- } \
- } \
+#define SEPARATE_ZVAL(zv) do { \
+ zval *_zv = (zv); \
+ if (Z_REFCOUNTED_P(_zv)) { \
+ if (Z_REFCOUNT_P(_zv) > 1) { \
+ if (Z_ISREF_P(_zv)) { \
+ Z_DELREF_P(_zv); \
+ ZVAL_DUP(_zv, Z_REFVAL_P(_zv)); \
+ } else if (Z_TYPE_FLAGS_P(_zv) & IS_TYPE_COPYABLE) { \
+ Z_DELREF_P(_zv); \
+ zval_copy_ctor_func(_zv); \
+ } \
+ } \
+ } \
} while (0)
-#define SEPARATE_ZVAL_IF_NOT_REF(zv) do { \
- zval *__zv = (zv); \
- if (!Z_ISREF_P(__zv)) { \
- SEPARATE_ZVAL(__zv); \
- } \
+#define SEPARATE_ZVAL_IF_NOT_REF(zv) do { \
+ zval *_zv = (zv); \
+ if (!Z_ISREF_P(_zv) && \
+ (Z_TYPE_FLAGS_P(_zv) & IS_TYPE_COPYABLE) && \
+ Z_REFCOUNT_P(_zv) > 1) { \
+ Z_DELREF_P(_zv); \
+ zval_copy_ctor_func(_zv); \
+ } \
} while (0)
-#define SEPARATE_ZVAL_IF_REF(zv) do { \
- zval *__zv = (zv); \
- if (Z_ISREF_P(__zv)) { \
- if (Z_REFCOUNT_P(__zv) == 1) { \
- ZVAL_UNREF(__zv); \
- } else { \
- Z_DELREF_P(__zv); \
- ZVAL_DUP(__zv, Z_REFVAL_P(__zv)); \
- } \
- } \
+#define SEPARATE_ZVAL_IF_REF(zv) do { \
+ zval *__zv = (zv); \
+ if (Z_ISREF_P(__zv)) { \
+ if (Z_REFCOUNT_P(__zv) == 1) { \
+ ZVAL_UNREF(__zv); \
+ } else { \
+ Z_DELREF_P(__zv); \
+ ZVAL_DUP(__zv, Z_REFVAL_P(__zv)); \
+ } \
+ } \
} while (0)
-#define SEPARATE_ZVAL_TO_MAKE_IS_REF(zv) do { \
- zval *__zv = (zv); \
- if (!Z_ISREF_P(__zv)) { \
- if (!Z_REFCOUNTED_P(__zv) || \
- Z_REFCOUNT_P(__zv) == 1) { \
- ZVAL_NEW_REF(__zv, __zv); \
- } else { \
- zval ref; \
- ZVAL_COPY_VALUE(&ref, __zv); \
- SEPARATE_ZVAL(&ref); \
- ZVAL_NEW_REF(__zv, &ref); \
- } \
- } \
+#define SEPARATE_ZVAL_TO_MAKE_IS_REF(zv) do { \
+ zval *__zv = (zv); \
+ if (!Z_ISREF_P(__zv)) { \
+ if (!(Z_TYPE_FLAGS_P(__zv) & IS_TYPE_COPYABLE) || \
+ Z_REFCOUNT_P(__zv) == 1) { \
+ ZVAL_NEW_REF(__zv, __zv); \
+ } else { \
+ Z_DELREF_P(__zv); \
+ ZVAL_NEW_REF(__zv, __zv); \
+ zval_copy_ctor_func(Z_REFVAL_P(__zv)); \
+ } \
+ } \
} while (0)
#define COPY_PZVAL_TO_ZVAL(zv, pzv) \
Z_ADDREF_P(z);
if(Z_TYPE_P(z) != IS_OBJECT) {
zval_dtor(arg);
- Z_TYPE_P(arg) = IS_NULL;
+ ZVAL_NULL(arg);
zend_make_printable_zval(z, arg, &use_copy);
if (!use_copy) {
ZVAL_ZVAL(arg, z, 1, 1);
Z_ADDREF_P(z);
if(Z_TYPE_P(z) != IS_OBJECT) {
zval_dtor(arg);
- Z_TYPE_P(arg) = IS_NULL;
+ ZVAL_NULL(arg);
zend_make_printable_zval(z, arg, &use_copy);
if (!use_copy) {
ZVAL_ZVAL(arg, z, 1, 1);
static int zval_update_class_constant(zval *pp, int is_static, int offset TSRMLS_DC) /* {{{ */
{
ZVAL_DEREF(pp);
- if (IS_CONSTANT_TYPE(Z_TYPE_P(pp))) {
+ if (Z_TYPE_FLAGS_P(pp) & IS_TYPE_CONSTANT) {
zend_class_entry **scope = EG(in_execution)?&EG(scope):&CG(active_class_entry);
if ((*scope)->parent) {
{
zval property;
- ZVAL_STR(&property, STR_INIT(value, strlen(value), ce->type & ZEND_INTERNAL_CLASS));
+ ZVAL_NEW_STR(&property, STR_INIT(value, strlen(value), ce->type & ZEND_INTERNAL_CLASS));
return zend_declare_property(ce, name, name_length, &property, access_type TSRMLS_CC);
}
/* }}} */
{
zval property;
- ZVAL_STR(&property, STR_INIT(value, value_len, ce->type & ZEND_INTERNAL_CLASS));
+ ZVAL_NEW_STR(&property, STR_INIT(value, value_len, ce->type & ZEND_INTERNAL_CLASS));
return zend_declare_property(ce, name, name_length, &property, access_type TSRMLS_CC);
}
/* }}} */
{
zval constant;
- ZVAL_STR(&constant, STR_INIT(value, value_length, ce->type & ZEND_INTERNAL_CLASS));
+ ZVAL_NEW_STR(&constant, STR_INIT(value, value_length, ce->type & ZEND_INTERNAL_CLASS));
return zend_declare_class_constant(ce, name, name_length, &constant TSRMLS_CC);
}
/* }}} */
#define CHECK_NULL_PATH(p, l) (strlen(p) != l)
#define ZVAL_STRINGL(z, s, l) do { \
- ZVAL_STR(z, STR_INIT(s, l, 0)); \
+ ZVAL_NEW_STR(z, STR_INIT(s, l, 0)); \
} while (0)
#define ZVAL_STRING(z, s) do { \
} while (0)
#define ZVAL_EMPTY_STRING(z) do { \
- ZVAL_STR(z, STR_EMPTY_ALLOC()); \
+ ZVAL_INT_STR(z, STR_EMPTY_ALLOC()); \
} while (0)
#define ZVAL_PSTRINGL(z, s, l) do { \
- ZVAL_STR(z, STR_INIT(s, l, 1)); \
+ ZVAL_NEW_STR(z, STR_INIT(s, l, 1)); \
} while (0)
#define ZVAL_PSTRING(z, s) do { \
#define RETVAL_LONG(l) ZVAL_LONG(return_value, l)
#define RETVAL_DOUBLE(d) ZVAL_DOUBLE(return_value, d)
#define RETVAL_STR(s) ZVAL_STR(return_value, s)
+#define RETVAL_INT_STR(s) ZVAL_INT_STR(return_value, s)
+#define RETVAL_NEW_STR(s) ZVAL_NEW_STR(return_value, s)
#define RETVAL_STRING(s) ZVAL_STRING(return_value, s)
#define RETVAL_STRINGL(s, l) ZVAL_STRINGL(return_value, s, l)
#define RETVAL_EMPTY_STRING() ZVAL_EMPTY_STRING(return_value)
#define RETURN_LONG(l) { RETVAL_LONG(l); return; }
#define RETURN_DOUBLE(d) { RETVAL_DOUBLE(d); return; }
#define RETURN_STR(s) { RETVAL_STR(s); return; }
+#define RETURN_INT_STR(s) { RETVAL_INT_STR(s); return; }
+#define RETURN_NEW_STR(s) { RETVAL_NEW_STR(s); return; }
#define RETURN_STRING(s) { RETVAL_STRING(s); return; }
#define RETURN_STRINGL(s, l) { RETVAL_STRINGL(s, l); return; }
#define RETURN_EMPTY_STRING() { RETVAL_EMPTY_STRING(); return; }
#define perealloc_recoverable_rel(ptr, size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc_recoverable_rel((ptr), (size)))
#define pestrdup_rel(s, persistent) ((persistent)?strdup(s):estrdup_rel(s))
-#define safe_estrdup(ptr) ((ptr)?(estrdup(ptr)):STR_EMPTY_ALLOC())
-#define safe_estrndup(ptr, len) ((ptr)?(estrndup((ptr), (len))):STR_EMPTY_ALLOC())
+//???#define safe_estrdup(ptr) ((ptr)?(estrdup(ptr)):STR_EMPTY_ALLOC())
+//???#define safe_estrndup(ptr, len) ((ptr)?(estrndup((ptr), (len))):STR_EMPTY_ALLOC())
ZEND_API int zend_set_memory_limit(size_t memory_limit TSRMLS_DC);
int i;
if (ast->kind == ZEND_CONST) {
- return !IS_CONSTANT_TYPE(Z_TYPE(ast->u.val));
+ return !(Z_TYPE_FLAGS(ast->u.val) & IS_TYPE_CONSTANT);
} else {
for (i = 0; i < ast->children; i++) {
if ((&ast->u.child)[i]) {
break;
case ZEND_CONST:
ZVAL_DUP(result, &ast->u.val);
- if (IS_CONSTANT_TYPE(Z_TYPE_P(result))) {
+ if (Z_TYPE_FLAGS_P(result) & IS_TYPE_CONSTANT) {
zval_update_constant_ex(result, (void *) 1, scope TSRMLS_CC);
}
break;
/* this is necessary to make it able to work with default array
* properties, returned to user */
- if (IS_CONSTANT_TYPE(Z_TYPE(prop_copy))) {
+ if (Z_TYPE_FLAGS(prop_copy) & IS_TYPE_CONSTANT) {
zval_update_constant(&prop_copy, 0 TSRMLS_CC);
}
}
/* NULL, name length, filename length, last accepting char position length */
- ZVAL_STR(result, STR_ALLOC(1+name_length+strlen(filename)+char_pos_len, 0));
+ ZVAL_NEW_STR(result, STR_ALLOC(1+name_length+strlen(filename)+char_pos_len, 0));
/* must be binary safe */
Z_STRVAL_P(result)[0] = '\0';
if (Z_TYPE_P(zv) == IS_STRING || Z_TYPE_P(zv) == IS_CONSTANT) {
STR_HASH_VAL(Z_STR_P(zv));
Z_STR_P(zv) = zend_new_interned_string(Z_STR_P(zv) TSRMLS_CC);
+ if (IS_INTERNED(Z_STR_P(zv))) {
+ Z_TYPE_FLAGS_P(zv) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+ }
}
ZVAL_COPY_VALUE(&CONSTANT_EX(op_array, literal_position), zv);
//??? Z_SET_REFCOUNT(CONSTANT_EX(op_array, literal_position), 2);
lc_name = STR_ALLOC(Z_STRLEN_P(zv), 0);
zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
- ZVAL_STR(&c, lc_name);
+ ZVAL_NEW_STR(&c, lc_name);
zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
return ret;
lc_name = STR_ALLOC(Z_STRLEN_P(zv), 0);
zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
- ZVAL_STR(&c, lc_name);
+ ZVAL_NEW_STR(&c, lc_name);
zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
ns_separator = (const char*)zend_memrchr(Z_STRVAL_P(zv), '\\', Z_STRLEN_P(zv));
lc_len = Z_STRLEN_P(zv) - (ns_separator - Z_STRVAL_P(zv));
lc_name = STR_ALLOC(lc_len, 0);
zend_str_tolower_copy(lc_name->val, ns_separator, lc_len);
- ZVAL_STR(&c, lc_name);
+ ZVAL_NEW_STR(&c, lc_name);
zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
}
lc_name = STR_ALLOC(Z_STRLEN_P(zv), 0);
zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
}
- ZVAL_STR(&c, lc_name);
+ ZVAL_NEW_STR(&c, lc_name);
zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
GET_CACHE_SLOT(ret);
/* lowercased namespace name & original constant name */
tmp_name = STR_INIT(name, name_len, 0);
zend_str_tolower(tmp_name->val, ns_len);
- ZVAL_STR(&c, tmp_name);
+ ZVAL_NEW_STR(&c, tmp_name);
zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
/* lowercased namespace name & lowercased constant name */
tmp_name = STR_ALLOC(name_len, 0);
zend_str_tolower_copy(tmp_name->val, name, name_len);
- ZVAL_STR(&c, tmp_name);
+ ZVAL_NEW_STR(&c, tmp_name);
zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
}
/* original constant name */
tmp_name = STR_INIT(name, name_len, 0);
- ZVAL_STR(&c, tmp_name);
+ ZVAL_NEW_STR(&c, tmp_name);
zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
/* lowercased constant name */
tmp_name = STR_ALLOC(name_len, 0);
zend_str_tolower_copy(tmp_name->val, name, name_len);
- ZVAL_STR(&c, tmp_name);
+ ZVAL_NEW_STR(&c, tmp_name);
zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
return ret;
zend_resolve_class_name(class_type TSRMLS_CC);
}
Z_STR(class_type->u.constant) = zend_new_interned_string(Z_STR(class_type->u.constant) TSRMLS_CC);
+ if (IS_INTERNED(Z_STR(class_type->u.constant))) {
+ Z_TYPE_FLAGS(class_type->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+ }
//???: for now we have to copy it :(
#if 1
cur_arg_info->class_name = estrndup(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant));
if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
tmp = *element_name;
Z_STR(tmp.u.constant) = STR_ALLOC(sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN(CG(current_namespace)), 0);
+ Z_TYPE_FLAGS(tmp.u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace))]), "\\", sizeof("\\")-1);
memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRLEN(element_name->u.constant)+1);
Z_STR(class_name->u.constant) = STR_REALLOC(
Z_STR(class_name->u.constant),
Z_STRLEN(class_name->u.constant) - 1, 0);
+ Z_TYPE_FLAGS(class_name->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", Z_STRVAL(class_name->u.constant));
opline->op1.opline_num = dest->opline_num;
zval_dtor(label);
- Z_TYPE_P(label) = IS_NULL;
+ ZVAL_NULL(label);
/* Check that we are not moving into loop or switch */
current = opline->extended_value;
int old_len = Z_STRLEN(result->u.constant);
length = sizeof("::")-1 + old_len + Z_STRLEN(name->u.constant);
Z_STR(result->u.constant) = STR_REALLOC(Z_STR(result->u.constant), length, 0);
+ Z_TYPE_FLAGS(result->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
memcpy(&Z_STRVAL(result->u.constant)[old_len], "::", sizeof("::")-1);
memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("::")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1);
STR_RELEASE(Z_STR(name->u.constant));
int old_len = Z_STRLEN(result->u.constant);
length = sizeof("\\")-1 + old_len + Z_STRLEN(name->u.constant);
Z_STR(result->u.constant) = STR_REALLOC(Z_STR(result->u.constant), length, 0);
+ Z_TYPE_FLAGS(result->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
memcpy(&Z_STRVAL(result->u.constant)[old_len], "\\", sizeof("\\")-1);
memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("\\")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1);
STR_RELEASE(Z_STR(name->u.constant));
}
Z_STR(var_name->u.constant) = zend_new_interned_string(Z_STR(var_name->u.constant) TSRMLS_CC);
+ if (IS_INTERNED(Z_STR(var_name->u.constant))) {
+ Z_TYPE_FLAGS(var_name->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+ }
zend_declare_property_ex(CG(active_class_entry), Z_STR(var_name->u.constant), &property, access_type, comment TSRMLS_CC);
//??? efree(Z_STRVAL(var_name->u.constant));
STR_RELEASE(Z_STR(var_name->u.constant));
ZVAL_COPY_VALUE(&property, &value->u.constant);
Z_STR(var_name->u.constant) = zend_new_interned_string(Z_STR(var_name->u.constant) TSRMLS_CC);
+ if (IS_INTERNED(Z_STR(var_name->u.constant))) {
+ Z_TYPE_FLAGS(var_name->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+ }
if (zend_hash_add(&CG(active_class_entry)->constants_table, Z_STR(var_name->u.constant), &property) == NULL) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant));
}
if (all_internal_constants_substitution &&
(c->flags & CONST_PERSISTENT) &&
!(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION) &&
- !IS_CONSTANT_TYPE(Z_TYPE(c->value))) {
+ !(Z_TYPE_FLAGS(c->value) & IS_TYPE_CONSTANT)) {
return c;
}
return NULL;
}
zend_do_build_full_name(NULL, constant_container, constant_name, 1 TSRMLS_CC);
*result = *constant_container;
- Z_TYPE(result->u.constant) = IS_CONSTANT | fetch_type;
+//???
+ Z_TYPE_INFO(result->u.constant) = IS_CONSTANT_EX;
+ if (IS_INTERNED(Z_STR(result->u.constant))) {
+ Z_TYPE_FLAGS(result->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+ }
+ Z_CONST_FLAGS(result->u.constant) = fetch_type;
break;
case ZEND_RT:
if (constant_container->op_type == IS_CONST &&
}
*result = *constant_name;
- Z_TYPE(result->u.constant) = IS_CONSTANT | fetch_type;
+//???
+ Z_TYPE_INFO(result->u.constant) = IS_CONSTANT_EX;
+ if (IS_INTERNED(Z_STR(result->u.constant))) {
+ Z_TYPE_FLAGS(result->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+ }
+ Z_CONST_FLAGS(result->u.constant) = fetch_type;
break;
case ZEND_RT:
compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
ZVAL_COPY_VALUE(&element, &expr->u.constant);
if (offset) {
- switch (Z_TYPE(offset->u.constant) & IS_CONSTANT_TYPE_MASK) {
+ switch (Z_TYPE(offset->u.constant)) {
case IS_CONSTANT:
//??? /* Ugly hack to denote that this value has a constant index */
Z_GC_FLAGS(offset->u.constant) |= IS_STR_CONSTANT;
- if (Z_TYPE(offset->u.constant) & IS_CONSTANT_UNQUALIFIED) {
+ if (Z_CONST_FLAGS(offset->u.constant) & IS_CONSTANT_UNQUALIFIED) {
Z_GC_FLAGS(offset->u.constant) |= IS_STR_CONSTANT_UNQUALIFIED;
}
//??? Z_TYPE(element) |= IS_CONSTANT_INDEX;
ZVAL_COPY_VALUE(&tmp, &static_assignment->u.constant);
} else {
ZVAL_NULL(&tmp);
+ Z_CONST_FLAGS(tmp) = 0;
}
if (!CG(active_op_array)->static_variables) {
if (CG(active_op_array)->scope) {
value.op_type = IS_CONST;
ZVAL_NULL(&value.u.constant);
- Z_TYPE(value.u.constant) |= is_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR;
+ Z_CONST_FLAGS(value.u.constant) = is_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR;
//??? Z_SET_REFCOUNT_P(&value.u.constant, 1);
//??? Z_UNSET_ISREF_P(&value.u.constant);
convert_to_long(&val->u.constant);
CG(declarables).ticks = val->u.constant;
} else if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "encoding", sizeof("encoding")-1)) {
- if ((Z_TYPE(val->u.constant) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
+ if (Z_TYPE(val->u.constant) == IS_CONSTANT) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use constants as encoding");
}
SET_UNUSED(opline->op2);
result->op_type = IS_CONST;
- Z_TYPE(result->u.constant) = IS_BOOL;
- Z_LVAL(result->u.constant) = 1;
+ ZVAL_BOOL(&result->u.constant, 1);
}
/* }}} */
}
again:
- Z_TYPE(zendlval->u.constant) = IS_LONG;
+//???
+ Z_TYPE_INFO(zendlval->u.constant) = IS_LONG;
retval = lex_scan(&zendlval->u.constant TSRMLS_CC);
switch (retval) {
case T_COMMENT:
znode tmp;
tmp.op_type = IS_CONST;
- ZVAL_STR(&tmp.u.constant, STR_ALLOC(Z_STRLEN(CG(current_namespace)), 0));
+ ZVAL_NEW_STR(&tmp.u.constant, STR_ALLOC(Z_STRLEN(CG(current_namespace)), 0));
zend_str_tolower_copy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
zend_do_build_namespace_name(&tmp, &tmp, name TSRMLS_CC);
*name = tmp;
zend_constant c;
//??? ZVAL_STRINGL(&c.value, strval, strlen, 0);
- ZVAL_STR(&c.value, STR_INIT(strval, strlen, flags & CONST_PERSISTENT));
+ ZVAL_NEW_STR(&c.value, STR_INIT(strval, strlen, flags & CONST_PERSISTENT));
c.flags = flags;
c.name = STR_INIT(name, name_len, flags & CONST_PERSISTENT);
c.module_number = module_number;
str->val[str->len] = '\0';
- RETURN_STR(str);
+ RETURN_NEW_STR(str);
}
/* }}} */
if (offset >= Z_STRLEN_P(str)) {
int old_len = Z_STRLEN_P(str);
Z_STR_P(str) = STR_REALLOC(Z_STR_P(str), offset + 1, 0);
+ Z_TYPE_INFO_P(str) = IS_STRING_EX;
memset(Z_STRVAL_P(str) + old_len, ' ', offset - old_len);
Z_STRVAL_P(str)[offset+1] = 0;
} else if (IS_INTERNED(Z_STR_P(str))) {
Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRLEN_P(str), 0);
+ Z_TYPE_INFO_P(str) = IS_STRING_EX;
}
if (Z_TYPE_P(value) != IS_STRING) {
case IS_STRING: {
zval tmp;
- zend_string *str;
if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) {
switch(Z_TYPE_P(dim)) {
if (type != BP_VAR_IS) {
zend_error(E_NOTICE, "Uninitialized string offset: %ld", Z_LVAL_P(dim));
}
- str = STR_EMPTY_ALLOC();
+ ZVAL_EMPTY_STRING(result);
} else {
zend_uchar c = (zend_uchar)Z_STRVAL_P(container)[Z_LVAL_P(dim)];
if (CG(one_char_string)[c]) {
- str = CG(one_char_string)[c];
+ ZVAL_INT_STR(result, CG(one_char_string)[c]);
} else {
- str = STR_INIT(Z_STRVAL_P(container) + Z_LVAL_P(dim), 1, 0);
+ ZVAL_NEW_STR(result, STR_INIT(Z_STRVAL_P(container) + Z_LVAL_P(dim), 1, 0));
}
}
- ZVAL_STR(result, str);
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
- 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_REFCOUNTED_P(zval_ptr)) {
if (!Z_DELREF_P(zval_ptr)) {
ZEND_ASSERT(zval_ptr != &EG(uninitialized_zval));
_zval_dtor_func_for_ptr(Z_COUNTED_P(zval_ptr) ZEND_FILE_LINE_CC);
#define IS_VISITED_CONSTANT 0x080 //??? IS_CONSTANT_INDEX
#define IS_CONSTANT_VISITED(p) (Z_TYPE_P(p) & IS_VISITED_CONSTANT)
#define Z_REAL_TYPE_P(p) (Z_TYPE_P(p) & ~IS_VISITED_CONSTANT)
-#define MARK_CONSTANT_VISITED(p) Z_TYPE_P(p) |= IS_VISITED_CONSTANT
+#define MARK_CONSTANT_VISITED(p) Z_TYPE_INFO_P(p) |= IS_VISITED_CONSTANT
static void zval_deep_copy(zval *p)
{
if (IS_CONSTANT_VISITED(p)) {
zend_error(E_ERROR, "Cannot declare self-referencing constant '%s'", Z_STRVAL_P(p));
- } else if ((Z_TYPE_P(p) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
+ } else if (Z_TYPE_P(p) == IS_CONSTANT) {
int refcount;
//??? zend_uchar is_ref;
MARK_CONSTANT_VISITED(p);
- refcount = Z_REFCOUNT_P(p);
+ refcount = Z_REFCOUNTED_P(p) ? Z_REFCOUNT_P(p) : 1;
//??? is_ref = Z_ISREF_P(p);
- if (!zend_get_constant_ex(Z_STRVAL_P(p), Z_STRLEN_P(p), &const_value, scope, Z_REAL_TYPE_P(p) TSRMLS_CC)) {
+ if (!zend_get_constant_ex(Z_STRVAL_P(p), Z_STRLEN_P(p), &const_value, scope, Z_CONST_FLAGS_P(p) TSRMLS_CC)) {
char *actual = Z_STRVAL_P(p);
if ((colon = (char*)zend_memrchr(Z_STRVAL_P(p), ':', Z_STRLEN_P(p)))) {
//??? Z_STRVAL_P(p) = colon + 1;
Z_STR_P(p) = STR_INIT(colon + 1, len, 0);
}
+ Z_TYPE_FLAGS_P(p) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
} else {
zend_string *save = Z_STR_P(p);
char *slash;
int actual_len = Z_STRLEN_P(p);
- if ((Z_TYPE_P(p) & IS_CONSTANT_UNQUALIFIED) && (slash = (char *)zend_memrchr(actual, '\\', actual_len))) {
+ if ((Z_CONST_FLAGS_P(p) & IS_CONSTANT_UNQUALIFIED) && (slash = (char *)zend_memrchr(actual, '\\', actual_len))) {
actual = slash + 1;
actual_len -= (actual - Z_STRVAL_P(p));
if (inline_change) {
zend_string *s = STR_INIT(actual, actual_len, 0);
//??? STR_RELEASE(Z_STR_P(p));
Z_STR_P(p) = s;
+ Z_TYPE_FLAGS_P(p) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
}
}
if (actual[0] == '\\') {
}
--actual_len;
}
- if ((Z_TYPE_P(p) & IS_CONSTANT_UNQUALIFIED) == 0) {
+ if ((Z_CONST_FLAGS_P(p) & IS_CONSTANT_UNQUALIFIED) == 0) {
if (save->val[0] == '\\') {
zend_error(E_ERROR, "Undefined constant '%s'", save->val + 1);
} else {
save = NULL;
}
zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
- Z_TYPE_P(p) = IS_STRING;
if (!inline_change) {
ZVAL_STRINGL(p, actual, actual_len);
- } else if (save && save->val != actual) {
- STR_RELEASE(save);
+ } else {
+ Z_TYPE_INFO_P(p) = IS_INTERNED(Z_STR_P(p)) ?
+ IS_INTERNED_STRING_EX : IS_STRING_EX;
+ if (save && save->val != actual) {
+ STR_RELEASE(save);
+ }
}
}
} else {
SEPARATE_ZVAL_IF_NOT_REF(p);
- Z_TYPE_P(p) = IS_ARRAY;
+ Z_TYPE_INFO_P(p) = IS_ARRAY_EX;
if (!inline_change) {
HashTable *ht = Z_ARRVAL_P(p);
ZVAL_NEW_ARR(p);
int retval;
if (retval_ptr) {
- ZVAL_STR(&pv, STR_ALLOC(str_len + sizeof("return ;")-1, 1));
+ ZVAL_NEW_STR(&pv, STR_ALLOC(str_len + sizeof("return ;")-1, 1));
memcpy(Z_STRVAL(pv), "return ", sizeof("return ") - 1);
memcpy(Z_STRVAL(pv) + sizeof("return ") - 1, str, str_len);
Z_STRVAL(pv)[Z_STRLEN(pv) - 1] = ';';
ZEND_API void gc_possible_root(zend_refcounted *ref TSRMLS_DC)
{
- if (UNEXPECTED(GC_ADDRESS(GC_INFO(ref)) &&
- GC_GET_COLOR(GC_INFO(ref)) == GC_BLACK &&
- GC_ADDRESS(GC_INFO(ref)) >= GC_G(last_unused) - GC_G(buf))) {
- /* The given zval is a garbage that is going to be deleted by
- * currently running GC */
- return;
- }
-
GC_BENCH_INC(zval_possible_root);
- if (GC_GET_COLOR(GC_INFO(ref)) == GC_BLACK) {
+ if (EXPECTED(GC_GET_COLOR(GC_INFO(ref)) == GC_BLACK)) {
GC_SET_PURPLE(GC_INFO(ref));
if (!GC_ADDRESS(GC_INFO(ref))) {
{
gc_root_buffer *root;
- if (UNEXPECTED(GC_ADDRESS(GC_INFO(ref)) &&
+ if (UNEXPECTED(/*GC_ADDRESS(GC_INFO(ref)) &&*/
GC_GET_COLOR(GC_INFO(ref)) == GC_BLACK &&
GC_ADDRESS(GC_INFO(ref)) >= GC_G(last_unused) - GC_G(buf))) {
/* The given zval is a garbage that is going to be deleted by
zend_hash_destroy(&arr->ht);
GC_REMOVE_FROM_BUFFER(arr);
efree(arr);
- } else if (GC_TYPE(p) == IS_REFERENCE) {
- zend_reference *ref = (zend_reference*)p;
-
- GC_TYPE(ref) = IS_NULL;
- if (EXPECTED(EG(objects_store).object_buckets != NULL) ||
- Z_TYPE(ref->val) != IS_OBJECT) {
- zval_dtor(&ref->val);
- }
- GC_REMOVE_FROM_BUFFER(ref);
- efree(ref);
}
current = GC_G(next_to_free);
}
static zend_always_inline void gc_check_possible_root(zval *z TSRMLS_DC)
{
- if (Z_TYPE_P(z) == IS_OBJECT || Z_TYPE_P(z) == IS_ARRAY ||
- (Z_ISREF_P(z) &&
- (Z_TYPE_P(Z_REFVAL_P(z)) == IS_ARRAY || Z_TYPE_P(Z_REFVAL_P(z)) == IS_OBJECT))) {
+ ZVAL_DEREF(z);
+ if ((Z_TYPE_FLAGS_P(z) & IS_TYPE_COLLECTABLE) &&
+ UNEXPECTED(!Z_GC_INFO_P(z))) {
gc_possible_root(Z_COUNTED_P(z) TSRMLS_CC);
}
}
idx = pos ? (*pos) : ht->nInternalPointer;
if (idx == INVALID_IDX) {
- Z_TYPE_P(key) = IS_NULL;
+ ZVAL_NULL(key);
} else {
p = ht->arData + idx;
if (p->key) {
int op1_len = Z_STRLEN_P(op1);
int length = op1_len + Z_STRLEN_P(op2);
- ZVAL_STR(result, STR_REALLOC(Z_STR_P(op1), length, 1));
+ ZVAL_NEW_STR(result, STR_REALLOC(Z_STR_P(op1), length, 1));
memcpy(Z_STRVAL_P(result)+op1_len, Z_STRVAL_P(op2), Z_STRLEN_P(op2));
Z_STRVAL_P(result)[length] = 0;
}
#define EAT_TRAILING_WHITESPACE() EAT_TRAILING_WHITESPACE_EX('X')
#define zend_ini_copy_value(retval, str, len) \
- ZVAL_STR(retval, STR_INIT(str, len, 1))
+ ZVAL_NEW_STR(retval, STR_INIT(str, len, 1))
#define RETURN_TOKEN(type, str, len) { \
#define EAT_TRAILING_WHITESPACE() EAT_TRAILING_WHITESPACE_EX('X')
#define zend_ini_copy_value(retval, str, len) \
- ZVAL_STR(retval, STR_INIT(str, len, 1))
+ ZVAL_NEW_STR(retval, STR_INIT(str, len, 1))
#define RETURN_TOKEN(type, str, len) { \
optional_class_type:
/* empty */ { $$.op_type = IS_UNUSED; }
- | T_ARRAY { $$.op_type = IS_CONST; Z_TYPE($$.u.constant)=IS_ARRAY; }
- | T_CALLABLE { $$.op_type = IS_CONST; Z_TYPE($$.u.constant)=IS_CALLABLE; }
+ | T_ARRAY { $$.op_type = IS_CONST; Z_TYPE_INFO($$.u.constant)=IS_ARRAY; }
+ | T_CALLABLE { $$.op_type = IS_CONST; Z_TYPE_INFO($$.u.constant)=IS_CALLABLE; }
| fully_qualified_class_name { $$ = $1; }
;
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); }
+ | static_var_list ',' T_VARIABLE '=' static_scalar { Z_CONST_FLAGS($5.u.constant) = 0; 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); }
+ | T_VARIABLE '=' static_scalar { Z_CONST_FLAGS($3.u.constant) = 0; zend_do_fetch_static_variable(&$1, &$3, ZEND_FETCH_STATIC TSRMLS_CC); }
;
for_expr:
- /* empty */ { $$.op_type = IS_CONST; Z_TYPE($$.u.constant) = IS_BOOL; Z_LVAL($$.u.constant) = 1; }
+ /* empty */ { $$.op_type = IS_CONST; ZVAL_BOOL(&$$.u.constant, 1); }
| non_empty_for_expr { $$ = $1; }
;
T_STATIC { $$.op_type = IS_CONST; ZVAL_STRINGL(&$$.u.constant, "static", sizeof("static")-1);}
| namespace_name { $$ = $1; }
| T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant); zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); }
- | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); $$ = $2; }
+ | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); $$ = $2; }
;
fully_qualified_class_name:
namespace_name { $$ = $1; }
| T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant); zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); }
- | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); $$ = $2; }
+ | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); $$ = $2; }
;
static_scalar: /* compile-time evaluated scalars */
static_scalar_value { zend_do_constant_expression(&$$, $1.u.ast TSRMLS_CC); }
- | 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; }
+ | T_ARRAY '(' static_array_pair_list ')' { $$ = $3; Z_TYPE_INFO($$.u.constant) = IS_CONSTANT_ARRAY_EX; }
+ | '[' static_array_pair_list ']' { $$ = $2; Z_TYPE_INFO($$.u.constant) = IS_CONSTANT_ARRAY_EX; }
;
static_scalar_value:
| static_class_name_scalar { $$.u.ast = zend_ast_create_constant(&$1.u.constant); }
| namespace_name { zend_do_fetch_constant(&$$, NULL, &$1, ZEND_CT, 1 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
| 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); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
- | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_CT, 0 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
+ | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_CT, 0 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
| static_class_constant { $$.u.ast = zend_ast_create_constant(&$1.u.constant); }
| T_CLASS_C { $$.u.ast = zend_ast_create_constant(&$1.u.constant); }
| static_operation { $$ = $1; }
| class_constant { $$ = $1; }
| namespace_name { zend_do_fetch_constant(&$$, NULL, &$1, ZEND_RT, 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_RT, 0 TSRMLS_CC); }
- | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_RT, 0 TSRMLS_CC); }
+ | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_RT, 0 TSRMLS_CC); }
| common_scalar { $$ = $1; }
| '"' encaps_list '"' { $$ = $2; }
| T_START_HEREDOC encaps_list T_END_HEREDOC { $$ = $2; }
/* enforce ZEND_MMAP_AHEAD trailing NULLs for flex... */
old_len = Z_STRLEN_P(str);
Z_STR_P(str) = STR_REALLOC(Z_STR_P(str), old_len + ZEND_MMAP_AHEAD, 0);
+ Z_TYPE_INFO_P(str) = IS_STRING_EX;
memset(Z_STRVAL_P(str) + old_len, 0, ZEND_MMAP_AHEAD + 1);
SCNG(yy_in) = NULL;
yymore_restart:
-#line 1005 "Zend/zend_language_scanner.c"
+#line 1006 "Zend/zend_language_scanner.c"
{
YYCTYPE yych;
unsigned int yyaccept = 0;
yy3:
YYDEBUG(3, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1767 "Zend/zend_language_scanner.l"
+#line 1764 "Zend/zend_language_scanner.l"
{
if (YYCURSOR > YYLIMIT) {
return 0;
if (readsize < yyleng) {
yyless(readsize);
}
- Z_TYPE_P(zendlval) = IS_STRING;
+ Z_TYPE_INFO_P(zendlval) = IS_STRING_EX;
} else {
ZVAL_STRINGL(zendlval, yytext, yyleng);
}
HANDLE_NEWLINES(yytext, yyleng);
return T_INLINE_HTML;
}
-#line 1163 "Zend/zend_language_scanner.c"
+#line 1164 "Zend/zend_language_scanner.c"
yy4:
YYDEBUG(4, *YYCURSOR);
yych = *++YYCURSOR;
yy6:
YYDEBUG(6, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1756 "Zend/zend_language_scanner.l"
+#line 1753 "Zend/zend_language_scanner.l"
{
if (CG(short_tags)) {
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way, no copying intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way, no copying intentional */
BEGIN(ST_IN_SCRIPTING);
return T_OPEN_TAG;
} else {
goto inline_char_handler;
}
}
-#line 1192 "Zend/zend_language_scanner.c"
+#line 1193 "Zend/zend_language_scanner.c"
yy7:
YYDEBUG(7, *YYCURSOR);
++YYCURSOR;
if ((yych = *YYCURSOR) == '=') goto yy43;
YYDEBUG(8, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1735 "Zend/zend_language_scanner.l"
+#line 1732 "Zend/zend_language_scanner.l"
{
if (CG(asp_tags)) {
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
BEGIN(ST_IN_SCRIPTING);
return T_OPEN_TAG;
} else {
goto inline_char_handler;
}
}
-#line 1210 "Zend/zend_language_scanner.c"
+#line 1211 "Zend/zend_language_scanner.c"
yy9:
YYDEBUG(9, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(38, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1698 "Zend/zend_language_scanner.l"
+#line 1695 "Zend/zend_language_scanner.l"
{
YYCTYPE *bracket = (YYCTYPE*)zend_memrchr(yytext, '<', yyleng - (sizeof("script language=php>") - 1));
HANDLE_NEWLINES(yytext, yyleng);
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
BEGIN(ST_IN_SCRIPTING);
return T_OPEN_TAG;
}
-#line 1412 "Zend/zend_language_scanner.c"
+#line 1413 "Zend/zend_language_scanner.c"
yy39:
YYDEBUG(39, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(44, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1715 "Zend/zend_language_scanner.l"
+#line 1712 "Zend/zend_language_scanner.l"
{
if (CG(asp_tags)) {
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
BEGIN(ST_IN_SCRIPTING);
return T_OPEN_TAG_WITH_ECHO;
} else {
goto inline_char_handler;
}
}
-#line 1450 "Zend/zend_language_scanner.c"
+#line 1451 "Zend/zend_language_scanner.c"
yy45:
YYDEBUG(45, *YYCURSOR);
++YYCURSOR;
YYDEBUG(46, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1727 "Zend/zend_language_scanner.l"
+#line 1724 "Zend/zend_language_scanner.l"
{
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
BEGIN(ST_IN_SCRIPTING);
return T_OPEN_TAG_WITH_ECHO;
}
-#line 1463 "Zend/zend_language_scanner.c"
+#line 1464 "Zend/zend_language_scanner.c"
yy47:
YYDEBUG(47, *YYCURSOR);
yych = *++YYCURSOR;
yy51:
YYDEBUG(51, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1747 "Zend/zend_language_scanner.l"
+#line 1744 "Zend/zend_language_scanner.l"
{
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way, no copying intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way, no copying intentional */
HANDLE_NEWLINE(yytext[yyleng-1]);
BEGIN(ST_IN_SCRIPTING);
return T_OPEN_TAG;
}
-#line 1498 "Zend/zend_language_scanner.c"
+#line 1499 "Zend/zend_language_scanner.c"
yy52:
YYDEBUG(52, *YYCURSOR);
++YYCURSOR;
yy56:
YYDEBUG(56, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2208 "Zend/zend_language_scanner.l"
+#line 2205 "Zend/zend_language_scanner.l"
{
if (YYCURSOR > YYLIMIT) {
return 0;
zend_scan_escape_string(zendlval, yytext, yyleng, '`' TSRMLS_CC);
return T_ENCAPSED_AND_WHITESPACE;
}
-#line 1610 "Zend/zend_language_scanner.c"
+#line 1611 "Zend/zend_language_scanner.c"
yy57:
YYDEBUG(57, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(59, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2152 "Zend/zend_language_scanner.l"
+#line 2149 "Zend/zend_language_scanner.l"
{
BEGIN(ST_IN_SCRIPTING);
return '`';
}
-#line 1626 "Zend/zend_language_scanner.c"
+#line 1627 "Zend/zend_language_scanner.c"
yy60:
YYDEBUG(60, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(62, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2139 "Zend/zend_language_scanner.l"
+#line 2136 "Zend/zend_language_scanner.l"
{
Z_LVAL_P(zendlval) = (long) '{';
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
yyless(1);
return T_CURLY_OPEN;
}
-#line 1643 "Zend/zend_language_scanner.c"
+#line 1644 "Zend/zend_language_scanner.c"
yy63:
YYDEBUG(63, *YYCURSOR);
yyaccept = 0;
yy65:
YYDEBUG(65, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1846 "Zend/zend_language_scanner.l"
+#line 1843 "Zend/zend_language_scanner.l"
{
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
}
-#line 1664 "Zend/zend_language_scanner.c"
+#line 1665 "Zend/zend_language_scanner.c"
yy66:
YYDEBUG(66, *YYCURSOR);
++YYCURSOR;
YYDEBUG(67, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1461 "Zend/zend_language_scanner.l"
+#line 1462 "Zend/zend_language_scanner.l"
{
yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
return T_DOLLAR_OPEN_CURLY_BRACES;
}
-#line 1675 "Zend/zend_language_scanner.c"
+#line 1676 "Zend/zend_language_scanner.c"
yy68:
YYDEBUG(68, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(71, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1839 "Zend/zend_language_scanner.l"
+#line 1836 "Zend/zend_language_scanner.l"
{
yyless(yyleng - 1);
yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
}
-#line 1696 "Zend/zend_language_scanner.c"
+#line 1697 "Zend/zend_language_scanner.c"
yy72:
YYDEBUG(72, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(74, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1830 "Zend/zend_language_scanner.l"
+#line 1827 "Zend/zend_language_scanner.l"
{
yyless(yyleng - 3);
yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
}
-#line 1721 "Zend/zend_language_scanner.c"
+#line 1722 "Zend/zend_language_scanner.c"
}
/* *********************************** */
yyc_ST_DOUBLE_QUOTES:
yy78:
YYDEBUG(78, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2158 "Zend/zend_language_scanner.l"
+#line 2155 "Zend/zend_language_scanner.l"
{
if (GET_DOUBLE_QUOTES_SCANNED_LENGTH()) {
YYCURSOR += GET_DOUBLE_QUOTES_SCANNED_LENGTH() - 1;
zend_scan_escape_string(zendlval, yytext, yyleng, '"' TSRMLS_CC);
return T_ENCAPSED_AND_WHITESPACE;
}
-#line 1838 "Zend/zend_language_scanner.c"
+#line 1839 "Zend/zend_language_scanner.c"
yy79:
YYDEBUG(79, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(81, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2147 "Zend/zend_language_scanner.l"
+#line 2144 "Zend/zend_language_scanner.l"
{
BEGIN(ST_IN_SCRIPTING);
return '"';
}
-#line 1854 "Zend/zend_language_scanner.c"
+#line 1855 "Zend/zend_language_scanner.c"
yy82:
YYDEBUG(82, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(84, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2139 "Zend/zend_language_scanner.l"
+#line 2136 "Zend/zend_language_scanner.l"
{
Z_LVAL_P(zendlval) = (long) '{';
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
yyless(1);
return T_CURLY_OPEN;
}
-#line 1871 "Zend/zend_language_scanner.c"
+#line 1872 "Zend/zend_language_scanner.c"
yy85:
YYDEBUG(85, *YYCURSOR);
yyaccept = 0;
yy87:
YYDEBUG(87, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1846 "Zend/zend_language_scanner.l"
+#line 1843 "Zend/zend_language_scanner.l"
{
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
}
-#line 1892 "Zend/zend_language_scanner.c"
+#line 1893 "Zend/zend_language_scanner.c"
yy88:
YYDEBUG(88, *YYCURSOR);
++YYCURSOR;
YYDEBUG(89, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1461 "Zend/zend_language_scanner.l"
+#line 1462 "Zend/zend_language_scanner.l"
{
yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
return T_DOLLAR_OPEN_CURLY_BRACES;
}
-#line 1903 "Zend/zend_language_scanner.c"
+#line 1904 "Zend/zend_language_scanner.c"
yy90:
YYDEBUG(90, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(93, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1839 "Zend/zend_language_scanner.l"
+#line 1836 "Zend/zend_language_scanner.l"
{
yyless(yyleng - 1);
yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
}
-#line 1924 "Zend/zend_language_scanner.c"
+#line 1925 "Zend/zend_language_scanner.c"
yy94:
YYDEBUG(94, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(96, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1830 "Zend/zend_language_scanner.l"
+#line 1827 "Zend/zend_language_scanner.l"
{
yyless(yyleng - 3);
yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
}
-#line 1949 "Zend/zend_language_scanner.c"
+#line 1950 "Zend/zend_language_scanner.c"
}
/* *********************************** */
yyc_ST_END_HEREDOC:
++YYCURSOR;
YYDEBUG(100, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2125 "Zend/zend_language_scanner.l"
+#line 2122 "Zend/zend_language_scanner.l"
{
zend_heredoc_label *heredoc_label = zend_ptr_stack_pop(&SCNG(heredoc_label_stack));
BEGIN(ST_IN_SCRIPTING);
return T_END_HEREDOC;
}
-#line 1973 "Zend/zend_language_scanner.c"
+#line 1974 "Zend/zend_language_scanner.c"
/* *********************************** */
yyc_ST_HEREDOC:
{
yy104:
YYDEBUG(104, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2250 "Zend/zend_language_scanner.l"
+#line 2247 "Zend/zend_language_scanner.l"
{
int newline = 0;
zend_scan_escape_string(zendlval, yytext, yyleng - newline, 0 TSRMLS_CC);
return T_ENCAPSED_AND_WHITESPACE;
}
-#line 2108 "Zend/zend_language_scanner.c"
+#line 2109 "Zend/zend_language_scanner.c"
yy105:
YYDEBUG(105, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(108, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2139 "Zend/zend_language_scanner.l"
+#line 2136 "Zend/zend_language_scanner.l"
{
Z_LVAL_P(zendlval) = (long) '{';
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
yyless(1);
return T_CURLY_OPEN;
}
-#line 2130 "Zend/zend_language_scanner.c"
+#line 2131 "Zend/zend_language_scanner.c"
yy109:
YYDEBUG(109, *YYCURSOR);
yyaccept = 0;
yy111:
YYDEBUG(111, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1846 "Zend/zend_language_scanner.l"
+#line 1843 "Zend/zend_language_scanner.l"
{
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
}
-#line 2151 "Zend/zend_language_scanner.c"
+#line 2152 "Zend/zend_language_scanner.c"
yy112:
YYDEBUG(112, *YYCURSOR);
++YYCURSOR;
YYDEBUG(113, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1461 "Zend/zend_language_scanner.l"
+#line 1462 "Zend/zend_language_scanner.l"
{
yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
return T_DOLLAR_OPEN_CURLY_BRACES;
}
-#line 2162 "Zend/zend_language_scanner.c"
+#line 2163 "Zend/zend_language_scanner.c"
yy114:
YYDEBUG(114, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(117, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1839 "Zend/zend_language_scanner.l"
+#line 1836 "Zend/zend_language_scanner.l"
{
yyless(yyleng - 1);
yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
}
-#line 2183 "Zend/zend_language_scanner.c"
+#line 2184 "Zend/zend_language_scanner.c"
yy118:
YYDEBUG(118, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(120, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1830 "Zend/zend_language_scanner.l"
+#line 1827 "Zend/zend_language_scanner.l"
{
yyless(yyleng - 3);
yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
}
-#line 2208 "Zend/zend_language_scanner.c"
+#line 2209 "Zend/zend_language_scanner.c"
}
/* *********************************** */
yyc_ST_IN_SCRIPTING:
yy124:
YYDEBUG(124, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1868 "Zend/zend_language_scanner.l"
+#line 1865 "Zend/zend_language_scanner.l"
{
zend_copy_value(zendlval, yytext, yyleng);
return T_STRING;
}
-#line 2396 "Zend/zend_language_scanner.c"
+#line 2397 "Zend/zend_language_scanner.c"
yy125:
YYDEBUG(125, *YYCURSOR);
yych = *++YYCURSOR;
yy139:
YYDEBUG(139, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1450 "Zend/zend_language_scanner.l"
+#line 1451 "Zend/zend_language_scanner.l"
{
return yytext[0];
}
-#line 2632 "Zend/zend_language_scanner.c"
+#line 2633 "Zend/zend_language_scanner.c"
yy140:
YYDEBUG(140, *YYCURSOR);
++YYCURSOR;
yy141:
YYDEBUG(141, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1179 "Zend/zend_language_scanner.l"
+#line 1180 "Zend/zend_language_scanner.l"
{
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
HANDLE_NEWLINES(yytext, yyleng);
return T_WHITESPACE;
}
-#line 2648 "Zend/zend_language_scanner.c"
+#line 2649 "Zend/zend_language_scanner.c"
yy142:
YYDEBUG(142, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(144, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1206 "Zend/zend_language_scanner.l"
+#line 1207 "Zend/zend_language_scanner.l"
{
return T_NS_SEPARATOR;
}
-#line 2663 "Zend/zend_language_scanner.c"
+#line 2664 "Zend/zend_language_scanner.c"
yy145:
YYDEBUG(145, *YYCURSOR);
yyaccept = 1;
++YYCURSOR;
YYDEBUG(169, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1455 "Zend/zend_language_scanner.l"
+#line 1456 "Zend/zend_language_scanner.l"
{
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
return '{';
}
-#line 2901 "Zend/zend_language_scanner.c"
+#line 2902 "Zend/zend_language_scanner.c"
yy170:
YYDEBUG(170, *YYCURSOR);
++YYCURSOR;
YYDEBUG(171, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1467 "Zend/zend_language_scanner.l"
+#line 1468 "Zend/zend_language_scanner.l"
{
RESET_DOC_COMMENT();
if (!zend_stack_is_empty(&SCNG(state_stack))) {
}
return '}';
}
-#line 2915 "Zend/zend_language_scanner.c"
+#line 2916 "Zend/zend_language_scanner.c"
yy172:
YYDEBUG(172, *YYCURSOR);
yyaccept = 2;
#line 1516 "Zend/zend_language_scanner.l"
{
if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */
- Z_LVAL_P(zendlval) = strtol(yytext, NULL, 0);
+ ZVAL_LONG(zendlval, strtol(yytext, NULL, 0));
} else {
errno = 0;
- Z_LVAL_P(zendlval) = strtol(yytext, NULL, 0);
+ ZVAL_LONG(zendlval, strtol(yytext, NULL, 0));
if (errno == ERANGE) { /* Overflow */
if (yytext[0] == '0') { /* octal overflow */
- Z_DVAL_P(zendlval) = zend_oct_strtod(yytext, NULL);
+ ZVAL_DOUBLE(zendlval, zend_oct_strtod(yytext, NULL));
} else {
- Z_DVAL_P(zendlval) = zend_strtod(yytext, NULL);
+ ZVAL_DOUBLE(zendlval, zend_strtod(yytext, NULL));
}
- Z_TYPE_P(zendlval) = IS_DOUBLE;
return T_DNUMBER;
}
}
-
- Z_TYPE_P(zendlval) = IS_LONG;
return T_LNUMBER;
}
-#line 2964 "Zend/zend_language_scanner.c"
+#line 2962 "Zend/zend_language_scanner.c"
yy174:
YYDEBUG(174, *YYCURSOR);
yyaccept = 2;
yy177:
YYDEBUG(177, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1874 "Zend/zend_language_scanner.l"
+#line 1871 "Zend/zend_language_scanner.l"
{
while (YYCURSOR < YYLIMIT) {
switch (*YYCURSOR++) {
return T_COMMENT;
}
-#line 3026 "Zend/zend_language_scanner.c"
+#line 3024 "Zend/zend_language_scanner.c"
yy178:
YYDEBUG(178, *YYCURSOR);
++YYCURSOR;
yy179:
YYDEBUG(179, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1962 "Zend/zend_language_scanner.l"
+#line 1959 "Zend/zend_language_scanner.l"
{
register char *s, *t;
char *end;
}
return T_CONSTANT_ENCAPSED_STRING;
}
-#line 3099 "Zend/zend_language_scanner.c"
+#line 3097 "Zend/zend_language_scanner.c"
yy180:
YYDEBUG(180, *YYCURSOR);
++YYCURSOR;
yy181:
YYDEBUG(181, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2029 "Zend/zend_language_scanner.l"
+#line 2026 "Zend/zend_language_scanner.l"
{
int bprefix = (yytext[0] != '"') ? 1 : 0;
BEGIN(ST_DOUBLE_QUOTES);
return '"';
}
-#line 3147 "Zend/zend_language_scanner.c"
+#line 3145 "Zend/zend_language_scanner.c"
yy182:
YYDEBUG(182, *YYCURSOR);
++YYCURSOR;
YYDEBUG(183, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2119 "Zend/zend_language_scanner.l"
+#line 2116 "Zend/zend_language_scanner.l"
{
BEGIN(ST_BACKQUOTE);
return '`';
}
-#line 3158 "Zend/zend_language_scanner.c"
+#line 3156 "Zend/zend_language_scanner.c"
yy184:
YYDEBUG(184, *YYCURSOR);
++YYCURSOR;
YYDEBUG(185, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2381 "Zend/zend_language_scanner.l"
+#line 2378 "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 3173 "Zend/zend_language_scanner.c"
+#line 3171 "Zend/zend_language_scanner.c"
yy186:
YYDEBUG(186, *YYCURSOR);
++YYCURSOR;
yy190:
YYDEBUG(190, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1575 "Zend/zend_language_scanner.l"
+#line 1571 "Zend/zend_language_scanner.l"
{
ZVAL_DOUBLE(zendlval, zend_strtod(yytext, NULL));
return T_DNUMBER;
}
-#line 3205 "Zend/zend_language_scanner.c"
+#line 3203 "Zend/zend_language_scanner.c"
yy191:
YYDEBUG(191, *YYCURSOR);
yyaccept = 2;
}
YYDEBUG(202, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1492 "Zend/zend_language_scanner.l"
+#line 1493 "Zend/zend_language_scanner.l"
{
char *bin = yytext + 2; /* Skip "0b" */
int len = yyleng - 2;
if (len < SIZEOF_LONG * 8) {
if (len == 0) {
- Z_LVAL_P(zendlval) = 0;
+ ZVAL_LONG(zendlval, 0);
} else {
- Z_LVAL_P(zendlval) = strtol(bin, NULL, 2);
+ ZVAL_LONG(zendlval, strtol(bin, NULL, 2));
}
- Z_TYPE_P(zendlval) = IS_LONG;
return T_LNUMBER;
} else {
ZVAL_DOUBLE(zendlval, zend_bin_strtod(bin, NULL));
return T_DNUMBER;
}
}
-#line 3321 "Zend/zend_language_scanner.c"
+#line 3318 "Zend/zend_language_scanner.c"
yy203:
YYDEBUG(203, *YYCURSOR);
++YYCURSOR;
}
YYDEBUG(205, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1537 "Zend/zend_language_scanner.l"
+#line 1534 "Zend/zend_language_scanner.l"
{
char *hex = yytext + 2; /* Skip "0x" */
int len = yyleng - 2;
if (len < SIZEOF_LONG * 2 || (len == SIZEOF_LONG * 2 && *hex <= '7')) {
if (len == 0) {
- Z_LVAL_P(zendlval) = 0;
+ ZVAL_LONG(zendlval, 0);
} else {
- Z_LVAL_P(zendlval) = strtol(hex, NULL, 16);
+ ZVAL_LONG(zendlval, strtol(hex, NULL, 16));
}
- Z_TYPE_P(zendlval) = IS_LONG;
return T_LNUMBER;
} else {
ZVAL_DOUBLE(zendlval, zend_hex_strtod(hex, NULL));
return T_DNUMBER;
}
}
-#line 3357 "Zend/zend_language_scanner.c"
+#line 3353 "Zend/zend_language_scanner.c"
yy206:
YYDEBUG(206, *YYCURSOR);
++YYCURSOR;
yy207:
YYDEBUG(207, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1941 "Zend/zend_language_scanner.l"
+#line 1938 "Zend/zend_language_scanner.l"
{
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
BEGIN(INITIAL);
return T_CLOSE_TAG; /* implicit ';' at php-end tag */
}
-#line 3373 "Zend/zend_language_scanner.c"
+#line 3369 "Zend/zend_language_scanner.c"
yy208:
YYDEBUG(208, *YYCURSOR);
yych = *++YYCURSOR;
yy212:
YYDEBUG(212, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1846 "Zend/zend_language_scanner.l"
+#line 1843 "Zend/zend_language_scanner.l"
{
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
}
-#line 3412 "Zend/zend_language_scanner.c"
+#line 3408 "Zend/zend_language_scanner.c"
yy213:
YYDEBUG(213, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(215, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1438 "Zend/zend_language_scanner.l"
+#line 1439 "Zend/zend_language_scanner.l"
{
return T_LOGICAL_XOR;
}
-#line 3430 "Zend/zend_language_scanner.c"
+#line 3426 "Zend/zend_language_scanner.c"
yy216:
YYDEBUG(216, *YYCURSOR);
++YYCURSOR;
}
YYDEBUG(217, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1430 "Zend/zend_language_scanner.l"
+#line 1431 "Zend/zend_language_scanner.l"
{
return T_LOGICAL_OR;
}
-#line 3443 "Zend/zend_language_scanner.c"
+#line 3439 "Zend/zend_language_scanner.c"
yy218:
YYDEBUG(218, *YYCURSOR);
++YYCURSOR;
YYDEBUG(219, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1418 "Zend/zend_language_scanner.l"
+#line 1419 "Zend/zend_language_scanner.l"
{
return T_XOR_EQUAL;
}
-#line 3453 "Zend/zend_language_scanner.c"
+#line 3449 "Zend/zend_language_scanner.c"
yy220:
YYDEBUG(220, *YYCURSOR);
++YYCURSOR;
YYDEBUG(221, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1422 "Zend/zend_language_scanner.l"
+#line 1423 "Zend/zend_language_scanner.l"
{
return T_BOOLEAN_OR;
}
-#line 3463 "Zend/zend_language_scanner.c"
+#line 3459 "Zend/zend_language_scanner.c"
yy222:
YYDEBUG(222, *YYCURSOR);
++YYCURSOR;
YYDEBUG(223, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1414 "Zend/zend_language_scanner.l"
+#line 1415 "Zend/zend_language_scanner.l"
{
return T_OR_EQUAL;
}
-#line 3473 "Zend/zend_language_scanner.c"
+#line 3469 "Zend/zend_language_scanner.c"
yy224:
YYDEBUG(224, *YYCURSOR);
++YYCURSOR;
YYDEBUG(225, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1426 "Zend/zend_language_scanner.l"
+#line 1427 "Zend/zend_language_scanner.l"
{
return T_BOOLEAN_AND;
}
-#line 3483 "Zend/zend_language_scanner.c"
+#line 3479 "Zend/zend_language_scanner.c"
yy226:
YYDEBUG(226, *YYCURSOR);
++YYCURSOR;
YYDEBUG(227, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1410 "Zend/zend_language_scanner.l"
+#line 1411 "Zend/zend_language_scanner.l"
{
return T_AND_EQUAL;
}
-#line 3493 "Zend/zend_language_scanner.c"
+#line 3489 "Zend/zend_language_scanner.c"
yy228:
YYDEBUG(228, *YYCURSOR);
++YYCURSOR;
yy229:
YYDEBUG(229, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1949 "Zend/zend_language_scanner.l"
+#line 1946 "Zend/zend_language_scanner.l"
{
if (CG(asp_tags)) {
BEGIN(INITIAL);
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
return T_CLOSE_TAG; /* implicit ';' at php-end tag */
} else {
yyless(1);
return yytext[0];
}
}
-#line 3514 "Zend/zend_language_scanner.c"
+#line 3510 "Zend/zend_language_scanner.c"
yy230:
YYDEBUG(230, *YYCURSOR);
++YYCURSOR;
YYDEBUG(231, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1398 "Zend/zend_language_scanner.l"
+#line 1399 "Zend/zend_language_scanner.l"
{
return T_MOD_EQUAL;
}
-#line 3524 "Zend/zend_language_scanner.c"
+#line 3520 "Zend/zend_language_scanner.c"
yy232:
YYDEBUG(232, *YYCURSOR);
yych = *++YYCURSOR;
yy235:
YYDEBUG(235, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1908 "Zend/zend_language_scanner.l"
+#line 1905 "Zend/zend_language_scanner.l"
{
int doc_com;
return T_COMMENT;
}
-#line 3575 "Zend/zend_language_scanner.c"
+#line 3571 "Zend/zend_language_scanner.c"
yy236:
YYDEBUG(236, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(238, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1390 "Zend/zend_language_scanner.l"
+#line 1391 "Zend/zend_language_scanner.l"
{
return T_DIV_EQUAL;
}
-#line 3589 "Zend/zend_language_scanner.c"
+#line 3585 "Zend/zend_language_scanner.c"
yy239:
YYDEBUG(239, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(243, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1386 "Zend/zend_language_scanner.l"
+#line 1387 "Zend/zend_language_scanner.l"
{
return T_MUL_EQUAL;
}
-#line 3616 "Zend/zend_language_scanner.c"
+#line 3612 "Zend/zend_language_scanner.c"
yy244:
YYDEBUG(244, *YYCURSOR);
++YYCURSOR;
if ((yych = *YYCURSOR) == '=') goto yy248;
YYDEBUG(245, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1446 "Zend/zend_language_scanner.l"
+#line 1447 "Zend/zend_language_scanner.l"
{
return T_SR;
}
-#line 3627 "Zend/zend_language_scanner.c"
+#line 3623 "Zend/zend_language_scanner.c"
yy246:
YYDEBUG(246, *YYCURSOR);
++YYCURSOR;
YYDEBUG(247, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1374 "Zend/zend_language_scanner.l"
+#line 1375 "Zend/zend_language_scanner.l"
{
return T_IS_GREATER_OR_EQUAL;
}
-#line 3637 "Zend/zend_language_scanner.c"
+#line 3633 "Zend/zend_language_scanner.c"
yy248:
YYDEBUG(248, *YYCURSOR);
++YYCURSOR;
YYDEBUG(249, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1406 "Zend/zend_language_scanner.l"
+#line 1407 "Zend/zend_language_scanner.l"
{
return T_SR_EQUAL;
}
-#line 3647 "Zend/zend_language_scanner.c"
+#line 3643 "Zend/zend_language_scanner.c"
yy250:
YYDEBUG(250, *YYCURSOR);
yyaccept = 5;
yy251:
YYDEBUG(251, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1442 "Zend/zend_language_scanner.l"
+#line 1443 "Zend/zend_language_scanner.l"
{
return T_SL;
}
-#line 3662 "Zend/zend_language_scanner.c"
+#line 3658 "Zend/zend_language_scanner.c"
yy252:
YYDEBUG(252, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(254, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1370 "Zend/zend_language_scanner.l"
+#line 1371 "Zend/zend_language_scanner.l"
{
return T_IS_SMALLER_OR_EQUAL;
}
-#line 3678 "Zend/zend_language_scanner.c"
+#line 3674 "Zend/zend_language_scanner.c"
yy255:
YYDEBUG(255, *YYCURSOR);
++YYCURSOR;
yy256:
YYDEBUG(256, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1366 "Zend/zend_language_scanner.l"
+#line 1367 "Zend/zend_language_scanner.l"
{
return T_IS_NOT_EQUAL;
}
-#line 3689 "Zend/zend_language_scanner.c"
+#line 3685 "Zend/zend_language_scanner.c"
yy257:
YYDEBUG(257, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(265, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1402 "Zend/zend_language_scanner.l"
+#line 1403 "Zend/zend_language_scanner.l"
{
return T_SL_EQUAL;
}
-#line 3744 "Zend/zend_language_scanner.c"
+#line 3740 "Zend/zend_language_scanner.c"
yy266:
YYDEBUG(266, *YYCURSOR);
++YYCURSOR;
yy276:
YYDEBUG(276, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2071 "Zend/zend_language_scanner.l"
+#line 2068 "Zend/zend_language_scanner.l"
{
char *s;
int bprefix = (yytext[0] != '<') ? 1 : 0;
return T_START_HEREDOC;
}
-#line 3896 "Zend/zend_language_scanner.c"
+#line 3892 "Zend/zend_language_scanner.c"
yy277:
YYDEBUG(277, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(282, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1358 "Zend/zend_language_scanner.l"
+#line 1359 "Zend/zend_language_scanner.l"
{
return T_IS_NOT_IDENTICAL;
}
-#line 3940 "Zend/zend_language_scanner.c"
+#line 3936 "Zend/zend_language_scanner.c"
yy283:
YYDEBUG(283, *YYCURSOR);
++YYCURSOR;
YYDEBUG(284, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1378 "Zend/zend_language_scanner.l"
+#line 1379 "Zend/zend_language_scanner.l"
{
return T_PLUS_EQUAL;
}
-#line 3950 "Zend/zend_language_scanner.c"
+#line 3946 "Zend/zend_language_scanner.c"
yy285:
YYDEBUG(285, *YYCURSOR);
++YYCURSOR;
YYDEBUG(286, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1346 "Zend/zend_language_scanner.l"
+#line 1347 "Zend/zend_language_scanner.l"
{
return T_INC;
}
-#line 3960 "Zend/zend_language_scanner.c"
+#line 3956 "Zend/zend_language_scanner.c"
yy287:
YYDEBUG(287, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(290, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1334 "Zend/zend_language_scanner.l"
+#line 1335 "Zend/zend_language_scanner.l"
{
return T_LIST;
}
-#line 3983 "Zend/zend_language_scanner.c"
+#line 3979 "Zend/zend_language_scanner.c"
yy291:
YYDEBUG(291, *YYCURSOR);
++YYCURSOR;
if ((yych = *YYCURSOR) == '=') goto yy295;
YYDEBUG(292, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1362 "Zend/zend_language_scanner.l"
+#line 1363 "Zend/zend_language_scanner.l"
{
return T_IS_EQUAL;
}
-#line 3994 "Zend/zend_language_scanner.c"
+#line 3990 "Zend/zend_language_scanner.c"
yy293:
YYDEBUG(293, *YYCURSOR);
++YYCURSOR;
YYDEBUG(294, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1330 "Zend/zend_language_scanner.l"
+#line 1331 "Zend/zend_language_scanner.l"
{
return T_DOUBLE_ARROW;
}
-#line 4004 "Zend/zend_language_scanner.c"
+#line 4000 "Zend/zend_language_scanner.c"
yy295:
YYDEBUG(295, *YYCURSOR);
++YYCURSOR;
YYDEBUG(296, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1354 "Zend/zend_language_scanner.l"
+#line 1355 "Zend/zend_language_scanner.l"
{
return T_IS_IDENTICAL;
}
-#line 4014 "Zend/zend_language_scanner.c"
+#line 4010 "Zend/zend_language_scanner.c"
yy297:
YYDEBUG(297, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(316, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1689 "Zend/zend_language_scanner.l"
+#line 1686 "Zend/zend_language_scanner.l"
{
if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
ZVAL_DUP(zendlval, &CG(current_namespace));
}
return T_NS_C;
}
-#line 4153 "Zend/zend_language_scanner.c"
+#line 4149 "Zend/zend_language_scanner.c"
yy317:
YYDEBUG(317, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(321, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1664 "Zend/zend_language_scanner.l"
+#line 1661 "Zend/zend_language_scanner.l"
{
zend_string *filename = zend_get_compiled_filename(TSRMLS_C);
zend_string *dirname;
ZVAL_STR(zendlval, dirname);
return T_DIR;
}
-#line 4198 "Zend/zend_language_scanner.c"
+#line 4194 "Zend/zend_language_scanner.c"
yy322:
YYDEBUG(322, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(327, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1649 "Zend/zend_language_scanner.l"
+#line 1645 "Zend/zend_language_scanner.l"
{
ZVAL_LONG(zendlval, CG(zend_lineno));
return T_LINE;
}
-#line 4228 "Zend/zend_language_scanner.c"
+#line 4224 "Zend/zend_language_scanner.c"
yy328:
YYDEBUG(328, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(335, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1617 "Zend/zend_language_scanner.l"
+#line 1613 "Zend/zend_language_scanner.l"
{
if (CG(active_class_entry)) {
int len = 0;
len += sizeof("::")-1;
len += CG(active_op_array)->function_name->len;
}
- ZVAL_STR(zendlval, STR_ALLOC(len, 0));
+ ZVAL_NEW_STR(zendlval, STR_ALLOC(len, 0));
len = 0;
if (CG(active_class_entry)->name) {
memcpy(Z_STRVAL_P(zendlval), CG(active_class_entry)->name->val, CG(active_class_entry)->name->len);
}
return T_METHOD_C;
}
-#line 4295 "Zend/zend_language_scanner.c"
+#line 4291 "Zend/zend_language_scanner.c"
yy336:
YYDEBUG(336, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(346, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1607 "Zend/zend_language_scanner.l"
+#line 1603 "Zend/zend_language_scanner.l"
{
zend_op_array *op_array = CG(active_op_array);
if (op_array && op_array->function_name) {
}
return T_FUNC_C;
}
-#line 4356 "Zend/zend_language_scanner.c"
+#line 4352 "Zend/zend_language_scanner.c"
yy347:
YYDEBUG(347, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(351, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1654 "Zend/zend_language_scanner.l"
+#line 1650 "Zend/zend_language_scanner.l"
{
zend_string *filename = zend_get_compiled_filename(TSRMLS_C);
if (!filename) {
- filename = STR_EMPTY_ALLOC();
+ ZVAL_EMPTY_STRING(zendlval);
+ } else {
+ ZVAL_STR(zendlval, STR_COPY(filename));
}
- ZVAL_STR(zendlval, STR_COPY(filename));
return T_FILE;
}
-#line 4386 "Zend/zend_language_scanner.c"
+#line 4383 "Zend/zend_language_scanner.c"
yy352:
YYDEBUG(352, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(358, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1597 "Zend/zend_language_scanner.l"
+#line 1593 "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)) {
}
return T_TRAIT_C;
}
-#line 4426 "Zend/zend_language_scanner.c"
+#line 4423 "Zend/zend_language_scanner.c"
yy359:
YYDEBUG(359, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(365, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1580 "Zend/zend_language_scanner.l"
+#line 1576 "Zend/zend_language_scanner.l"
{
zend_class_entry *ce = CG(active_class_entry);
if (ce && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {
/* We create a special __CLASS__ constant that is going to be resolved
at run-time */
ZVAL_STRINGL(zendlval, "__CLASS__", sizeof("__CLASS__") - 1);
- Z_TYPE_P(zendlval) = IS_CONSTANT;
+ Z_TYPE_INFO_P(zendlval) = IS_CONSTANT_EX;
} else {
if (ce && ce->name) {
ZVAL_STR(zendlval, STR_COPY(ce->name));
}
return T_CLASS_C;
}
-#line 4473 "Zend/zend_language_scanner.c"
+#line 4470 "Zend/zend_language_scanner.c"
yy366:
YYDEBUG(366, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(378, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1298 "Zend/zend_language_scanner.l"
+#line 1299 "Zend/zend_language_scanner.l"
{
return T_HALT_COMPILER;
}
-#line 4539 "Zend/zend_language_scanner.c"
+#line 4536 "Zend/zend_language_scanner.c"
yy379:
YYDEBUG(379, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(382, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1278 "Zend/zend_language_scanner.l"
+#line 1279 "Zend/zend_language_scanner.l"
{
return T_USE;
}
-#line 4563 "Zend/zend_language_scanner.c"
+#line 4560 "Zend/zend_language_scanner.c"
yy383:
YYDEBUG(383, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(386, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1326 "Zend/zend_language_scanner.l"
+#line 1327 "Zend/zend_language_scanner.l"
{
return T_UNSET;
}
-#line 4586 "Zend/zend_language_scanner.c"
+#line 4583 "Zend/zend_language_scanner.c"
yy387:
YYDEBUG(387, *YYCURSOR);
++YYCURSOR;
++YYCURSOR;
YYDEBUG(404, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1226 "Zend/zend_language_scanner.l"
+#line 1227 "Zend/zend_language_scanner.l"
{
return T_INT_CAST;
}
-#line 4762 "Zend/zend_language_scanner.c"
+#line 4759 "Zend/zend_language_scanner.c"
yy405:
YYDEBUG(405, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(413, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1230 "Zend/zend_language_scanner.l"
+#line 1231 "Zend/zend_language_scanner.l"
{
return T_DOUBLE_CAST;
}
-#line 4810 "Zend/zend_language_scanner.c"
+#line 4807 "Zend/zend_language_scanner.c"
yy414:
YYDEBUG(414, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(427, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1234 "Zend/zend_language_scanner.l"
+#line 1235 "Zend/zend_language_scanner.l"
{
return T_STRING_CAST;
}
-#line 4884 "Zend/zend_language_scanner.c"
+#line 4881 "Zend/zend_language_scanner.c"
yy428:
YYDEBUG(428, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(434, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1238 "Zend/zend_language_scanner.l"
+#line 1239 "Zend/zend_language_scanner.l"
{
return T_ARRAY_CAST;
}
-#line 4921 "Zend/zend_language_scanner.c"
+#line 4918 "Zend/zend_language_scanner.c"
yy435:
YYDEBUG(435, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(442, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1242 "Zend/zend_language_scanner.l"
+#line 1243 "Zend/zend_language_scanner.l"
{
return T_OBJECT_CAST;
}
-#line 4963 "Zend/zend_language_scanner.c"
+#line 4960 "Zend/zend_language_scanner.c"
yy443:
YYDEBUG(443, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(450, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1246 "Zend/zend_language_scanner.l"
+#line 1247 "Zend/zend_language_scanner.l"
{
return T_BOOL_CAST;
}
-#line 5008 "Zend/zend_language_scanner.c"
+#line 5005 "Zend/zend_language_scanner.c"
yy451:
YYDEBUG(451, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(462, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1250 "Zend/zend_language_scanner.l"
+#line 1251 "Zend/zend_language_scanner.l"
{
return T_UNSET_CAST;
}
-#line 5072 "Zend/zend_language_scanner.c"
+#line 5069 "Zend/zend_language_scanner.c"
yy463:
YYDEBUG(463, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(465, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1222 "Zend/zend_language_scanner.l"
+#line 1223 "Zend/zend_language_scanner.l"
{
return T_VAR;
}
-#line 5090 "Zend/zend_language_scanner.c"
+#line 5087 "Zend/zend_language_scanner.c"
yy466:
YYDEBUG(466, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(469, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1214 "Zend/zend_language_scanner.l"
+#line 1215 "Zend/zend_language_scanner.l"
{
return T_NEW;
}
-#line 5114 "Zend/zend_language_scanner.c"
+#line 5111 "Zend/zend_language_scanner.c"
yy470:
YYDEBUG(470, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(477, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1274 "Zend/zend_language_scanner.l"
+#line 1275 "Zend/zend_language_scanner.l"
{
return T_NAMESPACE;
}
-#line 5157 "Zend/zend_language_scanner.c"
+#line 5154 "Zend/zend_language_scanner.c"
yy478:
YYDEBUG(478, *YYCURSOR);
yyaccept = 3;
++YYCURSOR;
YYDEBUG(481, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1394 "Zend/zend_language_scanner.l"
+#line 1395 "Zend/zend_language_scanner.l"
{
return T_CONCAT_EQUAL;
}
-#line 5183 "Zend/zend_language_scanner.c"
+#line 5180 "Zend/zend_language_scanner.c"
yy482:
YYDEBUG(482, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(484, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1210 "Zend/zend_language_scanner.l"
+#line 1211 "Zend/zend_language_scanner.l"
{
return T_ELLIPSIS;
}
-#line 5196 "Zend/zend_language_scanner.c"
+#line 5193 "Zend/zend_language_scanner.c"
yy485:
YYDEBUG(485, *YYCURSOR);
++YYCURSOR;
YYDEBUG(486, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1202 "Zend/zend_language_scanner.l"
+#line 1203 "Zend/zend_language_scanner.l"
{
return T_PAAMAYIM_NEKUDOTAYIM;
}
-#line 5206 "Zend/zend_language_scanner.c"
+#line 5203 "Zend/zend_language_scanner.c"
yy487:
YYDEBUG(487, *YYCURSOR);
++YYCURSOR;
++YYCURSOR;
YYDEBUG(490, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1382 "Zend/zend_language_scanner.l"
+#line 1383 "Zend/zend_language_scanner.l"
{
return T_MINUS_EQUAL;
}
-#line 5232 "Zend/zend_language_scanner.c"
+#line 5229 "Zend/zend_language_scanner.c"
yy491:
YYDEBUG(491, *YYCURSOR);
++YYCURSOR;
YYDEBUG(492, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1350 "Zend/zend_language_scanner.l"
+#line 1351 "Zend/zend_language_scanner.l"
{
return T_DEC;
}
-#line 5242 "Zend/zend_language_scanner.c"
+#line 5239 "Zend/zend_language_scanner.c"
yy493:
YYDEBUG(493, *YYCURSOR);
++YYCURSOR;
YYDEBUG(494, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1174 "Zend/zend_language_scanner.l"
+#line 1175 "Zend/zend_language_scanner.l"
{
yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
return T_OBJECT_OPERATOR;
}
-#line 5253 "Zend/zend_language_scanner.c"
+#line 5250 "Zend/zend_language_scanner.c"
yy495:
YYDEBUG(495, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(501, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1322 "Zend/zend_language_scanner.l"
+#line 1323 "Zend/zend_language_scanner.l"
{
return T_PUBLIC;
}
-#line 5302 "Zend/zend_language_scanner.c"
+#line 5299 "Zend/zend_language_scanner.c"
yy502:
YYDEBUG(502, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(510, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1318 "Zend/zend_language_scanner.l"
+#line 1319 "Zend/zend_language_scanner.l"
{
return T_PROTECTED;
}
-#line 5361 "Zend/zend_language_scanner.c"
+#line 5358 "Zend/zend_language_scanner.c"
yy511:
YYDEBUG(511, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(516, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1314 "Zend/zend_language_scanner.l"
+#line 1315 "Zend/zend_language_scanner.l"
{
return T_PRIVATE;
}
-#line 5395 "Zend/zend_language_scanner.c"
+#line 5392 "Zend/zend_language_scanner.c"
yy517:
YYDEBUG(517, *YYCURSOR);
++YYCURSOR;
}
YYDEBUG(518, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1150 "Zend/zend_language_scanner.l"
+#line 1151 "Zend/zend_language_scanner.l"
{
return T_PRINT;
}
-#line 5408 "Zend/zend_language_scanner.c"
+#line 5405 "Zend/zend_language_scanner.c"
yy519:
YYDEBUG(519, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(523, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1142 "Zend/zend_language_scanner.l"
+#line 1143 "Zend/zend_language_scanner.l"
{
return T_GOTO;
}
-#line 5437 "Zend/zend_language_scanner.c"
+#line 5434 "Zend/zend_language_scanner.c"
yy524:
YYDEBUG(524, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(528, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1286 "Zend/zend_language_scanner.l"
+#line 1287 "Zend/zend_language_scanner.l"
{
return T_GLOBAL;
}
-#line 5465 "Zend/zend_language_scanner.c"
+#line 5462 "Zend/zend_language_scanner.c"
yy529:
YYDEBUG(529, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(536, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1134 "Zend/zend_language_scanner.l"
+#line 1135 "Zend/zend_language_scanner.l"
{
return T_BREAK;
}
-#line 5506 "Zend/zend_language_scanner.c"
+#line 5503 "Zend/zend_language_scanner.c"
yy537:
YYDEBUG(537, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(544, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1118 "Zend/zend_language_scanner.l"
+#line 1119 "Zend/zend_language_scanner.l"
{
return T_SWITCH;
}
-#line 5550 "Zend/zend_language_scanner.c"
+#line 5547 "Zend/zend_language_scanner.c"
yy545:
YYDEBUG(545, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(549, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1302 "Zend/zend_language_scanner.l"
+#line 1303 "Zend/zend_language_scanner.l"
{
return T_STATIC;
}
-#line 5578 "Zend/zend_language_scanner.c"
+#line 5575 "Zend/zend_language_scanner.c"
yy550:
YYDEBUG(550, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(554, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1114 "Zend/zend_language_scanner.l"
+#line 1115 "Zend/zend_language_scanner.l"
{
return T_AS;
}
-#line 5609 "Zend/zend_language_scanner.c"
+#line 5606 "Zend/zend_language_scanner.c"
yy555:
YYDEBUG(555, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(558, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1338 "Zend/zend_language_scanner.l"
+#line 1339 "Zend/zend_language_scanner.l"
{
return T_ARRAY;
}
-#line 5632 "Zend/zend_language_scanner.c"
+#line 5629 "Zend/zend_language_scanner.c"
yy559:
YYDEBUG(559, *YYCURSOR);
++YYCURSOR;
}
YYDEBUG(560, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1434 "Zend/zend_language_scanner.l"
+#line 1435 "Zend/zend_language_scanner.l"
{
return T_LOGICAL_AND;
}
-#line 5645 "Zend/zend_language_scanner.c"
+#line 5642 "Zend/zend_language_scanner.c"
yy561:
YYDEBUG(561, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(567, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1306 "Zend/zend_language_scanner.l"
+#line 1307 "Zend/zend_language_scanner.l"
{
return T_ABSTRACT;
}
-#line 5683 "Zend/zend_language_scanner.c"
+#line 5680 "Zend/zend_language_scanner.c"
yy568:
YYDEBUG(568, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(572, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1074 "Zend/zend_language_scanner.l"
+#line 1075 "Zend/zend_language_scanner.l"
{
return T_WHILE;
}
-#line 5711 "Zend/zend_language_scanner.c"
+#line 5708 "Zend/zend_language_scanner.c"
yy573:
YYDEBUG(573, *YYCURSOR);
++YYCURSOR;
}
YYDEBUG(574, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1058 "Zend/zend_language_scanner.l"
+#line 1059 "Zend/zend_language_scanner.l"
{
return T_IF;
}
-#line 5724 "Zend/zend_language_scanner.c"
+#line 5721 "Zend/zend_language_scanner.c"
yy575:
YYDEBUG(575, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(581, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1290 "Zend/zend_language_scanner.l"
+#line 1291 "Zend/zend_language_scanner.l"
{
return T_ISSET;
}
-#line 5780 "Zend/zend_language_scanner.c"
+#line 5777 "Zend/zend_language_scanner.c"
yy582:
YYDEBUG(582, *YYCURSOR);
yych = *++YYCURSOR;
yy589:
YYDEBUG(589, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1258 "Zend/zend_language_scanner.l"
+#line 1259 "Zend/zend_language_scanner.l"
{
return T_INCLUDE;
}
-#line 5838 "Zend/zend_language_scanner.c"
+#line 5835 "Zend/zend_language_scanner.c"
yy590:
YYDEBUG(590, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(595, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1262 "Zend/zend_language_scanner.l"
+#line 1263 "Zend/zend_language_scanner.l"
{
return T_INCLUDE_ONCE;
}
-#line 5871 "Zend/zend_language_scanner.c"
+#line 5868 "Zend/zend_language_scanner.c"
yy596:
YYDEBUG(596, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(602, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1158 "Zend/zend_language_scanner.l"
+#line 1159 "Zend/zend_language_scanner.l"
{
return T_INTERFACE;
}
-#line 5909 "Zend/zend_language_scanner.c"
+#line 5906 "Zend/zend_language_scanner.c"
yy603:
YYDEBUG(603, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(610, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1282 "Zend/zend_language_scanner.l"
+#line 1283 "Zend/zend_language_scanner.l"
{
return T_INSTEADOF;
}
-#line 5963 "Zend/zend_language_scanner.c"
+#line 5960 "Zend/zend_language_scanner.c"
yy611:
YYDEBUG(611, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(616, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1110 "Zend/zend_language_scanner.l"
+#line 1111 "Zend/zend_language_scanner.l"
{
return T_INSTANCEOF;
}
-#line 5996 "Zend/zend_language_scanner.c"
+#line 5993 "Zend/zend_language_scanner.c"
yy617:
YYDEBUG(617, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(625, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1170 "Zend/zend_language_scanner.l"
+#line 1171 "Zend/zend_language_scanner.l"
{
return T_IMPLEMENTS;
}
-#line 6044 "Zend/zend_language_scanner.c"
+#line 6041 "Zend/zend_language_scanner.c"
yy626:
YYDEBUG(626, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(629, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1042 "Zend/zend_language_scanner.l"
+#line 1043 "Zend/zend_language_scanner.l"
{
return T_TRY;
}
-#line 6076 "Zend/zend_language_scanner.c"
+#line 6073 "Zend/zend_language_scanner.c"
yy630:
YYDEBUG(630, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(633, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1162 "Zend/zend_language_scanner.l"
+#line 1163 "Zend/zend_language_scanner.l"
{
return T_TRAIT;
}
-#line 6099 "Zend/zend_language_scanner.c"
+#line 6096 "Zend/zend_language_scanner.c"
yy634:
YYDEBUG(634, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(637, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1054 "Zend/zend_language_scanner.l"
+#line 1055 "Zend/zend_language_scanner.l"
{
return T_THROW;
}
-#line 6122 "Zend/zend_language_scanner.c"
+#line 6119 "Zend/zend_language_scanner.c"
yy638:
YYDEBUG(638, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(642, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1038 "Zend/zend_language_scanner.l"
+#line 1039 "Zend/zend_language_scanner.l"
{
return T_YIELD;
}
-#line 6150 "Zend/zend_language_scanner.c"
+#line 6147 "Zend/zend_language_scanner.c"
yy643:
YYDEBUG(643, *YYCURSOR);
yych = *++YYCURSOR;
yy650:
YYDEBUG(650, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1266 "Zend/zend_language_scanner.l"
+#line 1267 "Zend/zend_language_scanner.l"
{
return T_REQUIRE;
}
-#line 6215 "Zend/zend_language_scanner.c"
+#line 6212 "Zend/zend_language_scanner.c"
yy651:
YYDEBUG(651, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(656, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1270 "Zend/zend_language_scanner.l"
+#line 1271 "Zend/zend_language_scanner.l"
{
return T_REQUIRE_ONCE;
}
-#line 6248 "Zend/zend_language_scanner.c"
+#line 6245 "Zend/zend_language_scanner.c"
yy657:
YYDEBUG(657, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(660, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1034 "Zend/zend_language_scanner.l"
+#line 1035 "Zend/zend_language_scanner.l"
{
return T_RETURN;
}
-#line 6271 "Zend/zend_language_scanner.c"
+#line 6268 "Zend/zend_language_scanner.c"
yy661:
YYDEBUG(661, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(671, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1138 "Zend/zend_language_scanner.l"
+#line 1139 "Zend/zend_language_scanner.l"
{
return T_CONTINUE;
}
-#line 6365 "Zend/zend_language_scanner.c"
+#line 6362 "Zend/zend_language_scanner.c"
yy672:
YYDEBUG(672, *YYCURSOR);
++YYCURSOR;
}
YYDEBUG(673, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1030 "Zend/zend_language_scanner.l"
+#line 1031 "Zend/zend_language_scanner.l"
{
return T_CONST;
}
-#line 6378 "Zend/zend_language_scanner.c"
+#line 6375 "Zend/zend_language_scanner.c"
yy674:
YYDEBUG(674, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(678, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1218 "Zend/zend_language_scanner.l"
+#line 1219 "Zend/zend_language_scanner.l"
{
return T_CLONE;
}
-#line 6407 "Zend/zend_language_scanner.c"
+#line 6404 "Zend/zend_language_scanner.c"
yy679:
YYDEBUG(679, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(681, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1154 "Zend/zend_language_scanner.l"
+#line 1155 "Zend/zend_language_scanner.l"
{
return T_CLASS;
}
-#line 6425 "Zend/zend_language_scanner.c"
+#line 6422 "Zend/zend_language_scanner.c"
yy682:
YYDEBUG(682, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(690, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1342 "Zend/zend_language_scanner.l"
+#line 1343 "Zend/zend_language_scanner.l"
{
return T_CALLABLE;
}
-#line 6475 "Zend/zend_language_scanner.c"
+#line 6472 "Zend/zend_language_scanner.c"
yy691:
YYDEBUG(691, *YYCURSOR);
++YYCURSOR;
}
YYDEBUG(692, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1126 "Zend/zend_language_scanner.l"
+#line 1127 "Zend/zend_language_scanner.l"
{
return T_CASE;
}
-#line 6488 "Zend/zend_language_scanner.c"
+#line 6485 "Zend/zend_language_scanner.c"
yy693:
YYDEBUG(693, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(695, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1046 "Zend/zend_language_scanner.l"
+#line 1047 "Zend/zend_language_scanner.l"
{
return T_CATCH;
}
-#line 6506 "Zend/zend_language_scanner.c"
+#line 6503 "Zend/zend_language_scanner.c"
yy696:
YYDEBUG(696, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(705, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1026 "Zend/zend_language_scanner.l"
+#line 1027 "Zend/zend_language_scanner.l"
{
return T_FUNCTION;
}
-#line 6561 "Zend/zend_language_scanner.c"
+#line 6558 "Zend/zend_language_scanner.c"
yy706:
YYDEBUG(706, *YYCURSOR);
++YYCURSOR;
yy707:
YYDEBUG(707, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1086 "Zend/zend_language_scanner.l"
+#line 1087 "Zend/zend_language_scanner.l"
{
return T_FOR;
}
-#line 6589 "Zend/zend_language_scanner.c"
+#line 6586 "Zend/zend_language_scanner.c"
yy708:
YYDEBUG(708, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(712, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1094 "Zend/zend_language_scanner.l"
+#line 1095 "Zend/zend_language_scanner.l"
{
return T_FOREACH;
}
-#line 6617 "Zend/zend_language_scanner.c"
+#line 6614 "Zend/zend_language_scanner.c"
yy713:
YYDEBUG(713, *YYCURSOR);
yych = *++YYCURSOR;
yy716:
YYDEBUG(716, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1310 "Zend/zend_language_scanner.l"
+#line 1311 "Zend/zend_language_scanner.l"
{
return T_FINAL;
}
-#line 6655 "Zend/zend_language_scanner.c"
+#line 6652 "Zend/zend_language_scanner.c"
yy717:
YYDEBUG(717, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(719, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1050 "Zend/zend_language_scanner.l"
+#line 1051 "Zend/zend_language_scanner.l"
{
return T_FINALLY;
}
-#line 6673 "Zend/zend_language_scanner.c"
+#line 6670 "Zend/zend_language_scanner.c"
yy720:
YYDEBUG(720, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(723, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1082 "Zend/zend_language_scanner.l"
+#line 1083 "Zend/zend_language_scanner.l"
{
return T_DO;
}
-#line 6708 "Zend/zend_language_scanner.c"
+#line 6705 "Zend/zend_language_scanner.c"
yy724:
YYDEBUG(724, *YYCURSOR);
++YYCURSOR;
}
YYDEBUG(725, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1022 "Zend/zend_language_scanner.l"
+#line 1023 "Zend/zend_language_scanner.l"
{
return T_EXIT;
}
-#line 6721 "Zend/zend_language_scanner.c"
+#line 6718 "Zend/zend_language_scanner.c"
yy726:
YYDEBUG(726, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(732, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1130 "Zend/zend_language_scanner.l"
+#line 1131 "Zend/zend_language_scanner.l"
{
return T_DEFAULT;
}
-#line 6760 "Zend/zend_language_scanner.c"
+#line 6757 "Zend/zend_language_scanner.c"
yy733:
YYDEBUG(733, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(737, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1102 "Zend/zend_language_scanner.l"
+#line 1103 "Zend/zend_language_scanner.l"
{
return T_DECLARE;
}
-#line 6788 "Zend/zend_language_scanner.c"
+#line 6785 "Zend/zend_language_scanner.c"
yy738:
YYDEBUG(738, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(750, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1166 "Zend/zend_language_scanner.l"
+#line 1167 "Zend/zend_language_scanner.l"
{
return T_EXTENDS;
}
-#line 6872 "Zend/zend_language_scanner.c"
+#line 6869 "Zend/zend_language_scanner.c"
yy751:
YYDEBUG(751, *YYCURSOR);
++YYCURSOR;
}
YYDEBUG(752, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1018 "Zend/zend_language_scanner.l"
+#line 1019 "Zend/zend_language_scanner.l"
{
return T_EXIT;
}
-#line 6885 "Zend/zend_language_scanner.c"
+#line 6882 "Zend/zend_language_scanner.c"
yy753:
YYDEBUG(753, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(755, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1254 "Zend/zend_language_scanner.l"
+#line 1255 "Zend/zend_language_scanner.l"
{
return T_EVAL;
}
-#line 6903 "Zend/zend_language_scanner.c"
+#line 6900 "Zend/zend_language_scanner.c"
yy756:
YYDEBUG(756, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(766, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1078 "Zend/zend_language_scanner.l"
+#line 1079 "Zend/zend_language_scanner.l"
{
return T_ENDWHILE;
}
-#line 6977 "Zend/zend_language_scanner.c"
+#line 6974 "Zend/zend_language_scanner.c"
yy767:
YYDEBUG(767, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(772, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1122 "Zend/zend_language_scanner.l"
+#line 1123 "Zend/zend_language_scanner.l"
{
return T_ENDSWITCH;
}
-#line 7010 "Zend/zend_language_scanner.c"
+#line 7007 "Zend/zend_language_scanner.c"
yy773:
YYDEBUG(773, *YYCURSOR);
++YYCURSOR;
}
YYDEBUG(774, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1066 "Zend/zend_language_scanner.l"
+#line 1067 "Zend/zend_language_scanner.l"
{
return T_ENDIF;
}
-#line 7023 "Zend/zend_language_scanner.c"
+#line 7020 "Zend/zend_language_scanner.c"
yy775:
YYDEBUG(775, *YYCURSOR);
yych = *++YYCURSOR;
yy777:
YYDEBUG(777, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1090 "Zend/zend_language_scanner.l"
+#line 1091 "Zend/zend_language_scanner.l"
{
return T_ENDFOR;
}
-#line 7056 "Zend/zend_language_scanner.c"
+#line 7053 "Zend/zend_language_scanner.c"
yy778:
YYDEBUG(778, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(782, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1098 "Zend/zend_language_scanner.l"
+#line 1099 "Zend/zend_language_scanner.l"
{
return T_ENDFOREACH;
}
-#line 7084 "Zend/zend_language_scanner.c"
+#line 7081 "Zend/zend_language_scanner.c"
yy783:
YYDEBUG(783, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(789, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1106 "Zend/zend_language_scanner.l"
+#line 1107 "Zend/zend_language_scanner.l"
{
return T_ENDDECLARE;
}
-#line 7122 "Zend/zend_language_scanner.c"
+#line 7119 "Zend/zend_language_scanner.c"
yy790:
YYDEBUG(790, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(793, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1294 "Zend/zend_language_scanner.l"
+#line 1295 "Zend/zend_language_scanner.l"
{
return T_EMPTY;
}
-#line 7145 "Zend/zend_language_scanner.c"
+#line 7142 "Zend/zend_language_scanner.c"
yy794:
YYDEBUG(794, *YYCURSOR);
yych = *++YYCURSOR;
yy796:
YYDEBUG(796, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1070 "Zend/zend_language_scanner.l"
+#line 1071 "Zend/zend_language_scanner.l"
{
return T_ELSE;
}
-#line 7178 "Zend/zend_language_scanner.c"
+#line 7175 "Zend/zend_language_scanner.c"
yy797:
YYDEBUG(797, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(799, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1062 "Zend/zend_language_scanner.l"
+#line 1063 "Zend/zend_language_scanner.l"
{
return T_ELSEIF;
}
-#line 7196 "Zend/zend_language_scanner.c"
+#line 7193 "Zend/zend_language_scanner.c"
yy800:
YYDEBUG(800, *YYCURSOR);
yych = *++YYCURSOR;
}
YYDEBUG(802, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1146 "Zend/zend_language_scanner.l"
+#line 1147 "Zend/zend_language_scanner.l"
{
return T_ECHO;
}
-#line 7214 "Zend/zend_language_scanner.c"
+#line 7211 "Zend/zend_language_scanner.c"
}
/* *********************************** */
yyc_ST_LOOKING_FOR_PROPERTY:
yy806:
YYDEBUG(806, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1179 "Zend/zend_language_scanner.l"
+#line 1180 "Zend/zend_language_scanner.l"
{
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
HANDLE_NEWLINES(yytext, yyleng);
return T_WHITESPACE;
}
-#line 7294 "Zend/zend_language_scanner.c"
+#line 7291 "Zend/zend_language_scanner.c"
yy807:
YYDEBUG(807, *YYCURSOR);
++YYCURSOR;
yy808:
YYDEBUG(808, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1196 "Zend/zend_language_scanner.l"
+#line 1197 "Zend/zend_language_scanner.l"
{
yyless(0);
yy_pop_state(TSRMLS_C);
goto restart;
}
-#line 7308 "Zend/zend_language_scanner.c"
+#line 7305 "Zend/zend_language_scanner.c"
yy809:
YYDEBUG(809, *YYCURSOR);
++YYCURSOR;
yy810:
YYDEBUG(810, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1190 "Zend/zend_language_scanner.l"
+#line 1191 "Zend/zend_language_scanner.l"
{
yy_pop_state(TSRMLS_C);
zend_copy_value(zendlval, yytext, yyleng);
return T_STRING;
}
-#line 7323 "Zend/zend_language_scanner.c"
+#line 7320 "Zend/zend_language_scanner.c"
yy811:
YYDEBUG(811, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(815, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1186 "Zend/zend_language_scanner.l"
+#line 1187 "Zend/zend_language_scanner.l"
{
return T_OBJECT_OPERATOR;
}
-#line 7348 "Zend/zend_language_scanner.c"
+#line 7345 "Zend/zend_language_scanner.c"
yy816:
YYDEBUG(816, *YYCURSOR);
++YYCURSOR;
yy821:
YYDEBUG(821, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1485 "Zend/zend_language_scanner.l"
+#line 1486 "Zend/zend_language_scanner.l"
{
yyless(0);
yy_pop_state(TSRMLS_C);
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
goto restart;
}
-#line 7440 "Zend/zend_language_scanner.c"
+#line 7437 "Zend/zend_language_scanner.c"
yy822:
YYDEBUG(822, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(827, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1476 "Zend/zend_language_scanner.l"
+#line 1477 "Zend/zend_language_scanner.l"
{
yyless(yyleng - 1);
zend_copy_value(zendlval, yytext, yyleng);
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
return T_STRING_VARNAME;
}
-#line 7473 "Zend/zend_language_scanner.c"
+#line 7470 "Zend/zend_language_scanner.c"
}
/* *********************************** */
yyc_ST_NOWDOC:
++YYCURSOR;
YYDEBUG(831, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2324 "Zend/zend_language_scanner.l"
+#line 2321 "Zend/zend_language_scanner.l"
{
int newline = 0;
HANDLE_NEWLINES(yytext, yyleng - newline);
return T_ENCAPSED_AND_WHITESPACE;
}
-#line 7540 "Zend/zend_language_scanner.c"
+#line 7537 "Zend/zend_language_scanner.c"
/* *********************************** */
yyc_ST_VAR_OFFSET:
{
yy835:
YYDEBUG(835, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1561 "Zend/zend_language_scanner.l"
+#line 1557 "Zend/zend_language_scanner.l"
{ /* Offset could be treated as a long */
if (yyleng < MAX_LENGTH_OF_LONG - 1 || (yyleng == MAX_LENGTH_OF_LONG - 1 && strcmp(yytext, long_min_digits) < 0)) {
ZVAL_LONG(zendlval, strtol(yytext, NULL, 10));
}
return T_NUM_STRING;
}
-#line 7656 "Zend/zend_language_scanner.c"
+#line 7653 "Zend/zend_language_scanner.c"
yy836:
YYDEBUG(836, *YYCURSOR);
yych = *++YYCURSOR;
yy838:
YYDEBUG(838, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1856 "Zend/zend_language_scanner.l"
+#line 1853 "Zend/zend_language_scanner.l"
{
/* Only '[' can be valid, but returning other tokens will allow a more explicit parse error */
return yytext[0];
}
-#line 7681 "Zend/zend_language_scanner.c"
+#line 7678 "Zend/zend_language_scanner.c"
yy839:
YYDEBUG(839, *YYCURSOR);
++YYCURSOR;
YYDEBUG(840, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1851 "Zend/zend_language_scanner.l"
+#line 1848 "Zend/zend_language_scanner.l"
{
yy_pop_state(TSRMLS_C);
return ']';
}
-#line 7692 "Zend/zend_language_scanner.c"
+#line 7689 "Zend/zend_language_scanner.c"
yy841:
YYDEBUG(841, *YYCURSOR);
yych = *++YYCURSOR;
++YYCURSOR;
YYDEBUG(843, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1861 "Zend/zend_language_scanner.l"
+#line 1858 "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 7709 "Zend/zend_language_scanner.c"
+#line 7706 "Zend/zend_language_scanner.c"
yy844:
YYDEBUG(844, *YYCURSOR);
++YYCURSOR;
yy845:
YYDEBUG(845, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1868 "Zend/zend_language_scanner.l"
+#line 1865 "Zend/zend_language_scanner.l"
{
zend_copy_value(zendlval, yytext, yyleng);
return T_STRING;
}
-#line 7723 "Zend/zend_language_scanner.c"
+#line 7720 "Zend/zend_language_scanner.c"
yy846:
YYDEBUG(846, *YYCURSOR);
++YYCURSOR;
YYDEBUG(847, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 2381 "Zend/zend_language_scanner.l"
+#line 2378 "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 7738 "Zend/zend_language_scanner.c"
+#line 7735 "Zend/zend_language_scanner.c"
yy848:
YYDEBUG(848, *YYCURSOR);
++YYCURSOR;
yy852:
YYDEBUG(852, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1846 "Zend/zend_language_scanner.l"
+#line 1843 "Zend/zend_language_scanner.l"
{
zend_copy_value(zendlval, (yytext+1), (yyleng-1));
return T_VARIABLE;
}
-#line 7779 "Zend/zend_language_scanner.c"
+#line 7776 "Zend/zend_language_scanner.c"
yy853:
YYDEBUG(853, *YYCURSOR);
++YYCURSOR;
yy860:
YYDEBUG(860, *YYCURSOR);
yyleng = YYCURSOR - SCNG(yy_text);
-#line 1570 "Zend/zend_language_scanner.l"
+#line 1566 "Zend/zend_language_scanner.l"
{ /* Offset must be treated as a string */
ZVAL_STRINGL(zendlval, yytext, yyleng);
return T_NUM_STRING;
}
-#line 7824 "Zend/zend_language_scanner.c"
+#line 7821 "Zend/zend_language_scanner.c"
yy861:
YYDEBUG(861, *YYCURSOR);
++YYCURSOR;
goto yy860;
}
}
-#line 2390 "Zend/zend_language_scanner.l"
+#line 2387 "Zend/zend_language_scanner.l"
}
/* enforce ZEND_MMAP_AHEAD trailing NULLs for flex... */
old_len = Z_STRLEN_P(str);
Z_STR_P(str) = STR_REALLOC(Z_STR_P(str), old_len + ZEND_MMAP_AHEAD, 0);
+ Z_TYPE_INFO_P(str) = IS_STRING_EX;
memset(Z_STRVAL_P(str) + old_len, 0, ZEND_MMAP_AHEAD + 1);
SCNG(yy_in) = NULL;
<ST_IN_SCRIPTING,ST_LOOKING_FOR_PROPERTY>{WHITESPACE}+ {
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
HANDLE_NEWLINES(yytext, yyleng);
return T_WHITESPACE;
}
if (len < SIZEOF_LONG * 8) {
if (len == 0) {
- Z_LVAL_P(zendlval) = 0;
+ ZVAL_LONG(zendlval, 0);
} else {
- Z_LVAL_P(zendlval) = strtol(bin, NULL, 2);
+ ZVAL_LONG(zendlval, strtol(bin, NULL, 2));
}
- Z_TYPE_P(zendlval) = IS_LONG;
return T_LNUMBER;
} else {
ZVAL_DOUBLE(zendlval, zend_bin_strtod(bin, NULL));
<ST_IN_SCRIPTING>{LNUM} {
if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */
- Z_LVAL_P(zendlval) = strtol(yytext, NULL, 0);
+ ZVAL_LONG(zendlval, strtol(yytext, NULL, 0));
} else {
errno = 0;
- Z_LVAL_P(zendlval) = strtol(yytext, NULL, 0);
+ ZVAL_LONG(zendlval, strtol(yytext, NULL, 0));
if (errno == ERANGE) { /* Overflow */
if (yytext[0] == '0') { /* octal overflow */
- Z_DVAL_P(zendlval) = zend_oct_strtod(yytext, NULL);
+ ZVAL_DOUBLE(zendlval, zend_oct_strtod(yytext, NULL));
} else {
- Z_DVAL_P(zendlval) = zend_strtod(yytext, NULL);
+ ZVAL_DOUBLE(zendlval, zend_strtod(yytext, NULL));
}
- Z_TYPE_P(zendlval) = IS_DOUBLE;
return T_DNUMBER;
}
}
-
- Z_TYPE_P(zendlval) = IS_LONG;
return T_LNUMBER;
}
if (len < SIZEOF_LONG * 2 || (len == SIZEOF_LONG * 2 && *hex <= '7')) {
if (len == 0) {
- Z_LVAL_P(zendlval) = 0;
+ ZVAL_LONG(zendlval, 0);
} else {
- Z_LVAL_P(zendlval) = strtol(hex, NULL, 16);
+ ZVAL_LONG(zendlval, strtol(hex, NULL, 16));
}
- Z_TYPE_P(zendlval) = IS_LONG;
return T_LNUMBER;
} else {
ZVAL_DOUBLE(zendlval, zend_hex_strtod(hex, NULL));
/* We create a special __CLASS__ constant that is going to be resolved
at run-time */
ZVAL_STRINGL(zendlval, "__CLASS__", sizeof("__CLASS__") - 1);
- Z_TYPE_P(zendlval) = IS_CONSTANT;
+ Z_TYPE_INFO_P(zendlval) = IS_CONSTANT_EX;
} else {
if (ce && ce->name) {
ZVAL_STR(zendlval, STR_COPY(ce->name));
len += sizeof("::")-1;
len += CG(active_op_array)->function_name->len;
}
- ZVAL_STR(zendlval, STR_ALLOC(len, 0));
+ ZVAL_NEW_STR(zendlval, STR_ALLOC(len, 0));
len = 0;
if (CG(active_class_entry)->name) {
memcpy(Z_STRVAL_P(zendlval), CG(active_class_entry)->name->val, CG(active_class_entry)->name->len);
zend_string *filename = zend_get_compiled_filename(TSRMLS_C);
if (!filename) {
- filename = STR_EMPTY_ALLOC();
+ ZVAL_EMPTY_STRING(zendlval);
+ } else {
+ ZVAL_STR(zendlval, STR_COPY(filename));
}
- ZVAL_STR(zendlval, STR_COPY(filename));
return T_FILE;
}
HANDLE_NEWLINES(yytext, yyleng);
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
BEGIN(ST_IN_SCRIPTING);
return T_OPEN_TAG;
}
<INITIAL>"<%=" {
if (CG(asp_tags)) {
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
BEGIN(ST_IN_SCRIPTING);
return T_OPEN_TAG_WITH_ECHO;
} else {
<INITIAL>"<?=" {
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
BEGIN(ST_IN_SCRIPTING);
return T_OPEN_TAG_WITH_ECHO;
}
<INITIAL>"<%" {
if (CG(asp_tags)) {
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
BEGIN(ST_IN_SCRIPTING);
return T_OPEN_TAG;
} else {
<INITIAL>"<?php"([ \t]|{NEWLINE}) {
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way, no copying intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way, no copying intentional */
HANDLE_NEWLINE(yytext[yyleng-1]);
BEGIN(ST_IN_SCRIPTING);
return T_OPEN_TAG;
<INITIAL>"<?" {
if (CG(short_tags)) {
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way, no copying intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way, no copying intentional */
BEGIN(ST_IN_SCRIPTING);
return T_OPEN_TAG;
} else {
if (readsize < yyleng) {
yyless(readsize);
}
- Z_TYPE_P(zendlval) = IS_STRING;
+ Z_TYPE_INFO_P(zendlval) = IS_STRING_EX;
} else {
ZVAL_STRINGL(zendlval, yytext, yyleng);
}
<ST_IN_SCRIPTING>("?>"|"</script"{WHITESPACE}*">"){NEWLINE}? {
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
BEGIN(INITIAL);
return T_CLOSE_TAG; /* implicit ';' at php-end tag */
}
if (CG(asp_tags)) {
BEGIN(INITIAL);
//??? ZVAL_STRINGL(zendlval, yytext, yyleng);
- ZVAL_STR(zendlval, STR_EMPTY_ALLOC()); /* tricky way to no copying - intentional */
+ ZVAL_EMPTY_STRING(zendlval); /* tricky way to no copying - intentional */
return T_CLOSE_TAG; /* implicit ';' at php-end tag */
} else {
yyless(1);
zend_string *str;
str = Z_STR_P(op);
- if ((Z_TYPE_P(op)=is_numeric_string(str->val, str->len, &Z_LVAL_P(op), &Z_DVAL_P(op), 1)) == 0) {
+ if ((Z_TYPE_INFO_P(op)=is_numeric_string(str->val, str->len, &Z_LVAL_P(op), &Z_DVAL_P(op), 1)) == 0) {
ZVAL_LONG(op, 0);
}
STR_RELEASE(str);
break;
}
case IS_BOOL:
- Z_TYPE_P(op) = IS_LONG;
+ Z_TYPE_INFO_P(op) = IS_LONG;
break;
case IS_RESOURCE:
{
switch (Z_TYPE_P(op)) { \
case IS_STRING: \
{ \
- if ((Z_TYPE(holder)=is_numeric_string(Z_STRVAL_P(op), Z_STRLEN_P(op), &Z_LVAL(holder), &Z_DVAL(holder), 1)) == 0) { \
+ if ((Z_TYPE_INFO(holder)=is_numeric_string(Z_STRVAL_P(op), Z_STRLEN_P(op), &Z_LVAL(holder), &Z_DVAL(holder), 1)) == 0) { \
ZVAL_LONG(&(holder), 0); \
} \
(op) = &(holder); \
} else if (Z_TYPE_P(op) != IS_LONG) { \
switch (Z_TYPE_P(op)) { \
case IS_NULL: \
- Z_LVAL(holder) = 0; \
+ ZVAL_LONG(&holder, 0); \
break; \
case IS_DOUBLE: \
- Z_LVAL(holder) = zend_dval_to_lval(Z_DVAL_P(op)); \
+ ZVAL_LONG(&holder, zend_dval_to_lval(Z_DVAL_P(op)));\
break; \
case IS_STRING: \
- Z_LVAL(holder) = strtol(Z_STRVAL_P(op), NULL, 10); \
+ ZVAL_LONG(&holder, strtol(Z_STRVAL_P(op), NULL, 10));\
break; \
case IS_ARRAY: \
- Z_LVAL(holder) = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \
+ ZVAL_LONG(&holder, zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \
break; \
case IS_OBJECT: \
ZVAL_DUP(&(holder), (op)); \
convert_to_long_base(&(holder), 10); \
break; \
case IS_BOOL: \
- Z_LVAL(holder) = Z_LVAL_P(op); \
+ ZVAL_LONG(&(holder), Z_LVAL_P(op)); \
break; \
case IS_RESOURCE: \
/* ??? delete old resource ??? */ \
break; \
default: \
zend_error(E_WARNING, "Cannot convert to ordinal value"); \
- Z_LVAL(holder) = 0; \
+ ZVAL_LONG(&holder, 0); \
break; \
} \
- Z_TYPE(holder) = IS_LONG; \
(op) = &(holder); \
}
} else if (Z_TYPE_P(op) != IS_BOOL) { \
switch (Z_TYPE_P(op)) { \
case IS_NULL: \
- Z_LVAL(holder) = 0; \
+ ZVAL_BOOL(&holder, 0); \
break; \
case IS_RESOURCE: \
- Z_LVAL(holder) = (Z_RES_HANDLE_P(op) ? 1 : 0); \
+ ZVAL_BOOL(&holder, Z_RES_HANDLE_P(op) ? 1 : 0); \
break; \
case IS_LONG: \
- Z_LVAL(holder) = (Z_LVAL_P(op) ? 1 : 0); \
+ ZVAL_BOOL(&holder, Z_LVAL_P(op) ? 1 : 0); \
break; \
case IS_DOUBLE: \
- Z_LVAL(holder) = (Z_DVAL_P(op) ? 1 : 0); \
+ ZVAL_BOOL(&holder, Z_DVAL_P(op) ? 1 : 0); \
break; \
case IS_STRING: \
if (Z_STRLEN_P(op) == 0 \
|| (Z_STRLEN_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) { \
- Z_LVAL(holder) = 0; \
+ ZVAL_BOOL(&holder, 0); \
} else { \
- Z_LVAL(holder) = 1; \
+ ZVAL_BOOL(&holder, 1); \
} \
break; \
case IS_ARRAY: \
- Z_LVAL(holder) = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \
+ ZVAL_BOOL(&holder, zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \
break; \
case IS_OBJECT: \
ZVAL_DUP(&(holder), (op)); \
convert_to_boolean(&(holder)); \
break; \
default: \
- Z_LVAL(holder) = 0; \
+ ZVAL_BOOL(&holder, 0); \
break; \
} \
- Z_TYPE(holder) = IS_BOOL; \
(op) = &(holder); \
}
zend_get_type_by_const(ctype)); \
} else { \
zval_dtor(op); \
- Z_TYPE_P(op) = ctype; \
- op->value = dst.value; \
+ ZVAL_COPY_VALUE(op, &dst); \
} \
} else { \
if (Z_OBJ_HT_P(op)->get) { \
switch (Z_TYPE_P(op)) {
case IS_NULL:
- Z_LVAL_P(op) = 0;
+ ZVAL_LONG(op, 0);
break;
case IS_RESOURCE: {
TSRMLS_FETCH();
long l = Z_RES_HANDLE_P(op);
zval_ptr_dtor(op);
- Z_LVAL_P(op) = l;
+ ZVAL_LONG(op, l);
}
/* break missing intentionally */
case IS_BOOL:
+ Z_TYPE_INFO_P(op) = IS_LONG;
+ break;
case IS_LONG:
break;
case IS_DOUBLE:
- Z_LVAL_P(op) = zend_dval_to_lval(Z_DVAL_P(op));
+ ZVAL_LONG(op, zend_dval_to_lval(Z_DVAL_P(op)));
break;
case IS_STRING:
{
zend_string *str = Z_STR_P(op);
- Z_LVAL_P(op) = strtol(str->val, NULL, base);
+ ZVAL_LONG(op, strtol(str->val, NULL, base));
STR_RELEASE(str);
}
break;
case IS_ARRAY:
tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
zval_dtor(op);
- Z_LVAL_P(op) = tmp;
+ ZVAL_LONG(op, tmp);
break;
case IS_OBJECT:
{
default:
zend_error(E_WARNING, "Cannot convert to ordinal value");
zval_dtor(op);
- Z_LVAL_P(op) = 0;
+ ZVAL_LONG(op, 0);
break;
}
-
- Z_TYPE_P(op) = IS_LONG;
}
/* }}} */
switch (Z_TYPE_P(op)) {
case IS_NULL:
- Z_DVAL_P(op) = 0.0;
+ ZVAL_DOUBLE(op, 0.0);
break;
case IS_RESOURCE: {
TSRMLS_FETCH();
double d = (double) Z_RES_HANDLE_P(op);
zval_ptr_dtor(op);
- Z_DVAL_P(op) = d;
+ ZVAL_DOUBLE(op, d);
}
break;
case IS_BOOL:
case IS_LONG:
- Z_DVAL_P(op) = (double) Z_LVAL_P(op);
+ ZVAL_DOUBLE(op, (double) Z_LVAL_P(op));
break;
case IS_DOUBLE:
break;
{
zend_string *str = Z_STR_P(op);
- Z_DVAL_P(op) = zend_strtod(str->val, NULL);
+ ZVAL_DOUBLE(op, zend_strtod(str->val, NULL));
STR_RELEASE(str);
}
break;
case IS_ARRAY:
tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
zval_dtor(op);
- Z_DVAL_P(op) = tmp;
+ ZVAL_DOUBLE(op, tmp);
break;
case IS_OBJECT:
{
default:
zend_error(E_WARNING, "Cannot convert to real value (type=%d)", Z_TYPE_P(op));
zval_dtor(op);
- Z_DVAL_P(op) = 0;
+ ZVAL_DOUBLE(op, 0);
break;
}
- Z_TYPE_P(op) = IS_DOUBLE;
}
/* }}} */
}
zval_dtor(op);
- Z_TYPE_P(op) = IS_NULL;
+ ZVAL_NULL(op);
}
/* }}} */
case IS_BOOL:
break;
case IS_NULL:
- Z_LVAL_P(op) = 0;
+ ZVAL_BOOL(op, 0);
break;
case IS_RESOURCE: {
TSRMLS_FETCH();
long l = (Z_RES_HANDLE_P(op) ? 1 : 0);
zval_ptr_dtor(op);
- Z_LVAL_P(op) = l;
+ ZVAL_BOOL(op, l);
}
break;
case IS_LONG:
- Z_LVAL_P(op) = (Z_LVAL_P(op) ? 1 : 0);
+ ZVAL_BOOL(op, Z_LVAL_P(op) ? 1 : 0);
break;
case IS_DOUBLE:
- Z_LVAL_P(op) = (Z_DVAL_P(op) ? 1 : 0);
+ ZVAL_BOOL(op, Z_DVAL_P(op) ? 1 : 0);
break;
case IS_STRING:
{
if (str->len == 0
|| (str->len == 1 && str->val[0] == '0')) {
- Z_LVAL_P(op) = 0;
+ ZVAL_BOOL(op, 0);
} else {
- Z_LVAL_P(op) = 1;
+ ZVAL_BOOL(op, 1);
}
STR_RELEASE(str);
}
case IS_ARRAY:
tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
zval_dtor(op);
- Z_LVAL_P(op) = tmp;
+ ZVAL_BOOL(op, tmp);
break;
case IS_OBJECT:
{
}
default:
zval_dtor(op);
- Z_LVAL_P(op) = 0;
+ ZVAL_BOOL(op, 0);
break;
}
- Z_TYPE_P(op) = IS_BOOL;
}
/* }}} */
ZEND_API void _convert_to_cstring(zval *op ZEND_FILE_LINE_DC) /* {{{ */
{
- double dval;
- switch (Z_TYPE_P(op)) {
- case IS_DOUBLE: {
- TSRMLS_FETCH();
- dval = Z_DVAL_P(op);
- Z_STRLEN_P(op) = zend_spprintf((char**)&Z_STRVAL_P(op), 0, "%.*H", (int) EG(precision), dval);
- /* %H already handles removing trailing zeros from the fractional part, yay */
- break;
- }
- default:
+//??? double dval;
+//??? switch (Z_TYPE_P(op)) {
+//??? case IS_DOUBLE: {
+//??? TSRMLS_FETCH();
+//??? dval = Z_DVAL_P(op);
+//??? Z_STRLEN_P(op) = zend_spprintf((char**)&Z_STRVAL_P(op), 0, "%.*H", (int) EG(precision), dval);
+//??? /* %H already handles removing trailing zeros from the fractional part, yay */
+//??? break;
+//??? }
+//??? default:
_convert_to_string(op ZEND_FILE_LINE_CC);
- }
- Z_TYPE_P(op) = IS_STRING;
+//??? }
+//??? Z_TYPE_P(op) = IS_STRING;
}
/* }}} */
switch (Z_TYPE_P(op)) {
case IS_NULL:
- Z_STR_P(op) = STR_EMPTY_ALLOC();
+ ZVAL_EMPTY_STRING(op);
break;
case IS_STRING:
break;
case IS_BOOL:
if (Z_LVAL_P(op)) {
- Z_STR_P(op) = STR_INIT("1", 1, 0);
+ ZVAL_NEW_STR(op, STR_INIT("1", 1, 0));
} else {
- Z_STR_P(op) = STR_EMPTY_ALLOC();
+ ZVAL_EMPTY_STRING(op);
}
break;
case IS_RESOURCE: {
zval_ptr_dtor(op);
len = zend_spprintf(&str, 0, "Resource id #%ld", tmp);
- Z_STR_P(op) = STR_INIT(str, len, 0);
+ ZVAL_NEW_STR(op, STR_INIT(str, len, 0));
efree(str);
break;
}
lval = Z_LVAL_P(op);
len = zend_spprintf(&str, 0, "%ld", lval);
- Z_STR_P(op) = STR_INIT(str, len, 0);
+ ZVAL_NEW_STR(op, STR_INIT(str, len, 0));
efree(str);
break;
}
dval = Z_DVAL_P(op);
len = zend_spprintf(&str, 0, "%.*G", (int) EG(precision), dval);
/* %G already handles removing trailing zeros from the fractional part, yay */
- Z_STR_P(op) = STR_INIT(str, len, 0);
+ ZVAL_NEW_STR(op, STR_INIT(str, len, 0));
efree(str);
break;
}
case IS_ARRAY:
zend_error(E_NOTICE, "Array to string conversion");
zval_dtor(op);
- Z_STR_P(op) = STR_INIT("Array", sizeof("Array")-1, 0);
+ ZVAL_NEW_STR(op, STR_INIT("Array", sizeof("Array")-1, 0));
break;
case IS_OBJECT: {
TSRMLS_FETCH();
zend_error(E_NOTICE, "Object of class %s to string conversion", Z_OBJCE_P(op)->name->val);
zval_dtor(op);
- Z_STR_P(op) = STR_INIT("Object", sizeof("Object")-1, 0);
+ ZVAL_NEW_STR(op, STR_INIT("Object", sizeof("Object")-1, 0));
break;
}
default:
ZVAL_BOOL(op, 0);
break;
}
- Z_TYPE_P(op) = IS_STRING;
}
/* }}} */
ZVAL_NEW_ARR(op);
zend_hash_init(Z_ARRVAL_P(op), 0, NULL, ZVAL_PTR_DTOR, 0);
zend_hash_index_update(Z_ARRVAL_P(op), 0, &entry);
- Z_TYPE_P(op) = IS_ARRAY;
break;
case IS_OBJECT:
object_init(op);
long overflow;
ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1),Z_LVAL_P(op2), Z_LVAL_P(result),Z_DVAL_P(result),overflow);
- Z_TYPE_P(result) = overflow ? IS_DOUBLE : IS_LONG;
+ Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
return SUCCESS;
}
int i;
zval op1_copy = *op1;
- Z_TYPE_P(result) = IS_STRING;
- Z_STR_P(result) = STR_ALLOC(Z_STRLEN(op1_copy), 0);
+ ZVAL_NEW_STR(result, STR_ALLOC(Z_STRLEN(op1_copy), 0));
for (i = 0; i < Z_STRLEN(op1_copy); i++) {
Z_STRVAL_P(result)[i] = ~Z_STRVAL(op1_copy)[i];
}
if (result==op1) {
STR_RELEASE(Z_STR_P(result));
}
- ZVAL_STR(result, str);
+ ZVAL_NEW_STR(result, str);
return SUCCESS;
}
if (result==op1) {
STR_RELEASE(Z_STR_P(result));
}
- ZVAL_STR(result, str);
+ ZVAL_NEW_STR(result, str);
return SUCCESS;
}
if (result==op1) {
STR_RELEASE(Z_STR_P(result));
}
- ZVAL_STR(result, str);
+ ZVAL_NEW_STR(result, str);
return SUCCESS;
}
buf->val[length - 1] = (char) Z_LVAL_P(op2);
buf->val[length] = 0;
- ZVAL_STR(result, buf);
+ ZVAL_NEW_STR(result, buf);
return SUCCESS;
}
/* }}} */
memcpy(buf->val + op1_len, Z_STRVAL_P(op2), Z_STRLEN_P(op2));
buf->val[length] = 0;
- ZVAL_STR(result, buf);
+ ZVAL_NEW_STR(result, buf);
return SUCCESS;
}
/* }}} */
}
Z_STR_P(result) = STR_REALLOC(Z_STR_P(result), res_len, 0 );
-
+ Z_TYPE_INFO_P(result) = IS_STRING_EX;
memcpy(Z_STRVAL_P(result) + op1_len, Z_STRVAL_P(op2), op2_len);
Z_STRVAL_P(result)[res_len]=0;
} else {
memcpy(buf->val, Z_STRVAL_P(op1), Z_STRLEN_P(op1));
memcpy(buf->val + Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2));
buf->val[length] = 0;
- ZVAL_STR(result, buf);
+ ZVAL_NEW_STR(result, buf);
}
if (use_copy1) {
zval_dtor(op1);
ZEND_API int is_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
- Z_TYPE_P(result) = IS_BOOL;
if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) {
- Z_LVAL_P(result) = 0;
+ ZVAL_BOOL(result, 0);
return SUCCESS;
}
switch (Z_TYPE_P(op1)) {
case IS_NULL:
- Z_LVAL_P(result) = 1;
+ ZVAL_BOOL(result, 1);
break;
case IS_BOOL:
case IS_LONG:
- Z_LVAL_P(result) = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+ ZVAL_BOOL(result, Z_LVAL_P(op1) == Z_LVAL_P(op2));
break;
case IS_RESOURCE:
- Z_LVAL_P(result) = (Z_RES_P(op1) == Z_RES_P(op2));
+ ZVAL_BOOL(result, Z_RES_P(op1) == Z_RES_P(op2));
break;
case IS_DOUBLE:
- Z_LVAL_P(result) = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+ ZVAL_BOOL(result, Z_DVAL_P(op1) == Z_DVAL_P(op2));
break;
case IS_STRING:
- Z_LVAL_P(result) = ((Z_STRLEN_P(op1) == Z_STRLEN_P(op2))
+// TODO: interned strings ???
+ ZVAL_BOOL(result, (Z_STRLEN_P(op1) == Z_STRLEN_P(op2))
&& (!memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1))));
break;
case IS_ARRAY:
- Z_LVAL_P(result) = (Z_ARRVAL_P(op1) == Z_ARRVAL_P(op2) ||
+ ZVAL_BOOL(result, Z_ARRVAL_P(op1) == Z_ARRVAL_P(op2) ||
zend_hash_compare(Z_ARRVAL_P(op1), Z_ARRVAL_P(op2), (compare_func_t) hash_zval_identical_function, 1 TSRMLS_CC)==0);
break;
case IS_OBJECT:
if (Z_OBJ_HT_P(op1) == Z_OBJ_HT_P(op2)) {
- Z_LVAL_P(result) = (Z_OBJ_P(op1) == Z_OBJ_P(op2));
+ ZVAL_BOOL(result, Z_OBJ_P(op1) == Z_OBJ_P(op2));
} else {
- Z_LVAL_P(result) = 0;
+ ZVAL_BOOL(result, 0);
}
break;
default:
- Z_LVAL_P(result) = 0;
+ ZVAL_BOOL(result, 0);
return FAILURE;
}
return SUCCESS;
if (Z_STRLEN_P(str) == 0) {
STR_RELEASE(Z_STR_P(str));
Z_STR_P(str) = STR_INIT("1", sizeof("1")-1, 0);
+ Z_TYPE_INFO_P(str) = IS_STRING_EX;
return;
}
if (IS_INTERNED(Z_STR_P(str))) {
Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRLEN_P(str), 0);
+ Z_TYPE_INFO_P(str) = IS_STRING_EX;
} else if (Z_REFCOUNT_P(str) > 1) {
Z_DELREF_P(str);
Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRLEN_P(str), 0);
break;
}
STR_FREE(Z_STR_P(str));
- ZVAL_STR(str, t);
+ ZVAL_NEW_STR(str, t);
}
}
/* }}} */
ZEND_API void zend_compare_objects(zval *result, zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
{
- Z_TYPE_P(result) = IS_LONG;
-
if (Z_OBJ_P(o1) == Z_OBJ_P(o2)) {
- Z_LVAL_P(result) = 0;
+ ZVAL_LONG(result, 0);
return;
}
if (Z_OBJ_HT_P(o1)->compare_objects == NULL) {
- Z_LVAL_P(result) = 1;
+ ZVAL_LONG(result, 1);
} else {
- Z_LVAL_P(result) = Z_OBJ_HT_P(o1)->compare_objects(o1, o2 TSRMLS_CC);
+ ZVAL_LONG(result, Z_OBJ_HT_P(o1)->compare_objects(o1, o2 TSRMLS_CC));
}
}
/* }}} */
int len;
len = zend_spprintf(&str, 0, "%.*G", (int) EG(precision), (double)Z_DVAL_P(op));
- Z_STR_P(op) = STR_INIT(str, len, 0);
+ ZVAL_NEW_STR(op, STR_INIT(str, len, 0));
efree(str);
}
/* }}} */
/* The offset in bytes between the value and type fields of a zval */
#define ZVAL_OFFSETOF_TYPE \
- (offsetof(zval, u.v.type) - offsetof(zval, value))
+ (offsetof(zval, u1.type_info) - offsetof(zval, value))
static zend_always_inline int fast_increment_function(zval *op1)
{
"jno 0f\n\t"
"movl $0x0, (%0)\n\t"
"movl $0x41e00000, 0x4(%0)\n\t"
- "movb %1, %c2(%0)\n"
+ "movl %1, %c2(%0)\n"
"0:"
:
: "r"(&op1->value),
"jno 0f\n\t"
"movl $0x0, (%0)\n\t"
"movl $0x43e00000, 0x4(%0)\n\t"
- "movb %1, %c2(%0)\n"
+ "movl %1, %c2(%0)\n"
"0:"
:
: "r"(&op1->value),
#else
if (UNEXPECTED(Z_LVAL_P(op1) == LONG_MAX)) {
/* switch to double */
- Z_DVAL_P(op1) = (double)LONG_MAX + 1.0;
- Z_TYPE_P(op1) = IS_DOUBLE;
+ ZVAL_DOUBLE(op1, (double)LONG_MAX + 1.0);
} else {
Z_LVAL_P(op1)++;
}
"jno 0f\n\t"
"movl $0x00200000, (%0)\n\t"
"movl $0xc1e00000, 0x4(%0)\n\t"
- "movb %1,%c2(%0)\n"
+ "movl %1,%c2(%0)\n"
"0:"
:
: "r"(&op1->value),
"jno 0f\n\t"
"movl $0x00000000, (%0)\n\t"
"movl $0xc3e00000, 0x4(%0)\n\t"
- "movb %1,%c2(%0)\n"
+ "movl %1,%c2(%0)\n"
"0:"
:
: "r"(&op1->value),
#else
if (UNEXPECTED(Z_LVAL_P(op1) == LONG_MIN)) {
/* switch to double */
- Z_DVAL_P(op1) = (double)LONG_MIN - 1.0;
- Z_TYPE_P(op1) = IS_DOUBLE;
+ ZVAL_DOUBLE(op1, (double)LONG_MIN - 1.0);
} else {
Z_LVAL_P(op1)--;
}
"addl (%2), %%eax\n\t"
"jo 0f\n\t"
"movl %%eax, (%0)\n\t"
- "movb %3, %c5(%0)\n\t"
+ "movl %3, %c5(%0)\n\t"
"jmp 1f\n"
"0:\n\t"
"fildl (%1)\n\t"
"fildl (%2)\n\t"
"faddp %%st, %%st(1)\n\t"
- "movb %4, %c5(%0)\n\t"
+ "movl %4, %c5(%0)\n\t"
"fstpl (%0)\n"
"1:"
:
"addq (%2), %%rax\n\t"
"jo 0f\n\t"
"movq %%rax, (%0)\n\t"
- "movb %3, %c5(%0)\n\t"
+ "movl %3, %c5(%0)\n\t"
"jmp 1f\n"
"0:\n\t"
"fildq (%1)\n\t"
"fildq (%2)\n\t"
"faddp %%st, %%st(1)\n\t"
- "movb %4, %c5(%0)\n\t"
+ "movl %4, %c5(%0)\n\t"
"fstpl (%0)\n"
"1:"
:
if (UNEXPECTED((Z_LVAL_P(op1) & LONG_SIGN_MASK) == (Z_LVAL_P(op2) & LONG_SIGN_MASK)
&& (Z_LVAL_P(op1) & LONG_SIGN_MASK) != ((Z_LVAL_P(op1) + Z_LVAL_P(op2)) & LONG_SIGN_MASK))) {
- Z_DVAL_P(result) = (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2);
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2));
} else {
- Z_LVAL_P(result) = Z_LVAL_P(op1) + Z_LVAL_P(op2);
- Z_TYPE_P(result) = IS_LONG;
+ ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
}
#endif
return SUCCESS;
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
- Z_DVAL_P(result) = ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2);
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));
return SUCCESS;
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
- Z_DVAL_P(result) = Z_DVAL_P(op1) + Z_DVAL_P(op2);
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
return SUCCESS;
} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
- Z_DVAL_P(result) = Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2));
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));
return SUCCESS;
}
}
"subl (%2), %%eax\n\t"
"jo 0f\n\t"
"movl %%eax, (%0)\n\t"
- "movb %3, %c5(%0)\n\t"
+ "movl %3, %c5(%0)\n\t"
"jmp 1f\n"
"0:\n\t"
"fildl (%2)\n\t"
#else
"fsubp %%st, %%st(1)\n\t"
#endif
- "movb %4, %c5(%0)\n\t"
+ "movl %4, %c5(%0)\n\t"
"fstpl (%0)\n"
"1:"
:
"subq (%2), %%rax\n\t"
"jo 0f\n\t"
"movq %%rax, (%0)\n\t"
- "movb %3, %c5(%0)\n\t"
+ "movl %3, %c5(%0)\n\t"
"jmp 1f\n"
"0:\n\t"
"fildq (%2)\n\t"
#else
"fsubp %%st, %%st(1)\n\t"
#endif
- "movb %4, %c5(%0)\n\t"
+ "movl %4, %c5(%0)\n\t"
"fstpl (%0)\n"
"1:"
:
"n"(ZVAL_OFFSETOF_TYPE)
: "rax","cc");
#else
- Z_LVAL_P(result) = Z_LVAL_P(op1) - Z_LVAL_P(op2);
+ ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
if (UNEXPECTED((Z_LVAL_P(op1) & LONG_SIGN_MASK) != (Z_LVAL_P(op2) & LONG_SIGN_MASK)
&& (Z_LVAL_P(op1) & LONG_SIGN_MASK) != (Z_LVAL_P(result) & LONG_SIGN_MASK))) {
- Z_DVAL_P(result) = (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2);
- Z_TYPE_P(result) = IS_DOUBLE;
- } else {
- Z_TYPE_P(result) = IS_LONG;
+ ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2));
}
#endif
return SUCCESS;
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
- Z_DVAL_P(result) = ((double)Z_LVAL_P(op1)) - Z_DVAL_P(op2);
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) - Z_DVAL_P(op2));
return SUCCESS;
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
- Z_DVAL_P(result) = Z_DVAL_P(op1) - Z_DVAL_P(op2);
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
return SUCCESS;
} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
- Z_DVAL_P(result) = Z_DVAL_P(op1) - ((double)Z_LVAL_P(op2));
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) - ((double)Z_LVAL_P(op2)));
return SUCCESS;
}
}
long overflow;
ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
- Z_TYPE_P(result) = overflow ? IS_DOUBLE : IS_LONG;
+ Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
return SUCCESS;
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
- Z_DVAL_P(result) = ((double)Z_LVAL_P(op1)) * Z_DVAL_P(op2);
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) * Z_DVAL_P(op2));
return SUCCESS;
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
- Z_DVAL_P(result) = Z_DVAL_P(op1) * Z_DVAL_P(op2);
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
return SUCCESS;
} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
- Z_DVAL_P(result) = Z_DVAL_P(op1) * ((double)Z_LVAL_P(op2));
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) * ((double)Z_LVAL_P(op2)));
return SUCCESS;
}
}
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
zend_error(E_WARNING, "Division by zero");
- Z_LVAL_P(result) = 0;
- Z_TYPE_P(result) = IS_BOOL;
+ ZVAL_BOOL(result, 0);
return FAILURE;
} else if (UNEXPECTED(Z_LVAL_P(op2) == -1 && Z_LVAL_P(op1) == LONG_MIN)) {
/* Prevent overflow error/crash */
- Z_DVAL_P(result) = (double) LONG_MIN / -1;
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, (double) LONG_MIN / -1);
} else if (EXPECTED(Z_LVAL_P(op1) % Z_LVAL_P(op2) == 0)) {
/* integer */
- Z_LVAL_P(result) = Z_LVAL_P(op1) / Z_LVAL_P(op2);
- Z_TYPE_P(result) = IS_LONG;
+ ZVAL_LONG(result, Z_LVAL_P(op1) / Z_LVAL_P(op2));
} else {
- Z_DVAL_P(result) = ((double) Z_LVAL_P(op1)) / ((double)Z_LVAL_P(op2));
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, ((double) Z_LVAL_P(op1)) / ((double)Z_LVAL_P(op2)));
}
return SUCCESS;
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
if (UNEXPECTED(Z_DVAL_P(op2) == 0)) {
zend_error(E_WARNING, "Division by zero");
- Z_LVAL_P(result) = 0;
- Z_TYPE_P(result) = IS_BOOL;
+ ZVAL_BOOL(result, 0);
return FAILURE;
}
- Z_DVAL_P(result) = ((double)Z_LVAL_P(op1)) / Z_DVAL_P(op2);
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) / Z_DVAL_P(op2));
return SUCCESS;
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE) && 0) {
if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
if (UNEXPECTED(Z_DVAL_P(op2) == 0)) {
zend_error(E_WARNING, "Division by zero");
- Z_LVAL_P(result) = 0;
- Z_TYPE_P(result) = IS_BOOL;
+ ZVAL_BOOL(result, 0);
return FAILURE;
}
- Z_DVAL_P(result) = Z_DVAL_P(op1) / Z_DVAL_P(op2);
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) / Z_DVAL_P(op2));
return SUCCESS;
} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
zend_error(E_WARNING, "Division by zero");
- Z_LVAL_P(result) = 0;
- Z_TYPE_P(result) = IS_BOOL;
+ ZVAL_BOOL(result, 0);
return FAILURE;
}
- Z_DVAL_P(result) = Z_DVAL_P(op1) / ((double)Z_LVAL_P(op2));
- Z_TYPE_P(result) = IS_DOUBLE;
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) / ((double)Z_LVAL_P(op2)));
return SUCCESS;
}
}
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
zend_error(E_WARNING, "Division by zero");
- Z_LVAL_P(result) = 0;
- Z_TYPE_P(result) = IS_BOOL;
+ ZVAL_BOOL(result, 0);
return FAILURE;
} else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
/* Prevent overflow error/crash if op1==LONG_MIN */
- Z_LVAL_P(result) = 0;
- Z_TYPE_P(result) = IS_LONG;
+ ZVAL_LONG(result, 0);
return SUCCESS;
}
- Z_LVAL_P(result) = Z_LVAL_P(op1) % Z_LVAL_P(op2);
- Z_TYPE_P(result) = IS_LONG;
+ ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
return SUCCESS;
}
}
p->h = h;
p->key = str;
Z_STR(p->val) = str;
- Z_TYPE(p->val) = IS_STRING;
+ Z_TYPE_INFO(p->val) = IS_INTERNED_STRING_EX;
nIndex = h & CG(interned_strings).nTableMask;
Z_NEXT(p->val) = CG(interned_strings).arHash[nIndex];
CG(interned_strings).arHash[nIndex] = idx;
zend_string *ret = pemalloc(sizeof(zend_string) + len, persistent);
GC_REFCOUNT(ret) = 1;
-// TODO use one assignment ???
+#if 1
+ /* optimized single assignment */
+ GC_TYPE_INFO(ret) = IS_STRING | ((persistent ? IS_STR_PERSISTENT : 0) << 8);
+#else
GC_TYPE(ret) = IS_STRING;
GC_FLAGS(ret) = (persistent ? IS_STR_PERSISTENT : 0);
GC_INFO(ret) = 0;
+#endif
ret->h = 0;
ret->len = len;
return ret;
union {
struct {
ZEND_ENDIAN_LOHI_4(
- zend_uchar type, /* active type */
- zend_uchar flags, /* various IS_VAR flags */
- zend_uchar res1,
- zend_uchar res2)
+ zend_uchar type, /* active type */
+ zend_uchar type_flags,
+ zend_uchar const_flags,
+ zend_uchar reserved) /* various IS_VAR flags */
} v;
zend_uint type_info;
- } u;
- zend_uint next; /* hash collision chain */
+ } u1;
+ union {
+ zend_uint var_flags;
+ zend_uint next; /* hash collision chain */
+ } u2;
};
struct _zend_refcounted {
#define IS_BOOL 3
#define IS_LONG 4
#define IS_DOUBLE 5
-//#define IS_INTERNED_STRING 6
-#define IS_STRING 7
-#define IS_ARRAY 8
-#define IS_OBJECT 9
-#define IS_RESOURCE 10
-#define IS_REFERENCE 11
-
-#define IS_CONSTANT 12
-#define IS_CONSTANT_ARRAY 13
-#define IS_CONSTANT_AST 14
-#define IS_CALLABLE 15
-
-#define IS_STR_OFFSET 16
-#define IS_PTR 17
-
-/* Ugly hack to support constants as static array indices */
-#define IS_CONSTANT_TYPE_MASK 0x00f
-#define IS_CONSTANT_UNQUALIFIED 0x010
-//???#define IS_CONSTANT_INDEX 0x080
-#define IS_LEXICAL_VAR 0x020
-#define IS_LEXICAL_REF 0x040
-#define IS_CONSTANT_IN_NAMESPACE 0x100
-
-#define IS_CONSTANT_TYPE(type) \
- (((type) & IS_CONSTANT_TYPE_MASK) >= IS_CONSTANT && ((type) & IS_CONSTANT_TYPE_MASK) <= IS_CONSTANT_AST)
+#define IS_STRING 6
+#define IS_ARRAY 7
+#define IS_OBJECT 8
+#define IS_RESOURCE 9
+#define IS_REFERENCE 10
+
+#define IS_CONSTANT 11
+#define IS_CONSTANT_ARRAY 12
+#define IS_CONSTANT_AST 13
+#define IS_CALLABLE 14
+
+#define IS_STR_OFFSET 15
+#define IS_PTR 16
+
+static inline zend_uchar zval_get_type(const zval* pz) {
+ return pz->u1.v.type;
+}
+
+//???
+#if 0
+# define Z_TYPE(zval) (zval).u1.v.type
+#else
+# define Z_TYPE(zval) zval_get_type(&(zval))
+#endif
+#define Z_TYPE_P(zval_p) Z_TYPE(*(zval_p))
-/* All data types < IS_STRING have their constructor/destructors skipped */
-#define IS_REFCOUNTED(type) ((type) >= IS_STRING)
+#define Z_TYPE_FLAGS(zval) (zval).u1.v.type_flags
+#define Z_TYPE_FLAGS_P(zval_p) Z_TYPE_FLAGS(*(zval_p))
-#define Z_TYPE(zval) (zval).u.v.type
-#define Z_TYPE_P(zval_p) Z_TYPE(*(zval_p))
+#define Z_CONST_FLAGS(zval) (zval).u1.v.const_flags
+#define Z_CONST_FLAGS_P(zval_p) Z_CONST_FLAGS(*(zval_p))
-#define Z_FLAGS(zval) (zval).u.v.flags
-#define Z_FLAGS_P(zval_p) Z_FLAGS(*(zval_p))
+#define Z_VAR_FLAGS(zval) (zval).u2.var_flags
+#define Z_VAR_FLAGS_P(zval_p) Z_VAR_FLAGS(*(zval_p))
-#define Z_TYPE_INFO(zval) (zval).u.type_info
+#define Z_TYPE_INFO(zval) (zval).u1.type_info
#define Z_TYPE_INFO_P(zval_p) Z_TYPE_INFO(*(zval_p))
-#define Z_NEXT(zval) (zval).next
+#define Z_NEXT(zval) (zval).u2.next
#define Z_NEXT_P(zval_p) Z_NEXT(*(zval_p))
#define Z_COUNTED(zval) (zval).value.counted
#define Z_GC_TYPE_INFO(zval) GC_TYPE_INFO(Z_COUNTED(zval))
#define Z_GC_TYPE_INFO_P(zval_p) Z_GC_TYPE_INFO(*(zval_p))
-/* zval.var_flags */
+/* zval.u1.v.type_flags */
+#define IS_TYPE_CONSTANT (1<<0)
+#define IS_TYPE_REFCOUNTED (1<<1)
+#define IS_TYPE_COLLECTABLE (1<<2)
+#define IS_TYPE_COPYABLE (1<<3)
+
+/* extended types */
+#define IS_INTERNED_STRING_EX IS_STRING
+
+#define IS_STRING_EX (IS_STRING | (( IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE) << 8))
+#define IS_ARRAY_EX (IS_ARRAY | (( IS_TYPE_REFCOUNTED | IS_TYPE_COLLECTABLE | IS_TYPE_COPYABLE) << 8))
+#define IS_OBJECT_EX (IS_OBJECT | (( IS_TYPE_REFCOUNTED | IS_TYPE_COLLECTABLE ) << 8))
+#define IS_RESOURCE_EX (IS_RESOURCE | (( IS_TYPE_REFCOUNTED ) << 8))
+#define IS_REFERENCE_EX (IS_REFERENCE | (( IS_TYPE_REFCOUNTED ) << 8))
+
+#define IS_CONSTANT_EX (IS_CONSTANT | ((IS_TYPE_CONSTANT | IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE) << 8))
+#define IS_CONSTANT_ARRAY_EX (IS_CONSTANT_ARRAY | ((IS_TYPE_CONSTANT | IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE) << 8))
+#define IS_CONSTANT_AST_EX (IS_CONSTANT_AST | ((IS_TYPE_CONSTANT | IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE) << 8))
+
+/* zval.u1.v.const_flags */
+#define IS_CONSTANT_UNQUALIFIED 0x010
+#define IS_LEXICAL_VAR 0x020
+#define IS_LEXICAL_REF 0x040
+#define IS_CONSTANT_IN_NAMESPACE 0x100 /* used only in opline->extended_value */
+
+/* zval.u2.var_flags */
#define IS_VAR_RET_REF (1<<0) /* return by by reference */
/* string flags (zval.value->gc.u.flags) */
#define IS_STR_CONSTANT_UNQUALIFIED (1<<4) /* the same as IS_CONSTANT_UNQUALIFIED */
#define IS_STR_AST (1<<5) /* constant expression index */
-/* object flags (zval.value->gc.u.vflags) */
+/* object flags (zval.value->gc.u.flags) */
#define IS_OBJ_APPLY_COUNT 0x07
#define IS_OBJ_DESTRUCTOR_CALLED (1<<3)
#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)) && \
- (Z_TYPE(zval) != IS_STRING || \
- !IS_INTERNED(Z_STR(zval))))
+/* All data types < IS_STRING have their constructor/destructors skipped */
+#define Z_REFCOUNTED(zval) (Z_TYPE_FLAGS(zval) & IS_TYPE_REFCOUNTED)
#define Z_REFCOUNTED_P(zval_p) Z_REFCOUNTED(*(zval_p))
#define Z_ISREF(zval) (Z_TYPE(zval) == IS_REFERENCE)
#define Z_STR_OFFSET(zval) (zval).value.str_offset
#define Z_STR_OFFSET_P(zval_p) Z_STR_OFFSET(*(zval_p))
-#define ZVAL_UNDEF(z) do { \
- Z_TYPE_P(z) = IS_UNDEF; \
+#define ZVAL_UNDEF(z) do { \
+ Z_TYPE_INFO_P(z) = IS_UNDEF; \
} while (0)
-#define ZVAL_NULL(z) do { \
- Z_TYPE_P(z) = IS_NULL; \
+#define ZVAL_NULL(z) do { \
+ Z_TYPE_INFO_P(z) = IS_NULL; \
} while (0)
-#define ZVAL_BOOL(z, b) do { \
- zval *__z = (z); \
- Z_LVAL_P(__z) = ((b) != 0); \
- Z_TYPE_P(__z) = IS_BOOL; \
+#define ZVAL_BOOL(z, b) do { \
+ zval *__z = (z); \
+ Z_LVAL_P(__z) = ((b) != 0); \
+ Z_TYPE_INFO_P(__z) = IS_BOOL; \
} while (0)
-#define ZVAL_LONG(z, l) { \
- zval *__z = (z); \
- Z_LVAL_P(__z) = l; \
- Z_TYPE_P(__z) = IS_LONG; \
+#define ZVAL_LONG(z, l) { \
+ zval *__z = (z); \
+ Z_LVAL_P(__z) = l; \
+ Z_TYPE_INFO_P(__z) = IS_LONG; \
}
-#define ZVAL_DOUBLE(z, d) { \
- zval *__z = (z); \
- Z_DVAL_P(__z) = d; \
- Z_TYPE_P(__z) = IS_DOUBLE; \
+#define ZVAL_DOUBLE(z, d) { \
+ zval *__z = (z); \
+ Z_DVAL_P(__z) = d; \
+ Z_TYPE_INFO_P(__z) = IS_DOUBLE; \
}
#define ZVAL_STR(z, s) do { \
zval *__z = (z); \
- Z_STR_P(__z) = (s); \
- Z_TYPE_P(__z) = IS_STRING; \
+ zend_string *__s = (s); \
+ Z_STR_P(__z) = __s; \
+ /* interned strings support */ \
+ Z_TYPE_INFO_P(__z) = IS_INTERNED(__s) ? \
+ IS_INTERNED_STRING_EX : \
+ IS_STRING_EX; \
+ } while (0)
+
+#define ZVAL_INT_STR(z, s) do { \
+ zval *__z = (z); \
+ zend_string *__s = (s); \
+ Z_STR_P(__z) = __s; \
+ Z_TYPE_INFO_P(__z) = IS_INTERNED_STRING_EX; \
+ } while (0)
+
+#define ZVAL_NEW_STR(z, s) do { \
+ zval *__z = (z); \
+ zend_string *__s = (s); \
+ Z_STR_P(__z) = __s; \
+ /* interned strings support */ \
+ Z_TYPE_INFO_P(__z) = IS_STRING_EX; \
} while (0)
#define ZVAL_ARR(z, a) do { \
zval *__z = (z); \
Z_ARR_P(__z) = (a); \
- Z_TYPE_P(__z) = IS_ARRAY; \
+ Z_TYPE_INFO_P(__z) = IS_ARRAY_EX; \
} while (0)
#define ZVAL_NEW_ARR(z) do { \
GC_REFCOUNT(_arr) = 1; \
GC_TYPE_INFO(_arr) = IS_ARRAY; \
Z_ARR_P(__z) = _arr; \
- Z_TYPE_P(__z) = IS_ARRAY; \
+ Z_TYPE_INFO_P(__z) = IS_ARRAY_EX; \
} while (0)
#define ZVAL_NEW_PERSISTENT_ARR(z) do { \
GC_REFCOUNT(_arr) = 1; \
GC_TYPE_INFO(_arr) = IS_ARRAY; \
Z_ARR_P(__z) = _arr; \
- Z_TYPE_P(__z) = IS_ARRAY; \
+ Z_TYPE_INFO_P(__z) = IS_ARRAY_EX; \
} while (0)
#define ZVAL_OBJ(z, o) do { \
zval *__z = (z); \
Z_OBJ_P(__z) = (o); \
- Z_TYPE_P(__z) = IS_OBJECT; \
+ Z_TYPE_INFO_P(__z) = IS_OBJECT_EX; \
} while (0)
#define ZVAL_RES(z, r) do { \
zval *__z = (z); \
Z_RES_P(__z) = (r); \
- Z_TYPE_P(__z) = IS_RESOURCE; \
+ Z_TYPE_INFO_P(__z) = IS_RESOURCE_EX; \
} while (0)
#define ZVAL_NEW_RES(z, h, p, t) do { \
_res->ptr = (p); \
zval *__z = (z); \
Z_RES_P(__z) = _res; \
- Z_TYPE_P(__z) = IS_RESOURCE; \
+ Z_TYPE_INFO_P(__z) = IS_RESOURCE_EX; \
} while (0)
#define ZVAL_NEW_PERSISTENT_RES(z, h, p, t) do { \
_res->ptr = (p); \
zval *__z = (z); \
Z_RES_P(__z) = _res; \
- Z_TYPE_P(__z) = IS_RESOURCE; \
+ Z_TYPE_INFO_P(__z) = IS_RESOURCE_EX; \
} while (0)
#define ZVAL_REF(z, r) do { \
zval *__z = (z); \
Z_REF_P(__z) = (r); \
- Z_TYPE_P(__z) = IS_REFERENCE; \
+ Z_TYPE_INFO_P(__z) = IS_REFERENCE_EX; \
} while (0)
#define ZVAL_NEW_REF(z, r) do { \
GC_TYPE_INFO(_ref) = IS_REFERENCE; \
ZVAL_COPY_VALUE(&_ref->val, r); \
Z_REF_P(z) = _ref; \
- Z_TYPE_P(z) = IS_REFERENCE; \
+ Z_TYPE_INFO_P(z) = IS_REFERENCE_EX; \
} while (0)
#define ZVAL_NEW_AST(z, a) do { \
GC_TYPE_INFO(_ast) = IS_CONSTANT_AST; \
_ast->ast = (a); \
Z_AST_P(__z) = _ast; \
- Z_TYPE_P(__z) = IS_CONSTANT_AST; \
+ Z_TYPE_INFO_P(__z) = IS_CONSTANT_AST_EX; \
} while (0)
#define ZVAL_INDIRECT(z, v) do { \
Z_INDIRECT_P(z) = (v); \
- Z_TYPE_P(z) = IS_INDIRECT; \
+ Z_TYPE_INFO_P(z) = IS_INDIRECT; \
} while (0)
#define ZVAL_PTR(z, p) do { \
Z_PTR_P(z) = (p); \
- Z_TYPE_P(z) = IS_PTR; \
+ Z_TYPE_INFO_P(z) = IS_PTR; \
} while (0)
#define ZVAL_FUNC(z, f) do { \
Z_FUNC_P(z) = (f); \
- Z_TYPE_P(z) = IS_PTR; \
+ Z_TYPE_INFO_P(z) = IS_PTR; \
} while (0)
#define ZVAL_CE(z, c) do { \
Z_CE_P(z) = (c); \
- Z_TYPE_P(z) = IS_PTR; \
+ Z_TYPE_INFO_P(z) = IS_PTR; \
} while (0)
#define ZVAL_STR_OFFSET(z, s, o) do { \
x->str = (s); \
x->offset = (o); \
Z_STR_OFFSET_P(z) = x; \
- Z_TYPE_P(z) = IS_STR_OFFSET; \
+ Z_TYPE_INFO_P(z) = IS_STR_OFFSET; \
} while (0)
#endif /* ZEND_TYPES_H */
ZEND_API void _zval_dtor_func(zend_refcounted *p ZEND_FILE_LINE_DC)
{
-//??? switch (Z_TYPE_P(zvalue) & IS_CONSTANT_TYPE_MASK) {
switch (GC_TYPE(p)) {
case IS_STRING:
case IS_CONSTANT: {
zend_string *str = (zend_string*)p;
//??? CHECK_ZVAL_STRING_REL(zvalue);
STR_RELEASE(str);
- goto exit;
+ break;
}
case IS_ARRAY:
case IS_CONSTANT_ARRAY: {
/* break possible cycles */
GC_TYPE(arr) = IS_NULL;
zend_hash_destroy(&arr->ht);
- goto gc_exit;
+ GC_REMOVE_FROM_BUFFER(arr);
+ efree(arr);
}
- goto exit;
+ break;
}
case IS_CONSTANT_AST: {
zend_ast_ref *ast =(zend_ast_ref*)p;
zend_ast_destroy(ast->ast);
efree(ast);
- goto exit;
+ break;
}
case IS_OBJECT: {
zend_object *obj = (zend_object*)p;
TSRMLS_FETCH();
OBJ_RELEASE(obj);
- goto exit;
+ break;
}
case IS_RESOURCE: {
zend_resource *res = (zend_resource*)p;
/* destroy resource */
zend_list_delete(res);
}
- goto exit;
+ break;
}
case IS_REFERENCE: {
zend_reference *ref = (zend_reference*)p;
if (--GC_REFCOUNT(ref) == 0) {
zval_ptr_dtor(&ref->val);
- goto gc_exit;
+ efree(ref);
}
- goto exit;
+ break;
}
default:
- goto exit;
+ break;
}
-gc_exit:
- GC_REMOVE_FROM_BUFFER(p);
- efree(p);
-exit:
- return;
}
ZEND_API void _zval_dtor_func_for_ptr(zend_refcounted *p ZEND_FILE_LINE_DC)
{
-//??? switch (Z_TYPE_P(zvalue) & IS_CONSTANT_TYPE_MASK) {
switch (GC_TYPE(p)) {
case IS_STRING:
case IS_CONSTANT: {
zend_string *str = (zend_string*)p;
//??? CHECK_ZVAL_STRING_REL(zvalue);
STR_FREE(str);
- goto exit;
+ break;
}
case IS_ARRAY:
case IS_CONSTANT_ARRAY: {
/* break possible cycles */
GC_TYPE(arr) = IS_NULL;
zend_hash_destroy(&arr->ht);
- goto gc_exit;
+ GC_REMOVE_FROM_BUFFER(arr);
+ efree(arr);
}
- goto exit;
+ break;
}
case IS_CONSTANT_AST: {
zend_ast_ref *ast =(zend_ast_ref*)p;
zend_ast_destroy(ast->ast);
efree(ast);
- goto exit;
+ break;
}
case IS_OBJECT: {
zend_object *obj = (zend_object*)p;
TSRMLS_FETCH();
zend_objects_store_del(obj TSRMLS_CC);
- goto exit;
+ break;
}
case IS_RESOURCE: {
zend_resource *res = (zend_resource*)p;
/* destroy resource */
zend_list_delete(res);
- goto exit;
+ break;
}
case IS_REFERENCE: {
zend_reference *ref = (zend_reference*)p;
zval_ptr_dtor(&ref->val);
- goto gc_exit;
+ efree(ref);
+ break;
}
default:
- goto exit;
+ break;
}
-gc_exit:
- GC_REMOVE_FROM_BUFFER(p);
- efree(p);
-exit:
- return;
}
ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC)
{
- switch (Z_TYPE_P(zvalue) & IS_CONSTANT_TYPE_MASK) {
+ switch (Z_TYPE_P(zvalue)) {
case IS_STRING:
case IS_CONSTANT:
CHECK_ZVAL_STRING_REL(zvalue);
ZEND_API void _zval_internal_dtor_for_ptr(zval *zvalue ZEND_FILE_LINE_DC)
{
- switch (Z_TYPE_P(zvalue) & IS_CONSTANT_TYPE_MASK) {
+ switch (Z_TYPE_P(zvalue)) {
case IS_STRING:
case IS_CONSTANT:
CHECK_ZVAL_STRING_REL(zvalue);
ZEND_API void _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC)
{
- switch (Z_TYPE_P(zvalue) & IS_CONSTANT_TYPE_MASK) {
+ switch (Z_TYPE_P(zvalue)) {
case IS_CONSTANT:
case IS_STRING:
CHECK_ZVAL_STRING_REL(zvalue);
zend_bool is_ref;
zval tmp;
- if (Z_TYPE_P(p) & (IS_LEXICAL_VAR|IS_LEXICAL_REF)) {
- is_ref = Z_TYPE_P(p) & IS_LEXICAL_REF;
+ if (Z_CONST_FLAGS_P(p) & (IS_LEXICAL_VAR|IS_LEXICAL_REF)) {
+ is_ref = Z_CONST_FLAGS_P(p) & IS_LEXICAL_REF;
if (!EG(active_symbol_table)) {
zend_rebuild_symbol_table(TSRMLS_C);
ZEND_API void _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC);
+#define zval_copy_ctor_func(zv) _zval_copy_ctor_func(zv ZEND_FILE_LINE_CC)
+
static zend_always_inline void _zval_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
{
- if (!Z_REFCOUNTED_P(zvalue)) {
- return;
+ if (Z_REFCOUNTED_P(zvalue)) {
+ if (Z_TYPE_FLAGS_P(zvalue) & IS_TYPE_COPYABLE) {
+ _zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
+ } else {
+ Z_ADDREF_P(zvalue);
+ }
}
- _zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
}
ZEND_API int zval_copy_static_var(zval *p TSRMLS_DC, int num_args, va_list args, zend_hash_key *key);
value_ptr &&
!Z_ISREF_P(value_ptr) &&
opline->extended_value == ZEND_RETURNS_FUNCTION &&
- !(Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF)) {
+ !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)) {
if (!OP2_FREE) {
PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */
}
ZVAL_NULL(ret);
//??? ret->var.ptr_ptr = &ret->var.ptr;
- Z_FLAGS_P(ret) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
+ Z_VAR_FLAGS_P(ret) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
if (!zend_execute_internal) {
/* saves one function call if zend_execute_internal is not used */
ZVAL_NULL(return_value);
//??? ret->var.ptr_ptr = &ret->var.ptr;
- Z_FLAGS_P(return_value) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
+ Z_VAR_FLAGS_P(return_value) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
}
if (UNEXPECTED((EG(active_op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
} else {
//??? Z_UNSET_ISREF_P(EX_T(opline->result.var).var.ptr);
//??? Z_SET_REFCOUNT_P(EX_T(opline->result.var).var.ptr, 1);
- Z_FLAGS_P(EX_VAR(opline->result.var)) = 0;
+ Z_VAR_FLAGS_P(EX_VAR(opline->result.var)) = 0;
//??? EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
}
}
if (OP1_TYPE == IS_UNUSED) {
/* Initialize for erealloc in add_char_to_string */
- ZVAL_STR(str, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(str);
}
add_char_to_string(str, str, opline->op2.zv);
if (OP1_TYPE == IS_UNUSED) {
/* Initialize for erealloc in add_string_to_string */
- ZVAL_STR(str, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(str);
}
add_string_to_string(str, str, opline->op2.zv);
if (OP1_TYPE == IS_UNUSED) {
/* Initialize for erealloc in add_string_to_string */
- ZVAL_STR(str, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(str);
}
if (Z_TYPE_P(var) != IS_STRING) {
if (OP1_TYPE == IS_VAR && !Z_ISREF_P(retval_ptr)) {
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
- (Z_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
+ (Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
//??? } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
} else {
zend_error(E_NOTICE, "Only variable references should be returned by reference");
varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
- (Z_FLAGS_P(varptr) & IS_VAR_RET_REF)) &&
+ (Z_VAR_FLAGS_P(varptr) & IS_VAR_RET_REF)) &&
((!Z_REFCOUNTED_P(varptr) && Z_TYPE_P(varptr) != IS_STRING) ||
Z_ISREF_P(varptr) ||
Z_TYPE_P(varptr) == IS_OBJECT ||
var_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
zval_ptr_dtor(var_ptr);
if (param == NULL) {
- if (IS_CONSTANT_TYPE(Z_TYPE_P(opline->op2.zv))) {
+ if (Z_TYPE_FLAGS_P(opline->op2.zv) & IS_TYPE_CONSTANT) {
zval tmp;
ZVAL_COPY_VALUE(&tmp, opline->op2.zv);
}
if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) {
- if (IS_CONSTANT_TYPE(Z_TYPE_P(value))) {
+ if (Z_TYPE_FLAGS_P(value) & IS_TYPE_CONSTANT) {
zend_class_entry *old_scope = EG(scope);
EG(scope) = ce;
name = GET_OP1_ZVAL_PTR(BP_VAR_R);
val = GET_OP2_ZVAL_PTR(BP_VAR_R);
- if (IS_CONSTANT_TYPE(Z_TYPE_P(val))) {
+ if (Z_TYPE_FLAGS_P(val) & IS_TYPE_CONSTANT) {
ZVAL_COPY_VALUE(&c.value, val);
if (Z_TYPE_P(val) == IS_CONSTANT_ARRAY) {
zval_copy_ctor(&c.value);
* not return by reference we throw a notice. */
if (OP1_TYPE == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
ZVAL_NULL(ret);
//??? ret->var.ptr_ptr = &ret->var.ptr;
- Z_FLAGS_P(ret) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
+ Z_VAR_FLAGS_P(ret) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
if (!zend_execute_internal) {
/* saves one function call if zend_execute_internal is not used */
ZVAL_NULL(return_value);
//??? ret->var.ptr_ptr = &ret->var.ptr;
- Z_FLAGS_P(return_value) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
+ Z_VAR_FLAGS_P(return_value) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
}
if (UNEXPECTED((EG(active_op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
} else {
//??? Z_UNSET_ISREF_P(EX_T(opline->result.var).var.ptr);
//??? Z_SET_REFCOUNT_P(EX_T(opline->result.var).var.ptr, 1);
- Z_FLAGS_P(EX_VAR(opline->result.var)) = 0;
+ Z_VAR_FLAGS_P(EX_VAR(opline->result.var)) = 0;
//??? EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
}
}
var_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
zval_ptr_dtor(var_ptr);
if (param == NULL) {
- if (IS_CONSTANT_TYPE(Z_TYPE_P(opline->op2.zv))) {
+ if (Z_TYPE_FLAGS_P(opline->op2.zv) & IS_TYPE_CONSTANT) {
zval tmp;
ZVAL_COPY_VALUE(&tmp, opline->op2.zv);
if (IS_CONST == IS_VAR && !Z_ISREF_P(retval_ptr)) {
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
- (Z_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
+ (Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
//??? } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
} else {
zend_error(E_NOTICE, "Only variable references should be returned by reference");
}
if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) {
- if (IS_CONSTANT_TYPE(Z_TYPE_P(value))) {
+ if (Z_TYPE_FLAGS_P(value) & IS_TYPE_CONSTANT) {
zend_class_entry *old_scope = EG(scope);
EG(scope) = ce;
name = opline->op1.zv;
val = opline->op2.zv;
- if (IS_CONSTANT_TYPE(Z_TYPE_P(val))) {
+ if (Z_TYPE_FLAGS_P(val) & IS_TYPE_CONSTANT) {
ZVAL_COPY_VALUE(&c.value, val);
if (Z_TYPE_P(val) == IS_CONSTANT_ARRAY) {
zval_copy_ctor(&c.value);
* not return by reference we throw a notice. */
if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
* not return by reference we throw a notice. */
if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
* not return by reference we throw a notice. */
if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
* not return by reference we throw a notice. */
if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
* not return by reference we throw a notice. */
if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(retval_ptr)) {
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
- (Z_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
+ (Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
//??? } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
} else {
zend_error(E_NOTICE, "Only variable references should be returned by reference");
if (IS_TMP_VAR == IS_UNUSED) {
/* Initialize for erealloc in add_char_to_string */
- ZVAL_STR(str, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(str);
}
add_char_to_string(str, str, opline->op2.zv);
if (IS_TMP_VAR == IS_UNUSED) {
/* Initialize for erealloc in add_string_to_string */
- ZVAL_STR(str, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(str);
}
add_string_to_string(str, str, opline->op2.zv);
* not return by reference we throw a notice. */
if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
if (IS_TMP_VAR == IS_UNUSED) {
/* Initialize for erealloc in add_string_to_string */
- ZVAL_STR(str, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(str);
}
if (Z_TYPE_P(var) != IS_STRING) {
* not return by reference we throw a notice. */
if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
if (IS_TMP_VAR == IS_UNUSED) {
/* Initialize for erealloc in add_string_to_string */
- ZVAL_STR(str, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(str);
}
if (Z_TYPE_P(var) != IS_STRING) {
* not return by reference we throw a notice. */
if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
* not return by reference we throw a notice. */
if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
if (IS_TMP_VAR == IS_UNUSED) {
/* Initialize for erealloc in add_string_to_string */
- ZVAL_STR(str, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(str);
}
if (Z_TYPE_P(var) != IS_STRING) {
* not return by reference we throw a notice. */
if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
if (IS_VAR == IS_VAR && !Z_ISREF_P(retval_ptr)) {
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
- (Z_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
+ (Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
//??? } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
} else {
zend_error(E_NOTICE, "Only variable references should be returned by reference");
varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
- (Z_FLAGS_P(varptr) & IS_VAR_RET_REF)) &&
+ (Z_VAR_FLAGS_P(varptr) & IS_VAR_RET_REF)) &&
((!Z_REFCOUNTED_P(varptr) && Z_TYPE_P(varptr) != IS_STRING) ||
Z_ISREF_P(varptr) ||
Z_TYPE_P(varptr) == IS_OBJECT ||
}
if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) {
- if (IS_CONSTANT_TYPE(Z_TYPE_P(value))) {
+ if (Z_TYPE_FLAGS_P(value) & IS_TYPE_CONSTANT) {
zend_class_entry *old_scope = EG(scope);
EG(scope) = ce;
* not return by reference we throw a notice. */
if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
* not return by reference we throw a notice. */
if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
value_ptr &&
!Z_ISREF_P(value_ptr) &&
opline->extended_value == ZEND_RETURNS_FUNCTION &&
- !(Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF)) {
+ !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)) {
if (!(free_op2.var != NULL)) {
PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */
}
* not return by reference we throw a notice. */
if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
* not return by reference we throw a notice. */
if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
value_ptr &&
!Z_ISREF_P(value_ptr) &&
opline->extended_value == ZEND_RETURNS_FUNCTION &&
- !(Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF)) {
+ !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)) {
if (!0) {
PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */
}
* not return by reference we throw a notice. */
if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
if (IS_UNUSED == IS_UNUSED) {
/* Initialize for erealloc in add_char_to_string */
- ZVAL_STR(str, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(str);
}
add_char_to_string(str, str, opline->op2.zv);
if (IS_UNUSED == IS_UNUSED) {
/* Initialize for erealloc in add_string_to_string */
- ZVAL_STR(str, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(str);
}
add_string_to_string(str, str, opline->op2.zv);
}
if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) {
- if (IS_CONSTANT_TYPE(Z_TYPE_P(value))) {
+ if (Z_TYPE_FLAGS_P(value) & IS_TYPE_CONSTANT) {
zend_class_entry *old_scope = EG(scope);
EG(scope) = ce;
* not return by reference we throw a notice. */
if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
if (IS_UNUSED == IS_UNUSED) {
/* Initialize for erealloc in add_string_to_string */
- ZVAL_STR(str, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(str);
}
if (Z_TYPE_P(var) != IS_STRING) {
* not return by reference we throw a notice. */
if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
if (IS_UNUSED == IS_UNUSED) {
/* Initialize for erealloc in add_string_to_string */
- ZVAL_STR(str, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(str);
}
if (Z_TYPE_P(var) != IS_STRING) {
* not return by reference we throw a notice. */
if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
* not return by reference we throw a notice. */
if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
if (IS_UNUSED == IS_UNUSED) {
/* Initialize for erealloc in add_string_to_string */
- ZVAL_STR(str, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(str);
}
if (Z_TYPE_P(var) != IS_STRING) {
* not return by reference we throw a notice. */
if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
if (IS_CV == IS_VAR && !Z_ISREF_P(retval_ptr)) {
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
- (Z_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
+ (Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
//??? } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
} else {
zend_error(E_NOTICE, "Only variable references should be returned by reference");
varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
- (Z_FLAGS_P(varptr) & IS_VAR_RET_REF)) &&
+ (Z_VAR_FLAGS_P(varptr) & IS_VAR_RET_REF)) &&
((!Z_REFCOUNTED_P(varptr) && Z_TYPE_P(varptr) != IS_STRING) ||
Z_ISREF_P(varptr) ||
Z_TYPE_P(varptr) == IS_OBJECT ||
* not return by reference we throw a notice. */
if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
* not return by reference we throw a notice. */
if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
value_ptr &&
!Z_ISREF_P(value_ptr) &&
opline->extended_value == ZEND_RETURNS_FUNCTION &&
- !(Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF)) {
+ !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)) {
if (!(free_op2.var != NULL)) {
PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */
}
* not return by reference we throw a notice. */
if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
* not return by reference we throw a notice. */
if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
value_ptr &&
!Z_ISREF_P(value_ptr) &&
opline->extended_value == ZEND_RETURNS_FUNCTION &&
- !(Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF)) {
+ !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)) {
if (!0) {
PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */
}
* not return by reference we throw a notice. */
if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr)
&& !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && (Z_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
+ && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))
//??? && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
/* Advanced Interface */
PHPAPI zval *php_date_instantiate(zend_class_entry *pce, zval *object TSRMLS_DC) /* {{{ */
{
- Z_TYPE_P(object) = IS_OBJECT;
object_init_ex(object, pce);
return object;
} /* }}} */
new_str = STR_ALLOC(str_len * 2, 0);
new_str->len = mysql_real_escape_string(mysql->conn, new_str->val, str, str_len);
- RETURN_STR(new_str);
+ RETURN_NEW_STR(new_str);
}
/* }}} */
} else {
Z_STR(ZEND_OP1_LITERAL(last_op)) = STR_REALLOC(Z_STR(ZEND_OP1_LITERAL(last_op)), l, 0);
}
+ Z_TYPE_INFO(ZEND_OP1_LITERAL(last_op)) = IS_STRING_EX;
memcpy(Z_STRVAL(ZEND_OP1_LITERAL(last_op)) + old_len, Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)));
Z_STRVAL(ZEND_OP1_LITERAL(last_op))[l] = '\0';
zval_dtor(&ZEND_OP1_LITERAL(opline));
#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
Z_STR(ZEND_OP1_LITERAL(opline)) = zend_new_interned_string(Z_STR(ZEND_OP1_LITERAL(last_op)) TSRMLS_CC);
- Z_TYPE(ZEND_OP1_LITERAL(last_op)) = IS_NULL;
+ if (IS_INTERNED(Z_STR(ZEND_OP1_LITERAL(opline)))) {
+ Z_TYPE_FLAGS(ZEND_OP1_LITERAL(opline)) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+ }
+ ZVAL_NULL(&ZEND_OP1_LITERAL(last_op));
#else
Z_STR(ZEND_OP1_LITERAL(opline)) = Z_STR(ZEND_OP1_LITERAL(last_op));
#endif
} else {
Z_STR(ZEND_OP2_LITERAL(src)) = STR_REALLOC(Z_STR(ZEND_OP2_LITERAL(src)), l, 0);
}
+ Z_TYPE_INFO(ZEND_OP2_LITERAL(last_op)) = IS_STRING_EX;
memcpy(Z_STRVAL(ZEND_OP2_LITERAL(src)) + old_len, Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)));
Z_STRVAL(ZEND_OP2_LITERAL(src))[l] = '\0';
STR_RELEASE(Z_STR(ZEND_OP2_LITERAL(opline)));
#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
Z_STR(ZEND_OP2_LITERAL(opline)) = zend_new_interned_string(Z_STR(ZEND_OP2_LITERAL(src)) TSRMLS_CC);
- Z_TYPE(ZEND_OP2_LITERAL(src)) = IS_NULL;
+ if (IS_INTERNED(Z_STR(ZEND_OP2_LITERAL(opline)))) {
+ Z_TYPE_FLAGS(ZEND_OP2_LITERAL(opline)) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+ }
+ ZVAL_NULL(&ZEND_OP2_LITERAL(src));
#else
Z_STR(ZEND_OP2_LITERAL(opline)) = Z_STR(ZEND_OP2_LITERAL(src));
#endif
/* BOOL */
result = ZEND_OP1_LITERAL(opline);
convert_to_boolean(&result);
- Z_TYPE(ZEND_OP1_LITERAL(opline)) = IS_NULL;
+ ZVAL_NULL(&ZEND_OP1_LITERAL(opline));
}
//??? PZ_SET_REFCOUNT_P(&result, 1);
//??? PZ_UNSET_ISREF_P(&result);
*/
#if ZEND_EXTENSION_API_NO > PHP_5_2_X_API_NO
-# define ZEND_IS_CONSTANT_TYPE(t) (((t) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT)
+# define ZEND_IS_CONSTANT_TYPE(t) ((t) == IS_CONSTANT)
#else
# define ZEND_IS_CONSTANT_TYPE(t) ((t) == IS_CONSTANT)
#endif
if (requires_conversion) { /* ZEND_ADD_CHAR */
char chval = (char)Z_LVAL(ZEND_OP2_LITERAL(opline));
- ZVAL_STR(&ZEND_OP2_LITERAL(opline), str);
+ ZVAL_NEW_STR(&ZEND_OP2_LITERAL(opline), str);
ptr[0] = chval;
opline->opcode = ZEND_ADD_STRING;
ptr++;
# define literal_dtor(zv) do { \
zval_dtor(zv); \
- Z_TYPE_P(zv) = IS_NULL; \
+ ZVAL_NULL(zv); \
} while (0)
#define COPY_NODE(target, src) do { \
ZCSG(interned_strings_top) += ZEND_MM_ALIGNED_SIZE(sizeof(zend_string) + str->len);
p->h = h;
GC_REFCOUNT(p->key) = 1;
-// TODO: use one assignment ???
+#if 1
+ /* optimized single assignment */
+ GC_TYPE_INFO(p->key) = IS_STRING | ((IS_STR_INTERNED | IS_STR_PERMANENT) << 8);
+#else
GC_TYPE(p->key) = IS_STRING;
GC_FLAGS(p->key) = IS_STR_INTERNED | IS_STR_PERMANENT;
+#endif
p->key->h = str->h;
p->key->len = str->len;
memcpy(p->key->val, str->val, str->len);
{
if (Z_REFCOUNTED_P(zvalue) && Z_DELREF_P(zvalue) == 0) {
#if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
- switch (Z_TYPE_P(zvalue) & IS_CONSTANT_TYPE_MASK) {
+ switch (Z_TYPE_P(zvalue)) {
#else
- switch (Z_TYPE_P(zvalue) & ~IS_CONSTANT_INDEX) {
+ switch (Z_TYPE_P(zvalue)) {
#endif
case IS_ARRAY:
case IS_CONSTANT_ARRAY: {
#endif
if (Z_ARR_P(zvalue) != &EG(symbol_table)) {
/* break possible cycles */
- Z_TYPE_P(zvalue) = IS_NULL;
+ ZVAL_NULL(zvalue);
Z_ARRVAL_P(zvalue)->pDestructor = accel_fast_zval_dtor;
accel_fast_hash_destroy(Z_ARRVAL_P(zvalue));
}
void *ptr;
#if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
- switch ((Z_TYPE_P(src) & IS_CONSTANT_TYPE_MASK)) {
+ switch (Z_TYPE_P(src)) {
#else
- switch ((Z_TYPE_P(src) & ~IS_CONSTANT_INDEX)) {
+ switch (Z_TYPE_P(src)) {
#endif
case IS_STRING:
case IS_CONSTANT:
void *new_ptr;
#if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
- switch (Z_TYPE_P(z) & IS_CONSTANT_TYPE_MASK) {
+ switch (Z_TYPE_P(z)) {
#else
- switch (Z_TYPE_P(z) & ~IS_CONSTANT_INDEX) {
+ switch (Z_TYPE_P(z)) {
#endif
case IS_STRING:
case IS_CONSTANT:
START_SIZE();
#if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
- switch (Z_TYPE_P(z) & IS_CONSTANT_TYPE_MASK) {
+ switch (Z_TYPE_P(z)) {
#else
- switch (Z_TYPE_P(z) & ~IS_CONSTANT_INDEX) {
+ switch (Z_TYPE_P(z)) {
#endif
case IS_STRING:
case IS_CONSTANT:
flags = Z_GC_FLAGS_P(z) & ~ (IS_STR_PERSISTENT | IS_STR_INTERNED | IS_STR_PERMANENT);
ADD_INTERNED_STRING(Z_STR_P(z), 0);
+ if (IS_INTERNED(Z_STR_P(z))) {
+ Z_TYPE_FLAGS_P(z) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+ }
Z_GC_FLAGS_P(z) |= flags;
break;
case IS_ARRAY:
ZVAL_COPY_VALUE(return_value, precv->op2.zv);
//??? INIT_PZVAL(return_value);
- if (!IS_CONSTANT_TYPE(Z_TYPE_P(return_value))) {
+ if (!(Z_TYPE_FLAGS_P(return_value) & IS_TYPE_CONSTANT)) {
zval_copy_ctor(return_value);
}
zval_update_constant_ex(return_value, (void*)0, param->fptr->common.scope TSRMLS_CC);
}
precv = _reflection_param_get_default_precv(INTERNAL_FUNCTION_PARAM_PASSTHRU, param);
- if (precv && (Z_TYPE_P(precv->op2.zv) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
+ if (precv && Z_TYPE_P(precv->op2.zv) == IS_CONSTANT) {
RETURN_TRUE;
}
}
precv = _reflection_param_get_default_precv(INTERNAL_FUNCTION_PARAM_PASSTHRU, param);
- if (precv && (Z_TYPE_P(precv->op2.zv) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
+ if (precv && Z_TYPE_P(precv->op2.zv) == IS_CONSTANT) {
RETURN_STR(STR_COPY(Z_STR_P(precv->op2.zv)));
}
}
/* this is necessary to make it able to work with default array
* properties, returned to user */
- if (IS_CONSTANT_TYPE(Z_TYPE(prop_copy))) {
+ if (Z_TYPE_FLAGS(prop_copy) & IS_TYPE_CONSTANT) {
zval_update_constant(&prop_copy, (void *) 1 TSRMLS_CC);
}
zend_update_class_constants(ce TSRMLS_CC);
intern = spl_filesystem_from_obj(spl_filesystem_object_new_ex(ce TSRMLS_CC));
- return_value->value.obj = &intern->std;
- Z_TYPE_P(return_value) = IS_OBJECT;
+ ZVAL_OBJ(return_value, &intern->std);
if (ce->constructor->common.scope != spl_ce_SplFileInfo) {
ZVAL_STRINGL(&arg1, file_path, file_path_len);
zend_update_class_constants(ce TSRMLS_CC);
intern = spl_filesystem_from_obj(spl_filesystem_object_new_ex(ce TSRMLS_CC));
- return_value->value.obj = &intern->std;
- Z_TYPE_P(return_value) = IS_OBJECT;
+ ZVAL_OBJ(return_value, &intern->std);
spl_filesystem_object_get_file_name(source TSRMLS_CC);
if (ce->constructor->common.scope != spl_ce_SplFileInfo) {
intern = spl_filesystem_from_obj(spl_filesystem_object_new_ex(ce TSRMLS_CC));
- return_value->value.obj = &intern->std;
- Z_TYPE_P(return_value) = IS_OBJECT;
+ ZVAL_OBJ(return_value, &intern->std);
spl_filesystem_object_get_file_name(source TSRMLS_CC);
if (intern->u.dir.sub_path) {
ZVAL_STRINGL(&tmp, intern->u.dir.sub_path, intern->u.dir.sub_path_len);
} else {
- ZVAL_STR(&tmp, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(&tmp);
}
zend_symtable_update(rv, pnstr, &tmp);
STR_RELEASE(pnstr);
if (intern->u.dir.sub_path) {
RETURN_STRINGL(intern->u.dir.sub_path, intern->u.dir.sub_path_len);
} else {
- RETURN_STR(STR_EMPTY_ALLOC());
+ RETURN_EMPTY_STRING();
}
}
/* }}} */
}
object_init_ex(return_value, spl_ce_SplFixedArray);
- Z_TYPE_P(return_value) = IS_OBJECT;
intern = Z_SPLFIXEDARRAY_P(return_value);
intern->array = array;
zval_ptr_dtor(&entry);
zval_ptr_dtor(&postfix);
- RETURN_STR(str);
+ RETURN_NEW_STR(str);
} /* }}} */
/* {{{ proto mixed RecursiveTreeIterator::key()
zval_ptr_dtor(&key);
zval_ptr_dtor(&postfix);
- RETURN_STR(str);
+ RETURN_NEW_STR(str);
} /* }}} */
ZEND_BEGIN_ARG_INFO_EX(arginfo_recursive_tree_it___construct, 0, 0, 1)
PHPAPI int php_prefix_varname(zval *result, zval *prefix, char *var_name, int var_name_len, zend_bool add_underscore TSRMLS_DC) /* {{{ */
{
- ZVAL_STR(result, STR_ALLOC(Z_STRLEN_P(prefix) + (add_underscore ? 1 : 0) + var_name_len, 0));
+ ZVAL_NEW_STR(result, STR_ALLOC(Z_STRLEN_P(prefix) + (add_underscore ? 1 : 0) + var_name_len, 0));
memcpy(Z_STRVAL_P(result), Z_STRVAL_P(prefix), Z_STRLEN_P(prefix));
if (add_underscore) {
(Z_STRLEN_P(arg2) == 3 && !strncasecmp(Z_STRVAL_P(arg2), "yes", sizeof("yes") - 1)) ||
(Z_STRLEN_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "true", sizeof("true") - 1))
) {
- ZVAL_STR(&new_property, STR_INIT("1", sizeof("1")-1, persistent));
+ ZVAL_NEW_STR(&new_property, STR_INIT("1", sizeof("1")-1, persistent));
} else if (
(Z_STRLEN_P(arg2) == 2 && !strncasecmp(Z_STRVAL_P(arg2), "no", sizeof("no") - 1)) ||
(Z_STRLEN_P(arg2) == 3 && !strncasecmp(Z_STRVAL_P(arg2), "off", sizeof("off") - 1)) ||
(Z_STRLEN_P(arg2) == 5 && !strncasecmp(Z_STRVAL_P(arg2), "false", sizeof("false") - 1))
) {
// TODO: USE STR_EMPTY_ALLOC()?
- ZVAL_STR(&new_property, STR_INIT("", sizeof("")-1, persistent));
+ ZVAL_NEW_STR(&new_property, STR_INIT("", sizeof("")-1, persistent));
} else { /* Other than true/false setting */
ZVAL_STR(&new_property, STR_DUP(Z_STR_P(arg2), persistent));
}
str = STR_INIT(input, input_len, 0);
php_convert_cyr_string(str->val, str->len, fr_cs[0], to_cs[0] TSRMLS_CC);
- RETVAL_STR(str);
+ RETVAL_NEW_STR(str);
}
/* }}} */
if ((contents = php_stream_copy_to_mem(stream, maxlen, 0)) != NULL) {
RETVAL_STR(contents);
} else {
- RETVAL_STR(STR_EMPTY_ALLOC());
+ RETVAL_EMPTY_STRING();
}
php_stream_close(stream);
RETURN_FALSE;
}
- ZVAL_STR(return_value, STR_ALLOC(len, 0));
+ ZVAL_NEW_STR(return_value, STR_ALLOC(len, 0));
Z_STRLEN_P(return_value) = php_stream_read(stream, Z_STRVAL_P(return_value), len);
/* needed because recv/read/gzread doesnt put a null at the end*/
str_out->val[j] = '\0';
str_out->len = j;
- RETVAL_STR(str_out);
+ RETVAL_NEW_STR(str_out);
}
/* }}} */
static inline void scan_set_error_return(int numVars, zval *return_value) /* {{{ */
{
if (numVars) {
- Z_TYPE_P(return_value) = IS_LONG;
- Z_LVAL_P(return_value) = SCAN_ERROR_EOF; /* EOF marker */
+ ZVAL_LONG(return_value, SCAN_ERROR_EOF); /* EOF marker */
} else {
/* convert_to_null calls destructor */
convert_to_null(return_value);
}
read_buf->val[recvd] = '\0';
read_buf->len = recvd;
- RETURN_STR(read_buf);
+ RETURN_NEW_STR(read_buf);
}
STR_FREE(read_buf);
}
}
- RETURN_STR(newtext);
+ RETURN_NEW_STR(newtext);
} else {
/* Multiple character line break or forced cut */
if (linelength > 0) {
/* free unused memory */
newtext = STR_REALLOC(newtext, newtextlen, 0);
- RETURN_STR(newtext);
+ RETURN_NEW_STR(newtext);
}
}
/* }}} */
return;
}
- ZVAL_STR(&tmp, STR_EMPTY_ALLOC());
+ ZVAL_EMPTY_STRING(&tmp);
delim = &tmp;
SEPARATE_ZVAL(arg1);
result = STR_INIT(arg, arglen, 0);
php_strtoupper(result->val, result->len);
- RETURN_STR(result);
+ RETURN_NEW_STR(result);
}
/* }}} */
result = STR_INIT(str, arglen, 0);
php_strtolower(result->val, result->len);
- RETURN_STR(result);
+ RETURN_NEW_STR(result);
}
/* }}} */
ret = STR_INIT(str, str_len, 0);
ret->len = zend_dirname(ret->val, str_len);
- RETURN_STR(ret);
+ RETURN_NEW_STR(ret);
}
/* }}} */
memcpy(result->val, str, str_len);
memcpy(result->val + str_len, end, endlen);
result->val[result->len] = '\0';
- RETURN_STR(result);
+ RETURN_NEW_STR(result);
}
if (!str_len) {
}
memcpy((result->val + f + repl_len), Z_STRVAL_P(str) + f + l, Z_STRLEN_P(str) - f - l);
result->val[result->len] = '\0';
- RETURN_STR(result);
+ RETURN_NEW_STR(result);
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Functionality of 'from' and 'len' as arrays is not implemented");
RETURN_STR(STR_COPY(Z_STR_P(str)));
*q = '\0';
- RETURN_STR(STR_REALLOC(str, q - str->val, 0));
+ RETURN_NEW_STR(STR_REALLOC(str, q - str->val, 0));
}
/* }}} */
*p = '\0';
- RETVAL_STR(n);
+ RETVAL_NEW_STR(n);
}
/* }}} */
return 0;
}
- ZVAL_STR(result, STR_ALLOC(len + (char_count * (to_len - 1)), 0));
+ ZVAL_NEW_STR(result, STR_ALLOC(len + (char_count * (to_len - 1)), 0));
target = Z_STRVAL_P(result); //??? = target = safe_emalloc(char_count, to_len, len + 1);
if (case_sensitivity) {
ZVAL_EMPTY_STRING(result);
return;
}
- Z_TYPE_P(result) = IS_STRING;
+//??? Z_TYPE_P(result) = IS_STRING;
/* If search is an array */
if (Z_TYPE_P(search) == IS_ARRAY) {
STR_FREE(Z_STR_P(result));
Z_STR_P(result) = Z_STR(temp_result);
+ Z_TYPE_INFO_P(result) = Z_TYPE_INFO(temp_result);
if (Z_STRLEN_P(result) == 0) {
zval_ptr_dtor(&tmp_subject);
php_char_to_str(broken_str->val, broken_str->len,'\n', "<br />\n", 7, return_value);
STR_FREE(broken_str);
} else {
- RETURN_STR(broken_str);
+ RETURN_NEW_STR(broken_str);
}
}
/* }}} */
*target = '\0';
- RETURN_STR(result);
+ RETURN_NEW_STR(result);
}
/* }}} */
result->val[result_len] = '\0';
- RETURN_STR(result);
+ RETURN_NEW_STR(result);
}
/* }}} */
result->val[result->len] = '\0';
- RETURN_STR(result);
+ RETURN_NEW_STR(result);
}
/* }}} */
}
str->val[str->len] = '\0';
- RETURN_STR(STR_REALLOC(str, str->len, 0));
+ RETURN_NEW_STR(STR_REALLOC(str, str->len, 0));
}
/* }}} */
#endif
out_str = STR_INIT(in_str->val, in_str->len, 0);
out_str->len = php_url_decode(out_str->val, out_str->len);
- RETURN_STR(out_str);
+ RETURN_NEW_STR(out_str);
}
/* }}} */
out_str = STR_INIT(in_str->val, in_str->len, 0);
out_str->len = php_raw_url_decode(out_str->val, out_str->len);
- RETURN_STR(out_str);
+ RETURN_NEW_STR(out_str);
}
/* }}} */
{
zval tmp;
- ZVAL_STR(&tmp, STR_INIT(fh.filename, strlen(fh.filename), 1));
+ ZVAL_NEW_STR(&tmp, STR_INIT(fh.filename, strlen(fh.filename), 1));
zend_hash_str_update(&configuration_hash, "cfg_file_path", sizeof("cfg_file_path")-1, &tmp);
if (php_ini_opened_path) {
efree(php_ini_opened_path);
assert(strval != NULL);
/* Prepare value */
- ZVAL_STR(&new_entry, STR_INIT(strval, str_len, 0));
+ ZVAL_NEW_STR(&new_entry, STR_INIT(strval, str_len, 0));
php_register_variable_ex(var, &new_entry, track_vars_array TSRMLS_CC);
}
/* store request init time */
{
zval request_time_float, request_time_long;
- Z_TYPE(request_time_float) = IS_DOUBLE;
- Z_DVAL(request_time_float) = sapi_get_request_time(TSRMLS_C);
+ ZVAL_DOUBLE(&request_time_float, sapi_get_request_time(TSRMLS_C));
php_register_variable_ex("REQUEST_TIME_FLOAT", &request_time_float, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
- Z_TYPE(request_time_long) = IS_LONG;
- Z_LVAL(request_time_long) = zend_dval_to_lval(Z_DVAL(request_time_float));
+ ZVAL_LONG(&request_time_long, zend_dval_to_lval(Z_DVAL(request_time_float)));
php_register_variable_ex("REQUEST_TIME", &request_time_long, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
}
void fcgi_set_mgmt_var(const char * name, size_t name_len, const char * value, size_t value_len)
{
zval zvalue;
- ZVAL_STR(&zvalue, STR_INIT(value, value_len, 1));
+ ZVAL_NEW_STR(&zvalue, STR_INIT(value, value_len, 1));
zend_hash_str_add(&fcgi_mgmt_vars, name, name_len, &zvalue);
}
/* overwriteable ini defaults must be set in sapi_cli_ini_defaults() */
#define INI_DEFAULT(name,value)\
- ZVAL_STR(&tmp, STR_INIT(value, sizeof(value)-1, 1));\
+ ZVAL_NEW_STR(&tmp, STR_INIT(value, sizeof(value)-1, 1));\
zend_hash_str_update(configuration_hash, name, sizeof(name)-1, &tmp);\
static void sapi_cli_ini_defaults(HashTable *configuration_hash)
new_break.code_len = expr_len;
str = STR_ALLOC(expr_len + sizeof("return ;") - 1, 0);
- ZVAL_STR(&pv, str);
+ ZVAL_NEW_STR(&pv, str);
memcpy(Z_STRVAL(pv), "return ", sizeof("return ") - 1);
memcpy(Z_STRVAL(pv) + sizeof("return ") - 1, expr, expr_len);
Z_STRVAL(pv)[Z_STRLEN(pv) - 1] = ';';
projects / php / commitdiff