Apply code style

Author: AJenbo

src/audio/dos/SDL_dosaudio_sb.c

@@ -23,8 +23,8 @@
 #ifndef SDL_dosaudio_sb_h_
 #define SDL_dosaudio_sb_h_
 
-#include "../SDL_sysaudio.h"
 #include "../../core/dos/SDL_dos.h"
+#include "../SDL_sysaudio.h"
 
 struct SDL_PrivateAudioData
 {

src/audio/dos/SDL_dosaudio_sb.h

@@ -26,7 +26,7 @@
 
 void *DOS_AllocateConventionalMemory(const int len, _go32_dpmi_seginfo *seginfo)
 {
-    seginfo->size = (len + 15) / 16;  // this is in "paragraphs"
+    seginfo->size = (len + 15) / 16; // this is in "paragraphs"
     if (_go32_dpmi_allocate_dos_memory(seginfo) != 0) {
         SDL_OutOfMemory();
         return NULL;
@@ -45,14 +45,14 @@ void *DOS_AllocateDMAMemory(const int len, _go32_dpmi_seginfo *seginfo)
     // a boundary. This is the standard technique used by Allegro, MIDAS, and
     // every other DOS audio library; allocate-check-retry would add complexity
     // for zero benefit.
-    uint8_t *ptr = (uint8_t *) DOS_AllocateConventionalMemory(len * 2, seginfo);
+    uint8_t *ptr = (uint8_t *)DOS_AllocateConventionalMemory(len * 2, seginfo);
     if (!ptr) {
         return NULL;
     }
 
     // if we're past the end of a page, use the second half of the block.
     const uint32_t physical = (seginfo->rm_segment * 16);
-    if ((physical >> 16) != ((physical+len) >> 16)) {
+    if ((physical >> 16) != ((physical + len) >> 16)) {
         ptr += len;
     }
     return ptr;
@@ -65,23 +65,24 @@ void DOS_FreeConventionalMemory(_go32_dpmi_seginfo *seginfo)
 
 char *DOS_GetFarPtrCString(const Uint32 segoffset)
 {
-    if (!segoffset) {  // let's just treat this as a NULL pointer.
+    if (!segoffset) { // let's just treat this as a NULL pointer.
         return NULL;
     }
 
-    const unsigned long ofs = (unsigned long) (((segoffset & 0xFFFF0000) >> 12) + (segoffset & 0xFFFF));
+    const unsigned long ofs = (unsigned long)(((segoffset & 0xFFFF0000) >> 12) + (segoffset & 0xFFFF));
     size_t len;
 
-    for (len = 0; _farpeekb(_dos_ds, ofs+len) != '\0'; len++) {}
+    for (len = 0; _farpeekb(_dos_ds, ofs + len) != '\0'; len++) {
+    }
 
-    len++;  // null terminator.
+    len++; // null terminator.
     char *retval = SDL_malloc(len);
     if (!retval) {
         return NULL;
     }
 
     for (size_t i = 0; i < len; i++) {
-        retval[i] = (char) _farpeekb(_dos_ds, ofs+i);
+        retval[i] = (char)_farpeekb(_dos_ds, ofs + i);
     }
     return retval;
 }
@@ -95,16 +96,16 @@ void DOS_HookInterrupt(int irq, DOS_InterruptHookFn fn, DOS_InterruptHook *hook)
     hook->irq = irq;
     hook->interrupt_vector = DOS_IRQToVector(irq);
     hook->irq_handler_seginfo.pm_selector = _go32_my_cs();
-    hook->irq_handler_seginfo.pm_offset = (uint32_t) fn;
+    hook->irq_handler_seginfo.pm_offset = (uint32_t)fn;
     _go32_dpmi_get_protected_mode_interrupt_vector(hook->interrupt_vector, &hook->original_irq_handler_seginfo);
     _go32_dpmi_chain_protected_mode_interrupt_vector(hook->interrupt_vector, &hook->irq_handler_seginfo);
 
     // enable interrupt on the correct PIC
     if (irq > 7) {
-        outportb(0xA1, inportb(0xA1) & ~(1 << (irq - 8)));  // unmask on slave PIC
-        outportb(0x21, inportb(0x21) & ~(1 << 2));           // ensure cascade (IRQ2) is unmasked
+        outportb(0xA1, inportb(0xA1) & ~(1 << (irq - 8))); // unmask on slave PIC
+        outportb(0x21, inportb(0x21) & ~(1 << 2));         // ensure cascade (IRQ2) is unmasked
     } else {
-        outportb(0x21, inportb(0x21) & ~(1 << irq));         // unmask on master PIC
+        outportb(0x21, inportb(0x21) & ~(1 << irq)); // unmask on master PIC
     }
 }
 
@@ -119,9 +120,9 @@ void DOS_UnhookInterrupt(DOS_InterruptHook *hook, bool disable_interrupt)
 
     if (disable_interrupt) {
         if (hook->irq > 7) {
-            outportb(0xA1, inportb(0xA1) | (1 << (hook->irq - 8)));  // mask on slave PIC
+            outportb(0xA1, inportb(0xA1) | (1 << (hook->irq - 8))); // mask on slave PIC
         } else {
-            outportb(0x21, inportb(0x21) | (1 << hook->irq));        // mask on master PIC
+            outportb(0x21, inportb(0x21) | (1 << hook->irq)); // mask on master PIC
         }
     }
 
@@ -138,6 +139,4 @@ void DOS_UnhookInterrupt(DOS_InterruptHook *hook, bool disable_interrupt)
     SDL_zerop(hook);
 }
 
-
 #endif // defined(SDL_PLATFORM_DOS)
-

src/core/dos/SDL_dos.c

@@ -63,12 +63,12 @@ extern "C" {
 //  C pointer usable from protected mode.
 SDL_FORCE_INLINE void *DOS_PhysicalToLinear(const Uint32 physical)
 {
-	return (void *) (physical + __djgpp_conventional_base);
+    return (void *)(physical + __djgpp_conventional_base);
 }
 
 SDL_FORCE_INLINE Uint32 DOS_LinearToPhysical(void *linear)
 {
-	return ((Uint32) linear) - __djgpp_conventional_base;
+    return ((Uint32)linear) - __djgpp_conventional_base;
 }
 
 SDL_FORCE_INLINE int DOS_IRQToVector(int irq)
@@ -89,27 +89,27 @@ SDL_FORCE_INLINE void DOS_EnableInterrupts(void)
 // Grab a single byte from a segment:offset.
 SDL_FORCE_INLINE Uint8 DOS_PeekUint8(const Uint32 segoffset)
 {
-    return (Uint8) _farpeekb(_dos_ds, ((segoffset & 0xFFFF0000) >> 12) + (segoffset & 0xFFFF));
+    return (Uint8)_farpeekb(_dos_ds, ((segoffset & 0xFFFF0000) >> 12) + (segoffset & 0xFFFF));
 }
 
 // Grab a single 16-bit word from a segment:offset.
 SDL_FORCE_INLINE Uint16 DOS_PeekUint16(const Uint32 segoffset)
 {
-    return (Uint16) _farpeekw(_dos_ds, ((segoffset & 0xFFFF0000) >> 12) + (segoffset & 0xFFFF));
+    return (Uint16)_farpeekw(_dos_ds, ((segoffset & 0xFFFF0000) >> 12) + (segoffset & 0xFFFF));
 }
 
 // Grab a single 32-bit dword from a segment:offset.
 SDL_FORCE_INLINE Uint32 DOS_PeekUint32(const Uint32 segoffset)
 {
-    return (Uint32) _farpeekl(_dos_ds, ((segoffset & 0xFFFF0000) >> 12) + (segoffset & 0xFFFF));
+    return (Uint32)_farpeekl(_dos_ds, ((segoffset & 0xFFFF0000) >> 12) + (segoffset & 0xFFFF));
 }
 
 SDL_FORCE_INLINE void DOS_EndOfInterrupt(int irq)
 {
     if (irq > 7) {
-        outportb(0xA0, 0x20);  // Send EOI to slave PIC (PIC2) for IRQs 8-15
+        outportb(0xA0, 0x20); // Send EOI to slave PIC (PIC2) for IRQs 8-15
     }
-    outportb(0x20, 0x20);  // Send EOI to master PIC (PIC1) — always needed (cascade)
+    outportb(0x20, 0x20); // Send EOI to master PIC (PIC1) — always needed (cascade)
 }
 
 // Allocate memory under the 640k line; various real mode services and DMA transfers need this.
@@ -131,13 +131,13 @@ typedef struct DOS_InterruptHook
 {
     DOS_InterruptHookFn fn;
     int irq;
-    int interrupt_vector;  // this is the _vector_ number, not the IRQ number!
+    int interrupt_vector; // this is the _vector_ number, not the IRQ number!
     _go32_dpmi_seginfo irq_handler_seginfo;
     _go32_dpmi_seginfo original_irq_handler_seginfo;
 
 } DOS_InterruptHook;
 
-void DOS_HookInterrupt(int irq, DOS_InterruptHookFn fn, DOS_InterruptHook *hook);  // `irq` is the IRQ number, not the interrupt vector number!
+void DOS_HookInterrupt(int irq, DOS_InterruptHookFn fn, DOS_InterruptHook *hook); // `irq` is the IRQ number, not the interrupt vector number!
 void DOS_UnhookInterrupt(DOS_InterruptHook *hook, bool disable_interrupt);
 
 // Ends C function definitions when using C++

src/core/dos/SDL_dos.h

@@ -39,7 +39,7 @@
 
 // Thread table — static array, no dynamic allocation needed
 static DOS_ThreadContext threads[DOS_MAX_THREADS];
-static int current_thread = 0;  // Index of currently running thread
+static int current_thread = 0; // Index of currently running thread
 static bool scheduler_initialized = false;
 
 // Find the next runnable thread using round-robin scheduling.
@@ -52,7 +52,7 @@ static int FindNextRunnable(int start)
             return idx;
         }
     }
-    return -1;  // No other thread is runnable
+    return -1; // No other thread is runnable
 }
 
 // Trampoline function that runs on a new thread's stack.
@@ -72,7 +72,8 @@ static void ThreadTrampoline(void)
     DOS_ExitThread(result);
 
     // Should never reach here
-    for (;;) {}
+    for (;;) {
+    }
 }
 
 void DOS_SchedulerInit(void)
@@ -121,7 +122,7 @@ int DOS_CreateThread(int (*fn)(void *), void *arg, size_t stack_size)
     }
 
     if (tid < 0) {
-        return -1;  // No free slots
+        return -1; // No free slots
     }
 
     if (stack_size == 0) {
@@ -161,12 +162,12 @@ int DOS_CreateThread(int (*fn)(void *), void *arg, size_t stack_size)
         // Stack grows downward, so SP starts at the top.
         // Align to 16 bytes for ABI compliance.
         Uint8 *stack_top = (Uint8 *)stack + stack_size;
-        stack_top = (Uint8 *)((uintptr_t)stack_top & ~0xFUL);  // 16-byte align
+        stack_top = (Uint8 *)((uintptr_t)stack_top & ~0xFUL); // 16-byte align
 
         // Leave room for a fake return address (the trampoline never returns,
         // but the ABI expects one on the stack at function entry)
         stack_top -= sizeof(void *);
-        *(void **)stack_top = NULL;  // Fake return address
+        *(void **)stack_top = NULL; // Fake return address
 
         ctx->env[0].__esp = (unsigned long)(uintptr_t)stack_top;
         ctx->env[0].__ebp = (unsigned long)(uintptr_t)stack_top;
@@ -186,7 +187,7 @@ void DOS_Yield(void)
 
     int next = FindNextRunnable(current_thread);
     if (next < 0) {
-        return;  // No other runnable thread, continue current
+        return; // No other runnable thread, continue current
     }
 
     int prev = current_thread;
@@ -237,7 +238,7 @@ void DOS_ExitThread(int status)
     // (This shouldn't happen in practice — the main thread should
     // always be runnable or waiting.)
     for (;;) {
-        __asm__ __volatile__("hlt");  // Wait for interrupt before retrying
+        __asm__ __volatile__("hlt"); // Wait for interrupt before retrying
         next = FindNextRunnable(current_thread);
         if (next >= 0) {
             current_thread = next;
@@ -298,7 +299,7 @@ void DOS_BlockCurrentThread(void)
 void DOS_DestroyThread(int thread_id)
 {
     if (thread_id <= 0 || thread_id >= DOS_MAX_THREADS) {
-        return;  // Can't destroy main thread (0) or invalid IDs
+        return; // Can't destroy main thread (0) or invalid IDs
     }
 
     DOS_ThreadContext *ctx = &threads[thread_id];

src/core/dos/SDL_dos_scheduler.c

@@ -37,30 +37,32 @@ extern "C" {
 #define DOS_DEFAULT_STACK_SIZE (64 * 1024)
 
 // Thread states
-typedef enum {
-    DOS_THREAD_FREE = 0,   // Slot is available
-    DOS_THREAD_READY,      // Runnable
-    DOS_THREAD_RUNNING,    // Currently executing
-    DOS_THREAD_BLOCKED,    // Waiting on a semaphore/mutex
-    DOS_THREAD_FINISHED    // Thread function returned
+typedef enum
+{
+    DOS_THREAD_FREE = 0, // Slot is available
+    DOS_THREAD_READY,    // Runnable
+    DOS_THREAD_RUNNING,  // Currently executing
+    DOS_THREAD_BLOCKED,  // Waiting on a semaphore/mutex
+    DOS_THREAD_FINISHED  // Thread function returned
 } DOS_ThreadState;
 
 // Per-thread context
-typedef struct DOS_ThreadContext {
-    jmp_buf         env;            // Saved CPU state for context switch
+typedef struct DOS_ThreadContext
+{
+    jmp_buf env; // Saved CPU state for context switch
     DOS_ThreadState state;
-    int             id;             // Thread ID (index into thread table)
-    void           *stack_base;     // malloc'd stack memory
-    size_t          stack_size;
-    int             exit_status;    // Return value from thread function
+    int id;           // Thread ID (index into thread table)
+    void *stack_base; // malloc'd stack memory
+    size_t stack_size;
+    int exit_status; // Return value from thread function
 
     // Entry point
-    int           (*entry_fn)(void *);
-    void           *entry_arg;
+    int (*entry_fn)(void *);
+    void *entry_arg;
 
     // Join support
-    volatile bool   finished;       // Set when thread function returns
-    int             join_waiter;    // ID of thread waiting in WaitThread, or -1
+    volatile bool finished; // Set when thread function returns
+    int join_waiter;        // ID of thread waiting in WaitThread, or -1
 } DOS_ThreadContext;
 
 // Initialize the scheduler. Must be called before any thread operations.

src/core/dos/SDL_dos_scheduler.h

@@ -22,8 +22,8 @@
 
 #ifdef SDL_FILESYSTEM_DOS
 
-#include <sys/stat.h>
 #include <dir.h>
+#include <sys/stat.h>
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 // System dependent filesystem routines
@@ -32,7 +32,7 @@
 
 char *SDL_SYS_GetBasePath(void)
 {
-    extern const char *SDL_argv0;  // from src/main/dos/SDL_sysmain_runapp.c
+    extern const char *SDL_argv0; // from src/main/dos/SDL_sysmain_runapp.c
     char *searched = searchpath(SDL_argv0);
     if (!searched) {
         SDL_SetError("argv[0] not found by searchpath");