ircproxy  The Ultimate Cyborg

---

ircd_chattr.h

//
// Copyright (C) 1998 Andrea Cocito
// Copyright (C) 2005 Carlo Wood
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 1, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//

// This character set code is adapted from Nemesi's Tools Library,
// which gives us the prefix NTL_ on these macros.

#ifndef INCLUDED_ircd_chattr_h
#define INCLUDED_ircd_chattr_h

#ifndef USE_PCH
#include <limits>
#endif

//
// Character attribute constants.
//
typedef unsigned int ntl_type;
ntl_type const NTL_ALNUM  =  0x0001;  // (NTL_ALPHA | NTL_DIGIT)
ntl_type const NTL_ALPHA  =  0x0002;  // (NTL_LOWER | NTL_UPPER)
ntl_type const NTL_CNTRL  =  0x0004;  // \\000 - \\037 == 0x00 - 0x1F
ntl_type const NTL_DIGIT  =  0x0008;  // 0123456789
ntl_type const NTL_GRAPH  =  0x0010;  // (NTL_ALNUM | NTL_PUNCT)
ntl_type const NTL_LOWER  =  0x0020;  // abcdefghijklmnopqrstuvwxyz{|}~
ntl_type const NTL_PRINT  =  0x0040;  // (NTL_GRAPH | ' ')
ntl_type const NTL_PUNCT  =  0x0080;  // !"#$%&'()*+,-./:;<=>?\@_`
ntl_type const NTL_SPACE  =  0x0100;  // \\011\\012\\013\\014\\015\\040
ntl_type const NTL_UPPER  =  0x0200;  // ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^
ntl_type const NTL_IRCCH  =  0x0400;  // Channel's names charset
ntl_type const NTL_IRCCL  =  0x0800;  // Force toLower() in ch-name
ntl_type const NTL_IRCNK  =  0x1000;  // Nick names charset, aka isvalid()
ntl_type const NTL_IRCUI  =  0x2000;  // UserIDs charset, IRCHN plus tilde
ntl_type const NTL_IRCHN  =  0x4000;  // Hostnames charset (weak, RFC 1033)
ntl_type const NTL_IRCIP  =  0x8000;  // Numeric IPs charset (DIGIT and .)
ntl_type const NTL_EOL    = 0x10000;  // \\r\\n
ntl_type const NTL_KTIME  = 0x20000;  // Valid character for a k:line time
ntl_type const NTL_CHPFX  = 0x40000;  // channel prefix char # & +
ntl_type const NTL_IRCIP6 = 0x80000;  // Numeric IPv6 character (hex or colon)

//
// Tables used for translation and classification macros
//

// Array mapping characters to RFC 1459 lower-case versions.
// Yes, the variable name lies about the encoding.
extern char const ToLowerTab_8859_1[];
// Array mapping characters to RFC 1459 upper-case versions.
// Yes, the variable name lies about the encoding.
extern char const ToUpperTab_8859_1[];
// Array mapping characters to attribute bitmasks.
extern ntl_type const IRCD_CharAttrTab[];

//
// Translation macros for channel name case translation
// NOTE: Channel names are supposed to be lower case insensitive for
// ISO 8859-1 character sets.
//

inline char ToLower(char c) __attribute__((const));
inline char ToUpper(char c) __attribute__((const));
inline bool IsAlnum(char c) __attribute__((const));
inline bool IsAlpha(char c) __attribute__((const));
inline bool IsDigit(char c) __attribute__((const));
inline bool IsLower(char c) __attribute__((const));
inline bool IsSpace(char c) __attribute__((const));
inline bool IsUpper(char c) __attribute__((const));
inline bool IsCntrl(char c) __attribute__((const));
inline bool IsChannelChar(char c) __attribute__((const));
inline bool IsChannelLower(char c) __attribute__((const));
inline bool IsChannelPrefix(char c) __attribute__((const));
inline bool IsNickChar(char c) __attribute__((const));
inline bool IsUserChar(char c) __attribute__((const));
inline bool IsHostChar(char c) __attribute__((const));
inline bool IsIPChar(char c) __attribute__((const));
inline bool IsIP6Char(char c) __attribute__((const));
inline bool IsEol(char c) __attribute__((const));
inline bool IsKTimeChar(char c) __attribute__((const));

// Convert a character to its lower-case equivalent.
inline char ToLower(char c)
{
  return ToLowerTab_8859_1[c - std::numeric_limits<char>::min()];
}

// Convert a character to its upper-case equivalent.
inline char ToUpper(char c)
{
  return ToUpperTab_8859_1[c - std::numeric_limits<char>::min()];
}

//
// Character classification macros
// NOTE: The IsUpper and IsLower macros do not apply to the complete
// ISO 8859-1 character set, unlike the ToUpper and ToLower macros above.
// IsUpper and IsLower only apply for comparisons of the US ASCII subset.
//

// Test whether a character is alphanumeric.
inline bool IsAlnum(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_ALNUM;
}

// Test whether a character is alphabetic.
inline bool IsAlpha(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_ALPHA;
}

// Test whether a character is a digit.
inline bool IsDigit(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_DIGIT;
}

// Test whether a character is lower case.
inline bool IsLower(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_LOWER;
}

// Test whether a character is whitespace.
inline bool IsSpace(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_SPACE;
}

// Test whether a character is upper case.
inline bool IsUpper(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_UPPER;
}

// Test whether a character is a control character.
inline bool IsCntrl(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_CNTRL;
}

// Test whether a character is valid in a channel name.
inline bool IsChannelChar(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_IRCCH;
}

// Test whether a character is a lower-case channel name character.
inline bool IsChannelLower(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_IRCCL;
}

// Test whether a character is a channel prefix.
inline bool IsChannelPrefix(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_CHPFX;
}

// Test whether a character is valid in a nickname.
inline bool IsNickChar(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_IRCNK;
}

// Test whether a character is valid in a userid.
inline bool IsUserChar(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_IRCUI;
}

// Test whether a character is valid in a hostname.
inline bool IsHostChar(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_IRCHN;
}

// Test whether a character is valid in an IPv4 address.
inline bool IsIPChar(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_IRCIP;
}

// Test whether a character is valid in an IPv6 address.
inline bool IsIP6Char(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_IRCIP6;
}

// Test whether a character is an end-of-line character.
inline bool IsEol(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_EOL;
}

// Test whether a character is valid in a K: line expiration string.
inline bool IsKTimeChar(char c)
{
  return IRCD_CharAttrTab[c - std::numeric_limits<char>::min()] & NTL_KTIME;
}

#endif /* INCLUDED_ircd_chattr_h */

---