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