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 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
49PyObject *
50PySys_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
59FILE *
60PySys_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
71int
72PySys_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
86static PyObject *
87sys_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
126PyDoc_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
132static PyObject *
133sys_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
143PyDoc_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
149static PyObject *
150sys_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
162PyDoc_STRVAR(exc_info_doc,
163"exc_info() -> (type, value, traceback)\n\
164\n\
165Return information about the most recent exception caught by an except\n\
166clause in the current stack frame or in an older stack frame."
167);
168
169static PyObject *
170sys_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
197PyDoc_STRVAR(exc_clear_doc,
198"exc_clear() -> None\n\
199\n\
200Clear global information on the current exception.  Subsequent calls to\n\
201exc_info() will return (None,None,None) until another exception is raised\n\
202in the current thread or the execution stack returns to a frame where\n\
203another exception is being handled."
204);
205
206static PyObject *
207sys_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
217PyDoc_STRVAR(exit_doc,
218"exit([status])\n\
219\n\
220Exit the interpreter by raising SystemExit(status).\n\
221If the status is omitted or None, it defaults to zero (i.e., success).\n\
222If the status is an integer, it will be used as the system exit status.\n\
223If it is another kind of object, it will be printed and the system\n\
224exit status will be one (i.e., failure)."
225);
226
227#ifdef Py_USING_UNICODE
228
229static PyObject *
230sys_getdefaultencoding(PyObject *self)
231{
232    return PyString_FromString(PyUnicode_GetDefaultEncoding());
233}
234
235PyDoc_STRVAR(getdefaultencoding_doc,
236"getdefaultencoding() -> string\n\
237\n\
238Return the current default string encoding used by the Unicode \n\
239implementation."
240);
241
242static PyObject *
243sys_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
254PyDoc_STRVAR(setdefaultencoding_doc,
255"setdefaultencoding(encoding)\n\
256\n\
257Set the current default string encoding used by the Unicode implementation."
258);
259
260static PyObject *
261sys_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
269PyDoc_STRVAR(getfilesystemencoding_doc,
270"getfilesystemencoding() -> string\n\
271\n\
272Return the encoding used to convert Unicode filenames in\n\
273operating 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 */
282static PyObject *whatstrings[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
283
284static int
285trace_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
303static PyObject *
304call_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
335static int
336profile_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
353static int
354trace_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_CLEAR(frame->f_trace);
371        return -1;
372    }
373    if (result != Py_None) {
374        PyObject *temp = frame->f_trace;
375        frame->f_trace = NULL;
376        Py_XDECREF(temp);
377        frame->f_trace = result;
378    }
379    else {
380        Py_DECREF(result);
381    }
382    return 0;
383}
384
385static PyObject *
386sys_settrace(PyObject *self, PyObject *args)
387{
388    if (trace_init() == -1)
389        return NULL;
390    if (args == Py_None)
391        PyEval_SetTrace(NULL, NULL);
392    else
393        PyEval_SetTrace(trace_trampoline, args);
394    Py_INCREF(Py_None);
395    return Py_None;
396}
397
398PyDoc_STRVAR(settrace_doc,
399"settrace(function)\n\
400\n\
401Set the global debug tracing function.  It will be called on each\n\
402function call.  See the debugger chapter in the library manual."
403);
404
405static PyObject *
406sys_gettrace(PyObject *self, PyObject *args)
407{
408    PyThreadState *tstate = PyThreadState_GET();
409    PyObject *temp = tstate->c_traceobj;
410
411    if (temp == NULL)
412        temp = Py_None;
413    Py_INCREF(temp);
414    return temp;
415}
416
417PyDoc_STRVAR(gettrace_doc,
418"gettrace()\n\
419\n\
420Return the global debug tracing function set with sys.settrace.\n\
421See the debugger chapter in the library manual."
422);
423
424static PyObject *
425sys_setprofile(PyObject *self, PyObject *args)
426{
427    if (trace_init() == -1)
428        return NULL;
429    if (args == Py_None)
430        PyEval_SetProfile(NULL, NULL);
431    else
432        PyEval_SetProfile(profile_trampoline, args);
433    Py_INCREF(Py_None);
434    return Py_None;
435}
436
437PyDoc_STRVAR(setprofile_doc,
438"setprofile(function)\n\
439\n\
440Set the profiling function.  It will be called on each function call\n\
441and return.  See the profiler chapter in the library manual."
442);
443
444static PyObject *
445sys_getprofile(PyObject *self, PyObject *args)
446{
447    PyThreadState *tstate = PyThreadState_GET();
448    PyObject *temp = tstate->c_profileobj;
449
450    if (temp == NULL)
451        temp = Py_None;
452    Py_INCREF(temp);
453    return temp;
454}
455
456PyDoc_STRVAR(getprofile_doc,
457"getprofile()\n\
458\n\
459Return the profiling function set with sys.setprofile.\n\
460See the profiler chapter in the library manual."
461);
462
463static PyObject *
464sys_setcheckinterval(PyObject *self, PyObject *args)
465{
466    if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval))
467        return NULL;
468    _Py_Ticker = _Py_CheckInterval;
469    Py_INCREF(Py_None);
470    return Py_None;
471}
472
473PyDoc_STRVAR(setcheckinterval_doc,
474"setcheckinterval(n)\n\
475\n\
476Tell the Python interpreter to check for asynchronous events every\n\
477n instructions.  This also affects how often thread switches occur."
478);
479
480static PyObject *
481sys_getcheckinterval(PyObject *self, PyObject *args)
482{
483    return PyInt_FromLong(_Py_CheckInterval);
484}
485
486PyDoc_STRVAR(getcheckinterval_doc,
487"getcheckinterval() -> current check interval; see setcheckinterval()."
488);
489
490#ifdef WITH_TSC
491static PyObject *
492sys_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
508PyDoc_STRVAR(settscdump_doc,
509"settscdump(bool)\n\
510\n\
511If true, tell the Python interpreter to dump VM measurements to\n\
512stderr.  If false, turn off dump.  The measurements are based on the\n\
513processor's time-stamp counter."
514);
515#endif /* TSC */
516
517static PyObject *
518sys_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
533PyDoc_STRVAR(setrecursionlimit_doc,
534"setrecursionlimit(n)\n\
535\n\
536Set the maximum depth of the Python interpreter stack to n.  This\n\
537limit prevents infinite recursion from causing an overflow of the C\n\
538stack and crashing Python.  The highest possible limit is platform-\n\
539dependent."
540);
541
542static PyObject *
543sys_getrecursionlimit(PyObject *self)
544{
545    return PyInt_FromLong(Py_GetRecursionLimit());
546}
547
548PyDoc_STRVAR(getrecursionlimit_doc,
549"getrecursionlimit()\n\
550\n\
551Return the current value of the recursion limit, the maximum depth\n\
552of the Python interpreter stack.  This limit prevents infinite\n\
553recursion from causing an overflow of the C stack and crashing Python."
554);
555
556#ifdef MS_WINDOWS
557PyDoc_STRVAR(getwindowsversion_doc,
558"getwindowsversion()\n\
559\n\
560Return information about the running version of Windows as a named tuple.\n\
561The members are named: major, minor, build, platform, service_pack,\n\
562service_pack_major, service_pack_minor, suite_mask, and product_type. For\n\
563backward compatibility, only the first 5 items are available by indexing.\n\
564All elements are numbers, except service_pack which is a string. Platform\n\
565may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP/Vista/7,\n\
5663 for Windows CE. Product_type may be 1 for a workstation, 2 for a domain\n\
567controller, 3 for a server."
568);
569
570static PyTypeObject WindowsVersionType = {0, 0, 0, 0, 0, 0};
571
572static PyStructSequence_Field windows_version_fields[] = {
573    {"major", "Major version number"},
574    {"minor", "Minor version number"},
575    {"build", "Build number"},
576    {"platform", "Operating system platform"},
577    {"service_pack", "Latest Service Pack installed on the system"},
578    {"service_pack_major", "Service Pack major version number"},
579    {"service_pack_minor", "Service Pack minor version number"},
580    {"suite_mask", "Bit mask identifying available product suites"},
581    {"product_type", "System product type"},
582    {0}
583};
584
585static PyStructSequence_Desc windows_version_desc = {
586    "sys.getwindowsversion",  /* name */
587    getwindowsversion_doc,    /* doc */
588    windows_version_fields,   /* fields */
589    5                         /* For backward compatibility,
590                                 only the first 5 items are accessible
591                                 via indexing, the rest are name only */
592};
593
594static PyObject *
595sys_getwindowsversion(PyObject *self)
596{
597    PyObject *version;
598    int pos = 0;
599    OSVERSIONINFOEX ver;
600    ver.dwOSVersionInfoSize = sizeof(ver);
601    if (!GetVersionEx((OSVERSIONINFO*) &ver))
602        return PyErr_SetFromWindowsErr(0);
603
604    version = PyStructSequence_New(&WindowsVersionType);
605    if (version == NULL)
606        return NULL;
607
608    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMajorVersion));
609    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMinorVersion));
610    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwBuildNumber));
611    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwPlatformId));
612    PyStructSequence_SET_ITEM(version, pos++, PyString_FromString(ver.szCSDVersion));
613    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMajor));
614    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMinor));
615    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wSuiteMask));
616    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wProductType));
617
618    if (PyErr_Occurred()) {
619        Py_DECREF(version);
620        return NULL;
621    }
622    return version;
623}
624
625#endif /* MS_WINDOWS */
626
627#ifdef HAVE_DLOPEN
628static PyObject *
629sys_setdlopenflags(PyObject *self, PyObject *args)
630{
631    int new_val;
632    PyThreadState *tstate = PyThreadState_GET();
633    if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val))
634        return NULL;
635    if (!tstate)
636        return NULL;
637    tstate->interp->dlopenflags = new_val;
638    Py_INCREF(Py_None);
639    return Py_None;
640}
641
642PyDoc_STRVAR(setdlopenflags_doc,
643"setdlopenflags(n) -> None\n\
644\n\
645Set the flags used by the interpreter for dlopen calls, such as when the\n\
646interpreter loads extension modules.  Among other things, this will enable\n\
647a lazy resolving of symbols when importing a module, if called as\n\
648sys.setdlopenflags(0).  To share symbols across extension modules, call as\n\
649sys.setdlopenflags(ctypes.RTLD_GLOBAL).  Symbolic names for the flag modules\n\
650can be either found in the ctypes module, or in the DLFCN module. If DLFCN\n\
651is not available, it can be generated from /usr/include/dlfcn.h using the\n\
652h2py script.");
653
654static PyObject *
655sys_getdlopenflags(PyObject *self, PyObject *args)
656{
657    PyThreadState *tstate = PyThreadState_GET();
658    if (!tstate)
659        return NULL;
660    return PyInt_FromLong(tstate->interp->dlopenflags);
661}
662
663PyDoc_STRVAR(getdlopenflags_doc,
664"getdlopenflags() -> int\n\
665\n\
666Return the current value of the flags that are used for dlopen calls.\n\
667The flag constants are defined in the ctypes and DLFCN modules.");
668
669#endif  /* HAVE_DLOPEN */
670
671#ifdef USE_MALLOPT
672/* Link with -lmalloc (or -lmpc) on an SGI */
673#include <malloc.h>
674
675static PyObject *
676sys_mdebug(PyObject *self, PyObject *args)
677{
678    int flag;
679    if (!PyArg_ParseTuple(args, "i:mdebug", &flag))
680        return NULL;
681    mallopt(M_DEBUG, flag);
682    Py_INCREF(Py_None);
683    return Py_None;
684}
685#endif /* USE_MALLOPT */
686
687size_t
688_PySys_GetSizeOf(PyObject *o)
689{
690    static PyObject *str__sizeof__ = NULL;
691    PyObject *res = NULL;
692    Py_ssize_t size;
693
694    /* Make sure the type is initialized. float gets initialized late */
695    if (PyType_Ready(Py_TYPE(o)) < 0)
696        return (size_t)-1;
697
698    /* Instance of old-style class */
699    if (PyInstance_Check(o))
700        size = PyInstance_Type.tp_basicsize;
701    /* all other objects */
702    else {
703        PyObject *method = _PyObject_LookupSpecial(o, "__sizeof__",
704                                                   &str__sizeof__);
705        if (method == NULL) {
706            if (!PyErr_Occurred())
707                PyErr_Format(PyExc_TypeError,
708                             "Type %.100s doesn't define __sizeof__",
709                             Py_TYPE(o)->tp_name);
710        }
711        else {
712            res = PyObject_CallFunctionObjArgs(method, NULL);
713            Py_DECREF(method);
714        }
715
716        if (res == NULL)
717            return (size_t)-1;
718
719        size = (size_t)PyInt_AsSsize_t(res);
720        Py_DECREF(res);
721        if (size == -1 && PyErr_Occurred())
722            return (size_t)-1;
723    }
724
725    if (size < 0) {
726        PyErr_SetString(PyExc_ValueError, "__sizeof__() should return >= 0");
727        return (size_t)-1;
728    }
729
730    /* add gc_head size */
731    if (PyObject_IS_GC(o))
732        return ((size_t)size) + sizeof(PyGC_Head);
733    return (size_t)size;
734}
735
736static PyObject *
737sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds)
738{
739    static char *kwlist[] = {"object", "default", 0};
740    size_t size;
741    PyObject *o, *dflt = NULL;
742
743    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof",
744                                     kwlist, &o, &dflt))
745        return NULL;
746
747    size = _PySys_GetSizeOf(o);
748
749    if (size == (size_t)-1 && PyErr_Occurred()) {
750        /* Has a default value been given */
751        if (dflt != NULL && PyErr_ExceptionMatches(PyExc_TypeError)) {
752            PyErr_Clear();
753            Py_INCREF(dflt);
754            return dflt;
755        }
756        else
757            return NULL;
758    }
759
760    return PyInt_FromSize_t(size);
761}
762
763PyDoc_STRVAR(getsizeof_doc,
764"getsizeof(object, default) -> int\n\
765\n\
766Return the size of object in bytes.");
767
768static PyObject *
769sys_getrefcount(PyObject *self, PyObject *arg)
770{
771    return PyInt_FromSsize_t(arg->ob_refcnt);
772}
773
774#ifdef Py_REF_DEBUG
775static PyObject *
776sys_gettotalrefcount(PyObject *self)
777{
778    return PyInt_FromSsize_t(_Py_GetRefTotal());
779}
780#endif /* Py_REF_DEBUG */
781
782PyDoc_STRVAR(getrefcount_doc,
783"getrefcount(object) -> integer\n\
784\n\
785Return the reference count of object.  The count returned is generally\n\
786one higher than you might expect, because it includes the (temporary)\n\
787reference as an argument to getrefcount()."
788);
789
790#ifdef COUNT_ALLOCS
791static PyObject *
792sys_getcounts(PyObject *self)
793{
794    extern PyObject *get_counts(void);
795
796    return get_counts();
797}
798#endif
799
800PyDoc_STRVAR(getframe_doc,
801"_getframe([depth]) -> frameobject\n\
802\n\
803Return a frame object from the call stack.  If optional integer depth is\n\
804given, return the frame object that many calls below the top of the stack.\n\
805If that is deeper than the call stack, ValueError is raised.  The default\n\
806for depth is zero, returning the frame at the top of the call stack.\n\
807\n\
808This function should be used for internal and specialized\n\
809purposes only."
810);
811
812static PyObject *
813sys_getframe(PyObject *self, PyObject *args)
814{
815    PyFrameObject *f = PyThreadState_GET()->frame;
816    int depth = -1;
817
818    if (!PyArg_ParseTuple(args, "|i:_getframe", &depth))
819        return NULL;
820
821    while (depth > 0 && f != NULL) {
822        f = f->f_back;
823        --depth;
824    }
825    if (f == NULL) {
826        PyErr_SetString(PyExc_ValueError,
827                        "call stack is not deep enough");
828        return NULL;
829    }
830    Py_INCREF(f);
831    return (PyObject*)f;
832}
833
834PyDoc_STRVAR(current_frames_doc,
835"_current_frames() -> dictionary\n\
836\n\
837Return a dictionary mapping each current thread T's thread id to T's\n\
838current stack frame.\n\
839\n\
840This function should be used for specialized purposes only."
841);
842
843static PyObject *
844sys_current_frames(PyObject *self, PyObject *noargs)
845{
846    return _PyThread_CurrentFrames();
847}
848
849PyDoc_STRVAR(call_tracing_doc,
850"call_tracing(func, args) -> object\n\
851\n\
852Call func(*args), while tracing is enabled.  The tracing state is\n\
853saved, and restored afterwards.  This is intended to be called from\n\
854a debugger from a checkpoint, to recursively debug some other code."
855);
856
857static PyObject *
858sys_call_tracing(PyObject *self, PyObject *args)
859{
860    PyObject *func, *funcargs;
861    if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs))
862        return NULL;
863    return _PyEval_CallTracing(func, funcargs);
864}
865
866PyDoc_STRVAR(callstats_doc,
867"callstats() -> tuple of integers\n\
868\n\
869Return a tuple of function call statistics, if CALL_PROFILE was defined\n\
870when Python was built.  Otherwise, return None.\n\
871\n\
872When enabled, this function returns detailed, implementation-specific\n\
873details about the number of function calls executed. The return value is\n\
874a 11-tuple where the entries in the tuple are counts of:\n\
8750. all function calls\n\
8761. calls to PyFunction_Type objects\n\
8772. PyFunction calls that do not create an argument tuple\n\
8783. PyFunction calls that do not create an argument tuple\n\
879   and bypass PyEval_EvalCodeEx()\n\
8804. PyMethod calls\n\
8815. PyMethod calls on bound methods\n\
8826. PyType calls\n\
8837. PyCFunction calls\n\
8848. generator calls\n\
8859. All other calls\n\
88610. Number of stack pops performed by call_function()"
887);
888
889#ifdef __cplusplus
890extern "C" {
891#endif
892
893#ifdef Py_TRACE_REFS
894/* Defined in objects.c because it uses static globals if that file */
895extern PyObject *_Py_GetObjects(PyObject *, PyObject *);
896#endif
897
898#ifdef DYNAMIC_EXECUTION_PROFILE
899/* Defined in ceval.c because it uses static globals if that file */
900extern PyObject *_Py_GetDXProfile(PyObject *,  PyObject *);
901#endif
902
903#ifdef __cplusplus
904}
905#endif
906
907static PyObject *
908sys_clear_type_cache(PyObject* self, PyObject* args)
909{
910    PyType_ClearCache();
911    Py_RETURN_NONE;
912}
913
914PyDoc_STRVAR(sys_clear_type_cache__doc__,
915"_clear_type_cache() -> None\n\
916Clear the internal type lookup cache.");
917
918
919static PyMethodDef sys_methods[] = {
920    /* Might as well keep this in alphabetic order */
921    {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS,
922     callstats_doc},
923    {"_clear_type_cache",       sys_clear_type_cache,     METH_NOARGS,
924     sys_clear_type_cache__doc__},
925    {"_current_frames", sys_current_frames, METH_NOARGS,
926     current_frames_doc},
927    {"displayhook",     sys_displayhook, METH_O, displayhook_doc},
928    {"exc_info",        sys_exc_info, METH_NOARGS, exc_info_doc},
929    {"exc_clear",       sys_exc_clear, METH_NOARGS, exc_clear_doc},
930    {"excepthook",      sys_excepthook, METH_VARARGS, excepthook_doc},
931    {"exit",            sys_exit, METH_VARARGS, exit_doc},
932#ifdef Py_USING_UNICODE
933    {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding,
934     METH_NOARGS, getdefaultencoding_doc},
935#endif
936#ifdef HAVE_DLOPEN
937    {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS,
938     getdlopenflags_doc},
939#endif
940#ifdef COUNT_ALLOCS
941    {"getcounts",       (PyCFunction)sys_getcounts, METH_NOARGS},
942#endif
943#ifdef DYNAMIC_EXECUTION_PROFILE
944    {"getdxp",          _Py_GetDXProfile, METH_VARARGS},
945#endif
946#ifdef Py_USING_UNICODE
947    {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding,
948     METH_NOARGS, getfilesystemencoding_doc},
949#endif
950#ifdef Py_TRACE_REFS
951    {"getobjects",      _Py_GetObjects, METH_VARARGS},
952#endif
953#ifdef Py_REF_DEBUG
954    {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS},
955#endif
956    {"getrefcount",     (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
957    {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS,
958     getrecursionlimit_doc},
959    {"getsizeof",   (PyCFunction)sys_getsizeof,
960     METH_VARARGS | METH_KEYWORDS, getsizeof_doc},
961    {"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
962#ifdef MS_WINDOWS
963    {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
964     getwindowsversion_doc},
965#endif /* MS_WINDOWS */
966#ifdef USE_MALLOPT
967    {"mdebug",          sys_mdebug, METH_VARARGS},
968#endif
969#ifdef Py_USING_UNICODE
970    {"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS,
971     setdefaultencoding_doc},
972#endif
973    {"setcheckinterval",        sys_setcheckinterval, METH_VARARGS,
974     setcheckinterval_doc},
975    {"getcheckinterval",        sys_getcheckinterval, METH_NOARGS,
976     getcheckinterval_doc},
977#ifdef HAVE_DLOPEN
978    {"setdlopenflags", sys_setdlopenflags, METH_VARARGS,
979     setdlopenflags_doc},
980#endif
981    {"setprofile",      sys_setprofile, METH_O, setprofile_doc},
982    {"getprofile",      sys_getprofile, METH_NOARGS, getprofile_doc},
983    {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS,
984     setrecursionlimit_doc},
985#ifdef WITH_TSC
986    {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc},
987#endif
988    {"settrace",        sys_settrace, METH_O, settrace_doc},
989    {"gettrace",        sys_gettrace, METH_NOARGS, gettrace_doc},
990    {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},
991    {NULL,              NULL}           /* sentinel */
992};
993
994static PyObject *
995list_builtin_module_names(void)
996{
997    PyObject *list = PyList_New(0);
998    int i;
999    if (list == NULL)
1000        return NULL;
1001    for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
1002        PyObject *name = PyString_FromString(
1003            PyImport_Inittab[i].name);
1004        if (name == NULL)
1005            break;
1006        PyList_Append(list, name);
1007        Py_DECREF(name);
1008    }
1009    if (PyList_Sort(list) != 0) {
1010        Py_DECREF(list);
1011        list = NULL;
1012    }
1013    if (list) {
1014        PyObject *v = PyList_AsTuple(list);
1015        Py_DECREF(list);
1016        list = v;
1017    }
1018    return list;
1019}
1020
1021static PyObject *warnoptions = NULL;
1022
1023void
1024PySys_ResetWarnOptions(void)
1025{
1026    if (warnoptions == NULL || !PyList_Check(warnoptions))
1027        return;
1028    PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
1029}
1030
1031void
1032PySys_AddWarnOption(char *s)
1033{
1034    PyObject *str;
1035
1036    if (warnoptions == NULL || !PyList_Check(warnoptions)) {
1037        Py_XDECREF(warnoptions);
1038        warnoptions = PyList_New(0);
1039        if (warnoptions == NULL)
1040            return;
1041    }
1042    str = PyString_FromString(s);
1043    if (str != NULL) {
1044        PyList_Append(warnoptions, str);
1045        Py_DECREF(str);
1046    }
1047}
1048
1049int
1050PySys_HasWarnOptions(void)
1051{
1052    return (warnoptions != NULL && (PyList_Size(warnoptions) > 0)) ? 1 : 0;
1053}
1054
1055/* XXX This doc string is too long to be a single string literal in VC++ 5.0.
1056   Two literals concatenated works just fine.  If you have a K&R compiler
1057   or other abomination that however *does* understand longer strings,
1058   get rid of the !!! comment in the middle and the quotes that surround it. */
1059PyDoc_VAR(sys_doc) =
1060PyDoc_STR(
1061"This module provides access to some objects used or maintained by the\n\
1062interpreter and to functions that interact strongly with the interpreter.\n\
1063\n\
1064Dynamic objects:\n\
1065\n\
1066argv -- command line arguments; argv[0] is the script pathname if known\n\
1067path -- module search path; path[0] is the script directory, else ''\n\
1068modules -- dictionary of loaded modules\n\
1069\n\
1070displayhook -- called to show results in an interactive session\n\
1071excepthook -- called to handle any uncaught exception other than SystemExit\n\
1072  To customize printing in an interactive session or to install a custom\n\
1073  top-level exception handler, assign other functions to replace these.\n\
1074\n\
1075exitfunc -- if sys.exitfunc exists, this routine is called when Python exits\n\
1076  Assigning to sys.exitfunc is deprecated; use the atexit module instead.\n\
1077\n\
1078stdin -- standard input file object; used by raw_input() and input()\n\
1079stdout -- standard output file object; used by the print statement\n\
1080stderr -- standard error object; used for error messages\n\
1081  By assigning other file objects (or objects that behave like files)\n\
1082  to these, it is possible to redirect all of the interpreter's I/O.\n\
1083\n\
1084last_type -- type of last uncaught exception\n\
1085last_value -- value of last uncaught exception\n\
1086last_traceback -- traceback of last uncaught exception\n\
1087  These three are only available in an interactive session after a\n\
1088  traceback has been printed.\n\
1089\n\
1090exc_type -- type of exception currently being handled\n\
1091exc_value -- value of exception currently being handled\n\
1092exc_traceback -- traceback of exception currently being handled\n\
1093  The function exc_info() should be used instead of these three,\n\
1094  because it is thread-safe.\n\
1095"
1096)
1097/* concatenating string here */
1098PyDoc_STR(
1099"\n\
1100Static objects:\n\
1101\n\
1102float_info -- a dict with information about the float inplementation.\n\
1103long_info -- a struct sequence with information about the long implementation.\n\
1104maxint -- the largest supported integer (the smallest is -maxint-1)\n\
1105maxsize -- the largest supported length of containers.\n\
1106maxunicode -- the largest supported character\n\
1107builtin_module_names -- tuple of module names built into this interpreter\n\
1108version -- the version of this interpreter as a string\n\
1109version_info -- version information as a named tuple\n\
1110hexversion -- version information encoded as a single integer\n\
1111copyright -- copyright notice pertaining to this interpreter\n\
1112platform -- platform identifier\n\
1113executable -- absolute path of the executable binary of the Python interpreter\n\
1114prefix -- prefix used to find the Python library\n\
1115exec_prefix -- prefix used to find the machine-specific Python library\n\
1116float_repr_style -- string indicating the style of repr() output for floats\n\
1117"
1118)
1119#ifdef MS_WINDOWS
1120/* concatenating string here */
1121PyDoc_STR(
1122"dllhandle -- [Windows only] integer handle of the Python DLL\n\
1123winver -- [Windows only] version number of the Python DLL\n\
1124"
1125)
1126#endif /* MS_WINDOWS */
1127PyDoc_STR(
1128"__stdin__ -- the original stdin; don't touch!\n\
1129__stdout__ -- the original stdout; don't touch!\n\
1130__stderr__ -- the original stderr; don't touch!\n\
1131__displayhook__ -- the original displayhook; don't touch!\n\
1132__excepthook__ -- the original excepthook; don't touch!\n\
1133\n\
1134Functions:\n\
1135\n\
1136displayhook() -- print an object to the screen, and save it in __builtin__._\n\
1137excepthook() -- print an exception and its traceback to sys.stderr\n\
1138exc_info() -- return thread-safe information about the current exception\n\
1139exc_clear() -- clear the exception state for the current thread\n\
1140exit() -- exit the interpreter by raising SystemExit\n\
1141getdlopenflags() -- returns flags to be used for dlopen() calls\n\
1142getprofile() -- get the global profiling function\n\
1143getrefcount() -- return the reference count for an object (plus one :-)\n\
1144getrecursionlimit() -- return the max recursion depth for the interpreter\n\
1145getsizeof() -- return the size of an object in bytes\n\
1146gettrace() -- get the global debug tracing function\n\
1147setcheckinterval() -- control how often the interpreter checks for events\n\
1148setdlopenflags() -- set the flags to be used for dlopen() calls\n\
1149setprofile() -- set the global profiling function\n\
1150setrecursionlimit() -- set the max recursion depth for the interpreter\n\
1151settrace() -- set the global debug tracing function\n\
1152"
1153)
1154/* end of sys_doc */ ;
1155
1156static int
1157_check_and_flush (FILE *stream)
1158{
1159  int prev_fail = ferror (stream);
1160  return fflush (stream) || prev_fail ? EOF : 0;
1161}
1162
1163/* Subversion branch and revision management */
1164static int svn_initialized;
1165static char patchlevel_revision[50]; /* Just the number */
1166static char branch[50];
1167static char shortbranch[50];
1168static const char *svn_revision;
1169
1170static void
1171svnversion_init(void)
1172{
1173    if (svn_initialized)
1174        return;
1175    svn_initialized = 1;
1176    *patchlevel_revision = '\0';
1177    strcpy(branch, "");
1178    strcpy(shortbranch, "unknown");
1179    svn_revision = "";
1180    return;
1181}
1182
1183/* Return svnversion output if available.
1184   Else return Revision of patchlevel.h if on branch.
1185   Else return empty string */
1186const char*
1187Py_SubversionRevision()
1188{
1189    svnversion_init();
1190    return svn_revision;
1191}
1192
1193const char*
1194Py_SubversionShortBranch()
1195{
1196    svnversion_init();
1197    return shortbranch;
1198}
1199
1200
1201PyDoc_STRVAR(flags__doc__,
1202"sys.flags\n\
1203\n\
1204Flags provided through command line arguments or environment vars.");
1205
1206static PyTypeObject FlagsType = {0, 0, 0, 0, 0, 0};
1207
1208static PyStructSequence_Field flags_fields[] = {
1209    {"debug",                   "-d"},
1210    {"py3k_warning",            "-3"},
1211    {"division_warning",        "-Q"},
1212    {"division_new",            "-Qnew"},
1213    {"inspect",                 "-i"},
1214    {"interactive",             "-i"},
1215    {"optimize",                "-O or -OO"},
1216    {"dont_write_bytecode",     "-B"},
1217    {"no_user_site",            "-s"},
1218    {"no_site",                 "-S"},
1219    {"ignore_environment",      "-E"},
1220    {"tabcheck",                "-t or -tt"},
1221    {"verbose",                 "-v"},
1222#ifdef RISCOS
1223    {"riscos_wimp",             "???"},
1224#endif
1225    /* {"unbuffered",                   "-u"}, */
1226    {"unicode",                 "-U"},
1227    /* {"skip_first",                   "-x"}, */
1228    {"bytes_warning", "-b"},
1229    {"hash_randomization", "-R"},
1230    {0}
1231};
1232
1233static PyStructSequence_Desc flags_desc = {
1234    "sys.flags",        /* name */
1235    flags__doc__,       /* doc */
1236    flags_fields,       /* fields */
1237#ifdef RISCOS
1238    17
1239#else
1240    16
1241#endif
1242};
1243
1244static PyObject*
1245make_flags(void)
1246{
1247    int pos = 0;
1248    PyObject *seq;
1249
1250    seq = PyStructSequence_New(&FlagsType);
1251    if (seq == NULL)
1252        return NULL;
1253
1254#define SetFlag(flag) \
1255    PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag))
1256
1257    SetFlag(Py_DebugFlag);
1258    SetFlag(Py_Py3kWarningFlag);
1259    SetFlag(Py_DivisionWarningFlag);
1260    SetFlag(_Py_QnewFlag);
1261    SetFlag(Py_InspectFlag);
1262    SetFlag(Py_InteractiveFlag);
1263    SetFlag(Py_OptimizeFlag);
1264    SetFlag(Py_DontWriteBytecodeFlag);
1265    SetFlag(Py_NoUserSiteDirectory);
1266    SetFlag(Py_NoSiteFlag);
1267    SetFlag(Py_IgnoreEnvironmentFlag);
1268    SetFlag(Py_TabcheckFlag);
1269    SetFlag(Py_VerboseFlag);
1270#ifdef RISCOS
1271    SetFlag(Py_RISCOSWimpFlag);
1272#endif
1273    /* SetFlag(saw_unbuffered_flag); */
1274    SetFlag(Py_UnicodeFlag);
1275    /* SetFlag(skipfirstline); */
1276    SetFlag(Py_BytesWarningFlag);
1277    SetFlag(Py_HashRandomizationFlag);
1278#undef SetFlag
1279
1280    if (PyErr_Occurred()) {
1281        Py_DECREF(seq);
1282        return NULL;
1283    }
1284    return seq;
1285}
1286
1287PyDoc_STRVAR(version_info__doc__,
1288"sys.version_info\n\
1289\n\
1290Version information as a named tuple.");
1291
1292static PyTypeObject VersionInfoType = {0, 0, 0, 0, 0, 0};
1293
1294static PyStructSequence_Field version_info_fields[] = {
1295    {"major", "Major release number"},
1296    {"minor", "Minor release number"},
1297    {"micro", "Patch release number"},
1298    {"releaselevel", "'alpha', 'beta', 'candidate', or 'final'"},
1299    {"serial", "Serial release number"},
1300    {0}
1301};
1302
1303static PyStructSequence_Desc version_info_desc = {
1304    "sys.version_info",     /* name */
1305    version_info__doc__,    /* doc */
1306    version_info_fields,    /* fields */
1307    5
1308};
1309
1310static PyObject *
1311make_version_info(void)
1312{
1313    PyObject *version_info;
1314    char *s;
1315    int pos = 0;
1316
1317    version_info = PyStructSequence_New(&VersionInfoType);
1318    if (version_info == NULL) {
1319        return NULL;
1320    }
1321
1322    /*
1323     * These release level checks are mutually exclusive and cover
1324     * the field, so don't get too fancy with the pre-processor!
1325     */
1326#if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
1327    s = "alpha";
1328#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
1329    s = "beta";
1330#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
1331    s = "candidate";
1332#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
1333    s = "final";
1334#endif
1335
1336#define SetIntItem(flag) \
1337    PyStructSequence_SET_ITEM(version_info, pos++, PyInt_FromLong(flag))
1338#define SetStrItem(flag) \
1339    PyStructSequence_SET_ITEM(version_info, pos++, PyString_FromString(flag))
1340
1341    SetIntItem(PY_MAJOR_VERSION);
1342    SetIntItem(PY_MINOR_VERSION);
1343    SetIntItem(PY_MICRO_VERSION);
1344    SetStrItem(s);
1345    SetIntItem(PY_RELEASE_SERIAL);
1346#undef SetIntItem
1347#undef SetStrItem
1348
1349    if (PyErr_Occurred()) {
1350        Py_CLEAR(version_info);
1351        return NULL;
1352    }
1353    return version_info;
1354}
1355
1356PyObject *
1357_PySys_Init(void)
1358{
1359    PyObject *m, *v, *sysdict;
1360    PyObject *sysin, *sysout, *syserr;
1361    char *s;
1362
1363    m = Py_InitModule3("sys", sys_methods, sys_doc);
1364    if (m == NULL)
1365        return NULL;
1366    sysdict = PyModule_GetDict(m);
1367#define SET_SYS_FROM_STRING(key, value)                 \
1368    v = value;                                          \
1369    if (v != NULL)                                      \
1370        PyDict_SetItemString(sysdict, key, v);          \
1371    Py_XDECREF(v)
1372
1373    /* Check that stdin is not a directory
1374    Using shell redirection, you can redirect stdin to a directory,
1375    crashing the Python interpreter. Catch this common mistake here
1376    and output a useful error message. Note that under MS Windows,
1377    the shell already prevents that. */
1378#if !defined(MS_WINDOWS)
1379    {
1380        struct stat sb;
1381        if (fstat(fileno(stdin), &sb) == 0 &&
1382            S_ISDIR(sb.st_mode)) {
1383            /* There's nothing more we can do. */
1384            /* Py_FatalError() will core dump, so just exit. */
1385            PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
1386            exit(EXIT_FAILURE);
1387        }
1388    }
1389#endif
1390
1391    /* Closing the standard FILE* if sys.std* goes aways causes problems
1392     * for embedded Python usages. Closing them when somebody explicitly
1393     * invokes .close() might be possible, but the FAQ promises they get
1394     * never closed. However, we still need to get write errors when
1395     * writing fails (e.g. because stdout is redirected), so we flush the
1396     * streams and check for errors before the file objects are deleted.
1397     * On OS X, fflush()ing stdin causes an error, so we exempt stdin
1398     * from that procedure.
1399     */
1400    sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL);
1401    sysout = PyFile_FromFile(stdout, "<stdout>", "w", _check_and_flush);
1402    syserr = PyFile_FromFile(stderr, "<stderr>", "w", _check_and_flush);
1403    if (PyErr_Occurred())
1404        return NULL;
1405
1406    PyDict_SetItemString(sysdict, "stdin", sysin);
1407    PyDict_SetItemString(sysdict, "stdout", sysout);
1408    PyDict_SetItemString(sysdict, "stderr", syserr);
1409    /* Make backup copies for cleanup */
1410    PyDict_SetItemString(sysdict, "__stdin__", sysin);
1411    PyDict_SetItemString(sysdict, "__stdout__", sysout);
1412    PyDict_SetItemString(sysdict, "__stderr__", syserr);
1413    PyDict_SetItemString(sysdict, "__displayhook__",
1414                         PyDict_GetItemString(sysdict, "displayhook"));
1415    PyDict_SetItemString(sysdict, "__excepthook__",
1416                         PyDict_GetItemString(sysdict, "excepthook"));
1417    Py_XDECREF(sysin);
1418    Py_XDECREF(sysout);
1419    Py_XDECREF(syserr);
1420
1421    SET_SYS_FROM_STRING("version",
1422                         PyString_FromString(Py_GetVersion()));
1423    SET_SYS_FROM_STRING("hexversion",
1424                         PyInt_FromLong(PY_VERSION_HEX));
1425    svnversion_init();
1426    SET_SYS_FROM_STRING("subversion",
1427                         Py_BuildValue("(ssz)", "CPython", branch,
1428                                      svn_revision));
1429    SET_SYS_FROM_STRING("_mercurial",
1430                        Py_BuildValue("(szz)", "CPython", _Py_hgidentifier(),
1431                                      _Py_hgversion()));
1432    SET_SYS_FROM_STRING("dont_write_bytecode",
1433                         PyBool_FromLong(Py_DontWriteBytecodeFlag));
1434    SET_SYS_FROM_STRING("api_version",
1435                        PyInt_FromLong(PYTHON_API_VERSION));
1436    SET_SYS_FROM_STRING("copyright",
1437                        PyString_FromString(Py_GetCopyright()));
1438    SET_SYS_FROM_STRING("platform",
1439                        PyString_FromString(Py_GetPlatform()));
1440    SET_SYS_FROM_STRING("executable",
1441                        PyString_FromString(Py_GetProgramFullPath()));
1442    SET_SYS_FROM_STRING("prefix",
1443                        PyString_FromString(Py_GetPrefix()));
1444    SET_SYS_FROM_STRING("exec_prefix",
1445                        PyString_FromString(Py_GetExecPrefix()));
1446    SET_SYS_FROM_STRING("maxsize",
1447                        PyInt_FromSsize_t(PY_SSIZE_T_MAX));
1448    SET_SYS_FROM_STRING("maxint",
1449                        PyInt_FromLong(PyInt_GetMax()));
1450    SET_SYS_FROM_STRING("py3kwarning",
1451                        PyBool_FromLong(Py_Py3kWarningFlag));
1452    SET_SYS_FROM_STRING("float_info",
1453                        PyFloat_GetInfo());
1454    SET_SYS_FROM_STRING("long_info",
1455                        PyLong_GetInfo());
1456#ifdef Py_USING_UNICODE
1457    SET_SYS_FROM_STRING("maxunicode",
1458                        PyInt_FromLong(PyUnicode_GetMax()));
1459#endif
1460    SET_SYS_FROM_STRING("builtin_module_names",
1461                        list_builtin_module_names());
1462    {
1463        /* Assumes that longs are at least 2 bytes long.
1464           Should be safe! */
1465        unsigned long number = 1;
1466        char *value;
1467
1468        s = (char *) &number;
1469        if (s[0] == 0)
1470            value = "big";
1471        else
1472            value = "little";
1473        SET_SYS_FROM_STRING("byteorder",
1474                            PyString_FromString(value));
1475    }
1476#ifdef MS_COREDLL
1477    SET_SYS_FROM_STRING("dllhandle",
1478                        PyLong_FromVoidPtr(PyWin_DLLhModule));
1479    SET_SYS_FROM_STRING("winver",
1480                        PyString_FromString(PyWin_DLLVersionString));
1481#endif
1482    if (warnoptions == NULL) {
1483        warnoptions = PyList_New(0);
1484    }
1485    else {
1486        Py_INCREF(warnoptions);
1487    }
1488    if (warnoptions != NULL) {
1489        PyDict_SetItemString(sysdict, "warnoptions", warnoptions);
1490    }
1491
1492    /* version_info */
1493    if (VersionInfoType.tp_name == 0)
1494        PyStructSequence_InitType(&VersionInfoType, &version_info_desc);
1495    SET_SYS_FROM_STRING("version_info", make_version_info());
1496    /* prevent user from creating new instances */
1497    VersionInfoType.tp_init = NULL;
1498    VersionInfoType.tp_new = NULL;
1499
1500    /* flags */
1501    if (FlagsType.tp_name == 0)
1502        PyStructSequence_InitType(&FlagsType, &flags_desc);
1503    SET_SYS_FROM_STRING("flags", make_flags());
1504    /* prevent user from creating new instances */
1505    FlagsType.tp_init = NULL;
1506    FlagsType.tp_new = NULL;
1507
1508
1509#if defined(MS_WINDOWS)
1510    /* getwindowsversion */
1511    if (WindowsVersionType.tp_name == 0)
1512        PyStructSequence_InitType(&WindowsVersionType, &windows_version_desc);
1513    /* prevent user from creating new instances */
1514    WindowsVersionType.tp_init = NULL;
1515    WindowsVersionType.tp_new = NULL;
1516#endif
1517
1518    /* float repr style: 0.03 (short) vs 0.029999999999999999 (legacy) */
1519#ifndef PY_NO_SHORT_FLOAT_REPR
1520    SET_SYS_FROM_STRING("float_repr_style",
1521                        PyString_FromString("short"));
1522#else
1523    SET_SYS_FROM_STRING("float_repr_style",
1524                        PyString_FromString("legacy"));
1525#endif
1526
1527#undef SET_SYS_FROM_STRING
1528    if (PyErr_Occurred())
1529        return NULL;
1530    return m;
1531}
1532
1533static PyObject *
1534makepathobject(char *path, int delim)
1535{
1536    int i, n;
1537    char *p;
1538    PyObject *v, *w;
1539
1540    n = 1;
1541    p = path;
1542    while ((p = strchr(p, delim)) != NULL) {
1543        n++;
1544        p++;
1545    }
1546    v = PyList_New(n);
1547    if (v == NULL)
1548        return NULL;
1549    for (i = 0; ; i++) {
1550        p = strchr(path, delim);
1551        if (p == NULL)
1552            p = strchr(path, '\0'); /* End of string */
1553        w = PyString_FromStringAndSize(path, (Py_ssize_t) (p - path));
1554        if (w == NULL) {
1555            Py_DECREF(v);
1556            return NULL;
1557        }
1558        PyList_SetItem(v, i, w);
1559        if (*p == '\0')
1560            break;
1561        path = p+1;
1562    }
1563    return v;
1564}
1565
1566void
1567PySys_SetPath(char *path)
1568{
1569    PyObject *v;
1570    if ((v = makepathobject(path, DELIM)) == NULL)
1571        Py_FatalError("can't create sys.path");
1572    if (PySys_SetObject("path", v) != 0)
1573        Py_FatalError("can't assign sys.path");
1574    Py_DECREF(v);
1575}
1576
1577static PyObject *
1578makeargvobject(int argc, char **argv)
1579{
1580    PyObject *av;
1581    if (argc <= 0 || argv == NULL) {
1582        /* Ensure at least one (empty) argument is seen */
1583        static char *empty_argv[1] = {""};
1584        argv = empty_argv;
1585        argc = 1;
1586    }
1587    av = PyList_New(argc);
1588    if (av != NULL) {
1589        int i;
1590        for (i = 0; i < argc; i++) {
1591#ifdef __VMS
1592            PyObject *v;
1593
1594            /* argv[0] is the script pathname if known */
1595            if (i == 0) {
1596                char* fn = decc$translate_vms(argv[0]);
1597                if ((fn == (char *)0) || fn == (char *)-1)
1598                    v = PyString_FromString(argv[0]);
1599                else
1600                    v = PyString_FromString(
1601                        decc$translate_vms(argv[0]));
1602            } else
1603                v = PyString_FromString(argv[i]);
1604#else
1605            PyObject *v = PyString_FromString(argv[i]);
1606#endif
1607            if (v == NULL) {
1608                Py_DECREF(av);
1609                av = NULL;
1610                break;
1611            }
1612            PyList_SetItem(av, i, v);
1613        }
1614    }
1615    return av;
1616}
1617
1618void
1619PySys_SetArgvEx(int argc, char **argv, int updatepath)
1620{
1621#if defined(HAVE_REALPATH)
1622    char fullpath[MAXPATHLEN];
1623#elif defined(MS_WINDOWS) && !defined(MS_WINCE)
1624    char fullpath[MAX_PATH];
1625#endif
1626    PyObject *av = makeargvobject(argc, argv);
1627    PyObject *path = PySys_GetObject("path");
1628    if (av == NULL)
1629        Py_FatalError("no mem for sys.argv");
1630    if (PySys_SetObject("argv", av) != 0)
1631        Py_FatalError("can't assign sys.argv");
1632    if (updatepath && path != NULL) {
1633        char *argv0 = argv[0];
1634        char *p = NULL;
1635        Py_ssize_t n = 0;
1636        PyObject *a;
1637#ifdef HAVE_READLINK
1638        char link[MAXPATHLEN+1];
1639        char argv0copy[2*MAXPATHLEN+1];
1640        int nr = 0;
1641        if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0)
1642            nr = readlink(argv0, link, MAXPATHLEN);
1643        if (nr > 0) {
1644            /* It's a symlink */
1645            link[nr] = '\0';
1646            if (link[0] == SEP)
1647                argv0 = link; /* Link to absolute path */
1648            else if (strchr(link, SEP) == NULL)
1649                ; /* Link without path */
1650            else {
1651                /* Must join(dirname(argv0), link) */
1652                char *q = strrchr(argv0, SEP);
1653                if (q == NULL)
1654                    argv0 = link; /* argv0 without path */
1655                else {
1656                    /* Must make a copy */
1657                    strcpy(argv0copy, argv0);
1658                    q = strrchr(argv0copy, SEP);
1659                    strcpy(q+1, link);
1660                    argv0 = argv0copy;
1661                }
1662            }
1663        }
1664#endif /* HAVE_READLINK */
1665#if SEP == '\\' /* Special case for MS filename syntax */
1666        if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
1667            char *q;
1668#if defined(MS_WINDOWS) && !defined(MS_WINCE)
1669            /* This code here replaces the first element in argv with the full
1670            path that it represents. Under CE, there are no relative paths so
1671            the argument must be the full path anyway. */
1672            char *ptemp;
1673            if (GetFullPathName(argv0,
1674                               sizeof(fullpath),
1675                               fullpath,
1676                               &ptemp)) {
1677                argv0 = fullpath;
1678            }
1679#endif
1680            p = strrchr(argv0, SEP);
1681            /* Test for alternate separator */
1682            q = strrchr(p ? p : argv0, '/');
1683            if (q != NULL)
1684                p = q;
1685            if (p != NULL) {
1686                n = p + 1 - argv0;
1687                if (n > 1 && p[-1] != ':')
1688                    n--; /* Drop trailing separator */
1689            }
1690        }
1691#else /* All other filename syntaxes */
1692        if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
1693#if defined(HAVE_REALPATH)
1694            if (realpath(argv0, fullpath)) {
1695                argv0 = fullpath;
1696            }
1697#endif
1698            p = strrchr(argv0, SEP);
1699        }
1700        if (p != NULL) {
1701#ifndef RISCOS
1702            n = p + 1 - argv0;
1703#else /* don't include trailing separator */
1704            n = p - argv0;
1705#endif /* RISCOS */
1706#if SEP == '/' /* Special case for Unix filename syntax */
1707            if (n > 1)
1708                n--; /* Drop trailing separator */
1709#endif /* Unix */
1710        }
1711#endif /* All others */
1712        a = PyString_FromStringAndSize(argv0, n);
1713        if (a == NULL)
1714            Py_FatalError("no mem for sys.path insertion");
1715        if (PyList_Insert(path, 0, a) < 0)
1716            Py_FatalError("sys.path.insert(0) failed");
1717        Py_DECREF(a);
1718    }
1719    Py_DECREF(av);
1720}
1721
1722void
1723PySys_SetArgv(int argc, char **argv)
1724{
1725    PySys_SetArgvEx(argc, argv, 1);
1726}
1727
1728
1729/* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
1730   Adapted from code submitted by Just van Rossum.
1731
1732   PySys_WriteStdout(format, ...)
1733   PySys_WriteStderr(format, ...)
1734
1735      The first function writes to sys.stdout; the second to sys.stderr.  When
1736      there is a problem, they write to the real (C level) stdout or stderr;
1737      no exceptions are raised.
1738
1739      Both take a printf-style format string as their first argument followed
1740      by a variable length argument list determined by the format string.
1741
1742      *** WARNING ***
1743
1744      The format should limit the total size of the formatted output string to
1745      1000 bytes.  In particular, this means that no unrestricted "%s" formats
1746      should occur; these should be limited using "%.<N>s where <N> is a
1747      decimal number calculated so that <N> plus the maximum size of other
1748      formatted text does not exceed 1000 bytes.  Also watch out for "%f",
1749      which can print hundreds of digits for very large numbers.
1750
1751 */
1752
1753static void
1754mywrite(char *name, FILE *fp, const char *format, va_list va)
1755{
1756    PyObject *file;
1757    PyObject *error_type, *error_value, *error_traceback;
1758
1759    PyErr_Fetch(&error_type, &error_value, &error_traceback);
1760    file = PySys_GetObject(name);
1761    if (file == NULL || PyFile_AsFile(file) == fp)
1762        vfprintf(fp, format, va);
1763    else {
1764        char buffer[1001];
1765        const int written = PyOS_vsnprintf(buffer, sizeof(buffer),
1766                                           format, va);
1767        if (PyFile_WriteString(buffer, file) != 0) {
1768            PyErr_Clear();
1769            fputs(buffer, fp);
1770        }
1771        if (written < 0 || (size_t)written >= sizeof(buffer)) {
1772            const char *truncated = "... truncated";
1773            if (PyFile_WriteString(truncated, file) != 0) {
1774                PyErr_Clear();
1775                fputs(truncated, fp);
1776            }
1777        }
1778    }
1779    PyErr_Restore(error_type, error_value, error_traceback);
1780}
1781
1782void
1783PySys_WriteStdout(const char *format, ...)
1784{
1785    va_list va;
1786
1787    va_start(va, format);
1788    mywrite("stdout", stdout, format, va);
1789    va_end(va);
1790}
1791
1792void
1793PySys_WriteStderr(const char *format, ...)
1794{
1795    va_list va;
1796
1797    va_start(va, format);
1798    mywrite("stderr", stderr, format, va);
1799    va_end(va);
1800}
1801