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