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 "structseq.h"

    19 #include "code.h"

    20 #include "frameobject.h"

    21 #include "eval.h"

    22 

    23 #include "osdefs.h"

    24 

    25 #ifdef MS_WINDOWS

    26 #define WIN32_LEAN_AND_MEAN

    27 #include "windows.h"

    28 #endif /* MS_WINDOWS */

    29 

    30 #ifdef MS_COREDLL

    31 extern void *PyWin_DLLhModule;

    32 /* A string loaded from the DLL at startup: */

    33 extern const char *PyWin_DLLVersionString;

    34 #endif

    35 

    36 #ifdef __VMS

    37 #include <unixlib.h>

    38 #endif

    39 

    40 #ifdef MS_WINDOWS

    41 #include <windows.h>

    42 #endif

    43 

    44 #ifdef HAVE_LANGINFO_H

    45 #include <locale.h>

    46 #include <langinfo.h>

    47 #endif

    48 

    49 PyObject *

    50 PySys_GetObject(char *name)

    51 {

    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 }

    58 

    59 FILE *

    60 PySys_GetFile(char *name, FILE *def)

    61 {

    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 }

    70 

    71 int

    72 PySys_SetObject(char *name, PyObject *v)

    73 {

    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 }

    85 

    86 static PyObject *

    87 sys_displayhook(PyObject *self, PyObject *o)

    88 {

    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 }

   125 

   126 PyDoc_STRVAR(displayhook_doc,

   127 "displayhook(object) -> None\n"

   128 "\n"

   129 "Print an object to sys.stdout and also save it in __builtin__.\n"

   130 );

   131 

   132 static PyObject *

   133 sys_excepthook(PyObject* self, PyObject* args)

   134 {

   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 }

   142 

   143 PyDoc_STRVAR(excepthook_doc,

   144 "excepthook(exctype, value, traceback) -> None\n"

   145 "\n"

   146 "Handle an exception by displaying it with a traceback on sys.stderr.\n"

   147 );

   148 

   149 static PyObject *

   150 sys_exc_info(PyObject *self, PyObject *noargs)

   151 {

   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 }

   161 

   162 PyDoc_STRVAR(exc_info_doc,

   163 "exc_info() -> (type, value, traceback)\n\

   164 \n\

   165 Return information about the most recent exception caught by an except\n\

   166 clause in the current stack frame or in an older stack frame."

   167 );

   168 

   169 static PyObject *

   170 sys_exc_clear(PyObject *self, PyObject *noargs)

   171 {

   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 }

   196 

   197 PyDoc_STRVAR(exc_clear_doc,

   198 "exc_clear() -> None\n\

   199 \n\

   200 Clear global information on the current exception.  Subsequent calls to\n\

   201 exc_info() will return (None,None,None) until another exception is raised\n\

   202 in the current thread or the execution stack returns to a frame where\n\

   203 another exception is being handled."

   204 );

   205 

   206 static PyObject *

   207 sys_exit(PyObject *self, PyObject *args)

   208 {

   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 }

   216 

   217 PyDoc_STRVAR(exit_doc,

   218 "exit([status])\n\

   219 \n\

   220 Exit the interpreter by raising SystemExit(status).\n\

   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\

   223 If it is another kind of object, it will be printed and the system\n\

   224 exit status will be one (i.e., failure)."

   225 );

   226 

   227 #ifdef Py_USING_UNICODE

   228 

   229 static PyObject *

   230 sys_getdefaultencoding(PyObject *self)

   231 {

   232 	return PyString_FromString(PyUnicode_GetDefaultEncoding());

   233 }

   234 

   235 PyDoc_STRVAR(getdefaultencoding_doc,

   236 "getdefaultencoding() -> string\n\

   237 \n\

   238 Return the current default string encoding used by the Unicode \n\

   239 implementation."

   240 );

   241 

   242 static PyObject *

   243 sys_setdefaultencoding(PyObject *self, PyObject *args)

   244 {

   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 }

   253 

   254 PyDoc_STRVAR(setdefaultencoding_doc,

   255 "setdefaultencoding(encoding)\n\

   256 \n\

   257 Set the current default string encoding used by the Unicode implementation."

   258 );

   259 

   260 static PyObject *

   261 sys_getfilesystemencoding(PyObject *self)

   262 {

   263 	if (Py_FileSystemDefaultEncoding)

   264 		return PyString_FromString(Py_FileSystemDefaultEncoding);

   265 	Py_INCREF(Py_None);

   266 	return Py_None;

   267 }

   268 

   269 PyDoc_STRVAR(getfilesystemencoding_doc,

   270 "getfilesystemencoding() -> string\n\

   271 \n\

   272 Return the encoding used to convert Unicode filenames in\n\

   273 operating system filenames."

   274 );

   275 

   276 #endif

   277 

   278 /*

   279  * Cached interned string objects used for calling the profile and

   280  * trace functions.  Initialized by trace_init().

   281  */

   282 static PyObject *whatstrings[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};

   283 

   284 static int

   285 trace_init(void)

   286 {

   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 }

   301 

   302 

   303 static PyObject *

   304 call_trampoline(PyThreadState *tstate, PyObject* callback,

   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 }

   334 

   335 static int

   336 profile_trampoline(PyObject *self, PyFrameObject *frame,

   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 }

   352 

   353 static int

   354 trace_trampoline(PyObject *self, PyFrameObject *frame,

   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 }

   385 

   386 static PyObject *

   387 sys_settrace(PyObject *self, PyObject *args)

   388 {

   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 }

   398 

   399 PyDoc_STRVAR(settrace_doc,

   400 "settrace(function)\n\

   401 \n\

   402 Set the global debug tracing function.  It will be called on each\n\

   403 function call.  See the debugger chapter in the library manual."

   404 );

   405 

   406 static PyObject *

   407 sys_gettrace(PyObject *self, PyObject *args)

   408 {

   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 }

   417 

   418 PyDoc_STRVAR(gettrace_doc,

   419 "gettrace()\n\

   420 \n\

   421 Return the global debug tracing function set with sys.settrace.\n\

   422 See the debugger chapter in the library manual."

   423 );

   424 

   425 static PyObject *

   426 sys_setprofile(PyObject *self, PyObject *args)

   427 {

   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 }

   437 

   438 PyDoc_STRVAR(setprofile_doc,

   439 "setprofile(function)\n\

   440 \n\

   441 Set the profiling function.  It will be called on each function call\n\

   442 and return.  See the profiler chapter in the library manual."

   443 );

   444 

   445 static PyObject *

   446 sys_getprofile(PyObject *self, PyObject *args)

   447 {

   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 }

   456 

   457 PyDoc_STRVAR(getprofile_doc,

   458 "getprofile()\n\

   459 \n\

   460 Return the profiling function set with sys.setprofile.\n\

   461 See the profiler chapter in the library manual."

   462 );

   463 

   464 static PyObject *

   465 sys_setcheckinterval(PyObject *self, PyObject *args)

   466 {

   467 	if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval))

   468 		return NULL;

   469 	Py_INCREF(Py_None);

   470 	return Py_None;

   471 }

   472 

   473 PyDoc_STRVAR(setcheckinterval_doc,

   474 "setcheckinterval(n)\n\

   475 \n\

   476 Tell the Python interpreter to check for asynchronous events every\n\

   477 n instructions.  This also affects how often thread switches occur."

   478 );

   479 

   480 static PyObject *

   481 sys_getcheckinterval(PyObject *self, PyObject *args)

   482 {

   483 	return PyInt_FromLong(_Py_CheckInterval);

   484 }

   485 

   486 PyDoc_STRVAR(getcheckinterval_doc,

   487 "getcheckinterval() -> current check interval; see setcheckinterval()."

   488 );

   489 

   490 #ifdef WITH_TSC

   491 static PyObject *

   492 sys_settscdump(PyObject *self, PyObject *args)

   493 {

   494 	int bool;

   495 	PyThreadState *tstate = PyThreadState_Get();

   496 

   497 	if (!PyArg_ParseTuple(args, "i:settscdump", &bool))

   498 		return NULL;

   499 	if (bool)

   500 		tstate->interp->tscdump = 1;

   501 	else

   502 		tstate->interp->tscdump = 0;

   503 	Py_INCREF(Py_None);

   504 	return Py_None;

   505 

   506 }

   507 

   508 PyDoc_STRVAR(settscdump_doc,

   509 "settscdump(bool)\n\

   510 \n\

   511 If true, tell the Python interpreter to dump VM measurements to\n\

   512 stderr.  If false, turn off dump.  The measurements are based on the\n\

   513 processor's time-stamp counter."

   514 );

   515 #endif /* TSC */

   516 

   517 static PyObject *

   518 sys_setrecursionlimit(PyObject *self, PyObject *args)

   519 {

   520 	int new_limit;

   521 	if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit))

   522 		return NULL;

   523 	if (new_limit <= 0) {

   524 		PyErr_SetString(PyExc_ValueError,

   525 				"recursion limit must be positive");

   526 		return NULL;

   527 	}

   528 	Py_SetRecursionLimit(new_limit);

   529 	Py_INCREF(Py_None);

   530 	return Py_None;

   531 }

   532 

   533 PyDoc_STRVAR(setrecursionlimit_doc,

   534 "setrecursionlimit(n)\n\

   535 \n\

   536 Set the maximum depth of the Python interpreter stack to n.  This\n\

   537 limit prevents infinite recursion from causing an overflow of the C\n\

   538 stack and crashing Python.  The highest possible limit is platform-\n\

   539 dependent."

   540 );

   541 

   542 static PyObject *

   543 sys_getrecursionlimit(PyObject *self)

   544 {

   545 	return PyInt_FromLong(Py_GetRecursionLimit());

   546 }

   547 

   548 PyDoc_STRVAR(getrecursionlimit_doc,

   549 "getrecursionlimit()\n\

   550 \n\

   551 Return the current value of the recursion limit, the maximum depth\n\

   552 of the Python interpreter stack.  This limit prevents infinite\n\

   553 recursion from causing an overflow of the C stack and crashing Python."

   554 );

   555 

   556 #ifdef MS_WINDOWS

   557 PyDoc_STRVAR(getwindowsversion_doc,

   558 "getwindowsversion()\n\

   559 \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 );

   566 

   567 static PyObject *

   568 sys_getwindowsversion(PyObject *self)

   569 {

   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);

   580 }

   581 

   582 #endif /* MS_WINDOWS */

   583 

   584 #ifdef HAVE_DLOPEN

   585 static PyObject *

   586 sys_setdlopenflags(PyObject *self, PyObject *args)

   587 {

   588 	int new_val;

   589         PyThreadState *tstate = PyThreadState_GET();

   590 	if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val))

   591 		return NULL;

   592         if (!tstate)

   593 		return NULL;

   594         tstate->interp->dlopenflags = new_val;

   595 	Py_INCREF(Py_None);

   596 	return Py_None;

   597 }

   598 

   599 PyDoc_STRVAR(setdlopenflags_doc,

   600 "setdlopenflags(n) -> None\n\

   601 \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 );

   608 

   609 static PyObject *

   610 sys_getdlopenflags(PyObject *self, PyObject *args)

   611 {

   612         PyThreadState *tstate = PyThreadState_GET();

   613         if (!tstate)

   614 		return NULL;

   615         return PyInt_FromLong(tstate->interp->dlopenflags);

   616 }

   617 

   618 PyDoc_STRVAR(getdlopenflags_doc,

   619 "getdlopenflags() -> int\n\

   620 \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

   625 

   626 #ifdef USE_MALLOPT

   627 /* Link with -lmalloc (or -lmpc) on an SGI */

   628 #include <malloc.h>

   629 

   630 static PyObject *

   631 sys_mdebug(PyObject *self, PyObject *args)

   632 {

   633 	int flag;

   634 	if (!PyArg_ParseTuple(args, "i:mdebug", &flag))

   635 		return NULL;

   636 	mallopt(M_DEBUG, flag);

   637 	Py_INCREF(Py_None);

   638 	return Py_None;

   639 }

   640 #endif /* USE_MALLOPT */

   641 

   642 static PyObject *

   643 sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds)

   644 {

   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;

   705 }

   706 

   707 PyDoc_STRVAR(getsizeof_doc,

   708 "getsizeof(object, default) -> int\n\

   709 \n\

   710 Return the size of object in bytes.");

   711 

   712 static PyObject *

   713 sys_getrefcount(PyObject *self, PyObject *arg)

   714 {

   715 	return PyInt_FromSsize_t(arg->ob_refcnt);

   716 }

   717 

   718 #ifdef Py_REF_DEBUG

   719 static PyObject *

   720 sys_gettotalrefcount(PyObject *self)

   721 {

   722 	return PyInt_FromSsize_t(_Py_GetRefTotal());

   723 }

   724 #endif /* Py_REF_DEBUG */

   725 

   726 PyDoc_STRVAR(getrefcount_doc,

   727 "getrefcount(object) -> integer\n\

   728 \n\

   729 Return the reference count of object.  The count returned is generally\n\

   730 one higher than you might expect, because it includes the (temporary)\n\

   731 reference as an argument to getrefcount()."

   732 );

   733 

   734 #ifdef COUNT_ALLOCS

   735 static PyObject *

   736 sys_getcounts(PyObject *self)

   737 {

   738 	extern PyObject *get_counts(void);

   739 

   740 	return get_counts();

   741 }

   742 #endif

   743 

   744 PyDoc_STRVAR(getframe_doc,

   745 "_getframe([depth]) -> frameobject\n\

   746 \n\

   747 Return a frame object from the call stack.  If optional integer depth is\n\

   748 given, return the frame object that many calls below the top of the stack.\n\

   749 If that is deeper than the call stack, ValueError is raised.  The default\n\

   750 for depth is zero, returning the frame at the top of the call stack.\n\

   751 \n\

   752 This function should be used for internal and specialized\n\

   753 purposes only."

   754 );

   755 

   756 static PyObject *

   757 sys_getframe(PyObject *self, PyObject *args)

   758 {

   759 	PyFrameObject *f = PyThreadState_GET()->frame;

   760 	int depth = -1;

   761 

   762 	if (!PyArg_ParseTuple(args, "|i:_getframe", &depth))

   763 		return NULL;

   764 

   765 	while (depth > 0 && f != NULL) {

   766 		f = f->f_back;

   767 		--depth;

   768 	}

   769 	if (f == NULL) {

   770 		PyErr_SetString(PyExc_ValueError,

   771 				"call stack is not deep enough");

   772 		return NULL;

   773 	}

   774 	Py_INCREF(f);

   775 	return (PyObject*)f;

   776 }

   777 

   778 PyDoc_STRVAR(current_frames_doc,

   779 "_current_frames() -> dictionary\n\

   780 \n\

   781 Return a dictionary mapping each current thread T's thread id to T's\n\

   782 current stack frame.\n\

   783 \n\

   784 This function should be used for specialized purposes only."

   785 );

   786 

   787 static PyObject *

   788 sys_current_frames(PyObject *self, PyObject *noargs)

   789 {

   790 	return _PyThread_CurrentFrames();

   791 }

   792 

   793 PyDoc_STRVAR(call_tracing_doc,

   794 "call_tracing(func, args) -> object\n\

   795 \n\

   796 Call func(*args), while tracing is enabled.  The tracing state is\n\

   797 saved, and restored afterwards.  This is intended to be called from\n\

   798 a debugger from a checkpoint, to recursively debug some other code."

   799 );

   800 

   801 static PyObject *

   802 sys_call_tracing(PyObject *self, PyObject *args)

   803 {

   804 	PyObject *func, *funcargs;

   805 	if (!PyArg_UnpackTuple(args, "call_tracing", 2, 2, &func, &funcargs))

   806 		return NULL;

   807 	return _PyEval_CallTracing(func, funcargs);

   808 }

   809 

   810 PyDoc_STRVAR(callstats_doc,

   811 "callstats() -> tuple of integers\n\

   812 \n\

   813 Return a tuple of function call statistics, if CALL_PROFILE was defined\n\

   814 when Python was built.  Otherwise, return None.\n\

   815 \n\

   816 When enabled, this function returns detailed, implementation-specific\n\

   817 details about the number of function calls executed. The return value is\n\

   818 a 11-tuple where the entries in the tuple are counts of:\n\

   819 0. all function calls\n\

   820 1. calls to PyFunction_Type objects\n\

   821 2. PyFunction calls that do not create an argument tuple\n\

   822 3. PyFunction calls that do not create an argument tuple\n\

   823    and bypass PyEval_EvalCodeEx()\n\

   824 4. PyMethod calls\n\

   825 5. PyMethod calls on bound methods\n\

   826 6. PyType calls\n\

   827 7. PyCFunction calls\n\

   828 8. generator calls\n\

   829 9. All other calls\n\

   830 10. Number of stack pops performed by call_function()"

   831 );

   832 

   833 #ifdef __cplusplus

   834 extern "C" {

   835 #endif

   836 

   837 #ifdef Py_TRACE_REFS

   838 /* Defined in objects.c because it uses static globals if that file */

   839 extern PyObject *_Py_GetObjects(PyObject *, PyObject *);

   840 #endif

   841 

   842 #ifdef DYNAMIC_EXECUTION_PROFILE

   843 /* Defined in ceval.c because it uses static globals if that file */

   844 extern PyObject *_Py_GetDXProfile(PyObject *,  PyObject *);

   845 #endif

   846 

   847 #ifdef __cplusplus

   848 }

   849 #endif

   850 

   851 static PyObject *

   852 sys_clear_type_cache(PyObject* self, PyObject* args)

   853 {

   854 	PyType_ClearCache();

   855 	Py_RETURN_NONE;

   856 }

   857 

   858 PyDoc_STRVAR(sys_clear_type_cache__doc__,

   859 "_clear_type_cache() -> None\n\

   860 Clear the internal type lookup cache.");

   861 

   862 

   863 static PyMethodDef sys_methods[] = {

   864 	/* Might as well keep this in alphabetic order */

   865 	{"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS,

   866 	 callstats_doc},

   867 	{"_clear_type_cache",	sys_clear_type_cache,	  METH_NOARGS,

   868 	 sys_clear_type_cache__doc__},

   869 	{"_current_frames", sys_current_frames, METH_NOARGS,

   870 	 current_frames_doc},

   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},

   876 #ifdef Py_USING_UNICODE

   877 	{"getdefaultencoding", (PyCFunction)sys_getdefaultencoding,

   878 	 METH_NOARGS, getdefaultencoding_doc},

   879 #endif

   880 #ifdef HAVE_DLOPEN

   881 	{"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS,

   882 	 getdlopenflags_doc},

   883 #endif

   884 #ifdef COUNT_ALLOCS

   885 	{"getcounts",	(PyCFunction)sys_getcounts, METH_NOARGS},

   886 #endif

   887 #ifdef DYNAMIC_EXECUTION_PROFILE

   888 	{"getdxp",	_Py_GetDXProfile, METH_VARARGS},

   889 #endif

   890 #ifdef Py_USING_UNICODE

   891 	{"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding,

   892 	 METH_NOARGS, getfilesystemencoding_doc},

   893 #endif

   894 #ifdef Py_TRACE_REFS

   895 	{"getobjects",	_Py_GetObjects, METH_VARARGS},

   896 #endif

   897 #ifdef Py_REF_DEBUG

   898 	{"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS},

   899 #endif

   900 	{"getrefcount",	(PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},

   901 	{"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS,

   902 	 getrecursionlimit_doc},

   903 	{"getsizeof",   (PyCFunction)sys_getsizeof,

   904 	 METH_VARARGS | METH_KEYWORDS, getsizeof_doc},

   905 	{"_getframe", sys_getframe, METH_VARARGS, getframe_doc},

   906 #ifdef MS_WINDOWS

   907 	{"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,

   908 	 getwindowsversion_doc},

   909 #endif /* MS_WINDOWS */

   910 #ifdef USE_MALLOPT

   911 	{"mdebug",	sys_mdebug, METH_VARARGS},

   912 #endif

   913 #ifdef Py_USING_UNICODE

   914 	{"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS,

   915 	 setdefaultencoding_doc},

   916 #endif

   917 	{"setcheckinterval",	sys_setcheckinterval, METH_VARARGS,

   918 	 setcheckinterval_doc},

   919 	{"getcheckinterval",	sys_getcheckinterval, METH_NOARGS,

   920 	 getcheckinterval_doc},

   921 #ifdef HAVE_DLOPEN

   922 	{"setdlopenflags", sys_setdlopenflags, METH_VARARGS,

   923 	 setdlopenflags_doc},

   924 #endif

   925 	{"setprofile",	sys_setprofile, METH_O, setprofile_doc},

   926 	{"getprofile",	sys_getprofile, METH_NOARGS, getprofile_doc},

   927 	{"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS,

   928 	 setrecursionlimit_doc},

   929 #ifdef WITH_TSC

   930 	{"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc},

   931 #endif

   932 	{"settrace",	sys_settrace, METH_O, settrace_doc},

   933 	{"gettrace",	sys_gettrace, METH_NOARGS, gettrace_doc},

   934 	{"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},

   935 	{NULL,		NULL}		/* sentinel */

   936 };

   937 

   938 static PyObject *

   939 list_builtin_module_names(void)

   940 {

   941 	PyObject *list = PyList_New(0);

   942 	int i;

   943 	if (list == NULL)

   944 		return NULL;

   945 	for (i = 0; PyImport_Inittab[i].name != NULL; i++) {

   946 		PyObject *name = PyString_FromString(

   947 			PyImport_Inittab[i].name);

   948 		if (name == NULL)

   949 			break;

   950 		PyList_Append(list, name);

   951 		Py_DECREF(name);

   952 	}

   953 	if (PyList_Sort(list) != 0) {

   954 		Py_DECREF(list);

   955 		list = NULL;

   956 	}

   957 	if (list) {

   958 		PyObject *v = PyList_AsTuple(list);

   959 		Py_DECREF(list);

   960 		list = v;

   961 	}

   962 	return list;

   963 }

   964 

   965 static PyObject *warnoptions = NULL;

   966 

   967 void

   968 PySys_ResetWarnOptions(void)

   969 {

   970 	if (warnoptions == NULL || !PyList_Check(warnoptions))

   971 		return;

   972 	PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);

   973 }

   974 

   975 void

   976 PySys_AddWarnOption(char *s)

   977 {

   978 	PyObject *str;

   979 

   980 	if (warnoptions == NULL || !PyList_Check(warnoptions)) {

   981 		Py_XDECREF(warnoptions);

   982 		warnoptions = PyList_New(0);

   983 		if (warnoptions == NULL)

   984 			return;

   985 	}

   986 	str = PyString_FromString(s);

   987 	if (str != NULL) {

   988 		PyList_Append(warnoptions, str);

   989 		Py_DECREF(str);

   990 	}

   991 }

   992 

   993 int

   994 PySys_HasWarnOptions(void)

   995 {

   996     return (warnoptions != NULL && (PyList_Size(warnoptions) > 0)) ? 1 : 0;

   997 }

   998 

   999 /* XXX This doc string is too long to be a single string literal in VC++ 5.0.

  1000    Two literals concatenated works just fine.  If you have a K&R compiler

  1001    or other abomination that however *does* understand longer strings,

  1002    get rid of the !!! comment in the middle and the quotes that surround it. */

  1003 PyDoc_VAR(sys_doc) =

  1004 PyDoc_STR(

  1005 "This module provides access to some objects used or maintained by the\n\

  1006 interpreter and to functions that interact strongly with the interpreter.\n\

  1007 \n\

  1008 Dynamic objects:\n\

  1009 \n\

  1010 argv -- command line arguments; argv[0] is the script pathname if known\n\

  1011 path -- module search path; path[0] is the script directory, else ''\n\

  1012 modules -- dictionary of loaded modules\n\

  1013 \n\

  1014 displayhook -- called to show results in an interactive session\n\

  1015 excepthook -- called to handle any uncaught exception other than SystemExit\n\

  1016   To customize printing in an interactive session or to install a custom\n\

  1017   top-level exception handler, assign other functions to replace these.\n\

  1018 \n\

  1019 exitfunc -- if sys.exitfunc exists, this routine is called when Python exits\n\

  1020   Assigning to sys.exitfunc is deprecated; use the atexit module instead.\n\

  1021 \n\

  1022 stdin -- standard input file object; used by raw_input() and input()\n\

  1023 stdout -- standard output file object; used by the print statement\n\

  1024 stderr -- standard error object; used for error messages\n\

  1025   By assigning other file objects (or objects that behave like files)\n\

  1026   to these, it is possible to redirect all of the interpreter's I/O.\n\

  1027 \n\

  1028 last_type -- type of last uncaught exception\n\

  1029 last_value -- value of last uncaught exception\n\

  1030 last_traceback -- traceback of last uncaught exception\n\

  1031   These three are only available in an interactive session after a\n\

  1032   traceback has been printed.\n\

  1033 \n\

  1034 exc_type -- type of exception currently being handled\n\

  1035 exc_value -- value of exception currently being handled\n\

  1036 exc_traceback -- traceback of exception currently being handled\n\

  1037   The function exc_info() should be used instead of these three,\n\

  1038   because it is thread-safe.\n\

  1039 "

  1040 )

  1041 /* concatenating string here */

  1042 PyDoc_STR(

  1043 "\n\

  1044 Static objects:\n\

  1045 \n\

  1046 maxint -- the largest supported integer (the smallest is -maxint-1)\n\

  1047 maxsize -- the largest supported length of containers.\n\

  1048 maxunicode -- the largest supported character\n\

  1049 builtin_module_names -- tuple of module names built into this interpreter\n\

  1050 version -- the version of this interpreter as a string\n\

  1051 version_info -- version information as a tuple\n\

  1052 hexversion -- version information encoded as a single integer\n\

  1053 copyright -- copyright notice pertaining to this interpreter\n\

  1054 platform -- platform identifier\n\

  1055 executable -- pathname of this Python interpreter\n\

  1056 prefix -- prefix used to find the Python library\n\

  1057 exec_prefix -- prefix used to find the machine-specific Python library\n\

  1058 "

  1059 )

  1060 #ifdef MS_WINDOWS

  1061 /* concatenating string here */

  1062 PyDoc_STR(

  1063 "dllhandle -- [Windows only] integer handle of the Python DLL\n\

  1064 winver -- [Windows only] version number of the Python DLL\n\

  1065 "

  1066 )

  1067 #endif /* MS_WINDOWS */

  1068 PyDoc_STR(

  1069 "__stdin__ -- the original stdin; don't touch!\n\

  1070 __stdout__ -- the original stdout; don't touch!\n\

  1071 __stderr__ -- the original stderr; don't touch!\n\

  1072 __displayhook__ -- the original displayhook; don't touch!\n\

  1073 __excepthook__ -- the original excepthook; don't touch!\n\

  1074 \n\

  1075 Functions:\n\

  1076 \n\

  1077 displayhook() -- print an object to the screen, and save it in __builtin__._\n\

  1078 excepthook() -- print an exception and its traceback to sys.stderr\n\

  1079 exc_info() -- return thread-safe information about the current exception\n\

  1080 exc_clear() -- clear the exception state for the current thread\n\

  1081 exit() -- exit the interpreter by raising SystemExit\n\

  1082 getdlopenflags() -- returns flags to be used for dlopen() calls\n\

  1083 getprofile() -- get the global profiling function\n\

  1084 getrefcount() -- return the reference count for an object (plus one :-)\n\

  1085 getrecursionlimit() -- return the max recursion depth for the interpreter\n\

  1086 getsizeof() -- return the size of an object in bytes\n\

  1087 gettrace() -- get the global debug tracing function\n\

  1088 setcheckinterval() -- control how often the interpreter checks for events\n\

  1089 setdlopenflags() -- set the flags to be used for dlopen() calls\n\

  1090 setprofile() -- set the global profiling function\n\

  1091 setrecursionlimit() -- set the max recursion depth for the interpreter\n\

  1092 settrace() -- set the global debug tracing function\n\

  1093 "

  1094 )

  1095 /* end of sys_doc */ ;

  1096 

  1097 static int

  1098 _check_and_flush (FILE *stream)

  1099 {

  1100   int prev_fail = ferror (stream);

  1101   return fflush (stream) || prev_fail ? EOF : 0;

  1102 }

  1103 

  1104 /* 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/r261/Python/sysmodule.c $";

  1107 static int svn_initialized;

  1108 static char patchlevel_revision[50]; /* Just the number */

  1109 static char branch[50];

  1110 static char shortbranch[50];

  1111 static const char *svn_revision;

  1112 

  1113 static void

  1114 svnversion_init(void)

  1115 {

  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, '/');