// ***************************************************************** -*- C++ -*-

/*

 * Copyright (C) 2004-2018 Exiv2 authors

 * This program is part of the Exiv2 distribution.

 *

 * 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 2

 * of the License, 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., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.

 */

/*

  File:      types.cpp

  Author(s): Andreas Huggel (ahu) <ahuggel@gmx.net>

  History:   26-Jan-04, ahu: created

             11-Feb-04, ahu: isolated as a component

 */

// *****************************************************************************

// included header files

#include "types.hpp"

#include "enforce.hpp"

#include "futils.hpp"

#include "i18n.h"  // for _exvGettext

#include "safe_op.hpp"

#include "unused.h"

// + standard includes

#ifdef EXV_UNICODE_PATH

# include <windows.h> // for MultiByteToWideChar etc

#endif

#include <string>

#include <iostream>

#include <iomanip>

#include <sstream>

#include <utility>

#include <cctype>

#include <ctime>

#include <cstdio>

#include <cstdlib>

#include <cassert>

#include <cstring>

#include <cmath>

#include <math.h>

// *****************************************************************************

namespace {

    //! Information pertaining to the defined %Exiv2 value type identifiers.

    struct TypeInfoTable {

        Exiv2::TypeId typeId_;                  //!< Type id

        const char* name_;                      //!< Name of the type

        long size_;                             //!< Bytes per data entry

        //! Comparison operator for \em typeId

        bool operator==(Exiv2::TypeId typeId) const

        {

            return typeId_ == typeId;

        }

        //! Comparison operator for \em name

        bool operator==(const std::string& name) const

        {

            return 0 == strcmp(name_, name.c_str());

        }

    }; // struct TypeInfoTable

    //! Lookup list with information of Exiv2 types

    const TypeInfoTable typeInfoTable[] = {

        { Exiv2::invalidTypeId,    "Invalid",     0 },

        { Exiv2::unsignedByte,     "Byte",        1 },

        { Exiv2::asciiString,      "Ascii",       1 },

        { Exiv2::unsignedShort,    "Short",       2 },

        { Exiv2::unsignedLong,     "Long",        4 },

        { Exiv2::unsignedRational, "Rational",    8 },

        { Exiv2::signedByte,       "SByte",       1 },

        { Exiv2::undefined,        "Undefined",   1 },

        { Exiv2::signedShort,      "SShort",      2 },

        { Exiv2::signedLong,       "SLong",       4 },

        { Exiv2::signedRational,   "SRational",   8 },

        { Exiv2::tiffFloat,        "Float",       4 },

        { Exiv2::tiffDouble,       "Double",      8 },

        { Exiv2::tiffIfd,          "Ifd",         4 },

        { Exiv2::string,           "String",      1 },

        { Exiv2::date,             "Date",        8 },

        { Exiv2::time,             "Time",       11 },

        { Exiv2::comment,          "Comment",     1 },

        { Exiv2::directory,        "Directory",   1 },

        { Exiv2::xmpText,          "XmpText",     1 },

        { Exiv2::xmpAlt,           "XmpAlt",      1 },

        { Exiv2::xmpBag,           "XmpBag",      1 },

        { Exiv2::xmpSeq,           "XmpSeq",      1 },

        { Exiv2::langAlt,          "LangAlt",     1 }

    };

}

// *****************************************************************************

// class member definitions

namespace Exiv2 {

    const char* TypeInfo::typeName(TypeId typeId)

    {

        const TypeInfoTable* tit = find(typeInfoTable, typeId);

        if (!tit) return 0;

        return tit->name_;

    }

    TypeId TypeInfo::typeId(const std::string& typeName)

    {

        const TypeInfoTable* tit = find(typeInfoTable, typeName);

        if (!tit) return invalidTypeId;

        return tit->typeId_;

    }

    long TypeInfo::typeSize(TypeId typeId)

    {

        const TypeInfoTable* tit = find(typeInfoTable, typeId);

        if (!tit) return 0;

        return tit->size_;

    }

    DataBuf::DataBuf(DataBuf& rhs)

        : pData_(rhs.pData_), size_(rhs.size_)

    {

        std::pair<byte*, long> ret = rhs.release();

        UNUSED(ret);

    }

    DataBuf::~DataBuf()

    { delete[] pData_; }

    DataBuf::DataBuf() : pData_(0), size_(0)

    {}

    DataBuf::DataBuf(long size) : pData_(new byte[size]()), size_(size)

    {}

    DataBuf::DataBuf(const byte* pData, long size)

        : pData_(0), size_(0)

    {

        if (size > 0) {

            pData_ = new byte[size];

            std::memcpy(pData_, pData, size);

            size_ = size;

        }

    }

    DataBuf& DataBuf::operator=(DataBuf& rhs)

    {

        if (this == &rhs) return *this;

        reset(rhs.release());

        return *this;

    }

    void DataBuf::alloc(long size)

    {

        if (size > size_) {

            delete[] pData_;

            pData_ = 0;

            size_ = 0;

            pData_ = new byte[size];

            size_ = size;

        }

    }

    EXV_WARN_UNUSED_RESULT std::pair<byte*, long> DataBuf::release()

    {

        std::pair<byte*, long> p = std::make_pair(pData_, size_);

        pData_ = 0;

        size_ = 0;

        return p;

    }

    void DataBuf::free()

    {

        delete[] pData_;

        pData_ = 0;

        size_ = 0;

    }

    void DataBuf::reset(std::pair<byte*, long> p)

    {

        if (pData_ != p.first) {

            delete[] pData_;

            pData_ = p.first;

        }

        size_ = p.second;

    }

    DataBuf::DataBuf(const DataBufRef &rhs) : pData_(rhs.p.first), size_(rhs.p.second) {}

    DataBuf &DataBuf::operator=(DataBufRef rhs) { reset(rhs.p); return *this; }

    Exiv2::DataBuf::operator DataBufRef() { return DataBufRef(release()); }

    // *************************************************************************

    // free functions

    static void checkDataBufBounds(const DataBuf& buf, size_t end) {

        enforce<std::invalid_argument>(end <= static_cast<size_t>(std::numeric_limits<long>::max()),

                                       "end of slice too large to be compared with DataBuf bounds.");

        enforce<std::out_of_range>(static_cast<long>(end) <= buf.size_, "Invalid slice bounds specified");

    }

    Slice<byte*> makeSlice(DataBuf& buf, size_t begin, size_t end)

    {

        checkDataBufBounds(buf, end);

        return Slice<byte*>(buf.pData_, begin, end);

    }

    Slice<const byte*> makeSlice(const DataBuf& buf, size_t begin, size_t end)

    {

        checkDataBufBounds(buf, end);

        return Slice<const byte*>(buf.pData_, begin, end);

    }

    std::ostream& operator<<(std::ostream& os, const Rational& r)

    {

        return os << r.first << "/" << r.second;

    }

    std::istream& operator>>(std::istream& is, Rational& r)

    {

        // http://dev.exiv2.org/boards/3/topics/1912?r=1915

        if ( std::tolower(is.peek()) == 'f' ) {

            char  F = 0;

            float f = 0.f;

            is >> F >> f ;

            f  = 2.0f * std::log(f) / std::log(2.0f) ;

            r  = Exiv2::floatToRationalCast(f);

        } else {

            int32_t nominator = 0;

            int32_t denominator = 0;

            char c('\0');

            is >> nominator >> c >> denominator;

            if (c != '/')

                is.setstate(std::ios::failbit);

            if (is)

                r = std::make_pair(nominator, denominator);

        }

        return is;

    }

    std::ostream& operator<<(std::ostream& os, const URational& r)

    {

        return os << r.first << "/" << r.second;

    }

    std::istream& operator>>(std::istream& is, URational& r)

    {

        // http://dev.exiv2.org/boards/3/topics/1912?r=1915

        /// \todo This implementation seems to be duplicated for the Rational type. Try to remove duplication

        if ( std::tolower(is.peek()) == 'f' ) {

            char  F = 0;

            float f = 0.f;

            is >> F >> f ;

            f  = 2.0f * std::log(f) / std::log(2.0f) ;

            r  = Exiv2::floatToRationalCast(f);

        } else {

            uint32_t nominator = 0;

            uint32_t denominator = 0;

            char c('\0');

            is >> nominator >> c >> denominator;

            if (c != '/')

                is.setstate(std::ios::failbit);

            if (is)

                r = std::make_pair(nominator, denominator);

        }

        return is;

    }

    uint16_t getUShort(const byte* buf, ByteOrder byteOrder)

    {

        return getUShort(makeSliceUntil(buf, 2), byteOrder);

    }

    uint32_t getULong(const byte* buf, ByteOrder byteOrder)

    {

        if (byteOrder == littleEndian) {

            return   (byte)buf[3] << 24 | (byte)buf[2] << 16

                   | (byte)buf[1] <<  8 | (byte)buf[0];

        }

        else {

            return   (byte)buf[0] << 24 | (byte)buf[1] << 16

                   | (byte)buf[2] <<  8 | (byte)buf[3];

        }

    }

    uint64_t getULongLong(const byte* buf, ByteOrder byteOrder)

    {

        if (byteOrder == littleEndian) {

            return   (uint64_t)buf[7] << 56 | (uint64_t)buf[6] << 48

                   | (uint64_t)buf[5] << 40 | (uint64_t)buf[4] << 32

                   | (uint64_t)buf[3] << 24 | (uint64_t)buf[2] << 16

                   | (uint64_t)buf[1] <<  8 | (uint64_t)buf[0];

        }

        else {

            return   (uint64_t)buf[0] << 56 | (uint64_t)buf[1] << 48

                   | (uint64_t)buf[2] << 40 | (uint64_t)buf[3] << 32

                   | (uint64_t)buf[4] << 24 | (uint64_t)buf[5] << 16

                   | (uint64_t)buf[6] <<  8 | (uint64_t)buf[7];

        }

    }

    URational getURational(const byte* buf, ByteOrder byteOrder)

    {

        uint32_t nominator = getULong(buf, byteOrder);

        uint32_t denominator = getULong(buf + 4, byteOrder);

        return std::make_pair(nominator, denominator);

    }

    int16_t getShort(const byte* buf, ByteOrder byteOrder)

    {

        if (byteOrder == littleEndian) {

            return (byte)buf[1] << 8 | (byte)buf[0];

        }

        else {

            return (byte)buf[0] << 8 | (byte)buf[1];

        }

    }

    int32_t getLong(const byte* buf, ByteOrder byteOrder)

    {

        if (byteOrder == littleEndian) {

            return   (byte)buf[3] << 24 | (byte)buf[2] << 16

                   | (byte)buf[1] <<  8 | (byte)buf[0];

        }

        else {

            return   (byte)buf[0] << 24 | (byte)buf[1] << 16

                   | (byte)buf[2] <<  8 | (byte)buf[3];

        }

    }

    Rational getRational(const byte* buf, ByteOrder byteOrder)

    {

        int32_t nominator = getLong(buf, byteOrder);

        int32_t denominator = getLong(buf + 4, byteOrder);

        return std::make_pair(nominator, denominator);

    }

    float getFloat(const byte* buf, ByteOrder byteOrder)

    {

        // This algorithm assumes that the internal representation of the float

        // type is the 4-byte IEEE 754 binary32 format, which is common but not

        // required by the C++ standard.

        assert(sizeof(float) == 4);

        union {

            uint32_t ul_;

            float    f_;

        } u;

        u.ul_ = getULong(buf, byteOrder);

        return u.f_;

    }

    double getDouble(const byte* buf, ByteOrder byteOrder)

    {

        // This algorithm assumes that the internal representation of the double

        // type is the 8-byte IEEE 754 binary64 format, which is common but not

        // required by the C++ standard.

        assert(sizeof(double) == 8);

        union {

            uint64_t ull_;

            double   d_;

        } u;

        u.ull_ = 0;

        if (byteOrder == littleEndian) {

            u.ull_ =   static_cast<uint64_t>(buf[7]) << 56

                     | static_cast<uint64_t>(buf[6]) << 48

                     | static_cast<uint64_t>(buf[5]) << 40

                     | static_cast<uint64_t>(buf[4]) << 32

                     | static_cast<uint64_t>(buf[3]) << 24

                     | static_cast<uint64_t>(buf[2]) << 16

                     | static_cast<uint64_t>(buf[1]) <<  8

                     | static_cast<uint64_t>(buf[0]);

        }

        else {

            u.ull_ =   static_cast<uint64_t>(buf[0]) << 56

                     | static_cast<uint64_t>(buf[1]) << 48

                     | static_cast<uint64_t>(buf[2]) << 40

                     | static_cast<uint64_t>(buf[3]) << 32

                     | static_cast<uint64_t>(buf[4]) << 24

                     | static_cast<uint64_t>(buf[5]) << 16

                     | static_cast<uint64_t>(buf[6]) <<  8

                     | static_cast<uint64_t>(buf[7]);

        }

        return u.d_;

    }

    long us2Data(byte* buf, uint16_t s, ByteOrder byteOrder)

    {

        if (byteOrder == littleEndian) {

            buf[0] = (byte) (s & 0x00ff);

            buf[1] = (byte)((s & 0xff00) >> 8);

        }

        else {

            buf[0] = (byte)((s & 0xff00) >> 8);

            buf[1] = (byte) (s & 0x00ff);

        }

        return 2;

    }

    long ul2Data(byte* buf, uint32_t l, ByteOrder byteOrder)

    {

        if (byteOrder == littleEndian) {

            buf[0] = (byte) (l & 0x000000ff);

            buf[1] = (byte)((l & 0x0000ff00) >> 8);

            buf[2] = (byte)((l & 0x00ff0000) >> 16);

            buf[3] = (byte)((l & 0xff000000) >> 24);

        }

        else {

            buf[0] = (byte)((l & 0xff000000) >> 24);

            buf[1] = (byte)((l & 0x00ff0000) >> 16);

            buf[2] = (byte)((l & 0x0000ff00) >> 8);

            buf[3] = (byte) (l & 0x000000ff);

        }

        return 4;

    }

    long ur2Data(byte* buf, URational l, ByteOrder byteOrder)

    {

        long o = ul2Data(buf, l.first, byteOrder);

        o += ul2Data(buf+o, l.second, byteOrder);

        return o;

    }

    long s2Data(byte* buf, int16_t s, ByteOrder byteOrder)

    {

        if (byteOrder == littleEndian) {

            buf[0] =  (byte)(s & 0x00ff);

            buf[1] = (byte)((s & 0xff00) >> 8);

        }

        else {

            buf[0] = (byte)((s & 0xff00) >> 8);

            buf[1] =  (byte)(s & 0x00ff);

        }

        return 2;

    }

    long l2Data(byte* buf, int32_t l, ByteOrder byteOrder)

    {

        if (byteOrder == littleEndian) {

            buf[0] =  (byte)(l & 0x000000ff);

            buf[1] = (byte)((l & 0x0000ff00) >> 8);

            buf[2] = (byte)((l & 0x00ff0000) >> 16);

            buf[3] = (byte)((l & 0xff000000) >> 24);

        }

        else {

            buf[0] = (byte)((l & 0xff000000) >> 24);

            buf[1] = (byte)((l & 0x00ff0000) >> 16);

            buf[2] = (byte)((l & 0x0000ff00) >> 8);

            buf[3] =  (byte)(l & 0x000000ff);

        }

        return 4;

    }

    long r2Data(byte* buf, Rational l, ByteOrder byteOrder)

    {

        long o = l2Data(buf, l.first, byteOrder);

        o += l2Data(buf+o, l.second, byteOrder);

        return o;

    }

    long f2Data(byte* buf, float f, ByteOrder byteOrder)

    {

        // This algorithm assumes that the internal representation of the float

        // type is the 4-byte IEEE 754 binary32 format, which is common but not

        // required by the C++ standard.

        assert(sizeof(float) == 4);

        union {

            uint32_t ul_;

            float    f_;

        } u;

        u.f_ = f;

        return ul2Data(buf, u.ul_, byteOrder);

    }

    long d2Data(byte* buf, double d, ByteOrder byteOrder)

    {

        // This algorithm assumes that the internal representation of the double

        // type is the 8-byte IEEE 754 binary64 format, which is common but not

        // required by the C++ standard.

        assert(sizeof(double) == 8);

        union {

            uint64_t ull_;

            double   d_;

        } u;

        u.d_ = d;

        uint64_t m = 0xff;

        if (byteOrder == littleEndian) {

            buf[0] =  (byte)(u.ull_ & m);

            buf[1] = (byte)((u.ull_ & (m <<  8)) >>  8);

            buf[2] = (byte)((u.ull_ & (m << 16)) >> 16);

            buf[3] = (byte)((u.ull_ & (m << 24)) >> 24);

            buf[4] = (byte)((u.ull_ & (m << 32)) >> 32);

            buf[5] = (byte)((u.ull_ & (m << 40)) >> 40);

            buf[6] = (byte)((u.ull_ & (m << 48)) >> 48);

            buf[7] = (byte)((u.ull_ & (m << 56)) >> 56);

        }

        else {

            buf[0] = (byte)((u.ull_ & (m << 56)) >> 56);

            buf[1] = (byte)((u.ull_ & (m << 48)) >> 48);

            buf[2] = (byte)((u.ull_ & (m << 40)) >> 40);

            buf[3] = (byte)((u.ull_ & (m << 32)) >> 32);

            buf[4] = (byte)((u.ull_ & (m << 24)) >> 24);

            buf[5] = (byte)((u.ull_ & (m << 16)) >> 16);

            buf[6] = (byte)((u.ull_ & (m <<  8)) >>  8);

            buf[7] =  (byte)(u.ull_ & m);

        }

        return 8;

    }

    void hexdump(std::ostream& os, const byte* buf, long len, long offset)

    {

        const std::string::size_type pos = 8 + 16 * 3 + 2;

        const std::string align(pos, ' ');

        std::ios::fmtflags f( os.flags() );

        long i = 0;

        while (i < len) {

            os << "  "

               << std::setw(4) << std::setfill('0') << std::hex

               << i + offset << "  ";

            std::ostringstream ss;

            do {

                byte c = buf[i];

                os << std::setw(2) << std::setfill('0') << std::right

                   << std::hex << (int)c << " ";

                ss << ((int)c >= 31 && (int)c < 127 ? char(buf[i]) : '.');

            } while (++i < len && i%16 != 0);

            std::string::size_type width = 9 + ((i-1)%16 + 1) * 3;

            os << (width > pos ? "" : align.substr(width)) << ss.str() << "\n";

        }

        os << std::dec << std::setfill(' ');

        os.flags(f);

    } // hexdump

    bool isHex(const std::string& str, size_t size, const std::string& prefix)

    {

        if (   str.size() <= prefix.size()

            || str.substr(0, prefix.size()) != prefix) return false;

        if (   size > 0

            && str.size() != size + prefix.size()) return false;

        for (size_t i = prefix.size(); i < str.size(); ++i) {

            if (!isxdigit(str[i])) return false;

        }

        return true;

    } // isHex

    int exifTime(const char* buf, struct tm* tm)

    {

        assert(buf != 0);

        assert(tm != 0);

        int rc = 1;

        int year, mon, mday, hour, min, sec;

        int scanned = std::sscanf(buf, "%4d:%2d:%2d %2d:%2d:%2d",

                                  &year, &mon, &mday, &hour, &min, &sec);

        if (scanned == 6) {

            tm->tm_year = year - 1900;

            tm->tm_mon  = mon - 1;

            tm->tm_mday = mday;

            tm->tm_hour = hour;

            tm->tm_min  = min;

            tm->tm_sec  = sec;

            rc = 0;

        }

        return rc;

    } // exifTime

    const char* exvGettext(const char* str)

    {

#ifdef EXV_ENABLE_NLS

        return _exvGettext(str);

#else

        return str;

#endif

    }

#ifdef EXV_UNICODE_PATH

    std::string ws2s(const std::wstring& s)

    {

        int len;

        int slength = (int)s.length() + 1;

        len = WideCharToMultiByte(CP_ACP, 0, s.c_str(), slength, 0, 0, 0, 0);

        char* buf = new char[len];

        WideCharToMultiByte(CP_ACP, 0, s.c_str(), slength, buf, len, 0, 0);

        std::string r(buf);

        delete[] buf;

        return r;

    }

    std::wstring s2ws(const std::string& s)

    {

        int len;

        int slength = (int)s.length() + 1;

        len = MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, 0, 0);

        wchar_t* buf = new wchar_t[len];

        MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, buf, len);

        std::wstring r(buf);

        delete[] buf;

        return r;

    }

#endif // EXV_UNICODE_PATH

    template<>

    bool stringTo<bool>(const std::string& s, bool& ok)

    {

        std::string lcs(s); /* lowercase string */

        for(unsigned i = 0; i < lcs.length(); i++) {

            lcs[i] = std::tolower(s[i]);

        }

        /* handle the same values as xmp sdk */

        if (lcs == "false" || lcs == "f" || lcs == "0") {

            ok = true;

            return false;

        }

        if (lcs == "true" || lcs == "t" || lcs == "1") {

            ok = true;

            return true;

        }

        ok = false;

        return false;

    }

    long parseLong(const std::string& s, bool& ok)

    {

        long ret = stringTo<long>(s, ok);

        if (ok) return ret;

        float f = stringTo<float>(s, ok);

        if (ok) return static_cast<long>(f);

        Rational r = stringTo<Rational>(s, ok);

        if (ok) {

            if (r.second == 0) {

                ok = false;

                return 0;

            }

            return static_cast<long>(static_cast<float>(r.first) / r.second);

        }

        bool b = stringTo<bool>(s, ok);

        if (ok) return b ? 1 : 0;

        // everything failed, return from stringTo<long> is probably the best fit

        return ret;

    }

    float parseFloat(const std::string& s, bool& ok)

    {

        float ret = stringTo<float>(s, ok);

        if (ok) return ret;

        Rational r = stringTo<Rational>(s, ok);

        if (ok) {

            if (r.second == 0) {

                ok = false;

                return 0.0;

            }

            return static_cast<float>(r.first) / r.second;

        }

        bool b = stringTo<bool>(s, ok);

        if (ok) return b ? 1.0f : 0.0f;

        // everything failed, return from stringTo<float> is probably the best fit

        return ret;

    }

    Rational parseRational(const std::string& s, bool& ok)

    {

        Rational ret = stringTo<Rational>(s, ok);

        if (ok) return ret;

        long l = stringTo<long>(s, ok);

        if (ok) return Rational(l, 1);

        float f = stringTo<float>(s, ok);

        if (ok) return floatToRationalCast(f);

        bool b = stringTo<bool>(s, ok);

        if (ok) return b ? Rational(1, 1) : Rational(0, 1);

        // everything failed, return from stringTo<Rational> is probably the best fit

        return ret;

    }

    Rational floatToRationalCast(float f)

    {

#if defined(_MSC_VER) && _MSC_VER < 1800

        if (!_finite(f)) {

#else

        if (!std::isfinite(f)) {

#endif

            return Rational(f > 0 ? 1 : -1, 0);

        }

        // Beware: primitive conversion algorithm

        int32_t den = 1000000;

        const long f_as_long = static_cast<long>(f);

        if (Safe::abs(f_as_long) > 2147) {

            den = 10000;

        }

        if (Safe::abs(f_as_long) > 214748) {

            den = 100;

        }

        if (Safe::abs(f_as_long) > 21474836) {

            den = 1;

        }

        const float rnd = f >= 0 ? 0.5f : -0.5f;

        const int32_t nom = static_cast<int32_t>(f * den + rnd);

        const int32_t g = gcd(nom, den);

        return Rational(nom / g, den / g);

    }

}                                       // namespace Exiv2

#ifdef EXV_ENABLE_NLS

// Declaration is in i18n.h

const char* _exvGettext(const char* str)

{

    static bool exvGettextInitialized = false;

    if (!exvGettextInitialized) {

        //bindtextdomain(EXV_PACKAGE_NAME, EXV_LOCALEDIR);

        const std::string localeDir = Exiv2::getProcessPath() + EXV_LOCALEDIR;

        bindtextdomain(EXV_PACKAGE_NAME, localeDir.c_str());

# ifdef EXV_HAVE_BIND_TEXTDOMAIN_CODESET

        bind_textdomain_codeset (EXV_PACKAGE_NAME, "UTF-8");

# endif

        exvGettextInitialized = true;

    }

    return dgettext(EXV_PACKAGE_NAME, str);

}

#endif // EXV_ENABLE_NLS