Lance has converted his modules to the new naming conventions, and

contributed a curses interface.
Setup.in uses .c instead of .o now.

4 files changed, 1496 insertions, 217 deletions

diff --git a/Modules/Setup.in b/Modules/Setup.in
index 82a26cc..61bbc5e 100644
--- a/Modules/Setup.in
+++ b/Modules/Setup.in
@@ -15,9 +15,9 @@
 # Comment out lines to suppress modules.
 # Lines have the following structure:
 #
-# <module> ... [<objectfile> ...] [<cpparg> ...] [<library> ...]
+# <module> ... [<sourcefile> ...] [<cpparg> ...] [<library> ...]
 #
-# <objectfile> is anything ending in .o
+# <sourcefile> is anything ending in .c (.C, .cc, .c++ are C++ files)
 # <cpparg> is anything starting with -I, -D, -U or -C
 # <library> is anything ending in .a or beginning with -l or -L
 # <module> is anything else but should be a valid Python
@@ -61,41 +61,42 @@ PYTHONPATH=.:$(DESTLIB)$(TESTPATH)$(ARCHPATH)$(STDWINPATH)
 
 # Modules that should always be present (non UNIX dependent)
 
-array arraymodule.o	# array objects
-math mathmodule.o	# math library functions, e.g. sin()
-parser parsermodule.o	# raw interface to the Python parser
-posix posixmodule.o	# posix (UNIX) system calls
-regex regexmodule.o regexpr.o	# Regular expressions, GNU Emacs style
-strop stropmodule.o	# fast string operations implemented in C
-struct structmodule.o	# binary structure packing/unpacking
-time timemodule.o	# time operations and variables
+array arraymodule.c	# array objects
+math mathmodule.c	# math library functions, e.g. sin()
+parser parsermodule.c	# raw interface to the Python parser
+posix posixmodule.c	# posix (UNIX) system calls
+regex regexmodule.c regexpr.c	# Regular expressions, GNU Emacs style
+strop stropmodule.c	# fast string operations implemented in C
+struct structmodule.c	# binary structure packing/unpacking
+time timemodule.c	# time operations and variables
 
 
 # Modules with some UNIX dependencies -- on by default.
 # (If you have a really backward UNIX, select and socket may not be
 # supported...)
 
-fcntl fcntlmodule.o	# fcntl(2) and ioctl(2)
-pwd pwdmodule.o		# pwd(3) 
-grp grpmodule.o		# grp(3)
-crypt cryptmodule.o	# crypt(3)
-select selectmodule.o	# select(2); not on ancient System V
-socket socketmodule.o	# socket(2); not on ancient System V
+fcntl fcntlmodule.c	# fcntl(2) and ioctl(2)
+pwd pwdmodule.c		# pwd(3) 
+grp grpmodule.c		# grp(3)
+crypt cryptmodule.c	# crypt(3)
+select selectmodule.c	# select(2); not on ancient System V
+socket socketmodule.c	# socket(2); not on ancient System V
+signal signalmodule.c	# signal(2)
 
 
 # Some more UNIX dependent modules -- off by default, since these
 # are not supported by all UNIX systems.
 
-#dbm dbmmodule.o 	# dbm(3) may require -lndbm or similar
-#nis nismodule.o 	# Sun yellow pages -- not everywhere
+#dbm dbmmodule.c 	# dbm(3) may require -lndbm or similar
+#nis nismodule.c 	# Sun yellow pages -- not everywhere
 
 
 # Multimedia modules -- on by default.
 # These represent audio samples or images as strings
 
-audioop audioop.o	# Operations on audio samples
-imageop imageop.o	# Operations on images
-rgbimg rgbimgmodule.o   # Read SGI RGB image files (but coded portably)
+audioop audioop.c	# Operations on audio samples
+imageop imageop.c	# Operations on images
+rgbimg rgbimgmodule.c   # Read SGI RGB image files (but coded portably)
 
 
 # The stdwin module provides a simple, portable (between X11 and Mac)
@@ -108,14 +109,14 @@ rgbimg rgbimgmodule.o   # Read SGI RGB image files (but coded portably)
 
 #STDWIN=/ufs/guido/src/stdwin
 #ARCH=???
-#stdwin stdwinmodule.o -I$(STDWIN)/H $(STDWIN)/Build/$(ARCH)/x11/lib/lib.a -lX11
+#stdwin stdwinmodule.c -I$(STDWIN)/H $(STDWIN)/Build/$(ARCH)/x11/lib/lib.a -lX11
 
 
 # The md5 module implements the RSA Data Security, Inc. MD5
 # Message-Digest Algorithm, described in RFC 1321.  The necessary files
 # md5c.c and md5.h are included here.
 
-md5 md5module.o md5c.o
+md5 md5module.c md5c.c
 
 
 # The mpz module interfaces to the GNU Multiple Precision library.
@@ -127,13 +128,7 @@ md5 md5module.o md5c.o
 # it).
 
 #GMP=/ufs/guido/src/gmp
-#mpz mpzmodule.o -I$(GMP) $(GMP)/libgmp.a
-
-
-# The rotor module (contributed by Lance Ellinghouse) implements a
-# rotor-based encryption algorithm.  It is self-contained.
-
-rotor rotormodule.o
+#mpz mpzmodule.c -I$(GMP) $(GMP)/libgmp.a
 
 
 # SGI IRIX specific modules -- off by default.
@@ -143,14 +138,14 @@ rotor rotormodule.o
 # (Font Manager and Graphics Library).
 
 #                               # ADD THESE FOR IRIX5:
-#al almodule.o -laudio
-#cd cdmodule.o -lcdaudio -lds	# -lmediad
-#cl clmodule.o -lcl		# -lawareaudio
-#fm fmmodule.o -lfm_s -lgl_s
-#gl glmodule.o -lgl_s -lX11_s
-#imgfile imgfile.o -limage -lgutil
-#sgi sgimodule.o
-#sv svmodule.o yuvconvert.o -lsvideo -lXext -lX11_s
+#al almodule.c -laudio
+#cd cdmodule.c -lcdaudio -lds	# -lmediad
+#cl clmodule.c -lcl		# -lawareaudio
+#fm fmmodule.c -lfm_s -lgl_s
+#gl glmodule.c -lgl_s -lX11_s
+#imgfile imgfile.c -limage -lgutil
+#sgi sgimodule.c
+#sv svmodule.c yuvconvert.c -lsvideo -lXext -lX11_s
 
 # The FORMS library, by Mark Overmars, implements user interface
 # components such as dialogs and buttons using SGI's GL and FM
@@ -160,53 +155,51 @@ rotor rotormodule.o
 # toplevel directory.
 
 #FORMS=/ufs/guido/src/forms/FORMS
-#fl flmodule.o -I$(FORMS) $(FORMS)/libforms.a
+#fl flmodule.c -I$(FORMS) $(FORMS)/libforms.a
 
 
 # SunOS specific modules -- off by default
 
-# sunaudiodev sunaudiodev.o
+# sunaudiodev sunaudiodev.c
 
 
 # Thread module -- works on SGI IRIX and on SunOS 5.x (SOLARIS) only.
 # Note that you must have configured (and built!) Python with the
 # --with-thread option passed to the configure script for this to work.
 
-# thread threadmodule.o
+# thread threadmodule.c
 
 
 # GNN's timing module
-# timing timingmodule.o
+# timing timingmodule.c
 
 
-# Lance Ellinghouse's signal module
-# signal signalmodule.o
+# Lance Ellinghouse's modules
+rotor rotormodule.c		# enigma-inspired en-, decryption
+# syslog syslogmodule.c		# syslog daemon interface
+# curses cursesmodule.c -lcurses -ltermcap	# guess what?
 
 
 # Tommy Burnette's 'new' module (creates new empty objects of certain kinds)
-# new newmodule.o
+# new newmodule.c
 
 
 # John Redford's sybase module
-# sybase sybasemodule.o
+# sybase sybasemodule.c
 
 
 # Generic (SunOS / SVR4) dynamic loading module
-# dl dlmodule.o
+# dl dlmodule.c
 
 
 # Jack Jansen's imgformat module
-# imgformat imgformat.o
-
-
-# Lance Ellinghouse's syslog module
-# syslog syslogmodule.o
+# imgformat imgformat.c
 
 
 # Anthony Baxter's gdbm module (derived from Jack's dbm module)
 # GNU dbm(3) will require -lgdbm
-# gdbm gdbmmodule.o -I/usr/local/include -L/usr/local/lib -lgdbm
+# gdbm gdbmmodule.c -I/usr/local/include -L/usr/local/lib -lgdbm
 
 
 # Example -- included for reference only
-# xx xxmodule.o
+# xx xxmodule.c
diff --git a/Modules/_cursesmodule.c b/Modules/_cursesmodule.c
new file mode 100644
index 0000000..0fdf710
--- /dev/null
+++ b/Modules/_cursesmodule.c
@@ -0,0 +1,1298 @@
+/***********************************************************
+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");
+}
diff --git a/Modules/rotormodule.c b/Modules/rotormodule.c
index a083e37..da5ed10 100644
--- a/Modules/rotormodule.c
+++ b/Modules/rotormodule.c
@@ -1,6 +1,6 @@
 /***********************************************************
-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
 
@@ -8,32 +8,19 @@ 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 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.
 
 ******************************************************************/
-/******************************************************************
-Copyright 1992 by Lance Ellinghouse (lance@markv.com)
-
-All Rights Reserved
-
-Permission to use, copy, distribute for any purpose and without fee
-is hereby granted, provided that this copyright notice appear in
-all copies and that both this copyright notice and this permission
-notice appear in supporting documentation.
-Permission to make any changes is granted on the basis that all
-changes and improvements are also forwarded to Lance Ellinghouse
-before distribution.
-******************************************************************/
 
 /* This creates an encryption and decryption engine I am calling
    a rotor due to the original design was a harware rotor with
@@ -641,14 +628,14 @@ PyRotor_Dealloc(xp)
 	PyMem_DEL(xp);
 }
 
-static PyObject *
+static PyObject * 
 PyRotor_Encrypt(self, args)
 	PyRotorObject *self;
-	PyObject *args;
+	PyObject * args;
 {
 	char *string = (char *)NULL;
 	int len = 0;
-	PyObject *rtn = (PyObject *)NULL;
+	PyObject * rtn = (PyObject * )NULL;
 	char *tmp;
 
 	if (!PyArg_Parse(args,"s#",&string, &len))
@@ -665,14 +652,14 @@ PyRotor_Encrypt(self, args)
 	return(rtn);
 }
 
-static PyObject *
+static PyObject * 
 PyRotor_EncryptMore(self, args)
 	PyRotorObject *self;
-	PyObject *args;
+	PyObject * args;
 {
 	char *string = (char *)NULL;
 	int len = 0;
-	PyObject *rtn = (PyObject *)NULL;
+	PyObject * rtn = (PyObject * )NULL;
 	char *tmp;
 
 	if (!PyArg_Parse(args,"s#",&string, &len))
@@ -689,14 +676,14 @@ PyRotor_EncryptMore(self, args)
 	return(rtn);
 }
 
-static PyObject *
+static PyObject * 
 PyRotor_Decrypt(self, args)
 	PyRotorObject *self;
-	PyObject *args;
+	PyObject * args;
 {
 	char *string = (char *)NULL;
 	int len = 0;
-	PyObject *rtn = (PyObject *)NULL;
+	PyObject * rtn = (PyObject * )NULL;
 	char *tmp;
 
 	if (!PyArg_Parse(args,"s#",&string, &len))
@@ -713,14 +700,14 @@ PyRotor_Decrypt(self, args)
 	return(rtn);
 }
 
-static PyObject *
+static PyObject * 
 PyRotor_DecryptMore(self, args)
 	PyRotorObject *self;
-	PyObject *args;
+	PyObject * args;
 {
 	char *string = (char *)NULL;
 	int len = 0;
-	PyObject *rtn = (PyObject *)NULL;
+	PyObject * rtn = (PyObject * )NULL;
 	char *tmp;
 
 	if (!PyArg_Parse(args,"s#",&string, &len))
@@ -737,21 +724,21 @@ PyRotor_DecryptMore(self, args)
 	return(rtn);
 }
 
-static PyObject *
+static PyObject * 
 PyRotor_SetKey(self, args)
 	PyRotorObject *self;
-	PyObject *args;
+	PyObject * args;
 {
 	char *key;
 	char *string;
 
 	if (PyArg_Parse(args,"s",&string))
 		set_key(self,string);
-	Py_INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static PyMethodDef PyRotor_Methods[] = {
+static struct methodlist PyRotor_Methods[] = {
 	{"encrypt",	(PyCFunction)PyRotor_Encrypt},
 	{"encryptmore",	(PyCFunction)PyRotor_EncryptMore},
 	{"decrypt",	(PyCFunction)PyRotor_Decrypt},
@@ -762,12 +749,12 @@ static PyMethodDef PyRotor_Methods[] = {
 
 
 /* Return a rotor object's named attribute. */
-static PyObject *
+static PyObject * 
 PyRotor_GetAttr(s, name)
 	PyRotorObject *s;
 	char *name;
 {
-	return Py_FindMethod(PyRotor_Methods, (PyObject *) s, name);
+	return Py_FindMethod(PyRotor_Methods, (PyObject * ) s, name);
 }
 
 static PyTypeObject PyRotor_Type = {
@@ -787,10 +774,10 @@ static PyTypeObject PyRotor_Type = {
 };
 
 
-static PyObject *
+static PyObject * 
 PyRotor_Rotor(self, args)
-	PyObject *self;
-	PyObject *args;
+	PyObject * self;
+	PyObject * args;
 {
 	char *string;
 	PyRotorObject *r;
@@ -805,10 +792,10 @@ PyRotor_Rotor(self, args)
 			return NULL;
 	}
 	r = PyRotor_New(num_rotors, string);
-	return (PyObject *)r;
+	return (PyObject * )r;
 }
 
-static PyMethodDef PyRotor_Rotor_Methods[] = {
+static struct methodlist PyRotor_Rotor_Methods[] = {
 	{"newrotor",		(PyCFunction)PyRotor_Rotor},
 	{NULL,			NULL}		 /* Sentinel */
 };
@@ -822,7 +809,7 @@ static PyMethodDef PyRotor_Rotor_Methods[] = {
 void
 initrotor()
 {
-	PyObject *m;
+	PyObject * m;
 
 	m = Py_InitModule("rotor", PyRotor_Rotor_Methods);
 }
diff --git a/Modules/syslogmodule.c b/Modules/syslogmodule.c
index dd0ba35..eea33aa 100644
--- a/Modules/syslogmodule.c
+++ b/Modules/syslogmodule.c
@@ -1,6 +1,6 @@
 /***********************************************************
-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
 
@@ -8,125 +8,126 @@ 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 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 */
 };
 
@@ -135,65 +136,65 @@ static struct methodlist syslog_methods[] = {
 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");
 }