PyFile_WriteString("\n", f);	if (offset == -1)		return;	PyFile_WriteString("    ", f);	offset--;	while (offset > 0) {		PyFile_WriteString(" ", f);		offset--;	}	PyFile_WriteString("^\n", f);} static voidhandle_system_exit(void){	PyObject *exception, *value, *tb;	int exitcode = 0; 	PyErr_Fetch(&exception, &value, &tb);	if (Py_FlushLine())		PyErr_Clear();	fflush(stdout);	if (value == NULL || value == Py_None)		goto done;	if (PyExceptionInstance_Check(value)) {		/* The error code should be in the `code' attribute. */		PyObject *code = PyObject_GetAttrString(value, "code");		if (code) {			Py_DECREF(value);			value = code;			if (value == Py_None)				goto done;		}		/* If we failed to dig out the 'code' attribute,		   just let the else clause below print the error. */	}	if (PyInt_Check(value))		exitcode = (int)PyInt_AsLong(value);	else {		PyObject_Print(value, stderr, Py_PRINT_RAW);		PySys_WriteStderr("\n");		exitcode = 1;	} done:	/* Restore and clear the exception info, in order to properly decref	 * the exception, value, and traceback.	 If we just exit instead,	 * these leak, which confuses PYTHONDUMPREFS output, and may prevent	 * some finalizers from running.	 */	PyErr_Restore(exception, value, tb);	PyErr_Clear();	Py_Exit(exitcode);	/* NOTREACHED */} voidPyErr_PrintEx(int set_sys_last_vars){	PyObject *exception, *v, *tb, *hook; 	if (PyErr_ExceptionMatches(PyExc_SystemExit)) {		handle_system_exit();	}	PyErr_Fetch(&exception, &v, &tb);	if (exception == NULL)		return;	PyErr_NormalizeException(&exception, &v, &tb);	if (exception == NULL)		return;        /* Now we know v != NULL too */	if (set_sys_last_vars) {		PySys_SetObject("last_type", exception);		PySys_SetObject("last_value", v);		PySys_SetObject("last_traceback", tb);	}	hook = PySys_GetObject("excepthook");	if (hook) {		PyObject *args = PyTuple_Pack(3,		    exception, v, tb ? tb : Py_None);		PyObject *result = PyEval_CallObject(hook, args);		if (result == NULL) {			PyObject *exception2, *v2, *tb2;			if (PyErr_ExceptionMatches(PyExc_SystemExit)) {				handle_system_exit();			}			PyErr_Fetch(&exception2, &v2, &tb2);			PyErr_NormalizeException(&exception2, &v2, &tb2);			/* It should not be possible for exception2 or v2			   to be NULL. However PyErr_Display() can't			   tolerate NULLs, so just be safe. */			if (exception2 == NULL) {				exception2 = Py_None;				Py_INCREF(exception2);			}			if (v2 == NULL) {				v2 = Py_None;				Py_INCREF(v2);			}			if (Py_FlushLine())				PyErr_Clear();			fflush(stdout);			PySys_WriteStderr("Error in sys.excepthook:\n");			PyErr_Display(exception2, v2, tb2);			PySys_WriteStderr("\nOriginal exception was:\n");			PyErr_Display(exception, v, tb);			Py_DECREF(exception2);			Py_DECREF(v2);			Py_XDECREF(tb2);		}		Py_XDECREF(result);		Py_XDECREF(args);	} else {		PySys_WriteStderr("sys.excepthook is missing\n");		PyErr_Display(exception, v, tb);	}	Py_XDECREF(exception);	Py_XDECREF(v);	Py_XDECREF(tb);} voidPyErr_Display(PyObject *exception, PyObject *value, PyObject *tb){	int err = 0;	PyObject *f = PySys_GetObject("stderr");	Py_INCREF(value);	if (f == NULL)		fprintf(stderr, "lost sys.stderr\n");	else {		if (Py_FlushLine())			PyErr_Clear();		fflush(stdout);		if (tb && tb != Py_None)			err = PyTraceBack_Print(tb, f);		if (err == 0 &&		    PyObject_HasAttrString(value, "print_file_and_line"))		{			PyObject *message;			const char *filename, *text;			int lineno, offset;			if (!parse_syntax_error(value, &message, &filename,						&lineno, &offset, &text))				PyErr_Clear();			else {				char buf[10];				PyFile_WriteString("  File \"", f);				if (filename == NULL)					PyFile_WriteString("<string>", f);				else					PyFile_WriteString(filename, f);				PyFile_WriteString("\", line ", f);				PyOS_snprintf(buf, sizeof(buf), "%d", lineno);				PyFile_WriteString(buf, f);				PyFile_WriteString("\n", f);				if (text != NULL)					print_error_text(f, offset, text);				Py_DECREF(value);				value = message;				/* Can't be bothered to check all those				   PyFile_WriteString() calls */				if (PyErr_Occurred())					err = -1;			}		}		if (err) {			/* Don't do anything else */		}		else if (PyExceptionClass_Check(exception)) {			PyObject* moduleName;			char* className = PyExceptionClass_Name(exception);			if (className != NULL) {				char *dot = strrchr(className, '.');				if (dot != NULL)					className = dot+1;			} 			moduleName = PyObject_GetAttrString(exception, "__module__");			if (moduleName == NULL)				err = PyFile_WriteString("<unknown>", f);			else {				char* modstr = PyString_AsString(moduleName);				if (modstr && strcmp(modstr, "exceptions"))				{					err = PyFile_WriteString(modstr, f);					err += PyFile_WriteString(".", f);				}				Py_DECREF(moduleName);			}			if (err == 0) {				if (className == NULL)				      err = PyFile_WriteString("<unknown>", f);				else				      err = PyFile_WriteString(className, f);			}		}		else			err = PyFile_WriteObject(exception, f, Py_PRINT_RAW);		if (err == 0 && (value != Py_None)) {			PyObject *s = PyObject_Str(value);			/* only print colon if the str() of the			   object is not the empty string			*/			if (s == NULL)				err = -1;			else if (!PyString_Check(s) ||				 PyString_GET_SIZE(s) != 0)				err = PyFile_WriteString(": ", f);			if (err == 0)			  err = PyFile_WriteObject(s, f, Py_PRINT_RAW);			Py_XDECREF(s);		}		if (err == 0)			err = PyFile_WriteString("\n", f);	}	Py_DECREF(value);	/* If an error happened here, don't show it.	   XXX This is wrong, but too many callers rely on this behavior. */	if (err != 0)		PyErr_Clear();} PyObject *PyRun_StringFlags(const char *str, int start, PyObject *globals,		  PyObject *locals, PyCompilerFlags *flags){	PyObject *ret = NULL;	mod_ty mod;	PyArena *arena = PyArena_New();	if (arena == NULL)		return NULL;		mod = PyParser_ASTFromString(str, "<string>", start, flags, arena);	if (mod != NULL)		ret = run_mod(mod, "<string>", globals, locals, flags, arena);	PyArena_Free(arena);	return ret;} PyObject *PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals,		  PyObject *locals, int closeit, PyCompilerFlags *flags){	PyObject *ret;	mod_ty mod;	PyArena *arena = PyArena_New();	if (arena == NULL)		return NULL;		mod = PyParser_ASTFromFile(fp, filename, start, 0, 0,				   flags, NULL, arena);	if (closeit)		fclose(fp);	if (mod == NULL) {		PyArena_Free(arena);		return NULL;	}	ret = run_mod(mod, filename, globals, locals, flags, arena);	PyArena_Free(arena);	return ret;} static PyObject *run_mod(mod_ty mod, const char *filename, PyObject *globals, PyObject *locals,	 PyCompilerFlags *flags, PyArena *arena){	PyCodeObject *co;	PyObject *v;	co = PyAST_Compile(mod, filename, flags, arena);	if (co == NULL)		return NULL;	v = PyEval_EvalCode(co, globals, locals);	Py_DECREF(co);	return v;} static PyObject *run_pyc_file(FILE *fp, const char *filename, PyObject *globals,	     PyObject *locals, PyCompilerFlags *flags){	PyCodeObject *co;	PyObject *v;	long magic;	long PyImport_GetMagicNumber(void); 	magic = PyMarshal_ReadLongFromFile(fp);	if (magic != PyImport_GetMagicNumber()) {		PyErr_SetString(PyExc_RuntimeError,			   "Bad magic number in .pyc file");		return NULL;	}	(void) PyMarshal_ReadLongFromFile(fp);	v = PyMarshal_ReadLastObjectFromFile(fp);	fclose(fp);	if (v == NULL || !PyCode_Check(v)) {		Py_XDECREF(v);		PyErr_SetString(PyExc_RuntimeError,			   "Bad code object in .pyc file");		return NULL;	}	co = (PyCodeObject *)v;	v = PyEval_EvalCode(co, globals, locals);	if (v && flags)		flags->cf_flags |= (co->co_flags & PyCF_MASK);	Py_DECREF(co);	return v;} PyObject *Py_CompileStringFlags(const char *str, const char *filename, int start,		      PyCompilerFlags *flags){	PyCodeObject *co;	mod_ty mod;	PyArena *arena = PyArena_New();	if (arena == NULL)		return NULL; 	mod = PyParser_ASTFromString(str, filename, start, flags, arena);	if (mod == NULL) {		PyArena_Free(arena);		return NULL;	}	if (flags && (flags->cf_flags & PyCF_ONLY_AST)) {		PyObject *result = PyAST_mod2obj(mod);		PyArena_Free(arena);		return result;	}	co = PyAST_Compile(mod, filename, flags, arena);	PyArena_Free(arena);	return (PyObject *)co;} struct symtable *Py_SymtableString(const char *str, const char *filename, int start){	struct symtable *st;	mod_ty mod;	PyArena *arena = PyArena_New();	if (arena == NULL)		return NULL; 	mod = PyParser_ASTFromString(str, filename, start, NULL, arena);	if (mod == NULL) {		PyArena_Free(arena);		return NULL;	}	st = PySymtable_Build(mod, filename, 0);	PyArena_Free(arena);	return st;} /* Preferred access to parser is through AST. */mod_tyPyParser_ASTFromString(const char *s, const char *filename, int start,		       PyCompilerFlags *flags, PyArena *arena){	mod_ty mod;	perrdetail err;	node *n = PyParser_ParseStringFlagsFilename(s, filename,					&_PyParser_Grammar, start, &err,					PARSER_FLAGS(flags));	if (n) {		mod = PyAST_FromNode(n, flags, filename, arena);		PyNode_Free(n);		return mod;	}	else {		err_input(&err);		return NULL;	}} mod_tyPyParser_ASTFromFile(FILE *fp, const char *filename, int start, char *ps1,		     char *ps2, PyCompilerFlags *flags, int *errcode,		     PyArena *arena){	mod_ty mod;	perrdetail err;	node *n = PyParser_ParseFileFlags(fp, filename, &_PyParser_Grammar,				start, ps1, ps2, &err, PARSER_FLAGS(flags));	if (n) {		mod = PyAST_FromNode(n, flags, filename, arena);		PyNode_Free(n);		return mod;	}	else {		err_input(&err);		if (errcode)			*errcode = err.error;		return NULL;	}} /* Simplified interface to parsefile -- return node or set exception */ node *PyParser_SimpleParseFileFlags(FILE *fp, const char *filename, int start, int flags){	perrdetail err;	node *n = PyParser_ParseFileFlags(fp, filename, &_PyParser_Grammar,					  start, NULL, NULL, &err, flags);	if (n == NULL)		err_input(&err); 	return n;} /* Simplified interface to parsestring -- return node or set exception */ node *PyParser_SimpleParseStringFlags(const char *str, int start, int flags){	perrdetail err;	node *n = PyParser_ParseStringFlags(str, &_PyParser_Grammar,					    start, &err, flags);	if (n == NULL)		err_input(&err);	return n;} node *PyParser_SimpleParseStringFlagsFilename(const char *str, const char *filename,					int start, int flags){	perrdetail err;	node *n = PyParser_ParseStringFlagsFilename(str, filename,				&_PyParser_Grammar, start, &err, flags);	if (n == NULL)		err_input(&err);	return n;} node *PyParser_SimpleParseStringFilename(const char *str, const char *filename, int start){	return PyParser_SimpleParseStringFlagsFilename(str, filename, start, 0);} /* May want to move a more generalized form of this to parsetok.c or   even parser modules. */ voidPyParser_SetError(perrdetail *err){	err_input(err);} /* Set the error appropriate to the given input error code (see errcode.h) */ static voiderr_input(perrdetail *err){	PyObject *v, *w, *errtype;	PyObject* u = NULL;	char *msg = NULL;	errtype = PyExc_SyntaxError;	switch (err->error) {	case E_SYNTAX:		errtype = PyExc_IndentationError;		if (err->expected == INDENT)			msg = "expected an indented block";		else if (err->token == INDENT)			msg = "unexpected indent";		else if (err->token == DEDENT)			msg = "unexpected unindent";		else {			errtype = PyExc_SyntaxError;			msg = "invalid syntax";		}		break;	case E_TOKEN:		msg = "invalid token";		break;	case E_EOFS:		msg = "EOF while scanning triple-quoted string";		break;	case E_EOLS:		msg = "EOL while scanning single-quoted string";		break;	case E_INTR:		if (!PyErr_Occurred())			PyErr_SetNone(PyExc_KeyboardInterrupt);		return;	case E_NOMEM:		PyErr_NoMemory();		return;	case E_EOF:		msg = "unexpected EOF while parsing";		break;	case E_TABSPACE:		errtype = PyExc_TabError;		msg = "inconsistent use of tabs and spaces in indentation";		break;	case E_OVERFLOW:		msg = "expression too long";		break;	case E_DEDENT:		errtype = PyExc_IndentationError;		msg = "unindent does not match any outer indentation level";

Lines 1001–1500 of 1857. Previous lines Load more