enc.h

Go to the documentation of this file.

#ifndef _RE2C_IR_REGEXP_ENCODING_ENC_
#define _RE2C_IR_REGEXP_ENCODING_ENC_

#include "src/util/c99_stdint.h"

namespace re2c {

class Range;

/*
 * note [encodings]
 *
 * Each encoding defines two concepts:
 *
 * 1) Code point -- abstract number, which represents single encoding symbol.
 *    E.g., Unicode defines code points in the range [0 - 0x10FFFF] , so each
 *    Unicode encoding must be capable of representing 0x110000 code points.
 *
 * 2) Code unit -- the smallest unit of memory, which is used in the encoded
 *    text. One or more code units can be needed to represent a single code
 *    point, depending on the encoding. For each encoding, all code points
 *    either are represented with equal number of code units (fixed-length
 *    encodings), or with variable number of code units (variable-length
 *    encodings).
 *
 * +----------+------------------+-----------------------+-----------------+----------------+
 * | encoding | code point range | code point size       | code unit range | code unit size |
 * +----------+------------------+-----------------------+-----------------+----------------+
 * | ASCII    | 0 - 0xFF         | fixed,        1 byte  | 0 - 0xFF        | 1 byte         |
 * | EBCDIC   | 0 - 0xFF         | fixed,        1 byte  | 0 - 0xFF        | 1 byte         |
 * | UCS2     | 0 - 0xFFFF       | fixed,        2 bytes | 0 - 0xFFFF      | 2 bytes        |
 * | UTF16    | 0 - 0x10FFFF     | variable, 2 - 4 bytes | 0 - 0xFFFF      | 2 bytes        |
 * | UTF32    | 0 - 0x10FFFF     | fixed,        4 bytes | 0 - 0x10FFFF    | 4 bytes        |
 * | UTF8     | 0 - 0x10FFFF     | variable, 1 - 4 bytes | 0 - 0xFF        | 1 byte         |
 * +----------+------------------+-----------------------+-----------------+----------------+
 */

class Enc
{
public:
    // Supported encodings.
    enum type_t
        { ASCII
        , EBCDIC
        , UCS2
        , UTF16
        , UTF32
        , UTF8
        };

    // What to do with invalid code points
    enum policy_t
        { POLICY_FAIL
        , POLICY_SUBSTITUTE
        , POLICY_IGNORE
        };

private:
    static const uint32_t asc2ebc[256];
    static const uint32_t ebc2asc[256];
    static const uint32_t SURR_MIN;
    static const uint32_t SURR_MAX;
    static const uint32_t UNICODE_ERROR;

    type_t type_;
    policy_t policy_;

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

    static const char * name (type_t t);

    bool operator != (const Enc & e) const { return type_ != e.type_; }

    inline uint32_t nCodePoints() const;
    inline uint32_t nCodeUnits() const;
    inline uint32_t szCodePoint() const;
    inline uint32_t szCodeUnit() const;

    inline bool set(type_t t);
    inline void unset(type_t);
    inline type_t type () const;

    inline 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;
};

inline const char * Enc::name (type_t t)
{
    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>";
    }
}

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

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

// returns *maximal* code point size for encoding
inline uint32_t Enc::szCodePoint() const
{
    switch (type_)
    {
        case ASCII:
        case EBCDIC:    return 1;
        case UCS2:  return 2;
        case UTF16:
        case UTF32:
        case UTF8:
        default:    return 4;
    }
}

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

inline bool Enc::set(type_t t)
{
    if (type_ == t)
        return true;
    else if (type_ != ASCII)
        return false;
    else
    {
        type_ = t;
        return true;
    }
}

inline void Enc::unset(type_t t)
{
    if (type_ == t)
        type_ = ASCII;
}

inline Enc::type_t Enc::type () const
{
    return type_;
}

inline void Enc::setPolicy(policy_t t)
{
    policy_ = t;
}

} // namespace re2c

#endif // _RE2C_IR_REGEXP_ENCODING_ENC_