windows代码页转换工具wincp.exe

happy886rr

[tvcp已经更名为wincp，修复数个bug，版本号升级为1.1]
wincp代码页转化工具，支持文本编码转换，BOM头修改、伪造BOM、去BOM，自动修正参数，BOM自动偏移 等功能。

下载：存外链图为a.zip解压便是。


WINCP.EXE  (TEXT CODEPAGE CONVERSION TOOL, BY LEO, VERSION 1.1)

摘要：
=========================================================================
代码页转化工具，支持文本编码转换，BOM头修改、伪造、去BOM，自动修正参数，
BOM自动偏移... 等功能。

用处特殊，效果奇佳。不仅仅是编码转换，更具代码页翻译、伪造、BOM自定义，加
密等等。

补充：code_page参数可以是代码页数字入936，也可以是代码页缩写如GBK，具体对
照详见 备注（常见代码页缩写）。
=========================================================================


用法：
-------------------------------------------------------------------------
wincp [input_file] -f [code_page] -t [code_page] -s [skip_number] -b[fill_BOM] -o [out_file]
-------------------------------------------------------------------------
  -f  From the code page
  -t  Translate to the code page
  -s  Skip the number of bytes
  -b  Filling BOM
  -o  Output file name
  -h  Show help information
-------------------------------------------------------------------------


举例：
-------------------------------------------------------------------------
REM 将test.txt从BIG5编码转为UTF8编码
wincp test.txt -o out.txt -f BIG5 -t UTF8

REM 将test.txt从ANSI编码转为UTF8编码
wincp test.txt -o out.txt -f 936 -t 65001

REM 将test.txt从UTF8编码转为UCS-2LE编码，即通常的UNICODE编码，并填充其BOM头为0xFFFE。
wincp test.txt -f 65001 -t 1200 -s 0 -b 0xFFFE -o out.txt

REM 将test.txt从UNICODE大端编码转为UTF8编码
wincp test.txt -o out.txt -f UCS2BE -t UTF8
wincp test.txt -oout.txt -fUNICODEBE -tUTF8

REM 将test.txt去除BOM
wincp test.txt -oout.txt

REM 伪造BOM
wincp test.txt -oout.txt -b0xADFF0000
...
-------------------------------------------------------------------------


备注：（常见代码页缩写）
-------------------------------------------------------------------------
ANSI    0
GBK     936
GB18030 54936
BIG5    950

UNICODE   UTF16    UCS2    1200
UNICODEBE UTF16BE  UCS2BE  1201

UTF8    65001
UTF7    65000

UTF32   12000
UTF32BE 12001
-------------------------------------------------------------------------


代码页：（通用代码页对照表）
-------------------------------------------------------------------------
  437 — 最初的 IBM PC 代码页，实现了扩展ASCII字符集
  737 — 希腊语
  850 — Latin-1(西欧语言)
  852 — Latin-2(中欧及东欧语言)
  855 — 西里尔(Cyril)字母
  857 — 土耳其语
  858 — 带欧元符号的“多语言”
  860 — 葡萄牙语
  861 — 冰岛语
  863 — 法语 加拿大英语
  865 — 北欧
  866 — 西里尔(Cyril)字母
  869 — 希腊语
  874 — 泰文字母
  932 — 日本
  949 — 韩国
  936 — GBK中文编码
  950 — BIG5繁体中文
1200 — UCS-2LE Unicode 小端序
1201 — UCS-2BE Unicode 大端序
1250 — 东欧拉丁字母
1251 — 古斯拉夫语
1252 — 西欧拉丁字母 ISO-8859-1.
1253 — 希腊语
1254 — 土耳其语
1255 — 希伯来语
1256 — 阿拉伯语
1257 — 巴尔
1258 — 越南
1254 — 土耳其语
10000 — Macintosh Roman encoding (followed by several other Mac character sets)
10007 — Macintosh Cyrillic encoding
10029 — Macintosh Central European encoding
12000 — utf-32 Unicode UTF-32, little endian byte order; available only to managed applications
12001 — utf-32BE Unicode UTF-32, big endian byte order; available only to managed applications
28591 — iso-8859-1 ISO 8859-1 Latin 1; Western European (ISO)
51936 — EUC-CN EUC Simplified Chinese; Chinese Simplified (EUC)
54936 — GB18030
65000 — UTF-7 Unicode
65001 — UTF-8 Unicode
-------------------------------------------------------------------------


BOM：（常见字节顺序标记）
-------------------------------------------------------------------------
UTF-8       EF BB BF
UTF-16 (LE) FF FE
UTF-16 (BE) FE FF
UTF-32 (LE) FF FE 00 00
UTF-32 (BE) 00 00 FE FF
UTF-7       2B 2F 76 +[38|39|2B|2F]
UTF-1       F7 64 4C
UTF-EBCDIC  DD 73 66 73
SCSU        0E FE FF
BOCU-1      FB EE 28 (+FF)
GB-18030    84 31 95 33
-------------------------------------------------------------------------

版本：
VERSION 1.0

源码支持单宽字符，各类win编译器编译。

1. 
   
2. /*
   
3.         TEXT CODEPAGE CONVERSION TOOL, COPYRIGHT@2017~2019 BY LEO, VERSION 1.1
   
4.         WINCP.EXE
   
5. 
   
6.         UNICODE COMPILATION:
   
7.         ==> G++ wincp.cpp -D _UNICODE -D UNICODE -municode -O2 -static
   
8.         ==> CL  wincp.cpp /O2 /Oy- /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /MD
   
9. 
   
10.         ANSI COMPILATION:
    
11.         ==> G++ wincp.cpp -O2 -static
    
12.         ==> CL  wincp.cpp /O2 /Oy- /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /MD
    
13. */
    
14. 
    
15. 
    
16. #include <stdio.h>
    
17. #include <stdlib.h>
    
18. #include <string.h>
    
19. #include <windows.h>
    
20. #include <locale.h>
    
21. #include <ctype.h>
    
22. #include <tchar.h>
    
23. #include <time.h>
    
24. 
    
25. #if !defined(_MSC_VER) && !defined(bool)
    
26. #include <stdbool.h>
    
27. #endif
    
28. 
    
29. #if !defined(WIN32) && !defined(__WIN32__)
    
30. #error Only run on windows system
    
31. #endif
    
32. 
    
33. /***************定义宏变量***************/
    
34. //文件限制
    
35. #define MAX_FILE_SIZE 1024 * 1024
    
36. 
    
37. //标准行长
    
38. #define BUFF_SIZE 1024
    
39. 
    
40. //BOM容器长度
    
41. #define BOMS_SIZE 4
    
42. 
    
43. //编码检测阈值（字节）
    
44. #define CHECK_SIZE 16383
    
45. 
    
46. //定义帮助说明
    
47. #define HELP_INFORMATION _T("\
    
48. wincp v1.1 - Console text codepage conv tool - Copyright (C) 2017-2019 by LEO\n\
    
49. Usage: wincp [input_file] -f [code_page] -t [code_page] -s [skip_number] -b[fill_BOM] -o [out_file]\n\
    
50. \n\
    
51. General options:\n\
    
52.   -f  From the code page\n\
    
53.   -t  Translate to the code page\n\
    
54.   -s  Skip the number of bytes\n\
    
55.   -b  Filling BOM\n\
    
56.   -o  Output file name\n\
    
57.   -h  Show help information\n\
    
58. \n\
    
59. Official website:\n\
    
60.       http://www.bathome.net/thread-44343-1-1.html\n\
    
61. ")
    
62. 
    
63. /*
    
64. Microsoft code pages:\n\
    
65.   897 – IBM-PC SBCS Japanese (JIS X 0201-1976)
    
66.   941 – IBM-PC Japanese DBCS for Open environment
    
67.   947 – IBM-PC DBCS for (Big5 encoding)
    
68.   950 – Traditional Chinese MIX (Big5 encoding) (1114 + 947) (same with euro: 1370)
    
69. 1114 – IBM-PC SBCS (Simplified Chinese; GBK; Traditional Chinese; Big5 encoding)
    
70. 1126 – IBM-PC Korean SBCS
    
71. 1162 – Windows Thai (Extension of 874; but still called that in Windows)
    
72. 1169 – Windows Cyrillic Asian
    
73. 1250 – Windows Central Europe
    
74. 1251 – Windows Cyrillic
    
75. 1252 – Windows Western
    
76. 1253 – Windows Greek
    
77. 1254 – Windows Turkish
    
78. 1255 – Windows Hebrew
    
79. 1256 – Windows Arabic
    
80. 1257 – Windows Baltic
    
81. 1258 – Windows Vietnamese
    
82. 1361 – Korean (JOHAB)
    
83. 1362 – Korean Hangul DBCS
    
84. 1363 – Windows Korean (1126 + 1362) (Windows CP 949)
    
85. 1372 – IBM-PC MS T Chinese Big5 encoding (Special for DB2)
    
86. 1373 – Windows Traditional Chinese (extension of 950)
    
87. 1374 – IBM-PC DB Big5 encoding extension for HKSCS
    
88. 1375 – Mixed Big5 encoding extension for HKSCS (intended to match 950)
    
89. 1385 – IBM-PC Simplified Chinese DBCS (Growing CS for GB18030, also used for GBK PC-DATA.)
    
90. 1386 – IBM-PC Simplified Chinese GBK (1114 + 1385) (Windows CP 936)
    
91. 1391 – Simplified Chinese 4 Byte (Growing CS for GB18030, also used for GBK PC-DATA.)
    
92. 1392 – IBM-PC Simplified Chinese MIX (1252 + 1385 + 1391)
    
93. ...
    
94. */
    
95. 
    
96. //开关解析宏名
    
97. #define _OPT_TEOF -1
    
98. #define _OPT_TILL -2
    
99. #define _OPT_TERR -3
    
100. 
     
101. //开关解析变量
     
102. int OPTIND=1, OPTOPT, UNOPTIND=-1;
     
103. TCHAR* OPTARG;
     
104. 
     
105. #if defined(_UNICODE) || defined(UNICODE)
     
106. #define TCHARFORMAT WCHAR
     
107. #else
     
108. #define TCHARFORMAT CHAR
     
109. #endif
     
110. 
     
111. //BOM转UINT宏函数
     
112. #define BOM2UINT(x) (unsigned int)(((unsigned char)(x)[0]<<24)|((unsigned char)(x)[1]<<16)|((unsigned char)(x)[2]<<8)|((unsigned char)(x)[3]))
     
113. 
     
114. /***************功能函数群***************/
     
115. //判断纯数字
     
116. int _istPositiveNumber(TCHAR* instr)
     
117. {
     
118.         //过滤前空
     
119.         while(_istspace(*instr))
     
120.         {
     
121.                 instr++;
     
122.         }
     
123. 
     
124.         //过滤空值和负数
     
125.         if(*instr == _T('\0') || *instr == _T('-'))
     
126.         {
     
127.                 return -1;
     
128.         }
     
129. 
     
130.         //判断每一位是数字
     
131.         while(_istdigit(*(instr)))
     
132.         {
     
133.                 instr++;
     
134.         }
     
135. 
     
136.         //判断结尾
     
137.         return (*instr == _T('\0')) ?0 :1;
     
138. }
     
139. 
     
140. //获取代码页
     
141. int _tgetCP(TCHAR* instr)
     
142. {
     
143.         //空指针
     
144.         if(instr == NULL)
     
145.         {
     
146.                 return -1;
     
147.         }
     
148. 
     
149.         //设置返回值
     
150.         int retCP;
     
151.         switch(_istPositiveNumber(instr))
     
152.         {
     
153.         case -1:
     
154.                 return -1;
     
155. 
     
156.         case  0:
     
157.                 return _ttoi((TCHARFORMAT*)instr);
     
158. 
     
159.         case  1:
     
160.                 break;
     
161.         }
     
162. 
     
163.         if     (_tcsicmp(instr, _T("ANSI")   ) ==0)
     
164.         {
     
165.                 retCP=CP_ACP;
     
166.         }
     
167.         else if(_tcsicmp(instr, _T("GBK")    ) ==0)
     
168.         {
     
169.                 retCP=936;
     
170.         }
     
171.         else if(_tcsicmp(instr, _T("GB18030")) ==0)
     
172.         {
     
173.                 retCP=54936;
     
174.         }
     
175.         else if(_tcsicmp(instr, _T("BIG5")   ) ==0)
     
176.         {
     
177.                 retCP=950;
     
178.         }
     
179.         else if(
     
180.             _tcsicmp(instr, _T("UNICODE")  ) ==0 ||
     
181.             _tcsicmp(instr, _T("UTF16")    ) ==0 ||
     
182.             _tcsicmp(instr, _T("UCS2")     ) ==0
     
183.         )
     
184.         {
     
185.                 retCP=1200;
     
186.         }
     
187.         else if(
     
188.             _tcsicmp(instr, _T("UNICODEBE")) ==0 ||
     
189.             _tcsicmp(instr, _T("UTF16BE")  ) ==0 ||
     
190.             _tcsicmp(instr, _T("UCS2BE")   ) ==0
     
191.         )
     
192.         {
     
193.                 retCP=1201;
     
194.         }
     
195.         else if(_tcsicmp(instr, _T("UTF7")   ) ==0)
     
196.         {
     
197.                 retCP=65000;
     
198.         }
     
199.         else if(_tcsicmp(instr, _T("UTF8")   ) ==0)
     
200.         {
     
201.                 retCP=65001;
     
202.         }
     
203.         else if(_tcsicmp(instr, _T("UTF32")  ) ==0)
     
204.         {
     
205.                 retCP=12000;
     
206.         }
     
207.         else if(_tcsicmp(instr, _T("UTF32BE")) ==0)
     
208.         {
     
209.                 retCP=12001;
     
210.         }
     
211.         else
     
212.         {
     
213.                 retCP=-1;
     
214.         }
     
215.         return retCP;
     
216. }
     
217. 
     
218. //字符转HEX
     
219. int C2HEX(TCHAR intc)
     
220. {
     
221.         int hret=-1;
     
222.         if     (_T('0')<=intc && intc<=_T('9'))
     
223.         {
     
224.                 hret=intc-48;
     
225.         }
     
226.         else if(_T('A')<=intc && intc<=_T('F'))
     
227.         {
     
228.                 hret=intc-55;
     
229.         }
     
230.         else if(_T('a')<=intc && intc<=_T('f'))
     
231.         {
     
232.                 hret=intc-87;
     
233.         }
     
234.         else
     
235.         {
     
236.                 hret=-1;
     
237.         }
     
238. 
     
239.         return hret;
     
240. }
     
241. 
     
242. //BOM头转BINBYTE
     
243. int TCHARRAY2BIN(TCHAR* instr, BYTE* &tainer)
     
244. {
     
245.         memset(tainer, 0, BOMS_SIZE);
     
246. 
     
247.         if(*instr == _T('x') || *instr == _T('X'))
     
248.         {
     
249.                 instr ++;
     
250.         }
     
251.         if(_tcsnicmp(instr, _T("0x"), 2) ==0)
     
252.         {
     
253.                 instr += 2;
     
254.         }
     
255. 
     
256.         int i=-1, hexNUM;
     
257.         while(++i<BOMS_SIZE)
     
258.         {
     
259.                 hexNUM=C2HEX(*instr++);
     
260.                 if(hexNUM != -1)
     
261.                 {
     
262.                         tainer[i] |= (hexNUM<<4);
     
263.                 }
     
264.                 else
     
265.                 {
     
266.                         break;
     
267.                 }
     
268. 
     
269.                 hexNUM=C2HEX(*instr++);
     
270.                 if(hexNUM != -1)
     
271.                 {
     
272.                         tainer[i] |= hexNUM;
     
273.                 }
     
274.                 else
     
275.                 {
     
276.                         break;
     
277.                 }
     
278.         }
     
279. 
     
280.         return i;
     
281. }
     
282. 
     
283. //开关解析模块
     
284. int _tgetopt(int nargc, TCHAR* nargv[], TCHAR* ostr)
     
285. {
     
286.         static TCHAR* place = (TCHAR*)_T("");
     
287.         static TCHAR* lastostr = NULL;
     
288.         register TCHAR* oli;
     
289. 
     
290.         if(ostr!=lastostr)
     
291.         {
     
292.                 lastostr=ostr;
     
293.                 place=(TCHAR*)_T("");
     
294.         }
     
295. 
     
296.         if(!*place)
     
297.         {
     
298.                 if(
     
299.                     (OPTIND>=nargc)                           ||
     
300.                     (*(place=nargv[OPTIND]) !=(TCHAR)_T('-')) ||
     
301.                     (!*(++place))
     
302.                 )
     
303.                 {
     
304.                         if(*place !=(TCHAR)_T('-') && OPTIND <nargc)
     
305.                         {
     
306.                                 place =(TCHAR*)_T("");
     
307.                                 if(UNOPTIND == -1)
     
308.                                 {
     
309.                                         UNOPTIND = OPTIND++;
     
310.                                         return _OPT_TILL;
     
311.                                 }
     
312.                                 else
     
313.                                 {
     
314.                                         return _OPT_TERR;
     
315.                                 }
     
316.                         }
     
317. 
     
318.                         place=(TCHAR*)_T("");
     
319.                         return _OPT_TEOF;
     
320.                 }
     
321.                 if (*place == (TCHAR)_T('-') && *(place+1) == (TCHAR)_T('\0'))
     
322.                 {
     
323.                         ++OPTIND;
     
324.                         return _OPT_TEOF;
     
325.                 }
     
326.         }
     
327. 
     
328.         if (
     
329.             (OPTOPT=*place++) == (TCHAR)_T(':') ||
     
330.             !(oli=(TCHAR*)_tcschr((TCHARFORMAT*)ostr, (TCHAR)OPTOPT))
     
331.         )
     
332.         {
     
333.                 if(!*place)
     
334.                 {
     
335.                         ++OPTIND;
     
336.                 }
     
337.         }
     
338. 
     
339.         if (oli != NULL && *(++oli) !=(TCHAR)_T(':'))
     
340.         {
     
341.                 OPTARG=NULL;
     
342.                 if(!*place)
     
343.                 {
     
344.                         ++OPTIND;
     
345.                 }
     
346.         }
     
347.         else
     
348.         {
     
349.                 if(*place)
     
350.                 {
     
351.                         OPTARG=place;
     
352.                 }
     
353.                 else if(nargc <= ++OPTIND)
     
354.                 {
     
355.                         place=(TCHAR*)_T("");
     
356.                 }
     
357.                 else
     
358.                 {
     
359.                         OPTARG=nargv[OPTIND];
     
360.                 }
     
361.                 place=(TCHAR*)_T("");
     
362.                 ++OPTIND;
     
363.         }
     
364.         return OPTOPT;
     
365. }
     
366. 
     
367. //代码页转化
     
368. void PageTurnAround(const BYTE* input, int inputSIZE, int inPAGE, int outPAGE, BYTE* &outDATA, int &oLEN)
     
369. {
     
370.         int wLEN;
     
371.         char* outCACHE=NULL;
     
372.         wchar_t* wcsCACHE=NULL;
     
373. 
     
374.         if(inPAGE == outPAGE)
     
375.         {
     
376.                 outDATA=(BYTE*)input, oLEN=inputSIZE;
     
377.                 return;
     
378.         }
     
379. 
     
380.         //针对UCS-2输入代码页
     
381.         if(inPAGE == 1200)
     
382.         {
     
383.                 wcsCACHE=(wchar_t*)input;
     
384.                 wLEN=inputSIZE/2+1;
     
385.                 goto TOMCS;
     
386.         }
     
387.         if(inPAGE == 1201)
     
388.         {
     
389.                 wchar_t* wp=(wchar_t*)input;
     
390.                 while(*wp)
     
391.                 {
     
392.                         *wp = (((*wp)&0x00FF)<<8)|(((*wp)&0xFF00)>>8);
     
393.                         wp ++;
     
394.                 }
     
395.                 wcsCACHE=(wchar_t*)input;
     
396.                 wLEN=inputSIZE/2+1;
     
397.                 goto TOMCS;
     
398.         }
     
399. 
     
400.         //输入代码页 过渡到 UNICODE中转代码页
     
401.         wLEN=MultiByteToWideChar(inPAGE, 0, (char*)input,-1, NULL, 0);
     
402.         if(wLEN <1)
     
403.         {
     
404.                 _ftprintf(stderr, _T("Unable to convert code page\n"));
     
405.                 exit(1);
     
406.         }
     
407.         wcsCACHE=(wchar_t*)malloc(wLEN * sizeof(wchar_t));
     
408.         MultiByteToWideChar(inPAGE, 0, (char*)input, -1, wcsCACHE, wLEN);
     
409. 
     
410. TOMCS:
     
411.         //针对UCS-2输出代码页
     
412.         if(outPAGE == 1200)
     
413.         {
     
414.                 outDATA=(BYTE*)wcsCACHE, oLEN=(wLEN-1)*2;
     
415.                 return;
     
416.         }
     
417.         if(outPAGE == 1201)
     
418.         {
     
419.                 wchar_t* wp=(wchar_t*)wcsCACHE;
     
420.                 while(*wp)
     
421.                 {
     
422.                         *wp = (((*wp)&0x00FF)<<8)|(((*wp)&0xFF00)>>8);
     
423.                         wp ++;
     
424.                 }
     
425.                 outDATA=(BYTE*)wcsCACHE, oLEN=(wLEN-1)*2;
     
426.                 return;
     
427.         }
     
428. 
     
429.         //UNICODE中转代码页 过渡到 输出代码页
     
430.         int uLEN=WideCharToMultiByte(outPAGE, 0, wcsCACHE, -1, NULL, 0, NULL, NULL);
     
431.         if(uLEN <1)
     
432.         {
     
433.                 _ftprintf(stderr, _T("Unable to convert code page\n"));
     
434.                 exit(1);
     
435.         }
     
436.         outCACHE=(char*)malloc(uLEN);
     
437.         WideCharToMultiByte(outPAGE, 0, wcsCACHE, -1, outCACHE, uLEN, NULL, NULL);
     
438. 
     
439.         outDATA=(BYTE*)outCACHE, oLEN=uLEN-1;
     
440.         return;
     
441. }
     
442. 
     
443. //文本转化核心
     
444. bool ConveTextFile(TCHAR* inFILE, TCHAR* outFILE, int inPAGE, int outPAGE, int skipNUMBER, int binBOM_SIZE, BYTE* tainerBOM_BIN)
     
445. {
     
446.         //读取输入文件
     
447.         FILE* inFP=_tfopen(inFILE, _T("rb"));
     
448.         if(inFP == NULL)
     
449.         {
     
450.                 _ftprintf(stderr, _T("Open input file error\n"));
     
451.                 exit(1);
     
452.         }
     
453. 
     
454.         //获取字典文件尺寸
     
455.         fseek(inFP, 0, SEEK_END);
     
456.         int fsize = ftell(inFP);
     
457.         if(fsize > MAX_FILE_SIZE)
     
458.         {
     
459.                 _ftprintf(stderr, _T("The input file is too large, can not be greater than %dKB\n"), MAX_FILE_SIZE/1024);
     
460.                 exit(1);
     
461.         }
     
462. 
     
463.         fseek(inFP, (long)skipNUMBER, SEEK_SET);
     
464. 
     
465.         //动态分配文本容器
     
466.         BYTE* inDATA=(BYTE*)malloc(fsize+1);
     
467. 
     
468.         //将文本流读入内存
     
469.         int readSIZE=fsize-skipNUMBER;
     
470.         fread(inDATA, sizeof(BYTE), readSIZE, inFP);
     
471.         fclose(inFP);
     
472.         inDATA[fsize-skipNUMBER]='\0';
     
473. 
     
474.         //转化代码页
     
475.         int oLEN=0;
     
476.         BYTE* outDATA=NULL;
     
477. 
     
478.         //调用代码页转换函数
     
479.         PageTurnAround(inDATA, readSIZE, inPAGE, outPAGE, outDATA, oLEN);
     
480. 
     
481.         if(oLEN <1)
     
482.         {
     
483.                 return false;
     
484.         }
     
485. 
     
486.         //读取输出文件
     
487.         FILE* outFP=_tfopen(outFILE, _T("wb"));
     
488.         if(outFP == NULL)
     
489.         {
     
490.                 _ftprintf(stderr, _T("Open output file error\n"));
     
491.                 exit(1);
     
492.         }
     
493. 
     
494.         fwrite(tainerBOM_BIN, sizeof(BYTE), binBOM_SIZE, outFP);
     
495.         fwrite(outDATA, sizeof(BYTE), oLEN, outFP);
     
496.         fclose(outFP);
     
497. 
     
498.         free(inDATA);
     
499.         return true;
     
500. }
     
501. 
     
502. #if defined _MSC_VER
     
503. #else
     
504. extern "C"
     
505. #endif
     
506. 
     
507. //*************MAIN主函数入口*************/
     
508. int _tmain(int argc, TCHAR** argv)
     
509. {
     
510.         if(argc<2)
     
511.         {
     
512.                 //无参数则退出
     
513.                 _ftprintf(stdout, HELP_INFORMATION);
     
514.                 return 0;
     
515.         }
     
516. 
     
517.         //设置传入参数
     
518.         TCHAR *opeOUTFILE=NULL,  *opeINFILE=NULL;
     
519.         int    opeIN_PAGE=CP_ACP, opeOUT_PAGE=CP_ACP, opeSKIP_NUMBER=0, opeBOM_SIZE=0;
     
520.         BYTE   opeFLAG=0x00, *pTAINER=NULL, tainerBOM_BIN[BOMS_SIZE]= {0};
     
521. 
     
522.         //开关解析
     
523.         int K=_OPT_TEOF;
     
524.         while( (K=_tgetopt(argc, argv, (TCHAR*)_T("f:t:s:b:o:hF:T:S:B:O:H"))) != _OPT_TEOF)
     
525.         {
     
526.                 switch(K)
     
527.                 {
     
528.                 case _T('f'):
     
529.                 case _T('F'):
     
530.                         opeIN_PAGE =_tgetCP(OPTARG);
     
531.                         if(opeIN_PAGE == -1)
     
532.                         {
     
533.                                 _ftprintf(stderr, _T("The switch '-f' needs a positive number\n"));
     
534.                                 exit(1);
     
535.                         }
     
536.                         opeFLAG |= 0x01;
     
537.                         break;
     
538.        
     
539.                 case _T('t'):
     
540.                 case _T('T'):
     
541.                         opeOUT_PAGE =_tgetCP(OPTARG);
     
542.                         if(opeIN_PAGE == -1)
     
543.                         {
     
544.                                 _ftprintf(stderr, _T("The switch '-t' needs a positive number\n"));
     
545.                                 exit(1);
     
546.        
     
547.                         }
     
548.                         opeFLAG |= 0x02;
     
549.                         break;
     
550.        
     
551.                 case _T('s'):
     
552.                 case _T('S'):
     
553.                         if(OPTARG == NULL)
     
554.                         {
     
555.                                 _ftprintf(stderr, _T("The switch '-s' needs a positive number\n"));
     
556.                                 exit(1);
     
557.                         }
     
558.                         opeSKIP_NUMBER = _ttoi((TCHARFORMAT*)OPTARG);
     
559.                         if(! (0<= opeSKIP_NUMBER && opeSKIP_NUMBER <=4 ) )
     
560.                         {
     
561.                                 _ftprintf(stderr, _T("The switch '-s' needs a number between {0,4}\n"));
     
562.                                 exit(1);
     
563.                         }
     
564.                         opeFLAG |= 0x04;
     
565.                         break;
     
566.        
     
567.                 case _T('b'):
     
568.                 case _T('B'):
     
569.                         if(OPTARG != NULL && _tcslen(OPTARG) <= 8)
     
570.                         {
     
571.                                 _ftprintf(stderr, _T("The switch '-b' needs binary number\n"));
     
572.                                 exit(1);
     
573.                         }
     
574.                         pTAINER=(BYTE*)tainerBOM_BIN;
     
575.                         opeBOM_SIZE = TCHARRAY2BIN(OPTARG, pTAINER);
     
576.                         opeFLAG |= 0x08;
     
577.                         break;
     
578.        
     
579.                 case _T('o'):
     
580.                 case _T('O'):
     
581.                         if(OPTARG != NULL)
     
582.                         {
     
583.                                 opeFLAG |= 0x10;
     
584.                                 opeOUTFILE = OPTARG;
     
585.                         }
     
586.                         break;
     
587.        
     
588.                 case _T('h'):
     
589.                 case _T('H'):
     
590.                         _ftprintf(stdout, HELP_INFORMATION);
     
591.                         return 0;
     
592.        
     
593.                 case _OPT_TILL:
     
594.                         //第一个无选项的参数识别为输入名
     
595.                         opeINFILE = argv[UNOPTIND];
     
596.                         break;
     
597.        
     
598.                 case _OPT_TERR:
     
599.                         _ftprintf(stderr, _T("Extra parameters "%s"\n"), argv[OPTIND]);
     
600.                         exit(1);
     
601.        
     
602.                 default:
     
603.                         _ftprintf(stderr, _T("Unknown switch '-%c'\n"), K);
     
604.                         exit(1);
     
605.                 }
     
606.         }
     
607. 
     
608.         //无输入，强制退出
     
609.         if(opeINFILE == NULL)
     
610.         {
     
611.                 _ftprintf(stderr, _T("Needs input file name\n"));
     
612.                 exit(1);
     
613.         }
     
614. 
     
615.         //无输出，强制覆盖
     
616.         if(opeOUTFILE == NULL)
     
617.         {
     
618.                 opeOUTFILE=opeINFILE;
     
619.         }
     
620. 
     
621.         //无参数，SKIP智能偏移
     
622.         if((opeFLAG&0x04) == 0)
     
623.         {
     
624. 
     
625.                 FILE* inFP=_tfopen(opeINFILE, _T("rb"));
     
626.                 if(inFP == NULL)
     
627.                 {
     
628.                         _ftprintf(stderr, _T("Open input file error\n"));
     
629.                         exit(1);
     
630.                 }
     
631.                 fread(tainerBOM_BIN, sizeof(BYTE), BOMS_SIZE, inFP);
     
632.                 fclose(inFP);
     
633. 
     
634.                 UINT uBOM_VALUE = BOM2UINT(tainerBOM_BIN);
     
635. 
     
636.                 //倒序识别BOM
     
637.                 switch(uBOM_VALUE)
     
638.                 {
     
639.                 case 0xFFFE0000:
     
640.                 case 0x0000FEFF:
     
641.                 case 0x2B2F7638:
     
642.                 case 0x84319533:
     
643.                         opeSKIP_NUMBER = 4;
     
644.                         break;
     
645. 
     
646.                 default:
     
647.                         if(
     
648.                             (uBOM_VALUE>>16) == 0xFFFE ||
     
649.                             (uBOM_VALUE>>16) == 0xFEFF
     
650.                         )
     
651.                         {
     
652.                                 opeSKIP_NUMBER = 2;
     
653.                         }
     
654.                         else if((uBOM_VALUE>>8) == 0xEFBBBF)
     
655.                         {
     
656.                                 opeSKIP_NUMBER = 3;
     
657.                         }
     
658.                         else
     
659.                         {
     
660.                                 opeSKIP_NUMBER = 0;
     
661.                         }
     
662.                         break;
     
663.                 }
     
664.         }
     
665. 
     
666.         //无参数，BOM自动修正
     
667.         if((opeFLAG&0x08) == 0)
     
668.         {
     
669.                 TCHAR* tcsBIN =_T("");
     
670.                 switch(opeOUT_PAGE)
     
671.                 {
     
672.                 case 1200:
     
673.                         tcsBIN =_T("0xFFFE");
     
674.                         break;
     
675. 
     
676.                 case 1201:
     
677.                         tcsBIN =_T("0xFEFF");
     
678.                         break;
     
679. 
     
680.                 case 12000:
     
681.                         tcsBIN =_T("0xFFFE0000");
     
682.                         break;
     
683. 
     
684.                 case 12001:
     
685.                         tcsBIN =_T("0x0000FEFF");
     
686.                         break;
     
687. 
     
688.                 case 65001:
     
689.                         tcsBIN =_T("0xEFBBBF");
     
690.                         break;
     
691. 
     
692.                 case 65007:
     
693.                         tcsBIN =_T("0x2B2F7638");
     
694.                         break;
     
695. 
     
696.                 case 54936:
     
697.                         tcsBIN =_T("0x84319533");
     
698.                         break;
     
699. 
     
700.                 default:
     
701.                         break;
     
702.                 }
     
703. 
     
704.                 //填充BOM缓存
     
705.                 pTAINER = (BYTE*)tainerBOM_BIN;
     
706.                 opeBOM_SIZE = TCHARRAY2BIN(tcsBIN, pTAINER);
     
707.         }
     
708. 
     
709.         //执行代码页转化
     
710.         if(! ConveTextFile(opeINFILE, opeOUTFILE, opeIN_PAGE, opeOUT_PAGE, opeSKIP_NUMBER, opeBOM_SIZE, tainerBOM_BIN))
     
711.         {
     
712.                 _ftprintf(stderr, _T("Conver file error\n"));
     
713.                 return 1;
     
714.         }
     
715. 
     
716.         return 0;
     
717. }
     

复制代码

3518228042

演示下将本地的目录“小说”目录下的所有网页转换成txt，
希望可以做到去除非段落换行，比如浏览器打开网页文件显示：
脸
　　
色当即羞红了起来
网页代码应该去除两个<br/>　　<br/>及之间的内容：
“脸<br/>　　<br/>色当即羞红了起来”替换成“脸色当即羞红了起来”

如果<br/>　　<br/>左边有中文右边有正规的段落换行(全角半角空格多个)，不希望替换；
如果<br/>　　<br/>左边有中文右边有中文，必须替换；
如果<br/>　　<br/>左边第一个字是，、“：；，必须替换；
如果<br/>　　<br/>右边是，。、“”：；！？…，必须替换；
如果<br/>　　<br/>左边第一个字是。？！”……右边是……不希望替换；
如果<br/>　　<br/>左边是：右边是“必须替换；

还有有时候所有的换行不是<br/>　　<br/>而是</P><P>、<br/><br/>或
<br/>
<br/>

最后提取标题和<br/>之间内容，自定义的替换广告内容，和对多个空字符换行被清理掉，变成干净的ANSI文本

我这里有几个测试网页

happy886rr

回复 2# 3518228042
建议直接用sed，处理这些最好用脚本和正则。当然，C语言也能做，但是代码将会很繁琐。