Unsuccessful initialization yields a NULL pointer.  Note that *no*   exception information is available even in this case -- the   exception information is held in the thread, and there is no   thread.    Locking: as above. */ PyThreadState *Py_NewInterpreter(void){	PyInterpreterState *interp;	PyThreadState *tstate, *save_tstate;	PyObject *bimod, *sysmod; 	if (!initialized)		Py_FatalError("Py_NewInterpreter: call Py_Initialize first"); 	interp = PyInterpreterState_New();	if (interp == NULL)		return NULL; 	tstate = PyThreadState_New(interp);	if (tstate == NULL) {		PyInterpreterState_Delete(interp);		return NULL;	} 	save_tstate = PyThreadState_Swap(tstate); 	/* XXX The following is lax in error checking */ 	interp->modules = PyDict_New();	interp->modules_reloading = PyDict_New(); 	bimod = _PyImport_FindExtension("__builtin__", "__builtin__");	if (bimod != NULL) {		interp->builtins = PyModule_GetDict(bimod);		if (interp->builtins == NULL)			goto handle_error;		Py_INCREF(interp->builtins);	}	sysmod = _PyImport_FindExtension("sys", "sys");	if (bimod != NULL && sysmod != NULL) {		interp->sysdict = PyModule_GetDict(sysmod);		if (interp->sysdict == NULL)			goto handle_error;		Py_INCREF(interp->sysdict);		PySys_SetPath(Py_GetPath());		PyDict_SetItemString(interp->sysdict, "modules",				     interp->modules);		_PyImportHooks_Init();		initmain();		if (!Py_NoSiteFlag)			initsite();	} 	if (!PyErr_Occurred())		return tstate; handle_error:	/* Oops, it didn't work.  Undo it all. */ 	PyErr_Print();	PyThreadState_Clear(tstate);	PyThreadState_Swap(save_tstate);	PyThreadState_Delete(tstate);	PyInterpreterState_Delete(interp); 	return NULL;} /* Delete an interpreter and its last thread.  This requires that the   given thread state is current, that the thread has no remaining   frames, and that it is its interpreter's only remaining thread.   It is a fatal error to violate these constraints.    (Py_Finalize() doesn't have these constraints -- it zaps   everything, regardless.)    Locking: as above. */ voidPy_EndInterpreter(PyThreadState *tstate){	PyInterpreterState *interp = tstate->interp; 	if (tstate != PyThreadState_GET())		Py_FatalError("Py_EndInterpreter: thread is not current");	if (tstate->frame != NULL)		Py_FatalError("Py_EndInterpreter: thread still has a frame");	if (tstate != interp->tstate_head || tstate->next != NULL)		Py_FatalError("Py_EndInterpreter: not the last thread"); 	PyImport_Cleanup();	PyInterpreterState_Clear(interp);	PyThreadState_Swap(NULL);	PyInterpreterState_Delete(interp);} static char *progname = "python"; voidPy_SetProgramName(char *pn){	if (pn && *pn)		progname = pn;} char *Py_GetProgramName(void){	return progname;} static char *default_home = NULL; voidPy_SetPythonHome(char *home){	default_home = home;} char *Py_GetPythonHome(void){	char *home = default_home;	if (home == NULL && !Py_IgnoreEnvironmentFlag)		home = Py_GETENV("PYTHONHOME");	return home;} /* Create __main__ module */ static voidinitmain(void){	PyObject *m, *d;	m = PyImport_AddModule("__main__");	if (m == NULL)		Py_FatalError("can't create __main__ module");	d = PyModule_GetDict(m);	if (PyDict_GetItemString(d, "__builtins__") == NULL) {		PyObject *bimod = PyImport_ImportModule("__builtin__");		if (bimod == NULL ||		    PyDict_SetItemString(d, "__builtins__", bimod) != 0)			Py_FatalError("can't add __builtins__ to __main__");		Py_DECREF(bimod);	}} /* Import the site module (not into __main__ though) */ static voidinitsite(void){	PyObject *m, *f;	m = PyImport_ImportModule("site");	if (m == NULL) {		f = PySys_GetObject("stderr");		if (Py_VerboseFlag) {			PyFile_WriteString(				"'import site' failed; traceback:\n", f);			PyErr_Print();		}		else {			PyFile_WriteString(			  "'import site' failed; use -v for traceback\n", f);			PyErr_Clear();		}	}	else {		Py_DECREF(m);	}} /* Parse input from a file and execute it */ intPyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit,		     PyCompilerFlags *flags){	if (filename == NULL)		filename = "???";	if (Py_FdIsInteractive(fp, filename)) {		int err = PyRun_InteractiveLoopFlags(fp, filename, flags);		if (closeit)			fclose(fp);		return err;	}	else		return PyRun_SimpleFileExFlags(fp, filename, closeit, flags);} intPyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags){	PyObject *v;	int ret;	PyCompilerFlags local_flags; 	if (flags == NULL) {		flags = &local_flags;		local_flags.cf_flags = 0;	}	v = PySys_GetObject("ps1");	if (v == NULL) {		PySys_SetObject("ps1", v = PyString_FromString(">>> "));		Py_XDECREF(v);	}	v = PySys_GetObject("ps2");	if (v == NULL) {		PySys_SetObject("ps2", v = PyString_FromString("... "));		Py_XDECREF(v);	}	for (;;) {		ret = PyRun_InteractiveOneFlags(fp, filename, flags);		PRINT_TOTAL_REFS();		if (ret == E_EOF)			return 0;		/*		if (ret == E_NOMEM)			return -1;		*/	}} /* compute parser flags based on compiler flags */#define PARSER_FLAGS(flags) \	((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \		      PyPARSE_DONT_IMPLY_DEDENT : 0) \		    | ((flags)->cf_flags & CO_FUTURE_WITH_STATEMENT ? \		       PyPARSE_WITH_IS_KEYWORD : 0)) : 0) intPyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags){	PyObject *m, *d, *v, *w;	mod_ty mod;	PyArena *arena;	char *ps1 = "", *ps2 = "";	int errcode = 0; 	v = PySys_GetObject("ps1");	if (v != NULL) {		v = PyObject_Str(v);		if (v == NULL)			PyErr_Clear();		else if (PyString_Check(v))			ps1 = PyString_AsString(v);	}	w = PySys_GetObject("ps2");	if (w != NULL) {		w = PyObject_Str(w);		if (w == NULL)			PyErr_Clear();		else if (PyString_Check(w))			ps2 = PyString_AsString(w);	}	arena = PyArena_New();	if (arena == NULL) {		Py_XDECREF(v);		Py_XDECREF(w);		return -1;	}	mod = PyParser_ASTFromFile(fp, filename,				   Py_single_input, ps1, ps2,				   flags, &errcode, arena);	Py_XDECREF(v);	Py_XDECREF(w);	if (mod == NULL) {		PyArena_Free(arena);		if (errcode == E_EOF) {			PyErr_Clear();			return E_EOF;		}		PyErr_Print();		return -1;	}	m = PyImport_AddModule("__main__");	if (m == NULL) {		PyArena_Free(arena);		return -1;	}	d = PyModule_GetDict(m);	v = run_mod(mod, filename, d, d, flags, arena);	PyArena_Free(arena);	if (v == NULL) {		PyErr_Print();		return -1;	}	Py_DECREF(v);	if (Py_FlushLine())		PyErr_Clear();	return 0;} /* Check whether a file maybe a pyc file: Look at the extension,   the file type, and, if we may close it, at the first few bytes. */ static intmaybe_pyc_file(FILE *fp, const char* filename, const char* ext, int closeit){	if (strcmp(ext, ".pyc") == 0 || strcmp(ext, ".pyo") == 0)		return 1; 	/* Only look into the file if we are allowed to close it, since	   it then should also be seekable. */	if (closeit) {		/* Read only two bytes of the magic. If the file was opened in		   text mode, the bytes 3 and 4 of the magic (\r\n) might not		   be read as they are on disk. */		unsigned int halfmagic = PyImport_GetMagicNumber() & 0xFFFF;		unsigned char buf[2];		/* Mess:  In case of -x, the stream is NOT at its start now,		   and ungetc() was used to push back the first newline,		   which makes the current stream position formally undefined,		   and a x-platform nightmare.		   Unfortunately, we have no direct way to know whether -x		   was specified.  So we use a terrible hack:  if the current		   stream position is not 0, we assume -x was specified, and		   give up.  Bug 132850 on SourceForge spells out the		   hopelessness of trying anything else (fseek and ftell		   don't work predictably x-platform for text-mode files).		*/		int ispyc = 0;		if (ftell(fp) == 0) {			if (fread(buf, 1, 2, fp) == 2 &&			    ((unsigned int)buf[1]<<8 | buf[0]) == halfmagic)				ispyc = 1;			rewind(fp);		}		return ispyc;	}	return 0;} intPyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit,			PyCompilerFlags *flags){	PyObject *m, *d, *v;	const char *ext; 	m = PyImport_AddModule("__main__");	if (m == NULL)		return -1;	d = PyModule_GetDict(m);	if (PyDict_GetItemString(d, "__file__") == NULL) {		PyObject *f = PyString_FromString(filename);		if (f == NULL)			return -1;		if (PyDict_SetItemString(d, "__file__", f) < 0) {			Py_DECREF(f);			return -1;		}		Py_DECREF(f);	}	ext = filename + strlen(filename) - 4;	if (maybe_pyc_file(fp, filename, ext, closeit)) {		/* Try to run a pyc file. First, re-open in binary */		if (closeit)			fclose(fp);		if ((fp = fopen(filename, "rb")) == NULL) {			fprintf(stderr, "python: Can't reopen .pyc file\n");			return -1;		}		/* Turn on optimization if a .pyo file is given */		if (strcmp(ext, ".pyo") == 0)			Py_OptimizeFlag = 1;		v = run_pyc_file(fp, filename, d, d, flags);	} else {		v = PyRun_FileExFlags(fp, filename, Py_file_input, d, d,				      closeit, flags);	}	if (v == NULL) {		PyErr_Print();		return -1;	}	Py_DECREF(v);	if (Py_FlushLine())		PyErr_Clear();	return 0;} intPyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags){	PyObject *m, *d, *v;	m = PyImport_AddModule("__main__");	if (m == NULL)		return -1;	d = PyModule_GetDict(m);	v = PyRun_StringFlags(command, Py_file_input, d, d, flags);	if (v == NULL) {		PyErr_Print();		return -1;	}	Py_DECREF(v);	if (Py_FlushLine())		PyErr_Clear();	return 0;} static intparse_syntax_error(PyObject *err, PyObject **message, const char **filename,		   int *lineno, int *offset, const char **text){	long hold;	PyObject *v; 	/* old style errors */	if (PyTuple_Check(err))		return PyArg_ParseTuple(err, "O(ziiz)", message, filename,					lineno, offset, text); 	/* new style errors.  `err' is an instance */ 	if (! (v = PyObject_GetAttrString(err, "msg")))		goto finally;	*message = v; 	if (!(v = PyObject_GetAttrString(err, "filename")))		goto finally;	if (v == Py_None)		*filename = NULL;	else if (! (*filename = PyString_AsString(v)))		goto finally; 	Py_DECREF(v);	if (!(v = PyObject_GetAttrString(err, "lineno")))		goto finally;	hold = PyInt_AsLong(v);	Py_DECREF(v);	v = NULL;	if (hold < 0 && PyErr_Occurred())		goto finally;	*lineno = (int)hold; 	if (!(v = PyObject_GetAttrString(err, "offset")))		goto finally;	if (v == Py_None) {		*offset = -1;		Py_DECREF(v);		v = NULL;	} else {		hold = PyInt_AsLong(v);		Py_DECREF(v);		v = NULL;		if (hold < 0 && PyErr_Occurred())			goto finally;		*offset = (int)hold;	} 	if (!(v = PyObject_GetAttrString(err, "text")))		goto finally;	if (v == Py_None)		*text = NULL;	else if (! (*text = PyString_AsString(v)))		goto finally;	Py_DECREF(v);	return 1; finally:	Py_XDECREF(v);	return 0;} voidPyErr_Print(void){	PyErr_PrintEx(1);} static voidprint_error_text(PyObject *f, int offset, const char *text){	char *nl;	if (offset >= 0) {		if (offset > 0 && offset == (int)strlen(text))			offset--;		for (;;) {			nl = strchr(text, '\n');			if (nl == NULL || nl-text >= offset)				break;			offset -= (int)(nl+1-text);			text = nl+1;		}		while (*text == ' ' || *text == '\t') {			text++;			offset--;		}	}	PyFile_WriteString("    ", f);	PyFile_WriteString(text, f);	if (*text == '\0' || text[strlen(text)-1] != '\n')

Lines 501–1000 of 1857. Previous lines Load more