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
;
40 #ifdef HAVE_LANGINFO_H
46 PySys_GetObject(const char *name
)
48 PyThreadState
*tstate
= PyThreadState_GET();
49 PyObject
*sd
= tstate
->interp
->sysdict
;
52 return PyDict_GetItemString(sd
, name
);
56 PySys_SetObject(const char *name
, PyObject
*v
)
58 PyThreadState
*tstate
= PyThreadState_GET();
59 PyObject
*sd
= tstate
->interp
->sysdict
;
61 if (PyDict_GetItemString(sd
, name
) == NULL
)
64 return PyDict_DelItemString(sd
, name
);
67 return PyDict_SetItemString(sd
, name
, v
);
71 sys_displayhook(PyObject
*self
, PyObject
*o
)
74 PyInterpreterState
*interp
= PyThreadState_GET()->interp
;
75 PyObject
*modules
= interp
->modules
;
76 PyObject
*builtins
= PyDict_GetItemString(modules
, "builtins");
78 if (builtins
== NULL
) {
79 PyErr_SetString(PyExc_RuntimeError
, "lost builtins module");
83 /* Print value except if None */
84 /* After printing, also assign to '_' */
85 /* Before, set '_' to None to avoid recursion */
90 if (PyObject_SetAttrString(builtins
, "_", Py_None
) != 0)
92 outf
= PySys_GetObject("stdout");
93 if (outf
== NULL
|| outf
== Py_None
) {
94 PyErr_SetString(PyExc_RuntimeError
, "lost sys.stdout");
97 if (PyFile_WriteObject(o
, outf
, 0) != 0)
99 if (PyFile_WriteString("\n", outf
) != 0)
101 if (PyObject_SetAttrString(builtins
, "_", o
) != 0)
107 PyDoc_STRVAR(displayhook_doc
,
108 "displayhook(object) -> None\n"
110 "Print an object to sys.stdout and also save it in builtins._\n"
114 sys_excepthook(PyObject
* self
, PyObject
* args
)
116 PyObject
*exc
, *value
, *tb
;
117 if (!PyArg_UnpackTuple(args
, "excepthook", 3, 3, &exc
, &value
, &tb
))
119 PyErr_Display(exc
, value
, tb
);
124 PyDoc_STRVAR(excepthook_doc
,
125 "excepthook(exctype, value, traceback) -> None\n"
127 "Handle an exception by displaying it with a traceback on sys.stderr.\n"
131 sys_exc_info(PyObject
*self
, PyObject
*noargs
)
133 PyThreadState
*tstate
;
134 tstate
= PyThreadState_GET();
135 return Py_BuildValue(
137 tstate
->exc_type
!= NULL
? tstate
->exc_type
: Py_None
,
138 tstate
->exc_value
!= NULL
? tstate
->exc_value
: Py_None
,
139 tstate
->exc_traceback
!= NULL
?
140 tstate
->exc_traceback
: Py_None
);
143 PyDoc_STRVAR(exc_info_doc
,
144 "exc_info() -> (type, value, traceback)\n\
146 Return information about the most recent exception caught by an except\n\
147 clause in the current stack frame or in an older stack frame."
151 sys_exit(PyObject
*self
, PyObject
*args
)
153 PyObject
*exit_code
= 0;
154 if (!PyArg_UnpackTuple(args
, "exit", 0, 1, &exit_code
))
156 /* Raise SystemExit so callers may catch it or clean up. */
157 PyErr_SetObject(PyExc_SystemExit
, exit_code
);
161 PyDoc_STRVAR(exit_doc
,
164 Exit the interpreter by raising SystemExit(status).\n\
165 If the status is omitted or None, it defaults to zero (i.e., success).\n\
166 If the status is numeric, it will be used as the system exit status.\n\
167 If it is another kind of object, it will be printed and the system\n\
168 exit status will be one (i.e., failure)."
173 sys_getdefaultencoding(PyObject
*self
)
175 return PyUnicode_FromString(PyUnicode_GetDefaultEncoding());
178 PyDoc_STRVAR(getdefaultencoding_doc
,
179 "getdefaultencoding() -> string\n\
181 Return the current default string encoding used by the Unicode \n\
186 sys_setdefaultencoding(PyObject
*self
, PyObject
*args
)
189 if (!PyArg_ParseTuple(args
, "s:setdefaultencoding", &encoding
))
191 if (PyUnicode_SetDefaultEncoding(encoding
))
197 PyDoc_STRVAR(setdefaultencoding_doc
,
198 "setdefaultencoding(encoding)\n\
200 Set the current default string encoding used by the Unicode implementation."
204 sys_getfilesystemencoding(PyObject
*self
)
206 if (Py_FileSystemDefaultEncoding
)
207 return PyUnicode_FromString(Py_FileSystemDefaultEncoding
);
212 PyDoc_STRVAR(getfilesystemencoding_doc
,
213 "getfilesystemencoding() -> string\n\
215 Return the encoding used to convert Unicode filenames in\n\
216 operating system filenames."
220 sys_setfilesystemencoding(PyObject
*self
, PyObject
*args
)
222 PyObject
*new_encoding
;
223 if (!PyArg_ParseTuple(args
, "U:setfilesystemencoding", &new_encoding
))
225 if (_Py_SetFileSystemEncoding(new_encoding
))
231 PyDoc_STRVAR(setfilesystemencoding_doc
,
232 "setfilesystemencoding(string) -> None\n\
234 Set the encoding used to convert Unicode filenames in\n\
235 operating system filenames."
239 sys_intern(PyObject
*self
, PyObject
*args
)
242 if (!PyArg_ParseTuple(args
, "U:intern", &s
))
244 if (PyUnicode_CheckExact(s
)) {
246 PyUnicode_InternInPlace(&s
);
250 PyErr_Format(PyExc_TypeError
,
251 "can't intern %.400s", s
->ob_type
->tp_name
);
256 PyDoc_STRVAR(intern_doc
,
257 "intern(string) -> string\n\
259 ``Intern'' the given string. This enters the string in the (global)\n\
260 table of interned strings whose purpose is to speed up dictionary lookups.\n\
261 Return the string itself or the previously interned string object with the\n\
266 * Cached interned string objects used for calling the profile and
267 * trace functions. Initialized by trace_init().
269 static PyObject
*whatstrings
[7] = {NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
};
274 static char *whatnames
[7] = {"call", "exception", "line", "return",
275 "c_call", "c_exception", "c_return"};
278 for (i
= 0; i
< 7; ++i
) {
279 if (whatstrings
[i
] == NULL
) {
280 name
= PyUnicode_InternFromString(whatnames
[i
]);
283 whatstrings
[i
] = name
;
291 call_trampoline(PyThreadState
*tstate
, PyObject
* callback
,
292 PyFrameObject
*frame
, int what
, PyObject
*arg
)
294 PyObject
*args
= PyTuple_New(3);
301 whatstr
= whatstrings
[what
];
306 PyTuple_SET_ITEM(args
, 0, (PyObject
*)frame
);
307 PyTuple_SET_ITEM(args
, 1, whatstr
);
308 PyTuple_SET_ITEM(args
, 2, arg
);
310 /* call the Python-level function */
311 PyFrame_FastToLocals(frame
);
312 result
= PyEval_CallObject(callback
, args
);
313 PyFrame_LocalsToFast(frame
, 1);
315 PyTraceBack_Here(frame
);
323 profile_trampoline(PyObject
*self
, PyFrameObject
*frame
,
324 int what
, PyObject
*arg
)
326 PyThreadState
*tstate
= frame
->f_tstate
;
331 result
= call_trampoline(tstate
, self
, frame
, what
, arg
);
332 if (result
== NULL
) {
333 PyEval_SetProfile(NULL
, NULL
);
341 trace_trampoline(PyObject
*self
, PyFrameObject
*frame
,
342 int what
, PyObject
*arg
)
344 PyThreadState
*tstate
= frame
->f_tstate
;
348 if (what
== PyTrace_CALL
)
351 callback
= frame
->f_trace
;
352 if (callback
== NULL
)
354 result
= call_trampoline(tstate
, callback
, frame
, what
, arg
);
355 if (result
== NULL
) {
356 PyEval_SetTrace(NULL
, NULL
);
357 Py_XDECREF(frame
->f_trace
);
358 frame
->f_trace
= NULL
;
361 if (result
!= Py_None
) {
362 PyObject
*temp
= frame
->f_trace
;
363 frame
->f_trace
= NULL
;
365 frame
->f_trace
= result
;
374 sys_settrace(PyObject
*self
, PyObject
*args
)
376 if (trace_init() == -1)
379 PyEval_SetTrace(NULL
, NULL
);
381 PyEval_SetTrace(trace_trampoline
, args
);
386 PyDoc_STRVAR(settrace_doc
,
387 "settrace(function)\n\
389 Set the global debug tracing function. It will be called on each\n\
390 function call. See the debugger chapter in the library manual."
394 sys_gettrace(PyObject
*self
, PyObject
*args
)
396 PyThreadState
*tstate
= PyThreadState_GET();
397 PyObject
*temp
= tstate
->c_traceobj
;
405 PyDoc_STRVAR(gettrace_doc
,
408 Return the global debug tracing function set with sys.settrace.\n\
409 See the debugger chapter in the library manual."
413 sys_setprofile(PyObject
*self
, PyObject
*args
)
415 if (trace_init() == -1)
418 PyEval_SetProfile(NULL
, NULL
);
420 PyEval_SetProfile(profile_trampoline
, args
);
425 PyDoc_STRVAR(setprofile_doc
,
426 "setprofile(function)\n\
428 Set the profiling function. It will be called on each function call\n\
429 and return. See the profiler chapter in the library manual."
433 sys_getprofile(PyObject
*self
, PyObject
*args
)
435 PyThreadState
*tstate
= PyThreadState_GET();
436 PyObject
*temp
= tstate
->c_profileobj
;
444 PyDoc_STRVAR(getprofile_doc
,
447 Return the profiling function set with sys.setprofile.\n\
448 See the profiler chapter in the library manual."
452 sys_setcheckinterval(PyObject
*self
, PyObject
*args
)
454 if (!PyArg_ParseTuple(args
, "i:setcheckinterval", &_Py_CheckInterval
))
460 PyDoc_STRVAR(setcheckinterval_doc
,
461 "setcheckinterval(n)\n\
463 Tell the Python interpreter to check for asynchronous events every\n\
464 n instructions. This also affects how often thread switches occur."
468 sys_getcheckinterval(PyObject
*self
, PyObject
*args
)
470 return PyLong_FromLong(_Py_CheckInterval
);
473 PyDoc_STRVAR(getcheckinterval_doc
,
474 "getcheckinterval() -> current check interval; see setcheckinterval()."
479 sys_settscdump(PyObject
*self
, PyObject
*args
)
482 PyThreadState
*tstate
= PyThreadState_Get();
484 if (!PyArg_ParseTuple(args
, "i:settscdump", &bool))
487 tstate
->interp
->tscdump
= 1;
489 tstate
->interp
->tscdump
= 0;
495 PyDoc_STRVAR(settscdump_doc
,
498 If true, tell the Python interpreter to dump VM measurements to\n\
499 stderr. If false, turn off dump. The measurements are based on the\n\
500 processor's time-stamp counter."
505 sys_setrecursionlimit(PyObject
*self
, PyObject
*args
)
508 if (!PyArg_ParseTuple(args
, "i:setrecursionlimit", &new_limit
))
510 if (new_limit
<= 0) {
511 PyErr_SetString(PyExc_ValueError
,
512 "recursion limit must be positive");
515 Py_SetRecursionLimit(new_limit
);
520 PyDoc_STRVAR(setrecursionlimit_doc
,
521 "setrecursionlimit(n)\n\
523 Set the maximum depth of the Python interpreter stack to n. This\n\
524 limit prevents infinite recursion from causing an overflow of the C\n\
525 stack and crashing Python. The highest possible limit is platform-\n\
530 sys_getrecursionlimit(PyObject
*self
)
532 return PyLong_FromLong(Py_GetRecursionLimit());
535 PyDoc_STRVAR(getrecursionlimit_doc
,
536 "getrecursionlimit()\n\
538 Return the current value of the recursion limit, the maximum depth\n\
539 of the Python interpreter stack. This limit prevents infinite\n\
540 recursion from causing an overflow of the C stack and crashing Python."
544 PyDoc_STRVAR(getwindowsversion_doc
,
545 "getwindowsversion()\n\
547 Return information about the running version of Windows.\n\
548 The result is a tuple of (major, minor, build, platform, text)\n\
549 All elements are numbers, except text which is a string.\n\
550 Platform may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP\n\
555 sys_getwindowsversion(PyObject
*self
)
558 ver
.dwOSVersionInfoSize
= sizeof(ver
);
559 if (!GetVersionEx(&ver
))
560 return PyErr_SetFromWindowsErr(0);
561 return Py_BuildValue("HHHHs",
569 #endif /* MS_WINDOWS */
573 sys_setdlopenflags(PyObject
*self
, PyObject
*args
)
576 PyThreadState
*tstate
= PyThreadState_GET();
577 if (!PyArg_ParseTuple(args
, "i:setdlopenflags", &new_val
))
581 tstate
->interp
->dlopenflags
= new_val
;
586 PyDoc_STRVAR(setdlopenflags_doc
,
587 "setdlopenflags(n) -> None\n\
589 Set the flags used by the interpreter for dlopen calls, such as when the\n\
590 interpreter loads extension modules. Among other things, this will enable\n\
591 a lazy resolving of symbols when importing a module, if called as\n\
592 sys.setdlopenflags(0). To share symbols across extension modules, call as\n\
593 sys.setdlopenflags(ctypes.RTLD_GLOBAL). Symbolic names for the flag modules\n\
594 can be either found in the ctypes module, or in the DLFCN module. If DLFCN\n\
595 is not available, it can be generated from /usr/include/dlfcn.h using the\n\
599 sys_getdlopenflags(PyObject
*self
, PyObject
*args
)
601 PyThreadState
*tstate
= PyThreadState_GET();
604 return PyLong_FromLong(tstate
->interp
->dlopenflags
);
607 PyDoc_STRVAR(getdlopenflags_doc
,
608 "getdlopenflags() -> int\n\
610 Return the current value of the flags that are used for dlopen calls.\n\
611 The flag constants are defined in the ctypes and DLFCN modules.");
613 #endif /* HAVE_DLOPEN */
616 /* Link with -lmalloc (or -lmpc) on an SGI */
620 sys_mdebug(PyObject
*self
, PyObject
*args
)
623 if (!PyArg_ParseTuple(args
, "i:mdebug", &flag
))
625 mallopt(M_DEBUG
, flag
);
629 #endif /* USE_MALLOPT */
632 sys_getsizeof(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
634 PyObject
*res
= NULL
;
635 static PyObject
*str__sizeof__
= NULL
, *gc_head_size
= NULL
;
636 static char *kwlist
[] = {"object", "default", 0};
637 PyObject
*o
, *dflt
= NULL
;
640 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "O|O:getsizeof",
644 /* Initialize static variable for GC head size */
645 if (gc_head_size
== NULL
) {
646 gc_head_size
= PyLong_FromSsize_t(sizeof(PyGC_Head
));
647 if (gc_head_size
== NULL
)
651 /* Make sure the type is initialized. float gets initialized late */
652 if (PyType_Ready(Py_TYPE(o
)) < 0)
655 method
= _PyObject_LookupSpecial(o
, "__sizeof__",
657 if (method
== NULL
) {
658 if (!PyErr_Occurred())
659 PyErr_Format(PyExc_TypeError
,
660 "Type %.100s doesn't define __sizeof__",
661 Py_TYPE(o
)->tp_name
);
664 res
= PyObject_CallFunctionObjArgs(method
, NULL
);
668 /* Has a default value been given */
669 if ((res
== NULL
) && (dflt
!= NULL
) &&
670 PyErr_ExceptionMatches(PyExc_TypeError
))
676 else if (res
== NULL
)
679 /* add gc_head size */
680 if (PyObject_IS_GC(o
)) {
682 res
= PyNumber_Add(tmp
, gc_head_size
);
688 PyDoc_STRVAR(getsizeof_doc
,
689 "getsizeof(object, default) -> int\n\
691 Return the size of object in bytes.");
694 sys_getrefcount(PyObject
*self
, PyObject
*arg
)
696 return PyLong_FromSsize_t(arg
->ob_refcnt
);
701 sys_gettotalrefcount(PyObject
*self
)
703 return PyLong_FromSsize_t(_Py_GetRefTotal());
705 #endif /* Py_REF_DEBUG */
707 PyDoc_STRVAR(getrefcount_doc
,
708 "getrefcount(object) -> integer\n\
710 Return the reference count of object. The count returned is generally\n\
711 one higher than you might expect, because it includes the (temporary)\n\
712 reference as an argument to getrefcount()."
717 sys_getcounts(PyObject
*self
)
719 extern PyObject
*get_counts(void);
725 PyDoc_STRVAR(getframe_doc
,
726 "_getframe([depth]) -> frameobject\n\
728 Return a frame object from the call stack. If optional integer depth is\n\
729 given, return the frame object that many calls below the top of the stack.\n\
730 If that is deeper than the call stack, ValueError is raised. The default\n\
731 for depth is zero, returning the frame at the top of the call stack.\n\
733 This function should be used for internal and specialized\n\
738 sys_getframe(PyObject
*self
, PyObject
*args
)
740 PyFrameObject
*f
= PyThreadState_GET()->frame
;
743 if (!PyArg_ParseTuple(args
, "|i:_getframe", &depth
))
746 while (depth
> 0 && f
!= NULL
) {
751 PyErr_SetString(PyExc_ValueError
,
752 "call stack is not deep enough");
759 PyDoc_STRVAR(current_frames_doc
,
760 "_current_frames() -> dictionary\n\
762 Return a dictionary mapping each current thread T's thread id to T's\n\
763 current stack frame.\n\
765 This function should be used for specialized purposes only."
769 sys_current_frames(PyObject
*self
, PyObject
*noargs
)
771 return _PyThread_CurrentFrames();
774 PyDoc_STRVAR(call_tracing_doc
,
775 "call_tracing(func, args) -> object\n\
777 Call func(*args), while tracing is enabled. The tracing state is\n\
778 saved, and restored afterwards. This is intended to be called from\n\
779 a debugger from a checkpoint, to recursively debug some other code."
783 sys_call_tracing(PyObject
*self
, PyObject
*args
)
785 PyObject
*func
, *funcargs
;
786 if (!PyArg_ParseTuple(args
, "OO!:call_tracing", &func
, &PyTuple_Type
, &funcargs
))
788 return _PyEval_CallTracing(func
, funcargs
);
791 PyDoc_STRVAR(callstats_doc
,
792 "callstats() -> tuple of integers\n\
794 Return a tuple of function call statistics, if CALL_PROFILE was defined\n\
795 when Python was built. Otherwise, return None.\n\
797 When enabled, this function returns detailed, implementation-specific\n\
798 details about the number of function calls executed. The return value is\n\
799 a 11-tuple where the entries in the tuple are counts of:\n\
800 0. all function calls\n\
801 1. calls to PyFunction_Type objects\n\
802 2. PyFunction calls that do not create an argument tuple\n\
803 3. PyFunction calls that do not create an argument tuple\n\
804 and bypass PyEval_EvalCodeEx()\n\
806 5. PyMethod calls on bound methods\n\
808 7. PyCFunction calls\n\
809 8. generator calls\n\
810 9. All other calls\n\
811 10. Number of stack pops performed by call_function()"
819 /* Defined in objects.c because it uses static globals if that file */
820 extern PyObject
*_Py_GetObjects(PyObject
*, PyObject
*);
823 #ifdef DYNAMIC_EXECUTION_PROFILE
824 /* Defined in ceval.c because it uses static globals if that file */
825 extern PyObject
*_Py_GetDXProfile(PyObject
*, PyObject
*);
833 sys_clear_type_cache(PyObject
* self
, PyObject
* args
)
839 PyDoc_STRVAR(sys_clear_type_cache__doc__
,
840 "_clear_type_cache() -> None\n\
841 Clear the internal type lookup cache.");
844 static PyMethodDef sys_methods
[] = {
845 /* Might as well keep this in alphabetic order */
846 {"callstats", (PyCFunction
)PyEval_GetCallStats
, METH_NOARGS
,
848 {"_clear_type_cache", sys_clear_type_cache
, METH_NOARGS
,
849 sys_clear_type_cache__doc__
},
850 {"_current_frames", sys_current_frames
, METH_NOARGS
,
852 {"displayhook", sys_displayhook
, METH_O
, displayhook_doc
},
853 {"exc_info", sys_exc_info
, METH_NOARGS
, exc_info_doc
},
854 {"excepthook", sys_excepthook
, METH_VARARGS
, excepthook_doc
},
855 {"exit", sys_exit
, METH_VARARGS
, exit_doc
},
856 {"getdefaultencoding", (PyCFunction
)sys_getdefaultencoding
,
857 METH_NOARGS
, getdefaultencoding_doc
},
859 {"getdlopenflags", (PyCFunction
)sys_getdlopenflags
, METH_NOARGS
,
863 {"getcounts", (PyCFunction
)sys_getcounts
, METH_NOARGS
},
865 #ifdef DYNAMIC_EXECUTION_PROFILE
866 {"getdxp", _Py_GetDXProfile
, METH_VARARGS
},
868 {"getfilesystemencoding", (PyCFunction
)sys_getfilesystemencoding
,
869 METH_NOARGS
, getfilesystemencoding_doc
},
871 {"getobjects", _Py_GetObjects
, METH_VARARGS
},
874 {"gettotalrefcount", (PyCFunction
)sys_gettotalrefcount
, METH_NOARGS
},
876 {"getrefcount", (PyCFunction
)sys_getrefcount
, METH_O
, getrefcount_doc
},
877 {"getrecursionlimit", (PyCFunction
)sys_getrecursionlimit
, METH_NOARGS
,
878 getrecursionlimit_doc
},
879 {"getsizeof", (PyCFunction
)sys_getsizeof
,
880 METH_VARARGS
| METH_KEYWORDS
, getsizeof_doc
},
881 {"_getframe", sys_getframe
, METH_VARARGS
, getframe_doc
},
883 {"getwindowsversion", (PyCFunction
)sys_getwindowsversion
, METH_NOARGS
,
884 getwindowsversion_doc
},
885 #endif /* MS_WINDOWS */
886 {"intern", sys_intern
, METH_VARARGS
, intern_doc
},
888 {"mdebug", sys_mdebug
, METH_VARARGS
},
890 {"setdefaultencoding", sys_setdefaultencoding
, METH_VARARGS
,
891 setdefaultencoding_doc
},
892 {"setfilesystemencoding", sys_setfilesystemencoding
, METH_VARARGS
,
893 setfilesystemencoding_doc
},
894 {"setcheckinterval", sys_setcheckinterval
, METH_VARARGS
,
895 setcheckinterval_doc
},
896 {"getcheckinterval", sys_getcheckinterval
, METH_NOARGS
,
897 getcheckinterval_doc
},
899 {"setdlopenflags", sys_setdlopenflags
, METH_VARARGS
,
902 {"setprofile", sys_setprofile
, METH_O
, setprofile_doc
},
903 {"getprofile", sys_getprofile
, METH_NOARGS
, getprofile_doc
},
904 {"setrecursionlimit", sys_setrecursionlimit
, METH_VARARGS
,
905 setrecursionlimit_doc
},
907 {"settscdump", sys_settscdump
, METH_VARARGS
, settscdump_doc
},
909 {"settrace", sys_settrace
, METH_O
, settrace_doc
},
910 {"gettrace", sys_gettrace
, METH_NOARGS
, gettrace_doc
},
911 {"call_tracing", sys_call_tracing
, METH_VARARGS
, call_tracing_doc
},
912 {NULL
, NULL
} /* sentinel */
916 list_builtin_module_names(void)
918 PyObject
*list
= PyList_New(0);
922 for (i
= 0; PyImport_Inittab
[i
].name
!= NULL
; i
++) {
923 PyObject
*name
= PyUnicode_FromString(
924 PyImport_Inittab
[i
].name
);
927 PyList_Append(list
, name
);
930 if (PyList_Sort(list
) != 0) {
935 PyObject
*v
= PyList_AsTuple(list
);
942 static PyObject
*warnoptions
= NULL
;
945 PySys_ResetWarnOptions(void)
947 if (warnoptions
== NULL
|| !PyList_Check(warnoptions
))
949 PyList_SetSlice(warnoptions
, 0, PyList_GET_SIZE(warnoptions
), NULL
);
953 PySys_AddWarnOption(const wchar_t *s
)
957 if (warnoptions
== NULL
|| !PyList_Check(warnoptions
)) {
958 Py_XDECREF(warnoptions
);
959 warnoptions
= PyList_New(0);
960 if (warnoptions
== NULL
)
963 str
= PyUnicode_FromWideChar(s
, -1);
965 PyList_Append(warnoptions
, str
);
971 PySys_HasWarnOptions(void)
973 return (warnoptions
!= NULL
&& (PyList_Size(warnoptions
) > 0)) ? 1 : 0;
976 /* XXX This doc string is too long to be a single string literal in VC++ 5.0.
977 Two literals concatenated works just fine. If you have a K&R compiler
978 or other abomination that however *does* understand longer strings,
979 get rid of the !!! comment in the middle and the quotes that surround it. */
982 "This module provides access to some objects used or maintained by the\n\
983 interpreter and to functions that interact strongly with the interpreter.\n\
987 argv -- command line arguments; argv[0] is the script pathname if known\n\
988 path -- module search path; path[0] is the script directory, else ''\n\
989 modules -- dictionary of loaded modules\n\
991 displayhook -- called to show results in an interactive session\n\
992 excepthook -- called to handle any uncaught exception other than SystemExit\n\
993 To customize printing in an interactive session or to install a custom\n\
994 top-level exception handler, assign other functions to replace these.\n\
996 stdin -- standard input file object; used by input()\n\
997 stdout -- standard output file object; used by print()\n\
998 stderr -- standard error object; used for error messages\n\
999 By assigning other file objects (or objects that behave like files)\n\
1000 to these, it is possible to redirect all of the interpreter's I/O.\n\
1002 last_type -- type of last uncaught exception\n\
1003 last_value -- value of last uncaught exception\n\
1004 last_traceback -- traceback of last uncaught exception\n\
1005 These three are only available in an interactive session after a\n\
1006 traceback has been printed.\n\
1009 /* concatenating string here */
1014 float_info -- a dict with information about the float implementation.\n\
1015 int_info -- a struct sequence with information about the int implementation.\n\
1016 maxsize -- the largest supported length of containers.\n\
1017 maxunicode -- the largest supported character\n\
1018 builtin_module_names -- tuple of module names built into this interpreter\n\
1019 subversion -- subversion information of the build as tuple\n\
1020 version -- the version of this interpreter as a string\n\
1021 version_info -- version information as a named tuple\n\
1022 hexversion -- version information encoded as a single integer\n\
1023 copyright -- copyright notice pertaining to this interpreter\n\
1024 platform -- platform identifier\n\
1025 executable -- pathname of this Python interpreter\n\
1026 prefix -- prefix used to find the Python library\n\
1027 exec_prefix -- prefix used to find the machine-specific Python library\n\
1028 float_repr_style -- string indicating the style of repr() output for floats\n\
1032 /* concatenating string here */
1034 "dllhandle -- [Windows only] integer handle of the Python DLL\n\
1035 winver -- [Windows only] version number of the Python DLL\n\
1038 #endif /* MS_WINDOWS */
1040 "__stdin__ -- the original stdin; don't touch!\n\
1041 __stdout__ -- the original stdout; don't touch!\n\
1042 __stderr__ -- the original stderr; don't touch!\n\
1043 __displayhook__ -- the original displayhook; don't touch!\n\
1044 __excepthook__ -- the original excepthook; don't touch!\n\
1048 displayhook() -- print an object to the screen, and save it in builtins._\n\
1049 excepthook() -- print an exception and its traceback to sys.stderr\n\
1050 exc_info() -- return thread-safe information about the current exception\n\
1051 exit() -- exit the interpreter by raising SystemExit\n\
1052 getdlopenflags() -- returns flags to be used for dlopen() calls\n\
1053 getprofile() -- get the global profiling function\n\
1054 getrefcount() -- return the reference count for an object (plus one :-)\n\
1055 getrecursionlimit() -- return the max recursion depth for the interpreter\n\
1056 getsizeof() -- return the size of an object in bytes\n\
1057 gettrace() -- get the global debug tracing function\n\
1058 setcheckinterval() -- control how often the interpreter checks for events\n\
1059 setdlopenflags() -- set the flags to be used for dlopen() calls\n\
1060 setprofile() -- set the global profiling function\n\
1061 setrecursionlimit() -- set the max recursion depth for the interpreter\n\
1062 settrace() -- set the global debug tracing function\n\
1065 /* end of sys_doc */ ;
1067 /* Subversion branch and revision management */
1068 static const char _patchlevel_revision
[] = PY_PATCHLEVEL_REVISION
;
1069 static const char headurl
[] = "$HeadURL$";
1070 static int svn_initialized
;
1071 static char patchlevel_revision
[50]; /* Just the number */
1072 static char branch
[50];
1073 static char shortbranch
[50];
1074 static const char *svn_revision
;
1077 svnversion_init(void)
1079 const char *python
, *br_start
, *br_end
, *br_end2
, *svnversion
;
1083 if (svn_initialized
)
1086 python
= strstr(headurl
, "/python/");
1088 strcpy(branch
, "unknown branch");
1089 strcpy(shortbranch
, "unknown");
1092 br_start
= python
+ 8;
1093 br_end
= strchr(br_start
, '/');
1096 /* Works even for trunk,
1097 as we are in trunk/Python/sysmodule.c */
1098 br_end2
= strchr(br_end
+1, '/');
1100 istag
= strncmp(br_start
, "tags", 4) == 0;
1101 if (strncmp(br_start
, "trunk", 5) == 0) {
1102 strcpy(branch
, "trunk");
1103 strcpy(shortbranch
, "trunk");
1105 else if (istag
|| strncmp(br_start
, "branches", 8) == 0) {
1106 len
= br_end2
- br_start
;
1107 strncpy(branch
, br_start
, len
);
1110 len
= br_end2
- (br_end
+ 1);
1111 strncpy(shortbranch
, br_end
+ 1, len
);
1112 shortbranch
[len
] = '\0';
1115 Py_FatalError("bad HeadURL");
1121 svnversion
= _Py_svnversion();
1122 if (strcmp(svnversion
, "Unversioned directory") != 0 && strcmp(svnversion
, "exported") != 0)
1123 svn_revision
= svnversion
;
1125 len
= strlen(_patchlevel_revision
);
1127 assert(len
< (sizeof(patchlevel_revision
) + 13));
1128 strncpy(patchlevel_revision
, _patchlevel_revision
+ 11,
1130 patchlevel_revision
[len
- 13] = '\0';
1131 svn_revision
= patchlevel_revision
;
1136 svn_initialized
= 1;
1139 /* Return svnversion output if available.
1140 Else return Revision of patchlevel.h if on branch.
1141 Else return empty string */
1143 Py_SubversionRevision()
1146 return svn_revision
;
1150 Py_SubversionShortBranch()
1157 PyDoc_STRVAR(flags__doc__
,
1160 Flags provided through command line arguments or environment vars.");
1162 static PyTypeObject FlagsType
;
1164 static PyStructSequence_Field flags_fields
[] = {
1166 {"division_warning", "-Q"},
1168 {"interactive", "-i"},
1169 {"optimize", "-O or -OO"},
1170 {"dont_write_bytecode", "-B"},
1171 {"no_user_site", "-s"},
1173 {"ignore_environment", "-E"},
1176 {"riscos_wimp", "???"},
1178 /* {"unbuffered", "-u"}, */
1179 /* {"skip_first", "-x"}, */
1180 {"bytes_warning", "-b"},
1184 static PyStructSequence_Desc flags_desc
= {
1185 "sys.flags", /* name */
1186 flags__doc__
, /* doc */
1187 flags_fields
, /* fields */
1201 seq
= PyStructSequence_New(&FlagsType
);
1205 #define SetFlag(flag) \
1206 PyStructSequence_SET_ITEM(seq, pos++, PyLong_FromLong(flag))
1208 SetFlag(Py_DebugFlag
);
1209 SetFlag(Py_DivisionWarningFlag
);
1210 SetFlag(Py_InspectFlag
);
1211 SetFlag(Py_InteractiveFlag
);
1212 SetFlag(Py_OptimizeFlag
);
1213 SetFlag(Py_DontWriteBytecodeFlag
);
1214 SetFlag(Py_NoUserSiteDirectory
);
1215 SetFlag(Py_NoSiteFlag
);
1216 SetFlag(Py_IgnoreEnvironmentFlag
);
1217 SetFlag(Py_VerboseFlag
);
1219 SetFlag(Py_RISCOSWimpFlag
);
1221 /* SetFlag(saw_unbuffered_flag); */
1222 /* SetFlag(skipfirstline); */
1223 SetFlag(Py_BytesWarningFlag
);
1226 if (PyErr_Occurred()) {
1232 PyDoc_STRVAR(version_info__doc__
,
1233 "sys.version_info\n\
1235 Version information as a named tuple.");
1237 static PyTypeObject VersionInfoType
;
1239 static PyStructSequence_Field version_info_fields
[] = {
1240 {"major", "Major release number"},
1241 {"minor", "Minor release number"},
1242 {"micro", "Patch release number"},
1243 {"releaselevel", "'alpha', 'beta', 'candidate', or 'release'"},
1244 {"serial", "Serial release number"},
1248 static PyStructSequence_Desc version_info_desc
= {
1249 "sys.version_info", /* name */
1250 version_info__doc__
, /* doc */
1251 version_info_fields
, /* fields */
1256 make_version_info(void)
1258 PyObject
*version_info
;
1262 version_info
= PyStructSequence_New(&VersionInfoType
);
1263 if (version_info
== NULL
) {
1268 * These release level checks are mutually exclusive and cover
1269 * the field, so don't get too fancy with the pre-processor!
1271 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
1273 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
1275 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
1277 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
1281 #define SetIntItem(flag) \
1282 PyStructSequence_SET_ITEM(version_info, pos++, PyLong_FromLong(flag))
1283 #define SetStrItem(flag) \
1284 PyStructSequence_SET_ITEM(version_info, pos++, PyUnicode_FromString(flag))
1286 SetIntItem(PY_MAJOR_VERSION
);
1287 SetIntItem(PY_MINOR_VERSION
);
1288 SetIntItem(PY_MICRO_VERSION
);
1290 SetIntItem(PY_RELEASE_SERIAL
);
1294 if (PyErr_Occurred()) {
1295 Py_CLEAR(version_info
);
1298 return version_info
;
1301 static struct PyModuleDef sysmodule
= {
1302 PyModuleDef_HEAD_INIT
,
1305 -1, /* multiple "initialization" just copies the module dict. */
1316 PyObject
*m
, *v
, *sysdict
;
1319 m
= PyModule_Create(&sysmodule
);
1322 sysdict
= PyModule_GetDict(m
);
1323 #define SET_SYS_FROM_STRING(key, value) \
1326 PyDict_SetItemString(sysdict, key, v); \
1329 /* Check that stdin is not a directory
1330 Using shell redirection, you can redirect stdin to a directory,
1331 crashing the Python interpreter. Catch this common mistake here
1332 and output a useful error message. Note that under MS Windows,
1333 the shell already prevents that. */
1334 #if !defined(MS_WINDOWS)
1337 if (fstat(fileno(stdin
), &sb
) == 0 &&
1338 S_ISDIR(sb
.st_mode
)) {
1339 /* There's nothing more we can do. */
1340 /* Py_FatalError() will core dump, so just exit. */
1341 PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
1347 /* stdin/stdout/stderr are now set by pythonrun.c */
1349 PyDict_SetItemString(sysdict
, "__displayhook__",
1350 PyDict_GetItemString(sysdict
, "displayhook"));
1351 PyDict_SetItemString(sysdict
, "__excepthook__",
1352 PyDict_GetItemString(sysdict
, "excepthook"));
1353 SET_SYS_FROM_STRING("version",
1354 PyUnicode_FromString(Py_GetVersion()));
1355 SET_SYS_FROM_STRING("hexversion",
1356 PyLong_FromLong(PY_VERSION_HEX
));
1358 SET_SYS_FROM_STRING("subversion",
1359 Py_BuildValue("(UUU)", "CPython", branch
,
1361 SET_SYS_FROM_STRING("dont_write_bytecode",
1362 PyBool_FromLong(Py_DontWriteBytecodeFlag
));
1363 SET_SYS_FROM_STRING("api_version",
1364 PyLong_FromLong(PYTHON_API_VERSION
));
1365 SET_SYS_FROM_STRING("copyright",
1366 PyUnicode_FromString(Py_GetCopyright()));
1367 SET_SYS_FROM_STRING("platform",
1368 PyUnicode_FromString(Py_GetPlatform()));
1369 SET_SYS_FROM_STRING("executable",
1370 PyUnicode_FromWideChar(
1371 Py_GetProgramFullPath(), -1));
1372 SET_SYS_FROM_STRING("prefix",
1373 PyUnicode_FromWideChar(Py_GetPrefix(), -1));
1374 SET_SYS_FROM_STRING("exec_prefix",
1375 PyUnicode_FromWideChar(Py_GetExecPrefix(), -1));
1376 SET_SYS_FROM_STRING("maxsize",
1377 PyLong_FromSsize_t(PY_SSIZE_T_MAX
));
1378 SET_SYS_FROM_STRING("float_info",
1380 SET_SYS_FROM_STRING("int_info",
1382 SET_SYS_FROM_STRING("maxunicode",
1383 PyLong_FromLong(PyUnicode_GetMax()));
1384 SET_SYS_FROM_STRING("builtin_module_names",
1385 list_builtin_module_names());
1387 /* Assumes that longs are at least 2 bytes long.
1389 unsigned long number
= 1;
1392 s
= (char *) &number
;
1397 SET_SYS_FROM_STRING("byteorder",
1398 PyUnicode_FromString(value
));
1401 SET_SYS_FROM_STRING("dllhandle",
1402 PyLong_FromVoidPtr(PyWin_DLLhModule
));
1403 SET_SYS_FROM_STRING("winver",
1404 PyUnicode_FromString(PyWin_DLLVersionString
));
1406 if (warnoptions
== NULL
) {
1407 warnoptions
= PyList_New(0);
1410 Py_INCREF(warnoptions
);
1412 if (warnoptions
!= NULL
) {
1413 PyDict_SetItemString(sysdict
, "warnoptions", warnoptions
);
1417 if (VersionInfoType
.tp_name
== 0)
1418 PyStructSequence_InitType(&VersionInfoType
, &version_info_desc
);
1419 SET_SYS_FROM_STRING("version_info", make_version_info());
1420 /* prevent user from creating new instances */
1421 VersionInfoType
.tp_init
= NULL
;
1422 VersionInfoType
.tp_new
= NULL
;
1425 if (FlagsType
.tp_name
== 0)
1426 PyStructSequence_InitType(&FlagsType
, &flags_desc
);
1427 SET_SYS_FROM_STRING("flags", make_flags());
1428 /* prevent user from creating new instances */
1429 FlagsType
.tp_init
= NULL
;
1430 FlagsType
.tp_new
= NULL
;
1432 /* float repr style: 0.03 (short) vs 0.029999999999999999 (legacy) */
1433 #ifndef PY_NO_SHORT_FLOAT_REPR
1434 SET_SYS_FROM_STRING("float_repr_style",
1435 PyUnicode_FromString("short"));
1437 SET_SYS_FROM_STRING("float_repr_style",
1438 PyUnicode_FromString("legacy"));
1441 #undef SET_SYS_FROM_STRING
1442 if (PyErr_Occurred())
1448 makepathobject(const wchar_t *path
, wchar_t delim
)
1456 while ((p
= wcschr(p
, delim
)) != NULL
) {
1463 for (i
= 0; ; i
++) {
1464 p
= wcschr(path
, delim
);
1466 p
= path
+ wcslen(path
); /* End of string */
1467 w
= PyUnicode_FromWideChar(path
, (Py_ssize_t
)(p
- path
));
1472 PyList_SetItem(v
, i
, w
);
1481 PySys_SetPath(const wchar_t *path
)
1484 if ((v
= makepathobject(path
, DELIM
)) == NULL
)
1485 Py_FatalError("can't create sys.path");
1486 if (PySys_SetObject("path", v
) != 0)
1487 Py_FatalError("can't assign sys.path");
1492 makeargvobject(int argc
, wchar_t **argv
)
1495 if (argc
<= 0 || argv
== NULL
) {
1496 /* Ensure at least one (empty) argument is seen */
1497 static wchar_t *empty_argv
[1] = {L
""};
1501 av
= PyList_New(argc
);
1504 for (i
= 0; i
< argc
; i
++) {
1508 /* argv[0] is the script pathname if known */
1510 char* fn
= decc$
translate_vms(argv
[0]);
1511 if ((fn
== (char *)0) || fn
== (char *)-1)
1512 v
= PyUnicode_FromString(argv
[0]);
1514 v
= PyUnicode_FromString(
1515 decc$
translate_vms(argv
[0]));
1517 v
= PyUnicode_FromString(argv
[i
]);
1519 PyObject
*v
= PyUnicode_FromWideChar(argv
[i
], -1);
1526 PyList_SetItem(av
, i
, v
);
1532 #ifdef HAVE_REALPATH
1534 _wrealpath(const wchar_t *path
, wchar_t *resolved_path
)
1536 char cpath
[PATH_MAX
];
1537 char cresolved_path
[PATH_MAX
];
1540 r
= wcstombs(cpath
, path
, PATH_MAX
);
1541 if (r
== (size_t)-1 || r
>= PATH_MAX
) {
1545 res
= realpath(cpath
, cresolved_path
);
1548 r
= mbstowcs(resolved_path
, cresolved_path
, PATH_MAX
);
1549 if (r
== (size_t)-1 || r
>= PATH_MAX
) {
1553 return resolved_path
;
1558 PySys_SetArgv(int argc
, wchar_t **argv
)
1560 #if defined(HAVE_REALPATH)
1561 wchar_t fullpath
[MAXPATHLEN
];
1562 #elif defined(MS_WINDOWS) && !defined(MS_WINCE)
1563 wchar_t fullpath
[MAX_PATH
];
1565 PyObject
*av
= makeargvobject(argc
, argv
);
1566 PyObject
*path
= PySys_GetObject("path");
1568 Py_FatalError("no mem for sys.argv");
1569 if (PySys_SetObject("argv", av
) != 0)
1570 Py_FatalError("can't assign sys.argv");
1572 wchar_t *argv0
= argv
[0];
1576 extern int _Py_wreadlink(const wchar_t *, wchar_t *, size_t);
1577 #ifdef HAVE_READLINK
1578 wchar_t link
[MAXPATHLEN
+1];
1579 wchar_t argv0copy
[2*MAXPATHLEN
+1];
1581 if (argc
> 0 && argv0
!= NULL
&& wcscmp(argv0
, L
"-c") != 0)
1582 nr
= _Py_wreadlink(argv0
, link
, MAXPATHLEN
);
1584 /* It's a symlink */
1587 argv0
= link
; /* Link to absolute path */
1588 else if (wcschr(link
, SEP
) == NULL
)
1589 ; /* Link without path */
1591 /* Must join(dirname(argv0), link) */
1592 wchar_t *q
= wcsrchr(argv0
, SEP
);
1594 argv0
= link
; /* argv0 without path */
1596 /* Must make a copy */
1597 wcscpy(argv0copy
, argv0
);
1598 q
= wcsrchr(argv0copy
, SEP
);
1604 #endif /* HAVE_READLINK */
1605 #if SEP == '\\' /* Special case for MS filename syntax */
1606 if (argc
> 0 && argv0
!= NULL
&& wcscmp(argv0
, L
"-c") != 0) {
1608 #if defined(MS_WINDOWS) && !defined(MS_WINCE)
1609 /* This code here replaces the first element in argv with the full
1610 path that it represents. Under CE, there are no relative paths so
1611 the argument must be the full path anyway. */
1613 if (GetFullPathNameW(argv0
,
1614 sizeof(fullpath
)/sizeof(fullpath
[0]),
1620 p
= wcsrchr(argv0
, SEP
);
1621 /* Test for alternate separator */
1622 q
= wcsrchr(p
? p
: argv0
, '/');
1627 if (n
> 1 && p
[-1] != ':')
1628 n
--; /* Drop trailing separator */
1631 #else /* All other filename syntaxes */
1632 if (argc
> 0 && argv0
!= NULL
&& wcscmp(argv0
, L
"-c") != 0) {
1633 #if defined(HAVE_REALPATH)
1634 if (_wrealpath(argv0
, fullpath
)) {
1638 p
= wcsrchr(argv0
, SEP
);
1642 #if SEP == '/' /* Special case for Unix filename syntax */
1644 n
--; /* Drop trailing separator */
1647 #endif /* All others */
1648 a
= PyUnicode_FromWideChar(argv0
, n
);
1650 Py_FatalError("no mem for sys.path insertion");
1651 if (PyList_Insert(path
, 0, a
) < 0)
1652 Py_FatalError("sys.path.insert(0) failed");
1658 /* Reimplementation of PyFile_WriteString() no calling indirectly
1659 PyErr_CheckSignals(): avoid the call to PyObject_Str(). */
1662 sys_pyfile_write(const char *text
, PyObject
*file
)
1664 PyObject
*unicode
= NULL
, *writer
= NULL
, *args
= NULL
, *result
= NULL
;
1667 unicode
= PyUnicode_FromString(text
);
1668 if (unicode
== NULL
)
1671 writer
= PyObject_GetAttrString(file
, "write");
1675 args
= PyTuple_Pack(1, unicode
);
1679 result
= PyEval_CallObject(writer
, args
);
1680 if (result
== NULL
) {
1690 Py_XDECREF(unicode
);
1698 /* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
1699 Adapted from code submitted by Just van Rossum.
1701 PySys_WriteStdout(format, ...)
1702 PySys_WriteStderr(format, ...)
1704 The first function writes to sys.stdout; the second to sys.stderr. When
1705 there is a problem, they write to the real (C level) stdout or stderr;
1706 no exceptions are raised.
1708 PyErr_CheckSignals() is not called to avoid the execution of the Python
1709 signal handlers: they may raise a new exception whereas mywrite() ignores
1712 Both take a printf-style format string as their first argument followed
1713 by a variable length argument list determined by the format string.
1717 The format should limit the total size of the formatted output string to
1718 1000 bytes. In particular, this means that no unrestricted "%s" formats
1719 should occur; these should be limited using "%.<N>s where <N> is a
1720 decimal number calculated so that <N> plus the maximum size of other
1721 formatted text does not exceed 1000 bytes. Also watch out for "%f",
1722 which can print hundreds of digits for very large numbers.
1727 mywrite(char *name
, FILE *fp
, const char *format
, va_list va
)
1730 PyObject
*error_type
, *error_value
, *error_traceback
;
1734 PyErr_Fetch(&error_type
, &error_value
, &error_traceback
);
1735 file
= PySys_GetObject(name
);
1736 written
= PyOS_vsnprintf(buffer
, sizeof(buffer
), format
, va
);
1737 if (sys_pyfile_write(buffer
, file
) != 0) {
1741 if (written
< 0 || (size_t)written
>= sizeof(buffer
)) {
1742 const char *truncated
= "... truncated";
1743 if (sys_pyfile_write(truncated
, file
) != 0) {
1745 fputs(truncated
, fp
);
1748 PyErr_Restore(error_type
, error_value
, error_traceback
);
1752 PySys_WriteStdout(const char *format
, ...)
1756 va_start(va
, format
);
1757 mywrite("stdout", stdout
, format
, va
);
1762 PySys_WriteStderr(const char *format
, ...)
1766 va_start(va
, format
);
1767 mywrite("stderr", stderr
, format
, va
);