1990-10-14 20:07:46 +08:00
|
|
|
|
/* String object implementation */
|
|
|
|
|
|
1997-05-02 11:12:38 +08:00
|
|
|
|
#include "Python.h"
|
1990-10-14 20:07:46 +08:00
|
|
|
|
|
1994-08-30 16:19:36 +08:00
|
|
|
|
#include <ctype.h>
|
|
|
|
|
|
1993-10-22 20:04:32 +08:00
|
|
|
|
#ifdef COUNT_ALLOCS
|
|
|
|
|
int null_strings, one_strings;
|
|
|
|
|
#endif
|
|
|
|
|
|
1997-05-02 11:12:38 +08:00
|
|
|
|
static PyStringObject *characters[UCHAR_MAX + 1];
|
|
|
|
|
static PyStringObject *nullstring;
|
1993-10-22 20:04:32 +08:00
|
|
|
|
|
2002-08-20 05:43:18 +08:00
|
|
|
|
/* This dictionary holds all interned strings. Note that references to
|
|
|
|
|
strings in this dictionary are *not* counted in the string's ob_refcnt.
|
|
|
|
|
When the interned string reaches a refcnt of 0 the string deallocation
|
|
|
|
|
function will delete the reference from this dictionary.
|
|
|
|
|
|
|
|
|
|
Another way to look at this is that to say that the actual reference
|
|
|
|
|
count of a string is: s->ob_refcnt + (s->ob_sstate?2:0)
|
|
|
|
|
*/
|
|
|
|
|
static PyObject *interned;
|
|
|
|
|
|
|
|
|
|
|
1993-10-22 20:04:32 +08:00
|
|
|
|
/*
|
2002-04-15 21:48:52 +08:00
|
|
|
|
For both PyString_FromString() and PyString_FromStringAndSize(), the
|
|
|
|
|
parameter `size' denotes number of characters to allocate, not counting any
|
2002-01-16 18:53:24 +08:00
|
|
|
|
null terminating character.
|
|
|
|
|
|
2002-04-15 21:48:52 +08:00
|
|
|
|
For PyString_FromString(), the parameter `str' points to a null-terminated
|
2002-01-16 18:53:24 +08:00
|
|
|
|
string containing exactly `size' bytes.
|
|
|
|
|
|
2002-04-15 21:48:52 +08:00
|
|
|
|
For PyString_FromStringAndSize(), the parameter the parameter `str' is
|
|
|
|
|
either NULL or else points to a string containing at least `size' bytes.
|
|
|
|
|
For PyString_FromStringAndSize(), the string in the `str' parameter does
|
|
|
|
|
not have to be null-terminated. (Therefore it is safe to construct a
|
|
|
|
|
substring by calling `PyString_FromStringAndSize(origstring, substrlen)'.)
|
|
|
|
|
If `str' is NULL then PyString_FromStringAndSize() will allocate `size+1'
|
|
|
|
|
bytes (setting the last byte to the null terminating character) and you can
|
|
|
|
|
fill in the data yourself. If `str' is non-NULL then the resulting
|
|
|
|
|
PyString object must be treated as immutable and you must not fill in nor
|
|
|
|
|
alter the data yourself, since the strings may be shared.
|
|
|
|
|
|
|
|
|
|
The PyObject member `op->ob_size', which denotes the number of "extra
|
|
|
|
|
items" in a variable-size object, will contain the number of bytes
|
|
|
|
|
allocated for string data, not counting the null terminating character. It
|
|
|
|
|
is therefore equal to the equal to the `size' parameter (for
|
|
|
|
|
PyString_FromStringAndSize()) or the length of the string in the `str'
|
|
|
|
|
parameter (for PyString_FromString()).
|
1993-10-22 20:04:32 +08:00
|
|
|
|
*/
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
PyString_FromStringAndSize(const char *str, int size)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
{
|
2001-05-09 15:37:07 +08:00
|
|
|
|
register PyStringObject *op;
|
1993-10-22 20:04:32 +08:00
|
|
|
|
if (size == 0 && (op = nullstring) != NULL) {
|
|
|
|
|
#ifdef COUNT_ALLOCS
|
|
|
|
|
null_strings++;
|
|
|
|
|
#endif
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_INCREF(op);
|
|
|
|
|
return (PyObject *)op;
|
1993-10-22 20:04:32 +08:00
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
if (size == 1 && str != NULL &&
|
|
|
|
|
(op = characters[*str & UCHAR_MAX]) != NULL)
|
|
|
|
|
{
|
1993-10-22 20:04:32 +08:00
|
|
|
|
#ifdef COUNT_ALLOCS
|
|
|
|
|
one_strings++;
|
|
|
|
|
#endif
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_INCREF(op);
|
|
|
|
|
return (PyObject *)op;
|
1993-10-22 20:04:32 +08:00
|
|
|
|
}
|
2000-05-04 07:44:39 +08:00
|
|
|
|
|
2002-08-20 03:26:42 +08:00
|
|
|
|
/* Inline PyObject_NewVar */
|
2004-06-28 01:24:49 +08:00
|
|
|
|
op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
|
1990-10-22 06:15:08 +08:00
|
|
|
|
if (op == NULL)
|
1997-05-02 11:12:38 +08:00
|
|
|
|
return PyErr_NoMemory();
|
2000-05-04 07:44:39 +08:00
|
|
|
|
PyObject_INIT_VAR(op, &PyString_Type, size);
|
1993-10-22 20:04:32 +08:00
|
|
|
|
op->ob_shash = -1;
|
2002-08-20 05:43:18 +08:00
|
|
|
|
op->ob_sstate = SSTATE_NOT_INTERNED;
|
1990-10-22 06:15:08 +08:00
|
|
|
|
if (str != NULL)
|
|
|
|
|
memcpy(op->ob_sval, str, size);
|
|
|
|
|
op->ob_sval[size] = '\0';
|
2002-03-30 18:06:07 +08:00
|
|
|
|
/* share short strings */
|
1993-10-22 20:04:32 +08:00
|
|
|
|
if (size == 0) {
|
2001-05-09 15:37:07 +08:00
|
|
|
|
PyObject *t = (PyObject *)op;
|
|
|
|
|
PyString_InternInPlace(&t);
|
2001-05-09 16:43:21 +08:00
|
|
|
|
op = (PyStringObject *)t;
|
1993-10-22 20:04:32 +08:00
|
|
|
|
nullstring = op;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_INCREF(op);
|
1993-10-22 20:04:32 +08:00
|
|
|
|
} else if (size == 1 && str != NULL) {
|
2001-05-09 15:37:07 +08:00
|
|
|
|
PyObject *t = (PyObject *)op;
|
|
|
|
|
PyString_InternInPlace(&t);
|
2001-05-09 16:43:21 +08:00
|
|
|
|
op = (PyStringObject *)t;
|
1993-10-22 20:04:32 +08:00
|
|
|
|
characters[*str & UCHAR_MAX] = op;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_INCREF(op);
|
1993-10-22 20:04:32 +08:00
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
return (PyObject *) op;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
|
|
|
|
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
PyString_FromString(const char *str)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
{
|
2001-12-07 04:29:32 +08:00
|
|
|
|
register size_t size;
|
2001-05-09 15:37:07 +08:00
|
|
|
|
register PyStringObject *op;
|
2001-12-07 04:29:32 +08:00
|
|
|
|
|
|
|
|
|
assert(str != NULL);
|
|
|
|
|
size = strlen(str);
|
2000-06-30 18:29:57 +08:00
|
|
|
|
if (size > INT_MAX) {
|
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
|
|
|
"string is too long for a Python string");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
1993-10-22 20:04:32 +08:00
|
|
|
|
if (size == 0 && (op = nullstring) != NULL) {
|
|
|
|
|
#ifdef COUNT_ALLOCS
|
|
|
|
|
null_strings++;
|
|
|
|
|
#endif
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_INCREF(op);
|
|
|
|
|
return (PyObject *)op;
|
1993-10-22 20:04:32 +08:00
|
|
|
|
}
|
|
|
|
|
if (size == 1 && (op = characters[*str & UCHAR_MAX]) != NULL) {
|
|
|
|
|
#ifdef COUNT_ALLOCS
|
|
|
|
|
one_strings++;
|
|
|
|
|
#endif
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_INCREF(op);
|
|
|
|
|
return (PyObject *)op;
|
1993-10-22 20:04:32 +08:00
|
|
|
|
}
|
2000-05-04 07:44:39 +08:00
|
|
|
|
|
2002-08-20 03:26:42 +08:00
|
|
|
|
/* Inline PyObject_NewVar */
|
2004-06-28 01:24:49 +08:00
|
|
|
|
op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
|
1990-10-22 06:15:08 +08:00
|
|
|
|
if (op == NULL)
|
1997-05-02 11:12:38 +08:00
|
|
|
|
return PyErr_NoMemory();
|
2000-05-04 07:44:39 +08:00
|
|
|
|
PyObject_INIT_VAR(op, &PyString_Type, size);
|
1993-10-22 20:04:32 +08:00
|
|
|
|
op->ob_shash = -1;
|
2002-08-20 05:43:18 +08:00
|
|
|
|
op->ob_sstate = SSTATE_NOT_INTERNED;
|
2001-12-10 23:45:54 +08:00
|
|
|
|
memcpy(op->ob_sval, str, size+1);
|
2002-03-30 18:06:07 +08:00
|
|
|
|
/* share short strings */
|
1993-10-22 20:04:32 +08:00
|
|
|
|
if (size == 0) {
|
2001-05-09 15:37:07 +08:00
|
|
|
|
PyObject *t = (PyObject *)op;
|
|
|
|
|
PyString_InternInPlace(&t);
|
2001-05-09 16:43:21 +08:00
|
|
|
|
op = (PyStringObject *)t;
|
1993-10-22 20:04:32 +08:00
|
|
|
|
nullstring = op;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_INCREF(op);
|
1993-10-22 20:04:32 +08:00
|
|
|
|
} else if (size == 1) {
|
2001-05-09 15:37:07 +08:00
|
|
|
|
PyObject *t = (PyObject *)op;
|
|
|
|
|
PyString_InternInPlace(&t);
|
2001-05-09 16:43:21 +08:00
|
|
|
|
op = (PyStringObject *)t;
|
1993-10-22 20:04:32 +08:00
|
|
|
|
characters[*str & UCHAR_MAX] = op;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_INCREF(op);
|
1993-10-22 20:04:32 +08:00
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
return (PyObject *) op;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
|
|
|
|
|
2001-08-25 02:32:06 +08:00
|
|
|
|
PyObject *
|
|
|
|
|
PyString_FromFormatV(const char *format, va_list vargs)
|
|
|
|
|
{
|
2001-10-03 05:32:07 +08:00
|
|
|
|
va_list count;
|
2001-08-25 02:32:06 +08:00
|
|
|
|
int n = 0;
|
|
|
|
|
const char* f;
|
|
|
|
|
char *s;
|
|
|
|
|
PyObject* string;
|
|
|
|
|
|
2001-10-03 05:32:07 +08:00
|
|
|
|
#ifdef VA_LIST_IS_ARRAY
|
|
|
|
|
memcpy(count, vargs, sizeof(va_list));
|
2002-07-28 18:23:27 +08:00
|
|
|
|
#else
|
|
|
|
|
#ifdef __va_copy
|
|
|
|
|
__va_copy(count, vargs);
|
2001-10-03 05:32:07 +08:00
|
|
|
|
#else
|
|
|
|
|
count = vargs;
|
2002-07-28 18:23:27 +08:00
|
|
|
|
#endif
|
2001-10-03 05:32:07 +08:00
|
|
|
|
#endif
|
2001-08-25 02:32:06 +08:00
|
|
|
|
/* step 1: figure out how large a buffer we need */
|
|
|
|
|
for (f = format; *f; f++) {
|
|
|
|
|
if (*f == '%') {
|
|
|
|
|
const char* p = f;
|
|
|
|
|
while (*++f && *f != '%' && !isalpha(Py_CHARMASK(*f)))
|
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
/* skip the 'l' in %ld, since it doesn't change the
|
|
|
|
|
width. although only %d is supported (see
|
|
|
|
|
"expand" section below), others can be easily
|
2001-12-03 09:55:38 +08:00
|
|
|
|
added */
|
2001-08-25 02:32:06 +08:00
|
|
|
|
if (*f == 'l' && *(f+1) == 'd')
|
|
|
|
|
++f;
|
2002-04-15 21:48:52 +08:00
|
|
|
|
|
2001-08-25 02:32:06 +08:00
|
|
|
|
switch (*f) {
|
|
|
|
|
case 'c':
|
|
|
|
|
(void)va_arg(count, int);
|
|
|
|
|
/* fall through... */
|
|
|
|
|
case '%':
|
|
|
|
|
n++;
|
|
|
|
|
break;
|
|
|
|
|
case 'd': case 'i': case 'x':
|
|
|
|
|
(void) va_arg(count, int);
|
2001-12-03 09:55:38 +08:00
|
|
|
|
/* 20 bytes is enough to hold a 64-bit
|
|
|
|
|
integer. Decimal takes the most space.
|
|
|
|
|
This isn't enough for octal. */
|
2001-08-25 02:32:06 +08:00
|
|
|
|
n += 20;
|
|
|
|
|
break;
|
|
|
|
|
case 's':
|
|
|
|
|
s = va_arg(count, char*);
|
|
|
|
|
n += strlen(s);
|
|
|
|
|
break;
|
|
|
|
|
case 'p':
|
|
|
|
|
(void) va_arg(count, int);
|
|
|
|
|
/* maximum 64-bit pointer representation:
|
|
|
|
|
* 0xffffffffffffffff
|
|
|
|
|
* so 19 characters is enough.
|
2001-12-03 09:55:38 +08:00
|
|
|
|
* XXX I count 18 -- what's the extra for?
|
2001-08-25 02:32:06 +08:00
|
|
|
|
*/
|
|
|
|
|
n += 19;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
/* if we stumble upon an unknown
|
|
|
|
|
formatting code, copy the rest of
|
|
|
|
|
the format string to the output
|
|
|
|
|
string. (we cannot just skip the
|
|
|
|
|
code, since there's no way to know
|
2002-04-15 21:48:52 +08:00
|
|
|
|
what's in the argument list) */
|
2001-08-25 02:32:06 +08:00
|
|
|
|
n += strlen(p);
|
|
|
|
|
goto expand;
|
|
|
|
|
}
|
|
|
|
|
} else
|
|
|
|
|
n++;
|
|
|
|
|
}
|
|
|
|
|
expand:
|
|
|
|
|
/* step 2: fill the buffer */
|
2001-12-03 09:55:38 +08:00
|
|
|
|
/* Since we've analyzed how much space we need for the worst case,
|
|
|
|
|
use sprintf directly instead of the slower PyOS_snprintf. */
|
2001-08-25 02:32:06 +08:00
|
|
|
|
string = PyString_FromStringAndSize(NULL, n);
|
|
|
|
|
if (!string)
|
|
|
|
|
return NULL;
|
2002-04-15 21:48:52 +08:00
|
|
|
|
|
2001-08-25 02:32:06 +08:00
|
|
|
|
s = PyString_AsString(string);
|
|
|
|
|
|
|
|
|
|
for (f = format; *f; f++) {
|
|
|
|
|
if (*f == '%') {
|
|
|
|
|
const char* p = f++;
|
|
|
|
|
int i, longflag = 0;
|
|
|
|
|
/* parse the width.precision part (we're only
|
|
|
|
|
interested in the precision value, if any) */
|
|
|
|
|
n = 0;
|
|
|
|
|
while (isdigit(Py_CHARMASK(*f)))
|
|
|
|
|
n = (n*10) + *f++ - '0';
|
|
|
|
|
if (*f == '.') {
|
|
|
|
|
f++;
|
|
|
|
|
n = 0;
|
|
|
|
|
while (isdigit(Py_CHARMASK(*f)))
|
|
|
|
|
n = (n*10) + *f++ - '0';
|
|
|
|
|
}
|
|
|
|
|
while (*f && *f != '%' && !isalpha(Py_CHARMASK(*f)))
|
|
|
|
|
f++;
|
|
|
|
|
/* handle the long flag, but only for %ld. others
|
|
|
|
|
can be added when necessary. */
|
|
|
|
|
if (*f == 'l' && *(f+1) == 'd') {
|
|
|
|
|
longflag = 1;
|
|
|
|
|
++f;
|
|
|
|
|
}
|
2002-04-15 21:48:52 +08:00
|
|
|
|
|
2001-08-25 02:32:06 +08:00
|
|
|
|
switch (*f) {
|
|
|
|
|
case 'c':
|
|
|
|
|
*s++ = va_arg(vargs, int);
|
|
|
|
|
break;
|
|
|
|
|
case 'd':
|
|
|
|
|
if (longflag)
|
|
|
|
|
sprintf(s, "%ld", va_arg(vargs, long));
|
|
|
|
|
else
|
|
|
|
|
sprintf(s, "%d", va_arg(vargs, int));
|
|
|
|
|
s += strlen(s);
|
|
|
|
|
break;
|
|
|
|
|
case 'i':
|
|
|
|
|
sprintf(s, "%i", va_arg(vargs, int));
|
|
|
|
|
s += strlen(s);
|
|
|
|
|
break;
|
|
|
|
|
case 'x':
|
|
|
|
|
sprintf(s, "%x", va_arg(vargs, int));
|
|
|
|
|
s += strlen(s);
|
|
|
|
|
break;
|
|
|
|
|
case 's':
|
|
|
|
|
p = va_arg(vargs, char*);
|
|
|
|
|
i = strlen(p);
|
|
|
|
|
if (n > 0 && i > n)
|
|
|
|
|
i = n;
|
|
|
|
|
memcpy(s, p, i);
|
|
|
|
|
s += i;
|
|
|
|
|
break;
|
|
|
|
|
case 'p':
|
|
|
|
|
sprintf(s, "%p", va_arg(vargs, void*));
|
2001-08-25 11:02:28 +08:00
|
|
|
|
/* %p is ill-defined: ensure leading 0x. */
|
|
|
|
|
if (s[1] == 'X')
|
|
|
|
|
s[1] = 'x';
|
|
|
|
|
else if (s[1] != 'x') {
|
|
|
|
|
memmove(s+2, s, strlen(s)+1);
|
|
|
|
|
s[0] = '0';
|
|
|
|
|
s[1] = 'x';
|
|
|
|
|
}
|
2001-08-25 02:32:06 +08:00
|
|
|
|
s += strlen(s);
|
|
|
|
|
break;
|
|
|
|
|
case '%':
|
|
|
|
|
*s++ = '%';
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
strcpy(s, p);
|
|
|
|
|
s += strlen(s);
|
|
|
|
|
goto end;
|
|
|
|
|
}
|
|
|
|
|
} else
|
|
|
|
|
*s++ = *f;
|
|
|
|
|
}
|
2002-04-15 21:48:52 +08:00
|
|
|
|
|
2001-08-25 02:32:06 +08:00
|
|
|
|
end:
|
2001-08-27 11:11:09 +08:00
|
|
|
|
_PyString_Resize(&string, s - PyString_AS_STRING(string));
|
2001-08-25 02:32:06 +08:00
|
|
|
|
return string;
|
|
|
|
|
}
|
2002-04-15 21:48:52 +08:00
|
|
|
|
|
2001-08-25 02:32:06 +08:00
|
|
|
|
PyObject *
|
2002-04-15 21:48:52 +08:00
|
|
|
|
PyString_FromFormat(const char *format, ...)
|
2001-08-25 02:32:06 +08:00
|
|
|
|
{
|
2001-08-27 11:11:09 +08:00
|
|
|
|
PyObject* ret;
|
2001-08-25 02:32:06 +08:00
|
|
|
|
va_list vargs;
|
|
|
|
|
|
|
|
|
|
#ifdef HAVE_STDARG_PROTOTYPES
|
|
|
|
|
va_start(vargs, format);
|
|
|
|
|
#else
|
|
|
|
|
va_start(vargs);
|
|
|
|
|
#endif
|
2001-08-27 11:11:09 +08:00
|
|
|
|
ret = PyString_FromFormatV(format, vargs);
|
|
|
|
|
va_end(vargs);
|
|
|
|
|
return ret;
|
2001-08-25 02:32:06 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2000-07-06 19:29:01 +08:00
|
|
|
|
PyObject *PyString_Decode(const char *s,
|
|
|
|
|
int size,
|
|
|
|
|
const char *encoding,
|
|
|
|
|
const char *errors)
|
|
|
|
|
{
|
2001-05-15 20:00:02 +08:00
|
|
|
|
PyObject *v, *str;
|
|
|
|
|
|
|
|
|
|
str = PyString_FromStringAndSize(s, size);
|
|
|
|
|
if (str == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
v = PyString_AsDecodedString(str, encoding, errors);
|
|
|
|
|
Py_DECREF(str);
|
|
|
|
|
return v;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
PyObject *PyString_AsDecodedObject(PyObject *str,
|
|
|
|
|
const char *encoding,
|
|
|
|
|
const char *errors)
|
|
|
|
|
{
|
|
|
|
|
PyObject *v;
|
|
|
|
|
|
|
|
|
|
if (!PyString_Check(str)) {
|
|
|
|
|
PyErr_BadArgument();
|
|
|
|
|
goto onError;
|
|
|
|
|
}
|
2001-04-28 13:38:26 +08:00
|
|
|
|
|
2001-08-18 02:39:25 +08:00
|
|
|
|
if (encoding == NULL) {
|
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-07-06 19:29:01 +08:00
|
|
|
|
encoding = PyUnicode_GetDefaultEncoding();
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#else
|
|
|
|
|
PyErr_SetString(PyExc_ValueError, "no encoding specified");
|
|
|
|
|
goto onError;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
2000-07-06 19:29:01 +08:00
|
|
|
|
|
|
|
|
|
/* Decode via the codec registry */
|
2001-05-15 20:00:02 +08:00
|
|
|
|
v = PyCodec_Decode(str, encoding, errors);
|
|
|
|
|
if (v == NULL)
|
2000-07-06 19:29:01 +08:00
|
|
|
|
goto onError;
|
2001-05-15 20:00:02 +08:00
|
|
|
|
|
|
|
|
|
return v;
|
|
|
|
|
|
|
|
|
|
onError:
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
PyObject *PyString_AsDecodedString(PyObject *str,
|
|
|
|
|
const char *encoding,
|
|
|
|
|
const char *errors)
|
|
|
|
|
{
|
|
|
|
|
PyObject *v;
|
|
|
|
|
|
|
|
|
|
v = PyString_AsDecodedObject(str, encoding, errors);
|
|
|
|
|
if (v == NULL)
|
2000-07-06 19:29:01 +08:00
|
|
|
|
goto onError;
|
2001-05-15 20:00:02 +08:00
|
|
|
|
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-07-06 19:29:01 +08:00
|
|
|
|
/* Convert Unicode to a string using the default encoding */
|
2001-05-15 20:00:02 +08:00
|
|
|
|
if (PyUnicode_Check(v)) {
|
|
|
|
|
PyObject *temp = v;
|
|
|
|
|
v = PyUnicode_AsEncodedString(v, NULL, NULL);
|
2000-07-06 19:29:01 +08:00
|
|
|
|
Py_DECREF(temp);
|
2001-05-15 20:00:02 +08:00
|
|
|
|
if (v == NULL)
|
2000-07-06 19:29:01 +08:00
|
|
|
|
goto onError;
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2001-05-15 20:00:02 +08:00
|
|
|
|
if (!PyString_Check(v)) {
|
2000-07-06 19:29:01 +08:00
|
|
|
|
PyErr_Format(PyExc_TypeError,
|
2000-07-12 10:58:28 +08:00
|
|
|
|
"decoder did not return a string object (type=%.400s)",
|
2001-05-15 20:00:02 +08:00
|
|
|
|
v->ob_type->tp_name);
|
|
|
|
|
Py_DECREF(v);
|
2000-07-06 19:29:01 +08:00
|
|
|
|
goto onError;
|
|
|
|
|
}
|
2001-05-15 20:00:02 +08:00
|
|
|
|
|
|
|
|
|
return v;
|
2001-04-28 13:38:26 +08:00
|
|
|
|
|
2000-07-06 19:29:01 +08:00
|
|
|
|
onError:
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
PyObject *PyString_Encode(const char *s,
|
|
|
|
|
int size,
|
|
|
|
|
const char *encoding,
|
|
|
|
|
const char *errors)
|
|
|
|
|
{
|
|
|
|
|
PyObject *v, *str;
|
2001-04-28 13:38:26 +08:00
|
|
|
|
|
2000-07-06 19:29:01 +08:00
|
|
|
|
str = PyString_FromStringAndSize(s, size);
|
|
|
|
|
if (str == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
v = PyString_AsEncodedString(str, encoding, errors);
|
|
|
|
|
Py_DECREF(str);
|
|
|
|
|
return v;
|
|
|
|
|
}
|
|
|
|
|
|
2001-05-15 20:00:02 +08:00
|
|
|
|
PyObject *PyString_AsEncodedObject(PyObject *str,
|
2000-07-06 19:29:01 +08:00
|
|
|
|
const char *encoding,
|
|
|
|
|
const char *errors)
|
|
|
|
|
{
|
|
|
|
|
PyObject *v;
|
2001-04-28 13:38:26 +08:00
|
|
|
|
|
2000-07-06 19:29:01 +08:00
|
|
|
|
if (!PyString_Check(str)) {
|
|
|
|
|
PyErr_BadArgument();
|
|
|
|
|
goto onError;
|
|
|
|
|
}
|
|
|
|
|
|
2001-08-18 02:39:25 +08:00
|
|
|
|
if (encoding == NULL) {
|
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-07-06 19:29:01 +08:00
|
|
|
|
encoding = PyUnicode_GetDefaultEncoding();
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#else
|
|
|
|
|
PyErr_SetString(PyExc_ValueError, "no encoding specified");
|
|
|
|
|
goto onError;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
2000-07-06 19:29:01 +08:00
|
|
|
|
|
|
|
|
|
/* Encode via the codec registry */
|
|
|
|
|
v = PyCodec_Encode(str, encoding, errors);
|
|
|
|
|
if (v == NULL)
|
|
|
|
|
goto onError;
|
2001-05-15 20:00:02 +08:00
|
|
|
|
|
|
|
|
|
return v;
|
|
|
|
|
|
|
|
|
|
onError:
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
PyObject *PyString_AsEncodedString(PyObject *str,
|
|
|
|
|
const char *encoding,
|
|
|
|
|
const char *errors)
|
|
|
|
|
{
|
|
|
|
|
PyObject *v;
|
|
|
|
|
|
2001-06-12 21:14:10 +08:00
|
|
|
|
v = PyString_AsEncodedObject(str, encoding, errors);
|
2001-05-15 20:00:02 +08:00
|
|
|
|
if (v == NULL)
|
|
|
|
|
goto onError;
|
|
|
|
|
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-07-06 19:29:01 +08:00
|
|
|
|
/* Convert Unicode to a string using the default encoding */
|
|
|
|
|
if (PyUnicode_Check(v)) {
|
|
|
|
|
PyObject *temp = v;
|
|
|
|
|
v = PyUnicode_AsEncodedString(v, NULL, NULL);
|
|
|
|
|
Py_DECREF(temp);
|
|
|
|
|
if (v == NULL)
|
|
|
|
|
goto onError;
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2000-07-06 19:29:01 +08:00
|
|
|
|
if (!PyString_Check(v)) {
|
|
|
|
|
PyErr_Format(PyExc_TypeError,
|
|
|
|
|
"encoder did not return a string object (type=%.400s)",
|
|
|
|
|
v->ob_type->tp_name);
|
|
|
|
|
Py_DECREF(v);
|
|
|
|
|
goto onError;
|
|
|
|
|
}
|
2001-05-15 20:00:02 +08:00
|
|
|
|
|
2000-07-06 19:29:01 +08:00
|
|
|
|
return v;
|
2001-04-28 13:38:26 +08:00
|
|
|
|
|
2000-07-06 19:29:01 +08:00
|
|
|
|
onError:
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
1993-06-17 20:35:49 +08:00
|
|
|
|
static void
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_dealloc(PyObject *op)
|
1992-03-28 01:31:02 +08:00
|
|
|
|
{
|
2002-08-20 05:43:18 +08:00
|
|
|
|
switch (PyString_CHECK_INTERNED(op)) {
|
|
|
|
|
case SSTATE_NOT_INTERNED:
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSTATE_INTERNED_MORTAL:
|
|
|
|
|
/* revive dead object temporarily for DelItem */
|
|
|
|
|
op->ob_refcnt = 3;
|
|
|
|
|
if (PyDict_DelItem(interned, op) != 0)
|
|
|
|
|
Py_FatalError(
|
|
|
|
|
"deletion of interned string failed");
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSTATE_INTERNED_IMMORTAL:
|
|
|
|
|
Py_FatalError("Immortal interned string died.");
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
Py_FatalError("Inconsistent interned string state.");
|
|
|
|
|
}
|
2001-10-06 04:51:39 +08:00
|
|
|
|
op->ob_type->tp_free(op);
|
1992-03-28 01:31:02 +08:00
|
|
|
|
}
|
|
|
|
|
|
2002-08-14 15:46:28 +08:00
|
|
|
|
/* Unescape a backslash-escaped string. If unicode is non-zero,
|
|
|
|
|
the string is a u-literal. If recode_encoding is non-zero,
|
|
|
|
|
the string is UTF-8 encoded and should be re-encoded in the
|
|
|
|
|
specified encoding. */
|
|
|
|
|
|
|
|
|
|
PyObject *PyString_DecodeEscape(const char *s,
|
|
|
|
|
int len,
|
|
|
|
|
const char *errors,
|
|
|
|
|
int unicode,
|
|
|
|
|
const char *recode_encoding)
|
|
|
|
|
{
|
|
|
|
|
int c;
|
|
|
|
|
char *p, *buf;
|
|
|
|
|
const char *end;
|
|
|
|
|
PyObject *v;
|
2002-09-03 21:53:40 +08:00
|
|
|
|
int newlen = recode_encoding ? 4*len:len;
|
|
|
|
|
v = PyString_FromStringAndSize((char *)NULL, newlen);
|
2002-08-14 15:46:28 +08:00
|
|
|
|
if (v == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
p = buf = PyString_AsString(v);
|
|
|
|
|
end = s + len;
|
|
|
|
|
while (s < end) {
|
|
|
|
|
if (*s != '\\') {
|
2002-09-09 14:17:05 +08:00
|
|
|
|
non_esc:
|
2002-08-14 15:46:28 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
|
|
|
|
if (recode_encoding && (*s & 0x80)) {
|
|
|
|
|
PyObject *u, *w;
|
|
|
|
|
char *r;
|
|
|
|
|
const char* t;
|
|
|
|
|
int rn;
|
|
|
|
|
t = s;
|
|
|
|
|
/* Decode non-ASCII bytes as UTF-8. */
|
|
|
|
|
while (t < end && (*t & 0x80)) t++;
|
|
|
|
|
u = PyUnicode_DecodeUTF8(s, t - s, errors);
|
|
|
|
|
if(!u) goto failed;
|
|
|
|
|
|
|
|
|
|
/* Recode them in target encoding. */
|
|
|
|
|
w = PyUnicode_AsEncodedString(
|
|
|
|
|
u, recode_encoding, errors);
|
|
|
|
|
Py_DECREF(u);
|
|
|
|
|
if (!w) goto failed;
|
|
|
|
|
|
|
|
|
|
/* Append bytes to output buffer. */
|
|
|
|
|
r = PyString_AsString(w);
|
|
|
|
|
rn = PyString_Size(w);
|
|
|
|
|
memcpy(p, r, rn);
|
|
|
|
|
p += rn;
|
|
|
|
|
Py_DECREF(w);
|
|
|
|
|
s = t;
|
|
|
|
|
} else {
|
|
|
|
|
*p++ = *s++;
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
*p++ = *s++;
|
|
|
|
|
#endif
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
s++;
|
2002-08-14 16:22:50 +08:00
|
|
|
|
if (s==end) {
|
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
|
"Trailing \\ in string");
|
|
|
|
|
goto failed;
|
|
|
|
|
}
|
2002-08-14 15:46:28 +08:00
|
|
|
|
switch (*s++) {
|
|
|
|
|
/* XXX This assumes ASCII! */
|
|
|
|
|
case '\n': break;
|
|
|
|
|
case '\\': *p++ = '\\'; break;
|
|
|
|
|
case '\'': *p++ = '\''; break;
|
|
|
|
|
case '\"': *p++ = '\"'; break;
|
|
|
|
|
case 'b': *p++ = '\b'; break;
|
|
|
|
|
case 'f': *p++ = '\014'; break; /* FF */
|
|
|
|
|
case 't': *p++ = '\t'; break;
|
|
|
|
|
case 'n': *p++ = '\n'; break;
|
|
|
|
|
case 'r': *p++ = '\r'; break;
|
|
|
|
|
case 'v': *p++ = '\013'; break; /* VT */
|
|
|
|
|
case 'a': *p++ = '\007'; break; /* BEL, not classic C */
|
|
|
|
|
case '0': case '1': case '2': case '3':
|
|
|
|
|
case '4': case '5': case '6': case '7':
|
|
|
|
|
c = s[-1] - '0';
|
|
|
|
|
if ('0' <= *s && *s <= '7') {
|
|
|
|
|
c = (c<<3) + *s++ - '0';
|
|
|
|
|
if ('0' <= *s && *s <= '7')
|
|
|
|
|
c = (c<<3) + *s++ - '0';
|
|
|
|
|
}
|
|
|
|
|
*p++ = c;
|
|
|
|
|
break;
|
|
|
|
|
case 'x':
|
|
|
|
|
if (isxdigit(Py_CHARMASK(s[0]))
|
|
|
|
|
&& isxdigit(Py_CHARMASK(s[1]))) {
|
|
|
|
|
unsigned int x = 0;
|
|
|
|
|
c = Py_CHARMASK(*s);
|
|
|
|
|
s++;
|
|
|
|
|
if (isdigit(c))
|
|
|
|
|
x = c - '0';
|
|
|
|
|
else if (islower(c))
|
|
|
|
|
x = 10 + c - 'a';
|
|
|
|
|
else
|
|
|
|
|
x = 10 + c - 'A';
|
|
|
|
|
x = x << 4;
|
|
|
|
|
c = Py_CHARMASK(*s);
|
|
|
|
|
s++;
|
|
|
|
|
if (isdigit(c))
|
|
|
|
|
x += c - '0';
|
|
|
|
|
else if (islower(c))
|
|
|
|
|
x += 10 + c - 'a';
|
|
|
|
|
else
|
|
|
|
|
x += 10 + c - 'A';
|
|
|
|
|
*p++ = x;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (!errors || strcmp(errors, "strict") == 0) {
|
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
|
"invalid \\x escape");
|
2002-08-14 16:22:50 +08:00
|
|
|
|
goto failed;
|
2002-08-14 15:46:28 +08:00
|
|
|
|
}
|
|
|
|
|
if (strcmp(errors, "replace") == 0) {
|
|
|
|
|
*p++ = '?';
|
|
|
|
|
} else if (strcmp(errors, "ignore") == 0)
|
|
|
|
|
/* do nothing */;
|
|
|
|
|
else {
|
|
|
|
|
PyErr_Format(PyExc_ValueError,
|
|
|
|
|
"decoding error; "
|
|
|
|
|
"unknown error handling code: %.400s",
|
|
|
|
|
errors);
|
2002-08-14 16:22:50 +08:00
|
|
|
|
goto failed;
|
2002-08-14 15:46:28 +08:00
|
|
|
|
}
|
|
|
|
|
#ifndef Py_USING_UNICODE
|
|
|
|
|
case 'u':
|
|
|
|
|
case 'U':
|
|
|
|
|
case 'N':
|
|
|
|
|
if (unicode) {
|
2002-08-17 07:20:39 +08:00
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
2002-08-14 15:46:28 +08:00
|
|
|
|
"Unicode escapes not legal "
|
|
|
|
|
"when Unicode disabled");
|
2002-08-14 16:22:50 +08:00
|
|
|
|
goto failed;
|
2002-08-14 15:46:28 +08:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
default:
|
|
|
|
|
*p++ = '\\';
|
2002-09-09 14:17:05 +08:00
|
|
|
|
s--;
|
|
|
|
|
goto non_esc; /* an arbitry number of unescaped
|
|
|
|
|
UTF-8 bytes may follow. */
|
2002-08-14 15:46:28 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
2002-09-03 21:53:40 +08:00
|
|
|
|
if (p-buf < newlen)
|
|
|
|
|
_PyString_Resize(&v, (int)(p - buf));
|
2002-08-14 15:46:28 +08:00
|
|
|
|
return v;
|
|
|
|
|
failed:
|
|
|
|
|
Py_DECREF(v);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2000-09-20 05:04:18 +08:00
|
|
|
|
static int
|
|
|
|
|
string_getsize(register PyObject *op)
|
|
|
|
|
{
|
|
|
|
|
char *s;
|
|
|
|
|
int len;
|
|
|
|
|
if (PyString_AsStringAndSize(op, &s, &len))
|
|
|
|
|
return -1;
|
|
|
|
|
return len;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static /*const*/ char *
|
|
|
|
|
string_getbuffer(register PyObject *op)
|
|
|
|
|
{
|
|
|
|
|
char *s;
|
|
|
|
|
int len;
|
|
|
|
|
if (PyString_AsStringAndSize(op, &s, &len))
|
|
|
|
|
return NULL;
|
|
|
|
|
return s;
|
|
|
|
|
}
|
|
|
|
|
|
1995-01-03 03:07:15 +08:00
|
|
|
|
int
|
2000-07-09 15:04:36 +08:00
|
|
|
|
PyString_Size(register PyObject *op)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
{
|
2000-09-20 05:04:18 +08:00
|
|
|
|
if (!PyString_Check(op))
|
|
|
|
|
return string_getsize(op);
|
1997-05-02 11:12:38 +08:00
|
|
|
|
return ((PyStringObject *)op) -> ob_size;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*const*/ char *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
PyString_AsString(register PyObject *op)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
{
|
2000-09-20 05:04:18 +08:00
|
|
|
|
if (!PyString_Check(op))
|
|
|
|
|
return string_getbuffer(op);
|
|
|
|
|
return ((PyStringObject *)op) -> ob_sval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
PyString_AsStringAndSize(register PyObject *obj,
|
|
|
|
|
register char **s,
|
|
|
|
|
register int *len)
|
|
|
|
|
{
|
|
|
|
|
if (s == NULL) {
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyErr_BadInternalCall();
|
2000-09-20 05:04:18 +08:00
|
|
|
|
return -1;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
2000-09-20 05:04:18 +08:00
|
|
|
|
|
|
|
|
|
if (!PyString_Check(obj)) {
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-09-20 05:04:18 +08:00
|
|
|
|
if (PyUnicode_Check(obj)) {
|
|
|
|
|
obj = _PyUnicode_AsDefaultEncodedString(obj, NULL);
|
|
|
|
|
if (obj == NULL)
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2002-04-15 21:48:52 +08:00
|
|
|
|
else
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
|
|
|
|
{
|
2000-09-20 05:04:18 +08:00
|
|
|
|
PyErr_Format(PyExc_TypeError,
|
|
|
|
|
"expected string or Unicode object, "
|
|
|
|
|
"%.200s found", obj->ob_type->tp_name);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*s = PyString_AS_STRING(obj);
|
|
|
|
|
if (len != NULL)
|
|
|
|
|
*len = PyString_GET_SIZE(obj);
|
|
|
|
|
else if ((int)strlen(*s) != PyString_GET_SIZE(obj)) {
|
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
|
"expected string without null bytes");
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Methods */
|
|
|
|
|
|
1991-06-08 07:58:57 +09:00
|
|
|
|
static int
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_print(PyStringObject *op, FILE *fp, int flags)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
char c;
|
1993-10-26 23:25:16 +08:00
|
|
|
|
int quote;
|
2001-10-17 04:18:24 +08:00
|
|
|
|
|
1991-06-08 07:58:57 +09:00
|
|
|
|
/* XXX Ought to check for interrupts when writing long strings */
|
2001-10-17 04:18:24 +08:00
|
|
|
|
if (! PyString_CheckExact(op)) {
|
|
|
|
|
int ret;
|
|
|
|
|
/* A str subclass may have its own __str__ method. */
|
|
|
|
|
op = (PyStringObject *) PyObject_Str((PyObject *)op);
|
|
|
|
|
if (op == NULL)
|
|
|
|
|
return -1;
|
|
|
|
|
ret = string_print(op, fp, flags);
|
|
|
|
|
Py_DECREF(op);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
if (flags & Py_PRINT_RAW) {
|
2002-12-06 20:48:53 +08:00
|
|
|
|
#ifdef __VMS
|
|
|
|
|
if (op->ob_size) fwrite(op->ob_sval, (int) op->ob_size, 1, fp);
|
|
|
|
|
#else
|
|
|
|
|
fwrite(op->ob_sval, 1, (int) op->ob_size, fp);
|
|
|
|
|
#endif
|
1991-06-08 07:58:57 +09:00
|
|
|
|
return 0;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
1993-10-26 23:25:16 +08:00
|
|
|
|
|
2000-07-16 20:04:32 +08:00
|
|
|
|
/* figure out which quote to use; single is preferred */
|
1993-10-26 23:25:16 +08:00
|
|
|
|
quote = '\'';
|
2002-04-15 21:48:52 +08:00
|
|
|
|
if (memchr(op->ob_sval, '\'', op->ob_size) &&
|
|
|
|
|
!memchr(op->ob_sval, '"', op->ob_size))
|
1993-10-26 23:25:16 +08:00
|
|
|
|
quote = '"';
|
|
|
|
|
|
|
|
|
|
fputc(quote, fp);
|
1990-10-14 20:07:46 +08:00
|
|
|
|
for (i = 0; i < op->ob_size; i++) {
|
|
|
|
|
c = op->ob_sval[i];
|
1993-10-26 23:25:16 +08:00
|
|
|
|
if (c == quote || c == '\\')
|
2002-10-11 13:37:59 +08:00
|
|
|
|
fprintf(fp, "\\%c", c);
|
2001-01-25 01:19:08 +08:00
|
|
|
|
else if (c == '\t')
|
2002-10-11 13:37:59 +08:00
|
|
|
|
fprintf(fp, "\\t");
|
2001-01-25 01:19:08 +08:00
|
|
|
|
else if (c == '\n')
|
2002-10-11 13:37:59 +08:00
|
|
|
|
fprintf(fp, "\\n");
|
2001-01-25 01:19:08 +08:00
|
|
|
|
else if (c == '\r')
|
2002-10-11 13:37:59 +08:00
|
|
|
|
fprintf(fp, "\\r");
|
|
|
|
|
else if (c < ' ' || c >= 0x7f)
|
|
|
|
|
fprintf(fp, "\\x%02x", c & 0xff);
|
2002-10-07 21:55:50 +08:00
|
|
|
|
else
|
2002-10-11 13:37:59 +08:00
|
|
|
|
fputc(c, fp);
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
1993-10-26 23:25:16 +08:00
|
|
|
|
fputc(quote, fp);
|
1991-06-08 07:58:57 +09:00
|
|
|
|
return 0;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
|
|
|
|
|
2002-08-14 15:46:28 +08:00
|
|
|
|
PyObject *
|
|
|
|
|
PyString_Repr(PyObject *obj, int smartquotes)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
{
|
2002-08-14 15:46:28 +08:00
|
|
|
|
register PyStringObject* op = (PyStringObject*) obj;
|
2004-06-28 01:24:49 +08:00
|
|
|
|
size_t newsize = 2 + 4 * op->ob_size;
|
2000-06-30 18:29:57 +08:00
|
|
|
|
PyObject *v;
|
|
|
|
|
if (newsize > INT_MAX) {
|
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
|
|
|
"string is too large to make repr");
|
|
|
|
|
}
|
|
|
|
|
v = PyString_FromStringAndSize((char *)NULL, newsize);
|
1990-10-14 20:07:46 +08:00
|
|
|
|
if (v == NULL) {
|
1991-06-08 07:58:57 +09:00
|
|
|
|
return NULL;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
register int i;
|
|
|
|
|
register char c;
|
|
|
|
|
register char *p;
|
1993-10-26 23:25:16 +08:00
|
|
|
|
int quote;
|
|
|
|
|
|
2000-07-16 20:04:32 +08:00
|
|
|
|
/* figure out which quote to use; single is preferred */
|
1993-10-26 23:25:16 +08:00
|
|
|
|
quote = '\'';
|
2002-08-14 15:46:28 +08:00
|
|
|
|
if (smartquotes &&
|
|
|
|
|
memchr(op->ob_sval, '\'', op->ob_size) &&
|
2002-04-15 21:48:52 +08:00
|
|
|
|
!memchr(op->ob_sval, '"', op->ob_size))
|
1993-10-26 23:25:16 +08:00
|
|
|
|
quote = '"';
|
|
|
|
|
|
2001-12-03 09:55:38 +08:00
|
|
|
|
p = PyString_AS_STRING(v);
|
1993-10-26 23:25:16 +08:00
|
|
|
|
*p++ = quote;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
for (i = 0; i < op->ob_size; i++) {
|
2001-12-03 09:55:38 +08:00
|
|
|
|
/* There's at least enough room for a hex escape
|
|
|
|
|
and a closing quote. */
|
|
|
|
|
assert(newsize - (p - PyString_AS_STRING(v)) >= 5);
|
1990-10-14 20:07:46 +08:00
|
|
|
|
c = op->ob_sval[i];
|
1993-10-26 23:25:16 +08:00
|
|
|
|
if (c == quote || c == '\\')
|
1990-10-14 20:07:46 +08:00
|
|
|
|
*p++ = '\\', *p++ = c;
|
2001-01-25 01:19:08 +08:00
|
|
|
|
else if (c == '\t')
|
|
|
|
|
*p++ = '\\', *p++ = 't';
|
|
|
|
|
else if (c == '\n')
|
|
|
|
|
*p++ = '\\', *p++ = 'n';
|
|
|
|
|
else if (c == '\r')
|
|
|
|
|
*p++ = '\\', *p++ = 'r';
|
2002-10-11 13:37:59 +08:00
|
|
|
|
else if (c < ' ' || c >= 0x7f) {
|
|
|
|
|
/* For performance, we don't want to call
|
|
|
|
|
PyOS_snprintf here (extra layers of
|
|
|
|
|
function call). */
|
|
|
|
|
sprintf(p, "\\x%02x", c & 0xff);
|
|
|
|
|
p += 4;
|
2002-10-07 21:55:50 +08:00
|
|
|
|
}
|
2002-10-11 13:37:59 +08:00
|
|
|
|
else
|
|
|
|
|
*p++ = c;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
2001-12-03 09:55:38 +08:00
|
|
|
|
assert(newsize - (p - PyString_AS_STRING(v)) >= 1);
|
1993-10-26 23:25:16 +08:00
|
|
|
|
*p++ = quote;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
*p = '\0';
|
1997-05-02 11:12:38 +08:00
|
|
|
|
_PyString_Resize(
|
2001-12-03 09:55:38 +08:00
|
|
|
|
&v, (int) (p - PyString_AS_STRING(v)));
|
1990-10-22 06:15:08 +08:00
|
|
|
|
return v;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2002-08-14 15:46:28 +08:00
|
|
|
|
static PyObject *
|
|
|
|
|
string_repr(PyObject *op)
|
|
|
|
|
{
|
|
|
|
|
return PyString_Repr(op, 1);
|
|
|
|
|
}
|
|
|
|
|
|
2001-05-02 00:51:53 +08:00
|
|
|
|
static PyObject *
|
|
|
|
|
string_str(PyObject *s)
|
|
|
|
|
{
|
2001-10-17 04:18:24 +08:00
|
|
|
|
assert(PyString_Check(s));
|
|
|
|
|
if (PyString_CheckExact(s)) {
|
|
|
|
|
Py_INCREF(s);
|
|
|
|
|
return s;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
/* Subtype -- return genuine string with the same value. */
|
|
|
|
|
PyStringObject *t = (PyStringObject *) s;
|
|
|
|
|
return PyString_FromStringAndSize(t->ob_sval, t->ob_size);
|
|
|
|
|
}
|
2001-05-02 00:51:53 +08:00
|
|
|
|
}
|
|
|
|
|
|
1990-10-14 20:07:46 +08:00
|
|
|
|
static int
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_length(PyStringObject *a)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
{
|
|
|
|
|
return a->ob_size;
|
|
|
|
|
}
|
|
|
|
|
|
1997-05-02 11:12:38 +08:00
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_concat(register PyStringObject *a, register PyObject *bb)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
{
|
|
|
|
|
register unsigned int size;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
register PyStringObject *op;
|
|
|
|
|
if (!PyString_Check(bb)) {
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-03-11 06:55:18 +08:00
|
|
|
|
if (PyUnicode_Check(bb))
|
|
|
|
|
return PyUnicode_Concat((PyObject *)a, bb);
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2001-04-28 13:38:26 +08:00
|
|
|
|
PyErr_Format(PyExc_TypeError,
|
2001-10-22 12:12:44 +08:00
|
|
|
|
"cannot concatenate 'str' and '%.200s' objects",
|
2000-06-01 11:12:13 +08:00
|
|
|
|
bb->ob_type->tp_name);
|
1990-10-14 20:07:46 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
#define b ((PyStringObject *)bb)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
/* Optimize cases with empty left or right operand */
|
2001-09-12 10:18:30 +08:00
|
|
|
|
if ((a->ob_size == 0 || b->ob_size == 0) &&
|
|
|
|
|
PyString_CheckExact(a) && PyString_CheckExact(b)) {
|
|
|
|
|
if (a->ob_size == 0) {
|
|
|
|
|
Py_INCREF(bb);
|
|
|
|
|
return bb;
|
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_INCREF(a);
|
|
|
|
|
return (PyObject *)a;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
|
|
|
|
size = a->ob_size + b->ob_size;
|
2002-08-20 03:26:42 +08:00
|
|
|
|
/* Inline PyObject_NewVar */
|
2004-06-28 01:24:49 +08:00
|
|
|
|
op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
|
1990-10-22 06:15:08 +08:00
|
|
|
|
if (op == NULL)
|
1997-05-02 11:12:38 +08:00
|
|
|
|
return PyErr_NoMemory();
|
2000-05-04 07:44:39 +08:00
|
|
|
|
PyObject_INIT_VAR(op, &PyString_Type, size);
|
1993-10-22 20:04:32 +08:00
|
|
|
|
op->ob_shash = -1;
|
2002-08-20 05:43:18 +08:00
|
|
|
|
op->ob_sstate = SSTATE_NOT_INTERNED;
|
1990-10-22 06:15:08 +08:00
|
|
|
|
memcpy(op->ob_sval, a->ob_sval, (int) a->ob_size);
|
|
|
|
|
memcpy(op->ob_sval + a->ob_size, b->ob_sval, (int) b->ob_size);
|
|
|
|
|
op->ob_sval[size] = '\0';
|
1997-05-02 11:12:38 +08:00
|
|
|
|
return (PyObject *) op;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
#undef b
|
|
|
|
|
}
|
|
|
|
|
|
1997-05-02 11:12:38 +08:00
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_repeat(register PyStringObject *a, register int n)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
{
|
|
|
|
|
register int i;
|
2003-01-06 18:33:56 +08:00
|
|
|
|
register int j;
|
1997-04-10 03:41:24 +08:00
|
|
|
|
register int size;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
register PyStringObject *op;
|
2000-09-09 14:13:41 +08:00
|
|
|
|
size_t nbytes;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
if (n < 0)
|
|
|
|
|
n = 0;
|
2000-09-09 14:13:41 +08:00
|
|
|
|
/* watch out for overflows: the size can overflow int,
|
|
|
|
|
* and the # of bytes needed can overflow size_t
|
|
|
|
|
*/
|
1990-10-14 20:07:46 +08:00
|
|
|
|
size = a->ob_size * n;
|
2000-09-09 14:13:41 +08:00
|
|
|
|
if (n && size / n != a->ob_size) {
|
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
|
|
|
"repeated string is too long");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2001-09-12 10:18:30 +08:00
|
|
|
|
if (size == a->ob_size && PyString_CheckExact(a)) {
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_INCREF(a);
|
|
|
|
|
return (PyObject *)a;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
2004-06-28 01:24:49 +08:00
|
|
|
|
nbytes = (size_t)size;
|
|
|
|
|
if (nbytes + sizeof(PyStringObject) <= nbytes) {
|
2000-09-09 14:13:41 +08:00
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
|
|
|
"repeated string is too long");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
op = (PyStringObject *)
|
2002-04-12 11:05:19 +08:00
|
|
|
|
PyObject_MALLOC(sizeof(PyStringObject) + nbytes);
|
1990-10-22 06:15:08 +08:00
|
|
|
|
if (op == NULL)
|
1997-05-02 11:12:38 +08:00
|
|
|
|
return PyErr_NoMemory();
|
2000-05-04 07:44:39 +08:00
|
|
|
|
PyObject_INIT_VAR(op, &PyString_Type, size);
|
1993-10-22 20:04:32 +08:00
|
|
|
|
op->ob_shash = -1;
|
2002-08-20 05:43:18 +08:00
|
|
|
|
op->ob_sstate = SSTATE_NOT_INTERNED;
|
2003-01-07 06:42:41 +08:00
|
|
|
|
op->ob_sval[size] = '\0';
|
|
|
|
|
if (a->ob_size == 1 && n > 0) {
|
|
|
|
|
memset(op->ob_sval, a->ob_sval[0] , n);
|
|
|
|
|
return (PyObject *) op;
|
|
|
|
|
}
|
2003-01-06 18:33:56 +08:00
|
|
|
|
i = 0;
|
|
|
|
|
if (i < size) {
|
|
|
|
|
memcpy(op->ob_sval, a->ob_sval, (int) a->ob_size);
|
|
|
|
|
i = (int) a->ob_size;
|
|
|
|
|
}
|
|
|
|
|
while (i < size) {
|
|
|
|
|
j = (i <= size-i) ? i : size-i;
|
|
|
|
|
memcpy(op->ob_sval+i, op->ob_sval, j);
|
|
|
|
|
i += j;
|
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
return (PyObject *) op;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* String slice a[i:j] consists of characters a[i] ... a[j-1] */
|
|
|
|
|
|
1997-05-02 11:12:38 +08:00
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_slice(register PyStringObject *a, register int i, register int j)
|
|
|
|
|
/* j -- may be negative! */
|
1990-10-14 20:07:46 +08:00
|
|
|
|
{
|
|
|
|
|
if (i < 0)
|
|
|
|
|
i = 0;
|
|
|
|
|
if (j < 0)
|
|
|
|
|
j = 0; /* Avoid signed/unsigned bug in next line */
|
|
|
|
|
if (j > a->ob_size)
|
|
|
|
|
j = a->ob_size;
|
2001-09-12 10:18:30 +08:00
|
|
|
|
if (i == 0 && j == a->ob_size && PyString_CheckExact(a)) {
|
|
|
|
|
/* It's the same as a */
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_INCREF(a);
|
|
|
|
|
return (PyObject *)a;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
|
|
|
|
if (j < i)
|
|
|
|
|
j = i;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
return PyString_FromStringAndSize(a->ob_sval + i, (int) (j-i));
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
|
|
|
|
|
2000-03-07 23:53:43 +08:00
|
|
|
|
static int
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_contains(PyObject *a, PyObject *el)
|
2000-03-07 23:53:43 +08:00
|
|
|
|
{
|
2002-08-07 00:58:21 +08:00
|
|
|
|
const char *lhs, *rhs, *end;
|
|
|
|
|
int size;
|
2002-08-24 14:57:49 +08:00
|
|
|
|
|
|
|
|
|
if (!PyString_CheckExact(el)) {
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2002-08-24 14:57:49 +08:00
|
|
|
|
if (PyUnicode_Check(el))
|
|
|
|
|
return PyUnicode_Contains(a, el);
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2002-08-24 14:57:49 +08:00
|
|
|
|
if (!PyString_Check(el)) {
|
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
|
"'in <string>' requires string as left operand");
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2000-03-07 23:53:43 +08:00
|
|
|
|
}
|
2002-08-24 14:57:49 +08:00
|
|
|
|
size = PyString_GET_SIZE(el);
|
2002-08-07 00:58:21 +08:00
|
|
|
|
rhs = PyString_AS_STRING(el);
|
|
|
|
|
lhs = PyString_AS_STRING(a);
|
|
|
|
|
|
|
|
|
|
/* optimize for a single character */
|
|
|
|
|
if (size == 1)
|
2002-08-24 14:57:49 +08:00
|
|
|
|
return memchr(lhs, *rhs, PyString_GET_SIZE(a)) != NULL;
|
2002-08-07 00:58:21 +08:00
|
|
|
|
|
2002-08-24 14:57:49 +08:00
|
|
|
|
end = lhs + (PyString_GET_SIZE(a) - size);
|
2002-08-07 00:58:21 +08:00
|
|
|
|
while (lhs <= end) {
|
|
|
|
|
if (memcmp(lhs++, rhs, size) == 0)
|
2000-03-07 23:53:43 +08:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
2002-08-07 00:58:21 +08:00
|
|
|
|
|
2000-03-07 23:53:43 +08:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
1997-05-02 11:12:38 +08:00
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_item(PyStringObject *a, register int i)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
{
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyObject *v;
|
2001-05-09 06:33:50 +08:00
|
|
|
|
char *pchar;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
if (i < 0 || i >= a->ob_size) {
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyErr_SetString(PyExc_IndexError, "string index out of range");
|
1990-10-14 20:07:46 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2001-05-09 06:33:50 +08:00
|
|
|
|
pchar = a->ob_sval + i;
|
2001-05-09 08:24:55 +08:00
|
|
|
|
v = (PyObject *)characters[*pchar & UCHAR_MAX];
|
2001-05-09 06:33:50 +08:00
|
|
|
|
if (v == NULL)
|
|
|
|
|
v = PyString_FromStringAndSize(pchar, 1);
|
2001-05-09 08:31:40 +08:00
|
|
|
|
else {
|
|
|
|
|
#ifdef COUNT_ALLOCS
|
|
|
|
|
one_strings++;
|
|
|
|
|
#endif
|
2001-05-09 08:24:55 +08:00
|
|
|
|
Py_INCREF(v);
|
2001-05-09 08:31:40 +08:00
|
|
|
|
}
|
1991-04-04 18:48:33 +08:00
|
|
|
|
return v;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
|
|
|
|
|
2001-05-25 00:56:35 +08:00
|
|
|
|
static PyObject*
|
|
|
|
|
string_richcompare(PyStringObject *a, PyStringObject *b, int op)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
{
|
2001-05-25 00:56:35 +08:00
|
|
|
|
int c;
|
|
|
|
|
int len_a, len_b;
|
|
|
|
|
int min_len;
|
|
|
|
|
PyObject *result;
|
|
|
|
|
|
2001-09-28 04:30:07 +08:00
|
|
|
|
/* Make sure both arguments are strings. */
|
|
|
|
|
if (!(PyString_Check(a) && PyString_Check(b))) {
|
2001-05-25 00:56:35 +08:00
|
|
|
|
result = Py_NotImplemented;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
if (a == b) {
|
|
|
|
|
switch (op) {
|
|
|
|
|
case Py_EQ:case Py_LE:case Py_GE:
|
|
|
|
|
result = Py_True;
|
|
|
|
|
goto out;
|
|
|
|
|
case Py_NE:case Py_LT:case Py_GT:
|
|
|
|
|
result = Py_False;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
1993-10-22 20:04:32 +08:00
|
|
|
|
}
|
2001-05-25 00:56:35 +08:00
|
|
|
|
if (op == Py_EQ) {
|
|
|
|
|
/* Supporting Py_NE here as well does not save
|
|
|
|
|
much time, since Py_NE is rarely used. */
|
|
|
|
|
if (a->ob_size == b->ob_size
|
|
|
|
|
&& (a->ob_sval[0] == b->ob_sval[0]
|
2002-04-15 21:48:52 +08:00
|
|
|
|
&& memcmp(a->ob_sval, b->ob_sval,
|
2001-05-25 00:56:35 +08:00
|
|
|
|
a->ob_size) == 0)) {
|
|
|
|
|
result = Py_True;
|
|
|
|
|
} else {
|
|
|
|
|
result = Py_False;
|
|
|
|
|
}
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
len_a = a->ob_size; len_b = b->ob_size;
|
|
|
|
|
min_len = (len_a < len_b) ? len_a : len_b;
|
|
|
|
|
if (min_len > 0) {
|
|
|
|
|
c = Py_CHARMASK(*a->ob_sval) - Py_CHARMASK(*b->ob_sval);
|
|
|
|
|
if (c==0)
|
|
|
|
|
c = memcmp(a->ob_sval, b->ob_sval, min_len);
|
|
|
|
|
}else
|
|
|
|
|
c = 0;
|
|
|
|
|
if (c == 0)
|
|
|
|
|
c = (len_a < len_b) ? -1 : (len_a > len_b) ? 1 : 0;
|
|
|
|
|
switch (op) {
|
|
|
|
|
case Py_LT: c = c < 0; break;
|
|
|
|
|
case Py_LE: c = c <= 0; break;
|
|
|
|
|
case Py_EQ: assert(0); break; /* unreachable */
|
|
|
|
|
case Py_NE: c = c != 0; break;
|
|
|
|
|
case Py_GT: c = c > 0; break;
|
|
|
|
|
case Py_GE: c = c >= 0; break;
|
|
|
|
|
default:
|
|
|
|
|
result = Py_NotImplemented;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
result = c ? Py_True : Py_False;
|
|
|
|
|
out:
|
|
|
|
|
Py_INCREF(result);
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
_PyString_Eq(PyObject *o1, PyObject *o2)
|
|
|
|
|
{
|
|
|
|
|
PyStringObject *a, *b;
|
|
|
|
|
a = (PyStringObject*)o1;
|
|
|
|
|
b = (PyStringObject*)o2;
|
|
|
|
|
return a->ob_size == b->ob_size
|
|
|
|
|
&& *a->ob_sval == *b->ob_sval
|
|
|
|
|
&& memcmp(a->ob_sval, b->ob_sval, a->ob_size) == 0;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
|
|
|
|
|
1993-03-29 18:43:31 +08:00
|
|
|
|
static long
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_hash(PyStringObject *a)
|
1993-03-29 18:43:31 +08:00
|
|
|
|
{
|
1993-10-22 20:04:32 +08:00
|
|
|
|
register int len;
|
|
|
|
|
register unsigned char *p;
|
|
|
|
|
register long x;
|
|
|
|
|
|
|
|
|
|
if (a->ob_shash != -1)
|
|
|
|
|
return a->ob_shash;
|
|
|
|
|
len = a->ob_size;
|
|
|
|
|
p = (unsigned char *) a->ob_sval;
|
|
|
|
|
x = *p << 7;
|
1993-03-29 18:43:31 +08:00
|
|
|
|
while (--len >= 0)
|
1996-09-12 04:22:48 +08:00
|
|
|
|
x = (1000003*x) ^ *p++;
|
1993-03-29 18:43:31 +08:00
|
|
|
|
x ^= a->ob_size;
|
|
|
|
|
if (x == -1)
|
|
|
|
|
x = -2;
|
1993-10-22 20:04:32 +08:00
|
|
|
|
a->ob_shash = x;
|
1993-03-29 18:43:31 +08:00
|
|
|
|
return x;
|
|
|
|
|
}
|
|
|
|
|
|
2002-06-11 18:55:12 +08:00
|
|
|
|
static PyObject*
|
|
|
|
|
string_subscript(PyStringObject* self, PyObject* item)
|
|
|
|
|
{
|
|
|
|
|
if (PyInt_Check(item)) {
|
|
|
|
|
long i = PyInt_AS_LONG(item);
|
|
|
|
|
if (i < 0)
|
|
|
|
|
i += PyString_GET_SIZE(self);
|
|
|
|
|
return string_item(self,i);
|
|
|
|
|
}
|
|
|
|
|
else if (PyLong_Check(item)) {
|
|
|
|
|
long i = PyLong_AsLong(item);
|
|
|
|
|
if (i == -1 && PyErr_Occurred())
|
|
|
|
|
return NULL;
|
|
|
|
|
if (i < 0)
|
|
|
|
|
i += PyString_GET_SIZE(self);
|
|
|
|
|
return string_item(self,i);
|
|
|
|
|
}
|
|
|
|
|
else if (PySlice_Check(item)) {
|
|
|
|
|
int start, stop, step, slicelength, cur, i;
|
|
|
|
|
char* source_buf;
|
|
|
|
|
char* result_buf;
|
|
|
|
|
PyObject* result;
|
|
|
|
|
|
|
|
|
|
if (PySlice_GetIndicesEx((PySliceObject*)item,
|
|
|
|
|
PyString_GET_SIZE(self),
|
|
|
|
|
&start, &stop, &step, &slicelength) < 0) {
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (slicelength <= 0) {
|
|
|
|
|
return PyString_FromStringAndSize("", 0);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
source_buf = PyString_AsString((PyObject*)self);
|
|
|
|
|
result_buf = PyMem_Malloc(slicelength);
|
|
|
|
|
|
|
|
|
|
for (cur = start, i = 0; i < slicelength;
|
|
|
|
|
cur += step, i++) {
|
|
|
|
|
result_buf[i] = source_buf[cur];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
result = PyString_FromStringAndSize(result_buf,
|
|
|
|
|
slicelength);
|
|
|
|
|
PyMem_Free(result_buf);
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
|
"string indices must be integers");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1997-05-06 06:15:02 +08:00
|
|
|
|
static int
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_buffer_getreadbuf(PyStringObject *self, int index, const void **ptr)
|
1997-05-06 06:15:02 +08:00
|
|
|
|
{
|
|
|
|
|
if ( index != 0 ) {
|
1997-09-09 02:30:11 +08:00
|
|
|
|
PyErr_SetString(PyExc_SystemError,
|
1998-10-08 10:18:52 +08:00
|
|
|
|
"accessing non-existent string segment");
|
1997-05-06 06:15:02 +08:00
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
*ptr = (void *)self->ob_sval;
|
|
|
|
|
return self->ob_size;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_buffer_getwritebuf(PyStringObject *self, int index, const void **ptr)
|
1997-05-06 06:15:02 +08:00
|
|
|
|
{
|
1997-09-09 02:30:11 +08:00
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
1998-10-01 23:59:48 +08:00
|
|
|
|
"Cannot use string as modifiable buffer");
|
1997-05-06 06:15:02 +08:00
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_buffer_getsegcount(PyStringObject *self, int *lenp)
|
1997-05-06 06:15:02 +08:00
|
|
|
|
{
|
|
|
|
|
if ( lenp )
|
|
|
|
|
*lenp = self->ob_size;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
1998-10-08 10:18:52 +08:00
|
|
|
|
static int
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_buffer_getcharbuf(PyStringObject *self, int index, const char **ptr)
|
1998-10-08 10:18:52 +08:00
|
|
|
|
{
|
|
|
|
|
if ( index != 0 ) {
|
|
|
|
|
PyErr_SetString(PyExc_SystemError,
|
|
|
|
|
"accessing non-existent string segment");
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
*ptr = self->ob_sval;
|
|
|
|
|
return self->ob_size;
|
|
|
|
|
}
|
|
|
|
|
|
1997-05-02 11:12:38 +08:00
|
|
|
|
static PySequenceMethods string_as_sequence = {
|
1994-08-30 16:19:36 +08:00
|
|
|
|
(inquiry)string_length, /*sq_length*/
|
|
|
|
|
(binaryfunc)string_concat, /*sq_concat*/
|
|
|
|
|
(intargfunc)string_repeat, /*sq_repeat*/
|
|
|
|
|
(intargfunc)string_item, /*sq_item*/
|
|
|
|
|
(intintargfunc)string_slice, /*sq_slice*/
|
1991-06-05 04:36:32 +09:00
|
|
|
|
0, /*sq_ass_item*/
|
|
|
|
|
0, /*sq_ass_slice*/
|
2000-03-07 23:53:43 +08:00
|
|
|
|
(objobjproc)string_contains /*sq_contains*/
|
1990-10-14 20:07:46 +08:00
|
|
|
|
};
|
|
|
|
|
|
2002-06-11 18:55:12 +08:00
|
|
|
|
static PyMappingMethods string_as_mapping = {
|
|
|
|
|
(inquiry)string_length,
|
|
|
|
|
(binaryfunc)string_subscript,
|
|
|
|
|
0,
|
|
|
|
|
};
|
|
|
|
|
|
1997-05-06 06:15:02 +08:00
|
|
|
|
static PyBufferProcs string_as_buffer = {
|
|
|
|
|
(getreadbufferproc)string_buffer_getreadbuf,
|
|
|
|
|
(getwritebufferproc)string_buffer_getwritebuf,
|
|
|
|
|
(getsegcountproc)string_buffer_getsegcount,
|
1998-10-08 10:18:52 +08:00
|
|
|
|
(getcharbufferproc)string_buffer_getcharbuf,
|
1997-05-06 06:15:02 +08:00
|
|
|
|
};
|
|
|
|
|
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define LEFTSTRIP 0
|
|
|
|
|
#define RIGHTSTRIP 1
|
|
|
|
|
#define BOTHSTRIP 2
|
|
|
|
|
|
2002-04-13 08:56:08 +08:00
|
|
|
|
/* Arrays indexed by above */
|
2002-04-23 01:42:37 +08:00
|
|
|
|
static const char *stripformat[] = {"|O:lstrip", "|O:rstrip", "|O:strip"};
|
|
|
|
|
|
|
|
|
|
#define STRIPNAME(i) (stripformat[i]+3)
|
2002-04-13 08:56:08 +08:00
|
|
|
|
|
2004-01-05 08:29:51 +08:00
|
|
|
|
#define SPLIT_APPEND(data, left, right) \
|
|
|
|
|
str = PyString_FromStringAndSize((data) + (left), \
|
|
|
|
|
(right) - (left)); \
|
|
|
|
|
if (str == NULL) \
|
|
|
|
|
goto onError; \
|
|
|
|
|
if (PyList_Append(list, str)) { \
|
|
|
|
|
Py_DECREF(str); \
|
|
|
|
|
goto onError; \
|
|
|
|
|
} \
|
|
|
|
|
else \
|
|
|
|
|
Py_DECREF(str);
|
|
|
|
|
|
|
|
|
|
#define SPLIT_INSERT(data, left, right) \
|
|
|
|
|
str = PyString_FromStringAndSize((data) + (left), \
|
|
|
|
|
(right) - (left)); \
|
|
|
|
|
if (str == NULL) \
|
|
|
|
|
goto onError; \
|
|
|
|
|
if (PyList_Insert(list, 0, str)) { \
|
|
|
|
|
Py_DECREF(str); \
|
|
|
|
|
goto onError; \
|
|
|
|
|
} \
|
|
|
|
|
else \
|
|
|
|
|
Py_DECREF(str);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2000-07-09 16:02:21 +08:00
|
|
|
|
split_whitespace(const char *s, int len, int maxsplit)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2004-01-05 08:29:51 +08:00
|
|
|
|
int i, j;
|
|
|
|
|
PyObject *str;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
PyObject *list = PyList_New(0);
|
|
|
|
|
|
|
|
|
|
if (list == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2000-03-11 06:55:18 +08:00
|
|
|
|
for (i = j = 0; i < len; ) {
|
|
|
|
|
while (i < len && isspace(Py_CHARMASK(s[i])))
|
|
|
|
|
i++;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
j = i;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
while (i < len && !isspace(Py_CHARMASK(s[i])))
|
|
|
|
|
i++;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
if (j < i) {
|
2000-03-11 06:55:18 +08:00
|
|
|
|
if (maxsplit-- <= 0)
|
|
|
|
|
break;
|
2004-01-05 08:29:51 +08:00
|
|
|
|
SPLIT_APPEND(s, j, i);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
while (i < len && isspace(Py_CHARMASK(s[i])))
|
|
|
|
|
i++;
|
|
|
|
|
j = i;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
2000-03-11 06:55:18 +08:00
|
|
|
|
if (j < len) {
|
2004-01-05 08:29:51 +08:00
|
|
|
|
SPLIT_APPEND(s, j, len);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
}
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return list;
|
2004-01-05 08:29:51 +08:00
|
|
|
|
onError:
|
1999-10-13 03:54:53 +08:00
|
|
|
|
Py_DECREF(list);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2004-01-05 08:29:51 +08:00
|
|
|
|
static PyObject *
|
|
|
|
|
split_char(const char *s, int len, char ch, int maxcount)
|
|
|
|
|
{
|
|
|
|
|
register int i, j;
|
|
|
|
|
PyObject *str;
|
|
|
|
|
PyObject *list = PyList_New(0);
|
|
|
|
|
|
|
|
|
|
if (list == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
for (i = j = 0; i < len; ) {
|
|
|
|
|
if (s[i] == ch) {
|
|
|
|
|
if (maxcount-- <= 0)
|
|
|
|
|
break;
|
|
|
|
|
SPLIT_APPEND(s, j, i);
|
|
|
|
|
i = j = i + 1;
|
|
|
|
|
} else
|
|
|
|
|
i++;
|
|
|
|
|
}
|
|
|
|
|
if (j <= len) {
|
|
|
|
|
SPLIT_APPEND(s, j, len);
|
|
|
|
|
}
|
|
|
|
|
return list;
|
|
|
|
|
|
|
|
|
|
onError:
|
|
|
|
|
Py_DECREF(list);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(split__doc__,
|
1999-10-13 03:54:53 +08:00
|
|
|
|
"S.split([sep [,maxsplit]]) -> list of strings\n\
|
|
|
|
|
\n\
|
|
|
|
|
Return a list of the words in the string S, using sep as the\n\
|
2000-03-11 06:55:18 +08:00
|
|
|
|
delimiter string. If maxsplit is given, at most maxsplit\n\
|
2002-08-05 14:28:21 +08:00
|
|
|
|
splits are done. If sep is not specified or is None, any\n\
|
|
|
|
|
whitespace string is a separator.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_split(PyStringObject *self, PyObject *args)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
|
|
|
|
int len = PyString_GET_SIZE(self), n, i, j, err;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
int maxsplit = -1;
|
|
|
|
|
const char *s = PyString_AS_STRING(self), *sub;
|
|
|
|
|
PyObject *list, *item, *subobj = Py_None;
|
|
|
|
|
|
|
|
|
|
if (!PyArg_ParseTuple(args, "|Oi:split", &subobj, &maxsplit))
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return NULL;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
if (maxsplit < 0)
|
|
|
|
|
maxsplit = INT_MAX;
|
|
|
|
|
if (subobj == Py_None)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return split_whitespace(s, len, maxsplit);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
if (PyString_Check(subobj)) {
|
|
|
|
|
sub = PyString_AS_STRING(subobj);
|
|
|
|
|
n = PyString_GET_SIZE(subobj);
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyUnicode_Check(subobj))
|
|
|
|
|
return PyUnicode_Split((PyObject *)self, subobj, maxsplit);
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyObject_AsCharBuffer(subobj, &sub, &n))
|
|
|
|
|
return NULL;
|
2004-01-05 08:29:51 +08:00
|
|
|
|
|
1999-10-13 03:54:53 +08:00
|
|
|
|
if (n == 0) {
|
|
|
|
|
PyErr_SetString(PyExc_ValueError, "empty separator");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2004-01-05 08:29:51 +08:00
|
|
|
|
else if (n == 1)
|
|
|
|
|
return split_char(s, len, sub[0], maxsplit);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
list = PyList_New(0);
|
|
|
|
|
if (list == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
i = j = 0;
|
|
|
|
|
while (i+n <= len) {
|
2000-06-20 23:47:54 +08:00
|
|
|
|
if (s[i] == sub[0] && memcmp(s+i, sub, n) == 0) {
|
2000-03-11 06:55:18 +08:00
|
|
|
|
if (maxsplit-- <= 0)
|
|
|
|
|
break;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
item = PyString_FromStringAndSize(s+j, (int)(i-j));
|
|
|
|
|
if (item == NULL)
|
|
|
|
|
goto fail;
|
|
|
|
|
err = PyList_Append(list, item);
|
|
|
|
|
Py_DECREF(item);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
goto fail;
|
|
|
|
|
i = j = i + n;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
i++;
|
|
|
|
|
}
|
|
|
|
|
item = PyString_FromStringAndSize(s+j, (int)(len-j));
|
|
|
|
|
if (item == NULL)
|
|
|
|
|
goto fail;
|
|
|
|
|
err = PyList_Append(list, item);
|
|
|
|
|
Py_DECREF(item);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
|
|
return list;
|
|
|
|
|
|
|
|
|
|
fail:
|
|
|
|
|
Py_DECREF(list);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2003-12-16 02:49:53 +08:00
|
|
|
|
static PyObject *
|
|
|
|
|
rsplit_whitespace(const char *s, int len, int maxsplit)
|
|
|
|
|
{
|
2004-01-05 08:29:51 +08:00
|
|
|
|
int i, j;
|
|
|
|
|
PyObject *str;
|
2003-12-16 02:49:53 +08:00
|
|
|
|
PyObject *list = PyList_New(0);
|
|
|
|
|
|
|
|
|
|
if (list == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
for (i = j = len - 1; i >= 0; ) {
|
|
|
|
|
while (i >= 0 && isspace(Py_CHARMASK(s[i])))
|
|
|
|
|
i--;
|
|
|
|
|
j = i;
|
|
|
|
|
while (i >= 0 && !isspace(Py_CHARMASK(s[i])))
|
|
|
|
|
i--;
|
|
|
|
|
if (j > i) {
|
|
|
|
|
if (maxsplit-- <= 0)
|
|
|
|
|
break;
|
2004-01-05 08:29:51 +08:00
|
|
|
|
SPLIT_INSERT(s, i + 1, j + 1);
|
2003-12-16 02:49:53 +08:00
|
|
|
|
while (i >= 0 && isspace(Py_CHARMASK(s[i])))
|
|
|
|
|
i--;
|
|
|
|
|
j = i;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (j >= 0) {
|
2004-01-05 08:29:51 +08:00
|
|
|
|
SPLIT_INSERT(s, 0, j + 1);
|
2003-12-16 02:49:53 +08:00
|
|
|
|
}
|
|
|
|
|
return list;
|
2004-01-05 08:29:51 +08:00
|
|
|
|
onError:
|
2003-12-16 02:49:53 +08:00
|
|
|
|
Py_DECREF(list);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2004-01-05 08:29:51 +08:00
|
|
|
|
static PyObject *
|
|
|
|
|
rsplit_char(const char *s, int len, char ch, int maxcount)
|
|
|
|
|
{
|
|
|
|
|
register int i, j;
|
|
|
|
|
PyObject *str;
|
|
|
|
|
PyObject *list = PyList_New(0);
|
|
|
|
|
|
|
|
|
|
if (list == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
for (i = j = len - 1; i >= 0; ) {
|
|
|
|
|
if (s[i] == ch) {
|
|
|
|
|
if (maxcount-- <= 0)
|
|
|
|
|
break;
|
|
|
|
|
SPLIT_INSERT(s, i + 1, j + 1);
|
|
|
|
|
j = i = i - 1;
|
|
|
|
|
} else
|
|
|
|
|
i--;
|
|
|
|
|
}
|
|
|
|
|
if (j >= -1) {
|
|
|
|
|
SPLIT_INSERT(s, 0, j + 1);
|
|
|
|
|
}
|
|
|
|
|
return list;
|
|
|
|
|
|
|
|
|
|
onError:
|
|
|
|
|
Py_DECREF(list);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2003-12-16 02:49:53 +08:00
|
|
|
|
|
|
|
|
|
PyDoc_STRVAR(rsplit__doc__,
|
|
|
|
|
"S.rsplit([sep [,maxsplit]]) -> list of strings\n\
|
|
|
|
|
\n\
|
|
|
|
|
Return a list of the words in the string S, using sep as the\n\
|
|
|
|
|
delimiter string, starting at the end of the string and working\n\
|
|
|
|
|
to the front. If maxsplit is given, at most maxsplit splits are\n\
|
|
|
|
|
done. If sep is not specified or is None, any whitespace string\n\
|
|
|
|
|
is a separator.");
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
|
string_rsplit(PyStringObject *self, PyObject *args)
|
|
|
|
|
{
|
|
|
|
|
int len = PyString_GET_SIZE(self), n, i, j, err;
|
|
|
|
|
int maxsplit = -1;
|
|
|
|
|
const char *s = PyString_AS_STRING(self), *sub;
|
|
|
|
|
PyObject *list, *item, *subobj = Py_None;
|
|
|
|
|
|
|
|
|
|
if (!PyArg_ParseTuple(args, "|Oi:rsplit", &subobj, &maxsplit))
|
|
|
|
|
return NULL;
|
|
|
|
|
if (maxsplit < 0)
|
|
|
|
|
maxsplit = INT_MAX;
|
|
|
|
|
if (subobj == Py_None)
|
|
|
|
|
return rsplit_whitespace(s, len, maxsplit);
|
|
|
|
|
if (PyString_Check(subobj)) {
|
|
|
|
|
sub = PyString_AS_STRING(subobj);
|
|
|
|
|
n = PyString_GET_SIZE(subobj);
|
|
|
|
|
}
|
|
|
|
|
#ifdef Py_USING_UNICODE
|
|
|
|
|
else if (PyUnicode_Check(subobj))
|
|
|
|
|
return PyUnicode_RSplit((PyObject *)self, subobj, maxsplit);
|
|
|
|
|
#endif
|
|
|
|
|
else if (PyObject_AsCharBuffer(subobj, &sub, &n))
|
|
|
|
|
return NULL;
|
2004-01-05 08:29:51 +08:00
|
|
|
|
|
2003-12-16 02:49:53 +08:00
|
|
|
|
if (n == 0) {
|
|
|
|
|
PyErr_SetString(PyExc_ValueError, "empty separator");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2004-01-05 08:29:51 +08:00
|
|
|
|
else if (n == 1)
|
|
|
|
|
return rsplit_char(s, len, sub[0], maxsplit);
|
2003-12-16 02:49:53 +08:00
|
|
|
|
|
|
|
|
|
list = PyList_New(0);
|
|
|
|
|
if (list == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
j = len;
|
|
|
|
|
i = j - n;
|
|
|
|
|
while (i >= 0) {
|
|
|
|
|
if (s[i] == sub[0] && memcmp(s+i, sub, n) == 0) {
|
|
|
|
|
if (maxsplit-- <= 0)
|
|
|
|
|
break;
|
|
|
|
|
item = PyString_FromStringAndSize(s+i+n, (int)(j-i-n));
|
|
|
|
|
if (item == NULL)
|
|
|
|
|
goto fail;
|
|
|
|
|
err = PyList_Insert(list, 0, item);
|
|
|
|
|
Py_DECREF(item);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
goto fail;
|
|
|
|
|
j = i;
|
|
|
|
|
i -= n;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
i--;
|
|
|
|
|
}
|
|
|
|
|
item = PyString_FromStringAndSize(s, j);
|
|
|
|
|
if (item == NULL)
|
|
|
|
|
goto fail;
|
|
|
|
|
err = PyList_Insert(list, 0, item);
|
|
|
|
|
Py_DECREF(item);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
|
|
return list;
|
|
|
|
|
|
|
|
|
|
fail:
|
|
|
|
|
Py_DECREF(list);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(join__doc__,
|
1999-10-13 03:54:53 +08:00
|
|
|
|
"S.join(sequence) -> string\n\
|
|
|
|
|
\n\
|
2000-03-11 06:55:18 +08:00
|
|
|
|
Return a string which is the concatenation of the strings in the\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
sequence. The separator between elements is S.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2001-08-16 21:15:00 +08:00
|
|
|
|
string_join(PyStringObject *self, PyObject *orig)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
|
|
|
|
char *sep = PyString_AS_STRING(self);
|
2001-01-19 11:03:47 +08:00
|
|
|
|
const int seplen = PyString_GET_SIZE(self);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
PyObject *res = NULL;
|
|
|
|
|
char *p;
|
|
|
|
|
int seqlen = 0;
|
2001-01-19 11:03:47 +08:00
|
|
|
|
size_t sz = 0;
|
|
|
|
|
int i;
|
2001-08-16 21:15:00 +08:00
|
|
|
|
PyObject *seq, *item;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2001-01-19 11:03:47 +08:00
|
|
|
|
seq = PySequence_Fast(orig, "");
|
|
|
|
|
if (seq == NULL) {
|
2000-07-11 05:30:28 +08:00
|
|
|
|
if (PyErr_ExceptionMatches(PyExc_TypeError))
|
|
|
|
|
PyErr_Format(PyExc_TypeError,
|
|
|
|
|
"sequence expected, %.80s found",
|
|
|
|
|
orig->ob_type->tp_name);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return NULL;
|
2000-07-11 05:30:28 +08:00
|
|
|
|
}
|
2001-01-19 11:03:47 +08:00
|
|
|
|
|
2000-07-12 21:05:33 +08:00
|
|
|
|
seqlen = PySequence_Size(seq);
|
2001-01-19 11:03:47 +08:00
|
|
|
|
if (seqlen == 0) {
|
|
|
|
|
Py_DECREF(seq);
|
|
|
|
|
return PyString_FromString("");
|
|
|
|
|
}
|
1999-10-13 03:54:53 +08:00
|
|
|
|
if (seqlen == 1) {
|
2000-07-11 05:30:28 +08:00
|
|
|
|
item = PySequence_Fast_GET_ITEM(seq, 0);
|
2004-08-24 07:23:54 +08:00
|
|
|
|
if (PyString_CheckExact(item) || PyUnicode_CheckExact(item)) {
|
|
|
|
|
Py_INCREF(item);
|
2001-01-19 11:03:47 +08:00
|
|
|
|
Py_DECREF(seq);
|
2004-08-24 07:23:54 +08:00
|
|
|
|
return item;
|
2001-01-19 11:03:47 +08:00
|
|
|
|
}
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
2000-07-11 05:30:28 +08:00
|
|
|
|
|
2004-08-24 07:23:54 +08:00
|
|
|
|
/* There are at least two things to join, or else we have a subclass
|
|
|
|
|
* of the builtin types in the sequence.
|
|
|
|
|
* Do a pre-pass to figure out the total amount of space we'll
|
|
|
|
|
* need (sz), see whether any argument is absurd, and defer to
|
|
|
|
|
* the Unicode join if appropriate.
|
2001-01-19 11:03:47 +08:00
|
|
|
|
*/
|
2000-07-11 05:30:28 +08:00
|
|
|
|
for (i = 0; i < seqlen; i++) {
|
2001-01-19 11:03:47 +08:00
|
|
|
|
const size_t old_sz = sz;
|
2000-07-11 05:30:28 +08:00
|
|
|
|
item = PySequence_Fast_GET_ITEM(seq, i);
|
|
|
|
|
if (!PyString_Check(item)){
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-07-11 05:30:28 +08:00
|
|
|
|
if (PyUnicode_Check(item)) {
|
2001-05-05 13:36:48 +08:00
|
|
|
|
/* Defer to Unicode join.
|
|
|
|
|
* CAUTION: There's no gurantee that the
|
|
|
|
|
* original sequence can be iterated over
|
|
|
|
|
* again, so we must pass seq here.
|
|
|
|
|
*/
|
|
|
|
|
PyObject *result;
|
|
|
|
|
result = PyUnicode_Join((PyObject *)self, seq);
|
2000-07-11 12:58:12 +08:00
|
|
|
|
Py_DECREF(seq);
|
2001-05-05 13:36:48 +08:00
|
|
|
|
return result;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2000-07-11 05:30:28 +08:00
|
|
|
|
PyErr_Format(PyExc_TypeError,
|
2000-07-12 04:55:38 +08:00
|
|
|
|
"sequence item %i: expected string,"
|
|
|
|
|
" %.80s found",
|
2000-07-11 05:30:28 +08:00
|
|
|
|
i, item->ob_type->tp_name);
|
2001-01-19 11:03:47 +08:00
|
|
|
|
Py_DECREF(seq);
|
|
|
|
|
return NULL;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
2001-01-19 11:03:47 +08:00
|
|
|
|
sz += PyString_GET_SIZE(item);
|
|
|
|
|
if (i != 0)
|
|
|
|
|
sz += seplen;
|
|
|
|
|
if (sz < old_sz || sz > INT_MAX) {
|
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
|
|
|
"join() is too long for a Python string");
|
|
|
|
|
Py_DECREF(seq);
|
|
|
|
|
return NULL;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
2001-01-19 11:03:47 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Allocate result space. */
|
|
|
|
|
res = PyString_FromStringAndSize((char*)NULL, (int)sz);
|
|
|
|
|
if (res == NULL) {
|
|
|
|
|
Py_DECREF(seq);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Catenate everything. */
|
|
|
|
|
p = PyString_AS_STRING(res);
|
|
|
|
|
for (i = 0; i < seqlen; ++i) {
|
|
|
|
|
size_t n;
|
|
|
|
|
item = PySequence_Fast_GET_ITEM(seq, i);
|
|
|
|
|
n = PyString_GET_SIZE(item);
|
|
|
|
|
memcpy(p, PyString_AS_STRING(item), n);
|
|
|
|
|
p += n;
|
|
|
|
|
if (i < seqlen - 1) {
|
2000-07-11 05:30:28 +08:00
|
|
|
|
memcpy(p, sep, seplen);
|
|
|
|
|
p += seplen;
|
|
|
|
|
}
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
|
|
|
|
|
2000-07-11 11:28:17 +08:00
|
|
|
|
Py_DECREF(seq);
|
2001-01-19 11:03:47 +08:00
|
|
|
|
return res;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
|
|
|
|
|
2001-06-16 13:42:57 +08:00
|
|
|
|
PyObject *
|
|
|
|
|
_PyString_Join(PyObject *sep, PyObject *x)
|
2001-06-16 13:11:17 +08:00
|
|
|
|
{
|
|
|
|
|
assert(sep != NULL && PyString_Check(sep));
|
|
|
|
|
assert(x != NULL);
|
2001-08-16 21:15:00 +08:00
|
|
|
|
return string_join((PyStringObject *)sep, x);
|
2001-06-16 13:11:17 +08:00
|
|
|
|
}
|
|
|
|
|
|
2002-06-14 08:50:42 +08:00
|
|
|
|
static void
|
|
|
|
|
string_adjust_indices(int *start, int *end, int len)
|
|
|
|
|
{
|
|
|
|
|
if (*end > len)
|
|
|
|
|
*end = len;
|
|
|
|
|
else if (*end < 0)
|
|
|
|
|
*end += len;
|
|
|
|
|
if (*end < 0)
|
|
|
|
|
*end = 0;
|
|
|
|
|
if (*start < 0)
|
|
|
|
|
*start += len;
|
|
|
|
|
if (*start < 0)
|
|
|
|
|
*start = 0;
|
|
|
|
|
}
|
|
|
|
|
|
1999-10-13 03:54:53 +08:00
|
|
|
|
static long
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_find_internal(PyStringObject *self, PyObject *args, int dir)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2000-03-11 06:55:18 +08:00
|
|
|
|
const char *s = PyString_AS_STRING(self), *sub;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
int len = PyString_GET_SIZE(self);
|
|
|
|
|
int n, i = 0, last = INT_MAX;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
PyObject *subobj;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2001-04-28 13:38:26 +08:00
|
|
|
|
if (!PyArg_ParseTuple(args, "O|O&O&:find/rfind/index/rindex",
|
2000-05-08 22:08:05 +08:00
|
|
|
|
&subobj, _PyEval_SliceIndex, &i, _PyEval_SliceIndex, &last))
|
2000-03-11 06:55:18 +08:00
|
|
|
|
return -2;
|
|
|
|
|
if (PyString_Check(subobj)) {
|
|
|
|
|
sub = PyString_AS_STRING(subobj);
|
|
|
|
|
n = PyString_GET_SIZE(subobj);
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyUnicode_Check(subobj))
|
2002-08-21 01:29:29 +08:00
|
|
|
|
return PyUnicode_Find((PyObject *)self, subobj, i, last, dir);
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyObject_AsCharBuffer(subobj, &sub, &n))
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return -2;
|
|
|
|
|
|
2002-06-14 08:50:42 +08:00
|
|
|
|
string_adjust_indices(&i, &last, len);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2000-03-11 06:55:18 +08:00
|
|
|
|
if (dir > 0) {
|
|
|
|
|
if (n == 0 && i <= last)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return (long)i;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
last -= n;
|
|
|
|
|
for (; i <= last; ++i)
|
2000-06-20 23:47:54 +08:00
|
|
|
|
if (s[i] == sub[0] && memcmp(&s[i], sub, n) == 0)
|
2000-03-11 06:55:18 +08:00
|
|
|
|
return (long)i;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
int j;
|
2001-04-28 13:38:26 +08:00
|
|
|
|
|
2000-03-11 06:55:18 +08:00
|
|
|
|
if (n == 0 && i <= last)
|
|
|
|
|
return (long)last;
|
|
|
|
|
for (j = last-n; j >= i; --j)
|
2000-06-20 23:47:54 +08:00
|
|
|
|
if (s[j] == sub[0] && memcmp(&s[j], sub, n) == 0)
|
2000-03-11 06:55:18 +08:00
|
|
|
|
return (long)j;
|
|
|
|
|
}
|
2001-04-28 13:38:26 +08:00
|
|
|
|
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(find__doc__,
|
1999-10-13 03:54:53 +08:00
|
|
|
|
"S.find(sub [,start [,end]]) -> int\n\
|
|
|
|
|
\n\
|
|
|
|
|
Return the lowest index in S where substring sub is found,\n\
|
|
|
|
|
such that sub is contained within s[start,end]. Optional\n\
|
|
|
|
|
arguments start and end are interpreted as in slice notation.\n\
|
|
|
|
|
\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
Return -1 on failure.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_find(PyStringObject *self, PyObject *args)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2000-03-11 06:55:18 +08:00
|
|
|
|
long result = string_find_internal(self, args, +1);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
if (result == -2)
|
|
|
|
|
return NULL;
|
|
|
|
|
return PyInt_FromLong(result);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(index__doc__,
|
1999-10-13 03:54:53 +08:00
|
|
|
|
"S.index(sub [,start [,end]]) -> int\n\
|
|
|
|
|
\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
Like S.find() but raise ValueError when the substring is not found.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_index(PyStringObject *self, PyObject *args)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2000-03-11 06:55:18 +08:00
|
|
|
|
long result = string_find_internal(self, args, +1);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
if (result == -2)
|
|
|
|
|
return NULL;
|
|
|
|
|
if (result == -1) {
|
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
2003-01-15 13:32:57 +08:00
|
|
|
|
"substring not found");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
return PyInt_FromLong(result);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(rfind__doc__,
|
1999-10-13 03:54:53 +08:00
|
|
|
|
"S.rfind(sub [,start [,end]]) -> int\n\
|
|
|
|
|
\n\
|
|
|
|
|
Return the highest index in S where substring sub is found,\n\
|
|
|
|
|
such that sub is contained within s[start,end]. Optional\n\
|
|
|
|
|
arguments start and end are interpreted as in slice notation.\n\
|
|
|
|
|
\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
Return -1 on failure.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_rfind(PyStringObject *self, PyObject *args)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2000-03-11 06:55:18 +08:00
|
|
|
|
long result = string_find_internal(self, args, -1);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
if (result == -2)
|
|
|
|
|
return NULL;
|
|
|
|
|
return PyInt_FromLong(result);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(rindex__doc__,
|
1999-10-13 03:54:53 +08:00
|
|
|
|
"S.rindex(sub [,start [,end]]) -> int\n\
|
|
|
|
|
\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
Like S.rfind() but raise ValueError when the substring is not found.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_rindex(PyStringObject *self, PyObject *args)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2000-03-11 06:55:18 +08:00
|
|
|
|
long result = string_find_internal(self, args, -1);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
if (result == -2)
|
|
|
|
|
return NULL;
|
|
|
|
|
if (result == -1) {
|
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
2003-01-15 13:32:57 +08:00
|
|
|
|
"substring not found");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
return PyInt_FromLong(result);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-04-13 08:56:08 +08:00
|
|
|
|
static PyObject *
|
|
|
|
|
do_xstrip(PyStringObject *self, int striptype, PyObject *sepobj)
|
|
|
|
|
{
|
|
|
|
|
char *s = PyString_AS_STRING(self);
|
|
|
|
|
int len = PyString_GET_SIZE(self);
|
|
|
|
|
char *sep = PyString_AS_STRING(sepobj);
|
|
|
|
|
int seplen = PyString_GET_SIZE(sepobj);
|
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
|
if (striptype != RIGHTSTRIP) {
|
|
|
|
|
while (i < len && memchr(sep, Py_CHARMASK(s[i]), seplen)) {
|
|
|
|
|
i++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
j = len;
|
|
|
|
|
if (striptype != LEFTSTRIP) {
|
|
|
|
|
do {
|
|
|
|
|
j--;
|
|
|
|
|
} while (j >= i && memchr(sep, Py_CHARMASK(s[j]), seplen));
|
|
|
|
|
j++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (i == 0 && j == len && PyString_CheckExact(self)) {
|
|
|
|
|
Py_INCREF(self);
|
|
|
|
|
return (PyObject*)self;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return PyString_FromStringAndSize(s+i, j-i);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
1999-10-13 03:54:53 +08:00
|
|
|
|
static PyObject *
|
2001-08-16 21:15:00 +08:00
|
|
|
|
do_strip(PyStringObject *self, int striptype)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
|
|
|
|
char *s = PyString_AS_STRING(self);
|
|
|
|
|
int len = PyString_GET_SIZE(self), i, j;
|
|
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
|
if (striptype != RIGHTSTRIP) {
|
|
|
|
|
while (i < len && isspace(Py_CHARMASK(s[i]))) {
|
|
|
|
|
i++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
j = len;
|
|
|
|
|
if (striptype != LEFTSTRIP) {
|
|
|
|
|
do {
|
|
|
|
|
j--;
|
|
|
|
|
} while (j >= i && isspace(Py_CHARMASK(s[j])));
|
|
|
|
|
j++;
|
|
|
|
|
}
|
|
|
|
|
|
2001-09-12 10:18:30 +08:00
|
|
|
|
if (i == 0 && j == len && PyString_CheckExact(self)) {
|
1999-10-13 03:54:53 +08:00
|
|
|
|
Py_INCREF(self);
|
|
|
|
|
return (PyObject*)self;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return PyString_FromStringAndSize(s+i, j-i);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-04-13 08:56:08 +08:00
|
|
|
|
static PyObject *
|
|
|
|
|
do_argstrip(PyStringObject *self, int striptype, PyObject *args)
|
|
|
|
|
{
|
|
|
|
|
PyObject *sep = NULL;
|
|
|
|
|
|
2002-04-23 01:42:37 +08:00
|
|
|
|
if (!PyArg_ParseTuple(args, (char *)stripformat[striptype], &sep))
|
2002-04-13 08:56:08 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
if (sep != NULL && sep != Py_None) {
|
2002-04-23 01:42:37 +08:00
|
|
|
|
if (PyString_Check(sep))
|
|
|
|
|
return do_xstrip(self, striptype, sep);
|
2002-05-13 17:00:41 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2002-04-23 01:42:37 +08:00
|
|
|
|
else if (PyUnicode_Check(sep)) {
|
|
|
|
|
PyObject *uniself = PyUnicode_FromObject((PyObject *)self);
|
|
|
|
|
PyObject *res;
|
|
|
|
|
if (uniself==NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
res = _PyUnicode_XStrip((PyUnicodeObject *)uniself,
|
|
|
|
|
striptype, sep);
|
|
|
|
|
Py_DECREF(uniself);
|
|
|
|
|
return res;
|
|
|
|
|
}
|
2002-05-13 17:00:41 +08:00
|
|
|
|
#endif
|
2002-04-23 01:42:37 +08:00
|
|
|
|
else {
|
2002-04-13 08:56:08 +08:00
|
|
|
|
PyErr_Format(PyExc_TypeError,
|
2002-05-13 17:00:41 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2002-04-23 01:42:37 +08:00
|
|
|
|
"%s arg must be None, str or unicode",
|
2002-05-13 17:00:41 +08:00
|
|
|
|
#else
|
|
|
|
|
"%s arg must be None or str",
|
|
|
|
|
#endif
|
2002-04-23 01:42:37 +08:00
|
|
|
|
STRIPNAME(striptype));
|
2002-04-13 08:56:08 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
return do_xstrip(self, striptype, sep);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return do_strip(self, striptype);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(strip__doc__,
|
2003-04-11 06:35:32 +08:00
|
|
|
|
"S.strip([chars]) -> string or unicode\n\
|
1999-10-13 03:54:53 +08:00
|
|
|
|
\n\
|
|
|
|
|
Return a copy of the string S with leading and trailing\n\
|
2002-04-13 08:56:08 +08:00
|
|
|
|
whitespace removed.\n\
|
2003-04-11 06:35:32 +08:00
|
|
|
|
If chars is given and not None, remove characters in chars instead.\n\
|
|
|
|
|
If chars is unicode, S will be converted to unicode before stripping");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2002-04-13 08:56:08 +08:00
|
|
|
|
string_strip(PyStringObject *self, PyObject *args)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2002-04-13 08:56:08 +08:00
|
|
|
|
if (PyTuple_GET_SIZE(args) == 0)
|
|
|
|
|
return do_strip(self, BOTHSTRIP); /* Common case */
|
|
|
|
|
else
|
|
|
|
|
return do_argstrip(self, BOTHSTRIP, args);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(lstrip__doc__,
|
2003-04-11 06:35:32 +08:00
|
|
|
|
"S.lstrip([chars]) -> string or unicode\n\
|
1999-10-13 03:54:53 +08:00
|
|
|
|
\n\
|
2002-04-13 08:56:08 +08:00
|
|
|
|
Return a copy of the string S with leading whitespace removed.\n\
|
2003-04-11 06:35:32 +08:00
|
|
|
|
If chars is given and not None, remove characters in chars instead.\n\
|
|
|
|
|
If chars is unicode, S will be converted to unicode before stripping");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2002-04-13 08:56:08 +08:00
|
|
|
|
string_lstrip(PyStringObject *self, PyObject *args)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2002-04-13 08:56:08 +08:00
|
|
|
|
if (PyTuple_GET_SIZE(args) == 0)
|
|
|
|
|
return do_strip(self, LEFTSTRIP); /* Common case */
|
|
|
|
|
else
|
|
|
|
|
return do_argstrip(self, LEFTSTRIP, args);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(rstrip__doc__,
|
2003-04-11 06:35:32 +08:00
|
|
|
|
"S.rstrip([chars]) -> string or unicode\n\
|
1999-10-13 03:54:53 +08:00
|
|
|
|
\n\
|
2002-04-13 08:56:08 +08:00
|
|
|
|
Return a copy of the string S with trailing whitespace removed.\n\
|
2003-04-11 06:35:32 +08:00
|
|
|
|
If chars is given and not None, remove characters in chars instead.\n\
|
|
|
|
|
If chars is unicode, S will be converted to unicode before stripping");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2002-04-13 08:56:08 +08:00
|
|
|
|
string_rstrip(PyStringObject *self, PyObject *args)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2002-04-13 08:56:08 +08:00
|
|
|
|
if (PyTuple_GET_SIZE(args) == 0)
|
|
|
|
|
return do_strip(self, RIGHTSTRIP); /* Common case */
|
|
|
|
|
else
|
|
|
|
|
return do_argstrip(self, RIGHTSTRIP, args);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(lower__doc__,
|
1999-10-13 03:54:53 +08:00
|
|
|
|
"S.lower() -> string\n\
|
|
|
|
|
\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
Return a copy of the string S converted to lowercase.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2001-08-16 21:15:00 +08:00
|
|
|
|
string_lower(PyStringObject *self)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
|
|
|
|
char *s = PyString_AS_STRING(self), *s_new;
|
|
|
|
|
int i, n = PyString_GET_SIZE(self);
|
|
|
|
|
PyObject *new;
|
|
|
|
|
|
|
|
|
|
new = PyString_FromStringAndSize(NULL, n);
|
|
|
|
|
if (new == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
s_new = PyString_AsString(new);
|
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
|
int c = Py_CHARMASK(*s++);
|
|
|
|
|
if (isupper(c)) {
|
|
|
|
|
*s_new = tolower(c);
|
|
|
|
|
} else
|
|
|
|
|
*s_new = c;
|
|
|
|
|
s_new++;
|
|
|
|
|
}
|
|
|
|
|
return new;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(upper__doc__,
|
1999-10-13 03:54:53 +08:00
|
|
|
|
"S.upper() -> string\n\
|
|
|
|
|
\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
Return a copy of the string S converted to uppercase.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2001-08-16 21:15:00 +08:00
|
|
|
|
string_upper(PyStringObject *self)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
|
|
|
|
char *s = PyString_AS_STRING(self), *s_new;
|
|
|
|
|
int i, n = PyString_GET_SIZE(self);
|
|
|
|
|
PyObject *new;
|
|
|
|
|
|
|
|
|
|
new = PyString_FromStringAndSize(NULL, n);
|
|
|
|
|
if (new == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
s_new = PyString_AsString(new);
|
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
|
int c = Py_CHARMASK(*s++);
|
|
|
|
|
if (islower(c)) {
|
|
|
|
|
*s_new = toupper(c);
|
|
|
|
|
} else
|
|
|
|
|
*s_new = c;
|
|
|
|
|
s_new++;
|
|
|
|
|
}
|
|
|
|
|
return new;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(title__doc__,
|
2000-03-11 06:55:18 +08:00
|
|
|
|
"S.title() -> string\n\
|
|
|
|
|
\n\
|
|
|
|
|
Return a titlecased version of S, i.e. words start with uppercase\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
characters, all remaining cased characters have lowercase.");
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
static PyObject*
|
2001-08-16 21:15:00 +08:00
|
|
|
|
string_title(PyStringObject *self)
|
2000-03-11 06:55:18 +08:00
|
|
|
|
{
|
|
|
|
|
char *s = PyString_AS_STRING(self), *s_new;
|
|
|
|
|
int i, n = PyString_GET_SIZE(self);
|
|
|
|
|
int previous_is_cased = 0;
|
|
|
|
|
PyObject *new;
|
|
|
|
|
|
|
|
|
|
new = PyString_FromStringAndSize(NULL, n);
|
|
|
|
|
if (new == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
s_new = PyString_AsString(new);
|
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
|
int c = Py_CHARMASK(*s++);
|
|
|
|
|
if (islower(c)) {
|
|
|
|
|
if (!previous_is_cased)
|
|
|
|
|
c = toupper(c);
|
|
|
|
|
previous_is_cased = 1;
|
|
|
|
|
} else if (isupper(c)) {
|
|
|
|
|
if (previous_is_cased)
|
|
|
|
|
c = tolower(c);
|
|
|
|
|
previous_is_cased = 1;
|
|
|
|
|
} else
|
|
|
|
|
previous_is_cased = 0;
|
|
|
|
|
*s_new++ = c;
|
|
|
|
|
}
|
|
|
|
|
return new;
|
|
|
|
|
}
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(capitalize__doc__,
|
1999-10-13 03:54:53 +08:00
|
|
|
|
"S.capitalize() -> string\n\
|
|
|
|
|
\n\
|
|
|
|
|
Return a copy of the string S with only its first character\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
capitalized.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2001-08-16 21:15:00 +08:00
|
|
|
|
string_capitalize(PyStringObject *self)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
|
|
|
|
char *s = PyString_AS_STRING(self), *s_new;
|
|
|
|
|
int i, n = PyString_GET_SIZE(self);
|
|
|
|
|
PyObject *new;
|
|
|
|
|
|
|
|
|
|
new = PyString_FromStringAndSize(NULL, n);
|
|
|
|
|
if (new == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
s_new = PyString_AsString(new);
|
|
|
|
|
if (0 < n) {
|
|
|
|
|
int c = Py_CHARMASK(*s++);
|
|
|
|
|
if (islower(c))
|
|
|
|
|
*s_new = toupper(c);
|
|
|
|
|
else
|
|
|
|
|
*s_new = c;
|
|
|
|
|
s_new++;
|
|
|
|
|
}
|
|
|
|
|
for (i = 1; i < n; i++) {
|
|
|
|
|
int c = Py_CHARMASK(*s++);
|
|
|
|
|
if (isupper(c))
|
|
|
|
|
*s_new = tolower(c);
|
|
|
|
|
else
|
|
|
|
|
*s_new = c;
|
|
|
|
|
s_new++;
|
|
|
|
|
}
|
|
|
|
|
return new;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(count__doc__,
|
1999-10-13 03:54:53 +08:00
|
|
|
|
"S.count(sub[, start[, end]]) -> int\n\
|
|
|
|
|
\n\
|
|
|
|
|
Return the number of occurrences of substring sub in string\n\
|
|
|
|
|
S[start:end]. Optional arguments start and end are\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
interpreted as in slice notation.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_count(PyStringObject *self, PyObject *args)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2000-03-11 06:55:18 +08:00
|
|
|
|
const char *s = PyString_AS_STRING(self), *sub;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
int len = PyString_GET_SIZE(self), n;
|
|
|
|
|
int i = 0, last = INT_MAX;
|
|
|
|
|
int m, r;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
PyObject *subobj;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2000-05-08 22:08:05 +08:00
|
|
|
|
if (!PyArg_ParseTuple(args, "O|O&O&:count", &subobj,
|
|
|
|
|
_PyEval_SliceIndex, &i, _PyEval_SliceIndex, &last))
|
2000-03-11 06:55:18 +08:00
|
|
|
|
return NULL;
|
2000-05-08 22:08:05 +08:00
|
|
|
|
|
2000-03-11 06:55:18 +08:00
|
|
|
|
if (PyString_Check(subobj)) {
|
|
|
|
|
sub = PyString_AS_STRING(subobj);
|
|
|
|
|
n = PyString_GET_SIZE(subobj);
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2001-01-16 19:54:12 +08:00
|
|
|
|
else if (PyUnicode_Check(subobj)) {
|
|
|
|
|
int count;
|
|
|
|
|
count = PyUnicode_Count((PyObject *)self, subobj, i, last);
|
|
|
|
|
if (count == -1)
|
|
|
|
|
return NULL;
|
|
|
|
|
else
|
|
|
|
|
return PyInt_FromLong((long) count);
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyObject_AsCharBuffer(subobj, &sub, &n))
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return NULL;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
2002-06-14 08:50:42 +08:00
|
|
|
|
string_adjust_indices(&i, &last, len);
|
|
|
|
|
|
1999-10-13 03:54:53 +08:00
|
|
|
|
m = last + 1 - n;
|
|
|
|
|
if (n == 0)
|
|
|
|
|
return PyInt_FromLong((long) (m-i));
|
|
|
|
|
|
|
|
|
|
r = 0;
|
|
|
|
|
while (i < m) {
|
|
|
|
|
if (!memcmp(s+i, sub, n)) {
|
|
|
|
|
r++;
|
|
|
|
|
i += n;
|
|
|
|
|
} else {
|
|
|
|
|
i++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return PyInt_FromLong((long) r);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(swapcase__doc__,
|
1999-10-13 03:54:53 +08:00
|
|
|
|
"S.swapcase() -> string\n\
|
|
|
|
|
\n\
|
2000-03-11 06:55:18 +08:00
|
|
|
|
Return a copy of the string S with uppercase characters\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
converted to lowercase and vice versa.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2001-08-16 21:15:00 +08:00
|
|
|
|
string_swapcase(PyStringObject *self)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
|
|
|
|
char *s = PyString_AS_STRING(self), *s_new;
|
|
|
|
|
int i, n = PyString_GET_SIZE(self);
|
|
|
|
|
PyObject *new;
|
|
|
|
|
|
|
|
|
|
new = PyString_FromStringAndSize(NULL, n);
|
|
|
|
|
if (new == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
s_new = PyString_AsString(new);
|
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
|
int c = Py_CHARMASK(*s++);
|
|
|
|
|
if (islower(c)) {
|
|
|
|
|
*s_new = toupper(c);
|
|
|
|
|
}
|
|
|
|
|
else if (isupper(c)) {
|
|
|
|
|
*s_new = tolower(c);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*s_new = c;
|
|
|
|
|
s_new++;
|
|
|
|
|
}
|
|
|
|
|
return new;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(translate__doc__,
|
1999-10-13 03:54:53 +08:00
|
|
|
|
"S.translate(table [,deletechars]) -> string\n\
|
|
|
|
|
\n\
|
|
|
|
|
Return a copy of the string S, where all characters occurring\n\
|
|
|
|
|
in the optional argument deletechars are removed, and the\n\
|
|
|
|
|
remaining characters have been mapped through the given\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
translation table, which must be a string of length 256.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_translate(PyStringObject *self, PyObject *args)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2000-03-11 06:55:18 +08:00
|
|
|
|
register char *input, *output;
|
|
|
|
|
register const char *table;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
register int i, c, changed = 0;
|
|
|
|
|
PyObject *input_obj = (PyObject*)self;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
const char *table1, *output_start, *del_table=NULL;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
int inlen, tablen, dellen = 0;
|
|
|
|
|
PyObject *result;
|
|
|
|
|
int trans_table[256];
|
2000-03-11 06:55:18 +08:00
|
|
|
|
PyObject *tableobj, *delobj = NULL;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2002-12-30 00:33:45 +08:00
|
|
|
|
if (!PyArg_UnpackTuple(args, "translate", 1, 2,
|
2000-03-11 06:55:18 +08:00
|
|
|
|
&tableobj, &delobj))
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return NULL;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
if (PyString_Check(tableobj)) {
|
|
|
|
|
table1 = PyString_AS_STRING(tableobj);
|
|
|
|
|
tablen = PyString_GET_SIZE(tableobj);
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyUnicode_Check(tableobj)) {
|
2001-04-28 13:38:26 +08:00
|
|
|
|
/* Unicode .translate() does not support the deletechars
|
2000-03-11 06:55:18 +08:00
|
|
|
|
parameter; instead a mapping to None will cause characters
|
|
|
|
|
to be deleted. */
|
|
|
|
|
if (delobj != NULL) {
|
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
|
"deletions are implemented differently for unicode");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
return PyUnicode_Translate((PyObject *)self, tableobj, NULL);
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyObject_AsCharBuffer(tableobj, &table1, &tablen))
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return NULL;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
2002-12-13 04:03:19 +08:00
|
|
|
|
if (tablen != 256) {
|
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
|
"translation table must be 256 characters long");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2000-03-11 06:55:18 +08:00
|
|
|
|
if (delobj != NULL) {
|
|
|
|
|
if (PyString_Check(delobj)) {
|
|
|
|
|
del_table = PyString_AS_STRING(delobj);
|
|
|
|
|
dellen = PyString_GET_SIZE(delobj);
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyUnicode_Check(delobj)) {
|
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
|
"deletions are implemented differently for unicode");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyObject_AsCharBuffer(delobj, &del_table, &dellen))
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
del_table = NULL;
|
|
|
|
|
dellen = 0;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
table = table1;
|
|
|
|
|
inlen = PyString_Size(input_obj);
|
|
|
|
|
result = PyString_FromStringAndSize((char *)NULL, inlen);
|
|
|
|
|
if (result == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
output_start = output = PyString_AsString(result);
|
|
|
|
|
input = PyString_AsString(input_obj);
|
|
|
|
|
|
|
|
|
|
if (dellen == 0) {
|
|
|
|
|
/* If no deletions are required, use faster code */
|
|
|
|
|
for (i = inlen; --i >= 0; ) {
|
|
|
|
|
c = Py_CHARMASK(*input++);
|
|
|
|
|
if (Py_CHARMASK((*output++ = table[c])) != c)
|
|
|
|
|
changed = 1;
|
|
|
|
|
}
|
2001-09-12 10:18:30 +08:00
|
|
|
|
if (changed || !PyString_CheckExact(input_obj))
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return result;
|
|
|
|
|
Py_DECREF(result);
|
|
|
|
|
Py_INCREF(input_obj);
|
|
|
|
|
return input_obj;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 256; i++)
|
|
|
|
|
trans_table[i] = Py_CHARMASK(table[i]);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < dellen; i++)
|
|
|
|
|
trans_table[(int) Py_CHARMASK(del_table[i])] = -1;
|
|
|
|
|
|
|
|
|
|
for (i = inlen; --i >= 0; ) {
|
|
|
|
|
c = Py_CHARMASK(*input++);
|
|
|
|
|
if (trans_table[c] != -1)
|
|
|
|
|
if (Py_CHARMASK(*output++ = (char)trans_table[c]) == c)
|
|
|
|
|
continue;
|
|
|
|
|
changed = 1;
|
|
|
|
|
}
|
2001-09-12 10:18:30 +08:00
|
|
|
|
if (!changed && PyString_CheckExact(input_obj)) {
|
1999-10-13 03:54:53 +08:00
|
|
|
|
Py_DECREF(result);
|
|
|
|
|
Py_INCREF(input_obj);
|
|
|
|
|
return input_obj;
|
|
|
|
|
}
|
|
|
|
|
/* Fix the size of the resulting string */
|
2002-04-28 02:44:32 +08:00
|
|
|
|
if (inlen > 0)
|
|
|
|
|
_PyString_Resize(&result, output - output_start);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* What follows is used for implementing replace(). Perry Stoll. */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
mymemfind
|
|
|
|
|
|
|
|
|
|
strstr replacement for arbitrary blocks of memory.
|
|
|
|
|
|
2000-03-21 00:36:48 +08:00
|
|
|
|
Locates the first occurrence in the memory pointed to by MEM of the
|
1999-10-13 03:54:53 +08:00
|
|
|
|
contents of memory pointed to by PAT. Returns the index into MEM if
|
|
|
|
|
found, or -1 if not found. If len of PAT is greater than length of
|
|
|
|
|
MEM, the function returns -1.
|
|
|
|
|
*/
|
2001-04-28 13:38:26 +08:00
|
|
|
|
static int
|
2000-07-09 16:02:21 +08:00
|
|
|
|
mymemfind(const char *mem, int len, const char *pat, int pat_len)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
|
|
|
|
register int ii;
|
|
|
|
|
|
|
|
|
|
/* pattern can not occur in the last pat_len-1 chars */
|
|
|
|
|
len -= pat_len;
|
|
|
|
|
|
|
|
|
|
for (ii = 0; ii <= len; ii++) {
|
2000-06-20 23:47:54 +08:00
|
|
|
|
if (mem[ii] == pat[0] && memcmp(&mem[ii], pat, pat_len) == 0) {
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return ii;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
mymemcnt
|
|
|
|
|
|
|
|
|
|
Return the number of distinct times PAT is found in MEM.
|
|
|
|
|
meaning mem=1111 and pat==11 returns 2.
|
|
|
|
|
mem=11111 and pat==11 also return 2.
|
|
|
|
|
*/
|
2001-04-28 13:38:26 +08:00
|
|
|
|
static int
|
2000-07-09 16:02:21 +08:00
|
|
|
|
mymemcnt(const char *mem, int len, const char *pat, int pat_len)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
|
|
|
|
register int offset = 0;
|
|
|
|
|
int nfound = 0;
|
|
|
|
|
|
|
|
|
|
while (len >= 0) {
|
|
|
|
|
offset = mymemfind(mem, len, pat, pat_len);
|
|
|
|
|
if (offset == -1)
|
|
|
|
|
break;
|
|
|
|
|
mem += offset + pat_len;
|
|
|
|
|
len -= offset + pat_len;
|
|
|
|
|
nfound++;
|
|
|
|
|
}
|
|
|
|
|
return nfound;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
mymemreplace
|
|
|
|
|
|
2000-07-16 20:04:32 +08:00
|
|
|
|
Return a string in which all occurrences of PAT in memory STR are
|
1999-10-13 03:54:53 +08:00
|
|
|
|
replaced with SUB.
|
|
|
|
|
|
2000-07-16 20:04:32 +08:00
|
|
|
|
If length of PAT is less than length of STR or there are no occurrences
|
1999-10-13 03:54:53 +08:00
|
|
|
|
of PAT in STR, then the original string is returned. Otherwise, a new
|
|
|
|
|
string is allocated here and returned.
|
|
|
|
|
|
|
|
|
|
on return, out_len is:
|
|
|
|
|
the length of output string, or
|
|
|
|
|
-1 if the input string is returned, or
|
|
|
|
|
unchanged if an error occurs (no memory).
|
|
|
|
|
|
|
|
|
|
return value is:
|
|
|
|
|
the new string allocated locally, or
|
|
|
|
|
NULL if an error occurred.
|
|
|
|
|
*/
|
|
|
|
|
static char *
|
2000-07-09 16:02:21 +08:00
|
|
|
|
mymemreplace(const char *str, int len, /* input string */
|
|
|
|
|
const char *pat, int pat_len, /* pattern string to find */
|
|
|
|
|
const char *sub, int sub_len, /* substitution string */
|
|
|
|
|
int count, /* number of replacements */
|
2001-05-10 08:05:33 +08:00
|
|
|
|
int *out_len)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
|
|
|
|
char *out_s;
|
|
|
|
|
char *new_s;
|
|
|
|
|
int nfound, offset, new_len;
|
|
|
|
|
|
2002-08-24 02:21:28 +08:00
|
|
|
|
if (len == 0 || (pat_len == 0 && sub_len == 0) || pat_len > len)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
goto return_same;
|
|
|
|
|
|
|
|
|
|
/* find length of output string */
|
2002-08-24 02:21:28 +08:00
|
|
|
|
nfound = (pat_len > 0) ? mymemcnt(str, len, pat, pat_len) : len + 1;
|
2001-05-10 08:32:57 +08:00
|
|
|
|
if (count < 0)
|
|
|
|
|
count = INT_MAX;
|
|
|
|
|
else if (nfound > count)
|
|
|
|
|
nfound = count;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
if (nfound == 0)
|
|
|
|
|
goto return_same;
|
2001-05-10 08:05:33 +08:00
|
|
|
|
|
1999-10-13 03:54:53 +08:00
|
|
|
|
new_len = len + nfound*(sub_len - pat_len);
|
2001-05-10 08:05:33 +08:00
|
|
|
|
if (new_len == 0) {
|
|
|
|
|
/* Have to allocate something for the caller to free(). */
|
|
|
|
|
out_s = (char *)PyMem_MALLOC(1);
|
2001-05-10 08:32:57 +08:00
|
|
|
|
if (out_s == NULL)
|
2001-05-10 08:05:33 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
out_s[0] = '\0';
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
assert(new_len > 0);
|
|
|
|
|
new_s = (char *)PyMem_MALLOC(new_len);
|
|
|
|
|
if (new_s == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
out_s = new_s;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2002-08-24 02:21:28 +08:00
|
|
|
|
if (pat_len > 0) {
|
|
|
|
|
for (; nfound > 0; --nfound) {
|
|
|
|
|
/* find index of next instance of pattern */
|
|
|
|
|
offset = mymemfind(str, len, pat, pat_len);
|
|
|
|
|
if (offset == -1)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* copy non matching part of input string */
|
|
|
|
|
memcpy(new_s, str, offset);
|
|
|
|
|
str += offset + pat_len;
|
|
|
|
|
len -= offset + pat_len;
|
|
|
|
|
|
|
|
|
|
/* copy substitute into the output string */
|
|
|
|
|
new_s += offset;
|
|
|
|
|
memcpy(new_s, sub, sub_len);
|
|
|
|
|
new_s += sub_len;
|
|
|
|
|
}
|
|
|
|
|
/* copy any remaining values into output string */
|
|
|
|
|
if (len > 0)
|
|
|
|
|
memcpy(new_s, str, len);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
for (;;++str, --len) {
|
|
|
|
|
memcpy(new_s, sub, sub_len);
|
|
|
|
|
new_s += sub_len;
|
|
|
|
|
if (--nfound <= 0) {
|
|
|
|
|
memcpy(new_s, str, len);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
*new_s++ = *str;
|
|
|
|
|
}
|
2001-05-10 08:05:33 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
1999-10-13 03:54:53 +08:00
|
|
|
|
*out_len = new_len;
|
|
|
|
|
return out_s;
|
|
|
|
|
|
|
|
|
|
return_same:
|
|
|
|
|
*out_len = -1;
|
2001-05-10 08:05:33 +08:00
|
|
|
|
return (char *)str; /* cast away const */
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(replace__doc__,
|
2003-10-22 10:56:40 +08:00
|
|
|
|
"S.replace (old, new[, count]) -> string\n\
|
1999-10-13 03:54:53 +08:00
|
|
|
|
\n\
|
|
|
|
|
Return a copy of string S with all occurrences of substring\n\
|
2003-10-22 10:56:40 +08:00
|
|
|
|
old replaced by new. If the optional argument count is\n\
|
|
|
|
|
given, only the first count occurrences are replaced.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_replace(PyStringObject *self, PyObject *args)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2000-03-11 06:55:18 +08:00
|
|
|
|
const char *str = PyString_AS_STRING(self), *sub, *repl;
|
|
|
|
|
char *new_s;
|
2001-09-12 10:18:30 +08:00
|
|
|
|
const int len = PyString_GET_SIZE(self);
|
|
|
|
|
int sub_len, repl_len, out_len;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
int count = -1;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
PyObject *new;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
PyObject *subobj, *replobj;
|
|
|
|
|
|
|
|
|
|
if (!PyArg_ParseTuple(args, "OO|i:replace",
|
|
|
|
|
&subobj, &replobj, &count))
|
|
|
|
|
return NULL;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2000-03-11 06:55:18 +08:00
|
|
|
|
if (PyString_Check(subobj)) {
|
|
|
|
|
sub = PyString_AS_STRING(subobj);
|
|
|
|
|
sub_len = PyString_GET_SIZE(subobj);
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyUnicode_Check(subobj))
|
2001-04-28 13:38:26 +08:00
|
|
|
|
return PyUnicode_Replace((PyObject *)self,
|
2000-03-11 06:55:18 +08:00
|
|
|
|
subobj, replobj, count);
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyObject_AsCharBuffer(subobj, &sub, &sub_len))
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return NULL;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
if (PyString_Check(replobj)) {
|
|
|
|
|
repl = PyString_AS_STRING(replobj);
|
|
|
|
|
repl_len = PyString_GET_SIZE(replobj);
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyUnicode_Check(replobj))
|
2001-04-28 13:38:26 +08:00
|
|
|
|
return PyUnicode_Replace((PyObject *)self,
|
2000-03-11 06:55:18 +08:00
|
|
|
|
subobj, replobj, count);
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyObject_AsCharBuffer(replobj, &repl, &repl_len))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
new_s = mymemreplace(str,len,sub,sub_len,repl,repl_len,count,&out_len);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
if (new_s == NULL) {
|
|
|
|
|
PyErr_NoMemory();
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
if (out_len == -1) {
|
2001-09-12 10:18:30 +08:00
|
|
|
|
if (PyString_CheckExact(self)) {
|
|
|
|
|
/* we're returning another reference to self */
|
|
|
|
|
new = (PyObject*)self;
|
|
|
|
|
Py_INCREF(new);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
new = PyString_FromStringAndSize(str, len);
|
|
|
|
|
if (new == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
new = PyString_FromStringAndSize(new_s, out_len);
|
2000-05-04 07:44:39 +08:00
|
|
|
|
PyMem_FREE(new_s);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
|
|
|
|
return new;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(startswith__doc__,
|
2002-04-04 06:41:51 +08:00
|
|
|
|
"S.startswith(prefix[, start[, end]]) -> bool\n\
|
1999-10-13 03:54:53 +08:00
|
|
|
|
\n\
|
2003-04-10 03:32:45 +08:00
|
|
|
|
Return True if S starts with the specified prefix, False otherwise.\n\
|
|
|
|
|
With optional start, test S beginning at that position.\n\
|
|
|
|
|
With optional end, stop comparing S at that position.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_startswith(PyStringObject *self, PyObject *args)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2000-03-11 06:55:18 +08:00
|
|
|
|
const char* str = PyString_AS_STRING(self);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
int len = PyString_GET_SIZE(self);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
const char* prefix;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
int plen;
|
|
|
|
|
int start = 0;
|
2002-06-14 08:50:42 +08:00
|
|
|
|
int end = INT_MAX;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
PyObject *subobj;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2000-05-08 22:08:05 +08:00
|
|
|
|
if (!PyArg_ParseTuple(args, "O|O&O&:startswith", &subobj,
|
|
|
|
|
_PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
|
2000-03-11 06:55:18 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
if (PyString_Check(subobj)) {
|
|
|
|
|
prefix = PyString_AS_STRING(subobj);
|
|
|
|
|
plen = PyString_GET_SIZE(subobj);
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2001-01-16 19:54:12 +08:00
|
|
|
|
else if (PyUnicode_Check(subobj)) {
|
|
|
|
|
int rc;
|
2001-04-28 13:38:26 +08:00
|
|
|
|
rc = PyUnicode_Tailmatch((PyObject *)self,
|
2001-01-16 19:54:12 +08:00
|
|
|
|
subobj, start, end, -1);
|
|
|
|
|
if (rc == -1)
|
|
|
|
|
return NULL;
|
|
|
|
|
else
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong((long) rc);
|
2001-01-16 19:54:12 +08:00
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyObject_AsCharBuffer(subobj, &prefix, &plen))
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
|
2002-06-14 08:50:42 +08:00
|
|
|
|
string_adjust_indices(&start, &end, len);
|
|
|
|
|
|
|
|
|
|
if (start+plen > len)
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2002-06-14 08:50:42 +08:00
|
|
|
|
if (end-start >= plen)
|
|
|
|
|
return PyBool_FromLong(!memcmp(str+start, prefix, plen));
|
|
|
|
|
else
|
|
|
|
|
return PyBool_FromLong(0);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(endswith__doc__,
|
2002-04-04 06:41:51 +08:00
|
|
|
|
"S.endswith(suffix[, start[, end]]) -> bool\n\
|
1999-10-13 03:54:53 +08:00
|
|
|
|
\n\
|
2003-04-10 03:32:45 +08:00
|
|
|
|
Return True if S ends with the specified suffix, False otherwise.\n\
|
|
|
|
|
With optional start, test S beginning at that position.\n\
|
|
|
|
|
With optional end, stop comparing S at that position.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
string_endswith(PyStringObject *self, PyObject *args)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2000-03-11 06:55:18 +08:00
|
|
|
|
const char* str = PyString_AS_STRING(self);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
int len = PyString_GET_SIZE(self);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
const char* suffix;
|
|
|
|
|
int slen;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
int start = 0;
|
2002-06-14 08:50:42 +08:00
|
|
|
|
int end = INT_MAX;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
PyObject *subobj;
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2000-05-08 22:08:05 +08:00
|
|
|
|
if (!PyArg_ParseTuple(args, "O|O&O&:endswith", &subobj,
|
|
|
|
|
_PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
|
2000-03-11 06:55:18 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
if (PyString_Check(subobj)) {
|
|
|
|
|
suffix = PyString_AS_STRING(subobj);
|
|
|
|
|
slen = PyString_GET_SIZE(subobj);
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2001-01-16 19:54:12 +08:00
|
|
|
|
else if (PyUnicode_Check(subobj)) {
|
|
|
|
|
int rc;
|
2001-04-28 13:38:26 +08:00
|
|
|
|
rc = PyUnicode_Tailmatch((PyObject *)self,
|
2001-01-16 19:54:12 +08:00
|
|
|
|
subobj, start, end, +1);
|
|
|
|
|
if (rc == -1)
|
|
|
|
|
return NULL;
|
|
|
|
|
else
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong((long) rc);
|
2001-01-16 19:54:12 +08:00
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (PyObject_AsCharBuffer(subobj, &suffix, &slen))
|
1999-10-13 03:54:53 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
|
2002-06-14 08:50:42 +08:00
|
|
|
|
string_adjust_indices(&start, &end, len);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2002-06-14 08:50:42 +08:00
|
|
|
|
if (end-start < slen || start > len)
|
|
|
|
|
return PyBool_FromLong(0);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2002-06-14 08:50:42 +08:00
|
|
|
|
if (end-slen > start)
|
|
|
|
|
start = end - slen;
|
|
|
|
|
if (end-start >= slen)
|
|
|
|
|
return PyBool_FromLong(!memcmp(str+start, suffix, slen));
|
|
|
|
|
else
|
|
|
|
|
return PyBool_FromLong(0);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(encode__doc__,
|
2001-05-15 20:00:02 +08:00
|
|
|
|
"S.encode([encoding[,errors]]) -> object\n\
|
2000-07-06 19:29:01 +08:00
|
|
|
|
\n\
|
2001-05-15 20:00:02 +08:00
|
|
|
|
Encodes S using the codec registered for encoding. encoding defaults\n\
|
|
|
|
|
to the default encoding. errors may be given to set a different error\n\
|
2000-07-06 19:29:01 +08:00
|
|
|
|
handling scheme. Default is 'strict' meaning that encoding errors raise\n\
|
2002-09-02 21:14:32 +08:00
|
|
|
|
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n\
|
|
|
|
|
'xmlcharrefreplace' as well as any other name registered with\n\
|
|
|
|
|
codecs.register_error that is able to handle UnicodeEncodeErrors.");
|
2000-07-06 19:29:01 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
|
string_encode(PyStringObject *self, PyObject *args)
|
|
|
|
|
{
|
|
|
|
|
char *encoding = NULL;
|
|
|
|
|
char *errors = NULL;
|
2004-07-09 01:57:32 +08:00
|
|
|
|
PyObject *v;
|
|
|
|
|
|
2000-07-06 19:29:01 +08:00
|
|
|
|
if (!PyArg_ParseTuple(args, "|ss:encode", &encoding, &errors))
|
|
|
|
|
return NULL;
|
2004-07-09 01:57:32 +08:00
|
|
|
|
v = PyString_AsEncodedObject((PyObject *)self, encoding, errors);
|
2004-07-09 03:13:55 +08:00
|
|
|
|
if (v == NULL)
|
|
|
|
|
goto onError;
|
2004-07-09 01:57:32 +08:00
|
|
|
|
if (!PyString_Check(v) && !PyUnicode_Check(v)) {
|
|
|
|
|
PyErr_Format(PyExc_TypeError,
|
|
|
|
|
"encoder did not return a string/unicode object "
|
|
|
|
|
"(type=%.400s)",
|
|
|
|
|
v->ob_type->tp_name);
|
|
|
|
|
Py_DECREF(v);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
return v;
|
2004-07-09 03:13:55 +08:00
|
|
|
|
|
|
|
|
|
onError:
|
|
|
|
|
return NULL;
|
2001-05-15 20:00:02 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(decode__doc__,
|
2001-05-15 20:00:02 +08:00
|
|
|
|
"S.decode([encoding[,errors]]) -> object\n\
|
|
|
|
|
\n\
|
|
|
|
|
Decodes S using the codec registered for encoding. encoding defaults\n\
|
|
|
|
|
to the default encoding. errors may be given to set a different error\n\
|
|
|
|
|
handling scheme. Default is 'strict' meaning that encoding errors raise\n\
|
2002-09-02 21:14:32 +08:00
|
|
|
|
a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n\
|
|
|
|
|
as well as any other name registerd with codecs.register_error that is\n\
|
|
|
|
|
able to handle UnicodeDecodeErrors.");
|
2001-05-15 20:00:02 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
|
string_decode(PyStringObject *self, PyObject *args)
|
|
|
|
|
{
|
|
|
|
|
char *encoding = NULL;
|
|
|
|
|
char *errors = NULL;
|
2004-07-09 01:57:32 +08:00
|
|
|
|
PyObject *v;
|
|
|
|
|
|
2001-05-15 20:00:02 +08:00
|
|
|
|
if (!PyArg_ParseTuple(args, "|ss:decode", &encoding, &errors))
|
|
|
|
|
return NULL;
|
2004-07-09 01:57:32 +08:00
|
|
|
|
v = PyString_AsDecodedObject((PyObject *)self, encoding, errors);
|
2004-07-09 03:13:55 +08:00
|
|
|
|
if (v == NULL)
|
|
|
|
|
goto onError;
|
2004-07-09 01:57:32 +08:00
|
|
|
|
if (!PyString_Check(v) && !PyUnicode_Check(v)) {
|
|
|
|
|
PyErr_Format(PyExc_TypeError,
|
|
|
|
|
"decoder did not return a string/unicode object "
|
|
|
|
|
"(type=%.400s)",
|
|
|
|
|
v->ob_type->tp_name);
|
|
|
|
|
Py_DECREF(v);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
return v;
|
2004-07-09 03:13:55 +08:00
|
|
|
|
|
|
|
|
|
onError:
|
|
|
|
|
return NULL;
|
2000-07-06 19:29:01 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(expandtabs__doc__,
|
2000-03-11 06:55:18 +08:00
|
|
|
|
"S.expandtabs([tabsize]) -> string\n\
|
|
|
|
|
\n\
|
|
|
|
|
Return a copy of S where all tab characters are expanded using spaces.\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
If tabsize is not given, a tab size of 8 characters is assumed.");
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
static PyObject*
|
|
|
|
|
string_expandtabs(PyStringObject *self, PyObject *args)
|
|
|
|
|
{
|
|
|
|
|
const char *e, *p;
|
|
|
|
|
char *q;
|
|
|
|
|
int i, j;
|
|
|
|
|
PyObject *u;
|
|
|
|
|
int tabsize = 8;
|
|
|
|
|
|
|
|
|
|
if (!PyArg_ParseTuple(args, "|i:expandtabs", &tabsize))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2000-07-16 20:04:32 +08:00
|
|
|
|
/* First pass: determine size of output string */
|
2000-03-11 06:55:18 +08:00
|
|
|
|
i = j = 0;
|
|
|
|
|
e = PyString_AS_STRING(self) + PyString_GET_SIZE(self);
|
|
|
|
|
for (p = PyString_AS_STRING(self); p < e; p++)
|
|
|
|
|
if (*p == '\t') {
|
|
|
|
|
if (tabsize > 0)
|
|
|
|
|
j += tabsize - (j % tabsize);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
j++;
|
|
|
|
|
if (*p == '\n' || *p == '\r') {
|
|
|
|
|
i += j;
|
|
|
|
|
j = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Second pass: create output string and fill it */
|
|
|
|
|
u = PyString_FromStringAndSize(NULL, i + j);
|
|
|
|
|
if (!u)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
j = 0;
|
|
|
|
|
q = PyString_AS_STRING(u);
|
|
|
|
|
|
|
|
|
|
for (p = PyString_AS_STRING(self); p < e; p++)
|
|
|
|
|
if (*p == '\t') {
|
|
|
|
|
if (tabsize > 0) {
|
|
|
|
|
i = tabsize - (j % tabsize);
|
|
|
|
|
j += i;
|
|
|
|
|
while (i--)
|
|
|
|
|
*q++ = ' ';
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
j++;
|
|
|
|
|
*q++ = *p;
|
|
|
|
|
if (*p == '\n' || *p == '\r')
|
|
|
|
|
j = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return u;
|
|
|
|
|
}
|
|
|
|
|
|
2001-09-12 10:18:30 +08:00
|
|
|
|
static PyObject *
|
|
|
|
|
pad(PyStringObject *self, int left, int right, char fill)
|
2000-03-11 06:55:18 +08:00
|
|
|
|
{
|
|
|
|
|
PyObject *u;
|
|
|
|
|
|
|
|
|
|
if (left < 0)
|
|
|
|
|
left = 0;
|
|
|
|
|
if (right < 0)
|
|
|
|
|
right = 0;
|
|
|
|
|
|
2001-09-12 10:18:30 +08:00
|
|
|
|
if (left == 0 && right == 0 && PyString_CheckExact(self)) {
|
2000-03-11 06:55:18 +08:00
|
|
|
|
Py_INCREF(self);
|
|
|
|
|
return (PyObject *)self;
|
|
|
|
|
}
|
|
|
|
|
|
2001-04-28 13:38:26 +08:00
|
|
|
|
u = PyString_FromStringAndSize(NULL,
|
2000-03-11 06:55:18 +08:00
|
|
|
|
left + PyString_GET_SIZE(self) + right);
|
|
|
|
|
if (u) {
|
|
|
|
|
if (left)
|
|
|
|
|
memset(PyString_AS_STRING(u), fill, left);
|
2001-04-28 13:38:26 +08:00
|
|
|
|
memcpy(PyString_AS_STRING(u) + left,
|
|
|
|
|
PyString_AS_STRING(self),
|
2000-03-11 06:55:18 +08:00
|
|
|
|
PyString_GET_SIZE(self));
|
|
|
|
|
if (right)
|
|
|
|
|
memset(PyString_AS_STRING(u) + left + PyString_GET_SIZE(self),
|
|
|
|
|
fill, right);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return u;
|
|
|
|
|
}
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(ljust__doc__,
|
2003-11-26 16:21:35 +08:00
|
|
|
|
"S.ljust(width[, fillchar]) -> string\n"
|
2001-09-12 10:18:30 +08:00
|
|
|
|
"\n"
|
|
|
|
|
"Return S left justified in a string of length width. Padding is\n"
|
2003-11-26 16:21:35 +08:00
|
|
|
|
"done using the specified fill character (default is a space).");
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
|
string_ljust(PyStringObject *self, PyObject *args)
|
|
|
|
|
{
|
|
|
|
|
int width;
|
2003-11-26 16:21:35 +08:00
|
|
|
|
char fillchar = ' ';
|
|
|
|
|
|
|
|
|
|
if (!PyArg_ParseTuple(args, "i|c:ljust", &width, &fillchar))
|
2000-03-11 06:55:18 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
|
2001-09-12 10:18:30 +08:00
|
|
|
|
if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
|
2000-03-11 06:55:18 +08:00
|
|
|
|
Py_INCREF(self);
|
|
|
|
|
return (PyObject*) self;
|
|
|
|
|
}
|
|
|
|
|
|
2003-11-26 16:21:35 +08:00
|
|
|
|
return pad(self, 0, width - PyString_GET_SIZE(self), fillchar);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(rjust__doc__,
|
2003-11-26 16:21:35 +08:00
|
|
|
|
"S.rjust(width[, fillchar]) -> string\n"
|
2001-09-12 10:18:30 +08:00
|
|
|
|
"\n"
|
|
|
|
|
"Return S right justified in a string of length width. Padding is\n"
|
2003-11-26 16:21:35 +08:00
|
|
|
|
"done using the specified fill character (default is a space)");
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
|
string_rjust(PyStringObject *self, PyObject *args)
|
|
|
|
|
{
|
|
|
|
|
int width;
|
2003-11-26 16:21:35 +08:00
|
|
|
|
char fillchar = ' ';
|
|
|
|
|
|
|
|
|
|
if (!PyArg_ParseTuple(args, "i|c:rjust", &width, &fillchar))
|
2000-03-11 06:55:18 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
|
2001-09-12 10:18:30 +08:00
|
|
|
|
if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
|
2000-03-11 06:55:18 +08:00
|
|
|
|
Py_INCREF(self);
|
|
|
|
|
return (PyObject*) self;
|
|
|
|
|
}
|
|
|
|
|
|
2003-11-26 16:21:35 +08:00
|
|
|
|
return pad(self, width - PyString_GET_SIZE(self), 0, fillchar);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(center__doc__,
|
2003-11-26 16:21:35 +08:00
|
|
|
|
"S.center(width[, fillchar]) -> string\n"
|
2001-09-12 10:18:30 +08:00
|
|
|
|
"\n"
|
2003-11-26 16:21:35 +08:00
|
|
|
|
"Return S centered in a string of length width. Padding is\n"
|
|
|
|
|
"done using the specified fill character (default is a space)");
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
|
string_center(PyStringObject *self, PyObject *args)
|
|
|
|
|
{
|
|
|
|
|
int marg, left;
|
|
|
|
|
int width;
|
2003-11-26 16:21:35 +08:00
|
|
|
|
char fillchar = ' ';
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
2003-11-26 16:21:35 +08:00
|
|
|
|
if (!PyArg_ParseTuple(args, "i|c:center", &width, &fillchar))
|
2000-03-11 06:55:18 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
|
2001-09-12 10:18:30 +08:00
|
|
|
|
if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
|
2000-03-11 06:55:18 +08:00
|
|
|
|
Py_INCREF(self);
|
|
|
|
|
return (PyObject*) self;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
marg = width - PyString_GET_SIZE(self);
|
|
|
|
|
left = marg / 2 + (marg & width & 1);
|
|
|
|
|
|
2003-11-26 16:21:35 +08:00
|
|
|
|
return pad(self, left, marg - left, fillchar);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
}
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(zfill__doc__,
|
2002-04-15 21:36:47 +08:00
|
|
|
|
"S.zfill(width) -> string\n"
|
|
|
|
|
"\n"
|
|
|
|
|
"Pad a numeric string S with zeros on the left, to fill a field\n"
|
2002-06-14 04:33:02 +08:00
|
|
|
|
"of the specified width. The string S is never truncated.");
|
2002-04-15 21:36:47 +08:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
|
string_zfill(PyStringObject *self, PyObject *args)
|
|
|
|
|
{
|
|
|
|
|
int fill;
|
|
|
|
|
PyObject *s;
|
2002-04-15 21:48:52 +08:00
|
|
|
|
char *p;
|
2002-04-15 21:36:47 +08:00
|
|
|
|
|
|
|
|
|
int width;
|
|
|
|
|
if (!PyArg_ParseTuple(args, "i:zfill", &width))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
if (PyString_GET_SIZE(self) >= width) {
|
2002-04-16 02:42:15 +08:00
|
|
|
|
if (PyString_CheckExact(self)) {
|
|
|
|
|
Py_INCREF(self);
|
|
|
|
|
return (PyObject*) self;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return PyString_FromStringAndSize(
|
|
|
|
|
PyString_AS_STRING(self),
|
|
|
|
|
PyString_GET_SIZE(self)
|
|
|
|
|
);
|
2002-04-15 21:36:47 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fill = width - PyString_GET_SIZE(self);
|
|
|
|
|
|
|
|
|
|
s = pad(self, fill, 0, '0');
|
|
|
|
|
|
|
|
|
|
if (s == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
p = PyString_AS_STRING(s);
|
|
|
|
|
if (p[fill] == '+' || p[fill] == '-') {
|
|
|
|
|
/* move sign to beginning of string */
|
|
|
|
|
p[0] = p[fill];
|
|
|
|
|
p[fill] = '0';
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return (PyObject*) s;
|
|
|
|
|
}
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(isspace__doc__,
|
2003-10-18 17:55:08 +08:00
|
|
|
|
"S.isspace() -> bool\n\
|
|
|
|
|
\n\
|
|
|
|
|
Return True if all characters in S are whitespace\n\
|
|
|
|
|
and there is at least one character in S, False otherwise.");
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
static PyObject*
|
2001-08-16 21:15:00 +08:00
|
|
|
|
string_isspace(PyStringObject *self)
|
2000-03-11 06:55:18 +08:00
|
|
|
|
{
|
2000-07-09 15:04:36 +08:00
|
|
|
|
register const unsigned char *p
|
|
|
|
|
= (unsigned char *) PyString_AS_STRING(self);
|
2000-05-06 04:44:24 +08:00
|
|
|
|
register const unsigned char *e;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
/* Shortcut for single character strings */
|
|
|
|
|
if (PyString_GET_SIZE(self) == 1 &&
|
|
|
|
|
isspace(*p))
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(1);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
2000-06-14 17:18:32 +08:00
|
|
|
|
/* Special case for empty strings */
|
|
|
|
|
if (PyString_GET_SIZE(self) == 0)
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-06-14 17:18:32 +08:00
|
|
|
|
|
2000-03-11 06:55:18 +08:00
|
|
|
|
e = p + PyString_GET_SIZE(self);
|
|
|
|
|
for (; p < e; p++) {
|
|
|
|
|
if (!isspace(*p))
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
}
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(1);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(isalpha__doc__,
|
2002-04-04 06:41:51 +08:00
|
|
|
|
"S.isalpha() -> bool\n\
|
2000-07-05 17:47:46 +08:00
|
|
|
|
\n\
|
2003-10-18 17:55:08 +08:00
|
|
|
|
Return True if all characters in S are alphabetic\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
and there is at least one character in S, False otherwise.");
|
2000-07-05 17:47:46 +08:00
|
|
|
|
|
|
|
|
|
static PyObject*
|
2001-08-16 21:15:00 +08:00
|
|
|
|
string_isalpha(PyStringObject *self)
|
2000-07-05 17:47:46 +08:00
|
|
|
|
{
|
2000-07-09 15:04:36 +08:00
|
|
|
|
register const unsigned char *p
|
|
|
|
|
= (unsigned char *) PyString_AS_STRING(self);
|
2000-07-05 17:47:46 +08:00
|
|
|
|
register const unsigned char *e;
|
|
|
|
|
|
|
|
|
|
/* Shortcut for single character strings */
|
|
|
|
|
if (PyString_GET_SIZE(self) == 1 &&
|
|
|
|
|
isalpha(*p))
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(1);
|
2000-07-05 17:47:46 +08:00
|
|
|
|
|
|
|
|
|
/* Special case for empty strings */
|
|
|
|
|
if (PyString_GET_SIZE(self) == 0)
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-07-05 17:47:46 +08:00
|
|
|
|
|
|
|
|
|
e = p + PyString_GET_SIZE(self);
|
|
|
|
|
for (; p < e; p++) {
|
|
|
|
|
if (!isalpha(*p))
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-07-05 17:47:46 +08:00
|
|
|
|
}
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(1);
|
2000-07-05 17:47:46 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(isalnum__doc__,
|
2002-04-04 06:41:51 +08:00
|
|
|
|
"S.isalnum() -> bool\n\
|
2000-07-05 17:47:46 +08:00
|
|
|
|
\n\
|
2003-10-18 17:55:08 +08:00
|
|
|
|
Return True if all characters in S are alphanumeric\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
and there is at least one character in S, False otherwise.");
|
2000-07-05 17:47:46 +08:00
|
|
|
|
|
|
|
|
|
static PyObject*
|
2001-08-16 21:15:00 +08:00
|
|
|
|
string_isalnum(PyStringObject *self)
|
2000-07-05 17:47:46 +08:00
|
|
|
|
{
|
2000-07-09 15:04:36 +08:00
|
|
|
|
register const unsigned char *p
|
|
|
|
|
= (unsigned char *) PyString_AS_STRING(self);
|
2000-07-05 17:47:46 +08:00
|
|
|
|
register const unsigned char *e;
|
|
|
|
|
|
|
|
|
|
/* Shortcut for single character strings */
|
|
|
|
|
if (PyString_GET_SIZE(self) == 1 &&
|
|
|
|
|
isalnum(*p))
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(1);
|
2000-07-05 17:47:46 +08:00
|
|
|
|
|
|
|
|
|
/* Special case for empty strings */
|
|
|
|
|
if (PyString_GET_SIZE(self) == 0)
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-07-05 17:47:46 +08:00
|
|
|
|
|
|
|
|
|
e = p + PyString_GET_SIZE(self);
|
|
|
|
|
for (; p < e; p++) {
|
|
|
|
|
if (!isalnum(*p))
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-07-05 17:47:46 +08:00
|
|
|
|
}
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(1);
|
2000-07-05 17:47:46 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(isdigit__doc__,
|
2002-04-04 06:41:51 +08:00
|
|
|
|
"S.isdigit() -> bool\n\
|
2000-03-11 06:55:18 +08:00
|
|
|
|
\n\
|
2003-10-18 17:55:08 +08:00
|
|
|
|
Return True if all characters in S are digits\n\
|
|
|
|
|
and there is at least one character in S, False otherwise.");
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
static PyObject*
|
2001-08-16 21:15:00 +08:00
|
|
|
|
string_isdigit(PyStringObject *self)
|
2000-03-11 06:55:18 +08:00
|
|
|
|
{
|
2000-07-09 15:04:36 +08:00
|
|
|
|
register const unsigned char *p
|
|
|
|
|
= (unsigned char *) PyString_AS_STRING(self);
|
2000-05-06 04:44:24 +08:00
|
|
|
|
register const unsigned char *e;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
/* Shortcut for single character strings */
|
|
|
|
|
if (PyString_GET_SIZE(self) == 1 &&
|
|
|
|
|
isdigit(*p))
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(1);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
2000-06-14 17:18:32 +08:00
|
|
|
|
/* Special case for empty strings */
|
|
|
|
|
if (PyString_GET_SIZE(self) == 0)
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-06-14 17:18:32 +08:00
|
|
|
|
|
2000-03-11 06:55:18 +08:00
|
|
|
|
e = p + PyString_GET_SIZE(self);
|
|
|
|
|
for (; p < e; p++) {
|
|
|
|
|
if (!isdigit(*p))
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
}
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(1);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(islower__doc__,
|
2002-04-04 06:41:51 +08:00
|
|
|
|
"S.islower() -> bool\n\
|
2000-03-11 06:55:18 +08:00
|
|
|
|
\n\
|
2002-04-04 06:41:51 +08:00
|
|
|
|
Return True if all cased characters in S are lowercase and there is\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
at least one cased character in S, False otherwise.");
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
static PyObject*
|
2001-08-16 21:15:00 +08:00
|
|
|
|
string_islower(PyStringObject *self)
|
2000-03-11 06:55:18 +08:00
|
|
|
|
{
|
2000-07-09 15:04:36 +08:00
|
|
|
|
register const unsigned char *p
|
|
|
|
|
= (unsigned char *) PyString_AS_STRING(self);
|
2000-05-06 04:44:24 +08:00
|
|
|
|
register const unsigned char *e;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
int cased;
|
|
|
|
|
|
|
|
|
|
/* Shortcut for single character strings */
|
|
|
|
|
if (PyString_GET_SIZE(self) == 1)
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(islower(*p) != 0);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
2000-06-14 17:18:32 +08:00
|
|
|
|
/* Special case for empty strings */
|
|
|
|
|
if (PyString_GET_SIZE(self) == 0)
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-06-14 17:18:32 +08:00
|
|
|
|
|
2000-03-11 06:55:18 +08:00
|
|
|
|
e = p + PyString_GET_SIZE(self);
|
|
|
|
|
cased = 0;
|
|
|
|
|
for (; p < e; p++) {
|
|
|
|
|
if (isupper(*p))
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (!cased && islower(*p))
|
|
|
|
|
cased = 1;
|
|
|
|
|
}
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(cased);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(isupper__doc__,
|
2002-04-04 06:41:51 +08:00
|
|
|
|
"S.isupper() -> bool\n\
|
2000-03-11 06:55:18 +08:00
|
|
|
|
\n\
|
2003-10-18 17:55:08 +08:00
|
|
|
|
Return True if all cased characters in S are uppercase and there is\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
at least one cased character in S, False otherwise.");
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
static PyObject*
|
2001-08-16 21:15:00 +08:00
|
|
|
|
string_isupper(PyStringObject *self)
|
2000-03-11 06:55:18 +08:00
|
|
|
|
{
|
2000-07-09 15:04:36 +08:00
|
|
|
|
register const unsigned char *p
|
|
|
|
|
= (unsigned char *) PyString_AS_STRING(self);
|
2000-05-06 04:44:24 +08:00
|
|
|
|
register const unsigned char *e;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
int cased;
|
|
|
|
|
|
|
|
|
|
/* Shortcut for single character strings */
|
|
|
|
|
if (PyString_GET_SIZE(self) == 1)
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(isupper(*p) != 0);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
2000-06-14 17:18:32 +08:00
|
|
|
|
/* Special case for empty strings */
|
|
|
|
|
if (PyString_GET_SIZE(self) == 0)
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-06-14 17:18:32 +08:00
|
|
|
|
|
2000-03-11 06:55:18 +08:00
|
|
|
|
e = p + PyString_GET_SIZE(self);
|
|
|
|
|
cased = 0;
|
|
|
|
|
for (; p < e; p++) {
|
|
|
|
|
if (islower(*p))
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
else if (!cased && isupper(*p))
|
|
|
|
|
cased = 1;
|
|
|
|
|
}
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(cased);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(istitle__doc__,
|
2002-04-04 06:41:51 +08:00
|
|
|
|
"S.istitle() -> bool\n\
|
2000-03-11 06:55:18 +08:00
|
|
|
|
\n\
|
2003-10-18 17:55:08 +08:00
|
|
|
|
Return True if S is a titlecased string and there is at least one\n\
|
|
|
|
|
character in S, i.e. uppercase characters may only follow uncased\n\
|
|
|
|
|
characters and lowercase characters only cased ones. Return False\n\
|
|
|
|
|
otherwise.");
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
static PyObject*
|
2001-08-16 21:15:00 +08:00
|
|
|
|
string_istitle(PyStringObject *self, PyObject *uncased)
|
2000-03-11 06:55:18 +08:00
|
|
|
|
{
|
2000-07-09 15:04:36 +08:00
|
|
|
|
register const unsigned char *p
|
|
|
|
|
= (unsigned char *) PyString_AS_STRING(self);
|
2000-05-06 04:44:24 +08:00
|
|
|
|
register const unsigned char *e;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
int cased, previous_is_cased;
|
|
|
|
|
|
|
|
|
|
/* Shortcut for single character strings */
|
|
|
|
|
if (PyString_GET_SIZE(self) == 1)
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(isupper(*p) != 0);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
2000-06-14 17:18:32 +08:00
|
|
|
|
/* Special case for empty strings */
|
|
|
|
|
if (PyString_GET_SIZE(self) == 0)
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-06-14 17:18:32 +08:00
|
|
|
|
|
2000-03-11 06:55:18 +08:00
|
|
|
|
e = p + PyString_GET_SIZE(self);
|
|
|
|
|
cased = 0;
|
|
|
|
|
previous_is_cased = 0;
|
|
|
|
|
for (; p < e; p++) {
|
2000-05-06 04:44:24 +08:00
|
|
|
|
register const unsigned char ch = *p;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
if (isupper(ch)) {
|
|
|
|
|
if (previous_is_cased)
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
previous_is_cased = 1;
|
|
|
|
|
cased = 1;
|
|
|
|
|
}
|
|
|
|
|
else if (islower(ch)) {
|
|
|
|
|
if (!previous_is_cased)
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(0);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
previous_is_cased = 1;
|
|
|
|
|
cased = 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
previous_is_cased = 0;
|
|
|
|
|
}
|
2002-04-04 06:41:51 +08:00
|
|
|
|
return PyBool_FromLong(cased);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(splitlines__doc__,
|
2001-10-13 23:57:55 +08:00
|
|
|
|
"S.splitlines([keepends]) -> list of strings\n\
|
2000-03-11 06:55:18 +08:00
|
|
|
|
\n\
|
|
|
|
|
Return a list of the lines in S, breaking at line boundaries.\n\
|
2000-04-11 23:39:26 +08:00
|
|
|
|
Line breaks are not included in the resulting list unless keepends\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
is given and true.");
|
2000-03-11 06:55:18 +08:00
|
|
|
|
|
|
|
|
|
static PyObject*
|
|
|
|
|
string_splitlines(PyStringObject *self, PyObject *args)
|
|
|
|
|
{
|
|
|
|
|
register int i;
|
|
|
|
|
register int j;
|
|
|
|
|
int len;
|
2000-04-11 23:39:26 +08:00
|
|
|
|
int keepends = 0;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
PyObject *list;
|
|
|
|
|
PyObject *str;
|
|
|
|
|
char *data;
|
|
|
|
|
|
2000-04-11 23:39:26 +08:00
|
|
|
|
if (!PyArg_ParseTuple(args, "|i:splitlines", &keepends))
|
2000-03-11 06:55:18 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
data = PyString_AS_STRING(self);
|
|
|
|
|
len = PyString_GET_SIZE(self);
|
|
|
|
|
|
|
|
|
|
list = PyList_New(0);
|
|
|
|
|
if (!list)
|
|
|
|
|
goto onError;
|
|
|
|
|
|
|
|
|
|
for (i = j = 0; i < len; ) {
|
2000-04-11 23:39:26 +08:00
|
|
|
|
int eol;
|
|
|
|
|
|
2000-03-11 06:55:18 +08:00
|
|
|
|
/* Find a line and append it */
|
|
|
|
|
while (i < len && data[i] != '\n' && data[i] != '\r')
|
|
|
|
|
i++;
|
|
|
|
|
|
|
|
|
|
/* Skip the line break reading CRLF as one line break */
|
2000-04-11 23:39:26 +08:00
|
|
|
|
eol = i;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
if (i < len) {
|
|
|
|
|
if (data[i] == '\r' && i + 1 < len &&
|
|
|
|
|
data[i+1] == '\n')
|
|
|
|
|
i += 2;
|
|
|
|
|
else
|
|
|
|
|
i++;
|
2000-04-11 23:39:26 +08:00
|
|
|
|
if (keepends)
|
|
|
|
|
eol = i;
|
2000-03-11 06:55:18 +08:00
|
|
|
|
}
|
2000-04-11 23:39:26 +08:00
|
|
|
|
SPLIT_APPEND(data, j, eol);
|
2000-03-11 06:55:18 +08:00
|
|
|
|
j = i;
|
|
|
|
|
}
|
|
|
|
|
if (j < len) {
|
|
|
|
|
SPLIT_APPEND(data, j, len);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return list;
|
|
|
|
|
|
|
|
|
|
onError:
|
|
|
|
|
Py_DECREF(list);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#undef SPLIT_APPEND
|
|
|
|
|
|
2003-01-30 01:58:45 +08:00
|
|
|
|
static PyObject *
|
|
|
|
|
string_getnewargs(PyStringObject *v)
|
|
|
|
|
{
|
|
|
|
|
return Py_BuildValue("(s#)", v->ob_sval, v->ob_size);
|
|
|
|
|
}
|
|
|
|
|
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
2001-04-28 13:38:26 +08:00
|
|
|
|
static PyMethodDef
|
1999-10-13 03:54:53 +08:00
|
|
|
|
string_methods[] = {
|
2000-03-11 06:55:18 +08:00
|
|
|
|
/* Counterparts of the obsolete stropmodule functions; except
|
|
|
|
|
string.maketrans(). */
|
2002-04-15 21:48:52 +08:00
|
|
|
|
{"join", (PyCFunction)string_join, METH_O, join__doc__},
|
|
|
|
|
{"split", (PyCFunction)string_split, METH_VARARGS, split__doc__},
|
2003-12-16 02:49:53 +08:00
|
|
|
|
{"rsplit", (PyCFunction)string_rsplit, METH_VARARGS, rsplit__doc__},
|
2002-04-15 21:48:52 +08:00
|
|
|
|
{"lower", (PyCFunction)string_lower, METH_NOARGS, lower__doc__},
|
|
|
|
|
{"upper", (PyCFunction)string_upper, METH_NOARGS, upper__doc__},
|
2001-08-16 21:15:00 +08:00
|
|
|
|
{"islower", (PyCFunction)string_islower, METH_NOARGS, islower__doc__},
|
|
|
|
|
{"isupper", (PyCFunction)string_isupper, METH_NOARGS, isupper__doc__},
|
|
|
|
|
{"isspace", (PyCFunction)string_isspace, METH_NOARGS, isspace__doc__},
|
|
|
|
|
{"isdigit", (PyCFunction)string_isdigit, METH_NOARGS, isdigit__doc__},
|
|
|
|
|
{"istitle", (PyCFunction)string_istitle, METH_NOARGS, istitle__doc__},
|
|
|
|
|
{"isalpha", (PyCFunction)string_isalpha, METH_NOARGS, isalpha__doc__},
|
|
|
|
|
{"isalnum", (PyCFunction)string_isalnum, METH_NOARGS, isalnum__doc__},
|
2002-04-15 21:48:52 +08:00
|
|
|
|
{"capitalize", (PyCFunction)string_capitalize, METH_NOARGS,
|
|
|
|
|
capitalize__doc__},
|
|
|
|
|
{"count", (PyCFunction)string_count, METH_VARARGS, count__doc__},
|
|
|
|
|
{"endswith", (PyCFunction)string_endswith, METH_VARARGS,
|
|
|
|
|
endswith__doc__},
|
|
|
|
|
{"find", (PyCFunction)string_find, METH_VARARGS, find__doc__},
|
|
|
|
|
{"index", (PyCFunction)string_index, METH_VARARGS, index__doc__},
|
|
|
|
|
{"lstrip", (PyCFunction)string_lstrip, METH_VARARGS, lstrip__doc__},
|
|
|
|
|
{"replace", (PyCFunction)string_replace, METH_VARARGS, replace__doc__},
|
|
|
|
|
{"rfind", (PyCFunction)string_rfind, METH_VARARGS, rfind__doc__},
|
|
|
|
|
{"rindex", (PyCFunction)string_rindex, METH_VARARGS, rindex__doc__},
|
|
|
|
|
{"rstrip", (PyCFunction)string_rstrip, METH_VARARGS, rstrip__doc__},
|
|
|
|
|
{"startswith", (PyCFunction)string_startswith, METH_VARARGS,
|
|
|
|
|
startswith__doc__},
|
|
|
|
|
{"strip", (PyCFunction)string_strip, METH_VARARGS, strip__doc__},
|
|
|
|
|
{"swapcase", (PyCFunction)string_swapcase, METH_NOARGS,
|
|
|
|
|
swapcase__doc__},
|
|
|
|
|
{"translate", (PyCFunction)string_translate, METH_VARARGS,
|
|
|
|
|
translate__doc__},
|
|
|
|
|
{"title", (PyCFunction)string_title, METH_NOARGS, title__doc__},
|
|
|
|
|
{"ljust", (PyCFunction)string_ljust, METH_VARARGS, ljust__doc__},
|
|
|
|
|
{"rjust", (PyCFunction)string_rjust, METH_VARARGS, rjust__doc__},
|
|
|
|
|
{"center", (PyCFunction)string_center, METH_VARARGS, center__doc__},
|
|
|
|
|
{"zfill", (PyCFunction)string_zfill, METH_VARARGS, zfill__doc__},
|
|
|
|
|
{"encode", (PyCFunction)string_encode, METH_VARARGS, encode__doc__},
|
|
|
|
|
{"decode", (PyCFunction)string_decode, METH_VARARGS, decode__doc__},
|
|
|
|
|
{"expandtabs", (PyCFunction)string_expandtabs, METH_VARARGS,
|
|
|
|
|
expandtabs__doc__},
|
|
|
|
|
{"splitlines", (PyCFunction)string_splitlines, METH_VARARGS,
|
|
|
|
|
splitlines__doc__},
|
2003-01-30 01:58:45 +08:00
|
|
|
|
{"__getnewargs__", (PyCFunction)string_getnewargs, METH_NOARGS},
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{NULL, NULL} /* sentinel */
|
|
|
|
|
};
|
|
|
|
|
|
2002-07-18 00:30:39 +08:00
|
|
|
|
static PyObject *
|
2001-08-30 11:11:59 +08:00
|
|
|
|
str_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
|
|
|
|
|
|
1999-10-13 03:54:53 +08:00
|
|
|
|
static PyObject *
|
2001-08-02 12:15:00 +08:00
|
|
|
|
string_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
1999-10-13 03:54:53 +08:00
|
|
|
|
{
|
2001-08-02 12:15:00 +08:00
|
|
|
|
PyObject *x = NULL;
|
|
|
|
|
static char *kwlist[] = {"object", 0};
|
|
|
|
|
|
2001-08-30 11:11:59 +08:00
|
|
|
|
if (type != &PyString_Type)
|
|
|
|
|
return str_subtype_new(type, args, kwds);
|
2001-08-02 12:15:00 +08:00
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:str", kwlist, &x))
|
|
|
|
|
return NULL;
|
|
|
|
|
if (x == NULL)
|
|
|
|
|
return PyString_FromString("");
|
|
|
|
|
return PyObject_Str(x);
|
1999-10-13 03:54:53 +08:00
|
|
|
|
}
|
|
|
|
|
|
2001-08-30 11:11:59 +08:00
|
|
|
|
static PyObject *
|
|
|
|
|
str_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|
|
|
|
{
|
2001-09-12 13:18:58 +08:00
|
|
|
|
PyObject *tmp, *pnew;
|
2001-08-30 11:11:59 +08:00
|
|
|
|
int n;
|
|
|
|
|
|
|
|
|
|
assert(PyType_IsSubtype(type, &PyString_Type));
|
|
|
|
|
tmp = string_new(&PyString_Type, args, kwds);
|
|
|
|
|
if (tmp == NULL)
|
|
|
|
|
return NULL;
|
2001-09-11 09:41:59 +08:00
|
|
|
|
assert(PyString_CheckExact(tmp));
|
2001-09-12 13:18:58 +08:00
|
|
|
|
n = PyString_GET_SIZE(tmp);
|
|
|
|
|
pnew = type->tp_alloc(type, n);
|
|
|
|
|
if (pnew != NULL) {
|
|
|
|
|
memcpy(PyString_AS_STRING(pnew), PyString_AS_STRING(tmp), n+1);
|
|
|
|
|
((PyStringObject *)pnew)->ob_shash =
|
|
|
|
|
((PyStringObject *)tmp)->ob_shash;
|
2002-08-20 05:43:18 +08:00
|
|
|
|
((PyStringObject *)pnew)->ob_sstate = SSTATE_NOT_INTERNED;
|
2001-09-12 13:18:58 +08:00
|
|
|
|
}
|
2001-09-01 00:11:15 +08:00
|
|
|
|
Py_DECREF(tmp);
|
2001-09-12 13:18:58 +08:00
|
|
|
|
return pnew;
|
2001-08-30 11:11:59 +08:00
|
|
|
|
}
|
|
|
|
|
|
2002-05-25 03:01:59 +08:00
|
|
|
|
static PyObject *
|
|
|
|
|
basestring_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|
|
|
|
{
|
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
2002-06-01 03:58:02 +08:00
|
|
|
|
"The basestring type cannot be instantiated");
|
2002-05-25 03:01:59 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2002-11-19 00:09:38 +08:00
|
|
|
|
static PyObject *
|
|
|
|
|
string_mod(PyObject *v, PyObject *w)
|
|
|
|
|
{
|
|
|
|
|
if (!PyString_Check(v)) {
|
|
|
|
|
Py_INCREF(Py_NotImplemented);
|
|
|
|
|
return Py_NotImplemented;
|
|
|
|
|
}
|
|
|
|
|
return PyString_Format(v, w);
|
|
|
|
|
}
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(basestring_doc,
|
|
|
|
|
"Type basestring cannot be instantiated; it is the base for str and unicode.");
|
2002-05-25 03:01:59 +08:00
|
|
|
|
|
2002-11-19 00:09:38 +08:00
|
|
|
|
static PyNumberMethods string_as_number = {
|
|
|
|
|
0, /*nb_add*/
|
|
|
|
|
0, /*nb_subtract*/
|
|
|
|
|
0, /*nb_multiply*/
|
|
|
|
|
0, /*nb_divide*/
|
|
|
|
|
string_mod, /*nb_remainder*/
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2002-05-25 03:01:59 +08:00
|
|
|
|
PyTypeObject PyBaseString_Type = {
|
|
|
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
|
|
|
0,
|
2002-06-01 03:58:02 +08:00
|
|
|
|
"basestring",
|
2002-05-25 03:01:59 +08:00
|
|
|
|
0,
|
|
|
|
|
0,
|
|
|
|
|
0, /* tp_dealloc */
|
|
|
|
|
0, /* tp_print */
|
|
|
|
|
0, /* tp_getattr */
|
|
|
|
|
0, /* tp_setattr */
|
|
|
|
|
0, /* tp_compare */
|
|
|
|
|
0, /* tp_repr */
|
|
|
|
|
0, /* tp_as_number */
|
|
|
|
|
0, /* tp_as_sequence */
|
|
|
|
|
0, /* tp_as_mapping */
|
|
|
|
|
0, /* tp_hash */
|
|
|
|
|
0, /* tp_call */
|
|
|
|
|
0, /* tp_str */
|
|
|
|
|
0, /* tp_getattro */
|
|
|
|
|
0, /* tp_setattro */
|
|
|
|
|
0, /* tp_as_buffer */
|
|
|
|
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
|
|
|
|
|
basestring_doc, /* tp_doc */
|
|
|
|
|
0, /* tp_traverse */
|
|
|
|
|
0, /* tp_clear */
|
|
|
|
|
0, /* tp_richcompare */
|
|
|
|
|
0, /* tp_weaklistoffset */
|
|
|
|
|
0, /* tp_iter */
|
|
|
|
|
0, /* tp_iternext */
|
|
|
|
|
0, /* tp_methods */
|
|
|
|
|
0, /* tp_members */
|
|
|
|
|
0, /* tp_getset */
|
|
|
|
|
&PyBaseObject_Type, /* tp_base */
|
|
|
|
|
0, /* tp_dict */
|
|
|
|
|
0, /* tp_descr_get */
|
|
|
|
|
0, /* tp_descr_set */
|
|
|
|
|
0, /* tp_dictoffset */
|
|
|
|
|
0, /* tp_init */
|
|
|
|
|
0, /* tp_alloc */
|
|
|
|
|
basestring_new, /* tp_new */
|
|
|
|
|
0, /* tp_free */
|
|
|
|
|
};
|
|
|
|
|
|
2002-06-14 04:33:02 +08:00
|
|
|
|
PyDoc_STRVAR(string_doc,
|
2001-08-02 12:15:00 +08:00
|
|
|
|
"str(object) -> string\n\
|
|
|
|
|
\n\
|
|
|
|
|
Return a nice string representation of the object.\n\
|
2002-06-14 04:33:02 +08:00
|
|
|
|
If the argument is a string, the return value is the same object.");
|
1999-10-13 03:54:53 +08:00
|
|
|
|
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyTypeObject PyString_Type = {
|
|
|
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
0,
|
2001-08-02 12:15:00 +08:00
|
|
|
|
"str",
|
1997-05-02 11:12:38 +08:00
|
|
|
|
sizeof(PyStringObject),
|
1990-10-14 20:07:46 +08:00
|
|
|
|
sizeof(char),
|
2001-08-02 12:15:00 +08:00
|
|
|
|
(destructor)string_dealloc, /* tp_dealloc */
|
|
|
|
|
(printfunc)string_print, /* tp_print */
|
|
|
|
|
0, /* tp_getattr */
|
|
|
|
|
0, /* tp_setattr */
|
|
|
|
|
0, /* tp_compare */
|
|
|
|
|
(reprfunc)string_repr, /* tp_repr */
|
2002-11-19 00:09:38 +08:00
|
|
|
|
&string_as_number, /* tp_as_number */
|
2001-08-02 12:15:00 +08:00
|
|
|
|
&string_as_sequence, /* tp_as_sequence */
|
2002-06-11 18:55:12 +08:00
|
|
|
|
&string_as_mapping, /* tp_as_mapping */
|
2001-08-02 12:15:00 +08:00
|
|
|
|
(hashfunc)string_hash, /* tp_hash */
|
|
|
|
|
0, /* tp_call */
|
|
|
|
|
(reprfunc)string_str, /* tp_str */
|
|
|
|
|
PyObject_GenericGetAttr, /* tp_getattro */
|
|
|
|
|
0, /* tp_setattro */
|
|
|
|
|
&string_as_buffer, /* tp_as_buffer */
|
2002-11-19 00:09:38 +08:00
|
|
|
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES |
|
|
|
|
|
Py_TPFLAGS_BASETYPE, /* tp_flags */
|
2001-08-02 12:15:00 +08:00
|
|
|
|
string_doc, /* tp_doc */
|
|
|
|
|
0, /* tp_traverse */
|
|
|
|
|
0, /* tp_clear */
|
|
|
|
|
(richcmpfunc)string_richcompare, /* tp_richcompare */
|
|
|
|
|
0, /* tp_weaklistoffset */
|
|
|
|
|
0, /* tp_iter */
|
|
|
|
|
0, /* tp_iternext */
|
|
|
|
|
string_methods, /* tp_methods */
|
|
|
|
|
0, /* tp_members */
|
|
|
|
|
0, /* tp_getset */
|
2002-05-25 03:01:59 +08:00
|
|
|
|
&PyBaseString_Type, /* tp_base */
|
2001-08-02 12:15:00 +08:00
|
|
|
|
0, /* tp_dict */
|
|
|
|
|
0, /* tp_descr_get */
|
|
|
|
|
0, /* tp_descr_set */
|
|
|
|
|
0, /* tp_dictoffset */
|
|
|
|
|
0, /* tp_init */
|
|
|
|
|
0, /* tp_alloc */
|
|
|
|
|
string_new, /* tp_new */
|
2002-04-12 11:05:19 +08:00
|
|
|
|
PyObject_Del, /* tp_free */
|
1990-10-14 20:07:46 +08:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
void
|
2000-07-09 15:04:36 +08:00
|
|
|
|
PyString_Concat(register PyObject **pv, register PyObject *w)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
{
|
1997-05-02 11:12:38 +08:00
|
|
|
|
register PyObject *v;
|
1994-08-30 16:19:36 +08:00
|
|
|
|
if (*pv == NULL)
|
|
|
|
|
return;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
if (w == NULL || !PyString_Check(*pv)) {
|
|
|
|
|
Py_DECREF(*pv);
|
1994-08-30 16:19:36 +08:00
|
|
|
|
*pv = NULL;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
return;
|
1994-08-30 16:19:36 +08:00
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
v = string_concat((PyStringObject *) *pv, w);
|
|
|
|
|
Py_DECREF(*pv);
|
1990-10-14 20:07:46 +08:00
|
|
|
|
*pv = v;
|
|
|
|
|
}
|
|
|
|
|
|
1994-08-30 16:19:36 +08:00
|
|
|
|
void
|
2000-07-09 15:04:36 +08:00
|
|
|
|
PyString_ConcatAndDel(register PyObject **pv, register PyObject *w)
|
1994-08-30 16:19:36 +08:00
|
|
|
|
{
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyString_Concat(pv, w);
|
|
|
|
|
Py_XDECREF(w);
|
1994-08-30 16:19:36 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
1990-10-14 20:07:46 +08:00
|
|
|
|
/* The following function breaks the notion that strings are immutable:
|
|
|
|
|
it changes the size of a string. We get away with this only if there
|
|
|
|
|
is only one module referencing the object. You can also think of it
|
|
|
|
|
as creating a new string object and destroying the old one, only
|
|
|
|
|
more efficiently. In any case, don't use this if the string may
|
2002-04-28 02:44:32 +08:00
|
|
|
|
already be known to some other part of the code...
|
|
|
|
|
Note that if there's not enough memory to resize the string, the original
|
|
|
|
|
string object at *pv is deallocated, *pv is set to NULL, an "out of
|
|
|
|
|
memory" exception is set, and -1 is returned. Else (on success) 0 is
|
|
|
|
|
returned, and the value in *pv may or may not be the same as on input.
|
|
|
|
|
As always, an extra byte is allocated for a trailing \0 byte (newsize
|
|
|
|
|
does *not* include that), and a trailing \0 byte is stored.
|
|
|
|
|
*/
|
1990-10-14 20:07:46 +08:00
|
|
|
|
|
|
|
|
|
int
|
2000-07-09 15:04:36 +08:00
|
|
|
|
_PyString_Resize(PyObject **pv, int newsize)
|
1990-10-14 20:07:46 +08:00
|
|
|
|
{
|
1997-05-02 11:12:38 +08:00
|
|
|
|
register PyObject *v;
|
|
|
|
|
register PyStringObject *sv;
|
1990-11-19 01:30:23 +08:00
|
|
|
|
v = *pv;
|
2004-08-08 04:58:32 +08:00
|
|
|
|
if (!PyString_Check(v) || v->ob_refcnt != 1 || newsize < 0 ||
|
|
|
|
|
PyString_CHECK_INTERNED(v)) {
|
1990-10-14 20:07:46 +08:00
|
|
|
|
*pv = 0;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_DECREF(v);
|
|
|
|
|
PyErr_BadInternalCall();
|
1990-10-22 06:15:08 +08:00
|
|
|
|
return -1;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
1990-11-19 01:30:23 +08:00
|
|
|
|
/* XXX UNREF/NEWREF interface should be more symmetrical */
|
object.h special-build macro minefield: renamed all the new lexical
helper macros to something saner, and used them appropriately in other
files too, to reduce #ifdef blocks.
classobject.c, instance_dealloc(): One of my worst Python Memories is
trying to fix this routine a few years ago when COUNT_ALLOCS was defined
but Py_TRACE_REFS wasn't. The special-build code here is way too
complicated. Now it's much simpler. Difference: in a Py_TRACE_REFS
build, the instance is no longer in the doubly-linked list of live
objects while its __del__ method is executing, and that may be visible
via sys.getobjects() called from a __del__ method. Tough -- the object
is presumed dead while its __del__ is executing anyway, and not calling
_Py_NewReference() at the start allows enormous code simplification.
typeobject.c, call_finalizer(): The special-build instance_dealloc()
pain apparently spread to here too via cut-'n-paste, and this is much
simpler now too. In addition, I didn't understand why this routine
was calling _PyObject_GC_TRACK() after a resurrection, since there's no
plausible way _PyObject_GC_UNTRACK() could have been called on the
object by this point. I suspect it was left over from pasting the
instance_delloc() code. Instead asserted that the object is still
tracked. Caution: I suspect we don't have a test that actually
exercises the subtype_dealloc() __del__-resurrected-me code.
2002-07-11 14:23:50 +08:00
|
|
|
|
_Py_DEC_REFTOTAL;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
_Py_ForgetReference(v);
|
|
|
|
|
*pv = (PyObject *)
|
2004-06-28 01:24:49 +08:00
|
|
|
|
PyObject_REALLOC((char *)v, sizeof(PyStringObject) + newsize);
|
1990-10-14 20:07:46 +08:00
|
|
|
|
if (*pv == NULL) {
|
2002-04-12 11:05:19 +08:00
|
|
|
|
PyObject_Del(v);
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyErr_NoMemory();
|
1990-10-22 06:15:08 +08:00
|
|
|
|
return -1;
|
1990-10-14 20:07:46 +08:00
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
_Py_NewReference(*pv);
|
|
|
|
|
sv = (PyStringObject *) *pv;
|
1990-11-19 01:30:23 +08:00
|
|
|
|
sv->ob_size = newsize;
|
|
|
|
|
sv->ob_sval[newsize] = '\0';
|
2004-10-26 09:52:37 +08:00
|
|
|
|
sv->ob_shash = -1; /* invalidate cached hash value */
|
1990-10-14 20:07:46 +08:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
1993-03-16 20:15:04 +08:00
|
|
|
|
|
|
|
|
|
/* Helpers for formatstring */
|
|
|
|
|
|
1997-05-02 11:12:38 +08:00
|
|
|
|
static PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
getnextarg(PyObject *args, int arglen, int *p_argidx)
|
1993-03-16 20:15:04 +08:00
|
|
|
|
{
|
|
|
|
|
int argidx = *p_argidx;
|
|
|
|
|
if (argidx < arglen) {
|
|
|
|
|
(*p_argidx)++;
|
|
|
|
|
if (arglen < 0)
|
|
|
|
|
return args;
|
|
|
|
|
else
|
1997-05-02 11:12:38 +08:00
|
|
|
|
return PyTuple_GetItem(args, argidx);
|
1993-03-16 20:15:04 +08:00
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
|
"not enough arguments for format string");
|
1993-03-16 20:15:04 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2000-09-21 13:43:11 +08:00
|
|
|
|
/* Format codes
|
|
|
|
|
* F_LJUST '-'
|
|
|
|
|
* F_SIGN '+'
|
|
|
|
|
* F_BLANK ' '
|
|
|
|
|
* F_ALT '#'
|
|
|
|
|
* F_ZERO '0'
|
|
|
|
|
*/
|
1993-03-16 20:15:04 +08:00
|
|
|
|
#define F_LJUST (1<<0)
|
|
|
|
|
#define F_SIGN (1<<1)
|
|
|
|
|
#define F_BLANK (1<<2)
|
|
|
|
|
#define F_ALT (1<<3)
|
|
|
|
|
#define F_ZERO (1<<4)
|
|
|
|
|
|
1997-01-22 00:12:09 +08:00
|
|
|
|
static int
|
2000-07-09 15:04:36 +08:00
|
|
|
|
formatfloat(char *buf, size_t buflen, int flags,
|
|
|
|
|
int prec, int type, PyObject *v)
|
1993-03-16 20:15:04 +08:00
|
|
|
|
{
|
2000-06-30 18:29:57 +08:00
|
|
|
|
/* fmt = '%#.' + `prec` + `type`
|
|
|
|
|
worst case length = 3 + 10 (len of INT_MAX) + 1 = 14 (use 20)*/
|
1993-03-16 20:15:04 +08:00
|
|
|
|
char fmt[20];
|
|
|
|
|
double x;
|
2002-07-29 00:44:23 +08:00
|
|
|
|
x = PyFloat_AsDouble(v);
|
|
|
|
|
if (x == -1.0 && PyErr_Occurred()) {
|
|
|
|
|
PyErr_SetString(PyExc_TypeError, "float argument required");
|
1997-01-22 00:12:09 +08:00
|
|
|
|
return -1;
|
2002-07-29 00:44:23 +08:00
|
|
|
|
}
|
1993-03-16 20:15:04 +08:00
|
|
|
|
if (prec < 0)
|
|
|
|
|
prec = 6;
|
|
|
|
|
if (type == 'f' && fabs(x)/1e25 >= 1e25)
|
|
|
|
|
type = 'g';
|
2002-12-30 03:44:06 +08:00
|
|
|
|
/* Worst case length calc to ensure no buffer overrun:
|
|
|
|
|
|
|
|
|
|
'g' formats:
|
2000-06-30 18:29:57 +08:00
|
|
|
|
fmt = %#.<prec>g
|
|
|
|
|
buf = '-' + [0-9]*prec + '.' + 'e+' + (longest exp
|
2001-04-28 13:38:26 +08:00
|
|
|
|
for any double rep.)
|
2000-06-30 18:29:57 +08:00
|
|
|
|
len = 1 + prec + 1 + 2 + 5 = 9 + prec
|
2002-12-30 03:44:06 +08:00
|
|
|
|
|
|
|
|
|
'f' formats:
|
|
|
|
|
buf = '-' + [0-9]*x + '.' + [0-9]*prec (with x < 50)
|
|
|
|
|
len = 1 + 50 + 1 + prec = 52 + prec
|
|
|
|
|
|
2000-06-30 18:29:57 +08:00
|
|
|
|
If prec=0 the effective precision is 1 (the leading digit is
|
2002-12-30 03:44:06 +08:00
|
|
|
|
always given), therefore increase the length by one.
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
if ((type == 'g' && buflen <= (size_t)10 + (size_t)prec) ||
|
|
|
|
|
(type == 'f' && buflen <= (size_t)53 + (size_t)prec)) {
|
2000-06-30 18:29:57 +08:00
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
2000-10-25 03:57:45 +08:00
|
|
|
|
"formatted float is too long (precision too large?)");
|
2000-06-30 18:29:57 +08:00
|
|
|
|
return -1;
|
|
|
|
|
}
|
2002-12-30 03:44:06 +08:00
|
|
|
|
PyOS_snprintf(fmt, sizeof(fmt), "%%%s.%d%c",
|
|
|
|
|
(flags&F_ALT) ? "#" : "",
|
|
|
|
|
prec, type);
|
2004-06-09 02:52:54 +08:00
|
|
|
|
PyOS_ascii_formatd(buf, buflen, fmt, x);
|
1997-01-22 00:12:09 +08:00
|
|
|
|
return strlen(buf);
|
1993-03-16 20:15:04 +08:00
|
|
|
|
}
|
|
|
|
|
|
2000-09-21 13:43:11 +08:00
|
|
|
|
/* _PyString_FormatLong emulates the format codes d, u, o, x and X, and
|
|
|
|
|
* the F_ALT flag, for Python's long (unbounded) ints. It's not used for
|
|
|
|
|
* Python's regular ints.
|
|
|
|
|
* Return value: a new PyString*, or NULL if error.
|
|
|
|
|
* . *pbuf is set to point into it,
|
|
|
|
|
* *plen set to the # of chars following that.
|
|
|
|
|
* Caller must decref it when done using pbuf.
|
|
|
|
|
* The string starting at *pbuf is of the form
|
|
|
|
|
* "-"? ("0x" | "0X")? digit+
|
|
|
|
|
* "0x"/"0X" are present only for x and X conversions, with F_ALT
|
2001-04-28 13:38:26 +08:00
|
|
|
|
* set in flags. The case of hex digits will be correct,
|
2000-09-21 13:43:11 +08:00
|
|
|
|
* There will be at least prec digits, zero-filled on the left if
|
|
|
|
|
* necessary to get that many.
|
|
|
|
|
* val object to be converted
|
|
|
|
|
* flags bitmask of format flags; only F_ALT is looked at
|
|
|
|
|
* prec minimum number of digits; 0-fill on left if needed
|
|
|
|
|
* type a character in [duoxX]; u acts the same as d
|
|
|
|
|
*
|
|
|
|
|
* CAUTION: o, x and X conversions on regular ints can never
|
|
|
|
|
* produce a '-' sign, but can for Python's unbounded ints.
|
|
|
|
|
*/
|
|
|
|
|
PyObject*
|
|
|
|
|
_PyString_FormatLong(PyObject *val, int flags, int prec, int type,
|
|
|
|
|
char **pbuf, int *plen)
|
|
|
|
|
{
|
|
|
|
|
PyObject *result = NULL;
|
|
|
|
|
char *buf;
|
|
|
|
|
int i;
|
|
|
|
|
int sign; /* 1 if '-', else 0 */
|
|
|
|
|
int len; /* number of characters */
|
|
|
|
|
int numdigits; /* len == numnondigits + numdigits */
|
|
|
|
|
int numnondigits = 0;
|
|
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
|
case 'd':
|
|
|
|
|
case 'u':
|
|
|
|
|
result = val->ob_type->tp_str(val);
|
|
|
|
|
break;
|
|
|
|
|
case 'o':
|
|
|
|
|
result = val->ob_type->tp_as_number->nb_oct(val);
|
|
|
|
|
break;
|
|
|
|
|
case 'x':
|
|
|
|
|
case 'X':
|
|
|
|
|
numnondigits = 2;
|
|
|
|
|
result = val->ob_type->tp_as_number->nb_hex(val);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
assert(!"'type' not in [duoxX]");
|
|
|
|
|
}
|
|
|
|
|
if (!result)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
/* To modify the string in-place, there can only be one reference. */
|
|
|
|
|
if (result->ob_refcnt != 1) {
|
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
buf = PyString_AsString(result);
|
|
|
|
|
len = PyString_Size(result);
|
|
|
|
|
if (buf[len-1] == 'L') {
|
|
|
|
|
--len;
|
|
|
|
|
buf[len] = '\0';
|
|
|
|
|
}
|
|
|
|
|
sign = buf[0] == '-';
|
|
|
|
|
numnondigits += sign;
|
|
|
|
|
numdigits = len - numnondigits;
|
|
|
|
|
assert(numdigits > 0);
|
|
|
|
|
|
2001-04-13 02:38:48 +08:00
|
|
|
|
/* Get rid of base marker unless F_ALT */
|
|
|
|
|
if ((flags & F_ALT) == 0) {
|
2000-09-21 13:43:11 +08:00
|
|
|
|
/* Need to skip 0x, 0X or 0. */
|
|
|
|
|
int skipped = 0;
|
|
|
|
|
switch (type) {
|
|
|
|
|
case 'o':
|
|
|
|
|
assert(buf[sign] == '0');
|
|
|
|
|
/* If 0 is only digit, leave it alone. */
|
|
|
|
|
if (numdigits > 1) {
|
|
|
|
|
skipped = 1;
|
|
|
|
|
--numdigits;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 'x':
|
|
|
|
|
case 'X':
|
|
|
|
|
assert(buf[sign] == '0');
|
|
|
|
|
assert(buf[sign + 1] == 'x');
|
|
|
|
|
skipped = 2;
|
|
|
|
|
numnondigits -= 2;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (skipped) {
|
|
|
|
|
buf += skipped;
|
|
|
|
|
len -= skipped;
|
|
|
|
|
if (sign)
|
|
|
|
|
buf[0] = '-';
|
|
|
|
|
}
|
|
|
|
|
assert(len == numnondigits + numdigits);
|
|
|
|
|
assert(numdigits > 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Fill with leading zeroes to meet minimum width. */
|
|
|
|
|
if (prec > numdigits) {
|
|
|
|
|
PyObject *r1 = PyString_FromStringAndSize(NULL,
|
|
|
|
|
numnondigits + prec);
|
|
|
|
|
char *b1;
|
|
|
|
|
if (!r1) {
|
|
|
|
|
Py_DECREF(result);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
b1 = PyString_AS_STRING(r1);
|
|
|
|
|
for (i = 0; i < numnondigits; ++i)
|
|
|
|
|
*b1++ = *buf++;
|
|
|
|
|
for (i = 0; i < prec - numdigits; i++)
|
|
|
|
|
*b1++ = '0';
|
|
|
|
|
for (i = 0; i < numdigits; i++)
|
|
|
|
|
*b1++ = *buf++;
|
|
|
|
|
*b1 = '\0';
|
|
|
|
|
Py_DECREF(result);
|
|
|
|
|
result = r1;
|
|
|
|
|
buf = PyString_AS_STRING(result);
|
|
|
|
|
len = numnondigits + prec;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Fix up case for hex conversions. */
|
|
|
|
|
switch (type) {
|
|
|
|
|
case 'x':
|
|
|
|
|
/* Need to convert all upper case letters to lower case. */
|
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
|
if (buf[i] >= 'A' && buf[i] <= 'F')
|
|
|
|
|
buf[i] += 'a'-'A';
|
|
|
|
|
break;
|
|
|
|
|
case 'X':
|
|
|
|
|
/* Need to convert 0x to 0X (and -0x to -0X). */
|
|
|
|
|
if (buf[sign + 1] == 'x')
|
|
|
|
|
buf[sign + 1] = 'X';
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
*pbuf = buf;
|
|
|
|
|
*plen = len;
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
1997-01-22 00:12:09 +08:00
|
|
|
|
static int
|
2000-07-09 15:04:36 +08:00
|
|
|
|
formatint(char *buf, size_t buflen, int flags,
|
|
|
|
|
int prec, int type, PyObject *v)
|
1993-03-16 20:15:04 +08:00
|
|
|
|
{
|
2000-06-30 18:29:57 +08:00
|
|
|
|
/* fmt = '%#.' + `prec` + 'l' + `type`
|
2000-09-21 13:43:11 +08:00
|
|
|
|
worst case length = 3 + 19 (worst len of INT_MAX on 64-bit machine)
|
|
|
|
|
+ 1 + 1 = 24 */
|
|
|
|
|
char fmt[64]; /* plenty big enough! */
|
2003-11-30 07:52:13 +08:00
|
|
|
|
char *sign;
|
1993-03-16 20:15:04 +08:00
|
|
|
|
long x;
|
2002-02-28 19:38:24 +08:00
|
|
|
|
|
2002-07-29 00:44:23 +08:00
|
|
|
|
x = PyInt_AsLong(v);
|
|
|
|
|
if (x == -1 && PyErr_Occurred()) {
|
|
|
|
|
PyErr_SetString(PyExc_TypeError, "int argument required");
|
1997-01-22 00:12:09 +08:00
|
|
|
|
return -1;
|
2002-07-29 00:44:23 +08:00
|
|
|
|
}
|
2003-11-30 07:52:13 +08:00
|
|
|
|
if (x < 0 && type == 'u') {
|
|
|
|
|
type = 'd';
|
2002-08-11 12:24:12 +08:00
|
|
|
|
}
|
2003-11-30 07:52:13 +08:00
|
|
|
|
if (x < 0 && (type == 'x' || type == 'X' || type == 'o'))
|
|
|
|
|
sign = "-";
|
|
|
|
|
else
|
|
|
|
|
sign = "";
|
1993-03-16 20:15:04 +08:00
|
|
|
|
if (prec < 0)
|
|
|
|
|
prec = 1;
|
2002-02-28 19:38:24 +08:00
|
|
|
|
|
|
|
|
|
if ((flags & F_ALT) &&
|
|
|
|
|
(type == 'x' || type == 'X')) {
|
2002-04-15 21:48:52 +08:00
|
|
|
|
/* When converting under %#x or %#X, there are a number
|
2002-02-28 19:38:24 +08:00
|
|
|
|
* of issues that cause pain:
|
|
|
|
|
* - when 0 is being converted, the C standard leaves off
|
|
|
|
|
* the '0x' or '0X', which is inconsistent with other
|
|
|
|
|
* %#x/%#X conversions and inconsistent with Python's
|
|
|
|
|
* hex() function
|
|
|
|
|
* - there are platforms that violate the standard and
|
|
|
|
|
* convert 0 with the '0x' or '0X'
|
|
|
|
|
* (Metrowerks, Compaq Tru64)
|
|
|
|
|
* - there are platforms that give '0x' when converting
|
2002-04-15 21:48:52 +08:00
|
|
|
|
* under %#X, but convert 0 in accordance with the
|
2002-02-28 19:38:24 +08:00
|
|
|
|
* standard (OS/2 EMX)
|
2002-04-15 21:48:52 +08:00
|
|
|
|
*
|
2002-02-28 19:38:24 +08:00
|
|
|
|
* We can achieve the desired consistency by inserting our
|
|
|
|
|
* own '0x' or '0X' prefix, and substituting %x/%X in place
|
|
|
|
|
* of %#x/%#X.
|
|
|
|
|
*
|
|
|
|
|
* Note that this is the same approach as used in
|
|
|
|
|
* formatint() in unicodeobject.c
|
|
|
|
|
*/
|
2003-11-30 07:52:13 +08:00
|
|
|
|
PyOS_snprintf(fmt, sizeof(fmt), "%s0%c%%.%dl%c",
|
|
|
|
|
sign, type, prec, type);
|
2002-02-28 19:38:24 +08:00
|
|
|
|
}
|
|
|
|
|
else {
|
2003-11-30 07:52:13 +08:00
|
|
|
|
PyOS_snprintf(fmt, sizeof(fmt), "%s%%%s.%dl%c",
|
|
|
|
|
sign, (flags&F_ALT) ? "#" : "",
|
2002-02-28 19:38:24 +08:00
|
|
|
|
prec, type);
|
|
|
|
|
}
|
|
|
|
|
|
2003-11-30 07:52:13 +08:00
|
|
|
|
/* buf = '+'/'-'/'' + '0'/'0x'/'' + '[0-9]'*max(prec, len(x in octal))
|
|
|
|
|
* worst case buf = '-0x' + [0-9]*prec, where prec >= 11
|
2002-02-28 19:38:24 +08:00
|
|
|
|
*/
|
2003-11-30 07:52:13 +08:00
|
|
|
|
if (buflen <= 14 || buflen <= (size_t)3 + (size_t)prec) {
|
2000-06-30 18:29:57 +08:00
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
2002-04-15 21:48:52 +08:00
|
|
|
|
"formatted integer is too long (precision too large?)");
|
2000-06-30 18:29:57 +08:00
|
|
|
|
return -1;
|
|
|
|
|
}
|
2003-11-30 07:52:13 +08:00
|
|
|
|
if (sign[0])
|
|
|
|
|
PyOS_snprintf(buf, buflen, fmt, -x);
|
|
|
|
|
else
|
|
|
|
|
PyOS_snprintf(buf, buflen, fmt, x);
|
1997-01-22 00:12:09 +08:00
|
|
|
|
return strlen(buf);
|
1993-03-16 20:15:04 +08:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-22 00:12:09 +08:00
|
|
|
|
static int
|
2000-07-09 15:04:36 +08:00
|
|
|
|
formatchar(char *buf, size_t buflen, PyObject *v)
|
1993-03-16 20:15:04 +08:00
|
|
|
|
{
|
2000-06-30 18:29:57 +08:00
|
|
|
|
/* presume that the buffer is at least 2 characters long */
|
1997-05-02 11:12:38 +08:00
|
|
|
|
if (PyString_Check(v)) {
|
|
|
|
|
if (!PyArg_Parse(v, "c;%c requires int or char", &buf[0]))
|
1997-01-22 00:12:09 +08:00
|
|
|
|
return -1;
|
1993-03-16 20:15:04 +08:00
|
|
|
|
}
|
|
|
|
|
else {
|
1997-05-02 11:12:38 +08:00
|
|
|
|
if (!PyArg_Parse(v, "b;%c requires int or char", &buf[0]))
|
1997-01-22 00:12:09 +08:00
|
|
|
|
return -1;
|
1993-03-16 20:15:04 +08:00
|
|
|
|
}
|
|
|
|
|
buf[1] = '\0';
|
1997-01-22 00:12:09 +08:00
|
|
|
|
return 1;
|
1993-03-16 20:15:04 +08:00
|
|
|
|
}
|
|
|
|
|
|
1994-08-30 16:19:36 +08:00
|
|
|
|
|
2000-06-30 18:29:57 +08:00
|
|
|
|
/* fmt%(v1,v2,...) is roughly equivalent to sprintf(fmt, v1, v2, ...)
|
|
|
|
|
|
|
|
|
|
FORMATBUFLEN is the length of the buffer in which the floats, ints, &
|
|
|
|
|
chars are formatted. XXX This is a magic number. Each formatting
|
|
|
|
|
routine does bounds checking to ensure no overflow, but a better
|
|
|
|
|
solution may be to malloc a buffer of appropriate size for each
|
|
|
|
|
format. For now, the current solution is sufficient.
|
|
|
|
|
*/
|
|
|
|
|
#define FORMATBUFLEN (size_t)120
|
1993-03-16 20:15:04 +08:00
|
|
|
|
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
PyString_Format(PyObject *format, PyObject *args)
|
1993-03-16 20:15:04 +08:00
|
|
|
|
{
|
|
|
|
|
char *fmt, *res;
|
|
|
|
|
int fmtcnt, rescnt, reslen, arglen, argidx;
|
1996-05-22 06:44:20 +08:00
|
|
|
|
int args_owned = 0;
|
2001-08-18 02:39:25 +08:00
|
|
|
|
PyObject *result, *orig_args;
|
|
|
|
|
#ifdef Py_USING_UNICODE
|
|
|
|
|
PyObject *v, *w;
|
|
|
|
|
#endif
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyObject *dict = NULL;
|
|
|
|
|
if (format == NULL || !PyString_Check(format) || args == NULL) {
|
|
|
|
|
PyErr_BadInternalCall();
|
1993-03-16 20:15:04 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2000-04-10 21:47:21 +08:00
|
|
|
|
orig_args = args;
|
2001-12-06 23:18:48 +08:00
|
|
|
|
fmt = PyString_AS_STRING(format);
|
|
|
|
|
fmtcnt = PyString_GET_SIZE(format);
|
1993-05-12 16:24:20 +08:00
|
|
|
|
reslen = rescnt = fmtcnt + 100;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
result = PyString_FromStringAndSize((char *)NULL, reslen);
|
1993-03-16 20:15:04 +08:00
|
|
|
|
if (result == NULL)
|
|
|
|
|
return NULL;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
res = PyString_AsString(result);
|
|
|
|
|
if (PyTuple_Check(args)) {
|
2001-12-06 23:18:48 +08:00
|
|
|
|
arglen = PyTuple_GET_SIZE(args);
|
1993-03-16 20:15:04 +08:00
|
|
|
|
argidx = 0;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
arglen = -1;
|
|
|
|
|
argidx = -2;
|
|
|
|
|
}
|
2002-11-13 07:01:12 +08:00
|
|
|
|
if (args->ob_type->tp_as_mapping && !PyTuple_Check(args) &&
|
|
|
|
|
!PyObject_TypeCheck(args, &PyBaseString_Type))
|
1994-08-30 16:19:36 +08:00
|
|
|
|
dict = args;
|
1993-03-16 20:15:04 +08:00
|
|
|
|
while (--fmtcnt >= 0) {
|
|
|
|
|
if (*fmt != '%') {
|
|
|
|
|
if (--rescnt < 0) {
|
1993-05-12 16:24:20 +08:00
|
|
|
|
rescnt = fmtcnt + 100;
|
|
|
|
|
reslen += rescnt;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
if (_PyString_Resize(&result, reslen) < 0)
|
1993-03-16 20:15:04 +08:00
|
|
|
|
return NULL;
|
2001-12-06 23:18:48 +08:00
|
|
|
|
res = PyString_AS_STRING(result)
|
1997-05-02 11:12:38 +08:00
|
|
|
|
+ reslen - rescnt;
|
1994-08-30 16:19:36 +08:00
|
|
|
|
--rescnt;
|
1993-03-16 20:15:04 +08:00
|
|
|
|
}
|
|
|
|
|
*res++ = *fmt++;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
/* Got a format specifier */
|
|
|
|
|
int flags = 0;
|
|
|
|
|
int width = -1;
|
|
|
|
|
int prec = -1;
|
1993-11-11 22:51:57 +08:00
|
|
|
|
int c = '\0';
|
1993-03-16 20:15:04 +08:00
|
|
|
|
int fill;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyObject *v = NULL;
|
|
|
|
|
PyObject *temp = NULL;
|
2000-06-30 18:29:57 +08:00
|
|
|
|
char *pbuf;
|
1993-03-16 20:15:04 +08:00
|
|
|
|
int sign;
|
|
|
|
|
int len;
|
2002-04-15 21:48:52 +08:00
|
|
|
|
char formatbuf[FORMATBUFLEN];
|
|
|
|
|
/* For format{float,int,char}() */
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-04-10 21:47:21 +08:00
|
|
|
|
char *fmt_start = fmt;
|
2001-05-02 22:21:53 +08:00
|
|
|
|
int argidx_start = argidx;
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2001-04-28 13:38:26 +08:00
|
|
|
|
|
1996-12-06 05:58:58 +08:00
|
|
|
|
fmt++;
|
1994-08-30 16:19:36 +08:00
|
|
|
|
if (*fmt == '(') {
|
|
|
|
|
char *keystart;
|
|
|
|
|
int keylen;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyObject *key;
|
1997-09-09 02:30:11 +08:00
|
|
|
|
int pcount = 1;
|
1994-08-30 16:19:36 +08:00
|
|
|
|
|
|
|
|
|
if (dict == NULL) {
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
2001-04-28 13:38:26 +08:00
|
|
|
|
"format requires a mapping");
|
1994-08-30 16:19:36 +08:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
++fmt;
|
|
|
|
|
--fmtcnt;
|
|
|
|
|
keystart = fmt;
|
1997-09-09 02:30:11 +08:00
|
|
|
|
/* Skip over balanced parentheses */
|
|
|
|
|
while (pcount > 0 && --fmtcnt >= 0) {
|
|
|
|
|
if (*fmt == ')')
|
|
|
|
|
--pcount;
|
|
|
|
|
else if (*fmt == '(')
|
|
|
|
|
++pcount;
|
1994-08-30 16:19:36 +08:00
|
|
|
|
fmt++;
|
1997-09-09 02:30:11 +08:00
|
|
|
|
}
|
|
|
|
|
keylen = fmt - keystart - 1;
|
|
|
|
|
if (fmtcnt < 0 || pcount > 0) {
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
1994-08-30 16:19:36 +08:00
|
|
|
|
"incomplete format key");
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
key = PyString_FromStringAndSize(keystart,
|
|
|
|
|
keylen);
|
1994-08-30 16:19:36 +08:00
|
|
|
|
if (key == NULL)
|
|
|
|
|
goto error;
|
1996-05-22 06:44:20 +08:00
|
|
|
|
if (args_owned) {
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_DECREF(args);
|
1996-05-22 06:44:20 +08:00
|
|
|
|
args_owned = 0;
|
|
|
|
|
}
|
|
|
|
|
args = PyObject_GetItem(dict, key);
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_DECREF(key);
|
1994-08-30 16:19:36 +08:00
|
|
|
|
if (args == NULL) {
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
1996-05-22 06:44:20 +08:00
|
|
|
|
args_owned = 1;
|
1994-08-30 16:19:36 +08:00
|
|
|
|
arglen = -1;
|
|
|
|
|
argidx = -2;
|
|
|
|
|
}
|
1993-03-16 20:15:04 +08:00
|
|
|
|
while (--fmtcnt >= 0) {
|
|
|
|
|
switch (c = *fmt++) {
|
|
|
|
|
case '-': flags |= F_LJUST; continue;
|
|
|
|
|
case '+': flags |= F_SIGN; continue;
|
|
|
|
|
case ' ': flags |= F_BLANK; continue;
|
|
|
|
|
case '#': flags |= F_ALT; continue;
|
|
|
|
|
case '0': flags |= F_ZERO; continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (c == '*') {
|
|
|
|
|
v = getnextarg(args, arglen, &argidx);
|
|
|
|
|
if (v == NULL)
|
|
|
|
|
goto error;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
if (!PyInt_Check(v)) {
|
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
|
"* wants int");
|
1993-03-16 20:15:04 +08:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
width = PyInt_AsLong(v);
|
1999-06-07 23:12:32 +08:00
|
|
|
|
if (width < 0) {
|
|
|
|
|
flags |= F_LJUST;
|
|
|
|
|
width = -width;
|
|
|
|
|
}
|
1993-03-16 20:15:04 +08:00
|
|
|
|
if (--fmtcnt >= 0)
|
|
|
|
|
c = *fmt++;
|
|
|
|
|
}
|
1995-02-11 01:00:37 +08:00
|
|
|
|
else if (c >= 0 && isdigit(c)) {
|
1993-03-16 20:15:04 +08:00
|
|
|
|
width = c - '0';
|
|
|
|
|
while (--fmtcnt >= 0) {
|
1995-02-11 01:00:37 +08:00
|
|
|
|
c = Py_CHARMASK(*fmt++);
|
1993-03-16 20:15:04 +08:00
|
|
|
|
if (!isdigit(c))
|
|
|
|
|
break;
|
|
|
|
|
if ((width*10) / 10 != width) {
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyErr_SetString(
|
|
|
|
|
PyExc_ValueError,
|
|
|
|
|
"width too big");
|
1993-03-16 20:15:04 +08:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
width = width*10 + (c - '0');
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (c == '.') {
|
|
|
|
|
prec = 0;
|
|
|
|
|
if (--fmtcnt >= 0)
|
|
|
|
|
c = *fmt++;
|
|
|
|
|
if (c == '*') {
|
|
|
|
|
v = getnextarg(args, arglen, &argidx);
|
|
|
|
|
if (v == NULL)
|
|
|
|
|
goto error;
|
1997-05-02 11:12:38 +08:00
|
|
|
|
if (!PyInt_Check(v)) {
|
|
|
|
|
PyErr_SetString(
|
|
|
|
|
PyExc_TypeError,
|
|
|
|
|
"* wants int");
|
1993-03-16 20:15:04 +08:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
prec = PyInt_AsLong(v);
|
1993-03-16 20:15:04 +08:00
|
|
|
|
if (prec < 0)
|
|
|
|
|
prec = 0;
|
|
|
|
|
if (--fmtcnt >= 0)
|
|
|
|
|
c = *fmt++;
|
|
|
|
|
}
|
1995-02-11 01:00:37 +08:00
|
|
|
|
else if (c >= 0 && isdigit(c)) {
|
1993-03-16 20:15:04 +08:00
|
|
|
|
prec = c - '0';
|
|
|
|
|
while (--fmtcnt >= 0) {
|
1995-02-11 01:00:37 +08:00
|
|
|
|
c = Py_CHARMASK(*fmt++);
|
1993-03-16 20:15:04 +08:00
|
|
|
|
if (!isdigit(c))
|
|
|
|
|
break;
|
|
|
|
|
if ((prec*10) / 10 != prec) {
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyErr_SetString(
|
|
|
|
|
PyExc_ValueError,
|
1993-03-16 20:15:04 +08:00
|
|
|
|
"prec too big");
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
prec = prec*10 + (c - '0');
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} /* prec */
|
|
|
|
|
if (fmtcnt >= 0) {
|
|
|
|
|
if (c == 'h' || c == 'l' || c == 'L') {
|
|
|
|
|
if (--fmtcnt >= 0)
|
|
|
|
|
c = *fmt++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (fmtcnt < 0) {
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
|
"incomplete format");
|
1993-03-16 20:15:04 +08:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
if (c != '%') {
|
|
|
|
|
v = getnextarg(args, arglen, &argidx);
|
|
|
|
|
if (v == NULL)
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
sign = 0;
|
|
|
|
|
fill = ' ';
|
|
|
|
|
switch (c) {
|
|
|
|
|
case '%':
|
2000-06-30 18:29:57 +08:00
|
|
|
|
pbuf = "%";
|
1993-03-16 20:15:04 +08:00
|
|
|
|
len = 1;
|
|
|
|
|
break;
|
|
|
|
|
case 's':
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-04-10 21:47:21 +08:00
|
|
|
|
if (PyUnicode_Check(v)) {
|
|
|
|
|
fmt = fmt_start;
|
2001-05-02 22:21:53 +08:00
|
|
|
|
argidx = argidx_start;
|
2000-04-10 21:47:21 +08:00
|
|
|
|
goto unicode;
|
|
|
|
|
}
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif
|
2002-10-10 03:07:53 +08:00
|
|
|
|
/* Fall through */
|
2003-06-18 22:17:01 +08:00
|
|
|
|
case 'r':
|
2000-04-11 23:39:26 +08:00
|
|
|
|
if (c == 's')
|
2001-12-06 23:18:48 +08:00
|
|
|
|
temp = PyObject_Str(v);
|
2000-04-11 23:39:26 +08:00
|
|
|
|
else
|
|
|
|
|
temp = PyObject_Repr(v);
|
1994-08-30 16:19:36 +08:00
|
|
|
|
if (temp == NULL)
|
1993-03-16 20:15:04 +08:00
|
|
|
|
goto error;
|
1998-06-09 23:08:41 +08:00
|
|
|
|
if (!PyString_Check(temp)) {
|
2002-10-10 03:14:30 +08:00
|
|
|
|
/* XXX Note: this should never happen,
|
|
|
|
|
since PyObject_Repr() and
|
|
|
|
|
PyObject_Str() assure this */
|
1998-06-09 23:08:41 +08:00
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
2002-10-10 03:14:30 +08:00
|
|
|
|
"%s argument has non-string str()");
|
2001-12-06 23:18:48 +08:00
|
|
|
|
Py_DECREF(temp);
|
1998-06-09 23:08:41 +08:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
2001-12-06 23:18:48 +08:00
|
|
|
|
pbuf = PyString_AS_STRING(temp);
|
|
|
|
|
len = PyString_GET_SIZE(temp);
|
1993-03-16 20:15:04 +08:00
|
|
|
|
if (prec >= 0 && len > prec)
|
|
|
|
|
len = prec;
|
|
|
|
|
break;
|
|
|
|
|
case 'i':
|
|
|
|
|
case 'd':
|
|
|
|
|
case 'u':
|
|
|
|
|
case 'o':
|
|
|
|
|
case 'x':
|
|
|
|
|
case 'X':
|
|
|
|
|
if (c == 'i')
|
|
|
|
|
c = 'd';
|
2000-11-30 13:22:44 +08:00
|
|
|
|
if (PyLong_Check(v)) {
|
2000-09-21 13:43:11 +08:00
|
|
|
|
temp = _PyString_FormatLong(v, flags,
|
|
|
|
|
prec, c, &pbuf, &len);
|
|
|
|
|
if (!temp)
|
|
|
|
|
goto error;
|
|
|
|
|
sign = 1;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
pbuf = formatbuf;
|
2002-04-15 21:48:52 +08:00
|
|
|
|
len = formatint(pbuf,
|
|
|
|
|
sizeof(formatbuf),
|
2000-09-21 13:43:11 +08:00
|
|
|
|
flags, prec, c, v);
|
|
|
|
|
if (len < 0)
|
|
|
|
|
goto error;
|
2003-11-30 07:52:13 +08:00
|
|
|
|
sign = 1;
|
1997-01-29 14:00:24 +08:00
|
|
|
|
}
|
2000-09-21 13:43:11 +08:00
|
|
|
|
if (flags & F_ZERO)
|
|
|
|
|
fill = '0';
|
1993-03-16 20:15:04 +08:00
|
|
|
|
break;
|
|
|
|
|
case 'e':
|
|
|
|
|
case 'E':
|
|
|
|
|
case 'f':
|
2003-08-27 12:55:52 +08:00
|
|
|
|
case 'F':
|
1993-03-16 20:15:04 +08:00
|
|
|
|
case 'g':
|
|
|
|
|
case 'G':
|
2003-08-27 12:55:52 +08:00
|
|
|
|
if (c == 'F')
|
|
|
|
|
c = 'f';
|
2000-06-30 18:29:57 +08:00
|
|
|
|
pbuf = formatbuf;
|
2002-04-15 21:48:52 +08:00
|
|
|
|
len = formatfloat(pbuf, sizeof(formatbuf),
|
|
|
|
|
flags, prec, c, v);
|
1997-01-22 00:12:09 +08:00
|
|
|
|
if (len < 0)
|
1993-03-16 20:15:04 +08:00
|
|
|
|
goto error;
|
|
|
|
|
sign = 1;
|
2000-09-21 13:43:11 +08:00
|
|
|
|
if (flags & F_ZERO)
|
1993-03-16 20:15:04 +08:00
|
|
|
|
fill = '0';
|
|
|
|
|
break;
|
|
|
|
|
case 'c':
|
2003-04-01 02:07:50 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
|
|
|
|
if (PyUnicode_Check(v)) {
|
|
|
|
|
fmt = fmt_start;
|
|
|
|
|
argidx = argidx_start;
|
|
|
|
|
goto unicode;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2000-06-30 18:29:57 +08:00
|
|
|
|
pbuf = formatbuf;
|
|
|
|
|
len = formatchar(pbuf, sizeof(formatbuf), v);
|
1997-01-22 00:12:09 +08:00
|
|
|
|
if (len < 0)
|
1993-03-16 20:15:04 +08:00
|
|
|
|
goto error;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
1997-09-09 02:30:11 +08:00
|
|
|
|
PyErr_Format(PyExc_ValueError,
|
2000-12-15 21:07:46 +08:00
|
|
|
|
"unsupported format character '%c' (0x%x) "
|
|
|
|
|
"at index %i",
|
2002-09-12 22:43:41 +08:00
|
|
|
|
c, c,
|
|
|
|
|
(int)(fmt - 1 - PyString_AsString(format)));
|
1993-03-16 20:15:04 +08:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
if (sign) {
|
2000-06-30 18:29:57 +08:00
|
|
|
|
if (*pbuf == '-' || *pbuf == '+') {
|
|
|
|
|
sign = *pbuf++;
|
1993-03-16 20:15:04 +08:00
|
|
|
|
len--;
|
|
|
|
|
}
|
|
|
|
|
else if (flags & F_SIGN)
|
|
|
|
|
sign = '+';
|
|
|
|
|
else if (flags & F_BLANK)
|
|
|
|
|
sign = ' ';
|
|
|
|
|
else
|
2000-09-21 13:43:11 +08:00
|
|
|
|
sign = 0;
|
1993-03-16 20:15:04 +08:00
|
|
|
|
}
|
|
|
|
|
if (width < len)
|
|
|
|
|
width = len;
|
2002-10-11 08:43:48 +08:00
|
|
|
|
if (rescnt - (sign != 0) < width) {
|
1993-05-12 16:24:20 +08:00
|
|
|
|
reslen -= rescnt;
|
|
|
|
|
rescnt = width + fmtcnt + 100;
|
|
|
|
|
reslen += rescnt;
|
2002-10-11 08:43:48 +08:00
|
|
|
|
if (reslen < 0) {
|
|
|
|
|
Py_DECREF(result);
|
|
|
|
|
return PyErr_NoMemory();
|
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
if (_PyString_Resize(&result, reslen) < 0)
|
1993-03-16 20:15:04 +08:00
|
|
|
|
return NULL;
|
2001-12-06 23:18:48 +08:00
|
|
|
|
res = PyString_AS_STRING(result)
|
1997-05-02 11:12:38 +08:00
|
|
|
|
+ reslen - rescnt;
|
1993-03-16 20:15:04 +08:00
|
|
|
|
}
|
|
|
|
|
if (sign) {
|
1993-11-11 23:03:51 +08:00
|
|
|
|
if (fill != ' ')
|
|
|
|
|
*res++ = sign;
|
1993-03-16 20:15:04 +08:00
|
|
|
|
rescnt--;
|
|
|
|
|
if (width > len)
|
|
|
|
|
width--;
|
|
|
|
|
}
|
2000-09-21 13:43:11 +08:00
|
|
|
|
if ((flags & F_ALT) && (c == 'x' || c == 'X')) {
|
|
|
|
|
assert(pbuf[0] == '0');
|
2001-04-13 02:38:48 +08:00
|
|
|
|
assert(pbuf[1] == c);
|
|
|
|
|
if (fill != ' ') {
|
|
|
|
|
*res++ = *pbuf++;
|
|
|
|
|
*res++ = *pbuf++;
|
2000-09-21 13:43:11 +08:00
|
|
|
|
}
|
2001-04-13 02:38:48 +08:00
|
|
|
|
rescnt -= 2;
|
|
|
|
|
width -= 2;
|
|
|
|
|
if (width < 0)
|
|
|
|
|
width = 0;
|
|
|
|
|
len -= 2;
|
2000-09-21 13:43:11 +08:00
|
|
|
|
}
|
|
|
|
|
if (width > len && !(flags & F_LJUST)) {
|
1993-03-16 20:15:04 +08:00
|
|
|
|
do {
|
|
|
|
|
--rescnt;
|
|
|
|
|
*res++ = fill;
|
|
|
|
|
} while (--width > len);
|
|
|
|
|
}
|
2000-09-21 13:43:11 +08:00
|
|
|
|
if (fill == ' ') {
|
|
|
|
|
if (sign)
|
|
|
|
|
*res++ = sign;
|
|
|
|
|
if ((flags & F_ALT) &&
|
2001-04-13 02:38:48 +08:00
|
|
|
|
(c == 'x' || c == 'X')) {
|
|
|
|
|
assert(pbuf[0] == '0');
|
|
|
|
|
assert(pbuf[1] == c);
|
2000-09-21 13:43:11 +08:00
|
|
|
|
*res++ = *pbuf++;
|
|
|
|
|
*res++ = *pbuf++;
|
|
|
|
|
}
|
|
|
|
|
}
|
2000-06-30 18:29:57 +08:00
|
|
|
|
memcpy(res, pbuf, len);
|
1993-03-16 20:15:04 +08:00
|
|
|
|
res += len;
|
|
|
|
|
rescnt -= len;
|
|
|
|
|
while (--width >= len) {
|
|
|
|
|
--rescnt;
|
|
|
|
|
*res++ = ' ';
|
|
|
|
|
}
|
1995-02-11 01:00:37 +08:00
|
|
|
|
if (dict && (argidx < arglen) && c != '%') {
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
2002-05-21 23:14:57 +08:00
|
|
|
|
"not all arguments converted during string formatting");
|
1994-08-30 16:19:36 +08:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_XDECREF(temp);
|
1993-03-16 20:15:04 +08:00
|
|
|
|
} /* '%' */
|
|
|
|
|
} /* until end */
|
1995-02-27 18:13:23 +08:00
|
|
|
|
if (argidx < arglen && !dict) {
|
1997-05-02 11:12:38 +08:00
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
2002-05-21 23:14:57 +08:00
|
|
|
|
"not all arguments converted during string formatting");
|
1993-03-16 20:15:04 +08:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
1998-04-11 06:16:39 +08:00
|
|
|
|
if (args_owned) {
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_DECREF(args);
|
1998-04-11 06:16:39 +08:00
|
|
|
|
}
|
1997-05-02 11:12:38 +08:00
|
|
|
|
_PyString_Resize(&result, reslen - rescnt);
|
1993-03-16 20:15:04 +08:00
|
|
|
|
return result;
|
2000-04-10 21:47:21 +08:00
|
|
|
|
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#ifdef Py_USING_UNICODE
|
2000-04-10 21:47:21 +08:00
|
|
|
|
unicode:
|
|
|
|
|
if (args_owned) {
|
|
|
|
|
Py_DECREF(args);
|
|
|
|
|
args_owned = 0;
|
|
|
|
|
}
|
2001-05-02 22:21:53 +08:00
|
|
|
|
/* Fiddle args right (remove the first argidx arguments) */
|
2000-04-10 21:47:21 +08:00
|
|
|
|
if (PyTuple_Check(orig_args) && argidx > 0) {
|
|
|
|
|
PyObject *v;
|
|
|
|
|
int n = PyTuple_GET_SIZE(orig_args) - argidx;
|
|
|
|
|
v = PyTuple_New(n);
|
|
|
|
|
if (v == NULL)
|
|
|
|
|
goto error;
|
|
|
|
|
while (--n >= 0) {
|
|
|
|
|
PyObject *w = PyTuple_GET_ITEM(orig_args, n + argidx);
|
|
|
|
|
Py_INCREF(w);
|
|
|
|
|
PyTuple_SET_ITEM(v, n, w);
|
|
|
|
|
}
|
|
|
|
|
args = v;
|
|
|
|
|
} else {
|
|
|
|
|
Py_INCREF(orig_args);
|
|
|
|
|
args = orig_args;
|
|
|
|
|
}
|
2000-10-07 16:54:09 +08:00
|
|
|
|
args_owned = 1;
|
|
|
|
|
/* Take what we have of the result and let the Unicode formatting
|
|
|
|
|
function format the rest of the input. */
|
2000-04-10 21:47:21 +08:00
|
|
|
|
rescnt = res - PyString_AS_STRING(result);
|
2000-10-07 16:54:09 +08:00
|
|
|
|
if (_PyString_Resize(&result, rescnt))
|
|
|
|
|
goto error;
|
2000-04-10 21:47:21 +08:00
|
|
|
|
fmtcnt = PyString_GET_SIZE(format) - \
|
|
|
|
|
(fmt - PyString_AS_STRING(format));
|
2000-10-07 16:54:09 +08:00
|
|
|
|
format = PyUnicode_Decode(fmt, fmtcnt, NULL, NULL);
|
|
|
|
|
if (format == NULL)
|
2000-04-10 21:47:21 +08:00
|
|
|
|
goto error;
|
2000-10-07 16:54:09 +08:00
|
|
|
|
v = PyUnicode_Format(format, args);
|
2000-04-10 21:47:21 +08:00
|
|
|
|
Py_DECREF(format);
|
2000-10-07 16:54:09 +08:00
|
|
|
|
if (v == NULL)
|
|
|
|
|
goto error;
|
|
|
|
|
/* Paste what we have (result) to what the Unicode formatting
|
|
|
|
|
function returned (v) and return the result (or error) */
|
|
|
|
|
w = PyUnicode_Concat(result, v);
|
|
|
|
|
Py_DECREF(result);
|
|
|
|
|
Py_DECREF(v);
|
2000-04-10 21:47:21 +08:00
|
|
|
|
Py_DECREF(args);
|
2000-10-07 16:54:09 +08:00
|
|
|
|
return w;
|
2001-08-18 02:39:25 +08:00
|
|
|
|
#endif /* Py_USING_UNICODE */
|
2001-04-28 13:38:26 +08:00
|
|
|
|
|
1993-03-16 20:15:04 +08:00
|
|
|
|
error:
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_DECREF(result);
|
1998-04-11 06:16:39 +08:00
|
|
|
|
if (args_owned) {
|
1997-05-02 11:12:38 +08:00
|
|
|
|
Py_DECREF(args);
|
1998-04-11 06:16:39 +08:00
|
|
|
|
}
|
1993-03-16 20:15:04 +08:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
1997-01-18 15:55:05 +08:00
|
|
|
|
|
|
|
|
|
void
|
2000-07-09 15:04:36 +08:00
|
|
|
|
PyString_InternInPlace(PyObject **p)
|
1997-01-18 15:55:05 +08:00
|
|
|
|
{
|
|
|
|
|
register PyStringObject *s = (PyStringObject *)(*p);
|
|
|
|
|
PyObject *t;
|
|
|
|
|
if (s == NULL || !PyString_Check(s))
|
|
|
|
|
Py_FatalError("PyString_InternInPlace: strings only please!");
|
2004-08-08 03:20:05 +08:00
|
|
|
|
/* If it's a string subclass, we don't really know what putting
|
|
|
|
|
it in the interned dict might do. */
|
|
|
|
|
if (!PyString_CheckExact(s))
|
|
|
|
|
return;
|
2002-08-20 05:43:18 +08:00
|
|
|
|
if (PyString_CHECK_INTERNED(s))
|
1997-01-18 15:55:05 +08:00
|
|
|
|
return;
|
|
|
|
|
if (interned == NULL) {
|
|
|
|
|
interned = PyDict_New();
|
2002-08-20 05:43:18 +08:00
|
|
|
|
if (interned == NULL) {
|
|
|
|
|
PyErr_Clear(); /* Don't leave an exception */
|
1997-01-18 15:55:05 +08:00
|
|
|
|
return;
|
2002-08-20 05:43:18 +08:00
|
|
|
|
}
|
1997-01-18 15:55:05 +08:00
|
|
|
|
}
|
2004-08-08 03:20:05 +08:00
|
|
|
|
t = PyDict_GetItem(interned, (PyObject *)s);
|
|
|
|
|
if (t) {
|
1997-01-18 15:55:05 +08:00
|
|
|
|
Py_INCREF(t);
|
2002-08-20 05:43:18 +08:00
|
|
|
|
Py_DECREF(*p);
|
|
|
|
|
*p = t;
|
1997-01-18 15:55:05 +08:00
|
|
|
|
return;
|
|
|
|
|
}
|
2002-08-20 05:43:18 +08:00
|
|
|
|
|
2004-08-08 03:27:39 +08:00
|
|
|
|
if (PyDict_SetItem(interned, (PyObject *)s, (PyObject *)s) < 0) {
|
2004-08-08 03:20:05 +08:00
|
|
|
|
PyErr_Clear();
|
2002-08-20 05:43:18 +08:00
|
|
|
|
return;
|
1997-01-18 15:55:05 +08:00
|
|
|
|
}
|
2004-08-08 03:20:05 +08:00
|
|
|
|
/* The two references in interned are not counted by refcnt.
|
|
|
|
|
The string deallocator will take care of this */
|
2004-08-08 03:27:39 +08:00
|
|
|
|
s->ob_refcnt -= 2;
|
2004-08-08 03:20:05 +08:00
|
|
|
|
PyString_CHECK_INTERNED(s) = SSTATE_INTERNED_MORTAL;
|
1997-01-18 15:55:05 +08:00
|
|
|
|
}
|
|
|
|
|
|
2002-08-20 05:43:18 +08:00
|
|
|
|
void
|
|
|
|
|
PyString_InternImmortal(PyObject **p)
|
|
|
|
|
{
|
|
|
|
|
PyString_InternInPlace(p);
|
|
|
|
|
if (PyString_CHECK_INTERNED(*p) != SSTATE_INTERNED_IMMORTAL) {
|
|
|
|
|
PyString_CHECK_INTERNED(*p) = SSTATE_INTERNED_IMMORTAL;
|
|
|
|
|
Py_INCREF(*p);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1997-01-18 15:55:05 +08:00
|
|
|
|
|
|
|
|
|
PyObject *
|
2000-07-09 15:04:36 +08:00
|
|
|
|
PyString_InternFromString(const char *cp)
|
1997-01-18 15:55:05 +08:00
|
|
|
|
{
|
|
|
|
|
PyObject *s = PyString_FromString(cp);
|
|
|
|
|
if (s == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
PyString_InternInPlace(&s);
|
|
|
|
|
return s;
|
|
|
|
|
}
|
|
|
|
|
|
1997-08-02 10:57:45 +08:00
|
|
|
|
void
|
2000-07-09 15:04:36 +08:00
|
|
|
|
PyString_Fini(void)
|
1997-08-02 10:57:45 +08:00
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < UCHAR_MAX + 1; i++) {
|
|
|
|
|
Py_XDECREF(characters[i]);
|
|
|
|
|
characters[i] = NULL;
|
|
|
|
|
}
|
|
|
|
|
Py_XDECREF(nullstring);
|
|
|
|
|
nullstring = NULL;
|
|
|
|
|
}
|
2001-02-24 00:40:48 +08:00
|
|
|
|
|
|
|
|
|
void _Py_ReleaseInternedStrings(void)
|
|
|
|
|
{
|
2002-08-20 05:43:18 +08:00
|
|
|
|
PyObject *keys;
|
|
|
|
|
PyStringObject *s;
|
|
|
|
|
int i, n;
|
|
|
|
|
|
|
|
|
|
if (interned == NULL || !PyDict_Check(interned))
|
|
|
|
|
return;
|
|
|
|
|
keys = PyDict_Keys(interned);
|
|
|
|
|
if (keys == NULL || !PyList_Check(keys)) {
|
|
|
|
|
PyErr_Clear();
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Since _Py_ReleaseInternedStrings() is intended to help a leak
|
|
|
|
|
detector, interned strings are not forcibly deallocated; rather, we
|
|
|
|
|
give them their stolen references back, and then clear and DECREF
|
|
|
|
|
the interned dict. */
|
|
|
|
|
|
|
|
|
|
fprintf(stderr, "releasing interned strings\n");
|
|
|
|
|
n = PyList_GET_SIZE(keys);
|
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
|
s = (PyStringObject *) PyList_GET_ITEM(keys, i);
|
|
|
|
|
switch (s->ob_sstate) {
|
|
|
|
|
case SSTATE_NOT_INTERNED:
|
|
|
|
|
/* XXX Shouldn't happen */
|
|
|
|
|
break;
|
|
|
|
|
case SSTATE_INTERNED_IMMORTAL:
|
|
|
|
|
s->ob_refcnt += 1;
|
|
|
|
|
break;
|
|
|
|
|
case SSTATE_INTERNED_MORTAL:
|
|
|
|
|
s->ob_refcnt += 2;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
Py_FatalError("Inconsistent interned string state.");
|
|
|
|
|
}
|
|
|
|
|
s->ob_sstate = SSTATE_NOT_INTERNED;
|
2001-02-24 00:40:48 +08:00
|
|
|
|
}
|
2002-08-20 05:43:18 +08:00
|
|
|
|
Py_DECREF(keys);
|
|
|
|
|
PyDict_Clear(interned);
|
|
|
|
|
Py_DECREF(interned);
|
|
|
|
|
interned = NULL;
|
2001-02-24 00:40:48 +08:00
|
|
|
|
}
|