1997-11-18 21:03:39 +00:00
|
|
|
/***********************************************************
|
2002-03-12 22:05:02 +00:00
|
|
|
Copyright (C) 1997, 2002 Martin von Loewis
|
1997-11-18 21:03:39 +00:00
|
|
|
|
|
|
|
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.
|
2000-07-08 19:57:37 +00:00
|
|
|
|
1997-11-18 21:03:39 +00:00
|
|
|
******************************************************************/
|
|
|
|
|
2000-08-10 21:41:08 +00:00
|
|
|
#include "Python.h"
|
|
|
|
|
1997-11-18 21:03:39 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <locale.h>
|
|
|
|
#include <string.h>
|
1998-06-19 04:33:30 +00:00
|
|
|
#include <ctype.h>
|
2000-07-08 19:57:37 +00:00
|
|
|
|
2001-08-10 13:58:50 +00:00
|
|
|
#ifdef HAVE_LANGINFO_H
|
|
|
|
#include <langinfo.h>
|
|
|
|
#endif
|
|
|
|
|
2002-03-27 18:49:02 +00:00
|
|
|
#ifdef HAVE_LIBINTL_H
|
|
|
|
#include <libintl.h>
|
|
|
|
#endif
|
|
|
|
|
2002-06-30 15:26:10 +00:00
|
|
|
#if defined(MS_WINDOWS)
|
2002-07-14 22:14:19 +00:00
|
|
|
#define WIN32_LEAN_AND_MEAN
|
2000-07-08 19:57:37 +00:00
|
|
|
#include <windows.h>
|
|
|
|
#endif
|
|
|
|
|
1998-04-28 16:08:19 +00:00
|
|
|
#ifdef macintosh
|
2000-07-15 22:31:45 +00:00
|
|
|
#include "macglue.h"
|
1998-04-28 16:08:19 +00:00
|
|
|
#endif
|
1997-11-18 21:03:39 +00:00
|
|
|
|
2001-03-02 06:28:17 +00:00
|
|
|
#ifdef RISCOS
|
|
|
|
char *strdup(const char *);
|
|
|
|
#endif
|
|
|
|
|
2002-06-13 20:33:02 +00:00
|
|
|
PyDoc_STRVAR(locale__doc__, "Support for POSIX locales.");
|
1997-11-18 21:03:39 +00:00
|
|
|
|
|
|
|
static PyObject *Error;
|
|
|
|
|
|
|
|
/* support functions for formatting floating point numbers */
|
|
|
|
|
2002-06-13 20:33:02 +00:00
|
|
|
PyDoc_STRVAR(setlocale__doc__,
|
|
|
|
"(integer,string=None) -> string. Activates/queries locale processing.");
|
1997-11-18 21:03:39 +00:00
|
|
|
|
|
|
|
/* to record the LC_NUMERIC settings */
|
2000-07-08 19:57:37 +00:00
|
|
|
static PyObject* grouping = NULL;
|
|
|
|
static PyObject* thousands_sep = NULL;
|
|
|
|
static PyObject* decimal_point = NULL;
|
1997-11-18 21:03:39 +00:00
|
|
|
/* if non-null, indicates that LC_NUMERIC is different from "C" */
|
2000-07-08 19:57:37 +00:00
|
|
|
static char* saved_numeric = NULL;
|
1997-11-18 21:03:39 +00:00
|
|
|
|
|
|
|
/* the grouping is terminated by either 0 or CHAR_MAX */
|
|
|
|
static PyObject*
|
2000-07-08 19:57:37 +00:00
|
|
|
copy_grouping(char* s)
|
1997-11-18 21:03:39 +00:00
|
|
|
{
|
2000-07-08 19:57:37 +00:00
|
|
|
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);
|
2000-07-08 20:07:24 +00:00
|
|
|
val = NULL;
|
2000-07-08 19:57:37 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
} while (s[i] != '\0' && s[i] != CHAR_MAX);
|
|
|
|
|
|
|
|
if (!val) {
|
|
|
|
Py_DECREF(result);
|
|
|
|
return NULL;
|
1997-11-18 21:03:39 +00:00
|
|
|
}
|
2000-07-08 19:57:37 +00:00
|
|
|
|
|
|
|
return result;
|
1997-11-18 21:03:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2000-07-08 19:57:37 +00:00
|
|
|
fixup_ulcase(void)
|
1997-11-18 21:03:39 +00:00
|
|
|
{
|
2000-07-08 19:57:37 +00:00
|
|
|
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);
|
2000-07-08 20:07:24 +00:00
|
|
|
if (!ulo)
|
2000-07-08 19:57:37 +00:00
|
|
|
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);
|
1997-11-18 21:03:39 +00:00
|
|
|
}
|
2001-09-05 17:09:48 +00:00
|
|
|
|
|
|
|
#if defined(HAVE_LANGINFO_H) && defined(CODESET)
|
|
|
|
static int fileencoding_uses_locale = 0;
|
|
|
|
#endif
|
1997-11-18 21:03:39 +00:00
|
|
|
|
|
|
|
static PyObject*
|
2000-07-08 19:57:37 +00:00
|
|
|
PyLocale_setlocale(PyObject* self, PyObject* args)
|
1997-11-18 21:03:39 +00:00
|
|
|
{
|
2000-07-08 19:57:37 +00:00
|
|
|
int category;
|
|
|
|
char *locale = NULL, *result;
|
|
|
|
PyObject *result_object;
|
|
|
|
struct lconv *lc;
|
|
|
|
|
|
|
|
if (!PyArg_ParseTuple(args, "i|z:setlocale", &category, &locale))
|
2000-07-08 20:07:24 +00:00
|
|
|
return NULL;
|
2000-07-08 19:57:37 +00:00
|
|
|
|
|
|
|
if (locale) {
|
|
|
|
/* set locale */
|
|
|
|
result = setlocale(category, locale);
|
|
|
|
if (!result) {
|
|
|
|
/* operation failed, no setting was changed */
|
|
|
|
PyErr_SetString(Error, "locale setting not supported");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
result_object = PyString_FromString(result);
|
|
|
|
if (!result)
|
|
|
|
return NULL;
|
|
|
|
/* record changes to LC_NUMERIC */
|
|
|
|
if (category == LC_NUMERIC || category == LC_ALL) {
|
|
|
|
if (strcmp(locale, "C") == 0 || strcmp(locale, "POSIX") == 0) {
|
|
|
|
/* user just asked for default numeric locale */
|
|
|
|
if (saved_numeric)
|
|
|
|
free(saved_numeric);
|
|
|
|
saved_numeric = NULL;
|
|
|
|
} else {
|
|
|
|
/* remember values */
|
|
|
|
lc = localeconv();
|
|
|
|
Py_XDECREF(grouping);
|
|
|
|
grouping = copy_grouping(lc->grouping);
|
|
|
|
Py_XDECREF(thousands_sep);
|
|
|
|
thousands_sep = PyString_FromString(lc->thousands_sep);
|
|
|
|
Py_XDECREF(decimal_point);
|
|
|
|
decimal_point = PyString_FromString(lc->decimal_point);
|
|
|
|
saved_numeric = strdup(locale);
|
|
|
|
/* restore to "C" */
|
|
|
|
setlocale(LC_NUMERIC, "C");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* 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();
|
2001-09-05 17:09:48 +00:00
|
|
|
#if defined(HAVE_LANGINFO_H) && defined(CODESET)
|
|
|
|
if (Py_FileSystemDefaultEncoding == NULL)
|
|
|
|
fileencoding_uses_locale = 1;
|
|
|
|
if (fileencoding_uses_locale) {
|
|
|
|
char *codeset = nl_langinfo(CODESET);
|
|
|
|
PyObject *enc = NULL;
|
|
|
|
if (*codeset && (enc = PyCodec_Encoder(codeset))) {
|
|
|
|
/* Release previous file encoding */
|
|
|
|
if (Py_FileSystemDefaultEncoding)
|
2001-09-20 19:18:30 +00:00
|
|
|
free((char *)Py_FileSystemDefaultEncoding);
|
2001-09-05 17:09:48 +00:00
|
|
|
Py_FileSystemDefaultEncoding = strdup(codeset);
|
|
|
|
Py_DECREF(enc);
|
|
|
|
} else
|
|
|
|
PyErr_Clear();
|
|
|
|
}
|
|
|
|
#endif
|
2000-07-08 19:57:37 +00:00
|
|
|
} else {
|
|
|
|
/* get locale */
|
|
|
|
/* restore LC_NUMERIC first, if appropriate */
|
|
|
|
if (saved_numeric)
|
|
|
|
setlocale(LC_NUMERIC, saved_numeric);
|
|
|
|
result = setlocale(category, NULL);
|
|
|
|
if (!result) {
|
|
|
|
PyErr_SetString(Error, "locale query failed");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
result_object = PyString_FromString(result);
|
|
|
|
/* restore back to "C" */
|
|
|
|
if (saved_numeric)
|
|
|
|
setlocale(LC_NUMERIC, "C");
|
1997-11-18 21:03:39 +00:00
|
|
|
}
|
2000-07-08 19:57:37 +00:00
|
|
|
return result_object;
|
1997-11-18 21:03:39 +00:00
|
|
|
}
|
|
|
|
|
2002-06-13 20:33:02 +00:00
|
|
|
PyDoc_STRVAR(localeconv__doc__,
|
|
|
|
"() -> dict. Returns numeric and monetary locale-specific parameters.");
|
1997-11-18 21:03:39 +00:00
|
|
|
|
|
|
|
static PyObject*
|
2002-03-25 20:46:46 +00:00
|
|
|
PyLocale_localeconv(PyObject* self)
|
1997-11-18 21:03:39 +00:00
|
|
|
{
|
2000-07-08 19:57:37 +00:00
|
|
|
PyObject* result;
|
|
|
|
struct lconv *l;
|
|
|
|
PyObject *x;
|
|
|
|
|
|
|
|
result = PyDict_New();
|
2000-07-08 20:07:24 +00:00
|
|
|
if (!result)
|
|
|
|
return NULL;
|
2000-07-08 19:57:37 +00:00
|
|
|
|
|
|
|
/* 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)
|
1997-11-18 21:03:39 +00:00
|
|
|
|
|
|
|
/* Numeric information */
|
2000-07-08 19:57:37 +00:00
|
|
|
if (saved_numeric){
|
|
|
|
/* cannot use localeconv results */
|
|
|
|
PyDict_SetItemString(result, "decimal_point", decimal_point);
|
|
|
|
PyDict_SetItemString(result, "grouping", grouping);
|
|
|
|
PyDict_SetItemString(result, "thousands_sep", thousands_sep);
|
|
|
|
} else {
|
|
|
|
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);
|
1997-11-18 21:03:39 +00:00
|
|
|
Py_XDECREF(x);
|
2000-07-08 19:57:37 +00:00
|
|
|
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;
|
1997-11-18 21:03:39 +00:00
|
|
|
}
|
|
|
|
|
2002-06-13 20:33:02 +00:00
|
|
|
PyDoc_STRVAR(strcoll__doc__,
|
|
|
|
"string,string -> int. Compares two strings according to the locale.");
|
1997-11-18 21:03:39 +00:00
|
|
|
|
|
|
|
static PyObject*
|
2000-07-08 19:57:37 +00:00
|
|
|
PyLocale_strcoll(PyObject* self, PyObject* args)
|
1997-11-18 21:03:39 +00:00
|
|
|
{
|
|
|
|
char *s1,*s2;
|
2000-07-08 19:57:37 +00:00
|
|
|
|
|
|
|
if (!PyArg_ParseTuple(args, "ss:strcoll", &s1, &s2))
|
|
|
|
return NULL;
|
|
|
|
return PyInt_FromLong(strcoll(s1, s2));
|
1997-11-18 21:03:39 +00:00
|
|
|
}
|
|
|
|
|
2002-06-13 20:33:02 +00:00
|
|
|
PyDoc_STRVAR(strxfrm__doc__,
|
|
|
|
"string -> string. Returns a string that behaves for cmp locale-aware.");
|
1997-11-18 21:03:39 +00:00
|
|
|
|
|
|
|
static PyObject*
|
2000-07-08 19:57:37 +00:00
|
|
|
PyLocale_strxfrm(PyObject* self, PyObject* args)
|
1997-11-18 21:03:39 +00:00
|
|
|
{
|
2000-07-08 19:57:37 +00:00
|
|
|
char *s, *buf;
|
|
|
|
size_t n1, n2;
|
|
|
|
PyObject *result;
|
|
|
|
|
2000-07-08 20:07:24 +00:00
|
|
|
if (!PyArg_ParseTuple(args, "s:strxfrm", &s))
|
2000-07-08 19:57:37 +00:00
|
|
|
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);
|
|
|
|
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;
|
1997-11-18 21:03:39 +00:00
|
|
|
}
|
|
|
|
|
2002-06-30 15:26:10 +00:00
|
|
|
#if defined(MS_WINDOWS)
|
2000-07-08 19:57:37 +00:00
|
|
|
static PyObject*
|
2002-03-25 20:46:46 +00:00
|
|
|
PyLocale_getdefaultlocale(PyObject* self)
|
2000-07-08 19:57:37 +00:00
|
|
|
{
|
|
|
|
char encoding[100];
|
|
|
|
char locale[100];
|
|
|
|
|
2001-11-28 20:27:42 +00:00
|
|
|
PyOS_snprintf(encoding, sizeof(encoding), "cp%d", GetACP());
|
2000-07-08 19:57:37 +00:00
|
|
|
|
|
|
|
if (GetLocaleInfo(LOCALE_USER_DEFAULT,
|
|
|
|
LOCALE_SISO639LANGNAME,
|
|
|
|
locale, sizeof(locale))) {
|
|
|
|
int i = strlen(locale);
|
|
|
|
locale[i++] = '_';
|
|
|
|
if (GetLocaleInfo(LOCALE_USER_DEFAULT,
|
|
|
|
LOCALE_SISO3166CTRYNAME,
|
|
|
|
locale+i, 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
|
|
|
|
|
2000-07-15 22:31:45 +00:00
|
|
|
#if defined(macintosh)
|
|
|
|
static PyObject*
|
2002-03-25 20:46:46 +00:00
|
|
|
PyLocale_getdefaultlocale(PyObject* self)
|
2000-07-15 22:31:45 +00:00
|
|
|
{
|
|
|
|
return Py_BuildValue("Os", Py_None, PyMac_getscript());
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-08-10 13:58:50 +00:00
|
|
|
#ifdef HAVE_LANGINFO_H
|
2002-03-12 22:05:02 +00:00
|
|
|
#define LANGINFO(X) {#X, X}
|
|
|
|
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),
|
|
|
|
|
2002-04-19 21:04:41 +00:00
|
|
|
/* 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. */
|
2002-03-12 22:05:02 +00:00
|
|
|
#ifdef CODESET
|
|
|
|
LANGINFO(CODESET),
|
2002-03-27 12:15:57 +00:00
|
|
|
#endif
|
|
|
|
#ifdef T_FMT_AMPM
|
2002-03-12 22:05:02 +00:00
|
|
|
LANGINFO(T_FMT_AMPM),
|
2002-04-19 21:04:41 +00:00
|
|
|
#endif
|
|
|
|
#ifdef ERA
|
2002-03-12 22:05:02 +00:00
|
|
|
LANGINFO(ERA),
|
2002-04-19 21:04:41 +00:00
|
|
|
#endif
|
|
|
|
#ifdef ERA_D_FMT
|
2002-03-12 22:05:02 +00:00
|
|
|
LANGINFO(ERA_D_FMT),
|
2002-04-19 21:04:41 +00:00
|
|
|
#endif
|
|
|
|
#ifdef ERA_D_T_FMT
|
2002-03-12 22:05:02 +00:00
|
|
|
LANGINFO(ERA_D_T_FMT),
|
2002-04-19 21:04:41 +00:00
|
|
|
#endif
|
|
|
|
#ifdef ERA_T_FMT
|
2002-03-12 22:05:02 +00:00
|
|
|
LANGINFO(ERA_T_FMT),
|
2002-04-19 21:04:41 +00:00
|
|
|
#endif
|
|
|
|
#ifdef ALT_DIGITS
|
2002-03-12 22:05:02 +00:00
|
|
|
LANGINFO(ALT_DIGITS),
|
2002-04-19 21:04:41 +00:00
|
|
|
#endif
|
|
|
|
#ifdef YESEXPR
|
2002-03-12 22:05:02 +00:00
|
|
|
LANGINFO(YESEXPR),
|
2002-04-19 21:04:41 +00:00
|
|
|
#endif
|
|
|
|
#ifdef NOEXPR
|
2002-03-12 22:05:02 +00:00
|
|
|
LANGINFO(NOEXPR),
|
|
|
|
#endif
|
|
|
|
#ifdef _DATE_FMT
|
|
|
|
/* This is not available in all glibc versions that have CODESET. */
|
|
|
|
LANGINFO(_DATE_FMT),
|
|
|
|
#endif
|
|
|
|
{0, 0}
|
|
|
|
};
|
|
|
|
|
2002-06-13 20:33:02 +00:00
|
|
|
PyDoc_STRVAR(nl_langinfo__doc__,
|
2001-08-10 13:58:50 +00:00
|
|
|
"nl_langinfo(key) -> string\n"
|
2002-06-13 20:33:02 +00:00
|
|
|
"Return the value for the locale information associated with key.");
|
2001-08-10 13:58:50 +00:00
|
|
|
|
|
|
|
static PyObject*
|
|
|
|
PyLocale_nl_langinfo(PyObject* self, PyObject* args)
|
|
|
|
{
|
2002-03-12 22:05:02 +00:00
|
|
|
int item, i;
|
2001-08-10 13:58:50 +00:00
|
|
|
if (!PyArg_ParseTuple(args, "i:nl_langinfo", &item))
|
|
|
|
return NULL;
|
2002-03-12 22:05:02 +00:00
|
|
|
/* 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)
|
|
|
|
return PyString_FromString(nl_langinfo(item));
|
|
|
|
PyErr_SetString(PyExc_ValueError, "unsupported langinfo constant");
|
|
|
|
return NULL;
|
2001-08-10 13:58:50 +00:00
|
|
|
}
|
2002-03-12 22:05:02 +00:00
|
|
|
#endif /* HAVE_LANGINFO_H */
|
2002-03-27 18:49:02 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_LIBINTL_H
|
|
|
|
|
2002-06-13 20:33:02 +00:00
|
|
|
PyDoc_STRVAR(gettext__doc__,
|
2002-03-27 18:49:02 +00:00
|
|
|
"gettext(msg) -> string\n"
|
2002-06-13 20:33:02 +00:00
|
|
|
"Return translation of msg.");
|
2002-03-27 18:49:02 +00:00
|
|
|
|
|
|
|
static PyObject*
|
|
|
|
PyIntl_gettext(PyObject* self, PyObject *args)
|
|
|
|
{
|
|
|
|
char *in;
|
|
|
|
if (!PyArg_ParseTuple(args, "z", &in))
|
|
|
|
return 0;
|
|
|
|
return PyString_FromString(gettext(in));
|
|
|
|
}
|
|
|
|
|
2002-06-13 20:33:02 +00:00
|
|
|
PyDoc_STRVAR(dgettext__doc__,
|
2002-03-27 18:49:02 +00:00
|
|
|
"dgettext(domain, msg) -> string\n"
|
2002-06-13 20:33:02 +00:00
|
|
|
"Return translation of msg in domain.");
|
2002-03-27 18:49:02 +00:00
|
|
|
|
|
|
|
static PyObject*
|
|
|
|
PyIntl_dgettext(PyObject* self, PyObject *args)
|
|
|
|
{
|
|
|
|
char *domain, *in;
|
|
|
|
if (!PyArg_ParseTuple(args, "zz", &domain, &in))
|
|
|
|
return 0;
|
|
|
|
return PyString_FromString(dgettext(domain, in));
|
|
|
|
}
|
|
|
|
|
2002-06-13 20:33:02 +00:00
|
|
|
PyDoc_STRVAR(dcgettext__doc__,
|
2002-03-27 18:49:02 +00:00
|
|
|
"dcgettext(domain, msg, category) -> string\n"
|
2002-06-13 20:33:02 +00:00
|
|
|
"Return translation of msg in domain and category.");
|
2002-03-27 18:49:02 +00:00
|
|
|
|
|
|
|
static PyObject*
|
|
|
|
PyIntl_dcgettext(PyObject *self, PyObject *args)
|
|
|
|
{
|
|
|
|
char *domain, *msgid;
|
|
|
|
int category;
|
|
|
|
if (!PyArg_ParseTuple(args, "zzi", &domain, &msgid, &category))
|
|
|
|
return 0;
|
|
|
|
return PyString_FromString(dcgettext(domain,msgid,category));
|
|
|
|
}
|
|
|
|
|
2002-06-13 20:33:02 +00:00
|
|
|
PyDoc_STRVAR(textdomain__doc__,
|
2002-03-27 18:49:02 +00:00
|
|
|
"textdomain(domain) -> string\n"
|
2002-06-13 20:33:02 +00:00
|
|
|
"Set the C library's textdmain to domain, returning the new domain.");
|
2002-03-27 18:49:02 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2002-06-13 20:33:02 +00:00
|
|
|
PyDoc_STRVAR(bindtextdomain__doc__,
|
2002-03-27 18:49:02 +00:00
|
|
|
"bindtextdomain(domain, dir) -> string\n"
|
2002-06-13 20:33:02 +00:00
|
|
|
"Bind the C library's domain to dir.");
|
2002-03-27 18:49:02 +00:00
|
|
|
|
|
|
|
static PyObject*
|
|
|
|
PyIntl_bindtextdomain(PyObject* self,PyObject*args)
|
|
|
|
{
|
|
|
|
char *domain,*dirname;
|
|
|
|
if (!PyArg_ParseTuple(args, "zz", &domain, &dirname))
|
|
|
|
return 0;
|
|
|
|
dirname = bindtextdomain(domain, dirname);
|
|
|
|
if (!dirname) {
|
|
|
|
PyErr_SetFromErrno(PyExc_OSError);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return PyString_FromString(dirname);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2001-08-10 13:58:50 +00:00
|
|
|
|
1997-11-18 21:03:39 +00:00
|
|
|
static struct PyMethodDef PyLocale_Methods[] = {
|
2000-08-03 02:06:16 +00:00
|
|
|
{"setlocale", (PyCFunction) PyLocale_setlocale,
|
|
|
|
METH_VARARGS, setlocale__doc__},
|
|
|
|
{"localeconv", (PyCFunction) PyLocale_localeconv,
|
2002-03-25 20:46:46 +00:00
|
|
|
METH_NOARGS, localeconv__doc__},
|
2000-08-03 02:06:16 +00:00
|
|
|
{"strcoll", (PyCFunction) PyLocale_strcoll,
|
|
|
|
METH_VARARGS, strcoll__doc__},
|
|
|
|
{"strxfrm", (PyCFunction) PyLocale_strxfrm,
|
|
|
|
METH_VARARGS, strxfrm__doc__},
|
2002-06-30 15:26:10 +00:00
|
|
|
#if defined(MS_WINDOWS) || defined(macintosh)
|
2002-03-25 20:46:46 +00:00
|
|
|
{"_getdefaultlocale", (PyCFunction) PyLocale_getdefaultlocale, METH_NOARGS},
|
2000-07-08 19:57:37 +00:00
|
|
|
#endif
|
2001-08-10 13:58:50 +00:00
|
|
|
#ifdef HAVE_LANGINFO_H
|
|
|
|
{"nl_langinfo", (PyCFunction) PyLocale_nl_langinfo,
|
|
|
|
METH_VARARGS, nl_langinfo__doc__},
|
|
|
|
#endif
|
2002-05-02 12:16:29 +00:00
|
|
|
#ifdef HAVE_LIBINTL_H
|
2002-03-27 18:49:02 +00:00
|
|
|
{"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__},
|
|
|
|
#endif
|
1997-11-18 21:03:39 +00:00
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
1998-12-04 18:50:17 +00:00
|
|
|
DL_EXPORT(void)
|
2000-07-21 06:00:07 +00:00
|
|
|
init_locale(void)
|
1997-11-18 21:03:39 +00:00
|
|
|
{
|
2000-07-08 19:57:37 +00:00
|
|
|
PyObject *m, *d, *x;
|
2002-03-12 22:05:02 +00:00
|
|
|
#ifdef HAVE_LANGINFO_H
|
|
|
|
int i;
|
|
|
|
#endif
|
1997-11-18 21:03:39 +00:00
|
|
|
|
2000-07-08 19:57:37 +00:00
|
|
|
m = Py_InitModule("_locale", PyLocale_Methods);
|
1997-11-18 21:03:39 +00:00
|
|
|
|
2000-07-08 19:57:37 +00:00
|
|
|
d = PyModule_GetDict(m);
|
1997-11-18 21:03:39 +00:00
|
|
|
|
2000-07-08 19:57:37 +00:00
|
|
|
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);
|
1997-11-18 21:03:39 +00:00
|
|
|
|
1997-12-09 19:35:11 +00:00
|
|
|
#ifdef LC_MESSAGES
|
2000-07-08 19:57:37 +00:00
|
|
|
x = PyInt_FromLong(LC_MESSAGES);
|
|
|
|
PyDict_SetItemString(d, "LC_MESSAGES", x);
|
|
|
|
Py_XDECREF(x);
|
1997-12-09 19:35:11 +00:00
|
|
|
#endif /* LC_MESSAGES */
|
1997-11-18 21:03:39 +00:00
|
|
|
|
2000-07-08 19:57:37 +00:00
|
|
|
x = PyInt_FromLong(LC_NUMERIC);
|
|
|
|
PyDict_SetItemString(d, "LC_NUMERIC", x);
|
|
|
|
Py_XDECREF(x);
|
1997-11-18 21:03:39 +00:00
|
|
|
|
2000-07-08 19:57:37 +00:00
|
|
|
x = PyInt_FromLong(LC_ALL);
|
|
|
|
PyDict_SetItemString(d, "LC_ALL", x);
|
|
|
|
Py_XDECREF(x);
|
1997-11-18 21:03:39 +00:00
|
|
|
|
2000-07-08 19:57:37 +00:00
|
|
|
x = PyInt_FromLong(CHAR_MAX);
|
|
|
|
PyDict_SetItemString(d, "CHAR_MAX", x);
|
|
|
|
Py_XDECREF(x);
|
1997-11-18 21:03:39 +00:00
|
|
|
|
2000-07-08 19:57:37 +00:00
|
|
|
Error = PyErr_NewException("locale.Error", NULL, NULL);
|
|
|
|
PyDict_SetItemString(d, "Error", Error);
|
1997-11-18 21:03:39 +00:00
|
|
|
|
2000-07-08 19:57:37 +00:00
|
|
|
x = PyString_FromString(locale__doc__);
|
|
|
|
PyDict_SetItemString(d, "__doc__", x);
|
|
|
|
Py_XDECREF(x);
|
2001-08-10 13:58:50 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_LANGINFO_H
|
2002-03-12 22:05:02 +00:00
|
|
|
for (i = 0; langinfo_constants[i].name; i++) {
|
|
|
|
PyModule_AddIntConstant(m, langinfo_constants[i].name,
|
|
|
|
langinfo_constants[i].value);
|
|
|
|
}
|
2001-08-10 13:58:50 +00:00
|
|
|
#endif
|
1997-11-18 21:03:39 +00:00
|
|
|
}
|