ch.h

Go to the documentation of this file.

// ============================================================================
// Project:     Deductive Database
// Filename:    ch.h
// Purpose:     Character Classes
// Last Change: 04.08.2017
// Language:    C++
// EMail:       brass@informatik.uni-halle.de
// WWW:         http://www.informatik.uni-halle.de/~brass/
// Address:     Feldschloesschen 15, D-06120 Halle (Saale), GERMANY
// Copyright:   (c) 1998-2017 by Stefan Brass
// License:     See file "LICENSE" for copying conditions.
// Note:        There is no warranty at all - this code may contain bugs.
// ============================================================================


//=============================================================================
// Include File Frame:
//=============================================================================

#ifndef CH_INCLUDED
#define CH_INCLUDED

//=============================================================================
// Used Types and Macros:
//=============================================================================

#ifndef CHECK_INCLUDED
#include "../base/check.h"
#endif

//=============================================================================
// Private Constants:
//=============================================================================

//-----------------------------------------------------------------------------
// CH_TABSIZE: Size of the character table, i.e. number of char values:
//-----------------------------------------------------------------------------

static const int CH_TABSIZE = 256;

//=============================================================================
// Exported Types:
//=============================================================================

//-----------------------------------------------------------------------------
// ch_t: Character classes.
//-----------------------------------------------------------------------------

typedef enum ch_enum {
        CH_NULL,
        CH_EOF,
        CH_ATOM,
        CH_VAR,
        CH_MINUS,
        CH_DIGIT,
        CH_QUOTE,
        CH_FULLSTOP,
        CH_COMMA,
        CH_LPAREN,
        CH_RPAREN,
        CH_LESS,
        CH_GREATER,
        CH_COLON,
        CH_NOT,
        CH_OR,
        CH_SEMICOLON,
        CH_AND,
        CH_QUEST,
        CH_UNUSED,
        CH_UNDEFINED
} ch_t;

//=============================================================================
// Auxillary Macros:
//=============================================================================

//-----------------------------------------------------------------------------
// CH_CHARCAST: How to get from characters to indices.
//-----------------------------------------------------------------------------

#define CH_CHARCAST(c)  ((int) ((unsigned char)(c)))

//=============================================================================
// Class for Classifying Characters:
//=============================================================================

class ch_c {
        public:

//-----------------------------------------------------------------------------
// init: Initialization of classification tables:
//-----------------------------------------------------------------------------

        static void     init();

//-----------------------------------------------------------------------------
// classify: Return the character class of a character.
//-----------------------------------------------------------------------------

        static inline   ch_t classify(char c)
                { CHECK(Initialized,
                        "ch_c::classify(not initialized)");
                  CHECK(CH_CHARCAST(c)<Tabsize,
                        "ch_c::classify(index out of range)");
                  return(Classify[CH_CHARCAST(c)]); }

//-----------------------------------------------------------------------------
// is_alnum: Is this an alphanumeric character?
//-----------------------------------------------------------------------------

        static inline bool is_alnum(char c)
                { CHECK(Initialized,
                        "ch_c::is_alnum(not initialized)");
                  CHECK(CH_CHARCAST(c)<Tabsize,
                        "ch_c::is_alnum(index out of range)");
                  return(IsAlnum[CH_CHARCAST(c)]); }

//-----------------------------------------------------------------------------
// is_space: Is this a space character (excluding newline)?
//-----------------------------------------------------------------------------

        static inline bool is_space(char c)
                { return(c==' ' || c=='\t' || c=='\r'); }

//-----------------------------------------------------------------------------
// is_comment: Is this the comment character?
//-----------------------------------------------------------------------------

        static inline bool is_comment(char c)
                { return(c=='%'); }

//-----------------------------------------------------------------------------
// is_newline: Is this the newline character?
//-----------------------------------------------------------------------------

        static inline bool is_newline(char c)
                { return(c=='\n'); }

//-----------------------------------------------------------------------------
// is_quote: Is this the quote character?
//-----------------------------------------------------------------------------

        static inline bool is_quote(char c)
                { return(c=='\''); }

//-----------------------------------------------------------------------------
// is_backslash: Is this the backslash character?
//-----------------------------------------------------------------------------

        static inline bool is_backslash(char c)
                { return(c=='\\'); }

//-----------------------------------------------------------------------------
// is_escape_seq: Is this a valid character after the backslash character?
//-----------------------------------------------------------------------------

        static inline bool is_escape_seq(char c)
                { return(c=='\\' || c=='\'' || c=='\"' || c=='n' || c=='r' ||
                                c=='t'); }

//-----------------------------------------------------------------------------
// is_undersc: Is this the underscore character?
//-----------------------------------------------------------------------------

        static inline bool is_undersc(char c)
                { return(c=='_'); }

//-----------------------------------------------------------------------------
// digit_val: Return int-value of digit.
//-----------------------------------------------------------------------------

        static inline int digit_val(char c) {
                switch(c) {
                        case '0': return 0;
                        case '1': return 1;
                        case '2': return 2;
                        case '3': return 3;
                        case '4': return 4;
                        case '5': return 5;
                        case '6': return 6;
                        case '7': return 7;
                        case '8': return 8;
                        case '9': return 9;
                        default:  return -1;
                }
        }

//-----------------------------------------------------------------------------
// ord: Return position in "alphabet" (for sorting purposes).
//-----------------------------------------------------------------------------

        static inline int ord(char c)
                { CHECK(Initialized,
                        "ch_c::ord(not initialized)");
                  CHECK(CH_CHARCAST(c)<Tabsize,
                        "ch_c::ord(index out of range)");
                  return(Ord[CH_CHARCAST(c)]); }

//-----------------------------------------------------------------------------
// xord: Position of second character equivalent to national character.
//-----------------------------------------------------------------------------

        static inline int xord(char c)
                { CHECK(Initialized,
                        "ch_c::xord(not initialized)");
                  CHECK(CH_CHARCAST(c)<Tabsize,
                        "ch_c::xord(index out of range)");
                  return(Xord[CH_CHARCAST(c)]); }

//=============================================================================
// This class has no objects, only static methods.
//=============================================================================

//-----------------------------------------------------------------------------
// Constructor, Destructor:
//-----------------------------------------------------------------------------

        private:

        // Constructor:
        ch_c();         // Not implemented

        // Destructor:
        ~ch_c();        // Not implemented


//-----------------------------------------------------------------------------
// Copy-constructor and assignment operator are not supported for this class:
//-----------------------------------------------------------------------------

        private:

        ch_c(const ch_c& obj);                  // Not implemented
        ch_c& operator=(const ch_c& obj);       // Not implemented

//=============================================================================
// Private Auxillary Functions:
//=============================================================================

        private:

//-----------------------------------------------------------------------------
// enter: Enter character-class translation into table.
//-----------------------------------------------------------------------------

        static inline void      enter(char c, ch_t cl);

//=============================================================================
// Private Class Members:
//=============================================================================

//-----------------------------------------------------------------------------
// Initialized: This module was initialized.
//-----------------------------------------------------------------------------

        static bool     Initialized;

//-----------------------------------------------------------------------------
// Classify: Character class of each character.
//-----------------------------------------------------------------------------

        static ch_t     Classify[CH_TABSIZE];

//-----------------------------------------------------------------------------
// IsAlnum: Which characters are alphanumeric?
//-----------------------------------------------------------------------------

        static bool     IsAlnum[CH_TABSIZE];

//-----------------------------------------------------------------------------
// Ord: Position in "alphabet" (for sorting).
//-----------------------------------------------------------------------------

        static int      Ord[CH_TABSIZE];

//-----------------------------------------------------------------------------
// Xord: Position of second character equivalent to national character.
//-----------------------------------------------------------------------------

        static int      Xord[CH_TABSIZE];

//-----------------------------------------------------------------------------
// Xupper: Extended list of uppercase characters (including national ones).
//-----------------------------------------------------------------------------

        static str_t    Xupper;

//-----------------------------------------------------------------------------
// Xlower: Extended list of lowercase characters (including national ones).
//-----------------------------------------------------------------------------

        static str_t    Xlower;

//-----------------------------------------------------------------------------
// SzLig: The german "ss" character (special for alphabetic orders).
//-----------------------------------------------------------------------------

        static char     SzLig;

//-----------------------------------------------------------------------------
// AeUpper: The nordic "Ae" character (special for alphabetic orders).
//-----------------------------------------------------------------------------

        static char     AeUpper;

//-----------------------------------------------------------------------------
// AeLower: The nordic "ae" character (special for alphabetic orders).
//-----------------------------------------------------------------------------

        static char     AeLower;

//-----------------------------------------------------------------------------
// Tabsize: To avoid warning "comparison is always true" in CECKs.
//-----------------------------------------------------------------------------

#if     VER_DEBUG
        static int      Tabsize; // Will be CH_TABSIZE
#endif

//=============================================================================
// End of Class:
//=============================================================================

};

//=============================================================================
// End of File:
//=============================================================================

#endif