5 Various bits of information used by the interpreter are collected in
8 - exit(sts): raise SystemExit
10 - stdin, stdout, stderr: standard file objects
11 - modules: the table of modules (dictionary)
12 - path: module search path (list of strings)
13 - argv: script arguments (list of strings)
14 - ps1, ps2: optional primary and secondary prompts (strings)
18 #include "structseq.h"
20 #include "frameobject.h"
26 #define WIN32_LEAN_AND_MEAN
28 #endif /* MS_WINDOWS */
31 extern void *PyWin_DLLhModule;
32 /* A string loaded from the DLL at startup: */
33 extern const char *PyWin_DLLVersionString;
44 #ifdef HAVE_LANGINFO_H
50 PySys_GetObject(char *name)
52 PyThreadState *tstate = PyThreadState_GET();
53 PyObject *sd = tstate->interp->sysdict;
56 return PyDict_GetItemString(sd, name);
60 PySys_GetFile(char *name, FILE *def)
63 PyObject *v = PySys_GetObject(name);
64 if (v != NULL && PyFile_Check(v))
65 fp = PyFile_AsFile(v);
72 PySys_SetObject(char *name, PyObject *v)
74 PyThreadState *tstate = PyThreadState_GET();
75 PyObject *sd = tstate->interp->sysdict;
77 if (PyDict_GetItemString(sd, name) == NULL)
80 return PyDict_DelItemString(sd, name);
83 return PyDict_SetItemString(sd, name, v);
87 sys_displayhook(PyObject *self, PyObject *o)
90 PyInterpreterState *interp = PyThreadState_GET()->interp;
91 PyObject *modules = interp->modules;
92 PyObject *builtins = PyDict_GetItemString(modules, "__builtin__");
94 if (builtins == NULL) {
95 PyErr_SetString(PyExc_RuntimeError, "lost __builtin__");
99 /* Print value except if None */
100 /* After printing, also assign to '_' */
101 /* Before, set '_' to None to avoid recursion */
106 if (PyObject_SetAttrString(builtins, "_", Py_None) != 0)
108 if (Py_FlushLine() != 0)
110 outf = PySys_GetObject("stdout");
112 PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
115 if (PyFile_WriteObject(o, outf, 0) != 0)
117 PyFile_SoftSpace(outf, 1);
118 if (Py_FlushLine() != 0)
120 if (PyObject_SetAttrString(builtins, "_", o) != 0)
126 PyDoc_STRVAR(displayhook_doc,
127 "displayhook(object) -> None\n"
129 "Print an object to sys.stdout and also save it in __builtin__._\n"
133 sys_excepthook(PyObject* self, PyObject* args)
135 PyObject *exc, *value, *tb;
136 if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb))
138 PyErr_Display(exc, value, tb);
143 PyDoc_STRVAR(excepthook_doc,
144 "excepthook(exctype, value, traceback) -> None\n"
146 "Handle an exception by displaying it with a traceback on sys.stderr.\n"
150 sys_exc_info(PyObject *self, PyObject *noargs)
152 PyThreadState *tstate;
153 tstate = PyThreadState_GET();
154 return Py_BuildValue(
156 tstate->exc_type != NULL ? tstate->exc_type : Py_None,
157 tstate->exc_value != NULL ? tstate->exc_value : Py_None,
158 tstate->exc_traceback != NULL ?
159 tstate->exc_traceback : Py_None);
162 PyDoc_STRVAR(exc_info_doc,
163 "exc_info() -> (type, value, traceback)\n\
165 Return information about the most recent exception caught by an except\n\
166 clause in the current stack frame or in an older stack frame."
170 sys_exc_clear(PyObject *self, PyObject *noargs)
172 PyThreadState *tstate;
173 PyObject *tmp_type, *tmp_value, *tmp_tb;
175 if (PyErr_WarnPy3k("sys.exc_clear() not supported in 3.x; "
176 "use except clauses", 1) < 0)
179 tstate = PyThreadState_GET();
180 tmp_type = tstate->exc_type;
181 tmp_value = tstate->exc_value;
182 tmp_tb = tstate->exc_traceback;
183 tstate->exc_type = NULL;
184 tstate->exc_value = NULL;
185 tstate->exc_traceback = NULL;
186 Py_XDECREF(tmp_type);
187 Py_XDECREF(tmp_value);
189 /* For b/w compatibility */
190 PySys_SetObject("exc_type", Py_None);
191 PySys_SetObject("exc_value", Py_None);
192 PySys_SetObject("exc_traceback", Py_None);
197 PyDoc_STRVAR(exc_clear_doc,
198 "exc_clear() -> None\n\
200 Clear global information on the current exception. Subsequent calls to\n\
201 exc_info() will return (None,None,None) until another exception is raised\n\
202 in the current thread or the execution stack returns to a frame where\n\
203 another exception is being handled."
207 sys_exit(PyObject *self, PyObject *args)
209 PyObject *exit_code = 0;
210 if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code))
212 /* Raise SystemExit so callers may catch it or clean up. */
213 PyErr_SetObject(PyExc_SystemExit, exit_code);
217 PyDoc_STRVAR(exit_doc,
220 Exit the interpreter by raising SystemExit(status).\n\
221 If the status is omitted or None, it defaults to zero (i.e., success).\n\
222 If the status is numeric, it will be used as the system exit status.\n\
223 If it is another kind of object, it will be printed and the system\n\
224 exit status will be one (i.e., failure)."
227 #ifdef Py_USING_UNICODE
230 sys_getdefaultencoding(PyObject *self)
232 return PyString_FromString(PyUnicode_GetDefaultEncoding());
235 PyDoc_STRVAR(getdefaultencoding_doc,
236 "getdefaultencoding() -> string\n\
238 Return the current default string encoding used by the Unicode \n\
243 sys_setdefaultencoding(PyObject *self, PyObject *args)
246 if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding))
248 if (PyUnicode_SetDefaultEncoding(encoding))
254 PyDoc_STRVAR(setdefaultencoding_doc,
255 "setdefaultencoding(encoding)\n\
257 Set the current default string encoding used by the Unicode implementation."
261 sys_getfilesystemencoding(PyObject *self)
263 if (Py_FileSystemDefaultEncoding)
264 return PyString_FromString(Py_FileSystemDefaultEncoding);
269 PyDoc_STRVAR(getfilesystemencoding_doc,
270 "getfilesystemencoding() -> string\n\
272 Return the encoding used to convert Unicode filenames in\n\
273 operating system filenames."
279 * Cached interned string objects used for calling the profile and
280 * trace functions. Initialized by trace_init().
282 static PyObject *whatstrings[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
287 static char *whatnames[7] = {"call", "exception", "line", "return",
288 "c_call", "c_exception", "c_return"};
291 for (i = 0; i < 7; ++i) {
292 if (whatstrings[i] == NULL) {
293 name = PyString_InternFromString(whatnames[i]);
296 whatstrings[i] = name;
304 call_trampoline(PyThreadState *tstate, PyObject* callback,
305 PyFrameObject *frame, int what, PyObject *arg)
307 PyObject *args = PyTuple_New(3);
314 whatstr = whatstrings[what];
319 PyTuple_SET_ITEM(args, 0, (PyObject *)frame);
320 PyTuple_SET_ITEM(args, 1, whatstr);
321 PyTuple_SET_ITEM(args, 2, arg);
323 /* call the Python-level function */
324 PyFrame_FastToLocals(frame);
325 result = PyEval_CallObject(callback, args);
326 PyFrame_LocalsToFast(frame, 1);
328 PyTraceBack_Here(frame);
336 profile_trampoline(PyObject *self, PyFrameObject *frame,
337 int what, PyObject *arg)
339 PyThreadState *tstate = frame->f_tstate;
344 result = call_trampoline(tstate, self, frame, what, arg);
345 if (result == NULL) {
346 PyEval_SetProfile(NULL, NULL);
354 trace_trampoline(PyObject *self, PyFrameObject *frame,
355 int what, PyObject *arg)
357 PyThreadState *tstate = frame->f_tstate;
361 if (what == PyTrace_CALL)
364 callback = frame->f_trace;
365 if (callback == NULL)
367 result = call_trampoline(tstate, callback, frame, what, arg);
368 if (result == NULL) {
369 PyEval_SetTrace(NULL, NULL);
370 Py_XDECREF(frame->f_trace);
371 frame->f_trace = NULL;
374 if (result != Py_None) {
375 PyObject *temp = frame->f_trace;
376 frame->f_trace = NULL;
378 frame->f_trace = result;
387 sys_settrace(PyObject *self, PyObject *args)
389 if (trace_init() == -1)
392 PyEval_SetTrace(NULL, NULL);
394 PyEval_SetTrace(trace_trampoline, args);
399 PyDoc_STRVAR(settrace_doc,
400 "settrace(function)\n\
402 Set the global debug tracing function. It will be called on each\n\
403 function call. See the debugger chapter in the library manual."
407 sys_gettrace(PyObject *self, PyObject *args)
409 PyThreadState *tstate = PyThreadState_GET();
410 PyObject *temp = tstate->c_traceobj;
418 PyDoc_STRVAR(gettrace_doc,
421 Return the global debug tracing function set with sys.settrace.\n\
422 See the debugger chapter in the library manual."
426 sys_setprofile(PyObject *self, PyObject *args)
428 if (trace_init() == -1)
431 PyEval_SetProfile(NULL, NULL);
433 PyEval_SetProfile(profile_trampoline, args);
438 PyDoc_STRVAR(setprofile_doc,
439 "setprofile(function)\n\
441 Set the profiling function. It will be called on each function call\n\
442 and return. See the profiler chapter in the library manual."
446 sys_getprofile(PyObject *self, PyObject *args)
448 PyThreadState *tstate = PyThreadState_GET();
449 PyObject *temp = tstate->c_profileobj;
457 PyDoc_STRVAR(getprofile_doc,
460 Return the profiling function set with sys.setprofile.\n\
461 See the profiler chapter in the library manual."
465 sys_setcheckinterval(PyObject *self, PyObject *args)
467 if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval))
469 _Py_Ticker = _Py_CheckInterval;
474 PyDoc_STRVAR(setcheckinterval_doc,
475 "setcheckinterval(n)\n\
477 Tell the Python interpreter to check for asynchronous events every\n\
478 n instructions. This also affects how often thread switches occur."
482 sys_getcheckinterval(PyObject *self, PyObject *args)
484 return PyInt_FromLong(_Py_CheckInterval);
487 PyDoc_STRVAR(getcheckinterval_doc,
488 "getcheckinterval() -> current check interval; see setcheckinterval()."
493 sys_settscdump(PyObject *self, PyObject *args)
496 PyThreadState *tstate = PyThreadState_Get();
498 if (!PyArg_ParseTuple(args, "i:settscdump", &bool))
501 tstate->interp->tscdump = 1;
503 tstate->interp->tscdump = 0;
509 PyDoc_STRVAR(settscdump_doc,
512 If true, tell the Python interpreter to dump VM measurements to\n\
513 stderr. If false, turn off dump. The measurements are based on the\n\
514 processor's time-stamp counter."
519 sys_setrecursionlimit(PyObject *self, PyObject *args)
522 if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit))
524 if (new_limit <= 0) {
525 PyErr_SetString(PyExc_ValueError,
526 "recursion limit must be positive");
529 Py_SetRecursionLimit(new_limit);
534 PyDoc_STRVAR(setrecursionlimit_doc,
535 "setrecursionlimit(n)\n\
537 Set the maximum depth of the Python interpreter stack to n. This\n\
538 limit prevents infinite recursion from causing an overflow of the C\n\
539 stack and crashing Python. The highest possible limit is platform-\n\
544 sys_getrecursionlimit(PyObject *self)
546 return PyInt_FromLong(Py_GetRecursionLimit());
549 PyDoc_STRVAR(getrecursionlimit_doc,
550 "getrecursionlimit()\n\
552 Return the current value of the recursion limit, the maximum depth\n\
553 of the Python interpreter stack. This limit prevents infinite\n\
554 recursion from causing an overflow of the C stack and crashing Python."
558 PyDoc_STRVAR(getwindowsversion_doc,
559 "getwindowsversion()\n\
561 Return information about the running version of Windows as a named tuple.\n\
562 The members are named: major, minor, build, platform, service_pack,\n\
563 service_pack_major, service_pack_minor, suite_mask, and product_type. For\n\
564 backward compatibility, only the first 5 items are available by indexing.\n\
565 All elements are numbers, except service_pack which is a string. Platform\n\
566 may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP/Vista/7,\n\
567 3 for Windows CE. Product_type may be 1 for a workstation, 2 for a domain\n\
568 controller, 3 for a server."
571 static PyTypeObject WindowsVersionType = {0, 0, 0, 0, 0, 0};
573 static PyStructSequence_Field windows_version_fields[] = {
574 {"major", "Major version number"},
575 {"minor", "Minor version number"},
576 {"build", "Build number"},
577 {"platform", "Operating system platform"},
578 {"service_pack", "Latest Service Pack installed on the system"},
579 {"service_pack_major", "Service Pack major version number"},
580 {"service_pack_minor", "Service Pack minor version number"},
581 {"suite_mask", "Bit mask identifying available product suites"},
582 {"product_type", "System product type"},
586 static PyStructSequence_Desc windows_version_desc = {
587 "sys.getwindowsversion", /* name */
588 getwindowsversion_doc, /* doc */
589 windows_version_fields, /* fields */
590 5 /* For backward compatibility,
591 only the first 5 items are accessible
592 via indexing, the rest are name only */
596 sys_getwindowsversion(PyObject *self)
601 ver.dwOSVersionInfoSize = sizeof(ver);
602 if (!GetVersionEx((OSVERSIONINFO*) &ver))
603 return PyErr_SetFromWindowsErr(0);
605 version = PyStructSequence_New(&WindowsVersionType);
609 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMajorVersion));
610 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMinorVersion));
611 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwBuildNumber));
612 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwPlatformId));
613 PyStructSequence_SET_ITEM(version, pos++, PyString_FromString(ver.szCSDVersion));
614 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMajor));
615 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMinor));
616 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wSuiteMask));
617 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wProductType));
622 #endif /* MS_WINDOWS */
626 sys_setdlopenflags(PyObject *self, PyObject *args)
629 PyThreadState *tstate = PyThreadState_GET();
630 if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val))
634 tstate->interp->dlopenflags = new_val;
639 PyDoc_STRVAR(setdlopenflags_doc,
640 "setdlopenflags(n) -> None\n\
642 Set the flags used by the interpreter for dlopen calls, such as when the\n\
643 interpreter loads extension modules. Among other things, this will enable\n\
644 a lazy resolving of symbols when importing a module, if called as\n\
645 sys.setdlopenflags(0). To share symbols across extension modules, call as\n\
646 sys.setdlopenflags(ctypes.RTLD_GLOBAL). Symbolic names for the flag modules\n\
647 can be either found in the ctypes module, or in the DLFCN module. If DLFCN\n\
648 is not available, it can be generated from /usr/include/dlfcn.h using the\n\
652 sys_getdlopenflags(PyObject *self, PyObject *args)
654 PyThreadState *tstate = PyThreadState_GET();
657 return PyInt_FromLong(tstate->interp->dlopenflags);
660 PyDoc_STRVAR(getdlopenflags_doc,
661 "getdlopenflags() -> int\n\
663 Return the current value of the flags that are used for dlopen calls.\n\
664 The flag constants are defined in the ctypes and DLFCN modules.");
666 #endif /* HAVE_DLOPEN */
669 /* Link with -lmalloc (or -lmpc) on an SGI */
673 sys_mdebug(PyObject *self, PyObject *args)
676 if (!PyArg_ParseTuple(args, "i:mdebug", &flag))
678 mallopt(M_DEBUG, flag);
682 #endif /* USE_MALLOPT */
685 sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds)
687 PyObject *res = NULL;
688 static PyObject *str__sizeof__ = NULL, *gc_head_size = NULL;
689 static char *kwlist[] = {"object", "default", 0};
690 PyObject *o, *dflt = NULL;
692 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof",
696 /* Initialize static variable for GC head size */
697 if (gc_head_size == NULL) {
698 gc_head_size = PyInt_FromSsize_t(sizeof(PyGC_Head));
699 if (gc_head_size == NULL)
703 /* Make sure the type is initialized. float gets initialized late */
704 if (PyType_Ready(Py_TYPE(o)) < 0)
707 /* Instance of old-style class */
708 if (PyInstance_Check(o))
709 res = PyInt_FromSsize_t(PyInstance_Type.tp_basicsize);
710 /* all other objects */
712 PyObject *method = _PyObject_LookupSpecial(o, "__sizeof__",
714 if (method == NULL) {
715 if (!PyErr_Occurred())
716 PyErr_Format(PyExc_TypeError,
717 "Type %.100s doesn't define __sizeof__",
718 Py_TYPE(o)->tp_name);
721 res = PyObject_CallFunctionObjArgs(method, NULL);
726 /* Has a default value been given? */
727 if ((res == NULL) && (dflt != NULL) &&
728 PyErr_ExceptionMatches(PyExc_TypeError))
734 else if (res == NULL)
737 /* add gc_head size */
738 if (PyObject_IS_GC(o)) {
740 res = PyNumber_Add(tmp, gc_head_size);
746 PyDoc_STRVAR(getsizeof_doc,
747 "getsizeof(object, default) -> int\n\
749 Return the size of object in bytes.");
752 sys_getrefcount(PyObject *self, PyObject *arg)
754 return PyInt_FromSsize_t(arg->ob_refcnt);
759 sys_gettotalrefcount(PyObject *self)
761 return PyInt_FromSsize_t(_Py_GetRefTotal());
763 #endif /* Py_REF_DEBUG */
765 PyDoc_STRVAR(getrefcount_doc,
766 "getrefcount(object) -> integer\n\
768 Return the reference count of object. The count returned is generally\n\
769 one higher than you might expect, because it includes the (temporary)\n\
770 reference as an argument to getrefcount()."
775 sys_getcounts(PyObject *self)
777 extern PyObject *get_counts(void);
783 PyDoc_STRVAR(getframe_doc,
784 "_getframe([depth]) -> frameobject\n\
786 Return a frame object from the call stack. If optional integer depth is\n\
787 given, return the frame object that many calls below the top of the stack.\n\
788 If that is deeper than the call stack, ValueError is raised. The default\n\
789 for depth is zero, returning the frame at the top of the call stack.\n\
791 This function should be used for internal and specialized\n\
796 sys_getframe(PyObject *self, PyObject *args)
798 PyFrameObject *f = PyThreadState_GET()->frame;
801 if (!PyArg_ParseTuple(args, "|i:_getframe", &depth))
804 while (depth > 0 && f != NULL) {
809 PyErr_SetString(PyExc_ValueError,
810 "call stack is not deep enough");
817 PyDoc_STRVAR(current_frames_doc,
818 "_current_frames() -> dictionary\n\
820 Return a dictionary mapping each current thread T's thread id to T's\n\
821 current stack frame.\n\
823 This function should be used for specialized purposes only."
827 sys_current_frames(PyObject *self, PyObject *noargs)
829 return _PyThread_CurrentFrames();
832 PyDoc_STRVAR(call_tracing_doc,
833 "call_tracing(func, args) -> object\n\
835 Call func(*args), while tracing is enabled. The tracing state is\n\
836 saved, and restored afterwards. This is intended to be called from\n\
837 a debugger from a checkpoint, to recursively debug some other code."
841 sys_call_tracing(PyObject *self, PyObject *args)
843 PyObject *func, *funcargs;
844 if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs))
846 return _PyEval_CallTracing(func, funcargs);
849 PyDoc_STRVAR(callstats_doc,
850 "callstats() -> tuple of integers\n\
852 Return a tuple of function call statistics, if CALL_PROFILE was defined\n\
853 when Python was built. Otherwise, return None.\n\
855 When enabled, this function returns detailed, implementation-specific\n\
856 details about the number of function calls executed. The return value is\n\
857 a 11-tuple where the entries in the tuple are counts of:\n\
858 0. all function calls\n\
859 1. calls to PyFunction_Type objects\n\
860 2. PyFunction calls that do not create an argument tuple\n\
861 3. PyFunction calls that do not create an argument tuple\n\
862 and bypass PyEval_EvalCodeEx()\n\
864 5. PyMethod calls on bound methods\n\
866 7. PyCFunction calls\n\
867 8. generator calls\n\
868 9. All other calls\n\
869 10. Number of stack pops performed by call_function()"
877 /* Defined in objects.c because it uses static globals if that file */
878 extern PyObject *_Py_GetObjects(PyObject *, PyObject *);
881 #ifdef DYNAMIC_EXECUTION_PROFILE
882 /* Defined in ceval.c because it uses static globals if that file */
883 extern PyObject *_Py_GetDXProfile(PyObject *, PyObject *);
891 sys_clear_type_cache(PyObject* self, PyObject* args)
897 PyDoc_STRVAR(sys_clear_type_cache__doc__,
898 "_clear_type_cache() -> None\n\
899 Clear the internal type lookup cache.");
902 static PyMethodDef sys_methods[] = {
903 /* Might as well keep this in alphabetic order */
904 {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS,
906 {"_clear_type_cache", sys_clear_type_cache, METH_NOARGS,
907 sys_clear_type_cache__doc__},
908 {"_current_frames", sys_current_frames, METH_NOARGS,
910 {"displayhook", sys_displayhook, METH_O, displayhook_doc},
911 {"exc_info", sys_exc_info, METH_NOARGS, exc_info_doc},
912 {"exc_clear", sys_exc_clear, METH_NOARGS, exc_clear_doc},
913 {"excepthook", sys_excepthook, METH_VARARGS, excepthook_doc},
914 {"exit", sys_exit, METH_VARARGS, exit_doc},
915 #ifdef Py_USING_UNICODE
916 {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding,
917 METH_NOARGS, getdefaultencoding_doc},
920 {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS,
924 {"getcounts", (PyCFunction)sys_getcounts, METH_NOARGS},
926 #ifdef DYNAMIC_EXECUTION_PROFILE
927 {"getdxp", _Py_GetDXProfile, METH_VARARGS},
929 #ifdef Py_USING_UNICODE
930 {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding,
931 METH_NOARGS, getfilesystemencoding_doc},
934 {"getobjects", _Py_GetObjects, METH_VARARGS},
937 {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS},
939 {"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
940 {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS,
941 getrecursionlimit_doc},
942 {"getsizeof", (PyCFunction)sys_getsizeof,
943 METH_VARARGS | METH_KEYWORDS, getsizeof_doc},
944 {"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
946 {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
947 getwindowsversion_doc},
948 #endif /* MS_WINDOWS */
950 {"mdebug", sys_mdebug, METH_VARARGS},
952 #ifdef Py_USING_UNICODE
953 {"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS,
954 setdefaultencoding_doc},
956 {"setcheckinterval", sys_setcheckinterval, METH_VARARGS,
957 setcheckinterval_doc},
958 {"getcheckinterval", sys_getcheckinterval, METH_NOARGS,
959 getcheckinterval_doc},
961 {"setdlopenflags", sys_setdlopenflags, METH_VARARGS,
964 {"setprofile", sys_setprofile, METH_O, setprofile_doc},
965 {"getprofile", sys_getprofile, METH_NOARGS, getprofile_doc},
966 {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS,
967 setrecursionlimit_doc},
969 {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc},
971 {"settrace", sys_settrace, METH_O, settrace_doc},
972 {"gettrace", sys_gettrace, METH_NOARGS, gettrace_doc},
973 {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},
974 {NULL, NULL} /* sentinel */
978 list_builtin_module_names(void)
980 PyObject *list = PyList_New(0);
984 for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
985 PyObject *name = PyString_FromString(
986 PyImport_Inittab[i].name);
989 PyList_Append(list, name);
992 if (PyList_Sort(list) != 0) {
997 PyObject *v = PyList_AsTuple(list);
1004 static PyObject *warnoptions = NULL;
1007 PySys_ResetWarnOptions(void)
1009 if (warnoptions == NULL || !PyList_Check(warnoptions))
1011 PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
1015 PySys_AddWarnOption(char *s)
1019 if (warnoptions == NULL || !PyList_Check(warnoptions)) {
1020 Py_XDECREF(warnoptions);
1021 warnoptions = PyList_New(0);
1022 if (warnoptions == NULL)
1025 str = PyString_FromString(s);
1027 PyList_Append(warnoptions, str);
1033 PySys_HasWarnOptions(void)
1035 return (warnoptions != NULL && (PyList_Size(warnoptions) > 0)) ? 1 : 0;
1038 /* XXX This doc string is too long to be a single string literal in VC++ 5.0.
1039 Two literals concatenated works just fine. If you have a K&R compiler
1040 or other abomination that however *does* understand longer strings,
1041 get rid of the !!! comment in the middle and the quotes that surround it. */
1042 PyDoc_VAR(sys_doc) =
1044 "This module provides access to some objects used or maintained by the\n\
1045 interpreter and to functions that interact strongly with the interpreter.\n\
1049 argv -- command line arguments; argv[0] is the script pathname if known\n\
1050 path -- module search path; path[0] is the script directory, else ''\n\
1051 modules -- dictionary of loaded modules\n\
1053 displayhook -- called to show results in an interactive session\n\
1054 excepthook -- called to handle any uncaught exception other than SystemExit\n\
1055 To customize printing in an interactive session or to install a custom\n\
1056 top-level exception handler, assign other functions to replace these.\n\
1058 exitfunc -- if sys.exitfunc exists, this routine is called when Python exits\n\
1059 Assigning to sys.exitfunc is deprecated; use the atexit module instead.\n\
1061 stdin -- standard input file object; used by raw_input() and input()\n\
1062 stdout -- standard output file object; used by the print statement\n\
1063 stderr -- standard error object; used for error messages\n\
1064 By assigning other file objects (or objects that behave like files)\n\
1065 to these, it is possible to redirect all of the interpreter's I/O.\n\
1067 last_type -- type of last uncaught exception\n\
1068 last_value -- value of last uncaught exception\n\
1069 last_traceback -- traceback of last uncaught exception\n\
1070 These three are only available in an interactive session after a\n\
1071 traceback has been printed.\n\
1073 exc_type -- type of exception currently being handled\n\
1074 exc_value -- value of exception currently being handled\n\
1075 exc_traceback -- traceback of exception currently being handled\n\
1076 The function exc_info() should be used instead of these three,\n\
1077 because it is thread-safe.\n\
1080 /* concatenating string here */
1085 float_info -- a dict with information about the float inplementation.\n\
1086 long_info -- a struct sequence with information about the long implementation.\n\
1087 maxint -- the largest supported integer (the smallest is -maxint-1)\n\
1088 maxsize -- the largest supported length of containers.\n\
1089 maxunicode -- the largest supported character\n\
1090 builtin_module_names -- tuple of module names built into this interpreter\n\
1091 version -- the version of this interpreter as a string\n\
1092 version_info -- version information as a named tuple\n\
1093 hexversion -- version information encoded as a single integer\n\
1094 copyright -- copyright notice pertaining to this interpreter\n\
1095 platform -- platform identifier\n\
1096 executable -- absolute path of the executable binary of the Python interpreter\n\
1097 prefix -- prefix used to find the Python library\n\
1098 exec_prefix -- prefix used to find the machine-specific Python library\n\
1099 float_repr_style -- string indicating the style of repr() output for floats\n\
1103 /* concatenating string here */
1105 "dllhandle -- [Windows only] integer handle of the Python DLL\n\
1106 winver -- [Windows only] version number of the Python DLL\n\
1109 #endif /* MS_WINDOWS */
1111 "__stdin__ -- the original stdin; don't touch!\n\
1112 __stdout__ -- the original stdout; don't touch!\n\
1113 __stderr__ -- the original stderr; don't touch!\n\
1114 __displayhook__ -- the original displayhook; don't touch!\n\
1115 __excepthook__ -- the original excepthook; don't touch!\n\
1119 displayhook() -- print an object to the screen, and save it in __builtin__._\n\
1120 excepthook() -- print an exception and its traceback to sys.stderr\n\
1121 exc_info() -- return thread-safe information about the current exception\n\
1122 exc_clear() -- clear the exception state for the current thread\n\
1123 exit() -- exit the interpreter by raising SystemExit\n\
1124 getdlopenflags() -- returns flags to be used for dlopen() calls\n\
1125 getprofile() -- get the global profiling function\n\
1126 getrefcount() -- return the reference count for an object (plus one :-)\n\
1127 getrecursionlimit() -- return the max recursion depth for the interpreter\n\
1128 getsizeof() -- return the size of an object in bytes\n\
1129 gettrace() -- get the global debug tracing function\n\
1130 setcheckinterval() -- control how often the interpreter checks for events\n\
1131 setdlopenflags() -- set the flags to be used for dlopen() calls\n\
1132 setprofile() -- set the global profiling function\n\
1133 setrecursionlimit() -- set the max recursion depth for the interpreter\n\
1134 settrace() -- set the global debug tracing function\n\
1137 /* end of sys_doc */ ;
1140 _check_and_flush (FILE *stream)
1142 int prev_fail = ferror (stream);
1143 return fflush (stream) || prev_fail ? EOF : 0;
1146 /* Subversion branch and revision management */
1147 static int svn_initialized;
1148 static char patchlevel_revision[50]; /* Just the number */
1149 static char branch[50];
1150 static char shortbranch[50];
1151 static const char *svn_revision;
1154 svnversion_init(void)
1156 if (svn_initialized)
1158 svn_initialized = 1;
1159 *patchlevel_revision = '\0';
1161 strcpy(shortbranch, "unknown");
1166 /* Return svnversion output if available.
1167 Else return Revision of patchlevel.h if on branch.
1168 Else return empty string */
1170 Py_SubversionRevision()
1173 return svn_revision;
1177 Py_SubversionShortBranch()
1184 PyDoc_STRVAR(flags__doc__,
1187 Flags provided through command line arguments or environment vars.");
1189 static PyTypeObject FlagsType = {0, 0, 0, 0, 0, 0};
1191 static PyStructSequence_Field flags_fields[] = {
1193 {"py3k_warning", "-3"},
1194 {"division_warning", "-Q"},
1195 {"division_new", "-Qnew"},
1197 {"interactive", "-i"},
1198 {"optimize", "-O or -OO"},
1199 {"dont_write_bytecode", "-B"},
1200 {"no_user_site", "-s"},
1202 {"ignore_environment", "-E"},
1203 {"tabcheck", "-t or -tt"},
1206 {"riscos_wimp", "???"},
1208 /* {"unbuffered", "-u"}, */
1210 /* {"skip_first", "-x"}, */
1211 {"bytes_warning", "-b"},
1212 {"hash_randomization", "-R"},
1216 static PyStructSequence_Desc flags_desc = {
1217 "sys.flags", /* name */
1218 flags__doc__, /* doc */
1219 flags_fields, /* fields */
1233 seq = PyStructSequence_New(&FlagsType);
1237 #define SetFlag(flag) \
1238 PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag))
1240 SetFlag(Py_DebugFlag);
1241 SetFlag(Py_Py3kWarningFlag);
1242 SetFlag(Py_DivisionWarningFlag);
1243 SetFlag(_Py_QnewFlag);
1244 SetFlag(Py_InspectFlag);
1245 SetFlag(Py_InteractiveFlag);
1246 SetFlag(Py_OptimizeFlag);
1247 SetFlag(Py_DontWriteBytecodeFlag);
1248 SetFlag(Py_NoUserSiteDirectory);
1249 SetFlag(Py_NoSiteFlag);
1250 SetFlag(Py_IgnoreEnvironmentFlag);
1251 SetFlag(Py_TabcheckFlag);
1252 SetFlag(Py_VerboseFlag);
1254 SetFlag(Py_RISCOSWimpFlag);
1256 /* SetFlag(saw_unbuffered_flag); */
1257 SetFlag(Py_UnicodeFlag);
1258 /* SetFlag(skipfirstline); */
1259 SetFlag(Py_BytesWarningFlag);
1260 SetFlag(Py_HashRandomizationFlag);
1263 if (PyErr_Occurred()) {
1269 PyDoc_STRVAR(version_info__doc__,
1270 "sys.version_info\n\
1272 Version information as a named tuple.");
1274 static PyTypeObject VersionInfoType = {0, 0, 0, 0, 0, 0};
1276 static PyStructSequence_Field version_info_fields[] = {
1277 {"major", "Major release number"},
1278 {"minor", "Minor release number"},
1279 {"micro", "Patch release number"},
1280 {"releaselevel", "'alpha', 'beta', 'candidate', or 'release'"},
1281 {"serial", "Serial release number"},
1285 static PyStructSequence_Desc version_info_desc = {
1286 "sys.version_info", /* name */
1287 version_info__doc__, /* doc */
1288 version_info_fields, /* fields */
1293 make_version_info(void)
1295 PyObject *version_info;
1299 version_info = PyStructSequence_New(&VersionInfoType);
1300 if (version_info == NULL) {
1305 * These release level checks are mutually exclusive and cover
1306 * the field, so don't get too fancy with the pre-processor!
1308 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
1310 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
1312 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
1314 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
1318 #define SetIntItem(flag) \
1319 PyStructSequence_SET_ITEM(version_info, pos++, PyInt_FromLong(flag))
1320 #define SetStrItem(flag) \
1321 PyStructSequence_SET_ITEM(version_info, pos++, PyString_FromString(flag))
1323 SetIntItem(PY_MAJOR_VERSION);
1324 SetIntItem(PY_MINOR_VERSION);
1325 SetIntItem(PY_MICRO_VERSION);
1327 SetIntItem(PY_RELEASE_SERIAL);
1331 if (PyErr_Occurred()) {
1332 Py_CLEAR(version_info);
1335 return version_info;
1341 PyObject *m, *v, *sysdict;
1342 PyObject *sysin, *sysout, *syserr;
1345 m = Py_InitModule3("sys", sys_methods, sys_doc);
1348 sysdict = PyModule_GetDict(m);
1349 #define SET_SYS_FROM_STRING(key, value) \
1352 PyDict_SetItemString(sysdict, key, v); \
1355 /* Check that stdin is not a directory
1356 Using shell redirection, you can redirect stdin to a directory,
1357 crashing the Python interpreter. Catch this common mistake here
1358 and output a useful error message. Note that under MS Windows,
1359 the shell already prevents that. */
1360 #if !defined(MS_WINDOWS)
1363 if (fstat(fileno(stdin), &sb) == 0 &&
1364 S_ISDIR(sb.st_mode)) {
1365 /* There's nothing more we can do. */
1366 /* Py_FatalError() will core dump, so just exit. */
1367 PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
1373 /* Closing the standard FILE* if sys.std* goes aways causes problems
1374 * for embedded Python usages. Closing them when somebody explicitly
1375 * invokes .close() might be possible, but the FAQ promises they get
1376 * never closed. However, we still need to get write errors when
1377 * writing fails (e.g. because stdout is redirected), so we flush the
1378 * streams and check for errors before the file objects are deleted.
1379 * On OS X, fflush()ing stdin causes an error, so we exempt stdin
1380 * from that procedure.
1382 sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL);
1383 sysout = PyFile_FromFile(stdout, "<stdout>", "w", _check_and_flush);
1384 syserr = PyFile_FromFile(stderr, "<stderr>", "w", _check_and_flush);
1385 if (PyErr_Occurred())
1388 PyDict_SetItemString(sysdict, "stdin", sysin);
1389 PyDict_SetItemString(sysdict, "stdout", sysout);
1390 PyDict_SetItemString(sysdict, "stderr", syserr);
1391 /* Make backup copies for cleanup */
1392 PyDict_SetItemString(sysdict, "__stdin__", sysin);
1393 PyDict_SetItemString(sysdict, "__stdout__", sysout);
1394 PyDict_SetItemString(sysdict, "__stderr__", syserr);
1395 PyDict_SetItemString(sysdict, "__displayhook__",
1396 PyDict_GetItemString(sysdict, "displayhook"));
1397 PyDict_SetItemString(sysdict, "__excepthook__",
1398 PyDict_GetItemString(sysdict, "excepthook"));
1403 SET_SYS_FROM_STRING("version",
1404 PyString_FromString(Py_GetVersion()));
1405 SET_SYS_FROM_STRING("hexversion",
1406 PyInt_FromLong(PY_VERSION_HEX));
1408 SET_SYS_FROM_STRING("subversion",
1409 Py_BuildValue("(ssz)", "CPython", branch,
1411 SET_SYS_FROM_STRING("_mercurial",
1412 Py_BuildValue("(szz)", "CPython", _Py_hgidentifier(),
1414 SET_SYS_FROM_STRING("dont_write_bytecode",
1415 PyBool_FromLong(Py_DontWriteBytecodeFlag));
1416 SET_SYS_FROM_STRING("api_version",
1417 PyInt_FromLong(PYTHON_API_VERSION));
1418 SET_SYS_FROM_STRING("copyright",
1419 PyString_FromString(Py_GetCopyright()));
1420 SET_SYS_FROM_STRING("platform",
1421 PyString_FromString(Py_GetPlatform()));
1422 SET_SYS_FROM_STRING("executable",
1423 PyString_FromString(Py_GetProgramFullPath()));
1424 SET_SYS_FROM_STRING("prefix",
1425 PyString_FromString(Py_GetPrefix()));
1426 SET_SYS_FROM_STRING("exec_prefix",
1427 PyString_FromString(Py_GetExecPrefix()));
1428 SET_SYS_FROM_STRING("maxsize",
1429 PyInt_FromSsize_t(PY_SSIZE_T_MAX));
1430 SET_SYS_FROM_STRING("maxint",
1431 PyInt_FromLong(PyInt_GetMax()));
1432 SET_SYS_FROM_STRING("py3kwarning",
1433 PyBool_FromLong(Py_Py3kWarningFlag));
1434 SET_SYS_FROM_STRING("float_info",
1436 SET_SYS_FROM_STRING("long_info",
1438 #ifdef Py_USING_UNICODE
1439 SET_SYS_FROM_STRING("maxunicode",
1440 PyInt_FromLong(PyUnicode_GetMax()));
1442 SET_SYS_FROM_STRING("builtin_module_names",
1443 list_builtin_module_names());
1445 /* Assumes that longs are at least 2 bytes long.
1447 unsigned long number = 1;
1450 s = (char *) &number;
1455 SET_SYS_FROM_STRING("byteorder",
1456 PyString_FromString(value));
1459 SET_SYS_FROM_STRING("dllhandle",
1460 PyLong_FromVoidPtr(PyWin_DLLhModule));
1461 SET_SYS_FROM_STRING("winver",
1462 PyString_FromString(PyWin_DLLVersionString));
1464 if (warnoptions == NULL) {
1465 warnoptions = PyList_New(0);
1468 Py_INCREF(warnoptions);
1470 if (warnoptions != NULL) {
1471 PyDict_SetItemString(sysdict, "warnoptions", warnoptions);
1475 if (VersionInfoType.tp_name == 0)
1476 PyStructSequence_InitType(&VersionInfoType, &version_info_desc);
1477 SET_SYS_FROM_STRING("version_info", make_version_info());
1478 /* prevent user from creating new instances */
1479 VersionInfoType.tp_init = NULL;
1480 VersionInfoType.tp_new = NULL;
1483 if (FlagsType.tp_name == 0)
1484 PyStructSequence_InitType(&FlagsType, &flags_desc);
1485 SET_SYS_FROM_STRING("flags", make_flags());
1486 /* prevent user from creating new instances */
1487 FlagsType.tp_init = NULL;
1488 FlagsType.tp_new = NULL;
1491 #if defined(MS_WINDOWS)
1492 /* getwindowsversion */
1493 if (WindowsVersionType.tp_name == 0)
1494 PyStructSequence_InitType(&WindowsVersionType, &windows_version_desc);
1495 /* prevent user from creating new instances */
1496 WindowsVersionType.tp_init = NULL;
1497 WindowsVersionType.tp_new = NULL;
1500 /* float repr style: 0.03 (short) vs 0.029999999999999999 (legacy) */
1501 #ifndef PY_NO_SHORT_FLOAT_REPR
1502 SET_SYS_FROM_STRING("float_repr_style",
1503 PyString_FromString("short"));
1505 SET_SYS_FROM_STRING("float_repr_style",
1506 PyString_FromString("legacy"));
1509 #undef SET_SYS_FROM_STRING
1510 if (PyErr_Occurred())
1516 makepathobject(char *path, int delim)
1524 while ((p = strchr(p, delim)) != NULL) {
1531 for (i = 0; ; i++) {
1532 p = strchr(path, delim);
1534 p = strchr(path, '\0'); /* End of string */
1535 w = PyString_FromStringAndSize(path, (Py_ssize_t) (p - path));
1540 PyList_SetItem(v, i, w);
1549 PySys_SetPath(char *path)
1552 if ((v = makepathobject(path, DELIM)) == NULL)
1553 Py_FatalError("can't create sys.path");
1554 if (PySys_SetObject("path", v) != 0)
1555 Py_FatalError("can't assign sys.path");
1560 makeargvobject(int argc, char **argv)
1563 if (argc <= 0 || argv == NULL) {
1564 /* Ensure at least one (empty) argument is seen */
1565 static char *empty_argv[1] = {""};
1569 av = PyList_New(argc);
1572 for (i = 0; i < argc; i++) {
1576 /* argv[0] is the script pathname if known */
1578 char* fn = decc$translate_vms(argv[0]);
1579 if ((fn == (char *)0) || fn == (char *)-1)
1580 v = PyString_FromString(argv[0]);
1582 v = PyString_FromString(
1583 decc$translate_vms(argv[0]));
1585 v = PyString_FromString(argv[i]);
1587 PyObject *v = PyString_FromString(argv[i]);
1594 PyList_SetItem(av, i, v);
1601 PySys_SetArgvEx(int argc, char **argv, int updatepath)
1603 #if defined(HAVE_REALPATH)
1604 char fullpath[MAXPATHLEN];
1605 #elif defined(MS_WINDOWS) && !defined(MS_WINCE)
1606 char fullpath[MAX_PATH];
1608 PyObject *av = makeargvobject(argc, argv);
1609 PyObject *path = PySys_GetObject("path");
1611 Py_FatalError("no mem for sys.argv");
1612 if (PySys_SetObject("argv", av) != 0)
1613 Py_FatalError("can't assign sys.argv");
1614 if (updatepath && path != NULL) {
1615 char *argv0 = argv[0];
1619 #ifdef HAVE_READLINK
1620 char link[MAXPATHLEN+1];
1621 char argv0copy[2*MAXPATHLEN+1];
1623 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0)
1624 nr = readlink(argv0, link, MAXPATHLEN);
1626 /* It's a symlink */
1629 argv0 = link; /* Link to absolute path */
1630 else if (strchr(link, SEP) == NULL)
1631 ; /* Link without path */
1633 /* Must join(dirname(argv0), link) */
1634 char *q = strrchr(argv0, SEP);
1636 argv0 = link; /* argv0 without path */
1638 /* Must make a copy */
1639 strcpy(argv0copy, argv0);
1640 q = strrchr(argv0copy, SEP);
1646 #endif /* HAVE_READLINK */
1647 #if SEP == '\\' /* Special case for MS filename syntax */
1648 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
1650 #if defined(MS_WINDOWS) && !defined(MS_WINCE)
1651 /* This code here replaces the first element in argv with the full
1652 path that it represents. Under CE, there are no relative paths so
1653 the argument must be the full path anyway. */
1655 if (GetFullPathName(argv0,
1662 p = strrchr(argv0, SEP);
1663 /* Test for alternate separator */
1664 q = strrchr(p ? p : argv0, '/');
1669 if (n > 1 && p[-1] != ':')
1670 n--; /* Drop trailing separator */
1673 #else /* All other filename syntaxes */
1674 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
1675 #if defined(HAVE_REALPATH)
1676 if (realpath(argv0, fullpath)) {
1680 p = strrchr(argv0, SEP);
1685 #else /* don't include trailing separator */
1688 #if SEP == '/' /* Special case for Unix filename syntax */
1690 n--; /* Drop trailing separator */
1693 #endif /* All others */
1694 a = PyString_FromStringAndSize(argv0, n);
1696 Py_FatalError("no mem for sys.path insertion");
1697 if (PyList_Insert(path, 0, a) < 0)
1698 Py_FatalError("sys.path.insert(0) failed");
1705 PySys_SetArgv(int argc, char **argv)
1707 PySys_SetArgvEx(argc, argv, 1);
1711 /* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
1712 Adapted from code submitted by Just van Rossum.
1714 PySys_WriteStdout(format, ...)
1715 PySys_WriteStderr(format, ...)
1717 The first function writes to sys.stdout; the second to sys.stderr. When
1718 there is a problem, they write to the real (C level) stdout or stderr;
1719 no exceptions are raised.
1721 Both take a printf-style format string as their first argument followed
1722 by a variable length argument list determined by the format string.
1726 The format should limit the total size of the formatted output string to
1727 1000 bytes. In particular, this means that no unrestricted "%s" formats
1728 should occur; these should be limited using "%.<N>s where <N> is a
1729 decimal number calculated so that <N> plus the maximum size of other
1730 formatted text does not exceed 1000 bytes. Also watch out for "%f",
1731 which can print hundreds of digits for very large numbers.
1736 mywrite(char *name, FILE *fp, const char *format, va_list va)
1739 PyObject *error_type, *error_value, *error_traceback;
1741 PyErr_Fetch(&error_type, &error_value, &error_traceback);
1742 file = PySys_GetObject(name);
1743 if (file == NULL || PyFile_AsFile(file) == fp)
1744 vfprintf(fp, format, va);
1747 const int written = PyOS_vsnprintf(buffer, sizeof(buffer),
1749 if (PyFile_WriteString(buffer, file) != 0) {
1753 if (written < 0 || (size_t)written >= sizeof(buffer)) {
1754 const char *truncated = "... truncated";
1755 if (PyFile_WriteString(truncated, file) != 0) {
1757 fputs(truncated, fp);
1761 PyErr_Restore(error_type, error_value, error_traceback);
1765 PySys_WriteStdout(const char *format, ...)
1769 va_start(va, format);
1770 mywrite("stdout", stdout, format, va);
1775 PySys_WriteStderr(const char *format, ...)
1779 va_start(va, format);
1780 mywrite("stderr", stderr, format, va);