/* char-class.c - character classifications
*
****************************************************************
* Copyright (C) 1998, 2000 Thomas Lord
*
* See the file "COPYING" for further information about
* the copyright and warranty status of this work.
*/
#include "hackerlab/char/char-class.h"
/************************************************************************
*(h1 "Character Classes"
* :include ("char/char-class.h"))
*
* The character-class macros assign each byte to various categories of
* characters such as upper-case and lower-case letters.
*
* These functions are based on the ASCII character set. They are not
* locale-sensative.
*
*/
#define cset(Q) \
Q(0), Q(1), Q(2), Q(3), Q(4), Q(5), Q(6), Q(7), \
Q(8), Q(9), Q(10), Q(11), Q(12), Q(13), Q(14), Q(15), \
Q(16), Q(17), Q(18), Q(19), Q(20), Q(21), Q(22), Q(23), \
Q(24), Q(25), Q(26), Q(27), Q(28), Q(29), Q(30), Q(31), \
Q(32), Q(33), Q(34), Q(35), Q(36), Q(37), Q(38), Q(39), \
Q(40), Q(41), Q(42), Q(43), Q(44), Q(45), Q(46), Q(47), \
Q(48), Q(49), Q(50), Q(51), Q(52), Q(53), Q(54), Q(55), \
Q(56), Q(57), Q(58), Q(59), Q(60), Q(61), Q(62), Q(63), \
Q(64), Q(65), Q(66), Q(67), Q(68), Q(69), Q(70), Q(71), \
Q(72), Q(73), Q(74), Q(75), Q(76), Q(77), Q(78), Q(79), \
Q(80), Q(81), Q(82), Q(83), Q(84), Q(85), Q(86), Q(87), \
Q(88), Q(89), Q(90), Q(91), Q(92), Q(93), Q(94), Q(95), \
Q(96), Q(97), Q(98), Q(99), Q(100), Q(101), Q(102), Q(103), \
Q(104), Q(105), Q(106), Q(107), Q(108), Q(109), Q(110), Q(111), \
Q(112), Q(113), Q(114), Q(115), Q(116), Q(117), Q(118), Q(119), \
Q(120), Q(121), Q(122), Q(123), Q(124), Q(125), Q(126), Q(127), \
Q(128), Q(129), Q(130), Q(131), Q(132), Q(133), Q(134), Q(135), \
Q(136), Q(137), Q(138), Q(139), Q(140), Q(141), Q(142), Q(143), \
Q(144), Q(145), Q(146), Q(147), Q(148), Q(149), Q(150), Q(151), \
Q(152), Q(153), Q(154), Q(155), Q(156), Q(157), Q(158), Q(159), \
Q(160), Q(161), Q(162), Q(163), Q(164), Q(165), Q(166), Q(167), \
Q(168), Q(169), Q(170), Q(171), Q(172), Q(173), Q(174), Q(175), \
Q(176), Q(177), Q(178), Q(179), Q(180), Q(181), Q(182), Q(183), \
Q(184), Q(185), Q(186), Q(187), Q(188), Q(189), Q(190), Q(191), \
Q(192), Q(193), Q(194), Q(195), Q(196), Q(197), Q(198), Q(199), \
Q(200), Q(201), Q(202), Q(203), Q(204), Q(205), Q(206), Q(207), \
Q(208), Q(209), Q(210), Q(211), Q(212), Q(213), Q(214), Q(215), \
Q(216), Q(217), Q(218), Q(219), Q(220), Q(221), Q(222), Q(223), \
Q(224), Q(225), Q(226), Q(227), Q(228), Q(229), Q(230), Q(231), \
Q(232), Q(233), Q(234), Q(235), Q(236), Q(237), Q(238), Q(239), \
Q(240), Q(241), Q(242), Q(243), Q(244), Q(245), Q(246), Q(247), \
Q(248), Q(249), Q(250), Q(251), Q(252), Q(253), Q(254), Q(255)
#define as_lower(X) ((((X) >= 'A') && ((X) <= 'Z')) \
? ((X) - 'A' + 'a') \
: (X))
#define as_upper(X) ((((X) >= 'a') && ((X) <= 'z')) \
? ((X) - 'a' + 'A') \
: (X))
t_uchar char__to_lower_table[] = { cset(as_lower) };
t_uchar char__to_upper_table[] = { cset(as_upper) };
#define upper_test(C) (((C) >= 'A') && ((C) <= 'Z'))
#define lower_test(C) (((C) >= 'a') && ((C) <= 'z'))
#define alpha_test(C) (upper_test(C) || lower_test(C))
#define digit_test(C) (((C) >= '0') && ((C) <= '9'))
#define alnum_test(C) (alpha_test(C) || digit_test(C))
#define control_test(C) ((C) < 32)
#define space_test(C) (((C) == '\n') || ((C) == '\t') || ((C) == '\f') || ((C) == ' ') || ((C) == '\r') || ((C) == '\v'))
#define graph_test(C) (((C) >= 33) && ((C) < 127))
#define printable_test(C) (graph_test(C) || ((C) == ' '))
#define c_id_test(C) (alnum_test(C) || ((C) == '_'))
#define xdigit_test(C) ( digit_test(C) \
|| (((C) >= 'a') && ((C) <= 'f')) \
|| (((C) >= 'A') && ((C) <= 'F')))
#define odigit_test(C) (((C) >= '0') && ((C) <= '7'))
#define punct_test(C) ( (((C) >= 33) && ((C) <= 47)) \
|| (((C) >= 58) && ((C) <= 64)) \
|| (((C) >= 91) && ((C) <= 96)) \
|| (((C) >= 123) && ((C) <= 126)))
#define blank_test(C) (((C) == ' ') || ((C) == '\t'))
#define backslash_test(C) ((C) == '\\')
#define quote_test(C) (((C) == '"') || ((C) == '\''))
#define non_ascii_test(C) ((C) >= 128)
#define upper_bit(C) (upper_test(C) ? char_class_upper : 0)
#define lower_bit(C) (lower_test(C) ? char_class_lower : 0)
#define alpha_bit(C) (alpha_test(C) ? char_class_alpha : 0)
#define digit_bit(C) (digit_test(C) ? char_class_digit : 0)
#define alnum_bit(C) (alnum_test(C) ? char_class_alnum : 0)
#define control_bit(C) (control_test(C) ? char_class_control : 0)
#define printable_bit(C) (printable_test(C) ? char_class_printable : 0)
#define space_bit(C) (space_test(C) ? char_class_space : 0)
#define graph_bit(C) (graph_test(C) ? char_class_graph : 0)
#define c_id_bit(C) (c_id_test(C) ? char_class_c_id : 0)
#define xdigit_bit(C) (xdigit_test(C) ? char_class_xdigit : 0)
#define odigit_bit(C) (odigit_test(C) ? char_class_odigit : 0)
#define punct_bit(C) (punct_test(C) ? char_class_punct : 0)
#define blank_bit(C) (blank_test(C) ? char_class_blank : 0)
#define backslash_bit(C) (backslash_test(C) ? char_class_backslash : 0)
#define quote_bit(C) (quote_test(C) ? char_class_quote : 0)
#define non_ascii_bit(C) (non_ascii_test(C) ? char_class_non_ascii : 0)
#define class_bits(C) ( upper_bit(C) \
| lower_bit(C) \
| alpha_bit(C) \
| digit_bit(C) \
| alnum_bit(C) \
| control_bit(C) \
| printable_bit(C) \
| space_bit(C) \
| graph_bit(C) \
| c_id_bit(C) \
| xdigit_bit(C) \
| odigit_bit(C) \
| punct_bit(C) \
| blank_bit(C) \
| backslash_bit(C) \
| quote_bit(C) \
| non_ascii_bit(C))
#define digit_value_n(C) ((digit_test (C) \
? ((C) - '0') \
: (upper_test (C) \
? (10 + (C) - 'A') \
: ((lower_test (C) \
? (10 + (C) - 'a') \
: -1)))))
unsigned int char__class_table[] =
{
cset (class_bits)
};
unsigned int char__digit_value_table [] =
{
cset (digit_value_n)
};
#if 0
/*(c char_is_upper :category macro)
* int char_is_upper (t_uchar x);
*
* Return 1 if `x' is an upper case letter, 0 otherwise.
*/
int
char_is_upper (t_uchar x)
{ macro }
/*(c char_is_lower :category macro)
* int char_is_lower (t_uchar x);
*
* Return 1 if `x' is a lower case letter, 0 otherwise.
*/
int
char_is_lower (t_uchar x)
{ macro }
/*(c char_is_alpha :category macro)
* int char_is_alpha (t_uchar x);
*
* Return 1 if `x' is an upper or lower case letter, 0 otherwise.
*/
int
char_is_alpha (t_uchar x)
{ macro }
/*(c char_is_digit :category macro)
* int char_is_digit (t_uchar x);
*
* Return 1 if `x' is a decimal digit, 0 otherwise.
*/
int
char_is_digit (t_uchar x)
{ macro }
/*(c char_is_alnum :category macro)
* int char_is_alnum (t_uchar x);
*
* Return 1 if `x' is an upper or lower case letter or digit, 0 otherwise.
*/
int
char_is_alnum (t_uchar x)
{ macro }
/*(c char_is_control :category macro)
* int char_is_control (t_uchar x);
*
* Return 1 if `x' is a control character, 0 otherwise.
*/
int
char_is_control (t_uchar x)
{ macro }
/*(c char_is_printable :category macro)
* int char_is_printable (t_uchar x);
*
* Return 1 if `x' is a printable character, 0 otherwise.
*/
int
char_is_printable (t_uchar x)
{ macro }
/*(c char_is_space :category macro)
* int char_is_space (t_uchar x);
*
* Return 1 if `x' is a space character, 0 otherwise.
*/
int
char_is_space (t_uchar x)
{ macro }
/*(c char_is_graph :category macro)
* int char_is_graph (t_uchar x);
*
* Return 1 if `x' is a non-space printable character, 0 otherwise.
*/
int
char_is_graph (t_uchar x)
{ macro }
/*(c char_is_c_id :category macro)
* int char_is_c_id (t_uchar x);
*
* Return 1 if `x' is an alpha-numeric character or '_', 0 otherwise.
*/
int
char_is_c_id (t_uchar x)
{ macro }
/*(c char_is_xdigit :category macro)
* int char_is_xdigit (t_uchar x);
*
* Return 1 if `x' is a hexadecimal digit, 0 otherwise.
*/
int
char_is_xdigit (t_uchar x)
{ macro }
/*(c char_is_odigit :category macro)
* int char_is_odigit (t_uchar x);
*
* Return 1 if `x' is an octal digit, 0 otherwise.
*/
int
char_is_odigit (t_uchar x)
{ macro }
/*(c char_is_punct :category macro)
* int char_is_punct (t_uchar x);
*
* Return 1 if `x' is a punctuation character, 0 otherwise.
*/
int
char_is_punct (t_uchar x)
{ macro }
/*(c char_is_ascii :category macro)
* int char_is_ascii (t_uchar x);
*
* Return 1 if `x' is an ascii character.
*/
int
char_is_non_ascii (t_uchar x)
{ macro }
/*(c char_is_non_ascii :category macro)
* int char_is_non_ascii (t_uchar x);
*
* Return 1 if `x' is not a plain ascii character.
*/
int
char_is_non_ascii (t_uchar x)
{ macro }
#endif
syntax highlighted by Code2HTML, v. 0.9.1