AppPkg/Applications/Python/Python-2.7.10/Python/sysmodule.c

   1
   2 /* System module */
   3
   4 /*
   5 Various bits of information used by the interpreter are collected in
   6 module 'sys'.
   7 Function member:
   8 - exit(sts): raise SystemExit
   9 Data members:
  10 - stdin, stdout, stderr: standard file objects
  11 - modules: the table of modules (dictionary)
  12 - path: module search path (list of strings)
  13 - argv: script arguments (list of strings)
  14 - ps1, ps2: optional primary and secondary prompts (strings)
  15 */
  16
  17 #include "Python.h"
  18 #include "structseq.h"
  19 #include "code.h"
  20 #include "frameobject.h"
  21 #include "eval.h"
  22
  23 #include "osdefs.h"
  24
  25 #ifdef MS_WINDOWS
  26 #define WIN32_LEAN_AND_MEAN
  27 #include "windows.h"
  28 #endif /* MS_WINDOWS */
  29
  30 #ifdef MS_COREDLL
  31 extern void *PyWin_DLLhModule;
  32 /* A string loaded from the DLL at startup: */
  33 extern const char *PyWin_DLLVersionString;
  34 #endif
  35
  36 #ifdef __VMS
  37 #include <unixlib.h>
  38 #endif
  39
  40 #ifdef MS_WINDOWS
  41 #include <windows.h>
  42 #endif
  43
  44 #ifdef HAVE_LANGINFO_H
  45 #include <locale.h>
  46 #include <langinfo.h>
  47 #endif
  48
  49 PyObject *
  50 PySys_GetObject(char *name)
  51 {
  52     PyThreadState *tstate = PyThreadState_GET();
  53     PyObject *sd = tstate->interp->sysdict;
  54     if (sd == NULL)
  55         return NULL;
  56     return PyDict_GetItemString(sd, name);
  57 }
  58
  59 FILE *
  60 PySys_GetFile(char *name, FILE *def)
  61 {
  62     FILE *fp = NULL;
  63     PyObject *v = PySys_GetObject(name);
  64     if (v != NULL && PyFile_Check(v))
  65         fp = PyFile_AsFile(v);
  66     if (fp == NULL)
  67         fp = def;
  68     return fp;
  69 }
  70
  71 int
  72 PySys_SetObject(char *name, PyObject *v)
  73 {
  74     PyThreadState *tstate = PyThreadState_GET();
  75     PyObject *sd = tstate->interp->sysdict;
  76     if (v == NULL) {
  77         if (PyDict_GetItemString(sd, name) == NULL)
  78             return 0;
  79         else
  80             return PyDict_DelItemString(sd, name);
  81     }
  82     else
  83         return PyDict_SetItemString(sd, name, v);
  84 }
  85
  86 static PyObject *
  87 sys_displayhook(PyObject *self, PyObject *o)
  88 {
  89     PyObject *outf;
  90     PyInterpreterState *interp = PyThreadState_GET()->interp;
  91     PyObject *modules = interp->modules;
  92     PyObject *builtins = PyDict_GetItemString(modules, "__builtin__");
  93
  94     if (builtins == NULL) {
  95         PyErr_SetString(PyExc_RuntimeError, "lost __builtin__");
  96         return NULL;
  97     }
  98
  99     /* Print value except if None */
 100     /* After printing, also assign to '_' */
 101     /* Before, set '_' to None to avoid recursion */
 102     if (o == Py_None) {
 103         Py_INCREF(Py_None);
 104         return Py_None;
 105     }
 106     if (PyObject_SetAttrString(builtins, "_", Py_None) != 0)
 107         return NULL;
 108     if (Py_FlushLine() != 0)
 109         return NULL;
 110     outf = PySys_GetObject("stdout");
 111     if (outf == NULL) {
 112         PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
 113         return NULL;
 114     }
 115     if (PyFile_WriteObject(o, outf, 0) != 0)
 116         return NULL;
 117     PyFile_SoftSpace(outf, 1);
 118     if (Py_FlushLine() != 0)
 119         return NULL;
 120     if (PyObject_SetAttrString(builtins, "_", o) != 0)
 121         return NULL;
 122     Py_INCREF(Py_None);
 123     return Py_None;
 124 }
 125
 126 PyDoc_STRVAR(displayhook_doc,
 127 "displayhook(object) -> None\n"
 128 "\n"
 129 "Print an object to sys.stdout and also save it in __builtin__._\n"
 130 );
 131
 132 static PyObject *
 133 sys_excepthook(PyObject* self, PyObject* args)
 134 {
 135     PyObject *exc, *value, *tb;
 136     if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb))
 137         return NULL;
 138     PyErr_Display(exc, value, tb);
 139     Py_INCREF(Py_None);
 140     return Py_None;
 141 }
 142
 143 PyDoc_STRVAR(excepthook_doc,
 144 "excepthook(exctype, value, traceback) -> None\n"
 145 "\n"
 146 "Handle an exception by displaying it with a traceback on sys.stderr.\n"
 147 );
 148
 149 static PyObject *
 150 sys_exc_info(PyObject *self, PyObject *noargs)
 151 {
 152     PyThreadState *tstate;
 153     tstate = PyThreadState_GET();
 154     return Py_BuildValue(
 155         "(OOO)",
 156         tstate->exc_type != NULL ? tstate->exc_type : Py_None,
 157         tstate->exc_value != NULL ? tstate->exc_value : Py_None,
 158         tstate->exc_traceback != NULL ?
 159             tstate->exc_traceback : Py_None);
 160 }
 161
 162 PyDoc_STRVAR(exc_info_doc,
 163 "exc_info() -> (type, value, traceback)\n\
 164 \n\
 165 Return information about the most recent exception caught by an except\n\
 166 clause in the current stack frame or in an older stack frame."
 167 );
 168
 169 static PyObject *
 170 sys_exc_clear(PyObject *self, PyObject *noargs)
 171 {
 172     PyThreadState *tstate;
 173     PyObject *tmp_type, *tmp_value, *tmp_tb;
 174
 175     if (PyErr_WarnPy3k("sys.exc_clear() not supported in 3.x; "
 176                        "use except clauses", 1) < 0)
 177         return NULL;
 178
 179     tstate = PyThreadState_GET();
 180     tmp_type = tstate->exc_type;
 181     tmp_value = tstate->exc_value;
 182     tmp_tb = tstate->exc_traceback;
 183     tstate->exc_type = NULL;
 184     tstate->exc_value = NULL;
 185     tstate->exc_traceback = NULL;
 186     Py_XDECREF(tmp_type);
 187     Py_XDECREF(tmp_value);
 188     Py_XDECREF(tmp_tb);
 189     /* For b/w compatibility */
 190     PySys_SetObject("exc_type", Py_None);
 191     PySys_SetObject("exc_value", Py_None);
 192     PySys_SetObject("exc_traceback", Py_None);
 193     Py_INCREF(Py_None);
 194     return Py_None;
 195 }
 196
 197 PyDoc_STRVAR(exc_clear_doc,
 198 "exc_clear() -> None\n\
 199 \n\
 200 Clear global information on the current exception.  Subsequent calls to\n\
 201 exc_info() will return (None,None,None) until another exception is raised\n\
 202 in the current thread or the execution stack returns to a frame where\n\
 203 another exception is being handled."
 204 );
 205
 206 static PyObject *
 207 sys_exit(PyObject *self, PyObject *args)
 208 {
 209     PyObject *exit_code = 0;
 210     if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code))
 211         return NULL;
 212     /* Raise SystemExit so callers may catch it or clean up. */
 213     PyErr_SetObject(PyExc_SystemExit, exit_code);
 214     return NULL;
 215 }
 216
 217 PyDoc_STRVAR(exit_doc,
 218 "exit([status])\n\
 219 \n\
 220 Exit the interpreter by raising SystemExit(status).\n\
 221 If the status is omitted or None, it defaults to zero (i.e., success).\n\
 222 If the status is an integer, it will be used as the system exit status.\n\
 223 If it is another kind of object, it will be printed and the system\n\
 224 exit status will be one (i.e., failure)."
 225 );
 226
 227 #ifdef Py_USING_UNICODE
 228
 229 static PyObject *
 230 sys_getdefaultencoding(PyObject *self)
 231 {
 232     return PyString_FromString(PyUnicode_GetDefaultEncoding());
 233 }
 234
 235 PyDoc_STRVAR(getdefaultencoding_doc,
 236 "getdefaultencoding() -> string\n\
 237 \n\
 238 Return the current default string encoding used by the Unicode \n\
 239 implementation."
 240 );
 241
 242 static PyObject *
 243 sys_setdefaultencoding(PyObject *self, PyObject *args)
 244 {
 245     char *encoding;
 246     if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding))
 247         return NULL;
 248     if (PyUnicode_SetDefaultEncoding(encoding))
 249         return NULL;
 250     Py_INCREF(Py_None);
 251     return Py_None;
 252 }
 253
 254 PyDoc_STRVAR(setdefaultencoding_doc,
 255 "setdefaultencoding(encoding)\n\
 256 \n\
 257 Set the current default string encoding used by the Unicode implementation."
 258 );
 259
 260 static PyObject *
 261 sys_getfilesystemencoding(PyObject *self)
 262 {
 263     if (Py_FileSystemDefaultEncoding)
 264         return PyString_FromString(Py_FileSystemDefaultEncoding);
 265     Py_INCREF(Py_None);
 266     return Py_None;
 267 }
 268
 269 PyDoc_STRVAR(getfilesystemencoding_doc,
 270 "getfilesystemencoding() -> string\n\
 271 \n\
 272 Return the encoding used to convert Unicode filenames in\n\
 273 operating system filenames."
 274 );
 275
 276 #endif
 277
 278 /*
 279  * Cached interned string objects used for calling the profile and
 280  * trace functions.  Initialized by trace_init().
 281  */
 282 static PyObject *whatstrings[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
 283
 284 static int
 285 trace_init(void)
 286 {
 287     static char *whatnames[7] = {"call", "exception", "line", "return",
 288                                     "c_call", "c_exception", "c_return"};
 289     PyObject *name;
 290     int i;
 291     for (i = 0; i < 7; ++i) {
 292         if (whatstrings[i] == NULL) {
 293             name = PyString_InternFromString(whatnames[i]);
 294             if (name == NULL)
 295                 return -1;
 296             whatstrings[i] = name;
 297         }
 298     }
 299     return 0;
 300 }
 301
 302
 303 static PyObject *
 304 call_trampoline(PyThreadState *tstate, PyObject* callback,
 305                 PyFrameObject *frame, int what, PyObject *arg)
 306 {
 307     PyObject *args = PyTuple_New(3);
 308     PyObject *whatstr;
 309     PyObject *result;
 310
 311     if (args == NULL)
 312         return NULL;
 313     Py_INCREF(frame);
 314     whatstr = whatstrings[what];
 315     Py_INCREF(whatstr);
 316     if (arg == NULL)
 317         arg = Py_None;
 318     Py_INCREF(arg);
 319     PyTuple_SET_ITEM(args, 0, (PyObject *)frame);
 320     PyTuple_SET_ITEM(args, 1, whatstr);
 321     PyTuple_SET_ITEM(args, 2, arg);
 322
 323     /* call the Python-level function */
 324     PyFrame_FastToLocals(frame);
 325     result = PyEval_CallObject(callback, args);
 326     PyFrame_LocalsToFast(frame, 1);
 327     if (result == NULL)
 328         PyTraceBack_Here(frame);
 329
 330     /* cleanup */
 331     Py_DECREF(args);
 332     return result;
 333 }
 334
 335 static int
 336 profile_trampoline(PyObject *self, PyFrameObject *frame,
 337                    int what, PyObject *arg)
 338 {
 339     PyThreadState *tstate = frame->f_tstate;
 340     PyObject *result;
 341
 342     if (arg == NULL)
 343         arg = Py_None;
 344     result = call_trampoline(tstate, self, frame, what, arg);
 345     if (result == NULL) {
 346         PyEval_SetProfile(NULL, NULL);
 347         return -1;
 348     }
 349     Py_DECREF(result);
 350     return 0;
 351 }
 352
 353 static int
 354 trace_trampoline(PyObject *self, PyFrameObject *frame,
 355                  int what, PyObject *arg)
 356 {
 357     PyThreadState *tstate = frame->f_tstate;
 358     PyObject *callback;
 359     PyObject *result;
 360
 361     if (what == PyTrace_CALL)
 362         callback = self;
 363     else
 364         callback = frame->f_trace;
 365     if (callback == NULL)
 366         return 0;
 367     result = call_trampoline(tstate, callback, frame, what, arg);
 368     if (result == NULL) {
 369         PyEval_SetTrace(NULL, NULL);
 370         Py_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
 385 static PyObject *
 386 sys_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
 398 PyDoc_STRVAR(settrace_doc,
 399 "settrace(function)\n\
 400 \n\
 401 Set the global debug tracing function.  It will be called on each\n\
 402 function call.  See the debugger chapter in the library manual."
 403 );
 404
 405 static PyObject *
 406 sys_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
 417 PyDoc_STRVAR(gettrace_doc,
 418 "gettrace()\n\
 419 \n\
 420 Return the global debug tracing function set with sys.settrace.\n\
 421 See the debugger chapter in the library manual."
 422 );
 423
 424 static PyObject *
 425 sys_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
 437 PyDoc_STRVAR(setprofile_doc,
 438 "setprofile(function)\n\
 439 \n\
 440 Set the profiling function.  It will be called on each function call\n\
 441 and return.  See the profiler chapter in the library manual."
 442 );
 443
 444 static PyObject *
 445 sys_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
 456 PyDoc_STRVAR(getprofile_doc,
 457 "getprofile()\n\
 458 \n\
 459 Return the profiling function set with sys.setprofile.\n\
 460 See the profiler chapter in the library manual."
 461 );
 462
 463 static PyObject *
 464 sys_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
 473 PyDoc_STRVAR(setcheckinterval_doc,
 474 "setcheckinterval(n)\n\
 475 \n\
 476 Tell the Python interpreter to check for asynchronous events every\n\
 477 n instructions.  This also affects how often thread switches occur."
 478 );
 479
 480 static PyObject *
 481 sys_getcheckinterval(PyObject *self, PyObject *args)
 482 {
 483     return PyInt_FromLong(_Py_CheckInterval);
 484 }
 485
 486 PyDoc_STRVAR(getcheckinterval_doc,
 487 "getcheckinterval() -> current check interval; see setcheckinterval()."
 488 );
 489
 490 #ifdef WITH_TSC
 491 static PyObject *
 492 sys_settscdump(PyObject *self, PyObject *args)
 493 {
 494     int bool;
 495     PyThreadState *tstate = PyThreadState_Get();
 496
 497     if (!PyArg_ParseTuple(args, "i:settscdump", &bool))
 498         return NULL;
 499     if (bool)
 500         tstate->interp->tscdump = 1;
 501     else
 502         tstate->interp->tscdump = 0;
 503     Py_INCREF(Py_None);
 504     return Py_None;
 505
 506 }
 507
 508 PyDoc_STRVAR(settscdump_doc,
 509 "settscdump(bool)\n\
 510 \n\
 511 If true, tell the Python interpreter to dump VM measurements to\n\
 512 stderr.  If false, turn off dump.  The measurements are based on the\n\
 513 processor's time-stamp counter."
 514 );
 515 #endif /* TSC */
 516
 517 static PyObject *
 518 sys_setrecursionlimit(PyObject *self, PyObject *args)
 519 {
 520     int new_limit;
 521     if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit))
 522         return NULL;
 523     if (new_limit <= 0) {
 524         PyErr_SetString(PyExc_ValueError,
 525                         "recursion limit must be positive");
 526         return NULL;
 527     }
 528     Py_SetRecursionLimit(new_limit);
 529     Py_INCREF(Py_None);
 530     return Py_None;
 531 }
 532
 533 PyDoc_STRVAR(setrecursionlimit_doc,
 534 "setrecursionlimit(n)\n\
 535 \n\
 536 Set the maximum depth of the Python interpreter stack to n.  This\n\
 537 limit prevents infinite recursion from causing an overflow of the C\n\
 538 stack and crashing Python.  The highest possible limit is platform-\n\
 539 dependent."
 540 );
 541
 542 static PyObject *
 543 sys_getrecursionlimit(PyObject *self)
 544 {
 545     return PyInt_FromLong(Py_GetRecursionLimit());
 546 }
 547
 548 PyDoc_STRVAR(getrecursionlimit_doc,
 549 "getrecursionlimit()\n\
 550 \n\
 551 Return the current value of the recursion limit, the maximum depth\n\
 552 of the Python interpreter stack.  This limit prevents infinite\n\
 553 recursion from causing an overflow of the C stack and crashing Python."
 554 );
 555
 556 #ifdef MS_WINDOWS
 557 PyDoc_STRVAR(getwindowsversion_doc,
 558 "getwindowsversion()\n\
 559 \n\
 560 Return information about the running version of Windows as a named tuple.\n\
 561 The members are named: major, minor, build, platform, service_pack,\n\
 562 service_pack_major, service_pack_minor, suite_mask, and product_type. For\n\
 563 backward compatibility, only the first 5 items are available by indexing.\n\
 564 All elements are numbers, except service_pack which is a string. Platform\n\
 565 may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP/Vista/7,\n\
 566 3 for Windows CE. Product_type may be 1 for a workstation, 2 for a domain\n\
 567 controller, 3 for a server."
 568 );
 569
 570 static PyTypeObject WindowsVersionType = {0, 0, 0, 0, 0, 0};
 571
 572 static 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
 585 static 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
 594 static PyObject *
 595 sys_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
 628 static PyObject *
 629 sys_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
 642 PyDoc_STRVAR(setdlopenflags_doc,
 643 "setdlopenflags(n) -> None\n\
 644 \n\
 645 Set the flags used by the interpreter for dlopen calls, such as when the\n\
 646 interpreter loads extension modules.  Among other things, this will enable\n\
 647 a lazy resolving of symbols when importing a module, if called as\n\
 648 sys.setdlopenflags(0).  To share symbols across extension modules, call as\n\
 649 sys.setdlopenflags(ctypes.RTLD_GLOBAL).  Symbolic names for the flag modules\n\
 650 can be either found in the ctypes module, or in the DLFCN module. If DLFCN\n\
 651 is not available, it can be generated from /usr/include/dlfcn.h using the\n\
 652 h2py script.");
 653
 654 static PyObject *
 655 sys_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
 663 PyDoc_STRVAR(getdlopenflags_doc,
 664 "getdlopenflags() -> int\n\
 665 \n\
 666 Return the current value of the flags that are used for dlopen calls.\n\
 667 The 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
 675 static PyObject *
 676 sys_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
 687 size_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
 736 static PyObject *
 737 sys_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
 763 PyDoc_STRVAR(getsizeof_doc,
 764 "getsizeof(object, default) -> int\n\
 765 \n\
 766 Return the size of object in bytes.");
 767
 768 static PyObject *
 769 sys_getrefcount(PyObject *self, PyObject *arg)
 770 {
 771     return PyInt_FromSsize_t(arg->ob_refcnt);
 772 }
 773
 774 #ifdef Py_REF_DEBUG
 775 static PyObject *
 776 sys_gettotalrefcount(PyObject *self)
 777 {
 778     return PyInt_FromSsize_t(_Py_GetRefTotal());
 779 }
 780 #endif /* Py_REF_DEBUG */
 781
 782 PyDoc_STRVAR(getrefcount_doc,
 783 "getrefcount(object) -> integer\n\
 784 \n\
 785 Return the reference count of object.  The count returned is generally\n\
 786 one higher than you might expect, because it includes the (temporary)\n\
 787 reference as an argument to getrefcount()."
 788 );
 789
 790 #ifdef COUNT_ALLOCS
 791 static PyObject *
 792 sys_getcounts(PyObject *self)
 793 {
 794     extern PyObject *get_counts(void);
 795
 796     return get_counts();
 797 }
 798 #endif
 799
 800 PyDoc_STRVAR(getframe_doc,
 801 "_getframe([depth]) -> frameobject\n\
 802 \n\
 803 Return a frame object from the call stack.  If optional integer depth is\n\
 804 given, return the frame object that many calls below the top of the stack.\n\
 805 If that is deeper than the call stack, ValueError is raised.  The default\n\
 806 for depth is zero, returning the frame at the top of the call stack.\n\
 807 \n\
 808 This function should be used for internal and specialized\n\
 809 purposes only."
 810 );
 811
 812 static PyObject *
 813 sys_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
 834 PyDoc_STRVAR(current_frames_doc,
 835 "_current_frames() -> dictionary\n\
 836 \n\
 837 Return a dictionary mapping each current thread T's thread id to T's\n\
 838 current stack frame.\n\
 839 \n\
 840 This function should be used for specialized purposes only."
 841 );
 842
 843 static PyObject *
 844 sys_current_frames(PyObject *self, PyObject *noargs)
 845 {
 846     return _PyThread_CurrentFrames();
 847 }
 848
 849 PyDoc_STRVAR(call_tracing_doc,
 850 "call_tracing(func, args) -> object\n\
 851 \n\
 852 Call func(*args), while tracing is enabled.  The tracing state is\n\
 853 saved, and restored afterwards.  This is intended to be called from\n\
 854 a debugger from a checkpoint, to recursively debug some other code."
 855 );
 856
 857 static PyObject *
 858 sys_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
 866 PyDoc_STRVAR(callstats_doc,
 867 "callstats() -> tuple of integers\n\
 868 \n\
 869 Return a tuple of function call statistics, if CALL_PROFILE was defined\n\
 870 when Python was built.  Otherwise, return None.\n\
 871 \n\
 872 When enabled, this function returns detailed, implementation-specific\n\
 873 details about the number of function calls executed. The return value is\n\
 874 a 11-tuple where the entries in the tuple are counts of:\n\
 875 0. all function calls\n\
 876 1. calls to PyFunction_Type objects\n\
 877 2. PyFunction calls that do not create an argument tuple\n\
 878 3. PyFunction calls that do not create an argument tuple\n\
 879    and bypass PyEval_EvalCodeEx()\n\
 880 4. PyMethod calls\n\
 881 5. PyMethod calls on bound methods\n\
 882 6. PyType calls\n\
 883 7. PyCFunction calls\n\
 884 8. generator calls\n\
 885 9. All other calls\n\
 886 10. Number of stack pops performed by call_function()"
 887 );
 888
 889 #ifdef __cplusplus
 890 extern "C" {
 891 #endif
 892
 893 #ifdef Py_TRACE_REFS
 894 /* Defined in objects.c because it uses static globals if that file */
 895 extern 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 */
 900 extern PyObject *_Py_GetDXProfile(PyObject *,  PyObject *);
 901 #endif
 902
 903 #ifdef __cplusplus
 904 }
 905 #endif
 906
 907 static PyObject *
 908 sys_clear_type_cache(PyObject* self, PyObject* args)
 909 {
 910     PyType_ClearCache();
 911     Py_RETURN_NONE;
 912 }
 913
 914 PyDoc_STRVAR(sys_clear_type_cache__doc__,
 915 "_clear_type_cache() -> None\n\
 916 Clear the internal type lookup cache.");
 917
 918
 919 static 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
 994 static PyObject *
 995 list_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
1021 static PyObject *warnoptions = NULL;
1022
1023 void
1024 PySys_ResetWarnOptions(void)
1025 {
1026     if (warnoptions == NULL || !PyList_Check(warnoptions))
1027         return;
1028     PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
1029 }
1030
1031 void
1032 PySys_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
1049 int
1050 PySys_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. */
1059 PyDoc_VAR(sys_doc) =
1060 PyDoc_STR(
1061 "This module provides access to some objects used or maintained by the\n\
1062 interpreter and to functions that interact strongly with the interpreter.\n\
1063 \n\
1064 Dynamic objects:\n\
1065 \n\
1066 argv -- command line arguments; argv[0] is the script pathname if known\n\
1067 path -- module search path; path[0] is the script directory, else ''\n\
1068 modules -- dictionary of loaded modules\n\
1069 \n\
1070 displayhook -- called to show results in an interactive session\n\
1071 excepthook -- 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\
1075 exitfunc -- 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\
1078 stdin -- standard input file object; used by raw_input() and input()\n\
1079 stdout -- standard output file object; used by the print statement\n\
1080 stderr -- 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\
1084 last_type -- type of last uncaught exception\n\
1085 last_value -- value of last uncaught exception\n\
1086 last_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\
1090 exc_type -- type of exception currently being handled\n\
1091 exc_value -- value of exception currently being handled\n\
1092 exc_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 */
1098 PyDoc_STR(
1099 "\n\
1100 Static objects:\n\
1101 \n\
1102 float_info -- a dict with information about the float inplementation.\n\
1103 long_info -- a struct sequence with information about the long implementation.\n\
1104 maxint -- the largest supported integer (the smallest is -maxint-1)\n\
1105 maxsize -- the largest supported length of containers.\n\
1106 maxunicode -- the largest supported character\n\
1107 builtin_module_names -- tuple of module names built into this interpreter\n\
1108 version -- the version of this interpreter as a string\n\
1109 version_info -- version information as a named tuple\n\
1110 hexversion -- version information encoded as a single integer\n\
1111 copyright -- copyright notice pertaining to this interpreter\n\
1112 platform -- platform identifier\n\
1113 executable -- absolute path of the executable binary of the Python interpreter\n\
1114 prefix -- prefix used to find the Python library\n\
1115 exec_prefix -- prefix used to find the machine-specific Python library\n\
1116 float_repr_style -- string indicating the style of repr() output for floats\n\
1117 "
1118 )
1119 #ifdef MS_WINDOWS
1120 /* concatenating string here */
1121 PyDoc_STR(
1122 "dllhandle -- [Windows only] integer handle of the Python DLL\n\
1123 winver -- [Windows only] version number of the Python DLL\n\
1124 "
1125 )
1126 #endif /* MS_WINDOWS */
1127 PyDoc_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\
1134 Functions:\n\
1135 \n\
1136 displayhook() -- print an object to the screen, and save it in __builtin__._\n\
1137 excepthook() -- print an exception and its traceback to sys.stderr\n\
1138 exc_info() -- return thread-safe information about the current exception\n\
1139 exc_clear() -- clear the exception state for the current thread\n\
1140 exit() -- exit the interpreter by raising SystemExit\n\
1141 getdlopenflags() -- returns flags to be used for dlopen() calls\n\
1142 getprofile() -- get the global profiling function\n\
1143 getrefcount() -- return the reference count for an object (plus one :-)\n\
1144 getrecursionlimit() -- return the max recursion depth for the interpreter\n\
1145 getsizeof() -- return the size of an object in bytes\n\
1146 gettrace() -- get the global debug tracing function\n\
1147 setcheckinterval() -- control how often the interpreter checks for events\n\
1148 setdlopenflags() -- set the flags to be used for dlopen() calls\n\
1149 setprofile() -- set the global profiling function\n\
1150 setrecursionlimit() -- set the max recursion depth for the interpreter\n\
1151 settrace() -- set the global debug tracing function\n\
1152 "
1153 )
1154 /* end of sys_doc */ ;
1155
1156 static 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 */
1164 static int svn_initialized;
1165 static char patchlevel_revision[50]; /* Just the number */
1166 static char branch[50];
1167 static char shortbranch[50];
1168 static const char *svn_revision;
1169
1170 static void
1171 svnversion_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 */
1186 const char*
1187 Py_SubversionRevision()
1188 {
1189     svnversion_init();
1190     return svn_revision;
1191 }
1192
1193 const char*
1194 Py_SubversionShortBranch()
1195 {
1196     svnversion_init();
1197     return shortbranch;
1198 }
1199
1200
1201 PyDoc_STRVAR(flags__doc__,
1202 "sys.flags\n\
1203 \n\
1204 Flags provided through command line arguments or environment vars.");
1205
1206 static PyTypeObject FlagsType = {0, 0, 0, 0, 0, 0};
1207
1208 static 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
1233 static 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
1244 static PyObject*
1245 make_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
1287 PyDoc_STRVAR(version_info__doc__,
1288 "sys.version_info\n\
1289 \n\
1290 Version information as a named tuple.");
1291
1292 static PyTypeObject VersionInfoType = {0, 0, 0, 0, 0, 0};
1293
1294 static 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 'release'"},
1299     {"serial", "Serial release number"},
1300     {0}
1301 };
1302
1303 static PyStructSequence_Desc version_info_desc = {
1304     "sys.version_info",     /* name */
1305     version_info__doc__,    /* doc */
1306     version_info_fields,    /* fields */
1307     5
1308 };
1309
1310 static PyObject *
1311 make_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
1356 PyObject *
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
1533 static PyObject *
1534 makepathobject(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
1566 void
1567 PySys_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
1577 static PyObject *
1578 makeargvobject(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
1618 void
1619 PySys_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
1722 void
1723 PySys_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
1753 static void
1754 mywrite(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
1782 void
1783 PySys_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
1792 void
1793 PySys_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 }