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