STRUCT_FOR_ID(exception)
STRUCT_FOR_ID(exp)
STRUCT_FOR_ID(extend)
+ STRUCT_FOR_ID(facility)
STRUCT_FOR_ID(factory)
STRUCT_FOR_ID(family)
STRUCT_FOR_ID(fanout)
STRUCT_FOR_ID(hi)
STRUCT_FOR_ID(hook)
STRUCT_FOR_ID(id)
+ STRUCT_FOR_ID(ident)
STRUCT_FOR_ID(ignore)
STRUCT_FOR_ID(imag)
STRUCT_FOR_ID(importlib)
STRUCT_FOR_ID(lo)
STRUCT_FOR_ID(locale)
STRUCT_FOR_ID(locals)
+ STRUCT_FOR_ID(logoption)
STRUCT_FOR_ID(loop)
STRUCT_FOR_ID(mapping)
STRUCT_FOR_ID(match)
INIT_ID(exception), \
INIT_ID(exp), \
INIT_ID(extend), \
+ INIT_ID(facility), \
INIT_ID(factory), \
INIT_ID(family), \
INIT_ID(fanout), \
INIT_ID(hi), \
INIT_ID(hook), \
INIT_ID(id), \
+ INIT_ID(ident), \
INIT_ID(ignore), \
INIT_ID(imag), \
INIT_ID(importlib), \
INIT_ID(lo), \
INIT_ID(locale), \
INIT_ID(locals), \
+ INIT_ID(logoption), \
INIT_ID(loop), \
INIT_ID(mapping), \
INIT_ID(match), \
PyUnicode_InternInPlace(&string);
string = &_Py_ID(extend);
PyUnicode_InternInPlace(&string);
+ string = &_Py_ID(facility);
+ PyUnicode_InternInPlace(&string);
string = &_Py_ID(factory);
PyUnicode_InternInPlace(&string);
string = &_Py_ID(family);
PyUnicode_InternInPlace(&string);
string = &_Py_ID(id);
PyUnicode_InternInPlace(&string);
+ string = &_Py_ID(ident);
+ PyUnicode_InternInPlace(&string);
string = &_Py_ID(ignore);
PyUnicode_InternInPlace(&string);
string = &_Py_ID(imag);
PyUnicode_InternInPlace(&string);
string = &_Py_ID(locals);
PyUnicode_InternInPlace(&string);
+ string = &_Py_ID(logoption);
+ PyUnicode_InternInPlace(&string);
string = &_Py_ID(loop);
PyUnicode_InternInPlace(&string);
string = &_Py_ID(mapping);
_PyObject_Dump((PyObject *)&_Py_ID(extend));
Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
};
+ if (Py_REFCNT((PyObject *)&_Py_ID(facility)) < _PyObject_IMMORTAL_REFCNT) {
+ _PyObject_Dump((PyObject *)&_Py_ID(facility));
+ Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
+ };
if (Py_REFCNT((PyObject *)&_Py_ID(factory)) < _PyObject_IMMORTAL_REFCNT) {
_PyObject_Dump((PyObject *)&_Py_ID(factory));
Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
_PyObject_Dump((PyObject *)&_Py_ID(id));
Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
};
+ if (Py_REFCNT((PyObject *)&_Py_ID(ident)) < _PyObject_IMMORTAL_REFCNT) {
+ _PyObject_Dump((PyObject *)&_Py_ID(ident));
+ Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
+ };
if (Py_REFCNT((PyObject *)&_Py_ID(ignore)) < _PyObject_IMMORTAL_REFCNT) {
_PyObject_Dump((PyObject *)&_Py_ID(ignore));
Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
_PyObject_Dump((PyObject *)&_Py_ID(locals));
Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
};
+ if (Py_REFCNT((PyObject *)&_Py_ID(logoption)) < _PyObject_IMMORTAL_REFCNT) {
+ _PyObject_Dump((PyObject *)&_Py_ID(logoption));
+ Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
+ };
if (Py_REFCNT((PyObject *)&_Py_ID(loop)) < _PyObject_IMMORTAL_REFCNT) {
_PyObject_Dump((PyObject *)&_Py_ID(loop));
Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
--- /dev/null
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+# include "pycore_gc.h" // PyGC_Head
+# include "pycore_runtime.h" // _Py_ID()
+#endif
+
+
+PyDoc_STRVAR(syslog_openlog__doc__,
+"openlog($module, /, ident=<unrepresentable>, logoption=0,\n"
+" facility=LOG_USER)\n"
+"--\n"
+"\n"
+"Set logging options of subsequent syslog() calls.");
+
+#define SYSLOG_OPENLOG_METHODDEF \
+ {"openlog", _PyCFunction_CAST(syslog_openlog), METH_FASTCALL|METH_KEYWORDS, syslog_openlog__doc__},
+
+static PyObject *
+syslog_openlog_impl(PyObject *module, PyObject *ident, long logopt,
+ long facility);
+
+static PyObject *
+syslog_openlog(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 3
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(ident), &_Py_ID(logoption), &_Py_ID(facility), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"ident", "logoption", "facility", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "openlog",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[3];
+ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
+ PyObject *ident = NULL;
+ long logopt = 0;
+ long facility = LOG_USER;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 3, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ if (!noptargs) {
+ goto skip_optional_pos;
+ }
+ if (args[0]) {
+ if (!PyUnicode_Check(args[0])) {
+ _PyArg_BadArgument("openlog", "argument 'ident'", "str", args[0]);
+ goto exit;
+ }
+ if (PyUnicode_READY(args[0]) == -1) {
+ goto exit;
+ }
+ ident = args[0];
+ if (!--noptargs) {
+ goto skip_optional_pos;
+ }
+ }
+ if (args[1]) {
+ logopt = PyLong_AsLong(args[1]);
+ if (logopt == -1 && PyErr_Occurred()) {
+ goto exit;
+ }
+ if (!--noptargs) {
+ goto skip_optional_pos;
+ }
+ }
+ facility = PyLong_AsLong(args[2]);
+ if (facility == -1 && PyErr_Occurred()) {
+ goto exit;
+ }
+skip_optional_pos:
+ return_value = syslog_openlog_impl(module, ident, logopt, facility);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(syslog_syslog__doc__,
+"syslog([priority=LOG_INFO,] message)\n"
+"Send the string message to the system logger.");
+
+#define SYSLOG_SYSLOG_METHODDEF \
+ {"syslog", (PyCFunction)syslog_syslog, METH_VARARGS, syslog_syslog__doc__},
+
+static PyObject *
+syslog_syslog_impl(PyObject *module, int group_left_1, int priority,
+ const char *message);
+
+static PyObject *
+syslog_syslog(PyObject *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ int group_left_1 = 0;
+ int priority = LOG_INFO;
+ const char *message;
+
+ switch (PyTuple_GET_SIZE(args)) {
+ case 1:
+ if (!PyArg_ParseTuple(args, "s:syslog", &message)) {
+ goto exit;
+ }
+ break;
+ case 2:
+ if (!PyArg_ParseTuple(args, "is:syslog", &priority, &message)) {
+ goto exit;
+ }
+ group_left_1 = 1;
+ break;
+ default:
+ PyErr_SetString(PyExc_TypeError, "syslog.syslog requires 1 to 2 arguments");
+ goto exit;
+ }
+ return_value = syslog_syslog_impl(module, group_left_1, priority, message);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(syslog_closelog__doc__,
+"closelog($module, /)\n"
+"--\n"
+"\n"
+"Reset the syslog module values and call the system library closelog().");
+
+#define SYSLOG_CLOSELOG_METHODDEF \
+ {"closelog", (PyCFunction)syslog_closelog, METH_NOARGS, syslog_closelog__doc__},
+
+static PyObject *
+syslog_closelog_impl(PyObject *module);
+
+static PyObject *
+syslog_closelog(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+ return syslog_closelog_impl(module);
+}
+
+PyDoc_STRVAR(syslog_setlogmask__doc__,
+"setlogmask($module, maskpri, /)\n"
+"--\n"
+"\n"
+"Set the priority mask to maskpri and return the previous mask value.");
+
+#define SYSLOG_SETLOGMASK_METHODDEF \
+ {"setlogmask", (PyCFunction)syslog_setlogmask, METH_O, syslog_setlogmask__doc__},
+
+static long
+syslog_setlogmask_impl(PyObject *module, long maskpri);
+
+static PyObject *
+syslog_setlogmask(PyObject *module, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ long maskpri;
+ long _return_value;
+
+ maskpri = PyLong_AsLong(arg);
+ if (maskpri == -1 && PyErr_Occurred()) {
+ goto exit;
+ }
+ _return_value = syslog_setlogmask_impl(module, maskpri);
+ if ((_return_value == -1) && PyErr_Occurred()) {
+ goto exit;
+ }
+ return_value = PyLong_FromLong(_return_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(syslog_LOG_MASK__doc__,
+"LOG_MASK($module, pri, /)\n"
+"--\n"
+"\n"
+"Calculates the mask for the individual priority pri.");
+
+#define SYSLOG_LOG_MASK_METHODDEF \
+ {"LOG_MASK", (PyCFunction)syslog_LOG_MASK, METH_O, syslog_LOG_MASK__doc__},
+
+static long
+syslog_LOG_MASK_impl(PyObject *module, long pri);
+
+static PyObject *
+syslog_LOG_MASK(PyObject *module, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ long pri;
+ long _return_value;
+
+ pri = PyLong_AsLong(arg);
+ if (pri == -1 && PyErr_Occurred()) {
+ goto exit;
+ }
+ _return_value = syslog_LOG_MASK_impl(module, pri);
+ if ((_return_value == -1) && PyErr_Occurred()) {
+ goto exit;
+ }
+ return_value = PyLong_FromLong(_return_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(syslog_LOG_UPTO__doc__,
+"LOG_UPTO($module, pri, /)\n"
+"--\n"
+"\n"
+"Calculates the mask for all priorities up to and including pri.");
+
+#define SYSLOG_LOG_UPTO_METHODDEF \
+ {"LOG_UPTO", (PyCFunction)syslog_LOG_UPTO, METH_O, syslog_LOG_UPTO__doc__},
+
+static long
+syslog_LOG_UPTO_impl(PyObject *module, long pri);
+
+static PyObject *
+syslog_LOG_UPTO(PyObject *module, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ long pri;
+ long _return_value;
+
+ pri = PyLong_AsLong(arg);
+ if (pri == -1 && PyErr_Occurred()) {
+ goto exit;
+ }
+ _return_value = syslog_LOG_UPTO_impl(module, pri);
+ if ((_return_value == -1) && PyErr_Occurred()) {
+ goto exit;
+ }
+ return_value = PyLong_FromLong(_return_value);
+
+exit:
+ return return_value;
+}
+/*[clinic end generated code: output=3b1bdb16565b8fda input=a9049054013a1b77]*/
#include <syslog.h>
+/*[clinic input]
+module syslog
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=478f4ac94a1d4cae]*/
+
+#include "clinic/syslogmodule.c.h"
+
/* only one instance, only one syslog, so globals should be ok */
static PyObject *S_ident_o = NULL; /* identifier, held by openlog() */
static char S_log_open = 0;
}
+/*[clinic input]
+syslog.openlog
+
+ ident: unicode = NULL
+ logoption as logopt: long = 0
+ facility: long(c_default="LOG_USER") = LOG_USER
+
+Set logging options of subsequent syslog() calls.
+[clinic start generated code]*/
+
static PyObject *
-syslog_openlog(PyObject * self, PyObject * args, PyObject *kwds)
+syslog_openlog_impl(PyObject *module, PyObject *ident, long logopt,
+ long facility)
+/*[clinic end generated code: output=5476c12829b6eb75 input=8a987a96a586eee7]*/
{
- long logopt = 0;
- long facility = LOG_USER;
- PyObject *ident = NULL;
- static char *keywords[] = {"ident", "logoption", "facility", 0};
const char *ident_str = NULL;
- if (!PyArg_ParseTupleAndKeywords(args, kwds,
- "|Ull:openlog", keywords, &ident, &logopt, &facility))
- return NULL;
-
if (ident) {
Py_INCREF(ident);
}
}
-static PyObject *
-syslog_syslog(PyObject * self, PyObject * args)
-{
- PyObject *message_object;
- const char *message;
- int priority = LOG_INFO;
- if (!PyArg_ParseTuple(args, "iU;[priority,] message string",
- &priority, &message_object)) {
- PyErr_Clear();
- if (!PyArg_ParseTuple(args, "U;[priority,] message string",
- &message_object))
- return NULL;
- }
+/*[clinic input]
+syslog.syslog
- message = PyUnicode_AsUTF8(message_object);
- if (message == NULL)
- return NULL;
+ [
+ priority: int(c_default="LOG_INFO") = LOG_INFO
+ ]
+
+ message: str
+
+ /
+Send the string message to the system logger.
+[clinic start generated code]*/
+
+static PyObject *
+syslog_syslog_impl(PyObject *module, int group_left_1, int priority,
+ const char *message)
+/*[clinic end generated code: output=c3dbc73445a0e078 input=ac83d92b12ea3d4e]*/
+{
if (PySys_Audit("syslog.syslog", "is", priority, message) < 0) {
return NULL;
}
/* if log is not opened, open it now */
if (!S_log_open) {
- PyObject *openargs;
-
- /* Continue even if PyTuple_New fails, because openlog(3) is optional.
- * So, we can still do logging in the unlikely event things are so hosed
- * that we can't do this tuple.
- */
- if ((openargs = PyTuple_New(0))) {
- PyObject *openlog_ret = syslog_openlog(self, openargs, NULL);
- Py_DECREF(openargs);
- if (openlog_ret == NULL) {
- return NULL;
- }
- Py_DECREF(openlog_ret);
- }
- else {
+ PyObject *openlog_ret = syslog_openlog_impl(module, NULL, 0, LOG_USER);
+ if (openlog_ret == NULL) {
return NULL;
}
+ Py_DECREF(openlog_ret);
}
/* Incref ident, because it can be decrefed if syslog.openlog() is
Py_RETURN_NONE;
}
+
+/*[clinic input]
+syslog.closelog
+
+Reset the syslog module values and call the system library closelog().
+[clinic start generated code]*/
+
static PyObject *
-syslog_closelog(PyObject *self, PyObject *unused)
+syslog_closelog_impl(PyObject *module)
+/*[clinic end generated code: output=97890a80a24b1b84 input=fb77a54d447acf07]*/
{
if (PySys_Audit("syslog.closelog", NULL) < 0) {
return NULL;
Py_RETURN_NONE;
}
-static PyObject *
-syslog_setlogmask(PyObject *self, PyObject *args)
-{
- long maskpri, omaskpri;
+/*[clinic input]
+syslog.setlogmask -> long
- if (!PyArg_ParseTuple(args, "l;mask for priority", &maskpri))
- return NULL;
+ maskpri: long
+ /
+
+Set the priority mask to maskpri and return the previous mask value.
+[clinic start generated code]*/
+
+static long
+syslog_setlogmask_impl(PyObject *module, long maskpri)
+/*[clinic end generated code: output=d6ed163917b434bf input=adff2c2b76c7629c]*/
+{
if (PySys_Audit("syslog.setlogmask", "l", maskpri) < 0) {
- return NULL;
+ return -1;
}
- omaskpri = setlogmask(maskpri);
- return PyLong_FromLong(omaskpri);
+
+ return setlogmask(maskpri);
}
-static PyObject *
-syslog_log_mask(PyObject *self, PyObject *args)
+/*[clinic input]
+syslog.LOG_MASK -> long
+
+ pri: long
+ /
+
+Calculates the mask for the individual priority pri.
+[clinic start generated code]*/
+
+static long
+syslog_LOG_MASK_impl(PyObject *module, long pri)
+/*[clinic end generated code: output=c4a5bbfcc74c7c94 input=534829cb7fb5f7d2]*/
{
- long mask;
- long pri;
- if (!PyArg_ParseTuple(args, "l:LOG_MASK", &pri))
- return NULL;
- mask = LOG_MASK(pri);
- return PyLong_FromLong(mask);
+ return LOG_MASK(pri);
}
-static PyObject *
-syslog_log_upto(PyObject *self, PyObject *args)
+/*[clinic input]
+syslog.LOG_UPTO -> long
+
+ pri: long
+ /
+
+Calculates the mask for all priorities up to and including pri.
+[clinic start generated code]*/
+
+static long
+syslog_LOG_UPTO_impl(PyObject *module, long pri)
+/*[clinic end generated code: output=9eab083c90601d7e input=5e906d6c406b7458]*/
{
- long mask;
- long pri;
- if (!PyArg_ParseTuple(args, "l:LOG_UPTO", &pri))
- return NULL;
- mask = LOG_UPTO(pri);
- return PyLong_FromLong(mask);
+ return LOG_UPTO(pri);
}
/* List of functions defined in the module */
static PyMethodDef syslog_methods[] = {
- {"openlog", _PyCFunction_CAST(syslog_openlog), METH_VARARGS | METH_KEYWORDS},
- {"closelog", syslog_closelog, METH_NOARGS},
- {"syslog", syslog_syslog, METH_VARARGS},
- {"setlogmask", syslog_setlogmask, METH_VARARGS},
- {"LOG_MASK", syslog_log_mask, METH_VARARGS},
- {"LOG_UPTO", syslog_log_upto, METH_VARARGS},
+ SYSLOG_OPENLOG_METHODDEF
+ SYSLOG_CLOSELOG_METHODDEF
+ SYSLOG_SYSLOG_METHODDEF
+ SYSLOG_SETLOGMASK_METHODDEF
+ SYSLOG_LOG_MASK_METHODDEF
+ SYSLOG_LOG_UPTO_METHODDEF
{NULL, NULL, 0}
};
projects / thirdparty / Python / cpython.git / commitdiff
