#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include <stdio.h>

#include <locale.h>

#include <string.h>

#include <ctype.h>

#ifdef HAVE_ERRNO_H

#include <errno.h>

#ifdef HAVE_LANGINFO_H

#include <langinfo.h>

#ifdef HAVE_LIBINTL_H

#include <libintl.h>

#ifdef HAVE_WCHAR_H

#include <wchar.h>

#if defined(MS_WINDOWS)

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

PyDoc_STRVAR(locale__doc__, "Support for POSIX locales.");

static PyObject *Error;

PyDoc_STRVAR(setlocale__doc__,

"(integer,string=None) -> string. Activates/queries locale processing.");

static PyObject*

copy_grouping(const char* s)

{

int i;

PyObject *result, *val = NULL;

if (s[0] == '\0') {

/* empty string: no grouping at all */

return PyList_New(0);

}

for (i = 0; s[i] != '\0' && s[i] != CHAR_MAX; i++)

; /* nothing */

result = PyList_New(i+1);

if (!result)

return NULL;

i = -1;

do {

i++;

val = PyLong_FromLong(s[i]);

if (!val)

break;

if (PyList_SetItem(result, i, val)) {

Py_DECREF(val);

val = NULL;

break;

}

} while (s[i] != '\0' && s[i] != CHAR_MAX);

if (!val) {

Py_DECREF(result);

return NULL;

}

return result;

}

static PyObject*

PyLocale_setlocale(PyObject* self, PyObject* args)

{

int category;

char *locale = NULL, *result;

PyObject *result_object;

if (!PyArg_ParseTuple(args, "i|z:setlocale", &category, &locale))

return NULL;

#if defined(MS_WINDOWS)

if (category < LC_MIN || category > LC_MAX)

{

PyErr_SetString(Error, "invalid locale category");

return NULL;

}

if (locale) {

/* set locale */

result = setlocale(category, locale);

if (!result) {

/* operation failed, no setting was changed */

PyErr_SetString(Error, "unsupported locale setting");

return NULL;

}

result_object = PyUnicode_DecodeLocale(result, NULL);

if (!result_object)

return NULL;

} else {

/* get locale */

result = setlocale(category, NULL);

if (!result) {

PyErr_SetString(Error, "locale query failed");

return NULL;

}

result_object = PyUnicode_DecodeLocale(result, NULL);

}

return result_object;

}

PyDoc_STRVAR(localeconv__doc__,

"() -> dict. Returns numeric and monetary locale-specific parameters.");

static PyObject*

PyLocale_localeconv(PyObject* self, PyObject *Py_UNUSED(ignored))

{

PyObject* result;

struct lconv *l;

PyObject *x;

result = PyDict_New();

if (!result) {

return NULL;

}

/* if LC_NUMERIC is different in the C library, use saved value */

l = localeconv();

/* hopefully, the localeconv result survives the C library calls

#define RESULT(key, obj)\

do { \

if (obj == NULL) \

goto failed; \

if (PyDict_SetItemString(result, key, obj) < 0) { \

Py_DECREF(obj); \

goto failed; \

} \

Py_DECREF(obj); \

} while (0)

#define RESULT_STRING(s)\

do { \

x = PyUnicode_DecodeLocale(l->s, NULL); \

RESULT(#s, x); \

} while (0)

#define RESULT_INT(i)\

do { \

x = PyLong_FromLong(l->i); \

RESULT(#i, x); \

} while (0)

/* Monetary information */

RESULT_STRING(int_curr_symbol);

RESULT_STRING(currency_symbol);

RESULT_STRING(mon_decimal_point);

RESULT_STRING(mon_thousands_sep);

x = copy_grouping(l->mon_grouping);

RESULT("mon_grouping", x);

RESULT_STRING(positive_sign);

RESULT_STRING(negative_sign);

RESULT_INT(int_frac_digits);

RESULT_INT(frac_digits);

RESULT_INT(p_cs_precedes);

RESULT_INT(p_sep_by_space);

RESULT_INT(n_cs_precedes);

RESULT_INT(n_sep_by_space);

RESULT_INT(p_sign_posn);

RESULT_INT(n_sign_posn);

/* Numeric information */

PyObject *decimal_point, *thousands_sep;

const char *grouping;

if (_Py_GetLocaleconvNumeric(&decimal_point,

&thousands_sep,

&grouping) < 0) {

goto failed;

}

if (PyDict_SetItemString(result, "decimal_point", decimal_point) < 0) {

Py_DECREF(decimal_point);

Py_DECREF(thousands_sep);

goto failed;

}

Py_DECREF(decimal_point);

if (PyDict_SetItemString(result, "thousands_sep", thousands_sep) < 0) {

Py_DECREF(thousands_sep);

goto failed;

}

Py_DECREF(thousands_sep);

x = copy_grouping(grouping);

RESULT("grouping", x);

return result;

failed:

Py_DECREF(result);

return NULL;

}

#if defined(HAVE_WCSCOLL)

PyDoc_STRVAR(strcoll__doc__,

"string,string -> int. Compares two strings according to the locale.");

static PyObject*

PyLocale_strcoll(PyObject* self, PyObject* args)

{

PyObject *os1, *os2, *result = NULL;

wchar_t *ws1 = NULL, *ws2 = NULL;

if (!PyArg_ParseTuple(args, "UU:strcoll", &os1, &os2))

return NULL;

/* Convert the unicode strings to wchar[]. */

ws1 = PyUnicode_AsWideCharString(os1, NULL);

if (ws1 == NULL)

goto done;

ws2 = PyUnicode_AsWideCharString(os2, NULL);

if (ws2 == NULL)

goto done;

/* Collate the strings. */

result = PyLong_FromLong(wcscoll(ws1, ws2));

done:

/* Deallocate everything. */

if (ws1) PyMem_FREE(ws1);

if (ws2) PyMem_FREE(ws2);

return result;

}

#ifdef HAVE_WCSXFRM

PyDoc_STRVAR(strxfrm__doc__,

Return a string that can be used as a key for locale-aware comparisons.");

static PyObject*

PyLocale_strxfrm(PyObject* self, PyObject* args)

{

PyObject *str;

Py_ssize_t n1;

wchar_t *s = NULL, *buf = NULL;

size_t n2;

PyObject *result = NULL;

if (!PyArg_ParseTuple(args, "U:strxfrm", &str))

return NULL;

s = PyUnicode_AsWideCharString(str, &n1);

if (s == NULL)

goto exit;

if (wcslen(s) != (size_t)n1) {

PyErr_SetString(PyExc_ValueError,

"embedded null character");

goto exit;

}

/* assume no change in size, first */

n1 = n1 + 1;

buf = PyMem_New(wchar_t, n1);

if (!buf) {

PyErr_NoMemory();

goto exit;

}

errno = 0;

n2 = wcsxfrm(buf, s, n1);

if (errno && errno != ERANGE) {

PyErr_SetFromErrno(PyExc_OSError);

goto exit;

}

if (n2 >= (size_t)n1) {

/* more space needed */

wchar_t * new_buf = PyMem_Realloc(buf, (n2+1)*sizeof(wchar_t));

if (!new_buf) {

PyErr_NoMemory();

goto exit;

}

buf = new_buf;

errno = 0;

n2 = wcsxfrm(buf, s, n2+1);

if (errno) {

PyErr_SetFromErrno(PyExc_OSError);

goto exit;

}

}

result = PyUnicode_FromWideChar(buf, n2);

exit:

PyMem_Free(buf);

PyMem_Free(s);

return result;

}

#if defined(MS_WINDOWS)

static PyObject*

PyLocale_getdefaultlocale(PyObject* self, PyObject *Py_UNUSED(ignored))

{

char encoding[20];

char locale[100];

PyOS_snprintf(encoding, sizeof(encoding), "cp%d", GetACP());

if (GetLocaleInfo(LOCALE_USER_DEFAULT,

LOCALE_SISO639LANGNAME,

locale, sizeof(locale))) {

Py_ssize_t i = strlen(locale);

locale[i++] = '_';

if (GetLocaleInfo(LOCALE_USER_DEFAULT,

LOCALE_SISO3166CTRYNAME,

locale+i, (int)(sizeof(locale)-i)))

return Py_BuildValue("ss", locale, encoding);

}

/* If we end up here, this windows version didn't know about

locale[0] = '0';

locale[1] = 'x';

if (GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTLANGUAGE,

locale+2, sizeof(locale)-2)) {

return Py_BuildValue("ss", locale, encoding);

}

/* cannot determine the language code (very unlikely) */

Py_INCREF(Py_None);

return Py_BuildValue("Os", Py_None, encoding);

}

#ifdef HAVE_LANGINFO_H

#define LANGINFO(X) {#X, X}

static struct langinfo_constant{

char* name;

int value;

} langinfo_constants[] =

{

/* These constants should exist on any langinfo implementation */

LANGINFO(DAY_1),

LANGINFO(DAY_2),

LANGINFO(DAY_3),

LANGINFO(DAY_4),

LANGINFO(DAY_5),

LANGINFO(DAY_6),

LANGINFO(DAY_7),

LANGINFO(ABDAY_1),

LANGINFO(ABDAY_2),

LANGINFO(ABDAY_3),

LANGINFO(ABDAY_4),

LANGINFO(ABDAY_5),

LANGINFO(ABDAY_6),

LANGINFO(ABDAY_7),

LANGINFO(MON_1),

LANGINFO(MON_2),

LANGINFO(MON_3),

LANGINFO(MON_4),

LANGINFO(MON_5),

LANGINFO(MON_6),

LANGINFO(MON_7),

LANGINFO(MON_8),

LANGINFO(MON_9),

LANGINFO(MON_10),

LANGINFO(MON_11),

LANGINFO(MON_12),

LANGINFO(ABMON_1),

LANGINFO(ABMON_2),

LANGINFO(ABMON_3),

LANGINFO(ABMON_4),

LANGINFO(ABMON_5),

LANGINFO(ABMON_6),

LANGINFO(ABMON_7),

LANGINFO(ABMON_8),

LANGINFO(ABMON_9),

LANGINFO(ABMON_10),

LANGINFO(ABMON_11),

LANGINFO(ABMON_12),

#ifdef RADIXCHAR

/* The following are not available with glibc 2.0 */

LANGINFO(RADIXCHAR),

LANGINFO(THOUSEP),

/* YESSTR and NOSTR are deprecated in glibc, since they are

LANGINFO(CRNCYSTR),

LANGINFO(D_T_FMT),

LANGINFO(D_FMT),

LANGINFO(T_FMT),

LANGINFO(AM_STR),

LANGINFO(PM_STR),

/* The following constants are available only with XPG4, but...

#ifdef CODESET

LANGINFO(CODESET),

#ifdef T_FMT_AMPM

LANGINFO(T_FMT_AMPM),

#ifdef ERA

LANGINFO(ERA),

#ifdef ERA_D_FMT

LANGINFO(ERA_D_FMT),

#ifdef ERA_D_T_FMT

LANGINFO(ERA_D_T_FMT),

#ifdef ERA_T_FMT

LANGINFO(ERA_T_FMT),

#ifdef ALT_DIGITS

LANGINFO(ALT_DIGITS),

#ifdef YESEXPR

LANGINFO(YESEXPR),

#ifdef NOEXPR

LANGINFO(NOEXPR),

#ifdef _DATE_FMT

/* This is not available in all glibc versions that have CODESET. */

LANGINFO(_DATE_FMT),

{0, 0}

};

PyDoc_STRVAR(nl_langinfo__doc__,

"Return the value for the locale information associated with key.");

static PyObject*

PyLocale_nl_langinfo(PyObject* self, PyObject* args)

{

int item, i;

if (!PyArg_ParseTuple(args, "i:nl_langinfo", &item))

return NULL;

/* Check whether this is a supported constant. GNU libc sometimes

for (i = 0; langinfo_constants[i].name; i++)

if (langinfo_constants[i].value == item) {

/* Check NULL as a workaround for GNU libc's returning NULL

const char *result = nl_langinfo(item);

result = result != NULL ? result : "";

return PyUnicode_DecodeLocale(result, NULL);

}

PyErr_SetString(PyExc_ValueError, "unsupported langinfo constant");

return NULL;

}

#endif /* HAVE_LANGINFO_H */

#ifdef HAVE_LIBINTL_H

PyDoc_STRVAR(gettext__doc__,

"Return translation of msg.");

static PyObject*

PyIntl_gettext(PyObject* self, PyObject *args)

{

char *in;

if (!PyArg_ParseTuple(args, "s", &in))

return 0;

return PyUnicode_DecodeLocale(gettext(in), NULL);

}

PyDoc_STRVAR(dgettext__doc__,

"Return translation of msg in domain.");

static PyObject*

PyIntl_dgettext(PyObject* self, PyObject *args)

{

char *domain, *in;

if (!PyArg_ParseTuple(args, "zs", &domain, &in))

return 0;

return PyUnicode_DecodeLocale(dgettext(domain, in), NULL);

}

PyDoc_STRVAR(dcgettext__doc__,

"Return translation of msg in domain and category.");

static PyObject*

PyIntl_dcgettext(PyObject *self, PyObject *args)

{

char *domain, *msgid;

int category;

if (!PyArg_ParseTuple(args, "zsi", &domain, &msgid, &category))

return 0;

return PyUnicode_DecodeLocale(dcgettext(domain,msgid,category), NULL);

}

PyDoc_STRVAR(textdomain__doc__,

"Set the C library's textdmain to domain, returning the new domain.");

static PyObject*

PyIntl_textdomain(PyObject* self, PyObject* args)

{

char *domain;

if (!PyArg_ParseTuple(args, "z", &domain))

return 0;

domain = textdomain(domain);

if (!domain) {

PyErr_SetFromErrno(PyExc_OSError);

return NULL;

}

return PyUnicode_DecodeLocale(domain, NULL);

}

PyDoc_STRVAR(bindtextdomain__doc__,

"Bind the C library's domain to dir.");

static PyObject*

PyIntl_bindtextdomain(PyObject* self,PyObject*args)

{

char *domain, *dirname, *current_dirname;

PyObject *dirname_obj, *dirname_bytes = NULL, *result;

if (!PyArg_ParseTuple(args, "sO", &domain, &dirname_obj))

return 0;

if (!strlen(domain)) {

PyErr_SetString(Error, "domain must be a non-empty string");

return 0;

}

if (dirname_obj != Py_None) {

if (!PyUnicode_FSConverter(dirname_obj, &dirname_bytes))

return NULL;

dirname = PyBytes_AsString(dirname_bytes);

} else {

dirname_bytes = NULL;

dirname = NULL;

}

current_dirname = bindtextdomain(domain, dirname);

if (current_dirname == NULL) {

Py_XDECREF(dirname_bytes);

PyErr_SetFromErrno(PyExc_OSError);

return NULL;

}

result = PyUnicode_DecodeLocale(current_dirname, NULL);

Py_XDECREF(dirname_bytes);

return result;

}

#ifdef HAVE_BIND_TEXTDOMAIN_CODESET

PyDoc_STRVAR(bind_textdomain_codeset__doc__,

"Bind the C library's domain to codeset.");

static PyObject*

PyIntl_bind_textdomain_codeset(PyObject* self,PyObject*args)

{

char *domain,*codeset;

if (!PyArg_ParseTuple(args, "sz", &domain, &codeset))

return NULL;

codeset = bind_textdomain_codeset(domain, codeset);

if (codeset) {

return PyUnicode_DecodeLocale(codeset, NULL);

}

Py_RETURN_NONE;

}

static struct PyMethodDef PyLocale_Methods[] = {

{"setlocale", (PyCFunction) PyLocale_setlocale,

METH_VARARGS, setlocale__doc__},

{"localeconv", PyLocale_localeconv, METH_NOARGS, localeconv__doc__},

#ifdef HAVE_WCSCOLL

{"strcoll", (PyCFunction) PyLocale_strcoll,

METH_VARARGS, strcoll__doc__},

#ifdef HAVE_WCSXFRM

{"strxfrm", (PyCFunction) PyLocale_strxfrm,

METH_VARARGS, strxfrm__doc__},

#if defined(MS_WINDOWS)

{"_getdefaultlocale", PyLocale_getdefaultlocale, METH_NOARGS},

#ifdef HAVE_LANGINFO_H

{"nl_langinfo", (PyCFunction) PyLocale_nl_langinfo,

METH_VARARGS, nl_langinfo__doc__},

#ifdef HAVE_LIBINTL_H

{"gettext",(PyCFunction)PyIntl_gettext,METH_VARARGS,

gettext__doc__},

{"dgettext",(PyCFunction)PyIntl_dgettext,METH_VARARGS,

dgettext__doc__},

{"dcgettext",(PyCFunction)PyIntl_dcgettext,METH_VARARGS,

dcgettext__doc__},

{"textdomain",(PyCFunction)PyIntl_textdomain,METH_VARARGS,

textdomain__doc__},

{"bindtextdomain",(PyCFunction)PyIntl_bindtextdomain,METH_VARARGS,

bindtextdomain__doc__},

#ifdef HAVE_BIND_TEXTDOMAIN_CODESET

{"bind_textdomain_codeset",(PyCFunction)PyIntl_bind_textdomain_codeset,

METH_VARARGS, bind_textdomain_codeset__doc__},

{NULL, NULL}

};

static struct PyModuleDef _localemodule = {

PyModuleDef_HEAD_INIT,

"_locale",

locale__doc__,

-1,

PyLocale_Methods,

NULL,

NULL,

NULL,

NULL

};

PyInit__locale(void)

{

PyObject *m;

#ifdef HAVE_LANGINFO_H

int i;

m = PyModule_Create(&_localemodule);

if (m == NULL)

return NULL;

PyModule_AddIntMacro(m, LC_CTYPE);

PyModule_AddIntMacro(m, LC_TIME);

PyModule_AddIntMacro(m, LC_COLLATE);

PyModule_AddIntMacro(m, LC_MONETARY);

#ifdef LC_MESSAGES

PyModule_AddIntMacro(m, LC_MESSAGES);

#endif /* LC_MESSAGES */

PyModule_AddIntMacro(m, LC_NUMERIC);

PyModule_AddIntMacro(m, LC_ALL);

PyModule_AddIntMacro(m, CHAR_MAX);

Error = PyErr_NewException("locale.Error", NULL, NULL);

if (Error == NULL) {

Py_DECREF(m);

return NULL;

}

PyModule_AddObject(m, "Error", Error);

#ifdef HAVE_LANGINFO_H

for (i = 0; langinfo_constants[i].name; i++) {

PyModule_AddIntConstant(m, langinfo_constants[i].name,

langinfo_constants[i].value);

}

if (PyErr_Occurred()) {

Py_DECREF(m);

return NULL;

}

return m;

}