Changeset 388 for python/vendor/current/Python/sysmodule.c
- Timestamp:
- Mar 19, 2014, 11:11:30 AM (11 years ago)
- File:
-
- 1 edited
-
python/vendor/current/Python/sysmodule.c (modified) (57 diffs)
Legend:
- Unmodified
- Added
- Removed
-
python/vendor/current/Python/sysmodule.c
r2 r388 50 50 PySys_GetObject(char *name) 51 51 { 52 53 54 55 56 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 57 } 58 58 … … 60 60 PySys_GetFile(char *name, FILE *def) 61 61 { 62 63 64 65 66 67 68 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 69 } 70 70 … … 72 72 PySys_SetObject(char *name, PyObject *v) 73 73 { 74 75 76 77 78 79 80 81 82 83 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 84 } 85 85 … … 87 87 sys_displayhook(PyObject *self, PyObject *o) 88 88 { 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 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 124 } 125 125 … … 127 127 "displayhook(object) -> None\n" 128 128 "\n" 129 "Print an object to sys.stdout and also save it in __builtin__. \n"129 "Print an object to sys.stdout and also save it in __builtin__._\n" 130 130 ); 131 131 … … 133 133 sys_excepthook(PyObject* self, PyObject* args) 134 134 { 135 136 137 138 139 140 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 141 } 142 142 … … 150 150 sys_exc_info(PyObject *self, PyObject *noargs) 151 151 { 152 153 154 155 156 157 158 159 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 160 } 161 161 … … 170 170 sys_exc_clear(PyObject *self, PyObject *noargs) 171 171 { 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 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 195 } 196 196 … … 207 207 sys_exit(PyObject *self, PyObject *args) 208 208 { 209 210 211 212 213 214 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 215 } 216 216 … … 220 220 Exit the interpreter by raising SystemExit(status).\n\ 221 221 If the status is omitted or None, it defaults to zero (i.e., success).\n\ 222 If the status is numeric, it will be used as the system exit status.\n\222 If the status is an integer, it will be used as the system exit status.\n\ 223 223 If it is another kind of object, it will be printed and the system\n\ 224 224 exit status will be one (i.e., failure)." … … 230 230 sys_getdefaultencoding(PyObject *self) 231 231 { 232 232 return PyString_FromString(PyUnicode_GetDefaultEncoding()); 233 233 } 234 234 … … 243 243 sys_setdefaultencoding(PyObject *self, PyObject *args) 244 244 { 245 246 247 248 249 250 251 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 252 } 253 253 … … 261 261 sys_getfilesystemencoding(PyObject *self) 262 262 { 263 264 265 266 263 if (Py_FileSystemDefaultEncoding) 264 return PyString_FromString(Py_FileSystemDefaultEncoding); 265 Py_INCREF(Py_None); 266 return Py_None; 267 267 } 268 268 … … 285 285 trace_init(void) 286 286 { 287 288 289 290 291 292 293 294 295 296 297 298 299 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 300 } 301 301 … … 303 303 static PyObject * 304 304 call_trampoline(PyThreadState *tstate, PyObject* callback, 305 306 { 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 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 333 } 334 334 335 335 static int 336 336 profile_trampoline(PyObject *self, PyFrameObject *frame, 337 338 { 339 340 341 342 343 344 345 346 347 348 349 350 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 351 } 352 352 353 353 static int 354 354 trace_trampoline(PyObject *self, PyFrameObject *frame, 355 356 { 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 355 int what, PyObject *arg) 356 { 357 PyThreadState *tstate = frame->f_tstate; 358 PyObject *callback; 359 PyObject *result; 360 361 if (what == PyTrace_CALL) 362 callback = self; 363 else 364 callback = frame->f_trace; 365 if (callback == NULL) 366 return 0; 367 result = call_trampoline(tstate, callback, frame, what, arg); 368 if (result == NULL) { 369 PyEval_SetTrace(NULL, NULL); 370 Py_XDECREF(frame->f_trace); 371 frame->f_trace = NULL; 372 return -1; 373 } 374 if (result != Py_None) { 375 PyObject *temp = frame->f_trace; 376 frame->f_trace = NULL; 377 Py_XDECREF(temp); 378 frame->f_trace = result; 379 } 380 else { 381 Py_DECREF(result); 382 } 383 return 0; 384 384 } 385 385 … … 387 387 sys_settrace(PyObject *self, PyObject *args) 388 388 { 389 390 391 392 393 394 395 396 389 if (trace_init() == -1) 390 return NULL; 391 if (args == Py_None) 392 PyEval_SetTrace(NULL, NULL); 393 else 394 PyEval_SetTrace(trace_trampoline, args); 395 Py_INCREF(Py_None); 396 return Py_None; 397 397 } 398 398 … … 407 407 sys_gettrace(PyObject *self, PyObject *args) 408 408 { 409 410 411 412 413 414 415 409 PyThreadState *tstate = PyThreadState_GET(); 410 PyObject *temp = tstate->c_traceobj; 411 412 if (temp == NULL) 413 temp = Py_None; 414 Py_INCREF(temp); 415 return temp; 416 416 } 417 417 … … 426 426 sys_setprofile(PyObject *self, PyObject *args) 427 427 { 428 429 430 431 432 433 434 435 428 if (trace_init() == -1) 429 return NULL; 430 if (args == Py_None) 431 PyEval_SetProfile(NULL, NULL); 432 else 433 PyEval_SetProfile(profile_trampoline, args); 434 Py_INCREF(Py_None); 435 return Py_None; 436 436 } 437 437 … … 446 446 sys_getprofile(PyObject *self, PyObject *args) 447 447 { 448 449 450 451 452 453 454 448 PyThreadState *tstate = PyThreadState_GET(); 449 PyObject *temp = tstate->c_profileobj; 450 451 if (temp == NULL) 452 temp = Py_None; 453 Py_INCREF(temp); 454 return temp; 455 455 } 456 456 … … 465 465 sys_setcheckinterval(PyObject *self, PyObject *args) 466 466 { 467 if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval)) 468 return NULL; 469 Py_INCREF(Py_None); 470 return Py_None; 467 if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval)) 468 return NULL; 469 _Py_Ticker = _Py_CheckInterval; 470 Py_INCREF(Py_None); 471 return Py_None; 471 472 } 472 473 … … 481 482 sys_getcheckinterval(PyObject *self, PyObject *args) 482 483 { 483 484 return PyInt_FromLong(_Py_CheckInterval); 484 485 } 485 486 … … 492 493 sys_settscdump(PyObject *self, PyObject *args) 493 494 { 494 495 496 497 498 499 500 501 502 503 504 495 int bool; 496 PyThreadState *tstate = PyThreadState_Get(); 497 498 if (!PyArg_ParseTuple(args, "i:settscdump", &bool)) 499 return NULL; 500 if (bool) 501 tstate->interp->tscdump = 1; 502 else 503 tstate->interp->tscdump = 0; 504 Py_INCREF(Py_None); 505 return Py_None; 505 506 506 507 } … … 518 519 sys_setrecursionlimit(PyObject *self, PyObject *args) 519 520 { 520 521 522 523 524 525 526 527 528 529 530 521 int new_limit; 522 if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit)) 523 return NULL; 524 if (new_limit <= 0) { 525 PyErr_SetString(PyExc_ValueError, 526 "recursion limit must be positive"); 527 return NULL; 528 } 529 Py_SetRecursionLimit(new_limit); 530 Py_INCREF(Py_None); 531 return Py_None; 531 532 } 532 533 … … 543 544 sys_getrecursionlimit(PyObject *self) 544 545 { 545 546 return PyInt_FromLong(Py_GetRecursionLimit()); 546 547 } 547 548 … … 558 559 "getwindowsversion()\n\ 559 560 \n\ 560 Return information about the running version of Windows.\n\ 561 The result is a tuple of (major, minor, build, platform, text)\n\ 562 All elements are numbers, except text which is a string.\n\ 563 Platform may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP\n\ 564 " 565 ); 561 Return information about the running version of Windows as a named tuple.\n\ 562 The members are named: major, minor, build, platform, service_pack,\n\ 563 service_pack_major, service_pack_minor, suite_mask, and product_type. For\n\ 564 backward compatibility, only the first 5 items are available by indexing.\n\ 565 All elements are numbers, except service_pack which is a string. Platform\n\ 566 may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP/Vista/7,\n\ 567 3 for Windows CE. Product_type may be 1 for a workstation, 2 for a domain\n\ 568 controller, 3 for a server." 569 ); 570 571 static PyTypeObject WindowsVersionType = {0, 0, 0, 0, 0, 0}; 572 573 static PyStructSequence_Field windows_version_fields[] = { 574 {"major", "Major version number"}, 575 {"minor", "Minor version number"}, 576 {"build", "Build number"}, 577 {"platform", "Operating system platform"}, 578 {"service_pack", "Latest Service Pack installed on the system"}, 579 {"service_pack_major", "Service Pack major version number"}, 580 {"service_pack_minor", "Service Pack minor version number"}, 581 {"suite_mask", "Bit mask identifying available product suites"}, 582 {"product_type", "System product type"}, 583 {0} 584 }; 585 586 static PyStructSequence_Desc windows_version_desc = { 587 "sys.getwindowsversion", /* name */ 588 getwindowsversion_doc, /* doc */ 589 windows_version_fields, /* fields */ 590 5 /* For backward compatibility, 591 only the first 5 items are accessible 592 via indexing, the rest are name only */ 593 }; 566 594 567 595 static PyObject * 568 596 sys_getwindowsversion(PyObject *self) 569 597 { 570 OSVERSIONINFO ver; 571 ver.dwOSVersionInfoSize = sizeof(ver); 572 if (!GetVersionEx(&ver)) 573 return PyErr_SetFromWindowsErr(0); 574 return Py_BuildValue("HHHHs", 575 ver.dwMajorVersion, 576 ver.dwMinorVersion, 577 ver.dwBuildNumber, 578 ver.dwPlatformId, 579 ver.szCSDVersion); 598 PyObject *version; 599 int pos = 0; 600 OSVERSIONINFOEX ver; 601 ver.dwOSVersionInfoSize = sizeof(ver); 602 if (!GetVersionEx((OSVERSIONINFO*) &ver)) 603 return PyErr_SetFromWindowsErr(0); 604 605 version = PyStructSequence_New(&WindowsVersionType); 606 if (version == NULL) 607 return NULL; 608 609 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMajorVersion)); 610 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMinorVersion)); 611 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwBuildNumber)); 612 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwPlatformId)); 613 PyStructSequence_SET_ITEM(version, pos++, PyString_FromString(ver.szCSDVersion)); 614 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMajor)); 615 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMinor)); 616 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wSuiteMask)); 617 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wProductType)); 618 619 return version; 580 620 } 581 621 … … 586 626 sys_setdlopenflags(PyObject *self, PyObject *args) 587 627 { 588 589 590 591 592 593 594 595 596 628 int new_val; 629 PyThreadState *tstate = PyThreadState_GET(); 630 if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val)) 631 return NULL; 632 if (!tstate) 633 return NULL; 634 tstate->interp->dlopenflags = new_val; 635 Py_INCREF(Py_None); 636 return Py_None; 597 637 } 598 638 … … 600 640 "setdlopenflags(n) -> None\n\ 601 641 \n\ 602 Set the flags that will be used for dlopen() calls. Among other\n\ 603 things, this will enable a lazy resolving of symbols when importing\n\ 604 a module, if called as sys.setdlopenflags(0)\n\ 605 To share symbols across extension modules, call as\n\ 606 sys.setdlopenflags(dl.RTLD_NOW|dl.RTLD_GLOBAL)" 607 ); 642 Set the flags used by the interpreter for dlopen calls, such as when the\n\ 643 interpreter loads extension modules. Among other things, this will enable\n\ 644 a lazy resolving of symbols when importing a module, if called as\n\ 645 sys.setdlopenflags(0). To share symbols across extension modules, call as\n\ 646 sys.setdlopenflags(ctypes.RTLD_GLOBAL). Symbolic names for the flag modules\n\ 647 can be either found in the ctypes module, or in the DLFCN module. If DLFCN\n\ 648 is not available, it can be generated from /usr/include/dlfcn.h using the\n\ 649 h2py script."); 608 650 609 651 static PyObject * 610 652 sys_getdlopenflags(PyObject *self, PyObject *args) 611 653 { 612 613 614 615 654 PyThreadState *tstate = PyThreadState_GET(); 655 if (!tstate) 656 return NULL; 657 return PyInt_FromLong(tstate->interp->dlopenflags); 616 658 } 617 659 … … 619 661 "getdlopenflags() -> int\n\ 620 662 \n\ 621 Return the current value of the flags that are used for dlopen ()\n\622 calls. The flag constants are defined in the dl module." 623 ); 624 #endif 663 Return the current value of the flags that are used for dlopen calls.\n\ 664 The flag constants are defined in the ctypes and DLFCN modules."); 665 666 #endif /* HAVE_DLOPEN */ 625 667 626 668 #ifdef USE_MALLOPT … … 631 673 sys_mdebug(PyObject *self, PyObject *args) 632 674 { 633 634 635 636 637 638 675 int flag; 676 if (!PyArg_ParseTuple(args, "i:mdebug", &flag)) 677 return NULL; 678 mallopt(M_DEBUG, flag); 679 Py_INCREF(Py_None); 680 return Py_None; 639 681 } 640 682 #endif /* USE_MALLOPT */ … … 643 685 sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds) 644 686 { 645 PyObject *res = NULL; 646 static PyObject *str__sizeof__, *gc_head_size = NULL; 647 static char *kwlist[] = {"object", "default", 0}; 648 PyObject *o, *dflt = NULL; 649 650 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof", 651 kwlist, &o, &dflt)) 652 return NULL; 653 654 /* Initialize static variable needed by _PyType_Lookup */ 655 if (str__sizeof__ == NULL) { 656 str__sizeof__ = PyString_InternFromString("__sizeof__"); 657 if (str__sizeof__ == NULL) 658 return NULL; 659 } 660 661 /* Initialize static variable for GC head size */ 662 if (gc_head_size == NULL) { 663 gc_head_size = PyInt_FromSsize_t(sizeof(PyGC_Head)); 664 if (gc_head_size == NULL) 665 return NULL; 666 } 667 668 /* Make sure the type is initialized. float gets initialized late */ 669 if (PyType_Ready(Py_TYPE(o)) < 0) 670 return NULL; 671 672 /* Instance of old-style class */ 673 if (PyInstance_Check(o)) 674 res = PyInt_FromSsize_t(PyInstance_Type.tp_basicsize); 675 /* all other objects */ 676 else { 677 PyObject *method = _PyType_Lookup(Py_TYPE(o), 678 str__sizeof__); 679 if (method == NULL) 680 PyErr_Format(PyExc_TypeError, 681 "Type %.100s doesn't define __sizeof__", 682 Py_TYPE(o)->tp_name); 683 else 684 res = PyObject_CallFunctionObjArgs(method, o, NULL); 685 } 686 687 /* Has a default value been given? */ 688 if ((res == NULL) && (dflt != NULL) && 689 PyErr_ExceptionMatches(PyExc_TypeError)) 690 { 691 PyErr_Clear(); 692 Py_INCREF(dflt); 693 return dflt; 694 } 695 else if (res == NULL) 696 return res; 697 698 /* add gc_head size */ 699 if (PyObject_IS_GC(o)) { 700 PyObject *tmp = res; 701 res = PyNumber_Add(tmp, gc_head_size); 702 Py_DECREF(tmp); 703 } 704 return res; 687 PyObject *res = NULL; 688 static PyObject *str__sizeof__ = NULL, *gc_head_size = NULL; 689 static char *kwlist[] = {"object", "default", 0}; 690 PyObject *o, *dflt = NULL; 691 692 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof", 693 kwlist, &o, &dflt)) 694 return NULL; 695 696 /* Initialize static variable for GC head size */ 697 if (gc_head_size == NULL) { 698 gc_head_size = PyInt_FromSsize_t(sizeof(PyGC_Head)); 699 if (gc_head_size == NULL) 700 return NULL; 701 } 702 703 /* Make sure the type is initialized. float gets initialized late */ 704 if (PyType_Ready(Py_TYPE(o)) < 0) 705 return NULL; 706 707 /* Instance of old-style class */ 708 if (PyInstance_Check(o)) 709 res = PyInt_FromSsize_t(PyInstance_Type.tp_basicsize); 710 /* all other objects */ 711 else { 712 PyObject *method = _PyObject_LookupSpecial(o, "__sizeof__", 713 &str__sizeof__); 714 if (method == NULL) { 715 if (!PyErr_Occurred()) 716 PyErr_Format(PyExc_TypeError, 717 "Type %.100s doesn't define __sizeof__", 718 Py_TYPE(o)->tp_name); 719 } 720 else { 721 res = PyObject_CallFunctionObjArgs(method, NULL); 722 Py_DECREF(method); 723 } 724 } 725 726 /* Has a default value been given? */ 727 if ((res == NULL) && (dflt != NULL) && 728 PyErr_ExceptionMatches(PyExc_TypeError)) 729 { 730 PyErr_Clear(); 731 Py_INCREF(dflt); 732 return dflt; 733 } 734 else if (res == NULL) 735 return res; 736 737 /* add gc_head size */ 738 if (PyObject_IS_GC(o)) { 739 PyObject *tmp = res; 740 res = PyNumber_Add(tmp, gc_head_size); 741 Py_DECREF(tmp); 742 } 743 return res; 705 744 } 706 745 … … 713 752 sys_getrefcount(PyObject *self, PyObject *arg) 714 753 { 715 754 return PyInt_FromSsize_t(arg->ob_refcnt); 716 755 } 717 756 … … 720 759 sys_gettotalrefcount(PyObject *self) 721 760 { 722 761 return PyInt_FromSsize_t(_Py_GetRefTotal()); 723 762 } 724 763 #endif /* Py_REF_DEBUG */ … … 736 775 sys_getcounts(PyObject *self) 737 776 { 738 739 740 777 extern PyObject *get_counts(void); 778 779 return get_counts(); 741 780 } 742 781 #endif … … 757 796 sys_getframe(PyObject *self, PyObject *args) 758 797 { 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 798 PyFrameObject *f = PyThreadState_GET()->frame; 799 int depth = -1; 800 801 if (!PyArg_ParseTuple(args, "|i:_getframe", &depth)) 802 return NULL; 803 804 while (depth > 0 && f != NULL) { 805 f = f->f_back; 806 --depth; 807 } 808 if (f == NULL) { 809 PyErr_SetString(PyExc_ValueError, 810 "call stack is not deep enough"); 811 return NULL; 812 } 813 Py_INCREF(f); 814 return (PyObject*)f; 776 815 } 777 816 … … 788 827 sys_current_frames(PyObject *self, PyObject *noargs) 789 828 { 790 829 return _PyThread_CurrentFrames(); 791 830 } 792 831 … … 802 841 sys_call_tracing(PyObject *self, PyObject *args) 803 842 { 804 805 806 807 843 PyObject *func, *funcargs; 844 if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs)) 845 return NULL; 846 return _PyEval_CallTracing(func, funcargs); 808 847 } 809 848 … … 852 891 sys_clear_type_cache(PyObject* self, PyObject* args) 853 892 { 854 855 893 PyType_ClearCache(); 894 Py_RETURN_NONE; 856 895 } 857 896 … … 862 901 863 902 static PyMethodDef sys_methods[] = { 864 865 866 867 {"_clear_type_cache", sys_clear_type_cache,METH_NOARGS,868 869 870 871 {"displayhook",sys_displayhook, METH_O, displayhook_doc},872 {"exc_info",sys_exc_info, METH_NOARGS, exc_info_doc},873 {"exc_clear",sys_exc_clear, METH_NOARGS, exc_clear_doc},874 {"excepthook",sys_excepthook, METH_VARARGS, excepthook_doc},875 {"exit",sys_exit, METH_VARARGS, exit_doc},903 /* Might as well keep this in alphabetic order */ 904 {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS, 905 callstats_doc}, 906 {"_clear_type_cache", sys_clear_type_cache, METH_NOARGS, 907 sys_clear_type_cache__doc__}, 908 {"_current_frames", sys_current_frames, METH_NOARGS, 909 current_frames_doc}, 910 {"displayhook", sys_displayhook, METH_O, displayhook_doc}, 911 {"exc_info", sys_exc_info, METH_NOARGS, exc_info_doc}, 912 {"exc_clear", sys_exc_clear, METH_NOARGS, exc_clear_doc}, 913 {"excepthook", sys_excepthook, METH_VARARGS, excepthook_doc}, 914 {"exit", sys_exit, METH_VARARGS, exit_doc}, 876 915 #ifdef Py_USING_UNICODE 877 878 916 {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding, 917 METH_NOARGS, getdefaultencoding_doc}, 879 918 #endif 880 919 #ifdef HAVE_DLOPEN 881 882 920 {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS, 921 getdlopenflags_doc}, 883 922 #endif 884 923 #ifdef COUNT_ALLOCS 885 {"getcounts",(PyCFunction)sys_getcounts, METH_NOARGS},924 {"getcounts", (PyCFunction)sys_getcounts, METH_NOARGS}, 886 925 #endif 887 926 #ifdef DYNAMIC_EXECUTION_PROFILE 888 {"getdxp",_Py_GetDXProfile, METH_VARARGS},927 {"getdxp", _Py_GetDXProfile, METH_VARARGS}, 889 928 #endif 890 929 #ifdef Py_USING_UNICODE 891 892 930 {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding, 931 METH_NOARGS, getfilesystemencoding_doc}, 893 932 #endif 894 933 #ifdef Py_TRACE_REFS 895 {"getobjects",_Py_GetObjects, METH_VARARGS},934 {"getobjects", _Py_GetObjects, METH_VARARGS}, 896 935 #endif 897 936 #ifdef Py_REF_DEBUG 898 899 #endif 900 {"getrefcount",(PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},901 902 903 904 905 937 {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS}, 938 #endif 939 {"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc}, 940 {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS, 941 getrecursionlimit_doc}, 942 {"getsizeof", (PyCFunction)sys_getsizeof, 943 METH_VARARGS | METH_KEYWORDS, getsizeof_doc}, 944 {"_getframe", sys_getframe, METH_VARARGS, getframe_doc}, 906 945 #ifdef MS_WINDOWS 907 908 946 {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS, 947 getwindowsversion_doc}, 909 948 #endif /* MS_WINDOWS */ 910 949 #ifdef USE_MALLOPT 911 {"mdebug",sys_mdebug, METH_VARARGS},950 {"mdebug", sys_mdebug, METH_VARARGS}, 912 951 #endif 913 952 #ifdef Py_USING_UNICODE 914 915 916 #endif 917 {"setcheckinterval",sys_setcheckinterval, METH_VARARGS,918 919 {"getcheckinterval",sys_getcheckinterval, METH_NOARGS,920 953 {"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS, 954 setdefaultencoding_doc}, 955 #endif 956 {"setcheckinterval", sys_setcheckinterval, METH_VARARGS, 957 setcheckinterval_doc}, 958 {"getcheckinterval", sys_getcheckinterval, METH_NOARGS, 959 getcheckinterval_doc}, 921 960 #ifdef HAVE_DLOPEN 922 923 924 #endif 925 {"setprofile",sys_setprofile, METH_O, setprofile_doc},926 {"getprofile",sys_getprofile, METH_NOARGS, getprofile_doc},927 928 961 {"setdlopenflags", sys_setdlopenflags, METH_VARARGS, 962 setdlopenflags_doc}, 963 #endif 964 {"setprofile", sys_setprofile, METH_O, setprofile_doc}, 965 {"getprofile", sys_getprofile, METH_NOARGS, getprofile_doc}, 966 {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS, 967 setrecursionlimit_doc}, 929 968 #ifdef WITH_TSC 930 931 #endif 932 {"settrace",sys_settrace, METH_O, settrace_doc},933 {"gettrace",sys_gettrace, METH_NOARGS, gettrace_doc},934 935 {NULL, NULL}/* sentinel */969 {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc}, 970 #endif 971 {"settrace", sys_settrace, METH_O, settrace_doc}, 972 {"gettrace", sys_gettrace, METH_NOARGS, gettrace_doc}, 973 {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc}, 974 {NULL, NULL} /* sentinel */ 936 975 }; 937 976 … … 939 978 list_builtin_module_names(void) 940 979 { 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 980 PyObject *list = PyList_New(0); 981 int i; 982 if (list == NULL) 983 return NULL; 984 for (i = 0; PyImport_Inittab[i].name != NULL; i++) { 985 PyObject *name = PyString_FromString( 986 PyImport_Inittab[i].name); 987 if (name == NULL) 988 break; 989 PyList_Append(list, name); 990 Py_DECREF(name); 991 } 992 if (PyList_Sort(list) != 0) { 993 Py_DECREF(list); 994 list = NULL; 995 } 996 if (list) { 997 PyObject *v = PyList_AsTuple(list); 998 Py_DECREF(list); 999 list = v; 1000 } 1001 return list; 963 1002 } 964 1003 … … 968 1007 PySys_ResetWarnOptions(void) 969 1008 { 970 971 972 1009 if (warnoptions == NULL || !PyList_Check(warnoptions)) 1010 return; 1011 PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL); 973 1012 } 974 1013 … … 976 1015 PySys_AddWarnOption(char *s) 977 1016 { 978 979 980 981 982 983 984 985 986 987 988 989 990 1017 PyObject *str; 1018 1019 if (warnoptions == NULL || !PyList_Check(warnoptions)) { 1020 Py_XDECREF(warnoptions); 1021 warnoptions = PyList_New(0); 1022 if (warnoptions == NULL) 1023 return; 1024 } 1025 str = PyString_FromString(s); 1026 if (str != NULL) { 1027 PyList_Append(warnoptions, str); 1028 Py_DECREF(str); 1029 } 991 1030 } 992 1031 … … 1044 1083 Static objects:\n\ 1045 1084 \n\ 1085 float_info -- a dict with information about the float inplementation.\n\ 1086 long_info -- a struct sequence with information about the long implementation.\n\ 1046 1087 maxint -- the largest supported integer (the smallest is -maxint-1)\n\ 1047 1088 maxsize -- the largest supported length of containers.\n\ … … 1049 1090 builtin_module_names -- tuple of module names built into this interpreter\n\ 1050 1091 version -- the version of this interpreter as a string\n\ 1051 version_info -- version information as a tuple\n\1092 version_info -- version information as a named tuple\n\ 1052 1093 hexversion -- version information encoded as a single integer\n\ 1053 1094 copyright -- copyright notice pertaining to this interpreter\n\ 1054 1095 platform -- platform identifier\n\ 1055 executable -- pathname of thisPython interpreter\n\1096 executable -- absolute path of the executable binary of the Python interpreter\n\ 1056 1097 prefix -- prefix used to find the Python library\n\ 1057 1098 exec_prefix -- prefix used to find the machine-specific Python library\n\ 1099 float_repr_style -- string indicating the style of repr() output for floats\n\ 1058 1100 " 1059 1101 ) … … 1103 1145 1104 1146 /* Subversion branch and revision management */ 1105 static const char _patchlevel_revision[] = PY_PATCHLEVEL_REVISION;1106 static const char headurl[] = "$HeadURL: http://svn.python.org/projects/python/tags/r265/Python/sysmodule.c $";1107 1147 static int svn_initialized; 1108 1148 static char patchlevel_revision[50]; /* Just the number */ … … 1114 1154 svnversion_init(void) 1115 1155 { 1116 const char *python, *br_start, *br_end, *br_end2, *svnversion; 1117 Py_ssize_t len; 1118 int istag; 1119 1120 if (svn_initialized) 1121 return; 1122 1123 python = strstr(headurl, "/python/"); 1124 if (!python) { 1125 /* XXX quick hack to get bzr working */ 1126 *patchlevel_revision = '\0'; 1127 strcpy(branch, ""); 1128 strcpy(shortbranch, "unknown"); 1129 svn_revision = ""; 1130 return; 1131 /* Py_FatalError("subversion keywords missing"); */ 1132 } 1133 1134 br_start = python + 8; 1135 br_end = strchr(br_start, '/'); 1136 assert(br_end); 1137 1138 /* Works even for trunk, 1139 as we are in trunk/Python/sysmodule.c */ 1140 br_end2 = strchr(br_end+1, '/'); 1141 1142 istag = strncmp(br_start, "tags", 4) == 0; 1143 if (strncmp(br_start, "trunk", 5) == 0) { 1144 strcpy(branch, "trunk"); 1145 strcpy(shortbranch, "trunk"); 1146 1147 } 1148 else if (istag || strncmp(br_start, "branches", 8) == 0) { 1149 len = br_end2 - br_start; 1150 strncpy(branch, br_start, len); 1151 branch[len] = '\0'; 1152 1153 len = br_end2 - (br_end + 1); 1154 strncpy(shortbranch, br_end + 1, len); 1155 shortbranch[len] = '\0'; 1156 } 1157 else { 1158 Py_FatalError("bad HeadURL"); 1159 return; 1160 } 1161 1162 1163 svnversion = _Py_svnversion(); 1164 if (strcmp(svnversion, "Unversioned directory") != 0 && strcmp(svnversion, "exported") != 0) 1165 svn_revision = svnversion; 1166 else if (istag) { 1167 len = strlen(_patchlevel_revision); 1168 assert(len >= 13); 1169 assert(len < (sizeof(patchlevel_revision) + 13)); 1170 strncpy(patchlevel_revision, _patchlevel_revision + 11, 1171 len - 13); 1172 patchlevel_revision[len - 13] = '\0'; 1173 svn_revision = patchlevel_revision; 1174 } 1175 else 1176 svn_revision = ""; 1177 1178 svn_initialized = 1; 1156 if (svn_initialized) 1157 return; 1158 svn_initialized = 1; 1159 *patchlevel_revision = '\0'; 1160 strcpy(branch, ""); 1161 strcpy(shortbranch, "unknown"); 1162 svn_revision = ""; 1163 return; 1179 1164 } 1180 1165 … … 1185 1170 Py_SubversionRevision() 1186 1171 { 1187 1188 1172 svnversion_init(); 1173 return svn_revision; 1189 1174 } 1190 1175 … … 1192 1177 Py_SubversionShortBranch() 1193 1178 { 1194 1195 1179 svnversion_init(); 1180 return shortbranch; 1196 1181 } 1197 1182 … … 1205 1190 1206 1191 static PyStructSequence_Field flags_fields[] = { 1207 {"debug","-d"},1208 {"py3k_warning","-3"},1209 {"division_warning","-Q"},1210 {"division_new","-Qnew"},1211 {"inspect","-i"},1212 {"interactive","-i"},1213 {"optimize","-O or -OO"},1214 {"dont_write_bytecode","-B"},1215 {"no_user_site","-s"},1216 {"no_site","-S"},1217 {"ignore_environment","-E"},1218 {"tabcheck","-t or -tt"},1219 {"verbose","-v"},1192 {"debug", "-d"}, 1193 {"py3k_warning", "-3"}, 1194 {"division_warning", "-Q"}, 1195 {"division_new", "-Qnew"}, 1196 {"inspect", "-i"}, 1197 {"interactive", "-i"}, 1198 {"optimize", "-O or -OO"}, 1199 {"dont_write_bytecode", "-B"}, 1200 {"no_user_site", "-s"}, 1201 {"no_site", "-S"}, 1202 {"ignore_environment", "-E"}, 1203 {"tabcheck", "-t or -tt"}, 1204 {"verbose", "-v"}, 1220 1205 #ifdef RISCOS 1221 {"riscos_wimp", "???"}, 1222 #endif 1223 /* {"unbuffered", "-u"}, */ 1224 {"unicode", "-U"}, 1225 /* {"skip_first", "-x"}, */ 1226 {"bytes_warning", "-b"}, 1227 {0} 1206 {"riscos_wimp", "???"}, 1207 #endif 1208 /* {"unbuffered", "-u"}, */ 1209 {"unicode", "-U"}, 1210 /* {"skip_first", "-x"}, */ 1211 {"bytes_warning", "-b"}, 1212 {"hash_randomization", "-R"}, 1213 {0} 1228 1214 }; 1229 1215 1230 1216 static PyStructSequence_Desc flags_desc = { 1231 "sys.flags",/* name */1232 flags__doc__,/* doc */1233 flags_fields,/* fields */1217 "sys.flags", /* name */ 1218 flags__doc__, /* doc */ 1219 flags_fields, /* fields */ 1234 1220 #ifdef RISCOS 1235 16 1221 17 1236 1222 #else 1237 15 1223 16 1238 1224 #endif 1239 1225 }; … … 1242 1228 make_flags(void) 1243 1229 { 1244 1245 1246 1247 1248 1249 1230 int pos = 0; 1231 PyObject *seq; 1232 1233 seq = PyStructSequence_New(&FlagsType); 1234 if (seq == NULL) 1235 return NULL; 1250 1236 1251 1237 #define SetFlag(flag) \ 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1238 PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag)) 1239 1240 SetFlag(Py_DebugFlag); 1241 SetFlag(Py_Py3kWarningFlag); 1242 SetFlag(Py_DivisionWarningFlag); 1243 SetFlag(_Py_QnewFlag); 1244 SetFlag(Py_InspectFlag); 1245 SetFlag(Py_InteractiveFlag); 1246 SetFlag(Py_OptimizeFlag); 1247 SetFlag(Py_DontWriteBytecodeFlag); 1248 SetFlag(Py_NoUserSiteDirectory); 1249 SetFlag(Py_NoSiteFlag); 1250 SetFlag(Py_IgnoreEnvironmentFlag); 1251 SetFlag(Py_TabcheckFlag); 1252 SetFlag(Py_VerboseFlag); 1267 1253 #ifdef RISCOS 1268 1269 #endif 1270 1271 1272 1254 SetFlag(Py_RISCOSWimpFlag); 1255 #endif 1256 /* SetFlag(saw_unbuffered_flag); */ 1257 SetFlag(Py_UnicodeFlag); 1258 /* SetFlag(skipfirstline); */ 1273 1259 SetFlag(Py_BytesWarningFlag); 1260 SetFlag(Py_HashRandomizationFlag); 1274 1261 #undef SetFlag 1275 1262 1276 if (PyErr_Occurred()) { 1277 return NULL; 1278 } 1279 return seq; 1263 if (PyErr_Occurred()) { 1264 return NULL; 1265 } 1266 return seq; 1267 } 1268 1269 PyDoc_STRVAR(version_info__doc__, 1270 "sys.version_info\n\ 1271 \n\ 1272 Version information as a named tuple."); 1273 1274 static PyTypeObject VersionInfoType = {0, 0, 0, 0, 0, 0}; 1275 1276 static PyStructSequence_Field version_info_fields[] = { 1277 {"major", "Major release number"}, 1278 {"minor", "Minor release number"}, 1279 {"micro", "Patch release number"}, 1280 {"releaselevel", "'alpha', 'beta', 'candidate', or 'release'"}, 1281 {"serial", "Serial release number"}, 1282 {0} 1283 }; 1284 1285 static PyStructSequence_Desc version_info_desc = { 1286 "sys.version_info", /* name */ 1287 version_info__doc__, /* doc */ 1288 version_info_fields, /* fields */ 1289 5 1290 }; 1291 1292 static PyObject * 1293 make_version_info(void) 1294 { 1295 PyObject *version_info; 1296 char *s; 1297 int pos = 0; 1298 1299 version_info = PyStructSequence_New(&VersionInfoType); 1300 if (version_info == NULL) { 1301 return NULL; 1302 } 1303 1304 /* 1305 * These release level checks are mutually exclusive and cover 1306 * the field, so don't get too fancy with the pre-processor! 1307 */ 1308 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA 1309 s = "alpha"; 1310 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA 1311 s = "beta"; 1312 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA 1313 s = "candidate"; 1314 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL 1315 s = "final"; 1316 #endif 1317 1318 #define SetIntItem(flag) \ 1319 PyStructSequence_SET_ITEM(version_info, pos++, PyInt_FromLong(flag)) 1320 #define SetStrItem(flag) \ 1321 PyStructSequence_SET_ITEM(version_info, pos++, PyString_FromString(flag)) 1322 1323 SetIntItem(PY_MAJOR_VERSION); 1324 SetIntItem(PY_MINOR_VERSION); 1325 SetIntItem(PY_MICRO_VERSION); 1326 SetStrItem(s); 1327 SetIntItem(PY_RELEASE_SERIAL); 1328 #undef SetIntItem 1329 #undef SetStrItem 1330 1331 if (PyErr_Occurred()) { 1332 Py_CLEAR(version_info); 1333 return NULL; 1334 } 1335 return version_info; 1280 1336 } 1281 1337 … … 1283 1339 _PySys_Init(void) 1284 1340 { 1285 1286 1287 1288 1289 1290 1291 1292 1293 #define SET_SYS_FROM_STRING(key, value) 1294 v = value;\1295 if (v != NULL)\1296 PyDict_SetItemString(sysdict, key, v);\1297 1298 1299 1300 1301 1302 1303 1341 PyObject *m, *v, *sysdict; 1342 PyObject *sysin, *sysout, *syserr; 1343 char *s; 1344 1345 m = Py_InitModule3("sys", sys_methods, sys_doc); 1346 if (m == NULL) 1347 return NULL; 1348 sysdict = PyModule_GetDict(m); 1349 #define SET_SYS_FROM_STRING(key, value) \ 1350 v = value; \ 1351 if (v != NULL) \ 1352 PyDict_SetItemString(sysdict, key, v); \ 1353 Py_XDECREF(v) 1354 1355 /* Check that stdin is not a directory 1356 Using shell redirection, you can redirect stdin to a directory, 1357 crashing the Python interpreter. Catch this common mistake here 1358 and output a useful error message. Note that under MS Windows, 1359 the shell already prevents that. */ 1304 1360 #if !defined(MS_WINDOWS) 1305 { 1306 struct stat sb; 1307 if (fstat(fileno(stdin), &sb) == 0 && 1308 S_ISDIR(sb.st_mode)) { 1309 /* There's nothing more we can do. */ 1310 /* Py_FatalError() will core dump, so just exit. */ 1311 PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n"); 1312 exit(EXIT_FAILURE); 1313 } 1314 } 1315 #endif 1316 1317 /* Closing the standard FILE* if sys.std* goes aways causes problems 1318 * for embedded Python usages. Closing them when somebody explicitly 1319 * invokes .close() might be possible, but the FAQ promises they get 1320 * never closed. However, we still need to get write errors when 1321 * writing fails (e.g. because stdout is redirected), so we flush the 1322 * streams and check for errors before the file objects are deleted. 1323 * On OS X, fflush()ing stdin causes an error, so we exempt stdin 1324 * from that procedure. 1325 */ 1326 sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL); 1327 sysout = PyFile_FromFile(stdout, "<stdout>", "w", _check_and_flush); 1328 syserr = PyFile_FromFile(stderr, "<stderr>", "w", _check_and_flush); 1329 if (PyErr_Occurred()) 1330 return NULL; 1331 1332 PyDict_SetItemString(sysdict, "stdin", sysin); 1333 PyDict_SetItemString(sysdict, "stdout", sysout); 1334 PyDict_SetItemString(sysdict, "stderr", syserr); 1335 /* Make backup copies for cleanup */ 1336 PyDict_SetItemString(sysdict, "__stdin__", sysin); 1337 PyDict_SetItemString(sysdict, "__stdout__", sysout); 1338 PyDict_SetItemString(sysdict, "__stderr__", syserr); 1339 PyDict_SetItemString(sysdict, "__displayhook__", 1340 PyDict_GetItemString(sysdict, "displayhook")); 1341 PyDict_SetItemString(sysdict, "__excepthook__", 1342 PyDict_GetItemString(sysdict, "excepthook")); 1343 Py_XDECREF(sysin); 1344 Py_XDECREF(sysout); 1345 Py_XDECREF(syserr); 1346 1347 SET_SYS_FROM_STRING("version", 1348 PyString_FromString(Py_GetVersion())); 1349 SET_SYS_FROM_STRING("hexversion", 1350 PyInt_FromLong(PY_VERSION_HEX)); 1351 svnversion_init(); 1352 SET_SYS_FROM_STRING("subversion", 1353 Py_BuildValue("(ssz)", "CPython", branch, 1354 svn_revision)); 1355 SET_SYS_FROM_STRING("dont_write_bytecode", 1356 PyBool_FromLong(Py_DontWriteBytecodeFlag)); 1357 /* 1358 * These release level checks are mutually exclusive and cover 1359 * the field, so don't get too fancy with the pre-processor! 1360 */ 1361 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA 1362 s = "alpha"; 1363 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA 1364 s = "beta"; 1365 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA 1366 s = "candidate"; 1367 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL 1368 s = "final"; 1369 #endif 1370 1371 SET_SYS_FROM_STRING("version_info", 1372 Py_BuildValue("iiisi", PY_MAJOR_VERSION, 1373 PY_MINOR_VERSION, 1374 PY_MICRO_VERSION, s, 1375 PY_RELEASE_SERIAL)); 1376 SET_SYS_FROM_STRING("api_version", 1377 PyInt_FromLong(PYTHON_API_VERSION)); 1378 SET_SYS_FROM_STRING("copyright", 1379 PyString_FromString(Py_GetCopyright())); 1380 SET_SYS_FROM_STRING("platform", 1381 PyString_FromString(Py_GetPlatform())); 1382 SET_SYS_FROM_STRING("executable", 1383 PyString_FromString(Py_GetProgramFullPath())); 1384 SET_SYS_FROM_STRING("prefix", 1385 PyString_FromString(Py_GetPrefix())); 1386 SET_SYS_FROM_STRING("exec_prefix", 1387 PyString_FromString(Py_GetExecPrefix())); 1388 SET_SYS_FROM_STRING("maxsize", 1389 PyInt_FromSsize_t(PY_SSIZE_T_MAX)); 1390 SET_SYS_FROM_STRING("maxint", 1391 PyInt_FromLong(PyInt_GetMax())); 1392 SET_SYS_FROM_STRING("py3kwarning", 1393 PyBool_FromLong(Py_Py3kWarningFlag)); 1394 SET_SYS_FROM_STRING("float_info", 1395 PyFloat_GetInfo()); 1361 { 1362 struct stat sb; 1363 if (fstat(fileno(stdin), &sb) == 0 && 1364 S_ISDIR(sb.st_mode)) { 1365 /* There's nothing more we can do. */ 1366 /* Py_FatalError() will core dump, so just exit. */ 1367 PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n"); 1368 exit(EXIT_FAILURE); 1369 } 1370 } 1371 #endif 1372 1373 /* Closing the standard FILE* if sys.std* goes aways causes problems 1374 * for embedded Python usages. Closing them when somebody explicitly 1375 * invokes .close() might be possible, but the FAQ promises they get 1376 * never closed. However, we still need to get write errors when 1377 * writing fails (e.g. because stdout is redirected), so we flush the 1378 * streams and check for errors before the file objects are deleted. 1379 * On OS X, fflush()ing stdin causes an error, so we exempt stdin 1380 * from that procedure. 1381 */ 1382 sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL); 1383 sysout = PyFile_FromFile(stdout, "<stdout>", "w", _check_and_flush); 1384 syserr = PyFile_FromFile(stderr, "<stderr>", "w", _check_and_flush); 1385 if (PyErr_Occurred()) 1386 return NULL; 1387 1388 PyDict_SetItemString(sysdict, "stdin", sysin); 1389 PyDict_SetItemString(sysdict, "stdout", sysout); 1390 PyDict_SetItemString(sysdict, "stderr", syserr); 1391 /* Make backup copies for cleanup */ 1392 PyDict_SetItemString(sysdict, "__stdin__", sysin); 1393 PyDict_SetItemString(sysdict, "__stdout__", sysout); 1394 PyDict_SetItemString(sysdict, "__stderr__", syserr); 1395 PyDict_SetItemString(sysdict, "__displayhook__", 1396 PyDict_GetItemString(sysdict, "displayhook")); 1397 PyDict_SetItemString(sysdict, "__excepthook__", 1398 PyDict_GetItemString(sysdict, "excepthook")); 1399 Py_XDECREF(sysin); 1400 Py_XDECREF(sysout); 1401 Py_XDECREF(syserr); 1402 1403 SET_SYS_FROM_STRING("version", 1404 PyString_FromString(Py_GetVersion())); 1405 SET_SYS_FROM_STRING("hexversion", 1406 PyInt_FromLong(PY_VERSION_HEX)); 1407 svnversion_init(); 1408 SET_SYS_FROM_STRING("subversion", 1409 Py_BuildValue("(ssz)", "CPython", branch, 1410 svn_revision)); 1411 SET_SYS_FROM_STRING("_mercurial", 1412 Py_BuildValue("(szz)", "CPython", _Py_hgidentifier(), 1413 _Py_hgversion())); 1414 SET_SYS_FROM_STRING("dont_write_bytecode", 1415 PyBool_FromLong(Py_DontWriteBytecodeFlag)); 1416 SET_SYS_FROM_STRING("api_version", 1417 PyInt_FromLong(PYTHON_API_VERSION)); 1418 SET_SYS_FROM_STRING("copyright", 1419 PyString_FromString(Py_GetCopyright())); 1420 SET_SYS_FROM_STRING("platform", 1421 PyString_FromString(Py_GetPlatform())); 1422 SET_SYS_FROM_STRING("executable", 1423 PyString_FromString(Py_GetProgramFullPath())); 1424 SET_SYS_FROM_STRING("prefix", 1425 PyString_FromString(Py_GetPrefix())); 1426 SET_SYS_FROM_STRING("exec_prefix", 1427 PyString_FromString(Py_GetExecPrefix())); 1428 SET_SYS_FROM_STRING("maxsize", 1429 PyInt_FromSsize_t(PY_SSIZE_T_MAX)); 1430 SET_SYS_FROM_STRING("maxint", 1431 PyInt_FromLong(PyInt_GetMax())); 1432 SET_SYS_FROM_STRING("py3kwarning", 1433 PyBool_FromLong(Py_Py3kWarningFlag)); 1434 SET_SYS_FROM_STRING("float_info", 1435 PyFloat_GetInfo()); 1436 SET_SYS_FROM_STRING("long_info", 1437 PyLong_GetInfo()); 1396 1438 #ifdef Py_USING_UNICODE 1397 1398 1399 #endif 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1439 SET_SYS_FROM_STRING("maxunicode", 1440 PyInt_FromLong(PyUnicode_GetMax())); 1441 #endif 1442 SET_SYS_FROM_STRING("builtin_module_names", 1443 list_builtin_module_names()); 1444 { 1445 /* Assumes that longs are at least 2 bytes long. 1446 Should be safe! */ 1447 unsigned long number = 1; 1448 char *value; 1449 1450 s = (char *) &number; 1451 if (s[0] == 0) 1452 value = "big"; 1453 else 1454 value = "little"; 1455 SET_SYS_FROM_STRING("byteorder", 1456 PyString_FromString(value)); 1457 } 1416 1458 #ifdef MS_COREDLL 1417 SET_SYS_FROM_STRING("dllhandle", 1418 PyLong_FromVoidPtr(PyWin_DLLhModule)); 1419 SET_SYS_FROM_STRING("winver", 1420 PyString_FromString(PyWin_DLLVersionString)); 1421 #endif 1422 if (warnoptions == NULL) { 1423 warnoptions = PyList_New(0); 1424 } 1425 else { 1426 Py_INCREF(warnoptions); 1427 } 1428 if (warnoptions != NULL) { 1429 PyDict_SetItemString(sysdict, "warnoptions", warnoptions); 1430 } 1431 1432 if (FlagsType.tp_name == 0) 1433 PyStructSequence_InitType(&FlagsType, &flags_desc); 1434 SET_SYS_FROM_STRING("flags", make_flags()); 1435 /* prevent user from creating new instances */ 1436 FlagsType.tp_init = NULL; 1437 FlagsType.tp_new = NULL; 1459 SET_SYS_FROM_STRING("dllhandle", 1460 PyLong_FromVoidPtr(PyWin_DLLhModule)); 1461 SET_SYS_FROM_STRING("winver", 1462 PyString_FromString(PyWin_DLLVersionString)); 1463 #endif 1464 if (warnoptions == NULL) { 1465 warnoptions = PyList_New(0); 1466 } 1467 else { 1468 Py_INCREF(warnoptions); 1469 } 1470 if (warnoptions != NULL) { 1471 PyDict_SetItemString(sysdict, "warnoptions", warnoptions); 1472 } 1473 1474 /* version_info */ 1475 if (VersionInfoType.tp_name == 0) 1476 PyStructSequence_InitType(&VersionInfoType, &version_info_desc); 1477 SET_SYS_FROM_STRING("version_info", make_version_info()); 1478 /* prevent user from creating new instances */ 1479 VersionInfoType.tp_init = NULL; 1480 VersionInfoType.tp_new = NULL; 1481 1482 /* flags */ 1483 if (FlagsType.tp_name == 0) 1484 PyStructSequence_InitType(&FlagsType, &flags_desc); 1485 SET_SYS_FROM_STRING("flags", make_flags()); 1486 /* prevent user from creating new instances */ 1487 FlagsType.tp_init = NULL; 1488 FlagsType.tp_new = NULL; 1489 1490 1491 #if defined(MS_WINDOWS) 1492 /* getwindowsversion */ 1493 if (WindowsVersionType.tp_name == 0) 1494 PyStructSequence_InitType(&WindowsVersionType, &windows_version_desc); 1495 /* prevent user from creating new instances */ 1496 WindowsVersionType.tp_init = NULL; 1497 WindowsVersionType.tp_new = NULL; 1498 #endif 1499 1500 /* float repr style: 0.03 (short) vs 0.029999999999999999 (legacy) */ 1501 #ifndef PY_NO_SHORT_FLOAT_REPR 1502 SET_SYS_FROM_STRING("float_repr_style", 1503 PyString_FromString("short")); 1504 #else 1505 SET_SYS_FROM_STRING("float_repr_style", 1506 PyString_FromString("legacy")); 1507 #endif 1438 1508 1439 1509 #undef SET_SYS_FROM_STRING 1440 1441 1442 1510 if (PyErr_Occurred()) 1511 return NULL; 1512 return m; 1443 1513 } 1444 1514 … … 1446 1516 makepathobject(char *path, int delim) 1447 1517 { 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1518 int i, n; 1519 char *p; 1520 PyObject *v, *w; 1521 1522 n = 1; 1523 p = path; 1524 while ((p = strchr(p, delim)) != NULL) { 1525 n++; 1526 p++; 1527 } 1528 v = PyList_New(n); 1529 if (v == NULL) 1530 return NULL; 1531 for (i = 0; ; i++) { 1532 p = strchr(path, delim); 1533 if (p == NULL) 1534 p = strchr(path, '\0'); /* End of string */ 1535 w = PyString_FromStringAndSize(path, (Py_ssize_t) (p - path)); 1536 if (w == NULL) { 1537 Py_DECREF(v); 1538 return NULL; 1539 } 1540 PyList_SetItem(v, i, w); 1541 if (*p == '\0') 1542 break; 1543 path = p+1; 1544 } 1545 return v; 1476 1546 } 1477 1547 … … 1479 1549 PySys_SetPath(char *path) 1480 1550 { 1481 1482 1483 1484 1485 1486 1551 PyObject *v; 1552 if ((v = makepathobject(path, DELIM)) == NULL) 1553 Py_FatalError("can't create sys.path"); 1554 if (PySys_SetObject("path", v) != 0) 1555 Py_FatalError("can't assign sys.path"); 1556 Py_DECREF(v); 1487 1557 } 1488 1558 … … 1490 1560 makeargvobject(int argc, char **argv) 1491 1561 { 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1562 PyObject *av; 1563 if (argc <= 0 || argv == NULL) { 1564 /* Ensure at least one (empty) argument is seen */ 1565 static char *empty_argv[1] = {""}; 1566 argv = empty_argv; 1567 argc = 1; 1568 } 1569 av = PyList_New(argc); 1570 if (av != NULL) { 1571 int i; 1572 for (i = 0; i < argc; i++) { 1503 1573 #ifdef __VMS 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1574 PyObject *v; 1575 1576 /* argv[0] is the script pathname if known */ 1577 if (i == 0) { 1578 char* fn = decc$translate_vms(argv[0]); 1579 if ((fn == (char *)0) || fn == (char *)-1) 1580 v = PyString_FromString(argv[0]); 1581 else 1582 v = PyString_FromString( 1583 decc$translate_vms(argv[0])); 1584 } else 1585 v = PyString_FromString(argv[i]); 1516 1586 #else 1517 PyObject *v = PyString_FromString(argv[i]); 1518 #endif 1519 if (v == NULL) { 1520 Py_DECREF(av); 1521 av = NULL; 1522 break; 1523 } 1524 PyList_SetItem(av, i, v); 1525 } 1526 } 1527 return av; 1587 PyObject *v = PyString_FromString(argv[i]); 1588 #endif 1589 if (v == NULL) { 1590 Py_DECREF(av); 1591 av = NULL; 1592 break; 1593 } 1594 PyList_SetItem(av, i, v); 1595 } 1596 } 1597 return av; 1598 } 1599 1600 void 1601 PySys_SetArgvEx(int argc, char **argv, int updatepath) 1602 { 1603 #if defined(HAVE_REALPATH) 1604 char fullpath[MAXPATHLEN]; 1605 #elif defined(MS_WINDOWS) && !defined(MS_WINCE) 1606 char fullpath[MAX_PATH]; 1607 #endif 1608 PyObject *av = makeargvobject(argc, argv); 1609 PyObject *path = PySys_GetObject("path"); 1610 if (av == NULL) 1611 Py_FatalError("no mem for sys.argv"); 1612 if (PySys_SetObject("argv", av) != 0) 1613 Py_FatalError("can't assign sys.argv"); 1614 if (updatepath && path != NULL) { 1615 char *argv0 = argv[0]; 1616 char *p = NULL; 1617 Py_ssize_t n = 0; 1618 PyObject *a; 1619 #ifdef HAVE_READLINK 1620 char link[MAXPATHLEN+1]; 1621 char argv0copy[2*MAXPATHLEN+1]; 1622 int nr = 0; 1623 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) 1624 nr = readlink(argv0, link, MAXPATHLEN); 1625 if (nr > 0) { 1626 /* It's a symlink */ 1627 link[nr] = '\0'; 1628 if (link[0] == SEP) 1629 argv0 = link; /* Link to absolute path */ 1630 else if (strchr(link, SEP) == NULL) 1631 ; /* Link without path */ 1632 else { 1633 /* Must join(dirname(argv0), link) */ 1634 char *q = strrchr(argv0, SEP); 1635 if (q == NULL) 1636 argv0 = link; /* argv0 without path */ 1637 else { 1638 /* Must make a copy */ 1639 strcpy(argv0copy, argv0); 1640 q = strrchr(argv0copy, SEP); 1641 strcpy(q+1, link); 1642 argv0 = argv0copy; 1643 } 1644 } 1645 } 1646 #endif /* HAVE_READLINK */ 1647 #if SEP == '\\' /* Special case for MS filename syntax */ 1648 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) { 1649 char *q; 1650 #if defined(MS_WINDOWS) && !defined(MS_WINCE) 1651 /* This code here replaces the first element in argv with the full 1652 path that it represents. Under CE, there are no relative paths so 1653 the argument must be the full path anyway. */ 1654 char *ptemp; 1655 if (GetFullPathName(argv0, 1656 sizeof(fullpath), 1657 fullpath, 1658 &ptemp)) { 1659 argv0 = fullpath; 1660 } 1661 #endif 1662 p = strrchr(argv0, SEP); 1663 /* Test for alternate separator */ 1664 q = strrchr(p ? p : argv0, '/'); 1665 if (q != NULL) 1666 p = q; 1667 if (p != NULL) { 1668 n = p + 1 - argv0; 1669 if (n > 1 && p[-1] != ':') 1670 n--; /* Drop trailing separator */ 1671 } 1672 } 1673 #else /* All other filename syntaxes */ 1674 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) { 1675 #if defined(HAVE_REALPATH) 1676 if (realpath(argv0, fullpath)) { 1677 argv0 = fullpath; 1678 } 1679 #endif 1680 p = strrchr(argv0, SEP); 1681 } 1682 if (p != NULL) { 1683 #ifndef RISCOS 1684 n = p + 1 - argv0; 1685 #else /* don't include trailing separator */ 1686 n = p - argv0; 1687 #endif /* RISCOS */ 1688 #if SEP == '/' /* Special case for Unix filename syntax */ 1689 if (n > 1) 1690 n--; /* Drop trailing separator */ 1691 #endif /* Unix */ 1692 } 1693 #endif /* All others */ 1694 a = PyString_FromStringAndSize(argv0, n); 1695 if (a == NULL) 1696 Py_FatalError("no mem for sys.path insertion"); 1697 if (PyList_Insert(path, 0, a) < 0) 1698 Py_FatalError("sys.path.insert(0) failed"); 1699 Py_DECREF(a); 1700 } 1701 Py_DECREF(av); 1528 1702 } 1529 1703 … … 1531 1705 PySys_SetArgv(int argc, char **argv) 1532 1706 { 1533 #if defined(HAVE_REALPATH) 1534 char fullpath[MAXPATHLEN]; 1535 #elif defined(MS_WINDOWS) && !defined(MS_WINCE) 1536 char fullpath[MAX_PATH]; 1537 #endif 1538 PyObject *av = makeargvobject(argc, argv); 1539 PyObject *path = PySys_GetObject("path"); 1540 if (av == NULL) 1541 Py_FatalError("no mem for sys.argv"); 1542 if (PySys_SetObject("argv", av) != 0) 1543 Py_FatalError("can't assign sys.argv"); 1544 if (path != NULL) { 1545 char *argv0 = argv[0]; 1546 char *p = NULL; 1547 Py_ssize_t n = 0; 1548 PyObject *a; 1549 #ifdef HAVE_READLINK 1550 char link[MAXPATHLEN+1]; 1551 char argv0copy[2*MAXPATHLEN+1]; 1552 int nr = 0; 1553 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) 1554 nr = readlink(argv0, link, MAXPATHLEN); 1555 if (nr > 0) { 1556 /* It's a symlink */ 1557 link[nr] = '\0'; 1558 if (link[0] == SEP) 1559 argv0 = link; /* Link to absolute path */ 1560 else if (strchr(link, SEP) == NULL) 1561 ; /* Link without path */ 1562 else { 1563 /* Must join(dirname(argv0), link) */ 1564 char *q = strrchr(argv0, SEP); 1565 if (q == NULL) 1566 argv0 = link; /* argv0 without path */ 1567 else { 1568 /* Must make a copy */ 1569 strcpy(argv0copy, argv0); 1570 q = strrchr(argv0copy, SEP); 1571 strcpy(q+1, link); 1572 argv0 = argv0copy; 1573 } 1574 } 1575 } 1576 #endif /* HAVE_READLINK */ 1577 #if SEP == '\\' /* Special case for MS filename syntax */ 1578 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) { 1579 char *q; 1580 #if defined(MS_WINDOWS) && !defined(MS_WINCE) 1581 /* This code here replaces the first element in argv with the full 1582 path that it represents. Under CE, there are no relative paths so 1583 the argument must be the full path anyway. */ 1584 char *ptemp; 1585 if (GetFullPathName(argv0, 1586 sizeof(fullpath), 1587 fullpath, 1588 &ptemp)) { 1589 argv0 = fullpath; 1590 } 1591 #endif 1592 p = strrchr(argv0, SEP); 1593 /* Test for alternate separator */ 1594 q = strrchr(p ? p : argv0, '/'); 1595 if (q != NULL) 1596 p = q; 1597 if (p != NULL) { 1598 n = p + 1 - argv0; 1599 if (n > 1 && p[-1] != ':') 1600 n--; /* Drop trailing separator */ 1601 } 1602 } 1603 #else /* All other filename syntaxes */ 1604 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) { 1605 #if defined(HAVE_REALPATH) 1606 if (realpath(argv0, fullpath)) { 1607 argv0 = fullpath; 1608 } 1609 #endif 1610 p = strrchr(argv0, SEP); 1611 } 1612 if (p != NULL) { 1613 #ifndef RISCOS 1614 n = p + 1 - argv0; 1615 #else /* don't include trailing separator */ 1616 n = p - argv0; 1617 #endif /* RISCOS */ 1618 #if SEP == '/' /* Special case for Unix filename syntax */ 1619 if (n > 1) 1620 n--; /* Drop trailing separator */ 1621 #endif /* Unix */ 1622 } 1623 #endif /* All others */ 1624 a = PyString_FromStringAndSize(argv0, n); 1625 if (a == NULL) 1626 Py_FatalError("no mem for sys.path insertion"); 1627 if (PyList_Insert(path, 0, a) < 0) 1628 Py_FatalError("sys.path.insert(0) failed"); 1629 Py_DECREF(a); 1630 } 1631 Py_DECREF(av); 1707 PySys_SetArgvEx(argc, argv, 1); 1632 1708 } 1633 1709 … … 1660 1736 mywrite(char *name, FILE *fp, const char *format, va_list va) 1661 1737 { 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1738 PyObject *file; 1739 PyObject *error_type, *error_value, *error_traceback; 1740 1741 PyErr_Fetch(&error_type, &error_value, &error_traceback); 1742 file = PySys_GetObject(name); 1743 if (file == NULL || PyFile_AsFile(file) == fp) 1744 vfprintf(fp, format, va); 1745 else { 1746 char buffer[1001]; 1747 const int written = PyOS_vsnprintf(buffer, sizeof(buffer), 1748 format, va); 1749 if (PyFile_WriteString(buffer, file) != 0) { 1750 PyErr_Clear(); 1751 fputs(buffer, fp); 1752 } 1753 if (written < 0 || (size_t)written >= sizeof(buffer)) { 1754 const char *truncated = "... truncated"; 1755 if (PyFile_WriteString(truncated, file) != 0) { 1756 PyErr_Clear(); 1757 fputs(truncated, fp); 1758 } 1759 } 1760 } 1761 PyErr_Restore(error_type, error_value, error_traceback); 1686 1762 } 1687 1763 … … 1689 1765 PySys_WriteStdout(const char *format, ...) 1690 1766 { 1691 1692 1693 1694 1695 1767 va_list va; 1768 1769 va_start(va, format); 1770 mywrite("stdout", stdout, format, va); 1771 va_end(va); 1696 1772 } 1697 1773 … … 1699 1775 PySys_WriteStderr(const char *format, ...) 1700 1776 { 1701 1702 1703 1704 1705 1706 } 1777 va_list va; 1778 1779 va_start(va, format); 1780 mywrite("stderr", stderr, format, va); 1781 va_end(va); 1782 }
Note:
See TracChangeset
for help on using the changeset viewer.
