sysmodule.c revision 49526f48fc73d3ccdf09d466ed2d39a30e4df9b9 
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 "code.h"
19#include "frameobject.h"
20#include "pythread.h"
21
22#include "osdefs.h"
23
24#ifdef MS_WINDOWS
25#define WIN32_LEAN_AND_MEAN
26#include <windows.h>
27#endif /* MS_WINDOWS */
28
29#ifdef MS_COREDLL
30extern void *PyWin_DLLhModule;
31/* A string loaded from the DLL at startup: */
32extern const char *PyWin_DLLVersionString;
33#endif
34
35#ifdef __VMS
36#include <unixlib.h>
37#endif
38
39#ifdef HAVE_LANGINFO_H
40#include <locale.h>
41#include <langinfo.h>
42#endif
43
44PyObject *
45PySys_GetObject(const char *name)
46{
47    PyThreadState *tstate = PyThreadState_GET();
48    PyObject *sd = tstate->interp->sysdict;
49    if (sd == NULL)
50        return NULL;
51    return PyDict_GetItemString(sd, name);
52}
53
54int
55PySys_SetObject(const char *name, PyObject *v)
56{
57    PyThreadState *tstate = PyThreadState_GET();
58    PyObject *sd = tstate->interp->sysdict;
59    if (v == NULL) {
60        if (PyDict_GetItemString(sd, name) == NULL)
61            return 0;
62        else
63            return PyDict_DelItemString(sd, name);
64    }
65    else
66        return PyDict_SetItemString(sd, name, v);
67}
68
69/* Write repr(o) to sys.stdout using sys.stdout.encoding and 'backslashreplace'
70   error handler. If sys.stdout has a buffer attribute, use
71   sys.stdout.buffer.write(encoded), otherwise redecode the string and use
72   sys.stdout.write(redecoded).
73
74   Helper function for sys_displayhook(). */
75static int
76sys_displayhook_unencodable(PyObject *outf, PyObject *o)
77{
78    PyObject *stdout_encoding = NULL;
79    PyObject *encoded, *escaped_str, *repr_str, *buffer, *result;
80    char *stdout_encoding_str;
81    int ret;
82    _Py_IDENTIFIER(encoding);
83    _Py_IDENTIFIER(buffer);
84
85    stdout_encoding = _PyObject_GetAttrId(outf, &PyId_encoding);
86    if (stdout_encoding == NULL)
87        goto error;
88    stdout_encoding_str = _PyUnicode_AsString(stdout_encoding);
89    if (stdout_encoding_str == NULL)
90        goto error;
91
92    repr_str = PyObject_Repr(o);
93    if (repr_str == NULL)
94        goto error;
95    encoded = PyUnicode_AsEncodedString(repr_str,
96                                        stdout_encoding_str,
97                                        "backslashreplace");
98    Py_DECREF(repr_str);
99    if (encoded == NULL)
100        goto error;
101
102    buffer = _PyObject_GetAttrId(outf, &PyId_buffer);
103    if (buffer) {
104        _Py_IDENTIFIER(write);
105        result = _PyObject_CallMethodId(buffer, &PyId_write, "(O)", encoded);
106        Py_DECREF(buffer);
107        Py_DECREF(encoded);
108        if (result == NULL)
109            goto error;
110        Py_DECREF(result);
111    }
112    else {
113        PyErr_Clear();
114        escaped_str = PyUnicode_FromEncodedObject(encoded,
115                                                  stdout_encoding_str,
116                                                  "strict");
117        Py_DECREF(encoded);
118        if (PyFile_WriteObject(escaped_str, outf, Py_PRINT_RAW) != 0) {
119            Py_DECREF(escaped_str);
120            goto error;
121        }
122        Py_DECREF(escaped_str);
123    }
124    ret = 0;
125    goto finally;
126
127error:
128    ret = -1;
129finally:
130    Py_XDECREF(stdout_encoding);
131    return ret;
132}
133
134static PyObject *
135sys_displayhook(PyObject *self, PyObject *o)
136{
137    PyObject *outf;
138    PyInterpreterState *interp = PyThreadState_GET()->interp;
139    PyObject *modules = interp->modules;
140    PyObject *builtins = PyDict_GetItemString(modules, "builtins");
141    int err;
142    _Py_IDENTIFIER(_);
143
144    if (builtins == NULL) {
145        PyErr_SetString(PyExc_RuntimeError, "lost builtins module");
146        return NULL;
147    }
148
149    /* Print value except if None */
150    /* After printing, also assign to '_' */
151    /* Before, set '_' to None to avoid recursion */
152    if (o == Py_None) {
153        Py_INCREF(Py_None);
154        return Py_None;
155    }
156    if (_PyObject_SetAttrId(builtins, &PyId__, Py_None) != 0)
157        return NULL;
158    outf = PySys_GetObject("stdout");
159    if (outf == NULL || outf == Py_None) {
160        PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
161        return NULL;
162    }
163    if (PyFile_WriteObject(o, outf, 0) != 0) {
164        if (PyErr_ExceptionMatches(PyExc_UnicodeEncodeError)) {
165            /* repr(o) is not encodable to sys.stdout.encoding with
166             * sys.stdout.errors error handler (which is probably 'strict') */
167            PyErr_Clear();
168            err = sys_displayhook_unencodable(outf, o);
169            if (err)
170                return NULL;
171        }
172        else {
173            return NULL;
174        }
175    }
176    if (PyFile_WriteString("\n", outf) != 0)
177        return NULL;
178    if (_PyObject_SetAttrId(builtins, &PyId__, o) != 0)
179        return NULL;
180    Py_INCREF(Py_None);
181    return Py_None;
182}
183
184PyDoc_STRVAR(displayhook_doc,
185"displayhook(object) -> None\n"
186"\n"
187"Print an object to sys.stdout and also save it in builtins._\n"
188);
189
190static PyObject *
191sys_excepthook(PyObject* self, PyObject* args)
192{
193    PyObject *exc, *value, *tb;
194    if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb))
195        return NULL;
196    PyErr_Display(exc, value, tb);
197    Py_INCREF(Py_None);
198    return Py_None;
199}
200
201PyDoc_STRVAR(excepthook_doc,
202"excepthook(exctype, value, traceback) -> None\n"
203"\n"
204"Handle an exception by displaying it with a traceback on sys.stderr.\n"
205);
206
207static PyObject *
208sys_exc_info(PyObject *self, PyObject *noargs)
209{
210    PyThreadState *tstate;
211    tstate = PyThreadState_GET();
212    return Py_BuildValue(
213        "(OOO)",
214        tstate->exc_type != NULL ? tstate->exc_type : Py_None,
215        tstate->exc_value != NULL ? tstate->exc_value : Py_None,
216        tstate->exc_traceback != NULL ?
217            tstate->exc_traceback : Py_None);
218}
219
220PyDoc_STRVAR(exc_info_doc,
221"exc_info() -> (type, value, traceback)\n\
222\n\
223Return information about the most recent exception caught by an except\n\
224clause in the current stack frame or in an older stack frame."
225);
226
227static PyObject *
228sys_exit(PyObject *self, PyObject *args)
229{
230    PyObject *exit_code = 0;
231    if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code))
232        return NULL;
233    /* Raise SystemExit so callers may catch it or clean up. */
234    PyErr_SetObject(PyExc_SystemExit, exit_code);
235    return NULL;
236}
237
238PyDoc_STRVAR(exit_doc,
239"exit([status])\n\
240\n\
241Exit the interpreter by raising SystemExit(status).\n\
242If the status is omitted or None, it defaults to zero (i.e., success).\n\
243If the status is numeric, it will be used as the system exit status.\n\
244If it is another kind of object, it will be printed and the system\n\
245exit status will be one (i.e., failure)."
246);
247
248
249static PyObject *
250sys_getdefaultencoding(PyObject *self)
251{
252    return PyUnicode_FromString(PyUnicode_GetDefaultEncoding());
253}
254
255PyDoc_STRVAR(getdefaultencoding_doc,
256"getdefaultencoding() -> string\n\
257\n\
258Return the current default string encoding used by the Unicode \n\
259implementation."
260);
261
262static PyObject *
263sys_getfilesystemencoding(PyObject *self)
264{
265    if (Py_FileSystemDefaultEncoding)
266        return PyUnicode_FromString(Py_FileSystemDefaultEncoding);
267    PyErr_SetString(PyExc_RuntimeError,
268                    "filesystem encoding is not initialized");
269    return NULL;
270}
271
272PyDoc_STRVAR(getfilesystemencoding_doc,
273"getfilesystemencoding() -> string\n\
274\n\
275Return the encoding used to convert Unicode filenames in\n\
276operating system filenames."
277);
278
279static PyObject *
280sys_intern(PyObject *self, PyObject *args)
281{
282    PyObject *s;
283    if (!PyArg_ParseTuple(args, "U:intern", &s))
284        return NULL;
285    if (PyUnicode_CheckExact(s)) {
286        Py_INCREF(s);
287        PyUnicode_InternInPlace(&s);
288        return s;
289    }
290    else {
291        PyErr_Format(PyExc_TypeError,
292                        "can't intern %.400s", s->ob_type->tp_name);
293        return NULL;
294    }
295}
296
297PyDoc_STRVAR(intern_doc,
298"intern(string) -> string\n\
299\n\
300``Intern'' the given string.  This enters the string in the (global)\n\
301table of interned strings whose purpose is to speed up dictionary lookups.\n\
302Return the string itself or the previously interned string object with the\n\
303same value.");
304
305
306/*
307 * Cached interned string objects used for calling the profile and
308 * trace functions.  Initialized by trace_init().
309 */
310static PyObject *whatstrings[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
311
312static int
313trace_init(void)
314{
315    static char *whatnames[7] = {"call", "exception", "line", "return",
316                                    "c_call", "c_exception", "c_return"};
317    PyObject *name;
318    int i;
319    for (i = 0; i < 7; ++i) {
320        if (whatstrings[i] == NULL) {
321            name = PyUnicode_InternFromString(whatnames[i]);
322            if (name == NULL)
323                return -1;
324            whatstrings[i] = name;
325        }
326    }
327    return 0;
328}
329
330
331static PyObject *
332call_trampoline(PyThreadState *tstate, PyObject* callback,
333                PyFrameObject *frame, int what, PyObject *arg)
334{
335    PyObject *args = PyTuple_New(3);
336    PyObject *whatstr;
337    PyObject *result;
338
339    if (args == NULL)
340        return NULL;
341    Py_INCREF(frame);
342    whatstr = whatstrings[what];
343    Py_INCREF(whatstr);
344    if (arg == NULL)
345        arg = Py_None;
346    Py_INCREF(arg);
347    PyTuple_SET_ITEM(args, 0, (PyObject *)frame);
348    PyTuple_SET_ITEM(args, 1, whatstr);
349    PyTuple_SET_ITEM(args, 2, arg);
350
351    /* call the Python-level function */
352    PyFrame_FastToLocals(frame);
353    result = PyEval_CallObject(callback, args);
354    PyFrame_LocalsToFast(frame, 1);
355    if (result == NULL)
356        PyTraceBack_Here(frame);
357
358    /* cleanup */
359    Py_DECREF(args);
360    return result;
361}
362
363static int
364profile_trampoline(PyObject *self, PyFrameObject *frame,
365                   int what, PyObject *arg)
366{
367    PyThreadState *tstate = frame->f_tstate;
368    PyObject *result;
369
370    if (arg == NULL)
371        arg = Py_None;
372    result = call_trampoline(tstate, self, frame, what, arg);
373    if (result == NULL) {
374        PyEval_SetProfile(NULL, NULL);
375        return -1;
376    }
377    Py_DECREF(result);
378    return 0;
379}
380
381static int
382trace_trampoline(PyObject *self, PyFrameObject *frame,
383                 int what, PyObject *arg)
384{
385    PyThreadState *tstate = frame->f_tstate;
386    PyObject *callback;
387    PyObject *result;
388
389    if (what == PyTrace_CALL)
390        callback = self;
391    else
392        callback = frame->f_trace;
393    if (callback == NULL)
394        return 0;
395    result = call_trampoline(tstate, callback, frame, what, arg);
396    if (result == NULL) {
397        PyEval_SetTrace(NULL, NULL);
398        Py_XDECREF(frame->f_trace);
399        frame->f_trace = NULL;
400        return -1;
401    }
402    if (result != Py_None) {
403        PyObject *temp = frame->f_trace;
404        frame->f_trace = NULL;
405        Py_XDECREF(temp);
406        frame->f_trace = result;
407    }
408    else {
409        Py_DECREF(result);
410    }
411    return 0;
412}
413
414static PyObject *
415sys_settrace(PyObject *self, PyObject *args)
416{
417    if (trace_init() == -1)
418        return NULL;
419    if (args == Py_None)
420        PyEval_SetTrace(NULL, NULL);
421    else
422        PyEval_SetTrace(trace_trampoline, args);
423    Py_INCREF(Py_None);
424    return Py_None;
425}
426
427PyDoc_STRVAR(settrace_doc,
428"settrace(function)\n\
429\n\
430Set the global debug tracing function.  It will be called on each\n\
431function call.  See the debugger chapter in the library manual."
432);
433
434static PyObject *
435sys_gettrace(PyObject *self, PyObject *args)
436{
437    PyThreadState *tstate = PyThreadState_GET();
438    PyObject *temp = tstate->c_traceobj;
439
440    if (temp == NULL)
441        temp = Py_None;
442    Py_INCREF(temp);
443    return temp;
444}
445
446PyDoc_STRVAR(gettrace_doc,
447"gettrace()\n\
448\n\
449Return the global debug tracing function set with sys.settrace.\n\
450See the debugger chapter in the library manual."
451);
452
453static PyObject *
454sys_setprofile(PyObject *self, PyObject *args)
455{
456    if (trace_init() == -1)
457        return NULL;
458    if (args == Py_None)
459        PyEval_SetProfile(NULL, NULL);
460    else
461        PyEval_SetProfile(profile_trampoline, args);
462    Py_INCREF(Py_None);
463    return Py_None;
464}
465
466PyDoc_STRVAR(setprofile_doc,
467"setprofile(function)\n\
468\n\
469Set the profiling function.  It will be called on each function call\n\
470and return.  See the profiler chapter in the library manual."
471);
472
473static PyObject *
474sys_getprofile(PyObject *self, PyObject *args)
475{
476    PyThreadState *tstate = PyThreadState_GET();
477    PyObject *temp = tstate->c_profileobj;
478
479    if (temp == NULL)
480        temp = Py_None;
481    Py_INCREF(temp);
482    return temp;
483}
484
485PyDoc_STRVAR(getprofile_doc,
486"getprofile()\n\
487\n\
488Return the profiling function set with sys.setprofile.\n\
489See the profiler chapter in the library manual."
490);
491
492static int _check_interval = 100;
493
494static PyObject *
495sys_setcheckinterval(PyObject *self, PyObject *args)
496{
497    if (PyErr_WarnEx(PyExc_DeprecationWarning,
498                     "sys.getcheckinterval() and sys.setcheckinterval() "
499                     "are deprecated.  Use sys.setswitchinterval() "
500                     "instead.", 1) < 0)
501        return NULL;
502    if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_check_interval))
503        return NULL;
504    Py_INCREF(Py_None);
505    return Py_None;
506}
507
508PyDoc_STRVAR(setcheckinterval_doc,
509"setcheckinterval(n)\n\
510\n\
511Tell the Python interpreter to check for asynchronous events every\n\
512n instructions.  This also affects how often thread switches occur."
513);
514
515static PyObject *
516sys_getcheckinterval(PyObject *self, PyObject *args)
517{
518    if (PyErr_WarnEx(PyExc_DeprecationWarning,
519                     "sys.getcheckinterval() and sys.setcheckinterval() "
520                     "are deprecated.  Use sys.getswitchinterval() "
521                     "instead.", 1) < 0)
522        return NULL;
523    return PyLong_FromLong(_check_interval);
524}
525
526PyDoc_STRVAR(getcheckinterval_doc,
527"getcheckinterval() -> current check interval; see setcheckinterval()."
528);
529
530#ifdef WITH_THREAD
531static PyObject *
532sys_setswitchinterval(PyObject *self, PyObject *args)
533{
534    double d;
535    if (!PyArg_ParseTuple(args, "d:setswitchinterval", &d))
536        return NULL;
537    if (d <= 0.0) {
538        PyErr_SetString(PyExc_ValueError,
539                        "switch interval must be strictly positive");
540        return NULL;
541    }
542    _PyEval_SetSwitchInterval((unsigned long) (1e6 * d));
543    Py_INCREF(Py_None);
544    return Py_None;
545}
546
547PyDoc_STRVAR(setswitchinterval_doc,
548"setswitchinterval(n)\n\
549\n\
550Set the ideal thread switching delay inside the Python interpreter\n\
551The actual frequency of switching threads can be lower if the\n\
552interpreter executes long sequences of uninterruptible code\n\
553(this is implementation-specific and workload-dependent).\n\
554\n\
555The parameter must represent the desired switching delay in seconds\n\
556A typical value is 0.005 (5 milliseconds)."
557);
558
559static PyObject *
560sys_getswitchinterval(PyObject *self, PyObject *args)
561{
562    return PyFloat_FromDouble(1e-6 * _PyEval_GetSwitchInterval());
563}
564
565PyDoc_STRVAR(getswitchinterval_doc,
566"getswitchinterval() -> current thread switch interval; see setswitchinterval()."
567);
568
569#endif /* WITH_THREAD */
570
571#ifdef WITH_TSC
572static PyObject *
573sys_settscdump(PyObject *self, PyObject *args)
574{
575    int bool;
576    PyThreadState *tstate = PyThreadState_Get();
577
578    if (!PyArg_ParseTuple(args, "i:settscdump", &bool))
579        return NULL;
580    if (bool)
581        tstate->interp->tscdump = 1;
582    else
583        tstate->interp->tscdump = 0;
584    Py_INCREF(Py_None);
585    return Py_None;
586
587}
588
589PyDoc_STRVAR(settscdump_doc,
590"settscdump(bool)\n\
591\n\
592If true, tell the Python interpreter to dump VM measurements to\n\
593stderr.  If false, turn off dump.  The measurements are based on the\n\
594processor's time-stamp counter."
595);
596#endif /* TSC */
597
598static PyObject *
599sys_setrecursionlimit(PyObject *self, PyObject *args)
600{
601    int new_limit;
602    if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit))
603        return NULL;
604    if (new_limit <= 0) {
605        PyErr_SetString(PyExc_ValueError,
606                        "recursion limit must be positive");
607        return NULL;
608    }
609    Py_SetRecursionLimit(new_limit);
610    Py_INCREF(Py_None);
611    return Py_None;
612}
613
614static PyTypeObject Hash_InfoType;
615
616PyDoc_STRVAR(hash_info_doc,
617"hash_info\n\
618\n\
619A struct sequence providing parameters used for computing\n\
620numeric hashes.  The attributes are read only.");
621
622static PyStructSequence_Field hash_info_fields[] = {
623    {"width", "width of the type used for hashing, in bits"},
624    {"modulus", "prime number giving the modulus on which the hash "
625                "function is based"},
626    {"inf", "value to be used for hash of a positive infinity"},
627    {"nan", "value to be used for hash of a nan"},
628    {"imag", "multiplier used for the imaginary part of a complex number"},
629    {NULL, NULL}
630};
631
632static PyStructSequence_Desc hash_info_desc = {
633    "sys.hash_info",
634    hash_info_doc,
635    hash_info_fields,
636    5,
637};
638
639static PyObject *
640get_hash_info(void)
641{
642    PyObject *hash_info;
643    int field = 0;
644    hash_info = PyStructSequence_New(&Hash_InfoType);
645    if (hash_info == NULL)
646        return NULL;
647    PyStructSequence_SET_ITEM(hash_info, field++,
648                              PyLong_FromLong(8*sizeof(Py_hash_t)));
649    PyStructSequence_SET_ITEM(hash_info, field++,
650                              PyLong_FromSsize_t(_PyHASH_MODULUS));
651    PyStructSequence_SET_ITEM(hash_info, field++,
652                              PyLong_FromLong(_PyHASH_INF));
653    PyStructSequence_SET_ITEM(hash_info, field++,
654                              PyLong_FromLong(_PyHASH_NAN));
655    PyStructSequence_SET_ITEM(hash_info, field++,
656                              PyLong_FromLong(_PyHASH_IMAG));
657    if (PyErr_Occurred()) {
658        Py_CLEAR(hash_info);
659        return NULL;
660    }
661    return hash_info;
662}
663
664
665PyDoc_STRVAR(setrecursionlimit_doc,
666"setrecursionlimit(n)\n\
667\n\
668Set the maximum depth of the Python interpreter stack to n.  This\n\
669limit prevents infinite recursion from causing an overflow of the C\n\
670stack and crashing Python.  The highest possible limit is platform-\n\
671dependent."
672);
673
674static PyObject *
675sys_getrecursionlimit(PyObject *self)
676{
677    return PyLong_FromLong(Py_GetRecursionLimit());
678}
679
680PyDoc_STRVAR(getrecursionlimit_doc,
681"getrecursionlimit()\n\
682\n\
683Return the current value of the recursion limit, the maximum depth\n\
684of the Python interpreter stack.  This limit prevents infinite\n\
685recursion from causing an overflow of the C stack and crashing Python."
686);
687
688#ifdef MS_WINDOWS
689PyDoc_STRVAR(getwindowsversion_doc,
690"getwindowsversion()\n\
691\n\
692Return information about the running version of Windows as a named tuple.\n\
693The members are named: major, minor, build, platform, service_pack,\n\
694service_pack_major, service_pack_minor, suite_mask, and product_type. For\n\
695backward compatibility, only the first 5 items are available by indexing.\n\
696All elements are numbers, except service_pack which is a string. Platform\n\
697may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP/Vista/7,\n\
6983 for Windows CE. Product_type may be 1 for a workstation, 2 for a domain\n\
699controller, 3 for a server."
700);
701
702static PyTypeObject WindowsVersionType = {0, 0, 0, 0, 0, 0};
703
704static PyStructSequence_Field windows_version_fields[] = {
705    {"major", "Major version number"},
706    {"minor", "Minor version number"},
707    {"build", "Build number"},
708    {"platform", "Operating system platform"},
709    {"service_pack", "Latest Service Pack installed on the system"},
710    {"service_pack_major", "Service Pack major version number"},
711    {"service_pack_minor", "Service Pack minor version number"},
712    {"suite_mask", "Bit mask identifying available product suites"},
713    {"product_type", "System product type"},
714    {0}
715};
716
717static PyStructSequence_Desc windows_version_desc = {
718    "sys.getwindowsversion",  /* name */
719    getwindowsversion_doc,    /* doc */
720    windows_version_fields,   /* fields */
721    5                         /* For backward compatibility,
722                                 only the first 5 items are accessible
723                                 via indexing, the rest are name only */
724};
725
726static PyObject *
727sys_getwindowsversion(PyObject *self)
728{
729    PyObject *version;
730    int pos = 0;
731    OSVERSIONINFOEX ver;
732    ver.dwOSVersionInfoSize = sizeof(ver);
733    if (!GetVersionEx((OSVERSIONINFO*) &ver))
734        return PyErr_SetFromWindowsErr(0);
735
736    version = PyStructSequence_New(&WindowsVersionType);
737    if (version == NULL)
738        return NULL;
739
740    PyStructSequence_SET_ITEM(version, pos++, PyLong_FromLong(ver.dwMajorVersion));
741    PyStructSequence_SET_ITEM(version, pos++, PyLong_FromLong(ver.dwMinorVersion));
742    PyStructSequence_SET_ITEM(version, pos++, PyLong_FromLong(ver.dwBuildNumber));
743    PyStructSequence_SET_ITEM(version, pos++, PyLong_FromLong(ver.dwPlatformId));
744    PyStructSequence_SET_ITEM(version, pos++, PyUnicode_FromString(ver.szCSDVersion));
745    PyStructSequence_SET_ITEM(version, pos++, PyLong_FromLong(ver.wServicePackMajor));
746    PyStructSequence_SET_ITEM(version, pos++, PyLong_FromLong(ver.wServicePackMinor));
747    PyStructSequence_SET_ITEM(version, pos++, PyLong_FromLong(ver.wSuiteMask));
748    PyStructSequence_SET_ITEM(version, pos++, PyLong_FromLong(ver.wProductType));
749
750    return version;
751}
752
753#endif /* MS_WINDOWS */
754
755#ifdef HAVE_DLOPEN
756static PyObject *
757sys_setdlopenflags(PyObject *self, PyObject *args)
758{
759    int new_val;
760    PyThreadState *tstate = PyThreadState_GET();
761    if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val))
762        return NULL;
763    if (!tstate)
764        return NULL;
765    tstate->interp->dlopenflags = new_val;
766    Py_INCREF(Py_None);
767    return Py_None;
768}
769
770PyDoc_STRVAR(setdlopenflags_doc,
771"setdlopenflags(n) -> None\n\
772\n\
773Set the flags used by the interpreter for dlopen calls, such as when the\n\
774interpreter loads extension modules.  Among other things, this will enable\n\
775a lazy resolving of symbols when importing a module, if called as\n\
776sys.setdlopenflags(0).  To share symbols across extension modules, call as\n\
777sys.setdlopenflags(ctypes.RTLD_GLOBAL).  Symbolic names for the flag modules\n\
778can be found in the os module (RTLD_xxx constants, e.g. os.RTLD_LAZY).");
779
780static PyObject *
781sys_getdlopenflags(PyObject *self, PyObject *args)
782{
783    PyThreadState *tstate = PyThreadState_GET();
784    if (!tstate)
785        return NULL;
786    return PyLong_FromLong(tstate->interp->dlopenflags);
787}
788
789PyDoc_STRVAR(getdlopenflags_doc,
790"getdlopenflags() -> int\n\
791\n\
792Return the current value of the flags that are used for dlopen calls.\n\
793The flag constants are defined in the ctypes and DLFCN modules.");
794
795#endif  /* HAVE_DLOPEN */
796
797#ifdef USE_MALLOPT
798/* Link with -lmalloc (or -lmpc) on an SGI */
799#include <malloc.h>
800
801static PyObject *
802sys_mdebug(PyObject *self, PyObject *args)
803{
804    int flag;
805    if (!PyArg_ParseTuple(args, "i:mdebug", &flag))
806        return NULL;
807    mallopt(M_DEBUG, flag);
808    Py_INCREF(Py_None);
809    return Py_None;
810}
811#endif /* USE_MALLOPT */
812
813static PyObject *
814sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds)
815{
816    PyObject *res = NULL;
817    static PyObject *gc_head_size = NULL;
818    static char *kwlist[] = {"object", "default", 0};
819    PyObject *o, *dflt = NULL;
820    PyObject *method;
821    _Py_IDENTIFIER(__sizeof__);
822
823    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof",
824                                     kwlist, &o, &dflt))
825        return NULL;
826
827    /* Initialize static variable for GC head size */
828    if (gc_head_size == NULL) {
829        gc_head_size = PyLong_FromSsize_t(sizeof(PyGC_Head));
830        if (gc_head_size == NULL)
831            return NULL;
832    }
833
834    /* Make sure the type is initialized. float gets initialized late */
835    if (PyType_Ready(Py_TYPE(o)) < 0)
836        return NULL;
837
838    method = _PyObject_LookupSpecial(o, &PyId___sizeof__);
839    if (method == NULL) {
840        if (!PyErr_Occurred())
841            PyErr_Format(PyExc_TypeError,
842                         "Type %.100s doesn't define __sizeof__",
843                         Py_TYPE(o)->tp_name);
844    }
845    else {
846        res = PyObject_CallFunctionObjArgs(method, NULL);
847        Py_DECREF(method);
848    }
849
850    /* Has a default value been given */
851    if ((res == NULL) && (dflt != NULL) &&
852        PyErr_ExceptionMatches(PyExc_TypeError))
853    {
854        PyErr_Clear();
855        Py_INCREF(dflt);
856        return dflt;
857    }
858    else if (res == NULL)
859        return res;
860
861    /* add gc_head size */
862    if (PyObject_IS_GC(o)) {
863        PyObject *tmp = res;
864        res = PyNumber_Add(tmp, gc_head_size);
865        Py_DECREF(tmp);
866    }
867    return res;
868}
869
870PyDoc_STRVAR(getsizeof_doc,
871"getsizeof(object, default) -> int\n\
872\n\
873Return the size of object in bytes.");
874
875static PyObject *
876sys_getrefcount(PyObject *self, PyObject *arg)
877{
878    return PyLong_FromSsize_t(arg->ob_refcnt);
879}
880
881#ifdef Py_REF_DEBUG
882static PyObject *
883sys_gettotalrefcount(PyObject *self)
884{
885    return PyLong_FromSsize_t(_Py_GetRefTotal());
886}
887#endif /* Py_REF_DEBUG */
888
889PyDoc_STRVAR(getrefcount_doc,
890"getrefcount(object) -> integer\n\
891\n\
892Return the reference count of object.  The count returned is generally\n\
893one higher than you might expect, because it includes the (temporary)\n\
894reference as an argument to getrefcount()."
895);
896
897#ifdef COUNT_ALLOCS
898static PyObject *
899sys_getcounts(PyObject *self)
900{
901    extern PyObject *get_counts(void);
902
903    return get_counts();
904}
905#endif
906
907PyDoc_STRVAR(getframe_doc,
908"_getframe([depth]) -> frameobject\n\
909\n\
910Return a frame object from the call stack.  If optional integer depth is\n\
911given, return the frame object that many calls below the top of the stack.\n\
912If that is deeper than the call stack, ValueError is raised.  The default\n\
913for depth is zero, returning the frame at the top of the call stack.\n\
914\n\
915This function should be used for internal and specialized\n\
916purposes only."
917);
918
919static PyObject *
920sys_getframe(PyObject *self, PyObject *args)
921{
922    PyFrameObject *f = PyThreadState_GET()->frame;
923    int depth = -1;
924
925    if (!PyArg_ParseTuple(args, "|i:_getframe", &depth))
926        return NULL;
927
928    while (depth > 0 && f != NULL) {
929        f = f->f_back;
930        --depth;
931    }
932    if (f == NULL) {
933        PyErr_SetString(PyExc_ValueError,
934                        "call stack is not deep enough");
935        return NULL;
936    }
937    Py_INCREF(f);
938    return (PyObject*)f;
939}
940
941PyDoc_STRVAR(current_frames_doc,
942"_current_frames() -> dictionary\n\
943\n\
944Return a dictionary mapping each current thread T's thread id to T's\n\
945current stack frame.\n\
946\n\
947This function should be used for specialized purposes only."
948);
949
950static PyObject *
951sys_current_frames(PyObject *self, PyObject *noargs)
952{
953    return _PyThread_CurrentFrames();
954}
955
956PyDoc_STRVAR(call_tracing_doc,
957"call_tracing(func, args) -> object\n\
958\n\
959Call func(*args), while tracing is enabled.  The tracing state is\n\
960saved, and restored afterwards.  This is intended to be called from\n\
961a debugger from a checkpoint, to recursively debug some other code."
962);
963
964static PyObject *
965sys_call_tracing(PyObject *self, PyObject *args)
966{
967    PyObject *func, *funcargs;
968    if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs))
969        return NULL;
970    return _PyEval_CallTracing(func, funcargs);
971}
972
973PyDoc_STRVAR(callstats_doc,
974"callstats() -> tuple of integers\n\
975\n\
976Return a tuple of function call statistics, if CALL_PROFILE was defined\n\
977when Python was built.  Otherwise, return None.\n\
978\n\
979When enabled, this function returns detailed, implementation-specific\n\
980details about the number of function calls executed. The return value is\n\
981a 11-tuple where the entries in the tuple are counts of:\n\
9820. all function calls\n\
9831. calls to PyFunction_Type objects\n\
9842. PyFunction calls that do not create an argument tuple\n\
9853. PyFunction calls that do not create an argument tuple\n\
986   and bypass PyEval_EvalCodeEx()\n\
9874. PyMethod calls\n\
9885. PyMethod calls on bound methods\n\
9896. PyType calls\n\
9907. PyCFunction calls\n\
9918. generator calls\n\
9929. All other calls\n\
99310. Number of stack pops performed by call_function()"
994);
995
996#ifdef __cplusplus
997extern "C" {
998#endif
999
1000static PyObject *
1001sys_debugmallocstats(PyObject *self, PyObject *args)
1002{
1003#ifdef WITH_PYMALLOC
1004    _PyObject_DebugMallocStats(stderr);
1005    fputc('\n', stderr);
1006#endif
1007    _PyObject_DebugTypeStats(stderr);
1008
1009    Py_RETURN_NONE;
1010}
1011PyDoc_STRVAR(debugmallocstats_doc,
1012"_debugmallocstats()\n\
1013\n\
1014Print summary info to stderr about the state of\n\
1015pymalloc's structures.\n\
1016\n\
1017In Py_DEBUG mode, also perform some expensive internal consistency\n\
1018checks.\n\
1019");
1020
1021#ifdef Py_TRACE_REFS
1022/* Defined in objects.c because it uses static globals if that file */
1023extern PyObject *_Py_GetObjects(PyObject *, PyObject *);
1024#endif
1025
1026#ifdef DYNAMIC_EXECUTION_PROFILE
1027/* Defined in ceval.c because it uses static globals if that file */
1028extern PyObject *_Py_GetDXProfile(PyObject *,  PyObject *);
1029#endif
1030
1031#ifdef __cplusplus
1032}
1033#endif
1034
1035static PyObject *
1036sys_clear_type_cache(PyObject* self, PyObject* args)
1037{
1038    PyType_ClearCache();
1039    Py_RETURN_NONE;
1040}
1041
1042PyDoc_STRVAR(sys_clear_type_cache__doc__,
1043"_clear_type_cache() -> None\n\
1044Clear the internal type lookup cache.");
1045
1046
1047static PyMethodDef sys_methods[] = {
1048    /* Might as well keep this in alphabetic order */
1049    {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS,
1050     callstats_doc},
1051    {"_clear_type_cache",       sys_clear_type_cache,     METH_NOARGS,
1052     sys_clear_type_cache__doc__},
1053    {"_current_frames", sys_current_frames, METH_NOARGS,
1054     current_frames_doc},
1055    {"displayhook",     sys_displayhook, METH_O, displayhook_doc},
1056    {"exc_info",        sys_exc_info, METH_NOARGS, exc_info_doc},
1057    {"excepthook",      sys_excepthook, METH_VARARGS, excepthook_doc},
1058    {"exit",            sys_exit, METH_VARARGS, exit_doc},
1059    {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding,
1060     METH_NOARGS, getdefaultencoding_doc},
1061#ifdef HAVE_DLOPEN
1062    {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS,
1063     getdlopenflags_doc},
1064#endif
1065#ifdef COUNT_ALLOCS
1066    {"getcounts",       (PyCFunction)sys_getcounts, METH_NOARGS},
1067#endif
1068#ifdef DYNAMIC_EXECUTION_PROFILE
1069    {"getdxp",          _Py_GetDXProfile, METH_VARARGS},
1070#endif
1071    {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding,
1072     METH_NOARGS, getfilesystemencoding_doc},
1073#ifdef Py_TRACE_REFS
1074    {"getobjects",      _Py_GetObjects, METH_VARARGS},
1075#endif
1076#ifdef Py_REF_DEBUG
1077    {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS},
1078#endif
1079    {"getrefcount",     (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
1080    {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS,
1081     getrecursionlimit_doc},
1082    {"getsizeof",   (PyCFunction)sys_getsizeof,
1083     METH_VARARGS | METH_KEYWORDS, getsizeof_doc},
1084    {"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
1085#ifdef MS_WINDOWS
1086    {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
1087     getwindowsversion_doc},
1088#endif /* MS_WINDOWS */
1089    {"intern",          sys_intern,     METH_VARARGS, intern_doc},
1090#ifdef USE_MALLOPT
1091    {"mdebug",          sys_mdebug, METH_VARARGS},
1092#endif
1093    {"setcheckinterval",        sys_setcheckinterval, METH_VARARGS,
1094     setcheckinterval_doc},
1095    {"getcheckinterval",        sys_getcheckinterval, METH_NOARGS,
1096     getcheckinterval_doc},
1097#ifdef WITH_THREAD
1098    {"setswitchinterval",       sys_setswitchinterval, METH_VARARGS,
1099     setswitchinterval_doc},
1100    {"getswitchinterval",       sys_getswitchinterval, METH_NOARGS,
1101     getswitchinterval_doc},
1102#endif
1103#ifdef HAVE_DLOPEN
1104    {"setdlopenflags", sys_setdlopenflags, METH_VARARGS,
1105     setdlopenflags_doc},
1106#endif
1107    {"setprofile",      sys_setprofile, METH_O, setprofile_doc},
1108    {"getprofile",      sys_getprofile, METH_NOARGS, getprofile_doc},
1109    {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS,
1110     setrecursionlimit_doc},
1111#ifdef WITH_TSC
1112    {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc},
1113#endif
1114    {"settrace",        sys_settrace, METH_O, settrace_doc},
1115    {"gettrace",        sys_gettrace, METH_NOARGS, gettrace_doc},
1116    {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},
1117    {"_debugmallocstats", sys_debugmallocstats, METH_VARARGS,
1118     debugmallocstats_doc},
1119    {NULL,              NULL}           /* sentinel */
1120};
1121
1122static PyObject *
1123list_builtin_module_names(void)
1124{
1125    PyObject *list = PyList_New(0);
1126    int i;
1127    if (list == NULL)
1128        return NULL;
1129    for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
1130        PyObject *name = PyUnicode_FromString(
1131            PyImport_Inittab[i].name);
1132        if (name == NULL)
1133            break;
1134        PyList_Append(list, name);
1135        Py_DECREF(name);
1136    }
1137    if (PyList_Sort(list) != 0) {
1138        Py_DECREF(list);
1139        list = NULL;
1140    }
1141    if (list) {
1142        PyObject *v = PyList_AsTuple(list);
1143        Py_DECREF(list);
1144        list = v;
1145    }
1146    return list;
1147}
1148
1149static PyObject *warnoptions = NULL;
1150
1151void
1152PySys_ResetWarnOptions(void)
1153{
1154    if (warnoptions == NULL || !PyList_Check(warnoptions))
1155        return;
1156    PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
1157}
1158
1159void
1160PySys_AddWarnOptionUnicode(PyObject *unicode)
1161{
1162    if (warnoptions == NULL || !PyList_Check(warnoptions)) {
1163        Py_XDECREF(warnoptions);
1164        warnoptions = PyList_New(0);
1165        if (warnoptions == NULL)
1166            return;
1167    }
1168    PyList_Append(warnoptions, unicode);
1169}
1170
1171void
1172PySys_AddWarnOption(const wchar_t *s)
1173{
1174    PyObject *unicode;
1175    unicode = PyUnicode_FromWideChar(s, -1);
1176    if (unicode == NULL)
1177        return;
1178    PySys_AddWarnOptionUnicode(unicode);
1179    Py_DECREF(unicode);
1180}
1181
1182int
1183PySys_HasWarnOptions(void)
1184{
1185    return (warnoptions != NULL && (PyList_Size(warnoptions) > 0)) ? 1 : 0;
1186}
1187
1188static PyObject *xoptions = NULL;
1189
1190static PyObject *
1191get_xoptions(void)
1192{
1193    if (xoptions == NULL || !PyDict_Check(xoptions)) {
1194        Py_XDECREF(xoptions);
1195        xoptions = PyDict_New();
1196    }
1197    return xoptions;
1198}
1199
1200void
1201PySys_AddXOption(const wchar_t *s)
1202{
1203    PyObject *opts;
1204    PyObject *name = NULL, *value = NULL;
1205    const wchar_t *name_end;
1206
1207    opts = get_xoptions();
1208    if (opts == NULL)
1209        goto error;
1210
1211    name_end = wcschr(s, L'=');
1212    if (!name_end) {
1213        name = PyUnicode_FromWideChar(s, -1);
1214        value = Py_True;
1215        Py_INCREF(value);
1216    }
1217    else {
1218        name = PyUnicode_FromWideChar(s, name_end - s);
1219        value = PyUnicode_FromWideChar(name_end + 1, -1);
1220    }
1221    if (name == NULL || value == NULL)
1222        goto error;
1223    PyDict_SetItem(opts, name, value);
1224    Py_DECREF(name);
1225    Py_DECREF(value);
1226    return;
1227
1228error:
1229    Py_XDECREF(name);
1230    Py_XDECREF(value);
1231    /* No return value, therefore clear error state if possible */
1232    if (_Py_atomic_load_relaxed(&_PyThreadState_Current))
1233        PyErr_Clear();
1234}
1235
1236PyObject *
1237PySys_GetXOptions(void)
1238{
1239    return get_xoptions();
1240}
1241
1242/* XXX This doc string is too long to be a single string literal in VC++ 5.0.
1243   Two literals concatenated works just fine.  If you have a K&R compiler
1244   or other abomination that however *does* understand longer strings,
1245   get rid of the !!! comment in the middle and the quotes that surround it. */
1246PyDoc_VAR(sys_doc) =
1247PyDoc_STR(
1248"This module provides access to some objects used or maintained by the\n\
1249interpreter and to functions that interact strongly with the interpreter.\n\
1250\n\
1251Dynamic objects:\n\
1252\n\
1253argv -- command line arguments; argv[0] is the script pathname if known\n\
1254path -- module search path; path[0] is the script directory, else ''\n\
1255modules -- dictionary of loaded modules\n\
1256\n\
1257displayhook -- called to show results in an interactive session\n\
1258excepthook -- called to handle any uncaught exception other than SystemExit\n\
1259  To customize printing in an interactive session or to install a custom\n\
1260  top-level exception handler, assign other functions to replace these.\n\
1261\n\
1262stdin -- standard input file object; used by input()\n\
1263stdout -- standard output file object; used by print()\n\
1264stderr -- standard error object; used for error messages\n\
1265  By assigning other file objects (or objects that behave like files)\n\
1266  to these, it is possible to redirect all of the interpreter's I/O.\n\
1267\n\
1268last_type -- type of last uncaught exception\n\
1269last_value -- value of last uncaught exception\n\
1270last_traceback -- traceback of last uncaught exception\n\
1271  These three are only available in an interactive session after a\n\
1272  traceback has been printed.\n\
1273"
1274)
1275/* concatenating string here */
1276PyDoc_STR(
1277"\n\
1278Static objects:\n\
1279\n\
1280builtin_module_names -- tuple of module names built into this interpreter\n\
1281copyright -- copyright notice pertaining to this interpreter\n\
1282exec_prefix -- prefix used to find the machine-specific Python library\n\
1283executable -- absolute path of the executable binary of the Python interpreter\n\
1284float_info -- a struct sequence with information about the float implementation.\n\
1285float_repr_style -- string indicating the style of repr() output for floats\n\
1286hexversion -- version information encoded as a single integer\n\
1287implementation -- Python implementation information.\n\
1288int_info -- a struct sequence with information about the int implementation.\n\
1289maxsize -- the largest supported length of containers.\n\
1290maxunicode -- the value of the largest Unicode codepoint\n\
1291platform -- platform identifier\n\
1292prefix -- prefix used to find the Python library\n\
1293thread_info -- a struct sequence with information about the thread implementation.\n\
1294version -- the version of this interpreter as a string\n\
1295version_info -- version information as a named tuple\n\
1296"
1297)
1298#ifdef MS_WINDOWS
1299/* concatenating string here */
1300PyDoc_STR(
1301"dllhandle -- [Windows only] integer handle of the Python DLL\n\
1302winver -- [Windows only] version number of the Python DLL\n\
1303"
1304)
1305#endif /* MS_WINDOWS */
1306PyDoc_STR(
1307"__stdin__ -- the original stdin; don't touch!\n\
1308__stdout__ -- the original stdout; don't touch!\n\
1309__stderr__ -- the original stderr; don't touch!\n\
1310__displayhook__ -- the original displayhook; don't touch!\n\
1311__excepthook__ -- the original excepthook; don't touch!\n\
1312\n\
1313Functions:\n\
1314\n\
1315displayhook() -- print an object to the screen, and save it in builtins._\n\
1316excepthook() -- print an exception and its traceback to sys.stderr\n\
1317exc_info() -- return thread-safe information about the current exception\n\
1318exit() -- exit the interpreter by raising SystemExit\n\
1319getdlopenflags() -- returns flags to be used for dlopen() calls\n\
1320getprofile() -- get the global profiling function\n\
1321getrefcount() -- return the reference count for an object (plus one :-)\n\
1322getrecursionlimit() -- return the max recursion depth for the interpreter\n\
1323getsizeof() -- return the size of an object in bytes\n\
1324gettrace() -- get the global debug tracing function\n\
1325setcheckinterval() -- control how often the interpreter checks for events\n\
1326setdlopenflags() -- set the flags to be used for dlopen() calls\n\
1327setprofile() -- set the global profiling function\n\
1328setrecursionlimit() -- set the max recursion depth for the interpreter\n\
1329settrace() -- set the global debug tracing function\n\
1330"
1331)
1332/* end of sys_doc */ ;
1333
1334
1335PyDoc_STRVAR(flags__doc__,
1336"sys.flags\n\
1337\n\
1338Flags provided through command line arguments or environment vars.");
1339
1340static PyTypeObject FlagsType;
1341
1342static PyStructSequence_Field flags_fields[] = {
1343    {"debug",                   "-d"},
1344    {"inspect",                 "-i"},
1345    {"interactive",             "-i"},
1346    {"optimize",                "-O or -OO"},
1347    {"dont_write_bytecode",     "-B"},
1348    {"no_user_site",            "-s"},
1349    {"no_site",                 "-S"},
1350    {"ignore_environment",      "-E"},
1351    {"verbose",                 "-v"},
1352#ifdef RISCOS
1353    {"riscos_wimp",             "???"},
1354#endif
1355    /* {"unbuffered",                   "-u"}, */
1356    /* {"skip_first",                   "-x"}, */
1357    {"bytes_warning",           "-b"},
1358    {"quiet",                   "-q"},
1359    {"hash_randomization",      "-R"},
1360    {0}
1361};
1362
1363static PyStructSequence_Desc flags_desc = {
1364    "sys.flags",        /* name */
1365    flags__doc__,       /* doc */
1366    flags_fields,       /* fields */
1367#ifdef RISCOS
1368    13
1369#else
1370    12
1371#endif
1372};
1373
1374static PyObject*
1375make_flags(void)
1376{
1377    int pos = 0;
1378    PyObject *seq;
1379
1380    seq = PyStructSequence_New(&FlagsType);
1381    if (seq == NULL)
1382        return NULL;
1383
1384#define SetFlag(flag) \
1385    PyStructSequence_SET_ITEM(seq, pos++, PyLong_FromLong(flag))
1386
1387    SetFlag(Py_DebugFlag);
1388    SetFlag(Py_InspectFlag);
1389    SetFlag(Py_InteractiveFlag);
1390    SetFlag(Py_OptimizeFlag);
1391    SetFlag(Py_DontWriteBytecodeFlag);
1392    SetFlag(Py_NoUserSiteDirectory);
1393    SetFlag(Py_NoSiteFlag);
1394    SetFlag(Py_IgnoreEnvironmentFlag);
1395    SetFlag(Py_VerboseFlag);
1396#ifdef RISCOS
1397    SetFlag(Py_RISCOSWimpFlag);
1398#endif
1399    /* SetFlag(saw_unbuffered_flag); */
1400    /* SetFlag(skipfirstline); */
1401    SetFlag(Py_BytesWarningFlag);
1402    SetFlag(Py_QuietFlag);
1403    SetFlag(Py_HashRandomizationFlag);
1404#undef SetFlag
1405
1406    if (PyErr_Occurred()) {
1407        return NULL;
1408    }
1409    return seq;
1410}
1411
1412PyDoc_STRVAR(version_info__doc__,
1413"sys.version_info\n\
1414\n\
1415Version information as a named tuple.");
1416
1417static PyTypeObject VersionInfoType;
1418
1419static PyStructSequence_Field version_info_fields[] = {
1420    {"major", "Major release number"},
1421    {"minor", "Minor release number"},
1422    {"micro", "Patch release number"},
1423    {"releaselevel", "'alpha', 'beta', 'candidate', or 'release'"},
1424    {"serial", "Serial release number"},
1425    {0}
1426};
1427
1428static PyStructSequence_Desc version_info_desc = {
1429    "sys.version_info",     /* name */
1430    version_info__doc__,    /* doc */
1431    version_info_fields,    /* fields */
1432    5
1433};
1434
1435static PyObject *
1436make_version_info(void)
1437{
1438    PyObject *version_info;
1439    char *s;
1440    int pos = 0;
1441
1442    version_info = PyStructSequence_New(&VersionInfoType);
1443    if (version_info == NULL) {
1444        return NULL;
1445    }
1446
1447    /*
1448     * These release level checks are mutually exclusive and cover
1449     * the field, so don't get too fancy with the pre-processor!
1450     */
1451#if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
1452    s = "alpha";
1453#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
1454    s = "beta";
1455#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
1456    s = "candidate";
1457#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
1458    s = "final";
1459#endif
1460
1461#define SetIntItem(flag) \
1462    PyStructSequence_SET_ITEM(version_info, pos++, PyLong_FromLong(flag))
1463#define SetStrItem(flag) \
1464    PyStructSequence_SET_ITEM(version_info, pos++, PyUnicode_FromString(flag))
1465
1466    SetIntItem(PY_MAJOR_VERSION);
1467    SetIntItem(PY_MINOR_VERSION);
1468    SetIntItem(PY_MICRO_VERSION);
1469    SetStrItem(s);
1470    SetIntItem(PY_RELEASE_SERIAL);
1471#undef SetIntItem
1472#undef SetStrItem
1473
1474    if (PyErr_Occurred()) {
1475        Py_CLEAR(version_info);
1476        return NULL;
1477    }
1478    return version_info;
1479}
1480
1481static PyObject *
1482make_impl_info(PyObject *version_info)
1483{
1484    int res;
1485    PyObject *impl_info, *value, *ns;
1486
1487    impl_info = PyDict_New();
1488    if (impl_info == NULL)
1489        return NULL;
1490
1491    /* populate the dict */
1492
1493#define NAME "cpython"
1494#define QUOTE(arg) #arg
1495#define STRIFY(name) QUOTE(name)
1496#define MAJOR STRIFY(PY_MAJOR_VERSION)
1497#define MINOR STRIFY(PY_MINOR_VERSION)
1498#define TAG NAME "-" MAJOR MINOR
1499    value = PyUnicode_FromString(NAME);
1500    if (value == NULL)
1501        goto error;
1502    res = PyDict_SetItemString(impl_info, "name", value);
1503    Py_DECREF(value);
1504    if (res < 0)
1505        goto error;
1506
1507    value = PyUnicode_FromString(TAG);
1508    if (value == NULL)
1509        goto error;
1510    res = PyDict_SetItemString(impl_info, "cache_tag", value);
1511    Py_DECREF(value);
1512    if (res < 0)
1513        goto error;
1514#undef NAME
1515#undef QUOTE
1516#undef STRIFY
1517#undef MAJOR
1518#undef MINOR
1519#undef TAG
1520
1521    res = PyDict_SetItemString(impl_info, "version", version_info);
1522    if (res < 0)
1523        goto error;
1524
1525    value = PyLong_FromLong(PY_VERSION_HEX);
1526    if (value == NULL)
1527        goto error;
1528    res = PyDict_SetItemString(impl_info, "hexversion", value);
1529    Py_DECREF(value);
1530    if (res < 0)
1531        goto error;
1532
1533    /* dict ready */
1534
1535    ns = _PyNamespace_New(impl_info);
1536    Py_DECREF(impl_info);
1537    return ns;
1538
1539error:
1540    Py_CLEAR(impl_info);
1541    return NULL;
1542}
1543
1544static struct PyModuleDef sysmodule = {
1545    PyModuleDef_HEAD_INIT,
1546    "sys",
1547    sys_doc,
1548    -1, /* multiple "initialization" just copies the module dict. */
1549    sys_methods,
1550    NULL,
1551    NULL,
1552    NULL,
1553    NULL
1554};
1555
1556PyObject *
1557_PySys_Init(void)
1558{
1559    PyObject *m, *v, *sysdict, *version_info;
1560    char *s;
1561
1562    m = PyModule_Create(&sysmodule);
1563    if (m == NULL)
1564        return NULL;
1565    sysdict = PyModule_GetDict(m);
1566#define SET_SYS_FROM_STRING(key, value)                 \
1567    v = value;                                          \
1568    if (v != NULL)                                      \
1569        PyDict_SetItemString(sysdict, key, v);          \
1570    Py_XDECREF(v)
1571
1572    /* Check that stdin is not a directory
1573    Using shell redirection, you can redirect stdin to a directory,
1574    crashing the Python interpreter. Catch this common mistake here
1575    and output a useful error message. Note that under MS Windows,
1576    the shell already prevents that. */
1577#if !defined(MS_WINDOWS)
1578    {
1579        struct stat sb;
1580        if (fstat(fileno(stdin), &sb) == 0 &&
1581            S_ISDIR(sb.st_mode)) {
1582            /* There's nothing more we can do. */
1583            /* Py_FatalError() will core dump, so just exit. */
1584            PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
1585            exit(EXIT_FAILURE);
1586        }
1587    }
1588#endif
1589
1590    /* stdin/stdout/stderr are now set by pythonrun.c */
1591
1592    PyDict_SetItemString(sysdict, "__displayhook__",
1593                         PyDict_GetItemString(sysdict, "displayhook"));
1594    PyDict_SetItemString(sysdict, "__excepthook__",
1595                         PyDict_GetItemString(sysdict, "excepthook"));
1596    SET_SYS_FROM_STRING("version",
1597                         PyUnicode_FromString(Py_GetVersion()));
1598    SET_SYS_FROM_STRING("hexversion",
1599                         PyLong_FromLong(PY_VERSION_HEX));
1600    SET_SYS_FROM_STRING("_mercurial",
1601                        Py_BuildValue("(szz)", "CPython", _Py_hgidentifier(),
1602                                      _Py_hgversion()));
1603    SET_SYS_FROM_STRING("dont_write_bytecode",
1604                         PyBool_FromLong(Py_DontWriteBytecodeFlag));
1605    SET_SYS_FROM_STRING("api_version",
1606                        PyLong_FromLong(PYTHON_API_VERSION));
1607    SET_SYS_FROM_STRING("copyright",
1608                        PyUnicode_FromString(Py_GetCopyright()));
1609    SET_SYS_FROM_STRING("platform",
1610                        PyUnicode_FromString(Py_GetPlatform()));
1611    SET_SYS_FROM_STRING("executable",
1612                        PyUnicode_FromWideChar(
1613                               Py_GetProgramFullPath(), -1));
1614    SET_SYS_FROM_STRING("prefix",
1615                        PyUnicode_FromWideChar(Py_GetPrefix(), -1));
1616    SET_SYS_FROM_STRING("exec_prefix",
1617                        PyUnicode_FromWideChar(Py_GetExecPrefix(), -1));
1618    SET_SYS_FROM_STRING("base_prefix",
1619                        PyUnicode_FromWideChar(Py_GetPrefix(), -1));
1620    SET_SYS_FROM_STRING("base_exec_prefix",
1621                        PyUnicode_FromWideChar(Py_GetExecPrefix(), -1));
1622    SET_SYS_FROM_STRING("maxsize",
1623                        PyLong_FromSsize_t(PY_SSIZE_T_MAX));
1624    SET_SYS_FROM_STRING("float_info",
1625                        PyFloat_GetInfo());
1626    SET_SYS_FROM_STRING("int_info",
1627                        PyLong_GetInfo());
1628    /* initialize hash_info */
1629    if (Hash_InfoType.tp_name == 0)
1630        PyStructSequence_InitType(&Hash_InfoType, &hash_info_desc);
1631    SET_SYS_FROM_STRING("hash_info",
1632                        get_hash_info());
1633    SET_SYS_FROM_STRING("maxunicode",
1634                        PyLong_FromLong(0x10FFFF));
1635    SET_SYS_FROM_STRING("builtin_module_names",
1636                        list_builtin_module_names());
1637    {
1638        /* Assumes that longs are at least 2 bytes long.
1639           Should be safe! */
1640        unsigned long number = 1;
1641        char *value;
1642
1643        s = (char *) &number;
1644        if (s[0] == 0)
1645            value = "big";
1646        else
1647            value = "little";
1648        SET_SYS_FROM_STRING("byteorder",
1649                            PyUnicode_FromString(value));
1650    }
1651#ifdef MS_COREDLL
1652    SET_SYS_FROM_STRING("dllhandle",
1653                        PyLong_FromVoidPtr(PyWin_DLLhModule));
1654    SET_SYS_FROM_STRING("winver",
1655                        PyUnicode_FromString(PyWin_DLLVersionString));
1656#endif
1657#ifdef ABIFLAGS
1658    SET_SYS_FROM_STRING("abiflags",
1659                        PyUnicode_FromString(ABIFLAGS));
1660#endif
1661    if (warnoptions == NULL) {
1662        warnoptions = PyList_New(0);
1663    }
1664    else {
1665        Py_INCREF(warnoptions);
1666    }
1667    if (warnoptions != NULL) {
1668        PyDict_SetItemString(sysdict, "warnoptions", warnoptions);
1669    }
1670
1671    v = get_xoptions();
1672    if (v != NULL) {
1673        PyDict_SetItemString(sysdict, "_xoptions", v);
1674    }
1675
1676    /* version_info */
1677    if (VersionInfoType.tp_name == 0)
1678        PyStructSequence_InitType(&VersionInfoType, &version_info_desc);
1679    version_info = make_version_info();
1680    SET_SYS_FROM_STRING("version_info", version_info);
1681    /* prevent user from creating new instances */
1682    VersionInfoType.tp_init = NULL;
1683    VersionInfoType.tp_new = NULL;
1684
1685    /* implementation */
1686    SET_SYS_FROM_STRING("implementation", make_impl_info(version_info));
1687
1688    /* flags */
1689    if (FlagsType.tp_name == 0)
1690        PyStructSequence_InitType(&FlagsType, &flags_desc);
1691    SET_SYS_FROM_STRING("flags", make_flags());
1692    /* prevent user from creating new instances */
1693    FlagsType.tp_init = NULL;
1694    FlagsType.tp_new = NULL;
1695
1696
1697#if defined(MS_WINDOWS)
1698    /* getwindowsversion */
1699    if (WindowsVersionType.tp_name == 0)
1700        PyStructSequence_InitType(&WindowsVersionType, &windows_version_desc);
1701    /* prevent user from creating new instances */
1702    WindowsVersionType.tp_init = NULL;
1703    WindowsVersionType.tp_new = NULL;
1704#endif
1705
1706    /* float repr style: 0.03 (short) vs 0.029999999999999999 (legacy) */
1707#ifndef PY_NO_SHORT_FLOAT_REPR
1708    SET_SYS_FROM_STRING("float_repr_style",
1709                        PyUnicode_FromString("short"));
1710#else
1711    SET_SYS_FROM_STRING("float_repr_style",
1712                        PyUnicode_FromString("legacy"));
1713#endif
1714
1715#ifdef WITH_THREAD
1716    SET_SYS_FROM_STRING("thread_info", PyThread_GetInfo());
1717#endif
1718
1719#undef SET_SYS_FROM_STRING
1720    if (PyErr_Occurred())
1721        return NULL;
1722    return m;
1723}
1724
1725static PyObject *
1726makepathobject(const wchar_t *path, wchar_t delim)
1727{
1728    int i, n;
1729    const wchar_t *p;
1730    PyObject *v, *w;
1731
1732    n = 1;
1733    p = path;
1734    while ((p = wcschr(p, delim)) != NULL) {
1735        n++;
1736        p++;
1737    }
1738    v = PyList_New(n);
1739    if (v == NULL)
1740        return NULL;
1741    for (i = 0; ; i++) {
1742        p = wcschr(path, delim);
1743        if (p == NULL)
1744            p = path + wcslen(path); /* End of string */
1745        w = PyUnicode_FromWideChar(path, (Py_ssize_t)(p - path));
1746        if (w == NULL) {
1747            Py_DECREF(v);
1748            return NULL;
1749        }
1750        PyList_SetItem(v, i, w);
1751        if (*p == '\0')
1752            break;
1753        path = p+1;
1754    }
1755    return v;
1756}
1757
1758void
1759PySys_SetPath(const wchar_t *path)
1760{
1761    PyObject *v;
1762    if ((v = makepathobject(path, DELIM)) == NULL)
1763        Py_FatalError("can't create sys.path");
1764    if (PySys_SetObject("path", v) != 0)
1765        Py_FatalError("can't assign sys.path");
1766    Py_DECREF(v);
1767}
1768
1769static PyObject *
1770makeargvobject(int argc, wchar_t **argv)
1771{
1772    PyObject *av;
1773    if (argc <= 0 || argv == NULL) {
1774        /* Ensure at least one (empty) argument is seen */
1775        static wchar_t *empty_argv[1] = {L""};
1776        argv = empty_argv;
1777        argc = 1;
1778    }
1779    av = PyList_New(argc);
1780    if (av != NULL) {
1781        int i;
1782        for (i = 0; i < argc; i++) {
1783#ifdef __VMS
1784            PyObject *v;
1785
1786            /* argv[0] is the script pathname if known */
1787            if (i == 0) {
1788                char* fn = decc$translate_vms(argv[0]);
1789                if ((fn == (char *)0) || fn == (char *)-1)
1790                    v = PyUnicode_FromString(argv[0]);
1791                else
1792                    v = PyUnicode_FromString(
1793                        decc$translate_vms(argv[0]));
1794            } else
1795                v = PyUnicode_FromString(argv[i]);
1796#else
1797            PyObject *v = PyUnicode_FromWideChar(argv[i], -1);
1798#endif
1799            if (v == NULL) {
1800                Py_DECREF(av);
1801                av = NULL;
1802                break;
1803            }
1804            PyList_SetItem(av, i, v);
1805        }
1806    }
1807    return av;
1808}
1809
1810#define _HAVE_SCRIPT_ARGUMENT(argc, argv) \
1811  (argc > 0 && argv0 != NULL && \
1812   wcscmp(argv0, L"-c") != 0 && wcscmp(argv0, L"-m") != 0)
1813
1814static void
1815sys_update_path(int argc, wchar_t **argv)
1816{
1817    wchar_t *argv0;
1818    wchar_t *p = NULL;
1819    Py_ssize_t n = 0;
1820    PyObject *a;
1821    PyObject *path;
1822#ifdef HAVE_READLINK
1823    wchar_t link[MAXPATHLEN+1];
1824    wchar_t argv0copy[2*MAXPATHLEN+1];
1825    int nr = 0;
1826#endif
1827#if defined(HAVE_REALPATH)
1828    wchar_t fullpath[MAXPATHLEN];
1829#elif defined(MS_WINDOWS) && !defined(MS_WINCE)
1830    wchar_t fullpath[MAX_PATH];
1831#endif
1832
1833    path = PySys_GetObject("path");
1834    if (path == NULL)
1835        return;
1836
1837    argv0 = argv[0];
1838
1839#ifdef HAVE_READLINK
1840    if (_HAVE_SCRIPT_ARGUMENT(argc, argv))
1841        nr = _Py_wreadlink(argv0, link, MAXPATHLEN);
1842    if (nr > 0) {
1843        /* It's a symlink */
1844        link[nr] = '\0';
1845        if (link[0] == SEP)
1846            argv0 = link; /* Link to absolute path */
1847        else if (wcschr(link, SEP) == NULL)
1848            ; /* Link without path */
1849        else {
1850            /* Must join(dirname(argv0), link) */
1851            wchar_t *q = wcsrchr(argv0, SEP);
1852            if (q == NULL)
1853                argv0 = link; /* argv0 without path */
1854            else {
1855                /* Must make a copy */
1856                wcscpy(argv0copy, argv0);
1857                q = wcsrchr(argv0copy, SEP);
1858                wcscpy(q+1, link);
1859                argv0 = argv0copy;
1860            }
1861        }
1862    }
1863#endif /* HAVE_READLINK */
1864#if SEP == '\\' /* Special case for MS filename syntax */
1865    if (_HAVE_SCRIPT_ARGUMENT(argc, argv)) {
1866        wchar_t *q;
1867#if defined(MS_WINDOWS) && !defined(MS_WINCE)
1868        /* This code here replaces the first element in argv with the full
1869        path that it represents. Under CE, there are no relative paths so
1870        the argument must be the full path anyway. */
1871        wchar_t *ptemp;
1872        if (GetFullPathNameW(argv0,
1873                           Py_ARRAY_LENGTH(fullpath),
1874                           fullpath,
1875                           &ptemp)) {
1876            argv0 = fullpath;
1877        }
1878#endif
1879        p = wcsrchr(argv0, SEP);
1880        /* Test for alternate separator */
1881        q = wcsrchr(p ? p : argv0, '/');
1882        if (q != NULL)
1883            p = q;
1884        if (p != NULL) {
1885            n = p + 1 - argv0;
1886            if (n > 1 && p[-1] != ':')
1887                n--; /* Drop trailing separator */
1888        }
1889    }
1890#else /* All other filename syntaxes */
1891    if (_HAVE_SCRIPT_ARGUMENT(argc, argv)) {
1892#if defined(HAVE_REALPATH)
1893        if (_Py_wrealpath(argv0, fullpath, PATH_MAX)) {
1894            argv0 = fullpath;
1895        }
1896#endif
1897        p = wcsrchr(argv0, SEP);
1898    }
1899    if (p != NULL) {
1900        n = p + 1 - argv0;
1901#if SEP == '/' /* Special case for Unix filename syntax */
1902        if (n > 1)
1903            n--; /* Drop trailing separator */
1904#endif /* Unix */
1905    }
1906#endif /* All others */
1907    a = PyUnicode_FromWideChar(argv0, n);
1908    if (a == NULL)
1909        Py_FatalError("no mem for sys.path insertion");
1910    if (PyList_Insert(path, 0, a) < 0)
1911        Py_FatalError("sys.path.insert(0) failed");
1912    Py_DECREF(a);
1913}
1914
1915void
1916PySys_SetArgvEx(int argc, wchar_t **argv, int updatepath)
1917{
1918    PyObject *av = makeargvobject(argc, argv);
1919    if (av == NULL)
1920        Py_FatalError("no mem for sys.argv");
1921    if (PySys_SetObject("argv", av) != 0)
1922        Py_FatalError("can't assign sys.argv");
1923    Py_DECREF(av);
1924    if (updatepath)
1925        sys_update_path(argc, argv);
1926}
1927
1928void
1929PySys_SetArgv(int argc, wchar_t **argv)
1930{
1931    PySys_SetArgvEx(argc, argv, 1);
1932}
1933
1934/* Reimplementation of PyFile_WriteString() no calling indirectly
1935   PyErr_CheckSignals(): avoid the call to PyObject_Str(). */
1936
1937static int
1938sys_pyfile_write_unicode(PyObject *unicode, PyObject *file)
1939{
1940    PyObject *writer = NULL, *args = NULL, *result = NULL;
1941    int err;
1942    _Py_IDENTIFIER(write);
1943
1944    if (file == NULL)
1945        return -1;
1946
1947    writer = _PyObject_GetAttrId(file, &PyId_write);
1948    if (writer == NULL)
1949        goto error;
1950
1951    args = PyTuple_Pack(1, unicode);
1952    if (args == NULL)
1953        goto error;
1954
1955    result = PyEval_CallObject(writer, args);
1956    if (result == NULL) {
1957        goto error;
1958    } else {
1959        err = 0;
1960        goto finally;
1961    }
1962
1963error:
1964    err = -1;
1965finally:
1966    Py_XDECREF(writer);
1967    Py_XDECREF(args);
1968    Py_XDECREF(result);
1969    return err;
1970}
1971
1972static int
1973sys_pyfile_write(const char *text, PyObject *file)
1974{
1975    PyObject *unicode = NULL;
1976    int err;
1977
1978    if (file == NULL)
1979        return -1;
1980
1981    unicode = PyUnicode_FromString(text);
1982    if (unicode == NULL)
1983        return -1;
1984
1985    err = sys_pyfile_write_unicode(unicode, file);
1986    Py_DECREF(unicode);
1987    return err;
1988}
1989
1990/* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
1991   Adapted from code submitted by Just van Rossum.
1992
1993   PySys_WriteStdout(format, ...)
1994   PySys_WriteStderr(format, ...)
1995
1996      The first function writes to sys.stdout; the second to sys.stderr.  When
1997      there is a problem, they write to the real (C level) stdout or stderr;
1998      no exceptions are raised.
1999
2000      PyErr_CheckSignals() is not called to avoid the execution of the Python
2001      signal handlers: they may raise a new exception whereas sys_write()
2002      ignores all exceptions.
2003
2004      Both take a printf-style format string as their first argument followed
2005      by a variable length argument list determined by the format string.
2006
2007      *** WARNING ***
2008
2009      The format should limit the total size of the formatted output string to
2010      1000 bytes.  In particular, this means that no unrestricted "%s" formats
2011      should occur; these should be limited using "%.<N>s where <N> is a
2012      decimal number calculated so that <N> plus the maximum size of other
2013      formatted text does not exceed 1000 bytes.  Also watch out for "%f",
2014      which can print hundreds of digits for very large numbers.
2015
2016 */
2017
2018static void
2019sys_write(char *name, FILE *fp, const char *format, va_list va)
2020{
2021    PyObject *file;
2022    PyObject *error_type, *error_value, *error_traceback;
2023    char buffer[1001];
2024    int written;
2025
2026    PyErr_Fetch(&error_type, &error_value, &error_traceback);
2027    file = PySys_GetObject(name);
2028    written = PyOS_vsnprintf(buffer, sizeof(buffer), format, va);
2029    if (sys_pyfile_write(buffer, file) != 0) {
2030        PyErr_Clear();
2031        fputs(buffer, fp);
2032    }
2033    if (written < 0 || (size_t)written >= sizeof(buffer)) {
2034        const char *truncated = "... truncated";
2035        if (sys_pyfile_write(truncated, file) != 0)
2036            fputs(truncated, fp);
2037    }
2038    PyErr_Restore(error_type, error_value, error_traceback);
2039}
2040
2041void
2042PySys_WriteStdout(const char *format, ...)
2043{
2044    va_list va;
2045
2046    va_start(va, format);
2047    sys_write("stdout", stdout, format, va);
2048    va_end(va);
2049}
2050
2051void
2052PySys_WriteStderr(const char *format, ...)
2053{
2054    va_list va;
2055
2056    va_start(va, format);
2057    sys_write("stderr", stderr, format, va);
2058    va_end(va);
2059}
2060
2061static void
2062sys_format(char *name, FILE *fp, const char *format, va_list va)
2063{
2064    PyObject *file, *message;
2065    PyObject *error_type, *error_value, *error_traceback;
2066    char *utf8;
2067
2068    PyErr_Fetch(&error_type, &error_value, &error_traceback);
2069    file = PySys_GetObject(name);
2070    message = PyUnicode_FromFormatV(format, va);
2071    if (message != NULL) {
2072        if (sys_pyfile_write_unicode(message, file) != 0) {
2073            PyErr_Clear();
2074            utf8 = _PyUnicode_AsString(message);
2075            if (utf8 != NULL)
2076                fputs(utf8, fp);
2077        }
2078        Py_DECREF(message);
2079    }
2080    PyErr_Restore(error_type, error_value, error_traceback);
2081}
2082
2083void
2084PySys_FormatStdout(const char *format, ...)
2085{
2086    va_list va;
2087
2088    va_start(va, format);
2089    sys_format("stdout", stdout, format, va);
2090    va_end(va);
2091}
2092
2093void
2094PySys_FormatStderr(const char *format, ...)
2095{
2096    va_list va;
2097
2098    va_start(va, format);
2099    sys_format("stderr", stderr, format, va);
2100    va_end(va);
2101}
2102