/* ------------------------------------------------------------------------

   unicodedata -- Provides access to the Unicode 5.1 data base.

   Data was extracted from the Unicode 5.1 UnicodeData.txt file.

   Written by Marc-Andre Lemburg (mal@lemburg.com).

   Modified for Python 2.0 by Fredrik Lundh (fredrik@pythonware.com)

   Modified by Martin v. Löwis (martin@v.loewis.de)

   Copyright (c) Corporation for National Research Initiatives.

   ------------------------------------------------------------------------ */

#include "Python.h"

#include "ucnhash.h"

#include "structmember.h"

/* character properties */

typedef struct {

    const unsigned char category;	/* index into

					   _PyUnicode_CategoryNames */

    const unsigned char	combining; 	/* combining class value 0 - 255 */

    const unsigned char	bidirectional; 	/* index into

					   _PyUnicode_BidirectionalNames */

    const unsigned char mirrored;	/* true if mirrored in bidir mode */

    const unsigned char east_asian_width;	/* index into

						   _PyUnicode_EastAsianWidth */

} _PyUnicode_DatabaseRecord;

typedef struct change_record {

    /* sequence of fields should be the same as in merge_old_version */

    const unsigned char bidir_changed;

    const unsigned char category_changed;

    const unsigned char decimal_changed;

    const unsigned char mirrored_changed;

    const int numeric_changed;

} change_record;

/* data file generated by Tools/unicode/makeunicodedata.py */

#include "unicodedata_db.h"

static const _PyUnicode_DatabaseRecord*

_getrecord_ex(Py_UCS4 code)

{

    int index;

    if (code >= 0x110000)

        index = 0;

    else {

        index = index1[(code>>SHIFT)];

        index = index2[(index<<SHIFT)+(code&((1<<SHIFT)-1))];

    }

    return &_PyUnicode_Database_Records[index];

}

/* ------------- Previous-version API ------------------------------------- */

typedef struct previous_version {

    PyObject_HEAD

    const char *name;

    const change_record* (*getrecord)(Py_UCS4);

    Py_UCS4 (*normalization)(Py_UCS4);

} PreviousDBVersion;

#define get_old_record(self, v)    ((((PreviousDBVersion*)self)->getrecord)(v))

static PyMemberDef DB_members[] = {

	{"unidata_version", T_STRING, offsetof(PreviousDBVersion, name), READONLY},

        {NULL}

};

/* forward declaration */

static PyTypeObject UCD_Type;

static PyObject*

new_previous_version(const char*name, const change_record* (*getrecord)(Py_UCS4),

                     Py_UCS4 (*normalization)(Py_UCS4))

{

	PreviousDBVersion *self;

	self = PyObject_New(PreviousDBVersion, &UCD_Type);

	if (self == NULL)

		return NULL;

	self->name = name;

	self->getrecord = getrecord;

        self->normalization = normalization;

	return (PyObject*)self;

}

static Py_UCS4 getuchar(PyUnicodeObject *obj)

{

    Py_UNICODE *v = PyUnicode_AS_UNICODE(obj);

    if (PyUnicode_GET_SIZE(obj) == 1)

	return *v;

#ifndef Py_UNICODE_WIDE

    else if ((PyUnicode_GET_SIZE(obj) == 2) &&

             (0xD800 <= v[0] && v[0] <= 0xDBFF) &&

             (0xDC00 <= v[1] && v[1] <= 0xDFFF))

	return (((v[0] & 0x3FF)<<10) | (v[1] & 0x3FF)) + 0x10000;

#endif

    PyErr_SetString(PyExc_TypeError,

                    "need a single Unicode character as parameter");

    return (Py_UCS4)-1;

}

/* --- Module API --------------------------------------------------------- */

PyDoc_STRVAR(unicodedata_decimal__doc__,

"decimal(unichr[, default])\n\

\n\

Returns the decimal value assigned to the Unicode character unichr\n\

as integer. If no such value is defined, default is returned, or, if\n\

not given, ValueError is raised.");

static PyObject *

unicodedata_decimal(PyObject *self, PyObject *args)

{

    PyUnicodeObject *v;

    PyObject *defobj = NULL;

    int have_old = 0;

    long rc;

    Py_UCS4 c;

    if (!PyArg_ParseTuple(args, "O!|O:decimal", &PyUnicode_Type, &v, &defobj))

        return NULL;

    c = getuchar(v);

    if (c == (Py_UCS4)-1)

        return NULL;

    if (self) {

        const change_record *old = get_old_record(self, c);

        if (old->category_changed == 0) {

            /* unassigned */

            have_old = 1;

            rc = -1;

        } 

        else if (old->decimal_changed != 0xFF) {

            have_old = 1;

            rc = old->decimal_changed;

        }

    }

    if (!have_old)

        rc = Py_UNICODE_TODECIMAL(c);

    if (rc < 0) {

	if (defobj == NULL) {

	    PyErr_SetString(PyExc_ValueError,

			    "not a decimal");

            return NULL;

	}

	else {

	    Py_INCREF(defobj);

	    return defobj;

	}

    }

    return PyInt_FromLong(rc);

}

PyDoc_STRVAR(unicodedata_digit__doc__,

"digit(unichr[, default])\n\

\n\

Returns the digit value assigned to the Unicode character unichr as\n\

integer. If no such value is defined, default is returned, or, if\n\

not given, ValueError is raised.");

static PyObject *

unicodedata_digit(PyObject *self, PyObject *args)

{

    PyUnicodeObject *v;

    PyObject *defobj = NULL;

    long rc;

    Py_UCS4 c;

    if (!PyArg_ParseTuple(args, "O!|O:digit", &PyUnicode_Type, &v, &defobj))

        return NULL;

    c = getuchar(v);

    if (c == (Py_UCS4)-1)

        return NULL;

    rc = Py_UNICODE_TODIGIT(c);

    if (rc < 0) {

	if (defobj == NULL) {

	    PyErr_SetString(PyExc_ValueError, "not a digit");

            return NULL;

	}

	else {

	    Py_INCREF(defobj);

	    return defobj;

	}

    }

    return PyInt_FromLong(rc);

}

PyDoc_STRVAR(unicodedata_numeric__doc__,

"numeric(unichr[, default])\n\

\n\

Returns the numeric value assigned to the Unicode character unichr\n\

as float. If no such value is defined, default is returned, or, if\n\

not given, ValueError is raised.");

static PyObject *

unicodedata_numeric(PyObject *self, PyObject *args)

{

    PyUnicodeObject *v;

    PyObject *defobj = NULL;

    int have_old = 0;

    double rc;

    Py_UCS4 c;

    if (!PyArg_ParseTuple(args, "O!|O:numeric", &PyUnicode_Type, &v, &defobj))

        return NULL;

    c = getuchar(v);

    if (c == (Py_UCS4)-1)

        return NULL;

    if (self) {

        const change_record *old = get_old_record(self, c);

        if (old->category_changed == 0) {

            /* unassigned */

            have_old = 1;

            rc = -1.0;

        } 

        else if (old->decimal_changed != 0xFF) {

            have_old = 1;

            rc = old->decimal_changed;

        }

    }

    if (!have_old)

        rc = Py_UNICODE_TONUMERIC(c);

    if (rc == -1.0) {

	if (defobj == NULL) {

	    PyErr_SetString(PyExc_ValueError, "not a numeric character");

	    return NULL;

	}

	else {

	    Py_INCREF(defobj);

	    return defobj;

	}

    }

    return PyFloat_FromDouble(rc);

}

PyDoc_STRVAR(unicodedata_category__doc__,

"category(unichr)\n\

\n\

Returns the general category assigned to the Unicode character\n\

unichr as string.");

static PyObject *

unicodedata_category(PyObject *self, PyObject *args)

{

    PyUnicodeObject *v;

    int index;

    Py_UCS4 c;

    if (!PyArg_ParseTuple(args, "O!:category",

			  &PyUnicode_Type, &v))

	return NULL;

    c = getuchar(v);

    if (c == (Py_UCS4)-1)

        return NULL;

    index = (int) _getrecord_ex(c)->category;

    if (self) {

        const change_record *old = get_old_record(self, c);

        if (old->category_changed != 0xFF)

            index = old->category_changed;

    }

    return PyString_FromString(_PyUnicode_CategoryNames[index]);

}

PyDoc_STRVAR(unicodedata_bidirectional__doc__,

"bidirectional(unichr)\n\

\n\

Returns the bidirectional category assigned to the Unicode character\n\

unichr as string. If no such value is defined, an empty string is\n\

returned.");

static PyObject *

unicodedata_bidirectional(PyObject *self, PyObject *args)

{

    PyUnicodeObject *v;

    int index;

    Py_UCS4 c;

    if (!PyArg_ParseTuple(args, "O!:bidirectional",

			  &PyUnicode_Type, &v))

	return NULL;

    c = getuchar(v);

    if (c == (Py_UCS4)-1)

        return NULL;

    index = (int) _getrecord_ex(c)->bidirectional;

    if (self) {

        const change_record *old = get_old_record(self, c);

        if (old->category_changed == 0)

            index = 0; /* unassigned */

        else if (old->bidir_changed != 0xFF)

            index = old->bidir_changed;

    }

    return PyString_FromString(_PyUnicode_BidirectionalNames[index]);

}

PyDoc_STRVAR(unicodedata_combining__doc__,

"combining(unichr)\n\

\n\

Returns the canonical combining class assigned to the Unicode\n\

character unichr as integer. Returns 0 if no combining class is\n\

defined.");

static PyObject *

unicodedata_combining(PyObject *self, PyObject *args)

{

    PyUnicodeObject *v;

    int index;

    Py_UCS4 c;

    if (!PyArg_ParseTuple(args, "O!:combining",

			  &PyUnicode_Type, &v))

	return NULL;

    c = getuchar(v);

    if (c == (Py_UCS4)-1)

        return NULL;

    index = (int) _getrecord_ex(c)->combining;

    if (self) {

        const change_record *old = get_old_record(self, c);

        if (old->category_changed == 0)

            index = 0; /* unassigned */

    }

    return PyInt_FromLong(index);

}

PyDoc_STRVAR(unicodedata_mirrored__doc__,

"mirrored(unichr)\n\

\n\

Returns the mirrored property assigned to the Unicode character\n\

unichr as integer. Returns 1 if the character has been identified as\n\

a \"mirrored\" character in bidirectional text, 0 otherwise.");

static PyObject *

unicodedata_mirrored(PyObject *self, PyObject *args)

{

    PyUnicodeObject *v;

    int index;

    Py_UCS4 c;

    if (!PyArg_ParseTuple(args, "O!:mirrored",

			  &PyUnicode_Type, &v))

	return NULL;

    c = getuchar(v);

    if (c == (Py_UCS4)-1)

        return NULL;

    index = (int) _getrecord_ex(c)->mirrored;

    if (self) {

        const change_record *old = get_old_record(self, c);

        if (old->category_changed == 0)

            index = 0; /* unassigned */

        else if (old->mirrored_changed != 0xFF)

            index = old->mirrored_changed;

    }

    return PyInt_FromLong(index);

}

PyDoc_STRVAR(unicodedata_east_asian_width__doc__,

"east_asian_width(unichr)\n\

\n\

Returns the east asian width assigned to the Unicode character\n\

unichr as string.");

static PyObject *

unicodedata_east_asian_width(PyObject *self, PyObject *args)

{

    PyUnicodeObject *v;

    int index;

    Py_UCS4 c;

    if (!PyArg_ParseTuple(args, "O!:east_asian_width",

			  &PyUnicode_Type, &v))

	return NULL;

    c = getuchar(v);

    if (c == (Py_UCS4)-1)

        return NULL;

    index = (int) _getrecord_ex(c)->east_asian_width;

    if (self) {

        const change_record *old = get_old_record(self, c);

        if (old->category_changed == 0)

            index = 0; /* unassigned */

    }

    return PyString_FromString(_PyUnicode_EastAsianWidthNames[index]);

}

PyDoc_STRVAR(unicodedata_decomposition__doc__,

"decomposition(unichr)\n\

\n\

Returns the character decomposition mapping assigned to the Unicode\n\

character unichr as string. An empty string is returned in case no\n\

such mapping is defined.");

static PyObject *

unicodedata_decomposition(PyObject *self, PyObject *args)

{

    PyUnicodeObject *v;

    char decomp[256];

    int code, index, count, i;

    unsigned int prefix_index;

    Py_UCS4 c;

    if (!PyArg_ParseTuple(args, "O!:decomposition",

			  &PyUnicode_Type, &v))

	return NULL;

    c = getuchar(v);

    if (c == (Py_UCS4)-1)

        return NULL;

    code = (int)c;

    if (self) {

        const change_record *old = get_old_record(self, c);

        if (old->category_changed == 0)

            return PyString_FromString(""); /* unassigned */

    }

    if (code < 0 || code >= 0x110000)

        index = 0;

    else {

        index = decomp_index1[(code>>DECOMP_SHIFT)];

        index = decomp_index2[(index<<DECOMP_SHIFT)+

                             (code&((1<<DECOMP_SHIFT)-1))];

    }

    /* high byte is number of hex bytes (usually one or two), low byte

       is prefix code (from*/

    count = decomp_data[index] >> 8;

    /* XXX: could allocate the PyString up front instead

       (strlen(prefix) + 5 * count + 1 bytes) */

    /* Based on how index is calculated above and decomp_data is generated

       from Tools/unicode/makeunicodedata.py, it should not be possible

       to overflow decomp_prefix. */

    prefix_index = decomp_data[index] & 255;

    assert(prefix_index < (sizeof(decomp_prefix)/sizeof(*decomp_prefix)));

    /* copy prefix */

    i = strlen(decomp_prefix[prefix_index]);

    memcpy(decomp, decomp_prefix[prefix_index], i);

    while (count-- > 0) {

        if (i)

            decomp[i++] = ' ';

        assert((size_t)i < sizeof(decomp));

        PyOS_snprintf(decomp + i, sizeof(decomp) - i, "%04X",

                      decomp_data[++index]);

        i += strlen(decomp + i);

    }

    decomp[i] = '\0';

    return PyString_FromString(decomp);

}

static void

get_decomp_record(PyObject *self, Py_UCS4 code, int *index, int *prefix, int *count)

{

    if (code >= 0x110000) {

        *index = 0;

    } else if (self && get_old_record(self, code)->category_changed==0) {

        /* unassigned in old version */

        *index = 0;

    }

    else {

        *index = decomp_index1[(code>>DECOMP_SHIFT)];

        *index = decomp_index2[(*index<<DECOMP_SHIFT)+

                               (code&((1<<DECOMP_SHIFT)-1))];

    }

    /* high byte is number of hex bytes (usually one or two), low byte

       is prefix code (from*/

    *count = decomp_data[*index] >> 8;

    *prefix = decomp_data[*index] & 255;

    (*index)++;

}

#define SBase   0xAC00

#define LBase   0x1100

#define VBase   0x1161

#define TBase   0x11A7

#define LCount  19

#define VCount  21

#define TCount  28

#define NCount  (VCount*TCount)

#define SCount  (LCount*NCount)

static PyObject*

nfd_nfkd(PyObject *self, PyObject *input, int k)

{

    PyObject *result;

    Py_UNICODE *i, *end, *o;

    /* Longest decomposition in Unicode 3.2: U+FDFA */

    Py_UNICODE stack[20]; 

    Py_ssize_t space, isize;

    int index, prefix, count, stackptr;

    unsigned char prev, cur;

    stackptr = 0;

    isize = PyUnicode_GET_SIZE(input);

    /* Overallocate atmost 10 characters. */

    space = (isize > 10 ? 10 : isize) + isize;

    result = PyUnicode_FromUnicode(NULL, space);

    if (!result)

        return NULL;

    i = PyUnicode_AS_UNICODE(input);

    end = i + isize;

    o = PyUnicode_AS_UNICODE(result);

    while (i < end) {

        stack[stackptr++] = *i++;

        while(stackptr) {

            Py_UNICODE code = stack[--stackptr];

            /* Hangul Decomposition adds three characters in

               a single step, so we need atleast that much room. */

            if (space < 3) {

                Py_ssize_t newsize = PyString_GET_SIZE(result) + 10;

                space += 10;

                if (PyUnicode_Resize(&result, newsize) == -1)

                    return NULL;

                o = PyUnicode_AS_UNICODE(result) + newsize - space;

            }