#include "Python.h"

#include "structseq.h"

#include "code.h"

#include "frameobject.h"

#include "eval.h"

#include "osdefs.h"

#ifdef MS_WINDOWS

#define WIN32_LEAN_AND_MEAN

#include "windows.h"

#endif /* MS_WINDOWS */

#ifdef MS_COREDLL

extern void *PyWin_DLLhModule;

extern const char *PyWin_DLLVersionString;

#ifdef __VMS

#include <unixlib.h>

#ifdef MS_WINDOWS

#include <windows.h>

#ifdef HAVE_LANGINFO_H

#include <locale.h>

#include <langinfo.h>

PyObject *

PySys_GetObject(char *name)

{

PyThreadState *tstate = PyThreadState_GET();

PyObject *sd = tstate->interp->sysdict;

if (sd == NULL)

return NULL;

return PyDict_GetItemString(sd, name);

}

FILE *

PySys_GetFile(char *name, FILE *def)

{

FILE *fp = NULL;

PyObject *v = PySys_GetObject(name);

if (v != NULL && PyFile_Check(v))

fp = PyFile_AsFile(v);

if (fp == NULL)

fp = def;

return fp;

}

PySys_SetObject(char *name, PyObject *v)

{

PyThreadState *tstate = PyThreadState_GET();

PyObject *sd = tstate->interp->sysdict;

if (v == NULL) {

if (PyDict_GetItemString(sd, name) == NULL)

return 0;

else

return PyDict_DelItemString(sd, name);

}

else

return PyDict_SetItemString(sd, name, v);

}

static PyObject *

sys_displayhook(PyObject *self, PyObject *o)

{

PyObject *outf;

PyInterpreterState *interp = PyThreadState_GET()->interp;

PyObject *modules = interp->modules;

PyObject *builtins = PyDict_GetItemString(modules, "__builtin__");

if (builtins == NULL) {

PyErr_SetString(PyExc_RuntimeError, "lost __builtin__");

return NULL;

}

/* Print value except if None */

/* After printing, also assign to '_' */

/* Before, set '_' to None to avoid recursion */

if (o == Py_None) {

Py_INCREF(Py_None);

return Py_None;

}

if (PyObject_SetAttrString(builtins, "_", Py_None) != 0)

return NULL;

if (Py_FlushLine() != 0)

return NULL;

outf = PySys_GetObject("stdout");

if (outf == NULL) {

PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");

return NULL;

}

if (PyFile_WriteObject(o, outf, 0) != 0)

return NULL;

PyFile_SoftSpace(outf, 1);

if (Py_FlushLine() != 0)

return NULL;

if (PyObject_SetAttrString(builtins, "_", o) != 0)

return NULL;

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(displayhook_doc,

);

static PyObject *

sys_excepthook(PyObject* self, PyObject* args)

{

PyObject *exc, *value, *tb;

if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb))

return NULL;

PyErr_Display(exc, value, tb);

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(excepthook_doc,

);

static PyObject *

sys_exc_info(PyObject *self, PyObject *noargs)

{

PyThreadState *tstate;

tstate = PyThreadState_GET();

return Py_BuildValue(

"(OOO)",

tstate->exc_type != NULL ? tstate->exc_type : Py_None,

tstate->exc_value != NULL ? tstate->exc_value : Py_None,

tstate->exc_traceback != NULL ?

tstate->exc_traceback : Py_None);

}

PyDoc_STRVAR(exc_info_doc,

);

static PyObject *

sys_exc_clear(PyObject *self, PyObject *noargs)

{

PyThreadState *tstate;

PyObject *tmp_type, *tmp_value, *tmp_tb;

if (PyErr_WarnPy3k("sys.exc_clear() not supported in 3.x; "

"use except clauses", 1) < 0)

return NULL;

tstate = PyThreadState_GET();

tmp_type = tstate->exc_type;

tmp_value = tstate->exc_value;

tmp_tb = tstate->exc_traceback;

tstate->exc_type = NULL;

tstate->exc_value = NULL;

tstate->exc_traceback = NULL;

Py_XDECREF(tmp_type);

Py_XDECREF(tmp_value);

Py_XDECREF(tmp_tb);

/* For b/w compatibility */

PySys_SetObject("exc_type", Py_None);

PySys_SetObject("exc_value", Py_None);

PySys_SetObject("exc_traceback", Py_None);

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(exc_clear_doc,

);

static PyObject *

sys_exit(PyObject *self, PyObject *args)

{

PyObject *exit_code = 0;

if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code))

return NULL;

/* Raise SystemExit so callers may catch it or clean up. */

PyErr_SetObject(PyExc_SystemExit, exit_code);

return NULL;

}

PyDoc_STRVAR(exit_doc,

);

#ifdef Py_USING_UNICODE

static PyObject *

sys_getdefaultencoding(PyObject *self)

{

return PyString_FromString(PyUnicode_GetDefaultEncoding());

}

PyDoc_STRVAR(getdefaultencoding_doc,

);

static PyObject *

sys_setdefaultencoding(PyObject *self, PyObject *args)

{

char *encoding;

if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding))

return NULL;

if (PyUnicode_SetDefaultEncoding(encoding))

return NULL;

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(setdefaultencoding_doc,

);

static PyObject *

sys_getfilesystemencoding(PyObject *self)

{

if (Py_FileSystemDefaultEncoding)

return PyString_FromString(Py_FileSystemDefaultEncoding);

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(getfilesystemencoding_doc,

);

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

static int

trace_init(void)

{

static char *whatnames[7] = {"call", "exception", "line", "return",

"c_call", "c_exception", "c_return"};

PyObject *name;

int i;

for (i = 0; i < 7; ++i) {

if (whatstrings[i] == NULL) {

name = PyString_InternFromString(whatnames[i]);

if (name == NULL)

return -1;

whatstrings[i] = name;

}

}

return 0;

}

static PyObject *

call_trampoline(PyThreadState *tstate, PyObject* callback,

PyFrameObject *frame, int what, PyObject *arg)

{

PyObject *args = PyTuple_New(3);

PyObject *whatstr;

PyObject *result;

if (args == NULL)

return NULL;

Py_INCREF(frame);

whatstr = whatstrings[what];

Py_INCREF(whatstr);

if (arg == NULL)

arg = Py_None;

Py_INCREF(arg);

PyTuple_SET_ITEM(args, 0, (PyObject *)frame);

PyTuple_SET_ITEM(args, 1, whatstr);

PyTuple_SET_ITEM(args, 2, arg);

/* call the Python-level function */

PyFrame_FastToLocals(frame);

result = PyEval_CallObject(callback, args);

PyFrame_LocalsToFast(frame, 1);

if (result == NULL)

PyTraceBack_Here(frame);

/* cleanup */

Py_DECREF(args);

return result;

}

static int

profile_trampoline(PyObject *self, PyFrameObject *frame,

int what, PyObject *arg)

{

PyThreadState *tstate = frame->f_tstate;

PyObject *result;

if (arg == NULL)

arg = Py_None;

result = call_trampoline(tstate, self, frame, what, arg);

if (result == NULL) {

PyEval_SetProfile(NULL, NULL);

return -1;

}

Py_DECREF(result);

return 0;

}

static int

trace_trampoline(PyObject *self, PyFrameObject *frame,

int what, PyObject *arg)

{

PyThreadState *tstate = frame->f_tstate;

PyObject *callback;

PyObject *result;

if (what == PyTrace_CALL)

callback = self;

else

callback = frame->f_trace;

if (callback == NULL)

return 0;

result = call_trampoline(tstate, callback, frame, what, arg);

if (result == NULL) {

PyEval_SetTrace(NULL, NULL);

Py_CLEAR(frame->f_trace);

return -1;

}

if (result != Py_None) {

PyObject *temp = frame->f_trace;

frame->f_trace = NULL;

Py_XDECREF(temp);

frame->f_trace = result;

}

else {

Py_DECREF(result);

}

return 0;

}

static PyObject *

sys_settrace(PyObject *self, PyObject *args)

{

if (trace_init() == -1)

return NULL;

if (args == Py_None)

PyEval_SetTrace(NULL, NULL);

else

PyEval_SetTrace(trace_trampoline, args);

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(settrace_doc,

);

static PyObject *

sys_gettrace(PyObject *self, PyObject *args)

{

PyThreadState *tstate = PyThreadState_GET();

PyObject *temp = tstate->c_traceobj;

if (temp == NULL)

temp = Py_None;

Py_INCREF(temp);

return temp;

}

PyDoc_STRVAR(gettrace_doc,

);

static PyObject *

sys_setprofile(PyObject *self, PyObject *args)

{

if (trace_init() == -1)

return NULL;

if (args == Py_None)

PyEval_SetProfile(NULL, NULL);

else

PyEval_SetProfile(profile_trampoline, args);

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(setprofile_doc,

);

static PyObject *

sys_getprofile(PyObject *self, PyObject *args)

{

PyThreadState *tstate = PyThreadState_GET();

PyObject *temp = tstate->c_profileobj;

if (temp == NULL)

temp = Py_None;

Py_INCREF(temp);

return temp;

}

PyDoc_STRVAR(getprofile_doc,

);

static PyObject *

sys_setcheckinterval(PyObject *self, PyObject *args)

{

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

return NULL;

_Py_Ticker = _Py_CheckInterval;

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(setcheckinterval_doc,

);

static PyObject *

sys_getcheckinterval(PyObject *self, PyObject *args)

{

return PyInt_FromLong(_Py_CheckInterval);

}

PyDoc_STRVAR(getcheckinterval_doc,

);

#ifdef WITH_TSC

static PyObject *

sys_settscdump(PyObject *self, PyObject *args)

{

int bool;

PyThreadState *tstate = PyThreadState_Get();

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

return NULL;

if (bool)

tstate->interp->tscdump = 1;

else

tstate->interp->tscdump = 0;

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(settscdump_doc,

);

#endif /* TSC */

static PyObject *

sys_setrecursionlimit(PyObject *self, PyObject *args)

{

int new_limit;

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

return NULL;

if (new_limit <= 0) {

PyErr_SetString(PyExc_ValueError,

"recursion limit must be positive");

return NULL;

}

Py_SetRecursionLimit(new_limit);

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(setrecursionlimit_doc,

);

static PyObject *

sys_getrecursionlimit(PyObject *self)

{

return PyInt_FromLong(Py_GetRecursionLimit());

}

PyDoc_STRVAR(getrecursionlimit_doc,

);

#ifdef MS_WINDOWS

PyDoc_STRVAR(getwindowsversion_doc,

);

static PyTypeObject WindowsVersionType = {0, 0, 0, 0, 0, 0};

static PyStructSequence_Field windows_version_fields[] = {

{"major", "Major version number"},

{"minor", "Minor version number"},

{"build", "Build number"},

{"platform", "Operating system platform"},

{"service_pack", "Latest Service Pack installed on the system"},

{"service_pack_major", "Service Pack major version number"},

{"service_pack_minor", "Service Pack minor version number"},

{"suite_mask", "Bit mask identifying available product suites"},

{"product_type", "System product type"},

{0}

};

static PyStructSequence_Desc windows_version_desc = {

"sys.getwindowsversion", /* name */

getwindowsversion_doc, /* doc */

windows_version_fields, /* fields */

5 /* For backward compatibility,

};

static PyObject *

sys_getwindowsversion(PyObject *self)

{

PyObject *version;

int pos = 0;

OSVERSIONINFOEX ver;

ver.dwOSVersionInfoSize = sizeof(ver);

if (!GetVersionEx((OSVERSIONINFO*) &ver))

return PyErr_SetFromWindowsErr(0);

version = PyStructSequence_New(&WindowsVersionType);

if (version == NULL)

return NULL;

PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMajorVersion));

PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMinorVersion));

PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwBuildNumber));

PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwPlatformId));

PyStructSequence_SET_ITEM(version, pos++, PyString_FromString(ver.szCSDVersion));

PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMajor));

PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMinor));

PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wSuiteMask));

PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wProductType));

if (PyErr_Occurred()) {

Py_DECREF(version);

return NULL;

}

return version;

}

#endif /* MS_WINDOWS */

#ifdef HAVE_DLOPEN

static PyObject *

sys_setdlopenflags(PyObject *self, PyObject *args)

{

int new_val;

PyThreadState *tstate = PyThreadState_GET();

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

return NULL;

if (!tstate)

return NULL;

tstate->interp->dlopenflags = new_val;

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(setdlopenflags_doc,

h2py script.");

static PyObject *

sys_getdlopenflags(PyObject *self, PyObject *args)

{

PyThreadState *tstate = PyThreadState_GET();

if (!tstate)

return NULL;

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

}

PyDoc_STRVAR(getdlopenflags_doc,

The flag constants are defined in the ctypes and DLFCN modules.");

#endif /* HAVE_DLOPEN */

#ifdef USE_MALLOPT

#include <malloc.h>

static PyObject *

sys_mdebug(PyObject *self, PyObject *args)

{

int flag;

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

return NULL;

mallopt(M_DEBUG, flag);

Py_INCREF(Py_None);

return Py_None;

}

#endif /* USE_MALLOPT */

_PySys_GetSizeOf(PyObject *o)

{

static PyObject *str__sizeof__ = NULL;

PyObject *res = NULL;

Py_ssize_t size;

/* Make sure the type is initialized. float gets initialized late */

if (PyType_Ready(Py_TYPE(o)) < 0)

return (size_t)-1;

/* Instance of old-style class */

if (PyInstance_Check(o))

size = PyInstance_Type.tp_basicsize;

/* all other objects */

else {

PyObject *method = _PyObject_LookupSpecial(o, "__sizeof__",

&str__sizeof__);

if (method == NULL) {

if (!PyErr_Occurred())

PyErr_Format(PyExc_TypeError,

"Type %.100s doesn't define __sizeof__",

Py_TYPE(o)->tp_name);

}

else {

res = PyObject_CallFunctionObjArgs(method, NULL);

Py_DECREF(method);

}

if (res == NULL)

return (size_t)-1;

size = (size_t)PyInt_AsSsize_t(res);

Py_DECREF(res);

if (size == -1 && PyErr_Occurred())

return (size_t)-1;

}

if (size < 0) {

PyErr_SetString(PyExc_ValueError, "__sizeof__() should return >= 0");

return (size_t)-1;

}

/* add gc_head size */

if (PyObject_IS_GC(o))

return ((size_t)size) + sizeof(PyGC_Head);

return (size_t)size;

}

static PyObject *

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

{

static char *kwlist[] = {"object", "default", 0};

size_t size;

PyObject *o, *dflt = NULL;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof",

kwlist, &o, &dflt))

return NULL;

size = _PySys_GetSizeOf(o);

if (size == (size_t)-1 && PyErr_Occurred()) {

/* Has a default value been given */

if (dflt != NULL && PyErr_ExceptionMatches(PyExc_TypeError)) {

PyErr_Clear();

Py_INCREF(dflt);

return dflt;

}

else

return NULL;

}

return PyInt_FromSize_t(size);

}

PyDoc_STRVAR(getsizeof_doc,

Return the size of object in bytes.");

static PyObject *

sys_getrefcount(PyObject *self, PyObject *arg)

{

return PyInt_FromSsize_t(arg->ob_refcnt);

}

#ifdef Py_REF_DEBUG

static PyObject *

sys_gettotalrefcount(PyObject *self)

{

return PyInt_FromSsize_t(_Py_GetRefTotal());

}

#endif /* Py_REF_DEBUG */

PyDoc_STRVAR(getrefcount_doc,

);

#ifdef COUNT_ALLOCS

static PyObject *

sys_getcounts(PyObject *self)

{

extern PyObject *get_counts(void);

return get_counts();

}

PyDoc_STRVAR(getframe_doc,

);

static PyObject *

sys_getframe(PyObject *self, PyObject *args)

{

PyFrameObject *f = PyThreadState_GET()->frame;

int depth = -1;

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

return NULL;

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

f = f->f_back;

--depth;

}

if (f == NULL) {

PyErr_SetString(PyExc_ValueError,

"call stack is not deep enough");

return NULL;

}

Py_INCREF(f);

return (PyObject*)f;

}

PyDoc_STRVAR(current_frames_doc,

);

static PyObject *

sys_current_frames(PyObject *self, PyObject *noargs)

{

return _PyThread_CurrentFrames();

}

PyDoc_STRVAR(call_tracing_doc,

);

static PyObject *

sys_call_tracing(PyObject *self, PyObject *args)

{

PyObject *func, *funcargs;

if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs))

return NULL;

return _PyEval_CallTracing(func, funcargs);

}

PyDoc_STRVAR(callstats_doc,

);

#ifdef __cplusplus

extern "C" {

static PyObject *

sys_debugmallocstats(PyObject *self, PyObject *args)

{

PyObject *file = NULL;

FILE *fp;

if (!PyArg_ParseTuple(args, "|O!",

&PyFile_Type, &file)) {

return NULL;

}

if (!file) {

/* Default to sys.stderr: */

file = PySys_GetObject("stderr");

if (!file) {

PyErr_SetString(PyExc_ValueError, "sys.stderr not set");

return NULL;

}

if (!PyFile_Check(file)) {

PyErr_SetString(PyExc_TypeError, "sys.stderr is not a file");

return NULL;

}

}

Py_INCREF(file);

/* OK, we now own a ref on non-NULL "file" */

fp = PyFile_AsFile(file);

if (!fp) {

PyErr_SetString(PyExc_ValueError, "file is closed");

Py_DECREF(file);

return NULL;

}

_PyObject_DebugMallocStats(fp);

fputc('\n', fp);

_PyObject_DebugTypeStats(fp);

Py_DECREF(file);

Py_RETURN_NONE;

}

PyDoc_STRVAR(debugmallocstats_doc,

");

#ifdef Py_TRACE_REFS

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

#ifdef DYNAMIC_EXECUTION_PROFILE

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

#ifdef __cplusplus

}

static PyObject *

sys_clear_type_cache(PyObject* self, PyObject* args)

{

PyType_ClearCache();

Py_RETURN_NONE;

}

PyDoc_STRVAR(sys_clear_type_cache__doc__,

Clear the internal type lookup cache.");

static PyMethodDef sys_methods[] = {

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

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

callstats_doc},

{"_clear_type_cache", sys_clear_type_cache, METH_NOARGS,

sys_clear_type_cache__doc__},

{"_current_frames", sys_current_frames, METH_NOARGS,

current_frames_doc},

{"displayhook", sys_displayhook, METH_O, displayhook_doc},

{"exc_info", sys_exc_info, METH_NOARGS, exc_info_doc},

{"exc_clear", sys_exc_clear, METH_NOARGS, exc_clear_doc},

{"excepthook", sys_excepthook, METH_VARARGS, excepthook_doc},

{"exit", sys_exit, METH_VARARGS, exit_doc},

#ifdef Py_USING_UNICODE

{"getdefaultencoding", (PyCFunction)sys_getdefaultencoding,

METH_NOARGS, getdefaultencoding_doc},

#ifdef HAVE_DLOPEN

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

getdlopenflags_doc},

#ifdef COUNT_ALLOCS

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

#ifdef DYNAMIC_EXECUTION_PROFILE

{"getdxp", _Py_GetDXProfile, METH_VARARGS},

#ifdef Py_USING_UNICODE

{"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding,

METH_NOARGS, getfilesystemencoding_doc},