1991-02-19 12:39:46 +00:00
|
|
|
/***********************************************************
|
2000-06-30 23:50:40 +00:00
|
|
|
Copyright (c) 2000, BeOpen.com.
|
|
|
|
Copyright (c) 1995-2000, Corporation for National Research Initiatives.
|
|
|
|
Copyright (c) 1990-1995, Stichting Mathematisch Centrum.
|
|
|
|
All rights reserved.
|
1996-10-25 14:44:06 +00:00
|
|
|
|
2000-06-30 23:50:40 +00:00
|
|
|
See the file "Misc/COPYRIGHT" for information on usage and
|
|
|
|
redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
1991-02-19 12:39:46 +00:00
|
|
|
******************************************************************/
|
|
|
|
|
1990-10-14 12:07:46 +00:00
|
|
|
/* System module */
|
|
|
|
|
|
|
|
/*
|
|
|
|
Various bits of information used by the interpreter are collected in
|
|
|
|
module 'sys'.
|
1990-12-20 15:06:42 +00:00
|
|
|
Function member:
|
1995-03-20 15:09:40 +00:00
|
|
|
- exit(sts): raise SystemExit
|
1990-10-14 12:07:46 +00:00
|
|
|
Data members:
|
|
|
|
- stdin, stdout, stderr: standard file objects
|
|
|
|
- modules: the table of modules (dictionary)
|
1990-12-20 15:06:42 +00:00
|
|
|
- path: module search path (list of strings)
|
|
|
|
- argv: script arguments (list of strings)
|
|
|
|
- ps1, ps2: optional primary and secondary prompts (strings)
|
1990-10-14 12:07:46 +00:00
|
|
|
*/
|
|
|
|
|
1997-04-29 18:33:38 +00:00
|
|
|
#include "Python.h"
|
1990-10-14 12:07:46 +00:00
|
|
|
|
1992-03-23 18:20:18 +00:00
|
|
|
#include "osdefs.h"
|
1990-12-20 15:06:42 +00:00
|
|
|
|
1997-05-20 15:57:25 +00:00
|
|
|
#ifdef HAVE_UNISTD_H
|
1997-04-25 15:38:31 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
|
|
|
1996-09-11 23:12:24 +00:00
|
|
|
#ifdef MS_COREDLL
|
1996-04-09 02:37:57 +00:00
|
|
|
extern void *PyWin_DLLhModule;
|
1997-09-29 23:34:23 +00:00
|
|
|
/* A string loaded from the DLL at startup: */
|
|
|
|
extern const char *PyWin_DLLVersionString;
|
1996-04-09 02:37:57 +00:00
|
|
|
#endif
|
|
|
|
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *
|
|
|
|
PySys_GetObject(name)
|
1990-10-14 12:07:46 +00:00
|
|
|
char *name;
|
|
|
|
{
|
1997-08-02 03:10:38 +00:00
|
|
|
PyThreadState *tstate = PyThreadState_Get();
|
|
|
|
PyObject *sd = tstate->interp->sysdict;
|
1999-10-05 22:17:41 +00:00
|
|
|
if (sd == NULL)
|
|
|
|
return NULL;
|
1997-08-02 03:10:38 +00:00
|
|
|
return PyDict_GetItemString(sd, name);
|
1990-10-14 12:07:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
FILE *
|
1997-04-29 18:33:38 +00:00
|
|
|
PySys_GetFile(name, def)
|
1990-10-14 12:07:46 +00:00
|
|
|
char *name;
|
|
|
|
FILE *def;
|
|
|
|
{
|
|
|
|
FILE *fp = NULL;
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *v = PySys_GetObject(name);
|
|
|
|
if (v != NULL && PyFile_Check(v))
|
|
|
|
fp = PyFile_AsFile(v);
|
1990-10-14 12:07:46 +00:00
|
|
|
if (fp == NULL)
|
|
|
|
fp = def;
|
|
|
|
return fp;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
1997-04-29 18:33:38 +00:00
|
|
|
PySys_SetObject(name, v)
|
1990-10-14 12:07:46 +00:00
|
|
|
char *name;
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *v;
|
1990-10-14 12:07:46 +00:00
|
|
|
{
|
1997-08-02 03:10:38 +00:00
|
|
|
PyThreadState *tstate = PyThreadState_Get();
|
|
|
|
PyObject *sd = tstate->interp->sysdict;
|
1992-01-26 18:15:48 +00:00
|
|
|
if (v == NULL) {
|
1997-08-02 03:10:38 +00:00
|
|
|
if (PyDict_GetItemString(sd, name) == NULL)
|
1992-01-26 18:15:48 +00:00
|
|
|
return 0;
|
|
|
|
else
|
1997-08-02 03:10:38 +00:00
|
|
|
return PyDict_DelItemString(sd, name);
|
1992-01-26 18:15:48 +00:00
|
|
|
}
|
1990-10-14 12:07:46 +00:00
|
|
|
else
|
1997-08-02 03:10:38 +00:00
|
|
|
return PyDict_SetItemString(sd, name, v);
|
1990-10-14 12:07:46 +00:00
|
|
|
}
|
|
|
|
|
1997-05-05 20:56:21 +00:00
|
|
|
static PyObject *
|
|
|
|
sys_exc_info(self, args)
|
|
|
|
PyObject *self;
|
|
|
|
PyObject *args;
|
|
|
|
{
|
|
|
|
PyThreadState *tstate;
|
2000-03-31 00:38:29 +00:00
|
|
|
if (!PyArg_ParseTuple(args, ":exc_info"))
|
1997-05-05 20:56:21 +00:00
|
|
|
return NULL;
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
1998-06-27 19:43:25 +00:00
|
|
|
static char exc_info_doc[] =
|
|
|
|
"exc_info() -> (type, value, traceback)\n\
|
|
|
|
\n\
|
|
|
|
Return information about the exception that is currently being handled.\n\
|
|
|
|
This should be called from inside an except clause only.";
|
|
|
|
|
1997-04-29 18:33:38 +00:00
|
|
|
static PyObject *
|
1990-10-14 12:07:46 +00:00
|
|
|
sys_exit(self, args)
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *self;
|
|
|
|
PyObject *args;
|
1990-10-14 12:07:46 +00:00
|
|
|
{
|
1991-12-31 13:15:35 +00:00
|
|
|
/* Raise SystemExit so callers may catch it or clean up. */
|
1997-04-29 18:33:38 +00:00
|
|
|
PyErr_SetObject(PyExc_SystemExit, args);
|
1991-12-31 13:15:35 +00:00
|
|
|
return NULL;
|
1990-10-14 12:07:46 +00:00
|
|
|
}
|
|
|
|
|
1998-06-27 19:43:25 +00:00
|
|
|
static char exit_doc[] =
|
|
|
|
"exit([status])\n\
|
|
|
|
\n\
|
|
|
|
Exit the interpreter by raising SystemExit(status).\n\
|
|
|
|
If the status is omitted or None, it defaults to zero (i.e., success).\n\
|
|
|
|
If the status numeric, it will be used as the system exit status.\n\
|
|
|
|
If it is another kind of object, it will be printed and the system\n\
|
|
|
|
exit status will be one (i.e., failure).";
|
|
|
|
|
2000-05-09 19:57:01 +00:00
|
|
|
static PyObject *
|
2000-06-07 09:13:41 +00:00
|
|
|
sys_getdefaultencoding(self, args)
|
2000-05-09 19:57:01 +00:00
|
|
|
PyObject *self;
|
|
|
|
PyObject *args;
|
|
|
|
{
|
2000-06-07 09:13:41 +00:00
|
|
|
if (!PyArg_ParseTuple(args, ":getdefaultencoding"))
|
2000-05-09 19:57:01 +00:00
|
|
|
return NULL;
|
|
|
|
return PyString_FromString(PyUnicode_GetDefaultEncoding());
|
|
|
|
}
|
|
|
|
|
2000-06-07 09:13:41 +00:00
|
|
|
static char getdefaultencoding_doc[] =
|
|
|
|
"getdefaultencoding() -> string\n\
|
2000-05-09 19:57:01 +00:00
|
|
|
\n\
|
|
|
|
Return the current default string encoding used by the Unicode \n\
|
|
|
|
implementation.";
|
|
|
|
|
|
|
|
static PyObject *
|
2000-06-07 09:13:41 +00:00
|
|
|
sys_setdefaultencoding(self, args)
|
2000-05-09 19:57:01 +00:00
|
|
|
PyObject *self;
|
|
|
|
PyObject *args;
|
|
|
|
{
|
|
|
|
char *encoding;
|
2000-06-07 09:13:41 +00:00
|
|
|
if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding))
|
2000-05-09 19:57:01 +00:00
|
|
|
return NULL;
|
|
|
|
if (PyUnicode_SetDefaultEncoding(encoding))
|
|
|
|
return NULL;
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
return Py_None;
|
|
|
|
}
|
|
|
|
|
2000-06-07 09:13:41 +00:00
|
|
|
static char setdefaultencoding_doc[] =
|
|
|
|
"setdefaultencoding(encoding)\n\
|
2000-05-09 19:57:01 +00:00
|
|
|
\n\
|
|
|
|
Set the current default string encoding used by the Unicode implementation.";
|
|
|
|
|
1997-04-29 18:33:38 +00:00
|
|
|
static PyObject *
|
1992-03-23 18:20:18 +00:00
|
|
|
sys_settrace(self, args)
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *self;
|
|
|
|
PyObject *args;
|
1992-03-23 18:20:18 +00:00
|
|
|
{
|
1997-05-05 20:56:21 +00:00
|
|
|
PyThreadState *tstate = PyThreadState_Get();
|
1997-04-29 18:33:38 +00:00
|
|
|
if (args == Py_None)
|
1992-03-23 18:20:18 +00:00
|
|
|
args = NULL;
|
1992-04-05 14:17:55 +00:00
|
|
|
else
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_XINCREF(args);
|
1997-05-05 20:56:21 +00:00
|
|
|
Py_XDECREF(tstate->sys_tracefunc);
|
|
|
|
tstate->sys_tracefunc = args;
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_INCREF(Py_None);
|
|
|
|
return Py_None;
|
1992-03-23 18:20:18 +00:00
|
|
|
}
|
|
|
|
|
1998-06-27 19:43:25 +00:00
|
|
|
static char settrace_doc[] =
|
|
|
|
"settrace(function)\n\
|
|
|
|
\n\
|
|
|
|
Set the global debug tracing function. It will be called on each\n\
|
|
|
|
function call. See the debugger chapter in the library manual.";
|
|
|
|
|
1997-04-29 18:33:38 +00:00
|
|
|
static PyObject *
|
1992-03-23 18:20:18 +00:00
|
|
|
sys_setprofile(self, args)
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *self;
|
|
|
|
PyObject *args;
|
1992-03-23 18:20:18 +00:00
|
|
|
{
|
1997-05-05 20:56:21 +00:00
|
|
|
PyThreadState *tstate = PyThreadState_Get();
|
1997-04-29 18:33:38 +00:00
|
|
|
if (args == Py_None)
|
1992-03-23 18:20:18 +00:00
|
|
|
args = NULL;
|
1992-04-05 14:17:55 +00:00
|
|
|
else
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_XINCREF(args);
|
1997-05-05 20:56:21 +00:00
|
|
|
Py_XDECREF(tstate->sys_profilefunc);
|
|
|
|
tstate->sys_profilefunc = args;
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_INCREF(Py_None);
|
|
|
|
return Py_None;
|
1992-03-23 18:20:18 +00:00
|
|
|
}
|
|
|
|
|
1998-06-27 19:43:25 +00:00
|
|
|
static char setprofile_doc[] =
|
|
|
|
"setprofile(function)\n\
|
|
|
|
\n\
|
|
|
|
Set the profiling function. It will be called on each function call\n\
|
|
|
|
and return. See the profiler chapter in the library manual.";
|
|
|
|
|
1997-04-29 18:33:38 +00:00
|
|
|
static PyObject *
|
1995-01-09 17:46:13 +00:00
|
|
|
sys_setcheckinterval(self, args)
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *self;
|
|
|
|
PyObject *args;
|
1995-01-09 17:46:13 +00:00
|
|
|
{
|
1997-05-05 20:56:21 +00:00
|
|
|
PyThreadState *tstate = PyThreadState_Get();
|
2000-02-29 13:59:29 +00:00
|
|
|
if (!PyArg_ParseTuple(args, "i:setcheckinterval", &tstate->interp->checkinterval))
|
1995-01-09 17:46:13 +00:00
|
|
|
return NULL;
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_INCREF(Py_None);
|
|
|
|
return Py_None;
|
1995-01-09 17:46:13 +00:00
|
|
|
}
|
|
|
|
|
1998-06-27 19:43:25 +00:00
|
|
|
static char setcheckinterval_doc[] =
|
|
|
|
"setcheckinterval(n)\n\
|
|
|
|
\n\
|
|
|
|
Tell the Python interpreter to check for asynchronous events every\n\
|
|
|
|
n instructions. This also affects how often thread switches occur.";
|
|
|
|
|
1992-09-03 20:25:30 +00:00
|
|
|
#ifdef USE_MALLOPT
|
|
|
|
/* Link with -lmalloc (or -lmpc) on an SGI */
|
|
|
|
#include <malloc.h>
|
|
|
|
|
1997-04-29 18:33:38 +00:00
|
|
|
static PyObject *
|
1992-09-03 20:25:30 +00:00
|
|
|
sys_mdebug(self, args)
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *self;
|
|
|
|
PyObject *args;
|
1992-09-03 20:25:30 +00:00
|
|
|
{
|
|
|
|
int flag;
|
2000-03-31 00:38:29 +00:00
|
|
|
if (!PyArg_ParseTuple(args, "i:mdebug", &flag))
|
1992-09-03 20:25:30 +00:00
|
|
|
return NULL;
|
|
|
|
mallopt(M_DEBUG, flag);
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_INCREF(Py_None);
|
|
|
|
return Py_None;
|
1992-09-03 20:25:30 +00:00
|
|
|
}
|
|
|
|
#endif /* USE_MALLOPT */
|
|
|
|
|
1997-04-29 18:33:38 +00:00
|
|
|
static PyObject *
|
1995-08-29 09:18:14 +00:00
|
|
|
sys_getrefcount(self, args)
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *self;
|
|
|
|
PyObject *args;
|
1995-08-29 09:18:14 +00:00
|
|
|
{
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *arg;
|
2000-03-31 00:38:29 +00:00
|
|
|
if (!PyArg_ParseTuple(args, "O:getrefcount", &arg))
|
1995-08-29 09:18:14 +00:00
|
|
|
return NULL;
|
2000-06-20 08:12:48 +00:00
|
|
|
return PyInt_FromLong(arg->ob_refcnt);
|
1995-08-29 09:18:14 +00:00
|
|
|
}
|
|
|
|
|
2000-06-20 08:12:48 +00:00
|
|
|
#ifdef Py_TRACE_REFS
|
|
|
|
static PyObject *
|
|
|
|
sys_gettotalrefcount(PyObject *self, PyObject *args)
|
|
|
|
{
|
|
|
|
extern long _Py_RefTotal;
|
|
|
|
if (!PyArg_ParseTuple(args, ":gettotalrefcount"))
|
|
|
|
return NULL;
|
|
|
|
return PyInt_FromLong(_Py_RefTotal);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* Py_TRACE_REFS */
|
|
|
|
|
1998-06-27 19:43:25 +00:00
|
|
|
static char getrefcount_doc[] =
|
|
|
|
"getrefcount(object) -> integer\n\
|
|
|
|
\n\
|
|
|
|
Return the current reference count for the object. This includes the\n\
|
|
|
|
temporary reference in the argument list, so it is at least 2.";
|
|
|
|
|
1995-08-29 09:18:14 +00:00
|
|
|
#ifdef COUNT_ALLOCS
|
|
|
|
static PyObject *
|
|
|
|
sys_getcounts(self, args)
|
|
|
|
PyObject *self, *args;
|
|
|
|
{
|
|
|
|
extern PyObject *get_counts Py_PROTO((void));
|
|
|
|
|
2000-03-31 00:38:29 +00:00
|
|
|
if (!PyArg_ParseTuple(args, ":getcounts"))
|
1995-08-29 09:18:14 +00:00
|
|
|
return NULL;
|
|
|
|
return get_counts();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1996-05-23 22:45:41 +00:00
|
|
|
#ifdef Py_TRACE_REFS
|
1996-05-24 20:48:31 +00:00
|
|
|
/* Defined in objects.c because it uses static globals if that file */
|
|
|
|
extern PyObject *_Py_GetObjects Py_PROTO((PyObject *, PyObject *));
|
1995-08-29 09:18:14 +00:00
|
|
|
#endif
|
1996-05-24 20:48:31 +00:00
|
|
|
|
1997-01-24 04:07:45 +00:00
|
|
|
#ifdef DYNAMIC_EXECUTION_PROFILE
|
|
|
|
/* Defined in ceval.c because it uses static globals if that file */
|
|
|
|
extern PyObject *_Py_GetDXProfile Py_PROTO((PyObject *, PyObject *));
|
|
|
|
#endif
|
|
|
|
|
1997-04-29 18:33:38 +00:00
|
|
|
static PyMethodDef sys_methods[] = {
|
1997-01-24 04:07:45 +00:00
|
|
|
/* Might as well keep this in alphabetic order */
|
2000-03-31 00:38:29 +00:00
|
|
|
{"exc_info", sys_exc_info, 1, exc_info_doc},
|
1998-06-27 19:43:25 +00:00
|
|
|
{"exit", sys_exit, 0, exit_doc},
|
2000-06-07 09:13:41 +00:00
|
|
|
{"getdefaultencoding", sys_getdefaultencoding, 1, getdefaultencoding_doc},
|
1995-08-29 09:18:14 +00:00
|
|
|
#ifdef COUNT_ALLOCS
|
2000-03-31 00:38:29 +00:00
|
|
|
{"getcounts", sys_getcounts, 1},
|
1995-08-29 09:18:14 +00:00
|
|
|
#endif
|
1997-01-24 04:07:45 +00:00
|
|
|
#ifdef DYNAMIC_EXECUTION_PROFILE
|
|
|
|
{"getdxp", _Py_GetDXProfile, 1},
|
|
|
|
#endif
|
1996-05-23 22:45:41 +00:00
|
|
|
#ifdef Py_TRACE_REFS
|
1996-05-24 20:48:31 +00:00
|
|
|
{"getobjects", _Py_GetObjects, 1},
|
2000-06-20 08:12:48 +00:00
|
|
|
{"gettotalrefcount", sys_gettotalrefcount, 1},
|
1995-08-29 09:18:14 +00:00
|
|
|
#endif
|
2000-03-31 00:38:29 +00:00
|
|
|
{"getrefcount", sys_getrefcount, 1, getrefcount_doc},
|
1992-09-03 20:25:30 +00:00
|
|
|
#ifdef USE_MALLOPT
|
2000-03-31 00:38:29 +00:00
|
|
|
{"mdebug", sys_mdebug, 1},
|
1992-09-03 20:25:30 +00:00
|
|
|
#endif
|
2000-06-07 09:13:41 +00:00
|
|
|
{"setdefaultencoding", sys_setdefaultencoding, 1, setdefaultencoding_doc},
|
1998-06-27 19:43:25 +00:00
|
|
|
{"setcheckinterval", sys_setcheckinterval, 1, setcheckinterval_doc},
|
|
|
|
{"setprofile", sys_setprofile, 0, setprofile_doc},
|
|
|
|
{"settrace", sys_settrace, 0, settrace_doc},
|
1990-12-20 15:06:42 +00:00
|
|
|
{NULL, NULL} /* sentinel */
|
|
|
|
};
|
|
|
|
|
1997-04-29 18:33:38 +00:00
|
|
|
static PyObject *
|
1993-01-26 13:33:44 +00:00
|
|
|
list_builtin_module_names()
|
|
|
|
{
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *list = PyList_New(0);
|
1993-01-26 13:33:44 +00:00
|
|
|
int i;
|
|
|
|
if (list == NULL)
|
|
|
|
return NULL;
|
1997-11-04 17:04:34 +00:00
|
|
|
for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
|
1997-05-05 20:56:21 +00:00
|
|
|
PyObject *name = PyString_FromString(
|
1997-11-04 17:04:34 +00:00
|
|
|
PyImport_Inittab[i].name);
|
1993-01-26 13:33:44 +00:00
|
|
|
if (name == NULL)
|
|
|
|
break;
|
1997-04-29 18:33:38 +00:00
|
|
|
PyList_Append(list, name);
|
|
|
|
Py_DECREF(name);
|
1993-01-26 13:33:44 +00:00
|
|
|
}
|
1997-04-29 18:33:38 +00:00
|
|
|
if (PyList_Sort(list) != 0) {
|
|
|
|
Py_DECREF(list);
|
1994-08-30 08:27:36 +00:00
|
|
|
list = NULL;
|
|
|
|
}
|
1997-01-06 22:55:54 +00:00
|
|
|
if (list) {
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *v = PyList_AsTuple(list);
|
|
|
|
Py_DECREF(list);
|
1997-01-06 22:55:54 +00:00
|
|
|
list = v;
|
|
|
|
}
|
1993-01-26 13:33:44 +00:00
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
1998-08-06 03:34:39 +00:00
|
|
|
/* XXX This doc string is too long to be a single string literal in VC++ 5.0.
|
|
|
|
Two literals concatenated works just fine. If you have a K&R compiler
|
|
|
|
or other abomination that however *does* understand longer strings,
|
|
|
|
get rid of the !!! comment in the middle and the quotes that surround it. */
|
1998-06-27 19:43:25 +00:00
|
|
|
static char sys_doc[] =
|
|
|
|
"This module provides access to some objects used or maintained by the\n\
|
|
|
|
interpreter and to functions that interact strongly with the interpreter.\n\
|
|
|
|
\n\
|
|
|
|
Dynamic objects:\n\
|
|
|
|
\n\
|
|
|
|
argv -- command line arguments; argv[0] is the script pathname if known\n\
|
|
|
|
path -- module search path; path[0] is the script directory, else ''\n\
|
|
|
|
modules -- dictionary of loaded modules\n\
|
|
|
|
exitfunc -- you may set this to a function to be called when Python exits\n\
|
|
|
|
\n\
|
|
|
|
stdin -- standard input file object; used by raw_input() and input()\n\
|
|
|
|
stdout -- standard output file object; used by the print statement\n\
|
|
|
|
stderr -- standard error object; used for error messages\n\
|
|
|
|
By assigning another file object (or an object that behaves like a file)\n\
|
|
|
|
to one of these, it is possible to redirect all of the interpreter's I/O.\n\
|
|
|
|
\n\
|
|
|
|
last_type -- type of last uncaught exception\n\
|
|
|
|
last_value -- value of last uncaught exception\n\
|
|
|
|
last_traceback -- traceback of last uncaught exception\n\
|
|
|
|
These three are only available in an interactive session after a\n\
|
|
|
|
traceback has been printed.\n\
|
|
|
|
\n\
|
|
|
|
exc_type -- type of exception currently being handled\n\
|
|
|
|
exc_value -- value of exception currently being handled\n\
|
|
|
|
exc_traceback -- traceback of exception currently being handled\n\
|
|
|
|
The function exc_info() should be used instead of these three,\n\
|
|
|
|
because it is thread-safe.\n\
|
1999-01-14 19:07:00 +00:00
|
|
|
"
|
|
|
|
#ifndef MS_WIN16
|
|
|
|
/* Concatenating string here */
|
|
|
|
"\n\
|
1998-06-27 19:43:25 +00:00
|
|
|
Static objects:\n\
|
|
|
|
\n\
|
|
|
|
maxint -- the largest supported integer (the smallest is -maxint-1)\n\
|
|
|
|
builtin_module_names -- tuple of module names built into this intepreter\n\
|
2000-04-13 15:29:10 +00:00
|
|
|
version -- the version of this interpreter as a string\n\
|
|
|
|
version_info -- version information as a tuple\n\
|
|
|
|
hexversion -- version information encoded as a single integer\n\
|
1998-06-27 19:43:25 +00:00
|
|
|
copyright -- copyright notice pertaining to this interpreter\n\
|
|
|
|
platform -- platform identifier\n\
|
|
|
|
executable -- pathname of this Python interpreter\n\
|
|
|
|
prefix -- prefix used to find the Python library\n\
|
|
|
|
exec_prefix -- prefix used to find the machine-specific Python library\n\
|
|
|
|
dllhandle -- [Windows only] integer handle of the Python DLL\n\
|
|
|
|
winver -- [Windows only] version number of the Python DLL\n\
|
|
|
|
__stdin__ -- the original stdin; don't use!\n\
|
|
|
|
__stdout__ -- the original stdout; don't use!\n\
|
|
|
|
__stderr__ -- the original stderr; don't use!\n\
|
|
|
|
\n\
|
|
|
|
Functions:\n\
|
|
|
|
\n\
|
|
|
|
exc_info() -- return thread-safe information about the current exception\n\
|
|
|
|
exit() -- exit the interpreter by raising SystemExit\n\
|
|
|
|
getrefcount() -- return the reference count for an object (plus one :-)\n\
|
|
|
|
setcheckinterval() -- control how often the interpreter checks for events\n\
|
|
|
|
setprofile() -- set the global profiling function\n\
|
|
|
|
settrace() -- set the global debug tracing function\n\
|
|
|
|
";
|
1999-01-14 19:07:00 +00:00
|
|
|
#endif
|
1998-06-27 19:43:25 +00:00
|
|
|
|
1997-08-02 03:10:38 +00:00
|
|
|
PyObject *
|
|
|
|
_PySys_Init()
|
1990-10-14 12:07:46 +00:00
|
|
|
{
|
1997-04-29 18:33:38 +00:00
|
|
|
extern int fclose Py_PROTO((FILE *));
|
1997-08-02 03:10:38 +00:00
|
|
|
PyObject *m, *v, *sysdict;
|
|
|
|
PyObject *sysin, *sysout, *syserr;
|
2000-04-13 20:03:20 +00:00
|
|
|
char *s;
|
1997-08-02 03:10:38 +00:00
|
|
|
|
1998-06-27 19:43:25 +00:00
|
|
|
m = Py_InitModule3("sys", sys_methods, sys_doc);
|
1997-04-29 18:33:38 +00:00
|
|
|
sysdict = PyModule_GetDict(m);
|
1997-08-02 03:10:38 +00:00
|
|
|
|
|
|
|
sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL);
|
|
|
|
sysout = PyFile_FromFile(stdout, "<stdout>", "w", NULL);
|
|
|
|
syserr = PyFile_FromFile(stderr, "<stderr>", "w", NULL);
|
1997-04-29 18:33:38 +00:00
|
|
|
if (PyErr_Occurred())
|
1997-08-02 03:10:38 +00:00
|
|
|
return NULL;
|
1997-04-29 18:33:38 +00:00
|
|
|
PyDict_SetItemString(sysdict, "stdin", sysin);
|
|
|
|
PyDict_SetItemString(sysdict, "stdout", sysout);
|
|
|
|
PyDict_SetItemString(sysdict, "stderr", syserr);
|
1998-02-19 20:53:06 +00:00
|
|
|
/* Make backup copies for cleanup */
|
|
|
|
PyDict_SetItemString(sysdict, "__stdin__", sysin);
|
|
|
|
PyDict_SetItemString(sysdict, "__stdout__", sysout);
|
|
|
|
PyDict_SetItemString(sysdict, "__stderr__", syserr);
|
1997-08-02 03:10:38 +00:00
|
|
|
Py_XDECREF(sysin);
|
|
|
|
Py_XDECREF(sysout);
|
|
|
|
Py_XDECREF(syserr);
|
1997-04-29 18:33:38 +00:00
|
|
|
PyDict_SetItemString(sysdict, "version",
|
|
|
|
v = PyString_FromString(Py_GetVersion()));
|
1999-01-27 16:33:19 +00:00
|
|
|
Py_XDECREF(v);
|
1999-01-03 12:55:39 +00:00
|
|
|
PyDict_SetItemString(sysdict, "hexversion",
|
|
|
|
v = PyInt_FromLong(PY_VERSION_HEX));
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_XDECREF(v);
|
2000-04-13 17:44:51 +00:00
|
|
|
/*
|
|
|
|
* These release level checks are mutually exclusive and cover
|
|
|
|
* the field, so don't get too fancy with the pre-processor!
|
|
|
|
*/
|
|
|
|
#if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
|
2000-04-13 20:03:20 +00:00
|
|
|
s = "alpha";
|
2000-04-13 17:44:51 +00:00
|
|
|
#endif
|
|
|
|
#if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
|
2000-04-13 20:03:20 +00:00
|
|
|
s = "beta";
|
2000-04-13 17:44:51 +00:00
|
|
|
#endif
|
|
|
|
#if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
|
2000-04-13 20:03:20 +00:00
|
|
|
s = "candidate";
|
2000-04-13 17:44:51 +00:00
|
|
|
#endif
|
2000-04-13 15:29:10 +00:00
|
|
|
#if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
|
2000-04-13 20:03:20 +00:00
|
|
|
s = "final";
|
2000-04-13 17:44:51 +00:00
|
|
|
#endif
|
2000-04-13 15:29:10 +00:00
|
|
|
PyDict_SetItemString(sysdict, "version_info",
|
2000-04-13 20:03:20 +00:00
|
|
|
v = Py_BuildValue("iiisi", PY_MAJOR_VERSION,
|
2000-04-13 15:29:10 +00:00
|
|
|
PY_MINOR_VERSION,
|
2000-04-13 20:03:20 +00:00
|
|
|
PY_MICRO_VERSION, s,
|
2000-04-13 17:44:51 +00:00
|
|
|
PY_RELEASE_SERIAL));
|
2000-04-13 15:29:10 +00:00
|
|
|
Py_XDECREF(v);
|
1997-04-29 18:33:38 +00:00
|
|
|
PyDict_SetItemString(sysdict, "copyright",
|
|
|
|
v = PyString_FromString(Py_GetCopyright()));
|
|
|
|
Py_XDECREF(v);
|
|
|
|
PyDict_SetItemString(sysdict, "platform",
|
|
|
|
v = PyString_FromString(Py_GetPlatform()));
|
|
|
|
Py_XDECREF(v);
|
1997-05-22 20:41:20 +00:00
|
|
|
PyDict_SetItemString(sysdict, "executable",
|
|
|
|
v = PyString_FromString(Py_GetProgramFullPath()));
|
|
|
|
Py_XDECREF(v);
|
1997-04-29 18:33:38 +00:00
|
|
|
PyDict_SetItemString(sysdict, "prefix",
|
|
|
|
v = PyString_FromString(Py_GetPrefix()));
|
|
|
|
Py_XDECREF(v);
|
|
|
|
PyDict_SetItemString(sysdict, "exec_prefix",
|
|
|
|
v = PyString_FromString(Py_GetExecPrefix()));
|
|
|
|
Py_XDECREF(v);
|
|
|
|
PyDict_SetItemString(sysdict, "maxint",
|
|
|
|
v = PyInt_FromLong(PyInt_GetMax()));
|
|
|
|
Py_XDECREF(v);
|
|
|
|
PyDict_SetItemString(sysdict, "builtin_module_names",
|
1995-01-02 19:04:15 +00:00
|
|
|
v = list_builtin_module_names());
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_XDECREF(v);
|
1996-08-23 18:14:47 +00:00
|
|
|
#ifdef MS_COREDLL
|
1997-04-29 18:33:38 +00:00
|
|
|
PyDict_SetItemString(sysdict, "dllhandle",
|
2000-06-28 22:07:35 +00:00
|
|
|
v = PyLong_FromVoidPtr(PyWin_DLLhModule));
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_XDECREF(v);
|
|
|
|
PyDict_SetItemString(sysdict, "winver",
|
1997-09-29 23:34:23 +00:00
|
|
|
v = PyString_FromString(PyWin_DLLVersionString));
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_XDECREF(v);
|
1996-04-09 02:37:57 +00:00
|
|
|
#endif
|
1997-04-29 18:33:38 +00:00
|
|
|
if (PyErr_Occurred())
|
1997-08-02 03:10:38 +00:00
|
|
|
return NULL;
|
|
|
|
return m;
|
1990-11-18 17:41:40 +00:00
|
|
|
}
|
|
|
|
|
1997-04-29 18:33:38 +00:00
|
|
|
static PyObject *
|
1990-12-20 15:06:42 +00:00
|
|
|
makepathobject(path, delim)
|
|
|
|
char *path;
|
|
|
|
int delim;
|
1990-11-18 17:41:40 +00:00
|
|
|
{
|
1990-12-20 15:06:42 +00:00
|
|
|
int i, n;
|
|
|
|
char *p;
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *v, *w;
|
1990-12-20 15:06:42 +00:00
|
|
|
|
|
|
|
n = 1;
|
|
|
|
p = path;
|
|
|
|
while ((p = strchr(p, delim)) != NULL) {
|
|
|
|
n++;
|
|
|
|
p++;
|
|
|
|
}
|
1997-04-29 18:33:38 +00:00
|
|
|
v = PyList_New(n);
|
1990-12-20 15:06:42 +00:00
|
|
|
if (v == NULL)
|
|
|
|
return NULL;
|
|
|
|
for (i = 0; ; i++) {
|
|
|
|
p = strchr(path, delim);
|
|
|
|
if (p == NULL)
|
|
|
|
p = strchr(path, '\0'); /* End of string */
|
1997-04-29 18:33:38 +00:00
|
|
|
w = PyString_FromStringAndSize(path, (int) (p - path));
|
1990-12-20 15:06:42 +00:00
|
|
|
if (w == NULL) {
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_DECREF(v);
|
1990-12-20 15:06:42 +00:00
|
|
|
return NULL;
|
1990-11-18 17:41:40 +00:00
|
|
|
}
|
1997-04-29 18:33:38 +00:00
|
|
|
PyList_SetItem(v, i, w);
|
1990-12-20 15:06:42 +00:00
|
|
|
if (*p == '\0')
|
|
|
|
break;
|
|
|
|
path = p+1;
|
1990-11-18 17:41:40 +00:00
|
|
|
}
|
1990-12-20 15:06:42 +00:00
|
|
|
return v;
|
1990-10-14 12:07:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
1997-04-29 18:33:38 +00:00
|
|
|
PySys_SetPath(path)
|
1990-12-20 15:06:42 +00:00
|
|
|
char *path;
|
1990-10-14 12:07:46 +00:00
|
|
|
{
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *v;
|
1990-12-20 15:06:42 +00:00
|
|
|
if ((v = makepathobject(path, DELIM)) == NULL)
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_FatalError("can't create sys.path");
|
|
|
|
if (PySys_SetObject("path", v) != 0)
|
|
|
|
Py_FatalError("can't assign sys.path");
|
|
|
|
Py_DECREF(v);
|
1990-12-20 15:06:42 +00:00
|
|
|
}
|
|
|
|
|
1997-04-29 18:33:38 +00:00
|
|
|
static PyObject *
|
1990-12-20 15:06:42 +00:00
|
|
|
makeargvobject(argc, argv)
|
|
|
|
int argc;
|
|
|
|
char **argv;
|
|
|
|
{
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *av;
|
1992-01-14 18:42:53 +00:00
|
|
|
if (argc <= 0 || argv == NULL) {
|
|
|
|
/* Ensure at least one (empty) argument is seen */
|
|
|
|
static char *empty_argv[1] = {""};
|
|
|
|
argv = empty_argv;
|
|
|
|
argc = 1;
|
|
|
|
}
|
1997-04-29 18:33:38 +00:00
|
|
|
av = PyList_New(argc);
|
1990-12-20 15:06:42 +00:00
|
|
|
if (av != NULL) {
|
1990-11-18 17:41:40 +00:00
|
|
|
int i;
|
1990-12-20 15:06:42 +00:00
|
|
|
for (i = 0; i < argc; i++) {
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *v = PyString_FromString(argv[i]);
|
1990-12-20 15:06:42 +00:00
|
|
|
if (v == NULL) {
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_DECREF(av);
|
1990-12-20 15:06:42 +00:00
|
|
|
av = NULL;
|
|
|
|
break;
|
1990-11-18 17:41:40 +00:00
|
|
|
}
|
1997-04-29 18:33:38 +00:00
|
|
|
PyList_SetItem(av, i, v);
|
1990-11-18 17:41:40 +00:00
|
|
|
}
|
|
|
|
}
|
1990-12-20 15:06:42 +00:00
|
|
|
return av;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
1997-04-29 18:33:38 +00:00
|
|
|
PySys_SetArgv(argc, argv)
|
1990-12-20 15:06:42 +00:00
|
|
|
int argc;
|
|
|
|
char **argv;
|
|
|
|
{
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *av = makeargvobject(argc, argv);
|
|
|
|
PyObject *path = PySys_GetObject("path");
|
1990-12-20 15:06:42 +00:00
|
|
|
if (av == NULL)
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_FatalError("no mem for sys.argv");
|
|
|
|
if (PySys_SetObject("argv", av) != 0)
|
|
|
|
Py_FatalError("can't assign sys.argv");
|
1996-07-30 20:35:50 +00:00
|
|
|
if (path != NULL) {
|
1997-04-25 15:38:31 +00:00
|
|
|
char *argv0 = argv[0];
|
1996-07-30 20:35:50 +00:00
|
|
|
char *p = NULL;
|
1996-09-10 14:44:21 +00:00
|
|
|
int n = 0;
|
1997-04-29 18:33:38 +00:00
|
|
|
PyObject *a;
|
1997-04-25 15:38:31 +00:00
|
|
|
#ifdef HAVE_READLINK
|
|
|
|
char link[MAXPATHLEN+1];
|
|
|
|
char argv0copy[2*MAXPATHLEN+1];
|
|
|
|
int nr = 0;
|
|
|
|
if (argc > 0 && argv0 != NULL)
|
|
|
|
nr = readlink(argv0, link, MAXPATHLEN);
|
|
|
|
if (nr > 0) {
|
|
|
|
/* It's a symlink */
|
|
|
|
link[nr] = '\0';
|
|
|
|
if (link[0] == SEP)
|
|
|
|
argv0 = link; /* Link to absolute path */
|
|
|
|
else if (strchr(link, SEP) == NULL)
|
|
|
|
; /* Link without path */
|
|
|
|
else {
|
|
|
|
/* Must join(dirname(argv0), link) */
|
|
|
|
char *q = strrchr(argv0, SEP);
|
|
|
|
if (q == NULL)
|
|
|
|
argv0 = link; /* argv0 without path */
|
|
|
|
else {
|
|
|
|
/* Must make a copy */
|
|
|
|
strcpy(argv0copy, argv0);
|
|
|
|
q = strrchr(argv0copy, SEP);
|
|
|
|
strcpy(q+1, link);
|
|
|
|
argv0 = argv0copy;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* HAVE_READLINK */
|
1996-09-10 14:44:21 +00:00
|
|
|
#if SEP == '\\' /* Special case for MS filename syntax */
|
1997-04-25 15:38:31 +00:00
|
|
|
if (argc > 0 && argv0 != NULL) {
|
1996-09-10 14:44:21 +00:00
|
|
|
char *q;
|
1997-04-25 15:38:31 +00:00
|
|
|
p = strrchr(argv0, SEP);
|
1996-09-10 14:44:21 +00:00
|
|
|
/* Test for alternate separator */
|
1997-04-25 15:38:31 +00:00
|
|
|
q = strrchr(p ? p : argv0, '/');
|
1996-09-10 14:44:21 +00:00
|
|
|
if (q != NULL)
|
|
|
|
p = q;
|
|
|
|
if (p != NULL) {
|
1997-04-25 15:38:31 +00:00
|
|
|
n = p + 1 - argv0;
|
1996-09-10 14:44:21 +00:00
|
|
|
if (n > 1 && p[-1] != ':')
|
|
|
|
n--; /* Drop trailing separator */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else /* All other filename syntaxes */
|
1997-04-25 15:38:31 +00:00
|
|
|
if (argc > 0 && argv0 != NULL)
|
|
|
|
p = strrchr(argv0, SEP);
|
1996-09-10 14:44:21 +00:00
|
|
|
if (p != NULL) {
|
1997-04-25 15:38:31 +00:00
|
|
|
n = p + 1 - argv0;
|
1996-09-10 14:44:21 +00:00
|
|
|
#if SEP == '/' /* Special case for Unix filename syntax */
|
|
|
|
if (n > 1)
|
|
|
|
n--; /* Drop trailing separator */
|
|
|
|
#endif /* Unix */
|
|
|
|
}
|
|
|
|
#endif /* All others */
|
1997-04-29 18:33:38 +00:00
|
|
|
a = PyString_FromStringAndSize(argv0, n);
|
1996-07-30 20:35:50 +00:00
|
|
|
if (a == NULL)
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_FatalError("no mem for sys.path insertion");
|
|
|
|
if (PyList_Insert(path, 0, a) < 0)
|
|
|
|
Py_FatalError("sys.path.insert(0) failed");
|
|
|
|
Py_DECREF(a);
|
1996-07-24 01:31:37 +00:00
|
|
|
}
|
1997-04-29 18:33:38 +00:00
|
|
|
Py_DECREF(av);
|
1990-10-14 12:07:46 +00:00
|
|
|
}
|
1998-05-12 14:59:24 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
|
|
|
|
Adapted from code submitted by Just van Rossum.
|
|
|
|
|
|
|
|
PySys_WriteStdout(format, ...)
|
|
|
|
PySys_WriteStderr(format, ...)
|
|
|
|
|
|
|
|
The first function writes to sys.stdout; the second to sys.stderr. When
|
|
|
|
there is a problem, they write to the real (C level) stdout or stderr;
|
1998-10-12 18:22:10 +00:00
|
|
|
no exceptions are raised.
|
1998-05-12 14:59:24 +00:00
|
|
|
|
|
|
|
Both take a printf-style format string as their first argument followed
|
|
|
|
by a variable length argument list determined by the format string.
|
|
|
|
|
|
|
|
*** WARNING ***
|
|
|
|
|
|
|
|
The format should limit the total size of the formatted output string to
|
|
|
|
1000 bytes. In particular, this means that no unrestricted "%s" formats
|
|
|
|
should occur; these should be limited using "%.<N>s where <N> is a
|
|
|
|
decimal number calculated so that <N> plus the maximum size of other
|
|
|
|
formatted text does not exceed 1000 bytes. Also watch out for "%f",
|
|
|
|
which can print hundreds of digits for very large numbers.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
mywrite(name, fp, format, va)
|
|
|
|
char *name;
|
|
|
|
FILE *fp;
|
|
|
|
const char *format;
|
|
|
|
va_list va;
|
|
|
|
{
|
|
|
|
PyObject *file;
|
1998-10-12 18:22:10 +00:00
|
|
|
PyObject *error_type, *error_value, *error_traceback;
|
1998-05-12 14:59:24 +00:00
|
|
|
|
1998-10-12 18:22:10 +00:00
|
|
|
PyErr_Fetch(&error_type, &error_value, &error_traceback);
|
1998-05-12 14:59:24 +00:00
|
|
|
file = PySys_GetObject(name);
|
|
|
|
if (file == NULL || PyFile_AsFile(file) == fp)
|
|
|
|
vfprintf(fp, format, va);
|
|
|
|
else {
|
|
|
|
char buffer[1001];
|
1998-10-12 18:22:10 +00:00
|
|
|
if (vsprintf(buffer, format, va) >= sizeof(buffer))
|
|
|
|
Py_FatalError("PySys_WriteStdout/err: buffer overrun");
|
1998-05-12 14:59:24 +00:00
|
|
|
if (PyFile_WriteString(buffer, file) != 0) {
|
|
|
|
PyErr_Clear();
|
|
|
|
fputs(buffer, fp);
|
|
|
|
}
|
|
|
|
}
|
1998-10-12 18:22:10 +00:00
|
|
|
PyErr_Restore(error_type, error_value, error_traceback);
|
1998-05-12 14:59:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
#ifdef HAVE_STDARG_PROTOTYPES
|
|
|
|
PySys_WriteStdout(const char *format, ...)
|
|
|
|
#else
|
|
|
|
PySys_WriteStdout(va_alist)
|
|
|
|
va_dcl
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
va_list va;
|
|
|
|
|
|
|
|
#ifdef HAVE_STDARG_PROTOTYPES
|
|
|
|
va_start(va, format);
|
|
|
|
#else
|
|
|
|
char *format;
|
|
|
|
va_start(va);
|
|
|
|
format = va_arg(va, char *);
|
|
|
|
#endif
|
|
|
|
mywrite("stdout", stdout, format, va);
|
|
|
|
va_end(va);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
#ifdef HAVE_STDARG_PROTOTYPES
|
|
|
|
PySys_WriteStderr(const char *format, ...)
|
|
|
|
#else
|
|
|
|
PySys_WriteStderr(va_alist)
|
|
|
|
va_dcl
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
va_list va;
|
|
|
|
|
|
|
|
#ifdef HAVE_STDARG_PROTOTYPES
|
|
|
|
va_start(va, format);
|
|
|
|
#else
|
|
|
|
char *format;
|
|
|
|
va_start(va);
|
|
|
|
format = va_arg(va, char *);
|
|
|
|
#endif
|
|
|
|
mywrite("stderr", stderr, format, va);
|
|
|
|
va_end(va);
|
|
|
|
}
|