feat: KT mBMS 펌웨어 3종(HW1/2/3) 및 통합 빌드 환경 초기 커밋 (V4.0.0.1)
This commit is contained in:
8603
APP_R3221/App/FATFS/exfuns/cc949.c
Normal file
8603
APP_R3221/App/FATFS/exfuns/cc949.c
Normal file
File diff suppressed because it is too large
Load Diff
388
APP_R3221/App/FATFS/exfuns/ccsbcs.c
Normal file
388
APP_R3221/App/FATFS/exfuns/ccsbcs.c
Normal file
@@ -0,0 +1,388 @@
|
||||
/*------------------------------------------------------------------------*/
|
||||
/* Unicode - Local code bidirectional converter (C)ChaN, 2015 */
|
||||
/* (SBCS code pages) */
|
||||
/*------------------------------------------------------------------------*/
|
||||
/* 437 U.S.
|
||||
/ 720 Arabic
|
||||
/ 737 Greek
|
||||
/ 771 KBL
|
||||
/ 775 Baltic
|
||||
/ 850 Latin 1
|
||||
/ 852 Latin 2
|
||||
/ 855 Cyrillic
|
||||
/ 857 Turkish
|
||||
/ 860 Portuguese
|
||||
/ 861 Icelandic
|
||||
/ 862 Hebrew
|
||||
/ 863 Canadian French
|
||||
/ 864 Arabic
|
||||
/ 865 Nordic
|
||||
/ 866 Russian
|
||||
/ 869 Greek 2
|
||||
*/
|
||||
|
||||
#include "ff.h"
|
||||
|
||||
|
||||
#if _CODE_PAGE == 437
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP437(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7, 0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9, 0x00FF, 0x00D6, 0x00DC, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA, 0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, 0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4, 0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
|
||||
0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248, 0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 720
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP720(0x80-0xFF) to Unicode conversion table */
|
||||
0x0000, 0x0000, 0x00E9, 0x00E2, 0x0000, 0x00E0, 0x0000, 0x00E7, 0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0651, 0x0652, 0x00F4, 0x00A4, 0x0640, 0x00FB, 0x00F9, 0x0621, 0x0622, 0x0623, 0x0624, 0x00A3, 0x0625, 0x0626, 0x0627,
|
||||
0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F, 0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, 0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x0636, 0x0637, 0x0638, 0x0639, 0x063A, 0x0641, 0x00B5, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647, 0x0648, 0x0649, 0x064A,
|
||||
0x2261, 0x064B, 0x064C, 0x064D, 0x064E, 0x064F, 0x0650, 0x2248, 0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 737
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP737(0x80-0xFF) to Unicode conversion table */
|
||||
0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0,
|
||||
0x03A1, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8,
|
||||
0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0, 0x03C1, 0x03C3, 0x03C2, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, 0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x03C9, 0x03AC, 0x03AD, 0x03AE, 0x03CA, 0x03AF, 0x03CC, 0x03CD, 0x03CB, 0x03CE, 0x0386, 0x0388, 0x0389, 0x038A, 0x038C, 0x038E,
|
||||
0x038F, 0x00B1, 0x2265, 0x2264, 0x03AA, 0x03AB, 0x00F7, 0x2248, 0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 771
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP771(0x80-0xFF) to Unicode conversion table */
|
||||
0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
|
||||
0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
|
||||
0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x2558, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, 0x256A, 0x2518, 0x250C, 0x2588, 0x0104, 0x0105, 0x010C, 0x010D,
|
||||
0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
|
||||
0x0118, 0x0119, 0x0116, 0x0117, 0x012E, 0x012F, 0x0160, 0x0161, 0x0172, 0x0173, 0x016A, 0x016B, 0x017D, 0x017E, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 775
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP775(0x80-0xFF) to Unicode conversion table */
|
||||
0x0106, 0x00FC, 0x00E9, 0x0101, 0x00E4, 0x0123, 0x00E5, 0x0107, 0x0142, 0x0113, 0x0156, 0x0157, 0x012B, 0x0179, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x014D, 0x00F6, 0x0122, 0x00A2, 0x015A, 0x015B, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x00A4,
|
||||
0x0100, 0x012A, 0x00F3, 0x017B, 0x017C, 0x017A, 0x201D, 0x00A6, 0x00A9, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x0141, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x0104, 0x010C, 0x0118, 0x0116, 0x2563, 0x2551, 0x2557, 0x255D, 0x012E, 0x0160, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x0172, 0x016A, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x017D,
|
||||
0x0105, 0x010D, 0x0119, 0x0117, 0x012F, 0x0161, 0x0173, 0x016B, 0x017E, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x00D3, 0x00DF, 0x014C, 0x0143, 0x00F5, 0x00D5, 0x00B5, 0x0144, 0x0136, 0x0137, 0x013B, 0x013C, 0x0146, 0x0112, 0x0145, 0x2019,
|
||||
0x00AD, 0x00B1, 0x201C, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x201E, 0x00B0, 0x2219, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 850
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP850(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7, 0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9, 0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA, 0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0, 0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
||||
0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x0131, 0x00CD, 0x00CE, 0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
|
||||
0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE, 0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
|
||||
0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8, 0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 852
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP852(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x016F, 0x0107, 0x00E7, 0x0142, 0x00EB, 0x0150, 0x0151, 0x00EE, 0x0179, 0x00C4, 0x0106,
|
||||
0x00C9, 0x0139, 0x013A, 0x00F4, 0x00F6, 0x013D, 0x013E, 0x015A, 0x015B, 0x00D6, 0x00DC, 0x0164, 0x0165, 0x0141, 0x00D7, 0x010D,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x0104, 0x0105, 0x017D, 0x017E, 0x0118, 0x0119, 0x00AC, 0x017A, 0x010C, 0x015F, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x011A, 0x015E, 0x2563, 0x2551, 0x2557, 0x255D, 0x017B, 0x017C, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x0102, 0x0103, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
||||
0x0111, 0x0110, 0x010E, 0x00CB, 0x010F, 0x0147, 0x00CD, 0x00CE, 0x011B, 0x2518, 0x250C, 0x2588, 0x2584, 0x0162, 0x016E, 0x2580,
|
||||
0x00D3, 0x00DF, 0x00D4, 0x0143, 0x0144, 0x0148, 0x0160, 0x0161, 0x0154, 0x00DA, 0x0155, 0x0170, 0x00FD, 0x00DD, 0x0163, 0x00B4,
|
||||
0x00AD, 0x02DD, 0x02DB, 0x02C7, 0x02D8, 0x00A7, 0x00F7, 0x00B8, 0x00B0, 0x00A8, 0x02D9, 0x0171, 0x0158, 0x0159, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 855
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP855(0x80-0xFF) to Unicode conversion table */
|
||||
0x0452, 0x0402, 0x0453, 0x0403, 0x0451, 0x0401, 0x0454, 0x0404, 0x0455, 0x0405, 0x0456, 0x0406, 0x0457, 0x0407, 0x0458, 0x0408,
|
||||
0x0459, 0x0409, 0x045A, 0x040A, 0x045B, 0x040B, 0x045C, 0x040C, 0x045E, 0x040E, 0x045F, 0x040F, 0x044E, 0x042E, 0x044A, 0x042A,
|
||||
0x0430, 0x0410, 0x0431, 0x0411, 0x0446, 0x0426, 0x0434, 0x0414, 0x0435, 0x0415, 0x0444, 0x0424, 0x0433, 0x0413, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x0445, 0x0425, 0x0438, 0x0418, 0x2563, 0x2551, 0x2557, 0x255D, 0x0439, 0x0419, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x043A, 0x041A, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
||||
0x043B, 0x041B, 0x043C, 0x041C, 0x043D, 0x041D, 0x043E, 0x041E, 0x043F, 0x2518, 0x250C, 0x2588, 0x2584, 0x041F, 0x044F, 0x2580,
|
||||
0x042F, 0x0440, 0x0420, 0x0441, 0x0421, 0x0442, 0x0422, 0x0443, 0x0423, 0x0436, 0x0416, 0x0432, 0x0412, 0x044C, 0x042C, 0x2116,
|
||||
0x00AD, 0x044B, 0x042B, 0x0437, 0x0417, 0x0448, 0x0428, 0x044D, 0x042D, 0x0449, 0x0429, 0x0447, 0x0427, 0x00A7, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 857
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP857(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7, 0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x0131, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9, 0x0130, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x015E, 0x015F,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x011E, 0x011F, 0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0, 0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
||||
0x00BA, 0x00AA, 0x00CA, 0x00CB, 0x00C8, 0x0000, 0x00CD, 0x00CE, 0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
|
||||
0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x0000, 0x00D7, 0x00DA, 0x00DB, 0x00D9, 0x00EC, 0x00FF, 0x00AF, 0x00B4,
|
||||
0x00AD, 0x00B1, 0x0000, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8, 0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 860
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP860(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E3, 0x00E0, 0x00C1, 0x00E7, 0x00EA, 0x00CA, 0x00E8, 0x00CD, 0x00D4, 0x00EC, 0x00C3, 0x00C2,
|
||||
0x00C9, 0x00C0, 0x00C8, 0x00F4, 0x00F5, 0x00F2, 0x00DA, 0x00F9, 0x00CC, 0x00D5, 0x00DC, 0x00A2, 0x00A3, 0x00D9, 0x20A7, 0x00D3,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA, 0x00BF, 0x00D2, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x2558, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, 0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4, 0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
|
||||
0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248, 0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 861
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP861(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E6, 0x00E7, 0x00EA, 0x00EB, 0x00E8, 0x00D0, 0x00F0, 0x00DE, 0x00C4, 0x00C5,
|
||||
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00FE, 0x00FB, 0x00DD, 0x00FD, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x20A7, 0x0192,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00C1, 0x00CD, 0x00D3, 0x00DA, 0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, 0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4, 0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
|
||||
0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248, 0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 862
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP862(0x80-0xFF) to Unicode conversion table */
|
||||
0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7, 0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
|
||||
0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7, 0x05E8, 0x05E9, 0x05EA, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA, 0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, 0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4, 0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
|
||||
0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248, 0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 863
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP863(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00C2, 0x00E0, 0x00B6, 0x00E7, 0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x2017, 0x00C0,
|
||||
0x00C9, 0x00C8, 0x00CA, 0x00F4, 0x00CB, 0x00CF, 0x00FB, 0x00F9, 0x00A4, 0x00D4, 0x00DC, 0x00A2, 0x00A3, 0x00D9, 0x00DB, 0x0192,
|
||||
0x00A6, 0x00B4, 0x00F3, 0x00FA, 0x00A8, 0x00BB, 0x00B3, 0x00AF, 0x00CE, 0x3210, 0x00AC, 0x00BD, 0x00BC, 0x00BE, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, 0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4, 0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2219,
|
||||
0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248, 0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 864
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP864(0x80-0xFF) to Unicode conversion table */
|
||||
0x00B0, 0x00B7, 0x2219, 0x221A, 0x2592, 0x2500, 0x2502, 0x253C, 0x2524, 0x252C, 0x251C, 0x2534, 0x2510, 0x250C, 0x2514, 0x2518,
|
||||
0x03B2, 0x221E, 0x03C6, 0x00B1, 0x00BD, 0x00BC, 0x2248, 0x00AB, 0x00BB, 0xFEF7, 0xFEF8, 0x0000, 0x0000, 0xFEFB, 0xFEFC, 0x0000,
|
||||
0x00A0, 0x00AD, 0xFE82, 0x00A3, 0x00A4, 0xFE84, 0x0000, 0x20AC, 0xFE8E, 0xFE8F, 0xFE95, 0xFE99, 0x060C, 0xFE9D, 0xFEA1, 0xFEA5,
|
||||
0x0660, 0x0661, 0x0662, 0x0663, 0x0664, 0x0665, 0x0666, 0x0667, 0x0668, 0x0669, 0xFED1, 0x061B, 0xFEB1, 0xFEB5, 0xFEB9, 0x061F,
|
||||
0x00A2, 0xFE80, 0xFE81, 0xFE83, 0xFE85, 0xFECA, 0xFE8B, 0xFE8D, 0xFE91, 0xFE93, 0xFE97, 0xFE9B, 0xFE9F, 0xFEA3, 0xFEA7, 0xFEA9,
|
||||
0xFEAB, 0xFEAD, 0xFEAF, 0xFEB3, 0xFEB7, 0xFEBB, 0xFEBF, 0xFEC1, 0xFEC5, 0xFECB, 0xFECF, 0x00A6, 0x00AC, 0x00F7, 0x00D7, 0xFEC9,
|
||||
0x0640, 0xFED3, 0xFED7, 0xFEDB, 0xFEDF, 0xFEE3, 0xFEE7, 0xFEEB, 0xFEED, 0xFEEF, 0xFEF3, 0xFEBD, 0xFECC, 0xFECE, 0xFECD, 0xFEE1,
|
||||
0xFE7D, 0x0651, 0xFEE5, 0xFEE9, 0xFEEC, 0xFEF0, 0xFEF2, 0xFED0, 0xFED5, 0xFEF5, 0xFEF6, 0xFEDD, 0xFED9, 0xFEF1, 0x25A0, 0x0000
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 865
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP865(0x80-0xFF) to Unicode conversion table */
|
||||
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7, 0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
|
||||
0x00C5, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9, 0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x20A7, 0x0192,
|
||||
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA, 0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00A4,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x2558, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, 0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4, 0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
|
||||
0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248, 0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 866
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP866(0x80-0xFF) to Unicode conversion table */
|
||||
0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
|
||||
0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
|
||||
0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
||||
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, 0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
||||
0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
|
||||
0x0401, 0x0451, 0x0404, 0x0454, 0x0407, 0x0457, 0x040E, 0x045E, 0x00B0, 0x2219, 0x00B7, 0x221A, 0x2116, 0x00A4, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#elif _CODE_PAGE == 869
|
||||
#define _TBLDEF 1
|
||||
static
|
||||
const WCHAR Tbl[] = { /* CP869(0x80-0xFF) to Unicode conversion table */
|
||||
0x00B7, 0x00B7, 0x00B7, 0x00B7, 0x00B7, 0x00B7, 0x0386, 0x00B7, 0x00B7, 0x00AC, 0x00A6, 0x2018, 0x2019, 0x0388, 0x2015, 0x0389,
|
||||
0x038A, 0x03AA, 0x038C, 0x00B7, 0x00B7, 0x038E, 0x03AB, 0x00A9, 0x038F, 0x00B2, 0x00B3, 0x03AC, 0x00A3, 0x03AD, 0x03AE, 0x03AF,
|
||||
0x03CA, 0x0390, 0x03CC, 0x03CD, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x00BD, 0x0398, 0x0399, 0x00AB, 0x00BB,
|
||||
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x039A, 0x039B, 0x039C, 0x039D, 0x2563, 0x2551, 0x2557, 0x255D, 0x039E, 0x039F, 0x2510,
|
||||
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x0A30, 0x03A1, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x03A3,
|
||||
0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9, 0x03B1, 0x03B2, 0x03B3, 0x2518, 0x250C, 0x2588, 0x2584, 0x03B4, 0x03B5, 0x2580,
|
||||
0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0, 0x03C1, 0x03C3, 0x03C2, 0x03C4, 0x0384,
|
||||
0x00AD, 0x00B1, 0x03C5, 0x03C6, 0x03C7, 0x00A7, 0x03C8, 0x0385, 0x00B0, 0x00A8, 0x03C9, 0x03CB, 0x03B0, 0x03CE, 0x25A0, 0x00A0
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#if !_TBLDEF || !_USE_LFN
|
||||
#error This file is not needed at current configuration. Remove from the project.
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
WCHAR ff_convert ( /* Converted character, Returns zero on error */
|
||||
WCHAR chr, /* Character code to be converted */
|
||||
UINT dir /* 0: Unicode to OEM code, 1: OEM code to Unicode */
|
||||
)
|
||||
{
|
||||
WCHAR c;
|
||||
|
||||
|
||||
if (chr < 0x80) { /* ASCII */
|
||||
c = chr;
|
||||
|
||||
} else {
|
||||
if (dir) { /* OEM code to Unicode */
|
||||
c = (chr >= 0x100) ? 0 : Tbl[chr - 0x80];
|
||||
|
||||
} else { /* Unicode to OEM code */
|
||||
for (c = 0; c < 0x80; c++) {
|
||||
if (chr == Tbl[c]) break;
|
||||
}
|
||||
c = (c + 0x80) & 0xFF;
|
||||
}
|
||||
}
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
|
||||
WCHAR ff_wtoupper ( /* Returns upper converted character */
|
||||
WCHAR chr /* Unicode character to be upper converted (BMP only) */
|
||||
)
|
||||
{
|
||||
/* Compressed upper conversion table */
|
||||
static const WCHAR cvt1[] = { /* U+0000 - U+0FFF */
|
||||
/* Basic Latin */
|
||||
0x0061,0x031A,
|
||||
/* Latin-1 Supplement */
|
||||
0x00E0,0x0317, 0x00F8,0x0307, 0x00FF,0x0001,0x0178,
|
||||
/* Latin Extended-A */
|
||||
0x0100,0x0130, 0x0132,0x0106, 0x0139,0x0110, 0x014A,0x012E, 0x0179,0x0106,
|
||||
/* Latin Extended-B */
|
||||
0x0180,0x004D,0x0243,0x0181,0x0182,0x0182,0x0184,0x0184,0x0186,0x0187,0x0187,0x0189,0x018A,0x018B,0x018B,0x018D,0x018E,0x018F,0x0190,0x0191,0x0191,0x0193,0x0194,0x01F6,0x0196,0x0197,0x0198,0x0198,0x023D,0x019B,0x019C,0x019D,0x0220,0x019F,0x01A0,0x01A0,0x01A2,0x01A2,0x01A4,0x01A4,0x01A6,0x01A7,0x01A7,0x01A9,0x01AA,0x01AB,0x01AC,0x01AC,0x01AE,0x01AF,0x01AF,0x01B1,0x01B2,0x01B3,0x01B3,0x01B5,0x01B5,0x01B7,0x01B8,0x01B8,0x01BA,0x01BB,0x01BC,0x01BC,0x01BE,0x01F7,0x01C0,0x01C1,0x01C2,0x01C3,0x01C4,0x01C5,0x01C4,0x01C7,0x01C8,0x01C7,0x01CA,0x01CB,0x01CA,
|
||||
0x01CD,0x0110, 0x01DD,0x0001,0x018E, 0x01DE,0x0112, 0x01F3,0x0003,0x01F1,0x01F4,0x01F4, 0x01F8,0x0128,
|
||||
0x0222,0x0112, 0x023A,0x0009,0x2C65,0x023B,0x023B,0x023D,0x2C66,0x023F,0x0240,0x0241,0x0241, 0x0246,0x010A,
|
||||
/* IPA Extensions */
|
||||
0x0253,0x0040,0x0181,0x0186,0x0255,0x0189,0x018A,0x0258,0x018F,0x025A,0x0190,0x025C,0x025D,0x025E,0x025F,0x0193,0x0261,0x0262,0x0194,0x0264,0x0265,0x0266,0x0267,0x0197,0x0196,0x026A,0x2C62,0x026C,0x026D,0x026E,0x019C,0x0270,0x0271,0x019D,0x0273,0x0274,0x019F,0x0276,0x0277,0x0278,0x0279,0x027A,0x027B,0x027C,0x2C64,0x027E,0x027F,0x01A6,0x0281,0x0282,0x01A9,0x0284,0x0285,0x0286,0x0287,0x01AE,0x0244,0x01B1,0x01B2,0x0245,0x028D,0x028E,0x028F,0x0290,0x0291,0x01B7,
|
||||
/* Greek, Coptic */
|
||||
0x037B,0x0003,0x03FD,0x03FE,0x03FF, 0x03AC,0x0004,0x0386,0x0388,0x0389,0x038A, 0x03B1,0x0311,
|
||||
0x03C2,0x0002,0x03A3,0x03A3, 0x03C4,0x0308, 0x03CC,0x0003,0x038C,0x038E,0x038F, 0x03D8,0x0118,
|
||||
0x03F2,0x000A,0x03F9,0x03F3,0x03F4,0x03F5,0x03F6,0x03F7,0x03F7,0x03F9,0x03FA,0x03FA,
|
||||
/* Cyrillic */
|
||||
0x0430,0x0320, 0x0450,0x0710, 0x0460,0x0122, 0x048A,0x0136, 0x04C1,0x010E, 0x04CF,0x0001,0x04C0, 0x04D0,0x0144,
|
||||
/* Armenian */
|
||||
0x0561,0x0426,
|
||||
|
||||
0x0000
|
||||
};
|
||||
static const WCHAR cvt2[] = { /* U+1000 - U+FFFF */
|
||||
/* Phonetic Extensions */
|
||||
0x1D7D,0x0001,0x2C63,
|
||||
/* Latin Extended Additional */
|
||||
0x1E00,0x0196, 0x1EA0,0x015A,
|
||||
/* Greek Extended */
|
||||
0x1F00,0x0608, 0x1F10,0x0606, 0x1F20,0x0608, 0x1F30,0x0608, 0x1F40,0x0606,
|
||||
0x1F51,0x0007,0x1F59,0x1F52,0x1F5B,0x1F54,0x1F5D,0x1F56,0x1F5F, 0x1F60,0x0608,
|
||||
0x1F70,0x000E,0x1FBA,0x1FBB,0x1FC8,0x1FC9,0x1FCA,0x1FCB,0x1FDA,0x1FDB,0x1FF8,0x1FF9,0x1FEA,0x1FEB,0x1FFA,0x1FFB,
|
||||
0x1F80,0x0608, 0x1F90,0x0608, 0x1FA0,0x0608, 0x1FB0,0x0004,0x1FB8,0x1FB9,0x1FB2,0x1FBC,
|
||||
0x1FCC,0x0001,0x1FC3, 0x1FD0,0x0602, 0x1FE0,0x0602, 0x1FE5,0x0001,0x1FEC, 0x1FF2,0x0001,0x1FFC,
|
||||
/* Letterlike Symbols */
|
||||
0x214E,0x0001,0x2132,
|
||||
/* Number forms */
|
||||
0x2170,0x0210, 0x2184,0x0001,0x2183,
|
||||
/* Enclosed Alphanumerics */
|
||||
0x24D0,0x051A, 0x2C30,0x042F,
|
||||
/* Latin Extended-C */
|
||||
0x2C60,0x0102, 0x2C67,0x0106, 0x2C75,0x0102,
|
||||
/* Coptic */
|
||||
0x2C80,0x0164,
|
||||
/* Georgian Supplement */
|
||||
0x2D00,0x0826,
|
||||
/* Full-width */
|
||||
0xFF41,0x031A,
|
||||
|
||||
0x0000
|
||||
};
|
||||
const WCHAR *p;
|
||||
WCHAR bc, nc, cmd;
|
||||
|
||||
|
||||
p = chr < 0x1000 ? cvt1 : cvt2;
|
||||
for (;;) {
|
||||
bc = *p++; /* Get block base */
|
||||
if (!bc || chr < bc) break;
|
||||
nc = *p++; cmd = nc >> 8; nc &= 0xFF; /* Get processing command and block size */
|
||||
if (chr < bc + nc) { /* In the block? */
|
||||
switch (cmd) {
|
||||
case 0: chr = p[chr - bc]; break; /* Table conversion */
|
||||
case 1: chr -= (chr - bc) & 1; break; /* Case pairs */
|
||||
case 2: chr -= 16; break; /* Shift -16 */
|
||||
case 3: chr -= 32; break; /* Shift -32 */
|
||||
case 4: chr -= 48; break; /* Shift -48 */
|
||||
case 5: chr -= 26; break; /* Shift -26 */
|
||||
case 6: chr += 8; break; /* Shift +8 */
|
||||
case 7: chr -= 80; break; /* Shift -80 */
|
||||
case 8: chr -= 0x1C60; break; /* Shift -0x1C60 */
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (!cmd) p += nc;
|
||||
}
|
||||
|
||||
return chr;
|
||||
}
|
||||
|
||||
416
APP_R3221/App/FATFS/exfuns/exfuns.c
Normal file
416
APP_R3221/App/FATFS/exfuns/exfuns.c
Normal file
@@ -0,0 +1,416 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* File Name : exfuns.c
|
||||
* Description : This file provides code for the configuration
|
||||
* of the External Functions instances.
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* <h2><center>© Copyright (c) 2019 STMicroelectronics.
|
||||
* All rights reserved.</center></h2>
|
||||
*
|
||||
* This software component is licensed by ST under Ultimate Liberty license
|
||||
* SLA0044, the "License"; You may not use this file except in compliance with
|
||||
* the License. You may obtain a copy of the License at:
|
||||
* www.st.com/SLA0044
|
||||
*
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include <string.h>
|
||||
#include "malloc.h"
|
||||
#include "exfuns.h"
|
||||
//#include "fattester.h"
|
||||
#include "usart.h"
|
||||
|
||||
#define FILE_MAX_TYPE_NUM 7 //Most FILE_MAX_TYPE_NUM categories
|
||||
#define FILE_MAX_SUBT_NUM 4 //Up to FILE_MAX_SUBT_NUM a small class
|
||||
|
||||
//File types list
|
||||
char * const FILE_TYPE_TBL[FILE_MAX_TYPE_NUM][FILE_MAX_SUBT_NUM]=
|
||||
{
|
||||
{"BIN"}, //BIN file
|
||||
{"LRC"}, //LRC files
|
||||
{"NES"}, //NES file
|
||||
{"TXT","C","H"}, //Text file
|
||||
{"WAV","MP3","APE","FLAC"},//Supported music files
|
||||
{"BMP","JPG","JPEG","GIF"},//Picture files
|
||||
{"AVI"}, //Video file
|
||||
};
|
||||
///////////////////////////////Public files area, when using the malloc////////////////////////////////////////////
|
||||
FATFS *fs[_VOLUMES]; //Logical disk.
|
||||
FIL *file; //File 1
|
||||
FIL *ftemp; //File 2.
|
||||
UINT br,bw; //Read and write variables
|
||||
FILINFO fileinfo; //File information
|
||||
DIR dir; //Directory
|
||||
|
||||
uint8_t *fatbuf; //SD card data buffer
|
||||
///////////////////////////////////////////////////////////////////////////////////////
|
||||
//Exfuns for the memory
|
||||
//Return values: 0-success
|
||||
// 1 failure
|
||||
uint8_t exfuns_init(void)
|
||||
{
|
||||
uint8_t i;
|
||||
for (i = 0; i < _VOLUMES; i++)
|
||||
{
|
||||
fs[i] = (FATFS*)mymalloc(sizeof(FATFS)); //Applications for disk I workspace memory
|
||||
if (!fs[i]) break;
|
||||
}
|
||||
file = (FIL*)mymalloc(sizeof(FIL)); //Applications for file memory
|
||||
ftemp = (FIL*)mymalloc(sizeof(FIL)); //Ftemp application memory
|
||||
fatbuf = (uint8_t*) mymalloc(512); //Fatbuf for the memory
|
||||
if (i == _VOLUMES && file && ftemp && fatbuf) return 0; //Success
|
||||
else return 1; //Failed
|
||||
}
|
||||
|
||||
//Lowercase letters to uppercase letters if numbers remained unchanged.
|
||||
uint8_t char_upper(uint8_t c)
|
||||
{
|
||||
if (c < 'A') return c; //Numbers remain the same.
|
||||
if (c >= 'a') return c - 0x20; //Uppercase.
|
||||
else return c; //Capital, remains unchanged
|
||||
}
|
||||
//Report file type
|
||||
//Fname: file name
|
||||
//Return value: 0XFF, said it could not identify the type of file number.
|
||||
// Other four member categories, low said four member categories.
|
||||
uint8_t f_typetell(uint8_t *fname)
|
||||
{
|
||||
uint8_t tbuf[5];
|
||||
uint8_t *attr = (uint8_t*)'\0';//Extension name
|
||||
uint8_t i=0,j;
|
||||
while(i<250)
|
||||
{
|
||||
i++;
|
||||
if(*fname=='\0')break;//Offset at the end of the.
|
||||
fname++;
|
||||
}
|
||||
if(i==250)return 0XFF;//Error string.
|
||||
for(i=0;i<5;i++)//Get extension
|
||||
{
|
||||
fname--;
|
||||
if(*fname=='.')
|
||||
{
|
||||
fname++;
|
||||
attr=fname;
|
||||
break;
|
||||
}
|
||||
}
|
||||
strcpy((char *)tbuf,(const char*)attr);//copy
|
||||
for(i=0;i<4;i++)tbuf[i]=char_upper(tbuf[i]);//All uppercase
|
||||
for(i=0;i<FILE_MAX_TYPE_NUM;i++) //Category comparison
|
||||
{
|
||||
for(j=0;j<FILE_MAX_SUBT_NUM;j++)//Subclass comparison
|
||||
{
|
||||
if(*FILE_TYPE_TBL[i][j]==0)break;//The members of this group have no comparable.
|
||||
if(strcmp((const char *)FILE_TYPE_TBL[i][j],(const char *)tbuf)==0)//Found it
|
||||
{
|
||||
return (i<<4)|j;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0XFF;//Not found
|
||||
}
|
||||
|
||||
//Get free disk capacity
|
||||
//drv:Disk number("0:"/"1:")
|
||||
//total:Total capacity (In KB)
|
||||
//free:Remaining capacity (In KB)
|
||||
//Return values: 0,., error code
|
||||
uint8_t exf_getfree(uint8_t *drv,uint32_t *total,uint32_t *free)
|
||||
{
|
||||
FATFS *fs1;
|
||||
uint8_t res;
|
||||
uint32_t fre_clust=0, fre_sect=0, tot_sect=0;
|
||||
//Get disk information and the number of free clusters
|
||||
res =(uint32_t)f_getfree((const TCHAR*)drv, (DWORD*)&fre_clust, &fs1);
|
||||
if(res==0)
|
||||
{
|
||||
tot_sect=(fs1->n_fatent-2)*fs1->csize; //Total number of sectors
|
||||
fre_sect=fre_clust*fs1->csize; //Get number of spare sectors
|
||||
#if _MAX_SS!=512 //Sector size other than 512 bytes, then the conversion is 512 bytes
|
||||
tot_sect*=fs1->ssize/512;
|
||||
fre_sect*=fs1->ssize/512;
|
||||
#endif
|
||||
*total=tot_sect>>1; //Unit is KB
|
||||
*free=fre_sect>>1; //Unit is KB
|
||||
}
|
||||
return res;
|
||||
}
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//File replication
|
||||
//Note the file size should not exceed 4GB.
|
||||
//The pSrc file, copy to pdst.
|
||||
//fcpymsg,A function pointer to implement copy information display
|
||||
// pname:File/folder name
|
||||
// pct:Percentage
|
||||
// mode:
|
||||
// [0]:Update file name
|
||||
// [1]:Update percentage of PCT
|
||||
// [2]:Update folder
|
||||
// [3~7]:Reservation
|
||||
//psrc,pdst:Source and target files
|
||||
//totsize:Total size (when totsize 0 when says just to copy a single file)
|
||||
//cpdsize:The size of replicated.
|
||||
//fwmode:File in write mode
|
||||
//0:Do not overwrite existing file
|
||||
//1:Overwrite the original file
|
||||
//Return values: 0 normal,
|
||||
// Other, errors, 0XFF, force quit
|
||||
uint8_t exf_copy(uint8_t(*fcpymsg)(uint8_t*pname,uint8_t pct,uint8_t mode),uint8_t *psrc,uint8_t *pdst,uint32_t totsize,uint32_t cpdsize,uint8_t fwmode)
|
||||
{
|
||||
uint8_t res;
|
||||
uint16_t br=0;
|
||||
uint16_t bw=0;
|
||||
FIL *fsrc=0;
|
||||
FIL *fdst=0;
|
||||
uint8_t *fbuf=0;
|
||||
uint8_t curpct=0;
|
||||
fsrc=(FIL*)mymalloc(sizeof(FIL));//For the memory
|
||||
fdst=(FIL*)mymalloc(sizeof(FIL));
|
||||
fbuf=(uint8_t *)mymalloc(8192);
|
||||
if(fsrc==NULL||fdst==NULL||fbuf==NULL)res=100;//Front left fatfs
|
||||
else
|
||||
{
|
||||
if(fwmode==0)fwmode=FA_CREATE_NEW;//Do not overwrite
|
||||
else fwmode=FA_CREATE_ALWAYS; //Overwrite the existing file
|
||||
|
||||
res=f_open(fsrc,(const TCHAR*)psrc,FA_READ|FA_OPEN_EXISTING); //Open a read-only file
|
||||
if(res==0)res=f_open(fdst,(const TCHAR*)pdst,FA_WRITE|fwmode); //First open success, began to open the second
|
||||
if(res==0)//Both open succeeded
|
||||
{
|
||||
if(totsize==0)//Only is a single file copy
|
||||
{
|
||||
totsize=fsrc->obj.objsize;
|
||||
cpdsize=0;
|
||||
curpct=0;
|
||||
}else curpct=(cpdsize*100)/totsize; //Percentage of new
|
||||
fcpymsg(psrc,curpct,0X02); //Update percentage
|
||||
while(res==0)//Start copying
|
||||
{
|
||||
res=f_read(fsrc,fbuf,8192,(UINT*)&br); //The source read 512 bytes
|
||||
if(res||br==0)break;
|
||||
res=f_write(fdst,fbuf,(UINT)br,(UINT*)&bw); //Write destination file
|
||||
cpdsize+=bw;
|
||||
if(curpct!=(cpdsize*100)/totsize)//Do you need to update the percentage
|
||||
{
|
||||
curpct=(cpdsize*100)/totsize;
|
||||
if(fcpymsg(psrc,curpct,0X02))//Update percentage
|
||||
{
|
||||
res=0XFF;//Force quit
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(res||bw<br)break;
|
||||
}
|
||||
f_close(fsrc);
|
||||
f_close(fdst);
|
||||
}
|
||||
}
|
||||
myfree(fsrc);//Free up memory
|
||||
myfree(fdst);
|
||||
myfree(fbuf);
|
||||
return res;
|
||||
}
|
||||
|
||||
//Get the path's directory
|
||||
//Return values: 0, path is a volume label.
|
||||
// Other folder name address
|
||||
uint8_t* exf_get_src_dname(uint8_t* dpfn)
|
||||
{
|
||||
uint16_t temp=0;
|
||||
while(*dpfn!=0)
|
||||
{
|
||||
dpfn++;
|
||||
temp++;
|
||||
}
|
||||
if(temp<4)return 0;
|
||||
while((*dpfn!=0x5c)&&(*dpfn!=0x2f))dpfn--; //Goes back to the last "\" or "/"
|
||||
return ++dpfn;
|
||||
}
|
||||
//Get folder size
|
||||
//Note the folder size not more than 4GB.
|
||||
//Return values: 0, folder size is 0, or the error occurred during a read.
|
||||
// Otherwise, the folder size.
|
||||
uint32_t exf_fdsize(uint8_t *fdname)
|
||||
{
|
||||
#define MAX_PATHNAME_DEPTH 512+1 //Maximum depth of target file path + file name
|
||||
uint8_t res=0;
|
||||
DIR *fddir=0; //Directory
|
||||
FILINFO *finfo=0; //File information
|
||||
uint8_t *fn=0; //Long file names
|
||||
uint8_t * pathname=0; //The destination folder path + file name
|
||||
uint16_t pathlen=0; //Destination path length
|
||||
uint32_t fdsize=0;
|
||||
|
||||
fddir=(DIR*)mymalloc(sizeof(DIR));//For the memory
|
||||
finfo=(FILINFO*)mymalloc(sizeof(FILINFO));
|
||||
if(fddir==NULL||finfo==NULL)res=100;
|
||||
if(res==0)
|
||||
{
|
||||
finfo->fsize = _MAX_LFN * 2 + 1;
|
||||
pathname = mymalloc(MAX_PATHNAME_DEPTH);
|
||||
if(finfo->fname == NULL || pathname == NULL) res=101;
|
||||
if(res==0)
|
||||
{
|
||||
pathname[0]=0;
|
||||
strcat((char*)pathname,(const char*)fdname); //Copy path
|
||||
res=f_opendir(fddir,(const TCHAR*)fdname); //Open source directory
|
||||
if(res==0)//Open Directory successfully
|
||||
{
|
||||
while(res==0)//Start copying folders inside stuff
|
||||
{
|
||||
res=f_readdir(fddir,finfo); //Read a file directory
|
||||
if(res!=FR_OK||finfo->fname[0]==0)break; //Errors/to the end of the exit
|
||||
if(finfo->fname[0]=='.')continue; //Ignoring superior directory
|
||||
if(finfo->fattrib&0X10)//Is the subdirectory (file attributes, 0X20, archive; 0X10, subdirectories;)
|
||||
{
|
||||
fn=(uint8_t*)(finfo->fname);//Get file name
|
||||
pathlen=strlen((const char*)pathname); //Get the current path length
|
||||
strcat((char*)pathname,(const char*)"/"); //Add a slash
|
||||
strcat((char*)pathname,(const char*)fn); //Source path and directory name
|
||||
//printf("\r\nsub folder:%s\r\n",pathname); //Print a directory name
|
||||
fdsize+=exf_fdsize(pathname); //Get directory size, recursive calls
|
||||
pathname[pathlen]=0; //Join the terminator
|
||||
}
|
||||
else fdsize+=finfo->fsize; //Non-catalog direct plus the size of the file
|
||||
|
||||
}
|
||||
}
|
||||
myfree(pathname);
|
||||
}
|
||||
}
|
||||
myfree(fddir);
|
||||
myfree(finfo);
|
||||
if(res)return 0;
|
||||
else return fdsize;
|
||||
}
|
||||
//Folder replication
|
||||
//Note the folder size not to exceed 4GB.
|
||||
//The pSrc folder, copy to pdst folder.
|
||||
//Pdst: must be shaped like "x:"/"X:XX"/"X:XX/XX" or something like that. but also the confirm folder one level up
|
||||
//Fcpymsg, function pointer, used to implement a copy of information display
|
||||
// pname:File/folder name
|
||||
// pct:Percentage
|
||||
// mode:
|
||||
// [0]:Update file name
|
||||
// [1]:Update percentage of PCT
|
||||
// [2]:Update folder
|
||||
// [3~7]:Reservation
|
||||
//psrc,pdst:Source and destination folders
|
||||
//totsize:Total size (when totsize 0 when says just to copy a single file)
|
||||
//cpdsize:Total size of the copied.
|
||||
//fwmode:File in write mode
|
||||
//0:Do not overwrite existing file
|
||||
//1:Overwrite the original file
|
||||
//Return values: 0-success
|
||||
// Other error code 0XFF, a forced exit
|
||||
uint8_t exf_fdcopy(uint8_t(*fcpymsg)(uint8_t*pname,uint8_t pct,uint8_t mode),uint8_t *psrc,uint8_t *pdst,uint32_t *totsize,uint32_t *cpdsize,uint8_t fwmode)
|
||||
{
|
||||
#define MAX_PATHNAME_DEPTH 512+1 //Maximum depth of target file path + file name
|
||||
uint8_t res=0;
|
||||
DIR *srcdir=0; //The source directory
|
||||
DIR *dstdir=0; //The destination directory
|
||||
FILINFO *finfo=0; //File information
|
||||
uint8_t *fn=0; //Long file names
|
||||
|
||||
uint8_t * dstpathname=0; //destination folder path + file name
|
||||
uint8_t * srcpathname=0; //Source folder path + filename
|
||||
|
||||
uint16_t dstpathlen=0; //Destination path length
|
||||
uint16_t srcpathlen=0; //Source path length
|
||||
|
||||
|
||||
srcdir=(DIR*)mymalloc(sizeof(DIR));//For the memory
|
||||
dstdir=(DIR*)mymalloc(sizeof(DIR));
|
||||
finfo=(FILINFO*)mymalloc(sizeof(FILINFO));
|
||||
|
||||
if(srcdir==NULL||dstdir==NULL||finfo==NULL)res=100;
|
||||
if(res==0)
|
||||
{
|
||||
finfo->fsize=_MAX_LFN*2+1;
|
||||
dstpathname=mymalloc(MAX_PATHNAME_DEPTH);
|
||||
srcpathname=mymalloc(MAX_PATHNAME_DEPTH);
|
||||
if(finfo->fname==NULL||dstpathname==NULL||srcpathname==NULL)res=101;
|
||||
if(res==0)
|
||||
{
|
||||
dstpathname[0]=0;
|
||||
srcpathname[0]=0;
|
||||
strcat((char*)srcpathname,(const char*)psrc); //A copy of the original source file path
|
||||
strcat((char*)dstpathname,(const char*)pdst); //A copy of the original target file path
|
||||
res=f_opendir(srcdir,(const TCHAR*)psrc); //Open source directory
|
||||
if(res==0)//Open Directory successfully
|
||||
{
|
||||
strcat((char*)dstpathname,(const char*)"/");//Join slash
|
||||
fn=exf_get_src_dname(psrc);
|
||||
if(fn==0)//Label copy
|
||||
{
|
||||
dstpathlen=strlen((const char*)dstpathname);
|
||||
dstpathname[dstpathlen]=psrc[0]; //Record label
|
||||
dstpathname[dstpathlen+1]=0; //Terminator
|
||||
}
|
||||
else strcat((char*)dstpathname,(const char*)fn);//Add filename
|
||||
fcpymsg(fn,0,0X04);//Update the folder name
|
||||
res=f_mkdir((const TCHAR*)dstpathname);//If the folder already exists, is not created. create a new folder if it does not exist.
|
||||
if(res==FR_EXIST)res=0;
|
||||
while(res==0)//Start copying folders inside stuff
|
||||
{
|
||||
res=f_readdir(srcdir,finfo); //Read a file directory
|
||||
if(res!=FR_OK||finfo->fname[0]==0)break; //Errors/to the end of the exit
|
||||
if(finfo->fname[0]=='.')continue; //Ignoring superior directory
|
||||
fn=(uint8_t*)(finfo->fname); //Get file name
|
||||
dstpathlen=strlen((const char*)dstpathname); //Get the length of the path to the current target
|
||||
srcpathlen=strlen((const char*)srcpathname); //Get the source path length
|
||||
|
||||
strcat((char*)srcpathname,(const char*)"/");//Source path in slash
|
||||
if(finfo->fattrib&0X10)//Is the subdirectory (file attributes, 0X20, archive; 0X10, subdirectories;)
|
||||
{
|
||||
strcat((char*)srcpathname,(const char*)fn); //Source path and directory name
|
||||
res=exf_fdcopy(fcpymsg,srcpathname,dstpathname,totsize,cpdsize,fwmode); //Copy folder
|
||||
}
|
||||
else //Non-catalog
|
||||
{
|
||||
strcat((char*)dstpathname,(const char*)"/");//Target path in slash
|
||||
strcat((char*)dstpathname,(const char*)fn); //Destination path and file name
|
||||
strcat((char*)srcpathname,(const char*)fn); //Source path and file name
|
||||
fcpymsg(fn,0,0X01);//Update file name
|
||||
res=exf_copy(fcpymsg,srcpathname,dstpathname,*totsize,*cpdsize,fwmode);//Copy the files
|
||||
*cpdsize+=finfo->fsize;//Add a file size
|
||||
}
|
||||
srcpathname[srcpathlen]=0;//Join the terminator
|
||||
dstpathname[dstpathlen]=0;//Join the terminator
|
||||
}
|
||||
}
|
||||
myfree(dstpathname);
|
||||
myfree(srcpathname);
|
||||
}
|
||||
}
|
||||
myfree(srcdir);
|
||||
myfree(dstdir);
|
||||
myfree(finfo);
|
||||
return res;
|
||||
}
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
75
APP_R3221/App/FATFS/exfuns/exfuns.h
Normal file
75
APP_R3221/App/FATFS/exfuns/exfuns.h
Normal file
@@ -0,0 +1,75 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file extfuns.h
|
||||
* @author AMG Energy Solution Team
|
||||
* @version V1.0.0
|
||||
* @date 07-Feb-2022
|
||||
* @brief This file provides all the headers of the ext file functions.
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
|
||||
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
|
||||
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
|
||||
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
|
||||
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
|
||||
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
|
||||
*
|
||||
* <h2><center>© COPYRIGHT 2022 AMG</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __EXFUNS_H
|
||||
#define __EXFUNS_H
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "hc32_ddl.h"
|
||||
#include "ff.h"
|
||||
|
||||
/* Exported types ------------------------------------------------------------*/
|
||||
/* Exported constants --------------------------------------------------------*/
|
||||
//F_typetell returns the type definition
|
||||
//Table FILE_TYPE_TBL access to. exfuns.c definition
|
||||
#define T_BIN 0X00 //Bin file
|
||||
#define T_LRC 0X10 //lrc file
|
||||
#define T_NES 0X20 //nes file
|
||||
|
||||
#define T_TEXT 0X30 //.txt file
|
||||
#define T_C 0X31 //.c file
|
||||
#define T_H 0X32 //.h file
|
||||
|
||||
#define T_WAV 0X40 //WAV file
|
||||
#define T_MP3 0X41 //MP3 file
|
||||
#define T_APE 0X42 //APE file
|
||||
#define T_FLAC 0X43 //FLAC file
|
||||
|
||||
#define T_BMP 0X50 //bmp file
|
||||
#define T_JPG 0X51 //jpg file
|
||||
#define T_JPEG 0X52 //jpeg file
|
||||
#define T_GIF 0X53 //gif file
|
||||
|
||||
#define T_AVI 0X60 //avi file
|
||||
|
||||
/* Exported macro ------------------------------------------------------------*/
|
||||
/* Exported extern variables -------------------------------------------------*/
|
||||
extern FATFS *fs[_VOLUMES];
|
||||
extern FIL *file;
|
||||
extern FIL *ftemp;
|
||||
extern UINT br,bw;
|
||||
extern FILINFO fileinfo;
|
||||
extern DIR dir;
|
||||
extern uint8_t *fatbuf;//SD card data buffer
|
||||
|
||||
/* Exported functions ------------------------------------------------------- */
|
||||
uint8_t exfuns_init(void); //For the memory
|
||||
uint8_t f_typetell(uint8_t *fname); //Identify the file type
|
||||
uint8_t exf_getfree(uint8_t *drv,uint32_t *total,uint32_t *free); //Get the total disk capacity and remaining capacity
|
||||
uint32_t exf_fdsize(uint8_t *fdname); //Get folder size
|
||||
uint8_t* exf_get_src_dname(uint8_t* dpfn);
|
||||
uint8_t exf_copy(uint8_t(*fcpymsg)(uint8_t*pname,uint8_t pct,uint8_t mode),uint8_t *psrc,uint8_t *pdst,uint32_t totsize,uint32_t cpdsize,uint8_t fwmode); //File replication
|
||||
uint8_t exf_fdcopy(uint8_t(*fcpymsg)(uint8_t*pname,uint8_t pct,uint8_t mode),uint8_t *psrc,uint8_t *pdst,uint32_t *totsize,uint32_t *cpdsize,uint8_t fwmode);//Folder replication
|
||||
|
||||
#endif
|
||||
|
||||
/*******************(C)COPYRIGHT 2022 AMG ********************END OF FILE******/
|
||||
|
||||
341
APP_R3221/App/FATFS/exfuns/fattester.c
Normal file
341
APP_R3221/App/FATFS/exfuns/fattester.c
Normal file
@@ -0,0 +1,341 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* File Name : exfuns.c
|
||||
* Description : This file provides code for the configuration
|
||||
* of the External Functions instances.
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* <h2><center>© Copyright (c) 2019 STMicroelectronics.
|
||||
* All rights reserved.</center></h2>
|
||||
*
|
||||
* This software component is licensed by ST under Ultimate Liberty license
|
||||
* SLA0044, the "License"; You may not use this file except in compliance with
|
||||
* the License. You may obtain a copy of the License at:
|
||||
* www.st.com/SLA0044
|
||||
*
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include <string.h>
|
||||
#include "malloc.h"
|
||||
#include "fattester.h"
|
||||
#include "usart.h"
|
||||
#include "exfuns.h"
|
||||
#include "ff.h"
|
||||
#include "string.h"
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
//This program is for educational purposes only, without the author's permission, may not be used for any other purpose
|
||||
//ALIENTEK STM32F4 Explorer Board
|
||||
//FATFS Test code
|
||||
//Hot Atomic @ALIENTEK
|
||||
//Forum: www.openedv.com
|
||||
//Date modified: 2015/9/12
|
||||
//Version£ºV1.0
|
||||
//All rights reserved pirated reserved.
|
||||
//Copyright(C) Guangzhou wing electronic technology limited company 2009-2019
|
||||
//All rights reserved
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//For disk registration area
|
||||
//Path: a path on disk, such as "0:", "1:"
|
||||
//MT:0, do not register (register later); 1, register now
|
||||
//Return values: the results
|
||||
u8 mf_mount(u8* path,u8 mt)
|
||||
{
|
||||
return f_mount(fs[2],(const TCHAR*)path,mt);
|
||||
}
|
||||
//Open the file path
|
||||
//Path: path + file name
|
||||
//mode: open the mode
|
||||
//Return values: the results
|
||||
u8 mf_open(u8*path,u8 mode)
|
||||
{
|
||||
u8 res;
|
||||
res=f_open(file,(const TCHAR*)path,mode);//Open the folder
|
||||
return res;
|
||||
}
|
||||
//Close the file
|
||||
//Return values: the results
|
||||
u8 mf_close(void)
|
||||
{
|
||||
f_close(file);
|
||||
return 0;
|
||||
}
|
||||
//Read data
|
||||
//Len: read the length of the
|
||||
//Return values: the results
|
||||
u8 mf_read(u16 len)
|
||||
{
|
||||
u16 i,t;
|
||||
u8 res=0;
|
||||
u16 tlen=0;
|
||||
printf("\r\nRead file data is:\r\n");
|
||||
for(i=0;i<len/512;i++)
|
||||
{
|
||||
res=f_read(file,fatbuf,512,&br);
|
||||
if(res)
|
||||
{
|
||||
printf("Read Error:%d\r\n",res);
|
||||
break;
|
||||
}else
|
||||
{
|
||||
tlen+=br;
|
||||
for(t=0;t<br;t++)printf("%c",fatbuf[t]);
|
||||
}
|
||||
}
|
||||
if(len%512)
|
||||
{
|
||||
res=f_read(file,fatbuf,len%512,&br);
|
||||
if(res) //Error reading data
|
||||
{
|
||||
printf("\r\nRead Error:%d\r\n",res);
|
||||
}else
|
||||
{
|
||||
tlen+=br;
|
||||
for(t=0;t<br;t++)printf("%c",fatbuf[t]);
|
||||
}
|
||||
}
|
||||
if(tlen)printf("\r\nReaded data len:%d\r\n",tlen);//Read the length of the data
|
||||
printf("Read data over\r\n");
|
||||
return res;
|
||||
}
|
||||
//Writing data
|
||||
//dat:The data buffer
|
||||
//len:Writing to length
|
||||
//Return values: the results
|
||||
u8 mf_write(u8*dat,u16 len)
|
||||
{
|
||||
u8 res;
|
||||
|
||||
printf("\r\nBegin Write file...\r\n");
|
||||
printf("Write data len:%d\r\n",len);
|
||||
res=f_write(file,dat,len,&bw);
|
||||
if(res)
|
||||
{
|
||||
printf("Write Error:%d\r\n",res);
|
||||
}else printf("Writed data len:%d\r\n",bw);
|
||||
printf("Write data over.\r\n");
|
||||
return res;
|
||||
}
|
||||
|
||||
//Open Directory
|
||||
//Path: path
|
||||
//Return values: the results
|
||||
u8 mf_opendir(u8* path)
|
||||
{
|
||||
return f_opendir(&dir,(const TCHAR*)path);
|
||||
}
|
||||
//Close catalog
|
||||
//Return values: the results
|
||||
u8 mf_closedir(void)
|
||||
{
|
||||
return f_closedir(&dir);
|
||||
}
|
||||
//Reading folders
|
||||
//Return values: the results
|
||||
u8 mf_readdir(void)
|
||||
{
|
||||
u8 res;
|
||||
char *fn;
|
||||
#if _USE_LFN
|
||||
fileinfo.fsize = _MAX_LFN * 2 + 1;
|
||||
#endif
|
||||
res=f_readdir(&dir, &fileinfo);//Read a file information
|
||||
if(res!=FR_OK||fileinfo.fname[0]==0)
|
||||
{
|
||||
return res;//Read.
|
||||
}
|
||||
#if _USE_LFN
|
||||
fn=fileinfo.fname;
|
||||
#else
|
||||
fn=fileinfo.fname;;
|
||||
#endif
|
||||
printf("\r\n DIR info:\r\n");
|
||||
|
||||
printf("dir.id:%d\r\n" ,dir.obj.id);
|
||||
printf("dir.index:%d\r\n" ,(uint32_t)dir.dptr);
|
||||
// printf("dir.sclust:%d\r\n",(u32)dir.);
|
||||
printf("dir.clust:%d\r\n" ,(u32)dir.clust);
|
||||
printf("dir.sect:%d\r\n" ,(u32)dir.sect);
|
||||
|
||||
printf("\r\n");
|
||||
printf("File Name is:%s\r\n",fn);
|
||||
printf("File Size is:%d\r\n",(u32)fileinfo.fsize);
|
||||
printf("File data is:%d\r\n",(u32)fileinfo.fdate);
|
||||
printf("File time is:%d\r\n",(u32)fileinfo.ftime);
|
||||
printf("File Attr is:%d\r\n",(u32)fileinfo.fattrib);
|
||||
printf("\r\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
//Traversing file
|
||||
//path:path
|
||||
//Return values: the results
|
||||
u8 mf_scan_files(u8 * path)
|
||||
{
|
||||
FRESULT res;
|
||||
char *fn; /* This function is assuming non-Unicode cfg. */
|
||||
#if _USE_LFN
|
||||
fileinfo.fsize = _MAX_LFN * 2 + 1;
|
||||
#endif
|
||||
|
||||
res = f_opendir(&dir,(const TCHAR*)path); //Open a directory
|
||||
if (res == FR_OK)
|
||||
{
|
||||
printf("\r\n");
|
||||
while(1)
|
||||
{
|
||||
res = f_readdir(&dir, &fileinfo); //Read a file directory
|
||||
if (res != FR_OK || fileinfo.fname[0] == 0) break; //Errors/to the end of the exit
|
||||
//if (fileinfo.fname[0] == '.') continue; //Ignoring superior directory
|
||||
#if _USE_LFN
|
||||
fn = fileinfo.fname;
|
||||
#else
|
||||
fn = fileinfo.fname;
|
||||
#endif /* It is a file. */
|
||||
printf("%s/", path);//Print path
|
||||
printf("%s\r\n", fn);//Print file name
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
//Displays the remaining capacity
|
||||
//drv:Drive letter
|
||||
//Return value: remaining capacity (in bytes)
|
||||
u32 mf_showfree(u8 *drv)
|
||||
{
|
||||
FATFS *fs1;
|
||||
u8 res;
|
||||
u32 fre_clust=0, fre_sect=0, tot_sect=0;
|
||||
//Get disk information and the number of free clusters
|
||||
res = f_getfree((const TCHAR*)drv,(DWORD*)&fre_clust, &fs1);
|
||||
if(res==0)
|
||||
{
|
||||
tot_sect = (fs1->n_fatent - 2) * fs1->csize;//Total number of sectors
|
||||
fre_sect = fre_clust * fs1->csize; //Get number of spare sectors
|
||||
#if _MAX_SS!=512
|
||||
tot_sect*=fs1->ssize/512;
|
||||
fre_sect*=fs1->ssize/512;
|
||||
#endif
|
||||
if(tot_sect<20480)//Total capacity is less than 10M
|
||||
{
|
||||
/* Print free space in unit of KB (assuming 512 bytes/sector) */
|
||||
printf("\r\nThe total disk capacity:%d KB\r\n"
|
||||
"Free space:%d KB\r\n",
|
||||
tot_sect>>1,fre_sect>>1);
|
||||
}else
|
||||
{
|
||||
/* Print free space in unit of KB (assuming 512 bytes/sector) */
|
||||
printf("\r\nThe total disk capacity:%d MB\r\n"
|
||||
"Free space:%d MB\r\n",
|
||||
tot_sect>>11,fre_sect>>11);
|
||||
}
|
||||
}
|
||||
return fre_sect;
|
||||
}
|
||||
//File read/write pointer offset
|
||||
//offset:Relative offset of the first address
|
||||
//Return value: the results of execution.
|
||||
u8 mf_lseek(u32 offset)
|
||||
{
|
||||
return f_lseek(file,offset);
|
||||
}
|
||||
//Read the current position of the read/write pointer.
|
||||
//Return value:location
|
||||
u32 mf_tell(void)
|
||||
{
|
||||
return f_tell(file);
|
||||
}
|
||||
//Read the file size
|
||||
//Return value: file size
|
||||
u32 mf_size(void)
|
||||
{
|
||||
return f_size(file);
|
||||
}
|
||||
//Create a directory
|
||||
//pname:Directory path + name
|
||||
//Return values: the results
|
||||
u8 mf_mkdir(u8*pname)
|
||||
{
|
||||
return f_mkdir((const TCHAR *)pname);
|
||||
}
|
||||
//Format
|
||||
//path:Disk path, such as "0:", "1:"
|
||||
//mode:mode
|
||||
//au:Cluster size
|
||||
//Return values: the results
|
||||
//u8 mf_fmkfs(u8* path,u8 mode,u16 au)
|
||||
//{
|
||||
// return f_mkfs((const TCHAR*)path, mode, au, );//Format the drv: drive letter; mode: mode au: cluster size
|
||||
//}
|
||||
//Deleting files/directories
|
||||
//PName: file/directory path + name
|
||||
//Return values: the results
|
||||
u8 mf_unlink(u8 *pname)
|
||||
{
|
||||
return f_unlink((const TCHAR *)pname);
|
||||
}
|
||||
|
||||
//Modify file/directory names (if the directory is different, you can also move the file!)
|
||||
//Oldname: previous names
|
||||
//Newname new name
|
||||
//Return values: the results
|
||||
u8 mf_rename(u8 *oldname,u8* newname)
|
||||
{
|
||||
return f_rename((const TCHAR *)oldname,(const TCHAR *)newname);
|
||||
}
|
||||
//Gets the drive letter (disk name)
|
||||
//Path: a path on disk, such as "0:", "1:"
|
||||
void mf_getlabel(u8 *path)
|
||||
{
|
||||
u8 buf[20];
|
||||
u32 sn=0;
|
||||
u8 res;
|
||||
res=f_getlabel ((const TCHAR *)path,(TCHAR *)buf,(DWORD*)&sn);
|
||||
if(res==FR_OK)
|
||||
{
|
||||
printf("\r\nDisk%s Label:%s\r\n",path,buf);
|
||||
printf("Disk%s Serial Number:%X\r\n\r\n",path,sn);
|
||||
}else printf("\r\nFailed to get£¬Error code:%X\r\n",res);
|
||||
}
|
||||
//Set the drive letter (disk name), a maximum of 11 characters!! Support the combination of numbers and uppercase letters and Chinese characters
|
||||
//path:Disk number + name£¬For example,"0:ALIENTEK"¡¢"1:OPENEDV"
|
||||
void mf_setlabel(u8 *path)
|
||||
{
|
||||
u8 res;
|
||||
res=f_setlabel ((const TCHAR *)path);
|
||||
if(res==FR_OK)
|
||||
{
|
||||
printf("\r\nDisk drive letter set successfully:%s\r\n",path);
|
||||
}else printf("\r\nDisk drive letter set£¬Error code:%X\r\n",res);
|
||||
}
|
||||
|
||||
//Read a string from file
|
||||
//size:To read the length of the
|
||||
void mf_gets(u16 size)
|
||||
{
|
||||
TCHAR* rbuf;
|
||||
rbuf=f_gets((TCHAR*)fatbuf,size,file);
|
||||
if(*rbuf==0)return ;//No data to read
|
||||
else
|
||||
{
|
||||
printf("\r\nThe String Readed Is:%s\r\n",rbuf);
|
||||
}
|
||||
}
|
||||
//Need _USE_STRFUNC>=1
|
||||
//Write a character to a file
|
||||
//c:The character to write
|
||||
//Return values: the results
|
||||
u8 mf_putc(u8 c)
|
||||
{
|
||||
return f_putc((TCHAR)c,file);
|
||||
}
|
||||
//Write a string to a file
|
||||
//c:The string to be written
|
||||
//Return value: writes the length of the string
|
||||
u8 mf_puts(u8*c)
|
||||
{
|
||||
return f_puts((TCHAR*)c,file);
|
||||
}
|
||||
71
APP_R3221/App/FATFS/exfuns/fattester.h
Normal file
71
APP_R3221/App/FATFS/exfuns/fattester.h
Normal file
@@ -0,0 +1,71 @@
|
||||
#ifndef __FATTESTER_H
|
||||
#define __FATTESTER_H
|
||||
#include <stm32f4xx.h>
|
||||
#include "ff.h"
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
|
||||
//ALIENTEK STM32F407开发板
|
||||
//FATFS 测试代码
|
||||
//正点原子@ALIENTEK
|
||||
//技术论坛:www.openedv.com
|
||||
//创建日期:2014/5/15
|
||||
//版本：V1.0
|
||||
//版权所有，盗版必究。
|
||||
//Copyright(C) 广州市星翼电子科技有限公司 2014-2024
|
||||
//All rights reserved
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
u8 mf_mount(u8* path,u8 mt);
|
||||
u8 mf_open(u8*path,u8 mode);
|
||||
u8 mf_close(void);
|
||||
u8 mf_read(u16 len);
|
||||
u8 mf_write(u8*dat,u16 len);
|
||||
u8 mf_opendir(u8* path);
|
||||
u8 mf_closedir(void);
|
||||
u8 mf_readdir(void);
|
||||
u8 mf_scan_files(u8 * path);
|
||||
u32 mf_showfree(u8 *drv);
|
||||
u8 mf_lseek(u32 offset);
|
||||
u32 mf_tell(void);
|
||||
u32 mf_size(void);
|
||||
u8 mf_mkdir(u8*pname);
|
||||
u8 mf_fmkfs(u8* path,u8 mode,u16 au);
|
||||
u8 mf_unlink(u8 *pname);
|
||||
u8 mf_rename(u8 *oldname,u8* newname);
|
||||
void mf_getlabel(u8 *path);
|
||||
void mf_setlabel(u8 *path);
|
||||
void mf_gets(u16 size);
|
||||
u8 mf_putc(u8 c);
|
||||
u8 mf_puts(u8*c);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
70
APP_R3221/App/FATFS/exfuns/mycc936.c
Normal file
70
APP_R3221/App/FATFS/exfuns/mycc936.c
Normal file
@@ -0,0 +1,70 @@
|
||||
#include "ff.h"
|
||||
#include "fontupd.h"
|
||||
#include "w25qxx.h"
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
|
||||
//ALIENTEK STM32F407开发板
|
||||
//cc936.c修改后 代码
|
||||
//正点原子@ALIENTEK
|
||||
//技术论坛:www.openedv.com
|
||||
//创建日期:2014/5/15
|
||||
//版本：V1.0
|
||||
//版权所有，盗版必究。
|
||||
//Copyright(C) 广州市星翼电子科技有限公司 2014-2024
|
||||
//All rights reserved
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
WCHAR ff_convert ( /* Converted code, 0 means conversion error */
|
||||
WCHAR src, /* Character code to be converted */
|
||||
UINT dir /* 0: Unicode to OEMCP, 1: OEMCP to Unicode */
|
||||
)
|
||||
{
|
||||
// WCHAR t[2];
|
||||
WCHAR c;
|
||||
// u32 i, li, hi;
|
||||
// u16 n;
|
||||
// u32 gbk2uni_offset=0;
|
||||
|
||||
// if (src < 0x80)c = src;//ASCII,直接不用转换.
|
||||
// else
|
||||
// {
|
||||
// if(dir) //GBK 2 UNICODE
|
||||
// {
|
||||
// gbk2uni_offset=ftinfo.ugbksize/2;
|
||||
// }else //UNICODE 2 GBK
|
||||
// {
|
||||
// gbk2uni_offset=0;
|
||||
// }
|
||||
// /* Unicode to OEMCP */
|
||||
// hi=ftinfo.ugbksize/2;//对半开.
|
||||
// hi =hi / 4 - 1;
|
||||
// li = 0;
|
||||
// for (n = 16; n; n--)
|
||||
// {
|
||||
// i = li + (hi - li) / 2;
|
||||
// W25QXX_Read((u8*)&t,ftinfo.ugbkaddr+i*4+gbk2uni_offset,4);//读出4个字节
|
||||
// if (src == t[0]) break;
|
||||
// if (src > t[0])li = i;
|
||||
// else hi = i;
|
||||
// }
|
||||
// c = n ? t[1] : 0;
|
||||
// }
|
||||
return c;
|
||||
}
|
||||
|
||||
WCHAR ff_wtoupper ( /* Upper converted character */
|
||||
WCHAR chr /* Input character */
|
||||
)
|
||||
{
|
||||
static const WCHAR tbl_lower[] = { 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xA1, 0x00A2, 0x00A3, 0x00A5, 0x00AC, 0x00AF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0x0FF, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F, 0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D, 0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B, 0x12D, 0x12F, 0x131, 0x133, 0x135, 0x137, 0x13A, 0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x148, 0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157, 0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165, 0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173, 0x175, 0x177, 0x17A, 0x17C, 0x17E, 0x192, 0x3B1, 0x3B2, 0x3B3, 0x3B4, 0x3B5, 0x3B6, 0x3B7, 0x3B8, 0x3B9, 0x3BA, 0x3BB, 0x3BC, 0x3BD, 0x3BE, 0x3BF, 0x3C0, 0x3C1, 0x3C3, 0x3C4, 0x3C5, 0x3C6, 0x3C7, 0x3C8, 0x3C9, 0x3CA, 0x430, 0x431, 0x432, 0x433, 0x434, 0x435, 0x436, 0x437, 0x438, 0x439, 0x43A, 0x43B, 0x43C, 0x43D, 0x43E, 0x43F, 0x440, 0x441, 0x442, 0x443, 0x444, 0x445, 0x446, 0x447, 0x448, 0x449, 0x44A, 0x44B, 0x44C, 0x44D, 0x44E, 0x44F, 0x451, 0x452, 0x453, 0x454, 0x455, 0x456, 0x457, 0x458, 0x459, 0x45A, 0x45B, 0x45C, 0x45E, 0x45F, 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, 0x217E, 0x217F, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A, 0 };
|
||||
static const WCHAR tbl_upper[] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x21, 0xFFE0, 0xFFE1, 0xFFE5, 0xFFE2, 0xFFE3, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0x178, 0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x132, 0x134, 0x136, 0x139, 0x13B, 0x13D, 0x13F, 0x141, 0x143, 0x145, 0x147, 0x14A, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x179, 0x17B, 0x17D, 0x191, 0x391, 0x392, 0x393, 0x394, 0x395, 0x396, 0x397, 0x398, 0x399, 0x39A, 0x39B, 0x39C, 0x39D, 0x39E, 0x39F, 0x3A0, 0x3A1, 0x3A3, 0x3A4, 0x3A5, 0x3A6, 0x3A7, 0x3A8, 0x3A9, 0x3AA, 0x410, 0x411, 0x412, 0x413, 0x414, 0x415, 0x416, 0x417, 0x418, 0x419, 0x41A, 0x41B, 0x41C, 0x41D, 0x41E, 0x41F, 0x420, 0x421, 0x422, 0x423, 0x424, 0x425, 0x426, 0x427, 0x428, 0x429, 0x42A, 0x42B, 0x42C, 0x42D, 0x42E, 0x42F, 0x401, 0x402, 0x403, 0x404, 0x405, 0x406, 0x407, 0x408, 0x409, 0x40A, 0x40B, 0x40C, 0x40E, 0x40F, 0x2160, 0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0x216A, 0x216B, 0x216C, 0x216D, 0x216E, 0x216F, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0 };
|
||||
int i;
|
||||
|
||||
|
||||
for (i = 0; tbl_lower[i] && chr != tbl_lower[i]; i++) ;
|
||||
|
||||
return tbl_lower[i] ? tbl_upper[i] : chr;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user