sysmodule.c revision 23fff911a2e0185d3f4618cd02a7b051b55fdd7e
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 "compile.h" 19#include "frameobject.h" 20 21#include "osdefs.h" 22 23#ifdef HAVE_UNISTD_H 24#include <unistd.h> 25#endif 26 27#ifdef MS_COREDLL 28extern void *PyWin_DLLhModule; 29/* A string loaded from the DLL at startup: */ 30extern const char *PyWin_DLLVersionString; 31#endif 32 33PyObject * 34PySys_GetObject(char *name) 35{ 36 PyThreadState *tstate = PyThreadState_Get(); 37 PyObject *sd = tstate->interp->sysdict; 38 if (sd == NULL) 39 return NULL; 40 return PyDict_GetItemString(sd, name); 41} 42 43FILE * 44PySys_GetFile(char *name, FILE *def) 45{ 46 FILE *fp = NULL; 47 PyObject *v = PySys_GetObject(name); 48 if (v != NULL && PyFile_Check(v)) 49 fp = PyFile_AsFile(v); 50 if (fp == NULL) 51 fp = def; 52 return fp; 53} 54 55int 56PySys_SetObject(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_exc_info(PyObject *self, PyObject *args) 72{ 73 PyThreadState *tstate; 74 if (!PyArg_ParseTuple(args, ":exc_info")) 75 return NULL; 76 tstate = PyThreadState_Get(); 77 return Py_BuildValue( 78 "(OOO)", 79 tstate->exc_type != NULL ? tstate->exc_type : Py_None, 80 tstate->exc_value != NULL ? tstate->exc_value : Py_None, 81 tstate->exc_traceback != NULL ? 82 tstate->exc_traceback : Py_None); 83} 84 85static char exc_info_doc[] = 86"exc_info() -> (type, value, traceback)\n\ 87\n\ 88Return information about the exception that is currently being handled.\n\ 89This should be called from inside an except clause only."; 90 91static PyObject * 92sys_exit(PyObject *self, PyObject *args) 93{ 94 /* Raise SystemExit so callers may catch it or clean up. */ 95 PyErr_SetObject(PyExc_SystemExit, args); 96 return NULL; 97} 98 99static char exit_doc[] = 100"exit([status])\n\ 101\n\ 102Exit the interpreter by raising SystemExit(status).\n\ 103If the status is omitted or None, it defaults to zero (i.e., success).\n\ 104If the status numeric, it will be used as the system exit status.\n\ 105If it is another kind of object, it will be printed and the system\n\ 106exit status will be one (i.e., failure)."; 107 108static PyObject * 109sys_getdefaultencoding(PyObject *self, PyObject *args) 110{ 111 if (!PyArg_ParseTuple(args, ":getdefaultencoding")) 112 return NULL; 113 return PyString_FromString(PyUnicode_GetDefaultEncoding()); 114} 115 116static char getdefaultencoding_doc[] = 117"getdefaultencoding() -> string\n\ 118\n\ 119Return the current default string encoding used by the Unicode \n\ 120implementation."; 121 122static PyObject * 123sys_setdefaultencoding(PyObject *self, PyObject *args) 124{ 125 char *encoding; 126 if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding)) 127 return NULL; 128 if (PyUnicode_SetDefaultEncoding(encoding)) 129 return NULL; 130 Py_INCREF(Py_None); 131 return Py_None; 132} 133 134static char setdefaultencoding_doc[] = 135"setdefaultencoding(encoding)\n\ 136\n\ 137Set the current default string encoding used by the Unicode implementation."; 138 139static PyObject * 140sys_settrace(PyObject *self, PyObject *args) 141{ 142 PyThreadState *tstate = PyThreadState_Get(); 143 if (args == Py_None) 144 args = NULL; 145 else 146 Py_XINCREF(args); 147 Py_XDECREF(tstate->sys_tracefunc); 148 tstate->sys_tracefunc = args; 149 Py_INCREF(Py_None); 150 return Py_None; 151} 152 153static char settrace_doc[] = 154"settrace(function)\n\ 155\n\ 156Set the global debug tracing function. It will be called on each\n\ 157function call. See the debugger chapter in the library manual."; 158 159static PyObject * 160sys_setprofile(PyObject *self, PyObject *args) 161{ 162 PyThreadState *tstate = PyThreadState_Get(); 163 if (args == Py_None) 164 args = NULL; 165 else 166 Py_XINCREF(args); 167 Py_XDECREF(tstate->sys_profilefunc); 168 tstate->sys_profilefunc = args; 169 Py_INCREF(Py_None); 170 return Py_None; 171} 172 173static char setprofile_doc[] = 174"setprofile(function)\n\ 175\n\ 176Set the profiling function. It will be called on each function call\n\ 177and return. See the profiler chapter in the library manual."; 178 179static PyObject * 180sys_setcheckinterval(PyObject *self, PyObject *args) 181{ 182 PyThreadState *tstate = PyThreadState_Get(); 183 if (!PyArg_ParseTuple(args, "i:setcheckinterval", &tstate->interp->checkinterval)) 184 return NULL; 185 Py_INCREF(Py_None); 186 return Py_None; 187} 188 189static char setcheckinterval_doc[] = 190"setcheckinterval(n)\n\ 191\n\ 192Tell the Python interpreter to check for asynchronous events every\n\ 193n instructions. This also affects how often thread switches occur."; 194 195static PyObject * 196sys_setrecursionlimit(PyObject *self, PyObject *args) 197{ 198 int new_limit; 199 if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit)) 200 return NULL; 201 if (new_limit <= 0) { 202 PyErr_SetString(PyExc_ValueError, 203 "recursion limit must be positive"); 204 return NULL; 205 } 206 Py_SetRecursionLimit(new_limit); 207 Py_INCREF(Py_None); 208 return Py_None; 209} 210 211static char setrecursionlimit_doc[] = 212"setrecursionlimit(n)\n\ 213\n\ 214Set the maximum depth of the Python interpreter stack to n. This\n\ 215limit prevents infinite recursion from causing an overflow of the C\n\ 216stack and crashing Python. The highest possible limit is platform-\n\ 217dependent."; 218 219static PyObject * 220sys_getrecursionlimit(PyObject *self, PyObject *args) 221{ 222 if (!PyArg_ParseTuple(args, ":getrecursionlimit")) 223 return NULL; 224 return PyInt_FromLong(Py_GetRecursionLimit()); 225} 226 227static char getrecursionlimit_doc[] = 228"getrecursionlimit()\n\ 229\n\ 230Return the current value of the recursion limit, the maximum depth\n\ 231of the Python interpreter stack. This limit prevents infinite\n\ 232recursion from causing an overflow of the C stack and crashing Python."; 233 234#ifdef USE_MALLOPT 235/* Link with -lmalloc (or -lmpc) on an SGI */ 236#include <malloc.h> 237 238static PyObject * 239sys_mdebug(PyObject *self, PyObject *args) 240{ 241 int flag; 242 if (!PyArg_ParseTuple(args, "i:mdebug", &flag)) 243 return NULL; 244 mallopt(M_DEBUG, flag); 245 Py_INCREF(Py_None); 246 return Py_None; 247} 248#endif /* USE_MALLOPT */ 249 250static PyObject * 251sys_getrefcount(PyObject *self, PyObject *args) 252{ 253 PyObject *arg; 254 if (!PyArg_ParseTuple(args, "O:getrefcount", &arg)) 255 return NULL; 256 return PyInt_FromLong(arg->ob_refcnt); 257} 258 259#ifdef Py_TRACE_REFS 260static PyObject * 261sys_gettotalrefcount(PyObject *self, PyObject *args) 262{ 263 extern long _Py_RefTotal; 264 if (!PyArg_ParseTuple(args, ":gettotalrefcount")) 265 return NULL; 266 return PyInt_FromLong(_Py_RefTotal); 267} 268 269#endif /* Py_TRACE_REFS */ 270 271static char getrefcount_doc[] = 272"getrefcount(object) -> integer\n\ 273\n\ 274Return the current reference count for the object. This includes the\n\ 275temporary reference in the argument list, so it is at least 2."; 276 277#ifdef COUNT_ALLOCS 278static PyObject * 279sys_getcounts(PyObject *self, PyObject *args) 280{ 281 extern PyObject *get_counts(void); 282 283 if (!PyArg_ParseTuple(args, ":getcounts")) 284 return NULL; 285 return get_counts(); 286} 287#endif 288 289static char getframe_doc[] = 290"_getframe([depth]) -> frameobject\n\ 291\n\ 292Return a frame object from the call stack. If optional integer depth is\n\ 293given, return the frame object that many calls below the top of the stack.\n\ 294If that is deeper than the call stack, ValueError is raised. The default\n\ 295for depth is zero, returning the frame at the top of the call stack.\n\ 296\n\ 297This function should be used for internal and specialized\n\ 298purposes only."; 299 300static PyObject * 301sys_getframe(PyObject *self, PyObject *args) 302{ 303 PyFrameObject *f = PyThreadState_Get()->frame; 304 int depth = -1; 305 306 if (!PyArg_ParseTuple(args, "|i:_getframe", &depth)) 307 return NULL; 308 309 while (depth > 0 && f != NULL) { 310 f = f->f_back; 311 --depth; 312 } 313 if (f == NULL) { 314 PyErr_SetString(PyExc_ValueError, 315 "call stack is not deep enough"); 316 return NULL; 317 } 318 Py_INCREF(f); 319 return (PyObject*)f; 320} 321 322 323#ifdef Py_TRACE_REFS 324/* Defined in objects.c because it uses static globals if that file */ 325extern PyObject *_Py_GetObjects(PyObject *, PyObject *); 326#endif 327 328#ifdef DYNAMIC_EXECUTION_PROFILE 329/* Defined in ceval.c because it uses static globals if that file */ 330extern PyObject *_Py_GetDXProfile(PyObject *, PyObject *); 331#endif 332 333static PyMethodDef sys_methods[] = { 334 /* Might as well keep this in alphabetic order */ 335 {"exc_info", sys_exc_info, 1, exc_info_doc}, 336 {"exit", sys_exit, 0, exit_doc}, 337 {"getdefaultencoding", sys_getdefaultencoding, 1, 338 getdefaultencoding_doc}, 339#ifdef COUNT_ALLOCS 340 {"getcounts", sys_getcounts, 1}, 341#endif 342#ifdef DYNAMIC_EXECUTION_PROFILE 343 {"getdxp", _Py_GetDXProfile, 1}, 344#endif 345#ifdef Py_TRACE_REFS 346 {"getobjects", _Py_GetObjects, 1}, 347 {"gettotalrefcount", sys_gettotalrefcount, 1}, 348#endif 349 {"getrefcount", sys_getrefcount, 1, getrefcount_doc}, 350 {"getrecursionlimit", sys_getrecursionlimit, 1, 351 getrecursionlimit_doc}, 352 {"_getframe", sys_getframe, 1, getframe_doc}, 353#ifdef USE_MALLOPT 354 {"mdebug", sys_mdebug, 1}, 355#endif 356 {"setdefaultencoding", sys_setdefaultencoding, 1, 357 setdefaultencoding_doc}, 358 {"setcheckinterval", sys_setcheckinterval, 1, 359 setcheckinterval_doc}, 360 {"setprofile", sys_setprofile, 0, setprofile_doc}, 361 {"setrecursionlimit", sys_setrecursionlimit, 1, 362 setrecursionlimit_doc}, 363 {"settrace", sys_settrace, 0, settrace_doc}, 364 {NULL, NULL} /* sentinel */ 365}; 366 367static PyObject * 368list_builtin_module_names(void) 369{ 370 PyObject *list = PyList_New(0); 371 int i; 372 if (list == NULL) 373 return NULL; 374 for (i = 0; PyImport_Inittab[i].name != NULL; i++) { 375 PyObject *name = PyString_FromString( 376 PyImport_Inittab[i].name); 377 if (name == NULL) 378 break; 379 PyList_Append(list, name); 380 Py_DECREF(name); 381 } 382 if (PyList_Sort(list) != 0) { 383 Py_DECREF(list); 384 list = NULL; 385 } 386 if (list) { 387 PyObject *v = PyList_AsTuple(list); 388 Py_DECREF(list); 389 list = v; 390 } 391 return list; 392} 393 394static PyObject *warnoptions = NULL; 395 396void 397PySys_ResetWarnOptions(void) 398{ 399 if (warnoptions == NULL || !PyList_Check(warnoptions)) 400 return; 401 PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL); 402} 403 404void 405PySys_AddWarnOption(char *s) 406{ 407 PyObject *str; 408 409 if (warnoptions == NULL || !PyList_Check(warnoptions)) { 410 Py_XDECREF(warnoptions); 411 warnoptions = PyList_New(0); 412 if (warnoptions == NULL) 413 return; 414 } 415 str = PyString_FromString(s); 416 if (str != NULL) { 417 PyList_Append(warnoptions, str); 418 Py_DECREF(str); 419 } 420} 421 422/* XXX This doc string is too long to be a single string literal in VC++ 5.0. 423 Two literals concatenated works just fine. If you have a K&R compiler 424 or other abomination that however *does* understand longer strings, 425 get rid of the !!! comment in the middle and the quotes that surround it. */ 426static char sys_doc[] = 427"This module provides access to some objects used or maintained by the\n\ 428interpreter and to functions that interact strongly with the interpreter.\n\ 429\n\ 430Dynamic objects:\n\ 431\n\ 432argv -- command line arguments; argv[0] is the script pathname if known\n\ 433path -- module search path; path[0] is the script directory, else ''\n\ 434modules -- dictionary of loaded modules\n\ 435exitfunc -- you may set this to a function to be called when Python exits\n\ 436\n\ 437stdin -- standard input file object; used by raw_input() and input()\n\ 438stdout -- standard output file object; used by the print statement\n\ 439stderr -- standard error object; used for error messages\n\ 440 By assigning another file object (or an object that behaves like a file)\n\ 441 to one of these, it is possible to redirect all of the interpreter's I/O.\n\ 442\n\ 443last_type -- type of last uncaught exception\n\ 444last_value -- value of last uncaught exception\n\ 445last_traceback -- traceback of last uncaught exception\n\ 446 These three are only available in an interactive session after a\n\ 447 traceback has been printed.\n\ 448\n\ 449exc_type -- type of exception currently being handled\n\ 450exc_value -- value of exception currently being handled\n\ 451exc_traceback -- traceback of exception currently being handled\n\ 452 The function exc_info() should be used instead of these three,\n\ 453 because it is thread-safe.\n\ 454" 455#ifndef MS_WIN16 456/* Concatenating string here */ 457"\n\ 458Static objects:\n\ 459\n\ 460maxint -- the largest supported integer (the smallest is -maxint-1)\n\ 461builtin_module_names -- tuple of module names built into this intepreter\n\ 462version -- the version of this interpreter as a string\n\ 463version_info -- version information as a tuple\n\ 464hexversion -- version information encoded as a single integer\n\ 465copyright -- copyright notice pertaining to this interpreter\n\ 466platform -- platform identifier\n\ 467executable -- pathname of this Python interpreter\n\ 468prefix -- prefix used to find the Python library\n\ 469exec_prefix -- prefix used to find the machine-specific Python library\n\ 470dllhandle -- [Windows only] integer handle of the Python DLL\n\ 471winver -- [Windows only] version number of the Python DLL\n\ 472__stdin__ -- the original stdin; don't use!\n\ 473__stdout__ -- the original stdout; don't use!\n\ 474__stderr__ -- the original stderr; don't use!\n\ 475\n\ 476Functions:\n\ 477\n\ 478exc_info() -- return thread-safe information about the current exception\n\ 479exit() -- exit the interpreter by raising SystemExit\n\ 480getrefcount() -- return the reference count for an object (plus one :-)\n\ 481getrecursionlimit() -- return the max recursion depth for the interpreter\n\ 482setcheckinterval() -- control how often the interpreter checks for events\n\ 483setprofile() -- set the global profiling function\n\ 484setrecursionlimit() -- set the max recursion depth for the interpreter\n\ 485settrace() -- set the global debug tracing function\n\ 486" 487#endif 488/* end of sys_doc */ ; 489 490PyObject * 491_PySys_Init(void) 492{ 493 PyObject *m, *v, *sysdict; 494 PyObject *sysin, *sysout, *syserr; 495 char *s; 496 497 m = Py_InitModule3("sys", sys_methods, sys_doc); 498 sysdict = PyModule_GetDict(m); 499 500 sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL); 501 sysout = PyFile_FromFile(stdout, "<stdout>", "w", NULL); 502 syserr = PyFile_FromFile(stderr, "<stderr>", "w", NULL); 503 if (PyErr_Occurred()) 504 return NULL; 505 PyDict_SetItemString(sysdict, "stdin", sysin); 506 PyDict_SetItemString(sysdict, "stdout", sysout); 507 PyDict_SetItemString(sysdict, "stderr", syserr); 508 /* Make backup copies for cleanup */ 509 PyDict_SetItemString(sysdict, "__stdin__", sysin); 510 PyDict_SetItemString(sysdict, "__stdout__", sysout); 511 PyDict_SetItemString(sysdict, "__stderr__", syserr); 512 Py_XDECREF(sysin); 513 Py_XDECREF(sysout); 514 Py_XDECREF(syserr); 515 PyDict_SetItemString(sysdict, "version", 516 v = PyString_FromString(Py_GetVersion())); 517 Py_XDECREF(v); 518 PyDict_SetItemString(sysdict, "hexversion", 519 v = PyInt_FromLong(PY_VERSION_HEX)); 520 Py_XDECREF(v); 521 /* 522 * These release level checks are mutually exclusive and cover 523 * the field, so don't get too fancy with the pre-processor! 524 */ 525#if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA 526 s = "alpha"; 527#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA 528 s = "beta"; 529#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA 530 s = "candidate"; 531#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL 532 s = "final"; 533#endif 534 PyDict_SetItemString(sysdict, "version_info", 535 v = Py_BuildValue("iiisi", PY_MAJOR_VERSION, 536 PY_MINOR_VERSION, 537 PY_MICRO_VERSION, s, 538 PY_RELEASE_SERIAL)); 539 Py_XDECREF(v); 540 PyDict_SetItemString(sysdict, "copyright", 541 v = PyString_FromString(Py_GetCopyright())); 542 Py_XDECREF(v); 543 PyDict_SetItemString(sysdict, "platform", 544 v = PyString_FromString(Py_GetPlatform())); 545 Py_XDECREF(v); 546 PyDict_SetItemString(sysdict, "executable", 547 v = PyString_FromString(Py_GetProgramFullPath())); 548 Py_XDECREF(v); 549 PyDict_SetItemString(sysdict, "prefix", 550 v = PyString_FromString(Py_GetPrefix())); 551 Py_XDECREF(v); 552 PyDict_SetItemString(sysdict, "exec_prefix", 553 v = PyString_FromString(Py_GetExecPrefix())); 554 Py_XDECREF(v); 555 PyDict_SetItemString(sysdict, "maxint", 556 v = PyInt_FromLong(PyInt_GetMax())); 557 Py_XDECREF(v); 558 PyDict_SetItemString(sysdict, "builtin_module_names", 559 v = list_builtin_module_names()); 560 Py_XDECREF(v); 561 { 562 /* Assumes that longs are at least 2 bytes long. 563 Should be safe! */ 564 unsigned long number = 1; 565 char *value; 566 567 s = (char *) &number; 568 if (s[0] == 0) 569 value = "big"; 570 else 571 value = "little"; 572 PyDict_SetItemString(sysdict, "byteorder", 573 v = PyString_FromString(value)); 574 Py_XDECREF(v); 575 } 576#ifdef MS_COREDLL 577 PyDict_SetItemString(sysdict, "dllhandle", 578 v = PyLong_FromVoidPtr(PyWin_DLLhModule)); 579 Py_XDECREF(v); 580 PyDict_SetItemString(sysdict, "winver", 581 v = PyString_FromString(PyWin_DLLVersionString)); 582 Py_XDECREF(v); 583#endif 584 if (warnoptions == NULL) { 585 warnoptions = PyList_New(0); 586 } 587 else { 588 Py_INCREF(warnoptions); 589 } 590 if (warnoptions != NULL) { 591 PyDict_SetItemString(sysdict, "warnoptions", v = warnoptions); 592 Py_DECREF(v); 593 } 594 595 if (PyErr_Occurred()) 596 return NULL; 597 return m; 598} 599 600static PyObject * 601makepathobject(char *path, int delim) 602{ 603 int i, n; 604 char *p; 605 PyObject *v, *w; 606 607 n = 1; 608 p = path; 609 while ((p = strchr(p, delim)) != NULL) { 610 n++; 611 p++; 612 } 613 v = PyList_New(n); 614 if (v == NULL) 615 return NULL; 616 for (i = 0; ; i++) { 617 p = strchr(path, delim); 618 if (p == NULL) 619 p = strchr(path, '\0'); /* End of string */ 620 w = PyString_FromStringAndSize(path, (int) (p - path)); 621 if (w == NULL) { 622 Py_DECREF(v); 623 return NULL; 624 } 625 PyList_SetItem(v, i, w); 626 if (*p == '\0') 627 break; 628 path = p+1; 629 } 630 return v; 631} 632 633void 634PySys_SetPath(char *path) 635{ 636 PyObject *v; 637 if ((v = makepathobject(path, DELIM)) == NULL) 638 Py_FatalError("can't create sys.path"); 639 if (PySys_SetObject("path", v) != 0) 640 Py_FatalError("can't assign sys.path"); 641 Py_DECREF(v); 642} 643 644static PyObject * 645makeargvobject(int argc, char **argv) 646{ 647 PyObject *av; 648 if (argc <= 0 || argv == NULL) { 649 /* Ensure at least one (empty) argument is seen */ 650 static char *empty_argv[1] = {""}; 651 argv = empty_argv; 652 argc = 1; 653 } 654 av = PyList_New(argc); 655 if (av != NULL) { 656 int i; 657 for (i = 0; i < argc; i++) { 658 PyObject *v = PyString_FromString(argv[i]); 659 if (v == NULL) { 660 Py_DECREF(av); 661 av = NULL; 662 break; 663 } 664 PyList_SetItem(av, i, v); 665 } 666 } 667 return av; 668} 669 670void 671PySys_SetArgv(int argc, char **argv) 672{ 673 PyObject *av = makeargvobject(argc, argv); 674 PyObject *path = PySys_GetObject("path"); 675 if (av == NULL) 676 Py_FatalError("no mem for sys.argv"); 677 if (PySys_SetObject("argv", av) != 0) 678 Py_FatalError("can't assign sys.argv"); 679 if (path != NULL) { 680 char *argv0 = argv[0]; 681 char *p = NULL; 682 int n = 0; 683 PyObject *a; 684#ifdef HAVE_READLINK 685 char link[MAXPATHLEN+1]; 686 char argv0copy[2*MAXPATHLEN+1]; 687 int nr = 0; 688 if (argc > 0 && argv0 != NULL) 689 nr = readlink(argv0, link, MAXPATHLEN); 690 if (nr > 0) { 691 /* It's a symlink */ 692 link[nr] = '\0'; 693 if (link[0] == SEP) 694 argv0 = link; /* Link to absolute path */ 695 else if (strchr(link, SEP) == NULL) 696 ; /* Link without path */ 697 else { 698 /* Must join(dirname(argv0), link) */ 699 char *q = strrchr(argv0, SEP); 700 if (q == NULL) 701 argv0 = link; /* argv0 without path */ 702 else { 703 /* Must make a copy */ 704 strcpy(argv0copy, argv0); 705 q = strrchr(argv0copy, SEP); 706 strcpy(q+1, link); 707 argv0 = argv0copy; 708 } 709 } 710 } 711#endif /* HAVE_READLINK */ 712#if SEP == '\\' /* Special case for MS filename syntax */ 713 if (argc > 0 && argv0 != NULL) { 714 char *q; 715 p = strrchr(argv0, SEP); 716 /* Test for alternate separator */ 717 q = strrchr(p ? p : argv0, '/'); 718 if (q != NULL) 719 p = q; 720 if (p != NULL) { 721 n = p + 1 - argv0; 722 if (n > 1 && p[-1] != ':') 723 n--; /* Drop trailing separator */ 724 } 725 } 726#else /* All other filename syntaxes */ 727 if (argc > 0 && argv0 != NULL) 728 p = strrchr(argv0, SEP); 729 if (p != NULL) { 730 n = p + 1 - argv0; 731#if SEP == '/' /* Special case for Unix filename syntax */ 732 if (n > 1) 733 n--; /* Drop trailing separator */ 734#endif /* Unix */ 735 } 736#endif /* All others */ 737 a = PyString_FromStringAndSize(argv0, n); 738 if (a == NULL) 739 Py_FatalError("no mem for sys.path insertion"); 740 if (PyList_Insert(path, 0, a) < 0) 741 Py_FatalError("sys.path.insert(0) failed"); 742 Py_DECREF(a); 743 } 744 Py_DECREF(av); 745} 746 747 748/* APIs to write to sys.stdout or sys.stderr using a printf-like interface. 749 Adapted from code submitted by Just van Rossum. 750 751 PySys_WriteStdout(format, ...) 752 PySys_WriteStderr(format, ...) 753 754 The first function writes to sys.stdout; the second to sys.stderr. When 755 there is a problem, they write to the real (C level) stdout or stderr; 756 no exceptions are raised. 757 758 Both take a printf-style format string as their first argument followed 759 by a variable length argument list determined by the format string. 760 761 *** WARNING *** 762 763 The format should limit the total size of the formatted output string to 764 1000 bytes. In particular, this means that no unrestricted "%s" formats 765 should occur; these should be limited using "%.<N>s where <N> is a 766 decimal number calculated so that <N> plus the maximum size of other 767 formatted text does not exceed 1000 bytes. Also watch out for "%f", 768 which can print hundreds of digits for very large numbers. 769 770 */ 771 772static void 773mywrite(char *name, FILE *fp, const char *format, va_list va) 774{ 775 PyObject *file; 776 PyObject *error_type, *error_value, *error_traceback; 777 778 PyErr_Fetch(&error_type, &error_value, &error_traceback); 779 file = PySys_GetObject(name); 780 if (file == NULL || PyFile_AsFile(file) == fp) 781 vfprintf(fp, format, va); 782 else { 783 char buffer[1001]; 784 if (vsprintf(buffer, format, va) >= sizeof(buffer)) 785 Py_FatalError("PySys_WriteStdout/err: buffer overrun"); 786 if (PyFile_WriteString(buffer, file) != 0) { 787 PyErr_Clear(); 788 fputs(buffer, fp); 789 } 790 } 791 PyErr_Restore(error_type, error_value, error_traceback); 792} 793 794void 795PySys_WriteStdout(const char *format, ...) 796{ 797 va_list va; 798 799 va_start(va, format); 800 mywrite("stdout", stdout, format, va); 801 va_end(va); 802} 803 804void 805PySys_WriteStderr(const char *format, ...) 806{ 807 va_list va; 808 809 va_start(va, format); 810 mywrite("stderr", stderr, format, va); 811 va_end(va); 812} 813