Commit: head - ttssh2 (svn) - Tera Term

--- branches/cmake/TTProxy/CMakeLists.txt (revision 7326)

+++ branches/cmake/TTProxy/CMakeLists.txt (revision 7327)

		@@ -1,18 +1,33 @@
1	1	project(ttproxy)
2	2
	3	+if(USE_UNICODE_API)
	4	+ add_definitions(-DUNICODE -D_UNICODE)
	5	+endif()
	6	+
3	7	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/")
4	8
	9	+if(MSVC)
	10	+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
	11	+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4")
	12	+endif()
	13	+
5	14	include(${CMAKE_CURRENT_SOURCE_DIR}/../libs/lib_openssl.cmake)
6	15
7	16	set(COMMON_SRC
8	17	../teraterm/common/ttlib.h
9	18	../teraterm/common/i18n.h
	19	+ ../teraterm/common/ttplugin.h
	20	+ ../teraterm/common/tttypes.h
	21	+ ../teraterm/common/tt-version.h
	22	+ ../teraterm/common/codeconv.h
	23	+ ../teraterm/common/codeconv.cpp
	24	+ ../teraterm/common/dlglib.h
	25	+ ../teraterm/common/dlglib.c
	26	+ ../teraterm/common/dlglib_cpp.cpp
	27	+ ../teraterm/common/dlglib_tmpl.cpp
10	28	../teraterm/teraterm/ttdialog.h
11	29	../teraterm/teraterm/ttfileio.h
12		- ../teraterm/common/ttplugin.h
13	30	../teraterm/teraterm/ttsetup.h
14		- ../teraterm/common/tttypes.h
15		- ../teraterm/common/tt-version.h
16	31	../teraterm/teraterm/ttwsk.h
17	32	)
18	33	source_group(

--- branches/cmake/TTProxy/Logger.h (revision 7326)

+++ branches/cmake/TTProxy/Logger.h (revision 7327)

		@@ -70,7 +70,7 @@
70	70	WriteFile(logfile, label, strlen(label), &written, NULL);
71	71	WriteFile(logfile, ": [", 3, &written, NULL);
72	72	while (size-- > 0) {
73		- len = wsprintf(buf, " %02x", *data++);
	73	+ len = wsprintfA(buf, " %02x", *data++);
74	74	WriteFile(logfile, buf, 3, &written, NULL);
75	75	}
76	76	WriteFile(logfile, " ]\r\n", 4, &written, NULL);

--- branches/cmake/TTProxy/ProxyWSockHook.h (revision 7326)

+++ branches/cmake/TTProxy/ProxyWSockHook.h (revision 7327)

		@@ -17,16 +17,23 @@
17	17
18	18	#include "ttlib.h"
19	19	#include "i18n.h"
	20	+#include "codeconv.h"
	21	+#include "dlglib.h"
20	22
21	23	extern char UILanguageFile[MAX_PATH];
22	24
23		-void UTIL_get_lang_msg(const char key, PCHAR buf, int buf_len, const char def)
	25	+void UTIL_get_lang_msg(const char key, TCHAR buf, int buf_len, const TCHAR *def)
24	26	{
25		- GetI18nStr("TTProxy", key, buf, buf_len, def, UILanguageFile);
	27	+ GetI18nStrT("TTProxy", key, buf, buf_len, def, UILanguageFile);
26	28	}
27	29
28		-int UTIL_get_lang_font(const char key, HWND dlg, PLOGFONT logfont, HFONT font)
	30	+void UTIL_get_lang_msgU8(const char key, char buf, int buf_len, const char *def)
29	31	{
	32	+ GetI18nStrU8("TTProxy", key, buf, buf_len, def, UILanguageFile);
	33	+}
	34	+
	35	+int UTIL_get_lang_font(const char key, HWND dlg, PLOGFONTA logfont, HFONT font)
	36	+{
30	37	if (GetI18nLogfont("TTProxy", key, logfont,
31	38	GetDeviceCaps(GetDC(dlg),LOGPIXELSY),
32	39	UILanguageFile) == FALSE) {

		@@ -33,7 +40,7 @@
33	40	return FALSE;
34	41	}
35	42
36		- if ((*font = CreateFontIndirect(logfont)) == NULL) {
	43	+ if ((*font = CreateFontIndirectA(logfont)) == NULL) {
37	44	return FALSE;
38	45	}
39	46

		@@ -44,7 +51,7 @@
44	51	public:
45	52	class MessageShower {
46	53	public:
47		- virtual void showMessage(const char* message)const = 0;
	54	+ virtual void showMessage(const TCHAR* message)const = 0;
48	55	};
49	56	private:
50	57	struct DUMMYHOSTENT {

		@@ -136,57 +143,57 @@
136	143	private:
137	144	struct PROXY_TYPE_TABLE {
138	145	Type type;
139		- const char* name;
	146	+ const TCHAR* name;
140	147	};
141	148	static const PROXY_TYPE_TABLE* proxy_type_table() {
142	149	static PROXY_TYPE_TABLE table[] = {
143		- {TYPE_HTTP, "http"},
144		- {TYPE_SOCKS5, "socks"},
145		- {TYPE_SOCKS4, "socks4"},
146		- {TYPE_TELNET, "telnet"},
147		- {TYPE_SOCKS5, "socks5"},
148		- {TYPE_NONE_FORCE, "none"},
149		- {TYPE_HTTP_SSL, "http+ssl"},
150		- {TYPE_SOCKS5_SSL, "socks+ssl"},
151		- {TYPE_SOCKS4_SSL, "socks4+ssl"},
152		- {TYPE_TELNET_SSL, "telnet+ssl"},
153		- {TYPE_SOCKS5_SSL, "socks5+ssl"},
154		- {TYPE_SSL, "ssl"},
155		- {TYPE_SSL, "none+ssl"},
	150	+ {TYPE_HTTP, _T("http")},
	151	+ {TYPE_SOCKS5, _T("socks")},
	152	+ {TYPE_SOCKS4, _T("socks4")},
	153	+ {TYPE_TELNET, _T("telnet")},
	154	+ {TYPE_SOCKS5, _T("socks5")},
	155	+ {TYPE_NONE_FORCE, _T("none")},
	156	+ {TYPE_HTTP_SSL, _T("http+ssl")},
	157	+ {TYPE_SOCKS5_SSL, _T("socks+ssl")},
	158	+ {TYPE_SOCKS4_SSL, _T("socks4+ssl")},
	159	+ {TYPE_TELNET_SSL, _T("telnet+ssl")},
	160	+ {TYPE_SOCKS5_SSL, _T("socks5+ssl")},
	161	+ {TYPE_SSL, _T("ssl")},
	162	+ {TYPE_SSL, _T("none+ssl")},
156	163	{TYPE_NONE, NULL},
157	164	};
158	165	return table;
159	166	}
160	167	public:
161		- static Type parseType(const char* string) {
162		- return parseType(string, string + strlen(string));
	168	+ static Type parseType(const TCHAR* string) {
	169	+ return parseType(string, string + _tcslen(string));
163	170	}
164		- static Type parseType(const char* string, const char* end) {
	171	+ static Type parseType(const TCHAR* string, const TCHAR* end) {
165	172	int length = end - string;
166		- char* buffer = (char*) alloca(length + 1);
167		- char* dst = buffer;
	173	+ TCHAR* buffer = (TCHAR) alloca(sizeof(TCHAR) (length + 1));
	174	+ TCHAR* dst = buffer;
168	175	while (length-- > 0 && *string != '\0') {
169		- int ch = *string++;
170		- if ('A' <= ch && ch <= 'Z') {
171		- ch += 'a' - 'A';
	176	+ TCHAR ch = *string++;
	177	+ if (_T('A') <= ch && ch <= _T('Z')) {
	178	+ ch += _T('a') - _T('A');
172	179	}
173	180	*dst++ = ch;
174	181	}
175		- *dst = '\0';
	182	+ *dst = _T('\0');
176	183	const PROXY_TYPE_TABLE* table = proxy_type_table();
177	184	bool ssl_enabled = SSLSocket::isEnabled();
178	185	while (table->name != NULL) {
179		- if (!ssl_enabled && strstr(table->name, "ssl") != NULL) {
	186	+ if (!ssl_enabled && _tcsstr(table->name, _T("ssl")) != NULL) {
180	187	table++;
181	188	continue;
182	189	}
183		- if (strcmp(buffer, table->name) == 0)
	190	+ if (_tcscmp(buffer, table->name) == 0)
184	191	return table->type;
185	192	table++;
186	193	}
187	194	return TYPE_NONE;
188	195	}
189		- static const char* getTypeName(Type type) {
	196	+ static const TCHAR* getTypeName(Type type) {
190	197	if (type != TYPE_NONE && type != TYPE_NONE_FORCE) {
191	198	const PROXY_TYPE_TABLE* table = proxy_type_table();
192	199	while (table->name != NULL) {

		@@ -198,10 +205,10 @@
198	205	return NULL;
199	206	}
200	207
201		- static int parsePort(const char* string) {
202		- return parsePort(string, string + strlen(string));
	208	+ static int parsePort(const TCHAR* string) {
	209	+ return parsePort(string, string + _tcslen(string));
203	210	}
204		- static int parsePort(const char* string, const char* end) {
	211	+ static int parsePort(const TCHAR* string, const TCHAR* end) {
205	212	if (string > end \|\| string < '1' \|\| '9' < string)
206	213	return -1;
207	214	int digit = 0;

		@@ -276,8 +283,8 @@
276	283	return url;
277	284	}
278	285	#else
279		- static String parse(const char* url, ProxyInfo& proxy) {
280		- char* p = strstr((char*) url, "://");
	286	+ static String parse(const TCHAR* url, ProxyInfo& proxy) {
	287	+ TCHAR* p = _tcsstr((TCHAR*) url, _T("://"));
281	288	if (p == NULL) {
282	289	proxy.type = TYPE_NONE;
283	290	return NULL;

		@@ -286,7 +293,7 @@
286	293	if (proxy.type == TYPE_NONE)
287	294	return NULL;
288	295	p += 3;
289		- const char* start = p;
	296	+ const TCHAR* start = p;
290	297
291	298	// user:pass があれば格納する
292	299	String tmp = String(start);

		@@ -352,7 +359,7 @@
352	359	return NULL;
353	360	StringBuffer buffer;
354	361	buffer.append(getTypeName(type));
355		- buffer.append("://");
	362	+ buffer.append(_T("://"));
356	363	if (type != TYPE_SSL) {
357	364	if (user != NULL) {
358	365	urlencode(user, buffer);

		@@ -366,9 +373,9 @@
366	373	buffer.append(host);
367	374	}
368	375	else {
369		- buffer.append("[");
	376	+ buffer.append(_T("["));
370	377	buffer.append(host);
371		- buffer.append("]");
	378	+ buffer.append(_T("]"));
372	379	}
373	380	if (port != 0) {
374	381	buffer.append(':');

		@@ -398,9 +405,9 @@
398	405	}
399	406	}
400	407
401		- static String urldecode(const char* start, const char* end) {
402		- char* buffer = (char) alloca((end - start) 3 + 1);
403		- char* dst = buffer;
	408	+ static String urldecode(const TCHAR* start, const TCHAR* end) {
	409	+ TCHAR* buffer = (TCHAR) alloca(sizeof(TCHAR) ((end - start) * 3 + 1));
	410	+ TCHAR* dst = buffer;
404	411	int c1, c2;
405	412	while (start < end) {
406	413	if (*start == '%' && start + 2 < end && (c1 = hexdigit(start[1])) != -1 && (c2 = hexdigit(start[2])) != -1) {

		@@ -407,9 +414,11 @@
407	414	*dst++ = (char) (c1 << 4 \| c2);
408	415	start += 3;
409	416	}else{
410		- if (IsDBCSLeadByte(*start)) {
	417	+#if !defined(UNICODE)
	418	+ if (::IsDBCSLeadByte(*start)) {
411	419	dst++ = start++;
412	420	}
	421	+#endif
413	422	dst++ = start++;
414	423	}
415	424	}

		@@ -416,16 +425,18 @@
416	425	*dst = '\0';
417	426	return buffer;
418	427	}
419		- static String urlencode(const char* string, StringBuffer& buffer) {
420		- static const char table[] = "0123456789ABCDEF";
421		- const char* start = string;
	428	+ static String urlencode(const TCHAR* string, StringBuffer& buffer) {
	429	+ static const TCHAR table[] = _T("0123456789ABCDEF");
	430	+ const TCHAR* start = string;
422	431	while (*string != '\0') {
423	432	if ('0' <= string && string <= '9'
424	433	\|\| 'A' <= string && string <= 'Z'
425	434	\|\| 'a' <= string && string <= 'z'
426	435	\|\| string == '-' \|\| string == '.' \|\| *string == '_') {
	436	+#if !defined(UNICODE)
427	437	}else if (::IsDBCSLeadByte(*string)) {
428	438	string++;
	439	+#endif
429	440	}else{
430	441	if (start < string) {
431	442	buffer.append(start, string - start);

		@@ -485,26 +496,26 @@
485	496	~ConnectionInfo() {
486	497	delete[] buffer;
487	498	}
488		- void fillBuffer(char* buffer, int bufferLength) {
489		- fillBuffer(buffer, bufferLength, "ssh");
	499	+ void fillBuffer(char* _buffer, int bufferLength) {
	500	+ fillBuffer(_buffer, bufferLength, "ssh");
490	501	}
491		- void fillBuffer(char* buffer, int bufferLength, const char *portname) {
492		- fillBuffer(buffer, bufferLength, "ssh", AF_UNSPEC);
	502	+ void fillBuffer(char* _buffer, int bufferLength, const char *portname) {
	503	+ fillBuffer(_buffer, bufferLength, "ssh", AF_UNSPEC);
493	504	}
494		- void fillBuffer(char* buffer, int bufferLength, const char *portname, int addr_family) {
495		- struct servent* sv;
	505	+ void fillBuffer(char* _buffer, int bufferLength, const char *portname, int addr_family) {
	506	+ struct servent* sv = getservbyname(portname, "tcp");
496	507	struct addrinfo* res;
497	508	struct addrinfo* res0;
498	509	struct addrinfo hints;
499	510	int portnum = 0;
500		- if (sv = getservbyname(portname, "tcp")) {
	511	+ if (sv) {
501	512	portnum = sv->s_port;
502	513	}
503	514	else {
504	515	portnum = atoi(portname);
505	516	}
506		- memset(buffer, 0, bufferLength);
507		- DUMMYHOSTENT* dst = (DUMMYHOSTENT*) buffer;
	517	+ memset(_buffer, 0, bufferLength);
	518	+ DUMMYHOSTENT* dst = (DUMMYHOSTENT*) _buffer;
508	519	dst->addr = addr;
509	520	dst->addr6 = addr6;
510	521	dst->addrlist[0] = (char*) &dst->addr;

		@@ -554,7 +565,7 @@
554	565	case AF_UNSPEC:
555	566	default:
556	567	memset(&hints, 0, sizeof hints);
557		- getaddrinfo(proxy.host, NULL, &hints, &res0);
	568	+ getaddrinfo((u8)proxy.host, NULL, &hints, &res0);
558	569	if (res0) {
559	570	int flag = 0;
560	571	for (res = res0; res; res = res->ai_next) {

		@@ -591,7 +602,7 @@
591	602	break;
592	603	}
593	604
594		- strcpy_s(dst->hostname, bufferLength - sizeof (DUMMYHOSTENT), realhost);
	605	+ strcpy_s(dst->hostname, bufferLength - sizeof (DUMMYHOSTENT), (u8)realhost);
595	606	}
596	607	};
597	608	class ConnectionInfoHolder {

		@@ -665,7 +676,7 @@
665	676	::LeaveCriticalSection(&section);
666	677	return info;
667	678	}
668		- ConnectionInfo* find(const char* url) {
	679	+ ConnectionInfo* find(const TCHAR* url) {
669	680	::EnterCriticalSection(&section);
670	681	ConnectionInfo* info = table.get(url);
671	682	::LeaveCriticalSection(&section);

		@@ -734,20 +745,18 @@
734	745	protected:
735	746	virtual bool dispatch(int message, int wParam, long lParam) {
736	747	if (message == WM_COMMAND && wParam == MAKEWPARAM(IDC_REFER, BN_CLICKED)) {
737		- char buffer[1024];
738		- char uimsg[MAX_UIMSG];
739		- OPENFILENAME ofn = {
740		- sizeof ofn,
741		- *this,
742		- };
	748	+ TCHAR buffer[1024];
	749	+ TCHAR uimsg[MAX_UIMSG];
	750	+ OPENFILENAME ofn;
	751	+ ofn.lStructSize = sizeof(ofn);
743	752	ofn.lpstrFile = buffer;
744	753	ofn.nMaxFile = countof(buffer);
745	754	ofn.Flags = OFN_LONGNAMES \| OFN_NONETWORKBUTTON \| OFN_PATHMUSTEXIST \| OFN_NOREADONLYRETURN \| OFN_HIDEREADONLY;
746		- UTIL_get_lang_msg("MSG_LOGFILE_SELECT", uimsg, sizeof(uimsg),
747		- "Select Logfile");
	755	+ UTIL_get_lang_msg("MSG_LOGFILE_SELECT", uimsg, _countof(uimsg),
	756	+ _T("Select Logfile"));
748	757	ofn.lpstrTitle = uimsg;
749	758	if (logfile != NULL) {
750		- strcpy_s(buffer, sizeof buffer, logfile);
	759	+ _tcscpy_s(buffer, _countof(buffer), (tc)logfile);
751	760	}else{
752	761	buffer[0] = '\0';
753	762	}

		@@ -764,14 +773,33 @@
764	773	return Dialog::dispatch(message, wParam, lParam);
765	774	}
766	775	virtual bool onInitDialog() {
767		- char uimsg[MAX_UIMSG], uitmp[MAX_UIMSG];
768		- LOGFONT logfont;
	776	+ const static DlgTextInfo text_info[] = {
	777	+ { 0, "DLG_OTHER_TITLE" },
	778	+ { IDC_GRP_COMMON, "DLG_OTHER_COMMON" },
	779	+ { IDC_TIMEOUT_LABEL, "DLG_OTHER_TIMEOUT" },
	780	+ { IDC_TIMEOUT_SECONDS, "DLG_OTHER_SECOND" },
	781	+ { IDC_LOGFILE_LABEL, "DLG_OTHER_LOG" },
	782	+ { IDC_REFER, "DLG_OTHER_REFER" },
	783	+ { IDC_GRP_SOCKS, "DLG_OTHER_SOCKS" },
	784	+ { IDC_RESOLVE_LABEL, "DLG_OTHER_RESOLV" },
	785	+ { IDC_GRP_TELNET, "DLG_OTHER_TELNET" },
	786	+ { IDC_HOSTNAME_LABEL, "DLG_OTHER_HOST" },
	787	+ { IDC_USERNAME_LABEL, "DLG_OTHER_USER" },
	788	+ { IDC_PASSWORD_LABEL, "DLG_OTHER_PASS" },
	789	+ { IDC_CONNECTED_LABEL, "DLG_OTHER_CONNECT" },
	790	+ { IDC_ERROR_LABEL, "DLG_OTHER_ERROR" },
	791	+// { IDOK, "BTN_OK" },
	792	+// { IDCANCEL, "BTN_CANCEL" },
	793	+ };
	794	+ TCHAR uimsg[MAX_UIMSG];
	795	+// TCHAR uitmp[MAX_UIMSG];
	796	+ LOGFONTA logfont;
769	797	HFONT font;
770	798
771	799	Dialog::onInitDialog();
772	800
773	801	font = (HFONT)SendMessage(WM_GETFONT, 0, 0);
774		- GetObject(font, sizeof(LOGFONT), &logfont);
	802	+ GetObject(font, sizeof(logfont), &logfont);
775	803	if (UTIL_get_lang_font("DLG_TAHOMA_FONT", HWND(), &logfont, &DlgFont)) {
776	804	SendDlgItemMessage(IDC_GRP_COMMON, WM_SETFONT, (WPARAM)DlgFont, MAKELPARAM(TRUE,0));
777	805	SendDlgItemMessage(IDC_TIMEOUT_LABEL, WM_SETFONT, (WPARAM)DlgFont, MAKELPARAM(TRUE,0));

		@@ -801,6 +829,9 @@
801	829	DlgFont = NULL;
802	830	}
803	831
	832	+ HWND hWnd = (HWND)this;
	833	+ SetDlgTexts(hWnd, text_info, _countof(text_info), UILanguageFile);
	834	+#if 0
804	835	GetWindowText(uitmp, sizeof(uitmp));
805	836	UTIL_get_lang_msg("DLG_OTHER_TITLE", uimsg, sizeof(uimsg), uitmp);
806	837	SetWindowText(uimsg);

		@@ -849,6 +880,7 @@
849	880	GetDlgItemText(IDCANCEL, uitmp, sizeof(uitmp));
850	881	UTIL_get_lang_msg("BTN_CANCEL", uimsg, sizeof(uimsg), uitmp);
851	882	SetDlgItemText(IDCANCEL, uimsg);
	883	+#endif
852	884
853	885	host = GetDlgItem(IDC_HOSTNAME);
854	886	user = GetDlgItem(IDC_USERNAME);

		@@ -860,22 +892,22 @@
860	892	SetDlgItemInt(IDC_TIMEOUT, timeout, false);
861	893
862	894	resolveCombo <<= GetDlgItem(IDC_RESOLVE);
863		- UTIL_get_lang_msg("DLG_OTHER_RESOLV_AUTO", uimsg, sizeof(uimsg), "auto resolve");
	895	+ UTIL_get_lang_msg("DLG_OTHER_RESOLV_AUTO", uimsg, _countof(uimsg), _T("auto resolve"));
864	896	resolveCombo.addString(uimsg);
865		- UTIL_get_lang_msg("DLG_OTHER_RESOLV_REMOTE", uimsg, sizeof(uimsg), "resolve remote");
	897	+ UTIL_get_lang_msg("DLG_OTHER_RESOLV_REMOTE", uimsg, _countof(uimsg), _T("resolve remote"));
866	898	resolveCombo.addString(uimsg);
867		- UTIL_get_lang_msg("DLG_OTHER_RESOLV_LOCAL", uimsg, sizeof(uimsg), "resolve local");
	899	+ UTIL_get_lang_msg("DLG_OTHER_RESOLV_LOCAL", uimsg, _countof(uimsg), _T("resolve local"));
868	900	resolveCombo.addString(uimsg);
869	901	resolveCombo.setCurSel(resolve);
870	902
871		- host.SetWindowText(HostnamePrompt);
872		- user.SetWindowText(UsernamePrompt);
873		- pass.SetWindowText(PasswordPrompt);
874		- conn.SetWindowText(ConnectedMessage);
875		- erro.SetWindowText(ErrorMessage);
	903	+ host.SetWindowText((tc)HostnamePrompt);
	904	+ user.SetWindowText((tc)UsernamePrompt);
	905	+ pass.SetWindowText((tc)PasswordPrompt);
	906	+ conn.SetWindowText((tc)ConnectedMessage);
	907	+ erro.SetWindowText((tc)ErrorMessage);
876	908
877	909	if (logfile != NULL)
878		- log.SetWindowText(logfile);
	910	+ log.SetWindowText((tc)logfile);
879	911
880	912	return true;
881	913	}

		@@ -885,9 +917,9 @@
885	917	\|\| pass.GetWindowTextLength() == 0
886	918	\|\| conn.GetWindowTextLength() == 0
887	919	\|\| erro.GetWindowTextLength() == 0) {
888		- char uimsg[MAX_UIMSG];
889		- UTIL_get_lang_msg("MSG_EMPTY_PARAMETER", uimsg, sizeof(uimsg),
890		- "Some parameters are empty!");
	920	+ TCHAR uimsg[MAX_UIMSG];
	921	+ UTIL_get_lang_msg("MSG_EMPTY_PARAMETER", uimsg, _countof(uimsg),
	922	+ _T("Some parameters are empty!"));
891	923	MessageBox(uimsg, FileVersion::getOwnVersion().getProductName(), MB_OK \| MB_ICONERROR);
892	924	return;
893	925	}

		@@ -962,14 +994,15 @@
962	994	return Dialog::dispatch(message, wParam, lParam);
963	995	}
964	996	virtual bool onInitDialog() {
965		- char uimsg[MAX_UIMSG], uitmp[MAX_UIMSG];
966		- LOGFONT logfont;
	997	+ TCHAR uimsg[MAX_UIMSG];
	998	+// TCHAR uitmp[MAX_UIMSG];
	999	+ LOGFONTA logfont;
967	1000	HFONT font;
968	1001
969	1002	Dialog::onInitDialog();
970	1003
971	1004	font = (HFONT)SendMessage(WM_GETFONT, 0, 0);
972		- GetObject(font, sizeof(LOGFONT), &logfont);
	1005	+ GetObject(font, sizeof(logfont), &logfont);
973	1006	if (UTIL_get_lang_font("DLG_TAHOMA_FONT", HWND(), &logfont, &DlgFont)) {
974	1007	SendDlgItemMessage(IDC_URL_LABEL, WM_SETFONT, (WPARAM)DlgFont, MAKELPARAM(TRUE,0));
975	1008	SendDlgItemMessage(IDC_URL, WM_SETFONT, (WPARAM)DlgFont, MAKELPARAM(TRUE,0));

		@@ -991,8 +1024,23 @@
991	1024	DlgFont = NULL;
992	1025	}
993	1026
	1027	+ const static DlgTextInfo text_info[] = {
	1028	+ { 0, "DLG_SETUP_TITLE" },
	1029	+ { IDC_URL_LABEL, "DLG_SETUP_URL" },
	1030	+ { IDC_TYPE_LEBEL, "DLG_SETUP_TYPE" },
	1031	+ { IDC_HOSTNAME_LABEL, "DLG_SETUP_HOST" },
	1032	+ { IDC_PORT_LABEL, "DLG_SETUP_PORT" },
	1033	+ { IDC_USERNAME_LABEL, "DLG_SETUP_USER" },
	1034	+ { IDC_PASSWORD_LABEL, "DLG_SETUP_PASS" },
	1035	+ { IDC_OPTIONS, "DLG_SETUP_OTHER" },
	1036	+// { IDOK, "BTN_OK" },
	1037	+// { IDCANCEL, "BTN_CANCEL" },
	1038	+ };
	1039	+ HWND hWnd = (HWND)this;
	1040	+ SetDlgTexts(hWnd, text_info, _countof(text_info), UILanguageFile);
	1041	+#if 0
994	1042	GetWindowText(uitmp, sizeof(uitmp));
995		- UTIL_get_lang_msg("DLG_SETUP_TITLE", uimsg, sizeof(uimsg), uitmp);
	1043	+ UTIL_get_lang_msgT("DLG_SETUP_TITLE", uimsg, sizeof(uimsg), uitmp);
996	1044	SetWindowText(uimsg);
997	1045	GetDlgItemText(IDC_URL_LABEL, uitmp, sizeof(uitmp));
998	1046	UTIL_get_lang_msg("DLG_SETUP_URL", uimsg, sizeof(uimsg), uitmp);

		@@ -1021,7 +1069,7 @@
1021	1069	GetDlgItemText(IDCANCEL, uitmp, sizeof(uitmp));
1022	1070	UTIL_get_lang_msg("BTN_CANCEL", uimsg, sizeof(uimsg), uitmp);
1023	1071	SetDlgItemText(IDCANCEL, uimsg);
1024		-
	1072	+#endif
1025	1073	url <<= GetDlgItem(IDC_URL);
1026	1074	type <<= GetDlgItem(IDC_TYPE);
1027	1075	host <<= GetDlgItem(IDC_HOSTNAME);

		@@ -1030,18 +1078,18 @@
1030	1078	pass <<= GetDlgItem(IDC_PASSWORD);
1031	1079
1032	1080	lock = true;
1033		- UTIL_get_lang_msg("MSG_TYPE_NONE", uimsg, sizeof(uimsg), "Without Proxy");
	1081	+ UTIL_get_lang_msg("MSG_TYPE_NONE", uimsg, _countof(uimsg), __T("Without Proxy"));
1034	1082	type.addString(uimsg);
1035		- type.addString("HTTP");
1036		- type.addString("TELNET");
1037		- type.addString("SOCKS4");
1038		- type.addString("SOCKS5");
	1083	+ type.addString(_T("HTTP"));
	1084	+ type.addString(_T("TELNET"));
	1085	+ type.addString(_T("SOCKS4"));
	1086	+ type.addString(_T("SOCKS5"));
1039	1087	if (SSLSocket::isEnabled()) {
1040		- type.addString("SSL");
1041		- type.addString("HTTP+SSL");
1042		- type.addString("TELNET+SSL");
1043		- type.addString("SOCKS4+SSL");
1044		- type.addString("SOCKS5+SSL");
	1088	+ type.addString(_T("SSL"));
	1089	+ type.addString(_T("HTTP+SSL"));
	1090	+ type.addString(_T("TELNET+SSL"));
	1091	+ type.addString(_T("SOCKS4+SSL"));
	1092	+ type.addString(_T("SOCKS5+SSL"));
1045	1093	}
1046	1094	type.setCurSel(proxy.type);
1047	1095

		@@ -1049,8 +1097,8 @@
1049	1097	if (proxy.host != NULL) {
1050	1098	host.SetWindowText(proxy.host);
1051	1099	if (proxy.port != 0) {
1052		- char buffer[16];
1053		- _itoa_s(proxy.port, buffer, sizeof buffer, 10);
	1100	+ TCHAR buffer[16];
	1101	+ _itot_s(proxy.port, buffer, _countof(buffer), 10);
1054	1102	port.SetWindowText(buffer);
1055	1103	}
1056	1104	if (proxy.user != NULL) {

		@@ -1066,17 +1114,17 @@
1066	1114	return true;
1067	1115	}
1068	1116	virtual void onOK() {
1069		- char uimsg[MAX_UIMSG];
	1117	+ TCHAR uimsg[MAX_UIMSG];
1070	1118	if (proxy.type != ProxyInfo::TYPE_NONE && proxy.type != ProxyInfo::TYPE_SSL) {
1071	1119	if (proxy.host == NULL) {
1072		- UTIL_get_lang_msg("MSG_EMPTY_HOSTNAME", uimsg, sizeof(uimsg),
1073		- "Hostname is empty!");
	1120	+ UTIL_get_lang_msg("MSG_EMPTY_HOSTNAME", uimsg, _countof(uimsg),
	1121	+ _T("Hostname is empty!"));
1074	1122	MessageBox(uimsg, FileVersion::getOwnVersion().getProductName(), MB_OK \| MB_ICONERROR);
1075	1123	return;
1076	1124	}
1077	1125	if (port.GetWindowTextLength() != 0 && proxy.port <= 0) {
1078		- UTIL_get_lang_msg("MSG_ILLEGAL_PORT", uimsg, sizeof(uimsg),
1079		- "Illegal port number!");
	1126	+ UTIL_get_lang_msg("MSG_ILLEGAL_PORT", uimsg, _countof(uimsg),
	1127	+ _T("Illegal port number!"));
1080	1128	MessageBox(uimsg, FileVersion::getOwnVersion().getProductName(), MB_OK \| MB_ICONERROR);
1081	1129	return;
1082	1130	}

		@@ -1177,9 +1225,9 @@
1177	1225	}
1178	1226	String urlS = proxy.generateURL();
1179	1227	if (urlS == NULL) {
1180		- urlS = "none:///";
	1228	+ urlS = _T("none:///");
1181	1229	}
1182		- url.SetWindowText(urlS);
	1230	+ url.SetWindowText((tc)urlS);
1183	1231	}
1184	1232	public:
1185	1233	ProxyInfo proxy;

		@@ -1197,15 +1245,15 @@
1197	1245	HFONT DlgFont;
1198	1246	virtual bool onInitDialog() {
1199	1247	String buf;
1200		- char *buf2;
1201		- const char *ver;
	1248	+ TCHAR *buf2;
	1249	+ const TCHAR *ver;
1202	1250	int n, a, b, c, d, len;
1203		- char uimsg[MAX_UIMSG], uimsg2[MAX_UIMSG], uimsg3[MAX_UIMSG];
1204		- LOGFONT logfont;
	1251	+ TCHAR uimsg[MAX_UIMSG], uimsg2[MAX_UIMSG], uimsg3[MAX_UIMSG];
	1252	+ LOGFONTA logfont;
1205	1253	HFONT font;
1206	1254
1207	1255	font = (HFONT)SendMessage(WM_GETFONT, 0, 0);
1208		- GetObject(font, sizeof(LOGFONT), &logfont);
	1256	+ GetObject(font, sizeof(logfont), &logfont);
1209	1257	if (UTIL_get_lang_font("DLG_TAHOMA_FONT", HWND(), &logfont, &DlgFont)) {
1210	1258	SendDlgItemMessage(IDC_VERSION, WM_SETFONT, (WPARAM)DlgFont, MAKELPARAM(TRUE,0));
1211	1259	SendDlgItemMessage(IDOK, WM_SETFONT, (WPARAM)DlgFont, MAKELPARAM(TRUE,0));

		@@ -1214,31 +1262,31 @@
1214	1262	DlgFont = NULL;
1215	1263	}
1216	1264
1217		- GetWindowText(uimsg2, sizeof(uimsg2));
1218		- UTIL_get_lang_msg("DLG_ABOUT_TITLE", uimsg, sizeof(uimsg), uimsg2);
	1265	+ GetWindowText(uimsg2, _countof(uimsg2));
	1266	+ UTIL_get_lang_msg("DLG_ABOUT_TITLE", uimsg, _countof(uimsg), uimsg2);
1219	1267	SetWindowText(uimsg);
1220	1268
1221		- UTIL_get_lang_msg("DLG_ABOUT_EXTENSION", uimsg, sizeof(uimsg),
1222		- "Tera Term proxy extension");
1223		- UTIL_get_lang_msg("DLG_ABOUT_YEBISUYA", uimsg2, sizeof(uimsg2),
1224		- "YebisuyaHompo");
1225		- UTIL_get_lang_msg("DLG_ABOUT_HOMEPAGE", uimsg3, sizeof(uimsg3),
1226		- "TTProxy home page");
	1269	+ UTIL_get_lang_msg("DLG_ABOUT_EXTENSION", uimsg, _countof(uimsg),
	1270	+ _T("Tera Term proxy extension"));
	1271	+ UTIL_get_lang_msg("DLG_ABOUT_YEBISUYA", uimsg2, _countof(uimsg2),
	1272	+ _T("YebisuyaHompo"));
	1273	+ UTIL_get_lang_msg("DLG_ABOUT_HOMEPAGE", uimsg3, _countof(uimsg3),
	1274	+ _T("TTProxy home page"));
1227	1275	buf = GetDlgItemText(IDC_VERSION);
1228	1276	len = buf.length() + 50;
1229		- buf2 = (char *)_alloca(len);
	1277	+ buf2 = (TCHAR )_alloca(sizeof(TCHAR) len);
1230	1278	if (buf2 == NULL) {
1231	1279	return true;
1232	1280	}
1233	1281	ver = FileVersion::getOwnVersion().getFileVersion();
1234		- n = sscanf_s(ver, "%d, %d, %d, %d", &a, &b, &c, &d);
	1282	+ n = _stscanf_s(ver, _T("%d, %d, %d, %d"), &a, &b, &c, &d);
1235	1283	if (n == 4) {
1236		- sprintf_s(buf2, len, buf, uimsg, a, b, c, d, uimsg2, uimsg3);
	1284	+ _stprintf_s(buf2, len, buf, uimsg, a, b, c, d, uimsg2, uimsg3);
1237	1285	}
1238	1286	SetDlgItemText(IDC_VERSION, (n == 4) ? buf2 : buf);
1239	1287
1240		- GetDlgItemText(IDOK, uimsg, sizeof(uimsg));
1241		- UTIL_get_lang_msg("BTN_OK", uimsg, sizeof(uimsg),"OK");
	1288	+ GetDlgItemText(IDOK, uimsg, _countof(uimsg));
	1289	+ UTIL_get_lang_msg("BTN_OK", uimsg, _countof(uimsg), _T("OK"));
1242	1290	SetDlgItemText(IDOK, uimsg);
1243	1291
1244	1292	return true;

		@@ -1277,7 +1325,6 @@
1277	1325	}
1278	1326
1279	1327	int sendToSocket(SOCKET s, const unsigned char* buffer, int size) {
1280		- int i = 0;
1281	1328	Logger::log("send", buffer, size);
1282	1329	return _sendToSocket(s, buffer, size);
1283	1330	}

		@@ -1287,20 +1334,20 @@
1287	1334	int len;
1288	1335	va_list arglist;
1289	1336	va_start(arglist, format);
1290		- len = wvsprintf(buf, format, arglist);
	1337	+ len = wvsprintfA(buf, format, arglist);
1291	1338	va_end(arglist);
1292	1339	Logger::log("send", buf);
1293	1340	return _sendToSocket(s, (const unsigned char*) buf, len);
1294	1341	}
1295	1342
1296		- int recieveFromSocketTimeout(SOCKET s, unsigned char* buffer, int size, int timeout) {
	1343	+ int recieveFromSocketTimeout(SOCKET s, unsigned char* buffer, int size, int _timeout) {
1297	1344	int ready = 0;
1298	1345	while (!ready) {
1299		- struct timeval tv = {timeout, 0};
	1346	+ struct timeval tv = {_timeout, 0};
1300	1347	fd_set fd;
1301	1348	FD_ZERO(&fd);
1302	1349	FD_SET(s, &fd);
1303		- switch (select((int) (s + 1), &fd, NULL, NULL, timeout > 0 ? &tv : NULL)) {
	1350	+ switch (select((int) (s + 1), &fd, NULL, NULL, _timeout > 0 ? &tv : NULL)) {
1304	1351	case SOCKET_ERROR:
1305	1352	return SOCKET_ERROR;
1306	1353	case 0:

		@@ -1348,13 +1395,13 @@
1348	1395	return 0;
1349	1396	}
1350	1397
1351		- int wait_for_prompt(SOCKET s, String prompts[], int count, int timeout /* sec */) {
	1398	+ int wait_for_prompt(SOCKET s, String prompts[], int count, int _timeout /* sec */) {
1352	1399	char buf[1024];
1353	1400	while (1) {
1354	1401	char *dst = buf;
1355	1402	char *end = buf + sizeof buf - 1;
1356	1403	while (dst < end) {
1357		- switch (recieveFromSocketTimeout(s, (unsigned char) dst, 1, timeout)) { / recv one-by-one */
	1404	+ switch (recieveFromSocketTimeout(s, (unsigned char) dst, 1, _timeout)) { / recv one-by-one */
1358	1405	case SOCKET_ERROR:
1359	1406	if (WSAGetLastError() != WSAEWOULDBLOCK) {
1360	1407	return SOCKET_ERROR;

		@@ -1376,7 +1423,8 @@
1376	1423	*dst = '\0';
1377	1424	Logger::log("recv", buf);
1378	1425	for (i = 0; i < count; i++) {
1379		- char* found = strstr(buf, prompts[i]);
	1426	+ u8 promptU8 = (const TCHAR *)prompts[i];
	1427	+ char* found = strstr(buf, promptU8);
1380	1428	if (found != NULL) {
1381	1429	return i;
1382	1430	}

		@@ -1389,13 +1437,16 @@
1389	1437	static const char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1390	1438	char buf[1024];
1391	1439	int status_code;
1392		- if (sendToSocketFormat(s, strchr(realhost,':')?"CONNECT [%s]:%d HTTP/1.1\r\n":"CONNECT %s:%d HTTP/1.1\r\n", (const char *)realhost, realport) == SOCKET_ERROR)
	1440	+ u8 realhostU8 = (const TCHAR *)realhost;
	1441	+ if (sendToSocketFormat(s, strchr((const char )realhostU8,':')?"CONNECT [%s]:%d HTTP/1.1\r\n":"CONNECT %s:%d HTTP/1.1\r\n", (const char )realhostU8, realport) == SOCKET_ERROR)
1393	1442	return SOCKET_ERROR;
1394		- if (sendToSocketFormat(s, strchr(realhost,':')?"Host: [%s]:%d\r\n":"Host: %s:%d\r\n", (const char *)realhost, realport) == SOCKET_ERROR)
	1443	+ if (sendToSocketFormat(s, strchr((const char )realhostU8,':')?"Host: [%s]:%d\r\n":"Host: %s:%d\r\n", (const char )realhostU8, realport) == SOCKET_ERROR)
1395	1444	return SOCKET_ERROR;
1396	1445	if (proxy.user != NULL) {
1397		- int userlen = strlen(proxy.user);
1398		- int passlen = strlen(proxy.pass);
	1446	+ u8 proxy_user = (const TCHAR *)proxy.user;
	1447	+ u8 proxy_pass = (const TCHAR *)proxy.pass;
	1448	+ int userlen = strlen(proxy_user);
	1449	+ int passlen = strlen(proxy_pass);
1399	1450	int authlen = userlen + 1 + passlen;
1400	1451	int encodedlen = (authlen + 2) / 3 * 4;
1401	1452	char* auth = (char*) alloca(authlen + 1);

		@@ -1404,10 +1455,10 @@
1404	1455	char *dst = encoded;
1405	1456	int bits = 0;
1406	1457	int data = 0;
1407		- strcpy_s(auth, authlen + 1, proxy.user);
	1458	+ strcpy_s(auth, authlen + 1, proxy_user);
1408	1459	auth[userlen] = ':';
1409		- strcpy_s(auth + userlen + 1, passlen + 1, proxy.pass);
1410		-
	1460	+ strcpy_s(auth + userlen + 1, passlen + 1, proxy_pass);
	1461	+
1411	1462	/* make base64 string */
1412	1463	while (*src != '\0') {
1413	1464	data = (data << 8) \| *src++;

		@@ -1422,7 +1473,7 @@
1422	1473	*dst++ = base64_table[0x3F & (data << (6 - bits))];
1423	1474	encodedlen--;
1424	1475	}
1425		- while (encodedlen-- > 0) {
	1476	+ while (encodedlen-- > 0) {
1426	1477	*dst++ = '=';
1427	1478	}
1428	1479	*dst = '\0';

		@@ -1441,12 +1492,12 @@
1441	1492	}
1442	1493	} while (strcmp(buf,"\r\n") != 0);
1443	1494	if (status_code != 200) {
1444		- char uimsg[MAX_UIMSG];
	1495	+ TCHAR uimsg[MAX_UIMSG];
1445	1496	switch (status_code) {
1446	1497	case 401:
1447	1498	case 407:
1448	1499	UTIL_get_lang_msg("MSG_PROXY_UNAUTHORIZED", uimsg, sizeof(uimsg),
1449		- "Proxy authorization failed!");
	1500	+ _T("Proxy authorization failed!"));
1450	1501	break;
1451	1502	case 400:
1452	1503	case 405:

		@@ -1453,7 +1504,7 @@
1453	1504	case 406:
1454	1505	case 403:
1455	1506	UTIL_get_lang_msg("MSG_PROXY_BAD_REQUEST", uimsg, sizeof(uimsg),
1456		- "Proxy prevent this connection!");
	1507	+ _T("Proxy prevent this connection!"));
1457	1508	break;
1458	1509	}
1459	1510	return setError(s, uimsg);

		@@ -1496,7 +1547,10 @@
1496	1547	int auth_result;
1497	1548	unsigned char buf[256];
1498	1549	unsigned char* ptr = buf;
1499		- char uimsg[MAX_UIMSG];
	1550	+ TCHAR uimsg[MAX_UIMSG];
	1551	+ u8 proxy_user = (const TCHAR *)proxy.user;
	1552	+ u8 proxy_pass = (const TCHAR *)proxy.pass;
	1553	+ u8 realhostU8 = (const TCHAR *)realhost;
1500	1554	*ptr++ = SOCKS5_VERSION;
1501	1555	if (proxy.user != NULL && proxy.pass != NULL) {
1502	1556	*ptr++ = 2; // support 2 auth methods : SOCKS5_AUTH_NOAUTH, SOCKS5_AUTH_USERPASS

		@@ -1512,9 +1566,8 @@
1512	1566	return SOCKET_ERROR;
1513	1567
1514	1568	if (buf[0] != SOCKS5_VERSION \|\| buf[1] == SOCKS5_REJECT) {
1515		- char uimsg[MAX_UIMSG];
1516	1569	UTIL_get_lang_msg("MSG_PROXY_BAD_REQUEST", uimsg, sizeof(uimsg),
1517		- "Proxy prevent this connection!");
	1570	+ _T("Proxy prevent this connection!"));
1518	1571	return setError(s, uimsg);
1519	1572	}
1520	1573	auth_method = buf[1];

		@@ -1529,19 +1582,19 @@
1529	1582	/* make authentication packet */
1530	1583	ptr = buf;
1531	1584	*ptr++ = SOCKS5_AUTH_SUBNEGOVER;
1532		- len = proxy.user.length();
	1585	+ len = strlen(proxy_user);
1533	1586	*ptr++ = len;
1534		- strcpy_s((char*) ptr, sizeof buf - (ptr - buf), proxy.user);
	1587	+ strcpy_s((char*) ptr, sizeof buf - (ptr - buf), proxy_user);
1535	1588	ptr += len;
1536		- len = proxy.pass.length();
	1589	+ len = strlen(proxy_pass);
1537	1590	*ptr++ = len;
1538		- strcpy_s((char*) ptr, sizeof buf - (ptr - buf), proxy.pass);
	1591	+ strcpy_s((char*) ptr, sizeof buf - (ptr - buf), proxy_pass);
1539	1592	ptr += len;
1540	1593
1541	1594	/* send it and get answer */
1542		- if (sendToSocket(s, buf, ptr - buf) == SOCKET_ERROR)
	1595	+ if (sendToSocket(s, buf, ptr - buf) == SOCKET_ERROR)
1543	1596	return SOCKET_ERROR;
1544		- if (recieveFromSocket(s, buf, 2) == SOCKET_ERROR)
	1597	+ if (recieveFromSocket(s, buf, 2) == SOCKET_ERROR)
1545	1598	return SOCKET_ERROR;
1546	1599
1547	1600	/* check status */

		@@ -1549,7 +1602,7 @@
1549	1602	break;
1550	1603	default:
1551	1604	UTIL_get_lang_msg("MSG_PROXY_BAD_REQUEST", uimsg, sizeof(uimsg),
1552		- "Proxy prevent this connection!");
	1605	+ _T("Proxy prevent this connection!"));
1553	1606	return setError(s, uimsg);
1554	1607	}
1555	1608	if (auth_result == SOCKET_ERROR) {

		@@ -1556,7 +1609,7 @@
1556	1609	return SOCKET_ERROR;
1557	1610	}else if (auth_result != 0) {
1558	1611	UTIL_get_lang_msg("MSG_PROXY_UNAUTHORIZED", uimsg, sizeof(uimsg),
1559		- "Proxy authorization failed!");
	1612	+ _T("Proxy authorization failed!"));
1560	1613	return setError(s, uimsg);
1561	1614	}
1562	1615	/* request to connect */

		@@ -1567,7 +1620,7 @@
1567	1620	struct addrinfo hints, *res = NULL;
1568	1621	if (resolve != RESOLVE_REMOTE) {
1569	1622	memset(&hints, 0, sizeof(hints));
1570		- getaddrinfo(realhost, NULL, &hints, &res);
	1623	+ getaddrinfo(realhostU8, NULL, &hints, &res);
1571	1624	}
1572	1625	if (res) {
1573	1626	switch (res->ai_family) {

		@@ -1584,6 +1637,7 @@
1584	1637	default:
1585	1638	freeaddrinfo(res);
1586	1639	WSASetLastError(WSAECONNREFUSED);
	1640	+
1587	1641	return SOCKET_ERROR;
1588	1642	break;
1589	1643	}

		@@ -1595,9 +1649,9 @@
1595	1649	}
1596	1650	else {
1597	1651	*ptr++ = SOCKS5_ATYP_DOMAINNAME;
1598		- len = strlen(realhost);
	1652	+ len = strlen(realhostU8);
1599	1653	*ptr++ = len;
1600		- memcpy(ptr, realhost, len);
	1654	+ memcpy(ptr, realhostU8, len);
1601	1655	ptr += len;
1602	1656	}
1603	1657	ptr++ = realport >> 8; / DST.PORT */

		@@ -1608,7 +1662,7 @@
1608	1662	return SOCKET_ERROR;
1609	1663	if (buf[0] != SOCKS5_VERSION \|\| buf[1] != SOCKS5_REP_SUCCEEDED) { /* check reply code */
1610	1664	UTIL_get_lang_msg("MSG_PROXY_BAD_REQUEST", uimsg, sizeof(uimsg),
1611		- "Proxy prevent this connection!");
	1665	+ _T("Proxy prevent this connection!"));
1612	1666	return setError(s, uimsg);
1613	1667	}
1614	1668	// buf[2] is reserved

		@@ -1647,8 +1701,8 @@
1647	1701
1648	1702	int begin_relay_socks4(ProxyInfo& proxy, String realhost, unsigned short realport, SOCKET s) {
1649	1703	unsigned char buf[256], *ptr;
1650		-
1651		- /* make connect request packet
	1704	+ u8 realhostU8 = (const TCHAR *)realhost;
	1705	+ /* make connect request packet
1652	1706	protocol v4:
1653	1707	VN:1, CD:1, PORT:2, ADDR:4, USER:n, NULL:1
1654	1708	protocol v4a:

		@@ -1661,15 +1715,15 @@
1661	1715	*ptr++ = realport & 0xFF;
1662	1716	in_addr addr;
1663	1717	addr.s_addr = INADDR_NONE;
1664		- char ch = realhost.charAt(0);
	1718	+ char ch = (const char )realhostU8;
1665	1719	if ('0' <= ch && ch <= '9') {
1666		- addr.s_addr = inet_addr(realhost);
	1720	+ addr.s_addr = inet_addr(realhostU8);
1667	1721	}
1668	1722	if (addr.s_addr != INADDR_NONE) {
1669	1723	memcpy(ptr, &addr, sizeof addr);
1670	1724	ptr += sizeof addr;
1671	1725	}else{
1672		- struct hostent* entry = resolve != RESOLVE_REMOTE ? gethostbyname(realhost) : NULL;
	1726	+ struct hostent* entry = resolve != RESOLVE_REMOTE ? gethostbyname(realhostU8) : NULL;
1673	1727	if (entry != NULL && entry->h_addrtype == AF_INET && entry->h_length == sizeof (in_addr)) {
1674	1728	addr.s_addr = INADDR_LOOPBACK;
1675	1729	memcpy(ptr, entry->h_addr_list[0], entry->h_length);

		@@ -1687,7 +1741,8 @@
1687	1741	}
1688	1742	/* username */
1689	1743	if (proxy.user != NULL) {
1690		- strcpy_s((char*) ptr, sizeof buf - (ptr - buf), proxy.user);
	1744	+ u8 proxy_user = (const TCHAR *)proxy.user;
	1745	+ strcpy_s((char*) ptr, sizeof buf - (ptr - buf), proxy_user);
1691	1746	ptr += proxy.user.length() + 1;
1692	1747	}else{
1693	1748	*ptr++ = '\0';

		@@ -1694,8 +1749,8 @@
1694	1749	}
1695	1750	if (addr.s_addr == INADDR_NONE) {
1696	1751	/* destination host name (for protocol 4a) */
1697		- strcpy_s((char*) ptr, sizeof buf - (ptr - buf), realhost);
1698		- ptr += strlen(realhost) + 1;
	1752	+ strcpy_s((char*) ptr, sizeof buf - (ptr - buf), realhostU8);
	1753	+ ptr += strlen(realhostU8) + 1;
1699	1754	}
1700	1755	/* send command and get response
1701	1756	response is: VN:1, CD:1, PORT:2, ADDR:4 */

		@@ -1705,22 +1760,22 @@
1705	1760	if (recieveFromSocket(s, buf, 8) == SOCKET_ERROR) {
1706	1761	return SOCKET_ERROR;
1707	1762	}
1708		- char uimsg[MAX_UIMSG];
1709		- uimsg[0] = NULL;
	1763	+ TCHAR uimsg[MAX_UIMSG];
	1764	+ uimsg[0] = 0;
1710	1765	if (buf[0] != 0) {
1711		- UTIL_get_lang_msg("MSG_PROXY_BAD_REQUEST", uimsg, sizeof(uimsg),
1712		- "Proxy prevent this connection!");
	1766	+ UTIL_get_lang_msg("MSG_PROXY_BAD_REQUEST", uimsg, _countof(uimsg),
	1767	+ _T("Proxy prevent this connection!"));
1713	1768	}else if (buf[1] == SOCKS4_REP_IDENT_FAIL \|\| buf[1] == SOCKS4_REP_USERID) {
1714		- UTIL_get_lang_msg("MSG_PROXY_UNAUTHORIZED", uimsg, sizeof(uimsg),
1715		- "Proxy authorization failed!");
	1769	+ UTIL_get_lang_msg("MSG_PROXY_UNAUTHORIZED", uimsg, _countof(uimsg),
	1770	+ _T("Proxy authorization failed!"));
1716	1771	}else if (buf[1] != SOCKS4_REP_SUCCEEDED) {
1717		- UTIL_get_lang_msg("MSG_PROXY_BAD_REQUEST", uimsg, sizeof(uimsg),
1718		- "Proxy prevent this connection!");
	1772	+ UTIL_get_lang_msg("MSG_PROXY_BAD_REQUEST", uimsg, _countof(uimsg),
	1773	+ _T("Proxy prevent this connection!"));
1719	1774	}
1720		- if (uimsg[0] != NULL) {
	1775	+ if (uimsg[0] != 0) {
1721	1776	return setError(s, uimsg);
1722	1777	}
1723		-
	1778	+
1724	1779	/* Conguraturation, connected via SOCKS4 server! */
1725	1780	return 0;
1726	1781	}

		@@ -1727,20 +1782,23 @@
1727	1782
1728	1783	int begin_relay_telnet(ProxyInfo& proxy, String realhost, unsigned short realport, SOCKET s) {
1729	1784	int err = 0;
1730		- char uimsg[MAX_UIMSG];
	1785	+ TCHAR uimsg[MAX_UIMSG];
	1786	+ u8 realhostU8 = (const TCHAR *)realhost;
	1787	+ u8 proxy_user = (const TCHAR *)proxy.user;
	1788	+ u8 proxy_pass = (const TCHAR *)proxy.pass;
1731	1789
1732	1790	while (!err) {
1733	1791	switch (wait_for_prompt(s, prompt_table, countof(prompt_table), 10)) {
1734	1792	case 0: /* Hostname prompt */
1735		- if (sendToSocketFormat(s, strchr(realhost,':')?"[%s]:%d\n":"%s:%d\n", (const char *)realhost, realport) == SOCKET_ERROR)
	1793	+ if (sendToSocketFormat(s, strchr(realhostU8,':')?"[%s]:%d\n":"%s:%d\n", (const char *)realhostU8, realport) == SOCKET_ERROR)
1736	1794	return SOCKET_ERROR;
1737	1795	break;
1738	1796	case 1: /* Username prompt */
1739		- if (sendToSocketFormat(s, "%s\n", (const char *)proxy.user) == SOCKET_ERROR)
	1797	+ if (sendToSocketFormat(s, "%s\n", (const char *)proxy_user) == SOCKET_ERROR)
1740	1798	return SOCKET_ERROR;
1741	1799	break;
1742	1800	case 2: /* Password prompt */
1743		- if (sendToSocketFormat(s, "%s\n", (const char *)proxy.pass) == SOCKET_ERROR)
	1801	+ if (sendToSocketFormat(s, "%s\n", (const char *)proxy_pass) == SOCKET_ERROR)
1744	1802	return SOCKET_ERROR;
1745	1803	break;
1746	1804	case 3: /* Established message */

		@@ -1752,11 +1810,11 @@
1752	1810	}
1753	1811	}
1754	1812	UTIL_get_lang_msg("MSG_PROXY_BAD_REQUEST", uimsg, sizeof(uimsg),
1755		- "Proxy prevent this connection!");
	1813	+ _T("Proxy prevent this connection!"));
1756	1814	return setError(s, uimsg);
1757	1815	}
1758	1816
1759		- int setError(SOCKET s, char *p) {
	1817	+ int setError(SOCKET s, TCHAR *p) {
1760	1818	if (*p != NULL)
1761	1819	showMessage(p);
1762	1820	HWND window;

		@@ -1771,7 +1829,7 @@
1771	1829	WSASetLastError(WSAECONNREFUSED);
1772	1830	return SOCKET_ERROR;
1773	1831	}
1774		- void showMessage(char *p) {
	1832	+ void showMessage(TCHAR *p) {
1775	1833	if (shower != NULL) {
1776	1834	shower->showMessage(p);
1777	1835	}

		@@ -1814,7 +1872,7 @@
1814	1872	struct sockaddr_in* in = (struct sockaddr_in*) name;
1815	1873	info = connectioninfolist.get(in->sin_addr);
1816	1874	if (info == NULL && defaultProxy.type != ProxyInfo::TYPE_NONE) {
1817		- info = new ConnectionInfo(defaultProxy, inet_ntoa(in->sin_addr));
	1875	+ info = new ConnectionInfo(defaultProxy, String((tc)inet_ntoa(in->sin_addr)));
1818	1876	holder = info;
1819	1877	}
1820	1878	}

		@@ -1824,8 +1882,8 @@
1824	1882	if (info == NULL && defaultProxy.type != ProxyInfo::TYPE_NONE) {
1825	1883	DWORD bufflen = 64;
1826	1884	char* buff = new char[64];
1827		- WSAAddressToString((struct sockaddr*)name, sizeof(struct sockaddr_in6), NULL, buff, &bufflen);
1828		- info = new ConnectionInfo(defaultProxy, buff);
	1885	+ WSAAddressToStringA((struct sockaddr*)name, sizeof(struct sockaddr_in6), NULL, buff, &bufflen);
	1886	+ info = new ConnectionInfo(defaultProxy, String((tc)buff));
1829	1887	holder = info;
1830	1888	}
1831	1889	}

		@@ -1833,7 +1891,7 @@
1833	1891	if (info->proxy.type == ProxyInfo::TYPE_NONE_FORCE) {
1834	1892	info = NULL;
1835	1893	}else{
1836		- const char* hostname;
	1894	+ u8 hostname;
1837	1895	if (info->proxy.type == ProxyInfo::TYPE_SSL) {
1838	1896	hostname = info->realhost;
1839	1897	}else{

		@@ -1918,147 +1976,147 @@
1918	1976	return SOCKET_ERROR;
1919	1977	}
1920	1978	SSLSocket* ssl = new SSLSocket();
1921		- if (!ssl->connect(s, info->realhost)) {
	1979	+ if (!ssl->connect(s, (u8)info->realhost)) {
1922	1980	shutdown(s, SD_BOTH);
1923	1981	int error_code = ssl->get_verify_result();
1924		- char uimsg[MAX_UIMSG];
	1982	+ TCHAR uimsg[MAX_UIMSG];
1925	1983	delete ssl;
1926	1984	switch (error_code) {
1927	1985	case IDS_UNABLE_TO_GET_ISSUER_CERT:
1928	1986	UTIL_get_lang_msg("MSG_UNABLE_TO_GET_ISSUER_CERT", uimsg, sizeof(uimsg),
1929		- "Unable to get Issuer Certificate");
	1987	+ _T("Unable to get Issuer Certificate"));
1930	1988	break;
1931	1989	case IDS_UNABLE_TO_GET_CRL:
1932	1990	UTIL_get_lang_msg("MSG_UNABLE_TO_GET_CRL", uimsg, sizeof(uimsg),
1933		- "Unable to get Certificate CRL");
	1991	+ _T("Unable to get Certificate CRL"));
1934	1992	break;
1935	1993	case IDS_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
1936	1994	UTIL_get_lang_msg("MSG_UNABLE_TO_DECRYPT_CERT_SIGNATURE", uimsg, sizeof(uimsg),
1937		- "Unable to decrypt Certificate's Signature");
	1995	+ _T("Unable to decrypt Certificate's Signature"));
1938	1996	break;
1939	1997	case IDS_UNABLE_TO_DECRYPT_CRL_SIGNATURE:
1940	1998	UTIL_get_lang_msg("MSG_UNABLE_TO_DECRYPT_CRL_SIGNATURE", uimsg, sizeof(uimsg),
1941		- "Unable to decrypt CRL's Signature");
	1999	+ _T("Unable to decrypt CRL's Signature"));
1942	2000	break;
1943	2001	case IDS_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:
1944	2002	UTIL_get_lang_msg("MSG_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY", uimsg, sizeof(uimsg),
1945		- "Unable to decode Issuer Public Key");
	2003	+ _T("Unable to decode Issuer Public Key"));
1946	2004	break;
1947	2005	case IDS_CERT_SIGNATURE_FAILURE:
1948	2006	UTIL_get_lang_msg("MSG_CERT_SIGNATURE_FAILURE", uimsg, sizeof(uimsg),
1949		- "Certificate Signature failure");
	2007	+ _T("Certificate Signature failure"));
1950	2008	break;
1951	2009	case IDS_CRL_SIGNATURE_FAILURE:
1952	2010	UTIL_get_lang_msg("MSG_CRL_SIGNATURE_FAILURE", uimsg, sizeof(uimsg),
1953		- "CRL Signature failure");
	2011	+ _T("CRL Signature failure"));
1954	2012	break;
1955	2013	case IDS_CERT_NOT_YET_VALID:
1956	2014	UTIL_get_lang_msg("MSG_CERT_NOT_YET_VALID", uimsg, sizeof(uimsg),
1957		- "Certificate is not yet valid");
	2015	+ _T("Certificate is not yet valid"));
1958	2016	break;
1959	2017	case IDS_CERT_HAS_EXPIRED:
1960	2018	UTIL_get_lang_msg("MSG_CERT_HAS_EXPIRED", uimsg, sizeof(uimsg),
1961		- "Certificate has expired");
	2019	+ _T("Certificate has expired"));
1962	2020	break;
1963	2021	case IDS_CRL_NOT_YET_VALID:
1964	2022	UTIL_get_lang_msg("MSG_CRL_NOT_YET_VALID", uimsg, sizeof(uimsg),
1965		- "CRL is not yet valid");
	2023	+ _T("CRL is not yet valid"));
1966	2024	break;
1967	2025	case IDS_CRL_HAS_EXPIRED:
1968	2026	UTIL_get_lang_msg("MSG_CRL_HAS_EXPIRED", uimsg, sizeof(uimsg),
1969		- "CRL has expired");
	2027	+ _T("CRL has expired"));
1970	2028	break;
1971	2029	case IDS_ERROR_IN_CERT_NOT_BEFORE_FIELD:
1972	2030	UTIL_get_lang_msg("MSG_ERROR_IN_CERT_NOT_BEFORE_FIELD", uimsg, sizeof(uimsg),
1973		- "Format error in Certificate's notBefore field");
	2031	+ _T("Format error in Certificate's notBefore field"));
1974	2032	break;
1975	2033	case IDS_ERROR_IN_CERT_NOT_AFTER_FIELD:
1976	2034	UTIL_get_lang_msg("MSG_ERROR_IN_CERT_NOT_AFTER_FIELD", uimsg, sizeof(uimsg),
1977		- "Format error in Certificate's notAfter field");
	2035	+ _T("Format error in Certificate's notAfter field"));
1978	2036	break;
1979	2037	case IDS_ERROR_IN_CRL_LAST_UPDATE_FIELD:
1980	2038	UTIL_get_lang_msg("MSG_ERROR_IN_CRL_LAST_UPDATE_FIELD", uimsg, sizeof(uimsg),
1981		- "Format error in CRL's lastUpdate field");
	2039	+ _T("Format error in CRL's lastUpdate field"));
1982	2040	break;
1983	2041	case IDS_ERROR_IN_CRL_NEXT_UPDATE_FIELD:
1984	2042	UTIL_get_lang_msg("MSG_ERROR_IN_CRL_NEXT_UPDATE_FIELD", uimsg, sizeof(uimsg),
1985		- "Format error in CRL's nextUpdate field");
	2043	+ _T("Format error in CRL's nextUpdate field"));
1986	2044	break;
1987	2045	case IDS_OUT_OF_MEM:
1988	2046	UTIL_get_lang_msg("MSG_OUT_OF_MEM", uimsg, sizeof(uimsg),
1989		- "Out of memory");
	2047	+ _T("Out of memory"));
1990	2048	break;
1991	2049	case IDS_DEPTH_ZERO_SELF_SIGNED_CERT:
1992	2050	UTIL_get_lang_msg("MSG_DEPTH_ZERO_SELF_SIGNED_CERT", uimsg, sizeof(uimsg),
1993		- "Self-signed Certificate");
	2051	+ _T("Self-signed Certificate"));
1994	2052	break;
1995	2053	case IDS_SELF_SIGNED_CERT_IN_CHAIN:
1996	2054	UTIL_get_lang_msg("MSG_SELF_SIGNED_CERT_IN_CHAIN", uimsg, sizeof(uimsg),
1997		- "Self-signed Certificate found in Certificate chain");
	2055	+ _T("Self-signed Certificate found in Certificate chain"));
1998	2056	break;
1999	2057	case IDS_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
2000	2058	UTIL_get_lang_msg("MSG_UNABLE_TO_GET_ISSUER_CERT_LOCALLY", uimsg, sizeof(uimsg),
2001		- "Unable to get Local Issuer Certificate");
	2059	+ _T("Unable to get Local Issuer Certificate"));
2002	2060	break;
2003	2061	case IDS_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
2004	2062	UTIL_get_lang_msg("MSG_UNABLE_TO_VERIFY_LEAF_SIGNATURE", uimsg, sizeof(uimsg),
2005		- "Unable to verify the first Certificate");
	2063	+ _T("Unable to verify the first Certificate"));
2006	2064	break;
2007	2065	case IDS_CERT_CHAIN_TOO_LONG:
2008	2066	UTIL_get_lang_msg("MSG_CERT_CHAIN_TOO_LONG", uimsg, sizeof(uimsg),
2009		- "Certificate chain too long");
	2067	+ _T("Certificate chain too long"));
2010	2068	break;
2011	2069	case IDS_CERT_REVOKED:
2012	2070	UTIL_get_lang_msg("MSG_CERT_REVOKED", uimsg, sizeof(uimsg),
2013		- "Certificate revoked");
	2071	+ _T("Certificate revoked"));
2014	2072	break;
2015	2073	case IDS_INVALID_CA:
2016	2074	UTIL_get_lang_msg("MSG_INVALID_CA", uimsg, sizeof(uimsg),
2017		- "Invalid CA Certificate");
	2075	+ _T("Invalid CA Certificate"));
2018	2076	break;
2019	2077	case IDS_PATH_LENGTH_EXCEEDED:
2020	2078	UTIL_get_lang_msg("MSG_PATH_LENGTH_EXCEEDED", uimsg, sizeof(uimsg),
2021		- "Path length constraint exceeded");
	2079	+ _T("Path length constraint exceeded"));
2022	2080	break;
2023	2081	case IDS_INVALID_PURPOSE:
2024	2082	UTIL_get_lang_msg("MSG_INVALID_PURPOSE", uimsg, sizeof(uimsg),
2025		- "Unsupported Certificate purpose");
	2083	+ _T("Unsupported Certificate purpose"));
2026	2084	break;
2027	2085	case IDS_CERT_UNTRUSTED:
2028	2086	UTIL_get_lang_msg("MSG_CERT_UNTRUSTED", uimsg, sizeof(uimsg),
2029		- "Certificate not trusted");
	2087	+ _T("Certificate not trusted"));
2030	2088	break;
2031	2089	case IDS_CERT_REJECTED:
2032	2090	UTIL_get_lang_msg("MSG_CERT_REJECTED", uimsg, sizeof(uimsg),
2033		- "Certificate rejected");
	2091	+ _T("Certificate rejected"));
2034	2092	break;
2035	2093	case IDS_SUBJECT_ISSUER_MISMATCH:
2036	2094	UTIL_get_lang_msg("MSG_SUBJECT_ISSUER_MISMATCH", uimsg, sizeof(uimsg),
2037		- "Subject Issuer mismatch");
	2095	+ _T("Subject Issuer mismatch"));
2038	2096	break;
2039	2097	case IDS_AKID_SKID_MISMATCH:
2040	2098	UTIL_get_lang_msg("MSG_AKID_SKID_MISMATCH", uimsg, sizeof(uimsg),
2041		- "Authority and Subject Key Identifier mismatch");
	2099	+ _T("Authority and Subject Key Identifier mismatch"));
2042	2100	break;
2043	2101	case IDS_AKID_ISSUER_SERIAL_MISMATCH:
2044	2102	UTIL_get_lang_msg("MSG_AKID_ISSUER_SERIAL_MISMATCH", uimsg, sizeof(uimsg),
2045		- "Authority and Issuer Serial Number mismatch");
	2103	+ _T("Authority and Issuer Serial Number mismatch"));
2046	2104	break;
2047	2105	case IDS_KEYUSAGE_NO_CERTSIGN:
2048	2106	UTIL_get_lang_msg("MSG_KEYUSAGE_NO_CERTSIGN", uimsg, sizeof(uimsg),
2049		- "Key usage does not include Certificate signing");
	2107	+ _T("Key usage does not include Certificate signing"));
2050	2108	break;
2051	2109	case IDS_APPLICATION_VERIFICATION:
2052	2110	UTIL_get_lang_msg("MSG_APPLICATION_VERIFICATION", uimsg, sizeof(uimsg),
2053		- "Application verification failure");
	2111	+ _T("Application verification failure"));
2054	2112	break;
2055	2113	case IDS_UNMATCH_COMMON_NAME:
2056	2114	UTIL_get_lang_msg("MSG_UNMATCH_COMMON_NAME", uimsg, sizeof(uimsg),
2057		- "Unmatch Common Name");
	2115	+ _T("Unmatch Common Name"));
2058	2116	break;
2059	2117	case IDS_UNABLE_TO_GET_COMMON_NAME:
2060	2118	UTIL_get_lang_msg("MSG_UNABLE_TO_GET_COMMON_NAME", uimsg, sizeof(uimsg),
2061		- "Unable to get Common Name");
	2119	+ _T("Unable to get Common Name"));
2062	2120	break;
2063	2121	default:
2064	2122	uimsg[0] = NULL;

		@@ -2073,10 +2131,10 @@
2073	2131	}
2074	2132
2075	2133	DECLARE_HOOKAPI(struct hostent, gethostbyname, (const char hostname), (hostname)) {
2076		- ConnectionInfo* info = connectioninfolist.find(hostname);
	2134	+ ConnectionInfo* info = connectioninfolist.find((tc)hostname);
2077	2135	if (info != NULL) {
2078	2136	if (info->proxy.type == ProxyInfo::TYPE_NONE_FORCE) {
2079		- hostname = info->realhost;
	2137	+ hostname = (u8)info->realhost;
2080	2138	}else{
2081	2139	if (info->proxy.type == ProxyInfo::TYPE_SSL
2082	2140	\|\| info->proxy.type == ProxyInfo::TYPE_HTTP_SSL

		@@ -2089,7 +2147,8 @@
2089	2147	}
2090	2148	}
2091	2149	if (info->buffer == NULL) {
2092		- int bufferLength = sizeof (DUMMYHOSTENT) + strlen(info->realhost);
	2150	+ u8 realhostU8 = (const TCHAR *)info->realhost;
	2151	+ int bufferLength = sizeof (DUMMYHOSTENT) + strlen(realhostU8);
2093	2152	info->buffer = new char[bufferLength];
2094	2153	info->fillBuffer(info->buffer, bufferLength);
2095	2154	}

		@@ -2100,7 +2159,7 @@
2100	2159	}
2101	2160
2102	2161	DECLARE_HOOKAPI(HANDLE, WSAAsyncGetHostByName, (HWND window, UINT message, const char* hostname, char* buffer, int bufferLength), (window, message, hostname, buffer, bufferLength)) {
2103		- ConnectionInfo* info = connectioninfolist.find(hostname);
	2162	+ ConnectionInfo* info = connectioninfolist.find((tc)hostname);
2104	2163	if (info == NULL \|\| info->proxy.type == ProxyInfo::TYPE_NONE_FORCE) {
2105	2164	return ORIG_WSAAsyncGetHostByName(window, message, hostname, buffer, bufferLength);
2106	2165	}

		@@ -2115,7 +2174,8 @@
2115	2174	}
2116	2175	}
2117	2176	HANDLE handle = connectioninfolist.getTask(info);
2118		- int len = sizeof (DUMMYHOSTENT) + strlen(hostname);
	2177	+ u8 hostnameU8 = hostname;
	2178	+ int len = sizeof (DUMMYHOSTENT) + strlen(hostnameU8);
2119	2179	if (bufferLength < len) {
2120	2180	::PostMessage(window, message, (WPARAM) handle, MAKELPARAM(len, WSAENOBUFS));
2121	2181	::WSASetLastError(WSAENOBUFS);

		@@ -2127,7 +2187,7 @@
2127	2187	}
2128	2188
2129	2189	DECLARE_HOOKAPI(HANDLE, WSAAsyncGetAddrInfo, (HWND window, UINT message, const char* hostname, const char* portname, struct addrinfo* hints, struct addrinfo** res), (window, message, hostname, portname, hints, res)) {
2130		- ConnectionInfo* info = connectioninfolist.find(hostname);
	2190	+ ConnectionInfo* info = connectioninfolist.find((tc)hostname);
2131	2191	if (info == NULL \|\| info->proxy.type == ProxyInfo::TYPE_NONE_FORCE) {
2132	2192	return ORIG_WSAAsyncGetAddrInfo(window, message, hostname, portname, hints, res);
2133	2193	}

		@@ -2142,7 +2202,8 @@
2142	2202	}
2143	2203	}
2144	2204	HANDLE handle = connectioninfolist.getTask(info);
2145		- int bufferLength = sizeof (DUMMYHOSTENT) + strlen(hostname) + 1;
	2205	+ u8 hostnameU8 = hostname;
	2206	+ int bufferLength = sizeof (DUMMYHOSTENT) + strlen(hostnameU8) + 1;
2146	2207	info->buffer = new char[bufferLength];
2147	2208	info->fillBuffer(info->buffer, bufferLength, portname, hints->ai_family);
2148	2209	DUMMYHOSTENT* d = (DUMMYHOSTENT*)info->buffer;

		@@ -2225,7 +2286,7 @@
2225	2286	int aicount;
2226	2287
2227	2288	ProxyWSockHook():shower(NULL), owner(NULL), resource_module(GetInstanceHandle()), timeout(0), aicount(0) {
2228		- HMODULE ws2_32 = ::GetModuleHandle("ws2_32.dll");
	2289	+ HMODULE ws2_32 = ::GetModuleHandle(_T("ws2_32.dll"));
2229	2290	LOADAPI(connect)
2230	2291	LOADAPI(gethostbyname)
2231	2292	LOADAPI(WSAAsyncGetHostByName)

		@@ -2245,54 +2306,54 @@
2245	2306	}
2246	2307	void _load(IniFile& ini) {
2247	2308	String temp;
2248		- temp = ini.getString("ProxyType");
	2309	+ temp = ini.getString(_T("ProxyType"));
2249	2310	if (temp != NULL) {
2250	2311	defaultProxy.type = ProxyInfo::parseType(temp);
2251	2312	if (defaultProxy.type != ProxyInfo::TYPE_NONE) {
2252		- defaultProxy.host = ini.getString("ProxyHost");
	2313	+ defaultProxy.host = ini.getString(_T("ProxyHost"));
2253	2314	if (defaultProxy.host == NULL \|\| defaultProxy.type == ProxyInfo::TYPE_NONE_FORCE) {
2254	2315	defaultProxy.type = ProxyInfo::TYPE_NONE;
2255	2316	}else{
2256		- defaultProxy.port = (unsigned short) ini.getInteger("ProxyPort");
2257		- defaultProxy.user = ini.getString("ProxyUser");
	2317	+ defaultProxy.port = (unsigned short) ini.getInteger(_T("ProxyPort"));
	2318	+ defaultProxy.user = ini.getString(_T("ProxyUser"));
2258	2319	if (defaultProxy.user != NULL)
2259		- defaultProxy.pass = ini.getString("ProxyPass");
	2320	+ defaultProxy.pass = ini.getString(_T("ProxyPass"));
2260	2321	}
2261	2322	}
2262	2323	}
2263	2324
2264		- timeout = ini.getInteger("ConnectionTimeout", 10);
	2325	+ timeout = ini.getInteger(_T("ConnectionTimeout"), 10);
2265	2326
2266		- temp = ini.getString("SocksResolve");
2267		- if (temp.equalsIgnoreCase("remote")) {
	2327	+ temp = ini.getString(_T("SocksResolve"));
	2328	+ if (temp.equalsIgnoreCase(_T("remote"))) {
2268	2329	resolve = RESOLVE_REMOTE;
2269		- }else if (temp.equalsIgnoreCase("local")) {
	2330	+ }else if (temp.equalsIgnoreCase(_T("local"))) {
2270	2331	resolve = RESOLVE_LOCAL;
2271	2332	}else{
2272	2333	resolve = RESOLVE_AUTO;
2273	2334	}
2274	2335
2275		- prompt_table[0] = ini.getString("TelnetHostnamePrompt", ">> Host name: ");
2276		- prompt_table[1] = ini.getString("TelnetUsernamePrompt", "Username:");
2277		- prompt_table[2] = ini.getString("TelnetPasswordPrompt", "Password:");
2278		- prompt_table[3] = ini.getString("TelnetConnectedMessage", "-- Connected to ");
2279		- prompt_table[4] = ini.getString("TelnetErrorMessage", "!!!!!!!!");
	2336	+ prompt_table[0] = ini.getString(_T("TelnetHostnamePrompt"), _T(">> Host name: "));
	2337	+ prompt_table[1] = ini.getString(_T("TelnetUsernamePrompt"), _T("Username:"));
	2338	+ prompt_table[2] = ini.getString(_T("TelnetPasswordPrompt"), _T("Password:"));
	2339	+ prompt_table[3] = ini.getString(_T("TelnetConnectedMessage"), _T("-- Connected to "));
	2340	+ prompt_table[4] = ini.getString(_T("TelnetErrorMessage"), _T("!!!!!!!!"));
2280	2341
2281		- logfile = ini.getString("DebugLog");
	2342	+ logfile = ini.getString(_T("DebugLog"));
2282	2343	Logger::open(logfile);
2283	2344	}
2284	2345	void _save(IniFile& ini) {
2285		- const char* type = NULL;
2286		- const char* host = NULL;
2287		- const char* port = NULL;
2288		- const char* user = NULL;
2289		- const char* pass = NULL;
	2346	+ const TCHAR* type = NULL;
	2347	+ const TCHAR* host = NULL;
	2348	+ const TCHAR* port = NULL;
	2349	+ const TCHAR* user = NULL;
	2350	+ const TCHAR* pass = NULL;
2290	2351	if (defaultProxy.type != ProxyInfo::TYPE_NONE && defaultProxy.type != ProxyInfo::TYPE_NONE_FORCE && defaultProxy.host != NULL) {
2291	2352	type = ProxyInfo::getTypeName(defaultProxy.type);
2292	2353	host = defaultProxy.host;
2293	2354	if (defaultProxy.port != 0) {
2294		- char* buffer = (char*) alloca(6);
2295		- _itoa_s(defaultProxy.port, buffer, 6, 10);
	2355	+ TCHAR* buffer = (TCHAR) alloca(sizeof(TCHAR) 6);
	2356	+ _itot_s(defaultProxy.port, buffer, 6, 10);
2296	2357	port = buffer;
2297	2358	}
2298	2359	if (defaultProxy.user != NULL) {

		@@ -2302,34 +2363,34 @@
2302	2363	}
2303	2364	}
2304	2365	}
2305		- ini.setString("ProxyType", type);
2306		- ini.setString("ProxyHost", host);
2307		- ini.setString("ProxyPort", port);
2308		- ini.setString("ProxyUser", user);
2309		- ini.setString("ProxyPass", pass);
	2366	+ ini.setString(_T("ProxyType"), type);
	2367	+ ini.setString(_T("ProxyHost"), host);
	2368	+ ini.setString(_T("ProxyPort"), port);
	2369	+ ini.setString(_T("ProxyUser"), user);
	2370	+ ini.setString(_T("ProxyPass"), pass);
2310	2371
2311		- ini.setInteger("ConnectionTimeout", timeout);
	2372	+ ini.setInteger(_T("ConnectionTimeout"), timeout);
2312	2373
2313	2374	switch (resolve) {
2314	2375	case RESOLVE_REMOTE:
2315		- type = "remote";
	2376	+ type = _T("remote");
2316	2377	break;
2317	2378	case RESOLVE_LOCAL:
2318		- type = "local";
	2379	+ type = _T("local");
2319	2380	break;
2320	2381	default:
2321		- type = "auto";
	2382	+ type = _T("auto");
2322	2383	break;
2323	2384	}
2324		- ini.setString("SocksResolve", type);
	2385	+ ini.setString(_T("SocksResolve"), type);
2325	2386
2326		- ini.setString("TelnetHostnamePrompt", prompt_table[0]);
2327		- ini.setString("TelnetUsernamePrompt", prompt_table[1]);
2328		- ini.setString("TelnetPasswordPrompt", prompt_table[2]);
2329		- ini.setString("TelnetConnectedMessage", prompt_table[3]);
2330		- ini.setString("TelnetErrorMessage", prompt_table[4]);
	2387	+ ini.setString(_T("TelnetHostnamePrompt"), prompt_table[0]);
	2388	+ ini.setString(_T("TelnetUsernamePrompt"), prompt_table[1]);
	2389	+ ini.setString(_T("TelnetPasswordPrompt"), prompt_table[2]);
	2390	+ ini.setString(_T("TelnetConnectedMessage"), prompt_table[3]);
	2391	+ ini.setString(_T("TelnetErrorMessage"), prompt_table[4]);
2331	2392
2332		- ini.setString("DebugLog", logfile);
	2393	+ ini.setString(_T("DebugLog"), logfile);
2333	2394	}
2334	2395	public:
2335	2396	static void setOwner(HWND owner) {

		@@ -2408,11 +2469,11 @@
2408	2469	static String generateURL() {
2409	2470	return instance().defaultProxy.generateURL();
2410	2471	}
2411		- static String parseURL(const char* url, BOOL prefix) {
	2472	+ static String parseURL(const char* url, BOOL prefix) {
2412	2473	ProxyInfo proxy;
2413		- String realhost = ProxyInfo::parse(url, proxy);
	2474	+ String realhost = ProxyInfo::parse((tc)url, proxy);
2414	2475	if (realhost != NULL) {
2415		- if (realhost.indexOf("://") != -1 && !prefix) {
	2476	+ if (realhost.indexOf(_T("://")) != -1 && !prefix) {
2416	2477	proxy.type = proxy.TYPE_NONE;
2417	2478	}
2418	2479	if (realhost.length() == 0) {

--- branches/cmake/TTProxy/SSLLIB.h (revision 7326)

+++ branches/cmake/TTProxy/SSLLIB.h (revision 7327)

		@@ -11,7 +11,7 @@
11	11	rettype apiname arglist { \
12	12	static rettype (*func) arglist = \
13	13	(rettype (*) arglist) \
14		- GetProcAddress(GetModuleHandle(#module), #apiname); \
	14	+ GetProcAddress(GetModuleHandleA(#module), #apiname); \
15	15	return (*func) args; \
16	16	}
17	17	#define DECLARE_MODULE_API_v(module, apiname, arglist, args) \

		@@ -18,7 +18,7 @@
18	18	void apiname arglist { \
19	19	static void (*func) arglist = \
20	20	(void (*) arglist) \
21		- GetProcAddress(GetModuleHandle(#module), #apiname); \
	21	+ GetProcAddress(GetModuleHandleA(#module), #apiname); \
22	22	(*func) args; \
23	23	}
24	24

--- branches/cmake/TTProxy/SSLSocket.h (revision 7326)

+++ branches/cmake/TTProxy/SSLSocket.h (revision 7327)

		@@ -84,8 +84,8 @@
84	84	}
85	85	public:
86	86	static bool init() {
87		- LIBEAY32() = ::LoadLibrary("LIBEAY32");
88		- SSLEAY32() = ::LoadLibrary("SSLEAY32");
	87	+ LIBEAY32() = ::LoadLibraryA("LIBEAY32");
	88	+ SSLEAY32() = ::LoadLibraryA("SSLEAY32");
89	89	if (LIBEAY32() == NULL \|\| SSLEAY32() == NULL) {
90	90	if (LIBEAY32() != NULL) {
91	91	::FreeLibrary(LIBEAY32());

		@@ -140,12 +140,15 @@
140	140	if (*s2 != '.')
141	141	return false;
142	142	}else{
	143	+#if !defined(UNICODE)
143	144	if (::IsDBCSLeadByte(*s1)) {
144	145	if (s1 != s2 \|\| s1 + 1 >= s1_end \|\| s2 + 1 >= s2_end \|\| (s1 + 1) != (s2 + 1))
145	146	return false;
146	147	s1++;
147	148	s2++;
148		- }else{
	149	+ } else
	150	+#endif
	151	+ {
149	152	if (toLowerCase(s1) != toLowerCase(s2))
150	153	return false;
151	154	}

		@@ -156,13 +159,15 @@
156	159	return true;
157	160	}
158	161
	162	+#if 0
159	163	static int print_debugw32(const char str, size_t len, void u) {
160	164	char* buf = (char*) alloca(len + 1);
161	165	memcpy(buf, str, len);
162	166	buf[len] = '\0';
163		- OutputDebugString(buf);
	167	+ OutputDebugStringA(buf);
164	168	return len;
165	169	}
	170	+#endif
166	171	private:
167	172	SSL* ssl;
168	173	long verify_result;

--- branches/cmake/TTProxy/TTProxy.cpp (revision 7326)

+++ branches/cmake/TTProxy/TTProxy.cpp (revision 7327)

		@@ -1,7 +1,7 @@
1	1	// ttx.cpp : DLL アプリケーション用のエントリポイントを定義します。
2	2	//
3	3
4		-#include "stdafx.h"
	4	+#include "StdAfx.h"
5	5
6	6	#include "resource.h"
7	7

		@@ -18,6 +18,7 @@
18	18	}
19	19
20	20	extern "C" __declspec(dllexport) BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved) {
	21	+ (void)reserved;
21	22	switch (reason) {
22	23	case DLL_PROCESS_ATTACH:
23	24	myInstance = instance;

--- branches/cmake/TTProxy/TTProxy.h (revision 7326)

+++ branches/cmake/TTProxy/TTProxy.h (revision 7327)

		@@ -1,6 +1,8 @@
1	1	#ifndef _YEBISOCKS_TTX_H_
2	2	#define _YEBISOCKS_TTX_H_
3	3
	4	+#include "codeconv.h"
	5	+
4	6	#include <YCL/DynamicLinkLibrary.h>
5	7	using namespace yebisuya;
6	8

		@@ -31,7 +33,7 @@
31	33	private:
32	34	class Shower : public ProxyWSockHook::MessageShower {
33	35	public:
34		- virtual void showMessage(const char* message)const {
	36	+ virtual void showMessage(const TCHAR* message)const {
35	37	add_error_message(message);
36	38	}
37	39	} shower;

		@@ -46,10 +48,10 @@
46	48	PWriteIniFile ORIG_WriteIniFile;
47	49	PParseParam ORIG_ParseParam;
48	50
49		- static void add_error_message(const char* message) {
	51	+ static void add_error_message(const TCHAR* message) {
50	52	if (getInstance().error_message != NULL) {
51		- StringBuffer buffer = (const char *)getInstance().error_message;
52		- buffer.append("\n\n");
	53	+ StringBuffer buffer = (const TCHAR *)getInstance().error_message;
	54	+ buffer.append(_T("\n\n"));
53	55	buffer.append(message);
54	56	getInstance().error_message = buffer.toString();
55	57	}else{

		@@ -58,22 +60,22 @@
58	60	::PostMessage(getInstance().cv->HWin, WM_COMMAND, ID_ASYNCMESSAGEBOX, 0);
59	61	}
60	62	static void read_options(const char* filename) {
61		- IniFile inifile(filename, "TTProxy");
	63	+ IniFile inifile(String((tc)filename), _T("TTProxy"));
62	64	ProxyWSockHook::load(inifile);
63	65	getInstance().initialized = true;
64	66	}
65	67	static void write_options(const char* filename) {
66		- IniFile inifile(filename, "TTProxy");
	68	+ IniFile inifile(String((tc)filename), _T("TTProxy"));
67	69	ProxyWSockHook::save(inifile);
68	70	}
69		- static String get_teraterm_dir_relative_name(char* basename) {
	71	+ static String get_teraterm_dir_relative_name(TCHAR* basename) {
70	72	if (basename[0] == '\\' \|\| basename[0] == '/' \|\| basename[0] != '\0' && basename[1] == ':') {
71	73	return basename;
72	74	}
73		- char buf[1024];
	75	+ TCHAR buf[1024];
74	76	::GetModuleFileName(NULL, buf, sizeof buf);
75		- char* filename = NULL;
76		- for (char* dst = buf; *dst != '\0'; dst++) {
	77	+ TCHAR* filename = NULL;
	78	+ for (TCHAR* dst = buf; *dst != '\0'; dst++) {
77	79	if (dst == '\\' \|\| dst == '/' \|\| *dst == ':') {
78	80	filename = dst + 1;
79	81	}

		@@ -87,16 +89,16 @@
87	89	return buffer.toString();
88	90	}
89	91
90		- static void PASCAL TTXReadINIFile(PCHAR fileName, PTTSet ts) {
	92	+ static void WINAPI TTXReadINIFile(char *fileName, PTTSet ts) {
91	93	getInstance().ORIG_ReadIniFile(fileName, ts);
92	94	read_options(fileName);
93	95	}
94		- static void PASCAL TTXWriteINIFile(PCHAR fileName, PTTSet ts) {
	96	+ static void WINAPI TTXWriteINIFile(char *fileName, PTTSet ts) {
95	97	getInstance().ORIG_WriteIniFile(fileName, ts);
96	98	write_options(fileName);
97	99	}
98	100
99		- static void PASCAL TTXParseParam(PCHAR param, PTTSet ts, PCHAR DDETopic) {
	101	+ static void WINAPI TTXParseParam(PCHAR param, PTTSet ts, PCHAR DDETopic) {
100	102	//int param_len=strlen(param);
101	103	char option[1024];
102	104	int opt_len = sizeof(option);

		@@ -115,7 +117,7 @@
115	117
116	118	if ((option[0] == '-' \|\| option[0] == '/')) {
117	119	if ((option[1] == 'F' \|\| option[1] == 'f') && option[2] == '=') {
118		- read_options(get_teraterm_dir_relative_name(option + 3));
	120	+ read_options((u8)get_teraterm_dir_relative_name((TCHAR )(const TCHAR )(tc)(option + 3)));
119	121	}
120	122	}
121	123

		@@ -156,7 +158,7 @@
156	158	String realhost = ProxyWSockHook::parseURL(option, FALSE);
157	159	if (realhost != NULL) {
158	160	getInstance().realhost = realhost;
159		- if (realhost.indexOf("://") == -1) {
	161	+ if (realhost.indexOf(_T("://")) == -1) {
160	162	action = OPTION_CLEAR;
161	163	}
162	164	else {

		@@ -182,7 +184,7 @@
182	184
183	185	getInstance().ORIG_ParseParam(param, ts, DDETopic);
184	186	if (getInstance().ts->HostName[0] == '\0' && getInstance().realhost != NULL) {
185		- strcpy_s(getInstance().ts->HostName, sizeof getInstance().ts->HostName, getInstance().realhost);
	187	+ strcpy_s(getInstance().ts->HostName, sizeof getInstance().ts->HostName, (u8)getInstance().realhost);
186	188	}
187	189	}
188	190

		@@ -195,7 +197,7 @@
195	197	((WORD) lParam) = langid;
196	198	return FALSE;
197	199	}
198		- static void PASCAL TTXInit(PTTSet ts, PComVar cv) {
	200	+ static void WINAPI TTXInit(PTTSet ts, PComVar cv) {
199	201	getInstance().ts = ts;
200	202	getInstance().cv = cv;
201	203

		@@ -202,7 +204,7 @@
202	204	ProxyWSockHook::setMessageShower(&getInstance().shower);
203	205	}
204	206
205		- static void PASCAL TTXGetSetupHooks(TTXSetupHooks* hooks) {
	207	+ static void WINAPI TTXGetSetupHooks(TTXSetupHooks* hooks) {
206	208	getInstance().ORIG_ReadIniFile = *hooks->ReadIniFile;
207	209	getInstance().ORIG_WriteIniFile = *hooks->WriteIniFile;
208	210	getInstance().ORIG_ParseParam = *hooks->ParseParam;

		@@ -212,7 +214,7 @@
212	214	copy_UILanguageFile();
213	215	}
214	216
215		- static void PASCAL TTXOpenTCP(TTXSockHooks* hooks) {
	217	+ static void WINAPI TTXOpenTCP(TTXSockHooks* hooks) {
216	218	if (!getInstance().initialized) {
217	219	read_options(getInstance().ts->SetupFName);
218	220	}

		@@ -224,7 +226,7 @@
224	226	(FARPROC&) hooks->PWSACancelAsyncRequest = ProxyWSockHook::hook_WSACancelAsyncRequest((FARPROC) hooks->PWSACancelAsyncRequest);
225	227	}
226	228
227		- static void PASCAL TTXCloseTCP(TTXSockHooks* hooks) {
	229	+ static void WINAPI TTXCloseTCP(TTXSockHooks* hooks) {
228	230	// unhook functions
229	231	ProxyWSockHook::unhook_connect((FARPROC) *hooks->Pconnect);
230	232	ProxyWSockHook::unhook_WSAAsyncGetHostByName((FARPROC) *hooks->PWSAAsyncGetHostByName);

		@@ -234,18 +236,18 @@
234	236	ProxyWSockHook::unhook_WSACancelAsyncRequest((FARPROC) *hooks->PWSACancelAsyncRequest);
235	237	}
236	238
237		- static void PASCAL TTXModifyMenu(HMENU menu) {
238		- char uimsg[MAX_UIMSG];
	239	+ static void WINAPI TTXModifyMenu(HMENU menu) {
	240	+ TCHAR uimsg[MAX_UIMSG];
239	241	copy_UILanguageFile();
240	242	/* inserts before ID_HELP_ABOUT */
241		- UTIL_get_lang_msg("MENU_ABOUT", uimsg, sizeof(uimsg), "About TT&Proxy...");
	243	+ UTIL_get_lang_msg("MENU_ABOUT", uimsg, _countof(uimsg), _T("About TT&Proxy..."));
242	244	InsertMenu(menu, 50990, MF_BYCOMMAND \| MF_ENABLED, ID_ABOUTMENU, uimsg);
243	245	/* inserts before ID_SETUP_TCPIP */
244		- UTIL_get_lang_msg("MENU_SETUP", uimsg, sizeof(uimsg), "&Proxy...");
	246	+ UTIL_get_lang_msg("MENU_SETUP", uimsg, _countof(uimsg), _T("&Proxy..."));
245	247	InsertMenu(menu, 50360, MF_BYCOMMAND \| MF_ENABLED, ID_PROXYSETUPMENU, uimsg);
246	248	}
247	249
248		- static int PASCAL TTXProcessCommand(HWND hWin, WORD cmd) {
	250	+ static int WINAPI TTXProcessCommand(HWND hWin, WORD cmd) {
249	251	switch (cmd) {
250	252	case ID_ABOUTMENU:
251	253	copy_UILanguageFile();

		@@ -260,7 +262,7 @@
260	262	String msg = getInstance().error_message;
261	263	getInstance().showing_error_message = true;
262	264	getInstance().error_message = NULL;
263		- ::MessageBox(hWin, msg, "TTProxy", MB_OK \| MB_ICONERROR);
	265	+ ::MessageBox(hWin, msg, _T("TTProxy"), MB_OK \| MB_ICONERROR);
264	266	getInstance().showing_error_message = false;
265	267	if (getInstance().error_message != NULL) {
266	268	::PostMessage(hWin, WM_COMMAND, ID_ASYNCMESSAGEBOX, 0);

		@@ -272,19 +274,20 @@
272	274	}
273	275	}
274	276
275		- static void PASCAL TTXSetCommandLine(PCHAR cmd, int cmdlen, PGetHNRec rec) {
	277	+ static void WINAPI TTXSetCommandLine(PCHAR cmd, int cmdlen, PGetHNRec rec) {
276	278	String url = ProxyWSockHook::generateURL();
277	279	if (url != NULL) {
278		- if (strlen(cmd) + 8 + url.length() >= (unsigned) cmdlen)
	280	+ u8 urlU8 = (const TCHAR *)url;
	281	+ if (strlen(cmd) + 8 + strlen(urlU8) >= (unsigned) cmdlen)
279	282	return;
280	283	strcat_s(cmd, cmdlen, " -proxy=");
281		- strcat_s(cmd, cmdlen, url);
	284	+ strcat_s(cmd, cmdlen, urlU8);
282	285	}
283	286	}
284	287
285		- static void PASCAL TTXEnd() {
	288	+ static void WINAPI TTXEnd() {
286	289	if (getInstance().error_message != NULL) {
287		- ::MessageBox(NULL, getInstance().error_message, "TTProxy", MB_OK \| MB_ICONERROR);
	290	+ ::MessageBox(NULL, getInstance().error_message, _T("TTProxy"), MB_OK \| MB_ICONERROR);
288	291	getInstance().error_message = NULL;
289	292	}
290	293	}

--- branches/cmake/TTProxy/YCL/include/YCL/ComboBoxCtrl.h (revision 7326)

+++ branches/cmake/TTProxy/YCL/include/YCL/ComboBoxCtrl.h (revision 7327)

		@@ -30,7 +30,7 @@
30	30	int resetContent() {
31	31	return SendMessage(CB_RESETCONTENT);
32	32	}
33		- int addString(const char* string) {
	33	+ int addString(const TCHAR* string) {
34	34	return SendMessage(CB_ADDSTRING, 0, (LPARAM) string);
35	35	}
36	36	int addItemData(long data) {

		@@ -48,12 +48,12 @@
48	48	int getTextLen(int index)const {
49	49	return SendMessage(CB_GETLBTEXTLEN, index);
50	50	}
51		- int getText(int index, char* buffer)const {
	51	+ int getText(int index, TCHAR* buffer)const {
52	52	return SendMessage(CB_GETLBTEXT, index, (LPARAM) buffer);
53	53	}
54	54	String getText(int index) {
55	55	int length = getTextLen(index);
56		- char* buffer = (char*) alloca(length + 1);
	56	+ TCHAR* buffer = (TCHAR) alloca(sizeof(TCHAR) (length + 1));
57	57	getText(index, buffer);
58	58	return buffer;
59	59	}

--- branches/cmake/TTProxy/YCL/include/YCL/Dialog.h (revision 7326)

+++ branches/cmake/TTProxy/YCL/include/YCL/Dialog.h (revision 7327)

		@@ -14,6 +14,10 @@
14	14	#include <YCL/Window.h>
15	15	#include <YCL/Hashtable.h>
16	16
	17	+#include "dlglib.h"
	18	+
	19	+#define DIALOGBOX_REPLACE 1
	20	+
17	21	namespace yebisuya {
18	22
19	23	class Dialog : virtual public Window {

		@@ -65,10 +69,10 @@
65	69	int value = ::GetDlgItemInt(*this, id, &succeeded, valueSigned);
66	70	return succeeded ? value : defaultValue;
67	71	}
68		- bool SetDlgItemText(int id, const char* text) {
	72	+ bool SetDlgItemText(int id, const TCHAR* text) {
69	73	return ::SetDlgItemText(*this, id, text) != FALSE;
70	74	}
71		- int GetDlgItemText(int id, char* buffer, size_t length)const {
	75	+ int GetDlgItemText(int id, TCHAR* buffer, size_t length)const {
72	76	return ::GetDlgItemText(*this, id, buffer, length);
73	77	}
74	78	String GetDlgItemText(int id)const {

		@@ -78,7 +82,11 @@
78	82	return ::SendDlgItemMessage(*this, id, message, wparam, lparam);
79	83	}
80	84	bool EndDialog(int result) {
	85	+#if defined(DIALOGBOX_REPLACE)
	86	+ return ::TTEndDialog(*this, result) != FALSE;
	87	+#else
81	88	return ::EndDialog(*this, result) != FALSE;
	89	+#endif
82	90	}
83	91	bool MapDialogRect(RECT& rect)const {
84	92	return ::MapDialogRect(*this, &rect) != FALSE;

		@@ -109,7 +117,11 @@
109	117	}
110	118	int open(HINSTANCE instance, int resourceId, HWND owner = NULL) {
111	119	YCLVERIFY(prepareOpen(this) == NULL, "Another dialog has been opening yet.");
	120	+#if defined(DIALOGBOX_REPLACE)
	121	+ return ::TTDialogBoxParam(instance, MAKEINTRESOURCE(resourceId), owner, (DLGPROC)DialogProc, NULL);
	122	+#else
112	123	return ::DialogBoxParam(instance, MAKEINTRESOURCE(resourceId), owner, (DLGPROC)DialogProc, NULL);
	124	+#endif
113	125	}
114	126	protected:
115	127	virtual bool dispatch(int message, int wparam, long lparam) {

--- branches/cmake/TTProxy/YCL/include/YCL/EditBoxCtrl.h (revision 7326)

+++ branches/cmake/TTProxy/YCL/include/YCL/EditBoxCtrl.h (revision 7327)

		@@ -21,13 +21,13 @@
21	21	int getLineCount()const {
22	22	return SendMessage(EM_GETLINECOUNT);
23	23	}
24		- int getLine(int line, char* buffer, int length)const {
	24	+ int getLine(int line, TCHAR* buffer, int length)const {
25	25	((int) buffer) = length;
26	26	return SendMessage(EM_GETLINE, line, (LPARAM) buffer);
27	27	}
28	28	String getLine(int line)const {
29	29	int length = lineLength(line);
30		- char* buffer = (char*) alloca(length + 1);
	30	+ TCHAR* buffer = (TCHAR) alloca(sizeof(TCHAR) (length + 1));
31	31	getLine(line, buffer, length + 1);
32	32	return buffer;
33	33	}

--- branches/cmake/TTProxy/YCL/include/YCL/FileVersion.h (revision 7326)

+++ branches/cmake/TTProxy/YCL/include/YCL/FileVersion.h (revision 7327)

		@@ -19,84 +19,84 @@
19	19
20	20	class FileVersion {
21	21	private:
22		- static const char* ROOT() {
23		- static const char string[] = "\\";
24		- return string;
25		- }
26		- static const char* TRANS() {
27		- static const char string[] = "\\VarFileInfo\\Translation";
28		- return string;
29		- }
30		- static const char* STRINGBLOCK() {
31		- static const char string[] = "\\StringFileInfo\\%08X\\%s";
32		- return string;
33		- }
	22	+ static const TCHAR* ROOT() {
	23	+ static const TCHAR string[] = _T("\\");
	24	+ return string;
	25	+ }
	26	+ static const TCHAR* TRANS() {
	27	+ static const TCHAR string[] = _T("\\VarFileInfo\\Translation");
	28	+ return string;
	29	+ }
	30	+ static const TCHAR* STRINGBLOCK() {
	31	+ static const TCHAR string[] = _T("\\StringFileInfo\\%08X\\%s");
	32	+ return string;
	33	+ }
34	34
35		- static const char* COMMENTS() {
36		- static const char string[] = "Comments";
37		- return string;
	35	+ static const TCHAR* COMMENTS() {
	36	+ static const TCHAR string[] = _T("Comments");
	37	+ return string;
38	38	}
39		- static const char* COMPANYNAME() {
40		- static const char string[] = "CompanyName";
41		- return string;
	39	+ static const TCHAR* COMPANYNAME() {
	40	+ static const TCHAR string[] = _T("CompanyName");
	41	+ return string;
42	42	}
43		- static const char* FILEDESCRIPTION() {
44		- static const char string[] = "FileDescription";
45		- return string;
	43	+ static const TCHAR* FILEDESCRIPTION() {
	44	+ static const TCHAR string[] = _T("FileDescription");
	45	+ return string;
46	46	}
47		- static const char* FILEVERSION() {
48		- static const char string[] = "FileVersion";
49		- return string;
	47	+ static const TCHAR* FILEVERSION() {
	48	+ static const TCHAR string[] = _T("FileVersion");
	49	+ return string;
50	50	}
51		- static const char* INTERNALNAME() {
52		- static const char string[] = "InternalName";
53		- return string;
	51	+ static const TCHAR* INTERNALNAME() {
	52	+ static const TCHAR string[] = _T("InternalName");
	53	+ return string;
54	54	}
55		- static const char* LEGALCOPYRIGHT() {
56		- static const char string[] = "LegalCopyright";
57		- return string;
	55	+ static const TCHAR* LEGALCOPYRIGHT() {
	56	+ static const TCHAR string[] = _T("LegalCopyright");
	57	+ return string;
58	58	}
59		- static const char* LEGALTRADEMARKS() {
60		- static const char string[] = "LegalTrademarks";
61		- return string;
	59	+ static const TCHAR* LEGALTRADEMARKS() {
	60	+ static const TCHAR string[] = _T("LegalTrademarks");
	61	+ return string;
62	62	}
63		- static const char* ORIGINALFILENAME() {
64		- static const char string[] = "OriginalFilename";
65		- return string;
	63	+ static const TCHAR* ORIGINALFILENAME() {
	64	+ static const TCHAR string[] = _T("OriginalFilename");
	65	+ return string;
66	66	}
67		- static const char* PRIVATEBUILD() {
68		- static const char string[] = "PrivateBuild";
69		- return string;
	67	+ static const TCHAR* PRIVATEBUILD() {
	68	+ static const TCHAR string[] = _T("PrivateBuild");
	69	+ return string;
70	70	}
71		- static const char* PRODUCTNAME() {
72		- static const char string[] = "ProductName";
73		- return string;
	71	+ static const TCHAR* PRODUCTNAME() {
	72	+ static const TCHAR string[] = _T("ProductName");
	73	+ return string;
74	74	}
75		- static const char* PRODUCTVERSION() {
76		- static const char string[] = "ProductVersion";
77		- return string;
	75	+ static const TCHAR* PRODUCTVERSION() {
	76	+ static const TCHAR string[] = _T("ProductVersion");
	77	+ return string;
78	78	}
79		- static const char* SPECIALBUILD() {
80		- static const char string[] = "SpecialBuild";
81		- return string;
	79	+ static const TCHAR* SPECIALBUILD() {
	80	+ static const TCHAR string[] = _T("SpecialBuild");
	81	+ return string;
82	82	}
83	83
84		- char* info;
	84	+ TCHAR* info;
85	85	mutable LPWORD trans;
86	86	mutable UINT transSize;
87	87	mutable VS_FIXEDFILEINFO* fixedInfo;
88	88
89	89	void init(HINSTANCE instance) {
90		- char buffer[MAX_PATH];
	90	+ TCHAR buffer[MAX_PATH];
91	91	::GetModuleFileName(instance, buffer, countof(buffer));
92	92	init(buffer);
93	93	}
94		- void init(const char* filename) {
	94	+ void init(const TCHAR* filename) {
95	95	DWORD handle;
96		- DWORD size = ::GetFileVersionInfoSize((char*) filename, &handle);
	96	+ DWORD size = ::GetFileVersionInfoSize(filename, &handle);
97	97	if (size != 0){
98		- info = new char[size];
99		- if (!::GetFileVersionInfo((char*) filename, handle, size, info)) {
	98	+ info = new TCHAR[size];
	99	+ if (!::GetFileVersionInfo(filename, handle, size, info)) {
100	100	delete[] info;
101	101	info = NULL;
102	102	}

		@@ -105,7 +105,7 @@
105	105	bool validateFixedFileInfo()const {
106	106	if (fixedInfo == NULL){
107	107	UINT size;
108		- if (!::VerQueryValue((void) (const void) info, (char) ROOT(), (LPVOID) &fixedInfo, &size))
	108	+ if (!::VerQueryValue((void) (const void) info, ROOT(), (LPVOID*) &fixedInfo, &size))
109	109	return false;
110	110	}
111	111	return true;

		@@ -112,7 +112,7 @@
112	112	}
113	113	bool validateTranslation()const {
114	114	if (trans == NULL){
115		- if (!::VerQueryValue((void) (const void) info, (char) TRANS(), (LPVOID) &trans, &transSize))
	115	+ if (!::VerQueryValue((void) (const void) info, TRANS(), (LPVOID*) &trans, &transSize))
116	116	return false;
117	117	}
118	118	return true;

		@@ -124,7 +124,7 @@
124	124	FileVersion(HINSTANCE hInstance):info(NULL), fixedInfo(NULL), trans(NULL), transSize(0) {
125	125	init(hInstance);
126	126	}
127		- FileVersion(const char* filename):info(NULL), fixedInfo(NULL), trans(NULL), transSize(0) {
	127	+ FileVersion(const TCHAR* filename):info(NULL), fixedInfo(NULL), trans(NULL), transSize(0) {
128	128	init(filename);
129	129	}
130	130	~FileVersion() {

		@@ -152,51 +152,51 @@
152	152	int getCharset(int index = 0)const {
153	153	return validateTranslation() ? MAKELONG(trans[index * 2 + 1], trans[index * 2]) : 0;
154	154	}
155		- const char* getString(int charset, const char* blockName)const {
156		- char buffer[64];
	155	+ const TCHAR* getString(int charset, const TCHAR* blockName)const {
	156	+ TCHAR buffer[64];
157	157	wsprintf(buffer, STRINGBLOCK(), charset, blockName);
158	158	UINT size;
159		- const char* string;
	159	+ const TCHAR* string;
160	160	return ::VerQueryValue((void) (const void) info, buffer, (LPVOID*) &string, &size) ? string : NULL;
161	161	}
162		- const char* getString(const char* blockName)const {
	162	+ const TCHAR* getString(const TCHAR* blockName)const {
163	163	return getString(getCharset(), blockName);
164	164	}
165	165
166		- const char* getComments()const {
	166	+ const TCHAR* getComments()const {
167	167	return getString(COMMENTS());
168	168	}
169		- const char* getCompanyName()const {
	169	+ const TCHAR* getCompanyName()const {
170	170	return getString(COMPANYNAME());
171	171	}
172		- const char* getFileDescription()const {
	172	+ const TCHAR* getFileDescription()const {
173	173	return getString(FILEDESCRIPTION());
174	174	}
175		- const char* getFileVersion()const {
	175	+ const TCHAR* getFileVersion()const {
176	176	return getString(FILEVERSION());
177	177	}
178		- const char* getInternalName()const {
	178	+ const TCHAR* getInternalName()const {
179	179	return getString(INTERNALNAME());
180	180	}
181		- const char* getLegalCopyright()const {
	181	+ const TCHAR* getLegalCopyright()const {
182	182	return getString(LEGALCOPYRIGHT());
183	183	}
184		- const char* getLegalTrademarks()const {
	184	+ const TCHAR* getLegalTrademarks()const {
185	185	return getString(LEGALTRADEMARKS());
186	186	}
187		- const char* getOriginalFilename()const {
	187	+ const TCHAR* getOriginalFilename()const {
188	188	return getString(ORIGINALFILENAME());
189	189	}
190		- const char* getPrivateBuild()const {
	190	+ const TCHAR* getPrivateBuild()const {
191	191	return getString(PRIVATEBUILD());
192	192	}
193		- const char* getProductName()const {
	193	+ const TCHAR* getProductName()const {
194	194	return getString(PRODUCTNAME());
195	195	}
196		- const char* getProductVersion()const {
	196	+ const TCHAR* getProductVersion()const {
197	197	return getString(PRODUCTVERSION());
198	198	}
199		- const char* getSpecialBuild()const {
	199	+ const TCHAR* getSpecialBuild()const {
200	200	return getString(SPECIALBUILD());
201	201	}
202	202

--- branches/cmake/TTProxy/YCL/include/YCL/IniFile.h (revision 7326)

+++ branches/cmake/TTProxy/YCL/include/YCL/IniFile.h (revision 7327)

		@@ -24,17 +24,17 @@
24	24	class IniFile {
25	25	private:
26	26	static String YES() {
27		- static const char YES[] = "yes";
	27	+ static const TCHAR YES[] = _T("yes");
28	28	static String string = YES;
29	29	return string;
30	30	}
31	31	static String NO() {
32		- static const char NO[] = "no";
	32	+ static const TCHAR NO[] = _T("no");
33	33	static String string = NO;
34	34	return string;
35	35	}
36		- static const char* INVALID() {
37		- static const char string[] = "\n:";
	36	+ static const TCHAR* INVALID() {
	37	+ static const TCHAR string[] = _T("\n:");
38	38	return string;
39	39	}
40	40

		@@ -43,16 +43,16 @@
43	43	Vector<String> list;
44	44	mutable int index;
45	45	public:
46		- EnumKeyNames(const char* filename, const char* section):index(0) {
	46	+ EnumKeyNames(const TCHAR* filename, const TCHAR* section):index(0) {
47	47	Hashtable<String, int> table;
48		- int section_len = strlen(section);
49		- char* buffer;
	48	+ int section_len = _tcslen(section);
	49	+ TCHAR* buffer;
50	50	size_t size = 256;
51	51	while ((buffer = getSectionNames(filename, size)) == NULL)
52	52	size += 256;
53		- const char* name = buffer;
	53	+ const TCHAR* name = buffer;
54	54	while (*name != '\0') {
55		- if (strncmp(name, section, section_len) == 0) {
	55	+ if (_tcsncmp(name, section, section_len) == 0) {
56	56	if (name[section_len] == '\\') {
57	57	int i;
58	58	name += section_len + 1;

		@@ -59,8 +59,10 @@
59	59	for (i = 0; name[i] != '\0'; i++) {
60	60	if (name[i] == '\\')
61	61	break;
	62	+#if !defined(UNICODE)
62	63	if (String::isLeadByte(name[i]))
63	64	i++;
	65	+#endif
64	66	}
65	67	table.put(String(name, i), 1);
66	68	}

		@@ -84,10 +86,10 @@
84	86	friend class EnumKeyNames;
85	87	class EnumValueNames : public Enumeration<String> {
86	88	private:
87		- char* buffer;
88		- mutable char* p;
	89	+ TCHAR* buffer;
	90	+ mutable TCHAR* p;
89	91	public:
90		- EnumValueNames(const char* filename, const char* section) {
	92	+ EnumValueNames(const TCHAR* filename, const TCHAR* section) {
91	93	size_t size = 256;
92	94	while ((buffer = getValueNames(filename, section, size)) == NULL)
93	95	size += 256;

		@@ -140,23 +142,23 @@
140	142	return ((IniFile*) ini)->deleteValue(name);
141	143	}
142	144	};
143		- static char* getSectionNames(const char* filename, size_t size) {
144		- char* buffer = new char[size];
	145	+ static TCHAR* getSectionNames(const TCHAR* filename, size_t size) {
	146	+ TCHAR* buffer = new TCHAR[size];
145	147	if (::GetPrivateProfileSectionNames(buffer, size, filename) < size - 2)
146	148	return buffer;
147	149	delete[] buffer;
148	150	return NULL;
149	151	}
150		- static char* getValueNames(const char* filename, const char* section, size_t size) {
151		- static const char null = '\0';
152		- char* buffer = new char[size];
	152	+ static TCHAR* getValueNames(const TCHAR* filename, const TCHAR* section, size_t size) {
	153	+ static const TCHAR null = '\0';
	154	+ TCHAR* buffer = new TCHAR[size];
153	155	if (::GetPrivateProfileString(section, NULL, &null, buffer, size, filename) < size - 2)
154	156	return buffer;
155	157	delete[] buffer;
156	158	return NULL;
157	159	}
158		- static String getString(const char* filename, const char* section, const char* name, bool& exists, size_t size) {
159		- char* buffer = (char*) alloca(size);
	160	+ static String getString(const TCHAR* filename, const TCHAR* section, const TCHAR* name, bool& exists, size_t size) {
	161	+ TCHAR* buffer = (TCHAR) alloca(sizeof(TCHAR) size);
160	162	size_t len = ::GetPrivateProfileString(section, name, INVALID(), buffer, size, filename);
161	163	if (len < size - 2) {
162	164	// 改行を含んだ文字列はiniファイルからは取得できないので取得失敗したことが分かる

		@@ -170,24 +172,24 @@
170	172	exists = true;
171	173	return NULL;
172	174	}
173		- static String generateSectionName(const char* parentSection, const char* subkeyName) {
	175	+ static String generateSectionName(const TCHAR* parentSection, const TCHAR* subkeyName) {
174	176	StringBuffer buffer = parentSection;
175	177	buffer.append('\\');
176	178	buffer.append(subkeyName);
177	179	return buffer.toString();
178	180	}
179		- static bool deleteAllSubsection(const char* filename, const char* section, const char* subkey) {
	181	+ static bool deleteAllSubsection(const TCHAR* filename, const TCHAR* section, const TCHAR* subkey) {
180	182	String keyname = generateSectionName(section, subkey);
181	183	int keyname_len = keyname.length();
182	184
183		- char* buffer;
	185	+ TCHAR* buffer;
184	186	size_t size = 256;
185	187	while ((buffer = getSectionNames(filename, size)) == NULL)
186	188	size += 256;
187		- const char* name = buffer;
	189	+ const TCHAR* name = buffer;
188	190	bool succeeded = true;
189	191	while (*name != '\0') {
190		- if (strncmp(name, keyname, keyname_len) == 0) {
	192	+ if (_tcsncmp(name, keyname, keyname_len) == 0) {
191	193	if (name[keyname_len] == '\0' \|\| name[keyname_len] == '\\') {
192	194	if (!::WritePrivateProfileString(name, NULL, NULL, filename)) {
193	195	succeeded = false;

		@@ -209,19 +211,19 @@
209	211	}
210	212	IniFile(String filename, String section):filename(filename), section(section) {
211	213	}
212		- IniFile(const IniFile& parent, const char* subkeyName):filename(parent.filename), section(generateSectionName(parent.section, subkeyName)) {
	214	+ IniFile(const IniFile& parent, const TCHAR* subkeyName):filename(parent.filename), section(generateSectionName(parent.section, subkeyName)) {
213	215	}
214	216
215	217	bool isOpened()const {
216	218	return filename != NULL && section != NULL;
217	219	}
218		- long getInteger(const char* name, long defaultValue = 0)const {
	220	+ long getInteger(const TCHAR* name, long defaultValue = 0)const {
219	221	return filename != NULL && section != NULL ? ::GetPrivateProfileInt(section, name, defaultValue, filename) : defaultValue;
220	222	}
221		- String getString(const char* name)const {
	223	+ String getString(const TCHAR* name)const {
222	224	return getString(name, NULL);
223	225	}
224		- String getString(const char* name, String defaultValue)const {
	226	+ String getString(const TCHAR* name, String defaultValue)const {
225	227	if (filename != NULL && section != NULL && name != NULL) {
226	228	size_t size = 256;
227	229	String string;

		@@ -233,7 +235,7 @@
233	235	}
234	236	return defaultValue;
235	237	}
236		- bool getBoolean(const char* name, bool defaultValue = false)const {
	238	+ bool getBoolean(const TCHAR* name, bool defaultValue = false)const {
237	239	String string = getString(name);
238	240	if (string != NULL) {
239	241	if (string == YES())

		@@ -244,10 +246,10 @@
244	246	return defaultValue;
245	247	}
246	248
247		- bool setInteger(const char* name, long value) {
	249	+ bool setInteger(const TCHAR* name, long value) {
248	250	return setString(name, Integer::toString(value));
249	251	}
250		- bool setString(const char* name, String value) {
	252	+ bool setString(const TCHAR* name, String value) {
251	253	if (filename != NULL && section != NULL && name != NULL) {
252	254	// NULLでなければエスケープしてから""で括る
253	255	if (value != NULL) {

		@@ -262,30 +264,30 @@
262	264	}
263	265	return false;
264	266	}
265		- bool setBoolean(const char* name, bool value) {
	267	+ bool setBoolean(const TCHAR* name, bool value) {
266	268	return setString(name, value ? YES() : NO());
267	269	}
268	270
269		- bool existsValue(const char* name) {
270		- char buffer[3];
	271	+ bool existsValue(const TCHAR* name) {
	272	+ TCHAR buffer[3];
271	273	::GetPrivateProfileString(section, name, INVALID(), buffer, countof(buffer), filename);
272	274	return buffer[0] != '\n';
273	275	}
274		- bool deleteKey(const char* name) {
	276	+ bool deleteKey(const TCHAR* name) {
275	277	return filename != NULL && section != NULL && name != NULL && deleteAllSubsection(filename, section, name);
276	278	}
277		- bool deleteValue(const char* name) {
	279	+ bool deleteValue(const TCHAR* name) {
278	280	return filename != NULL && section != NULL && name != NULL
279	281	&& ::WritePrivateProfileString(section, name, NULL, filename) != FALSE;
280	282	}
281	283
282		- bool open(String filename, String section) {
	284	+ bool open(String _filename, String _section) {
283	285	close();
284		- this->filename = filename;
285		- this->section = section;
	286	+ filename = _filename;
	287	+ section = _section;
286	288	return isOpened();
287	289	}
288		- bool open(const IniFile& parent, const char* subkeyName) {
	290	+ bool open(const IniFile& parent, const TCHAR* subkeyName) {
289	291	close();
290	292	filename = parent.filename;
291	293	section = generateSectionName(parent.section, subkeyName);

--- branches/cmake/TTProxy/YCL/include/YCL/Integer.h (revision 7326)

+++ branches/cmake/TTProxy/YCL/include/YCL/Integer.h (revision 7327)

		@@ -46,8 +46,8 @@
46	46	static String toString(unsigned long value, int base, bool negative) {
47	47	if (base < 2 \|\| base > 36)
48	48	return NULL;
49		- char buffer[64];
50		- char* p = buffer + countof(buffer);
	49	+ TCHAR buffer[64];
	50	+ TCHAR* p = buffer + countof(buffer);
51	51	*--p = '\0';
52	52	if (value == 0) {
53	53	*--p = '0';

--- branches/cmake/TTProxy/YCL/include/YCL/Resource.h (revision 7326)

+++ branches/cmake/TTProxy/YCL/include/YCL/Resource.h (revision 7327)

		@@ -10,8 +10,8 @@
10	10	#endif // _MSC_VER >= 1000
11	11
12	12	#include <YCL/common.h>
13		-
14	13	#include <YCL/String.h>
	14	+#include "codeconv.h"
15	15
16	16	namespace yebisuya {
17	17

		@@ -18,7 +18,7 @@
18	18	class Resource {
19	19	public:
20	20	static String loadString(HINSTANCE instance, UINT id, int bufsize) {
21		- char* buffer = (char*) alloca(bufsize);
	21	+ TCHAR* buffer = (TCHAR) alloca(sizeof(TCHAR) bufsize);
22	22	int length = loadString(instance, id, buffer, bufsize);
23	23	if (length >= bufsize - 1)
24	24	return NULL;

		@@ -28,10 +28,10 @@
28	28	}
29	29
30	30	public:
31		- static int loadString(UINT id, char* buffer, int bufsize) {
	31	+ static int loadString(UINT id, TCHAR* buffer, int bufsize) {
32	32	return loadString(GetInstanceHandle(), id, buffer, bufsize);
33	33	}
34		- static int loadString(HINSTANCE instance, UINT id, char* buffer, int bufsize) {
	34	+ static int loadString(HINSTANCE instance, UINT id, TCHAR* buffer, int bufsize) {
35	35	return LoadString(instance, id, buffer, bufsize);
36	36	}
37	37	static String loadString(int id) {

		@@ -54,10 +54,10 @@
54	54	return loadIcon(GetInstanceHandle(), id);
55	55	}
56	56	static HICON loadIcon(HINSTANCE instance, int id) {
57		- return loadIcon(instance, MAKEINTRESOURCE(id));
	57	+ return loadIcon(instance, MAKEINTRESOURCEA(id));
58	58	}
59	59	static HICON loadIcon(HINSTANCE instance, const char* id) {
60		- return ::LoadIcon(instance, id);
	60	+ return ::LoadIcon(instance, (tc)id);
61	61	}
62	62
63	63	static HICON loadIcon(int id, int cx, int cy) {

		@@ -67,7 +67,7 @@
67	67	return loadIcon(GetInstanceHandle(), id, cx, cy);
68	68	}
69	69	static HICON loadIcon(HINSTANCE instance, int id, int cx, int cy) {
70		- return loadIcon(instance, MAKEINTRESOURCE(id), cx, cy);
	70	+ return loadIcon(instance, MAKEINTRESOURCEA(id), cx, cy);
71	71	}
72	72	static HICON loadIcon(HINSTANCE instance, const char* id, int cx, int cy) {
73	73	return loadIcon(instance, id, cx, cy, LR_DEFAULTCOLOR \| LR_SHARED);

		@@ -79,10 +79,10 @@
79	79	return loadIcon(GetInstanceHandle(), id, cx, cy, flags);
80	80	}
81	81	static HICON loadIcon(HINSTANCE instance, int id, int cx, int cy, int flags) {
82		- return loadIcon(instance, MAKEINTRESOURCE(id), cx, cy, flags);
	82	+ return loadIcon(instance, MAKEINTRESOURCEA(id), cx, cy, flags);
83	83	}
84	84	static HICON loadIcon(HINSTANCE instance, const char* id, int cx, int cy, int flags) {
85		- return (HICON) ::LoadImage(instance, id, IMAGE_ICON, cx, cy, flags);
	85	+ return (HICON) ::LoadImage(instance, (tc)id, IMAGE_ICON, cx, cy, flags);
86	86	}
87	87
88	88	static HCURSOR loadCursor(int id) {

		@@ -92,10 +92,10 @@
92	92	return loadCursor(GetInstanceHandle(), id);
93	93	}
94	94	static HCURSOR loadCursor(HINSTANCE instance, int id) {
95		- return loadCursor(instance, MAKEINTRESOURCE(id));
	95	+ return loadCursor(instance, MAKEINTRESOURCEA(id));
96	96	}
97	97	static HCURSOR loadCursor(HINSTANCE instance, const char* id) {
98		- return ::LoadCursor(instance, id);
	98	+ return ::LoadCursor(instance, (tc)id);
99	99	}
100	100
101	101	static HCURSOR loadCursor(int id, int cx, int cy) {

		@@ -105,7 +105,7 @@
105	105	return loadCursor(GetInstanceHandle(), id, cx, cy);
106	106	}
107	107	static HCURSOR loadCursor(HINSTANCE instance, int id, int cx, int cy) {
108		- return loadCursor(instance, MAKEINTRESOURCE(id), cx, cy);
	108	+ return loadCursor(instance, MAKEINTRESOURCEA(id), cx, cy);
109	109	}
110	110	static HCURSOR loadCursor(HINSTANCE instance, const char* id, int cx, int cy) {
111	111	return loadCursor(instance, id, cx, cy, LR_DEFAULTCOLOR \| LR_SHARED);

		@@ -117,10 +117,10 @@
117	117	return loadCursor(GetInstanceHandle(), id, cx, cy, flags);
118	118	}
119	119	static HCURSOR loadCursor(HINSTANCE instance, int id, int cx, int cy, int flags) {
120		- return loadCursor(instance, MAKEINTRESOURCE(id), cx, cy, flags);
	120	+ return loadCursor(instance, MAKEINTRESOURCEA(id), cx, cy, flags);
121	121	}
122	122	static HCURSOR loadCursor(HINSTANCE instance, const char* id, int cx, int cy, int flags) {
123		- return (HCURSOR) ::LoadImage(instance, id, IMAGE_CURSOR, cx, cy, flags);
	123	+ return (HCURSOR) ::LoadImage(instance, (tc)id, IMAGE_CURSOR, cx, cy, flags);
124	124	}
125	125
126	126	static HMENU loadMenu(int id) {

		@@ -130,10 +130,10 @@
130	130	return loadMenu(GetInstanceHandle(), id);
131	131	}
132	132	static HMENU loadMenu(HINSTANCE instance, int id) {
133		- return loadMenu(instance, MAKEINTRESOURCE(id));
	133	+ return loadMenu(instance, MAKEINTRESOURCEA(id));
134	134	}
135	135	static HMENU loadMenu(HINSTANCE instance, const char* id) {
136		- return ::LoadMenu(instance, id);
	136	+ return ::LoadMenu(instance, (tc)id);
137	137	}
138	138	};
139	139

--- branches/cmake/TTProxy/YCL/include/YCL/String.h (revision 7326)

+++ branches/cmake/TTProxy/YCL/include/YCL/String.h (revision 7327)

		@@ -12,6 +12,7 @@
12	12	#include <YCL/common.h>
13	13
14	14	#include <string.h>
	15	+#include <tchar.h>
15	16
16	17	namespace yebisuya {
17	18

		@@ -21,7 +22,7 @@
21	22	// 文字列を格納するバッファ。
22	23	// 文字列の前には参照カウンタを持ち、
23	24	// 代入や破棄の際にはそこを変更する。
24		- const char* string;
	25	+ const TCHAR* string;
25	26
26	27	// utilities
27	28	// 文字列を格納するバッファを作成する。

		@@ -31,10 +32,10 @@
31	32	// length 文字列の長さ。
32	33	// 返値:
33	34	// 作成したバッファの文字列部のアドレス。
34		- static char* createBuffer(size_t length) {
35		- size_t* count = (size_t) new unsigned char[sizeof (size_t) + sizeof (char) (length + 1)];
	35	+ static TCHAR* createBuffer(size_t length) {
	36	+ size_t* count = (size_t) new TCHAR[sizeof (size_t) + sizeof (TCHAR) (length + 1)];
36	37	*count = 0;
37		- return (char*) (count + 1);
	38	+ return (TCHAR*) (count + 1);
38	39	}
39	40	// 文字列を格納したバッファを作成する。
40	41	// 引数:

		@@ -41,8 +42,8 @@
41	42	// source 格納する文字列。
42	43	// 返値:
43	44	// 作成したバッファの文字列部のアドレス。
44		- static const char* create(const char* source) {
45		- return source != NULL ? create(source, strlen(source)) : NULL;
	45	+ static const TCHAR* create(const TCHAR* source) {
	46	+ return source != NULL ? create(source, _tcslen(source)) : NULL;
46	47	}
47	48	// 文字列を格納したバッファを作成する。
48	49	// 引数:

		@@ -50,10 +51,10 @@
50	51	// length 文字列の長さ。
51	52	// 返値:
52	53	// 作成したバッファの文字列部のアドレス。
53		- static const char* create(const char* source, size_t length) {
	54	+ static const TCHAR* create(const TCHAR* source, size_t length) {
54	55	if (source != NULL) {
55		- char* buffer = createBuffer(length);
56		- memcpy(buffer, source, length);
	56	+ TCHAR* buffer = createBuffer(length);
	57	+ memcpy(buffer, source, sizeof(TCHAR) * length);
57	58	buffer[length] = '\0';
58	59	return buffer;
59	60	}

		@@ -65,12 +66,12 @@
65	66	// str2 連結する文字列(後)。
66	67	// 返値:
67	68	// 作成したバッファの文字列部のアドレス。
68		- static const char* concat(const char* str1, const char* str2) {
69		- size_t len1 = strlen(str1);
70		- size_t len2 = strlen(str2);
71		- char* buffer = createBuffer(len1 + len2);
72		- memcpy(buffer, str1, len1);
73		- memcpy(buffer + len1, str2, len2);
	69	+ static const TCHAR* concat(const TCHAR* str1, const TCHAR* str2) {
	70	+ size_t len1 = _tcslen(str1);
	71	+ size_t len2 = _tcslen(str2);
	72	+ TCHAR* buffer = createBuffer(len1 + len2);
	73	+ memcpy(buffer, str1, sizeof(TCHAR) * len1);
	74	+ memcpy(buffer + len1, str2, sizeof(TCHAR) * len2);
74	75	buffer[len1 + len2] = '\0';
75	76	return buffer;
76	77	}

		@@ -80,7 +81,7 @@
80	81	if (string != NULL) {
81	82	size_t* count = (size_t*) string - 1;
82	83	if (--*count == 0)
83		- delete[] (unsigned char*) count;
	84	+ delete[] (TCHAR*) count;
84	85	}
85	86	}
86	87	// 参照カウンタを増やす。

		@@ -95,7 +96,7 @@
95	96	// 新しいバッファの参照カウンタを増やす。
96	97	// 引数:
97	98	// source 置き換える新しいバッファ。
98		- void set(const char* source) {
	99	+ void set(const TCHAR* source) {
99	100	if (string != source) {
100	101	release();
101	102	string = source;

		@@ -111,7 +112,7 @@
111	112	// 元の文字列を指定するコンストラクタ。
112	113	// 引数:
113	114	// source 元の文字列。
114		- String(const char* source):string(NULL) {
	115	+ String(const TCHAR* source):string(NULL) {
115	116	set(create(source));
116	117	}
117	118	// 元の文字列を長さ付きで指定するコンストラクタ。

		@@ -118,7 +119,7 @@
118	119	// 引数:
119	120	// source 元の文字列。
120	121	// length 文字列の長さ。
121		- String(const char* source, size_t length):string(NULL) {
	122	+ String(const TCHAR* source, size_t length):string(NULL) {
122	123	set(create(source, length));
123	124	}
124	125	// コピーコンストラクタ。

		@@ -131,7 +132,7 @@
131	132	// 引数:
132	133	// str1 前になる文字列。
133	134	// str2 後になる文字列。
134		- String(const char* str1, const char* str2):string(NULL) {
	135	+ String(const TCHAR* str1, const TCHAR* str2):string(NULL) {
135	136	set(concat(str1, str2));
136	137	}
137	138	// 二つの文字列を連結するコンストラクタ。

		@@ -138,7 +139,7 @@
138	139	// 引数:
139	140	// str1 前になる文字列。
140	141	// str2 後になる文字列。
141		- String(const String& str1, const char* str2):string(NULL) {
	142	+ String(const String& str1, const TCHAR* str2):string(NULL) {
142	143	set(*str2 != '\0' ? concat(str1.string, str2) : str1.string);
143	144	}
144	145	// destructor

		@@ -153,7 +154,7 @@
153	154	// source 連結する文字列。
154	155	// 返値:
155	156	// 連結された文字列。
156		- String concat(const char* source)const {
	157	+ String concat(const TCHAR* source)const {
157	158	return String(*this, source);
158	159	}
159	160	// 文字列との比較を行う。

		@@ -162,12 +163,12 @@
162	163	// str 比較する文字列。
163	164	// 返値:
164	165	// 等しければ0、strの方が大きければ負、小さければ正。
165		- int compareTo(const char* str)const {
	166	+ int compareTo(const TCHAR* str)const {
166	167	if (str == NULL)
167	168	return string == NULL ? 0 : 1;
168	169	else if (string == NULL)
169	170	return -1;
170		- return strcmp(string, str);
	171	+ return _tcscmp(string, str);
171	172	}
172	173	// 文字列との比較を大文字小文字の区別なしで行う。
173	174	// NULLとも比較できる。

		@@ -175,12 +176,12 @@
175	176	// str 比較する文字列。
176	177	// 返値:
177	178	// 等しければ0、strの方が大きければ負、小さければ正。
178		- int compareToIgnoreCase(const char* str)const {
	179	+ int compareToIgnoreCase(const TCHAR* str)const {
179	180	if (str == NULL)
180	181	return string == NULL ? 0 : 1;
181	182	else if (string == NULL)
182	183	return -1;
183		- return _stricmp(string, str);
	184	+ return _tcsicmp(string, str);
184	185	}
185	186	// 文字列との比較を行う。
186	187	// NULLとも比較できる。

		@@ -188,7 +189,7 @@
188	189	// str 比較する文字列。
189	190	// 返値:
190	191	// 等しければ真。
191		- bool equals(const char* str)const {
	192	+ bool equals(const TCHAR* str)const {
192	193	return compareTo(str) == 0;
193	194	}
194	195	// 文字列との比較を大文字小文字の区別なしで行う。

		@@ -197,7 +198,7 @@
197	198	// str 比較する文字列。
198	199	// 返値:
199	200	// 等しければ真。
200		- bool equalsIgnoreCase(const char* str)const {
	201	+ bool equalsIgnoreCase(const TCHAR* str)const {
201	202	return compareToIgnoreCase(str) == 0;
202	203	}
203	204	// 指定された文字列で始まっているかどうかを判定する。

		@@ -205,7 +206,7 @@
205	206	// str 比較する文字列。
206	207	// 返値:
207	208	// 指定された文字列で始まっていれば真。
208		- bool startsWith(const char* str)const {
	209	+ bool startsWith(const TCHAR* str)const {
209	210	return startsWith(str, 0);
210	211	}
211	212	// 指定の位置から指定された文字列で始まっているかどうかを判定する。

		@@ -213,8 +214,8 @@
213	214	// str 比較する文字列。
214	215	// 返値:
215	216	// 指定された文字列で始まっていれば真。
216		- bool startsWith(const char* str, int offset)const {
217		- return strncmp(string, str, strlen(str)) == 0;
	217	+ bool startsWith(const TCHAR* str, int offset)const {
	218	+ return _tcsncmp(string, str, _tcslen(str)) == 0;
218	219	}
219	220	// 指定された文字列で終わっているかどうかを判定する。
220	221	// 引数:

		@@ -221,13 +222,13 @@
221	222	// str 比較する文字列。
222	223	// 返値:
223	224	// 指定された文字列で終わっていれば真。
224		- //
225		- bool endsWith(const char* str)const {
226		- size_t str_length = strlen(str);
	225	+ //
	226	+ bool endsWith(const TCHAR* str)const {
	227	+ size_t str_length = _tcslen(str);
227	228	size_t string_length = length();
228	229	if (string_length < str_length)
229	230	return false;
230		- return strcmp(string + string_length - str_length, str) == 0;
	231	+ return _tcscmp(string + string_length - str_length, str) == 0;
231	232	}
232	233	// 指定の文字がどの位置にあるかを探す。
233	234	// 引数:

		@@ -234,7 +235,7 @@
234	235	// chr 探す文字。
235	236	// 返値:
236	237	// 文字の見つかったインデックス。見つからなければ-1。
237		- int indexOf(char chr)const {
	238	+ int indexOf(TCHAR chr)const {
238	239	return indexOf(chr, 0);
239	240	}
240	241	// 指定の文字がどの位置にあるかを指定の位置から探す。

		@@ -243,12 +244,10 @@
243	244	// from 探し始める位置。
244	245	// 返値:
245	246	// 文字の見つかったインデックス。見つからなければ-1。
246		- int indexOf(char chr, size_t from)const {
247		- if (from < 0)
248		- from = 0;
249		- else if (from >= length())
	247	+ int indexOf(TCHAR chr, size_t from)const {
	248	+ if (from >= length())
250	249	return -1;
251		- const char* found = strchr(string + from, chr);
	250	+ const TCHAR* found = _tcschr(string + from, chr);
252	251	if (found == NULL)
253	252	return -1;
254	253	return found - string;

		@@ -258,7 +257,7 @@
258	257	// str 探す文字列。
259	258	// 返値:
260	259	// 文字列の見つかったインデックス。見つからなければ-1。
261		- int indexOf(const char* str)const {
	260	+ int indexOf(const TCHAR* str)const {
262	261	return indexOf(str, 0);
263	262	}
264	263	// 指定の文字列がどの位置にあるかを指定の位置から探す。

		@@ -267,13 +266,11 @@
267	266	// from 探し始める位置。
268	267	// 返値:
269	268	// 文字列の見つかったインデックス。見つからなければ-1。
270		- //
271		- int indexOf(const char* str, size_t from)const {
272		- if (from < 0)
273		- from = 0;
274		- else if (from >= length())
	269	+ //
	270	+ int indexOf(const TCHAR* str, size_t from)const {
	271	+ if (from >= length())
275	272	return -1;
276		- const char* found = strstr(string + from, str);
	273	+ const TCHAR* found = _tcsstr(string + from, str);
277	274	if (found == NULL)
278	275	return -1;
279	276	return found - string;

		@@ -280,7 +277,7 @@
280	277	}
281	278	// 文字列の長さを返す。
282	279	size_t length()const {
283		- return strlen(string);
	280	+ return _tcslen(string);
284	281	}
285	282	// 指定の文字が最後に見つかる位置を取得する。
286	283	// 引数:

		@@ -287,7 +284,7 @@
287	284	// chr 探す文字。
288	285	// 返値:
289	286	// 文字の見つかったインデックス。見つからなければ-1。
290		- int lastIndexOf(char chr)const {
	287	+ int lastIndexOf(TCHAR chr)const {
291	288	return lastIndexOf(chr, (size_t) -1);
292	289	}
293	290	// 指定の文字が指定の位置よりも前で最後に見つかる位置を取得する。

		@@ -296,18 +293,20 @@
296	293	// from 探し始める位置。
297	294	// 返値:
298	295	// 文字の見つかったインデックス。見つからなければ-1。
299		- int lastIndexOf(char chr, size_t from)const {
	296	+ int lastIndexOf(TCHAR chr, size_t from)const {
300	297	size_t len = length();
301	298	if (from > len - 1)
302	299	from = len - 1;
303		- const char* s = string;
304		- const char* end = string + from;
305		- const char* found = NULL;
	300	+ const TCHAR* s = string;
	301	+ const TCHAR* end = string + from;
	302	+ const TCHAR* found = NULL;
306	303	while (*s != '0' && s <= end) {
307	304	if (*s == chr)
308	305	found = s;
	306	+#if !defined(UNICODE)
309	307	if (isLeadByte(*s))
310	308	s++;
	309	+#endif
311	310	s++;
312	311	}
313	312	return found != NULL ? found - string : -1;

		@@ -317,7 +316,7 @@
317	316	// str 探す文字列。
318	317	// 返値:
319	318	// 文字列の見つかったインデックス。見つからなければ-1。
320		- int lastIndexOf(const char* str)const {
	319	+ int lastIndexOf(const TCHAR* str)const {
321	320	return lastIndexOf(str, (size_t) -1);
322	321	}
323	322	// 指定の文字列が指定の位置よりも前で最後に見つかる位置を取得する。

		@@ -326,14 +325,14 @@
326	325	// from 探し始める位置。
327	326	// 返値:
328	327	// 文字列の見つかったインデックス。見つからなければ-1。
329		- int lastIndexOf(const char* str, size_t from)const {
	328	+ int lastIndexOf(const TCHAR* str, size_t from)const {
330	329	size_t len = length();
331		- size_t str_len = strlen(str);
	330	+ size_t str_len = _tcslen(str);
332	331	if (from > len - str_len)
333	332	from = len - str_len;
334		- const char* s = string + from;
	333	+ const TCHAR* s = string + from;
335	334	while (s >= string) {
336		- if (strncmp(s, str, str_len) == 0)
	335	+ if (_tcsncmp(s, str, str_len) == 0)
337	336	return s - string;
338	337	s--;
339	338	}

		@@ -361,8 +360,8 @@
361	360	// index 取り出す文字の位置。
362	361	// 返値:
363	362	// 指定の位置にある文字。
364		- char charAt(size_t index)const {
365		- return index >= 0 && index < length() ? string[index] : '\0';
	363	+ TCHAR TCHARAt(size_t index)const {
	364	+ return index < length() ? string[index] : '\0';
366	365	}
367	366	// 指定の文字を指定の文字に置き換えます。
368	367	// 引数:

		@@ -370,13 +369,16 @@
370	369	// newChr 置き換える文字。
371	370	// 返値:
372	371	// 置換後の文字列。
373		- String replace(char oldChr, char newChr)const {
	372	+ String replace(TCHAR oldChr, TCHAR newChr)const {
374	373	String result(string);
375		- char* s = (char*) result.string;
	374	+ TCHAR* s = (TCHAR*) result.string;
376	375	while (*s != '\0'){
	376	+#if !defined(UNICODE)
377	377	if (String::isLeadByte(*s))
378	378	s++;
379		- else if (*s == oldChr)
	379	+ else
	380	+#endif
	381	+ if (*s == oldChr)
380	382	*s = newChr;
381	383	s++;
382	384	}

		@@ -387,11 +389,14 @@
387	389	// 変換後の文字列。
388	390	String toLowerCase()const {
389	391	String result(string);
390		- char* s = (char*) result.string;
	392	+ TCHAR* s = (TCHAR*) result.string;
391	393	while (*s != '\0'){
	394	+#if !defined(UNICODE)
392	395	if (String::isLeadByte(*s))
393	396	s++;
394		- else if ('A' <= s && s <= 'Z')
	397	+ else
	398	+#endif
	399	+ if ('A' <= s && s <= 'Z')
395	400	*s += 'a' - 'A';
396	401	s++;
397	402	}

		@@ -402,12 +407,15 @@
402	407	// 変換後の文字列。
403	408	String toUpperCase()const {
404	409	String result(string);
405		- char* s = (char*) result.string;
	410	+ TCHAR* s = (TCHAR*) result.string;
406	411	while (*s != '\0'){
	412	+#if !defined(UNICODE)
407	413	if (String::isLeadByte(*s))
408	414	s++;
409		- else if ('a' <= s && s <= 'z')
410		- *s += 'A' - 'a';
	415	+ else
	416	+#endif
	417	+ if (_T('a') <= s && s <= _T('z'))
	418	+ *s += _T('A') - _T('a');
411	419	s++;
412	420	}
413	421	return result;

		@@ -416,12 +424,12 @@
416	424	// 返値:
417	425	// 削除後の文字列。
418	426	String trim()const {
419		- const char* s = string;
420		- while (s != '\0' && (unsigned char) s <= ' ')
	427	+ const TCHAR* s = string;
	428	+ while (s != '\0' && (TCHAR) s <= _T(' '))
421	429	s++;
422		- const char* start = s;
	430	+ const TCHAR* start = s;
423	431	s = string + length();
424		- while (s > start && (s != '\0' && (unsigned char) s <= ' '))
	432	+ while (s > start && (s != '\0' && (TCHAR) s <= _T(' ')))
425	433	s--;
426	434	return String(start, s - start);
427	435	}

		@@ -428,19 +436,19 @@
428	436
429	437	// operators
430	438
431		- // const char*へのキャスト演算子
	439	+ // const TCHAR*へのキャスト演算子
432	440	// 返値:
433	441	// 文字列へのアドレス。
434		- operator const char*()const {
	442	+ operator const TCHAR*()const {
435	443	return string;
436	444	}
437		- // char配列のように扱うための[]演算子。
	445	+ // TCHAR配列のように扱うための[]演算子。
438	446	// 引数:
439	447	// index 取得する文字のインデックス。
440	448	// 返値:
441	449	// 指定のインデックスにある文字。
442		- char operator[](size_t index)const {
443		- return charAt(index);
	450	+ TCHAR operator[](size_t index)const {
	451	+ return TCHARAt(index);
444	452	}
445	453	// 文字列を連結するための+演算子。
446	454	// 引数:

		@@ -447,7 +455,7 @@
447	455	// source 連結する文字列。
448	456	// 返値:
449	457	// 連結した文字列。
450		- String operator+(const char* source)const {
	458	+ String operator+(const TCHAR* source)const {
451	459	return String(string, source);
452	460	}
453	461	// 文字列を連結するための+演算子。

		@@ -464,7 +472,7 @@
464	472	// str2 連結する文字列(後)。
465	473	// 返値:
466	474	// 連結した文字列。
467		- friend String operator+(const char* str1, const String& str2) {
	475	+ friend String operator+(const TCHAR* str1, const String& str2) {
468	476	return *str1 != '\0' ? String(str1, str2.string) : str2;
469	477	}
470	478	// 代入演算子。

		@@ -472,7 +480,7 @@
472	480	// source 代入する文字列。
473	481	// 返値:
474	482	// 代入結果。
475		- String& operator=(const char* source) {
	483	+ String& operator=(const TCHAR* source) {
476	484	set(create(source));
477	485	return *this;
478	486	}

		@@ -490,7 +498,7 @@
490	498	// source 連結する文字列。
491	499	// 返値:
492	500	// 連結結果。
493		- String& operator+=(const char* source) {
	501	+ String& operator+=(const TCHAR* source) {
494	502	if (*source != '\0')
495	503	set(concat(string, source));
496	504	return *this;

		@@ -508,7 +516,7 @@
508	516	// str 比較対象の文字列。
509	517	// 返値:
510	518	// strの方が等しければ真。
511		- bool operator==(const char* str)const {
	519	+ bool operator==(const TCHAR* str)const {
512	520	return compareTo(str) == 0;
513	521	}
514	522	// 比較演算子。

		@@ -517,7 +525,7 @@
517	525	// str2 比較する文字列。
518	526	// 返値:
519	527	// str1よりstr2の方が等しければ真。
520		- friend bool operator==(const char* str1, const String& str2) {
	528	+ friend bool operator==(const TCHAR* str1, const String& str2) {
521	529	return str2.compareTo(str1) == 0;
522	530	}
523	531	// 比較演算子。

		@@ -533,7 +541,7 @@
533	541	// str 比較対象の文字列。
534	542	// 返値:
535	543	// strの方が等しくなければ真。
536		- bool operator!=(const char* str)const {
	544	+ bool operator!=(const TCHAR* str)const {
537	545	return compareTo(str) != 0;
538	546	}
539	547	// 比較演算子。

		@@ -542,7 +550,7 @@
542	550	// str2 比較する文字列。
543	551	// 返値:
544	552	// str1よりstr2の方が等しくなければ真。
545		- friend bool operator!=(const char* str1, const String& str2) {
	553	+ friend bool operator!=(const TCHAR* str1, const String& str2) {
546	554	return str2.compareTo(str1) != 0;
547	555	}
548	556	// 比較演算子。

		@@ -558,7 +566,7 @@
558	566	// str 比較対象の文字列。
559	567	// 返値:
560	568	// strの方が大きければ真。
561		- bool operator<(const char* str)const {
	569	+ bool operator<(const TCHAR* str)const {
562	570	return compareTo(str) < 0;
563	571	}
564	572	// 比較演算子。

		@@ -567,7 +575,7 @@
567	575	// str2 比較する文字列。
568	576	// 返値:
569	577	// str1よりstr2の方が大きければ真。
570		- friend bool operator<(const char* str1, const String& str2) {
	578	+ friend bool operator<(const TCHAR* str1, const String& str2) {
571	579	return str2.compareTo(str1) > 0;
572	580	}
573	581	// 比較演算子。

		@@ -583,7 +591,7 @@
583	591	// str 比較対象の文字列。
584	592	// 返値:
585	593	// strの方が大きいか等しければ真。
586		- bool operator<=(const char* str)const {
	594	+ bool operator<=(const TCHAR* str)const {
587	595	return compareTo(str) <= 0;
588	596	}
589	597	// 比較演算子。

		@@ -592,7 +600,7 @@
592	600	// str2 比較する文字列。
593	601	// 返値:
594	602	// str1よりstr2の方が大きいか等しければ真。
595		- friend bool operator<=(const char* str1, const String& str2) {
	603	+ friend bool operator<=(const TCHAR* str1, const String& str2) {
596	604	return str2.compareTo(str1) >= 0;
597	605	}
598	606	// 比較演算子。

		@@ -608,7 +616,7 @@
608	616	// str 比較対象の文字列。
609	617	// 返値:
610	618	// strの方が小さければ真。
611		- bool operator>(const char* str)const {
	619	+ bool operator>(const TCHAR* str)const {
612	620	return compareTo(str) > 0;
613	621	}
614	622	// 比較演算子。

		@@ -617,7 +625,7 @@
617	625	// str2 比較する文字列。
618	626	// 返値:
619	627	// str1よりstr2の方が小さければ真。
620		- friend bool operator>(const char* str1, const String& str2) {
	628	+ friend bool operator>(const TCHAR* str1, const String& str2) {
621	629	return str2.compareTo(str1) < 0;
622	630	}
623	631	// 比較演算子。

		@@ -633,7 +641,7 @@
633	641	// str 比較対象の文字列。
634	642	// 返値:
635	643	// strの方が小さいか等しければ真。
636		- bool operator>=(const char* str)const {
	644	+ bool operator>=(const TCHAR* str)const {
637	645	return compareTo(str) >= 0;
638	646	}
639	647	// 比較演算子。

		@@ -642,7 +650,7 @@
642	650	// str2 比較する文字列。
643	651	// 返値:
644	652	// str1よりstr2の方が小さいか等しければ真。
645		- friend bool operator>=(const char* str1, const String& str2) {
	653	+ friend bool operator>=(const TCHAR* str1, const String& str2) {
646	654	return str2.compareTo(str1) <= 0;
647	655	}
648	656

		@@ -653,7 +661,8 @@
653	661	// 判定するバイト。
654	662	// 返値:
655	663	// 2バイト文字の最初の1バイトであれば真。
656		- static bool isLeadByte(char ch) {
	664	+#if !defined(UNICODE)
	665	+ static bool isLeadByte(TCHAR ch) {
657	666	#ifdef _INC_WINDOWS
658	667	return ::IsDBCSLeadByte(ch) != 0;
659	668	#else

		@@ -660,6 +669,7 @@
660	669	return (ch & 0x80) != 0;
661	670	#endif
662	671	}
	672	+#endif
663	673	};
664	674
665	675	}

--- branches/cmake/TTProxy/YCL/include/YCL/StringBuffer.h (revision 7326)

+++ branches/cmake/TTProxy/YCL/include/YCL/StringBuffer.h (revision 7327)

		@@ -14,6 +14,7 @@
14	14	#include <YCL/String.h>
15	15
16	16	#include <malloc.h>
	17	+#include <tchar.h>
17	18
18	19	namespace yebisuya {
19	20

		@@ -21,7 +22,7 @@
21	22	class StringBuffer {
22	23	private:
23	24	// 文字列を格納するバッファ。
24		- char* buffer;
	25	+ TCHAR* buffer;
25	26	// 現在有効な文字列の長さ。
26	27	size_t validLength;
27	28	// バッファの大きさ。

		@@ -35,7 +36,7 @@
35	36	// source 初期文字列。
36	37	// length 初期文字列の長さ。
37	38	// capacity バッファの初期サイズ。
38		- void init(const char* source, size_t length, size_t capacity) {
	39	+ void init(const TCHAR* source, size_t length, size_t capacity) {
39	40	if ((capacity != 0 \|\| length != 0) && capacity < length + INIT_CAPACITY)
40	41	capacity = length + INIT_CAPACITY;
41	42	validLength = length;

		@@ -43,10 +44,10 @@
43	44	if (bufferSize == 0) {
44	45	buffer = NULL;
45	46	}else{
46		- buffer = new char[bufferSize];
	47	+ buffer = new TCHAR[bufferSize];
47	48	}
48		- memcpy(buffer, source, validLength);
49		- memset(buffer + validLength, '\0', bufferSize - validLength);
	49	+ memcpy(buffer, source, sizeof(TCHAR) * validLength);
	50	+ memset(buffer + validLength, '\0', sizeof(TCHAR) * (bufferSize - validLength));
50	51	}
51	52	public:
52	53	// デフォルトコンストラクタ。

		@@ -62,8 +63,8 @@
62	63	// バッファの初期文字列を指定するコンストラクタ。
63	64	// 引数:
64	65	// source 初期文字列。
65		- StringBuffer(const char* source) {
66		- init(source, strlen(source), 0);
	66	+ StringBuffer(const TCHAR* source) {
	67	+ init(source, _tcslen(source), 0);
67	68	}
68	69	// コピーコンストラクタ。
69	70	// 引数:

		@@ -93,7 +94,7 @@
93	94	// newLength 調節する長さ。
94	95	void ensureCapacity(size_t newLength) {
95	96	if (bufferSize < newLength) {
96		- char* oldBuffer = buffer;
	97	+ TCHAR* oldBuffer = buffer;
97	98	init(oldBuffer, validLength, newLength + INIT_CAPACITY);
98	99	delete[] oldBuffer;
99	100	}

		@@ -111,8 +112,8 @@
111	112	// index 文字の位置。
112	113	// 返値:
113	114	// 指定の位置の文字。
114		- char charAt(size_t index)const {
115		- return index >= 0 && index < validLength ? buffer[index] : '\0';
	115	+ TCHAR charAt(size_t index)const {
	116	+ return index < validLength ? buffer[index] : '\0';
116	117	}
117	118	// 指定の位置の文字を取得する。
118	119	// 引数:

		@@ -119,10 +120,8 @@
119	120	// index 文字の位置。
120	121	// 返値:
121	122	// 指定の位置の文字の参照。
122		- char& charAt(size_t index) {
123		- if (index < 0) {
124		- index = 0;
125		- }else if (index >= validLength) {
	123	+ TCHAR& charAt(size_t index) {
	124	+ if (index >= validLength) {
126	125	ensureCapacity(validLength + 1);
127	126	index = validLength++;
128	127	}

		@@ -132,7 +131,7 @@
132	131	// 引数:
133	132	// index 変更する文字の位置。
134	133	// chr 変更する文字。
135		- void setCharAt(int index, char chr) {
	134	+ void setCharAt(int index, TCHAR chr) {
136	135	charAt(index) = chr;
137	136	}
138	137	// 文字を追加する。

		@@ -140,7 +139,7 @@
140	139	// chr 追加する文字。
141	140	// 返値:
142	141	// 追加結果。
143		- StringBuffer& append(char chr) {
	142	+ StringBuffer& append(TCHAR chr) {
144	143	charAt(validLength) = chr;
145	144	return *this;
146	145	}

		@@ -149,8 +148,8 @@
149	148	// source 追加する文字列。
150	149	// 返値:
151	150	// 追加結果。
152		- StringBuffer& append(const char* source) {
153		- return append(source, strlen(source));
	151	+ StringBuffer& append(const TCHAR* source) {
	152	+ return append(source, _tcslen(source));
154	153	}
155	154	// 文字列を追加する。
156	155	// 引数:

		@@ -158,10 +157,10 @@
158	157	// length 追加する文字列の長さ。
159	158	// 返値:
160	159	// 追加結果。
161		- StringBuffer& append(const char* source, size_t length) {
	160	+ StringBuffer& append(const TCHAR* source, size_t length) {
162	161	size_t oldLength = validLength;
163	162	ensureCapacity(validLength + length);
164		- memcpy(buffer + oldLength, source, length);
	163	+ memcpy(buffer + oldLength, source, sizeof(TCHAR) * length);
165	164	validLength += length;
166	165	return *this;
167	166	}

		@@ -184,7 +183,7 @@
184	183	start = 0;
185	184	if (start < end) {
186	185	if (end < validLength){
187		- memcpy(buffer + start, buffer + end, validLength - end);
	186	+ memcpy(buffer + start, buffer + end, sizeof(TCHAR) * (validLength - end));
188	187	validLength -= end - start;
189	188	}else{
190	189	validLength = start;

		@@ -199,17 +198,15 @@
199	198	// source 置換する文字列。
200	199	// 返値:
201	200	// 置換結果。
202		- StringBuffer& replace(size_t start, size_t end, const char* source) {
203		- if (start < 0)
204		- start = 0;
	201	+ StringBuffer& replace(size_t start, size_t end, const TCHAR* source) {
205	202	if (end > validLength)
206	203	end = validLength;
207	204	if (start < end) {
208		- size_t length = strlen(source);
	205	+ size_t length = _tcslen(source);
209	206	size_t oldLength = validLength;
210	207	ensureCapacity(validLength += length - (end - start));
211		- memcpy(buffer + start + length, buffer + end, oldLength - end);
212		- memcpy(buffer + start, source, length);
	208	+ memcpy(buffer + start + length, buffer + end, sizeof(TCHAR) * (oldLength - end));
	209	+ memcpy(buffer + start, source, sizeof(TCHAR) * length);
213	210	}
214	211	return *this;
215	212	}

		@@ -219,8 +216,6 @@
219	216	// 返値:
220	217	// 指定の位置の文字列。
221	218	String substring(size_t index)const {
222		- if (index < 0)
223		- index = 0;
224	219	return String(buffer + index, validLength - index);
225	220	}
226	221	// 指定の位置の文字列を取得する。

		@@ -230,8 +225,6 @@
230	225	// 返値:
231	226	// 指定の位置の文字列。
232	227	String substring(size_t start, size_t end)const {
233		- if (start < 0)
234		- start = 0;
235	228	if (end > validLength)
236	229	end = validLength;
237	230	return String(buffer + start, end - start);

		@@ -242,7 +235,7 @@
242	235	// source 挿入する文字。
243	236	// 返値:
244	237	// 挿入結果。
245		- StringBuffer& insert(size_t index, char chr) {
	238	+ StringBuffer& insert(size_t index, TCHAR chr) {
246	239	return insert(index, &chr, 1);
247	240	}
248	241	// 指定の位置に文字列を挿入する。

		@@ -251,8 +244,8 @@
251	244	// source 挿入する文字列。
252	245	// 返値:
253	246	// 挿入結果。
254		- StringBuffer& insert(size_t index, const char* source) {
255		- return insert(index, source, strlen(source));
	247	+ StringBuffer& insert(size_t index, const TCHAR* source) {
	248	+ return insert(index, source, _tcslen(source));
256	249	}
257	250	// 指定の位置に文字列を挿入する。
258	251	// 引数:

		@@ -261,17 +254,15 @@
261	254	// length 文字列の長さ。
262	255	// 返値:
263	256	// 挿入結果。
264		- StringBuffer& insert(size_t index, const char* source, size_t length) {
265		- if (index < 0)
266		- index = 0;
267		- else if (index >= validLength)
	257	+ StringBuffer& insert(size_t index, const TCHAR* source, size_t length) {
	258	+ if (index >= validLength)
268	259	index = validLength;
269	260	size_t oldLength = validLength;
270	261	ensureCapacity(validLength + length);
271		- char* temp = (char*) alloca(oldLength - index);
272		- memcpy(temp, buffer + index, oldLength - index);
273		- memcpy(buffer + index, source, length);
274		- memcpy(buffer + index + length, temp, oldLength - index);
	262	+ TCHAR* temp = (TCHAR) alloca(sizeof(TCHAR) (oldLength - index));
	263	+ memcpy(temp, buffer + index, sizeof(TCHAR) * (oldLength - index));
	264	+ memcpy(buffer + index, source, sizeof(TCHAR) * length);
	265	+ memcpy(buffer + index + length, temp, sizeof(TCHAR) * (oldLength - index));
275	266	validLength += length;
276	267	return *this;
277	268	}

		@@ -279,19 +270,22 @@
279	270	// 返値:
280	271	// 反転結果。
281	272	StringBuffer& reverse() {
282		- char* temporary = (char) alloca(sizeof (char) validLength);
283		- char* dst = temporary + validLength;
284		- char* src = buffer;
	273	+ TCHAR* temporary = (TCHAR) alloca(sizeof (TCHAR) validLength);
	274	+ TCHAR* dst = temporary + validLength;
	275	+ TCHAR* src = buffer;
285	276	while (temporary < dst) {
	277	+#if !defined(UNICODE)
286	278	if (String::isLeadByte(*src)) {
287		- char pre = *src++;
	279	+ TCHAR pre = *src++;
288	280	--dst = src++;
289	281	*--dst = pre;
290		- }else{
	282	+ }else
	283	+#endif
	284	+ {
291	285	--dst = src++;
292	286	}
293	287	}
294		- memcpy(buffer, temporary, validLength);
	288	+ memcpy(buffer, temporary, sizeof(TCHAR) * validLength);
295	289	return *this;
296	290	}
297	291	// 文字列を取得する。

		@@ -306,7 +300,7 @@
306	300	// 変更する一文字。
307	301	// 返値:
308	302	// 変更結果。
309		- StringBuffer& set(char chr) {
	303	+ StringBuffer& set(TCHAR chr) {
310	304	ensureCapacity(1);
311	305	buffer[0] = chr;
312	306	validLength = 1;

		@@ -317,18 +311,18 @@
317	311	// source 変更する文字列。
318	312	// 返値:
319	313	// 変更結果。
320		- StringBuffer& set(const char* source) {
321		- size_t length = strlen(source);
	314	+ StringBuffer& set(const TCHAR* source) {
	315	+ size_t length = _tcslen(source);
322	316	ensureCapacity(validLength = length);
323		- memcpy(buffer, source, length);
	317	+ memcpy(buffer, source, sizeof(TCHAR) * length);
324	318	return *this;
325	319	}
326	320
327		- // char*に変換するキャスト演算子。
	321	+ // TCHAR*に変換するキャスト演算子。
328	322	// バッファのアドレスを取得する。
329	323	// 返値:
330	324	// バッファのアドレス。
331		- operator char*() {
	325	+ operator TCHAR*() {
332	326	return buffer;
333	327	}
334	328	// Stringに変換するキャスト演算子。

		@@ -344,7 +338,7 @@
344	338	// ch 変更する一文字。
345	339	// 返値:
346	340	// 代入結果。
347		- StringBuffer& operator=(char ch) {
	341	+ StringBuffer& operator=(TCHAR ch) {
348	342	return set(ch);
349	343	}
350	344	// 代入演算子。

		@@ -353,7 +347,7 @@
353	347	// source 変更する文字列。
354	348	// 返値:
355	349	// 代入結果。
356		- StringBuffer& operator=(const char* source) {
	350	+ StringBuffer& operator=(const TCHAR* source) {
357	351	return set(source);
358	352	}
359	353	// 連結代入演算子。

		@@ -362,7 +356,7 @@
362	356	// ch 追加する文字。
363	357	// 返値:
364	358	// 代入結果。
365		- StringBuffer& operator+=(char ch) {
	359	+ StringBuffer& operator+=(TCHAR ch) {
366	360	return append(ch);
367	361	}
368	362	// 連結代入演算子。

		@@ -371,7 +365,7 @@
371	365	// source 追加する文字列。
372	366	// 返値:
373	367	// 代入結果。
374		- StringBuffer& operator+=(const char* source) {
	368	+ StringBuffer& operator+=(const TCHAR* source) {
375	369	return append(source);
376	370	}
377	371	};

--- branches/cmake/TTProxy/YCL/include/YCL/StringUtil.h (revision 7326)

+++ branches/cmake/TTProxy/YCL/include/YCL/StringUtil.h (revision 7327)

		@@ -18,7 +18,7 @@
18	18
19	19	class StringUtil {
20	20	private:
21		- static int hexadecimal(char c) {
	21	+ static int hexadecimal(TCHAR c) {
22	22	if ('0' <= c && c <= '9') {
23	23	return c - '0';
24	24	}else if ('A' <= c && c <= 'F') {

		@@ -29,15 +29,15 @@
29	29	return -1;
30	30	}
31	31	}
32		- static int octet(char c) {
	32	+ static int octet(TCHAR c) {
33	33	return '0' <= c && c <= '7' ? c - '0' : -1;
34	34	}
35		- static const char* ESCAPE_CHARS() {
36		- static const char string[] = "abfnrtv";
	35	+ static const TCHAR* ESCAPE_CHARS() {
	36	+ static const TCHAR string[] = _T("abfnrtv");
37	37	return string;
38	38	}
39		- static const char* CONTROL_CHARS() {
40		- static const char string[] = "\a\b\f\n\r\t\v";
	39	+ static const TCHAR* CONTROL_CHARS() {
	40	+ static const TCHAR string[] = _T("\a\b\f\n\r\t\v");
41	41	return string;
42	42	}
43	43	public:

		@@ -60,12 +60,12 @@
60	60	static bool escape(StringBuffer& buffer, String string, int offset, int length) {
61	61	if (string == NULL)
62	62	return false;
63		- const char* start = string;
	63	+ const TCHAR* start = string;
64	64	start += offset;
65		- const char* p = start;
66		- const char* end = start + length;
	65	+ const TCHAR* p = start;
	66	+ const TCHAR* end = start + length;
67	67	while (p < end && *p != '\0') {
68		- char ch = *p;
	68	+ TCHAR ch = *p;
69	69	if ('\0' < ch && ch < ' ' \|\| ch == '\'' \|\| ch == '"' \|\| ch == '?' \|\| ch == '\\') {
70	70	bool useOctet;
71	71	if (ch < ' ') {

		@@ -95,12 +95,14 @@
95	95	}
96	96	start = ++p;
97	97	}else{
	98	+#if !defined(UNICODE)
98	99	if (String::isLeadByte(ch))
99	100	p++;
	101	+#endif
100	102	p++;
101	103	}
102	104	}
103		- if (start == (const char*) string) {
	105	+ if (start == (const TCHAR*) string) {
104	106	return false;
105	107	}
106	108	buffer.append(start);

		@@ -126,10 +128,10 @@
126	128	static bool unescape(StringBuffer& buffer, String string, int offset, int length) {
127	129	if (string == NULL)
128	130	return false;
129		- const char* start = string;
	131	+ const TCHAR* start = string;
130	132	start += offset;
131		- const char* p = start;
132		- const char* end = start + length;
	133	+ const TCHAR* p = start;
	134	+ const TCHAR* end = start + length;
133	135	while (p < end && *p != '\0') {
134	136	if (*p == '\\') {
135	137	if (p > start) {

		@@ -136,7 +138,7 @@
136	138	buffer.append(start, p - start);
137	139	start = p;
138	140	}
139		- char ch = '\0';
	141	+ TCHAR ch = '\0';
140	142	switch (*++p) {
141	143	case '\'':
142	144	case '"':

		@@ -188,13 +190,15 @@
188	190	start = p;
189	191	}
190	192	}else{
	193	+#if !defined(UNICODE)
191	194	if (String::isLeadByte(*p)) {
192	195	p++;
193	196	}
	197	+#endif
194	198	p++;
195	199	}
196	200	}
197		- if (start == (const char*) string) {
	201	+ if (start == (const TCHAR*) string) {
198	202	return false;
199	203	}
200	204	buffer.append(start);

--- branches/cmake/TTProxy/YCL/include/YCL/Window.h (revision 7326)

+++ branches/cmake/TTProxy/YCL/include/YCL/Window.h (revision 7327)

		@@ -10,8 +10,8 @@
10	10	#endif // _MSC_VER >= 1000
11	11
12	12	#include <YCL/common.h>
13		-
14	13	#include <YCL/String.h>
	14	+//#include "codeconv.h"
15	15
16	16	namespace yebisuya {
17	17

		@@ -39,16 +39,16 @@
39	39	int GetWindowTextLength()const {
40	40	return ::GetWindowTextLength(window);
41	41	}
42		- int GetWindowText(char* buffer, int size)const {
	42	+ int GetWindowText(TCHAR* buffer, int size)const {
43	43	return ::GetWindowText(window, buffer, size);
44	44	}
45	45	String GetWindowText()const {
46	46	int length = GetWindowTextLength();
47		- char* buffer = (char*) alloca(length + 1);
	47	+ TCHAR* buffer = (TCHAR) alloca((length + 1) sizeof(TCHAR));
48	48	GetWindowText(buffer, length + 1);
49		- return buffer;
	49	+ return String(buffer);
50	50	}
51		- bool SetWindowText(const char* text) {
	51	+ bool SetWindowText(const TCHAR* text) {
52	52	return ::SetWindowText(window, text) != FALSE;
53	53	}
54	54	long SendMessage(int message, int wparam = 0, long lparam = 0)const {

		@@ -208,7 +208,7 @@
208	208	static const char USER32[] = "user32.dll";
209	209	static const char APINAME[] = "SetLayeredWindowAttributes";
210	210	static DWORD (WINAPI* api)(HWND, DWORD, BYTE, DWORD)
211		- = (DWORD (WINAPI*)(HWND, DWORD, BYTE, DWORD)) ::GetProcAddress(::GetModuleHandle(USER32), APINAME);
	211	+ = (DWORD (WINAPI*)(HWND, DWORD, BYTE, DWORD)) ::GetProcAddress(::GetModuleHandleA(USER32), APINAME);
212	212	return api != NULL ? (*api)(window, reserved, parameters, attribute) : 0;
213	213	}
214	214	long SetLayeredWindowAttributes(int parameters, long attribute) {

		@@ -226,10 +226,10 @@
226	226	bool UnregisterHotKey(int id) {
227	227	return ::UnregisterHotKey(window, id) != FALSE;
228	228	}
229		- int MessageBox(const char* message, const char* caption, int type) {
	229	+ int MessageBox(const TCHAR* message, const TCHAR* caption, int type) {
230	230	return ::MessageBox(window, message, caption, type);
231	231	}
232		- int MessageBox(const char* message, int type) {
	232	+ int MessageBox(const TCHAR* message, int type) {
233	233	Window top(window);
234	234	while ((top.getStyle() & WS_CHILD) != 0) {
235	235	top <<= top.GetParent();

		@@ -247,7 +247,7 @@
247	247	return create(exStyle, classname, title, style, rect, parent, menu, GetInstanceHandle(), param);
248	248	}
249	249	bool create(long exStyle, const char* classname, const char* title, long style, const RECT& rect, HWND parent, HMENU menu, HINSTANCE instance, void* param = NULL) {
250		- return (window = ::CreateWindowEx(exStyle, classname, title,
	250	+ return (window = ::CreateWindowExA(exStyle, classname, title,
251	251	style, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
252	252	parent, menu, instance, param)) != NULL;
253	253	}

--- branches/cmake/TTProxy/YCL/include/YCL/common.h (revision 7326)

+++ branches/cmake/TTProxy/YCL/include/YCL/common.h (revision 7327)

		@@ -38,9 +38,9 @@
38	38	char buffer[1025];
39	39	va_list arglist;
40	40	va_start(arglist, format);
41		- wvsprintf(buffer, format, arglist);
	41	+ wvsprintfA(buffer, format, arglist);
42	42	va_end(arglist);
43		- OutputDebugString(buffer);
	43	+ OutputDebugStringA(buffer);
44	44	}
45	45
46	46	#define YCLTRACE(s) OutputDebugString(s)

		@@ -53,12 +53,12 @@
53	53	inline bool YclAssert(bool condition, const char* message) {
54	54	if (!condition) {
55	55	char buffer[1025];
56		- wsprintf(buffer, "Assertion Failed!!\n\n"
	56	+ wsprintfA(buffer, "Assertion Failed!!\n\n"
57	57	" %s\n\n"
58	58	"if ABORT button pushed then exit this program,\n"
59	59	"if RETRY button pushed then enter debug mode,\n"
60	60	"and if IGNORE button pushed then continue program.", message);
61		- switch (MessageBox(NULL, buffer, "YEBISUYA Class Library", MB_ABORTRETRYIGNORE \| MB_ICONWARNING)) {
	61	+ switch (MessageBoxA(NULL, buffer, "YEBISUYA Class Library", MB_ABORTRETRYIGNORE \| MB_ICONWARNING)) {
62	62	case IDABORT:
63	63	ExitProcess(-1);
64	64	break;

--- branches/cmake/teraterm/common/codeconv.cpp (revision 7326)

+++ branches/cmake/teraterm/common/codeconv.cpp (revision 7327)

		@@ -148,3 +148,271 @@
148	148	return strU8;
149	149	}
150	150
	151	+//////////////////////////////////////////////////////////////////////////////
	152	+
	153	+u8::u8()
	154	+{
	155	+ u8str_ = NULL;
	156	+}
	157	+
	158	+u8::u8(const char *astr)
	159	+{
	160	+ u8str_ = NULL;
	161	+ assign(astr, CP_ACP);
	162	+}
	163	+
	164	+u8::u8(const char *astr, int cpage)
	165	+{
	166	+ u8str_ = NULL;
	167	+ assign(astr, cpage);
	168	+}
	169	+
	170	+u8::u8(const wchar_t *wstr)
	171	+{
	172	+ u8str_ = NULL;
	173	+ assign(wstr);
	174	+}
	175	+
	176	+u8::u8(const u8 &obj)
	177	+{
	178	+ copy(obj);
	179	+}
	180	+
	181	+#if defined(MOVE_CONSTRUCTOR_ENABLE)
	182	+u8::u8(u8 &&obj) noexcept
	183	+{
	184	+ move(obj);
	185	+}
	186	+#endif
	187	+
	188	+u8::~u8()
	189	+{
	190	+ if (u8str_ != NULL) {
	191	+ free(u8str_);
	192	+ u8str_ = NULL;
	193	+ }
	194	+}
	195	+
	196	+u8& u8::operator=(const char *astr)
	197	+{
	198	+ assign(astr, CP_ACP);
	199	+ return *this;
	200	+}
	201	+
	202	+u8& u8::operator=(const wchar_t *wstr)
	203	+{
	204	+ assign(wstr);
	205	+ return *this;
	206	+}
	207	+
	208	+u8& u8::operator=(const u8 &obj)
	209	+{
	210	+ copy(obj);
	211	+ return *this;
	212	+}
	213	+
	214	+#if defined(MOVE_CONSTRUCTOR_ENABLE)
	215	+u8& u8::operator=(u8 &&obj) noexcept
	216	+{
	217	+ move(obj);
	218	+ return *this;
	219	+}
	220	+#endif
	221	+
	222	+u8::operator const char *() const
	223	+{
	224	+ return cstr();
	225	+}
	226	+
	227	+const char *u8::cstr() const
	228	+{
	229	+ if (u8str_ == NULL) {
	230	+ return "";
	231	+ }
	232	+ return u8str_;
	233	+}
	234	+
	235	+void u8::assign(const char *astr, int code_page)
	236	+{
	237	+ if (u8str_ != NULL) {
	238	+ free(u8str_);
	239	+ }
	240	+ wchar_t *wstr = _MultiByteToWideChar(astr, 0, code_page, NULL);
	241	+ if (wstr != NULL) {
	242	+ assign(wstr);
	243	+ free(wstr);
	244	+ } else {
	245	+ u8str_ = NULL;
	246	+ }
	247	+}
	248	+
	249	+void u8::assign(const wchar_t *wstr)
	250	+{
	251	+ if (u8str_ != NULL) {
	252	+ free(u8str_);
	253	+ }
	254	+ char *u8str = _WideCharToMultiByte(wstr, 0, CP_UTF8, NULL);
	255	+ if (u8str != NULL) {
	256	+ u8str_ = u8str;
	257	+ } else {
	258	+ u8str_ = NULL;
	259	+ }
	260	+}
	261	+
	262	+void u8::copy(const u8 &obj)
	263	+{
	264	+ if (u8str_ != NULL) {
	265	+ free(u8str_);
	266	+ }
	267	+ u8str_ = _strdup(obj.u8str_);
	268	+}
	269	+
	270	+void u8::move(u8 &obj)
	271	+{
	272	+ if (this != &obj) {
	273	+ if (u8str_ != NULL) {
	274	+ free(u8str_);
	275	+ }
	276	+ u8str_ = obj.u8str_;
	277	+ obj.u8str_ = NULL;
	278	+ }
	279	+}
	280	+
	281	+//////////////////////////////////////////////////////////////////////////////
	282	+
	283	+tc::tc()
	284	+{
	285	+ tstr_ = NULL;
	286	+}
	287	+
	288	+tc::tc(const char *astr)
	289	+{
	290	+ tstr_ = NULL;
	291	+ assign(astr, CP_ACP);
	292	+}
	293	+
	294	+tc::tc(const char *astr, int code_page)
	295	+{
	296	+ tstr_ = NULL;
	297	+ assign(astr, code_page);
	298	+}
	299	+
	300	+tc::tc(const wchar_t *wstr)
	301	+{
	302	+ tstr_ = NULL;
	303	+ assign(wstr, CP_ACP);
	304	+}
	305	+
	306	+tc::tc(const wchar_t *wstr, int code_page)
	307	+{
	308	+ tstr_ = NULL;
	309	+ assign(wstr, code_page);
	310	+}
	311	+
	312	+#if defined(MOVE_CONSTRUCTOR_ENABLE)
	313	+tc::tc(tc &&obj) noexcept
	314	+{
	315	+ move(obj);
	316	+}
	317	+#endif
	318	+
	319	+tc::~tc()
	320	+{
	321	+ if (tstr_ != NULL) {
	322	+ free(tstr_);
	323	+ }
	324	+}
	325	+
	326	+tc& tc::operator=(const char *astr)
	327	+{
	328	+ assign(astr, CP_ACP);
	329	+ return *this;
	330	+}
	331	+
	332	+tc& tc::operator=(const wchar_t *wstr)
	333	+{
	334	+ assign(wstr, CP_ACP);
	335	+ return *this;
	336	+}
	337	+
	338	+const TCHAR tc::fromUtf8(const char u8str)
	339	+{
	340	+ if (tstr_ != NULL) {
	341	+ free(tstr_);
	342	+ }
	343	+ tstr_ = NULL;
	344	+ wchar_t *wstr = _MultiByteToWideChar(u8str, 0, CP_UTF8, NULL);
	345	+ if (wstr != NULL) {
	346	+ assign(wstr, CP_ACP);
	347	+ free(wstr);
	348	+ }
	349	+ return cstr();
	350	+}
	351	+
	352	+tc::operator const TCHAR *() const
	353	+{
	354	+ return cstr();
	355	+}
	356	+
	357	+const TCHAR *tc::cstr() const
	358	+{
	359	+ if (tstr_ == NULL) {
	360	+ return _T("");
	361	+ }
	362	+ return tstr_;
	363	+}
	364	+
	365	+void tc::assign(const char *astr, int code_page)
	366	+{
	367	+ if (tstr_ != NULL) {
	368	+ free(tstr_);
	369	+ }
	370	+#if !defined(UNICODE)
	371	+ (void)code_page;
	372	+ tstr_ = _strdup(astr);
	373	+#else
	374	+ wchar_t *wstr = _MultiByteToWideChar(astr, 0, code_page, NULL);
	375	+ if (wstr != NULL) {
	376	+ tstr_ = wstr;
	377	+ } else {
	378	+ tstr_ = NULL;
	379	+ }
	380	+#endif
	381	+}
	382	+
	383	+void tc::assign(const wchar_t *wstr, int code_page)
	384	+{
	385	+ if (tstr_ != NULL) {
	386	+ free(tstr_);
	387	+ }
	388	+#if defined(UNICODE)
	389	+ (void)code_page;
	390	+ tstr_ = _wcsdup(wstr);
	391	+#else
	392	+ char *astr = _WideCharToMultiByte(wstr, 0, code_page, NULL);
	393	+ if (astr != NULL) {
	394	+ tstr_ = astr;
	395	+ } else {
	396	+ tstr_ = NULL;
	397	+ }
	398	+#endif
	399	+}
	400	+
	401	+void tc::copy(const tc &obj)
	402	+{
	403	+ if (tstr_ != NULL) {
	404	+ free(tstr_);
	405	+ }
	406	+ tstr_ = _tcsdup(obj.tstr_);
	407	+}
	408	+
	409	+void tc::move(tc &obj)
	410	+{
	411	+ if (this != &obj) {
	412	+ if (tstr_ != NULL) {
	413	+ free(tstr_);
	414	+ }
	415	+ tstr_ = obj.tstr_;
	416	+ obj.tstr_ = NULL;
	417	+ }
	418	+}

--- branches/cmake/teraterm/common/codeconv.h (revision 7326)

+++ branches/cmake/teraterm/common/codeconv.h (revision 7327)

		@@ -1,4 +1,6 @@
1	1
	2	+#pragma once
	3	+
2	4	#include <tchar.h>
3	5
4	6	#ifdef __cplusplus

		@@ -33,3 +35,70 @@
33	35	TCHAR ToTchar(const wchar_t strW);
34	36	#endif
35	37
	38	+
	39	+#ifdef __cplusplus
	40	+
	41	+#if defined(__GNUC__) \|\| (defined(_MSC_VER) && (_MSC_VER > 1910))
	42	+#define MOVE_CONSTRUCTOR_ENABLE
	43	+#endif
	44	+
	45	+class u8
	46	+{
	47	+public:
	48	+ u8();
	49	+ u8(const char *astr);
	50	+ u8(const char *astr, int code_page);
	51	+ u8(const wchar_t *wstr);
	52	+ u8(const u8 &obj);
	53	+#if defined(MOVE_CONSTRUCTOR_ENABLE)
	54	+ u8(u8 &&obj) noexcept;
	55	+#endif
	56	+ ~u8();
	57	+ u8& operator=(const char *astr);
	58	+ u8& operator=(const wchar_t *wstr);
	59	+ u8& operator=(const u8 &obj);
	60	+#if defined(MOVE_CONSTRUCTOR_ENABLE)
	61	+ u8& operator=(u8 &&obj) noexcept;
	62	+#endif
	63	+ operator const char *() const;
	64	+ const char *cstr() const;
	65	+private:
	66	+ char *u8str_;
	67	+ void assign(const char *astr, int code_page);
	68	+ void assign(const wchar_t *wstr);
	69	+ void copy(const u8 &obj);
	70	+ void move(u8 &obj);
	71	+};
	72	+
	73	+class tc
	74	+{
	75	+public:
	76	+ tc();
	77	+ tc(const char *astr);
	78	+ tc(const char *astr, int code_page);
	79	+ tc(const wchar_t *wstr);
	80	+ tc(const wchar_t *wstr, int code_page);
	81	+ tc(const tc &obj);
	82	+#if defined(MOVE_CONSTRUCTOR_ENABLE)
	83	+ tc(tc &&obj) noexcept;
	84	+#endif
	85	+ ~tc();
	86	+ tc& operator=(const char *astr);
	87	+ tc& operator=(const wchar_t *wstr);
	88	+ tc& operator=(const tc &obj);
	89	+#if defined(MOVE_CONSTRUCTOR_ENABLE)
	90	+ tc& operator=(tc &&obj) noexcept;
	91	+#endif
	92	+ const TCHAR fromUtf8(const char u8str);
	93	+ operator const TCHAR *() const;
	94	+ const TCHAR *cstr() const;
	95	+private:
	96	+ TCHAR *tstr_;
	97	+ void assign(const char *astr, int code_page);
	98	+ void assign(const wchar_t *astr, int code_page);
	99	+ void copy(const tc &obj);
	100	+ void move(tc &obj);
	101	+};
	102	+#endif
	103	+
	104	+

Tera Term

ttssh2: Commit

Commit MetaInfo

Log Message

Change Summary

Incremental Difference