--- a/src/cdrom/osf/SDL_syscdrom.c	Mon May 29 03:53:21 2006 +0000
+++ b/src/cdrom/osf/SDL_syscdrom.c	Mon May 29 04:04:35 2006 +0000
@@ -45,21 +45,21 @@
 static dev_t SDL_cdmode[MAX_DRIVES];
 
 /* The system-dependent CD control functions */
-static const char *SDL_SYS_CDName (int drive);
-static int SDL_SYS_CDOpen (int drive);
-static int SDL_SYS_CDGetTOC (SDL_CD * cdrom);
-static CDstatus SDL_SYS_CDStatus (SDL_CD * cdrom, int *position);
-static int SDL_SYS_CDPlay (SDL_CD * cdrom, int start, int length);
-static int SDL_SYS_CDPause (SDL_CD * cdrom);
-static int SDL_SYS_CDResume (SDL_CD * cdrom);
-static int SDL_SYS_CDStop (SDL_CD * cdrom);
-static int SDL_SYS_CDEject (SDL_CD * cdrom);
-static void SDL_SYS_CDClose (SDL_CD * cdrom);
+static const char *SDL_SYS_CDName(int drive);
+static int SDL_SYS_CDOpen(int drive);
+static int SDL_SYS_CDGetTOC(SDL_CD * cdrom);
+static CDstatus SDL_SYS_CDStatus(SDL_CD * cdrom, int *position);
+static int SDL_SYS_CDPlay(SDL_CD * cdrom, int start, int length);
+static int SDL_SYS_CDPause(SDL_CD * cdrom);
+static int SDL_SYS_CDResume(SDL_CD * cdrom);
+static int SDL_SYS_CDStop(SDL_CD * cdrom);
+static int SDL_SYS_CDEject(SDL_CD * cdrom);
+static void SDL_SYS_CDClose(SDL_CD * cdrom);
 
 /* Check a drive to see if it is a CD-ROM */
 /* Caution!! Not tested. */
 static int
-CheckDrive (char *drive, struct stat *stbuf)
+CheckDrive(char *drive, struct stat *stbuf)
 {
     int cdfd, is_cd = 0;
     struct mode_sel_sns_params msp;
@@ -71,29 +71,29 @@
     };
 #endif
 
-    bzero (&msp, sizeof (msp));
-    bzero (&inq, sizeof (inq));
+    bzero(&msp, sizeof(msp));
+    bzero(&inq, sizeof(inq));
 
     /* If it doesn't exist, return -1 */
-    if (stat (drive, stbuf) < 0) {
+    if (stat(drive, stbuf) < 0) {
         return (-1);
     }
 
-    if ((cdfd = open (drive, (O_RDWR | O_NDELAY), 0)) >= 0) {
+    if ((cdfd = open(drive, (O_RDWR | O_NDELAY), 0)) >= 0) {
         msp.msp_addr = (caddr_t) & inq;
         msp.msp_pgcode = 0;
         msp.msp_pgctrl = 0;
-        msp.msp_length = sizeof (inq);
+        msp.msp_length = sizeof(inq);
         msp.msp_setps = 0;
 
-        if (ioctl (cdfd, SCSI_GET_INQUIRY_DATA, &msp))
+        if (ioctl(cdfd, SCSI_GET_INQUIRY_DATA, &msp))
             return (0);
 
 #ifdef DEBUG_CDROM
-        fprintf (stderr, "Device Type: %s\n", devtype[inq.perfdt]);
-        fprintf (stderr, "Vendor: %.8s\n", inq.vndrid);
-        fprintf (stderr, "Product: %.8s\n", inq.prodid);
-        fprintf (stderr, "Revision: %.8s\n", inq.revlvl);
+        fprintf(stderr, "Device Type: %s\n", devtype[inq.perfdt]);
+        fprintf(stderr, "Vendor: %.8s\n", inq.vndrid);
+        fprintf(stderr, "Product: %.8s\n", inq.prodid);
+        fprintf(stderr, "Revision: %.8s\n", inq.revlvl);
 #endif
         if (inq.perfdt == DTYPE_RODIRECT)
             is_cd = 1;
@@ -104,7 +104,7 @@
 
 /* Add a CD-ROM drive to our list of valid drives */
 static void
-AddDrive (char *drive, struct stat *stbuf)
+AddDrive(char *drive, struct stat *stbuf)
 {
     int i;
 
@@ -116,8 +116,8 @@
         for (i = 0; i < SDL_numcds; ++i) {
             if (stbuf->st_rdev == SDL_cdmode[i]) {
 #ifdef DEBUG_CDROM
-                fprintf (stderr, "Duplicate drive detected: %s == %s\n",
-                         drive, SDL_cdlist[i]);
+                fprintf(stderr, "Duplicate drive detected: %s == %s\n",
+                        drive, SDL_cdlist[i]);
 #endif
                 return;
             }
@@ -125,21 +125,21 @@
 
         /* Add this drive to our list */
         i = SDL_numcds;
-        SDL_cdlist[i] = SDL_strdup (drive);
+        SDL_cdlist[i] = SDL_strdup(drive);
         if (SDL_cdlist[i] == NULL) {
-            SDL_OutOfMemory ();
+            SDL_OutOfMemory();
             return;
         }
         SDL_cdmode[i] = stbuf->st_rdev;
         ++SDL_numcds;
 #ifdef DEBUG_CDROM
-        fprintf (stderr, "Added CD-ROM drive: %s\n", drive);
+        fprintf(stderr, "Added CD-ROM drive: %s\n", drive);
 #endif
     }
 }
 
 int
-SDL_SYS_CDInit (void)
+SDL_SYS_CDInit(void)
 {
     /* checklist:
      *
@@ -178,21 +178,21 @@
 
 
     /* Look in the environment for our CD-ROM drive list */
-    SDLcdrom = SDL_getenv ("SDL_CDROM");        /* ':' separated list of devices */
+    SDLcdrom = SDL_getenv("SDL_CDROM"); /* ':' separated list of devices */
     if (SDLcdrom != NULL) {
         char *cdpath, *delim;
-        size_t len = SDL_strlen (SDLcdrom) + 1;
-        cdpath = SDL_stack_alloc (char, len);
+        size_t len = SDL_strlen(SDLcdrom) + 1;
+        cdpath = SDL_stack_alloc(char, len);
         if (cdpath != NULL) {
-            SDL_strlcpy (cdpath, SDLcdrom, len);
+            SDL_strlcpy(cdpath, SDLcdrom, len);
             SDLcdrom = cdpath;
             do {
-                delim = SDL_strchr (SDLcdrom, ':');
+                delim = SDL_strchr(SDLcdrom, ':');
                 if (delim) {
                     *delim++ = '\0';
                 }
-                if (CheckDrive (SDLcdrom, &stbuf) > 0) {
-                    AddDrive (SDLcdrom, &stbuf);
+                if (CheckDrive(SDLcdrom, &stbuf) > 0) {
+                    AddDrive(SDLcdrom, &stbuf);
                 }
                 if (delim) {
                     SDLcdrom = delim;
@@ -201,7 +201,7 @@
                 }
             }
             while (SDLcdrom);
-            SDL_stack_free (cdpath);
+            SDL_stack_free(cdpath);
         }
 
         /* If we found our drives, there's nothing left to do */
@@ -215,26 +215,26 @@
         struct dirent *devent;
         int name_len;
 
-        devdir = opendir (checklist[i].dir);
+        devdir = opendir(checklist[i].dir);
         if (devdir) {
-            name_len = SDL_strlen (checklist[i].name);
-            while (devent = readdir (devdir))
+            name_len = SDL_strlen(checklist[i].name);
+            while (devent = readdir(devdir))
                 if (SDL_memcmp
                     (checklist[i].name, devent->d_name, name_len) == 0)
                     if (devent->d_name[devent->d_namlen - 1] == 'c') {
-                        SDL_snprintf (drive, SDL_arraysize (drive),
-                                      "%s/%s", checklist[i].dir,
-                                      devent->d_name);
+                        SDL_snprintf(drive, SDL_arraysize(drive),
+                                     "%s/%s", checklist[i].dir,
+                                     devent->d_name);
 #ifdef DEBUG_CDROM
-                        fprintf (stderr, "Try to add drive: %s\n", drive);
+                        fprintf(stderr, "Try to add drive: %s\n", drive);
 #endif
-                        if (CheckDrive (drive, &stbuf) > 0)
-                            AddDrive (drive, &stbuf);
+                        if (CheckDrive(drive, &stbuf) > 0)
+                            AddDrive(drive, &stbuf);
                     }
-            closedir (devdir);
+            closedir(devdir);
         } else {
 #ifdef DEBUG_CDROM
-            fprintf (stderr, "cannot open dir: %s\n", checklist[i].dir);
+            fprintf(stderr, "cannot open dir: %s\n", checklist[i].dir);
 #endif
         }
     }
@@ -242,28 +242,28 @@
 }
 
 static const char *
-SDL_SYS_CDName (int drive)
+SDL_SYS_CDName(int drive)
 {
     return (SDL_cdlist[drive]);
 }
 
 static int
-SDL_SYS_CDOpen (int drive)
+SDL_SYS_CDOpen(int drive)
 {
     /* O_RDWR: To use ioctl(fd, SCSI_STOP_UNIT) */
-    return (open (SDL_cdlist[drive], (O_RDWR | O_NDELAY), 0));
+    return (open(SDL_cdlist[drive], (O_RDWR | O_NDELAY), 0));
 }
 
 static int
-SDL_SYS_CDGetTOC (SDL_CD * cdrom)
+SDL_SYS_CDGetTOC(SDL_CD * cdrom)
 {
     struct cd_toc toc;
     struct cd_toc_header hdr;
     struct cd_toc_entry *cdte;
     int i;
     int okay = 0;
-    if (ioctl (cdrom->id, CDROM_TOC_HEADER, &hdr)) {
-        fprintf (stderr, "ioctl error CDROM_TOC_HEADER\n");
+    if (ioctl(cdrom->id, CDROM_TOC_HEADER, &hdr)) {
+        fprintf(stderr, "ioctl error CDROM_TOC_HEADER\n");
         return -1;
     }
     cdrom->numtracks = hdr.th_ending_track - hdr.th_starting_track + 1;
@@ -271,28 +271,28 @@
         cdrom->numtracks = SDL_MAX_TRACKS;
     }
 #ifdef DEBUG_CDROM
-    fprintf (stderr, "hdr.th_data_len1 = %d\n", hdr.th_data_len1);
-    fprintf (stderr, "hdr.th_data_len0 = %d\n", hdr.th_data_len0);
-    fprintf (stderr, "hdr.th_starting_track = %d\n", hdr.th_starting_track);
-    fprintf (stderr, "hdr.th_ending_track = %d\n", hdr.th_ending_track);
-    fprintf (stderr, "cdrom->numtracks = %d\n", cdrom->numtracks);
+    fprintf(stderr, "hdr.th_data_len1 = %d\n", hdr.th_data_len1);
+    fprintf(stderr, "hdr.th_data_len0 = %d\n", hdr.th_data_len0);
+    fprintf(stderr, "hdr.th_starting_track = %d\n", hdr.th_starting_track);
+    fprintf(stderr, "hdr.th_ending_track = %d\n", hdr.th_ending_track);
+    fprintf(stderr, "cdrom->numtracks = %d\n", cdrom->numtracks);
 #endif
     toc.toc_address_format = CDROM_LBA_FORMAT;
     toc.toc_starting_track = 0;
     toc.toc_alloc_length = (hdr.th_data_len1 << 8) +
-        hdr.th_data_len0 + sizeof (hdr);
-    if ((toc.toc_buffer = alloca (toc.toc_alloc_length)) == NULL) {
-        fprintf (stderr, "cannot allocate toc.toc_buffer\n");
+        hdr.th_data_len0 + sizeof(hdr);
+    if ((toc.toc_buffer = alloca(toc.toc_alloc_length)) == NULL) {
+        fprintf(stderr, "cannot allocate toc.toc_buffer\n");
         return -1;
     }
 
-    bzero (toc.toc_buffer, toc.toc_alloc_length);
-    if (ioctl (cdrom->id, CDROM_TOC_ENTRYS, &toc)) {
-        fprintf (stderr, "ioctl error CDROM_TOC_ENTRYS\n");
+    bzero(toc.toc_buffer, toc.toc_alloc_length);
+    if (ioctl(cdrom->id, CDROM_TOC_ENTRYS, &toc)) {
+        fprintf(stderr, "ioctl error CDROM_TOC_ENTRYS\n");
         return -1;
     }
 
-    cdte = (struct cd_toc_entry *) ((char *) toc.toc_buffer + sizeof (hdr));
+    cdte = (struct cd_toc_entry *) ((char *) toc.toc_buffer + sizeof(hdr));
     for (i = 0; i <= cdrom->numtracks; ++i) {
         if (i == cdrom->numtracks) {
             cdrom->track[i].id = 0xAA;;
@@ -313,15 +313,15 @@
     }
 #ifdef DEBUG_CDROM
     for (i = 0; i <= cdrom->numtracks; i++) {
-        fprintf (stderr, "toc_entry[%d].te_track_number = %d\n",
-                 i, cdte[i].te_track_number);
-        fprintf (stderr, "cdrom->track[%d].id = %d\n", i, cdrom->track[i].id);
-        fprintf (stderr, "cdrom->track[%d].type = %x\n", i,
-                 cdrom->track[i].type);
-        fprintf (stderr, "cdrom->track[%d].offset = %d\n", i,
-                 cdrom->track[i].offset);
-        fprintf (stderr, "cdrom->track[%d].length = %d\n", i,
-                 cdrom->track[i].length);
+        fprintf(stderr, "toc_entry[%d].te_track_number = %d\n",
+                i, cdte[i].te_track_number);
+        fprintf(stderr, "cdrom->track[%d].id = %d\n", i, cdrom->track[i].id);
+        fprintf(stderr, "cdrom->track[%d].type = %x\n", i,
+                cdrom->track[i].type);
+        fprintf(stderr, "cdrom->track[%d].offset = %d\n", i,
+                cdrom->track[i].offset);
+        fprintf(stderr, "cdrom->track[%d].length = %d\n", i,
+                cdrom->track[i].length);
     }
 #endif
     if (i == (cdrom->numtracks + 1)) {
@@ -333,7 +333,7 @@
 
 /* Get CD-ROM status */
 static CDstatus
-SDL_SYS_CDStatus (SDL_CD * cdrom, int *position)
+SDL_SYS_CDStatus(SDL_CD * cdrom, int *position)
 {
     CDstatus status;
     struct cd_sub_channel sc;
@@ -342,11 +342,11 @@
     sc.sch_address_format = CDROM_LBA_FORMAT;
     sc.sch_data_format = CDROM_CURRENT_POSITION;
     sc.sch_track_number = 0;
-    sc.sch_alloc_length = sizeof (scd);
+    sc.sch_alloc_length = sizeof(scd);
     sc.sch_buffer = (caddr_t) & scd;
-    if (ioctl (cdrom->id, CDROM_READ_SUBCHANNEL, &sc)) {
+    if (ioctl(cdrom->id, CDROM_READ_SUBCHANNEL, &sc)) {
         status = CD_ERROR;
-        fprintf (stderr, "ioctl error CDROM_READ_SUBCHANNEL \n");
+        fprintf(stderr, "ioctl error CDROM_READ_SUBCHANNEL \n");
     } else {
         switch (scd.scd_header.sh_audio_status) {
         case AS_AUDIO_INVALID:
@@ -372,8 +372,8 @@
             break;
         }
 #ifdef DEBUG_CDROM
-        fprintf (stderr, "scd.scd_header.sh_audio_status = %x\n",
-                 scd.scd_header.sh_audio_status);
+        fprintf(stderr, "scd.scd_header.sh_audio_status = %x\n",
+                scd.scd_header.sh_audio_status);
 #endif
     }
     if (position) {
@@ -393,7 +393,7 @@
 
 /* Start play */
 static int
-SDL_SYS_CDPlay (SDL_CD * cdrom, int start, int length)
+SDL_SYS_CDPlay(SDL_CD * cdrom, int start, int length)
 {
 /*
  * Play MSF
@@ -401,61 +401,61 @@
     struct cd_play_audio_msf msf;
     int end;
 
-    bzero (&msf, sizeof (msf));
+    bzero(&msf, sizeof(msf));
     end = start + length;
-    FRAMES_TO_MSF (start + 150, /* LBA = 4500*M + 75*S + F - 150 */
-                   &msf.msf_starting_M_unit,
-                   &msf.msf_starting_S_unit, &msf.msf_starting_F_unit);
-    FRAMES_TO_MSF (end + 150,   /* LBA = 4500*M + 75*S + F - 150 */
-                   &msf.msf_ending_M_unit,
-                   &msf.msf_ending_S_unit, &msf.msf_ending_F_unit);
+    FRAMES_TO_MSF(start + 150,  /* LBA = 4500*M + 75*S + F - 150 */
+                  &msf.msf_starting_M_unit,
+                  &msf.msf_starting_S_unit, &msf.msf_starting_F_unit);
+    FRAMES_TO_MSF(end + 150,    /* LBA = 4500*M + 75*S + F - 150 */
+                  &msf.msf_ending_M_unit,
+                  &msf.msf_ending_S_unit, &msf.msf_ending_F_unit);
 
-    return (ioctl (cdrom->id, CDROM_PLAY_AUDIO_MSF, &msf));
+    return (ioctl(cdrom->id, CDROM_PLAY_AUDIO_MSF, &msf));
 }
 
 /* Pause play */
 static int
-SDL_SYS_CDPause (SDL_CD * cdrom)
+SDL_SYS_CDPause(SDL_CD * cdrom)
 {
-    return (ioctl (cdrom->id, CDROM_PAUSE_PLAY));
+    return (ioctl(cdrom->id, CDROM_PAUSE_PLAY));
 }
 
 /* Resume play */
 static int
-SDL_SYS_CDResume (SDL_CD * cdrom)
+SDL_SYS_CDResume(SDL_CD * cdrom)
 {
-    return (ioctl (cdrom->id, CDROM_RESUME_PLAY));
+    return (ioctl(cdrom->id, CDROM_RESUME_PLAY));
 }
 
 /* Stop play */
 static int
-SDL_SYS_CDStop (SDL_CD * cdrom)
+SDL_SYS_CDStop(SDL_CD * cdrom)
 {
-    return (ioctl (cdrom->id, SCSI_STOP_UNIT));
+    return (ioctl(cdrom->id, SCSI_STOP_UNIT));
 }
 
 /* Eject the CD-ROM */
 static int
-SDL_SYS_CDEject (SDL_CD * cdrom)
+SDL_SYS_CDEject(SDL_CD * cdrom)
 {
-    return (ioctl (cdrom->id, CDROM_EJECT_CADDY));
+    return (ioctl(cdrom->id, CDROM_EJECT_CADDY));
 }
 
 /* Close the CD-ROM handle */
 static void
-SDL_SYS_CDClose (SDL_CD * cdrom)
+SDL_SYS_CDClose(SDL_CD * cdrom)
 {
-    close (cdrom->id);
+    close(cdrom->id);
 }
 
 void
-SDL_SYS_CDQuit (void)
+SDL_SYS_CDQuit(void)
 {
     int i;
 
     if (SDL_numcds > 0) {
         for (i = 0; i < SDL_numcds; ++i) {
-            SDL_free (SDL_cdlist[i]);
+            SDL_free(SDL_cdlist[i]);
         }
         SDL_numcds = 0;
     }