/* Find the decimal point character(s?), thousands_separator(s?), and
grouping description, either for the current locale if type is
LT_CURRENT_LOCALE, a hard-coded locale if LT_DEFAULT_LOCALE, or
none if LT_NO_LOCALE. */
static int
get_locale_info(int type, LocaleInfo *locale_info)
{
switch (type) {
case LT_CURRENT_LOCALE: {
struct lconv *locale_data = localeconv();
locale_info->decimal_point = PyUnicode_DecodeLocale(
locale_data->decimal_point,
NULL);
if (locale_info->decimal_point == NULL)
return -1;
locale_info->thousands_sep = PyUnicode_DecodeLocale(
locale_data->thousands_sep,
NULL);
if (locale_info->thousands_sep == NULL) {
Py_DECREF(locale_info->decimal_point);
return -1;
}
locale_info->grouping = locale_data->grouping;
break;
}
case LT_DEFAULT_LOCALE:
locale_info->decimal_point = PyUnicode_FromOrdinal('.');
locale_info->thousands_sep = PyUnicode_FromOrdinal(',');
if (!locale_info->decimal_point || !locale_info->thousands_sep) {
Py_XDECREF(locale_info->decimal_point);
Py_XDECREF(locale_info->thousands_sep);
return -1;
}
locale_info->grouping = "\3"; /* Group every 3 characters. The
(implicit) trailing 0 means repeat
infinitely. */
break;
case LT_NO_LOCALE:
locale_info->decimal_point = PyUnicode_FromOrdinal('.');
locale_info->thousands_sep = PyUnicode_New(0, 0);
if (!locale_info->decimal_point || !locale_info->thousands_sep) {
Py_XDECREF(locale_info->decimal_point);
Py_XDECREF(locale_info->thousands_sep);
return -1;
}
locale_info->grouping = no_grouping;
break;
default:
assert(0);
}
return 0;
}
static PyObject *
get_nullchar_as_None(Py_UCS4 c)
{
if (c == '\0') {
Py_RETURN_NONE;
}
else
return PyUnicode_FromOrdinal(c);
}
static PyObject *
get_nullchar_as_None(Py_UCS4 c)
{
if (c == '\0') {
Py_INCREF(Py_None);
return Py_None;
}
else
return PyUnicode_FromOrdinal(c);
}
static int
format_long_internal(PyObject *value, const InternalFormatSpec *format,
_PyUnicodeWriter *writer)
{
int result = -1;
Py_UCS4 maxchar = 127;
PyObject *tmp = NULL;
Py_ssize_t inumeric_chars;
Py_UCS4 sign_char = '\0';
Py_ssize_t n_digits; /* count of digits need from the computed
string */
Py_ssize_t n_remainder = 0; /* Used only for 'c' formatting, which
produces non-digits */
Py_ssize_t n_prefix = 0; /* Count of prefix chars, (e.g., '0x') */
Py_ssize_t n_total;
Py_ssize_t prefix = 0;
NumberFieldWidths spec;
long x;
/* Locale settings, either from the actual locale or
from a hard-code pseudo-locale */
LocaleInfo locale = STATIC_LOCALE_INFO_INIT;
/* no precision allowed on integers */
if (format->precision != -1) {
PyErr_SetString(PyExc_ValueError,
"Precision not allowed in integer format specifier");
goto done;
}
/* special case for character formatting */
if (format->type == 'c') {
/* error to specify a sign */
if (format->sign != '\0') {
PyErr_SetString(PyExc_ValueError,
"Sign not allowed with integer"
" format specifier 'c'");
goto done;
}
/* taken from unicodeobject.c formatchar() */
/* Integer input truncated to a character */
x = PyLong_AsLong(value);
if (x == -1 && PyErr_Occurred())
goto done;
if (x < 0 || x > 0x10ffff) {
PyErr_SetString(PyExc_OverflowError,
"%c arg not in range(0x110000)");
goto done;
}
tmp = PyUnicode_FromOrdinal(x);
inumeric_chars = 0;
n_digits = 1;
maxchar = Py_MAX(maxchar, (Py_UCS4)x);
/* As a sort-of hack, we tell calc_number_widths that we only
have "remainder" characters. calc_number_widths thinks
these are characters that don't get formatted, only copied
into the output string. We do this for 'c' formatting,
because the characters are likely to be non-digits. */
n_remainder = 1;
}
else {
int base;
int leading_chars_to_skip = 0; /* Number of characters added by
PyNumber_ToBase that we want to
skip over. */
/* Compute the base and how many characters will be added by
PyNumber_ToBase */
switch (format->type) {
case 'b':
base = 2;
leading_chars_to_skip = 2; /* 0b */
break;
case 'o':
base = 8;
leading_chars_to_skip = 2; /* 0o */
break;
case 'x':
case 'X':
base = 16;
leading_chars_to_skip = 2; /* 0x */
break;
default: /* shouldn't be needed, but stops a compiler warning */
case 'd':
case 'n':
base = 10;
break;
}
if (format->sign != '+' && format->sign != ' '
&& format->width == -1
&& format->type != 'X' && format->type != 'n'
&& !format->thousands_separators
&& PyLong_CheckExact(value))
{
/* Fast path */
return _PyLong_FormatWriter(writer, value, base, format->alternate);
}
/* The number of prefix chars is the same as the leading
chars to skip */
if (format->alternate)
n_prefix = leading_chars_to_skip;
/* Do the hard part, converting to a string in a given base */
tmp = _PyLong_Format(value, base);
if (tmp == NULL || PyUnicode_READY(tmp) == -1)
goto done;
inumeric_chars = 0;
n_digits = PyUnicode_GET_LENGTH(tmp);
prefix = inumeric_chars;
/* Is a sign character present in the output? If so, remember it
and skip it */
if (PyUnicode_READ_CHAR(tmp, inumeric_chars) == '-') {
sign_char = '-';
++prefix;
++leading_chars_to_skip;
}
/* Skip over the leading chars (0x, 0b, etc.) */
n_digits -= leading_chars_to_skip;
inumeric_chars += leading_chars_to_skip;
}
/* Determine the grouping, separator, and decimal point, if any. */
if (get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE :
(format->thousands_separators ?
LT_DEFAULT_LOCALE :
LT_NO_LOCALE),
&locale) == -1)
goto done;
/* Calculate how much memory we'll need. */
n_total = calc_number_widths(&spec, n_prefix, sign_char, tmp, inumeric_chars,
inumeric_chars + n_digits, n_remainder, 0,
&locale, format, &maxchar);
/* Allocate the memory. */
if (_PyUnicodeWriter_Prepare(writer, n_total, maxchar) == -1)
goto done;
/* Populate the memory. */
result = fill_number(writer, &spec,
tmp, inumeric_chars, inumeric_chars + n_digits,
tmp, prefix, format->fill_char,
&locale, format->type == 'X');
done:
Py_XDECREF(tmp);
free_locale_info(&locale);
return result;
}
/* +interp, +buf */
static inline ssize_t CReader_readStr_read_unicodeescape(CReader_Buffer *buffer, off_t *pos, char *dst)
{
ssize_t len = 0;
off_t p = *pos;
PyObject *u;
PyObject *s;
char *sbuffer;
int slength;
switch (buffer->buf[buffer->pos + p++])
{
case 'N':
p++; /* skip '{' too */
{
size_t namestart = p;
while (1)
{
if (!CReader_Buffer_unlockedExtend(buffer, p + 1)) return -1;
if (buffer->buf[buffer->pos + p] == '}')
break;
p++;
}
{
size_t namelen = p - namestart;
char name[namelen + 1];
memcpy(name, buffer->buf + buffer->pos + namestart, namelen);
name[namelen] = '\0';
u = PyObject_CallFunction(unicodedatalookup, "s", name);
}
p++; /* skip '}' */
break;
}
case 'u':
{
char num[5];
if (!CReader_Buffer_unlockedExtend(buffer, p + 4)) return -1;
memcpy(num, buffer->buf + buffer->pos + p, 4);
num[4] = '\0';
p += 4;
u = PyUnicode_FromOrdinal((int) strtol(num, NULL, 16));
break;
}
case 'U':
{
char num[9];
if (!CReader_Buffer_unlockedExtend(buffer, p + 8)) return -1;
memcpy(num, buffer->buf + buffer->pos + p, 8);
num[8] = '\0';
p += 8;
u = PyUnicode_FromOrdinal((int) strtol(num, NULL, 16));
break;
}
}
if (!u) return -1;
s = PyUnicode_AsEncodedString(u, "utf", "strict");
Py_DECREF(u);
if (!s) return -1;
if (PyString_AsStringAndSize(s, &sbuffer, &slength) == -1)
{
Py_DECREF(s);
return -1;
}
len += slength;
p++; /* skip '}' */
if (dst)
{
memcpy(dst, sbuffer, slength);
dst += slength;
if (!CReader_Buffer_unlockedAdvance(buffer, p)) return -1;
p = 0;
}
Py_DECREF(s);
*pos = p;
return len;
}
static PyObject*
_create_dict_from_event (SDL_Event *event, int release)
{
PyObject *val = NULL;
PyObject *dict = PyDict_New ();
if (!dict)
return NULL;
if (event->type >= SDL_USEREVENT && event->type < SDL_NUMEVENTS)
{
if (event->user.code == PYGAME_USEREVENT_CODE &&
event->user.data1 == (void*)PYGAME_USEREVENT)
{
/* It comes from pygame, it goes to pygame. */
PyObject *vdict = (PyObject*) event->user.data2;
if (PyDict_Update (dict, vdict) == -1)
goto failed;
if (release)
{
Py_DECREF (vdict);
}
return dict;
}
else
{
/* It comes from some SDL stuff, it goes to pygame. */
if (!_set_item (dict, "code", PyInt_FromLong (event->user.code)))
goto failed;
#if PY_VERSION_HEX >= 0x03010000
if (!_set_item (dict, "data1",
PyCapsule_New (event->user.data1, "data1", NULL)))
goto failed;
if (!_set_item (dict, "data2",
PyCapsule_New (event->user.data2, "data2", NULL)))
goto failed;
#else
if (!_set_item (dict, "data1",
PyCObject_FromVoidPtr (event->user.data1, NULL)))
goto failed;
if (!_set_item (dict, "data2",
PyCObject_FromVoidPtr (event->user.data2, NULL)))
goto failed;
#endif
}
return dict;
}
switch (event->type)
{
case SDL_ACTIVEEVENT:
if (!_set_item (dict, "gain", PyInt_FromLong (event->active.gain)))
goto failed;
if (!_set_item (dict, "state", PyInt_FromLong (event->active.state)))
goto failed;
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
if (!_set_item (dict, "state", PyInt_FromLong (event->key.state)))
goto failed;
if (!_set_item (dict, "scancode",
PyInt_FromLong (event->key.keysym.scancode)))
goto failed;
if (!_set_item (dict, "key",
PyLong_FromUnsignedLong (event->key.keysym.sym)))
goto failed;
if (!_set_item (dict, "sym",
PyLong_FromUnsignedLong (event->key.keysym.sym)))
goto failed;
if (!_set_item (dict, "mod",
PyLong_FromUnsignedLong (event->key.keysym.mod)))
goto failed;
/* if SDL_EnableUNICODE() == 0, unicode will be a 0 character */
if (!_set_item (dict, "unicode",
PyUnicode_FromOrdinal (event->key.keysym.unicode)))
goto failed;
break;
case SDL_MOUSEMOTION:
if (!_set_item (dict, "state", PyInt_FromLong (event->motion.state)))
goto failed;
if (!_set_item (dict, "x", PyInt_FromLong (event->motion.x)))
goto failed;
if (!_set_item (dict, "y", PyInt_FromLong (event->motion.y)))
goto failed;
if (!_set_item (dict, "xrel", PyInt_FromLong (event->motion.xrel)))
goto failed;
if (!_set_item (dict, "yrel", PyInt_FromLong (event->motion.yrel)))
goto failed;
val = Py_BuildValue ("(ii)", event->motion.x, event->motion.y);
if (!val)
goto failed;
if (!_set_item (dict, "pos", val))
goto failed;
val = Py_BuildValue ("(ii)", event->motion.xrel, event->motion.yrel);
if (!val)
goto failed;
if (!_set_item (dict, "rel", val))
goto failed;
val = PyTuple_New (3);
if (!val)
return NULL;
PyTuple_SET_ITEM (val, 0,
PyBool_FromLong (event->motion.state & SDL_BUTTON(1)));
PyTuple_SET_ITEM (val, 1,
PyBool_FromLong (event->motion.state & SDL_BUTTON(2)));
PyTuple_SET_ITEM (val, 2,
PyBool_FromLong (event->motion.state & SDL_BUTTON(3)));
if (!_set_item (dict, "buttons", val))
goto failed;
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
if (!_set_item (dict, "button", PyInt_FromLong (event->button.button)))
goto failed;
if (!_set_item (dict, "x", PyInt_FromLong (event->button.x)))
goto failed;
if (!_set_item (dict, "y", PyInt_FromLong (event->button.y)))
goto failed;
val = Py_BuildValue ("(ii)", event->button.x, event->button.y);
if (!val)
goto failed;
if (!_set_item (dict, "pos", val))
goto failed;
if (!_set_item (dict, "state", PyInt_FromLong (event->button.state)))
goto failed;
break;
case SDL_JOYAXISMOTION:
if (!_set_item (dict, "which", PyInt_FromLong (event->jaxis.which)))
goto failed;
if (!_set_item (dict, "joy", PyInt_FromLong (event->jaxis.which)))
goto failed;
if (!_set_item (dict, "axis", PyInt_FromLong (event->jaxis.axis)))
goto failed;
if (!_set_item (dict, "value", PyInt_FromLong (event->jaxis.value)))
goto failed;
break;
case SDL_JOYBALLMOTION:
if (!_set_item (dict, "which", PyInt_FromLong (event->jball.which)))
goto failed;
if (!_set_item (dict, "joy", PyInt_FromLong (event->jball.which)))
goto failed;
if (!_set_item (dict, "ball", PyInt_FromLong (event->jball.ball)))
goto failed;
if (!_set_item (dict, "xrel", PyInt_FromLong (event->jball.xrel)))
goto failed;
if (!_set_item (dict, "yrel", PyInt_FromLong (event->jball.yrel)))
goto failed;
val = Py_BuildValue ("(ii)", event->jball.xrel, event->jball.yrel);
if (!val)
goto failed;
if (!_set_item (dict, "rel", val))
goto failed;
break;
case SDL_JOYHATMOTION:
if (!_set_item (dict, "which", PyInt_FromLong (event->jhat.which)))
goto failed;
if (!_set_item (dict, "joy", PyInt_FromLong (event->jhat.which)))
goto failed;
if (!_set_item (dict, "hat", PyInt_FromLong (event->jhat.hat)))
goto failed;
if (!_set_item (dict, "value", PyInt_FromLong (event->jhat.value)))
goto failed;
break;
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
if (!_set_item (dict, "which", PyInt_FromLong (event->jbutton.which)))
goto failed;
if (!_set_item (dict, "joy", PyInt_FromLong (event->jbutton.which)))
goto failed;
if (!_set_item (dict, "button", PyInt_FromLong (event->jbutton.button)))
goto failed;
if (!_set_item (dict, "state", PyInt_FromLong (event->jbutton.state)))
goto failed;
break;
case SDL_VIDEORESIZE:
if (!_set_item (dict, "w", PyInt_FromLong (event->resize.w)))
goto failed;
if (!_set_item (dict, "h", PyInt_FromLong (event->resize.h)))
goto failed;
val = Py_BuildValue ("(ii)", event->resize.w, event->resize.h);
if (!val)
goto failed;
if (!_set_item (dict, "size", val))
goto failed;
break;
case SDL_SYSWMEVENT:
#if defined(SDL_VIDEO_DRIVER_WINDIB) || defined(SDL_VIDEO_DRIVER_DDRAW) || defined(SDL_VIDEO_DRIVER_GAPI)
if (!_set_item (dict, "hwnd",
PyInt_FromLong ((long) event->syswm.msg->hwnd)))
goto failed;
if (!_set_item (dict, "msg", PyInt_FromLong (event->syswm.msg->msg)))
goto failed;
if (!_set_item (dict, "wparam",
PyInt_FromLong (event->syswm.msg->wParam)))
goto failed;
if (!_set_item (dict, "lparam",
PyInt_FromLong (event-> syswm.msg->lParam)))
goto failed;
#elif defined(SDL_VIDEO_DRIVER_X11)
if (!_set_item (dict, "event", Text_FromUTF8AndSize
((char*) &(event->syswm.msg->event.xevent), sizeof (XEvent))))
goto failed;
#endif
break;
case SDL_QUIT:
break;
case SDL_VIDEOEXPOSE:
break;
default:
break;
}
return dict;
failed:
Py_XDECREF (val);
Py_XDECREF (dict);
return NULL;
}
