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