759 lines
19 KiB
C
759 lines
19 KiB
C
|
/***********************************************************
|
||
|
Copyright (C) 1997, 2002, 2003 Martin von Loewis
|
||
|
|
||
|
Permission to use, copy, modify, and distribute this software and its
|
||
|
documentation for any purpose and without fee is hereby granted,
|
||
|
provided that the above copyright notice appear in all copies.
|
||
|
|
||
|
This software comes with no warranty. Use at your own risk.
|
||
|
|
||
|
******************************************************************/
|
||
|
|
||
|
#include "Python.h"
|
||
|
|
||
|
#include <stdio.h>
|
||
|
#include <locale.h>
|
||
|
#include <string.h>
|
||
|
#include <ctype.h>
|
||
|
|
||
|
#ifdef HAVE_ERRNO_H
|
||
|
#include <errno.h>
|
||
|
#endif
|
||
|
|
||
|
#ifdef HAVE_LANGINFO_H
|
||
|
#include <langinfo.h>
|
||
|
#endif
|
||
|
|
||
|
#ifdef HAVE_LIBINTL_H
|
||
|
#include <libintl.h>
|
||
|
#endif
|
||
|
|
||
|
#ifdef HAVE_WCHAR_H
|
||
|
#include <wchar.h>
|
||
|
#endif
|
||
|
|
||
|
#if defined(MS_WINDOWS)
|
||
|
#define WIN32_LEAN_AND_MEAN
|
||
|
#include <windows.h>
|
||
|
#endif
|
||
|
|
||
|
#ifdef RISCOS
|
||
|
char *strdup(const char *);
|
||
|
#endif
|
||
|
|
||
|
PyDoc_STRVAR(locale__doc__, "Support for POSIX locales.");
|
||
|
|
||
|
static PyObject *Error;
|
||
|
|
||
|
/* support functions for formatting floating point numbers */
|
||
|
|
||
|
PyDoc_STRVAR(setlocale__doc__,
|
||
|
"(integer,string=None) -> string. Activates/queries locale processing.");
|
||
|
|
||
|
/* the grouping is terminated by either 0 or CHAR_MAX */
|
||
|
static PyObject*
|
||
|
copy_grouping(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 = PyInt_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 void
|
||
|
fixup_ulcase(void)
|
||
|
{
|
||
|
PyObject *mods, *strop, *string, *ulo;
|
||
|
unsigned char ul[256];
|
||
|
int n, c;
|
||
|
|
||
|
/* find the string and strop modules */
|
||
|
mods = PyImport_GetModuleDict();
|
||
|
if (!mods)
|
||
|
return;
|
||
|
string = PyDict_GetItemString(mods, "string");
|
||
|
if (string)
|
||
|
string = PyModule_GetDict(string);
|
||
|
strop=PyDict_GetItemString(mods, "strop");
|
||
|
if (strop)
|
||
|
strop = PyModule_GetDict(strop);
|
||
|
if (!string && !strop)
|
||
|
return;
|
||
|
|
||
|
/* create uppercase map string */
|
||
|
n = 0;
|
||
|
for (c = 0; c < 256; c++) {
|
||
|
if (isupper(c))
|
||
|
ul[n++] = c;
|
||
|
}
|
||
|
ulo = PyString_FromStringAndSize((const char *)ul, n);
|
||
|
if (!ulo)
|
||
|
return;
|
||
|
if (string)
|
||
|
PyDict_SetItemString(string, "uppercase", ulo);
|
||
|
if (strop)
|
||
|
PyDict_SetItemString(strop, "uppercase", ulo);
|
||
|
Py_DECREF(ulo);
|
||
|
|
||
|
/* create lowercase string */
|
||
|
n = 0;
|
||
|
for (c = 0; c < 256; c++) {
|
||
|
if (islower(c))
|
||
|
ul[n++] = c;
|
||
|
}
|
||
|
ulo = PyString_FromStringAndSize((const char *)ul, n);
|
||
|
if (!ulo)
|
||
|
return;
|
||
|
if (string)
|
||
|
PyDict_SetItemString(string, "lowercase", ulo);
|
||
|
if (strop)
|
||
|
PyDict_SetItemString(strop, "lowercase", ulo);
|
||
|
Py_DECREF(ulo);
|
||
|
|
||
|
/* create letters string */
|
||
|
n = 0;
|
||
|
for (c = 0; c < 256; c++) {
|
||
|
if (isalpha(c))
|
||
|
ul[n++] = c;
|
||
|
}
|
||
|
ulo = PyString_FromStringAndSize((const char *)ul, n);
|
||
|
if (!ulo)
|
||
|
return;
|
||
|
if (string)
|
||
|
PyDict_SetItemString(string, "letters", ulo);
|
||
|
Py_DECREF(ulo);
|
||
|
}
|
||
|
|
||
|
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;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
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 = PyString_FromString(result);
|
||
|
if (!result_object)
|
||
|
return NULL;
|
||
|
/* record changes to LC_CTYPE */
|
||
|
if (category == LC_CTYPE || category == LC_ALL)
|
||
|
fixup_ulcase();
|
||
|
/* things that got wrong up to here are ignored */
|
||
|
PyErr_Clear();
|
||
|
} else {
|
||
|
/* get locale */
|
||
|
result = setlocale(category, NULL);
|
||
|
if (!result) {
|
||
|
PyErr_SetString(Error, "locale query failed");
|
||
|
return NULL;
|
||
|
}
|
||
|
result_object = PyString_FromString(result);
|
||
|
}
|
||
|
return result_object;
|
||
|
}
|
||
|
|
||
|
PyDoc_STRVAR(localeconv__doc__,
|
||
|
"() -> dict. Returns numeric and monetary locale-specific parameters.");
|
||
|
|
||
|
static PyObject*
|
||
|
PyLocale_localeconv(PyObject* self)
|
||
|
{
|
||
|
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
|
||
|
involved herein */
|
||
|
|
||
|
#define RESULT_STRING(s)\
|
||
|
x = PyString_FromString(l->s);\
|
||
|
if (!x) goto failed;\
|
||
|
PyDict_SetItemString(result, #s, x);\
|
||
|
Py_XDECREF(x)
|
||
|
|
||
|
#define RESULT_INT(i)\
|
||
|
x = PyInt_FromLong(l->i);\
|
||
|
if (!x) goto failed;\
|
||
|
PyDict_SetItemString(result, #i, x);\
|
||
|
Py_XDECREF(x)
|
||
|
|
||
|
/* Numeric information */
|
||
|
RESULT_STRING(decimal_point);
|
||
|
RESULT_STRING(thousands_sep);
|
||
|
x = copy_grouping(l->grouping);
|
||
|
if (!x)
|
||
|
goto failed;
|
||
|
PyDict_SetItemString(result, "grouping", x);
|
||
|
Py_XDECREF(x);
|
||
|
|
||
|
/* 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);
|
||
|
if (!x)
|
||
|
goto failed;
|
||
|
PyDict_SetItemString(result, "mon_grouping", x);
|
||
|
Py_XDECREF(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);
|
||
|
return result;
|
||
|
|
||
|
failed:
|
||
|
Py_XDECREF(result);
|
||
|
Py_XDECREF(x);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
PyDoc_STRVAR(strcoll__doc__,
|
||
|
"string,string -> int. Compares two strings according to the locale.");
|
||
|
|
||
|
static PyObject*
|
||
|
PyLocale_strcoll(PyObject* self, PyObject* args)
|
||
|
{
|
||
|
#if !defined(HAVE_WCSCOLL) || !defined(Py_USING_UNICODE)
|
||
|
char *s1,*s2;
|
||
|
|
||
|
if (!PyArg_ParseTuple(args, "ss:strcoll", &s1, &s2))
|
||
|
return NULL;
|
||
|
return PyInt_FromLong(strcoll(s1, s2));
|
||
|
#else
|
||
|
PyObject *os1, *os2, *result = NULL;
|
||
|
wchar_t *ws1 = NULL, *ws2 = NULL;
|
||
|
int rel1 = 0, rel2 = 0, len1, len2;
|
||
|
|
||
|
if (!PyArg_UnpackTuple(args, "strcoll", 2, 2, &os1, &os2))
|
||
|
return NULL;
|
||
|
/* If both arguments are byte strings, use strcoll. */
|
||
|
if (PyString_Check(os1) && PyString_Check(os2))
|
||
|
return PyInt_FromLong(strcoll(PyString_AS_STRING(os1),
|
||
|
PyString_AS_STRING(os2)));
|
||
|
/* If neither argument is unicode, it's an error. */
|
||
|
if (!PyUnicode_Check(os1) && !PyUnicode_Check(os2)) {
|
||
|
PyErr_SetString(PyExc_ValueError, "strcoll arguments must be strings");
|
||
|
}
|
||
|
/* Convert the non-unicode argument to unicode. */
|
||
|
if (!PyUnicode_Check(os1)) {
|
||
|
os1 = PyUnicode_FromObject(os1);
|
||
|
if (!os1)
|
||
|
return NULL;
|
||
|
rel1 = 1;
|
||
|
}
|
||
|
if (!PyUnicode_Check(os2)) {
|
||
|
os2 = PyUnicode_FromObject(os2);
|
||
|
if (!os2) {
|
||
|
if (rel1) {
|
||
|
Py_DECREF(os1);
|
||
|
}
|
||
|
return NULL;
|
||
|
}
|
||
|
rel2 = 1;
|
||
|
}
|
||
|
/* Convert the unicode strings to wchar[]. */
|
||
|
len1 = PyUnicode_GET_SIZE(os1) + 1;
|
||
|
ws1 = PyMem_MALLOC(len1 * sizeof(wchar_t));
|
||
|
if (!ws1) {
|
||
|
PyErr_NoMemory();
|
||
|
goto done;
|
||
|
}
|
||
|
if (PyUnicode_AsWideChar((PyUnicodeObject*)os1, ws1, len1) == -1)
|
||
|
goto done;
|
||
|
ws1[len1 - 1] = 0;
|
||
|
len2 = PyUnicode_GET_SIZE(os2) + 1;
|
||
|
ws2 = PyMem_MALLOC(len2 * sizeof(wchar_t));
|
||
|
if (!ws2) {
|
||
|
PyErr_NoMemory();
|
||
|
goto done;
|
||
|
}
|
||
|
if (PyUnicode_AsWideChar((PyUnicodeObject*)os2, ws2, len2) == -1)
|
||
|
goto done;
|
||
|
ws2[len2 - 1] = 0;
|
||
|
/* Collate the strings. */
|
||
|
result = PyInt_FromLong(wcscoll(ws1, ws2));
|
||
|
done:
|
||
|
/* Deallocate everything. */
|
||
|
if (ws1) PyMem_FREE(ws1);
|
||
|
if (ws2) PyMem_FREE(ws2);
|
||
|
if (rel1) {
|
||
|
Py_DECREF(os1);
|
||
|
}
|
||
|
if (rel2) {
|
||
|
Py_DECREF(os2);
|
||
|
}
|
||
|
return result;
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
|
||
|
PyDoc_STRVAR(strxfrm__doc__,
|
||
|
"string -> string. Returns a string that behaves for cmp locale-aware.");
|
||
|
|
||
|
static PyObject*
|
||
|
PyLocale_strxfrm(PyObject* self, PyObject* args)
|
||
|
{
|
||
|
char *s, *buf;
|
||
|
size_t n1, n2;
|
||
|
PyObject *result;
|
||
|
|
||
|
if (!PyArg_ParseTuple(args, "s:strxfrm", &s))
|
||
|
return NULL;
|
||
|
|
||
|
/* assume no change in size, first */
|
||
|
n1 = strlen(s) + 1;
|
||
|
buf = PyMem_Malloc(n1);
|
||
|
if (!buf)
|
||
|
return PyErr_NoMemory();
|
||
|
n2 = strxfrm(buf, s, n1) + 1;
|
||
|
if (n2 > n1) {
|
||
|
/* more space needed */
|
||
|
buf = PyMem_Realloc(buf, n2);
|
||
|
if (!buf)
|
||
|
return PyErr_NoMemory();
|
||
|
strxfrm(buf, s, n2);
|
||
|
}
|
||
|
result = PyString_FromString(buf);
|
||
|
PyMem_Free(buf);
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
#if defined(MS_WINDOWS)
|
||
|
static PyObject*
|
||
|
PyLocale_getdefaultlocale(PyObject* self)
|
||
|
{
|
||
|
char encoding[100];
|
||
|
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
|
||
|
ISO639/ISO3166 names (it's probably Windows 95). Return the
|
||
|
Windows language identifier instead (a hexadecimal number) */
|
||
|
|
||
|
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);
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
#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
|
||
|
a special case of message translation, which should be rather
|
||
|
done using gettext. So we don't expose it to Python in the
|
||
|
first place.
|
||
|
LANGINFO(YESSTR),
|
||
|
LANGINFO(NOSTR),
|
||
|
*/
|
||
|
LANGINFO(CRNCYSTR),
|
||
|
#endif
|
||
|
|
||
|
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...
|
||
|
AIX 3.2. only has CODESET.
|
||
|
OpenBSD doesn't have CODESET but has T_FMT_AMPM, and doesn't have
|
||
|
a few of the others.
|
||
|
Solution: ifdef-test them all. */
|
||
|
#ifdef CODESET
|
||
|
LANGINFO(CODESET),
|
||
|
#endif
|
||
|
#ifdef T_FMT_AMPM
|
||
|
LANGINFO(T_FMT_AMPM),
|
||
|
#endif
|
||
|
#ifdef ERA
|
||
|
LANGINFO(ERA),
|
||
|
#endif
|
||
|
#ifdef ERA_D_FMT
|
||
|
LANGINFO(ERA_D_FMT),
|
||
|
#endif
|
||
|
#ifdef ERA_D_T_FMT
|
||
|
LANGINFO(ERA_D_T_FMT),
|
||
|
#endif
|
||
|
#ifdef ERA_T_FMT
|
||
|
LANGINFO(ERA_T_FMT),
|
||
|
#endif
|
||
|
#ifdef ALT_DIGITS
|
||
|
LANGINFO(ALT_DIGITS),
|
||
|
#endif
|
||
|
#ifdef YESEXPR
|
||
|
LANGINFO(YESEXPR),
|
||
|
#endif
|
||
|
#ifdef NOEXPR
|
||
|
LANGINFO(NOEXPR),
|
||
|
#endif
|
||
|
#ifdef _DATE_FMT
|
||
|
/* This is not available in all glibc versions that have CODESET. */
|
||
|
LANGINFO(_DATE_FMT),
|
||
|
#endif
|
||
|
{0, 0}
|
||
|
};
|
||
|
|
||
|
PyDoc_STRVAR(nl_langinfo__doc__,
|
||
|
"nl_langinfo(key) -> string\n"
|
||
|
"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
|
||
|
returns numeric values in the char* return value, which would
|
||
|
crash PyString_FromString. */
|
||
|
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
|
||
|
instead of an empty string for nl_langinfo(ERA). */
|
||
|
const char *result = nl_langinfo(item);
|
||
|
return PyString_FromString(result != NULL ? result : "");
|
||
|
}
|
||
|
PyErr_SetString(PyExc_ValueError, "unsupported langinfo constant");
|
||
|
return NULL;
|
||
|
}
|
||
|
#endif /* HAVE_LANGINFO_H */
|
||
|
|
||
|
#ifdef HAVE_LIBINTL_H
|
||
|
|
||
|
PyDoc_STRVAR(gettext__doc__,
|
||
|
"gettext(msg) -> string\n"
|
||
|
"Return translation of msg.");
|
||
|
|
||
|
static PyObject*
|
||
|
PyIntl_gettext(PyObject* self, PyObject *args)
|
||
|
{
|
||
|
char *in;
|
||
|
if (!PyArg_ParseTuple(args, "s", &in))
|
||
|
return 0;
|
||
|
return PyString_FromString(gettext(in));
|
||
|
}
|
||
|
|
||
|
PyDoc_STRVAR(dgettext__doc__,
|
||
|
"dgettext(domain, msg) -> string\n"
|
||
|
"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 PyString_FromString(dgettext(domain, in));
|
||
|
}
|
||
|
|
||
|
PyDoc_STRVAR(dcgettext__doc__,
|
||
|
"dcgettext(domain, msg, category) -> string\n"
|
||
|
"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 PyString_FromString(dcgettext(domain,msgid,category));
|
||
|
}
|
||
|
|
||
|
PyDoc_STRVAR(textdomain__doc__,
|
||
|
"textdomain(domain) -> string\n"
|
||
|
"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 PyString_FromString(domain);
|
||
|
}
|
||
|
|
||
|
PyDoc_STRVAR(bindtextdomain__doc__,
|
||
|
"bindtextdomain(domain, dir) -> string\n"
|
||
|
"Bind the C library's domain to dir.");
|
||
|
|
||
|
static PyObject*
|
||
|
PyIntl_bindtextdomain(PyObject* self,PyObject*args)
|
||
|
{
|
||
|
char *domain, *dirname;
|
||
|
if (!PyArg_ParseTuple(args, "sz", &domain, &dirname))
|
||
|
return 0;
|
||
|
if (!strlen(domain)) {
|
||
|
PyErr_SetString(Error, "domain must be a non-empty string");
|
||
|
return 0;
|
||
|
}
|
||
|
dirname = bindtextdomain(domain, dirname);
|
||
|
if (!dirname) {
|
||
|
PyErr_SetFromErrno(PyExc_OSError);
|
||
|
return NULL;
|
||
|
}
|
||
|
return PyString_FromString(dirname);
|
||
|
}
|
||
|
|
||
|
#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
|
||
|
PyDoc_STRVAR(bind_textdomain_codeset__doc__,
|
||
|
"bind_textdomain_codeset(domain, codeset) -> string\n"
|
||
|
"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 PyString_FromString(codeset);
|
||
|
Py_RETURN_NONE;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
#endif
|
||
|
|
||
|
static struct PyMethodDef PyLocale_Methods[] = {
|
||
|
{"setlocale", (PyCFunction) PyLocale_setlocale,
|
||
|
METH_VARARGS, setlocale__doc__},
|
||
|
{"localeconv", (PyCFunction) PyLocale_localeconv,
|
||
|
METH_NOARGS, localeconv__doc__},
|
||
|
{"strcoll", (PyCFunction) PyLocale_strcoll,
|
||
|
METH_VARARGS, strcoll__doc__},
|
||
|
{"strxfrm", (PyCFunction) PyLocale_strxfrm,
|
||
|
METH_VARARGS, strxfrm__doc__},
|
||
|
#if defined(MS_WINDOWS)
|
||
|
{"_getdefaultlocale", (PyCFunction) PyLocale_getdefaultlocale, METH_NOARGS},
|
||
|
#endif
|
||
|
#ifdef HAVE_LANGINFO_H
|
||
|
{"nl_langinfo", (PyCFunction) PyLocale_nl_langinfo,
|
||
|
METH_VARARGS, nl_langinfo__doc__},
|
||
|
#endif
|
||
|
#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__},
|
||
|
#endif
|
||
|
#endif
|
||
|
{NULL, NULL}
|
||
|
};
|
||
|
|
||
|
PyMODINIT_FUNC
|
||
|
init_locale(void)
|
||
|
{
|
||
|
PyObject *m, *d, *x;
|
||
|
#ifdef HAVE_LANGINFO_H
|
||
|
int i;
|
||
|
#endif
|
||
|
|
||
|
m = Py_InitModule("_locale", PyLocale_Methods);
|
||
|
if (m == NULL)
|
||
|
return;
|
||
|
|
||
|
d = PyModule_GetDict(m);
|
||
|
|
||
|
x = PyInt_FromLong(LC_CTYPE);
|
||
|
PyDict_SetItemString(d, "LC_CTYPE", x);
|
||
|
Py_XDECREF(x);
|
||
|
|
||
|
x = PyInt_FromLong(LC_TIME);
|
||
|
PyDict_SetItemString(d, "LC_TIME", x);
|
||
|
Py_XDECREF(x);
|
||
|
|
||
|
x = PyInt_FromLong(LC_COLLATE);
|
||
|
PyDict_SetItemString(d, "LC_COLLATE", x);
|
||
|
Py_XDECREF(x);
|
||
|
|
||
|
x = PyInt_FromLong(LC_MONETARY);
|
||
|
PyDict_SetItemString(d, "LC_MONETARY", x);
|
||
|
Py_XDECREF(x);
|
||
|
|
||
|
#ifdef LC_MESSAGES
|
||
|
x = PyInt_FromLong(LC_MESSAGES);
|
||
|
PyDict_SetItemString(d, "LC_MESSAGES", x);
|
||
|
Py_XDECREF(x);
|
||
|
#endif /* LC_MESSAGES */
|
||
|
|
||
|
x = PyInt_FromLong(LC_NUMERIC);
|
||
|
PyDict_SetItemString(d, "LC_NUMERIC", x);
|
||
|
Py_XDECREF(x);
|
||
|
|
||
|
x = PyInt_FromLong(LC_ALL);
|
||
|
PyDict_SetItemString(d, "LC_ALL", x);
|
||
|
Py_XDECREF(x);
|
||
|
|
||
|
x = PyInt_FromLong(CHAR_MAX);
|
||
|
PyDict_SetItemString(d, "CHAR_MAX", x);
|
||
|
Py_XDECREF(x);
|
||
|
|
||
|
Error = PyErr_NewException("locale.Error", NULL, NULL);
|
||
|
PyDict_SetItemString(d, "Error", Error);
|
||
|
|
||
|
x = PyString_FromString(locale__doc__);
|
||
|
PyDict_SetItemString(d, "__doc__", x);
|
||
|
Py_XDECREF(x);
|
||
|
|
||
|
#ifdef HAVE_LANGINFO_H
|
||
|
for (i = 0; langinfo_constants[i].name; i++) {
|
||
|
PyModule_AddIntConstant(m, langinfo_constants[i].name,
|
||
|
langinfo_constants[i].value);
|
||
|
}
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
Local variables:
|
||
|
c-basic-offset: 4
|
||
|
indent-tabs-mode: nil
|
||
|
End:
|
||
|
*/
|