Struct _zend_compiler_globals 

#[repr(C)]
pub struct _zend_compiler_globals {

    pub loop_var_stack: zend_stack,
    pub active_class_entry: *mut zend_class_entry,
    pub compiled_filename: *mut zend_string,
    pub zend_lineno: c_int,
    pub active_op_array: *mut zend_op_array,
    pub function_table: *mut HashTable,
    pub class_table: *mut HashTable,
    pub auto_globals: *mut HashTable,
    pub parse_error: u8,
    pub in_compilation: bool,
    pub short_tags: bool,
    pub unclean_shutdown: bool,
    pub ini_parser_unbuffered_errors: bool,
    pub open_files: zend_llist,
    pub ini_parser_param: *mut _zend_ini_parser_param,
    pub skip_shebang: bool,
    pub increment_lineno: bool,
    pub variable_width_locale: bool,
    pub ascii_compatible_locale: bool,
    pub doc_comment: *mut zend_string,
    pub extra_fn_flags: u32,
    pub compiler_options: u32,
    pub context: zend_oparray_context,
    pub file_context: zend_file_context,
    pub arena: *mut zend_arena,
    pub interned_strings: HashTable,
    pub script_encoding_list: *mut *const zend_encoding,
    pub script_encoding_list_size: usize,
    pub multibyte: bool,
    pub detect_unicode: bool,
    pub encoding_declared: bool,
    pub ast: *mut zend_ast,
    pub ast_arena: *mut zend_arena,
    pub delayed_oplines_stack: zend_stack,
    pub memoized_exprs: *mut HashTable,
    pub memoize_mode: zend_memoize_mode,
    pub map_ptr_real_base: *mut c_void,
    pub map_ptr_base: *mut c_void,
    pub map_ptr_size: usize,
    pub map_ptr_last: usize,
    pub delayed_variance_obligations: *mut HashTable,
    pub delayed_autoloads: *mut HashTable,
    pub unlinked_uses: *mut HashTable,
    pub current_linking_class: *mut zend_class_entry,
    pub rtd_key_counter: u32,
    pub internal_run_time_cache: *mut c_void,
    pub internal_run_time_cache_size: u32,
    pub short_circuiting_opnums: zend_stack,
}

Fields

loop_var_stack: zend_stack

active_class_entry: *mut zend_class_entry

compiled_filename: *mut zend_string

zend_lineno: c_int

active_op_array: *mut zend_op_array

function_table: *mut HashTable

class_table: *mut HashTable

auto_globals: *mut HashTable

parse_error: u8

in_compilation: bool

short_tags: bool

unclean_shutdown: bool

ini_parser_unbuffered_errors: bool

open_files: zend_llist

ini_parser_param: *mut _zend_ini_parser_param

skip_shebang: bool

increment_lineno: bool

variable_width_locale: bool

ascii_compatible_locale: bool

doc_comment: *mut zend_string

extra_fn_flags: u32

compiler_options: u32

context: zend_oparray_context

file_context: zend_file_context

arena: *mut zend_arena

interned_strings: HashTable

script_encoding_list: *mut *const zend_encoding

script_encoding_list_size: usize

multibyte: bool

detect_unicode: bool

encoding_declared: bool

ast: *mut zend_ast

ast_arena: *mut zend_arena

delayed_oplines_stack: zend_stack

memoized_exprs: *mut HashTable

memoize_mode: zend_memoize_mode

map_ptr_real_base: *mut c_void

map_ptr_base: *mut c_void

map_ptr_size: usize

map_ptr_last: usize

delayed_variance_obligations: *mut HashTable

delayed_autoloads: *mut HashTable

unlinked_uses: *mut HashTable

current_linking_class: *mut zend_class_entry

rtd_key_counter: u32

internal_run_time_cache: *mut c_void

internal_run_time_cache_size: u32

short_circuiting_opnums: zend_stack

Implementations

impl _zend_compiler_globals

pub fn get() -> GlobalReadGuard<Self>

Returns a reference to the PHP compiler globals.

The compiler globals are guarded by a RwLock. There can be multiple immutable references at one time but only ever one mutable reference. Attempting to retrieve the globals while already holding the global guard will lead to a deadlock. Dropping the globals guard will release the lock.

Panics

• If static executor globals are not set

pub fn get_mut() -> GlobalWriteGuard<Self>

Returns a mutable reference to the PHP compiler globals.

The compiler globals are guarded by a RwLock. There can be multiple immutable references at one time but only ever one mutable reference. Attempting to retrieve the globals while already holding the global guard will lead to a deadlock. Dropping the globals guard will release the lock.

Panics

• If static compiler globals are not set