source: python/vendor/Python-2.6.5/Modules/_localemodule.c

Last change on this file was 2, checked in by Yuri Dario, 15 years ago

Initial import for vendor code.
  • Property svn:eol-style set to native
File size: 19.8 KB
Line 
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*/
Note: See TracBrowser for help on using the repository browser.