}
/* }}} */
-static const zend_function_entry curlfile_funcs[] = {
- PHP_ME(CURLFile, __construct, arginfo_class_CURLFile___construct, ZEND_ACC_PUBLIC)
- PHP_ME(CURLFile, getFilename, arginfo_class_CURLFile_getFilename, ZEND_ACC_PUBLIC)
- PHP_ME(CURLFile, getMimeType, arginfo_class_CURLFile_getMimeType, ZEND_ACC_PUBLIC)
- PHP_ME(CURLFile, setMimeType, arginfo_class_CURLFile_setMimeType, ZEND_ACC_PUBLIC)
- PHP_ME(CURLFile, getPostFilename, arginfo_class_CURLFile_getPostFilename, ZEND_ACC_PUBLIC)
- PHP_ME(CURLFile, setPostFilename, arginfo_class_CURLFile_setPostFilename, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
void curlfile_register_class(void)
{
zend_class_entry ce;
- INIT_CLASS_ENTRY( ce, "CURLFile", curlfile_funcs );
+ INIT_CLASS_ENTRY( ce, "CURLFile", class_CURLFile_methods );
curl_CURLFile_class = zend_register_internal_class(&ce);
curl_CURLFile_class->serialize = zend_class_serialize_deny;
curl_CURLFile_class->unserialize = zend_class_unserialize_deny;
<?php
+/** @generate-function-entries */
+
class CURLFile
{
public function __construct(
ZEND_BEGIN_ARG_INFO_EX(arginfo_class_CURLFile_setPostFilename, 0, 0, 1)
ZEND_ARG_TYPE_INFO(0, postname, IS_STRING, 0)
ZEND_END_ARG_INFO()
+
+
+ZEND_METHOD(CURLFile, __construct);
+ZEND_METHOD(CURLFile, getFilename);
+ZEND_METHOD(CURLFile, getMimeType);
+ZEND_METHOD(CURLFile, getPostFilename);
+ZEND_METHOD(CURLFile, setMimeType);
+ZEND_METHOD(CURLFile, setPostFilename);
+
+
+static const zend_function_entry class_CURLFile_methods[] = {
+ ZEND_ME(CURLFile, __construct, arginfo_class_CURLFile___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(CURLFile, getFilename, arginfo_class_CURLFile_getFilename, ZEND_ACC_PUBLIC)
+ ZEND_ME(CURLFile, getMimeType, arginfo_class_CURLFile_getMimeType, ZEND_ACC_PUBLIC)
+ ZEND_ME(CURLFile, getPostFilename, arginfo_class_CURLFile_getPostFilename, ZEND_ACC_PUBLIC)
+ ZEND_ME(CURLFile, setMimeType, arginfo_class_CURLFile_setMimeType, ZEND_ACC_PUBLIC)
+ ZEND_ME(CURLFile, setPostFilename, arginfo_class_CURLFile_setPostFilename, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
}
/* }}} */
-static const zend_function_entry zend_ffi_functions[] = {
- ZEND_ME(FFI, cdef, arginfo_class_FFI_cdef, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, load, arginfo_class_FFI_load, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, scope, arginfo_class_FFI_scope, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, new, arginfo_class_FFI_new, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, free, arginfo_class_FFI_free, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, cast, arginfo_class_FFI_cast, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, type, arginfo_class_FFI_type, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, typeof, arginfo_class_FFI_typeof, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, arrayType, arginfo_class_FFI_arrayType, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, addr, arginfo_class_FFI_addr, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, sizeof, arginfo_class_FFI_sizeof, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, alignof, arginfo_class_FFI_alignof, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, memcpy, arginfo_class_FFI_memcpy, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, memcmp, arginfo_class_FFI_memcmp, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, memset, arginfo_class_FFI_memset, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, string, arginfo_class_FFI_string, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_ME(FFI, isNull, arginfo_class_FFI_isNull, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- ZEND_FE_END
-};
-
static char *zend_ffi_parse_directives(const char *filename, char *code_pos, char **scope_name, char **lib, zend_bool preload) /* {{{ */
{
char *p;
zend_ffi_parser_exception_ce = zend_register_internal_class_ex(&ce, zend_ffi_exception_ce);
zend_ffi_parser_exception_ce->ce_flags |= ZEND_ACC_FINAL;
- INIT_CLASS_ENTRY(ce, "FFI", zend_ffi_functions);
+ INIT_CLASS_ENTRY(ce, "FFI", class_FFI_methods);
zend_ffi_ce = zend_register_internal_class(&ce);
zend_ffi_ce->ce_flags |= ZEND_ACC_FINAL;
zend_ffi_ce->create_object = zend_ffi_new;
<?php
+/** @generate-function-entries */
+
final class FFI
{
public static function cdef(string $code = UNKNOWN, string $lib = UNKNOWN): ?FFI {}
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_FFI_isNull, 0, 1, _IS_BOOL, 0)
ZEND_ARG_OBJ_INFO(ZEND_SEND_PREFER_REF, ptr, FFI\\CData, 0)
ZEND_END_ARG_INFO()
+
+
+ZEND_METHOD(FFI, cdef);
+ZEND_METHOD(FFI, load);
+ZEND_METHOD(FFI, scope);
+ZEND_METHOD(FFI, new);
+ZEND_METHOD(FFI, free);
+ZEND_METHOD(FFI, cast);
+ZEND_METHOD(FFI, type);
+ZEND_METHOD(FFI, typeof);
+ZEND_METHOD(FFI, arrayType);
+ZEND_METHOD(FFI, addr);
+ZEND_METHOD(FFI, sizeof);
+ZEND_METHOD(FFI, alignof);
+ZEND_METHOD(FFI, memcpy);
+ZEND_METHOD(FFI, memcmp);
+ZEND_METHOD(FFI, memset);
+ZEND_METHOD(FFI, string);
+ZEND_METHOD(FFI, isNull);
+
+
+static const zend_function_entry class_FFI_methods[] = {
+ ZEND_ME(FFI, cdef, arginfo_class_FFI_cdef, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, load, arginfo_class_FFI_load, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, scope, arginfo_class_FFI_scope, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, new, arginfo_class_FFI_new, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, free, arginfo_class_FFI_free, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, cast, arginfo_class_FFI_cast, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, type, arginfo_class_FFI_type, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, typeof, arginfo_class_FFI_typeof, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, arrayType, arginfo_class_FFI_arrayType, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, addr, arginfo_class_FFI_addr, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, sizeof, arginfo_class_FFI_sizeof, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, alignof, arginfo_class_FFI_alignof, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, memcpy, arginfo_class_FFI_memcpy, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, memcmp, arginfo_class_FFI_memcmp, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, memset, arginfo_class_FFI_memset, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, string, arginfo_class_FFI_string, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(FFI, isNull, arginfo_class_FFI_isNull, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_FE_END
+};
/* {{{ proto PDO::__construct(string dsn[, string username[, string passwd [, array options]]])
*/
-static PHP_METHOD(PDO, dbh_constructor)
+PHP_METHOD(PDO, dbh_constructor)
{
zval *object = ZEND_THIS;
pdo_dbh_t *dbh = NULL;
/* {{{ proto object PDO::prepare(string statement [, array options])
Prepares a statement for execution and returns a statement object */
-static PHP_METHOD(PDO, prepare)
+PHP_METHOD(PDO, prepare)
{
pdo_stmt_t *stmt;
char *statement;
/* {{{ proto bool PDO::beginTransaction()
Initiates a transaction */
-static PHP_METHOD(PDO, beginTransaction)
+PHP_METHOD(PDO, beginTransaction)
{
pdo_dbh_t *dbh = Z_PDO_DBH_P(ZEND_THIS);
/* {{{ proto bool PDO::commit()
Commit a transaction */
-static PHP_METHOD(PDO, commit)
+PHP_METHOD(PDO, commit)
{
pdo_dbh_t *dbh = Z_PDO_DBH_P(ZEND_THIS);
/* {{{ proto bool PDO::rollBack()
roll back a transaction */
-static PHP_METHOD(PDO, rollBack)
+PHP_METHOD(PDO, rollBack)
{
pdo_dbh_t *dbh = Z_PDO_DBH_P(ZEND_THIS);
/* {{{ proto bool PDO::inTransaction()
determine if inside a transaction */
-static PHP_METHOD(PDO, inTransaction)
+PHP_METHOD(PDO, inTransaction)
{
pdo_dbh_t *dbh = Z_PDO_DBH_P(ZEND_THIS);
/* {{{ proto bool PDO::setAttribute(int attribute, mixed value)
Set an attribute */
-static PHP_METHOD(PDO, setAttribute)
+PHP_METHOD(PDO, setAttribute)
{
pdo_dbh_t *dbh = Z_PDO_DBH_P(ZEND_THIS);
zend_long attr;
/* {{{ proto mixed PDO::getAttribute(int attribute)
Get an attribute */
-static PHP_METHOD(PDO, getAttribute)
+PHP_METHOD(PDO, getAttribute)
{
pdo_dbh_t *dbh = Z_PDO_DBH_P(ZEND_THIS);
zend_long attr;
/* {{{ proto int PDO::exec(string statement)
Execute a statement that does not return a row set, returning the number of affected rows */
-static PHP_METHOD(PDO, exec)
+PHP_METHOD(PDO, exec)
{
pdo_dbh_t *dbh = Z_PDO_DBH_P(ZEND_THIS);
char *statement;
/* {{{ proto string PDO::lastInsertId([string name])
Returns the id of the last row that we affected on this connection. Some databases require a sequence or table name to be passed in. Not always meaningful. */
-static PHP_METHOD(PDO, lastInsertId)
+PHP_METHOD(PDO, lastInsertId)
{
pdo_dbh_t *dbh = Z_PDO_DBH_P(ZEND_THIS);
char *name = NULL;
/* {{{ proto string PDO::errorCode()
Fetch the error code associated with the last operation on the database handle */
-static PHP_METHOD(PDO, errorCode)
+PHP_METHOD(PDO, errorCode)
{
pdo_dbh_t *dbh = Z_PDO_DBH_P(ZEND_THIS);
/* {{{ proto array PDO::errorInfo()
Fetch extended error information associated with the last operation on the database handle */
-static PHP_METHOD(PDO, errorInfo)
+PHP_METHOD(PDO, errorInfo)
{
int error_count;
int error_count_diff = 0;
/* {{{ proto object PDO::query(string sql [, PDOStatement::setFetchMode() args])
Prepare and execute $sql; returns the statement object for iteration */
-static PHP_METHOD(PDO, query)
+PHP_METHOD(PDO, query)
{
pdo_stmt_t *stmt;
char *statement;
/* {{{ proto string PDO::quote(string string [, int paramtype])
quotes string for use in a query. The optional paramtype acts as a hint for drivers that have alternate quoting styles. The default value is PDO_PARAM_STR */
-static PHP_METHOD(PDO, quote)
+PHP_METHOD(PDO, quote)
{
pdo_dbh_t *dbh = Z_PDO_DBH_P(ZEND_THIS);
char *str;
/* {{{ proto array PDO::getAvailableDrivers()
Return array of available PDO drivers */
-static PHP_METHOD(PDO, getAvailableDrivers)
+PHP_METHOD(PDO, getAvailableDrivers)
{
pdo_driver_t *pdriver;
}
/* }}} */
-const zend_function_entry pdo_dbh_functions[] = /* {{{ */ {
- ZEND_MALIAS(PDO, __construct, dbh_constructor, arginfo_class_PDO___construct, ZEND_ACC_PUBLIC)
- PHP_ME(PDO, prepare, arginfo_class_PDO_prepare, ZEND_ACC_PUBLIC)
- PHP_ME(PDO, beginTransaction, arginfo_class_PDO_beginTransaction, ZEND_ACC_PUBLIC)
- PHP_ME(PDO, commit, arginfo_class_PDO_commit, ZEND_ACC_PUBLIC)
- PHP_ME(PDO, rollBack, arginfo_class_PDO_rollBack, ZEND_ACC_PUBLIC)
- PHP_ME(PDO, inTransaction, arginfo_class_PDO_inTransaction, ZEND_ACC_PUBLIC)
- PHP_ME(PDO, setAttribute, arginfo_class_PDO_setAttribute, ZEND_ACC_PUBLIC)
- PHP_ME(PDO, exec, arginfo_class_PDO_exec, ZEND_ACC_PUBLIC)
- PHP_ME(PDO, query, arginfo_class_PDO_query, ZEND_ACC_PUBLIC)
- PHP_ME(PDO, lastInsertId, arginfo_class_PDO_lastInsertId, ZEND_ACC_PUBLIC)
- PHP_ME(PDO, errorCode, arginfo_class_PDO_errorCode, ZEND_ACC_PUBLIC)
- PHP_ME(PDO, errorInfo, arginfo_class_PDO_errorInfo, ZEND_ACC_PUBLIC)
- PHP_ME(PDO, getAttribute, arginfo_class_PDO_getAttribute, ZEND_ACC_PUBLIC)
- PHP_ME(PDO, quote, arginfo_class_PDO_quote, ZEND_ACC_PUBLIC)
- PHP_ME(PDO, getAvailableDrivers, arginfo_class_PDO_getAvailableDrivers, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- PHP_FE_END
-};
-/* }}} */
-
static void cls_method_dtor(zval *el) /* {{{ */ {
zend_function *func = (zend_function*)Z_PTR_P(el);
if (func->common.function_name) {
{
zend_class_entry ce;
- INIT_CLASS_ENTRY(ce, "PDO", pdo_dbh_functions);
+ INIT_CLASS_ENTRY(ce, "PDO", class_PDO_methods);
pdo_dbh_ce = zend_register_internal_class(&ce);
pdo_dbh_ce->create_object = pdo_dbh_new;
pdo_dbh_ce->serialize = zend_class_serialize_deny;
<?php
+/** @generate-function-entries */
+
class PDO
{
+ /** @alias PDO::dbh_constructor */
public function __construct(string $dsn, ?string $username = null, ?string $passwd = null, ?array $options = null) {}
/** @return bool */
ZEND_ARG_TYPE_INFO(0, attribute, IS_LONG, 0)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
+
+
+ZEND_METHOD(PDO, dbh_constructor);
+ZEND_METHOD(PDO, beginTransaction);
+ZEND_METHOD(PDO, commit);
+ZEND_METHOD(PDO, errorCode);
+ZEND_METHOD(PDO, errorInfo);
+ZEND_METHOD(PDO, exec);
+ZEND_METHOD(PDO, getAttribute);
+ZEND_METHOD(PDO, getAvailableDrivers);
+ZEND_METHOD(PDO, inTransaction);
+ZEND_METHOD(PDO, lastInsertId);
+ZEND_METHOD(PDO, prepare);
+ZEND_METHOD(PDO, query);
+ZEND_METHOD(PDO, quote);
+ZEND_METHOD(PDO, rollBack);
+ZEND_METHOD(PDO, setAttribute);
+
+
+static const zend_function_entry class_PDO_methods[] = {
+ ZEND_MALIAS(PDO, __construct, dbh_constructor, arginfo_class_PDO___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDO, beginTransaction, arginfo_class_PDO_beginTransaction, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDO, commit, arginfo_class_PDO_commit, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDO, errorCode, arginfo_class_PDO_errorCode, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDO, errorInfo, arginfo_class_PDO_errorInfo, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDO, exec, arginfo_class_PDO_exec, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDO, getAttribute, arginfo_class_PDO_getAttribute, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDO, getAvailableDrivers, arginfo_class_PDO_getAvailableDrivers, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(PDO, inTransaction, arginfo_class_PDO_inTransaction, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDO, lastInsertId, arginfo_class_PDO_lastInsertId, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDO, prepare, arginfo_class_PDO_prepare, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDO, query, arginfo_class_PDO_query, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDO, quote, arginfo_class_PDO_quote, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDO, rollBack, arginfo_class_PDO_rollBack, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDO, setAttribute, arginfo_class_PDO_setAttribute, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
/* {{{ proto bool PDOStatement::execute([array $bound_input_params])
Execute a prepared statement, optionally binding parameters */
-static PHP_METHOD(PDOStatement, execute)
+PHP_METHOD(PDOStatement, execute)
{
zval *input_params = NULL;
int ret = 1;
/* {{{ proto mixed PDOStatement::fetch([int $how = PDO_FETCH_BOTH [, int $orientation [, int $offset]]])
Fetches the next row and returns it, or false if there are no more rows */
-static PHP_METHOD(PDOStatement, fetch)
+PHP_METHOD(PDOStatement, fetch)
{
zend_long how = PDO_FETCH_USE_DEFAULT;
zend_long ori = PDO_FETCH_ORI_NEXT;
/* {{{ proto mixed PDOStatement::fetchObject([string class_name [, NULL|array ctor_args]])
Fetches the next row and returns it as an object. */
-static PHP_METHOD(PDOStatement, fetchObject)
+PHP_METHOD(PDOStatement, fetchObject)
{
zend_long how = PDO_FETCH_CLASS;
zend_long ori = PDO_FETCH_ORI_NEXT;
/* {{{ proto string PDOStatement::fetchColumn([int column_number])
Returns a data of the specified column in the result set. */
-static PHP_METHOD(PDOStatement, fetchColumn)
+PHP_METHOD(PDOStatement, fetchColumn)
{
zend_long col_n = 0;
PHP_STMT_GET_OBJ;
/* {{{ proto array PDOStatement::fetchAll([int $how = PDO_FETCH_BOTH [, string class_name [, NULL|array ctor_args]]])
Returns an array of all of the results. */
-static PHP_METHOD(PDOStatement, fetchAll)
+PHP_METHOD(PDOStatement, fetchAll)
{
zend_long how = PDO_FETCH_USE_DEFAULT;
zval data, *return_all;
/* {{{ proto bool PDOStatement::bindValue(mixed $paramno, mixed $param [, int $type ])
bind an input parameter to the value of a PHP variable. $paramno is the 1-based position of the placeholder in the SQL statement (but can be the parameter name for drivers that support named placeholders). It should be called prior to execute(). */
-static PHP_METHOD(PDOStatement, bindValue)
+PHP_METHOD(PDOStatement, bindValue)
{
struct pdo_bound_param_data param;
zend_long param_type = PDO_PARAM_STR;
/* {{{ proto bool PDOStatement::bindParam(mixed $paramno, mixed &$param [, int $type [, int $maxlen [, mixed $driverdata]]])
bind a parameter to a PHP variable. $paramno is the 1-based position of the placeholder in the SQL statement (but can be the parameter name for drivers that support named placeholders). This isn't supported by all drivers. It should be called prior to execute(). */
-static PHP_METHOD(PDOStatement, bindParam)
+PHP_METHOD(PDOStatement, bindParam)
{
PHP_STMT_GET_OBJ;
RETURN_BOOL(register_bound_param(INTERNAL_FUNCTION_PARAM_PASSTHRU, stmt, TRUE));
/* {{{ proto bool PDOStatement::bindColumn(mixed $column, mixed &$param [, int $type [, int $maxlen [, mixed $driverdata]]])
bind a column to a PHP variable. On each row fetch $param will contain the value of the corresponding column. $column is the 1-based offset of the column, or the column name. For portability, don't call this before execute(). */
-static PHP_METHOD(PDOStatement, bindColumn)
+PHP_METHOD(PDOStatement, bindColumn)
{
PHP_STMT_GET_OBJ;
RETURN_BOOL(register_bound_param(INTERNAL_FUNCTION_PARAM_PASSTHRU, stmt, 0));
/* {{{ proto int PDOStatement::rowCount()
Returns the number of rows in a result set, or the number of rows affected by the last execute(). It is not always meaningful. */
-static PHP_METHOD(PDOStatement, rowCount)
+PHP_METHOD(PDOStatement, rowCount)
{
PHP_STMT_GET_OBJ;
/* {{{ proto string PDOStatement::errorCode()
Fetch the error code associated with the last operation on the statement handle */
-static PHP_METHOD(PDOStatement, errorCode)
+PHP_METHOD(PDOStatement, errorCode)
{
PHP_STMT_GET_OBJ;
/* {{{ proto array PDOStatement::errorInfo()
Fetch extended error information associated with the last operation on the statement handle */
-static PHP_METHOD(PDOStatement, errorInfo)
+PHP_METHOD(PDOStatement, errorInfo)
{
int error_count;
int error_count_diff = 0;
/* {{{ proto bool PDOStatement::setAttribute(long attribute, mixed value)
Set an attribute */
-static PHP_METHOD(PDOStatement, setAttribute)
+PHP_METHOD(PDOStatement, setAttribute)
{
zend_long attr;
zval *value = NULL;
return 0;
}
-static PHP_METHOD(PDOStatement, getAttribute)
+PHP_METHOD(PDOStatement, getAttribute)
{
zend_long attr;
PHP_STMT_GET_OBJ;
/* {{{ proto int PDOStatement::columnCount()
Returns the number of columns in the result set */
-static PHP_METHOD(PDOStatement, columnCount)
+PHP_METHOD(PDOStatement, columnCount)
{
PHP_STMT_GET_OBJ;
/* {{{ proto array PDOStatement::getColumnMeta(int $column)
Returns meta data for a numbered column */
-static PHP_METHOD(PDOStatement, getColumnMeta)
+PHP_METHOD(PDOStatement, getColumnMeta)
{
zend_long colno;
struct pdo_column_data *col;
return retval;
}
-static PHP_METHOD(PDOStatement, setFetchMode)
+PHP_METHOD(PDOStatement, setFetchMode)
{
PHP_STMT_GET_OBJ;
return 1;
}
-static PHP_METHOD(PDOStatement, nextRowset)
+PHP_METHOD(PDOStatement, nextRowset)
{
PHP_STMT_GET_OBJ;
/* {{{ proto bool PDOStatement::closeCursor()
Closes the cursor, leaving the statement ready for re-execution. */
-static PHP_METHOD(PDOStatement, closeCursor)
+PHP_METHOD(PDOStatement, closeCursor)
{
PHP_STMT_GET_OBJ;
/* {{{ proto void PDOStatement::debugDumpParams()
A utility for internals hackers to debug parameter internals */
-static PHP_METHOD(PDOStatement, debugDumpParams)
+PHP_METHOD(PDOStatement, debugDumpParams)
{
ZEND_PARSE_PARAMETERS_NONE();
php_stream_close(out);
}
/* }}} */
-const zend_function_entry pdo_dbstmt_functions[] = {
- PHP_ME(PDOStatement, execute, arginfo_class_PDOStatement_execute, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, fetch, arginfo_class_PDOStatement_fetch, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, bindParam, arginfo_class_PDOStatement_bindParam, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, bindColumn, arginfo_class_PDOStatement_bindColumn, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, bindValue, arginfo_class_PDOStatement_bindValue, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, rowCount, arginfo_class_PDOStatement_rowCount, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, fetchColumn, arginfo_class_PDOStatement_fetchColumn, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, fetchAll, arginfo_class_PDOStatement_fetchAll, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, fetchObject, arginfo_class_PDOStatement_fetchObject, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, errorCode, arginfo_class_PDOStatement_errorCode, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, errorInfo, arginfo_class_PDOStatement_errorInfo, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, setAttribute, arginfo_class_PDOStatement_setAttribute, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, getAttribute, arginfo_class_PDOStatement_getAttribute, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, columnCount, arginfo_class_PDOStatement_columnCount, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, getColumnMeta, arginfo_class_PDOStatement_getColumnMeta, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, setFetchMode, arginfo_class_PDOStatement_setFetchMode, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, nextRowset, arginfo_class_PDOStatement_nextRowset, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, closeCursor, arginfo_class_PDOStatement_closeCursor, ZEND_ACC_PUBLIC)
- PHP_ME(PDOStatement, debugDumpParams, arginfo_class_PDOStatement_debugDumpParams, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
/* {{{ overloaded handlers for PDOStatement class */
static zval *dbstmt_prop_write(zend_object *object, zend_string *name, zval *value, void **cache_slot)
/* {{{ overloaded handlers for PDORow class (used by PDO_FETCH_LAZY) */
-const zend_function_entry pdo_row_functions[] = {
- PHP_FE_END
-};
-
static zval *row_prop_read(zend_object *object, zend_string *name, int type, void **cache_slot, zval *rv)
{
pdo_row_t *row = (pdo_row_t *)object;
{
zend_class_entry ce;
- INIT_CLASS_ENTRY(ce, "PDOStatement", pdo_dbstmt_functions);
+ INIT_CLASS_ENTRY(ce, "PDOStatement", class_PDOStatement_methods);
pdo_dbstmt_ce = zend_register_internal_class(&ce);
pdo_dbstmt_ce->get_iterator = pdo_stmt_iter_get;
pdo_dbstmt_ce->create_object = pdo_dbstmt_new;
pdo_dbstmt_object_handlers.compare = dbstmt_compare;
pdo_dbstmt_object_handlers.clone_obj = NULL;
- INIT_CLASS_ENTRY(ce, "PDORow", pdo_row_functions);
+ INIT_CLASS_ENTRY(ce, "PDORow", class_PDORow_methods);
pdo_row_ce = zend_register_internal_class(&ce);
pdo_row_ce->ce_flags |= ZEND_ACC_FINAL; /* when removing this a lot of handlers need to be redone */
pdo_row_ce->create_object = pdo_row_new;
<?php
+/** @generate-function-entries */
+
class PDOStatement implements Traversable
{
/**
/** @return bool */
public function setFetchMode(int $mode, $param1 = UNKNOWN, $param2 = UNKNOWN) {}
}
+
+final class PDORow
+{
+}
ZEND_ARG_INFO(0, param1)
ZEND_ARG_INFO(0, param2)
ZEND_END_ARG_INFO()
+
+
+ZEND_METHOD(PDOStatement, bindColumn);
+ZEND_METHOD(PDOStatement, bindParam);
+ZEND_METHOD(PDOStatement, bindValue);
+ZEND_METHOD(PDOStatement, closeCursor);
+ZEND_METHOD(PDOStatement, columnCount);
+ZEND_METHOD(PDOStatement, debugDumpParams);
+ZEND_METHOD(PDOStatement, errorCode);
+ZEND_METHOD(PDOStatement, errorInfo);
+ZEND_METHOD(PDOStatement, execute);
+ZEND_METHOD(PDOStatement, fetch);
+ZEND_METHOD(PDOStatement, fetchAll);
+ZEND_METHOD(PDOStatement, fetchColumn);
+ZEND_METHOD(PDOStatement, fetchObject);
+ZEND_METHOD(PDOStatement, getAttribute);
+ZEND_METHOD(PDOStatement, getColumnMeta);
+ZEND_METHOD(PDOStatement, nextRowset);
+ZEND_METHOD(PDOStatement, rowCount);
+ZEND_METHOD(PDOStatement, setAttribute);
+ZEND_METHOD(PDOStatement, setFetchMode);
+
+
+static const zend_function_entry class_PDOStatement_methods[] = {
+ ZEND_ME(PDOStatement, bindColumn, arginfo_class_PDOStatement_bindColumn, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, bindParam, arginfo_class_PDOStatement_bindParam, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, bindValue, arginfo_class_PDOStatement_bindValue, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, closeCursor, arginfo_class_PDOStatement_closeCursor, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, columnCount, arginfo_class_PDOStatement_columnCount, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, debugDumpParams, arginfo_class_PDOStatement_debugDumpParams, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, errorCode, arginfo_class_PDOStatement_errorCode, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, errorInfo, arginfo_class_PDOStatement_errorInfo, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, execute, arginfo_class_PDOStatement_execute, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, fetch, arginfo_class_PDOStatement_fetch, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, fetchAll, arginfo_class_PDOStatement_fetchAll, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, fetchColumn, arginfo_class_PDOStatement_fetchColumn, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, fetchObject, arginfo_class_PDOStatement_fetchObject, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, getAttribute, arginfo_class_PDOStatement_getAttribute, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, getColumnMeta, arginfo_class_PDOStatement_getColumnMeta, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, nextRowset, arginfo_class_PDOStatement_nextRowset, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, rowCount, arginfo_class_PDOStatement_rowCount, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, setAttribute, arginfo_class_PDOStatement_setAttribute, ZEND_ACC_PUBLIC)
+ ZEND_ME(PDOStatement, setFetchMode, arginfo_class_PDOStatement_setFetchMode, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_PDORow_methods[] = {
+ ZEND_FE_END
+};
/* {{{ phar methods */
-static const zend_function_entry php_archive_methods[] = {
- PHP_ME(Phar, __construct, arginfo_class_Phar___construct, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, __destruct, arginfo_class_Phar___destruct, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, addEmptyDir, arginfo_class_Phar_addEmptyDir, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, addFile, arginfo_class_Phar_addFile, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, addFromString, arginfo_class_Phar_addFromString, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, buildFromDirectory, arginfo_class_Phar_buildFromDirectory, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, buildFromIterator, arginfo_class_Phar_buildFromIterator, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, compressFiles, arginfo_class_Phar_compressFiles, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, decompressFiles, arginfo_class_Phar_decompressFiles, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, compress, arginfo_class_Phar_compress, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, decompress, arginfo_class_Phar_decompress, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, convertToExecutable, arginfo_class_Phar_convertToExecutable, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, convertToData, arginfo_class_Phar_convertToData, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, copy, arginfo_class_Phar_copy, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, count, arginfo_class_Phar_count, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, delete, arginfo_class_Phar_delete, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, delMetadata, arginfo_class_Phar_delMetadata, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, extractTo, arginfo_class_Phar_extractTo, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, getAlias, arginfo_class_Phar_getAlias, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, getPath, arginfo_class_Phar_getPath, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, getMetadata, arginfo_class_Phar_getMetadata, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, getModified, arginfo_class_Phar_getModified, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, getSignature, arginfo_class_Phar_getSignature, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, getStub, arginfo_class_Phar_getStub, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, getVersion, arginfo_class_Phar_getVersion, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, hasMetadata, arginfo_class_Phar_hasMetadata, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, isBuffering, arginfo_class_Phar_isBuffering, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, isCompressed, arginfo_class_Phar_isCompressed, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, isFileFormat, arginfo_class_Phar_isFileFormat, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, isWritable, arginfo_class_Phar_isWritable, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, offsetExists, arginfo_class_Phar_offsetExists, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, offsetGet, arginfo_class_Phar_offsetGet, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, offsetSet, arginfo_class_Phar_offsetSet, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, offsetUnset, arginfo_class_Phar_offsetUnset, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, setAlias, arginfo_class_Phar_setAlias, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, setDefaultStub, arginfo_class_Phar_setDefaultStub, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, setMetadata, arginfo_class_Phar_setMetadata, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, setSignatureAlgorithm, arginfo_class_Phar_setSignatureAlgorithm, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, setStub, arginfo_class_Phar_setStub, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, startBuffering, arginfo_class_Phar_startBuffering, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, stopBuffering, arginfo_class_Phar_stopBuffering, ZEND_ACC_PUBLIC)
- /* static member functions */
- PHP_ME(Phar, apiVersion, arginfo_class_Phar_apiVersion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, canCompress, arginfo_class_Phar_canCompress, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, canWrite, arginfo_class_Phar_canWrite, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, createDefaultStub, arginfo_class_Phar_createDefaultStub, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, getSupportedCompression,arginfo_class_Phar_getSupportedCompression, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, getSupportedSignatures,arginfo_class_Phar_getSupportedSignatures, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, interceptFileFuncs, arginfo_class_Phar_interceptFileFuncs, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, isValidPharFilename, arginfo_class_Phar_isValidPharFilename, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, loadPhar, arginfo_class_Phar_loadPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, mapPhar, arginfo_class_Phar_mapPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, running, arginfo_class_Phar_running, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, mount, arginfo_class_Phar_mount, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, mungServer, arginfo_class_Phar_mungServer, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, unlinkArchive, arginfo_class_Phar_unlinkArchive, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, webPhar, arginfo_class_Phar_webPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_FE_END
-};
-
-static const zend_function_entry php_data_methods[] = {
- PHP_ME(Phar, __construct, arginfo_class_PharData___construct, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, __destruct, arginfo_class_PharData___destruct, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, addEmptyDir, arginfo_class_PharData_addEmptyDir, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, addFile, arginfo_class_PharData_addFile, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, addFromString, arginfo_class_PharData_addFromString, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, buildFromDirectory, arginfo_class_PharData_buildFromDirectory, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, buildFromIterator, arginfo_class_PharData_buildFromIterator, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, compressFiles, arginfo_class_PharData_compressFiles, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, decompressFiles, arginfo_class_PharData_decompressFiles, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, compress, arginfo_class_PharData_compress, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, decompress, arginfo_class_PharData_decompress, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, convertToExecutable, arginfo_class_PharData_convertToExecutable, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, convertToData, arginfo_class_PharData_convertToData, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, copy, arginfo_class_PharData_copy, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, count, arginfo_class_PharData_count, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, delete, arginfo_class_PharData_delete, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, delMetadata, arginfo_class_PharData_delMetadata, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, extractTo, arginfo_class_PharData_extractTo, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, getAlias, arginfo_class_PharData_getAlias, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, getPath, arginfo_class_PharData_getPath, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, getMetadata, arginfo_class_PharData_getMetadata, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, getModified, arginfo_class_PharData_getModified, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, getSignature, arginfo_class_PharData_getSignature, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, getStub, arginfo_class_PharData_getStub, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, getVersion, arginfo_class_PharData_getVersion, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, hasMetadata, arginfo_class_PharData_hasMetadata, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, isBuffering, arginfo_class_PharData_isBuffering, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, isCompressed, arginfo_class_PharData_isCompressed, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, isFileFormat, arginfo_class_PharData_isFileFormat, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, isWritable, arginfo_class_PharData_isWritable, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, offsetExists, arginfo_class_PharData_offsetExists, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, offsetGet, arginfo_class_PharData_offsetGet, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, offsetSet, arginfo_class_PharData_offsetSet, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, offsetUnset, arginfo_class_PharData_offsetUnset, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, setAlias, arginfo_class_PharData_setAlias, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, setDefaultStub, arginfo_class_PharData_setDefaultStub, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, setMetadata, arginfo_class_PharData_setMetadata, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, setSignatureAlgorithm, arginfo_class_PharData_setSignatureAlgorithm, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, setStub, arginfo_class_PharData_setStub, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, startBuffering, arginfo_class_PharData_startBuffering, ZEND_ACC_PUBLIC)
- PHP_ME(Phar, stopBuffering, arginfo_class_PharData_stopBuffering, ZEND_ACC_PUBLIC)
- /* static member functions */
- PHP_ME(Phar, apiVersion, arginfo_class_PharData_apiVersion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, canCompress, arginfo_class_PharData_canCompress, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, canWrite, arginfo_class_PharData_canWrite, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, createDefaultStub, arginfo_class_PharData_createDefaultStub, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, getSupportedCompression,arginfo_class_PharData_getSupportedCompression, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, getSupportedSignatures,arginfo_class_PharData_getSupportedSignatures, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, interceptFileFuncs, arginfo_class_PharData_interceptFileFuncs, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, isValidPharFilename, arginfo_class_PharData_isValidPharFilename, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, loadPhar, arginfo_class_PharData_loadPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, mapPhar, arginfo_class_PharData_mapPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, running, arginfo_class_PharData_running, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, mount, arginfo_class_PharData_mount, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, mungServer, arginfo_class_PharData_mungServer, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, unlinkArchive, arginfo_class_PharData_unlinkArchive, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_ME(Phar, webPhar, arginfo_class_PharData_webPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
- PHP_FE_END
-};
-
-static const zend_function_entry php_entry_methods[] = {
- PHP_ME(PharFileInfo, __construct, arginfo_class_PharFileInfo___construct, ZEND_ACC_PUBLIC)
- PHP_ME(PharFileInfo, __destruct, arginfo_class_PharFileInfo___destruct, ZEND_ACC_PUBLIC)
- PHP_ME(PharFileInfo, chmod, arginfo_class_PharFileInfo_chmod, ZEND_ACC_PUBLIC)
- PHP_ME(PharFileInfo, compress, arginfo_class_PharFileInfo_compress, ZEND_ACC_PUBLIC)
- PHP_ME(PharFileInfo, decompress, arginfo_class_PharFileInfo_decompress, ZEND_ACC_PUBLIC)
- PHP_ME(PharFileInfo, delMetadata, arginfo_class_PharFileInfo_delMetadata, ZEND_ACC_PUBLIC)
- PHP_ME(PharFileInfo, getCompressedSize, arginfo_class_PharFileInfo_getCompressedSize, ZEND_ACC_PUBLIC)
- PHP_ME(PharFileInfo, getCRC32, arginfo_class_PharFileInfo_getCRC32, ZEND_ACC_PUBLIC)
- PHP_ME(PharFileInfo, getContent, arginfo_class_PharFileInfo_getContent, ZEND_ACC_PUBLIC)
- PHP_ME(PharFileInfo, getMetadata, arginfo_class_PharFileInfo_getMetadata, ZEND_ACC_PUBLIC)
- PHP_ME(PharFileInfo, getPharFlags, arginfo_class_PharFileInfo_getPharFlags, ZEND_ACC_PUBLIC)
- PHP_ME(PharFileInfo, hasMetadata, arginfo_class_PharFileInfo_hasMetadata, ZEND_ACC_PUBLIC)
- PHP_ME(PharFileInfo, isCompressed, arginfo_class_PharFileInfo_isCompressed, ZEND_ACC_PUBLIC)
- PHP_ME(PharFileInfo, isCRCChecked, arginfo_class_PharFileInfo_isCRCChecked, ZEND_ACC_PUBLIC)
- PHP_ME(PharFileInfo, setMetadata, arginfo_class_PharFileInfo_setMetadata, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-static const zend_function_entry phar_exception_methods[] = {
- PHP_FE_END
-};
-/* }}} */
-
#define REGISTER_PHAR_CLASS_CONST_LONG(class_name, const_name, value) \
zend_declare_class_constant_long(class_name, const_name, sizeof(const_name)-1, (zend_long)value);
{
zend_class_entry ce;
- INIT_CLASS_ENTRY(ce, "PharException", phar_exception_methods);
+ INIT_CLASS_ENTRY(ce, "PharException", class_PharException_methods);
phar_ce_PharException = zend_register_internal_class_ex(&ce, zend_ce_exception);
- INIT_CLASS_ENTRY(ce, "Phar", php_archive_methods);
+ INIT_CLASS_ENTRY(ce, "Phar", class_Phar_methods);
phar_ce_archive = zend_register_internal_class_ex(&ce, spl_ce_RecursiveDirectoryIterator);
zend_class_implements(phar_ce_archive, 2, zend_ce_countable, zend_ce_arrayaccess);
- INIT_CLASS_ENTRY(ce, "PharData", php_data_methods);
+ INIT_CLASS_ENTRY(ce, "PharData", class_PharData_methods);
phar_ce_data = zend_register_internal_class_ex(&ce, spl_ce_RecursiveDirectoryIterator);
zend_class_implements(phar_ce_data, 2, zend_ce_countable, zend_ce_arrayaccess);
- INIT_CLASS_ENTRY(ce, "PharFileInfo", php_entry_methods);
+ INIT_CLASS_ENTRY(ce, "PharFileInfo", class_PharFileInfo_methods);
phar_ce_entry = zend_register_internal_class_ex(&ce, spl_ce_SplFileInfo);
REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "BZ2", PHAR_ENT_COMPRESSED_BZ2)
<?php
+/** @generate-function-entries */
+
+class PharException extends Exception
+{
+}
+
class Phar extends RecursiveDirectoryIterator implements Countable, ArrayAccess
{
public function __construct(string $filename, int $flags = FilesystemIterator::SKIP_DOTS|FilesystemIterator::UNIX_PATHS, ?string $alias = null) {}
class PharData extends RecursiveDirectoryIterator implements Countable, ArrayAccess
{
+ /** @alias Phar::__construct */
public function __construct(string $filename, int $flags = FilesystemIterator::SKIP_DOTS|FilesystemIterator::UNIX_PATHS, ?string $alias = null, $fileformat = 0) {}
+ /** @alias Phar::__destruct */
public function __destruct() {}
- /** @return void */
+ /**
+ * @return void
+ * @alias Phar::addEmptyDir
+ */
public function addEmptyDir(string $dirname) {}
- /** @return void */
+ /**
+ * @return void
+ * @alias Phar::addFile
+ */
public function addFile(string $filename, string $localname = UNKNOWN) {}
- /** @return void */
+ /**
+ * @return void
+ * @alias Phar::addFromString
+ */
public function addFromString(string $localname, string $contents) {}
- /** @return array|false */
+ /**
+ * @return array|false
+ * @alias Phar::buildFromDirectory
+ */
public function buildFromDirectory(string $base_dir, string $regex = UNKNOWN) {}
- /** @return array|false */
+ /**
+ * @return array|false
+ * @alias Phar::buildFromIterator
+ */
public function buildFromIterator(Traversable $iterator, string $base_directory = UNKNOWN) {}
- /** @return void */
+ /**
+ * @return void
+ * @alias Phar::compressFiles
+ */
public function compressFiles(int $compression_type) {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias Phar::decompressFiles
+ */
public function decompressFiles() {}
- /** @return Phar|null */
+ /**
+ * @return Phar|null
+ * @alias Phar::compress
+ */
public function compress(int $compression_type, string $file_ext = UNKNOWN) {}
- /** @return Phar|null */
+ /**
+ * @return Phar|null
+ * @alias Phar::decompress
+ */
public function decompress(string $file_ext = UNKNOWN) {}
- /** @return Phar|null */
+ /**
+ * @return Phar|null
+ * @alias Phar::convertToExecutable
+ */
public function convertToExecutable(int $format = 9021976, int $compression_type = 9021976, string $file_ext = UNKNOWN) {}
- /** @return Phar|null */
+ /**
+ * @return Phar|null
+ * @alias Phar::convertToData
+ */
public function convertToData(int $format = 9021976, int $compression_type = 9021976, string $file_ext = UNKNOWN) {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias Phar::copy
+ */
public function copy(string $newfile, string $oldfile) {}
- /** @return int */
+ /**
+ * @return int
+ * @alias Phar::count
+ */
public function count(int $mode = UNKNOWN) {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias Phar::delete
+ */
public function delete(string $entry) {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias Phar::delMetadata
+ */
public function delMetadata() {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias Phar::extractTo
+ */
public function extractTo(string $pathto, $files = null, bool $overwrite = false) {}
- /** @return string|null */
+ /**
+ * @return string|null
+ * @alias Phar::getAlias
+ */
public function getAlias() {}
- /** @return string */
+ /**
+ * @return string
+ * @alias Phar::getPath
+ */
public function getPath() {}
- /** @return mixed */
+ /**
+ * @return mixed
+ * @alias Phar::getMetadata
+ */
public function getMetadata() {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias Phar::getModified
+ */
public function getModified() {}
- /** @return array|false */
+ /**
+ * @return array|false
+ * @alias Phar::getSignature
+ */
public function getSignature() {}
- /** @return string */
+ /**
+ * @return string
+ * @alias Phar::getStub
+ */
public function getStub() {}
- /** @return string */
+ /**
+ * @return string
+ * @alias Phar::getVersion
+ */
public function getVersion() {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias Phar::hasMetadata
+ */
public function hasMetadata() {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias Phar::isBuffering
+ */
public function isBuffering() {}
- /** @return int|false */
+ /**
+ * @return int|false
+ * @alias Phar::isCompressed
+ */
public function isCompressed() {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias Phar::isFileFormat
+ */
public function isFileFormat(int $fileformat) {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias Phar::isWritable
+ */
public function isWritable() {}
/**
* @param string $entry
* @return bool
+ * @alias Phar::offsetExists
*/
public function offsetExists($entry) {}
/**
* @param string $entry
* @return PharFileInfo
+ * @alias Phar::offsetGet
*/
public function offsetGet($entry) {}
* @param string $entry
* @param resource|string $value
* @return void
+ * @alias Phar::offsetSet
*/
public function offsetSet($entry, $value) {}
/**
* @param string $entry
* @return bool
+ * @alias Phar::offsetUnset
*/
public function offsetUnset($entry) {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias Phar::setAlias
+ */
public function setAlias(string $alias) {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias Phar::setDefaultStub
+ */
public function setDefaultStub(?string $index = null, string $webindex = UNKNOWN) {}
/**
* @param mixed $metadata
* @return void
+ * @alias Phar::setMetadata
*/
public function setMetadata($metadata) {}
- /** @return void */
+ /**
+ * @return void
+ * @alias Phar::setSignatureAlgorithm
+ */
public function setSignatureAlgorithm(int $algorithm, string $privatekey = UNKNOWN) {}
/**
* @param resource $newstub
* @return bool
+ * @alias Phar::setStub
*/
public function setStub($newstub, $maxlen = -1) {}
- /** @return void */
+ /**
+ * @return void
+ * @alias Phar::startBuffering
+ */
public function startBuffering() {}
- /** @return void */
+ /**
+ * @return void
+ * @alias Phar::stopBuffering
+ */
public function stopBuffering() {}
+ /** @alias Phar::apiVersion */
final public static function apiVersion(): string {}
+ /** @alias Phar::canCompress */
final public static function canCompress(int $method = 0): bool {}
+ /** @alias Phar::canWrite */
final public static function canWrite(): bool {}
+ /** @alias Phar::createDefaultStub */
final public static function createDefaultStub(
string $index = UNKNOWN, string $webindex = UNKNOWN): string {}
+ /** @alias Phar::getSupportedCompression */
final public static function getSupportedCompression(): array {}
+ /** @alias Phar::getSupportedSignatures */
final public static function getSupportedSignatures(): array {}
+ /** @alias Phar::interceptFileFuncs */
final public static function interceptFileFuncs(): void {}
+ /** @alias Phar::isValidPharFilename */
final public static function isValidPharFilename(
string $filename, bool $executable = true): bool {}
+ /** @alias Phar::loadPhar */
final public static function loadPhar(string $filename, ?string $alias = null): bool {}
+ /** @alias Phar::mapPhar */
final public static function mapPhar(?string $alias = null, int $offset = 0): bool {}
+ /** @alias Phar::running */
final public static function running(bool $retphar = true): string {}
+ /** @alias Phar::mount */
final public static function mount(string $inphar, string $externalfile): void {}
+ /** @alias Phar::mungServer */
final public static function mungServer(array $munglist): void {}
+ /** @alias Phar::unlinkArchive */
final public static function unlinkArchive(string $archive): bool {}
+ /** @alias Phar::webPhar */
final public static function webPhar(
?string $alias = null, ?string $index = null, string $f404 = UNKNOWN,
array $mimetypes = [], $rewrites = UNKNOWN): void {}
#define arginfo_class_PharFileInfo_isCRCChecked arginfo_class_Phar___destruct
#define arginfo_class_PharFileInfo_setMetadata arginfo_class_Phar_setMetadata
+
+
+ZEND_METHOD(Phar, __construct);
+ZEND_METHOD(Phar, __destruct);
+ZEND_METHOD(Phar, addEmptyDir);
+ZEND_METHOD(Phar, addFile);
+ZEND_METHOD(Phar, addFromString);
+ZEND_METHOD(Phar, buildFromDirectory);
+ZEND_METHOD(Phar, buildFromIterator);
+ZEND_METHOD(Phar, compressFiles);
+ZEND_METHOD(Phar, decompressFiles);
+ZEND_METHOD(Phar, compress);
+ZEND_METHOD(Phar, decompress);
+ZEND_METHOD(Phar, convertToExecutable);
+ZEND_METHOD(Phar, convertToData);
+ZEND_METHOD(Phar, copy);
+ZEND_METHOD(Phar, count);
+ZEND_METHOD(Phar, delete);
+ZEND_METHOD(Phar, delMetadata);
+ZEND_METHOD(Phar, extractTo);
+ZEND_METHOD(Phar, getAlias);
+ZEND_METHOD(Phar, getPath);
+ZEND_METHOD(Phar, getMetadata);
+ZEND_METHOD(Phar, getModified);
+ZEND_METHOD(Phar, getSignature);
+ZEND_METHOD(Phar, getStub);
+ZEND_METHOD(Phar, getVersion);
+ZEND_METHOD(Phar, hasMetadata);
+ZEND_METHOD(Phar, isBuffering);
+ZEND_METHOD(Phar, isCompressed);
+ZEND_METHOD(Phar, isFileFormat);
+ZEND_METHOD(Phar, isWritable);
+ZEND_METHOD(Phar, offsetExists);
+ZEND_METHOD(Phar, offsetGet);
+ZEND_METHOD(Phar, offsetSet);
+ZEND_METHOD(Phar, offsetUnset);
+ZEND_METHOD(Phar, setAlias);
+ZEND_METHOD(Phar, setDefaultStub);
+ZEND_METHOD(Phar, setMetadata);
+ZEND_METHOD(Phar, setSignatureAlgorithm);
+ZEND_METHOD(Phar, setStub);
+ZEND_METHOD(Phar, startBuffering);
+ZEND_METHOD(Phar, stopBuffering);
+ZEND_METHOD(Phar, apiVersion);
+ZEND_METHOD(Phar, canCompress);
+ZEND_METHOD(Phar, canWrite);
+ZEND_METHOD(Phar, createDefaultStub);
+ZEND_METHOD(Phar, getSupportedCompression);
+ZEND_METHOD(Phar, getSupportedSignatures);
+ZEND_METHOD(Phar, interceptFileFuncs);
+ZEND_METHOD(Phar, isValidPharFilename);
+ZEND_METHOD(Phar, loadPhar);
+ZEND_METHOD(Phar, mapPhar);
+ZEND_METHOD(Phar, running);
+ZEND_METHOD(Phar, mount);
+ZEND_METHOD(Phar, mungServer);
+ZEND_METHOD(Phar, unlinkArchive);
+ZEND_METHOD(Phar, webPhar);
+ZEND_METHOD(PharFileInfo, __construct);
+ZEND_METHOD(PharFileInfo, __destruct);
+ZEND_METHOD(PharFileInfo, chmod);
+ZEND_METHOD(PharFileInfo, compress);
+ZEND_METHOD(PharFileInfo, decompress);
+ZEND_METHOD(PharFileInfo, delMetadata);
+ZEND_METHOD(PharFileInfo, getCompressedSize);
+ZEND_METHOD(PharFileInfo, getCRC32);
+ZEND_METHOD(PharFileInfo, getContent);
+ZEND_METHOD(PharFileInfo, getMetadata);
+ZEND_METHOD(PharFileInfo, getPharFlags);
+ZEND_METHOD(PharFileInfo, hasMetadata);
+ZEND_METHOD(PharFileInfo, isCompressed);
+ZEND_METHOD(PharFileInfo, isCRCChecked);
+ZEND_METHOD(PharFileInfo, setMetadata);
+
+
+static const zend_function_entry class_PharException_methods[] = {
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_Phar_methods[] = {
+ ZEND_ME(Phar, __construct, arginfo_class_Phar___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, __destruct, arginfo_class_Phar___destruct, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, addEmptyDir, arginfo_class_Phar_addEmptyDir, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, addFile, arginfo_class_Phar_addFile, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, addFromString, arginfo_class_Phar_addFromString, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, buildFromDirectory, arginfo_class_Phar_buildFromDirectory, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, buildFromIterator, arginfo_class_Phar_buildFromIterator, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, compressFiles, arginfo_class_Phar_compressFiles, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, decompressFiles, arginfo_class_Phar_decompressFiles, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, compress, arginfo_class_Phar_compress, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, decompress, arginfo_class_Phar_decompress, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, convertToExecutable, arginfo_class_Phar_convertToExecutable, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, convertToData, arginfo_class_Phar_convertToData, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, copy, arginfo_class_Phar_copy, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, count, arginfo_class_Phar_count, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, delete, arginfo_class_Phar_delete, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, delMetadata, arginfo_class_Phar_delMetadata, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, extractTo, arginfo_class_Phar_extractTo, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, getAlias, arginfo_class_Phar_getAlias, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, getPath, arginfo_class_Phar_getPath, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, getMetadata, arginfo_class_Phar_getMetadata, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, getModified, arginfo_class_Phar_getModified, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, getSignature, arginfo_class_Phar_getSignature, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, getStub, arginfo_class_Phar_getStub, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, getVersion, arginfo_class_Phar_getVersion, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, hasMetadata, arginfo_class_Phar_hasMetadata, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, isBuffering, arginfo_class_Phar_isBuffering, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, isCompressed, arginfo_class_Phar_isCompressed, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, isFileFormat, arginfo_class_Phar_isFileFormat, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, isWritable, arginfo_class_Phar_isWritable, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, offsetExists, arginfo_class_Phar_offsetExists, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, offsetGet, arginfo_class_Phar_offsetGet, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, offsetSet, arginfo_class_Phar_offsetSet, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, offsetUnset, arginfo_class_Phar_offsetUnset, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, setAlias, arginfo_class_Phar_setAlias, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, setDefaultStub, arginfo_class_Phar_setDefaultStub, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, setMetadata, arginfo_class_Phar_setMetadata, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, setSignatureAlgorithm, arginfo_class_Phar_setSignatureAlgorithm, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, setStub, arginfo_class_Phar_setStub, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, startBuffering, arginfo_class_Phar_startBuffering, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, stopBuffering, arginfo_class_Phar_stopBuffering, ZEND_ACC_PUBLIC)
+ ZEND_ME(Phar, apiVersion, arginfo_class_Phar_apiVersion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_ME(Phar, canCompress, arginfo_class_Phar_canCompress, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_ME(Phar, canWrite, arginfo_class_Phar_canWrite, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_ME(Phar, createDefaultStub, arginfo_class_Phar_createDefaultStub, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_ME(Phar, getSupportedCompression, arginfo_class_Phar_getSupportedCompression, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_ME(Phar, getSupportedSignatures, arginfo_class_Phar_getSupportedSignatures, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_ME(Phar, interceptFileFuncs, arginfo_class_Phar_interceptFileFuncs, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_ME(Phar, isValidPharFilename, arginfo_class_Phar_isValidPharFilename, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_ME(Phar, loadPhar, arginfo_class_Phar_loadPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_ME(Phar, mapPhar, arginfo_class_Phar_mapPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_ME(Phar, running, arginfo_class_Phar_running, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_ME(Phar, mount, arginfo_class_Phar_mount, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_ME(Phar, mungServer, arginfo_class_Phar_mungServer, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_ME(Phar, unlinkArchive, arginfo_class_Phar_unlinkArchive, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_ME(Phar, webPhar, arginfo_class_Phar_webPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_PharData_methods[] = {
+ ZEND_MALIAS(Phar, __construct, __construct, arginfo_class_PharData___construct, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, __destruct, __destruct, arginfo_class_PharData___destruct, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, addEmptyDir, addEmptyDir, arginfo_class_PharData_addEmptyDir, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, addFile, addFile, arginfo_class_PharData_addFile, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, addFromString, addFromString, arginfo_class_PharData_addFromString, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, buildFromDirectory, buildFromDirectory, arginfo_class_PharData_buildFromDirectory, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, buildFromIterator, buildFromIterator, arginfo_class_PharData_buildFromIterator, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, compressFiles, compressFiles, arginfo_class_PharData_compressFiles, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, decompressFiles, decompressFiles, arginfo_class_PharData_decompressFiles, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, compress, compress, arginfo_class_PharData_compress, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, decompress, decompress, arginfo_class_PharData_decompress, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, convertToExecutable, convertToExecutable, arginfo_class_PharData_convertToExecutable, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, convertToData, convertToData, arginfo_class_PharData_convertToData, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, copy, copy, arginfo_class_PharData_copy, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, count, count, arginfo_class_PharData_count, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, delete, delete, arginfo_class_PharData_delete, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, delMetadata, delMetadata, arginfo_class_PharData_delMetadata, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, extractTo, extractTo, arginfo_class_PharData_extractTo, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, getAlias, getAlias, arginfo_class_PharData_getAlias, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, getPath, getPath, arginfo_class_PharData_getPath, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, getMetadata, getMetadata, arginfo_class_PharData_getMetadata, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, getModified, getModified, arginfo_class_PharData_getModified, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, getSignature, getSignature, arginfo_class_PharData_getSignature, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, getStub, getStub, arginfo_class_PharData_getStub, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, getVersion, getVersion, arginfo_class_PharData_getVersion, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, hasMetadata, hasMetadata, arginfo_class_PharData_hasMetadata, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, isBuffering, isBuffering, arginfo_class_PharData_isBuffering, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, isCompressed, isCompressed, arginfo_class_PharData_isCompressed, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, isFileFormat, isFileFormat, arginfo_class_PharData_isFileFormat, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, isWritable, isWritable, arginfo_class_PharData_isWritable, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, offsetExists, offsetExists, arginfo_class_PharData_offsetExists, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, offsetGet, offsetGet, arginfo_class_PharData_offsetGet, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, offsetSet, offsetSet, arginfo_class_PharData_offsetSet, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, offsetUnset, offsetUnset, arginfo_class_PharData_offsetUnset, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, setAlias, setAlias, arginfo_class_PharData_setAlias, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, setDefaultStub, setDefaultStub, arginfo_class_PharData_setDefaultStub, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, setMetadata, setMetadata, arginfo_class_PharData_setMetadata, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, setSignatureAlgorithm, setSignatureAlgorithm, arginfo_class_PharData_setSignatureAlgorithm, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, setStub, setStub, arginfo_class_PharData_setStub, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, startBuffering, startBuffering, arginfo_class_PharData_startBuffering, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, stopBuffering, stopBuffering, arginfo_class_PharData_stopBuffering, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(Phar, apiVersion, apiVersion, arginfo_class_PharData_apiVersion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_MALIAS(Phar, canCompress, canCompress, arginfo_class_PharData_canCompress, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_MALIAS(Phar, canWrite, canWrite, arginfo_class_PharData_canWrite, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_MALIAS(Phar, createDefaultStub, createDefaultStub, arginfo_class_PharData_createDefaultStub, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_MALIAS(Phar, getSupportedCompression, getSupportedCompression, arginfo_class_PharData_getSupportedCompression, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_MALIAS(Phar, getSupportedSignatures, getSupportedSignatures, arginfo_class_PharData_getSupportedSignatures, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_MALIAS(Phar, interceptFileFuncs, interceptFileFuncs, arginfo_class_PharData_interceptFileFuncs, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_MALIAS(Phar, isValidPharFilename, isValidPharFilename, arginfo_class_PharData_isValidPharFilename, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_MALIAS(Phar, loadPhar, loadPhar, arginfo_class_PharData_loadPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_MALIAS(Phar, mapPhar, mapPhar, arginfo_class_PharData_mapPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_MALIAS(Phar, running, running, arginfo_class_PharData_running, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_MALIAS(Phar, mount, mount, arginfo_class_PharData_mount, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_MALIAS(Phar, mungServer, mungServer, arginfo_class_PharData_mungServer, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_MALIAS(Phar, unlinkArchive, unlinkArchive, arginfo_class_PharData_unlinkArchive, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_MALIAS(Phar, webPhar, webPhar, arginfo_class_PharData_webPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_PharFileInfo_methods[] = {
+ ZEND_ME(PharFileInfo, __construct, arginfo_class_PharFileInfo___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(PharFileInfo, __destruct, arginfo_class_PharFileInfo___destruct, ZEND_ACC_PUBLIC)
+ ZEND_ME(PharFileInfo, chmod, arginfo_class_PharFileInfo_chmod, ZEND_ACC_PUBLIC)
+ ZEND_ME(PharFileInfo, compress, arginfo_class_PharFileInfo_compress, ZEND_ACC_PUBLIC)
+ ZEND_ME(PharFileInfo, decompress, arginfo_class_PharFileInfo_decompress, ZEND_ACC_PUBLIC)
+ ZEND_ME(PharFileInfo, delMetadata, arginfo_class_PharFileInfo_delMetadata, ZEND_ACC_PUBLIC)
+ ZEND_ME(PharFileInfo, getCompressedSize, arginfo_class_PharFileInfo_getCompressedSize, ZEND_ACC_PUBLIC)
+ ZEND_ME(PharFileInfo, getCRC32, arginfo_class_PharFileInfo_getCRC32, ZEND_ACC_PUBLIC)
+ ZEND_ME(PharFileInfo, getContent, arginfo_class_PharFileInfo_getContent, ZEND_ACC_PUBLIC)
+ ZEND_ME(PharFileInfo, getMetadata, arginfo_class_PharFileInfo_getMetadata, ZEND_ACC_PUBLIC)
+ ZEND_ME(PharFileInfo, getPharFlags, arginfo_class_PharFileInfo_getPharFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(PharFileInfo, hasMetadata, arginfo_class_PharFileInfo_hasMetadata, ZEND_ACC_PUBLIC)
+ ZEND_ME(PharFileInfo, isCompressed, arginfo_class_PharFileInfo_isCompressed, ZEND_ACC_PUBLIC)
+ ZEND_ME(PharFileInfo, isCRCChecked, arginfo_class_PharFileInfo_isCRCChecked, ZEND_ACC_PUBLIC)
+ ZEND_ME(PharFileInfo, setMetadata, arginfo_class_PharFileInfo_setMetadata, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};