PageRenderTime 54ms CodeModel.GetById 16ms app.highlight 32ms RepoModel.GetById 2ms app.codeStats 0ms

/Modules/_localemodule.c

http://unladen-swallow.googlecode.com/
C | 786 lines | 620 code | 94 blank | 72 comment | 97 complexity | c743b8b23c4fb46da46b59b099407e07 MD5 | raw file
  1/***********************************************************
  2Copyright (C) 1997, 2002, 2003 Martin von Loewis
  3
  4Permission to use, copy, modify, and distribute this software and its
  5documentation for any purpose and without fee is hereby granted,
  6provided that the above copyright notice appear in all copies.
  7
  8This software comes with no warranty. Use at your own risk.
  9
 10******************************************************************/
 11
 12#include "Python.h"
 13
 14#include <stdio.h>
 15#include <locale.h>
 16#include <string.h>
 17#include <ctype.h>
 18
 19#ifdef HAVE_ERRNO_H
 20#include <errno.h>
 21#endif
 22
 23#ifdef HAVE_LANGINFO_H
 24#include <langinfo.h>
 25#endif
 26
 27#ifdef HAVE_LIBINTL_H
 28#include <libintl.h>
 29#endif
 30
 31#ifdef HAVE_WCHAR_H
 32#include <wchar.h>
 33#endif
 34
 35#if defined(__APPLE__)
 36#include <CoreFoundation/CoreFoundation.h>
 37#endif
 38
 39#if defined(MS_WINDOWS)
 40#define WIN32_LEAN_AND_MEAN
 41#include <windows.h>
 42#endif
 43
 44#ifdef RISCOS
 45char *strdup(const char *);
 46#endif
 47
 48PyDoc_STRVAR(locale__doc__, "Support for POSIX locales.");
 49
 50static PyObject *Error;
 51
 52/* support functions for formatting floating point numbers */
 53
 54PyDoc_STRVAR(setlocale__doc__,
 55"(integer,string=None) -> string. Activates/queries locale processing.");
 56
 57/* the grouping is terminated by either 0 or CHAR_MAX */
 58static PyObject*
 59copy_grouping(char* s)
 60{
 61    int i;
 62    PyObject *result, *val = NULL;
 63
 64    if (s[0] == '\0')
 65        /* empty string: no grouping at all */
 66        return PyList_New(0);
 67
 68    for (i = 0; s[i] != '\0' && s[i] != CHAR_MAX; i++)
 69        ; /* nothing */
 70
 71    result = PyList_New(i+1);
 72    if (!result)
 73        return NULL;
 74
 75    i = -1;
 76    do {
 77        i++;
 78        val = PyInt_FromLong(s[i]);
 79        if (!val)
 80            break;
 81        if (PyList_SetItem(result, i, val)) {
 82            Py_DECREF(val);
 83            val = NULL;
 84            break;
 85        }
 86    } while (s[i] != '\0' && s[i] != CHAR_MAX);
 87
 88    if (!val) {
 89        Py_DECREF(result);
 90        return NULL;
 91    }
 92
 93    return result;
 94}
 95
 96static void
 97fixup_ulcase(void)
 98{
 99    PyObject *mods, *strop, *string, *ulo;
100    unsigned char ul[256];
101    int n, c;
102
103    /* find the string and strop modules */
104    mods = PyImport_GetModuleDict();
105    if (!mods)
106        return;
107    string = PyDict_GetItemString(mods, "string");
108    if (string)
109        string = PyModule_GetDict(string);
110    strop=PyDict_GetItemString(mods, "strop");
111    if (strop)
112        strop = PyModule_GetDict(strop);
113    if (!string && !strop)
114        return;
115
116    /* create uppercase map string */
117    n = 0;
118    for (c = 0; c < 256; c++) {
119        if (isupper(c))
120            ul[n++] = c;
121    }
122    ulo = PyString_FromStringAndSize((const char *)ul, n);
123    if (!ulo)
124        return;
125    if (string)
126        PyDict_SetItemString(string, "uppercase", ulo);
127    if (strop)
128        PyDict_SetItemString(strop, "uppercase", ulo);
129    Py_DECREF(ulo);
130
131    /* create lowercase string */
132    n = 0;
133    for (c = 0; c < 256; c++) {
134        if (islower(c))
135            ul[n++] = c;
136    }
137    ulo = PyString_FromStringAndSize((const char *)ul, n);
138    if (!ulo)
139        return;
140    if (string)
141        PyDict_SetItemString(string, "lowercase", ulo);
142    if (strop)
143        PyDict_SetItemString(strop, "lowercase", ulo);
144    Py_DECREF(ulo);
145
146    /* create letters string */
147    n = 0;
148    for (c = 0; c < 256; c++) {
149        if (isalpha(c))
150            ul[n++] = c;
151    }
152    ulo = PyString_FromStringAndSize((const char *)ul, n);
153    if (!ulo)
154        return;
155    if (string)
156        PyDict_SetItemString(string, "letters", ulo);
157    Py_DECREF(ulo);
158}
159
160static PyObject*
161PyLocale_setlocale(PyObject* self, PyObject* args)
162{
163    int category;
164    char *locale = NULL, *result;
165    PyObject *result_object;
166
167    if (!PyArg_ParseTuple(args, "i|z:setlocale", &category, &locale))
168        return NULL;
169
170    if (locale) {
171        /* set locale */
172        result = setlocale(category, locale);
173        if (!result) {
174            /* operation failed, no setting was changed */
175            PyErr_SetString(Error, "unsupported locale setting");
176            return NULL;
177        }
178        result_object = PyString_FromString(result);
179        if (!result_object)
180            return NULL;
181        /* record changes to LC_CTYPE */
182        if (category == LC_CTYPE || category == LC_ALL)
183            fixup_ulcase();
184        /* things that got wrong up to here are ignored */
185        PyErr_Clear();
186    } else {
187        /* get locale */
188        result = setlocale(category, NULL);
189        if (!result) {
190            PyErr_SetString(Error, "locale query failed");
191            return NULL;
192        }
193        result_object = PyString_FromString(result);
194    }
195    return result_object;
196}
197
198PyDoc_STRVAR(localeconv__doc__,
199"() -> dict. Returns numeric and monetary locale-specific parameters.");
200
201static PyObject*
202PyLocale_localeconv(PyObject* self)
203{
204    PyObject* result;
205    struct lconv *l;
206    PyObject *x;
207
208    result = PyDict_New();
209    if (!result)
210        return NULL;
211
212    /* if LC_NUMERIC is different in the C library, use saved value */
213    l = localeconv();
214
215    /* hopefully, the localeconv result survives the C library calls
216       involved herein */
217
218#define RESULT_STRING(s)\
219    x = PyString_FromString(l->s);\
220    if (!x) goto failed;\
221    PyDict_SetItemString(result, #s, x);\
222    Py_XDECREF(x)
223
224#define RESULT_INT(i)\
225    x = PyInt_FromLong(l->i);\
226    if (!x) goto failed;\
227    PyDict_SetItemString(result, #i, x);\
228    Py_XDECREF(x)
229
230    /* Numeric information */
231    RESULT_STRING(decimal_point);
232    RESULT_STRING(thousands_sep);
233    x = copy_grouping(l->grouping);
234    if (!x)
235        goto failed;
236    PyDict_SetItemString(result, "grouping", x);
237    Py_XDECREF(x);
238
239    /* Monetary information */
240    RESULT_STRING(int_curr_symbol);
241    RESULT_STRING(currency_symbol);
242    RESULT_STRING(mon_decimal_point);
243    RESULT_STRING(mon_thousands_sep);
244    x = copy_grouping(l->mon_grouping);
245    if (!x)
246        goto failed;
247    PyDict_SetItemString(result, "mon_grouping", x);
248    Py_XDECREF(x);
249    RESULT_STRING(positive_sign);
250    RESULT_STRING(negative_sign);
251    RESULT_INT(int_frac_digits);
252    RESULT_INT(frac_digits);
253    RESULT_INT(p_cs_precedes);
254    RESULT_INT(p_sep_by_space);
255    RESULT_INT(n_cs_precedes);
256    RESULT_INT(n_sep_by_space);
257    RESULT_INT(p_sign_posn);
258    RESULT_INT(n_sign_posn);
259    return result;
260
261  failed:
262    Py_XDECREF(result);
263    Py_XDECREF(x);
264    return NULL;
265}
266
267PyDoc_STRVAR(strcoll__doc__,
268"string,string -> int. Compares two strings according to the locale.");
269
270static PyObject*
271PyLocale_strcoll(PyObject* self, PyObject* args)
272{
273#if !defined(HAVE_WCSCOLL) || !defined(Py_USING_UNICODE)
274    char *s1,*s2;
275    
276    if (!PyArg_ParseTuple(args, "ss:strcoll", &s1, &s2))
277        return NULL;
278    return PyInt_FromLong(strcoll(s1, s2));
279#else
280    PyObject *os1, *os2, *result = NULL;
281    wchar_t *ws1 = NULL, *ws2 = NULL;
282    int rel1 = 0, rel2 = 0, len1, len2;
283    
284    if (!PyArg_UnpackTuple(args, "strcoll", 2, 2, &os1, &os2))
285        return NULL;
286    /* If both arguments are byte strings, use strcoll.  */
287    if (PyString_Check(os1) && PyString_Check(os2))
288        return PyInt_FromLong(strcoll(PyString_AS_STRING(os1),
289                                      PyString_AS_STRING(os2)));
290    /* If neither argument is unicode, it's an error.  */
291    if (!PyUnicode_Check(os1) && !PyUnicode_Check(os2)) {
292        PyErr_SetString(PyExc_ValueError, "strcoll arguments must be strings");
293    }
294    /* Convert the non-unicode argument to unicode. */
295    if (!PyUnicode_Check(os1)) {
296        os1 = PyUnicode_FromObject(os1);
297        if (!os1)
298            return NULL;
299        rel1 = 1;
300    }
301    if (!PyUnicode_Check(os2)) {
302        os2 = PyUnicode_FromObject(os2);
303        if (!os2) {
304            if (rel1) {
305                Py_DECREF(os1);
306            }
307            return NULL;
308        } 
309        rel2 = 1;
310    }
311    /* Convert the unicode strings to wchar[]. */
312    len1 = PyUnicode_GET_SIZE(os1) + 1;
313    ws1 = PyMem_MALLOC(len1 * sizeof(wchar_t));
314    if (!ws1) {
315        PyErr_NoMemory();
316        goto done;
317    }
318    if (PyUnicode_AsWideChar((PyUnicodeObject*)os1, ws1, len1) == -1)
319        goto done;
320    ws1[len1 - 1] = 0;
321    len2 = PyUnicode_GET_SIZE(os2) + 1;
322    ws2 = PyMem_MALLOC(len2 * sizeof(wchar_t));
323    if (!ws2) {
324        PyErr_NoMemory();
325        goto done;
326    }
327    if (PyUnicode_AsWideChar((PyUnicodeObject*)os2, ws2, len2) == -1)
328        goto done;
329    ws2[len2 - 1] = 0;
330    /* Collate the strings. */
331    result = PyInt_FromLong(wcscoll(ws1, ws2));
332  done:
333    /* Deallocate everything. */
334    if (ws1) PyMem_FREE(ws1);
335    if (ws2) PyMem_FREE(ws2);
336    if (rel1) {
337        Py_DECREF(os1);
338    }
339    if (rel2) {
340        Py_DECREF(os2);
341    }
342    return result;
343#endif
344}
345
346
347PyDoc_STRVAR(strxfrm__doc__,
348"string -> string. Returns a string that behaves for cmp locale-aware.");
349
350static PyObject*
351PyLocale_strxfrm(PyObject* self, PyObject* args)
352{
353    char *s, *buf;
354    size_t n1, n2;
355    PyObject *result;
356
357    if (!PyArg_ParseTuple(args, "s:strxfrm", &s))
358        return NULL;
359
360    /* assume no change in size, first */
361    n1 = strlen(s) + 1;
362    buf = PyMem_Malloc(n1);
363    if (!buf)
364        return PyErr_NoMemory();
365    n2 = strxfrm(buf, s, n1) + 1;
366    if (n2 > n1) {
367        /* more space needed */
368        buf = PyMem_Realloc(buf, n2);
369        if (!buf)
370            return PyErr_NoMemory();
371        strxfrm(buf, s, n2);
372    }
373    result = PyString_FromString(buf);
374    PyMem_Free(buf);
375    return result;
376}
377
378#if defined(MS_WINDOWS)
379static PyObject*
380PyLocale_getdefaultlocale(PyObject* self)
381{
382    char encoding[100];
383    char locale[100];
384
385    PyOS_snprintf(encoding, sizeof(encoding), "cp%d", GetACP());
386
387    if (GetLocaleInfo(LOCALE_USER_DEFAULT,
388                      LOCALE_SISO639LANGNAME,
389                      locale, sizeof(locale))) {
390        Py_ssize_t i = strlen(locale);
391        locale[i++] = '_';
392        if (GetLocaleInfo(LOCALE_USER_DEFAULT,
393                          LOCALE_SISO3166CTRYNAME,
394                          locale+i, (int)(sizeof(locale)-i)))
395            return Py_BuildValue("ss", locale, encoding);
396    }
397
398    /* If we end up here, this windows version didn't know about
399       ISO639/ISO3166 names (it's probably Windows 95).  Return the
400       Windows language identifier instead (a hexadecimal number) */
401
402    locale[0] = '0';
403    locale[1] = 'x';
404    if (GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTLANGUAGE,
405                      locale+2, sizeof(locale)-2)) {
406        return Py_BuildValue("ss", locale, encoding);
407    }
408
409    /* cannot determine the language code (very unlikely) */
410    Py_INCREF(Py_None);
411    return Py_BuildValue("Os", Py_None, encoding);
412}
413#endif
414
415#if defined(__APPLE__)
416/*
417** Find out what the current script is.
418** Donated by Fredrik Lundh.
419*/
420static char *mac_getscript(void)
421{
422    CFStringEncoding enc = CFStringGetSystemEncoding();
423    static CFStringRef name = NULL;
424    /* Return the code name for the encodings for which we have codecs. */
425    switch(enc) {
426    case kCFStringEncodingMacRoman: return "mac-roman";
427    case kCFStringEncodingMacGreek: return "mac-greek";
428    case kCFStringEncodingMacCyrillic: return "mac-cyrillic";
429    case kCFStringEncodingMacTurkish: return "mac-turkish";
430    case kCFStringEncodingMacIcelandic: return "mac-icelandic";
431    /* XXX which one is mac-latin2? */
432    }
433    if (!name) {
434        /* This leaks an object. */
435        name = CFStringConvertEncodingToIANACharSetName(enc);
436    }
437    return (char *)CFStringGetCStringPtr(name, 0); 
438}
439
440static PyObject*
441PyLocale_getdefaultlocale(PyObject* self)
442{
443    return Py_BuildValue("Os", Py_None, mac_getscript());
444}
445#endif
446
447#ifdef HAVE_LANGINFO_H
448#define LANGINFO(X) {#X, X}
449static struct langinfo_constant{
450	char* name;
451	int value;
452} langinfo_constants[] = 
453{
454    /* These constants should exist on any langinfo implementation */
455    LANGINFO(DAY_1),
456    LANGINFO(DAY_2),
457    LANGINFO(DAY_3),
458    LANGINFO(DAY_4),
459    LANGINFO(DAY_5),
460    LANGINFO(DAY_6),
461    LANGINFO(DAY_7),
462
463    LANGINFO(ABDAY_1),
464    LANGINFO(ABDAY_2),
465    LANGINFO(ABDAY_3),
466    LANGINFO(ABDAY_4),
467    LANGINFO(ABDAY_5),
468    LANGINFO(ABDAY_6),
469    LANGINFO(ABDAY_7),
470
471    LANGINFO(MON_1),
472    LANGINFO(MON_2),
473    LANGINFO(MON_3),
474    LANGINFO(MON_4),
475    LANGINFO(MON_5),
476    LANGINFO(MON_6),
477    LANGINFO(MON_7),
478    LANGINFO(MON_8),
479    LANGINFO(MON_9),
480    LANGINFO(MON_10),
481    LANGINFO(MON_11),
482    LANGINFO(MON_12),
483
484    LANGINFO(ABMON_1),
485    LANGINFO(ABMON_2),
486    LANGINFO(ABMON_3),
487    LANGINFO(ABMON_4),
488    LANGINFO(ABMON_5),
489    LANGINFO(ABMON_6),
490    LANGINFO(ABMON_7),
491    LANGINFO(ABMON_8),
492    LANGINFO(ABMON_9),
493    LANGINFO(ABMON_10),
494    LANGINFO(ABMON_11),
495    LANGINFO(ABMON_12),
496
497#ifdef RADIXCHAR
498    /* The following are not available with glibc 2.0 */
499    LANGINFO(RADIXCHAR),
500    LANGINFO(THOUSEP),
501    /* YESSTR and NOSTR are deprecated in glibc, since they are
502       a special case of message translation, which should be rather
503       done using gettext. So we don't expose it to Python in the
504       first place.
505    LANGINFO(YESSTR),
506    LANGINFO(NOSTR),
507    */
508    LANGINFO(CRNCYSTR),
509#endif
510
511    LANGINFO(D_T_FMT),
512    LANGINFO(D_FMT),
513    LANGINFO(T_FMT),
514    LANGINFO(AM_STR),
515    LANGINFO(PM_STR),
516
517    /* The following constants are available only with XPG4, but...
518       AIX 3.2. only has CODESET.
519       OpenBSD doesn't have CODESET but has T_FMT_AMPM, and doesn't have
520       a few of the others.
521       Solution: ifdef-test them all. */
522#ifdef CODESET
523    LANGINFO(CODESET),
524#endif
525#ifdef T_FMT_AMPM
526    LANGINFO(T_FMT_AMPM),
527#endif
528#ifdef ERA
529    LANGINFO(ERA),
530#endif
531#ifdef ERA_D_FMT
532    LANGINFO(ERA_D_FMT),
533#endif
534#ifdef ERA_D_T_FMT
535    LANGINFO(ERA_D_T_FMT),
536#endif
537#ifdef ERA_T_FMT
538    LANGINFO(ERA_T_FMT),
539#endif
540#ifdef ALT_DIGITS
541    LANGINFO(ALT_DIGITS),
542#endif
543#ifdef YESEXPR
544    LANGINFO(YESEXPR),
545#endif
546#ifdef NOEXPR
547    LANGINFO(NOEXPR),
548#endif
549#ifdef _DATE_FMT
550    /* This is not available in all glibc versions that have CODESET. */
551    LANGINFO(_DATE_FMT),
552#endif
553    {0, 0}
554};
555
556PyDoc_STRVAR(nl_langinfo__doc__,
557"nl_langinfo(key) -> string\n"
558"Return the value for the locale information associated with key.");
559
560static PyObject*
561PyLocale_nl_langinfo(PyObject* self, PyObject* args)
562{
563    int item, i;
564    if (!PyArg_ParseTuple(args, "i:nl_langinfo", &item))
565        return NULL;
566    /* Check whether this is a supported constant. GNU libc sometimes
567       returns numeric values in the char* return value, which would
568       crash PyString_FromString.  */
569    for (i = 0; langinfo_constants[i].name; i++)
570        if (langinfo_constants[i].value == item) {
571            /* Check NULL as a workaround for GNU libc's returning NULL
572               instead of an empty string for nl_langinfo(ERA).  */
573            const char *result = nl_langinfo(item);
574            return PyString_FromString(result != NULL ? result : "");
575        }
576    PyErr_SetString(PyExc_ValueError, "unsupported langinfo constant");
577    return NULL;
578}
579#endif /* HAVE_LANGINFO_H */
580
581#ifdef HAVE_LIBINTL_H
582
583PyDoc_STRVAR(gettext__doc__,
584"gettext(msg) -> string\n"
585"Return translation of msg.");
586
587static PyObject*
588PyIntl_gettext(PyObject* self, PyObject *args)
589{
590	char *in;
591	if (!PyArg_ParseTuple(args, "s", &in))
592		return 0;
593	return PyString_FromString(gettext(in));
594}
595
596PyDoc_STRVAR(dgettext__doc__,
597"dgettext(domain, msg) -> string\n"
598"Return translation of msg in domain.");
599
600static PyObject*
601PyIntl_dgettext(PyObject* self, PyObject *args)
602{
603	char *domain, *in;
604	if (!PyArg_ParseTuple(args, "zs", &domain, &in))
605		return 0;
606	return PyString_FromString(dgettext(domain, in));
607}
608
609PyDoc_STRVAR(dcgettext__doc__,
610"dcgettext(domain, msg, category) -> string\n"
611"Return translation of msg in domain and category.");
612
613static PyObject*
614PyIntl_dcgettext(PyObject *self, PyObject *args)
615{
616	char *domain, *msgid;
617	int category;
618	if (!PyArg_ParseTuple(args, "zsi", &domain, &msgid, &category))
619		return 0;
620	return PyString_FromString(dcgettext(domain,msgid,category));
621}
622
623PyDoc_STRVAR(textdomain__doc__,
624"textdomain(domain) -> string\n"
625"Set the C library's textdmain to domain, returning the new domain.");
626
627static PyObject*
628PyIntl_textdomain(PyObject* self, PyObject* args)
629{
630	char *domain;
631	if (!PyArg_ParseTuple(args, "z", &domain))
632		return 0;
633	domain = textdomain(domain);
634	if (!domain) {
635		PyErr_SetFromErrno(PyExc_OSError);
636		return NULL;
637	}
638	return PyString_FromString(domain);
639}
640
641PyDoc_STRVAR(bindtextdomain__doc__,
642"bindtextdomain(domain, dir) -> string\n"
643"Bind the C library's domain to dir.");
644
645static PyObject*
646PyIntl_bindtextdomain(PyObject* self,PyObject*args)
647{
648	char *domain, *dirname;
649	if (!PyArg_ParseTuple(args, "sz", &domain, &dirname))
650		return 0;
651	if (!strlen(domain)) {
652		PyErr_SetString(Error, "domain must be a non-empty string");
653		return 0;
654	}
655	dirname = bindtextdomain(domain, dirname);
656	if (!dirname) {
657		PyErr_SetFromErrno(PyExc_OSError);
658		return NULL;
659	}
660	return PyString_FromString(dirname);
661}
662
663#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
664PyDoc_STRVAR(bind_textdomain_codeset__doc__,
665"bind_textdomain_codeset(domain, codeset) -> string\n"
666"Bind the C library's domain to codeset.");
667
668static PyObject*
669PyIntl_bind_textdomain_codeset(PyObject* self,PyObject*args)
670{
671	char *domain,*codeset;
672	if (!PyArg_ParseTuple(args, "sz", &domain, &codeset))
673		return NULL;
674	codeset = bind_textdomain_codeset(domain, codeset);
675	if (codeset)
676		return PyString_FromString(codeset);
677	Py_RETURN_NONE;
678}
679#endif
680
681#endif
682
683static struct PyMethodDef PyLocale_Methods[] = {
684  {"setlocale", (PyCFunction) PyLocale_setlocale, 
685   METH_VARARGS, setlocale__doc__},
686  {"localeconv", (PyCFunction) PyLocale_localeconv, 
687   METH_NOARGS, localeconv__doc__},
688  {"strcoll", (PyCFunction) PyLocale_strcoll, 
689   METH_VARARGS, strcoll__doc__},
690  {"strxfrm", (PyCFunction) PyLocale_strxfrm, 
691   METH_VARARGS, strxfrm__doc__},
692#if defined(MS_WINDOWS) || defined(__APPLE__)
693  {"_getdefaultlocale", (PyCFunction) PyLocale_getdefaultlocale, METH_NOARGS},
694#endif
695#ifdef HAVE_LANGINFO_H
696  {"nl_langinfo", (PyCFunction) PyLocale_nl_langinfo,
697   METH_VARARGS, nl_langinfo__doc__},
698#endif
699#ifdef HAVE_LIBINTL_H
700  {"gettext",(PyCFunction)PyIntl_gettext,METH_VARARGS,
701    gettext__doc__},
702  {"dgettext",(PyCFunction)PyIntl_dgettext,METH_VARARGS,
703   dgettext__doc__},
704  {"dcgettext",(PyCFunction)PyIntl_dcgettext,METH_VARARGS,
705    dcgettext__doc__},
706  {"textdomain",(PyCFunction)PyIntl_textdomain,METH_VARARGS,
707   textdomain__doc__},
708  {"bindtextdomain",(PyCFunction)PyIntl_bindtextdomain,METH_VARARGS,
709   bindtextdomain__doc__},
710#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
711  {"bind_textdomain_codeset",(PyCFunction)PyIntl_bind_textdomain_codeset,
712   METH_VARARGS, bind_textdomain_codeset__doc__},
713#endif
714#endif  
715  {NULL, NULL}
716};
717
718PyMODINIT_FUNC
719init_locale(void)
720{
721    PyObject *m, *d, *x;
722#ifdef HAVE_LANGINFO_H
723    int i;
724#endif
725
726    m = Py_InitModule("_locale", PyLocale_Methods);
727    if (m == NULL)
728    	return;
729
730    d = PyModule_GetDict(m);
731
732    x = PyInt_FromLong(LC_CTYPE);
733    PyDict_SetItemString(d, "LC_CTYPE", x);
734    Py_XDECREF(x);
735
736    x = PyInt_FromLong(LC_TIME);
737    PyDict_SetItemString(d, "LC_TIME", x);
738    Py_XDECREF(x);
739
740    x = PyInt_FromLong(LC_COLLATE);
741    PyDict_SetItemString(d, "LC_COLLATE", x);
742    Py_XDECREF(x);
743
744    x = PyInt_FromLong(LC_MONETARY);
745    PyDict_SetItemString(d, "LC_MONETARY", x);
746    Py_XDECREF(x);
747
748#ifdef LC_MESSAGES
749    x = PyInt_FromLong(LC_MESSAGES);
750    PyDict_SetItemString(d, "LC_MESSAGES", x);
751    Py_XDECREF(x);
752#endif /* LC_MESSAGES */
753
754    x = PyInt_FromLong(LC_NUMERIC);
755    PyDict_SetItemString(d, "LC_NUMERIC", x);
756    Py_XDECREF(x);
757
758    x = PyInt_FromLong(LC_ALL);
759    PyDict_SetItemString(d, "LC_ALL", x);
760    Py_XDECREF(x);
761
762    x = PyInt_FromLong(CHAR_MAX);
763    PyDict_SetItemString(d, "CHAR_MAX", x);
764    Py_XDECREF(x);
765
766    Error = PyErr_NewException("locale.Error", NULL, NULL);
767    PyDict_SetItemString(d, "Error", Error);
768
769    x = PyString_FromString(locale__doc__);
770    PyDict_SetItemString(d, "__doc__", x);
771    Py_XDECREF(x);
772
773#ifdef HAVE_LANGINFO_H
774    for (i = 0; langinfo_constants[i].name; i++) {
775	    PyModule_AddIntConstant(m, langinfo_constants[i].name,
776				    langinfo_constants[i].value);
777    }
778#endif
779}
780
781/* 
782Local variables:
783c-basic-offset: 4
784indent-tabs-mode: nil
785End:
786*/