支持TCHAR的getopt发布

happy886rr

tgetopt.hpp库 [2017-05-21 version 1.0]

TGETOPT是一款可以支持TCHAR的getopt扩展库。使用非常简单，直接在项目中#include "tgetopt.hpp"即可。从而让你的任何C、C++项目瞬间变成TCHAR版，完全支持单、宽字符。从此不再为宽字符开关解析发愁，让你的VS项目、TCAHR版项目 可以拥有与GNU一样的开关玩法。新增的T2V、V2T函数让你瞬间在 单、宽字符 与TCAHR间轻松切换。从此不必为项目中的字符集转换发愁。

TGETOPT.HPP (GETOPT FOR TCHAR, COPYRIGHT@2017~2019 BY LEO, VERSION 1.0)

摘要：
====================================================
TGETOPT.HPP库，让TCHAR支持getopt。新增两个辅助函数T2V、V2T，实现 TCHAR*
与 VOID* 的无缝转化。 自然的令任何C/C++ 项目完美支持 TCHAR* 开关解析。
====================================================

宏名：
-------------------------------------------------------------------------
// TCHARFORMAT 格式化宏
#if defined(_UNICODE) || defined(UNICODE)
#define TCHARFORMAT WCHAR
#else
#define TCHARFORMAT CHAR
#endif

// 开关解析宏
#define _OPT_TEOF -1    //OPT循环结束符
#define _OPT_TILL -2    //第一个无选项的参数序号已存入UNOPTIND，通过argv[UNOPTIND]获取
#define _OPT_TERR -3    //OPT开关错误符

// 开关解析变量
INT OPTIND=1, OPTOPT, UNOPTIND=-1;
TCHAR* OPTARG;          //每次解析到的字符串
-------------------------------------------------------------------------

用法：（直接 #include "tgetopt.hpp" 即可）
-------------------------------------------------------------------------
INT   _tgetopt(INT, TCHAR**, TCHAR*);     //用法同GNU版getopt()，但须传递：TCAHR*参数
TCHAR* V2T(VOID*, BOOL);                  //将任意类型转 TCHAR*，BOOL为真：输入宽字节
VOID*  T2V(TCHAR*, BOOL);                 //将TCHAR* 转任意类型，BOOL为真：输出宽字节
-------------------------------------------------------------------------

版本：
VERSION 1.0

源码：tgetopt.hpp

1. /*
   
2.         GETOPT FOR TCHAR, COPYRIGHT@2017~2019 BY LEO, VERSION 1.0
   
3.         TGETOPT.HPP
   
4. */
   
5. 
   
6. #ifndef _TGETOPT_HPP
   
7. #define _TGETOPT_HPP USED
   
8. 
   
9. #if !( defined(_WINDOWS_H) || defined(_WINDOWS_) )
   
10. #include <windows.h>
    
11. #endif
    
12. 
    
13. #if !( defined(_TCHAR_H) || defined(_INC_TCHAR) )
    
14. #include   <tchar.h>
    
15. #endif
    
16. 
    
17. // TCHARFORMAT 格式化宏
    
18. #if defined(_UNICODE) || defined(UNICODE)
    
19. #define TCHARFORMAT WCHAR
    
20. #else
    
21. #define TCHARFORMAT CHAR
    
22. #endif
    
23. 
    
24. // 开关解析宏名
    
25. #define _OPT_TEOF -1
    
26. #define _OPT_TILL -2
    
27. #define _OPT_TERR -3
    
28. 
    
29. // 开关解析变量
    
30. INT OPTIND=1, OPTOPT, UNOPTIND=-1;
    
31. TCHAR* OPTARG;
    
32. 
    
33. //函数声明
    
34. INT   _tgetopt(INT, TCHAR**, TCHAR*);
    
35. TCHAR* V2T(VOID*, BOOL);
    
36. VOID*  T2V(TCHAR*, BOOL);
    
37. 
    
38. // TCHAR 版 getopt
    
39. INT _tgetopt(INT nargc, TCHAR* nargv[], TCHAR* ostr)
    
40. {
    
41.         static TCHAR* place = (TCHAR*)_T("");
    
42.         static TCHAR* lastostr = NULL;
    
43.         register TCHAR* oli;
    
44. 
    
45.         if(ostr!=lastostr)
    
46.         {
    
47.                 lastostr=ostr;
    
48.                 place=(TCHAR*)_T("");
    
49.         }
    
50. 
    
51.         if(!*place)
    
52.         {
    
53.                 if(
    
54.                     (OPTIND>=nargc)                           ||
    
55.                     (*(place=nargv[OPTIND]) !=(TCHAR)_T('-')) ||
    
56.                     (!*(++place))
    
57.                 )
    
58.                 {
    
59.                         if(*place !=(TCHAR)_T('-') && OPTIND <nargc)
    
60.                         {
    
61.                                 place =(TCHAR*)_T("");
    
62.                                 if(UNOPTIND == -1)
    
63.                                 {
    
64.                                         UNOPTIND = OPTIND++;
    
65.                                         return _OPT_TILL;
    
66.                                 }
    
67.                                 else
    
68.                                 {
    
69.                                         return _OPT_TERR;
    
70.                                 }
    
71.                         }
    
72. 
    
73.                         place=(TCHAR*)_T("");
    
74.                         return _OPT_TEOF;
    
75.                 }
    
76.                 if(*place == (TCHAR)_T('-') && *(place+1) == (TCHAR)_T('\0'))
    
77.                 {
    
78.                         ++OPTIND;
    
79.                         return _OPT_TEOF;
    
80.                 }
    
81.         }
    
82. 
    
83.         if(
    
84.             (OPTOPT=*place++) == (TCHAR)_T(':') ||
    
85.             !(oli=(TCHAR*)_tcschr((TCHARFORMAT*)ostr, (TCHAR)OPTOPT))
    
86.         )
    
87.         {
    
88.                 if(!*place)
    
89.                 {
    
90.                         ++OPTIND;
    
91.                 }
    
92.         }
    
93. 
    
94.         if(oli != NULL && *(++oli) !=(TCHAR)_T(':'))
    
95.         {
    
96.                 OPTARG=NULL;
    
97.                 if(!*place)
    
98.                 {
    
99.                         ++OPTIND;
    
100.                 }
     
101.         }
     
102.         else
     
103.         {
     
104.                 if(*place)
     
105.                 {
     
106.                         OPTARG=place;
     
107.                 }
     
108.                 else if(nargc <= ++OPTIND)
     
109.                 {
     
110.                         place=(TCHAR*)_T("");
     
111.                 }
     
112.                 else
     
113.                 {
     
114.                         OPTARG=nargv[OPTIND];
     
115.                 }
     
116.                 place=(TCHAR*)_T("");
     
117.                 ++OPTIND;
     
118.         }
     
119.         return OPTOPT;
     
120. }
     
121. 
     
122. // VOID* 转 TCHAR*
     
123. TCHAR* V2T(VOID* csDATA, BOOL wcsMODE)
     
124. {
     
125. #if defined(_UNICODE) || defined(UNICODE)
     
126. 
     
127.         if(wcsMODE == TRUE)
     
128.         {
     
129.                 return (TCHAR*)csDATA;
     
130.         }
     
131.         else
     
132.         {
     
133.                 INT wLEN = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (CHAR*)csDATA, -1, NULL, 0);
     
134.                 WCHAR* wsDATA = (WCHAR*)malloc(wLEN + 1);
     
135.                 MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (CHAR*)csDATA, -1, wsDATA, wLEN);
     
136.                 wsDATA[wLEN]=L'\0';
     
137.                 return (TCHAR*)wsDATA;
     
138.         }
     
139. 
     
140. #else
     
141. 
     
142.         if(wcsMODE == TRUE)
     
143.         {
     
144.                 INT aLEN = WideCharToMultiByte(CP_ACP, (DWORD)NULL, (WCHAR*)csDATA, -1, NULL, 0, NULL, NULL);
     
145.                 CHAR* asDATA = (CHAR*)malloc(aLEN + 1);
     
146.                 WideCharToMultiByte(CP_ACP, (DWORD)NULL, (WCHAR*)csDATA, -1, asDATA, aLEN, NULL, NULL);
     
147.                 asDATA[aLEN] = '\0';
     
148.                 return (TCHAR*)asDATA;
     
149.         }
     
150.         else
     
151.         {
     
152.                 return (TCHAR*)csDATA;
     
153.         }
     
154. 
     
155. #endif
     
156. }
     
157. 
     
158. // TCHAR* 转 VOID*
     
159. VOID* T2V(TCHAR* csDATA, BOOL wcsMODE)
     
160. {
     
161. #if defined(_UNICODE) || defined(UNICODE)
     
162. 
     
163.         if(wcsMODE == TRUE)
     
164.         {
     
165.                 return (VOID*)csDATA;
     
166.         }
     
167.         else
     
168.         {
     
169.                 INT aLEN = WideCharToMultiByte(CP_ACP, (DWORD)NULL, (WCHAR*)csDATA, -1, NULL, 0, NULL, NULL);
     
170.                 CHAR* asDATA = (CHAR*)malloc(aLEN + 1);
     
171.                 WideCharToMultiByte(CP_ACP, (DWORD)NULL, (WCHAR*)csDATA, -1, asDATA, aLEN, NULL, NULL);
     
172.                 asDATA[aLEN] = '\0';
     
173.                 return (VOID*)asDATA;
     
174.         }
     
175. 
     
176. #else
     
177. 
     
178.         if(wcsMODE == TRUE)
     
179.         {
     
180.                 INT wLEN = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (CHAR*)csDATA, -1, NULL, 0);
     
181.                 WCHAR* wsDATA = (WCHAR*)malloc(wLEN + 1);
     
182.                 MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (CHAR*)csDATA, -1, wsDATA, wLEN);
     
183.                 wsDATA[wLEN]=L'\0';
     
184.                 return (VOID*)wsDATA;
     
185.         }
     
186.         else
     
187.         {
     
188.                 return (VOID*)csDATA;
     
189.         }
     
190. 
     
191. #endif
     
192. }
     
193. 
     
194. #endif
     

复制代码