* Convert to a argv[] * @return zval[] */

* Retrieve the child * @return Php::Value */

* Apply a callback to each registered class * * The callback will be called with the name of the namespace, and * a reference to the registered

* Retrieve the value of a constant by its name * @param name Name of the constant * @return Value Actual constant value */

* Apply a callback to each registered constant * * The callback will be called with the name of the namespace, and * a reference to the registe

* Check whether a handle is already persistently opened * @param handle * @return bool */

* Helper function converts an object to a string * @return std::string */

* Decrement position (pre-decrement) * @return bool */

* Check whether this object is derived from a certain class * * If you set the parameter 'allowString' to true, and the Value object * holds a s

* Destruct the object */

* Implementation of the dl() function - activate a different PHP extension * * If you open an extension persistently, the static variables inside

* Filling ini_entries * @param zend_ini_entry *ini_entry, int module_number * @param int module_number */

export the "get_module" function that will be called by the Zend engine

* Include a file only once * @param filename * @return Value */

* Increment position (pre-increment) * @return bool */

* Check whether this object is an instance of a certain class * * If you set the parameter 'allowString' to true, and the Value object * holds a

* Are we an array? This will also check if we're a reference to an array * @return bool */

* Convert the object to a map with string index and Php::Value value * @return std::map */

* my_catch_exception_function() * Catches the exception thrown by the PHP callback function. * @param Php::Parameters */

* my_no_parameters_function() * @return Php::Value */

* my_return_value_function() * @return Php::Value */

* my_throw_exception_function() * Throws an exception which should be caught by PHP. */

* my_with_defined_parameters_reference_function() * @param Php::Parameters the given parameters */

* my_with_defined_object_parameters_function() * The use of objects is not yet implemented. * @param Php::Parameters the given parameters *

* my_with_defined_parameters_function() * @param Php::Parameters the given parameters * @return Php::Value Param[0] and Param[1] ad

* This functions receives a reference to a variable. When the variable is altered, * so is the value in the php script. * my_with_defined_paramet

* my_with_undefined_parameters_function() * @param Php:Parameters the given parameters */

* Register a callback that is called to cleanup things after a pageview/request * * The callback will be called after _each_ request, so

* Register a callback that is called at the beginning of each pageview/request * * You can register a callback if you want to initialize

* Register a function to be called when the PHP engine is going to stop * * The callback will be called right before the process is going

* Register a function to be called when the PHP engine is ready * * The callback will be called after all extensions are loaded, and all

* Comparison operators< for hardcoded Value * @param value * @return bool */

* process_globals() * * This function reads and modifies global variables */

* Retrieve the refcount * @return int */

* Rewind the iterator back to the start * @param iter */

* Method that is called to serialize an object * @param object The object to be serialized * @param buffer Buffer in which to store t

* Function that is called when the extension shuts down * @param module_number * @return bool */

* Retrieve number of characters in the string * * @return Number of characters, not including the terminating null */

* Start the module * @return bool */

* Method that is called to unserialize an object * @param object The object to be unserialized * @param entry The class entry to whi

* The extension version * @return const char * */

* Destructor */

* Constructor * @param value The original object */

* Constructor * @param name * @param value * @param flags */

* Constructor * * @param callback The callback to invoke * @param name Function or method name * @param arguments

* Constructor */

* Constructor and destructor */

* Protected constructor * @param classname Class name * @param flags Class flags */

* Constructor * @param name Class name * @param type Class type */

* Constructor * @param options */

* Constructor * @param name Constant name * @param value Constant value */

* Constructor * @param name * @param value */

* Constructor * @param data Data that will be freed on destruction */

* Default constructor */

* No trivial constructor */

* Constructor that defines a number of functions right away * @param name Extension name * @param version Extension version string

* Constructor * @param data Extension object created by the extension programmer */

* No copy'ing and no moving */

* Constructor * @param data Pointer to the extension object created by the extension programmer * @param name Name of the extensi

* Constructor * @param path */

* Constructor * * The constructor receives a filename as parameter. It uses the normal * PHP include path resolve algorithms to find the locatio

* Constructor * @param name * @param value * @param flags */

* Constructor * @param function The function to be wrapped */

* Constructor * @param function The function to wrap */

* Move constructor * @param global */

* Constructor * @param hashtable The hashtable to iterate over * @param first Should it start on the first position?

* Constructors for string values * * @param name Name of the php.ini variable * @param value Default value * @p

* Constructor * @param name */

* Constructor * @param zval The object that is being iterated * @param iterator The iterator that is implemented by the exten

* Constructor * @param name the original name */

* Constructor */

* Constructor * @param name Name of the member * @param flags Flag access to a class member (public, protected etc) *

* Constructor * * @param name Method name * @param callback Callback to invoke * @param flags A

* Constructor * * A module can be loaded persistently. This means that the variables in * the module will keep in scope for as long

* Constructor * * @param name Function name * @param function The native C function */

* Constructor */

* Constructor * @param name * @param flags */

* Constructor * @param name * @param value * @param flags */

* Constructor to create a new instance of a builtin class * * @param name Name of the class to instantiate * @param base The C++

* Constructor * * This will create a new object in the Zend engine. * * @param entry Zend class entry * @param ha

* Constructor * @param opcodes */

* Constructor * @param this_ptr Pointer to the object * @param argc Number of arguments */

* Constructor */

* Constructor * @param getter * @param setter */

* Protected constructor (only ThrowableException and ThrowableError should be extended) */

* Constructor * @param object */

* Constructor * @param object */

* Constructor * @param name name of the script * @param script actual PHP code * @param size length of the string */

* Constructor */

* Constructor * @param value value to be wrapped * @throws std::runtime_error */