From 4815be44db6b7a73cabfa872dc17d7e1574e1930 Mon Sep 17 00:00:00 2001
From: =?utf8?q?M=C3=A1t=C3=A9=20Kocsis?= <kocsismate@woohoolabs.com>
Date: Sun, 19 Apr 2020 20:05:16 +0200
Subject: [PATCH] Generate function entries from stubs

Converts ext/pcntl, ext/simplexml, ext/snmp, ext/soap, ext/sqlite3.
Closes GH-5421
---
 ext/pcntl/pcntl.c                 |  45 +--------
 ext/pcntl/pcntl.stub.php          |   4 +-
 ext/pcntl/pcntl_arginfo.h         |  90 +++++++++++++++++-
 ext/simplexml/simplexml.c         |  35 +------
 ext/simplexml/simplexml.stub.php  |   7 +-
 ext/simplexml/simplexml_arginfo.h |  45 +++++++++
 ext/simplexml/sxe.c               |  28 ++----
 ext/simplexml/sxe.stub.php        |   2 +
 ext/simplexml/sxe_arginfo.h       |  21 +++++
 ext/snmp/php_snmp.h               |  36 -------
 ext/snmp/snmp.c                   |  72 +++-----------
 ext/snmp/snmp.stub.php            |   2 +
 ext/snmp/snmp_arginfo.h           |  76 +++++++++++++++
 ext/soap/soap.c                   | 121 ++----------------------
 ext/soap/soap.stub.php            |  63 +++++++------
 ext/soap/soap_arginfo.h           |  96 +++++++++++++++++++
 ext/sqlite3/sqlite3.c             | 150 +++++++++---------------------
 ext/sqlite3/sqlite3.stub.php      |  14 ++-
 ext/sqlite3/sqlite3_arginfo.h     | 108 +++++++++++++++++++++
 19 files changed, 563 insertions(+), 452 deletions(-)

diff --git a/ext/pcntl/pcntl.c b/ext/pcntl/pcntl.c
index a4554a61cd..a52429e549 100644
--- a/ext/pcntl/pcntl.c
+++ b/ext/pcntl/pcntl.c
@@ -57,53 +57,10 @@
 ZEND_DECLARE_MODULE_GLOBALS(pcntl)
 static PHP_GINIT_FUNCTION(pcntl);
 
-static const zend_function_entry pcntl_functions[] = {
-	PHP_FE(pcntl_fork,			arginfo_pcntl_fork)
-	PHP_FE(pcntl_waitpid,		arginfo_pcntl_waitpid)
-	PHP_FE(pcntl_wait,			arginfo_pcntl_wait)
-	PHP_FE(pcntl_signal,		arginfo_pcntl_signal)
-	PHP_FE(pcntl_signal_get_handler,		arginfo_pcntl_signal_get_handler)
-	PHP_FE(pcntl_signal_dispatch,	arginfo_pcntl_signal_dispatch)
-	PHP_FE(pcntl_wifexited,		arginfo_pcntl_wifexited)
-	PHP_FE(pcntl_wifstopped,	arginfo_pcntl_wifstopped)
-	PHP_FE(pcntl_wifsignaled,	arginfo_pcntl_wifsignaled)
-	PHP_FE(pcntl_wexitstatus,	arginfo_pcntl_wifexitstatus)
-	PHP_FE(pcntl_wtermsig,		arginfo_pcntl_wtermsig)
-	PHP_FE(pcntl_wstopsig,		arginfo_pcntl_wstopsig)
-	PHP_FE(pcntl_exec,			arginfo_pcntl_exec)
-	PHP_FE(pcntl_alarm,			arginfo_pcntl_alarm)
-	PHP_FE(pcntl_get_last_error,	arginfo_pcntl_get_last_error)
-	PHP_FALIAS(pcntl_errno, pcntl_get_last_error,	arginfo_pcntl_errno)
-	PHP_FE(pcntl_strerror,		arginfo_pcntl_strerror)
-#ifdef HAVE_GETPRIORITY
-	PHP_FE(pcntl_getpriority,	arginfo_pcntl_getpriority)
-#endif
-#ifdef HAVE_SETPRIORITY
-	PHP_FE(pcntl_setpriority,	arginfo_pcntl_setpriority)
-#endif
-#ifdef HAVE_SIGPROCMASK
-	PHP_FE(pcntl_sigprocmask,	arginfo_pcntl_sigprocmask)
-#endif
-#ifdef HAVE_STRUCT_SIGINFO_T
-# if HAVE_SIGWAITINFO && HAVE_SIGTIMEDWAIT
-	PHP_FE(pcntl_sigwaitinfo,	arginfo_pcntl_sigwaitinfo)
-	PHP_FE(pcntl_sigtimedwait,	arginfo_pcntl_sigtimedwait)
-# endif
-#endif
-#ifdef HAVE_WCONTINUED
-	PHP_FE(pcntl_wifcontinued,	arginfo_pcntl_wifcontinued)
-#endif
-	PHP_FE(pcntl_async_signals,	arginfo_pcntl_async_signals)
-#ifdef HAVE_UNSHARE
-	PHP_FE(pcntl_unshare,		arginfo_pcntl_unshare)
-#endif
-	PHP_FE_END
-};
-
 zend_module_entry pcntl_module_entry = {
 	STANDARD_MODULE_HEADER,
 	"pcntl",
-	pcntl_functions,
+	ext_functions,
 	PHP_MINIT(pcntl),
 	PHP_MSHUTDOWN(pcntl),
 	PHP_RINIT(pcntl),
diff --git a/ext/pcntl/pcntl.stub.php b/ext/pcntl/pcntl.stub.php
index 82bac57316..60e9c98a7f 100644
--- a/ext/pcntl/pcntl.stub.php
+++ b/ext/pcntl/pcntl.stub.php
@@ -1,5 +1,7 @@
 <?php
 
+/** @generate-function-entries */
+
 function pcntl_fork(): int {}
 
 function pcntl_waitpid(int $pid, &$status, int $options = 0, &$rusage = []): int {}
@@ -38,7 +40,7 @@ function pcntl_wifcontinued(int $status): bool {}
 
 function pcntl_wifsignaled(int $status): bool {}
 
-function pcntl_wifexitstatus(int $status): int|false {}
+function pcntl_wexitstatus(int $status): int|false {}
 
 function pcntl_wtermsig(int $status): int|false {}
 
diff --git a/ext/pcntl/pcntl_arginfo.h b/ext/pcntl/pcntl_arginfo.h
index 19c46e4725..e7dff8e379 100644
--- a/ext/pcntl/pcntl_arginfo.h
+++ b/ext/pcntl/pcntl_arginfo.h
@@ -67,13 +67,13 @@ ZEND_END_ARG_INFO()
 
 #define arginfo_pcntl_wifsignaled arginfo_pcntl_wifexited
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_pcntl_wifexitstatus, 0, 1, MAY_BE_LONG|MAY_BE_FALSE)
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_pcntl_wexitstatus, 0, 1, MAY_BE_LONG|MAY_BE_FALSE)
 	ZEND_ARG_TYPE_INFO(0, status, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
-#define arginfo_pcntl_wtermsig arginfo_pcntl_wifexitstatus
+#define arginfo_pcntl_wtermsig arginfo_pcntl_wexitstatus
 
-#define arginfo_pcntl_wstopsig arginfo_pcntl_wifexitstatus
+#define arginfo_pcntl_wstopsig arginfo_pcntl_wexitstatus
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_pcntl_exec, 0, 1, _IS_BOOL, 0)
 	ZEND_ARG_TYPE_INFO(0, path, IS_STRING, 0)
@@ -117,3 +117,87 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_pcntl_unshare, 0, 1, _IS_BOOL, 0
 	ZEND_ARG_TYPE_INFO(0, flags, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 #endif
+
+
+ZEND_FUNCTION(pcntl_fork);
+ZEND_FUNCTION(pcntl_waitpid);
+ZEND_FUNCTION(pcntl_wait);
+ZEND_FUNCTION(pcntl_signal);
+ZEND_FUNCTION(pcntl_signal_get_handler);
+ZEND_FUNCTION(pcntl_signal_dispatch);
+#if defined(HAVE_SIGPROCMASK)
+ZEND_FUNCTION(pcntl_sigprocmask);
+#endif
+#if defined(HAVE_STRUCT_SIGINFO_T) && HAVE_SIGWAITINFO && HAVE_SIGTIMEDWAIT
+ZEND_FUNCTION(pcntl_sigwaitinfo);
+#endif
+#if defined(HAVE_STRUCT_SIGINFO_T) && HAVE_SIGWAITINFO && HAVE_SIGTIMEDWAIT
+ZEND_FUNCTION(pcntl_sigtimedwait);
+#endif
+ZEND_FUNCTION(pcntl_wifexited);
+ZEND_FUNCTION(pcntl_wifstopped);
+#if defined(HAVE_WCONTINUED)
+ZEND_FUNCTION(pcntl_wifcontinued);
+#endif
+ZEND_FUNCTION(pcntl_wifsignaled);
+ZEND_FUNCTION(pcntl_wexitstatus);
+ZEND_FUNCTION(pcntl_wtermsig);
+ZEND_FUNCTION(pcntl_wstopsig);
+ZEND_FUNCTION(pcntl_exec);
+ZEND_FUNCTION(pcntl_alarm);
+ZEND_FUNCTION(pcntl_get_last_error);
+#if defined(HAVE_GETPRIORITY)
+ZEND_FUNCTION(pcntl_getpriority);
+#endif
+#if defined(HAVE_SETPRIORITY)
+ZEND_FUNCTION(pcntl_setpriority);
+#endif
+ZEND_FUNCTION(pcntl_strerror);
+ZEND_FUNCTION(pcntl_async_signals);
+#if defined(HAVE_UNSHARE)
+ZEND_FUNCTION(pcntl_unshare);
+#endif
+
+
+static const zend_function_entry ext_functions[] = {
+	ZEND_FE(pcntl_fork, arginfo_pcntl_fork)
+	ZEND_FE(pcntl_waitpid, arginfo_pcntl_waitpid)
+	ZEND_FE(pcntl_wait, arginfo_pcntl_wait)
+	ZEND_FE(pcntl_signal, arginfo_pcntl_signal)
+	ZEND_FE(pcntl_signal_get_handler, arginfo_pcntl_signal_get_handler)
+	ZEND_FE(pcntl_signal_dispatch, arginfo_pcntl_signal_dispatch)
+#if defined(HAVE_SIGPROCMASK)
+	ZEND_FE(pcntl_sigprocmask, arginfo_pcntl_sigprocmask)
+#endif
+#if defined(HAVE_STRUCT_SIGINFO_T) && HAVE_SIGWAITINFO && HAVE_SIGTIMEDWAIT
+	ZEND_FE(pcntl_sigwaitinfo, arginfo_pcntl_sigwaitinfo)
+#endif
+#if defined(HAVE_STRUCT_SIGINFO_T) && HAVE_SIGWAITINFO && HAVE_SIGTIMEDWAIT
+	ZEND_FE(pcntl_sigtimedwait, arginfo_pcntl_sigtimedwait)
+#endif
+	ZEND_FE(pcntl_wifexited, arginfo_pcntl_wifexited)
+	ZEND_FE(pcntl_wifstopped, arginfo_pcntl_wifstopped)
+#if defined(HAVE_WCONTINUED)
+	ZEND_FE(pcntl_wifcontinued, arginfo_pcntl_wifcontinued)
+#endif
+	ZEND_FE(pcntl_wifsignaled, arginfo_pcntl_wifsignaled)
+	ZEND_FE(pcntl_wexitstatus, arginfo_pcntl_wexitstatus)
+	ZEND_FE(pcntl_wtermsig, arginfo_pcntl_wtermsig)
+	ZEND_FE(pcntl_wstopsig, arginfo_pcntl_wstopsig)
+	ZEND_FE(pcntl_exec, arginfo_pcntl_exec)
+	ZEND_FE(pcntl_alarm, arginfo_pcntl_alarm)
+	ZEND_FE(pcntl_get_last_error, arginfo_pcntl_get_last_error)
+	ZEND_FALIAS(pcntl_errno, pcntl_get_last_error, arginfo_pcntl_errno)
+#if defined(HAVE_GETPRIORITY)
+	ZEND_FE(pcntl_getpriority, arginfo_pcntl_getpriority)
+#endif
+#if defined(HAVE_SETPRIORITY)
+	ZEND_FE(pcntl_setpriority, arginfo_pcntl_setpriority)
+#endif
+	ZEND_FE(pcntl_strerror, arginfo_pcntl_strerror)
+	ZEND_FE(pcntl_async_signals, arginfo_pcntl_async_signals)
+#if defined(HAVE_UNSHARE)
+	ZEND_FE(pcntl_unshare, arginfo_pcntl_unshare)
+#endif
+	ZEND_FE_END
+};
diff --git a/ext/simplexml/simplexml.c b/ext/simplexml/simplexml.c
index f44c268286..5f23c48026 100644
--- a/ext/simplexml/simplexml.c
+++ b/ext/simplexml/simplexml.c
@@ -44,7 +44,7 @@ PHP_SXE_API zend_class_entry *sxe_get_element_class_entry() /* {{{ */
 #define SXE_ME(func, arg_info, flags) PHP_ME(simplexml_element, func, arg_info, flags)
 #define SXE_MALIAS(func, alias, arg_info, flags) PHP_MALIAS(simplexml_element, func, alias, arg_info, flags)
 
-#define SXE_METHOD(func) PHP_METHOD(simplexml_element, func)
+#define SXE_METHOD(func) PHP_METHOD(SimpleXMLElement, func)
 
 static php_sxe_object* php_sxe_object_new(zend_class_entry *ce, zend_function *fptr_count);
 static xmlNodePtr php_sxe_reset_iterator(php_sxe_object *sxe, int use_data);
@@ -2576,14 +2576,6 @@ PHP_FUNCTION(simplexml_import_dom)
 }
 /* }}} */
 
-static const zend_function_entry simplexml_functions[] = { /* {{{ */
-	PHP_FE(simplexml_load_file, 	arginfo_simplexml_load_file)
-	PHP_FE(simplexml_load_string,	arginfo_simplexml_load_string)
-	PHP_FE(simplexml_import_dom,	arginfo_simplexml_import_dom)
-	PHP_FE_END
-};
-/* }}} */
-
 static const zend_module_dep simplexml_deps[] = { /* {{{ */
 	ZEND_MOD_REQUIRED("libxml")
 	ZEND_MOD_REQUIRED("spl")
@@ -2595,7 +2587,7 @@ zend_module_entry simplexml_module_entry = { /* {{{ */
 	STANDARD_MODULE_HEADER_EX, NULL,
 	simplexml_deps,
 	"SimpleXML",
-	simplexml_functions,
+	ext_functions,
 	PHP_MINIT(simplexml),
 	PHP_MSHUTDOWN(simplexml),
 	NULL,
@@ -2610,34 +2602,13 @@ zend_module_entry simplexml_module_entry = { /* {{{ */
 ZEND_GET_MODULE(simplexml)
 #endif
 
-/* the method table */
-/* each method can have its own parameters and visibility */
-static const zend_function_entry sxe_functions[] = { /* {{{ */
-	SXE_ME(__construct,            arginfo_class_SimpleXMLElement___construct, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) /* must be called */
-	SXE_ME(asXML,                  arginfo_class_SimpleXMLElement_asXML, ZEND_ACC_PUBLIC)
-	SXE_MALIAS(saveXML, asXML,	   arginfo_class_SimpleXMLElement_saveXML, ZEND_ACC_PUBLIC)
-	SXE_ME(xpath,                  arginfo_class_SimpleXMLElement_xpath, ZEND_ACC_PUBLIC)
-	SXE_ME(registerXPathNamespace, arginfo_class_SimpleXMLElement_registerXPathNamespace, ZEND_ACC_PUBLIC)
-	SXE_ME(attributes,             arginfo_class_SimpleXMLElement_attributes, ZEND_ACC_PUBLIC)
-	SXE_ME(children,               arginfo_class_SimpleXMLElement_children, ZEND_ACC_PUBLIC)
-	SXE_ME(getNamespaces,          arginfo_class_SimpleXMLElement_getNamespaces, ZEND_ACC_PUBLIC)
-	SXE_ME(getDocNamespaces,       arginfo_class_SimpleXMLElement_getDocNamespaces, ZEND_ACC_PUBLIC)
-	SXE_ME(getName,                arginfo_class_SimpleXMLElement_getName, ZEND_ACC_PUBLIC)
-	SXE_ME(addChild,               arginfo_class_SimpleXMLElement_addChild, ZEND_ACC_PUBLIC)
-	SXE_ME(addAttribute,           arginfo_class_SimpleXMLElement_addAttribute, ZEND_ACC_PUBLIC)
-	SXE_ME(__toString,             arginfo_class_SimpleXMLElement___toString, ZEND_ACC_PUBLIC)
-	SXE_ME(count,                  arginfo_class_SimpleXMLElement_count, ZEND_ACC_PUBLIC)
-	PHP_FE_END
-};
-/* }}} */
-
 /* {{{ PHP_MINIT_FUNCTION(simplexml)
  */
 PHP_MINIT_FUNCTION(simplexml)
 {
 	zend_class_entry sxe;
 
-	INIT_CLASS_ENTRY(sxe, "SimpleXMLElement", sxe_functions);
+	INIT_CLASS_ENTRY(sxe, "SimpleXMLElement", class_SimpleXMLElement_methods);
 	sxe.create_object = sxe_object_new;
 	sxe_class_entry = zend_register_internal_class(&sxe);
 	sxe_class_entry->get_iterator = php_sxe_get_iterator;
diff --git a/ext/simplexml/simplexml.stub.php b/ext/simplexml/simplexml.stub.php
index f78694c139..68eaf2be6e 100644
--- a/ext/simplexml/simplexml.stub.php
+++ b/ext/simplexml/simplexml.stub.php
@@ -1,5 +1,7 @@
 <?php
 
+/** @generate-function-entries */
+
 function simplexml_load_file(string $filename, ?string $class_name = SimpleXMLElement::class, int $options = 0, string $ns = '', bool $is_prefix = false): SimpleXMLElement|false {}
 
 function simplexml_load_string(string $data, ?string $class_name = SimpleXMLElement::class, int $options = 0, string $ns = '', bool $is_prefix = false): SimpleXMLElement|false {}
@@ -17,7 +19,10 @@ class SimpleXMLElement implements Stringable
     /** @return string|bool */
     public function asXML(string $filename = UNKNOWN) {}
 
-    /** @return string|bool */
+    /**
+     * @return string|bool
+     * @alias SimpleXMLElement::asXML
+     */
     public function saveXML(string $filename = UNKNOWN) {}
 
     /** @return array */
diff --git a/ext/simplexml/simplexml_arginfo.h b/ext/simplexml/simplexml_arginfo.h
index c77878c927..1a38450764 100644
--- a/ext/simplexml/simplexml_arginfo.h
+++ b/ext/simplexml/simplexml_arginfo.h
@@ -75,3 +75,48 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_SimpleXMLElement___toStrin
 ZEND_END_ARG_INFO()
 
 #define arginfo_class_SimpleXMLElement_count arginfo_class_SimpleXMLElement_getName
+
+
+ZEND_FUNCTION(simplexml_load_file);
+ZEND_FUNCTION(simplexml_load_string);
+ZEND_FUNCTION(simplexml_import_dom);
+ZEND_METHOD(SimpleXMLElement, xpath);
+ZEND_METHOD(SimpleXMLElement, registerXPathNamespace);
+ZEND_METHOD(SimpleXMLElement, asXML);
+ZEND_METHOD(SimpleXMLElement, getNamespaces);
+ZEND_METHOD(SimpleXMLElement, getDocNamespaces);
+ZEND_METHOD(SimpleXMLElement, children);
+ZEND_METHOD(SimpleXMLElement, attributes);
+ZEND_METHOD(SimpleXMLElement, __construct);
+ZEND_METHOD(SimpleXMLElement, addChild);
+ZEND_METHOD(SimpleXMLElement, addAttribute);
+ZEND_METHOD(SimpleXMLElement, getName);
+ZEND_METHOD(SimpleXMLElement, __toString);
+ZEND_METHOD(SimpleXMLElement, count);
+
+
+static const zend_function_entry ext_functions[] = {
+	ZEND_FE(simplexml_load_file, arginfo_simplexml_load_file)
+	ZEND_FE(simplexml_load_string, arginfo_simplexml_load_string)
+	ZEND_FE(simplexml_import_dom, arginfo_simplexml_import_dom)
+	ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SimpleXMLElement_methods[] = {
+	ZEND_ME(SimpleXMLElement, xpath, arginfo_class_SimpleXMLElement_xpath, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLElement, registerXPathNamespace, arginfo_class_SimpleXMLElement_registerXPathNamespace, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLElement, asXML, arginfo_class_SimpleXMLElement_asXML, ZEND_ACC_PUBLIC)
+	ZEND_MALIAS(SimpleXMLElement, saveXML, asXML, arginfo_class_SimpleXMLElement_saveXML, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLElement, getNamespaces, arginfo_class_SimpleXMLElement_getNamespaces, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLElement, getDocNamespaces, arginfo_class_SimpleXMLElement_getDocNamespaces, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLElement, children, arginfo_class_SimpleXMLElement_children, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLElement, attributes, arginfo_class_SimpleXMLElement_attributes, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLElement, __construct, arginfo_class_SimpleXMLElement___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLElement, addChild, arginfo_class_SimpleXMLElement_addChild, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLElement, addAttribute, arginfo_class_SimpleXMLElement_addAttribute, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLElement, getName, arginfo_class_SimpleXMLElement_getName, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLElement, __toString, arginfo_class_SimpleXMLElement___toString, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLElement, count, arginfo_class_SimpleXMLElement_count, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
diff --git a/ext/simplexml/sxe.c b/ext/simplexml/sxe.c
index 8c9d050dcb..66ff567249 100644
--- a/ext/simplexml/sxe.c
+++ b/ext/simplexml/sxe.c
@@ -36,7 +36,7 @@ PHP_SXE_API zend_class_entry *ce_SimpleXMLElement;
 
 /* {{{ proto void SimpleXMLIterator::rewind()
  Rewind to first element */
-PHP_METHOD(ce_SimpleXMLIterator, rewind)
+PHP_METHOD(SimpleXMLIterator, rewind)
 {
 	if (zend_parse_parameters_none() == FAILURE) {
 		RETURN_THROWS();
@@ -48,7 +48,7 @@ PHP_METHOD(ce_SimpleXMLIterator, rewind)
 
 /* {{{ proto bool SimpleXMLIterator::valid()
  Check whether iteration is valid */
-PHP_METHOD(ce_SimpleXMLIterator, valid)
+PHP_METHOD(SimpleXMLIterator, valid)
 {
 	php_sxe_object *sxe = Z_SXEOBJ_P(ZEND_THIS);
 
@@ -62,7 +62,7 @@ PHP_METHOD(ce_SimpleXMLIterator, valid)
 
 /* {{{ proto SimpleXMLIterator SimpleXMLIterator::current()
  Get current element */
-PHP_METHOD(ce_SimpleXMLIterator, current)
+PHP_METHOD(SimpleXMLIterator, current)
 {
 	php_sxe_object *sxe = Z_SXEOBJ_P(ZEND_THIS);
 	zval *data;
@@ -82,7 +82,7 @@ PHP_METHOD(ce_SimpleXMLIterator, current)
 
 /* {{{ proto string SimpleXMLIterator::key()
  Get name of current child element */
-PHP_METHOD(ce_SimpleXMLIterator, key)
+PHP_METHOD(SimpleXMLIterator, key)
 {
 	xmlNodePtr curnode;
 	php_sxe_object *intern;
@@ -108,7 +108,7 @@ PHP_METHOD(ce_SimpleXMLIterator, key)
 
 /* {{{ proto void SimpleXMLIterator::next()
  Move to next element */
-PHP_METHOD(ce_SimpleXMLIterator, next)
+PHP_METHOD(SimpleXMLIterator, next)
 {
 	if (zend_parse_parameters_none() == FAILURE) {
 		RETURN_THROWS();
@@ -120,7 +120,7 @@ PHP_METHOD(ce_SimpleXMLIterator, next)
 
 /* {{{ proto bool SimpleXMLIterator::hasChildren()
  Check whether element has children (elements) */
-PHP_METHOD(ce_SimpleXMLIterator, hasChildren)
+PHP_METHOD(SimpleXMLIterator, hasChildren)
 {
 	php_sxe_object *sxe = Z_SXEOBJ_P(ZEND_THIS);
 	php_sxe_object *child;
@@ -148,7 +148,7 @@ PHP_METHOD(ce_SimpleXMLIterator, hasChildren)
 
 /* {{{ proto SimpleXMLIterator SimpleXMLIterator::getChildren()
  Get child element iterator */
-PHP_METHOD(ce_SimpleXMLIterator, getChildren)
+PHP_METHOD(SimpleXMLIterator, getChildren)
 {
 	php_sxe_object *sxe = Z_SXEOBJ_P(ZEND_THIS);
 	zval *data;
@@ -165,18 +165,6 @@ PHP_METHOD(ce_SimpleXMLIterator, getChildren)
 	ZVAL_COPY_DEREF(return_value, data);
 }
 
-static const zend_function_entry funcs_SimpleXMLIterator[] = {
-	PHP_ME(ce_SimpleXMLIterator, rewind,                 arginfo_class_SimpleXMLIterator_rewind, ZEND_ACC_PUBLIC)
-	PHP_ME(ce_SimpleXMLIterator, valid,                  arginfo_class_SimpleXMLIterator_valid, ZEND_ACC_PUBLIC)
-	PHP_ME(ce_SimpleXMLIterator, current,                arginfo_class_SimpleXMLIterator_current, ZEND_ACC_PUBLIC)
-	PHP_ME(ce_SimpleXMLIterator, key,                    arginfo_class_SimpleXMLIterator_key, ZEND_ACC_PUBLIC)
-	PHP_ME(ce_SimpleXMLIterator, next,                   arginfo_class_SimpleXMLIterator_next, ZEND_ACC_PUBLIC)
-	PHP_ME(ce_SimpleXMLIterator, hasChildren,            arginfo_class_SimpleXMLIterator_hasChildren, ZEND_ACC_PUBLIC)
-	PHP_ME(ce_SimpleXMLIterator, getChildren,            arginfo_class_SimpleXMLIterator_getChildren, ZEND_ACC_PUBLIC)
-	PHP_FE_END
-};
-/* }}} */
-
 PHP_MINIT_FUNCTION(sxe) /* {{{ */
 {
 	zend_class_entry *pce;
@@ -190,7 +178,7 @@ PHP_MINIT_FUNCTION(sxe) /* {{{ */
 
 	ce_SimpleXMLElement = pce;
 
-	INIT_CLASS_ENTRY_EX(sxi, "SimpleXMLIterator", sizeof("SimpleXMLIterator") - 1, funcs_SimpleXMLIterator);
+	INIT_CLASS_ENTRY_EX(sxi, "SimpleXMLIterator", sizeof("SimpleXMLIterator") - 1, class_SimpleXMLIterator_methods);
 	ce_SimpleXMLIterator = zend_register_internal_class_ex(&sxi, ce_SimpleXMLElement);
 	ce_SimpleXMLIterator->create_object = ce_SimpleXMLElement->create_object;
 
diff --git a/ext/simplexml/sxe.stub.php b/ext/simplexml/sxe.stub.php
index d609e93846..a6e24dbc5c 100644
--- a/ext/simplexml/sxe.stub.php
+++ b/ext/simplexml/sxe.stub.php
@@ -1,5 +1,7 @@
 <?php
 
+/** @generate-function-entries */
+
 class SimpleXMLIterator
 {
     /** @return void */
diff --git a/ext/simplexml/sxe_arginfo.h b/ext/simplexml/sxe_arginfo.h
index d3b0c6c479..c21cf3da24 100644
--- a/ext/simplexml/sxe_arginfo.h
+++ b/ext/simplexml/sxe_arginfo.h
@@ -14,3 +14,24 @@ ZEND_END_ARG_INFO()
 #define arginfo_class_SimpleXMLIterator_hasChildren arginfo_class_SimpleXMLIterator_rewind
 
 #define arginfo_class_SimpleXMLIterator_getChildren arginfo_class_SimpleXMLIterator_rewind
+
+
+ZEND_METHOD(SimpleXMLIterator, rewind);
+ZEND_METHOD(SimpleXMLIterator, valid);
+ZEND_METHOD(SimpleXMLIterator, current);
+ZEND_METHOD(SimpleXMLIterator, key);
+ZEND_METHOD(SimpleXMLIterator, next);
+ZEND_METHOD(SimpleXMLIterator, hasChildren);
+ZEND_METHOD(SimpleXMLIterator, getChildren);
+
+
+static const zend_function_entry class_SimpleXMLIterator_methods[] = {
+	ZEND_ME(SimpleXMLIterator, rewind, arginfo_class_SimpleXMLIterator_rewind, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLIterator, valid, arginfo_class_SimpleXMLIterator_valid, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLIterator, current, arginfo_class_SimpleXMLIterator_current, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLIterator, key, arginfo_class_SimpleXMLIterator_key, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLIterator, next, arginfo_class_SimpleXMLIterator_next, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLIterator, hasChildren, arginfo_class_SimpleXMLIterator_hasChildren, ZEND_ACC_PUBLIC)
+	ZEND_ME(SimpleXMLIterator, getChildren, arginfo_class_SimpleXMLIterator_getChildren, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
diff --git a/ext/snmp/php_snmp.h b/ext/snmp/php_snmp.h
index 45c8ae3d0f..25eb67f35a 100644
--- a/ext/snmp/php_snmp.h
+++ b/ext/snmp/php_snmp.h
@@ -44,42 +44,6 @@ PHP_MINIT_FUNCTION(snmp);
 PHP_MSHUTDOWN_FUNCTION(snmp);
 PHP_MINFO_FUNCTION(snmp);
 
-PHP_FUNCTION(snmpget);
-PHP_FUNCTION(snmpgetnext);
-PHP_FUNCTION(snmpwalk);
-PHP_FUNCTION(snmprealwalk);
-PHP_FUNCTION(snmpset);
-PHP_FUNCTION(snmp_get_quick_print);
-PHP_FUNCTION(snmp_set_quick_print);
-PHP_FUNCTION(snmp_set_enum_print);
-PHP_FUNCTION(snmp_set_oid_output_format);
-
-PHP_FUNCTION(snmp2_get);
-PHP_FUNCTION(snmp2_getnext);
-PHP_FUNCTION(snmp2_walk);
-PHP_FUNCTION(snmp2_real_walk);
-PHP_FUNCTION(snmp2_set);
-
-PHP_FUNCTION(snmp3_get);
-PHP_FUNCTION(snmp3_getnext);
-PHP_FUNCTION(snmp3_walk);
-PHP_FUNCTION(snmp3_real_walk);
-PHP_FUNCTION(snmp3_set);
-
-PHP_FUNCTION(snmp_set_valueretrieval);
-PHP_FUNCTION(snmp_get_valueretrieval);
-
-PHP_FUNCTION(snmp_read_mib);
-
-PHP_METHOD(SNMP, setSecurity);
-PHP_METHOD(SNMP, close);
-PHP_METHOD(SNMP, get);
-PHP_METHOD(SNMP, getnext);
-PHP_METHOD(SNMP, walk);
-PHP_METHOD(SNMP, set);
-PHP_METHOD(SNMP, getErrno);
-PHP_METHOD(SNMP, getError);
-
 typedef struct _php_snmp_object {
 	struct snmp_session *session;
 	int max_oids;
diff --git a/ext/snmp/snmp.c b/ext/snmp/snmp.c
index 6c720e2b17..8464e74aad 100644
--- a/ext/snmp/snmp.c
+++ b/ext/snmp/snmp.c
@@ -136,40 +136,6 @@ struct objid_query {
 	snmpobjarg *vars;
 };
 
-/* {{{ snmp_functions[]
- */
-static const zend_function_entry snmp_functions[] = {
-	PHP_FE(snmpget,					arginfo_snmpget)
-	PHP_FE(snmpgetnext, 				arginfo_snmpgetnext)
-	PHP_FE(snmpwalk, 				arginfo_snmpwalk)
-	PHP_FE(snmprealwalk, 				arginfo_snmprealwalk)
-	PHP_FALIAS(snmpwalkoid, snmprealwalk, 		arginfo_snmpwalkoid)
-	PHP_FE(snmpset, 				arginfo_snmpset)
-	PHP_FE(snmp_get_quick_print, 			arginfo_snmp_get_quick_print)
-	PHP_FE(snmp_set_quick_print, 			arginfo_snmp_set_quick_print)
-	PHP_FE(snmp_set_enum_print, 			arginfo_snmp_set_enum_print)
-	PHP_FE(snmp_set_oid_output_format, 		arginfo_snmp_set_oid_output_format)
-	PHP_FALIAS(snmp_set_oid_numeric_print, snmp_set_oid_output_format, arginfo_snmp_set_oid_numeric_print)
-
-	PHP_FE(snmp2_get, 				arginfo_snmp2_get)
-	PHP_FE(snmp2_getnext, 				arginfo_snmp2_getnext)
-	PHP_FE(snmp2_walk, 				arginfo_snmp2_walk)
-	PHP_FE(snmp2_real_walk, 			arginfo_snmp2_real_walk)
-	PHP_FE(snmp2_set, 				arginfo_snmp2_set)
-
-	PHP_FE(snmp3_get, 				arginfo_snmp3_get)
-	PHP_FE(snmp3_getnext, 				arginfo_snmp3_getnext)
-	PHP_FE(snmp3_walk, 				arginfo_snmp3_walk)
-	PHP_FE(snmp3_real_walk, 			arginfo_snmp3_real_walk)
-	PHP_FE(snmp3_set, 				arginfo_snmp3_set)
-	PHP_FE(snmp_set_valueretrieval,			arginfo_snmp_set_valueretrieval)
-	PHP_FE(snmp_get_valueretrieval,			arginfo_snmp_get_valueretrieval)
-
-	PHP_FE(snmp_read_mib, 				arginfo_snmp_read_mib)
-	PHP_FE_END
-};
-/* }}} */
-
 /* query an agent with GET method */
 #define SNMP_CMD_GET		(1<<0)
 /* query an agent with GETNEXT method */
@@ -1517,7 +1483,7 @@ PHP_FUNCTION(snmp_read_mib)
 
 /* {{{ proto SNMP::__construct(int version, string hostname, string community|securityName [, int timeout [, int retries]])
 	Creates a new SNMP session to specified host. */
-PHP_METHOD(snmp, __construct)
+PHP_METHOD(SNMP, __construct)
 {
 	php_snmp_object *snmp_object;
 	zval *object = ZEND_THIS;
@@ -1564,7 +1530,7 @@ PHP_METHOD(snmp, __construct)
 
 /* {{{ proto bool SNMP::close()
 	Close SNMP session */
-PHP_METHOD(snmp, close)
+PHP_METHOD(SNMP, close)
 {
 	php_snmp_object *snmp_object;
 	zval *object = ZEND_THIS;
@@ -1583,7 +1549,7 @@ PHP_METHOD(snmp, close)
 
 /* {{{ proto mixed SNMP::get(mixed object_id [, bool preserve_keys])
    Fetch a SNMP object returning scalar for single OID and array of oid->value pairs for multi OID request */
-PHP_METHOD(snmp, get)
+PHP_METHOD(SNMP, get)
 {
 	php_snmp(INTERNAL_FUNCTION_PARAM_PASSTHRU, SNMP_CMD_GET, (-1));
 }
@@ -1591,7 +1557,7 @@ PHP_METHOD(snmp, get)
 
 /* {{{ proto mixed SNMP::getnext(mixed object_id)
    Fetch a SNMP object returning scalar for single OID and array of oid->value pairs for multi OID request */
-PHP_METHOD(snmp, getnext)
+PHP_METHOD(SNMP, getnext)
 {
 	php_snmp(INTERNAL_FUNCTION_PARAM_PASSTHRU, SNMP_CMD_GETNEXT, (-1));
 }
@@ -1599,7 +1565,7 @@ PHP_METHOD(snmp, getnext)
 
 /* {{{ proto mixed SNMP::walk(mixed object_id [, bool $suffix_as_key = FALSE [, int $max_repetitions [, int $non_repeaters]])
    Return all objects including their respective object id within the specified one as array of oid->value pairs */
-PHP_METHOD(snmp, walk)
+PHP_METHOD(SNMP, walk)
 {
 	php_snmp(INTERNAL_FUNCTION_PARAM_PASSTHRU, SNMP_CMD_WALK, (-1));
 }
@@ -1607,7 +1573,7 @@ PHP_METHOD(snmp, walk)
 
 /* {{{ proto bool SNMP::set(mixed object_id, mixed type, mixed value)
    Set the value of a SNMP object */
-PHP_METHOD(snmp, set)
+PHP_METHOD(SNMP, set)
 {
 	php_snmp(INTERNAL_FUNCTION_PARAM_PASSTHRU, SNMP_CMD_SET, (-1));
 }
@@ -1615,7 +1581,7 @@ PHP_METHOD(snmp, set)
 
 /* {{{ proto bool SNMP::setSecurity(string sec_level, [ string auth_protocol, string auth_passphrase [, string priv_protocol, string priv_passphrase [, string contextName [, string contextEngineID]]]])
 	Set SNMPv3 security-related session parameters */
-PHP_METHOD(snmp, setSecurity)
+PHP_METHOD(SNMP, setSecurity)
 {
 	php_snmp_object *snmp_object;
 	zval *object = ZEND_THIS;
@@ -1640,7 +1606,7 @@ PHP_METHOD(snmp, setSecurity)
 
 /* {{{ proto int SNMP::getErrno()
 	Get last error code number */
-PHP_METHOD(snmp, getErrno)
+PHP_METHOD(SNMP, getErrno)
 {
 	php_snmp_object *snmp_object;
 	zval *object = ZEND_THIS;
@@ -1658,7 +1624,7 @@ PHP_METHOD(snmp, getErrno)
 
 /* {{{ proto int SNMP::getError()
 	Get last error message */
-PHP_METHOD(snmp, getError)
+PHP_METHOD(SNMP, getError)
 {
 	php_snmp_object *snmp_object;
 	zval *object = ZEND_THIS;
@@ -1979,22 +1945,6 @@ static void free_php_snmp_properties(zval *el)  /* {{{ */
 }
 /* }}} */
 
-/* {{{ php_snmp_class_methods[] */
-static const zend_function_entry php_snmp_class_methods[] = {
-	PHP_ME(snmp,	 __construct,		arginfo_class_SNMP___construct,	ZEND_ACC_PUBLIC)
-	PHP_ME(snmp,	 close,				arginfo_class_SNMP_close,		ZEND_ACC_PUBLIC)
-	PHP_ME(snmp,	 setSecurity,		arginfo_class_SNMP_setSecurity,	ZEND_ACC_PUBLIC)
-
-	PHP_ME(snmp,	 get,				arginfo_class_SNMP_get,			ZEND_ACC_PUBLIC)
-	PHP_ME(snmp,	 getnext,			arginfo_class_SNMP_getnext,		ZEND_ACC_PUBLIC)
-	PHP_ME(snmp,	 walk,				arginfo_class_SNMP_walk,		ZEND_ACC_PUBLIC)
-	PHP_ME(snmp,	 set,				arginfo_class_SNMP_set,			ZEND_ACC_PUBLIC)
-	PHP_ME(snmp,	 getErrno,			arginfo_class_SNMP_getErrno,	ZEND_ACC_PUBLIC)
-	PHP_ME(snmp,	 getError,			arginfo_class_SNMP_getError,	ZEND_ACC_PUBLIC)
-
-	PHP_FE_END
-};
-
 #define PHP_SNMP_PROPERTY_ENTRY_RECORD(name) \
 	{ "" #name "",		sizeof("" #name "") - 1,	php_snmp_read_##name,	php_snmp_write_##name }
 
@@ -2042,7 +1992,7 @@ PHP_MINIT_FUNCTION(snmp)
 	php_snmp_object_handlers.get_gc = php_snmp_get_gc;
 
 	/* Register SNMP Class */
-	INIT_CLASS_ENTRY(ce, "SNMP", php_snmp_class_methods);
+	INIT_CLASS_ENTRY(ce, "SNMP", class_SNMP_methods);
 	ce.create_object = php_snmp_object_new;
 	php_snmp_object_handlers.offset = XtOffsetOf(php_snmp_object, zo);
 	php_snmp_object_handlers.clone_obj = NULL;
@@ -2137,7 +2087,7 @@ zend_module_entry snmp_module_entry = {
 	NULL,
 	snmp_module_deps,
 	"snmp",
-	snmp_functions,
+	ext_functions,
 	PHP_MINIT(snmp),
 	PHP_MSHUTDOWN(snmp),
 	NULL,
diff --git a/ext/snmp/snmp.stub.php b/ext/snmp/snmp.stub.php
index bee2b39318..06632b602d 100644
--- a/ext/snmp/snmp.stub.php
+++ b/ext/snmp/snmp.stub.php
@@ -1,5 +1,7 @@
 <?php
 
+/** @generate-function-entries */
+
 /** @param array|string $object_id */
 function snmpget(string $host, string $community, $object_id, int $timeout = UNKNOWN, int $retries = UNKNOWN): array|bool {}
 
diff --git a/ext/snmp/snmp_arginfo.h b/ext/snmp/snmp_arginfo.h
index 487304f113..ed907a7dbd 100644
--- a/ext/snmp/snmp_arginfo.h
+++ b/ext/snmp/snmp_arginfo.h
@@ -144,3 +144,79 @@ ZEND_END_ARG_INFO()
 #define arginfo_class_SNMP_getErrno arginfo_class_SNMP_close
 
 #define arginfo_class_SNMP_getError arginfo_class_SNMP_close
+
+
+ZEND_FUNCTION(snmpget);
+ZEND_FUNCTION(snmpgetnext);
+ZEND_FUNCTION(snmpwalk);
+ZEND_FUNCTION(snmprealwalk);
+ZEND_FUNCTION(snmpset);
+ZEND_FUNCTION(snmp_get_quick_print);
+ZEND_FUNCTION(snmp_set_quick_print);
+ZEND_FUNCTION(snmp_set_enum_print);
+ZEND_FUNCTION(snmp_set_oid_output_format);
+ZEND_FUNCTION(snmp2_get);
+ZEND_FUNCTION(snmp2_getnext);
+ZEND_FUNCTION(snmp2_walk);
+ZEND_FUNCTION(snmp2_real_walk);
+ZEND_FUNCTION(snmp2_set);
+ZEND_FUNCTION(snmp3_get);
+ZEND_FUNCTION(snmp3_getnext);
+ZEND_FUNCTION(snmp3_walk);
+ZEND_FUNCTION(snmp3_real_walk);
+ZEND_FUNCTION(snmp3_set);
+ZEND_FUNCTION(snmp_set_valueretrieval);
+ZEND_FUNCTION(snmp_get_valueretrieval);
+ZEND_FUNCTION(snmp_read_mib);
+ZEND_METHOD(SNMP, __construct);
+ZEND_METHOD(SNMP, close);
+ZEND_METHOD(SNMP, setSecurity);
+ZEND_METHOD(SNMP, get);
+ZEND_METHOD(SNMP, getnext);
+ZEND_METHOD(SNMP, walk);
+ZEND_METHOD(SNMP, set);
+ZEND_METHOD(SNMP, getErrno);
+ZEND_METHOD(SNMP, getError);
+
+
+static const zend_function_entry ext_functions[] = {
+	ZEND_FE(snmpget, arginfo_snmpget)
+	ZEND_FE(snmpgetnext, arginfo_snmpgetnext)
+	ZEND_FE(snmpwalk, arginfo_snmpwalk)
+	ZEND_FE(snmprealwalk, arginfo_snmprealwalk)
+	ZEND_FALIAS(snmpwalkoid, snmprealwalk, arginfo_snmpwalkoid)
+	ZEND_FE(snmpset, arginfo_snmpset)
+	ZEND_FE(snmp_get_quick_print, arginfo_snmp_get_quick_print)
+	ZEND_FE(snmp_set_quick_print, arginfo_snmp_set_quick_print)
+	ZEND_FE(snmp_set_enum_print, arginfo_snmp_set_enum_print)
+	ZEND_FE(snmp_set_oid_output_format, arginfo_snmp_set_oid_output_format)
+	ZEND_FALIAS(snmp_set_oid_numeric_print, snmp_set_oid_output_format, arginfo_snmp_set_oid_numeric_print)
+	ZEND_FE(snmp2_get, arginfo_snmp2_get)
+	ZEND_FE(snmp2_getnext, arginfo_snmp2_getnext)
+	ZEND_FE(snmp2_walk, arginfo_snmp2_walk)
+	ZEND_FE(snmp2_real_walk, arginfo_snmp2_real_walk)
+	ZEND_FE(snmp2_set, arginfo_snmp2_set)
+	ZEND_FE(snmp3_get, arginfo_snmp3_get)
+	ZEND_FE(snmp3_getnext, arginfo_snmp3_getnext)
+	ZEND_FE(snmp3_walk, arginfo_snmp3_walk)
+	ZEND_FE(snmp3_real_walk, arginfo_snmp3_real_walk)
+	ZEND_FE(snmp3_set, arginfo_snmp3_set)
+	ZEND_FE(snmp_set_valueretrieval, arginfo_snmp_set_valueretrieval)
+	ZEND_FE(snmp_get_valueretrieval, arginfo_snmp_get_valueretrieval)
+	ZEND_FE(snmp_read_mib, arginfo_snmp_read_mib)
+	ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SNMP_methods[] = {
+	ZEND_ME(SNMP, __construct, arginfo_class_SNMP___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(SNMP, close, arginfo_class_SNMP_close, ZEND_ACC_PUBLIC)
+	ZEND_ME(SNMP, setSecurity, arginfo_class_SNMP_setSecurity, ZEND_ACC_PUBLIC)
+	ZEND_ME(SNMP, get, arginfo_class_SNMP_get, ZEND_ACC_PUBLIC)
+	ZEND_ME(SNMP, getnext, arginfo_class_SNMP_getnext, ZEND_ACC_PUBLIC)
+	ZEND_ME(SNMP, walk, arginfo_class_SNMP_walk, ZEND_ACC_PUBLIC)
+	ZEND_ME(SNMP, set, arginfo_class_SNMP_set, ZEND_ACC_PUBLIC)
+	ZEND_ME(SNMP, getErrno, arginfo_class_SNMP_getErrno, ZEND_ACC_PUBLIC)
+	ZEND_ME(SNMP, getError, arginfo_class_SNMP_getError, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
diff --git a/ext/soap/soap.c b/ext/soap/soap.c
index 3cede8417d..2c82ac3919 100644
--- a/ext/soap/soap.c
+++ b/ext/soap/soap.c
@@ -185,119 +185,12 @@ PHP_MINIT_FUNCTION(soap);
 PHP_MSHUTDOWN_FUNCTION(soap);
 PHP_MINFO_FUNCTION(soap);
 
-/*
-  Registry Functions
-  TODO: this!
-*/
-PHP_FUNCTION(soap_encode_to_xml);
-PHP_FUNCTION(soap_encode_to_zval);
-PHP_FUNCTION(use_soap_error_handler);
-PHP_FUNCTION(is_soap_fault);
-
-
-/* Server Functions */
-PHP_METHOD(SoapServer, __construct);
-PHP_METHOD(SoapServer, setClass);
-PHP_METHOD(SoapServer, setObject);
-PHP_METHOD(SoapServer, addFunction);
-PHP_METHOD(SoapServer, getFunctions);
-PHP_METHOD(SoapServer, handle);
-PHP_METHOD(SoapServer, setPersistence);
-PHP_METHOD(SoapServer, fault);
-PHP_METHOD(SoapServer, addSoapHeader);
-
-/* Client Functions */
-PHP_METHOD(SoapClient, __construct);
-PHP_METHOD(SoapClient, __call);
-PHP_METHOD(SoapClient, __getLastRequest);
-PHP_METHOD(SoapClient, __getLastResponse);
-PHP_METHOD(SoapClient, __getLastRequestHeaders);
-PHP_METHOD(SoapClient, __getLastResponseHeaders);
-PHP_METHOD(SoapClient, __getFunctions);
-PHP_METHOD(SoapClient, __getTypes);
-PHP_METHOD(SoapClient, __doRequest);
-PHP_METHOD(SoapClient, __setCookie);
-PHP_METHOD(SoapClient, __getCookies);
-PHP_METHOD(SoapClient, __setLocation);
-PHP_METHOD(SoapClient, __setSoapHeaders);
-
-/* SoapVar Functions */
-PHP_METHOD(SoapVar, __construct);
-
-/* SoapFault Functions */
-PHP_METHOD(SoapFault, __construct);
-PHP_METHOD(SoapFault, __toString);
-
-/* SoapParam Functions */
-PHP_METHOD(SoapParam, __construct);
-
-/* SoapHeader Functions */
-PHP_METHOD(SoapHeader, __construct);
-
-static const zend_function_entry soap_functions[] = {
-	PHP_FE(use_soap_error_handler, 	arginfo_use_soap_error_handler)
-	PHP_FE(is_soap_fault, 			arginfo_is_soap_fault)
-	PHP_FE_END
-};
-
-static const zend_function_entry soap_fault_functions[] = {
-	PHP_ME(SoapFault, __construct, arginfo_class_SoapFault___construct, 0)
-	PHP_ME(SoapFault, __toString, arginfo_class_SoapFault___toString, 0)
-	PHP_FE_END
-};
-
-static const zend_function_entry soap_server_functions[] = {
-	PHP_ME(SoapServer, __construct, 	arginfo_class_SoapServer___construct, 0)
-	PHP_ME(SoapServer, setPersistence, 	arginfo_class_SoapServer_setPersistence, 0)
-	PHP_ME(SoapServer, setClass, 		arginfo_class_SoapServer_setClass, 0)
-	PHP_ME(SoapServer, setObject, 		arginfo_class_SoapServer_setObject, 0)
-	PHP_ME(SoapServer, addFunction, 	arginfo_class_SoapServer_addFunction, 0)
-	PHP_ME(SoapServer, getFunctions, 	arginfo_class_SoapServer_getFunctions, 0)
-	PHP_ME(SoapServer, handle, 			arginfo_class_SoapServer_handle, 0)
-	PHP_ME(SoapServer, fault, 			arginfo_class_SoapServer_fault, 0)
-	PHP_ME(SoapServer, addSoapHeader, 	arginfo_class_SoapServer_addSoapHeader, 0)
-	PHP_FE_END
-};
-
-static const zend_function_entry soap_client_functions[] = {
-	PHP_ME(SoapClient, __construct, 				arginfo_class_SoapClient___construct, 0)
-	PHP_ME(SoapClient, __call, 						arginfo_class_SoapClient___call, 0)
-	ZEND_NAMED_ME(__soapCall, ZEND_MN(SoapClient___call), arginfo_class_SoapClient___soapCall, 0)
-	PHP_ME(SoapClient, __getLastRequest, 			arginfo_class_SoapClient___getLastRequest, 0)
-	PHP_ME(SoapClient, __getLastResponse, 			arginfo_class_SoapClient___getLastResponse, 0)
-	PHP_ME(SoapClient, __getLastRequestHeaders, 	arginfo_class_SoapClient___getLastRequestHeaders, 0)
-	PHP_ME(SoapClient, __getLastResponseHeaders, 	arginfo_class_SoapClient___getLastResponseHeaders, 0)
-	PHP_ME(SoapClient, __getFunctions, 				arginfo_class_SoapClient___getFunctions, 0)
-	PHP_ME(SoapClient, __getTypes, 					arginfo_class_SoapClient___getTypes, 0)
-	PHP_ME(SoapClient, __doRequest, 				arginfo_class_SoapClient___doRequest, 0)
-	PHP_ME(SoapClient, __setCookie, 				arginfo_class_SoapClient___setCookie, 0)
-	PHP_ME(SoapClient, __getCookies, 				arginfo_class_SoapClient___getCookies, 0)
-	PHP_ME(SoapClient, __setLocation, 				arginfo_class_SoapClient___setLocation, 0)
-	PHP_ME(SoapClient, __setSoapHeaders, 			arginfo_class_SoapClient___setSoapHeaders, 0)
-	PHP_FE_END
-};
-
-static const zend_function_entry soap_var_functions[] = {
-	PHP_ME(SoapVar, __construct, arginfo_class_SoapVar___construct, 0)
-	PHP_FE_END
-};
-
-static const zend_function_entry soap_param_functions[] = {
-	PHP_ME(SoapParam, __construct, arginfo_class_SoapParam___construct, 0)
-	PHP_FE_END
-};
-
-static const zend_function_entry soap_header_functions[] = {
-	PHP_ME(SoapHeader, __construct, arginfo_class_SoapHeader___construct, 0)
-	PHP_FE_END
-};
-
 zend_module_entry soap_module_entry = {
 #ifdef STANDARD_MODULE_HEADER
   STANDARD_MODULE_HEADER,
 #endif
   "soap",
-  soap_functions,
+  ext_functions,
   PHP_MINIT(soap),
   PHP_MSHUTDOWN(soap),
   PHP_RINIT(soap),
@@ -496,26 +389,26 @@ PHP_MINIT_FUNCTION(soap)
 		soap_call_function_handler should be of type zend_function, not (*handle_function_call).
 	*/
 	{
-		INIT_CLASS_ENTRY(ce, PHP_SOAP_CLIENT_CLASSNAME, soap_client_functions);
+		INIT_CLASS_ENTRY(ce, PHP_SOAP_CLIENT_CLASSNAME, class_SoapClient_methods);
 		soap_class_entry = zend_register_internal_class(&ce);
 	}
 	/* Register SoapVar class */
-	INIT_CLASS_ENTRY(ce, PHP_SOAP_VAR_CLASSNAME, soap_var_functions);
+	INIT_CLASS_ENTRY(ce, PHP_SOAP_VAR_CLASSNAME, class_SoapVar_methods);
 	soap_var_class_entry = zend_register_internal_class(&ce);
 
 	/* Register SoapServer class */
-	INIT_CLASS_ENTRY(ce, PHP_SOAP_SERVER_CLASSNAME, soap_server_functions);
+	INIT_CLASS_ENTRY(ce, PHP_SOAP_SERVER_CLASSNAME, class_SoapServer_methods);
 	soap_server_class_entry = zend_register_internal_class(&ce);
 
 	/* Register SoapFault class */
-	INIT_CLASS_ENTRY(ce, PHP_SOAP_FAULT_CLASSNAME, soap_fault_functions);
+	INIT_CLASS_ENTRY(ce, PHP_SOAP_FAULT_CLASSNAME, class_SoapFault_methods);
 	soap_fault_class_entry = zend_register_internal_class_ex(&ce, zend_ce_exception);
 
 	/* Register SoapParam class */
-	INIT_CLASS_ENTRY(ce, PHP_SOAP_PARAM_CLASSNAME, soap_param_functions);
+	INIT_CLASS_ENTRY(ce, PHP_SOAP_PARAM_CLASSNAME, class_SoapParam_methods);
 	soap_param_class_entry = zend_register_internal_class(&ce);
 
-	INIT_CLASS_ENTRY(ce, PHP_SOAP_HEADER_CLASSNAME, soap_header_functions);
+	INIT_CLASS_ENTRY(ce, PHP_SOAP_HEADER_CLASSNAME, class_SoapHeader_methods);
 	soap_header_class_entry = zend_register_internal_class(&ce);
 
 	le_sdl = zend_register_list_destructors_ex(delete_sdl_res, NULL, "SOAP SDL", module_number);
diff --git a/ext/soap/soap.stub.php b/ext/soap/soap.stub.php
index a3ae6e93d3..5e8e2eca28 100644
--- a/ext/soap/soap.stub.php
+++ b/ext/soap/soap.stub.php
@@ -1,100 +1,105 @@
 <?php
 
+/** @generate-function-entries */
+
 function use_soap_error_handler(bool $handler = true): bool {}
 
 function is_soap_fault($object): bool {}
 
 class SoapParam
 {
-    public function __construct($data, string $name);
+    public function __construct($data, string $name) {}
 }
 
 class SoapHeader
 {
-    public function __construct(string $namespace, string $name, $data = UNKNOWN, bool $mustunderstand = false, $actor = UNKNOWN);
+    public function __construct(string $namespace, string $name, $data = UNKNOWN, bool $mustunderstand = false, $actor = UNKNOWN) {}
 }
 
 class SoapFault extends Exception
 {
-    public function __construct($faultcode, string $faultstring, ?string $faultactor = null, $detail = null, ?string $faultname = null, $headerfault = null);
+    public function __construct($faultcode, string $faultstring, ?string $faultactor = null, $detail = null, ?string $faultname = null, $headerfault = null) {}
 
-    public function __toString(): string;
+    public function __toString(): string {}
 }
 
 class SoapVar
 {
-    public function __construct($data, $encoding, string $type_name = "", string $type_namespace = "", string $node_name = "", string $node_namespace = "");
+    public function __construct($data, $encoding, string $type_name = "", string $type_namespace = "", string $node_name = "", string $node_namespace = "") {}
 }
 
 class SoapServer
 {
-    public function __construct($wsdl, array $options = []);
+    public function __construct($wsdl, array $options = []) {}
 
     /** @return void */
-    public function fault(string $code, string $string, string $actor = "", $details = null, string $name = "");
+    public function fault(string $code, string $string, string $actor = "", $details = null, string $name = "") {}
 
     /** @return void */
-    public function addSoapHeader(SoapHeader $object);
+    public function addSoapHeader(SoapHeader $object) {}
 
     /** @return void */
-    public function setPersistence(int $mode);
+    public function setPersistence(int $mode) {}
 
     /** @return void */
-    public function setClass(string $class_name, ...$argv);
+    public function setClass(string $class_name, ...$argv) {}
 
     /** @return void */
-    public function setObject(object $object);
+    public function setObject(object $object) {}
 
     /** @return array */
-    public function getFunctions();
+    public function getFunctions() {}
 
     /** @return void */
-    public function addFunction($functions);
+    public function addFunction($functions) {}
 
     /** @return void */
-    public function handle(string $soap_request = UNKNOWN);
+    public function handle(string $soap_request = UNKNOWN) {}
 }
 
 class SoapClient
 {
-    public function __construct($wsdl, array $options = []);
+    public function __construct($wsdl, array $options = []) {}
 
     /** @return mixed */
-    public function __call(string $function_name, array $arguments);
+    public function __call(string $function_name, array $arguments) {}
 
-    /** @return mixed */
-    public function __soapCall(string $function_name, array $arguments, ?array $options = null, $input_headers = null, $output_headers = null);
+    /**
+     * @return mixed
+     * @alias SoapClient::__call
+     */
+    public function __soapCall(string $function_name, array $arguments, ?array $options = null, $input_headers = null, $output_headers = null) {}
 
     /** @return array|null */
-    public function __getFunctions();
+    public function __getFunctions() {}
 
     /** @return array|null */
-    public function __getTypes();
+    public function __getTypes() {}
 
     /** @return string|null */
-    public function __getLastRequest();
+    public function __getLastRequest() {}
 
     /** @return string|null */
-    public function __getLastResponse();
+    public function __getLastResponse() {}
 
     /** @return string|null */
-    public function __getLastRequestHeaders();
+    public function __getLastRequestHeaders() {}
 
     /** @return string|null */
-    public function __getLastResponseHeaders();
+    public function __getLastResponseHeaders() {}
 
     /** @return string|null */
-    public function __doRequest(string $request, string $location, string $action, int $version, int $one_way = 0);
+    public function __doRequest(string $request, string $location, string $action, int $version, int $one_way = 0) {}
 
     /** @return void */
-    public function __setCookie(string $name, ?string $value = null);
+    public function __setCookie(string $name, ?string $value = null) {}
 
     /** @return array */
-    public function __getCookies();
+    public function __getCookies() {}
 
     /** @return bool */
-    public function __setSoapHeaders($soapheaders = null);
+    public function __setSoapHeaders($soapheaders = null) {}
 
     /** @return string|null */
-    public function __setLocation(string $new_location = "");
+    public function __setLocation(string $new_location = "") {}
 }
diff --git a/ext/soap/soap_arginfo.h b/ext/soap/soap_arginfo.h
index 505629fb88..f22e76a47d 100644
--- a/ext/soap/soap_arginfo.h
+++ b/ext/soap/soap_arginfo.h
@@ -132,3 +132,99 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_INFO_EX(arginfo_class_SoapClient___setLocation, 0, 0, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, new_location, IS_STRING, 0, "\"\"")
 ZEND_END_ARG_INFO()
+
+
+ZEND_FUNCTION(use_soap_error_handler);
+ZEND_FUNCTION(is_soap_fault);
+ZEND_METHOD(SoapParam, __construct);
+ZEND_METHOD(SoapHeader, __construct);
+ZEND_METHOD(SoapFault, __construct);
+ZEND_METHOD(SoapFault, __toString);
+ZEND_METHOD(SoapVar, __construct);
+ZEND_METHOD(SoapServer, __construct);
+ZEND_METHOD(SoapServer, fault);
+ZEND_METHOD(SoapServer, addSoapHeader);
+ZEND_METHOD(SoapServer, setPersistence);
+ZEND_METHOD(SoapServer, setClass);
+ZEND_METHOD(SoapServer, setObject);
+ZEND_METHOD(SoapServer, getFunctions);
+ZEND_METHOD(SoapServer, addFunction);
+ZEND_METHOD(SoapServer, handle);
+ZEND_METHOD(SoapClient, __construct);
+ZEND_METHOD(SoapClient, __call);
+ZEND_METHOD(SoapClient, __getFunctions);
+ZEND_METHOD(SoapClient, __getTypes);
+ZEND_METHOD(SoapClient, __getLastRequest);
+ZEND_METHOD(SoapClient, __getLastResponse);
+ZEND_METHOD(SoapClient, __getLastRequestHeaders);
+ZEND_METHOD(SoapClient, __getLastResponseHeaders);
+ZEND_METHOD(SoapClient, __doRequest);
+ZEND_METHOD(SoapClient, __setCookie);
+ZEND_METHOD(SoapClient, __getCookies);
+ZEND_METHOD(SoapClient, __setSoapHeaders);
+ZEND_METHOD(SoapClient, __setLocation);
+
+
+static const zend_function_entry ext_functions[] = {
+	ZEND_FE(use_soap_error_handler, arginfo_use_soap_error_handler)
+	ZEND_FE(is_soap_fault, arginfo_is_soap_fault)
+	ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SoapParam_methods[] = {
+	ZEND_ME(SoapParam, __construct, arginfo_class_SoapParam___construct, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SoapHeader_methods[] = {
+	ZEND_ME(SoapHeader, __construct, arginfo_class_SoapHeader___construct, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SoapFault_methods[] = {
+	ZEND_ME(SoapFault, __construct, arginfo_class_SoapFault___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapFault, __toString, arginfo_class_SoapFault___toString, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SoapVar_methods[] = {
+	ZEND_ME(SoapVar, __construct, arginfo_class_SoapVar___construct, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SoapServer_methods[] = {
+	ZEND_ME(SoapServer, __construct, arginfo_class_SoapServer___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapServer, fault, arginfo_class_SoapServer_fault, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapServer, addSoapHeader, arginfo_class_SoapServer_addSoapHeader, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapServer, setPersistence, arginfo_class_SoapServer_setPersistence, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapServer, setClass, arginfo_class_SoapServer_setClass, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapServer, setObject, arginfo_class_SoapServer_setObject, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapServer, getFunctions, arginfo_class_SoapServer_getFunctions, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapServer, addFunction, arginfo_class_SoapServer_addFunction, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapServer, handle, arginfo_class_SoapServer_handle, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SoapClient_methods[] = {
+	ZEND_ME(SoapClient, __construct, arginfo_class_SoapClient___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapClient, __call, arginfo_class_SoapClient___call, ZEND_ACC_PUBLIC)
+	ZEND_MALIAS(SoapClient, __soapCall, __call, arginfo_class_SoapClient___soapCall, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapClient, __getFunctions, arginfo_class_SoapClient___getFunctions, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapClient, __getTypes, arginfo_class_SoapClient___getTypes, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapClient, __getLastRequest, arginfo_class_SoapClient___getLastRequest, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapClient, __getLastResponse, arginfo_class_SoapClient___getLastResponse, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapClient, __getLastRequestHeaders, arginfo_class_SoapClient___getLastRequestHeaders, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapClient, __getLastResponseHeaders, arginfo_class_SoapClient___getLastResponseHeaders, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapClient, __doRequest, arginfo_class_SoapClient___doRequest, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapClient, __setCookie, arginfo_class_SoapClient___setCookie, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapClient, __getCookies, arginfo_class_SoapClient___getCookies, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapClient, __setSoapHeaders, arginfo_class_SoapClient___setSoapHeaders, ZEND_ACC_PUBLIC)
+	ZEND_ME(SoapClient, __setLocation, arginfo_class_SoapClient___setLocation, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
diff --git a/ext/sqlite3/sqlite3.c b/ext/sqlite3/sqlite3.c
index 18dddd962d..aa104f3d8b 100644
--- a/ext/sqlite3/sqlite3.c
+++ b/ext/sqlite3/sqlite3.c
@@ -96,7 +96,7 @@ zend_class_entry *php_sqlite3_result_entry;
 
 /* {{{ proto void SQLite3::open(String filename [, int Flags [, string Encryption Key]])
    Opens a SQLite 3 Database, if the build includes encryption then it will attempt to use the key. */
-PHP_METHOD(sqlite3, open)
+PHP_METHOD(SQLite3, open)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -178,7 +178,7 @@ PHP_METHOD(sqlite3, open)
 
 /* {{{ proto bool SQLite3::close()
    Close a SQLite 3 Database. */
-PHP_METHOD(sqlite3, close)
+PHP_METHOD(SQLite3, close)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -207,7 +207,7 @@ PHP_METHOD(sqlite3, close)
 
 /* {{{ proto bool SQLite3::exec(String Query)
    Executes a result-less query against a given database. */
-PHP_METHOD(sqlite3, exec)
+PHP_METHOD(SQLite3, exec)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -233,7 +233,7 @@ PHP_METHOD(sqlite3, exec)
 
 /* {{{ proto Array SQLite3::version()
    Returns the SQLite3 Library version as a string constant and as a number. */
-PHP_METHOD(sqlite3, version)
+PHP_METHOD(SQLite3, version)
 {
 	if (zend_parse_parameters_none() == FAILURE) {
 		RETURN_THROWS();
@@ -250,7 +250,7 @@ PHP_METHOD(sqlite3, version)
 
 /* {{{ proto int SQLite3::lastInsertRowID()
    Returns the rowid of the most recent INSERT into the database from the database connection. */
-PHP_METHOD(sqlite3, lastInsertRowID)
+PHP_METHOD(SQLite3, lastInsertRowID)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -268,7 +268,7 @@ PHP_METHOD(sqlite3, lastInsertRowID)
 
 /* {{{ proto int SQLite3::lastErrorCode()
    Returns the numeric result code of the most recent failed sqlite API call for the database connection. */
-PHP_METHOD(sqlite3, lastErrorCode)
+PHP_METHOD(SQLite3, lastErrorCode)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -290,7 +290,7 @@ PHP_METHOD(sqlite3, lastErrorCode)
 
 /* {{{ proto int SQLite3::lastExtendedErrorCode()
    Returns the numeric extended result code of the most recent failed sqlite API call for the database connection. */
-PHP_METHOD(sqlite3, lastExtendedErrorCode)
+PHP_METHOD(SQLite3, lastExtendedErrorCode)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -312,7 +312,7 @@ PHP_METHOD(sqlite3, lastExtendedErrorCode)
 
 /* {{{ proto bool SQLite3::enableExtendedResultCodes([bool enable = true])
     Turns on or off the extended result codes feature of SQLite. */
-PHP_METHOD(sqlite3, enableExtendedResultCodes)
+PHP_METHOD(SQLite3, enableExtendedResultCodes)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -340,7 +340,7 @@ PHP_METHOD(sqlite3, enableExtendedResultCodes)
 
 /* {{{ proto string SQLite3::lastErrorMsg()
    Returns english text describing the most recent failed sqlite API call for the database connection. */
-PHP_METHOD(sqlite3, lastErrorMsg)
+PHP_METHOD(SQLite3, lastErrorMsg)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -362,7 +362,7 @@ PHP_METHOD(sqlite3, lastErrorMsg)
 
 /* {{{ proto bool SQLite3::busyTimeout(int msecs)
    Sets a busy handler that will sleep until database is not locked or timeout is reached. Passing a value less than or equal to zero turns off all busy handlers. */
-PHP_METHOD(sqlite3, busyTimeout)
+PHP_METHOD(SQLite3, busyTimeout)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -396,7 +396,7 @@ PHP_METHOD(sqlite3, busyTimeout)
 #ifndef SQLITE_OMIT_LOAD_EXTENSION
 /* {{{ proto bool SQLite3::loadExtension(String Shared Library)
    Attempts to load an SQLite extension library. */
-PHP_METHOD(sqlite3, loadExtension)
+PHP_METHOD(SQLite3, loadExtension)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -469,7 +469,7 @@ PHP_METHOD(sqlite3, loadExtension)
 
 /* {{{ proto int SQLite3::changes()
   Returns the number of database rows that were changed (or inserted or deleted) by the most recent SQL statement. */
-PHP_METHOD(sqlite3, changes)
+PHP_METHOD(SQLite3, changes)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -487,7 +487,7 @@ PHP_METHOD(sqlite3, changes)
 
 /* {{{ proto String SQLite3::escapeString(String value)
    Returns a string that has been properly escaped. */
-PHP_METHOD(sqlite3, escapeString)
+PHP_METHOD(SQLite3, escapeString)
 {
 	zend_string *sql;
 	char *ret;
@@ -510,7 +510,7 @@ PHP_METHOD(sqlite3, escapeString)
 
 /* {{{ proto SQLite3Stmt SQLite3::prepare(String Query)
    Returns a prepared SQL statement for execution. */
-PHP_METHOD(sqlite3, prepare)
+PHP_METHOD(SQLite3, prepare)
 {
 	php_sqlite3_db_object *db_obj;
 	php_sqlite3_stmt *stmt_obj;
@@ -556,7 +556,7 @@ PHP_METHOD(sqlite3, prepare)
 
 /* {{{ proto SQLite3Result SQLite3::query(String Query)
    Returns true or false, for queries that return data it will return a SQLite3Result object. */
-PHP_METHOD(sqlite3, query)
+PHP_METHOD(SQLite3, query)
 {
 	php_sqlite3_db_object *db_obj;
 	php_sqlite3_result *result;
@@ -673,7 +673,7 @@ static void sqlite_value_to_zval(sqlite3_stmt *stmt, int column, zval *data) /*
 
 /* {{{ proto SQLite3Result SQLite3::querySingle(String Query [, bool entire_row = false])
    Returns a string of the first column, or an array of the entire row. */
-PHP_METHOD(sqlite3, querySingle)
+PHP_METHOD(SQLite3, querySingle)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -966,7 +966,7 @@ static int php_sqlite3_callback_compare(void *coll, int a_len, const void *a, in
 
 /* {{{ proto bool SQLite3::createFunction(string name, mixed callback [, int argcount, int flags])
    Allows registration of a PHP function as a SQLite UDF that can be called within SQL statements. */
-PHP_METHOD(sqlite3, createFunction)
+PHP_METHOD(SQLite3, createFunction)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -1016,7 +1016,7 @@ PHP_METHOD(sqlite3, createFunction)
 
 /* {{{ proto bool SQLite3::createAggregate(string name, mixed step, mixed final [, int argcount])
    Allows registration of a PHP function for use as an aggregate. */
-PHP_METHOD(sqlite3, createAggregate)
+PHP_METHOD(SQLite3, createAggregate)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -1073,7 +1073,7 @@ PHP_METHOD(sqlite3, createAggregate)
 
 /* {{{ proto bool SQLite3::createCollation(string name, mixed callback)
    Registers a PHP function as a comparator that can be used with the SQL COLLATE operator. Callback must accept two strings and return an integer (as strcmp()). */
-PHP_METHOD(sqlite3, createCollation)
+PHP_METHOD(SQLite3, createCollation)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -1279,7 +1279,7 @@ static const php_stream_ops php_stream_sqlite3_ops = {
 
 /* {{{ proto resource SQLite3::openBlob(string table, string column, int rowid [, string dbname [, int flags]])
    Open a blob as a stream which we can read / write to. */
-PHP_METHOD(sqlite3, openBlob)
+PHP_METHOD(SQLite3, openBlob)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -1332,7 +1332,7 @@ PHP_METHOD(sqlite3, openBlob)
 
 /* {{{ proto bool SQLite3::enableExceptions([bool enableExceptions = false])
    Enables an exception error mode. */
-PHP_METHOD(sqlite3, enableExceptions)
+PHP_METHOD(SQLite3, enableExceptions)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -1352,7 +1352,7 @@ PHP_METHOD(sqlite3, enableExceptions)
 
 /* {{{ proto bool SQLite3::setAuthorizer(mixed callback)
    Register a callback function to be used as an authorizer by SQLite. The callback should return SQLite3::OK, SQLite3::IGNORE or SQLite3::DENY. */
-PHP_METHOD(sqlite3, setAuthorizer)
+PHP_METHOD(SQLite3, setAuthorizer)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = ZEND_THIS;
@@ -1387,7 +1387,7 @@ PHP_METHOD(sqlite3, setAuthorizer)
 #if SQLITE_VERSION_NUMBER >= 3006011
 /* {{{ proto bool SQLite3::backup(SQLite3 destination_db[, string source_dbname = "main"[, string destination_dbname = "main"]])
    Backups the current database to another one. */
-PHP_METHOD(sqlite3, backup)
+PHP_METHOD(SQLite3, backup)
 {
 	php_sqlite3_db_object *source_obj;
 	php_sqlite3_db_object *destination_obj;
@@ -1453,7 +1453,7 @@ PHP_METHOD(sqlite3, backup)
 
 /* {{{ proto int SQLite3Stmt::paramCount()
    Returns the number of parameters within the prepared statement. */
-PHP_METHOD(sqlite3stmt, paramCount)
+PHP_METHOD(SQLite3Stmt, paramCount)
 {
 	php_sqlite3_stmt *stmt_obj;
 	zval *object = ZEND_THIS;
@@ -1472,7 +1472,7 @@ PHP_METHOD(sqlite3stmt, paramCount)
 
 /* {{{ proto bool SQLite3Stmt::close()
    Closes the prepared statement. */
-PHP_METHOD(sqlite3stmt, close)
+PHP_METHOD(SQLite3Stmt, close)
 {
 	php_sqlite3_stmt *stmt_obj;
 	zval *object = ZEND_THIS;
@@ -1494,7 +1494,7 @@ PHP_METHOD(sqlite3stmt, close)
 
 /* {{{ proto bool SQLite3Stmt::reset()
    Reset the prepared statement to the state before it was executed, bindings still remain. */
-PHP_METHOD(sqlite3stmt, reset)
+PHP_METHOD(SQLite3Stmt, reset)
 {
 	php_sqlite3_stmt *stmt_obj;
 	zval *object = ZEND_THIS;
@@ -1517,7 +1517,7 @@ PHP_METHOD(sqlite3stmt, reset)
 
 /* {{{ proto bool SQLite3Stmt::clear()
    Clear all current bound parameters. */
-PHP_METHOD(sqlite3stmt, clear)
+PHP_METHOD(SQLite3Stmt, clear)
 {
 	php_sqlite3_stmt *stmt_obj;
 	zval *object = ZEND_THIS;
@@ -1547,7 +1547,7 @@ PHP_METHOD(sqlite3stmt, clear)
 
 /* {{{ proto bool SQLite3Stmt::readOnly()
    Returns true if a statement is definitely read only */
-PHP_METHOD(sqlite3stmt, readOnly)
+PHP_METHOD(SQLite3Stmt, readOnly)
 {
 	php_sqlite3_stmt *stmt_obj;
 	zval *object = ZEND_THIS;
@@ -1677,7 +1677,7 @@ static int php_sqlite3_bind_params(php_sqlite3_stmt *stmt_obj) /* {{{ */
 
 /* {{{ proto string SQLite3Stmt::getSQL([expanded = false])
    Returns the SQL statement used to prepare the query. If expanded is true, binded parameters and values will be expanded. */
-PHP_METHOD(sqlite3stmt, getSQL)
+PHP_METHOD(SQLite3Stmt, getSQL)
 {
 	php_sqlite3_stmt *stmt_obj;
 	zend_bool expanded = 0;
@@ -1822,7 +1822,7 @@ static void sqlite3stmt_bind(INTERNAL_FUNCTION_PARAMETERS)
 
 /* {{{ proto bool SQLite3Stmt::bindParam(int parameter_number, mixed parameter [, int type])
    Bind Parameter to a stmt variable. */
-PHP_METHOD(sqlite3stmt, bindParam)
+PHP_METHOD(SQLite3Stmt, bindParam)
 {
 	sqlite3stmt_bind(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 }
@@ -1830,7 +1830,7 @@ PHP_METHOD(sqlite3stmt, bindParam)
 
 /* {{{ proto bool SQLite3Stmt::bindValue(int parameter_number, mixed parameter [, int type])
    Bind Value of a parameter to a stmt variable. */
-PHP_METHOD(sqlite3stmt, bindValue)
+PHP_METHOD(SQLite3Stmt, bindValue)
 {
 	sqlite3stmt_bind(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 }
@@ -1840,7 +1840,7 @@ PHP_METHOD(sqlite3stmt, bindValue)
 
 /* {{{ proto SQLite3Result SQLite3Stmt::execute()
    Executes a prepared statement and returns a result set object. */
-PHP_METHOD(sqlite3stmt, execute)
+PHP_METHOD(SQLite3Stmt, execute)
 {
 	php_sqlite3_stmt *stmt_obj;
 	php_sqlite3_result *result;
@@ -1901,7 +1901,7 @@ PHP_METHOD(sqlite3stmt, execute)
 
 /* {{{ proto SQLite3Stmt::__construct(SQLite3 dbobject, String Statement)
    __constructor for SQLite3Stmt. */
-PHP_METHOD(sqlite3stmt, __construct)
+PHP_METHOD(SQLite3Stmt, __construct)
 {
 	php_sqlite3_stmt *stmt_obj;
 	php_sqlite3_db_object *db_obj;
@@ -1951,7 +1951,7 @@ PHP_METHOD(sqlite3stmt, __construct)
 
 /* {{{ proto int SQLite3Result::numColumns()
    Number of columns in the result set. */
-PHP_METHOD(sqlite3result, numColumns)
+PHP_METHOD(SQLite3Result, numColumns)
 {
 	php_sqlite3_result *result_obj;
 	zval *object = ZEND_THIS;
@@ -1969,7 +1969,7 @@ PHP_METHOD(sqlite3result, numColumns)
 
 /* {{{ proto string SQLite3Result::columnName(int column)
    Returns the name of the nth column. */
-PHP_METHOD(sqlite3result, columnName)
+PHP_METHOD(SQLite3Result, columnName)
 {
 	php_sqlite3_result *result_obj;
 	zval *object = ZEND_THIS;
@@ -1994,7 +1994,7 @@ PHP_METHOD(sqlite3result, columnName)
 
 /* {{{ proto int SQLite3Result::columnType(int column)
    Returns the type of the nth column. */
-PHP_METHOD(sqlite3result, columnType)
+PHP_METHOD(SQLite3Result, columnType)
 {
 	php_sqlite3_result *result_obj;
 	zval *object = ZEND_THIS;
@@ -2017,7 +2017,7 @@ PHP_METHOD(sqlite3result, columnType)
 
 /* {{{ proto array SQLite3Result::fetchArray([int mode])
    Fetch a result row as both an associative or numerically indexed array or both. */
-PHP_METHOD(sqlite3result, fetchArray)
+PHP_METHOD(SQLite3Result, fetchArray)
 {
 	php_sqlite3_result *result_obj;
 	zval *object = ZEND_THIS;
@@ -2073,7 +2073,7 @@ PHP_METHOD(sqlite3result, fetchArray)
 
 /* {{{ proto bool SQLite3Result::reset()
    Resets the result set back to the first row. */
-PHP_METHOD(sqlite3result, reset)
+PHP_METHOD(SQLite3Result, reset)
 {
 	php_sqlite3_result *result_obj;
 	zval *object = ZEND_THIS;
@@ -2095,7 +2095,7 @@ PHP_METHOD(sqlite3result, reset)
 
 /* {{{ proto bool SQLite3Result::finalize()
    Closes the result set. */
-PHP_METHOD(sqlite3result, finalize)
+PHP_METHOD(SQLite3Result, finalize)
 {
 	php_sqlite3_result *result_obj;
 	zval *object = ZEND_THIS;
@@ -2121,76 +2121,12 @@ PHP_METHOD(sqlite3result, finalize)
 
 /* {{{ proto SQLite3Result::__construct()
    __constructor for SQLite3Result. */
-PHP_METHOD(sqlite3result, __construct)
+PHP_METHOD(SQLite3Result, __construct)
 {
 	zend_throw_exception(zend_ce_exception, "SQLite3Result cannot be directly instantiated", 0);
 }
 /* }}} */
 
-/* {{{ php_sqlite3_class_methods */
-static const zend_function_entry php_sqlite3_class_methods[] = {
-	PHP_ME(sqlite3,		open,						arginfo_class_SQLite3_open, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		close,						arginfo_class_SQLite3_close, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		exec,						arginfo_class_SQLite3_query, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		version,					arginfo_class_SQLite3_version, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	PHP_ME(sqlite3,		lastInsertRowID,			arginfo_class_SQLite3_lastInsertRowID, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		lastErrorCode,				arginfo_class_SQLite3_lastErrorCode, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		lastExtendedErrorCode,		arginfo_class_SQLite3_lastExtendedErrorCode, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		enableExtendedResultCodes,	arginfo_class_SQLite3_enableExtendedResultCodes, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		lastErrorMsg,				arginfo_class_SQLite3_lastErrorMsg, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		busyTimeout,				arginfo_class_SQLite3_busyTimeout, ZEND_ACC_PUBLIC)
-#ifndef SQLITE_OMIT_LOAD_EXTENSION
-	PHP_ME(sqlite3,		loadExtension,				arginfo_class_SQLite3_loadExtension, ZEND_ACC_PUBLIC)
-#endif
-	PHP_ME(sqlite3,		changes,					arginfo_class_SQLite3_changes, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		escapeString,				arginfo_class_SQLite3_escapeString, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	PHP_ME(sqlite3,		prepare,					arginfo_class_SQLite3_prepare, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		query,						arginfo_class_SQLite3_query, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		querySingle,				arginfo_class_SQLite3_querySingle, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		createFunction,				arginfo_class_SQLite3_createFunction, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		createAggregate,			arginfo_class_SQLite3_createAggregate, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		createCollation,			arginfo_class_SQLite3_createCollation, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		openBlob,					arginfo_class_SQLite3_openBlob, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		enableExceptions,			arginfo_class_SQLite3_enableExceptions, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3,		setAuthorizer,				arginfo_class_SQLite3_setAuthorizer, ZEND_ACC_PUBLIC)
-#if SQLITE_VERSION_NUMBER >= 3006011
-	PHP_ME(sqlite3,		backup,						arginfo_class_SQLite3_backup, ZEND_ACC_PUBLIC)
-#endif
-	/* Aliases */
-	PHP_MALIAS(sqlite3,	__construct, open, arginfo_class_SQLite3___construct, ZEND_ACC_PUBLIC)
-	PHP_FE_END
-};
-/* }}} */
-
-/* {{{ php_sqlite3_stmt_class_methods */
-static const zend_function_entry php_sqlite3_stmt_class_methods[] = {
-	PHP_ME(sqlite3stmt, paramCount,	arginfo_class_SQLite3Stmt_paramCount, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3stmt, close,		arginfo_class_SQLite3Stmt_close, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3stmt, reset,		arginfo_class_SQLite3Stmt_reset, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3stmt, clear,		arginfo_class_SQLite3Stmt_clear, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3stmt, execute,	arginfo_class_SQLite3Stmt_execute, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3stmt, bindParam,	arginfo_class_SQLite3Stmt_bindParam, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3stmt, bindValue,	arginfo_class_SQLite3Stmt_bindValue, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3stmt, readOnly,	arginfo_class_SQLite3Stmt_readOnly, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3stmt, getSQL,		arginfo_class_SQLite3Stmt_getSQL, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3stmt, __construct, arginfo_class_SQLite3Stmt___construct, ZEND_ACC_PRIVATE)
-	PHP_FE_END
-};
-/* }}} */
-
-/* {{{ php_sqlite3_result_class_methods */
-static const zend_function_entry php_sqlite3_result_class_methods[] = {
-	PHP_ME(sqlite3result, numColumns,		arginfo_class_SQLite3Result_numColumns, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3result, columnName,		arginfo_class_SQLite3Result_columnName, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3result, columnType,		arginfo_class_SQLite3Result_columnType, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3result, fetchArray,		arginfo_class_SQLite3Result_fetchArray, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3result, reset,			arginfo_class_SQLite3Result_reset, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3result, finalize,			arginfo_class_SQLite3Result_finalize, ZEND_ACC_PUBLIC)
-	PHP_ME(sqlite3result, __construct, 		arginfo_class_SQLite3Result___construct, ZEND_ACC_PRIVATE)
-	PHP_FE_END
-};
-/* }}} */
-
 /* {{{ Authorization Callback
 */
 static int php_sqlite3_authorizer(void *autharg, int action, const char *arg1, const char *arg2, const char *arg3, const char *arg4)
@@ -2499,7 +2435,7 @@ PHP_MINIT_FUNCTION(sqlite3)
 	memcpy(&sqlite3_result_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
 
 	/* Register SQLite 3 Class */
-	INIT_CLASS_ENTRY(ce, "SQLite3", php_sqlite3_class_methods);
+	INIT_CLASS_ENTRY(ce, "SQLite3", class_SQLite3_methods);
 	ce.create_object = php_sqlite3_object_new;
 	sqlite3_object_handlers.offset = XtOffsetOf(php_sqlite3_db_object, zo);
 	sqlite3_object_handlers.clone_obj = NULL;
@@ -2509,7 +2445,7 @@ PHP_MINIT_FUNCTION(sqlite3)
 	php_sqlite3_sc_entry->unserialize = zend_class_unserialize_deny;
 
 	/* Register SQLite 3 Prepared Statement Class */
-	INIT_CLASS_ENTRY(ce, "SQLite3Stmt", php_sqlite3_stmt_class_methods);
+	INIT_CLASS_ENTRY(ce, "SQLite3Stmt", class_SQLite3Stmt_methods);
 	ce.create_object = php_sqlite3_stmt_object_new;
 	sqlite3_stmt_object_handlers.offset = XtOffsetOf(php_sqlite3_stmt, zo);
 	sqlite3_stmt_object_handlers.clone_obj = NULL;
@@ -2519,7 +2455,7 @@ PHP_MINIT_FUNCTION(sqlite3)
 	php_sqlite3_stmt_entry->unserialize = zend_class_unserialize_deny;
 
 	/* Register SQLite 3 Result Class */
-	INIT_CLASS_ENTRY(ce, "SQLite3Result", php_sqlite3_result_class_methods);
+	INIT_CLASS_ENTRY(ce, "SQLite3Result", class_SQLite3Result_methods);
 	ce.create_object = php_sqlite3_result_object_new;
 	sqlite3_result_object_handlers.offset = XtOffsetOf(php_sqlite3_result, zo);
 	sqlite3_result_object_handlers.clone_obj = NULL;
diff --git a/ext/sqlite3/sqlite3.stub.php b/ext/sqlite3/sqlite3.stub.php
index 18478d85b3..42ba303b00 100644
--- a/ext/sqlite3/sqlite3.stub.php
+++ b/ext/sqlite3/sqlite3.stub.php
@@ -1,7 +1,10 @@
 <?php
 
+/** @generate-function-entries */
+
 class SQLite3
 {
+    /** @alias SQLite3::open */
     public function __construct(string $filename, int $flags = SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE, string $encryption_key = '') {}
 
     /** @return void */
@@ -11,7 +14,7 @@ class SQLite3
     public function close() {}
 
     /** @return array */
-    public function version() {}
+    public static function version() {}
 
     /** @return int */
     public function lastInsertRowID() {}
@@ -42,11 +45,14 @@ class SQLite3
 #endif
 
     /** @return string */
-    public function escapeString(string $value) {}
+    public static function escapeString(string $value) {}
 
     /** @return SQLite3Stmt|false */
     public function prepare(string $query) {}
 
+    /** @return bool */
+    public function exec(string $query) {}
+
     /** @return SQLite3Result|false|null */
     public function query(string $query) {}
 
@@ -77,7 +83,7 @@ class SQLite3
 
 class SQLite3Stmt
 {
-    public function __construct(SQLite3 $sqlite3, string $sql) {}
+    private function __construct(SQLite3 $sqlite3, string $sql) {}
 
     /** @return bool */
     public function bindParam($param_number, &$param, int $type = UNKNOWN) {}
@@ -109,7 +115,7 @@ class SQLite3Stmt
 
 class SQLite3Result
 {
-    public function __construct() {}
+    private function __construct() {}
 
     /** @return int */
     public function numColumns() {}
diff --git a/ext/sqlite3/sqlite3_arginfo.h b/ext/sqlite3/sqlite3_arginfo.h
index 1656a6c023..ab79449dda 100644
--- a/ext/sqlite3/sqlite3_arginfo.h
+++ b/ext/sqlite3/sqlite3_arginfo.h
@@ -49,6 +49,8 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_class_SQLite3_prepare, 0, 0, 1)
 	ZEND_ARG_TYPE_INFO(0, query, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
+#define arginfo_class_SQLite3_exec arginfo_class_SQLite3_prepare
+
 #define arginfo_class_SQLite3_query arginfo_class_SQLite3_prepare
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_class_SQLite3_querySingle, 0, 0, 1)
@@ -145,3 +147,109 @@ ZEND_END_ARG_INFO()
 #define arginfo_class_SQLite3Result_reset arginfo_class_SQLite3_close
 
 #define arginfo_class_SQLite3Result_finalize arginfo_class_SQLite3_close
+
+
+ZEND_METHOD(SQLite3, open);
+ZEND_METHOD(SQLite3, close);
+ZEND_METHOD(SQLite3, version);
+ZEND_METHOD(SQLite3, lastInsertRowID);
+ZEND_METHOD(SQLite3, lastErrorCode);
+ZEND_METHOD(SQLite3, lastExtendedErrorCode);
+ZEND_METHOD(SQLite3, lastErrorMsg);
+ZEND_METHOD(SQLite3, changes);
+ZEND_METHOD(SQLite3, busyTimeout);
+#if !defined(SQLITE_OMIT_LOAD_EXTENSION)
+ZEND_METHOD(SQLite3, loadExtension);
+#endif
+#if SQLITE_VERSION_NUMBER >= 3006011
+ZEND_METHOD(SQLite3, backup);
+#endif
+ZEND_METHOD(SQLite3, escapeString);
+ZEND_METHOD(SQLite3, prepare);
+ZEND_METHOD(SQLite3, exec);
+ZEND_METHOD(SQLite3, query);
+ZEND_METHOD(SQLite3, querySingle);
+ZEND_METHOD(SQLite3, createFunction);
+ZEND_METHOD(SQLite3, createAggregate);
+ZEND_METHOD(SQLite3, createCollation);
+ZEND_METHOD(SQLite3, openBlob);
+ZEND_METHOD(SQLite3, enableExceptions);
+ZEND_METHOD(SQLite3, enableExtendedResultCodes);
+ZEND_METHOD(SQLite3, setAuthorizer);
+ZEND_METHOD(SQLite3Stmt, __construct);
+ZEND_METHOD(SQLite3Stmt, bindParam);
+ZEND_METHOD(SQLite3Stmt, bindValue);
+ZEND_METHOD(SQLite3Stmt, clear);
+ZEND_METHOD(SQLite3Stmt, close);
+ZEND_METHOD(SQLite3Stmt, execute);
+ZEND_METHOD(SQLite3Stmt, getSQL);
+ZEND_METHOD(SQLite3Stmt, paramCount);
+ZEND_METHOD(SQLite3Stmt, readOnly);
+ZEND_METHOD(SQLite3Stmt, reset);
+ZEND_METHOD(SQLite3Result, __construct);
+ZEND_METHOD(SQLite3Result, numColumns);
+ZEND_METHOD(SQLite3Result, columnName);
+ZEND_METHOD(SQLite3Result, columnType);
+ZEND_METHOD(SQLite3Result, fetchArray);
+ZEND_METHOD(SQLite3Result, reset);
+ZEND_METHOD(SQLite3Result, finalize);
+
+
+static const zend_function_entry class_SQLite3_methods[] = {
+	ZEND_MALIAS(SQLite3, __construct, open, arginfo_class_SQLite3___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, open, arginfo_class_SQLite3_open, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, close, arginfo_class_SQLite3_close, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, version, arginfo_class_SQLite3_version, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	ZEND_ME(SQLite3, lastInsertRowID, arginfo_class_SQLite3_lastInsertRowID, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, lastErrorCode, arginfo_class_SQLite3_lastErrorCode, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, lastExtendedErrorCode, arginfo_class_SQLite3_lastExtendedErrorCode, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, lastErrorMsg, arginfo_class_SQLite3_lastErrorMsg, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, changes, arginfo_class_SQLite3_changes, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, busyTimeout, arginfo_class_SQLite3_busyTimeout, ZEND_ACC_PUBLIC)
+#if !defined(SQLITE_OMIT_LOAD_EXTENSION)
+	ZEND_ME(SQLite3, loadExtension, arginfo_class_SQLite3_loadExtension, ZEND_ACC_PUBLIC)
+#endif
+#if SQLITE_VERSION_NUMBER >= 3006011
+	ZEND_ME(SQLite3, backup, arginfo_class_SQLite3_backup, ZEND_ACC_PUBLIC)
+#endif
+	ZEND_ME(SQLite3, escapeString, arginfo_class_SQLite3_escapeString, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	ZEND_ME(SQLite3, prepare, arginfo_class_SQLite3_prepare, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, exec, arginfo_class_SQLite3_exec, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, query, arginfo_class_SQLite3_query, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, querySingle, arginfo_class_SQLite3_querySingle, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, createFunction, arginfo_class_SQLite3_createFunction, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, createAggregate, arginfo_class_SQLite3_createAggregate, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, createCollation, arginfo_class_SQLite3_createCollation, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, openBlob, arginfo_class_SQLite3_openBlob, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, enableExceptions, arginfo_class_SQLite3_enableExceptions, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, enableExtendedResultCodes, arginfo_class_SQLite3_enableExtendedResultCodes, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3, setAuthorizer, arginfo_class_SQLite3_setAuthorizer, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SQLite3Stmt_methods[] = {
+	ZEND_ME(SQLite3Stmt, __construct, arginfo_class_SQLite3Stmt___construct, ZEND_ACC_PRIVATE)
+	ZEND_ME(SQLite3Stmt, bindParam, arginfo_class_SQLite3Stmt_bindParam, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3Stmt, bindValue, arginfo_class_SQLite3Stmt_bindValue, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3Stmt, clear, arginfo_class_SQLite3Stmt_clear, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3Stmt, close, arginfo_class_SQLite3Stmt_close, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3Stmt, execute, arginfo_class_SQLite3Stmt_execute, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3Stmt, getSQL, arginfo_class_SQLite3Stmt_getSQL, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3Stmt, paramCount, arginfo_class_SQLite3Stmt_paramCount, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3Stmt, readOnly, arginfo_class_SQLite3Stmt_readOnly, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3Stmt, reset, arginfo_class_SQLite3Stmt_reset, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SQLite3Result_methods[] = {
+	ZEND_ME(SQLite3Result, __construct, arginfo_class_SQLite3Result___construct, ZEND_ACC_PRIVATE)
+	ZEND_ME(SQLite3Result, numColumns, arginfo_class_SQLite3Result_numColumns, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3Result, columnName, arginfo_class_SQLite3Result_columnName, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3Result, columnType, arginfo_class_SQLite3Result_columnType, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3Result, fetchArray, arginfo_class_SQLite3Result_fetchArray, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3Result, reset, arginfo_class_SQLite3Result_reset, ZEND_ACC_PUBLIC)
+	ZEND_ME(SQLite3Result, finalize, arginfo_class_SQLite3Result_finalize, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
-- 
2.40.0