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