Line data Source code
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 1707 : PySys_GetObject(char *name)
51 : {
52 1707 : PyThreadState *tstate = PyThreadState_GET();
53 1707 : PyObject *sd = tstate->interp->sysdict;
54 1707 : if (sd == NULL)
55 0 : return NULL;
56 1707 : return PyDict_GetItemString(sd, name);
57 : }
58 :
59 : FILE *
60 0 : PySys_GetFile(char *name, FILE *def)
61 : {
62 0 : FILE *fp = NULL;
63 0 : PyObject *v = PySys_GetObject(name);
64 0 : if (v != NULL && PyFile_Check(v))
65 0 : fp = PyFile_AsFile(v);
66 0 : if (fp == NULL)
67 0 : fp = def;
68 0 : return fp;
69 : }
70 :
71 : int
72 5850 : PySys_SetObject(char *name, PyObject *v)
73 : {
74 5850 : PyThreadState *tstate = PyThreadState_GET();
75 5850 : PyObject *sd = tstate->interp->sysdict;
76 5850 : if (v == NULL) {
77 405 : if (PyDict_GetItemString(sd, name) == NULL)
78 0 : return 0;
79 : else
80 405 : return PyDict_DelItemString(sd, name);
81 : }
82 : else
83 5445 : return PyDict_SetItemString(sd, name, v);
84 : }
85 :
86 : static PyObject *
87 0 : sys_displayhook(PyObject *self, PyObject *o)
88 : {
89 : PyObject *outf;
90 0 : PyInterpreterState *interp = PyThreadState_GET()->interp;
91 0 : PyObject *modules = interp->modules;
92 0 : PyObject *builtins = PyDict_GetItemString(modules, "__builtin__");
93 :
94 0 : if (builtins == NULL) {
95 0 : PyErr_SetString(PyExc_RuntimeError, "lost __builtin__");
96 0 : 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 0 : if (o == Py_None) {
103 0 : Py_INCREF(Py_None);
104 0 : return Py_None;
105 : }
106 0 : if (PyObject_SetAttrString(builtins, "_", Py_None) != 0)
107 0 : return NULL;
108 0 : if (Py_FlushLine() != 0)
109 0 : return NULL;
110 0 : outf = PySys_GetObject("stdout");
111 0 : if (outf == NULL) {
112 0 : PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
113 0 : return NULL;
114 : }
115 0 : if (PyFile_WriteObject(o, outf, 0) != 0)
116 0 : return NULL;
117 0 : PyFile_SoftSpace(outf, 1);
118 0 : if (Py_FlushLine() != 0)
119 0 : return NULL;
120 0 : if (PyObject_SetAttrString(builtins, "_", o) != 0)
121 0 : return NULL;
122 0 : Py_INCREF(Py_None);
123 0 : 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 0 : sys_excepthook(PyObject* self, PyObject* args)
134 : {
135 : PyObject *exc, *value, *tb;
136 0 : if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb))
137 0 : return NULL;
138 0 : PyErr_Display(exc, value, tb);
139 0 : Py_INCREF(Py_None);
140 0 : 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 3 : sys_exc_info(PyObject *self, PyObject *noargs)
151 : {
152 : PyThreadState *tstate;
153 3 : tstate = PyThreadState_GET();
154 9 : return Py_BuildValue(
155 : "(OOO)",
156 3 : tstate->exc_type != NULL ? tstate->exc_type : Py_None,
157 3 : tstate->exc_value != NULL ? tstate->exc_value : Py_None,
158 3 : 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 0 : sys_exc_clear(PyObject *self, PyObject *noargs)
171 : {
172 : PyThreadState *tstate;
173 : PyObject *tmp_type, *tmp_value, *tmp_tb;
174 :
175 0 : if (PyErr_WarnPy3k("sys.exc_clear() not supported in 3.x; "
176 0 : "use except clauses", 1) < 0)
177 0 : return NULL;
178 :
179 0 : tstate = PyThreadState_GET();
180 0 : tmp_type = tstate->exc_type;
181 0 : tmp_value = tstate->exc_value;
182 0 : tmp_tb = tstate->exc_traceback;
183 0 : tstate->exc_type = NULL;
184 0 : tstate->exc_value = NULL;
185 0 : tstate->exc_traceback = NULL;
186 0 : Py_XDECREF(tmp_type);
187 0 : Py_XDECREF(tmp_value);
188 0 : Py_XDECREF(tmp_tb);
189 : /* For b/w compatibility */
190 0 : PySys_SetObject("exc_type", Py_None);
191 0 : PySys_SetObject("exc_value", Py_None);
192 0 : PySys_SetObject("exc_traceback", Py_None);
193 0 : Py_INCREF(Py_None);
194 0 : 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 3 : sys_exit(PyObject *self, PyObject *args)
208 : {
209 3 : PyObject *exit_code = 0;
210 3 : if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code))
211 0 : return NULL;
212 : /* Raise SystemExit so callers may catch it or clean up. */
213 3 : PyErr_SetObject(PyExc_SystemExit, exit_code);
214 3 : 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 an integer, 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 0 : sys_getdefaultencoding(PyObject *self)
231 : {
232 0 : 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 0 : sys_setdefaultencoding(PyObject *self, PyObject *args)
244 : {
245 : char *encoding;
246 0 : if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding))
247 0 : return NULL;
248 0 : if (PyUnicode_SetDefaultEncoding(encoding))
249 0 : return NULL;
250 0 : Py_INCREF(Py_None);
251 0 : 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 0 : sys_getfilesystemencoding(PyObject *self)
262 : {
263 0 : if (Py_FileSystemDefaultEncoding)
264 0 : return PyString_FromString(Py_FileSystemDefaultEncoding);
265 0 : Py_INCREF(Py_None);
266 0 : 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 0 : 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 0 : for (i = 0; i < 7; ++i) {
292 0 : if (whatstrings[i] == NULL) {
293 0 : name = PyString_InternFromString(whatnames[i]);
294 0 : if (name == NULL)
295 0 : return -1;
296 0 : whatstrings[i] = name;
297 : }
298 : }
299 0 : return 0;
300 : }
301 :
302 :
303 : static PyObject *
304 0 : call_trampoline(PyThreadState *tstate, PyObject* callback,
305 : PyFrameObject *frame, int what, PyObject *arg)
306 : {
307 0 : PyObject *args = PyTuple_New(3);
308 : PyObject *whatstr;
309 : PyObject *result;
310 :
311 0 : if (args == NULL)
312 0 : return NULL;
313 0 : Py_INCREF(frame);
314 0 : whatstr = whatstrings[what];
315 0 : Py_INCREF(whatstr);
316 0 : if (arg == NULL)
317 0 : arg = Py_None;
318 0 : Py_INCREF(arg);
319 0 : PyTuple_SET_ITEM(args, 0, (PyObject *)frame);
320 0 : PyTuple_SET_ITEM(args, 1, whatstr);
321 0 : PyTuple_SET_ITEM(args, 2, arg);
322 :
323 : /* call the Python-level function */
324 0 : PyFrame_FastToLocals(frame);
325 0 : result = PyEval_CallObject(callback, args);
326 0 : PyFrame_LocalsToFast(frame, 1);
327 0 : if (result == NULL)
328 0 : PyTraceBack_Here(frame);
329 :
330 : /* cleanup */
331 0 : Py_DECREF(args);
332 0 : return result;
333 : }
334 :
335 : static int
336 0 : profile_trampoline(PyObject *self, PyFrameObject *frame,
337 : int what, PyObject *arg)
338 : {
339 0 : PyThreadState *tstate = frame->f_tstate;
340 : PyObject *result;
341 :
342 0 : if (arg == NULL)
343 0 : arg = Py_None;
344 0 : result = call_trampoline(tstate, self, frame, what, arg);
345 0 : if (result == NULL) {
346 0 : PyEval_SetProfile(NULL, NULL);
347 0 : return -1;
348 : }
349 0 : Py_DECREF(result);
350 0 : return 0;
351 : }
352 :
353 : static int
354 0 : trace_trampoline(PyObject *self, PyFrameObject *frame,
355 : int what, PyObject *arg)
356 : {
357 0 : PyThreadState *tstate = frame->f_tstate;
358 : PyObject *callback;
359 : PyObject *result;
360 :
361 0 : if (what == PyTrace_CALL)
362 0 : callback = self;
363 : else
364 0 : callback = frame->f_trace;
365 0 : if (callback == NULL)
366 0 : return 0;
367 0 : result = call_trampoline(tstate, callback, frame, what, arg);
368 0 : if (result == NULL) {
369 0 : PyEval_SetTrace(NULL, NULL);
370 0 : Py_CLEAR(frame->f_trace);
371 0 : return -1;
372 : }
373 0 : if (result != Py_None) {
374 0 : PyObject *temp = frame->f_trace;
375 0 : frame->f_trace = NULL;
376 0 : Py_XDECREF(temp);
377 0 : frame->f_trace = result;
378 : }
379 : else {
380 0 : Py_DECREF(result);
381 : }
382 0 : return 0;
383 : }
384 :
385 : static PyObject *
386 0 : sys_settrace(PyObject *self, PyObject *args)
387 : {
388 0 : if (trace_init() == -1)
389 0 : return NULL;
390 0 : if (args == Py_None)
391 0 : PyEval_SetTrace(NULL, NULL);
392 : else
393 0 : PyEval_SetTrace(trace_trampoline, args);
394 0 : Py_INCREF(Py_None);
395 0 : return Py_None;
396 : }
397 :
398 : PyDoc_STRVAR(settrace_doc,
399 : "settrace(function)\n\
400 : \n\
401 : Set the global debug tracing function. It will be called on each\n\
402 : function call. See the debugger chapter in the library manual."
403 : );
404 :
405 : static PyObject *
406 0 : sys_gettrace(PyObject *self, PyObject *args)
407 : {
408 0 : PyThreadState *tstate = PyThreadState_GET();
409 0 : PyObject *temp = tstate->c_traceobj;
410 :
411 0 : if (temp == NULL)
412 0 : temp = Py_None;
413 0 : Py_INCREF(temp);
414 0 : return temp;
415 : }
416 :
417 : PyDoc_STRVAR(gettrace_doc,
418 : "gettrace()\n\
419 : \n\
420 : Return the global debug tracing function set with sys.settrace.\n\
421 : See the debugger chapter in the library manual."
422 : );
423 :
424 : static PyObject *
425 0 : sys_setprofile(PyObject *self, PyObject *args)
426 : {
427 0 : if (trace_init() == -1)
428 0 : return NULL;
429 0 : if (args == Py_None)
430 0 : PyEval_SetProfile(NULL, NULL);
431 : else
432 0 : PyEval_SetProfile(profile_trampoline, args);
433 0 : Py_INCREF(Py_None);
434 0 : return Py_None;
435 : }
436 :
437 : PyDoc_STRVAR(setprofile_doc,
438 : "setprofile(function)\n\
439 : \n\
440 : Set the profiling function. It will be called on each function call\n\
441 : and return. See the profiler chapter in the library manual."
442 : );
443 :
444 : static PyObject *
445 0 : sys_getprofile(PyObject *self, PyObject *args)
446 : {
447 0 : PyThreadState *tstate = PyThreadState_GET();
448 0 : PyObject *temp = tstate->c_profileobj;
449 :
450 0 : if (temp == NULL)
451 0 : temp = Py_None;
452 0 : Py_INCREF(temp);
453 0 : return temp;
454 : }
455 :
456 : PyDoc_STRVAR(getprofile_doc,
457 : "getprofile()\n\
458 : \n\
459 : Return the profiling function set with sys.setprofile.\n\
460 : See the profiler chapter in the library manual."
461 : );
462 :
463 : static PyObject *
464 0 : sys_setcheckinterval(PyObject *self, PyObject *args)
465 : {
466 0 : if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval))
467 0 : return NULL;
468 0 : _Py_Ticker = _Py_CheckInterval;
469 0 : Py_INCREF(Py_None);
470 0 : 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 0 : sys_getcheckinterval(PyObject *self, PyObject *args)
482 : {
483 0 : 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 0 : sys_setrecursionlimit(PyObject *self, PyObject *args)
519 : {
520 : int new_limit;
521 0 : if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit))
522 0 : return NULL;
523 0 : if (new_limit <= 0) {
524 0 : PyErr_SetString(PyExc_ValueError,
525 : "recursion limit must be positive");
526 0 : return NULL;
527 : }
528 0 : Py_SetRecursionLimit(new_limit);
529 0 : Py_INCREF(Py_None);
530 0 : 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 0 : sys_getrecursionlimit(PyObject *self)
544 : {
545 0 : 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 as a named tuple.\n\
561 : The members are named: major, minor, build, platform, service_pack,\n\
562 : service_pack_major, service_pack_minor, suite_mask, and product_type. For\n\
563 : backward compatibility, only the first 5 items are available by indexing.\n\
564 : All elements are numbers, except service_pack which is a string. Platform\n\
565 : may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP/Vista/7,\n\
566 : 3 for Windows CE. Product_type may be 1 for a workstation, 2 for a domain\n\
567 : controller, 3 for a server."
568 : );
569 :
570 : static PyTypeObject WindowsVersionType = {0, 0, 0, 0, 0, 0};
571 :
572 : static PyStructSequence_Field windows_version_fields[] = {
573 : {"major", "Major version number"},
574 : {"minor", "Minor version number"},
575 : {"build", "Build number"},
576 : {"platform", "Operating system platform"},
577 : {"service_pack", "Latest Service Pack installed on the system"},
578 : {"service_pack_major", "Service Pack major version number"},
579 : {"service_pack_minor", "Service Pack minor version number"},
580 : {"suite_mask", "Bit mask identifying available product suites"},
581 : {"product_type", "System product type"},
582 : {0}
583 : };
584 :
585 : static PyStructSequence_Desc windows_version_desc = {
586 : "sys.getwindowsversion", /* name */
587 : getwindowsversion_doc, /* doc */
588 : windows_version_fields, /* fields */
589 : 5 /* For backward compatibility,
590 : only the first 5 items are accessible
591 : via indexing, the rest are name only */
592 : };
593 :
594 : static PyObject *
595 : sys_getwindowsversion(PyObject *self)
596 : {
597 : PyObject *version;
598 : int pos = 0;
599 : OSVERSIONINFOEX ver;
600 : ver.dwOSVersionInfoSize = sizeof(ver);
601 : if (!GetVersionEx((OSVERSIONINFO*) &ver))
602 : return PyErr_SetFromWindowsErr(0);
603 :
604 : version = PyStructSequence_New(&WindowsVersionType);
605 : if (version == NULL)
606 : return NULL;
607 :
608 : PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMajorVersion));
609 : PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMinorVersion));
610 : PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwBuildNumber));
611 : PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwPlatformId));
612 : PyStructSequence_SET_ITEM(version, pos++, PyString_FromString(ver.szCSDVersion));
613 : PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMajor));
614 : PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMinor));
615 : PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wSuiteMask));
616 : PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wProductType));
617 :
618 : if (PyErr_Occurred()) {
619 : Py_DECREF(version);
620 : return NULL;
621 : }
622 : return version;
623 : }
624 :
625 : #endif /* MS_WINDOWS */
626 :
627 : #ifdef HAVE_DLOPEN
628 : static PyObject *
629 0 : sys_setdlopenflags(PyObject *self, PyObject *args)
630 : {
631 : int new_val;
632 0 : PyThreadState *tstate = PyThreadState_GET();
633 0 : if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val))
634 0 : return NULL;
635 0 : if (!tstate)
636 0 : return NULL;
637 0 : tstate->interp->dlopenflags = new_val;
638 0 : Py_INCREF(Py_None);
639 0 : return Py_None;
640 : }
641 :
642 : PyDoc_STRVAR(setdlopenflags_doc,
643 : "setdlopenflags(n) -> None\n\
644 : \n\
645 : Set the flags used by the interpreter for dlopen calls, such as when the\n\
646 : interpreter loads extension modules. Among other things, this will enable\n\
647 : a lazy resolving of symbols when importing a module, if called as\n\
648 : sys.setdlopenflags(0). To share symbols across extension modules, call as\n\
649 : sys.setdlopenflags(ctypes.RTLD_GLOBAL). Symbolic names for the flag modules\n\
650 : can be either found in the ctypes module, or in the DLFCN module. If DLFCN\n\
651 : is not available, it can be generated from /usr/include/dlfcn.h using the\n\
652 : h2py script.");
653 :
654 : static PyObject *
655 0 : sys_getdlopenflags(PyObject *self, PyObject *args)
656 : {
657 0 : PyThreadState *tstate = PyThreadState_GET();
658 0 : if (!tstate)
659 0 : return NULL;
660 0 : return PyInt_FromLong(tstate->interp->dlopenflags);
661 : }
662 :
663 : PyDoc_STRVAR(getdlopenflags_doc,
664 : "getdlopenflags() -> int\n\
665 : \n\
666 : Return the current value of the flags that are used for dlopen calls.\n\
667 : The flag constants are defined in the ctypes and DLFCN modules.");
668 :
669 : #endif /* HAVE_DLOPEN */
670 :
671 : #ifdef USE_MALLOPT
672 : /* Link with -lmalloc (or -lmpc) on an SGI */
673 : #include <malloc.h>
674 :
675 : static PyObject *
676 : sys_mdebug(PyObject *self, PyObject *args)
677 : {
678 : int flag;
679 : if (!PyArg_ParseTuple(args, "i:mdebug", &flag))
680 : return NULL;
681 : mallopt(M_DEBUG, flag);
682 : Py_INCREF(Py_None);
683 : return Py_None;
684 : }
685 : #endif /* USE_MALLOPT */
686 :
687 : size_t
688 0 : _PySys_GetSizeOf(PyObject *o)
689 : {
690 : static PyObject *str__sizeof__ = NULL;
691 0 : PyObject *res = NULL;
692 : Py_ssize_t size;
693 :
694 : /* Make sure the type is initialized. float gets initialized late */
695 0 : if (PyType_Ready(Py_TYPE(o)) < 0)
696 0 : return (size_t)-1;
697 :
698 : /* Instance of old-style class */
699 0 : if (PyInstance_Check(o))
700 0 : size = PyInstance_Type.tp_basicsize;
701 : /* all other objects */
702 : else {
703 0 : PyObject *method = _PyObject_LookupSpecial(o, "__sizeof__",
704 : &str__sizeof__);
705 0 : if (method == NULL) {
706 0 : if (!PyErr_Occurred())
707 0 : PyErr_Format(PyExc_TypeError,
708 : "Type %.100s doesn't define __sizeof__",
709 0 : Py_TYPE(o)->tp_name);
710 : }
711 : else {
712 0 : res = PyObject_CallFunctionObjArgs(method, NULL);
713 0 : Py_DECREF(method);
714 : }
715 :
716 0 : if (res == NULL)
717 0 : return (size_t)-1;
718 :
719 0 : size = (size_t)PyInt_AsSsize_t(res);
720 0 : Py_DECREF(res);
721 0 : if (size == -1 && PyErr_Occurred())
722 0 : return (size_t)-1;
723 : }
724 :
725 0 : if (size < 0) {
726 0 : PyErr_SetString(PyExc_ValueError, "__sizeof__() should return >= 0");
727 0 : return (size_t)-1;
728 : }
729 :
730 : /* add gc_head size */
731 0 : if (PyObject_IS_GC(o))
732 0 : return ((size_t)size) + sizeof(PyGC_Head);
733 0 : return (size_t)size;
734 : }
735 :
736 : static PyObject *
737 0 : sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds)
738 : {
739 : static char *kwlist[] = {"object", "default", 0};
740 : size_t size;
741 0 : PyObject *o, *dflt = NULL;
742 :
743 0 : if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof",
744 : kwlist, &o, &dflt))
745 0 : return NULL;
746 :
747 0 : size = _PySys_GetSizeOf(o);
748 :
749 0 : if (size == (size_t)-1 && PyErr_Occurred()) {
750 : /* Has a default value been given */
751 0 : if (dflt != NULL && PyErr_ExceptionMatches(PyExc_TypeError)) {
752 0 : PyErr_Clear();
753 0 : Py_INCREF(dflt);
754 0 : return dflt;
755 : }
756 : else
757 0 : return NULL;
758 : }
759 :
760 0 : return PyInt_FromSize_t(size);
761 : }
762 :
763 : PyDoc_STRVAR(getsizeof_doc,
764 : "getsizeof(object, default) -> int\n\
765 : \n\
766 : Return the size of object in bytes.");
767 :
768 : static PyObject *
769 0 : sys_getrefcount(PyObject *self, PyObject *arg)
770 : {
771 0 : return PyInt_FromSsize_t(arg->ob_refcnt);
772 : }
773 :
774 : #ifdef Py_REF_DEBUG
775 : static PyObject *
776 : sys_gettotalrefcount(PyObject *self)
777 : {
778 : return PyInt_FromSsize_t(_Py_GetRefTotal());
779 : }
780 : #endif /* Py_REF_DEBUG */
781 :
782 : PyDoc_STRVAR(getrefcount_doc,
783 : "getrefcount(object) -> integer\n\
784 : \n\
785 : Return the reference count of object. The count returned is generally\n\
786 : one higher than you might expect, because it includes the (temporary)\n\
787 : reference as an argument to getrefcount()."
788 : );
789 :
790 : #ifdef COUNT_ALLOCS
791 : static PyObject *
792 : sys_getcounts(PyObject *self)
793 : {
794 : extern PyObject *get_counts(void);
795 :
796 : return get_counts();
797 : }
798 : #endif
799 :
800 : PyDoc_STRVAR(getframe_doc,
801 : "_getframe([depth]) -> frameobject\n\
802 : \n\
803 : Return a frame object from the call stack. If optional integer depth is\n\
804 : given, return the frame object that many calls below the top of the stack.\n\
805 : If that is deeper than the call stack, ValueError is raised. The default\n\
806 : for depth is zero, returning the frame at the top of the call stack.\n\
807 : \n\
808 : This function should be used for internal and specialized\n\
809 : purposes only."
810 : );
811 :
812 : static PyObject *
813 27 : sys_getframe(PyObject *self, PyObject *args)
814 : {
815 27 : PyFrameObject *f = PyThreadState_GET()->frame;
816 27 : int depth = -1;
817 :
818 27 : if (!PyArg_ParseTuple(args, "|i:_getframe", &depth))
819 0 : return NULL;
820 :
821 81 : while (depth > 0 && f != NULL) {
822 27 : f = f->f_back;
823 27 : --depth;
824 : }
825 27 : if (f == NULL) {
826 0 : PyErr_SetString(PyExc_ValueError,
827 : "call stack is not deep enough");
828 0 : return NULL;
829 : }
830 27 : Py_INCREF(f);
831 27 : return (PyObject*)f;
832 : }
833 :
834 : PyDoc_STRVAR(current_frames_doc,
835 : "_current_frames() -> dictionary\n\
836 : \n\
837 : Return a dictionary mapping each current thread T's thread id to T's\n\
838 : current stack frame.\n\
839 : \n\
840 : This function should be used for specialized purposes only."
841 : );
842 :
843 : static PyObject *
844 0 : sys_current_frames(PyObject *self, PyObject *noargs)
845 : {
846 0 : return _PyThread_CurrentFrames();
847 : }
848 :
849 : PyDoc_STRVAR(call_tracing_doc,
850 : "call_tracing(func, args) -> object\n\
851 : \n\
852 : Call func(*args), while tracing is enabled. The tracing state is\n\
853 : saved, and restored afterwards. This is intended to be called from\n\
854 : a debugger from a checkpoint, to recursively debug some other code."
855 : );
856 :
857 : static PyObject *
858 0 : sys_call_tracing(PyObject *self, PyObject *args)
859 : {
860 : PyObject *func, *funcargs;
861 0 : if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs))
862 0 : return NULL;
863 0 : return _PyEval_CallTracing(func, funcargs);
864 : }
865 :
866 : PyDoc_STRVAR(callstats_doc,
867 : "callstats() -> tuple of integers\n\
868 : \n\
869 : Return a tuple of function call statistics, if CALL_PROFILE was defined\n\
870 : when Python was built. Otherwise, return None.\n\
871 : \n\
872 : When enabled, this function returns detailed, implementation-specific\n\
873 : details about the number of function calls executed. The return value is\n\
874 : a 11-tuple where the entries in the tuple are counts of:\n\
875 : 0. all function calls\n\
876 : 1. calls to PyFunction_Type objects\n\
877 : 2. PyFunction calls that do not create an argument tuple\n\
878 : 3. PyFunction calls that do not create an argument tuple\n\
879 : and bypass PyEval_EvalCodeEx()\n\
880 : 4. PyMethod calls\n\
881 : 5. PyMethod calls on bound methods\n\
882 : 6. PyType calls\n\
883 : 7. PyCFunction calls\n\
884 : 8. generator calls\n\
885 : 9. All other calls\n\
886 : 10. Number of stack pops performed by call_function()"
887 : );
888 :
889 : #ifdef __cplusplus
890 : extern "C" {
891 : #endif
892 :
893 : #ifdef Py_TRACE_REFS
894 : /* Defined in objects.c because it uses static globals if that file */
895 : extern PyObject *_Py_GetObjects(PyObject *, PyObject *);
896 : #endif
897 :
898 : #ifdef DYNAMIC_EXECUTION_PROFILE
899 : /* Defined in ceval.c because it uses static globals if that file */
900 : extern PyObject *_Py_GetDXProfile(PyObject *, PyObject *);
901 : #endif
902 :
903 : #ifdef __cplusplus
904 : }
905 : #endif
906 :
907 : static PyObject *
908 0 : sys_clear_type_cache(PyObject* self, PyObject* args)
909 : {
910 0 : PyType_ClearCache();
911 0 : Py_RETURN_NONE;
912 : }
913 :
914 : PyDoc_STRVAR(sys_clear_type_cache__doc__,
915 : "_clear_type_cache() -> None\n\
916 : Clear the internal type lookup cache.");
917 :
918 :
919 : static PyMethodDef sys_methods[] = {
920 : /* Might as well keep this in alphabetic order */
921 : {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS,
922 : callstats_doc},
923 : {"_clear_type_cache", sys_clear_type_cache, METH_NOARGS,
924 : sys_clear_type_cache__doc__},
925 : {"_current_frames", sys_current_frames, METH_NOARGS,
926 : current_frames_doc},
927 : {"displayhook", sys_displayhook, METH_O, displayhook_doc},
928 : {"exc_info", sys_exc_info, METH_NOARGS, exc_info_doc},
929 : {"exc_clear", sys_exc_clear, METH_NOARGS, exc_clear_doc},
930 : {"excepthook", sys_excepthook, METH_VARARGS, excepthook_doc},
931 : {"exit", sys_exit, METH_VARARGS, exit_doc},
932 : #ifdef Py_USING_UNICODE
933 : {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding,
934 : METH_NOARGS, getdefaultencoding_doc},
935 : #endif
936 : #ifdef HAVE_DLOPEN
937 : {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS,
938 : getdlopenflags_doc},
939 : #endif
940 : #ifdef COUNT_ALLOCS
941 : {"getcounts", (PyCFunction)sys_getcounts, METH_NOARGS},
942 : #endif
943 : #ifdef DYNAMIC_EXECUTION_PROFILE
944 : {"getdxp", _Py_GetDXProfile, METH_VARARGS},
945 : #endif
946 : #ifdef Py_USING_UNICODE
947 : {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding,
948 : METH_NOARGS, getfilesystemencoding_doc},
949 : #endif
950 : #ifdef Py_TRACE_REFS
951 : {"getobjects", _Py_GetObjects, METH_VARARGS},
952 : #endif
953 : #ifdef Py_REF_DEBUG
954 : {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS},
955 : #endif
956 : {"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
957 : {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS,
958 : getrecursionlimit_doc},
959 : {"getsizeof", (PyCFunction)sys_getsizeof,
960 : METH_VARARGS | METH_KEYWORDS, getsizeof_doc},
961 : {"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
962 : #ifdef MS_WINDOWS
963 : {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
964 : getwindowsversion_doc},
965 : #endif /* MS_WINDOWS */
966 : #ifdef USE_MALLOPT
967 : {"mdebug", sys_mdebug, METH_VARARGS},
968 : #endif
969 : #ifdef Py_USING_UNICODE
970 : {"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS,
971 : setdefaultencoding_doc},
972 : #endif
973 : {"setcheckinterval", sys_setcheckinterval, METH_VARARGS,
974 : setcheckinterval_doc},
975 : {"getcheckinterval", sys_getcheckinterval, METH_NOARGS,
976 : getcheckinterval_doc},
977 : #ifdef HAVE_DLOPEN
978 : {"setdlopenflags", sys_setdlopenflags, METH_VARARGS,
979 : setdlopenflags_doc},
980 : #endif
981 : {"setprofile", sys_setprofile, METH_O, setprofile_doc},
982 : {"getprofile", sys_getprofile, METH_NOARGS, getprofile_doc},
983 : {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS,
984 : setrecursionlimit_doc},
985 : #ifdef WITH_TSC
986 : {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc},
987 : #endif
988 : {"settrace", sys_settrace, METH_O, settrace_doc},
989 : {"gettrace", sys_gettrace, METH_NOARGS, gettrace_doc},
990 : {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},
991 : {NULL, NULL} /* sentinel */
992 : };
993 :
994 : static PyObject *
995 3 : list_builtin_module_names(void)
996 : {
997 3 : PyObject *list = PyList_New(0);
998 : int i;
999 3 : if (list == NULL)
1000 0 : return NULL;
1001 63 : for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
1002 60 : PyObject *name = PyString_FromString(
1003 60 : PyImport_Inittab[i].name);
1004 60 : if (name == NULL)
1005 0 : break;
1006 60 : PyList_Append(list, name);
1007 60 : Py_DECREF(name);
1008 : }
1009 3 : if (PyList_Sort(list) != 0) {
1010 0 : Py_DECREF(list);
1011 0 : list = NULL;
1012 : }
1013 3 : if (list) {
1014 3 : PyObject *v = PyList_AsTuple(list);
1015 3 : Py_DECREF(list);
1016 3 : list = v;
1017 : }
1018 3 : return list;
1019 : }
1020 :
1021 : static PyObject *warnoptions = NULL;
1022 :
1023 : void
1024 3 : PySys_ResetWarnOptions(void)
1025 : {
1026 3 : if (warnoptions == NULL || !PyList_Check(warnoptions))
1027 6 : return;
1028 0 : PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
1029 : }
1030 :
1031 : void
1032 0 : PySys_AddWarnOption(char *s)
1033 : {
1034 : PyObject *str;
1035 :
1036 0 : if (warnoptions == NULL || !PyList_Check(warnoptions)) {
1037 0 : Py_XDECREF(warnoptions);
1038 0 : warnoptions = PyList_New(0);
1039 0 : if (warnoptions == NULL)
1040 0 : return;
1041 : }
1042 0 : str = PyString_FromString(s);
1043 0 : if (str != NULL) {
1044 0 : PyList_Append(warnoptions, str);
1045 0 : Py_DECREF(str);
1046 : }
1047 : }
1048 :
1049 : int
1050 3 : PySys_HasWarnOptions(void)
1051 : {
1052 3 : return (warnoptions != NULL && (PyList_Size(warnoptions) > 0)) ? 1 : 0;
1053 : }
1054 :
1055 : /* XXX This doc string is too long to be a single string literal in VC++ 5.0.
1056 : Two literals concatenated works just fine. If you have a K&R compiler
1057 : or other abomination that however *does* understand longer strings,
1058 : get rid of the !!! comment in the middle and the quotes that surround it. */
1059 : PyDoc_VAR(sys_doc) =
1060 : PyDoc_STR(
1061 : "This module provides access to some objects used or maintained by the\n\
1062 : interpreter and to functions that interact strongly with the interpreter.\n\
1063 : \n\
1064 : Dynamic objects:\n\
1065 : \n\
1066 : argv -- command line arguments; argv[0] is the script pathname if known\n\
1067 : path -- module search path; path[0] is the script directory, else ''\n\
1068 : modules -- dictionary of loaded modules\n\
1069 : \n\
1070 : displayhook -- called to show results in an interactive session\n\
1071 : excepthook -- called to handle any uncaught exception other than SystemExit\n\
1072 : To customize printing in an interactive session or to install a custom\n\
1073 : top-level exception handler, assign other functions to replace these.\n\
1074 : \n\
1075 : exitfunc -- if sys.exitfunc exists, this routine is called when Python exits\n\
1076 : Assigning to sys.exitfunc is deprecated; use the atexit module instead.\n\
1077 : \n\
1078 : stdin -- standard input file object; used by raw_input() and input()\n\
1079 : stdout -- standard output file object; used by the print statement\n\
1080 : stderr -- standard error object; used for error messages\n\
1081 : By assigning other file objects (or objects that behave like files)\n\
1082 : to these, it is possible to redirect all of the interpreter's I/O.\n\
1083 : \n\
1084 : last_type -- type of last uncaught exception\n\
1085 : last_value -- value of last uncaught exception\n\
1086 : last_traceback -- traceback of last uncaught exception\n\
1087 : These three are only available in an interactive session after a\n\
1088 : traceback has been printed.\n\
1089 : \n\
1090 : exc_type -- type of exception currently being handled\n\
1091 : exc_value -- value of exception currently being handled\n\
1092 : exc_traceback -- traceback of exception currently being handled\n\
1093 : The function exc_info() should be used instead of these three,\n\
1094 : because it is thread-safe.\n\
1095 : "
1096 : )
1097 : /* concatenating string here */
1098 : PyDoc_STR(
1099 : "\n\
1100 : Static objects:\n\
1101 : \n\
1102 : float_info -- a dict with information about the float inplementation.\n\
1103 : long_info -- a struct sequence with information about the long implementation.\n\
1104 : maxint -- the largest supported integer (the smallest is -maxint-1)\n\
1105 : maxsize -- the largest supported length of containers.\n\
1106 : maxunicode -- the largest supported character\n\
1107 : builtin_module_names -- tuple of module names built into this interpreter\n\
1108 : version -- the version of this interpreter as a string\n\
1109 : version_info -- version information as a named tuple\n\
1110 : hexversion -- version information encoded as a single integer\n\
1111 : copyright -- copyright notice pertaining to this interpreter\n\
1112 : platform -- platform identifier\n\
1113 : executable -- absolute path of the executable binary of the Python interpreter\n\
1114 : prefix -- prefix used to find the Python library\n\
1115 : exec_prefix -- prefix used to find the machine-specific Python library\n\
1116 : float_repr_style -- string indicating the style of repr() output for floats\n\
1117 : "
1118 : )
1119 : #ifdef MS_WINDOWS
1120 : /* concatenating string here */
1121 : PyDoc_STR(
1122 : "dllhandle -- [Windows only] integer handle of the Python DLL\n\
1123 : winver -- [Windows only] version number of the Python DLL\n\
1124 : "
1125 : )
1126 : #endif /* MS_WINDOWS */
1127 : PyDoc_STR(
1128 : "__stdin__ -- the original stdin; don't touch!\n\
1129 : __stdout__ -- the original stdout; don't touch!\n\
1130 : __stderr__ -- the original stderr; don't touch!\n\
1131 : __displayhook__ -- the original displayhook; don't touch!\n\
1132 : __excepthook__ -- the original excepthook; don't touch!\n\
1133 : \n\
1134 : Functions:\n\
1135 : \n\
1136 : displayhook() -- print an object to the screen, and save it in __builtin__._\n\
1137 : excepthook() -- print an exception and its traceback to sys.stderr\n\
1138 : exc_info() -- return thread-safe information about the current exception\n\
1139 : exc_clear() -- clear the exception state for the current thread\n\
1140 : exit() -- exit the interpreter by raising SystemExit\n\
1141 : getdlopenflags() -- returns flags to be used for dlopen() calls\n\
1142 : getprofile() -- get the global profiling function\n\
1143 : getrefcount() -- return the reference count for an object (plus one :-)\n\
1144 : getrecursionlimit() -- return the max recursion depth for the interpreter\n\
1145 : getsizeof() -- return the size of an object in bytes\n\
1146 : gettrace() -- get the global debug tracing function\n\
1147 : setcheckinterval() -- control how often the interpreter checks for events\n\
1148 : setdlopenflags() -- set the flags to be used for dlopen() calls\n\
1149 : setprofile() -- set the global profiling function\n\
1150 : setrecursionlimit() -- set the max recursion depth for the interpreter\n\
1151 : settrace() -- set the global debug tracing function\n\
1152 : "
1153 : )
1154 : /* end of sys_doc */ ;
1155 :
1156 : static int
1157 6 : _check_and_flush (FILE *stream)
1158 : {
1159 6 : int prev_fail = ferror (stream);
1160 6 : return fflush (stream) || prev_fail ? EOF : 0;
1161 : }
1162 :
1163 : /* Subversion branch and revision management */
1164 : static int svn_initialized;
1165 : static char patchlevel_revision[50]; /* Just the number */
1166 : static char branch[50];
1167 : static char shortbranch[50];
1168 : static const char *svn_revision;
1169 :
1170 : static void
1171 3 : svnversion_init(void)
1172 : {
1173 3 : if (svn_initialized)
1174 0 : return;
1175 3 : svn_initialized = 1;
1176 3 : *patchlevel_revision = '\0';
1177 3 : strcpy(branch, "");
1178 3 : strcpy(shortbranch, "unknown");
1179 3 : svn_revision = "";
1180 3 : return;
1181 : }
1182 :
1183 : /* Return svnversion output if available.
1184 : Else return Revision of patchlevel.h if on branch.
1185 : Else return empty string */
1186 : const char*
1187 0 : Py_SubversionRevision()
1188 : {
1189 0 : svnversion_init();
1190 0 : return svn_revision;
1191 : }
1192 :
1193 : const char*
1194 0 : Py_SubversionShortBranch()
1195 : {
1196 0 : svnversion_init();
1197 0 : return shortbranch;
1198 : }
1199 :
1200 :
1201 : PyDoc_STRVAR(flags__doc__,
1202 : "sys.flags\n\
1203 : \n\
1204 : Flags provided through command line arguments or environment vars.");
1205 :
1206 : static PyTypeObject FlagsType = {0, 0, 0, 0, 0, 0};
1207 :
1208 : static PyStructSequence_Field flags_fields[] = {
1209 : {"debug", "-d"},
1210 : {"py3k_warning", "-3"},
1211 : {"division_warning", "-Q"},
1212 : {"division_new", "-Qnew"},
1213 : {"inspect", "-i"},
1214 : {"interactive", "-i"},
1215 : {"optimize", "-O or -OO"},
1216 : {"dont_write_bytecode", "-B"},
1217 : {"no_user_site", "-s"},
1218 : {"no_site", "-S"},
1219 : {"ignore_environment", "-E"},
1220 : {"tabcheck", "-t or -tt"},
1221 : {"verbose", "-v"},
1222 : #ifdef RISCOS
1223 : {"riscos_wimp", "???"},
1224 : #endif
1225 : /* {"unbuffered", "-u"}, */
1226 : {"unicode", "-U"},
1227 : /* {"skip_first", "-x"}, */
1228 : {"bytes_warning", "-b"},
1229 : {"hash_randomization", "-R"},
1230 : {0}
1231 : };
1232 :
1233 : static PyStructSequence_Desc flags_desc = {
1234 : "sys.flags", /* name */
1235 : flags__doc__, /* doc */
1236 : flags_fields, /* fields */
1237 : #ifdef RISCOS
1238 : 17
1239 : #else
1240 : 16
1241 : #endif
1242 : };
1243 :
1244 : static PyObject*
1245 3 : make_flags(void)
1246 : {
1247 3 : int pos = 0;
1248 : PyObject *seq;
1249 :
1250 3 : seq = PyStructSequence_New(&FlagsType);
1251 3 : if (seq == NULL)
1252 0 : return NULL;
1253 :
1254 : #define SetFlag(flag) \
1255 : PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag))
1256 :
1257 3 : SetFlag(Py_DebugFlag);
1258 3 : SetFlag(Py_Py3kWarningFlag);
1259 3 : SetFlag(Py_DivisionWarningFlag);
1260 3 : SetFlag(_Py_QnewFlag);
1261 3 : SetFlag(Py_InspectFlag);
1262 3 : SetFlag(Py_InteractiveFlag);
1263 3 : SetFlag(Py_OptimizeFlag);
1264 3 : SetFlag(Py_DontWriteBytecodeFlag);
1265 3 : SetFlag(Py_NoUserSiteDirectory);
1266 3 : SetFlag(Py_NoSiteFlag);
1267 3 : SetFlag(Py_IgnoreEnvironmentFlag);
1268 3 : SetFlag(Py_TabcheckFlag);
1269 3 : SetFlag(Py_VerboseFlag);
1270 : #ifdef RISCOS
1271 : SetFlag(Py_RISCOSWimpFlag);
1272 : #endif
1273 : /* SetFlag(saw_unbuffered_flag); */
1274 3 : SetFlag(Py_UnicodeFlag);
1275 : /* SetFlag(skipfirstline); */
1276 3 : SetFlag(Py_BytesWarningFlag);
1277 3 : SetFlag(Py_HashRandomizationFlag);
1278 : #undef SetFlag
1279 :
1280 3 : if (PyErr_Occurred()) {
1281 0 : Py_DECREF(seq);
1282 0 : return NULL;
1283 : }
1284 3 : return seq;
1285 : }
1286 :
1287 : PyDoc_STRVAR(version_info__doc__,
1288 : "sys.version_info\n\
1289 : \n\
1290 : Version information as a named tuple.");
1291 :
1292 : static PyTypeObject VersionInfoType = {0, 0, 0, 0, 0, 0};
1293 :
1294 : static PyStructSequence_Field version_info_fields[] = {
1295 : {"major", "Major release number"},
1296 : {"minor", "Minor release number"},
1297 : {"micro", "Patch release number"},
1298 : {"releaselevel", "'alpha', 'beta', 'candidate', or 'final'"},
1299 : {"serial", "Serial release number"},
1300 : {0}
1301 : };
1302 :
1303 : static PyStructSequence_Desc version_info_desc = {
1304 : "sys.version_info", /* name */
1305 : version_info__doc__, /* doc */
1306 : version_info_fields, /* fields */
1307 : 5
1308 : };
1309 :
1310 : static PyObject *
1311 3 : make_version_info(void)
1312 : {
1313 : PyObject *version_info;
1314 : char *s;
1315 3 : int pos = 0;
1316 :
1317 3 : version_info = PyStructSequence_New(&VersionInfoType);
1318 3 : if (version_info == NULL) {
1319 0 : return NULL;
1320 : }
1321 :
1322 : /*
1323 : * These release level checks are mutually exclusive and cover
1324 : * the field, so don't get too fancy with the pre-processor!
1325 : */
1326 : #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
1327 : s = "alpha";
1328 : #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
1329 : s = "beta";
1330 : #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
1331 : s = "candidate";
1332 : #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
1333 3 : s = "final";
1334 : #endif
1335 :
1336 : #define SetIntItem(flag) \
1337 : PyStructSequence_SET_ITEM(version_info, pos++, PyInt_FromLong(flag))
1338 : #define SetStrItem(flag) \
1339 : PyStructSequence_SET_ITEM(version_info, pos++, PyString_FromString(flag))
1340 :
1341 3 : SetIntItem(PY_MAJOR_VERSION);
1342 3 : SetIntItem(PY_MINOR_VERSION);
1343 3 : SetIntItem(PY_MICRO_VERSION);
1344 3 : SetStrItem(s);
1345 3 : SetIntItem(PY_RELEASE_SERIAL);
1346 : #undef SetIntItem
1347 : #undef SetStrItem
1348 :
1349 3 : if (PyErr_Occurred()) {
1350 0 : Py_CLEAR(version_info);
1351 0 : return NULL;
1352 : }
1353 3 : return version_info;
1354 : }
1355 :
1356 : PyObject *
1357 3 : _PySys_Init(void)
1358 : {
1359 : PyObject *m, *v, *sysdict;
1360 : PyObject *sysin, *sysout, *syserr;
1361 : char *s;
1362 :
1363 3 : m = Py_InitModule3("sys", sys_methods, sys_doc);
1364 3 : if (m == NULL)
1365 0 : return NULL;
1366 3 : sysdict = PyModule_GetDict(m);
1367 : #define SET_SYS_FROM_STRING(key, value) \
1368 : v = value; \
1369 : if (v != NULL) \
1370 : PyDict_SetItemString(sysdict, key, v); \
1371 : Py_XDECREF(v)
1372 :
1373 : /* Check that stdin is not a directory
1374 : Using shell redirection, you can redirect stdin to a directory,
1375 : crashing the Python interpreter. Catch this common mistake here
1376 : and output a useful error message. Note that under MS Windows,
1377 : the shell already prevents that. */
1378 : #if !defined(MS_WINDOWS)
1379 : {
1380 : struct stat sb;
1381 6 : if (fstat(fileno(stdin), &sb) == 0 &&
1382 3 : S_ISDIR(sb.st_mode)) {
1383 : /* There's nothing more we can do. */
1384 : /* Py_FatalError() will core dump, so just exit. */
1385 0 : PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
1386 0 : exit(EXIT_FAILURE);
1387 : }
1388 : }
1389 : #endif
1390 :
1391 : /* Closing the standard FILE* if sys.std* goes aways causes problems
1392 : * for embedded Python usages. Closing them when somebody explicitly
1393 : * invokes .close() might be possible, but the FAQ promises they get
1394 : * never closed. However, we still need to get write errors when
1395 : * writing fails (e.g. because stdout is redirected), so we flush the
1396 : * streams and check for errors before the file objects are deleted.
1397 : * On OS X, fflush()ing stdin causes an error, so we exempt stdin
1398 : * from that procedure.
1399 : */
1400 3 : sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL);
1401 3 : sysout = PyFile_FromFile(stdout, "<stdout>", "w", _check_and_flush);
1402 3 : syserr = PyFile_FromFile(stderr, "<stderr>", "w", _check_and_flush);
1403 3 : if (PyErr_Occurred())
1404 0 : return NULL;
1405 :
1406 3 : PyDict_SetItemString(sysdict, "stdin", sysin);
1407 3 : PyDict_SetItemString(sysdict, "stdout", sysout);
1408 3 : PyDict_SetItemString(sysdict, "stderr", syserr);
1409 : /* Make backup copies for cleanup */
1410 3 : PyDict_SetItemString(sysdict, "__stdin__", sysin);
1411 3 : PyDict_SetItemString(sysdict, "__stdout__", sysout);
1412 3 : PyDict_SetItemString(sysdict, "__stderr__", syserr);
1413 3 : PyDict_SetItemString(sysdict, "__displayhook__",
1414 : PyDict_GetItemString(sysdict, "displayhook"));
1415 3 : PyDict_SetItemString(sysdict, "__excepthook__",
1416 : PyDict_GetItemString(sysdict, "excepthook"));
1417 3 : Py_XDECREF(sysin);
1418 3 : Py_XDECREF(sysout);
1419 3 : Py_XDECREF(syserr);
1420 :
1421 3 : SET_SYS_FROM_STRING("version",
1422 : PyString_FromString(Py_GetVersion()));
1423 3 : SET_SYS_FROM_STRING("hexversion",
1424 : PyInt_FromLong(PY_VERSION_HEX));
1425 3 : svnversion_init();
1426 3 : SET_SYS_FROM_STRING("subversion",
1427 : Py_BuildValue("(ssz)", "CPython", branch,
1428 : svn_revision));
1429 3 : SET_SYS_FROM_STRING("_mercurial",
1430 : Py_BuildValue("(szz)", "CPython", _Py_hgidentifier(),
1431 : _Py_hgversion()));
1432 3 : SET_SYS_FROM_STRING("dont_write_bytecode",
1433 : PyBool_FromLong(Py_DontWriteBytecodeFlag));
1434 3 : SET_SYS_FROM_STRING("api_version",
1435 : PyInt_FromLong(PYTHON_API_VERSION));
1436 3 : SET_SYS_FROM_STRING("copyright",
1437 : PyString_FromString(Py_GetCopyright()));
1438 3 : SET_SYS_FROM_STRING("platform",
1439 : PyString_FromString(Py_GetPlatform()));
1440 3 : SET_SYS_FROM_STRING("executable",
1441 : PyString_FromString(Py_GetProgramFullPath()));
1442 3 : SET_SYS_FROM_STRING("prefix",
1443 : PyString_FromString(Py_GetPrefix()));
1444 3 : SET_SYS_FROM_STRING("exec_prefix",
1445 : PyString_FromString(Py_GetExecPrefix()));
1446 3 : SET_SYS_FROM_STRING("maxsize",
1447 : PyInt_FromSsize_t(PY_SSIZE_T_MAX));
1448 3 : SET_SYS_FROM_STRING("maxint",
1449 : PyInt_FromLong(PyInt_GetMax()));
1450 3 : SET_SYS_FROM_STRING("py3kwarning",
1451 : PyBool_FromLong(Py_Py3kWarningFlag));
1452 3 : SET_SYS_FROM_STRING("float_info",
1453 : PyFloat_GetInfo());
1454 3 : SET_SYS_FROM_STRING("long_info",
1455 : PyLong_GetInfo());
1456 : #ifdef Py_USING_UNICODE
1457 3 : SET_SYS_FROM_STRING("maxunicode",
1458 : PyInt_FromLong(PyUnicode_GetMax()));
1459 : #endif
1460 3 : SET_SYS_FROM_STRING("builtin_module_names",
1461 : list_builtin_module_names());
1462 : {
1463 : /* Assumes that longs are at least 2 bytes long.
1464 : Should be safe! */
1465 3 : unsigned long number = 1;
1466 : char *value;
1467 :
1468 3 : s = (char *) &number;
1469 3 : if (s[0] == 0)
1470 0 : value = "big";
1471 : else
1472 3 : value = "little";
1473 3 : SET_SYS_FROM_STRING("byteorder",
1474 : PyString_FromString(value));
1475 : }
1476 : #ifdef MS_COREDLL
1477 : SET_SYS_FROM_STRING("dllhandle",
1478 : PyLong_FromVoidPtr(PyWin_DLLhModule));
1479 : SET_SYS_FROM_STRING("winver",
1480 : PyString_FromString(PyWin_DLLVersionString));
1481 : #endif
1482 3 : if (warnoptions == NULL) {
1483 3 : warnoptions = PyList_New(0);
1484 : }
1485 : else {
1486 0 : Py_INCREF(warnoptions);
1487 : }
1488 3 : if (warnoptions != NULL) {
1489 3 : PyDict_SetItemString(sysdict, "warnoptions", warnoptions);
1490 : }
1491 :
1492 : /* version_info */
1493 3 : if (VersionInfoType.tp_name == 0)
1494 3 : PyStructSequence_InitType(&VersionInfoType, &version_info_desc);
1495 3 : SET_SYS_FROM_STRING("version_info", make_version_info());
1496 : /* prevent user from creating new instances */
1497 3 : VersionInfoType.tp_init = NULL;
1498 3 : VersionInfoType.tp_new = NULL;
1499 :
1500 : /* flags */
1501 3 : if (FlagsType.tp_name == 0)
1502 3 : PyStructSequence_InitType(&FlagsType, &flags_desc);
1503 3 : SET_SYS_FROM_STRING("flags", make_flags());
1504 : /* prevent user from creating new instances */
1505 3 : FlagsType.tp_init = NULL;
1506 3 : FlagsType.tp_new = NULL;
1507 :
1508 :
1509 : #if defined(MS_WINDOWS)
1510 : /* getwindowsversion */
1511 : if (WindowsVersionType.tp_name == 0)
1512 : PyStructSequence_InitType(&WindowsVersionType, &windows_version_desc);
1513 : /* prevent user from creating new instances */
1514 : WindowsVersionType.tp_init = NULL;
1515 : WindowsVersionType.tp_new = NULL;
1516 : #endif
1517 :
1518 : /* float repr style: 0.03 (short) vs 0.029999999999999999 (legacy) */
1519 : #ifndef PY_NO_SHORT_FLOAT_REPR
1520 3 : SET_SYS_FROM_STRING("float_repr_style",
1521 : PyString_FromString("short"));
1522 : #else
1523 : SET_SYS_FROM_STRING("float_repr_style",
1524 : PyString_FromString("legacy"));
1525 : #endif
1526 :
1527 : #undef SET_SYS_FROM_STRING
1528 3 : if (PyErr_Occurred())
1529 0 : return NULL;
1530 3 : return m;
1531 : }
1532 :
1533 : static PyObject *
1534 3 : makepathobject(char *path, int delim)
1535 : {
1536 : int i, n;
1537 : char *p;
1538 : PyObject *v, *w;
1539 :
1540 3 : n = 1;
1541 3 : p = path;
1542 21 : while ((p = strchr(p, delim)) != NULL) {
1543 15 : n++;
1544 15 : p++;
1545 : }
1546 3 : v = PyList_New(n);
1547 3 : if (v == NULL)
1548 0 : return NULL;
1549 18 : for (i = 0; ; i++) {
1550 18 : p = strchr(path, delim);
1551 18 : if (p == NULL)
1552 3 : p = strchr(path, '\0'); /* End of string */
1553 18 : w = PyString_FromStringAndSize(path, (Py_ssize_t) (p - path));
1554 18 : if (w == NULL) {
1555 0 : Py_DECREF(v);
1556 0 : return NULL;
1557 : }
1558 18 : PyList_SetItem(v, i, w);
1559 18 : if (*p == '\0')
1560 3 : break;
1561 15 : path = p+1;
1562 15 : }
1563 3 : return v;
1564 : }
1565 :
1566 : void
1567 3 : PySys_SetPath(char *path)
1568 : {
1569 : PyObject *v;
1570 3 : if ((v = makepathobject(path, DELIM)) == NULL)
1571 0 : Py_FatalError("can't create sys.path");
1572 3 : if (PySys_SetObject("path", v) != 0)
1573 0 : Py_FatalError("can't assign sys.path");
1574 3 : Py_DECREF(v);
1575 3 : }
1576 :
1577 : static PyObject *
1578 3 : makeargvobject(int argc, char **argv)
1579 : {
1580 : PyObject *av;
1581 3 : if (argc <= 0 || argv == NULL) {
1582 : /* Ensure at least one (empty) argument is seen */
1583 : static char *empty_argv[1] = {""};
1584 0 : argv = empty_argv;
1585 0 : argc = 1;
1586 : }
1587 3 : av = PyList_New(argc);
1588 3 : if (av != NULL) {
1589 : int i;
1590 15 : for (i = 0; i < argc; i++) {
1591 : #ifdef __VMS
1592 : PyObject *v;
1593 :
1594 : /* argv[0] is the script pathname if known */
1595 : if (i == 0) {
1596 : char* fn = decc$translate_vms(argv[0]);
1597 : if ((fn == (char *)0) || fn == (char *)-1)
1598 : v = PyString_FromString(argv[0]);
1599 : else
1600 : v = PyString_FromString(
1601 : decc$translate_vms(argv[0]));
1602 : } else
1603 : v = PyString_FromString(argv[i]);
1604 : #else
1605 12 : PyObject *v = PyString_FromString(argv[i]);
1606 : #endif
1607 12 : if (v == NULL) {
1608 0 : Py_DECREF(av);
1609 0 : av = NULL;
1610 0 : break;
1611 : }
1612 12 : PyList_SetItem(av, i, v);
1613 : }
1614 : }
1615 3 : return av;
1616 : }
1617 :
1618 : void
1619 3 : PySys_SetArgvEx(int argc, char **argv, int updatepath)
1620 : {
1621 : #if defined(HAVE_REALPATH)
1622 : char fullpath[MAXPATHLEN];
1623 : #elif defined(MS_WINDOWS) && !defined(MS_WINCE)
1624 : char fullpath[MAX_PATH];
1625 : #endif
1626 3 : PyObject *av = makeargvobject(argc, argv);
1627 3 : PyObject *path = PySys_GetObject("path");
1628 3 : if (av == NULL)
1629 0 : Py_FatalError("no mem for sys.argv");
1630 3 : if (PySys_SetObject("argv", av) != 0)
1631 0 : Py_FatalError("can't assign sys.argv");
1632 3 : if (updatepath && path != NULL) {
1633 3 : char *argv0 = argv[0];
1634 3 : char *p = NULL;
1635 3 : Py_ssize_t n = 0;
1636 : PyObject *a;
1637 : #ifdef HAVE_READLINK
1638 : char link[MAXPATHLEN+1];
1639 : char argv0copy[2*MAXPATHLEN+1];
1640 3 : int nr = 0;
1641 3 : if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0)
1642 3 : nr = readlink(argv0, link, MAXPATHLEN);
1643 3 : if (nr > 0) {
1644 : /* It's a symlink */
1645 0 : link[nr] = '\0';
1646 0 : if (link[0] == SEP)
1647 0 : argv0 = link; /* Link to absolute path */
1648 0 : else if (strchr(link, SEP) == NULL)
1649 : ; /* Link without path */
1650 : else {
1651 : /* Must join(dirname(argv0), link) */
1652 0 : char *q = strrchr(argv0, SEP);
1653 0 : if (q == NULL)
1654 0 : argv0 = link; /* argv0 without path */
1655 : else {
1656 : /* Must make a copy */
1657 0 : strcpy(argv0copy, argv0);
1658 0 : q = strrchr(argv0copy, SEP);
1659 0 : strcpy(q+1, link);
1660 0 : argv0 = argv0copy;
1661 : }
1662 : }
1663 : }
1664 : #endif /* HAVE_READLINK */
1665 : #if SEP == '\\' /* Special case for MS filename syntax */
1666 : if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
1667 : char *q;
1668 : #if defined(MS_WINDOWS) && !defined(MS_WINCE)
1669 : /* This code here replaces the first element in argv with the full
1670 : path that it represents. Under CE, there are no relative paths so
1671 : the argument must be the full path anyway. */
1672 : char *ptemp;
1673 : if (GetFullPathName(argv0,
1674 : sizeof(fullpath),
1675 : fullpath,
1676 : &ptemp)) {
1677 : argv0 = fullpath;
1678 : }
1679 : #endif
1680 : p = strrchr(argv0, SEP);
1681 : /* Test for alternate separator */
1682 : q = strrchr(p ? p : argv0, '/');
1683 : if (q != NULL)
1684 : p = q;
1685 : if (p != NULL) {
1686 : n = p + 1 - argv0;
1687 : if (n > 1 && p[-1] != ':')
1688 : n--; /* Drop trailing separator */
1689 : }
1690 : }
1691 : #else /* All other filename syntaxes */
1692 3 : if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
1693 : #if defined(HAVE_REALPATH)
1694 3 : if (realpath(argv0, fullpath)) {
1695 3 : argv0 = fullpath;
1696 : }
1697 : #endif
1698 3 : p = strrchr(argv0, SEP);
1699 : }
1700 3 : if (p != NULL) {
1701 : #ifndef RISCOS
1702 3 : n = p + 1 - argv0;
1703 : #else /* don't include trailing separator */
1704 : n = p - argv0;
1705 : #endif /* RISCOS */
1706 : #if SEP == '/' /* Special case for Unix filename syntax */
1707 3 : if (n > 1)
1708 3 : n--; /* Drop trailing separator */
1709 : #endif /* Unix */
1710 : }
1711 : #endif /* All others */
1712 3 : a = PyString_FromStringAndSize(argv0, n);
1713 3 : if (a == NULL)
1714 0 : Py_FatalError("no mem for sys.path insertion");
1715 3 : if (PyList_Insert(path, 0, a) < 0)
1716 0 : Py_FatalError("sys.path.insert(0) failed");
1717 3 : Py_DECREF(a);
1718 : }
1719 3 : Py_DECREF(av);
1720 3 : }
1721 :
1722 : void
1723 3 : PySys_SetArgv(int argc, char **argv)
1724 : {
1725 3 : PySys_SetArgvEx(argc, argv, 1);
1726 3 : }
1727 :
1728 :
1729 : /* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
1730 : Adapted from code submitted by Just van Rossum.
1731 :
1732 : PySys_WriteStdout(format, ...)
1733 : PySys_WriteStderr(format, ...)
1734 :
1735 : The first function writes to sys.stdout; the second to sys.stderr. When
1736 : there is a problem, they write to the real (C level) stdout or stderr;
1737 : no exceptions are raised.
1738 :
1739 : Both take a printf-style format string as their first argument followed
1740 : by a variable length argument list determined by the format string.
1741 :
1742 : *** WARNING ***
1743 :
1744 : The format should limit the total size of the formatted output string to
1745 : 1000 bytes. In particular, this means that no unrestricted "%s" formats
1746 : should occur; these should be limited using "%.<N>s where <N> is a
1747 : decimal number calculated so that <N> plus the maximum size of other
1748 : formatted text does not exceed 1000 bytes. Also watch out for "%f",
1749 : which can print hundreds of digits for very large numbers.
1750 :
1751 : */
1752 :
1753 : static void
1754 0 : mywrite(char *name, FILE *fp, const char *format, va_list va)
1755 : {
1756 : PyObject *file;
1757 : PyObject *error_type, *error_value, *error_traceback;
1758 :
1759 0 : PyErr_Fetch(&error_type, &error_value, &error_traceback);
1760 0 : file = PySys_GetObject(name);
1761 0 : if (file == NULL || PyFile_AsFile(file) == fp)
1762 0 : vfprintf(fp, format, va);
1763 : else {
1764 : char buffer[1001];
1765 0 : const int written = PyOS_vsnprintf(buffer, sizeof(buffer),
1766 : format, va);
1767 0 : if (PyFile_WriteString(buffer, file) != 0) {
1768 0 : PyErr_Clear();
1769 0 : fputs(buffer, fp);
1770 : }
1771 0 : if (written < 0 || (size_t)written >= sizeof(buffer)) {
1772 0 : const char *truncated = "... truncated";
1773 0 : if (PyFile_WriteString(truncated, file) != 0) {
1774 0 : PyErr_Clear();
1775 0 : fputs(truncated, fp);
1776 : }
1777 : }
1778 : }
1779 0 : PyErr_Restore(error_type, error_value, error_traceback);
1780 0 : }
1781 :
1782 : void
1783 0 : PySys_WriteStdout(const char *format, ...)
1784 : {
1785 : va_list va;
1786 :
1787 0 : va_start(va, format);
1788 0 : mywrite("stdout", stdout, format, va);
1789 0 : va_end(va);
1790 0 : }
1791 :
1792 : void
1793 0 : PySys_WriteStderr(const char *format, ...)
1794 : {
1795 : va_list va;
1796 :
1797 0 : va_start(va, format);
1798 0 : mywrite("stderr", stderr, format, va);
1799 0 : va_end(va);
1800 0 : }
|
