#53: + Apply code format

Author: EdmondDantes

async.c

@@ -910,7 +910,8 @@ static PHP_GINIT_FUNCTION(async)
 }
 
 /* {{{ PHP_GSHUTDOWN_FUNCTION */
-static PHP_GSHUTDOWN_FUNCTION(async){
+static PHP_GSHUTDOWN_FUNCTION(async)
+{
 #ifdef PHP_WIN32
 #endif
 } /* }}} */

async_API.c

@@ -610,8 +610,8 @@ static void await_iterator_dispose(async_await_iterator_t *iterator, async_itera
 		iterator->zend_iterator = NULL;
 
 		// When the iterator has finished, it’s now possible to specify the exact number of elements since it’s known.
-		iterator->await_context->total = iterator->await_context->futures_count +
-										 iterator->await_context->resolved_count;
+		iterator->await_context->total =
+				iterator->await_context->futures_count + iterator->await_context->resolved_count;
 
 		// Scenario: the iterator has already finished, and there’s nothing left to await.
 		// In that case, the coroutine needs to be terminated.

coroutine.c

@@ -49,7 +49,10 @@ static void coroutine_event_start(zend_async_event_t *event);
 static void coroutine_event_stop(zend_async_event_t *event);
 static void coroutine_add_callback(zend_async_event_t *event, zend_async_event_callback_t *callback);
 static void coroutine_del_callback(zend_async_event_t *event, zend_async_event_callback_t *callback);
-static bool coroutine_replay(zend_async_event_t *event, zend_async_event_callback_t *callback, zval *result, zend_object **exception);
+static bool coroutine_replay(zend_async_event_t *event,
+							 zend_async_event_callback_t *callback,
+							 zval *result,
+							 zend_object **exception);
 static zend_string *coroutine_info(zend_async_event_t *event);
 static void coroutine_dispose(zend_async_event_t *event);
 
@@ -286,7 +289,8 @@ static HashTable *async_coroutine_object_gc(zend_object *object, zval **table, i
 	async_fiber_context_t *fiber_context = coroutine->fiber_context;
 
 	/* Check if we should traverse execution stack (similar to fibers) */
-	if (fiber_context == NULL || (fiber_context->context.status != ZEND_FIBER_STATUS_SUSPENDED || !fiber_context->execute_data)) {
+	if (fiber_context == NULL ||
+		(fiber_context->context.status != ZEND_FIBER_STATUS_SUSPENDED || !fiber_context->execute_data)) {
 		zend_get_gc_buffer_use(buf, table, num);
 		return NULL;
 	}
@@ -394,7 +398,7 @@ ZEND_STACK_ALIGNED void async_coroutine_execute(async_coroutine_t *coroutine)
 
 		coroutine->coroutine.event.dispose(&coroutine->coroutine.event);
 
-		if(EXPECTED(ZEND_ASYNC_CURRENT_COROUTINE == &coroutine->coroutine)) {
+		if (EXPECTED(ZEND_ASYNC_CURRENT_COROUTINE == &coroutine->coroutine)) {
 			ZEND_ASYNC_CURRENT_COROUTINE = NULL;
 		}
 
@@ -405,7 +409,7 @@ ZEND_STACK_ALIGNED void async_coroutine_execute(async_coroutine_t *coroutine)
 		zend_error(E_ERROR, "Attempt to resume a coroutine that has not been resolved");
 		coroutine->coroutine.event.dispose(&coroutine->coroutine.event);
 
-		if(EXPECTED(ZEND_ASYNC_CURRENT_COROUTINE == &coroutine->coroutine)) {
+		if (EXPECTED(ZEND_ASYNC_CURRENT_COROUTINE == &coroutine->coroutine)) {
 			ZEND_ASYNC_CURRENT_COROUTINE = NULL;
 		}
 
@@ -460,7 +464,7 @@ ZEND_STACK_ALIGNED void async_coroutine_execute(async_coroutine_t *coroutine)
 	}
 	zend_end_try();
 
-	if(EXPECTED(ZEND_ASYNC_CURRENT_COROUTINE == &coroutine->coroutine)) {
+	if (EXPECTED(ZEND_ASYNC_CURRENT_COROUTINE == &coroutine->coroutine)) {
 		ZEND_ASYNC_CURRENT_COROUTINE = NULL;
 	}
 
@@ -901,8 +905,7 @@ static zend_string *coroutine_info(zend_async_event_t *event)
 							   coroutine->std.handle,
 							   coroutine->coroutine.filename ? ZSTR_VAL(coroutine->coroutine.filename) : "",
 							   coroutine->coroutine.lineno,
-							   coroutine->waker.filename ? ZSTR_VAL(coroutine->waker.filename)
-																	: "",
+							   coroutine->waker.filename ? ZSTR_VAL(coroutine->waker.filename) : "",
 							   coroutine->waker.lineno,
 							   ZSTR_VAL(zend_coroutine_name));
 	} else {
@@ -1348,8 +1351,7 @@ METHOD(getSuspendLocation)
 	async_coroutine_t *coroutine = THIS_COROUTINE;
 
 	if (coroutine->waker.filename) {
-		RETURN_STR(zend_strpprintf(
-				0, "%s:%d", ZSTR_VAL(coroutine->waker.filename), coroutine->waker.lineno));
+		RETURN_STR(zend_strpprintf(0, "%s:%d", ZSTR_VAL(coroutine->waker.filename), coroutine->waker.lineno));
 	} else {
 		RETURN_STRING("unknown");
 	}

coroutine.h

@@ -29,7 +29,7 @@ struct _async_fiber_context_s
 
 	/* Active fiber VM stack */
 	zend_vm_stack vm_stack;
-	
+
 	/* Current Zend VM execute data */
 	zend_execute_data *execute_data;
 
@@ -47,7 +47,7 @@ struct _async_coroutine_s
 
 	/* Basic structure for coroutine. */
 	zend_coroutine_t coroutine;
-	
+
 	/* Embedded waker (always allocated, no malloc needed) */
 	zend_async_waker_t waker;
 

exceptions.c

@@ -201,7 +201,8 @@ PHP_ASYNC_API ZEND_COLD zend_object *async_new_composite_exception(void)
 	return Z_OBJ(composite);
 }
 
-PHP_ASYNC_API void async_composite_exception_add_exception(zend_object *composite, zend_object *exception, bool transfer)
+PHP_ASYNC_API void
+async_composite_exception_add_exception(zend_object *composite, zend_object *exception, bool transfer)
 {
 	if (composite == NULL || exception == NULL) {
 		return;
@@ -308,10 +309,11 @@ zend_object *async_extract_exception(void)
  */
 void async_apply_exception(zend_object **to_exception)
 {
-	if (UNEXPECTED(EG(exception) &&
-				   false ==
-						   (instanceof_function(EG(exception)->ce, ZEND_ASYNC_GET_CE(ZEND_ASYNC_EXCEPTION_CANCELLATION)) ||
-							zend_is_graceful_exit(EG(exception)) || zend_is_unwind_exit(EG(exception))))) {
+	if (UNEXPECTED(
+				EG(exception) &&
+				false ==
+						(instanceof_function(EG(exception)->ce, ZEND_ASYNC_GET_CE(ZEND_ASYNC_EXCEPTION_CANCELLATION)) ||
+						 zend_is_graceful_exit(EG(exception)) || zend_is_unwind_exit(EG(exception))))) {
 
 		zend_object *exception = async_extract_exception();
 

exceptions.h

@@ -39,7 +39,8 @@ PHP_ASYNC_API ZEND_COLD zend_object *async_throw_input_output(const char *format
 PHP_ASYNC_API ZEND_COLD zend_object *async_throw_timeout(const char *format, const zend_long timeout);
 PHP_ASYNC_API ZEND_COLD zend_object *async_throw_poll(const char *format, ...);
 PHP_ASYNC_API ZEND_COLD zend_object *async_new_composite_exception(void);
-PHP_ASYNC_API void async_composite_exception_add_exception(zend_object *composite, zend_object *exception, bool transfer);
+PHP_ASYNC_API void
+async_composite_exception_add_exception(zend_object *composite, zend_object *exception, bool transfer);
 bool async_spawn_and_throw(zend_object *exception, zend_async_scope_t *scope, int32_t priority);
 void async_apply_exception_to_context(zend_object *exception);
 zend_object *async_extract_exception(void);

internal/circular_buffer.h

@@ -83,46 +83,51 @@ zend_result zval_circular_buffer_pop(circular_buffer_t *buffer, zval *value);
 /* Inline optimized functions - placed after all declarations */
 
 /* Inline version for hot path performance */
-static zend_always_inline bool circular_buffer_is_not_empty(const circular_buffer_t *buffer) {
-    return buffer->head != buffer->tail;
+static zend_always_inline bool circular_buffer_is_not_empty(const circular_buffer_t *buffer)
+{
+	return buffer->head != buffer->tail;
 }
 
-static zend_always_inline void circular_buffer_clean(circular_buffer_t *buffer) {
+static zend_always_inline void circular_buffer_clean(circular_buffer_t *buffer)
+{
 	buffer->head = buffer->tail;
 }
 
 /* Fast specialized version for pointer push (8 bytes) */
-static zend_always_inline zend_result circular_buffer_push_ptr(circular_buffer_t *buffer, void *ptr) {
-    // Check if buffer is full using bitwise AND (capacity is power of 2)
-    if (EXPECTED(((buffer->head + 1) & (buffer->capacity - 1)) != buffer->tail)) {
-        // Direct pointer assignment - no memcpy overhead
-        *(void**)((char*)buffer->data + buffer->head * sizeof(void*)) = ptr;
-        buffer->head = (buffer->head + 1) & (buffer->capacity - 1);
-        return SUCCESS;
-    }
-    return FAILURE;
+static zend_always_inline zend_result circular_buffer_push_ptr(circular_buffer_t *buffer, void *ptr)
+{
+	// Check if buffer is full using bitwise AND (capacity is power of 2)
+	if (EXPECTED(((buffer->head + 1) & (buffer->capacity - 1)) != buffer->tail)) {
+		// Direct pointer assignment - no memcpy overhead
+		*(void **) ((char *) buffer->data + buffer->head * sizeof(void *)) = ptr;
+		buffer->head = (buffer->head + 1) & (buffer->capacity - 1);
+		return SUCCESS;
+	}
+	return FAILURE;
 }
 
 /* Fast specialized version for pointer pop (8 bytes) */
-static zend_always_inline zend_result circular_buffer_pop_ptr(circular_buffer_t *buffer, void **ptr) {
-    // Check if buffer is empty
-    if (EXPECTED(buffer->head != buffer->tail)) {
-        // Direct pointer read - no memcpy overhead
-        *ptr = *(void**)((char*)buffer->data + buffer->tail * sizeof(void*));
-        buffer->tail = (buffer->tail + 1) & (buffer->capacity - 1);
-        return SUCCESS;
-    }
-    return FAILURE;
+static zend_always_inline zend_result circular_buffer_pop_ptr(circular_buffer_t *buffer, void **ptr)
+{
+	// Check if buffer is empty
+	if (EXPECTED(buffer->head != buffer->tail)) {
+		// Direct pointer read - no memcpy overhead
+		*ptr = *(void **) ((char *) buffer->data + buffer->tail * sizeof(void *));
+		buffer->tail = (buffer->tail + 1) & (buffer->capacity - 1);
+		return SUCCESS;
+	}
+	return FAILURE;
 }
 
 /* Smart wrapper for pointer push with resize fallback */
-static zend_always_inline zend_result circular_buffer_push_ptr_with_resize(circular_buffer_t *buffer, void *ptr) {
-    // Try fast path first (no resize)
-    if (EXPECTED(circular_buffer_push_ptr(buffer, ptr) == SUCCESS)) {
-        return SUCCESS;
-    }
-    // Fallback to slow path with resize - need address of ptr for memcpy
-    return circular_buffer_push(buffer, &ptr, true);
+static zend_always_inline zend_result circular_buffer_push_ptr_with_resize(circular_buffer_t *buffer, void *ptr)
+{
+	// Try fast path first (no resize)
+	if (EXPECTED(circular_buffer_push_ptr(buffer, ptr) == SUCCESS)) {
+		return SUCCESS;
+	}
+	// Fallback to slow path with resize - need address of ptr for memcpy
+	return circular_buffer_push(buffer, &ptr, true);
 }
 
 #endif // ASYNC_CIRCULAR_BUFFER_V2_H

libuv_reactor.c

@@ -199,7 +199,7 @@ static void libuv_close_handle_cb(uv_handle_t *handle)
 /* {{{ libuv_close_poll_handle_cb */
 static void libuv_close_poll_handle_cb(uv_handle_t *handle)
 {
-	async_poll_event_t *poll = (async_poll_event_t *)handle->data;
+	async_poll_event_t *poll = (async_poll_event_t *) handle->data;
 
 	/* Check if PHP requested descriptor closure after event cleanup */
 	if (ZEND_ASYNC_EVENT_SHOULD_CLOSE_FD(&poll->event.base)) {
@@ -213,7 +213,7 @@ static void libuv_close_poll_handle_cb(uv_handle_t *handle)
 		} else if (!poll->event.is_socket && poll->event.file != ZEND_FD_NULL) {
 			/* File descriptor cleanup */
 #ifdef PHP_WIN32
-			CloseHandle((HANDLE)poll->event.file);
+			CloseHandle((HANDLE) poll->event.file);
 #else
 			close(poll->event.file);
 #endif
@@ -246,7 +246,8 @@ static void libuv_remove_callback(zend_async_event_t *event, zend_async_event_ca
 //////////////////////////////////////////////////////////////////////////////
 
 /* Forward declaration */
-static zend_always_inline void async_poll_notify_proxies(async_poll_event_t *poll, async_poll_event triggered_events, zend_object *exception);
+static zend_always_inline void
+async_poll_notify_proxies(async_poll_event_t *poll, async_poll_event triggered_events, zend_object *exception);
 
 /* {{{ on_poll_event */
 static void on_poll_event(uv_poll_t *handle, int status, int events)
@@ -359,7 +360,8 @@ static void libuv_poll_dispose(zend_async_event_t *event)
 /* }}} */
 
 /* {{{ async_poll_notify_proxies */
-static zend_always_inline void async_poll_notify_proxies(async_poll_event_t *poll, async_poll_event triggered_events, zend_object *exception)
+static zend_always_inline void
+async_poll_notify_proxies(async_poll_event_t *poll, async_poll_event triggered_events, zend_object *exception)
 {
 	/* Process each proxy that matches triggered events */
 	for (uint32_t i = 0; i < poll->proxies_count; i++) {
@@ -381,6 +383,7 @@ static zend_always_inline void async_poll_notify_proxies(async_poll_event_t *pol
 		}
 	}
 }
+
 /* }}} */
 
 /* {{{ async_poll_add_proxy */
@@ -394,11 +397,12 @@ static zend_always_inline void async_poll_add_proxy(async_poll_event_t *poll, ze
 	if (poll->proxies_count == poll->proxies_capacity) {
 		poll->proxies_capacity *= 2;
 		poll->proxies = (zend_async_poll_proxy_t **) perealloc(
-			poll->proxies, poll->proxies_capacity * sizeof(zend_async_poll_proxy_t *), 0);
+				poll->proxies, poll->proxies_capacity * sizeof(zend_async_poll_proxy_t *), 0);
 	}
 
 	poll->proxies[poll->proxies_count++] = proxy;
 }
+
 /* }}} */
 
 /* {{{ async_poll_remove_proxy */
@@ -412,6 +416,7 @@ static zend_always_inline void async_poll_remove_proxy(async_poll_event_t *poll,
 		}
 	}
 }
+
 /* }}} */
 
 /* {{{ async_poll_aggregate_events */
@@ -430,6 +435,7 @@ static zend_always_inline async_poll_event async_poll_aggregate_events(async_pol
 
 	return aggregated;
 }
+
 /* }}} */
 
 /* {{{ libuv_poll_proxy_start */
@@ -438,7 +444,7 @@ static void libuv_poll_proxy_start(zend_async_event_t *event)
 	EVENT_START_PROLOGUE(event);
 
 	zend_async_poll_proxy_t *proxy = (zend_async_poll_proxy_t *) event;
-	async_poll_event_t *poll = (async_poll_event_t *)proxy->poll_event;
+	async_poll_event_t *poll = (async_poll_event_t *) proxy->poll_event;
 
 	/* Add proxy to the array */
 	async_poll_add_proxy(poll, proxy);
@@ -459,6 +465,7 @@ static void libuv_poll_proxy_start(zend_async_event_t *event)
 	ZEND_ASYNC_INCREASE_EVENT_COUNT;
 	event->loop_ref_count = 1;
 }
+
 /* }}} */
 
 /* {{{ libuv_poll_proxy_stop */
@@ -467,7 +474,7 @@ static void libuv_poll_proxy_stop(zend_async_event_t *event)
 	EVENT_STOP_PROLOGUE(event);
 
 	zend_async_poll_proxy_t *proxy = (zend_async_poll_proxy_t *) event;
-	async_poll_event_t *poll = (async_poll_event_t *)proxy->poll_event;
+	async_poll_event_t *poll = (async_poll_event_t *) proxy->poll_event;
 
 	/* Remove proxy from the array */
 	async_poll_remove_proxy(poll, proxy);
@@ -490,6 +497,7 @@ static void libuv_poll_proxy_stop(zend_async_event_t *event)
 	event->loop_ref_count = 0;
 	ZEND_ASYNC_DECREASE_EVENT_COUNT;
 }
+
 /* }}} */
 
 /* {{{ libuv_poll_proxy_dispose */
@@ -501,7 +509,7 @@ static void libuv_poll_proxy_dispose(zend_async_event_t *event)
 	}
 
 	zend_async_poll_proxy_t *proxy = (zend_async_poll_proxy_t *) event;
-	async_poll_event_t *poll = (async_poll_event_t *)proxy->poll_event;
+	async_poll_event_t *poll = (async_poll_event_t *) proxy->poll_event;
 
 	if (event->loop_ref_count > 0) {
 		event->loop_ref_count = 1;
@@ -515,6 +523,7 @@ static void libuv_poll_proxy_dispose(zend_async_event_t *event)
 
 	pefree(proxy, 0);
 }
+
 /* }}} */
 
 /* {{{ libuv_new_poll_event */
@@ -578,12 +587,13 @@ zend_async_poll_event_t *libuv_new_socket_event(zend_socket_t socket, async_poll
 /* }}} */
 
 /* {{{ libuv_new_poll_proxy_event */
-zend_async_poll_proxy_t *libuv_new_poll_proxy_event(zend_async_poll_event_t *poll_event, async_poll_event events, size_t extra_size)
+zend_async_poll_proxy_t *
+libuv_new_poll_proxy_event(zend_async_poll_event_t *poll_event, async_poll_event events, size_t extra_size)
 {
 	START_REACTOR_OR_RETURN_NULL;
 
-	zend_async_poll_proxy_t *proxy =
-		pecalloc(1, extra_size != 0 ? sizeof(zend_async_poll_proxy_t) + extra_size : sizeof(zend_async_poll_proxy_t), 0);
+	zend_async_poll_proxy_t *proxy = pecalloc(
+			1, extra_size != 0 ? sizeof(zend_async_poll_proxy_t) + extra_size : sizeof(zend_async_poll_proxy_t), 0);
 
 	/* Set up proxy */
 	proxy->poll_event = poll_event;

php_async_api.h

@@ -17,17 +17,17 @@
 #define PHP_ASYNC_API_H
 
 #ifdef PHP_WIN32
-# ifdef ASYNC_EXPORTS
-#  define PHP_ASYNC_API __declspec(dllexport)
-# else
-#  define PHP_ASYNC_API __declspec(dllimport)
-# endif
+#ifdef ASYNC_EXPORTS
+#define PHP_ASYNC_API __declspec(dllexport)
 #else
-# if defined(__GNUC__) && __GNUC__ >= 4
-#  define PHP_ASYNC_API __attribute__ ((visibility("default")))
-# else
-#  define PHP_ASYNC_API
-# endif
+#define PHP_ASYNC_API __declspec(dllimport)
+#endif
+#else
+#if defined(__GNUC__) && __GNUC__ >= 4
+#define PHP_ASYNC_API __attribute__((visibility("default")))
+#else
+#define PHP_ASYNC_API
+#endif
 #endif
 
 #endif // PHP_ASYNC_API_H