mirror of
https://github.com/python/cpython.git
synced 2025-10-31 13:41:24 +00:00
361 lines
9.1 KiB
C
361 lines
9.1 KiB
C
/***********************************************************
|
|
Copyright (C) 1997 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 <stdio.h>
|
|
#include <errno.h>
|
|
#include <locale.h>
|
|
#include <string.h>
|
|
#include <limits.h>
|
|
#include <ctype.h>
|
|
#include "Python.h"
|
|
#ifdef macintosh
|
|
char *strdup Py_PROTO((char *));
|
|
#endif
|
|
|
|
static char locale__doc__[]="Support for POSIX locales.";
|
|
|
|
static PyObject *Error;
|
|
|
|
/* support functions for formatting floating point numbers */
|
|
|
|
static char setlocale__doc__[]=
|
|
"(integer,string=None) -> string. Activates/queries locale processing."
|
|
;
|
|
|
|
/* to record the LC_NUMERIC settings */
|
|
static PyObject* grouping=0;
|
|
static PyObject* thousands_sep=0;
|
|
static PyObject* decimal_point=0;
|
|
/* if non-null, indicates that LC_NUMERIC is different from "C" */
|
|
static char* saved_numeric=0;
|
|
|
|
/* the grouping is terminated by either 0 or CHAR_MAX */
|
|
static PyObject*
|
|
copy_grouping(s)
|
|
char* s;
|
|
{
|
|
int i;
|
|
PyObject *result,*val=0;
|
|
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=0;
|
|
break;
|
|
}
|
|
}while(s[i]!='\0' && s[i]!=CHAR_MAX);
|
|
if(!val){
|
|
Py_DECREF(result);
|
|
return NULL;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static void
|
|
fixup_ulcase()
|
|
{
|
|
PyObject *mods,*strop,*string,*ulo;
|
|
unsigned char ul[256];
|
|
int n,c;
|
|
|
|
/* finding sys.modules */
|
|
mods=PyImport_GetModuleDict();
|
|
if(!mods)return;
|
|
/* finding the module */
|
|
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 */
|
|
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 */
|
|
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 */
|
|
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(self,args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
int category;
|
|
char *locale=0,*result;
|
|
PyObject *result_object;
|
|
struct lconv *lc;
|
|
if(!PyArg_ParseTuple(args,"i|z",&category,&locale))return 0;
|
|
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=0;
|
|
}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();
|
|
}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");
|
|
}
|
|
return result_object;
|
|
}
|
|
|
|
static char localeconv__doc__[]=
|
|
"() -> dict. Returns numeric and monetary locale-specific parameters."
|
|
;
|
|
|
|
static PyObject*
|
|
PyLocale_localeconv(self,args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
PyObject* result;
|
|
struct lconv *l;
|
|
PyObject *x;
|
|
if(!PyArg_NoArgs(args))return 0;
|
|
result = PyDict_New();
|
|
if(!result)return 0;
|
|
/* 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 */
|
|
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);
|
|
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;
|
|
}
|
|
|
|
static char strcoll__doc__[]=
|
|
"string,string -> int. Compares two strings according to the locale."
|
|
;
|
|
|
|
static PyObject*
|
|
PyLocale_strcoll(self,args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
char *s1,*s2;
|
|
if(!PyArg_ParseTuple(args,"ss",&s1,&s2))
|
|
return NULL;
|
|
return PyInt_FromLong(strcoll(s1,s2));
|
|
}
|
|
|
|
static char strxfrm__doc__[]=
|
|
"string -> string. Returns a string that behaves for cmp locale-aware."
|
|
;
|
|
|
|
static PyObject*
|
|
PyLocale_strxfrm(self,args)
|
|
PyObject* self;
|
|
PyObject* args;
|
|
{
|
|
char *s,*buf;
|
|
int n1,n2;
|
|
PyObject *result;
|
|
if(!PyArg_ParseTuple(args,"s",&s))
|
|
return NULL;
|
|
/* assume no change in size, first */
|
|
n1=strlen(s)+1;
|
|
buf=Py_Malloc(n1);
|
|
if(!buf)return NULL;
|
|
n2=strxfrm(buf,s,n1);
|
|
if(n2>n1){
|
|
/* more space needed */
|
|
buf=Py_Realloc(buf,n2);
|
|
if(!buf)return NULL;
|
|
strxfrm(buf,s,n2);
|
|
}
|
|
result=PyString_FromString(buf);
|
|
Py_Free(buf);
|
|
return result;
|
|
}
|
|
|
|
static struct PyMethodDef PyLocale_Methods[] = {
|
|
{"setlocale",(PyCFunction)PyLocale_setlocale,1,setlocale__doc__},
|
|
{"localeconv",(PyCFunction)PyLocale_localeconv,0,localeconv__doc__},
|
|
{"strcoll",(PyCFunction)PyLocale_strcoll,1,strcoll__doc__},
|
|
{"strxfrm",(PyCFunction)PyLocale_strxfrm,1,strxfrm__doc__},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
DL_EXPORT(void)
|
|
init_locale()
|
|
{
|
|
PyObject *m,*d,*x;
|
|
m=Py_InitModule("_locale",PyLocale_Methods);
|
|
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);
|
|
|
|
if(PyErr_Occurred())
|
|
Py_FatalError("Can't initialize module locale");
|
|
}
|