命令行通配

Arthur.Echo

没有处理转义字符

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. 
   
6. #define TRUE 1
   
7. #define FALSE 0
   
8. 
   
9. 
   
10. int parse_range(char *src,char c)
    
11. {
    
12.         char *p;
    
13.         p = index(src,'-');
    
14.         if(p == NULL)
    
15.         {
    
16.                 if(index(src,c) == NULL)
    
17.                         return FALSE;
    
18.                 else
    
19.                         return TRUE;
    
20.         }
    
21.         else
    
22.         {
    
23.                 int i,j;
    
24.                 i = 0;
    
25.                 j = (int)(p - src);
    
26.                 if(j == 0)
    
27.                 {
    
28.                         if(*(p + 1))
    
29.                         {
    
30.                                 if(*(p + 2))
    
31.                                         return parse_range(p + 2,c);
    
32.                                 else
    
33.                                         return FALSE;
    
34.                         }
    
35.                         else
    
36.                                 return FALSE;
    
37.                 }
    
38.                 else if(j == 1)
    
39.                 {
    
40.                         if((*(p - 1) >= '0' && *(p - 1) <= '9') && (*(p + 1) >= '0' && *(p + 1) <= '9'))
    
41.                         {
    
42.                                 if(c >= *(p - 1) && c <= *(p + 1))
    
43.                                         return TRUE;
    
44.                                 else if(*(p + 2))
    
45.                                         return parse_range(p + 2,c);
    
46.                                 else
    
47.                                         return FALSE;
    
48.                         }
    
49.                         else if((*(p - 1) >= 'a' && *(p - 1) <= 'z') && (*(p + 1) >= 'a' && *(p + 1) <= 'z'))
    
50.                         {
    
51.                                 if(c >= *(p - 1) && c <= *(p + 1))
    
52.                                         return TRUE;
    
53.                                 else if(*(p + 2))
    
54.                                          return parse_range(p + 2,c);
    
55.                                 else
    
56.                                         return FALSE;
    
57.                         }
    
58.                         else if((*(p - 1) >= 'A' && *(p - 1) <= 'Z') && (*(p + 1) >= 'A' && *(p + 1) <= 'Z'))
    
59.                         {
    
60.                                 if(c >= *(p - 1) && c <= *(p + 1))
    
61.                                         return TRUE;
    
62.                                 else if(*(p + 2))
    
63.                                          return parse_range(p + 2,c);
    
64.                                 else
    
65.                                         return FALSE;
    
66.                         }
    
67.                         else if(*(p + 1))
    
68.                         {
    
69.                                 if(*(p + 2))
    
70.                                         return parse_range(p + 2,c);
    
71.                                 else
    
72.                                         return FALSE;
    
73.                         }
    
74.                         else
    
75.                                 return FALSE;
    
76.                        
    
77.                 }
    
78.                 else   // j >= 2
    
79.                 {
    
80.                         while(i < j -1)
    
81.                         {
    
82.                                 if(src[i] == c)
    
83.                                         return TRUE;
    
84.                                 else
    
85.                                         i++;
    
86.                         }
    
87. 
    
88.                         return parse_range(p - 1,c);       
    
89.                 }
    
90.         }
    
91. }
    
92. 
    
93. int parse_wildcard(char *src,char *dst)
    
94. {
    
95.         int head_d = 0,head_s = 0,i,j;
    
96.         char *ptr,ascii[128];
    
97. 
    
98.         while(1)
    
99.         {
    
100.                 switch(dst[head_d])
     
101.                 {
     
102.                         case 'X':        if(src[head_s] <= '9' && src[head_s] >= '0')
     
103.                                         {
     
104.                                                 head_d++;
     
105.                                                 head_s++;
     
106.                                                 break;
     
107.                                         }
     
108.                                         else
     
109.                                                 return FALSE;
     
110. 
     
111.                         case 'Z':        if(src[head_s] <= '9' && src[head_s] >= '1')
     
112.                                         {
     
113.                                                 head_d++;
     
114.                                                 head_s++;
     
115.                                                 break;
     
116.                                         }
     
117.                                         else
     
118.                                                 return FALSE;
     
119.        
     
120.                         case 'N':       if(src[head_s] <= '9' && src[head_s] >= '2')
     
121.                                         {
     
122.                                                 head_d++;
     
123.                                                 head_s++;
     
124.                                                 break;
     
125.                                         }
     
126.                                         else
     
127.                                                 return FALSE;
     
128. 
     
129.                         case '[':        ptr = index(&dst[head_d],']');
     
130.                                         if(ptr)
     
131.                                         {
     
132.                                                 if(!((src[head_s] >= '0' && src[head_s] <= '9') || (src[head_s] >= 'a' && src[head_s] <= 'z') || (src[head_s] >= 'A' && src[head_s] <= 'Z')))
     
133.                                                                return FALSE;
     
134.                                                 else
     
135.                                                 {
     
136.                                                         bzero(ascii,128);
     
137.                                                         strncpy(ascii,&dst[head_d + 1],(int)(ptr - &dst[head_d]) -1);
     
138.                                                         if (parse_range(ascii, src[head_s]) == FALSE)
     
139.                                                                 return FALSE;
     
140.                                                         else
     
141.                                                         {
     
142.                                                                 head_d = (int)((ptr - dst) + 1);
     
143.                                                                 head_s ++;
     
144.                                                                 break;
     
145.                                                         }
     
146.                                                 }
     
147.                                         }
     
148.                                         else
     
149.                                         {
     
150.                                                 if(dst[head_d] == src[head_s])
     
151.                                                 {
     
152.                                                         head_s++;
     
153.                                                         head_d++;
     
154.                                                         break;
     
155.                                                 }
     
156.                                                 else
     
157.                                                         return FALSE;
     
158.                                         }
     
159. 
     
160. 
     
161.                         case '.':        if(dst[head_d + 1] == '\0' && src[head_s] != '\0')
     
162.                                                 return TRUE;
     
163.                                         else
     
164.                                         {
     
165.                                                 j = 1;
     
166.                                                 while(src[head_s + j])
     
167.                                                 {
     
168.                                                         if(parse_wildcard(&src[head_s + j],&dst[head_d + 1]) == TRUE)
     
169.                                                                 return TRUE;
     
170.                                                         else
     
171.                                                                 j++;
     
172.                                                 }
     
173.                                                 return FALSE;
     
174.                                         }
     
175. 
     
176.                         case '!':        if(dst[head_d + 1] == '\0')
     
177.                                                 return TRUE;
     
178.                                         else
     
179.                                         {
     
180.                                                 i = 0;
     
181.                                                 while(src[head_s + i])
     
182.                                                 {
     
183.                                                         if(parse_wildcard(&src[head_s + i],&dst[head_d + 1]) == TRUE)
     
184.                                                                 return TRUE;
     
185.                                                         else
     
186.                                                                 i++;
     
187.                                                 }
     
188.                                                 return FALSE;
     
189.                                         }               
     
190. 
     
191.                         case '\0':        if(src[head_s] ==  '\0')
     
192.                                                 return TRUE;
     
193.                                         else
     
194.                                                 return FALSE;
     
195. 
     
196.                         //case ']':        return FALSE;
     
197. 
     
198.                         default:        if(src[head_s] == dst[head_d])
     
199.                                         {
     
200.                                                 head_s++;
     
201.                                                 head_d++;
     
202.                                                 break;
     
203.                                         }
     
204.                                         else
     
205.                                                 return FALSE;
     
206.                 }
     
207.         }
     
208. }
     
209. 
     
210. 
     
211. 
     
212. int main(int argc,char **argv)
     
213. {
     
214.         if(parse_wildcard(argv[1],argv[2]) == TRUE)
     
215.                 printf("OK\n");
     
216.         else
     
217.         {
     
218.                 if(!strcmp(argv[1],argv[2]))
     
219.                         printf("OK\n");
     
220.                 else
     
221.                         printf("BAD\n");
     
222.         }
     
223. 
     
224.         return 0;
     
225. }
     
226. 
     

复制代码

jackk294

这个是什么意思阿？
有什么问题呢
还是show你的程序阿？

x11

什么叫命令行通配