正则文本查找工具rf.exe

happy886rr

[2016/11/30]修复了ansi编码下/G:开关的漏洞，不作版本号提升，不作重新编译，只在核心源码中作了更新。

RF.EXE
-----------------------------------------------------------------------------
取代find、findstr的正则查找工具，智能识别文本编码，自动判断BOM类型。原生支持
ANSI、UTF8、Unicode、Unicode big endian编码。准确识别有无BOM类型。

支持pcre正则表达式查找、精确字符串查找，多种开关，完全模仿微软findstr的开关及
使用方法。具体用法与findstr大同小异，请自行品味。

源码完全开放，gcc、tcc均可编译。VC稍加修改亦能通过。
-----------------------------------------------------------------------------
COPYRIGHT@2016~2018 BY HAPPY, VERSION 1.0
REGEX FIND TOOLS
-----------------------------------------------------------------------------
rf [/F|/N|/V] [/S:[match string]     ]|
              [/R:[pcre expression]  ]|
              [/G:[ANSI strings file]] [txtfile]
-----------------------------------------------------------------------------
   /H  Show help information
   /F  Finds the line to which matches
   /N  Print the line number
   /V  Shows all rows that do not contain matching regulars
   /S: Finds the line to which the string matches
   /R: Finds the line to which the regular expression matches
   /G: Gets the matching strings from a ANSI strings file
-----------------------------------------------------------------------------
                                                                   11/06/2016

图片存为a.zip解压即是


核心代码：

1. /*
   
2.         REGEX FIND TOOLS, VERSION 1.0
   
3.         RF.EXE
   
4.         COPYRIGHT@2016~2018 BY HAPPY
   
5. */
   
6. //静态编译（pcre）
   
7. #define PCRE_STATIC
   
8. #include    "pcre.h"
   
9. #include   <stdio.h>
   
10. #include  <string.h>
    
11. #include  <locale.h>
    
12. #include <stdbool.h>
    
13. #include <windows.h>
    
14. 
    
15. //定义行长（字节）
    
16. #define BUFF_SIZE 4096
    
17. //检测阈值（字节）
    
18. #define CHECK_SIZE 16383
    
19. 
    
20. //基础函数群
    
21. char* UnicodeToANSI(const wchar_t* Str)
    
22. {
    
23.         int L=WideCharToMultiByte(CP_ACP, 0, Str, -1, NULL, 0, NULL, NULL);
    
24.         char* Out=(char *)calloc(L+1, sizeof(char));
    
25.         WideCharToMultiByte(CP_ACP, 0, Str, -1, Out, L, NULL, NULL);
    
26.         return Out;
    
27. }
    
28. wchar_t* UTF8ToUnicode(const char* Str)
    
29. {
    
30.         int L=MultiByteToWideChar(CP_UTF8, 0, Str,-1, NULL, 0);
    
31.         wchar_t* Out=(wchar_t *)calloc(L+1, sizeof(wchar_t));
    
32.         MultiByteToWideChar(CP_UTF8, 0, Str, -1, (LPWSTR)Out, L);
    
33.         return Out;
    
34. }
    
35. bool isUTF8(const char* Str)
    
36. {
    
37.         if(!Str){
    
38.                 return false;
    
39.         }
    
40.         const unsigned char* bytes=(const unsigned char *)Str;
    
41.         while(*bytes){
    
42.                 if(
    
43.                         (
    
44.                                  bytes[0]<=0x7F ||
    
45.                                 bytes[0]==0x09 ||
    
46.                                 bytes[0]==0x0A ||
    
47.                                 bytes[0]==0x0D ||
    
48.                                 (0x20<=bytes[0] && bytes[0]<=0x7E)
    
49.                         )
    
50.                 ){
    
51.                         bytes+=1;
    
52.                         continue;
    
53.                 }
    
54.                 if(
    
55.                          (
    
56.                                 (0xC2<=bytes[0] && bytes[0]<=0xDF) &&
    
57.                                 (0x80<=bytes[1] && bytes[1]<=0xBF)
    
58.                         )
    
59.                 ){
    
60.                         bytes+=2;
    
61.                         continue;
    
62.                 }
    
63.                 if(
    
64.                         (
    
65.                                                   (bytes[0]==0xE0) &&
    
66.                                 (0xA0<=bytes[1] && bytes[1]<=0xBF) &&
    
67.                                 (0x80<=bytes[2] && bytes[2]<=0xBF)
    
68.                         ) ||
    
69.                         (
    
70.                                 (
    
71.                                         (0xE1<=bytes[0] && bytes[0]<=0xEC)||
    
72.                                                            bytes[0]==0xEE ||
    
73.                                                            bytes[0]==0xEF
    
74.                                                                  ) &&
    
75.                                 (0x80<=bytes[1] && bytes[1]<=0xBF) &&
    
76.                                 (0x80<=bytes[2] && bytes[2]<=0xBF)
    
77.                         ) ||
    
78.                         (
    
79.                                                   (bytes[0]==0xED) &&
    
80.                                 (0x80<=bytes[1] && bytes[1]<=0x9F) &&
    
81.                                 (0x80<=bytes[2] && bytes[2]<=0xBF)
    
82.                         )
    
83.                 ){
    
84.                         bytes+=3;
    
85.                         continue;
    
86.                 }
    
87.                 if(
    
88.                         (
    
89.                                                   (bytes[0]==0xF0) &&
    
90.                                 (0x90<=bytes[1] && bytes[1]<=0xBF) &&
    
91.                                 (0x80<=bytes[2] && bytes[2]<=0xBF) &&
    
92.                                 (0x80<=bytes[3] && bytes[3]<=0xBF)
    
93.                         ) ||
    
94.                         (
    
95.                                 (0xF1<=bytes[0] && bytes[0]<=0xF3) &&
    
96.                                 (0x80<=bytes[1] && bytes[1]<=0xBF) &&
    
97.                                 (0x80<=bytes[2] && bytes[2]<=0xBF) &&
    
98.                                 (0x80<=bytes[3] && bytes[3]<=0xBF)
    
99.                         ) ||
    
100.                         (
     
101.                                                   (bytes[0]==0xF4) &&
     
102.                                 (0x80<=bytes[1] && bytes[1]<=0x8F) &&
     
103.                                 (0x80<=bytes[2] && bytes[2]<=0xBF) &&
     
104.                                 (0x80<=bytes[3] && bytes[3]<=0xBF)
     
105.                         )
     
106.                 ){
     
107.                         bytes+=4;
     
108.                         continue;
     
109.                 }
     
110.                 return false;
     
111.         }
     
112.         return true;
     
113. }
     
114. 
     
115. //BOM检测
     
116. int CheckBom(FILE* fp)
     
117. {
     
118.         unsigned char* buf=(unsigned char*)calloc(3,sizeof(unsigned char));
     
119.         unsigned char* buf2;
     
120.         fseek(fp, 0, SEEK_SET);
     
121.         fread(buf, sizeof(unsigned char), 3, fp);
     
122.              if(buf[0]==0xEF && buf[1]==0xBB && buf[2]==0xBF){return 3;}
     
123.         else if(buf[0]==0xFF && buf[1]==0xFE){return 5;}
     
124.         else if(buf[0]==0xFE && buf[1]==0xFF){return 6;}
     
125.         else{
     
126.                 fseek(fp, 0, SEEK_SET);
     
127.                 buf2=(unsigned char*)calloc(CHECK_SIZE,sizeof(unsigned char));
     
128.                 fread(buf2, sizeof(unsigned char), CHECK_SIZE, fp);
     
129.                 if(isUTF8(buf2)){
     
130.                         free(buf2);
     
131.                         return 2;
     
132.                 }
     
133.                 free(buf2);
     
134.         }
     
135.         return 1;
     
136. }
     
137. 
     
138. //正则查找函数
     
139. int RFindLine(FILE* fp, char* src, int FLAG)
     
140. {
     
141.         bool mode=false;
     
142.         int BOM=0, EN=0, i=0, n=0;
     
143.         FILE* sp;
     
144.         char* Li=(char *)malloc(BUFF_SIZE*sizeof(char));
     
145.         char* LineV;char* LineU;
     
146.         pcre  *re;
     
147.         int erroffset, ovector[30], rc;
     
148.         const char *error;
     
149. 
     
150.         if      ( (FLAG&0x0F)==0x02 ){
     
151.                 pcre_compile(src, 0, &error, &erroffset, NULL);
     
152.                 if( (re=pcre_compile(src, 0, &error, &erroffset, NULL)) == NULL ){
     
153.                         fputs("PCRE compilation failed", stderr);
     
154.                         exit(1);
     
155.                 }
     
156.         }else if( (FLAG&0x0F)==0x03 ){
     
157.                 if( (sp=fopen(src, "rb"))==NULL ){
     
158.                         fputs("Read matching failed", stderr);
     
159.                         exit(1);
     
160.                 }       
     
161.         }
     
162.         //BOM偏移值
     
163.         BOM=CheckBom(fp);
     
164.         if      (BOM==1 || BOM==2){
     
165.                 EN=0;
     
166.         }else if(BOM==5 || BOM==6){
     
167.                 EN=2;
     
168.         }else if(BOM==3){
     
169.                 EN=3;
     
170.         }
     
171.         //执行偏移值
     
172.         fseek(fp, EN, SEEK_SET);
     
173.         //执行匹配过程
     
174.         if(BOM==1){
     
175.                 char* Line=(char *)malloc(BUFF_SIZE*sizeof(char));
     
176.                 while(!feof(fp)){
     
177.                         memset(Line, 0, BUFF_SIZE*sizeof(char));
     
178.                         fgets(Line, BUFF_SIZE, fp);
     
179.                         i++;
     
180.                         if      ( (FLAG&0x0F)==0x01 ){
     
181.                                 if( strstr(Line, src)!=NULL ){
     
182.                                         mode=true;
     
183.                                 }else{
     
184.                                         mode=false;
     
185.                                 }
     
186.                         }else if( (FLAG&0x0F)==0x02 ){
     
187.                                 if( pcre_exec(re, NULL, Line, strlen(Line), 0, 0, ovector, 30) >= 0 ){
     
188.                                         mode=true;
     
189.                                 }else{
     
190.                                         mode=false;
     
191.                                 }
     
192.                         }else if( (FLAG&0x0F)==0x03 ){
     
193.                                 mode=false;
     
194.                                 fseek(sp, 0, SEEK_SET);
     
195.                                 while(!feof(sp)){
     
196.                                         memset(Li, 0, BUFF_SIZE*sizeof(char));
     
197.                                         fgets(Li, BUFF_SIZE, sp);
     
198.                                         char* tp=Li;
     
199.                                         while(*tp=='\t' ||*tp==' ' ||*tp=='\r' ||*tp=='\n'){tp++;}
     
200.                                         int tp_LEN=strlen(tp);
     
201.                                         tp[tp_LEN-2]=(tp[tp_LEN-2]=='\r')?'\0':tp[tp_LEN-2];
     
202.                                         if(tp[0]!='\0' &&strstr(Line, tp)!=NULL){
     
203.                                                 mode=true;
     
204.                                                 break;
     
205.                                         }
     
206.                                 }
     
207.                         }
     
208.                         //输出显示
     
209.                         if( (FLAG>>4)==0x03 && mode==true ){
     
210.                                         fprintf(stdout, "%d:%s", i, Line);
     
211.                         }else if(
     
212.                                         ((FLAG>>4)==0x02 && mode==false)||
     
213.                                         ((FLAG>>4)==0x01 && mode==true )
     
214.                         ){
     
215.                                 fputs(Line, stdout);
     
216.                         }
     
217.                 }
     
218.         }else if(BOM==2 || BOM==3){
     
219.                 char* Line=(char *)malloc(BUFF_SIZE*sizeof(char));
     
220.                 while(!feof(fp)){
     
221.                         memset(Line, 0, BUFF_SIZE*sizeof(char));
     
222.                         fgets(Line, BUFF_SIZE, fp);
     
223.                         i++;
     
224.                         if(BOM>1){LineU=UnicodeToANSI(UTF8ToUnicode(Line));}
     
225.                         if      ( (FLAG&0x0F)==0x01 ){
     
226.                                 if( strstr(LineU, src)!=NULL ){
     
227.                                         mode=true;
     
228.                                 }else{
     
229.                                         mode=false;
     
230.                                 }
     
231.                         }else if( (FLAG&0x0F)==0x02 ){
     
232.                                 if( pcre_exec(re, NULL, LineU, strlen(LineU), 0, 0, ovector, 30) >= 0 ){
     
233.                                         mode=true;
     
234.                                 }else{
     
235.                                         mode=false;
     
236.                                 }
     
237.                         }else if( (FLAG&0x0F)==0x03 ){
     
238.                                 fseek(sp, 0, SEEK_SET);
     
239.                                 while(!feof(sp)){
     
240.                                         memset(Li, 0, BUFF_SIZE*sizeof(char));
     
241.                                         fgets(Li, BUFF_SIZE, sp);
     
242.                                         if( strstr(LineU, Li)!=NULL ){
     
243.                                                 mode=true;
     
244.                                                 break;
     
245.                                         }
     
246.                                 }
     
247.                         }
     
248.                         //输出显示
     
249.                         if( (FLAG>>4)==0x03 && mode==true ){
     
250.                                         fprintf(stdout, "%d:%s", i, LineU);
     
251.                         }else if(
     
252.                                         ((FLAG>>4)==0x02 && mode==false)||
     
253.                                         ((FLAG>>4)==0x01 && mode==true )
     
254.                         ){
     
255.                                 fputs(LineU, stdout);
     
256.                         }
     
257.                 }
     
258.         }else if(BOM==5){               //Unicode
     
259.                 wchar_t* LineW=(wchar_t *)calloc(BUFF_SIZE, sizeof(wchar_t));
     
260.                 while(!feof(fp)){
     
261.                         memset(LineW, 0, BUFF_SIZE*sizeof(wchar_t));
     
262.                         fgetws(LineW, BUFF_SIZE, fp);
     
263.                         i++;
     
264.                         LineV=UnicodeToANSI(LineW);
     
265.                         if      ( (FLAG&0x0F)==0x01 ){
     
266.                                 if( strstr(LineV, src)!=NULL ){
     
267.                                         mode=true;
     
268.                                 }else{
     
269.                                         mode=false;
     
270.                                 }
     
271.                         }else if( (FLAG&0x0F)==0x02 ){
     
272.                                 if( pcre_exec(re, NULL, LineV, strlen(LineV), 0, 0, ovector, 30) >= 0 ){
     
273.                                         mode=true;
     
274.                                 }else{
     
275.                                         mode=false;
     
276.                                 }
     
277.                         }else if( (FLAG&0x0F)==0x03 ){
     
278.                                 fseek(sp, 0, SEEK_SET);
     
279.                                 while(!feof(sp)){
     
280.                                         memset(Li, 0, BUFF_SIZE*sizeof(char));
     
281.                                         fgets(Li, BUFF_SIZE, sp);
     
282.                                         if( strstr(LineV, Li)!=NULL ){
     
283.                                                 mode=true;
     
284.                                                 break;
     
285.                                         }
     
286.                                 }
     
287.                         }
     
288.                         if      ( (FLAG>>4)==0x03 && mode==true ){
     
289.                                 fprintf(stdout, "%d:%s", i, LineV);
     
290.                         }else if(
     
291.                                         ((FLAG>>4)==0x02 && mode==false)||
     
292.                                         ((FLAG>>4)==0x01 && mode==true )
     
293.                         ){
     
294.                                 fputs(LineV, stdout);
     
295.                         }
     
296.                 }
     
297.         }else if(BOM==6){               //Unicode big endian
     
298.                 wchar_t* LineW=(wchar_t *)calloc(BUFF_SIZE, sizeof(wchar_t));
     
299.                 while(!feof(fp)){
     
300.                         memset(LineW, 0, BUFF_SIZE*sizeof(wchar_t));
     
301.                         fgets(LineW, BUFF_SIZE, fp);
     
302.                         i++;
     
303.                         for(n=0;LineW[n]!=0x0000;n++){
     
304.                                 LineW[n]=(LineW[n]&0x00FF)<<8|(LineW[n]&0xFF00)>>8;
     
305.                         }
     
306.                         LineV=UnicodeToANSI(LineW);
     
307.                         if      ( (FLAG&0x0F)==0x01 ){
     
308.                                 if( strstr(LineV, src)!=NULL ){
     
309.                                         mode=true;
     
310.                                 }else{
     
311.                                         mode=false;
     
312.                                 }
     
313.                         }else if( (FLAG&0x0F)==0x02 ){
     
314.                                 if( pcre_exec(re, NULL, LineV, strlen(LineV), 0, 0, ovector, 30) >= 0 ){
     
315.                                         mode=true;
     
316.                                 }else{
     
317.                                         mode=false;
     
318.                                 }
     
319.                         }else if( (FLAG&0x0F)==0x03 ){
     
320.                                 fseek(sp, 0, SEEK_SET);
     
321.                                 while(!feof(sp)){
     
322.                                         memset(Li, 0, BUFF_SIZE*sizeof(char));
     
323.                                         fgets(Li, BUFF_SIZE, sp);
     
324.                                         if( strstr(LineV, Li)!=NULL ){
     
325.                                                 mode=true;
     
326.                                                 break;
     
327.                                         }
     
328.                                 }
     
329.                         }
     
330.                         if      ( (FLAG>>4)==0x03 && mode==true ){
     
331.                                 fprintf(stdout, "%d:%s", i, LineV);
     
332.                         }else if(
     
333.                                         ((FLAG>>4)==0x02 && mode==false)||
     
334.                                         ((FLAG>>4)==0x01 && mode==true )
     
335.                         ){
     
336.                                 fputs(LineV, stdout);
     
337.                         }
     
338.                 }
     
339.         }
     
340.         fflush(stdout);
     
341.         if( (FLAG&0x0F)==0x02 ){pcre_free(re);}
     
342.         free(Li);
     
343.         return 0;
     
344. }
     
345. 
     
346. //帮助信息
     
347. void Help_Info(FILE* stream, int Exit_Code)
     
348. {
     
349.         fprintf(stream,
     
350.                 "COPYRIGHT@2016~2018 BY HAPPY, VERSION 1.0\n"
     
351.                 "REGEX FIND TOOLS\n"
     
352.                 "-----------------------------------------------------------------------------\n"
     
353.                 "rf [/F|/N|/V] [/S:[match string]     ]|\n"
     
354.                 "              [/R:[pcre expression]  ]|\n"
     
355.                 "              [/G:[ANSI strings file]] [txtfile]\n"
     
356.                 "-----------------------------------------------------------------------------\n"
     
357.                 "   /H  Show help information\n"
     
358.                 "   /F  Finds the line to which matches\n"
     
359.                 "   /N  Print the line number\n"
     
360.                 "   /V  Shows all rows that do not contain matching regulars\n"
     
361.                 "   /S: Finds the line to which the string matches\n"
     
362.                 "   /R: Finds the line to which the regular expression matches\n"
     
363.                 "   /G: Gets the matching strings from a ANSI strings file\n"
     
364.                 "-----------------------------------------------------------------------------\n"
     
365.                 "                                                                   11/06/2016\n"
     
366.         );
     
367.         exit(Exit_Code);
     
368. }
     
369. 
     
370. //主函数入口
     
371. int main(int argc, char** argv)
     
372. {
     
373.         FILE* fp;
     
374.         unsigned char FLAG=0;
     
375.         if( (argc==4) && (argv[1][0]=='/') && (argv[2][0]=='/') && (argv[2][2]== ':') ){
     
376.                 switch(argv[1][1]){
     
377.                         case 'F':
     
378.                         case 'f':
     
379.                                 FLAG|=0x10;
     
380.                                 break;
     
381.                         case 'V':
     
382.                         case 'v':
     
383.                                 FLAG|=0x20;
     
384.                                 break;
     
385.                         case 'N':
     
386.                         case 'n':
     
387.                                 FLAG|=0x30;
     
388.                                 break;
     
389.                         default:
     
390.                                 Help_Info(stderr, 2);
     
391.                 }
     
392.                 switch(argv[2][1]){
     
393.                         case 'S':
     
394.                         case 's':
     
395.                                 FLAG|=0x01;
     
396.                                 break;
     
397.                         case 'R':
     
398.                         case 'r':
     
399.                                 FLAG|=0x02;
     
400.                                 break;
     
401.                         case 'G':
     
402.                         case 'g':
     
403.                                 FLAG|=0x03;
     
404.                                 break;
     
405.                         default:
     
406.                                 Help_Info(stderr, 1);
     
407.                 }
     
408.         }else {
     
409.                 Help_Info(stderr, 3);
     
410.         }
     
411. 
     
412.         if( (fp=fopen(argv[3], "rb"))==NULL ){
     
413.                 fputs("Read failed", stderr);
     
414.                 return 3;
     
415.         }
     
416.         RFindLine(fp, argv[2]+3, FLAG);
     
417.         fclose(fp);
     
418.         return 0;
     
419. }
     

复制代码

Bella

又在重复造轮子, 缩进不要超过3层

codegay

回复 2# Bella


    别人的造的轮子是别人的。自己造的轮子才是自己的。

sanmaodo

求教，如何把字符串 “D:\My Documents\Pictures\★★★2016113-154wer52.jpg" 中的文件名用正则表达式提取出来？

我想得到的字符串是这个 “★★2016113-154wer52.jpg”  （注意：文件名少一个 ★ 号）。

正则测试工具用  (?<=★).*  是行的。但不知RF怎么写。

my7213@qq.com

好东西好东西好东西

happy886rr

回复 4# sanmaodo
容易，在rf源码的227行下面添加如下代码。编译成exe即可提取子串。

1. for (int i = 0; i < pcre_exec(re, NULL, Line, strlen(Line), 0, 0, ovector, 30); i++) {
   
2.         char *getkeywords = src + ovector[2*i];
   
3.         printf("%s\n",getkeywords);
   
4. }

复制代码

rf使用pcre正则，因此，你的正则式  (?<=★).*无需更改，直接使用。
rf暂时不开放其他特殊功能，这个模块请自行添加用gcc或tcc编译即可。

sanmaodo

回复 6# happy886rr
非常感谢！

freesoft00

gcc需要在linux中编译，还是可以在windows的gcc就可以？

happy886rr

回复 8# freesoft00
那个图片存为zip格式，必须用winrar软件才能解压，压缩包里有exe文件，不用编译，要编译也只支持windows下的gcc编译。

freesoft00

回复 9# happy886rr

    压缩包里有exe文件

exe不是最新版本呀。

523066680

回复 10# freesoft00


有这一句   #include <windows.h>
当然是 windows

话说没去试就问问题也是服了 。。。

我觉得楼主可以开一个网盘专门分享附件。图片另存-改扩展名-解压 其实也不太方便。

happy886rr

回复 11# 523066680
很好的建议，我之前的好多图片都是外链，那些图片网站只保存半个月，就让我的图片失效了。下回直接整百度网盘吧。

happy886rr

回复 10# freesoft00
也对，编译参数是

1. gcc RF.c -lpcre -L./ -oRF.exe

复制代码

windows下最好用mingw32编译器。使用-O3优化以达到最佳编译效果。后续我将会去开发linux的第三方，之后的第三方我将尽量提供双平台版本以及安卓手机版。

freesoft00

回复 13# happy886rr

https://sourceforge.net/projects/mingw/files/?source=navbar
https://sourceforge.net/projects/mingw-w64/files/?source=navbar
这两个是哪一个。不好意思，对这个不熟悉，所以问的问题比较初级。

523066680

回复 14# freesoft00


    https://nuwen.net/mingw.html

二选一
mingw-14.0.exe
mingw-14.0-without-git.exe