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