Make CardReader class static (#12451)

* Make CardReader a static class
* Make CardReader flags into bitfields

Marlin/src/HAL/HAL_DUE/usb/sd_mmc_spi_mem.cpp

 }
 
 Ctrl_status sd_mmc_spi_test_unit_ready(void) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.cardOK)
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.flag.cardOK)
     return CTRL_NO_PRESENT;
   return CTRL_GOOD;
 }
 // NOTE: This function is defined as returning the address of the last block
 // in the card, which is cardSize() - 1
 Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.cardOK)
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.flag.cardOK)
     return CTRL_NO_PRESENT;
   *nb_sector = card.getSd2Card().cardSize() - 1;
   return CTRL_GOOD;
 }
 
 bool sd_mmc_spi_removal(void) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.cardOK)
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.flag.cardOK)
     return true;
   return false;
 }
 // #define DEBUG_MMC
 
 Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.cardOK)
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.flag.cardOK)
     return CTRL_NO_PRESENT;
 
   #ifdef DEBUG_MMC
 }
 
 Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.cardOK)
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.flag.cardOK)
     return CTRL_NO_PRESENT;
 
   #ifdef DEBUG_MMC

Marlin/src/HAL/HAL_LPC1768/main.cpp

     // the disk if Marlin has it mounted. Unfortuately there is currently no way
     // to unmount the disk from the LCD menu.
     // if (IS_SD_PRINTING() || IS_SD_FILE_OPEN())
-    if (card.cardOK)
+    if (card.flag.cardOK)
       MSC_Aquire_Lock();
     else
       MSC_Release_Lock();

Marlin/src/HAL/HAL_STM32F1/persistent_store_sdcard.cpp

 char eeprom_filename[] = "eeprom.dat";
 
 bool PersistentStore::access_start() {
-  if (!card.cardOK) return false;
+  if (!card.flag.cardOK) return false;
   int16_t bytes_read = 0;
   constexpr char eeprom_zero = 0xFF;
   card.openFile(eeprom_filename, true);
 }
 
 bool PersistentStore::access_finish() {
-  if (!card.cardOK) return false;
+  if (!card.flag.cardOK) return false;
   card.openFile(eeprom_filename, true);
   int16_t bytes_written = card.write(HAL_STM32F1_eeprom_content, HAL_STM32F1_EEPROM_SIZE);
   card.closefile();

Marlin/src/Marlin.cpp

     #if ENABLED(SDSUPPORT)
       card.checkautostart();
 
-      if (card.abort_sd_printing) {
+      if (card.flag.abort_sd_printing) {
         card.stopSDPrint(
           #if SD_RESORT
             true

Marlin/src/feature/power_loss_recovery.cpp

  */
 void PrintJobRecovery::check() {
   if (enabled) {
-    if (!card.cardOK) card.initsd();
-    if (card.cardOK) {
+    if (!card.flag.cardOK) card.initsd();
+    if (card.flag.cardOK) {
       load();
       if (!valid()) return purge();
       enqueue_and_echo_commands_P(PSTR("M1000 S"));

Marlin/src/feature/power_loss_recovery.h

   char command_queue[BUFSIZE][MAX_CMD_SIZE];
 
   // SD Filename and position
-  char sd_filename[MAXPATHNAMELENGTH];
+  char sd_filename[MAXPATHNAMELENGTH + 1];
   uint32_t sdpos;
 
   // Job elapsed time

Marlin/src/gcode/queue.cpp

             break;
           case StreamState::STREAM_COMPLETE:
             stream_state = StreamState::STREAM_RESET;
-            card.binary_mode = false;
+            card.flag.binary_mode = false;
             card.closefile();
             CARD_ECHO_P("echo: ");
             CARD_ECHO_P(card.filename);
             return;
           case StreamState::STREAM_FAILED:
             stream_state = StreamState::STREAM_RESET;
-            card.binary_mode = false;
+            card.flag.binary_mode = false;
             card.closefile();
             card.removeFile(card.filename);
             CARD_ECHOLN_P("echo: File transfer failed");
             ;
 
   #if ENABLED(FAST_FILE_TRANSFER)
-    if (card.saving && card.binary_mode) {
+    if (card.flag.saving && card.flag.binary_mode) {
       /**
        * For binary stream file transfer, use serial_line_buffer as the working
        * receive buffer (which limits the packet size to MAX_CMD_SIZE).
           gcode_LastN = gcode_N;
         }
         #if ENABLED(SDSUPPORT)
-          else if (card.saving && strcmp(command, "M29") != 0) // No line number with M29 in Pronterface
+          else if (card.flag.saving && strcmp(command, "M29") != 0) // No line number with M29 in Pronterface
             return gcode_line_error(PSTR(MSG_ERR_NO_CHECKSUM), i);
         #endif
 
 
   #if ENABLED(SDSUPPORT)
 
-    if (card.saving) {
+    if (card.flag.saving) {
       char* command = command_queue[cmd_queue_index_r];
       if (strstr_P(command, PSTR("M29"))) {
         // M29 closes the file
       else {
         // Write the string from the read buffer to SD
         card.write_command(command);
-        if (card.logging)
+        if (card.flag.logging)
           gcode.process_next_command(); // The card is saving because it's logging
         else
           ok_to_send();

Marlin/src/gcode/sdcard/M20-M30_M32-M34_M524_M928.cpp

  * M26: Set SD Card file index
  */
 void GcodeSuite::M26() {
-  if (card.cardOK && parser.seenval('S'))
+  if (card.flag.cardOK && parser.seenval('S'))
     card.setIndex(parser.value_long());
 }
 
     }
 
     // Binary transfer mode
-    if ((card.binary_mode = binary_mode)) {
+    if ((card.flag.binary_mode = binary_mode)) {
       SERIAL_ECHO_START_P(port);
       SERIAL_ECHO_P(port, " preparing to receive: ");
       SERIAL_ECHOLN_P(port, p);
  * Processed in write to file routine
  */
 void GcodeSuite::M29() {
-  // card.saving = false;
+  // card.flag.saving = false;
 }
 
 /**
  * M30 <filename>: Delete SD Card file
  */
 void GcodeSuite::M30() {
-  if (card.cardOK) {
+  if (card.flag.cardOK) {
     card.closefile();
     card.removeFile(parser.string_arg);
   }
 void GcodeSuite::M32() {
   if (IS_SD_PRINTING()) planner.synchronize();
 
-  if (card.cardOK) {
+  if (card.flag.cardOK) {
     const bool call_procedure = parser.boolval('P');
 
     card.openFile(parser.string_arg, true, call_procedure);
  * M524: Abort the current SD print job (started with M24)
  */
 void GcodeSuite::M524() {
-  if (IS_SD_PRINTING()) card.abort_sd_printing = true;
+  if (IS_SD_PRINTING()) card.flag.abort_sd_printing = true;
 }
 
 /**

Marlin/src/lcd/extensible_ui/ui_api.cpp

   }
 
   bool isPrintingFromMedia() {
-    return IFSD(card.cardOK && card.isFileOpen(), false);
+    return IFSD(card.flag.cardOK && card.isFileOpen(), false);
   }
 
   bool isPrinting() {
   }
 
   bool isMediaInserted() {
-    return IFSD(IS_SD_INSERTED() && card.cardOK, false);
+    return IFSD(IS_SD_INSERTED() && card.flag.cardOK, false);
   }
 
   void pausePrint() {
   void stopPrint() {
     #if ENABLED(SDSUPPORT)
       wait_for_heatup = wait_for_user = false;
-      card.abort_sd_printing = true;
+      card.flag.abort_sd_printing = true;
       ExtUI::onStatusChanged(PSTR(MSG_PRINT_ABORTED));
     #endif
   }
   }
 
   bool FileList::isDir() {
-    return IFSD(card.filenameIsDir, false);
+    return IFSD(card.flag.filenameIsDir, false);
   }
 
   uint16_t FileList::count() {
       last_sd_status = sd_status;
       if (sd_status) {
         card.initsd();
-        if (card.cardOK)
+        if (card.flag.cardOK)
           ExtUI::onMediaInserted();
         else
           ExtUI::onMediaError();
       }
       else {
-        const bool ok = card.cardOK;
+        const bool ok = card.flag.cardOK;
         card.release();
         if (ok) ExtUI::onMediaRemoved();
       }

Marlin/src/lcd/malyanlcd.cpp

         // There may be a difference in how V1 and V2 LCDs handle subdirectory
         // prints. Investigate more. This matches the V1 motion controller actions
         // but the V2 LCD switches to "print" mode on {SYS:DIR} response.
-        if (card.filenameIsDir) {
+        if (card.flag.filenameIsDir) {
           card.chdir(card.filename);
           write_to_lcd_P(PSTR("{SYS:DIR}"));
         }
 
     case 'L': {
       #if ENABLED(SDSUPPORT)
-        if (!card.cardOK) card.initsd();
+        if (!card.flag.cardOK) card.initsd();
 
         // A more efficient way to do this would be to
         // implement a callback in the ls_SerialPrint code, but
         uint16_t file_count = card.get_num_Files();
         for (uint16_t i = 0; i < file_count; i++) {
           card.getfilename(i);
-          sprintf_P(message_buffer, card.filenameIsDir ? PSTR("{DIR:%s}") : PSTR("{FILE:%s}"), card.longest_filename());
+          sprintf_P(message_buffer, card.flag.filenameIsDir ? PSTR("{DIR:%s}") : PSTR("{FILE:%s}"), card.longest_filename());
           write_to_lcd(message_buffer);
         }
 

Marlin/src/lcd/menu/menu_main.cpp

 
   void lcd_sdcard_stop() {
     wait_for_heatup = wait_for_user = false;
-    card.abort_sd_printing = true;
+    card.flag.abort_sd_printing = true;
     ui.setstatusPGM(PSTR(MSG_PRINT_ABORTED), -1);
     ui.return_to_status();
   }
   MENU_BACK(MSG_WATCH);
 
   #if ENABLED(SDSUPPORT)
-    if (card.cardOK) {
+    if (card.flag.cardOK) {
       if (card.isFileOpen()) {
         if (IS_SD_PRINTING())
           MENU_ITEM(function, MSG_PAUSE_PRINT, lcd_sdcard_pause);

Marlin/src/lcd/menu/menu_sdcard.cpp

 
       card.getfilename_sorted(nr);
 
-      if (card.filenameIsDir)
+      if (card.flag.filenameIsDir)
         MENU_ITEM(sdfolder, MSG_CARD_MENU, card);
       else
         MENU_ITEM(sdfile, MSG_CARD_MENU, card);

Marlin/src/sd/SdFatConfig.h

  * Defines for 8.3 and long (vfat) filenames
  */
 
-#define FILENAME_LENGTH 13 // Number of UTF-16 characters per entry
+#define FILENAME_LENGTH 12 // Number of UTF-16 characters per entry
 
 // Total bytes needed to store a single long filename
-#define LONG_FILENAME_LENGTH (FILENAME_LENGTH * MAX_VFAT_ENTRIES + 1)
+#define LONG_FILENAME_LENGTH ((FILENAME_LENGTH) * (MAX_VFAT_ENTRIES))

Marlin/src/sd/cardreader.cpp

   #include "../feature/pause.h"
 #endif
 
-#include <ctype.h>
+// public:
+
+card_flags_t CardReader::flag;
+char CardReader::filename[FILENAME_LENGTH + 1], CardReader::longFilename[LONG_FILENAME_LENGTH + 1];
+int8_t CardReader::autostart_index;
+
+#if ENABLED(FAST_FILE_TRANSFER)
+  #if NUM_SERIAL > 1
+    uint8_t CardReader::transfer_port;
+  #endif
+#endif
+
+// private:
+
+SdFile CardReader::root, CardReader::workDir, CardReader::workDirParents[MAX_DIR_DEPTH];
+uint8_t CardReader::workDirDepth;
+
+#if ENABLED(SDCARD_SORT_ALPHA)
+  uint16_t CardReader::sort_count;
+  #if ENABLED(SDSORT_GCODE)
+    bool CardReader::sort_alpha;
+    int CardReader::sort_folders;
+    //bool CardReader::sort_reverse;
+  #endif
+
+  #if ENABLED(SDSORT_DYNAMIC_RAM)
+    uint8_t *CardReader::sort_order;
+  #else
+    uint8_t CardReader::sort_order[SDSORT_LIMIT];
+  #endif
+
+  #if ENABLED(SDSORT_USES_RAM)
+
+    #if ENABLED(SDSORT_CACHE_NAMES)
+      #if ENABLED(SDSORT_DYNAMIC_RAM)
+        char **CardReader::sortshort, **CardReader::sortnames;
+      #else
+        char CardReader::sortshort[SDSORT_LIMIT][FILENAME_LENGTH + 1];
+        char CardReader::sortnames[SDSORT_LIMIT][SORTED_LONGNAME_MAXLEN + 1];
+      #endif
+    #elif DISABLED(SDSORT_USES_STACK)
+      char CardReader::sortnames[SDSORT_LIMIT][SORTED_LONGNAME_MAXLEN + 1];
+    #endif
+
+    #if HAS_FOLDER_SORTING
+      #if ENABLED(SDSORT_DYNAMIC_RAM)
+        uint8_t *CardReader::isDir;
+      #elif ENABLED(SDSORT_CACHE_NAMES) || DISABLED(SDSORT_USES_STACK)
+        uint8_t CardReader::isDir[(SDSORT_LIMIT+7)>>3];
+      #endif
+    #endif
+
+  #endif // SDSORT_USES_RAM
+
+#endif // SDCARD_SORT_ALPHA
+
+Sd2Card CardReader::sd2card;
+SdVolume CardReader::volume;
+SdFile CardReader::file;
+
+uint8_t CardReader::file_subcall_ctr;
+uint32_t CardReader::filespos[SD_PROCEDURE_DEPTH];
+char CardReader::proc_filenames[SD_PROCEDURE_DEPTH][MAXPATHNAMELENGTH + 1];
+
+uint32_t CardReader::filesize, CardReader::sdpos;
+
+LsAction CardReader::lsAction; //stored for recursion.
+uint16_t CardReader::nrFiles; //counter for the files in the current directory and recycled as position counter for getting the nrFiles'th name in the directory.
+char *CardReader::diveDirName;
+
+#if ENABLED(AUTO_REPORT_SD_STATUS)
+  uint8_t CardReader::auto_report_sd_interval;
+  millis_t CardReader::next_sd_report_ms;
+  #if NUM_SERIAL > 1
+    int8_t CardReader::serialport;
+  #endif
+#endif
 
 CardReader::CardReader() {
   #if ENABLED(SDCARD_SORT_ALPHA)
       //sort_reverse = false;
     #endif
   #endif
-  sdprinting = cardOK = saving = logging = false;
-  filesize = 0;
-  sdpos = 0;
+  flag.sdprinting = flag.cardOK = flag.saving = flag.logging = false;
+  filesize = sdpos = 0;
   file_subcall_ctr = 0;
 
   workDirDepth = 0;
   #endif
 }
 
-char *createFilename(char *buffer, const dir_t &p) { //buffer > 12characters
+char *createFilename(char *buffer, const dir_t &p) {
   char *pos = buffer;
   for (uint8_t i = 0; i < 11; i++) {
     if (p.name[i] == ' ') continue;
     if (DIR_IS_SUBDIR(&p) && lsAction != LS_Count && lsAction != LS_GetFilename) {
 
       // Get the short name for the item, which we know is a folder
-      char dosFilename[FILENAME_LENGTH];
+      char dosFilename[FILENAME_LENGTH + 1];
       createFilename(dosFilename, p);
 
       // Allocate enough stack space for the full path to a folder, trailing slash, and nul
       // It contains the full path to the "parent" argument.
       // We now have the full path to the item in this folder.
       strcpy(path, prepend_is_empty ? "/" : prepend); // root slash if prepend is empty
-      strcat(path, dosFilename); // FILENAME_LENGTH-1 characters maximum
-      strcat(path, "/");       // 1 character
+      strcat(path, dosFilename);                      // FILENAME_LENGTH characters maximum
+      strcat(path, "/");                              // 1 character
 
       // Serial.print(path);
 
 
       if (!DIR_IS_FILE_OR_SUBDIR(&p) || (p.attributes & DIR_ATT_HIDDEN)) continue;
 
-      filenameIsDir = DIR_IS_SUBDIR(&p);
+      flag.filenameIsDir = DIR_IS_SUBDIR(&p);
 
-      if (!filenameIsDir && (p.name[8] != 'G' || p.name[9] == '~')) continue;
+      if (!flag.filenameIsDir && (p.name[8] != 'G' || p.name[9] == '~')) continue;
 
       switch (lsAction) {  // 1 based file count
         case LS_Count:
       SERIAL_PROTOCOL_P(port, longFilename[0] ? longFilename : "???");
 
       // If the filename was printed then that's it
-      if (!filenameIsDir) break;
+      if (!flag.filenameIsDir) break;
 
       // SERIAL_ECHOPGM_P(port, "Opening dir: "); SERIAL_ECHOLN_P(port, segment);
 
   #endif
 ) {
   if (file.isOpen()) {
-    char dosFilename[FILENAME_LENGTH];
+    char dosFilename[FILENAME_LENGTH + 1];
     file.getFilename(dosFilename);
     SERIAL_ECHO_P(port, dosFilename);
     #if ENABLED(LONG_FILENAME_HOST_SUPPORT)
 }
 
 void CardReader::initsd() {
-  cardOK = false;
+  flag.cardOK = false;
   if (root.isOpen()) root.close();
 
   #ifndef SPI_SPEED
     SERIAL_ERRORLNPGM(MSG_SD_OPENROOT_FAIL);
   }
   else {
-    cardOK = true;
+    flag.cardOK = true;
     SERIAL_ECHO_START();
     SERIAL_ECHOLNPGM(MSG_SD_CARD_OK);
   }
 
 void CardReader::release() {
   stopSDPrint();
-  cardOK = false;
+  flag.cardOK = false;
 }
 
 void CardReader::openAndPrintFile(const char *name) {
 }
 
 void CardReader::startFileprint() {
-  if (cardOK) {
-    sdprinting = true;
+  if (flag.cardOK) {
+    flag.sdprinting = true;
     #if SD_RESORT
       flush_presort();
     #endif
   #if ENABLED(ADVANCED_PAUSE_FEATURE)
     did_pause_print = 0;
   #endif
-  sdprinting = abort_sd_printing = false;
+  flag.sdprinting = flag.abort_sd_printing = false;
   if (isFileOpen()) file.close();
   #if SD_RESORT
     if (re_sort) presort();
 }
 
 void CardReader::openLogFile(char * const path) {
-  logging = true;
+  flag.logging = true;
   openFile(path, false);
 }
 
   for (uint8_t i = 0; i < workDirDepth; i++)                // Loop to current work dir
     appendAtom(workDirParents[i], t, cnt);
 
-  if (cnt < MAXPATHNAMELENGTH - (FILENAME_LENGTH)) {
+  if (cnt < MAXPATHNAMELENGTH - (FILENAME_LENGTH) - 1) {    // Leave room for filename and nul
     appendAtom(file, t, cnt);
     --t;
   }
 
 void CardReader::openFile(char * const path, const bool read, const bool subcall/*=false*/) {
 
-  if (!cardOK) return;
+  if (!flag.cardOK) return;
 
   uint8_t doing = 0;
   if (isFileOpen()) {                     // Replacing current file or doing a subroutine
       SERIAL_EOL();
     }
     else {
-      saving = true;
+      flag.saving = true;
       getfilename(0, fname);
       #if ENABLED(EMERGENCY_PARSER)
         emergency_parser.disable();
 }
 
 void CardReader::removeFile(const char * const name) {
-  if (!cardOK) return;
+  if (!flag.cardOK) return;
 
   //stopSDPrint();
 
     const int8_t port/*= -1*/
   #endif
 ) {
-  if (cardOK && sdprinting) {
+  if (flag.cardOK && flag.sdprinting) {
     SERIAL_PROTOCOLPGM_P(port, MSG_SD_PRINTING_BYTE);
     SERIAL_PROTOCOL_P(port, sdpos);
     SERIAL_PROTOCOLCHAR_P(port, '/');
 
 void CardReader::checkautostart() {
 
-  if (autostart_index < 0 || sdprinting) return;
+  if (autostart_index < 0 || flag.sdprinting) return;
 
-  if (!cardOK) initsd();
+  if (!flag.cardOK) initsd();
 
-  if (cardOK
+  if (flag.cardOK
     #if ENABLED(POWER_LOSS_RECOVERY)
       && !recovery.valid() // Don't run auto#.g when a resume file exists
     #endif
 void CardReader::closefile(const bool store_location) {
   file.sync();
   file.close();
-  saving = logging = false;
+  flag.saving = flag.logging = false;
   sdpos = 0;
   #if ENABLED(EMERGENCY_PARSER)
     emergency_parser.enable();
     if (nr < sort_count) {
       strcpy(filename, sortshort[nr]);
       strcpy(longFilename, sortnames[nr]);
-      filenameIsDir = TEST(isDir[nr>>3], nr & 0x07);
+      flag.filenameIsDir = TEST(isDir[nr>>3], nr & 0x07);
       return;
     }
   #endif // SDSORT_CACHE_NAMES
     );
   }
 
+  #if ENABLED(SDSORT_USES_RAM)
+    #if ENABLED(SDSORT_DYNAMIC_RAM)
+      // Use dynamic method to copy long filename
+      #define SET_SORTNAME(I) (sortnames[I] = strdup(longest_filename()))
+      #if ENABLED(SDSORT_CACHE_NAMES)
+        // When caching also store the short name, since
+        // we're replacing the getfilename() behavior.
+        #define SET_SORTSHORT(I) (sortshort[I] = strdup(filename))
+      #else
+        #define SET_SORTSHORT(I) NOOP
+      #endif
+    #else
+      // Copy filenames into the static array
+      #if SORTED_LONGNAME_MAXLEN != LONG_FILENAME_LENGTH
+        #define SET_SORTNAME(I) do{ strncpy(sortnames[I], longest_filename(), SORTED_LONGNAME_MAXLEN); \
+                                    sortnames[I][SORTED_LONGNAME_MAXLEN] = '\0'; }while(0)
+      #else
+        #define SET_SORTNAME(I) strncpy(sortnames[I], longest_filename(), SORTED_LONGNAME_MAXLEN)
+      #endif
+      #if ENABLED(SDSORT_CACHE_NAMES)
+        #define SET_SORTSHORT(I) strcpy(sortshort[I], filename)
+      #else
+        #define SET_SORTSHORT(I) NOOP
+      #endif
+    #endif
+  #endif
+
   /**
    * Read all the files and produce a sort key
    *
             sortnames = new char*[fileCnt];
           #endif
         #elif ENABLED(SDSORT_USES_STACK)
-          char sortnames[fileCnt][SORTED_LONGNAME_MAXLEN];
+          char sortnames[fileCnt][SORTED_LONGNAME_MAXLEN + 1];
         #endif
 
         // Folder sorting needs 1 bit per entry for flags.
           // If using RAM then read all filenames now.
           #if ENABLED(SDSORT_USES_RAM)
             getfilename(i);
-            #if ENABLED(SDSORT_DYNAMIC_RAM)
-              // Use dynamic method to copy long filename
-              sortnames[i] = strdup(longest_filename());
-              #if ENABLED(SDSORT_CACHE_NAMES)
-                // When caching also store the short name, since
-                // we're replacing the getfilename() behavior.
-                sortshort[i] = strdup(filename);
-              #endif
-            #else
-              // Copy filenames into the static array
-              #if SORTED_LONGNAME_MAXLEN != LONG_FILENAME_LENGTH
-                strncpy(sortnames[i], longest_filename(), SORTED_LONGNAME_MAXLEN);
-                sortnames[i][SORTED_LONGNAME_MAXLEN - 1] = '\0';
-              #else
-                strncpy(sortnames[i], longest_filename(), SORTED_LONGNAME_MAXLEN);
-              #endif
-              #if ENABLED(SDSORT_CACHE_NAMES)
-                strcpy(sortshort[i], filename);
-              #endif
-            #endif
+            SET_SORTNAME(i);
+            SET_SORTSHORT(i);
             // char out[30];
-            // sprintf_P(out, PSTR("---- %i %s %s"), i, filenameIsDir ? "D" : " ", sortnames[i]);
+            // sprintf_P(out, PSTR("---- %i %s %s"), i, flag.filenameIsDir ? "D" : " ", sortnames[i]);
             // SERIAL_ECHOLN(out);
             #if HAS_FOLDER_SORTING
               const uint16_t bit = i & 0x07, ind = i >> 3;
               if (bit == 0) isDir[ind] = 0x00;
-              if (filenameIsDir) isDir[ind] |= _BV(bit);
+              if (flag.filenameIsDir) isDir[ind] |= _BV(bit);
             #endif
           #endif
         }
                     ? _SORT_CMP_NODIR() \
                     : (isDir[fs > 0 ? ind1 : ind2] & (fs > 0 ? _BV(bit1) : _BV(bit2))) != 0)
               #else
-                #define _SORT_CMP_DIR(fs) ((dir1 == filenameIsDir) ? _SORT_CMP_NODIR() : (fs > 0 ? dir1 : !dir1))
+                #define _SORT_CMP_DIR(fs) ((dir1 == flag.filenameIsDir) ? _SORT_CMP_NODIR() : (fs > 0 ? dir1 : !dir1))
               #endif
             #endif
 
               getfilename(o1);
               strcpy(name1, longest_filename()); // save (or getfilename below will trounce it)
               #if HAS_FOLDER_SORTING
-                bool dir1 = filenameIsDir;
+                bool dir1 = flag.filenameIsDir;
               #endif
               getfilename(o2);
               char *name2 = longest_filename(); // use the string in-place
       else {
         sort_order[0] = 0;
         #if ENABLED(SDSORT_USES_RAM) && ENABLED(SDSORT_CACHE_NAMES)
-          getfilename(0);
           #if ENABLED(SDSORT_DYNAMIC_RAM)
             sortnames = new char*[1];
-            sortnames[0] = strdup(longest_filename()); // malloc
             #if ENABLED(SDSORT_CACHE_NAMES)
               sortshort = new char*[1];
-              sortshort[0] = strdup(filename);       // malloc
             #endif
             isDir = new uint8_t[1];
-          #else
-            #if SORTED_LONGNAME_MAXLEN != LONG_FILENAME_LENGTH
-              strncpy(sortnames[0], longest_filename(), SORTED_LONGNAME_MAXLEN);
-              sortnames[0][SORTED_LONGNAME_MAXLEN - 1] = '\0';
-            #else
-              strncpy(sortnames[0], longest_filename(), SORTED_LONGNAME_MAXLEN);
-            #endif
-            #if ENABLED(SDSORT_CACHE_NAMES)
-              strcpy(sortshort[0], filename);
-            #endif
           #endif
-          isDir[0] = filenameIsDir ? 0x01 : 0x00;
+          getfilename(0);
+          SET_SORTNAME(0);
+          SET_SORTSHORT(0);
+          isDir[0] = flag.filenameIsDir ? 0x01 : 0x00;
         #endif
       }
 
   }
 
   void CardReader::openJobRecoveryFile(const bool read) {
-    if (!cardOK) return;
+    if (!flag.cardOK) return;
     if (recovery.file.isOpen()) return;
     if (!recovery.file.open(&root, job_recovery_file_name, read ? O_READ : O_CREAT | O_WRITE | O_TRUNC | O_SYNC)) {
       SERIAL_PROTOCOLPAIR(MSG_SD_OPEN_FILE_FAIL, job_recovery_file_name);

Marlin/src/sd/cardreader.h

 
 #define SD_RESORT ENABLED(SDCARD_SORT_ALPHA) && ENABLED(SDSORT_DYNAMIC_RAM)
 
-#define MAX_DIR_DEPTH 10          // Maximum folder depth
+#define MAX_DIR_DEPTH     10       // Maximum folder depth
+#define MAXDIRNAMELENGTH   8       // DOS folder name size
+#define MAXPATHNAMELENGTH  (1 + (MAXDIRNAMELENGTH + 1) * (MAX_DIR_DEPTH) + 1 + FILENAME_LENGTH) // "/" + N * ("ADIRNAME/") + "filename.ext"
 
 #include "SdFile.h"
 
 enum LsAction : uint8_t { LS_SerialPrint, LS_Count, LS_GetFilename };
 
+typedef struct {
+  bool saving:1,
+       logging:1,
+       sdprinting:1,
+       cardOK:1,
+       filenameIsDir:1,
+       abort_sd_printing:1
+       #if ENABLED(FAST_FILE_TRANSFER)
+         , binary_mode:1
+       #endif
+    ;
+} card_flags_t;
+
 class CardReader {
 public:
   CardReader();
 
-  void initsd();
-  void write_command(char *buf);
+  static void initsd();
+  static void write_command(char *buf);
 
-  void beginautostart();
-  void checkautostart();
+  static void beginautostart();
+  static void checkautostart();
 
-  void openFile(char * const path, const bool read, const bool subcall=false);
-  void openLogFile(char * const path);
-  void removeFile(const char * const name);
-  void closefile(const bool store_location=false);
-  void release();
-  void openAndPrintFile(const char *name);
-  void startFileprint();
-  void stopSDPrint(
+  static void openFile(char * const path, const bool read, const bool subcall=false);
+  static void openLogFile(char * const path);
+  static void removeFile(const char * const name);
+  static void closefile(const bool store_location=false);
+  static void release();
+  static void openAndPrintFile(const char *name);
+  static void startFileprint();
+  static void stopSDPrint(
     #if SD_RESORT
       const bool re_sort=false
     #endif
   );
-  void getStatus(
+  static void getStatus(
     #if NUM_SERIAL > 1
       const int8_t port = -1
     #endif
   );
-  void printingHasFinished();
-  void printFilename(
+  static void printingHasFinished();
+  static void printFilename(
     #if NUM_SERIAL > 1
       const int8_t port = -1
     #endif
   );
 
   #if ENABLED(LONG_FILENAME_HOST_SUPPORT)
-    void printLongPath(char *path
+    static void printLongPath(char *path
       #if NUM_SERIAL > 1
         , const int8_t port = -1
       #endif
     );
   #endif
 
-  void getfilename(uint16_t nr, const char* const match=NULL);
-  uint16_t getnrfilenames();
+  static void getfilename(uint16_t nr, const char* const match=NULL);
+  static uint16_t getnrfilenames();
 
-  void getAbsFilename(char *t);
+  static void getAbsFilename(char *t);
 
-  void ls(
+  static void ls(
     #if NUM_SERIAL > 1
       const int8_t port = -1
     #endif
   );
-  void chdir(const char *relpath);
-  int8_t updir();
-  void setroot();
+  static void chdir(const char *relpath);
+  static int8_t updir();
+  static void setroot();
 
-  const char* diveToFile(SdFile*& curDir, const char * const path, const bool echo);
+  static const char* diveToFile(SdFile*& curDir, const char * const path, const bool echo);
 
-  uint16_t get_num_Files();
+  static uint16_t get_num_Files();
 
   #if ENABLED(SDCARD_SORT_ALPHA)
-    void presort();
-    void getfilename_sorted(const uint16_t nr);
+    static void presort();
+    static void getfilename_sorted(const uint16_t nr);
     #if ENABLED(SDSORT_GCODE)
-      FORCE_INLINE void setSortOn(bool b) { sort_alpha = b; presort(); }
-      FORCE_INLINE void setSortFolders(int i) { sort_folders = i; presort(); }
-      //FORCE_INLINE void setSortReverse(bool b) { sort_reverse = b; }
+      FORCE_INLINE static void setSortOn(bool b) { sort_alpha = b; presort(); }
+      FORCE_INLINE static void setSortFolders(int i) { sort_folders = i; presort(); }
+      //FORCE_INLINE static void setSortReverse(bool b) { sort_reverse = b; }
     #endif
   #else
-    FORCE_INLINE void getfilename_sorted(const uint16_t nr) { getfilename(nr); }
+    FORCE_INLINE static void getfilename_sorted(const uint16_t nr) { getfilename(nr); }
   #endif
 
   #if ENABLED(POWER_LOSS_RECOVERY)
-    bool jobRecoverFileExists();
-    void openJobRecoveryFile(const bool read);
-    void removeJobRecoveryFile();
+    static bool jobRecoverFileExists();
+    static void openJobRecoveryFile(const bool read);
+    static void removeJobRecoveryFile();
   #endif
 
-  inline void pauseSDPrint() { sdprinting = false; }
-  inline bool isFileOpen() { return file.isOpen(); }
-  inline bool eof() { return sdpos >= filesize; }
-  inline int16_t get() { sdpos = file.curPosition(); return (int16_t)file.read(); }
-  inline void setIndex(const uint32_t index) { sdpos = index; file.seekSet(index); }
-  inline uint32_t getIndex() { return sdpos; }
-  inline uint8_t percentDone() { return (isFileOpen() && filesize) ? sdpos / ((filesize + 99) / 100) : 0; }
-  inline char* getWorkDirName() { workDir.getFilename(filename); return filename; }
-  inline int16_t read(void* buf, uint16_t nbyte) { return file.isOpen() ? file.read(buf, nbyte) : -1; }
-  inline int16_t write(void* buf, uint16_t nbyte) { return file.isOpen() ? file.write(buf, nbyte) : -1; }
+  static inline void pauseSDPrint() { flag.sdprinting = false; }
+  static inline bool isFileOpen() { return file.isOpen(); }
+  static inline bool eof() { return sdpos >= filesize; }
+  static inline int16_t get() { sdpos = file.curPosition(); return (int16_t)file.read(); }
+  static inline void setIndex(const uint32_t index) { sdpos = index; file.seekSet(index); }
+  static inline uint32_t getIndex() { return sdpos; }
+  static inline uint8_t percentDone() { return (isFileOpen() && filesize) ? sdpos / ((filesize + 99) / 100) : 0; }
+  static inline char* getWorkDirName() { workDir.getFilename(filename); return filename; }
+  static inline int16_t read(void* buf, uint16_t nbyte) { return file.isOpen() ? file.read(buf, nbyte) : -1; }
+  static inline int16_t write(void* buf, uint16_t nbyte) { return file.isOpen() ? file.write(buf, nbyte) : -1; }
 
-  Sd2Card& getSd2Card() { return sd2card; }
+  static Sd2Card& getSd2Card() { return sd2card; }
 
   #if ENABLED(AUTO_REPORT_SD_STATUS)
-    void auto_report_sd_status(void);
-    inline void set_auto_report_interval(uint8_t v
+    static void auto_report_sd_status(void);
+    static inline void set_auto_report_interval(uint8_t v
       #if NUM_SERIAL > 1
         , int8_t port
       #endif
     }
   #endif
 
-  inline char* longest_filename() { return longFilename[0] ? longFilename : filename; }
+  static inline char* longest_filename() { return longFilename[0] ? longFilename : filename; }
 
 public:
-  bool saving, logging, sdprinting, cardOK, filenameIsDir, abort_sd_printing;
-  char filename[FILENAME_LENGTH], longFilename[LONG_FILENAME_LENGTH];
-  int8_t autostart_index;
+  static card_flags_t flag;
+  static char filename[FILENAME_LENGTH + 1], longFilename[LONG_FILENAME_LENGTH + 1];
+  static int8_t autostart_index;
 
   #if ENABLED(FAST_FILE_TRANSFER)
-    bool binary_mode;
     #if NUM_SERIAL > 1
-      uint8_t transfer_port;
+      static uint8_t transfer_port;
     #else
       static constexpr uint8_t transfer_port = 0;
     #endif
   #endif
 
 private:
-  SdFile root, workDir, workDirParents[MAX_DIR_DEPTH];
-  uint8_t workDirDepth;
+  static SdFile root, workDir, workDirParents[MAX_DIR_DEPTH];
+  static uint8_t workDirDepth;
 
   // Sort files and folders alphabetically.
   #if ENABLED(SDCARD_SORT_ALPHA)
-    uint16_t sort_count;        // Count of sorted items in the current directory
+    static uint16_t sort_count;   // Count of sorted items in the current directory
     #if ENABLED(SDSORT_GCODE)
-      bool sort_alpha;          // Flag to enable / disable the feature
-      int sort_folders;         // Flag to enable / disable folder sorting
-      //bool sort_reverse;      // Flag to enable / disable reverse sorting
+      static bool sort_alpha;     // Flag to enable / disable the feature
+      static int sort_folders;    // Folder sorting before/none/after
+      //static bool sort_reverse; // Flag to enable / disable reverse sorting
     #endif
 
     // By default the sort index is static
     #if ENABLED(SDSORT_DYNAMIC_RAM)
-      uint8_t *sort_order;
+      static uint8_t *sort_order;
     #else
-      uint8_t sort_order[SDSORT_LIMIT];
+      static uint8_t sort_order[SDSORT_LIMIT];
     #endif
 
     #if ENABLED(SDSORT_USES_RAM) && ENABLED(SDSORT_CACHE_NAMES) && DISABLED(SDSORT_DYNAMIC_RAM)
       // If using dynamic ram for names, allocate on the heap.
       #if ENABLED(SDSORT_CACHE_NAMES)
         #if ENABLED(SDSORT_DYNAMIC_RAM)
-          char **sortshort, **sortnames;
+          static char **sortshort, **sortnames;
         #else
-          char sortshort[SDSORT_LIMIT][FILENAME_LENGTH];
-          char sortnames[SDSORT_LIMIT][SORTED_LONGNAME_MAXLEN];
+          static char sortshort[SDSORT_LIMIT][FILENAME_LENGTH + 1];
+          static char sortnames[SDSORT_LIMIT][SORTED_LONGNAME_MAXLEN + 1];
         #endif
       #elif DISABLED(SDSORT_USES_STACK)
-        char sortnames[SDSORT_LIMIT][SORTED_LONGNAME_MAXLEN];
+        static char sortnames[SDSORT_LIMIT][SORTED_LONGNAME_MAXLEN + 1];
       #endif
 
       // Folder sorting uses an isDir array when caching items.
       #if HAS_FOLDER_SORTING
         #if ENABLED(SDSORT_DYNAMIC_RAM)
-          uint8_t *isDir;
+          static uint8_t *isDir;
         #elif ENABLED(SDSORT_CACHE_NAMES) || DISABLED(SDSORT_USES_STACK)
-          uint8_t isDir[(SDSORT_LIMIT+7)>>3];
+          static uint8_t isDir[(SDSORT_LIMIT+7)>>3];
         #endif
       #endif
 
 
   #endif // SDCARD_SORT_ALPHA
 
-  Sd2Card sd2card;
-  SdVolume volume;
-  SdFile file;
-
-  #define SD_PROCEDURE_DEPTH 1
-  #define MAXPATHNAMELENGTH (FILENAME_LENGTH*MAX_DIR_DEPTH + MAX_DIR_DEPTH + 1)
-  uint8_t file_subcall_ctr;
-  uint32_t filespos[SD_PROCEDURE_DEPTH];
-  char proc_filenames[SD_PROCEDURE_DEPTH][MAXPATHNAMELENGTH];
-  uint32_t filesize, sdpos;
-
-  LsAction lsAction; //stored for recursion.
-  uint16_t nrFiles; //counter for the files in the current directory and recycled as position counter for getting the nrFiles'th name in the directory.
-  char* diveDirName;
-  void lsDive(const char *prepend, SdFile parent, const char * const match=NULL
+  static Sd2Card sd2card;
+  static SdVolume volume;
+  static SdFile file;
+
+  #ifndef SD_PROCEDURE_DEPTH
+    #define SD_PROCEDURE_DEPTH 1
+  #endif
+
+  static uint8_t file_subcall_ctr;
+  static uint32_t filespos[SD_PROCEDURE_DEPTH];
+  static char proc_filenames[SD_PROCEDURE_DEPTH][MAXPATHNAMELENGTH + 1];
+
+  static uint32_t filesize, sdpos;
+
+  static LsAction lsAction; //stored for recursion.
+  static uint16_t nrFiles; //counter for the files in the current directory and recycled as position counter for getting the nrFiles'th name in the directory.
+  static char *diveDirName;
+  static void lsDive(const char *prepend, SdFile parent, const char * const match=NULL
     #if NUM_SERIAL > 1
       , const int8_t port = -1
     #endif
   );
 
   #if ENABLED(SDCARD_SORT_ALPHA)
-    void flush_presort();
+    static void flush_presort();
   #endif
 
   #if ENABLED(AUTO_REPORT_SD_STATUS)
   #define IS_SD_INSERTED() true
 #endif
 
-#define IS_SD_PRINTING()  card.sdprinting
+#define IS_SD_PRINTING()  card.flag.sdprinting
 #define IS_SD_FILE_OPEN() card.isFileOpen()
 
 extern CardReader card;