ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/libio/string/match.c
Revision: 290
Committed: Sun Dec 4 13:31:27 2005 UTC (20 years, 8 months ago) by michael
Content type: text/x-csrc
File size: 22240 byte(s)
Log Message: 
- Moved has_wildcards() from m_list.c to match.c and re-use it
  in some other places.

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     char c;
292    
293     while ((c = *s++))
294     if (IsMWildChar(c))
295     return 1;
296    
297     return 0;
298     }
299    
300 adx 59 /* collapse()
301     *
302     * collapses a string containing multiple *'s.
303     */
304     char *
305     collapse(char *pattern)
306     {
307     char *p = pattern, *po = pattern;
308     char c;
309    
310     if (p == NULL)
311     return NULL;
312    
313     while ((c = *p++))
314     {
315     if (c != '*')
316     *po++ = c;
317     else if (*p != '*')
318     *po++ = '*';
319     }
320    
321     *po = 0;
322    
323     return pattern;
324     }
325    
326     /* collapse_esc()
327     *
328     * The collapse() function with support for escaping characters
329     */
330     char *
331     collapse_esc(char *pattern)
332     {
333     char *p = pattern, *po = pattern;
334     char c;
335    
336     if (p == NULL)
337     return NULL;
338    
339     while ((c = *p++))
340     {
341     if (c != '*')
342     {
343     *po++ = c;
344     if (c == '\\' && *p)
345     *po++ = *p++;
346     }
347     else if (*p != '*')
348     *po++ = '*';
349     }
350    
351     *po = 0;
352    
353     return pattern;
354     }
355    
356     /*
357     * irccmp - case insensitive comparison of two 0 terminated strings.
358     *
359     * returns 0, if s1 equal to s2
360     * 1, if not
361     */
362     int
363     irccmp(const char *s1, const char *s2)
364     {
365     const unsigned char *str1 = (const unsigned char *) s1;
366     const unsigned char *str2 = (const unsigned char *) s2;
367    
368     assert(s1 != NULL);
369     assert(s2 != NULL);
370    
371     while (ToUpper(*str1) == ToUpper(*str2))
372     {
373     if (*str1 == '\0')
374     return 0;
375     str1++;
376     str2++;
377     }
378    
379     return 1;
380     }
381    
382     int
383     ircncmp(const char* s1, const char *s2, size_t n)
384     {
385     const unsigned char *str1 = (const unsigned char *) s1;
386     const unsigned char *str2 = (const unsigned char *) s2;
387     int res;
388    
389     assert(s1 != NULL);
390     assert(s2 != NULL);
391    
392     while ((res = ToUpper(*str1) - ToUpper(*str2)) == 0)
393     {
394     str1++, str2++, n--;
395     if (n == 0 || (*str1 == '\0' && *str2 == '\0'))
396     return 0;
397     }
398     return res;
399     }
400    
401     const unsigned char ToLowerTab[] = {
402     0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa,
403     0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11, 0x12, 0x13, 0x14,
404     0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
405     0x1e, 0x1f,
406     ' ', '!', '"', '#', '$', '%', '&', 0x27, '(', ')',
407     '*', '+', ',', '-', '.', '/',
408     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
409     ':', ';', '<', '=', '>', '?',
410     '@', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
411     'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
412     't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~',
413     '_',
414     '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
415     'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
416     't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~',
417     0x7f,
418     0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
419     0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
420     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
421     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
422     0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
423     0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
424     0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
425     0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
426     0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
427     0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
428     0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
429     0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
430     0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
431     0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
432     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
433     0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
434     };
435    
436     const unsigned char ToUpperTab[] = {
437     0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa,
438     0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11, 0x12, 0x13, 0x14,
439     0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
440     0x1e, 0x1f,
441     ' ', '!', '"', '#', '$', '%', '&', 0x27, '(', ')',
442     '*', '+', ',', '-', '.', '/',
443     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
444     ':', ';', '<', '=', '>', '?',
445     '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
446     'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
447     'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^',
448     0x5f,
449     '`', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
450     'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
451     'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^',
452     0x7f,
453     0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
454     0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
455     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
456     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
457     0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
458     0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
459     0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
460     0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
461     0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
462     0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
463     0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
464     0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
465     0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
466     0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
467     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
468     0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
469     };
470    
471     /*
472     * CharAttrs table
473     *
474     * NOTE: RFC 1459 sez: anything but a ^G, comma, or space is allowed
475     * for channel names
476     */
477     const unsigned int CharAttrs[] = {
478     /* 0 */ CNTRL_C,
479     /* 1 */ CNTRL_C|CHAN_C|NONEOS_C,
480     /* 2 */ CNTRL_C|CHAN_C|NONEOS_C,
481     /* 3 */ CNTRL_C|CHAN_C|NONEOS_C,
482     /* 4 */ CNTRL_C|CHAN_C|NONEOS_C,
483     /* 5 */ CNTRL_C|CHAN_C|NONEOS_C,
484     /* 6 */ CNTRL_C|CHAN_C|NONEOS_C,
485     /* 7 BEL */ CNTRL_C|NONEOS_C,
486     /* 8 \b */ CNTRL_C|CHAN_C|NONEOS_C,
487     /* 9 \t */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C,
488     /* 10 \n */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C|EOL_C,
489     /* 11 \v */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C,
490     /* 12 \f */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C,
491     /* 13 \r */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C|EOL_C,
492     /* 14 */ CNTRL_C|CHAN_C|NONEOS_C,
493     /* 15 */ CNTRL_C|CHAN_C|NONEOS_C,
494     /* 16 */ CNTRL_C|CHAN_C|NONEOS_C,
495     /* 17 */ CNTRL_C|CHAN_C|NONEOS_C,
496     /* 18 */ CNTRL_C|CHAN_C|NONEOS_C,
497     /* 19 */ CNTRL_C|CHAN_C|NONEOS_C,
498     /* 20 */ CNTRL_C|CHAN_C|NONEOS_C,
499     /* 21 */ CNTRL_C|CHAN_C|NONEOS_C,
500     /* 22 */ CNTRL_C|CHAN_C|NONEOS_C,
501     /* 23 */ CNTRL_C|CHAN_C|NONEOS_C,
502     /* 24 */ CNTRL_C|CHAN_C|NONEOS_C,
503     /* 25 */ CNTRL_C|CHAN_C|NONEOS_C,
504     /* 26 */ CNTRL_C|CHAN_C|NONEOS_C,
505     /* 27 */ CNTRL_C|CHAN_C|NONEOS_C,
506     /* 28 */ CNTRL_C|CHAN_C|NONEOS_C,
507     /* 29 */ CNTRL_C|CHAN_C|NONEOS_C,
508     /* 30 */ CNTRL_C|CHAN_C|NONEOS_C,
509     /* 31 */ CNTRL_C|CHAN_C|NONEOS_C,
510     /* SP */ PRINT_C|SPACE_C,
511     /* ! */ PRINT_C|KWILD_C|CHAN_C|NONEOS_C,
512     /* " */ PRINT_C|CHAN_C|NONEOS_C,
513     /* # */ PRINT_C|KWILD_C|MWILD_C|CHANPFX_C|CHAN_C|NONEOS_C,
514     /* $ */ PRINT_C|CHAN_C|NONEOS_C|USER_C,
515     /* % */ PRINT_C|CHAN_C|NONEOS_C,
516     /* & */ PRINT_C|CHANPFX_C|CHAN_C|NONEOS_C,
517     /* ' */ PRINT_C|CHAN_C|NONEOS_C,
518     /* ( */ PRINT_C|CHAN_C|NONEOS_C,
519     /* ) */ PRINT_C|CHAN_C|NONEOS_C,
520     /* * */ PRINT_C|KWILD_C|MWILD_C|CHAN_C|NONEOS_C|SERV_C,
521     /* + */ PRINT_C|CHAN_C|NONEOS_C,
522     /* , */ PRINT_C|NONEOS_C,
523     /* - */ PRINT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
524     /* . */ PRINT_C|KWILD_C|CHAN_C|NONEOS_C|USER_C|HOST_C|SERV_C,
525     /* / */ PRINT_C|CHAN_C|NONEOS_C,
526     /* 0 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
527     /* 1 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
528     /* 2 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
529     /* 3 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
530     /* 4 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
531     /* 5 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
532     /* 6 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
533     /* 7 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
534     /* 8 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
535     /* 9 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
536     /* : */ PRINT_C|KWILD_C|CHAN_C|NONEOS_C|HOST_C,
537     /* ; */ PRINT_C|CHAN_C|NONEOS_C,
538     /* < */ PRINT_C|CHAN_C|NONEOS_C,
539     /* = */ PRINT_C|CHAN_C|NONEOS_C,
540     /* > */ PRINT_C|CHAN_C|NONEOS_C,
541     /* ? */ PRINT_C|KWILD_C|MWILD_C|CHAN_C|NONEOS_C,
542     /* @ */ PRINT_C|KWILD_C|CHAN_C|NONEOS_C,
543     /* A */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
544     /* B */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
545     /* C */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
546     /* D */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
547     /* E */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
548     /* F */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
549     /* G */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
550     /* H */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
551     /* I */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
552     /* J */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
553     /* K */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
554     /* L */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
555     /* M */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
556     /* N */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
557     /* O */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
558     /* P */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
559     /* Q */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
560     /* R */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
561     /* S */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
562     /* T */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
563     /* U */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
564     /* V */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
565     /* W */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
566     /* X */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
567     /* Y */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
568     /* Z */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
569     /* [ */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
570     /* \ */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
571     /* ] */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
572     /* ^ */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
573     /* _ */ PRINT_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
574     /* ` */ PRINT_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
575     /* a */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
576     /* b */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
577     /* c */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
578     /* d */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
579     /* e */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
580     /* f */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
581     /* g */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
582     /* h */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
583     /* i */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
584     /* j */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
585     /* k */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
586     /* l */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
587     /* m */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
588     /* n */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
589     /* o */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
590     /* p */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
591     /* q */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
592     /* r */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
593     /* s */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
594     /* t */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
595     /* u */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
596     /* v */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
597     /* w */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
598     /* x */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
599     /* y */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
600     /* z */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
601     /* { */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
602     /* | */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
603     /* } */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
604     /* ~ */ PRINT_C|ALPHA_C|CHAN_C|NONEOS_C|USER_C,
605     /* del */ CHAN_C|NONEOS_C,
606     /* 0x80 */ CHAN_C|NONEOS_C,
607     /* 0x81 */ CHAN_C|NONEOS_C,
608     /* 0x82 */ CHAN_C|NONEOS_C,
609     /* 0x83 */ CHAN_C|NONEOS_C,
610     /* 0x84 */ CHAN_C|NONEOS_C,
611     /* 0x85 */ CHAN_C|NONEOS_C,
612     /* 0x86 */ CHAN_C|NONEOS_C,
613     /* 0x87 */ CHAN_C|NONEOS_C,
614     /* 0x88 */ CHAN_C|NONEOS_C,
615     /* 0x89 */ CHAN_C|NONEOS_C,
616     /* 0x8A */ CHAN_C|NONEOS_C,
617     /* 0x8B */ CHAN_C|NONEOS_C,
618     /* 0x8C */ CHAN_C|NONEOS_C,
619     /* 0x8D */ CHAN_C|NONEOS_C,
620     /* 0x8E */ CHAN_C|NONEOS_C,
621     /* 0x8F */ CHAN_C|NONEOS_C,
622     /* 0x90 */ CHAN_C|NONEOS_C,
623     /* 0x91 */ CHAN_C|NONEOS_C,
624     /* 0x92 */ CHAN_C|NONEOS_C,
625     /* 0x93 */ CHAN_C|NONEOS_C,
626     /* 0x94 */ CHAN_C|NONEOS_C,
627     /* 0x95 */ CHAN_C|NONEOS_C,
628     /* 0x96 */ CHAN_C|NONEOS_C,
629     /* 0x97 */ CHAN_C|NONEOS_C,
630     /* 0x98 */ CHAN_C|NONEOS_C,
631     /* 0x99 */ CHAN_C|NONEOS_C,
632     /* 0x9A */ CHAN_C|NONEOS_C,
633     /* 0x9B */ CHAN_C|NONEOS_C,
634     /* 0x9C */ CHAN_C|NONEOS_C,
635     /* 0x9D */ CHAN_C|NONEOS_C,
636     /* 0x9E */ CHAN_C|NONEOS_C,
637     /* 0x9F */ CHAN_C|NONEOS_C,
638     /* 0xA0 */ CHAN_C|NONEOS_C,
639     /* 0xA1 */ CHAN_C|NONEOS_C,
640     /* 0xA2 */ CHAN_C|NONEOS_C,
641     /* 0xA3 */ CHAN_C|NONEOS_C,
642     /* 0xA4 */ CHAN_C|NONEOS_C,
643     /* 0xA5 */ CHAN_C|NONEOS_C,
644     /* 0xA6 */ CHAN_C|NONEOS_C,
645     /* 0xA7 */ CHAN_C|NONEOS_C,
646     /* 0xA8 */ CHAN_C|NONEOS_C,
647     /* 0xA9 */ CHAN_C|NONEOS_C,
648     /* 0xAA */ CHAN_C|NONEOS_C,
649     /* 0xAB */ CHAN_C|NONEOS_C,
650     /* 0xAC */ CHAN_C|NONEOS_C,
651     /* 0xAD */ CHAN_C|NONEOS_C,
652     /* 0xAE */ CHAN_C|NONEOS_C,
653     /* 0xAF */ CHAN_C|NONEOS_C,
654     /* 0xB0 */ CHAN_C|NONEOS_C,
655     /* 0xB1 */ CHAN_C|NONEOS_C,
656     /* 0xB2 */ CHAN_C|NONEOS_C,
657     /* 0xB3 */ CHAN_C|NONEOS_C,
658     /* 0xB4 */ CHAN_C|NONEOS_C,
659     /* 0xB5 */ CHAN_C|NONEOS_C,
660     /* 0xB6 */ CHAN_C|NONEOS_C,
661     /* 0xB7 */ CHAN_C|NONEOS_C,
662     /* 0xB8 */ CHAN_C|NONEOS_C,
663     /* 0xB9 */ CHAN_C|NONEOS_C,
664     /* 0xBA */ CHAN_C|NONEOS_C,
665     /* 0xBB */ CHAN_C|NONEOS_C,
666     /* 0xBC */ CHAN_C|NONEOS_C,
667     /* 0xBD */ CHAN_C|NONEOS_C,
668     /* 0xBE */ CHAN_C|NONEOS_C,
669     /* 0xBF */ CHAN_C|NONEOS_C,
670     /* 0xC0 */ CHAN_C|NONEOS_C,
671     /* 0xC1 */ CHAN_C|NONEOS_C,
672     /* 0xC2 */ CHAN_C|NONEOS_C,
673     /* 0xC3 */ CHAN_C|NONEOS_C,
674     /* 0xC4 */ CHAN_C|NONEOS_C,
675     /* 0xC5 */ CHAN_C|NONEOS_C,
676     /* 0xC6 */ CHAN_C|NONEOS_C,
677     /* 0xC7 */ CHAN_C|NONEOS_C,
678     /* 0xC8 */ CHAN_C|NONEOS_C,
679     /* 0xC9 */ CHAN_C|NONEOS_C,
680     /* 0xCA */ CHAN_C|NONEOS_C,
681     /* 0xCB */ CHAN_C|NONEOS_C,
682     /* 0xCC */ CHAN_C|NONEOS_C,
683     /* 0xCD */ CHAN_C|NONEOS_C,
684     /* 0xCE */ CHAN_C|NONEOS_C,
685     /* 0xCF */ CHAN_C|NONEOS_C,
686     /* 0xD0 */ CHAN_C|NONEOS_C,
687     /* 0xD1 */ CHAN_C|NONEOS_C,
688     /* 0xD2 */ CHAN_C|NONEOS_C,
689     /* 0xD3 */ CHAN_C|NONEOS_C,
690     /* 0xD4 */ CHAN_C|NONEOS_C,
691     /* 0xD5 */ CHAN_C|NONEOS_C,
692     /* 0xD6 */ CHAN_C|NONEOS_C,
693     /* 0xD7 */ CHAN_C|NONEOS_C,
694     /* 0xD8 */ CHAN_C|NONEOS_C,
695     /* 0xD9 */ CHAN_C|NONEOS_C,
696     /* 0xDA */ CHAN_C|NONEOS_C,
697     /* 0xDB */ CHAN_C|NONEOS_C,
698     /* 0xDC */ CHAN_C|NONEOS_C,
699     /* 0xDD */ CHAN_C|NONEOS_C,
700     /* 0xDE */ CHAN_C|NONEOS_C,
701     /* 0xDF */ CHAN_C|NONEOS_C,
702     /* 0xE0 */ CHAN_C|NONEOS_C,
703     /* 0xE1 */ CHAN_C|NONEOS_C,
704     /* 0xE2 */ CHAN_C|NONEOS_C,
705     /* 0xE3 */ CHAN_C|NONEOS_C,
706     /* 0xE4 */ CHAN_C|NONEOS_C,
707     /* 0xE5 */ CHAN_C|NONEOS_C,
708     /* 0xE6 */ CHAN_C|NONEOS_C,
709     /* 0xE7 */ CHAN_C|NONEOS_C,
710     /* 0xE8 */ CHAN_C|NONEOS_C,
711     /* 0xE9 */ CHAN_C|NONEOS_C,
712     /* 0xEA */ CHAN_C|NONEOS_C,
713     /* 0xEB */ CHAN_C|NONEOS_C,
714     /* 0xEC */ CHAN_C|NONEOS_C,
715     /* 0xED */ CHAN_C|NONEOS_C,
716     /* 0xEE */ CHAN_C|NONEOS_C,
717     /* 0xEF */ CHAN_C|NONEOS_C,
718     /* 0xF0 */ CHAN_C|NONEOS_C,
719     /* 0xF1 */ CHAN_C|NONEOS_C,
720     /* 0xF2 */ CHAN_C|NONEOS_C,
721     /* 0xF3 */ CHAN_C|NONEOS_C,
722     /* 0xF4 */ CHAN_C|NONEOS_C,
723     /* 0xF5 */ CHAN_C|NONEOS_C,
724     /* 0xF6 */ CHAN_C|NONEOS_C,
725     /* 0xF7 */ CHAN_C|NONEOS_C,
726     /* 0xF8 */ CHAN_C|NONEOS_C,
727     /* 0xF9 */ CHAN_C|NONEOS_C,
728     /* 0xFA */ CHAN_C|NONEOS_C,
729     /* 0xFB */ CHAN_C|NONEOS_C,
730     /* 0xFC */ CHAN_C|NONEOS_C,
731     /* 0xFD */ CHAN_C|NONEOS_C,
732     /* 0xFE */ CHAN_C|NONEOS_C,
733     /* 0xFF */ CHAN_C|NONEOS_C
734     };

Properties

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