re2c::Enc Class Reference

#include <enc.h>

Public Types
enum	type_t {   ASCII, EBCDIC, UCS2, UTF16,   UTF32, UTF8 }
enum	policy_t { POLICY_FAIL, POLICY_SUBSTITUTE, POLICY_IGNORE }

Public Member Functions
	Enc ()
bool	operator!= (const Enc &e) const
uint32_t	nCodePoints () const
uint32_t	nCodeUnits () const
uint32_t	szCodePoint () const
uint32_t	szCodeUnit () const
bool	set (type_t t)
void	unset (type_t)
type_t	type () const
void	setPolicy (policy_t t)
bool	encode (uint32_t &c) const
uint32_t	decodeUnsafe (uint32_t c) const
Range *	encodeRange (uint32_t l, uint32_t h) const
Range *	fullRange () const

Static Public Member Functions
static const char *	name (type_t t)

Detailed Description

Definition at line 38 of file enc.h.

Member Enumeration Documentation

enum re2c::Enc::policy_t

Enumerator
POLICY_FAIL
POLICY_SUBSTITUTE
POLICY_IGNORE

Definition at line 52 of file enc.h.

        { POLICY_FAIL
        , POLICY_SUBSTITUTE
        , POLICY_IGNORE
        };

enum re2c::Enc::type_t

Enumerator
ASCII
EBCDIC
UCS2
UTF16
UTF32
UTF8

Definition at line 42 of file enc.h.

        { ASCII
        , EBCDIC
        , UCS2
        , UTF16
        , UTF32
        , UTF8
        };

Constructor & Destructor Documentation

re2c::Enc::Enc ( )

inline

Definition at line 69 of file enc.h.

        : type_ (ASCII)
        , policy_ (POLICY_IGNORE)
    { }

Member Function Documentation

uint32_t re2c::Enc::decodeUnsafe

(

uint32_t

c

)

const

Definition at line 103 of file enc.cc.

{
    switch (type_)
    {
        case EBCDIC:
            c = ebc2asc[c & 0xFF];
            break;
        case ASCII:
        case UCS2:
        case UTF16:
        case UTF32:
        case UTF8:
            break;
    }
    return c;
}

Here is the caller graph for this function:

bool re2c::Enc::encode

(

uint32_t &

c

)

const

Definition at line 62 of file enc.cc.

{
    if (c >= nCodePoints ())
    {
        return false;
    }

    switch (type_)
    {
        case ASCII:
            return true;
        case EBCDIC:
            c = asc2ebc[c];
            return true;
        case UCS2:
        case UTF16:
        case UTF32:
        case UTF8:
            if (c < SURR_MIN || c > SURR_MAX)
                return true;
            else
            {
                switch (policy_)
                {
                    case POLICY_FAIL:
                        return false;
                    case POLICY_SUBSTITUTE:
                        c = UNICODE_ERROR;
                        return true;
                    case POLICY_IGNORE:
                        return true;
                }
            }
    }
    return false; // to silence gcc warning
}

Here is the call graph for this function:

Here is the caller graph for this function:

Range * re2c::Enc::encodeRange	(	uint32_t	l,
		uint32_t	h
	)		const

Definition at line 132 of file enc.cc.

{
    if (l >= nCodePoints () || h >= nCodePoints ())
    {
        return NULL;
    }

    Range * r = NULL;
    switch (type_)
    {
        case ASCII:
            r = Range::ran (l, h + 1);
            break;
        case EBCDIC:
        {
            const uint32_t el = asc2ebc[l];
            r = Range::sym (el);
            for (uint32_t c = l + 1; c <= h; ++c)
            {
                const uint32_t ec = asc2ebc[c];
                r = Range::add (r, Range::sym (ec));
            }
            break;
        }
        case UCS2:
        case UTF16:
        case UTF32:
        case UTF8:
            r = Range::ran (l, h + 1);
            if (l <= SURR_MAX && h >= SURR_MIN)
            {
                switch (policy_)
                {
                    case POLICY_FAIL:
                        r = NULL;
                        break;
                    case POLICY_SUBSTITUTE:
                    {
                        Range * surrs = Range::ran (SURR_MIN, SURR_MAX + 1);
                        Range * error = Range::sym (UNICODE_ERROR);
                        r = Range::sub (r, surrs);
                        r = Range::add (r, error);
                        break;
                    }
                    case POLICY_IGNORE:
                        break;
                }
            }
            break;
    }
    return r;
}

Here is the call graph for this function:

Range * re2c::Enc::fullRange

(

)

const

Definition at line 195 of file enc.cc.

{
    Range * r = Range::ran (0, nCodePoints());
    if (policy_ != POLICY_IGNORE)
    {
        Range * surrs = Range::ran (SURR_MIN, SURR_MAX + 1);
        r = Range::sub (r, surrs);
    }
    return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char * re2c::Enc::name ( type_t  t )

inlinestatic

Definition at line 95 of file enc.h.

{
    switch (t)
    {
        case ASCII:  return "ASCII";
        case EBCDIC: return "EBCDIC";
        case UTF8:   return "UTF8";
        case UCS2:   return "USC2";
        case UTF16:  return "UTF16";
        case UTF32:  return "UTF32";
        default:     return "<bad encoding>";
    }
}

uint32_t re2c::Enc::nCodePoints ( ) const

inline

Definition at line 109 of file enc.h.

{
    switch (type_)
    {
        case ASCII:
        case EBCDIC:    return 0x100;
        case UCS2:  return 0x10000;
        case UTF16:
        case UTF32:
        case UTF8:
        default:    return 0x110000;
    }
}

Here is the caller graph for this function:

uint32_t re2c::Enc::nCodeUnits ( ) const

inline

Definition at line 123 of file enc.h.

{
    switch (type_)
    {
        case ASCII:
        case EBCDIC:
        case UTF8:  return 0x100;
        case UCS2:
        case UTF16: return 0x10000;
        case UTF32:
        default:    return 0x110000;
    }
}

Here is the caller graph for this function:

bool re2c::Enc::operator!= ( const Enc &  e ) const

inline

Definition at line 76 of file enc.h.

{ return type_ != e.type_; }

bool re2c::Enc::set ( type_t  t )

inline

Definition at line 166 of file enc.h.

{
    if (type_ == t)
        return true;
    else if (type_ != ASCII)
        return false;
    else
    {
        type_ = t;
        return true;
    }
}

Here is the caller graph for this function:

void re2c::Enc::setPolicy ( policy_t  t )

inline

Definition at line 190 of file enc.h.

{
    policy_ = t;
}

Here is the caller graph for this function:

uint32_t re2c::Enc::szCodePoint ( ) const

inline

Definition at line 138 of file enc.h.

{
    switch (type_)
    {
        case ASCII:
        case EBCDIC:    return 1;
        case UCS2:  return 2;
        case UTF16:
        case UTF32:
        case UTF8:
        default:    return 4;
    }
}

uint32_t re2c::Enc::szCodeUnit ( ) const

inline

Definition at line 152 of file enc.h.

{
    switch (type_)
    {
        case ASCII:
        case EBCDIC:
        case UTF8:  return 1;
        case UCS2:
        case UTF16: return 2;
        case UTF32:
        default:    return 4;
    }
}

Here is the caller graph for this function:

Enc::type_t re2c::Enc::type ( ) const

inline

Definition at line 185 of file enc.h.

{
    return type_;
}

Here is the caller graph for this function:

void re2c::Enc::unset ( type_t  t )

inline

Definition at line 179 of file enc.h.

{
    if (type_ == t)
        type_ = ASCII;
}

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• ir/regexp/encoding/enc.h
• ir/regexp/encoding/enc.cc