ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/libio/string/match.c
Revision: 292
Committed: Mon Dec 5 10:40:18 2005 UTC (20 years, 8 months ago) by michael
Content type: text/x-csrc
File size: 22376 byte(s)
Log Message: 
- Added support for (\) escape character to has_wildcards()

File Contents

# User Rev Content
1 adx 59 /************************************************************************
2     * IRC - Internet Relay Chat, src/match.c
3     * Copyright (C) 1990 Jarkko Oikarinen
4     *
5     * This program is free software; you can redistribute it and/or modify
6     * it under the terms of the GNU General Public License as published by
7     * the Free Software Foundation; either version 1, or (at your option)
8     * any later version.
9     *
10     * This program is distributed in the hope that it will be useful,
11     * but WITHOUT ANY WARRANTY; without even the implied warranty of
12     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13     * GNU General Public License for more details.
14     *
15     * You should have received a copy of the GNU General Public License
16     * along with this program; if not, write to the Free Software
17     * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18     *
19 knight 71 * $Id$
20 adx 59 *
21     */
22    
23     #include "stdinc.h"
24    
25     /* Fix "statement not reached" warnings on Sun WorkShop C */
26     #ifdef __SUNPRO_C
27     # pragma error_messages(off, E_STATEMENT_NOT_REACHED)
28     #endif
29    
30     /* match()
31     *
32     * Compare if a given string (name) matches the given
33     * mask (which can contain wild cards: '*' - match any
34     * number of chars, '?' - match any single character.
35     *
36     * return 1, if match
37     * 0, if no match
38     *
39     * Originally by Douglas A Lewis (dalewis@acsu.buffalo.edu)
40     */
41     int
42     match(const char *mask, const char *name)
43     {
44     const unsigned char* m = (const unsigned char *) mask;
45     const unsigned char* n = (const unsigned char *) name;
46     const unsigned char* ma = NULL;
47     const unsigned char* na = (const unsigned char *) name;
48    
49     assert(mask != NULL);
50     assert(name != NULL);
51    
52     while (1)
53     {
54     if (*m == '*')
55     {
56     /*
57     * XXX - shouldn't need to spin here, the mask should have been
58     * collapsed before match is called
59     */
60     while (*m == '*')
61     m++;
62     ma = m;
63     na = n;
64     }
65    
66     if (!*m)
67     {
68     if (!*n)
69     return 1;
70     if (!ma)
71     return 0;
72     for (m--; (m > (const unsigned char*) mask) && (*m == '?'); m--)
73     ;
74     if (*m == '*')
75     return 1;
76     m = ma;
77     n = ++na;
78     }
79     else if (!*n)
80     {
81     /*
82     * XXX - shouldn't need to spin here, the mask should have been
83     * collapsed before match is called
84     */
85     while (*m == '*')
86     m++;
87     return (*m == 0);
88     }
89    
90     if (ToLower(*m) != ToLower(*n) && *m != '?' && (*m != '#' || !IsDigit(*n)))
91     {
92     if (!ma)
93     return 0;
94     m = ma;
95     n = ++na;
96     }
97     else
98     m++, n++;
99     }
100    
101     return 0;
102     }
103    
104     /* match_esc()
105     *
106     * The match() function with support for escaping characters such
107     * as '*' and '?'
108     */
109     int
110     match_esc(const char *mask, const char *name)
111     {
112     const unsigned char *m = (const unsigned char *) mask;
113     const unsigned char *n = (const unsigned char *) name;
114     const unsigned char *ma = NULL;
115     const unsigned char *na = (const unsigned char *) name;
116    
117     assert(mask != NULL);
118     assert(name != NULL);
119    
120     while (1)
121     {
122     if (*m == '*')
123     {
124     /*
125     * XXX - shouldn't need to spin here, the mask should have been
126     * collapsed before match is called
127     */
128     while (*m == '*')
129     m++;
130     ma = m;
131     na = n;
132     }
133    
134     if (!*m)
135     {
136     if (!*n)
137     return 1;
138     if (!ma)
139     return 0;
140     for (m--; (m > (const unsigned char*) mask) && (*m == '?'); m--)
141     ;
142     if (*m == '*')
143     return 1;
144     m = ma;
145     n = ++na;
146     }
147     else if (!*n)
148     {
149     /*
150     * XXX - shouldn't need to spin here, the mask should have been
151     * collapsed before match is called
152     */
153     while (*m == '*')
154     m++;
155     return (*m == 0);
156     }
157    
158     if (*m != '?' && (*m != '#' || IsDigit(*n)))
159     {
160     if (*m == '\\')
161     if (!*++m)
162     return 0;
163     if (ToLower(*m) != ToLower(*n))
164     {
165     if (!ma)
166     return 0;
167     m = ma;
168     n = ++na;
169     }
170     else
171     m++, n++;
172     }
173     else
174     m++, n++;
175     }
176    
177     return 0;
178     }
179    
180     /* match_chan()
181     *
182     * The match_esc() function doing channel prefix auto-escape,
183     * ie. mask: #blah*blah is seen like \#blah*blah
184     */
185     int
186     match_chan(const char *mask, const char *name)
187     {
188     return *mask ? (*mask == *name && match_esc(mask + 1, name + 1)) : !*name;
189     }
190    
191     static inline int
192     comp_with_mask(void *addr, void *dest, unsigned int mask)
193     {
194     if (memcmp(addr, dest, mask / 8) == 0)
195     {
196     int n = mask / 8;
197     int m = ((-1) << (8 - (mask % 8)));
198    
199     if (mask % 8 == 0 ||
200     (((unsigned char *) addr)[n] & m) == (((unsigned char *) dest)[n] & m))
201     return 1;
202     }
203    
204     return 0;
205     }
206    
207     /* match_cidr()
208     *
209     * Input - mask, address
210     * Output - 1 = Matched 0 = Did not match
211     */
212     int
213     match_cidr(const char *s1, const char *s2)
214     {
215     struct irc_ssaddr ipaddr, maskaddr;
216     char address[NICKLEN + USERLEN + HOSTLEN + 6];
217     char mask[NICKLEN + USERLEN + HOSTLEN + 6];
218     char *ipmask, *ip, *len;
219     int cidrlen, offset;
220     struct addrinfo hints, *res;
221    
222     /* Unlikely to ever overflow, but we may as well be consistant - stu */
223     strlcpy(mask, s1, sizeof(mask));
224     strlcpy(address, s2, sizeof(address));
225    
226     ipmask = strrchr(mask, '@');
227     if (ipmask == NULL)
228     return 0;
229    
230     *ipmask++ = '\0';
231    
232     ip = strrchr(address, '@');
233     if (ip == NULL)
234     return 0;
235     *ip++ = '\0';
236    
237     len = strrchr(ipmask, '/');
238     if (len == NULL)
239     return 0;
240    
241     *len++ = '\0';
242    
243     cidrlen = atoi(len);
244     if (cidrlen == 0)
245     return 0;
246    
247     memset(&hints, 0, sizeof(hints));
248     hints.ai_family = AF_UNSPEC;
249     hints.ai_flags = AI_NUMERICHOST;
250    
251     irc_getaddrinfo(ip, NULL, &hints, &res);
252     if (!res)
253     return 0;
254    
255     #ifdef INET6
256     if (res->ai_family == AF_INET)
257     offset = offsetof(struct sockaddr_in, sin_addr);
258     else if (res->ai_family == AF_INET6)
259     offset = offsetof(struct sockaddr_in6, sin6_addr);
260     else
261     return 0;
262     #else
263     offset = offsetof(struct sockaddr_in, sin_addr);
264     #endif
265    
266     memcpy(&ipaddr, res->ai_addr, res->ai_addrlen);
267     ipaddr.ss_len = res->ai_addrlen;
268     irc_freeaddrinfo(res);
269    
270     if (cidrlen > ipaddr.ss_len * 8)
271     return 0;
272    
273     irc_getaddrinfo(ipmask, NULL, &hints, &res);
274     if (!res)
275     return 0;
276    
277     memcpy(&maskaddr, res->ai_addr, res->ai_addrlen);
278     maskaddr.ss_len = res->ai_addrlen;
279     irc_freeaddrinfo(res);
280    
281     if (maskaddr.ss_len != ipaddr.ss_len)
282     return 0;
283    
284     return (comp_with_mask(((char *) &ipaddr) + offset, ((char *) &maskaddr) +
285     offset, cidrlen) && match(mask, address));
286     }
287    
288 michael 290 int
289     has_wildcards(const char *s)
290     {
291 michael 292 const unsigned char *p = (const unsigned char *)s;
292 michael 290
293 michael 292 for (; *p != '\0'; ++p)
294     {
295     if (*p == '\\')
296     {
297     if (*++p == '\0')
298     return 0;
299     }
300     else if (IsMWildChar(*p))
301 michael 290 return 1;
302 michael 292 }
303 michael 290
304     return 0;
305     }
306    
307 adx 59 /* collapse()
308     *
309     * collapses a string containing multiple *'s.
310     */
311     char *
312     collapse(char *pattern)
313     {
314     char *p = pattern, *po = pattern;
315     char c;
316    
317     if (p == NULL)
318     return NULL;
319    
320     while ((c = *p++))
321     {
322     if (c != '*')
323     *po++ = c;
324     else if (*p != '*')
325     *po++ = '*';
326     }
327    
328     *po = 0;
329    
330     return pattern;
331     }
332    
333     /* collapse_esc()
334     *
335     * The collapse() function with support for escaping characters
336     */
337     char *
338     collapse_esc(char *pattern)
339     {
340     char *p = pattern, *po = pattern;
341     char c;
342    
343     if (p == NULL)
344     return NULL;
345    
346     while ((c = *p++))
347     {
348     if (c != '*')
349     {
350     *po++ = c;
351     if (c == '\\' && *p)
352     *po++ = *p++;
353     }
354     else if (*p != '*')
355     *po++ = '*';
356     }
357    
358     *po = 0;
359    
360     return pattern;
361     }
362    
363     /*
364     * irccmp - case insensitive comparison of two 0 terminated strings.
365     *
366     * returns 0, if s1 equal to s2
367     * 1, if not
368     */
369     int
370     irccmp(const char *s1, const char *s2)
371     {
372     const unsigned char *str1 = (const unsigned char *) s1;
373     const unsigned char *str2 = (const unsigned char *) s2;
374    
375     assert(s1 != NULL);
376     assert(s2 != NULL);
377    
378     while (ToUpper(*str1) == ToUpper(*str2))
379     {
380     if (*str1 == '\0')
381     return 0;
382     str1++;
383     str2++;
384     }
385    
386     return 1;
387     }
388    
389     int
390     ircncmp(const char* s1, const char *s2, size_t n)
391     {
392     const unsigned char *str1 = (const unsigned char *) s1;
393     const unsigned char *str2 = (const unsigned char *) s2;
394     int res;
395    
396     assert(s1 != NULL);
397     assert(s2 != NULL);
398    
399     while ((res = ToUpper(*str1) - ToUpper(*str2)) == 0)
400     {
401     str1++, str2++, n--;
402     if (n == 0 || (*str1 == '\0' && *str2 == '\0'))
403     return 0;
404     }
405     return res;
406     }
407    
408     const unsigned char ToLowerTab[] = {
409     0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa,
410     0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11, 0x12, 0x13, 0x14,
411     0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
412     0x1e, 0x1f,
413     ' ', '!', '"', '#', '$', '%', '&', 0x27, '(', ')',
414     '*', '+', ',', '-', '.', '/',
415     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
416     ':', ';', '<', '=', '>', '?',
417     '@', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
418     'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
419     't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~',
420     '_',
421     '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
422     'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
423     't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~',
424     0x7f,
425     0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
426     0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
427     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
428     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
429     0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
430     0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
431     0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
432     0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
433     0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
434     0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
435     0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
436     0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
437     0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
438     0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
439     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
440     0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
441     };
442    
443     const unsigned char ToUpperTab[] = {
444     0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa,
445     0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11, 0x12, 0x13, 0x14,
446     0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
447     0x1e, 0x1f,
448     ' ', '!', '"', '#', '$', '%', '&', 0x27, '(', ')',
449     '*', '+', ',', '-', '.', '/',
450     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
451     ':', ';', '<', '=', '>', '?',
452     '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
453     'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
454     'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^',
455     0x5f,
456     '`', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
457     'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
458     'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^',
459     0x7f,
460     0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
461     0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
462     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
463     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
464     0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
465     0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
466     0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
467     0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
468     0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
469     0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
470     0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
471     0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
472     0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
473     0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
474     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
475     0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
476     };
477    
478     /*
479     * CharAttrs table
480     *
481     * NOTE: RFC 1459 sez: anything but a ^G, comma, or space is allowed
482     * for channel names
483     */
484     const unsigned int CharAttrs[] = {
485     /* 0 */ CNTRL_C,
486     /* 1 */ CNTRL_C|CHAN_C|NONEOS_C,
487     /* 2 */ CNTRL_C|CHAN_C|NONEOS_C,
488     /* 3 */ CNTRL_C|CHAN_C|NONEOS_C,
489     /* 4 */ CNTRL_C|CHAN_C|NONEOS_C,
490     /* 5 */ CNTRL_C|CHAN_C|NONEOS_C,
491     /* 6 */ CNTRL_C|CHAN_C|NONEOS_C,
492     /* 7 BEL */ CNTRL_C|NONEOS_C,
493     /* 8 \b */ CNTRL_C|CHAN_C|NONEOS_C,
494     /* 9 \t */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C,
495     /* 10 \n */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C|EOL_C,
496     /* 11 \v */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C,
497     /* 12 \f */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C,
498     /* 13 \r */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C|EOL_C,
499     /* 14 */ CNTRL_C|CHAN_C|NONEOS_C,
500     /* 15 */ CNTRL_C|CHAN_C|NONEOS_C,
501     /* 16 */ CNTRL_C|CHAN_C|NONEOS_C,
502     /* 17 */ CNTRL_C|CHAN_C|NONEOS_C,
503     /* 18 */ CNTRL_C|CHAN_C|NONEOS_C,
504     /* 19 */ CNTRL_C|CHAN_C|NONEOS_C,
505     /* 20 */ CNTRL_C|CHAN_C|NONEOS_C,
506     /* 21 */ CNTRL_C|CHAN_C|NONEOS_C,
507     /* 22 */ CNTRL_C|CHAN_C|NONEOS_C,
508     /* 23 */ CNTRL_C|CHAN_C|NONEOS_C,
509     /* 24 */ CNTRL_C|CHAN_C|NONEOS_C,
510     /* 25 */ CNTRL_C|CHAN_C|NONEOS_C,
511     /* 26 */ CNTRL_C|CHAN_C|NONEOS_C,
512     /* 27 */ CNTRL_C|CHAN_C|NONEOS_C,
513     /* 28 */ CNTRL_C|CHAN_C|NONEOS_C,
514     /* 29 */ CNTRL_C|CHAN_C|NONEOS_C,
515     /* 30 */ CNTRL_C|CHAN_C|NONEOS_C,
516     /* 31 */ CNTRL_C|CHAN_C|NONEOS_C,
517     /* SP */ PRINT_C|SPACE_C,
518     /* ! */ PRINT_C|KWILD_C|CHAN_C|NONEOS_C,
519     /* " */ PRINT_C|CHAN_C|NONEOS_C,
520     /* # */ PRINT_C|KWILD_C|MWILD_C|CHANPFX_C|CHAN_C|NONEOS_C,
521     /* $ */ PRINT_C|CHAN_C|NONEOS_C|USER_C,
522     /* % */ PRINT_C|CHAN_C|NONEOS_C,
523     /* & */ PRINT_C|CHANPFX_C|CHAN_C|NONEOS_C,
524     /* ' */ PRINT_C|CHAN_C|NONEOS_C,
525     /* ( */ PRINT_C|CHAN_C|NONEOS_C,
526     /* ) */ PRINT_C|CHAN_C|NONEOS_C,
527     /* * */ PRINT_C|KWILD_C|MWILD_C|CHAN_C|NONEOS_C|SERV_C,
528     /* + */ PRINT_C|CHAN_C|NONEOS_C,
529     /* , */ PRINT_C|NONEOS_C,
530     /* - */ PRINT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
531     /* . */ PRINT_C|KWILD_C|CHAN_C|NONEOS_C|USER_C|HOST_C|SERV_C,
532     /* / */ PRINT_C|CHAN_C|NONEOS_C,
533     /* 0 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
534     /* 1 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
535     /* 2 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
536     /* 3 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
537     /* 4 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
538     /* 5 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
539     /* 6 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
540     /* 7 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
541     /* 8 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
542     /* 9 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
543     /* : */ PRINT_C|KWILD_C|CHAN_C|NONEOS_C|HOST_C,
544     /* ; */ PRINT_C|CHAN_C|NONEOS_C,
545     /* < */ PRINT_C|CHAN_C|NONEOS_C,
546     /* = */ PRINT_C|CHAN_C|NONEOS_C,
547     /* > */ PRINT_C|CHAN_C|NONEOS_C,
548     /* ? */ PRINT_C|KWILD_C|MWILD_C|CHAN_C|NONEOS_C,
549     /* @ */ PRINT_C|KWILD_C|CHAN_C|NONEOS_C,
550     /* A */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
551     /* B */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
552     /* C */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
553     /* D */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
554     /* E */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
555     /* F */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
556     /* G */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
557     /* H */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
558     /* I */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
559     /* J */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
560     /* K */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
561     /* L */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
562     /* M */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
563     /* N */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
564     /* O */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
565     /* P */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
566     /* Q */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
567     /* R */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
568     /* S */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
569     /* T */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
570     /* U */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
571     /* V */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
572     /* W */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
573     /* X */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
574     /* Y */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
575     /* Z */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
576     /* [ */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
577     /* \ */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
578     /* ] */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
579     /* ^ */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
580     /* _ */ PRINT_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
581     /* ` */ PRINT_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
582     /* a */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
583     /* b */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
584     /* c */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
585     /* d */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
586     /* e */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
587     /* f */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
588     /* g */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
589     /* h */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
590     /* i */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
591     /* j */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
592     /* k */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
593     /* l */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
594     /* m */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
595     /* n */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
596     /* o */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
597     /* p */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
598     /* q */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
599     /* r */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
600     /* s */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
601     /* t */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
602     /* u */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
603     /* v */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
604     /* w */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
605     /* x */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
606     /* y */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
607     /* z */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
608     /* { */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
609     /* | */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
610     /* } */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
611     /* ~ */ PRINT_C|ALPHA_C|CHAN_C|NONEOS_C|USER_C,
612     /* del */ CHAN_C|NONEOS_C,
613     /* 0x80 */ CHAN_C|NONEOS_C,
614     /* 0x81 */ CHAN_C|NONEOS_C,
615     /* 0x82 */ CHAN_C|NONEOS_C,
616     /* 0x83 */ CHAN_C|NONEOS_C,
617     /* 0x84 */ CHAN_C|NONEOS_C,
618     /* 0x85 */ CHAN_C|NONEOS_C,
619     /* 0x86 */ CHAN_C|NONEOS_C,
620     /* 0x87 */ CHAN_C|NONEOS_C,
621     /* 0x88 */ CHAN_C|NONEOS_C,
622     /* 0x89 */ CHAN_C|NONEOS_C,
623     /* 0x8A */ CHAN_C|NONEOS_C,
624     /* 0x8B */ CHAN_C|NONEOS_C,
625     /* 0x8C */ CHAN_C|NONEOS_C,
626     /* 0x8D */ CHAN_C|NONEOS_C,
627     /* 0x8E */ CHAN_C|NONEOS_C,
628     /* 0x8F */ CHAN_C|NONEOS_C,
629     /* 0x90 */ CHAN_C|NONEOS_C,
630     /* 0x91 */ CHAN_C|NONEOS_C,
631     /* 0x92 */ CHAN_C|NONEOS_C,
632     /* 0x93 */ CHAN_C|NONEOS_C,
633     /* 0x94 */ CHAN_C|NONEOS_C,
634     /* 0x95 */ CHAN_C|NONEOS_C,
635     /* 0x96 */ CHAN_C|NONEOS_C,
636     /* 0x97 */ CHAN_C|NONEOS_C,
637     /* 0x98 */ CHAN_C|NONEOS_C,
638     /* 0x99 */ CHAN_C|NONEOS_C,
639     /* 0x9A */ CHAN_C|NONEOS_C,
640     /* 0x9B */ CHAN_C|NONEOS_C,
641     /* 0x9C */ CHAN_C|NONEOS_C,
642     /* 0x9D */ CHAN_C|NONEOS_C,
643     /* 0x9E */ CHAN_C|NONEOS_C,
644     /* 0x9F */ CHAN_C|NONEOS_C,
645     /* 0xA0 */ CHAN_C|NONEOS_C,
646     /* 0xA1 */ CHAN_C|NONEOS_C,
647     /* 0xA2 */ CHAN_C|NONEOS_C,
648     /* 0xA3 */ CHAN_C|NONEOS_C,
649     /* 0xA4 */ CHAN_C|NONEOS_C,
650     /* 0xA5 */ CHAN_C|NONEOS_C,
651     /* 0xA6 */ CHAN_C|NONEOS_C,
652     /* 0xA7 */ CHAN_C|NONEOS_C,
653     /* 0xA8 */ CHAN_C|NONEOS_C,
654     /* 0xA9 */ CHAN_C|NONEOS_C,
655     /* 0xAA */ CHAN_C|NONEOS_C,
656     /* 0xAB */ CHAN_C|NONEOS_C,
657     /* 0xAC */ CHAN_C|NONEOS_C,
658     /* 0xAD */ CHAN_C|NONEOS_C,
659     /* 0xAE */ CHAN_C|NONEOS_C,
660     /* 0xAF */ CHAN_C|NONEOS_C,
661     /* 0xB0 */ CHAN_C|NONEOS_C,
662     /* 0xB1 */ CHAN_C|NONEOS_C,
663     /* 0xB2 */ CHAN_C|NONEOS_C,
664     /* 0xB3 */ CHAN_C|NONEOS_C,
665     /* 0xB4 */ CHAN_C|NONEOS_C,
666     /* 0xB5 */ CHAN_C|NONEOS_C,
667     /* 0xB6 */ CHAN_C|NONEOS_C,
668     /* 0xB7 */ CHAN_C|NONEOS_C,
669     /* 0xB8 */ CHAN_C|NONEOS_C,
670     /* 0xB9 */ CHAN_C|NONEOS_C,
671     /* 0xBA */ CHAN_C|NONEOS_C,
672     /* 0xBB */ CHAN_C|NONEOS_C,
673     /* 0xBC */ CHAN_C|NONEOS_C,
674     /* 0xBD */ CHAN_C|NONEOS_C,
675     /* 0xBE */ CHAN_C|NONEOS_C,
676     /* 0xBF */ CHAN_C|NONEOS_C,
677     /* 0xC0 */ CHAN_C|NONEOS_C,
678     /* 0xC1 */ CHAN_C|NONEOS_C,
679     /* 0xC2 */ CHAN_C|NONEOS_C,
680     /* 0xC3 */ CHAN_C|NONEOS_C,
681     /* 0xC4 */ CHAN_C|NONEOS_C,
682     /* 0xC5 */ CHAN_C|NONEOS_C,
683     /* 0xC6 */ CHAN_C|NONEOS_C,
684     /* 0xC7 */ CHAN_C|NONEOS_C,
685     /* 0xC8 */ CHAN_C|NONEOS_C,
686     /* 0xC9 */ CHAN_C|NONEOS_C,
687     /* 0xCA */ CHAN_C|NONEOS_C,
688     /* 0xCB */ CHAN_C|NONEOS_C,
689     /* 0xCC */ CHAN_C|NONEOS_C,
690     /* 0xCD */ CHAN_C|NONEOS_C,
691     /* 0xCE */ CHAN_C|NONEOS_C,
692     /* 0xCF */ CHAN_C|NONEOS_C,
693     /* 0xD0 */ CHAN_C|NONEOS_C,
694     /* 0xD1 */ CHAN_C|NONEOS_C,
695     /* 0xD2 */ CHAN_C|NONEOS_C,
696     /* 0xD3 */ CHAN_C|NONEOS_C,
697     /* 0xD4 */ CHAN_C|NONEOS_C,
698     /* 0xD5 */ CHAN_C|NONEOS_C,
699     /* 0xD6 */ CHAN_C|NONEOS_C,
700     /* 0xD7 */ CHAN_C|NONEOS_C,
701     /* 0xD8 */ CHAN_C|NONEOS_C,
702     /* 0xD9 */ CHAN_C|NONEOS_C,
703     /* 0xDA */ CHAN_C|NONEOS_C,
704     /* 0xDB */ CHAN_C|NONEOS_C,
705     /* 0xDC */ CHAN_C|NONEOS_C,
706     /* 0xDD */ CHAN_C|NONEOS_C,
707     /* 0xDE */ CHAN_C|NONEOS_C,
708     /* 0xDF */ CHAN_C|NONEOS_C,
709     /* 0xE0 */ CHAN_C|NONEOS_C,
710     /* 0xE1 */ CHAN_C|NONEOS_C,
711     /* 0xE2 */ CHAN_C|NONEOS_C,
712     /* 0xE3 */ CHAN_C|NONEOS_C,
713     /* 0xE4 */ CHAN_C|NONEOS_C,
714     /* 0xE5 */ CHAN_C|NONEOS_C,
715     /* 0xE6 */ CHAN_C|NONEOS_C,
716     /* 0xE7 */ CHAN_C|NONEOS_C,
717     /* 0xE8 */ CHAN_C|NONEOS_C,
718     /* 0xE9 */ CHAN_C|NONEOS_C,
719     /* 0xEA */ CHAN_C|NONEOS_C,
720     /* 0xEB */ CHAN_C|NONEOS_C,
721     /* 0xEC */ CHAN_C|NONEOS_C,
722     /* 0xED */ CHAN_C|NONEOS_C,
723     /* 0xEE */ CHAN_C|NONEOS_C,
724     /* 0xEF */ CHAN_C|NONEOS_C,
725     /* 0xF0 */ CHAN_C|NONEOS_C,
726     /* 0xF1 */ CHAN_C|NONEOS_C,
727     /* 0xF2 */ CHAN_C|NONEOS_C,
728     /* 0xF3 */ CHAN_C|NONEOS_C,
729     /* 0xF4 */ CHAN_C|NONEOS_C,
730     /* 0xF5 */ CHAN_C|NONEOS_C,
731     /* 0xF6 */ CHAN_C|NONEOS_C,
732     /* 0xF7 */ CHAN_C|NONEOS_C,
733     /* 0xF8 */ CHAN_C|NONEOS_C,
734     /* 0xF9 */ CHAN_C|NONEOS_C,
735     /* 0xFA */ CHAN_C|NONEOS_C,
736     /* 0xFB */ CHAN_C|NONEOS_C,
737     /* 0xFC */ CHAN_C|NONEOS_C,
738     /* 0xFD */ CHAN_C|NONEOS_C,
739     /* 0xFE */ CHAN_C|NONEOS_C,
740     /* 0xFF */ CHAN_C|NONEOS_C
741     };

Properties

Name Value
svn:eol-style native
svn:keywords Id Revision