Changeset 508

Timestamp:

04/15/07 19:07:43 (3 years ago)

Author:

goodea

Message:

reformat

Location:

trunk/hal/lpc2106-cmucam3

Files:

• rdcf2.c (modified) (30 diffs)
• rdcf2.h (modified) (7 diffs)

trunk/hal/lpc2106-cmucam3/rdcf2.c

@@ -57 +57 @@
 /* buffer status */
 
-enum buffer_status {EMPTY, CLEAN, DIRTY};
+enum buffer_status { EMPTY, CLEAN, DIRTY };
 
 /* additional mode bit */
@@ -87 +87 @@
 #ifdef _BIG_ENDIAN
 
-static void swap_two(uint8_t *p)
-{
-        uint8_t x = p[0];
-        p[0] = p[1];
-        p[1] = x;
-}
-
-static void swap_four(uint8_t *p)
-{
-        uint8_t x = p[0];
-        p[0] = p[3];
-        p[3] = x;
-        swap_two(p+1);
-}
-
-  #define convert_short(x) swap_two((uint8_t *)(&(x)))
-  #define convert_long(x)  swap_four((uint8_t *)(&(x)))
+static void swap_two (uint8_t * p)
+{
+  uint8_t x = p[0];
+  p[0] = p[1];
+  p[1] = x;
+}
+
+static void swap_four (uint8_t * p)
+{
+  uint8_t x = p[0];
+  p[0] = p[3];
+  p[3] = x;
+  swap_two (p + 1);
+}
+
+#define convert_short(x) swap_two((uint8_t *)(&(x)))
+#define convert_long(x)  swap_four((uint8_t *)(&(x)))
 
 #endif
 
-static void rdcf_get_date_and_time(struct rdcf_date_and_time *p)
-{
-        struct tm dateTime;
-        struct timeval  temp;
-        time_t now;
-
-        gettimeofday(&temp, 0);
-        now = temp.tv_sec;
-        localtime_r(&now, &dateTime);
-                // time is correct.
-        p->hour = dateTime.tm_hour;
-        p->minute = dateTime.tm_min;
-        p->second = dateTime.tm_sec;
-        p->month = dateTime.tm_mon+1;
-        p->day = dateTime.tm_mday;
-        p->year = dateTime.tm_year+1900;
+static void rdcf_get_date_and_time (struct rdcf_date_and_time *p)
+{
+  struct tm dateTime;
+  struct timeval temp;
+  time_t now;
+
+  gettimeofday (&temp, 0);
+  now = temp.tv_sec;
+  localtime_r (&now, &dateTime);
+  // time is correct.
+  p->hour = dateTime.tm_hour;
+  p->minute = dateTime.tm_min;
+  p->second = dateTime.tm_sec;
+  p->month = dateTime.tm_mon + 1;
+  p->day = dateTime.tm_mday;
+  p->year = dateTime.tm_year + 1900;
 }
 
@@ -130 +130 @@
 -----------------------------------------------------------------------------*/
 
-static void error_exit(struct rdcf *f, int error)
-{
-  longjmp(f->error, error);
+static void error_exit (struct rdcf *f, int error)
+{
+  longjmp (f->error, error);
 }
 
@@ -141 +141 @@
 static void read_sector (struct rdcf *f, unsigned sector, void *buffer)
 {
-        f->drive_error = f->ReadSector(sector, buffer);
-        if (f->drive_error != 0) error_exit(f, ~EIO);
-}
-
-static void write_sector (struct rdcf *f, unsigned sector, const uint8_t *buffer)
-{
-        f->drive_error = f->WriteSector(sector, buffer);
-        if (f->drive_error != 0) error_exit(f, ~EIO);
-}
-        
+  f->drive_error = f->ReadSector (sector, buffer);
+  if (f->drive_error != 0)
+    error_exit (f, ~EIO);
+}
+
+static void write_sector (struct rdcf *f, unsigned sector,
+                          const uint8_t * buffer)
+{
+  f->drive_error = f->WriteSector (sector, buffer);
+  if (f->drive_error != 0)
+    error_exit (f, ~EIO);
+}
+
 /*-----------------------------------------------------------------------------
 This function writes the buffer in the FCB if it is marked as "dirty".
 -----------------------------------------------------------------------------*/
 
-static void flush_buffer(struct rdcf *f)
-{
-        if (f->buffer_status == DIRTY) {
-                        // here is where we keep from thrashing while doing FAT operations.
-                        // if the sector to be written is in the first FAT table, then
-                        // mirror the write to corresponding sector in second FAT.
-                write_sector(f, f->sector_in_buffer, f->buffer.buf);
-                if ((f->sector_in_buffer >= f->first_FAT_sector) &&
-                                (f->sector_in_buffer <= f->first_FAT_sector+f->sectors_per_FAT)) {
-                                // mirror.
-                        write_sector(f, f->sector_in_buffer+f->sectors_per_FAT, f->buffer.buf);
-                }
-                f->buffer_status = CLEAN;
-        }
+static void flush_buffer (struct rdcf *f)
+{
+  if (f->buffer_status == DIRTY) {
+    // here is where we keep from thrashing while doing FAT operations.
+    // if the sector to be written is in the first FAT table, then
+    // mirror the write to corresponding sector in second FAT.
+    write_sector (f, f->sector_in_buffer, f->buffer.buf);
+    if ((f->sector_in_buffer >= f->first_FAT_sector) &&
+        (f->sector_in_buffer <= f->first_FAT_sector + f->sectors_per_FAT)) {
+      // mirror.
+      write_sector (f, f->sector_in_buffer + f->sectors_per_FAT,
+                    f->buffer.buf);
+    }
+    f->buffer_status = CLEAN;
+  }
 }
 
@@ -176 +180 @@
 -----------------------------------------------------------------------------*/
 
-static void read_buffer(struct rdcf *f, unsigned sector)
-{
-        if (f->buffer_status == EMPTY || sector != f->sector_in_buffer) {
-                flush_buffer(f);
-                read_sector(f, sector, f->buffer.buf);
-                f->sector_in_buffer = sector;
-                f->buffer_status = CLEAN;
-        }
+static void read_buffer (struct rdcf *f, unsigned sector)
+{
+  if (f->buffer_status == EMPTY || sector != f->sector_in_buffer) {
+    flush_buffer (f);
+    read_sector (f, sector, f->buffer.buf);
+    f->sector_in_buffer = sector;
+    f->buffer_status = CLEAN;
+  }
 }
 
@@ -191 +195 @@
 -----------------------------------------------------------------------------*/
 
-static void check_cluster(struct rdcf *f, unsigned cluster)
-{
-        if (cluster < 2 || cluster > f->maximum_cluster_number)
-                error_exit(f, ~ESPIPE);
+static void check_cluster (struct rdcf *f, unsigned cluster)
+{
+  if (cluster < 2 || cluster > f->maximum_cluster_number)
+    error_exit (f, ~ESPIPE);
 }
 
@@ -202 +206 @@
 -----------------------------------------------------------------------------*/
 
-static unsigned FAT_entry(struct rdcf *f, unsigned cluster)
-{
-        check_cluster(f, cluster);
-        if (f->maximum_cluster_number < RESERVED_CLUSTER_12_BIT) {
-                unsigned byte_index = cluster + (cluster>>1);
-                uint8_t p[2];
-                read_buffer(f, f->first_FAT_sector + byte_index/SECTOR_SIZE);
-                p[0] = f->buffer.buf[byte_index%SECTOR_SIZE];
-                byte_index++;
-                read_buffer(f, f->first_FAT_sector + byte_index/SECTOR_SIZE);
-                p[1] = f->buffer.buf[byte_index%SECTOR_SIZE];
-                return (cluster&1) ? (p[1]<<4 | p[0]>>4) : (p[0] | p[1])<<8&0xF00;
-        } else {
-                ushort x;
-                read_buffer(f, f->first_FAT_sector + cluster/(SECTOR_SIZE/2));
-                x = f->buffer.fat[cluster%(SECTOR_SIZE/2)];
-                #ifdef _BIG_ENDIAN
-                convert_short(x);
-                #endif
-                return x;
-        }
+static unsigned FAT_entry (struct rdcf *f, unsigned cluster)
+{
+  check_cluster (f, cluster);
+  if (f->maximum_cluster_number < RESERVED_CLUSTER_12_BIT) {
+    unsigned byte_index = cluster + (cluster >> 1);
+    uint8_t p[2];
+    read_buffer (f, f->first_FAT_sector + byte_index / SECTOR_SIZE);
+    p[0] = f->buffer.buf[byte_index % SECTOR_SIZE];
+    byte_index++;
+    read_buffer (f, f->first_FAT_sector + byte_index / SECTOR_SIZE);
+    p[1] = f->buffer.buf[byte_index % SECTOR_SIZE];
+    return (cluster & 1) ? (p[1] << 4 | p[0] >> 4) : (p[0] | p[1]) << 8 &
+      0xF00;
+  }
+  else {
+    ushort x;
+    read_buffer (f, f->first_FAT_sector + cluster / (SECTOR_SIZE / 2));
+    x = f->buffer.fat[cluster % (SECTOR_SIZE / 2)];
+#ifdef _BIG_ENDIAN
+    convert_short (x);
+#endif
+    return x;
+  }
 }
 
@@ -235 +241 @@
 -----------------------------------------------------------------------------*/
 
-static void set_FAT_entry(struct rdcf *f, unsigned cluster, unsigned x)
-{
-        unsigned sector;
-        check_cluster(f, cluster);
+static void set_FAT_entry (struct rdcf *f, unsigned cluster, unsigned x)
+{
+  unsigned sector;
+  check_cluster (f, cluster);
 #ifdef _BIG_ENDIAN
-        if (f->maximum_cluster_number >= RESERVED_CLUSTER_12_BIT)
-                convert_short(x);
+  if (f->maximum_cluster_number >= RESERVED_CLUSTER_12_BIT)
+    convert_short (x);
 #endif
-        sector = f->first_FAT_sector;
-        if (f->maximum_cluster_number < RESERVED_CLUSTER_12_BIT) {
-                unsigned byte_index = cluster + (cluster>>1);
-                uint8_t *p;
-                read_buffer(f, sector + byte_index/SECTOR_SIZE);
-                p = f->buffer.buf + byte_index%SECTOR_SIZE;
-                *p = (cluster&1) ? (*p & 0x0F) | (x<<4) : x;
-                f->buffer_status = DIRTY;
-                read_buffer(f, sector + (byte_index+1)/SECTOR_SIZE);
-                p = f->buffer.buf + (byte_index+1)%SECTOR_SIZE;
-                *p = (cluster&1) ? x>>4 : (*p&0xF0) | (x>>8);
-        } else {
-                read_buffer(f, sector + cluster/(SECTOR_SIZE/2));
-                f->buffer.fat[cluster%(SECTOR_SIZE/2)] = x;
-        }
-        f->buffer_status = DIRTY;
+  sector = f->first_FAT_sector;
+  if (f->maximum_cluster_number < RESERVED_CLUSTER_12_BIT) {
+    unsigned byte_index = cluster + (cluster >> 1);
+    uint8_t *p;
+    read_buffer (f, sector + byte_index / SECTOR_SIZE);
+    p = f->buffer.buf + byte_index % SECTOR_SIZE;
+    *p = (cluster & 1) ? (*p & 0x0F) | (x << 4) : x;
+    f->buffer_status = DIRTY;
+    read_buffer (f, sector + (byte_index + 1) / SECTOR_SIZE);
+    p = f->buffer.buf + (byte_index + 1) % SECTOR_SIZE;
+    *p = (cluster & 1) ? x >> 4 : (*p & 0xF0) | (x >> 8);
+  }
+  else {
+    read_buffer (f, sector + cluster / (SECTOR_SIZE / 2));
+    f->buffer.fat[cluster % (SECTOR_SIZE / 2)] = x;
+  }
+  f->buffer_status = DIRTY;
 }
 
@@ -267 +274 @@
 -----------------------------------------------------------------------------*/
 
-static void check_file_character(struct rdcf *f, unsigned c)
-{
-        static uint8_t table[32] = {
-                0xFF, 0xFF, 0xFF, 0xFF, 0x05, 0xDC, 0x00, 0xFC,
-                0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x90,
-                0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-                0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
-        };
-        if (table[c>>3] & 1<<(c&7)) error_exit(f, ~EINVAL);
+static void check_file_character (struct rdcf *f, unsigned c)
+{
+  static uint8_t table[32] = {
+    0xFF, 0xFF, 0xFF, 0xFF, 0x05, 0xDC, 0x00, 0xFC,
+    0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x90,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
+  };
+  if (table[c >> 3] & 1 << (c & 7))
+    error_exit (f, ~EINVAL);
 }
 
@@ -284 +292 @@
 -----------------------------------------------------------------------------*/
 
-static const char *spec_to_name_extension(struct rdcf *f,
-        uint8_t *name_extension, const uint8_t *spec)
-{
-        unsigned i = 0;
-        unsigned c;
-        while ((c=(*spec++))!=0 && c!=RDCF_SLASH_CHAR && c!='.') {
-                check_file_character(f,c);
-                if (i<NAME_SIZE) name_extension[i++] = toupper(c);
-        }
-        if (i==0) error_exit(f, ~EINVAL);
-        while (i<NAME_SIZE) name_extension[i++] = ' ';
-        if (c=='.') while ((c=(*spec++))!=0 && c!=RDCF_SLASH_CHAR) {
-                check_file_character(f,c);
-                if (i<NAME_SIZE+EXTENSION_SIZE) name_extension[i++] = toupper(c);
-        }
-        while (i<NAME_SIZE+EXTENSION_SIZE) name_extension[i++] = ' ';
-        return spec-1;
+static const char *spec_to_name_extension (struct rdcf *f,
+                                           uint8_t * name_extension,
+                                           const uint8_t * spec)
+{
+  unsigned i = 0;
+  unsigned c;
+  while ((c = (*spec++)) != 0 && c != RDCF_SLASH_CHAR && c != '.') {
+    check_file_character (f, c);
+    if (i < NAME_SIZE)
+      name_extension[i++] = toupper (c);
+  }
+  if (i == 0)
+    error_exit (f, ~EINVAL);
+  while (i < NAME_SIZE)
+    name_extension[i++] = ' ';
+  if (c == '.')
+    while ((c = (*spec++)) != 0 && c != RDCF_SLASH_CHAR) {
+      check_file_character (f, c);
+      if (i < NAME_SIZE + EXTENSION_SIZE)
+        name_extension[i++] = toupper (c);
+    }
+  while (i < NAME_SIZE + EXTENSION_SIZE)
+    name_extension[i++] = ' ';
+  return spec - 1;
 }
 
@@ -307 +322 @@
 -----------------------------------------------------------------------------*/
 
-static void name_extension_to_spec(uint8_t *spec, const uint8_t *name_extension)
-{
-        unsigned i;
-        uint8_t *s = spec;
-        for (i=0; i<NAME_SIZE && name_extension[i]!=' '; i++)
-                *s++ = name_extension[i];
-        if (name_extension[NAME_SIZE]!=' ') {
-                *s++ = '.';
-                for (i=NAME_SIZE;
-                                i<NAME_SIZE+EXTENSION_SIZE && name_extension[i]!=' '; i++) {
-                        *s++ = name_extension[i];
-                }
-        }
-        *s = 0;
+static void name_extension_to_spec (uint8_t * spec,
+                                    const uint8_t * name_extension)
+{
+  unsigned i;
+  uint8_t *s = spec;
+  for (i = 0; i < NAME_SIZE && name_extension[i] != ' '; i++)
+    *s++ = name_extension[i];
+  if (name_extension[NAME_SIZE] != ' ') {
+    *s++ = '.';
+    for (i = NAME_SIZE;
+         i < NAME_SIZE + EXTENSION_SIZE && name_extension[i] != ' '; i++) {
+      *s++ = name_extension[i];
+    }
+  }
+  *s = 0;
 }
 
@@ -328 +344 @@
 -----------------------------------------------------------------------------*/
 
-static unsigned first_sector_in_cluster(struct rdcf *f, unsigned cluster)
-{
-        check_cluster(f, cluster);
-        return f->first_data_sector + (cluster-2) * f->sectors_per_cluster;
+static unsigned first_sector_in_cluster (struct rdcf *f, unsigned cluster)
+{
+  check_cluster (f, cluster);
+  return f->first_data_sector + (cluster - 2) * f->sectors_per_cluster;
 }
 
@@ -339 +355 @@
 -----------------------------------------------------------------------------*/
 
-static struct directory *find_directory(struct rdcf *f)
-{
-        read_buffer(f, (f->directory_cluster == 0 ? f->first_directory_sector :
-                first_sector_in_cluster(f, f->directory_cluster)) +
-                f->directory_index/ENTRIES_PER_SECTOR);
-        return &f->buffer.dir[f->directory_index%ENTRIES_PER_SECTOR];
-}
- 
+static struct directory *find_directory (struct rdcf *f)
+{
+  read_buffer (f, (f->directory_cluster == 0 ? f->first_directory_sector :
+                   first_sector_in_cluster (f, f->directory_cluster)) +
+               f->directory_index / ENTRIES_PER_SECTOR);
+  return &f->buffer.dir[f->directory_index % ENTRIES_PER_SECTOR];
+}
+
 /*-----------------------------------------------------------------------------
 This function updates a directory entry.  If the "delete_entry" parameter is
@@ -352 +368 @@
 -----------------------------------------------------------------------------*/
 
-static void update_directory_entry(struct rdcf *f, int delete_entry)
-{
-        struct directory *d = find_directory(f);
-        if (f->file.attribute & RDCF_VOLUME || f->file.spec[0] == '.')
-                memcpy(d->name_extension, f->file.spec, NAME_SIZE+EXTENSION_SIZE);
-        else
-                spec_to_name_extension(f, d->name_extension, f->file.spec);
-        if (delete_entry) d->name_extension[0] = DELETED_FILE;
-        d->attribute = f->file.attribute;
-        d->date = (f->file.date_and_time.year-1980)<<9 |
-        f->file.date_and_time.month<<5 | f->file.date_and_time.day;
-        d->time = f->file.date_and_time.hour<<11 |
-        f->file.date_and_time.minute<<5 | f->file.date_and_time.second>>1;
-        d->first_cluster = f->file.first_cluster;
-        d->size = f->file.size;
-        memset(d->reserved, 0, sizeof(d->reserved));
+static void update_directory_entry (struct rdcf *f, int delete_entry)
+{
+  struct directory *d = find_directory (f);
+  if (f->file.attribute & RDCF_VOLUME || f->file.spec[0] == '.')
+    memcpy (d->name_extension, f->file.spec, NAME_SIZE + EXTENSION_SIZE);
+  else
+    spec_to_name_extension (f, d->name_extension, f->file.spec);
+  if (delete_entry)
+    d->name_extension[0] = DELETED_FILE;
+  d->attribute = f->file.attribute;
+  d->date = (f->file.date_and_time.year - 1980) << 9 |
+    f->file.date_and_time.month << 5 | f->file.date_and_time.day;
+  d->time = f->file.date_and_time.hour << 11 |
+    f->file.date_and_time.minute << 5 | f->file.date_and_time.second >> 1;
+  d->first_cluster = f->file.first_cluster;
+  d->size = f->file.size;
+  memset (d->reserved, 0, sizeof (d->reserved));
 #ifdef _BIG_ENDIAN
-        convert_short(d->date);
-        convert_short(d->time);
-        convert_short(d->first_cluster);
-        convert_long(d->size);
+  convert_short (d->date);
+  convert_short (d->time);
+  convert_short (d->first_cluster);
+  convert_long (d->size);
 #endif
-        f->buffer_status = DIRTY;
+  f->buffer_status = DIRTY;
 }
 
@@ -381 +398 @@
 -----------------------------------------------------------------------------*/
 
-static void read_directory_entry(struct rdcf *f)
-{
-        struct directory *d = find_directory(f);
-        if (d->attribute&RDCF_VOLUME) {
-                memcpy(f->file.spec, d->name_extension, NAME_SIZE+EXTENSION_SIZE);
-                f->file.spec[NAME_SIZE+EXTENSION_SIZE] = 0;
-        } else
-                name_extension_to_spec(f->file.spec, d->name_extension);
-        f->file.attribute = d->attribute;
-        {
-                ushort date = d->date;
+static void read_directory_entry (struct rdcf *f)
+{
+  struct directory *d = find_directory (f);
+  if (d->attribute & RDCF_VOLUME) {
+    memcpy (f->file.spec, d->name_extension, NAME_SIZE + EXTENSION_SIZE);
+    f->file.spec[NAME_SIZE + EXTENSION_SIZE] = 0;
+  }
+  else
+    name_extension_to_spec (f->file.spec, d->name_extension);
+  f->file.attribute = d->attribute;
+  {
+    ushort date = d->date;
 #ifdef _BIG_ENDIAN
-                convert_short(date);
+    convert_short (date);
 #endif
-                f->file.date_and_time.year = (date>>9)+1980;
-                f->file.date_and_time.month = date>>5&0xF;
-                f->file.date_and_time.day = date&0x1F;
-        }
-        {
-                ushort aTime = d->time;
+    f->file.date_and_time.year = (date >> 9) + 1980;
+    f->file.date_and_time.month = date >> 5 & 0xF;
+    f->file.date_and_time.day = date & 0x1F;
+  }
+  {
+    ushort aTime = d->time;
 #ifdef _BIG_ENDIAN
-                convert_short(time);
+    convert_short (time);
 #endif
-                f->file.date_and_time.hour = aTime>>11;
-                f->file.date_and_time.minute = aTime>>5&0x3F;
-                f->file.date_and_time.second = aTime<<1&0x1F<<1;
-        }
-        f->file.first_cluster = d->first_cluster;
-        f->file.size = d->size;
+    f->file.date_and_time.hour = aTime >> 11;
+    f->file.date_and_time.minute = aTime >> 5 & 0x3F;
+    f->file.date_and_time.second = aTime << 1 & 0x1F << 1;
+  }
+  f->file.first_cluster = d->first_cluster;
+  f->file.size = d->size;
 #ifdef _BIG_ENDIAN
-        convert_short(f->file.first_cluster);
-        convert_long(f->file.size);
+  convert_short (f->file.first_cluster);
+  convert_long (f->file.size);
 #endif
 }
@@ -435 +453 @@
 -----------------------------------------------------------------------------*/
 
-static int find_file_in_directory_or_find_volume(struct rdcf *f,
-        const uint8_t *name_extension)
-{
-        unsigned empty_cluster = 2;
-        unsigned empty_index = NO_DIRECTORY_INDEX;
-        unsigned number_of_directory_entries = f->directory_cluster == 0 ?
-                (f->first_data_sector - f->first_directory_sector)*ENTRIES_PER_SECTOR :
-                ENTRIES_PER_SECTOR*f->sectors_per_cluster;
-        f->directory_first_cluster = f->directory_cluster;
-        while (1) {
-                for (f->directory_index = 0;
-                                f->directory_index < number_of_directory_entries; f->directory_index++) {
-                        struct directory *d = find_directory(f);
-                        if ((d->name_extension[0] == DELETED_FILE ||
-                                        d->name_extension[0] == END_DIRECTORY) &&
-                                        empty_index == NO_DIRECTORY_INDEX) {
-                                empty_cluster = f->directory_cluster;
-                                empty_index = f->directory_index;
-                        }
-                        if (d->name_extension[0] == END_DIRECTORY) break;
-                        if ((name_extension == NULL &&
-                                        (d->name_extension[0] != DELETED_FILE && d->attribute & RDCF_VOLUME)) ||
-                                        (name_extension != NULL &&
-                                        (memcmp(d->name_extension, name_extension, NAME_SIZE+EXTENSION_SIZE)
-                                        == 0 && (d->attribute&RDCF_VOLUME) == 0))) {
-                                read_directory_entry(f);
-                                return 1;
-                        }
-                }
-                if (f->directory_index < number_of_directory_entries ||
-                                f->directory_cluster == 0) {
-                        break;
-                }
-                {
-                        unsigned x = FAT_entry(f, f->directory_cluster);
-                        if (x >= f->last_cluster_mark) break;
-                        f->directory_cluster = x;
-                }
-        }
-        f->directory_index = empty_index;
-        if (f->directory_index != NO_DIRECTORY_INDEX)
-                f->directory_cluster = empty_cluster;
-        if (name_extension != NULL)
-                name_extension_to_spec(f->file.spec, name_extension);
-        return 0;
+static int find_file_in_directory_or_find_volume (struct rdcf *f,
+                                                  const uint8_t *
+                                                  name_extension)
+{
+  unsigned empty_cluster = 2;
+  unsigned empty_index = NO_DIRECTORY_INDEX;
+  unsigned number_of_directory_entries = f->directory_cluster == 0 ?
+    (f->first_data_sector - f->first_directory_sector) * ENTRIES_PER_SECTOR :
+    ENTRIES_PER_SECTOR * f->sectors_per_cluster;
+  f->directory_first_cluster = f->directory_cluster;
+  while (1) {
+    for (f->directory_index = 0;
+         f->directory_index < number_of_directory_entries;
+         f->directory_index++) {
+      struct directory *d = find_directory (f);
+      if ((d->name_extension[0] == DELETED_FILE ||
+           d->name_extension[0] == END_DIRECTORY) &&
+          empty_index == NO_DIRECTORY_INDEX) {
+        empty_cluster = f->directory_cluster;
+        empty_index = f->directory_index;
+      }
+      if (d->name_extension[0] == END_DIRECTORY)
+        break;
+      if ((name_extension == NULL &&
+           (d->name_extension[0] != DELETED_FILE
+            && d->attribute & RDCF_VOLUME)) || (name_extension != NULL
+                                                &&
+                                                (memcmp
+                                                 (d->name_extension,
+                                                  name_extension,
+                                                  NAME_SIZE + EXTENSION_SIZE)
+                                                 == 0
+                                                 && (d->
+                                                     attribute & RDCF_VOLUME)
+                                                 == 0))) {
+        read_directory_entry (f);
+        return 1;
+      }
+    }
+    if (f->directory_index < number_of_directory_entries ||
+        f->directory_cluster == 0) {
+      break;
+    }
+    {
+      unsigned x = FAT_entry (f, f->directory_cluster);
+      if (x >= f->last_cluster_mark)
+        break;
+      f->directory_cluster = x;
+    }
+  }
+  f->directory_index = empty_index;
+  if (f->directory_index != NO_DIRECTORY_INDEX)
+    f->directory_cluster = empty_cluster;
+  if (name_extension != NULL)
+    name_extension_to_spec (f->file.spec, name_extension);
+  return 0;
 }
 
@@ -494 +523 @@
 -----------------------------------------------------------------------------*/
 
-static int find_file(struct rdcf *f, const char *spec)
-{
-                /* start with root directory */
-        f->directory_cluster = 0;
-        while (1) {
-                int found;
-                uint8_t name_extension[NAME_SIZE+EXTENSION_SIZE];
-                        /* scan name and extension */
-                spec = spec_to_name_extension(f, name_extension, spec);
-                        /* look it up in directory */
-                found = find_file_in_directory_or_find_volume(f, name_extension);
-                        /* if this is the end of the file specification, return */
-                if (*spec == 0) return found;
-                        /* otherwise, the name and extension were a subdirectory in the path */
-                if (!found || (f->file.attribute&RDCF_DIRECTORY) == 0)
-                        error_exit(f, ~EISDIR);
-                f->directory_cluster = f->file.first_cluster;
-                        /* skip over the \ after the subdirectory */
-                spec++;
-        }
+static int find_file (struct rdcf *f, const char *spec)
+{
+  /* start with root directory */
+  f->directory_cluster = 0;
+  while (1) {
+    int found;
+    uint8_t name_extension[NAME_SIZE + EXTENSION_SIZE];
+    /* scan name and extension */
+    spec = spec_to_name_extension (f, name_extension, spec);
+    /* look it up in directory */
+    found = find_file_in_directory_or_find_volume (f, name_extension);
+    /* if this is the end of the file specification, return */
+    if (*spec == 0)
+      return found;
+    /* otherwise, the name and extension were a subdirectory in the path */
+    if (!found || (f->file.attribute & RDCF_DIRECTORY) == 0)
+      error_exit (f, ~EISDIR);
+    f->directory_cluster = f->file.first_cluster;
+    /* skip over the \ after the subdirectory */
+    spec++;
+  }
 }
 
@@ -520 +550 @@
 -----------------------------------------------------------------------------*/
 
-static void read_file_system_information(struct rdcf *f)
-{
-        f->first_FAT_sector = DriveDesc.FirstFatSector;
-        f->sectors_per_FAT = DriveDesc.SectorsPerFAT;
-        f->sectors_per_cluster = DriveDesc.SectorsPerCluster;
-        f->first_directory_sector = DriveDesc.RootDirSector;
-        f->first_data_sector = DriveDesc.DataStartSector;
-        f->maximum_cluster_number =
-                ((DriveDesc.MaxDataSector - DriveDesc.DataStartSector) /
-                DriveDesc.SectorsPerCluster) + 1;
-        f->last_cluster_mark =
-                f->maximum_cluster_number < RESERVED_CLUSTER_12_BIT ?
-                LAST_CLUSTER_12_BIT : LAST_CLUSTER_16_BIT;
+static void read_file_system_information (struct rdcf *f)
+{
+  f->first_FAT_sector = DriveDesc.FirstFatSector;
+  f->sectors_per_FAT = DriveDesc.SectorsPerFAT;
+  f->sectors_per_cluster = DriveDesc.SectorsPerCluster;
+  f->first_directory_sector = DriveDesc.RootDirSector;
+  f->first_data_sector = DriveDesc.DataStartSector;
+  f->maximum_cluster_number =
+    ((DriveDesc.MaxDataSector - DriveDesc.DataStartSector) /
+     DriveDesc.SectorsPerCluster) + 1;
+  f->last_cluster_mark =
+    f->maximum_cluster_number < RESERVED_CLUSTER_12_BIT ?
+    LAST_CLUSTER_12_BIT : LAST_CLUSTER_16_BIT;
 }
 
@@ -542 +572 @@
 #ifdef RDCF_MULTIPLE_DRIVE
 #error "multiple drives has not been implemented!"
-static char *get_drive(struct rdcf *f, char *spec)
-{
-        if (spec[0] != 0 && spec[1] == ':') {
-                if (isalpha(spec[0])) f->drive = toupper(spec[0])-'A';
-                else error_exit(f, ~EINVAL);
-                return spec + 2;
-        }
-        error_exit(f, ~EINVAL);
+static char *get_drive (struct rdcf *f, char *spec)
+{
+  if (spec[0] != 0 && spec[1] == ':') {
+    if (isalpha (spec[0]))
+      f->drive = toupper (spec[0]) - 'A';
+    else
+      error_exit (f, ~EINVAL);
+    return spec + 2;
+  }
+  error_exit (f, ~EINVAL);
 }
 #endif
@@ -559 +591 @@
 -----------------------------------------------------------------------------*/
 
-static const char * initialize_fcb(struct rdcf *f, const char * spec)
-{
-        f->buffer_status = EMPTY;
-        f->first_possibly_empty_cluster = 2;
-        read_file_system_information(f);
-        return spec;
+static const char *initialize_fcb (struct rdcf *f, const char *spec)
+{
+  f->buffer_status = EMPTY;
+  f->first_possibly_empty_cluster = 2;
+  read_file_system_information (f);
+  return spec;
 }
 
@@ -572 +604 @@
 -----------------------------------------------------------------------------*/
 
-static void check_write_access(struct rdcf *f)
-{
-        if (f->file.attribute & (RDCF_READ_ONLY+RDCF_HIDDEN+RDCF_SYSTEM))
-                error_exit(f, ~EACCES);
+static void check_write_access (struct rdcf *f)
+{
+  if (f->file.attribute & (RDCF_READ_ONLY + RDCF_HIDDEN + RDCF_SYSTEM))
+    error_exit (f, ~EACCES);
 }
 
@@ -582 +614 @@
 -----------------------------------------------------------------------------*/
 
-static void release_FAT_entries(struct rdcf *f)
-{
-        unsigned j;
-        j = f->file.first_cluster;
-        if (j != EMPTY_CLUSTER) {
-                while (j < f->last_cluster_mark && j) {
-                        unsigned k = FAT_entry(f,j);
-                        if (j < f->first_possibly_empty_cluster) {
-                          f->first_possibly_empty_cluster = j;
-                        }
-                        set_FAT_entry(f,j,EMPTY_CLUSTER);
-                        j = k;
-                }
-        }
-        f->mode |= WRITTEN;
+static void release_FAT_entries (struct rdcf *f)
+{
+  unsigned j;
+  j = f->file.first_cluster;
+  if (j != EMPTY_CLUSTER) {
+    while (j < f->last_cluster_mark && j) {
+      unsigned k = FAT_entry (f, j);
+      if (j < f->first_possibly_empty_cluster) {
+        f->first_possibly_empty_cluster = j;
+      }
+      set_FAT_entry (f, j, EMPTY_CLUSTER);
+      j = k;
+    }
+  }
+  f->mode |= WRITTEN;
 }
 
@@ -605 +637 @@
 -----------------------------------------------------------------------------*/
 
-static unsigned add_new_cluster(struct rdcf *f, unsigned cluster,
-        unsigned first_possibly_empty_cluster)
-{
-unsigned new_cluster;
-        for (new_cluster = first_possibly_empty_cluster;
-                        new_cluster <= f->maximum_cluster_number; new_cluster++) {
-                if (FAT_entry(f, new_cluster)==EMPTY_CLUSTER) break;
-        }
-        if (new_cluster > f->maximum_cluster_number) return EMPTY_CLUSTER;
-        if (cluster != EMPTY_CLUSTER) set_FAT_entry(f, cluster, new_cluster);
-        set_FAT_entry(f, new_cluster, f->last_cluster_mark);
-        return new_cluster;
+static unsigned add_new_cluster (struct rdcf *f, unsigned cluster,
+                                 unsigned first_possibly_empty_cluster)
+{
+  unsigned new_cluster;
+  for (new_cluster = first_possibly_empty_cluster;
+       new_cluster <= f->maximum_cluster_number; new_cluster++) {
+    if (FAT_entry (f, new_cluster) == EMPTY_CLUSTER)
+      break;
+  }
+  if (new_cluster > f->maximum_cluster_number)
+    return EMPTY_CLUSTER;
+  if (cluster != EMPTY_CLUSTER)
+    set_FAT_entry (f, cluster, new_cluster);
+  set_FAT_entry (f, new_cluster, f->last_cluster_mark);
+  return new_cluster;
 }
 
@@ -623 +658 @@
 -----------------------------------------------------------------------------*/
 
-static void clear_cluster(struct rdcf *f, unsigned cluster)
-{
-        unsigned count = f->sectors_per_cluster;
-        unsigned sector = first_sector_in_cluster(f, cluster);
-        flush_buffer(f);
-        f->buffer_status = EMPTY;
-        memset(f->buffer.buf, 0, SECTOR_SIZE);
-        do write_sector(f, sector++, f->buffer.buf); while (--count != 0);
+static void clear_cluster (struct rdcf *f, unsigned cluster)
+{
+  unsigned count = f->sectors_per_cluster;
+  unsigned sector = first_sector_in_cluster (f, cluster);
+  flush_buffer (f);
+  f->buffer_status = EMPTY;
+  memset (f->buffer.buf, 0, SECTOR_SIZE);
+  do
+    write_sector (f, sector++, f->buffer.buf);
+  while (--count != 0);
 }
 
@@ -638 +675 @@
 -----------------------------------------------------------------------------*/
 
-static void lengthen_directory_if_necessary(struct rdcf *f)
-{
-        if (f->directory_index == NO_DIRECTORY_INDEX) {
-                if (f->directory_cluster == 0) error_exit(f, ~ENOSPC);
-                f->directory_cluster = add_new_cluster(f, f->directory_cluster, 2);
-                if (f->directory_cluster == 0) error_exit(f, ~ENOSPC);
-                f->directory_index = 0;
-                clear_cluster(f, f->directory_cluster);
-        }
+static void lengthen_directory_if_necessary (struct rdcf *f)
+{
+  if (f->directory_index == NO_DIRECTORY_INDEX) {
+    if (f->directory_cluster == 0)
+      error_exit (f, ~ENOSPC);
+    f->directory_cluster = add_new_cluster (f, f->directory_cluster, 2);
+    if (f->directory_cluster == 0)
+      error_exit (f, ~ENOSPC);
+    f->directory_index = 0;
+    clear_cluster (f, f->directory_cluster);
+  }
 }
 
@@ -658 +697 @@
     (RDCF_ARCHIVE+RDCF_HIDDEN+RDCF_READ_ONLY+RDCF_SYSTEM)
 
-int rdcf_close(struct rdcf *f)
-{
-        if ((f->result=setjmp(f->error)) != 0) return f->result;
-        if (f->mode & WRITTEN) {
-                f->buffer_status = EMPTY;
-                f->file.attribute |= RDCF_ARCHIVE;
-                rdcf_get_date_and_time(&f->file.date_and_time);
-                        // do not allow empty files.
-                update_directory_entry(f, (f->file.size) ? 0 : 1);
-                flush_buffer(f);
-        }
-        return 0;
-}
-
-int rdcf_delete(struct rdcf *f, const char *spec)
-{
-        if ((f->result=setjmp(f->error)) != 0) return f->result;
-        spec = initialize_fcb(f, spec);
-        if (*spec == 0) /* delete volume label */ {
-                if (!find_file_in_directory_or_find_volume(f, NULL))
-                        error_exit(f, ~ENOENT);
-        } else if (!find_file(f, spec))
-                error_exit(f, ~ENOENT);
-                /* check to see that a directory is empty before deleting it */
-        else if (f->file.attribute & RDCF_DIRECTORY) {
-                unsigned cluster = f->file.first_cluster;
-                while (cluster != EMPTY_CLUSTER && cluster < f->last_cluster_mark) {
-                        unsigned sector = first_sector_in_cluster(f, cluster);
-                        unsigned sector_count = f->sectors_per_cluster;
-                        unsigned next_cluster = FAT_entry(f, cluster);
-                        do {
-                                unsigned entry_count = ENTRIES_PER_SECTOR;
-                                uint8_t *p = f->buffer.buf;
-                                read_buffer(f, sector);
-                                do {
-                                        unsigned c = *p;
-                                        if (c == END_DIRECTORY) break;
-                                        if (c != DELETED_FILE && c != '.') error_exit(f, ~EACCES);
-                                        p += sizeof(struct directory);
-                                } while (--entry_count != 0);
-                                if (entry_count != 0) break;
-                        } while (--sector_count != 0);
-                        cluster = next_cluster;
-                }
-        } else check_write_access(f);
-        release_FAT_entries(f);
-        update_directory_entry(f, 1);
-        flush_buffer(f);
-        return 0;
-}
-
-int rdcf_rename(struct rdcf *f, const char *old_spec, const char *new_spec)
-{
-        uint8_t name_extension[NAME_SIZE+EXTENSION_SIZE];
-        if ((f->result=setjmp(f->error)) != 0) return f->result;
-        old_spec = initialize_fcb(f, old_spec);
-        if (!find_file(f, old_spec)) error_exit(f, ~ENOENT);
-        if (f->file.attribute & (RDCF_HIDDEN+RDCF_SYSTEM))
-                error_exit(f, ~EACCES);
-        spec_to_name_extension(f, name_extension, new_spec);
-        f->directory_cluster = f->directory_first_cluster;
-        if (find_file_in_directory_or_find_volume(f, name_extension))
-                error_exit(f, ~ENOENT);
-        find_file(f, old_spec);
-        name_extension_to_spec(f->file.spec, name_extension);
-        update_directory_entry(f, 0);
-        flush_buffer(f);
-        return 0;
-}
-
-int rdcf_open(struct rdcf *f, const char *spec, unsigned mode)
-{
-        int found;
-        if ((f->result=setjmp(f->error)) != 0) return f->result;
-                // make sure it is not open on another stream.
-        f->mode = 0;
-        found = find_file(f, initialize_fcb(f, spec));
-        if (found && f->file.attribute&RDCF_DIRECTORY)
-                error_exit(f, ~EISDIR);
-                // see how to open the file.
-        if (mode & _FTRUNC && found) {
-                        // simply empty the file of clusters.
-                if (found) {
-                        check_write_access(f);
-                        release_FAT_entries(f);
-                        flush_buffer(f);
-                } else lengthen_directory_if_necessary(f);
-                f->file.first_cluster = EMPTY_CLUSTER;
-                f->file.size = 0L;
-        }
-                // create new dir entry if mode is not purely read: "r"
-        if (!found && (mode & 0x3)) {
-                f->file.attribute = RDCF_ARCHIVE;
-                rdcf_get_date_and_time(&f->file.date_and_time);
-                f->mode |= WRITTEN;
-                f->file.first_cluster = EMPTY_CLUSTER;
-                f->file.size = 0L;
-                update_directory_entry(f, 0);
-                flush_buffer(f);
-        }
-        if ((mode & 0x3) == 0) {
-                        // open for reading.
-                f->mode |= RDCF_READ;
-                if (!found) error_exit(f, ~ENOENT);
-        } else {
-                        // open for writing or
-                f->mode |= RDCF_WRITE;
-                        // open for read write.
-                if ((mode & 0x3) == 2) f->mode |= RDCF_READ;
-                check_write_access(f);
-        }
-        f->last_cluster = EMPTY_CLUSTER;
-        f->position = 0;
-        f->cluster = f->file.first_cluster;
-        if (mode & _FAPPEND) {
-                        // seek to end of file.
-                if ((found = rdcf_seek(f, f->file.size)) != 0) return found;
-        }
-        return 0;
+int rdcf_close (struct rdcf *f)
+{
+  if ((f->result = setjmp (f->error)) != 0)
+    return f->result;
+  if (f->mode & WRITTEN) {
+    f->buffer_status = EMPTY;
+    f->file.attribute |= RDCF_ARCHIVE;
+    rdcf_get_date_and_time (&f->file.date_and_time);
+    // do not allow empty files.
+    update_directory_entry (f, (f->file.size) ? 0 : 1);
+    flush_buffer (f);
+  }
+  return 0;
+}
+
+int rdcf_delete (struct rdcf *f, const char *spec)
+{
+  if ((f->result = setjmp (f->error)) != 0)
+    return f->result;
+  spec = initialize_fcb (f, spec);
+  if (*spec == 0) {             /* delete volume label */
+    if (!find_file_in_directory_or_find_volume (f, NULL))
+      error_exit (f, ~ENOENT);
+  }
+  else if (!find_file (f, spec))
+    error_exit (f, ~ENOENT);
+  /* check to see that a directory is empty before deleting it */
+  else if (f->file.attribute & RDCF_DIRECTORY) {
+    unsigned cluster = f->file.first_cluster;
+    while (cluster != EMPTY_CLUSTER && cluster < f->last_cluster_mark) {
+      unsigned sector = first_sector_in_cluster (f, cluster);
+      unsigned sector_count = f->sectors_per_cluster;
+      unsigned next_cluster = FAT_entry (f, cluster);
+      do {
+        unsigned entry_count = ENTRIES_PER_SECTOR;
+        uint8_t *p = f->buffer.buf;
+        read_buffer (f, sector);
+        do {
+          unsigned c = *p;
+          if (c == END_DIRECTORY)
+            break;
+          if (c != DELETED_FILE && c != '.')
+            error_exit (f, ~EACCES);
+          p += sizeof (struct directory);
+        } while (--entry_count != 0);
+        if (entry_count != 0)
+          break;
+      } while (--sector_count != 0);
+      cluster = next_cluster;
+    }
+  }
+  else
+    check_write_access (f);
+  release_FAT_entries (f);
+  update_directory_entry (f, 1);
+  flush_buffer (f);
+  return 0;
+}
+
+int rdcf_rename (struct rdcf *f, const char *old_spec, const char *new_spec)
+{
+  uint8_t name_extension[NAME_SIZE + EXTENSION_SIZE];
+  if ((f->result = setjmp (f->error)) != 0)
+    return f->result;
+  old_spec = initialize_fcb (f, old_spec);
+  if (!find_file (f, old_spec))
+    error_exit (f, ~ENOENT);
+  if (f->file.attribute & (RDCF_HIDDEN + RDCF_SYSTEM))
+    error_exit (f, ~EACCES);
+  spec_to_name_extension (f, name_extension, new_spec);
+  f->directory_cluster = f->directory_first_cluster;
+  if (find_file_in_directory_or_find_volume (f, name_extension))
+    error_exit (f, ~ENOENT);
+  find_file (f, old_spec);
+  name_extension_to_spec (f->file.spec, name_extension);
+  update_directory_entry (f, 0);
+  flush_buffer (f);
+  return 0;
+}
+
+int rdcf_open (struct rdcf *f, const char *spec, unsigned mode)
+{
+  int found;
+  if ((f->result = setjmp (f->error)) != 0)
+    return f->result;
+  // make sure it is not open on another stream.
+  f->mode = 0;
+  found = find_file (f, initialize_fcb (f, spec));
+  if (found && f->file.attribute & RDCF_DIRECTORY)
+    error_exit (f, ~EISDIR);
+  // see how to open the file.
+  if (mode & _FTRUNC && found) {
+    // simply empty the file of clusters.
+    if (found) {
+      check_write_access (f);
+      release_FAT_entries (f);
+      flush_buffer (f);
+    }
+    else
+      lengthen_directory_if_necessary (f);
+    f->file.first_cluster = EMPTY_CLUSTER;
+    f->file.size = 0L;
+  }
+  // create new dir entry if mode is not purely read: "r"
+  if (!found && (mode & 0x3)) {
+    f->file.attribute = RDCF_ARCHIVE;
+    rdcf_get_date_and_time (&f->file.date_and_time);
+    f->mode |= WRITTEN;
+    f->file.first_cluster = EMPTY_CLUSTER;
+    f->file.size = 0L;
+    update_directory_entry (f, 0);
+    flush_buffer (f);
+  }
+  if ((mode & 0x3) == 0) {
+    // open for reading.
+    f->mode |= RDCF_READ;
+    if (!found)
+      error_exit (f, ~ENOENT);
+  }
+  else {
+    // open for writing or
+    f->mode |= RDCF_WRITE;
+    // open for read write.
+    if ((mode & 0x3) == 2)
+      f->mode |= RDCF_READ;
+    check_write_access (f);
+  }
+  f->last_cluster = EMPTY_CLUSTER;
+  f->position = 0;
+  f->cluster = f->file.first_cluster;
+  if (mode & _FAPPEND) {
+    // seek to end of file.
+    if ((found = rdcf_seek (f, f->file.size)) != 0)
+      return found;
+  }
+  return 0;
 }
 
@@ -786 +842 @@
  *
 ***************************************************************/
-int rdcf_read(struct rdcf *f, void *buf, int count)
-{
-        uint32_t size = f->file.size;
-        unsigned unread_bytes = count;
-        uint32_t position = f->position;
-        char *buffer = buf;
-        if ((f->result=setjmp(f->error)) != 0) return f->result;
-        if ((f->mode & RDCF_READ) == 0) error_exit(f, ~EBADFD);
-        f->buffer_status = EMPTY;
-        while (unread_bytes>0) {
-                unsigned n = unread_bytes;
-                unsigned rest_of_sector = SECTOR_SIZE - position%SECTOR_SIZE;
-                unsigned sector;
-                if (size<position+n) n = size-position;
-                if (n==0) break;
-                sector = first_sector_in_cluster(f, f->cluster) +
-                        (position/SECTOR_SIZE)%f->sectors_per_cluster;
-                if (n>rest_of_sector) n = rest_of_sector;
-                if (position%SECTOR_SIZE==0 && n==SECTOR_SIZE)
-                        read_sector(f, sector, buffer);
-                else /* read a partial sector */ {
-                        read_buffer(f, sector);
-                        memcpy(buffer, &f->buffer.buf[position%SECTOR_SIZE], n);
-                }
-                buffer += n;
-                position += n;
-                unread_bytes -= n;
-                if (position%(f->sectors_per_cluster*SECTOR_SIZE)==0 && position<size) {
-                        unsigned next_cluster = FAT_entry(f, f->cluster);
-                        if (next_cluster >= f->last_cluster_mark) f->last_cluster = f->cluster;
-                        f->cluster = next_cluster;
-                }
-        }
-        f->position = position;
-        return f->result = count - unread_bytes;
-}
-
-
-int rdcf_seek(struct rdcf *f, uint32_t offset)
-{
-        unsigned i, cluster;
-        if ((f->result=setjmp(f->error)) != 0) return f->result;
-        if (offset>f->file.size) error_exit(f, ~ESPIPE);
-        f->buffer_status = EMPTY;
-        cluster = f->file.first_cluster;
-        for (i=offset/(f->sectors_per_cluster*SECTOR_SIZE); i>0; i--) {
-                unsigned new_cluster = FAT_entry(f, cluster);
-                if (new_cluster >= f->last_cluster_mark) f->last_cluster = cluster;
-                cluster = new_cluster;
-        }
-        f->cluster = cluster;
-        f->position = offset;
-        return 0;
-}
-
-static int real_rdcf_write(struct rdcf *f, const uint8_t *buf, int count)
-{
-        uint32_t size = f->file.size;
-        uint32_t position = f->position;
-        unsigned unwritten_bytes = count;
-        const char *buffer = buf;
-        if ((f->result=setjmp(f->error)) != 0) return f->result;
-        f->buffer_status = EMPTY;
-        if ((f->mode & RDCF_WRITE) == 0) error_exit(f, ~EBADFD);
-        while (unwritten_bytes>0) {
-                unsigned sector;
-                unsigned n = unwritten_bytes;
-                unsigned rest_of_sector = SECTOR_SIZE - position%SECTOR_SIZE;
-                if (n>rest_of_sector) n = rest_of_sector;
-                if (f->cluster == EMPTY_CLUSTER || f->cluster >= f->last_cluster_mark) {
-                        unsigned new_cluster =
-                                add_new_cluster(f, f->last_cluster, f->first_possibly_empty_cluster);
-                        if (new_cluster == EMPTY_CLUSTER) break;
-                        f->first_possibly_empty_cluster = new_cluster+1;
-                        f->cluster = f->last_cluster = new_cluster;
-                        if (f->file.first_cluster==EMPTY_CLUSTER)
-                        f->file.first_cluster = new_cluster;
-                }
-                sector = first_sector_in_cluster(f, f->cluster) +
-                        (position/SECTOR_SIZE)%f->sectors_per_cluster;
-                if (position%SECTOR_SIZE==0 &&
-                                (n==SECTOR_SIZE || position+n>=size)) {
-                        write_sector(f, sector, buffer);
-                } else /* write a partial sector */ {
-                        read_buffer(f, sector);
-                        memcpy(&f->buffer.buf[position%SECTOR_SIZE], buffer, n);
-                        f->buffer_status = DIRTY;
-                }
-                buffer += n;
-                position += n;
-                unwritten_bytes -= n;
-                if (position>size) size = position;
-                if (position%(f->sectors_per_cluster*SECTOR_SIZE)==0) {
-                        unsigned next_cluster = FAT_entry(f, f->cluster);
-                        if (next_cluster >= f->last_cluster_mark)
-                                f->last_cluster = f->cluster;
-                        f->cluster = next_cluster;
-                }
-        }
-        flush_buffer(f);
-        f->position = position;
-        f->file.size = size;
-        f->mode |= WRITTEN;
+int rdcf_read (struct rdcf *f, void *buf, int count)
+{
+  uint32_t size = f->file.size;
+  unsigned unread_bytes = count;
+  uint32_t position = f->position;
+  char *buffer = buf;
+  if ((f->result = setjmp (f->error)) != 0)
+    return f->result;
+  if ((f->mode & RDCF_READ) == 0)
+    error_exit (f, ~EBADFD);
+  f->buffer_status = EMPTY;
+  while (unread_bytes > 0) {
+    unsigned n = unread_bytes;
+    unsigned rest_of_sector = SECTOR_SIZE - position % SECTOR_SIZE;
+    unsigned sector;
+    if (size < position + n)
+      n = size - position;
+    if (n == 0)
+      break;
+    sector = first_sector_in_cluster (f, f->cluster) +
+      (position / SECTOR_SIZE) % f->sectors_per_cluster;
+    if (n > rest_of_sector)
+      n = rest_of_sector;
+    if (position % SECTOR_SIZE == 0 && n == SECTOR_SIZE)
+      read_sector (f, sector, buffer);
+    else {                      /* read a partial sector */
+
+      read_buffer (f, sector);
+      memcpy (buffer, &f->buffer.buf[position % SECTOR_SIZE], n);
+    }
+    buffer += n;
+    position += n;
+    unread_bytes -= n;
+    if (position % (f->sectors_per_cluster * SECTOR_SIZE) == 0
+        && position < size) {
+      unsigned next_cluster = FAT_entry (f, f->cluster);
+      if (next_cluster >= f->last_cluster_mark)
+        f->last_cluster = f->cluster;
+      f->cluster = next_cluster;
+    }
+  }
+  f->position = position;
+  return f->result = count - unread_bytes;
+}
+
+
+int rdcf_seek (struct rdcf *f, uint32_t offset)
+{
+  unsigned i, cluster;
+  if ((f->result = setjmp (f->error)) != 0)
+    return f->result;
+  if (offset > f->file.size)
+    error_exit (f, ~ESPIPE);
+  f->buffer_status = EMPTY;
+  cluster = f->file.first_cluster;
+  for (i = offset / (f->sectors_per_cluster * SECTOR_SIZE); i > 0; i--) {
+    unsigned new_cluster = FAT_entry (f, cluster);
+    if (new_cluster >= f->last_cluster_mark)
+      f->last_cluster = cluster;
+    cluster = new_cluster;
+  }
+  f->cluster = cluster;
+  f->position = offset;
+  return 0;
+}
+
+static int real_rdcf_write (struct rdcf *f, const uint8_t * buf, int count)
+{
+  uint32_t size = f->file.size;
+  uint32_t position = f->position;
+  unsigned unwritten_bytes = count;
+  const char *buffer = buf;
+  if ((f->result = setjmp (f->error)) != 0)
+    return f->result;
+  f->buffer_status = EMPTY;
+  if ((f->mode & RDCF_WRITE) == 0)
+    error_exit (f, ~EBADFD);
+  while (unwritten_bytes > 0) {
+    unsigned sector;
+    unsigned n = unwritten_bytes;
+    unsigned rest_of_sector = SECTOR_SIZE - position % SECTOR_SIZE;
+    if (n > rest_of_sector)
+      n = rest_of_sector;
+    if (f->cluster == EMPTY_CLUSTER || f->cluster >= f->last_cluster_mark) {
+      unsigned new_cluster =
+        add_new_cluster (f, f->last_cluster, f->first_possibly_empty_cluster);
+      if (new_cluster == EMPTY_CLUSTER)
+        break;
+      f->first_possibly_empty_cluster = new_cluster + 1;
+      f->cluster = f->last_cluster = new_cluster;
+      if (f->file.first_cluster == EMPTY_CLUSTER)
+        f->file.first_cluster = new_cluster;
+    }
+    sector = first_sector_in_cluster (f, f->cluster) +
+      (position / SECTOR_SIZE) % f->sectors_per_cluster;
+    if (position % SECTOR_SIZE == 0 &&
+        (n == SECTOR_SIZE || position + n >= size)) {
+      write_sector (f, sector, buffer);
+    }
+    else {                      /* write a partial sector */
+
+      read_buffer (f, sector);
+      memcpy (&f->buffer.buf[position % SECTOR_SIZE], buffer, n);
+      f->buffer_status = DIRTY;
+    }
+    buffer += n;
+    position += n;
+    unwritten_bytes -= n;
+    if (position > size)
+      size = position;
+    if (position % (f->sectors_per_cluster * SECTOR_SIZE) == 0) {
+      unsigned next_cluster = FAT_entry (f, f->cluster);
+      if (next_cluster >= f->last_cluster_mark)
+        f->last_cluster = f->cluster;
+      f->cluster = next_cluster;
+    }
+  }
+  flush_buffer (f);
+  f->position = position;
+  f->file.size = size;
+  f->mode |= WRITTEN;
 #ifdef RDCF_FLUSH_DIR_AFTER_WRITE
-        rdcf_get_date_and_time(&f->file.date_and_time);
-                // do not allow empty files.
-        update_directory_entry(f, (f->file.size) ? 0 : 1);
-        flush_buffer(f);
+  rdcf_get_date_and_time (&f->file.date_and_time);
+  // do not allow empty files.
+  update_directory_entry (f, (f->file.size) ? 0 : 1);
+  flush_buffer (f);
 #endif
-        return f->result = count-unwritten_bytes;
-}
-
-int rdcf_write(struct rdcf *f, const void *buf, int count)
-{// traps write() and ensures no dangling FAT chains.
-int     result;
-        result = real_rdcf_write(f, buf, count);
-                // uhoh, something really bad happened!
-                // flush buffer and close the handle.
-        if (result <= 0) {
-                rdcf_close(f);
-        }
-        return result;
-}
-
-int rdcf_flush_directory(struct rdcf *f)
-{
-        if ((f->result=setjmp(f->error)) != 0) return f->result;
-        rdcf_get_date_and_time(&f->file.date_and_time);
-                // do not allow empty files.
-        update_directory_entry(f, (f->file.size) ? 0 : 1);
-        flush_buffer(f);
-        return 0;
+  return f->result = count - unwritten_bytes;
+}
+
+int rdcf_write (struct rdcf *f, const void *buf, int count)
+{                               // traps write() and ensures no dangling FAT chains.
+  int result;
+  result = real_rdcf_write (f, buf, count);
+  // uhoh, something really bad happened!
+  // flush buffer and close the handle.
+  if (result <= 0) {
+    rdcf_close (f);
+  }
+  return result;
+}
+
+int rdcf_flush_directory (struct rdcf *f)
+{
+  if ((f->result = setjmp (f->error)) != 0)
+    return f->result;
+  rdcf_get_date_and_time (&f->file.date_and_time);
+  // do not allow empty files.
+  update_directory_entry (f, (f->file.size) ? 0 : 1);
+  flush_buffer (f);
+  return 0;
 }
 
 #if 0
-int rdcf_attribute(struct rdcf *f, const char *spec, unsigned attribute)
-{
-        if ((f->result=setjmp(f->error)) != 0) return f->result;
-        if (!find_file(f, initialize_fcb(f, spec)) ||
-                        f->file.attribute & RDCF_DIRECTORY) {
-                error_exit(f, ~ENOENT);
-        }
-        f->file.attribute = (f->file.attribute & ~CHANGEABLE_ATTRIBUTES) |
-                (attribute & CHANGEABLE_ATTRIBUTES);
-        update_directory_entry(f, 0);
-        flush_buffer(f);
-        return 0;
-}
-
-int rdcf_date_and_time(struct rdcf *f, const char *spec,
-        struct rdcf_date_and_time *p)
-{
-        if ((f->result=setjmp(f->error)) != 0) return f->result;
-        spec = initialize_fcb(f, spec);
-        if (*spec == 0) {
-                f->directory_cluster = 0;
-                if (!find_file_in_directory_or_find_volume(f, NULL))
-                        error_exit(f, ~ENOENT);
-                } else {
-                        if (!find_file(f, spec)) error_exit(f, ~ENOENT);
-        }
-        f->file.date_and_time = *p;
-        if ((f->file.attribute & (RDCF_DIRECTORY+RDCF_VOLUME)) == 0) {
-                check_write_access(f);
-                f->file.attribute |= RDCF_ARCHIVE;
-        }
-        update_directory_entry(f, 0);
-        if (f->file.attribute & RDCF_DIRECTORY) update_dot_and_dot_dot(f);
-        flush_buffer(f);
-        return 0;
-}
-
-int rdcf_directory(struct rdcf *f, const char *spec)
-{
-                /* uint8_t name_extension[NAME_SIZE+EXTENSION_SIZE]; ??? */
-        if ((f->result=setjmp(f->error)) != 0) return f->result;
-        if (find_file(f, initialize_fcb(f, spec))) error_exit(f, ~EISDIR);
-                /* spec_to_name_extension(f, name_extension, f->file.spec); ??? */
-                /* name_extension_to_spec(f->file.spec, name_extension); ??? */
-                /* determine whether there is enough free space for directory */
-        {
-                unsigned cluster = 2;
-                unsigned required_clusters =
-                f->directory_index == NO_DIRECTORY_INDEX ? 2 : 1;
-                for (cluster = 2; required_clusters != 0; cluster++) {
-                        if (cluster > f->maximum_cluster_number) error_exit(f, ~ENOSPC);
-                        if (FAT_entry(f, cluster)==EMPTY_CLUSTER) required_clusters--;
-                }
-        }
-        lengthen_directory_if_necessary(f);
-        f->file.attribute = RDCF_DIRECTORY;
-        f->file.first_cluster = add_new_cluster(f, EMPTY_CLUSTER, 2);
-        clear_cluster(f, f->file.first_cluster);
-        f->file.size = 0L;
-        rdcf_get_date_and_time(&f->file.date_and_time);
-        update_directory_entry(f, 0);
-        update_dot_and_dot_dot(f);
-        flush_buffer(f);
-        return 0;
-}
-
-long int rdcf_free_space(struct rdcf *f
+int rdcf_attribute (struct rdcf *f, const char *spec, unsigned attribute)
+{
+  if ((f->result = setjmp (f->error)) != 0)
+    return f->result;
+  if (!find_file (f, initialize_fcb (f, spec)) ||
+      f->file.attribute & RDCF_DIRECTORY) {
+    error_exit (f, ~ENOENT);
+  }
+  f->file.attribute = (f->file.attribute & ~CHANGEABLE_ATTRIBUTES) |
+    (attribute & CHANGEABLE_ATTRIBUTES);
+  update_directory_entry (f, 0);
+  flush_buffer (f);
+  return 0;
+}
+
+int rdcf_date_and_time (struct rdcf *f, const char *spec,
+                        struct rdcf_date_and_time *p)
+{
+  if ((f->result = setjmp (f->error)) != 0)
+    return f->result;
+  spec = initialize_fcb (f, spec);
+  if (*spec == 0) {
+    f->directory_cluster = 0;
+    if (!find_file_in_directory_or_find_volume (f, NULL))
+      error_exit (f, ~ENOENT);
+  }
+  else {
+    if (!find_file (f, spec))
+      error_exit (f, ~ENOENT);
+  }
+  f->file.date_and_time = *p;
+  if ((f->file.attribute & (RDCF_DIRECTORY + RDCF_VOLUME)) == 0) {
+    check_write_access (f);
+    f->file.attribute |= RDCF_ARCHIVE;
+  }
+  update_directory_entry (f, 0);
+  if (f->file.attribute & RDCF_DIRECTORY)
+    update_dot_and_dot_dot (f);
+  flush_buffer (f);
+  return 0;
+}
+
+int rdcf_directory (struct rdcf *f, const char *spec)
+{
+  /* uint8_t name_extension[NAME_SIZE+EXTENSION_SIZE]; ??? */
+  if ((f->result = setjmp (f->error)) != 0)
+    return f->result;
+  if (find_file (f, initialize_fcb (f, spec)))
+    error_exit (f, ~EISDIR);
+  /* spec_to_name_extension(f, name_extension, f->file.spec); ??? */
+  /* name_extension_to_spec(f->file.spec, name_extension); ??? */
+  /* determine whether there is enough free space for directory */
+  {
+    unsigned cluster = 2;
+    unsigned required_clusters =
+      f->directory_index == NO_DIRECTORY_INDEX ? 2 : 1;
+    for (cluster = 2; required_clusters != 0; cluster++) {
+      if (cluster > f->maximum_cluster_number)
+        error_exit (f, ~ENOSPC);
+      if (FAT_entry (f, cluster) == EMPTY_CLUSTER)
+        required_clusters--;
+    }
+  }
+  lengthen_directory_if_necessary (f);
+  f->file.attribute = RDCF_DIRECTORY;
+  f->file.first_cluster = add_new_cluster (f, EMPTY_CLUSTER, 2);
+  clear_cluster (f, f->file.first_cluster);
+  f->file.size = 0L;
+  rdcf_get_date_and_time (&f->file.date_and_time);
+  update_directory_entry (f, 0);
+  update_dot_and_dot_dot (f);
+  flush_buffer (f);
+  return 0;
+}
+
+long int rdcf_free_space (struct rdcf *f
 #ifdef RDCF_MULTIPLE_DRIVE
-        , char *spec
+                          , char *spec
 #endif
-)
-{
-        unsigned cluster;
-        unsigned number_of_empty_clusters = 0;
-        if ((f->result=setjmp(f->error)) != 0) return (long)(f->result);
+  )
+{
+  unsigned cluster;
+  unsigned number_of_empty_clusters = 0;
+  if ((f->result = setjmp (f->error)) != 0)
+    return (long) (f->result);
 #ifndef RDCF_MULTIPLE_DRIVE
-        initialize_fcb(f, NULL);
+  initialize_fcb (f, NULL);
 #else
-        if (*initialize_fcb(f, spec) != 0) error_exit(f, ~EINVAL);
+  if (*initialize_fcb (f, spec) != 0)
+    error_exit (f, ~EINVAL);
 #endif
-        for (cluster = 2; cluster <= f->maximum_cluster_number; cluster++) {
-                if (FAT_entry(f, cluster) == EMPTY_CLUSTER) number_of_empty_clusters++;
-        }
-        f->file.size = (uint32_t) number_of_empty_clusters *
-        (f->sectors_per_cluster * SECTOR_SIZE);
-        return (long)(f->file.size);
-}
-
-int rdcf_get_file_information(struct rdcf *f, const char *spec, unsigned idx)
-{
-        if ((f->result=setjmp(f->error)) != 0) return f->result;
-        find_entry(f, spec, idx);
-        read_directory_entry(f);
-        return f->result = f->file.spec[0] == DELETED_FILE ? ENOENT :
-                f->file.spec[0] == 0 ? ENOSPC : 0;
-}
-
-int rdcf_next_file_information(struct rdcf *f)
-{
-        if ((f->result=setjmp(f->error)) != 0) return f->result;
-        f->directory_index++;
-        if (f->directory_cluster == 0) {
-                if (f->directory_index >=
-                                (f->first_data_sector - f->first_directory_sector)*ENTRIES_PER_SECTOR) {
-                        error_exit(f, ~ENOSPC);
-                }
-        } else {
-                if (f->directory_index >= ENTRIES_PER_SECTOR*f->sectors_per_cluster) {
-                        f->directory_cluster = FAT_entry(f, f->directory_cluster);
-                        if (f->directory_cluster >= f->last_cluster_mark)
-                        error_exit(f, ~ENOSPC);
-                        f->directory_index = 0;
-                }
-        }
-        read_directory_entry(f);
-        return f->result = f->file.spec[0] == DELETED_FILE ? ENOENT :
-                f->file.spec[0] == 0 ? ENOSPC : 0;
+  for (cluster = 2; cluster <= f->maximum_cluster_number; cluster++) {
+    if (FAT_entry (f, cluster) == EMPTY_CLUSTER)
+      number_of_empty_clusters++;
+  }
+  f->file.size = (uint32_t) number_of_empty_clusters *
+    (f->sectors_per_cluster * SECTOR_SIZE);
+  return (long) (f->file.size);
+}
+
+int rdcf_get_file_information (struct rdcf *f, const char *spec, unsigned idx)
+{
+  if ((f->result = setjmp (f->error)) != 0)
+    return f->result;
+  find_entry (f, spec, idx);
+  read_directory_entry (f);
+  return f->result = f->file.spec[0] == DELETED_FILE ? ENOENT :
+    f->file.spec[0] == 0 ? ENOSPC : 0;
+}
+
+int rdcf_next_file_information (struct rdcf *f)
+{
+  if ((f->result = setjmp (f->error)) != 0)
+    return f->result;
+  f->directory_index++;
+  if (f->directory_cluster == 0) {
+    if (f->directory_index >=
+        (f->first_data_sector -
+         f->first_directory_sector) * ENTRIES_PER_SECTOR) {
+      error_exit (f, ~ENOSPC);
+    }
+  }
+  else {
+    if (f->directory_index >= ENTRIES_PER_SECTOR * f->sectors_per_cluster) {
+      f->directory_cluster = FAT_entry (f, f->directory_cluster);
+      if (f->directory_cluster >= f->last_cluster_mark)
+        error_exit (f, ~ENOSPC);
+      f->directory_index = 0;
+    }
+  }
+  read_directory_entry (f);
+  return f->result = f->file.spec[0] == DELETED_FILE ? ENOENT :
+    f->file.spec[0] == 0 ? ENOSPC : 0;
 }
 
@@ -1045 +1136 @@
 -----------------------------------------------------------------------------*/
 
-static void update_dot_and_dot_dot(struct rdcf *f)
-{
-        f->directory_cluster = f->file.first_cluster;
-        f->directory_index = 0;
-        memset(f->file.spec, ' ', NAME_SIZE+EXTENSION_SIZE);
-        f->file.spec[0] = '.';
-        update_directory_entry(f, 0);
-        f->file.first_cluster = f->directory_first_cluster;
-        f->directory_index = 1;
-        f->file.spec[1] = '.';
-        update_directory_entry(f, 0);
+static void update_dot_and_dot_dot (struct rdcf *f)
+{
+  f->directory_cluster = f->file.first_cluster;
+  f->directory_index = 0;
+  memset (f->file.spec, ' ', NAME_SIZE + EXTENSION_SIZE);
+  f->file.spec[0] = '.';
+  update_directory_entry (f, 0);
+  f->file.first_cluster = f->directory_first_cluster;
+  f->directory_index = 1;
+  f->file.spec[1] = '.';
+  update_directory_entry (f, 0);
 }
 
@@ -1065 +1156 @@
 -----------------------------------------------------------------------------*/
 
-static void find_entry(struct rdcf *f, const char *spec, unsigned idx)
-{
-        spec = initialize_fcb(f, spec);
-        if (*spec == 0) {
-                if (idx >=
-                                (f->first_data_sector - f->first_directory_sector)*ENTRIES_PER_SECTOR) {
-                        error_exit(f, ~ENOSPC);
-                }
-                f->directory_first_cluster = f->directory_cluster = 0;
-        } else {
-                if (!find_file(f, spec) || (f->file.attribute&RDCF_DIRECTORY) == 0)
-                        error_exit(f, ~ENOENT);
-                f->directory_first_cluster = f->directory_cluster = f->file.first_cluster;
-                while (idx >= ENTRIES_PER_SECTOR*f->sectors_per_cluster) {
-                        f->directory_cluster = FAT_entry(f, f->directory_cluster);
-                        if (f->directory_cluster >= f->last_cluster_mark)
-                                error_exit(f, ~ENOSPC);
-                        idx -= ENTRIES_PER_SECTOR*f->sectors_per_cluster;
-                }
-        }
-        f->directory_index = idx;
+static void find_entry (struct rdcf *f, const char *spec, unsigned idx)
+{
+  spec = initialize_fcb (f, spec);
+  if (*spec == 0) {
+    if (idx >=
+        (f->first_data_sector -
+         f->first_directory_sector) * ENTRIES_PER_SECTOR) {
+      error_exit (f, ~ENOSPC);
+    }
+    f->directory_first_cluster = f->directory_cluster = 0;
+  }
+  else {
+    if (!find_file (f, spec) || (f->file.attribute & RDCF_DIRECTORY) == 0)
+      error_exit (f, ~ENOENT);
+    f->directory_first_cluster = f->directory_cluster = f->file.first_cluster;
+    while (idx >= ENTRIES_PER_SECTOR * f->sectors_per_cluster) {
+      f->directory_cluster = FAT_entry (f, f->directory_cluster);
+      if (f->directory_cluster >= f->last_cluster_mark)
+        error_exit (f, ~ENOSPC);
+      idx -= ENTRIES_PER_SECTOR * f->sectors_per_cluster;
+    }
+  }
+  f->directory_index = idx;
 }
 
@@ -1091 +1184 @@
 
 // vi:nowrap:
-

trunk/hal/lpc2106-cmucam3/rdcf2.h

@@ -47 +47 @@
 //#define RDCF_FLUSH_DIR_AFTER_WRITE
 //#define _BIG_ENDIAN
-//#define RDCF_SLASH_CHAR                       '\\'
+//#define RDCF_SLASH_CHAR                       '\\'
 #define RDCF_SLASH_CHAR                 '/'
 
@@ -54 +54 @@
  ******************************************************/
 
-struct rdcf_date_and_time
-{
+struct rdcf_date_and_time {
   uint8_t second;
   uint8_t minute;
@@ -64 +63 @@
 };
 
-struct rdcf_file_information
-{
+struct rdcf_file_information {
   uint8_t spec[13];
   uint8_t attribute;
@@ -83 +81 @@
 #define NAME_SIZE       8
 #define EXTENSION_SIZE  3
-struct directory
-{
-  uint8_t name_extension[NAME_SIZE+EXTENSION_SIZE];
+struct directory {
+  uint8_t name_extension[NAME_SIZE + EXTENSION_SIZE];
   uint8_t attribute;
   uint8_t reserved[10];
@@ -95 +92 @@
 
 union IO_BUFFER {
-  struct directory dir[RDCF_SECTOR_SIZE / sizeof(struct directory)];
-  uint16_t fat[RDCF_SECTOR_SIZE/2];
+  struct directory dir[RDCF_SECTOR_SIZE / sizeof (struct directory)];
+  uint16_t fat[RDCF_SECTOR_SIZE / 2];
   uint8_t buf[RDCF_SECTOR_SIZE];
 };
@@ -102 +99 @@
 /* FCB (File Control Block) */
 
-struct rdcf
-{
+struct rdcf {
   /* values that must be initialized by the calling program */
-  union  IO_BUFFER buffer;
+  union IO_BUFFER buffer;
   // hardware access.
-  bool (*ReadSector)(uint32_t sector, uint8_t * buf);
-  bool (*WriteSector)(uint32_t sector, const uint8_t * buf);
+    bool (*ReadSector) (uint32_t sector, uint8_t * buf);
+    bool (*WriteSector) (uint32_t sector, const uint8_t * buf);
   /* file information */
   struct rdcf_file_information file;
@@ -179 +175 @@
 /* prototypes for functions defined in RDCF */
 
-int rdcf_open(struct rdcf *, const char *, unsigned);
-int rdcf_close(struct rdcf *);
-int rdcf_write(struct rdcf *, const void *, int);
-int rdcf_read(struct rdcf *, void *, int);
-int rdcf_seek(struct rdcf *, uint32_t);
-int rdcf_flush_directory(struct rdcf *);
-int rdcf_delete(struct rdcf *, const char *);
-int rdcf_rename(struct rdcf *, const char *, const char *);
+int rdcf_open (struct rdcf *, const char *, unsigned);
+int rdcf_close (struct rdcf *);
+int rdcf_write (struct rdcf *, const void *, int);
+int rdcf_read (struct rdcf *, void *, int);
+int rdcf_seek (struct rdcf *, uint32_t);
+int rdcf_flush_directory (struct rdcf *);
+int rdcf_delete (struct rdcf *, const char *);
+int rdcf_rename (struct rdcf *, const char *, const char *);
 
 #if 0
-int rdcf_directory(struct rdcf *, const char *);
-int rdcf_get_file_information(struct rdcf *, const char *, unsigned);
-int rdcf_next_file_information(struct rdcf *);
-int rdcf_date_and_time(struct rdcf *, const char *, struct rdcf_date_and_time *);
-int rdcf_attribute(struct rdcf *, const char *, unsigned);
-int rdcf_get_volume(struct rdcf *);
-long rdcf_free_space(struct rdcf *);
+int rdcf_directory (struct rdcf *, const char *);
+int rdcf_get_file_information (struct rdcf *, const char *, unsigned);
+int rdcf_next_file_information (struct rdcf *);
+int rdcf_date_and_time (struct rdcf *, const char *,
+                        struct rdcf_date_and_time *);
+int rdcf_attribute (struct rdcf *, const char *, unsigned);
+int rdcf_get_volume (struct rdcf *);
+long rdcf_free_space (struct rdcf *);
 #endif