sysmodule.c revision a01c6b3c9e6f9e0d3411051a3ff646852b37b4d6 
1
2/* System module */
3
4/*
5Various bits of information used by the interpreter are collected in
6module 'sys'.
7Function member:
8- exit(sts): raise SystemExit
9Data 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
31extern void *PyWin_DLLhModule;
32/* A string loaded from the DLL at startup: */
33extern const char *PyWin_DLLVersionString;
34#endif
35
36#ifdef __VMS
37#include <unixlib.h>
38#endif
39
40#ifdef HAVE_LANGINFO_H
41#include <locale.h>
42#include <langinfo.h>
43#endif
44
45PyObject *
46PySys_GetObject(const char *name)
47{
48    PyThreadState *tstate = PyThreadState_GET();
49    PyObject *sd = tstate->interp->sysdict;
50    if (sd == NULL)
51        return NULL;
52    return PyDict_GetItemString(sd, name);
53}
54
55int
56PySys_SetObject(const char *name, PyObject *v)
57{
58    PyThreadState *tstate = PyThreadState_GET();
59    PyObject *sd = tstate->interp->sysdict;
60    if (v == NULL) {
61        if (PyDict_GetItemString(sd, name) == NULL)
62            return 0;
63        else
64            return PyDict_DelItemString(sd, name);
65    }
66    else
67        return PyDict_SetItemString(sd, name, v);
68}
69
70static PyObject *
71sys_displayhook(PyObject *self, PyObject *o)
72{
73    PyObject *outf;
74    PyInterpreterState *interp = PyThreadState_GET()->interp;
75    PyObject *modules = interp->modules;
76    PyObject *builtins = PyDict_GetItemString(modules, "builtins");
77
78    if (builtins == NULL) {
79        PyErr_SetString(PyExc_RuntimeError, "lost builtins module");
80        return NULL;
81    }
82
83    /* Print value except if None */
84    /* After printing, also assign to '_' */
85    /* Before, set '_' to None to avoid recursion */
86    if (o == Py_None) {
87        Py_INCREF(Py_None);
88        return Py_None;
89    }
90    if (PyObject_SetAttrString(builtins, "_", Py_None) != 0)
91        return NULL;
92    outf = PySys_GetObject("stdout");
93    if (outf == NULL || outf == Py_None) {
94        PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
95        return NULL;
96    }
97    if (PyFile_WriteObject(o, outf, 0) != 0)
98        return NULL;
99    if (PyFile_WriteString("\n", outf) != 0)
100        return NULL;
101    if (PyObject_SetAttrString(builtins, "_", o) != 0)
102        return NULL;
103    Py_INCREF(Py_None);
104    return Py_None;
105}
106
107PyDoc_STRVAR(displayhook_doc,
108"displayhook(object) -> None\n"
109"\n"
110"Print an object to sys.stdout and also save it in builtins._\n"
111);
112
113static PyObject *
114sys_excepthook(PyObject* self, PyObject* args)
115{
116    PyObject *exc, *value, *tb;
117    if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb))
118        return NULL;
119    PyErr_Display(exc, value, tb);
120    Py_INCREF(Py_None);
121    return Py_None;
122}
123
124PyDoc_STRVAR(excepthook_doc,
125"excepthook(exctype, value, traceback) -> None\n"
126"\n"
127"Handle an exception by displaying it with a traceback on sys.stderr.\n"
128);
129
130static PyObject *
131sys_exc_info(PyObject *self, PyObject *noargs)
132{
133    PyThreadState *tstate;
134    tstate = PyThreadState_GET();
135    return Py_BuildValue(
136        "(OOO)",
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);
141}
142
143PyDoc_STRVAR(exc_info_doc,
144"exc_info() -> (type, value, traceback)\n\
145\n\
146Return information about the most recent exception caught by an except\n\
147clause in the current stack frame or in an older stack frame."
148);
149
150static PyObject *
151sys_exit(PyObject *self, PyObject *args)
152{
153    PyObject *exit_code = 0;
154    if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code))
155        return NULL;
156    /* Raise SystemExit so callers may catch it or clean up. */
157    PyErr_SetObject(PyExc_SystemExit, exit_code);
158    return NULL;
159}
160
161PyDoc_STRVAR(exit_doc,
162"exit([status])\n\
163\n\
164Exit the interpreter by raising SystemExit(status).\n\
165If the status is omitted or None, it defaults to zero (i.e., success).\n\
166If the status is numeric, it will be used as the system exit status.\n\
167If it is another kind of object, it will be printed and the system\n\
168exit status will be one (i.e., failure)."
169);
170
171
172static PyObject *
173sys_getdefaultencoding(PyObject *self)
174{
175    return PyUnicode_FromString(PyUnicode_GetDefaultEncoding());
176}
177
178PyDoc_STRVAR(getdefaultencoding_doc,
179"getdefaultencoding() -> string\n\
180\n\
181Return the current default string encoding used by the Unicode \n\
182implementation."
183);
184
185static PyObject *
186sys_setdefaultencoding(PyObject *self, PyObject *args)
187{
188    char *encoding;
189    if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding))
190        return NULL;
191    if (PyUnicode_SetDefaultEncoding(encoding))
192        return NULL;
193    Py_INCREF(Py_None);
194    return Py_None;
195}
196
197PyDoc_STRVAR(setdefaultencoding_doc,
198"setdefaultencoding(encoding)\n\
199\n\
200Set the current default string encoding used by the Unicode implementation."
201);
202
203static PyObject *
204sys_getfilesystemencoding(PyObject *self)
205{
206    if (Py_FileSystemDefaultEncoding)
207        return PyUnicode_FromString(Py_FileSystemDefaultEncoding);
208    Py_INCREF(Py_None);
209    return Py_None;
210}
211
212PyDoc_STRVAR(getfilesystemencoding_doc,
213"getfilesystemencoding() -> string\n\
214\n\
215Return the encoding used to convert Unicode filenames in\n\
216operating system filenames."
217);
218
219static PyObject *
220sys_setfilesystemencoding(PyObject *self, PyObject *args)
221{
222    PyObject *new_encoding;
223    if (!PyArg_ParseTuple(args, "U:setfilesystemencoding", &new_encoding))
224        return NULL;
225    if (_Py_SetFileSystemEncoding(new_encoding))
226        return NULL;
227    Py_INCREF(Py_None);
228    return Py_None;
229}
230
231PyDoc_STRVAR(setfilesystemencoding_doc,
232"setfilesystemencoding(string) -> None\n\
233\n\
234Set the encoding used to convert Unicode filenames in\n\
235operating system filenames."
236);
237
238static PyObject *
239sys_intern(PyObject *self, PyObject *args)
240{
241    PyObject *s;
242    if (!PyArg_ParseTuple(args, "U:intern", &s))
243        return NULL;
244    if (PyUnicode_CheckExact(s)) {
245        Py_INCREF(s);
246        PyUnicode_InternInPlace(&s);
247        return s;
248    }
249    else {
250        PyErr_Format(PyExc_TypeError,
251                        "can't intern %.400s", s->ob_type->tp_name);
252        return NULL;
253    }
254}
255
256PyDoc_STRVAR(intern_doc,
257"intern(string) -> string\n\
258\n\
259``Intern'' the given string.  This enters the string in the (global)\n\
260table of interned strings whose purpose is to speed up dictionary lookups.\n\
261Return the string itself or the previously interned string object with the\n\
262same value.");
263
264
265/*
266 * Cached interned string objects used for calling the profile and
267 * trace functions.  Initialized by trace_init().
268 */
269static PyObject *whatstrings[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
270
271static int
272trace_init(void)
273{
274    static char *whatnames[7] = {"call", "exception", "line", "return",
275                                    "c_call", "c_exception", "c_return"};
276    PyObject *name;
277    int i;
278    for (i = 0; i < 7; ++i) {
279        if (whatstrings[i] == NULL) {
280            name = PyUnicode_InternFromString(whatnames[i]);
281            if (name == NULL)
282                return -1;
283            whatstrings[i] = name;
284        }
285    }
286    return 0;
287}
288
289
290static PyObject *
291call_trampoline(PyThreadState *tstate, PyObject* callback,
292                PyFrameObject *frame, int what, PyObject *arg)
293{
294    PyObject *args = PyTuple_New(3);
295    PyObject *whatstr;
296    PyObject *result;
297
298    if (args == NULL)
299        return NULL;
300    Py_INCREF(frame);
301    whatstr = whatstrings[what];
302    Py_INCREF(whatstr);
303    if (arg == NULL)
304        arg = Py_None;
305    Py_INCREF(arg);
306    PyTuple_SET_ITEM(args, 0, (PyObject *)frame);
307    PyTuple_SET_ITEM(args, 1, whatstr);
308    PyTuple_SET_ITEM(args, 2, arg);
309
310    /* call the Python-level function */
311    PyFrame_FastToLocals(frame);
312    result = PyEval_CallObject(callback, args);
313    PyFrame_LocalsToFast(frame, 1);
314    if (result == NULL)
315        PyTraceBack_Here(frame);
316
317    /* cleanup */
318    Py_DECREF(args);
319    return result;
320}
321
322static int
323profile_trampoline(PyObject *self, PyFrameObject *frame,
324                   int what, PyObject *arg)
325{
326    PyThreadState *tstate = frame->f_tstate;
327    PyObject *result;
328
329    if (arg == NULL)
330        arg = Py_None;
331    result = call_trampoline(tstate, self, frame, what, arg);
332    if (result == NULL) {
333        PyEval_SetProfile(NULL, NULL);
334        return -1;
335    }
336    Py_DECREF(result);
337    return 0;
338}
339
340static int
341trace_trampoline(PyObject *self, PyFrameObject *frame,
342                 int what, PyObject *arg)
343{
344    PyThreadState *tstate = frame->f_tstate;
345    PyObject *callback;
346    PyObject *result;
347
348    if (what == PyTrace_CALL)
349        callback = self;
350    else
351        callback = frame->f_trace;
352    if (callback == NULL)
353        return 0;
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;
359        return -1;
360    }
361    if (result != Py_None) {
362        PyObject *temp = frame->f_trace;
363        frame->f_trace = NULL;
364        Py_XDECREF(temp);
365        frame->f_trace = result;
366    }
367    else {
368        Py_DECREF(result);
369    }
370    return 0;
371}
372
373static PyObject *
374sys_settrace(PyObject *self, PyObject *args)
375{
376    if (trace_init() == -1)
377        return NULL;
378    if (args == Py_None)
379        PyEval_SetTrace(NULL, NULL);
380    else
381        PyEval_SetTrace(trace_trampoline, args);
382    Py_INCREF(Py_None);
383    return Py_None;
384}
385
386PyDoc_STRVAR(settrace_doc,
387"settrace(function)\n\
388\n\
389Set the global debug tracing function.  It will be called on each\n\
390function call.  See the debugger chapter in the library manual."
391);
392
393static PyObject *
394sys_gettrace(PyObject *self, PyObject *args)
395{
396    PyThreadState *tstate = PyThreadState_GET();
397    PyObject *temp = tstate->c_traceobj;
398
399    if (temp == NULL)
400        temp = Py_None;
401    Py_INCREF(temp);
402    return temp;
403}
404
405PyDoc_STRVAR(gettrace_doc,
406"gettrace()\n\
407\n\
408Return the global debug tracing function set with sys.settrace.\n\
409See the debugger chapter in the library manual."
410);
411
412static PyObject *
413sys_setprofile(PyObject *self, PyObject *args)
414{
415    if (trace_init() == -1)
416        return NULL;
417    if (args == Py_None)
418        PyEval_SetProfile(NULL, NULL);
419    else
420        PyEval_SetProfile(profile_trampoline, args);
421    Py_INCREF(Py_None);
422    return Py_None;
423}
424
425PyDoc_STRVAR(setprofile_doc,
426"setprofile(function)\n\
427\n\
428Set the profiling function.  It will be called on each function call\n\
429and return.  See the profiler chapter in the library manual."
430);
431
432static PyObject *
433sys_getprofile(PyObject *self, PyObject *args)
434{
435    PyThreadState *tstate = PyThreadState_GET();
436    PyObject *temp = tstate->c_profileobj;
437
438    if (temp == NULL)
439        temp = Py_None;
440    Py_INCREF(temp);
441    return temp;
442}
443
444PyDoc_STRVAR(getprofile_doc,
445"getprofile()\n\
446\n\
447Return the profiling function set with sys.setprofile.\n\
448See the profiler chapter in the library manual."
449);
450
451static PyObject *
452sys_setcheckinterval(PyObject *self, PyObject *args)
453{
454    if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval))
455        return NULL;
456    Py_INCREF(Py_None);
457    return Py_None;
458}
459
460PyDoc_STRVAR(setcheckinterval_doc,
461"setcheckinterval(n)\n\
462\n\
463Tell the Python interpreter to check for asynchronous events every\n\
464n instructions.  This also affects how often thread switches occur."
465);
466
467static PyObject *
468sys_getcheckinterval(PyObject *self, PyObject *args)
469{
470    return PyLong_FromLong(_Py_CheckInterval);
471}
472
473PyDoc_STRVAR(getcheckinterval_doc,
474"getcheckinterval() -> current check interval; see setcheckinterval()."
475);
476
477#ifdef WITH_TSC
478static PyObject *
479sys_settscdump(PyObject *self, PyObject *args)
480{
481    int bool;
482    PyThreadState *tstate = PyThreadState_Get();
483
484    if (!PyArg_ParseTuple(args, "i:settscdump", &bool))
485        return NULL;
486    if (bool)
487        tstate->interp->tscdump = 1;
488    else
489        tstate->interp->tscdump = 0;
490    Py_INCREF(Py_None);
491    return Py_None;
492
493}
494
495PyDoc_STRVAR(settscdump_doc,
496"settscdump(bool)\n\
497\n\
498If true, tell the Python interpreter to dump VM measurements to\n\
499stderr.  If false, turn off dump.  The measurements are based on the\n\
500processor's time-stamp counter."
501);
502#endif /* TSC */
503
504static PyObject *
505sys_setrecursionlimit(PyObject *self, PyObject *args)
506{
507    int new_limit;
508    if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit))
509        return NULL;
510    if (new_limit <= 0) {
511        PyErr_SetString(PyExc_ValueError,
512                        "recursion limit must be positive");
513        return NULL;
514    }
515    Py_SetRecursionLimit(new_limit);
516    Py_INCREF(Py_None);
517    return Py_None;
518}
519
520PyDoc_STRVAR(setrecursionlimit_doc,
521"setrecursionlimit(n)\n\
522\n\
523Set the maximum depth of the Python interpreter stack to n.  This\n\
524limit prevents infinite recursion from causing an overflow of the C\n\
525stack and crashing Python.  The highest possible limit is platform-\n\
526dependent."
527);
528
529static PyObject *
530sys_getrecursionlimit(PyObject *self)
531{
532    return PyLong_FromLong(Py_GetRecursionLimit());
533}
534
535PyDoc_STRVAR(getrecursionlimit_doc,
536"getrecursionlimit()\n\
537\n\
538Return the current value of the recursion limit, the maximum depth\n\
539of the Python interpreter stack.  This limit prevents infinite\n\
540recursion from causing an overflow of the C stack and crashing Python."
541);
542
543#ifdef MS_WINDOWS
544PyDoc_STRVAR(getwindowsversion_doc,
545"getwindowsversion()\n\
546\n\
547Return information about the running version of Windows.\n\
548The result is a tuple of (major, minor, build, platform, text)\n\
549All elements are numbers, except text which is a string.\n\
550Platform may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP\n\
551"
552);
553
554static PyObject *
555sys_getwindowsversion(PyObject *self)
556{
557    OSVERSIONINFO ver;
558    ver.dwOSVersionInfoSize = sizeof(ver);
559    if (!GetVersionEx(&ver))
560        return PyErr_SetFromWindowsErr(0);
561    return Py_BuildValue("HHHHs",
562                         ver.dwMajorVersion,
563                         ver.dwMinorVersion,
564                         ver.dwBuildNumber,
565                         ver.dwPlatformId,
566                         ver.szCSDVersion);
567}
568
569#endif /* MS_WINDOWS */
570
571#ifdef HAVE_DLOPEN
572static PyObject *
573sys_setdlopenflags(PyObject *self, PyObject *args)
574{
575    int new_val;
576    PyThreadState *tstate = PyThreadState_GET();
577    if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val))
578        return NULL;
579    if (!tstate)
580        return NULL;
581    tstate->interp->dlopenflags = new_val;
582    Py_INCREF(Py_None);
583    return Py_None;
584}
585
586PyDoc_STRVAR(setdlopenflags_doc,
587"setdlopenflags(n) -> None\n\
588\n\
589Set the flags used by the interpreter for dlopen calls, such as when the\n\
590interpreter loads extension modules.  Among other things, this will enable\n\
591a lazy resolving of symbols when importing a module, if called as\n\
592sys.setdlopenflags(0).  To share symbols across extension modules, call as\n\
593sys.setdlopenflags(ctypes.RTLD_GLOBAL).  Symbolic names for the flag modules\n\
594can be either found in the ctypes module, or in the DLFCN module. If DLFCN\n\
595is not available, it can be generated from /usr/include/dlfcn.h using the\n\
596h2py script.");
597
598static PyObject *
599sys_getdlopenflags(PyObject *self, PyObject *args)
600{
601    PyThreadState *tstate = PyThreadState_GET();
602    if (!tstate)
603        return NULL;
604    return PyLong_FromLong(tstate->interp->dlopenflags);
605}
606
607PyDoc_STRVAR(getdlopenflags_doc,
608"getdlopenflags() -> int\n\
609\n\
610Return the current value of the flags that are used for dlopen calls.\n\
611The flag constants are defined in the ctypes and DLFCN modules.");
612
613#endif  /* HAVE_DLOPEN */
614
615#ifdef USE_MALLOPT
616/* Link with -lmalloc (or -lmpc) on an SGI */
617#include <malloc.h>
618
619static PyObject *
620sys_mdebug(PyObject *self, PyObject *args)
621{
622    int flag;
623    if (!PyArg_ParseTuple(args, "i:mdebug", &flag))
624        return NULL;
625    mallopt(M_DEBUG, flag);
626    Py_INCREF(Py_None);
627    return Py_None;
628}
629#endif /* USE_MALLOPT */
630
631static PyObject *
632sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds)
633{
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;
638    PyObject *method;
639
640    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof",
641                                     kwlist, &o, &dflt))
642        return NULL;
643
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)
648            return NULL;
649    }
650
651    /* Make sure the type is initialized. float gets initialized late */
652    if (PyType_Ready(Py_TYPE(o)) < 0)
653        return NULL;
654
655    method = _PyObject_LookupSpecial(o, "__sizeof__",
656                                     &str__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);
662    }
663    else {
664        res = PyObject_CallFunctionObjArgs(method, NULL);
665        Py_DECREF(method);
666    }
667
668    /* Has a default value been given */
669    if ((res == NULL) && (dflt != NULL) &&
670        PyErr_ExceptionMatches(PyExc_TypeError))
671    {
672        PyErr_Clear();
673        Py_INCREF(dflt);
674        return dflt;
675    }
676    else if (res == NULL)
677        return res;
678
679    /* add gc_head size */
680    if (PyObject_IS_GC(o)) {
681        PyObject *tmp = res;
682        res = PyNumber_Add(tmp, gc_head_size);
683        Py_DECREF(tmp);
684    }
685    return res;
686}
687
688PyDoc_STRVAR(getsizeof_doc,
689"getsizeof(object, default) -> int\n\
690\n\
691Return the size of object in bytes.");
692
693static PyObject *
694sys_getrefcount(PyObject *self, PyObject *arg)
695{
696    return PyLong_FromSsize_t(arg->ob_refcnt);
697}
698
699#ifdef Py_REF_DEBUG
700static PyObject *
701sys_gettotalrefcount(PyObject *self)
702{
703    return PyLong_FromSsize_t(_Py_GetRefTotal());
704}
705#endif /* Py_REF_DEBUG */
706
707PyDoc_STRVAR(getrefcount_doc,
708"getrefcount(object) -> integer\n\
709\n\
710Return the reference count of object.  The count returned is generally\n\
711one higher than you might expect, because it includes the (temporary)\n\
712reference as an argument to getrefcount()."
713);
714
715#ifdef COUNT_ALLOCS
716static PyObject *
717sys_getcounts(PyObject *self)
718{
719    extern PyObject *get_counts(void);
720
721    return get_counts();
722}
723#endif
724
725PyDoc_STRVAR(getframe_doc,
726"_getframe([depth]) -> frameobject\n\
727\n\
728Return a frame object from the call stack.  If optional integer depth is\n\
729given, return the frame object that many calls below the top of the stack.\n\
730If that is deeper than the call stack, ValueError is raised.  The default\n\
731for depth is zero, returning the frame at the top of the call stack.\n\
732\n\
733This function should be used for internal and specialized\n\
734purposes only."
735);
736
737static PyObject *
738sys_getframe(PyObject *self, PyObject *args)
739{
740    PyFrameObject *f = PyThreadState_GET()->frame;
741    int depth = -1;
742
743    if (!PyArg_ParseTuple(args, "|i:_getframe", &depth))
744        return NULL;
745
746    while (depth > 0 && f != NULL) {
747        f = f->f_back;
748        --depth;
749    }
750    if (f == NULL) {
751        PyErr_SetString(PyExc_ValueError,
752                        "call stack is not deep enough");
753        return NULL;
754    }
755    Py_INCREF(f);
756    return (PyObject*)f;
757}
758
759PyDoc_STRVAR(current_frames_doc,
760"_current_frames() -> dictionary\n\
761\n\
762Return a dictionary mapping each current thread T's thread id to T's\n\
763current stack frame.\n\
764\n\
765This function should be used for specialized purposes only."
766);
767
768static PyObject *
769sys_current_frames(PyObject *self, PyObject *noargs)
770{
771    return _PyThread_CurrentFrames();
772}
773
774PyDoc_STRVAR(call_tracing_doc,
775"call_tracing(func, args) -> object\n\
776\n\
777Call func(*args), while tracing is enabled.  The tracing state is\n\
778saved, and restored afterwards.  This is intended to be called from\n\
779a debugger from a checkpoint, to recursively debug some other code."
780);
781
782static PyObject *
783sys_call_tracing(PyObject *self, PyObject *args)
784{
785    PyObject *func, *funcargs;
786    if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs))
787        return NULL;
788    return _PyEval_CallTracing(func, funcargs);
789}
790
791PyDoc_STRVAR(callstats_doc,
792"callstats() -> tuple of integers\n\
793\n\
794Return a tuple of function call statistics, if CALL_PROFILE was defined\n\
795when Python was built.  Otherwise, return None.\n\
796\n\
797When enabled, this function returns detailed, implementation-specific\n\
798details about the number of function calls executed. The return value is\n\
799a 11-tuple where the entries in the tuple are counts of:\n\
8000. all function calls\n\
8011. calls to PyFunction_Type objects\n\
8022. PyFunction calls that do not create an argument tuple\n\
8033. PyFunction calls that do not create an argument tuple\n\
804   and bypass PyEval_EvalCodeEx()\n\
8054. PyMethod calls\n\
8065. PyMethod calls on bound methods\n\
8076. PyType calls\n\
8087. PyCFunction calls\n\
8098. generator calls\n\
8109. All other calls\n\
81110. Number of stack pops performed by call_function()"
812);
813
814#ifdef __cplusplus
815extern "C" {
816#endif
817
818#ifdef Py_TRACE_REFS
819/* Defined in objects.c because it uses static globals if that file */
820extern PyObject *_Py_GetObjects(PyObject *, PyObject *);
821#endif
822
823#ifdef DYNAMIC_EXECUTION_PROFILE
824/* Defined in ceval.c because it uses static globals if that file */
825extern PyObject *_Py_GetDXProfile(PyObject *,  PyObject *);
826#endif
827
828#ifdef __cplusplus
829}
830#endif
831
832static PyObject *
833sys_clear_type_cache(PyObject* self, PyObject* args)
834{
835    PyType_ClearCache();
836    Py_RETURN_NONE;
837}
838
839PyDoc_STRVAR(sys_clear_type_cache__doc__,
840"_clear_type_cache() -> None\n\
841Clear the internal type lookup cache.");
842
843
844static PyMethodDef sys_methods[] = {
845    /* Might as well keep this in alphabetic order */
846    {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS,
847     callstats_doc},
848    {"_clear_type_cache",       sys_clear_type_cache,     METH_NOARGS,
849     sys_clear_type_cache__doc__},
850    {"_current_frames", sys_current_frames, METH_NOARGS,
851     current_frames_doc},
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},
858#ifdef HAVE_DLOPEN
859    {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS,
860     getdlopenflags_doc},
861#endif
862#ifdef COUNT_ALLOCS
863    {"getcounts",       (PyCFunction)sys_getcounts, METH_NOARGS},
864#endif
865#ifdef DYNAMIC_EXECUTION_PROFILE
866    {"getdxp",          _Py_GetDXProfile, METH_VARARGS},
867#endif
868    {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding,
869     METH_NOARGS, getfilesystemencoding_doc},
870#ifdef Py_TRACE_REFS
871    {"getobjects",      _Py_GetObjects, METH_VARARGS},
872#endif
873#ifdef Py_REF_DEBUG
874    {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS},
875#endif
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},
882#ifdef MS_WINDOWS
883    {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
884     getwindowsversion_doc},
885#endif /* MS_WINDOWS */
886    {"intern",          sys_intern,     METH_VARARGS, intern_doc},
887#ifdef USE_MALLOPT
888    {"mdebug",          sys_mdebug, METH_VARARGS},
889#endif
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},
898#ifdef HAVE_DLOPEN
899    {"setdlopenflags", sys_setdlopenflags, METH_VARARGS,
900     setdlopenflags_doc},
901#endif
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},
906#ifdef WITH_TSC
907    {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc},
908#endif
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 */
913};
914
915static PyObject *
916list_builtin_module_names(void)
917{
918    PyObject *list = PyList_New(0);
919    int i;
920    if (list == NULL)
921        return NULL;
922    for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
923        PyObject *name = PyUnicode_FromString(
924            PyImport_Inittab[i].name);
925        if (name == NULL)
926            break;
927        PyList_Append(list, name);
928        Py_DECREF(name);
929    }
930    if (PyList_Sort(list) != 0) {
931        Py_DECREF(list);
932        list = NULL;
933    }
934    if (list) {
935        PyObject *v = PyList_AsTuple(list);
936        Py_DECREF(list);
937        list = v;
938    }
939    return list;
940}
941
942static PyObject *warnoptions = NULL;
943
944void
945PySys_ResetWarnOptions(void)
946{
947    if (warnoptions == NULL || !PyList_Check(warnoptions))
948        return;
949    PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
950}
951
952void
953PySys_AddWarnOption(const wchar_t *s)
954{
955    PyObject *str;
956
957    if (warnoptions == NULL || !PyList_Check(warnoptions)) {
958        Py_XDECREF(warnoptions);
959        warnoptions = PyList_New(0);
960        if (warnoptions == NULL)
961            return;
962    }
963    str = PyUnicode_FromWideChar(s, -1);
964    if (str != NULL) {
965        PyList_Append(warnoptions, str);
966        Py_DECREF(str);
967    }
968}
969
970int
971PySys_HasWarnOptions(void)
972{
973    return (warnoptions != NULL && (PyList_Size(warnoptions) > 0)) ? 1 : 0;
974}
975
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. */
980PyDoc_VAR(sys_doc) =
981PyDoc_STR(
982"This module provides access to some objects used or maintained by the\n\
983interpreter and to functions that interact strongly with the interpreter.\n\
984\n\
985Dynamic objects:\n\
986\n\
987argv -- command line arguments; argv[0] is the script pathname if known\n\
988path -- module search path; path[0] is the script directory, else ''\n\
989modules -- dictionary of loaded modules\n\
990\n\
991displayhook -- called to show results in an interactive session\n\
992excepthook -- 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\
995\n\
996stdin -- standard input file object; used by input()\n\
997stdout -- standard output file object; used by print()\n\
998stderr -- 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\
1001\n\
1002last_type -- type of last uncaught exception\n\
1003last_value -- value of last uncaught exception\n\
1004last_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\
1007"
1008)
1009/* concatenating string here */
1010PyDoc_STR(
1011"\n\
1012Static objects:\n\
1013\n\
1014float_info -- a dict with information about the float implementation.\n\
1015int_info -- a struct sequence with information about the int implementation.\n\
1016maxsize -- the largest supported length of containers.\n\
1017maxunicode -- the largest supported character\n\
1018builtin_module_names -- tuple of module names built into this interpreter\n\
1019subversion -- subversion information of the build as tuple\n\
1020version -- the version of this interpreter as a string\n\
1021version_info -- version information as a named tuple\n\
1022hexversion -- version information encoded as a single integer\n\
1023copyright -- copyright notice pertaining to this interpreter\n\
1024platform -- platform identifier\n\
1025executable -- pathname of this Python interpreter\n\
1026prefix -- prefix used to find the Python library\n\
1027exec_prefix -- prefix used to find the machine-specific Python library\n\
1028float_repr_style -- string indicating the style of repr() output for floats\n\
1029"
1030)
1031#ifdef MS_WINDOWS
1032/* concatenating string here */
1033PyDoc_STR(
1034"dllhandle -- [Windows only] integer handle of the Python DLL\n\
1035winver -- [Windows only] version number of the Python DLL\n\
1036"
1037)
1038#endif /* MS_WINDOWS */
1039PyDoc_STR(
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\
1045\n\
1046Functions:\n\
1047\n\
1048displayhook() -- print an object to the screen, and save it in builtins._\n\
1049excepthook() -- print an exception and its traceback to sys.stderr\n\
1050exc_info() -- return thread-safe information about the current exception\n\
1051exit() -- exit the interpreter by raising SystemExit\n\
1052getdlopenflags() -- returns flags to be used for dlopen() calls\n\
1053getprofile() -- get the global profiling function\n\
1054getrefcount() -- return the reference count for an object (plus one :-)\n\
1055getrecursionlimit() -- return the max recursion depth for the interpreter\n\
1056getsizeof() -- return the size of an object in bytes\n\
1057gettrace() -- get the global debug tracing function\n\
1058setcheckinterval() -- control how often the interpreter checks for events\n\
1059setdlopenflags() -- set the flags to be used for dlopen() calls\n\
1060setprofile() -- set the global profiling function\n\
1061setrecursionlimit() -- set the max recursion depth for the interpreter\n\
1062settrace() -- set the global debug tracing function\n\
1063"
1064)
1065/* end of sys_doc */ ;
1066
1067/* Subversion branch and revision management */
1068static const char _patchlevel_revision[] = PY_PATCHLEVEL_REVISION;
1069static const char headurl[] = "$HeadURL$";
1070static int svn_initialized;
1071static char patchlevel_revision[50]; /* Just the number */
1072static char branch[50];
1073static char shortbranch[50];
1074static const char *svn_revision;
1075
1076static void
1077svnversion_init(void)
1078{
1079    const char *python, *br_start, *br_end, *br_end2, *svnversion;
1080    Py_ssize_t len;
1081    int istag = 0;
1082
1083    if (svn_initialized)
1084        return;
1085
1086    python = strstr(headurl, "/python/");
1087    if (!python) {
1088        strcpy(branch, "unknown branch");
1089        strcpy(shortbranch, "unknown");
1090    }
1091    else {
1092        br_start = python + 8;
1093        br_end = strchr(br_start, '/');
1094        assert(br_end);
1095
1096        /* Works even for trunk,
1097           as we are in trunk/Python/sysmodule.c */
1098        br_end2 = strchr(br_end+1, '/');
1099
1100        istag = strncmp(br_start, "tags", 4) == 0;
1101        if (strncmp(br_start, "trunk", 5) == 0) {
1102            strcpy(branch, "trunk");
1103            strcpy(shortbranch, "trunk");
1104        }
1105        else if (istag || strncmp(br_start, "branches", 8) == 0) {
1106            len = br_end2 - br_start;
1107            strncpy(branch, br_start, len);
1108            branch[len] = '\0';
1109
1110            len = br_end2 - (br_end + 1);
1111            strncpy(shortbranch, br_end + 1, len);
1112            shortbranch[len] = '\0';
1113        }
1114        else {
1115            Py_FatalError("bad HeadURL");
1116            return;
1117        }
1118    }
1119
1120
1121    svnversion = _Py_svnversion();
1122    if (strcmp(svnversion, "Unversioned directory") != 0 && strcmp(svnversion, "exported") != 0)
1123        svn_revision = svnversion;
1124    else if (istag) {
1125        len = strlen(_patchlevel_revision);
1126        assert(len >= 13);
1127        assert(len < (sizeof(patchlevel_revision) + 13));
1128        strncpy(patchlevel_revision, _patchlevel_revision + 11,
1129            len - 13);
1130        patchlevel_revision[len - 13] = '\0';
1131        svn_revision = patchlevel_revision;
1132    }
1133    else
1134        svn_revision = "";
1135
1136    svn_initialized = 1;
1137}
1138
1139/* Return svnversion output if available.
1140   Else return Revision of patchlevel.h if on branch.
1141   Else return empty string */
1142const char*
1143Py_SubversionRevision()
1144{
1145    svnversion_init();
1146    return svn_revision;
1147}
1148
1149const char*
1150Py_SubversionShortBranch()
1151{
1152    svnversion_init();
1153    return shortbranch;
1154}
1155
1156
1157PyDoc_STRVAR(flags__doc__,
1158"sys.flags\n\
1159\n\
1160Flags provided through command line arguments or environment vars.");
1161
1162static PyTypeObject FlagsType;
1163
1164static PyStructSequence_Field flags_fields[] = {
1165    {"debug",                   "-d"},
1166    {"division_warning",        "-Q"},
1167    {"inspect",                 "-i"},
1168    {"interactive",             "-i"},
1169    {"optimize",                "-O or -OO"},
1170    {"dont_write_bytecode",     "-B"},
1171    {"no_user_site",            "-s"},
1172    {"no_site",                 "-S"},
1173    {"ignore_environment",      "-E"},
1174    {"verbose",                 "-v"},
1175#ifdef RISCOS
1176    {"riscos_wimp",             "???"},
1177#endif
1178    /* {"unbuffered",                   "-u"}, */
1179    /* {"skip_first",                   "-x"}, */
1180    {"bytes_warning", "-b"},
1181    {0}
1182};
1183
1184static PyStructSequence_Desc flags_desc = {
1185    "sys.flags",        /* name */
1186    flags__doc__,       /* doc */
1187    flags_fields,       /* fields */
1188#ifdef RISCOS
1189    12
1190#else
1191    11
1192#endif
1193};
1194
1195static PyObject*
1196make_flags(void)
1197{
1198    int pos = 0;
1199    PyObject *seq;
1200
1201    seq = PyStructSequence_New(&FlagsType);
1202    if (seq == NULL)
1203        return NULL;
1204
1205#define SetFlag(flag) \
1206    PyStructSequence_SET_ITEM(seq, pos++, PyLong_FromLong(flag))
1207
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);
1218#ifdef RISCOS
1219    SetFlag(Py_RISCOSWimpFlag);
1220#endif
1221    /* SetFlag(saw_unbuffered_flag); */
1222    /* SetFlag(skipfirstline); */
1223    SetFlag(Py_BytesWarningFlag);
1224#undef SetFlag
1225
1226    if (PyErr_Occurred()) {
1227        return NULL;
1228    }
1229    return seq;
1230}
1231
1232PyDoc_STRVAR(version_info__doc__,
1233"sys.version_info\n\
1234\n\
1235Version information as a named tuple.");
1236
1237static PyTypeObject VersionInfoType;
1238
1239static 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"},
1245    {0}
1246};
1247
1248static PyStructSequence_Desc version_info_desc = {
1249    "sys.version_info",     /* name */
1250    version_info__doc__,    /* doc */
1251    version_info_fields,    /* fields */
1252    5
1253};
1254
1255static PyObject *
1256make_version_info(void)
1257{
1258    PyObject *version_info;
1259    char *s;
1260    int pos = 0;
1261
1262    version_info = PyStructSequence_New(&VersionInfoType);
1263    if (version_info == NULL) {
1264        return NULL;
1265    }
1266
1267    /*
1268     * These release level checks are mutually exclusive and cover
1269     * the field, so don't get too fancy with the pre-processor!
1270     */
1271#if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
1272    s = "alpha";
1273#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
1274    s = "beta";
1275#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
1276    s = "candidate";
1277#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
1278    s = "final";
1279#endif
1280
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))
1285
1286    SetIntItem(PY_MAJOR_VERSION);
1287    SetIntItem(PY_MINOR_VERSION);
1288    SetIntItem(PY_MICRO_VERSION);
1289    SetStrItem(s);
1290    SetIntItem(PY_RELEASE_SERIAL);
1291#undef SetIntItem
1292#undef SetStrItem
1293
1294    if (PyErr_Occurred()) {
1295        Py_CLEAR(version_info);
1296        return NULL;
1297    }
1298    return version_info;
1299}
1300
1301static struct PyModuleDef sysmodule = {
1302    PyModuleDef_HEAD_INIT,
1303    "sys",
1304    sys_doc,
1305    -1, /* multiple "initialization" just copies the module dict. */
1306    sys_methods,
1307    NULL,
1308    NULL,
1309    NULL,
1310    NULL
1311};
1312
1313PyObject *
1314_PySys_Init(void)
1315{
1316    PyObject *m, *v, *sysdict;
1317    char *s;
1318
1319    m = PyModule_Create(&sysmodule);
1320    if (m == NULL)
1321        return NULL;
1322    sysdict = PyModule_GetDict(m);
1323#define SET_SYS_FROM_STRING(key, value)                 \
1324    v = value;                                          \
1325    if (v != NULL)                                      \
1326        PyDict_SetItemString(sysdict, key, v);          \
1327    Py_XDECREF(v)
1328
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)
1335    {
1336        struct stat sb;
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");
1342            exit(EXIT_FAILURE);
1343        }
1344    }
1345#endif
1346
1347    /* stdin/stdout/stderr are now set by pythonrun.c */
1348
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));
1357    svnversion_init();
1358    SET_SYS_FROM_STRING("subversion",
1359                        Py_BuildValue("(UUU)", "CPython", branch,
1360                                      svn_revision));
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",
1379                        PyFloat_GetInfo());
1380    SET_SYS_FROM_STRING("int_info",
1381                        PyLong_GetInfo());
1382    SET_SYS_FROM_STRING("maxunicode",
1383                        PyLong_FromLong(PyUnicode_GetMax()));
1384    SET_SYS_FROM_STRING("builtin_module_names",
1385                        list_builtin_module_names());
1386    {
1387        /* Assumes that longs are at least 2 bytes long.
1388           Should be safe! */
1389        unsigned long number = 1;
1390        char *value;
1391
1392        s = (char *) &number;
1393        if (s[0] == 0)
1394            value = "big";
1395        else
1396            value = "little";
1397        SET_SYS_FROM_STRING("byteorder",
1398                            PyUnicode_FromString(value));
1399    }
1400#ifdef MS_COREDLL
1401    SET_SYS_FROM_STRING("dllhandle",
1402                        PyLong_FromVoidPtr(PyWin_DLLhModule));
1403    SET_SYS_FROM_STRING("winver",
1404                        PyUnicode_FromString(PyWin_DLLVersionString));
1405#endif
1406    if (warnoptions == NULL) {
1407        warnoptions = PyList_New(0);
1408    }
1409    else {
1410        Py_INCREF(warnoptions);
1411    }
1412    if (warnoptions != NULL) {
1413        PyDict_SetItemString(sysdict, "warnoptions", warnoptions);
1414    }
1415
1416    /* version_info */
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;
1423
1424    /* flags */
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;
1431
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"));
1436#else
1437    SET_SYS_FROM_STRING("float_repr_style",
1438                        PyUnicode_FromString("legacy"));
1439#endif
1440
1441#undef SET_SYS_FROM_STRING
1442    if (PyErr_Occurred())
1443        return NULL;
1444    return m;
1445}
1446
1447static PyObject *
1448makepathobject(const wchar_t *path, wchar_t delim)
1449{
1450    int i, n;
1451    const wchar_t *p;
1452    PyObject *v, *w;
1453
1454    n = 1;
1455    p = path;
1456    while ((p = wcschr(p, delim)) != NULL) {
1457        n++;
1458        p++;
1459    }
1460    v = PyList_New(n);
1461    if (v == NULL)
1462        return NULL;
1463    for (i = 0; ; i++) {
1464        p = wcschr(path, delim);
1465        if (p == NULL)
1466            p = path + wcslen(path); /* End of string */
1467        w = PyUnicode_FromWideChar(path, (Py_ssize_t)(p - path));
1468        if (w == NULL) {
1469            Py_DECREF(v);
1470            return NULL;
1471        }
1472        PyList_SetItem(v, i, w);
1473        if (*p == '\0')
1474            break;
1475        path = p+1;
1476    }
1477    return v;
1478}
1479
1480void
1481PySys_SetPath(const wchar_t *path)
1482{
1483    PyObject *v;
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");
1488    Py_DECREF(v);
1489}
1490
1491static PyObject *
1492makeargvobject(int argc, wchar_t **argv)
1493{
1494    PyObject *av;
1495    if (argc <= 0 || argv == NULL) {
1496        /* Ensure at least one (empty) argument is seen */
1497        static wchar_t *empty_argv[1] = {L""};
1498        argv = empty_argv;
1499        argc = 1;
1500    }
1501    av = PyList_New(argc);
1502    if (av != NULL) {
1503        int i;
1504        for (i = 0; i < argc; i++) {
1505#ifdef __VMS
1506            PyObject *v;
1507
1508            /* argv[0] is the script pathname if known */
1509            if (i == 0) {
1510                char* fn = decc$translate_vms(argv[0]);
1511                if ((fn == (char *)0) || fn == (char *)-1)
1512                    v = PyUnicode_FromString(argv[0]);
1513                else
1514                    v = PyUnicode_FromString(
1515                        decc$translate_vms(argv[0]));
1516            } else
1517                v = PyUnicode_FromString(argv[i]);
1518#else
1519            PyObject *v = PyUnicode_FromWideChar(argv[i], -1);
1520#endif
1521            if (v == NULL) {
1522                Py_DECREF(av);
1523                av = NULL;
1524                break;
1525            }
1526            PyList_SetItem(av, i, v);
1527        }
1528    }
1529    return av;
1530}
1531
1532#ifdef HAVE_REALPATH
1533static wchar_t*
1534_wrealpath(const wchar_t *path, wchar_t *resolved_path)
1535{
1536    char cpath[PATH_MAX];
1537    char cresolved_path[PATH_MAX];
1538    char *res;
1539    size_t r;
1540    r = wcstombs(cpath, path, PATH_MAX);
1541    if (r == (size_t)-1 || r >= PATH_MAX) {
1542        errno = EINVAL;
1543        return NULL;
1544    }
1545    res = realpath(cpath, cresolved_path);
1546    if (res == NULL)
1547        return NULL;
1548    r = mbstowcs(resolved_path, cresolved_path, PATH_MAX);
1549    if (r == (size_t)-1 || r >= PATH_MAX) {
1550        errno = EINVAL;
1551        return NULL;
1552    }
1553    return resolved_path;
1554}
1555#endif
1556
1557void
1558PySys_SetArgvEx(int argc, wchar_t **argv, int updatepath)
1559{
1560#if defined(HAVE_REALPATH)
1561    wchar_t fullpath[MAXPATHLEN];
1562#elif defined(MS_WINDOWS) && !defined(MS_WINCE)
1563    wchar_t fullpath[MAX_PATH];
1564#endif
1565    PyObject *av = makeargvobject(argc, argv);
1566    PyObject *path = PySys_GetObject("path");
1567    if (av == NULL)
1568        Py_FatalError("no mem for sys.argv");
1569    if (PySys_SetObject("argv", av) != 0)
1570        Py_FatalError("can't assign sys.argv");
1571    if (updatepath && path != NULL) {
1572        wchar_t *argv0 = argv[0];
1573        wchar_t *p = NULL;
1574        Py_ssize_t n = 0;
1575        PyObject *a;
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];
1580        int nr = 0;
1581        if (argc > 0 && argv0 != NULL && wcscmp(argv0, L"-c") != 0)
1582            nr = _Py_wreadlink(argv0, link, MAXPATHLEN);
1583        if (nr > 0) {
1584            /* It's a symlink */
1585            link[nr] = '\0';
1586            if (link[0] == SEP)
1587                argv0 = link; /* Link to absolute path */
1588            else if (wcschr(link, SEP) == NULL)
1589                ; /* Link without path */
1590            else {
1591                /* Must join(dirname(argv0), link) */
1592                wchar_t *q = wcsrchr(argv0, SEP);
1593                if (q == NULL)
1594                    argv0 = link; /* argv0 without path */
1595                else {
1596                    /* Must make a copy */
1597                    wcscpy(argv0copy, argv0);
1598                    q = wcsrchr(argv0copy, SEP);
1599                    wcscpy(q+1, link);
1600                    argv0 = argv0copy;
1601                }
1602            }
1603        }
1604#endif /* HAVE_READLINK */
1605#if SEP == '\\' /* Special case for MS filename syntax */
1606        if (argc > 0 && argv0 != NULL && wcscmp(argv0, L"-c") != 0) {
1607            wchar_t *q;
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. */
1612            wchar_t *ptemp;
1613            if (GetFullPathNameW(argv0,
1614                               sizeof(fullpath)/sizeof(fullpath[0]),
1615                               fullpath,
1616                               &ptemp)) {
1617                argv0 = fullpath;
1618            }
1619#endif
1620            p = wcsrchr(argv0, SEP);
1621            /* Test for alternate separator */
1622            q = wcsrchr(p ? p : argv0, '/');
1623            if (q != NULL)
1624                p = q;
1625            if (p != NULL) {
1626                n = p + 1 - argv0;
1627                if (n > 1 && p[-1] != ':')
1628                    n--; /* Drop trailing separator */
1629            }
1630        }
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)) {
1635                argv0 = fullpath;
1636            }
1637#endif
1638            p = wcsrchr(argv0, SEP);
1639        }
1640        if (p != NULL) {
1641            n = p + 1 - argv0;
1642#if SEP == '/' /* Special case for Unix filename syntax */
1643            if (n > 1)
1644                n--; /* Drop trailing separator */
1645#endif /* Unix */
1646        }
1647#endif /* All others */
1648        a = PyUnicode_FromWideChar(argv0, n);
1649        if (a == NULL)
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");
1653        Py_DECREF(a);
1654    }
1655    Py_DECREF(av);
1656}
1657
1658void
1659PySys_SetArgv(int argc, wchar_t **argv)
1660{
1661    PySys_SetArgvEx(argc, argv, 1);
1662}
1663
1664/* Reimplementation of PyFile_WriteString() no calling indirectly
1665   PyErr_CheckSignals(): avoid the call to PyObject_Str(). */
1666
1667static int
1668sys_pyfile_write(const char *text, PyObject *file)
1669{
1670    PyObject *unicode = NULL, *writer = NULL, *args = NULL, *result = NULL;
1671    int err;
1672
1673    if (file == NULL)
1674        return -1;
1675
1676    unicode = PyUnicode_FromString(text);
1677    if (unicode == NULL)
1678        goto error;
1679
1680    writer = PyObject_GetAttrString(file, "write");
1681    if (writer == NULL)
1682        goto error;
1683
1684    args = PyTuple_Pack(1, unicode);
1685    if (args == NULL)
1686        goto error;
1687
1688    result = PyEval_CallObject(writer, args);
1689    if (result == NULL) {
1690        goto error;
1691    } else {
1692        err = 0;
1693        goto finally;
1694    }
1695
1696error:
1697    err = -1;
1698finally:
1699    Py_XDECREF(unicode);
1700    Py_XDECREF(writer);
1701    Py_XDECREF(args);
1702    Py_XDECREF(result);
1703    return err;
1704}
1705
1706
1707/* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
1708   Adapted from code submitted by Just van Rossum.
1709
1710   PySys_WriteStdout(format, ...)
1711   PySys_WriteStderr(format, ...)
1712
1713      The first function writes to sys.stdout; the second to sys.stderr.  When
1714      there is a problem, they write to the real (C level) stdout or stderr;
1715      no exceptions are raised.
1716
1717      PyErr_CheckSignals() is not called to avoid the execution of the Python
1718      signal handlers: they may raise a new exception whereas mywrite() ignores
1719      all exceptions.
1720
1721      Both take a printf-style format string as their first argument followed
1722      by a variable length argument list determined by the format string.
1723
1724      *** WARNING ***
1725
1726      The format should limit the total size of the formatted output string to
1727      1000 bytes.  In particular, this means that no unrestricted "%s" formats
1728      should occur; these should be limited using "%.<N>s where <N> is a
1729      decimal number calculated so that <N> plus the maximum size of other
1730      formatted text does not exceed 1000 bytes.  Also watch out for "%f",
1731      which can print hundreds of digits for very large numbers.
1732
1733 */
1734
1735static void
1736mywrite(char *name, FILE *fp, const char *format, va_list va)
1737{
1738    PyObject *file;
1739    PyObject *error_type, *error_value, *error_traceback;
1740    char buffer[1001];
1741    int written;
1742
1743    PyErr_Fetch(&error_type, &error_value, &error_traceback);
1744    file = PySys_GetObject(name);
1745    written = PyOS_vsnprintf(buffer, sizeof(buffer), format, va);
1746    if (sys_pyfile_write(buffer, file) != 0) {
1747        PyErr_Clear();
1748        fputs(buffer, fp);
1749    }
1750    if (written < 0 || (size_t)written >= sizeof(buffer)) {
1751        const char *truncated = "... truncated";
1752        if (sys_pyfile_write(truncated, file) != 0) {
1753            PyErr_Clear();
1754            fputs(truncated, fp);
1755        }
1756    }
1757    PyErr_Restore(error_type, error_value, error_traceback);
1758}
1759
1760void
1761PySys_WriteStdout(const char *format, ...)
1762{
1763    va_list va;
1764
1765    va_start(va, format);
1766    mywrite("stdout", stdout, format, va);
1767    va_end(va);
1768}
1769
1770void
1771PySys_WriteStderr(const char *format, ...)
1772{
1773    va_list va;
1774
1775    va_start(va, format);
1776    mywrite("stderr", stderr, format, va);
1777    va_end(va);
1778}
1779