--- a/src/timer/unix/SDL_systimer.c	Mon May 29 03:53:21 2006 +0000
+++ b/src/timer/unix/SDL_systimer.c	Mon May 29 04:04:35 2006 +0000
@@ -59,23 +59,23 @@
 
 
 void
-SDL_StartTicks (void)
+SDL_StartTicks(void)
 {
     /* Set first ticks value */
 #if HAVE_CLOCK_GETTIME
-    clock_gettime (CLOCK_MONOTONIC, &start);
+    clock_gettime(CLOCK_MONOTONIC, &start);
 #else
-    gettimeofday (&start, NULL);
+    gettimeofday(&start, NULL);
 #endif
 }
 
 Uint32
-SDL_GetTicks (void)
+SDL_GetTicks(void)
 {
 #if HAVE_CLOCK_GETTIME
     Uint32 ticks;
     struct timespec now;
-    clock_gettime (CLOCK_MONOTONIC, &now);
+    clock_gettime(CLOCK_MONOTONIC, &now);
     ticks =
         (now.tv_sec - start.tv_sec) * 1000 + (now.tv_nsec -
                                               start.tv_nsec) / 1000000;
@@ -83,7 +83,7 @@
 #else
     Uint32 ticks;
     struct timeval now;
-    gettimeofday (&now, NULL);
+    gettimeofday(&now, NULL);
     ticks =
         (now.tv_sec - start.tv_sec) * 1000 + (now.tv_usec -
                                               start.tv_usec) / 1000;
@@ -92,13 +92,13 @@
 }
 
 void
-SDL_Delay (Uint32 ms)
+SDL_Delay(Uint32 ms)
 {
 #if SDL_THREAD_PTH
     pth_time_t tv;
     tv.tv_sec = ms / 1000;
     tv.tv_usec = (ms % 1000) * 1000;
-    pth_nap (tv);
+    pth_nap(tv);
 #else
     int was_error;
 
@@ -114,7 +114,7 @@
     elapsed.tv_sec = ms / 1000;
     elapsed.tv_nsec = (ms % 1000) * 1000000;
 #else
-    then = SDL_GetTicks ();
+    then = SDL_GetTicks();
 #endif
     do {
         errno = 0;
@@ -122,10 +122,10 @@
 #if HAVE_NANOSLEEP
         tv.tv_sec = elapsed.tv_sec;
         tv.tv_nsec = elapsed.tv_nsec;
-        was_error = nanosleep (&tv, &elapsed);
+        was_error = nanosleep(&tv, &elapsed);
 #else
         /* Calculate the time interval left (in case of interrupt) */
-        now = SDL_GetTicks ();
+        now = SDL_GetTicks();
         elapsed = (now - then);
         then = now;
         if (elapsed >= ms) {
@@ -135,7 +135,7 @@
         tv.tv_sec = ms / 1000;
         tv.tv_usec = (ms % 1000) * 1000;
 
-        was_error = select (0, NULL, NULL, NULL, &tv);
+        was_error = select(0, NULL, NULL, NULL, &tv);
 #endif /* HAVE_NANOSLEEP */
     }
     while (was_error && (errno == EINTR));
@@ -145,40 +145,40 @@
 #ifdef USE_ITIMER
 
 static void
-HandleAlarm (int sig)
+HandleAlarm(int sig)
 {
     Uint32 ms;
 
     if (SDL_alarm_callback) {
         ms = (*SDL_alarm_callback) (SDL_alarm_interval);
         if (ms != SDL_alarm_interval) {
-            SDL_SetTimer (ms, SDL_alarm_callback);
+            SDL_SetTimer(ms, SDL_alarm_callback);
         }
     }
 }
 
 int
-SDL_SYS_TimerInit (void)
+SDL_SYS_TimerInit(void)
 {
     struct sigaction action;
 
     /* Set the alarm handler (Linux specific) */
-    SDL_memset (&action, 0, sizeof (action));
+    SDL_memset(&action, 0, sizeof(action));
     action.sa_handler = HandleAlarm;
     action.sa_flags = SA_RESTART;
-    sigemptyset (&action.sa_mask);
-    sigaction (SIGALRM, &action, NULL);
+    sigemptyset(&action.sa_mask);
+    sigaction(SIGALRM, &action, NULL);
     return (0);
 }
 
 void
-SDL_SYS_TimerQuit (void)
+SDL_SYS_TimerQuit(void)
 {
-    SDL_SetTimer (0, NULL);
+    SDL_SetTimer(0, NULL);
 }
 
 int
-SDL_SYS_StartTimer (void)
+SDL_SYS_StartTimer(void)
 {
     struct itimerval timer;
 
@@ -186,17 +186,17 @@
     timer.it_value.tv_usec = (SDL_alarm_interval % 1000) * 1000;
     timer.it_interval.tv_sec = (SDL_alarm_interval / 1000);
     timer.it_interval.tv_usec = (SDL_alarm_interval % 1000) * 1000;
-    setitimer (ITIMER_REAL, &timer, NULL);
+    setitimer(ITIMER_REAL, &timer, NULL);
     return (0);
 }
 
 void
-SDL_SYS_StopTimer (void)
+SDL_SYS_StopTimer(void)
 {
     struct itimerval timer;
 
-    SDL_memset (&timer, 0, (sizeof timer));
-    setitimer (ITIMER_REAL, &timer, NULL);
+    SDL_memset(&timer, 0, (sizeof timer));
+    setitimer(ITIMER_REAL, &timer, NULL);
 }
 
 #else /* USE_ITIMER */
@@ -208,47 +208,47 @@
 static SDL_Thread *timer = NULL;
 
 static int
-RunTimer (void *unused)
+RunTimer(void *unused)
 {
     while (timer_alive) {
         if (SDL_timer_running) {
-            SDL_ThreadedTimerCheck ();
+            SDL_ThreadedTimerCheck();
         }
-        SDL_Delay (1);
+        SDL_Delay(1);
     }
     return (0);
 }
 
 /* This is only called if the event thread is not running */
 int
-SDL_SYS_TimerInit (void)
+SDL_SYS_TimerInit(void)
 {
     timer_alive = 1;
-    timer = SDL_CreateThread (RunTimer, NULL);
+    timer = SDL_CreateThread(RunTimer, NULL);
     if (timer == NULL)
         return (-1);
-    return (SDL_SetTimerThreaded (1));
+    return (SDL_SetTimerThreaded(1));
 }
 
 void
-SDL_SYS_TimerQuit (void)
+SDL_SYS_TimerQuit(void)
 {
     timer_alive = 0;
     if (timer) {
-        SDL_WaitThread (timer, NULL);
+        SDL_WaitThread(timer, NULL);
         timer = NULL;
     }
 }
 
 int
-SDL_SYS_StartTimer (void)
+SDL_SYS_StartTimer(void)
 {
-    SDL_SetError ("Internal logic error: Linux uses threaded timer");
+    SDL_SetError("Internal logic error: Linux uses threaded timer");
     return (-1);
 }
 
 void
-SDL_SYS_StopTimer (void)
+SDL_SYS_StopTimer(void)
 {
     return;
 }