add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Objects/stringobject.c (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Objects/stringobject.c+5009−0

@@ -0,0 +1,5009 @@
	1	/* String object implementation */
	2
	3	#define PY_SSIZE_T_CLEAN
	4
	5	#include "Python.h"
	6
	7	#include <ctype.h>
	8
	9	#ifdef COUNT_ALLOCS
	10	int null_strings, one_strings;
	11	#endif
	12
	13	static PyStringObject *characters[UCHAR_MAX + 1];
	14	static PyStringObject *nullstring;
	15
	16	/* This dictionary holds all interned strings. Note that references to
	17	strings in this dictionary are not counted in the string's ob_refcnt.
	18	When the interned string reaches a refcnt of 0 the string deallocation
	19	function will delete the reference from this dictionary.
	20
	21	Another way to look at this is that to say that the actual reference
	22	count of a string is: s->ob_refcnt + (s->ob_sstate?2:0)
	23	*/
	24	static PyObject *interned;
	25
	26	/*
	27	For both PyString_FromString() and PyString_FromStringAndSize(), the
	28	parameter `size' denotes number of characters to allocate, not counting any
	29	null terminating character.
	30
	31	For PyString_FromString(), the parameter `str' points to a null-terminated
	32	string containing exactly `size' bytes.
	33
	34	For PyString_FromStringAndSize(), the parameter the parameter `str' is
	35	either NULL or else points to a string containing at least `size' bytes.
	36	For PyString_FromStringAndSize(), the string in the `str' parameter does
	37	not have to be null-terminated. (Therefore it is safe to construct a
	38	substring by calling `PyString_FromStringAndSize(origstring, substrlen)'.)
	39	If `str' is NULL then PyString_FromStringAndSize() will allocate `size+1'
	40	bytes (setting the last byte to the null terminating character) and you can
	41	fill in the data yourself. If `str' is non-NULL then the resulting
	42	PyString object must be treated as immutable and you must not fill in nor
	43	alter the data yourself, since the strings may be shared.
	44
	45	The PyObject member `op->ob_size', which denotes the number of "extra
	46	items" in a variable-size object, will contain the number of bytes
	47	allocated for string data, not counting the null terminating character. It
	48	is therefore equal to the equal to the `size' parameter (for
	49	PyString_FromStringAndSize()) or the length of the string in the `str'
	50	parameter (for PyString_FromString()).
	51	*/
	52	PyObject *
	53	PyString_FromStringAndSize(const char *str, Py_ssize_t size)
	54	{
	55	register PyStringObject *op;
	56	assert(size >= 0);
	57	if (size == 0 && (op = nullstring) != NULL) {
	58	#ifdef COUNT_ALLOCS
	59	null_strings++;
	60	#endif
	61	Py_INCREF(op);
	62	return (PyObject *)op;
	63	}
	64	if (size == 1 && str != NULL &&
	65	(op = characters[*str & UCHAR_MAX]) != NULL)
	66	{
	67	#ifdef COUNT_ALLOCS
	68	one_strings++;
	69	#endif
	70	Py_INCREF(op);
	71	return (PyObject *)op;
	72	}
	73
	74	/* Inline PyObject_NewVar */
	75	op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
	76	if (op == NULL)
	77	return PyErr_NoMemory();
	78	PyObject_INIT_VAR(op, &PyString_Type, size);
	79	op->ob_shash = -1;
	80	op->ob_sstate = SSTATE_NOT_INTERNED;
	81	if (str != NULL)
	82	Py_MEMCPY(op->ob_sval, str, size);
	83	op->ob_sval[size] = '\0';
	84	/* share short strings */
	85	if (size == 0) {
	86	PyObject t = (PyObject )op;
	87	PyString_InternInPlace(&t);
	88	op = (PyStringObject *)t;
	89	nullstring = op;
	90	Py_INCREF(op);
	91	} else if (size == 1 && str != NULL) {
	92	PyObject t = (PyObject )op;
	93	PyString_InternInPlace(&t);
	94	op = (PyStringObject *)t;
	95	characters[*str & UCHAR_MAX] = op;
	96	Py_INCREF(op);
	97	}
	98	return (PyObject *) op;
	99	}
	100
	101	PyObject *
	102	PyString_FromString(const char *str)
	103	{
	104	register size_t size;
	105	register PyStringObject *op;
	106
	107	assert(str != NULL);
	108	size = strlen(str);
	109	if (size > PY_SSIZE_T_MAX) {
	110	PyErr_SetString(PyExc_OverflowError,
	111	"string is too long for a Python string");
	112	return NULL;
	113	}
	114	if (size == 0 && (op = nullstring) != NULL) {
	115	#ifdef COUNT_ALLOCS
	116	null_strings++;
	117	#endif
	118	Py_INCREF(op);
	119	return (PyObject *)op;
	120	}
	121	if (size == 1 && (op = characters[*str & UCHAR_MAX]) != NULL) {
	122	#ifdef COUNT_ALLOCS
	123	one_strings++;
	124	#endif
	125	Py_INCREF(op);
	126	return (PyObject *)op;
	127	}
	128
	129	/* Inline PyObject_NewVar */
	130	op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
	131	if (op == NULL)
	132	return PyErr_NoMemory();
	133	PyObject_INIT_VAR(op, &PyString_Type, size);
	134	op->ob_shash = -1;
	135	op->ob_sstate = SSTATE_NOT_INTERNED;
	136	Py_MEMCPY(op->ob_sval, str, size+1);
	137	/* share short strings */
	138	if (size == 0) {
	139	PyObject t = (PyObject )op;
	140	PyString_InternInPlace(&t);
	141	op = (PyStringObject *)t;
	142	nullstring = op;
	143	Py_INCREF(op);
	144	} else if (size == 1) {
	145	PyObject t = (PyObject )op;
	146	PyString_InternInPlace(&t);
	147	op = (PyStringObject *)t;
	148	characters[*str & UCHAR_MAX] = op;
	149	Py_INCREF(op);
	150	}
	151	return (PyObject *) op;
	152	}
	153
	154	PyObject *
	155	PyString_FromFormatV(const char *format, va_list vargs)
	156	{
	157	va_list count;
	158	Py_ssize_t n = 0;
	159	const char* f;
	160	char *s;
	161	PyObject* string;
	162
	163	#ifdef VA_LIST_IS_ARRAY
	164	Py_MEMCPY(count, vargs, sizeof(va_list));
	165	#else
	166	#ifdef __va_copy
	167	__va_copy(count, vargs);
	168	#else
	169	count = vargs;
	170	#endif
	171	#endif
	172	/* step 1: figure out how large a buffer we need */
	173	for (f = format; *f; f++) {
	174	if (*f == '%') {
	175	const char* p = f;
	176	while (++f && f != '%' && !isalpha(Py_CHARMASK(*f)))
	177	;
	178
	179	/* skip the 'l' or 'z' in {%ld, %zd, %lu, %zu} since
	180	* they don't affect the amount of space we reserve.
	181	*/
	182	if ((f == 'l' \|\| f == 'z') &&
	183	(f[1] == 'd' \|\| f[1] == 'u'))
	184	++f;
	185
	186	switch (*f) {
	187	case 'c':
	188	(void)va_arg(count, int);
	189	/* fall through... */
	190	case '%':
	191	n++;
	192	break;
	193	case 'd': case 'u': case 'i': case 'x':
	194	(void) va_arg(count, int);
	195	/* 20 bytes is enough to hold a 64-bit
	196	integer. Decimal takes the most space.
	197	This isn't enough for octal. */
	198	n += 20;
	199	break;
	200	case 's':
	201	s = va_arg(count, char*);
	202	n += strlen(s);
	203	break;
	204	case 'p':
	205	(void) va_arg(count, int);
	206	/* maximum 64-bit pointer representation:
	207	* 0xffffffffffffffff
	208	* so 19 characters is enough.
	209	* XXX I count 18 -- what's the extra for?
	210	*/
	211	n += 19;
	212	break;
	213	default:
	214	/* if we stumble upon an unknown
	215	formatting code, copy the rest of
	216	the format string to the output
	217	string. (we cannot just skip the
	218	code, since there's no way to know
	219	what's in the argument list) */
	220	n += strlen(p);
	221	goto expand;
	222	}
	223	} else
	224	n++;
	225	}
	226	expand:
	227	/* step 2: fill the buffer */
	228	/* Since we've analyzed how much space we need for the worst case,
	229	use sprintf directly instead of the slower PyOS_snprintf. */
	230	string = PyString_FromStringAndSize(NULL, n);
	231	if (!string)
	232	return NULL;
	233
	234	s = PyString_AsString(string);
	235
	236	for (f = format; *f; f++) {
	237	if (*f == '%') {
	238	const char* p = f++;
	239	Py_ssize_t i;
	240	int longflag = 0;
	241	int size_tflag = 0;
	242	/* parse the width.precision part (we're only
	243	interested in the precision value, if any) */
	244	n = 0;
	245	while (isdigit(Py_CHARMASK(*f)))
	246	n = (n10) + f++ - '0';
	247	if (*f == '.') {
	248	f++;
	249	n = 0;
	250	while (isdigit(Py_CHARMASK(*f)))
	251	n = (n10) + f++ - '0';
	252	}
	253	while (f && f != '%' && !isalpha(Py_CHARMASK(*f)))
	254	f++;
	255	/* handle the long flag, but only for %ld and %lu.
	256	others can be added when necessary. */
	257	if (*f == 'l' && (f[1] == 'd' \|\| f[1] == 'u')) {
	258	longflag = 1;
	259	++f;
	260	}
	261	/* handle the size_t flag. */
	262	if (*f == 'z' && (f[1] == 'd' \|\| f[1] == 'u')) {
	263	size_tflag = 1;
	264	++f;
	265	}
	266
	267	switch (*f) {
	268	case 'c':
	269	*s++ = va_arg(vargs, int);
	270	break;
	271	case 'd':
	272	if (longflag)
	273	sprintf(s, "%ld", va_arg(vargs, long));
	274	else if (size_tflag)
	275	sprintf(s, "%" PY_FORMAT_SIZE_T "d",
	276	va_arg(vargs, Py_ssize_t));
	277	else
	278	sprintf(s, "%d", va_arg(vargs, int));
	279	s += strlen(s);
	280	break;
	281	case 'u':
	282	if (longflag)
	283	sprintf(s, "%lu",
	284	va_arg(vargs, unsigned long));
	285	else if (size_tflag)
	286	sprintf(s, "%" PY_FORMAT_SIZE_T "u",
	287	va_arg(vargs, size_t));
	288	else
	289	sprintf(s, "%u",
	290	va_arg(vargs, unsigned int));
	291	s += strlen(s);
	292	break;
	293	case 'i':
	294	sprintf(s, "%i", va_arg(vargs, int));
	295	s += strlen(s);
	296	break;
	297	case 'x':
	298	sprintf(s, "%x", va_arg(vargs, int));
	299	s += strlen(s);
	300	break;
	301	case 's':
	302	p = va_arg(vargs, char*);
	303	i = strlen(p);
	304	if (n > 0 && i > n)
	305	i = n;
	306	Py_MEMCPY(s, p, i);
	307	s += i;
	308	break;
	309	case 'p':
	310	sprintf(s, "%p", va_arg(vargs, void*));
	311	/* %p is ill-defined: ensure leading 0x. */
	312	if (s[1] == 'X')
	313	s[1] = 'x';
	314	else if (s[1] != 'x') {
	315	memmove(s+2, s, strlen(s)+1);
	316	s[0] = '0';
	317	s[1] = 'x';
	318	}
	319	s += strlen(s);
	320	break;
	321	case '%':
	322	*s++ = '%';
	323	break;
	324	default:
	325	strcpy(s, p);
	326	s += strlen(s);
	327	goto end;
	328	}
	329	} else
	330	s++ = f;
	331	}
	332
	333	end:
	334	_PyString_Resize(&string, s - PyString_AS_STRING(string));
	335	return string;
	336	}
	337
	338	PyObject *
	339	PyString_FromFormat(const char *format, ...)
	340	{
	341	PyObject* ret;
	342	va_list vargs;
	343
	344	#ifdef HAVE_STDARG_PROTOTYPES
	345	va_start(vargs, format);
	346	#else
	347	va_start(vargs);
	348	#endif
	349	ret = PyString_FromFormatV(format, vargs);
	350	va_end(vargs);
	351	return ret;
	352	}
	353
	354
	355	PyObject PyString_Decode(const char s,
	356	Py_ssize_t size,
	357	const char *encoding,
	358	const char *errors)
	359	{
	360	PyObject v, str;
	361
	362	str = PyString_FromStringAndSize(s, size);
	363	if (str == NULL)
	364	return NULL;
	365	v = PyString_AsDecodedString(str, encoding, errors);
	366	Py_DECREF(str);
	367	return v;
	368	}
	369
	370	PyObject PyString_AsDecodedObject(PyObject str,
	371	const char *encoding,
	372	const char *errors)
	373	{
	374	PyObject *v;
	375
	376	if (!PyString_Check(str)) {
	377	PyErr_BadArgument();
	378	goto onError;
	379	}
	380
	381	if (encoding == NULL) {
	382	#ifdef Py_USING_UNICODE
	383	encoding = PyUnicode_GetDefaultEncoding();
	384	#else
	385	PyErr_SetString(PyExc_ValueError, "no encoding specified");
	386	goto onError;
	387	#endif
	388	}
	389
	390	/* Decode via the codec registry */
	391	v = PyCodec_Decode(str, encoding, errors);
	392	if (v == NULL)
	393	goto onError;
	394
	395	return v;
	396
	397	onError:
	398	return NULL;
	399	}
	400
	401	PyObject PyString_AsDecodedString(PyObject str,
	402	const char *encoding,
	403	const char *errors)
	404	{
	405	PyObject *v;
	406
	407	v = PyString_AsDecodedObject(str, encoding, errors);
	408	if (v == NULL)
	409	goto onError;
	410
	411	#ifdef Py_USING_UNICODE
	412	/* Convert Unicode to a string using the default encoding */
	413	if (PyUnicode_Check(v)) {
	414	PyObject *temp = v;
	415	v = PyUnicode_AsEncodedString(v, NULL, NULL);
	416	Py_DECREF(temp);
	417	if (v == NULL)
	418	goto onError;
	419	}
	420	#endif
	421	if (!PyString_Check(v)) {
	422	PyErr_Format(PyExc_TypeError,
	423	"decoder did not return a string object (type=%.400s)",
	424	v->ob_type->tp_name);
	425	Py_DECREF(v);
	426	goto onError;
	427	}
	428
	429	return v;
	430
	431	onError:
	432	return NULL;
	433	}
	434
	435	PyObject PyString_Encode(const char s,
	436	Py_ssize_t size,
	437	const char *encoding,
	438	const char *errors)
	439	{
	440	PyObject v, str;
	441
	442	str = PyString_FromStringAndSize(s, size);
	443	if (str == NULL)
	444	return NULL;
	445	v = PyString_AsEncodedString(str, encoding, errors);
	446	Py_DECREF(str);
	447	return v;
	448	}
	449
	450	PyObject PyString_AsEncodedObject(PyObject str,
	451	const char *encoding,
	452	const char *errors)
	453	{
	454	PyObject *v;
	455
	456	if (!PyString_Check(str)) {
	457	PyErr_BadArgument();
	458	goto onError;
	459	}
	460
	461	if (encoding == NULL) {
	462	#ifdef Py_USING_UNICODE
	463	encoding = PyUnicode_GetDefaultEncoding();
	464	#else
	465	PyErr_SetString(PyExc_ValueError, "no encoding specified");
	466	goto onError;
	467	#endif
	468	}
	469
	470	/* Encode via the codec registry */
	471	v = PyCodec_Encode(str, encoding, errors);
	472	if (v == NULL)
	473	goto onError;
	474
	475	return v;
	476
	477	onError:
	478	return NULL;
	479	}
	480
	481	PyObject PyString_AsEncodedString(PyObject str,
	482	const char *encoding,
	483	const char *errors)
	484	{
	485	PyObject *v;
	486
	487	v = PyString_AsEncodedObject(str, encoding, errors);
	488	if (v == NULL)
	489	goto onError;
	490
	491	#ifdef Py_USING_UNICODE
	492	/* Convert Unicode to a string using the default encoding */
	493	if (PyUnicode_Check(v)) {
	494	PyObject *temp = v;
	495	v = PyUnicode_AsEncodedString(v, NULL, NULL);
	496	Py_DECREF(temp);
	497	if (v == NULL)
	498	goto onError;
	499	}
	500	#endif
	501	if (!PyString_Check(v)) {
	502	PyErr_Format(PyExc_TypeError,
	503	"encoder did not return a string object (type=%.400s)",
	504	v->ob_type->tp_name);
	505	Py_DECREF(v);
	506	goto onError;
	507	}
	508
	509	return v;
	510
	511	onError:
	512	return NULL;
	513	}
	514
	515	static void
	516	string_dealloc(PyObject *op)
	517	{
	518	switch (PyString_CHECK_INTERNED(op)) {
	519	case SSTATE_NOT_INTERNED:
	520	break;
	521
	522	case SSTATE_INTERNED_MORTAL:
	523	/* revive dead object temporarily for DelItem */
	524	op->ob_refcnt = 3;
	525	if (PyDict_DelItem(interned, op) != 0)
	526	Py_FatalError(
	527	"deletion of interned string failed");
	528	break;
	529
	530	case SSTATE_INTERNED_IMMORTAL:
	531	Py_FatalError("Immortal interned string died.");
	532
	533	default:
	534	Py_FatalError("Inconsistent interned string state.");
	535	}
	536	op->ob_type->tp_free(op);
	537	}
	538
	539	/* Unescape a backslash-escaped string. If unicode is non-zero,
	540	the string is a u-literal. If recode_encoding is non-zero,
	541	the string is UTF-8 encoded and should be re-encoded in the
	542	specified encoding. */
	543
	544	PyObject PyString_DecodeEscape(const char s,
	545	Py_ssize_t len,
	546	const char *errors,
	547	Py_ssize_t unicode,
	548	const char *recode_encoding)
	549	{
	550	int c;
	551	char p, buf;
	552	const char *end;
	553	PyObject *v;
	554	Py_ssize_t newlen = recode_encoding ? 4*len:len;
	555	v = PyString_FromStringAndSize((char *)NULL, newlen);
	556	if (v == NULL)
	557	return NULL;
	558	p = buf = PyString_AsString(v);
	559	end = s + len;
	560	while (s < end) {
	561	if (*s != '\\') {
	562	non_esc:
	563	#ifdef Py_USING_UNICODE
	564	if (recode_encoding && (*s & 0x80)) {
	565	PyObject u, w;
	566	char *r;
	567	const char* t;
	568	Py_ssize_t rn;
	569	t = s;
	570	/* Decode non-ASCII bytes as UTF-8. */
	571	while (t < end && (*t & 0x80)) t++;
	572	u = PyUnicode_DecodeUTF8(s, t - s, errors);
	573	if(!u) goto failed;
	574
	575	/* Recode them in target encoding. */
	576	w = PyUnicode_AsEncodedString(
	577	u, recode_encoding, errors);
	578	Py_DECREF(u);
	579	if (!w) goto failed;
	580
	581	/* Append bytes to output buffer. */
	582	assert(PyString_Check(w));
	583	r = PyString_AS_STRING(w);
	584	rn = PyString_GET_SIZE(w);
	585	Py_MEMCPY(p, r, rn);
	586	p += rn;
	587	Py_DECREF(w);
	588	s = t;
	589	} else {
	590	p++ = s++;
	591	}
	592	#else
	593	p++ = s++;
	594	#endif
	595	continue;
	596	}
	597	s++;
	598	if (s==end) {
	599	PyErr_SetString(PyExc_ValueError,
	600	"Trailing \\ in string");
	601	goto failed;
	602	}
	603	switch (*s++) {
	604	/* XXX This assumes ASCII! */
	605	case '\n': break;
	606	case '\\': *p++ = '\\'; break;
	607	case '\'': *p++ = '\''; break;
	608	case '\"': *p++ = '\"'; break;
	609	case 'b': *p++ = '\b'; break;
	610	case 'f': p++ = '\014'; break; / FF */
	611	case 't': *p++ = '\t'; break;
	612	case 'n': *p++ = '\n'; break;
	613	case 'r': *p++ = '\r'; break;
	614	case 'v': p++ = '\013'; break; / VT */
	615	case 'a': p++ = '\007'; break; / BEL, not classic C */
	616	case '0': case '1': case '2': case '3':
	617	case '4': case '5': case '6': case '7':
	618	c = s[-1] - '0';
	619	if ('0' <= s && s <= '7') {
	620	c = (c<<3) + *s++ - '0';
	621	if ('0' <= s && s <= '7')
	622	c = (c<<3) + *s++ - '0';
	623	}
	624	*p++ = c;
	625	break;
	626	case 'x':
	627	if (isxdigit(Py_CHARMASK(s[0]))
	628	&& isxdigit(Py_CHARMASK(s[1]))) {
	629	unsigned int x = 0;
	630	c = Py_CHARMASK(*s);
	631	s++;
	632	if (isdigit(c))
	633	x = c - '0';
	634	else if (islower(c))
	635	x = 10 + c - 'a';
	636	else
	637	x = 10 + c - 'A';
	638	x = x << 4;
	639	c = Py_CHARMASK(*s);
	640	s++;
	641	if (isdigit(c))
	642	x += c - '0';
	643	else if (islower(c))
	644	x += 10 + c - 'a';
	645	else
	646	x += 10 + c - 'A';
	647	*p++ = x;
	648	break;
	649	}
	650	if (!errors \|\| strcmp(errors, "strict") == 0) {
	651	PyErr_SetString(PyExc_ValueError,
	652	"invalid \\x escape");
	653	goto failed;
	654	}
	655	if (strcmp(errors, "replace") == 0) {
	656	*p++ = '?';
	657	} else if (strcmp(errors, "ignore") == 0)
	658	/* do nothing */;
	659	else {
	660	PyErr_Format(PyExc_ValueError,
	661	"decoding error; "
	662	"unknown error handling code: %.400s",
	663	errors);
	664	goto failed;
	665	}
	666	#ifndef Py_USING_UNICODE
	667	case 'u':
	668	case 'U':
	669	case 'N':
	670	if (unicode) {
	671	PyErr_SetString(PyExc_ValueError,
	672	"Unicode escapes not legal "
	673	"when Unicode disabled");
	674	goto failed;
	675	}
	676	#endif
	677	default:
	678	*p++ = '\\';
	679	s--;
	680	goto non_esc; /* an arbitry number of unescaped
	681	UTF-8 bytes may follow. */
	682	}
	683	}
	684	if (p-buf < newlen)
	685	_PyString_Resize(&v, p - buf);
	686	return v;
	687	failed:
	688	Py_DECREF(v);
	689	return NULL;
	690	}
	691
	692	/* -------------------------------------------------------------------- */
	693	/* object api */
	694
	695	static Py_ssize_t
	696	string_getsize(register PyObject *op)
	697	{
	698	char *s;
	699	Py_ssize_t len;
	700	if (PyString_AsStringAndSize(op, &s, &len))
	701	return -1;
	702	return len;
	703	}
	704
	705	static /const/ char *
	706	string_getbuffer(register PyObject *op)
	707	{
	708	char *s;
	709	Py_ssize_t len;
	710	if (PyString_AsStringAndSize(op, &s, &len))
	711	return NULL;
	712	return s;
	713	}
	714
	715	Py_ssize_t
	716	PyString_Size(register PyObject *op)
	717	{
	718	if (!PyString_Check(op))
	719	return string_getsize(op);
	720	return ((PyStringObject *)op) -> ob_size;
	721	}
	722
	723	/const/ char *
	724	PyString_AsString(register PyObject *op)
	725	{
	726	if (!PyString_Check(op))
	727	return string_getbuffer(op);
	728	return ((PyStringObject *)op) -> ob_sval;
	729	}
	730
	731	int
	732	PyString_AsStringAndSize(register PyObject *obj,
	733	register char **s,
	734	register Py_ssize_t *len)
	735	{
	736	if (s == NULL) {
	737	PyErr_BadInternalCall();
	738	return -1;
	739	}
	740
	741	if (!PyString_Check(obj)) {
	742	#ifdef Py_USING_UNICODE
	743	if (PyUnicode_Check(obj)) {
	744	obj = _PyUnicode_AsDefaultEncodedString(obj, NULL);
	745	if (obj == NULL)
	746	return -1;
	747	}
	748	else
	749	#endif
	750	{
	751	PyErr_Format(PyExc_TypeError,
	752	"expected string or Unicode object, "
	753	"%.200s found", obj->ob_type->tp_name);
	754	return -1;
	755	}
	756	}
	757
	758	*s = PyString_AS_STRING(obj);
	759	if (len != NULL)
	760	*len = PyString_GET_SIZE(obj);
	761	else if (strlen(*s) != (size_t)PyString_GET_SIZE(obj)) {
	762	PyErr_SetString(PyExc_TypeError,
	763	"expected string without null bytes");
	764	return -1;
	765	}
	766	return 0;
	767	}
	768
	769	/* -------------------------------------------------------------------- */
	770	/* Methods */
	771
	772	#define STRINGLIB_CHAR char
	773
	774	#define STRINGLIB_CMP memcmp
	775	#define STRINGLIB_LEN PyString_GET_SIZE
	776	#define STRINGLIB_NEW PyString_FromStringAndSize
	777	#define STRINGLIB_STR PyString_AS_STRING
	778
	779	#define STRINGLIB_EMPTY nullstring
	780
	781	#include "stringlib/fastsearch.h"
	782
	783	#include "stringlib/count.h"
	784	#include "stringlib/find.h"
	785	#include "stringlib/partition.h"
	786
	787
	788	static int
	789	string_print(PyStringObject op, FILE fp, int flags)
	790	{
	791	Py_ssize_t i;
	792	char c;
	793	int quote;
	794
	795	/* XXX Ought to check for interrupts when writing long strings */
	796	if (! PyString_CheckExact(op)) {
	797	int ret;
	798	/* A str subclass may have its own __str__ method. */
	799	op = (PyStringObject ) PyObject_Str((PyObject )op);
	800	if (op == NULL)
	801	return -1;
	802	ret = string_print(op, fp, flags);
	803	Py_DECREF(op);
	804	return ret;
	805	}
	806	if (flags & Py_PRINT_RAW) {
	807	char *data = op->ob_sval;
	808	Py_ssize_t size = op->ob_size;
	809	while (size > INT_MAX) {
	810	/* Very long strings cannot be written atomically.
	811	* But don't write exactly INT_MAX bytes at a time
	812	* to avoid memory aligment issues.
	813	*/
	814	const int chunk_size = INT_MAX & ~0x3FFF;
	815	fwrite(data, 1, chunk_size, fp);
	816	data += chunk_size;
	817	size -= chunk_size;
	818	}
	819	#ifdef __VMS
	820	if (size) fwrite(data, (int)size, 1, fp);
	821	#else
	822	fwrite(data, 1, (int)size, fp);
	823	#endif
	824	return 0;
	825	}
	826
	827	/* figure out which quote to use; single is preferred */
	828	quote = '\'';
	829	if (memchr(op->ob_sval, '\'', op->ob_size) &&
	830	!memchr(op->ob_sval, '"', op->ob_size))
	831	quote = '"';
	832
	833	fputc(quote, fp);
	834	for (i = 0; i < op->ob_size; i++) {
	835	c = op->ob_sval[i];
	836	if (c == quote \|\| c == '\\')
	837	fprintf(fp, "\\%c", c);
	838	else if (c == '\t')
	839	fprintf(fp, "\\t");
	840	else if (c == '\n')
	841	fprintf(fp, "\\n");
	842	else if (c == '\r')
	843	fprintf(fp, "\\r");
	844	else if (c < ' ' \|\| c >= 0x7f)
	845	fprintf(fp, "\\x%02x", c & 0xff);
	846	else
	847	fputc(c, fp);
	848	}
	849	fputc(quote, fp);
	850	return 0;
	851	}
	852
	853	PyObject *
	854	PyString_Repr(PyObject *obj, int smartquotes)
	855	{
	856	register PyStringObject* op = (PyStringObject*) obj;
	857	size_t newsize = 2 + 4 * op->ob_size;
	858	PyObject *v;
	859	if (newsize > PY_SSIZE_T_MAX \|\| newsize / 4 != op->ob_size) {
	860	PyErr_SetString(PyExc_OverflowError,
	861	"string is too large to make repr");
	862	}
	863	v = PyString_FromStringAndSize((char *)NULL, newsize);
	864	if (v == NULL) {
	865	return NULL;
	866	}
	867	else {
	868	register Py_ssize_t i;
	869	register char c;
	870	register char *p;
	871	int quote;
	872
	873	/* figure out which quote to use; single is preferred */
	874	quote = '\'';
	875	if (smartquotes &&
	876	memchr(op->ob_sval, '\'', op->ob_size) &&
	877	!memchr(op->ob_sval, '"', op->ob_size))
	878	quote = '"';
	879
	880	p = PyString_AS_STRING(v);
	881	*p++ = quote;
	882	for (i = 0; i < op->ob_size; i++) {
	883	/* There's at least enough room for a hex escape
	884	and a closing quote. */
	885	assert(newsize - (p - PyString_AS_STRING(v)) >= 5);
	886	c = op->ob_sval[i];
	887	if (c == quote \|\| c == '\\')
	888	p++ = '\\', p++ = c;
	889	else if (c == '\t')
	890	p++ = '\\', p++ = 't';
	891	else if (c == '\n')
	892	p++ = '\\', p++ = 'n';
	893	else if (c == '\r')
	894	p++ = '\\', p++ = 'r';
	895	else if (c < ' ' \|\| c >= 0x7f) {
	896	/* For performance, we don't want to call
	897	PyOS_snprintf here (extra layers of
	898	function call). */
	899	sprintf(p, "\\x%02x", c & 0xff);
	900	p += 4;
	901	}
	902	else
	903	*p++ = c;
	904	}
	905	assert(newsize - (p - PyString_AS_STRING(v)) >= 1);
	906	*p++ = quote;
	907	*p = '\0';
	908	_PyString_Resize(
	909	&v, (p - PyString_AS_STRING(v)));
	910	return v;
	911	}
	912	}
	913
	914	static PyObject *
	915	string_repr(PyObject *op)
	916	{
	917	return PyString_Repr(op, 1);
	918	}
	919
	920	static PyObject *
	921	string_str(PyObject *s)
	922	{
	923	assert(PyString_Check(s));
	924	if (PyString_CheckExact(s)) {
	925	Py_INCREF(s);
	926	return s;
	927	}
	928	else {
	929	/* Subtype -- return genuine string with the same value. */
	930	PyStringObject t = (PyStringObject ) s;
	931	return PyString_FromStringAndSize(t->ob_sval, t->ob_size);
	932	}
	933	}
	934
	935	static Py_ssize_t
	936	string_length(PyStringObject *a)
	937	{
	938	return a->ob_size;
	939	}
	940
	941	static PyObject *
	942	string_concat(register PyStringObject a, register PyObject bb)
	943	{
	944	register Py_ssize_t size;
	945	register PyStringObject *op;
	946	if (!PyString_Check(bb)) {
	947	#ifdef Py_USING_UNICODE
	948	if (PyUnicode_Check(bb))
	949	return PyUnicode_Concat((PyObject *)a, bb);
	950	#endif
	951	PyErr_Format(PyExc_TypeError,
	952	"cannot concatenate 'str' and '%.200s' objects",
	953	bb->ob_type->tp_name);
	954	return NULL;
	955	}
	956	#define b ((PyStringObject *)bb)
	957	/* Optimize cases with empty left or right operand */
	958	if ((a->ob_size == 0 \|\| b->ob_size == 0) &&
	959	PyString_CheckExact(a) && PyString_CheckExact(b)) {
	960	if (a->ob_size == 0) {
	961	Py_INCREF(bb);
	962	return bb;
	963	}
	964	Py_INCREF(a);
	965	return (PyObject *)a;
	966	}
	967	size = a->ob_size + b->ob_size;
	968	if (size < 0) {
	969	PyErr_SetString(PyExc_OverflowError,
	970	"strings are too large to concat");
	971	return NULL;
	972	}
	973
	974	/* Inline PyObject_NewVar */
	975	op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
	976	if (op == NULL)
	977	return PyErr_NoMemory();
	978	PyObject_INIT_VAR(op, &PyString_Type, size);
	979	op->ob_shash = -1;
	980	op->ob_sstate = SSTATE_NOT_INTERNED;
	981	Py_MEMCPY(op->ob_sval, a->ob_sval, a->ob_size);
	982	Py_MEMCPY(op->ob_sval + a->ob_size, b->ob_sval, b->ob_size);
	983	op->ob_sval[size] = '\0';
	984	return (PyObject *) op;
	985	#undef b
	986	}
	987
	988	static PyObject *
	989	string_repeat(register PyStringObject *a, register Py_ssize_t n)
	990	{
	991	register Py_ssize_t i;
	992	register Py_ssize_t j;
	993	register Py_ssize_t size;
	994	register PyStringObject *op;
	995	size_t nbytes;
	996	if (n < 0)
	997	n = 0;
	998	/* watch out for overflows: the size can overflow int,
	999	* and the # of bytes needed can overflow size_t
	1000	*/
	1001	size = a->ob_size * n;
	1002	if (n && size / n != a->ob_size) {
	1003	PyErr_SetString(PyExc_OverflowError,
	1004	"repeated string is too long");
	1005	return NULL;
	1006	}
	1007	if (size == a->ob_size && PyString_CheckExact(a)) {
	1008	Py_INCREF(a);
	1009	return (PyObject *)a;
	1010	}
	1011	nbytes = (size_t)size;
	1012	if (nbytes + sizeof(PyStringObject) <= nbytes) {
	1013	PyErr_SetString(PyExc_OverflowError,
	1014	"repeated string is too long");
	1015	return NULL;
	1016	}
	1017	op = (PyStringObject *)
	1018	PyObject_MALLOC(sizeof(PyStringObject) + nbytes);
	1019	if (op == NULL)
	1020	return PyErr_NoMemory();
	1021	PyObject_INIT_VAR(op, &PyString_Type, size);
	1022	op->ob_shash = -1;
	1023	op->ob_sstate = SSTATE_NOT_INTERNED;
	1024	op->ob_sval[size] = '\0';
	1025	if (a->ob_size == 1 && n > 0) {
	1026	memset(op->ob_sval, a->ob_sval[0] , n);
	1027	return (PyObject *) op;
	1028	}
	1029	i = 0;
	1030	if (i < size) {
	1031	Py_MEMCPY(op->ob_sval, a->ob_sval, a->ob_size);
	1032	i = a->ob_size;
	1033	}
	1034	while (i < size) {
	1035	j = (i <= size-i) ? i : size-i;
	1036	Py_MEMCPY(op->ob_sval+i, op->ob_sval, j);
	1037	i += j;
	1038	}
	1039	return (PyObject *) op;
	1040	}
	1041
	1042	/* String slice a[i:j] consists of characters a[i] ... a[j-1] */
	1043
	1044	static PyObject *
	1045	string_slice(register PyStringObject *a, register Py_ssize_t i,
	1046	register Py_ssize_t j)
	1047	/* j -- may be negative! */
	1048	{
	1049	if (i < 0)
	1050	i = 0;
	1051	if (j < 0)
	1052	j = 0; /* Avoid signed/unsigned bug in next line */
	1053	if (j > a->ob_size)
	1054	j = a->ob_size;
	1055	if (i == 0 && j == a->ob_size && PyString_CheckExact(a)) {
	1056	/* It's the same as a */
	1057	Py_INCREF(a);
	1058	return (PyObject *)a;
	1059	}
	1060	if (j < i)
	1061	j = i;
	1062	return PyString_FromStringAndSize(a->ob_sval + i, j-i);
	1063	}
	1064
	1065	static int
	1066	string_contains(PyObject str_obj, PyObject sub_obj)
	1067	{
	1068	if (!PyString_CheckExact(sub_obj)) {
	1069	#ifdef Py_USING_UNICODE
	1070	if (PyUnicode_Check(sub_obj))
	1071	return PyUnicode_Contains(str_obj, sub_obj);
	1072	#endif
	1073	if (!PyString_Check(sub_obj)) {
	1074	PyErr_SetString(PyExc_TypeError,
	1075	"'in <string>' requires string as left operand");
	1076	return -1;
	1077	}
	1078	}
	1079
	1080	return stringlib_contains_obj(str_obj, sub_obj);
	1081	}
	1082
	1083	static PyObject *
	1084	string_item(PyStringObject *a, register Py_ssize_t i)
	1085	{
	1086	char pchar;
	1087	PyObject *v;
	1088	if (i < 0 \|\| i >= a->ob_size) {
	1089	PyErr_SetString(PyExc_IndexError, "string index out of range");
	1090	return NULL;
	1091	}
	1092	pchar = a->ob_sval[i];
	1093	v = (PyObject *)characters[pchar & UCHAR_MAX];
	1094	if (v == NULL)
	1095	v = PyString_FromStringAndSize(&pchar, 1);
	1096	else {
	1097	#ifdef COUNT_ALLOCS
	1098	one_strings++;
	1099	#endif
	1100	Py_INCREF(v);
	1101	}
	1102	return v;
	1103	}
	1104
	1105	static PyObject*
	1106	string_richcompare(PyStringObject a, PyStringObject b, int op)
	1107	{
	1108	int c;
	1109	Py_ssize_t len_a, len_b;
	1110	Py_ssize_t min_len;
	1111	PyObject *result;
	1112
	1113	/* Make sure both arguments are strings. */
	1114	if (!(PyString_Check(a) && PyString_Check(b))) {
	1115	result = Py_NotImplemented;
	1116	goto out;
	1117	}
	1118	if (a == b) {
	1119	switch (op) {
	1120	case Py_EQ:case Py_LE:case Py_GE:
	1121	result = Py_True;
	1122	goto out;
	1123	case Py_NE:case Py_LT:case Py_GT:
	1124	result = Py_False;
	1125	goto out;
	1126	}
	1127	}
	1128	if (op == Py_EQ) {
	1129	/* Supporting Py_NE here as well does not save
	1130	much time, since Py_NE is rarely used. */
	1131	if (a->ob_size == b->ob_size
	1132	&& (a->ob_sval[0] == b->ob_sval[0]
	1133	&& memcmp(a->ob_sval, b->ob_sval,
	1134	a->ob_size) == 0)) {
	1135	result = Py_True;
	1136	} else {
	1137	result = Py_False;
	1138	}
	1139	goto out;
	1140	}
	1141	len_a = a->ob_size; len_b = b->ob_size;
	1142	min_len = (len_a < len_b) ? len_a : len_b;
	1143	if (min_len > 0) {
	1144	c = Py_CHARMASK(a->ob_sval) - Py_CHARMASK(b->ob_sval);
	1145	if (c==0)
	1146	c = memcmp(a->ob_sval, b->ob_sval, min_len);
	1147	}else
	1148	c = 0;
	1149	if (c == 0)
	1150	c = (len_a < len_b) ? -1 : (len_a > len_b) ? 1 : 0;
	1151	switch (op) {
	1152	case Py_LT: c = c < 0; break;
	1153	case Py_LE: c = c <= 0; break;
	1154	case Py_EQ: assert(0); break; /* unreachable */
	1155	case Py_NE: c = c != 0; break;
	1156	case Py_GT: c = c > 0; break;
	1157	case Py_GE: c = c >= 0; break;
	1158	default:
	1159	result = Py_NotImplemented;
	1160	goto out;
	1161	}
	1162	result = c ? Py_True : Py_False;
	1163	out:
	1164	Py_INCREF(result);
	1165	return result;
	1166	}
	1167
	1168	int
	1169	_PyString_Eq(PyObject o1, PyObject o2)
	1170	{
	1171	PyStringObject a = (PyStringObject) o1;
	1172	PyStringObject b = (PyStringObject) o2;
	1173	return a->ob_size == b->ob_size
	1174	&& a->ob_sval == b->ob_sval
	1175	&& memcmp(a->ob_sval, b->ob_sval, a->ob_size) == 0;
	1176	}
	1177
	1178	static long
	1179	string_hash(PyStringObject *a)
	1180	{
	1181	register Py_ssize_t len;
	1182	register unsigned char *p;
	1183	register long x;
	1184
	1185	if (a->ob_shash != -1)
	1186	return a->ob_shash;
	1187	len = a->ob_size;
	1188	p = (unsigned char *) a->ob_sval;
	1189	x = *p << 7;
	1190	while (--len >= 0)
	1191	x = (1000003x) ^ p++;
	1192	x ^= a->ob_size;
	1193	if (x == -1)
	1194	x = -2;
	1195	a->ob_shash = x;
	1196	return x;
	1197	}
	1198
	1199	static PyObject*
	1200	string_subscript(PyStringObject* self, PyObject* item)
	1201	{
	1202	if (PyIndex_Check(item)) {
	1203	Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
	1204	if (i == -1 && PyErr_Occurred())
	1205	return NULL;
	1206	if (i < 0)
	1207	i += PyString_GET_SIZE(self);
	1208	return string_item(self, i);
	1209	}
	1210	else if (PySlice_Check(item)) {
	1211	Py_ssize_t start, stop, step, slicelength, cur, i;
	1212	char* source_buf;
	1213	char* result_buf;
	1214	PyObject* result;
	1215
	1216	if (PySlice_GetIndicesEx((PySliceObject*)item,
	1217	PyString_GET_SIZE(self),
	1218	&start, &stop, &step, &slicelength) < 0) {
	1219	return NULL;
	1220	}
	1221
	1222	if (slicelength <= 0) {
	1223	return PyString_FromStringAndSize("", 0);
	1224	}
	1225	else {
	1226	source_buf = PyString_AsString((PyObject*)self);
	1227	result_buf = (char *)PyMem_Malloc(slicelength);
	1228	if (result_buf == NULL)
	1229	return PyErr_NoMemory();
	1230
	1231	for (cur = start, i = 0; i < slicelength;
	1232	cur += step, i++) {
	1233	result_buf[i] = source_buf[cur];
	1234	}
	1235
	1236	result = PyString_FromStringAndSize(result_buf,
	1237	slicelength);
	1238	PyMem_Free(result_buf);
	1239	return result;
	1240	}
	1241	}
	1242	else {
	1243	PyErr_SetString(PyExc_TypeError,
	1244	"string indices must be integers");
	1245	return NULL;
	1246	}
	1247	}
	1248
	1249	static Py_ssize_t
	1250	string_buffer_getreadbuf(PyStringObject self, Py_ssize_t index, const void *ptr)
	1251	{
	1252	if ( index != 0 ) {
	1253	PyErr_SetString(PyExc_SystemError,
	1254	"accessing non-existent string segment");
	1255	return -1;
	1256	}
	1257	ptr = (void )self->ob_sval;
	1258	return self->ob_size;
	1259	}
	1260
	1261	static Py_ssize_t
	1262	string_buffer_getwritebuf(PyStringObject self, Py_ssize_t index, const void *ptr)
	1263	{
	1264	PyErr_SetString(PyExc_TypeError,
	1265	"Cannot use string as modifiable buffer");
	1266	return -1;
	1267	}
	1268
	1269	static Py_ssize_t
	1270	string_buffer_getsegcount(PyStringObject self, Py_ssize_t lenp)
	1271	{
	1272	if ( lenp )
	1273	*lenp = self->ob_size;
	1274	return 1;
	1275	}
	1276
	1277	static Py_ssize_t
	1278	string_buffer_getcharbuf(PyStringObject self, Py_ssize_t index, const char *ptr)
	1279	{
	1280	if ( index != 0 ) {
	1281	PyErr_SetString(PyExc_SystemError,
	1282	"accessing non-existent string segment");
	1283	return -1;
	1284	}
	1285	*ptr = self->ob_sval;
	1286	return self->ob_size;
	1287	}
	1288
	1289	static PySequenceMethods string_as_sequence = {
	1290	(lenfunc)string_length, /sq_length/
	1291	(binaryfunc)string_concat, /sq_concat/
	1292	(ssizeargfunc)string_repeat, /sq_repeat/
	1293	(ssizeargfunc)string_item, /sq_item/
	1294	(ssizessizeargfunc)string_slice, /sq_slice/
	1295	0, /sq_ass_item/
	1296	0, /sq_ass_slice/
	1297	(objobjproc)string_contains /sq_contains/
	1298	};
	1299
	1300	static PyMappingMethods string_as_mapping = {
	1301	(lenfunc)string_length,
	1302	(binaryfunc)string_subscript,
	1303	0,
	1304	};
	1305
	1306	static PyBufferProcs string_as_buffer = {
	1307	(readbufferproc)string_buffer_getreadbuf,
	1308	(writebufferproc)string_buffer_getwritebuf,
	1309	(segcountproc)string_buffer_getsegcount,
	1310	(charbufferproc)string_buffer_getcharbuf,
	1311	};
	1312
	1313
	1314
	1315	#define LEFTSTRIP 0
	1316	#define RIGHTSTRIP 1
	1317	#define BOTHSTRIP 2
	1318
	1319	/* Arrays indexed by above */
	1320	static const char *stripformat[] = {"\|O:lstrip", "\|O:rstrip", "\|O:strip"};
	1321
	1322	#define STRIPNAME(i) (stripformat[i]+3)
	1323
	1324
	1325	/* Don't call if length < 2 */
	1326	#define Py_STRING_MATCH(target, offset, pattern, length) \
	1327	(target[offset] == pattern[0] && \
	1328	target[offset+length-1] == pattern[length-1] && \
	1329	!memcmp(target+offset+1, pattern+1, length-2) )
	1330
	1331
	1332	/* Overallocate the initial list to reduce the number of reallocs for small
	1333	split sizes. Eg, "A A A A A A A A A A".split() (10 elements) has three
	1334	resizes, to sizes 4, 8, then 16. Most observed string splits are for human
	1335	text (roughly 11 words per line) and field delimited data (usually 1-10
	1336	fields). For large strings the split algorithms are bandwidth limited
	1337	so increasing the preallocation likely will not improve things.*/
	1338
	1339	#define MAX_PREALLOC 12
	1340
	1341	/* 5 splits gives 6 elements */
	1342	#define PREALLOC_SIZE(maxsplit) \
	1343	(maxsplit >= MAX_PREALLOC ? MAX_PREALLOC : maxsplit+1)
	1344
	1345	#define SPLIT_APPEND(data, left, right) \
	1346	str = PyString_FromStringAndSize((data) + (left), \
	1347	(right) - (left)); \
	1348	if (str == NULL) \
	1349	goto onError; \
	1350	if (PyList_Append(list, str)) { \
	1351	Py_DECREF(str); \
	1352	goto onError; \
	1353	} \
	1354	else \
	1355	Py_DECREF(str);
	1356
	1357	#define SPLIT_ADD(data, left, right) { \
	1358	str = PyString_FromStringAndSize((data) + (left), \
	1359	(right) - (left)); \
	1360	if (str == NULL) \
	1361	goto onError; \
	1362	if (count < MAX_PREALLOC) { \
	1363	PyList_SET_ITEM(list, count, str); \
	1364	} else { \
	1365	if (PyList_Append(list, str)) { \
	1366	Py_DECREF(str); \
	1367	goto onError; \
	1368	} \
	1369	else \
	1370	Py_DECREF(str); \
	1371	} \
	1372	count++; }
	1373
	1374	/* Always force the list to the expected size. */
	1375	#define FIX_PREALLOC_SIZE(list) ((PyListObject *)list)->ob_size = count
	1376
	1377	#define SKIP_SPACE(s, i, len) { while (i<len && isspace(Py_CHARMASK(s[i]))) i++; }
	1378	#define SKIP_NONSPACE(s, i, len) { while (i<len && !isspace(Py_CHARMASK(s[i]))) i++; }
	1379	#define RSKIP_SPACE(s, i) { while (i>=0 && isspace(Py_CHARMASK(s[i]))) i--; }
	1380	#define RSKIP_NONSPACE(s, i) { while (i>=0 && !isspace(Py_CHARMASK(s[i]))) i--; }
	1381
	1382	Py_LOCAL_INLINE(PyObject *)
	1383	split_whitespace(const char *s, Py_ssize_t len, Py_ssize_t maxsplit)
	1384	{
	1385	Py_ssize_t i, j, count=0;
	1386	PyObject *str;
	1387	PyObject *list = PyList_New(PREALLOC_SIZE(maxsplit));
	1388
	1389	if (list == NULL)
	1390	return NULL;
	1391
	1392	i = j = 0;
	1393
	1394	while (maxsplit-- > 0) {
	1395	SKIP_SPACE(s, i, len);
	1396	if (i==len) break;
	1397	j = i; i++;
	1398	SKIP_NONSPACE(s, i, len);
	1399	SPLIT_ADD(s, j, i);
	1400	}
	1401
	1402	if (i < len) {
	1403	/* Only occurs when maxsplit was reached */
	1404	/* Skip any remaining whitespace and copy to end of string */
	1405	SKIP_SPACE(s, i, len);
	1406	if (i != len)
	1407	SPLIT_ADD(s, i, len);
	1408	}
	1409	FIX_PREALLOC_SIZE(list);
	1410	return list;
	1411	onError:
	1412	Py_DECREF(list);
	1413	return NULL;
	1414	}
	1415
	1416	Py_LOCAL_INLINE(PyObject *)
	1417	split_char(const char *s, Py_ssize_t len, char ch, Py_ssize_t maxcount)
	1418	{
	1419	register Py_ssize_t i, j, count=0;
	1420	PyObject *str;
	1421	PyObject *list = PyList_New(PREALLOC_SIZE(maxcount));
	1422
	1423	if (list == NULL)
	1424	return NULL;
	1425
	1426	i = j = 0;
	1427	while ((j < len) && (maxcount-- > 0)) {
	1428	for(; j<len; j++) {
	1429	/* I found that using memchr makes no difference */
	1430	if (s[j] == ch) {
	1431	SPLIT_ADD(s, i, j);
	1432	i = j = j + 1;
	1433	break;
	1434	}
	1435	}
	1436	}
	1437	if (i <= len) {
	1438	SPLIT_ADD(s, i, len);
	1439	}
	1440	FIX_PREALLOC_SIZE(list);
	1441	return list;
	1442
	1443	onError:
	1444	Py_DECREF(list);
	1445	return NULL;
	1446	}
	1447
	1448	PyDoc_STRVAR(split__doc__,
	1449	"S.split([sep [,maxsplit]]) -> list of strings\n\
	1450	\n\
	1451	Return a list of the words in the string S, using sep as the\n\
	1452	delimiter string. If maxsplit is given, at most maxsplit\n\
	1453	splits are done. If sep is not specified or is None, any\n\
	1454	whitespace string is a separator.");
	1455
	1456	static PyObject *
	1457	string_split(PyStringObject self, PyObject args)
	1458	{
	1459	Py_ssize_t len = PyString_GET_SIZE(self), n, i, j;
	1460	Py_ssize_t maxsplit = -1, count=0;
	1461	const char s = PyString_AS_STRING(self), sub;
	1462	PyObject list, str, *subobj = Py_None;
	1463	#ifdef USE_FAST
	1464	Py_ssize_t pos;
	1465	#endif
	1466
	1467	if (!PyArg_ParseTuple(args, "\|On:split", &subobj, &maxsplit))
	1468	return NULL;
	1469	if (maxsplit < 0)
	1470	maxsplit = PY_SSIZE_T_MAX;
	1471	if (subobj == Py_None)
	1472	return split_whitespace(s, len, maxsplit);
	1473	if (PyString_Check(subobj)) {
	1474	sub = PyString_AS_STRING(subobj);
	1475	n = PyString_GET_SIZE(subobj);
	1476	}
	1477	#ifdef Py_USING_UNICODE
	1478	else if (PyUnicode_Check(subobj))
	1479	return PyUnicode_Split((PyObject *)self, subobj, maxsplit);
	1480	#endif
	1481	else if (PyObject_AsCharBuffer(subobj, &sub, &n))
	1482	return NULL;
	1483
	1484	if (n == 0) {
	1485	PyErr_SetString(PyExc_ValueError, "empty separator");
	1486	return NULL;
	1487	}
	1488	else if (n == 1)
	1489	return split_char(s, len, sub[0], maxsplit);
	1490
	1491	list = PyList_New(PREALLOC_SIZE(maxsplit));
	1492	if (list == NULL)
	1493	return NULL;
	1494
	1495	#ifdef USE_FAST
	1496	i = j = 0;
	1497	while (maxsplit-- > 0) {
	1498	pos = fastsearch(s+i, len-i, sub, n, FAST_SEARCH);
	1499	if (pos < 0)
	1500	break;
	1501	j = i+pos;
	1502	SPLIT_ADD(s, i, j);
	1503	i = j + n;
	1504	}
	1505	#else
	1506	i = j = 0;
	1507	while ((j+n <= len) && (maxsplit-- > 0)) {
	1508	for (; j+n <= len; j++) {
	1509	if (Py_STRING_MATCH(s, j, sub, n)) {
	1510	SPLIT_ADD(s, i, j);
	1511	i = j = j + n;
	1512	break;
	1513	}
	1514	}
	1515	}
	1516	#endif
	1517	SPLIT_ADD(s, i, len);
	1518	FIX_PREALLOC_SIZE(list);
	1519	return list;
	1520
	1521	onError:
	1522	Py_DECREF(list);
	1523	return NULL;
	1524	}
	1525
	1526	PyDoc_STRVAR(partition__doc__,
	1527	"S.partition(sep) -> (head, sep, tail)\n\
	1528	\n\
	1529	Searches for the separator sep in S, and returns the part before it,\n\
	1530	the separator itself, and the part after it. If the separator is not\n\
	1531	found, returns S and two empty strings.");
	1532
	1533	static PyObject *
	1534	string_partition(PyStringObject self, PyObject sep_obj)
	1535	{
	1536	const char *sep;
	1537	Py_ssize_t sep_len;
	1538
	1539	if (PyString_Check(sep_obj)) {
	1540	sep = PyString_AS_STRING(sep_obj);
	1541	sep_len = PyString_GET_SIZE(sep_obj);
	1542	}
	1543	#ifdef Py_USING_UNICODE
	1544	else if (PyUnicode_Check(sep_obj))
	1545	return PyUnicode_Partition((PyObject *) self, sep_obj);
	1546	#endif
	1547	else if (PyObject_AsCharBuffer(sep_obj, &sep, &sep_len))
	1548	return NULL;
	1549
	1550	return stringlib_partition(
	1551	(PyObject*) self,
	1552	PyString_AS_STRING(self), PyString_GET_SIZE(self),
	1553	sep_obj, sep, sep_len
	1554	);
	1555	}
	1556
	1557	PyDoc_STRVAR(rpartition__doc__,
	1558	"S.rpartition(sep) -> (tail, sep, head)\n\
	1559	\n\
	1560	Searches for the separator sep in S, starting at the end of S, and returns\n\
	1561	the part before it, the separator itself, and the part after it. If the\n\
	1562	separator is not found, returns two empty strings and S.");
	1563
	1564	static PyObject *
	1565	string_rpartition(PyStringObject self, PyObject sep_obj)
	1566	{
	1567	const char *sep;
	1568	Py_ssize_t sep_len;
	1569
	1570	if (PyString_Check(sep_obj)) {
	1571	sep = PyString_AS_STRING(sep_obj);
	1572	sep_len = PyString_GET_SIZE(sep_obj);
	1573	}
	1574	#ifdef Py_USING_UNICODE
	1575	else if (PyUnicode_Check(sep_obj))
	1576	return PyUnicode_Partition((PyObject *) self, sep_obj);
	1577	#endif
	1578	else if (PyObject_AsCharBuffer(sep_obj, &sep, &sep_len))
	1579	return NULL;
	1580
	1581	return stringlib_rpartition(
	1582	(PyObject*) self,
	1583	PyString_AS_STRING(self), PyString_GET_SIZE(self),
	1584	sep_obj, sep, sep_len
	1585	);
	1586	}
	1587
	1588	Py_LOCAL_INLINE(PyObject *)
	1589	rsplit_whitespace(const char *s, Py_ssize_t len, Py_ssize_t maxsplit)
	1590	{
	1591	Py_ssize_t i, j, count=0;
	1592	PyObject *str;
	1593	PyObject *list = PyList_New(PREALLOC_SIZE(maxsplit));
	1594
	1595	if (list == NULL)
	1596	return NULL;
	1597
	1598	i = j = len-1;
	1599
	1600	while (maxsplit-- > 0) {
	1601	RSKIP_SPACE(s, i);
	1602	if (i<0) break;
	1603	j = i; i--;
	1604	RSKIP_NONSPACE(s, i);
	1605	SPLIT_ADD(s, i + 1, j + 1);
	1606	}
	1607	if (i >= 0) {
	1608	/* Only occurs when maxsplit was reached */
	1609	/* Skip any remaining whitespace and copy to beginning of string */
	1610	RSKIP_SPACE(s, i);
	1611	if (i >= 0)
	1612	SPLIT_ADD(s, 0, i + 1);
	1613
	1614	}
	1615	FIX_PREALLOC_SIZE(list);
	1616	if (PyList_Reverse(list) < 0)
	1617	goto onError;
	1618	return list;
	1619	onError:
	1620	Py_DECREF(list);
	1621	return NULL;
	1622	}
	1623
	1624	Py_LOCAL_INLINE(PyObject *)
	1625	rsplit_char(const char *s, Py_ssize_t len, char ch, Py_ssize_t maxcount)
	1626	{
	1627	register Py_ssize_t i, j, count=0;
	1628	PyObject *str;
	1629	PyObject *list = PyList_New(PREALLOC_SIZE(maxcount));
	1630
	1631	if (list == NULL)
	1632	return NULL;
	1633
	1634	i = j = len - 1;
	1635	while ((i >= 0) && (maxcount-- > 0)) {
	1636	for (; i >= 0; i--) {
	1637	if (s[i] == ch) {
	1638	SPLIT_ADD(s, i + 1, j + 1);
	1639	j = i = i - 1;
	1640	break;
	1641	}
	1642	}
	1643	}
	1644	if (j >= -1) {
	1645	SPLIT_ADD(s, 0, j + 1);
	1646	}
	1647	FIX_PREALLOC_SIZE(list);
	1648	if (PyList_Reverse(list) < 0)
	1649	goto onError;
	1650	return list;
	1651
	1652	onError:
	1653	Py_DECREF(list);
	1654	return NULL;
	1655	}
	1656
	1657	PyDoc_STRVAR(rsplit__doc__,
	1658	"S.rsplit([sep [,maxsplit]]) -> list of strings\n\
	1659	\n\
	1660	Return a list of the words in the string S, using sep as the\n\
	1661	delimiter string, starting at the end of the string and working\n\
	1662	to the front. If maxsplit is given, at most maxsplit splits are\n\
	1663	done. If sep is not specified or is None, any whitespace string\n\
	1664	is a separator.");
	1665
	1666	static PyObject *
	1667	string_rsplit(PyStringObject self, PyObject args)
	1668	{
	1669	Py_ssize_t len = PyString_GET_SIZE(self), n, i, j;
	1670	Py_ssize_t maxsplit = -1, count=0;
	1671	const char s = PyString_AS_STRING(self), sub;
	1672	PyObject list, str, *subobj = Py_None;
	1673
	1674	if (!PyArg_ParseTuple(args, "\|On:rsplit", &subobj, &maxsplit))
	1675	return NULL;
	1676	if (maxsplit < 0)
	1677	maxsplit = PY_SSIZE_T_MAX;
	1678	if (subobj == Py_None)
	1679	return rsplit_whitespace(s, len, maxsplit);
	1680	if (PyString_Check(subobj)) {
	1681	sub = PyString_AS_STRING(subobj);
	1682	n = PyString_GET_SIZE(subobj);
	1683	}
	1684	#ifdef Py_USING_UNICODE
	1685	else if (PyUnicode_Check(subobj))
	1686	return PyUnicode_RSplit((PyObject *)self, subobj, maxsplit);
	1687	#endif
	1688	else if (PyObject_AsCharBuffer(subobj, &sub, &n))
	1689	return NULL;
	1690
	1691	if (n == 0) {
	1692	PyErr_SetString(PyExc_ValueError, "empty separator");
	1693	return NULL;
	1694	}
	1695	else if (n == 1)
	1696	return rsplit_char(s, len, sub[0], maxsplit);
	1697
	1698	list = PyList_New(PREALLOC_SIZE(maxsplit));
	1699	if (list == NULL)
	1700	return NULL;
	1701
	1702	j = len;
	1703	i = j - n;
	1704
	1705	while ( (i >= 0) && (maxsplit-- > 0) ) {
	1706	for (; i>=0; i--) {
	1707	if (Py_STRING_MATCH(s, i, sub, n)) {
	1708	SPLIT_ADD(s, i + n, j);
	1709	j = i;
	1710	i -= n;
	1711	break;
	1712	}
	1713	}
	1714	}
	1715	SPLIT_ADD(s, 0, j);
	1716	FIX_PREALLOC_SIZE(list);
	1717	if (PyList_Reverse(list) < 0)
	1718	goto onError;
	1719	return list;
	1720
	1721	onError:
	1722	Py_DECREF(list);
	1723	return NULL;
	1724	}
	1725
	1726
	1727	PyDoc_STRVAR(join__doc__,
	1728	"S.join(sequence) -> string\n\
	1729	\n\
	1730	Return a string which is the concatenation of the strings in the\n\
	1731	sequence. The separator between elements is S.");
	1732
	1733	static PyObject *
	1734	string_join(PyStringObject self, PyObject orig)
	1735	{
	1736	char *sep = PyString_AS_STRING(self);
	1737	const Py_ssize_t seplen = PyString_GET_SIZE(self);
	1738	PyObject *res = NULL;
	1739	char *p;
	1740	Py_ssize_t seqlen = 0;
	1741	size_t sz = 0;
	1742	Py_ssize_t i;
	1743	PyObject seq, item;
	1744
	1745	seq = PySequence_Fast(orig, "");
	1746	if (seq == NULL) {
	1747	return NULL;
	1748	}
	1749
	1750	seqlen = PySequence_Size(seq);
	1751	if (seqlen == 0) {
	1752	Py_DECREF(seq);
	1753	return PyString_FromString("");
	1754	}
	1755	if (seqlen == 1) {
	1756	item = PySequence_Fast_GET_ITEM(seq, 0);
	1757	if (PyString_CheckExact(item) \|\| PyUnicode_CheckExact(item)) {
	1758	Py_INCREF(item);
	1759	Py_DECREF(seq);
	1760	return item;
	1761	}
	1762	}
	1763
	1764	/* There are at least two things to join, or else we have a subclass
	1765	* of the builtin types in the sequence.
	1766	* Do a pre-pass to figure out the total amount of space we'll
	1767	* need (sz), see whether any argument is absurd, and defer to
	1768	* the Unicode join if appropriate.
	1769	*/
	1770	for (i = 0; i < seqlen; i++) {
	1771	const size_t old_sz = sz;
	1772	item = PySequence_Fast_GET_ITEM(seq, i);
	1773	if (!PyString_Check(item)){
	1774	#ifdef Py_USING_UNICODE
	1775	if (PyUnicode_Check(item)) {
	1776	/* Defer to Unicode join.
	1777	* CAUTION: There's no gurantee that the
	1778	* original sequence can be iterated over
	1779	* again, so we must pass seq here.
	1780	*/
	1781	PyObject *result;
	1782	result = PyUnicode_Join((PyObject *)self, seq);
	1783	Py_DECREF(seq);
	1784	return result;
	1785	}
	1786	#endif
	1787	PyErr_Format(PyExc_TypeError,
	1788	"sequence item %zd: expected string,"
	1789	" %.80s found",
	1790	i, item->ob_type->tp_name);
	1791	Py_DECREF(seq);
	1792	return NULL;
	1793	}
	1794	sz += PyString_GET_SIZE(item);
	1795	if (i != 0)
	1796	sz += seplen;
	1797	if (sz < old_sz \|\| sz > PY_SSIZE_T_MAX) {
	1798	PyErr_SetString(PyExc_OverflowError,
	1799	"join() result is too long for a Python string");
	1800	Py_DECREF(seq);
	1801	return NULL;
	1802	}
	1803	}
	1804
	1805	/* Allocate result space. */
	1806	res = PyString_FromStringAndSize((char*)NULL, sz);
	1807	if (res == NULL) {
	1808	Py_DECREF(seq);
	1809	return NULL;
	1810	}
	1811
	1812	/* Catenate everything. */
	1813	p = PyString_AS_STRING(res);
	1814	for (i = 0; i < seqlen; ++i) {
	1815	size_t n;
	1816	item = PySequence_Fast_GET_ITEM(seq, i);
	1817	n = PyString_GET_SIZE(item);
	1818	Py_MEMCPY(p, PyString_AS_STRING(item), n);
	1819	p += n;
	1820	if (i < seqlen - 1) {
	1821	Py_MEMCPY(p, sep, seplen);
	1822	p += seplen;
	1823	}
	1824	}
	1825
	1826	Py_DECREF(seq);
	1827	return res;
	1828	}
	1829
	1830	PyObject *
	1831	_PyString_Join(PyObject sep, PyObject x)
	1832	{
	1833	assert(sep != NULL && PyString_Check(sep));
	1834	assert(x != NULL);
	1835	return string_join((PyStringObject *)sep, x);
	1836	}
	1837
	1838	Py_LOCAL_INLINE(void)
	1839	string_adjust_indices(Py_ssize_t start, Py_ssize_t end, Py_ssize_t len)
	1840	{
	1841	if (*end > len)
	1842	*end = len;
	1843	else if (*end < 0)
	1844	*end += len;
	1845	if (*end < 0)
	1846	*end = 0;
	1847	if (*start < 0)
	1848	*start += len;
	1849	if (*start < 0)
	1850	*start = 0;
	1851	}
	1852
	1853	Py_LOCAL_INLINE(Py_ssize_t)
	1854	string_find_internal(PyStringObject self, PyObject args, int dir)
	1855	{
	1856	PyObject *subobj;
	1857	const char *sub;
	1858	Py_ssize_t sub_len;
	1859	Py_ssize_t start=0, end=PY_SSIZE_T_MAX;
	1860
	1861	if (!PyArg_ParseTuple(args, "O\|O&O&:find/rfind/index/rindex", &subobj,
	1862	_PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
	1863	return -2;
	1864	if (PyString_Check(subobj)) {
	1865	sub = PyString_AS_STRING(subobj);
	1866	sub_len = PyString_GET_SIZE(subobj);
	1867	}
	1868	#ifdef Py_USING_UNICODE
	1869	else if (PyUnicode_Check(subobj))
	1870	return PyUnicode_Find(
	1871	(PyObject *)self, subobj, start, end, dir);
	1872	#endif
	1873	else if (PyObject_AsCharBuffer(subobj, &sub, &sub_len))
	1874	/* XXX - the "expected a character buffer object" is pretty
	1875	confusing for a non-expert. remap to something else ? */
	1876	return -2;
	1877
	1878	if (dir > 0)
	1879	return stringlib_find_slice(
	1880	PyString_AS_STRING(self), PyString_GET_SIZE(self),
	1881	sub, sub_len, start, end);
	1882	else
	1883	return stringlib_rfind_slice(
	1884	PyString_AS_STRING(self), PyString_GET_SIZE(self),
	1885	sub, sub_len, start, end);
	1886	}
	1887
	1888
	1889	PyDoc_STRVAR(find__doc__,
	1890	"S.find(sub [,start [,end]]) -> int\n\
	1891	\n\
	1892	Return the lowest index in S where substring sub is found,\n\
	1893	such that sub is contained within s[start,end]. Optional\n\
	1894	arguments start and end are interpreted as in slice notation.\n\
	1895	\n\
	1896	Return -1 on failure.");
	1897
	1898	static PyObject *
	1899	string_find(PyStringObject self, PyObject args)
	1900	{
	1901	Py_ssize_t result = string_find_internal(self, args, +1);
	1902	if (result == -2)
	1903	return NULL;
	1904	return PyInt_FromSsize_t(result);
	1905	}
	1906
	1907
	1908	PyDoc_STRVAR(index__doc__,
	1909	"S.index(sub [,start [,end]]) -> int\n\
	1910	\n\
	1911	Like S.find() but raise ValueError when the substring is not found.");
	1912
	1913	static PyObject *
	1914	string_index(PyStringObject self, PyObject args)
	1915	{
	1916	Py_ssize_t result = string_find_internal(self, args, +1);
	1917	if (result == -2)
	1918	return NULL;
	1919	if (result == -1) {
	1920	PyErr_SetString(PyExc_ValueError,
	1921	"substring not found");
	1922	return NULL;
	1923	}
	1924	return PyInt_FromSsize_t(result);
	1925	}
	1926
	1927
	1928	PyDoc_STRVAR(rfind__doc__,
	1929	"S.rfind(sub [,start [,end]]) -> int\n\
	1930	\n\
	1931	Return the highest index in S where substring sub is found,\n\
	1932	such that sub is contained within s[start,end]. Optional\n\
	1933	arguments start and end are interpreted as in slice notation.\n\
	1934	\n\
	1935	Return -1 on failure.");
	1936
	1937	static PyObject *
	1938	string_rfind(PyStringObject self, PyObject args)
	1939	{
	1940	Py_ssize_t result = string_find_internal(self, args, -1);
	1941	if (result == -2)
	1942	return NULL;
	1943	return PyInt_FromSsize_t(result);
	1944	}
	1945
	1946
	1947	PyDoc_STRVAR(rindex__doc__,
	1948	"S.rindex(sub [,start [,end]]) -> int\n\
	1949	\n\
	1950	Like S.rfind() but raise ValueError when the substring is not found.");
	1951
	1952	static PyObject *
	1953	string_rindex(PyStringObject self, PyObject args)
	1954	{
	1955	Py_ssize_t result = string_find_internal(self, args, -1);
	1956	if (result == -2)
	1957	return NULL;
	1958	if (result == -1) {
	1959	PyErr_SetString(PyExc_ValueError,
	1960	"substring not found");
	1961	return NULL;
	1962	}
	1963	return PyInt_FromSsize_t(result);
	1964	}
	1965
	1966
	1967	Py_LOCAL_INLINE(PyObject *)
	1968	do_xstrip(PyStringObject self, int striptype, PyObject sepobj)
	1969	{
	1970	char *s = PyString_AS_STRING(self);
	1971	Py_ssize_t len = PyString_GET_SIZE(self);
	1972	char *sep = PyString_AS_STRING(sepobj);
	1973	Py_ssize_t seplen = PyString_GET_SIZE(sepobj);
	1974	Py_ssize_t i, j;
	1975
	1976	i = 0;
	1977	if (striptype != RIGHTSTRIP) {
	1978	while (i < len && memchr(sep, Py_CHARMASK(s[i]), seplen)) {
	1979	i++;
	1980	}
	1981	}
	1982
	1983	j = len;
	1984	if (striptype != LEFTSTRIP) {
	1985	do {
	1986	j--;
	1987	} while (j >= i && memchr(sep, Py_CHARMASK(s[j]), seplen));
	1988	j++;
	1989	}
	1990
	1991	if (i == 0 && j == len && PyString_CheckExact(self)) {
	1992	Py_INCREF(self);
	1993	return (PyObject*)self;
	1994	}
	1995	else
	1996	return PyString_FromStringAndSize(s+i, j-i);
	1997	}
	1998
	1999
	2000	Py_LOCAL_INLINE(PyObject *)
	2001	do_strip(PyStringObject *self, int striptype)
	2002	{
	2003	char *s = PyString_AS_STRING(self);
	2004	Py_ssize_t len = PyString_GET_SIZE(self), i, j;
	2005
	2006	i = 0;
	2007	if (striptype != RIGHTSTRIP) {
	2008	while (i < len && isspace(Py_CHARMASK(s[i]))) {
	2009	i++;
	2010	}
	2011	}
	2012
	2013	j = len;
	2014	if (striptype != LEFTSTRIP) {
	2015	do {
	2016	j--;
	2017	} while (j >= i && isspace(Py_CHARMASK(s[j])));
	2018	j++;
	2019	}
	2020
	2021	if (i == 0 && j == len && PyString_CheckExact(self)) {
	2022	Py_INCREF(self);
	2023	return (PyObject*)self;
	2024	}
	2025	else
	2026	return PyString_FromStringAndSize(s+i, j-i);
	2027	}
	2028
	2029
	2030	Py_LOCAL_INLINE(PyObject *)
	2031	do_argstrip(PyStringObject self, int striptype, PyObject args)
	2032	{
	2033	PyObject *sep = NULL;
	2034
	2035	if (!PyArg_ParseTuple(args, (char *)stripformat[striptype], &sep))
	2036	return NULL;
	2037
	2038	if (sep != NULL && sep != Py_None) {
	2039	if (PyString_Check(sep))
	2040	return do_xstrip(self, striptype, sep);
	2041	#ifdef Py_USING_UNICODE
	2042	else if (PyUnicode_Check(sep)) {
	2043	PyObject uniself = PyUnicode_FromObject((PyObject )self);
	2044	PyObject *res;
	2045	if (uniself==NULL)
	2046	return NULL;
	2047	res = _PyUnicode_XStrip((PyUnicodeObject *)uniself,
	2048	striptype, sep);
	2049	Py_DECREF(uniself);
	2050	return res;
	2051	}
	2052	#endif
	2053	PyErr_Format(PyExc_TypeError,
	2054	#ifdef Py_USING_UNICODE
	2055	"%s arg must be None, str or unicode",
	2056	#else
	2057	"%s arg must be None or str",
	2058	#endif
	2059	STRIPNAME(striptype));
	2060	return NULL;
	2061	}
	2062
	2063	return do_strip(self, striptype);
	2064	}
	2065
	2066
	2067	PyDoc_STRVAR(strip__doc__,
	2068	"S.strip([chars]) -> string or unicode\n\
	2069	\n\
	2070	Return a copy of the string S with leading and trailing\n\
	2071	whitespace removed.\n\
	2072	If chars is given and not None, remove characters in chars instead.\n\
	2073	If chars is unicode, S will be converted to unicode before stripping");
	2074
	2075	static PyObject *
	2076	string_strip(PyStringObject self, PyObject args)
	2077	{
	2078	if (PyTuple_GET_SIZE(args) == 0)
	2079	return do_strip(self, BOTHSTRIP); /* Common case */
	2080	else
	2081	return do_argstrip(self, BOTHSTRIP, args);
	2082	}
	2083
	2084
	2085	PyDoc_STRVAR(lstrip__doc__,
	2086	"S.lstrip([chars]) -> string or unicode\n\
	2087	\n\
	2088	Return a copy of the string S with leading whitespace removed.\n\
	2089	If chars is given and not None, remove characters in chars instead.\n\
	2090	If chars is unicode, S will be converted to unicode before stripping");
	2091
	2092	static PyObject *
	2093	string_lstrip(PyStringObject self, PyObject args)
	2094	{
	2095	if (PyTuple_GET_SIZE(args) == 0)
	2096	return do_strip(self, LEFTSTRIP); /* Common case */
	2097	else
	2098	return do_argstrip(self, LEFTSTRIP, args);
	2099	}
	2100
	2101
	2102	PyDoc_STRVAR(rstrip__doc__,
	2103	"S.rstrip([chars]) -> string or unicode\n\
	2104	\n\
	2105	Return a copy of the string S with trailing whitespace removed.\n\
	2106	If chars is given and not None, remove characters in chars instead.\n\
	2107	If chars is unicode, S will be converted to unicode before stripping");
	2108
	2109	static PyObject *
	2110	string_rstrip(PyStringObject self, PyObject args)
	2111	{
	2112	if (PyTuple_GET_SIZE(args) == 0)
	2113	return do_strip(self, RIGHTSTRIP); /* Common case */
	2114	else
	2115	return do_argstrip(self, RIGHTSTRIP, args);
	2116	}
	2117
	2118
	2119	PyDoc_STRVAR(lower__doc__,
	2120	"S.lower() -> string\n\
	2121	\n\
	2122	Return a copy of the string S converted to lowercase.");
	2123
	2124	/* _tolower and _toupper are defined by SUSv2, but they're not ISO C */
	2125	#ifndef _tolower
	2126	#define _tolower tolower
	2127	#endif
	2128
	2129	static PyObject *
	2130	string_lower(PyStringObject *self)
	2131	{
	2132	char *s;
	2133	Py_ssize_t i, n = PyString_GET_SIZE(self);
	2134	PyObject *newobj;
	2135
	2136	newobj = PyString_FromStringAndSize(NULL, n);
	2137	if (!newobj)
	2138	return NULL;
	2139
	2140	s = PyString_AS_STRING(newobj);
	2141
	2142	Py_MEMCPY(s, PyString_AS_STRING(self), n);
	2143
	2144	for (i = 0; i < n; i++) {
	2145	int c = Py_CHARMASK(s[i]);
	2146	if (isupper(c))
	2147	s[i] = _tolower(c);
	2148	}
	2149
	2150	return newobj;
	2151	}
	2152
	2153	PyDoc_STRVAR(upper__doc__,
	2154	"S.upper() -> string\n\
	2155	\n\
	2156	Return a copy of the string S converted to uppercase.");
	2157
	2158	#ifndef _toupper
	2159	#define _toupper toupper
	2160	#endif
	2161
	2162	static PyObject *
	2163	string_upper(PyStringObject *self)
	2164	{
	2165	char *s;
	2166	Py_ssize_t i, n = PyString_GET_SIZE(self);
	2167	PyObject *newobj;
	2168
	2169	newobj = PyString_FromStringAndSize(NULL, n);
	2170	if (!newobj)
	2171	return NULL;
	2172
	2173	s = PyString_AS_STRING(newobj);
	2174
	2175	Py_MEMCPY(s, PyString_AS_STRING(self), n);
	2176
	2177	for (i = 0; i < n; i++) {
	2178	int c = Py_CHARMASK(s[i]);
	2179	if (islower(c))
	2180	s[i] = _toupper(c);
	2181	}
	2182
	2183	return newobj;
	2184	}
	2185
	2186	PyDoc_STRVAR(title__doc__,
	2187	"S.title() -> string\n\
	2188	\n\
	2189	Return a titlecased version of S, i.e. words start with uppercase\n\
	2190	characters, all remaining cased characters have lowercase.");
	2191
	2192	static PyObject*
	2193	string_title(PyStringObject *self)
	2194	{
	2195	char s = PyString_AS_STRING(self), s_new;
	2196	Py_ssize_t i, n = PyString_GET_SIZE(self);
	2197	int previous_is_cased = 0;
	2198	PyObject *newobj;
	2199
	2200	newobj = PyString_FromStringAndSize(NULL, n);
	2201	if (newobj == NULL)
	2202	return NULL;
	2203	s_new = PyString_AsString(newobj);
	2204	for (i = 0; i < n; i++) {
	2205	int c = Py_CHARMASK(*s++);
	2206	if (islower(c)) {
	2207	if (!previous_is_cased)
	2208	c = toupper(c);
	2209	previous_is_cased = 1;
	2210	} else if (isupper(c)) {
	2211	if (previous_is_cased)
	2212	c = tolower(c);
	2213	previous_is_cased = 1;
	2214	} else
	2215	previous_is_cased = 0;
	2216	*s_new++ = c;
	2217	}
	2218	return newobj;
	2219	}
	2220
	2221	PyDoc_STRVAR(capitalize__doc__,
	2222	"S.capitalize() -> string\n\
	2223	\n\
	2224	Return a copy of the string S with only its first character\n\
	2225	capitalized.");
	2226
	2227	static PyObject *
	2228	string_capitalize(PyStringObject *self)
	2229	{
	2230	char s = PyString_AS_STRING(self), s_new;
	2231	Py_ssize_t i, n = PyString_GET_SIZE(self);
	2232	PyObject *newobj;
	2233
	2234	newobj = PyString_FromStringAndSize(NULL, n);
	2235	if (newobj == NULL)
	2236	return NULL;
	2237	s_new = PyString_AsString(newobj);
	2238	if (0 < n) {
	2239	int c = Py_CHARMASK(*s++);
	2240	if (islower(c))
	2241	*s_new = toupper(c);
	2242	else
	2243	*s_new = c;
	2244	s_new++;
	2245	}
	2246	for (i = 1; i < n; i++) {
	2247	int c = Py_CHARMASK(*s++);
	2248	if (isupper(c))
	2249	*s_new = tolower(c);
	2250	else
	2251	*s_new = c;
	2252	s_new++;
	2253	}
	2254	return newobj;
	2255	}
	2256
	2257
	2258	PyDoc_STRVAR(count__doc__,
	2259	"S.count(sub[, start[, end]]) -> int\n\
	2260	\n\
	2261	Return the number of non-overlapping occurrences of substring sub in\n\
	2262	string S[start:end]. Optional arguments start and end are interpreted\n\
	2263	as in slice notation.");
	2264
	2265	static PyObject *
	2266	string_count(PyStringObject self, PyObject args)
	2267	{
	2268	PyObject *sub_obj;
	2269	const char str = PyString_AS_STRING(self), sub;
	2270	Py_ssize_t sub_len;
	2271	Py_ssize_t start = 0, end = PY_SSIZE_T_MAX;
	2272
	2273	if (!PyArg_ParseTuple(args, "O\|O&O&:count", &sub_obj,
	2274	_PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
	2275	return NULL;
	2276
	2277	if (PyString_Check(sub_obj)) {
	2278	sub = PyString_AS_STRING(sub_obj);
	2279	sub_len = PyString_GET_SIZE(sub_obj);
	2280	}
	2281	#ifdef Py_USING_UNICODE
	2282	else if (PyUnicode_Check(sub_obj)) {
	2283	Py_ssize_t count;
	2284	count = PyUnicode_Count((PyObject *)self, sub_obj, start, end);
	2285	if (count == -1)
	2286	return NULL;
	2287	else
	2288	return PyInt_FromSsize_t(count);
	2289	}
	2290	#endif
	2291	else if (PyObject_AsCharBuffer(sub_obj, &sub, &sub_len))
	2292	return NULL;
	2293
	2294	string_adjust_indices(&start, &end, PyString_GET_SIZE(self));
	2295
	2296	return PyInt_FromSsize_t(
	2297	stringlib_count(str + start, end - start, sub, sub_len)
	2298	);
	2299	}
	2300
	2301	PyDoc_STRVAR(swapcase__doc__,
	2302	"S.swapcase() -> string\n\
	2303	\n\
	2304	Return a copy of the string S with uppercase characters\n\
	2305	converted to lowercase and vice versa.");
	2306
	2307	static PyObject *
	2308	string_swapcase(PyStringObject *self)
	2309	{
	2310	char s = PyString_AS_STRING(self), s_new;
	2311	Py_ssize_t i, n = PyString_GET_SIZE(self);
	2312	PyObject *newobj;
	2313
	2314	newobj = PyString_FromStringAndSize(NULL, n);
	2315	if (newobj == NULL)
	2316	return NULL;
	2317	s_new = PyString_AsString(newobj);
	2318	for (i = 0; i < n; i++) {
	2319	int c = Py_CHARMASK(*s++);
	2320	if (islower(c)) {
	2321	*s_new = toupper(c);
	2322	}
	2323	else if (isupper(c)) {
	2324	*s_new = tolower(c);
	2325	}
	2326	else
	2327	*s_new = c;
	2328	s_new++;
	2329	}
	2330	return newobj;
	2331	}
	2332
	2333
	2334	PyDoc_STRVAR(translate__doc__,
	2335	"S.translate(table [,deletechars]) -> string\n\
	2336	\n\
	2337	Return a copy of the string S, where all characters occurring\n\
	2338	in the optional argument deletechars are removed, and the\n\
	2339	remaining characters have been mapped through the given\n\
	2340	translation table, which must be a string of length 256.");
	2341
	2342	static PyObject *
	2343	string_translate(PyStringObject self, PyObject args)
	2344	{
	2345	register char input, output;
	2346	register const char *table;
	2347	register Py_ssize_t i, c, changed = 0;
	2348	PyObject input_obj = (PyObject)self;
	2349	const char table1, output_start, *del_table=NULL;
	2350	Py_ssize_t inlen, tablen, dellen = 0;
	2351	PyObject *result;
	2352	int trans_table[256];
	2353	PyObject tableobj, delobj = NULL;
	2354
	2355	if (!PyArg_UnpackTuple(args, "translate", 1, 2,
	2356	&tableobj, &delobj))
	2357	return NULL;
	2358
	2359	if (PyString_Check(tableobj)) {
	2360	table1 = PyString_AS_STRING(tableobj);
	2361	tablen = PyString_GET_SIZE(tableobj);
	2362	}
	2363	#ifdef Py_USING_UNICODE
	2364	else if (PyUnicode_Check(tableobj)) {
	2365	/* Unicode .translate() does not support the deletechars
	2366	parameter; instead a mapping to None will cause characters
	2367	to be deleted. */
	2368	if (delobj != NULL) {
	2369	PyErr_SetString(PyExc_TypeError,
	2370	"deletions are implemented differently for unicode");
	2371	return NULL;
	2372	}
	2373	return PyUnicode_Translate((PyObject *)self, tableobj, NULL);
	2374	}
	2375	#endif
	2376	else if (PyObject_AsCharBuffer(tableobj, &table1, &tablen))
	2377	return NULL;
	2378
	2379	if (tablen != 256) {
	2380	PyErr_SetString(PyExc_ValueError,
	2381	"translation table must be 256 characters long");
	2382	return NULL;
	2383	}
	2384
	2385	if (delobj != NULL) {
	2386	if (PyString_Check(delobj)) {
	2387	del_table = PyString_AS_STRING(delobj);
	2388	dellen = PyString_GET_SIZE(delobj);
	2389	}
	2390	#ifdef Py_USING_UNICODE
	2391	else if (PyUnicode_Check(delobj)) {
	2392	PyErr_SetString(PyExc_TypeError,
	2393	"deletions are implemented differently for unicode");
	2394	return NULL;
	2395	}
	2396	#endif
	2397	else if (PyObject_AsCharBuffer(delobj, &del_table, &dellen))
	2398	return NULL;
	2399	}
	2400	else {
	2401	del_table = NULL;
	2402	dellen = 0;
	2403	}
	2404
	2405	table = table1;
	2406	inlen = PyString_GET_SIZE(input_obj);
	2407	result = PyString_FromStringAndSize((char *)NULL, inlen);
	2408	if (result == NULL)
	2409	return NULL;
	2410	output_start = output = PyString_AsString(result);
	2411	input = PyString_AS_STRING(input_obj);
	2412
	2413	if (dellen == 0) {
	2414	/* If no deletions are required, use faster code */
	2415	for (i = inlen; --i >= 0; ) {
	2416	c = Py_CHARMASK(*input++);
	2417	if (Py_CHARMASK((*output++ = table[c])) != c)
	2418	changed = 1;
	2419	}
	2420	if (changed \|\| !PyString_CheckExact(input_obj))
	2421	return result;
	2422	Py_DECREF(result);
	2423	Py_INCREF(input_obj);
	2424	return input_obj;
	2425	}
	2426
	2427	for (i = 0; i < 256; i++)
	2428	trans_table[i] = Py_CHARMASK(table[i]);
	2429
	2430	for (i = 0; i < dellen; i++)
	2431	trans_table[(int) Py_CHARMASK(del_table[i])] = -1;
	2432
	2433	for (i = inlen; --i >= 0; ) {
	2434	c = Py_CHARMASK(*input++);
	2435	if (trans_table[c] != -1)
	2436	if (Py_CHARMASK(*output++ = (char)trans_table[c]) == c)
	2437	continue;
	2438	changed = 1;
	2439	}
	2440	if (!changed && PyString_CheckExact(input_obj)) {
	2441	Py_DECREF(result);
	2442	Py_INCREF(input_obj);
	2443	return input_obj;
	2444	}
	2445	/* Fix the size of the resulting string */
	2446	if (inlen > 0)
	2447	_PyString_Resize(&result, output - output_start);
	2448	return result;
	2449	}
	2450
	2451
	2452	#define FORWARD 1
	2453	#define REVERSE -1
	2454
	2455	/* find and count characters and substrings */
	2456
	2457	#define findchar(target, target_len, c) \
	2458	((char )memchr((const void )(target), c, target_len))
	2459
	2460	/* String ops must return a string. */
	2461	/* If the object is subclass of string, create a copy */
	2462	Py_LOCAL(PyStringObject *)
	2463	return_self(PyStringObject *self)
	2464	{
	2465	if (PyString_CheckExact(self)) {
	2466	Py_INCREF(self);
	2467	return self;
	2468	}
	2469	return (PyStringObject *)PyString_FromStringAndSize(
	2470	PyString_AS_STRING(self),
	2471	PyString_GET_SIZE(self));
	2472	}
	2473
	2474	Py_LOCAL_INLINE(Py_ssize_t)
	2475	countchar(const char *target, int target_len, char c, Py_ssize_t maxcount)
	2476	{
	2477	Py_ssize_t count=0;
	2478	const char *start=target;
	2479	const char *end=target+target_len;
	2480
	2481	while ( (start=findchar(start, end-start, c)) != NULL ) {
	2482	count++;
	2483	if (count >= maxcount)
	2484	break;
	2485	start += 1;
	2486	}
	2487	return count;
	2488	}
	2489
	2490	Py_LOCAL(Py_ssize_t)
	2491	findstring(const char *target, Py_ssize_t target_len,
	2492	const char *pattern, Py_ssize_t pattern_len,
	2493	Py_ssize_t start,
	2494	Py_ssize_t end,
	2495	int direction)
	2496	{
	2497	if (start < 0) {
	2498	start += target_len;
	2499	if (start < 0)
	2500	start = 0;
	2501	}
	2502	if (end > target_len) {
	2503	end = target_len;
	2504	} else if (end < 0) {
	2505	end += target_len;
	2506	if (end < 0)
	2507	end = 0;
	2508	}
	2509
	2510	/* zero-length substrings always match at the first attempt */
	2511	if (pattern_len == 0)
	2512	return (direction > 0) ? start : end;
	2513
	2514	end -= pattern_len;
	2515
	2516	if (direction < 0) {
	2517	for (; end >= start; end--)
	2518	if (Py_STRING_MATCH(target, end, pattern, pattern_len))
	2519	return end;
	2520	} else {
	2521	for (; start <= end; start++)
	2522	if (Py_STRING_MATCH(target, start, pattern, pattern_len))
	2523	return start;
	2524	}
	2525	return -1;
	2526	}
	2527
	2528	Py_LOCAL_INLINE(Py_ssize_t)
	2529	countstring(const char *target, Py_ssize_t target_len,
	2530	const char *pattern, Py_ssize_t pattern_len,
	2531	Py_ssize_t start,
	2532	Py_ssize_t end,
	2533	int direction, Py_ssize_t maxcount)
	2534	{
	2535	Py_ssize_t count=0;
	2536
	2537	if (start < 0) {
	2538	start += target_len;
	2539	if (start < 0)
	2540	start = 0;
	2541	}
	2542	if (end > target_len) {
	2543	end = target_len;
	2544	} else if (end < 0) {
	2545	end += target_len;
	2546	if (end < 0)
	2547	end = 0;
	2548	}
	2549
	2550	/* zero-length substrings match everywhere */
	2551	if (pattern_len == 0 \|\| maxcount == 0) {
	2552	if (target_len+1 < maxcount)
	2553	return target_len+1;
	2554	return maxcount;
	2555	}
	2556
	2557	end -= pattern_len;
	2558	if (direction < 0) {
	2559	for (; (end >= start); end--)
	2560	if (Py_STRING_MATCH(target, end, pattern, pattern_len)) {
	2561	count++;
	2562	if (--maxcount <= 0) break;
	2563	end -= pattern_len-1;
	2564	}
	2565	} else {
	2566	for (; (start <= end); start++)
	2567	if (Py_STRING_MATCH(target, start, pattern, pattern_len)) {
	2568	count++;
	2569	if (--maxcount <= 0)
	2570	break;
	2571	start += pattern_len-1;
	2572	}
	2573	}
	2574	return count;
	2575	}
	2576
	2577
	2578	/* Algorithms for different cases of string replacement */
	2579
	2580	/* len(self)>=1, from="", len(to)>=1, maxcount>=1 */
	2581	Py_LOCAL(PyStringObject *)
	2582	replace_interleave(PyStringObject *self,
	2583	const char *to_s, Py_ssize_t to_len,
	2584	Py_ssize_t maxcount)
	2585	{
	2586	char self_s, result_s;
	2587	Py_ssize_t self_len, result_len;
	2588	Py_ssize_t count, i, product;
	2589	PyStringObject *result;
	2590
	2591	self_len = PyString_GET_SIZE(self);
	2592
	2593	/* 1 at the end plus 1 after every character */
	2594	count = self_len+1;
	2595	if (maxcount < count)
	2596	count = maxcount;
	2597
	2598	/* Check for overflow */
	2599	/* result_len = count * to_len + self_len; */
	2600	product = count * to_len;
	2601	if (product / to_len != count) {
	2602	PyErr_SetString(PyExc_OverflowError,
	2603	"replace string is too long");
	2604	return NULL;
	2605	}
	2606	result_len = product + self_len;
	2607	if (result_len < 0) {
	2608	PyErr_SetString(PyExc_OverflowError,
	2609	"replace string is too long");
	2610	return NULL;
	2611	}
	2612
	2613	if (! (result = (PyStringObject *)
	2614	PyString_FromStringAndSize(NULL, result_len)) )
	2615	return NULL;
	2616
	2617	self_s = PyString_AS_STRING(self);
	2618	result_s = PyString_AS_STRING(result);
	2619
	2620	/* TODO: special case single character, which doesn't need memcpy */
	2621
	2622	/* Lay the first one down (guaranteed this will occur) */
	2623	Py_MEMCPY(result_s, to_s, to_len);
	2624	result_s += to_len;
	2625	count -= 1;
	2626
	2627	for (i=0; i<count; i++) {
	2628	result_s++ = self_s++;
	2629	Py_MEMCPY(result_s, to_s, to_len);
	2630	result_s += to_len;
	2631	}
	2632
	2633	/* Copy the rest of the original string */
	2634	Py_MEMCPY(result_s, self_s, self_len-i);
	2635
	2636	return result;
	2637	}
	2638
	2639	/* Special case for deleting a single character */
	2640	/* len(self)>=1, len(from)==1, to="", maxcount>=1 */
	2641	Py_LOCAL(PyStringObject *)
	2642	replace_delete_single_character(PyStringObject *self,
	2643	char from_c, Py_ssize_t maxcount)
	2644	{
	2645	char self_s, result_s;
	2646	char start, next, *end;
	2647	Py_ssize_t self_len, result_len;
	2648	Py_ssize_t count;
	2649	PyStringObject *result;
	2650
	2651	self_len = PyString_GET_SIZE(self);
	2652	self_s = PyString_AS_STRING(self);
	2653
	2654	count = countchar(self_s, self_len, from_c, maxcount);
	2655	if (count == 0) {
	2656	return return_self(self);
	2657	}
	2658
	2659	result_len = self_len - count; /* from_len == 1 */
	2660	assert(result_len>=0);
	2661
	2662	if ( (result = (PyStringObject *)
	2663	PyString_FromStringAndSize(NULL, result_len)) == NULL)
	2664	return NULL;
	2665	result_s = PyString_AS_STRING(result);
	2666
	2667	start = self_s;
	2668	end = self_s + self_len;
	2669	while (count-- > 0) {
	2670	next = findchar(start, end-start, from_c);
	2671	if (next == NULL)
	2672	break;
	2673	Py_MEMCPY(result_s, start, next-start);
	2674	result_s += (next-start);
	2675	start = next+1;
	2676	}
	2677	Py_MEMCPY(result_s, start, end-start);
	2678
	2679	return result;
	2680	}
	2681
	2682	/* len(self)>=1, len(from)>=2, to="", maxcount>=1 */
	2683
	2684	Py_LOCAL(PyStringObject *)
	2685	replace_delete_substring(PyStringObject *self,
	2686	const char *from_s, Py_ssize_t from_len,
	2687	Py_ssize_t maxcount) {
	2688	char self_s, result_s;
	2689	char start, next, *end;
	2690	Py_ssize_t self_len, result_len;
	2691	Py_ssize_t count, offset;
	2692	PyStringObject *result;
	2693
	2694	self_len = PyString_GET_SIZE(self);
	2695	self_s = PyString_AS_STRING(self);
	2696
	2697	count = countstring(self_s, self_len,
	2698	from_s, from_len,
	2699	0, self_len, 1,
	2700	maxcount);
	2701
	2702	if (count == 0) {
	2703	/* no matches */
	2704	return return_self(self);
	2705	}
	2706
	2707	result_len = self_len - (count * from_len);
	2708	assert (result_len>=0);
	2709
	2710	if ( (result = (PyStringObject *)
	2711	PyString_FromStringAndSize(NULL, result_len)) == NULL )
	2712	return NULL;
	2713
	2714	result_s = PyString_AS_STRING(result);
	2715
	2716	start = self_s;
	2717	end = self_s + self_len;
	2718	while (count-- > 0) {
	2719	offset = findstring(start, end-start,
	2720	from_s, from_len,
	2721	0, end-start, FORWARD);
	2722	if (offset == -1)
	2723	break;
	2724	next = start + offset;
	2725
	2726	Py_MEMCPY(result_s, start, next-start);
	2727
	2728	result_s += (next-start);
	2729	start = next+from_len;
	2730	}
	2731	Py_MEMCPY(result_s, start, end-start);
	2732	return result;
	2733	}
	2734
	2735	/* len(self)>=1, len(from)==len(to)==1, maxcount>=1 */
	2736	Py_LOCAL(PyStringObject *)
	2737	replace_single_character_in_place(PyStringObject *self,
	2738	char from_c, char to_c,
	2739	Py_ssize_t maxcount)
	2740	{
	2741	char self_s, result_s, start, end, *next;
	2742	Py_ssize_t self_len;
	2743	PyStringObject *result;
	2744
	2745	/* The result string will be the same size */
	2746	self_s = PyString_AS_STRING(self);
	2747	self_len = PyString_GET_SIZE(self);
	2748
	2749	next = findchar(self_s, self_len, from_c);
	2750
	2751	if (next == NULL) {
	2752	/* No matches; return the original string */
	2753	return return_self(self);
	2754	}
	2755
	2756	/* Need to make a new string */
	2757	result = (PyStringObject *) PyString_FromStringAndSize(NULL, self_len);
	2758	if (result == NULL)
	2759	return NULL;
	2760	result_s = PyString_AS_STRING(result);
	2761	Py_MEMCPY(result_s, self_s, self_len);
	2762
	2763	/* change everything in-place, starting with this one */
	2764	start = result_s + (next-self_s);
	2765	*start = to_c;
	2766	start++;
	2767	end = result_s + self_len;
	2768
	2769	while (--maxcount > 0) {
	2770	next = findchar(start, end-start, from_c);
	2771	if (next == NULL)
	2772	break;
	2773	*next = to_c;
	2774	start = next+1;
	2775	}
	2776
	2777	return result;
	2778	}
	2779
	2780	/* len(self)>=1, len(from)==len(to)>=2, maxcount>=1 */
	2781	Py_LOCAL(PyStringObject *)
	2782	replace_substring_in_place(PyStringObject *self,
	2783	const char *from_s, Py_ssize_t from_len,
	2784	const char *to_s, Py_ssize_t to_len,
	2785	Py_ssize_t maxcount)
	2786	{
	2787	char result_s, start, *end;
	2788	char *self_s;
	2789	Py_ssize_t self_len, offset;
	2790	PyStringObject *result;
	2791
	2792	/* The result string will be the same size */
	2793
	2794	self_s = PyString_AS_STRING(self);
	2795	self_len = PyString_GET_SIZE(self);
	2796
	2797	offset = findstring(self_s, self_len,
	2798	from_s, from_len,
	2799	0, self_len, FORWARD);
	2800	if (offset == -1) {
	2801	/* No matches; return the original string */
	2802	return return_self(self);
	2803	}
	2804
	2805	/* Need to make a new string */
	2806	result = (PyStringObject *) PyString_FromStringAndSize(NULL, self_len);
	2807	if (result == NULL)
	2808	return NULL;
	2809	result_s = PyString_AS_STRING(result);
	2810	Py_MEMCPY(result_s, self_s, self_len);
	2811
	2812	/* change everything in-place, starting with this one */
	2813	start = result_s + offset;
	2814	Py_MEMCPY(start, to_s, from_len);
	2815	start += from_len;
	2816	end = result_s + self_len;
	2817
	2818	while ( --maxcount > 0) {
	2819	offset = findstring(start, end-start,
	2820	from_s, from_len,
	2821	0, end-start, FORWARD);
	2822	if (offset==-1)
	2823	break;
	2824	Py_MEMCPY(start+offset, to_s, from_len);
	2825	start += offset+from_len;
	2826	}
	2827
	2828	return result;
	2829	}
	2830
	2831	/* len(self)>=1, len(from)==1, len(to)>=2, maxcount>=1 */
	2832	Py_LOCAL(PyStringObject *)
	2833	replace_single_character(PyStringObject *self,
	2834	char from_c,
	2835	const char *to_s, Py_ssize_t to_len,
	2836	Py_ssize_t maxcount)
	2837	{
	2838	char self_s, result_s;
	2839	char start, next, *end;
	2840	Py_ssize_t self_len, result_len;
	2841	Py_ssize_t count, product;
	2842	PyStringObject *result;
	2843
	2844	self_s = PyString_AS_STRING(self);
	2845	self_len = PyString_GET_SIZE(self);
	2846
	2847	count = countchar(self_s, self_len, from_c, maxcount);
	2848	if (count == 0) {
	2849	/* no matches, return unchanged */
	2850	return return_self(self);
	2851	}
	2852
	2853	/* use the difference between current and new, hence the "-1" */
	2854	/* result_len = self_len + count * (to_len-1) */
	2855	product = count * (to_len-1);
	2856	if (product / (to_len-1) != count) {
	2857	PyErr_SetString(PyExc_OverflowError, "replace string is too long");
	2858	return NULL;
	2859	}
	2860	result_len = self_len + product;
	2861	if (result_len < 0) {
	2862	PyErr_SetString(PyExc_OverflowError, "replace string is too long");
	2863	return NULL;
	2864	}
	2865
	2866	if ( (result = (PyStringObject *)
	2867	PyString_FromStringAndSize(NULL, result_len)) == NULL)
	2868	return NULL;
	2869	result_s = PyString_AS_STRING(result);
	2870
	2871	start = self_s;
	2872	end = self_s + self_len;
	2873	while (count-- > 0) {
	2874	next = findchar(start, end-start, from_c);
	2875	if (next == NULL)
	2876	break;
	2877
	2878	if (next == start) {
	2879	/* replace with the 'to' */
	2880	Py_MEMCPY(result_s, to_s, to_len);
	2881	result_s += to_len;
	2882	start += 1;
	2883	} else {
	2884	/* copy the unchanged old then the 'to' */
	2885	Py_MEMCPY(result_s, start, next-start);
	2886	result_s += (next-start);
	2887	Py_MEMCPY(result_s, to_s, to_len);
	2888	result_s += to_len;
	2889	start = next+1;
	2890	}
	2891	}
	2892	/* Copy the remainder of the remaining string */
	2893	Py_MEMCPY(result_s, start, end-start);
	2894
	2895	return result;
	2896	}
	2897
	2898	/* len(self)>=1, len(from)>=2, len(to)>=2, maxcount>=1 */
	2899	Py_LOCAL(PyStringObject *)
	2900	replace_substring(PyStringObject *self,
	2901	const char *from_s, Py_ssize_t from_len,
	2902	const char *to_s, Py_ssize_t to_len,
	2903	Py_ssize_t maxcount) {
	2904	char self_s, result_s;
	2905	char start, next, *end;
	2906	Py_ssize_t self_len, result_len;
	2907	Py_ssize_t count, offset, product;
	2908	PyStringObject *result;
	2909
	2910	self_s = PyString_AS_STRING(self);
	2911	self_len = PyString_GET_SIZE(self);
	2912
	2913	count = countstring(self_s, self_len,
	2914	from_s, from_len,
	2915	0, self_len, FORWARD, maxcount);
	2916	if (count == 0) {
	2917	/* no matches, return unchanged */
	2918	return return_self(self);
	2919	}
	2920
	2921	/* Check for overflow */
	2922	/* result_len = self_len + count * (to_len-from_len) */
	2923	product = count * (to_len-from_len);
	2924	if (product / (to_len-from_len) != count) {
	2925	PyErr_SetString(PyExc_OverflowError, "replace string is too long");
	2926	return NULL;
	2927	}
	2928	result_len = self_len + product;
	2929	if (result_len < 0) {
	2930	PyErr_SetString(PyExc_OverflowError, "replace string is too long");
	2931	return NULL;
	2932	}
	2933
	2934	if ( (result = (PyStringObject *)
	2935	PyString_FromStringAndSize(NULL, result_len)) == NULL)
	2936	return NULL;
	2937	result_s = PyString_AS_STRING(result);
	2938
	2939	start = self_s;
	2940	end = self_s + self_len;
	2941	while (count-- > 0) {
	2942	offset = findstring(start, end-start,
	2943	from_s, from_len,
	2944	0, end-start, FORWARD);
	2945	if (offset == -1)
	2946	break;
	2947	next = start+offset;
	2948	if (next == start) {
	2949	/* replace with the 'to' */
	2950	Py_MEMCPY(result_s, to_s, to_len);
	2951	result_s += to_len;
	2952	start += from_len;
	2953	} else {
	2954	/* copy the unchanged old then the 'to' */
	2955	Py_MEMCPY(result_s, start, next-start);
	2956	result_s += (next-start);
	2957	Py_MEMCPY(result_s, to_s, to_len);
	2958	result_s += to_len;
	2959	start = next+from_len;
	2960	}
	2961	}
	2962	/* Copy the remainder of the remaining string */
	2963	Py_MEMCPY(result_s, start, end-start);
	2964
	2965	return result;
	2966	}
	2967
	2968
	2969	Py_LOCAL(PyStringObject *)
	2970	replace(PyStringObject *self,
	2971	const char *from_s, Py_ssize_t from_len,
	2972	const char *to_s, Py_ssize_t to_len,
	2973	Py_ssize_t maxcount)
	2974	{
	2975	if (maxcount < 0) {
	2976	maxcount = PY_SSIZE_T_MAX;
	2977	} else if (maxcount == 0 \|\| PyString_GET_SIZE(self) == 0) {
	2978	/* nothing to do; return the original string */
	2979	return return_self(self);
	2980	}
	2981
	2982	if (maxcount == 0 \|\|
	2983	(from_len == 0 && to_len == 0)) {
	2984	/* nothing to do; return the original string */
	2985	return return_self(self);
	2986	}
	2987
	2988	/* Handle zero-length special cases */
	2989
	2990	if (from_len == 0) {
	2991	/* insert the 'to' string everywhere. */
	2992	/* >>> "Python".replace("", ".") */
	2993	/* '.P.y.t.h.o.n.' */
	2994	return replace_interleave(self, to_s, to_len, maxcount);
	2995	}
	2996
	2997	/* Except for "".replace("", "A") == "A" there is no way beyond this */
	2998	/* point for an empty self string to generate a non-empty string */
	2999	/* Special case so the remaining code always gets a non-empty string */
	3000	if (PyString_GET_SIZE(self) == 0) {
	3001	return return_self(self);
	3002	}
	3003
	3004	if (to_len == 0) {
	3005	/* delete all occurances of 'from' string */
	3006	if (from_len == 1) {
	3007	return replace_delete_single_character(
	3008	self, from_s[0], maxcount);
	3009	} else {
	3010	return replace_delete_substring(self, from_s, from_len, maxcount);
	3011	}
	3012	}
	3013
	3014	/* Handle special case where both strings have the same length */
	3015
	3016	if (from_len == to_len) {
	3017	if (from_len == 1) {
	3018	return replace_single_character_in_place(
	3019	self,
	3020	from_s[0],
	3021	to_s[0],
	3022	maxcount);
	3023	} else {
	3024	return replace_substring_in_place(
	3025	self, from_s, from_len, to_s, to_len, maxcount);
	3026	}
	3027	}
	3028
	3029	/* Otherwise use the more generic algorithms */
	3030	if (from_len == 1) {
	3031	return replace_single_character(self, from_s[0],
	3032	to_s, to_len, maxcount);
	3033	} else {
	3034	/* len('from')>=2, len('to')>=1 */
	3035	return replace_substring(self, from_s, from_len, to_s, to_len, maxcount);
	3036	}
	3037	}
	3038
	3039	PyDoc_STRVAR(replace__doc__,
	3040	"S.replace (old, new[, count]) -> string\n\
	3041	\n\
	3042	Return a copy of string S with all occurrences of substring\n\
	3043	old replaced by new. If the optional argument count is\n\
	3044	given, only the first count occurrences are replaced.");
	3045
	3046	static PyObject *
	3047	string_replace(PyStringObject self, PyObject args)
	3048	{
	3049	Py_ssize_t count = -1;
	3050	PyObject from, to;
	3051	const char from_s, to_s;
	3052	Py_ssize_t from_len, to_len;
	3053
	3054	if (!PyArg_ParseTuple(args, "OO\|n:replace", &from, &to, &count))
	3055	return NULL;
	3056
	3057	if (PyString_Check(from)) {
	3058	from_s = PyString_AS_STRING(from);
	3059	from_len = PyString_GET_SIZE(from);
	3060	}
	3061	#ifdef Py_USING_UNICODE
	3062	if (PyUnicode_Check(from))
	3063	return PyUnicode_Replace((PyObject *)self,
	3064	from, to, count);
	3065	#endif
	3066	else if (PyObject_AsCharBuffer(from, &from_s, &from_len))
	3067	return NULL;
	3068
	3069	if (PyString_Check(to)) {
	3070	to_s = PyString_AS_STRING(to);
	3071	to_len = PyString_GET_SIZE(to);
	3072	}
	3073	#ifdef Py_USING_UNICODE
	3074	else if (PyUnicode_Check(to))
	3075	return PyUnicode_Replace((PyObject *)self,
	3076	from, to, count);
	3077	#endif
	3078	else if (PyObject_AsCharBuffer(to, &to_s, &to_len))
	3079	return NULL;
	3080
	3081	return (PyObject )replace((PyStringObject ) self,
	3082	from_s, from_len,
	3083	to_s, to_len, count);
	3084	}
	3085
	3086	/ End DALKE /
	3087
	3088	/* Matches the end (direction >= 0) or start (direction < 0) of self
	3089	* against substr, using the start and end arguments. Returns
	3090	* -1 on error, 0 if not found and 1 if found.
	3091	*/
	3092	Py_LOCAL(int)
	3093	_string_tailmatch(PyStringObject self, PyObject substr, Py_ssize_t start,
	3094	Py_ssize_t end, int direction)
	3095	{
	3096	Py_ssize_t len = PyString_GET_SIZE(self);
	3097	Py_ssize_t slen;
	3098	const char* sub;
	3099	const char* str;
	3100
	3101	if (PyString_Check(substr)) {
	3102	sub = PyString_AS_STRING(substr);
	3103	slen = PyString_GET_SIZE(substr);
	3104	}
	3105	#ifdef Py_USING_UNICODE
	3106	else if (PyUnicode_Check(substr))
	3107	return PyUnicode_Tailmatch((PyObject *)self,
	3108	substr, start, end, direction);
	3109	#endif
	3110	else if (PyObject_AsCharBuffer(substr, &sub, &slen))
	3111	return -1;
	3112	str = PyString_AS_STRING(self);
	3113
	3114	string_adjust_indices(&start, &end, len);
	3115
	3116	if (direction < 0) {
	3117	/* startswith */
	3118	if (start+slen > len)
	3119	return 0;
	3120	} else {
	3121	/* endswith */
	3122	if (end-start < slen \|\| start > len)
	3123	return 0;
	3124
	3125	if (end-slen > start)
	3126	start = end - slen;
	3127	}
	3128	if (end-start >= slen)
	3129	return ! memcmp(str+start, sub, slen);
	3130	return 0;
	3131	}
	3132
	3133
	3134	PyDoc_STRVAR(startswith__doc__,
	3135	"S.startswith(prefix[, start[, end]]) -> bool\n\
	3136	\n\
	3137	Return True if S starts with the specified prefix, False otherwise.\n\
	3138	With optional start, test S beginning at that position.\n\
	3139	With optional end, stop comparing S at that position.\n\
	3140	prefix can also be a tuple of strings to try.");
	3141
	3142	static PyObject *
	3143	string_startswith(PyStringObject self, PyObject args)
	3144	{
	3145	Py_ssize_t start = 0;
	3146	Py_ssize_t end = PY_SSIZE_T_MAX;
	3147	PyObject *subobj;
	3148	int result;
	3149
	3150	if (!PyArg_ParseTuple(args, "O\|O&O&:startswith", &subobj,
	3151	_PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
	3152	return NULL;
	3153	if (PyTuple_Check(subobj)) {
	3154	Py_ssize_t i;
	3155	for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) {
	3156	result = _string_tailmatch(self,
	3157	PyTuple_GET_ITEM(subobj, i),
	3158	start, end, -1);
	3159	if (result == -1)
	3160	return NULL;
	3161	else if (result) {
	3162	Py_RETURN_TRUE;
	3163	}
	3164	}
	3165	Py_RETURN_FALSE;
	3166	}
	3167	result = _string_tailmatch(self, subobj, start, end, -1);
	3168	if (result == -1)
	3169	return NULL;
	3170	else
	3171	return PyBool_FromLong(result);
	3172	}
	3173
	3174
	3175	PyDoc_STRVAR(endswith__doc__,
	3176	"S.endswith(suffix[, start[, end]]) -> bool\n\
	3177	\n\
	3178	Return True if S ends with the specified suffix, False otherwise.\n\
	3179	With optional start, test S beginning at that position.\n\
	3180	With optional end, stop comparing S at that position.\n\
	3181	suffix can also be a tuple of strings to try.");
	3182
	3183	static PyObject *
	3184	string_endswith(PyStringObject self, PyObject args)
	3185	{
	3186	Py_ssize_t start = 0;
	3187	Py_ssize_t end = PY_SSIZE_T_MAX;
	3188	PyObject *subobj;
	3189	int result;
	3190
	3191	if (!PyArg_ParseTuple(args, "O\|O&O&:endswith", &subobj,
	3192	_PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
	3193	return NULL;
	3194	if (PyTuple_Check(subobj)) {
	3195	Py_ssize_t i;
	3196	for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) {
	3197	result = _string_tailmatch(self,
	3198	PyTuple_GET_ITEM(subobj, i),
	3199	start, end, +1);
	3200	if (result == -1)
	3201	return NULL;
	3202	else if (result) {
	3203	Py_RETURN_TRUE;
	3204	}
	3205	}
	3206	Py_RETURN_FALSE;
	3207	}
	3208	result = _string_tailmatch(self, subobj, start, end, +1);
	3209	if (result == -1)
	3210	return NULL;
	3211	else
	3212	return PyBool_FromLong(result);
	3213	}
	3214
	3215
	3216	PyDoc_STRVAR(encode__doc__,
	3217	"S.encode([encoding[,errors]]) -> object\n\
	3218	\n\
	3219	Encodes S using the codec registered for encoding. encoding defaults\n\
	3220	to the default encoding. errors may be given to set a different error\n\
	3221	handling scheme. Default is 'strict' meaning that encoding errors raise\n\
	3222	a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n\
	3223	'xmlcharrefreplace' as well as any other name registered with\n\
	3224	codecs.register_error that is able to handle UnicodeEncodeErrors.");
	3225
	3226	static PyObject *
	3227	string_encode(PyStringObject self, PyObject args)
	3228	{
	3229	char *encoding = NULL;
	3230	char *errors = NULL;
	3231	PyObject *v;
	3232
	3233	if (!PyArg_ParseTuple(args, "\|ss:encode", &encoding, &errors))
	3234	return NULL;
	3235	v = PyString_AsEncodedObject((PyObject *)self, encoding, errors);
	3236	if (v == NULL)
	3237	goto onError;
	3238	if (!PyString_Check(v) && !PyUnicode_Check(v)) {
	3239	PyErr_Format(PyExc_TypeError,
	3240	"encoder did not return a string/unicode object "
	3241	"(type=%.400s)",
	3242	v->ob_type->tp_name);
	3243	Py_DECREF(v);
	3244	return NULL;
	3245	}
	3246	return v;
	3247
	3248	onError:
	3249	return NULL;
	3250	}
	3251
	3252
	3253	PyDoc_STRVAR(decode__doc__,
	3254	"S.decode([encoding[,errors]]) -> object\n\
	3255	\n\
	3256	Decodes S using the codec registered for encoding. encoding defaults\n\
	3257	to the default encoding. errors may be given to set a different error\n\
	3258	handling scheme. Default is 'strict' meaning that encoding errors raise\n\
	3259	a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n\
	3260	as well as any other name registerd with codecs.register_error that is\n\
	3261	able to handle UnicodeDecodeErrors.");
	3262
	3263	static PyObject *
	3264	string_decode(PyStringObject self, PyObject args)
	3265	{
	3266	char *encoding = NULL;
	3267	char *errors = NULL;
	3268	PyObject *v;
	3269
	3270	if (!PyArg_ParseTuple(args, "\|ss:decode", &encoding, &errors))
	3271	return NULL;
	3272	v = PyString_AsDecodedObject((PyObject *)self, encoding, errors);
	3273	if (v == NULL)
	3274	goto onError;
	3275	if (!PyString_Check(v) && !PyUnicode_Check(v)) {
	3276	PyErr_Format(PyExc_TypeError,
	3277	"decoder did not return a string/unicode object "
	3278	"(type=%.400s)",
	3279	v->ob_type->tp_name);
	3280	Py_DECREF(v);
	3281	return NULL;
	3282	}
	3283	return v;
	3284
	3285	onError:
	3286	return NULL;
	3287	}
	3288
	3289
	3290	PyDoc_STRVAR(expandtabs__doc__,
	3291	"S.expandtabs([tabsize]) -> string\n\
	3292	\n\
	3293	Return a copy of S where all tab characters are expanded using spaces.\n\
	3294	If tabsize is not given, a tab size of 8 characters is assumed.");
	3295
	3296	static PyObject*
	3297	string_expandtabs(PyStringObject self, PyObject args)
	3298	{
	3299	const char e, p;
	3300	char *q;
	3301	Py_ssize_t i, j;
	3302	PyObject *u;
	3303	int tabsize = 8;
	3304
	3305	if (!PyArg_ParseTuple(args, "\|i:expandtabs", &tabsize))
	3306	return NULL;
	3307
	3308	/* First pass: determine size of output string */
	3309	i = j = 0;
	3310	e = PyString_AS_STRING(self) + PyString_GET_SIZE(self);
	3311	for (p = PyString_AS_STRING(self); p < e; p++)
	3312	if (*p == '\t') {
	3313	if (tabsize > 0)
	3314	j += tabsize - (j % tabsize);
	3315	}
	3316	else {
	3317	j++;
	3318	if (p == '\n' \|\| p == '\r') {
	3319	i += j;
	3320	j = 0;
	3321	}
	3322	}
	3323
	3324	/* Second pass: create output string and fill it */
	3325	u = PyString_FromStringAndSize(NULL, i + j);
	3326	if (!u)
	3327	return NULL;
	3328
	3329	j = 0;
	3330	q = PyString_AS_STRING(u);
	3331
	3332	for (p = PyString_AS_STRING(self); p < e; p++)
	3333	if (*p == '\t') {
	3334	if (tabsize > 0) {
	3335	i = tabsize - (j % tabsize);
	3336	j += i;
	3337	while (i--)
	3338	*q++ = ' ';
	3339	}
	3340	}
	3341	else {
	3342	j++;
	3343	q++ = p;
	3344	if (p == '\n' \|\| p == '\r')
	3345	j = 0;
	3346	}
	3347
	3348	return u;
	3349	}
	3350
	3351	Py_LOCAL_INLINE(PyObject *)
	3352	pad(PyStringObject *self, Py_ssize_t left, Py_ssize_t right, char fill)
	3353	{
	3354	PyObject *u;
	3355
	3356	if (left < 0)
	3357	left = 0;
	3358	if (right < 0)
	3359	right = 0;
	3360
	3361	if (left == 0 && right == 0 && PyString_CheckExact(self)) {
	3362	Py_INCREF(self);
	3363	return (PyObject *)self;
	3364	}
	3365
	3366	u = PyString_FromStringAndSize(NULL,
	3367	left + PyString_GET_SIZE(self) + right);
	3368	if (u) {
	3369	if (left)
	3370	memset(PyString_AS_STRING(u), fill, left);
	3371	Py_MEMCPY(PyString_AS_STRING(u) + left,
	3372	PyString_AS_STRING(self),
	3373	PyString_GET_SIZE(self));
	3374	if (right)
	3375	memset(PyString_AS_STRING(u) + left + PyString_GET_SIZE(self),
	3376	fill, right);
	3377	}
	3378
	3379	return u;
	3380	}
	3381
	3382	PyDoc_STRVAR(ljust__doc__,
	3383	"S.ljust(width[, fillchar]) -> string\n"
	3384	"\n"
	3385	"Return S left justified in a string of length width. Padding is\n"
	3386	"done using the specified fill character (default is a space).");
	3387
	3388	static PyObject *
	3389	string_ljust(PyStringObject self, PyObject args)
	3390	{
	3391	Py_ssize_t width;
	3392	char fillchar = ' ';
	3393
	3394	if (!PyArg_ParseTuple(args, "n\|c:ljust", &width, &fillchar))
	3395	return NULL;
	3396
	3397	if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
	3398	Py_INCREF(self);
	3399	return (PyObject*) self;
	3400	}
	3401
	3402	return pad(self, 0, width - PyString_GET_SIZE(self), fillchar);
	3403	}
	3404
	3405
	3406	PyDoc_STRVAR(rjust__doc__,
	3407	"S.rjust(width[, fillchar]) -> string\n"
	3408	"\n"
	3409	"Return S right justified in a string of length width. Padding is\n"
	3410	"done using the specified fill character (default is a space)");
	3411
	3412	static PyObject *
	3413	string_rjust(PyStringObject self, PyObject args)
	3414	{
	3415	Py_ssize_t width;
	3416	char fillchar = ' ';
	3417
	3418	if (!PyArg_ParseTuple(args, "n\|c:rjust", &width, &fillchar))
	3419	return NULL;
	3420
	3421	if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
	3422	Py_INCREF(self);
	3423	return (PyObject*) self;
	3424	}
	3425
	3426	return pad(self, width - PyString_GET_SIZE(self), 0, fillchar);
	3427	}
	3428
	3429
	3430	PyDoc_STRVAR(center__doc__,
	3431	"S.center(width[, fillchar]) -> string\n"
	3432	"\n"
	3433	"Return S centered in a string of length width. Padding is\n"
	3434	"done using the specified fill character (default is a space)");
	3435
	3436	static PyObject *
	3437	string_center(PyStringObject self, PyObject args)
	3438	{
	3439	Py_ssize_t marg, left;
	3440	Py_ssize_t width;
	3441	char fillchar = ' ';
	3442
	3443	if (!PyArg_ParseTuple(args, "n\|c:center", &width, &fillchar))
	3444	return NULL;
	3445
	3446	if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
	3447	Py_INCREF(self);
	3448	return (PyObject*) self;
	3449	}
	3450
	3451	marg = width - PyString_GET_SIZE(self);
	3452	left = marg / 2 + (marg & width & 1);
	3453
	3454	return pad(self, left, marg - left, fillchar);
	3455	}
	3456
	3457	PyDoc_STRVAR(zfill__doc__,
	3458	"S.zfill(width) -> string\n"
	3459	"\n"
	3460	"Pad a numeric string S with zeros on the left, to fill a field\n"
	3461	"of the specified width. The string S is never truncated.");
	3462
	3463	static PyObject *
	3464	string_zfill(PyStringObject self, PyObject args)
	3465	{
	3466	Py_ssize_t fill;
	3467	PyObject *s;
	3468	char *p;
	3469	Py_ssize_t width;
	3470
	3471	if (!PyArg_ParseTuple(args, "n:zfill", &width))
	3472	return NULL;
	3473
	3474	if (PyString_GET_SIZE(self) >= width) {
	3475	if (PyString_CheckExact(self)) {
	3476	Py_INCREF(self);
	3477	return (PyObject*) self;
	3478	}
	3479	else
	3480	return PyString_FromStringAndSize(
	3481	PyString_AS_STRING(self),
	3482	PyString_GET_SIZE(self)
	3483	);
	3484	}
	3485
	3486	fill = width - PyString_GET_SIZE(self);
	3487
	3488	s = pad(self, fill, 0, '0');
	3489
	3490	if (s == NULL)
	3491	return NULL;
	3492
	3493	p = PyString_AS_STRING(s);
	3494	if (p[fill] == '+' \|\| p[fill] == '-') {
	3495	/* move sign to beginning of string */
	3496	p[0] = p[fill];
	3497	p[fill] = '0';
	3498	}
	3499
	3500	return (PyObject*) s;
	3501	}
	3502
	3503	PyDoc_STRVAR(isspace__doc__,
	3504	"S.isspace() -> bool\n\
	3505	\n\
	3506	Return True if all characters in S are whitespace\n\
	3507	and there is at least one character in S, False otherwise.");
	3508
	3509	static PyObject*
	3510	string_isspace(PyStringObject *self)
	3511	{
	3512	register const unsigned char *p
	3513	= (unsigned char *) PyString_AS_STRING(self);
	3514	register const unsigned char *e;
	3515
	3516	/* Shortcut for single character strings */
	3517	if (PyString_GET_SIZE(self) == 1 &&
	3518	isspace(*p))
	3519	return PyBool_FromLong(1);
	3520
	3521	/* Special case for empty strings */
	3522	if (PyString_GET_SIZE(self) == 0)
	3523	return PyBool_FromLong(0);
	3524
	3525	e = p + PyString_GET_SIZE(self);
	3526	for (; p < e; p++) {
	3527	if (!isspace(*p))
	3528	return PyBool_FromLong(0);
	3529	}
	3530	return PyBool_FromLong(1);
	3531	}
	3532
	3533
	3534	PyDoc_STRVAR(isalpha__doc__,
	3535	"S.isalpha() -> bool\n\
	3536	\n\
	3537	Return True if all characters in S are alphabetic\n\
	3538	and there is at least one character in S, False otherwise.");
	3539
	3540	static PyObject*
	3541	string_isalpha(PyStringObject *self)
	3542	{
	3543	register const unsigned char *p
	3544	= (unsigned char *) PyString_AS_STRING(self);
	3545	register const unsigned char *e;
	3546
	3547	/* Shortcut for single character strings */
	3548	if (PyString_GET_SIZE(self) == 1 &&
	3549	isalpha(*p))
	3550	return PyBool_FromLong(1);
	3551
	3552	/* Special case for empty strings */
	3553	if (PyString_GET_SIZE(self) == 0)
	3554	return PyBool_FromLong(0);
	3555
	3556	e = p + PyString_GET_SIZE(self);
	3557	for (; p < e; p++) {
	3558	if (!isalpha(*p))
	3559	return PyBool_FromLong(0);
	3560	}
	3561	return PyBool_FromLong(1);
	3562	}
	3563
	3564
	3565	PyDoc_STRVAR(isalnum__doc__,
	3566	"S.isalnum() -> bool\n\
	3567	\n\
	3568	Return True if all characters in S are alphanumeric\n\
	3569	and there is at least one character in S, False otherwise.");
	3570
	3571	static PyObject*
	3572	string_isalnum(PyStringObject *self)
	3573	{
	3574	register const unsigned char *p
	3575	= (unsigned char *) PyString_AS_STRING(self);
	3576	register const unsigned char *e;
	3577
	3578	/* Shortcut for single character strings */
	3579	if (PyString_GET_SIZE(self) == 1 &&
	3580	isalnum(*p))
	3581	return PyBool_FromLong(1);
	3582
	3583	/* Special case for empty strings */
	3584	if (PyString_GET_SIZE(self) == 0)
	3585	return PyBool_FromLong(0);
	3586
	3587	e = p + PyString_GET_SIZE(self);
	3588	for (; p < e; p++) {
	3589	if (!isalnum(*p))
	3590	return PyBool_FromLong(0);
	3591	}
	3592	return PyBool_FromLong(1);
	3593	}
	3594
	3595
	3596	PyDoc_STRVAR(isdigit__doc__,
	3597	"S.isdigit() -> bool\n\
	3598	\n\
	3599	Return True if all characters in S are digits\n\
	3600	and there is at least one character in S, False otherwise.");
	3601
	3602	static PyObject*
	3603	string_isdigit(PyStringObject *self)
	3604	{
	3605	register const unsigned char *p
	3606	= (unsigned char *) PyString_AS_STRING(self);
	3607	register const unsigned char *e;
	3608
	3609	/* Shortcut for single character strings */
	3610	if (PyString_GET_SIZE(self) == 1 &&
	3611	isdigit(*p))
	3612	return PyBool_FromLong(1);
	3613
	3614	/* Special case for empty strings */
	3615	if (PyString_GET_SIZE(self) == 0)
	3616	return PyBool_FromLong(0);
	3617
	3618	e = p + PyString_GET_SIZE(self);
	3619	for (; p < e; p++) {
	3620	if (!isdigit(*p))
	3621	return PyBool_FromLong(0);
	3622	}
	3623	return PyBool_FromLong(1);
	3624	}
	3625
	3626
	3627	PyDoc_STRVAR(islower__doc__,
	3628	"S.islower() -> bool\n\
	3629	\n\
	3630	Return True if all cased characters in S are lowercase and there is\n\
	3631	at least one cased character in S, False otherwise.");
	3632
	3633	static PyObject*
	3634	string_islower(PyStringObject *self)
	3635	{
	3636	register const unsigned char *p
	3637	= (unsigned char *) PyString_AS_STRING(self);
	3638	register const unsigned char *e;
	3639	int cased;
	3640
	3641	/* Shortcut for single character strings */
	3642	if (PyString_GET_SIZE(self) == 1)
	3643	return PyBool_FromLong(islower(*p) != 0);
	3644
	3645	/* Special case for empty strings */
	3646	if (PyString_GET_SIZE(self) == 0)
	3647	return PyBool_FromLong(0);
	3648
	3649	e = p + PyString_GET_SIZE(self);
	3650	cased = 0;
	3651	for (; p < e; p++) {
	3652	if (isupper(*p))
	3653	return PyBool_FromLong(0);
	3654	else if (!cased && islower(*p))
	3655	cased = 1;
	3656	}
	3657	return PyBool_FromLong(cased);
	3658	}
	3659
	3660
	3661	PyDoc_STRVAR(isupper__doc__,
	3662	"S.isupper() -> bool\n\
	3663	\n\
	3664	Return True if all cased characters in S are uppercase and there is\n\
	3665	at least one cased character in S, False otherwise.");
	3666
	3667	static PyObject*
	3668	string_isupper(PyStringObject *self)
	3669	{
	3670	register const unsigned char *p
	3671	= (unsigned char *) PyString_AS_STRING(self);
	3672	register const unsigned char *e;
	3673	int cased;
	3674
	3675	/* Shortcut for single character strings */
	3676	if (PyString_GET_SIZE(self) == 1)
	3677	return PyBool_FromLong(isupper(*p) != 0);
	3678
	3679	/* Special case for empty strings */
	3680	if (PyString_GET_SIZE(self) == 0)
	3681	return PyBool_FromLong(0);
	3682
	3683	e = p + PyString_GET_SIZE(self);
	3684	cased = 0;
	3685	for (; p < e; p++) {
	3686	if (islower(*p))
	3687	return PyBool_FromLong(0);
	3688	else if (!cased && isupper(*p))
	3689	cased = 1;
	3690	}
	3691	return PyBool_FromLong(cased);
	3692	}
	3693
	3694
	3695	PyDoc_STRVAR(istitle__doc__,
	3696	"S.istitle() -> bool\n\
	3697	\n\
	3698	Return True if S is a titlecased string and there is at least one\n\
	3699	character in S, i.e. uppercase characters may only follow uncased\n\
	3700	characters and lowercase characters only cased ones. Return False\n\
	3701	otherwise.");
	3702
	3703	static PyObject*
	3704	string_istitle(PyStringObject self, PyObject uncased)
	3705	{
	3706	register const unsigned char *p
	3707	= (unsigned char *) PyString_AS_STRING(self);
	3708	register const unsigned char *e;
	3709	int cased, previous_is_cased;
	3710
	3711	/* Shortcut for single character strings */
	3712	if (PyString_GET_SIZE(self) == 1)
	3713	return PyBool_FromLong(isupper(*p) != 0);
	3714
	3715	/* Special case for empty strings */
	3716	if (PyString_GET_SIZE(self) == 0)
	3717	return PyBool_FromLong(0);
	3718
	3719	e = p + PyString_GET_SIZE(self);
	3720	cased = 0;
	3721	previous_is_cased = 0;
	3722	for (; p < e; p++) {
	3723	register const unsigned char ch = *p;
	3724
	3725	if (isupper(ch)) {
	3726	if (previous_is_cased)
	3727	return PyBool_FromLong(0);
	3728	previous_is_cased = 1;
	3729	cased = 1;
	3730	}
	3731	else if (islower(ch)) {
	3732	if (!previous_is_cased)
	3733	return PyBool_FromLong(0);
	3734	previous_is_cased = 1;
	3735	cased = 1;
	3736	}
	3737	else
	3738	previous_is_cased = 0;
	3739	}
	3740	return PyBool_FromLong(cased);
	3741	}
	3742
	3743
	3744	PyDoc_STRVAR(splitlines__doc__,
	3745	"S.splitlines([keepends]) -> list of strings\n\
	3746	\n\
	3747	Return a list of the lines in S, breaking at line boundaries.\n\
	3748	Line breaks are not included in the resulting list unless keepends\n\
	3749	is given and true.");
	3750
	3751	static PyObject*
	3752	string_splitlines(PyStringObject self, PyObject args)
	3753	{
	3754	register Py_ssize_t i;
	3755	register Py_ssize_t j;
	3756	Py_ssize_t len;
	3757	int keepends = 0;
	3758	PyObject *list;
	3759	PyObject *str;
	3760	char *data;
	3761
	3762	if (!PyArg_ParseTuple(args, "\|i:splitlines", &keepends))
	3763	return NULL;
	3764
	3765	data = PyString_AS_STRING(self);
	3766	len = PyString_GET_SIZE(self);
	3767
	3768	/* This does not use the preallocated list because splitlines is
	3769	usually run with hundreds of newlines. The overhead of
	3770	switching between PyList_SET_ITEM and append causes about a
	3771	2-3% slowdown for that common case. A smarter implementation
	3772	could move the if check out, so the SET_ITEMs are done first
	3773	and the appends only done when the prealloc buffer is full.
	3774	That's too much work for little gain.*/
	3775
	3776	list = PyList_New(0);
	3777	if (!list)
	3778	goto onError;
	3779
	3780	for (i = j = 0; i < len; ) {
	3781	Py_ssize_t eol;
	3782
	3783	/* Find a line and append it */
	3784	while (i < len && data[i] != '\n' && data[i] != '\r')
	3785	i++;
	3786
	3787	/* Skip the line break reading CRLF as one line break */
	3788	eol = i;
	3789	if (i < len) {
	3790	if (data[i] == '\r' && i + 1 < len &&
	3791	data[i+1] == '\n')
	3792	i += 2;
	3793	else
	3794	i++;
	3795	if (keepends)
	3796	eol = i;
	3797	}
	3798	SPLIT_APPEND(data, j, eol);
	3799	j = i;
	3800	}
	3801	if (j < len) {
	3802	SPLIT_APPEND(data, j, len);
	3803	}
	3804
	3805	return list;
	3806
	3807	onError:
	3808	Py_XDECREF(list);
	3809	return NULL;
	3810	}
	3811
	3812	#undef SPLIT_APPEND
	3813	#undef SPLIT_ADD
	3814	#undef MAX_PREALLOC
	3815	#undef PREALLOC_SIZE
	3816
	3817	static PyObject *
	3818	string_getnewargs(PyStringObject *v)
	3819	{
	3820	return Py_BuildValue("(s#)", v->ob_sval, v->ob_size);
	3821	}
	3822
	3823
	3824	static PyMethodDef
	3825	string_methods[] = {
	3826	/* Counterparts of the obsolete stropmodule functions; except
	3827	string.maketrans(). */
	3828	{"join", (PyCFunction)string_join, METH_O, join__doc__},
	3829	{"split", (PyCFunction)string_split, METH_VARARGS, split__doc__},
	3830	{"rsplit", (PyCFunction)string_rsplit, METH_VARARGS, rsplit__doc__},
	3831	{"lower", (PyCFunction)string_lower, METH_NOARGS, lower__doc__},
	3832	{"upper", (PyCFunction)string_upper, METH_NOARGS, upper__doc__},
	3833	{"islower", (PyCFunction)string_islower, METH_NOARGS, islower__doc__},
	3834	{"isupper", (PyCFunction)string_isupper, METH_NOARGS, isupper__doc__},
	3835	{"isspace", (PyCFunction)string_isspace, METH_NOARGS, isspace__doc__},
	3836	{"isdigit", (PyCFunction)string_isdigit, METH_NOARGS, isdigit__doc__},
	3837	{"istitle", (PyCFunction)string_istitle, METH_NOARGS, istitle__doc__},
	3838	{"isalpha", (PyCFunction)string_isalpha, METH_NOARGS, isalpha__doc__},
	3839	{"isalnum", (PyCFunction)string_isalnum, METH_NOARGS, isalnum__doc__},
	3840	{"capitalize", (PyCFunction)string_capitalize, METH_NOARGS,
	3841	capitalize__doc__},
	3842	{"count", (PyCFunction)string_count, METH_VARARGS, count__doc__},
	3843	{"endswith", (PyCFunction)string_endswith, METH_VARARGS,
	3844	endswith__doc__},
	3845	{"partition", (PyCFunction)string_partition, METH_O, partition__doc__},
	3846	{"find", (PyCFunction)string_find, METH_VARARGS, find__doc__},
	3847	{"index", (PyCFunction)string_index, METH_VARARGS, index__doc__},
	3848	{"lstrip", (PyCFunction)string_lstrip, METH_VARARGS, lstrip__doc__},
	3849	{"replace", (PyCFunction)string_replace, METH_VARARGS, replace__doc__},
	3850	{"rfind", (PyCFunction)string_rfind, METH_VARARGS, rfind__doc__},
	3851	{"rindex", (PyCFunction)string_rindex, METH_VARARGS, rindex__doc__},
	3852	{"rstrip", (PyCFunction)string_rstrip, METH_VARARGS, rstrip__doc__},
	3853	{"rpartition", (PyCFunction)string_rpartition, METH_O,
	3854	rpartition__doc__},
	3855	{"startswith", (PyCFunction)string_startswith, METH_VARARGS,
	3856	startswith__doc__},
	3857	{"strip", (PyCFunction)string_strip, METH_VARARGS, strip__doc__},
	3858	{"swapcase", (PyCFunction)string_swapcase, METH_NOARGS,
	3859	swapcase__doc__},
	3860	{"translate", (PyCFunction)string_translate, METH_VARARGS,
	3861	translate__doc__},
	3862	{"title", (PyCFunction)string_title, METH_NOARGS, title__doc__},
	3863	{"ljust", (PyCFunction)string_ljust, METH_VARARGS, ljust__doc__},
	3864	{"rjust", (PyCFunction)string_rjust, METH_VARARGS, rjust__doc__},
	3865	{"center", (PyCFunction)string_center, METH_VARARGS, center__doc__},
	3866	{"zfill", (PyCFunction)string_zfill, METH_VARARGS, zfill__doc__},
	3867	{"encode", (PyCFunction)string_encode, METH_VARARGS, encode__doc__},
	3868	{"decode", (PyCFunction)string_decode, METH_VARARGS, decode__doc__},
	3869	{"expandtabs", (PyCFunction)string_expandtabs, METH_VARARGS,
	3870	expandtabs__doc__},
	3871	{"splitlines", (PyCFunction)string_splitlines, METH_VARARGS,
	3872	splitlines__doc__},
	3873	{"__getnewargs__", (PyCFunction)string_getnewargs, METH_NOARGS},
	3874	{NULL, NULL} /* sentinel */
	3875	};
	3876
	3877	static PyObject *
	3878	str_subtype_new(PyTypeObject type, PyObject args, PyObject *kwds);
	3879
	3880	static PyObject *
	3881	string_new(PyTypeObject type, PyObject args, PyObject *kwds)
	3882	{
	3883	PyObject *x = NULL;
	3884	static char *kwlist[] = {"object", 0};
	3885
	3886	if (type != &PyString_Type)
	3887	return str_subtype_new(type, args, kwds);
	3888	if (!PyArg_ParseTupleAndKeywords(args, kwds, "\|O:str", kwlist, &x))
	3889	return NULL;
	3890	if (x == NULL)
	3891	return PyString_FromString("");
	3892	return PyObject_Str(x);
	3893	}
	3894
	3895	static PyObject *
	3896	str_subtype_new(PyTypeObject type, PyObject args, PyObject *kwds)
	3897	{
	3898	PyObject tmp, pnew;
	3899	Py_ssize_t n;
	3900
	3901	assert(PyType_IsSubtype(type, &PyString_Type));
	3902	tmp = string_new(&PyString_Type, args, kwds);
	3903	if (tmp == NULL)
	3904	return NULL;
	3905	assert(PyString_CheckExact(tmp));
	3906	n = PyString_GET_SIZE(tmp);
	3907	pnew = type->tp_alloc(type, n);
	3908	if (pnew != NULL) {
	3909	Py_MEMCPY(PyString_AS_STRING(pnew), PyString_AS_STRING(tmp), n+1);
	3910	((PyStringObject *)pnew)->ob_shash =
	3911	((PyStringObject *)tmp)->ob_shash;
	3912	((PyStringObject *)pnew)->ob_sstate = SSTATE_NOT_INTERNED;
	3913	}
	3914	Py_DECREF(tmp);
	3915	return pnew;
	3916	}
	3917
	3918	static PyObject *
	3919	basestring_new(PyTypeObject type, PyObject args, PyObject *kwds)
	3920	{
	3921	PyErr_SetString(PyExc_TypeError,
	3922	"The basestring type cannot be instantiated");
	3923	return NULL;
	3924	}
	3925
	3926	static PyObject *
	3927	string_mod(PyObject v, PyObject w)
	3928	{
	3929	if (!PyString_Check(v)) {
	3930	Py_INCREF(Py_NotImplemented);
	3931	return Py_NotImplemented;
	3932	}
	3933	return PyString_Format(v, w);
	3934	}
	3935
	3936	PyDoc_STRVAR(basestring_doc,
	3937	"Type basestring cannot be instantiated; it is the base for str and unicode.");
	3938
	3939	static PyNumberMethods string_as_number = {
	3940	0, /nb_add/
	3941	0, /nb_subtract/
	3942	0, /nb_multiply/
	3943	0, /nb_divide/
	3944	string_mod, /nb_remainder/
	3945	};
	3946
	3947
	3948	PyTypeObject PyBaseString_Type = {
	3949	PyObject_HEAD_INIT(&PyType_Type)
	3950	0,
	3951	"basestring",
	3952	0,
	3953	0,
	3954	0, /* tp_dealloc */
	3955	0, /* tp_print */
	3956	0, /* tp_getattr */
	3957	0, /* tp_setattr */
	3958	0, /* tp_compare */
	3959	0, /* tp_repr */
	3960	0, /* tp_as_number */
	3961	0, /* tp_as_sequence */
	3962	0, /* tp_as_mapping */
	3963	0, /* tp_hash */
	3964	0, /* tp_call */
	3965	0, /* tp_str */
	3966	0, /* tp_getattro */
	3967	0, /* tp_setattro */
	3968	0, /* tp_as_buffer */
	3969	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE, /* tp_flags */
	3970	basestring_doc, /* tp_doc */
	3971	0, /* tp_traverse */
	3972	0, /* tp_clear */
	3973	0, /* tp_richcompare */
	3974	0, /* tp_weaklistoffset */
	3975	0, /* tp_iter */
	3976	0, /* tp_iternext */
	3977	0, /* tp_methods */
	3978	0, /* tp_members */
	3979	0, /* tp_getset */
	3980	&PyBaseObject_Type, /* tp_base */
	3981	0, /* tp_dict */
	3982	0, /* tp_descr_get */
	3983	0, /* tp_descr_set */
	3984	0, /* tp_dictoffset */
	3985	0, /* tp_init */
	3986	0, /* tp_alloc */
	3987	basestring_new, /* tp_new */
	3988	0, /* tp_free */
	3989	};
	3990
	3991	PyDoc_STRVAR(string_doc,
	3992	"str(object) -> string\n\
	3993	\n\
	3994	Return a nice string representation of the object.\n\
	3995	If the argument is a string, the return value is the same object.");
	3996
	3997	PyTypeObject PyString_Type = {
	3998	PyObject_HEAD_INIT(&PyType_Type)
	3999	0,
	4000	"str",
	4001	sizeof(PyStringObject),
	4002	sizeof(char),
	4003	string_dealloc, /* tp_dealloc */
	4004	(printfunc)string_print, /* tp_print */
	4005	0, /* tp_getattr */
	4006	0, /* tp_setattr */
	4007	0, /* tp_compare */
	4008	string_repr, /* tp_repr */
	4009	&string_as_number, /* tp_as_number */
	4010	&string_as_sequence, /* tp_as_sequence */
	4011	&string_as_mapping, /* tp_as_mapping */
	4012	(hashfunc)string_hash, /* tp_hash */
	4013	0, /* tp_call */
	4014	string_str, /* tp_str */
	4015	PyObject_GenericGetAttr, /* tp_getattro */
	4016	0, /* tp_setattro */
	4017	&string_as_buffer, /* tp_as_buffer */
	4018	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_CHECKTYPES \|
	4019	Py_TPFLAGS_BASETYPE, /* tp_flags */
	4020	string_doc, /* tp_doc */
	4021	0, /* tp_traverse */
	4022	0, /* tp_clear */
	4023	(richcmpfunc)string_richcompare, /* tp_richcompare */
	4024	0, /* tp_weaklistoffset */
	4025	0, /* tp_iter */
	4026	0, /* tp_iternext */
	4027	string_methods, /* tp_methods */
	4028	0, /* tp_members */
	4029	0, /* tp_getset */
	4030	&PyBaseString_Type, /* tp_base */
	4031	0, /* tp_dict */
	4032	0, /* tp_descr_get */
	4033	0, /* tp_descr_set */
	4034	0, /* tp_dictoffset */
	4035	0, /* tp_init */
	4036	0, /* tp_alloc */
	4037	string_new, /* tp_new */
	4038	PyObject_Del, /* tp_free */
	4039	};
	4040
	4041	void
	4042	PyString_Concat(register PyObject *pv, register PyObject w)
	4043	{
	4044	register PyObject *v;
	4045	if (*pv == NULL)
	4046	return;
	4047	if (w == NULL \|\| !PyString_Check(*pv)) {
	4048	Py_DECREF(*pv);
	4049	*pv = NULL;
	4050	return;
	4051	}
	4052	v = string_concat((PyStringObject ) pv, w);
	4053	Py_DECREF(*pv);
	4054	*pv = v;
	4055	}
	4056
	4057	void
	4058	PyString_ConcatAndDel(register PyObject *pv, register PyObject w)
	4059	{
	4060	PyString_Concat(pv, w);
	4061	Py_XDECREF(w);
	4062	}
	4063
	4064
	4065	/* The following function breaks the notion that strings are immutable:
	4066	it changes the size of a string. We get away with this only if there
	4067	is only one module referencing the object. You can also think of it
	4068	as creating a new string object and destroying the old one, only
	4069	more efficiently. In any case, don't use this if the string may
	4070	already be known to some other part of the code...
	4071	Note that if there's not enough memory to resize the string, the original
	4072	string object at pv is deallocated, pv is set to NULL, an "out of
	4073	memory" exception is set, and -1 is returned. Else (on success) 0 is
	4074	returned, and the value in *pv may or may not be the same as on input.
	4075	As always, an extra byte is allocated for a trailing \0 byte (newsize
	4076	does not include that), and a trailing \0 byte is stored.
	4077	*/
	4078
	4079	int
	4080	_PyString_Resize(PyObject **pv, Py_ssize_t newsize)
	4081	{
	4082	register PyObject *v;
	4083	register PyStringObject *sv;
	4084	v = *pv;
	4085	if (!PyString_Check(v) \|\| v->ob_refcnt != 1 \|\| newsize < 0 \|\|
	4086	PyString_CHECK_INTERNED(v)) {
	4087	*pv = 0;
	4088	Py_DECREF(v);
	4089	PyErr_BadInternalCall();
	4090	return -1;
	4091	}
	4092	/* XXX UNREF/NEWREF interface should be more symmetrical */
	4093	_Py_DEC_REFTOTAL;
	4094	_Py_ForgetReference(v);
	4095	pv = (PyObject )
	4096	PyObject_REALLOC((char *)v, sizeof(PyStringObject) + newsize);
	4097	if (*pv == NULL) {
	4098	PyObject_Del(v);
	4099	PyErr_NoMemory();
	4100	return -1;
	4101	}
	4102	_Py_NewReference(*pv);
	4103	sv = (PyStringObject ) pv;
	4104	sv->ob_size = newsize;
	4105	sv->ob_sval[newsize] = '\0';
	4106	sv->ob_shash = -1; /* invalidate cached hash value */
	4107	return 0;
	4108	}
	4109
	4110	/* Helpers for formatstring */
	4111
	4112	Py_LOCAL_INLINE(PyObject *)
	4113	getnextarg(PyObject args, Py_ssize_t arglen, Py_ssize_t p_argidx)
	4114	{
	4115	Py_ssize_t argidx = *p_argidx;
	4116	if (argidx < arglen) {
	4117	(*p_argidx)++;
	4118	if (arglen < 0)
	4119	return args;
	4120	else
	4121	return PyTuple_GetItem(args, argidx);
	4122	}
	4123	PyErr_SetString(PyExc_TypeError,
	4124	"not enough arguments for format string");
	4125	return NULL;
	4126	}
	4127
	4128	/* Format codes
	4129	* F_LJUST '-'
	4130	* F_SIGN '+'
	4131	* F_BLANK ' '
	4132	* F_ALT '#'
	4133	* F_ZERO '0'
	4134	*/
	4135	#define F_LJUST (1<<0)
	4136	#define F_SIGN (1<<1)
	4137	#define F_BLANK (1<<2)
	4138	#define F_ALT (1<<3)
	4139	#define F_ZERO (1<<4)
	4140
	4141	Py_LOCAL_INLINE(int)
	4142	formatfloat(char *buf, size_t buflen, int flags,
	4143	int prec, int type, PyObject *v)
	4144	{
	4145	/* fmt = '%#.' + `prec` + `type`
	4146	worst case length = 3 + 10 (len of INT_MAX) + 1 = 14 (use 20)*/
	4147	char fmt[20];
	4148	double x;
	4149	x = PyFloat_AsDouble(v);
	4150	if (x == -1.0 && PyErr_Occurred()) {
	4151	PyErr_SetString(PyExc_TypeError, "float argument required");
	4152	return -1;
	4153	}
	4154	if (prec < 0)
	4155	prec = 6;
	4156	if (type == 'f' && fabs(x)/1e25 >= 1e25)
	4157	type = 'g';
	4158	/* Worst case length calc to ensure no buffer overrun:
	4159
	4160	'g' formats:
	4161	fmt = %#.<prec>g
	4162	buf = '-' + [0-9]*prec + '.' + 'e+' + (longest exp
	4163	for any double rep.)
	4164	len = 1 + prec + 1 + 2 + 5 = 9 + prec
	4165
	4166	'f' formats:
	4167	buf = '-' + [0-9]x + '.' + [0-9]prec (with x < 50)
	4168	len = 1 + 50 + 1 + prec = 52 + prec
	4169
	4170	If prec=0 the effective precision is 1 (the leading digit is
	4171	always given), therefore increase the length by one.
	4172
	4173	*/
	4174	if ((type == 'g' && buflen <= (size_t)10 + (size_t)prec) \|\|
	4175	(type == 'f' && buflen <= (size_t)53 + (size_t)prec)) {
	4176	PyErr_SetString(PyExc_OverflowError,
	4177	"formatted float is too long (precision too large?)");
	4178	return -1;
	4179	}
	4180	PyOS_snprintf(fmt, sizeof(fmt), "%%%s.%d%c",
	4181	(flags&F_ALT) ? "#" : "",
	4182	prec, type);
	4183	PyOS_ascii_formatd(buf, buflen, fmt, x);
	4184	return (int)strlen(buf);
	4185	}
	4186
	4187	/* _PyString_FormatLong emulates the format codes d, u, o, x and X, and
	4188	* the F_ALT flag, for Python's long (unbounded) ints. It's not used for
	4189	* Python's regular ints.
	4190	* Return value: a new PyString*, or NULL if error.
	4191	* . *pbuf is set to point into it,
	4192	* *plen set to the # of chars following that.
	4193	* Caller must decref it when done using pbuf.
	4194	* The string starting at *pbuf is of the form
	4195	* "-"? ("0x" \| "0X")? digit+
	4196	* "0x"/"0X" are present only for x and X conversions, with F_ALT
	4197	* set in flags. The case of hex digits will be correct,
	4198	* There will be at least prec digits, zero-filled on the left if
	4199	* necessary to get that many.
	4200	* val object to be converted
	4201	* flags bitmask of format flags; only F_ALT is looked at
	4202	* prec minimum number of digits; 0-fill on left if needed
	4203	* type a character in [duoxX]; u acts the same as d
	4204	*
	4205	* CAUTION: o, x and X conversions on regular ints can never
	4206	* produce a '-' sign, but can for Python's unbounded ints.
	4207	*/
	4208	PyObject*
	4209	_PyString_FormatLong(PyObject *val, int flags, int prec, int type,
	4210	char *pbuf, int plen)
	4211	{
	4212	PyObject *result = NULL;
	4213	char *buf;
	4214	Py_ssize_t i;
	4215	int sign; /* 1 if '-', else 0 */
	4216	int len; /* number of characters */
	4217	Py_ssize_t llen;
	4218	int numdigits; /* len == numnondigits + numdigits */
	4219	int numnondigits = 0;
	4220
	4221	switch (type) {
	4222	case 'd':
	4223	case 'u':
	4224	result = val->ob_type->tp_str(val);
	4225	break;
	4226	case 'o':
	4227	result = val->ob_type->tp_as_number->nb_oct(val);
	4228	break;
	4229	case 'x':
	4230	case 'X':
	4231	numnondigits = 2;
	4232	result = val->ob_type->tp_as_number->nb_hex(val);
	4233	break;
	4234	default:
	4235	assert(!"'type' not in [duoxX]");
	4236	}
	4237	if (!result)
	4238	return NULL;
	4239
	4240	buf = PyString_AsString(result);
	4241	if (!buf) {
	4242	Py_DECREF(result);
	4243	return NULL;
	4244	}
	4245
	4246	/* To modify the string in-place, there can only be one reference. */
	4247	if (result->ob_refcnt != 1) {
	4248	PyErr_BadInternalCall();
	4249	return NULL;
	4250	}
	4251	llen = PyString_Size(result);
	4252	if (llen > INT_MAX) {
	4253	PyErr_SetString(PyExc_ValueError, "string too large in _PyString_FormatLong");
	4254	return NULL;
	4255	}
	4256	len = (int)llen;
	4257	if (buf[len-1] == 'L') {
	4258	--len;
	4259	buf[len] = '\0';
	4260	}
	4261	sign = buf[0] == '-';
	4262	numnondigits += sign;
	4263	numdigits = len - numnondigits;
	4264	assert(numdigits > 0);
	4265
	4266	/* Get rid of base marker unless F_ALT */
	4267	if ((flags & F_ALT) == 0) {
	4268	/* Need to skip 0x, 0X or 0. */
	4269	int skipped = 0;
	4270	switch (type) {
	4271	case 'o':
	4272	assert(buf[sign] == '0');
	4273	/* If 0 is only digit, leave it alone. */
	4274	if (numdigits > 1) {
	4275	skipped = 1;
	4276	--numdigits;
	4277	}
	4278	break;
	4279	case 'x':
	4280	case 'X':
	4281	assert(buf[sign] == '0');
	4282	assert(buf[sign + 1] == 'x');
	4283	skipped = 2;
	4284	numnondigits -= 2;
	4285	break;
	4286	}
	4287	if (skipped) {
	4288	buf += skipped;
	4289	len -= skipped;
	4290	if (sign)
	4291	buf[0] = '-';
	4292	}
	4293	assert(len == numnondigits + numdigits);
	4294	assert(numdigits > 0);
	4295	}
	4296
	4297	/* Fill with leading zeroes to meet minimum width. */
	4298	if (prec > numdigits) {
	4299	PyObject *r1 = PyString_FromStringAndSize(NULL,
	4300	numnondigits + prec);
	4301	char *b1;
	4302	if (!r1) {
	4303	Py_DECREF(result);
	4304	return NULL;
	4305	}
	4306	b1 = PyString_AS_STRING(r1);
	4307	for (i = 0; i < numnondigits; ++i)
	4308	b1++ = buf++;
	4309	for (i = 0; i < prec - numdigits; i++)
	4310	*b1++ = '0';
	4311	for (i = 0; i < numdigits; i++)
	4312	b1++ = buf++;
	4313	*b1 = '\0';
	4314	Py_DECREF(result);
	4315	result = r1;
	4316	buf = PyString_AS_STRING(result);
	4317	len = numnondigits + prec;
	4318	}
	4319
	4320	/* Fix up case for hex conversions. */
	4321	if (type == 'X') {
	4322	/* Need to convert all lower case letters to upper case.
	4323	and need to convert 0x to 0X (and -0x to -0X). */
	4324	for (i = 0; i < len; i++)
	4325	if (buf[i] >= 'a' && buf[i] <= 'x')
	4326	buf[i] -= 'a'-'A';
	4327	}
	4328	*pbuf = buf;
	4329	*plen = len;
	4330	return result;
	4331	}
	4332
	4333	Py_LOCAL_INLINE(int)
	4334	formatint(char *buf, size_t buflen, int flags,
	4335	int prec, int type, PyObject *v)
	4336	{
	4337	/* fmt = '%#.' + `prec` + 'l' + `type`
	4338	worst case length = 3 + 19 (worst len of INT_MAX on 64-bit machine)
	4339	+ 1 + 1 = 24 */
	4340	char fmt[64]; /* plenty big enough! */
	4341	char *sign;
	4342	long x;
	4343
	4344	x = PyInt_AsLong(v);
	4345	if (x == -1 && PyErr_Occurred()) {
	4346	PyErr_SetString(PyExc_TypeError, "int argument required");
	4347	return -1;
	4348	}
	4349	if (x < 0 && type == 'u') {
	4350	type = 'd';
	4351	}
	4352	if (x < 0 && (type == 'x' \|\| type == 'X' \|\| type == 'o'))
	4353	sign = "-";
	4354	else
	4355	sign = "";
	4356	if (prec < 0)
	4357	prec = 1;
	4358
	4359	if ((flags & F_ALT) &&
	4360	(type == 'x' \|\| type == 'X')) {
	4361	/* When converting under %#x or %#X, there are a number
	4362	* of issues that cause pain:
	4363	* - when 0 is being converted, the C standard leaves off
	4364	* the '0x' or '0X', which is inconsistent with other
	4365	* %#x/%#X conversions and inconsistent with Python's
	4366	* hex() function
	4367	* - there are platforms that violate the standard and
	4368	* convert 0 with the '0x' or '0X'
	4369	* (Metrowerks, Compaq Tru64)
	4370	* - there are platforms that give '0x' when converting
	4371	* under %#X, but convert 0 in accordance with the
	4372	* standard (OS/2 EMX)
	4373	*
	4374	* We can achieve the desired consistency by inserting our
	4375	* own '0x' or '0X' prefix, and substituting %x/%X in place
	4376	* of %#x/%#X.
	4377	*
	4378	* Note that this is the same approach as used in
	4379	* formatint() in unicodeobject.c
	4380	*/
	4381	PyOS_snprintf(fmt, sizeof(fmt), "%s0%c%%.%dl%c",
	4382	sign, type, prec, type);
	4383	}
	4384	else {
	4385	PyOS_snprintf(fmt, sizeof(fmt), "%s%%%s.%dl%c",
	4386	sign, (flags&F_ALT) ? "#" : "",
	4387	prec, type);
	4388	}
	4389
	4390	/* buf = '+'/'-'/'' + '0'/'0x'/'' + '[0-9]'*max(prec, len(x in octal))
	4391	* worst case buf = '-0x' + [0-9]*prec, where prec >= 11
	4392	*/
	4393	if (buflen <= 14 \|\| buflen <= (size_t)3 + (size_t)prec) {
	4394	PyErr_SetString(PyExc_OverflowError,
	4395	"formatted integer is too long (precision too large?)");
	4396	return -1;
	4397	}
	4398	if (sign[0])
	4399	PyOS_snprintf(buf, buflen, fmt, -x);
	4400	else
	4401	PyOS_snprintf(buf, buflen, fmt, x);
	4402	return (int)strlen(buf);
	4403	}
	4404
	4405	Py_LOCAL_INLINE(int)
	4406	formatchar(char buf, size_t buflen, PyObject v)
	4407	{
	4408	/* presume that the buffer is at least 2 characters long */
	4409	if (PyString_Check(v)) {
	4410	if (!PyArg_Parse(v, "c;%c requires int or char", &buf[0]))
	4411	return -1;
	4412	}
	4413	else {
	4414	if (!PyArg_Parse(v, "b;%c requires int or char", &buf[0]))
	4415	return -1;
	4416	}
	4417	buf[1] = '\0';
	4418	return 1;
	4419	}
	4420
	4421	/* fmt%(v1,v2,...) is roughly equivalent to sprintf(fmt, v1, v2, ...)
	4422
	4423	FORMATBUFLEN is the length of the buffer in which the floats, ints, &
	4424	chars are formatted. XXX This is a magic number. Each formatting
	4425	routine does bounds checking to ensure no overflow, but a better
	4426	solution may be to malloc a buffer of appropriate size for each
	4427	format. For now, the current solution is sufficient.
	4428	*/
	4429	#define FORMATBUFLEN (size_t)120
	4430
	4431	PyObject *
	4432	PyString_Format(PyObject format, PyObject args)
	4433	{
	4434	char fmt, res;
	4435	Py_ssize_t arglen, argidx;
	4436	Py_ssize_t reslen, rescnt, fmtcnt;
	4437	int args_owned = 0;
	4438	PyObject result, orig_args;
	4439	#ifdef Py_USING_UNICODE
	4440	PyObject v, w;
	4441	#endif
	4442	PyObject *dict = NULL;
	4443	if (format == NULL \|\| !PyString_Check(format) \|\| args == NULL) {
	4444	PyErr_BadInternalCall();
	4445	return NULL;
	4446	}
	4447	orig_args = args;
	4448	fmt = PyString_AS_STRING(format);
	4449	fmtcnt = PyString_GET_SIZE(format);
	4450	reslen = rescnt = fmtcnt + 100;
	4451	result = PyString_FromStringAndSize((char *)NULL, reslen);
	4452	if (result == NULL)
	4453	return NULL;
	4454	res = PyString_AsString(result);
	4455	if (PyTuple_Check(args)) {
	4456	arglen = PyTuple_GET_SIZE(args);
	4457	argidx = 0;
	4458	}
	4459	else {
	4460	arglen = -1;
	4461	argidx = -2;
	4462	}
	4463	if (args->ob_type->tp_as_mapping && !PyTuple_Check(args) &&
	4464	!PyObject_TypeCheck(args, &PyBaseString_Type))
	4465	dict = args;
	4466	while (--fmtcnt >= 0) {
	4467	if (*fmt != '%') {
	4468	if (--rescnt < 0) {
	4469	rescnt = fmtcnt + 100;
	4470	reslen += rescnt;
	4471	if (_PyString_Resize(&result, reslen) < 0)
	4472	return NULL;
	4473	res = PyString_AS_STRING(result)
	4474	+ reslen - rescnt;
	4475	--rescnt;
	4476	}
	4477	res++ = fmt++;
	4478	}
	4479	else {
	4480	/* Got a format specifier */
	4481	int flags = 0;
	4482	Py_ssize_t width = -1;
	4483	int prec = -1;
	4484	int c = '\0';
	4485	int fill;
	4486	PyObject *v = NULL;
	4487	PyObject *temp = NULL;
	4488	char *pbuf;
	4489	int sign;
	4490	Py_ssize_t len;
	4491	char formatbuf[FORMATBUFLEN];
	4492	/* For format{float,int,char}() */
	4493	#ifdef Py_USING_UNICODE
	4494	char *fmt_start = fmt;
	4495	Py_ssize_t argidx_start = argidx;
	4496	#endif
	4497
	4498	fmt++;
	4499	if (*fmt == '(') {
	4500	char *keystart;
	4501	Py_ssize_t keylen;
	4502	PyObject *key;
	4503	int pcount = 1;
	4504
	4505	if (dict == NULL) {
	4506	PyErr_SetString(PyExc_TypeError,
	4507	"format requires a mapping");
	4508	goto error;
	4509	}
	4510	++fmt;
	4511	--fmtcnt;
	4512	keystart = fmt;
	4513	/* Skip over balanced parentheses */
	4514	while (pcount > 0 && --fmtcnt >= 0) {
	4515	if (*fmt == ')')
	4516	--pcount;
	4517	else if (*fmt == '(')
	4518	++pcount;
	4519	fmt++;
	4520	}
	4521	keylen = fmt - keystart - 1;
	4522	if (fmtcnt < 0 \|\| pcount > 0) {
	4523	PyErr_SetString(PyExc_ValueError,
	4524	"incomplete format key");
	4525	goto error;
	4526	}
	4527	key = PyString_FromStringAndSize(keystart,
	4528	keylen);
	4529	if (key == NULL)
	4530	goto error;
	4531	if (args_owned) {
	4532	Py_DECREF(args);
	4533	args_owned = 0;
	4534	}
	4535	args = PyObject_GetItem(dict, key);
	4536	Py_DECREF(key);
	4537	if (args == NULL) {
	4538	goto error;
	4539	}
	4540	args_owned = 1;
	4541	arglen = -1;
	4542	argidx = -2;
	4543	}
	4544	while (--fmtcnt >= 0) {
	4545	switch (c = *fmt++) {
	4546	case '-': flags \|= F_LJUST; continue;
	4547	case '+': flags \|= F_SIGN; continue;
	4548	case ' ': flags \|= F_BLANK; continue;
	4549	case '#': flags \|= F_ALT; continue;
	4550	case '0': flags \|= F_ZERO; continue;
	4551	}
	4552	break;
	4553	}
	4554	if (c == '*') {
	4555	v = getnextarg(args, arglen, &argidx);
	4556	if (v == NULL)
	4557	goto error;
	4558	if (!PyInt_Check(v)) {
	4559	PyErr_SetString(PyExc_TypeError,
	4560	"* wants int");
	4561	goto error;
	4562	}
	4563	width = PyInt_AsLong(v);
	4564	if (width < 0) {
	4565	flags \|= F_LJUST;
	4566	width = -width;
	4567	}
	4568	if (--fmtcnt >= 0)
	4569	c = *fmt++;
	4570	}
	4571	else if (c >= 0 && isdigit(c)) {
	4572	width = c - '0';
	4573	while (--fmtcnt >= 0) {
	4574	c = Py_CHARMASK(*fmt++);
	4575	if (!isdigit(c))
	4576	break;
	4577	if ((width*10) / 10 != width) {
	4578	PyErr_SetString(
	4579	PyExc_ValueError,
	4580	"width too big");
	4581	goto error;
	4582	}
	4583	width = width*10 + (c - '0');
	4584	}
	4585	}
	4586	if (c == '.') {
	4587	prec = 0;
	4588	if (--fmtcnt >= 0)
	4589	c = *fmt++;
	4590	if (c == '*') {
	4591	v = getnextarg(args, arglen, &argidx);
	4592	if (v == NULL)
	4593	goto error;
	4594	if (!PyInt_Check(v)) {
	4595	PyErr_SetString(
	4596	PyExc_TypeError,
	4597	"* wants int");
	4598	goto error;
	4599	}
	4600	prec = PyInt_AsLong(v);
	4601	if (prec < 0)
	4602	prec = 0;
	4603	if (--fmtcnt >= 0)
	4604	c = *fmt++;
	4605	}
	4606	else if (c >= 0 && isdigit(c)) {
	4607	prec = c - '0';
	4608	while (--fmtcnt >= 0) {
	4609	c = Py_CHARMASK(*fmt++);
	4610	if (!isdigit(c))
	4611	break;
	4612	if ((prec*10) / 10 != prec) {
	4613	PyErr_SetString(
	4614	PyExc_ValueError,
	4615	"prec too big");
	4616	goto error;
	4617	}
	4618	prec = prec*10 + (c - '0');
	4619	}
	4620	}
	4621	} /* prec */
	4622	if (fmtcnt >= 0) {
	4623	if (c == 'h' \|\| c == 'l' \|\| c == 'L') {
	4624	if (--fmtcnt >= 0)
	4625	c = *fmt++;
	4626	}
	4627	}
	4628	if (fmtcnt < 0) {
	4629	PyErr_SetString(PyExc_ValueError,
	4630	"incomplete format");
	4631	goto error;
	4632	}
	4633	if (c != '%') {
	4634	v = getnextarg(args, arglen, &argidx);
	4635	if (v == NULL)
	4636	goto error;
	4637	}
	4638	sign = 0;
	4639	fill = ' ';
	4640	switch (c) {
	4641	case '%':
	4642	pbuf = "%";
	4643	len = 1;
	4644	break;
	4645	case 's':
	4646	#ifdef Py_USING_UNICODE
	4647	if (PyUnicode_Check(v)) {
	4648	fmt = fmt_start;
	4649	argidx = argidx_start;
	4650	goto unicode;
	4651	}
	4652	#endif
	4653	temp = _PyObject_Str(v);
	4654	#ifdef Py_USING_UNICODE
	4655	if (temp != NULL && PyUnicode_Check(temp)) {
	4656	Py_DECREF(temp);
	4657	fmt = fmt_start;
	4658	argidx = argidx_start;
	4659	goto unicode;
	4660	}
	4661	#endif
	4662	/* Fall through */
	4663	case 'r':
	4664	if (c == 'r')
	4665	temp = PyObject_Repr(v);
	4666	if (temp == NULL)
	4667	goto error;
	4668	if (!PyString_Check(temp)) {
	4669	PyErr_SetString(PyExc_TypeError,
	4670	"%s argument has non-string str()");
	4671	Py_DECREF(temp);
	4672	goto error;
	4673	}
	4674	pbuf = PyString_AS_STRING(temp);
	4675	len = PyString_GET_SIZE(temp);
	4676	if (prec >= 0 && len > prec)
	4677	len = prec;
	4678	break;
	4679	case 'i':
	4680	case 'd':
	4681	case 'u':
	4682	case 'o':
	4683	case 'x':
	4684	case 'X':
	4685	if (c == 'i')
	4686	c = 'd';
	4687	if (PyLong_Check(v)) {
	4688	int ilen;
	4689	temp = _PyString_FormatLong(v, flags,
	4690	prec, c, &pbuf, &ilen);
	4691	len = ilen;
	4692	if (!temp)
	4693	goto error;
	4694	sign = 1;
	4695	}
	4696	else {
	4697	pbuf = formatbuf;
	4698	len = formatint(pbuf,
	4699	sizeof(formatbuf),
	4700	flags, prec, c, v);
	4701	if (len < 0)
	4702	goto error;
	4703	sign = 1;
	4704	}
	4705	if (flags & F_ZERO)
	4706	fill = '0';
	4707	break;
	4708	case 'e':
	4709	case 'E':
	4710	case 'f':
	4711	case 'F':
	4712	case 'g':
	4713	case 'G':
	4714	if (c == 'F')
	4715	c = 'f';
	4716	pbuf = formatbuf;
	4717	len = formatfloat(pbuf, sizeof(formatbuf),
	4718	flags, prec, c, v);
	4719	if (len < 0)
	4720	goto error;
	4721	sign = 1;
	4722	if (flags & F_ZERO)
	4723	fill = '0';
	4724	break;
	4725	case 'c':
	4726	#ifdef Py_USING_UNICODE
	4727	if (PyUnicode_Check(v)) {
	4728	fmt = fmt_start;
	4729	argidx = argidx_start;
	4730	goto unicode;
	4731	}
	4732	#endif
	4733	pbuf = formatbuf;
	4734	len = formatchar(pbuf, sizeof(formatbuf), v);
	4735	if (len < 0)
	4736	goto error;
	4737	break;
	4738	default:
	4739	PyErr_Format(PyExc_ValueError,
	4740	"unsupported format character '%c' (0x%x) "
	4741	"at index %zd",
	4742	c, c,
	4743	(Py_ssize_t)(fmt - 1 -
	4744	PyString_AsString(format)));
	4745	goto error;
	4746	}
	4747	if (sign) {
	4748	if (pbuf == '-' \|\| pbuf == '+') {
	4749	sign = *pbuf++;
	4750	len--;
	4751	}
	4752	else if (flags & F_SIGN)
	4753	sign = '+';
	4754	else if (flags & F_BLANK)
	4755	sign = ' ';
	4756	else
	4757	sign = 0;
	4758	}
	4759	if (width < len)
	4760	width = len;
	4761	if (rescnt - (sign != 0) < width) {
	4762	reslen -= rescnt;
	4763	rescnt = width + fmtcnt + 100;
	4764	reslen += rescnt;
	4765	if (reslen < 0) {
	4766	Py_DECREF(result);
	4767	Py_XDECREF(temp);
	4768	return PyErr_NoMemory();
	4769	}
	4770	if (_PyString_Resize(&result, reslen) < 0) {
	4771	Py_XDECREF(temp);
	4772	return NULL;
	4773	}
	4774	res = PyString_AS_STRING(result)
	4775	+ reslen - rescnt;
	4776	}
	4777	if (sign) {
	4778	if (fill != ' ')
	4779	*res++ = sign;
	4780	rescnt--;
	4781	if (width > len)
	4782	width--;
	4783	}
	4784	if ((flags & F_ALT) && (c == 'x' \|\| c == 'X')) {
	4785	assert(pbuf[0] == '0');
	4786	assert(pbuf[1] == c);
	4787	if (fill != ' ') {
	4788	res++ = pbuf++;
	4789	res++ = pbuf++;
	4790	}
	4791	rescnt -= 2;
	4792	width -= 2;
	4793	if (width < 0)
	4794	width = 0;
	4795	len -= 2;
	4796	}
	4797	if (width > len && !(flags & F_LJUST)) {
	4798	do {
	4799	--rescnt;
	4800	*res++ = fill;
	4801	} while (--width > len);
	4802	}
	4803	if (fill == ' ') {
	4804	if (sign)
	4805	*res++ = sign;
	4806	if ((flags & F_ALT) &&
	4807	(c == 'x' \|\| c == 'X')) {
	4808	assert(pbuf[0] == '0');
	4809	assert(pbuf[1] == c);
	4810	res++ = pbuf++;
	4811	res++ = pbuf++;
	4812	}
	4813	}
	4814	Py_MEMCPY(res, pbuf, len);
	4815	res += len;
	4816	rescnt -= len;
	4817	while (--width >= len) {
	4818	--rescnt;
	4819	*res++ = ' ';
	4820	}
	4821	if (dict && (argidx < arglen) && c != '%') {
	4822	PyErr_SetString(PyExc_TypeError,
	4823	"not all arguments converted during string formatting");
	4824	Py_XDECREF(temp);
	4825	goto error;
	4826	}
	4827	Py_XDECREF(temp);
	4828	} /* '%' */
	4829	} /* until end */
	4830	if (argidx < arglen && !dict) {
	4831	PyErr_SetString(PyExc_TypeError,
	4832	"not all arguments converted during string formatting");
	4833	goto error;
	4834	}
	4835	if (args_owned) {
	4836	Py_DECREF(args);
	4837	}
	4838	_PyString_Resize(&result, reslen - rescnt);
	4839	return result;
	4840
	4841	#ifdef Py_USING_UNICODE
	4842	unicode:
	4843	if (args_owned) {
	4844	Py_DECREF(args);
	4845	args_owned = 0;
	4846	}
	4847	/* Fiddle args right (remove the first argidx arguments) */
	4848	if (PyTuple_Check(orig_args) && argidx > 0) {
	4849	PyObject *v;
	4850	Py_ssize_t n = PyTuple_GET_SIZE(orig_args) - argidx;
	4851	v = PyTuple_New(n);
	4852	if (v == NULL)
	4853	goto error;
	4854	while (--n >= 0) {
	4855	PyObject *w = PyTuple_GET_ITEM(orig_args, n + argidx);
	4856	Py_INCREF(w);
	4857	PyTuple_SET_ITEM(v, n, w);
	4858	}
	4859	args = v;
	4860	} else {
	4861	Py_INCREF(orig_args);
	4862	args = orig_args;
	4863	}
	4864	args_owned = 1;
	4865	/* Take what we have of the result and let the Unicode formatting
	4866	function format the rest of the input. */
	4867	rescnt = res - PyString_AS_STRING(result);
	4868	if (_PyString_Resize(&result, rescnt))
	4869	goto error;
	4870	fmtcnt = PyString_GET_SIZE(format) - \
	4871	(fmt - PyString_AS_STRING(format));
	4872	format = PyUnicode_Decode(fmt, fmtcnt, NULL, NULL);
	4873	if (format == NULL)
	4874	goto error;
	4875	v = PyUnicode_Format(format, args);
	4876	Py_DECREF(format);
	4877	if (v == NULL)
	4878	goto error;
	4879	/* Paste what we have (result) to what the Unicode formatting
	4880	function returned (v) and return the result (or error) */
	4881	w = PyUnicode_Concat(result, v);
	4882	Py_DECREF(result);
	4883	Py_DECREF(v);
	4884	Py_DECREF(args);
	4885	return w;
	4886	#endif /* Py_USING_UNICODE */
	4887
	4888	error:
	4889	Py_DECREF(result);
	4890	if (args_owned) {
	4891	Py_DECREF(args);
	4892	}
	4893	return NULL;
	4894	}
	4895
	4896	void
	4897	PyString_InternInPlace(PyObject **p)
	4898	{
	4899	register PyStringObject s = (PyStringObject )(*p);
	4900	PyObject *t;
	4901	if (s == NULL \|\| !PyString_Check(s))
	4902	Py_FatalError("PyString_InternInPlace: strings only please!");
	4903	/* If it's a string subclass, we don't really know what putting
	4904	it in the interned dict might do. */
	4905	if (!PyString_CheckExact(s))
	4906	return;
	4907	if (PyString_CHECK_INTERNED(s))
	4908	return;
	4909	if (interned == NULL) {
	4910	interned = PyDict_New();
	4911	if (interned == NULL) {
	4912	PyErr_Clear(); /* Don't leave an exception */
	4913	return;
	4914	}
	4915	}
	4916	t = PyDict_GetItem(interned, (PyObject *)s);
	4917	if (t) {
	4918	Py_INCREF(t);
	4919	Py_DECREF(*p);
	4920	*p = t;
	4921	return;
	4922	}
	4923
	4924	if (PyDict_SetItem(interned, (PyObject )s, (PyObject )s) < 0) {
	4925	PyErr_Clear();
	4926	return;
	4927	}
	4928	/* The two references in interned are not counted by refcnt.
	4929	The string deallocator will take care of this */
	4930	s->ob_refcnt -= 2;
	4931	PyString_CHECK_INTERNED(s) = SSTATE_INTERNED_MORTAL;
	4932	}
	4933
	4934	void
	4935	PyString_InternImmortal(PyObject **p)
	4936	{
	4937	PyString_InternInPlace(p);
	4938	if (PyString_CHECK_INTERNED(*p) != SSTATE_INTERNED_IMMORTAL) {
	4939	PyString_CHECK_INTERNED(*p) = SSTATE_INTERNED_IMMORTAL;
	4940	Py_INCREF(*p);
	4941	}
	4942	}
	4943
	4944
	4945	PyObject *
	4946	PyString_InternFromString(const char *cp)
	4947	{
	4948	PyObject *s = PyString_FromString(cp);
	4949	if (s == NULL)
	4950	return NULL;
	4951	PyString_InternInPlace(&s);
	4952	return s;
	4953	}
	4954
	4955	void
	4956	PyString_Fini(void)
	4957	{
	4958	int i;
	4959	for (i = 0; i < UCHAR_MAX + 1; i++) {
	4960	Py_XDECREF(characters[i]);
	4961	characters[i] = NULL;
	4962	}
	4963	Py_XDECREF(nullstring);
	4964	nullstring = NULL;
	4965	}
	4966
	4967	void _Py_ReleaseInternedStrings(void)
	4968	{
	4969	PyObject *keys;
	4970	PyStringObject *s;
	4971	Py_ssize_t i, n;
	4972
	4973	if (interned == NULL \|\| !PyDict_Check(interned))
	4974	return;
	4975	keys = PyDict_Keys(interned);
	4976	if (keys == NULL \|\| !PyList_Check(keys)) {
	4977	PyErr_Clear();
	4978	return;
	4979	}
	4980
	4981	/* Since _Py_ReleaseInternedStrings() is intended to help a leak
	4982	detector, interned strings are not forcibly deallocated; rather, we
	4983	give them their stolen references back, and then clear and DECREF
	4984	the interned dict. */
	4985
	4986	fprintf(stderr, "releasing interned strings\n");
	4987	n = PyList_GET_SIZE(keys);
	4988	for (i = 0; i < n; i++) {
	4989	s = (PyStringObject *) PyList_GET_ITEM(keys, i);
	4990	switch (s->ob_sstate) {
	4991	case SSTATE_NOT_INTERNED:
	4992	/* XXX Shouldn't happen */
	4993	break;
	4994	case SSTATE_INTERNED_IMMORTAL:
	4995	s->ob_refcnt += 1;
	4996	break;
	4997	case SSTATE_INTERNED_MORTAL:
	4998	s->ob_refcnt += 2;
	4999	break;

10 more lines aren’t shown here.