3DPrinting/MarlinFirmware
1
0
Fork 0
mirror of https://github.com/MarlinFirmware/Marlin.git synced 2024-11-27 13:56:24 +00:00
Code Issues Releases Wiki Activity

misc. pointer formatting

Browse Source
This commit is contained in:
Scott Lahteine 2021-04-04 18:07:16 -05:00 committed by Scott Lahteine
parent c4379db8fc
commit ba5644376c
23 changed files with 85 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Marlin/src/HAL/DUE/eeprom_flash.cpp
View File

@ -135,7 +135,7 @@ static uint8_t buffer[256] = {0}, // The RAM buffer to accumulate writes
#define DEBUG_OUT ENABLED(EE_EMU_DEBUG)
#include "../../core/debug_out.h"
static void ee_Dump(const int page, const void* data) {
static void ee_Dump(const int page, const void *data) {
#ifdef EE_EMU_DEBUG
@ -181,7 +181,7 @@ static void ee_Dump(const int page, const void* data) {
* @param data (pointer to the data buffer)
*/
__attribute__ ((long_call, section (".ramfunc")))
static bool ee_PageWrite(uint16_t page, const void* data) {
static bool ee_PageWrite(uint16_t page, const void *data) {
uint16_t i;
uint32_t addrflash = uint32_t(getFlashStorage(page));

2
Marlin/src/HAL/ESP32/i2s.cpp
View File

@ -139,7 +139,7 @@ static void IRAM_ATTR i2s_intr_handler_default(void *arg) {
I2S0.int_clr.val = I2S0.int_st.val; //clear pending interrupt
}
void stepperTask(void* parameter) {
void stepperTask(void *parameter) {
uint32_t remaining = 0;
while (1) {

2
Marlin/src/HAL/STM32/MarlinSerial.h
View File

@ -29,7 +29,7 @@
typedef void (*usart_rx_callback_t)(serial_t * obj);
struct MarlinSerial : public HardwareSerial {
MarlinSerial(void* peripheral, usart_rx_callback_t rx_callback) :
MarlinSerial(void *peripheral, usart_rx_callback_t rx_callback) :
HardwareSerial(peripheral), _rx_callback(rx_callback)
{ }

2
Marlin/src/HAL/STM32F1/onboard_sd.h
View File

@ -48,7 +48,7 @@ DRESULT disk_read(BYTE pdrv, BYTE* buff, DWORD sector, UINT count);
DRESULT disk_write(BYTE pdrv, const BYTE* buff, DWORD sector, UINT count);
#endif
#if _DISKIO_IOCTL
DRESULT disk_ioctl(BYTE pdrv, BYTE cmd, void* buff);
DRESULT disk_ioctl(BYTE pdrv, BYTE cmd, void *buff);
#endif
/* Disk Status Bits (DSTATUS) */

2
Marlin/src/HAL/shared/backtrace/backtrace.cpp
View File

@ -29,7 +29,7 @@
#include <stdarg.h>
// Dump a backtrace entry
static bool UnwReportOut(void* ctx, const UnwReport* bte) {
static bool UnwReportOut(void *ctx, const UnwReport *bte) {
int *p = (int*)ctx;
(*p)++;

2
Marlin/src/HAL/shared/backtrace/unwinder.h
View File

@ -114,7 +114,7 @@ typedef struct {
* report function maybe called again in future. If false is returned,
* unwinding will stop with UnwindStart() returning UNWIND_TRUNCATED.
*/
typedef bool (*UnwindReportFunc)(void* data, const UnwReport* bte);
typedef bool (*UnwindReportFunc)(void *data, const UnwReport *bte);
/** Structure that holds memory callback function pointers.
*/

2
Marlin/src/feature/spindle_laser.h
View File

@ -215,7 +215,7 @@ public:
static inline void disable() { isReady = false; set_enabled(false); }
#if HAS_LCD_MENU
static inline void enable_with_dir(const bool reverse) {
static inline void enable_with_dir(const bool reverse) {
isReady = true;
const uint8_t ocr = TERN(SPINDLE_LASER_PWM, upower_to_ocr(menuPower), 255);
if (menuPower)

4
Marlin/src/lcd/extui/lib/dgus/DGUSDisplay.cpp
View File

@ -70,7 +70,7 @@ void DGUSDisplay::InitDisplay() {
RequestScreen(TERN(SHOW_BOOTSCREEN, DGUSLCD_SCREEN_BOOT, DGUSLCD_SCREEN_MAIN));
}
void DGUSDisplay::WriteVariable(uint16_t adr, const void* values, uint8_t valueslen, bool isstr) {
void DGUSDisplay::WriteVariable(uint16_t adr, const void *values, uint8_t valueslen, bool isstr) {
const char* myvalues = static_cast<const char*>(values);
bool strend = !myvalues;
WriteHeader(adr, DGUS_CMD_WRITEVAR, valueslen);
@ -120,7 +120,7 @@ void DGUSDisplay::WriteVariable(uint16_t adr, long value) {
WriteVariable(adr, static_cast<const void*>(&tmp), sizeof(long));
}
void DGUSDisplay::WriteVariablePGM(uint16_t adr, const void* values, uint8_t valueslen, bool isstr) {
void DGUSDisplay::WriteVariablePGM(uint16_t adr, const void *values, uint8_t valueslen, bool isstr) {
const char* myvalues = static_cast<const char*>(values);
bool strend = !myvalues;
WriteHeader(adr, DGUS_CMD_WRITEVAR, valueslen);

4
Marlin/src/lcd/extui/lib/dgus/DGUSDisplay.h
View File

@ -56,8 +56,8 @@ public:
static void InitDisplay();
// Variable access.
static void WriteVariable(uint16_t adr, const void* values, uint8_t valueslen, bool isstr=false);
static void WriteVariablePGM(uint16_t adr, const void* values, uint8_t valueslen, bool isstr=false);
static void WriteVariable(uint16_t adr, const void *values, uint8_t valueslen, bool isstr=false);
static void WriteVariablePGM(uint16_t adr, const void *values, uint8_t valueslen, bool isstr=false);
static void WriteVariable(uint16_t adr, int16_t value);
static void WriteVariable(uint16_t adr, uint16_t value);
static void WriteVariable(uint16_t adr, uint8_t value);

2
Marlin/src/lcd/extui/lib/dgus/mks/DGUSScreenHandler.cpp
View File

@ -75,7 +75,7 @@ void DGUSScreenHandler::sendinfoscreen_en_mks(const char *line1, const char *lin
dgusdisplay.WriteVariable(VP_MSGSTR4, line4, 32, true);
}
void DGUSScreenHandler::sendinfoscreen_mks(const void* line1, const void* line2, const void* line3, const void* line4, uint16_t language) {
void DGUSScreenHandler::sendinfoscreen_mks(const void *line1, const void *line2, const void *line3, const void *line4, uint16_t language) {
if (language == MKS_English)
DGUSScreenHandler::sendinfoscreen_en_mks((char *)line1, (char *)line2, (char *)line3, (char *)line4);
else if (language == MKS_SimpleChinese)

2
Marlin/src/lcd/extui/lib/dgus/mks/DGUSScreenHandler.h
View File

@ -44,7 +44,7 @@ public:
#if 0
static void sendinfoscreen_ch_mks(const uint16_t *line1, const uint16_t *line2, const uint16_t *line3, const uint16_t *line4);
static void sendinfoscreen_en_mks(const char *line1, const char *line2, const char *line3, const char *line4) ;
static void sendinfoscreen_mks(const void* line1, const void* line2, const void* line3, const void* line4,uint16_t language);
static void sendinfoscreen_mks(const void *line1, const void *line2, const void *line3, const void *line4, uint16_t language);
#endif
// "M117" Message -- msg is a RAM ptr.

2
Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/ftdi_eve_lib/basic/commands.cpp
View File

@ -229,7 +229,7 @@ void CLCD::CommandFifo::cmd(uint32_t cmd32) {
write((void*)&cmd32, sizeof(uint32_t));
}
void CLCD::CommandFifo::cmd(void* data, uint16_t len) {
void CLCD::CommandFifo::cmd(void *data, uint16_t len) {
write(data, len);
}

2
Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/ftdi_eve_lib/basic/commands.h
View File

@ -196,7 +196,7 @@ class CLCD::CommandFifo {
void execute();
void cmd(uint32_t cmd32);
void cmd(void* data, uint16_t len);
void cmd(void *data, uint16_t len);
void dlstart() {cmd(FTDI::CMD_DLSTART);}
void swap() {cmd(FTDI::CMD_SWAP);}

2
Marlin/src/lcd/extui/lib/ftdi_eve_touch_ui/ftdi_eve_lib/extended/command_processor.h
View File

@ -149,7 +149,7 @@ class CommandProcessor : public CLCD::CommandFifo {
// Wrap all the CommandFifo routines to allow method chaining
inline CommandProcessor& cmd (uint32_t cmd32) {CLCD::CommandFifo::cmd(cmd32); return *this;}
inline CommandProcessor& cmd (void* data, uint16_t len) {CLCD::CommandFifo::cmd(data, len); return *this;}
inline CommandProcessor& cmd (void *data, uint16_t len) {CLCD::CommandFifo::cmd(data, len); return *this;}
inline CommandProcessor& execute() {CLCD::CommandFifo::execute(); return *this;}
inline CommandProcessor& fgcolor (uint32_t rgb) {CLCD::CommandFifo::fgcolor(rgb); return *this;}

2
Marlin/src/sd/Sd2Card.cpp
View File

@ -477,7 +477,7 @@ bool Sd2Card::readData(uint8_t *dst, const uint16_t count) {
}
/** read CID or CSR register */
bool Sd2Card::readRegister(const uint8_t cmd, void* buf) {
bool Sd2Card::readRegister(const uint8_t cmd, void *buf) {
uint8_t *dst = reinterpret_cast<uint8_t*>(buf);
if (cardCommand(cmd, 0)) {
error(SD_CARD_ERROR_READ_REG);

2
Marlin/src/sd/Sd2Card.h
View File

@ -177,7 +177,7 @@ private:
uint8_t cardCommand(const uint8_t cmd, const uint32_t arg);
bool readData(uint8_t *dst, const uint16_t count);
bool readRegister(const uint8_t cmd, void* buf);
bool readRegister(const uint8_t cmd, void *buf);
void chipDeselect();
void chipSelect();
inline void type(const uint8_t value) { type_ = value; }

82
Marlin/src/sd/SdBaseFile.cpp
View File

@ -40,7 +40,7 @@
#include "SdBaseFile.h"
#include "../MarlinCore.h"
SdBaseFile* SdBaseFile::cwd_ = 0; // Pointer to Current Working Directory
SdBaseFile *SdBaseFile::cwd_ = 0; // Pointer to Current Working Directory
// callback function for date/time
void (*SdBaseFile::dateTime_)(uint16_t *date, uint16_t *time) = 0;
@ -155,7 +155,7 @@ bool SdBaseFile::contiguousRange(uint32_t *bgnBlock, uint32_t *endBlock) {
* a file is already open, the file already exists, the root
* directory is full or an I/O error.
*/
bool SdBaseFile::createContiguous(SdBaseFile* dirFile, const char *path, uint32_t size) {
bool SdBaseFile::createContiguous(SdBaseFile *dirFile, const char *path, uint32_t size) {
if (ENABLED(SDCARD_READONLY)) return false;
uint32_t count;
@ -187,12 +187,11 @@ bool SdBaseFile::createContiguous(SdBaseFile* dirFile, const char *path, uint32_
* \return true for success, false for failure.
*/
bool SdBaseFile::dirEntry(dir_t *dir) {
dir_t *p;
// make sure fields on SD are correct
if (!sync()) return false;
// read entry
p = cacheDirEntry(SdVolume::CACHE_FOR_READ);
dir_t *p = cacheDirEntry(SdVolume::CACHE_FOR_READ);
if (!p) return false;
// copy to caller's struct
@ -207,7 +206,7 @@ bool SdBaseFile::dirEntry(dir_t *dir) {
* \param[in] dir The directory structure containing the name.
* \param[out] name A 13 byte char array for the formatted name.
*/
void SdBaseFile::dirName(const dir_t& dir, char *name) {
void SdBaseFile::dirName(const dir_t &dir, char *name) {
uint8_t j = 0;
LOOP_L_N(i, 11) {
if (dir.name[i] == ' ')continue;
@ -386,7 +385,7 @@ int8_t SdBaseFile::lsPrintNext(uint8_t flags, uint8_t indent) {
}
// Format directory name field from a 8.3 name string
bool SdBaseFile::make83Name(const char *str, uint8_t *name, const char** ptr) {
bool SdBaseFile::make83Name(const char *str, uint8_t *name, const char **ptr) {
uint8_t n = 7, // Max index until a dot is found
i = 11;
while (i) name[--i] = ' '; // Set whole FILENAME.EXT to spaces
@ -423,13 +422,13 @@ bool SdBaseFile::make83Name(const char *str, uint8_t *name, const char** ptr) {
* Reasons for failure include this file is already open, \a parent is not a
* directory, \a path is invalid or already exists in \a parent.
*/
bool SdBaseFile::mkdir(SdBaseFile* parent, const char *path, bool pFlag) {
bool SdBaseFile::mkdir(SdBaseFile *parent, const char *path, bool pFlag) {
if (ENABLED(SDCARD_READONLY)) return false;
uint8_t dname[11];
SdBaseFile dir1, dir2;
SdBaseFile* sub = &dir1;
SdBaseFile* start = parent;
SdBaseFile *sub = &dir1;
SdBaseFile *start = parent;
if (!parent || isOpen()) return false;
@ -455,13 +454,9 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const char *path, bool pFlag) {
return mkdir(parent, dname);
}
bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t dname[11]) {
bool SdBaseFile::mkdir(SdBaseFile *parent, const uint8_t dname[11]) {
if (ENABLED(SDCARD_READONLY)) return false;
uint32_t block;
dir_t d;
dir_t *p;
if (!parent->isDir()) return false;
// create a normal file
@ -478,19 +473,20 @@ bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t dname[11]) {
if (!sync()) return false;
// cache entry - should already be in cache due to sync() call
p = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
dir_t *p = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
if (!p) return false;
// change directory entry attribute
p->attributes = DIR_ATT_DIRECTORY;
// make entry for '.'
dir_t d;
memcpy(&d, p, sizeof(d));
d.name[0] = '.';
LOOP_S_L_N(i, 1, 11) d.name[i] = ' ';
// cache block for '.' and '..'
block = vol_->clusterStartBlock(firstCluster_);
uint32_t block = vol_->clusterStartBlock(firstCluster_);
if (!vol_->cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) return false;
// copy '.' to block
@ -577,7 +573,7 @@ bool SdBaseFile::open(const char *path, uint8_t oflag) {
* a directory, \a path is invalid, the file does not exist
* or can't be opened in the access mode specified by oflag.
*/
bool SdBaseFile::open(SdBaseFile* dirFile, const char *path, uint8_t oflag) {
bool SdBaseFile::open(SdBaseFile *dirFile, const char *path, uint8_t oflag) {
uint8_t dname[11];
SdBaseFile dir1, dir2;
SdBaseFile *parent = dirFile, *sub = &dir1;
@ -605,7 +601,7 @@ bool SdBaseFile::open(SdBaseFile* dirFile, const char *path, uint8_t oflag) {
}
// open with filename in dname
bool SdBaseFile::open(SdBaseFile* dirFile, const uint8_t dname[11], uint8_t oflag) {
bool SdBaseFile::open(SdBaseFile *dirFile, const uint8_t dname[11], uint8_t oflag) {
bool emptyFound = false, fileFound = false;
uint8_t index;
dir_t *p;
@ -696,9 +692,7 @@ bool SdBaseFile::open(SdBaseFile* dirFile, const uint8_t dname[11], uint8_t ofla
* See open() by path for definition of flags.
* \return true for success or false for failure.
*/
bool SdBaseFile::open(SdBaseFile* dirFile, uint16_t index, uint8_t oflag) {
dir_t *p;
bool SdBaseFile::open(SdBaseFile *dirFile, uint16_t index, uint8_t oflag) {
vol_ = dirFile->vol_;
// error if already open
@ -711,7 +705,7 @@ bool SdBaseFile::open(SdBaseFile* dirFile, uint16_t index, uint8_t oflag) {
if (!dirFile->seekSet(32 * index)) return false;
// read entry into cache
p = dirFile->readDirCache();
dir_t *p = dirFile->readDirCache();
if (!p) return false;
// error if empty slot or '.' or '..'
@ -784,10 +778,7 @@ bool SdBaseFile::openCachedEntry(uint8_t dirIndex, uint8_t oflag) {
* See open() by path for definition of flags.
* \return true for success or false for failure.
*/
bool SdBaseFile::openNext(SdBaseFile* dirFile, uint8_t oflag) {
dir_t *p;
uint8_t index;
bool SdBaseFile::openNext(SdBaseFile *dirFile, uint8_t oflag) {
if (!dirFile) return false;
// error if already open
@ -796,10 +787,10 @@ bool SdBaseFile::openNext(SdBaseFile* dirFile, uint8_t oflag) {
vol_ = dirFile->vol_;
while (1) {
index = 0xF & (dirFile->curPosition_ >> 5);
uint8_t index = 0xF & (dirFile->curPosition_ >> 5);
// read entry into cache
p = dirFile->readDirCache();
dir_t *p = dirFile->readDirCache();
if (!p) return false;
// done if last entry
@ -825,9 +816,8 @@ bool SdBaseFile::openNext(SdBaseFile* dirFile, uint8_t oflag) {
*
* \return true for success, false for failure.
*/
bool SdBaseFile::openParent(SdBaseFile* dir) {
bool SdBaseFile::openParent(SdBaseFile *dir) {
dir_t entry;
dir_t *p;
SdBaseFile file;
uint32_t c;
uint32_t cluster;
@ -850,7 +840,7 @@ bool SdBaseFile::openParent(SdBaseFile* dir) {
// first block of parent dir
if (!vol_->cacheRawBlock(lbn, SdVolume::CACHE_FOR_READ)) return false;
p = &vol_->cacheBuffer_.dir[1];
dir_t *p = &vol_->cacheBuffer_.dir[1];
// verify name for '../..'
if (p->name[0] != '.' || p->name[1] != '.') return false;
// '..' is pointer to first cluster of parent. open '../..' to find parent
@ -881,7 +871,7 @@ bool SdBaseFile::openParent(SdBaseFile* dir) {
* Reasons for failure include the file is already open, the FAT volume has
* not been initialized or it a FAT12 volume.
*/
bool SdBaseFile::openRoot(SdVolume* vol) {
bool SdBaseFile::openRoot(SdVolume *vol) {
// error if file is already open
if (isOpen()) return false;
@ -1008,7 +998,7 @@ int16_t SdBaseFile::read() {
* read() called before a file has been opened, corrupt file system
* or an I/O error occurred.
*/
int16_t SdBaseFile::read(void* buf, uint16_t nbyte) {
int16_t SdBaseFile::read(void *buf, uint16_t nbyte) {
uint8_t *dst = reinterpret_cast<uint8_t*>(buf);
uint16_t offset, toRead;
uint32_t block; // raw device block number
@ -1136,7 +1126,7 @@ int8_t SdBaseFile::readDir(dir_t *dir, char *longFilename) {
// Reset n to the start of the long name
n = 0;
for (uint16_t idx = 0; idx < (LONG_FILENAME_LENGTH) / 2; idx += 2) { // idx is fixed since FAT LFN always contains UTF-16LE encoding
uint16_t utf16_ch = longFilename[idx] | (longFilename[idx + 1] << 8);
const uint16_t utf16_ch = longFilename[idx] | (longFilename[idx + 1] << 8);
if (0xD800 == (utf16_ch & 0xF800)) // Surrogate pair - encode as '_'
longFilename[n++] = '_';
else if (0 == (utf16_ch & 0xFF80)) // Encode as 1-byte UTF-8 char
@ -1199,12 +1189,11 @@ dir_t* SdBaseFile::readDirCache() {
bool SdBaseFile::remove() {
if (ENABLED(SDCARD_READONLY)) return false;
dir_t *d;
// free any clusters - will fail if read-only or directory
if (!truncate(0)) return false;
// cache directory entry
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
dir_t *d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
if (!d) return false;
// mark entry deleted
@ -1235,7 +1224,7 @@ bool SdBaseFile::remove() {
* \a dirFile is not a directory, \a path is not found
* or an I/O error occurred.
*/
bool SdBaseFile::remove(SdBaseFile* dirFile, const char *path) {
bool SdBaseFile::remove(SdBaseFile *dirFile, const char *path) {
if (ENABLED(SDCARD_READONLY)) return false;
SdBaseFile file;
@ -1252,13 +1241,10 @@ bool SdBaseFile::remove(SdBaseFile* dirFile, const char *path) {
* Reasons for failure include \a dirFile is not open or is not a directory
* file, newPath is invalid or already exists, or an I/O error occurs.
*/
bool SdBaseFile::rename(SdBaseFile* dirFile, const char *newPath) {
bool SdBaseFile::rename(SdBaseFile *dirFile, const char *newPath) {
if (ENABLED(SDCARD_READONLY)) return false;
dir_t entry;
uint32_t dirCluster = 0;
SdBaseFile file;
dir_t *d;
// must be an open file or subdirectory
if (!(isFile() || isSubDir())) return false;
@ -1268,16 +1254,18 @@ bool SdBaseFile::rename(SdBaseFile* dirFile, const char *newPath) {
// sync() and cache directory entry
sync();
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
dir_t *d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
if (!d) return false;
// save directory entry
dir_t entry;
memcpy(&entry, d, sizeof(entry));
// mark entry deleted
d->name[0] = DIR_NAME_DELETED;
// make directory entry for new path
SdBaseFile file;
if (isFile()) {
if (!file.open(dirFile, newPath, O_CREAT | O_EXCL | O_WRITE)) {
goto restore;
@ -1536,8 +1524,7 @@ bool SdBaseFile::sync() {
*
* \return true for success, false for failure.
*/
bool SdBaseFile::timestamp(SdBaseFile* file) {
dir_t *d;
bool SdBaseFile::timestamp(SdBaseFile *file) {
dir_t dir;
// get timestamps
@ -1546,7 +1533,7 @@ bool SdBaseFile::timestamp(SdBaseFile* file) {
// update directory fields
if (!sync()) return false;
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
dir_t *d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
if (!d) return false;
// copy timestamps
@ -1599,7 +1586,6 @@ bool SdBaseFile::timestamp(uint8_t flags, uint16_t year, uint8_t month,
if (ENABLED(SDCARD_READONLY)) return false;
uint16_t dirDate, dirTime;
dir_t *d;
if (!isOpen()
|| year < 1980
@ -1616,7 +1602,7 @@ bool SdBaseFile::timestamp(uint8_t flags, uint16_t year, uint8_t month,
// update directory entry
if (!sync()) return false;
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
dir_t *d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
if (!d) return false;
dirDate = FAT_DATE(year, month, day);
@ -1710,7 +1696,7 @@ bool SdBaseFile::truncate(uint32_t length) {
* include write() is called before a file has been opened, write is called
* for a read-only file, device is full, a corrupt file system or an I/O error.
*/
int16_t SdBaseFile::write(const void* buf, uint16_t nbyte) {
int16_t SdBaseFile::write(const void *buf, uint16_t nbyte) {
#if ENABLED(SDCARD_READONLY)
writeError = true; return -1;
#endif

36
Marlin/src/sd/SdBaseFile.h
View File

@ -189,7 +189,7 @@ class SdBaseFile {
bool close();
bool contiguousRange(uint32_t *bgnBlock, uint32_t *endBlock);
bool createContiguous(SdBaseFile* dirFile,
bool createContiguous(SdBaseFile *dirFile,
const char *path, uint32_t size);
/**
* \return The current cluster number for a file or directory.
@ -204,7 +204,7 @@ class SdBaseFile {
/**
* \return Current working directory
*/
static SdBaseFile* cwd() { return cwd_; }
static SdBaseFile *cwd() { return cwd_; }
/**
* Set the date/time callback function
@ -286,27 +286,27 @@ class SdBaseFile {
bool getDosName(char * const name);
void ls(uint8_t flags = 0, uint8_t indent = 0);
bool mkdir(SdBaseFile* dir, const char *path, bool pFlag = true);
bool open(SdBaseFile* dirFile, uint16_t index, uint8_t oflag);
bool open(SdBaseFile* dirFile, const char *path, uint8_t oflag);
bool mkdir(SdBaseFile *dir, const char *path, bool pFlag = true);
bool open(SdBaseFile *dirFile, uint16_t index, uint8_t oflag);
bool open(SdBaseFile *dirFile, const char *path, uint8_t oflag);
bool open(const char *path, uint8_t oflag = O_READ);
bool openNext(SdBaseFile* dirFile, uint8_t oflag);
bool openRoot(SdVolume* vol);
bool openNext(SdBaseFile *dirFile, uint8_t oflag);
bool openRoot(SdVolume *vol);
int peek();
static void printFatDate(uint16_t fatDate);
static void printFatTime(uint16_t fatTime);
bool printName();
int16_t read();
int16_t read(void* buf, uint16_t nbyte);
int16_t read(void *buf, uint16_t nbyte);
int8_t readDir(dir_t *dir, char *longFilename);
static bool remove(SdBaseFile* dirFile, const char *path);
static bool remove(SdBaseFile *dirFile, const char *path);
bool remove();
/**
* Set the file's current position to zero.
*/
void rewind() { seekSet(0); }
bool rename(SdBaseFile* dirFile, const char *newPath);
bool rename(SdBaseFile *dirFile, const char *newPath);
bool rmdir();
bool rmRfStar();
@ -325,7 +325,7 @@ class SdBaseFile {
bool seekEnd(const int32_t offset = 0) { return seekSet(fileSize_ + offset); }
bool seekSet(const uint32_t pos);
bool sync();
bool timestamp(SdBaseFile* file);
bool timestamp(SdBaseFile *file);
bool timestamp(uint8_t flag, uint16_t year, uint8_t month, uint8_t day,
uint8_t hour, uint8_t minute, uint8_t second);
@ -341,11 +341,11 @@ class SdBaseFile {
* \return SdVolume that contains this file.
*/
SdVolume* volume() const { return vol_; }
int16_t write(const void* buf, uint16_t nbyte);
int16_t write(const void *buf, uint16_t nbyte);
private:
friend class SdFat; // allow SdFat to set cwd_
static SdBaseFile* cwd_; // global pointer to cwd dir
static SdBaseFile *cwd_; // global pointer to cwd dir
// data time callback function
static void (*dateTime_)(uint16_t *date, uint16_t *time);
@ -364,21 +364,21 @@ class SdBaseFile {
uint8_t dirIndex_; // index of directory entry in dirBlock
uint32_t fileSize_; // file size in bytes
uint32_t firstCluster_; // first cluster of file
SdVolume* vol_; // volume where file is located
SdVolume *vol_; // volume where file is located
/**
* EXPERIMENTAL - Don't use!
*/
//bool openParent(SdBaseFile* dir);
//bool openParent(SdBaseFile *dir);
// private functions
bool addCluster();
bool addDirCluster();
dir_t* cacheDirEntry(uint8_t action);
int8_t lsPrintNext(uint8_t flags, uint8_t indent);
static bool make83Name(const char *str, uint8_t *name, const char** ptr);
bool mkdir(SdBaseFile* parent, const uint8_t dname[11]);
bool open(SdBaseFile* dirFile, const uint8_t dname[11], uint8_t oflag);
static bool make83Name(const char *str, uint8_t *name, const char **ptr);
bool mkdir(SdBaseFile *parent, const uint8_t dname[11]);
bool open(SdBaseFile *dirFile, const uint8_t dname[11], uint8_t oflag);
bool openCachedEntry(uint8_t cacheIndex, uint8_t oflags);
dir_t* readDirCache();
};

2
Marlin/src/sd/SdFile.cpp
View File

@ -60,7 +60,7 @@ SdFile::SdFile(const char *path, uint8_t oflag) : SdBaseFile(path, oflag) { }
* include write() is called before a file has been opened, write is called
* for a read-only file, device is full, a corrupt file system or an I/O error.
*/
int16_t SdFile::write(const void* buf, uint16_t nbyte) { return SdBaseFile::write(buf, nbyte); }
int16_t SdFile::write(const void *buf, uint16_t nbyte) { return SdBaseFile::write(buf, nbyte); }
/**
* Write a byte to a file. Required by the Arduino Print class.

4
Marlin/src/sd/SdFile.h
View File

@ -46,10 +46,10 @@ class SdFile : public SdBaseFile {
#if ARDUINO >= 100
size_t write(uint8_t b);
#else
void write(uint8_t b);
void write(uint8_t b);
#endif
int16_t write(const void* buf, uint16_t nbyte);
int16_t write(const void *buf, uint16_t nbyte);
void write(const char *str);
void write_P(PGM_P str);
void writeln_P(PGM_P str);

8
Marlin/src/sd/SdVolume.h
View File

@ -90,8 +90,8 @@ class SdVolume {
* Reasons for failure include not finding a valid partition, not finding
* a valid FAT file system or an I/O error.
*/
bool init(Sd2Card* dev) { return init(dev, 1) ? true : init(dev, 0); }
bool init(Sd2Card* dev, uint8_t part);
bool init(Sd2Card *dev) { return init(dev, 1) ? true : init(dev, 0); }
bool init(Sd2Card *dev, uint8_t part);
// inline functions that return volume info
uint8_t blocksPerCluster() const { return blocksPerCluster_; } //> \return The volume's cluster size in blocks.
@ -138,13 +138,13 @@ class SdVolume {
#if USE_MULTIPLE_CARDS
cache_t cacheBuffer_; // 512 byte cache for device blocks
uint32_t cacheBlockNumber_; // Logical number of block in the cache
Sd2Card* sdCard_; // Sd2Card object for cache
Sd2Card *sdCard_; // Sd2Card object for cache
bool cacheDirty_; // cacheFlush() will write block if true
uint32_t cacheMirrorBlock_; // block number for mirror FAT
#else
static cache_t cacheBuffer_; // 512 byte cache for device blocks
static uint32_t cacheBlockNumber_; // Logical number of block in the cache
static Sd2Card* sdCard_; // Sd2Card object for cache
static Sd2Card *sdCard_; // Sd2Card object for cache
static bool cacheDirty_; // cacheFlush() will write block if true
static uint32_t cacheMirrorBlock_; // block number for mirror FAT
#endif

8
Marlin/src/sd/cardreader.cpp
View File

@ -723,9 +723,9 @@ void CardReader::report_status() {
}
void CardReader::write_command(char * const buf) {
char* begin = buf;
char* npos = nullptr;
char* end = buf + strlen(buf) - 1;
char *begin = buf;
char *npos = nullptr;
char *end = buf + strlen(buf) - 1;
file.writeError = false;
if ((npos = strchr(buf, 'N'))) {
@ -845,7 +845,7 @@ uint16_t CardReader::countFilesInWorkDir() {
*
* A nullptr result indicates an unrecoverable error.
*/
const char* CardReader::diveToFile(const bool update_cwd, SdFile*& diveDir, const char * const path, const bool echo/*=false*/) {
const char* CardReader::diveToFile(const bool update_cwd, SdFile* &diveDir, const char * const path, const bool echo/*=false*/) {
// Track both parent and subfolder
static SdFile newDir1, newDir2;
SdFile *sub = &newDir1, *startDir;

6
Marlin/src/sd/cardreader.h
View File

@ -141,7 +141,7 @@ public:
static inline uint8_t percentDone() { return (isFileOpen() && filesize) ? sdpos / ((filesize + 99) / 100) : 0; }
// Helper for open and remove
static const char* diveToFile(const bool update_cwd, SdFile*& curDir, const char * const path, const bool echo=false);
static const char* diveToFile(const bool update_cwd, SdFile* &curDir, const char * const path, const bool echo=false);
#if ENABLED(SDCARD_SORT_ALPHA)
static void presort();
@ -168,8 +168,8 @@ public:
static inline void setIndex(const uint32_t index) { file.seekSet((sdpos = index)); }
static inline char* getWorkDirName() { workDir.getDosName(filename); return filename; }
static inline int16_t get() { int16_t out = (int16_t)file.read(); sdpos = file.curPosition(); return out; }
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; }
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; }
static Sd2Card& getSd2Card() { return sd2card; }