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)
19 #include "frameobject.h"
25 #define WIN32_LEAN_AND_MEAN
27 #endif /* MS_WINDOWS */
30 extern void *PyWin_DLLhModule
;
31 /* A string loaded from the DLL at startup: */
32 extern const char *PyWin_DLLVersionString
;
43 #ifdef HAVE_LANGINFO_H
49 PySys_GetObject(char *name
)
51 PyThreadState
*tstate
= PyThreadState_GET();
52 PyObject
*sd
= tstate
->interp
->sysdict
;
55 return PyDict_GetItemString(sd
, name
);
59 PySys_GetFile(char *name
, FILE *def
)
62 PyObject
*v
= PySys_GetObject(name
);
63 if (v
!= NULL
&& PyFile_Check(v
))
64 fp
= PyFile_AsFile(v
);
71 PySys_SetObject(char *name
, PyObject
*v
)
73 PyThreadState
*tstate
= PyThreadState_GET();
74 PyObject
*sd
= tstate
->interp
->sysdict
;
76 if (PyDict_GetItemString(sd
, name
) == NULL
)
79 return PyDict_DelItemString(sd
, name
);
82 return PyDict_SetItemString(sd
, name
, v
);
86 sys_displayhook(PyObject
*self
, PyObject
*o
)
89 PyInterpreterState
*interp
= PyThreadState_GET()->interp
;
90 PyObject
*modules
= interp
->modules
;
91 PyObject
*builtins
= PyDict_GetItemString(modules
, "__builtin__");
93 if (builtins
== NULL
) {
94 PyErr_SetString(PyExc_RuntimeError
, "lost __builtin__");
98 /* Print value except if None */
99 /* After printing, also assign to '_' */
100 /* Before, set '_' to None to avoid recursion */
105 if (PyObject_SetAttrString(builtins
, "_", Py_None
) != 0)
107 if (Py_FlushLine() != 0)
109 outf
= PySys_GetObject("stdout");
111 PyErr_SetString(PyExc_RuntimeError
, "lost sys.stdout");
114 if (PyFile_WriteObject(o
, outf
, 0) != 0)
116 PyFile_SoftSpace(outf
, 1);
117 if (Py_FlushLine() != 0)
119 if (PyObject_SetAttrString(builtins
, "_", o
) != 0)
125 PyDoc_STRVAR(displayhook_doc
,
126 "displayhook(object) -> None\n"
128 "Print an object to sys.stdout and also save it in __builtin__.\n"
132 sys_excepthook(PyObject
* self
, PyObject
* args
)
134 PyObject
*exc
, *value
, *tb
;
135 if (!PyArg_UnpackTuple(args
, "excepthook", 3, 3, &exc
, &value
, &tb
))
137 PyErr_Display(exc
, value
, tb
);
142 PyDoc_STRVAR(excepthook_doc
,
143 "excepthook(exctype, value, traceback) -> None\n"
145 "Handle an exception by displaying it with a traceback on sys.stderr.\n"
149 sys_exc_info(PyObject
*self
, PyObject
*noargs
)
151 PyThreadState
*tstate
;
152 tstate
= PyThreadState_GET();
153 return Py_BuildValue(
155 tstate
->exc_type
!= NULL
? tstate
->exc_type
: Py_None
,
156 tstate
->exc_value
!= NULL
? tstate
->exc_value
: Py_None
,
157 tstate
->exc_traceback
!= NULL
?
158 tstate
->exc_traceback
: Py_None
);
161 PyDoc_STRVAR(exc_info_doc
,
162 "exc_info() -> (type, value, traceback)\n\
164 Return information about the most recent exception caught by an except\n\
165 clause in the current stack frame or in an older stack frame."
169 sys_exc_clear(PyObject
*self
, PyObject
*noargs
)
171 PyThreadState
*tstate
= PyThreadState_GET();
172 PyObject
*tmp_type
, *tmp_value
, *tmp_tb
;
173 tmp_type
= tstate
->exc_type
;
174 tmp_value
= tstate
->exc_value
;
175 tmp_tb
= tstate
->exc_traceback
;
176 tstate
->exc_type
= NULL
;
177 tstate
->exc_value
= NULL
;
178 tstate
->exc_traceback
= NULL
;
179 Py_XDECREF(tmp_type
);
180 Py_XDECREF(tmp_value
);
182 /* For b/w compatibility */
183 PySys_SetObject("exc_type", Py_None
);
184 PySys_SetObject("exc_value", Py_None
);
185 PySys_SetObject("exc_traceback", Py_None
);
190 PyDoc_STRVAR(exc_clear_doc
,
191 "exc_clear() -> None\n\
193 Clear global information on the current exception. Subsequent calls to\n\
194 exc_info() will return (None,None,None) until another exception is raised\n\
195 in the current thread or the execution stack returns to a frame where\n\
196 another exception is being handled."
200 sys_exit(PyObject
*self
, PyObject
*args
)
202 PyObject
*exit_code
= 0;
203 if (!PyArg_UnpackTuple(args
, "exit", 0, 1, &exit_code
))
205 /* Raise SystemExit so callers may catch it or clean up. */
206 PyErr_SetObject(PyExc_SystemExit
, exit_code
);
210 PyDoc_STRVAR(exit_doc
,
213 Exit the interpreter by raising SystemExit(status).\n\
214 If the status is omitted or None, it defaults to zero (i.e., success).\n\
215 If the status is numeric, it will be used as the system exit status.\n\
216 If it is another kind of object, it will be printed and the system\n\
217 exit status will be one (i.e., failure)."
220 #ifdef Py_USING_UNICODE
223 sys_getdefaultencoding(PyObject
*self
)
225 return PyString_FromString(PyUnicode_GetDefaultEncoding());
228 PyDoc_STRVAR(getdefaultencoding_doc
,
229 "getdefaultencoding() -> string\n\
231 Return the current default string encoding used by the Unicode \n\
236 sys_setdefaultencoding(PyObject
*self
, PyObject
*args
)
239 if (!PyArg_ParseTuple(args
, "s:setdefaultencoding", &encoding
))
241 if (PyUnicode_SetDefaultEncoding(encoding
))
247 PyDoc_STRVAR(setdefaultencoding_doc
,
248 "setdefaultencoding(encoding)\n\
250 Set the current default string encoding used by the Unicode implementation."
254 sys_getfilesystemencoding(PyObject
*self
)
256 if (Py_FileSystemDefaultEncoding
)
257 return PyString_FromString(Py_FileSystemDefaultEncoding
);
262 PyDoc_STRVAR(getfilesystemencoding_doc
,
263 "getfilesystemencoding() -> string\n\
265 Return the encoding used to convert Unicode filenames in\n\
266 operating system filenames."
272 * Cached interned string objects used for calling the profile and
273 * trace functions. Initialized by trace_init().
275 static PyObject
*whatstrings
[7] = {NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
};
280 static char *whatnames
[7] = {"call", "exception", "line", "return",
281 "c_call", "c_exception", "c_return"};
284 for (i
= 0; i
< 7; ++i
) {
285 if (whatstrings
[i
] == NULL
) {
286 name
= PyString_InternFromString(whatnames
[i
]);
289 whatstrings
[i
] = name
;
297 call_trampoline(PyThreadState
*tstate
, PyObject
* callback
,
298 PyFrameObject
*frame
, int what
, PyObject
*arg
)
300 PyObject
*args
= PyTuple_New(3);
307 whatstr
= whatstrings
[what
];
312 PyTuple_SET_ITEM(args
, 0, (PyObject
*)frame
);
313 PyTuple_SET_ITEM(args
, 1, whatstr
);
314 PyTuple_SET_ITEM(args
, 2, arg
);
316 /* call the Python-level function */
317 PyFrame_FastToLocals(frame
);
318 result
= PyEval_CallObject(callback
, args
);
319 PyFrame_LocalsToFast(frame
, 1);
321 PyTraceBack_Here(frame
);
329 profile_trampoline(PyObject
*self
, PyFrameObject
*frame
,
330 int what
, PyObject
*arg
)
332 PyThreadState
*tstate
= frame
->f_tstate
;
337 result
= call_trampoline(tstate
, self
, frame
, what
, arg
);
338 if (result
== NULL
) {
339 PyEval_SetProfile(NULL
, NULL
);
347 trace_trampoline(PyObject
*self
, PyFrameObject
*frame
,
348 int what
, PyObject
*arg
)
350 PyThreadState
*tstate
= frame
->f_tstate
;
354 if (what
== PyTrace_CALL
)
357 callback
= frame
->f_trace
;
358 if (callback
== NULL
)
360 result
= call_trampoline(tstate
, callback
, frame
, what
, arg
);
361 if (result
== NULL
) {
362 PyEval_SetTrace(NULL
, NULL
);
363 Py_XDECREF(frame
->f_trace
);
364 frame
->f_trace
= NULL
;
367 if (result
!= Py_None
) {
368 PyObject
*temp
= frame
->f_trace
;
369 frame
->f_trace
= NULL
;
371 frame
->f_trace
= result
;
380 sys_settrace(PyObject
*self
, PyObject
*args
)
382 if (trace_init() == -1)
385 PyEval_SetTrace(NULL
, NULL
);
387 PyEval_SetTrace(trace_trampoline
, args
);
392 PyDoc_STRVAR(settrace_doc
,
393 "settrace(function)\n\
395 Set the global debug tracing function. It will be called on each\n\
396 function call. See the debugger chapter in the library manual."
400 sys_setprofile(PyObject
*self
, PyObject
*args
)
402 if (trace_init() == -1)
405 PyEval_SetProfile(NULL
, NULL
);
407 PyEval_SetProfile(profile_trampoline
, args
);
412 PyDoc_STRVAR(setprofile_doc
,
413 "setprofile(function)\n\
415 Set the profiling function. It will be called on each function call\n\
416 and return. See the profiler chapter in the library manual."
420 sys_setcheckinterval(PyObject
*self
, PyObject
*args
)
422 if (!PyArg_ParseTuple(args
, "i:setcheckinterval", &_Py_CheckInterval
))
428 PyDoc_STRVAR(setcheckinterval_doc
,
429 "setcheckinterval(n)\n\
431 Tell the Python interpreter to check for asynchronous events every\n\
432 n instructions. This also affects how often thread switches occur."
436 sys_getcheckinterval(PyObject
*self
, PyObject
*args
)
438 return PyInt_FromLong(_Py_CheckInterval
);
441 PyDoc_STRVAR(getcheckinterval_doc
,
442 "getcheckinterval() -> current check interval; see setcheckinterval()."
447 sys_settscdump(PyObject
*self
, PyObject
*args
)
450 PyThreadState
*tstate
= PyThreadState_Get();
452 if (!PyArg_ParseTuple(args
, "i:settscdump", &bool))
455 tstate
->interp
->tscdump
= 1;
457 tstate
->interp
->tscdump
= 0;
463 PyDoc_STRVAR(settscdump_doc
,
466 If true, tell the Python interpreter to dump VM measurements to\n\
467 stderr. If false, turn off dump. The measurements are based on the\n\
468 processor's time-stamp counter."
473 sys_setrecursionlimit(PyObject
*self
, PyObject
*args
)
476 if (!PyArg_ParseTuple(args
, "i:setrecursionlimit", &new_limit
))
478 if (new_limit
<= 0) {
479 PyErr_SetString(PyExc_ValueError
,
480 "recursion limit must be positive");
483 Py_SetRecursionLimit(new_limit
);
488 PyDoc_STRVAR(setrecursionlimit_doc
,
489 "setrecursionlimit(n)\n\
491 Set the maximum depth of the Python interpreter stack to n. This\n\
492 limit prevents infinite recursion from causing an overflow of the C\n\
493 stack and crashing Python. The highest possible limit is platform-\n\
498 sys_getrecursionlimit(PyObject
*self
)
500 return PyInt_FromLong(Py_GetRecursionLimit());
503 PyDoc_STRVAR(getrecursionlimit_doc
,
504 "getrecursionlimit()\n\
506 Return the current value of the recursion limit, the maximum depth\n\
507 of the Python interpreter stack. This limit prevents infinite\n\
508 recursion from causing an overflow of the C stack and crashing Python."
512 PyDoc_STRVAR(getwindowsversion_doc
,
513 "getwindowsversion()\n\
515 Return information about the running version of Windows.\n\
516 The result is a tuple of (major, minor, build, platform, text)\n\
517 All elements are numbers, except text which is a string.\n\
518 Platform may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP\n\
523 sys_getwindowsversion(PyObject
*self
)
526 ver
.dwOSVersionInfoSize
= sizeof(ver
);
527 if (!GetVersionEx(&ver
))
528 return PyErr_SetFromWindowsErr(0);
529 return Py_BuildValue("HHHHs",
537 #endif /* MS_WINDOWS */
541 sys_setdlopenflags(PyObject
*self
, PyObject
*args
)
544 PyThreadState
*tstate
= PyThreadState_GET();
545 if (!PyArg_ParseTuple(args
, "i:setdlopenflags", &new_val
))
549 tstate
->interp
->dlopenflags
= new_val
;
554 PyDoc_STRVAR(setdlopenflags_doc
,
555 "setdlopenflags(n) -> None\n\
557 Set the flags that will be used for dlopen() calls. Among other\n\
558 things, this will enable a lazy resolving of symbols when importing\n\
559 a module, if called as sys.setdlopenflags(0)\n\
560 To share symbols across extension modules, call as\n\
561 sys.setdlopenflags(dl.RTLD_NOW|dl.RTLD_GLOBAL)"
565 sys_getdlopenflags(PyObject
*self
, PyObject
*args
)
567 PyThreadState
*tstate
= PyThreadState_GET();
570 return PyInt_FromLong(tstate
->interp
->dlopenflags
);
573 PyDoc_STRVAR(getdlopenflags_doc
,
574 "getdlopenflags() -> int\n\
576 Return the current value of the flags that are used for dlopen()\n\
577 calls. The flag constants are defined in the dl module."
582 /* Link with -lmalloc (or -lmpc) on an SGI */
586 sys_mdebug(PyObject
*self
, PyObject
*args
)
589 if (!PyArg_ParseTuple(args
, "i:mdebug", &flag
))
591 mallopt(M_DEBUG
, flag
);
595 #endif /* USE_MALLOPT */
598 sys_getrefcount(PyObject
*self
, PyObject
*arg
)
600 return PyInt_FromSsize_t(arg
->ob_refcnt
);
605 sys_gettotalrefcount(PyObject
*self
)
607 return PyInt_FromSsize_t(_Py_GetRefTotal());
609 #endif /* Py_REF_DEBUG */
611 PyDoc_STRVAR(getrefcount_doc
,
612 "getrefcount(object) -> integer\n\
614 Return the reference count of object. The count returned is generally\n\
615 one higher than you might expect, because it includes the (temporary)\n\
616 reference as an argument to getrefcount()."
621 sys_getcounts(PyObject
*self
)
623 extern PyObject
*get_counts(void);
629 PyDoc_STRVAR(getframe_doc
,
630 "_getframe([depth]) -> frameobject\n\
632 Return a frame object from the call stack. If optional integer depth is\n\
633 given, return the frame object that many calls below the top of the stack.\n\
634 If that is deeper than the call stack, ValueError is raised. The default\n\
635 for depth is zero, returning the frame at the top of the call stack.\n\
637 This function should be used for internal and specialized\n\
642 sys_getframe(PyObject
*self
, PyObject
*args
)
644 PyFrameObject
*f
= PyThreadState_GET()->frame
;
647 if (!PyArg_ParseTuple(args
, "|i:_getframe", &depth
))
650 while (depth
> 0 && f
!= NULL
) {
655 PyErr_SetString(PyExc_ValueError
,
656 "call stack is not deep enough");
663 PyDoc_STRVAR(current_frames_doc
,
664 "_current_frames() -> dictionary\n\
666 Return a dictionary mapping each current thread T's thread id to T's\n\
667 current stack frame.\n\
669 This function should be used for specialized purposes only."
673 sys_current_frames(PyObject
*self
, PyObject
*noargs
)
675 return _PyThread_CurrentFrames();
678 PyDoc_STRVAR(call_tracing_doc
,
679 "call_tracing(func, args) -> object\n\
681 Call func(*args), while tracing is enabled. The tracing state is\n\
682 saved, and restored afterwards. This is intended to be called from\n\
683 a debugger from a checkpoint, to recursively debug some other code."
687 sys_call_tracing(PyObject
*self
, PyObject
*args
)
689 PyObject
*func
, *funcargs
;
690 if (!PyArg_UnpackTuple(args
, "call_tracing", 2, 2, &func
, &funcargs
))
692 return _PyEval_CallTracing(func
, funcargs
);
695 PyDoc_STRVAR(callstats_doc
,
696 "callstats() -> tuple of integers\n\
698 Return a tuple of function call statistics, if CALL_PROFILE was defined\n\
699 when Python was built. Otherwise, return None.\n\
701 When enabled, this function returns detailed, implementation-specific\n\
702 details about the number of function calls executed. The return value is\n\
703 a 11-tuple where the entries in the tuple are counts of:\n\
704 0. all function calls\n\
705 1. calls to PyFunction_Type objects\n\
706 2. PyFunction calls that do not create an argument tuple\n\
707 3. PyFunction calls that do not create an argument tuple\n\
708 and bypass PyEval_EvalCodeEx()\n\
710 5. PyMethod calls on bound methods\n\
712 7. PyCFunction calls\n\
713 8. generator calls\n\
714 9. All other calls\n\
715 10. Number of stack pops performed by call_function()"
723 /* Defined in objects.c because it uses static globals if that file */
724 extern PyObject
*_Py_GetObjects(PyObject
*, PyObject
*);
727 #ifdef DYNAMIC_EXECUTION_PROFILE
728 /* Defined in ceval.c because it uses static globals if that file */
729 extern PyObject
*_Py_GetDXProfile(PyObject
*, PyObject
*);
736 static PyMethodDef sys_methods
[] = {
737 /* Might as well keep this in alphabetic order */
738 {"callstats", (PyCFunction
)PyEval_GetCallStats
, METH_NOARGS
,
740 {"_current_frames", sys_current_frames
, METH_NOARGS
,
742 {"displayhook", sys_displayhook
, METH_O
, displayhook_doc
},
743 {"exc_info", sys_exc_info
, METH_NOARGS
, exc_info_doc
},
744 {"exc_clear", sys_exc_clear
, METH_NOARGS
, exc_clear_doc
},
745 {"excepthook", sys_excepthook
, METH_VARARGS
, excepthook_doc
},
746 {"exit", sys_exit
, METH_VARARGS
, exit_doc
},
747 #ifdef Py_USING_UNICODE
748 {"getdefaultencoding", (PyCFunction
)sys_getdefaultencoding
,
749 METH_NOARGS
, getdefaultencoding_doc
},
752 {"getdlopenflags", (PyCFunction
)sys_getdlopenflags
, METH_NOARGS
,
756 {"getcounts", (PyCFunction
)sys_getcounts
, METH_NOARGS
},
758 #ifdef DYNAMIC_EXECUTION_PROFILE
759 {"getdxp", _Py_GetDXProfile
, METH_VARARGS
},
761 #ifdef Py_USING_UNICODE
762 {"getfilesystemencoding", (PyCFunction
)sys_getfilesystemencoding
,
763 METH_NOARGS
, getfilesystemencoding_doc
},
766 {"getobjects", _Py_GetObjects
, METH_VARARGS
},
769 {"gettotalrefcount", (PyCFunction
)sys_gettotalrefcount
, METH_NOARGS
},
771 {"getrefcount", (PyCFunction
)sys_getrefcount
, METH_O
, getrefcount_doc
},
772 {"getrecursionlimit", (PyCFunction
)sys_getrecursionlimit
, METH_NOARGS
,
773 getrecursionlimit_doc
},
774 {"_getframe", sys_getframe
, METH_VARARGS
, getframe_doc
},
776 {"getwindowsversion", (PyCFunction
)sys_getwindowsversion
, METH_NOARGS
,
777 getwindowsversion_doc
},
778 #endif /* MS_WINDOWS */
780 {"mdebug", sys_mdebug
, METH_VARARGS
},
782 #ifdef Py_USING_UNICODE
783 {"setdefaultencoding", sys_setdefaultencoding
, METH_VARARGS
,
784 setdefaultencoding_doc
},
786 {"setcheckinterval", sys_setcheckinterval
, METH_VARARGS
,
787 setcheckinterval_doc
},
788 {"getcheckinterval", sys_getcheckinterval
, METH_NOARGS
,
789 getcheckinterval_doc
},
791 {"setdlopenflags", sys_setdlopenflags
, METH_VARARGS
,
794 {"setprofile", sys_setprofile
, METH_O
, setprofile_doc
},
795 {"setrecursionlimit", sys_setrecursionlimit
, METH_VARARGS
,
796 setrecursionlimit_doc
},
798 {"settscdump", sys_settscdump
, METH_VARARGS
, settscdump_doc
},
800 {"settrace", sys_settrace
, METH_O
, settrace_doc
},
801 {"call_tracing", sys_call_tracing
, METH_VARARGS
, call_tracing_doc
},
802 {NULL
, NULL
} /* sentinel */
806 list_builtin_module_names(void)
808 PyObject
*list
= PyList_New(0);
812 for (i
= 0; PyImport_Inittab
[i
].name
!= NULL
; i
++) {
813 PyObject
*name
= PyString_FromString(
814 PyImport_Inittab
[i
].name
);
817 PyList_Append(list
, name
);
820 if (PyList_Sort(list
) != 0) {
825 PyObject
*v
= PyList_AsTuple(list
);
832 static PyObject
*warnoptions
= NULL
;
835 PySys_ResetWarnOptions(void)
837 if (warnoptions
== NULL
|| !PyList_Check(warnoptions
))
839 PyList_SetSlice(warnoptions
, 0, PyList_GET_SIZE(warnoptions
), NULL
);
843 PySys_AddWarnOption(char *s
)
847 if (warnoptions
== NULL
|| !PyList_Check(warnoptions
)) {
848 Py_XDECREF(warnoptions
);
849 warnoptions
= PyList_New(0);
850 if (warnoptions
== NULL
)
853 str
= PyString_FromString(s
);
855 PyList_Append(warnoptions
, str
);
860 /* XXX This doc string is too long to be a single string literal in VC++ 5.0.
861 Two literals concatenated works just fine. If you have a K&R compiler
862 or other abomination that however *does* understand longer strings,
863 get rid of the !!! comment in the middle and the quotes that surround it. */
866 "This module provides access to some objects used or maintained by the\n\
867 interpreter and to functions that interact strongly with the interpreter.\n\
871 argv -- command line arguments; argv[0] is the script pathname if known\n\
872 path -- module search path; path[0] is the script directory, else ''\n\
873 modules -- dictionary of loaded modules\n\
875 displayhook -- called to show results in an interactive session\n\
876 excepthook -- called to handle any uncaught exception other than SystemExit\n\
877 To customize printing in an interactive session or to install a custom\n\
878 top-level exception handler, assign other functions to replace these.\n\
880 exitfunc -- if sys.exitfunc exists, this routine is called when Python exits\n\
881 Assigning to sys.exitfunc is deprecated; use the atexit module instead.\n\
883 stdin -- standard input file object; used by raw_input() and input()\n\
884 stdout -- standard output file object; used by the print statement\n\
885 stderr -- standard error object; used for error messages\n\
886 By assigning other file objects (or objects that behave like files)\n\
887 to these, it is possible to redirect all of the interpreter's I/O.\n\
889 last_type -- type of last uncaught exception\n\
890 last_value -- value of last uncaught exception\n\
891 last_traceback -- traceback of last uncaught exception\n\
892 These three are only available in an interactive session after a\n\
893 traceback has been printed.\n\
895 exc_type -- type of exception currently being handled\n\
896 exc_value -- value of exception currently being handled\n\
897 exc_traceback -- traceback of exception currently being handled\n\
898 The function exc_info() should be used instead of these three,\n\
899 because it is thread-safe.\n\
902 /* concatenating string here */
907 maxint -- the largest supported integer (the smallest is -maxint-1)\n\
908 maxunicode -- the largest supported character\n\
909 builtin_module_names -- tuple of module names built into this interpreter\n\
910 version -- the version of this interpreter as a string\n\
911 version_info -- version information as a tuple\n\
912 hexversion -- version information encoded as a single integer\n\
913 copyright -- copyright notice pertaining to this interpreter\n\
914 platform -- platform identifier\n\
915 executable -- pathname of this Python interpreter\n\
916 prefix -- prefix used to find the Python library\n\
917 exec_prefix -- prefix used to find the machine-specific Python library\n\
921 /* concatenating string here */
923 "dllhandle -- [Windows only] integer handle of the Python DLL\n\
924 winver -- [Windows only] version number of the Python DLL\n\
927 #endif /* MS_WINDOWS */
929 "__stdin__ -- the original stdin; don't touch!\n\
930 __stdout__ -- the original stdout; don't touch!\n\
931 __stderr__ -- the original stderr; don't touch!\n\
932 __displayhook__ -- the original displayhook; don't touch!\n\
933 __excepthook__ -- the original excepthook; don't touch!\n\
937 displayhook() -- print an object to the screen, and save it in __builtin__._\n\
938 excepthook() -- print an exception and its traceback to sys.stderr\n\
939 exc_info() -- return thread-safe information about the current exception\n\
940 exc_clear() -- clear the exception state for the current thread\n\
941 exit() -- exit the interpreter by raising SystemExit\n\
942 getdlopenflags() -- returns flags to be used for dlopen() calls\n\
943 getrefcount() -- return the reference count for an object (plus one :-)\n\
944 getrecursionlimit() -- return the max recursion depth for the interpreter\n\
945 setcheckinterval() -- control how often the interpreter checks for events\n\
946 setdlopenflags() -- set the flags to be used for dlopen() calls\n\
947 setprofile() -- set the global profiling function\n\
948 setrecursionlimit() -- set the max recursion depth for the interpreter\n\
949 settrace() -- set the global debug tracing function\n\
952 /* end of sys_doc */ ;
955 _check_and_flush (FILE *stream
)
957 int prev_fail
= ferror (stream
);
958 return fflush (stream
) || prev_fail
? EOF
: 0;
961 /* Subversion branch and revision management */
962 static const char _patchlevel_revision
[] = PY_PATCHLEVEL_REVISION
;
963 static const char headurl
[] = "$HeadURL$";
964 static int svn_initialized
;
965 static char patchlevel_revision
[50]; /* Just the number */
966 static char branch
[50];
967 static char shortbranch
[50];
968 static const char *svn_revision
;
971 svnversion_init(void)
973 const char *python
, *br_start
, *br_end
, *br_end2
, *svnversion
;
980 python
= strstr(headurl
, "/python/");
982 Py_FatalError("subversion keywords missing");
984 br_start
= python
+ 8;
985 br_end
= strchr(br_start
, '/');
988 /* Works even for trunk,
989 as we are in trunk/Python/sysmodule.c */
990 br_end2
= strchr(br_end
+1, '/');
992 istag
= strncmp(br_start
, "tags", 4) == 0;
993 if (strncmp(br_start
, "trunk", 5) == 0) {
994 strcpy(branch
, "trunk");
995 strcpy(shortbranch
, "trunk");
998 else if (istag
|| strncmp(br_start
, "branches", 8) == 0) {
999 len
= br_end2
- br_start
;
1001 assert(len
< (sizeof(patchlevel_revision
) - 13));
1002 strncpy(branch
, br_start
, len
);
1005 len
= br_end2
- (br_end
+ 1);
1006 strncpy(shortbranch
, br_end
+ 1, len
);
1007 shortbranch
[len
] = '\0';
1010 Py_FatalError("bad HeadURL");
1015 svnversion
= _Py_svnversion();
1016 if (strcmp(svnversion
, "exported") != 0)
1017 svn_revision
= svnversion
;
1019 len
= strlen(_patchlevel_revision
);
1020 strncpy(patchlevel_revision
, _patchlevel_revision
+ 11,
1022 patchlevel_revision
[len
- 13] = '\0';
1023 svn_revision
= patchlevel_revision
;
1028 svn_initialized
= 1;
1031 /* Return svnversion output if available.
1032 Else return Revision of patchlevel.h if on branch.
1033 Else return empty string */
1035 Py_SubversionRevision()
1038 return svn_revision
;
1042 Py_SubversionShortBranch()
1051 PyObject
*m
, *v
, *sysdict
;
1052 PyObject
*sysin
, *sysout
, *syserr
;
1058 m
= Py_InitModule3("sys", sys_methods
, sys_doc
);
1061 sysdict
= PyModule_GetDict(m
);
1064 /* XXX: does this work on Win/Win64? (see posix_fstat) */
1066 if (fstat(fileno(stdin
), &sb
) == 0 &&
1067 S_ISDIR(sb
.st_mode
)) {
1068 /* There's nothing more we can do. */
1069 /* Py_FatalError() will core dump, so just exit. */
1070 PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
1075 /* Closing the standard FILE* if sys.std* goes aways causes problems
1076 * for embedded Python usages. Closing them when somebody explicitly
1077 * invokes .close() might be possible, but the FAQ promises they get
1078 * never closed. However, we still need to get write errors when
1079 * writing fails (e.g. because stdout is redirected), so we flush the
1080 * streams and check for errors before the file objects are deleted.
1081 * On OS X, fflush()ing stdin causes an error, so we exempt stdin
1082 * from that procedure.
1084 sysin
= PyFile_FromFile(stdin
, "<stdin>", "r", NULL
);
1085 sysout
= PyFile_FromFile(stdout
, "<stdout>", "w", _check_and_flush
);
1086 syserr
= PyFile_FromFile(stderr
, "<stderr>", "w", _check_and_flush
);
1087 if (PyErr_Occurred())
1090 if(isatty(_fileno(stdin
))){
1091 sprintf(buf
, "cp%d", GetConsoleCP());
1092 if (!PyFile_SetEncoding(sysin
, buf
))
1095 if(isatty(_fileno(stdout
))) {
1096 sprintf(buf
, "cp%d", GetConsoleOutputCP());
1097 if (!PyFile_SetEncoding(sysout
, buf
))
1100 if(isatty(_fileno(stderr
))) {
1101 sprintf(buf
, "cp%d", GetConsoleOutputCP());
1102 if (!PyFile_SetEncoding(syserr
, buf
))
1107 PyDict_SetItemString(sysdict
, "stdin", sysin
);
1108 PyDict_SetItemString(sysdict
, "stdout", sysout
);
1109 PyDict_SetItemString(sysdict
, "stderr", syserr
);
1110 /* Make backup copies for cleanup */
1111 PyDict_SetItemString(sysdict
, "__stdin__", sysin
);
1112 PyDict_SetItemString(sysdict
, "__stdout__", sysout
);
1113 PyDict_SetItemString(sysdict
, "__stderr__", syserr
);
1114 PyDict_SetItemString(sysdict
, "__displayhook__",
1115 PyDict_GetItemString(sysdict
, "displayhook"));
1116 PyDict_SetItemString(sysdict
, "__excepthook__",
1117 PyDict_GetItemString(sysdict
, "excepthook"));
1121 PyDict_SetItemString(sysdict
, "version",
1122 v
= PyString_FromString(Py_GetVersion()));
1124 PyDict_SetItemString(sysdict
, "hexversion",
1125 v
= PyInt_FromLong(PY_VERSION_HEX
));
1128 v
= Py_BuildValue("(ssz)", "CPython", branch
, svn_revision
);
1129 PyDict_SetItemString(sysdict
, "subversion", v
);
1132 * These release level checks are mutually exclusive and cover
1133 * the field, so don't get too fancy with the pre-processor!
1135 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
1137 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
1139 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
1141 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
1145 #define SET_SYS_FROM_STRING(key, value) \
1148 PyDict_SetItemString(sysdict, key, v); \
1151 SET_SYS_FROM_STRING("version_info",
1152 Py_BuildValue("iiisi", PY_MAJOR_VERSION
,
1154 PY_MICRO_VERSION
, s
,
1155 PY_RELEASE_SERIAL
));
1156 SET_SYS_FROM_STRING("api_version",
1157 PyInt_FromLong(PYTHON_API_VERSION
));
1158 SET_SYS_FROM_STRING("copyright",
1159 PyString_FromString(Py_GetCopyright()));
1160 SET_SYS_FROM_STRING("platform",
1161 PyString_FromString(Py_GetPlatform()));
1162 SET_SYS_FROM_STRING("executable",
1163 PyString_FromString(Py_GetProgramFullPath()));
1164 SET_SYS_FROM_STRING("prefix",
1165 PyString_FromString(Py_GetPrefix()));
1166 SET_SYS_FROM_STRING("exec_prefix",
1167 PyString_FromString(Py_GetExecPrefix()));
1168 SET_SYS_FROM_STRING("maxint",
1169 PyInt_FromLong(PyInt_GetMax()));
1170 #ifdef Py_USING_UNICODE
1171 SET_SYS_FROM_STRING("maxunicode",
1172 PyInt_FromLong(PyUnicode_GetMax()));
1174 SET_SYS_FROM_STRING("builtin_module_names",
1175 list_builtin_module_names());
1177 /* Assumes that longs are at least 2 bytes long.
1179 unsigned long number
= 1;
1182 s
= (char *) &number
;
1187 SET_SYS_FROM_STRING("byteorder",
1188 PyString_FromString(value
));
1191 SET_SYS_FROM_STRING("dllhandle",
1192 PyLong_FromVoidPtr(PyWin_DLLhModule
));
1193 SET_SYS_FROM_STRING("winver",
1194 PyString_FromString(PyWin_DLLVersionString
));
1196 #undef SET_SYS_FROM_STRING
1197 if (warnoptions
== NULL
) {
1198 warnoptions
= PyList_New(0);
1201 Py_INCREF(warnoptions
);
1203 if (warnoptions
!= NULL
) {
1204 PyDict_SetItemString(sysdict
, "warnoptions", warnoptions
);
1207 if (PyErr_Occurred())
1213 makepathobject(char *path
, int delim
)
1221 while ((p
= strchr(p
, delim
)) != NULL
) {
1228 for (i
= 0; ; i
++) {
1229 p
= strchr(path
, delim
);
1231 p
= strchr(path
, '\0'); /* End of string */
1232 w
= PyString_FromStringAndSize(path
, (Py_ssize_t
) (p
- path
));
1237 PyList_SetItem(v
, i
, w
);
1246 PySys_SetPath(char *path
)
1249 if ((v
= makepathobject(path
, DELIM
)) == NULL
)
1250 Py_FatalError("can't create sys.path");
1251 if (PySys_SetObject("path", v
) != 0)
1252 Py_FatalError("can't assign sys.path");
1257 makeargvobject(int argc
, char **argv
)
1260 if (argc
<= 0 || argv
== NULL
) {
1261 /* Ensure at least one (empty) argument is seen */
1262 static char *empty_argv
[1] = {""};
1266 av
= PyList_New(argc
);
1269 for (i
= 0; i
< argc
; i
++) {
1273 /* argv[0] is the script pathname if known */
1275 char* fn
= decc$
translate_vms(argv
[0]);
1276 if ((fn
== (char *)0) || fn
== (char *)-1)
1277 v
= PyString_FromString(argv
[0]);
1279 v
= PyString_FromString(
1280 decc$
translate_vms(argv
[0]));
1282 v
= PyString_FromString(argv
[i
]);
1284 PyObject
*v
= PyString_FromString(argv
[i
]);
1291 PyList_SetItem(av
, i
, v
);
1298 PySys_SetArgv(int argc
, char **argv
)
1300 #if defined(HAVE_REALPATH)
1301 char fullpath
[MAXPATHLEN
];
1302 #elif defined(MS_WINDOWS)
1303 char fullpath
[MAX_PATH
];
1305 PyObject
*av
= makeargvobject(argc
, argv
);
1306 PyObject
*path
= PySys_GetObject("path");
1308 Py_FatalError("no mem for sys.argv");
1309 if (PySys_SetObject("argv", av
) != 0)
1310 Py_FatalError("can't assign sys.argv");
1312 char *argv0
= argv
[0];
1316 #ifdef HAVE_READLINK
1317 char link
[MAXPATHLEN
+1];
1318 char argv0copy
[2*MAXPATHLEN
+1];
1320 if (argc
> 0 && argv0
!= NULL
&& strcmp(argv0
, "-c") != 0)
1321 nr
= readlink(argv0
, link
, MAXPATHLEN
);
1323 /* It's a symlink */
1326 argv0
= link
; /* Link to absolute path */
1327 else if (strchr(link
, SEP
) == NULL
)
1328 ; /* Link without path */
1330 /* Must join(dirname(argv0), link) */
1331 char *q
= strrchr(argv0
, SEP
);
1333 argv0
= link
; /* argv0 without path */
1335 /* Must make a copy */
1336 strcpy(argv0copy
, argv0
);
1337 q
= strrchr(argv0copy
, SEP
);
1343 #endif /* HAVE_READLINK */
1344 #if SEP == '\\' /* Special case for MS filename syntax */
1345 if (argc
> 0 && argv0
!= NULL
&& strcmp(argv0
, "-c") != 0) {
1349 if (GetFullPathName(argv0
,
1356 p
= strrchr(argv0
, SEP
);
1357 /* Test for alternate separator */
1358 q
= strrchr(p
? p
: argv0
, '/');
1363 if (n
> 1 && p
[-1] != ':')
1364 n
--; /* Drop trailing separator */
1367 #else /* All other filename syntaxes */
1368 if (argc
> 0 && argv0
!= NULL
&& strcmp(argv0
, "-c") != 0) {
1369 #if defined(HAVE_REALPATH)
1370 if (realpath(argv0
, fullpath
)) {
1374 p
= strrchr(argv0
, SEP
);
1379 #else /* don't include trailing separator */
1382 #if SEP == '/' /* Special case for Unix filename syntax */
1384 n
--; /* Drop trailing separator */
1387 #endif /* All others */
1388 a
= PyString_FromStringAndSize(argv0
, n
);
1390 Py_FatalError("no mem for sys.path insertion");
1391 if (PyList_Insert(path
, 0, a
) < 0)
1392 Py_FatalError("sys.path.insert(0) failed");
1399 /* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
1400 Adapted from code submitted by Just van Rossum.
1402 PySys_WriteStdout(format, ...)
1403 PySys_WriteStderr(format, ...)
1405 The first function writes to sys.stdout; the second to sys.stderr. When
1406 there is a problem, they write to the real (C level) stdout or stderr;
1407 no exceptions are raised.
1409 Both take a printf-style format string as their first argument followed
1410 by a variable length argument list determined by the format string.
1414 The format should limit the total size of the formatted output string to
1415 1000 bytes. In particular, this means that no unrestricted "%s" formats
1416 should occur; these should be limited using "%.<N>s where <N> is a
1417 decimal number calculated so that <N> plus the maximum size of other
1418 formatted text does not exceed 1000 bytes. Also watch out for "%f",
1419 which can print hundreds of digits for very large numbers.
1424 mywrite(char *name
, FILE *fp
, const char *format
, va_list va
)
1427 PyObject
*error_type
, *error_value
, *error_traceback
;
1429 PyErr_Fetch(&error_type
, &error_value
, &error_traceback
);
1430 file
= PySys_GetObject(name
);
1431 if (file
== NULL
|| PyFile_AsFile(file
) == fp
)
1432 vfprintf(fp
, format
, va
);
1435 const int written
= PyOS_vsnprintf(buffer
, sizeof(buffer
),
1437 if (PyFile_WriteString(buffer
, file
) != 0) {
1441 if (written
< 0 || (size_t)written
>= sizeof(buffer
)) {
1442 const char *truncated
= "... truncated";
1443 if (PyFile_WriteString(truncated
, file
) != 0) {
1445 fputs(truncated
, fp
);
1449 PyErr_Restore(error_type
, error_value
, error_traceback
);
1453 PySys_WriteStdout(const char *format
, ...)
1457 va_start(va
, format
);
1458 mywrite("stdout", stdout
, format
, va
);
1463 PySys_WriteStderr(const char *format
, ...)
1467 va_start(va
, format
);
1468 mywrite("stderr", stderr
, format
, va
);