cpython-lru_cache-weakref: Python/ceval.c comparison

comparison Python/ceval.c @ 47294:4fe192d48960 legacy-trunk

Renamed PyString to PyBytes

author	Christian Heimes <christian@cheimes.de>
date	Mon, 26 May 2008 12:51:38 +0000
parents	7670005da8c5
children	52294af4b663

comparison

equal deleted inserted replaced

-:abafccfe7501
+:4fe192d48960
 	co = f->f_code;
 	names = co->co_names;
 	consts = co->co_consts;
 	fastlocals = f->f_localsplus;
 	freevars = f->f_localsplus + co->co_nlocals;
-	first_instr = (unsigned char*) PyString_AS_STRING(co->co_code);
+	first_instr = (unsigned char*) PyBytes_AS_STRING(co->co_code);
 	/* An explanation is in order for the next line.
 	   f->f_lasti now refers to the index of the last instruction
 	   executed.  You might think this was obvious from the name, but
 	   this wasn't always true before 2.3!  PyFrame_New now sets
 #ifdef LLTRACE
 	lltrace = PyDict_GetItemString(f->f_globals, "__lltrace__") != NULL;
 #endif
 #if defined(Py_DEBUG) || defined(LLTRACE)
-	filename = PyString_AsString(co->co_filename);
+	filename = PyBytes_AsString(co->co_filename);
 #endif
 	why = WHY_NOT;
 	err = 0;
 	x = Py_None;	/* Not a reference, just anything non-NULL */
 				i = a + b;
 				if ((i^a) < 0 && (i^b) < 0)
 					goto slow_add;
 				x = PyInt_FromLong(i);
 			}
-			else if (PyString_CheckExact(v) &&
+			else if (PyBytes_CheckExact(v) &&
-				 PyString_CheckExact(w)) {
+				 PyBytes_CheckExact(w)) {
 				x = string_concatenate(v, w, f, next_instr);
 				/* string_concatenate consumed the ref to v */
 				goto skip_decref_vx;
 			}
 			else {
 				i = a + b;
 				if ((i^a) < 0 && (i^b) < 0)
 					goto slow_iadd;
 				x = PyInt_FromLong(i);
 			}
-			else if (PyString_CheckExact(v) &&
+			else if (PyBytes_CheckExact(v) &&
-				 PyString_CheckExact(w)) {
+				 PyBytes_CheckExact(w)) {
 				x = string_concatenate(v, w, f, next_instr);
 				/* string_concatenate consumed the ref to v */
 				goto skip_decref_v;
 			}
 			else {
 				err = PyFile_WriteString(" ", w);
 			if (err == 0)
 				err = PyFile_WriteObject(v, w, Py_PRINT_RAW);
 			if (err == 0) {
 			    /* XXX move into writeobject() ? */
-			    if (PyString_Check(v)) {
+			    if (PyBytes_Check(v)) {
-				char *s = PyString_AS_STRING(v);
+				char *s = PyBytes_AS_STRING(v);
-				Py_ssize_t len = PyString_GET_SIZE(v);
+				Py_ssize_t len = PyBytes_GET_SIZE(v);
 				if (len == 0 ||
 				    !isspace(Py_CHARMASK(s[len-1])) ||
 				    s[len-1] == ' ')
 					PyFile_SoftSpace(w, 1);
 			    }
 				if (why == WHY_RETURN ||
 				    why == WHY_CONTINUE)
 					retval = POP();
 			}
 			else if (PyExceptionClass_Check(v) ||
-			         PyString_Check(v)) {
+			         PyBytes_Check(v)) {
 				w = POP();
 				u = POP();
 				PyErr_Restore(v, w, u);
 				why = WHY_RERAISE;
 				break;
 			PUSH(x);
 			continue;
 		case LOAD_GLOBAL:
 			w = GETITEM(names, oparg);
-			if (PyString_CheckExact(w)) {
+			if (PyBytes_CheckExact(w)) {
 				/* Inline the PyDict_GetItem() calls.
 				   WARNING: this is an extreme speed hack.
 				   Do not try this at home. */
-				long hash = ((PyStringObject *)w)->ob_shash;
+				long hash = ((PyBytesObject *)w)->ob_shash;
 				if (hash != -1) {
 					PyDictObject *d;
 					PyDictEntry *e;
 					d = (PyDictObject *)(f->f_globals);
 					e = d->ma_lookup(d, w, hash);
 		if (argcount > co->co_argcount) {
 			if (!(co->co_flags & CO_VARARGS)) {
 				PyErr_Format(PyExc_TypeError,
 				    "%.200s() takes %s %d "
 				    "%sargument%s (%d given)",
-				    PyString_AsString(co->co_name),
+				    PyBytes_AsString(co->co_name),
 				    defcount ? "at most" : "exactly",
 				    co->co_argcount,
 				    kwcount ? "non-keyword " : "",
 				    co->co_argcount == 1 ? "" : "s",
 				    argcount);
 		}
 		for (i = 0; i < kwcount; i++) {
 			PyObject *keyword = kws[2*i];
 			PyObject *value = kws[2*i + 1];
 			int j;
-			if (keyword == NULL || !PyString_Check(keyword)) {
+			if (keyword == NULL || !PyBytes_Check(keyword)) {
 				PyErr_Format(PyExc_TypeError,
 				    "%.200s() keywords must be strings",
-				    PyString_AsString(co->co_name));
+				    PyBytes_AsString(co->co_name));
 				goto fail;
 			}
 			/* XXX slow -- speed up using dictionary? */
 			for (j = 0; j < co->co_argcount; j++) {
 				PyObject *nm = PyTuple_GET_ITEM(
 			if (j >= co->co_argcount) {
 				if (kwdict == NULL) {
 					PyErr_Format(PyExc_TypeError,
 					    "%.200s() got an unexpected "
 					    "keyword argument '%.400s'",
-					    PyString_AsString(co->co_name),
+					    PyBytes_AsString(co->co_name),
-					    PyString_AsString(keyword));
+					    PyBytes_AsString(keyword));
 					goto fail;
 				}
 				PyDict_SetItem(kwdict, keyword, value);
 			}
 			else {
 				if (GETLOCAL(j) != NULL) {
 					PyErr_Format(PyExc_TypeError,
 					     "%.200s() got multiple "
 					     "values for keyword "
 					     "argument '%.400s'",
-					     PyString_AsString(co->co_name),
+					     PyBytes_AsString(co->co_name),
-					     PyString_AsString(keyword));
+					     PyBytes_AsString(keyword));
 					goto fail;
 				}
 				Py_INCREF(value);
 				SETLOCAL(j, value);
 			}
 			for (i = argcount; i < m; i++) {
 				if (GETLOCAL(i) == NULL) {
 					PyErr_Format(PyExc_TypeError,
 					    "%.200s() takes %s %d "
 					    "%sargument%s (%d given)",
-					    PyString_AsString(co->co_name),
+					    PyBytes_AsString(co->co_name),
 					    ((co->co_flags & CO_VARARGS) ||
 					     defcount) ? "at least"
 						       : "exactly",
 					    m, kwcount ? "non-keyword " : "",
 					    m == 1 ? "" : "s", i);
 	}
 	else {
 		if (argcount > 0 || kwcount > 0) {
 			PyErr_Format(PyExc_TypeError,
 				     "%.200s() takes no arguments (%d given)",
-				     PyString_AsString(co->co_name),
+				     PyBytes_AsString(co->co_name),
 				     argcount + kwcount);
 			goto fail;
 		}
 	}
 	/* Allocate and initialize storage for cell vars, and copy free
 		   Should arrange for the compiler to put cellvars
 		   that are arguments at the beginning of the cellvars
 		   list so that we can march over it more efficiently?
 		*/
 		for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) {
-			cellname = PyString_AS_STRING(
+			cellname = PyBytes_AS_STRING(
 				PyTuple_GET_ITEM(co->co_cellvars, i));
 			found = 0;
 			for (j = 0; j < nargs; j++) {
-				argname = PyString_AS_STRING(
+				argname = PyBytes_AS_STRING(
 					PyTuple_GET_ITEM(co->co_varnames, j));
 				if (strcmp(cellname, argname) == 0) {
 					c = PyCell_New(GETLOCAL(j));
 					if (c == NULL)
 						goto fail;
 PyEval_GetFuncName(PyObject *func)
 {
 	if (PyMethod_Check(func))
 		return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
 	else if (PyFunction_Check(func))
-		return PyString_AsString(((PyFunctionObject*)func)->func_name);
+		return PyBytes_AsString(((PyFunctionObject*)func)->func_name);
 	else if (PyCFunction_Check(func))
 		return ((PyCFunctionObject*)func)->m_ml->ml_name;
 	else if (PyClass_Check(func))
-		return PyString_AsString(((PyClassObject*)func)->cl_name);
+		return PyBytes_AsString(((PyClassObject*)func)->cl_name);
 	else if (PyInstance_Check(func)) {
-		return PyString_AsString(
+		return PyBytes_AsString(
 			((PyInstanceObject*)func)->in_class->cl_name);
 	} else {
 		return func->ob_type->tp_name;
 	}
 }
 			PyErr_Format(PyExc_TypeError,
 				     "%.200s%s got multiple values "
 				     "for keyword argument '%.200s'",
 				     PyEval_GetFuncName(func),
 				     PyEval_GetFuncDesc(func),
-				     PyString_AsString(key));
+				     PyBytes_AsString(key));
 			Py_DECREF(key);
 			Py_DECREF(value);
 			Py_DECREF(kwdict);
 			return NULL;
 		}
 		if (PyTuple_Check(w)) {
 			Py_ssize_t i, length;
 			length = PyTuple_Size(w);
 			for (i = 0; i < length; i += 1) {
 				PyObject *exc = PyTuple_GET_ITEM(w, i);
-				if (PyString_Check(exc)) {
+				if (PyBytes_Check(exc)) {
 					int ret_val;
 					ret_val = PyErr_WarnEx(
 						PyExc_DeprecationWarning,
 						"catching of string "
 						"exceptions is deprecated", 1);
 						return NULL;
 				}
 			}
 		}
 		else {
-			if (PyString_Check(w)) {
+			if (PyBytes_Check(w)) {
 				int ret_val;
 				ret_val = PyErr_WarnEx(
 						PyExc_DeprecationWarning,
 						"catching of string "
 						"exceptions is deprecated", 1);
 	x = PyObject_GetAttr(v, name);
 	if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
 		PyErr_Format(PyExc_ImportError,
 			     "cannot import name %.230s",
-			     PyString_AsString(name));
+			     PyBytes_AsString(name));
 	}
 	return x;
 }
 static int
 			else
 				PyErr_Clear();
 			break;
 		}
 		if (skip_leading_underscores &&
-		    PyString_Check(name) &&
+		    PyBytes_Check(name) &&
-		    PyString_AS_STRING(name)[0] == '_')
+		    PyBytes_AS_STRING(name)[0] == '_')
 		{
 			Py_DECREF(name);
 			continue;
 		}
 		value = PyObject_GetAttr(v, name);
 		   by augmenting the error message with more information.*/
 		PyObject *ptype, *pvalue, *ptraceback;
 		PyErr_Fetch(&ptype, &pvalue, &ptraceback);
-		if (PyString_Check(pvalue)) {
+		if (PyBytes_Check(pvalue)) {
 			PyObject *newmsg;
-			newmsg = PyString_FromFormat(
+			newmsg = PyBytes_FromFormat(
 				"Error when calling the metaclass bases\n"
 				"    %s",
-				PyString_AS_STRING(pvalue));
+				PyBytes_AS_STRING(pvalue));
 			if (newmsg != NULL) {
 				Py_DECREF(pvalue);
 				pvalue = newmsg;
 			}
 		}
 			return -1;
 		}
 	}
 	else if (locals == Py_None)
 		locals = globals;
-	if (!PyString_Check(prog) &&
+	if (!PyBytes_Check(prog) &&
 	    !PyUnicode_Check(prog) &&
 	    !PyCode_Check(prog) &&
 	    !PyFile_Check(prog)) {
 		PyErr_SetString(PyExc_TypeError,
 			"exec: arg 1 must be a string, file, or code object");
 		}
 		v = PyEval_EvalCode((PyCodeObject *) prog, globals, locals);
 	}
 	else if (PyFile_Check(prog)) {
 		FILE *fp = PyFile_AsFile(prog);
-		char *name = PyString_AsString(PyFile_Name(prog));
+		char *name = PyBytes_AsString(PyFile_Name(prog));
 		PyCompilerFlags cf;
 		if (name == NULL)
 			return -1;
 		cf.cf_flags = 0;
 		if (PyEval_MergeCompilerFlags(&cf))
 				return -1;
 			prog = tmp;
 			cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
 		}
 #endif
-		if (PyString_AsStringAndSize(prog, &str, NULL))
+		if (PyBytes_AsStringAndSize(prog, &str, NULL))
 			return -1;
 		if (PyEval_MergeCompilerFlags(&cf))
 			v = PyRun_StringFlags(str, Py_file_input, globals,
 					      locals, &cf);
 		else
 	char *obj_str;
 	if (!obj)
 		return;
-	obj_str = PyString_AsString(obj);
+	obj_str = PyBytes_AsString(obj);
 	if (!obj_str)
 		return;
 	PyErr_Format(exc, format_str, obj_str);
 }
 string_concatenate(PyObject *v, PyObject *w,
 		   PyFrameObject *f, unsigned char *next_instr)
 {
 	/* This function implements 'variable += expr' when both arguments
 	   are strings. */
-	Py_ssize_t v_len = PyString_GET_SIZE(v);
+	Py_ssize_t v_len = PyBytes_GET_SIZE(v);
-	Py_ssize_t w_len = PyString_GET_SIZE(w);
+	Py_ssize_t w_len = PyBytes_GET_SIZE(w);
 	Py_ssize_t new_len = v_len + w_len;
 	if (new_len < 0) {
 		PyErr_SetString(PyExc_OverflowError,
 				"strings are too large to concat");
 		return NULL;
 			break;
 		}
 		}
 	}
-	if (v->ob_refcnt == 1 && !PyString_CHECK_INTERNED(v)) {
+	if (v->ob_refcnt == 1 && !PyBytes_CHECK_INTERNED(v)) {
 		/* Now we own the last reference to 'v', so we can resize it
 		 * in-place.
 		 */
-		if (_PyString_Resize(&v, new_len) != 0) {
+		if (_PyBytes_Resize(&v, new_len) != 0) {
-			/* XXX if _PyString_Resize() fails, 'v' has been
+			/* XXX if _PyBytes_Resize() fails, 'v' has been
 			 * deallocated so it cannot be put back into
 			 * 'variable'.  The MemoryError is raised when there
 			 * is no value in 'variable', which might (very
 			 * remotely) be a cause of incompatibilities.
 			 */
 			return NULL;
 		}
 		/* copy 'w' into the newly allocated area of 'v' */
-		memcpy(PyString_AS_STRING(v) + v_len,
+		memcpy(PyBytes_AS_STRING(v) + v_len,
-		       PyString_AS_STRING(w), w_len);
+		       PyBytes_AS_STRING(w), w_len);
 		return v;
 	}
 	else {
 		/* When in-place resizing is not an option. */
-		PyString_Concat(&v, w);
+		PyBytes_Concat(&v, w);
 		return v;
 	}
 }
 #ifdef DYNAMIC_EXECUTION_PROFILE

Mercurial > cpython-lru_cache-weakref

comparison Python/ceval.c @ 47294:4fe192d48960 legacy-trunk