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 that will be used for dlopen() calls. Among other\n\
603 things, this will enable a lazy resolving of symbols when importing\n\
604 a module, if called as sys.setdlopenflags(0)\n\
605 To share symbols across extension modules, call as\n\
606 sys.setdlopenflags(dl.RTLD_NOW|dl.RTLD_GLOBAL)"
610 sys_getdlopenflags(PyObject
*self
, PyObject
*args
)
612 PyThreadState
*tstate
= PyThreadState_GET();
615 return PyInt_FromLong(tstate
->interp
->dlopenflags
);
618 PyDoc_STRVAR(getdlopenflags_doc
,
619 "getdlopenflags() -> int\n\
621 Return the current value of the flags that are used for dlopen()\n\
622 calls. The flag constants are defined in the dl module."
627 /* Link with -lmalloc (or -lmpc) on an SGI */
631 sys_mdebug(PyObject
*self
, PyObject
*args
)
634 if (!PyArg_ParseTuple(args
, "i:mdebug", &flag
))
636 mallopt(M_DEBUG
, flag
);
640 #endif /* USE_MALLOPT */
643 sys_getsizeof(PyObject
*self
, PyObject
*args
)
645 static PyObject
* str__sizeof__
= NULL
;
647 /* Initialize static variable needed by _PyType_Lookup */
648 if (str__sizeof__
== NULL
) {
649 str__sizeof__
= PyString_InternFromString("__sizeof__");
650 if (str__sizeof__
== NULL
)
655 if (PyType_Check(args
)){
656 PyObject
*method
= _PyType_Lookup(Py_TYPE(args
),
658 if (method
== NULL
) {
659 PyErr_Format(PyExc_TypeError
,
660 "Type %.100s doesn't define __sizeof__",
661 Py_TYPE(args
)->tp_name
);
664 return PyObject_CallFunctionObjArgs(method
, args
, NULL
);
666 /* Instance of old-style classes */
667 else if (PyInstance_Check(args
))
668 return PyInt_FromSsize_t(PyInstance_Type
.tp_basicsize
);
669 /* Old-style classes */
670 else if (PyClass_Check(args
))
671 return PyInt_FromSsize_t(PyClass_Type
.tp_basicsize
);
673 return PyObject_CallMethod(args
, "__sizeof__", NULL
);
676 PyDoc_STRVAR(getsizeof_doc
,
677 "getsizeof(object) -> int\n\
679 Return the size of object in bytes.");
682 sys_getrefcount(PyObject
*self
, PyObject
*arg
)
684 return PyInt_FromSsize_t(arg
->ob_refcnt
);
689 sys_gettotalrefcount(PyObject
*self
)
691 return PyInt_FromSsize_t(_Py_GetRefTotal());
693 #endif /* Py_REF_DEBUG */
695 PyDoc_STRVAR(getrefcount_doc
,
696 "getrefcount(object) -> integer\n\
698 Return the reference count of object. The count returned is generally\n\
699 one higher than you might expect, because it includes the (temporary)\n\
700 reference as an argument to getrefcount()."
705 sys_getcounts(PyObject
*self
)
707 extern PyObject
*get_counts(void);
713 PyDoc_STRVAR(getframe_doc
,
714 "_getframe([depth]) -> frameobject\n\
716 Return a frame object from the call stack. If optional integer depth is\n\
717 given, return the frame object that many calls below the top of the stack.\n\
718 If that is deeper than the call stack, ValueError is raised. The default\n\
719 for depth is zero, returning the frame at the top of the call stack.\n\
721 This function should be used for internal and specialized\n\
726 sys_getframe(PyObject
*self
, PyObject
*args
)
728 PyFrameObject
*f
= PyThreadState_GET()->frame
;
731 if (!PyArg_ParseTuple(args
, "|i:_getframe", &depth
))
734 while (depth
> 0 && f
!= NULL
) {
739 PyErr_SetString(PyExc_ValueError
,
740 "call stack is not deep enough");
747 PyDoc_STRVAR(current_frames_doc
,
748 "_current_frames() -> dictionary\n\
750 Return a dictionary mapping each current thread T's thread id to T's\n\
751 current stack frame.\n\
753 This function should be used for specialized purposes only."
757 sys_current_frames(PyObject
*self
, PyObject
*noargs
)
759 return _PyThread_CurrentFrames();
762 PyDoc_STRVAR(call_tracing_doc
,
763 "call_tracing(func, args) -> object\n\
765 Call func(*args), while tracing is enabled. The tracing state is\n\
766 saved, and restored afterwards. This is intended to be called from\n\
767 a debugger from a checkpoint, to recursively debug some other code."
771 sys_call_tracing(PyObject
*self
, PyObject
*args
)
773 PyObject
*func
, *funcargs
;
774 if (!PyArg_UnpackTuple(args
, "call_tracing", 2, 2, &func
, &funcargs
))
776 return _PyEval_CallTracing(func
, funcargs
);
779 PyDoc_STRVAR(callstats_doc
,
780 "callstats() -> tuple of integers\n\
782 Return a tuple of function call statistics, if CALL_PROFILE was defined\n\
783 when Python was built. Otherwise, return None.\n\
785 When enabled, this function returns detailed, implementation-specific\n\
786 details about the number of function calls executed. The return value is\n\
787 a 11-tuple where the entries in the tuple are counts of:\n\
788 0. all function calls\n\
789 1. calls to PyFunction_Type objects\n\
790 2. PyFunction calls that do not create an argument tuple\n\
791 3. PyFunction calls that do not create an argument tuple\n\
792 and bypass PyEval_EvalCodeEx()\n\
794 5. PyMethod calls on bound methods\n\
796 7. PyCFunction calls\n\
797 8. generator calls\n\
798 9. All other calls\n\
799 10. Number of stack pops performed by call_function()"
807 /* Defined in objects.c because it uses static globals if that file */
808 extern PyObject
*_Py_GetObjects(PyObject
*, PyObject
*);
811 #ifdef DYNAMIC_EXECUTION_PROFILE
812 /* Defined in ceval.c because it uses static globals if that file */
813 extern PyObject
*_Py_GetDXProfile(PyObject
*, PyObject
*);
821 sys_clear_type_cache(PyObject
* self
, PyObject
* args
)
827 PyDoc_STRVAR(sys_clear_type_cache__doc__
,
828 "_clear_type_cache() -> None\n\
829 Clear the internal type lookup cache.");
833 sys_compact_freelists(PyObject
* self
, PyObject
* args
)
835 size_t isum
, ibc
, ibf
;
836 size_t fsum
, fbc
, fbf
;
838 PyInt_CompactFreeList(&ibc
, &ibf
, &isum
);
839 PyFloat_CompactFreeList(&fbc
, &fbf
, &fsum
);
841 return Py_BuildValue("(kkk)(kkk)", isum
, ibc
, ibf
,
846 PyDoc_STRVAR(sys_compact_freelists__doc__
,
847 "_compact_freelists() -> ((remaing_objects, total_blocks, freed_blocks), ...)\n\
848 Compact the free lists of ints and floats.");
850 static PyMethodDef sys_methods
[] = {
851 /* Might as well keep this in alphabetic order */
852 {"callstats", (PyCFunction
)PyEval_GetCallStats
, METH_NOARGS
,
854 {"_clear_type_cache", sys_clear_type_cache
, METH_NOARGS
,
855 sys_clear_type_cache__doc__
},
856 {"_compact_freelists", sys_compact_freelists
, METH_NOARGS
,
857 sys_compact_freelists__doc__
},
858 {"_current_frames", sys_current_frames
, METH_NOARGS
,
860 {"displayhook", sys_displayhook
, METH_O
, displayhook_doc
},
861 {"exc_info", sys_exc_info
, METH_NOARGS
, exc_info_doc
},
862 {"exc_clear", sys_exc_clear
, METH_NOARGS
, exc_clear_doc
},
863 {"excepthook", sys_excepthook
, METH_VARARGS
, excepthook_doc
},
864 {"exit", sys_exit
, METH_VARARGS
, exit_doc
},
865 #ifdef Py_USING_UNICODE
866 {"getdefaultencoding", (PyCFunction
)sys_getdefaultencoding
,
867 METH_NOARGS
, getdefaultencoding_doc
},
870 {"getdlopenflags", (PyCFunction
)sys_getdlopenflags
, METH_NOARGS
,
874 {"getcounts", (PyCFunction
)sys_getcounts
, METH_NOARGS
},
876 #ifdef DYNAMIC_EXECUTION_PROFILE
877 {"getdxp", _Py_GetDXProfile
, METH_VARARGS
},
879 #ifdef Py_USING_UNICODE
880 {"getfilesystemencoding", (PyCFunction
)sys_getfilesystemencoding
,
881 METH_NOARGS
, getfilesystemencoding_doc
},
884 {"getobjects", _Py_GetObjects
, METH_VARARGS
},
887 {"gettotalrefcount", (PyCFunction
)sys_gettotalrefcount
, METH_NOARGS
},
889 {"getrefcount", (PyCFunction
)sys_getrefcount
, METH_O
, getrefcount_doc
},
890 {"getrecursionlimit", (PyCFunction
)sys_getrecursionlimit
, METH_NOARGS
,
891 getrecursionlimit_doc
},
892 {"getsizeof", sys_getsizeof
, METH_O
, getsizeof_doc
},
893 {"_getframe", sys_getframe
, METH_VARARGS
, getframe_doc
},
895 {"getwindowsversion", (PyCFunction
)sys_getwindowsversion
, METH_NOARGS
,
896 getwindowsversion_doc
},
897 #endif /* MS_WINDOWS */
899 {"mdebug", sys_mdebug
, METH_VARARGS
},
901 #ifdef Py_USING_UNICODE
902 {"setdefaultencoding", sys_setdefaultencoding
, METH_VARARGS
,
903 setdefaultencoding_doc
},
905 {"setcheckinterval", sys_setcheckinterval
, METH_VARARGS
,
906 setcheckinterval_doc
},
907 {"getcheckinterval", sys_getcheckinterval
, METH_NOARGS
,
908 getcheckinterval_doc
},
910 {"setdlopenflags", sys_setdlopenflags
, METH_VARARGS
,
913 {"setprofile", sys_setprofile
, METH_O
, setprofile_doc
},
914 {"getprofile", sys_getprofile
, METH_NOARGS
, getprofile_doc
},
915 {"setrecursionlimit", sys_setrecursionlimit
, METH_VARARGS
,
916 setrecursionlimit_doc
},
918 {"settscdump", sys_settscdump
, METH_VARARGS
, settscdump_doc
},
920 {"settrace", sys_settrace
, METH_O
, settrace_doc
},
921 {"gettrace", sys_gettrace
, METH_NOARGS
, gettrace_doc
},
922 {"call_tracing", sys_call_tracing
, METH_VARARGS
, call_tracing_doc
},
923 {NULL
, NULL
} /* sentinel */
927 list_builtin_module_names(void)
929 PyObject
*list
= PyList_New(0);
933 for (i
= 0; PyImport_Inittab
[i
].name
!= NULL
; i
++) {
934 PyObject
*name
= PyString_FromString(
935 PyImport_Inittab
[i
].name
);
938 PyList_Append(list
, name
);
941 if (PyList_Sort(list
) != 0) {
946 PyObject
*v
= PyList_AsTuple(list
);
953 static PyObject
*warnoptions
= NULL
;
956 PySys_ResetWarnOptions(void)
958 if (warnoptions
== NULL
|| !PyList_Check(warnoptions
))
960 PyList_SetSlice(warnoptions
, 0, PyList_GET_SIZE(warnoptions
), NULL
);
964 PySys_AddWarnOption(char *s
)
968 if (warnoptions
== NULL
|| !PyList_Check(warnoptions
)) {
969 Py_XDECREF(warnoptions
);
970 warnoptions
= PyList_New(0);
971 if (warnoptions
== NULL
)
974 str
= PyString_FromString(s
);
976 PyList_Append(warnoptions
, str
);
982 PySys_HasWarnOptions(void)
984 return (warnoptions
!= NULL
&& (PyList_Size(warnoptions
) > 0)) ? 1 : 0;
987 /* XXX This doc string is too long to be a single string literal in VC++ 5.0.
988 Two literals concatenated works just fine. If you have a K&R compiler
989 or other abomination that however *does* understand longer strings,
990 get rid of the !!! comment in the middle and the quotes that surround it. */
993 "This module provides access to some objects used or maintained by the\n\
994 interpreter and to functions that interact strongly with the interpreter.\n\
998 argv -- command line arguments; argv[0] is the script pathname if known\n\
999 path -- module search path; path[0] is the script directory, else ''\n\
1000 modules -- dictionary of loaded modules\n\
1002 displayhook -- called to show results in an interactive session\n\
1003 excepthook -- called to handle any uncaught exception other than SystemExit\n\
1004 To customize printing in an interactive session or to install a custom\n\
1005 top-level exception handler, assign other functions to replace these.\n\
1007 exitfunc -- if sys.exitfunc exists, this routine is called when Python exits\n\
1008 Assigning to sys.exitfunc is deprecated; use the atexit module instead.\n\
1010 stdin -- standard input file object; used by raw_input() and input()\n\
1011 stdout -- standard output file object; used by the print statement\n\
1012 stderr -- standard error object; used for error messages\n\
1013 By assigning other file objects (or objects that behave like files)\n\
1014 to these, it is possible to redirect all of the interpreter's I/O.\n\
1016 last_type -- type of last uncaught exception\n\
1017 last_value -- value of last uncaught exception\n\
1018 last_traceback -- traceback of last uncaught exception\n\
1019 These three are only available in an interactive session after a\n\
1020 traceback has been printed.\n\
1022 exc_type -- type of exception currently being handled\n\
1023 exc_value -- value of exception currently being handled\n\
1024 exc_traceback -- traceback of exception currently being handled\n\
1025 The function exc_info() should be used instead of these three,\n\
1026 because it is thread-safe.\n\
1029 /* concatenating string here */
1034 maxint -- the largest supported integer (the smallest is -maxint-1)\n\
1035 maxsize -- the largest supported length of containers.\n\
1036 maxunicode -- the largest supported character\n\
1037 builtin_module_names -- tuple of module names built into this interpreter\n\
1038 version -- the version of this interpreter as a string\n\
1039 version_info -- version information as a tuple\n\
1040 hexversion -- version information encoded as a single integer\n\
1041 copyright -- copyright notice pertaining to this interpreter\n\
1042 platform -- platform identifier\n\
1043 executable -- pathname of this Python interpreter\n\
1044 prefix -- prefix used to find the Python library\n\
1045 exec_prefix -- prefix used to find the machine-specific Python library\n\
1049 /* concatenating string here */
1051 "dllhandle -- [Windows only] integer handle of the Python DLL\n\
1052 winver -- [Windows only] version number of the Python DLL\n\
1055 #endif /* MS_WINDOWS */
1057 "__stdin__ -- the original stdin; don't touch!\n\
1058 __stdout__ -- the original stdout; don't touch!\n\
1059 __stderr__ -- the original stderr; don't touch!\n\
1060 __displayhook__ -- the original displayhook; don't touch!\n\
1061 __excepthook__ -- the original excepthook; don't touch!\n\
1065 displayhook() -- print an object to the screen, and save it in __builtin__._\n\
1066 excepthook() -- print an exception and its traceback to sys.stderr\n\
1067 exc_info() -- return thread-safe information about the current exception\n\
1068 exc_clear() -- clear the exception state for the current thread\n\
1069 exit() -- exit the interpreter by raising SystemExit\n\
1070 getdlopenflags() -- returns flags to be used for dlopen() calls\n\
1071 getprofile() -- get the global profiling function\n\
1072 getrefcount() -- return the reference count for an object (plus one :-)\n\
1073 getrecursionlimit() -- return the max recursion depth for the interpreter\n\
1074 getsizeof() -- return the size of an object in bytes\n\
1075 gettrace() -- get the global debug tracing function\n\
1076 setcheckinterval() -- control how often the interpreter checks for events\n\
1077 setdlopenflags() -- set the flags to be used for dlopen() calls\n\
1078 setprofile() -- set the global profiling function\n\
1079 setrecursionlimit() -- set the max recursion depth for the interpreter\n\
1080 settrace() -- set the global debug tracing function\n\
1083 /* end of sys_doc */ ;
1086 _check_and_flush (FILE *stream
)
1088 int prev_fail
= ferror (stream
);
1089 return fflush (stream
) || prev_fail
? EOF
: 0;
1092 /* Subversion branch and revision management */
1093 static const char _patchlevel_revision
[] = PY_PATCHLEVEL_REVISION
;
1094 static const char headurl
[] = "$HeadURL$";
1095 static int svn_initialized
;
1096 static char patchlevel_revision
[50]; /* Just the number */
1097 static char branch
[50];
1098 static char shortbranch
[50];
1099 static const char *svn_revision
;
1102 svnversion_init(void)
1104 const char *python
, *br_start
, *br_end
, *br_end2
, *svnversion
;
1108 if (svn_initialized
)
1111 python
= strstr(headurl
, "/python/");
1113 /* XXX quick hack to get bzr working */
1114 *patchlevel_revision
= '\0';
1116 strcpy(shortbranch
, "unknown");
1119 /* Py_FatalError("subversion keywords missing"); */
1122 br_start
= python
+ 8;
1123 br_end
= strchr(br_start
, '/');
1126 /* Works even for trunk,
1127 as we are in trunk/Python/sysmodule.c */
1128 br_end2
= strchr(br_end
+1, '/');
1130 istag
= strncmp(br_start
, "tags", 4) == 0;
1131 if (strncmp(br_start
, "trunk", 5) == 0) {
1132 strcpy(branch
, "trunk");
1133 strcpy(shortbranch
, "trunk");
1136 else if (istag
|| strncmp(br_start
, "branches", 8) == 0) {
1137 len
= br_end2
- br_start
;
1138 strncpy(branch
, br_start
, len
);
1141 len
= br_end2
- (br_end
+ 1);
1142 strncpy(shortbranch
, br_end
+ 1, len
);
1143 shortbranch
[len
] = '\0';
1146 Py_FatalError("bad HeadURL");
1151 svnversion
= _Py_svnversion();
1152 if (strcmp(svnversion
, "exported") != 0)
1153 svn_revision
= svnversion
;
1155 len
= strlen(_patchlevel_revision
);
1157 assert(len
< (sizeof(patchlevel_revision
) + 13));
1158 strncpy(patchlevel_revision
, _patchlevel_revision
+ 11,
1160 patchlevel_revision
[len
- 13] = '\0';
1161 svn_revision
= patchlevel_revision
;
1166 svn_initialized
= 1;
1169 /* Return svnversion output if available.
1170 Else return Revision of patchlevel.h if on branch.
1171 Else return empty string */
1173 Py_SubversionRevision()
1176 return svn_revision
;
1180 Py_SubversionShortBranch()
1187 PyDoc_STRVAR(flags__doc__
,
1190 Flags provided through command line arguments or environment vars.");
1192 static PyTypeObject FlagsType
= {0, 0, 0, 0, 0, 0};
1194 static PyStructSequence_Field flags_fields
[] = {
1196 {"py3k_warning", "-3"},
1197 {"division_warning", "-Q"},
1198 {"division_new", "-Qnew"},
1200 {"interactive", "-i"},
1201 {"optimize", "-O or -OO"},
1202 {"dont_write_bytecode", "-B"},
1203 {"no_user_site", "-s"},
1205 {"ignore_environment", "-E"},
1206 {"tabcheck", "-t or -tt"},
1209 {"riscos_wimp", "???"},
1211 /* {"unbuffered", "-u"}, */
1213 /* {"skip_first", "-x"}, */
1214 {"bytes_warning", "-b"},
1218 static PyStructSequence_Desc flags_desc
= {
1219 "sys.flags", /* name */
1220 flags__doc__
, /* doc */
1221 flags_fields
, /* fields */
1235 seq
= PyStructSequence_New(&FlagsType
);
1239 #define SetFlag(flag) \
1240 PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag))
1242 SetFlag(Py_DebugFlag
);
1243 SetFlag(Py_Py3kWarningFlag
);
1244 SetFlag(Py_DivisionWarningFlag
);
1245 SetFlag(_Py_QnewFlag
);
1246 SetFlag(Py_InspectFlag
);
1247 SetFlag(Py_InteractiveFlag
);
1248 SetFlag(Py_OptimizeFlag
);
1249 SetFlag(Py_DontWriteBytecodeFlag
);
1250 SetFlag(Py_NoUserSiteDirectory
);
1251 SetFlag(Py_NoSiteFlag
);
1252 SetFlag(Py_IgnoreEnvironmentFlag
);
1253 SetFlag(Py_TabcheckFlag
);
1254 SetFlag(Py_VerboseFlag
);
1256 SetFlag(Py_RISCOSWimpFlag
);
1258 /* SetFlag(saw_unbuffered_flag); */
1259 SetFlag(Py_UnicodeFlag
);
1260 /* SetFlag(skipfirstline); */
1261 SetFlag(Py_BytesWarningFlag
);
1264 if (PyErr_Occurred()) {
1273 PyObject
*m
, *v
, *sysdict
;
1274 PyObject
*sysin
, *sysout
, *syserr
;
1277 m
= Py_InitModule3("sys", sys_methods
, sys_doc
);
1280 sysdict
= PyModule_GetDict(m
);
1281 #define SET_SYS_FROM_STRING(key, value) \
1284 PyDict_SetItemString(sysdict, key, v); \
1288 /* XXX: does this work on Win/Win64? (see posix_fstat) */
1290 if (fstat(fileno(stdin
), &sb
) == 0 &&
1291 S_ISDIR(sb
.st_mode
)) {
1292 /* There's nothing more we can do. */
1293 /* Py_FatalError() will core dump, so just exit. */
1294 PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
1299 /* Closing the standard FILE* if sys.std* goes aways causes problems
1300 * for embedded Python usages. Closing them when somebody explicitly
1301 * invokes .close() might be possible, but the FAQ promises they get
1302 * never closed. However, we still need to get write errors when
1303 * writing fails (e.g. because stdout is redirected), so we flush the
1304 * streams and check for errors before the file objects are deleted.
1305 * On OS X, fflush()ing stdin causes an error, so we exempt stdin
1306 * from that procedure.
1308 sysin
= PyFile_FromFile(stdin
, "<stdin>", "r", NULL
);
1309 sysout
= PyFile_FromFile(stdout
, "<stdout>", "w", _check_and_flush
);
1310 syserr
= PyFile_FromFile(stderr
, "<stderr>", "w", _check_and_flush
);
1311 if (PyErr_Occurred())
1314 PyDict_SetItemString(sysdict
, "stdin", sysin
);
1315 PyDict_SetItemString(sysdict
, "stdout", sysout
);
1316 PyDict_SetItemString(sysdict
, "stderr", syserr
);
1317 /* Make backup copies for cleanup */
1318 PyDict_SetItemString(sysdict
, "__stdin__", sysin
);
1319 PyDict_SetItemString(sysdict
, "__stdout__", sysout
);
1320 PyDict_SetItemString(sysdict
, "__stderr__", syserr
);
1321 PyDict_SetItemString(sysdict
, "__displayhook__",
1322 PyDict_GetItemString(sysdict
, "displayhook"));
1323 PyDict_SetItemString(sysdict
, "__excepthook__",
1324 PyDict_GetItemString(sysdict
, "excepthook"));
1329 SET_SYS_FROM_STRING("version",
1330 PyString_FromString(Py_GetVersion()));
1331 SET_SYS_FROM_STRING("hexversion",
1332 PyInt_FromLong(PY_VERSION_HEX
));
1334 SET_SYS_FROM_STRING("subversion",
1335 Py_BuildValue("(ssz)", "CPython", branch
,
1337 SET_SYS_FROM_STRING("dont_write_bytecode",
1338 PyBool_FromLong(Py_DontWriteBytecodeFlag
));
1340 * These release level checks are mutually exclusive and cover
1341 * the field, so don't get too fancy with the pre-processor!
1343 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
1345 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
1347 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
1349 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
1353 SET_SYS_FROM_STRING("version_info",
1354 Py_BuildValue("iiisi", PY_MAJOR_VERSION
,
1356 PY_MICRO_VERSION
, s
,
1357 PY_RELEASE_SERIAL
));
1358 SET_SYS_FROM_STRING("api_version",
1359 PyInt_FromLong(PYTHON_API_VERSION
));
1360 SET_SYS_FROM_STRING("copyright",
1361 PyString_FromString(Py_GetCopyright()));
1362 SET_SYS_FROM_STRING("platform",
1363 PyString_FromString(Py_GetPlatform()));
1364 SET_SYS_FROM_STRING("executable",
1365 PyString_FromString(Py_GetProgramFullPath()));
1366 SET_SYS_FROM_STRING("prefix",
1367 PyString_FromString(Py_GetPrefix()));
1368 SET_SYS_FROM_STRING("exec_prefix",
1369 PyString_FromString(Py_GetExecPrefix()));
1370 SET_SYS_FROM_STRING("maxsize",
1371 PyInt_FromSsize_t(PY_SSIZE_T_MAX
));
1372 SET_SYS_FROM_STRING("maxint",
1373 PyInt_FromLong(PyInt_GetMax()));
1374 SET_SYS_FROM_STRING("py3kwarning",
1375 PyBool_FromLong(Py_Py3kWarningFlag
));
1376 SET_SYS_FROM_STRING("float_info",
1378 #ifdef Py_USING_UNICODE
1379 SET_SYS_FROM_STRING("maxunicode",
1380 PyInt_FromLong(PyUnicode_GetMax()));
1382 SET_SYS_FROM_STRING("builtin_module_names",
1383 list_builtin_module_names());
1385 /* Assumes that longs are at least 2 bytes long.
1387 unsigned long number
= 1;
1390 s
= (char *) &number
;
1395 SET_SYS_FROM_STRING("byteorder",
1396 PyString_FromString(value
));
1399 SET_SYS_FROM_STRING("dllhandle",
1400 PyLong_FromVoidPtr(PyWin_DLLhModule
));
1401 SET_SYS_FROM_STRING("winver",
1402 PyString_FromString(PyWin_DLLVersionString
));
1404 if (warnoptions
== NULL
) {
1405 warnoptions
= PyList_New(0);
1408 Py_INCREF(warnoptions
);
1410 if (warnoptions
!= NULL
) {
1411 PyDict_SetItemString(sysdict
, "warnoptions", warnoptions
);
1414 if (FlagsType
.tp_name
== 0)
1415 PyStructSequence_InitType(&FlagsType
, &flags_desc
);
1416 SET_SYS_FROM_STRING("flags", make_flags());
1417 /* prevent user from creating new instances */
1418 FlagsType
.tp_init
= NULL
;
1419 FlagsType
.tp_new
= NULL
;
1421 #undef SET_SYS_FROM_STRING
1422 if (PyErr_Occurred())
1428 makepathobject(char *path
, int delim
)
1436 while ((p
= strchr(p
, delim
)) != NULL
) {
1443 for (i
= 0; ; i
++) {
1444 p
= strchr(path
, delim
);
1446 p
= strchr(path
, '\0'); /* End of string */
1447 w
= PyString_FromStringAndSize(path
, (Py_ssize_t
) (p
- path
));
1452 PyList_SetItem(v
, i
, w
);
1461 PySys_SetPath(char *path
)
1464 if ((v
= makepathobject(path
, DELIM
)) == NULL
)
1465 Py_FatalError("can't create sys.path");
1466 if (PySys_SetObject("path", v
) != 0)
1467 Py_FatalError("can't assign sys.path");
1472 makeargvobject(int argc
, char **argv
)
1475 if (argc
<= 0 || argv
== NULL
) {
1476 /* Ensure at least one (empty) argument is seen */
1477 static char *empty_argv
[1] = {""};
1481 av
= PyList_New(argc
);
1484 for (i
= 0; i
< argc
; i
++) {
1488 /* argv[0] is the script pathname if known */
1490 char* fn
= decc$
translate_vms(argv
[0]);
1491 if ((fn
== (char *)0) || fn
== (char *)-1)
1492 v
= PyString_FromString(argv
[0]);
1494 v
= PyString_FromString(
1495 decc$
translate_vms(argv
[0]));
1497 v
= PyString_FromString(argv
[i
]);
1499 PyObject
*v
= PyString_FromString(argv
[i
]);
1506 PyList_SetItem(av
, i
, v
);
1513 PySys_SetArgv(int argc
, char **argv
)
1515 #if defined(HAVE_REALPATH)
1516 char fullpath
[MAXPATHLEN
];
1517 #elif defined(MS_WINDOWS)
1518 char fullpath
[MAX_PATH
];
1520 PyObject
*av
= makeargvobject(argc
, argv
);
1521 PyObject
*path
= PySys_GetObject("path");
1523 Py_FatalError("no mem for sys.argv");
1524 if (PySys_SetObject("argv", av
) != 0)
1525 Py_FatalError("can't assign sys.argv");
1527 char *argv0
= argv
[0];
1531 #ifdef HAVE_READLINK
1532 char link
[MAXPATHLEN
+1];
1533 char argv0copy
[2*MAXPATHLEN
+1];
1535 if (argc
> 0 && argv0
!= NULL
&& strcmp(argv0
, "-c") != 0)
1536 nr
= readlink(argv0
, link
, MAXPATHLEN
);
1538 /* It's a symlink */
1541 argv0
= link
; /* Link to absolute path */
1542 else if (strchr(link
, SEP
) == NULL
)
1543 ; /* Link without path */
1545 /* Must join(dirname(argv0), link) */
1546 char *q
= strrchr(argv0
, SEP
);
1548 argv0
= link
; /* argv0 without path */
1550 /* Must make a copy */
1551 strcpy(argv0copy
, argv0
);
1552 q
= strrchr(argv0copy
, SEP
);
1558 #endif /* HAVE_READLINK */
1559 #if SEP == '\\' /* Special case for MS filename syntax */
1560 if (argc
> 0 && argv0
!= NULL
&& strcmp(argv0
, "-c") != 0) {
1564 if (GetFullPathName(argv0
,
1571 p
= strrchr(argv0
, SEP
);
1572 /* Test for alternate separator */
1573 q
= strrchr(p
? p
: argv0
, '/');
1578 if (n
> 1 && p
[-1] != ':')
1579 n
--; /* Drop trailing separator */
1582 #else /* All other filename syntaxes */
1583 if (argc
> 0 && argv0
!= NULL
&& strcmp(argv0
, "-c") != 0) {
1584 #if defined(HAVE_REALPATH)
1585 if (realpath(argv0
, fullpath
)) {
1589 p
= strrchr(argv0
, SEP
);
1594 #else /* don't include trailing separator */
1597 #if SEP == '/' /* Special case for Unix filename syntax */
1599 n
--; /* Drop trailing separator */
1602 #endif /* All others */
1603 a
= PyString_FromStringAndSize(argv0
, n
);
1605 Py_FatalError("no mem for sys.path insertion");
1606 if (PyList_Insert(path
, 0, a
) < 0)
1607 Py_FatalError("sys.path.insert(0) failed");
1614 /* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
1615 Adapted from code submitted by Just van Rossum.
1617 PySys_WriteStdout(format, ...)
1618 PySys_WriteStderr(format, ...)
1620 The first function writes to sys.stdout; the second to sys.stderr. When
1621 there is a problem, they write to the real (C level) stdout or stderr;
1622 no exceptions are raised.
1624 Both take a printf-style format string as their first argument followed
1625 by a variable length argument list determined by the format string.
1629 The format should limit the total size of the formatted output string to
1630 1000 bytes. In particular, this means that no unrestricted "%s" formats
1631 should occur; these should be limited using "%.<N>s where <N> is a
1632 decimal number calculated so that <N> plus the maximum size of other
1633 formatted text does not exceed 1000 bytes. Also watch out for "%f",
1634 which can print hundreds of digits for very large numbers.
1639 mywrite(char *name
, FILE *fp
, const char *format
, va_list va
)
1642 PyObject
*error_type
, *error_value
, *error_traceback
;
1644 PyErr_Fetch(&error_type
, &error_value
, &error_traceback
);
1645 file
= PySys_GetObject(name
);
1646 if (file
== NULL
|| PyFile_AsFile(file
) == fp
)
1647 vfprintf(fp
, format
, va
);
1650 const int written
= PyOS_vsnprintf(buffer
, sizeof(buffer
),
1652 if (PyFile_WriteString(buffer
, file
) != 0) {
1656 if (written
< 0 || (size_t)written
>= sizeof(buffer
)) {
1657 const char *truncated
= "... truncated";
1658 if (PyFile_WriteString(truncated
, file
) != 0) {
1660 fputs(truncated
, fp
);
1664 PyErr_Restore(error_type
, error_value
, error_traceback
);
1668 PySys_WriteStdout(const char *format
, ...)
1672 va_start(va
, format
);
1673 mywrite("stdout", stdout
, format
, va
);
1678 PySys_WriteStderr(const char *format
, ...)
1682 va_start(va
, format
);
1683 mywrite("stderr", stderr
, format
, va
);