sysmodule.c revision 7a98be2efbdc44a6271e3bf6117a1e6c77828414
1 2/* System module */ 3 4/* 5Various bits of information used by the interpreter are collected in 6module 'sys'. 7Function member: 8- exit(sts): raise SystemExit 9Data 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 "code.h" 19#include "frameobject.h" 20#include "eval.h" 21 22#include "osdefs.h" 23 24#ifdef MS_WINDOWS 25#define WIN32_LEAN_AND_MEAN 26#include "windows.h" 27#endif /* MS_WINDOWS */ 28 29#ifdef MS_COREDLL 30extern void *PyWin_DLLhModule; 31/* A string loaded from the DLL at startup: */ 32extern const char *PyWin_DLLVersionString; 33#endif 34 35#ifdef __VMS 36#include <unixlib.h> 37#endif 38 39#ifdef MS_WINDOWS 40#include <windows.h> 41#endif 42 43#ifdef HAVE_LANGINFO_H 44#include <locale.h> 45#include <langinfo.h> 46#endif 47 48PyObject * 49PySys_GetObject(char *name) 50{ 51 PyThreadState *tstate = PyThreadState_GET(); 52 PyObject *sd = tstate->interp->sysdict; 53 if (sd == NULL) 54 return NULL; 55 return PyDict_GetItemString(sd, name); 56} 57 58int 59PySys_SetObject(char *name, PyObject *v) 60{ 61 PyThreadState *tstate = PyThreadState_GET(); 62 PyObject *sd = tstate->interp->sysdict; 63 if (v == NULL) { 64 if (PyDict_GetItemString(sd, name) == NULL) 65 return 0; 66 else 67 return PyDict_DelItemString(sd, name); 68 } 69 else 70 return PyDict_SetItemString(sd, name, v); 71} 72 73static PyObject * 74sys_displayhook(PyObject *self, PyObject *o) 75{ 76 PyObject *outf; 77 PyInterpreterState *interp = PyThreadState_GET()->interp; 78 PyObject *modules = interp->modules; 79 PyObject *builtins = PyDict_GetItemString(modules, "__builtin__"); 80 81 if (builtins == NULL) { 82 PyErr_SetString(PyExc_RuntimeError, "lost __builtin__"); 83 return NULL; 84 } 85 86 /* Print value except if None */ 87 /* After printing, also assign to '_' */ 88 /* Before, set '_' to None to avoid recursion */ 89 if (o == Py_None) { 90 Py_INCREF(Py_None); 91 return Py_None; 92 } 93 if (PyObject_SetAttrString(builtins, "_", Py_None) != 0) 94 return NULL; 95 outf = PySys_GetObject("stdout"); 96 if (outf == NULL) { 97 PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout"); 98 return NULL; 99 } 100 if (PyFile_WriteObject(o, outf, 0) != 0) 101 return NULL; 102 if (PyFile_WriteString("\n", outf) != 0) 103 return NULL; 104 if (PyObject_SetAttrString(builtins, "_", o) != 0) 105 return NULL; 106 Py_INCREF(Py_None); 107 return Py_None; 108} 109 110PyDoc_STRVAR(displayhook_doc, 111"displayhook(object) -> None\n" 112"\n" 113"Print an object to sys.stdout and also save it in __builtin__.\n" 114); 115 116static PyObject * 117sys_excepthook(PyObject* self, PyObject* args) 118{ 119 PyObject *exc, *value, *tb; 120 if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb)) 121 return NULL; 122 PyErr_Display(exc, value, tb); 123 Py_INCREF(Py_None); 124 return Py_None; 125} 126 127PyDoc_STRVAR(excepthook_doc, 128"excepthook(exctype, value, traceback) -> None\n" 129"\n" 130"Handle an exception by displaying it with a traceback on sys.stderr.\n" 131); 132 133static PyObject * 134sys_exc_info(PyObject *self, PyObject *noargs) 135{ 136 PyThreadState *tstate; 137 tstate = PyThreadState_GET(); 138 return Py_BuildValue( 139 "(OOO)", 140 tstate->exc_type != NULL ? tstate->exc_type : Py_None, 141 tstate->exc_value != NULL ? tstate->exc_value : Py_None, 142 tstate->exc_traceback != NULL ? 143 tstate->exc_traceback : Py_None); 144} 145 146PyDoc_STRVAR(exc_info_doc, 147"exc_info() -> (type, value, traceback)\n\ 148\n\ 149Return information about the most recent exception caught by an except\n\ 150clause in the current stack frame or in an older stack frame." 151); 152 153static PyObject * 154sys_exit(PyObject *self, PyObject *args) 155{ 156 PyObject *exit_code = 0; 157 if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code)) 158 return NULL; 159 /* Raise SystemExit so callers may catch it or clean up. */ 160 PyErr_SetObject(PyExc_SystemExit, exit_code); 161 return NULL; 162} 163 164PyDoc_STRVAR(exit_doc, 165"exit([status])\n\ 166\n\ 167Exit the interpreter by raising SystemExit(status).\n\ 168If the status is omitted or None, it defaults to zero (i.e., success).\n\ 169If the status is numeric, it will be used as the system exit status.\n\ 170If it is another kind of object, it will be printed and the system\n\ 171exit status will be one (i.e., failure)." 172); 173 174 175static PyObject * 176sys_getdefaultencoding(PyObject *self) 177{ 178 return PyUnicode_FromString(PyUnicode_GetDefaultEncoding()); 179} 180 181PyDoc_STRVAR(getdefaultencoding_doc, 182"getdefaultencoding() -> string\n\ 183\n\ 184Return the current default string encoding used by the Unicode \n\ 185implementation." 186); 187 188static PyObject * 189sys_setdefaultencoding(PyObject *self, PyObject *args) 190{ 191 char *encoding; 192 if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding)) 193 return NULL; 194 if (PyUnicode_SetDefaultEncoding(encoding)) 195 return NULL; 196 Py_INCREF(Py_None); 197 return Py_None; 198} 199 200PyDoc_STRVAR(setdefaultencoding_doc, 201"setdefaultencoding(encoding)\n\ 202\n\ 203Set the current default string encoding used by the Unicode implementation." 204); 205 206static PyObject * 207sys_getfilesystemencoding(PyObject *self) 208{ 209 if (Py_FileSystemDefaultEncoding) 210 return PyUnicode_FromString(Py_FileSystemDefaultEncoding); 211 Py_INCREF(Py_None); 212 return Py_None; 213} 214 215PyDoc_STRVAR(getfilesystemencoding_doc, 216"getfilesystemencoding() -> string\n\ 217\n\ 218Return the encoding used to convert Unicode filenames in\n\ 219operating system filenames." 220); 221 222 223 224static PyObject * 225sys_intern(PyObject *self, PyObject *args) 226{ 227 PyObject *s; 228 if (!PyArg_ParseTuple(args, "S:intern", &s)) 229 return NULL; 230 if (PyString_CheckExact(s)) { 231 Py_INCREF(s); 232 PyString_InternInPlace(&s); 233 return s; 234 } 235 else if (PyUnicode_CheckExact(s)) { 236 Py_INCREF(s); 237 PyUnicode_InternInPlace(&s); 238 return s; 239 } 240 else { 241 PyErr_Format(PyExc_TypeError, 242 "can't intern %.400s", s->ob_type->tp_name); 243 return NULL; 244 } 245} 246 247PyDoc_STRVAR(intern_doc, 248"intern(string) -> string\n\ 249\n\ 250``Intern'' the given string. This enters the string in the (global)\n\ 251table of interned strings whose purpose is to speed up dictionary lookups.\n\ 252Return the string itself or the previously interned string object with the\n\ 253same value."); 254 255 256/* 257 * Cached interned string objects used for calling the profile and 258 * trace functions. Initialized by trace_init(). 259 */ 260static PyObject *whatstrings[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL}; 261 262static int 263trace_init(void) 264{ 265 static char *whatnames[7] = {"call", "exception", "line", "return", 266 "c_call", "c_exception", "c_return"}; 267 PyObject *name; 268 int i; 269 for (i = 0; i < 7; ++i) { 270 if (whatstrings[i] == NULL) { 271 name = PyUnicode_InternFromString(whatnames[i]); 272 if (name == NULL) 273 return -1; 274 whatstrings[i] = name; 275 } 276 } 277 return 0; 278} 279 280 281static PyObject * 282call_trampoline(PyThreadState *tstate, PyObject* callback, 283 PyFrameObject *frame, int what, PyObject *arg) 284{ 285 PyObject *args = PyTuple_New(3); 286 PyObject *whatstr; 287 PyObject *result; 288 289 if (args == NULL) 290 return NULL; 291 Py_INCREF(frame); 292 whatstr = whatstrings[what]; 293 Py_INCREF(whatstr); 294 if (arg == NULL) 295 arg = Py_None; 296 Py_INCREF(arg); 297 PyTuple_SET_ITEM(args, 0, (PyObject *)frame); 298 PyTuple_SET_ITEM(args, 1, whatstr); 299 PyTuple_SET_ITEM(args, 2, arg); 300 301 /* call the Python-level function */ 302 PyFrame_FastToLocals(frame); 303 result = PyEval_CallObject(callback, args); 304 PyFrame_LocalsToFast(frame, 1); 305 if (result == NULL) 306 PyTraceBack_Here(frame); 307 308 /* cleanup */ 309 Py_DECREF(args); 310 return result; 311} 312 313static int 314profile_trampoline(PyObject *self, PyFrameObject *frame, 315 int what, PyObject *arg) 316{ 317 PyThreadState *tstate = frame->f_tstate; 318 PyObject *result; 319 320 if (arg == NULL) 321 arg = Py_None; 322 result = call_trampoline(tstate, self, frame, what, arg); 323 if (result == NULL) { 324 PyEval_SetProfile(NULL, NULL); 325 return -1; 326 } 327 Py_DECREF(result); 328 return 0; 329} 330 331static int 332trace_trampoline(PyObject *self, PyFrameObject *frame, 333 int what, PyObject *arg) 334{ 335 PyThreadState *tstate = frame->f_tstate; 336 PyObject *callback; 337 PyObject *result; 338 339 if (what == PyTrace_CALL) 340 callback = self; 341 else 342 callback = frame->f_trace; 343 if (callback == NULL) 344 return 0; 345 result = call_trampoline(tstate, callback, frame, what, arg); 346 if (result == NULL) { 347 PyEval_SetTrace(NULL, NULL); 348 Py_XDECREF(frame->f_trace); 349 frame->f_trace = NULL; 350 return -1; 351 } 352 if (result != Py_None) { 353 PyObject *temp = frame->f_trace; 354 frame->f_trace = NULL; 355 Py_XDECREF(temp); 356 frame->f_trace = result; 357 } 358 else { 359 Py_DECREF(result); 360 } 361 return 0; 362} 363 364static PyObject * 365sys_settrace(PyObject *self, PyObject *args) 366{ 367 if (trace_init() == -1) 368 return NULL; 369 if (args == Py_None) 370 PyEval_SetTrace(NULL, NULL); 371 else 372 PyEval_SetTrace(trace_trampoline, args); 373 Py_INCREF(Py_None); 374 return Py_None; 375} 376 377PyDoc_STRVAR(settrace_doc, 378"settrace(function)\n\ 379\n\ 380Set the global debug tracing function. It will be called on each\n\ 381function call. See the debugger chapter in the library manual." 382); 383 384static PyObject * 385sys_setprofile(PyObject *self, PyObject *args) 386{ 387 if (trace_init() == -1) 388 return NULL; 389 if (args == Py_None) 390 PyEval_SetProfile(NULL, NULL); 391 else 392 PyEval_SetProfile(profile_trampoline, args); 393 Py_INCREF(Py_None); 394 return Py_None; 395} 396 397PyDoc_STRVAR(setprofile_doc, 398"setprofile(function)\n\ 399\n\ 400Set the profiling function. It will be called on each function call\n\ 401and return. See the profiler chapter in the library manual." 402); 403 404static PyObject * 405sys_setcheckinterval(PyObject *self, PyObject *args) 406{ 407 if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval)) 408 return NULL; 409 Py_INCREF(Py_None); 410 return Py_None; 411} 412 413PyDoc_STRVAR(setcheckinterval_doc, 414"setcheckinterval(n)\n\ 415\n\ 416Tell the Python interpreter to check for asynchronous events every\n\ 417n instructions. This also affects how often thread switches occur." 418); 419 420static PyObject * 421sys_getcheckinterval(PyObject *self, PyObject *args) 422{ 423 return PyInt_FromLong(_Py_CheckInterval); 424} 425 426PyDoc_STRVAR(getcheckinterval_doc, 427"getcheckinterval() -> current check interval; see setcheckinterval()." 428); 429 430#ifdef WITH_TSC 431static PyObject * 432sys_settscdump(PyObject *self, PyObject *args) 433{ 434 int bool; 435 PyThreadState *tstate = PyThreadState_Get(); 436 437 if (!PyArg_ParseTuple(args, "i:settscdump", &bool)) 438 return NULL; 439 if (bool) 440 tstate->interp->tscdump = 1; 441 else 442 tstate->interp->tscdump = 0; 443 Py_INCREF(Py_None); 444 return Py_None; 445 446} 447 448PyDoc_STRVAR(settscdump_doc, 449"settscdump(bool)\n\ 450\n\ 451If true, tell the Python interpreter to dump VM measurements to\n\ 452stderr. If false, turn off dump. The measurements are based on the\n\ 453processor's time-stamp counter." 454); 455#endif /* TSC */ 456 457static PyObject * 458sys_setrecursionlimit(PyObject *self, PyObject *args) 459{ 460 int new_limit; 461 if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit)) 462 return NULL; 463 if (new_limit <= 0) { 464 PyErr_SetString(PyExc_ValueError, 465 "recursion limit must be positive"); 466 return NULL; 467 } 468 Py_SetRecursionLimit(new_limit); 469 Py_INCREF(Py_None); 470 return Py_None; 471} 472 473PyDoc_STRVAR(setrecursionlimit_doc, 474"setrecursionlimit(n)\n\ 475\n\ 476Set the maximum depth of the Python interpreter stack to n. This\n\ 477limit prevents infinite recursion from causing an overflow of the C\n\ 478stack and crashing Python. The highest possible limit is platform-\n\ 479dependent." 480); 481 482static PyObject * 483sys_getrecursionlimit(PyObject *self) 484{ 485 return PyInt_FromLong(Py_GetRecursionLimit()); 486} 487 488PyDoc_STRVAR(getrecursionlimit_doc, 489"getrecursionlimit()\n\ 490\n\ 491Return the current value of the recursion limit, the maximum depth\n\ 492of the Python interpreter stack. This limit prevents infinite\n\ 493recursion from causing an overflow of the C stack and crashing Python." 494); 495 496#ifdef MS_WINDOWS 497PyDoc_STRVAR(getwindowsversion_doc, 498"getwindowsversion()\n\ 499\n\ 500Return information about the running version of Windows.\n\ 501The result is a tuple of (major, minor, build, platform, text)\n\ 502All elements are numbers, except text which is a string.\n\ 503Platform may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP\n\ 504" 505); 506 507static PyObject * 508sys_getwindowsversion(PyObject *self) 509{ 510 OSVERSIONINFO ver; 511 ver.dwOSVersionInfoSize = sizeof(ver); 512 if (!GetVersionEx(&ver)) 513 return PyErr_SetFromWindowsErr(0); 514 return Py_BuildValue("HHHHs", 515 ver.dwMajorVersion, 516 ver.dwMinorVersion, 517 ver.dwBuildNumber, 518 ver.dwPlatformId, 519 ver.szCSDVersion); 520} 521 522#endif /* MS_WINDOWS */ 523 524#ifdef HAVE_DLOPEN 525static PyObject * 526sys_setdlopenflags(PyObject *self, PyObject *args) 527{ 528 int new_val; 529 PyThreadState *tstate = PyThreadState_GET(); 530 if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val)) 531 return NULL; 532 if (!tstate) 533 return NULL; 534 tstate->interp->dlopenflags = new_val; 535 Py_INCREF(Py_None); 536 return Py_None; 537} 538 539PyDoc_STRVAR(setdlopenflags_doc, 540"setdlopenflags(n) -> None\n\ 541\n\ 542Set the flags that will be used for dlopen() calls. Among other\n\ 543things, this will enable a lazy resolving of symbols when importing\n\ 544a module, if called as sys.setdlopenflags(0)\n\ 545To share symbols across extension modules, call as\n\ 546sys.setdlopenflags(dl.RTLD_NOW|dl.RTLD_GLOBAL)" 547); 548 549static PyObject * 550sys_getdlopenflags(PyObject *self, PyObject *args) 551{ 552 PyThreadState *tstate = PyThreadState_GET(); 553 if (!tstate) 554 return NULL; 555 return PyInt_FromLong(tstate->interp->dlopenflags); 556} 557 558PyDoc_STRVAR(getdlopenflags_doc, 559"getdlopenflags() -> int\n\ 560\n\ 561Return the current value of the flags that are used for dlopen()\n\ 562calls. The flag constants are defined in the dl module." 563); 564#endif 565 566#ifdef USE_MALLOPT 567/* Link with -lmalloc (or -lmpc) on an SGI */ 568#include <malloc.h> 569 570static PyObject * 571sys_mdebug(PyObject *self, PyObject *args) 572{ 573 int flag; 574 if (!PyArg_ParseTuple(args, "i:mdebug", &flag)) 575 return NULL; 576 mallopt(M_DEBUG, flag); 577 Py_INCREF(Py_None); 578 return Py_None; 579} 580#endif /* USE_MALLOPT */ 581 582static PyObject * 583sys_getrefcount(PyObject *self, PyObject *arg) 584{ 585 return PyInt_FromSsize_t(arg->ob_refcnt); 586} 587 588#ifdef Py_REF_DEBUG 589static PyObject * 590sys_gettotalrefcount(PyObject *self) 591{ 592 return PyInt_FromSsize_t(_Py_GetRefTotal()); 593} 594#endif /* Py_REF_DEBUG */ 595 596PyDoc_STRVAR(getrefcount_doc, 597"getrefcount(object) -> integer\n\ 598\n\ 599Return the reference count of object. The count returned is generally\n\ 600one higher than you might expect, because it includes the (temporary)\n\ 601reference as an argument to getrefcount()." 602); 603 604#ifdef COUNT_ALLOCS 605static PyObject * 606sys_getcounts(PyObject *self) 607{ 608 extern PyObject *get_counts(void); 609 610 return get_counts(); 611} 612#endif 613 614PyDoc_STRVAR(getframe_doc, 615"_getframe([depth]) -> frameobject\n\ 616\n\ 617Return a frame object from the call stack. If optional integer depth is\n\ 618given, return the frame object that many calls below the top of the stack.\n\ 619If that is deeper than the call stack, ValueError is raised. The default\n\ 620for depth is zero, returning the frame at the top of the call stack.\n\ 621\n\ 622This function should be used for internal and specialized\n\ 623purposes only." 624); 625 626static PyObject * 627sys_getframe(PyObject *self, PyObject *args) 628{ 629 PyFrameObject *f = PyThreadState_GET()->frame; 630 int depth = -1; 631 632 if (!PyArg_ParseTuple(args, "|i:_getframe", &depth)) 633 return NULL; 634 635 while (depth > 0 && f != NULL) { 636 f = f->f_back; 637 --depth; 638 } 639 if (f == NULL) { 640 PyErr_SetString(PyExc_ValueError, 641 "call stack is not deep enough"); 642 return NULL; 643 } 644 Py_INCREF(f); 645 return (PyObject*)f; 646} 647 648PyDoc_STRVAR(current_frames_doc, 649"_current_frames() -> dictionary\n\ 650\n\ 651Return a dictionary mapping each current thread T's thread id to T's\n\ 652current stack frame.\n\ 653\n\ 654This function should be used for specialized purposes only." 655); 656 657static PyObject * 658sys_current_frames(PyObject *self, PyObject *noargs) 659{ 660 return _PyThread_CurrentFrames(); 661} 662 663PyDoc_STRVAR(call_tracing_doc, 664"call_tracing(func, args) -> object\n\ 665\n\ 666Call func(*args), while tracing is enabled. The tracing state is\n\ 667saved, and restored afterwards. This is intended to be called from\n\ 668a debugger from a checkpoint, to recursively debug some other code." 669); 670 671static PyObject * 672sys_call_tracing(PyObject *self, PyObject *args) 673{ 674 PyObject *func, *funcargs; 675 if (!PyArg_UnpackTuple(args, "call_tracing", 2, 2, &func, &funcargs)) 676 return NULL; 677 return _PyEval_CallTracing(func, funcargs); 678} 679 680PyDoc_STRVAR(callstats_doc, 681"callstats() -> tuple of integers\n\ 682\n\ 683Return a tuple of function call statistics, if CALL_PROFILE was defined\n\ 684when Python was built. Otherwise, return None.\n\ 685\n\ 686When enabled, this function returns detailed, implementation-specific\n\ 687details about the number of function calls executed. The return value is\n\ 688a 11-tuple where the entries in the tuple are counts of:\n\ 6890. all function calls\n\ 6901. calls to PyFunction_Type objects\n\ 6912. PyFunction calls that do not create an argument tuple\n\ 6923. PyFunction calls that do not create an argument tuple\n\ 693 and bypass PyEval_EvalCodeEx()\n\ 6944. PyMethod calls\n\ 6955. PyMethod calls on bound methods\n\ 6966. PyType calls\n\ 6977. PyCFunction calls\n\ 6988. generator calls\n\ 6999. All other calls\n\ 70010. Number of stack pops performed by call_function()" 701); 702 703#ifdef __cplusplus 704extern "C" { 705#endif 706 707#ifdef Py_TRACE_REFS 708/* Defined in objects.c because it uses static globals if that file */ 709extern PyObject *_Py_GetObjects(PyObject *, PyObject *); 710#endif 711 712#ifdef DYNAMIC_EXECUTION_PROFILE 713/* Defined in ceval.c because it uses static globals if that file */ 714extern PyObject *_Py_GetDXProfile(PyObject *, PyObject *); 715#endif 716 717#ifdef __cplusplus 718} 719#endif 720 721static PyMethodDef sys_methods[] = { 722 /* Might as well keep this in alphabetic order */ 723 {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS, 724 callstats_doc}, 725 {"_current_frames", sys_current_frames, METH_NOARGS, 726 current_frames_doc}, 727 {"displayhook", sys_displayhook, METH_O, displayhook_doc}, 728 {"exc_info", sys_exc_info, METH_NOARGS, exc_info_doc}, 729 {"excepthook", sys_excepthook, METH_VARARGS, excepthook_doc}, 730 {"exit", sys_exit, METH_VARARGS, exit_doc}, 731 {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding, 732 METH_NOARGS, getdefaultencoding_doc}, 733#ifdef HAVE_DLOPEN 734 {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS, 735 getdlopenflags_doc}, 736#endif 737#ifdef COUNT_ALLOCS 738 {"getcounts", (PyCFunction)sys_getcounts, METH_NOARGS}, 739#endif 740#ifdef DYNAMIC_EXECUTION_PROFILE 741 {"getdxp", _Py_GetDXProfile, METH_VARARGS}, 742#endif 743 {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding, 744 METH_NOARGS, getfilesystemencoding_doc}, 745#ifdef Py_TRACE_REFS 746 {"getobjects", _Py_GetObjects, METH_VARARGS}, 747#endif 748#ifdef Py_REF_DEBUG 749 {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS}, 750#endif 751 {"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc}, 752 {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS, 753 getrecursionlimit_doc}, 754 {"_getframe", sys_getframe, METH_VARARGS, getframe_doc}, 755#ifdef MS_WINDOWS 756 {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS, 757 getwindowsversion_doc}, 758#endif /* MS_WINDOWS */ 759 {"intern", sys_intern, METH_VARARGS, intern_doc}, 760#ifdef USE_MALLOPT 761 {"mdebug", sys_mdebug, METH_VARARGS}, 762#endif 763 {"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS, 764 setdefaultencoding_doc}, 765 {"setcheckinterval", sys_setcheckinterval, METH_VARARGS, 766 setcheckinterval_doc}, 767 {"getcheckinterval", sys_getcheckinterval, METH_NOARGS, 768 getcheckinterval_doc}, 769#ifdef HAVE_DLOPEN 770 {"setdlopenflags", sys_setdlopenflags, METH_VARARGS, 771 setdlopenflags_doc}, 772#endif 773 {"setprofile", sys_setprofile, METH_O, setprofile_doc}, 774 {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS, 775 setrecursionlimit_doc}, 776#ifdef WITH_TSC 777 {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc}, 778#endif 779 {"settrace", sys_settrace, METH_O, settrace_doc}, 780 {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc}, 781 {NULL, NULL} /* sentinel */ 782}; 783 784static PyObject * 785list_builtin_module_names(void) 786{ 787 PyObject *list = PyList_New(0); 788 int i; 789 if (list == NULL) 790 return NULL; 791 for (i = 0; PyImport_Inittab[i].name != NULL; i++) { 792 PyObject *name = PyUnicode_FromString( 793 PyImport_Inittab[i].name); 794 if (name == NULL) 795 break; 796 PyList_Append(list, name); 797 Py_DECREF(name); 798 } 799 if (PyList_Sort(list) != 0) { 800 Py_DECREF(list); 801 list = NULL; 802 } 803 if (list) { 804 PyObject *v = PyList_AsTuple(list); 805 Py_DECREF(list); 806 list = v; 807 } 808 return list; 809} 810 811static PyObject *warnoptions = NULL; 812 813void 814PySys_ResetWarnOptions(void) 815{ 816 if (warnoptions == NULL || !PyList_Check(warnoptions)) 817 return; 818 PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL); 819} 820 821void 822PySys_AddWarnOption(char *s) 823{ 824 PyObject *str; 825 826 if (warnoptions == NULL || !PyList_Check(warnoptions)) { 827 Py_XDECREF(warnoptions); 828 warnoptions = PyList_New(0); 829 if (warnoptions == NULL) 830 return; 831 } 832 str = PyString_FromString(s); 833 if (str != NULL) { 834 PyList_Append(warnoptions, str); 835 Py_DECREF(str); 836 } 837} 838 839/* XXX This doc string is too long to be a single string literal in VC++ 5.0. 840 Two literals concatenated works just fine. If you have a K&R compiler 841 or other abomination that however *does* understand longer strings, 842 get rid of the !!! comment in the middle and the quotes that surround it. */ 843PyDoc_VAR(sys_doc) = 844PyDoc_STR( 845"This module provides access to some objects used or maintained by the\n\ 846interpreter and to functions that interact strongly with the interpreter.\n\ 847\n\ 848Dynamic objects:\n\ 849\n\ 850argv -- command line arguments; argv[0] is the script pathname if known\n\ 851path -- module search path; path[0] is the script directory, else ''\n\ 852modules -- dictionary of loaded modules\n\ 853\n\ 854displayhook -- called to show results in an interactive session\n\ 855excepthook -- called to handle any uncaught exception other than SystemExit\n\ 856 To customize printing in an interactive session or to install a custom\n\ 857 top-level exception handler, assign other functions to replace these.\n\ 858\n\ 859stdin -- standard input file object; used by raw_input() and input()\n\ 860stdout -- standard output file object; used by print()\n\ 861stderr -- standard error object; used for error messages\n\ 862 By assigning other file objects (or objects that behave like files)\n\ 863 to these, it is possible to redirect all of the interpreter's I/O.\n\ 864\n\ 865last_type -- type of last uncaught exception\n\ 866last_value -- value of last uncaught exception\n\ 867last_traceback -- traceback of last uncaught exception\n\ 868 These three are only available in an interactive session after a\n\ 869 traceback has been printed.\n\ 870" 871) 872/* concatenating string here */ 873PyDoc_STR( 874"\n\ 875Static objects:\n\ 876\n\ 877maxint -- the largest supported integer (the smallest is -maxint-1)\n\ 878maxunicode -- the largest supported character\n\ 879builtin_module_names -- tuple of module names built into this interpreter\n\ 880version -- the version of this interpreter as a string\n\ 881version_info -- version information as a tuple\n\ 882hexversion -- version information encoded as a single integer\n\ 883copyright -- copyright notice pertaining to this interpreter\n\ 884platform -- platform identifier\n\ 885executable -- pathname of this Python interpreter\n\ 886prefix -- prefix used to find the Python library\n\ 887exec_prefix -- prefix used to find the machine-specific Python library\n\ 888" 889) 890#ifdef MS_WINDOWS 891/* concatenating string here */ 892PyDoc_STR( 893"dllhandle -- [Windows only] integer handle of the Python DLL\n\ 894winver -- [Windows only] version number of the Python DLL\n\ 895" 896) 897#endif /* MS_WINDOWS */ 898PyDoc_STR( 899"__stdin__ -- the original stdin; don't touch!\n\ 900__stdout__ -- the original stdout; don't touch!\n\ 901__stderr__ -- the original stderr; don't touch!\n\ 902__displayhook__ -- the original displayhook; don't touch!\n\ 903__excepthook__ -- the original excepthook; don't touch!\n\ 904\n\ 905Functions:\n\ 906\n\ 907displayhook() -- print an object to the screen, and save it in __builtin__._\n\ 908excepthook() -- print an exception and its traceback to sys.stderr\n\ 909exc_info() -- return thread-safe information about the current exception\n\ 910exit() -- exit the interpreter by raising SystemExit\n\ 911getdlopenflags() -- returns flags to be used for dlopen() calls\n\ 912getrefcount() -- return the reference count for an object (plus one :-)\n\ 913getrecursionlimit() -- return the max recursion depth for the interpreter\n\ 914setcheckinterval() -- control how often the interpreter checks for events\n\ 915setdlopenflags() -- set the flags to be used for dlopen() calls\n\ 916setprofile() -- set the global profiling function\n\ 917setrecursionlimit() -- set the max recursion depth for the interpreter\n\ 918settrace() -- set the global debug tracing function\n\ 919" 920) 921/* end of sys_doc */ ; 922 923/* Subversion branch and revision management */ 924static const char _patchlevel_revision[] = PY_PATCHLEVEL_REVISION; 925static const char headurl[] = "$HeadURL$"; 926static int svn_initialized; 927static char patchlevel_revision[50]; /* Just the number */ 928static char branch[50]; 929static char shortbranch[50]; 930static const char *svn_revision; 931 932static void 933svnversion_init(void) 934{ 935 const char *python, *br_start, *br_end, *br_end2, *svnversion; 936 Py_ssize_t len; 937 int istag; 938 939 if (svn_initialized) 940 return; 941 942 python = strstr(headurl, "/python/"); 943 if (!python) 944 Py_FatalError("subversion keywords missing"); 945 946 br_start = python + 8; 947 br_end = strchr(br_start, '/'); 948 assert(br_end); 949 950 /* Works even for trunk, 951 as we are in trunk/Python/sysmodule.c */ 952 br_end2 = strchr(br_end+1, '/'); 953 954 istag = strncmp(br_start, "tags", 4) == 0; 955 if (strncmp(br_start, "trunk", 5) == 0) { 956 strcpy(branch, "trunk"); 957 strcpy(shortbranch, "trunk"); 958 959 } 960 else if (istag || strncmp(br_start, "branches", 8) == 0) { 961 len = br_end2 - br_start; 962 strncpy(branch, br_start, len); 963 branch[len] = '\0'; 964 965 len = br_end2 - (br_end + 1); 966 strncpy(shortbranch, br_end + 1, len); 967 shortbranch[len] = '\0'; 968 } 969 else { 970 Py_FatalError("bad HeadURL"); 971 return; 972 } 973 974 975 svnversion = _Py_svnversion(); 976 if (strcmp(svnversion, "exported") != 0) 977 svn_revision = svnversion; 978 else if (istag) { 979 len = strlen(_patchlevel_revision); 980 assert(len >= 13); 981 assert(len < (sizeof(patchlevel_revision) + 13)); 982 strncpy(patchlevel_revision, _patchlevel_revision + 11, 983 len - 13); 984 patchlevel_revision[len - 13] = '\0'; 985 svn_revision = patchlevel_revision; 986 } 987 else 988 svn_revision = ""; 989 990 svn_initialized = 1; 991} 992 993/* Return svnversion output if available. 994 Else return Revision of patchlevel.h if on branch. 995 Else return empty string */ 996const char* 997Py_SubversionRevision() 998{ 999 svnversion_init(); 1000 return svn_revision; 1001} 1002 1003const char* 1004Py_SubversionShortBranch() 1005{ 1006 svnversion_init(); 1007 return shortbranch; 1008} 1009 1010PyObject * 1011_PySys_Init(void) 1012{ 1013 PyObject *m, *v, *sysdict; 1014 char *s; 1015 1016 m = Py_InitModule3("sys", sys_methods, sys_doc); 1017 if (m == NULL) 1018 return NULL; 1019 sysdict = PyModule_GetDict(m); 1020 1021 { 1022 /* XXX: does this work on Win/Win64? (see posix_fstat) */ 1023 struct stat sb; 1024 if (fstat(fileno(stdin), &sb) == 0 && 1025 S_ISDIR(sb.st_mode)) { 1026 /* There's nothing more we can do. */ 1027 /* Py_FatalError() will core dump, so just exit. */ 1028 PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n"); 1029 exit(EXIT_FAILURE); 1030 } 1031 } 1032 1033 /* stdin/stdout/stderr are now set by site.py. */ 1034 1035 PyDict_SetItemString(sysdict, "__displayhook__", 1036 PyDict_GetItemString(sysdict, "displayhook")); 1037 PyDict_SetItemString(sysdict, "__excepthook__", 1038 PyDict_GetItemString(sysdict, "excepthook")); 1039 PyDict_SetItemString(sysdict, "version", 1040 v = PyUnicode_FromString(Py_GetVersion())); 1041 Py_XDECREF(v); 1042 PyDict_SetItemString(sysdict, "hexversion", 1043 v = PyInt_FromLong(PY_VERSION_HEX)); 1044 Py_XDECREF(v); 1045 svnversion_init(); 1046 v = Py_BuildValue("(UUU)", "CPython", branch, svn_revision); 1047 PyDict_SetItemString(sysdict, "subversion", v); 1048 Py_XDECREF(v); 1049 /* 1050 * These release level checks are mutually exclusive and cover 1051 * the field, so don't get too fancy with the pre-processor! 1052 */ 1053#if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA 1054 s = "alpha"; 1055#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA 1056 s = "beta"; 1057#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA 1058 s = "candidate"; 1059#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL 1060 s = "final"; 1061#endif 1062 1063#define SET_SYS_FROM_STRING(key, value) \ 1064 v = value; \ 1065 if (v != NULL) \ 1066 PyDict_SetItemString(sysdict, key, v); \ 1067 Py_XDECREF(v) 1068 1069 SET_SYS_FROM_STRING("version_info", 1070 Py_BuildValue("iiiUi", PY_MAJOR_VERSION, 1071 PY_MINOR_VERSION, 1072 PY_MICRO_VERSION, s, 1073 PY_RELEASE_SERIAL)); 1074 SET_SYS_FROM_STRING("api_version", 1075 PyInt_FromLong(PYTHON_API_VERSION)); 1076 SET_SYS_FROM_STRING("copyright", 1077 PyUnicode_FromString(Py_GetCopyright())); 1078 SET_SYS_FROM_STRING("platform", 1079 PyUnicode_FromString(Py_GetPlatform())); 1080 SET_SYS_FROM_STRING("executable", 1081 PyString_FromString(Py_GetProgramFullPath())); 1082 SET_SYS_FROM_STRING("prefix", 1083 PyString_FromString(Py_GetPrefix())); 1084 SET_SYS_FROM_STRING("exec_prefix", 1085 PyString_FromString(Py_GetExecPrefix())); 1086 SET_SYS_FROM_STRING("maxint", 1087 PyInt_FromLong(PyInt_GetMax())); 1088 SET_SYS_FROM_STRING("maxunicode", 1089 PyInt_FromLong(PyUnicode_GetMax())); 1090 SET_SYS_FROM_STRING("builtin_module_names", 1091 list_builtin_module_names()); 1092 { 1093 /* Assumes that longs are at least 2 bytes long. 1094 Should be safe! */ 1095 unsigned long number = 1; 1096 char *value; 1097 1098 s = (char *) &number; 1099 if (s[0] == 0) 1100 value = "big"; 1101 else 1102 value = "little"; 1103 SET_SYS_FROM_STRING("byteorder", 1104 PyUnicode_FromString(value)); 1105 } 1106#ifdef MS_COREDLL 1107 SET_SYS_FROM_STRING("dllhandle", 1108 PyLong_FromVoidPtr(PyWin_DLLhModule)); 1109 SET_SYS_FROM_STRING("winver", 1110 PyUnicode_FromString(PyWin_DLLVersionString)); 1111#endif 1112#undef SET_SYS_FROM_STRING 1113 if (warnoptions == NULL) { 1114 warnoptions = PyList_New(0); 1115 } 1116 else { 1117 Py_INCREF(warnoptions); 1118 } 1119 if (warnoptions != NULL) { 1120 PyDict_SetItemString(sysdict, "warnoptions", warnoptions); 1121 } 1122 1123 if (PyErr_Occurred()) 1124 return NULL; 1125 return m; 1126} 1127 1128static PyObject * 1129makepathobject(char *path, int delim) 1130{ 1131 int i, n; 1132 char *p; 1133 PyObject *v, *w; 1134 1135 n = 1; 1136 p = path; 1137 while ((p = strchr(p, delim)) != NULL) { 1138 n++; 1139 p++; 1140 } 1141 v = PyList_New(n); 1142 if (v == NULL) 1143 return NULL; 1144 for (i = 0; ; i++) { 1145 p = strchr(path, delim); 1146 if (p == NULL) 1147 p = strchr(path, '\0'); /* End of string */ 1148 w = PyUnicode_FromStringAndSize(path, (Py_ssize_t) (p - path)); 1149 if (w == NULL) { 1150 Py_DECREF(v); 1151 return NULL; 1152 } 1153 PyList_SetItem(v, i, w); 1154 if (*p == '\0') 1155 break; 1156 path = p+1; 1157 } 1158 return v; 1159} 1160 1161void 1162PySys_SetPath(char *path) 1163{ 1164 PyObject *v; 1165 if ((v = makepathobject(path, DELIM)) == NULL) 1166 Py_FatalError("can't create sys.path"); 1167 if (PySys_SetObject("path", v) != 0) 1168 Py_FatalError("can't assign sys.path"); 1169 Py_DECREF(v); 1170} 1171 1172static PyObject * 1173makeargvobject(int argc, char **argv) 1174{ 1175 PyObject *av; 1176 if (argc <= 0 || argv == NULL) { 1177 /* Ensure at least one (empty) argument is seen */ 1178 static char *empty_argv[1] = {""}; 1179 argv = empty_argv; 1180 argc = 1; 1181 } 1182 av = PyList_New(argc); 1183 if (av != NULL) { 1184 int i; 1185 for (i = 0; i < argc; i++) { 1186#ifdef __VMS 1187 PyObject *v; 1188 1189 /* argv[0] is the script pathname if known */ 1190 if (i == 0) { 1191 char* fn = decc$translate_vms(argv[0]); 1192 if ((fn == (char *)0) || fn == (char *)-1) 1193 v = PyUnicode_FromString(argv[0]); 1194 else 1195 v = PyUnicode_FromString( 1196 decc$translate_vms(argv[0])); 1197 } else 1198 v = PyUnicode_FromString(argv[i]); 1199#else 1200 PyObject *v = PyUnicode_FromString(argv[i]); 1201#endif 1202 if (v == NULL) { 1203 Py_DECREF(av); 1204 av = NULL; 1205 break; 1206 } 1207 PyList_SetItem(av, i, v); 1208 } 1209 } 1210 return av; 1211} 1212 1213void 1214PySys_SetArgv(int argc, char **argv) 1215{ 1216#if defined(HAVE_REALPATH) 1217 char fullpath[MAXPATHLEN]; 1218#elif defined(MS_WINDOWS) 1219 char fullpath[MAX_PATH]; 1220#endif 1221 PyObject *av = makeargvobject(argc, argv); 1222 PyObject *path = PySys_GetObject("path"); 1223 if (av == NULL) 1224 Py_FatalError("no mem for sys.argv"); 1225 if (PySys_SetObject("argv", av) != 0) 1226 Py_FatalError("can't assign sys.argv"); 1227 if (path != NULL) { 1228 char *argv0 = argv[0]; 1229 char *p = NULL; 1230 Py_ssize_t n = 0; 1231 PyObject *a; 1232#ifdef HAVE_READLINK 1233 char link[MAXPATHLEN+1]; 1234 char argv0copy[2*MAXPATHLEN+1]; 1235 int nr = 0; 1236 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) 1237 nr = readlink(argv0, link, MAXPATHLEN); 1238 if (nr > 0) { 1239 /* It's a symlink */ 1240 link[nr] = '\0'; 1241 if (link[0] == SEP) 1242 argv0 = link; /* Link to absolute path */ 1243 else if (strchr(link, SEP) == NULL) 1244 ; /* Link without path */ 1245 else { 1246 /* Must join(dirname(argv0), link) */ 1247 char *q = strrchr(argv0, SEP); 1248 if (q == NULL) 1249 argv0 = link; /* argv0 without path */ 1250 else { 1251 /* Must make a copy */ 1252 strcpy(argv0copy, argv0); 1253 q = strrchr(argv0copy, SEP); 1254 strcpy(q+1, link); 1255 argv0 = argv0copy; 1256 } 1257 } 1258 } 1259#endif /* HAVE_READLINK */ 1260#if SEP == '\\' /* Special case for MS filename syntax */ 1261 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) { 1262 char *q; 1263#ifdef MS_WINDOWS 1264 char *ptemp; 1265 if (GetFullPathName(argv0, 1266 sizeof(fullpath), 1267 fullpath, 1268 &ptemp)) { 1269 argv0 = fullpath; 1270 } 1271#endif 1272 p = strrchr(argv0, SEP); 1273 /* Test for alternate separator */ 1274 q = strrchr(p ? p : argv0, '/'); 1275 if (q != NULL) 1276 p = q; 1277 if (p != NULL) { 1278 n = p + 1 - argv0; 1279 if (n > 1 && p[-1] != ':') 1280 n--; /* Drop trailing separator */ 1281 } 1282 } 1283#else /* All other filename syntaxes */ 1284 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) { 1285#if defined(HAVE_REALPATH) 1286 if (realpath(argv0, fullpath)) { 1287 argv0 = fullpath; 1288 } 1289#endif 1290 p = strrchr(argv0, SEP); 1291 } 1292 if (p != NULL) { 1293 n = p + 1 - argv0; 1294#if SEP == '/' /* Special case for Unix filename syntax */ 1295 if (n > 1) 1296 n--; /* Drop trailing separator */ 1297#endif /* Unix */ 1298 } 1299#endif /* All others */ 1300 a = PyUnicode_FromStringAndSize(argv0, n); 1301 if (a == NULL) 1302 Py_FatalError("no mem for sys.path insertion"); 1303 if (PyList_Insert(path, 0, a) < 0) 1304 Py_FatalError("sys.path.insert(0) failed"); 1305 Py_DECREF(a); 1306 } 1307 Py_DECREF(av); 1308} 1309 1310 1311/* APIs to write to sys.stdout or sys.stderr using a printf-like interface. 1312 Adapted from code submitted by Just van Rossum. 1313 1314 PySys_WriteStdout(format, ...) 1315 PySys_WriteStderr(format, ...) 1316 1317 The first function writes to sys.stdout; the second to sys.stderr. When 1318 there is a problem, they write to the real (C level) stdout or stderr; 1319 no exceptions are raised. 1320 1321 Both take a printf-style format string as their first argument followed 1322 by a variable length argument list determined by the format string. 1323 1324 *** WARNING *** 1325 1326 The format should limit the total size of the formatted output string to 1327 1000 bytes. In particular, this means that no unrestricted "%s" formats 1328 should occur; these should be limited using "%.<N>s where <N> is a 1329 decimal number calculated so that <N> plus the maximum size of other 1330 formatted text does not exceed 1000 bytes. Also watch out for "%f", 1331 which can print hundreds of digits for very large numbers. 1332 1333 */ 1334 1335static void 1336mywrite(char *name, FILE *fp, const char *format, va_list va) 1337{ 1338 PyObject *file; 1339 PyObject *error_type, *error_value, *error_traceback; 1340 char buffer[1001]; 1341 int written; 1342 1343 PyErr_Fetch(&error_type, &error_value, &error_traceback); 1344 file = PySys_GetObject(name); 1345 written = PyOS_vsnprintf(buffer, sizeof(buffer), format, va); 1346 if (PyFile_WriteString(buffer, file) != 0) { 1347 PyErr_Clear(); 1348 fputs(buffer, fp); 1349 } 1350 if (written < 0 || (size_t)written >= sizeof(buffer)) { 1351 const char *truncated = "... truncated"; 1352 if (PyFile_WriteString(truncated, file) != 0) { 1353 PyErr_Clear(); 1354 fputs(truncated, fp); 1355 } 1356 } 1357 PyErr_Restore(error_type, error_value, error_traceback); 1358} 1359 1360void 1361PySys_WriteStdout(const char *format, ...) 1362{ 1363 va_list va; 1364 1365 va_start(va, format); 1366 mywrite("stdout", stdout, format, va); 1367 va_end(va); 1368} 1369 1370void 1371PySys_WriteStderr(const char *format, ...) 1372{ 1373 va_list va; 1374 1375 va_start(va, format); 1376 mywrite("stderr", stderr, format, va); 1377 va_end(va); 1378} 1379