--- /dev/null
+/***********************************************************
+Copyright 1994 by Lance Ellinghouse,
+Cathedral City, California Republic, United States of America.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Lance Ellinghouse
+not be used in advertising or publicity pertaining to distribution
+of the software without specific, written prior permission.
+
+LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE BE LIABLE FOR ANY SPECIAL,
+INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/* curses module */
+
+#include "allobjects.h"
+#include "fileobject.h"
+#include "modsupport.h"
+
+#include <curses.h>
+
+#include "rename1.h"
+
+typedef struct {
+ PyObject_HEAD
+ SCREEN *scr;
+} PyCursesScreenObject;
+
+typedef struct {
+ PyObject_HEAD
+ WINDOW *win;
+ WINDOW *parent;
+} PyCursesWindowObject;
+
+typedef struct {
+ PyObject_HEAD
+ WINDOW *pad;
+} PyCursesPadObject;
+
+staticforward PyTypeObject PyCursesScreen_Type;
+staticforward PyTypeObject PyCursesWindow_Type;
+staticforward PyTypeObject PyCursesPad_Type;
+
+#define PyCursesScreen_Check(v) ((v)->ob_type == &PyCursesScreen_Type)
+#define PyCursesWindow_Check(v) ((v)->ob_type == &PyCursesWindow_Type)
+#define PyCursesPad_Check(v) ((v)->ob_type == &PyCursesPad_Type)
+
+/* Defines */
+PyObject *PyCurses_OK;
+PyObject *PyCurses_ERR;
+
+/* ------------- SCREEN routines --------------- */
+#ifdef NOT_YET
+static PyObject *
+PyCursesScreen_New(arg)
+ PyObject * arg;
+{
+ char *term_type;
+ PyFileObject *in_fo;
+ PyFileObject *out_fo;
+ PyCursesScreenObject *xp;
+ xp = (PyObject *)PyObject_NEW(PyCursesScreenObject, &PyCursesScreen_Type);
+ if (xp == NULL)
+ return NULL;
+ return (PyObject *)xp;
+}
+#endif
+/* ------------- WINDOW routines --------------- */
+static PyObject *
+PyCursesWindow_New(win)
+ WINDOW *win;
+{
+ PyCursesWindowObject *wo;
+ wo = (PyCursesWindowObject *)PyObject_NEW(PyCursesWindowObject, &PyCursesWindow_Type);
+ if (wo == NULL)
+ return NULL;
+ wo->win = win;
+ wo->parent = (WINDOW *)NULL;
+ return (PyObject *)wo;
+}
+
+static void
+PyCursesWindow_Dealloc(wo)
+ PyCursesWindowObject *wo;
+{
+ if (wo->win != stdscr)
+ delwin(wo->win);
+ PyMem_DEL(wo);
+}
+
+static PyObject *
+PyCursesWindow_Refresh(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ return (PyObject *)PyInt_FromLong(wrefresh(self->win));
+}
+
+static PyObject *
+PyCursesWindow_NoOutRefresh(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ return (PyObject *)PyInt_FromLong(wnoutrefresh(self->win));
+}
+
+static PyObject *
+PyCursesWindow_MoveWin(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int rtn;
+ int x, y;
+ if (!PyArg_Parse(arg,"(ii)", &y, &x))
+ return (PyObject *)NULL;
+ rtn = mvwin(self->win,y,x);
+ if (rtn == OK) {
+ Py_INCREF(PyCurses_OK);
+ return (PyObject *)PyCurses_OK;
+ }
+ Py_INCREF(PyCurses_ERR);
+ return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_Move(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int rtn;
+ int x, y;
+ if (!PyArg_Parse(arg,"(ii)", &y, &x))
+ return (PyObject *)NULL;
+ rtn = wmove(self->win,y,x);
+ if (rtn == OK) {
+ Py_INCREF(PyCurses_OK);
+ return (PyObject *)PyCurses_OK;
+ }
+ Py_INCREF(PyCurses_ERR);
+ return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_SubWin(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ WINDOW *win;
+ PyCursesWindowObject *rtn_win;
+ int nlines, ncols, begin_y, begin_x;
+ nlines = 0;
+ ncols = 0;
+ if (!PyArg_Parse(arg,
+ "(iiii);nlines,ncols,begin_y,begin_x",
+ &nlines,&ncols,&begin_y,&begin_x))
+ if (!PyArg_Parse(arg,"(ii)",&begin_y,&begin_x))
+ return (PyObject *)NULL;
+ win = subwin(self->win,nlines,ncols,begin_y,begin_x);
+ if (win == NULL) {
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+ }
+ rtn_win = (PyCursesWindowObject *)PyCursesWindow_New(win);
+ rtn_win->parent = self->win;
+ return (PyObject *)rtn_win;
+}
+
+static PyObject *
+PyCursesWindow_AddCh(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int rtn;
+ int x, y;
+ int ch;
+ int attr;
+ int attr_old;
+ int use_xy = TRUE;
+ int use_attr = TRUE;
+ switch (PyTuple_Size(arg)) {
+ case 2:
+ case 4:
+ use_attr = TRUE;
+ break;
+ default:
+ use_attr = FALSE;
+ }
+ if (!PyArg_Parse(arg,"(iiii);y,x,ch,attr", &y, &x, &ch, &attr)) {
+ if (!PyArg_Parse(arg,"(iii);y,x,ch", &y, &x, &ch)) {
+ use_xy = FALSE;
+ if (!PyArg_Parse(arg,"(ii);ch,attr", &ch, &attr))
+ if (!PyArg_Parse(arg,"i;ch", &ch))
+ return (PyObject *)NULL;
+ }
+ }
+ if (use_attr == TRUE) {
+ attr_old = getattrs(self->win);
+ wattrset(self->win,attr);
+ }
+ if (use_xy == TRUE)
+ rtn = mvwaddch(self->win,y,x,ch);
+ else
+ rtn = waddch(self->win,ch);
+ if (use_attr == TRUE)
+ wattrset(self->win,attr_old);
+ if (rtn == OK) {
+ Py_INCREF(PyCurses_OK);
+ return (PyObject *)PyCurses_OK;
+ }
+ Py_INCREF(PyCurses_ERR);
+ return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_InsCh(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int rtn;
+ int x, y;
+ int ch;
+ int use_xy = TRUE;
+ int attr, attr_old, use_attr = FALSE;
+ switch (PyTuple_Size(arg)) {
+ case 2:
+ case 4:
+ use_attr = TRUE;
+ break;
+ default:
+ use_attr = FALSE;
+ }
+ if (!PyArg_Parse(arg,"(iiii);y,x,ch,attr", &y, &x, &ch, &attr)) {
+ if (!PyArg_Parse(arg,"(iii);y,x,ch", &y, &x, &ch)) {
+ use_xy = FALSE;
+ if (!PyArg_Parse(arg,"(ii);ch,attr", &ch, &attr))
+ if (!PyArg_Parse(arg,"i;ch", &ch))
+ return (PyObject *)NULL;
+ }
+ }
+ if (use_attr == TRUE) {
+ attr_old = getattrs(self->win);
+ wattrset(self->win,attr);
+ }
+ if (use_xy == TRUE)
+ rtn = mvwinsch(self->win,y,x,ch);
+ else
+ rtn = winsch(self->win,ch);
+ if (use_attr == TRUE)
+ wattrset(self->win,attr_old);
+ if (rtn == OK) {
+ Py_INCREF(PyCurses_OK);
+ return (PyObject *)PyCurses_OK;
+ }
+ Py_INCREF(PyCurses_ERR);
+ return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_DelCh(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int rtn;
+ int x, y;
+ int use_xy = TRUE;
+ if (!PyArg_Parse(arg,"(ii);y,x", &y, &x))
+ use_xy = FALSE;
+ if (use_xy == TRUE)
+ rtn = mvwdelch(self->win,y,x);
+ else
+ rtn = wdelch(self->win);
+ if (rtn == OK) {
+ Py_INCREF(PyCurses_OK);
+ return (PyObject *)PyCurses_OK;
+ }
+ Py_INCREF(PyCurses_ERR);
+ return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_EchoChar(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int rtn;
+ int ch;
+ int attr, attr_old, use_attr = TRUE;
+ if (!PyArg_Parse(arg,"(ii);ch,attr", &ch, &attr)) {
+ use_attr = FALSE;
+ if (!PyArg_Parse(arg,"i;ch", &ch))
+ return (PyObject *)NULL;
+ }
+ if (use_attr == TRUE) {
+ attr_old = getattrs(self->win);
+ wattrset(self->win,attr);
+ }
+ rtn = wechochar(self->win,ch);
+ if (use_attr == TRUE)
+ wattrset(self->win,attr_old);
+ if (rtn == OK) {
+ Py_INCREF(PyCurses_OK);
+ return (PyObject *)PyCurses_OK;
+ }
+ Py_INCREF(PyCurses_ERR);
+ return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_AddStr(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int rtn;
+ int x, y;
+ char *str;
+ int use_xy = TRUE;
+ int attr, attr_old, use_attr = TRUE;
+ switch (PyTuple_Size(arg)) {
+ case 2:
+ case 4:
+ use_attr = TRUE;
+ break;
+ default:
+ use_attr = FALSE;
+ }
+ if (!PyArg_Parse(arg,"(iisi);y,x,str,attr", &y, &x, &str, &attr)) {
+ if (!PyArg_Parse(arg,"(iis);y,x,str", &y, &x, &str)) {
+ use_xy = FALSE;
+ if (!PyArg_Parse(arg,"(si);str,attr", &str, &attr))
+ if (!PyArg_Parse(arg,"s;str", &str))
+ return (PyObject *)NULL;
+ }
+ }
+ if (use_attr == TRUE) {
+ attr_old = getattrs(self->win);
+ wattrset(self->win,attr);
+ }
+ if (use_xy == TRUE)
+ rtn = mvwaddstr(self->win,y,x,str);
+ else
+ rtn = waddstr(self->win,str);
+ if (use_attr == TRUE)
+ wattrset(self->win,attr_old);
+ if (rtn == OK) {
+ Py_INCREF(PyCurses_OK);
+ return (PyObject *)PyCurses_OK;
+ }
+ Py_INCREF(PyCurses_ERR);
+ return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_AttrOn(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int rtn;
+ int ch;
+ if (!PyArg_Parse(arg,"i;attr", &ch))
+ return (PyObject *)NULL;
+ rtn = wattron(self->win,ch);
+ if (rtn == OK) {
+ Py_INCREF(PyCurses_OK);
+ return (PyObject *)PyCurses_OK;
+ }
+ Py_INCREF(PyCurses_ERR);
+ return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_AttrOff(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int rtn;
+ int ch;
+ if (!PyArg_Parse(arg,"i;attr", &ch))
+ return (PyObject *)NULL;
+ rtn = wattroff(self->win,ch);
+ if (rtn == OK) {
+ Py_INCREF(PyCurses_OK);
+ return (PyObject *)PyCurses_OK;
+ }
+ Py_INCREF(PyCurses_ERR);
+ return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_AttrSet(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int rtn;
+ int ch;
+ if (!PyArg_Parse(arg,"i;attr", &ch))
+ return (PyObject *)NULL;
+ rtn = wattrset(self->win,ch);
+ if (rtn == OK) {
+ Py_INCREF(PyCurses_OK);
+ return (PyObject *)PyCurses_OK;
+ }
+ Py_INCREF(PyCurses_ERR);
+ return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_StandEnd(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int rtn;
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ rtn = wstandend(self->win);
+ if (rtn == OK) {
+ Py_INCREF(PyCurses_OK);
+ return (PyObject *)PyCurses_OK;
+ }
+ Py_INCREF(PyCurses_ERR);
+ return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_StandOut(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int rtn;
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ rtn = wstandout(self->win);
+ if (rtn == OK) {
+ Py_INCREF(PyCurses_OK);
+ return (PyObject *)PyCurses_OK;
+ }
+ Py_INCREF(PyCurses_ERR);
+ return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_Box(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int rtn;
+ int ch1=0,ch2=0;
+ if (!PyArg_Parse(arg,"(ii);vertch,horch", &ch1, &ch2))
+ PyErr_Clear();
+ rtn = box(self->win,ch1,ch2);
+ if (rtn == OK) {
+ Py_INCREF(PyCurses_OK);
+ return (PyObject *)PyCurses_OK;
+ }
+ Py_INCREF(PyCurses_ERR);
+ return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_Erase(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ werase(self->win);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_DeleteLine(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ wdeleteln(self->win);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_InsertLine(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ winsertln(self->win);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_GetYX(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int x, y;
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ getyx(self->win,y,x);
+ return (PyObject *)Py_BuildValue("(ii)", y, x);
+}
+
+static PyObject *
+PyCursesWindow_GetBegYX(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int x, y;
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ getbegyx(self->win,y,x);
+ return (PyObject *)Py_BuildValue("(ii)", y, x);
+}
+
+static PyObject *
+PyCursesWindow_GetMaxYX(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int x, y;
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ getmaxyx(self->win,y,x);
+ return (PyObject *)Py_BuildValue("(ii)", y, x);
+}
+
+static PyObject *
+PyCursesWindow_Clear(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ wclear(self->win);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_ClearToBottom(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ wclrtobot(self->win);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_ClearToEOL(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ wclrtoeol(self->win);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_Scroll(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ scroll(self->win);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_TouchWin(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ touchwin(self->win);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_TouchLine(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int st, cnt;
+ if (!PyArg_Parse(arg,"(ii);start, count",&st,&cnt))
+ return (PyObject *)NULL;
+ touchline(self->win,st,cnt);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_GetCh(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int x, y;
+ int use_xy = TRUE;
+ int rtn;
+ if (!PyArg_Parse(arg,"(ii);y,x",&y,&x))
+ use_xy = FALSE;
+ if (use_xy == TRUE)
+ rtn = mvwgetch(self->win,y,x);
+ else
+ rtn = wgetch(self->win);
+ return (PyObject *)PyInt_FromLong(rtn);
+}
+
+static PyObject *
+PyCursesWindow_GetStr(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int x, y;
+ int use_xy = TRUE;
+ char rtn[1024]; /* This should be big enough.. I hope */
+ int rtn2;
+ if (!PyArg_Parse(arg,"(ii);y,x",&y,&x))
+ use_xy = FALSE;
+ if (use_xy == TRUE)
+ rtn2 = mvwgetstr(self->win,y,x,rtn);
+ else
+ rtn2 = wgetstr(self->win,rtn);
+ if (rtn2 == ERR)
+ rtn[0] = 0;
+ return (PyObject *)PyString_FromString(rtn);
+}
+
+static PyObject *
+PyCursesWindow_InCh(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int x, y;
+ int use_xy = TRUE;
+ int rtn;
+ if (!PyArg_Parse(arg,"(ii);y,x",&y,&x))
+ use_xy = FALSE;
+ if (use_xy == TRUE)
+ rtn = mvwinch(self->win,y,x);
+ else
+ rtn = winch(self->win);
+ return (PyObject *)PyInt_FromLong(rtn);
+}
+
+static PyObject *
+PyCursesWindow_ClearOk(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int val;
+ if (!PyArg_Parse(arg,"i;True(1) or False(0)",&val))
+ return (PyObject *)NULL;
+ clearok(self->win,val);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_IdlOk(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int val;
+ if (!PyArg_Parse(arg,"i;True(1) or False(0)",&val))
+ return (PyObject *)NULL;
+ idlok(self->win,val);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_LeaveOk(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int val;
+ if (!PyArg_Parse(arg,"i;True(1) or False(0)",&val))
+ return (PyObject *)NULL;
+ leaveok(self->win,val);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_ScrollOk(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int val;
+ if (!PyArg_Parse(arg,"i;True(1) or False(0)",&val))
+ return (PyObject *)NULL;
+ scrollok(self->win,val);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_SetScrollRegion(self,arg)
+ PyCursesWindowObject *self;
+ PyObject * arg;
+{
+ int x, y;
+ if (!PyArg_Parse(arg,"(ii);top, bottom",&y,&x))
+ return (PyObject *)NULL;
+ wsetscrreg(self->win,y,x);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_KeyPad(self,arg)
+ PyCursesWindowObject * self;
+ PyObject * arg;
+{
+ int ch;
+ if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch))
+ return (PyObject *)NULL;
+ keypad(self->win,ch);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_NoDelay(self,arg)
+ PyCursesWindowObject * self;
+ PyObject * arg;
+{
+ int ch;
+ if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch))
+ return (PyObject *)NULL;
+ nodelay(self->win,ch);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_NoTimeout(self,arg)
+ PyCursesWindowObject * self;
+ PyObject * arg;
+{
+ int ch;
+ if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch))
+ return (PyObject *)NULL;
+ notimeout(self->win,ch);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyMethodDef PyCursesWindow_Methods[] = {
+ {"refresh", (PyCFunction)PyCursesWindow_Refresh},
+ {"nooutrefresh", (PyCFunction)PyCursesWindow_NoOutRefresh},
+ {"mvwin", (PyCFunction)PyCursesWindow_MoveWin},
+ {"move", (PyCFunction)PyCursesWindow_Move},
+ {"subwin", (PyCFunction)PyCursesWindow_SubWin},
+ {"addch", (PyCFunction)PyCursesWindow_AddCh},
+ {"insch", (PyCFunction)PyCursesWindow_InsCh},
+ {"delch", (PyCFunction)PyCursesWindow_DelCh},
+ {"echochar", (PyCFunction)PyCursesWindow_EchoChar},
+ {"addstr", (PyCFunction)PyCursesWindow_AddStr},
+ {"attron", (PyCFunction)PyCursesWindow_AttrOn},
+ {"attroff", (PyCFunction)PyCursesWindow_AttrOff},
+ {"attrset", (PyCFunction)PyCursesWindow_AttrSet},
+ {"standend", (PyCFunction)PyCursesWindow_StandEnd},
+ {"standout", (PyCFunction)PyCursesWindow_StandOut},
+ {"box", (PyCFunction)PyCursesWindow_Box},
+ {"erase", (PyCFunction)PyCursesWindow_Erase},
+ {"deleteln", (PyCFunction)PyCursesWindow_DeleteLine},
+ {"insertln", (PyCFunction)PyCursesWindow_InsertLine},
+ {"getyx", (PyCFunction)PyCursesWindow_GetYX},
+ {"getbegyx", (PyCFunction)PyCursesWindow_GetBegYX},
+ {"getmaxyx", (PyCFunction)PyCursesWindow_GetMaxYX},
+ {"clear", (PyCFunction)PyCursesWindow_Clear},
+ {"clrtobot", (PyCFunction)PyCursesWindow_ClearToBottom},
+ {"clrtoeol", (PyCFunction)PyCursesWindow_ClearToEOL},
+ {"scroll", (PyCFunction)PyCursesWindow_Scroll},
+ {"touchwin", (PyCFunction)PyCursesWindow_TouchWin},
+ {"touchline", (PyCFunction)PyCursesWindow_TouchLine},
+ {"getch", (PyCFunction)PyCursesWindow_GetCh},
+ {"getstr", (PyCFunction)PyCursesWindow_GetStr},
+ {"inch", (PyCFunction)PyCursesWindow_InCh},
+ {"clearok", (PyCFunction)PyCursesWindow_ClearOk},
+ {"idlok", (PyCFunction)PyCursesWindow_IdlOk},
+ {"leaveok", (PyCFunction)PyCursesWindow_LeaveOk},
+ {"scrollok", (PyCFunction)PyCursesWindow_ScrollOk},
+ {"setscrreg", (PyCFunction)PyCursesWindow_SetScrollRegion},
+ {"keypad", (PyCFunction)PyCursesWindow_KeyPad},
+ {"nodelay", (PyCFunction)PyCursesWindow_NoDelay},
+ {"notimeout", (PyCFunction)PyCursesWindow_NoTimeout},
+ {NULL, (PyCFunction)NULL} /* sentinel */
+};
+
+static PyObject *
+PyCursesWindow_GetAttr(self, name)
+ PyCursesWindowObject *self;
+ char *name;
+{
+ return findmethod(PyCursesWindow_Methods, (PyObject *)self, name);
+}
+
+/* --------------- PAD routines ---------------- */
+static PyObject *
+PyCursesPad_New(pad)
+ WINDOW *pad;
+{
+ PyCursesPadObject *po;
+ po = (PyCursesPadObject *)PyObject_NEW(PyCursesPadObject, &PyCursesPad_Type);
+ if (po == NULL)
+ return NULL;
+ po->pad = pad;
+ return (PyObject *)po;
+}
+
+/* -------------------------------------------------------*/
+static PyTypeObject PyCursesScreen_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "curses screen", /*tp_name*/
+ sizeof(PyCursesScreenObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor)0 /*PyCursesScreen_Dealloc*/, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc)0, /*tp_getattr*/
+ (setattrfunc)0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+};
+
+static PyTypeObject PyCursesWindow_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "curses window", /*tp_name*/
+ sizeof(PyCursesWindowObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor)PyCursesWindow_Dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc)PyCursesWindow_GetAttr, /*tp_getattr*/
+ (setattrfunc)0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+};
+
+static PyTypeObject PyCursesPad_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "curses pad", /*tp_name*/
+ sizeof(PyCursesPadObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor)0 /*PyCursesPad_Dealloc*/, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc)0, /*tp_getattr*/
+ (setattrfunc)0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+};
+
+/* -------------------------------------------------------*/
+
+static PyObject *
+PyCurses_InitScr(self, args)
+ PyObject * self;
+ PyObject * args;
+{
+ static int already_inited = FALSE;
+ if (!PyArg_NoArgs(args))
+ return (PyObject *)NULL;
+ if (already_inited == TRUE) {
+ wrefresh(stdscr);
+ return (PyObject *)PyCursesWindow_New(stdscr);
+ }
+ already_inited = TRUE;
+ return (PyObject *)PyCursesWindow_New(initscr());
+}
+
+static PyObject *
+PyCurses_EndWin(self, args)
+ PyObject * self;
+ PyObject * args;
+{
+ if (!PyArg_NoArgs(args))
+ return (PyObject *)NULL;
+ endwin();
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+PyCurses_IsEndWin(self, args)
+ PyObject * self;
+ PyObject * args;
+{
+ if (!PyArg_NoArgs(args))
+ return (PyObject *)NULL;
+ if (isendwin() == FALSE) {
+ Py_INCREF(Py_False);
+ return Py_False;
+ }
+ Py_INCREF(Py_True);
+ return Py_True;
+}
+
+static PyObject *
+PyCurses_DoUpdate(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ return (PyObject *)PyInt_FromLong(doupdate());
+}
+
+static PyObject *
+PyCurses_NewWindow(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ WINDOW *win;
+ int nlines, ncols, begin_y, begin_x;
+ nlines = 0;
+ ncols = 0;
+ if (!PyArg_Parse(arg,
+ "(iiii);nlines,ncols,begin_y,begin_x",
+ &nlines,&ncols,&begin_y,&begin_x))
+ if (!PyArg_Parse(arg,"(ii)",&begin_y,&begin_x))
+ return (PyObject *)NULL;
+ win = newwin(nlines,ncols,begin_y,begin_x);
+ if (win == NULL) {
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+ }
+ return (PyObject *)PyCursesWindow_New(win);
+}
+
+static PyObject *
+PyCurses_Beep(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ beep();
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_Flash(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ flash();
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_UngetCh(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ int ch;
+ if (!PyArg_Parse(arg,"i;integer",&ch))
+ return (PyObject *)NULL;
+ ungetch(ch);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_FlushInp(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ flushinp();
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_CBreak(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ cbreak();
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_NoCBreak(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ nocbreak();
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_Echo(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ echo();
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_NoEcho(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ noecho();
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_Nl(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ nl();
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_NoNl(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ nonl();
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_Raw(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ raw();
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_NoRaw(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ if (!PyArg_NoArgs(arg))
+ return (PyObject *)NULL;
+ noraw();
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_IntrFlush(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ int ch;
+ if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch))
+ return (PyObject *)NULL;
+ intrflush(NULL,ch);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_Meta(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ int ch;
+ if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch))
+ return (PyObject *)NULL;
+ meta(NULL,ch);
+ Py_INCREF(Py_None);
+ return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_KeyName(self,arg)
+ PyObject * self;
+ PyObject * arg;
+{
+ int ch;
+ if (!PyArg_Parse(arg,"i",&ch))
+ return (PyObject *)NULL;
+ return PyString_FromString((char *)keyname(ch));
+}
+
+#ifdef NOT_YET
+static PyObject *
+PyCurses_NewTerm(self, args)
+ PyObject * self;
+ PyObject * args;
+{
+}
+
+static PyObject *
+PyCurses_SetTerm(self, args)
+ PyObject * self;
+ PyObject * args;
+{
+}
+#endif
+
+/* List of functions defined in the module */
+
+static PyMethodDef PyCurses_methods[] = {
+ {"initscr", (PyCFunction)PyCurses_InitScr},
+ {"endwin", (PyCFunction)PyCurses_EndWin},
+ {"isendwin", (PyCFunction)PyCurses_IsEndWin},
+ {"doupdate", (PyCFunction)PyCurses_DoUpdate},
+ {"newwin", (PyCFunction)PyCurses_NewWindow},
+ {"beep", (PyCFunction)PyCurses_Beep},
+ {"flash", (PyCFunction)PyCurses_Flash},
+ {"ungetch", (PyCFunction)PyCurses_UngetCh},
+ {"flushinp", (PyCFunction)PyCurses_FlushInp},
+ {"cbreak", (PyCFunction)PyCurses_CBreak},
+ {"nocbreak", (PyCFunction)PyCurses_NoCBreak},
+ {"echo", (PyCFunction)PyCurses_Echo},
+ {"noecho", (PyCFunction)PyCurses_NoEcho},
+ {"nl", (PyCFunction)PyCurses_Nl},
+ {"nonl", (PyCFunction)PyCurses_NoNl},
+ {"raw", (PyCFunction)PyCurses_Raw},
+ {"noraw", (PyCFunction)PyCurses_NoRaw},
+ {"intrflush", (PyCFunction)PyCurses_IntrFlush},
+ {"meta", (PyCFunction)PyCurses_Meta},
+ {"keyname", (PyCFunction)PyCurses_KeyName},
+#ifdef NOT_YET
+ {"newterm", (PyCFunction)PyCurses_NewTerm},
+ {"set_term", (PyCFunction)PyCurses_SetTerm},
+#endif
+ {NULL, NULL} /* sentinel */
+};
+
+/* Initialization function for the module */
+
+void
+initcurses()
+{
+ PyObject *m, *d, *x;
+
+ /* Create the module and add the functions */
+ m = Py_InitModule("ncurses", PyCurses_methods);
+
+ PyCurses_OK = Py_True;
+ PyCurses_ERR = Py_False;
+ Py_INCREF(PyCurses_OK);
+ Py_INCREF(PyCurses_ERR);
+ /* Add some symbolic constants to the module */
+ d = PyModule_GetDict(m);
+ /* Here are some defines */
+ PyDict_SetItemString(d,"OK", PyCurses_OK);
+ PyDict_SetItemString(d,"ERR",PyCurses_ERR);
+
+#define SetDictChar(string,ch) \
+ PyDict_SetItemString(d,string,PyInt_FromLong(ch));
+
+ /* Here are some graphic symbols you can use */
+ SetDictChar("ACS_ULCORNER",(ACS_ULCORNER));
+ SetDictChar("ACS_ULCORNER",(ACS_ULCORNER));
+ SetDictChar("ACS_LLCORNER",(ACS_LLCORNER));
+ SetDictChar("ACS_URCORNER",(ACS_URCORNER));
+ SetDictChar("ACS_LRCORNER",(ACS_LRCORNER));
+ SetDictChar("ACS_RTEE", (ACS_RTEE));
+ SetDictChar("ACS_LTEE", (ACS_LTEE));
+ SetDictChar("ACS_BTEE", (ACS_BTEE));
+ SetDictChar("ACS_TTEE", (ACS_TTEE));
+ SetDictChar("ACS_HLINE", (ACS_HLINE));
+ SetDictChar("ACS_VLINE", (ACS_VLINE));
+ SetDictChar("ACS_PLUS", (ACS_PLUS));
+ SetDictChar("ACS_S1", (ACS_S1));
+ SetDictChar("ACS_S9", (ACS_S9));
+ SetDictChar("ACS_DIAMOND", (ACS_DIAMOND));
+ SetDictChar("ACS_CKBOARD", (ACS_CKBOARD));
+ SetDictChar("ACS_DEGREE", (ACS_DEGREE));
+ SetDictChar("ACS_PLMINUS", (ACS_PLMINUS));
+ SetDictChar("ACS_BULLET", (ACS_BULLET));
+ SetDictChar("ACS_LARROW", (ACS_RARROW));
+ SetDictChar("ACS_DARROW", (ACS_DARROW));
+ SetDictChar("ACS_UARROW", (ACS_UARROW));
+ SetDictChar("ACS_BOARD", (ACS_BOARD));
+ SetDictChar("ACS_LANTERN", (ACS_LANTERN));
+ SetDictChar("ACS_BLOCK", (ACS_BLOCK));
+
+ /* Here are some attributes you can add to chars to print */
+ PyDict_SetItemString(d, "A_NORMAL", PyInt_FromLong(A_NORMAL));
+ PyDict_SetItemString(d, "A_STANDOUT", PyInt_FromLong(A_STANDOUT));
+ PyDict_SetItemString(d, "A_UNDERLINE", PyInt_FromLong(A_UNDERLINE));
+ PyDict_SetItemString(d, "A_REVERSE", PyInt_FromLong(A_REVERSE));
+ PyDict_SetItemString(d, "A_BLINK", PyInt_FromLong(A_BLINK));
+ PyDict_SetItemString(d, "A_DIM", PyInt_FromLong(A_DIM));
+ PyDict_SetItemString(d, "A_BOLD", PyInt_FromLong(A_BOLD));
+ PyDict_SetItemString(d, "A_ALTCHARSET",PyInt_FromLong(A_ALTCHARSET));
+
+ /* Now set everything up for KEY_ variables */
+ {
+ int key;
+ char *key_n;
+ char *key_n2;
+ for (key=KEY_MIN;key < KEY_MAX; key++) {
+ key_n = (char *)keyname(key);
+ if (strcmp(key_n,"UNKNOWN KEY")==0)
+ continue;
+ if (strncmp(key_n,"KEY_F(",6)==0) {
+ char *p1, *p2;
+ key_n2 = malloc(strlen(key_n)+1);
+ p1 = key_n;
+ p2 = key_n2;
+ while (*p1) {
+ if (*p1 != '(' && *p1 != ')') {
+ *p2 = *p1;
+ p2++;
+ }
+ p1++;
+ }
+ *p2 = (char)0;
+ } else
+ key_n2 = key_n;
+ PyDict_SetItemString(d,key_n2,PyInt_FromLong(key));
+ if (key_n2 != key_n)
+ free(key_n2);
+ }
+ SetDictChar("KEY_MIN",KEY_MIN);
+ SetDictChar("KEY_MAX",KEY_MAX);
+ }
+
+ /* Check for errors */
+ if (PyErr_Occurred())
+ Py_FatalError("can't initialize module syslog");
+}
/***********************************************************
-Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
-Amsterdam, The Netherlands.
+Copyright 1994 by Lance Ellinghouse,
+Cathedral City, California Republic, United States of America.
All Rights Reserved
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
-supporting documentation, and that the names of Stichting Mathematisch
-Centrum or CWI not be used in advertising or publicity pertaining to
-distribution of the software without specific, written prior permission.
+supporting documentation, and that the name of Lance Ellinghouse
+not be used in advertising or publicity pertaining to distribution
+of the software without specific, written prior permission.
-STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
-FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE BE LIABLE FOR ANY SPECIAL,
+INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
******************************************************************/
/* syslog module */
-/* (By Lance Ellinghouse) */
#include "allobjects.h"
#include "modsupport.h"
#include <syslog.h>
-static object *
+#include "rename1.h"
+
+static PyObject *
syslog_openlog(self, args)
- object *self;
- object *args;
+ PyObject * self;
+ PyObject * args;
{
char *ident = "";
- object *ident_o;
+ PyObject * ident_o;
long logopt = LOG_PID;
long facility = LOG_USER;
- if (!getargs(args, "(Sll);ident string, logoption, facility", &ident_o, &logopt, &facility))
- if (!getargs(args, "(Sl);ident string, logoption", &ident_o, &logopt))
- if (!getargs(args, "S;ident string", &ident_o))
+ if (!PyArg_Parse(args, "(Sll);ident string, logoption, facility", &ident_o, &logopt, &facility))
+ if (!PyArg_Parse(args, "(Sl);ident string, logoption", &ident_o, &logopt))
+ if (!PyArg_Parse(args, "S;ident string", &ident_o))
return NULL;
- INCREF(ident_o); /* This is needed because openlog() does NOT make a copy
+ Py_INCREF(ident_o); /* This is needed because openlog() does NOT make a copy
and syslog() later uses it.. cannot trash it. */
- ident = getstringvalue(ident_o);
+ ident = PyString_AsString(ident_o);
openlog(ident,logopt,facility);
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
syslog_syslog(self, args)
- object *self;
- object *args;
+ PyObject * self;
+ PyObject * args;
{
int priority = LOG_INFO;
char *message;
- if (!getargs(args,"(is);priority, message string",&priority,&message))
- if (!getargs(args,"s;message string",&message))
+ if (!PyArg_Parse(args,"(is);priority, message string",&priority,&message))
+ if (!PyArg_Parse(args,"s;message string",&message))
return NULL;
syslog(priority, message);
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
syslog_closelog(self, args)
- object *self;
- object *args;
+ PyObject * self;
+ PyObject * args;
{
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
closelog();
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
syslog_setlogmask(self, args)
- object *self;
- object *args;
+ PyObject * self;
+ PyObject * args;
{
long maskpri;
- if (!getargs(args,"l;mask for priority",&maskpri))
+ if (!PyArg_Parse(args,"l;mask for priority",&maskpri))
return NULL;
setlogmask(maskpri);
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
syslog_log_mask(self, args)
- object *self;
- object *args;
+ PyObject * self;
+ PyObject * args;
{
long mask;
long pri;
- if (!getargs(args,"l",&pri))
+ if (!PyArg_Parse(args,"l",&pri))
return NULL;
mask = LOG_MASK(pri);
- return newintobject(mask);
+ return PyInt_FromLong(mask);
}
-static object *
+static PyObject *
syslog_log_upto(self, args)
- object *self;
- object *args;
+ PyObject * self;
+ PyObject * args;
{
long mask;
long pri;
- if (!getargs(args,"l",&pri))
+ if (!PyArg_Parse(args,"l",&pri))
return NULL;
mask = LOG_UPTO(pri);
- return newintobject(mask);
+ return PyInt_FromLong(mask);
}
/* List of functions defined in the module */
-static struct methodlist syslog_methods[] = {
- {"openlog", syslog_openlog},
- {"closelog", syslog_closelog},
- {"syslog", syslog_syslog},
- {"setlogmask", syslog_setlogmask},
- {"LOG_MASK", syslog_log_mask},
- {"LOG_UPTO", syslog_log_upto},
+static PyMethodDef syslog_methods[] = {
+ {"openlog", (PyCFunction)syslog_openlog},
+ {"closelog", (PyCFunction)syslog_closelog},
+ {"syslog", (PyCFunction)syslog_syslog},
+ {"setlogmask", (PyCFunction)syslog_setlogmask},
+ {"LOG_MASK", (PyCFunction)syslog_log_mask},
+ {"LOG_UPTO", (PyCFunction)syslog_log_upto},
{NULL, NULL} /* sentinel */
};
void
initsyslog()
{
- object *m, *d, *x;
+ PyObject *m, *d, *x;
/* Create the module and add the functions */
- m = initmodule("syslog", syslog_methods);
+ m = Py_InitModule("syslog", syslog_methods);
/* Add some symbolic constants to the module */
- d = getmoduledict(m);
- x = newintobject(LOG_EMERG);
- dictinsert(d, "LOG_EMERG", x);
- x = newintobject(LOG_ALERT);
- dictinsert(d, "LOG_ALERT", x);
- x = newintobject(LOG_CRIT);
- dictinsert(d, "LOG_CRIT", x);
- x = newintobject(LOG_ERR);
- dictinsert(d, "LOG_ERR", x);
- x = newintobject(LOG_WARNING);
- dictinsert(d, "LOG_WARNING", x);
- x = newintobject(LOG_NOTICE);
- dictinsert(d, "LOG_NOTICE", x);
- x = newintobject(LOG_INFO);
- dictinsert(d, "LOG_INFO", x);
- x = newintobject(LOG_DEBUG);
- dictinsert(d, "LOG_DEBUG", x);
- x = newintobject(LOG_PID);
- dictinsert(d, "LOG_PID", x);
- x = newintobject(LOG_CONS);
- dictinsert(d, "LOG_CONS", x);
- x = newintobject(LOG_NDELAY);
- dictinsert(d, "LOG_NDELAY", x);
- x = newintobject(LOG_NOWAIT);
- dictinsert(d, "LOG_NOWAIT", x);
- x = newintobject(LOG_KERN);
- dictinsert(d, "LOG_KERN", x);
- x = newintobject(LOG_USER);
- dictinsert(d, "LOG_USER", x);
- x = newintobject(LOG_MAIL);
- dictinsert(d, "LOG_MAIL", x);
- x = newintobject(LOG_DAEMON);
- dictinsert(d, "LOG_DAEMON", x);
- x = newintobject(LOG_LPR);
- dictinsert(d, "LOG_LPR", x);
- x = newintobject(LOG_LOCAL0);
- dictinsert(d, "LOG_LOCAL0", x);
- x = newintobject(LOG_LOCAL1);
- dictinsert(d, "LOG_LOCAL1", x);
- x = newintobject(LOG_LOCAL2);
- dictinsert(d, "LOG_LOCAL2", x);
- x = newintobject(LOG_LOCAL3);
- dictinsert(d, "LOG_LOCAL3", x);
- x = newintobject(LOG_LOCAL4);
- dictinsert(d, "LOG_LOCAL4", x);
- x = newintobject(LOG_LOCAL5);
- dictinsert(d, "LOG_LOCAL5", x);
- x = newintobject(LOG_LOCAL6);
- dictinsert(d, "LOG_LOCAL6", x);
- x = newintobject(LOG_LOCAL7);
- dictinsert(d, "LOG_LOCAL7", x);
+ d = PyModule_GetDict(m);
+ x = PyInt_FromLong(LOG_EMERG);
+ PyDict_SetItemString(d, "LOG_EMERG", x);
+ x = PyInt_FromLong(LOG_ALERT);
+ PyDict_SetItemString(d, "LOG_ALERT", x);
+ x = PyInt_FromLong(LOG_CRIT);
+ PyDict_SetItemString(d, "LOG_CRIT", x);
+ x = PyInt_FromLong(LOG_ERR);
+ PyDict_SetItemString(d, "LOG_ERR", x);
+ x = PyInt_FromLong(LOG_WARNING);
+ PyDict_SetItemString(d, "LOG_WARNING", x);
+ x = PyInt_FromLong(LOG_NOTICE);
+ PyDict_SetItemString(d, "LOG_NOTICE", x);
+ x = PyInt_FromLong(LOG_INFO);
+ PyDict_SetItemString(d, "LOG_INFO", x);
+ x = PyInt_FromLong(LOG_DEBUG);
+ PyDict_SetItemString(d, "LOG_DEBUG", x);
+ x = PyInt_FromLong(LOG_PID);
+ PyDict_SetItemString(d, "LOG_PID", x);
+ x = PyInt_FromLong(LOG_CONS);
+ PyDict_SetItemString(d, "LOG_CONS", x);
+ x = PyInt_FromLong(LOG_NDELAY);
+ PyDict_SetItemString(d, "LOG_NDELAY", x);
+ x = PyInt_FromLong(LOG_NOWAIT);
+ PyDict_SetItemString(d, "LOG_NOWAIT", x);
+ x = PyInt_FromLong(LOG_KERN);
+ PyDict_SetItemString(d, "LOG_KERN", x);
+ x = PyInt_FromLong(LOG_USER);
+ PyDict_SetItemString(d, "LOG_USER", x);
+ x = PyInt_FromLong(LOG_MAIL);
+ PyDict_SetItemString(d, "LOG_MAIL", x);
+ x = PyInt_FromLong(LOG_DAEMON);
+ PyDict_SetItemString(d, "LOG_DAEMON", x);
+ x = PyInt_FromLong(LOG_LPR);
+ PyDict_SetItemString(d, "LOG_LPR", x);
+ x = PyInt_FromLong(LOG_LOCAL0);
+ PyDict_SetItemString(d, "LOG_LOCAL0", x);
+ x = PyInt_FromLong(LOG_LOCAL1);
+ PyDict_SetItemString(d, "LOG_LOCAL1", x);
+ x = PyInt_FromLong(LOG_LOCAL2);
+ PyDict_SetItemString(d, "LOG_LOCAL2", x);
+ x = PyInt_FromLong(LOG_LOCAL3);
+ PyDict_SetItemString(d, "LOG_LOCAL3", x);
+ x = PyInt_FromLong(LOG_LOCAL4);
+ PyDict_SetItemString(d, "LOG_LOCAL4", x);
+ x = PyInt_FromLong(LOG_LOCAL5);
+ PyDict_SetItemString(d, "LOG_LOCAL5", x);
+ x = PyInt_FromLong(LOG_LOCAL6);
+ PyDict_SetItemString(d, "LOG_LOCAL6", x);
+ x = PyInt_FromLong(LOG_LOCAL7);
+ PyDict_SetItemString(d, "LOG_LOCAL7", x);
/* Check for errors */
- if (err_occurred())
- fatal("can't initialize module syslog");
+ if (PyErr_Occurred())
+ Py_FatalError("can't initialize module syslog");
}
projects / thirdparty / Python / cpython.git / commitdiff
