Patch goto labels for consistency

Marlin/Sd2Card.cpp

@@ -244,7 +244,7 @@ void Sd2Card::chipSelectLow() {
  */
 bool Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock) {
   csd_t csd;
-  if (!readCSD(&csd)) goto fail;
+  if (!readCSD(&csd)) goto FAIL;
   // check for single block erase
   if (!csd.v1.erase_blk_en) {
     // erase size mask
@@ -252,7 +252,7 @@ bool Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock) {
     if ((firstBlock & m) != 0 || ((lastBlock + 1) & m) != 0) {
       // error card can't erase specified area
       error(SD_CARD_ERROR_ERASE_SINGLE_BLOCK);
-      goto fail;
+      goto FAIL;
     }
   }
   if (type_ != SD_CARD_TYPE_SDHC) {
@@ -263,15 +263,15 @@ bool Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock) {
       || cardCommand(CMD33, lastBlock)
       || cardCommand(CMD38, 0)) {
     error(SD_CARD_ERROR_ERASE);
-    goto fail;
+    goto FAIL;
   }
   if (!waitNotBusy(SD_ERASE_TIMEOUT)) {
     error(SD_CARD_ERROR_ERASE_TIMEOUT);
-    goto fail;
+    goto FAIL;
   }
   chipSelectHigh();
   return true;
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
@@ -335,7 +335,7 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
   while ((status_ = cardCommand(CMD0, 0)) != R1_IDLE_STATE) {
     if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
       error(SD_CARD_ERROR_CMD0);
-      goto fail;
+      goto FAIL;
     }
   }
   // check SD version
@@ -347,7 +347,7 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
     for (uint8_t i = 0; i < 4; i++) status_ = spiRec();
     if (status_ != 0xAA) {
       error(SD_CARD_ERROR_CMD8);
-      goto fail;
+      goto FAIL;
     }
     type(SD_CARD_TYPE_SD2);
   }
@@ -358,14 +358,14 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
     // check for timeout
     if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
       error(SD_CARD_ERROR_ACMD41);
-      goto fail;
+      goto FAIL;
     }
   }
   // if SD2 read OCR register to check for SDHC card
   if (type() == SD_CARD_TYPE_SD2) {
     if (cardCommand(CMD58, 0)) {
       error(SD_CARD_ERROR_CMD58);
-      goto fail;
+      goto FAIL;
     }
     if ((spiRec() & 0xC0) == 0xC0) type(SD_CARD_TYPE_SDHC);
     // discard rest of ocr - contains allowed voltage range
@@ -380,7 +380,7 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
     return true;
   #endif  // SOFTWARE_SPI
 
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
@@ -486,12 +486,12 @@ bool Sd2Card::readData(uint8_t* dst, uint16_t count) {
   while ((status_ = spiRec()) == 0XFF) {
     if (((uint16_t)millis() - t0) > SD_READ_TIMEOUT) {
       error(SD_CARD_ERROR_READ_TIMEOUT);
-      goto fail;
+      goto FAIL;
     }
   }
   if (status_ != DATA_START_BLOCK) {
     error(SD_CARD_ERROR_READ);
-    goto fail;
+    goto FAIL;
   }
   // transfer data
   spiRead(dst, count);
@@ -503,7 +503,7 @@ bool Sd2Card::readData(uint8_t* dst, uint16_t count) {
     recvCrc |= spiRec();
     if (calcCrc != recvCrc) {
       error(SD_CARD_ERROR_CRC);
-      goto fail;
+      goto FAIL;
     }
   }
 #else
@@ -515,7 +515,7 @@ bool Sd2Card::readData(uint8_t* dst, uint16_t count) {
   // Send an additional dummy byte, required by Toshiba Flash Air SD Card
   spiSend(0XFF);
   return true;
-fail:
+  FAIL:
   chipSelectHigh();
   // Send an additional dummy byte, required by Toshiba Flash Air SD Card
   spiSend(0XFF);
@@ -527,10 +527,10 @@ bool Sd2Card::readRegister(uint8_t cmd, void* buf) {
   uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
   if (cardCommand(cmd, 0)) {
     error(SD_CARD_ERROR_READ_REG);
-    goto fail;
+    goto FAIL;
   }
   return readData(dst, 16);
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
@@ -549,11 +549,11 @@ bool Sd2Card::readStart(uint32_t blockNumber) {
   if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;
   if (cardCommand(CMD18, blockNumber)) {
     error(SD_CARD_ERROR_CMD18);
-    goto fail;
+    goto FAIL;
   }
   chipSelectHigh();
   return true;
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
@@ -567,11 +567,11 @@ bool Sd2Card::readStop() {
   chipSelectLow();
   if (cardCommand(CMD12, 0)) {
     error(SD_CARD_ERROR_CMD12);
-    goto fail;
+    goto FAIL;
   }
   chipSelectHigh();
   return true;
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
@@ -601,10 +601,10 @@ bool Sd2Card::setSckRate(uint8_t sckRateID) {
 bool Sd2Card::waitNotBusy(uint16_t timeoutMillis) {
   uint16_t t0 = millis();
   while (spiRec() != 0XFF) {
-    if (((uint16_t)millis() - t0) >= timeoutMillis) goto fail;
+    if (((uint16_t)millis() - t0) >= timeoutMillis) goto FAIL;
   }
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -621,23 +621,23 @@ bool Sd2Card::writeBlock(uint32_t blockNumber, const uint8_t* src) {
   if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;
   if (cardCommand(CMD24, blockNumber)) {
     error(SD_CARD_ERROR_CMD24);
-    goto fail;
+    goto FAIL;
   }
-  if (!writeData(DATA_START_BLOCK, src)) goto fail;
+  if (!writeData(DATA_START_BLOCK, src)) goto FAIL;
 
   // wait for flash programming to complete
   if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
     error(SD_CARD_ERROR_WRITE_TIMEOUT);
-    goto fail;
+    goto FAIL;
   }
   // response is r2 so get and check two bytes for nonzero
   if (cardCommand(CMD13, 0) || spiRec()) {
     error(SD_CARD_ERROR_WRITE_PROGRAMMING);
-    goto fail;
+    goto FAIL;
   }
   chipSelectHigh();
   return true;
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
@@ -650,11 +650,11 @@ fail:
 bool Sd2Card::writeData(const uint8_t* src) {
   chipSelectLow();
   // wait for previous write to finish
-  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;
-  if (!writeData(WRITE_MULTIPLE_TOKEN, src)) goto fail;
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto FAIL;
+  if (!writeData(WRITE_MULTIPLE_TOKEN, src)) goto FAIL;
   chipSelectHigh();
   return true;
-fail:
+  FAIL:
   error(SD_CARD_ERROR_WRITE_MULTIPLE);
   chipSelectHigh();
   return false;
@@ -670,10 +670,10 @@ bool Sd2Card::writeData(uint8_t token, const uint8_t* src) {
   status_ = spiRec();
   if ((status_ & DATA_RES_MASK) != DATA_RES_ACCEPTED) {
     error(SD_CARD_ERROR_WRITE);
-    goto fail;
+    goto FAIL;
   }
   return true;
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
@@ -693,17 +693,17 @@ bool Sd2Card::writeStart(uint32_t blockNumber, uint32_t eraseCount) {
   // send pre-erase count
   if (cardAcmd(ACMD23, eraseCount)) {
     error(SD_CARD_ERROR_ACMD23);
-    goto fail;
+    goto FAIL;
   }
   // use address if not SDHC card
   if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;
   if (cardCommand(CMD25, blockNumber)) {
     error(SD_CARD_ERROR_CMD25);
-    goto fail;
+    goto FAIL;
   }
   chipSelectHigh();
   return true;
-fail:
+  FAIL:
   chipSelectHigh();
   return false;
 }
@@ -715,12 +715,12 @@ fail:
  */
 bool Sd2Card::writeStop() {
   chipSelectLow();
-  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto FAIL;
   spiSend(STOP_TRAN_TOKEN);
-  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto FAIL;
   chipSelectHigh();
   return true;
-fail:
+  FAIL:
   error(SD_CARD_ERROR_STOP_TRAN);
   chipSelectHigh();
   return false;

Marlin/SdBaseFile.cpp

@@ -39,7 +39,7 @@ void (*SdBaseFile::dateTime_)(uint16_t* date, uint16_t* time) = 0;
 //------------------------------------------------------------------------------
 // add a cluster to a file
 bool SdBaseFile::addCluster() {
-  if (!vol_->allocContiguous(1, &curCluster_)) goto fail;
+  if (!vol_->allocContiguous(1, &curCluster_)) goto FAIL;
 
   // if first cluster of file link to directory entry
   if (firstCluster_ == 0) {
@@ -48,7 +48,7 @@ bool SdBaseFile::addCluster() {
   }
   return true;
 
- fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -57,10 +57,10 @@ bool SdBaseFile::addCluster() {
 bool SdBaseFile::addDirCluster() {
   uint32_t block;
   // max folder size
-  if (fileSize_ / sizeof(dir_t) >= 0xFFFF) goto fail;
+  if (fileSize_ / sizeof(dir_t) >= 0xFFFF) goto FAIL;
 
-  if (!addCluster()) goto fail;
-  if (!vol_->cacheFlush()) goto fail;
+  if (!addCluster()) goto FAIL;
+  if (!vol_->cacheFlush()) goto FAIL;
 
   block = vol_->clusterStartBlock(curCluster_);
 
@@ -72,21 +72,21 @@ bool SdBaseFile::addDirCluster() {
 
   // zero rest of cluster
   for (uint8_t i = 1; i < vol_->blocksPerCluster_; i++) {
-    if (!vol_->writeBlock(block + i, vol_->cacheBuffer_.data)) goto fail;
+    if (!vol_->writeBlock(block + i, vol_->cacheBuffer_.data)) goto FAIL;
   }
   // Increase directory file size by cluster size
   fileSize_ += 512UL << vol_->clusterSizeShift_;
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
 // cache a file's directory entry
 // return pointer to cached entry or null for failure
 dir_t* SdBaseFile::cacheDirEntry(uint8_t action) {
-  if (!vol_->cacheRawBlock(dirBlock_, action)) goto fail;
+  if (!vol_->cacheRawBlock(dirBlock_, action)) goto FAIL;
   return vol_->cache()->dir + dirIndex_;
-fail:
+  FAIL:
   return 0;
 }
 //------------------------------------------------------------------------------
@@ -115,16 +115,16 @@ bool SdBaseFile::close() {
  */
 bool SdBaseFile::contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock) {
   // error if no blocks
-  if (firstCluster_ == 0) goto fail;
+  if (firstCluster_ == 0) goto FAIL;
 
   for (uint32_t c = firstCluster_; ; c++) {
     uint32_t next;
-    if (!vol_->fatGet(c, &next)) goto fail;
+    if (!vol_->fatGet(c, &next)) goto FAIL;
 
     // check for contiguous
     if (next != (c + 1)) {
       // error if not end of chain
-      if (!vol_->isEOC(next)) goto fail;
+      if (!vol_->isEOC(next)) goto FAIL;
       *bgnBlock = vol_->clusterStartBlock(firstCluster_);
       *endBlock = vol_->clusterStartBlock(c)
                   + vol_->blocksPerCluster_ - 1;
@@ -132,7 +132,7 @@ bool SdBaseFile::contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock) {
     }
   }
 
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -157,8 +157,8 @@ bool SdBaseFile::createContiguous(SdBaseFile* dirFile,
                                   const char* path, uint32_t size) {
   uint32_t count;
   // don't allow zero length file
-  if (size == 0) goto fail;
-  if (!open(dirFile, path, O_CREAT | O_EXCL | O_RDWR)) goto fail;
+  if (size == 0) goto FAIL;
+  if (!open(dirFile, path, O_CREAT | O_EXCL | O_RDWR)) goto FAIL;
 
   // calculate number of clusters needed
   count = ((size - 1) >> (vol_->clusterSizeShift_ + 9)) + 1;
@@ -166,7 +166,7 @@ bool SdBaseFile::createContiguous(SdBaseFile* dirFile,
   // allocate clusters
   if (!vol_->allocContiguous(count, &firstCluster_)) {
     remove();
-    goto fail;
+    goto FAIL;
   }
   fileSize_ = size;
 
@@ -174,7 +174,7 @@ bool SdBaseFile::createContiguous(SdBaseFile* dirFile,
   flags_ |= F_FILE_DIR_DIRTY;
 
   return sync();
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -188,16 +188,16 @@ fail:
 bool SdBaseFile::dirEntry(dir_t* dir) {
   dir_t* p;
   // make sure fields on SD are correct
-  if (!sync()) goto fail;
+  if (!sync()) goto FAIL;
 
   // read entry
   p = cacheDirEntry(SdVolume::CACHE_FOR_READ);
-  if (!p) goto fail;
+  if (!p) goto FAIL;
 
   // copy to caller's struct
   memcpy(dir, p, sizeof(dir_t));
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -395,7 +395,7 @@ bool SdBaseFile::make83Name(const char* str, uint8_t* name, const char** ptr) {
   while (*str != '\0' && *str != '/') {
     c = *str++;
     if (c == '.') {
-      if (n == 10) goto fail;  // only one dot allowed
+      if (n == 10) goto FAIL;  // only one dot allowed
       n = 10;  // max index for full 8.3 name
       i = 8;   // place for extension
     }
@@ -403,9 +403,9 @@ bool SdBaseFile::make83Name(const char* str, uint8_t* name, const char** ptr) {
       // illegal FAT characters
       PGM_P p = PSTR("|<>^+=?/[];,*\"\\");
       uint8_t b;
-      while ((b = pgm_read_byte(p++))) if (b == c) goto fail;
+      while ((b = pgm_read_byte(p++))) if (b == c) goto FAIL;
       // check size and only allow ASCII printable characters
-      if (i > n || c < 0x21 || c == 0x7F) goto fail;
+      if (i > n || c < 0x21 || c == 0x7F) goto FAIL;
       // only upper case allowed in 8.3 names - convert lower to upper
       name[i++] = (c < 'a' || c > 'z') ? (c) : (c + ('A' - 'a'));
     }
@@ -413,7 +413,7 @@ bool SdBaseFile::make83Name(const char* str, uint8_t* name, const char** ptr) {
   *ptr = str;
   // must have a file name, extension is optional
   return name[0] != ' ';
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -437,22 +437,22 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const char* path, bool pFlag) {
   SdBaseFile* sub = &dir1;
   SdBaseFile* start = parent;
 
-  if (!parent || isOpen()) goto fail;
+  if (!parent || isOpen()) goto FAIL;
 
   if (*path == '/') {
     while (*path == '/') path++;
     if (!parent->isRoot()) {
-      if (!dir2.openRoot(parent->vol_)) goto fail;
+      if (!dir2.openRoot(parent->vol_)) goto FAIL;
       parent = &dir2;
     }
   }
   while (1) {
-    if (!make83Name(path, dname, &path)) goto fail;
+    if (!make83Name(path, dname, &path)) goto FAIL;
     while (*path == '/') path++;
     if (!*path) break;
     if (!sub->open(parent, dname, O_READ)) {
       if (!pFlag || !sub->mkdir(parent, dname)) {
-        goto fail;
+        goto FAIL;
       }
     }
     if (parent != start) parent->close();
@@ -460,7 +460,7 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const char* path, bool pFlag) {
     sub = parent != &dir1 ? &dir1 : &dir2;
   }
   return mkdir(parent, dname);
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -469,24 +469,24 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t dname[11]) {
   dir_t d;
   dir_t* p;
 
-  if (!parent->isDir()) goto fail;
+  if (!parent->isDir()) goto FAIL;
 
   // create a normal file
-  if (!open(parent, dname, O_CREAT | O_EXCL | O_RDWR)) goto fail;
+  if (!open(parent, dname, O_CREAT | O_EXCL | O_RDWR)) goto FAIL;
 
   // convert file to directory
   flags_ = O_READ;
   type_ = FAT_FILE_TYPE_SUBDIR;
 
   // allocate and zero first cluster
-  if (!addDirCluster())goto fail;
+  if (!addDirCluster())goto FAIL;
 
   // force entry to SD
-  if (!sync()) goto fail;
+  if (!sync()) goto FAIL;
 
   // cache entry - should already be in cache due to sync() call
   p = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
-  if (!p) goto fail;
+  if (!p) goto FAIL;
 
   // change directory entry  attribute
   p->attributes = DIR_ATT_DIRECTORY;
@@ -498,7 +498,7 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t dname[11]) {
 
   // cache block for '.'  and '..'
   block = vol_->clusterStartBlock(firstCluster_);
-  if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) goto fail;
+  if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) goto FAIL;
 
   // copy '.' to block
   memcpy(&vol_->cache()->dir[0], &d, sizeof(d));
@@ -518,7 +518,7 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t dname[11]) {
 
   // write first block
   return vol_->cacheFlush();
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -592,29 +592,29 @@ bool SdBaseFile::open(SdBaseFile* dirFile, const char* path, uint8_t oflag) {
   SdBaseFile* parent = dirFile;
   SdBaseFile* sub = &dir1;
 
-  if (!dirFile) goto fail;
+  if (!dirFile) goto FAIL;
 
   // error if already open
-  if (isOpen()) goto fail;
+  if (isOpen()) goto FAIL;
 
   if (*path == '/') {
     while (*path == '/') path++;
     if (!dirFile->isRoot()) {
-      if (!dir2.openRoot(dirFile->vol_)) goto fail;
+      if (!dir2.openRoot(dirFile->vol_)) goto FAIL;
       parent = &dir2;
     }
   }
   while (1) {
-    if (!make83Name(path, dname, &path)) goto fail;
+    if (!make83Name(path, dname, &path)) goto FAIL;
     while (*path == '/') path++;
     if (!*path) break;
-    if (!sub->open(parent, dname, O_READ)) goto fail;
+    if (!sub->open(parent, dname, O_READ)) goto FAIL;
     if (parent != dirFile) parent->close();
     parent = sub;
     sub = parent != &dir1 ? &dir1 : &dir2;
   }
   return open(parent, dname, oflag);
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -634,7 +634,7 @@ bool SdBaseFile::open(SdBaseFile* dirFile,
   while (dirFile->curPosition_ < dirFile->fileSize_) {
     index = 0XF & (dirFile->curPosition_ >> 5);
     p = dirFile->readDirCache();
-    if (!p) goto fail;
+    if (!p) goto FAIL;
 
     if (p->name[0] == DIR_NAME_FREE || p->name[0] == DIR_NAME_DELETED) {
       // remember first empty slot
@@ -653,21 +653,21 @@ bool SdBaseFile::open(SdBaseFile* dirFile,
   }
   if (fileFound) {
     // don't open existing file if O_EXCL
-    if (oflag & O_EXCL) goto fail;
+    if (oflag & O_EXCL) goto FAIL;
   }
   else {
     // don't create unless O_CREAT and O_WRITE
-    if (!(oflag & O_CREAT) || !(oflag & O_WRITE)) goto fail;
+    if (!(oflag & O_CREAT) || !(oflag & O_WRITE)) goto FAIL;
     if (emptyFound) {
       index = dirIndex_;
       p = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
-      if (!p) goto fail;
+      if (!p) goto FAIL;
     }
     else {
-      if (dirFile->type_ == FAT_FILE_TYPE_ROOT_FIXED) goto fail;
+      if (dirFile->type_ == FAT_FILE_TYPE_ROOT_FIXED) goto FAIL;
 
       // add and zero cluster for dirFile - first cluster is in cache for write
-      if (!dirFile->addDirCluster()) goto fail;
+      if (!dirFile->addDirCluster()) goto FAIL;
 
       // use first entry in cluster
       p = dirFile->vol_->cache()->dir;
@@ -692,11 +692,11 @@ bool SdBaseFile::open(SdBaseFile* dirFile,
     p->lastWriteTime = p->creationTime;
 
     // write entry to SD
-    if (!dirFile->vol_->cacheFlush()) goto fail;
+    if (!dirFile->vol_->cacheFlush()) goto FAIL;
   }
   // open entry in cache
   return openCachedEntry(index, oflag);
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -719,26 +719,26 @@ bool SdBaseFile::open(SdBaseFile* dirFile, uint16_t index, uint8_t oflag) {
   vol_ = dirFile->vol_;
 
   // error if already open
-  if (isOpen() || !dirFile) goto fail;
+  if (isOpen() || !dirFile) goto FAIL;
 
   // don't open existing file if O_EXCL - user call error
-  if (oflag & O_EXCL) goto fail;
+  if (oflag & O_EXCL) goto FAIL;
 
   // seek to location of entry
-  if (!dirFile->seekSet(32 * index)) goto fail;
+  if (!dirFile->seekSet(32 * index)) goto FAIL;
 
   // read entry into cache
   p = dirFile->readDirCache();
-  if (!p) goto fail;
+  if (!p) goto FAIL;
 
   // error if empty slot or '.' or '..'
   if (p->name[0] == DIR_NAME_FREE ||
       p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
-    goto fail;
+    goto FAIL;
   }
   // open cached entry
   return openCachedEntry(index & 0XF, oflag);
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -749,7 +749,7 @@ bool SdBaseFile::openCachedEntry(uint8_t dirIndex, uint8_t oflag) {
 
   // write or truncate is an error for a directory or read-only file
   if (p->attributes & (DIR_ATT_READ_ONLY | DIR_ATT_DIRECTORY)) {
-    if (oflag & (O_WRITE | O_TRUNC)) goto fail;
+    if (oflag & (O_WRITE | O_TRUNC)) goto FAIL;
   }
   // remember location of directory entry on SD
   dirBlock_ = vol_->cacheBlockNumber();
@@ -765,11 +765,11 @@ bool SdBaseFile::openCachedEntry(uint8_t dirIndex, uint8_t oflag) {
     type_ = FAT_FILE_TYPE_NORMAL;
   }
   else if (DIR_IS_SUBDIR(p)) {
-    if (!vol_->chainSize(firstCluster_, &fileSize_)) goto fail;
+    if (!vol_->chainSize(firstCluster_, &fileSize_)) goto FAIL;
     type_ = FAT_FILE_TYPE_SUBDIR;
   }
   else {
-    goto fail;
+    goto FAIL;
   }
   // save open flags for read/write
   flags_ = oflag & F_OFLAG;
@@ -779,7 +779,7 @@ bool SdBaseFile::openCachedEntry(uint8_t dirIndex, uint8_t oflag) {
   curPosition_ = 0;
   if ((oflag & O_TRUNC) && !truncate(0)) return false;
   return oflag & O_AT_END ? seekEnd(0) : true;
-fail:
+  FAIL:
   type_ = FAT_FILE_TYPE_CLOSED;
   return false;
 }
@@ -799,10 +799,10 @@ bool SdBaseFile::openNext(SdBaseFile* dirFile, uint8_t oflag) {
   dir_t* p;
   uint8_t index;
 
-  if (!dirFile) goto fail;
+  if (!dirFile) goto FAIL;
 
   // error if already open
-  if (isOpen()) goto fail;
+  if (isOpen()) goto FAIL;
 
   vol_ = dirFile->vol_;
 
@@ -811,10 +811,10 @@ bool SdBaseFile::openNext(SdBaseFile* dirFile, uint8_t oflag) {
 
     // read entry into cache
     p = dirFile->readDirCache();
-    if (!p) goto fail;
+    if (!p) goto FAIL;
 
     // done if last entry
-    if (p->name[0] == DIR_NAME_FREE) goto fail;
+    if (p->name[0] == DIR_NAME_FREE) goto FAIL;
 
     // skip empty slot or '.' or '..'
     if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
@@ -825,7 +825,7 @@ bool SdBaseFile::openNext(SdBaseFile* dirFile, uint8_t oflag) {
       return openCachedEntry(index, oflag);
     }
   }
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -844,14 +844,14 @@ bool SdBaseFile::openParent(SdBaseFile* dir) {
   uint32_t cluster;
   uint32_t lbn;
   // error if already open or dir is root or dir is not a directory
-  if (isOpen() || !dir || dir->isRoot() || !dir->isDir()) goto fail;
+  if (isOpen() || !dir || dir->isRoot() || !dir->isDir()) goto FAIL;
   vol_ = dir->vol_;
   // position to '..'
-  if (!dir->seekSet(32)) goto fail;
+  if (!dir->seekSet(32)) goto FAIL;
   // read '..' entry
-  if (dir->read(&entry, sizeof(entry)) != 32) goto fail;
+  if (dir->read(&entry, sizeof(entry)) != 32) goto FAIL;
   // verify it is '..'
-  if (entry.name[0] != '.' || entry.name[1] != '.') goto fail;
+  if (entry.name[0] != '.' || entry.name[1] != '.') goto FAIL;
   // start cluster for '..'
   cluster = entry.firstClusterLow;
   cluster |= (uint32_t)entry.firstClusterHigh << 16;
@@ -860,27 +860,27 @@ bool SdBaseFile::openParent(SdBaseFile* dir) {
   lbn = vol_->clusterStartBlock(cluster);
   // first block of parent dir
   if (!vol_->cacheRawBlock(lbn, SdVolume::CACHE_FOR_READ)) {
-    goto fail;
+    goto FAIL;
   }
   p = &vol_->cacheBuffer_.dir[1];
   // verify name for '../..'
-  if (p->name[0] != '.' || p->name[1] != '.') goto fail;
+  if (p->name[0] != '.' || p->name[1] != '.') goto FAIL;
   // '..' is pointer to first cluster of parent. open '../..' to find parent
   if (p->firstClusterHigh == 0 && p->firstClusterLow == 0) {
-    if (!file.openRoot(dir->volume())) goto fail;
+    if (!file.openRoot(dir->volume())) goto FAIL;
   }
   else if (!file.openCachedEntry(1, O_READ)) {
-    goto fail;
+    goto FAIL;
   }
   // search for parent in '../..'
   do {
-    if (file.readDir(&entry, NULL) != 32) goto fail;
+    if (file.readDir(&entry, NULL) != 32) goto FAIL;
     c = entry.firstClusterLow;
     c |= (uint32_t)entry.firstClusterHigh << 16;
   } while (c != cluster);
   // open parent
   return open(&file, file.curPosition() / 32 - 1, O_READ);
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -895,7 +895,7 @@ fail:
  */
 bool SdBaseFile::openRoot(SdVolume* vol) {
   // error if file is already open
-  if (isOpen()) goto fail;
+  if (isOpen()) goto FAIL;
 
   if (vol->fatType() == 16 || (FAT12_SUPPORT && vol->fatType() == 12)) {
     type_ = FAT_FILE_TYPE_ROOT_FIXED;
@@ -905,7 +905,7 @@ bool SdBaseFile::openRoot(SdVolume* vol) {
   else if (vol->fatType() == 32) {
     type_ = FAT_FILE_TYPE_ROOT32;
     firstCluster_ = vol->rootDirStart();
-    if (!vol->chainSize(firstCluster_, &fileSize_)) goto fail;
+    if (!vol->chainSize(firstCluster_, &fileSize_)) goto FAIL;
   }
   else {
     // volume is not initialized, invalid, or FAT12 without support
@@ -923,7 +923,7 @@ bool SdBaseFile::openRoot(SdVolume* vol) {
   dirBlock_ = 0;
   dirIndex_ = 0;
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -1055,7 +1055,7 @@ int16_t SdBaseFile::read(void* buf, uint16_t nbyte) {
   uint32_t block;  // raw device block number
 
   // error if not open or write only
-  if (!isOpen() || !(flags_ & O_READ)) goto fail;
+  if (!isOpen() || !(flags_ & O_READ)) goto FAIL;
 
   // max bytes left in file
   NOMORE(nbyte, fileSize_ - curPosition_);
@@ -1077,7 +1077,7 @@ int16_t SdBaseFile::read(void* buf, uint16_t nbyte) {
         }
         else {
           // get next cluster from FAT
-          if (!vol_->fatGet(curCluster_, &curCluster_)) goto fail;
+          if (!vol_->fatGet(curCluster_, &curCluster_)) goto FAIL;
         }
       }
       block = vol_->clusterStartBlock(curCluster_) + blockOfCluster;
@@ -1089,11 +1089,11 @@ int16_t SdBaseFile::read(void* buf, uint16_t nbyte) {
 
     // no buffering needed if n == 512
     if (n == 512 && block != vol_->cacheBlockNumber()) {
-      if (!vol_->readBlock(block, dst)) goto fail;
+      if (!vol_->readBlock(block, dst)) goto FAIL;
     }
     else {
       // read block to cache and copy data to caller
-      if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_READ)) goto fail;
+      if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_READ)) goto FAIL;
       uint8_t* src = vol_->cache()->data + offset;
       memcpy(dst, src, n);
     }
@@ -1102,7 +1102,7 @@ int16_t SdBaseFile::read(void* buf, uint16_t nbyte) {
     toRead -= n;
   }
   return nbyte;
-fail:
+  FAIL:
   return -1;
 }
 
@@ -1161,20 +1161,20 @@ int8_t SdBaseFile::readDir(dir_t* dir, char* longFilename) {
 dir_t* SdBaseFile::readDirCache() {
   uint8_t i;
   // error if not directory
-  if (!isDir()) goto fail;
+  if (!isDir()) goto FAIL;
 
   // index of entry in cache
   i = (curPosition_ >> 5) & 0XF;
 
   // use read to locate and cache block
-  if (read() < 0) goto fail;
+  if (read() < 0) goto FAIL;
 
   // advance to next entry
   curPosition_ += 31;
 
   // return pointer to entry
   return vol_->cache()->dir + i;
-fail:
+  FAIL:
   return 0;
 }
 //------------------------------------------------------------------------------
@@ -1194,11 +1194,11 @@ fail:
 bool SdBaseFile::remove() {
   dir_t* d;
   // free any clusters - will fail if read-only or directory
-  if (!truncate(0)) goto fail;
+  if (!truncate(0)) goto FAIL;
 
   // cache directory entry
   d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
-  if (!d) goto fail;
+  if (!d) goto FAIL;
 
   // mark entry deleted
   d->name[0] = DIR_NAME_DELETED;
@@ -1209,7 +1209,7 @@ bool SdBaseFile::remove() {
   // write entry to SD
   return vol_->cacheFlush();
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -1232,9 +1232,9 @@ fail:
  */
 bool SdBaseFile::remove(SdBaseFile* dirFile, const char* path) {
   SdBaseFile file;
-  if (!file.open(dirFile, path, O_WRITE)) goto fail;
+  if (!file.open(dirFile, path, O_WRITE)) goto FAIL;
   return file.remove();
-fail:
+  FAIL:
   // can't set iostate - static function
   return false;
 }
@@ -1256,15 +1256,15 @@ bool SdBaseFile::rename(SdBaseFile* dirFile, const char* newPath) {
   dir_t* d;
 
   // must be an open file or subdirectory
-  if (!(isFile() || isSubDir())) goto fail;
+  if (!(isFile() || isSubDir())) goto FAIL;
 
   // can't move file
-  if (vol_ != dirFile->vol_) goto fail;
+  if (vol_ != dirFile->vol_) goto FAIL;
 
   // sync() and cache directory entry
   sync();
   d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
-  if (!d) goto fail;
+  if (!d) goto FAIL;
 
   // save directory entry
   memcpy(&entry, d, sizeof(entry));
@@ -1295,7 +1295,7 @@ bool SdBaseFile::rename(SdBaseFile* dirFile, const char* newPath) {
 
   // cache new directory entry
   d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
-  if (!d) goto fail;
+  if (!d) goto FAIL;
 
   // copy all but name field to new directory entry
   memcpy(&d->attributes, &entry.attributes, sizeof(entry) - sizeof(d->name));
@@ -1304,27 +1304,27 @@ bool SdBaseFile::rename(SdBaseFile* dirFile, const char* newPath) {
   if (dirCluster) {
     // get new dot dot
     uint32_t block = vol_->clusterStartBlock(dirCluster);
-    if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_READ)) goto fail;
+    if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_READ)) goto FAIL;
     memcpy(&entry, &vol_->cache()->dir[1], sizeof(entry));
 
     // free unused cluster
-    if (!vol_->freeChain(dirCluster)) goto fail;
+    if (!vol_->freeChain(dirCluster)) goto FAIL;
 
     // store new dot dot
     block = vol_->clusterStartBlock(firstCluster_);
-    if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) goto fail;
+    if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) goto FAIL;
     memcpy(&vol_->cache()->dir[1], &entry, sizeof(entry));
   }
   return vol_->cacheFlush();
 
 restore:
   d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
-  if (!d) goto fail;
+  if (!d) goto FAIL;
   // restore entry
   d->name[0] = entry.name[0];
   vol_->cacheFlush();
 
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -1345,26 +1345,26 @@ fail:
  */
 bool SdBaseFile::rmdir() {
   // must be open subdirectory
-  if (!isSubDir()) goto fail;
+  if (!isSubDir()) goto FAIL;
 
   rewind();
 
   // make sure directory is empty
   while (curPosition_ < fileSize_) {
     dir_t* p = readDirCache();
-    if (!p) goto fail;
+    if (!p) goto FAIL;
     // done if past last used entry
     if (p->name[0] == DIR_NAME_FREE) break;
     // skip empty slot, '.' or '..'
     if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') continue;
     // error not empty
-    if (DIR_IS_FILE_OR_SUBDIR(p)) goto fail;
+    if (DIR_IS_FILE_OR_SUBDIR(p)) goto FAIL;
   }
   // convert empty directory to normal file for remove
   type_ = FAT_FILE_TYPE_NORMAL;
   flags_ |= O_WRITE;
   return remove();
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -1392,7 +1392,7 @@ bool SdBaseFile::rmRfStar() {
     index = curPosition_ / 32;
 
     dir_t* p = readDirCache();
-    if (!p) goto fail;
+    if (!p) goto FAIL;
 
     // done if past last entry
     if (p->name[0] == DIR_NAME_FREE) break;
@@ -1403,27 +1403,27 @@ bool SdBaseFile::rmRfStar() {
     // skip if part of long file name or volume label in root
     if (!DIR_IS_FILE_OR_SUBDIR(p)) continue;
 
-    if (!f.open(this, index, O_READ)) goto fail;
+    if (!f.open(this, index, O_READ)) goto FAIL;
     if (f.isSubDir()) {
       // recursively delete
-      if (!f.rmRfStar()) goto fail;
+      if (!f.rmRfStar()) goto FAIL;
     }
     else {
       // ignore read-only
       f.flags_ |= O_WRITE;
-      if (!f.remove()) goto fail;
+      if (!f.remove()) goto FAIL;
     }
     // position to next entry if required
     if (curPosition_ != (32 * (index + 1))) {
-      if (!seekSet(32 * (index + 1))) goto fail;
+      if (!seekSet(32 * (index + 1))) goto FAIL;
     }
   }
   // don't try to delete root
   if (!isRoot()) {
-    if (!rmdir()) goto fail;
+    if (!rmdir()) goto FAIL;
   }
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -1451,7 +1451,7 @@ bool SdBaseFile::seekSet(uint32_t pos) {
   uint32_t nCur;
   uint32_t nNew;
   // error if file not open or seek past end of file
-  if (!isOpen() || pos > fileSize_) goto fail;
+  if (!isOpen() || pos > fileSize_) goto FAIL;
 
   if (type_ == FAT_FILE_TYPE_ROOT_FIXED) {
     curPosition_ = pos;
@@ -1476,14 +1476,14 @@ bool SdBaseFile::seekSet(uint32_t pos) {
     nNew -= nCur;
   }
   while (nNew--) {
-    if (!vol_->fatGet(curCluster_, &curCluster_)) goto fail;
+    if (!vol_->fatGet(curCluster_, &curCluster_)) goto FAIL;
   }
   curPosition_ = pos;
 
 done:
   return true;
 
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -1502,12 +1502,12 @@ void SdBaseFile::setpos(filepos_t* pos) {
  */
 bool SdBaseFile::sync() {
   // only allow open files and directories
-  if (!isOpen()) goto fail;
+  if (!isOpen()) goto FAIL;
 
   if (flags_ & F_FILE_DIR_DIRTY) {
     dir_t* d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
     // check for deleted by another open file object
-    if (!d || d->name[0] == DIR_NAME_DELETED) goto fail;
+    if (!d || d->name[0] == DIR_NAME_DELETED) goto FAIL;
 
     // do not set filesize for dir files
     if (!isDir()) d->fileSize = fileSize_;
@@ -1526,7 +1526,7 @@ bool SdBaseFile::sync() {
   }
   return vol_->cacheFlush();
 
-fail:
+  FAIL:
   writeError = true;
   return false;
 }
@@ -1547,13 +1547,13 @@ bool SdBaseFile::timestamp(SdBaseFile* file) {
   dir_t dir;
 
   // get timestamps
-  if (!file->dirEntry(&dir)) goto fail;
+  if (!file->dirEntry(&dir)) goto FAIL;
 
   // update directory fields
-  if (!sync()) goto fail;
+  if (!sync()) goto FAIL;
 
   d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
-  if (!d) goto fail;
+  if (!d) goto FAIL;
 
   // copy timestamps
   d->lastAccessDate = dir.lastAccessDate;
@@ -1566,7 +1566,7 @@ bool SdBaseFile::timestamp(SdBaseFile* file) {
   // write back entry
   return vol_->cacheFlush();
 
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -1619,13 +1619,13 @@ bool SdBaseFile::timestamp(uint8_t flags, uint16_t year, uint8_t month,
       || hour > 23
       || minute > 59
       || second > 59) {
-    goto fail;
+    goto FAIL;
   }
   // update directory entry
-  if (!sync()) goto fail;
+  if (!sync()) goto FAIL;
 
   d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
-  if (!d) goto fail;
+  if (!d) goto FAIL;
 
   dirDate = FAT_DATE(year, month, day);
   dirTime = FAT_TIME(hour, minute, second);
@@ -1643,7 +1643,7 @@ bool SdBaseFile::timestamp(uint8_t flags, uint16_t year, uint8_t month,
     d->lastWriteTime = dirTime;
   }
   return vol_->cacheFlush();
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -1661,10 +1661,10 @@ fail:
 bool SdBaseFile::truncate(uint32_t length) {
   uint32_t newPos;
   // error if not a normal file or read-only
-  if (!isFile() || !(flags_ & O_WRITE)) goto fail;
+  if (!isFile() || !(flags_ & O_WRITE)) goto FAIL;
 
   // error if length is greater than current size
-  if (length > fileSize_) goto fail;
+  if (length > fileSize_) goto FAIL;
 
   // fileSize and length are zero - nothing to do
   if (fileSize_ == 0) return true;
@@ -1673,23 +1673,23 @@ bool SdBaseFile::truncate(uint32_t length) {
   newPos = curPosition_ > length ? length : curPosition_;
 
   // position to last cluster in truncated file
-  if (!seekSet(length)) goto fail;
+  if (!seekSet(length)) goto FAIL;
 
   if (length == 0) {
     // free all clusters
-    if (!vol_->freeChain(firstCluster_)) goto fail;
+    if (!vol_->freeChain(firstCluster_)) goto FAIL;
     firstCluster_ = 0;
   }
   else {
     uint32_t toFree;
-    if (!vol_->fatGet(curCluster_, &toFree)) goto fail;
+    if (!vol_->fatGet(curCluster_, &toFree)) goto FAIL;
 
     if (!vol_->isEOC(toFree)) {
       // free extra clusters
-      if (!vol_->freeChain(toFree)) goto fail;
+      if (!vol_->freeChain(toFree)) goto FAIL;
 
       // current cluster is end of chain
-      if (!vol_->fatPutEOC(curCluster_)) goto fail;
+      if (!vol_->fatPutEOC(curCluster_)) goto FAIL;
     }
   }
   fileSize_ = length;
@@ -1697,12 +1697,12 @@ bool SdBaseFile::truncate(uint32_t length) {
   // need to update directory entry
   flags_ |= F_FILE_DIR_DIRTY;
 
-  if (!sync()) goto fail;
+  if (!sync()) goto FAIL;
 
   // set file to correct position
   return seekSet(newPos);
 
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -1729,11 +1729,11 @@ int16_t SdBaseFile::write(const void* buf, uint16_t nbyte) {
   uint16_t nToWrite = nbyte;
 
   // error if not a normal file or is read-only
-  if (!isFile() || !(flags_ & O_WRITE)) goto fail;
+  if (!isFile() || !(flags_ & O_WRITE)) goto FAIL;
 
   // seek to end of file if append flag
   if ((flags_ & O_APPEND) && curPosition_ != fileSize_) {
-    if (!seekEnd()) goto fail;
+    if (!seekEnd()) goto FAIL;
   }
 
   while (nToWrite > 0) {
@@ -1744,7 +1744,7 @@ int16_t SdBaseFile::write(const void* buf, uint16_t nbyte) {
       if (curCluster_ == 0) {
         if (firstCluster_ == 0) {
           // allocate first cluster of file
-          if (!addCluster()) goto fail;
+          if (!addCluster()) goto FAIL;
         }
         else {
           curCluster_ = firstCluster_;
@@ -1752,10 +1752,10 @@ int16_t SdBaseFile::write(const void* buf, uint16_t nbyte) {
       }
       else {
         uint32_t next;
-        if (!vol_->fatGet(curCluster_, &next)) goto fail;
+        if (!vol_->fatGet(curCluster_, &next)) goto FAIL;
         if (vol_->isEOC(next)) {
           // add cluster if at end of chain
-          if (!addCluster()) goto fail;
+          if (!addCluster()) goto FAIL;
         }
         else {
           curCluster_ = next;
@@ -1776,18 +1776,18 @@ int16_t SdBaseFile::write(const void* buf, uint16_t nbyte) {
         // invalidate cache if block is in cache
         vol_->cacheSetBlockNumber(0xFFFFFFFF, false);
       }
-      if (!vol_->writeBlock(block, src)) goto fail;
+      if (!vol_->writeBlock(block, src)) goto FAIL;
     }
     else {
       if (blockOffset == 0 && curPosition_ >= fileSize_) {
         // start of new block don't need to read into cache
-        if (!vol_->cacheFlush()) goto fail;
+        if (!vol_->cacheFlush()) goto FAIL;
         // set cache dirty and SD address of block
         vol_->cacheSetBlockNumber(block, true);
       }
       else {
         // rewrite part of block
-        if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) goto fail;
+        if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) goto FAIL;
       }
       uint8_t* dst = vol_->cache()->data + blockOffset;
       memcpy(dst, src, n);
@@ -1807,11 +1807,11 @@ int16_t SdBaseFile::write(const void* buf, uint16_t nbyte) {
   }
 
   if (flags_ & O_SYNC) {
-    if (!sync()) goto fail;
+    if (!sync()) goto FAIL;
   }
   return nbyte;
 
-fail:
+  FAIL:
   // return for write error
   writeError = true;
   return -1;

Marlin/SdVolume.cpp

@@ -73,14 +73,14 @@ bool SdVolume::allocContiguous(uint32_t count, uint32_t* curCluster) {
   // search the FAT for free clusters
   for (uint32_t n = 0;; n++, endCluster++) {
     // can't find space checked all clusters
-    if (n >= clusterCount_) goto fail;
+    if (n >= clusterCount_) goto FAIL;
 
     // past end - start from beginning of FAT
     if (endCluster > fatEnd) {
       bgnCluster = endCluster = 2;
     }
     uint32_t f;
-    if (!fatGet(endCluster, &f)) goto fail;
+    if (!fatGet(endCluster, &f)) goto FAIL;
 
     if (f != 0) {
       // cluster in use try next cluster as bgnCluster
@@ -92,16 +92,16 @@ bool SdVolume::allocContiguous(uint32_t count, uint32_t* curCluster) {
     }
   }
   // mark end of chain
-  if (!fatPutEOC(endCluster)) goto fail;
+  if (!fatPutEOC(endCluster)) goto FAIL;
 
   // link clusters
   while (endCluster > bgnCluster) {
-    if (!fatPut(endCluster - 1, endCluster)) goto fail;
+    if (!fatPut(endCluster - 1, endCluster)) goto FAIL;
     endCluster--;
   }
   if (*curCluster != 0) {
     // connect chains
-    if (!fatPut(*curCluster, bgnCluster)) goto fail;
+    if (!fatPut(*curCluster, bgnCluster)) goto FAIL;
   }
   // return first cluster number to caller
   *curCluster = bgnCluster;
@@ -110,38 +110,38 @@ bool SdVolume::allocContiguous(uint32_t count, uint32_t* curCluster) {
   if (setStart) allocSearchStart_ = bgnCluster + 1;
 
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
 bool SdVolume::cacheFlush() {
   if (cacheDirty_) {
     if (!sdCard_->writeBlock(cacheBlockNumber_, cacheBuffer_.data)) {
-      goto fail;
+      goto FAIL;
     }
     // mirror FAT tables
     if (cacheMirrorBlock_) {
       if (!sdCard_->writeBlock(cacheMirrorBlock_, cacheBuffer_.data)) {
-        goto fail;
+        goto FAIL;
       }
       cacheMirrorBlock_ = 0;
     }
     cacheDirty_ = 0;
   }
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
 bool SdVolume::cacheRawBlock(uint32_t blockNumber, bool dirty) {
   if (cacheBlockNumber_ != blockNumber) {
-    if (!cacheFlush()) goto fail;
-    if (!sdCard_->readBlock(blockNumber, cacheBuffer_.data)) goto fail;
+    if (!cacheFlush()) goto FAIL;
+    if (!sdCard_->readBlock(blockNumber, cacheBuffer_.data)) goto FAIL;
     cacheBlockNumber_ = blockNumber;
   }
   if (dirty) cacheDirty_ = true;
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -149,29 +149,29 @@ fail:
 bool SdVolume::chainSize(uint32_t cluster, uint32_t* size) {
   uint32_t s = 0;
   do {
-    if (!fatGet(cluster, &cluster)) goto fail;
+    if (!fatGet(cluster, &cluster)) goto FAIL;
     s += 512UL << clusterSizeShift_;
   } while (!isEOC(cluster));
   *size = s;
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
 // Fetch a FAT entry
 bool SdVolume::fatGet(uint32_t cluster, uint32_t* value) {
   uint32_t lba;
-  if (cluster > (clusterCount_ + 1)) goto fail;
+  if (cluster > (clusterCount_ + 1)) goto FAIL;
   if (FAT12_SUPPORT && fatType_ == 12) {
     uint16_t index = cluster;
     index += index >> 1;
     lba = fatStartBlock_ + (index >> 9);
-    if (!cacheRawBlock(lba, CACHE_FOR_READ)) goto fail;
+    if (!cacheRawBlock(lba, CACHE_FOR_READ)) goto FAIL;
     index &= 0x1FF;
     uint16_t tmp = cacheBuffer_.data[index];
     index++;
     if (index == 512) {
-      if (!cacheRawBlock(lba + 1, CACHE_FOR_READ)) goto fail;
+      if (!cacheRawBlock(lba + 1, CACHE_FOR_READ)) goto FAIL;
       index = 0;
     }
     tmp |= cacheBuffer_.data[index] << 8;
@@ -185,10 +185,10 @@ bool SdVolume::fatGet(uint32_t cluster, uint32_t* value) {
     lba = fatStartBlock_ + (cluster >> 7);
   }
   else {
-    goto fail;
+    goto FAIL;
   }
   if (lba != cacheBlockNumber_) {
-    if (!cacheRawBlock(lba, CACHE_FOR_READ)) goto fail;
+    if (!cacheRawBlock(lba, CACHE_FOR_READ)) goto FAIL;
   }
   if (fatType_ == 16) {
     *value = cacheBuffer_.fat16[cluster & 0xFF];
@@ -197,7 +197,7 @@ bool SdVolume::fatGet(uint32_t cluster, uint32_t* value) {
     *value = cacheBuffer_.fat32[cluster & 0x7F] & FAT32MASK;
   }
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -205,16 +205,16 @@ fail:
 bool SdVolume::fatPut(uint32_t cluster, uint32_t value) {
   uint32_t lba;
   // error if reserved cluster
-  if (cluster < 2) goto fail;
+  if (cluster < 2) goto FAIL;
 
   // error if not in FAT
-  if (cluster > (clusterCount_ + 1)) goto fail;
+  if (cluster > (clusterCount_ + 1)) goto FAIL;
 
   if (FAT12_SUPPORT && fatType_ == 12) {
     uint16_t index = cluster;
     index += index >> 1;
     lba = fatStartBlock_ + (index >> 9);
-    if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto fail;
+    if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto FAIL;
     // mirror second FAT
     if (fatCount_ > 1) cacheMirrorBlock_ = lba + blocksPerFat_;
     index &= 0x1FF;
@@ -227,7 +227,7 @@ bool SdVolume::fatPut(uint32_t cluster, uint32_t value) {
     if (index == 512) {
       lba++;
       index = 0;
-      if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto fail;
+      if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto FAIL;
       // mirror second FAT
       if (fatCount_ > 1) cacheMirrorBlock_ = lba + blocksPerFat_;
     }
@@ -245,9 +245,9 @@ bool SdVolume::fatPut(uint32_t cluster, uint32_t value) {
     lba = fatStartBlock_ + (cluster >> 7);
   }
   else {
-    goto fail;
+    goto FAIL;
   }
-  if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto fail;
+  if (!cacheRawBlock(lba, CACHE_FOR_WRITE)) goto FAIL;
   // store entry
   if (fatType_ == 16) {
     cacheBuffer_.fat16[cluster & 0xFF] = value;
@@ -258,7 +258,7 @@ bool SdVolume::fatPut(uint32_t cluster, uint32_t value) {
   // mirror second FAT
   if (fatCount_ > 1) cacheMirrorBlock_ = lba + blocksPerFat_;
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -270,16 +270,16 @@ bool SdVolume::freeChain(uint32_t cluster) {
   allocSearchStart_ = 2;
 
   do {
-    if (!fatGet(cluster, &next)) goto fail;
+    if (!fatGet(cluster, &next)) goto FAIL;
 
     // free cluster
-    if (!fatPut(cluster, 0)) goto fail;
+    if (!fatPut(cluster, 0)) goto FAIL;
 
     cluster = next;
   } while (!isEOC(cluster));
 
   return true;
-fail:
+  FAIL:
   return false;
 }
 //------------------------------------------------------------------------------
@@ -349,25 +349,25 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
   // if part == 0 assume super floppy with FAT boot sector in block zero
   // if part > 0 assume mbr volume with partition table
   if (part) {
-    if (part > 4)goto fail;
-    if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) goto fail;
+    if (part > 4)goto FAIL;
+    if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) goto FAIL;
     part_t* p = &cacheBuffer_.mbr.part[part - 1];
     if ((p->boot & 0x7F) != 0  ||
         p->totalSectors < 100 ||
         p->firstSector == 0) {
       // not a valid partition
-      goto fail;
+      goto FAIL;
     }
     volumeStartBlock = p->firstSector;
   }
-  if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) goto fail;
+  if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) goto FAIL;
   fbs = &cacheBuffer_.fbs32;
   if (fbs->bytesPerSector != 512 ||
       fbs->fatCount == 0 ||
       fbs->reservedSectorCount == 0 ||
       fbs->sectorsPerCluster == 0) {
     // not valid FAT volume
-    goto fail;
+    goto FAIL;
   }
   fatCount_ = fbs->fatCount;
   blocksPerCluster_ = fbs->sectorsPerCluster;
@@ -375,7 +375,7 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
   clusterSizeShift_ = 0;
   while (blocksPerCluster_ != _BV(clusterSizeShift_)) {
     // error if not power of 2
-    if (clusterSizeShift_++ > 7) goto fail;
+    if (clusterSizeShift_++ > 7) goto FAIL;
   }
   blocksPerFat_ = fbs->sectorsPerFat16 ?
                   fbs->sectorsPerFat16 : fbs->sectorsPerFat32;
@@ -404,7 +404,7 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
   // FAT type is determined by cluster count
   if (clusterCount_ < 4085) {
     fatType_ = 12;
-    if (!FAT12_SUPPORT) goto fail;
+    if (!FAT12_SUPPORT) goto FAIL;
   }
   else if (clusterCount_ < 65525) {
     fatType_ = 16;
@@ -414,7 +414,7 @@ bool SdVolume::init(Sd2Card* dev, uint8_t part) {
     fatType_ = 32;
   }
   return true;
-fail:
+  FAIL:
   return false;
 }
 #endif