hyzboy/CMCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

support "u8char" type

Browse Source
This commit is contained in:
hyzboy 2020-07-07 19:14:42 +08:00
parent 5e67c0cef7
commit f6a846c655
22 changed files with 92 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
inc/hgl/CodePage.h
View File

@ -85,7 +85,7 @@ namespace hgl
constexpr int CharPageCount=sizeof(CodeSet2CharPage)/sizeof(CodePageAndCharSet); constexpr int CharPageCount=sizeof(CodeSet2CharPage)/sizeof(CodePageAndCharSet);
inline CharCodePage FindCodePage(const char *char_set) inline CharCodePage FindCodePage(const u8char *char_set)
{ {
for(int i=0;i<CharPageCount;i++) for(int i=0;i<CharPageCount;i++)
if(!charset_cmp(CodePage2CharSet[i].charset,char_set)) if(!charset_cmp(CodePage2CharSet[i].charset,char_set))
@ -104,17 +104,17 @@ namespace hgl
CharSet() CharSet()
{ {
codepage=ccpNone; codepage=ccpNone;
strcpy(charset,CharSetNameLength,"us-ascii"); hgl::strcpy(charset,CharSetNameLength,"us-ascii");
} }
CharSet(CharCodePage ccp,const char *cs) CharSet(CharCodePage ccp,const char *cs)
{ {
codepage=ccp; codepage=ccp;
strcpy(charset,CharSetNameLength,cs); hgl::strcpy(charset,CharSetNameLength,cs);
} }
CharSet(CharCodePage); CharSet(CharCodePage);
CharSet(const char *); CharSet(const u8char *);
CharSet(const CodePageAndCharSet &cs) CharSet(const CodePageAndCharSet &cs)
{ {
@ -129,13 +129,13 @@ namespace hgl
inline CharSet::CharSet(CharCodePage ccp) inline CharSet::CharSet(CharCodePage ccp)
{ {
codepage=ccp; codepage=ccp;
strcpy(charset,CharSetNameLength,FindCharSet(ccp)); hgl::strcpy(charset,CharSetNameLength,FindCharSet(ccp));
} }
inline CharSet::CharSet(const char *cs) inline CharSet::CharSet(const u8char *cs)
{ {
codepage=FindCodePage(cs); codepage=FindCodePage(cs);
strcpy(charset,CharSetNameLength,FindCharSet(codepage)); hgl::strcpy(charset,CharSetNameLength,FindCharSet(codepage));
} }
extern CharSet DefaultCharSet(); extern CharSet DefaultCharSet();
@ -152,9 +152,9 @@ namespace hgl
* @param src_size 字符串长度,-1表示全部 * @param src_size 字符串长度,-1表示全部
* @return 转换成功后的字符串字符数 * @return 转换成功后的字符串字符数
*/ */
int to_utf16(const CharSet &charset,u16char **dst,const char *src,const int src_size=-1); int to_utf16(const CharSet &charset,u16char **dst,const void *src,const int src_size=-1);
int to_utf8(const CharSet &charset,char **dst,const char *src,const int src_size=-1); int to_utf8(const CharSet &charset,u8char **dst,const void *src,const int src_size=-1);
/** /**
* 转换u16char *字符串到指定字符集的字符串 * 转换u16char *字符串到指定字符集的字符串
@ -164,29 +164,29 @@ namespace hgl
* @param src_size 字符串长度,-1表示全部 * @param src_size 字符串长度,-1表示全部
* @return 转换成功后的字符串字符数 * @return 转换成功后的字符串字符数
*/ */
int utf16_to(const CharSet &charset,char **dst,const u16char *src,const int src_size=-1); int utf16_to(const CharSet &charset,u8char **dst,const u16char *src,const int src_size=-1);
int utf8_to(const CharSet &charset,char **dst,const char *src,const int src_size=-1); int utf8_to(const CharSet &charset,u8char **dst,const u8char *src,const int src_size=-1);
int u16_to_u8(char *,int,const u16char *,const int=-1); ///<转换u16char *到utf8格式的char * int u16_to_u8(u8char *,int,const u16char *,const int=-1); ///<转换u16char *到utf8格式的u8char *
int u8_to_u16(u16char *,int,const char *,const int=-1); ///<转换utf8格式的char *到u16char * int u8_to_u16(u16char *,int,const u8char *,const int=-1); ///<转换utf8格式的u8char *到u16char *
char * u16_to_u8(const u16char *,const int,int &); ///<转换u16char *到utf8格式的char * u8char * u16_to_u8(const u16char *,const int,int &); ///<转换u16char *到utf8格式的u8char *
u16char * u8_to_u16(const char *,const int,int &); ///<转换utf8格式的char *到u16char * u16char * u8_to_u16(const u8char *,const int,int &); ///<转换utf8格式的u8char *到u16char *
inline char * u16_to_u8(const u16char *str) inline u8char * u16_to_u8(const u16char *str)
{ {
int len; int len;
return u16_to_u8(str,hgl::strlen<u16char>(str)+1,len); return u16_to_u8(str,hgl::strlen<u16char>(str)+1,len);
} }
inline u16char *u8_to_u16(const char *str) inline u16char *u8_to_u16(const u8char *str)
{ {
int len; int len;
return u8_to_u16(str,hgl::strlen<char>(str)+1,len); return u8_to_u16(str,hgl::strlen<u8char>(str)+1,len);
} }
inline UTF16String to_u16(const char *u8_str,int length) inline UTF16String to_u16(const u8char *u8_str,int length)
{ {
int wlen; int wlen;
u16char *ws=u8_to_u16(u8_str,length,wlen); u16char *ws=u8_to_u16(u8_str,length,wlen);
@ -199,7 +199,7 @@ namespace hgl
return to_u16(u8str.c_str(),u8str.Length()); return to_u16(u8str.c_str(),u8str.Length());
} }
inline UTF16String to_u16(const char *str) inline UTF16String to_u16(const u8char *str)
{ {
int wlen; int wlen;
@ -212,7 +212,7 @@ namespace hgl
{ {
int ulen; int ulen;
char *us=u16_to_u8(wide_str,length,ulen); u8char *us=u16_to_u8(wide_str,length,ulen);
return UTF8String::newOf(us,ulen); return UTF8String::newOf(us,ulen);
} }
@ -223,7 +223,7 @@ namespace hgl
} }
#if HGL_OS == HGL_OS_Windows #if HGL_OS == HGL_OS_Windows
inline OSString ToOSString(const char *str){return to_u16(str);} inline OSString ToOSString(const u8char *str){return to_u16(str);}
inline OSString ToOSString(const UTF8String &str){return to_u16(str.c_str(), (int)(str.Length()));} inline OSString ToOSString(const UTF8String &str){return to_u16(str.c_str(), (int)(str.Length()));}
inline UTF8String ToUTF8String(const os_char *str){return to_u8(str,strlen(str));} inline UTF8String ToUTF8String(const os_char *str){return to_u8(str,strlen(str));}

8
inc/hgl/Endian.h
View File

@ -58,10 +58,10 @@ namespace hgl
bomEnd bomEnd
}; };
constexpr uint CharSetNameLength=32; ///<字符集名称长度 constexpr uint CharSetNameLength=32; ///<字符集名称长度
using CharSetName=char[CharSetNameLength]; ///<字符集名称类型定义 using CharSetName=char[CharSetNameLength]; ///<字符集名称类型定义
template<int,char> const CharSetName &GetCurCharSet(); ///<取得当前程序编码字符集 template<int,char> const CharSetName &GetCurCharSet(); ///<取得当前程序编码字符集
constexpr CharSetName utf8_charset="utf8"; constexpr CharSetName utf8_charset="utf8";
constexpr CharSetName utf16le_charset="utf-16le"; constexpr CharSetName utf16le_charset="utf-16le";
@ -85,7 +85,7 @@ namespace hgl
struct BOMFileHeader struct BOMFileHeader
{ {
int size; ///<字节序文件头长度 int size; ///<字节序文件头长度
unsigned char data[4]; ///<字节序数据 uint8 data[4]; ///<字节序数据
ByteOrderMask bom; ///<字节序枚举 ByteOrderMask bom; ///<字节序枚举
const CharSetName *char_set;///<字符集名称 const CharSetName *char_set;///<字符集名称

2
inc/hgl/filesystem/FileSystem.h
View File

@ -147,7 +147,7 @@ namespace hgl
} }
inline UTF8String MergeFilename(const UTF8String &pathname,const UTF8String &filename) ///<组合路径名与文件名 inline UTF8String MergeFilename(const UTF8String &pathname,const UTF8String &filename) ///<组合路径名与文件名
{return MergeFilename<char>(pathname,filename,HGL_DIRECTORY_SEPARATOR,HGL_DIRECTORY_SEPARATOR_U8STR);} {return MergeFilename<u8char>(pathname,filename,HGL_DIRECTORY_SEPARATOR,HGL_DIRECTORY_SEPARATOR_U8STR);}
inline WideString MergeFilename(const WideString &pathname,const WideString &filename) ///<组合路径名与文件名 inline WideString MergeFilename(const WideString &pathname,const WideString &filename) ///<组合路径名与文件名
{return MergeFilename<wchar_t>(pathname,filename,L'\\',L"\\");} {return MergeFilename<wchar_t>(pathname,filename,L'\\',L"\\");}

14
inc/hgl/io/DataOutputStream.h
View File

@ -140,7 +140,7 @@ namespace hgl
template<typename T> bool WriteUTF16LEChars (const BaseString<T> &str){return WriteUTF16LEChars (str.c_str(),str.Length());} template<typename T> bool WriteUTF16LEChars (const BaseString<T> &str){return WriteUTF16LEChars (str.c_str(),str.Length());}
template<typename T> bool WriteUTF16BEChars (const BaseString<T> &str){return WriteUTF16BEChars (str.c_str(),str.Length());} template<typename T> bool WriteUTF16BEChars (const BaseString<T> &str){return WriteUTF16BEChars (str.c_str(),str.Length());}
template<typename T> bool WriteUTF8StringWithLength (const char *str,const uint length); template<typename T> bool WriteUTF8StringWithLength (const u8char *str,const uint length);
template<typename T> bool WriteUTF8StringWithLength (const UTF16String &str); template<typename T> bool WriteUTF8StringWithLength (const UTF16String &str);
template<uchar C,typename T> bool WriteUTF16StringWithLength(const u16char *str,const uint len); template<uchar C,typename T> bool WriteUTF16StringWithLength(const u16char *str,const uint len);
@ -148,8 +148,8 @@ namespace hgl
public: public:
//32 bit length //32 bit length
bool WriteUTF8String (const char *str,uint length); ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列) bool WriteUTF8String (const u8char *str,uint length); ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF8String (const char *str ); ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列) bool WriteUTF8String (const u8char *str ); ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF8String (const UTF8String &str ); ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列) bool WriteUTF8String (const UTF8String &str ); ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool WriteUTF8String (const UTF16String &str ); ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列) bool WriteUTF8String (const UTF16String &str ); ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
@ -166,8 +166,8 @@ namespace hgl
bool WriteUTF16BEString (const UTF8String &str ){return WriteUTF16BEString(to_u16(str));} ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列) bool WriteUTF16BEString (const UTF8String &str ){return WriteUTF16BEString(to_u16(str));} ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
//16 bit length //16 bit length
bool WriteUTF8ShortString (const char *str,uint length); ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列) bool WriteUTF8ShortString (const u8char *str,uint length); ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF8ShortString (const char *str ); ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列) bool WriteUTF8ShortString (const u8char *str ); ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF8ShortString (const UTF8String &str ); ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列) bool WriteUTF8ShortString (const UTF8String &str ); ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool WriteUTF8ShortString (const UTF16String &str ); ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列) bool WriteUTF8ShortString (const UTF16String &str ); ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
@ -184,8 +184,8 @@ namespace hgl
bool WriteUTF16BEShortString(const UTF8String &str ){return WriteUTF16BEShortString(to_u16(str));} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列) bool WriteUTF16BEShortString(const UTF8String &str ){return WriteUTF16BEShortString(to_u16(str));} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
//8 bit length //8 bit length
bool WriteUTF8TinyString (const char *str,uint length); ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列) bool WriteUTF8TinyString (const u8char *str,uint length); ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF8TinyString (const char *str ); ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列) bool WriteUTF8TinyString (const u8char *str ); ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF8TinyString (const UTF8String &str ); ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列) bool WriteUTF8TinyString (const UTF8String &str ); ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool WriteUTF8TinyString (const UTF16String &str ); ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列) bool WriteUTF8TinyString (const UTF16String &str ); ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)

4
inc/hgl/io/TextOutputStream.h
View File

@ -55,7 +55,7 @@ namespace hgl
return(out->Write(bom_item->data,bom_item->size)==bom_item->size); return(out->Write(bom_item->data,bom_item->size)==bom_item->size);
} }
virtual bool WriteChars(const char *,int64)=0; ///<写入一个字符串 virtual bool WriteChars(const u8char *,int64)=0; ///<写入一个字符串
virtual bool WriteChars(const u16char *,int64)=0; ///<写入一个字符串 virtual bool WriteChars(const u16char *,int64)=0; ///<写入一个字符串
template<typename N> template<typename N>
@ -162,7 +162,7 @@ namespace hgl
EndianTextOutputStream(OutputStream *); EndianTextOutputStream(OutputStream *);
bool WriteChars(const char *,int64); ///<写入一个字符串 bool WriteChars(const u8char *,int64); ///<写入一个字符串
bool WriteChars(const u16char *,int64); ///<写入一个字符串 bool WriteChars(const u16char *,int64); ///<写入一个字符串
};//template<ByteOrderMask BOM> class EndianTextOutputStream };//template<ByteOrderMask BOM> class EndianTextOutputStream

9
inc/hgl/log/LogInfo.h
View File

@ -30,18 +30,23 @@ namespace hgl
} }
inline void Log(LogLevel ll,const UTF8String &str) inline void Log(LogLevel ll,const UTF8String &str)
{
std::cout<<(char *)str.c_str()<<std::endl;
}
inline void Log(LogLevel ll,const AnsiString &str)
{ {
std::cout<<str.c_str()<<std::endl; std::cout<<str.c_str()<<std::endl;
} }
inline void DebugLog(LogLevel ll,const UTF16String &str,const char *filename,int line,const char *funcname) inline void DebugLog(LogLevel ll,const UTF16String &str,const char *filename,int line,const char *funcname)
{ {
Log(ll,str+U16_TEXT(">>LogFrom(\"")+to_u16(filename)+U16_TEXT("\", ")+UTF16String::valueOf(line)+U16_TEXT(" line,func:\"")+to_u16(funcname)+U16_TEXT("\")")); Log(ll,str+U16_TEXT(">>LogFrom(\"")+to_u16((u8char *)filename)+U16_TEXT("\", ")+UTF16String::valueOf(line)+U16_TEXT(" line,func:\"")+to_u16((u8char *)funcname)+U16_TEXT("\")"));
} }
inline void DebugLog(LogLevel ll,const UTF8String &str,const char *filename,int line,const char *funcname) inline void DebugLog(LogLevel ll,const UTF8String &str,const char *filename,int line,const char *funcname)
{ {
Log(ll,str+U8_TEXT(">>LogFrom(\"")+UTF8String(filename)+U8_TEXT("\", ")+UTF8String::valueOf(line)+U8_TEXT(" line,func:\"")+UTF8String(funcname)+U8_TEXT("\")")); Log(ll,str+U8_TEXT(">>LogFrom(\"")+UTF8String((u8char *)filename)+U8_TEXT("\", ")+UTF8String::valueOf(line)+U8_TEXT(" line,func:\"")+UTF8String((u8char *)funcname)+U8_TEXT("\")"));
} }
#define LOG_INFO(str) {Log(llLog, str);} #define LOG_INFO(str) {Log(llLog, str);}

2
inc/hgl/log/Logger.h
View File

@ -35,7 +35,7 @@ namespace hgl
virtual void Close()=0; ///<关闭日志 virtual void Close()=0; ///<关闭日志
virtual void Write(const u16char *,int)=0; ///<输出一行u16char日志 virtual void Write(const u16char *,int)=0; ///<输出一行u16char日志
virtual void Write(const char *,int)=0; ///<输出一行char(utf8)日志 virtual void Write(const u8char *,int)=0; ///<输出一行u8char日志
};//class Logger };//class Logger
}//namespace logger }//namespace logger

2
inc/hgl/platform/os/CharType.h
View File

@ -3,7 +3,9 @@
using u32char =char32_t; using u32char =char32_t;
using u16char =char16_t; using u16char =char16_t;
using u8char =char8_t;
using os_char =char; using os_char =char;
#define to_oschar to_u8 #define to_oschar to_u8
#define OS_TEXT(str) u8##str #define OS_TEXT(str) u8##str
#define U8_TEXT(str) u8##str #define U8_TEXT(str) u8##str

3
inc/hgl/platform/os/MSWindows.h
View File

@ -4,13 +4,16 @@
#include<malloc.h> #include<malloc.h>
#include<winsock2.h> //winsock2必须在Windows.h前面，不然会报错 #include<winsock2.h> //winsock2必须在Windows.h前面，不然会报错
#include<windows.h> #include<windows.h>
#include<uchar.h>
#undef min #undef min
#undef max #undef max
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
using u32char =char32_t; using u32char =char32_t;
using u16char =wchar_t; using u16char =wchar_t;
using u8char =char8_t;
using os_char =wchar_t; using os_char =wchar_t;
#define to_oschar to_u16 #define to_oschar to_u16
#define OS_TEXT(str) L##str #define OS_TEXT(str) L##str
#define U8_TEXT(str) u8##str #define U8_TEXT(str) u8##str

2
inc/hgl/thread/Thread.h
View File

@ -58,7 +58,7 @@ namespace hgl
virtual bool ProcStartThread() ///<线程启动运行函数,在Execute前被调用 virtual bool ProcStartThread() ///<线程启动运行函数,在Execute前被调用
{ {
#ifdef _DEBUG #ifdef _DEBUG
char thread_addr[(sizeof(thread_ptr)<<1)+1]; u8char thread_addr[(sizeof(thread_ptr)<<1)+1];
DataToUpperHexStr(thread_addr,(uint8 *)&tp,sizeof(thread_ptr)); DataToUpperHexStr(thread_addr,(uint8 *)&tp,sizeof(thread_ptr));

6
inc/hgl/type/BaseString.h
View File

@ -1289,12 +1289,12 @@ namespace hgl
return BaseString<T>(value)+str; return BaseString<T>(value)+str;
} }
using UTF8String =BaseString<char>;
using AnsiString =BaseString<char>; using AnsiString =BaseString<char>;
using UTF8String =BaseString<u8char>;
using UTF16String =BaseString<u16char>; using UTF16String =BaseString<u16char>;
using OSString =BaseString<os_char>;
using UTF32String =BaseString<char32_t>; using UTF32String =BaseString<char32_t>;
using OSString =BaseString<os_char>;
using WideString =BaseString<wchar_t>; using WideString =BaseString<wchar_t>;
template<typename C> bool ToNumber(const BaseString<C> &str,int &value){return str.ToInt(value);} template<typename C> bool ToNumber(const BaseString<C> &str,int &value){return str.ToInt(value);}

7
inc/hgl/type/StdString.h
View File

@ -7,14 +7,14 @@
#if HGL_OS == HGL_OS_Windows #if HGL_OS == HGL_OS_Windows
inline hgl::OSString std_to_os(const std::string &str) inline hgl::OSString std_to_os(const std::string &str)
{ {
return hgl::to_u16(str.c_str(),(int)(str.length())); return hgl::to_u16((u8char *)str.c_str(),(int)(str.length()));
} }
inline std::string to_std(const hgl::OSString &str) inline std::string to_std(const hgl::OSString &str)
{ {
hgl::UTF8String u8_str=hgl::to_u8(str); hgl::UTF8String u8_str=hgl::to_u8(str);
return std::string(u8_str.c_str(),str.Length()); return std::string((char *)u8_str.c_str(),str.Length());
} }
#else #else
inline hgl::OSString std_to_os(const std::string &str) inline hgl::OSString std_to_os(const std::string &str)
@ -30,6 +30,5 @@ inline std::string to_std(const hgl::OSString &str)
inline hgl::UTF8String std_to_u8(const std::string &str) inline hgl::UTF8String std_to_u8(const std::string &str)
{ {
return hgl::UTF8String(str.c_str(),int(str.size())); return hgl::UTF8String((u8char *)str.c_str(),int(str.size()));
} }

2
inc/hgl/type/StringList.h
View File

@ -639,7 +639,7 @@ namespace hgl
return(result); return(result);
}//int LoadStringList }//int LoadStringList
inline int LoadUTF8StringList (UTF8StringList & sl,io::DataInputStream *dis){return LoadStringList<char, bomUTF8 >(sl,dis);} inline int LoadUTF8StringList (UTF8StringList & sl,io::DataInputStream *dis){return LoadStringList<u8char, bomUTF8 >(sl,dis);}
inline int LoadUTF16LEStringList (UTF16StringList & sl,io::DataInputStream *dis){return LoadStringList<u16char, bomUTF16LE >(sl,dis);} inline int LoadUTF16LEStringList (UTF16StringList & sl,io::DataInputStream *dis){return LoadStringList<u16char, bomUTF16LE >(sl,dis);}
inline int LoadUTF16BEStringList (UTF16StringList & sl,io::DataInputStream *dis){return LoadStringList<u16char, bomUTF16BE >(sl,dis);} inline int LoadUTF16BEStringList (UTF16StringList & sl,io::DataInputStream *dis){return LoadStringList<u16char, bomUTF16BE >(sl,dis);}

12
src/DataType/StringList.cpp
View File

@ -7,16 +7,16 @@ namespace hgl
*/ */
int LoadStringListFromText(UTF8StringList &sl,uchar *data,const int size,const CharSet &cs) int LoadStringListFromText(UTF8StringList &sl,uchar *data,const int size,const CharSet &cs)
{ {
char *str=nullptr; u8char *str=nullptr;
int line_count; int line_count;
int char_count; int char_count;
if(size>=3&&data[0]==0xEF&&data[1]==0xBB&&data[2]==0xBF) //utf8 if(size>=3&&data[0]==0xEF&&data[1]==0xBB&&data[2]==0xBF) //utf8
line_count=SplitToStringListByEnter<char>(sl,(char *)(data+3),size-3); line_count=SplitToStringListByEnter<u8char>(sl,(u8char *)(data+3),size-3);
else else
if(cs==UTF8CharSet) if(cs==UTF8CharSet)
line_count=SplitToStringListByEnter<char>(sl,(char *)data,size); line_count=SplitToStringListByEnter<u8char>(sl,(u8char *)data,size);
else else
{ {
if(size>=2) if(size>=2)
@ -69,7 +69,7 @@ namespace hgl
char_count=to_utf8(cs,&str,(char *)data,size); char_count=to_utf8(cs,&str,(char *)data,size);
#endif// #endif//
line_count=SplitToStringListByEnter<char>(sl,str,char_count); line_count=SplitToStringListByEnter<u8char>(sl,str,char_count);
delete[] str; delete[] str;
} }
@ -128,10 +128,10 @@ namespace hgl
else else
{ {
if(size>=3&&data[0]==0xEF&&data[1]==0xBB&&data[2]==0xBF) //utf8 if(size>=3&&data[0]==0xEF&&data[1]==0xBB&&data[2]==0xBF) //utf8
str=u8_to_u16((char *)(data+3),size-3,char_count); str=u8_to_u16((u8char *)(data+3),size-3,char_count);
else else
if(cs==UTF8CharSet) if(cs==UTF8CharSet)
str=u8_to_u16((char *)data,size,char_count); str=u8_to_u16((u8char *)data,size,char_count);
else else
{ {
#ifdef __ANDROID__ #ifdef __ANDROID__

4
src/IO/DataInputStream.cpp
View File

@ -96,7 +96,7 @@ namespace hgl
const uint count=(max_len>str_len?str_len:max_len); const uint count=(max_len>str_len?str_len:max_len);
char *utf8_str=dis->ReadArrays<char>(count); u8char *utf8_str=dis->ReadArrays<u8char>(count);
if(!utf8_str) if(!utf8_str)
return(false); return(false);
@ -131,7 +131,7 @@ namespace hgl
const uint count=(max_len>str_len?str_len:max_len); const uint count=(max_len>str_len?str_len:max_len);
char *utf8_str=dis->ReadArrays<char>(count); u8char *utf8_str=dis->ReadArrays<u8char>(count);
if(!utf8_str) if(!utf8_str)
return(false); return(false);

22
src/IO/DataOutputStream.cpp
View File

@ -4,7 +4,7 @@ namespace hgl
{ {
namespace io // write utf8 chars namespace io // write utf8 chars
{ {
template<> bool DataOutputStream::WriteUTF8Chars<char> (const char *str,uint size) template<> bool DataOutputStream::WriteUTF8Chars<u8char> (const u8char *str,uint size)
{ {
if(!out)return(false); if(!out)return(false);
if(size==0)return(true); if(size==0)return(true);
@ -27,7 +27,7 @@ namespace hgl
namespace io //write utf8 string namespace io //write utf8 string
{ {
template<typename T> bool DataOutputStream::WriteUTF8StringWithLength(const char *str,const uint length) template<typename T> bool DataOutputStream::WriteUTF8StringWithLength(const u8char *str,const uint length)
{ {
if(!out)return(false); if(!out)return(false);
@ -47,7 +47,7 @@ namespace hgl
if(!out)return(false); if(!out)return(false);
int utf8_count; int utf8_count;
char *utf8_str=u16_to_u8(str.c_str(),str.Length(),utf8_count); u8char *utf8_str=u16_to_u8(str.c_str(),str.Length(),utf8_count);
const bool result=WriteUTF8StringWithLength<T>(utf8_str,utf8_count); const bool result=WriteUTF8StringWithLength<T>(utf8_str,utf8_count);
@ -78,7 +78,7 @@ namespace hgl
namespace io //write utf16-le chars namespace io //write utf16-le chars
{ {
template<> bool DataOutputStream::WriteUTF16LEChars<char>(const char *str,uint length) template<> bool DataOutputStream::WriteUTF16LEChars<u8char>(const u8char *str,uint length)
{ {
if(length==0)return(true); if(length==0)return(true);
if(!out||!str||!*str)return(false); if(!out||!str||!*str)return(false);
@ -99,7 +99,7 @@ namespace hgl
namespace io //write utf16-be chars namespace io //write utf16-be chars
{ {
template<> bool DataOutputStream::WriteUTF16BEChars<char>(const char *str,uint length) template<> bool DataOutputStream::WriteUTF16BEChars<u8char>(const u8char *str,uint length)
{ {
if(length==0)return(true); if(length==0)return(true);
if(!out||!str||!*str)return(false); if(!out||!str||!*str)return(false);
@ -136,8 +136,8 @@ namespace hgl
namespace io namespace io
{ {
bool DataOutputStream::WriteUTF8String (const char *str,uint length){return WriteUTF8StringWithLength<uint32>(str, length);} ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列) bool DataOutputStream::WriteUTF8String (const u8char *str,uint length){return WriteUTF8StringWithLength<uint32>(str, length);} ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8String (const char *str ){return WriteUTF8StringWithLength<uint32>(str, hgl::strlen(str));} ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列) bool DataOutputStream::WriteUTF8String (const u8char *str ){return WriteUTF8StringWithLength<uint32>(str, hgl::strlen(str));} ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8String (const UTF8String &str ){return WriteUTF8StringWithLength<uint32>(str.c_str(), str.Length());} ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列) bool DataOutputStream::WriteUTF8String (const UTF8String &str ){return WriteUTF8StringWithLength<uint32>(str.c_str(), str.Length());} ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8String (const UTF16String &str ){return WriteUTF8StringWithLength<uint32>(str);} ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列) bool DataOutputStream::WriteUTF8String (const UTF16String &str ){return WriteUTF8StringWithLength<uint32>(str);} ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
@ -152,8 +152,8 @@ namespace hgl
bool DataOutputStream::WriteUTF8ShortString (const char *str,uint length){return WriteUTF8StringWithLength<uint16>(str, length);} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列) bool DataOutputStream::WriteUTF8ShortString (const u8char *str,uint length){return WriteUTF8StringWithLength<uint16>(str, length);} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8ShortString (const char *str ){return WriteUTF8StringWithLength<uint16>(str, hgl::strlen(str));} ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列) bool DataOutputStream::WriteUTF8ShortString (const u8char *str ){return WriteUTF8StringWithLength<uint16>(str, hgl::strlen(str));} ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8ShortString (const UTF8String &str ){return WriteUTF8StringWithLength<uint16>(str.c_str(), str.Length());} ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列) bool DataOutputStream::WriteUTF8ShortString (const UTF8String &str ){return WriteUTF8StringWithLength<uint16>(str.c_str(), str.Length());} ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8ShortString (const UTF16String &str ){return WriteUTF8StringWithLength<uint16>(str);} ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列) bool DataOutputStream::WriteUTF8ShortString (const UTF16String &str ){return WriteUTF8StringWithLength<uint16>(str);} ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
@ -168,8 +168,8 @@ namespace hgl
bool DataOutputStream::WriteUTF8TinyString (const char *str,uint length){return WriteUTF8StringWithLength<uint8>(str, length);} ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列) bool DataOutputStream::WriteUTF8TinyString (const u8char *str,uint length){return WriteUTF8StringWithLength<uint8>(str, length);} ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8TinyString (const char *str ){return WriteUTF8StringWithLength<uint8>(str, hgl::strlen(str));} ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列) bool DataOutputStream::WriteUTF8TinyString (const u8char *str ){return WriteUTF8StringWithLength<uint8>(str, hgl::strlen(str));} ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8TinyString (const UTF8String &str ){return WriteUTF8StringWithLength<uint8>(str.c_str(), str.Length());} ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列) bool DataOutputStream::WriteUTF8TinyString (const UTF8String &str ){return WriteUTF8StringWithLength<uint8>(str.c_str(), str.Length());} ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
bool DataOutputStream::WriteUTF8TinyString (const UTF16String &str ){return WriteUTF8StringWithLength<uint8>(str);} ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列) bool DataOutputStream::WriteUTF8TinyString (const UTF16String &str ){return WriteUTF8StringWithLength<uint8>(str);} ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)

8
src/IO/TextOutputStream.cpp
View File

@ -8,13 +8,13 @@ namespace hgl
template<> EndianTextOutputStream<bomUTF16LE>::EndianTextOutputStream(OutputStream *os):TextOutputStream(bomUTF16LE,new LEDataOutputStream(os)){} template<> EndianTextOutputStream<bomUTF16LE>::EndianTextOutputStream(OutputStream *os):TextOutputStream(bomUTF16LE,new LEDataOutputStream(os)){}
template<> EndianTextOutputStream<bomUTF16BE>::EndianTextOutputStream(OutputStream *os):TextOutputStream(bomUTF16BE,new BEDataOutputStream(os)){} template<> EndianTextOutputStream<bomUTF16BE>::EndianTextOutputStream(OutputStream *os):TextOutputStream(bomUTF16BE,new BEDataOutputStream(os)){}
template<> TextOutputStream *CreateTextOutputStream<char>(OutputStream *os){return(new UTF8TextOutputStream(os));} template<> TextOutputStream *CreateTextOutputStream<u8char>(OutputStream *os){return(new UTF8TextOutputStream(os));}
template<> TextOutputStream *CreateTextOutputStream<wchar_t>(OutputStream *os){return(new UTF16LETextOutputStream(os));} template<> TextOutputStream *CreateTextOutputStream<wchar_t>(OutputStream *os){return(new UTF16LETextOutputStream(os));}
}//namespace io }//namespace io
namespace io //WriteChars函数 namespace io //WriteChars函数
{ {
template<> bool EndianTextOutputStream<bomUTF8>::WriteChars(const char *str,int64 size) template<> bool EndianTextOutputStream<bomUTF8>::WriteChars(const u8char *str,int64 size)
{ {
return out?out->WriteUTF8Chars(str,size):false; return out?out->WriteUTF8Chars(str,size):false;
} }
@ -24,7 +24,7 @@ namespace hgl
return out?out->WriteUTF8Chars(str,size):false; return out?out->WriteUTF8Chars(str,size):false;
} }
template<> bool EndianTextOutputStream<bomUTF16LE>::WriteChars(const char *str,int64 size) template<> bool EndianTextOutputStream<bomUTF16LE>::WriteChars(const u8char *str,int64 size)
{ {
return out?out->WriteUTF16LEChars(str,size):false; return out?out->WriteUTF16LEChars(str,size):false;
} }
@ -34,7 +34,7 @@ namespace hgl
return out?out->WriteUTF16LEChars(str,size):false; return out?out->WriteUTF16LEChars(str,size):false;
} }
template<> bool EndianTextOutputStream<bomUTF16BE>::WriteChars(const char *str,int64 size) template<> bool EndianTextOutputStream<bomUTF16BE>::WriteChars(const u8char *str,int64 size)
{ {
return out?out->WriteUTF16BEChars(str,size):false; return out?out->WriteUTF16BEChars(str,size):false;
} }

2
src/Log/LogFile.cpp
View File

@ -86,7 +86,7 @@ namespace hgl
} }
} }
void Write(const char *str,int size) void Write(const u8char *str,int size)
{ {
if(tos&&str&&*str&&size>0) if(tos&&str&&*str&&size>0)
{ {

6
src/Log/Loginfo.cpp
View File

@ -104,7 +104,7 @@ namespace hgl
void (*Close)(); ///<关闭所有日志输出 void (*Close)(); ///<关闭所有日志输出
void (*WriteUTF16)(LogLevel,const u16char *,int); ///<输出一行日志 void (*WriteUTF16)(LogLevel,const u16char *,int); ///<输出一行日志
void (*WriteUTF8)(LogLevel,const char *,int); ///<输出一行日志 void (*WriteUTF8)(LogLevel,const u8char *,int); ///<输出一行日志
};//struct LogInterface };//struct LogInterface
static LogInterface LogInterface3= static LogInterface LogInterface3=
@ -115,7 +115,7 @@ namespace hgl
CloseAllLog, CloseAllLog,
WriteLog<u16char>, WriteLog<u16char>,
WriteLog<char> WriteLog<u8char>
}; };
/** /**
@ -180,7 +180,7 @@ namespace hgl
li->WriteUTF16(level,str,size==-1?hgl::strlen(str):size); li->WriteUTF16(level,str,size==-1?hgl::strlen(str):size);
} }
void Log(LogLevel level,const char *str,int size) void Log(LogLevel level,const u8char *str,int size)
{ {
if(li) if(li)
li->WriteUTF8(level,str,size==-1?hgl::strlen(str):size); li->WriteUTF8(level,str,size==-1?hgl::strlen(str):size);

10
src/Other/CodePage.cpp
View File

@ -8,7 +8,7 @@ namespace hgl
CharSet UTF16LECharSet (ccpUTF16LE,utf16le_charset ); CharSet UTF16LECharSet (ccpUTF16LE,utf16le_charset );
CharSet UTF16BECharSet (ccpUTF16BE,utf16be_charset ); CharSet UTF16BECharSet (ccpUTF16BE,utf16be_charset );
int u16_to_u8(char *dst,int dst_size,const u16char *src,const int src_size) int u16_to_u8(u8char *dst,int dst_size,const u16char *src,const int src_size)
{ {
if(src_size<=0||!src||!*src) if(src_size<=0||!src||!*src)
{ {
@ -50,7 +50,7 @@ namespace hgl
return int(tp-(uint8 *)dst); return int(tp-(uint8 *)dst);
} }
int u8_to_u16(u16char *dst,int dst_size,const char *src,const int src_size) int u8_to_u16(u16char *dst,int dst_size,const u8char *src,const int src_size)
{ {
if(src_size<=0||!src||!*src) if(src_size<=0||!src||!*src)
{ {
@ -116,7 +116,7 @@ namespace hgl
* @param dst_size 结果字符串字符数 * @param dst_size 结果字符串字符数
* @return 转换结果，需自行delete[] * @return 转换结果，需自行delete[]
*/ */
char *u16_to_u8(const u16char *src,const int src_size,int &dst_size) u8char *u16_to_u8(const u16char *src,const int src_size,int &dst_size)
{ {
if(src_size<=0||!src||!*src) if(src_size<=0||!src||!*src)
{ {
@ -150,7 +150,7 @@ namespace hgl
if(dst_size<=0) if(dst_size<=0)
return(nullptr); return(nullptr);
char *dst=new char[dst_size+1]; u8char *dst=new u8char[dst_size+1];
dst[dst_size]=0; //为防止内存检测工具报错，所以提前赋0 dst[dst_size]=0; //为防止内存检测工具报错，所以提前赋0
@ -166,7 +166,7 @@ namespace hgl
* @param dst_size 结果字符串字符数 * @param dst_size 结果字符串字符数
* @return 转换结果，需自行delete[] * @return 转换结果，需自行delete[]
*/ */
u16char *u8_to_u16(const char *src,const int src_size,int &dst_size) u16char *u8_to_u16(const u8char *src,const int src_size,int &dst_size)
{ {
if(src_size<=0||!src||!*src) if(src_size<=0||!src||!*src)
{ {

2
src/Other/UnicodeBlocks.cpp
View File

@ -372,7 +372,7 @@ namespace hgl
return UnicodeBlock::Error; return UnicodeBlock::Error;
} }
bool IsInUnicodeBlock(const UnicodeBlock &type,const uint32 ch) bool IsInUnicodeBlock(const UnicodeBlock &type,const u32char ch)
{ {
if(type<UnicodeBlock::basic_latin if(type<UnicodeBlock::basic_latin
||type>UnicodeBlock::END_RANGE) ||type>UnicodeBlock::END_RANGE)

4
src/PlugIn/ExternalModule.cpp
View File

@ -35,13 +35,13 @@ namespace hgl
void *func=pi_get(fp,name); void *func=pi_get(fp,name);
if(!func) if(!func)
LOG_ERROR("don't find "+UTF8String(name)); LOG_ERROR("don't find "+AnsiString(name));
return(func); return(func);
} }
else else
{ {
LOG_ERROR("Get func <"+UTF8String(name)+"> error: no load module!"); LOG_ERROR("Get func <"+AnsiString(name)+"> error: no load module!");
return(nullptr); return(nullptr);
} }