1999-04-07 18:10:10 +00:00
/*
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| Zend Engine |
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
2016-01-02 09:56:11 +00:00
| Copyright ( c ) 1998 - 2016 Zend Technologies Ltd . ( http : //www.zend.com) |
1999-04-07 18:10:10 +00:00
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
2001-12-11 15:16:21 +00:00
| This source file is subject to version 2.00 of the Zend license , |
2013-01-28 02:02:51 +00:00
| that is bundled with this package in the file LICENSE , and is |
2003-06-10 20:04:29 +00:00
| available through the world - wide - web at the following url : |
2001-12-11 15:16:21 +00:00
| http : //www.zend.com/license/2_00.txt. |
1999-07-16 14:58:16 +00:00
| If you did not receive a copy of the Zend license and are unable to |
| obtain it through the world - wide - web , please send a note to |
| license @ zend . com so we can mail you a copy immediately . |
1999-04-07 18:10:10 +00:00
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| Authors : Andi Gutmans < andi @ zend . com > |
| Zeev Suraski < zeev @ zend . com > |
2014-07-27 11:25:32 +00:00
| Nikita Popov < nikic @ php . net > |
1999-04-07 18:10:10 +00:00
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
*/
2003-02-01 01:49:15 +00:00
/* $Id$ */
1999-07-16 14:58:16 +00:00
2004-12-30 15:18:24 +00:00
# include <zend_language_parser.h>
1999-04-07 18:10:10 +00:00
# include "zend.h"
# include "zend_compile.h"
2003-04-10 17:02:31 +00:00
# include "zend_constants.h"
1999-04-07 18:10:10 +00:00
# include "zend_llist.h"
# include "zend_API.h"
2007-02-24 02:17:47 +00:00
# include "zend_exceptions.h"
2015-04-26 13:02:57 +00:00
# include "zend_interfaces.h"
2013-10-17 07:43:52 +00:00
# include "zend_virtual_cwd.h"
2008-06-29 08:21:35 +00:00
# include "zend_multibyte.h"
2015-05-26 02:36:52 +00:00
# include "zend_language_scanner.h"
2014-09-18 22:01:05 +00:00
# include "zend_inheritance.h"
2015-07-10 01:44:21 +00:00
# include "zend_vm.h"
2008-06-29 08:21:35 +00:00
2010-04-20 10:57:45 +00:00
# define SET_NODE(target, src) do { \
target # # _type = ( src ) - > op_type ; \
if ( ( src ) - > op_type = = IS_CONST ) { \
2014-12-13 22:06:14 +00:00
target . constant = zend_add_literal ( CG ( active_op_array ) , & ( src ) - > u . constant ) ; \
2010-04-20 10:57:45 +00:00
} else { \
target = ( src ) - > u . op ; \
} \
} while ( 0 )
# define GET_NODE(target, src) do { \
( target ) - > op_type = src # # _type ; \
if ( ( target ) - > op_type = = IS_CONST ) { \
2014-12-12 07:19:41 +00:00
ZVAL_COPY_VALUE ( & ( target ) - > u . constant , CT_CONSTANT ( src ) ) ; \
2010-04-20 10:57:45 +00:00
} else { \
( target ) - > u . op = src ; \
} \
} while ( 0 )
2015-04-20 18:16:58 +00:00
# define FC(member) (CG(file_context).member)
2015-07-10 11:30:25 +00:00
typedef struct _zend_loop_var {
zend_uchar opcode ;
2015-08-04 04:37:06 +00:00
zend_uchar var_type ;
uint32_t var_num ;
union {
uint32_t try_catch_offset ;
uint32_t brk_cont_offset ;
} u ;
2015-07-10 11:30:25 +00:00
} zend_loop_var ;
2014-12-13 22:06:14 +00:00
static inline void zend_alloc_cache_slot ( uint32_t literal ) {
2014-08-15 15:10:06 +00:00
zend_op_array * op_array = CG ( active_op_array ) ;
2015-02-24 22:52:35 +00:00
Z_CACHE_SLOT ( op_array - > literals [ literal ] ) = op_array - > cache_size ;
op_array - > cache_size + = sizeof ( void * ) ;
2014-08-15 15:10:06 +00:00
}
2010-05-24 14:11:39 +00:00
# define POLYMORPHIC_CACHE_SLOT_SIZE 2
2014-12-13 22:06:14 +00:00
static inline void zend_alloc_polymorphic_cache_slot ( uint32_t literal ) {
2014-08-15 15:10:06 +00:00
zend_op_array * op_array = CG ( active_op_array ) ;
2015-02-24 22:52:35 +00:00
Z_CACHE_SLOT ( op_array - > literals [ literal ] ) = op_array - > cache_size ;
op_array - > cache_size + = POLYMORPHIC_CACHE_SLOT_SIZE * sizeof ( void * ) ;
2014-08-15 15:10:06 +00:00
}
2010-05-24 14:11:39 +00:00
2014-12-13 22:06:14 +00:00
ZEND_API zend_op_array * ( * zend_compile_file ) ( zend_file_handle * file_handle , int type ) ;
ZEND_API zend_op_array * ( * zend_compile_string ) ( zval * source_string , char * filename ) ;
1999-04-07 18:10:10 +00:00
# ifndef ZTS
ZEND_API zend_compiler_globals compiler_globals ;
ZEND_API zend_executor_globals executor_globals ;
# endif
2014-02-17 07:50:32 +00:00
static void zend_destroy_property_info_internal ( zval * zv ) /* { { { */
2003-08-23 19:37:39 +00:00
{
2014-02-17 07:50:32 +00:00
zend_property_info * property_info = Z_PTR_P ( zv ) ;
2014-08-25 17:24:55 +00:00
zend_string_release ( property_info - > name ) ;
2014-02-17 13:59:18 +00:00
free ( property_info ) ;
2003-08-23 19:37:39 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
2003-08-23 19:37:39 +00:00
2014-12-13 22:06:14 +00:00
static zend_string * zend_new_interned_string_safe ( zend_string * str ) /* { { { */ {
2014-07-24 19:35:57 +00:00
zend_string * interned_str ;
2014-08-25 19:21:16 +00:00
zend_string_addref ( str ) ;
2014-12-13 22:06:14 +00:00
interned_str = zend_new_interned_string ( str ) ;
2014-07-24 19:35:57 +00:00
if ( str ! = interned_str ) {
return interned_str ;
} else {
2014-08-25 19:21:16 +00:00
zend_string_release ( str ) ;
2014-07-24 19:35:57 +00:00
return str ;
}
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-24 19:35:57 +00:00
2014-12-13 22:06:14 +00:00
static zend_string * zend_build_runtime_definition_key ( zend_string * name , unsigned char * lex_pos ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-29 18:01:11 +00:00
zend_string * result ;
2004-01-11 19:27:13 +00:00
char char_pos_buf [ 32 ] ;
2015-05-24 19:50:46 +00:00
size_t char_pos_len = zend_sprintf ( char_pos_buf , " %p " , lex_pos ) ;
zend_string * filename = CG ( active_op_array ) - > filename ;
1999-09-02 21:06:05 +00:00
2004-01-11 19:27:13 +00:00
/* NULL, name length, filename length, last accepting char position length */
2015-06-30 10:59:27 +00:00
result = zend_string_alloc ( 1 + ZSTR_LEN ( name ) + ZSTR_LEN ( filename ) + char_pos_len , 0 ) ;
sprintf ( ZSTR_VAL ( result ) , " %c%s%s%s " , ' \0 ' , ZSTR_VAL ( name ) , ZSTR_VAL ( filename ) , char_pos_buf ) ;
2014-12-13 22:06:14 +00:00
return zend_new_interned_string ( result ) ;
1999-09-02 21:06:05 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-09-02 21:06:05 +00:00
2014-09-28 21:17:29 +00:00
static zend_bool zend_get_unqualified_name ( const zend_string * name , const char * * result , size_t * result_len ) /* { { { */
{
2015-06-30 10:59:27 +00:00
const char * ns_separator = zend_memrchr ( ZSTR_VAL ( name ) , ' \\ ' , ZSTR_LEN ( name ) ) ;
2014-09-28 21:17:29 +00:00
if ( ns_separator ! = NULL ) {
* result = ns_separator + 1 ;
2015-06-30 10:59:27 +00:00
* result_len = ZSTR_VAL ( name ) + ZSTR_LEN ( name ) - * result ;
2014-09-28 21:17:29 +00:00
return 1 ;
}
return 0 ;
}
/* }}} */
2015-03-30 20:05:26 +00:00
struct reserved_class_name {
const char * name ;
size_t len ;
} ;
static const struct reserved_class_name reserved_class_names [ ] = {
{ ZEND_STRL ( " bool " ) } ,
{ ZEND_STRL ( " false " ) } ,
{ ZEND_STRL ( " float " ) } ,
{ ZEND_STRL ( " int " ) } ,
{ ZEND_STRL ( " null " ) } ,
{ ZEND_STRL ( " parent " ) } ,
{ ZEND_STRL ( " self " ) } ,
{ ZEND_STRL ( " static " ) } ,
{ ZEND_STRL ( " string " ) } ,
{ ZEND_STRL ( " true " ) } ,
{ NULL , 0 }
} ;
static zend_bool zend_is_reserved_class_name ( const zend_string * name ) /* { { { */
{
const struct reserved_class_name * reserved = reserved_class_names ;
2015-06-30 10:59:27 +00:00
const char * uqname = ZSTR_VAL ( name ) ;
size_t uqname_len = ZSTR_LEN ( name ) ;
2015-03-30 20:05:26 +00:00
zend_get_unqualified_name ( name , & uqname , & uqname_len ) ;
for ( ; reserved - > name ; + + reserved ) {
if ( uqname_len = = reserved - > len
& & zend_binary_strcasecmp ( uqname , uqname_len , reserved - > name , reserved - > len ) = = 0
) {
return 1 ;
}
}
return 0 ;
}
/* }}} */
ZEND_API void zend_assert_valid_class_name ( const zend_string * name ) /* { { { */
{
if ( zend_is_reserved_class_name ( name ) ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
2015-06-30 10:59:27 +00:00
" Cannot use '%s' as class name as it is reserved " , ZSTR_VAL ( name ) ) ;
2015-03-30 20:05:26 +00:00
}
}
/* }}} */
2015-05-21 01:39:31 +00:00
typedef struct _builtin_type_info {
2015-02-01 14:22:48 +00:00
const char * name ;
const size_t name_len ;
const zend_uchar type ;
2015-05-21 01:39:31 +00:00
} builtin_type_info ;
2015-02-01 14:22:48 +00:00
2015-05-21 01:39:31 +00:00
static const builtin_type_info builtin_types [ ] = {
2015-11-09 11:15:58 +00:00
{ ZEND_STRL ( " int " ) , IS_LONG } ,
{ ZEND_STRL ( " float " ) , IS_DOUBLE } ,
{ ZEND_STRL ( " string " ) , IS_STRING } ,
{ ZEND_STRL ( " bool " ) , _IS_BOOL } ,
2015-02-01 14:22:48 +00:00
{ NULL , 0 , IS_UNDEF }
} ;
2015-05-21 01:54:11 +00:00
static zend_always_inline zend_uchar zend_lookup_builtin_type_by_name ( const zend_string * name ) /* { { { */
2015-02-01 14:22:48 +00:00
{
2015-05-21 01:39:31 +00:00
const builtin_type_info * info = & builtin_types [ 0 ] ;
2015-03-19 18:07:03 +00:00
2015-03-30 20:05:26 +00:00
for ( ; info - > name ; + + info ) {
2015-06-30 10:59:27 +00:00
if ( ZSTR_LEN ( name ) = = info - > name_len
& & zend_binary_strcasecmp ( ZSTR_VAL ( name ) , ZSTR_LEN ( name ) , info - > name , info - > name_len ) = = 0
2015-03-30 20:05:26 +00:00
) {
2015-05-21 01:54:11 +00:00
return info - > type ;
2015-02-01 14:22:48 +00:00
}
}
2015-05-21 01:54:11 +00:00
return 0 ;
2015-02-01 14:22:48 +00:00
}
/* }}} */
2015-04-20 15:39:32 +00:00
void zend_oparray_context_begin ( zend_oparray_context * prev_context ) /* { { { */
2010-09-15 07:38:52 +00:00
{
2015-04-20 15:39:32 +00:00
* prev_context = CG ( context ) ;
2014-08-25 21:45:02 +00:00
CG ( context ) . opcodes_size = INITIAL_OP_ARRAY_SIZE ;
2010-09-15 07:38:52 +00:00
CG ( context ) . vars_size = 0 ;
CG ( context ) . literals_size = 0 ;
2015-07-10 00:31:52 +00:00
CG ( context ) . current_brk_cont = - 1 ;
2010-09-15 07:38:52 +00:00
CG ( context ) . backpatch_count = 0 ;
2012-12-12 22:48:51 +00:00
CG ( context ) . in_finally = 0 ;
2014-11-27 06:56:43 +00:00
CG ( context ) . fast_call_var = - 1 ;
2010-09-15 07:38:52 +00:00
CG ( context ) . labels = NULL ;
}
/* }}} */
2000-01-24 19:00:30 +00:00
2015-04-20 15:39:32 +00:00
void zend_oparray_context_end ( zend_oparray_context * prev_context ) /* { { { */
{
if ( CG ( context ) . labels ) {
zend_hash_destroy ( CG ( context ) . labels ) ;
FREE_HASHTABLE ( CG ( context ) . labels ) ;
CG ( context ) . labels = NULL ;
}
CG ( context ) = * prev_context ;
}
/* }}} */
static void zend_reset_import_tables ( void ) /* { { { */
{
2015-04-20 18:16:58 +00:00
if ( FC ( imports ) ) {
zend_hash_destroy ( FC ( imports ) ) ;
efree ( FC ( imports ) ) ;
FC ( imports ) = NULL ;
2015-04-20 15:39:32 +00:00
}
2015-04-20 18:16:58 +00:00
if ( FC ( imports_function ) ) {
zend_hash_destroy ( FC ( imports_function ) ) ;
efree ( FC ( imports_function ) ) ;
FC ( imports_function ) = NULL ;
2015-04-20 15:39:32 +00:00
}
2015-04-20 18:16:58 +00:00
if ( FC ( imports_const ) ) {
zend_hash_destroy ( FC ( imports_const ) ) ;
efree ( FC ( imports_const ) ) ;
FC ( imports_const ) = NULL ;
}
}
/* }}} */
static void zend_end_namespace ( void ) /* { { { */ {
FC ( in_namespace ) = 0 ;
zend_reset_import_tables ( ) ;
if ( FC ( current_namespace ) ) {
zend_string_release ( FC ( current_namespace ) ) ;
FC ( current_namespace ) = NULL ;
2015-04-20 15:39:32 +00:00
}
}
/* }}} */
void zend_file_context_begin ( zend_file_context * prev_context ) /* { { { */
{
* prev_context = CG ( file_context ) ;
2015-04-20 18:16:58 +00:00
FC ( imports ) = NULL ;
FC ( imports_function ) = NULL ;
FC ( imports_const ) = NULL ;
FC ( current_namespace ) = NULL ;
FC ( in_namespace ) = 0 ;
FC ( has_bracketed_namespaces ) = 0 ;
FC ( declarables ) . ticks = 0 ;
2015-04-20 15:39:32 +00:00
}
/* }}} */
void zend_file_context_end ( zend_file_context * prev_context ) /* { { { */
{
2015-04-20 18:16:58 +00:00
zend_end_namespace ( ) ;
2015-04-20 15:39:32 +00:00
CG ( file_context ) = * prev_context ;
}
/* }}} */
2014-12-13 22:06:14 +00:00
void zend_init_compiler_data_structures ( void ) /* { { { */
1999-04-07 18:10:10 +00:00
{
2015-07-10 11:30:25 +00:00
zend_stack_init ( & CG ( loop_var_stack ) , sizeof ( zend_loop_var ) ) ;
2014-08-15 15:10:06 +00:00
zend_stack_init ( & CG ( delayed_oplines_stack ) , sizeof ( zend_op ) ) ;
1999-04-07 18:10:10 +00:00
CG ( active_class_entry ) = NULL ;
2000-02-04 14:45:58 +00:00
CG ( in_compilation ) = 0 ;
2003-01-05 16:09:59 +00:00
CG ( start_lineno ) = 0 ;
2014-04-21 14:25:34 +00:00
zend_hash_init ( & CG ( const_filenames ) , 8 , NULL , NULL , 0 ) ;
2008-06-29 08:21:35 +00:00
2009-11-16 22:52:00 +00:00
CG ( encoding_declared ) = 0 ;
2008-03-16 21:06:55 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
2008-03-16 21:06:55 +00:00
2009-07-27 14:11:53 +00:00
ZEND_API void file_handle_dtor ( zend_file_handle * fh ) /* { { { */
2008-03-16 21:06:55 +00:00
{
2014-10-15 07:37:55 +00:00
2014-12-13 22:06:14 +00:00
zend_file_handle_dtor ( fh ) ;
2001-05-06 19:30:31 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
2001-05-06 19:30:31 +00:00
2014-12-13 22:06:14 +00:00
void init_compiler ( void ) /* { { { */
2001-05-06 19:30:31 +00:00
{
2014-06-17 22:47:01 +00:00
CG ( arena ) = zend_arena_create ( 64 * 1024 ) ;
2006-05-02 15:49:26 +00:00
CG ( active_op_array ) = NULL ;
2012-11-14 13:45:10 +00:00
memset ( & CG ( context ) , 0 , sizeof ( CG ( context ) ) ) ;
2014-12-13 22:06:14 +00:00
zend_init_compiler_data_structures ( ) ;
zend_init_rsrc_list ( ) ;
2015-09-11 02:58:24 +00:00
zend_hash_init ( & CG ( filenames_table ) , 8 , NULL , ZVAL_PTR_DTOR , 0 ) ;
2008-03-16 21:06:55 +00:00
zend_llist_init ( & CG ( open_files ) , sizeof ( zend_file_handle ) , ( void ( * ) ( void * ) ) file_handle_dtor , 0 ) ;
2001-05-06 19:30:31 +00:00
CG ( unclean_shutdown ) = 0 ;
1999-04-07 18:10:10 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void shutdown_compiler ( void ) /* { { { */
1999-04-07 18:10:10 +00:00
{
2015-07-10 00:31:52 +00:00
zend_stack_destroy ( & CG ( loop_var_stack ) ) ;
2014-08-15 15:10:06 +00:00
zend_stack_destroy ( & CG ( delayed_oplines_stack ) ) ;
2000-08-19 17:50:42 +00:00
zend_hash_destroy ( & CG ( filenames_table ) ) ;
2013-08-24 21:53:43 +00:00
zend_hash_destroy ( & CG ( const_filenames ) ) ;
2014-06-17 22:47:01 +00:00
zend_arena_destroy ( CG ( arena ) ) ;
1999-04-07 18:10:10 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
ZEND_API zend_string * zend_set_compiled_filename ( zend_string * new_compiled_filename ) /* { { { */
1999-04-07 18:10:10 +00:00
{
2015-09-11 02:58:24 +00:00
zval * p , rv ;
1999-04-07 18:10:10 +00:00
2015-09-11 02:58:24 +00:00
if ( ( p = zend_hash_find ( & CG ( filenames_table ) , new_compiled_filename ) ) ) {
ZEND_ASSERT ( Z_TYPE_P ( p ) = = IS_STRING ) ;
CG ( compiled_filename ) = Z_STR_P ( p ) ;
return Z_STR_P ( p ) ;
2000-08-19 17:50:42 +00:00
}
2015-09-11 02:58:24 +00:00
ZVAL_STR_COPY ( & rv , new_compiled_filename ) ;
zend_hash_update ( & CG ( filenames_table ) , new_compiled_filename , & rv ) ;
CG ( compiled_filename ) = new_compiled_filename ;
return new_compiled_filename ;
1999-04-07 18:10:10 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
ZEND_API void zend_restore_compiled_filename ( zend_string * original_compiled_filename ) /* { { { */
1999-04-07 18:10:10 +00:00
{
CG ( compiled_filename ) = original_compiled_filename ;
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
ZEND_API zend_string * zend_get_compiled_filename ( void ) /* { { { */
2000-02-04 14:45:58 +00:00
{
return CG ( compiled_filename ) ;
}
2009-07-27 14:11:53 +00:00
/* }}} */
2000-02-04 14:45:58 +00:00
2014-12-13 22:06:14 +00:00
ZEND_API int zend_get_compiled_lineno ( void ) /* { { { */
2000-02-04 14:45:58 +00:00
{
return CG ( zend_lineno ) ;
}
2009-07-27 14:11:53 +00:00
/* }}} */
2000-02-04 14:45:58 +00:00
2014-12-13 22:06:14 +00:00
ZEND_API zend_bool zend_is_compiling ( void ) /* { { { */
1999-04-07 18:10:10 +00:00
{
2000-02-04 14:45:58 +00:00
return CG ( in_compilation ) ;
1999-04-07 18:10:10 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-08-25 17:28:33 +00:00
static uint32_t get_temporary_variable ( zend_op_array * op_array ) /* { { { */
1999-04-07 18:10:10 +00:00
{
2014-08-25 17:28:33 +00:00
return ( uint32_t ) op_array - > T + + ;
1999-04-07 18:10:10 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
static int lookup_cv ( zend_op_array * op_array , zend_string * name ) /* { { { */ {
2004-10-04 19:54:35 +00:00
int i = 0 ;
2014-08-25 17:24:55 +00:00
zend_ulong hash_value = zend_string_hash_val ( name ) ;
2004-10-04 19:54:35 +00:00
while ( i < op_array - > last_var ) {
2015-06-30 10:59:27 +00:00
if ( ZSTR_VAL ( op_array - > vars [ i ] ) = = ZSTR_VAL ( name ) | |
( ZSTR_H ( op_array - > vars [ i ] ) = = hash_value & &
ZSTR_LEN ( op_array - > vars [ i ] ) = = ZSTR_LEN ( name ) & &
memcmp ( ZSTR_VAL ( op_array - > vars [ i ] ) , ZSTR_VAL ( name ) , ZSTR_LEN ( name ) ) = = 0 ) ) {
2014-08-25 17:24:55 +00:00
zend_string_release ( name ) ;
2014-11-28 08:11:33 +00:00
return ( int ) ( zend_intptr_t ) ZEND_CALL_VAR_NUM ( NULL , i ) ;
2004-10-04 19:54:35 +00:00
}
i + + ;
}
i = op_array - > last_var ;
op_array - > last_var + + ;
2010-09-15 07:38:52 +00:00
if ( op_array - > last_var > CG ( context ) . vars_size ) {
CG ( context ) . vars_size + = 16 ; /* FIXME */
2014-02-10 06:04:30 +00:00
op_array - > vars = erealloc ( op_array - > vars , CG ( context ) . vars_size * sizeof ( zend_string * ) ) ;
2004-10-04 19:54:35 +00:00
}
2014-02-10 06:04:30 +00:00
2014-12-13 22:06:14 +00:00
op_array - > vars [ i ] = zend_new_interned_string ( name ) ;
2014-11-28 08:11:33 +00:00
return ( int ) ( zend_intptr_t ) ZEND_CALL_VAR_NUM ( NULL , i ) ;
2004-10-04 19:54:35 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
2004-10-04 19:54:35 +00:00
2010-04-20 10:57:45 +00:00
void zend_del_literal ( zend_op_array * op_array , int n ) /* { { { */
{
2014-12-12 07:19:41 +00:00
zval_dtor ( CT_CONSTANT_EX ( op_array , n ) ) ;
2010-04-20 10:57:45 +00:00
if ( n + 1 = = op_array - > last_literal ) {
op_array - > last_literal - - ;
} else {
2014-12-12 07:19:41 +00:00
ZVAL_UNDEF ( CT_CONSTANT_EX ( op_array , n ) ) ;
2010-04-20 10:57:45 +00:00
}
}
/* }}} */
1999-04-07 18:10:10 +00:00
2011-08-15 09:54:06 +00:00
/* Common part of zend_add_literal and zend_append_individual_literal */
2014-12-13 22:06:14 +00:00
static inline void zend_insert_literal ( zend_op_array * op_array , zval * zv , int literal_position ) /* { { { */
2011-08-15 09:54:06 +00:00
{
if ( Z_TYPE_P ( zv ) = = IS_STRING | | Z_TYPE_P ( zv ) = = IS_CONSTANT ) {
2014-08-25 17:24:55 +00:00
zend_string_hash_val ( Z_STR_P ( zv ) ) ;
2014-12-13 22:06:14 +00:00
Z_STR_P ( zv ) = zend_new_interned_string ( Z_STR_P ( zv ) ) ;
2015-06-29 13:44:54 +00:00
if ( ZSTR_IS_INTERNED ( Z_STR_P ( zv ) ) ) {
2014-04-03 11:26:23 +00:00
Z_TYPE_FLAGS_P ( zv ) & = ~ ( IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE ) ;
}
2011-08-15 09:54:06 +00:00
}
2014-12-12 07:19:41 +00:00
ZVAL_COPY_VALUE ( CT_CONSTANT_EX ( op_array , literal_position ) , zv ) ;
2014-04-17 11:40:45 +00:00
Z_CACHE_SLOT ( op_array - > literals [ literal_position ] ) = - 1 ;
2011-08-15 09:54:06 +00:00
}
/* }}} */
/* Is used while compiling a function, using the context to keep track
of an approximate size to avoid to relocate to often .
Literals are truncated to actual size in the second compiler pass ( pass_two ( ) ) . */
2014-12-13 22:06:14 +00:00
int zend_add_literal ( zend_op_array * op_array , zval * zv ) /* { { { */
2010-04-20 10:57:45 +00:00
{
int i = op_array - > last_literal ;
op_array - > last_literal + + ;
2010-09-15 07:38:52 +00:00
if ( i > = CG ( context ) . literals_size ) {
2011-08-15 09:54:06 +00:00
while ( i > = CG ( context ) . literals_size ) {
CG ( context ) . literals_size + = 16 ; /* FIXME */
}
2014-04-17 11:40:45 +00:00
op_array - > literals = ( zval * ) erealloc ( op_array - > literals , CG ( context ) . literals_size * sizeof ( zval ) ) ;
2010-04-20 10:57:45 +00:00
}
2014-12-13 22:06:14 +00:00
zend_insert_literal ( op_array , zv , i ) ;
2011-08-15 09:54:06 +00:00
return i ;
}
/* }}} */
2010-04-20 11:05:54 +00:00
2014-12-13 22:06:14 +00:00
static inline int zend_add_literal_string ( zend_op_array * op_array , zend_string * * str ) /* { { { */
2010-04-21 14:58:33 +00:00
{
int ret ;
2014-09-23 18:21:28 +00:00
zval zv ;
ZVAL_STR ( & zv , * str ) ;
2014-12-13 22:06:14 +00:00
ret = zend_add_literal ( op_array , & zv ) ;
2014-09-23 18:21:28 +00:00
* str = Z_STR ( zv ) ;
return ret ;
}
2014-12-02 14:21:19 +00:00
/* }}} */
2010-04-21 14:58:33 +00:00
2014-12-13 22:06:14 +00:00
static int zend_add_func_name_literal ( zend_op_array * op_array , zend_string * name ) /* { { { */
2014-09-23 18:21:28 +00:00
{
2014-09-28 21:17:29 +00:00
/* Original name */
2014-12-13 22:06:14 +00:00
int ret = zend_add_literal_string ( op_array , & name ) ;
2013-01-28 02:02:51 +00:00
2014-09-28 21:17:29 +00:00
/* Lowercased name */
2014-12-24 12:04:51 +00:00
zend_string * lc_name = zend_string_tolower ( name ) ;
2014-12-13 22:06:14 +00:00
zend_add_literal_string ( op_array , & lc_name ) ;
2010-04-21 14:58:33 +00:00
return ret ;
}
/* }}} */
2014-12-13 22:06:14 +00:00
static int zend_add_ns_func_name_literal ( zend_op_array * op_array , zend_string * name ) /* { { { */
2010-04-27 12:09:13 +00:00
{
2014-09-28 21:17:29 +00:00
const char * unqualified_name ;
size_t unqualified_name_len ;
2010-04-27 12:09:13 +00:00
2014-09-28 21:17:29 +00:00
/* Original name */
2014-12-13 22:06:14 +00:00
int ret = zend_add_literal_string ( op_array , & name ) ;
2010-04-27 12:09:13 +00:00
2014-09-28 21:17:29 +00:00
/* Lowercased name */
2014-12-24 12:04:51 +00:00
zend_string * lc_name = zend_string_tolower ( name ) ;
2014-12-13 22:06:14 +00:00
zend_add_literal_string ( op_array , & lc_name ) ;
2013-08-22 01:24:59 +00:00
2014-09-28 21:17:29 +00:00
/* Lowercased unqualfied name */
if ( zend_get_unqualified_name ( name , & unqualified_name , & unqualified_name_len ) ) {
lc_name = zend_string_alloc ( unqualified_name_len , 0 ) ;
2015-06-30 10:59:27 +00:00
zend_str_tolower_copy ( ZSTR_VAL ( lc_name ) , unqualified_name , unqualified_name_len ) ;
2014-12-13 22:06:14 +00:00
zend_add_literal_string ( op_array , & lc_name ) ;
2013-08-22 01:24:59 +00:00
}
2010-04-27 12:09:13 +00:00
return ret ;
}
/* }}} */
2010-04-21 14:58:33 +00:00
2014-12-13 22:06:14 +00:00
static int zend_add_class_name_literal ( zend_op_array * op_array , zend_string * name ) /* { { { */
2014-09-23 17:32:02 +00:00
{
2014-09-28 21:17:29 +00:00
/* Original name */
2014-12-13 22:06:14 +00:00
int ret = zend_add_literal_string ( op_array , & name ) ;
2014-07-19 21:30:07 +00:00
2014-09-28 21:17:29 +00:00
/* Lowercased name */
2014-12-24 12:04:51 +00:00
zend_string * lc_name = zend_string_tolower ( name ) ;
2014-12-13 22:06:14 +00:00
zend_add_literal_string ( op_array , & lc_name ) ;
2010-04-21 14:58:33 +00:00
2014-12-13 22:06:14 +00:00
zend_alloc_cache_slot ( ret ) ;
2010-05-24 14:11:39 +00:00
2010-04-21 14:58:33 +00:00
return ret ;
}
/* }}} */
2014-12-13 22:06:14 +00:00
static int zend_add_const_name_literal ( zend_op_array * op_array , zend_string * name , zend_bool unqualified ) /* { { { */
2010-04-22 15:03:17 +00:00
{
2014-02-10 06:04:30 +00:00
zend_string * tmp_name ;
2010-04-22 15:03:17 +00:00
2014-12-13 22:06:14 +00:00
int ret = zend_add_literal_string ( op_array , & name ) ;
2010-04-22 15:03:17 +00:00
2015-06-30 10:59:27 +00:00
size_t ns_len = 0 , after_ns_len = ZSTR_LEN ( name ) ;
const char * after_ns = zend_memrchr ( ZSTR_VAL ( name ) , ' \\ ' , ZSTR_LEN ( name ) ) ;
2014-09-23 18:21:28 +00:00
if ( after_ns ) {
after_ns + = 1 ;
2015-06-30 10:59:27 +00:00
ns_len = after_ns - ZSTR_VAL ( name ) - 1 ;
after_ns_len = ZSTR_LEN ( name ) - ns_len - 1 ;
2010-04-22 15:03:17 +00:00
/* lowercased namespace name & original constant name */
2015-06-30 10:59:27 +00:00
tmp_name = zend_string_init ( ZSTR_VAL ( name ) , ZSTR_LEN ( name ) , 0 ) ;
zend_str_tolower ( ZSTR_VAL ( tmp_name ) , ns_len ) ;
2014-12-13 22:06:14 +00:00
zend_add_literal_string ( op_array , & tmp_name ) ;
2010-04-22 15:03:17 +00:00
/* lowercased namespace name & lowercased constant name */
2014-12-24 12:04:51 +00:00
tmp_name = zend_string_tolower ( name ) ;
2014-12-13 22:06:14 +00:00
zend_add_literal_string ( op_array , & tmp_name ) ;
2010-04-22 15:03:17 +00:00
if ( ! unqualified ) {
return ret ;
}
2014-09-23 18:21:28 +00:00
} else {
2015-06-30 10:59:27 +00:00
after_ns = ZSTR_VAL ( name ) ;
2010-04-22 15:03:17 +00:00
}
2014-09-23 18:21:28 +00:00
/* original unqualified constant name */
tmp_name = zend_string_init ( after_ns , after_ns_len , 0 ) ;
2014-12-13 22:06:14 +00:00
zend_add_literal_string ( op_array , & tmp_name ) ;
2010-04-22 15:03:17 +00:00
2014-09-23 18:21:28 +00:00
/* lowercased unqualified constant name */
tmp_name = zend_string_alloc ( after_ns_len , 0 ) ;
2015-06-30 10:59:27 +00:00
zend_str_tolower_copy ( ZSTR_VAL ( tmp_name ) , after_ns , after_ns_len ) ;
2014-12-13 22:06:14 +00:00
zend_add_literal_string ( op_array , & tmp_name ) ;
2010-04-22 15:03:17 +00:00
return ret ;
}
/* }}} */
2014-02-10 06:04:30 +00:00
# define LITERAL_STR(op, str) do { \
2010-04-20 10:57:45 +00:00
zval _c ; \
2014-02-10 06:04:30 +00:00
ZVAL_STR ( & _c , str ) ; \
2014-12-13 22:06:14 +00:00
op . constant = zend_add_literal ( CG ( active_op_array ) , & _c ) ; \
2014-02-10 06:04:30 +00:00
} while ( 0 )
2015-04-05 11:50:35 +00:00
void zend_stop_lexing ( void )
{
if ( LANG_SCNG ( on_event ) ) LANG_SCNG ( on_event ) ( ON_STOP , END , 0 ) ;
2014-07-22 13:50:23 +00:00
LANG_SCNG ( yy_cursor ) = LANG_SCNG ( yy_limit ) ;
}
2010-04-21 14:58:33 +00:00
2015-08-04 04:37:06 +00:00
static inline void zend_begin_loop ( zend_uchar free_opcode , const znode * loop_var ) /* { { { */
2010-08-25 09:14:36 +00:00
{
1999-04-07 18:10:10 +00:00
zend_brk_cont_element * brk_cont_element ;
2015-05-22 19:35:33 +00:00
int parent = CG ( context ) . current_brk_cont ;
2015-07-10 11:30:25 +00:00
zend_loop_var info = { 0 } ;
2010-08-25 09:14:36 +00:00
2015-07-10 00:31:52 +00:00
CG ( context ) . current_brk_cont = CG ( active_op_array ) - > last_brk_cont ;
1999-04-07 18:10:10 +00:00
brk_cont_element = get_next_brk_cont_element ( CG ( active_op_array ) ) ;
brk_cont_element - > parent = parent ;
2015-07-10 00:31:52 +00:00
2015-07-10 11:30:25 +00:00
if ( loop_var & & ( loop_var - > op_type & ( IS_VAR | IS_TMP_VAR ) ) ) {
2015-08-04 04:37:06 +00:00
info . opcode = free_opcode ;
info . var_type = loop_var - > op_type ;
info . var_num = loop_var - > u . op . var ;
info . u . brk_cont_offset = CG ( context ) . current_brk_cont ;
2015-07-10 00:31:52 +00:00
brk_cont_element - > start = get_next_op_number ( CG ( active_op_array ) ) ;
2015-05-22 19:35:33 +00:00
} else {
2015-07-10 11:30:25 +00:00
info . opcode = ZEND_NOP ;
2015-07-10 00:31:52 +00:00
/* The start field is used to free temporary variables in case of exceptions.
* We won ' t try to free something of we don ' t have loop variable . */
brk_cont_element - > start = - 1 ;
2015-05-22 19:35:33 +00:00
}
2015-07-10 11:30:25 +00:00
zend_stack_push ( & CG ( loop_var_stack ) , & info ) ;
2010-08-25 09:14:36 +00:00
}
/* }}} */
2015-05-22 19:35:33 +00:00
static inline void zend_end_loop ( int cont_addr ) /* { { { */
1999-04-07 18:10:10 +00:00
{
2015-05-22 19:35:33 +00:00
zend_brk_cont_element * brk_cont_element
2015-07-10 00:31:52 +00:00
= & CG ( active_op_array ) - > brk_cont_array [ CG ( context ) . current_brk_cont ] ;
2015-05-22 19:35:33 +00:00
brk_cont_element - > cont = cont_addr ;
brk_cont_element - > brk = get_next_op_number ( CG ( active_op_array ) ) ;
CG ( context ) . current_brk_cont = brk_cont_element - > parent ;
2015-07-10 00:31:52 +00:00
2015-07-10 11:30:25 +00:00
zend_stack_del_top ( & CG ( loop_var_stack ) ) ;
1999-04-07 18:10:10 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_do_free ( znode * op1 ) /* { { { */
1999-04-07 18:10:10 +00:00
{
2016-03-17 13:10:08 +00:00
if ( op1 - > op_type = = IS_TMP_VAR ) {
zend_op * opline = & CG ( active_op_array ) - > opcodes [ CG ( active_op_array ) - > last - 1 ] ;
while ( opline - > opcode = = ZEND_END_SILENCE ) {
opline - - ;
}
if ( opline - > result_type = = IS_TMP_VAR & & opline - > result . var = = op1 - > u . op . var ) {
if ( opline - > opcode = = ZEND_BOOL | | opline - > opcode = = ZEND_BOOL_NOT ) {
return ;
}
}
opline = get_next_op ( CG ( active_op_array ) ) ;
1999-04-07 18:10:10 +00:00
1999-12-20 20:01:19 +00:00
opline - > opcode = ZEND_FREE ;
2010-04-20 10:57:45 +00:00
SET_NODE ( opline - > op1 , op1 ) ;
1999-12-20 20:01:19 +00:00
SET_UNUSED ( opline - > op2 ) ;
2016-03-17 13:10:08 +00:00
} else if ( op1 - > op_type = = IS_VAR ) {
1999-04-07 18:10:10 +00:00
zend_op * opline = & CG ( active_op_array ) - > opcodes [ CG ( active_op_array ) - > last - 1 ] ;
2016-03-17 13:10:08 +00:00
while ( opline - > opcode = = ZEND_END_SILENCE | |
opline - > opcode = = ZEND_EXT_FCALL_END | |
opline - > opcode = = ZEND_OP_DATA ) {
1999-12-20 20:01:19 +00:00
opline - - ;
}
2010-04-20 10:57:45 +00:00
if ( opline - > result_type = = IS_VAR
& & opline - > result . var = = op1 - > u . op . var ) {
2010-07-16 13:38:09 +00:00
if ( opline - > opcode = = ZEND_FETCH_R | |
opline - > opcode = = ZEND_FETCH_DIM_R | |
2014-09-23 21:57:40 +00:00
opline - > opcode = = ZEND_FETCH_OBJ_R ) {
2010-07-16 13:38:09 +00:00
/* It's very rare and useless case. It's better to use
additional FREE opcode and simplify the FETCH handlers
their selves */
2014-12-13 22:06:14 +00:00
opline = get_next_op ( CG ( active_op_array ) ) ;
2010-07-16 13:38:09 +00:00
opline - > opcode = ZEND_FREE ;
SET_NODE ( opline - > op1 , op1 ) ;
SET_UNUSED ( opline - > op2 ) ;
} else {
opline - > result_type | = EXT_TYPE_UNUSED ;
}
1999-04-07 18:10:10 +00:00
} else {
2014-10-23 07:52:34 +00:00
while ( opline > = CG ( active_op_array ) - > opcodes ) {
2014-10-05 09:02:58 +00:00
if ( opline - > opcode = = ZEND_FETCH_LIST & &
opline - > op1_type = = IS_VAR & &
opline - > op1 . var = = op1 - > u . op . var ) {
2014-12-13 22:06:14 +00:00
opline = get_next_op ( CG ( active_op_array ) ) ;
2014-10-05 09:02:58 +00:00
opline - > opcode = ZEND_FREE ;
SET_NODE ( opline - > op1 , op1 ) ;
SET_UNUSED ( opline - > op2 ) ;
return ;
}
2016-03-17 13:10:08 +00:00
if ( opline - > result_type = = IS_VAR
2010-04-20 10:57:45 +00:00
& & opline - > result . var = = op1 - > u . op . var ) {
2005-06-10 07:56:40 +00:00
if ( opline - > opcode = = ZEND_NEW ) {
2010-04-20 10:57:45 +00:00
opline - > result_type | = EXT_TYPE_UNUSED ;
2014-07-22 14:55:34 +00:00
opline = & CG ( active_op_array ) - > opcodes [ CG ( active_op_array ) - > last - 1 ] ;
while ( opline - > opcode ! = ZEND_DO_FCALL | | opline - > op1 . num ! = ZEND_CALL_CTOR ) {
opline - - ;
}
opline - > op1 . num | = ZEND_CALL_CTOR_RESULT_UNUSED ;
2005-06-10 07:56:40 +00:00
}
2000-02-02 16:47:43 +00:00
break ;
1999-04-07 18:10:10 +00:00
}
opline - - ;
}
}
2000-12-18 13:28:32 +00:00
} else if ( op1 - > op_type = = IS_CONST ) {
2014-08-17 19:45:29 +00:00
/* Destroy value without using GC: When opcache moves arrays into SHM it will
* free the zend_array structure , so references to it from outside the op array
* become invalid . GC would cause such a reference in the root buffer . */
2014-09-03 13:16:32 +00:00
zval_ptr_dtor_nogc ( & op1 - > u . constant ) ;
2006-05-09 23:53:23 +00:00
}
2002-03-10 13:42:37 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-01 18:44:07 +00:00
uint32_t zend_add_class_modifier ( uint32_t flags , uint32_t new_flag ) /* { { { */
{
uint32_t new_flags = flags | new_flag ;
if ( ( flags & ZEND_ACC_EXPLICIT_ABSTRACT_CLASS ) & & ( new_flag & ZEND_ACC_EXPLICIT_ABSTRACT_CLASS ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Multiple abstract modifiers are not allowed " ) ;
}
if ( ( flags & ZEND_ACC_FINAL ) & & ( new_flag & ZEND_ACC_FINAL ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Multiple final modifiers are not allowed " ) ;
}
if ( ( new_flags & ZEND_ACC_EXPLICIT_ABSTRACT_CLASS ) & & ( new_flags & ZEND_ACC_FINAL ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use the final modifier on an abstract class " ) ;
}
return new_flags ;
}
/* }}} */
2014-08-29 05:05:58 +00:00
uint32_t zend_add_member_modifier ( uint32_t flags , uint32_t new_flag ) /* { { { */
{
2014-08-25 19:21:16 +00:00
uint32_t new_flags = flags | new_flag ;
2014-07-27 10:17:36 +00:00
if ( ( flags & ZEND_ACC_PPP_MASK ) & & ( new_flag & ZEND_ACC_PPP_MASK ) ) {
2013-10-19 21:22:20 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Multiple access type modifiers are not allowed " ) ;
2002-12-06 17:09:44 +00:00
}
2014-07-27 10:17:36 +00:00
if ( ( flags & ZEND_ACC_ABSTRACT ) & & ( new_flag & ZEND_ACC_ABSTRACT ) ) {
2013-10-19 21:22:20 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Multiple abstract modifiers are not allowed " ) ;
2007-11-13 16:52:14 +00:00
}
2014-07-27 10:17:36 +00:00
if ( ( flags & ZEND_ACC_STATIC ) & & ( new_flag & ZEND_ACC_STATIC ) ) {
2013-10-19 21:22:20 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Multiple static modifiers are not allowed " ) ;
2007-11-13 16:52:14 +00:00
}
2014-07-27 10:17:36 +00:00
if ( ( flags & ZEND_ACC_FINAL ) & & ( new_flag & ZEND_ACC_FINAL ) ) {
2013-10-19 21:22:20 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Multiple final modifiers are not allowed " ) ;
2007-11-13 16:52:14 +00:00
}
2014-07-27 10:17:36 +00:00
if ( ( new_flags & ZEND_ACC_ABSTRACT ) & & ( new_flags & ZEND_ACC_FINAL ) ) {
2013-10-19 21:22:20 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use the final modifier on an abstract class member " ) ;
2003-03-01 14:57:49 +00:00
}
2014-07-27 10:17:36 +00:00
return new_flags ;
2002-12-06 17:09:44 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2006-05-09 23:53:23 +00:00
2014-08-29 05:05:58 +00:00
zend_string * zend_concat3 ( char * str1 , size_t str1_len , char * str2 , size_t str2_len , char * str3 , size_t str3_len ) /* { { { */
{
2014-07-16 21:23:25 +00:00
size_t len = str1_len + str2_len + str3_len ;
2014-08-25 19:21:16 +00:00
zend_string * res = zend_string_alloc ( len , 0 ) ;
2005-06-08 15:01:35 +00:00
2015-06-30 10:59:27 +00:00
memcpy ( ZSTR_VAL ( res ) , str1 , str1_len ) ;
memcpy ( ZSTR_VAL ( res ) + str1_len , str2 , str2_len ) ;
memcpy ( ZSTR_VAL ( res ) + str1_len + str2_len , str3 , str3_len ) ;
ZSTR_VAL ( res ) [ len ] = ' \0 ' ;
2005-06-08 15:01:35 +00:00
2014-06-28 20:27:06 +00:00
return res ;
1999-04-07 18:10:10 +00:00
}
2014-07-16 21:23:25 +00:00
zend_string * zend_concat_names ( char * name1 , size_t name1_len , char * name2 , size_t name2_len ) {
return zend_concat3 ( name1 , name1_len , " \\ " , 1 , name2 , name2_len ) ;
}
2004-10-04 19:54:35 +00:00
2014-12-13 22:06:14 +00:00
zend_string * zend_prefix_with_ns ( zend_string * name ) {
2015-04-20 18:16:58 +00:00
if ( FC ( current_namespace ) ) {
zend_string * ns = FC ( current_namespace ) ;
2015-06-30 10:59:27 +00:00
return zend_concat_names ( ZSTR_VAL ( ns ) , ZSTR_LEN ( ns ) , ZSTR_VAL ( name ) , ZSTR_LEN ( name ) ) ;
1999-09-20 15:44:30 +00:00
} else {
2014-08-25 19:21:16 +00:00
return zend_string_copy ( name ) ;
1999-09-20 15:44:30 +00:00
}
2014-07-22 11:30:26 +00:00
}
1999-09-20 15:44:30 +00:00
2014-09-28 21:17:29 +00:00
void * zend_hash_find_ptr_lc ( HashTable * ht , const char * str , size_t len ) {
2014-07-04 22:11:00 +00:00
void * result ;
2014-09-28 21:17:29 +00:00
zend_string * lcname ;
ALLOCA_FLAG ( use_heap ) ;
2015-06-29 13:44:54 +00:00
ZSTR_ALLOCA_ALLOC ( lcname , len , use_heap ) ;
2015-06-30 10:59:27 +00:00
zend_str_tolower_copy ( ZSTR_VAL ( lcname ) , str , len ) ;
2014-07-04 22:11:00 +00:00
result = zend_hash_find_ptr ( ht , lcname ) ;
2015-06-29 13:44:54 +00:00
ZSTR_ALLOCA_FREE ( lcname , use_heap ) ;
2014-09-28 21:17:29 +00:00
2014-07-04 22:11:00 +00:00
return result ;
}
2001-08-08 17:18:16 +00:00
2014-06-28 20:27:06 +00:00
zend_string * zend_resolve_non_class_name (
2014-08-25 19:21:16 +00:00
zend_string * name , uint32_t type , zend_bool * is_fully_qualified ,
2014-12-14 13:07:59 +00:00
zend_bool case_sensitive , HashTable * current_import_sub
2014-06-28 20:27:06 +00:00
) {
char * compound ;
2014-07-22 11:25:47 +00:00
* is_fully_qualified = 0 ;
2008-11-04 15:58:55 +00:00
2015-06-30 10:59:27 +00:00
if ( ZSTR_VAL ( name ) [ 0 ] = = ' \\ ' ) {
2014-07-04 22:11:00 +00:00
/* Remove \ prefix (only relevant if this is a string rather than a label) */
2015-06-30 10:59:27 +00:00
return zend_string_init ( ZSTR_VAL ( name ) + 1 , ZSTR_LEN ( name ) - 1 , 0 ) ;
2001-08-08 17:18:16 +00:00
}
1999-04-07 18:10:10 +00:00
2014-07-22 11:25:47 +00:00
if ( type = = ZEND_NAME_FQ ) {
* is_fully_qualified = 1 ;
2014-08-25 19:21:16 +00:00
return zend_string_copy ( name ) ;
1999-04-07 18:10:10 +00:00
}
2014-07-22 11:25:47 +00:00
if ( type = = ZEND_NAME_RELATIVE ) {
* is_fully_qualified = 1 ;
2014-12-13 22:06:14 +00:00
return zend_prefix_with_ns ( name ) ;
2014-07-22 11:25:47 +00:00
}
1999-09-20 14:45:36 +00:00
2013-07-23 19:08:49 +00:00
if ( current_import_sub ) {
2014-07-04 22:11:00 +00:00
/* If an unqualified name is a function/const alias, replace it. */
zend_string * import_name ;
2013-08-25 14:21:51 +00:00
if ( case_sensitive ) {
2014-07-04 22:11:00 +00:00
import_name = zend_hash_find_ptr ( current_import_sub , name ) ;
2010-05-06 10:27:35 +00:00
} else {
2015-06-30 10:59:27 +00:00
import_name = zend_hash_find_ptr_lc ( current_import_sub , ZSTR_VAL ( name ) , ZSTR_LEN ( name ) ) ;
2010-05-06 10:27:35 +00:00
}
2004-10-04 19:54:35 +00:00
2014-07-04 22:11:00 +00:00
if ( import_name ) {
2014-06-28 20:27:06 +00:00
* is_fully_qualified = 1 ;
2014-08-25 19:21:16 +00:00
return zend_string_copy ( import_name ) ;
2013-07-16 18:39:33 +00:00
}
2014-06-28 20:27:06 +00:00
}
2004-10-04 19:54:35 +00:00
2015-06-30 10:59:27 +00:00
compound = memchr ( ZSTR_VAL ( name ) , ' \\ ' , ZSTR_LEN ( name ) ) ;
2014-06-28 20:27:06 +00:00
if ( compound ) {
* is_fully_qualified = 1 ;
2013-07-16 18:39:33 +00:00
}
2015-04-20 18:16:58 +00:00
if ( compound & & FC ( imports ) ) {
2014-07-04 22:11:00 +00:00
/* If the first part of a qualified name is an alias, substitute it. */
2015-06-30 10:59:27 +00:00
size_t len = compound - ZSTR_VAL ( name ) ;
zend_string * import_name = zend_hash_find_ptr_lc ( FC ( imports ) , ZSTR_VAL ( name ) , len ) ;
2014-06-28 20:27:06 +00:00
2014-07-04 22:11:00 +00:00
if ( import_name ) {
2014-06-28 20:27:06 +00:00
return zend_concat_names (
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( import_name ) , ZSTR_LEN ( import_name ) , ZSTR_VAL ( name ) + len + 1 , ZSTR_LEN ( name ) - len - 1 ) ;
2004-10-04 19:54:35 +00:00
}
}
2008-11-04 15:58:55 +00:00
2014-12-13 22:06:14 +00:00
return zend_prefix_with_ns ( name ) ;
2001-11-25 08:49:09 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_string * zend_resolve_function_name ( zend_string * name , uint32_t type , zend_bool * is_fully_qualified ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-28 20:27:06 +00:00
return zend_resolve_non_class_name (
2015-04-20 18:16:58 +00:00
name , type , is_fully_qualified , 0 , FC ( imports_function ) ) ;
2013-07-23 19:08:49 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_string * zend_resolve_const_name ( zend_string * name , uint32_t type , zend_bool * is_fully_qualified ) /* { { { */ {
2014-06-28 20:27:06 +00:00
return zend_resolve_non_class_name (
2015-04-20 18:16:58 +00:00
name , type , is_fully_qualified , 1 , FC ( imports_const ) ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_string * zend_resolve_class_name ( zend_string * name , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2007-09-28 19:52:53 +00:00
char * compound ;
2010-04-20 10:57:45 +00:00
2014-07-22 11:25:47 +00:00
if ( type = = ZEND_NAME_RELATIVE ) {
2014-12-13 22:06:14 +00:00
return zend_prefix_with_ns ( name ) ;
2014-07-22 11:25:47 +00:00
}
2015-06-30 10:59:27 +00:00
if ( type = = ZEND_NAME_FQ | | ZSTR_VAL ( name ) [ 0 ] = = ' \\ ' ) {
2014-07-04 21:45:20 +00:00
/* Remove \ prefix (only relevant if this is a string rather than a label) */
2015-06-30 10:59:27 +00:00
if ( ZSTR_VAL ( name ) [ 0 ] = = ' \\ ' ) {
name = zend_string_init ( ZSTR_VAL ( name ) + 1 , ZSTR_LEN ( name ) - 1 , 0 ) ;
2013-01-28 02:02:51 +00:00
} else {
2014-08-25 19:21:16 +00:00
zend_string_addref ( name ) ;
2014-07-04 21:45:20 +00:00
}
/* Ensure that \self, \parent and \static are not used */
2014-07-28 13:39:43 +00:00
if ( ZEND_FETCH_CLASS_DEFAULT ! = zend_get_class_fetch_type ( name ) ) {
2015-06-30 10:59:27 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " ' \\ %s' is an invalid class name " , ZSTR_VAL ( name ) ) ;
2010-04-20 10:57:45 +00:00
}
2014-07-04 21:45:20 +00:00
return name ;
2010-04-20 10:57:45 +00:00
}
2013-01-28 02:02:51 +00:00
2015-04-20 18:16:58 +00:00
if ( FC ( imports ) ) {
2015-06-30 10:59:27 +00:00
compound = memchr ( ZSTR_VAL ( name ) , ' \\ ' , ZSTR_LEN ( name ) ) ;
2014-07-04 21:45:20 +00:00
if ( compound ) {
/* If the first part of a qualified name is an alias, substitute it. */
2015-06-30 10:59:27 +00:00
size_t len = compound - ZSTR_VAL ( name ) ;
2015-04-20 15:39:32 +00:00
zend_string * import_name =
2015-06-30 10:59:27 +00:00
zend_hash_find_ptr_lc ( FC ( imports ) , ZSTR_VAL ( name ) , len ) ;
2014-07-04 21:45:20 +00:00
2014-07-04 22:11:00 +00:00
if ( import_name ) {
2014-07-04 21:45:20 +00:00
return zend_concat_names (
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( import_name ) , ZSTR_LEN ( import_name ) , ZSTR_VAL ( name ) + len + 1 , ZSTR_LEN ( name ) - len - 1 ) ;
2007-12-03 14:15:43 +00:00
}
2014-07-04 21:45:20 +00:00
} else {
/* If an unqualified name is an alias, replace it. */
2014-07-04 22:11:00 +00:00
zend_string * import_name
2015-06-30 10:59:27 +00:00
= zend_hash_find_ptr_lc ( FC ( imports ) , ZSTR_VAL ( name ) , ZSTR_LEN ( name ) ) ;
2014-07-04 21:45:20 +00:00
2014-07-04 22:11:00 +00:00
if ( import_name ) {
2014-08-25 19:21:16 +00:00
return zend_string_copy ( import_name ) ;
2007-09-28 19:52:53 +00:00
}
}
2014-07-04 21:45:20 +00:00
}
1999-04-07 18:10:10 +00:00
2014-07-04 21:45:20 +00:00
/* If not fully qualified and not an alias, prepend the current namespace */
2014-12-13 22:06:14 +00:00
return zend_prefix_with_ns ( name ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_string * zend_resolve_class_name_ast ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2015-06-12 13:07:23 +00:00
zval * class_name = zend_ast_get_zval ( ast ) ;
if ( Z_TYPE_P ( class_name ) ! = IS_STRING ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Illegal class name " ) ;
}
return zend_resolve_class_name ( Z_STR_P ( class_name ) , ast - > attr ) ;
2000-01-29 10:16:04 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2000-01-29 10:16:04 +00:00
2015-08-12 03:15:09 +00:00
static void label_ptr_dtor ( zval * zv ) /* { { { */
1999-04-07 18:10:10 +00:00
{
2015-08-12 03:15:09 +00:00
efree_size ( Z_PTR_P ( zv ) , sizeof ( zend_label ) ) ;
1999-04-07 18:10:10 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-08-29 05:05:58 +00:00
static void str_dtor ( zval * zv ) /* { { { */ {
2014-08-25 19:21:16 +00:00
zend_string_release ( Z_STR_P ( zv ) ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2015-07-10 00:31:52 +00:00
static zend_bool zend_is_call ( zend_ast * ast ) ;
2014-12-13 22:06:14 +00:00
static uint32_t zend_add_try_element ( uint32_t try_op ) /* { { { */
1999-04-07 18:10:10 +00:00
{
2014-07-12 11:50:58 +00:00
zend_op_array * op_array = CG ( active_op_array ) ;
2014-08-25 19:21:16 +00:00
uint32_t try_catch_offset = op_array - > last_try_catch + + ;
2014-07-12 11:50:58 +00:00
zend_try_catch_element * elem ;
1999-04-07 18:10:10 +00:00
2014-07-12 11:50:58 +00:00
op_array - > try_catch_array = safe_erealloc (
op_array - > try_catch_array , sizeof ( zend_try_catch_element ) , op_array - > last_try_catch , 0 ) ;
1999-04-07 18:10:10 +00:00
2014-07-12 11:50:58 +00:00
elem = & op_array - > try_catch_array [ try_catch_offset ] ;
elem - > try_op = try_op ;
elem - > catch_op = 0 ;
elem - > finally_op = 0 ;
elem - > finally_end = 0 ;
2004-07-20 08:58:18 +00:00
2004-02-03 12:17:09 +00:00
return try_catch_offset ;
2001-12-16 19:45:49 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2009-07-27 14:11:53 +00:00
ZEND_API void function_add_ref ( zend_function * function ) /* { { { */
1999-04-07 18:10:10 +00:00
{
1999-07-08 16:55:27 +00:00
if ( function - > type = = ZEND_USER_FUNCTION ) {
1999-12-23 19:23:36 +00:00
zend_op_array * op_array = & function - > op_array ;
1999-04-07 18:10:10 +00:00
2015-02-20 11:59:30 +00:00
if ( op_array - > refcount ) {
( * op_array - > refcount ) + + ;
}
1999-12-23 19:23:36 +00:00
if ( op_array - > static_variables ) {
2015-02-20 10:28:26 +00:00
if ( ! ( GC_FLAGS ( op_array - > static_variables ) & IS_ARRAY_IMMUTABLE ) ) {
GC_REFCOUNT ( op_array - > static_variables ) + + ;
}
2005-07-19 07:33:00 +00:00
}
2010-05-24 14:11:39 +00:00
op_array - > run_time_cache = NULL ;
2014-04-09 19:40:01 +00:00
} else if ( function - > type = = ZEND_INTERNAL_FUNCTION ) {
if ( function - > common . function_name ) {
2014-08-25 19:21:16 +00:00
zend_string_addref ( function - > common . function_name ) ;
2007-10-23 09:55:11 +00:00
}
1999-04-07 18:10:10 +00:00
}
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
ZEND_API int do_bind_function ( const zend_op_array * op_array , const zend_op * opline , HashTable * function_table , zend_bool compile_time ) /* { { { */
2004-02-03 12:17:09 +00:00
{
2014-02-17 13:59:18 +00:00
zend_function * function , * new_function ;
2010-04-20 10:57:45 +00:00
zval * op1 , * op2 ;
2004-02-03 12:17:09 +00:00
2010-04-20 10:57:45 +00:00
if ( compile_time ) {
2014-12-12 07:19:41 +00:00
op1 = CT_CONSTANT_EX ( op_array , opline - > op1 . constant ) ;
op2 = CT_CONSTANT_EX ( op_array , opline - > op2 . constant ) ;
2010-04-20 10:57:45 +00:00
} else {
2014-12-12 07:19:41 +00:00
op1 = RT_CONSTANT ( op_array , opline - > op1 ) ;
op2 = RT_CONSTANT ( op_array , opline - > op2 ) ;
2010-04-20 10:57:45 +00:00
}
2007-01-09 15:06:07 +00:00
2014-02-10 06:04:30 +00:00
function = zend_hash_find_ptr ( function_table , Z_STR_P ( op1 ) ) ;
2014-07-22 14:55:34 +00:00
new_function = zend_arena_alloc ( & CG ( arena ) , sizeof ( zend_op_array ) ) ;
2014-02-17 13:59:18 +00:00
memcpy ( new_function , function , sizeof ( zend_op_array ) ) ;
if ( zend_hash_add_ptr ( function_table , Z_STR_P ( op2 ) , new_function ) = = NULL ) {
2003-09-03 08:39:43 +00:00
int error_level = compile_time ? E_COMPILE_ERROR : E_ERROR ;
2009-04-08 13:17:09 +00:00
zend_function * old_function ;
2004-02-03 12:17:09 +00:00
2014-02-10 06:04:30 +00:00
if ( ( old_function = zend_hash_find_ptr ( function_table , Z_STR_P ( op2 ) ) ) ! = NULL
2009-04-08 13:17:09 +00:00
& & old_function - > type = = ZEND_USER_FUNCTION
& & old_function - > op_array . last > 0 ) {
2015-04-01 17:01:57 +00:00
zend_error_noreturn ( error_level , " Cannot redeclare %s() (previously declared in %s:%d) " ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( function - > common . function_name ) ,
ZSTR_VAL ( old_function - > op_array . filename ) ,
2009-04-08 13:17:09 +00:00
old_function - > op_array . opcodes [ 0 ] . lineno ) ;
2002-09-24 19:05:53 +00:00
} else {
2015-06-30 10:59:27 +00:00
zend_error_noreturn ( error_level , " Cannot redeclare %s() " , ZSTR_VAL ( function - > common . function_name ) ) ;
2002-09-24 19:05:53 +00:00
}
return FAILURE ;
2004-02-03 12:17:09 +00:00
} else {
2015-02-20 11:59:30 +00:00
if ( function - > op_array . refcount ) {
( * function - > op_array . refcount ) + + ;
}
2014-02-25 19:56:09 +00:00
function - > op_array . static_variables = NULL ; /* NULL out the unbound function */
2002-09-24 19:05:53 +00:00
return SUCCESS ;
2004-02-03 12:17:09 +00:00
}
2001-08-30 15:26:30 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
2001-08-30 15:26:30 +00:00
2014-12-13 22:06:14 +00:00
ZEND_API zend_class_entry * do_bind_class ( const zend_op_array * op_array , const zend_op * opline , HashTable * class_table , zend_bool compile_time ) /* { { { */
2012-11-22 11:17:05 +00:00
{
2014-02-10 06:04:30 +00:00
zend_class_entry * ce ;
2010-04-20 10:57:45 +00:00
zval * op1 , * op2 ;
2012-12-12 22:48:51 +00:00
2010-04-20 10:57:45 +00:00
if ( compile_time ) {
2014-12-12 07:19:41 +00:00
op1 = CT_CONSTANT_EX ( op_array , opline - > op1 . constant ) ;
op2 = CT_CONSTANT_EX ( op_array , opline - > op2 . constant ) ;
2010-04-20 10:57:45 +00:00
} else {
2014-12-12 07:19:41 +00:00
op1 = RT_CONSTANT ( op_array , opline - > op1 ) ;
op2 = RT_CONSTANT ( op_array , opline - > op2 ) ;
2010-04-20 10:57:45 +00:00
}
2014-02-10 06:04:30 +00:00
if ( ( ce = zend_hash_find_ptr ( class_table , Z_STR_P ( op1 ) ) ) = = NULL ) {
2013-10-19 21:22:20 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Internal Zend error - Missing class information for %s " , Z_STRVAL_P ( op1 ) ) ;
2003-03-05 11:14:44 +00:00
return NULL ;
2002-09-24 19:05:53 +00:00
}
ce - > refcount + + ;
2014-02-10 06:04:30 +00:00
if ( zend_hash_add_ptr ( class_table , Z_STR_P ( op2 ) , ce ) = = NULL ) {
2002-09-24 19:05:53 +00:00
ce - > refcount - - ;
2004-02-04 16:30:15 +00:00
if ( ! compile_time ) {
/* If we're in compile time, in practice, it's quite possible
* that we ' ll never reach this class declaration at runtime ,
* so we shut up about it . This allows the if ( ! defined ( ' FOO ' ) ) { return ; }
* approach to work .
*/
2015-06-30 10:59:27 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot declare %s %s, because the name is already in use " , zend_get_object_type ( ce ) , ZSTR_VAL ( ce - > name ) ) ;
2004-02-04 16:30:15 +00:00
}
2003-03-05 11:14:44 +00:00
return NULL ;
2002-09-24 19:05:53 +00:00
} else {
2012-12-25 06:23:08 +00:00
if ( ! ( ce - > ce_flags & ( ZEND_ACC_INTERFACE | ZEND_ACC_IMPLEMENT_INTERFACES | ZEND_ACC_IMPLEMENT_TRAITS ) ) ) {
2014-12-13 22:06:14 +00:00
zend_verify_abstract_class ( ce ) ;
2004-02-04 17:10:44 +00:00
}
2003-03-05 11:14:44 +00:00
return ce ;
2002-09-24 19:05:53 +00:00
}
2012-11-22 11:17:05 +00:00
}
/* }}} */
2012-08-13 13:48:39 +00:00
2014-12-13 22:06:14 +00:00
ZEND_API zend_class_entry * do_bind_inherited_class ( const zend_op_array * op_array , const zend_op * opline , HashTable * class_table , zend_class_entry * parent_ce , zend_bool compile_time ) /* { { { */
2001-08-30 15:26:30 +00:00
{
2014-02-10 06:04:30 +00:00
zend_class_entry * ce ;
2010-04-20 10:57:45 +00:00
zval * op1 , * op2 ;
2006-05-09 23:53:23 +00:00
2010-04-20 10:57:45 +00:00
if ( compile_time ) {
2014-12-12 07:19:41 +00:00
op1 = CT_CONSTANT_EX ( op_array , opline - > op1 . constant ) ;
op2 = CT_CONSTANT_EX ( op_array , opline - > op2 . constant ) ;
2010-04-20 11:16:39 +00:00
} else {
2014-12-12 07:19:41 +00:00
op1 = RT_CONSTANT ( op_array , opline - > op1 ) ;
op2 = RT_CONSTANT ( op_array , opline - > op2 ) ;
2007-09-28 19:52:53 +00:00
}
2014-02-10 06:04:30 +00:00
ce = zend_hash_find_ptr ( class_table , Z_STR_P ( op1 ) ) ;
2001-08-30 15:26:30 +00:00
2014-02-10 06:04:30 +00:00
if ( ! ce ) {
2004-02-04 16:30:15 +00:00
if ( ! compile_time ) {
/* If we're in compile time, in practice, it's quite possible
* that we ' ll never reach this class declaration at runtime ,
* so we shut up about it . This allows the if ( ! defined ( ' FOO ' ) ) { return ; }
* approach to work .
*/
2015-03-26 00:44:23 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot declare %s %s, because the name is already in use " , zend_get_object_type ( Z_OBJCE_P ( op2 ) ) , Z_STRVAL_P ( op2 ) ) ;
2004-02-04 16:30:15 +00:00
}
2003-03-05 11:14:44 +00:00
return NULL ;
2002-09-24 19:05:53 +00:00
}
2007-01-09 15:06:07 +00:00
2015-03-10 15:50:07 +00:00
if ( zend_hash_exists ( class_table , Z_STR_P ( op2 ) ) ) {
2015-06-30 10:59:27 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot declare %s %s, because the name is already in use " , zend_get_object_type ( ce ) , ZSTR_VAL ( ce - > name ) ) ;
2015-03-10 15:50:07 +00:00
}
2015-04-26 13:54:30 +00:00
zend_do_inheritance ( ce , parent_ce ) ;
2007-01-09 15:06:07 +00:00
2002-09-24 19:32:01 +00:00
ce - > refcount + + ;
2012-08-13 13:48:39 +00:00
2002-09-24 19:05:53 +00:00
/* Register the derived class */
2014-02-10 06:04:30 +00:00
if ( zend_hash_add_ptr ( class_table , Z_STR_P ( op2 ) , ce ) = = NULL ) {
2015-06-30 10:59:27 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot declare %s %s, because the name is already in use " , zend_get_object_type ( ce ) , ZSTR_VAL ( ce - > name ) ) ;
2012-08-14 00:59:40 +00:00
}
2003-03-05 11:14:44 +00:00
return ce ;
2012-08-13 13:48:39 +00:00
}
/* }}} */
2014-12-13 22:06:14 +00:00
void zend_do_early_binding ( void ) /* { { { */
2012-08-13 13:48:39 +00:00
{
1999-05-15 15:47:24 +00:00
zend_op * opline = & CG ( active_op_array ) - > opcodes [ CG ( active_op_array ) - > last - 1 ] ;
2004-02-04 16:30:15 +00:00
HashTable * table ;
1999-05-15 15:47:24 +00:00
2003-01-28 11:34:24 +00:00
while ( opline - > opcode = = ZEND_TICKS & & opline > CG ( active_op_array ) - > opcodes ) {
opline - - ;
2013-01-28 02:02:51 +00:00
}
2004-02-04 16:30:15 +00:00
switch ( opline - > opcode ) {
case ZEND_DECLARE_FUNCTION :
2014-12-13 22:06:14 +00:00
if ( do_bind_function ( CG ( active_op_array ) , opline , CG ( function_table ) , 1 ) = = FAILURE ) {
2004-02-04 16:30:15 +00:00
return ;
}
table = CG ( function_table ) ;
break ;
2004-02-04 17:10:44 +00:00
case ZEND_DECLARE_CLASS :
2014-12-13 22:06:14 +00:00
if ( do_bind_class ( CG ( active_op_array ) , opline , CG ( class_table ) , 1 ) = = NULL ) {
2008-03-18 08:36:30 +00:00
return ;
}
table = CG ( class_table ) ;
break ;
2004-02-04 17:10:44 +00:00
case ZEND_DECLARE_INHERITED_CLASS :
2008-03-18 08:36:30 +00:00
{
zend_op * fetch_class_opline = opline - 1 ;
2010-04-20 10:57:45 +00:00
zval * parent_name ;
2014-02-10 06:04:30 +00:00
zend_class_entry * ce ;
2012-08-13 13:48:39 +00:00
2014-12-12 07:19:41 +00:00
parent_name = CT_CONSTANT ( fetch_class_opline - > op2 ) ;
2015-02-03 14:39:05 +00:00
if ( ( ( ce = zend_lookup_class_ex ( Z_STR_P ( parent_name ) , parent_name + 1 , 0 ) ) = = NULL ) | |
2008-03-18 08:36:30 +00:00
( ( CG ( compiler_options ) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES ) & &
2014-02-10 06:04:30 +00:00
( ce - > type = = ZEND_INTERNAL_CLASS ) ) ) {
2015-01-08 20:40:36 +00:00
if ( CG ( compiler_options ) & ZEND_COMPILE_DELAYED_BINDING ) {
2014-08-25 19:21:16 +00:00
uint32_t * opline_num = & CG ( active_op_array ) - > early_binding ;
2013-01-28 02:02:51 +00:00
2014-12-12 18:57:34 +00:00
while ( * opline_num ! = ( uint32_t ) - 1 ) {
2010-04-20 10:57:45 +00:00
opline_num = & CG ( active_op_array ) - > opcodes [ * opline_num ] . result . opline_num ;
2008-03-18 08:36:30 +00:00
}
* opline_num = opline - CG ( active_op_array ) - > opcodes ;
opline - > opcode = ZEND_DECLARE_INHERITED_CLASS_DELAYED ;
2010-04-20 10:57:45 +00:00
opline - > result_type = IS_UNUSED ;
opline - > result . opline_num = - 1 ;
2004-02-04 16:30:15 +00:00
}
return ;
}
2014-12-13 22:06:14 +00:00
if ( do_bind_inherited_class ( CG ( active_op_array ) , opline , CG ( class_table ) , ce , 1 ) = = NULL ) {
2008-03-18 08:36:30 +00:00
return ;
2004-02-04 17:10:44 +00:00
}
2008-03-18 08:36:30 +00:00
/* clear unnecessary ZEND_FETCH_CLASS opcode */
2010-04-20 10:57:45 +00:00
zend_del_literal ( CG ( active_op_array ) , fetch_class_opline - > op2 . constant ) ;
2008-03-18 08:36:30 +00:00
MAKE_NOP ( fetch_class_opline ) ;
2012-12-12 22:48:51 +00:00
2008-03-18 08:36:30 +00:00
table = CG ( class_table ) ;
break ;
}
case ZEND_VERIFY_ABSTRACT_CLASS :
2004-02-04 18:24:44 +00:00
case ZEND_ADD_INTERFACE :
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
case ZEND_ADD_TRAIT :
case ZEND_BIND_TRAITS :
2004-02-04 18:24:44 +00:00
/* We currently don't early-bind classes that implement interfaces */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
/* Classes with traits are handled exactly the same, no early-bind here */
2004-02-04 18:24:44 +00:00
return ;
2004-02-04 16:30:15 +00:00
default :
2013-10-19 21:22:20 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Invalid binding type " ) ;
2004-02-04 16:30:15 +00:00
return ;
2013-01-28 02:02:51 +00:00
}
2002-09-24 19:05:53 +00:00
2014-12-12 07:19:41 +00:00
zend_hash_del ( table , Z_STR_P ( CT_CONSTANT ( opline - > op1 ) ) ) ;
2010-04-20 10:57:45 +00:00
zend_del_literal ( CG ( active_op_array ) , opline - > op1 . constant ) ;
zend_del_literal ( CG ( active_op_array ) , opline - > op2 . constant ) ;
2008-03-18 08:36:30 +00:00
MAKE_NOP ( opline ) ;
2001-08-30 15:26:30 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
2001-08-30 15:26:30 +00:00
2015-08-11 20:12:06 +00:00
static void zend_mark_function_as_generator ( ) /* { { { */
{
if ( ! CG ( active_op_array ) - > function_name ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
" The \" yield \" expression can only be used inside a function " ) ;
}
if ( CG ( active_op_array ) - > fn_flags & ZEND_ACC_HAS_RETURN_TYPE ) {
const char * msg = " Generators may only declare a return type of Generator, Iterator or Traversable, %s is not permitted " ;
if ( ! CG ( active_op_array ) - > arg_info [ - 1 ] . class_name ) {
zend_error_noreturn ( E_COMPILE_ERROR , msg ,
zend_get_type_by_const ( CG ( active_op_array ) - > arg_info [ - 1 ] . type_hint ) ) ;
}
if ( ! ( ZSTR_LEN ( CG ( active_op_array ) - > arg_info [ - 1 ] . class_name ) = = sizeof ( " Traversable " ) - 1
& & zend_binary_strcasecmp ( ZSTR_VAL ( CG ( active_op_array ) - > arg_info [ - 1 ] . class_name ) , sizeof ( " Traversable " ) - 1 , " Traversable " , sizeof ( " Traversable " ) - 1 ) = = 0 ) & &
! ( ZSTR_LEN ( CG ( active_op_array ) - > arg_info [ - 1 ] . class_name ) = = sizeof ( " Iterator " ) - 1
& & zend_binary_strcasecmp ( ZSTR_VAL ( CG ( active_op_array ) - > arg_info [ - 1 ] . class_name ) , sizeof ( " Iterator " ) - 1 , " Iterator " , sizeof ( " Iterator " ) - 1 ) = = 0 ) & &
! ( ZSTR_LEN ( CG ( active_op_array ) - > arg_info [ - 1 ] . class_name ) = = sizeof ( " Generator " ) - 1
& & zend_binary_strcasecmp ( ZSTR_VAL ( CG ( active_op_array ) - > arg_info [ - 1 ] . class_name ) , sizeof ( " Generator " ) - 1 , " Generator " , sizeof ( " Generator " ) - 1 ) = = 0 ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , msg , ZSTR_VAL ( CG ( active_op_array ) - > arg_info [ - 1 ] . class_name ) ) ;
}
}
CG ( active_op_array ) - > fn_flags | = ZEND_ACC_GENERATOR ;
}
/* }}} */
2014-12-13 22:06:14 +00:00
ZEND_API void zend_do_delayed_early_binding ( const zend_op_array * op_array ) /* { { { */
2001-08-30 15:26:30 +00:00
{
2014-12-12 18:57:34 +00:00
if ( op_array - > early_binding ! = ( uint32_t ) - 1 ) {
2008-03-18 08:36:30 +00:00
zend_bool orig_in_compilation = CG ( in_compilation ) ;
2014-08-25 19:21:16 +00:00
uint32_t opline_num = op_array - > early_binding ;
2014-02-10 06:04:30 +00:00
zend_class_entry * ce ;
2006-05-09 23:53:23 +00:00
2008-03-18 08:36:30 +00:00
CG ( in_compilation ) = 1 ;
2014-12-12 18:57:34 +00:00
while ( opline_num ! = ( uint32_t ) - 1 ) {
2015-02-03 14:39:05 +00:00
zval * parent_name = RT_CONSTANT ( op_array , op_array - > opcodes [ opline_num - 1 ] . op2 ) ;
if ( ( ce = zend_lookup_class_ex ( Z_STR_P ( parent_name ) , parent_name + 1 , 0 ) ) ! = NULL ) {
2014-12-13 22:06:14 +00:00
do_bind_inherited_class ( op_array , & op_array - > opcodes [ opline_num ] , EG ( class_table ) , ce , 0 ) ;
2008-03-18 08:36:30 +00:00
}
2010-04-20 10:57:45 +00:00
opline_num = op_array - > opcodes [ opline_num ] . result . opline_num ;
2008-03-18 08:36:30 +00:00
}
CG ( in_compilation ) = orig_in_compilation ;
}
2001-08-30 15:26:30 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
2001-08-30 15:26:30 +00:00
2014-09-15 22:23:58 +00:00
ZEND_API zend_string * zend_mangle_property_name ( const char * src1 , size_t src1_length , const char * src2 , size_t src2_length , int internal ) /* { { { */
1999-07-08 16:55:27 +00:00
{
2014-09-15 22:23:58 +00:00
size_t prop_name_length = 1 + src1_length + 1 + src2_length ;
zend_string * prop_name = zend_string_alloc ( prop_name_length , internal ) ;
1999-12-23 19:23:36 +00:00
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( prop_name ) [ 0 ] = ' \0 ' ;
memcpy ( ZSTR_VAL ( prop_name ) + 1 , src1 , src1_length + 1 ) ;
memcpy ( ZSTR_VAL ( prop_name ) + 1 + src1_length + 1 , src2 , src2_length + 1 ) ;
2014-02-17 13:59:18 +00:00
return prop_name ;
2002-02-21 11:50:44 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-12-23 19:23:36 +00:00
2015-04-28 03:30:25 +00:00
static zend_always_inline size_t zend_strnlen ( const char * s , size_t maxlen ) /* { { { */
2005-09-16 17:05:09 +00:00
{
2014-09-15 22:23:58 +00:00
size_t len = 0 ;
2006-07-24 17:58:32 +00:00
while ( * s + + & & maxlen - - ) len + + ;
return len ;
1999-07-08 16:55:27 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-07-08 16:55:27 +00:00
2014-09-15 22:23:58 +00:00
ZEND_API int zend_unmangle_property_name_ex ( const zend_string * name , const char * * class_name , const char * * prop_name , size_t * prop_len ) /* { { { */
1999-07-27 20:34:31 +00:00
{
2014-09-15 22:23:58 +00:00
size_t class_name_len ;
2015-08-06 15:17:53 +00:00
size_t anonclass_src_len ;
2003-09-03 21:21:18 +00:00
2006-07-24 17:58:32 +00:00
* class_name = NULL ;
2005-02-23 11:15:51 +00:00
2016-04-03 11:38:25 +00:00
if ( ! ZSTR_LEN ( name ) | | ZSTR_VAL ( name ) [ 0 ] ! = ' \0 ' ) {
2015-06-30 10:59:27 +00:00
* prop_name = ZSTR_VAL ( name ) ;
2013-01-14 08:23:22 +00:00
if ( prop_len ) {
2015-06-30 10:59:27 +00:00
* prop_len = ZSTR_LEN ( name ) ;
2005-12-17 15:51:52 +00:00
}
2006-07-24 17:58:32 +00:00
return SUCCESS ;
2002-06-23 15:46:58 +00:00
}
2015-06-30 10:59:27 +00:00
if ( ZSTR_LEN ( name ) < 3 | | ZSTR_VAL ( name ) [ 1 ] = = ' \0 ' ) {
2006-07-24 17:58:32 +00:00
zend_error ( E_NOTICE , " Illegal member variable name " ) ;
2015-06-30 10:59:27 +00:00
* prop_name = ZSTR_VAL ( name ) ;
2013-01-14 08:23:22 +00:00
if ( prop_len ) {
2015-06-30 10:59:27 +00:00
* prop_len = ZSTR_LEN ( name ) ;
2014-02-17 13:59:18 +00:00
}
2006-07-24 17:58:32 +00:00
return FAILURE ;
2003-06-08 18:53:58 +00:00
}
2014-02-10 06:04:30 +00:00
2015-06-30 10:59:27 +00:00
class_name_len = zend_strnlen ( ZSTR_VAL ( name ) + 1 , ZSTR_LEN ( name ) - 2 ) ;
if ( class_name_len > = ZSTR_LEN ( name ) - 2 | | ZSTR_VAL ( name ) [ class_name_len + 1 ] ! = ' \0 ' ) {
2006-07-24 17:58:32 +00:00
zend_error ( E_NOTICE , " Corrupt member variable name " ) ;
2015-06-30 10:59:27 +00:00
* prop_name = ZSTR_VAL ( name ) ;
2013-01-14 08:23:22 +00:00
if ( prop_len ) {
2015-06-30 10:59:27 +00:00
* prop_len = ZSTR_LEN ( name ) ;
2003-09-03 21:21:18 +00:00
}
2006-07-24 17:58:32 +00:00
return FAILURE ;
2003-09-03 21:21:18 +00:00
}
2014-09-15 22:23:58 +00:00
2015-06-30 10:59:27 +00:00
* class_name = ZSTR_VAL ( name ) + 1 ;
2015-08-06 15:17:53 +00:00
anonclass_src_len = zend_strnlen ( * class_name + class_name_len + 1 , ZSTR_LEN ( name ) - class_name_len - 2 ) ;
if ( class_name_len + anonclass_src_len + 2 ! = ZSTR_LEN ( name ) ) {
class_name_len + = anonclass_src_len + 1 ;
}
2015-06-30 10:59:27 +00:00
* prop_name = ZSTR_VAL ( name ) + class_name_len + 2 ;
2013-01-14 08:23:22 +00:00
if ( prop_len ) {
2015-06-30 10:59:27 +00:00
* prop_len = ZSTR_LEN ( name ) - class_name_len - 2 ;
2013-01-14 08:23:22 +00:00
}
2006-07-24 17:58:32 +00:00
return SUCCESS ;
1999-07-27 20:34:31 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-07-27 20:34:31 +00:00
2014-12-13 22:06:14 +00:00
static zend_constant * zend_lookup_reserved_const ( const char * name , size_t len ) /* { { { */
2002-12-06 17:09:44 +00:00
{
2014-09-28 21:17:29 +00:00
zend_constant * c = zend_hash_find_ptr_lc ( EG ( zend_constants ) , name , len ) ;
if ( c & & ! ( c - > flags & CONST_CS ) & & ( c - > flags & CONST_CT_SUBST ) ) {
2008-07-25 04:54:08 +00:00
return c ;
2002-12-06 17:09:44 +00:00
}
2007-09-28 19:52:53 +00:00
return NULL ;
2002-12-06 17:09:44 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
2002-12-06 17:09:44 +00:00
2014-12-13 22:06:14 +00:00
static zend_bool zend_try_ct_eval_const ( zval * zv , zend_string * name , zend_bool is_fully_qualified ) /* { { { */
2002-12-06 17:09:44 +00:00
{
2014-09-28 21:17:29 +00:00
zend_constant * c ;
2014-02-17 13:59:18 +00:00
2015-02-10 14:43:23 +00:00
/* Substitute case-sensitive (or lowercase) constants */
c = zend_hash_find_ptr ( EG ( zend_constants ) , name ) ;
if ( c & & (
2015-02-10 21:17:43 +00:00
( ( c - > flags & CONST_PERSISTENT ) & & ! ( CG ( compiler_options ) & ZEND_COMPILE_NO_PERSISTENT_CONSTANT_SUBSTITUTION ) )
| | ( Z_TYPE ( c - > value ) < IS_OBJECT & & ! ( CG ( compiler_options ) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION ) )
) ) {
2015-02-10 14:43:23 +00:00
ZVAL_DUP ( zv , & c - > value ) ;
return 1 ;
2014-02-17 13:59:18 +00:00
}
2014-09-28 21:17:29 +00:00
{
/* Substitute true, false and null (including unqualified usage in namespaces) */
2015-06-30 10:59:27 +00:00
const char * lookup_name = ZSTR_VAL ( name ) ;
size_t lookup_len = ZSTR_LEN ( name ) ;
2014-09-28 21:17:29 +00:00
if ( ! is_fully_qualified ) {
zend_get_unqualified_name ( name , & lookup_name , & lookup_len ) ;
}
2014-12-13 22:06:14 +00:00
c = zend_lookup_reserved_const ( lookup_name , lookup_len ) ;
2014-09-28 21:17:29 +00:00
if ( c ) {
ZVAL_DUP ( zv , & c - > value ) ;
return 1 ;
}
2014-02-17 13:59:18 +00:00
}
2014-09-28 21:17:29 +00:00
2006-03-15 09:04:36 +00:00
return 0 ;
2002-12-06 17:09:44 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
2002-12-06 17:09:44 +00:00
2015-05-05 17:52:03 +00:00
static inline zend_bool zend_is_scope_known ( ) /* { { { */
{
if ( CG ( active_op_array ) - > fn_flags & ZEND_ACC_CLOSURE ) {
/* Closures can be rebound to a different scope */
return 0 ;
}
if ( ! CG ( active_class_entry ) ) {
2015-05-21 19:07:05 +00:00
/* The scope is known if we're in a free function (no scope), but not if we're in
* a file / eval ( which inherits including / eval ' ing scope ) . */
return CG ( active_op_array ) - > function_name ! = NULL ;
2015-05-05 17:52:03 +00:00
}
/* For traits self etc refers to the using class, not the trait itself */
return ( CG ( active_class_entry ) - > ce_flags & ZEND_ACC_TRAIT ) = = 0 ;
}
/* }}} */
static inline zend_bool class_name_refers_to_active_ce ( zend_string * class_name , uint32_t fetch_type ) /* { { { */
{
if ( ! CG ( active_class_entry ) ) {
return 0 ;
}
if ( fetch_type = = ZEND_FETCH_CLASS_SELF & & zend_is_scope_known ( ) ) {
return 1 ;
}
return fetch_type = = ZEND_FETCH_CLASS_DEFAULT
& & zend_string_equals_ci ( class_name , CG ( active_class_entry ) - > name ) ;
}
/* }}} */
2015-05-25 20:58:30 +00:00
uint32_t zend_get_class_fetch_type ( zend_string * name ) /* { { { */
{
if ( zend_string_equals_literal_ci ( name , " self " ) ) {
return ZEND_FETCH_CLASS_SELF ;
} else if ( zend_string_equals_literal_ci ( name , " parent " ) ) {
return ZEND_FETCH_CLASS_PARENT ;
} else if ( zend_string_equals_literal_ci ( name , " static " ) ) {
return ZEND_FETCH_CLASS_STATIC ;
} else {
return ZEND_FETCH_CLASS_DEFAULT ;
}
}
/* }}} */
static uint32_t zend_get_class_fetch_type_ast ( zend_ast * name_ast ) /* { { { */
{
/* Fully qualified names are always default refs */
if ( name_ast - > attr = = ZEND_NAME_FQ ) {
return ZEND_FETCH_CLASS_DEFAULT ;
}
return zend_get_class_fetch_type ( zend_ast_get_str ( name_ast ) ) ;
}
/* }}} */
static void zend_ensure_valid_class_fetch_type ( uint32_t fetch_type ) /* { { { */
{
if ( fetch_type ! = ZEND_FETCH_CLASS_DEFAULT & & ! CG ( active_class_entry ) & & zend_is_scope_known ( ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use \" %s \" when no class scope is active " ,
fetch_type = = ZEND_FETCH_CLASS_SELF ? " self " :
fetch_type = = ZEND_FETCH_CLASS_PARENT ? " parent " : " static " ) ;
}
}
/* }}} */
static zend_bool zend_try_compile_const_expr_resolve_class_name ( zval * zv , zend_ast * class_ast , zend_ast * name_ast , zend_bool constant ) /* { { { */
{
uint32_t fetch_type ;
if ( name_ast - > kind ! = ZEND_AST_ZVAL ) {
return 0 ;
}
if ( ! zend_string_equals_literal_ci ( zend_ast_get_str ( name_ast ) , " class " ) ) {
return 0 ;
}
if ( class_ast - > kind ! = ZEND_AST_ZVAL ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
" Dynamic class names are not allowed in compile-time ::class fetch " ) ;
}
fetch_type = zend_get_class_fetch_type ( zend_ast_get_str ( class_ast ) ) ;
zend_ensure_valid_class_fetch_type ( fetch_type ) ;
switch ( fetch_type ) {
case ZEND_FETCH_CLASS_SELF :
if ( constant | | ( CG ( active_class_entry ) & & zend_is_scope_known ( ) ) ) {
ZVAL_STR_COPY ( zv , CG ( active_class_entry ) - > name ) ;
} else {
ZVAL_NULL ( zv ) ;
}
return 1 ;
case ZEND_FETCH_CLASS_STATIC :
case ZEND_FETCH_CLASS_PARENT :
if ( constant ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
" %s::class cannot be used for compile-time class name resolution " ,
fetch_type = = ZEND_FETCH_CLASS_STATIC ? " static " : " parent "
) ;
} else {
ZVAL_NULL ( zv ) ;
}
return 1 ;
case ZEND_FETCH_CLASS_DEFAULT :
ZVAL_STR ( zv , zend_resolve_class_name_ast ( class_ast ) ) ;
return 1 ;
EMPTY_SWITCH_DEFAULT_CASE ( )
}
}
/* }}} */
2015-02-10 14:43:23 +00:00
static zend_bool zend_try_ct_eval_class_const ( zval * zv , zend_string * class_name , zend_string * name ) /* { { { */
{
uint32_t fetch_type = zend_get_class_fetch_type ( class_name ) ;
zval * c ;
2015-05-05 17:52:03 +00:00
if ( class_name_refers_to_active_ce ( class_name , fetch_type ) ) {
2015-02-10 14:43:23 +00:00
c = zend_hash_find ( & CG ( active_class_entry ) - > constants_table , name ) ;
} else if ( fetch_type = = ZEND_FETCH_CLASS_DEFAULT & & ! ( CG ( compiler_options ) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION ) ) {
2015-06-30 10:59:27 +00:00
zend_class_entry * ce = zend_hash_find_ptr_lc ( CG ( class_table ) , ZSTR_VAL ( class_name ) , ZSTR_LEN ( class_name ) ) ;
2015-02-10 14:43:23 +00:00
if ( ce ) {
c = zend_hash_find ( & ce - > constants_table , name ) ;
} else {
return 0 ;
}
} else {
return 0 ;
}
2015-02-10 21:17:43 +00:00
if ( CG ( compiler_options ) & ZEND_COMPILE_NO_PERSISTENT_CONSTANT_SUBSTITUTION ) {
return 0 ;
}
2015-02-10 14:43:23 +00:00
/* Substitute case-sensitive (or lowercase) persistent class constants */
if ( c & & Z_TYPE_P ( c ) < IS_OBJECT ) {
ZVAL_DUP ( zv , c ) ;
return 1 ;
}
return 0 ;
}
2015-02-13 05:18:14 +00:00
/* }}} */
2015-02-10 14:43:23 +00:00
2015-05-24 19:56:49 +00:00
static void zend_add_to_list ( void * result , void * item ) /* { { { */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
{
void * * list = * ( void * * ) result ;
size_t n = 0 ;
2012-08-28 12:06:18 +00:00
2012-12-25 06:23:08 +00:00
if ( list ) {
while ( list [ n ] ) {
n + + ;
}
2004-02-25 09:25:37 +00:00
}
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
list = erealloc ( list , sizeof ( void * ) * ( n + 2 ) ) ;
2004-02-12 13:49:55 +00:00
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
list [ n ] = item ;
list [ n + 1 ] = NULL ;
2013-09-26 16:39:17 +00:00
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
* ( void * * ) result = list ;
}
/* }}} */
2013-09-26 16:39:17 +00:00
2014-12-13 22:06:14 +00:00
void zend_do_extended_info ( void ) /* { { { */
1999-04-07 18:10:10 +00:00
{
zend_op * opline ;
2013-09-26 16:39:17 +00:00
2008-03-18 08:36:30 +00:00
if ( ! ( CG ( compiler_options ) & ZEND_COMPILE_EXTENDED_INFO ) ) {
1999-04-07 18:10:10 +00:00
return ;
}
2013-09-26 16:39:17 +00:00
2014-12-13 22:06:14 +00:00
opline = get_next_op ( CG ( active_op_array ) ) ;
2007-11-09 13:34:39 +00:00
1999-04-07 18:10:10 +00:00
opline - > opcode = ZEND_EXT_STMT ;
SET_UNUSED ( opline - > op1 ) ;
SET_UNUSED ( opline - > op2 ) ;
}
2009-07-27 14:11:53 +00:00
/* }}} */
2012-03-02 03:32:12 +00:00
2014-12-13 22:06:14 +00:00
void zend_do_extended_fcall_begin ( void ) /* { { { */
1999-04-07 18:10:10 +00:00
{
zend_op * opline ;
2012-03-02 03:32:12 +00:00
2008-03-18 08:36:30 +00:00
if ( ! ( CG ( compiler_options ) & ZEND_COMPILE_EXTENDED_INFO ) ) {
1999-04-07 18:10:10 +00:00
return ;
}
2012-03-02 03:32:12 +00:00
2014-12-13 22:06:14 +00:00
opline = get_next_op ( CG ( active_op_array ) ) ;
2012-03-02 03:32:12 +00:00
1999-04-07 18:10:10 +00:00
opline - > opcode = ZEND_EXT_FCALL_BEGIN ;
SET_UNUSED ( opline - > op1 ) ;
SET_UNUSED ( opline - > op2 ) ;
}
2009-07-27 14:11:53 +00:00
/* }}} */
2012-03-02 03:32:12 +00:00
2014-12-13 22:06:14 +00:00
void zend_do_extended_fcall_end ( void ) /* { { { */
1999-04-07 18:10:10 +00:00
{
zend_op * opline ;
2012-03-02 03:32:12 +00:00
2008-03-18 08:36:30 +00:00
if ( ! ( CG ( compiler_options ) & ZEND_COMPILE_EXTENDED_INFO ) ) {
1999-04-07 18:10:10 +00:00
return ;
}
2006-05-09 23:53:23 +00:00
2014-12-13 22:06:14 +00:00
opline = get_next_op ( CG ( active_op_array ) ) ;
1999-04-07 18:10:10 +00:00
opline - > opcode = ZEND_EXT_FCALL_END ;
SET_UNUSED ( opline - > op1 ) ;
SET_UNUSED ( opline - > op2 ) ;
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2015-02-13 05:18:14 +00:00
zend_bool zend_is_auto_global_str ( char * name , size_t len ) /* { { { */ {
zend_auto_global * auto_global ;
2004-02-02 12:28:19 +00:00
2015-02-13 05:18:14 +00:00
if ( ( auto_global = zend_hash_str_find_ptr ( CG ( auto_globals ) , name , len ) ) ! = NULL ) {
if ( auto_global - > armed ) {
auto_global - > armed = auto_global - > auto_global_callback ( auto_global - > name ) ;
2013-01-28 02:02:51 +00:00
}
2015-02-13 05:18:14 +00:00
return 1 ;
2004-02-02 12:28:19 +00:00
}
2015-02-13 05:18:14 +00:00
return 0 ;
1999-04-07 18:10:10 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_bool zend_is_auto_global ( zend_string * name ) /* { { { */
2003-03-02 13:33:31 +00:00
{
zend_auto_global * auto_global ;
2014-02-10 06:04:30 +00:00
if ( ( auto_global = zend_hash_find_ptr ( CG ( auto_globals ) , name ) ) ! = NULL ) {
2003-03-02 13:33:31 +00:00
if ( auto_global - > armed ) {
2014-12-13 22:06:14 +00:00
auto_global - > armed = auto_global - > auto_global_callback ( auto_global - > name ) ;
2013-01-28 02:02:51 +00:00
}
2003-03-02 13:33:31 +00:00
return 1 ;
}
return 0 ;
}
2009-07-27 14:11:53 +00:00
/* }}} */
2003-03-02 13:33:31 +00:00
2014-12-13 22:06:14 +00:00
int zend_register_auto_global ( zend_string * name , zend_bool jit , zend_auto_global_callback auto_global_callback ) /* { { { */
2001-08-08 17:18:16 +00:00
{
2003-03-02 10:04:53 +00:00
zend_auto_global auto_global ;
2014-04-10 11:50:25 +00:00
int retval ;
2003-03-02 10:04:53 +00:00
2014-12-13 22:06:14 +00:00
auto_global . name = zend_new_interned_string ( name ) ;
2003-03-02 10:04:53 +00:00
auto_global . auto_global_callback = auto_global_callback ;
2010-07-08 14:05:11 +00:00
auto_global . jit = jit ;
2003-03-02 10:04:53 +00:00
2014-12-29 06:35:08 +00:00
retval = zend_hash_add_mem ( CG ( auto_globals ) , auto_global . name , & auto_global , sizeof ( zend_auto_global ) ) ! = NULL ? SUCCESS : FAILURE ;
2014-04-10 11:50:25 +00:00
2014-12-29 06:35:08 +00:00
zend_string_release ( name ) ;
2014-04-10 11:50:25 +00:00
return retval ;
2001-08-08 17:18:16 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
2001-08-08 17:18:16 +00:00
2014-12-13 22:06:14 +00:00
ZEND_API void zend_activate_auto_globals ( void ) /* { { { */
2010-07-08 14:05:11 +00:00
{
2014-07-22 14:55:34 +00:00
zend_auto_global * auto_global ;
ZEND_HASH_FOREACH_PTR ( CG ( auto_globals ) , auto_global ) {
if ( auto_global - > jit ) {
auto_global - > armed = 1 ;
} else if ( auto_global - > auto_global_callback ) {
2014-12-13 22:06:14 +00:00
auto_global - > armed = auto_global - > auto_global_callback ( auto_global - > name ) ;
2002-11-23 20:44:12 +00:00
} else {
2014-07-22 14:55:34 +00:00
auto_global - > armed = 0 ;
2005-05-26 13:46:17 +00:00
}
2014-07-22 14:55:34 +00:00
} ZEND_HASH_FOREACH_END ( ) ;
2010-07-08 14:05:11 +00:00
}
/* }}} */
2010-11-03 15:40:24 +00:00
2014-12-13 22:06:14 +00:00
int zendlex ( zend_parser_stack_elem * elem ) /* { { { */
1999-04-07 18:10:10 +00:00
{
2014-07-26 18:54:41 +00:00
zval zv ;
1999-04-07 18:10:10 +00:00
int retval ;
2001-08-06 14:36:46 +00:00
if ( CG ( increment_lineno ) ) {
CG ( zend_lineno ) + + ;
CG ( increment_lineno ) = 0 ;
}
2007-05-18 13:12:05 +00:00
again :
2014-07-26 18:54:41 +00:00
ZVAL_UNDEF ( & zv ) ;
2014-12-13 22:06:14 +00:00
retval = lex_scan ( & zv ) ;
2015-07-09 20:59:31 +00:00
if ( EG ( exception ) ) {
return T_ERROR ;
}
2002-11-30 11:20:25 +00:00
switch ( retval ) {
1999-04-22 23:08:42 +00:00
case T_COMMENT :
2003-04-02 16:13:12 +00:00
case T_DOC_COMMENT :
1999-04-22 23:08:42 +00:00
case T_OPEN_TAG :
1999-04-07 18:10:10 +00:00
case T_WHITESPACE :
2003-05-29 09:01:55 +00:00
goto again ;
1999-04-22 23:08:42 +00:00
case T_CLOSE_TAG :
2007-05-18 13:12:05 +00:00
if ( LANG_SCNG ( yy_text ) [ LANG_SCNG ( yy_leng ) - 1 ] ! = ' > ' ) {
2001-08-06 14:36:46 +00:00
CG ( increment_lineno ) = 1 ;
}
1999-04-07 18:10:10 +00:00
retval = ' ; ' ; /* implicit ; */
break ;
1999-04-22 23:08:42 +00:00
case T_OPEN_TAG_WITH_ECHO :
retval = T_ECHO ;
1999-04-07 18:10:10 +00:00
break ;
}
2014-07-26 18:54:41 +00:00
if ( Z_TYPE ( zv ) ! = IS_UNDEF ) {
2014-07-27 10:45:38 +00:00
elem - > ast = zend_ast_create_zval ( & zv ) ;
2014-07-26 18:54:41 +00:00
}
2006-05-09 23:53:23 +00:00
1999-04-07 18:10:10 +00:00
return retval ;
}
2009-07-27 14:11:53 +00:00
/* }}} */
2003-02-01 01:49:15 +00:00
2014-12-13 22:06:14 +00:00
ZEND_API void zend_initialize_class_data ( zend_class_entry * ce , zend_bool nullify_handlers ) /* { { { */
2003-02-10 16:11:24 +00:00
{
2003-02-10 16:46:05 +00:00
zend_bool persistent_hashes = ( ce - > type = = ZEND_INTERNAL_CLASS ) ? 1 : 0 ;
2003-11-13 06:40:34 +00:00
dtor_func_t zval_ptr_dtor_func = ( ( persistent_hashes ) ? ZVAL_INTERNAL_PTR_DTOR : ZVAL_PTR_DTOR ) ;
2003-02-10 16:46:05 +00:00
2003-02-10 16:11:24 +00:00
ce - > refcount = 1 ;
2014-07-22 14:55:34 +00:00
ce - > ce_flags = ZEND_ACC_CONSTANTS_UPDATED ;
2003-03-31 20:42:01 +00:00
2015-09-20 05:23:36 +00:00
if ( CG ( compiler_options ) & ZEND_COMPILE_GUARDS ) {
ce - > ce_flags | = ZEND_ACC_USE_GUARDS ;
}
2010-05-24 14:11:39 +00:00
ce - > default_properties_table = NULL ;
ce - > default_static_members_table = NULL ;
2015-03-04 14:41:01 +00:00
zend_hash_init_ex ( & ce - > properties_info , 8 , NULL , ( persistent_hashes ? zend_destroy_property_info_internal : NULL ) , persistent_hashes , 0 ) ;
2014-04-21 14:25:34 +00:00
zend_hash_init_ex ( & ce - > constants_table , 8 , NULL , zval_ptr_dtor_func , persistent_hashes , 0 ) ;
zend_hash_init_ex ( & ce - > function_table , 8 , NULL , ZEND_FUNCTION_DTOR , persistent_hashes , 0 ) ;
2003-02-10 16:11:24 +00:00
2005-12-01 11:48:17 +00:00
if ( ce - > type = = ZEND_INTERNAL_CLASS ) {
# ifdef ZTS
int n = zend_hash_num_elements ( CG ( class_table ) ) ;
2010-05-24 17:07:52 +00:00
if ( CG ( static_members_table ) & & n > = CG ( last_static_member ) ) {
2005-12-01 11:48:17 +00:00
/* Support for run-time declaration: dl() */
CG ( last_static_member ) = n + 1 ;
2014-04-09 19:40:01 +00:00
CG ( static_members_table ) = realloc ( CG ( static_members_table ) , ( n + 1 ) * sizeof ( zval * ) ) ;
2010-05-24 17:07:52 +00:00
CG ( static_members_table ) [ n ] = NULL ;
2003-03-29 11:19:38 +00:00
}
2014-04-09 19:40:01 +00:00
ce - > static_members_table = ( zval * ) ( zend_intptr_t ) n ;
2005-12-01 11:48:17 +00:00
# else
2010-05-24 14:11:39 +00:00
ce - > static_members_table = NULL ;
2005-12-01 11:48:17 +00:00
# endif
} else {
2010-05-24 17:07:52 +00:00
ce - > static_members_table = ce - > default_static_members_table ;
2010-09-15 07:38:52 +00:00
ce - > info . user . doc_comment = NULL ;
2003-07-16 09:13:47 +00:00
}
2004-02-25 09:25:37 +00:00
2010-05-24 14:11:39 +00:00
ce - > default_properties_count = 0 ;
ce - > default_static_members_count = 0 ;
2003-02-10 16:11:24 +00:00
if ( nullify_handlers ) {
ce - > constructor = NULL ;
ce - > destructor = NULL ;
ce - > clone = NULL ;
ce - > __get = NULL ;
ce - > __set = NULL ;
2005-07-07 16:07:09 +00:00
ce - > __unset = NULL ;
ce - > __isset = NULL ;
2003-02-10 16:11:24 +00:00
ce - > __call = NULL ;
2007-09-29 08:52:40 +00:00
ce - > __callstatic = NULL ;
2006-05-09 23:53:23 +00:00
ce - > __tostring = NULL ;
2003-02-10 16:11:24 +00:00
ce - > create_object = NULL ;
2003-12-28 15:18:05 +00:00
ce - > get_iterator = NULL ;
ce - > iterator_funcs . funcs = NULL ;
ce - > interface_gets_implemented = NULL ;
2007-09-29 09:34:24 +00:00
ce - > get_static_method = NULL ;
2003-12-28 15:18:05 +00:00
ce - > parent = NULL ;
ce - > num_interfaces = 0 ;
ce - > interfaces = NULL ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
ce - > num_traits = 0 ;
ce - > traits = NULL ;
ce - > trait_aliases = NULL ;
ce - > trait_precedences = NULL ;
2005-02-23 11:15:51 +00:00
ce - > serialize = NULL ;
ce - > unserialize = NULL ;
2005-03-07 22:23:14 +00:00
ce - > serialize_func = NULL ;
ce - > unserialize_func = NULL ;
2014-02-20 01:07:34 +00:00
ce - > __debugInfo = NULL ;
2010-09-15 07:38:52 +00:00
if ( ce - > type = = ZEND_INTERNAL_CLASS ) {
ce - > info . internal . module = NULL ;
ce - > info . internal . builtin_functions = NULL ;
}
2003-02-10 16:11:24 +00:00
}
2003-03-29 11:19:38 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
2003-03-29 11:19:38 +00:00
2014-08-25 19:21:16 +00:00
ZEND_API zend_string * zend_get_compiled_variable_name ( const zend_op_array * op_array , uint32_t var ) /* { { { */
2011-09-23 15:08:11 +00:00
{
2014-03-27 12:00:25 +00:00
return op_array - > vars [ EX_VAR_TO_NUM ( var ) ] ;
2005-01-22 02:29:18 +00:00
}
2009-07-27 14:11:53 +00:00
/* }}} */
2011-09-23 15:08:11 +00:00
2014-08-29 05:05:58 +00:00
zend_ast * zend_ast_append_str ( zend_ast * left_ast , zend_ast * right_ast ) /* { { { */
{
2014-07-26 19:53:50 +00:00
zval * left_zv = zend_ast_get_zval ( left_ast ) ;
zend_string * left = Z_STR_P ( left_zv ) ;
zend_string * right = zend_ast_get_str ( right_ast ) ;
2007-12-07 17:11:24 +00:00
2014-07-26 19:53:50 +00:00
zend_string * result ;
2015-06-30 10:59:27 +00:00
size_t left_len = ZSTR_LEN ( left ) ;
size_t len = left_len + ZSTR_LEN ( right ) + 1 ; /* left\right */
2014-07-26 19:53:50 +00:00
2015-03-19 23:02:42 +00:00
result = zend_string_extend ( left , len , 0 ) ;
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( result ) [ left_len ] = ' \\ ' ;
memcpy ( & ZSTR_VAL ( result ) [ left_len + 1 ] , ZSTR_VAL ( right ) , ZSTR_LEN ( right ) ) ;
ZSTR_VAL ( result ) [ len ] = ' \0 ' ;
2014-08-25 19:21:16 +00:00
zend_string_release ( right ) ;
2014-07-26 19:53:50 +00:00
ZVAL_STR ( left_zv , result ) ;
return left_ast ;
2007-09-28 19:52:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2007-09-28 19:52:53 +00:00
2014-12-13 22:06:14 +00:00
void zend_verify_namespace ( void ) /* { { { */
2007-09-28 19:52:53 +00:00
{
2015-04-20 18:16:58 +00:00
if ( FC ( has_bracketed_namespaces ) & & ! FC ( in_namespace ) ) {
2013-10-19 21:22:20 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " No code may exist outside of namespace {} " ) ;
2011-09-23 15:08:11 +00:00
}
2008-11-25 09:56:32 +00:00
}
/* }}} */
2013-01-28 02:02:51 +00:00
2008-02-12 01:17:48 +00:00
/* {{{ zend_dirname
Returns directory name component of path */
2008-02-12 00:21:15 +00:00
ZEND_API size_t zend_dirname ( char * path , size_t len )
{
register char * end = path + len - 1 ;
unsigned int len_adjust = 0 ;
2011-09-23 15:08:11 +00:00
2015-07-04 16:55:22 +00:00
# ifdef ZEND_WIN32
2008-02-12 00:21:15 +00:00
/* Note that on Win32 CWD is per drive (heritage from CP/M).
* This means dirname ( " c:foo " ) maps to " c:. " or " c: " - which means CWD on C : drive .
*/
if ( ( 2 < = len ) & & isalpha ( ( int ) ( ( unsigned char * ) path ) [ 0 ] ) & & ( ' : ' = = path [ 1 ] ) ) {
/* Skip over the drive spec (if any) so as not to change */
path + = 2 ;
len_adjust + = 2 ;
if ( 2 = = len ) {
/* Return "c:" on Win32 for dirname("c:").
2013-01-28 02:02:51 +00:00
* It would be more consistent to return " c:. "
2008-02-12 00:21:15 +00:00
* but that would require making the string * longer * .
*/
return len ;
}
}
# elif defined(NETWARE)
/*
2013-06-10 21:20:18 +00:00
* Find the first occurrence of : from the left
2008-02-12 00:21:15 +00:00
* move the path pointer to the position just after :
* increment the len_adjust to the length of path till colon character ( inclusive )
* If there is no character beyond : simple return len
*/
char * colonpos = NULL ;
colonpos = strchr ( path , ' : ' ) ;
if ( colonpos ! = NULL ) {
len_adjust = ( ( colonpos - path ) + 1 ) ;
path + = len_adjust ;
if ( len_adjust = = len ) {
return len ;
}
2011-01-19 17:17:52 +00:00
}
2008-02-12 00:21:15 +00:00
# endif
if ( len = = 0 ) {
/* Illegal use of this function */
return 0 ;
}
/* Strip trailing slashes */
while ( end > = path & & IS_SLASH_P ( end ) ) {
end - - ;
}
if ( end < path ) {
/* The path only contained slashes */
path [ 0 ] = DEFAULT_SLASH ;
path [ 1 ] = ' \0 ' ;
return 1 + len_adjust ;
}
/* Strip filename */
while ( end > = path & & ! IS_SLASH_P ( end ) ) {
end - - ;
}
if ( end < path ) {
/* No slash found, therefore return '.' */
# ifdef NETWARE
if ( len_adjust = = 0 ) {
path [ 0 ] = ' . ' ;
path [ 1 ] = ' \0 ' ;
2008-08-03 11:48:20 +00:00
return 1 ; /* only one character */
2008-02-12 00:21:15 +00:00
} else {
path [ 0 ] = ' \0 ' ;
return len_adjust ;
}
# else
path [ 0 ] = ' . ' ;
path [ 1 ] = ' \0 ' ;
return 1 + len_adjust ;
# endif
}
/* Strip slashes which came before the file name */
while ( end > = path & & IS_SLASH_P ( end ) ) {
end - - ;
}
if ( end < path ) {
path [ 0 ] = DEFAULT_SLASH ;
path [ 1 ] = ' \0 ' ;
return 1 + len_adjust ;
}
* ( end + 1 ) = ' \0 ' ;
return ( size_t ) ( end + 1 - path ) + len_adjust ;
}
/* }}} */
2008-02-12 01:17:48 +00:00
2015-01-03 09:22:58 +00:00
static void zend_adjust_for_fetch_type ( zend_op * opline , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
switch ( type & BP_VAR_MASK ) {
case BP_VAR_R :
return ;
case BP_VAR_W :
case BP_VAR_REF :
opline - > opcode + = 3 ;
return ;
case BP_VAR_RW :
opline - > opcode + = 6 ;
return ;
case BP_VAR_IS :
opline - > opcode + = 9 ;
return ;
case BP_VAR_FUNC_ARG :
opline - > opcode + = 12 ;
opline - > extended_value | = type > > BP_VAR_SHIFT ;
return ;
case BP_VAR_UNSET :
opline - > opcode + = 15 ;
return ;
EMPTY_SWITCH_DEFAULT_CASE ( )
}
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-07 11:06:53 +00:00
2015-01-03 09:22:58 +00:00
static inline void zend_make_var_result ( znode * result , zend_op * opline ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-08-15 15:10:06 +00:00
opline - > result_type = IS_VAR ;
opline - > result . var = get_temporary_variable ( CG ( active_op_array ) ) ;
GET_NODE ( result , opline - > result ) ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-08-15 15:10:06 +00:00
2014-12-13 22:06:14 +00:00
static inline void zend_make_tmp_result ( znode * result , zend_op * opline ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-08-15 15:10:06 +00:00
opline - > result_type = IS_TMP_VAR ;
opline - > result . var = get_temporary_variable ( CG ( active_op_array ) ) ;
GET_NODE ( result , opline - > result ) ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2011-09-23 15:08:11 +00:00
2015-01-03 09:22:58 +00:00
static zend_op * zend_emit_op ( znode * result , zend_uchar opcode , znode * op1 , znode * op2 ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-12-13 22:06:14 +00:00
zend_op * opline = get_next_op ( CG ( active_op_array ) ) ;
2014-06-07 11:06:53 +00:00
opline - > opcode = opcode ;
2014-02-10 06:04:30 +00:00
2014-06-07 11:06:53 +00:00
if ( op1 = = NULL ) {
SET_UNUSED ( opline - > op1 ) ;
} else {
SET_NODE ( opline - > op1 , op1 ) ;
}
2011-09-23 15:08:11 +00:00
2014-06-07 11:06:53 +00:00
if ( op2 = = NULL ) {
SET_UNUSED ( opline - > op2 ) ;
} else {
SET_NODE ( opline - > op2 , op2 ) ;
2011-09-23 15:08:11 +00:00
}
2014-08-15 15:10:06 +00:00
if ( result ) {
2014-12-13 22:06:14 +00:00
zend_make_var_result ( result , opline ) ;
2014-06-07 11:06:53 +00:00
}
return opline ;
2013-01-28 02:02:51 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2011-09-23 15:08:11 +00:00
2014-12-13 22:06:14 +00:00
static zend_op * zend_emit_op_tmp ( znode * result , zend_uchar opcode , znode * op1 , znode * op2 ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-12-13 22:06:14 +00:00
zend_op * opline = get_next_op ( CG ( active_op_array ) ) ;
2014-06-14 16:30:18 +00:00
opline - > opcode = opcode ;
2011-01-19 17:17:52 +00:00
2014-06-19 11:57:29 +00:00
if ( op1 = = NULL ) {
SET_UNUSED ( opline - > op1 ) ;
} else {
SET_NODE ( opline - > op1 , op1 ) ;
2004-01-28 10:25:45 +00:00
}
2014-06-14 16:30:18 +00:00
if ( op2 = = NULL ) {
SET_UNUSED ( opline - > op2 ) ;
} else {
SET_NODE ( opline - > op2 , op2 ) ;
2003-02-24 12:05:58 +00:00
}
2014-09-23 21:57:40 +00:00
if ( result ) {
2014-12-13 22:06:14 +00:00
zend_make_tmp_result ( result , opline ) ;
2014-09-23 21:57:40 +00:00
}
2014-06-14 16:30:18 +00:00
return opline ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-14 16:30:18 +00:00
2014-12-13 22:06:14 +00:00
static void zend_emit_tick ( void ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2015-07-07 16:26:14 +00:00
zend_op * opline ;
2015-07-07 13:03:58 +00:00
/* This prevents a double TICK generated by the parser statement of "declare()" */
if ( CG ( active_op_array ) - > last & & CG ( active_op_array ) - > opcodes [ CG ( active_op_array ) - > last - 1 ] . opcode = = ZEND_TICKS ) {
return ;
2008-11-04 15:58:55 +00:00
}
2015-07-07 13:03:58 +00:00
2015-07-07 16:26:14 +00:00
opline = get_next_op ( CG ( active_op_array ) ) ;
2014-07-09 22:00:48 +00:00
opline - > opcode = ZEND_TICKS ;
SET_UNUSED ( opline - > op1 ) ;
SET_UNUSED ( opline - > op2 ) ;
2015-04-20 18:16:58 +00:00
opline - > extended_value = FC ( declarables ) . ticks ;
2014-07-09 22:00:48 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-09 22:00:48 +00:00
2014-12-13 22:06:14 +00:00
static inline zend_op * zend_emit_op_data ( znode * value ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-12-13 22:06:14 +00:00
return zend_emit_op ( NULL , ZEND_OP_DATA , value , NULL ) ;
2014-07-28 10:55:37 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-28 10:55:37 +00:00
2014-12-13 22:06:14 +00:00
static inline uint32_t zend_emit_jump ( uint32_t opnum_target ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-08-25 19:21:16 +00:00
uint32_t opnum = get_next_op_number ( CG ( active_op_array ) ) ;
2014-12-13 22:06:14 +00:00
zend_op * opline = zend_emit_op ( NULL , ZEND_JMP , NULL , NULL ) ;
2014-07-18 17:57:38 +00:00
opline - > op1 . opline_num = opnum_target ;
return opnum ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-18 17:57:38 +00:00
2014-12-13 22:06:14 +00:00
static inline uint32_t zend_emit_cond_jump ( zend_uchar opcode , znode * cond , uint32_t opnum_target ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-08-25 19:21:16 +00:00
uint32_t opnum = get_next_op_number ( CG ( active_op_array ) ) ;
2014-12-13 22:06:14 +00:00
zend_op * opline = zend_emit_op ( NULL , opcode , cond , NULL ) ;
2014-07-18 17:57:38 +00:00
opline - > op2 . opline_num = opnum_target ;
return opnum ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-18 17:57:38 +00:00
2014-12-13 22:06:14 +00:00
static inline void zend_update_jump_target ( uint32_t opnum_jump , uint32_t opnum_target ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-18 14:11:43 +00:00
zend_op * opline = & CG ( active_op_array ) - > opcodes [ opnum_jump ] ;
switch ( opline - > opcode ) {
case ZEND_JMP :
opline - > op1 . opline_num = opnum_target ;
break ;
case ZEND_JMPZ :
case ZEND_JMPNZ :
case ZEND_JMPZ_EX :
case ZEND_JMPNZ_EX :
2015-07-06 15:41:29 +00:00
case ZEND_JMP_SET :
2014-07-18 14:11:43 +00:00
opline - > op2 . opline_num = opnum_target ;
break ;
EMPTY_SWITCH_DEFAULT_CASE ( )
}
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-18 14:11:43 +00:00
2015-01-03 09:22:58 +00:00
static inline void zend_update_jump_target_to_next ( uint32_t opnum_jump ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-12-13 22:06:14 +00:00
zend_update_jump_target ( opnum_jump , get_next_op_number ( CG ( active_op_array ) ) ) ;
2014-07-18 14:11:43 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-18 14:11:43 +00:00
2014-12-13 22:06:14 +00:00
static inline zend_op * zend_delayed_emit_op ( znode * result , zend_uchar opcode , znode * op1 , znode * op2 ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-08-15 15:10:06 +00:00
zend_op tmp_opline ;
2014-12-13 22:06:14 +00:00
init_op ( & tmp_opline ) ;
2014-08-15 15:10:06 +00:00
tmp_opline . opcode = opcode ;
2015-02-02 17:44:16 +00:00
if ( op1 = = NULL ) {
SET_UNUSED ( tmp_opline . op1 ) ;
} else {
SET_NODE ( tmp_opline . op1 , op1 ) ;
}
if ( op2 = = NULL ) {
SET_UNUSED ( tmp_opline . op2 ) ;
} else {
SET_NODE ( tmp_opline . op2 , op2 ) ;
}
2014-08-15 15:10:06 +00:00
if ( result ) {
2014-12-13 22:06:14 +00:00
zend_make_var_result ( result , & tmp_opline ) ;
2002-11-23 20:44:12 +00:00
}
2002-12-07 21:46:12 +00:00
2014-08-15 15:10:06 +00:00
zend_stack_push ( & CG ( delayed_oplines_stack ) , & tmp_opline ) ;
return zend_stack_top ( & CG ( delayed_oplines_stack ) ) ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-08-15 15:10:06 +00:00
2014-12-13 22:06:14 +00:00
static inline uint32_t zend_delayed_compile_begin ( void ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-08-15 15:10:06 +00:00
return zend_stack_count ( & CG ( delayed_oplines_stack ) ) ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-08-15 15:10:06 +00:00
2014-12-13 22:06:14 +00:00
static zend_op * zend_delayed_compile_end ( uint32_t offset ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-11-27 09:52:31 +00:00
zend_op * opline = NULL , * oplines = zend_stack_base ( & CG ( delayed_oplines_stack ) ) ;
2014-08-25 19:21:16 +00:00
uint32_t i , count = zend_stack_count ( & CG ( delayed_oplines_stack ) ) ;
2014-08-15 15:10:06 +00:00
2016-01-07 15:05:17 +00:00
ZEND_ASSERT ( count > = offset ) ;
2014-08-15 15:10:06 +00:00
for ( i = offset ; i < count ; + + i ) {
2014-12-13 22:06:14 +00:00
opline = get_next_op ( CG ( active_op_array ) ) ;
2014-08-15 15:10:06 +00:00
memcpy ( opline , & oplines [ i ] , sizeof ( zend_op ) ) ;
2002-11-23 20:44:12 +00:00
}
2014-08-15 15:10:06 +00:00
CG ( delayed_oplines_stack ) . top = offset ;
return opline ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2002-12-09 12:10:17 +00:00
2015-01-08 20:40:36 +00:00
static void zend_emit_return_type_check ( znode * expr , zend_arg_info * return_info ) /* { { { */
{
if ( return_info - > type_hint ! = IS_UNDEF ) {
2015-02-01 23:20:39 +00:00
zend_op * opline = zend_emit_op ( NULL , ZEND_VERIFY_RETURN_TYPE , expr , NULL ) ;
2015-03-20 15:36:43 +00:00
if ( expr & & expr - > op_type = = IS_CONST ) {
opline - > result_type = expr - > op_type = IS_TMP_VAR ;
opline - > result . var = expr - > u . op . var = get_temporary_variable ( CG ( active_op_array ) ) ;
}
2015-06-17 09:07:43 +00:00
if ( return_info - > class_name ) {
opline - > op2 . num = CG ( active_op_array ) - > cache_size ;
CG ( active_op_array ) - > cache_size + = sizeof ( void * ) ;
} else {
opline - > op2 . num = - 1 ;
}
2015-01-08 20:40:36 +00:00
}
}
/* }}} */
2014-12-13 22:06:14 +00:00
void zend_emit_final_return ( zval * zv ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-26 19:32:48 +00:00
znode zn ;
2015-10-02 09:43:52 +00:00
zend_op * ret ;
2014-07-26 19:32:48 +00:00
zend_bool returns_reference = ( CG ( active_op_array ) - > fn_flags & ZEND_ACC_RETURN_REFERENCE ) ! = 0 ;
2015-01-08 20:40:36 +00:00
if ( CG ( active_op_array ) - > fn_flags & ZEND_ACC_HAS_RETURN_TYPE ) {
zend_emit_return_type_check ( NULL , CG ( active_op_array ) - > arg_info - 1 ) ;
}
2014-07-26 19:32:48 +00:00
zn . op_type = IS_CONST ;
if ( zv ) {
ZVAL_COPY_VALUE ( & zn . u . constant , zv ) ;
2003-01-02 13:58:08 +00:00
} else {
2014-07-26 19:32:48 +00:00
ZVAL_NULL ( & zn . u . constant ) ;
2002-12-09 12:10:17 +00:00
}
2002-12-26 16:27:59 +00:00
2015-10-02 09:43:52 +00:00
ret = zend_emit_op ( NULL , returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN , & zn , NULL ) ;
ret - > extended_value = - 1 ;
2014-07-26 19:32:48 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-26 19:32:48 +00:00
2014-08-29 05:05:58 +00:00
static inline zend_bool zend_is_variable ( zend_ast * ast ) /* { { { */
{
2014-06-19 11:57:29 +00:00
return ast - > kind = = ZEND_AST_VAR | | ast - > kind = = ZEND_AST_DIM
| | ast - > kind = = ZEND_AST_PROP | | ast - > kind = = ZEND_AST_STATIC_PROP
2014-06-07 11:06:53 +00:00
| | ast - > kind = = ZEND_AST_CALL | | ast - > kind = = ZEND_AST_METHOD_CALL
| | ast - > kind = = ZEND_AST_STATIC_CALL ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-07 11:06:53 +00:00
2014-08-29 05:05:58 +00:00
static inline zend_bool zend_is_call ( zend_ast * ast ) /* { { { */
{
2014-06-07 11:06:53 +00:00
return ast - > kind = = ZEND_AST_CALL
| | ast - > kind = = ZEND_AST_METHOD_CALL
| | ast - > kind = = ZEND_AST_STATIC_CALL ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-07 11:06:53 +00:00
2014-08-29 05:05:58 +00:00
static inline zend_bool zend_is_unticked_stmt ( zend_ast * ast ) /* { { { */
{
2015-07-22 11:12:54 +00:00
return ast - > kind = = ZEND_AST_STMT_LIST | | ast - > kind = = ZEND_AST_LABEL
| | ast - > kind = = ZEND_AST_PROP_DECL | | ast - > kind = = ZEND_AST_CLASS_CONST_DECL
| | ast - > kind = = ZEND_AST_USE_TRAIT | | ast - > kind = = ZEND_AST_METHOD ;
2014-07-09 22:00:48 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-09 22:00:48 +00:00
2014-08-29 05:05:58 +00:00
static inline zend_bool zend_can_write_to_variable ( zend_ast * ast ) /* { { { */
{
2014-06-19 11:57:29 +00:00
while ( ast - > kind = = ZEND_AST_DIM | | ast - > kind = = ZEND_AST_PROP ) {
ast = ast - > child [ 0 ] ;
2003-03-29 11:19:38 +00:00
}
2014-06-19 11:57:29 +00:00
return zend_is_variable ( ast ) ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-19 11:57:29 +00:00
2014-08-29 05:05:58 +00:00
static inline zend_bool zend_is_const_default_class_ref ( zend_ast * name_ast ) /* { { { */
{
2014-06-28 16:03:26 +00:00
if ( name_ast - > kind ! = ZEND_AST_ZVAL ) {
2014-06-14 16:30:18 +00:00
return 0 ;
}
2015-04-27 19:14:58 +00:00
return ZEND_FETCH_CLASS_DEFAULT = = zend_get_class_fetch_type_ast ( name_ast ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2003-03-29 11:19:38 +00:00
2014-12-13 22:06:14 +00:00
static inline void zend_handle_numeric_op ( znode * node ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-08-15 15:10:06 +00:00
if ( node - > op_type = = IS_CONST & & Z_TYPE ( node - > u . constant ) = = IS_STRING ) {
zend_ulong index ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-08-15 15:10:06 +00:00
if ( ZEND_HANDLE_NUMERIC ( Z_STR ( node - > u . constant ) , index ) ) {
zval_ptr_dtor ( & node - > u . constant ) ;
ZVAL_LONG ( & node - > u . constant , index ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
}
2014-06-19 11:57:29 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2013-01-28 02:02:51 +00:00
2014-12-13 22:06:14 +00:00
static inline void zend_set_class_name_op1 ( zend_op * opline , znode * class_node ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-19 11:57:29 +00:00
if ( class_node - > op_type = = IS_CONST ) {
opline - > op1_type = IS_CONST ;
2014-07-19 21:30:07 +00:00
opline - > op1 . constant = zend_add_class_name_literal (
2014-12-13 22:06:14 +00:00
CG ( active_op_array ) , Z_STR ( class_node - > u . constant ) ) ;
2014-06-19 11:57:29 +00:00
} else {
SET_NODE ( opline - > op1 , class_node ) ;
}
2002-11-23 20:44:12 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2002-11-23 20:44:12 +00:00
2015-04-01 17:01:57 +00:00
static zend_op * zend_compile_class_ref ( znode * result , zend_ast * name_ast , int throw_exception ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_op * opline ;
2014-07-29 21:17:54 +00:00
znode name_node ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & name_node , name_ast ) ;
2003-02-04 12:12:34 +00:00
2014-07-29 21:17:54 +00:00
if ( name_node . op_type = = IS_CONST ) {
2015-10-24 21:18:28 +00:00
zend_string * name ;
uint32_t fetch_type ;
if ( Z_TYPE ( name_node . u . constant ) ! = IS_STRING ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Illegal class name " ) ;
}
name = Z_STR ( name_node . u . constant ) ;
fetch_type = zend_get_class_fetch_type ( name ) ;
2014-06-14 16:30:18 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( result , ZEND_FETCH_CLASS , NULL , NULL ) ;
2015-04-01 17:01:57 +00:00
opline - > extended_value = fetch_type | ( throw_exception ? ZEND_FETCH_CLASS_EXCEPTION : 0 ) ;
2014-06-14 16:30:18 +00:00
2014-07-19 21:30:07 +00:00
if ( fetch_type = = ZEND_FETCH_CLASS_DEFAULT ) {
2014-08-25 19:21:16 +00:00
uint32_t type = name_ast - > kind = = ZEND_AST_ZVAL ? name_ast - > attr : ZEND_NAME_FQ ;
2014-07-19 21:30:07 +00:00
opline - > op2_type = IS_CONST ;
opline - > op2 . constant = zend_add_class_name_literal ( CG ( active_op_array ) ,
2014-12-13 22:06:14 +00:00
zend_resolve_class_name ( name , type ) ) ;
2015-04-27 19:14:58 +00:00
} else {
zend_ensure_valid_class_fetch_type ( fetch_type ) ;
2003-03-18 16:30:23 +00:00
}
2014-07-29 21:17:54 +00:00
2014-08-25 19:21:16 +00:00
zend_string_release ( name ) ;
2014-06-14 16:30:18 +00:00
} else {
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( result , ZEND_FETCH_CLASS , NULL , & name_node ) ;
2015-04-01 17:01:57 +00:00
opline - > extended_value = ZEND_FETCH_CLASS_DEFAULT | ( throw_exception ? ZEND_FETCH_CLASS_EXCEPTION : 0 ) ;
2003-02-04 12:12:34 +00:00
}
2014-06-14 16:30:18 +00:00
return opline ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2013-01-28 02:02:51 +00:00
2015-01-03 09:22:58 +00:00
static int zend_try_compile_cv ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
zend_ast * name_ast = ast - > child [ 0 ] ;
2014-06-28 16:03:26 +00:00
if ( name_ast - > kind = = ZEND_AST_ZVAL ) {
2014-06-07 11:06:53 +00:00
zend_string * name = zval_get_string ( zend_ast_get_zval ( name_ast ) ) ;
2014-12-13 22:06:14 +00:00
if ( zend_is_auto_global ( name ) ) {
2014-08-25 19:21:16 +00:00
zend_string_release ( name ) ;
2014-06-07 11:06:53 +00:00
return FAILURE ;
2003-09-03 19:28:46 +00:00
}
2006-05-11 21:07:39 +00:00
2014-06-07 11:06:53 +00:00
result - > op_type = IS_CV ;
2014-12-13 22:06:14 +00:00
result - > u . op . var = lookup_cv ( CG ( active_op_array ) , name ) ;
2014-06-07 11:06:53 +00:00
2015-01-04 16:57:23 +00:00
/* lookup_cv may be using another zend_string instance */
name = CG ( active_op_array ) - > vars [ EX_VAR_TO_NUM ( result - > u . op . var ) ] ;
2014-08-25 20:40:58 +00:00
if ( zend_string_equals_literal ( name , " this " ) ) {
2014-06-07 11:06:53 +00:00
CG ( active_op_array ) - > this_var = result - > u . op . var ;
2005-06-09 17:20:44 +00:00
}
2014-06-07 11:06:53 +00:00
return SUCCESS ;
}
return FAILURE ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-07 11:06:53 +00:00
2015-02-02 17:44:16 +00:00
static zend_op * zend_compile_simple_var_no_cv ( znode * result , zend_ast * ast , uint32_t type , int delayed ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
zend_ast * name_ast = ast - > child [ 0 ] ;
znode name_node ;
zend_op * opline ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & name_node , name_ast ) ;
2015-01-04 17:07:44 +00:00
if ( name_node . op_type = = IS_CONST ) {
convert_to_string ( & name_node . u . constant ) ;
}
2006-05-11 21:07:39 +00:00
2015-02-02 17:44:16 +00:00
if ( delayed ) {
opline = zend_delayed_emit_op ( result , ZEND_FETCH_R , & name_node , NULL ) ;
} else {
opline = zend_emit_op ( result , ZEND_FETCH_R , & name_node , NULL ) ;
}
2014-06-07 11:06:53 +00:00
2015-05-25 16:59:25 +00:00
if ( name_node . op_type = = IS_CONST & &
zend_is_auto_global ( Z_STR ( name_node . u . constant ) ) ) {
opline - > extended_value = ZEND_FETCH_GLOBAL ;
} else {
opline - > extended_value = ZEND_FETCH_LOCAL ;
/* there is a chance someone is accessing $this */
if ( ast - > kind ! = ZEND_AST_ZVAL
& & CG ( active_op_array ) - > scope & & CG ( active_op_array ) - > this_var = = ( uint32_t ) - 1
) {
zend_string * key = zend_string_init ( " this " , sizeof ( " this " ) - 1 , 0 ) ;
CG ( active_op_array ) - > this_var = lookup_cv ( CG ( active_op_array ) , key ) ;
2003-02-04 12:12:34 +00:00
}
}
2014-06-07 11:06:53 +00:00
return opline ;
2003-02-04 12:12:34 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2003-02-04 12:12:34 +00:00
2015-02-02 17:44:16 +00:00
static void zend_compile_simple_var ( znode * result , zend_ast * ast , uint32_t type , int delayed ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-12-13 22:06:14 +00:00
if ( zend_try_compile_cv ( result , ast ) = = FAILURE ) {
2015-02-02 17:44:16 +00:00
zend_op * opline = zend_compile_simple_var_no_cv ( result , ast , type , delayed ) ;
2014-06-07 11:06:53 +00:00
zend_adjust_for_fetch_type ( opline , type ) ;
2003-10-22 19:59:58 +00:00
}
2014-06-07 11:06:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-07 11:06:53 +00:00
2014-12-13 22:06:14 +00:00
static void zend_separate_if_call_and_write ( znode * node , zend_ast * ast , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
if ( type ! = BP_VAR_R & & type ! = BP_VAR_IS & & zend_is_call ( ast ) ) {
2014-09-03 12:30:48 +00:00
if ( node - > op_type = = IS_VAR ) {
2014-12-13 22:06:14 +00:00
zend_op * opline = zend_emit_op ( NULL , ZEND_SEPARATE , node , NULL ) ;
2014-09-03 12:30:48 +00:00
opline - > result_type = IS_VAR ;
opline - > result . var = opline - > op1 . var ;
} else {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use result of built-in function in write context " ) ;
}
2004-12-06 11:53:30 +00:00
}
2003-10-22 19:59:58 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2003-05-29 19:00:40 +00:00
2014-12-13 22:06:14 +00:00
void zend_delayed_compile_var ( znode * result , zend_ast * ast , uint32_t type ) ;
void zend_compile_assign ( znode * result , zend_ast * ast ) ;
static void zend_compile_list_assign ( znode * result , zend_ast * ast , znode * expr_node ) ;
2014-09-22 16:34:09 +00:00
2014-12-13 22:06:14 +00:00
static inline void zend_emit_assign_znode ( zend_ast * var_ast , znode * value_node ) /* { { { */
2014-09-22 16:34:09 +00:00
{
znode dummy_node ;
2014-09-23 19:19:11 +00:00
if ( var_ast - > kind = = ZEND_AST_LIST ) {
2014-12-13 22:06:14 +00:00
zend_compile_list_assign ( & dummy_node , var_ast , value_node ) ;
2014-09-23 19:19:11 +00:00
} else {
zend_ast * assign_ast = zend_ast_create ( ZEND_AST_ASSIGN , var_ast ,
zend_ast_create_znode ( value_node ) ) ;
2014-12-13 22:06:14 +00:00
zend_compile_assign ( & dummy_node , assign_ast ) ;
2014-09-23 19:19:11 +00:00
}
2014-12-13 22:06:14 +00:00
zend_do_free ( & dummy_node ) ;
2014-09-22 16:34:09 +00:00
}
/* }}} */
2003-10-22 19:59:58 +00:00
2014-12-13 22:06:14 +00:00
static zend_op * zend_delayed_compile_dim ( znode * result , zend_ast * ast , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
zend_ast * var_ast = ast - > child [ 0 ] ;
zend_ast * dim_ast = ast - > child [ 1 ] ;
2003-10-22 19:59:58 +00:00
2014-06-07 11:06:53 +00:00
znode var_node , dim_node ;
2004-01-28 09:13:41 +00:00
2014-12-13 22:06:14 +00:00
zend_delayed_compile_var ( & var_node , var_ast , type ) ;
zend_separate_if_call_and_write ( & var_node , var_ast , type ) ;
2014-06-07 11:06:53 +00:00
if ( dim_ast = = NULL ) {
if ( type = = BP_VAR_R | | type = = BP_VAR_IS ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use [] for reading " ) ;
2003-10-22 19:59:58 +00:00
}
2014-06-07 11:06:53 +00:00
if ( type = = BP_VAR_UNSET ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use [] for unsetting " ) ;
2003-05-29 19:00:40 +00:00
}
2014-06-07 11:06:53 +00:00
dim_node . op_type = IS_UNUSED ;
} else {
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & dim_node , dim_ast ) ;
zend_handle_numeric_op ( & dim_node ) ;
2003-05-29 19:00:40 +00:00
}
2004-01-28 09:13:41 +00:00
2014-12-13 22:06:14 +00:00
return zend_delayed_emit_op ( result , ZEND_FETCH_DIM_R , & var_node , & dim_node ) ;
2003-05-29 19:00:40 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2003-05-29 19:00:40 +00:00
2014-12-13 22:06:14 +00:00
static inline zend_op * zend_compile_dim_common ( znode * result , zend_ast * ast , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-12-13 22:06:14 +00:00
uint32_t offset = zend_delayed_compile_begin ( ) ;
zend_delayed_compile_dim ( result , ast , type ) ;
return zend_delayed_compile_end ( offset ) ;
2014-06-07 11:06:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2010-08-11 09:38:41 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_dim ( znode * result , zend_ast * ast , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-12-13 22:06:14 +00:00
zend_op * opline = zend_compile_dim_common ( result , ast , type ) ;
2014-06-07 11:06:53 +00:00
zend_adjust_for_fetch_type ( opline , type ) ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-07 11:06:53 +00:00
2014-08-29 05:05:58 +00:00
static zend_bool is_this_fetch ( zend_ast * ast ) /* { { { */
{
2014-08-25 17:46:21 +00:00
if ( ast - > kind = = ZEND_AST_VAR & & ast - > child [ 0 ] - > kind = = ZEND_AST_ZVAL ) {
zval * name = zend_ast_get_zval ( ast - > child [ 0 ] ) ;
2014-08-25 20:40:58 +00:00
return Z_TYPE_P ( name ) = = IS_STRING & & zend_string_equals_literal ( Z_STR_P ( name ) , " this " ) ;
2014-06-16 17:11:52 +00:00
}
2014-06-07 11:06:53 +00:00
2014-08-25 17:46:21 +00:00
return 0 ;
2014-04-14 09:24:43 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-04-14 09:24:43 +00:00
2014-12-13 22:06:14 +00:00
static zend_op * zend_delayed_compile_prop ( znode * result , zend_ast * ast , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
zend_ast * obj_ast = ast - > child [ 0 ] ;
zend_ast * prop_ast = ast - > child [ 1 ] ;
2010-05-24 14:11:39 +00:00
2014-06-07 11:06:53 +00:00
znode obj_node , prop_node ;
zend_op * opline ;
2003-03-05 11:14:44 +00:00
2014-06-07 11:06:53 +00:00
if ( is_this_fetch ( obj_ast ) ) {
obj_node . op_type = IS_UNUSED ;
} else {
2014-12-13 22:06:14 +00:00
zend_delayed_compile_var ( & obj_node , obj_ast , type ) ;
zend_separate_if_call_and_write ( & obj_node , obj_ast , type ) ;
2008-08-24 18:22:33 +00:00
}
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & prop_node , prop_ast ) ;
2014-06-07 11:06:53 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_delayed_emit_op ( result , ZEND_FETCH_OBJ_R , & obj_node , & prop_node ) ;
2014-11-10 15:35:45 +00:00
if ( opline - > op2_type = = IS_CONST ) {
2014-12-12 07:19:41 +00:00
convert_to_string ( CT_CONSTANT ( opline - > op2 ) ) ;
2014-12-13 22:06:14 +00:00
zend_alloc_polymorphic_cache_slot ( opline - > op2 . constant ) ;
2008-08-24 18:22:33 +00:00
}
2014-06-07 11:06:53 +00:00
return opline ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2000-06-09 14:40:14 +00:00
2014-12-13 22:06:14 +00:00
static zend_op * zend_compile_prop_common ( znode * result , zend_ast * ast , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-12-13 22:06:14 +00:00
uint32_t offset = zend_delayed_compile_begin ( ) ;
zend_delayed_compile_prop ( result , ast , type ) ;
return zend_delayed_compile_end ( offset ) ;
2014-08-15 15:10:06 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2010-05-24 14:11:39 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_prop ( znode * result , zend_ast * ast , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-12-13 22:06:14 +00:00
zend_op * opline = zend_compile_prop_common ( result , ast , type ) ;
2014-06-07 11:06:53 +00:00
zend_adjust_for_fetch_type ( opline , type ) ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-04-09 13:51:28 +00:00
2015-02-02 17:44:16 +00:00
zend_op * zend_compile_static_prop_common ( znode * result , zend_ast * ast , uint32_t type , int delayed ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
zend_ast * class_ast = ast - > child [ 0 ] ;
zend_ast * prop_ast = ast - > child [ 1 ] ;
2010-05-24 14:11:39 +00:00
2014-06-14 16:30:18 +00:00
znode class_node , prop_node ;
2014-06-07 11:06:53 +00:00
zend_op * opline ;
2010-05-24 14:11:39 +00:00
2015-10-06 20:48:04 +00:00
if ( zend_is_const_default_class_ref ( class_ast ) ) {
2014-07-19 21:30:07 +00:00
class_node . op_type = IS_CONST ;
2014-12-13 22:06:14 +00:00
ZVAL_STR ( & class_node . u . constant , zend_resolve_class_name_ast ( class_ast ) ) ;
2005-09-01 10:05:32 +00:00
} else {
2015-10-06 20:48:04 +00:00
zend_compile_class_ref ( & class_node , class_ast , 1 ) ;
2005-09-01 10:05:32 +00:00
}
2011-01-19 17:17:52 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & prop_node , prop_ast ) ;
2002-07-15 18:09:56 +00:00
2015-02-02 17:44:16 +00:00
if ( delayed ) {
opline = zend_delayed_emit_op ( result , ZEND_FETCH_R , & prop_node , NULL ) ;
} else {
opline = zend_emit_op ( result , ZEND_FETCH_R , & prop_node , NULL ) ;
}
2014-06-07 11:06:53 +00:00
if ( opline - > op1_type = = IS_CONST ) {
2015-12-10 17:12:59 +00:00
convert_to_string ( CT_CONSTANT ( opline - > op1 ) ) ;
2014-12-13 22:06:14 +00:00
zend_alloc_polymorphic_cache_slot ( opline - > op1 . constant ) ;
2014-06-07 11:06:53 +00:00
}
if ( class_node . op_type = = IS_CONST ) {
opline - > op2_type = IS_CONST ;
2014-07-19 21:30:07 +00:00
opline - > op2 . constant = zend_add_class_name_literal (
2014-12-13 22:06:14 +00:00
CG ( active_op_array ) , Z_STR ( class_node . u . constant ) ) ;
2014-06-07 11:06:53 +00:00
} else {
SET_NODE ( opline - > op2 , & class_node ) ;
}
opline - > extended_value | = ZEND_FETCH_STATIC_MEMBER ;
2014-05-26 17:29:35 +00:00
2014-06-19 11:57:29 +00:00
return opline ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-05-26 17:29:35 +00:00
2015-02-02 17:44:16 +00:00
void zend_compile_static_prop ( znode * result , zend_ast * ast , uint32_t type , int delayed ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2015-02-02 17:44:16 +00:00
zend_op * opline = zend_compile_static_prop_common ( result , ast , type , delayed ) ;
2014-06-19 11:57:29 +00:00
zend_adjust_for_fetch_type ( opline , type ) ;
2014-06-07 11:06:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2006-05-11 21:07:39 +00:00
2014-12-13 22:06:14 +00:00
static void zend_compile_list_assign ( znode * result , zend_ast * ast , znode * expr_node ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-27 20:26:06 +00:00
zend_ast_list * list = zend_ast_get_list ( ast ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2015-01-09 17:27:06 +00:00
zend_bool has_elems = 0 ;
2004-01-28 11:53:52 +00:00
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < list - > children ; + + i ) {
zend_ast * var_ast = list - > child [ i ] ;
2014-09-22 16:34:09 +00:00
znode fetch_result , dim_node ;
2014-06-07 11:06:53 +00:00
if ( var_ast = = NULL ) {
continue ;
}
2015-01-09 17:27:06 +00:00
has_elems = 1 ;
2014-06-07 11:06:53 +00:00
dim_node . op_type = IS_CONST ;
ZVAL_LONG ( & dim_node . u . constant , i ) ;
2014-08-15 20:36:22 +00:00
if ( expr_node - > op_type = = IS_CONST ) {
Z_TRY_ADDREF ( expr_node - > u . constant ) ;
}
2014-12-13 22:06:14 +00:00
zend_emit_op ( & fetch_result , ZEND_FETCH_LIST , expr_node , & dim_node ) ;
zend_emit_assign_znode ( var_ast , & fetch_result ) ;
2014-04-14 09:24:43 +00:00
}
2015-01-09 17:27:06 +00:00
if ( ! has_elems ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use empty list " ) ;
}
2014-06-07 11:06:53 +00:00
* result = * expr_node ;
2014-04-14 09:24:43 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-04-14 09:24:43 +00:00
2015-03-27 15:40:04 +00:00
static void zend_ensure_writable_variable ( const zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
if ( ast - > kind = = ZEND_AST_CALL ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Can't use function return value in write context " ) ;
}
if ( ast - > kind = = ZEND_AST_METHOD_CALL | | ast - > kind = = ZEND_AST_STATIC_CALL ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Can't use method return value in write context " ) ;
}
}
2014-08-29 05:05:58 +00:00
/* }}} */
2006-06-07 09:21:06 +00:00
2014-06-14 16:30:18 +00:00
/* Detects $a... = $a pattern */
2014-12-13 22:06:14 +00:00
zend_bool zend_is_assign_to_self ( zend_ast * var_ast , zend_ast * expr_ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-28 16:03:26 +00:00
if ( expr_ast - > kind ! = ZEND_AST_VAR | | expr_ast - > child [ 0 ] - > kind ! = ZEND_AST_ZVAL ) {
2014-06-07 11:06:53 +00:00
return 0 ;
2006-06-07 09:21:06 +00:00
}
2013-01-28 02:02:51 +00:00
2014-06-14 16:30:18 +00:00
while ( zend_is_variable ( var_ast ) & & var_ast - > kind ! = ZEND_AST_VAR ) {
2014-06-07 11:06:53 +00:00
var_ast = var_ast - > child [ 0 ] ;
}
2014-05-26 17:29:35 +00:00
2014-06-28 16:03:26 +00:00
if ( var_ast - > kind ! = ZEND_AST_VAR | | var_ast - > child [ 0 ] - > kind ! = ZEND_AST_ZVAL ) {
2014-06-07 11:06:53 +00:00
return 0 ;
}
2013-01-28 02:02:51 +00:00
2014-06-07 11:06:53 +00:00
{
zend_string * name1 = zval_get_string ( zend_ast_get_zval ( var_ast - > child [ 0 ] ) ) ;
zend_string * name2 = zval_get_string ( zend_ast_get_zval ( expr_ast - > child [ 0 ] ) ) ;
2014-08-25 20:40:58 +00:00
zend_bool result = zend_string_equals ( name1 , name2 ) ;
2014-08-25 19:21:16 +00:00
zend_string_release ( name1 ) ;
zend_string_release ( name2 ) ;
2014-06-07 11:06:53 +00:00
return result ;
2006-06-07 09:21:06 +00:00
}
2003-03-05 11:14:44 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2003-03-05 11:14:44 +00:00
2015-02-24 17:57:14 +00:00
/* Detects if list($a, $b, $c) contains variable with given name */
zend_bool zend_list_has_assign_to ( zend_ast * list_ast , zend_string * name ) /* { { { */
{
zend_ast_list * list = zend_ast_get_list ( list_ast ) ;
uint32_t i ;
for ( i = 0 ; i < list - > children ; i + + ) {
zend_ast * var_ast = list - > child [ i ] ;
if ( ! var_ast ) {
continue ;
}
/* Recursively check nested list()s */
if ( var_ast - > kind = = ZEND_AST_LIST & & zend_list_has_assign_to ( var_ast , name ) ) {
return 1 ;
}
if ( var_ast - > kind = = ZEND_AST_VAR & & var_ast - > child [ 0 ] - > kind = = ZEND_AST_ZVAL ) {
zend_string * var_name = zval_get_string ( zend_ast_get_zval ( var_ast - > child [ 0 ] ) ) ;
zend_bool result = zend_string_equals ( var_name , name ) ;
zend_string_release ( var_name ) ;
if ( result ) {
return 1 ;
}
}
}
return 0 ;
}
/* }}} */
/* Detects patterns like list($a, $b, $c) = $a */
zend_bool zend_list_has_assign_to_self ( zend_ast * list_ast , zend_ast * expr_ast ) /* { { { */
{
/* Only check simple variables on the RHS, as only CVs cause issues with this. */
if ( expr_ast - > kind = = ZEND_AST_VAR & & expr_ast - > child [ 0 ] - > kind = = ZEND_AST_ZVAL ) {
zend_string * name = zval_get_string ( zend_ast_get_zval ( expr_ast - > child [ 0 ] ) ) ;
zend_bool result = zend_list_has_assign_to ( list_ast , name ) ;
zend_string_release ( name ) ;
return result ;
}
return 0 ;
}
/* }}} */
2014-12-13 22:06:14 +00:00
void zend_compile_assign ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
zend_ast * var_ast = ast - > child [ 0 ] ;
zend_ast * expr_ast = ast - > child [ 1 ] ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-06-07 11:06:53 +00:00
znode var_node , expr_node ;
zend_op * opline ;
2014-08-25 19:21:16 +00:00
uint32_t offset ;
2014-06-07 11:06:53 +00:00
if ( is_this_fetch ( var_ast ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot re-assign $this " ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-06-07 11:06:53 +00:00
zend_ensure_writable_variable ( var_ast ) ;
switch ( var_ast - > kind ) {
case ZEND_AST_VAR :
case ZEND_AST_STATIC_PROP :
2016-01-07 15:05:17 +00:00
offset = zend_delayed_compile_begin ( ) ;
zend_delayed_compile_var ( & var_node , var_ast , BP_VAR_W ) ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & expr_node , expr_ast ) ;
2016-01-07 15:05:17 +00:00
zend_delayed_compile_end ( offset ) ;
2014-12-13 22:06:14 +00:00
zend_emit_op ( result , ZEND_ASSIGN , & var_node , & expr_node ) ;
2014-06-07 11:06:53 +00:00
return ;
case ZEND_AST_DIM :
2014-12-13 22:06:14 +00:00
offset = zend_delayed_compile_begin ( ) ;
zend_delayed_compile_dim ( result , var_ast , BP_VAR_W ) ;
2014-08-15 15:10:06 +00:00
2014-12-13 22:06:14 +00:00
if ( zend_is_assign_to_self ( var_ast , expr_ast ) ) {
2014-08-15 15:10:06 +00:00
/* $a[0] = $a should evaluate the right $a first */
2015-02-02 17:44:16 +00:00
zend_compile_simple_var_no_cv ( & expr_node , expr_ast , BP_VAR_R , 0 ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
} else {
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & expr_node , expr_ast ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-08-15 15:10:06 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_delayed_compile_end ( offset ) ;
2014-06-07 11:06:53 +00:00
opline - > opcode = ZEND_ASSIGN_DIM ;
2014-12-13 22:06:14 +00:00
opline = zend_emit_op_data ( & expr_node ) ;
2014-06-07 11:06:53 +00:00
return ;
case ZEND_AST_PROP :
2014-12-13 22:06:14 +00:00
offset = zend_delayed_compile_begin ( ) ;
zend_delayed_compile_prop ( result , var_ast , BP_VAR_W ) ;
zend_compile_expr ( & expr_node , expr_ast ) ;
2014-08-15 15:10:06 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_delayed_compile_end ( offset ) ;
2014-06-07 11:06:53 +00:00
opline - > opcode = ZEND_ASSIGN_OBJ ;
2014-12-13 22:06:14 +00:00
zend_emit_op_data ( & expr_node ) ;
2014-06-07 11:06:53 +00:00
return ;
case ZEND_AST_LIST :
2015-02-24 17:57:14 +00:00
if ( zend_list_has_assign_to_self ( var_ast , expr_ast ) ) {
/* list($a, $b) = $a should evaluate the right $a first */
zend_compile_simple_var_no_cv ( & expr_node , expr_ast , BP_VAR_R , 0 ) ;
} else {
zend_compile_expr ( & expr_node , expr_ast ) ;
}
2014-12-13 22:06:14 +00:00
zend_compile_list_assign ( result , var_ast , & expr_node ) ;
2014-06-07 11:06:53 +00:00
return ;
EMPTY_SWITCH_DEFAULT_CASE ( ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
}
2014-08-29 05:05:58 +00:00
/* }}} */
2013-01-28 02:02:51 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_assign_ref ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
zend_ast * target_ast = ast - > child [ 0 ] ;
zend_ast * source_ast = ast - > child [ 1 ] ;
2014-08-15 15:10:06 +00:00
znode target_node , source_node ;
2014-06-07 11:06:53 +00:00
zend_op * opline ;
2016-02-06 15:38:59 +00:00
uint32_t offset ;
2014-06-07 11:06:53 +00:00
2014-08-15 15:10:06 +00:00
if ( is_this_fetch ( target_ast ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot re-assign $this " ) ;
}
zend_ensure_writable_variable ( target_ast ) ;
2016-02-06 15:38:59 +00:00
offset = zend_delayed_compile_begin ( ) ;
zend_delayed_compile_var ( & target_node , target_ast , BP_VAR_W ) ;
zend_delayed_compile_var ( & source_node , source_ast , BP_VAR_REF ) ;
zend_delayed_compile_end ( offset ) ;
2014-08-15 15:10:06 +00:00
2014-09-23 18:42:22 +00:00
if ( source_node . op_type ! = IS_VAR & & zend_is_call ( source_ast ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use result of built-in function in write context " ) ;
}
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( result , ZEND_ASSIGN_REF , & target_node , & source_node ) ;
2014-08-15 15:10:06 +00:00
if ( ! result ) {
opline - > result_type | = EXT_TYPE_UNUSED ;
}
2014-06-07 11:06:53 +00:00
if ( zend_is_call ( source_ast ) ) {
opline - > extended_value = ZEND_RETURNS_FUNCTION ;
2011-10-09 11:13:27 +00:00
}
}
2014-08-29 05:05:58 +00:00
/* }}} */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-12-13 22:06:14 +00:00
static inline void zend_emit_assign_ref_znode ( zend_ast * var_ast , znode * value_node ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-08-15 15:10:06 +00:00
zend_ast * assign_ast = zend_ast_create ( ZEND_AST_ASSIGN_REF , var_ast ,
zend_ast_create_znode ( value_node ) ) ;
2014-12-13 22:06:14 +00:00
zend_compile_assign_ref ( NULL , assign_ast ) ;
2014-08-15 15:10:06 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2011-11-05 02:05:28 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_compound_assign ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
zend_ast * var_ast = ast - > child [ 0 ] ;
zend_ast * expr_ast = ast - > child [ 1 ] ;
2014-08-25 19:21:16 +00:00
uint32_t opcode = ast - > attr ;
2014-06-07 11:06:53 +00:00
znode var_node , expr_node ;
zend_op * opline ;
2014-08-25 19:21:16 +00:00
uint32_t offset ;
2014-06-07 11:06:53 +00:00
zend_ensure_writable_variable ( var_ast ) ;
switch ( var_ast - > kind ) {
case ZEND_AST_VAR :
2014-07-19 11:03:58 +00:00
case ZEND_AST_STATIC_PROP :
2016-01-07 15:05:17 +00:00
offset = zend_delayed_compile_begin ( ) ;
zend_delayed_compile_var ( & var_node , var_ast , BP_VAR_RW ) ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & expr_node , expr_ast ) ;
2016-01-07 15:05:17 +00:00
zend_delayed_compile_end ( offset ) ;
2014-12-13 22:06:14 +00:00
zend_emit_op ( result , opcode , & var_node , & expr_node ) ;
2012-12-25 06:23:08 +00:00
return ;
2014-06-07 11:06:53 +00:00
case ZEND_AST_DIM :
2014-12-13 22:06:14 +00:00
offset = zend_delayed_compile_begin ( ) ;
zend_delayed_compile_dim ( result , var_ast , BP_VAR_RW ) ;
zend_compile_expr ( & expr_node , expr_ast ) ;
2014-08-15 15:10:06 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_delayed_compile_end ( offset ) ;
2014-06-19 11:57:29 +00:00
opline - > opcode = opcode ;
2014-06-07 11:06:53 +00:00
opline - > extended_value = ZEND_ASSIGN_DIM ;
2014-12-13 22:06:14 +00:00
opline = zend_emit_op_data ( & expr_node ) ;
2012-12-25 06:23:08 +00:00
return ;
2014-06-07 11:06:53 +00:00
case ZEND_AST_PROP :
2014-12-13 22:06:14 +00:00
offset = zend_delayed_compile_begin ( ) ;
zend_delayed_compile_prop ( result , var_ast , BP_VAR_RW ) ;
zend_compile_expr ( & expr_node , expr_ast ) ;
2011-11-01 15:25:24 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_delayed_compile_end ( offset ) ;
2014-06-19 11:57:29 +00:00
opline - > opcode = opcode ;
2014-06-07 11:06:53 +00:00
opline - > extended_value = ZEND_ASSIGN_OBJ ;
2014-12-13 22:06:14 +00:00
zend_emit_op_data ( & expr_node ) ;
2014-06-07 11:06:53 +00:00
return ;
EMPTY_SWITCH_DEFAULT_CASE ( )
}
2012-12-25 06:23:08 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2011-11-01 15:25:24 +00:00
2014-12-13 22:06:14 +00:00
uint32_t zend_compile_args ( zend_ast * ast , zend_function * fbc ) /* { { { */
2014-08-29 05:05:58 +00:00
{
/* TODO.AST &var error */
2014-07-27 20:26:06 +00:00
zend_ast_list * args = zend_ast_get_list ( ast ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2014-06-07 11:06:53 +00:00
zend_bool uses_arg_unpack = 0 ;
2014-08-25 19:21:16 +00:00
uint32_t arg_count = 0 ; /* number of arguments not including unpacks */
2012-12-25 06:23:08 +00:00
2014-07-13 11:11:55 +00:00
for ( i = 0 ; i < args - > children ; + + i ) {
zend_ast * arg = args - > child [ i ] ;
2014-08-25 19:21:16 +00:00
uint32_t arg_num = i + 1 ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-07-13 11:11:55 +00:00
znode arg_node ;
2014-06-07 11:06:53 +00:00
zend_op * opline ;
zend_uchar opcode ;
zend_ulong flags = 0 ;
2014-07-13 11:11:55 +00:00
if ( arg - > kind = = ZEND_AST_UNPACK ) {
2014-06-07 11:06:53 +00:00
uses_arg_unpack = 1 ;
2014-07-22 18:41:45 +00:00
fbc = NULL ;
2015-01-03 09:22:58 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & arg_node , arg - > child [ 0 ] ) ;
opline = zend_emit_op ( NULL , ZEND_SEND_UNPACK , & arg_node , NULL ) ;
2014-06-07 11:06:53 +00:00
opline - > op2 . num = arg_count ;
2014-12-16 15:40:52 +00:00
opline - > result . var = ( uint32_t ) ( zend_intptr_t ) ZEND_CALL_ARG ( NULL , arg_count ) ;
2014-06-07 11:06:53 +00:00
continue ;
}
if ( uses_arg_unpack ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
" Cannot use positional argument after argument unpacking " ) ;
}
arg_count + + ;
2014-07-13 11:11:55 +00:00
if ( zend_is_variable ( arg ) ) {
if ( zend_is_call ( arg ) ) {
2014-12-13 22:06:14 +00:00
zend_compile_var ( & arg_node , arg , BP_VAR_R ) ;
2014-08-26 10:22:03 +00:00
if ( arg_node . op_type & ( IS_CONST | IS_TMP_VAR ) ) {
/* Function call was converted into builtin instruction */
opcode = ZEND_SEND_VAL ;
} else {
opcode = ZEND_SEND_VAR_NO_REF ;
flags | = ZEND_ARG_SEND_FUNCTION ;
if ( fbc & & ARG_SHOULD_BE_SENT_BY_REF ( fbc , arg_num ) ) {
flags | = ZEND_ARG_SEND_BY_REF ;
if ( ARG_MAY_BE_SENT_BY_REF ( fbc , arg_num ) ) {
flags | = ZEND_ARG_SEND_SILENT ;
}
2014-06-07 11:06:53 +00:00
}
}
} else if ( fbc ) {
if ( ARG_SHOULD_BE_SENT_BY_REF ( fbc , arg_num ) ) {
2014-12-13 22:06:14 +00:00
zend_compile_var ( & arg_node , arg , BP_VAR_W ) ;
2014-06-07 11:06:53 +00:00
opcode = ZEND_SEND_REF ;
} else {
2014-12-13 22:06:14 +00:00
zend_compile_var ( & arg_node , arg , BP_VAR_R ) ;
2014-06-07 11:06:53 +00:00
opcode = ZEND_SEND_VAR ;
}
} else {
2014-07-13 11:11:55 +00:00
zend_compile_var ( & arg_node , arg ,
2014-12-13 22:06:14 +00:00
BP_VAR_FUNC_ARG | ( arg_num < < BP_VAR_SHIFT ) ) ;
2014-07-22 14:55:34 +00:00
opcode = ZEND_SEND_VAR_EX ;
2014-06-07 11:06:53 +00:00
}
} else {
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & arg_node , arg ) ;
2015-07-08 15:33:58 +00:00
ZEND_ASSERT ( arg_node . op_type ! = IS_CV ) ;
if ( arg_node . op_type = = IS_VAR ) {
2014-06-07 11:06:53 +00:00
opcode = ZEND_SEND_VAR_NO_REF ;
2014-08-16 20:29:15 +00:00
if ( fbc & & ARG_MUST_BE_SENT_BY_REF ( fbc , arg_num ) ) {
2014-06-07 11:06:53 +00:00
flags | = ZEND_ARG_SEND_BY_REF ;
}
} else {
2014-07-22 14:55:34 +00:00
if ( fbc ) {
opcode = ZEND_SEND_VAL ;
if ( ARG_MUST_BE_SENT_BY_REF ( fbc , arg_num ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Only variables can be passed by reference " ) ;
}
} else {
opcode = ZEND_SEND_VAL_EX ;
2014-06-07 11:06:53 +00:00
}
}
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-06-07 11:06:53 +00:00
2014-12-13 22:06:14 +00:00
opline = get_next_op ( CG ( active_op_array ) ) ;
2014-06-07 11:06:53 +00:00
opline - > opcode = opcode ;
2014-07-13 11:11:55 +00:00
SET_NODE ( opline - > op1 , & arg_node ) ;
2014-06-07 11:06:53 +00:00
SET_UNUSED ( opline - > op2 ) ;
opline - > op2 . opline_num = arg_num ;
2014-12-16 15:40:52 +00:00
opline - > result . var = ( uint32_t ) ( zend_intptr_t ) ZEND_CALL_ARG ( NULL , arg_num ) ;
2014-06-07 11:06:53 +00:00
if ( opcode = = ZEND_SEND_VAR_NO_REF ) {
if ( fbc ) {
flags | = ZEND_ARG_COMPILE_TIME_BOUND ;
}
2014-11-18 11:37:36 +00:00
if ( ( flags & ZEND_ARG_COMPILE_TIME_BOUND ) & & ! ( flags & ZEND_ARG_SEND_BY_REF ) ) {
opline - > opcode = ZEND_SEND_VAR ;
opline - > extended_value = ZEND_ARG_COMPILE_TIME_BOUND ;
} else {
opline - > extended_value = flags ;
}
2014-07-22 14:55:34 +00:00
} else if ( fbc ) {
opline - > extended_value = ZEND_ARG_COMPILE_TIME_BOUND ;
2010-07-06 11:40:17 +00:00
}
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-06-07 11:06:53 +00:00
return arg_count ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2015-02-25 07:37:21 +00:00
ZEND_API zend_uchar zend_get_call_op ( zend_uchar init_op , zend_function * fbc ) /* { { { */
{
if ( fbc ) {
if ( fbc - > type = = ZEND_INTERNAL_FUNCTION ) {
if ( ! zend_execute_internal & &
! fbc - > common . scope & &
2015-04-23 21:34:11 +00:00
! ( fbc - > common . fn_flags & ( ZEND_ACC_ABSTRACT | ZEND_ACC_DEPRECATED | ZEND_ACC_HAS_TYPE_HINTS | ZEND_ACC_RETURN_REFERENCE ) ) ) {
2015-02-25 07:37:21 +00:00
return ZEND_DO_ICALL ;
}
} else {
if ( zend_execute_ex = = execute_ex & &
! ( fbc - > common . fn_flags & ZEND_ACC_GENERATOR ) ) {
return ZEND_DO_UCALL ;
}
}
} else if ( zend_execute_ex = = execute_ex & &
! zend_execute_internal & &
( init_op = = ZEND_INIT_FCALL_BY_NAME | |
init_op = = ZEND_INIT_NS_FCALL_BY_NAME ) ) {
return ZEND_DO_FCALL_BY_NAME ;
}
return ZEND_DO_FCALL ;
}
/* }}} */
2014-12-13 22:06:14 +00:00
void zend_compile_call_common ( znode * result , zend_ast * args_ast , zend_function * fbc ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
zend_op * opline ;
2014-08-25 19:21:16 +00:00
uint32_t opnum_init = get_next_op_number ( CG ( active_op_array ) ) - 1 ;
uint32_t arg_count ;
uint32_t call_flags ;
2012-12-25 06:23:08 +00:00
2014-12-13 22:06:14 +00:00
zend_do_extended_fcall_begin ( ) ;
2013-01-28 02:02:51 +00:00
2014-12-13 22:06:14 +00:00
arg_count = zend_compile_args ( args_ast , fbc ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-07-22 14:55:34 +00:00
opline = & CG ( active_op_array ) - > opcodes [ opnum_init ] ;
2014-06-07 11:06:53 +00:00
opline - > extended_value = arg_count ;
2011-11-17 21:04:15 +00:00
2014-12-12 06:01:42 +00:00
if ( opline - > opcode = = ZEND_INIT_FCALL ) {
opline - > op1 . num = zend_vm_calc_used_stack ( arg_count , fbc ) ;
}
2014-07-22 14:55:34 +00:00
call_flags = ( opline - > opcode = = ZEND_NEW ? ZEND_CALL_CTOR : 0 ) ;
2015-02-25 07:37:21 +00:00
opline = zend_emit_op ( result , zend_get_call_op ( opline - > opcode , fbc ) , NULL , NULL ) ;
2014-07-22 14:55:34 +00:00
opline - > op1 . num = call_flags ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-12-13 22:06:14 +00:00
zend_do_extended_fcall_end ( ) ;
2014-06-07 11:06:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2012-12-25 06:23:08 +00:00
2014-12-13 22:06:14 +00:00
zend_bool zend_compile_function_name ( znode * name_node , zend_ast * name_ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-28 13:16:35 +00:00
zend_string * orig_name = zend_ast_get_str ( name_ast ) ;
2014-07-22 11:25:47 +00:00
zend_bool is_fully_qualified ;
2012-12-25 06:23:08 +00:00
2014-06-28 20:27:06 +00:00
name_node - > op_type = IS_CONST ;
ZVAL_STR ( & name_node - > u . constant , zend_resolve_function_name (
2014-12-13 22:06:14 +00:00
orig_name , name_ast - > attr , & is_fully_qualified ) ) ;
2011-11-17 21:04:15 +00:00
2015-04-20 18:16:58 +00:00
return ! is_fully_qualified & & FC ( current_namespace ) ;
2014-06-07 11:06:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_ns_call ( znode * result , znode * name_node , zend_ast * args_ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-12-13 22:06:14 +00:00
zend_op * opline = get_next_op ( CG ( active_op_array ) ) ;
2014-06-07 11:06:53 +00:00
opline - > opcode = ZEND_INIT_NS_FCALL_BY_NAME ;
SET_UNUSED ( opline - > op1 ) ;
opline - > op2_type = IS_CONST ;
opline - > op2 . constant = zend_add_ns_func_name_literal (
2014-12-13 22:06:14 +00:00
CG ( active_op_array ) , Z_STR ( name_node - > u . constant ) ) ;
zend_alloc_cache_slot ( opline - > op2 . constant ) ;
2014-06-07 11:06:53 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_call_common ( result , args_ast , NULL ) ;
2014-06-07 11:06:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-07 11:06:53 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_dynamic_call ( znode * result , znode * name_node , zend_ast * args_ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-12-13 22:06:14 +00:00
zend_op * opline = get_next_op ( CG ( active_op_array ) ) ;
2014-06-07 11:06:53 +00:00
if ( name_node - > op_type = = IS_CONST & & Z_TYPE ( name_node - > u . constant ) = = IS_STRING ) {
2015-06-26 17:55:13 +00:00
const char * colon ;
zend_string * str = Z_STR ( name_node - > u . constant ) ;
2015-06-30 10:59:27 +00:00
if ( ( colon = zend_memrchr ( ZSTR_VAL ( str ) , ' : ' , ZSTR_LEN ( str ) ) ) ! = NULL & & colon > ZSTR_VAL ( str ) & & * ( colon - 1 ) = = ' : ' ) {
zend_string * class = zend_string_init ( ZSTR_VAL ( str ) , colon - ZSTR_VAL ( str ) - 1 , 0 ) ;
zend_string * method = zend_string_init ( colon + 1 , ZSTR_LEN ( str ) - ( colon - ZSTR_VAL ( str ) ) - 1 , 0 ) ;
2015-06-26 17:55:13 +00:00
opline - > opcode = ZEND_INIT_STATIC_METHOD_CALL ;
opline - > op1_type = IS_CONST ;
opline - > op1 . constant = zend_add_class_name_literal ( CG ( active_op_array ) , class ) ;
opline - > op2_type = IS_CONST ;
opline - > op2 . constant = zend_add_func_name_literal ( CG ( active_op_array ) , method ) ;
zend_alloc_cache_slot ( opline - > op2 . constant ) ;
zval_ptr_dtor ( & name_node - > u . constant ) ;
} else {
opline - > opcode = ZEND_INIT_FCALL_BY_NAME ;
SET_UNUSED ( opline - > op1 ) ;
opline - > op2_type = IS_CONST ;
opline - > op2 . constant = zend_add_func_name_literal ( CG ( active_op_array ) , str ) ;
zend_alloc_cache_slot ( opline - > op2 . constant ) ;
}
2014-06-07 11:06:53 +00:00
} else {
2015-02-24 19:29:47 +00:00
opline - > opcode = ZEND_INIT_DYNAMIC_CALL ;
2015-06-26 17:55:13 +00:00
SET_UNUSED ( opline - > op1 ) ;
2014-06-07 11:06:53 +00:00
SET_NODE ( opline - > op2 , name_node ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-12-13 22:06:14 +00:00
zend_compile_call_common ( result , args_ast , NULL ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-08-29 05:05:58 +00:00
static zend_bool zend_args_contain_unpack ( zend_ast_list * args ) /* { { { */
{
2014-08-25 17:28:33 +00:00
uint32_t i ;
2014-07-13 11:11:55 +00:00
for ( i = 0 ; i < args - > children ; + + i ) {
if ( args - > child [ i ] - > kind = = ZEND_AST_UNPACK ) {
2014-06-07 11:06:53 +00:00
return 1 ;
}
2013-02-21 10:18:41 +00:00
}
2014-06-07 11:06:53 +00:00
return 0 ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2013-02-21 10:18:41 +00:00
2014-12-13 22:06:14 +00:00
int zend_compile_func_strlen ( znode * result , zend_ast_list * args ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-22 21:11:12 +00:00
znode arg_node ;
if ( ( CG ( compiler_options ) & ZEND_COMPILE_NO_BUILTIN_STRLEN )
2014-07-27 20:26:06 +00:00
| | args - > children ! = 1 | | args - > child [ 0 ] - > kind = = ZEND_AST_UNPACK
2014-07-22 21:11:12 +00:00
) {
return FAILURE ;
2012-12-25 06:23:08 +00:00
}
2014-07-22 21:11:12 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & arg_node , args - > child [ 0 ] ) ;
2015-06-10 22:57:37 +00:00
if ( arg_node . op_type = = IS_CONST & & Z_TYPE ( arg_node . u . constant ) = = IS_STRING ) {
result - > op_type = IS_CONST ;
ZVAL_LONG ( & result - > u . constant , Z_STRLEN ( arg_node . u . constant ) ) ;
zval_dtor ( & arg_node . u . constant ) ;
} else {
zend_emit_op_tmp ( result , ZEND_STRLEN , & arg_node , NULL ) ;
}
2014-07-22 21:11:12 +00:00
return SUCCESS ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-12-13 22:06:14 +00:00
int zend_compile_func_typecheck ( znode * result , zend_ast_list * args , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-22 21:11:12 +00:00
znode arg_node ;
zend_op * opline ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-07-27 20:26:06 +00:00
if ( args - > children ! = 1 | | args - > child [ 0 ] - > kind = = ZEND_AST_UNPACK ) {
2014-07-22 21:11:12 +00:00
return FAILURE ;
}
2015-01-03 09:22:58 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & arg_node , args - > child [ 0 ] ) ;
opline = zend_emit_op_tmp ( result , ZEND_TYPE_CHECK , & arg_node , NULL ) ;
2014-07-22 21:11:12 +00:00
opline - > extended_value = type ;
return SUCCESS ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2011-11-17 21:04:15 +00:00
2014-12-13 22:06:14 +00:00
int zend_compile_func_defined ( znode * result , zend_ast_list * args ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-22 21:27:00 +00:00
zend_string * name ;
zend_op * opline ;
2013-01-28 02:02:51 +00:00
2014-07-27 20:26:06 +00:00
if ( args - > children ! = 1 | | args - > child [ 0 ] - > kind ! = ZEND_AST_ZVAL ) {
2014-07-22 21:27:00 +00:00
return FAILURE ;
}
2010-05-02 18:47:27 +00:00
2014-07-27 20:26:06 +00:00
name = zval_get_string ( zend_ast_get_zval ( args - > child [ 0 ] ) ) ;
2015-06-30 10:59:27 +00:00
if ( zend_memrchr ( ZSTR_VAL ( name ) , ' \\ ' , ZSTR_LEN ( name ) ) | | zend_memrchr ( ZSTR_VAL ( name ) , ' : ' , ZSTR_LEN ( name ) ) ) {
2014-08-25 19:21:16 +00:00
zend_string_release ( name ) ;
2014-07-22 21:27:00 +00:00
return FAILURE ;
}
2012-12-25 06:23:08 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_emit_op_tmp ( result , ZEND_DEFINED , NULL , NULL ) ;
2014-07-22 21:27:00 +00:00
opline - > op1_type = IS_CONST ;
LITERAL_STR ( opline - > op1 , name ) ;
2014-12-13 22:06:14 +00:00
zend_alloc_cache_slot ( opline - > op1 . constant ) ;
2013-01-28 02:02:51 +00:00
2014-07-22 21:27:00 +00:00
/* Lowercase constant name in a separate literal */
{
zval c ;
2014-12-24 12:04:51 +00:00
zend_string * lcname = zend_string_tolower ( name ) ;
2014-07-22 21:27:00 +00:00
ZVAL_NEW_STR ( & c , lcname ) ;
2014-12-13 22:06:14 +00:00
zend_add_literal ( CG ( active_op_array ) , & c ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-07-22 21:27:00 +00:00
return SUCCESS ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-12-13 22:06:14 +00:00
static int zend_try_compile_ct_bound_init_user_func ( zend_ast * name_ast , uint32_t num_args ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-24 17:22:46 +00:00
zend_string * name , * lcname ;
zend_function * fbc ;
zend_op * opline ;
2011-11-17 21:04:15 +00:00
2014-09-23 19:02:32 +00:00
if ( name_ast - > kind ! = ZEND_AST_ZVAL | | Z_TYPE_P ( zend_ast_get_zval ( name_ast ) ) ! = IS_STRING ) {
2014-07-24 17:22:46 +00:00
return FAILURE ;
}
2011-11-17 21:04:15 +00:00
2014-07-28 13:16:35 +00:00
name = zend_ast_get_str ( name_ast ) ;
2014-12-24 12:04:51 +00:00
lcname = zend_string_tolower ( name ) ;
2014-07-24 17:22:46 +00:00
fbc = zend_hash_find_ptr ( CG ( function_table ) , lcname ) ;
2015-07-21 14:39:22 +00:00
if ( ! fbc
| | ( fbc - > type = = ZEND_INTERNAL_FUNCTION & & ( CG ( compiler_options ) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS ) )
| | ( fbc - > type = = ZEND_USER_FUNCTION & & ( CG ( compiler_options ) & ZEND_COMPILE_IGNORE_USER_FUNCTIONS ) )
2014-07-24 17:22:46 +00:00
) {
2014-12-24 12:04:51 +00:00
zend_string_release ( lcname ) ;
2014-07-24 17:22:46 +00:00
return FAILURE ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-07-24 17:22:46 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( NULL , ZEND_INIT_FCALL , NULL , NULL ) ;
2014-09-23 19:02:32 +00:00
opline - > extended_value = num_args ;
2014-12-12 06:01:42 +00:00
opline - > op1 . num = zend_vm_calc_used_stack ( num_args , fbc ) ;
2014-07-24 17:22:46 +00:00
opline - > op2_type = IS_CONST ;
LITERAL_STR ( opline - > op2 , lcname ) ;
2014-12-13 22:06:14 +00:00
zend_alloc_cache_slot ( opline - > op2 . constant ) ;
2014-07-24 17:22:46 +00:00
return SUCCESS ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-12-13 22:06:14 +00:00
static void zend_compile_init_user_func ( zend_ast * name_ast , uint32_t num_args , zend_string * orig_func_name ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-24 17:22:46 +00:00
zend_op * opline ;
znode name_node ;
2013-01-28 02:02:51 +00:00
2014-12-13 22:06:14 +00:00
if ( zend_try_compile_ct_bound_init_user_func ( name_ast , num_args ) = = SUCCESS ) {
2011-06-20 01:36:23 +00:00
return ;
}
2014-07-24 17:22:46 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & name_node , name_ast ) ;
2014-07-24 17:22:46 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( NULL , ZEND_INIT_USER_CALL , NULL , & name_node ) ;
2014-07-24 17:22:46 +00:00
opline - > op1_type = IS_CONST ;
2014-08-25 19:21:16 +00:00
LITERAL_STR ( opline - > op1 , zend_string_copy ( orig_func_name ) ) ;
2014-07-24 17:22:46 +00:00
opline - > extended_value = num_args ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-24 17:22:46 +00:00
2014-07-24 18:35:18 +00:00
/* cufa = call_user_func_array */
2014-12-13 22:06:14 +00:00
int zend_compile_func_cufa ( znode * result , zend_ast_list * args , zend_string * lcname ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-24 17:22:46 +00:00
znode arg_node ;
2014-07-27 20:26:06 +00:00
if ( args - > children ! = 2 | | zend_args_contain_unpack ( args ) ) {
2014-07-24 17:22:46 +00:00
return FAILURE ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-07-24 17:22:46 +00:00
2014-12-16 16:13:47 +00:00
zend_compile_init_user_func ( args - > child [ 0 ] , 0 , lcname ) ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & arg_node , args - > child [ 1 ] ) ;
zend_emit_op ( NULL , ZEND_SEND_ARRAY , & arg_node , NULL ) ;
zend_emit_op ( result , ZEND_DO_FCALL , NULL , NULL ) ;
2014-07-24 17:22:46 +00:00
return SUCCESS ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-07-24 18:35:18 +00:00
/* cuf = call_user_func */
2014-12-13 22:06:14 +00:00
int zend_compile_func_cuf ( znode * result , zend_ast_list * args , zend_string * lcname ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-08-25 17:28:33 +00:00
uint32_t i ;
2012-12-25 06:23:08 +00:00
2014-07-27 20:26:06 +00:00
if ( args - > children < 1 | | zend_args_contain_unpack ( args ) ) {
2014-07-24 18:35:18 +00:00
return FAILURE ;
}
2011-01-19 17:17:52 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_init_user_func ( args - > child [ 0 ] , args - > children - 1 , lcname ) ;
2014-07-27 20:26:06 +00:00
for ( i = 1 ; i < args - > children ; + + i ) {
zend_ast * arg_ast = args - > child [ i ] ;
2014-07-24 18:35:18 +00:00
znode arg_node ;
zend_op * opline ;
zend_bool send_user = 0 ;
2011-07-09 12:06:11 +00:00
2014-07-24 18:35:18 +00:00
if ( zend_is_variable ( arg_ast ) & & ! zend_is_call ( arg_ast ) ) {
2014-12-13 22:06:14 +00:00
zend_compile_var ( & arg_node , arg_ast , BP_VAR_FUNC_ARG | ( i < < BP_VAR_SHIFT ) ) ;
2014-07-24 18:35:18 +00:00
send_user = 1 ;
} else {
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & arg_node , arg_ast ) ;
2014-07-24 18:35:18 +00:00
if ( arg_node . op_type & ( IS_VAR | IS_CV ) ) {
send_user = 1 ;
}
}
2012-12-25 06:23:08 +00:00
2014-07-24 18:35:18 +00:00
if ( send_user ) {
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( NULL , ZEND_SEND_USER , & arg_node , NULL ) ;
2011-07-09 12:06:11 +00:00
} else {
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( NULL , ZEND_SEND_VAL , & arg_node , NULL ) ;
2011-07-09 12:06:11 +00:00
}
2014-07-24 18:35:18 +00:00
2014-12-16 15:40:52 +00:00
opline - > op2 . num = i ;
opline - > result . var = ( uint32_t ) ( zend_intptr_t ) ZEND_CALL_ARG ( NULL , i ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-12-13 22:06:14 +00:00
zend_emit_op ( result , ZEND_DO_FCALL , NULL , NULL ) ;
2013-01-28 02:02:51 +00:00
2014-07-24 18:35:18 +00:00
return SUCCESS ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2015-08-11 20:12:06 +00:00
static void zend_compile_assert_side_effects ( zend_ast * ast ) /* { { { */
{
int i ;
int children = zend_ast_is_list ( ast ) ? zend_ast_get_list ( ast ) - > children : zend_ast_get_num_children ( ast ) ;
for ( i = 0 ; i < children ; i + + ) {
zend_ast * child = ( zend_ast_is_list ( ast ) ? zend_ast_get_list ( ast ) - > child : ast - > child ) [ i ] ;
2015-08-18 13:01:24 +00:00
if ( child ) {
if ( child - > kind = = ZEND_AST_YIELD ) {
zend_mark_function_as_generator ( ) ;
} else if ( ast - > kind > = ZEND_AST_IS_LIST_SHIFT ) {
zend_compile_assert_side_effects ( child ) ;
}
2015-08-11 20:12:06 +00:00
}
}
}
/* }}} */
2015-03-02 09:25:40 +00:00
static int zend_compile_assert ( znode * result , zend_ast_list * args , zend_string * name , zend_function * fbc ) /* { { { */
{
if ( EG ( assertions ) > = 0 ) {
znode name_node ;
zend_op * opline ;
uint32_t check_op_number = get_next_op_number ( CG ( active_op_array ) ) ;
zend_emit_op ( NULL , ZEND_ASSERT_CHECK , NULL , NULL ) ;
if ( fbc ) {
name_node . op_type = IS_CONST ;
ZVAL_STR_COPY ( & name_node . u . constant , name ) ;
opline = zend_emit_op ( NULL , ZEND_INIT_FCALL , NULL , & name_node ) ;
} else {
opline = zend_emit_op ( NULL , ZEND_INIT_NS_FCALL_BY_NAME , NULL , NULL ) ;
opline - > op2_type = IS_CONST ;
opline - > op2 . constant = zend_add_ns_func_name_literal (
CG ( active_op_array ) , name ) ;
}
zend_alloc_cache_slot ( opline - > op2 . constant ) ;
if ( args - > children = = 1 & &
( args - > child [ 0 ] - > kind ! = ZEND_AST_ZVAL | |
Z_TYPE_P ( zend_ast_get_zval ( args - > child [ 0 ] ) ) ! = IS_STRING ) ) {
/* add "assert(condition) as assertion message */
zend_ast_list_add ( ( zend_ast * ) args ,
zend_ast_create_zval_from_str (
zend_ast_export ( " assert( " , args - > child [ 0 ] , " ) " ) ) ) ;
}
zend_compile_call_common ( result , ( zend_ast * ) args , fbc ) ;
CG ( active_op_array ) - > opcodes [ check_op_number ] . op2 . opline_num = get_next_op_number ( CG ( active_op_array ) ) ;
} else {
if ( ! fbc ) {
zend_string_release ( name ) ;
}
result - > op_type = IS_CONST ;
ZVAL_TRUE ( & result - > u . constant ) ;
2015-08-11 20:12:06 +00:00
zend_compile_assert_side_effects ( ( zend_ast * ) args ) ;
2015-03-02 09:25:40 +00:00
}
return SUCCESS ;
}
/* }}} */
int zend_try_compile_special_func ( znode * result , zend_string * lcname , zend_ast_list * args , zend_function * fbc ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2015-03-27 09:50:36 +00:00
if ( fbc - > internal_function . handler = = ZEND_FN ( display_disabled_function ) ) {
return FAILURE ;
}
2014-08-25 20:40:58 +00:00
if ( zend_string_equals_literal ( lcname , " strlen " ) ) {
2014-12-13 22:06:14 +00:00
return zend_compile_func_strlen ( result , args ) ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , " is_null " ) ) {
2014-12-13 22:06:14 +00:00
return zend_compile_func_typecheck ( result , args , IS_NULL ) ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , " is_bool " ) ) {
2014-12-13 22:06:14 +00:00
return zend_compile_func_typecheck ( result , args , _IS_BOOL ) ;
2014-08-28 19:53:32 +00:00
} else if ( zend_string_equals_literal ( lcname , " is_long " )
| | zend_string_equals_literal ( lcname , " is_int " )
| | zend_string_equals_literal ( lcname , " is_integer " )
) {
2014-12-13 22:06:14 +00:00
return zend_compile_func_typecheck ( result , args , IS_LONG ) ;
2014-08-28 19:53:32 +00:00
} else if ( zend_string_equals_literal ( lcname , " is_float " )
| | zend_string_equals_literal ( lcname , " is_double " )
| | zend_string_equals_literal ( lcname , " is_real " )
) {
2014-12-13 22:06:14 +00:00
return zend_compile_func_typecheck ( result , args , IS_DOUBLE ) ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , " is_string " ) ) {
2014-12-13 22:06:14 +00:00
return zend_compile_func_typecheck ( result , args , IS_STRING ) ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , " is_array " ) ) {
2014-12-13 22:06:14 +00:00
return zend_compile_func_typecheck ( result , args , IS_ARRAY ) ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , " is_object " ) ) {
2014-12-13 22:06:14 +00:00
return zend_compile_func_typecheck ( result , args , IS_OBJECT ) ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , " is_resource " ) ) {
2014-12-13 22:06:14 +00:00
return zend_compile_func_typecheck ( result , args , IS_RESOURCE ) ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , " defined " ) ) {
2014-12-13 22:06:14 +00:00
return zend_compile_func_defined ( result , args ) ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , " call_user_func_array " ) ) {
2014-12-13 22:06:14 +00:00
return zend_compile_func_cufa ( result , args , lcname ) ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , " call_user_func " ) ) {
2014-12-13 22:06:14 +00:00
return zend_compile_func_cuf ( result , args , lcname ) ;
2015-03-02 09:25:40 +00:00
} else if ( zend_string_equals_literal ( lcname , " assert " ) ) {
return zend_compile_assert ( result , args , lcname , fbc ) ;
2014-07-22 21:27:00 +00:00
} else {
return FAILURE ;
2012-12-25 06:23:08 +00:00
}
2010-12-20 00:52:40 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2010-12-20 00:52:40 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_call ( znode * result , zend_ast * ast , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
zend_ast * name_ast = ast - > child [ 0 ] ;
2014-07-13 11:11:55 +00:00
zend_ast * args_ast = ast - > child [ 1 ] ;
2010-12-20 00:52:40 +00:00
2014-06-07 11:06:53 +00:00
znode name_node ;
2014-06-28 20:27:06 +00:00
if ( name_ast - > kind ! = ZEND_AST_ZVAL | | Z_TYPE_P ( zend_ast_get_zval ( name_ast ) ) ! = IS_STRING ) {
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & name_node , name_ast ) ;
zend_compile_dynamic_call ( result , & name_node , args_ast ) ;
2014-06-07 11:06:53 +00:00
return ;
2012-01-20 12:30:57 +00:00
}
2014-06-07 11:06:53 +00:00
{
2014-12-13 22:06:14 +00:00
zend_bool runtime_resolution = zend_compile_function_name ( & name_node , name_ast ) ;
2014-07-28 20:03:16 +00:00
if ( runtime_resolution ) {
2015-03-02 09:25:40 +00:00
if ( zend_string_equals_literal_ci ( zend_ast_get_str ( name_ast ) , " assert " ) ) {
2015-03-04 02:55:14 +00:00
zend_compile_assert ( result , zend_ast_get_list ( args_ast ) , Z_STR ( name_node . u . constant ) , NULL ) ;
2015-03-02 09:25:40 +00:00
} else {
zend_compile_ns_call ( result , & name_node , args_ast ) ;
}
2014-06-07 11:06:53 +00:00
return ;
}
}
2011-12-19 16:48:18 +00:00
2014-06-07 11:06:53 +00:00
{
zval * name = & name_node . u . constant ;
2014-12-24 12:04:51 +00:00
zend_string * lcname ;
2014-06-07 11:06:53 +00:00
zend_function * fbc ;
zend_op * opline ;
2012-12-25 06:23:08 +00:00
2014-12-24 12:04:51 +00:00
lcname = zend_string_tolower ( Z_STR_P ( name ) ) ;
2014-02-10 06:04:30 +00:00
2014-07-24 17:22:46 +00:00
fbc = zend_hash_find_ptr ( CG ( function_table ) , lcname ) ;
2015-07-21 14:39:22 +00:00
if ( ! fbc
| | ( fbc - > type = = ZEND_INTERNAL_FUNCTION & & ( CG ( compiler_options ) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS ) )
| | ( fbc - > type = = ZEND_USER_FUNCTION & & ( CG ( compiler_options ) & ZEND_COMPILE_IGNORE_USER_FUNCTIONS ) )
2014-07-24 17:22:46 +00:00
) {
2014-08-25 19:21:16 +00:00
zend_string_release ( lcname ) ;
2014-12-13 22:06:14 +00:00
zend_compile_dynamic_call ( result , & name_node , args_ast ) ;
2014-07-22 21:11:12 +00:00
return ;
2014-07-22 20:57:38 +00:00
}
2011-01-19 17:17:52 +00:00
2014-07-27 20:26:06 +00:00
if ( zend_try_compile_special_func ( result , lcname ,
2015-03-02 09:25:40 +00:00
zend_ast_get_list ( args_ast ) , fbc ) = = SUCCESS
2014-07-27 20:26:06 +00:00
) {
2014-08-25 19:21:16 +00:00
zend_string_release ( lcname ) ;
2014-07-24 17:22:46 +00:00
zval_ptr_dtor ( & name_node . u . constant ) ;
2014-06-07 11:06:53 +00:00
return ;
}
2011-12-19 16:48:18 +00:00
2014-06-07 11:06:53 +00:00
zval_ptr_dtor ( & name_node . u . constant ) ;
ZVAL_NEW_STR ( & name_node . u . constant , lcname ) ;
2011-01-19 17:17:52 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( NULL , ZEND_INIT_FCALL , NULL , & name_node ) ;
zend_alloc_cache_slot ( opline - > op2 . constant ) ;
2010-12-20 00:52:40 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_call_common ( result , args_ast , fbc ) ;
2010-12-20 00:52:40 +00:00
}
}
2014-08-29 05:05:58 +00:00
/* }}} */
2013-01-28 02:02:51 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_method_call ( znode * result , zend_ast * ast , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-08-15 15:10:06 +00:00
zend_ast * obj_ast = ast - > child [ 0 ] ;
zend_ast * method_ast = ast - > child [ 1 ] ;
2014-07-13 11:11:55 +00:00
zend_ast * args_ast = ast - > child [ 2 ] ;
2013-01-28 02:02:51 +00:00
2014-08-15 15:10:06 +00:00
znode obj_node , method_node ;
zend_op * opline ;
2011-11-18 13:49:07 +00:00
2014-08-15 15:10:06 +00:00
if ( is_this_fetch ( obj_ast ) ) {
obj_node . op_type = IS_UNUSED ;
} else {
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & obj_node , obj_ast ) ;
2011-11-17 21:04:15 +00:00
}
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & method_node , method_ast ) ;
opline = zend_emit_op ( NULL , ZEND_INIT_METHOD_CALL , & obj_node , NULL ) ;
2015-01-03 09:22:58 +00:00
2014-08-15 15:10:06 +00:00
if ( method_node . op_type = = IS_CONST ) {
if ( Z_TYPE ( method_node . u . constant ) ! = IS_STRING ) {
2014-06-07 11:06:53 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Method name must be a string " ) ;
}
2010-12-20 00:52:40 +00:00
2014-08-15 15:10:06 +00:00
opline - > op2_type = IS_CONST ;
2014-09-23 18:21:28 +00:00
opline - > op2 . constant = zend_add_func_name_literal ( CG ( active_op_array ) ,
2014-12-13 22:06:14 +00:00
Z_STR ( method_node . u . constant ) ) ;
zend_alloc_polymorphic_cache_slot ( opline - > op2 . constant ) ;
2014-08-15 15:10:06 +00:00
} else {
SET_NODE ( opline - > op2 , & method_node ) ;
2010-12-20 00:52:40 +00:00
}
2014-12-13 22:06:14 +00:00
zend_compile_call_common ( result , args_ast , NULL ) ;
2014-06-07 11:06:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2013-01-28 02:02:51 +00:00
2015-03-31 14:10:22 +00:00
static zend_bool zend_is_constructor ( zend_string * name ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-08-25 20:40:58 +00:00
return zend_string_equals_literal_ci ( name , ZEND_CONSTRUCTOR_FUNC_NAME ) ;
2014-06-07 11:06:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2010-12-20 00:52:40 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_static_call ( znode * result , zend_ast * ast , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
zend_ast * class_ast = ast - > child [ 0 ] ;
zend_ast * method_ast = ast - > child [ 1 ] ;
2014-07-13 11:11:55 +00:00
zend_ast * args_ast = ast - > child [ 2 ] ;
2010-12-20 00:52:40 +00:00
2014-06-14 16:30:18 +00:00
znode class_node , method_node ;
2014-06-07 11:06:53 +00:00
zend_op * opline ;
2015-10-06 20:48:08 +00:00
zend_ulong extended_value = 0 ;
2013-01-28 02:02:51 +00:00
2015-10-06 20:48:08 +00:00
if ( zend_is_const_default_class_ref ( class_ast ) ) {
2014-07-19 21:30:07 +00:00
class_node . op_type = IS_CONST ;
2014-12-13 22:06:14 +00:00
ZVAL_STR ( & class_node . u . constant , zend_resolve_class_name_ast ( class_ast ) ) ;
2014-06-07 11:06:53 +00:00
} else {
2015-10-06 20:48:08 +00:00
opline = zend_compile_class_ref ( & class_node , class_ast , 1 ) ;
extended_value = opline - > extended_value ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2010-04-20 10:57:45 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & method_node , method_ast ) ;
2014-06-07 11:06:53 +00:00
if ( method_node . op_type = = IS_CONST ) {
zval * name = & method_node . u . constant ;
if ( Z_TYPE_P ( name ) ! = IS_STRING ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Method name must be a string " ) ;
}
if ( zend_is_constructor ( Z_STR_P ( name ) ) ) {
zval_ptr_dtor ( name ) ;
method_node . op_type = IS_UNUSED ;
}
2010-04-20 10:57:45 +00:00
}
1999-05-15 15:47:24 +00:00
2014-12-13 22:06:14 +00:00
opline = get_next_op ( CG ( active_op_array ) ) ;
2014-06-07 11:06:53 +00:00
opline - > opcode = ZEND_INIT_STATIC_METHOD_CALL ;
2015-10-06 20:48:08 +00:00
opline - > extended_value = extended_value ;
2002-09-24 19:05:53 +00:00
2014-12-13 22:06:14 +00:00
zend_set_class_name_op1 ( opline , & class_node ) ;
2014-06-07 11:06:53 +00:00
if ( method_node . op_type = = IS_CONST ) {
opline - > op2_type = IS_CONST ;
2014-09-23 18:21:28 +00:00
opline - > op2 . constant = zend_add_func_name_literal ( CG ( active_op_array ) ,
2014-12-13 22:06:14 +00:00
Z_STR ( method_node . u . constant ) ) ;
2014-06-07 11:06:53 +00:00
if ( opline - > op1_type = = IS_CONST ) {
2014-12-13 22:06:14 +00:00
zend_alloc_cache_slot ( opline - > op2 . constant ) ;
2002-09-24 19:05:53 +00:00
} else {
2014-12-13 22:06:14 +00:00
zend_alloc_polymorphic_cache_slot ( opline - > op2 . constant ) ;
2002-09-24 19:05:53 +00:00
}
} else {
2014-06-07 11:06:53 +00:00
SET_NODE ( opline - > op2 , & method_node ) ;
2002-09-24 19:05:53 +00:00
}
2014-06-07 11:06:53 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_call_common ( result , args_ast , NULL ) ;
2002-09-24 19:05:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2006-05-09 23:53:23 +00:00
2015-04-27 18:15:06 +00:00
void zend_compile_class_decl ( zend_ast * ast ) ;
2015-04-26 13:02:57 +00:00
2015-04-26 13:24:13 +00:00
void zend_compile_new ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_ast * class_ast = ast - > child [ 0 ] ;
2014-07-13 11:11:55 +00:00
zend_ast * args_ast = ast - > child [ 1 ] ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-06-14 16:30:18 +00:00
znode class_node , ctor_result ;
zend_op * opline ;
2014-08-25 19:21:16 +00:00
uint32_t opnum ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-10-23 07:52:34 +00:00
if ( zend_is_const_default_class_ref ( class_ast ) ) {
class_node . op_type = IS_CONST ;
2014-12-13 22:06:14 +00:00
ZVAL_STR ( & class_node . u . constant , zend_resolve_class_name_ast ( class_ast ) ) ;
2015-04-26 13:17:53 +00:00
} else if ( class_ast - > kind = = ZEND_AST_CLASS ) {
2015-04-27 09:24:39 +00:00
uint32_t dcl_opnum = get_next_op_number ( CG ( active_op_array ) ) ;
2015-04-27 18:15:06 +00:00
zend_compile_class_decl ( class_ast ) ;
2015-04-27 09:24:39 +00:00
/* jump over anon class declaration */
opline = & CG ( active_op_array ) - > opcodes [ dcl_opnum ] ;
if ( opline - > opcode = = ZEND_FETCH_CLASS ) {
opline + + ;
}
2015-04-27 11:16:29 +00:00
class_node . op_type = opline - > result_type ;
class_node . u . op . var = opline - > result . var ;
2015-04-27 09:24:39 +00:00
opline - > op1 . opline_num = get_next_op_number ( CG ( active_op_array ) ) ;
2015-04-26 13:17:53 +00:00
} else {
zend_compile_class_ref ( & class_node , class_ast , 1 ) ;
2014-10-23 07:52:34 +00:00
}
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-06-14 16:30:18 +00:00
opnum = get_next_op_number ( CG ( active_op_array ) ) ;
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( result , ZEND_NEW , NULL , NULL ) ;
2014-10-23 07:52:34 +00:00
if ( class_node . op_type = = IS_CONST ) {
opline - > op1_type = IS_CONST ;
opline - > op1 . constant = zend_add_class_name_literal (
2014-12-13 22:06:14 +00:00
CG ( active_op_array ) , Z_STR ( class_node . u . constant ) ) ;
2014-10-23 07:52:34 +00:00
} else {
SET_NODE ( opline - > op1 , & class_node ) ;
}
2014-06-14 16:30:18 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_call_common ( & ctor_result , args_ast , NULL ) ;
zend_do_free ( & ctor_result ) ;
2014-06-14 16:30:18 +00:00
/* New jumps over ctor call if ctor does not exist */
opline = & CG ( active_op_array ) - > opcodes [ opnum ] ;
opline - > op2 . opline_num = get_next_op_number ( CG ( active_op_array ) ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_clone ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_ast * obj_ast = ast - > child [ 0 ] ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-06-14 16:30:18 +00:00
znode obj_node ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & obj_node , obj_ast ) ;
2014-06-14 16:30:18 +00:00
2014-12-13 22:06:14 +00:00
zend_emit_op ( result , ZEND_CLONE , & obj_node , NULL ) ;
2014-06-14 16:30:18 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-14 16:30:18 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_global_var ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
zend_ast * var_ast = ast - > child [ 0 ] ;
2014-07-22 18:24:47 +00:00
zend_ast * name_ast = var_ast - > child [ 0 ] ;
2014-06-07 11:06:53 +00:00
2014-07-22 18:24:47 +00:00
znode name_node , result ;
2014-06-07 11:06:53 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & name_node , name_ast ) ;
2014-07-22 18:24:47 +00:00
if ( name_node . op_type = = IS_CONST ) {
2014-11-10 15:41:55 +00:00
convert_to_string ( & name_node . u . constant ) ;
2010-05-06 19:20:12 +00:00
}
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-12-13 22:06:14 +00:00
if ( zend_try_compile_cv ( & result , var_ast ) = = SUCCESS ) {
zend_op * opline = zend_emit_op ( NULL , ZEND_BIND_GLOBAL , & result , & name_node ) ;
zend_alloc_cache_slot ( opline - > op2 . constant ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
} else {
2014-12-13 22:06:14 +00:00
zend_emit_op ( & result , ZEND_FETCH_W , & name_node , NULL ) ;
2014-06-07 11:06:53 +00:00
2014-07-22 18:24:47 +00:00
// TODO.AST Avoid double fetch
//opline->extended_value = ZEND_FETCH_GLOBAL_LOCK;
2014-06-07 11:06:53 +00:00
2014-12-13 22:06:14 +00:00
zend_emit_assign_ref_znode ( var_ast , & result ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
}
2014-08-29 05:05:58 +00:00
/* }}} */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-12-13 22:06:14 +00:00
static void zend_compile_static_var_common ( zend_ast * var_ast , zval * value , zend_bool by_ref ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-12 15:00:53 +00:00
znode var_node , result ;
zend_op * opline ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & var_node , var_ast ) ;
2014-07-12 15:00:53 +00:00
if ( ! CG ( active_op_array ) - > static_variables ) {
if ( CG ( active_op_array ) - > scope ) {
CG ( active_op_array ) - > scope - > ce_flags | = ZEND_HAS_STATIC_IN_METHODS ;
}
ALLOC_HASHTABLE ( CG ( active_op_array ) - > static_variables ) ;
zend_hash_init ( CG ( active_op_array ) - > static_variables , 8 , NULL , ZVAL_PTR_DTOR , 0 ) ;
}
2015-02-20 10:28:26 +00:00
if ( GC_REFCOUNT ( CG ( active_op_array ) - > static_variables ) > 1 ) {
if ( ! ( GC_FLAGS ( CG ( active_op_array ) - > static_variables ) & IS_ARRAY_IMMUTABLE ) ) {
GC_REFCOUNT ( CG ( active_op_array ) - > static_variables ) - - ;
}
CG ( active_op_array ) - > static_variables = zend_array_dup ( CG ( active_op_array ) - > static_variables ) ;
}
2014-07-18 10:30:39 +00:00
zend_hash_update ( CG ( active_op_array ) - > static_variables , Z_STR ( var_node . u . constant ) , value ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( & result , by_ref ? ZEND_FETCH_W : ZEND_FETCH_R , & var_node , NULL ) ;
2014-07-12 15:00:53 +00:00
opline - > extended_value = ZEND_FETCH_STATIC ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-07-18 10:30:39 +00:00
if ( by_ref ) {
2014-07-28 16:18:47 +00:00
zend_ast * fetch_ast = zend_ast_create ( ZEND_AST_VAR , var_ast ) ;
2014-12-13 22:06:14 +00:00
zend_emit_assign_ref_znode ( fetch_ast , & result ) ;
2014-07-18 10:30:39 +00:00
} else {
2014-07-28 16:18:47 +00:00
zend_ast * fetch_ast = zend_ast_create ( ZEND_AST_VAR , var_ast ) ;
2014-12-13 22:06:14 +00:00
zend_emit_assign_znode ( fetch_ast , & result ) ;
2014-07-18 10:30:39 +00:00
}
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_static_var ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-18 10:30:39 +00:00
zend_ast * var_ast = ast - > child [ 0 ] ;
zend_ast * value_ast = ast - > child [ 1 ] ;
zval value_zv ;
2002-09-24 19:05:53 +00:00
2014-07-18 10:30:39 +00:00
if ( value_ast ) {
2014-12-13 22:06:14 +00:00
zend_const_expr_to_zval ( & value_zv , value_ast ) ;
2010-04-20 10:57:45 +00:00
} else {
2014-07-18 10:30:39 +00:00
ZVAL_NULL ( & value_zv ) ;
2010-04-20 10:57:45 +00:00
}
2014-07-18 10:30:39 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_static_var_common ( var_ast , & value_zv , 1 ) ;
2014-07-12 15:00:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-12 15:00:53 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_unset ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
zend_ast * var_ast = ast - > child [ 0 ] ;
znode var_node ;
zend_op * opline ;
2015-08-11 13:42:11 +00:00
zend_ensure_writable_variable ( var_ast ) ;
2014-06-07 11:06:53 +00:00
switch ( var_ast - > kind ) {
case ZEND_AST_VAR :
2014-12-13 22:06:14 +00:00
if ( zend_try_compile_cv ( & var_node , var_ast ) = = SUCCESS ) {
opline = zend_emit_op ( NULL , ZEND_UNSET_VAR , & var_node , NULL ) ;
2014-06-07 11:06:53 +00:00
opline - > extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET ;
} else {
2015-02-02 17:44:16 +00:00
opline = zend_compile_simple_var_no_cv ( NULL , var_ast , BP_VAR_UNSET , 0 ) ;
2014-06-07 11:06:53 +00:00
opline - > opcode = ZEND_UNSET_VAR ;
}
return ;
case ZEND_AST_DIM :
2014-12-13 22:06:14 +00:00
opline = zend_compile_dim_common ( NULL , var_ast , BP_VAR_UNSET ) ;
2014-06-07 11:06:53 +00:00
opline - > opcode = ZEND_UNSET_DIM ;
return ;
case ZEND_AST_PROP :
2014-12-13 22:06:14 +00:00
opline = zend_compile_prop_common ( NULL , var_ast , BP_VAR_UNSET ) ;
2014-06-07 11:06:53 +00:00
opline - > opcode = ZEND_UNSET_OBJ ;
return ;
2014-06-19 11:57:29 +00:00
case ZEND_AST_STATIC_PROP :
2015-02-02 17:44:16 +00:00
opline = zend_compile_static_prop_common ( NULL , var_ast , BP_VAR_UNSET , 0 ) ;
2014-06-19 11:57:29 +00:00
opline - > opcode = ZEND_UNSET_VAR ;
return ;
2014-06-07 11:06:53 +00:00
EMPTY_SWITCH_DEFAULT_CASE ( )
2002-09-24 19:05:53 +00:00
}
2014-06-07 11:06:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-07 11:06:53 +00:00
2015-08-04 04:37:06 +00:00
static int zend_handle_loops_and_finally_ex ( zend_long depth ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2015-08-04 04:37:06 +00:00
zend_loop_var * base ;
2015-07-10 11:30:25 +00:00
zend_loop_var * loop_var = zend_stack_top ( & CG ( loop_var_stack ) ) ;
2015-08-04 04:37:06 +00:00
if ( ! loop_var ) {
return 1 ;
}
base = zend_stack_base ( & CG ( loop_var_stack ) ) ;
for ( ; loop_var > = base ; loop_var - - ) {
if ( loop_var - > opcode = = ZEND_FAST_CALL ) {
zend_op * opline = get_next_op ( CG ( active_op_array ) ) ;
opline - > opcode = ZEND_FAST_CALL ;
opline - > result_type = IS_TMP_VAR ;
opline - > result . var = loop_var - > var_num ;
SET_UNUSED ( opline - > op1 ) ;
SET_UNUSED ( opline - > op2 ) ;
opline - > op1 . num = loop_var - > u . try_catch_offset ;
} else if ( loop_var - > opcode = = ZEND_RETURN ) {
/* Stack separator */
break ;
} else if ( depth < = 1 ) {
return 1 ;
} else if ( loop_var - > opcode = = ZEND_NOP ) {
/* Loop doesn't have freeable variable */
depth - - ;
} else {
zend_op * opline ;
ZEND_ASSERT ( loop_var - > var_type = = IS_VAR | | loop_var - > var_type = = IS_TMP_VAR ) ;
opline = get_next_op ( CG ( active_op_array ) ) ;
opline - > opcode = loop_var - > opcode ;
opline - > op1_type = loop_var - > var_type ;
opline - > op1 . var = loop_var - > var_num ;
SET_UNUSED ( opline - > op2 ) ;
opline - > op2 . num = loop_var - > u . brk_cont_offset ;
opline - > extended_value = ZEND_FREE_ON_RETURN ;
depth - - ;
}
2015-07-10 01:13:34 +00:00
}
2015-08-04 04:37:06 +00:00
return ( depth = = 0 ) ;
}
/* }}} */
static int zend_handle_loops_and_finally ( void ) /* { { { */
{
2015-08-10 13:48:17 +00:00
return zend_handle_loops_and_finally_ex ( zend_stack_count ( & CG ( loop_var_stack ) ) + 1 ) ;
2002-09-24 19:05:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2000-05-25 16:26:22 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_return ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-07 19:06:02 +00:00
zend_ast * expr_ast = ast - > child [ 0 ] ;
zend_bool by_ref = ( CG ( active_op_array ) - > fn_flags & ZEND_ACC_RETURN_REFERENCE ) ! = 0 ;
2010-04-20 10:57:45 +00:00
2014-07-07 19:06:02 +00:00
znode expr_node ;
zend_op * opline ;
if ( ! expr_ast ) {
expr_node . op_type = IS_CONST ;
ZVAL_NULL ( & expr_node . u . constant ) ;
} else if ( by_ref & & zend_is_variable ( expr_ast ) & & ! zend_is_call ( expr_ast ) ) {
2014-12-13 22:06:14 +00:00
zend_compile_var ( & expr_node , expr_ast , BP_VAR_REF ) ;
2010-04-20 10:57:45 +00:00
} else {
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & expr_node , expr_ast ) ;
2010-04-20 10:57:45 +00:00
}
2002-09-15 07:54:01 +00:00
2014-07-07 19:06:02 +00:00
if ( CG ( context ) . in_finally ) {
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( NULL , ZEND_DISCARD_EXCEPTION , NULL , NULL ) ;
2014-11-27 06:56:43 +00:00
opline - > op1_type = IS_TMP_VAR ;
opline - > op1 . var = CG ( context ) . fast_call_var ;
2002-09-24 19:05:53 +00:00
}
2015-07-10 00:31:52 +00:00
/* Generator return types are handled separately */
if ( ! ( CG ( active_op_array ) - > fn_flags & ZEND_ACC_GENERATOR ) & & CG ( active_op_array ) - > fn_flags & ZEND_ACC_HAS_RETURN_TYPE ) {
zend_emit_return_type_check ( expr_ast ? & expr_node : NULL , CG ( active_op_array ) - > arg_info - 1 ) ;
}
2015-12-11 17:11:28 +00:00
zend_handle_loops_and_finally ( ) ;
2014-07-28 20:03:16 +00:00
opline = zend_emit_op ( NULL , by_ref ? ZEND_RETURN_BY_REF : ZEND_RETURN ,
2014-12-13 22:06:14 +00:00
& expr_node , NULL ) ;
2014-07-28 20:03:16 +00:00
2014-07-07 19:06:02 +00:00
if ( expr_ast ) {
if ( zend_is_call ( expr_ast ) ) {
opline - > extended_value = ZEND_RETURNS_FUNCTION ;
2014-10-22 17:45:02 +00:00
} else if ( by_ref & & ! zend_is_variable ( expr_ast ) ) {
2014-07-07 19:06:02 +00:00
opline - > extended_value = ZEND_RETURNS_VALUE ;
}
2004-08-26 22:59:25 +00:00
}
2014-07-07 19:06:02 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2004-08-26 22:59:25 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_echo ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2015-09-29 13:49:22 +00:00
zend_op * opline ;
2014-07-07 19:14:14 +00:00
zend_ast * expr_ast = ast - > child [ 0 ] ;
2002-09-24 19:05:53 +00:00
2014-07-07 19:14:14 +00:00
znode expr_node ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & expr_node , expr_ast ) ;
2002-09-24 19:32:01 +00:00
2015-09-29 13:49:22 +00:00
opline = zend_emit_op ( NULL , ZEND_ECHO , & expr_node , NULL ) ;
2015-09-30 02:41:27 +00:00
opline - > extended_value = 0 ;
1999-05-15 15:47:24 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-05-15 15:47:24 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_throw ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-09 20:47:36 +00:00
zend_ast * expr_ast = ast - > child [ 0 ] ;
1999-05-15 15:47:24 +00:00
2014-07-09 20:47:36 +00:00
znode expr_node ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & expr_node , expr_ast ) ;
2003-01-28 11:34:24 +00:00
2014-12-13 22:06:14 +00:00
zend_emit_op ( NULL , ZEND_THROW , & expr_node , NULL ) ;
2014-07-09 20:47:36 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2008-03-18 08:36:30 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_break_continue ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-09 21:05:21 +00:00
zend_ast * depth_ast = ast - > child [ 0 ] ;
2008-03-18 08:36:30 +00:00
2014-07-09 21:05:21 +00:00
zend_op * opline ;
2015-05-22 20:08:44 +00:00
int depth ;
2004-02-04 16:30:15 +00:00
2014-07-27 20:26:06 +00:00
ZEND_ASSERT ( ast - > kind = = ZEND_AST_BREAK | | ast - > kind = = ZEND_AST_CONTINUE ) ;
2014-07-09 21:05:21 +00:00
if ( depth_ast ) {
2015-05-22 20:08:44 +00:00
zval * depth_zv ;
2014-07-09 21:05:21 +00:00
if ( depth_ast - > kind ! = ZEND_AST_ZVAL ) {
zend_error_noreturn ( E_COMPILE_ERROR , " '%s' operator with non-constant operand "
2014-07-27 20:26:06 +00:00
" is no longer supported " , ast - > kind = = ZEND_AST_BREAK ? " break " : " continue " ) ;
2014-07-09 21:05:21 +00:00
}
2015-05-22 20:08:44 +00:00
depth_zv = zend_ast_get_zval ( depth_ast ) ;
if ( Z_TYPE_P ( depth_zv ) ! = IS_LONG | | Z_LVAL_P ( depth_zv ) < 1 ) {
2014-07-09 21:05:21 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " '%s' operator accepts only positive numbers " ,
2014-07-27 20:26:06 +00:00
ast - > kind = = ZEND_AST_BREAK ? " break " : " continue " ) ;
2014-07-09 21:05:21 +00:00
}
2015-05-22 20:08:44 +00:00
depth = Z_LVAL_P ( depth_zv ) ;
2014-07-09 21:05:21 +00:00
} else {
2015-05-22 20:08:44 +00:00
depth = 1 ;
1999-07-26 21:18:35 +00:00
}
2002-09-24 19:05:53 +00:00
2015-04-01 12:52:26 +00:00
if ( CG ( context ) . current_brk_cont = = - 1 ) {
zend_error_noreturn ( E_COMPILE_ERROR , " '%s' not in the 'loop' or 'switch' context " ,
ast - > kind = = ZEND_AST_BREAK ? " break " : " continue " ) ;
} else {
2015-08-04 04:37:06 +00:00
if ( ! zend_handle_loops_and_finally_ex ( depth ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot '%s' %d level%s " ,
ast - > kind = = ZEND_AST_BREAK ? " break " : " continue " ,
depth , depth = = 1 ? " " : " s " ) ;
}
2015-04-01 12:52:26 +00:00
}
2015-05-22 20:08:44 +00:00
opline = zend_emit_op ( NULL , ast - > kind = = ZEND_AST_BREAK ? ZEND_BRK : ZEND_CONT , NULL , NULL ) ;
opline - > op1 . num = CG ( context ) . current_brk_cont ;
opline - > op2 . num = depth ;
1999-05-15 15:47:24 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-05-15 15:47:24 +00:00
2015-08-04 04:37:06 +00:00
void zend_resolve_goto_label ( zend_op_array * op_array , zend_op * opline ) /* { { { */
2015-07-10 01:44:21 +00:00
{
zend_label * dest ;
2015-07-10 11:30:25 +00:00
int current , remove_oplines = opline - > op1 . num ;
2015-07-10 01:44:21 +00:00
zval * label ;
2015-07-10 11:30:25 +00:00
uint32_t opnum = opline - op_array - > opcodes ;
2015-07-10 01:44:21 +00:00
2015-07-10 11:30:25 +00:00
label = CT_CONSTANT_EX ( op_array , opline - > op2 . constant ) ;
2015-07-10 01:44:21 +00:00
if ( CG ( context ) . labels = = NULL | |
2015-07-10 11:30:25 +00:00
( dest = zend_hash_find_ptr ( CG ( context ) . labels , Z_STR_P ( label ) ) ) = = NULL
) {
CG ( in_compilation ) = 1 ;
CG ( active_op_array ) = op_array ;
CG ( zend_lineno ) = opline - > lineno ;
zend_error_noreturn ( E_COMPILE_ERROR , " 'goto' to undefined label '%s' " , Z_STRVAL_P ( label ) ) ;
2015-07-10 01:44:21 +00:00
}
zval_dtor ( label ) ;
ZVAL_NULL ( label ) ;
2015-07-10 11:30:25 +00:00
current = opline - > extended_value ;
for ( ; current ! = dest - > brk_cont ; current = op_array - > brk_cont_array [ current ] . parent ) {
2015-07-10 01:44:21 +00:00
if ( current = = - 1 ) {
2015-07-10 11:30:25 +00:00
CG ( in_compilation ) = 1 ;
CG ( active_op_array ) = op_array ;
CG ( zend_lineno ) = opline - > lineno ;
2015-07-10 01:44:21 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " 'goto' into loop or switch statement is disallowed " ) ;
}
if ( op_array - > brk_cont_array [ current ] . start > = 0 ) {
2015-07-10 11:30:25 +00:00
remove_oplines - - ;
2015-07-10 01:44:21 +00:00
}
2015-07-10 11:30:25 +00:00
}
for ( current = 0 ; current < op_array - > last_try_catch ; + + current ) {
zend_try_catch_element * elem = & op_array - > try_catch_array [ current ] ;
if ( elem - > try_op > opnum ) {
break ;
2015-07-10 01:44:21 +00:00
}
2015-07-10 11:30:25 +00:00
if ( elem - > finally_op & & opnum < elem - > finally_op - 1
& & ( dest - > opline_num > elem - > finally_end | | dest - > opline_num < elem - > try_op )
) {
remove_oplines - - ;
}
}
opline - > opcode = ZEND_JMP ;
opline - > op1 . opline_num = dest - > opline_num ;
opline - > extended_value = 0 ;
SET_UNUSED ( opline - > op1 ) ;
SET_UNUSED ( opline - > op2 ) ;
SET_UNUSED ( opline - > result ) ;
2015-08-04 04:37:06 +00:00
ZEND_ASSERT ( remove_oplines > = 0 ) ;
while ( remove_oplines - - ) {
opline - - ;
MAKE_NOP ( opline ) ;
ZEND_VM_SET_OPCODE_HANDLER ( opline ) ;
}
2015-07-10 01:44:21 +00:00
}
/* }}} */
2014-12-13 22:06:14 +00:00
void zend_compile_goto ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-09 21:11:32 +00:00
zend_ast * label_ast = ast - > child [ 0 ] ;
znode label_node ;
2015-07-10 11:30:25 +00:00
zend_op * opline ;
uint32_t opnum_start = get_next_op_number ( CG ( active_op_array ) ) ;
2014-07-09 21:11:32 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & label_node , label_ast ) ;
2015-07-10 11:30:25 +00:00
/* Label resolution and unwinding adjustments happen in pass two. */
zend_handle_loops_and_finally ( ) ;
opline = zend_emit_op ( NULL , ZEND_GOTO , NULL , & label_node ) ;
opline - > op1 . num = get_next_op_number ( CG ( active_op_array ) ) - opnum_start - 1 ;
opline - > extended_value = CG ( context ) . current_brk_cont ;
2014-07-09 21:11:32 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-09 21:11:32 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_label ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-09-22 22:57:00 +00:00
zend_string * label = zend_ast_get_str ( ast - > child [ 0 ] ) ;
2014-07-09 21:46:22 +00:00
zend_label dest ;
if ( ! CG ( context ) . labels ) {
ALLOC_HASHTABLE ( CG ( context ) . labels ) ;
2015-08-12 03:15:09 +00:00
zend_hash_init ( CG ( context ) . labels , 8 , NULL , label_ptr_dtor , 0 ) ;
2014-07-09 21:46:22 +00:00
}
dest . brk_cont = CG ( context ) . current_brk_cont ;
dest . opline_num = get_next_op_number ( CG ( active_op_array ) ) ;
2008-03-18 08:36:30 +00:00
2014-09-22 22:57:00 +00:00
if ( ! zend_hash_add_mem ( CG ( context ) . labels , label , & dest , sizeof ( zend_label ) ) ) {
2015-06-30 10:59:27 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Label '%s' already defined " , ZSTR_VAL ( label ) ) ;
2008-03-18 08:36:30 +00:00
}
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-05-15 15:47:24 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_while ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-10 12:35:59 +00:00
zend_ast * cond_ast = ast - > child [ 0 ] ;
zend_ast * stmt_ast = ast - > child [ 1 ] ;
znode cond_node ;
2015-01-19 10:27:44 +00:00
uint32_t opnum_start , opnum_jmp , opnum_cond ;
2006-05-09 23:53:23 +00:00
2015-01-19 10:27:44 +00:00
opnum_jmp = zend_emit_jump ( 0 ) ;
1999-04-07 18:10:10 +00:00
2015-08-04 04:37:06 +00:00
zend_begin_loop ( ZEND_NOP , NULL ) ;
1999-04-07 18:10:10 +00:00
2015-01-19 10:27:44 +00:00
opnum_start = get_next_op_number ( CG ( active_op_array ) ) ;
2014-12-13 22:06:14 +00:00
zend_compile_stmt ( stmt_ast ) ;
1999-04-07 18:10:10 +00:00
2015-01-19 10:27:44 +00:00
opnum_cond = get_next_op_number ( CG ( active_op_array ) ) ;
zend_update_jump_target ( opnum_jmp , opnum_cond ) ;
zend_compile_expr ( & cond_node , cond_ast ) ;
2014-07-10 12:35:59 +00:00
2015-01-19 10:27:44 +00:00
zend_emit_cond_jump ( ZEND_JMPNZ , & cond_node , opnum_start ) ;
1999-04-07 18:10:10 +00:00
2015-05-22 19:35:33 +00:00
zend_end_loop ( opnum_cond ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_do_while ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-10 12:46:22 +00:00
zend_ast * stmt_ast = ast - > child [ 0 ] ;
zend_ast * cond_ast = ast - > child [ 1 ] ;
1999-04-07 18:10:10 +00:00
2014-07-10 12:46:22 +00:00
znode cond_node ;
2014-08-25 19:21:16 +00:00
uint32_t opnum_start , opnum_cond ;
2006-05-09 23:53:23 +00:00
2015-08-04 04:37:06 +00:00
zend_begin_loop ( ZEND_NOP , NULL ) ;
1999-04-07 18:10:10 +00:00
2014-07-10 12:46:22 +00:00
opnum_start = get_next_op_number ( CG ( active_op_array ) ) ;
2014-12-13 22:06:14 +00:00
zend_compile_stmt ( stmt_ast ) ;
1999-04-07 18:10:10 +00:00
2014-07-10 12:46:22 +00:00
opnum_cond = get_next_op_number ( CG ( active_op_array ) ) ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & cond_node , cond_ast ) ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_emit_cond_jump ( ZEND_JMPNZ , & cond_node , opnum_start ) ;
1999-04-07 18:10:10 +00:00
2015-05-22 19:35:33 +00:00
zend_end_loop ( opnum_cond ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_expr_list ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-27 20:26:06 +00:00
zend_ast_list * list ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
1999-04-07 18:10:10 +00:00
2014-07-19 11:21:12 +00:00
result - > op_type = IS_CONST ;
ZVAL_TRUE ( & result - > u . constant ) ;
1999-04-07 18:10:10 +00:00
2014-07-19 11:21:12 +00:00
if ( ! ast ) {
return ;
}
1999-04-07 18:10:10 +00:00
2014-07-27 20:26:06 +00:00
list = zend_ast_get_list ( ast ) ;
for ( i = 0 ; i < list - > children ; + + i ) {
zend_ast * expr_ast = list - > child [ i ] ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_do_free ( result ) ;
zend_compile_expr ( result , expr_ast ) ;
2014-07-10 13:51:47 +00:00
}
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_for ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-10 13:51:47 +00:00
zend_ast * init_ast = ast - > child [ 0 ] ;
zend_ast * cond_ast = ast - > child [ 1 ] ;
zend_ast * loop_ast = ast - > child [ 2 ] ;
zend_ast * stmt_ast = ast - > child [ 3 ] ;
1999-04-07 18:10:10 +00:00
2014-07-10 13:51:47 +00:00
znode result ;
2015-01-20 03:58:40 +00:00
uint32_t opnum_start , opnum_jmp , opnum_loop ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr_list ( & result , init_ast ) ;
zend_do_free ( & result ) ;
2000-08-10 20:42:57 +00:00
2015-01-19 10:27:44 +00:00
opnum_jmp = zend_emit_jump ( 0 ) ;
2014-07-10 13:51:47 +00:00
2015-08-04 04:37:06 +00:00
zend_begin_loop ( ZEND_NOP , NULL ) ;
2014-07-10 13:51:47 +00:00
2015-01-19 10:27:44 +00:00
opnum_start = get_next_op_number ( CG ( active_op_array ) ) ;
2014-12-13 22:06:14 +00:00
zend_compile_stmt ( stmt_ast ) ;
1999-04-07 18:10:10 +00:00
2014-07-10 13:51:47 +00:00
opnum_loop = get_next_op_number ( CG ( active_op_array ) ) ;
2014-12-13 22:06:14 +00:00
zend_compile_expr_list ( & result , loop_ast ) ;
zend_do_free ( & result ) ;
1999-04-07 18:10:10 +00:00
2015-01-19 10:27:44 +00:00
zend_update_jump_target_to_next ( opnum_jmp ) ;
zend_compile_expr_list ( & result , cond_ast ) ;
zend_do_extended_info ( ) ;
2014-07-10 13:51:47 +00:00
2015-01-19 10:27:44 +00:00
zend_emit_cond_jump ( ZEND_JMPNZ , & result , opnum_start ) ;
2014-07-10 13:51:47 +00:00
2015-05-22 19:35:33 +00:00
zend_end_loop ( opnum_loop ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_foreach ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-11 10:16:21 +00:00
zend_ast * expr_ast = ast - > child [ 0 ] ;
zend_ast * value_ast = ast - > child [ 1 ] ;
zend_ast * key_ast = ast - > child [ 2 ] ;
zend_ast * stmt_ast = ast - > child [ 3 ] ;
zend_bool by_ref = value_ast - > kind = = ZEND_AST_REF ;
zend_bool is_variable = zend_is_variable ( expr_ast ) & & ! zend_is_call ( expr_ast )
& & zend_can_write_to_variable ( expr_ast ) ;
2014-09-23 19:19:11 +00:00
znode expr_node , reset_node , value_node , key_node ;
1999-04-07 18:10:10 +00:00
zend_op * opline ;
2014-08-25 19:21:16 +00:00
uint32_t opnum_reset , opnum_fetch ;
1999-04-07 18:10:10 +00:00
2014-07-11 10:16:21 +00:00
if ( key_ast ) {
if ( key_ast - > kind = = ZEND_AST_REF ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Key element cannot be a reference " ) ;
}
if ( key_ast - > kind = = ZEND_AST_LIST ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use list as key element " ) ;
}
2004-10-08 18:50:00 +00:00
}
2014-07-11 10:16:21 +00:00
if ( by_ref ) {
value_ast = value_ast - > child [ 0 ] ;
}
2011-01-19 17:17:52 +00:00
2014-07-11 10:16:21 +00:00
if ( by_ref & & is_variable ) {
2014-12-13 22:06:14 +00:00
zend_compile_var ( & expr_node , expr_ast , BP_VAR_W ) ;
2014-07-11 10:16:21 +00:00
} else {
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & expr_node , expr_ast ) ;
1999-04-07 18:10:10 +00:00
}
2014-09-20 19:58:06 +00:00
if ( by_ref ) {
2014-12-13 22:06:14 +00:00
zend_separate_if_call_and_write ( & expr_node , expr_ast , BP_VAR_W ) ;
1999-07-26 21:18:35 +00:00
}
2002-09-24 19:05:53 +00:00
2014-07-11 10:16:21 +00:00
opnum_reset = get_next_op_number ( CG ( active_op_array ) ) ;
2015-02-12 10:57:12 +00:00
opline = zend_emit_op ( & reset_node , by_ref ? ZEND_FE_RESET_RW : ZEND_FE_RESET_R , & expr_node , NULL ) ;
1999-04-07 18:10:10 +00:00
2014-07-11 10:16:21 +00:00
opnum_fetch = get_next_op_number ( CG ( active_op_array ) ) ;
2015-05-13 09:55:42 +00:00
opline = zend_emit_op ( NULL , by_ref ? ZEND_FE_FETCH_RW : ZEND_FE_FETCH_R , & reset_node , NULL ) ;
1999-04-07 18:10:10 +00:00
2015-05-13 09:55:42 +00:00
if ( value_ast - > kind = = ZEND_AST_VAR & &
zend_try_compile_cv ( & value_node , value_ast ) = = SUCCESS ) {
SET_NODE ( opline - > op2 , & value_node ) ;
2014-07-11 10:16:21 +00:00
} else {
2015-05-13 09:55:42 +00:00
opline - > op2_type = IS_VAR ;
opline - > op2 . var = get_temporary_variable ( CG ( active_op_array ) ) ;
GET_NODE ( & value_node , opline - > op2 ) ;
if ( by_ref ) {
zend_emit_assign_ref_znode ( value_ast , & value_node ) ;
} else {
zend_emit_assign_znode ( value_ast , & value_node ) ;
}
2004-08-23 20:16:35 +00:00
}
2014-07-11 10:16:21 +00:00
if ( key_ast ) {
2015-05-13 09:55:42 +00:00
opline = & CG ( active_op_array ) - > opcodes [ opnum_fetch ] ;
zend_make_tmp_result ( & key_node , opline ) ;
2014-12-13 22:06:14 +00:00
zend_emit_assign_znode ( key_ast , & key_node ) ;
1999-04-07 18:10:10 +00:00
}
2006-05-09 23:53:23 +00:00
2015-08-04 04:37:06 +00:00
zend_begin_loop ( ZEND_FE_FREE , & reset_node ) ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_stmt ( stmt_ast ) ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_emit_jump ( opnum_fetch ) ;
1999-04-07 18:10:10 +00:00
2014-07-11 10:16:21 +00:00
opline = & CG ( active_op_array ) - > opcodes [ opnum_reset ] ;
opline - > op2 . opline_num = get_next_op_number ( CG ( active_op_array ) ) ;
1999-04-07 18:10:10 +00:00
2014-07-11 10:16:21 +00:00
opline = & CG ( active_op_array ) - > opcodes [ opnum_fetch ] ;
2015-05-13 09:55:42 +00:00
opline - > extended_value = get_next_op_number ( CG ( active_op_array ) ) ;
2014-07-11 10:16:21 +00:00
2015-05-22 19:35:33 +00:00
zend_end_loop ( opnum_fetch ) ;
2014-07-11 10:16:21 +00:00
2015-07-10 11:30:25 +00:00
zend_emit_op ( NULL , ZEND_FE_FREE , & reset_node , NULL ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_if ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-27 20:26:06 +00:00
zend_ast_list * list = zend_ast_get_list ( ast ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2014-11-27 09:52:31 +00:00
uint32_t * jmp_opnums = NULL ;
2015-01-03 09:22:58 +00:00
2014-08-26 17:39:40 +00:00
if ( list - > children > 1 ) {
jmp_opnums = safe_emalloc ( sizeof ( uint32_t ) , list - > children - 1 , 0 ) ;
}
1999-04-07 18:10:10 +00:00
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < list - > children ; + + i ) {
zend_ast * elem_ast = list - > child [ i ] ;
2014-07-10 14:38:04 +00:00
zend_ast * cond_ast = elem_ast - > child [ 0 ] ;
zend_ast * stmt_ast = elem_ast - > child [ 1 ] ;
2004-10-08 18:50:00 +00:00
2014-07-10 14:38:04 +00:00
znode cond_node ;
2014-08-25 19:21:16 +00:00
uint32_t opnum_jmpz ;
2014-07-10 14:38:04 +00:00
if ( cond_ast ) {
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & cond_node , cond_ast ) ;
opnum_jmpz = zend_emit_cond_jump ( ZEND_JMPZ , & cond_node , 0 ) ;
2014-07-10 14:38:04 +00:00
}
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_stmt ( stmt_ast ) ;
2014-07-10 14:38:04 +00:00
2014-07-27 20:26:06 +00:00
if ( i ! = list - > children - 1 ) {
2014-12-13 22:06:14 +00:00
jmp_opnums [ i ] = zend_emit_jump ( 0 ) ;
2014-07-10 14:38:04 +00:00
}
if ( cond_ast ) {
2014-12-13 22:06:14 +00:00
zend_update_jump_target_to_next ( opnum_jmpz ) ;
2014-07-10 14:38:04 +00:00
}
1999-04-07 18:10:10 +00:00
}
2014-07-10 14:38:04 +00:00
2014-08-26 17:39:40 +00:00
if ( list - > children > 1 ) {
for ( i = 0 ; i < list - > children - 1 ; + + i ) {
2014-12-13 22:06:14 +00:00
zend_update_jump_target_to_next ( jmp_opnums [ i ] ) ;
2014-08-26 17:39:40 +00:00
}
efree ( jmp_opnums ) ;
2014-07-10 14:38:04 +00:00
}
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_switch ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-11 13:31:47 +00:00
zend_ast * expr_ast = ast - > child [ 0 ] ;
2014-07-27 20:26:06 +00:00
zend_ast_list * cases = zend_ast_get_list ( ast - > child [ 1 ] ) ;
2001-10-29 17:19:02 +00:00
2014-08-25 19:21:16 +00:00
uint32_t i ;
2014-07-11 13:31:47 +00:00
zend_bool has_default_case = 0 ;
2004-01-12 07:15:55 +00:00
2014-07-11 13:31:47 +00:00
znode expr_node , case_node ;
zend_op * opline ;
2014-08-25 19:21:16 +00:00
uint32_t * jmpnz_opnums = safe_emalloc ( sizeof ( uint32_t ) , cases - > children , 0 ) ;
uint32_t opnum_default_jmp ;
2006-12-21 02:09:36 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & expr_node , expr_ast ) ;
2003-02-10 16:11:24 +00:00
2015-08-04 04:37:06 +00:00
zend_begin_loop ( ZEND_FREE , & expr_node ) ;
2007-09-28 19:52:53 +00:00
2014-07-11 13:31:47 +00:00
case_node . op_type = IS_TMP_VAR ;
case_node . u . op . var = get_temporary_variable ( CG ( active_op_array ) ) ;
2007-09-28 19:52:53 +00:00
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < cases - > children ; + + i ) {
zend_ast * case_ast = cases - > child [ i ] ;
2014-07-11 13:31:47 +00:00
zend_ast * cond_ast = case_ast - > child [ 0 ] ;
znode cond_node ;
2007-11-12 15:52:22 +00:00
2014-07-11 13:31:47 +00:00
if ( ! cond_ast ) {
2014-09-05 22:07:07 +00:00
if ( has_default_case ) {
CG ( zend_lineno ) = case_ast - > lineno ;
zend_error_noreturn ( E_COMPILE_ERROR ,
" Switch statements may only contain one default clause " ) ;
}
2014-07-11 13:31:47 +00:00
has_default_case = 1 ;
continue ;
2007-11-12 15:52:22 +00:00
}
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & cond_node , cond_ast ) ;
1999-04-07 18:10:10 +00:00
2015-01-19 14:02:17 +00:00
if ( expr_node . op_type = = IS_CONST
& & Z_TYPE ( expr_node . u . constant ) = = IS_FALSE ) {
jmpnz_opnums [ i ] = zend_emit_cond_jump ( ZEND_JMPZ , & cond_node , 0 ) ;
} else if ( expr_node . op_type = = IS_CONST
& & Z_TYPE ( expr_node . u . constant ) = = IS_TRUE ) {
jmpnz_opnums [ i ] = zend_emit_cond_jump ( ZEND_JMPNZ , & cond_node , 0 ) ;
} else {
opline = zend_emit_op ( NULL , ZEND_CASE , & expr_node , & cond_node ) ;
SET_NODE ( opline - > result , & case_node ) ;
if ( opline - > op1_type = = IS_CONST ) {
zval_copy_ctor ( CT_CONSTANT ( opline - > op1 ) ) ;
}
2014-07-11 13:31:47 +00:00
2015-01-19 14:02:17 +00:00
jmpnz_opnums [ i ] = zend_emit_cond_jump ( ZEND_JMPNZ , & case_node , 0 ) ;
}
2001-10-29 17:19:02 +00:00
}
2014-12-13 22:06:14 +00:00
opnum_default_jmp = zend_emit_jump ( 0 ) ;
2013-01-28 02:02:51 +00:00
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < cases - > children ; + + i ) {
zend_ast * case_ast = cases - > child [ i ] ;
2014-07-11 13:31:47 +00:00
zend_ast * cond_ast = case_ast - > child [ 0 ] ;
zend_ast * stmt_ast = case_ast - > child [ 1 ] ;
2006-05-09 23:53:23 +00:00
2014-07-11 13:31:47 +00:00
if ( cond_ast ) {
2014-12-13 22:06:14 +00:00
zend_update_jump_target_to_next ( jmpnz_opnums [ i ] ) ;
2014-07-11 13:31:47 +00:00
} else {
2014-12-13 22:06:14 +00:00
zend_update_jump_target_to_next ( opnum_default_jmp ) ;
2012-08-22 10:32:03 +00:00
}
2014-12-13 22:06:14 +00:00
zend_compile_stmt ( stmt_ast ) ;
1999-07-08 16:55:27 +00:00
}
2002-09-24 19:05:53 +00:00
2014-07-11 13:31:47 +00:00
if ( ! has_default_case ) {
2014-12-13 22:06:14 +00:00
zend_update_jump_target_to_next ( opnum_default_jmp ) ;
2014-07-11 13:31:47 +00:00
}
2003-03-05 11:14:44 +00:00
2015-05-22 19:35:33 +00:00
zend_end_loop ( get_next_op_number ( CG ( active_op_array ) ) ) ;
2003-04-02 16:51:49 +00:00
2014-07-11 13:31:47 +00:00
if ( expr_node . op_type = = IS_VAR | | expr_node . op_type = = IS_TMP_VAR ) {
2015-05-22 19:35:33 +00:00
zend_emit_op ( NULL , ZEND_FREE , & expr_node , NULL ) ;
2014-07-11 13:31:47 +00:00
} else if ( expr_node . op_type = = IS_CONST ) {
zval_dtor ( & expr_node . u . constant ) ;
2003-04-02 16:51:49 +00:00
}
2014-07-11 13:31:47 +00:00
2014-07-11 13:33:39 +00:00
efree ( jmpnz_opnums ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_try ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-12 11:50:58 +00:00
zend_ast * try_ast = ast - > child [ 0 ] ;
2014-07-27 20:26:06 +00:00
zend_ast_list * catches = zend_ast_get_list ( ast - > child [ 1 ] ) ;
2014-07-12 11:50:58 +00:00
zend_ast * finally_ast = ast - > child [ 2 ] ;
2003-03-06 22:53:23 +00:00
2014-08-25 19:21:16 +00:00
uint32_t i ;
2014-07-12 11:50:58 +00:00
zend_op * opline ;
2015-07-10 21:29:07 +00:00
uint32_t try_catch_offset ;
2014-08-25 19:21:16 +00:00
uint32_t * jmp_opnums = safe_emalloc ( sizeof ( uint32_t ) , catches - > children , 0 ) ;
2003-03-06 22:53:23 +00:00
2014-07-27 20:26:06 +00:00
if ( catches - > children = = 0 & & ! finally_ast ) {
2014-07-12 11:50:58 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use try without catch or finally " ) ;
}
2003-05-29 19:00:40 +00:00
2015-07-10 21:29:07 +00:00
/* label: try { } must not be equal to try { label: } */
if ( CG ( context ) . labels ) {
2015-07-11 10:59:09 +00:00
zend_label * label ;
ZEND_HASH_REVERSE_FOREACH_PTR ( CG ( context ) . labels , label ) {
2015-07-10 21:29:07 +00:00
if ( label - > opline_num = = get_next_op_number ( CG ( active_op_array ) ) ) {
2015-07-10 21:35:05 +00:00
zend_emit_op ( NULL , ZEND_NOP , NULL , NULL ) ;
2015-07-10 21:29:07 +00:00
}
2015-07-11 10:59:09 +00:00
break ;
} ZEND_HASH_FOREACH_END ( ) ;
2015-07-10 21:29:07 +00:00
}
try_catch_offset = zend_add_try_element ( get_next_op_number ( CG ( active_op_array ) ) ) ;
2015-07-10 11:30:25 +00:00
if ( finally_ast ) {
zend_loop_var fast_call ;
if ( ! ( CG ( active_op_array ) - > fn_flags & ZEND_ACC_HAS_FINALLY_BLOCK ) ) {
CG ( active_op_array ) - > fn_flags | = ZEND_ACC_HAS_FINALLY_BLOCK ;
CG ( context ) . fast_call_var = get_temporary_variable ( CG ( active_op_array ) ) ;
}
/* Push FAST_CALL on unwind stack */
fast_call . opcode = ZEND_FAST_CALL ;
2015-08-04 04:37:06 +00:00
fast_call . var_type = IS_TMP_VAR ;
fast_call . var_num = CG ( context ) . fast_call_var ;
fast_call . u . try_catch_offset = try_catch_offset ;
2015-07-10 11:30:25 +00:00
zend_stack_push ( & CG ( loop_var_stack ) , & fast_call ) ;
}
2014-12-13 22:06:14 +00:00
zend_compile_stmt ( try_ast ) ;
2014-07-12 11:50:58 +00:00
2014-07-27 20:26:06 +00:00
if ( catches - > children ! = 0 ) {
2014-12-13 22:06:14 +00:00
jmp_opnums [ 0 ] = zend_emit_jump ( 0 ) ;
2003-08-23 15:38:58 +00:00
}
2014-07-12 11:50:58 +00:00
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < catches - > children ; + + i ) {
zend_ast * catch_ast = catches - > child [ i ] ;
2014-07-12 11:50:58 +00:00
zend_ast * class_ast = catch_ast - > child [ 0 ] ;
zend_ast * var_ast = catch_ast - > child [ 1 ] ;
zend_ast * stmt_ast = catch_ast - > child [ 2 ] ;
zval * var_name = zend_ast_get_zval ( var_ast ) ;
2014-07-27 20:26:06 +00:00
zend_bool is_last_catch = ( i + 1 = = catches - > children ) ;
2014-07-12 11:50:58 +00:00
2014-08-25 19:21:16 +00:00
uint32_t opnum_catch ;
2014-07-12 11:50:58 +00:00
2014-07-19 21:30:07 +00:00
if ( ! zend_is_const_default_class_ref ( class_ast ) ) {
2014-07-12 11:50:58 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Bad class name in the catch statement " ) ;
2003-09-02 13:26:25 +00:00
}
2014-07-12 11:50:58 +00:00
opnum_catch = get_next_op_number ( CG ( active_op_array ) ) ;
2014-07-12 14:25:47 +00:00
if ( i = = 0 ) {
CG ( active_op_array ) - > try_catch_array [ try_catch_offset ] . catch_op = opnum_catch ;
2004-01-23 20:52:39 +00:00
}
2003-08-23 15:38:58 +00:00
2014-07-16 21:27:27 +00:00
CG ( zend_lineno ) = catch_ast - > lineno ;
2013-01-28 02:02:51 +00:00
2014-12-13 22:06:14 +00:00
opline = get_next_op ( CG ( active_op_array ) ) ;
2014-07-12 11:50:58 +00:00
opline - > opcode = ZEND_CATCH ;
opline - > op1_type = IS_CONST ;
2014-07-19 21:30:07 +00:00
opline - > op1 . constant = zend_add_class_name_literal ( CG ( active_op_array ) ,
2014-12-13 22:06:14 +00:00
zend_resolve_class_name_ast ( class_ast ) ) ;
2010-05-07 16:29:15 +00:00
2014-07-12 11:50:58 +00:00
opline - > op2_type = IS_CV ;
2014-12-13 22:06:14 +00:00
opline - > op2 . var = lookup_cv ( CG ( active_op_array ) , zend_string_copy ( Z_STR_P ( var_name ) ) ) ;
2014-07-12 17:08:09 +00:00
opline - > result . num = is_last_catch ;
2010-05-07 16:29:15 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_stmt ( stmt_ast ) ;
2003-03-31 20:42:01 +00:00
2014-07-12 17:08:09 +00:00
if ( ! is_last_catch ) {
2014-12-13 22:06:14 +00:00
jmp_opnums [ i + 1 ] = zend_emit_jump ( 0 ) ;
2004-02-27 09:14:55 +00:00
}
2014-07-12 11:50:58 +00:00
opline = & CG ( active_op_array ) - > opcodes [ opnum_catch ] ;
opline - > extended_value = get_next_op_number ( CG ( active_op_array ) ) ;
2003-03-06 22:53:23 +00:00
}
2014-07-12 11:50:58 +00:00
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < catches - > children ; + + i ) {
2014-12-13 22:06:14 +00:00
zend_update_jump_target_to_next ( jmp_opnums [ i ] ) ;
2014-07-12 11:50:58 +00:00
}
if ( finally_ast ) {
2014-08-25 19:21:16 +00:00
uint32_t opnum_jmp = get_next_op_number ( CG ( active_op_array ) ) + 1 ;
2015-07-10 11:30:25 +00:00
/* Pop FAST_CALL from unwind stack */
zend_stack_del_top ( & CG ( loop_var_stack ) ) ;
2014-11-27 06:56:43 +00:00
2015-12-31 09:46:43 +00:00
CG ( zend_lineno ) = finally_ast - > lineno ;
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( NULL , ZEND_FAST_CALL , NULL , NULL ) ;
2015-08-04 05:35:40 +00:00
opline - > op1 . num = try_catch_offset ;
2014-11-27 06:56:43 +00:00
opline - > result_type = IS_TMP_VAR ;
opline - > result . var = CG ( context ) . fast_call_var ;
2014-07-12 11:50:58 +00:00
2014-12-13 22:06:14 +00:00
zend_emit_op ( NULL , ZEND_JMP , NULL , NULL ) ;
2014-07-12 11:50:58 +00:00
CG ( context ) . in_finally + + ;
2014-12-13 22:06:14 +00:00
zend_compile_stmt ( finally_ast ) ;
2014-07-12 11:50:58 +00:00
CG ( context ) . in_finally - - ;
CG ( active_op_array ) - > try_catch_array [ try_catch_offset ] . finally_op = opnum_jmp + 1 ;
CG ( active_op_array ) - > try_catch_array [ try_catch_offset ] . finally_end
= get_next_op_number ( CG ( active_op_array ) ) ;
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( NULL , ZEND_FAST_RET , NULL , NULL ) ;
2014-11-27 06:56:43 +00:00
opline - > op1_type = IS_TMP_VAR ;
opline - > op1 . var = CG ( context ) . fast_call_var ;
2014-07-12 11:50:58 +00:00
2014-12-13 22:06:14 +00:00
zend_update_jump_target_to_next ( opnum_jmp ) ;
2006-06-07 09:21:06 +00:00
}
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-07-12 11:50:58 +00:00
efree ( jmp_opnums ) ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-12 11:50:58 +00:00
2014-08-18 14:07:18 +00:00
/* Encoding declarations must already be handled during parsing */
2014-12-13 22:06:14 +00:00
void zend_handle_encoding_declaration ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-08-29 18:52:26 +00:00
zend_ast_list * declares = zend_ast_get_list ( ast ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < declares - > children ; + + i ) {
zend_ast * declare_ast = declares - > child [ i ] ;
2014-07-22 14:11:19 +00:00
zend_ast * name_ast = declare_ast - > child [ 0 ] ;
zend_ast * value_ast = declare_ast - > child [ 1 ] ;
2014-07-28 13:16:35 +00:00
zend_string * name = zend_ast_get_str ( name_ast ) ;
2014-07-22 14:11:19 +00:00
2014-08-25 20:40:58 +00:00
if ( zend_string_equals_literal_ci ( name , " encoding " ) ) {
2014-08-18 14:07:18 +00:00
if ( value_ast - > kind ! = ZEND_AST_ZVAL ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Encoding must be a literal " ) ;
2014-07-22 14:11:19 +00:00
}
if ( CG ( multibyte ) ) {
2014-08-18 14:07:18 +00:00
zend_string * encoding_name = zval_get_string ( zend_ast_get_zval ( value_ast ) ) ;
2014-07-22 14:11:19 +00:00
const zend_encoding * new_encoding , * old_encoding ;
zend_encoding_filter old_input_filter ;
CG ( encoding_declared ) = 1 ;
2015-06-30 10:59:27 +00:00
new_encoding = zend_multibyte_fetch_encoding ( ZSTR_VAL ( encoding_name ) ) ;
2014-07-22 14:11:19 +00:00
if ( ! new_encoding ) {
2015-06-30 10:59:27 +00:00
zend_error ( E_COMPILE_WARNING , " Unsupported encoding [%s] " , ZSTR_VAL ( encoding_name ) ) ;
2014-07-22 14:11:19 +00:00
} else {
old_input_filter = LANG_SCNG ( input_filter ) ;
old_encoding = LANG_SCNG ( script_encoding ) ;
2014-12-13 22:06:14 +00:00
zend_multibyte_set_filter ( new_encoding ) ;
2014-07-22 14:11:19 +00:00
/* need to re-scan if input filter changed */
if ( old_input_filter ! = LANG_SCNG ( input_filter ) | |
( old_input_filter & & new_encoding ! = old_encoding ) ) {
2014-12-13 22:06:14 +00:00
zend_multibyte_yyinput_again ( old_input_filter , old_encoding ) ;
2014-07-22 14:11:19 +00:00
}
}
2014-08-18 14:07:18 +00:00
2014-08-25 19:21:16 +00:00
zend_string_release ( encoding_name ) ;
2014-07-22 14:11:19 +00:00
} else {
zend_error ( E_COMPILE_WARNING , " declare(encoding=...) ignored because "
" Zend multibyte feature is turned off by settings " ) ;
}
2014-08-18 14:07:18 +00:00
}
}
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2015-02-20 20:56:58 +00:00
static int zend_declare_is_first_statement ( zend_ast * ast ) /* { { { */
{
uint32_t i = 0 ;
zend_ast_list * file_ast = zend_ast_get_list ( CG ( ast ) ) ;
/* Check to see if this declare is preceeded only by declare statements */
while ( i < file_ast - > children ) {
if ( file_ast - > child [ i ] = = ast ) {
return SUCCESS ;
} else if ( file_ast - > child [ i ] = = NULL ) {
/* Empty statements are not allowed prior to a declare */
return FAILURE ;
} else if ( file_ast - > child [ i ] - > kind ! = ZEND_AST_DECLARE ) {
/* declares can only be preceeded by other declares */
return FAILURE ;
}
i + + ;
}
return FAILURE ;
}
/* }}} */
2014-12-13 22:06:14 +00:00
void zend_compile_declare ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-08-18 14:07:18 +00:00
zend_ast_list * declares = zend_ast_get_list ( ast - > child [ 0 ] ) ;
zend_ast * stmt_ast = ast - > child [ 1 ] ;
2015-04-20 18:16:58 +00:00
zend_declarables orig_declarables = FC ( declarables ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2014-08-18 14:07:18 +00:00
for ( i = 0 ; i < declares - > children ; + + i ) {
zend_ast * declare_ast = declares - > child [ i ] ;
zend_ast * name_ast = declare_ast - > child [ 0 ] ;
zend_ast * value_ast = declare_ast - > child [ 1 ] ;
zend_string * name = zend_ast_get_str ( name_ast ) ;
2014-08-25 20:40:58 +00:00
if ( zend_string_equals_literal_ci ( name , " ticks " ) ) {
2014-08-18 14:07:18 +00:00
zval value_zv ;
2014-12-13 22:06:14 +00:00
zend_const_expr_to_zval ( & value_zv , value_ast ) ;
2015-04-20 18:16:58 +00:00
FC ( declarables ) . ticks = zval_get_long ( & value_zv ) ;
2014-07-22 14:11:19 +00:00
zval_dtor ( & value_zv ) ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal_ci ( name , " encoding " ) ) {
2015-03-20 08:10:29 +00:00
2015-02-20 20:56:58 +00:00
if ( FAILURE = = zend_declare_is_first_statement ( ast ) ) {
2014-08-18 14:07:18 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Encoding declaration pragma must be "
" the very first statement in the script " ) ;
}
2015-01-25 01:40:54 +00:00
} else if ( zend_string_equals_literal_ci ( name , " strict_types " ) ) {
2015-01-10 03:29:41 +00:00
zval value_zv ;
2015-02-18 15:26:29 +00:00
2015-02-20 20:56:58 +00:00
if ( FAILURE = = zend_declare_is_first_statement ( ast ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " strict_types declaration must be "
" the very first statement in the script " ) ;
}
2015-02-18 15:26:29 +00:00
2015-02-20 20:56:58 +00:00
if ( ast - > child [ 1 ] ! = NULL ) {
zend_error_noreturn ( E_COMPILE_ERROR , " strict_types declaration must not "
2015-03-20 08:10:29 +00:00
" use block mode " ) ;
2015-02-20 20:56:58 +00:00
}
2015-02-18 17:43:57 +00:00
2015-02-20 20:56:58 +00:00
zend_const_expr_to_zval ( & value_zv , value_ast ) ;
2015-01-10 03:29:41 +00:00
2015-01-25 01:40:54 +00:00
if ( Z_TYPE ( value_zv ) ! = IS_LONG | | ( Z_LVAL ( value_zv ) ! = 0 & & Z_LVAL ( value_zv ) ! = 1 ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " strict_types declaration must have 0 or 1 as its value " ) ;
2015-01-10 03:29:41 +00:00
}
2015-03-19 17:30:11 +00:00
if ( Z_LVAL ( value_zv ) = = 1 ) {
CG ( active_op_array ) - > fn_flags | = ZEND_ACC_STRICT_TYPES ;
}
2015-03-20 08:10:29 +00:00
2014-07-22 14:11:19 +00:00
} else {
2015-06-30 10:59:27 +00:00
zend_error ( E_COMPILE_WARNING , " Unsupported declare '%s' " , ZSTR_VAL ( name ) ) ;
2014-07-22 14:11:19 +00:00
}
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-07-22 14:11:19 +00:00
if ( stmt_ast ) {
2014-12-13 22:06:14 +00:00
zend_compile_stmt ( stmt_ast ) ;
2014-07-22 14:11:19 +00:00
2015-04-20 18:16:58 +00:00
FC ( declarables ) = orig_declarables ;
2005-06-24 08:45:17 +00:00
}
2014-07-22 14:11:19 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2006-05-09 23:53:23 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_stmt_list ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-27 20:26:06 +00:00
zend_ast_list * list = zend_ast_get_list ( ast ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < list - > children ; + + i ) {
2014-12-13 22:06:14 +00:00
zend_compile_stmt ( list - > child [ i ] ) ;
2014-07-09 21:39:21 +00:00
}
2003-03-05 11:14:44 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2003-03-05 11:14:44 +00:00
2015-04-23 10:31:02 +00:00
ZEND_API void zend_set_function_arg_flags ( zend_function * func ) /* { { { */
2015-04-22 18:46:13 +00:00
{
uint32_t i , n ;
func - > common . arg_flags [ 0 ] = 0 ;
func - > common . arg_flags [ 1 ] = 0 ;
func - > common . arg_flags [ 2 ] = 0 ;
if ( func - > common . arg_info ) {
n = MIN ( func - > common . num_args , MAX_ARG_FLAG_NUM ) ;
i = 0 ;
while ( i < n ) {
ZEND_SET_ARG_FLAG ( func , i + 1 , func - > common . arg_info [ i ] . pass_by_reference ) ;
i + + ;
}
2015-04-23 13:50:38 +00:00
if ( UNEXPECTED ( func - > common . fn_flags & ZEND_ACC_VARIADIC & & func - > common . arg_info [ i ] . pass_by_reference ) ) {
2015-04-25 16:47:26 +00:00
uint32_t pass_by_reference = func - > common . arg_info [ i ] . pass_by_reference ;
2015-04-22 18:46:13 +00:00
while ( i < MAX_ARG_FLAG_NUM ) {
2015-04-25 16:47:26 +00:00
ZEND_SET_ARG_FLAG ( func , i + 1 , pass_by_reference ) ;
2015-04-22 18:46:13 +00:00
i + + ;
}
}
}
}
/* }}} */
2015-05-21 01:50:20 +00:00
static void zend_compile_typename ( zend_ast * ast , zend_arg_info * arg_info ) /* { { { */
{
if ( ast - > kind = = ZEND_AST_TYPE ) {
arg_info - > type_hint = ast - > attr ;
} else {
zend_string * class_name = zend_ast_get_str ( ast ) ;
zend_uchar type = zend_lookup_builtin_type_by_name ( class_name ) ;
if ( type ! = 0 ) {
2015-11-26 15:56:08 +00:00
if ( ast - > attr ! = ZEND_NAME_NOT_FQ ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
" Scalar type declaration '%s' must be unqualified " ,
ZSTR_VAL ( zend_string_tolower ( class_name ) ) ) ;
2015-11-24 20:39:06 +00:00
}
2015-05-21 01:50:20 +00:00
arg_info - > type_hint = type ;
} else {
uint32_t fetch_type = zend_get_class_fetch_type_ast ( ast ) ;
if ( fetch_type = = ZEND_FETCH_CLASS_DEFAULT ) {
class_name = zend_resolve_class_name_ast ( ast ) ;
zend_assert_valid_class_name ( class_name ) ;
} else {
zend_ensure_valid_class_fetch_type ( fetch_type ) ;
zend_string_addref ( class_name ) ;
}
arg_info - > type_hint = IS_OBJECT ;
arg_info - > class_name = class_name ;
}
}
}
/* }}} */
2015-04-27 19:14:58 +00:00
void zend_compile_params ( zend_ast * ast , zend_ast * return_type_ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-27 20:26:06 +00:00
zend_ast_list * list = zend_ast_get_list ( ast ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2014-07-14 21:03:53 +00:00
zend_op_array * op_array = CG ( active_op_array ) ;
zend_arg_info * arg_infos ;
2015-01-08 20:40:36 +00:00
if ( return_type_ast ) {
2015-10-20 16:50:13 +00:00
/* Use op_array->arg_info[-1] for return type */
2015-01-08 20:40:36 +00:00
arg_infos = safe_emalloc ( sizeof ( zend_arg_info ) , list - > children + 1 , 0 ) ;
arg_infos - > name = NULL ;
arg_infos - > pass_by_reference = ( op_array - > fn_flags & ZEND_ACC_RETURN_REFERENCE ) ! = 0 ;
arg_infos - > is_variadic = 0 ;
arg_infos - > type_hint = 0 ;
arg_infos - > allow_null = 0 ;
arg_infos - > class_name = NULL ;
2015-05-21 01:50:20 +00:00
zend_compile_typename ( return_type_ast , arg_infos ) ;
2015-01-08 20:40:36 +00:00
arg_infos + + ;
op_array - > fn_flags | = ZEND_ACC_HAS_RETURN_TYPE ;
} else {
if ( list - > children = = 0 ) {
return ;
}
arg_infos = safe_emalloc ( sizeof ( zend_arg_info ) , list - > children , 0 ) ;
2011-12-19 10:05:48 +00:00
}
2015-01-03 09:22:58 +00:00
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < list - > children ; + + i ) {
zend_ast * param_ast = list - > child [ i ] ;
2014-07-14 21:03:53 +00:00
zend_ast * type_ast = param_ast - > child [ 0 ] ;
zend_ast * var_ast = param_ast - > child [ 1 ] ;
zend_ast * default_ast = param_ast - > child [ 2 ] ;
2014-07-28 13:16:35 +00:00
zend_string * name = zend_ast_get_str ( var_ast ) ;
2014-07-14 21:03:53 +00:00
zend_bool is_ref = ( param_ast - > attr & ZEND_PARAM_REF ) ! = 0 ;
zend_bool is_variadic = ( param_ast - > attr & ZEND_PARAM_VARIADIC ) ! = 0 ;
znode var_node , default_node ;
zend_uchar opcode ;
zend_op * opline ;
zend_arg_info * arg_info ;
2011-11-01 00:39:10 +00:00
2014-12-13 22:06:14 +00:00
if ( zend_is_auto_global ( name ) ) {
2014-07-14 21:03:53 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot re-assign auto-global variable %s " ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( name ) ) ;
2014-07-14 21:03:53 +00:00
}
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-07-14 21:03:53 +00:00
var_node . op_type = IS_CV ;
2014-12-13 22:06:14 +00:00
var_node . u . op . var = lookup_cv ( CG ( active_op_array ) , zend_string_copy ( name ) ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-07-22 14:55:34 +00:00
if ( EX_VAR_TO_NUM ( var_node . u . op . var ) ! = i ) {
2014-08-25 19:21:16 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Redefinition of parameter $%s " ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( name ) ) ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( name , " this " ) ) {
2014-07-14 21:03:53 +00:00
if ( op_array - > scope & & ( op_array - > fn_flags & ZEND_ACC_STATIC ) = = 0 ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot re-assign $this " ) ;
}
op_array - > this_var = var_node . u . op . var ;
}
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-07-14 21:03:53 +00:00
if ( op_array - > fn_flags & ZEND_ACC_VARIADIC ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Only the last parameter can be variadic " ) ;
}
2006-05-09 23:53:23 +00:00
2014-07-14 21:03:53 +00:00
if ( is_variadic ) {
opcode = ZEND_RECV_VARIADIC ;
default_node . op_type = IS_UNUSED ;
op_array - > fn_flags | = ZEND_ACC_VARIADIC ;
1999-04-07 18:10:10 +00:00
2014-07-14 21:03:53 +00:00
if ( default_ast ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
" Variadic parameter cannot have a default value " ) ;
}
} else if ( default_ast ) {
2015-02-10 21:17:43 +00:00
/* we cannot substitute constants here or it will break ReflectionParameter::getDefaultValueConstantName() and ReflectionParameter::isDefaultValueConstant() */
uint32_t cops = CG ( compiler_options ) ;
CG ( compiler_options ) | = ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION | ZEND_COMPILE_NO_PERSISTENT_CONSTANT_SUBSTITUTION ;
2014-07-14 21:03:53 +00:00
opcode = ZEND_RECV_INIT ;
default_node . op_type = IS_CONST ;
2014-12-13 22:06:14 +00:00
zend_const_expr_to_zval ( & default_node . u . constant , default_ast ) ;
2015-02-10 21:17:43 +00:00
CG ( compiler_options ) = cops ;
2014-07-14 21:03:53 +00:00
} else {
opcode = ZEND_RECV ;
default_node . op_type = IS_UNUSED ;
op_array - > required_num_args = i + 1 ;
}
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( NULL , opcode , NULL , & default_node ) ;
2014-07-14 21:03:53 +00:00
SET_NODE ( opline - > result , & var_node ) ;
opline - > op1 . num = i + 1 ;
arg_info = & arg_infos [ i ] ;
2014-12-03 13:56:09 +00:00
arg_info - > name = zend_string_copy ( name ) ;
2014-07-14 21:03:53 +00:00
arg_info - > pass_by_reference = is_ref ;
arg_info - > is_variadic = is_variadic ;
arg_info - > type_hint = 0 ;
arg_info - > allow_null = 1 ;
arg_info - > class_name = NULL ;
if ( type_ast ) {
zend_bool has_null_default = default_ast
& & ( Z_TYPE ( default_node . u . constant ) = = IS_NULL
| | ( Z_TYPE ( default_node . u . constant ) = = IS_CONSTANT
2014-11-25 15:12:30 +00:00
& & strcasecmp ( Z_STRVAL ( default_node . u . constant ) , " NULL " ) = = 0 ) ) ;
2014-07-14 21:03:53 +00:00
op_array - > fn_flags | = ZEND_ACC_HAS_TYPE_HINTS ;
arg_info - > allow_null = has_null_default ;
2015-05-21 01:50:20 +00:00
zend_compile_typename ( type_ast , arg_info ) ;
2014-07-14 21:03:53 +00:00
if ( type_ast - > kind = = ZEND_AST_TYPE ) {
if ( arg_info - > type_hint = = IS_ARRAY ) {
if ( default_ast & & ! has_null_default
& & Z_TYPE ( default_node . u . constant ) ! = IS_ARRAY
2014-11-25 15:12:30 +00:00
& & ! Z_CONSTANT ( default_node . u . constant )
2014-07-14 21:03:53 +00:00
) {
zend_error_noreturn ( E_COMPILE_ERROR , " Default value for parameters "
2015-10-20 16:50:13 +00:00
" with array type can only be an array or NULL " ) ;
2014-07-14 21:03:53 +00:00
}
} else if ( arg_info - > type_hint = = IS_CALLABLE & & default_ast ) {
2014-11-25 15:12:30 +00:00
if ( ! has_null_default & & ! Z_CONSTANT ( default_node . u . constant ) ) {
2014-07-14 21:03:53 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Default value for parameters "
2015-10-20 16:50:13 +00:00
" with callable type can only be NULL " ) ;
2014-07-14 21:03:53 +00:00
}
}
} else {
2014-11-25 15:12:30 +00:00
if ( default_ast & & ! has_null_default & & ! Z_CONSTANT ( default_node . u . constant ) ) {
2014-12-27 17:47:33 +00:00
if ( arg_info - > class_name ) {
2014-07-14 21:03:53 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Default value for parameters "
2015-10-20 16:50:13 +00:00
" with a class type can only be NULL " ) ;
2015-07-02 22:46:51 +00:00
} else switch ( arg_info - > type_hint ) {
case IS_DOUBLE :
if ( Z_TYPE ( default_node . u . constant ) ! = IS_DOUBLE & & Z_TYPE ( default_node . u . constant ) ! = IS_LONG ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Default value for parameters "
2015-10-20 16:50:13 +00:00
" with a float type can only be float, integer, or NULL " ) ;
2015-07-02 22:46:51 +00:00
}
break ;
default :
if ( ! ZEND_SAME_FAKE_TYPE ( arg_info - > type_hint , Z_TYPE ( default_node . u . constant ) ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Default value for parameters "
2015-10-20 16:50:13 +00:00
" with a %s type can only be %s or NULL " ,
2015-07-02 22:46:51 +00:00
zend_get_type_by_const ( arg_info - > type_hint ) , zend_get_type_by_const ( arg_info - > type_hint ) ) ;
}
break ;
2014-12-27 17:47:33 +00:00
}
2014-07-14 21:03:53 +00:00
}
}
2015-06-17 09:07:43 +00:00
/* Allocate cache slot to speed-up run-time class resolution */
if ( opline - > opcode = = ZEND_RECV_INIT ) {
if ( arg_info - > class_name ) {
zend_alloc_cache_slot ( opline - > op2 . constant ) ;
} else {
Z_CACHE_SLOT ( op_array - > literals [ opline - > op2 . constant ] ) = - 1 ;
}
} else {
if ( arg_info - > class_name ) {
opline - > op2 . num = op_array - > cache_size ;
op_array - > cache_size + = sizeof ( void * ) ;
} else {
opline - > op2 . num = - 1 ;
}
}
2015-06-18 11:56:08 +00:00
} else {
if ( opline - > opcode = = ZEND_RECV_INIT ) {
Z_CACHE_SLOT ( op_array - > literals [ opline - > op2 . constant ] ) = - 1 ;
} else {
opline - > op2 . num = - 1 ;
}
}
2003-06-08 18:53:58 +00:00
}
2014-07-14 21:03:53 +00:00
/* These are assigned at the end to avoid unitialized memory in case of an error */
2014-07-27 20:26:06 +00:00
op_array - > num_args = list - > children ;
2014-07-14 21:03:53 +00:00
op_array - > arg_info = arg_infos ;
2014-12-22 13:44:39 +00:00
/* Don't count the variadic argument */
if ( op_array - > fn_flags & ZEND_ACC_VARIADIC ) {
op_array - > num_args - - ;
2015-01-03 09:22:58 +00:00
}
2015-04-22 18:46:13 +00:00
zend_set_function_arg_flags ( ( zend_function * ) op_array ) ;
2014-07-14 21:03:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-14 21:03:53 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_closure_uses ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-27 20:26:06 +00:00
zend_ast_list * list = zend_ast_get_list ( ast ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2014-07-18 10:30:39 +00:00
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < list - > children ; + + i ) {
zend_ast * var_ast = list - > child [ i ] ;
2014-07-28 13:16:35 +00:00
zend_string * name = zend_ast_get_str ( var_ast ) ;
2014-07-18 10:30:39 +00:00
zend_bool by_ref = var_ast - > attr ;
zval zv ;
2014-08-25 20:40:58 +00:00
if ( zend_string_equals_literal ( name , " this " ) ) {
2014-07-18 10:30:39 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use $this as lexical variable " ) ;
2013-01-14 08:23:22 +00:00
}
2014-07-18 10:30:39 +00:00
ZVAL_NULL ( & zv ) ;
Z_CONST_FLAGS ( zv ) = by_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR ;
2014-12-13 22:06:14 +00:00
zend_compile_static_var_common ( var_ast , & zv , by_ref ) ;
2013-01-14 08:23:22 +00:00
}
2003-06-08 18:53:58 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2003-06-08 18:53:58 +00:00
2014-12-13 22:06:14 +00:00
void zend_begin_method_decl ( zend_op_array * op_array , zend_string * name , zend_bool has_body ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-19 10:52:44 +00:00
zend_class_entry * ce = CG ( active_class_entry ) ;
zend_bool in_interface = ( ce - > ce_flags & ZEND_ACC_INTERFACE ) ! = 0 ;
2015-02-12 22:19:14 +00:00
zend_bool in_trait = ( ce - > ce_flags & ZEND_ACC_TRAIT ) ! = 0 ;
2014-07-19 10:52:44 +00:00
zend_bool is_public = ( op_array - > fn_flags & ZEND_ACC_PUBLIC ) ! = 0 ;
zend_bool is_static = ( op_array - > fn_flags & ZEND_ACC_STATIC ) ! = 0 ;
1999-12-26 21:21:33 +00:00
2014-07-19 10:52:44 +00:00
zend_string * lcname ;
2003-03-05 11:14:44 +00:00
2014-07-19 10:52:44 +00:00
if ( in_interface ) {
2016-03-21 21:49:18 +00:00
if ( ! is_public | | ( op_array - > fn_flags & ( ZEND_ACC_FINAL | ZEND_ACC_ABSTRACT ) ) ) {
2014-07-19 10:52:44 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Access type for interface method "
2015-06-30 10:59:27 +00:00
" %s::%s() must be omitted " , ZSTR_VAL ( ce - > name ) , ZSTR_VAL ( name ) ) ;
2014-07-19 10:52:44 +00:00
}
op_array - > fn_flags | = ZEND_ACC_ABSTRACT ;
2003-02-11 09:48:37 +00:00
}
2014-07-19 10:52:44 +00:00
if ( op_array - > fn_flags & ZEND_ACC_ABSTRACT ) {
if ( op_array - > fn_flags & ZEND_ACC_PRIVATE ) {
zend_error_noreturn ( E_COMPILE_ERROR , " %s function %s::%s() cannot be declared private " ,
2015-06-30 10:59:27 +00:00
in_interface ? " Interface " : " Abstract " , ZSTR_VAL ( ce - > name ) , ZSTR_VAL ( name ) ) ;
2014-07-19 10:52:44 +00:00
}
1999-04-07 18:10:10 +00:00
2014-07-19 10:52:44 +00:00
if ( has_body ) {
zend_error_noreturn ( E_COMPILE_ERROR , " %s function %s::%s() cannot contain body " ,
2015-06-30 10:59:27 +00:00
in_interface ? " Interface " : " Abstract " , ZSTR_VAL ( ce - > name ) , ZSTR_VAL ( name ) ) ;
2014-07-19 10:52:44 +00:00
}
2002-02-14 04:01:53 +00:00
2014-07-19 10:52:44 +00:00
ce - > ce_flags | = ZEND_ACC_IMPLICIT_ABSTRACT_CLASS ;
} else if ( ! has_body ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Non-abstract method %s::%s() must contain body " ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( ce - > name ) , ZSTR_VAL ( name ) ) ;
2014-04-03 11:26:23 +00:00
}
1999-04-07 18:10:10 +00:00
2014-07-19 10:52:44 +00:00
op_array - > scope = ce ;
2014-08-25 19:21:16 +00:00
op_array - > function_name = zend_string_copy ( name ) ;
2006-05-09 23:53:23 +00:00
2014-12-24 12:04:51 +00:00
lcname = zend_string_tolower ( name ) ;
2014-12-13 22:06:14 +00:00
lcname = zend_new_interned_string ( lcname ) ;
2013-01-28 02:02:51 +00:00
2014-07-19 10:52:44 +00:00
if ( zend_hash_add_ptr ( & ce - > function_table , lcname , op_array ) = = NULL ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot redeclare %s::%s() " ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( ce - > name ) , ZSTR_VAL ( name ) ) ;
2009-11-14 19:17:22 +00:00
}
2002-12-06 17:09:44 +00:00
2014-07-19 10:52:44 +00:00
if ( in_interface ) {
2014-08-25 20:40:58 +00:00
if ( zend_string_equals_literal ( lcname , ZEND_CALL_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __call() must have "
" public visibility and cannot be static " ) ;
2002-10-16 18:06:36 +00:00
}
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_CALLSTATIC_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | ! is_static ) {
zend_error ( E_WARNING , " The magic method __callStatic() must have "
" public visibility and be static " ) ;
}
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_GET_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __get() must have "
" public visibility and cannot be static " ) ;
}
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_SET_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __set() must have "
" public visibility and cannot be static " ) ;
}
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_UNSET_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __unset() must have "
" public visibility and cannot be static " ) ;
}
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_ISSET_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __isset() must have "
" public visibility and cannot be static " ) ;
}
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_TOSTRING_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __toString() must have "
" public visibility and cannot be static " ) ;
}
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_INVOKE_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __invoke() must have "
" public visibility and cannot be static " ) ;
}
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_DEBUGINFO_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __debugInfo() must have "
" public visibility and cannot be static " ) ;
2010-04-20 10:57:45 +00:00
}
2014-07-19 10:52:44 +00:00
}
} else {
2015-02-11 08:03:48 +00:00
if ( ! in_trait & & zend_string_equals_ci ( lcname , ce - > name ) ) {
2014-07-19 10:52:44 +00:00
if ( ! ce - > constructor ) {
ce - > constructor = ( zend_function * ) op_array ;
}
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_CONSTRUCTOR_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
ce - > constructor = ( zend_function * ) op_array ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_DESTRUCTOR_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
ce - > destructor = ( zend_function * ) op_array ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_CLONE_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
ce - > clone = ( zend_function * ) op_array ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_CALL_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __call() must have "
" public visibility and cannot be static " ) ;
}
ce - > __call = ( zend_function * ) op_array ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_CALLSTATIC_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | ! is_static ) {
zend_error ( E_WARNING , " The magic method __callStatic() must have "
" public visibility and be static " ) ;
}
ce - > __callstatic = ( zend_function * ) op_array ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_GET_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __get() must have "
" public visibility and cannot be static " ) ;
}
ce - > __get = ( zend_function * ) op_array ;
2015-02-04 12:24:13 +00:00
ce - > ce_flags | = ZEND_ACC_USE_GUARDS ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_SET_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __set() must have "
" public visibility and cannot be static " ) ;
}
ce - > __set = ( zend_function * ) op_array ;
2015-02-04 12:24:13 +00:00
ce - > ce_flags | = ZEND_ACC_USE_GUARDS ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_UNSET_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __unset() must have "
" public visibility and cannot be static " ) ;
}
ce - > __unset = ( zend_function * ) op_array ;
2015-02-04 12:24:13 +00:00
ce - > ce_flags | = ZEND_ACC_USE_GUARDS ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_ISSET_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __isset() must have "
" public visibility and cannot be static " ) ;
}
ce - > __isset = ( zend_function * ) op_array ;
2015-02-04 12:24:13 +00:00
ce - > ce_flags | = ZEND_ACC_USE_GUARDS ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_TOSTRING_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __toString() must have "
" public visibility and cannot be static " ) ;
}
ce - > __tostring = ( zend_function * ) op_array ;
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_INVOKE_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __invoke() must have "
" public visibility and cannot be static " ) ;
}
2014-08-25 20:40:58 +00:00
} else if ( zend_string_equals_literal ( lcname , ZEND_DEBUGINFO_FUNC_NAME ) ) {
2014-07-19 10:52:44 +00:00
if ( ! is_public | | is_static ) {
zend_error ( E_WARNING , " The magic method __debugInfo() must have "
" public visibility and cannot be static " ) ;
}
ce - > __debugInfo = ( zend_function * ) op_array ;
} else if ( ! is_static ) {
op_array - > fn_flags | = ZEND_ACC_ALLOW_STATIC ;
2002-01-05 15:18:30 +00:00
}
}
1999-04-07 18:10:10 +00:00
2014-08-25 19:21:16 +00:00
zend_string_release ( lcname ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
static void zend_begin_func_decl ( znode * result , zend_op_array * op_array , zend_ast_decl * decl ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-21 13:38:21 +00:00
zend_ast * params_ast = decl - > child [ 0 ] ;
zend_string * name = decl - > name , * lcname ;
2014-07-21 13:22:13 +00:00
zend_op * opline ;
2013-01-28 02:02:51 +00:00
2014-12-13 22:06:14 +00:00
op_array - > function_name = name = zend_prefix_with_ns ( name ) ;
2013-01-28 02:02:51 +00:00
2014-12-24 12:04:51 +00:00
lcname = zend_string_tolower ( name ) ;
2013-01-28 02:02:51 +00:00
2015-04-20 18:16:58 +00:00
if ( FC ( imports_function ) ) {
zend_string * import_name = zend_hash_find_ptr ( FC ( imports_function ) , lcname ) ;
2015-02-11 08:03:48 +00:00
if ( import_name & & ! zend_string_equals_ci ( lcname , import_name ) ) {
2015-04-01 10:32:23 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot declare function %s "
2015-06-30 10:59:27 +00:00
" because the name is already in use " , ZSTR_VAL ( name ) ) ;
2014-07-21 13:22:13 +00:00
}
2011-05-19 23:20:47 +00:00
}
2003-06-09 13:51:53 +00:00
2014-08-25 20:40:58 +00:00
if ( zend_string_equals_literal ( lcname , ZEND_AUTOLOAD_FUNC_NAME )
2014-07-27 20:26:06 +00:00
& & zend_ast_get_list ( params_ast ) - > children ! = 1
) {
2014-07-21 13:22:13 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " %s() must take exactly 1 argument " ,
ZEND_AUTOLOAD_FUNC_NAME ) ;
}
1999-04-07 18:10:10 +00:00
2014-07-21 13:22:13 +00:00
if ( op_array - > fn_flags & ZEND_ACC_CLOSURE ) {
2014-12-13 22:06:14 +00:00
opline = zend_emit_op_tmp ( result , ZEND_DECLARE_LAMBDA_FUNCTION , NULL , NULL ) ;
2014-07-21 13:22:13 +00:00
} else {
2014-12-13 22:06:14 +00:00
opline = get_next_op ( CG ( active_op_array ) ) ;
2014-07-21 13:22:13 +00:00
opline - > opcode = ZEND_DECLARE_FUNCTION ;
opline - > op2_type = IS_CONST ;
2014-08-25 19:21:16 +00:00
LITERAL_STR ( opline - > op2 , zend_string_copy ( lcname ) ) ;
2003-06-09 13:51:53 +00:00
}
1999-04-07 18:10:10 +00:00
2014-07-21 13:22:13 +00:00
{
2014-12-13 22:06:14 +00:00
zend_string * key = zend_build_runtime_definition_key ( lcname , decl - > lex_pos ) ;
2006-05-09 23:53:23 +00:00
2014-07-21 13:22:13 +00:00
opline - > op1_type = IS_CONST ;
2014-07-29 18:01:11 +00:00
LITERAL_STR ( opline - > op1 , key ) ;
2014-07-21 13:22:13 +00:00
2014-07-29 18:01:11 +00:00
zend_hash_update_ptr ( CG ( function_table ) , key , op_array ) ;
2014-07-21 13:22:13 +00:00
}
2006-05-09 23:53:23 +00:00
2014-08-25 19:21:16 +00:00
zend_string_release ( lcname ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_func_decl ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-21 13:38:21 +00:00
zend_ast_decl * decl = ( zend_ast_decl * ) ast ;
zend_ast * params_ast = decl - > child [ 0 ] ;
zend_ast * uses_ast = decl - > child [ 1 ] ;
zend_ast * stmt_ast = decl - > child [ 2 ] ;
2015-01-08 20:40:36 +00:00
zend_ast * return_type_ast = decl - > child [ 3 ] ;
2014-07-21 13:38:21 +00:00
zend_bool is_method = decl - > kind = = ZEND_AST_METHOD ;
1999-04-07 18:10:10 +00:00
2014-07-18 12:57:00 +00:00
zend_op_array * orig_op_array = CG ( active_op_array ) ;
2014-07-22 14:55:34 +00:00
zend_op_array * op_array = zend_arena_alloc ( & CG ( arena ) , sizeof ( zend_op_array ) ) ;
2015-04-20 15:39:32 +00:00
zend_oparray_context orig_oparray_context ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
init_op_array ( op_array , ZEND_USER_FUNCTION , INITIAL_OP_ARRAY_SIZE ) ;
1999-04-07 18:10:10 +00:00
2015-03-19 17:30:11 +00:00
op_array - > fn_flags | = ( orig_op_array - > fn_flags & ZEND_ACC_STRICT_TYPES ) ;
2014-07-21 13:38:21 +00:00
op_array - > fn_flags | = decl - > flags ;
op_array - > line_start = decl - > start_lineno ;
op_array - > line_end = decl - > end_lineno ;
if ( decl - > doc_comment ) {
2014-08-25 19:21:16 +00:00
op_array - > doc_comment = zend_string_copy ( decl - > doc_comment ) ;
2014-07-18 13:23:16 +00:00
}
2014-07-21 13:38:21 +00:00
if ( decl - > kind = = ZEND_AST_CLOSURE ) {
2015-10-06 20:59:36 +00:00
op_array - > fn_flags | = ZEND_ACC_CLOSURE ;
2014-07-18 11:15:58 +00:00
}
2006-03-15 09:04:36 +00:00
2014-07-19 10:52:44 +00:00
if ( is_method ) {
2014-07-21 13:38:21 +00:00
zend_bool has_body = stmt_ast ! = NULL ;
2014-12-13 22:06:14 +00:00
zend_begin_method_decl ( op_array , decl - > name , has_body ) ;
2014-07-19 10:52:44 +00:00
} else {
2014-12-13 22:06:14 +00:00
zend_begin_func_decl ( result , op_array , decl ) ;
2006-03-15 09:04:36 +00:00
}
2014-07-15 22:06:41 +00:00
CG ( active_op_array ) = op_array ;
2015-07-14 00:37:35 +00:00
2015-04-20 15:39:32 +00:00
zend_oparray_context_begin ( & orig_oparray_context ) ;
2014-07-15 22:06:41 +00:00
if ( CG ( compiler_options ) & ZEND_COMPILE_EXTENDED_INFO ) {
2014-12-13 22:06:14 +00:00
zend_op * opline_ext = zend_emit_op ( NULL , ZEND_EXT_NOP , NULL , NULL ) ;
2014-07-21 13:38:21 +00:00
opline_ext - > lineno = decl - > start_lineno ;
2007-09-28 19:52:53 +00:00
}
2014-07-15 22:06:41 +00:00
2015-07-10 00:31:52 +00:00
{
/* Push a separator to the loop variable stack */
2015-07-10 11:30:25 +00:00
zend_loop_var dummy_var ;
dummy_var . opcode = ZEND_RETURN ;
2015-07-10 00:31:52 +00:00
zend_stack_push ( & CG ( loop_var_stack ) , ( void * ) & dummy_var ) ;
}
2015-04-27 19:14:58 +00:00
zend_compile_params ( params_ast , return_type_ast ) ;
2014-07-27 20:26:06 +00:00
if ( uses_ast ) {
2014-12-13 22:06:14 +00:00
zend_compile_closure_uses ( uses_ast ) ;
2008-11-04 15:58:55 +00:00
}
2014-12-13 22:06:14 +00:00
zend_compile_stmt ( stmt_ast ) ;
2008-11-04 15:58:55 +00:00
2014-07-19 10:52:44 +00:00
if ( is_method ) {
zend_check_magic_method_implementation (
2014-12-13 22:06:14 +00:00
CG ( active_class_entry ) , ( zend_function * ) op_array , E_COMPILE_ERROR ) ;
2014-07-19 10:52:44 +00:00
}
2008-11-11 19:45:29 +00:00
2015-07-31 00:44:42 +00:00
/* put the implicit return on the really last line */
CG ( zend_lineno ) = decl - > end_lineno ;
2014-12-13 22:06:14 +00:00
zend_do_extended_info ( ) ;
zend_emit_final_return ( NULL ) ;
2008-11-11 19:45:29 +00:00
2014-12-13 22:06:14 +00:00
pass_two ( CG ( active_op_array ) ) ;
2015-04-20 15:39:32 +00:00
zend_oparray_context_end ( & orig_oparray_context ) ;
2008-11-11 19:45:29 +00:00
2015-07-10 00:31:52 +00:00
/* Pop the loop variable stack separator */
zend_stack_del_top ( & CG ( loop_var_stack ) ) ;
2014-07-18 10:58:24 +00:00
CG ( active_op_array ) = orig_op_array ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2013-01-28 02:02:51 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_prop_decl ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-27 20:26:06 +00:00
zend_ast_list * list = zend_ast_get_list ( ast ) ;
2014-08-25 19:21:16 +00:00
uint32_t flags = list - > attr ;
2014-07-19 12:54:56 +00:00
zend_class_entry * ce = CG ( active_class_entry ) ;
2014-08-25 19:21:16 +00:00
uint32_t i , children = list - > children ;
2008-11-04 15:58:55 +00:00
2014-07-19 12:54:56 +00:00
if ( ce - > ce_flags & ZEND_ACC_INTERFACE ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Interfaces may not include member variables " ) ;
1999-04-07 18:10:10 +00:00
}
2014-07-19 12:54:56 +00:00
if ( flags & ZEND_ACC_ABSTRACT ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Properties cannot be declared abstract " ) ;
}
2014-06-30 11:43:45 +00:00
2014-07-30 17:12:48 +00:00
for ( i = 0 ; i < children ; + + i ) {
2014-07-27 20:26:06 +00:00
zend_ast * prop_ast = list - > child [ i ] ;
2014-07-19 12:54:56 +00:00
zend_ast * name_ast = prop_ast - > child [ 0 ] ;
zend_ast * value_ast = prop_ast - > child [ 1 ] ;
2015-10-06 20:32:23 +00:00
zend_ast * doc_comment_ast = prop_ast - > child [ 2 ] ;
2014-07-28 13:16:35 +00:00
zend_string * name = zend_ast_get_str ( name_ast ) ;
2015-10-06 20:32:23 +00:00
zend_string * doc_comment = NULL ;
2014-07-19 12:54:56 +00:00
zval value_zv ;
1999-04-07 18:10:10 +00:00
2015-10-06 20:32:23 +00:00
/* Doc comment has been appended as last element in ZEND_AST_PROP_ELEM ast */
if ( doc_comment_ast ) {
doc_comment = zend_string_copy ( zend_ast_get_str ( doc_comment_ast ) ) ;
}
2014-07-19 12:54:56 +00:00
if ( flags & ZEND_ACC_FINAL ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot declare property %s::$%s final, "
" the final modifier is allowed only for methods and classes " ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( ce - > name ) , ZSTR_VAL ( name ) ) ;
2014-07-19 12:54:56 +00:00
}
1999-04-07 18:10:10 +00:00
2014-07-19 12:54:56 +00:00
if ( zend_hash_exists ( & ce - > properties_info , name ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot redeclare %s::$%s " ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( ce - > name ) , ZSTR_VAL ( name ) ) ;
2014-07-19 12:54:56 +00:00
}
2014-04-22 15:54:34 +00:00
2014-07-19 12:54:56 +00:00
if ( value_ast ) {
2014-12-13 22:06:14 +00:00
zend_const_expr_to_zval ( & value_zv , value_ast ) ;
1999-04-07 18:10:10 +00:00
} else {
2014-07-19 12:54:56 +00:00
ZVAL_NULL ( & value_zv ) ;
1999-04-07 18:10:10 +00:00
}
2014-12-13 22:06:14 +00:00
name = zend_new_interned_string_safe ( name ) ;
zend_declare_property_ex ( ce , name , & value_zv , flags , doc_comment ) ;
1999-04-07 18:10:10 +00:00
}
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_class_const_decl ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-27 20:26:06 +00:00
zend_ast_list * list = zend_ast_get_list ( ast ) ;
2014-07-19 13:13:50 +00:00
zend_class_entry * ce = CG ( active_class_entry ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2014-05-29 14:21:56 +00:00
2015-03-03 13:28:09 +00:00
if ( ( ce - > ce_flags & ZEND_ACC_TRAIT ) ! = 0 ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Traits cannot have constants " ) ;
return ;
}
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < list - > children ; + + i ) {
zend_ast * const_ast = list - > child [ i ] ;
2014-07-19 13:13:50 +00:00
zend_ast * name_ast = const_ast - > child [ 0 ] ;
zend_ast * value_ast = const_ast - > child [ 1 ] ;
2014-07-28 13:16:35 +00:00
zend_string * name = zend_ast_get_str ( name_ast ) ;
2014-07-19 13:13:50 +00:00
zval value_zv ;
2014-05-29 14:21:56 +00:00
2015-05-25 20:58:30 +00:00
if ( zend_string_equals_literal_ci ( name , " class " ) ) {
zend_error ( E_COMPILE_ERROR ,
" A class constant must not be called 'class'; it is reserved for class name fetching " ) ;
}
2014-12-13 22:06:14 +00:00
zend_const_expr_to_zval ( & value_zv , value_ast ) ;
2014-07-19 13:13:50 +00:00
2014-12-13 22:06:14 +00:00
name = zend_new_interned_string_safe ( name ) ;
2014-07-19 13:13:50 +00:00
if ( zend_hash_add ( & ce - > constants_table , name , & value_zv ) = = NULL ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot redefine class constant %s::%s " ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( ce - > name ) , ZSTR_VAL ( name ) ) ;
2014-05-29 14:21:56 +00:00
}
2014-07-22 14:55:34 +00:00
if ( Z_CONSTANT ( value_zv ) ) {
ce - > ce_flags & = ~ ZEND_ACC_CONSTANTS_UPDATED ;
}
2014-05-29 14:21:56 +00:00
}
2014-04-22 15:54:34 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-04-22 15:54:34 +00:00
2014-12-13 22:06:14 +00:00
static zend_trait_method_reference * zend_compile_method_ref ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-19 20:39:01 +00:00
zend_ast * class_ast = ast - > child [ 0 ] ;
zend_ast * method_ast = ast - > child [ 1 ] ;
1999-04-07 18:10:10 +00:00
2014-07-19 20:39:01 +00:00
zend_trait_method_reference * method_ref = emalloc ( sizeof ( zend_trait_method_reference ) ) ;
method_ref - > ce = NULL ;
2014-08-25 19:21:16 +00:00
method_ref - > method_name = zend_string_copy ( zend_ast_get_str ( method_ast ) ) ;
2002-03-17 19:13:46 +00:00
2014-07-19 20:39:01 +00:00
if ( class_ast ) {
2014-12-13 22:06:14 +00:00
method_ref - > class_name = zend_resolve_class_name_ast ( class_ast ) ;
2014-07-19 20:39:01 +00:00
} else {
method_ref - > class_name = NULL ;
1999-04-07 18:10:10 +00:00
}
2014-07-19 20:39:01 +00:00
return method_ref ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
static zend_string * * zend_compile_name_list ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-27 20:26:06 +00:00
zend_ast_list * list = zend_ast_get_list ( ast ) ;
zend_string * * names = safe_emalloc ( sizeof ( zend_string * ) , list - > children + 1 , 0 ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2014-07-19 20:39:01 +00:00
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < list - > children ; + + i ) {
zend_ast * name_ast = list - > child [ i ] ;
2014-12-13 22:06:14 +00:00
names [ i ] = zend_resolve_class_name_ast ( name_ast ) ;
2014-07-19 20:39:01 +00:00
}
2014-07-27 20:26:06 +00:00
names [ list - > children ] = NULL ;
2014-07-19 20:39:01 +00:00
return names ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
static void zend_compile_trait_precedence ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-19 20:39:01 +00:00
zend_ast * method_ref_ast = ast - > child [ 0 ] ;
zend_ast * insteadof_ast = ast - > child [ 1 ] ;
2015-01-03 09:22:58 +00:00
2014-07-19 20:39:01 +00:00
zend_trait_precedence * precedence = emalloc ( sizeof ( zend_trait_precedence ) ) ;
2014-12-13 22:06:14 +00:00
precedence - > trait_method = zend_compile_method_ref ( method_ref_ast ) ;
2014-07-19 20:39:01 +00:00
precedence - > exclude_from_classes
2014-12-13 22:06:14 +00:00
= ( void * ) zend_compile_name_list ( insteadof_ast ) ;
2014-07-19 20:39:01 +00:00
2014-12-13 22:06:14 +00:00
zend_add_to_list ( & CG ( active_class_entry ) - > trait_precedences , precedence ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
static void zend_compile_trait_alias ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-19 20:39:01 +00:00
zend_ast * method_ref_ast = ast - > child [ 0 ] ;
zend_ast * alias_ast = ast - > child [ 1 ] ;
2014-08-25 19:21:16 +00:00
uint32_t modifiers = ast - > attr ;
2014-07-19 20:39:01 +00:00
zend_trait_alias * alias ;
if ( modifiers = = ZEND_ACC_STATIC ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use 'static' as method modifier " ) ;
} else if ( modifiers = = ZEND_ACC_ABSTRACT ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use 'abstract' as method modifier " ) ;
} else if ( modifiers = = ZEND_ACC_FINAL ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use 'final' as method modifier " ) ;
}
alias = emalloc ( sizeof ( zend_trait_alias ) ) ;
2014-12-13 22:06:14 +00:00
alias - > trait_method = zend_compile_method_ref ( method_ref_ast ) ;
2014-07-19 20:39:01 +00:00
alias - > modifiers = modifiers ;
if ( alias_ast ) {
2014-08-25 19:21:16 +00:00
alias - > alias = zend_string_copy ( zend_ast_get_str ( alias_ast ) ) ;
2014-07-19 20:39:01 +00:00
} else {
alias - > alias = NULL ;
}
2014-12-13 22:06:14 +00:00
zend_add_to_list ( & CG ( active_class_entry ) - > trait_aliases , alias ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_use_trait ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-27 20:26:06 +00:00
zend_ast_list * traits = zend_ast_get_list ( ast - > child [ 0 ] ) ;
zend_ast_list * adaptations = ast - > child [ 1 ] ? zend_ast_get_list ( ast - > child [ 1 ] ) : NULL ;
2014-07-19 20:39:01 +00:00
zend_class_entry * ce = CG ( active_class_entry ) ;
1999-04-07 18:10:10 +00:00
zend_op * opline ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
1999-04-07 18:10:10 +00:00
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < traits - > children ; + + i ) {
zend_ast * trait_ast = traits - > child [ i ] ;
2014-07-28 13:16:35 +00:00
zend_string * name = zend_ast_get_str ( trait_ast ) ;
2014-07-19 20:39:01 +00:00
if ( ce - > ce_flags & ZEND_ACC_INTERFACE ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use traits inside of interfaces. "
2015-06-30 10:59:27 +00:00
" %s is used in %s " , ZSTR_VAL ( name ) , ZSTR_VAL ( ce - > name ) ) ;
1999-04-07 18:10:10 +00:00
}
2014-07-19 20:39:01 +00:00
2014-07-28 13:39:43 +00:00
switch ( zend_get_class_fetch_type ( name ) ) {
2014-07-19 20:39:01 +00:00
case ZEND_FETCH_CLASS_SELF :
case ZEND_FETCH_CLASS_PARENT :
case ZEND_FETCH_CLASS_STATIC :
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use '%s' as trait name "
2015-06-30 10:59:27 +00:00
" as it is reserved " , ZSTR_VAL ( name ) ) ;
2014-07-19 20:39:01 +00:00
break ;
}
2014-12-13 22:06:14 +00:00
opline = get_next_op ( CG ( active_op_array ) ) ;
2014-07-19 20:39:01 +00:00
opline - > opcode = ZEND_ADD_TRAIT ;
2015-04-20 18:16:58 +00:00
SET_NODE ( opline - > op1 , & FC ( implementing_class ) ) ;
2014-07-19 20:39:01 +00:00
opline - > op2_type = IS_CONST ;
2014-07-19 21:30:07 +00:00
opline - > op2 . constant = zend_add_class_name_literal ( CG ( active_op_array ) ,
2014-12-13 22:06:14 +00:00
zend_resolve_class_name_ast ( trait_ast ) ) ;
2014-07-19 21:30:07 +00:00
2014-07-19 20:39:01 +00:00
ce - > num_traits + + ;
1999-04-07 18:10:10 +00:00
}
2001-07-16 15:48:31 +00:00
2014-07-27 20:26:06 +00:00
if ( ! adaptations ) {
2014-07-19 20:39:01 +00:00
return ;
}
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < adaptations - > children ; + + i ) {
zend_ast * adaptation_ast = adaptations - > child [ i ] ;
2014-07-19 20:39:01 +00:00
switch ( adaptation_ast - > kind ) {
case ZEND_AST_TRAIT_PRECEDENCE :
2014-12-13 22:06:14 +00:00
zend_compile_trait_precedence ( adaptation_ast ) ;
2014-07-19 20:39:01 +00:00
break ;
case ZEND_AST_TRAIT_ALIAS :
2014-12-13 22:06:14 +00:00
zend_compile_trait_alias ( adaptation_ast ) ;
2014-07-19 20:39:01 +00:00
break ;
EMPTY_SWITCH_DEFAULT_CASE ( )
}
2001-07-16 15:48:31 +00:00
}
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_implements ( znode * class_node , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-27 20:26:06 +00:00
zend_ast_list * list = zend_ast_get_list ( ast ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < list - > children ; + + i ) {
zend_ast * class_ast = list - > child [ i ] ;
2014-07-28 13:16:35 +00:00
zend_string * name = zend_ast_get_str ( class_ast ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-07-21 15:14:01 +00:00
zend_op * opline ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2014-07-21 15:14:01 +00:00
if ( ! zend_is_const_default_class_ref ( class_ast ) ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
2015-06-30 10:59:27 +00:00
" Cannot use '%s' as interface name as it is reserved " , ZSTR_VAL ( name ) ) ;
2014-07-21 15:14:01 +00:00
}
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( NULL , ZEND_ADD_INTERFACE , class_node , NULL ) ;
2014-07-21 15:14:01 +00:00
opline - > op2_type = IS_CONST ;
opline - > op2 . constant = zend_add_class_name_literal ( CG ( active_op_array ) ,
2014-12-13 22:06:14 +00:00
zend_resolve_class_name_ast ( class_ast ) ) ;
2014-07-21 15:14:01 +00:00
CG ( active_class_entry ) - > num_interfaces + + ;
}
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2015-04-27 10:08:22 +00:00
static zend_string * zend_generate_anon_class_name ( unsigned char * lex_pos ) /* { { { */
2015-04-26 13:24:13 +00:00
{
2015-04-27 10:08:22 +00:00
zend_string * result ;
char char_pos_buf [ 32 ] ;
2015-05-24 19:50:46 +00:00
size_t char_pos_len = zend_sprintf ( char_pos_buf , " %p " , lex_pos ) ;
zend_string * filename = CG ( active_op_array ) - > filename ;
2015-04-27 10:08:22 +00:00
/* NULL, name length, filename length, last accepting char position length */
2015-06-30 10:59:27 +00:00
result = zend_string_alloc ( sizeof ( " class@anonymous " ) + ZSTR_LEN ( filename ) + char_pos_len , 0 ) ;
sprintf ( ZSTR_VAL ( result ) , " class@anonymous%c%s%s " , ' \0 ' , ZSTR_VAL ( filename ) , char_pos_buf ) ;
2015-04-27 10:08:22 +00:00
return zend_new_interned_string ( result ) ;
2015-04-26 13:24:13 +00:00
}
/* }}} */
2015-04-27 18:15:06 +00:00
void zend_compile_class_decl ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-21 14:34:45 +00:00
zend_ast_decl * decl = ( zend_ast_decl * ) ast ;
zend_ast * extends_ast = decl - > child [ 0 ] ;
zend_ast * implements_ast = decl - > child [ 1 ] ;
zend_ast * stmt_ast = decl - > child [ 2 ] ;
2015-06-13 02:49:07 +00:00
zend_string * name , * lcname , * import_name = NULL ;
2014-07-22 14:55:34 +00:00
zend_class_entry * ce = zend_arena_alloc ( & CG ( arena ) , sizeof ( zend_class_entry ) ) ;
2014-07-21 14:34:45 +00:00
zend_op * opline ;
2014-07-21 15:14:01 +00:00
znode declare_node , extends_node ;
2015-04-26 14:03:58 +00:00
zend_class_entry * original_ce = CG ( active_class_entry ) ;
znode original_implementing_class = FC ( implementing_class ) ;
2015-04-26 13:28:55 +00:00
2015-06-13 02:56:30 +00:00
if ( EXPECTED ( ( decl - > flags & ZEND_ACC_ANON_CLASS ) = = 0 ) ) {
2015-06-13 02:49:07 +00:00
if ( CG ( active_class_entry ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Class declarations may not be nested " ) ;
}
name = decl - > name ;
zend_assert_valid_class_name ( name ) ;
lcname = zend_string_tolower ( name ) ;
if ( FC ( current_namespace ) ) {
name = zend_prefix_with_ns ( name ) ;
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2015-06-13 02:49:07 +00:00
zend_string_release ( lcname ) ;
lcname = zend_string_tolower ( name ) ;
} else {
zend_string_addref ( name ) ;
}
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2015-06-13 02:49:07 +00:00
if ( FC ( imports ) ) {
import_name = zend_hash_find_ptr ( FC ( imports ) , lcname ) ;
}
Implemented Traits for PHP as proposed in the RFC [TRAITS]
# RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior
# Ok, here we go, I guess that will result in more discussion, which is fine
# by me. But now, the patch is here, and properly archived.
#
# See below a list of notes to the patch, it also includes a list of
# points which should be fixed
#
# Internals of the Traits Patch
# -----------------------------
#
# Open TODOs
# """"""""""
#
# - Reflection API
# - support for traits for internal classes
# - currently destroy_zend_class does not handle that case
#
# Introduced Structures
# """""""""""""""""""""
#
# Data structures to encode the composition information specified in the
# source:
# - zend_trait_method_reference
# - zend_trait_precedence
# - zend_trait_alias
#
# Changes
# """""""
#
# zend_class_entry
# - uses NULL terminated lists of pointers for
# - trait_aliases
# - trait_precedences
# - do you prefer an explicit counter?
# - the information is only necessary during class composition
# but might be interesting for reflection
# - did not want to blow up class further with not really necessary length counters
#
# added keywords
# - trait
# - insteadof
#
# Added opcodes
# ZEND_ADD_TRAIT
# - similar to ZEND_ADD_INTERFACE
# - adds the trait to the list of traits of a class, no actual composition done
# ZEND_BIND_TRAITS
# - emitted in zend_do_end_class_declaration
# - concludes the class definition and will initiate the trait composition
# when the class definition is encountered during runtime
#
# Added Flags
# ZEND_ACC_TRAIT = 0x120
# ZEND_ACC_IMPLEMENT_TRAITS = 0x400000
# ZEND_FETCH_CLASS_TRAIT = 14
#
# zend_vm_execute.h
# - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER,
# ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective
#
# zend_compile.c
# - refactored do_inherit_method_check
# split into do_inherit_method_check and do_inheritance_check_on_method
# - added helper functions use a '_' as prefix and are not mentioned in the
# headers
# - _copy_functions
# prepare hash-maps of functions which should be merged into a class
# here the aliases are handled
# - _merge_functions
# builds a hash-table of the methods which need to be added to a class
# does the conflict detection
# - reused php_runkit_function_copy_ctor
# - it is not identical with the original code anymore, needed to update it
# think I fixed some bugs, not sure whether all have been reported back to runkit
# - has to be renamed, left the name for the moment, to make its origin obvious
# - here might be optimization potential
# - not sure whether everything needs to be copied
# - copying the literals might be broken
# - added it since the literals array is freed by efree and gave problems
# with doubled frees
# - all immutable parts of the zend_op array should not be copied
# - am not sure which parts are immutable
# - and not sure how to avoid doubled frees on the same arrays on shutdown
# - _merge_functions_to_class
# does the final merging with the target class to handle inherited
# and overridden methods
# - small helper for NULL terminated lists
# zend_init_list, zend_add_to_list
#
# zend_language_parser.y
# - reused class definition for traits
# - there should be something with regard to properties
# - if they get explicitly defined, it might be worthwhile to
# check that there are no collisions with other traits in a composition
# (however, I would not introduce elaborate language features to control that
# but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
2015-06-13 02:49:07 +00:00
if ( import_name & & ! zend_string_equals_ci ( lcname , import_name ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot declare class %s "
2015-06-30 10:59:27 +00:00
" because the name is already in use " , ZSTR_VAL ( name ) ) ;
2015-06-13 02:49:07 +00:00
}
1999-04-07 18:10:10 +00:00
2015-06-13 02:49:07 +00:00
name = zend_new_interned_string ( name ) ;
2002-11-10 17:50:27 +00:00
} else {
2015-07-05 00:00:38 +00:00
name = zend_generate_anon_class_name ( decl - > lex_pos ) ;
2015-07-21 18:34:06 +00:00
lcname = zend_string_tolower ( name ) ;
2014-07-21 14:34:45 +00:00
}
2015-07-21 18:34:06 +00:00
lcname = zend_new_interned_string ( lcname ) ;
2014-07-21 14:34:45 +00:00
ce - > type = ZEND_USER_CLASS ;
2014-07-24 19:07:37 +00:00
ce - > name = name ;
2015-04-26 13:12:10 +00:00
zend_initialize_class_data ( ce , 1 ) ;
2014-07-21 14:34:45 +00:00
ce - > ce_flags | = decl - > flags ;
2015-04-26 13:12:10 +00:00
ce - > info . user . filename = zend_get_compiled_filename ( ) ;
2014-07-21 14:34:45 +00:00
ce - > info . user . line_start = decl - > start_lineno ;
ce - > info . user . line_end = decl - > end_lineno ;
2015-06-13 02:49:07 +00:00
2014-07-21 14:34:45 +00:00
if ( decl - > doc_comment ) {
2014-08-25 19:21:16 +00:00
ce - > info . user . doc_comment = zend_string_copy ( decl - > doc_comment ) ;
1999-04-07 18:10:10 +00:00
}
2003-01-19 17:25:39 +00:00
2015-06-13 02:56:30 +00:00
if ( UNEXPECTED ( ( decl - > flags & ZEND_ACC_ANON_CLASS ) ) ) {
2015-06-13 02:49:07 +00:00
/* Serialization is not supported for anonymous classes */
ce - > serialize = zend_class_serialize_deny ;
ce - > unserialize = zend_class_unserialize_deny ;
}
2014-07-21 14:34:45 +00:00
if ( extends_ast ) {
if ( ! zend_is_const_default_class_ref ( extends_ast ) ) {
2014-07-28 13:16:35 +00:00
zend_string * extends_name = zend_ast_get_str ( extends_ast ) ;
2014-07-21 14:34:45 +00:00
zend_error_noreturn ( E_COMPILE_ERROR ,
2015-06-30 10:59:27 +00:00
" Cannot use '%s' as class name as it is reserved " , ZSTR_VAL ( extends_name ) ) ;
2008-01-23 17:55:55 +00:00
}
2014-07-21 14:34:45 +00:00
2015-04-01 17:01:57 +00:00
zend_compile_class_ref ( & extends_node , extends_ast , 0 ) ;
2008-01-23 17:55:55 +00:00
}
2015-04-26 13:12:10 +00:00
opline = get_next_op ( CG ( active_op_array ) ) ;
zend_make_var_result ( & declare_node , opline ) ;
2003-01-19 17:25:39 +00:00
2014-07-21 15:14:01 +00:00
// TODO.AST drop this
2015-04-20 18:16:58 +00:00
GET_NODE ( & FC ( implementing_class ) , opline - > result ) ;
2003-01-19 17:25:39 +00:00
2014-07-21 14:34:45 +00:00
opline - > op2_type = IS_CONST ;
LITERAL_STR ( opline - > op2 , lcname ) ;
2008-07-14 09:49:03 +00:00
2015-04-27 09:24:39 +00:00
if ( decl - > flags & ZEND_ACC_ANON_CLASS ) {
if ( extends_ast ) {
opline - > opcode = ZEND_DECLARE_ANON_INHERITED_CLASS ;
opline - > extended_value = extends_node . u . op . var ;
} else {
opline - > opcode = ZEND_DECLARE_ANON_CLASS ;
}
opline - > op1_type = IS_UNUSED ;
zend_hash_update_ptr ( CG ( class_table ) , lcname , ce ) ;
2008-07-14 09:49:03 +00:00
} else {
2015-04-27 09:24:39 +00:00
zend_string * key ;
1999-04-07 18:10:10 +00:00
2015-04-27 09:24:39 +00:00
if ( extends_ast ) {
opline - > opcode = ZEND_DECLARE_INHERITED_CLASS ;
opline - > extended_value = extends_node . u . op . var ;
} else {
opline - > opcode = ZEND_DECLARE_CLASS ;
}
key = zend_build_runtime_definition_key ( lcname , decl - > lex_pos ) ;
2008-07-14 09:49:03 +00:00
2014-07-21 14:34:45 +00:00
opline - > op1_type = IS_CONST ;
2014-07-29 18:01:11 +00:00
LITERAL_STR ( opline - > op1 , key ) ;
2014-07-21 14:34:45 +00:00
2014-07-29 18:01:11 +00:00
zend_hash_update_ptr ( CG ( class_table ) , key , ce ) ;
2008-07-14 09:49:03 +00:00
}
2014-07-21 14:34:45 +00:00
CG ( active_class_entry ) = ce ;
2008-07-14 09:49:03 +00:00
2015-04-26 13:12:10 +00:00
zend_compile_stmt ( stmt_ast ) ;
2014-07-21 14:34:45 +00:00
2015-07-27 22:56:18 +00:00
/* Reset lineno for final opcodes and errors */
CG ( zend_lineno ) = ast - > lineno ;
2015-03-31 14:10:06 +00:00
if ( ce - > num_traits = = 0 ) {
/* For traits this check is delayed until after trait binding */
zend_check_deprecated_constructor ( ce ) ;
}
2014-07-21 16:15:09 +00:00
if ( ce - > constructor ) {
ce - > constructor - > common . fn_flags | = ZEND_ACC_CTOR ;
if ( ce - > constructor - > common . fn_flags & ZEND_ACC_STATIC ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Constructor %s::%s() cannot be static " ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( ce - > name ) , ZSTR_VAL ( ce - > constructor - > common . function_name ) ) ;
2014-07-21 16:15:09 +00:00
}
2015-04-26 13:12:10 +00:00
if ( ce - > constructor - > common . fn_flags & ZEND_ACC_HAS_RETURN_TYPE ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
" Constructor %s::%s() cannot declare a return type " ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( ce - > name ) , ZSTR_VAL ( ce - > constructor - > common . function_name ) ) ;
2015-04-26 13:12:10 +00:00
}
2014-07-21 16:15:09 +00:00
}
if ( ce - > destructor ) {
ce - > destructor - > common . fn_flags | = ZEND_ACC_DTOR ;
if ( ce - > destructor - > common . fn_flags & ZEND_ACC_STATIC ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Destructor %s::%s() cannot be static " ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( ce - > name ) , ZSTR_VAL ( ce - > destructor - > common . function_name ) ) ;
2015-04-26 13:12:10 +00:00
} else if ( ce - > destructor - > common . fn_flags & ZEND_ACC_HAS_RETURN_TYPE ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
" Destructor %s::%s() cannot declare a return type " ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( ce - > name ) , ZSTR_VAL ( ce - > destructor - > common . function_name ) ) ;
2014-07-21 16:15:09 +00:00
}
}
if ( ce - > clone ) {
ce - > clone - > common . fn_flags | = ZEND_ACC_CLONE ;
if ( ce - > clone - > common . fn_flags & ZEND_ACC_STATIC ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Clone method %s::%s() cannot be static " ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( ce - > name ) , ZSTR_VAL ( ce - > clone - > common . function_name ) ) ;
2015-04-26 13:12:10 +00:00
} else if ( ce - > clone - > common . fn_flags & ZEND_ACC_HAS_RETURN_TYPE ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
" %s::%s() cannot declare a return type " ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( ce - > name ) , ZSTR_VAL ( ce - > clone - > common . function_name ) ) ;
2008-01-23 17:55:55 +00:00
}
}
2014-07-21 15:14:01 +00:00
/* Check for traits and proceed like with interfaces.
* The only difference will be a combined handling of them in the end .
* Thus , we need another opcode here . */
if ( ce - > num_traits > 0 ) {
ce - > traits = NULL ;
ce - > num_traits = 0 ;
ce - > ce_flags | = ZEND_ACC_IMPLEMENT_TRAITS ;
1999-04-07 18:10:10 +00:00
2015-04-26 13:12:10 +00:00
zend_emit_op ( NULL , ZEND_BIND_TRAITS , & declare_node , NULL ) ;
2014-07-21 15:14:01 +00:00
}
1999-04-07 18:10:10 +00:00
2016-03-26 23:47:31 +00:00
if ( implements_ast ) {
zend_compile_implements ( & declare_node , implements_ast ) ;
}
2014-07-21 15:14:01 +00:00
if ( ! ( ce - > ce_flags & ( ZEND_ACC_INTERFACE | ZEND_ACC_EXPLICIT_ABSTRACT_CLASS ) )
2016-03-26 23:47:31 +00:00
& & ( extends_ast | | implements_ast )
2014-07-21 15:14:01 +00:00
) {
2015-04-26 13:12:10 +00:00
zend_verify_abstract_class ( ce ) ;
2016-03-26 23:47:31 +00:00
if ( implements_ast ) {
2015-04-26 13:12:10 +00:00
zend_emit_op ( NULL , ZEND_VERIFY_ABSTRACT_CLASS , & declare_node , NULL ) ;
2014-06-06 11:04:30 +00:00
}
}
1999-04-07 18:10:10 +00:00
2014-07-21 15:14:01 +00:00
/* Inherit interfaces; reset number to zero, we need it for above check and
* will restore it during actual implementation .
* The ZEND_ACC_IMPLEMENT_INTERFACES flag disables double call to
* zend_verify_abstract_class ( ) */
if ( ce - > num_interfaces > 0 ) {
ce - > interfaces = NULL ;
ce - > num_interfaces = 0 ;
ce - > ce_flags | = ZEND_ACC_IMPLEMENT_INTERFACES ;
}
1999-04-07 18:10:10 +00:00
2015-04-26 14:03:58 +00:00
FC ( implementing_class ) = original_implementing_class ;
CG ( active_class_entry ) = original_ce ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
static HashTable * zend_get_import_ht ( uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-21 21:41:11 +00:00
switch ( type ) {
case T_CLASS :
2015-04-20 18:16:58 +00:00
if ( ! FC ( imports ) ) {
FC ( imports ) = emalloc ( sizeof ( HashTable ) ) ;
zend_hash_init ( FC ( imports ) , 8 , NULL , str_dtor , 0 ) ;
2014-07-21 21:41:11 +00:00
}
2015-04-20 18:16:58 +00:00
return FC ( imports ) ;
2014-07-21 21:41:11 +00:00
case T_FUNCTION :
2015-04-20 18:16:58 +00:00
if ( ! FC ( imports_function ) ) {
FC ( imports_function ) = emalloc ( sizeof ( HashTable ) ) ;
zend_hash_init ( FC ( imports_function ) , 8 , NULL , str_dtor , 0 ) ;
2014-07-21 21:41:11 +00:00
}
2015-04-20 18:16:58 +00:00
return FC ( imports_function ) ;
2014-07-21 21:41:11 +00:00
case T_CONST :
2015-04-20 18:16:58 +00:00
if ( ! FC ( imports_const ) ) {
FC ( imports_const ) = emalloc ( sizeof ( HashTable ) ) ;
zend_hash_init ( FC ( imports_const ) , 8 , NULL , str_dtor , 0 ) ;
2014-07-21 21:41:11 +00:00
}
2015-04-20 18:16:58 +00:00
return FC ( imports_const ) ;
2014-07-21 21:41:11 +00:00
EMPTY_SWITCH_DEFAULT_CASE ( )
1999-12-23 15:03:25 +00:00
}
2014-10-31 17:49:29 +00:00
return NULL ;
1999-12-23 15:03:25 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-08-29 05:05:58 +00:00
static char * zend_get_use_type_str ( uint32_t type ) /* { { { */
{
2014-07-21 21:41:11 +00:00
switch ( type ) {
case T_CLASS :
return " " ;
case T_FUNCTION :
return " function " ;
case T_CONST :
return " const " ;
EMPTY_SWITCH_DEFAULT_CASE ( )
1999-04-07 18:10:10 +00:00
}
2014-10-31 17:49:29 +00:00
return " unknown " ;
2014-07-21 21:41:11 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-21 21:41:11 +00:00
2014-08-29 05:05:58 +00:00
static void zend_check_already_in_use ( uint32_t type , zend_string * old_name , zend_string * new_name , zend_string * check_name ) /* { { { */
{
2015-02-11 08:03:48 +00:00
if ( zend_string_equals_ci ( old_name , check_name ) ) {
2014-07-28 20:16:24 +00:00
return ;
2010-12-01 13:33:49 +00:00
}
2014-07-21 21:41:11 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use%s %s as %s because the name "
2015-06-30 10:59:27 +00:00
" is already in use " , zend_get_use_type_str ( type ) , ZSTR_VAL ( old_name ) , ZSTR_VAL ( new_name ) ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_use ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-27 20:26:06 +00:00
zend_ast_list * list = zend_ast_get_list ( ast ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2015-04-20 18:16:58 +00:00
zend_string * current_ns = FC ( current_namespace ) ;
2014-08-25 19:21:16 +00:00
uint32_t type = ast - > attr ;
2014-12-13 22:06:14 +00:00
HashTable * current_import = zend_get_import_ht ( type ) ;
2014-07-21 21:41:11 +00:00
zend_bool case_sensitive = type = = T_CONST ;
2014-07-21 20:49:31 +00:00
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < list - > children ; + + i ) {
zend_ast * use_ast = list - > child [ i ] ;
2014-07-21 20:49:31 +00:00
zend_ast * old_name_ast = use_ast - > child [ 0 ] ;
zend_ast * new_name_ast = use_ast - > child [ 1 ] ;
2014-07-28 13:16:35 +00:00
zend_string * old_name = zend_ast_get_str ( old_name_ast ) ;
2014-07-21 21:41:11 +00:00
zend_string * new_name , * lookup_name ;
2014-07-21 20:49:31 +00:00
if ( new_name_ast ) {
2014-08-25 19:21:16 +00:00
new_name = zend_string_copy ( zend_ast_get_str ( new_name_ast ) ) ;
2014-07-21 20:49:31 +00:00
} else {
2014-09-28 21:17:29 +00:00
const char * unqualified_name ;
size_t unqualified_name_len ;
if ( zend_get_unqualified_name ( old_name , & unqualified_name , & unqualified_name_len ) ) {
2015-01-18 14:46:32 +00:00
/* The form "use A\B" is equivalent to "use A\B as B" */
2014-09-28 21:17:29 +00:00
new_name = zend_string_init ( unqualified_name , unqualified_name_len , 0 ) ;
2014-07-21 20:49:31 +00:00
} else {
2014-08-25 19:21:16 +00:00
new_name = zend_string_copy ( old_name ) ;
1999-04-07 18:10:10 +00:00
2014-07-21 20:49:31 +00:00
if ( ! current_ns ) {
2014-08-25 20:40:58 +00:00
if ( type = = T_CLASS & & zend_string_equals_literal ( new_name , " strict " ) ) {
2014-07-21 20:49:31 +00:00
zend_error_noreturn ( E_COMPILE_ERROR ,
" You seem to be trying to use a different language... " ) ;
}
2002-03-17 19:13:46 +00:00
2014-07-21 20:49:31 +00:00
zend_error ( E_WARNING , " The use statement with non-compound name '%s' "
2015-06-30 10:59:27 +00:00
" has no effect " , ZSTR_VAL ( new_name ) ) ;
2014-07-21 20:49:31 +00:00
}
}
}
1999-04-07 18:10:10 +00:00
2014-07-21 21:41:11 +00:00
if ( case_sensitive ) {
2014-08-25 19:21:16 +00:00
lookup_name = zend_string_copy ( new_name ) ;
2014-07-21 21:41:11 +00:00
} else {
2014-12-24 12:04:51 +00:00
lookup_name = zend_string_tolower ( new_name ) ;
2014-07-21 21:41:11 +00:00
}
1999-04-07 18:10:10 +00:00
2015-03-30 20:05:26 +00:00
if ( type = = T_CLASS & & zend_is_reserved_class_name ( new_name ) ) {
2014-07-21 20:49:31 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use %s as %s because '%s' "
2015-06-30 10:59:27 +00:00
" is a special class name " , ZSTR_VAL ( old_name ) , ZSTR_VAL ( new_name ) , ZSTR_VAL ( new_name ) ) ;
2004-10-04 19:54:35 +00:00
}
1999-04-07 18:10:10 +00:00
2014-07-21 20:49:31 +00:00
if ( current_ns ) {
2015-06-30 10:59:27 +00:00
zend_string * ns_name = zend_string_alloc ( ZSTR_LEN ( current_ns ) + 1 + ZSTR_LEN ( new_name ) , 0 ) ;
zend_str_tolower_copy ( ZSTR_VAL ( ns_name ) , ZSTR_VAL ( current_ns ) , ZSTR_LEN ( current_ns ) ) ;
ZSTR_VAL ( ns_name ) [ ZSTR_LEN ( current_ns ) ] = ' \\ ' ;
memcpy ( ZSTR_VAL ( ns_name ) + ZSTR_LEN ( current_ns ) + 1 , ZSTR_VAL ( lookup_name ) , ZSTR_LEN ( lookup_name ) ) ;
1999-04-07 18:10:10 +00:00
2014-07-21 20:49:31 +00:00
if ( zend_hash_exists ( CG ( class_table ) , ns_name ) ) {
2014-07-21 21:41:11 +00:00
zend_check_already_in_use ( type , old_name , new_name , ns_name ) ;
2014-07-21 20:49:31 +00:00
}
2001-12-26 14:46:18 +00:00
2014-08-25 19:21:16 +00:00
zend_string_free ( ns_name ) ;
2012-04-12 09:54:52 +00:00
} else {
2014-07-21 21:41:11 +00:00
switch ( type ) {
case T_CLASS :
{
zend_class_entry * ce = zend_hash_find_ptr ( CG ( class_table ) , lookup_name ) ;
if ( ce & & ce - > type = = ZEND_USER_CLASS
& & ce - > info . user . filename = = CG ( compiled_filename )
) {
zend_check_already_in_use ( type , old_name , new_name , lookup_name ) ;
}
break ;
}
case T_FUNCTION :
{
zend_function * fn = zend_hash_find_ptr ( CG ( function_table ) , lookup_name ) ;
if ( fn & & fn - > type = = ZEND_USER_FUNCTION
2014-07-28 20:30:24 +00:00
& & fn - > op_array . filename = = CG ( compiled_filename )
2014-07-21 21:41:11 +00:00
) {
zend_check_already_in_use ( type , old_name , new_name , lookup_name ) ;
}
break ;
}
case T_CONST :
{
zend_string * filename = zend_hash_find_ptr ( & CG ( const_filenames ) , lookup_name ) ;
2014-07-28 20:30:24 +00:00
if ( filename & & filename = = CG ( compiled_filename ) ) {
2014-07-21 21:41:11 +00:00
zend_check_already_in_use ( type , old_name , new_name , lookup_name ) ;
}
break ;
}
EMPTY_SWITCH_DEFAULT_CASE ( )
2014-07-21 20:49:31 +00:00
}
2012-04-12 09:54:52 +00:00
}
2014-08-25 19:21:16 +00:00
zend_string_addref ( old_name ) ;
2014-07-21 21:41:11 +00:00
if ( ! zend_hash_add_ptr ( current_import , lookup_name , old_name ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use%s %s as %s because the name "
2015-06-30 10:59:27 +00:00
" is already in use " , zend_get_use_type_str ( type ) , ZSTR_VAL ( old_name ) , ZSTR_VAL ( new_name ) ) ;
2014-07-21 20:49:31 +00:00
}
2014-08-25 19:21:16 +00:00
zend_string_release ( lookup_name ) ;
zend_string_release ( new_name ) ;
2012-04-12 09:54:52 +00:00
}
2014-07-21 20:49:31 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2006-05-09 23:53:23 +00:00
2015-03-07 20:59:20 +00:00
void zend_compile_group_use ( zend_ast * ast ) /* { { { */
{
2015-03-08 16:01:55 +00:00
uint32_t i ;
2015-03-07 20:59:20 +00:00
zend_string * ns = zend_ast_get_str ( ast - > child [ 0 ] ) ;
zend_ast_list * list = zend_ast_get_list ( ast - > child [ 1 ] ) ;
for ( i = 0 ; i < list - > children ; i + + ) {
2015-03-08 16:01:55 +00:00
zend_ast * inline_use , * use = list - > child [ i ] ;
2015-03-07 20:59:20 +00:00
zval * name_zval = zend_ast_get_zval ( use - > child [ 0 ] ) ;
zend_string * name = Z_STR_P ( name_zval ) ;
2015-06-30 10:59:27 +00:00
zend_string * compound_ns = zend_concat_names ( ZSTR_VAL ( ns ) , ZSTR_LEN ( ns ) , ZSTR_VAL ( name ) , ZSTR_LEN ( name ) ) ;
2015-03-07 20:59:20 +00:00
zend_string_release ( name ) ;
ZVAL_STR ( name_zval , compound_ns ) ;
2015-03-08 16:01:55 +00:00
inline_use = zend_ast_create_list ( 1 , ZEND_AST_USE , use ) ;
2015-03-07 20:59:20 +00:00
inline_use - > attr = ast - > attr ? ast - > attr : use - > attr ;
zend_compile_use ( inline_use ) ;
}
}
/* }}} */
2014-12-13 22:06:14 +00:00
void zend_compile_const_decl ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-27 20:26:06 +00:00
zend_ast_list * list = zend_ast_get_list ( ast ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < list - > children ; + + i ) {
zend_ast * const_ast = list - > child [ i ] ;
2014-07-22 09:55:07 +00:00
zend_ast * name_ast = const_ast - > child [ 0 ] ;
zend_ast * value_ast = const_ast - > child [ 1 ] ;
2014-07-28 13:16:35 +00:00
zend_string * name = zend_ast_get_str ( name_ast ) ;
2006-05-09 23:53:23 +00:00
2014-07-22 09:55:07 +00:00
zend_string * import_name ;
znode name_node , value_node ;
zval * value_zv = & value_node . u . constant ;
value_node . op_type = IS_CONST ;
2014-12-13 22:06:14 +00:00
zend_const_expr_to_zval ( value_zv , value_ast ) ;
2014-07-22 09:55:07 +00:00
2015-06-30 10:59:27 +00:00
if ( zend_lookup_reserved_const ( ZSTR_VAL ( name ) , ZSTR_LEN ( name ) ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot redeclare constant '%s' " , ZSTR_VAL ( name ) ) ;
2004-10-04 19:54:35 +00:00
}
2002-02-04 19:29:56 +00:00
2014-12-13 22:06:14 +00:00
name = zend_prefix_with_ns ( name ) ;
name = zend_new_interned_string ( name ) ;
2014-07-22 09:55:07 +00:00
2015-04-20 18:16:58 +00:00
if ( FC ( imports_const )
& & ( import_name = zend_hash_find_ptr ( FC ( imports_const ) , name ) )
2014-07-22 09:55:07 +00:00
) {
2014-08-25 20:40:58 +00:00
if ( ! zend_string_equals ( import_name , name ) ) {
2015-04-01 10:32:23 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot declare const %s because "
2015-06-30 10:59:27 +00:00
" the name is already in use " , ZSTR_VAL ( name ) ) ;
2014-07-22 09:55:07 +00:00
}
}
name_node . op_type = IS_CONST ;
ZVAL_STR ( & name_node . u . constant , name ) ;
2014-12-13 22:06:14 +00:00
zend_emit_op ( NULL , ZEND_DECLARE_CONST , & name_node , & value_node ) ;
2014-07-22 09:55:07 +00:00
zend_hash_add_ptr ( & CG ( const_filenames ) , name , CG ( compiled_filename ) ) ;
}
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}}*/
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_namespace ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-22 10:45:44 +00:00
zend_ast * name_ast = ast - > child [ 0 ] ;
zend_ast * stmt_ast = ast - > child [ 1 ] ;
zend_string * name ;
2014-07-22 12:08:52 +00:00
zend_bool with_bracket = stmt_ast ! = NULL ;
2002-07-30 04:07:15 +00:00
2014-07-22 12:08:52 +00:00
/* handle mixed syntax declaration or nested namespaces */
2015-04-20 18:16:58 +00:00
if ( ! FC ( has_bracketed_namespaces ) ) {
if ( FC ( current_namespace ) ) {
2014-07-22 12:08:52 +00:00
/* previous namespace declarations were unbracketed */
if ( with_bracket ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot mix bracketed namespace declarations "
" with unbracketed namespace declarations " ) ;
}
}
} else {
/* previous namespace declarations were bracketed */
if ( ! with_bracket ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot mix bracketed namespace declarations "
" with unbracketed namespace declarations " ) ;
2015-04-20 18:16:58 +00:00
} else if ( FC ( current_namespace ) | | FC ( in_namespace ) ) {
2014-07-22 12:08:52 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Namespace declarations cannot be nested " ) ;
2005-09-09 06:48:49 +00:00
}
}
2015-04-20 18:16:58 +00:00
if ( ( ( ! with_bracket & & ! FC ( current_namespace ) )
| | ( with_bracket & & ! FC ( has_bracketed_namespaces ) ) ) & & CG ( active_op_array ) - > last > 0
2014-07-22 12:08:52 +00:00
) {
/* ignore ZEND_EXT_STMT and ZEND_TICKS */
2014-08-25 19:21:16 +00:00
uint32_t num = CG ( active_op_array ) - > last ;
2014-07-22 12:08:52 +00:00
while ( num > 0 & &
( CG ( active_op_array ) - > opcodes [ num - 1 ] . opcode = = ZEND_EXT_STMT | |
CG ( active_op_array ) - > opcodes [ num - 1 ] . opcode = = ZEND_TICKS ) ) {
- - num ;
}
if ( num > 0 ) {
2014-07-28 20:03:16 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Namespace declaration statement has to be "
2015-11-29 07:43:41 +00:00
" the very first statement or after any declare call in the script " ) ;
2014-07-22 12:08:52 +00:00
}
2006-12-12 23:25:23 +00:00
}
2015-04-20 18:16:58 +00:00
if ( FC ( current_namespace ) ) {
zend_string_release ( FC ( current_namespace ) ) ;
2014-07-22 10:45:44 +00:00
}
2002-07-30 04:07:15 +00:00
2014-07-22 10:45:44 +00:00
if ( name_ast ) {
2014-07-28 13:16:35 +00:00
name = zend_ast_get_str ( name_ast ) ;
2001-08-08 15:07:11 +00:00
2014-07-28 13:39:43 +00:00
if ( ZEND_FETCH_CLASS_DEFAULT ! = zend_get_class_fetch_type ( name ) ) {
2015-06-30 10:59:27 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use '%s' as namespace name " , ZSTR_VAL ( name ) ) ;
2001-08-08 15:07:11 +00:00
}
2014-07-22 10:45:44 +00:00
2015-04-20 18:16:58 +00:00
FC ( current_namespace ) = zend_string_copy ( name ) ;
2001-08-08 15:07:11 +00:00
} else {
2015-04-20 18:16:58 +00:00
FC ( current_namespace ) = NULL ;
2001-08-08 15:07:11 +00:00
}
2014-12-13 22:06:14 +00:00
zend_reset_import_tables ( ) ;
2005-02-11 22:26:45 +00:00
2015-04-20 18:16:58 +00:00
FC ( in_namespace ) = 1 ;
2014-07-22 12:08:52 +00:00
if ( with_bracket ) {
2015-04-20 18:16:58 +00:00
FC ( has_bracketed_namespaces ) = 1 ;
2014-07-22 12:08:52 +00:00
}
1999-04-07 18:10:10 +00:00
2014-07-22 10:45:44 +00:00
if ( stmt_ast ) {
2014-12-13 22:06:14 +00:00
zend_compile_top_stmt ( stmt_ast ) ;
zend_end_namespace ( ) ;
2014-07-22 10:45:44 +00:00
}
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_halt_compiler ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-22 12:22:59 +00:00
zend_ast * offset_ast = ast - > child [ 0 ] ;
2014-08-25 19:21:16 +00:00
zend_long offset = Z_LVAL_P ( zend_ast_get_zval ( offset_ast ) ) ;
2006-05-09 23:53:23 +00:00
2014-07-22 12:22:59 +00:00
zend_string * filename , * name ;
const char const_name [ ] = " __COMPILER_HALT_OFFSET__ " ;
2005-02-07 15:22:38 +00:00
2015-04-20 18:16:58 +00:00
if ( FC ( has_bracketed_namespaces ) & & FC ( in_namespace ) ) {
2014-07-28 20:03:16 +00:00
zend_error_noreturn ( E_COMPILE_ERROR ,
" __HALT_COMPILER() can only be used from the outermost scope " ) ;
2014-07-22 12:22:59 +00:00
}
2005-02-07 16:09:54 +00:00
2014-12-13 22:06:14 +00:00
filename = zend_get_compiled_filename ( ) ;
2014-07-22 12:22:59 +00:00
name = zend_mangle_property_name ( const_name , sizeof ( const_name ) - 1 ,
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( filename ) , ZSTR_LEN ( filename ) , 0 ) ;
2014-07-22 12:22:59 +00:00
2015-06-30 10:59:27 +00:00
zend_register_long_constant ( ZSTR_VAL ( name ) , ZSTR_LEN ( name ) , offset , CONST_CS , 0 ) ;
2014-08-25 19:21:16 +00:00
zend_string_release ( name ) ;
2014-07-22 12:22:59 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-22 12:22:59 +00:00
2014-12-13 22:06:14 +00:00
static zend_bool zend_try_ct_eval_magic_const ( zval * zv , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-29 21:22:23 +00:00
zend_op_array * op_array = CG ( active_op_array ) ;
zend_class_entry * ce = CG ( active_class_entry ) ;
switch ( ast - > attr ) {
2014-08-26 20:47:11 +00:00
case T_LINE :
2014-10-12 18:54:45 +00:00
ZVAL_LONG ( zv , ast - > lineno ) ;
2014-08-26 20:47:11 +00:00
break ;
case T_FILE :
2014-09-19 13:32:50 +00:00
ZVAL_STR_COPY ( zv , CG ( compiled_filename ) ) ;
2014-08-26 20:47:11 +00:00
break ;
case T_DIR :
{
zend_string * filename = CG ( compiled_filename ) ;
2015-06-30 10:59:27 +00:00
zend_string * dirname = zend_string_init ( ZSTR_VAL ( filename ) , ZSTR_LEN ( filename ) , 0 ) ;
zend_dirname ( ZSTR_VAL ( dirname ) , ZSTR_LEN ( dirname ) ) ;
2014-08-26 20:47:11 +00:00
2015-06-30 10:59:27 +00:00
if ( strcmp ( ZSTR_VAL ( dirname ) , " . " ) = = 0 ) {
2015-03-19 23:02:42 +00:00
dirname = zend_string_extend ( dirname , MAXPATHLEN , 0 ) ;
2014-08-26 20:47:11 +00:00
# if HAVE_GETCWD
2015-07-16 20:48:56 +00:00
ZEND_IGNORE_VALUE ( VCWD_GETCWD ( ZSTR_VAL ( dirname ) , MAXPATHLEN ) ) ;
2014-08-26 20:47:11 +00:00
# elif HAVE_GETWD
2015-07-16 20:48:56 +00:00
ZEND_IGNORE_VALUE ( VCWD_GETWD ( ZSTR_VAL ( dirname ) ) ) ;
2014-08-26 20:47:11 +00:00
# endif
}
2015-06-30 10:59:27 +00:00
ZSTR_LEN ( dirname ) = strlen ( ZSTR_VAL ( dirname ) ) ;
2014-08-26 20:47:11 +00:00
ZVAL_STR ( zv , dirname ) ;
break ;
}
2014-07-29 21:22:23 +00:00
case T_FUNC_C :
if ( op_array & & op_array - > function_name ) {
2014-09-19 13:32:50 +00:00
ZVAL_STR_COPY ( zv , op_array - > function_name ) ;
2014-07-29 21:22:23 +00:00
} else {
ZVAL_EMPTY_STRING ( zv ) ;
}
break ;
case T_METHOD_C :
2015-07-28 13:27:58 +00:00
if ( ( op_array & & ! op_array - > scope & & op_array - > function_name ) | | ( op_array - > fn_flags & ZEND_ACC_CLOSURE ) ) {
ZVAL_STR_COPY ( zv , op_array - > function_name ) ;
} else if ( ce ) {
2014-07-29 21:22:23 +00:00
if ( op_array & & op_array - > function_name ) {
2015-06-30 10:59:27 +00:00
ZVAL_NEW_STR ( zv , zend_concat3 ( ZSTR_VAL ( ce - > name ) , ZSTR_LEN ( ce - > name ) , " :: " , 2 ,
ZSTR_VAL ( op_array - > function_name ) , ZSTR_LEN ( op_array - > function_name ) ) ) ;
2014-07-29 21:22:23 +00:00
} else {
2014-09-19 13:32:50 +00:00
ZVAL_STR_COPY ( zv , ce - > name ) ;
2014-07-29 21:22:23 +00:00
}
} else if ( op_array & & op_array - > function_name ) {
2014-09-19 13:32:50 +00:00
ZVAL_STR_COPY ( zv , op_array - > function_name ) ;
2014-07-29 21:22:23 +00:00
} else {
ZVAL_EMPTY_STRING ( zv ) ;
}
break ;
case T_CLASS_C :
if ( ce ) {
2015-02-12 22:19:14 +00:00
if ( ( ce - > ce_flags & ZEND_ACC_TRAIT ) ! = 0 ) {
2014-07-29 21:22:23 +00:00
return 0 ;
} else {
2014-09-19 13:32:50 +00:00
ZVAL_STR_COPY ( zv , ce - > name ) ;
2014-07-29 21:22:23 +00:00
}
} else {
ZVAL_EMPTY_STRING ( zv ) ;
}
break ;
case T_TRAIT_C :
2015-02-12 22:19:14 +00:00
if ( ce & & ( ce - > ce_flags & ZEND_ACC_TRAIT ) ! = 0 ) {
2014-09-19 13:32:50 +00:00
ZVAL_STR_COPY ( zv , ce - > name ) ;
2014-07-29 21:22:23 +00:00
} else {
ZVAL_EMPTY_STRING ( zv ) ;
}
break ;
case T_NS_C :
2015-04-20 18:16:58 +00:00
if ( FC ( current_namespace ) ) {
ZVAL_STR_COPY ( zv , FC ( current_namespace ) ) ;
2014-07-29 21:22:23 +00:00
} else {
ZVAL_EMPTY_STRING ( zv ) ;
}
break ;
EMPTY_SWITCH_DEFAULT_CASE ( )
2014-03-13 13:01:28 +00:00
}
2014-07-29 21:22:23 +00:00
return 1 ;
2005-02-07 15:22:38 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2005-02-07 15:22:38 +00:00
2015-06-16 16:09:59 +00:00
static inline zend_bool zend_try_ct_eval_binary_op ( zval * result , uint32_t opcode , zval * op1 , zval * op2 ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-29 21:22:23 +00:00
binary_op_type fn = get_binary_op ( opcode ) ;
2015-06-16 16:09:59 +00:00
/* don't evaluate division by zero at compile-time */
2015-07-05 18:18:17 +00:00
if ( ( opcode = = ZEND_DIV | | opcode = = ZEND_MOD ) & &
zval_get_long ( op2 ) = = 0 ) {
2015-06-29 09:58:07 +00:00
return 0 ;
2015-07-05 18:18:17 +00:00
} else if ( ( opcode = = ZEND_SL | | opcode = = ZEND_SR ) & &
zval_get_long ( op2 ) < 0 ) {
2015-06-29 09:58:07 +00:00
return 0 ;
2015-06-16 16:09:59 +00:00
}
2014-12-13 22:06:14 +00:00
fn ( result , op1 , op2 ) ;
2015-06-16 16:09:59 +00:00
return 1 ;
2014-07-29 21:22:23 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2015-06-10 22:57:37 +00:00
static inline void zend_ct_eval_unary_op ( zval * result , uint32_t opcode , zval * op ) /* { { { */
{
unary_op_type fn = get_unary_op ( opcode ) ;
fn ( result , op ) ;
}
/* }}} */
2014-12-13 22:06:14 +00:00
static inline void zend_ct_eval_unary_pm ( zval * result , zend_ast_kind kind , zval * op ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-29 21:22:23 +00:00
zval left ;
2015-12-19 02:25:44 +00:00
ZVAL_LONG ( & left , ( kind = = ZEND_AST_UNARY_PLUS ) ? 1 : - 1 ) ;
mul_function ( result , & left , op ) ;
2014-07-29 21:22:23 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2004-08-12 05:41:01 +00:00
2014-12-13 22:06:14 +00:00
static inline void zend_ct_eval_greater ( zval * result , zend_ast_kind kind , zval * op1 , zval * op2 ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-29 21:22:23 +00:00
binary_op_type fn = kind = = ZEND_AST_GREATER
? is_smaller_function : is_smaller_or_equal_function ;
2014-12-13 22:06:14 +00:00
fn ( result , op2 , op1 ) ;
2014-07-29 21:22:23 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
static zend_bool zend_try_ct_eval_array ( zval * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-29 21:22:23 +00:00
zend_ast_list * list = zend_ast_get_list ( ast ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2015-06-15 15:41:47 +00:00
zend_bool is_constant = 1 ;
2005-02-07 16:09:54 +00:00
2014-07-29 21:22:23 +00:00
/* First ensure that *all* child nodes are constant and by-val */
for ( i = 0 ; i < list - > children ; + + i ) {
zend_ast * elem_ast = list - > child [ i ] ;
zend_bool by_ref = elem_ast - > attr ;
2014-12-13 22:06:14 +00:00
zend_eval_const_expr ( & elem_ast - > child [ 0 ] ) ;
zend_eval_const_expr ( & elem_ast - > child [ 1 ] ) ;
2012-07-22 12:33:25 +00:00
2014-07-30 11:43:04 +00:00
if ( by_ref | | elem_ast - > child [ 0 ] - > kind ! = ZEND_AST_ZVAL
| | ( elem_ast - > child [ 1 ] & & elem_ast - > child [ 1 ] - > kind ! = ZEND_AST_ZVAL )
2014-07-29 21:22:23 +00:00
) {
2015-06-15 15:41:47 +00:00
is_constant = 0 ;
2007-01-10 15:58:08 +00:00
}
1999-04-07 18:10:10 +00:00
}
2015-06-15 15:41:47 +00:00
if ( ! is_constant ) {
return 0 ;
}
2014-07-29 21:22:23 +00:00
array_init_size ( result , list - > children ) ;
for ( i = 0 ; i < list - > children ; + + i ) {
zend_ast * elem_ast = list - > child [ i ] ;
zend_ast * value_ast = elem_ast - > child [ 0 ] ;
zend_ast * key_ast = elem_ast - > child [ 1 ] ;
2006-05-11 21:07:39 +00:00
2014-07-29 21:22:23 +00:00
zval * value = zend_ast_get_zval ( value_ast ) ;
if ( Z_REFCOUNTED_P ( value ) ) Z_ADDREF_P ( value ) ;
if ( key_ast ) {
zval * key = zend_ast_get_zval ( key_ast ) ;
switch ( Z_TYPE_P ( key ) ) {
case IS_LONG :
zend_hash_index_update ( Z_ARRVAL_P ( result ) , Z_LVAL_P ( key ) , value ) ;
break ;
case IS_STRING :
zend_symtable_update ( Z_ARRVAL_P ( result ) , Z_STR_P ( key ) , value ) ;
break ;
case IS_DOUBLE :
zend_hash_index_update ( Z_ARRVAL_P ( result ) ,
zend_dval_to_lval ( Z_DVAL_P ( key ) ) , value ) ;
break ;
case IS_FALSE :
zend_hash_index_update ( Z_ARRVAL_P ( result ) , 0 , value ) ;
break ;
case IS_TRUE :
zend_hash_index_update ( Z_ARRVAL_P ( result ) , 1 , value ) ;
break ;
case IS_NULL :
2015-06-29 13:44:54 +00:00
zend_hash_update ( Z_ARRVAL_P ( result ) , ZSTR_EMPTY_ALLOC ( ) , value ) ;
2014-07-29 21:22:23 +00:00
break ;
default :
2015-04-01 10:32:23 +00:00
zend_error_noreturn ( E_COMPILE_ERROR , " Illegal offset type " ) ;
2014-07-29 21:22:23 +00:00
break ;
}
2012-08-25 14:23:14 +00:00
} else {
2014-07-29 21:22:23 +00:00
zend_hash_next_index_insert ( Z_ARRVAL_P ( result ) , value ) ;
2012-08-25 14:23:14 +00:00
}
2003-07-24 12:38:33 +00:00
}
2005-02-07 16:09:54 +00:00
2014-07-29 21:22:23 +00:00
return 1 ;
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-29 21:22:23 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_binary_op ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_ast * left_ast = ast - > child [ 0 ] ;
zend_ast * right_ast = ast - > child [ 1 ] ;
2014-08-25 19:21:16 +00:00
uint32_t opcode = ast - > attr ;
2005-02-20 10:19:11 +00:00
2014-06-14 16:30:18 +00:00
znode left_node , right_node ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & left_node , left_ast ) ;
zend_compile_expr ( & right_node , right_ast ) ;
2005-02-07 16:09:54 +00:00
2014-07-29 21:22:23 +00:00
if ( left_node . op_type = = IS_CONST & & right_node . op_type = = IS_CONST ) {
2015-06-16 16:09:59 +00:00
if ( zend_try_ct_eval_binary_op ( & result - > u . constant , opcode ,
& left_node . u . constant , & right_node . u . constant )
) {
2015-04-06 11:30:05 +00:00
result - > op_type = IS_CONST ;
zval_ptr_dtor ( & left_node . u . constant ) ;
zval_ptr_dtor ( & right_node . u . constant ) ;
return ;
2015-06-16 16:09:59 +00:00
}
1999-04-07 18:10:10 +00:00
}
2015-01-19 14:02:17 +00:00
do {
if ( opcode = = ZEND_IS_EQUAL | | opcode = = ZEND_IS_NOT_EQUAL ) {
if ( left_node . op_type = = IS_CONST ) {
if ( Z_TYPE ( left_node . u . constant ) = = IS_FALSE ) {
opcode = ( opcode = = ZEND_IS_NOT_EQUAL ) ? ZEND_BOOL : ZEND_BOOL_NOT ;
zend_emit_op_tmp ( result , opcode , & right_node , NULL ) ;
break ;
} else if ( Z_TYPE ( left_node . u . constant ) = = IS_TRUE ) {
opcode = ( opcode = = ZEND_IS_EQUAL ) ? ZEND_BOOL : ZEND_BOOL_NOT ;
zend_emit_op_tmp ( result , opcode , & right_node , NULL ) ;
break ;
}
} else if ( right_node . op_type = = IS_CONST ) {
if ( Z_TYPE ( right_node . u . constant ) = = IS_FALSE ) {
opcode = ( opcode = = ZEND_IS_NOT_EQUAL ) ? ZEND_BOOL : ZEND_BOOL_NOT ;
zend_emit_op_tmp ( result , opcode , & left_node , NULL ) ;
break ;
} else if ( Z_TYPE ( right_node . u . constant ) = = IS_TRUE ) {
opcode = ( opcode = = ZEND_IS_EQUAL ) ? ZEND_BOOL : ZEND_BOOL_NOT ;
zend_emit_op_tmp ( result , opcode , & left_node , NULL ) ;
break ;
}
}
}
2015-06-04 06:38:22 +00:00
if ( opcode = = ZEND_CONCAT ) {
/* convert constant operands to strings at compile-time */
if ( left_node . op_type = = IS_CONST ) {
convert_to_string ( & left_node . u . constant ) ;
}
if ( right_node . op_type = = IS_CONST ) {
convert_to_string ( & right_node . u . constant ) ;
}
}
2015-01-19 14:02:17 +00:00
zend_emit_op_tmp ( result , opcode , & left_node , & right_node ) ;
} while ( 0 ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-06-14 16:30:18 +00:00
/* We do not use zend_compile_binary_op for this because we want to retain the left-to-right
* evaluation order . */
2014-12-13 22:06:14 +00:00
void zend_compile_greater ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_ast * left_ast = ast - > child [ 0 ] ;
zend_ast * right_ast = ast - > child [ 1 ] ;
znode left_node , right_node ;
1999-04-07 18:10:10 +00:00
2014-06-14 16:30:18 +00:00
ZEND_ASSERT ( ast - > kind = = ZEND_AST_GREATER | | ast - > kind = = ZEND_AST_GREATER_EQUAL ) ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & left_node , left_ast ) ;
zend_compile_expr ( & right_node , right_ast ) ;
1999-04-07 18:10:10 +00:00
2014-07-29 21:22:23 +00:00
if ( left_node . op_type = = IS_CONST & & right_node . op_type = = IS_CONST ) {
result - > op_type = IS_CONST ;
zend_ct_eval_greater ( & result - > u . constant , ast - > kind ,
2014-12-13 22:06:14 +00:00
& left_node . u . constant , & right_node . u . constant ) ;
2014-07-29 21:22:23 +00:00
zval_ptr_dtor ( & left_node . u . constant ) ;
zval_ptr_dtor ( & right_node . u . constant ) ;
return ;
}
1999-04-07 18:10:10 +00:00
2014-07-28 20:03:16 +00:00
zend_emit_op_tmp ( result ,
ast - > kind = = ZEND_AST_GREATER ? ZEND_IS_SMALLER : ZEND_IS_SMALLER_OR_EQUAL ,
2014-12-13 22:06:14 +00:00
& right_node , & left_node ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_unary_op ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_ast * expr_ast = ast - > child [ 0 ] ;
2014-08-25 19:21:16 +00:00
uint32_t opcode = ast - > attr ;
2000-01-24 19:00:30 +00:00
2014-06-14 16:30:18 +00:00
znode expr_node ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & expr_node , expr_ast ) ;
2008-07-24 22:21:41 +00:00
2015-06-10 22:57:37 +00:00
if ( expr_node . op_type = = IS_CONST ) {
result - > op_type = IS_CONST ;
zend_ct_eval_unary_op ( & result - > u . constant , opcode ,
& expr_node . u . constant ) ;
zval_ptr_dtor ( & expr_node . u . constant ) ;
return ;
}
2014-12-13 22:06:14 +00:00
zend_emit_op_tmp ( result , opcode , & expr_node , NULL ) ;
2014-06-14 16:30:18 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2008-06-29 08:21:35 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_unary_pm ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_ast * expr_ast = ast - > child [ 0 ] ;
2015-12-17 22:36:14 +00:00
znode expr_node ;
2015-12-19 02:25:44 +00:00
znode lefthand_node ;
2010-11-24 05:41:23 +00:00
2014-06-26 10:43:20 +00:00
ZEND_ASSERT ( ast - > kind = = ZEND_AST_UNARY_PLUS | | ast - > kind = = ZEND_AST_UNARY_MINUS ) ;
2010-11-24 05:41:23 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & expr_node , expr_ast ) ;
2000-01-24 19:00:30 +00:00
2014-07-29 21:22:23 +00:00
if ( expr_node . op_type = = IS_CONST ) {
result - > op_type = IS_CONST ;
2014-12-13 22:06:14 +00:00
zend_ct_eval_unary_pm ( & result - > u . constant , ast - > kind , & expr_node . u . constant ) ;
2014-07-29 21:22:23 +00:00
zval_ptr_dtor ( & expr_node . u . constant ) ;
return ;
2002-07-30 22:19:50 +00:00
}
2000-01-24 19:00:30 +00:00
2015-12-19 02:25:44 +00:00
lefthand_node . op_type = IS_CONST ;
ZVAL_LONG ( & lefthand_node . u . constant , ( ast - > kind = = ZEND_AST_UNARY_PLUS ) ? 1 : - 1 ) ;
zend_emit_op_tmp ( result , ZEND_MUL , & lefthand_node , & expr_node ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_short_circuiting ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_ast * left_ast = ast - > child [ 0 ] ;
zend_ast * right_ast = ast - > child [ 1 ] ;
1999-04-07 18:10:10 +00:00
2014-06-14 16:30:18 +00:00
znode left_node , right_node ;
zend_op * opline_jmpz , * opline_bool ;
2014-08-25 19:21:16 +00:00
uint32_t opnum_jmpz ;
1999-04-07 18:10:10 +00:00
2014-06-14 16:30:18 +00:00
ZEND_ASSERT ( ast - > kind = = ZEND_AST_AND | | ast - > kind = = ZEND_AST_OR ) ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & left_node , left_ast ) ;
1999-04-07 18:10:10 +00:00
2015-06-14 13:46:11 +00:00
if ( left_node . op_type = = IS_CONST ) {
2015-06-14 14:56:06 +00:00
if ( ( ast - > kind = = ZEND_AST_AND & & ! zend_is_true ( & left_node . u . constant ) )
2015-06-14 15:08:39 +00:00
| | ( ast - > kind = = ZEND_AST_OR & & zend_is_true ( & left_node . u . constant ) ) ) {
2015-06-14 13:46:11 +00:00
result - > op_type = IS_CONST ;
ZVAL_BOOL ( & result - > u . constant , zend_is_true ( & left_node . u . constant ) ) ;
} else {
zend_compile_expr ( & right_node , right_ast ) ;
if ( right_node . op_type = = IS_CONST ) {
result - > op_type = IS_CONST ;
ZVAL_BOOL ( & result - > u . constant , zend_is_true ( & right_node . u . constant ) ) ;
zval_ptr_dtor ( & right_node . u . constant ) ;
} else {
2016-03-17 14:55:25 +00:00
zend_emit_op_tmp ( result , ZEND_BOOL , & right_node , NULL ) ;
2015-06-14 13:46:11 +00:00
}
}
zval_ptr_dtor ( & left_node . u . constant ) ;
return ;
}
2014-06-14 16:30:18 +00:00
opnum_jmpz = get_next_op_number ( CG ( active_op_array ) ) ;
2014-07-28 20:03:16 +00:00
opline_jmpz = zend_emit_op ( NULL , ast - > kind = = ZEND_AST_AND ? ZEND_JMPZ_EX : ZEND_JMPNZ_EX ,
2014-12-13 22:06:14 +00:00
& left_node , NULL ) ;
2007-11-21 09:41:35 +00:00
2014-06-14 16:30:18 +00:00
if ( left_node . op_type = = IS_TMP_VAR ) {
SET_NODE ( opline_jmpz - > result , & left_node ) ;
2015-06-14 14:56:06 +00:00
} else {
2015-06-14 06:27:48 +00:00
opline_jmpz - > result . var = get_temporary_variable ( CG ( active_op_array ) ) ;
opline_jmpz - > result_type = IS_TMP_VAR ;
2011-10-18 19:42:42 +00:00
}
2013-01-28 02:02:51 +00:00
2015-06-14 13:46:11 +00:00
GET_NODE ( result , opline_jmpz - > result ) ;
2015-06-19 15:05:35 +00:00
zend_compile_expr ( & right_node , right_ast ) ;
2015-06-14 13:46:11 +00:00
opline_bool = zend_emit_op ( NULL , ZEND_BOOL , & right_node , NULL ) ;
SET_NODE ( opline_bool - > result , result ) ;
2014-12-13 22:06:14 +00:00
zend_update_jump_target_to_next ( opnum_jmpz ) ;
2007-11-21 09:41:35 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2007-11-21 09:41:35 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_post_incdec ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_ast * var_ast = ast - > child [ 0 ] ;
2014-07-27 20:26:06 +00:00
ZEND_ASSERT ( ast - > kind = = ZEND_AST_POST_INC | | ast - > kind = = ZEND_AST_POST_DEC ) ;
2007-11-21 09:41:35 +00:00
2015-03-27 15:40:04 +00:00
zend_ensure_writable_variable ( var_ast ) ;
2014-06-14 16:30:18 +00:00
if ( var_ast - > kind = = ZEND_AST_PROP ) {
2014-12-13 22:06:14 +00:00
zend_op * opline = zend_compile_prop_common ( NULL , var_ast , BP_VAR_RW ) ;
2014-07-27 20:26:06 +00:00
opline - > opcode = ast - > kind = = ZEND_AST_POST_INC ? ZEND_POST_INC_OBJ : ZEND_POST_DEC_OBJ ;
2014-12-13 22:06:14 +00:00
zend_make_tmp_result ( result , opline ) ;
2011-10-18 19:42:42 +00:00
} else {
2014-07-29 19:00:19 +00:00
znode var_node ;
2014-12-13 22:06:14 +00:00
zend_compile_var ( & var_node , var_ast , BP_VAR_RW ) ;
2014-07-28 20:03:16 +00:00
zend_emit_op_tmp ( result , ast - > kind = = ZEND_AST_POST_INC ? ZEND_POST_INC : ZEND_POST_DEC ,
2014-12-13 22:06:14 +00:00
& var_node , NULL ) ;
2011-10-18 19:42:42 +00:00
}
2014-06-14 16:30:18 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2007-11-21 09:41:35 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_pre_incdec ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_ast * var_ast = ast - > child [ 0 ] ;
2014-07-27 20:26:06 +00:00
ZEND_ASSERT ( ast - > kind = = ZEND_AST_PRE_INC | | ast - > kind = = ZEND_AST_PRE_DEC ) ;
2013-01-28 02:02:51 +00:00
2015-03-27 15:40:04 +00:00
zend_ensure_writable_variable ( var_ast ) ;
2014-06-14 16:30:18 +00:00
if ( var_ast - > kind = = ZEND_AST_PROP ) {
2014-12-13 22:06:14 +00:00
zend_op * opline = zend_compile_prop_common ( result , var_ast , BP_VAR_RW ) ;
2014-07-27 20:26:06 +00:00
opline - > opcode = ast - > kind = = ZEND_AST_PRE_INC ? ZEND_PRE_INC_OBJ : ZEND_PRE_DEC_OBJ ;
2014-06-14 16:30:18 +00:00
} else {
2014-07-29 19:00:19 +00:00
znode var_node ;
2014-12-13 22:06:14 +00:00
zend_compile_var ( & var_node , var_ast , BP_VAR_RW ) ;
2014-07-28 20:03:16 +00:00
zend_emit_op ( result , ast - > kind = = ZEND_AST_PRE_INC ? ZEND_PRE_INC : ZEND_PRE_DEC ,
2014-12-13 22:06:14 +00:00
& var_node , NULL ) ;
2014-06-14 16:30:18 +00:00
}
2007-11-21 09:41:35 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2007-11-21 09:41:35 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_cast ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_ast * expr_ast = ast - > child [ 0 ] ;
znode expr_node ;
1999-04-07 18:10:10 +00:00
zend_op * opline ;
2006-05-09 23:53:23 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & expr_node , expr_ast ) ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_emit_op_tmp ( result , ZEND_CAST , & expr_node , NULL ) ;
2014-06-19 11:57:29 +00:00
opline - > extended_value = ast - > attr ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
static void zend_compile_shorthand_conditional ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_ast * cond_ast = ast - > child [ 0 ] ;
zend_ast * false_ast = ast - > child [ 2 ] ;
1999-04-07 18:10:10 +00:00
2014-06-14 16:30:18 +00:00
znode cond_node , false_node ;
2015-07-06 15:41:29 +00:00
zend_op * opline_qm_assign ;
2014-08-25 19:21:16 +00:00
uint32_t opnum_jmp_set ;
1999-04-07 18:10:10 +00:00
2014-06-14 16:30:18 +00:00
ZEND_ASSERT ( ast - > child [ 1 ] = = NULL ) ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & cond_node , cond_ast ) ;
1999-04-07 18:10:10 +00:00
2014-06-14 16:30:18 +00:00
opnum_jmp_set = get_next_op_number ( CG ( active_op_array ) ) ;
2014-12-13 22:06:14 +00:00
zend_emit_op_tmp ( result , ZEND_JMP_SET , & cond_node , NULL ) ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & false_node , false_ast ) ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
opline_qm_assign = zend_emit_op_tmp ( NULL , ZEND_QM_ASSIGN , & false_node , NULL ) ;
2014-06-14 16:30:18 +00:00
SET_NODE ( opline_qm_assign - > result , result ) ;
2015-07-06 15:41:29 +00:00
zend_update_jump_target_to_next ( opnum_jmp_set ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_conditional ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_ast * cond_ast = ast - > child [ 0 ] ;
zend_ast * true_ast = ast - > child [ 1 ] ;
zend_ast * false_ast = ast - > child [ 2 ] ;
2006-05-09 23:53:23 +00:00
2014-06-14 16:30:18 +00:00
znode cond_node , true_node , false_node ;
2015-07-06 15:41:29 +00:00
zend_op * opline_qm_assign2 ;
uint32_t opnum_jmpz , opnum_jmp ;
2014-06-14 16:30:18 +00:00
if ( ! true_ast ) {
2014-12-13 22:06:14 +00:00
zend_compile_shorthand_conditional ( result , ast ) ;
1999-04-07 18:10:10 +00:00
return ;
}
2015-01-03 09:22:58 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & cond_node , cond_ast ) ;
2006-05-09 23:53:23 +00:00
2014-12-13 22:06:14 +00:00
opnum_jmpz = zend_emit_cond_jump ( ZEND_JMPZ , & cond_node , 0 ) ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & true_node , true_ast ) ;
2006-05-09 23:53:23 +00:00
2014-12-13 22:06:14 +00:00
zend_emit_op_tmp ( result , ZEND_QM_ASSIGN , & true_node , NULL ) ;
2006-05-09 23:53:23 +00:00
2014-12-13 22:06:14 +00:00
opnum_jmp = zend_emit_jump ( 0 ) ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_update_jump_target_to_next ( opnum_jmpz ) ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & false_node , false_ast ) ;
2006-05-09 23:53:23 +00:00
2015-07-06 15:41:29 +00:00
opline_qm_assign2 = zend_emit_op ( NULL , ZEND_QM_ASSIGN , & false_node , NULL ) ;
2014-06-14 16:30:18 +00:00
SET_NODE ( opline_qm_assign2 - > result , result ) ;
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
zend_update_jump_target_to_next ( opnum_jmp ) ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
1999-04-07 18:10:10 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_coalesce ( znode * result , zend_ast * ast ) /* { { { */
2014-09-16 18:14:46 +00:00
{
zend_ast * expr_ast = ast - > child [ 0 ] ;
zend_ast * default_ast = ast - > child [ 1 ] ;
znode expr_node , default_node ;
zend_op * opline ;
uint32_t opnum ;
2014-12-13 22:06:14 +00:00
zend_compile_var ( & expr_node , expr_ast , BP_VAR_IS ) ;
2014-09-16 18:14:46 +00:00
opnum = get_next_op_number ( CG ( active_op_array ) ) ;
2014-12-13 22:06:14 +00:00
zend_emit_op_tmp ( result , ZEND_COALESCE , & expr_node , NULL ) ;
2014-09-16 18:14:46 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & default_node , default_ast ) ;
2014-09-16 18:14:46 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_emit_op_tmp ( NULL , ZEND_QM_ASSIGN , & default_node , NULL ) ;
2014-09-16 18:14:46 +00:00
SET_NODE ( opline - > result , result ) ;
opline = & CG ( active_op_array ) - > opcodes [ opnum ] ;
opline - > op2 . opline_num = get_next_op_number ( CG ( active_op_array ) ) ;
}
/* }}} */
2014-12-13 22:06:14 +00:00
void zend_compile_print ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2015-09-29 13:49:22 +00:00
zend_op * opline ;
2014-06-14 16:30:18 +00:00
zend_ast * expr_ast = ast - > child [ 0 ] ;
2000-01-24 19:00:30 +00:00
2014-06-14 16:30:18 +00:00
znode expr_node ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & expr_node , expr_ast ) ;
2014-06-14 16:30:18 +00:00
2015-09-29 13:49:22 +00:00
opline = zend_emit_op ( NULL , ZEND_ECHO , & expr_node , NULL ) ;
2015-09-30 02:41:27 +00:00
opline - > extended_value = 1 ;
2014-12-06 11:57:20 +00:00
result - > op_type = IS_CONST ;
ZVAL_LONG ( & result - > u . constant , 1 ) ;
2000-01-24 19:00:30 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2000-01-24 19:00:30 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_exit ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_ast * expr_ast = ast - > child [ 0 ] ;
2003-03-02 13:33:31 +00:00
2014-06-14 16:30:18 +00:00
if ( expr_ast ) {
znode expr_node ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & expr_node , expr_ast ) ;
zend_emit_op ( NULL , ZEND_EXIT , & expr_node , NULL ) ;
2014-06-14 16:30:18 +00:00
} else {
2014-12-13 22:06:14 +00:00
zend_emit_op ( NULL , ZEND_EXIT , NULL , NULL ) ;
2003-03-02 13:33:31 +00:00
}
2014-06-14 16:30:18 +00:00
result - > op_type = IS_CONST ;
ZVAL_BOOL ( & result - > u . constant , 1 ) ;
2003-03-02 13:33:31 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2003-03-02 13:33:31 +00:00
2015-02-20 11:59:56 +00:00
void zend_compile_yield ( znode * result , zend_ast * ast ) /* { { { */
{
zend_ast * value_ast = ast - > child [ 0 ] ;
zend_ast * key_ast = ast - > child [ 1 ] ;
znode value_node , key_node ;
znode * value_node_ptr = NULL , * key_node_ptr = NULL ;
zend_op * opline ;
zend_bool returns_by_ref = ( CG ( active_op_array ) - > fn_flags & ZEND_ACC_RETURN_REFERENCE ) ! = 0 ;
zend_mark_function_as_generator ( ) ;
2001-08-08 17:18:16 +00:00
2014-06-14 16:30:18 +00:00
if ( key_ast ) {
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & key_node , key_ast ) ;
2014-06-14 16:30:18 +00:00
key_node_ptr = & key_node ;
}
2014-06-16 17:11:52 +00:00
2014-06-14 16:30:18 +00:00
if ( value_ast ) {
if ( returns_by_ref & & zend_is_variable ( value_ast ) & & ! zend_is_call ( value_ast ) ) {
2014-12-13 22:06:14 +00:00
zend_compile_var ( & value_node , value_ast , BP_VAR_REF ) ;
2014-06-16 17:11:52 +00:00
} else {
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & value_node , value_ast ) ;
2014-06-16 17:11:52 +00:00
}
2014-06-14 16:30:18 +00:00
value_node_ptr = & value_node ;
}
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( result , ZEND_YIELD , value_node_ptr , key_node_ptr ) ;
2014-06-14 16:30:18 +00:00
if ( value_ast & & returns_by_ref & & zend_is_call ( value_ast ) ) {
opline - > extended_value = ZEND_RETURNS_FUNCTION ;
}
2010-07-08 14:05:11 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2010-07-08 14:05:11 +00:00
2015-02-20 11:59:56 +00:00
void zend_compile_yield_from ( znode * result , zend_ast * ast ) /* { { { */
{
zend_ast * expr_ast = ast - > child [ 0 ] ;
znode expr_node ;
zend_mark_function_as_generator ( ) ;
2016-02-12 16:55:29 +00:00
if ( CG ( active_op_array ) - > fn_flags & ZEND_ACC_RETURN_REFERENCE ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
" Cannot use \" yield from \" inside a by-reference generator " ) ;
}
2015-02-20 11:59:56 +00:00
zend_compile_expr ( & expr_node , expr_ast ) ;
zend_emit_op_tmp ( result , ZEND_YIELD_FROM , & expr_node , NULL ) ;
}
/* }}} */
2014-12-13 22:06:14 +00:00
void zend_compile_instanceof ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-14 16:30:18 +00:00
zend_ast * obj_ast = ast - > child [ 0 ] ;
zend_ast * class_ast = ast - > child [ 1 ] ;
1999-04-07 18:10:10 +00:00
2014-06-14 16:30:18 +00:00
znode obj_node , class_node ;
zend_op * opline ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & obj_node , obj_ast ) ;
2014-06-14 16:30:18 +00:00
if ( obj_node . op_type = = IS_CONST ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
" instanceof expects an object instance, constant given " ) ;
2001-08-06 14:36:46 +00:00
}
2014-10-22 13:23:43 +00:00
if ( zend_is_const_default_class_ref ( class_ast ) ) {
class_node . op_type = IS_CONST ;
2014-12-13 22:06:14 +00:00
ZVAL_STR ( & class_node . u . constant , zend_resolve_class_name_ast ( class_ast ) ) ;
2014-10-22 13:23:43 +00:00
} else {
2015-04-01 17:01:57 +00:00
opline = zend_compile_class_ref ( & class_node , class_ast , 0 ) ;
2014-10-23 10:50:57 +00:00
opline - > extended_value | = ZEND_FETCH_CLASS_NO_AUTOLOAD ;
2014-10-22 13:23:43 +00:00
}
2014-12-13 22:06:14 +00:00
opline = zend_emit_op_tmp ( result , ZEND_INSTANCEOF , & obj_node , NULL ) ;
2003-05-29 09:01:55 +00:00
2014-10-22 13:23:43 +00:00
if ( class_node . op_type = = IS_CONST ) {
opline - > op2_type = IS_CONST ;
opline - > op2 . constant = zend_add_class_name_literal (
2014-12-13 22:06:14 +00:00
CG ( active_op_array ) , Z_STR ( class_node . u . constant ) ) ;
2014-10-22 13:23:43 +00:00
} else {
SET_NODE ( opline - > op2 , & class_node ) ;
}
2014-06-14 16:30:18 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-14 16:30:18 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_include_or_eval ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-19 11:57:29 +00:00
zend_ast * expr_ast = ast - > child [ 0 ] ;
znode expr_node ;
zend_op * opline ;
2014-12-13 22:06:14 +00:00
zend_do_extended_fcall_begin ( ) ;
zend_compile_expr ( & expr_node , expr_ast ) ;
2014-06-19 11:57:29 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_emit_op ( result , ZEND_INCLUDE_OR_EVAL , & expr_node , NULL ) ;
2014-06-19 11:57:29 +00:00
opline - > extended_value = ast - > attr ;
2014-12-13 22:06:14 +00:00
zend_do_extended_fcall_end ( ) ;
2014-06-19 11:57:29 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-19 11:57:29 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_isset_or_empty ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-19 11:57:29 +00:00
zend_ast * var_ast = ast - > child [ 0 ] ;
znode var_node ;
2014-11-10 16:31:31 +00:00
zend_op * opline = NULL ;
2014-06-19 11:57:29 +00:00
ZEND_ASSERT ( ast - > kind = = ZEND_AST_ISSET | | ast - > kind = = ZEND_AST_EMPTY ) ;
if ( ! zend_is_variable ( var_ast ) | | zend_is_call ( var_ast ) ) {
if ( ast - > kind = = ZEND_AST_EMPTY ) {
/* empty(expr) can be transformed to !expr */
2014-07-28 16:18:47 +00:00
zend_ast * not_ast = zend_ast_create_ex ( ZEND_AST_UNARY_OP , ZEND_BOOL_NOT , var_ast ) ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( result , not_ast ) ;
2014-06-19 11:57:29 +00:00
return ;
} else {
zend_error_noreturn ( E_COMPILE_ERROR ,
" Cannot use isset() on the result of an expression "
" (you can use \" null !== expression \" instead) " ) ;
}
}
switch ( var_ast - > kind ) {
case ZEND_AST_VAR :
2014-12-13 22:06:14 +00:00
if ( zend_try_compile_cv ( & var_node , var_ast ) = = SUCCESS ) {
opline = zend_emit_op ( result , ZEND_ISSET_ISEMPTY_VAR , & var_node , NULL ) ;
2014-06-19 11:57:29 +00:00
opline - > extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET ;
} else {
2015-02-02 17:44:16 +00:00
opline = zend_compile_simple_var_no_cv ( result , var_ast , BP_VAR_IS , 0 ) ;
2014-06-19 11:57:29 +00:00
opline - > opcode = ZEND_ISSET_ISEMPTY_VAR ;
2008-11-25 09:56:32 +00:00
}
1999-04-07 18:10:10 +00:00
break ;
2014-06-19 11:57:29 +00:00
case ZEND_AST_DIM :
2014-12-13 22:06:14 +00:00
opline = zend_compile_dim_common ( result , var_ast , BP_VAR_IS ) ;
2014-06-19 11:57:29 +00:00
opline - > opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ ;
break ;
case ZEND_AST_PROP :
2014-12-13 22:06:14 +00:00
opline = zend_compile_prop_common ( result , var_ast , BP_VAR_IS ) ;
2014-06-19 11:57:29 +00:00
opline - > opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ ;
1999-04-07 18:10:10 +00:00
break ;
2014-06-19 11:57:29 +00:00
case ZEND_AST_STATIC_PROP :
2015-02-02 17:44:16 +00:00
opline = zend_compile_static_prop_common ( result , var_ast , BP_VAR_IS , 0 ) ;
2014-06-19 11:57:29 +00:00
opline - > opcode = ZEND_ISSET_ISEMPTY_VAR ;
break ;
EMPTY_SWITCH_DEFAULT_CASE ( )
1999-04-07 18:10:10 +00:00
}
2006-05-09 23:53:23 +00:00
2014-08-26 10:22:03 +00:00
result - > op_type = opline - > result_type = IS_TMP_VAR ;
2014-06-19 11:57:29 +00:00
opline - > extended_value | = ast - > kind = = ZEND_AST_ISSET ? ZEND_ISSET : ZEND_ISEMPTY ;
1999-04-07 18:10:10 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2003-03-31 20:42:01 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_silence ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-19 11:57:29 +00:00
zend_ast * expr_ast = ast - > child [ 0 ] ;
znode silence_node ;
2015-07-10 00:31:52 +00:00
uint32_t begin_opline_num , end_opline_num ;
zend_brk_cont_element * brk_cont_element ;
2003-02-10 16:11:24 +00:00
2015-07-10 00:31:52 +00:00
begin_opline_num = get_next_op_number ( CG ( active_op_array ) ) ;
2014-12-13 22:06:14 +00:00
zend_emit_op_tmp ( & silence_node , ZEND_BEGIN_SILENCE , NULL , NULL ) ;
2005-12-01 11:48:17 +00:00
2014-06-19 11:57:29 +00:00
if ( expr_ast - > kind = = ZEND_AST_VAR ) {
/* For @$var we need to force a FETCH instruction, otherwise the CV access will
* happen outside the silenced section . */
2015-02-02 17:44:16 +00:00
zend_compile_simple_var_no_cv ( result , expr_ast , BP_VAR_R , 0 ) ;
2005-12-01 11:48:17 +00:00
} else {
2014-12-13 22:06:14 +00:00
zend_compile_expr ( result , expr_ast ) ;
2005-12-01 11:48:17 +00:00
}
2005-09-01 10:05:32 +00:00
2015-07-10 00:31:52 +00:00
end_opline_num = get_next_op_number ( CG ( active_op_array ) ) ;
2014-12-13 22:06:14 +00:00
zend_emit_op ( NULL , ZEND_END_SILENCE , & silence_node , NULL ) ;
2015-07-10 00:31:52 +00:00
/* Store BEGIN_SILENCE/END_SILENCE pair to restore previous
* EG ( error_reporting ) value on exception */
brk_cont_element = get_next_brk_cont_element ( CG ( active_op_array ) ) ;
brk_cont_element - > start = begin_opline_num ;
brk_cont_element - > cont = brk_cont_element - > brk = end_opline_num ;
brk_cont_element - > parent = - 1 ;
2003-02-10 16:11:24 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2003-02-10 16:11:24 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_shell_exec ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-19 11:57:29 +00:00
zend_ast * expr_ast = ast - > child [ 0 ] ;
2003-08-03 08:21:08 +00:00
2014-06-19 11:57:29 +00:00
zval fn_name ;
2014-07-13 11:11:55 +00:00
zend_ast * name_ast , * args_ast , * call_ast ;
2014-06-19 11:57:29 +00:00
ZVAL_STRING ( & fn_name , " shell_exec " ) ;
name_ast = zend_ast_create_zval ( & fn_name ) ;
2014-08-29 18:52:26 +00:00
args_ast = zend_ast_create_list ( 1 , ZEND_AST_ARG_LIST , expr_ast ) ;
2014-07-28 16:18:47 +00:00
call_ast = zend_ast_create ( ZEND_AST_CALL , name_ast , args_ast ) ;
2014-06-19 11:57:29 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( result , call_ast ) ;
2014-06-19 11:57:29 +00:00
2014-07-25 18:24:15 +00:00
zval_ptr_dtor ( & fn_name ) ;
2005-01-22 02:29:18 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2005-01-22 02:29:18 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_array ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-27 20:26:06 +00:00
zend_ast_list * list = zend_ast_get_list ( ast ) ;
2014-06-19 11:57:29 +00:00
zend_op * opline ;
2014-10-02 09:37:44 +00:00
uint32_t i , opnum_init = - 1 ;
2014-06-19 11:57:29 +00:00
zend_bool packed = 1 ;
2014-12-13 22:06:14 +00:00
if ( zend_try_ct_eval_array ( & result - > u . constant , ast ) ) {
2007-09-28 19:52:53 +00:00
result - > op_type = IS_CONST ;
2014-07-29 21:22:23 +00:00
return ;
2007-09-28 19:52:53 +00:00
}
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < list - > children ; + + i ) {
zend_ast * elem_ast = list - > child [ i ] ;
2014-06-19 11:57:29 +00:00
zend_ast * value_ast = elem_ast - > child [ 0 ] ;
zend_ast * key_ast = elem_ast - > child [ 1 ] ;
zend_bool by_ref = elem_ast - > attr ;
2008-11-25 09:56:32 +00:00
2014-06-19 11:57:29 +00:00
znode value_node , key_node , * key_node_ptr = NULL ;
2008-11-25 09:56:32 +00:00
2014-06-19 11:57:29 +00:00
if ( key_ast ) {
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & key_node , key_ast ) ;
zend_handle_numeric_op ( & key_node ) ;
2014-06-19 11:57:29 +00:00
key_node_ptr = & key_node ;
}
2007-09-28 19:52:53 +00:00
2014-06-19 11:57:29 +00:00
if ( by_ref ) {
zend_ensure_writable_variable ( value_ast ) ;
2014-12-13 22:06:14 +00:00
zend_compile_var ( & value_node , value_ast , BP_VAR_W ) ;
2014-06-19 11:57:29 +00:00
} else {
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & value_node , value_ast ) ;
2008-11-25 09:56:32 +00:00
}
2014-06-19 11:57:29 +00:00
if ( i = = 0 ) {
2014-10-02 09:37:44 +00:00
opnum_init = get_next_op_number ( CG ( active_op_array ) ) ;
2014-12-13 22:06:14 +00:00
opline = zend_emit_op_tmp ( result , ZEND_INIT_ARRAY , & value_node , key_node_ptr ) ;
2014-07-27 20:26:06 +00:00
opline - > extended_value = list - > children < < ZEND_ARRAY_SIZE_SHIFT ;
2014-06-19 11:57:29 +00:00
} else {
2014-07-28 20:03:16 +00:00
opline = zend_emit_op ( NULL , ZEND_ADD_ARRAY_ELEMENT ,
2014-12-13 22:06:14 +00:00
& value_node , key_node_ptr ) ;
2014-06-19 11:57:29 +00:00
SET_NODE ( opline - > result , result ) ;
2008-11-25 09:56:32 +00:00
}
2014-06-19 11:57:29 +00:00
opline - > extended_value | = by_ref ;
2014-08-15 15:10:06 +00:00
if ( key_ast & & key_node . op_type = = IS_CONST & & Z_TYPE ( key_node . u . constant ) = = IS_STRING ) {
packed = 0 ;
2008-11-25 09:56:32 +00:00
}
2007-12-13 08:57:52 +00:00
}
2008-11-25 09:56:32 +00:00
2014-06-19 11:57:29 +00:00
/* Handle empty array */
2014-07-27 20:26:06 +00:00
if ( ! list - > children ) {
2014-12-13 22:06:14 +00:00
zend_emit_op_tmp ( result , ZEND_INIT_ARRAY , NULL , NULL ) ;
2007-12-13 08:57:52 +00:00
}
2013-01-28 02:02:51 +00:00
2014-06-19 11:57:29 +00:00
/* Add a flag to INIT_ARRAY if we know this array cannot be packed */
if ( ! packed ) {
2014-10-02 09:37:44 +00:00
ZEND_ASSERT ( opnum_init ! = - 1 ) ;
2014-06-19 11:57:29 +00:00
opline = & CG ( active_op_array ) - > opcodes [ opnum_init ] ;
opline - > extended_value | = ZEND_ARRAY_NOT_PACKED ;
2013-07-16 18:39:33 +00:00
}
2014-06-19 11:57:29 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2013-07-16 18:39:33 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_const ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-19 11:57:29 +00:00
zend_ast * name_ast = ast - > child [ 0 ] ;
zend_op * opline ;
2014-09-23 18:21:28 +00:00
zend_bool is_fully_qualified ;
zend_string * orig_name = zend_ast_get_str ( name_ast ) ;
2015-07-29 17:18:13 +00:00
zend_string * resolved_name = zend_resolve_const_name ( orig_name , name_ast - > attr , & is_fully_qualified ) ;
2014-06-19 11:57:29 +00:00
2015-07-29 17:18:13 +00:00
if ( zend_string_equals_literal ( resolved_name , " __COMPILER_HALT_OFFSET__ " ) | | ( name_ast - > attr ! = ZEND_NAME_RELATIVE & & zend_string_equals_literal ( orig_name , " __COMPILER_HALT_OFFSET__ " ) ) ) {
2015-03-18 12:31:29 +00:00
zend_ast * last = CG ( ast ) ;
while ( last - > kind = = ZEND_AST_STMT_LIST ) {
zend_ast_list * list = zend_ast_get_list ( last ) ;
last = list - > child [ list - > children - 1 ] ;
}
if ( last - > kind = = ZEND_AST_HALT_COMPILER ) {
result - > op_type = IS_CONST ;
2015-07-29 17:18:13 +00:00
ZVAL_LONG ( & result - > u . constant , Z_LVAL_P ( zend_ast_get_zval ( last - > child [ 0 ] ) ) ) ;
2015-03-18 12:31:29 +00:00
zend_string_release ( resolved_name ) ;
return ;
}
}
2015-07-29 17:18:13 +00:00
if ( zend_try_ct_eval_const ( & result - > u . constant , resolved_name , is_fully_qualified ) ) {
result - > op_type = IS_CONST ;
zend_string_release ( resolved_name ) ;
return ;
}
2014-12-13 22:06:14 +00:00
opline = zend_emit_op_tmp ( result , ZEND_FETCH_CONSTANT , NULL , NULL ) ;
2014-06-19 11:57:29 +00:00
opline - > op2_type = IS_CONST ;
2014-06-28 20:27:06 +00:00
if ( is_fully_qualified ) {
2014-06-19 11:57:29 +00:00
opline - > op2 . constant = zend_add_const_name_literal (
2014-12-13 22:06:14 +00:00
CG ( active_op_array ) , resolved_name , 0 ) ;
2014-06-19 11:57:29 +00:00
} else {
opline - > extended_value = IS_CONSTANT_UNQUALIFIED ;
2015-04-20 18:16:58 +00:00
if ( FC ( current_namespace ) ) {
2014-06-19 11:57:29 +00:00
opline - > extended_value | = IS_CONSTANT_IN_NAMESPACE ;
opline - > op2 . constant = zend_add_const_name_literal (
2014-12-13 22:06:14 +00:00
CG ( active_op_array ) , resolved_name , 1 ) ;
2014-06-19 11:57:29 +00:00
} else {
opline - > op2 . constant = zend_add_const_name_literal (
2014-12-13 22:06:14 +00:00
CG ( active_op_array ) , resolved_name , 0 ) ;
2014-06-19 11:57:29 +00:00
}
2011-07-07 23:07:14 +00:00
}
2014-12-13 22:06:14 +00:00
zend_alloc_cache_slot ( opline - > op2 . constant ) ;
2007-09-28 19:52:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2007-09-28 19:52:53 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_class_const ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-19 11:57:29 +00:00
zend_ast * class_ast = ast - > child [ 0 ] ;
zend_ast * const_ast = ast - > child [ 1 ] ;
2007-09-28 19:52:53 +00:00
2014-06-19 11:57:29 +00:00
znode class_node , const_node ;
2015-02-13 14:33:50 +00:00
zend_op * opline ;
2015-02-10 14:43:23 +00:00
zend_string * resolved_name ;
2015-05-25 20:58:30 +00:00
if ( zend_try_compile_const_expr_resolve_class_name ( & result - > u . constant , class_ast , const_ast , 0 ) ) {
if ( Z_TYPE ( result - > u . constant ) = = IS_NULL ) {
zend_op * opline = zend_emit_op_tmp ( result , ZEND_FETCH_CLASS_NAME , NULL , NULL ) ;
opline - > extended_value = zend_get_class_fetch_type ( zend_ast_get_str ( class_ast ) ) ;
} else {
result - > op_type = IS_CONST ;
}
return ;
}
2015-02-10 14:43:23 +00:00
zend_eval_const_expr ( & class_ast ) ;
zend_eval_const_expr ( & const_ast ) ;
if ( class_ast - > kind = = ZEND_AST_ZVAL ) {
resolved_name = zend_resolve_class_name_ast ( class_ast ) ;
if ( const_ast - > kind = = ZEND_AST_ZVAL & & zend_try_ct_eval_class_const ( & result - > u . constant , resolved_name , zend_ast_get_str ( const_ast ) ) ) {
result - > op_type = IS_CONST ;
zend_string_release ( resolved_name ) ;
return ;
}
}
2015-05-25 20:58:30 +00:00
if ( const_ast - > kind = = ZEND_AST_ZVAL & & zend_string_equals_literal_ci ( zend_ast_get_str ( const_ast ) , " class " ) ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
" Dynamic class names are not allowed in compile-time ::class fetch " ) ;
}
2014-06-19 11:57:29 +00:00
if ( zend_is_const_default_class_ref ( class_ast ) ) {
2014-07-19 21:30:07 +00:00
class_node . op_type = IS_CONST ;
2015-02-10 14:43:23 +00:00
ZVAL_STR ( & class_node . u . constant , resolved_name ) ;
2014-06-19 11:57:29 +00:00
} else {
2015-02-10 14:43:23 +00:00
if ( class_ast - > kind = = ZEND_AST_ZVAL ) {
zend_string_release ( resolved_name ) ;
}
2015-04-01 17:01:57 +00:00
zend_compile_class_ref ( & class_node , class_ast , 1 ) ;
2007-09-28 19:52:53 +00:00
}
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & const_node , const_ast ) ;
2014-06-19 11:57:29 +00:00
2014-12-13 22:06:14 +00:00
opline = zend_emit_op_tmp ( result , ZEND_FETCH_CONSTANT , NULL , & const_node ) ;
2014-06-19 11:57:29 +00:00
2014-12-13 22:06:14 +00:00
zend_set_class_name_op1 ( opline , & class_node ) ;
2014-06-19 11:57:29 +00:00
if ( opline - > op1_type = = IS_CONST ) {
2014-12-13 22:06:14 +00:00
zend_alloc_cache_slot ( opline - > op2 . constant ) ;
2007-09-28 19:52:53 +00:00
} else {
2014-12-13 22:06:14 +00:00
zend_alloc_polymorphic_cache_slot ( opline - > op2 . constant ) ;
2007-09-28 19:52:53 +00:00
}
2014-06-19 11:57:29 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-19 11:57:29 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_resolve_class_name ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-19 11:57:29 +00:00
zend_ast * name_ast = ast - > child [ 0 ] ;
2014-08-25 19:21:16 +00:00
uint32_t fetch_type = zend_get_class_fetch_type ( zend_ast_get_str ( name_ast ) ) ;
2015-04-27 19:14:58 +00:00
zend_ensure_valid_class_fetch_type ( fetch_type ) ;
2014-06-19 11:57:29 +00:00
switch ( fetch_type ) {
case ZEND_FETCH_CLASS_SELF :
2015-05-05 17:52:03 +00:00
if ( CG ( active_class_entry ) & & zend_is_scope_known ( ) ) {
2014-11-28 12:31:53 +00:00
result - > op_type = IS_CONST ;
ZVAL_STR_COPY ( & result - > u . constant , CG ( active_class_entry ) - > name ) ;
2015-05-05 17:52:03 +00:00
} else {
zend_op * opline = zend_emit_op_tmp ( result , ZEND_FETCH_CLASS_NAME , NULL , NULL ) ;
opline - > extended_value = fetch_type ;
2014-11-28 12:31:53 +00:00
}
2014-06-19 11:57:29 +00:00
break ;
2015-02-10 14:43:23 +00:00
case ZEND_FETCH_CLASS_STATIC :
case ZEND_FETCH_CLASS_PARENT :
2015-04-27 19:14:58 +00:00
{
2015-05-05 16:22:20 +00:00
zend_op * opline = zend_emit_op_tmp ( result , ZEND_FETCH_CLASS_NAME , NULL , NULL ) ;
opline - > extended_value = fetch_type ;
2014-06-19 11:57:29 +00:00
}
break ;
case ZEND_FETCH_CLASS_DEFAULT :
2014-07-19 21:30:07 +00:00
result - > op_type = IS_CONST ;
2014-12-13 22:06:14 +00:00
ZVAL_STR ( & result - > u . constant , zend_resolve_class_name_ast ( name_ast ) ) ;
2014-06-19 11:57:29 +00:00
break ;
EMPTY_SWITCH_DEFAULT_CASE ( )
2007-09-28 19:52:53 +00:00
}
2014-06-19 11:57:29 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-19 11:57:29 +00:00
2015-03-24 19:47:21 +00:00
static zend_op * zend_compile_rope_add ( znode * result , uint32_t num , znode * elem_node ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2015-03-24 19:47:21 +00:00
zend_op * opline = get_next_op ( CG ( active_op_array ) ) ;
2014-06-21 18:03:29 +00:00
2015-03-24 19:47:21 +00:00
if ( num = = 0 ) {
result - > op_type = IS_TMP_VAR ;
result - > u . op . var = - 1 ;
opline - > opcode = ZEND_ROPE_INIT ;
SET_UNUSED ( opline - > op1 ) ;
} else {
opline - > opcode = ZEND_ROPE_ADD ;
SET_NODE ( opline - > op1 , result ) ;
}
SET_NODE ( opline - > op2 , elem_node ) ;
SET_NODE ( opline - > result , result ) ;
opline - > extended_value = num ;
return opline ;
}
/* }}} */
2007-09-28 19:52:53 +00:00
2015-03-24 19:47:21 +00:00
static void zend_compile_encaps_list ( znode * result , zend_ast * ast ) /* { { { */
{
uint32_t i , j ;
uint32_t rope_init_lineno = - 1 ;
zend_op * opline = NULL , * init_opline ;
znode elem_node , last_const_node ;
zend_ast_list * list = zend_ast_get_list ( ast ) ;
2014-06-21 18:03:29 +00:00
2015-03-24 19:47:21 +00:00
ZEND_ASSERT ( list - > children > 0 ) ;
2014-06-21 18:03:29 +00:00
2015-03-24 19:47:21 +00:00
j = 0 ;
last_const_node . op_type = IS_UNUSED ;
for ( i = 0 ; i < list - > children ; i + + ) {
zend_compile_expr ( & elem_node , list - > child [ i ] ) ;
2007-10-17 10:01:22 +00:00
2015-03-24 19:47:21 +00:00
if ( elem_node . op_type = = IS_CONST ) {
convert_to_string ( & elem_node . u . constant ) ;
2007-11-12 15:52:22 +00:00
2015-03-24 19:47:21 +00:00
if ( Z_STRLEN ( elem_node . u . constant ) = = 0 ) {
zval_ptr_dtor ( & elem_node . u . constant ) ;
} else if ( last_const_node . op_type = = IS_CONST ) {
concat_function ( & last_const_node . u . constant , & last_const_node . u . constant , & elem_node . u . constant ) ;
zval_ptr_dtor ( & elem_node . u . constant ) ;
2014-06-21 18:03:29 +00:00
} else {
2015-03-24 19:47:21 +00:00
last_const_node . op_type = IS_CONST ;
ZVAL_COPY_VALUE ( & last_const_node . u . constant , & elem_node . u . constant ) ;
2007-11-12 15:52:22 +00:00
}
2015-03-24 19:47:21 +00:00
continue ;
2014-06-21 18:03:29 +00:00
} else {
2015-03-24 19:47:21 +00:00
if ( j = = 0 ) {
rope_init_lineno = get_next_op_number ( CG ( active_op_array ) ) ;
}
if ( last_const_node . op_type = = IS_CONST ) {
zend_compile_rope_add ( result , j + + , & last_const_node ) ;
last_const_node . op_type = IS_UNUSED ;
}
opline = zend_compile_rope_add ( result , j + + , & elem_node ) ;
2007-10-17 10:01:22 +00:00
}
2015-03-24 19:47:21 +00:00
}
2007-11-12 15:52:22 +00:00
2015-03-24 19:47:21 +00:00
if ( j = = 0 ) {
result - > op_type = IS_CONST ;
if ( last_const_node . op_type = = IS_CONST ) {
ZVAL_COPY_VALUE ( & result - > u . constant , & last_const_node . u . constant ) ;
} else {
ZVAL_EMPTY_STRING ( & result - > u . constant ) ;
/* empty string */
}
return ;
} else if ( last_const_node . op_type = = IS_CONST ) {
opline = zend_compile_rope_add ( result , j + + , & last_const_node ) ;
}
init_opline = CG ( active_op_array ) - > opcodes + rope_init_lineno ;
if ( j = = 1 ) {
if ( opline - > op2_type = = IS_CONST ) {
GET_NODE ( result , opline - > op2 ) ;
MAKE_NOP ( opline ) ;
2014-06-21 18:03:29 +00:00
} else {
2015-03-24 19:47:21 +00:00
opline - > opcode = ZEND_CAST ;
opline - > extended_value = IS_STRING ;
opline - > op1_type = opline - > op2_type ;
opline - > op1 = opline - > op2 ;
opline - > result_type = IS_TMP_VAR ;
opline - > result . var = get_temporary_variable ( CG ( active_op_array ) ) ;
SET_UNUSED ( opline - > op2 ) ;
GET_NODE ( result , opline - > result ) ;
}
} else if ( j = = 2 ) {
opline - > opcode = ZEND_FAST_CONCAT ;
opline - > extended_value = 0 ;
opline - > op1_type = init_opline - > op2_type ;
opline - > op1 = init_opline - > op2 ;
opline - > result_type = IS_TMP_VAR ;
opline - > result . var = get_temporary_variable ( CG ( active_op_array ) ) ;
MAKE_NOP ( init_opline ) ;
GET_NODE ( result , opline - > result ) ;
} else {
uint32_t var ;
2015-07-10 00:31:52 +00:00
zend_brk_cont_element * info = get_next_brk_cont_element ( CG ( active_op_array ) ) ;
info - > start = rope_init_lineno ;
info - > parent = CG ( context ) . current_brk_cont ;
info - > cont = info - > brk = opline - CG ( active_op_array ) - > opcodes ;
2015-03-24 19:47:21 +00:00
init_opline - > extended_value = j ;
opline - > opcode = ZEND_ROPE_END ;
opline - > result . var = get_temporary_variable ( CG ( active_op_array ) ) ;
var = opline - > op1 . var = get_temporary_variable ( CG ( active_op_array ) ) ;
GET_NODE ( result , opline - > result ) ;
/* Allocates the necessary number of zval slots to keep the rope */
i = ( ( j * sizeof ( zend_string * ) ) + ( sizeof ( zval ) - 1 ) ) / sizeof ( zval ) ;
while ( i > 1 ) {
get_temporary_variable ( CG ( active_op_array ) ) ;
i - - ;
}
/* Update all the previous opcodes to use the same variable */
while ( opline ! = init_opline ) {
opline - - ;
if ( opline - > opcode = = ZEND_ROPE_ADD & &
opline - > result . var = = - 1 ) {
opline - > op1 . var = var ;
opline - > result . var = var ;
} else if ( opline - > opcode = = ZEND_ROPE_INIT & &
opline - > result . var = = - 1 ) {
opline - > result . var = var ;
}
2007-11-12 15:52:22 +00:00
}
2007-09-28 19:52:53 +00:00
}
2014-06-21 18:03:29 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-21 18:03:29 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_magic_const ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2015-05-05 16:22:20 +00:00
zend_op * opline ;
2014-12-13 22:06:14 +00:00
if ( zend_try_ct_eval_magic_const ( & result - > u . constant , ast ) ) {
2014-07-21 16:02:31 +00:00
result - > op_type = IS_CONST ;
return ;
2007-09-28 19:52:53 +00:00
}
2014-07-21 16:02:31 +00:00
2014-11-27 09:52:31 +00:00
ZEND_ASSERT ( ast - > attr = = T_CLASS_C & &
CG ( active_class_entry ) & &
2015-02-12 22:19:14 +00:00
( CG ( active_class_entry ) - > ce_flags & ZEND_ACC_TRAIT ) ! = 0 ) ;
2014-07-21 16:02:31 +00:00
2015-05-05 16:22:20 +00:00
opline = zend_emit_op_tmp ( result , ZEND_FETCH_CLASS_NAME , NULL , NULL ) ;
opline - > extended_value = ZEND_FETCH_CLASS_SELF ;
2014-07-16 21:10:16 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-07-16 21:10:16 +00:00
2014-08-29 05:05:58 +00:00
zend_bool zend_is_allowed_in_const_expr ( zend_ast_kind kind ) /* { { { */
{
2014-06-28 16:03:26 +00:00
return kind = = ZEND_AST_ZVAL | | kind = = ZEND_AST_BINARY_OP
2014-06-26 20:02:54 +00:00
| | kind = = ZEND_AST_GREATER | | kind = = ZEND_AST_GREATER_EQUAL
2014-06-26 14:03:15 +00:00
| | kind = = ZEND_AST_AND | | kind = = ZEND_AST_OR
2014-07-27 20:26:06 +00:00
| | kind = = ZEND_AST_UNARY_OP
2014-06-26 14:03:15 +00:00
| | kind = = ZEND_AST_UNARY_PLUS | | kind = = ZEND_AST_UNARY_MINUS
2014-08-16 20:08:02 +00:00
| | kind = = ZEND_AST_CONDITIONAL | | kind = = ZEND_AST_DIM
2014-06-26 14:35:30 +00:00
| | kind = = ZEND_AST_ARRAY | | kind = = ZEND_AST_ARRAY_ELEM
2014-06-26 19:44:46 +00:00
| | kind = = ZEND_AST_CONST | | kind = = ZEND_AST_CLASS_CONST
2015-05-25 20:58:30 +00:00
| | kind = = ZEND_AST_MAGIC_CONST ;
2014-06-26 14:35:30 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2014-06-26 14:35:30 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_const_expr_class_const ( zend_ast * * ast_ptr ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-26 14:35:30 +00:00
zend_ast * ast = * ast_ptr ;
zend_ast * class_ast = ast - > child [ 0 ] ;
zend_ast * const_ast = ast - > child [ 1 ] ;
2014-09-22 22:40:17 +00:00
zend_string * class_name ;
2014-07-28 13:16:35 +00:00
zend_string * const_name = zend_ast_get_str ( const_ast ) ;
2014-06-26 14:35:30 +00:00
zval result ;
int fetch_type ;
2014-06-28 16:03:26 +00:00
if ( class_ast - > kind ! = ZEND_AST_ZVAL ) {
2014-06-26 14:35:30 +00:00
zend_error_noreturn ( E_COMPILE_ERROR ,
" Dynamic class names are not allowed in compile-time class constant references " ) ;
2007-09-28 19:52:53 +00:00
}
2015-05-25 20:58:30 +00:00
if ( zend_try_compile_const_expr_resolve_class_name ( & result , class_ast , const_ast , 1 ) ) {
* ast_ptr = zend_ast_create_zval ( & result ) ;
return ;
}
2014-09-22 22:40:17 +00:00
class_name = zend_ast_get_str ( class_ast ) ;
2014-07-28 13:39:43 +00:00
fetch_type = zend_get_class_fetch_type ( class_name ) ;
2013-07-16 18:39:33 +00:00
2014-06-26 14:35:30 +00:00
if ( ZEND_FETCH_CLASS_STATIC = = fetch_type ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
" \" static:: \" is not allowed in compile-time constants " ) ;
2014-07-19 21:30:07 +00:00
}
2015-01-03 09:22:58 +00:00
2014-07-19 21:30:07 +00:00
if ( ZEND_FETCH_CLASS_DEFAULT = = fetch_type ) {
2014-12-13 22:06:14 +00:00
class_name = zend_resolve_class_name_ast ( class_ast ) ;
2013-07-16 18:39:33 +00:00
} else {
2014-08-25 19:21:16 +00:00
zend_string_addref ( class_name ) ;
2013-07-16 18:39:33 +00:00
}
2014-07-19 21:30:07 +00:00
Z_STR ( result ) = zend_concat3 (
2015-06-30 10:59:27 +00:00
ZSTR_VAL ( class_name ) , ZSTR_LEN ( class_name ) , " :: " , 2 , ZSTR_VAL ( const_name ) , ZSTR_LEN ( const_name ) ) ;
2014-06-26 14:35:30 +00:00
Z_TYPE_INFO ( result ) = IS_CONSTANT_EX ;
Z_CONST_FLAGS ( result ) = fetch_type ;
2013-07-16 18:39:33 +00:00
2014-06-26 14:35:30 +00:00
zend_ast_destroy ( ast ) ;
2014-08-25 19:21:16 +00:00
zend_string_release ( class_name ) ;
2013-08-24 21:53:43 +00:00
2014-06-28 16:03:26 +00:00
* ast_ptr = zend_ast_create_zval ( & result ) ;
2014-06-26 14:03:15 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2013-08-24 21:53:43 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_const_expr_const ( zend_ast * * ast_ptr ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-26 14:56:50 +00:00
zend_ast * ast = * ast_ptr ;
2014-06-28 20:27:06 +00:00
zend_ast * name_ast = ast - > child [ 0 ] ;
2014-09-23 18:21:28 +00:00
zend_string * orig_name = zend_ast_get_str ( name_ast ) ;
2014-07-22 11:25:47 +00:00
zend_bool is_fully_qualified ;
2014-06-26 14:56:50 +00:00
2014-09-23 18:21:28 +00:00
zval result , resolved_name ;
2014-09-28 21:17:29 +00:00
ZVAL_STR ( & resolved_name , zend_resolve_const_name (
2014-12-13 22:06:14 +00:00
orig_name , name_ast - > attr , & is_fully_qualified ) ) ;
2014-06-26 14:56:50 +00:00
2014-12-13 22:06:14 +00:00
if ( zend_try_ct_eval_const ( & result , Z_STR ( resolved_name ) , is_fully_qualified ) ) {
2014-09-28 21:17:29 +00:00
zend_string_release ( Z_STR ( resolved_name ) ) ;
2014-06-26 14:56:50 +00:00
zend_ast_destroy ( ast ) ;
2014-09-23 18:21:28 +00:00
* ast_ptr = zend_ast_create_zval ( & result ) ;
2014-06-26 14:56:50 +00:00
return ;
}
2014-06-28 20:27:06 +00:00
Z_TYPE_INFO ( resolved_name ) = IS_CONSTANT_EX ;
if ( ! is_fully_qualified ) {
Z_CONST_FLAGS ( resolved_name ) = IS_CONSTANT_UNQUALIFIED ;
2014-06-26 14:56:50 +00:00
}
zend_ast_destroy ( ast ) ;
2014-06-28 20:27:06 +00:00
* ast_ptr = zend_ast_create_zval ( & resolved_name ) ;
2014-06-26 14:56:50 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2013-08-24 21:53:43 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_const_expr_magic_const ( zend_ast * * ast_ptr ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-21 16:21:13 +00:00
zend_ast * ast = * ast_ptr ;
2013-11-09 02:37:38 +00:00
2014-07-21 16:21:13 +00:00
/* Other cases already resolved by constant folding */
2014-11-27 09:52:31 +00:00
ZEND_ASSERT ( ast - > attr = = T_CLASS_C & &
CG ( active_class_entry ) & &
2015-02-12 22:19:14 +00:00
( CG ( active_class_entry ) - > ce_flags & ZEND_ACC_TRAIT ) ! = 0 ) ;
2013-11-09 02:37:38 +00:00
2014-07-21 16:21:13 +00:00
{
zval const_zv ;
2015-03-18 12:31:29 +00:00
Z_STR ( const_zv ) = zend_string_init ( " __CLASS__ " , sizeof ( " __CLASS__ " ) - 1 , 0 ) ;
Z_TYPE_INFO ( const_zv ) = IS_CONSTANT_EX | ( IS_CONSTANT_CLASS < < Z_CONST_FLAGS_SHIFT ) ;
2013-08-24 21:53:43 +00:00
2014-07-21 16:21:13 +00:00
zend_ast_destroy ( ast ) ;
* ast_ptr = zend_ast_create_zval ( & const_zv ) ;
2013-07-16 18:39:33 +00:00
}
}
2014-08-29 05:05:58 +00:00
/* }}} */
2013-07-16 18:39:33 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_const_expr ( zend_ast * * ast_ptr ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-26 14:03:15 +00:00
zend_ast * ast = * ast_ptr ;
2014-06-28 16:03:26 +00:00
if ( ast = = NULL | | ast - > kind = = ZEND_AST_ZVAL ) {
2014-06-26 14:03:15 +00:00
return ;
2013-07-23 18:21:48 +00:00
}
2014-06-26 14:03:15 +00:00
if ( ! zend_is_allowed_in_const_expr ( ast - > kind ) ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Constant expression contains invalid operations " ) ;
2013-07-23 18:21:48 +00:00
}
2014-06-26 14:35:30 +00:00
switch ( ast - > kind ) {
case ZEND_AST_CLASS_CONST :
2014-12-13 22:06:14 +00:00
zend_compile_const_expr_class_const ( ast_ptr ) ;
2014-06-26 14:35:30 +00:00
break ;
2014-06-26 14:56:50 +00:00
case ZEND_AST_CONST :
2014-12-13 22:06:14 +00:00
zend_compile_const_expr_const ( ast_ptr ) ;
2014-06-26 14:56:50 +00:00
break ;
2014-07-21 16:21:13 +00:00
case ZEND_AST_MAGIC_CONST :
2014-12-13 22:06:14 +00:00
zend_compile_const_expr_magic_const ( ast_ptr ) ;
2014-07-21 16:21:13 +00:00
break ;
2014-07-30 15:29:59 +00:00
default :
2014-12-13 22:06:14 +00:00
zend_ast_apply ( ast , zend_compile_const_expr ) ;
2014-07-30 15:29:59 +00:00
break ;
2014-06-26 14:35:30 +00:00
}
2013-07-23 18:21:48 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2013-07-23 18:21:48 +00:00
2014-12-13 22:06:14 +00:00
void zend_const_expr_to_zval ( zval * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-30 15:44:26 +00:00
zend_ast * orig_ast = ast ;
2014-12-13 22:06:14 +00:00
zend_eval_const_expr ( & ast ) ;
zend_compile_const_expr ( & ast ) ;
2014-07-30 15:44:26 +00:00
if ( ast - > kind = = ZEND_AST_ZVAL ) {
ZVAL_COPY_VALUE ( result , zend_ast_get_zval ( ast ) ) ;
2007-09-28 19:52:53 +00:00
2014-07-30 15:44:26 +00:00
/* Kill this branch of the original AST, as it was already destroyed.
* It would be nice to find a better solution to this problem in the
* future . */
orig_ast - > kind = 0 ;
} else {
ZVAL_NEW_AST ( result , zend_ast_copy ( ast ) ) ;
2007-09-28 19:52:53 +00:00
}
2014-07-30 15:44:26 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2007-09-28 19:52:53 +00:00
2014-07-22 11:02:51 +00:00
/* Same as compile_stmt, but with early binding */
2014-12-13 22:06:14 +00:00
void zend_compile_top_stmt ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-22 11:02:51 +00:00
if ( ! ast ) {
return ;
2007-09-28 19:52:53 +00:00
}
2014-07-22 11:02:51 +00:00
if ( ast - > kind = = ZEND_AST_STMT_LIST ) {
2014-07-27 20:26:06 +00:00
zend_ast_list * list = zend_ast_get_list ( ast ) ;
2014-08-25 19:21:16 +00:00
uint32_t i ;
2014-07-27 20:26:06 +00:00
for ( i = 0 ; i < list - > children ; + + i ) {
2014-12-13 22:06:14 +00:00
zend_compile_top_stmt ( list - > child [ i ] ) ;
2013-08-24 22:05:55 +00:00
}
2014-07-22 11:02:51 +00:00
return ;
2013-08-24 22:05:55 +00:00
}
2014-12-13 22:06:14 +00:00
zend_compile_stmt ( ast ) ;
2007-09-28 19:52:53 +00:00
2014-07-22 13:50:23 +00:00
if ( ast - > kind ! = ZEND_AST_NAMESPACE & & ast - > kind ! = ZEND_AST_HALT_COMPILER ) {
2014-12-13 22:06:14 +00:00
zend_verify_namespace ( ) ;
2014-07-22 12:08:52 +00:00
}
2014-07-22 11:02:51 +00:00
if ( ast - > kind = = ZEND_AST_FUNC_DECL | | ast - > kind = = ZEND_AST_CLASS ) {
2014-07-26 16:36:57 +00:00
CG ( zend_lineno ) = ( ( zend_ast_decl * ) ast ) - > end_lineno ;
2014-12-13 22:06:14 +00:00
zend_do_early_binding ( ) ;
2008-11-25 09:56:32 +00:00
}
}
2014-08-29 05:05:58 +00:00
/* }}} */
2008-11-25 09:56:32 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_stmt ( zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-09 21:39:21 +00:00
if ( ! ast ) {
return ;
2007-09-28 19:52:53 +00:00
}
2014-07-09 21:39:21 +00:00
2014-07-12 15:10:10 +00:00
CG ( zend_lineno ) = ast - > lineno ;
2014-07-12 12:03:42 +00:00
2015-07-22 11:12:54 +00:00
if ( ( CG ( compiler_options ) & ZEND_COMPILE_EXTENDED_INFO ) & & ! zend_is_unticked_stmt ( ast ) ) {
zend_do_extended_info ( ) ;
}
2014-06-07 11:06:53 +00:00
switch ( ast - > kind ) {
2014-07-09 21:39:21 +00:00
case ZEND_AST_STMT_LIST :
2014-12-13 22:06:14 +00:00
zend_compile_stmt_list ( ast ) ;
2014-07-09 22:00:48 +00:00
break ;
2014-06-07 11:06:53 +00:00
case ZEND_AST_GLOBAL :
2014-12-13 22:06:14 +00:00
zend_compile_global_var ( ast ) ;
2014-07-09 22:00:48 +00:00
break ;
2014-07-12 15:00:53 +00:00
case ZEND_AST_STATIC :
2014-12-13 22:06:14 +00:00
zend_compile_static_var ( ast ) ;
2014-07-12 15:00:53 +00:00
break ;
2014-06-07 11:06:53 +00:00
case ZEND_AST_UNSET :
2014-12-13 22:06:14 +00:00
zend_compile_unset ( ast ) ;
2014-07-09 22:00:48 +00:00
break ;
2014-07-07 19:06:02 +00:00
case ZEND_AST_RETURN :
2014-12-13 22:06:14 +00:00
zend_compile_return ( ast ) ;
2014-07-09 22:00:48 +00:00
break ;
2014-07-27 20:26:06 +00:00
case ZEND_AST_ECHO :
2014-12-13 22:06:14 +00:00
zend_compile_echo ( ast ) ;
2014-07-09 22:00:48 +00:00
break ;
2014-07-27 20:26:06 +00:00
case ZEND_AST_THROW :
2014-12-13 22:06:14 +00:00
zend_compile_throw ( ast ) ;
2014-07-09 22:00:48 +00:00
break ;
2014-07-27 20:26:06 +00:00
case ZEND_AST_BREAK :
case ZEND_AST_CONTINUE :
2014-12-13 22:06:14 +00:00
zend_compile_break_continue ( ast ) ;
2014-07-09 22:00:48 +00:00
break ;
2014-07-27 20:26:06 +00:00
case ZEND_AST_GOTO :
2014-12-13 22:06:14 +00:00
zend_compile_goto ( ast ) ;
2014-07-09 22:00:48 +00:00
break ;
2014-07-09 21:46:22 +00:00
case ZEND_AST_LABEL :
2014-12-13 22:06:14 +00:00
zend_compile_label ( ast ) ;
2014-07-09 22:00:48 +00:00
break ;
2014-07-10 12:35:59 +00:00
case ZEND_AST_WHILE :
2014-12-13 22:06:14 +00:00
zend_compile_while ( ast ) ;
2014-07-10 12:35:59 +00:00
break ;
2014-07-10 12:46:22 +00:00
case ZEND_AST_DO_WHILE :
2014-12-13 22:06:14 +00:00
zend_compile_do_while ( ast ) ;
2014-07-10 12:46:22 +00:00
break ;
2014-07-10 13:51:47 +00:00
case ZEND_AST_FOR :
2014-12-13 22:06:14 +00:00
zend_compile_for ( ast ) ;
2014-07-10 13:51:47 +00:00
break ;
2014-07-11 10:16:21 +00:00
case ZEND_AST_FOREACH :
2014-12-13 22:06:14 +00:00
zend_compile_foreach ( ast ) ;
2014-07-11 10:16:21 +00:00
break ;
2014-07-10 14:38:04 +00:00
case ZEND_AST_IF :
2014-12-13 22:06:14 +00:00
zend_compile_if ( ast ) ;
2014-07-10 14:38:04 +00:00
break ;
2014-07-11 13:31:47 +00:00
case ZEND_AST_SWITCH :
2014-12-13 22:06:14 +00:00
zend_compile_switch ( ast ) ;
2014-07-11 13:31:47 +00:00
break ;
2014-07-12 11:50:58 +00:00
case ZEND_AST_TRY :
2014-12-13 22:06:14 +00:00
zend_compile_try ( ast ) ;
2014-07-12 11:50:58 +00:00
break ;
2014-07-22 14:11:19 +00:00
case ZEND_AST_DECLARE :
2014-12-13 22:06:14 +00:00
zend_compile_declare ( ast ) ;
2014-07-22 14:11:19 +00:00
break ;
2014-07-15 22:06:41 +00:00
case ZEND_AST_FUNC_DECL :
2014-07-19 10:52:44 +00:00
case ZEND_AST_METHOD :
2014-12-13 22:06:14 +00:00
zend_compile_func_decl ( NULL , ast ) ;
2014-07-15 22:06:41 +00:00
break ;
2014-07-19 12:54:56 +00:00
case ZEND_AST_PROP_DECL :
2014-12-13 22:06:14 +00:00
zend_compile_prop_decl ( ast ) ;
2014-07-19 12:54:56 +00:00
break ;
2014-07-19 13:13:50 +00:00
case ZEND_AST_CLASS_CONST_DECL :
2014-12-13 22:06:14 +00:00
zend_compile_class_const_decl ( ast ) ;
2014-07-19 13:13:50 +00:00
break ;
2014-07-19 20:39:01 +00:00
case ZEND_AST_USE_TRAIT :
2014-12-13 22:06:14 +00:00
zend_compile_use_trait ( ast ) ;
2014-07-19 20:39:01 +00:00
break ;
2014-07-21 14:34:45 +00:00
case ZEND_AST_CLASS :
2014-12-13 22:06:14 +00:00
zend_compile_class_decl ( ast ) ;
2014-07-21 14:34:45 +00:00
break ;
2015-03-07 20:59:20 +00:00
case ZEND_AST_GROUP_USE :
zend_compile_group_use ( ast ) ;
2015-01-19 05:22:23 +00:00
break ;
2014-07-21 20:49:31 +00:00
case ZEND_AST_USE :
2014-12-13 22:06:14 +00:00
zend_compile_use ( ast ) ;
2014-07-21 20:49:31 +00:00
break ;
2014-07-22 09:55:07 +00:00
case ZEND_AST_CONST_DECL :
2014-12-13 22:06:14 +00:00
zend_compile_const_decl ( ast ) ;
2014-07-22 09:55:07 +00:00
break ;
2014-07-22 10:45:44 +00:00
case ZEND_AST_NAMESPACE :
2014-12-13 22:06:14 +00:00
zend_compile_namespace ( ast ) ;
2014-07-22 10:45:44 +00:00
break ;
2014-07-22 12:22:59 +00:00
case ZEND_AST_HALT_COMPILER :
2014-12-13 22:06:14 +00:00
zend_compile_halt_compiler ( ast ) ;
2014-07-22 12:22:59 +00:00
break ;
2014-07-09 22:04:27 +00:00
default :
{
znode result ;
2014-12-13 22:06:14 +00:00
zend_compile_expr ( & result , ast ) ;
zend_do_free ( & result ) ;
2014-07-09 22:04:27 +00:00
}
2013-07-16 18:39:33 +00:00
}
2014-07-09 22:00:48 +00:00
2015-04-20 18:16:58 +00:00
if ( FC ( declarables ) . ticks & & ! zend_is_unticked_stmt ( ast ) ) {
2014-12-13 22:06:14 +00:00
zend_emit_tick ( ) ;
2013-07-23 18:21:48 +00:00
}
2007-09-28 19:52:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2007-09-28 19:52:53 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_expr ( znode * result , zend_ast * ast ) /* { { { */
2014-08-29 05:05:58 +00:00
{
/* CG(zend_lineno) = ast->lineno; */
2014-07-27 11:25:32 +00:00
CG ( zend_lineno ) = zend_ast_get_lineno ( ast ) ;
2008-11-25 09:56:32 +00:00
2014-06-07 11:06:53 +00:00
switch ( ast - > kind ) {
2014-06-28 16:03:26 +00:00
case ZEND_AST_ZVAL :
2014-06-07 11:06:53 +00:00
ZVAL_COPY ( & result - > u . constant , zend_ast_get_zval ( ast ) ) ;
result - > op_type = IS_CONST ;
return ;
case ZEND_AST_ZNODE :
* result = * zend_ast_get_znode ( ast ) ;
return ;
case ZEND_AST_VAR :
case ZEND_AST_DIM :
case ZEND_AST_PROP :
case ZEND_AST_STATIC_PROP :
case ZEND_AST_CALL :
case ZEND_AST_METHOD_CALL :
case ZEND_AST_STATIC_CALL :
2014-12-13 22:06:14 +00:00
zend_compile_var ( result , ast , BP_VAR_R ) ;
2014-06-07 11:06:53 +00:00
return ;
case ZEND_AST_ASSIGN :
2014-12-13 22:06:14 +00:00
zend_compile_assign ( result , ast ) ;
2014-06-07 11:06:53 +00:00
return ;
case ZEND_AST_ASSIGN_REF :
2014-12-13 22:06:14 +00:00
zend_compile_assign_ref ( result , ast ) ;
2014-06-07 11:06:53 +00:00
return ;
2014-07-27 20:26:06 +00:00
case ZEND_AST_NEW :
2014-12-13 22:06:14 +00:00
zend_compile_new ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
2014-07-27 20:26:06 +00:00
case ZEND_AST_CLONE :
2014-12-13 22:06:14 +00:00
zend_compile_clone ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
2014-06-19 11:57:29 +00:00
case ZEND_AST_ASSIGN_OP :
2014-12-13 22:06:14 +00:00
zend_compile_compound_assign ( result , ast ) ;
2014-06-07 11:06:53 +00:00
return ;
2014-06-19 11:57:29 +00:00
case ZEND_AST_BINARY_OP :
2014-12-13 22:06:14 +00:00
zend_compile_binary_op ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
case ZEND_AST_GREATER :
case ZEND_AST_GREATER_EQUAL :
2014-12-13 22:06:14 +00:00
zend_compile_greater ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
2014-07-27 20:26:06 +00:00
case ZEND_AST_UNARY_OP :
2014-12-13 22:06:14 +00:00
zend_compile_unary_op ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
2014-06-26 10:43:20 +00:00
case ZEND_AST_UNARY_PLUS :
case ZEND_AST_UNARY_MINUS :
2014-12-13 22:06:14 +00:00
zend_compile_unary_pm ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
case ZEND_AST_AND :
case ZEND_AST_OR :
2014-12-13 22:06:14 +00:00
zend_compile_short_circuiting ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
2014-07-27 20:26:06 +00:00
case ZEND_AST_POST_INC :
case ZEND_AST_POST_DEC :
2014-12-13 22:06:14 +00:00
zend_compile_post_incdec ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
2014-07-27 20:26:06 +00:00
case ZEND_AST_PRE_INC :
case ZEND_AST_PRE_DEC :
2014-12-13 22:06:14 +00:00
zend_compile_pre_incdec ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
2014-06-19 11:57:29 +00:00
case ZEND_AST_CAST :
2014-12-13 22:06:14 +00:00
zend_compile_cast ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
case ZEND_AST_CONDITIONAL :
2014-12-13 22:06:14 +00:00
zend_compile_conditional ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
2014-09-16 18:14:46 +00:00
case ZEND_AST_COALESCE :
2014-12-13 22:06:14 +00:00
zend_compile_coalesce ( result , ast ) ;
2014-09-16 18:14:46 +00:00
return ;
2014-07-27 20:26:06 +00:00
case ZEND_AST_PRINT :
2014-12-13 22:06:14 +00:00
zend_compile_print ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
2014-07-27 20:26:06 +00:00
case ZEND_AST_EXIT :
2014-12-13 22:06:14 +00:00
zend_compile_exit ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
2014-07-27 20:26:06 +00:00
case ZEND_AST_YIELD :
2014-12-13 22:06:14 +00:00
zend_compile_yield ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
2015-02-20 11:59:56 +00:00
case ZEND_AST_YIELD_FROM :
zend_compile_yield_from ( result , ast ) ;
return ;
2014-07-27 20:26:06 +00:00
case ZEND_AST_INSTANCEOF :
2014-12-13 22:06:14 +00:00
zend_compile_instanceof ( result , ast ) ;
2014-06-14 16:30:18 +00:00
return ;
2014-07-27 20:26:06 +00:00
case ZEND_AST_INCLUDE_OR_EVAL :
2014-12-13 22:06:14 +00:00
zend_compile_include_or_eval ( result , ast ) ;
2014-06-19 11:57:29 +00:00
return ;
case ZEND_AST_ISSET :
case ZEND_AST_EMPTY :
2014-12-13 22:06:14 +00:00
zend_compile_isset_or_empty ( result , ast ) ;
2014-06-19 11:57:29 +00:00
return ;
case ZEND_AST_SILENCE :
2014-12-13 22:06:14 +00:00
zend_compile_silence ( result , ast ) ;
2014-06-19 11:57:29 +00:00
return ;
case ZEND_AST_SHELL_EXEC :
2014-12-13 22:06:14 +00:00
zend_compile_shell_exec ( result , ast ) ;
2014-06-19 11:57:29 +00:00
return ;
case ZEND_AST_ARRAY :
2014-12-13 22:06:14 +00:00
zend_compile_array ( result , ast ) ;
2014-06-19 11:57:29 +00:00
return ;
case ZEND_AST_CONST :
2014-12-13 22:06:14 +00:00
zend_compile_const ( result , ast ) ;
2014-06-19 11:57:29 +00:00
return ;
case ZEND_AST_CLASS_CONST :
2014-12-13 22:06:14 +00:00
zend_compile_class_const ( result , ast ) ;
2014-06-19 11:57:29 +00:00
return ;
2014-06-21 18:03:29 +00:00
case ZEND_AST_ENCAPS_LIST :
2014-12-13 22:06:14 +00:00
zend_compile_encaps_list ( result , ast ) ;
2014-06-21 18:03:29 +00:00
return ;
2014-07-16 21:10:16 +00:00
case ZEND_AST_MAGIC_CONST :
2014-12-13 22:06:14 +00:00
zend_compile_magic_const ( result , ast ) ;
2014-07-16 21:10:16 +00:00
return ;
2014-07-18 10:58:24 +00:00
case ZEND_AST_CLOSURE :
2014-12-13 22:06:14 +00:00
zend_compile_func_decl ( result , ast ) ;
2014-07-18 10:58:24 +00:00
return ;
2014-06-07 11:06:53 +00:00
default :
ZEND_ASSERT ( 0 /* not supported */ ) ;
2013-11-06 18:21:07 +00:00
}
}
2014-08-29 05:05:58 +00:00
/* }}} */
2013-11-06 18:21:07 +00:00
2014-12-13 22:06:14 +00:00
void zend_compile_var ( znode * result , zend_ast * ast , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-06-07 11:06:53 +00:00
switch ( ast - > kind ) {
case ZEND_AST_VAR :
2015-02-02 17:44:16 +00:00
zend_compile_simple_var ( result , ast , type , 0 ) ;
2014-06-07 11:06:53 +00:00
return ;
case ZEND_AST_DIM :
2014-12-13 22:06:14 +00:00
zend_compile_dim ( result , ast , type ) ;
2014-06-07 11:06:53 +00:00
return ;
case ZEND_AST_PROP :
2014-12-13 22:06:14 +00:00
zend_compile_prop ( result , ast , type ) ;
2014-06-07 11:06:53 +00:00
return ;
case ZEND_AST_STATIC_PROP :
2015-02-02 17:44:16 +00:00
zend_compile_static_prop ( result , ast , type , 0 ) ;
2014-06-07 11:06:53 +00:00
return ;
case ZEND_AST_CALL :
2014-12-13 22:06:14 +00:00
zend_compile_call ( result , ast , type ) ;
2014-06-07 11:06:53 +00:00
return ;
case ZEND_AST_METHOD_CALL :
2014-12-13 22:06:14 +00:00
zend_compile_method_call ( result , ast , type ) ;
2014-06-07 11:06:53 +00:00
return ;
case ZEND_AST_STATIC_CALL :
2014-12-13 22:06:14 +00:00
zend_compile_static_call ( result , ast , type ) ;
2014-06-07 11:06:53 +00:00
return ;
2014-08-15 15:10:06 +00:00
case ZEND_AST_ZNODE :
* result = * zend_ast_get_znode ( ast ) ;
return ;
2014-06-07 11:06:53 +00:00
default :
2014-06-19 11:57:29 +00:00
if ( type = = BP_VAR_W | | type = = BP_VAR_REF
| | type = = BP_VAR_RW | | type = = BP_VAR_UNSET
) {
2014-09-10 13:55:26 +00:00
zend_error_noreturn ( E_COMPILE_ERROR ,
" Cannot use temporary expression in write context " ) ;
2014-06-19 11:57:29 +00:00
}
2008-02-12 00:21:15 +00:00
2014-12-13 22:06:14 +00:00
zend_compile_expr ( result , ast ) ;
2014-06-07 11:06:53 +00:00
return ;
2011-01-19 17:17:52 +00:00
}
2014-06-07 11:06:53 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2008-02-12 00:21:15 +00:00
2014-12-13 22:06:14 +00:00
void zend_delayed_compile_var ( znode * result , zend_ast * ast , uint32_t type ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-08-15 15:10:06 +00:00
zend_op * opline ;
switch ( ast - > kind ) {
2015-02-02 17:44:16 +00:00
case ZEND_AST_VAR :
zend_compile_simple_var ( result , ast , type , 1 ) ;
return ;
2014-08-15 15:10:06 +00:00
case ZEND_AST_DIM :
2014-12-13 22:06:14 +00:00
opline = zend_delayed_compile_dim ( result , ast , type ) ;
2014-08-15 15:10:06 +00:00
zend_adjust_for_fetch_type ( opline , type ) ;
return ;
case ZEND_AST_PROP :
2014-12-13 22:06:14 +00:00
opline = zend_delayed_compile_prop ( result , ast , type ) ;
2014-08-15 15:10:06 +00:00
zend_adjust_for_fetch_type ( opline , type ) ;
return ;
2015-02-02 17:44:16 +00:00
case ZEND_AST_STATIC_PROP :
zend_compile_static_prop ( result , ast , type , 1 ) ;
return ;
2014-08-15 15:10:06 +00:00
default :
2014-12-13 22:06:14 +00:00
zend_compile_var ( result , ast , type ) ;
2014-08-15 15:10:06 +00:00
return ;
2008-02-12 00:21:15 +00:00
}
2014-08-15 15:10:06 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2008-02-12 00:21:15 +00:00
2014-12-13 22:06:14 +00:00
void zend_eval_const_expr ( zend_ast * * ast_ptr ) /* { { { */
2014-08-29 05:05:58 +00:00
{
2014-07-21 16:02:31 +00:00
zend_ast * ast = * ast_ptr ;
zval result ;
2008-02-12 00:21:15 +00:00
2014-07-30 15:29:59 +00:00
if ( ! ast ) {
2014-06-23 19:30:57 +00:00
return ;
2008-02-12 00:21:15 +00:00
}
2014-06-23 19:30:57 +00:00
switch ( ast - > kind ) {
case ZEND_AST_BINARY_OP :
2014-12-13 22:06:14 +00:00
zend_eval_const_expr ( & ast - > child [ 0 ] ) ;
zend_eval_const_expr ( & ast - > child [ 1 ] ) ;
2014-07-29 21:22:23 +00:00
if ( ast - > child [ 0 ] - > kind ! = ZEND_AST_ZVAL | | ast - > child [ 1 ] - > kind ! = ZEND_AST_ZVAL ) {
return ;
}
2015-06-16 16:09:59 +00:00
if ( ! zend_try_ct_eval_binary_op ( & result , ast - > attr ,
zend_ast_get_zval ( ast - > child [ 0 ] ) , zend_ast_get_zval ( ast - > child [ 1 ] ) )
) {
return ;
2015-04-06 11:30:05 +00:00
}
2014-06-23 19:30:57 +00:00
break ;
2014-06-26 10:43:20 +00:00
case ZEND_AST_GREATER :
case ZEND_AST_GREATER_EQUAL :
2014-12-13 22:06:14 +00:00
zend_eval_const_expr ( & ast - > child [ 0 ] ) ;
zend_eval_const_expr ( & ast - > child [ 1 ] ) ;
2014-07-29 21:22:23 +00:00
if ( ast - > child [ 0 ] - > kind ! = ZEND_AST_ZVAL | | ast - > child [ 1 ] - > kind ! = ZEND_AST_ZVAL ) {
return ;
}
zend_ct_eval_greater ( & result , ast - > kind ,
2014-12-13 22:06:14 +00:00
zend_ast_get_zval ( ast - > child [ 0 ] ) , zend_ast_get_zval ( ast - > child [ 1 ] ) ) ;
2014-06-26 10:43:20 +00:00
break ;
2015-06-16 14:53:17 +00:00
case ZEND_AST_AND :
case ZEND_AST_OR :
{
int i ;
for ( i = 0 ; i < = 1 ; i + + ) {
zend_eval_const_expr ( & ast - > child [ i ] ) ;
if ( ast - > child [ i ] - > kind = = ZEND_AST_ZVAL ) {
if ( zend_is_true ( zend_ast_get_zval ( ast - > child [ i ] ) ) = = ( ast - > kind = = ZEND_AST_OR ) ) {
ZVAL_BOOL ( & result , ast - > kind = = ZEND_AST_OR ) ;
return ;
}
}
}
if ( ast - > child [ 0 ] - > kind ! = ZEND_AST_ZVAL | | ast - > child [ 1 ] - > kind ! = ZEND_AST_ZVAL ) {
return ;
}
if ( ast - > kind = = ZEND_AST_OR ) {
ZVAL_BOOL ( & result , zend_is_true ( zend_ast_get_zval ( ast - > child [ 0 ] ) ) | | zend_is_true ( zend_ast_get_zval ( ast - > child [ 1 ] ) ) ) ;
} else {
ZVAL_BOOL ( & result , zend_is_true ( zend_ast_get_zval ( ast - > child [ 0 ] ) ) & & zend_is_true ( zend_ast_get_zval ( ast - > child [ 1 ] ) ) ) ;
}
break ;
}
case ZEND_AST_UNARY_OP :
zend_eval_const_expr ( & ast - > child [ 0 ] ) ;
if ( ast - > child [ 0 ] - > kind ! = ZEND_AST_ZVAL ) {
return ;
}
zend_ct_eval_unary_op ( & result , ast - > attr , zend_ast_get_zval ( ast - > child [ 0 ] ) ) ;
break ;
2014-06-26 10:43:20 +00:00
case ZEND_AST_UNARY_PLUS :
case ZEND_AST_UNARY_MINUS :
2014-12-13 22:06:14 +00:00
zend_eval_const_expr ( & ast - > child [ 0 ] ) ;
2014-07-29 21:22:23 +00:00
if ( ast - > child [ 0 ] - > kind ! = ZEND_AST_ZVAL ) {
return ;
}
2015-06-16 14:53:17 +00:00
zend_ct_eval_unary_pm ( & result , ast - > kind , zend_ast_get_zval ( ast - > child [ 0 ] ) ) ;
break ;
case ZEND_AST_CONDITIONAL :
{
zend_ast * * child , * child_ast ;
zend_eval_const_expr ( & ast - > child [ 0 ] ) ;
if ( ast - > child [ 0 ] - > kind ! = ZEND_AST_ZVAL ) {
/* ensure everything was compile-time evaluated at least once */
if ( ast - > child [ 1 ] ) {
zend_eval_const_expr ( & ast - > child [ 1 ] ) ;
}
zend_eval_const_expr ( & ast - > child [ 2 ] ) ;
return ;
}
child = & ast - > child [ 2 - zend_is_true ( zend_ast_get_zval ( ast - > child [ 0 ] ) ) ] ;
if ( * child = = NULL ) {
child - - ;
}
child_ast = * child ;
* child = NULL ;
zend_ast_destroy ( ast ) ;
* ast_ptr = child_ast ;
zend_eval_const_expr ( ast_ptr ) ;
return ;
}
case ZEND_AST_DIM :
{
/* constant expression should be always read context ... */
zval * container , * dim ;
2015-11-13 13:01:11 +00:00
if ( ast - > child [ 1 ] = = NULL ) {
zend_error_noreturn ( E_COMPILE_ERROR , " Cannot use [] for reading " ) ;
}
2015-06-16 14:53:17 +00:00
zend_eval_const_expr ( & ast - > child [ 0 ] ) ;
zend_eval_const_expr ( & ast - > child [ 1 ] ) ;
2015-11-13 13:01:11 +00:00
if ( ast - > child [ 0 ] - > kind ! = ZEND_AST_ZVAL | | ast - > child [ 1 ] - > kind ! = ZEND_AST_ZVAL ) {
2015-06-16 14:53:17 +00:00
return ;
}
container = zend_ast_get_zval ( ast - > child [ 0 ] ) ;
dim = zend_ast_get_zval ( ast - > child [ 1 ] ) ;
if ( Z_TYPE_P ( container ) = = IS_ARRAY ) {
zval * el ;
if ( Z_TYPE_P ( dim ) = = IS_LONG ) {
el = zend_hash_index_find ( Z_ARR_P ( container ) , Z_LVAL_P ( dim ) ) ;
if ( el ) {
ZVAL_COPY ( & result , el ) ;
} else {
return ;
}
} else if ( Z_TYPE_P ( dim ) = = IS_STRING ) {
el = zend_symtable_find ( Z_ARR_P ( container ) , Z_STR_P ( dim ) ) ;
if ( el ) {
ZVAL_COPY ( & result , el ) ;
} else {
return ;
}
} else {
return ; /* warning... handle at runtime */
}
} else if ( Z_TYPE_P ( container ) = = IS_STRING ) {
zend_long offset ;
zend_uchar c ;
if ( Z_TYPE_P ( dim ) = = IS_LONG ) {
offset = Z_LVAL_P ( dim ) ;
} else if ( Z_TYPE_P ( dim ) ! = IS_STRING | | is_numeric_string ( Z_STRVAL_P ( dim ) , Z_STRLEN_P ( dim ) , & offset , NULL , 1 ) ! = IS_LONG ) {
return ;
}
2015-09-23 20:19:05 +00:00
if ( offset < 0 | | ( size_t ) offset > = Z_STRLEN_P ( container ) ) {
2015-06-16 14:53:17 +00:00
return ;
}
c = ( zend_uchar ) Z_STRVAL_P ( container ) [ offset ] ;
if ( CG ( one_char_string ) [ c ] ) {
ZVAL_INTERNED_STR ( & result , CG ( one_char_string ) [ c ] ) ;
} else {
ZVAL_NEW_STR ( & result , zend_string_init ( ( char * ) & c , 1 , 0 ) ) ;
}
} else if ( Z_TYPE_P ( container ) < = IS_FALSE ) {
ZVAL_NULL ( & result ) ;
} else {
return ;
}
2014-06-26 10:43:20 +00:00
break ;
2015-06-16 14:53:17 +00:00
}
2014-06-23 19:30:57 +00:00
case ZEND_AST_ARRAY :
2014-12-13 22:06:14 +00:00
if ( ! zend_try_ct_eval_array ( & result , ast ) ) {
2014-07-29 21:22:23 +00:00
return ;
}
2014-06-23 19:30:57 +00:00
break ;
2014-07-21 16:02:31 +00:00
case ZEND_AST_MAGIC_CONST :
2014-12-13 22:06:14 +00:00
if ( ! zend_try_ct_eval_magic_const ( & result , ast ) ) {
2014-07-29 21:22:23 +00:00
return ;
}
2014-07-21 16:02:31 +00:00
break ;
2014-09-23 18:21:28 +00:00
case ZEND_AST_CONST :
2014-09-28 21:17:29 +00:00
{
zend_ast * name_ast = ast - > child [ 0 ] ;
zend_bool is_fully_qualified ;
zend_string * resolved_name = zend_resolve_const_name (
2014-12-13 22:06:14 +00:00
zend_ast_get_str ( name_ast ) , name_ast - > attr , & is_fully_qualified ) ;
2014-09-28 21:17:29 +00:00
2014-12-13 22:06:14 +00:00
if ( ! zend_try_ct_eval_const ( & result , resolved_name , is_fully_qualified ) ) {
2014-09-28 21:17:29 +00:00
zend_string_release ( resolved_name ) ;
2014-08-26 09:06:19 +00:00
return ;
}
2014-09-28 21:17:29 +00:00
zend_string_release ( resolved_name ) ;
2014-09-23 18:21:28 +00:00
break ;
2014-09-28 21:17:29 +00:00
}
2015-02-10 14:43:23 +00:00
case ZEND_AST_CLASS_CONST :
{
zend_ast * class_ast = ast - > child [ 0 ] ;
zend_ast * name_ast = ast - > child [ 1 ] ;
zend_string * resolved_name ;
2015-06-03 21:59:59 +00:00
if ( zend_try_compile_const_expr_resolve_class_name ( & result , class_ast , name_ast , 0 ) ) {
if ( Z_TYPE ( result ) = = IS_NULL ) {
2015-11-23 10:31:56 +00:00
if ( zend_get_class_fetch_type ( zend_ast_get_str ( class_ast ) ) = = ZEND_FETCH_CLASS_SELF ) {
zend_ast_destroy ( ast ) ;
* ast_ptr = zend_ast_create_ex ( ZEND_AST_MAGIC_CONST , T_CLASS_C ) ;
}
2015-06-03 21:59:59 +00:00
return ;
}
2015-11-23 10:31:56 +00:00
break ;
2015-05-25 20:58:30 +00:00
}
2015-02-10 14:43:23 +00:00
zend_eval_const_expr ( & class_ast ) ;
zend_eval_const_expr ( & name_ast ) ;
2015-05-25 20:58:30 +00:00
if ( name_ast - > kind = = ZEND_AST_ZVAL & & zend_string_equals_literal_ci ( zend_ast_get_str ( name_ast ) , " class " ) ) {
zend_error_noreturn ( E_COMPILE_ERROR ,
" Dynamic class names are not allowed in compile-time ::class fetch " ) ;
}
2015-02-10 14:43:23 +00:00
if ( class_ast - > kind ! = ZEND_AST_ZVAL | | name_ast - > kind ! = ZEND_AST_ZVAL ) {
return ;
}
resolved_name = zend_resolve_class_name_ast ( class_ast ) ;
if ( ! zend_try_ct_eval_class_const ( & result , resolved_name , zend_ast_get_str ( name_ast ) ) ) {
zend_string_release ( resolved_name ) ;
return ;
}
zend_string_release ( resolved_name ) ;
break ;
}
2014-07-29 21:22:23 +00:00
default :
return ;
2008-02-12 00:21:15 +00:00
}
2014-07-29 21:22:23 +00:00
zend_ast_destroy ( ast ) ;
* ast_ptr = zend_ast_create_zval ( & result ) ;
2008-02-12 00:21:15 +00:00
}
2014-08-29 05:05:58 +00:00
/* }}} */
2008-02-12 01:17:48 +00:00
2003-02-01 01:49:15 +00:00
/*
* Local variables :
* tab - width : 4
* c - basic - offset : 4
* indent - tabs - mode : t
* End :
*/