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
))
473 PyDoc_STRVAR(setcheckinterval_doc
,
474 "setcheckinterval(n)\n\
476 Tell the Python interpreter to check for asynchronous events every\n\
477 n instructions. This also affects how often thread switches occur."
481 sys_getcheckinterval(PyObject
*self
, PyObject
*args
)
483 return PyInt_FromLong(_Py_CheckInterval
);
486 PyDoc_STRVAR(getcheckinterval_doc
,
487 "getcheckinterval() -> current check interval; see setcheckinterval()."
492 sys_settscdump(PyObject
*self
, PyObject
*args
)
495 PyThreadState
*tstate
= PyThreadState_Get();
497 if (!PyArg_ParseTuple(args
, "i:settscdump", &bool))
500 tstate
->interp
->tscdump
= 1;
502 tstate
->interp
->tscdump
= 0;
508 PyDoc_STRVAR(settscdump_doc
,
511 If true, tell the Python interpreter to dump VM measurements to\n\
512 stderr. If false, turn off dump. The measurements are based on the\n\
513 processor's time-stamp counter."
518 sys_setrecursionlimit(PyObject
*self
, PyObject
*args
)
521 if (!PyArg_ParseTuple(args
, "i:setrecursionlimit", &new_limit
))
523 if (new_limit
<= 0) {
524 PyErr_SetString(PyExc_ValueError
,
525 "recursion limit must be positive");
528 Py_SetRecursionLimit(new_limit
);
533 PyDoc_STRVAR(setrecursionlimit_doc
,
534 "setrecursionlimit(n)\n\
536 Set the maximum depth of the Python interpreter stack to n. This\n\
537 limit prevents infinite recursion from causing an overflow of the C\n\
538 stack and crashing Python. The highest possible limit is platform-\n\
543 sys_getrecursionlimit(PyObject
*self
)
545 return PyInt_FromLong(Py_GetRecursionLimit());
548 PyDoc_STRVAR(getrecursionlimit_doc
,
549 "getrecursionlimit()\n\
551 Return the current value of the recursion limit, the maximum depth\n\
552 of the Python interpreter stack. This limit prevents infinite\n\
553 recursion from causing an overflow of the C stack and crashing Python."
557 PyDoc_STRVAR(getwindowsversion_doc
,
558 "getwindowsversion()\n\
560 Return information about the running version of Windows.\n\
561 The result is a tuple of (major, minor, build, platform, text)\n\
562 All elements are numbers, except text which is a string.\n\
563 Platform may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP\n\
568 sys_getwindowsversion(PyObject
*self
)
571 ver
.dwOSVersionInfoSize
= sizeof(ver
);
572 if (!GetVersionEx(&ver
))
573 return PyErr_SetFromWindowsErr(0);
574 return Py_BuildValue("HHHHs",
582 #endif /* MS_WINDOWS */
586 sys_setdlopenflags(PyObject
*self
, PyObject
*args
)
589 PyThreadState
*tstate
= PyThreadState_GET();
590 if (!PyArg_ParseTuple(args
, "i:setdlopenflags", &new_val
))
594 tstate
->interp
->dlopenflags
= new_val
;
599 PyDoc_STRVAR(setdlopenflags_doc
,
600 "setdlopenflags(n) -> None\n\
602 Set the flags used by the interpreter for dlopen calls, such as when the\n\
603 interpreter loads extension modules. Among other things, this will enable\n\
604 a lazy resolving of symbols when importing a module, if called as\n\
605 sys.setdlopenflags(0). To share symbols across extension modules, call as\n\
606 sys.setdlopenflags(ctypes.RTLD_GLOBAL). Symbolic names for the flag modules\n\
607 can be either found in the ctypes module, or in the DLFCN module. If DLFCN\n\
608 is not available, it can be generated from /usr/include/dlfcn.h using the\n\
612 sys_getdlopenflags(PyObject
*self
, PyObject
*args
)
614 PyThreadState
*tstate
= PyThreadState_GET();
617 return PyInt_FromLong(tstate
->interp
->dlopenflags
);
620 PyDoc_STRVAR(getdlopenflags_doc
,
621 "getdlopenflags() -> int\n\
623 Return the current value of the flags that are used for dlopen calls.\n\
624 The flag constants are defined in the ctypes and DLFCN modules.");
626 #endif /* HAVE_DLOPEN */
629 /* Link with -lmalloc (or -lmpc) on an SGI */
633 sys_mdebug(PyObject
*self
, PyObject
*args
)
636 if (!PyArg_ParseTuple(args
, "i:mdebug", &flag
))
638 mallopt(M_DEBUG
, flag
);
642 #endif /* USE_MALLOPT */
645 sys_getsizeof(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
647 PyObject
*res
= NULL
;
648 static PyObject
*str__sizeof__
= NULL
, *gc_head_size
= NULL
;
649 static char *kwlist
[] = {"object", "default", 0};
650 PyObject
*o
, *dflt
= NULL
;
652 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "O|O:getsizeof",
656 /* Initialize static variable for GC head size */
657 if (gc_head_size
== NULL
) {
658 gc_head_size
= PyInt_FromSsize_t(sizeof(PyGC_Head
));
659 if (gc_head_size
== NULL
)
663 /* Make sure the type is initialized. float gets initialized late */
664 if (PyType_Ready(Py_TYPE(o
)) < 0)
667 /* Instance of old-style class */
668 if (PyInstance_Check(o
))
669 res
= PyInt_FromSsize_t(PyInstance_Type
.tp_basicsize
);
670 /* all other objects */
672 PyObject
*method
= _PyObject_LookupSpecial(o
, "__sizeof__",
674 if (method
== NULL
) {
675 if (!PyErr_Occurred())
676 PyErr_Format(PyExc_TypeError
,
677 "Type %.100s doesn't define __sizeof__",
678 Py_TYPE(o
)->tp_name
);
681 res
= PyObject_CallFunctionObjArgs(method
, NULL
);
686 /* Has a default value been given? */
687 if ((res
== NULL
) && (dflt
!= NULL
) &&
688 PyErr_ExceptionMatches(PyExc_TypeError
))
694 else if (res
== NULL
)
697 /* add gc_head size */
698 if (PyObject_IS_GC(o
)) {
700 res
= PyNumber_Add(tmp
, gc_head_size
);
706 PyDoc_STRVAR(getsizeof_doc
,
707 "getsizeof(object, default) -> int\n\
709 Return the size of object in bytes.");
712 sys_getrefcount(PyObject
*self
, PyObject
*arg
)
714 return PyInt_FromSsize_t(arg
->ob_refcnt
);
719 sys_gettotalrefcount(PyObject
*self
)
721 return PyInt_FromSsize_t(_Py_GetRefTotal());
723 #endif /* Py_REF_DEBUG */
725 PyDoc_STRVAR(getrefcount_doc
,
726 "getrefcount(object) -> integer\n\
728 Return the reference count of object. The count returned is generally\n\
729 one higher than you might expect, because it includes the (temporary)\n\
730 reference as an argument to getrefcount()."
735 sys_getcounts(PyObject
*self
)
737 extern PyObject
*get_counts(void);
743 PyDoc_STRVAR(getframe_doc
,
744 "_getframe([depth]) -> frameobject\n\
746 Return a frame object from the call stack. If optional integer depth is\n\
747 given, return the frame object that many calls below the top of the stack.\n\
748 If that is deeper than the call stack, ValueError is raised. The default\n\
749 for depth is zero, returning the frame at the top of the call stack.\n\
751 This function should be used for internal and specialized\n\
756 sys_getframe(PyObject
*self
, PyObject
*args
)
758 PyFrameObject
*f
= PyThreadState_GET()->frame
;
761 if (!PyArg_ParseTuple(args
, "|i:_getframe", &depth
))
764 while (depth
> 0 && f
!= NULL
) {
769 PyErr_SetString(PyExc_ValueError
,
770 "call stack is not deep enough");
777 PyDoc_STRVAR(current_frames_doc
,
778 "_current_frames() -> dictionary\n\
780 Return a dictionary mapping each current thread T's thread id to T's\n\
781 current stack frame.\n\
783 This function should be used for specialized purposes only."
787 sys_current_frames(PyObject
*self
, PyObject
*noargs
)
789 return _PyThread_CurrentFrames();
792 PyDoc_STRVAR(call_tracing_doc
,
793 "call_tracing(func, args) -> object\n\
795 Call func(*args), while tracing is enabled. The tracing state is\n\
796 saved, and restored afterwards. This is intended to be called from\n\
797 a debugger from a checkpoint, to recursively debug some other code."
801 sys_call_tracing(PyObject
*self
, PyObject
*args
)
803 PyObject
*func
, *funcargs
;
804 if (!PyArg_UnpackTuple(args
, "call_tracing", 2, 2, &func
, &funcargs
))
806 return _PyEval_CallTracing(func
, funcargs
);
809 PyDoc_STRVAR(callstats_doc
,
810 "callstats() -> tuple of integers\n\
812 Return a tuple of function call statistics, if CALL_PROFILE was defined\n\
813 when Python was built. Otherwise, return None.\n\
815 When enabled, this function returns detailed, implementation-specific\n\
816 details about the number of function calls executed. The return value is\n\
817 a 11-tuple where the entries in the tuple are counts of:\n\
818 0. all function calls\n\
819 1. calls to PyFunction_Type objects\n\
820 2. PyFunction calls that do not create an argument tuple\n\
821 3. PyFunction calls that do not create an argument tuple\n\
822 and bypass PyEval_EvalCodeEx()\n\
824 5. PyMethod calls on bound methods\n\
826 7. PyCFunction calls\n\
827 8. generator calls\n\
828 9. All other calls\n\
829 10. Number of stack pops performed by call_function()"
837 /* Defined in objects.c because it uses static globals if that file */
838 extern PyObject
*_Py_GetObjects(PyObject
*, PyObject
*);
841 #ifdef DYNAMIC_EXECUTION_PROFILE
842 /* Defined in ceval.c because it uses static globals if that file */
843 extern PyObject
*_Py_GetDXProfile(PyObject
*, PyObject
*);
851 sys_clear_type_cache(PyObject
* self
, PyObject
* args
)
857 PyDoc_STRVAR(sys_clear_type_cache__doc__
,
858 "_clear_type_cache() -> None\n\
859 Clear the internal type lookup cache.");
862 static PyMethodDef sys_methods
[] = {
863 /* Might as well keep this in alphabetic order */
864 {"callstats", (PyCFunction
)PyEval_GetCallStats
, METH_NOARGS
,
866 {"_clear_type_cache", sys_clear_type_cache
, METH_NOARGS
,
867 sys_clear_type_cache__doc__
},
868 {"_current_frames", sys_current_frames
, METH_NOARGS
,
870 {"displayhook", sys_displayhook
, METH_O
, displayhook_doc
},
871 {"exc_info", sys_exc_info
, METH_NOARGS
, exc_info_doc
},
872 {"exc_clear", sys_exc_clear
, METH_NOARGS
, exc_clear_doc
},
873 {"excepthook", sys_excepthook
, METH_VARARGS
, excepthook_doc
},
874 {"exit", sys_exit
, METH_VARARGS
, exit_doc
},
875 #ifdef Py_USING_UNICODE
876 {"getdefaultencoding", (PyCFunction
)sys_getdefaultencoding
,
877 METH_NOARGS
, getdefaultencoding_doc
},
880 {"getdlopenflags", (PyCFunction
)sys_getdlopenflags
, METH_NOARGS
,
884 {"getcounts", (PyCFunction
)sys_getcounts
, METH_NOARGS
},
886 #ifdef DYNAMIC_EXECUTION_PROFILE
887 {"getdxp", _Py_GetDXProfile
, METH_VARARGS
},
889 #ifdef Py_USING_UNICODE
890 {"getfilesystemencoding", (PyCFunction
)sys_getfilesystemencoding
,
891 METH_NOARGS
, getfilesystemencoding_doc
},
894 {"getobjects", _Py_GetObjects
, METH_VARARGS
},
897 {"gettotalrefcount", (PyCFunction
)sys_gettotalrefcount
, METH_NOARGS
},
899 {"getrefcount", (PyCFunction
)sys_getrefcount
, METH_O
, getrefcount_doc
},
900 {"getrecursionlimit", (PyCFunction
)sys_getrecursionlimit
, METH_NOARGS
,
901 getrecursionlimit_doc
},
902 {"getsizeof", (PyCFunction
)sys_getsizeof
,
903 METH_VARARGS
| METH_KEYWORDS
, getsizeof_doc
},
904 {"_getframe", sys_getframe
, METH_VARARGS
, getframe_doc
},
906 {"getwindowsversion", (PyCFunction
)sys_getwindowsversion
, METH_NOARGS
,
907 getwindowsversion_doc
},
908 #endif /* MS_WINDOWS */
910 {"mdebug", sys_mdebug
, METH_VARARGS
},
912 #ifdef Py_USING_UNICODE
913 {"setdefaultencoding", sys_setdefaultencoding
, METH_VARARGS
,
914 setdefaultencoding_doc
},
916 {"setcheckinterval", sys_setcheckinterval
, METH_VARARGS
,
917 setcheckinterval_doc
},
918 {"getcheckinterval", sys_getcheckinterval
, METH_NOARGS
,
919 getcheckinterval_doc
},
921 {"setdlopenflags", sys_setdlopenflags
, METH_VARARGS
,
924 {"setprofile", sys_setprofile
, METH_O
, setprofile_doc
},
925 {"getprofile", sys_getprofile
, METH_NOARGS
, getprofile_doc
},
926 {"setrecursionlimit", sys_setrecursionlimit
, METH_VARARGS
,
927 setrecursionlimit_doc
},
929 {"settscdump", sys_settscdump
, METH_VARARGS
, settscdump_doc
},
931 {"settrace", sys_settrace
, METH_O
, settrace_doc
},
932 {"gettrace", sys_gettrace
, METH_NOARGS
, gettrace_doc
},
933 {"call_tracing", sys_call_tracing
, METH_VARARGS
, call_tracing_doc
},
934 {NULL
, NULL
} /* sentinel */
938 list_builtin_module_names(void)
940 PyObject
*list
= PyList_New(0);
944 for (i
= 0; PyImport_Inittab
[i
].name
!= NULL
; i
++) {
945 PyObject
*name
= PyString_FromString(
946 PyImport_Inittab
[i
].name
);
949 PyList_Append(list
, name
);
952 if (PyList_Sort(list
) != 0) {
957 PyObject
*v
= PyList_AsTuple(list
);
964 static PyObject
*warnoptions
= NULL
;
967 PySys_ResetWarnOptions(void)
969 if (warnoptions
== NULL
|| !PyList_Check(warnoptions
))
971 PyList_SetSlice(warnoptions
, 0, PyList_GET_SIZE(warnoptions
), NULL
);
975 PySys_AddWarnOption(char *s
)
979 if (warnoptions
== NULL
|| !PyList_Check(warnoptions
)) {
980 Py_XDECREF(warnoptions
);
981 warnoptions
= PyList_New(0);
982 if (warnoptions
== NULL
)
985 str
= PyString_FromString(s
);
987 PyList_Append(warnoptions
, str
);
993 PySys_HasWarnOptions(void)
995 return (warnoptions
!= NULL
&& (PyList_Size(warnoptions
) > 0)) ? 1 : 0;
998 /* XXX This doc string is too long to be a single string literal in VC++ 5.0.
999 Two literals concatenated works just fine. If you have a K&R compiler
1000 or other abomination that however *does* understand longer strings,
1001 get rid of the !!! comment in the middle and the quotes that surround it. */
1002 PyDoc_VAR(sys_doc
) =
1004 "This module provides access to some objects used or maintained by the\n\
1005 interpreter and to functions that interact strongly with the interpreter.\n\
1009 argv -- command line arguments; argv[0] is the script pathname if known\n\
1010 path -- module search path; path[0] is the script directory, else ''\n\
1011 modules -- dictionary of loaded modules\n\
1013 displayhook -- called to show results in an interactive session\n\
1014 excepthook -- called to handle any uncaught exception other than SystemExit\n\
1015 To customize printing in an interactive session or to install a custom\n\
1016 top-level exception handler, assign other functions to replace these.\n\
1018 exitfunc -- if sys.exitfunc exists, this routine is called when Python exits\n\
1019 Assigning to sys.exitfunc is deprecated; use the atexit module instead.\n\
1021 stdin -- standard input file object; used by raw_input() and input()\n\
1022 stdout -- standard output file object; used by the print statement\n\
1023 stderr -- standard error object; used for error messages\n\
1024 By assigning other file objects (or objects that behave like files)\n\
1025 to these, it is possible to redirect all of the interpreter's I/O.\n\
1027 last_type -- type of last uncaught exception\n\
1028 last_value -- value of last uncaught exception\n\
1029 last_traceback -- traceback of last uncaught exception\n\
1030 These three are only available in an interactive session after a\n\
1031 traceback has been printed.\n\
1033 exc_type -- type of exception currently being handled\n\
1034 exc_value -- value of exception currently being handled\n\
1035 exc_traceback -- traceback of exception currently being handled\n\
1036 The function exc_info() should be used instead of these three,\n\
1037 because it is thread-safe.\n\
1040 /* concatenating string here */
1045 float_info -- a dict with information about the float inplementation.\n\
1046 long_info -- a struct sequence with information about the long implementation.\n\
1047 maxint -- the largest supported integer (the smallest is -maxint-1)\n\
1048 maxsize -- the largest supported length of containers.\n\
1049 maxunicode -- the largest supported character\n\
1050 builtin_module_names -- tuple of module names built into this interpreter\n\
1051 version -- the version of this interpreter as a string\n\
1052 version_info -- version information as a named tuple\n\
1053 hexversion -- version information encoded as a single integer\n\
1054 copyright -- copyright notice pertaining to this interpreter\n\
1055 platform -- platform identifier\n\
1056 executable -- pathname of this Python interpreter\n\
1057 prefix -- prefix used to find the Python library\n\
1058 exec_prefix -- prefix used to find the machine-specific Python library\n\
1062 /* concatenating string here */
1064 "dllhandle -- [Windows only] integer handle of the Python DLL\n\
1065 winver -- [Windows only] version number of the Python DLL\n\
1068 #endif /* MS_WINDOWS */
1070 "__stdin__ -- the original stdin; don't touch!\n\
1071 __stdout__ -- the original stdout; don't touch!\n\
1072 __stderr__ -- the original stderr; don't touch!\n\
1073 __displayhook__ -- the original displayhook; don't touch!\n\
1074 __excepthook__ -- the original excepthook; don't touch!\n\
1078 displayhook() -- print an object to the screen, and save it in __builtin__._\n\
1079 excepthook() -- print an exception and its traceback to sys.stderr\n\
1080 exc_info() -- return thread-safe information about the current exception\n\
1081 exc_clear() -- clear the exception state for the current thread\n\
1082 exit() -- exit the interpreter by raising SystemExit\n\
1083 getdlopenflags() -- returns flags to be used for dlopen() calls\n\
1084 getprofile() -- get the global profiling function\n\
1085 getrefcount() -- return the reference count for an object (plus one :-)\n\
1086 getrecursionlimit() -- return the max recursion depth for the interpreter\n\
1087 getsizeof() -- return the size of an object in bytes\n\
1088 gettrace() -- get the global debug tracing function\n\
1089 setcheckinterval() -- control how often the interpreter checks for events\n\
1090 setdlopenflags() -- set the flags to be used for dlopen() calls\n\
1091 setprofile() -- set the global profiling function\n\
1092 setrecursionlimit() -- set the max recursion depth for the interpreter\n\
1093 settrace() -- set the global debug tracing function\n\
1096 /* end of sys_doc */ ;
1099 _check_and_flush (FILE *stream
)
1101 int prev_fail
= ferror (stream
);
1102 return fflush (stream
) || prev_fail
? EOF
: 0;
1105 /* Subversion branch and revision management */
1106 static const char _patchlevel_revision
[] = PY_PATCHLEVEL_REVISION
;
1107 static const char headurl
[] = "$HeadURL$";
1108 static int svn_initialized
;
1109 static char patchlevel_revision
[50]; /* Just the number */
1110 static char branch
[50];
1111 static char shortbranch
[50];
1112 static const char *svn_revision
;
1115 svnversion_init(void)
1117 const char *python
, *br_start
, *br_end
, *br_end2
, *svnversion
;
1121 if (svn_initialized
)
1124 python
= strstr(headurl
, "/python/");
1126 /* XXX quick hack to get bzr working */
1127 *patchlevel_revision
= '\0';
1129 strcpy(shortbranch
, "unknown");
1132 /* Py_FatalError("subversion keywords missing"); */
1135 br_start
= python
+ 8;
1136 br_end
= strchr(br_start
, '/');
1139 /* Works even for trunk,
1140 as we are in trunk/Python/sysmodule.c */
1141 br_end2
= strchr(br_end
+1, '/');
1143 istag
= strncmp(br_start
, "tags", 4) == 0;
1144 if (strncmp(br_start
, "trunk", 5) == 0) {
1145 strcpy(branch
, "trunk");
1146 strcpy(shortbranch
, "trunk");
1149 else if (istag
|| strncmp(br_start
, "branches", 8) == 0) {
1150 len
= br_end2
- br_start
;
1151 strncpy(branch
, br_start
, len
);
1154 len
= br_end2
- (br_end
+ 1);
1155 strncpy(shortbranch
, br_end
+ 1, len
);
1156 shortbranch
[len
] = '\0';
1159 Py_FatalError("bad HeadURL");
1164 svnversion
= _Py_svnversion();
1165 if (strcmp(svnversion
, "Unversioned directory") != 0 && strcmp(svnversion
, "exported") != 0)
1166 svn_revision
= svnversion
;
1168 len
= strlen(_patchlevel_revision
);
1170 assert(len
< (sizeof(patchlevel_revision
) + 13));
1171 strncpy(patchlevel_revision
, _patchlevel_revision
+ 11,
1173 patchlevel_revision
[len
- 13] = '\0';
1174 svn_revision
= patchlevel_revision
;
1179 svn_initialized
= 1;
1182 /* Return svnversion output if available.
1183 Else return Revision of patchlevel.h if on branch.
1184 Else return empty string */
1186 Py_SubversionRevision()
1189 return svn_revision
;
1193 Py_SubversionShortBranch()
1200 PyDoc_STRVAR(flags__doc__
,
1203 Flags provided through command line arguments or environment vars.");
1205 static PyTypeObject FlagsType
= {0, 0, 0, 0, 0, 0};
1207 static PyStructSequence_Field flags_fields
[] = {
1209 {"py3k_warning", "-3"},
1210 {"division_warning", "-Q"},
1211 {"division_new", "-Qnew"},
1213 {"interactive", "-i"},
1214 {"optimize", "-O or -OO"},
1215 {"dont_write_bytecode", "-B"},
1216 {"no_user_site", "-s"},
1218 {"ignore_environment", "-E"},
1219 {"tabcheck", "-t or -tt"},
1222 {"riscos_wimp", "???"},
1224 /* {"unbuffered", "-u"}, */
1226 /* {"skip_first", "-x"}, */
1227 {"bytes_warning", "-b"},
1231 static PyStructSequence_Desc flags_desc
= {
1232 "sys.flags", /* name */
1233 flags__doc__
, /* doc */
1234 flags_fields
, /* fields */
1248 seq
= PyStructSequence_New(&FlagsType
);
1252 #define SetFlag(flag) \
1253 PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag))
1255 SetFlag(Py_DebugFlag
);
1256 SetFlag(Py_Py3kWarningFlag
);
1257 SetFlag(Py_DivisionWarningFlag
);
1258 SetFlag(_Py_QnewFlag
);
1259 SetFlag(Py_InspectFlag
);
1260 SetFlag(Py_InteractiveFlag
);
1261 SetFlag(Py_OptimizeFlag
);
1262 SetFlag(Py_DontWriteBytecodeFlag
);
1263 SetFlag(Py_NoUserSiteDirectory
);
1264 SetFlag(Py_NoSiteFlag
);
1265 SetFlag(Py_IgnoreEnvironmentFlag
);
1266 SetFlag(Py_TabcheckFlag
);
1267 SetFlag(Py_VerboseFlag
);
1269 SetFlag(Py_RISCOSWimpFlag
);
1271 /* SetFlag(saw_unbuffered_flag); */
1272 SetFlag(Py_UnicodeFlag
);
1273 /* SetFlag(skipfirstline); */
1274 SetFlag(Py_BytesWarningFlag
);
1277 if (PyErr_Occurred()) {
1283 PyDoc_STRVAR(version_info__doc__
,
1284 "sys.version_info\n\
1286 Version information as a named tuple.");
1288 static PyTypeObject VersionInfoType
= {0, 0, 0, 0, 0, 0};
1290 static PyStructSequence_Field version_info_fields
[] = {
1291 {"major", "Major release number"},
1292 {"minor", "Minor release number"},
1293 {"micro", "Patch release number"},
1294 {"releaselevel", "'alpha', 'beta', 'candidate', or 'release'"},
1295 {"serial", "Serial release number"},
1299 static PyStructSequence_Desc version_info_desc
= {
1300 "sys.version_info", /* name */
1301 version_info__doc__
, /* doc */
1302 version_info_fields
, /* fields */
1307 make_version_info(void)
1309 PyObject
*version_info
;
1313 version_info
= PyStructSequence_New(&VersionInfoType
);
1314 if (version_info
== NULL
) {
1319 * These release level checks are mutually exclusive and cover
1320 * the field, so don't get too fancy with the pre-processor!
1322 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
1324 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
1326 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
1328 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
1332 #define SetIntItem(flag) \
1333 PyStructSequence_SET_ITEM(version_info, pos++, PyInt_FromLong(flag))
1334 #define SetStrItem(flag) \
1335 PyStructSequence_SET_ITEM(version_info, pos++, PyString_FromString(flag))
1337 SetIntItem(PY_MAJOR_VERSION
);
1338 SetIntItem(PY_MINOR_VERSION
);
1339 SetIntItem(PY_MICRO_VERSION
);
1341 SetIntItem(PY_RELEASE_SERIAL
);
1345 if (PyErr_Occurred()) {
1346 Py_CLEAR(version_info
);
1349 return version_info
;
1355 PyObject
*m
, *v
, *sysdict
;
1356 PyObject
*sysin
, *sysout
, *syserr
;
1359 m
= Py_InitModule3("sys", sys_methods
, sys_doc
);
1362 sysdict
= PyModule_GetDict(m
);
1363 #define SET_SYS_FROM_STRING(key, value) \
1366 PyDict_SetItemString(sysdict, key, v); \
1369 /* Check that stdin is not a directory
1370 Using shell redirection, you can redirect stdin to a directory,
1371 crashing the Python interpreter. Catch this common mistake here
1372 and output a useful error message. Note that under MS Windows,
1373 the shell already prevents that. */
1374 #if !defined(MS_WINDOWS)
1377 if (fstat(fileno(stdin
), &sb
) == 0 &&
1378 S_ISDIR(sb
.st_mode
)) {
1379 /* There's nothing more we can do. */
1380 /* Py_FatalError() will core dump, so just exit. */
1381 PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
1387 /* Closing the standard FILE* if sys.std* goes aways causes problems
1388 * for embedded Python usages. Closing them when somebody explicitly
1389 * invokes .close() might be possible, but the FAQ promises they get
1390 * never closed. However, we still need to get write errors when
1391 * writing fails (e.g. because stdout is redirected), so we flush the
1392 * streams and check for errors before the file objects are deleted.
1393 * On OS X, fflush()ing stdin causes an error, so we exempt stdin
1394 * from that procedure.
1396 sysin
= PyFile_FromFile(stdin
, "<stdin>", "r", NULL
);
1397 sysout
= PyFile_FromFile(stdout
, "<stdout>", "w", _check_and_flush
);
1398 syserr
= PyFile_FromFile(stderr
, "<stderr>", "w", _check_and_flush
);
1399 if (PyErr_Occurred())
1402 PyDict_SetItemString(sysdict
, "stdin", sysin
);
1403 PyDict_SetItemString(sysdict
, "stdout", sysout
);
1404 PyDict_SetItemString(sysdict
, "stderr", syserr
);
1405 /* Make backup copies for cleanup */
1406 PyDict_SetItemString(sysdict
, "__stdin__", sysin
);
1407 PyDict_SetItemString(sysdict
, "__stdout__", sysout
);
1408 PyDict_SetItemString(sysdict
, "__stderr__", syserr
);
1409 PyDict_SetItemString(sysdict
, "__displayhook__",
1410 PyDict_GetItemString(sysdict
, "displayhook"));
1411 PyDict_SetItemString(sysdict
, "__excepthook__",
1412 PyDict_GetItemString(sysdict
, "excepthook"));
1417 SET_SYS_FROM_STRING("version",
1418 PyString_FromString(Py_GetVersion()));
1419 SET_SYS_FROM_STRING("hexversion",
1420 PyInt_FromLong(PY_VERSION_HEX
));
1422 SET_SYS_FROM_STRING("subversion",
1423 Py_BuildValue("(ssz)", "CPython", branch
,
1425 SET_SYS_FROM_STRING("dont_write_bytecode",
1426 PyBool_FromLong(Py_DontWriteBytecodeFlag
));
1427 SET_SYS_FROM_STRING("api_version",
1428 PyInt_FromLong(PYTHON_API_VERSION
));
1429 SET_SYS_FROM_STRING("copyright",
1430 PyString_FromString(Py_GetCopyright()));
1431 SET_SYS_FROM_STRING("platform",
1432 PyString_FromString(Py_GetPlatform()));
1433 SET_SYS_FROM_STRING("executable",
1434 PyString_FromString(Py_GetProgramFullPath()));
1435 SET_SYS_FROM_STRING("prefix",
1436 PyString_FromString(Py_GetPrefix()));
1437 SET_SYS_FROM_STRING("exec_prefix",
1438 PyString_FromString(Py_GetExecPrefix()));
1439 SET_SYS_FROM_STRING("maxsize",
1440 PyInt_FromSsize_t(PY_SSIZE_T_MAX
));
1441 SET_SYS_FROM_STRING("maxint",
1442 PyInt_FromLong(PyInt_GetMax()));
1443 SET_SYS_FROM_STRING("py3kwarning",
1444 PyBool_FromLong(Py_Py3kWarningFlag
));
1445 SET_SYS_FROM_STRING("float_info",
1447 SET_SYS_FROM_STRING("long_info",
1449 #ifdef Py_USING_UNICODE
1450 SET_SYS_FROM_STRING("maxunicode",
1451 PyInt_FromLong(PyUnicode_GetMax()));
1453 SET_SYS_FROM_STRING("builtin_module_names",
1454 list_builtin_module_names());
1456 /* Assumes that longs are at least 2 bytes long.
1458 unsigned long number
= 1;
1461 s
= (char *) &number
;
1466 SET_SYS_FROM_STRING("byteorder",
1467 PyString_FromString(value
));
1470 SET_SYS_FROM_STRING("dllhandle",
1471 PyLong_FromVoidPtr(PyWin_DLLhModule
));
1472 SET_SYS_FROM_STRING("winver",
1473 PyString_FromString(PyWin_DLLVersionString
));
1475 if (warnoptions
== NULL
) {
1476 warnoptions
= PyList_New(0);
1479 Py_INCREF(warnoptions
);
1481 if (warnoptions
!= NULL
) {
1482 PyDict_SetItemString(sysdict
, "warnoptions", warnoptions
);
1486 if (VersionInfoType
.tp_name
== 0)
1487 PyStructSequence_InitType(&VersionInfoType
, &version_info_desc
);
1488 SET_SYS_FROM_STRING("version_info", make_version_info());
1489 /* prevent user from creating new instances */
1490 VersionInfoType
.tp_init
= NULL
;
1491 VersionInfoType
.tp_new
= NULL
;
1494 if (FlagsType
.tp_name
== 0)
1495 PyStructSequence_InitType(&FlagsType
, &flags_desc
);
1496 SET_SYS_FROM_STRING("flags", make_flags());
1497 /* prevent user from creating new instances */
1498 FlagsType
.tp_init
= NULL
;
1499 FlagsType
.tp_new
= NULL
;
1501 #undef SET_SYS_FROM_STRING
1502 if (PyErr_Occurred())
1508 makepathobject(char *path
, int delim
)
1516 while ((p
= strchr(p
, delim
)) != NULL
) {
1523 for (i
= 0; ; i
++) {
1524 p
= strchr(path
, delim
);
1526 p
= strchr(path
, '\0'); /* End of string */
1527 w
= PyString_FromStringAndSize(path
, (Py_ssize_t
) (p
- path
));
1532 PyList_SetItem(v
, i
, w
);
1541 PySys_SetPath(char *path
)
1544 if ((v
= makepathobject(path
, DELIM
)) == NULL
)
1545 Py_FatalError("can't create sys.path");
1546 if (PySys_SetObject("path", v
) != 0)
1547 Py_FatalError("can't assign sys.path");
1552 makeargvobject(int argc
, char **argv
)
1555 if (argc
<= 0 || argv
== NULL
) {
1556 /* Ensure at least one (empty) argument is seen */
1557 static char *empty_argv
[1] = {""};
1561 av
= PyList_New(argc
);
1564 for (i
= 0; i
< argc
; i
++) {
1568 /* argv[0] is the script pathname if known */
1570 char* fn
= decc$
translate_vms(argv
[0]);
1571 if ((fn
== (char *)0) || fn
== (char *)-1)
1572 v
= PyString_FromString(argv
[0]);
1574 v
= PyString_FromString(
1575 decc$
translate_vms(argv
[0]));
1577 v
= PyString_FromString(argv
[i
]);
1579 PyObject
*v
= PyString_FromString(argv
[i
]);
1586 PyList_SetItem(av
, i
, v
);
1593 PySys_SetArgv(int argc
, char **argv
)
1595 #if defined(HAVE_REALPATH)
1596 char fullpath
[MAXPATHLEN
];
1597 #elif defined(MS_WINDOWS) && !defined(MS_WINCE)
1598 char fullpath
[MAX_PATH
];
1600 PyObject
*av
= makeargvobject(argc
, argv
);
1601 PyObject
*path
= PySys_GetObject("path");
1603 Py_FatalError("no mem for sys.argv");
1604 if (PySys_SetObject("argv", av
) != 0)
1605 Py_FatalError("can't assign sys.argv");
1607 char *argv0
= argv
[0];
1611 #ifdef HAVE_READLINK
1612 char link
[MAXPATHLEN
+1];
1613 char argv0copy
[2*MAXPATHLEN
+1];
1615 if (argc
> 0 && argv0
!= NULL
&& strcmp(argv0
, "-c") != 0)
1616 nr
= readlink(argv0
, link
, MAXPATHLEN
);
1618 /* It's a symlink */
1621 argv0
= link
; /* Link to absolute path */
1622 else if (strchr(link
, SEP
) == NULL
)
1623 ; /* Link without path */
1625 /* Must join(dirname(argv0), link) */
1626 char *q
= strrchr(argv0
, SEP
);
1628 argv0
= link
; /* argv0 without path */
1630 /* Must make a copy */
1631 strcpy(argv0copy
, argv0
);
1632 q
= strrchr(argv0copy
, SEP
);
1638 #endif /* HAVE_READLINK */
1639 #if SEP == '\\' /* Special case for MS filename syntax */
1640 if (argc
> 0 && argv0
!= NULL
&& strcmp(argv0
, "-c") != 0) {
1642 #if defined(MS_WINDOWS) && !defined(MS_WINCE)
1643 /* This code here replaces the first element in argv with the full
1644 path that it represents. Under CE, there are no relative paths so
1645 the argument must be the full path anyway. */
1647 if (GetFullPathName(argv0
,
1654 p
= strrchr(argv0
, SEP
);
1655 /* Test for alternate separator */
1656 q
= strrchr(p
? p
: argv0
, '/');
1661 if (n
> 1 && p
[-1] != ':')
1662 n
--; /* Drop trailing separator */
1665 #else /* All other filename syntaxes */
1666 if (argc
> 0 && argv0
!= NULL
&& strcmp(argv0
, "-c") != 0) {
1667 #if defined(HAVE_REALPATH)
1668 if (realpath(argv0
, fullpath
)) {
1672 p
= strrchr(argv0
, SEP
);
1677 #else /* don't include trailing separator */
1680 #if SEP == '/' /* Special case for Unix filename syntax */
1682 n
--; /* Drop trailing separator */
1685 #endif /* All others */
1686 a
= PyString_FromStringAndSize(argv0
, n
);
1688 Py_FatalError("no mem for sys.path insertion");
1689 if (PyList_Insert(path
, 0, a
) < 0)
1690 Py_FatalError("sys.path.insert(0) failed");
1697 /* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
1698 Adapted from code submitted by Just van Rossum.
1700 PySys_WriteStdout(format, ...)
1701 PySys_WriteStderr(format, ...)
1703 The first function writes to sys.stdout; the second to sys.stderr. When
1704 there is a problem, they write to the real (C level) stdout or stderr;
1705 no exceptions are raised.
1707 Both take a printf-style format string as their first argument followed
1708 by a variable length argument list determined by the format string.
1712 The format should limit the total size of the formatted output string to
1713 1000 bytes. In particular, this means that no unrestricted "%s" formats
1714 should occur; these should be limited using "%.<N>s where <N> is a
1715 decimal number calculated so that <N> plus the maximum size of other
1716 formatted text does not exceed 1000 bytes. Also watch out for "%f",
1717 which can print hundreds of digits for very large numbers.
1722 mywrite(char *name
, FILE *fp
, const char *format
, va_list va
)
1725 PyObject
*error_type
, *error_value
, *error_traceback
;
1727 PyErr_Fetch(&error_type
, &error_value
, &error_traceback
);
1728 file
= PySys_GetObject(name
);
1729 if (file
== NULL
|| PyFile_AsFile(file
) == fp
)
1730 vfprintf(fp
, format
, va
);
1733 const int written
= PyOS_vsnprintf(buffer
, sizeof(buffer
),
1735 if (PyFile_WriteString(buffer
, file
) != 0) {
1739 if (written
< 0 || (size_t)written
>= sizeof(buffer
)) {
1740 const char *truncated
= "... truncated";
1741 if (PyFile_WriteString(truncated
, file
) != 0) {
1743 fputs(truncated
, fp
);
1747 PyErr_Restore(error_type
, error_value
, error_traceback
);
1751 PySys_WriteStdout(const char *format
, ...)
1755 va_start(va
, format
);
1756 mywrite("stdout", stdout
, format
, va
);
1761 PySys_WriteStderr(const char *format
, ...)
1765 va_start(va
, format
);
1766 mywrite("stderr", stderr
, format
, va
);