]> granicus.if.org Git - php/commitdiff
Generate method entries from stubs for curl, ffi, pdo, phar
authorMáté Kocsis <kocsismate@woohoolabs.com>
Sun, 12 Apr 2020 16:50:41 +0000 (18:50 +0200)
committerMáté Kocsis <kocsismate@woohoolabs.com>
Tue, 14 Apr 2020 09:49:02 +0000 (11:49 +0200)
Closes GH-5375

15 files changed:
ext/curl/curl_file.c
ext/curl/curl_file.stub.php
ext/curl/curl_file_arginfo.h
ext/ffi/ffi.c
ext/ffi/ffi.stub.php
ext/ffi/ffi_arginfo.h
ext/pdo/pdo_dbh.c
ext/pdo/pdo_dbh.stub.php
ext/pdo/pdo_dbh_arginfo.h
ext/pdo/pdo_stmt.c
ext/pdo/pdo_stmt.stub.php
ext/pdo/pdo_stmt_arginfo.h
ext/phar/phar_object.c
ext/phar/phar_object.stub.php
ext/phar/phar_object_arginfo.h

index e034babd0feada7a6ef91dc2fc727bc7a9630e46..3f4fe03fa42adbb4e2d529c3faeb86d168bc47a8 100644 (file)
@@ -128,20 +128,10 @@ ZEND_METHOD(CURLFile, setPostFilename)
 }
 /* }}} */
 
-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;
index e1b289bd975aa0c75fc1c8675714aef8578814b9..8b3f46d259fdb196c926348d20e34c98d11f73df 100644 (file)
@@ -1,5 +1,7 @@
 <?php
 
+/** @generate-function-entries */
+
 class CURLFile
 {
     public function __construct(
index df50ab29dd81c0cda0dc9cc7b696067831f873d5..a3fc79b35ac738e32f64cfe81ab35e685d1ca776 100644 (file)
@@ -20,3 +20,22 @@ ZEND_END_ARG_INFO()
 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
+};
index 3d1eaaf831aa92231d3095c3797001943a61d178..95ae8e3711dbdf506fe14128b3784b06836a21e7 100644 (file)
@@ -4429,27 +4429,6 @@ ZEND_METHOD(FFI, isNull) /* {{{ */
 }
 /* }}} */
 
-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;
@@ -4887,7 +4866,7 @@ ZEND_MINIT_FUNCTION(ffi)
        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;
index 384a89ad08197a2e5e22de185fbeb9d66f80be3a..4d3100579e93526ff38ac85ef08b7c52cec7972a 100644 (file)
@@ -1,5 +1,7 @@
 <?php
 
+/** @generate-function-entries */
+
 final class FFI
 {
     public static function cdef(string $code = UNKNOWN, string $lib = UNKNOWN): ?FFI {}
index 6d91fc4a9b2aad7ea62103e3d453f0a364a2649a..960c3e39650245a2bf099b75544480b040fcdf66 100644 (file)
@@ -77,3 +77,44 @@ ZEND_END_ARG_INFO()
 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
+};
index 7f877f271f2c20c5556025f9ade643ef4922edc3..56940395936a94f3f6ef52c87a699ebd5f9783a4 100644 (file)
@@ -192,7 +192,7 @@ static char *dsn_from_uri(char *uri, char *buf, size_t buflen) /* {{{ */
 
 /* {{{ 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;
@@ -456,7 +456,7 @@ static void pdo_stmt_construct(zend_execute_data *execute_data, pdo_stmt_t *stmt
 
 /* {{{ 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;
@@ -556,7 +556,7 @@ static PHP_METHOD(PDO, prepare)
 
 /* {{{ 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);
 
@@ -588,7 +588,7 @@ static PHP_METHOD(PDO, beginTransaction)
 
 /* {{{ 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);
 
@@ -613,7 +613,7 @@ static PHP_METHOD(PDO, commit)
 
 /* {{{ 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);
 
@@ -638,7 +638,7 @@ static PHP_METHOD(PDO, rollBack)
 
 /* {{{ 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);
 
@@ -810,7 +810,7 @@ fail:
 
 /* {{{ 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;
@@ -833,7 +833,7 @@ static PHP_METHOD(PDO, setAttribute)
 
 /* {{{ 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;
@@ -898,7 +898,7 @@ static PHP_METHOD(PDO, getAttribute)
 
 /* {{{ 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;
@@ -927,7 +927,7 @@ static PHP_METHOD(PDO, exec)
 
 /* {{{ 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;
@@ -961,7 +961,7 @@ static PHP_METHOD(PDO, lastInsertId)
 
 /* {{{ 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);
 
@@ -987,7 +987,7 @@ static PHP_METHOD(PDO, errorCode)
 
 /* {{{ 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;
@@ -1034,7 +1034,7 @@ fill_array:
 
 /* {{{ 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;
@@ -1115,7 +1115,7 @@ static PHP_METHOD(PDO, query)
 
 /* {{{ 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;
@@ -1149,7 +1149,7 @@ static PHP_METHOD(PDO, quote)
 
 /* {{{ proto array PDO::getAvailableDrivers()
    Return array of available PDO drivers */
-static PHP_METHOD(PDO, getAvailableDrivers)
+PHP_METHOD(PDO, getAvailableDrivers)
 {
        pdo_driver_t *pdriver;
 
@@ -1163,26 +1163,6 @@ static PHP_METHOD(PDO, getAvailableDrivers)
 }
 /* }}} */
 
-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) {
@@ -1316,7 +1296,7 @@ void pdo_dbh_init(void)
 {
        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;
index 01a3b2b09aa582f8b72668fcb623a05c07ebb581..a743fb3a20a6acec013cf24b2e7ba8d5335ae2c4 100644 (file)
@@ -1,7 +1,10 @@
 <?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 */
index 833d60099a729ebff00c788a1cdf527319b5e3d4..e82bf0c18ece301092fd8d1f277fa663bcb59693 100644 (file)
@@ -50,3 +50,40 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_class_PDO_setAttribute, 0, 0, 2)
        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
+};
index e258ed194c808db9b6b48ffc6bf101328ab57c18..42cc447608e24c578d123b8a31df2a19be8dd439 100644 (file)
@@ -345,7 +345,7 @@ static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_s
 
 /* {{{ 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;
@@ -1168,7 +1168,7 @@ static int pdo_stmt_verify_mode(pdo_stmt_t *stmt, zend_long mode, int fetch_all)
 
 /* {{{ 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;
@@ -1197,7 +1197,7 @@ static PHP_METHOD(PDOStatement, fetch)
 
 /* {{{ 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;
@@ -1264,7 +1264,7 @@ static PHP_METHOD(PDOStatement, fetchObject)
 
 /* {{{ 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;
@@ -1287,7 +1287,7 @@ static PHP_METHOD(PDOStatement, fetchColumn)
 
 /* {{{ 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;
@@ -1493,7 +1493,7 @@ static int register_bound_param(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt,
 
 /* {{{ 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;
@@ -1534,7 +1534,7 @@ static PHP_METHOD(PDOStatement, bindValue)
 
 /* {{{ 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));
@@ -1543,7 +1543,7 @@ static PHP_METHOD(PDOStatement, bindParam)
 
 /* {{{ 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));
@@ -1552,7 +1552,7 @@ static PHP_METHOD(PDOStatement, bindColumn)
 
 /* {{{ 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;
 
@@ -1564,7 +1564,7 @@ static PHP_METHOD(PDOStatement, rowCount)
 
 /* {{{ 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;
 
@@ -1580,7 +1580,7 @@ static PHP_METHOD(PDOStatement, errorCode)
 
 /* {{{ 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;
@@ -1612,7 +1612,7 @@ static PHP_METHOD(PDOStatement, errorInfo)
 
 /* {{{ 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;
@@ -1655,7 +1655,7 @@ static int generic_stmt_attr_get(pdo_stmt_t *stmt, zval *return_value, zend_long
        return 0;
 }
 
-static PHP_METHOD(PDOStatement, getAttribute)
+PHP_METHOD(PDOStatement, getAttribute)
 {
        zend_long attr;
        PHP_STMT_GET_OBJ;
@@ -1696,7 +1696,7 @@ static PHP_METHOD(PDOStatement, getAttribute)
 
 /* {{{ 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;
 
@@ -1708,7 +1708,7 @@ static PHP_METHOD(PDOStatement, columnCount)
 
 /* {{{ 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;
@@ -1917,7 +1917,7 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in
        return retval;
 }
 
-static PHP_METHOD(PDOStatement, setFetchMode)
+PHP_METHOD(PDOStatement, setFetchMode)
 {
        PHP_STMT_GET_OBJ;
 
@@ -1959,7 +1959,7 @@ static int pdo_stmt_do_next_rowset(pdo_stmt_t *stmt)
        return 1;
 }
 
-static PHP_METHOD(PDOStatement, nextRowset)
+PHP_METHOD(PDOStatement, nextRowset)
 {
        PHP_STMT_GET_OBJ;
 
@@ -1983,7 +1983,7 @@ static PHP_METHOD(PDOStatement, nextRowset)
 
 /* {{{ 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;
 
@@ -2020,7 +2020,7 @@ static PHP_METHOD(PDOStatement, closeCursor)
 
 /* {{{ 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();
 
@@ -2078,28 +2078,6 @@ static PHP_METHOD(PDOStatement, debugDumpParams)
        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)
@@ -2357,10 +2335,6 @@ zend_object_iterator *pdo_stmt_iter_get(zend_class_entry *ce, zval *object, int
 
 /* {{{ 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;
@@ -2610,7 +2584,7 @@ void pdo_stmt_init(void)
 {
        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;
@@ -2629,7 +2603,7 @@ void pdo_stmt_init(void)
        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;
index 57d302fef48aa78b15230e037e1df9233e0611d2..fe87ffc40daa3872c223ce9ded8e0ecdededbb52 100644 (file)
@@ -1,5 +1,7 @@
 <?php
 
+/** @generate-function-entries */
+
 class PDOStatement implements Traversable
 {
     /**
@@ -75,3 +77,7 @@ class PDOStatement implements Traversable
     /** @return bool */
     public function setFetchMode(int $mode, $param1 = UNKNOWN, $param2 = UNKNOWN) {}
 }
+
+final class PDORow
+{
+}
index 604b95a9ea716553d02aee3d34873d7e6be0a54e..2f4a9f63c10812893c16a534ebbeeae3476c40a2 100644 (file)
@@ -80,3 +80,53 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_class_PDOStatement_setFetchMode, 0, 0, 1)
        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
+};
index b246167ed8ba6ba4f502364ff6975a7f9a1be0a6..f1a7ade1fd2c11214cf89c226622722addb1a055 100644 (file)
@@ -5158,152 +5158,6 @@ PHP_METHOD(PharFileInfo, decompress)
 
 /* {{{ 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);
 
@@ -5311,20 +5165,20 @@ void phar_object_init(void) /* {{{ */
 {
        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)
index 80a9128f118a77836b93a1ecaf256efdd56062fb..f3439d851a235722bf86253ea27da64345761946 100644 (file)
@@ -1,5 +1,11 @@
 <?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) {}
@@ -179,103 +185,191 @@ class Phar extends RecursiveDirectoryIterator implements Countable, ArrayAccess
 
 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) {}
 
@@ -283,72 +377,106 @@ class PharData extends RecursiveDirectoryIterator implements Countable, ArrayAcc
      * @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 {}
index 5f096eb0aceef6b1495d50655b96a4dd03967e9a..c0cf1a9c63f5489a4ce16479bd58d2967abd5edc 100644 (file)
@@ -358,3 +358,223 @@ ZEND_END_ARG_INFO()
 #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
+};