Python/sysmodule.c

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