diff --git a/ext-src/swoole_async_coro.cc b/ext-src/swoole_async_coro.cc
index 19c5c92dad1..e0466bfadea 100644
--- a/ext-src/swoole_async_coro.cc
+++ b/ext-src/swoole_async_coro.cc
@@ -128,11 +128,15 @@ PHP_FUNCTION(swoole_async_dns_lookup_coro) {
     Coroutine::get_current_safe();
 
     zval *domain;
-    long type = AF_INET;
+    zend_long type = AF_INET;
     double timeout = swoole::network::Socket::default_dns_timeout;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|dl", &domain, &timeout, &type) == FAILURE) {
-        RETURN_FALSE;
-    }
+
+    ZEND_PARSE_PARAMETERS_START(1, 3)
+    Z_PARAM_ZVAL(domain)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_DOUBLE(timeout)
+    Z_PARAM_LONG(type)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     if (Z_TYPE_P(domain) != IS_STRING) {
         php_swoole_fatal_error(E_WARNING, "invalid domain name");
diff --git a/ext-src/swoole_coroutine.cc b/ext-src/swoole_coroutine.cc
index 17f64960f3c..8e1e72beb4d 100644
--- a/ext-src/swoole_coroutine.cc
+++ b/ext-src/swoole_coroutine.cc
@@ -1169,10 +1169,11 @@ static PHP_METHOD(swoole_coroutine, exists) {
 }
 
 static PHP_METHOD(swoole_coroutine, resume) {
-    long cid;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &cid) == FAILURE) {
-        RETURN_FALSE;
-    }
+    zend_long cid;
+
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+    Z_PARAM_LONG(cid)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     auto coroutine_iterator = user_yield_coros.find(cid);
     if (coroutine_iterator == user_yield_coros.end()) {
@@ -1283,10 +1284,11 @@ static PHP_METHOD(swoole_coroutine, join) {
 }
 
 static PHP_METHOD(swoole_coroutine, cancel) {
-    long cid;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &cid) == FAILURE) {
-        RETURN_FALSE;
-    }
+    zend_long cid;
+
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+    Z_PARAM_LONG(cid)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     Coroutine *co = swoole_coroutine_get(cid);
     if (!co) {
diff --git a/ext-src/swoole_coroutine_system.cc b/ext-src/swoole_coroutine_system.cc
index 952f3b37335..ab474752770 100644
--- a/ext-src/swoole_coroutine_system.cc
+++ b/ext-src/swoole_coroutine_system.cc
@@ -128,9 +128,12 @@ PHP_FUNCTION(swoole_coroutine_gethostbyname) {
     zend_long family = AF_INET;
     double timeout = -1;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|ld", &domain_name, &l_domain_name, &family, &timeout) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(1, 3)
+    Z_PARAM_STRING(domain_name, l_domain_name)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_LONG(family)
+    Z_PARAM_DOUBLE(timeout)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     if (l_domain_name == 0) {
         php_swoole_fatal_error(E_WARNING, "domain name is empty");
@@ -164,18 +167,15 @@ PHP_METHOD(swoole_coroutine_system, getaddrinfo) {
     size_t l_service = 0;
     double timeout = -1;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(),
-                              "s|lllsd",
-                              &hostname,
-                              &l_hostname,
-                              &family,
-                              &socktype,
-                              &protocol,
-                              &service,
-                              &l_service,
-                              &timeout) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(1, 6)
+    Z_PARAM_STRING(hostname, l_hostname)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_LONG(family)
+    Z_PARAM_LONG(socktype)
+    Z_PARAM_LONG(protocol)
+    Z_PARAM_STRING(service, l_service)
+    Z_PARAM_DOUBLE(timeout)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     if (l_hostname == 0) {
         php_swoole_fatal_error(E_WARNING, "hostname is empty");
diff --git a/ext-src/swoole_http2_client_coro.cc b/ext-src/swoole_http2_client_coro.cc
index 9537f446e34..f59d8050a96 100644
--- a/ext-src/swoole_http2_client_coro.cc
+++ b/ext-src/swoole_http2_client_coro.cc
@@ -1428,9 +1428,11 @@ static PHP_METHOD(swoole_http2_client_coro, stats) {
 
 static PHP_METHOD(swoole_http2_client_coro, isStreamExist) {
     zend_long stream_id = 0;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &stream_id) == FAILURE) {
-        RETURN_FALSE;
-    }
+
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+    Z_PARAM_LONG(stream_id)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+
     if (stream_id < 0) {
         RETURN_FALSE;
     }
diff --git a/ext-src/swoole_http_response.cc b/ext-src/swoole_http_response.cc
index 5f412d98edd..e977dfb9854 100644
--- a/ext-src/swoole_http_response.cc
+++ b/ext-src/swoole_http_response.cc
@@ -208,9 +208,10 @@ void php_swoole_http_response_minit(int module_number) {
 
 static PHP_METHOD(swoole_http_response, write) {
     zval *zdata;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zdata) == FAILURE) {
-        RETURN_FALSE;
-    }
+
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+    Z_PARAM_ZVAL(zdata)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     HttpContext *ctx = php_swoole_http_response_get_and_check_context(ZEND_THIS);
     if (UNEXPECTED(!ctx)) {
@@ -920,9 +921,12 @@ static PHP_METHOD(swoole_http_response, sendfile) {
     zend_long offset = 0;
     zend_long length = 0;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|ll", &file, &l_file, &offset, &length) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(1, 3)
+    Z_PARAM_STRING(file, l_file)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_LONG(offset)
+    Z_PARAM_LONG(length)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     if (l_file == 0) {
         php_swoole_error(E_WARNING, "file name is empty");
@@ -1128,13 +1132,16 @@ static PHP_METHOD(swoole_http_response, goaway) {
         php_swoole_fatal_error(E_WARNING, "fd[%ld] is not a HTTP2 conncetion", ctx->fd);
         RETURN_FALSE;
     }
+
     zend_long error_code = SW_HTTP2_ERROR_NO_ERROR;
     char *debug_data = nullptr;
     size_t debug_data_len = 0;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "|ls", &error_code, &debug_data, &debug_data_len) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(0, 2)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_LONG(error_code)
+    Z_PARAM_STRING(debug_data, debug_data_len)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     SW_CHECK_RETURN(swoole_http2_server_goaway(ctx, error_code, debug_data, debug_data_len));
 }
diff --git a/ext-src/swoole_lock.cc b/ext-src/swoole_lock.cc
index 36dc18f5ade..5481317e294 100644
--- a/ext-src/swoole_lock.cc
+++ b/ext-src/swoole_lock.cc
@@ -177,9 +177,11 @@ static PHP_METHOD(swoole_lock, lock) {
 static PHP_METHOD(swoole_lock, lockwait) {
     double timeout = 1.0;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "d", &timeout) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(0, 1)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_DOUBLE(timeout)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+
     Lock *lock = php_swoole_lock_get_and_check_ptr(ZEND_THIS);
     if (lock->get_type() != Lock::MUTEX) {
         zend_throw_exception(swoole_exception_ce, "only mutex supports lockwait", -2);
diff --git a/ext-src/swoole_redis_server.cc b/ext-src/swoole_redis_server.cc
index bb427cda020..1058bce9d0b 100644
--- a/ext-src/swoole_redis_server.cc
+++ b/ext-src/swoole_redis_server.cc
@@ -195,9 +195,10 @@ static PHP_METHOD(swoole_redis_server, setHandler) {
     size_t command_len;
     zval *zcallback;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz", &command, &command_len, &zcallback) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(2, 2)
+    Z_PARAM_STRING(command, command_len)
+    Z_PARAM_ZVAL(zcallback)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     if (command_len == 0 || command_len >= SW_REDIS_MAX_COMMAND_SIZE) {
         php_swoole_fatal_error(E_ERROR, "invalid command");
@@ -234,9 +235,9 @@ static PHP_METHOD(swoole_redis_server, getHandler) {
     char *command;
     size_t command_len;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &command, &command_len) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+    Z_PARAM_STRING(command, command_len)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     char _command[SW_REDIS_MAX_COMMAND_SIZE];
     size_t _command_len = sw_snprintf(_command, sizeof(_command), "_handler_%s", command);
@@ -251,9 +252,11 @@ static PHP_METHOD(swoole_redis_server, format) {
     zend_long type;
     zval *value = nullptr;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|z", &type, &value) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(1, 2)
+    Z_PARAM_LONG(type)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_ZVAL(value)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     char message[256];
     int length;
diff --git a/ext-src/swoole_server.cc b/ext-src/swoole_server.cc
index 1097a367090..43c2ac5304d 100644
--- a/ext-src/swoole_server.cc
+++ b/ext-src/swoole_server.cc
@@ -2431,9 +2431,10 @@ static PHP_METHOD(swoole_server, on) {
     zval *name;
     zval *cb;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &name, &cb) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(2, 2)
+    Z_PARAM_ZVAL(name)
+    Z_PARAM_ZVAL(cb)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     char *func_name = nullptr;
     zend_fcall_info_cache *fci_cache = (zend_fcall_info_cache *) emalloc(sizeof(zend_fcall_info_cache));
@@ -2509,9 +2510,11 @@ static PHP_METHOD(swoole_server, listen) {
     long sock_type;
     long port;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "sll", &host, &host_len, &port, &sock_type) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(3, 3)
+    Z_PARAM_STRING(host, host_len)
+    Z_PARAM_LONG(port)
+    Z_PARAM_LONG(sock_type)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     ListenPort *ls = serv->add_port((enum swSocketType) sock_type, host, (int) port);
     if (!ls) {
@@ -2534,18 +2537,13 @@ static PHP_METHOD(swoole_server, addProcess) {
 
     int worker_id;
     Worker *worker;
-    zval *process = nullptr;
-
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &process) == FAILURE) {
-        RETURN_FALSE;
-    }
+    zval *process;
 
-    if (ZVAL_IS_NULL(process)) {
-        php_swoole_fatal_error(E_WARNING, "the first parameter can't be empty");
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+    Z_PARAM_ZVAL(process)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
-    if (!instanceof_function(Z_OBJCE_P(process), swoole_process_ce)) {
+    if (!ZVAL_IS_OBJECT(process) || !instanceof_function(Z_OBJCE_P(process), swoole_process_ce)) {
         php_swoole_fatal_error(E_ERROR, "object is not instanceof swoole_process");
         RETURN_FALSE;
     }
@@ -2851,9 +2849,13 @@ static PHP_METHOD(swoole_server, sendfile) {
     zend_long offset = 0;
     zend_long length = 0;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "ls|ll", &fd, &filename, &len, &offset, &length) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(2, 4)
+    Z_PARAM_LONG(fd)
+    Z_PARAM_STRING(filename, len)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_LONG(offset)
+    Z_PARAM_LONG(length)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     if (serv->is_master()) {
         php_swoole_fatal_error(E_WARNING, "can't sendfile[%s] to the connections in master process", filename);
@@ -2890,9 +2892,11 @@ static PHP_METHOD(swoole_server, pause) {
     }
 
     zend_long fd;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &fd) == FAILURE) {
-        RETURN_FALSE;
-    }
+
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+    Z_PARAM_LONG(fd)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+
     Connection *conn = serv->get_connection_verify(fd);
     if (!conn) {
         swoole_set_last_error(SW_ERROR_SESSION_NOT_EXIST);
@@ -2909,9 +2913,11 @@ static PHP_METHOD(swoole_server, resume) {
     }
 
     zend_long fd;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &fd) == FAILURE) {
-        RETURN_FALSE;
-    }
+
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+    Z_PARAM_LONG(fd)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+
     Connection *conn = serv->get_connection_verify(fd);
     if (!conn) {
         swoole_set_last_error(SW_ERROR_SESSION_NOT_EXIST);
@@ -2981,11 +2987,13 @@ static PHP_METHOD(swoole_server, reload) {
         php_swoole_fatal_error(E_WARNING, "not supported with single process mode");
         RETURN_FALSE;
     }
+
     zend_bool only_reload_taskworker = 0;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &only_reload_taskworker) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(0, 1)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_BOOL(only_reload_taskworker)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     int signo = only_reload_taskworker ? SIGUSR2 : SIGUSR1;
     if (swoole_kill(serv->gs->manager_pid, signo) < 0) {
@@ -3004,9 +3012,10 @@ static PHP_METHOD(swoole_server, heartbeat) {
 
     zend_bool close_connection = 0;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &close_connection) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(0, 1)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_BOOL(close_connection)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     if (serv->heartbeat_check_interval < 1) {
         RETURN_FALSE;
@@ -3051,9 +3060,12 @@ static PHP_METHOD(swoole_server, taskwait) {
     double timeout = SW_TASKWAIT_TIMEOUT;
     zend_long dst_worker_id = -1;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|dl", &zdata, &timeout, &dst_worker_id) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(1, 3)
+    Z_PARAM_ZVAL(zdata)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_DOUBLE(timeout)
+    Z_PARAM_LONG(dst_worker_id)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     if (php_swoole_server_task_check_param(serv, dst_worker_id) < 0) {
         RETURN_FALSE;
@@ -3598,9 +3610,10 @@ static PHP_METHOD(swoole_server, bind) {
     zend_long fd = 0;
     zend_long uid = 0;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "ll", &fd, &uid) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(2, 2)
+    Z_PARAM_LONG(fd)
+    Z_PARAM_LONG(uid)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     if (uid > UINT32_MAX || uid < INT32_MIN) {
         php_swoole_fatal_error(E_WARNING, "uid can not be greater than %u or less than %d", UINT32_MAX, INT32_MIN);
@@ -3628,9 +3641,10 @@ static PHP_METHOD(swoole_server, getSocket) {
 
     zend_long port = 0;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &port) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(0, 1)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_LONG(port)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     const ListenPort *lp = serv->get_port(port);
     php_socket *socket_object = php_swoole_convert_to_socket(lp->get_fd());
@@ -3655,9 +3669,12 @@ static PHP_METHOD(swoole_server, getClientInfo) {
     zend_long reactor_id = -1;
     zend_bool dont_check_connection = 0;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|lb", &fd, &reactor_id, &dont_check_connection) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(1, 3)
+    Z_PARAM_LONG(fd)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_LONG(reactor_id)
+    Z_PARAM_BOOL(dont_check_connection)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     Connection *conn = serv->get_connection_verify(fd);
     if (!conn) {
@@ -3719,9 +3736,11 @@ static PHP_METHOD(swoole_server, getClientList) {
     zend_long start_session_id = 0;
     zend_long find_count = 10;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "|ll", &start_session_id, &find_count) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(0, 2)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_LONG(start_session_id)
+    Z_PARAM_LONG(find_count)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     // exceeded the maximum number of searches
     if (find_count > SW_MAX_FIND_COUNT) {
@@ -3782,9 +3801,10 @@ static PHP_METHOD(swoole_server, sendwait) {
     zend_long fd;
     zval *zdata;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "lz", &fd, &zdata) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(2, 2)
+    Z_PARAM_LONG(fd)
+    Z_PARAM_ZVAL(zdata)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     char *data;
     size_t length = php_swoole_get_send_data(zdata, &data);
@@ -3833,9 +3853,11 @@ static PHP_METHOD(swoole_server, protect) {
     zend_long session_id;
     zend_bool value = 1;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|b", &session_id, &value) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(1, 2)
+    Z_PARAM_LONG(session_id)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_BOOL(value)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     Connection *conn = serv->get_connection_verify(session_id);
     if (!conn || conn->closed) {
@@ -3863,9 +3885,11 @@ static PHP_METHOD(swoole_server, getWorkerStatus) {
     }
 
     zend_long worker_id = -1;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &worker_id) == FAILURE) {
-        RETURN_FALSE;
-    }
+
+    ZEND_PARSE_PARAMETERS_START(0, 1)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_LONG(worker_id)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     Worker *worker;
     if (worker_id == -1) {
@@ -3884,9 +3908,12 @@ static PHP_METHOD(swoole_server, getWorkerStatus) {
 static PHP_METHOD(swoole_server, getWorkerPid) {
     Server *serv = php_swoole_server_get_and_check_server(ZEND_THIS);
     zend_long worker_id = -1;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &worker_id) == FAILURE) {
-        RETURN_FALSE;
-    }
+
+    ZEND_PARSE_PARAMETERS_START(0, 1)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_LONG(worker_id)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+
     Worker *worker = worker_id < 0 ? sw_worker() : serv->get_worker(worker_id);
     if (!worker) {
         RETURN_FALSE;
@@ -3994,9 +4021,11 @@ static PHP_METHOD(swoole_connection_iterator, offsetExists) {
     zval *zserv = php_swoole_server_zval_ptr(iterator->serv);
     zval *zfd;
     zval retval;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zfd) == FAILURE) {
-        RETURN_FALSE;
-    }
+
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+    Z_PARAM_ZVAL(zfd)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+
     sw_zend_call_method_with_1_params(zserv, swoole_server_ce, nullptr, "exists", &retval, zfd);
     RETVAL_BOOL(Z_BVAL_P(&retval));
 }
@@ -4006,9 +4035,11 @@ static PHP_METHOD(swoole_connection_iterator, offsetGet) {
     zval *zserv = php_swoole_server_zval_ptr(iterator->serv);
     zval *zfd;
     zval retval;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zfd) == FAILURE) {
-        RETURN_FALSE;
-    }
+
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+    Z_PARAM_ZVAL(zfd)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+
     sw_zend_call_method_with_1_params(zserv, swoole_server_ce, nullptr, "getClientInfo", &retval, zfd);
     RETVAL_ZVAL(&retval, 0, 0);
 }
diff --git a/ext-src/swoole_server_port.cc b/ext-src/swoole_server_port.cc
index 28b0f51197e..2feb2940353 100644
--- a/ext-src/swoole_server_port.cc
+++ b/ext-src/swoole_server_port.cc
@@ -627,9 +627,10 @@ static PHP_METHOD(swoole_server_port, on) {
         RETURN_FALSE;
     }
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz", &name, &len, &cb) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(2, 2)
+    Z_PARAM_STRING(name, len)
+    Z_PARAM_ZVAL(cb)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     char *func_name = nullptr;
     zend_fcall_info_cache *fci_cache = (zend_fcall_info_cache *) emalloc(sizeof(zend_fcall_info_cache));
diff --git a/ext-src/swoole_socket_coro.cc b/ext-src/swoole_socket_coro.cc
index fef52ea7d61..0d316ae3082 100644
--- a/ext-src/swoole_socket_coro.cc
+++ b/ext-src/swoole_socket_coro.cc
@@ -1743,9 +1743,13 @@ static PHP_METHOD(swoole_socket_coro, sendFile) {
     zend_long offset = 0;
     zend_long length = 0;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|ll", &file, &file_len, &offset, &length) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(1, 3)
+    Z_PARAM_STRING(file, file_len)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_LONG(offset)
+    Z_PARAM_LONG(length)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+
     if (file_len == 0) {
         php_swoole_fatal_error(E_WARNING, "file to send is empty");
         RETURN_FALSE;
@@ -1905,9 +1909,10 @@ static PHP_METHOD(swoole_socket_coro, getOption) {
     int other_val;
     zend_long level, optname;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "ll", &level, &optname) == FAILURE) {
-        return;
-    }
+    ZEND_PARSE_PARAMETERS_START(2, 2)
+    Z_PARAM_LONG(level)
+    Z_PARAM_LONG(optname)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     swoole_get_socket_coro(sock, ZEND_THIS);
     auto _socket = sock->socket->get_socket();
@@ -2005,9 +2010,11 @@ static PHP_METHOD(swoole_socket_coro, setOption) {
     zval *l_onoff, *l_linger;
     zval *sec, *usec;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "llz", &level, &optname, &arg4) == FAILURE) {
-        return;
-    }
+    ZEND_PARSE_PARAMETERS_START(3, 3)
+    Z_PARAM_LONG(level)
+    Z_PARAM_LONG(optname)
+    Z_PARAM_ZVAL(arg4)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     swoole_get_socket_coro(sock, ZEND_THIS);
 
diff --git a/ext-src/swoole_thread_lock.cc b/ext-src/swoole_thread_lock.cc
index df6aa88e717..e52c2bf6775 100644
--- a/ext-src/swoole_thread_lock.cc
+++ b/ext-src/swoole_thread_lock.cc
@@ -183,9 +183,11 @@ static PHP_METHOD(swoole_thread_lock, lock) {
 static PHP_METHOD(swoole_thread_lock, lockwait) {
     double timeout = 1.0;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "d", &timeout) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(0, 1)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_DOUBLE(timeout)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+
     Lock *lock = lock_get_and_check_ptr(ZEND_THIS);
     if (lock->get_type() != Lock::MUTEX) {
         zend_throw_exception(swoole_exception_ce, "only mutex supports lockwait", -2);
diff --git a/ext-src/swoole_websocket_server.cc b/ext-src/swoole_websocket_server.cc
index e471a738b24..970649cca97 100644
--- a/ext-src/swoole_websocket_server.cc
+++ b/ext-src/swoole_websocket_server.cc
@@ -752,9 +752,13 @@ static PHP_METHOD(swoole_websocket_server, disconnect) {
     char *data = nullptr;
     size_t length = 0;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|ls", &fd, &code, &data, &length) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(1, 3)
+    Z_PARAM_LONG(fd)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_LONG(code)
+    Z_PARAM_STRING(data, length)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+
     swoole_websocket_buffer->clear();
     if (WebSocket::pack_close_frame(swoole_websocket_buffer, code, data, length, 0) < 0) {
         RETURN_FALSE;
@@ -894,9 +898,9 @@ static PHP_METHOD(swoole_websocket_frame, __toString) {
 static PHP_METHOD(swoole_websocket_server, unpack) {
     String buffer = {};
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &buffer.str, &buffer.length) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+    Z_PARAM_STRING(buffer.str, buffer.length)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     php_swoole_websocket_frame_unpack(&buffer, return_value);
 }
@@ -910,9 +914,9 @@ static PHP_METHOD(swoole_websocket_server, isEstablished) {
 
     zend_long session_id;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &session_id) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+    Z_PARAM_LONG(session_id)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     Connection *conn = serv->get_connection_verify(session_id);
     // not isEstablished