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