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 numeric, 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_XDECREF(frame->f_trace);
 371                 frame->f_trace = NULL;
 372                 return -1;
 373         }
 374         if (result != Py_None) {
 375                 PyObject *temp = frame->f_trace;
 376                 frame->f_trace = NULL;
 377                 Py_XDECREF(temp);
 378                 frame->f_trace = result;
 379         }
 380         else {
 381                 Py_DECREF(result);
 382         }
 383         return 0;
 384 }
 385
 386 static PyObject *
 387 sys_settrace(PyObject *self, PyObject *args)
 388 {
 389         if (trace_init() == -1)
 390                 return NULL;
 391         if (args == Py_None)
 392                 PyEval_SetTrace(NULL, NULL);
 393         else
 394                 PyEval_SetTrace(trace_trampoline, args);
 395         Py_INCREF(Py_None);
 396         return Py_None;
 397 }
 398
 399 PyDoc_STRVAR(settrace_doc,
 400 "settrace(function)\n\
 401 \n\
 402 Set the global debug tracing function.  It will be called on each\n\
 403 function call.  See the debugger chapter in the library manual."
 404 );
 405
 406 static PyObject *
 407 sys_gettrace(PyObject *self, PyObject *args)
 408 {
 409         PyThreadState *tstate = PyThreadState_GET();
 410         PyObject *temp = tstate->c_traceobj;
 411
 412         if (temp == NULL)
 413                 temp = Py_None;
 414         Py_INCREF(temp);
 415         return temp;
 416 }
 417
 418 PyDoc_STRVAR(gettrace_doc,
 419 "gettrace()\n\
 420 \n\
 421 Return the global debug tracing function set with sys.settrace.\n\
 422 See the debugger chapter in the library manual."
 423 );
 424
 425 static PyObject *
 426 sys_setprofile(PyObject *self, PyObject *args)
 427 {
 428         if (trace_init() == -1)
 429                 return NULL;
 430         if (args == Py_None)
 431                 PyEval_SetProfile(NULL, NULL);
 432         else
 433                 PyEval_SetProfile(profile_trampoline, args);
 434         Py_INCREF(Py_None);
 435         return Py_None;
 436 }
 437
 438 PyDoc_STRVAR(setprofile_doc,
 439 "setprofile(function)\n\
 440 \n\
 441 Set the profiling function.  It will be called on each function call\n\
 442 and return.  See the profiler chapter in the library manual."
 443 );
 444
 445 static PyObject *
 446 sys_getprofile(PyObject *self, PyObject *args)
 447 {
 448         PyThreadState *tstate = PyThreadState_GET();
 449         PyObject *temp = tstate->c_profileobj;
 450
 451         if (temp == NULL)
 452                 temp = Py_None;
 453         Py_INCREF(temp);
 454         return temp;
 455 }
 456
 457 PyDoc_STRVAR(getprofile_doc,
 458 "getprofile()\n\
 459 \n\
 460 Return the profiling function set with sys.setprofile.\n\
 461 See the profiler chapter in the library manual."
 462 );
 463
 464 static PyObject *
 465 sys_setcheckinterval(PyObject *self, PyObject *args)
 466 {
 467         if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval))
 468                 return NULL;
 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.\n\
 561 The result is a tuple of (major, minor, build, platform, text)\n\
 562 All elements are numbers, except text which is a string.\n\
 563 Platform may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP\n\
 564 "
 565 );
 566
 567 static PyObject *
 568 sys_getwindowsversion(PyObject *self)
 569 {
 570         OSVERSIONINFO ver;
 571         ver.dwOSVersionInfoSize = sizeof(ver);
 572         if (!GetVersionEx(&ver))
 573                 return PyErr_SetFromWindowsErr(0);
 574         return Py_BuildValue("HHHHs",
 575                              ver.dwMajorVersion,
 576                              ver.dwMinorVersion,
 577                              ver.dwBuildNumber,
 578                              ver.dwPlatformId,
 579                              ver.szCSDVersion);
 580 }
 581
 582 #endif /* MS_WINDOWS */
 583
 584 #ifdef HAVE_DLOPEN
 585 static PyObject *
 586 sys_setdlopenflags(PyObject *self, PyObject *args)
 587 {
 588         int new_val;
 589         PyThreadState *tstate = PyThreadState_GET();
 590         if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val))
 591                 return NULL;
 592         if (!tstate)
 593                 return NULL;
 594         tstate->interp->dlopenflags = new_val;
 595         Py_INCREF(Py_None);
 596         return Py_None;
 597 }
 598
 599 PyDoc_STRVAR(setdlopenflags_doc,
 600 "setdlopenflags(n) -> None\n\
 601 \n\
 602 Set the flags that will be used for dlopen() calls. Among other\n\
 603 things, this will enable a lazy resolving of symbols when importing\n\
 604 a module, if called as sys.setdlopenflags(0)\n\
 605 To share symbols across extension modules, call as\n\
 606 sys.setdlopenflags(dl.RTLD_NOW|dl.RTLD_GLOBAL)"
 607 );
 608
 609 static PyObject *
 610 sys_getdlopenflags(PyObject *self, PyObject *args)
 611 {
 612         PyThreadState *tstate = PyThreadState_GET();
 613         if (!tstate)
 614                 return NULL;
 615         return PyInt_FromLong(tstate->interp->dlopenflags);
 616 }
 617
 618 PyDoc_STRVAR(getdlopenflags_doc,
 619 "getdlopenflags() -> int\n\
 620 \n\
 621 Return the current value of the flags that are used for dlopen()\n\
 622 calls. The flag constants are defined in the dl module."
 623 );
 624 #endif
 625
 626 #ifdef USE_MALLOPT
 627 /* Link with -lmalloc (or -lmpc) on an SGI */
 628 #include <malloc.h>
 629
 630 static PyObject *
 631 sys_mdebug(PyObject *self, PyObject *args)
 632 {
 633         int flag;
 634         if (!PyArg_ParseTuple(args, "i:mdebug", &flag))
 635                 return NULL;
 636         mallopt(M_DEBUG, flag);
 637         Py_INCREF(Py_None);
 638         return Py_None;
 639 }
 640 #endif /* USE_MALLOPT */
 641
 642 static PyObject *
 643 sys_getsizeof(PyObject *self, PyObject *args)
 644 {
 645         static PyObject * str__sizeof__ = NULL;
 646
 647         /* Initialize static variable needed by _PyType_Lookup */
 648         if (str__sizeof__ == NULL) {
 649                 str__sizeof__ = PyString_InternFromString("__sizeof__");
 650                 if (str__sizeof__ == NULL)
 651                         return NULL;
 652         }
 653
 654         /* Type objects */
 655         if (PyType_Check(args)){
 656                 PyObject *method = _PyType_Lookup(Py_TYPE(args),
 657                                                   str__sizeof__);
 658                 if (method == NULL) {
 659                         PyErr_Format(PyExc_TypeError,
 660                                      "Type %.100s doesn't define __sizeof__",
 661                                      Py_TYPE(args)->tp_name);
 662                         return NULL;
 663                 }
 664                 return PyObject_CallFunctionObjArgs(method, args, NULL);
 665         }
 666         /* Instance of old-style classes */
 667         else if (PyInstance_Check(args))
 668                 return PyInt_FromSsize_t(PyInstance_Type.tp_basicsize);
 669         /* Old-style classes */
 670         else if (PyClass_Check(args))
 671                 return PyInt_FromSsize_t(PyClass_Type.tp_basicsize);
 672         else
 673                 return PyObject_CallMethod(args, "__sizeof__", NULL);
 674 }
 675
 676 PyDoc_STRVAR(getsizeof_doc,
 677 "getsizeof(object) -> int\n\
 678 \n\
 679 Return the size of object in bytes.");
 680
 681 static PyObject *
 682 sys_getrefcount(PyObject *self, PyObject *arg)
 683 {
 684         return PyInt_FromSsize_t(arg->ob_refcnt);
 685 }
 686
 687 #ifdef Py_REF_DEBUG
 688 static PyObject *
 689 sys_gettotalrefcount(PyObject *self)
 690 {
 691         return PyInt_FromSsize_t(_Py_GetRefTotal());
 692 }
 693 #endif /* Py_REF_DEBUG */
 694
 695 PyDoc_STRVAR(getrefcount_doc,
 696 "getrefcount(object) -> integer\n\
 697 \n\
 698 Return the reference count of object.  The count returned is generally\n\
 699 one higher than you might expect, because it includes the (temporary)\n\
 700 reference as an argument to getrefcount()."
 701 );
 702
 703 #ifdef COUNT_ALLOCS
 704 static PyObject *
 705 sys_getcounts(PyObject *self)
 706 {
 707         extern PyObject *get_counts(void);
 708
 709         return get_counts();
 710 }
 711 #endif
 712
 713 PyDoc_STRVAR(getframe_doc,
 714 "_getframe([depth]) -> frameobject\n\
 715 \n\
 716 Return a frame object from the call stack.  If optional integer depth is\n\
 717 given, return the frame object that many calls below the top of the stack.\n\
 718 If that is deeper than the call stack, ValueError is raised.  The default\n\
 719 for depth is zero, returning the frame at the top of the call stack.\n\
 720 \n\
 721 This function should be used for internal and specialized\n\
 722 purposes only."
 723 );
 724
 725 static PyObject *
 726 sys_getframe(PyObject *self, PyObject *args)
 727 {
 728         PyFrameObject *f = PyThreadState_GET()->frame;
 729         int depth = -1;
 730
 731         if (!PyArg_ParseTuple(args, "|i:_getframe", &depth))
 732                 return NULL;
 733
 734         while (depth > 0 && f != NULL) {
 735                 f = f->f_back;
 736                 --depth;
 737         }
 738         if (f == NULL) {
 739                 PyErr_SetString(PyExc_ValueError,
 740                                 "call stack is not deep enough");
 741                 return NULL;
 742         }
 743         Py_INCREF(f);
 744         return (PyObject*)f;
 745 }
 746
 747 PyDoc_STRVAR(current_frames_doc,
 748 "_current_frames() -> dictionary\n\
 749 \n\
 750 Return a dictionary mapping each current thread T's thread id to T's\n\
 751 current stack frame.\n\
 752 \n\
 753 This function should be used for specialized purposes only."
 754 );
 755
 756 static PyObject *
 757 sys_current_frames(PyObject *self, PyObject *noargs)
 758 {
 759         return _PyThread_CurrentFrames();
 760 }
 761
 762 PyDoc_STRVAR(call_tracing_doc,
 763 "call_tracing(func, args) -> object\n\
 764 \n\
 765 Call func(*args), while tracing is enabled.  The tracing state is\n\
 766 saved, and restored afterwards.  This is intended to be called from\n\
 767 a debugger from a checkpoint, to recursively debug some other code."
 768 );
 769
 770 static PyObject *
 771 sys_call_tracing(PyObject *self, PyObject *args)
 772 {
 773         PyObject *func, *funcargs;
 774         if (!PyArg_UnpackTuple(args, "call_tracing", 2, 2, &func, &funcargs))
 775                 return NULL;
 776         return _PyEval_CallTracing(func, funcargs);
 777 }
 778
 779 PyDoc_STRVAR(callstats_doc,
 780 "callstats() -> tuple of integers\n\
 781 \n\
 782 Return a tuple of function call statistics, if CALL_PROFILE was defined\n\
 783 when Python was built.  Otherwise, return None.\n\
 784 \n\
 785 When enabled, this function returns detailed, implementation-specific\n\
 786 details about the number of function calls executed. The return value is\n\
 787 a 11-tuple where the entries in the tuple are counts of:\n\
 788 0. all function calls\n\
 789 1. calls to PyFunction_Type objects\n\
 790 2. PyFunction calls that do not create an argument tuple\n\
 791 3. PyFunction calls that do not create an argument tuple\n\
 792    and bypass PyEval_EvalCodeEx()\n\
 793 4. PyMethod calls\n\
 794 5. PyMethod calls on bound methods\n\
 795 6. PyType calls\n\
 796 7. PyCFunction calls\n\
 797 8. generator calls\n\
 798 9. All other calls\n\
 799 10. Number of stack pops performed by call_function()"
 800 );
 801
 802 #ifdef __cplusplus
 803 extern "C" {
 804 #endif
 805
 806 #ifdef Py_TRACE_REFS
 807 /* Defined in objects.c because it uses static globals if that file */
 808 extern PyObject *_Py_GetObjects(PyObject *, PyObject *);
 809 #endif
 810
 811 #ifdef DYNAMIC_EXECUTION_PROFILE
 812 /* Defined in ceval.c because it uses static globals if that file */
 813 extern PyObject *_Py_GetDXProfile(PyObject *,  PyObject *);
 814 #endif
 815
 816 #ifdef __cplusplus
 817 }
 818 #endif
 819
 820 static PyObject *
 821 sys_clear_type_cache(PyObject* self, PyObject* args)
 822 {
 823         PyType_ClearCache();
 824         Py_RETURN_NONE;
 825 }
 826
 827 PyDoc_STRVAR(sys_clear_type_cache__doc__,
 828 "_clear_type_cache() -> None\n\
 829 Clear the internal type lookup cache.");
 830
 831
 832 static PyObject *
 833 sys_compact_freelists(PyObject* self, PyObject* args)
 834 {
 835         size_t isum, ibc, ibf;
 836         size_t fsum, fbc, fbf;
 837
 838         PyInt_CompactFreeList(&ibc, &ibf, &isum);
 839         PyFloat_CompactFreeList(&fbc, &fbf, &fsum);
 840
 841         return Py_BuildValue("(kkk)(kkk)", isum, ibc, ibf,
 842                                            fsum, fbc, fbf);
 843
 844 }
 845
 846 PyDoc_STRVAR(sys_compact_freelists__doc__,
 847 "_compact_freelists() -> ((remaing_objects, total_blocks, freed_blocks), ...)\n\
 848 Compact the free lists of ints and floats.");
 849
 850 static PyMethodDef sys_methods[] = {
 851         /* Might as well keep this in alphabetic order */
 852         {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS,
 853          callstats_doc},
 854         {"_clear_type_cache",   sys_clear_type_cache,     METH_NOARGS,
 855          sys_clear_type_cache__doc__},
 856         {"_compact_freelists",  sys_compact_freelists,    METH_NOARGS,
 857          sys_compact_freelists__doc__},
 858         {"_current_frames", sys_current_frames, METH_NOARGS,
 859          current_frames_doc},
 860         {"displayhook", sys_displayhook, METH_O, displayhook_doc},
 861         {"exc_info",    sys_exc_info, METH_NOARGS, exc_info_doc},
 862         {"exc_clear",   sys_exc_clear, METH_NOARGS, exc_clear_doc},
 863         {"excepthook",  sys_excepthook, METH_VARARGS, excepthook_doc},
 864         {"exit",        sys_exit, METH_VARARGS, exit_doc},
 865 #ifdef Py_USING_UNICODE
 866         {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding,
 867          METH_NOARGS, getdefaultencoding_doc},
 868 #endif
 869 #ifdef HAVE_DLOPEN
 870         {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS,
 871          getdlopenflags_doc},
 872 #endif
 873 #ifdef COUNT_ALLOCS
 874         {"getcounts",   (PyCFunction)sys_getcounts, METH_NOARGS},
 875 #endif
 876 #ifdef DYNAMIC_EXECUTION_PROFILE
 877         {"getdxp",      _Py_GetDXProfile, METH_VARARGS},
 878 #endif
 879 #ifdef Py_USING_UNICODE
 880         {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding,
 881          METH_NOARGS, getfilesystemencoding_doc},
 882 #endif
 883 #ifdef Py_TRACE_REFS
 884         {"getobjects",  _Py_GetObjects, METH_VARARGS},
 885 #endif
 886 #ifdef Py_REF_DEBUG
 887         {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS},
 888 #endif
 889         {"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
 890         {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS,
 891          getrecursionlimit_doc},
 892         {"getsizeof",   sys_getsizeof,  METH_O, getsizeof_doc},
 893         {"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
 894 #ifdef MS_WINDOWS
 895         {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
 896          getwindowsversion_doc},
 897 #endif /* MS_WINDOWS */
 898 #ifdef USE_MALLOPT
 899         {"mdebug",      sys_mdebug, METH_VARARGS},
 900 #endif
 901 #ifdef Py_USING_UNICODE
 902         {"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS,
 903          setdefaultencoding_doc},
 904 #endif
 905         {"setcheckinterval",    sys_setcheckinterval, METH_VARARGS,
 906          setcheckinterval_doc},
 907         {"getcheckinterval",    sys_getcheckinterval, METH_NOARGS,
 908          getcheckinterval_doc},
 909 #ifdef HAVE_DLOPEN
 910         {"setdlopenflags", sys_setdlopenflags, METH_VARARGS,
 911          setdlopenflags_doc},
 912 #endif
 913         {"setprofile",  sys_setprofile, METH_O, setprofile_doc},
 914         {"getprofile",  sys_getprofile, METH_NOARGS, getprofile_doc},
 915         {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS,
 916          setrecursionlimit_doc},
 917 #ifdef WITH_TSC
 918         {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc},
 919 #endif
 920         {"settrace",    sys_settrace, METH_O, settrace_doc},
 921         {"gettrace",    sys_gettrace, METH_NOARGS, gettrace_doc},
 922         {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},
 923         {NULL,          NULL}           /* sentinel */
 924 };
 925
 926 static PyObject *
 927 list_builtin_module_names(void)
 928 {
 929         PyObject *list = PyList_New(0);
 930         int i;
 931         if (list == NULL)
 932                 return NULL;
 933         for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
 934                 PyObject *name = PyString_FromString(
 935                         PyImport_Inittab[i].name);
 936                 if (name == NULL)
 937                         break;
 938                 PyList_Append(list, name);
 939                 Py_DECREF(name);
 940         }
 941         if (PyList_Sort(list) != 0) {
 942                 Py_DECREF(list);
 943                 list = NULL;
 944         }
 945         if (list) {
 946                 PyObject *v = PyList_AsTuple(list);
 947                 Py_DECREF(list);
 948                 list = v;
 949         }
 950         return list;
 951 }
 952
 953 static PyObject *warnoptions = NULL;
 954
 955 void
 956 PySys_ResetWarnOptions(void)
 957 {
 958         if (warnoptions == NULL || !PyList_Check(warnoptions))
 959                 return;
 960         PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
 961 }
 962
 963 void
 964 PySys_AddWarnOption(char *s)
 965 {
 966         PyObject *str;
 967
 968         if (warnoptions == NULL || !PyList_Check(warnoptions)) {
 969                 Py_XDECREF(warnoptions);
 970                 warnoptions = PyList_New(0);
 971                 if (warnoptions == NULL)
 972                         return;
 973         }
 974         str = PyString_FromString(s);
 975         if (str != NULL) {
 976                 PyList_Append(warnoptions, str);
 977                 Py_DECREF(str);
 978         }
 979 }
 980
 981 int
 982 PySys_HasWarnOptions(void)
 983 {
 984     return (warnoptions != NULL && (PyList_Size(warnoptions) > 0)) ? 1 : 0;
 985 }
 986
 987 /* XXX This doc string is too long to be a single string literal in VC++ 5.0.
 988    Two literals concatenated works just fine.  If you have a K&R compiler
 989    or other abomination that however *does* understand longer strings,
 990    get rid of the !!! comment in the middle and the quotes that surround it. */
 991 PyDoc_VAR(sys_doc) =
 992 PyDoc_STR(
 993 "This module provides access to some objects used or maintained by the\n\
 994 interpreter and to functions that interact strongly with the interpreter.\n\
 995 \n\
 996 Dynamic objects:\n\
 997 \n\
 998 argv -- command line arguments; argv[0] is the script pathname if known\n\
 999 path -- module search path; path[0] is the script directory, else ''\n\
1000 modules -- dictionary of loaded modules\n\
1001 \n\
1002 displayhook -- called to show results in an interactive session\n\
1003 excepthook -- called to handle any uncaught exception other than SystemExit\n\
1004   To customize printing in an interactive session or to install a custom\n\
1005   top-level exception handler, assign other functions to replace these.\n\
1006 \n\
1007 exitfunc -- if sys.exitfunc exists, this routine is called when Python exits\n\
1008   Assigning to sys.exitfunc is deprecated; use the atexit module instead.\n\
1009 \n\
1010 stdin -- standard input file object; used by raw_input() and input()\n\
1011 stdout -- standard output file object; used by the print statement\n\
1012 stderr -- standard error object; used for error messages\n\
1013   By assigning other file objects (or objects that behave like files)\n\
1014   to these, it is possible to redirect all of the interpreter's I/O.\n\
1015 \n\
1016 last_type -- type of last uncaught exception\n\
1017 last_value -- value of last uncaught exception\n\
1018 last_traceback -- traceback of last uncaught exception\n\
1019   These three are only available in an interactive session after a\n\
1020   traceback has been printed.\n\
1021 \n\
1022 exc_type -- type of exception currently being handled\n\
1023 exc_value -- value of exception currently being handled\n\
1024 exc_traceback -- traceback of exception currently being handled\n\
1025   The function exc_info() should be used instead of these three,\n\
1026   because it is thread-safe.\n\
1027 "
1028 )
1029 /* concatenating string here */
1030 PyDoc_STR(
1031 "\n\
1032 Static objects:\n\
1033 \n\
1034 maxint -- the largest supported integer (the smallest is -maxint-1)\n\
1035 maxsize -- the largest supported length of containers.\n\
1036 maxunicode -- the largest supported character\n\
1037 builtin_module_names -- tuple of module names built into this interpreter\n\
1038 version -- the version of this interpreter as a string\n\
1039 version_info -- version information as a tuple\n\
1040 hexversion -- version information encoded as a single integer\n\
1041 copyright -- copyright notice pertaining to this interpreter\n\
1042 platform -- platform identifier\n\
1043 executable -- pathname of this Python interpreter\n\
1044 prefix -- prefix used to find the Python library\n\
1045 exec_prefix -- prefix used to find the machine-specific Python library\n\
1046 "
1047 )
1048 #ifdef MS_WINDOWS
1049 /* concatenating string here */
1050 PyDoc_STR(
1051 "dllhandle -- [Windows only] integer handle of the Python DLL\n\
1052 winver -- [Windows only] version number of the Python DLL\n\
1053 "
1054 )
1055 #endif /* MS_WINDOWS */
1056 PyDoc_STR(
1057 "__stdin__ -- the original stdin; don't touch!\n\
1058 __stdout__ -- the original stdout; don't touch!\n\
1059 __stderr__ -- the original stderr; don't touch!\n\
1060 __displayhook__ -- the original displayhook; don't touch!\n\
1061 __excepthook__ -- the original excepthook; don't touch!\n\
1062 \n\
1063 Functions:\n\
1064 \n\
1065 displayhook() -- print an object to the screen, and save it in __builtin__._\n\
1066 excepthook() -- print an exception and its traceback to sys.stderr\n\
1067 exc_info() -- return thread-safe information about the current exception\n\
1068 exc_clear() -- clear the exception state for the current thread\n\
1069 exit() -- exit the interpreter by raising SystemExit\n\
1070 getdlopenflags() -- returns flags to be used for dlopen() calls\n\
1071 getprofile() -- get the global profiling function\n\
1072 getrefcount() -- return the reference count for an object (plus one :-)\n\
1073 getrecursionlimit() -- return the max recursion depth for the interpreter\n\
1074 getsizeof() -- return the size of an object in bytes\n\
1075 gettrace() -- get the global debug tracing function\n\
1076 setcheckinterval() -- control how often the interpreter checks for events\n\
1077 setdlopenflags() -- set the flags to be used for dlopen() calls\n\
1078 setprofile() -- set the global profiling function\n\
1079 setrecursionlimit() -- set the max recursion depth for the interpreter\n\
1080 settrace() -- set the global debug tracing function\n\
1081 "
1082 )
1083 /* end of sys_doc */ ;
1084
1085 static int
1086 _check_and_flush (FILE *stream)
1087 {
1088   int prev_fail = ferror (stream);
1089   return fflush (stream) || prev_fail ? EOF : 0;
1090 }
1091
1092 /* Subversion branch and revision management */
1093 static const char _patchlevel_revision[] = PY_PATCHLEVEL_REVISION;
1094 static const char headurl[] = "$HeadURL$";
1095 static int svn_initialized;
1096 static char patchlevel_revision[50]; /* Just the number */
1097 static char branch[50];
1098 static char shortbranch[50];
1099 static const char *svn_revision;
1100
1101 static void
1102 svnversion_init(void)
1103 {
1104         const char *python, *br_start, *br_end, *br_end2, *svnversion;
1105         Py_ssize_t len;
1106         int istag;
1107
1108         if (svn_initialized)
1109                 return;
1110
1111         python = strstr(headurl, "/python/");
1112         if (!python) {
1113                 /* XXX quick hack to get bzr working */
1114                 *patchlevel_revision = '\0';
1115                 strcpy(branch, "");
1116                 strcpy(shortbranch, "unknown");
1117                 svn_revision = "";
1118                 return;
1119                 /* Py_FatalError("subversion keywords missing"); */
1120         }
1121
1122         br_start = python + 8;
1123         br_end = strchr(br_start, '/');
1124         assert(br_end);
1125
1126         /* Works even for trunk,
1127            as we are in trunk/Python/sysmodule.c */
1128         br_end2 = strchr(br_end+1, '/');
1129
1130         istag = strncmp(br_start, "tags", 4) == 0;
1131         if (strncmp(br_start, "trunk", 5) == 0) {
1132                 strcpy(branch, "trunk");
1133                 strcpy(shortbranch, "trunk");
1134
1135         }
1136         else if (istag || strncmp(br_start, "branches", 8) == 0) {
1137                 len = br_end2 - br_start;
1138                 strncpy(branch, br_start, len);
1139                 branch[len] = '\0';
1140
1141                 len = br_end2 - (br_end + 1);
1142                 strncpy(shortbranch, br_end + 1, len);
1143                 shortbranch[len] = '\0';
1144         }
1145         else {
1146                 Py_FatalError("bad HeadURL");
1147                 return;
1148         }
1149
1150
1151         svnversion = _Py_svnversion();
1152         if (strcmp(svnversion, "exported") != 0)
1153                 svn_revision = svnversion;
1154         else if (istag) {
1155                 len = strlen(_patchlevel_revision);
1156                 assert(len >= 13);
1157                 assert(len < (sizeof(patchlevel_revision) + 13));
1158                 strncpy(patchlevel_revision, _patchlevel_revision + 11,
1159                         len - 13);
1160                 patchlevel_revision[len - 13] = '\0';
1161                 svn_revision = patchlevel_revision;
1162         }
1163         else
1164                 svn_revision = "";
1165
1166         svn_initialized = 1;
1167 }
1168
1169 /* Return svnversion output if available.
1170    Else return Revision of patchlevel.h if on branch.
1171    Else return empty string */
1172 const char*
1173 Py_SubversionRevision()
1174 {
1175         svnversion_init();
1176         return svn_revision;
1177 }
1178
1179 const char*
1180 Py_SubversionShortBranch()
1181 {
1182         svnversion_init();
1183         return shortbranch;
1184 }
1185
1186
1187 PyDoc_STRVAR(flags__doc__,
1188 "sys.flags\n\
1189 \n\
1190 Flags provided through command line arguments or environment vars.");
1191
1192 static PyTypeObject FlagsType = {0, 0, 0, 0, 0, 0};
1193
1194 static PyStructSequence_Field flags_fields[] = {
1195         {"debug",               "-d"},
1196         {"py3k_warning",        "-3"},
1197         {"division_warning",    "-Q"},
1198         {"division_new",        "-Qnew"},
1199         {"inspect",             "-i"},
1200         {"interactive",         "-i"},
1201         {"optimize",            "-O or -OO"},
1202         {"dont_write_bytecode", "-B"},
1203         {"no_user_site",        "-s"},
1204         {"no_site",             "-S"},
1205         {"ignore_environment",  "-E"},
1206         {"tabcheck",            "-t or -tt"},
1207         {"verbose",             "-v"},
1208 #ifdef RISCOS
1209         {"riscos_wimp",         "???"},
1210 #endif
1211         /* {"unbuffered",               "-u"}, */
1212         {"unicode",             "-U"},
1213         /* {"skip_first",               "-x"}, */
1214         {"bytes_warning", "-b"},
1215         {0}
1216 };
1217
1218 static PyStructSequence_Desc flags_desc = {
1219         "sys.flags",    /* name */
1220         flags__doc__,   /* doc */
1221         flags_fields,   /* fields */
1222 #ifdef RISCOS
1223         16
1224 #else
1225         15
1226 #endif
1227 };
1228
1229 static PyObject*
1230 make_flags(void)
1231 {
1232         int pos = 0;
1233         PyObject *seq;
1234
1235         seq = PyStructSequence_New(&FlagsType);
1236         if (seq == NULL)
1237                 return NULL;
1238
1239 #define SetFlag(flag) \
1240         PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag))
1241
1242         SetFlag(Py_DebugFlag);
1243         SetFlag(Py_Py3kWarningFlag);
1244         SetFlag(Py_DivisionWarningFlag);
1245         SetFlag(_Py_QnewFlag);
1246         SetFlag(Py_InspectFlag);
1247         SetFlag(Py_InteractiveFlag);
1248         SetFlag(Py_OptimizeFlag);
1249         SetFlag(Py_DontWriteBytecodeFlag);
1250         SetFlag(Py_NoUserSiteDirectory);
1251         SetFlag(Py_NoSiteFlag);
1252         SetFlag(Py_IgnoreEnvironmentFlag);
1253         SetFlag(Py_TabcheckFlag);
1254         SetFlag(Py_VerboseFlag);
1255 #ifdef RISCOS
1256         SetFlag(Py_RISCOSWimpFlag);
1257 #endif
1258         /* SetFlag(saw_unbuffered_flag); */
1259         SetFlag(Py_UnicodeFlag);
1260         /* SetFlag(skipfirstline); */
1261     SetFlag(Py_BytesWarningFlag);
1262 #undef SetFlag
1263
1264         if (PyErr_Occurred()) {
1265                 return NULL;
1266         }
1267         return seq;
1268 }
1269
1270 PyObject *
1271 _PySys_Init(void)
1272 {
1273         PyObject *m, *v, *sysdict;
1274         PyObject *sysin, *sysout, *syserr;
1275         char *s;
1276
1277         m = Py_InitModule3("sys", sys_methods, sys_doc);
1278         if (m == NULL)
1279                 return NULL;
1280         sysdict = PyModule_GetDict(m);
1281 #define SET_SYS_FROM_STRING(key, value)                 \
1282         v = value;                                      \
1283         if (v != NULL)                                  \
1284                 PyDict_SetItemString(sysdict, key, v);  \
1285         Py_XDECREF(v)
1286
1287         {
1288                 /* XXX: does this work on Win/Win64? (see posix_fstat) */
1289                 struct stat sb;
1290                 if (fstat(fileno(stdin), &sb) == 0 &&
1291                     S_ISDIR(sb.st_mode)) {
1292                         /* There's nothing more we can do. */
1293                         /* Py_FatalError() will core dump, so just exit. */
1294                         PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
1295                         exit(EXIT_FAILURE);
1296                 }
1297         }
1298
1299         /* Closing the standard FILE* if sys.std* goes aways causes problems
1300          * for embedded Python usages. Closing them when somebody explicitly
1301          * invokes .close() might be possible, but the FAQ promises they get
1302          * never closed. However, we still need to get write errors when
1303          * writing fails (e.g. because stdout is redirected), so we flush the
1304          * streams and check for errors before the file objects are deleted.
1305          * On OS X, fflush()ing stdin causes an error, so we exempt stdin
1306          * from that procedure.
1307          */
1308         sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL);
1309         sysout = PyFile_FromFile(stdout, "<stdout>", "w", _check_and_flush);
1310         syserr = PyFile_FromFile(stderr, "<stderr>", "w", _check_and_flush);
1311         if (PyErr_Occurred())
1312                 return NULL;
1313
1314         PyDict_SetItemString(sysdict, "stdin", sysin);
1315         PyDict_SetItemString(sysdict, "stdout", sysout);
1316         PyDict_SetItemString(sysdict, "stderr", syserr);
1317         /* Make backup copies for cleanup */
1318         PyDict_SetItemString(sysdict, "__stdin__", sysin);
1319         PyDict_SetItemString(sysdict, "__stdout__", sysout);
1320         PyDict_SetItemString(sysdict, "__stderr__", syserr);
1321         PyDict_SetItemString(sysdict, "__displayhook__",
1322                              PyDict_GetItemString(sysdict, "displayhook"));
1323         PyDict_SetItemString(sysdict, "__excepthook__",
1324                              PyDict_GetItemString(sysdict, "excepthook"));
1325         Py_XDECREF(sysin);
1326         Py_XDECREF(sysout);
1327         Py_XDECREF(syserr);
1328
1329         SET_SYS_FROM_STRING("version",
1330                              PyString_FromString(Py_GetVersion()));
1331         SET_SYS_FROM_STRING("hexversion",
1332                              PyInt_FromLong(PY_VERSION_HEX));
1333         svnversion_init();
1334         SET_SYS_FROM_STRING("subversion",
1335                              Py_BuildValue("(ssz)", "CPython", branch,
1336                                           svn_revision));
1337         SET_SYS_FROM_STRING("dont_write_bytecode",
1338                              PyBool_FromLong(Py_DontWriteBytecodeFlag));
1339         /*
1340          * These release level checks are mutually exclusive and cover
1341          * the field, so don't get too fancy with the pre-processor!
1342          */
1343 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
1344         s = "alpha";
1345 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
1346         s = "beta";
1347 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
1348         s = "candidate";
1349 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
1350         s = "final";
1351 #endif
1352
1353         SET_SYS_FROM_STRING("version_info",
1354                             Py_BuildValue("iiisi", PY_MAJOR_VERSION,
1355                                                PY_MINOR_VERSION,
1356                                                PY_MICRO_VERSION, s,
1357                                                PY_RELEASE_SERIAL));
1358         SET_SYS_FROM_STRING("api_version",
1359                             PyInt_FromLong(PYTHON_API_VERSION));
1360         SET_SYS_FROM_STRING("copyright",
1361                             PyString_FromString(Py_GetCopyright()));
1362         SET_SYS_FROM_STRING("platform",
1363                             PyString_FromString(Py_GetPlatform()));
1364         SET_SYS_FROM_STRING("executable",
1365                             PyString_FromString(Py_GetProgramFullPath()));
1366         SET_SYS_FROM_STRING("prefix",
1367                             PyString_FromString(Py_GetPrefix()));
1368         SET_SYS_FROM_STRING("exec_prefix",
1369                             PyString_FromString(Py_GetExecPrefix()));
1370         SET_SYS_FROM_STRING("maxsize",
1371                             PyInt_FromSsize_t(PY_SSIZE_T_MAX));
1372         SET_SYS_FROM_STRING("maxint",
1373                             PyInt_FromLong(PyInt_GetMax()));
1374         SET_SYS_FROM_STRING("py3kwarning",
1375                             PyBool_FromLong(Py_Py3kWarningFlag));
1376         SET_SYS_FROM_STRING("float_info",
1377                             PyFloat_GetInfo());
1378 #ifdef Py_USING_UNICODE
1379         SET_SYS_FROM_STRING("maxunicode",
1380                             PyInt_FromLong(PyUnicode_GetMax()));
1381 #endif
1382         SET_SYS_FROM_STRING("builtin_module_names",
1383                             list_builtin_module_names());
1384         {
1385                 /* Assumes that longs are at least 2 bytes long.
1386                    Should be safe! */
1387                 unsigned long number = 1;
1388                 char *value;
1389
1390                 s = (char *) &number;
1391                 if (s[0] == 0)
1392                         value = "big";
1393                 else
1394                         value = "little";
1395                 SET_SYS_FROM_STRING("byteorder",
1396                                     PyString_FromString(value));
1397         }
1398 #ifdef MS_COREDLL
1399         SET_SYS_FROM_STRING("dllhandle",
1400                             PyLong_FromVoidPtr(PyWin_DLLhModule));
1401         SET_SYS_FROM_STRING("winver",
1402                             PyString_FromString(PyWin_DLLVersionString));
1403 #endif
1404         if (warnoptions == NULL) {
1405                 warnoptions = PyList_New(0);
1406         }
1407         else {
1408                 Py_INCREF(warnoptions);
1409         }
1410         if (warnoptions != NULL) {
1411                 PyDict_SetItemString(sysdict, "warnoptions", warnoptions);
1412         }
1413
1414         if (FlagsType.tp_name == 0)
1415                 PyStructSequence_InitType(&FlagsType, &flags_desc);
1416         SET_SYS_FROM_STRING("flags", make_flags());
1417         /* prevent user from creating new instances */
1418         FlagsType.tp_init = NULL;
1419         FlagsType.tp_new = NULL;
1420
1421 #undef SET_SYS_FROM_STRING
1422         if (PyErr_Occurred())
1423                 return NULL;
1424         return m;
1425 }
1426
1427 static PyObject *
1428 makepathobject(char *path, int delim)
1429 {
1430         int i, n;
1431         char *p;
1432         PyObject *v, *w;
1433
1434         n = 1;
1435         p = path;
1436         while ((p = strchr(p, delim)) != NULL) {
1437                 n++;
1438                 p++;
1439         }
1440         v = PyList_New(n);
1441         if (v == NULL)
1442                 return NULL;
1443         for (i = 0; ; i++) {
1444                 p = strchr(path, delim);
1445                 if (p == NULL)
1446                         p = strchr(path, '\0'); /* End of string */
1447                 w = PyString_FromStringAndSize(path, (Py_ssize_t) (p - path));
1448                 if (w == NULL) {
1449                         Py_DECREF(v);
1450                         return NULL;
1451                 }
1452                 PyList_SetItem(v, i, w);
1453                 if (*p == '\0')
1454                         break;
1455                 path = p+1;
1456         }
1457         return v;
1458 }
1459
1460 void
1461 PySys_SetPath(char *path)
1462 {
1463         PyObject *v;
1464         if ((v = makepathobject(path, DELIM)) == NULL)
1465                 Py_FatalError("can't create sys.path");
1466         if (PySys_SetObject("path", v) != 0)
1467                 Py_FatalError("can't assign sys.path");
1468         Py_DECREF(v);
1469 }
1470
1471 static PyObject *
1472 makeargvobject(int argc, char **argv)
1473 {
1474         PyObject *av;
1475         if (argc <= 0 || argv == NULL) {
1476                 /* Ensure at least one (empty) argument is seen */
1477                 static char *empty_argv[1] = {""};
1478                 argv = empty_argv;
1479                 argc = 1;
1480         }
1481         av = PyList_New(argc);
1482         if (av != NULL) {
1483                 int i;
1484                 for (i = 0; i < argc; i++) {
1485 #ifdef __VMS
1486                         PyObject *v;
1487
1488                         /* argv[0] is the script pathname if known */
1489                         if (i == 0) {
1490                                 char* fn = decc$translate_vms(argv[0]);
1491                                 if ((fn == (char *)0) || fn == (char *)-1)
1492                                         v = PyString_FromString(argv[0]);
1493                                 else
1494                                         v = PyString_FromString(
1495                                                 decc$translate_vms(argv[0]));
1496                         } else
1497                                 v = PyString_FromString(argv[i]);
1498 #else
1499                         PyObject *v = PyString_FromString(argv[i]);
1500 #endif
1501                         if (v == NULL) {
1502                                 Py_DECREF(av);
1503                                 av = NULL;
1504                                 break;
1505                         }
1506                         PyList_SetItem(av, i, v);
1507                 }
1508         }
1509         return av;
1510 }
1511
1512 void
1513 PySys_SetArgv(int argc, char **argv)
1514 {
1515 #if defined(HAVE_REALPATH)
1516         char fullpath[MAXPATHLEN];
1517 #elif defined(MS_WINDOWS)
1518         char fullpath[MAX_PATH];
1519 #endif
1520         PyObject *av = makeargvobject(argc, argv);
1521         PyObject *path = PySys_GetObject("path");
1522         if (av == NULL)
1523                 Py_FatalError("no mem for sys.argv");
1524         if (PySys_SetObject("argv", av) != 0)
1525                 Py_FatalError("can't assign sys.argv");
1526         if (path != NULL) {
1527                 char *argv0 = argv[0];
1528                 char *p = NULL;
1529                 Py_ssize_t n = 0;
1530                 PyObject *a;
1531 #ifdef HAVE_READLINK
1532                 char link[MAXPATHLEN+1];
1533                 char argv0copy[2*MAXPATHLEN+1];
1534                 int nr = 0;
1535                 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0)
1536                         nr = readlink(argv0, link, MAXPATHLEN);
1537                 if (nr > 0) {
1538                         /* It's a symlink */
1539                         link[nr] = '\0';
1540                         if (link[0] == SEP)
1541                                 argv0 = link; /* Link to absolute path */
1542                         else if (strchr(link, SEP) == NULL)
1543                                 ; /* Link without path */
1544                         else {
1545                                 /* Must join(dirname(argv0), link) */
1546                                 char *q = strrchr(argv0, SEP);
1547                                 if (q == NULL)
1548                                         argv0 = link; /* argv0 without path */
1549                                 else {
1550                                         /* Must make a copy */
1551                                         strcpy(argv0copy, argv0);
1552                                         q = strrchr(argv0copy, SEP);
1553                                         strcpy(q+1, link);
1554                                         argv0 = argv0copy;
1555                                 }
1556                         }
1557                 }
1558 #endif /* HAVE_READLINK */
1559 #if SEP == '\\' /* Special case for MS filename syntax */
1560                 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
1561                         char *q;
1562 #ifdef MS_WINDOWS
1563                         char *ptemp;
1564                         if (GetFullPathName(argv0,
1565                                            sizeof(fullpath),
1566                                            fullpath,
1567                                            &ptemp)) {
1568                                 argv0 = fullpath;
1569                         }
1570 #endif
1571                         p = strrchr(argv0, SEP);
1572                         /* Test for alternate separator */
1573                         q = strrchr(p ? p : argv0, '/');
1574                         if (q != NULL)
1575                                 p = q;
1576                         if (p != NULL) {
1577                                 n = p + 1 - argv0;
1578                                 if (n > 1 && p[-1] != ':')
1579                                         n--; /* Drop trailing separator */
1580                         }
1581                 }
1582 #else /* All other filename syntaxes */
1583                 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
1584 #if defined(HAVE_REALPATH)
1585                         if (realpath(argv0, fullpath)) {
1586                                 argv0 = fullpath;
1587                         }
1588 #endif
1589                         p = strrchr(argv0, SEP);
1590                 }
1591                 if (p != NULL) {
1592 #ifndef RISCOS
1593                         n = p + 1 - argv0;
1594 #else /* don't include trailing separator */
1595                         n = p - argv0;
1596 #endif /* RISCOS */
1597 #if SEP == '/' /* Special case for Unix filename syntax */
1598                         if (n > 1)
1599                                 n--; /* Drop trailing separator */
1600 #endif /* Unix */
1601                 }
1602 #endif /* All others */
1603                 a = PyString_FromStringAndSize(argv0, n);
1604                 if (a == NULL)
1605                         Py_FatalError("no mem for sys.path insertion");
1606                 if (PyList_Insert(path, 0, a) < 0)
1607                         Py_FatalError("sys.path.insert(0) failed");
1608                 Py_DECREF(a);
1609         }
1610         Py_DECREF(av);
1611 }
1612
1613
1614 /* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
1615    Adapted from code submitted by Just van Rossum.
1616
1617    PySys_WriteStdout(format, ...)
1618    PySys_WriteStderr(format, ...)
1619
1620       The first function writes to sys.stdout; the second to sys.stderr.  When
1621       there is a problem, they write to the real (C level) stdout or stderr;
1622       no exceptions are raised.
1623
1624       Both take a printf-style format string as their first argument followed
1625       by a variable length argument list determined by the format string.
1626
1627       *** WARNING ***
1628
1629       The format should limit the total size of the formatted output string to
1630       1000 bytes.  In particular, this means that no unrestricted "%s" formats
1631       should occur; these should be limited using "%.<N>s where <N> is a
1632       decimal number calculated so that <N> plus the maximum size of other
1633       formatted text does not exceed 1000 bytes.  Also watch out for "%f",
1634       which can print hundreds of digits for very large numbers.
1635
1636  */
1637
1638 static void
1639 mywrite(char *name, FILE *fp, const char *format, va_list va)
1640 {
1641         PyObject *file;
1642         PyObject *error_type, *error_value, *error_traceback;
1643
1644         PyErr_Fetch(&error_type, &error_value, &error_traceback);
1645         file = PySys_GetObject(name);
1646         if (file == NULL || PyFile_AsFile(file) == fp)
1647                 vfprintf(fp, format, va);
1648         else {
1649                 char buffer[1001];
1650                 const int written = PyOS_vsnprintf(buffer, sizeof(buffer),
1651                                                    format, va);
1652                 if (PyFile_WriteString(buffer, file) != 0) {
1653                         PyErr_Clear();
1654                         fputs(buffer, fp);
1655                 }
1656                 if (written < 0 || (size_t)written >= sizeof(buffer)) {
1657                         const char *truncated = "... truncated";
1658                         if (PyFile_WriteString(truncated, file) != 0) {
1659                                 PyErr_Clear();
1660                                 fputs(truncated, fp);
1661                         }
1662                 }
1663         }
1664         PyErr_Restore(error_type, error_value, error_traceback);
1665 }
1666
1667 void
1668 PySys_WriteStdout(const char *format, ...)
1669 {
1670         va_list va;
1671
1672         va_start(va, format);
1673         mywrite("stdout", stdout, format, va);
1674         va_end(va);
1675 }
1676
1677 void
1678 PySys_WriteStderr(const char *format, ...)
1679 {
1680         va_list va;
1681
1682         va_start(va, format);
1683         mywrite("stderr", stderr, format, va);
1684         va_end(va);
1685 }