ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Externals/FatFs: Avoid conflicts with Windows.h.

This commit is contained in:
Admiral H. Curtiss 2022-04-17 02:39:06 +02:00
parent bd02356e49
commit f43ffca488
No known key found for this signature in database
GPG Key ID: F051B4C4044F33FB
2 changed files with 131 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

186
Externals/FatFs/ff.c vendored
View File

@ -728,13 +728,13 @@ static int dbc_2nd (BYTE c)
#if FF_USE_LFN #if FF_USE_LFN
/* Get a Unicode code point from the TCHAR string in defined API encodeing */ /* Get a Unicode code point from the FATFS_TCHAR string in defined API encodeing */
static DWORD tchar2uni ( /* Returns a character in UTF-16 encoding (>=0x10000 on surrogate pair, 0xFFFFFFFF on decode error) */ static DWORD tchar2uni ( /* Returns a character in UTF-16 encoding (>=0x10000 on surrogate pair, 0xFFFFFFFF on decode error) */
const TCHAR** str /* Pointer to pointer to TCHAR string in configured encoding */ const FATFS_TCHAR** str /* Pointer to pointer to FATFS_TCHAR string in configured encoding */
) )
{ {
DWORD uc; DWORD uc;
const TCHAR *p = *str; const FATFS_TCHAR *p = *str;
#if FF_LFN_UNICODE == 1 /* UTF-16 input */ #if FF_LFN_UNICODE == 1 /* UTF-16 input */
WCHAR wc; WCHAR wc;
@ -771,7 +771,7 @@ static DWORD tchar2uni ( /* Returns a character in UTF-16 encoding (>=0x10000 on
} }
#elif FF_LFN_UNICODE == 3 /* UTF-32 input */ #elif FF_LFN_UNICODE == 3 /* UTF-32 input */
uc = (TCHAR)*p++; /* Get a unit */ uc = (FATFS_TCHAR)*p++; /* Get a unit */
if (uc >= 0x110000 || IsSurrogate(uc)) return 0xFFFFFFFF; /* Wrong code? */ if (uc >= 0x110000 || IsSurrogate(uc)) return 0xFFFFFFFF; /* Wrong code? */
if (uc >= 0x010000) uc = 0xD800DC00 | ((uc - 0x10000) << 6 & 0x3FF0000) | (uc & 0x3FF); /* Make a surrogate pair if needed */ if (uc >= 0x010000) uc = 0xD800DC00 | ((uc - 0x10000) << 6 & 0x3FF0000) | (uc & 0x3FF); /* Make a surrogate pair if needed */
@ -800,7 +800,7 @@ static DWORD tchar2uni ( /* Returns a character in UTF-16 encoding (>=0x10000 on
/* Store a Unicode char in defined API encoding */ /* Store a Unicode char in defined API encoding */
static UINT put_utf ( /* Returns number of encoding units written (0:buffer overflow or wrong encoding) */ static UINT put_utf ( /* Returns number of encoding units written (0:buffer overflow or wrong encoding) */
DWORD chr, /* UTF-16 encoded character (Surrogate pair if >=0x10000) */ DWORD chr, /* UTF-16 encoded character (Surrogate pair if >=0x10000) */
TCHAR* buf, /* Output buffer */ FATFS_TCHAR* buf, /* Output buffer */
UINT szb /* Size of the buffer */ UINT szb /* Size of the buffer */
) )
{ {
@ -824,20 +824,20 @@ static UINT put_utf ( /* Returns number of encoding units written (0:buffer over
if (chr < 0x80) { /* Single byte code? */ if (chr < 0x80) { /* Single byte code? */
if (szb < 1) return 0; /* Buffer overflow? */ if (szb < 1) return 0; /* Buffer overflow? */
*buf = (TCHAR)chr; *buf = (FATFS_TCHAR)chr;
return 1; return 1;
} }
if (chr < 0x800) { /* 2-byte sequence? */ if (chr < 0x800) { /* 2-byte sequence? */
if (szb < 2) return 0; /* Buffer overflow? */ if (szb < 2) return 0; /* Buffer overflow? */
*buf++ = (TCHAR)(0xC0 | (chr >> 6 & 0x1F)); *buf++ = (FATFS_TCHAR)(0xC0 | (chr >> 6 & 0x1F));
*buf++ = (TCHAR)(0x80 | (chr >> 0 & 0x3F)); *buf++ = (FATFS_TCHAR)(0x80 | (chr >> 0 & 0x3F));
return 2; return 2;
} }
if (chr < 0x10000) { /* 3-byte sequence? */ if (chr < 0x10000) { /* 3-byte sequence? */
if (szb < 3 || IsSurrogate(chr)) return 0; /* Buffer overflow or wrong code? */ if (szb < 3 || IsSurrogate(chr)) return 0; /* Buffer overflow or wrong code? */
*buf++ = (TCHAR)(0xE0 | (chr >> 12 & 0x0F)); *buf++ = (FATFS_TCHAR)(0xE0 | (chr >> 12 & 0x0F));
*buf++ = (TCHAR)(0x80 | (chr >> 6 & 0x3F)); *buf++ = (FATFS_TCHAR)(0x80 | (chr >> 6 & 0x3F));
*buf++ = (TCHAR)(0x80 | (chr >> 0 & 0x3F)); *buf++ = (FATFS_TCHAR)(0x80 | (chr >> 0 & 0x3F));
return 3; return 3;
} }
/* 4-byte sequence */ /* 4-byte sequence */
@ -846,10 +846,10 @@ static UINT put_utf ( /* Returns number of encoding units written (0:buffer over
chr = (chr & 0xFFFF) - 0xDC00; /* Get low 10 bits */ chr = (chr & 0xFFFF) - 0xDC00; /* Get low 10 bits */
if (hc >= 0x100000 || chr >= 0x400) return 0; /* Wrong surrogate? */ if (hc >= 0x100000 || chr >= 0x400) return 0; /* Wrong surrogate? */
chr = (hc | chr) + 0x10000; chr = (hc | chr) + 0x10000;
*buf++ = (TCHAR)(0xF0 | (chr >> 18 & 0x07)); *buf++ = (FATFS_TCHAR)(0xF0 | (chr >> 18 & 0x07));
*buf++ = (TCHAR)(0x80 | (chr >> 12 & 0x3F)); *buf++ = (FATFS_TCHAR)(0x80 | (chr >> 12 & 0x3F));
*buf++ = (TCHAR)(0x80 | (chr >> 6 & 0x3F)); *buf++ = (FATFS_TCHAR)(0x80 | (chr >> 6 & 0x3F));
*buf++ = (TCHAR)(0x80 | (chr >> 0 & 0x3F)); *buf++ = (FATFS_TCHAR)(0x80 | (chr >> 0 & 0x3F));
return 4; return 4;
#elif FF_LFN_UNICODE == 3 /* UTF-32 output */ #elif FF_LFN_UNICODE == 3 /* UTF-32 output */
@ -862,7 +862,7 @@ static UINT put_utf ( /* Returns number of encoding units written (0:buffer over
if (hc >= 0x100000 || chr >= 0x400) return 0; /* Wrong surrogate? */ if (hc >= 0x100000 || chr >= 0x400) return 0; /* Wrong surrogate? */
chr = (hc | chr) + 0x10000; chr = (hc | chr) + 0x10000;
} }
*buf++ = (TCHAR)chr; *buf++ = (FATFS_TCHAR)chr;
return 1; return 1;
#else /* ANSI/OEM output */ #else /* ANSI/OEM output */
@ -872,11 +872,11 @@ static UINT put_utf ( /* Returns number of encoding units written (0:buffer over
if (wc >= 0x100) { /* Is this a DBC? */ if (wc >= 0x100) { /* Is this a DBC? */
if (szb < 2) return 0; if (szb < 2) return 0;
*buf++ = (char)(wc >> 8); /* Store DBC 1st byte */ *buf++ = (char)(wc >> 8); /* Store DBC 1st byte */
*buf++ = (TCHAR)wc; /* Store DBC 2nd byte */ *buf++ = (FATFS_TCHAR)wc; /* Store DBC 2nd byte */
return 2; return 2;
} }
if (wc == 0 || szb < 1) return 0; /* Invalid char or buffer overflow? */ if (wc == 0 || szb < 1) return 0; /* Invalid char or buffer overflow? */
*buf++ = (TCHAR)wc; /* Store the character */ *buf++ = (FATFS_TCHAR)wc; /* Store the character */
return 1; return 1;
#endif #endif
} }
@ -2595,7 +2595,7 @@ static void get_fileinfo (
FATFS *fs = dp->obj.fs; FATFS *fs = dp->obj.fs;
UINT nw; UINT nw;
#else #else
TCHAR c; FATFS_TCHAR c;
#endif #endif
@ -2668,7 +2668,7 @@ static void get_fileinfo (
if (nw == 0) { di = 0; break; } /* Buffer overflow? */ if (nw == 0) { di = 0; break; } /* Buffer overflow? */
di += nw; di += nw;
#else /* ANSI/OEM output */ #else /* ANSI/OEM output */
fno->altname[di++] = (TCHAR)wc; /* Store it without any conversion */ fno->altname[di++] = (FATFS_TCHAR)wc; /* Store it without any conversion */
#endif #endif
} }
fno->altname[di] = 0; /* Terminate the SFN (null string means SFN is invalid) */ fno->altname[di] = 0; /* Terminate the SFN (null string means SFN is invalid) */
@ -2681,7 +2681,7 @@ static void get_fileinfo (
wc = (WCHAR)fno->altname[si]; wc = (WCHAR)fno->altname[si];
if (wc == '.') lcf = NS_EXT; if (wc == '.') lcf = NS_EXT;
if (IsUpper(wc) && (dp->dir[DIR_NTres] & lcf)) wc += 0x20; if (IsUpper(wc) && (dp->dir[DIR_NTres] & lcf)) wc += 0x20;
fno->fname[di] = (TCHAR)wc; fno->fname[di] = (FATFS_TCHAR)wc;
} }
} }
fno->fname[di] = 0; /* Terminate the LFN */ fno->fname[di] = 0; /* Terminate the LFN */
@ -2691,7 +2691,7 @@ static void get_fileinfo (
#else /* Non-LFN configuration */ #else /* Non-LFN configuration */
si = di = 0; si = di = 0;
while (si < 11) { /* Copy name body and extension */ while (si < 11) { /* Copy name body and extension */
c = (TCHAR)dp->dir[si++]; c = (FATFS_TCHAR)dp->dir[si++];
if (c == ' ') continue; /* Skip padding spaces */ if (c == ' ') continue; /* Skip padding spaces */
if (c == RDDEM) c = DDEM; /* Restore replaced DDEM character */ if (c == RDDEM) c = DDEM; /* Restore replaced DDEM character */
if (si == 9) fno->fname[di++] = '.';/* Insert a . if extension is exist */ if (si == 9) fno->fname[di++] = '.';/* Insert a . if extension is exist */
@ -2719,7 +2719,7 @@ static void get_fileinfo (
static DWORD get_achar ( /* Get a character and advance ptr */ static DWORD get_achar ( /* Get a character and advance ptr */
const TCHAR** ptr /* Pointer to pointer to the ANSI/OEM or Unicode string */ const FATFS_TCHAR** ptr /* Pointer to pointer to the ANSI/OEM or Unicode string */
) )
{ {
DWORD chr; DWORD chr;
@ -2750,13 +2750,13 @@ static DWORD get_achar ( /* Get a character and advance ptr */
static int pattern_match ( /* 0:mismatched, 1:matched */ static int pattern_match ( /* 0:mismatched, 1:matched */
const TCHAR* pat, /* Matching pattern */ const FATFS_TCHAR* pat, /* Matching pattern */
const TCHAR* nam, /* String to be tested */ const FATFS_TCHAR* nam, /* String to be tested */
UINT skip, /* Number of pre-skip chars (number of ?s, b8:infinite (* specified)) */ UINT skip, /* Number of pre-skip chars (number of ?s, b8:infinite (* specified)) */
UINT recur /* Recursion count */ UINT recur /* Recursion count */
) )
{ {
const TCHAR *pptr, *nptr; const FATFS_TCHAR *pptr, *nptr;
DWORD pchr, nchr; DWORD pchr, nchr;
UINT sk; UINT sk;
@ -2800,7 +2800,7 @@ static int pattern_match ( /* 0:mismatched, 1:matched */
static FRESULT create_name ( /* FR_OK: successful, FR_INVALID_NAME: could not create */ static FRESULT create_name ( /* FR_OK: successful, FR_INVALID_NAME: could not create */
DIR* dp, /* Pointer to the directory object */ DIR* dp, /* Pointer to the directory object */
const TCHAR** path /* Pointer to pointer to the segment in the path string */ const FATFS_TCHAR** path /* Pointer to pointer to the segment in the path string */
) )
{ {
#if FF_USE_LFN /* LFN configuration */ #if FF_USE_LFN /* LFN configuration */
@ -2808,7 +2808,7 @@ static FRESULT create_name ( /* FR_OK: successful, FR_INVALID_NAME: could not cr
WCHAR wc, *lfn; WCHAR wc, *lfn;
DWORD uc; DWORD uc;
UINT i, ni, si, di; UINT i, ni, si, di;
const TCHAR *p; const FATFS_TCHAR *p;
/* Create LFN into LFN working buffer */ /* Create LFN into LFN working buffer */
@ -3002,7 +3002,7 @@ static FRESULT create_name ( /* FR_OK: successful, FR_INVALID_NAME: could not cr
static FRESULT follow_path ( /* FR_OK(0): successful, !=0: error code */ static FRESULT follow_path ( /* FR_OK(0): successful, !=0: error code */
DIR* dp, /* Directory object to return last directory and found object */ DIR* dp, /* Directory object to return last directory and found object */
const TCHAR* path /* Full-path string to find a file or directory */ const FATFS_TCHAR* path /* Full-path string to find a file or directory */
) )
{ {
FRESULT res; FRESULT res;
@ -3088,11 +3088,11 @@ static FRESULT follow_path ( /* FR_OK(0): successful, !=0: error code */
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
static int get_ldnumber ( /* Returns logical drive number (-1:invalid drive number or null pointer) */ static int get_ldnumber ( /* Returns logical drive number (-1:invalid drive number or null pointer) */
const TCHAR** path /* Pointer to pointer to the path name */ const FATFS_TCHAR** path /* Pointer to pointer to the path name */
) )
{ {
const TCHAR *tp, *tt; const FATFS_TCHAR *tp, *tt;
TCHAR tc; FATFS_TCHAR tc;
int i; int i;
int vol = -1; int vol = -1;
#if FF_STR_VOLUME_ID /* Find string volume ID */ #if FF_STR_VOLUME_ID /* Find string volume ID */
@ -3118,7 +3118,7 @@ static int get_ldnumber ( /* Returns logical drive number (-1:invalid drive numb
c = *sp++; tc = *tp++; c = *sp++; tc = *tp++;
if (IsLower(c)) c -= 0x20; if (IsLower(c)) c -= 0x20;
if (IsLower(tc)) tc -= 0x20; if (IsLower(tc)) tc -= 0x20;
} while (c && (TCHAR)c == tc); } while (c && (FATFS_TCHAR)c == tc);
} while ((c || tp != tt) && ++i < FF_VOLUMES); /* Repeat for each id until pattern match */ } while ((c || tp != tt) && ++i < FF_VOLUMES); /* Repeat for each id until pattern match */
} }
#endif #endif
@ -3138,7 +3138,7 @@ static int get_ldnumber ( /* Returns logical drive number (-1:invalid drive numb
c = *sp++; tc = *(++tt); c = *sp++; tc = *(++tt);
if (IsLower(c)) c -= 0x20; if (IsLower(c)) c -= 0x20;
if (IsLower(tc)) tc -= 0x20; if (IsLower(tc)) tc -= 0x20;
} while (c && (TCHAR)c == tc); } while (c && (FATFS_TCHAR)c == tc);
} while ((c || (tc != '/' && !IsTerminator(tc))) && ++i < FF_VOLUMES); /* Repeat for each ID until pattern match */ } while ((c || (tc != '/' && !IsTerminator(tc))) && ++i < FF_VOLUMES); /* Repeat for each ID until pattern match */
if (i < FF_VOLUMES) { /* If a volume ID is found, get the drive number and strip it */ if (i < FF_VOLUMES) { /* If a volume ID is found, get the drive number and strip it */
vol = i; /* Drive number */ vol = i; /* Drive number */
@ -3330,7 +3330,7 @@ static UINT find_volume ( /* Returns BS status found in the hosting drive */
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
static FRESULT mount_volume ( /* FR_OK(0): successful, !=0: an error occurred */ static FRESULT mount_volume ( /* FR_OK(0): successful, !=0: an error occurred */
const TCHAR** path, /* Pointer to pointer to the path name (drive number) */ const FATFS_TCHAR** path, /* Pointer to pointer to the path name (drive number) */
FATFS** rfs, /* Pointer to pointer to the found filesystem object */ FATFS** rfs, /* Pointer to pointer to the found filesystem object */
BYTE mode /* !=0: Check write protection for write access */ BYTE mode /* !=0: Check write protection for write access */
) )
@ -3604,14 +3604,14 @@ static FRESULT validate ( /* Returns FR_OK or FR_INVALID_OBJECT */
FRESULT f_mount ( FRESULT f_mount (
FATFS* fs, /* Pointer to the filesystem object to be registered (NULL:unmount)*/ FATFS* fs, /* Pointer to the filesystem object to be registered (NULL:unmount)*/
const TCHAR* path, /* Logical drive number to be mounted/unmounted */ const FATFS_TCHAR* path, /* Logical drive number to be mounted/unmounted */
BYTE opt /* Mount option: 0=Do not mount (delayed mount), 1=Mount immediately */ BYTE opt /* Mount option: 0=Do not mount (delayed mount), 1=Mount immediately */
) )
{ {
FATFS *cfs; FATFS *cfs;
int vol; int vol;
FRESULT res; FRESULT res;
const TCHAR *rp = path; const FATFS_TCHAR *rp = path;
/* Get logical drive number */ /* Get logical drive number */
@ -3652,7 +3652,7 @@ FRESULT f_mount (
FRESULT f_open ( FRESULT f_open (
FIL* fp, /* Pointer to the blank file object */ FIL* fp, /* Pointer to the blank file object */
const TCHAR* path, /* Pointer to the file name */ const FATFS_TCHAR* path, /* Pointer to the file name */
BYTE mode /* Access mode and open mode flags */ BYTE mode /* Access mode and open mode flags */
) )
{ {
@ -4186,7 +4186,7 @@ FRESULT f_close (
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
FRESULT f_chdrive ( FRESULT f_chdrive (
const TCHAR* path /* Drive number to set */ const FATFS_TCHAR* path /* Drive number to set */
) )
{ {
int vol; int vol;
@ -4203,7 +4203,7 @@ FRESULT f_chdrive (
FRESULT f_chdir ( FRESULT f_chdir (
const TCHAR* path /* Pointer to the directory path */ const FATFS_TCHAR* path /* Pointer to the directory path */
) )
{ {
#if FF_STR_VOLUME_ID == 2 #if FF_STR_VOLUME_ID == 2
@ -4265,8 +4265,8 @@ FRESULT f_chdir (
#if FF_FS_RPATH >= 2 #if FF_FS_RPATH >= 2
FRESULT f_getcwd ( FRESULT f_getcwd (
TCHAR* buff, /* Pointer to the directory path */ FATFS_TCHAR* buff, /* Pointer to the directory path */
UINT len /* Size of buff in unit of TCHAR */ UINT len /* Size of buff in unit of FATFS_TCHAR */
) )
{ {
FRESULT res; FRESULT res;
@ -4274,7 +4274,7 @@ FRESULT f_getcwd (
FATFS *fs; FATFS *fs;
UINT i, n; UINT i, n;
DWORD ccl; DWORD ccl;
TCHAR *tp = buff; FATFS_TCHAR *tp = buff;
#if FF_VOLUMES >= 2 #if FF_VOLUMES >= 2
UINT vl; UINT vl;
#if FF_STR_VOLUME_ID #if FF_STR_VOLUME_ID
@ -4287,7 +4287,7 @@ FRESULT f_getcwd (
/* Get logical drive */ /* Get logical drive */
buff[0] = 0; /* Set null string to get current volume */ buff[0] = 0; /* Set null string to get current volume */
res = mount_volume((const TCHAR**)&buff, &fs, 0); /* Get current volume */ res = mount_volume((const FATFS_TCHAR**)&buff, &fs, 0); /* Get current volume */
if (res == FR_OK) { if (res == FR_OK) {
dj.obj.fs = fs; dj.obj.fs = fs;
INIT_NAMBUF(fs); INIT_NAMBUF(fs);
@ -4328,15 +4328,15 @@ FRESULT f_getcwd (
#if FF_STR_VOLUME_ID >= 1 /* String volume ID */ #if FF_STR_VOLUME_ID >= 1 /* String volume ID */
for (n = 0, vp = (const char*)VolumeStr[CurrVol]; vp[n]; n++) ; for (n = 0, vp = (const char*)VolumeStr[CurrVol]; vp[n]; n++) ;
if (i >= n + 2) { if (i >= n + 2) {
if (FF_STR_VOLUME_ID == 2) *tp++ = (TCHAR)'/'; if (FF_STR_VOLUME_ID == 2) *tp++ = (FATFS_TCHAR)'/';
for (vl = 0; vl < n; *tp++ = (TCHAR)vp[vl], vl++) ; for (vl = 0; vl < n; *tp++ = (FATFS_TCHAR)vp[vl], vl++) ;
if (FF_STR_VOLUME_ID == 1) *tp++ = (TCHAR)':'; if (FF_STR_VOLUME_ID == 1) *tp++ = (FATFS_TCHAR)':';
vl++; vl++;
} }
#else /* Numeric volume ID */ #else /* Numeric volume ID */
if (i >= 3) { if (i >= 3) {
*tp++ = (TCHAR)'0' + CurrVol; *tp++ = (FATFS_TCHAR)'0' + CurrVol;
*tp++ = (TCHAR)':'; *tp++ = (FATFS_TCHAR)':';
vl = 2; vl = 2;
} }
#endif #endif
@ -4530,7 +4530,7 @@ FRESULT f_lseek (
FRESULT f_opendir ( FRESULT f_opendir (
DIR* dp, /* Pointer to directory object to create */ DIR* dp, /* Pointer to directory object to create */
const TCHAR* path /* Pointer to the directory path */ const FATFS_TCHAR* path /* Pointer to the directory path */
) )
{ {
FRESULT res; FRESULT res;
@ -4688,8 +4688,8 @@ FRESULT f_findnext (
FRESULT f_findfirst ( FRESULT f_findfirst (
DIR* dp, /* Pointer to the blank directory object */ DIR* dp, /* Pointer to the blank directory object */
FILINFO* fno, /* Pointer to the file information structure */ FILINFO* fno, /* Pointer to the file information structure */
const TCHAR* path, /* Pointer to the directory to open */ const FATFS_TCHAR* path, /* Pointer to the directory to open */
const TCHAR* pattern /* Pointer to the matching pattern */ const FATFS_TCHAR* pattern /* Pointer to the matching pattern */
) )
{ {
FRESULT res; FRESULT res;
@ -4713,7 +4713,7 @@ FRESULT f_findfirst (
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
FRESULT f_stat ( FRESULT f_stat (
const TCHAR* path, /* Pointer to the file path */ const FATFS_TCHAR* path, /* Pointer to the file path */
FILINFO* fno /* Pointer to file information to return */ FILINFO* fno /* Pointer to file information to return */
) )
{ {
@ -4748,7 +4748,7 @@ FRESULT f_stat (
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
FRESULT f_getfree ( FRESULT f_getfree (
const TCHAR* path, /* Logical drive number */ const FATFS_TCHAR* path, /* Logical drive number */
DWORD* nclst, /* Pointer to a variable to return number of free clusters */ DWORD* nclst, /* Pointer to a variable to return number of free clusters */
FATFS** fatfs /* Pointer to return pointer to corresponding filesystem object */ FATFS** fatfs /* Pointer to return pointer to corresponding filesystem object */
) )
@ -4890,7 +4890,7 @@ FRESULT f_truncate (
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
FRESULT f_unlink ( FRESULT f_unlink (
const TCHAR* path /* Pointer to the file or directory path */ const FATFS_TCHAR* path /* Pointer to the file or directory path */
) )
{ {
FRESULT res; FRESULT res;
@ -4984,7 +4984,7 @@ FRESULT f_unlink (
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
FRESULT f_mkdir ( FRESULT f_mkdir (
const TCHAR* path /* Pointer to the directory path */ const FATFS_TCHAR* path /* Pointer to the directory path */
) )
{ {
FRESULT res; FRESULT res;
@ -5068,8 +5068,8 @@ FRESULT f_mkdir (
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
FRESULT f_rename ( FRESULT f_rename (
const TCHAR* path_old, /* Pointer to the object name to be renamed */ const FATFS_TCHAR* path_old, /* Pointer to the object name to be renamed */
const TCHAR* path_new /* Pointer to the new name */ const FATFS_TCHAR* path_new /* Pointer to the new name */
) )
{ {
FRESULT res; FRESULT res;
@ -5178,7 +5178,7 @@ FRESULT f_rename (
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
FRESULT f_chmod ( FRESULT f_chmod (
const TCHAR* path, /* Pointer to the file path */ const FATFS_TCHAR* path, /* Pointer to the file path */
BYTE attr, /* Attribute bits */ BYTE attr, /* Attribute bits */
BYTE mask /* Attribute mask to change */ BYTE mask /* Attribute mask to change */
) )
@ -5225,7 +5225,7 @@ FRESULT f_chmod (
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
FRESULT f_utime ( FRESULT f_utime (
const TCHAR* path, /* Pointer to the file/directory name */ const FATFS_TCHAR* path, /* Pointer to the file/directory name */
const FILINFO* fno /* Pointer to the timestamp to be set */ const FILINFO* fno /* Pointer to the timestamp to be set */
) )
{ {
@ -5272,8 +5272,8 @@ FRESULT f_utime (
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
FRESULT f_getlabel ( FRESULT f_getlabel (
const TCHAR* path, /* Logical drive number */ const FATFS_TCHAR* path, /* Logical drive number */
TCHAR* label, /* Buffer to store the volume label */ FATFS_TCHAR* label, /* Buffer to store the volume label */
DWORD* vsn /* Variable to store the volume serial number */ DWORD* vsn /* Variable to store the volume serial number */
) )
{ {
@ -5322,7 +5322,7 @@ FRESULT f_getlabel (
if (wc == 0) { di = 0; break; } /* Invalid char in current code page? */ if (wc == 0) { di = 0; break; } /* Invalid char in current code page? */
di += put_utf(wc, &label[di], 4); /* Store it in Unicode */ di += put_utf(wc, &label[di], 4); /* Store it in Unicode */
#else /* ANSI/OEM output */ #else /* ANSI/OEM output */
label[di++] = (TCHAR)wc; label[di++] = (FATFS_TCHAR)wc;
#endif #endif
} }
do { /* Truncate trailing spaces */ do { /* Truncate trailing spaces */
@ -5369,7 +5369,7 @@ FRESULT f_getlabel (
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
FRESULT f_setlabel ( FRESULT f_setlabel (
const TCHAR* label /* Volume label to set with heading logical drive number */ const FATFS_TCHAR* label /* Volume label to set with heading logical drive number */
) )
{ {
FRESULT res; FRESULT res;
@ -5800,7 +5800,7 @@ static FRESULT create_partition (
FRESULT f_mkfs ( FRESULT f_mkfs (
const TCHAR* path, /* Logical drive number */ const FATFS_TCHAR* path, /* Logical drive number */
const MKFS_PARM* opt, /* Format options */ const MKFS_PARM* opt, /* Format options */
void* work, /* Pointer to working buffer (null: use heap memory) */ void* work, /* Pointer to working buffer (null: use heap memory) */
UINT len /* Size of working buffer [byte] */ UINT len /* Size of working buffer [byte] */
@ -6335,14 +6335,14 @@ FRESULT f_fdisk (
/* Get a String from the File */ /* Get a String from the File */
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
TCHAR* f_gets ( FATFS_TCHAR* f_gets (
TCHAR* buff, /* Pointer to the buffer to store read string */ FATFS_TCHAR* buff, /* Pointer to the buffer to store read string */
int len, /* Size of string buffer (items) */ int len, /* Size of string buffer (items) */
FIL* fp /* Pointer to the file object */ FIL* fp /* Pointer to the file object */
) )
{ {
int nc = 0; int nc = 0;
TCHAR *p = buff; FATFS_TCHAR *p = buff;
BYTE s[4]; BYTE s[4];
UINT rc; UINT rc;
DWORD dc; DWORD dc;
@ -6407,32 +6407,32 @@ TCHAR* f_gets (
if (FF_USE_STRFUNC == 2 && dc == '\r') continue; /* Strip \r off if needed */ if (FF_USE_STRFUNC == 2 && dc == '\r') continue; /* Strip \r off if needed */
#if FF_LFN_UNICODE == 1 || FF_LFN_UNICODE == 3 /* Output it in UTF-16/32 encoding */ #if FF_LFN_UNICODE == 1 || FF_LFN_UNICODE == 3 /* Output it in UTF-16/32 encoding */
if (FF_LFN_UNICODE == 1 && dc >= 0x10000) { /* Out of BMP at UTF-16? */ if (FF_LFN_UNICODE == 1 && dc >= 0x10000) { /* Out of BMP at UTF-16? */
*p++ = (TCHAR)(0xD800 | ((dc >> 10) - 0x40)); nc++; /* Make and output high surrogate */ *p++ = (FATFS_TCHAR)(0xD800 | ((dc >> 10) - 0x40)); nc++; /* Make and output high surrogate */
dc = 0xDC00 | (dc & 0x3FF); /* Make low surrogate */ dc = 0xDC00 | (dc & 0x3FF); /* Make low surrogate */
} }
*p++ = (TCHAR)dc; nc++; *p++ = (FATFS_TCHAR)dc; nc++;
if (dc == '\n') break; /* End of line? */ if (dc == '\n') break; /* End of line? */
#elif FF_LFN_UNICODE == 2 /* Output it in UTF-8 encoding */ #elif FF_LFN_UNICODE == 2 /* Output it in UTF-8 encoding */
if (dc < 0x80) { /* Single byte? */ if (dc < 0x80) { /* Single byte? */
*p++ = (TCHAR)dc; *p++ = (FATFS_TCHAR)dc;
nc++; nc++;
if (dc == '\n') break; /* End of line? */ if (dc == '\n') break; /* End of line? */
} else { } else {
if (dc < 0x800) { /* 2-byte sequence? */ if (dc < 0x800) { /* 2-byte sequence? */
*p++ = (TCHAR)(0xC0 | (dc >> 6 & 0x1F)); *p++ = (FATFS_TCHAR)(0xC0 | (dc >> 6 & 0x1F));
*p++ = (TCHAR)(0x80 | (dc >> 0 & 0x3F)); *p++ = (FATFS_TCHAR)(0x80 | (dc >> 0 & 0x3F));
nc += 2; nc += 2;
} else { } else {
if (dc < 0x10000) { /* 3-byte sequence? */ if (dc < 0x10000) { /* 3-byte sequence? */
*p++ = (TCHAR)(0xE0 | (dc >> 12 & 0x0F)); *p++ = (FATFS_TCHAR)(0xE0 | (dc >> 12 & 0x0F));
*p++ = (TCHAR)(0x80 | (dc >> 6 & 0x3F)); *p++ = (FATFS_TCHAR)(0x80 | (dc >> 6 & 0x3F));
*p++ = (TCHAR)(0x80 | (dc >> 0 & 0x3F)); *p++ = (FATFS_TCHAR)(0x80 | (dc >> 0 & 0x3F));
nc += 3; nc += 3;
} else { /* 4-byte sequence? */ } else { /* 4-byte sequence? */
*p++ = (TCHAR)(0xF0 | (dc >> 18 & 0x07)); *p++ = (FATFS_TCHAR)(0xF0 | (dc >> 18 & 0x07));
*p++ = (TCHAR)(0x80 | (dc >> 12 & 0x3F)); *p++ = (FATFS_TCHAR)(0x80 | (dc >> 12 & 0x3F));
*p++ = (TCHAR)(0x80 | (dc >> 6 & 0x3F)); *p++ = (FATFS_TCHAR)(0x80 | (dc >> 6 & 0x3F));
*p++ = (TCHAR)(0x80 | (dc >> 0 & 0x3F)); *p++ = (FATFS_TCHAR)(0x80 | (dc >> 0 & 0x3F));
nc += 4; nc += 4;
} }
} }
@ -6447,7 +6447,7 @@ TCHAR* f_gets (
if (rc != 1) break; /* EOF? */ if (rc != 1) break; /* EOF? */
dc = s[0]; dc = s[0];
if (FF_USE_STRFUNC == 2 && dc == '\r') continue; if (FF_USE_STRFUNC == 2 && dc == '\r') continue;
*p++ = (TCHAR)dc; nc++; *p++ = (FATFS_TCHAR)dc; nc++;
if (dc == '\n') break; if (dc == '\n') break;
} }
#endif #endif
@ -6485,7 +6485,7 @@ typedef struct {
/* Buffered file write with code conversion */ /* Buffered file write with code conversion */
static void putc_bfd (putbuff* pb, TCHAR c) static void putc_bfd (putbuff* pb, FATFS_TCHAR c)
{ {
UINT n; UINT n;
int i, nc; int i, nc;
@ -6493,7 +6493,7 @@ static void putc_bfd (putbuff* pb, TCHAR c)
WCHAR hs, wc; WCHAR hs, wc;
#if FF_LFN_UNICODE == 2 #if FF_LFN_UNICODE == 2
DWORD dc; DWORD dc;
const TCHAR *tp; const FATFS_TCHAR *tp;
#endif #endif
#endif #endif
@ -6535,7 +6535,7 @@ static void putc_bfd (putbuff* pb, TCHAR c)
return; return;
} }
} }
tp = (const TCHAR*)pb->bs; tp = (const FATFS_TCHAR*)pb->bs;
dc = tchar2uni(&tp); /* UTF-8 ==> UTF-16 */ dc = tchar2uni(&tp); /* UTF-8 ==> UTF-16 */
if (dc == 0xFFFFFFFF) return; /* Wrong code? */ if (dc == 0xFFFFFFFF) return; /* Wrong code? */
wc = (WCHAR)dc; wc = (WCHAR)dc;
@ -6638,7 +6638,7 @@ static void putc_init (putbuff* pb, FIL* fp)
int f_putc ( int f_putc (
TCHAR c, /* A character to be output */ FATFS_TCHAR c, /* A character to be output */
FIL* fp /* Pointer to the file object */ FIL* fp /* Pointer to the file object */
) )
{ {
@ -6658,7 +6658,7 @@ int f_putc (
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
int f_puts ( int f_puts (
const TCHAR* str, /* Pointer to the string to be output */ const FATFS_TCHAR* str, /* Pointer to the string to be output */
FIL* fp /* Pointer to the file object */ FIL* fp /* Pointer to the file object */
) )
{ {
@ -6727,7 +6727,7 @@ static void ftoa (
char* buf, /* Buffer to output the floating point string */ char* buf, /* Buffer to output the floating point string */
double val, /* Value to output */ double val, /* Value to output */
int prec, /* Number of fractional digits */ int prec, /* Number of fractional digits */
TCHAR fmt /* Notation */ FATFS_TCHAR fmt /* Notation */
) )
{ {
int d; int d;
@ -6800,7 +6800,7 @@ static void ftoa (
int f_printf ( int f_printf (
FIL* fp, /* Pointer to the file object */ FIL* fp, /* Pointer to the file object */
const TCHAR* fmt, /* Pointer to the format string */ const FATFS_TCHAR* fmt, /* Pointer to the format string */
... /* Optional arguments... */ ... /* Optional arguments... */
) )
{ {
@ -6813,8 +6813,8 @@ int f_printf (
#else #else
DWORD v; DWORD v;
#endif #endif
TCHAR tc, pad, *tp; FATFS_TCHAR tc, pad, *tp;
TCHAR nul = 0; FATFS_TCHAR nul = 0;
char d, str[SZ_NUM_BUF]; char d, str[SZ_NUM_BUF];
@ -6879,10 +6879,10 @@ int f_printf (
case 'X': /* Unsigned hexdecimal (upper case) */ case 'X': /* Unsigned hexdecimal (upper case) */
r = 16; break; r = 16; break;
case 'c': /* Character */ case 'c': /* Character */
putc_bfd(&pb, (TCHAR)va_arg(arp, int)); putc_bfd(&pb, (FATFS_TCHAR)va_arg(arp, int));
continue; continue;
case 's': /* String */ case 's': /* String */
tp = va_arg(arp, TCHAR*); /* Get a pointer argument */ tp = va_arg(arp, FATFS_TCHAR*); /* Get a pointer argument */
if (!tp) tp = &nul; /* Null ptr generates a null string */ if (!tp) tp = &nul; /* Null ptr generates a null string */
for (j = 0; tp[j]; j++) ; /* j = tcslen(tp) */ for (j = 0; tp[j]; j++) ; /* j = tcslen(tp) */
if (prec >= 0 && j > (UINT)prec) j = prec; /* Limited length of string body */ if (prec >= 0 && j > (UINT)prec) j = prec; /* Limited length of string body */
@ -6937,7 +6937,7 @@ int f_printf (
if (f & 1) str[i++] = '-'; /* Sign */ if (f & 1) str[i++] = '-'; /* Sign */
/* Write it */ /* Write it */
for (j = i; !(f & 2) && j < w; j++) putc_bfd(&pb, pad); /* Left pads */ for (j = i; !(f & 2) && j < w; j++) putc_bfd(&pb, pad); /* Left pads */
do putc_bfd(&pb, (TCHAR)str[--i]); while (i); /* Body */ do putc_bfd(&pb, (FATFS_TCHAR)str[--i]); while (i); /* Body */
while (j++ < w) putc_bfd(&pb, ' '); /* Right pads */ while (j++ < w) putc_bfd(&pb, ' '); /* Right pads */
} }

76
Externals/FatFs/ff.h vendored
View File

@ -85,26 +85,26 @@ typedef DWORD LBA_t;
/* Type of path name strings on FatFs API (TCHAR) */ /* Type of path name strings on FatFs API (FATFS_TCHAR) */
#if FF_USE_LFN && FF_LFN_UNICODE == 1 /* Unicode in UTF-16 encoding */ #if FF_USE_LFN && FF_LFN_UNICODE == 1 /* Unicode in UTF-16 encoding */
typedef WCHAR TCHAR; typedef WCHAR FATFS_TCHAR;
#define _T(x) L ## x #define FATFS__T(x) L ## x
#define _TEXT(x) L ## x #define FATFS__TEXT(x) L ## x
#elif FF_USE_LFN && FF_LFN_UNICODE == 2 /* Unicode in UTF-8 encoding */ #elif FF_USE_LFN && FF_LFN_UNICODE == 2 /* Unicode in UTF-8 encoding */
typedef char TCHAR; typedef char FATFS_TCHAR;
#define _T(x) u8 ## x #define FATFS__T(x) u8 ## x
#define _TEXT(x) u8 ## x #define FATFS__TEXT(x) u8 ## x
#elif FF_USE_LFN && FF_LFN_UNICODE == 3 /* Unicode in UTF-32 encoding */ #elif FF_USE_LFN && FF_LFN_UNICODE == 3 /* Unicode in UTF-32 encoding */
typedef DWORD TCHAR; typedef DWORD FATFS_TCHAR;
#define _T(x) U ## x #define FATFS__T(x) U ## x
#define _TEXT(x) U ## x #define FATFS__TEXT(x) U ## x
#elif FF_USE_LFN && (FF_LFN_UNICODE < 0 || FF_LFN_UNICODE > 3) #elif FF_USE_LFN && (FF_LFN_UNICODE < 0 || FF_LFN_UNICODE > 3)
#error Wrong FF_LFN_UNICODE setting #error Wrong FF_LFN_UNICODE setting
#else /* ANSI/OEM code in SBCS/DBCS */ #else /* ANSI/OEM code in SBCS/DBCS */
typedef char TCHAR; typedef char FATFS_TCHAR;
#define _T(x) x #define FATFS__T(x) x
#define _TEXT(x) x #define FATFS__TEXT(x) x
#endif #endif
@ -236,7 +236,7 @@ typedef struct {
DWORD blk_ofs; /* Offset of current entry block being processed (0xFFFFFFFF:Invalid) */ DWORD blk_ofs; /* Offset of current entry block being processed (0xFFFFFFFF:Invalid) */
#endif #endif
#if FF_USE_FIND #if FF_USE_FIND
const TCHAR* pat; /* Pointer to the name matching pattern */ const FATFS_TCHAR* pat; /* Pointer to the name matching pattern */
#endif #endif
} DIR; } DIR;
@ -250,10 +250,10 @@ typedef struct {
WORD ftime; /* Modified time */ WORD ftime; /* Modified time */
BYTE fattrib; /* File attribute */ BYTE fattrib; /* File attribute */
#if FF_USE_LFN #if FF_USE_LFN
TCHAR altname[FF_SFN_BUF + 1];/* Altenative file name */ FATFS_TCHAR altname[FF_SFN_BUF + 1];/* Altenative file name */
TCHAR fname[FF_LFN_BUF + 1]; /* Primary file name */ FATFS_TCHAR fname[FF_LFN_BUF + 1]; /* Primary file name */
#else #else
TCHAR fname[12 + 1]; /* File name */ FATFS_TCHAR fname[12 + 1]; /* File name */
#endif #endif
} FILINFO; } FILINFO;
@ -301,40 +301,40 @@ typedef enum {
/*--------------------------------------------------------------*/ /*--------------------------------------------------------------*/
/* FatFs module application interface */ /* FatFs module application interface */
FRESULT f_open (FIL* fp, const TCHAR* path, BYTE mode); /* Open or create a file */ FRESULT f_open (FIL* fp, const FATFS_TCHAR* path, BYTE mode); /* Open or create a file */
FRESULT f_close (FIL* fp); /* Close an open file object */ FRESULT f_close (FIL* fp); /* Close an open file object */
FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br); /* Read data from the file */ FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br); /* Read data from the file */
FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw); /* Write data to the file */ FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw); /* Write data to the file */
FRESULT f_lseek (FIL* fp, FSIZE_t ofs); /* Move file pointer of the file object */ FRESULT f_lseek (FIL* fp, FSIZE_t ofs); /* Move file pointer of the file object */
FRESULT f_truncate (FIL* fp); /* Truncate the file */ FRESULT f_truncate (FIL* fp); /* Truncate the file */
FRESULT f_sync (FIL* fp); /* Flush cached data of the writing file */ FRESULT f_sync (FIL* fp); /* Flush cached data of the writing file */
FRESULT f_opendir (DIR* dp, const TCHAR* path); /* Open a directory */ FRESULT f_opendir (DIR* dp, const FATFS_TCHAR* path); /* Open a directory */
FRESULT f_closedir (DIR* dp); /* Close an open directory */ FRESULT f_closedir (DIR* dp); /* Close an open directory */
FRESULT f_readdir (DIR* dp, FILINFO* fno); /* Read a directory item */ FRESULT f_readdir (DIR* dp, FILINFO* fno); /* Read a directory item */
FRESULT f_findfirst (DIR* dp, FILINFO* fno, const TCHAR* path, const TCHAR* pattern); /* Find first file */ FRESULT f_findfirst (DIR* dp, FILINFO* fno, const FATFS_TCHAR* path, const FATFS_TCHAR* pattern); /* Find first file */
FRESULT f_findnext (DIR* dp, FILINFO* fno); /* Find next file */ FRESULT f_findnext (DIR* dp, FILINFO* fno); /* Find next file */
FRESULT f_mkdir (const TCHAR* path); /* Create a sub directory */ FRESULT f_mkdir (const FATFS_TCHAR* path); /* Create a sub directory */
FRESULT f_unlink (const TCHAR* path); /* Delete an existing file or directory */ FRESULT f_unlink (const FATFS_TCHAR* path); /* Delete an existing file or directory */
FRESULT f_rename (const TCHAR* path_old, const TCHAR* path_new); /* Rename/Move a file or directory */ FRESULT f_rename (const FATFS_TCHAR* path_old, const FATFS_TCHAR* path_new); /* Rename/Move a file or directory */
FRESULT f_stat (const TCHAR* path, FILINFO* fno); /* Get file status */ FRESULT f_stat (const FATFS_TCHAR* path, FILINFO* fno); /* Get file status */
FRESULT f_chmod (const TCHAR* path, BYTE attr, BYTE mask); /* Change attribute of a file/dir */ FRESULT f_chmod (const FATFS_TCHAR* path, BYTE attr, BYTE mask); /* Change attribute of a file/dir */
FRESULT f_utime (const TCHAR* path, const FILINFO* fno); /* Change timestamp of a file/dir */ FRESULT f_utime (const FATFS_TCHAR* path, const FILINFO* fno); /* Change timestamp of a file/dir */
FRESULT f_chdir (const TCHAR* path); /* Change current directory */ FRESULT f_chdir (const FATFS_TCHAR* path); /* Change current directory */
FRESULT f_chdrive (const TCHAR* path); /* Change current drive */ FRESULT f_chdrive (const FATFS_TCHAR* path); /* Change current drive */
FRESULT f_getcwd (TCHAR* buff, UINT len); /* Get current directory */ FRESULT f_getcwd (FATFS_TCHAR* buff, UINT len); /* Get current directory */
FRESULT f_getfree (const TCHAR* path, DWORD* nclst, FATFS** fatfs); /* Get number of free clusters on the drive */ FRESULT f_getfree (const FATFS_TCHAR* path, DWORD* nclst, FATFS** fatfs); /* Get number of free clusters on the drive */
FRESULT f_getlabel (const TCHAR* path, TCHAR* label, DWORD* vsn); /* Get volume label */ FRESULT f_getlabel (const FATFS_TCHAR* path, FATFS_TCHAR* label, DWORD* vsn); /* Get volume label */
FRESULT f_setlabel (const TCHAR* label); /* Set volume label */ FRESULT f_setlabel (const FATFS_TCHAR* label); /* Set volume label */
FRESULT f_forward (FIL* fp, UINT(*func)(const BYTE*,UINT), UINT btf, UINT* bf); /* Forward data to the stream */ FRESULT f_forward (FIL* fp, UINT(*func)(const BYTE*,UINT), UINT btf, UINT* bf); /* Forward data to the stream */
FRESULT f_expand (FIL* fp, FSIZE_t fsz, BYTE opt); /* Allocate a contiguous block to the file */ FRESULT f_expand (FIL* fp, FSIZE_t fsz, BYTE opt); /* Allocate a contiguous block to the file */
FRESULT f_mount (FATFS* fs, const TCHAR* path, BYTE opt); /* Mount/Unmount a logical drive */ FRESULT f_mount (FATFS* fs, const FATFS_TCHAR* path, BYTE opt); /* Mount/Unmount a logical drive */
FRESULT f_mkfs (const TCHAR* path, const MKFS_PARM* opt, void* work, UINT len); /* Create a FAT volume */ FRESULT f_mkfs (const FATFS_TCHAR* path, const MKFS_PARM* opt, void* work, UINT len); /* Create a FAT volume */
FRESULT f_fdisk (BYTE pdrv, const LBA_t ptbl[], void* work); /* Divide a physical drive into some partitions */ FRESULT f_fdisk (BYTE pdrv, const LBA_t ptbl[], void* work); /* Divide a physical drive into some partitions */
FRESULT f_setcp (WORD cp); /* Set current code page */ FRESULT f_setcp (WORD cp); /* Set current code page */
int f_putc (TCHAR c, FIL* fp); /* Put a character to the file */ int f_putc (FATFS_TCHAR c, FIL* fp); /* Put a character to the file */
int f_puts (const TCHAR* str, FIL* cp); /* Put a string to the file */ int f_puts (const FATFS_TCHAR* str, FIL* cp); /* Put a string to the file */
int f_printf (FIL* fp, const TCHAR* str, ...); /* Put a formatted string to the file */ int f_printf (FIL* fp, const FATFS_TCHAR* str, ...); /* Put a formatted string to the file */
TCHAR* f_gets (TCHAR* buff, int len, FIL* fp); /* Get a string from the file */ FATFS_TCHAR* f_gets (FATFS_TCHAR* buff, int len, FIL* fp); /* Get a string from the file */
#define f_eof(fp) ((int)((fp)->fptr == (fp)->obj.objsize)) #define f_eof(fp) ((int)((fp)->fptr == (fp)->obj.objsize))
#define f_error(fp) ((fp)->err) #define f_error(fp) ((fp)->err)