Context Navigation

source: python/trunk/Python/sysmodule.c@ 388

Last change on this file since 388 was 10, checked in by Yuri Dario, 15 years ago
python: merged offline changes.
Property svn:eol-style set to `native`
File size: 44.3 KB

Line
1
2	/* System module */
3
4	/*
5	Various bits of information used by the interpreter are collected in
6	module 'sys'.
7	Function member:
8	- exit(sts): raise SystemExit
9	Data members:
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)
15	*/
16
17	#include "Python.h"
18	#include "structseq.h"
19	#include "code.h"
20	#include "frameobject.h"
21	#include "eval.h"
22
23	#include "osdefs.h"
24
25	#ifdef MS_WINDOWS
26	#define WIN32_LEAN_AND_MEAN
27	#include "windows.h"
28	#endif /* MS_WINDOWS */
29
30	#ifdef MS_COREDLL
31	extern void *PyWin_DLLhModule;
32	/* A string loaded from the DLL at startup: */
33	extern const char *PyWin_DLLVersionString;
34	#endif
35
36	#ifdef __VMS
37	#include <unixlib.h>
38	#endif
39
40	#ifdef MS_WINDOWS
41	#include <windows.h>
42	#endif
43
44	#ifdef HAVE_LANGINFO_H
45	#include <locale.h>
46	#include <langinfo.h>
47	#endif
48
49	PyObject *
50	PySys_GetObject(char *name)
51	{
52	PyThreadState *tstate = PyThreadState_GET();
53	PyObject *sd = tstate->interp->sysdict;
54	if (sd == NULL)
55	return NULL;
56	return PyDict_GetItemString(sd, name);
57	}
58
59	FILE *
60	PySys_GetFile(char name, FILE def)
61	{
62	FILE *fp = NULL;
63	PyObject *v = PySys_GetObject(name);
64	if (v != NULL && PyFile_Check(v))
65	fp = PyFile_AsFile(v);
66	if (fp == NULL)
67	fp = def;
68	return fp;
69	}
70
71	int
72	PySys_SetObject(char name, PyObject v)
73	{
74	PyThreadState *tstate = PyThreadState_GET();
75	PyObject *sd = tstate->interp->sysdict;
76	if (v == NULL) {
77	if (PyDict_GetItemString(sd, name) == NULL)
78	return 0;
79	else
80	return PyDict_DelItemString(sd, name);
81	}
82	else
83	return PyDict_SetItemString(sd, name, v);
84	}
85
86	static PyObject *
87	sys_displayhook(PyObject self, PyObject o)
88	{
89	PyObject *outf;
90	PyInterpreterState *interp = PyThreadState_GET()->interp;
91	PyObject *modules = interp->modules;
92	PyObject *builtins = PyDict_GetItemString(modules, "__builtin__");
93
94	if (builtins == NULL) {
95	PyErr_SetString(PyExc_RuntimeError, "lost __builtin__");
96	return NULL;
97	}
98
99	/* Print value except if None */
100	/* After printing, also assign to '_' */
101	/* Before, set '_' to None to avoid recursion */
102	if (o == Py_None) {
103	Py_INCREF(Py_None);
104	return Py_None;
105	}
106	if (PyObject_SetAttrString(builtins, "_", Py_None) != 0)
107	return NULL;
108	if (Py_FlushLine() != 0)
109	return NULL;
110	outf = PySys_GetObject("stdout");
111	if (outf == NULL) {
112	PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
113	return NULL;
114	}
115	if (PyFile_WriteObject(o, outf, 0) != 0)
116	return NULL;
117	PyFile_SoftSpace(outf, 1);
118	if (Py_FlushLine() != 0)
119	return NULL;
120	if (PyObject_SetAttrString(builtins, "_", o) != 0)
121	return NULL;
122	Py_INCREF(Py_None);
123	return Py_None;
124	}
125
126	PyDoc_STRVAR(displayhook_doc,
127	"displayhook(object) -> None\n"
128	"\n"
129	"Print an object to sys.stdout and also save it in __builtin__.\n"
130	);
131
132	static PyObject *
133	sys_excepthook(PyObject* self, PyObject* args)
134	{
135	PyObject exc, value, *tb;
136	if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb))
137	return NULL;
138	PyErr_Display(exc, value, tb);
139	Py_INCREF(Py_None);
140	return Py_None;
141	}
142
143	PyDoc_STRVAR(excepthook_doc,
144	"excepthook(exctype, value, traceback) -> None\n"
145	"\n"
146	"Handle an exception by displaying it with a traceback on sys.stderr.\n"
147	);
148
149	static PyObject *
150	sys_exc_info(PyObject self, PyObject noargs)
151	{
152	PyThreadState *tstate;
153	tstate = PyThreadState_GET();
154	return Py_BuildValue(
155	"(OOO)",
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);
160	}
161
162	PyDoc_STRVAR(exc_info_doc,
163	"exc_info() -> (type, value, traceback)\n\
164	\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."
167	);
168
169	static PyObject *
170	sys_exc_clear(PyObject self, PyObject noargs)
171	{
172	PyThreadState *tstate;
173	PyObject tmp_type, tmp_value, *tmp_tb;
174
175	if (PyErr_WarnPy3k("sys.exc_clear() not supported in 3.x; "
176	"use except clauses", 1) < 0)
177	return NULL;
178
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);
188	Py_XDECREF(tmp_tb);
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);
193	Py_INCREF(Py_None);
194	return Py_None;
195	}
196
197	PyDoc_STRVAR(exc_clear_doc,
198	"exc_clear() -> None\n\
199	\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."
204	);
205
206	static PyObject *
207	sys_exit(PyObject self, PyObject args)
208	{
209	PyObject *exit_code = 0;
210	if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code))
211	return NULL;
212	/* Raise SystemExit so callers may catch it or clean up. */
213	PyErr_SetObject(PyExc_SystemExit, exit_code);
214	return NULL;
215	}
216
217	PyDoc_STRVAR(exit_doc,
218	"exit([status])\n\
219	\n\
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)."
225	);
226
227	#ifdef Py_USING_UNICODE
228
229	static PyObject *
230	sys_getdefaultencoding(PyObject *self)
231	{
232	return PyString_FromString(PyUnicode_GetDefaultEncoding());
233	}
234
235	PyDoc_STRVAR(getdefaultencoding_doc,
236	"getdefaultencoding() -> string\n\
237	\n\
238	Return the current default string encoding used by the Unicode \n\
239	implementation."
240	);
241
242	static PyObject *
243	sys_setdefaultencoding(PyObject self, PyObject args)
244	{
245	char *encoding;
246	if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding))
247	return NULL;
248	if (PyUnicode_SetDefaultEncoding(encoding))
249	return NULL;
250	Py_INCREF(Py_None);
251	return Py_None;
252	}
253
254	PyDoc_STRVAR(setdefaultencoding_doc,
255	"setdefaultencoding(encoding)\n\
256	\n\
257	Set the current default string encoding used by the Unicode implementation."
258	);
259
260	static PyObject *
261	sys_getfilesystemencoding(PyObject *self)
262	{
263	if (Py_FileSystemDefaultEncoding)
264	return PyString_FromString(Py_FileSystemDefaultEncoding);
265	Py_INCREF(Py_None);
266	return Py_None;
267	}
268
269	PyDoc_STRVAR(getfilesystemencoding_doc,
270	"getfilesystemencoding() -> string\n\
271	\n\
272	Return the encoding used to convert Unicode filenames in\n\
273	operating system filenames."
274	);
275
276	#endif
277
278	/*
279	* Cached interned string objects used for calling the profile and
280	* trace functions. Initialized by trace_init().
281	*/
282	static PyObject *whatstrings[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
283
284	static int
285	trace_init(void)
286	{
287	static char *whatnames[7] = {"call", "exception", "line", "return",
288	"c_call", "c_exception", "c_return"};
289	PyObject *name;
290	int i;
291	for (i = 0; i < 7; ++i) {
292	if (whatstrings[i] == NULL) {
293	name = PyString_InternFromString(whatnames[i]);
294	if (name == NULL)
295	return -1;
296	whatstrings[i] = name;
297	}
298	}
299	return 0;
300	}
301
302
303	static PyObject *
304	call_trampoline(PyThreadState tstate, PyObject callback,
305	PyFrameObject frame, int what, PyObject arg)
306	{
307	PyObject *args = PyTuple_New(3);
308	PyObject *whatstr;
309	PyObject *result;
310
311	if (args == NULL)
312	return NULL;
313	Py_INCREF(frame);
314	whatstr = whatstrings[what];
315	Py_INCREF(whatstr);
316	if (arg == NULL)
317	arg = Py_None;
318	Py_INCREF(arg);
319	PyTuple_SET_ITEM(args, 0, (PyObject *)frame);
320	PyTuple_SET_ITEM(args, 1, whatstr);
321	PyTuple_SET_ITEM(args, 2, arg);
322
323	/* call the Python-level function */
324	PyFrame_FastToLocals(frame);
325	result = PyEval_CallObject(callback, args);
326	PyFrame_LocalsToFast(frame, 1);
327	if (result == NULL)
328	PyTraceBack_Here(frame);
329
330	/* cleanup */
331	Py_DECREF(args);
332	return result;
333	}
334
335	static int
336	profile_trampoline(PyObject self, PyFrameObject frame,
337	int what, PyObject *arg)
338	{
339	PyThreadState *tstate = frame->f_tstate;
340	PyObject *result;
341
342	if (arg == NULL)
343	arg = Py_None;
344	result = call_trampoline(tstate, self, frame, what, arg);
345	if (result == NULL) {
346	PyEval_SetProfile(NULL, NULL);
347	return -1;
348	}
349	Py_DECREF(result);
350	return 0;
351	}
352
353	static int
354	trace_trampoline(PyObject self, PyFrameObject frame,
355	int what, PyObject *arg)
356	{
357	PyThreadState *tstate = frame->f_tstate;
358	PyObject *callback;
359	PyObject *result;
360
361	if (what == PyTrace_CALL)
362	callback = self;
363	else
364	callback = frame->f_trace;
365	if (callback == NULL)
366	return 0;
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;
372	return -1;
373	}
374	if (result != Py_None) {
375	PyObject *temp = frame->f_trace;
376	frame->f_trace = NULL;
377	Py_XDECREF(temp);
378	frame->f_trace = result;
379	}
380	else {
381	Py_DECREF(result);
382	}
383	return 0;
384	}
385
386	static PyObject *
387	sys_settrace(PyObject self, PyObject args)
388	{
389	if (trace_init() == -1)
390	return NULL;
391	if (args == Py_None)
392	PyEval_SetTrace(NULL, NULL);
393	else
394	PyEval_SetTrace(trace_trampoline, args);
395	Py_INCREF(Py_None);
396	return Py_None;
397	}
398
399	PyDoc_STRVAR(settrace_doc,
400	"settrace(function)\n\
401	\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."
404	);
405
406	static PyObject *
407	sys_gettrace(PyObject self, PyObject args)
408	{
409	PyThreadState *tstate = PyThreadState_GET();
410	PyObject *temp = tstate->c_traceobj;
411
412	if (temp == NULL)
413	temp = Py_None;
414	Py_INCREF(temp);
415	return temp;
416	}
417
418	PyDoc_STRVAR(gettrace_doc,
419	"gettrace()\n\
420	\n\
421	Return the global debug tracing function set with sys.settrace.\n\
422	See the debugger chapter in the library manual."
423	);
424
425	static PyObject *
426	sys_setprofile(PyObject self, PyObject args)
427	{
428	if (trace_init() == -1)
429	return NULL;
430	if (args == Py_None)
431	PyEval_SetProfile(NULL, NULL);
432	else
433	PyEval_SetProfile(profile_trampoline, args);
434	Py_INCREF(Py_None);
435	return Py_None;
436	}
437
438	PyDoc_STRVAR(setprofile_doc,
439	"setprofile(function)\n\
440	\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."
443	);
444
445	static PyObject *
446	sys_getprofile(PyObject self, PyObject args)
447	{
448	PyThreadState *tstate = PyThreadState_GET();
449	PyObject *temp = tstate->c_profileobj;
450
451	if (temp == NULL)
452	temp = Py_None;
453	Py_INCREF(temp);
454	return temp;
455	}
456
457	PyDoc_STRVAR(getprofile_doc,
458	"getprofile()\n\
459	\n\
460	Return the profiling function set with sys.setprofile.\n\
461	See the profiler chapter in the library manual."
462	);
463
464	static PyObject *
465	sys_setcheckinterval(PyObject self, PyObject args)
466	{
467	if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval))
468	return NULL;
469	Py_INCREF(Py_None);
470	return Py_None;
471	}
472
473	PyDoc_STRVAR(setcheckinterval_doc,
474	"setcheckinterval(n)\n\
475	\n\
476	Tell the Python interpreter to check for asynchronous events every\n\
477	n instructions. This also affects how often thread switches occur."
478	);
479
480	static PyObject *
481	sys_getcheckinterval(PyObject self, PyObject args)
482	{
483	return PyInt_FromLong(_Py_CheckInterval);
484	}
485
486	PyDoc_STRVAR(getcheckinterval_doc,
487	"getcheckinterval() -> current check interval; see setcheckinterval()."
488	);
489
490	#ifdef WITH_TSC
491	static PyObject *
492	sys_settscdump(PyObject self, PyObject args)
493	{
494	int bool;
495	PyThreadState *tstate = PyThreadState_Get();
496
497	if (!PyArg_ParseTuple(args, "i:settscdump", &bool))
498	return NULL;
499	if (bool)
500	tstate->interp->tscdump = 1;
501	else
502	tstate->interp->tscdump = 0;
503	Py_INCREF(Py_None);
504	return Py_None;
505
506	}
507
508	PyDoc_STRVAR(settscdump_doc,
509	"settscdump(bool)\n\
510	\n\
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."
514	);
515	#endif /* TSC */
516
517	static PyObject *
518	sys_setrecursionlimit(PyObject self, PyObject args)
519	{
520	int new_limit;
521	if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit))
522	return NULL;
523	if (new_limit <= 0) {
524	PyErr_SetString(PyExc_ValueError,
525	"recursion limit must be positive");
526	return NULL;
527	}
528	Py_SetRecursionLimit(new_limit);
529	Py_INCREF(Py_None);
530	return Py_None;
531	}
532
533	PyDoc_STRVAR(setrecursionlimit_doc,
534	"setrecursionlimit(n)\n\
535	\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\
539	dependent."
540	);
541
542	static PyObject *
543	sys_getrecursionlimit(PyObject *self)
544	{
545	return PyInt_FromLong(Py_GetRecursionLimit());
546	}
547
548	PyDoc_STRVAR(getrecursionlimit_doc,
549	"getrecursionlimit()\n\
550	\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."
554	);
555
556	#ifdef MS_WINDOWS
557	PyDoc_STRVAR(getwindowsversion_doc,
558	"getwindowsversion()\n\
559	\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\
564	"
565	);
566
567	static PyObject *
568	sys_getwindowsversion(PyObject *self)
569	{
570	OSVERSIONINFO ver;
571	ver.dwOSVersionInfoSize = sizeof(ver);
572	if (!GetVersionEx(&ver))
573	return PyErr_SetFromWindowsErr(0);
574	return Py_BuildValue("HHHHs",
575	ver.dwMajorVersion,
576	ver.dwMinorVersion,
577	ver.dwBuildNumber,
578	ver.dwPlatformId,
579	ver.szCSDVersion);
580	}
581
582	#endif /* MS_WINDOWS */
583
584	#ifdef HAVE_DLOPEN
585	static PyObject *
586	sys_setdlopenflags(PyObject self, PyObject args)
587	{
588	int new_val;
589	PyThreadState *tstate = PyThreadState_GET();
590	if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val))
591	return NULL;
592	if (!tstate)
593	return NULL;
594	tstate->interp->dlopenflags = new_val;
595	Py_INCREF(Py_None);
596	return Py_None;
597	}
598
599	PyDoc_STRVAR(setdlopenflags_doc,
600	"setdlopenflags(n) -> None\n\
601	\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)"
607	);
608
609	static PyObject *
610	sys_getdlopenflags(PyObject self, PyObject args)
611	{
612	PyThreadState *tstate = PyThreadState_GET();
613	if (!tstate)
614	return NULL;
615	return PyInt_FromLong(tstate->interp->dlopenflags);
616	}
617
618	PyDoc_STRVAR(getdlopenflags_doc,
619	"getdlopenflags() -> int\n\
620	\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."
623	);
624	#endif
625
626	#ifdef USE_MALLOPT
627	/* Link with -lmalloc (or -lmpc) on an SGI */
628	#include <malloc.h>
629
630	static PyObject *
631	sys_mdebug(PyObject self, PyObject args)
632	{
633	int flag;
634	if (!PyArg_ParseTuple(args, "i:mdebug", &flag))
635	return NULL;
636	mallopt(M_DEBUG, flag);
637	Py_INCREF(Py_None);
638	return Py_None;
639	}
640	#endif /* USE_MALLOPT */
641
642	static PyObject *
643	sys_getsizeof(PyObject self, PyObject args, PyObject *kwds)
644	{
645	PyObject *res = NULL;
646	static PyObject str__sizeof__, gc_head_size = NULL;
647	static char *kwlist[] = {"object", "default", 0};
648	PyObject o, dflt = NULL;
649
650	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O\|O:getsizeof",
651	kwlist, &o, &dflt))
652	return NULL;
653
654	/* Initialize static variable needed by _PyType_Lookup */
655	if (str__sizeof__ == NULL) {
656	str__sizeof__ = PyString_InternFromString("__sizeof__");
657	if (str__sizeof__ == NULL)
658	return NULL;
659	}
660
661	/* Initialize static variable for GC head size */
662	if (gc_head_size == NULL) {
663	gc_head_size = PyInt_FromSsize_t(sizeof(PyGC_Head));
664	if (gc_head_size == NULL)
665	return NULL;
666	}
667
668	/* Make sure the type is initialized. float gets initialized late */
669	if (PyType_Ready(Py_TYPE(o)) < 0)
670	return NULL;
671
672	/* Instance of old-style class */
673	if (PyInstance_Check(o))
674	res = PyInt_FromSsize_t(PyInstance_Type.tp_basicsize);
675	/* all other objects */
676	else {
677	PyObject *method = _PyType_Lookup(Py_TYPE(o),
678	str__sizeof__);
679	if (method == NULL)
680	PyErr_Format(PyExc_TypeError,
681	"Type %.100s doesn't define __sizeof__",
682	Py_TYPE(o)->tp_name);
683	else
684	res = PyObject_CallFunctionObjArgs(method, o, NULL);
685	}
686
687	/* Has a default value been given? */
688	if ((res == NULL) && (dflt != NULL) &&
689	PyErr_ExceptionMatches(PyExc_TypeError))
690	{
691	PyErr_Clear();
692	Py_INCREF(dflt);
693	return dflt;
694	}
695	else if (res == NULL)
696	return res;
697
698	/* add gc_head size */
699	if (PyObject_IS_GC(o)) {
700	PyObject *tmp = res;
701	res = PyNumber_Add(tmp, gc_head_size);
702	Py_DECREF(tmp);
703	}
704	return res;
705	}
706
707	PyDoc_STRVAR(getsizeof_doc,
708	"getsizeof(object, default) -> int\n\
709	\n\
710	Return the size of object in bytes.");
711
712	static PyObject *
713	sys_getrefcount(PyObject self, PyObject arg)
714	{
715	return PyInt_FromSsize_t(arg->ob_refcnt);
716	}
717
718	#ifdef Py_REF_DEBUG
719	static PyObject *
720	sys_gettotalrefcount(PyObject *self)
721	{
722	return PyInt_FromSsize_t(_Py_GetRefTotal());
723	}
724	#endif /* Py_REF_DEBUG */
725
726	PyDoc_STRVAR(getrefcount_doc,
727	"getrefcount(object) -> integer\n\
728	\n\
729	Return the reference count of object. The count returned is generally\n\
730	one higher than you might expect, because it includes the (temporary)\n\
731	reference as an argument to getrefcount()."
732	);
733
734	#ifdef COUNT_ALLOCS
735	static PyObject *
736	sys_getcounts(PyObject *self)
737	{
738	extern PyObject *get_counts(void);
739
740	return get_counts();
741	}
742	#endif
743
744	PyDoc_STRVAR(getframe_doc,
745	"_getframe([depth]) -> frameobject\n\
746	\n\
747	Return a frame object from the call stack. If optional integer depth is\n\
748	given, return the frame object that many calls below the top of the stack.\n\
749	If that is deeper than the call stack, ValueError is raised. The default\n\
750	for depth is zero, returning the frame at the top of the call stack.\n\
751	\n\
752	This function should be used for internal and specialized\n\
753	purposes only."
754	);
755
756	static PyObject *
757	sys_getframe(PyObject self, PyObject args)
758	{
759	PyFrameObject *f = PyThreadState_GET()->frame;
760	int depth = -1;
761
762	if (!PyArg_ParseTuple(args, "\|i:_getframe", &depth))
763	return NULL;
764
765	while (depth > 0 && f != NULL) {
766	f = f->f_back;
767	--depth;
768	}
769	if (f == NULL) {
770	PyErr_SetString(PyExc_ValueError,
771	"call stack is not deep enough");
772	return NULL;
773	}
774	Py_INCREF(f);
775	return (PyObject*)f;
776	}
777
778	PyDoc_STRVAR(current_frames_doc,
779	"_current_frames() -> dictionary\n\
780	\n\
781	Return a dictionary mapping each current thread T's thread id to T's\n\
782	current stack frame.\n\
783	\n\
784	This function should be used for specialized purposes only."
785	);
786
787	static PyObject *
788	sys_current_frames(PyObject self, PyObject noargs)
789	{
790	return _PyThread_CurrentFrames();
791	}
792
793	PyDoc_STRVAR(call_tracing_doc,
794	"call_tracing(func, args) -> object\n\
795	\n\
796	Call func(*args), while tracing is enabled. The tracing state is\n\
797	saved, and restored afterwards. This is intended to be called from\n\
798	a debugger from a checkpoint, to recursively debug some other code."
799	);
800
801	static PyObject *
802	sys_call_tracing(PyObject self, PyObject args)
803	{
804	PyObject func, funcargs;
805	if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs))
806	return NULL;
807	return _PyEval_CallTracing(func, funcargs);
808	}
809
810	PyDoc_STRVAR(callstats_doc,
811	"callstats() -> tuple of integers\n\
812	\n\
813	Return a tuple of function call statistics, if CALL_PROFILE was defined\n\
814	when Python was built. Otherwise, return None.\n\
815	\n\
816	When enabled, this function returns detailed, implementation-specific\n\
817	details about the number of function calls executed. The return value is\n\
818	a 11-tuple where the entries in the tuple are counts of:\n\
819	0. all function calls\n\
820	1. calls to PyFunction_Type objects\n\
821	2. PyFunction calls that do not create an argument tuple\n\
822	3. PyFunction calls that do not create an argument tuple\n\
823	and bypass PyEval_EvalCodeEx()\n\
824	4. PyMethod calls\n\
825	5. PyMethod calls on bound methods\n\
826	6. PyType calls\n\
827	7. PyCFunction calls\n\
828	8. generator calls\n\
829	9. All other calls\n\
830	10. Number of stack pops performed by call_function()"
831	);
832
833	#ifdef __cplusplus
834	extern "C" {
835	#endif
836
837	#ifdef Py_TRACE_REFS
838	/* Defined in objects.c because it uses static globals if that file */
839	extern PyObject _Py_GetObjects(PyObject , PyObject *);
840	#endif
841
842	#ifdef DYNAMIC_EXECUTION_PROFILE
843	/* Defined in ceval.c because it uses static globals if that file */
844	extern PyObject _Py_GetDXProfile(PyObject , PyObject *);
845	#endif
846
847	#ifdef __cplusplus
848	}
849	#endif
850
851	static PyObject *
852	sys_clear_type_cache(PyObject* self, PyObject* args)
853	{
854	PyType_ClearCache();
855	Py_RETURN_NONE;
856	}
857
858	PyDoc_STRVAR(sys_clear_type_cache__doc__,
859	"_clear_type_cache() -> None\n\
860	Clear the internal type lookup cache.");
861
862
863	static PyMethodDef sys_methods[] = {
864	/* Might as well keep this in alphabetic order */
865	{"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS,
866	callstats_doc},
867	{"_clear_type_cache", sys_clear_type_cache, METH_NOARGS,
868	sys_clear_type_cache__doc__},
869	{"_current_frames", sys_current_frames, METH_NOARGS,
870	current_frames_doc},
871	{"displayhook", sys_displayhook, METH_O, displayhook_doc},
872	{"exc_info", sys_exc_info, METH_NOARGS, exc_info_doc},
873	{"exc_clear", sys_exc_clear, METH_NOARGS, exc_clear_doc},
874	{"excepthook", sys_excepthook, METH_VARARGS, excepthook_doc},
875	{"exit", sys_exit, METH_VARARGS, exit_doc},
876	#ifdef Py_USING_UNICODE
877	{"getdefaultencoding", (PyCFunction)sys_getdefaultencoding,
878	METH_NOARGS, getdefaultencoding_doc},
879	#endif
880	#ifdef HAVE_DLOPEN
881	{"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS,
882	getdlopenflags_doc},
883	#endif
884	#ifdef COUNT_ALLOCS
885	{"getcounts", (PyCFunction)sys_getcounts, METH_NOARGS},
886	#endif
887	#ifdef DYNAMIC_EXECUTION_PROFILE
888	{"getdxp", _Py_GetDXProfile, METH_VARARGS},
889	#endif
890	#ifdef Py_USING_UNICODE
891	{"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding,
892	METH_NOARGS, getfilesystemencoding_doc},
893	#endif
894	#ifdef Py_TRACE_REFS
895	{"getobjects", _Py_GetObjects, METH_VARARGS},
896	#endif
897	#ifdef Py_REF_DEBUG
898	{"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS},
899	#endif
900	{"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
901	{"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS,
902	getrecursionlimit_doc},
903	{"getsizeof", (PyCFunction)sys_getsizeof,
904	METH_VARARGS \| METH_KEYWORDS, getsizeof_doc},
905	{"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
906	#ifdef MS_WINDOWS
907	{"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
908	getwindowsversion_doc},
909	#endif /* MS_WINDOWS */
910	#ifdef USE_MALLOPT
911	{"mdebug", sys_mdebug, METH_VARARGS},
912	#endif
913	#ifdef Py_USING_UNICODE
914	{"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS,
915	setdefaultencoding_doc},
916	#endif
917	{"setcheckinterval", sys_setcheckinterval, METH_VARARGS,
918	setcheckinterval_doc},
919	{"getcheckinterval", sys_getcheckinterval, METH_NOARGS,
920	getcheckinterval_doc},
921	#ifdef HAVE_DLOPEN
922	{"setdlopenflags", sys_setdlopenflags, METH_VARARGS,
923	setdlopenflags_doc},
924	#endif
925	{"setprofile", sys_setprofile, METH_O, setprofile_doc},
926	{"getprofile", sys_getprofile, METH_NOARGS, getprofile_doc},
927	{"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS,
928	setrecursionlimit_doc},
929	#ifdef WITH_TSC
930	{"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc},
931	#endif
932	{"settrace", sys_settrace, METH_O, settrace_doc},
933	{"gettrace", sys_gettrace, METH_NOARGS, gettrace_doc},
934	{"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},
935	{NULL, NULL} /* sentinel */
936	};
937
938	static PyObject *
939	list_builtin_module_names(void)
940	{
941	PyObject *list = PyList_New(0);
942	int i;
943	if (list == NULL)
944	return NULL;
945	for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
946	PyObject *name = PyString_FromString(
947	PyImport_Inittab[i].name);
948	if (name == NULL)
949	break;
950	PyList_Append(list, name);
951	Py_DECREF(name);
952	}
953	if (PyList_Sort(list) != 0) {
954	Py_DECREF(list);
955	list = NULL;
956	}
957	if (list) {
958	PyObject *v = PyList_AsTuple(list);
959	Py_DECREF(list);
960	list = v;
961	}
962	return list;
963	}
964
965	static PyObject *warnoptions = NULL;
966
967	void
968	PySys_ResetWarnOptions(void)
969	{
970	if (warnoptions == NULL \|\| !PyList_Check(warnoptions))
971	return;
972	PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
973	}
974
975	void
976	PySys_AddWarnOption(char *s)
977	{
978	PyObject *str;
979
980	if (warnoptions == NULL \|\| !PyList_Check(warnoptions)) {
981	Py_XDECREF(warnoptions);
982	warnoptions = PyList_New(0);
983	if (warnoptions == NULL)
984	return;
985	}
986	str = PyString_FromString(s);
987	if (str != NULL) {
988	PyList_Append(warnoptions, str);
989	Py_DECREF(str);
990	}
991	}
992
993	int
994	PySys_HasWarnOptions(void)
995	{
996	return (warnoptions != NULL && (PyList_Size(warnoptions) > 0)) ? 1 : 0;
997	}
998
999	/* XXX This doc string is too long to be a single string literal in VC++ 5.0.
1000	Two literals concatenated works just fine. If you have a K&R compiler
1001	or other abomination that however does understand longer strings,
1002	get rid of the !!! comment in the middle and the quotes that surround it. */
1003	PyDoc_VAR(sys_doc) =
1004	PyDoc_STR(
1005	"This module provides access to some objects used or maintained by the\n\
1006	interpreter and to functions that interact strongly with the interpreter.\n\
1007	\n\
1008	Dynamic objects:\n\
1009	\n\
1010	argv -- command line arguments; argv[0] is the script pathname if known\n\
1011	path -- module search path; path[0] is the script directory, else ''\n\
1012	modules -- dictionary of loaded modules\n\
1013	\n\
1014	displayhook -- called to show results in an interactive session\n\
1015	excepthook -- called to handle any uncaught exception other than SystemExit\n\
1016	To customize printing in an interactive session or to install a custom\n\
1017	top-level exception handler, assign other functions to replace these.\n\
1018	\n\
1019	exitfunc -- if sys.exitfunc exists, this routine is called when Python exits\n\
1020	Assigning to sys.exitfunc is deprecated; use the atexit module instead.\n\
1021	\n\
1022	stdin -- standard input file object; used by raw_input() and input()\n\
1023	stdout -- standard output file object; used by the print statement\n\
1024	stderr -- standard error object; used for error messages\n\
1025	By assigning other file objects (or objects that behave like files)\n\
1026	to these, it is possible to redirect all of the interpreter's I/O.\n\
1027	\n\
1028	last_type -- type of last uncaught exception\n\
1029	last_value -- value of last uncaught exception\n\
1030	last_traceback -- traceback of last uncaught exception\n\
1031	These three are only available in an interactive session after a\n\
1032	traceback has been printed.\n\
1033	\n\
1034	exc_type -- type of exception currently being handled\n\
1035	exc_value -- value of exception currently being handled\n\
1036	exc_traceback -- traceback of exception currently being handled\n\
1037	The function exc_info() should be used instead of these three,\n\
1038	because it is thread-safe.\n\
1039	"
1040	)
1041	/* concatenating string here */
1042	PyDoc_STR(
1043	"\n\
1044	Static objects:\n\
1045	\n\
1046	maxint -- the largest supported integer (the smallest is -maxint-1)\n\
1047	maxsize -- the largest supported length of containers.\n\
1048	maxunicode -- the largest supported character\n\
1049	builtin_module_names -- tuple of module names built into this interpreter\n\
1050	version -- the version of this interpreter as a string\n\
1051	version_info -- version information as a tuple\n\
1052	hexversion -- version information encoded as a single integer\n\
1053	copyright -- copyright notice pertaining to this interpreter\n\
1054	platform -- platform identifier\n\
1055	executable -- pathname of this Python interpreter\n\
1056	prefix -- prefix used to find the Python library\n\
1057	exec_prefix -- prefix used to find the machine-specific Python library\n\
1058	"
1059	)
1060	#ifdef MS_WINDOWS
1061	/* concatenating string here */
1062	PyDoc_STR(
1063	"dllhandle -- [Windows only] integer handle of the Python DLL\n\
1064	winver -- [Windows only] version number of the Python DLL\n\
1065	"
1066	)
1067	#endif /* MS_WINDOWS */
1068	PyDoc_STR(
1069	"__stdin__ -- the original stdin; don't touch!\n\
1070	__stdout__ -- the original stdout; don't touch!\n\
1071	__stderr__ -- the original stderr; don't touch!\n\
1072	__displayhook__ -- the original displayhook; don't touch!\n\
1073	__excepthook__ -- the original excepthook; don't touch!\n\
1074	\n\
1075	Functions:\n\
1076	\n\
1077	displayhook() -- print an object to the screen, and save it in __builtin__._\n\
1078	excepthook() -- print an exception and its traceback to sys.stderr\n\
1079	exc_info() -- return thread-safe information about the current exception\n\
1080	exc_clear() -- clear the exception state for the current thread\n\
1081	exit() -- exit the interpreter by raising SystemExit\n\
1082	getdlopenflags() -- returns flags to be used for dlopen() calls\n\
1083	getprofile() -- get the global profiling function\n\
1084	getrefcount() -- return the reference count for an object (plus one :-)\n\
1085	getrecursionlimit() -- return the max recursion depth for the interpreter\n\
1086	getsizeof() -- return the size of an object in bytes\n\
1087	gettrace() -- get the global debug tracing function\n\
1088	setcheckinterval() -- control how often the interpreter checks for events\n\
1089	setdlopenflags() -- set the flags to be used for dlopen() calls\n\
1090	setprofile() -- set the global profiling function\n\
1091	setrecursionlimit() -- set the max recursion depth for the interpreter\n\
1092	settrace() -- set the global debug tracing function\n\
1093	"
1094	)
1095	/* end of sys_doc */ ;
1096
1097	static int
1098	_check_and_flush (FILE *stream)
1099	{
1100	int prev_fail = ferror (stream);
1101	return fflush (stream) \|\| prev_fail ? EOF : 0;
1102	}
1103
1104	/* Subversion branch and revision management */
1105	static const char _patchlevel_revision[] = PY_PATCHLEVEL_REVISION;
1106	static const char headurl[] = "$HeadURL: http://svn.python.org/projects/python/tags/r265/Python/sysmodule.c $";
1107	static int svn_initialized;
1108	static char patchlevel_revision[50]; /* Just the number */
1109	static char branch[50];
1110	static char shortbranch[50];
1111	static const char *svn_revision;
1112
1113	static void
1114	svnversion_init(void)
1115	{
1116	const char python, br_start, br_end, br_end2, *svnversion;
1117	Py_ssize_t len;
1118	int istag;
1119
1120	if (svn_initialized)
1121	return;
1122
1123	python = strstr(headurl, "/python/");
1124	if (!python) {
1125	/* XXX quick hack to get bzr working */
1126	*patchlevel_revision = '\0';
1127	strcpy(branch, "");
1128	strcpy(shortbranch, "unknown");
1129	svn_revision = "";
1130	return;
1131	/* Py_FatalError("subversion keywords missing"); */
1132	}
1133
1134	br_start = python + 8;
1135	br_end = strchr(br_start, '/');
1136	assert(br_end);
1137
1138	/* Works even for trunk,
1139	as we are in trunk/Python/sysmodule.c */
1140	br_end2 = strchr(br_end+1, '/');
1141
1142	istag = strncmp(br_start, "tags", 4) == 0;
1143	if (strncmp(br_start, "trunk", 5) == 0) {
1144	strcpy(branch, "trunk");
1145	strcpy(shortbranch, "trunk");
1146
1147	}
1148	else if (istag \|\| strncmp(br_start, "branches", 8) == 0) {
1149	len = br_end2 - br_start;
1150	strncpy(branch, br_start, len);
1151	branch[len] = '\0';
1152
1153	len = br_end2 - (br_end + 1);
1154	strncpy(shortbranch, br_end + 1, len);
1155	shortbranch[len] = '\0';
1156	}
1157	else {
1158	Py_FatalError("bad HeadURL");
1159	return;
1160	}
1161
1162
1163	svnversion = _Py_svnversion();
1164	if (strcmp(svnversion, "Unversioned directory") != 0 && strcmp(svnversion, "exported") != 0)
1165	svn_revision = svnversion;
1166	else if (istag) {
1167	len = strlen(_patchlevel_revision);
1168	assert(len >= 13);
1169	assert(len < (sizeof(patchlevel_revision) + 13));
1170	strncpy(patchlevel_revision, _patchlevel_revision + 11,
1171	len - 13);
1172	patchlevel_revision[len - 13] = '\0';
1173	svn_revision = patchlevel_revision;
1174	}
1175	else
1176	svn_revision = "";
1177
1178	svn_initialized = 1;
1179	}
1180
1181	/* Return svnversion output if available.
1182	Else return Revision of patchlevel.h if on branch.
1183	Else return empty string */
1184	const char*
1185	Py_SubversionRevision()
1186	{
1187	svnversion_init();
1188	return svn_revision;
1189	}
1190
1191	const char*
1192	Py_SubversionShortBranch()
1193	{
1194	svnversion_init();
1195	return shortbranch;
1196	}
1197
1198
1199	PyDoc_STRVAR(flags__doc__,
1200	"sys.flags\n\
1201	\n\
1202	Flags provided through command line arguments or environment vars.");
1203
1204	static PyTypeObject FlagsType = {0, 0, 0, 0, 0, 0};
1205
1206	static PyStructSequence_Field flags_fields[] = {
1207	{"debug", "-d"},
1208	{"py3k_warning", "-3"},
1209	{"division_warning", "-Q"},
1210	{"division_new", "-Qnew"},
1211	{"inspect", "-i"},
1212	{"interactive", "-i"},
1213	{"optimize", "-O or -OO"},
1214	{"dont_write_bytecode", "-B"},
1215	{"no_user_site", "-s"},
1216	{"no_site", "-S"},
1217	{"ignore_environment", "-E"},
1218	{"tabcheck", "-t or -tt"},
1219	{"verbose", "-v"},
1220	#ifdef RISCOS
1221	{"riscos_wimp", "???"},
1222	#endif
1223	/* {"unbuffered", "-u"}, */
1224	{"unicode", "-U"},
1225	/* {"skip_first", "-x"}, */
1226	{"bytes_warning", "-b"},
1227	{0}
1228	};
1229
1230	static PyStructSequence_Desc flags_desc = {
1231	"sys.flags", /* name */
1232	flags__doc__, /* doc */
1233	flags_fields, /* fields */
1234	#ifdef RISCOS
1235	16
1236	#else
1237	15
1238	#endif
1239	};
1240
1241	static PyObject*
1242	make_flags(void)
1243	{
1244	int pos = 0;
1245	PyObject *seq;
1246
1247	seq = PyStructSequence_New(&FlagsType);
1248	if (seq == NULL)
1249	return NULL;
1250
1251	#define SetFlag(flag) \
1252	PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag))
1253
1254	SetFlag(Py_DebugFlag);
1255	SetFlag(Py_Py3kWarningFlag);
1256	SetFlag(Py_DivisionWarningFlag);
1257	SetFlag(_Py_QnewFlag);
1258	SetFlag(Py_InspectFlag);
1259	SetFlag(Py_InteractiveFlag);
1260	SetFlag(Py_OptimizeFlag);
1261	SetFlag(Py_DontWriteBytecodeFlag);
1262	SetFlag(Py_NoUserSiteDirectory);
1263	SetFlag(Py_NoSiteFlag);
1264	SetFlag(Py_IgnoreEnvironmentFlag);
1265	SetFlag(Py_TabcheckFlag);
1266	SetFlag(Py_VerboseFlag);
1267	#ifdef RISCOS
1268	SetFlag(Py_RISCOSWimpFlag);
1269	#endif
1270	/* SetFlag(saw_unbuffered_flag); */
1271	SetFlag(Py_UnicodeFlag);
1272	/* SetFlag(skipfirstline); */
1273	SetFlag(Py_BytesWarningFlag);
1274	#undef SetFlag
1275
1276	if (PyErr_Occurred()) {
1277	return NULL;
1278	}
1279	return seq;
1280	}
1281
1282	PyObject *
1283	_PySys_Init(void)
1284	{
1285	PyObject m, v, *sysdict;
1286	PyObject sysin, sysout, *syserr;
1287	char *s;
1288
1289	m = Py_InitModule3("sys", sys_methods, sys_doc);
1290	if (m == NULL)
1291	return NULL;
1292	sysdict = PyModule_GetDict(m);
1293	#define SET_SYS_FROM_STRING(key, value) \
1294	v = value; \
1295	if (v != NULL) \
1296	PyDict_SetItemString(sysdict, key, v); \
1297	Py_XDECREF(v)
1298
1299	/* Check that stdin is not a directory
1300	Using shell redirection, you can redirect stdin to a directory,
1301	crashing the Python interpreter. Catch this common mistake here
1302	and output a useful error message. Note that under MS Windows,
1303	the shell already prevents that. */
1304	#if !defined(MS_WINDOWS)
1305	{
1306	struct stat sb;
1307	if (fstat(fileno(stdin), &sb) == 0 &&
1308	S_ISDIR(sb.st_mode)) {
1309	/* There's nothing more we can do. */
1310	/* Py_FatalError() will core dump, so just exit. */
1311	PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
1312	exit(EXIT_FAILURE);
1313	}
1314	}
1315	#endif
1316
1317	/* Closing the standard FILE* if sys.std* goes aways causes problems
1318	* for embedded Python usages. Closing them when somebody explicitly
1319	* invokes .close() might be possible, but the FAQ promises they get
1320	* never closed. However, we still need to get write errors when
1321	* writing fails (e.g. because stdout is redirected), so we flush the
1322	* streams and check for errors before the file objects are deleted.
1323	* On OS X, fflush()ing stdin causes an error, so we exempt stdin
1324	* from that procedure.
1325	*/
1326	sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL);
1327	sysout = PyFile_FromFile(stdout, "<stdout>", "w", _check_and_flush);
1328	syserr = PyFile_FromFile(stderr, "<stderr>", "w", _check_and_flush);
1329	if (PyErr_Occurred())
1330	return NULL;
1331
1332	PyDict_SetItemString(sysdict, "stdin", sysin);
1333	PyDict_SetItemString(sysdict, "stdout", sysout);
1334	PyDict_SetItemString(sysdict, "stderr", syserr);
1335	/* Make backup copies for cleanup */
1336	PyDict_SetItemString(sysdict, "__stdin__", sysin);
1337	PyDict_SetItemString(sysdict, "__stdout__", sysout);
1338	PyDict_SetItemString(sysdict, "__stderr__", syserr);
1339	PyDict_SetItemString(sysdict, "__displayhook__",
1340	PyDict_GetItemString(sysdict, "displayhook"));
1341	PyDict_SetItemString(sysdict, "__excepthook__",
1342	PyDict_GetItemString(sysdict, "excepthook"));
1343	Py_XDECREF(sysin);
1344	Py_XDECREF(sysout);
1345	Py_XDECREF(syserr);
1346
1347	SET_SYS_FROM_STRING("version",
1348	PyString_FromString(Py_GetVersion()));
1349	SET_SYS_FROM_STRING("hexversion",
1350	PyInt_FromLong(PY_VERSION_HEX));
1351	svnversion_init();
1352	SET_SYS_FROM_STRING("subversion",
1353	Py_BuildValue("(ssz)", "CPython", branch,
1354	svn_revision));
1355	SET_SYS_FROM_STRING("dont_write_bytecode",
1356	PyBool_FromLong(Py_DontWriteBytecodeFlag));
1357	/*
1358	* These release level checks are mutually exclusive and cover
1359	* the field, so don't get too fancy with the pre-processor!
1360	*/
1361	#if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
1362	s = "alpha";
1363	#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
1364	s = "beta";
1365	#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
1366	s = "candidate";
1367	#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
1368	s = "final";
1369	#endif
1370
1371	SET_SYS_FROM_STRING("version_info",
1372	Py_BuildValue("iiisi", PY_MAJOR_VERSION,
1373	PY_MINOR_VERSION,
1374	PY_MICRO_VERSION, s,
1375	PY_RELEASE_SERIAL));
1376	SET_SYS_FROM_STRING("api_version",
1377	PyInt_FromLong(PYTHON_API_VERSION));
1378	SET_SYS_FROM_STRING("copyright",
1379	PyString_FromString(Py_GetCopyright()));
1380	SET_SYS_FROM_STRING("platform",
1381	PyString_FromString(Py_GetPlatform()));
1382	SET_SYS_FROM_STRING("executable",
1383	PyString_FromString(Py_GetProgramFullPath()));
1384	SET_SYS_FROM_STRING("prefix",
1385	PyString_FromString(Py_GetPrefix()));
1386	SET_SYS_FROM_STRING("exec_prefix",
1387	PyString_FromString(Py_GetExecPrefix()));
1388	SET_SYS_FROM_STRING("maxsize",
1389	PyInt_FromSsize_t(PY_SSIZE_T_MAX));
1390	SET_SYS_FROM_STRING("maxint",
1391	PyInt_FromLong(PyInt_GetMax()));
1392	SET_SYS_FROM_STRING("py3kwarning",
1393	PyBool_FromLong(Py_Py3kWarningFlag));
1394	SET_SYS_FROM_STRING("float_info",
1395	PyFloat_GetInfo());
1396	#ifdef Py_USING_UNICODE
1397	SET_SYS_FROM_STRING("maxunicode",
1398	PyInt_FromLong(PyUnicode_GetMax()));
1399	#endif
1400	SET_SYS_FROM_STRING("builtin_module_names",
1401	list_builtin_module_names());
1402	{
1403	/* Assumes that longs are at least 2 bytes long.
1404	Should be safe! */
1405	unsigned long number = 1;
1406	char *value;
1407
1408	s = (char *) &number;
1409	if (s[0] == 0)
1410	value = "big";
1411	else
1412	value = "little";
1413	SET_SYS_FROM_STRING("byteorder",
1414	PyString_FromString(value));
1415	}
1416	#ifdef MS_COREDLL
1417	SET_SYS_FROM_STRING("dllhandle",
1418	PyLong_FromVoidPtr(PyWin_DLLhModule));
1419	SET_SYS_FROM_STRING("winver",
1420	PyString_FromString(PyWin_DLLVersionString));
1421	#endif
1422	if (warnoptions == NULL) {
1423	warnoptions = PyList_New(0);
1424	}
1425	else {
1426	Py_INCREF(warnoptions);
1427	}
1428	if (warnoptions != NULL) {
1429	PyDict_SetItemString(sysdict, "warnoptions", warnoptions);
1430	}
1431
1432	if (FlagsType.tp_name == 0)
1433	PyStructSequence_InitType(&FlagsType, &flags_desc);
1434	SET_SYS_FROM_STRING("flags", make_flags());
1435	/* prevent user from creating new instances */
1436	FlagsType.tp_init = NULL;
1437	FlagsType.tp_new = NULL;
1438
1439	#undef SET_SYS_FROM_STRING
1440	if (PyErr_Occurred())
1441	return NULL;
1442	return m;
1443	}
1444
1445	static PyObject *
1446	makepathobject(char *path, int delim)
1447	{
1448	int i, n;
1449	char *p;
1450	PyObject v, w;
1451
1452	n = 1;
1453	p = path;
1454	while ((p = strchr(p, delim)) != NULL) {
1455	n++;
1456	p++;
1457	}
1458	v = PyList_New(n);
1459	if (v == NULL)
1460	return NULL;
1461	for (i = 0; ; i++) {
1462	p = strchr(path, delim);
1463	if (p == NULL)
1464	p = strchr(path, '\0'); /* End of string */
1465	w = PyString_FromStringAndSize(path, (Py_ssize_t) (p - path));
1466	if (w == NULL) {
1467	Py_DECREF(v);
1468	return NULL;
1469	}
1470	PyList_SetItem(v, i, w);
1471	if (*p == '\0')
1472	break;
1473	path = p+1;
1474	}
1475	return v;
1476	}
1477
1478	void
1479	PySys_SetPath(char *path)
1480	{
1481	PyObject *v;
1482	if ((v = makepathobject(path, DELIM)) == NULL)
1483	Py_FatalError("can't create sys.path");
1484	if (PySys_SetObject("path", v) != 0)
1485	Py_FatalError("can't assign sys.path");
1486	Py_DECREF(v);
1487	}
1488
1489	static PyObject *
1490	makeargvobject(int argc, char **argv)
1491	{
1492	PyObject *av;
1493	if (argc <= 0 \|\| argv == NULL) {
1494	/* Ensure at least one (empty) argument is seen */
1495	static char *empty_argv[1] = {""};
1496	argv = empty_argv;
1497	argc = 1;
1498	}
1499	av = PyList_New(argc);
1500	if (av != NULL) {
1501	int i;
1502	for (i = 0; i < argc; i++) {
1503	#ifdef __VMS
1504	PyObject *v;
1505
1506	/* argv[0] is the script pathname if known */
1507	if (i == 0) {
1508	char* fn = decc$translate_vms(argv[0]);
1509	if ((fn == (char )0) \|\| fn == (char )-1)
1510	v = PyString_FromString(argv[0]);
1511	else
1512	v = PyString_FromString(
1513	decc$translate_vms(argv[0]));
1514	} else
1515	v = PyString_FromString(argv[i]);
1516	#else
1517	PyObject *v = PyString_FromString(argv[i]);
1518	#endif
1519	if (v == NULL) {
1520	Py_DECREF(av);
1521	av = NULL;
1522	break;
1523	}
1524	PyList_SetItem(av, i, v);
1525	}
1526	}
1527	return av;
1528	}
1529
1530	void
1531	PySys_SetArgv(int argc, char **argv)
1532	{
1533	#if defined(HAVE_REALPATH)
1534	char fullpath[MAXPATHLEN];
1535	#elif defined(MS_WINDOWS) && !defined(MS_WINCE)
1536	char fullpath[MAX_PATH];
1537	#endif
1538	PyObject *av = makeargvobject(argc, argv);
1539	PyObject *path = PySys_GetObject("path");
1540	if (av == NULL)
1541	Py_FatalError("no mem for sys.argv");
1542	if (PySys_SetObject("argv", av) != 0)
1543	Py_FatalError("can't assign sys.argv");
1544	if (path != NULL) {
1545	char *argv0 = argv[0];
1546	char *p = NULL;
1547	Py_ssize_t n = 0;
1548	PyObject *a;
1549	#ifdef HAVE_READLINK
1550	char link[MAXPATHLEN+1];
1551	char argv0copy[2*MAXPATHLEN+1];
1552	int nr = 0;
1553	if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0)
1554	nr = readlink(argv0, link, MAXPATHLEN);
1555	if (nr > 0) {
1556	/* It's a symlink */
1557	link[nr] = '\0';
1558	if (IS_ABSPATH(link))
1559	argv0 = link; /* Link to absolute path */
1560	else if (!HAS_ANYSEP(link))
1561	; /* Link without path */
1562	else {
1563	/* Must join(dirname(argv0), link) */
1564	char *q = strrchr(argv0, SEP);
1565	#ifdef ALTSEP
1566	char *q2 = strrchr(q ? q : argv0, ALTSEP);
1567	if (q2)
1568	q = q2;
1569	#endif
1570	#ifdef DRVSEP
1571	if (!q && HAS_DRV(argv0))
1572	q = strchr(argv0, DRVSEP);
1573	#endif
1574
1575	if (q == NULL)
1576	argv0 = link; /* argv0 without path */
1577	else {
1578	/* Must make a copy */
1579	strcpy(argv0copy, argv0);
1580	q = &argv0copy[q - argv0];
1581	strcpy(q+1, link);
1582	argv0 = argv0copy;
1583	}
1584	}
1585	}
1586	#endif /* HAVE_READLINK */
1587	#if SEP == '\\' /* Special case for MS filename syntax */
1588	if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
1589	char *q;
1590	#if defined(MS_WINDOWS) && !defined(MS_WINCE)
1591	/* This code here replaces the first element in argv with the full
1592	path that it represents. Under CE, there are no relative paths so
1593	the argument must be the full path anyway. */
1594	char *ptemp;
1595	if (GetFullPathName(argv0,
1596	sizeof(fullpath),
1597	fullpath,
1598	&ptemp)) {
1599	argv0 = fullpath;
1600	}
1601	#endif
1602	p = strrchr(argv0, SEP);
1603	/* Test for alternate separator */
1604	q = strrchr(p ? p : argv0, '/');
1605	if (q != NULL)
1606	p = q;
1607	if (p != NULL) {
1608	n = p + 1 - argv0;
1609	if (n > 1 && p[-1] != ':')
1610	n--; /* Drop trailing separator */
1611	}
1612	}
1613	#else /* All other filename syntaxes */
1614	if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
1615	#if defined(HAVE_REALPATH)
1616	if (realpath(argv0, fullpath)) {
1617	argv0 = fullpath;
1618	}
1619	#endif
1620	p = strrchr(argv0, SEP);
1621	#ifdef ALTSEP
1622	{
1623	char *p2 = strrchr(p ? p : argv0, ALTSEP);
1624	if (p2 != NULL)
1625	p = p2;
1626	}
1627	#endif
1628	#ifdef DRVSEP
1629	if (p == NULL && HAS_DRV(argv0))
1630	p = strchr(argv0, DRVSEP);
1631	#endif
1632	}
1633	if (p != NULL) {
1634	#ifndef RISCOS
1635	n = p + 1 - argv0;
1636	#else /* don't include trailing separator */
1637	n = p - argv0;
1638	#endif /* RISCOS */
1639	#if SEP == '/' /* Special case for Unix filename syntax */
1640	if (n > 1)
1641	n--; /* Drop trailing separator */
1642	#endif /* Unix */
1643	}
1644	#endif /* All others */
1645	a = PyString_FromStringAndSize(argv0, n);
1646	if (a == NULL)
1647	Py_FatalError("no mem for sys.path insertion");
1648	if (PyList_Insert(path, 0, a) < 0)
1649	Py_FatalError("sys.path.insert(0) failed");
1650	Py_DECREF(a);
1651	}
1652	Py_DECREF(av);
1653	}
1654
1655
1656	/* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
1657	Adapted from code submitted by Just van Rossum.
1658
1659	PySys_WriteStdout(format, ...)
1660	PySys_WriteStderr(format, ...)
1661
1662	The first function writes to sys.stdout; the second to sys.stderr. When
1663	there is a problem, they write to the real (C level) stdout or stderr;
1664	no exceptions are raised.
1665
1666	Both take a printf-style format string as their first argument followed
1667	by a variable length argument list determined by the format string.
1668
1669	* WARNING *
1670
1671	The format should limit the total size of the formatted output string to
1672	1000 bytes. In particular, this means that no unrestricted "%s" formats
1673	should occur; these should be limited using "%.<N>s where <N> is a
1674	decimal number calculated so that <N> plus the maximum size of other
1675	formatted text does not exceed 1000 bytes. Also watch out for "%f",
1676	which can print hundreds of digits for very large numbers.
1677
1678	*/
1679
1680	static void
1681	mywrite(char name, FILE fp, const char *format, va_list va)
1682	{
1683	PyObject *file;
1684	PyObject error_type, error_value, *error_traceback;
1685
1686	PyErr_Fetch(&error_type, &error_value, &error_traceback);
1687	file = PySys_GetObject(name);
1688	if (file == NULL \|\| PyFile_AsFile(file) == fp)
1689	vfprintf(fp, format, va);
1690	else {
1691	char buffer[1001];
1692	const int written = PyOS_vsnprintf(buffer, sizeof(buffer),
1693	format, va);
1694	if (PyFile_WriteString(buffer, file) != 0) {
1695	PyErr_Clear();
1696	fputs(buffer, fp);
1697	}
1698	if (written < 0 \|\| (size_t)written >= sizeof(buffer)) {
1699	const char *truncated = "... truncated";
1700	if (PyFile_WriteString(truncated, file) != 0) {
1701	PyErr_Clear();
1702	fputs(truncated, fp);
1703	}
1704	}
1705	}
1706	PyErr_Restore(error_type, error_value, error_traceback);
1707	}
1708
1709	void
1710	PySys_WriteStdout(const char *format, ...)
1711	{
1712	va_list va;
1713
1714	va_start(va, format);
1715	mywrite("stdout", stdout, format, va);
1716	va_end(va);
1717	}
1718
1719	void
1720	PySys_WriteStderr(const char *format, ...)
1721	{
1722	va_list va;
1723
1724	va_start(va, format);
1725	mywrite("stderr", stderr, format, va);
1726	va_end(va);
1727	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: