Mostly the _T, _TEXT and such provide an auto-switching trick for programs that need to be compiled as both Unicode or Ansi versions. These are macros (open tchar.h in the source editor and look at it) that respond to the UNICODE and _UNICODE defines... when unicode is defined they insert an L before your string literals, when it's not defined they do nothing ... L"Hello" vs "Hello". The L prefix means "long characters" or "wide characters" (whichever way you know them).
The UNICODE define in Windows switches all windows API calls to their wide character versions. To see the switching mechanism look at some windows headers in the source editor (just don't edit them or save them!) you will find most API calls have two versions... FunctionNameA() for Ansi and FunctionNameW() for unicode. With UNICODE defined, FunctionName() gets you the W version, with it not defined you get the A version.
In windows UNICODE is utf16le
unicode... In linux and other operating systems it may signify a different unicode format... and there are several, including utf8 which Windows calls mbcs (multibyte character set).
Text isn't just text anymore... now it's a huge jumble of formats and character sets. To give you an example, here's what it takes to open a simple playlist where the source file might be any of several unicode formats:
// parse input file to strings
void CopyWChar(PWCHAR Buf)
{ PWCHAR tok; // token string
PWCHAR nt; // next token
WCHAR fp[MAX_PATH]; // line buffer
nt = wcstok(Buf,L"\r\n",&tok);
while(nt)
{ // ignore comments and urls
if ((nt[0] != '#') && (!PathIsURL(nt)))
{ // test for relative paths
if (PathIsRelative( nt ))
{ wcscpy(fp,FilePath);
wcscat(fp,nt); }
else
wcscpy(fp,nt);
// test for folders
if (PathFileExists( fp ))
{ if (PathIsDirectory( fp ))
ExpandFolder( fp );
else
AddLine( fp ); } }
nt = wcstok(tok,L"\r\n",&tok); }
// randomize here
ShuffleList();
SavePlayerFile(); }
// convert mbyte to utf16le for parser
void CopyMByte(PBYTE Buf, DWORD Bytes)
{ PWCHAR ut = calloc(Bytes + 1,sizeof(WCHAR)); // unicode buffer
try
{ if (MultiByteToWideChar(CP_UTF8,0,(PCHAR)Buf,Bytes,ut,Bytes * sizeof(WCHAR)) < 1)
Exception(0xE0640006);
CopyWChar( ut ); }
finally
{ free (ut); } }
// convert UTF-16 byte order
void FlipEndian(PBYTE Buf, DWORD Bytes)
{ BYTE t; // temp for swaps
for (INT i = 0; i < Bytes; i += 2)
{ t = Buf[i];
Buf[i] = Buf[i + 1];
Buf[i + 1] = t; } }
// open and translate file
BOOL M3ULaunch(PWCHAR FileName)
{ PBYTE rf; // raw file data
DWORD br; // bytes read
// load the raw file
{ HANDLE pl; // playlist file handle
DWORD fs; // file size
// get path to file
wcsncpy(FilePath,FileName,MAX_PATH);
PathRemoveFileSpec(FilePath);
wcscat(FilePath,L"\\");
// open the file
pl = CreateFile(FileName,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
if (pl == INVALID_HANDLE_VALUE)
Exception(GetLastError());
fs = GetFileSize(pl,NULL);
rf = calloc(fs + 2, sizeof(BYTE));
if (! ReadFile(pl, rf, fs, &br, NULL))
Exception(GetLastError());
CloseHandle(pl);
if (br != fs)
Exception(0xE00640007); }
try
{ DWORD bom = *(DWORD*)rf;
if ((bom == 0x0000FEFF) || (bom == 0xFFFE0000)) // utf32le bom
Exception(0xE0640002); // utf32be bom
else if ((bom & 0xFFFF) == 0xFFFE) // utf16be bom
{ FlipEndian(rf,br);
CopyWChar((PWCHAR) rf + 1); }
else if ((bom & 0xFFFF) == 0xFEFF) // utf16le bom
CopyWChar((PWCHAR) rf + 1);
else if ((bom & 0xFFFFFF) == 0xBFBBEF) // utf8 bom
CopyMByte(rf + 3, br - 3);
else // no known bom, probe the file
{ if (! memchr(rf, 0x00, br)) // 8 bit text has no nulls
CopyMByte(rf,br); // ansi / utf8 no bom
else
{ PBYTE lf = memchr(rf,0x0A,br); // lf is always present as 1 byte.
if (!lf)
Exception(0xE0640003);
if ((!(*(DWORD*)(lf - 3) & 0x00FFFFFF)) || //utf32be no bom
(!(*(DWORD*)lf & 0xFFFFFF00))) //utf32le no bom
Exception(0xE0640002);
if ((lf - rf) & 1) // big endian? (lf at odd offset)
FlipEndian(rf,br); // utf16be no bom
CopyWChar((PWCHAR) rf); } } } // utf16le no bom
finally
{ free(rf); }
return 1; }
... and that's just to open the file and convert it to Windows compatible wide character strings...
Yes... it's confusing at first... but unicode is the best means of internationalization we have at this time. It can handle even the most complex languages (such as traditional Japanese and Farsi)... Most modern programs are written exclusively in unicode formats, so that at least user entered text is language independent.
For indepth information on Unicode and it's various formats... Google is your friend
There's a ton of information out there.
