Patch #477752: Drop old-style getargs from curses.

2 files changed, 309 insertions, 372 deletions

diff --git a/Modules/_curses_panel.c b/Modules/_curses_panel.c
index 11bf5c8..f95392f 100644
--- a/Modules/_curses_panel.c
+++ b/Modules/_curses_panel.c
@@ -141,14 +141,12 @@ find_po(PANEL *pan)
    PARSESTR - format string for argument parsing */
 
 #define Panel_NoArgNoReturnFunction(X) \
-static PyObject *PyCursesPanel_##X(PyCursesPanelObject *self, PyObject *args) \
-{ if (!PyArg_NoArgs(args)) return NULL; \
-  return PyCursesCheckERR(X(self->pan), # X); }
+static PyObject *PyCursesPanel_##X(PyCursesPanelObject *self) \
+{ return PyCursesCheckERR(X(self->pan), # X); }
 
 #define Panel_NoArgTrueFalseFunction(X) \
-static PyObject *PyCursesPanel_##X(PyCursesPanelObject *self, PyObject *args) \
+static PyObject *PyCursesPanel_##X(PyCursesPanelObject *self) \
 { \
-  if (!PyArg_NoArgs(args)) return NULL; \
   if (X (self->pan) == FALSE) { Py_INCREF(Py_False); return Py_False; } \
   else { Py_INCREF(Py_True); return Py_True; } }
 
@@ -156,7 +154,7 @@ static PyObject *PyCursesPanel_##X(PyCursesPanelObject *self, PyObject *args) \
 static PyObject *PyCursesPanel_##X(PyCursesPanelObject *self, PyObject *args) \
 { \
   TYPE arg1, arg2; \
-  if (!PyArg_Parse(args,PARSESTR, &arg1, &arg2)) return NULL; \
+  if (!PyArg_ParseTuple(args, PARSESTR, &arg1, &arg2)) return NULL; \
   return PyCursesCheckERR(X(self->pan, arg1, arg2), # X); }
 
 /* ------------- PANEL routines --------------- */
@@ -166,7 +164,7 @@ Panel_NoArgNoReturnFunction(hide_panel)
 Panel_NoArgNoReturnFunction(show_panel)
 Panel_NoArgNoReturnFunction(top_panel)
 Panel_NoArgTrueFalseFunction(panel_hidden)
-Panel_TwoArgNoReturnFunction(move_panel, int, "(ii);y,x")
+Panel_TwoArgNoReturnFunction(move_panel, int, "ii;y,x")
 
 /* Allocation and deallocation of Panel Objects */
 
@@ -199,13 +197,11 @@ PyCursesPanel_Dealloc(PyCursesPanelObject *po)
 /* panel_above(NULL) returns the bottom panel in the stack. To get
    this behaviour we use curses.panel.bottom_panel(). */
 static PyObject *
-PyCursesPanel_above(PyCursesPanelObject *self, PyObject *args)
+PyCursesPanel_above(PyCursesPanelObject *self)
 {
     PANEL *pan;
     PyCursesPanelObject *po;
     
-    if (!PyArg_NoArgs(args)) return NULL;
-    
     pan = panel_above(self->pan);
 
     if (pan == NULL) {		/* valid output, it means the calling panel
@@ -226,13 +222,11 @@ PyCursesPanel_above(PyCursesPanelObject *self, PyObject *args)
 /* panel_below(NULL) returns the top panel in the stack. To get
    this behaviour we use curses.panel.top_panel(). */
 static PyObject *
-PyCursesPanel_below(PyCursesPanelObject *self, PyObject *args)
+PyCursesPanel_below(PyCursesPanelObject *self)
 {
     PANEL *pan;
     PyCursesPanelObject *po;
     
-    if (!PyArg_NoArgs(args)) return NULL;
-    
     pan = panel_below(self->pan);
     
     if (pan == NULL) {		/* valid output, it means the calling panel
@@ -251,10 +245,8 @@ PyCursesPanel_below(PyCursesPanelObject *self, PyObject *args)
 }
 
 static PyObject *
-PyCursesPanel_window(PyCursesPanelObject *self, PyObject *args)
+PyCursesPanel_window(PyCursesPanelObject *self)
 {
-    if (!PyArg_NoArgs(args)) return NULL;
-
     Py_INCREF(self->wo);
     return (PyObject *)self->wo;
 }
@@ -266,7 +258,7 @@ PyCursesPanel_replace_panel(PyCursesPanelObject *self, PyObject *args)
     PyCursesWindowObject *temp;
     int rtn;
     
-    if (ARG_COUNT(args) != 1) {
+    if (PyTuple_Size(args) != 1) {
 	PyErr_SetString(PyExc_TypeError, "replace requires one argument");
 	return NULL;
     }
@@ -294,27 +286,18 @@ PyCursesPanel_replace_panel(PyCursesPanelObject *self, PyObject *args)
 }
 
 static PyObject *
-PyCursesPanel_set_panel_userptr(PyCursesPanelObject *self, PyObject *args)
+PyCursesPanel_set_panel_userptr(PyCursesPanelObject *self, PyObject *obj)
 {
-    PyObject *obj;
-    
-    if (ARG_COUNT(args) != 1) {
-	PyErr_SetString(PyExc_TypeError, "set_userptr requires one argument");
-	return NULL;
-    }
-    obj = PyTuple_GetItem(args, 0);
     Py_INCREF(obj);
     return PyCursesCheckERR(set_panel_userptr(self->pan, (void*)obj),
                             "set_panel_userptr");
 }
 
-static PyObject *PyCursesPanel_userptr
-(PyCursesPanelObject *self, PyObject *args)
+static PyObject *
+PyCursesPanel_userptr(PyCursesPanelObject *self)
 {
     PyObject *obj;
     PyCursesInitialised; 
-    if (!PyArg_NoArgs(args))
-        return NULL;
     obj = (PyObject *) panel_userptr(self->pan);
     Py_INCREF(obj);
     return obj;
@@ -324,20 +307,19 @@ static PyObject *PyCursesPanel_userptr
 /* Module interface */
 
 static PyMethodDef PyCursesPanel_Methods[] = {
-    {"above",           (PyCFunction)PyCursesPanel_above},
-    {"below",           (PyCFunction)PyCursesPanel_below},
-    {"bottom",          (PyCFunction)PyCursesPanel_bottom_panel},
-    {"hidden",          (PyCFunction)PyCursesPanel_panel_hidden},
-    {"hide",            (PyCFunction)PyCursesPanel_hide_panel},
-    {"move",            (PyCFunction)PyCursesPanel_move_panel},
+    {"above",           (PyCFunction)PyCursesPanel_above, METH_NOARGS},
+    {"below",           (PyCFunction)PyCursesPanel_below, METH_NOARGS},
+    {"bottom",          (PyCFunction)PyCursesPanel_bottom_panel, METH_NOARGS},
+    {"hidden",          (PyCFunction)PyCursesPanel_panel_hidden, METH_NOARGS},
+    {"hide",            (PyCFunction)PyCursesPanel_hide_panel, METH_NOARGS},
+    {"move",            (PyCFunction)PyCursesPanel_move_panel, METH_VARARGS},
     {"replace",         (PyCFunction)PyCursesPanel_replace_panel,
      METH_VARARGS},
-    {"set_userptr",     (PyCFunction)PyCursesPanel_set_panel_userptr, 
-     METH_VARARGS},
-    {"show",            (PyCFunction)PyCursesPanel_show_panel},
-    {"top",             (PyCFunction)PyCursesPanel_top_panel},
-    {"userptr",         (PyCFunction)PyCursesPanel_userptr},
-    {"window",          (PyCFunction)PyCursesPanel_window},
+    {"set_userptr",     (PyCFunction)PyCursesPanel_set_panel_userptr, METH_O},
+    {"show",            (PyCFunction)PyCursesPanel_show_panel, METH_NOARGS},
+    {"top",             (PyCFunction)PyCursesPanel_top_panel, METH_NOARGS},
+    {"userptr",         (PyCFunction)PyCursesPanel_userptr, METH_NOARGS},
+    {"window",          (PyCFunction)PyCursesPanel_window, METH_NOARGS},
     {NULL,		NULL}   /* sentinel */
 };
 
diff --git a/Modules/_cursesmodule.c b/Modules/_cursesmodule.c
index d3f97be..e785e48 100644
--- a/Modules/_cursesmodule.c
+++ b/Modules/_cursesmodule.c
@@ -242,48 +242,44 @@ PyTypeObject PyCursesWindow_Type;
 
 #define Window_NoArgNoReturnFunction(X) \
 static PyObject *PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
-{ if (!PyArg_NoArgs(args)) return NULL; \
-  return PyCursesCheckERR(X(self->win), # X); }
+{ return PyCursesCheckERR(X(self->win), # X); }
 
 #define Window_NoArgTrueFalseFunction(X) \
-static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
+static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
 { \
-  if (!PyArg_NoArgs(args)) return NULL; \
   if (X (self->win) == FALSE) { Py_INCREF(Py_False); return Py_False; } \
   else { Py_INCREF(Py_True); return Py_True; } }
 
 #define Window_NoArgNoReturnVoidFunction(X) \
-static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
+static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
 { \
-  if (!PyArg_NoArgs(args)) return NULL; \
   X(self->win); Py_INCREF(Py_None); return Py_None; }
 
 #define Window_NoArg2TupleReturnFunction(X, TYPE, ERGSTR) \
-static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
+static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \
 { \
   TYPE arg1, arg2; \
-  if (!PyArg_NoArgs(args)) return NULL; \
   X(self->win,arg1,arg2); return Py_BuildValue(ERGSTR, arg1, arg2); } 
 
 #define Window_OneArgNoReturnVoidFunction(X, TYPE, PARSESTR) \
 static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
 { \
   TYPE arg1; \
-  if (!PyArg_Parse(args, PARSESTR, &arg1)) return NULL; \
+  if (!PyArg_ParseTuple(args, PARSESTR, &arg1)) return NULL; \
   X(self->win,arg1); Py_INCREF(Py_None); return Py_None; }
 
 #define Window_OneArgNoReturnFunction(X, TYPE, PARSESTR) \
 static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
 { \
   TYPE arg1; \
-  if (!PyArg_Parse(args,PARSESTR, &arg1)) return NULL; \
+  if (!PyArg_ParseTuple(args,PARSESTR, &arg1)) return NULL; \
   return PyCursesCheckERR(X(self->win, arg1), # X); }
 
 #define Window_TwoArgNoReturnFunction(X, TYPE, PARSESTR) \
 static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \
 { \
   TYPE arg1, arg2; \
-  if (!PyArg_Parse(args,PARSESTR, &arg1, &arg2)) return NULL; \
+  if (!PyArg_ParseTuple(args,PARSESTR, &arg1, &arg2)) return NULL; \
   return PyCursesCheckERR(X(self->win, arg1, arg2), # X); }
 
 /* ------------- WINDOW routines --------------- */
@@ -310,10 +306,10 @@ Window_OneArgNoReturnVoidFunction(idcok, int, "i;True(1) or False(0)")
 Window_OneArgNoReturnVoidFunction(immedok, int, "i;True(1) or False(0)")
 Window_OneArgNoReturnVoidFunction(wtimeout, int, "i;delay")
 
-Window_NoArg2TupleReturnFunction(getyx, int, "(ii)")
-Window_NoArg2TupleReturnFunction(getbegyx, int, "(ii)")
-Window_NoArg2TupleReturnFunction(getmaxyx, int, "(ii)")
-Window_NoArg2TupleReturnFunction(getparyx, int, "(ii)")
+Window_NoArg2TupleReturnFunction(getyx, int, "ii")
+Window_NoArg2TupleReturnFunction(getbegyx, int, "ii")
+Window_NoArg2TupleReturnFunction(getmaxyx, int, "ii")
+Window_NoArg2TupleReturnFunction(getparyx, int, "ii")
 
 Window_OneArgNoReturnFunction(wattron, attr_t, "l;attr")
 Window_OneArgNoReturnFunction(wattroff, attr_t, "l;attr")
@@ -336,11 +332,11 @@ Window_OneArgNoReturnFunction(scrollok, int, "i;True(1) or False(0)")
 Window_OneArgNoReturnFunction(winsdelln, int, "i;nlines")
 Window_OneArgNoReturnFunction(syncok, int, "i;True(1) or False(0)")
 
-Window_TwoArgNoReturnFunction(mvwin, int, "(ii);y,x")
-Window_TwoArgNoReturnFunction(mvderwin, int, "(ii);y,x")
-Window_TwoArgNoReturnFunction(wmove, int, "(ii);y,x")
+Window_TwoArgNoReturnFunction(mvwin, int, "ii;y,x")
+Window_TwoArgNoReturnFunction(mvderwin, int, "ii;y,x")
+Window_TwoArgNoReturnFunction(wmove, int, "ii;y,x")
 #ifndef STRICT_SYSV_CURSES
-Window_TwoArgNoReturnFunction(wresize, int, "(ii);lines,columns")
+Window_TwoArgNoReturnFunction(wresize, int, "ii;lines,columns")
 #endif
 
 /* Allocation and deallocation of Window Objects */
@@ -373,22 +369,22 @@ PyCursesWindow_AddCh(PyCursesWindowObject *self, PyObject *args)
   chtype ch = 0;
   attr_t attr = A_NORMAL;
   
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 1:
-    if (!PyArg_Parse(args, "O;ch or int", &temp))
+    if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
 	  return NULL;
     break;
   case 2:
-    if (!PyArg_Parse(args, "(Ol);ch or int,attr", &temp, &attr))
+    if (!PyArg_ParseTuple(args, "Ol;ch or int,attr", &temp, &attr))
       return NULL;
     break;
   case 3:
-    if (!PyArg_Parse(args,"(iiO);y,x,ch or int", &y, &x, &temp))
+    if (!PyArg_ParseTuple(args,"iiO;y,x,ch or int", &y, &x, &temp))
       return NULL;
     use_xy = TRUE;
     break;
   case 4:
-    if (!PyArg_Parse(args,"(iiOl);y,x,ch or int, attr", 
+    if (!PyArg_ParseTuple(args,"iiOl;y,x,ch or int, attr", 
 		     &y, &x, &temp, &attr))
       return NULL;
     use_xy = TRUE;
@@ -420,23 +416,23 @@ PyCursesWindow_AddStr(PyCursesWindowObject *self, PyObject *args)
   attr_t attr = A_NORMAL , attr_old = A_NORMAL;
   int use_xy = FALSE, use_attr = FALSE;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 1:
-    if (!PyArg_Parse(args,"s;str", &str))
+    if (!PyArg_ParseTuple(args,"s;str", &str))
       return NULL;
     break;
   case 2:
-    if (!PyArg_Parse(args,"(sl);str,attr", &str, &attr))
+    if (!PyArg_ParseTuple(args,"sl;str,attr", &str, &attr))
       return NULL;
     use_attr = TRUE;
     break;
   case 3:
-    if (!PyArg_Parse(args,"(iis);int,int,str", &y, &x, &str))
+    if (!PyArg_ParseTuple(args,"iis;int,int,str", &y, &x, &str))
       return NULL;
     use_xy = TRUE;
     break;
   case 4:
-    if (!PyArg_Parse(args,"(iisl);int,int,str,attr", &y, &x, &str, &attr))
+    if (!PyArg_ParseTuple(args,"iisl;int,int,str,attr", &y, &x, &str, &attr))
       return NULL;
     use_xy = use_attr = TRUE;
     break;
@@ -466,23 +462,23 @@ PyCursesWindow_AddNStr(PyCursesWindowObject *self, PyObject *args)
   attr_t attr = A_NORMAL , attr_old = A_NORMAL;
   int use_xy = FALSE, use_attr = FALSE;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 2:
-    if (!PyArg_Parse(args,"(si);str,n", &str, &n))
+    if (!PyArg_ParseTuple(args,"si;str,n", &str, &n))
       return NULL;
     break;
   case 3:
-    if (!PyArg_Parse(args,"(sil);str,n,attr", &str, &n, &attr))
+    if (!PyArg_ParseTuple(args,"sil;str,n,attr", &str, &n, &attr))
       return NULL;
     use_attr = TRUE;
     break;
   case 4:
-    if (!PyArg_Parse(args,"(iisi);y,x,str,n", &y, &x, &str, &n))
+    if (!PyArg_ParseTuple(args,"iisi;y,x,str,n", &y, &x, &str, &n))
       return NULL;
     use_xy = TRUE;
     break;
   case 5:
-    if (!PyArg_Parse(args,"(iisil);y,x,str,n,attr", &y, &x, &str, &n, &attr))
+    if (!PyArg_ParseTuple(args,"iisil;y,x,str,n,attr", &y, &x, &str, &n, &attr))
       return NULL;
     use_xy = use_attr = TRUE;
     break;
@@ -511,13 +507,13 @@ PyCursesWindow_Bkgd(PyCursesWindowObject *self, PyObject *args)
   chtype bkgd;
   attr_t attr = A_NORMAL;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
     case 1:
-      if (!PyArg_Parse(args, "O;ch or int", &temp))
+      if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
         return NULL;
       break;
     case 2:
-      if (!PyArg_Parse(args,"(Ol);ch or int,attr", &temp, &attr))
+      if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &attr))
         return NULL;
       break;
     default:
@@ -540,13 +536,13 @@ PyCursesWindow_BkgdSet(PyCursesWindowObject *self, PyObject *args)
   chtype bkgd;
   attr_t attr = A_NORMAL;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
     case 1:
-      if (!PyArg_Parse(args, "O;ch or int", &temp))
+      if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
         return NULL;
       break;
     case 2:
-      if (!PyArg_Parse(args,"(Ol);ch or int,attr", &temp, &attr))
+      if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &attr))
         return NULL;
       break;
     default:
@@ -600,9 +596,10 @@ static PyObject *
 PyCursesWindow_Box(PyCursesWindowObject *self, PyObject *args)
 {
   chtype ch1=0,ch2=0;
-  if (!PyArg_NoArgs(args)) {
-    PyErr_Clear();
-    if (!PyArg_Parse(args,"(ll);vertint,horint", &ch1, &ch2))
+  switch(PyTuple_Size(args)){
+  case 0: break;
+  default:
+    if (!PyArg_ParseTuple(args,"ll;vertint,horint", &ch1, &ch2))
       return NULL;
   }
   box(self->win,ch1,ch2);
@@ -629,12 +626,12 @@ PyCursesWindow_DelCh(PyCursesWindowObject *self, PyObject *args)
   int rtn;
   int x, y;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 0:
     rtn = wdelch(self->win);
     break;
   case 2:
-    if (!PyArg_Parse(args,"(ii);y,x", &y, &x))
+    if (!PyArg_ParseTuple(args,"ii;y,x", &y, &x))
       return NULL;
     rtn = py_mvwdelch(self->win,y,x);
     break;
@@ -653,13 +650,13 @@ PyCursesWindow_DerWin(PyCursesWindowObject *self, PyObject *args)
 
   nlines = 0;
   ncols  = 0;
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 2:
-    if (!PyArg_Parse(args,"(ii);begin_y,begin_x",&begin_y,&begin_x))
+    if (!PyArg_ParseTuple(args,"ii;begin_y,begin_x",&begin_y,&begin_x))
       return NULL;
     break;
   case 4:
-    if (!PyArg_Parse(args, "(iiii);nlines,ncols,begin_y,begin_x",
+    if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",
 		   &nlines,&ncols,&begin_y,&begin_x))
       return NULL;
     break;
@@ -685,13 +682,13 @@ PyCursesWindow_EchoChar(PyCursesWindowObject *self, PyObject *args)
   chtype ch;
   attr_t attr = A_NORMAL;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 1:
-    if (!PyArg_Parse(args,"O;ch or int", &temp))
+    if (!PyArg_ParseTuple(args,"O;ch or int", &temp))
       return NULL;
     break;
   case 2:
-    if (!PyArg_Parse(args,"(Ol);ch or int,attr", &temp, &attr))
+    if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &attr))
       return NULL;
     break;
   default:
@@ -721,7 +718,7 @@ static PyObject *
 PyCursesWindow_Enclose(PyCursesWindowObject *self, PyObject *args)
 {
 	int x, y;
-	if (!PyArg_Parse(args,"(ii);y,x", &y, &x))
+	if (!PyArg_ParseTuple(args,"ii;y,x", &y, &x))
 		return NULL;
 
 	return PyInt_FromLong( wenclose(self->win,y,x) );
@@ -729,10 +726,8 @@ PyCursesWindow_Enclose(PyCursesWindowObject *self, PyObject *args)
 #endif
 
 static PyObject *
-PyCursesWindow_GetBkgd(PyCursesWindowObject *self, PyObject *args)
+PyCursesWindow_GetBkgd(PyCursesWindowObject *self)
 {
-  if (!PyArg_NoArgs(args))
-    return NULL;
   return PyInt_FromLong((long) getbkgd(self->win));
 }
 
@@ -742,14 +737,14 @@ PyCursesWindow_GetCh(PyCursesWindowObject *self, PyObject *args)
   int x, y;
   chtype rtn;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 0:
     Py_BEGIN_ALLOW_THREADS
     rtn = wgetch(self->win);
     Py_END_ALLOW_THREADS
     break;
   case 2:
-    if (!PyArg_Parse(args,"(ii);y,x",&y,&x))
+    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
       return NULL;
     Py_BEGIN_ALLOW_THREADS
     rtn = mvwgetch(self->win,y,x);
@@ -768,14 +763,14 @@ PyCursesWindow_GetKey(PyCursesWindowObject *self, PyObject *args)
   int x, y;
   chtype rtn;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 0:
     Py_BEGIN_ALLOW_THREADS
     rtn = wgetch(self->win);
     Py_END_ALLOW_THREADS
     break;
   case 2:
-    if (!PyArg_Parse(args,"(ii);y,x",&y,&x))
+    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
       return NULL;
     Py_BEGIN_ALLOW_THREADS
     rtn = mvwgetch(self->win,y,x);
@@ -802,28 +797,28 @@ PyCursesWindow_GetStr(PyCursesWindowObject *self, PyObject *args)
   char rtn[1024]; /* This should be big enough.. I hope */
   int rtn2;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 0:
     Py_BEGIN_ALLOW_THREADS
     rtn2 = wgetstr(self->win,rtn);
     Py_END_ALLOW_THREADS
     break;
   case 1:
-    if (!PyArg_Parse(args,"i;n", &n))
+    if (!PyArg_ParseTuple(args,"i;n", &n))
       return NULL;
     Py_BEGIN_ALLOW_THREADS
     rtn2 = wgetnstr(self->win,rtn,n);
     Py_END_ALLOW_THREADS
     break;
   case 2:
-    if (!PyArg_Parse(args,"(ii);y,x",&y,&x))
+    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
       return NULL;
     Py_BEGIN_ALLOW_THREADS
     rtn2 = mvwgetstr(self->win,y,x,rtn);
     Py_END_ALLOW_THREADS
     break;
   case 3:
-    if (!PyArg_Parse(args,"(iii);y,x,n", &y, &x, &n))
+    if (!PyArg_ParseTuple(args,"iii;y,x,n", &y, &x, &n))
       return NULL;
 #ifdef STRICT_SYSV_CURSES
  /* Untested */
@@ -854,22 +849,22 @@ PyCursesWindow_Hline(PyCursesWindowObject *self, PyObject *args)
   int n, x, y, code = OK;
   attr_t attr = A_NORMAL;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 2:
-    if (!PyArg_Parse(args, "(Oi);ch or int,n", &temp, &n))
+    if (!PyArg_ParseTuple(args, "Oi;ch or int,n", &temp, &n))
       return NULL;
     break;
   case 3:
-    if (!PyArg_Parse(args, "(Oil);ch or int,n,attr", &temp, &n, &attr))
+    if (!PyArg_ParseTuple(args, "Oil;ch or int,n,attr", &temp, &n, &attr))
       return NULL;
     break;
   case 4:
-    if (!PyArg_Parse(args, "(iiOi);y,x,ch or int,n", &y, &x, &temp, &n))
+    if (!PyArg_ParseTuple(args, "iiOi;y,x,ch or int,n", &y, &x, &temp, &n))
       return NULL;
     code = wmove(self->win, y, x);
     break;
   case 5:
-    if (!PyArg_Parse(args, "(iiOil); y,x,ch or int,n,attr", 
+    if (!PyArg_ParseTuple(args, "iiOil; y,x,ch or int,n,attr", 
 		     &y, &x, &temp, &n, &attr))
       return NULL;
     code = wmove(self->win, y, x);
@@ -898,22 +893,22 @@ PyCursesWindow_InsCh(PyCursesWindowObject *self, PyObject *args)
   chtype ch = 0;
   attr_t attr = A_NORMAL;
   
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 1:
-    if (!PyArg_Parse(args, "O;ch or int", &temp))
+    if (!PyArg_ParseTuple(args, "O;ch or int", &temp))
       return NULL;
     break;
   case 2:
-    if (!PyArg_Parse(args, "(Ol);ch or int,attr", &temp, &attr))
+    if (!PyArg_ParseTuple(args, "Ol;ch or int,attr", &temp, &attr))
       return NULL;
     break;
   case 3:
-    if (!PyArg_Parse(args,"(iiO);y,x,ch or int", &y, &x, &temp))
+    if (!PyArg_ParseTuple(args,"iiO;y,x,ch or int", &y, &x, &temp))
       return NULL;
     use_xy = TRUE;
     break;
   case 4:
-    if (!PyArg_Parse(args,"(iiOl);y,x,ch or int, attr", &y, &x, &temp, &attr))
+    if (!PyArg_ParseTuple(args,"iiOl;y,x,ch or int, attr", &y, &x, &temp, &attr))
       return NULL;
     use_xy = TRUE;
     break;
@@ -941,12 +936,12 @@ PyCursesWindow_InCh(PyCursesWindowObject *self, PyObject *args)
 {
   int x, y, rtn;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 0:
     rtn = winch(self->win);
     break;
   case 2:
-    if (!PyArg_Parse(args,"(ii);y,x",&y,&x))
+    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
       return NULL;
     rtn = mvwinch(self->win,y,x);
     break;
@@ -964,22 +959,22 @@ PyCursesWindow_InStr(PyCursesWindowObject *self, PyObject *args)
   char rtn[1024]; /* This should be big enough.. I hope */
   int rtn2;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 0:
     rtn2 = winstr(self->win,rtn);
     break;
   case 1:
-    if (!PyArg_Parse(args,"i;n", &n))
+    if (!PyArg_ParseTuple(args,"i;n", &n))
       return NULL;
     rtn2 = winnstr(self->win,rtn,n);
     break;
   case 2:
-    if (!PyArg_Parse(args,"(ii);y,x",&y,&x))
+    if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))
       return NULL;
     rtn2 = mvwinstr(self->win,y,x,rtn);
     break;
   case 3:
-    if (!PyArg_Parse(args, "(iii);y,x,n", &y, &x, &n))
+    if (!PyArg_ParseTuple(args, "iii;y,x,n", &y, &x, &n))
       return NULL;
     rtn2 = mvwinnstr(self->win, y, x, rtn, n);
     break;
@@ -1001,23 +996,23 @@ PyCursesWindow_InsStr(PyCursesWindowObject *self, PyObject *args)
   attr_t attr = A_NORMAL , attr_old = A_NORMAL;
   int use_xy = FALSE, use_attr = FALSE;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 1:
-    if (!PyArg_Parse(args,"s;str", &str))
+    if (!PyArg_ParseTuple(args,"s;str", &str))
       return NULL;
     break;
   case 2:
-    if (!PyArg_Parse(args,"(sl);str,attr", &str, &attr))
+    if (!PyArg_ParseTuple(args,"sl;str,attr", &str, &attr))
       return NULL;
     use_attr = TRUE;
     break;
   case 3:
-    if (!PyArg_Parse(args,"(iis);y,x,str", &y, &x, &str))
+    if (!PyArg_ParseTuple(args,"iis;y,x,str", &y, &x, &str))
       return NULL;
     use_xy = TRUE;
     break;
   case 4:
-    if (!PyArg_Parse(args,"(iisl);y,x,str,attr", &y, &x, &str, &attr))
+    if (!PyArg_ParseTuple(args,"iisl;y,x,str,attr", &y, &x, &str, &attr))
       return NULL;
     use_xy = use_attr = TRUE;
     break;
@@ -1047,23 +1042,23 @@ PyCursesWindow_InsNStr(PyCursesWindowObject *self, PyObject *args)
   attr_t attr = A_NORMAL , attr_old = A_NORMAL;
   int use_xy = FALSE, use_attr = FALSE;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 2:
-    if (!PyArg_Parse(args,"(si);str,n", &str, &n))
+    if (!PyArg_ParseTuple(args,"si;str,n", &str, &n))
       return NULL;
     break;
   case 3:
-    if (!PyArg_Parse(args,"(sil);str,n,attr", &str, &n, &attr))
+    if (!PyArg_ParseTuple(args,"sil;str,n,attr", &str, &n, &attr))
       return NULL;
     use_attr = TRUE;
     break;
   case 4:
-    if (!PyArg_Parse(args,"(iisi);y,x,str,n", &y, &x, &str, &n))
+    if (!PyArg_ParseTuple(args,"iisi;y,x,str,n", &y, &x, &str, &n))
       return NULL;
     use_xy = TRUE;
     break;
   case 5:
-    if (!PyArg_Parse(args,"(iisil);y,x,str,n,attr", &y, &x, &str, &n, &attr))
+    if (!PyArg_ParseTuple(args,"iisil;y,x,str,n,attr", &y, &x, &str, &n, &attr))
       return NULL;
     use_xy = use_attr = TRUE;
     break;
@@ -1089,7 +1084,7 @@ static PyObject *
 PyCursesWindow_Is_LineTouched(PyCursesWindowObject *self, PyObject *args)
 {
   int line, erg;
-  if (!PyArg_Parse(args,"i;line", &line))
+  if (!PyArg_ParseTuple(args,"i;line", &line))
     return NULL;
   erg = is_linetouched(self->win, line);
   if (erg == ERR) {
@@ -1117,10 +1112,10 @@ PyCursesWindow_NoOutRefresh(PyCursesWindowObject *self, PyObject *args)
 #else
   if (self->win->_flags & _ISPAD) {
 #endif
-    switch(ARG_COUNT(args)) {
+    switch(PyTuple_Size(args)) {
     case 6:
-      if (!PyArg_Parse(args, 
-		       "(iiiiii);" \
+      if (!PyArg_ParseTuple(args, 
+		       "iiiiii;" \
 		       "pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol", 
 		       &pminrow, &pmincol, &sminrow, 
 		       &smincol, &smaxrow, &smaxcol))
@@ -1138,7 +1133,7 @@ PyCursesWindow_NoOutRefresh(PyCursesWindowObject *self, PyObject *args)
       return NULL;
     }
   } else {
-    if (!PyArg_NoArgs(args))
+    if (!PyArg_ParseTuple(args, ":noutrefresh"))
       return NULL;    
 
     Py_BEGIN_ALLOW_THREADS
@@ -1156,7 +1151,7 @@ PyCursesWindow_Overlay(PyCursesWindowObject *self, PyObject *args)
     int sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol;
     int rtn;
     
-    switch (ARG_COUNT(args)) {
+    switch (PyTuple_Size(args)) {
     case 1:
 	if (!PyArg_ParseTuple(args, "O!;window object",
 			      &PyCursesWindow_Type, &temp))
@@ -1194,7 +1189,7 @@ PyCursesWindow_Overwrite(PyCursesWindowObject *self, PyObject *args)
     int sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol;
     int rtn;
     
-    switch (ARG_COUNT(args)) {
+    switch (PyTuple_Size(args)) {
     case 1:
 	if (!PyArg_ParseTuple(args, "O!;window object",
 			      &PyCursesWindow_Type, &temp))
@@ -1229,7 +1224,7 @@ PyCursesWindow_PutWin(PyCursesWindowObject *self, PyObject *args)
 {
   PyObject *temp;
   
-  if (!PyArg_Parse(args, "O;fileobj", &temp))
+  if (!PyArg_ParseTuple(args, "O;fileobj", &temp))
     return NULL;
   if (!PyFile_Check(temp)) {
     PyErr_SetString(PyExc_TypeError, "argument must be a file object");
@@ -1243,7 +1238,7 @@ static PyObject *
 PyCursesWindow_RedrawLine(PyCursesWindowObject *self, PyObject *args)
 {
   int beg, num;
-  if (!PyArg_Parse(args,"(ii);beg,num", &beg, &num))
+  if (!PyArg_ParseTuple(args,"ii;beg,num", &beg, &num))
     return NULL;
   return PyCursesCheckERR(wredrawln(self->win,beg,num), "redrawln");
 }
@@ -1259,10 +1254,10 @@ PyCursesWindow_Refresh(PyCursesWindowObject *self, PyObject *args)
 #else
   if (self->win->_flags & _ISPAD) {
 #endif
-    switch(ARG_COUNT(args)) {
+    switch(PyTuple_Size(args)) {
     case 6:
-      if (!PyArg_Parse(args, 
-		       "(iiiiii);" \
+      if (!PyArg_ParseTuple(args, 
+		       "iiiiii;" \
 		       "pminrow,pmincol,sminrow,smincol,smaxrow,smaxcol", 
 		       &pminrow, &pmincol, &sminrow, 
 		       &smincol, &smaxrow, &smaxcol))
@@ -1280,7 +1275,7 @@ PyCursesWindow_Refresh(PyCursesWindowObject *self, PyObject *args)
       return NULL;
     }
   } else {
-    if (!PyArg_NoArgs(args))
+    if (!PyArg_ParseTuple(args, ":refresh"))
       return NULL;    
     Py_BEGIN_ALLOW_THREADS
     rtn = wrefresh(self->win);
@@ -1293,7 +1288,7 @@ static PyObject *
 PyCursesWindow_SetScrollRegion(PyCursesWindowObject *self, PyObject *args)
 {
   int x, y;
-  if (!PyArg_Parse(args,"(ii);top, bottom",&y,&x))
+  if (!PyArg_ParseTuple(args,"ii;top, bottom",&y,&x))
     return NULL;
   return PyCursesCheckERR(wsetscrreg(self->win,y,x), "wsetscrreg");
 }
@@ -1306,13 +1301,13 @@ PyCursesWindow_SubWin(PyCursesWindowObject *self, PyObject *args)
 
   nlines = 0;
   ncols  = 0;
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 2:
-    if (!PyArg_Parse(args,"(ii);begin_y,begin_x",&begin_y,&begin_x))
+    if (!PyArg_ParseTuple(args,"ii;begin_y,begin_x",&begin_y,&begin_x))
       return NULL;
     break;
   case 4:
-    if (!PyArg_Parse(args, "(iiii);nlines,ncols,begin_y,begin_x",
+    if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",
 		   &nlines,&ncols,&begin_y,&begin_x))
       return NULL;
     break;
@@ -1341,11 +1336,11 @@ static PyObject *
 PyCursesWindow_Scroll(PyCursesWindowObject *self, PyObject *args)
 {
   int nlines;
-  switch(ARG_COUNT(args)) {
+  switch(PyTuple_Size(args)) {
   case 0:
     return PyCursesCheckERR(scroll(self->win), "scroll");
   case 1:
-    if (!PyArg_Parse(args, "i;nlines", &nlines))
+    if (!PyArg_ParseTuple(args, "i;nlines", &nlines))
       return NULL;
     return PyCursesCheckERR(wscrl(self->win, nlines), "scroll");
   default:
@@ -1358,13 +1353,13 @@ static PyObject *
 PyCursesWindow_TouchLine(PyCursesWindowObject *self, PyObject *args)
 {
   int st, cnt, val;
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 2:
-    if (!PyArg_Parse(args,"(ii);start,count",&st,&cnt))
+    if (!PyArg_ParseTuple(args,"ii;start,count",&st,&cnt))
       return NULL;
     return PyCursesCheckERR(touchline(self->win,st,cnt), "touchline");
   case 3:
-    if (!PyArg_Parse(args, "(iii);start,count,val", &st, &cnt, &val))
+    if (!PyArg_ParseTuple(args, "iii;start,count,val", &st, &cnt, &val))
       return NULL;
     return PyCursesCheckERR(wtouchln(self->win, st, cnt, val), "touchline");
   default:
@@ -1381,22 +1376,22 @@ PyCursesWindow_Vline(PyCursesWindowObject *self, PyObject *args)
   int n, x, y, code = OK;
   attr_t attr = A_NORMAL;
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 2:
-    if (!PyArg_Parse(args, "(Oi);ch or int,n", &temp, &n))
+    if (!PyArg_ParseTuple(args, "Oi;ch or int,n", &temp, &n))
       return NULL;
     break;
   case 3:
-    if (!PyArg_Parse(args, "(Oil);ch or int,n,attr", &temp, &n, &attr))
+    if (!PyArg_ParseTuple(args, "Oil;ch or int,n,attr", &temp, &n, &attr))
       return NULL;
     break;
   case 4:
-    if (!PyArg_Parse(args, "(iiOi);y,x,ch or int,n", &y, &x, &temp, &n))
+    if (!PyArg_ParseTuple(args, "iiOi;y,x,ch or int,n", &y, &x, &temp, &n))
       return NULL;
     code = wmove(self->win, y, x);
     break;
   case 5:
-    if (!PyArg_Parse(args, "(iiOil); y,x,ch or int,n,attr", 
+    if (!PyArg_ParseTuple(args, "iiOil; y,x,ch or int,n,attr", 
 		     &y, &x, &temp, &n, &attr))
       return NULL;
     code = wmove(self->win, y, x);
@@ -1418,85 +1413,85 @@ PyCursesWindow_Vline(PyCursesWindowObject *self, PyObject *args)
 }
 
 static PyMethodDef PyCursesWindow_Methods[] = {
-	{"addch",           (PyCFunction)PyCursesWindow_AddCh},
-	{"addnstr",         (PyCFunction)PyCursesWindow_AddNStr},
-	{"addstr",          (PyCFunction)PyCursesWindow_AddStr},
-	{"attroff",         (PyCFunction)PyCursesWindow_wattroff},
-	{"attron",          (PyCFunction)PyCursesWindow_wattron},
-	{"attrset",         (PyCFunction)PyCursesWindow_wattrset},
-	{"bkgd",            (PyCFunction)PyCursesWindow_Bkgd},
-	{"bkgdset",         (PyCFunction)PyCursesWindow_BkgdSet},
+	{"addch",           (PyCFunction)PyCursesWindow_AddCh, METH_VARARGS},
+	{"addnstr",         (PyCFunction)PyCursesWindow_AddNStr, METH_VARARGS},
+	{"addstr",          (PyCFunction)PyCursesWindow_AddStr, METH_VARARGS},
+	{"attroff",         (PyCFunction)PyCursesWindow_wattroff, METH_VARARGS},
+	{"attron",          (PyCFunction)PyCursesWindow_wattron, METH_VARARGS},
+	{"attrset",         (PyCFunction)PyCursesWindow_wattrset, METH_VARARGS},
+	{"bkgd",            (PyCFunction)PyCursesWindow_Bkgd, METH_VARARGS},
+	{"bkgdset",         (PyCFunction)PyCursesWindow_BkgdSet, METH_VARARGS},
 	{"border",          (PyCFunction)PyCursesWindow_Border, METH_VARARGS},
-	{"box",             (PyCFunction)PyCursesWindow_Box},
-	{"clear",           (PyCFunction)PyCursesWindow_wclear},
-	{"clearok",         (PyCFunction)PyCursesWindow_clearok},
-	{"clrtobot",        (PyCFunction)PyCursesWindow_wclrtobot},
-	{"clrtoeol",        (PyCFunction)PyCursesWindow_wclrtoeol},
-	{"cursyncup",       (PyCFunction)PyCursesWindow_wcursyncup},
-	{"delch",           (PyCFunction)PyCursesWindow_DelCh},
-	{"deleteln",        (PyCFunction)PyCursesWindow_wdeleteln},
-	{"derwin",          (PyCFunction)PyCursesWindow_DerWin},
-	{"echochar",        (PyCFunction)PyCursesWindow_EchoChar},
+	{"box",             (PyCFunction)PyCursesWindow_Box, METH_VARARGS},
+	{"clear",           (PyCFunction)PyCursesWindow_wclear, METH_NOARGS},
+	{"clearok",         (PyCFunction)PyCursesWindow_clearok, METH_VARARGS},
+	{"clrtobot",        (PyCFunction)PyCursesWindow_wclrtobot, METH_NOARGS},
+	{"clrtoeol",        (PyCFunction)PyCursesWindow_wclrtoeol, METH_NOARGS},
+	{"cursyncup",       (PyCFunction)PyCursesWindow_wcursyncup, METH_NOARGS},
+	{"delch",           (PyCFunction)PyCursesWindow_DelCh, METH_VARARGS},
+	{"deleteln",        (PyCFunction)PyCursesWindow_wdeleteln, METH_NOARGS},
+	{"derwin",          (PyCFunction)PyCursesWindow_DerWin, METH_VARARGS},
+	{"echochar",        (PyCFunction)PyCursesWindow_EchoChar, METH_VARARGS},
 #ifdef NCURSES_MOUSE_VERSION
-	{"enclose",         (PyCFunction)PyCursesWindow_Enclose},
+	{"enclose",         (PyCFunction)PyCursesWindow_Enclose, METH_VARARGS},
 #endif
-	{"erase",           (PyCFunction)PyCursesWindow_werase},
-	{"getbegyx",        (PyCFunction)PyCursesWindow_getbegyx},
-	{"getbkgd",         (PyCFunction)PyCursesWindow_GetBkgd},
-	{"getch",           (PyCFunction)PyCursesWindow_GetCh},
-	{"getkey",          (PyCFunction)PyCursesWindow_GetKey},
-	{"getmaxyx",        (PyCFunction)PyCursesWindow_getmaxyx},
-	{"getparyx",        (PyCFunction)PyCursesWindow_getparyx},
-	{"getstr",          (PyCFunction)PyCursesWindow_GetStr},
-	{"getyx",           (PyCFunction)PyCursesWindow_getyx},
-	{"hline",           (PyCFunction)PyCursesWindow_Hline},
-	{"idcok",           (PyCFunction)PyCursesWindow_idcok},
-	{"idlok",           (PyCFunction)PyCursesWindow_idlok},
-	{"immedok",         (PyCFunction)PyCursesWindow_immedok},
-	{"inch",            (PyCFunction)PyCursesWindow_InCh},
-	{"insch",           (PyCFunction)PyCursesWindow_InsCh},
-	{"insdelln",        (PyCFunction)PyCursesWindow_winsdelln},
-	{"insertln",        (PyCFunction)PyCursesWindow_winsertln},
-	{"insnstr",         (PyCFunction)PyCursesWindow_InsNStr},
-	{"insstr",          (PyCFunction)PyCursesWindow_InsStr},
-	{"instr",           (PyCFunction)PyCursesWindow_InStr},
-	{"is_linetouched",  (PyCFunction)PyCursesWindow_Is_LineTouched},
-	{"is_wintouched",   (PyCFunction)PyCursesWindow_is_wintouched},
-	{"keypad",          (PyCFunction)PyCursesWindow_keypad},
-	{"leaveok",         (PyCFunction)PyCursesWindow_leaveok},
-	{"move",            (PyCFunction)PyCursesWindow_wmove},
-	{"mvderwin",        (PyCFunction)PyCursesWindow_mvderwin},
-	{"mvwin",           (PyCFunction)PyCursesWindow_mvwin},
-	{"nodelay",         (PyCFunction)PyCursesWindow_nodelay},
-	{"notimeout",       (PyCFunction)PyCursesWindow_notimeout},
-	{"noutrefresh",     (PyCFunction)PyCursesWindow_NoOutRefresh},
-        /* Backward compatibility alias -- remove in Python 2.1 */
-	{"nooutrefresh",    (PyCFunction)PyCursesWindow_NoOutRefresh},
+	{"erase",           (PyCFunction)PyCursesWindow_werase, METH_NOARGS},
+	{"getbegyx",        (PyCFunction)PyCursesWindow_getbegyx, METH_NOARGS},
+	{"getbkgd",         (PyCFunction)PyCursesWindow_GetBkgd, METH_NOARGS},
+	{"getch",           (PyCFunction)PyCursesWindow_GetCh, METH_VARARGS},
+	{"getkey",          (PyCFunction)PyCursesWindow_GetKey, METH_VARARGS},
+	{"getmaxyx",        (PyCFunction)PyCursesWindow_getmaxyx, METH_NOARGS},
+	{"getparyx",        (PyCFunction)PyCursesWindow_getparyx, METH_NOARGS},
+	{"getstr",          (PyCFunction)PyCursesWindow_GetStr, METH_VARARGS},
+	{"getyx",           (PyCFunction)PyCursesWindow_getyx, METH_NOARGS},
+	{"hline",           (PyCFunction)PyCursesWindow_Hline, METH_VARARGS},
+	{"idcok",           (PyCFunction)PyCursesWindow_idcok, METH_VARARGS},
+	{"idlok",           (PyCFunction)PyCursesWindow_idlok, METH_VARARGS},
+	{"immedok",         (PyCFunction)PyCursesWindow_immedok, METH_VARARGS},
+	{"inch",            (PyCFunction)PyCursesWindow_InCh, METH_VARARGS},
+	{"insch",           (PyCFunction)PyCursesWindow_InsCh, METH_VARARGS},
+	{"insdelln",        (PyCFunction)PyCursesWindow_winsdelln, METH_VARARGS},
+	{"insertln",        (PyCFunction)PyCursesWindow_winsertln, METH_NOARGS},
+	{"insnstr",         (PyCFunction)PyCursesWindow_InsNStr, METH_VARARGS},
+	{"insstr",          (PyCFunction)PyCursesWindow_InsStr, METH_VARARGS},
+	{"instr",           (PyCFunction)PyCursesWindow_InStr, METH_VARARGS},
+	{"is_linetouched",  (PyCFunction)PyCursesWindow_Is_LineTouched, METH_VARARGS},
+	{"is_wintouched",   (PyCFunction)PyCursesWindow_is_wintouched, METH_NOARGS},
+	{"keypad",          (PyCFunction)PyCursesWindow_keypad, METH_VARARGS},
+	{"leaveok",         (PyCFunction)PyCursesWindow_leaveok, METH_VARARGS},
+	{"move",            (PyCFunction)PyCursesWindow_wmove, METH_VARARGS},
+	{"mvderwin",        (PyCFunction)PyCursesWindow_mvderwin, METH_VARARGS},
+	{"mvwin",           (PyCFunction)PyCursesWindow_mvwin, METH_VARARGS},
+	{"nodelay",         (PyCFunction)PyCursesWindow_nodelay, METH_VARARGS},
+	{"notimeout",       (PyCFunction)PyCursesWindow_notimeout, METH_VARARGS},
+	{"noutrefresh",     (PyCFunction)PyCursesWindow_NoOutRefresh, METH_VARARGS},
+        /* Backward compatibility alias -- remove in Python 2.3 */
+	{"nooutrefresh",    (PyCFunction)PyCursesWindow_NoOutRefresh, METH_VARARGS},
 	{"overlay",         (PyCFunction)PyCursesWindow_Overlay, METH_VARARGS},
 	{"overwrite",       (PyCFunction)PyCursesWindow_Overwrite,
          METH_VARARGS},
-	{"putwin",          (PyCFunction)PyCursesWindow_PutWin},
+	{"putwin",          (PyCFunction)PyCursesWindow_PutWin, METH_VARARGS},
 	{"redrawln",        (PyCFunction)PyCursesWindow_RedrawLine},
-	{"redrawwin",       (PyCFunction)PyCursesWindow_redrawwin},
-	{"refresh",         (PyCFunction)PyCursesWindow_Refresh},
+	{"redrawwin",       (PyCFunction)PyCursesWindow_redrawwin, METH_NOARGS},
+	{"refresh",         (PyCFunction)PyCursesWindow_Refresh, METH_VARARGS},
 #ifndef STRICT_SYSV_CURSES
-	{"resize",          (PyCFunction)PyCursesWindow_wresize},
+	{"resize",          (PyCFunction)PyCursesWindow_wresize, METH_VARARGS},
 #endif
-	{"scroll",          (PyCFunction)PyCursesWindow_Scroll},
-	{"scrollok",        (PyCFunction)PyCursesWindow_scrollok},
-	{"setscrreg",       (PyCFunction)PyCursesWindow_SetScrollRegion},
-	{"standend",        (PyCFunction)PyCursesWindow_wstandend},
-	{"standout",        (PyCFunction)PyCursesWindow_wstandout},
-	{"subpad",          (PyCFunction)PyCursesWindow_SubWin},
-	{"subwin",          (PyCFunction)PyCursesWindow_SubWin},
-	{"syncdown",        (PyCFunction)PyCursesWindow_wsyncdown},
-	{"syncok",          (PyCFunction)PyCursesWindow_syncok},
-	{"syncup",          (PyCFunction)PyCursesWindow_wsyncup},
-	{"timeout",         (PyCFunction)PyCursesWindow_wtimeout},
-	{"touchline",       (PyCFunction)PyCursesWindow_TouchLine},
-	{"touchwin",        (PyCFunction)PyCursesWindow_touchwin},
-	{"untouchwin",      (PyCFunction)PyCursesWindow_untouchwin},
-	{"vline",           (PyCFunction)PyCursesWindow_Vline},
+	{"scroll",          (PyCFunction)PyCursesWindow_Scroll, METH_VARARGS},
+	{"scrollok",        (PyCFunction)PyCursesWindow_scrollok, METH_VARARGS},
+	{"setscrreg",       (PyCFunction)PyCursesWindow_SetScrollRegion, METH_VARARGS},
+	{"standend",        (PyCFunction)PyCursesWindow_wstandend, METH_NOARGS},
+	{"standout",        (PyCFunction)PyCursesWindow_wstandout, METH_NOARGS},
+	{"subpad",          (PyCFunction)PyCursesWindow_SubWin, METH_VARARGS},
+	{"subwin",          (PyCFunction)PyCursesWindow_SubWin, METH_VARARGS},
+	{"syncdown",        (PyCFunction)PyCursesWindow_wsyncdown, METH_NOARGS},
+	{"syncok",          (PyCFunction)PyCursesWindow_syncok, METH_VARARGS},
+	{"syncup",          (PyCFunction)PyCursesWindow_wsyncup, METH_NOARGS},
+	{"timeout",         (PyCFunction)PyCursesWindow_wtimeout, METH_VARARGS},
+	{"touchline",       (PyCFunction)PyCursesWindow_TouchLine, METH_VARARGS},
+	{"touchwin",        (PyCFunction)PyCursesWindow_touchwin, METH_NOARGS},
+	{"untouchwin",      (PyCFunction)PyCursesWindow_untouchwin, METH_NOARGS},
+	{"vline",           (PyCFunction)PyCursesWindow_Vline, METH_VARARGS},
 	{NULL,		    NULL}   /* sentinel */
 };
 
@@ -1574,13 +1569,7 @@ PyCurses_Color_Content(PyObject *self, PyObject *args)
   PyCursesInitialised
   PyCursesInitialisedColor
 
-  if (ARG_COUNT(args) != 1) {
-    PyErr_SetString(PyExc_TypeError, 
-		    "color_content requires 1 argument");
-    return NULL;
-  }
-
-  if (!PyArg_Parse(args, "h;color", &color)) return NULL;
+  if (!PyArg_ParseTuple(args, "h:color_content", &color)) return NULL;
 
   if (color_content(color, &r, &g, &b) != ERR)
     return Py_BuildValue("(iii)", r, g, b);
@@ -1599,11 +1588,7 @@ PyCurses_color_pair(PyObject *self, PyObject *args)
   PyCursesInitialised
   PyCursesInitialisedColor
 
-  if (ARG_COUNT(args) != 1) {
-    PyErr_SetString(PyExc_TypeError, "color_pair requires 1 argument");
-    return NULL;
-  }
-  if (!PyArg_Parse(args, "i;number", &n)) return NULL;
+  if (!PyArg_ParseTuple(args, "i:color_pair", &n)) return NULL;
   return PyInt_FromLong((long) (n << 8));
 }
 
@@ -1614,12 +1599,7 @@ PyCurses_Curs_Set(PyObject *self, PyObject *args)
 
   PyCursesInitialised
 
-  if (ARG_COUNT(args)!=1) {
-    PyErr_SetString(PyExc_TypeError, "curs_set requires 1 argument");
-    return NULL;
-  }
-
-  if (!PyArg_Parse(args, "i;int", &vis)) return NULL;
+  if (!PyArg_ParseTuple(args, "i:curs_set", &vis)) return NULL;
 
   erg = curs_set(vis);
   if (erg == ERR) return PyCursesCheckERR(erg, "curs_set");
@@ -1634,38 +1614,30 @@ PyCurses_Delay_Output(PyObject *self, PyObject *args)
 
   PyCursesInitialised
 
-  if (ARG_COUNT(args) != 1) {
-    PyErr_SetString(PyExc_TypeError, "delay_output requires 1 argument");
-    return NULL;
-  }
-  if (!PyArg_Parse(args, "i;ms", &ms)) return NULL;
+  if (!PyArg_ParseTuple(args, "i:delay_output", &ms)) return NULL;
 
   return PyCursesCheckERR(delay_output(ms), "delay_output");
 }
 
 static PyObject *
-PyCurses_EraseChar(PyObject *self, PyObject *args)
+PyCurses_EraseChar(PyObject *self)
 {
   char ch;
 
   PyCursesInitialised
 
-  if (!PyArg_NoArgs(args)) return NULL;
-
   ch = erasechar();
 
   return PyString_FromStringAndSize(&ch, 1);
 }
 
 static PyObject *
-PyCurses_getsyx(PyObject *self, PyObject *args)
+PyCurses_getsyx(PyObject *self)
 {
   int x,y;
 
   PyCursesInitialised
 
-  if (!PyArg_NoArgs(args)) return NULL;
-
   getsyx(y, x);
 
   return Py_BuildValue("(ii)", y, x);
@@ -1673,13 +1645,12 @@ PyCurses_getsyx(PyObject *self, PyObject *args)
 
 #ifdef NCURSES_MOUSE_VERSION
 static PyObject *
-PyCurses_GetMouse(PyObject *self, PyObject *args)
+PyCurses_GetMouse(PyObject *self)
 {
 	int rtn;
 	MEVENT event;
 
 	PyCursesInitialised
-	if (!PyArg_NoArgs(args)) return NULL;
 
 	rtn = getmouse( &event );
 	if (rtn == ERR) {
@@ -1709,15 +1680,12 @@ PyCurses_UngetMouse(PyObject *self, PyObject *args)
 #endif
 
 static PyObject *
-PyCurses_GetWin(PyCursesWindowObject *self, PyObject *args)
+PyCurses_GetWin(PyCursesWindowObject *self, PyObject *temp)
 {
   WINDOW *win;
-  PyObject *temp;
 
   PyCursesInitialised
 
-  if (!PyArg_Parse(args, "O;fileobj", &temp)) return NULL;
-
   if (!PyFile_Check(temp)) {
     PyErr_SetString(PyExc_TypeError, "argument must be a file object");
     return NULL;
@@ -1740,14 +1708,7 @@ PyCurses_HalfDelay(PyObject *self, PyObject *args)
 
   PyCursesInitialised
 
-  switch(ARG_COUNT(args)) {
-  case 1:
-    if (!PyArg_Parse(args, "b;tenths", &tenths)) return NULL;
-    break;
-  default:
-    PyErr_SetString(PyExc_TypeError, "halfdelay requires 1 argument");
-    return NULL;
-  }
+  if (!PyArg_ParseTuple(args, "b:halfdelay", &tenths)) return NULL;
 
   return PyCursesCheckERR(halfdelay(tenths), "halfdelay");
 }
@@ -1760,7 +1721,7 @@ static PyObject * PyCurses_has_key(PyObject *self, PyObject *args)
 
   PyCursesInitialised
 
-  if (!PyArg_Parse(args,"i",&ch)) return NULL;
+  if (!PyArg_ParseTuple(args,"i",&ch)) return NULL;
 
   if (has_key(ch) == FALSE) {
     Py_INCREF(Py_False);
@@ -1779,9 +1740,9 @@ PyCurses_Init_Color(PyObject *self, PyObject *args)
   PyCursesInitialised
   PyCursesInitialisedColor
 
-  switch(ARG_COUNT(args)) {
+  switch(PyTuple_Size(args)) {
   case 4:
-    if (!PyArg_Parse(args, "(hhhh);color,r,g,b", &color, &r, &g, &b)) return NULL;
+    if (!PyArg_ParseTuple(args, "hhhh;color,r,g,b", &color, &r, &g, &b)) return NULL;
     break;
   default:
     PyErr_SetString(PyExc_TypeError, "init_color requires 4 arguments");
@@ -1799,12 +1760,12 @@ PyCurses_Init_Pair(PyObject *self, PyObject *args)
   PyCursesInitialised
   PyCursesInitialisedColor
 
-  if (ARG_COUNT(args) != 3) {
+  if (PyTuple_Size(args) != 3) {
     PyErr_SetString(PyExc_TypeError, "init_pair requires 3 arguments");
     return NULL;
   }
 
-  if (!PyArg_Parse(args, "(hhh);pair, f, b", &pair, &f, &b)) return NULL;
+  if (!PyArg_ParseTuple(args, "hhh;pair, f, b", &pair, &f, &b)) return NULL;
 
   return PyCursesCheckERR(init_pair(pair, f, b), "init_pair");
 }
@@ -1812,13 +1773,11 @@ PyCurses_Init_Pair(PyObject *self, PyObject *args)
 static PyObject *ModDict;
 
 static PyObject * 
-PyCurses_InitScr(PyObject *self, PyObject *args)
+PyCurses_InitScr(PyObject *self)
 {
   WINDOW *win;
   PyObject *nlines, *cols;
 
-  if (!PyArg_NoArgs(args)) return NULL;
-
   if (initialised == TRUE) {
     wrefresh(stdscr);
     return (PyObject *)PyCursesWindow_New(stdscr);
@@ -1974,9 +1933,9 @@ PyCurses_IntrFlush(PyObject *self, PyObject *args)
 
   PyCursesInitialised
 
-  switch(ARG_COUNT(args)) {
+  switch(PyTuple_Size(args)) {
   case 1:
-    if (!PyArg_Parse(args,"i;True(1), False(0)",&ch)) return NULL;
+    if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&ch)) return NULL;
     break;
   default:
     PyErr_SetString(PyExc_TypeError, "intrflush requires 1 argument");
@@ -1995,7 +1954,7 @@ PyCurses_KeyName(PyObject *self, PyObject *args)
 
   PyCursesInitialised
 
-  if (!PyArg_Parse(args,"i",&ch)) return NULL;
+  if (!PyArg_ParseTuple(args,"i",&ch)) return NULL;
 
   knp = keyname(ch);
 
@@ -2004,12 +1963,10 @@ PyCurses_KeyName(PyObject *self, PyObject *args)
 #endif
 
 static PyObject *  
-PyCurses_KillChar(PyObject *self, PyObject *args)  
+PyCurses_KillChar(PyObject *self)  
 {  
   char ch;  
 
-  if (!PyArg_NoArgs(args)) return NULL;  
-
   ch = killchar();  
 
   return PyString_FromStringAndSize(&ch, 1);  
@@ -2022,9 +1979,9 @@ PyCurses_Meta(PyObject *self, PyObject *args)
 
   PyCursesInitialised
 
-  switch(ARG_COUNT(args)) {
+  switch(PyTuple_Size(args)) {
   case 1:
-    if (!PyArg_Parse(args,"i;True(1), False(0)",&ch)) return NULL;
+    if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&ch)) return NULL;
     break;
   default:
     PyErr_SetString(PyExc_TypeError, "meta requires 1 argument");
@@ -2041,7 +1998,7 @@ PyCurses_MouseInterval(PyObject *self, PyObject *args)
 	int interval;
 	PyCursesInitialised 
 
-	if (!PyArg_Parse(args,"i;interval",&interval)) 
+	if (!PyArg_ParseTuple(args,"i;interval",&interval)) 
 		return NULL;
 	return PyCursesCheckERR(mouseinterval(interval), "mouseinterval");
 }
@@ -2053,7 +2010,7 @@ PyCurses_MouseMask(PyObject *self, PyObject *args)
 	mmask_t oldmask, availmask;
 
 	PyCursesInitialised 
-	if (!PyArg_Parse(args,"i;mousemask",&newmask)) 
+	if (!PyArg_ParseTuple(args,"i;mousemask",&newmask)) 
 		return NULL;
 	availmask = mousemask(newmask, &oldmask);
 	return Py_BuildValue("(ll)", (long)availmask, (long)oldmask);
@@ -2066,7 +2023,7 @@ PyCurses_Napms(PyObject *self, PyObject *args)
     int ms;
 
     PyCursesInitialised
-    if (!PyArg_Parse(args, "i;ms", &ms)) return NULL;
+    if (!PyArg_ParseTuple(args, "i;ms", &ms)) return NULL;
 
     return Py_BuildValue("i", napms(ms));
 }
@@ -2080,7 +2037,7 @@ PyCurses_NewPad(PyObject *self, PyObject *args)
 
   PyCursesInitialised 
 
-  if (!PyArg_Parse(args,"(ii);nlines,ncols",&nlines,&ncols)) return NULL;
+  if (!PyArg_ParseTuple(args,"ii;nlines,ncols",&nlines,&ncols)) return NULL;
 
   win = newpad(nlines, ncols);
   
@@ -2100,13 +2057,13 @@ PyCurses_NewWindow(PyObject *self, PyObject *args)
 
   PyCursesInitialised
 
-  switch (ARG_COUNT(args)) {
+  switch (PyTuple_Size(args)) {
   case 2:
-    if (!PyArg_Parse(args,"(ii);nlines,ncols",&nlines,&ncols))
+    if (!PyArg_ParseTuple(args,"ii;nlines,ncols",&nlines,&ncols))
       return NULL;
     break;
   case 4:
-    if (!PyArg_Parse(args, "(iiii);nlines,ncols,begin_y,begin_x",
+    if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",
 		   &nlines,&ncols,&begin_y,&begin_x))
       return NULL;
     break;
@@ -2132,9 +2089,9 @@ PyCurses_Pair_Content(PyObject *self, PyObject *args)
   PyCursesInitialised
   PyCursesInitialisedColor
 
-  switch(ARG_COUNT(args)) {
+  switch(PyTuple_Size(args)) {
   case 1:
-    if (!PyArg_Parse(args, "h;pair", &pair)) return NULL;
+    if (!PyArg_ParseTuple(args, "h;pair", &pair)) return NULL;
     break;
   default:
     PyErr_SetString(PyExc_TypeError, "pair_content requires 1 argument");
@@ -2158,9 +2115,9 @@ PyCurses_pair_number(PyObject *self, PyObject *args)
   PyCursesInitialised
   PyCursesInitialisedColor
 
-  switch(ARG_COUNT(args)) {
+  switch(PyTuple_Size(args)) {
   case 1:
-    if (!PyArg_Parse(args, "i;pairvalue", &n)) return NULL;
+    if (!PyArg_ParseTuple(args, "i;pairvalue", &n)) return NULL;
     break;
   default:
     PyErr_SetString(PyExc_TypeError,
@@ -2176,7 +2133,7 @@ PyCurses_Putp(PyObject *self, PyObject *args)
 {
   char *str;
 
-  if (!PyArg_Parse(args,"s;str", &str)) return NULL;
+  if (!PyArg_ParseTuple(args,"s;str", &str)) return NULL;
   return PyCursesCheckERR(putp(str), "putp");
 }
 
@@ -2187,13 +2144,13 @@ PyCurses_QiFlush(PyObject *self, PyObject *args)
 
   PyCursesInitialised
 
-  switch(ARG_COUNT(args)) {
+  switch(PyTuple_Size(args)) {
   case 0:
     qiflush();
     Py_INCREF(Py_None);
     return Py_None;
   case 1:
-    if (!PyArg_Parse(args, "i;True(1) or False(0)", &flag)) return NULL;
+    if (!PyArg_ParseTuple(args, "i;True(1) or False(0)", &flag)) return NULL;
     if (flag) qiflush();
     else noqiflush();
     Py_INCREF(Py_None);
@@ -2211,12 +2168,12 @@ PyCurses_setsyx(PyObject *self, PyObject *args)
 
   PyCursesInitialised
 
-  if (ARG_COUNT(args)!=2) {
+  if (PyTuple_Size(args)!=2) {
     PyErr_SetString(PyExc_TypeError, "setsyx requires 2 arguments");
     return NULL;
   }
 
-  if (!PyArg_Parse(args, "(ii);y, x", &y, &x)) return NULL;
+  if (!PyArg_ParseTuple(args, "ii;y, x", &y, &x)) return NULL;
 
   setsyx(y,x);
 
@@ -2225,15 +2182,13 @@ PyCurses_setsyx(PyObject *self, PyObject *args)
 }
 
 static PyObject *
-PyCurses_Start_Color(PyObject *self, PyObject *args)
+PyCurses_Start_Color(PyObject *self)
 {
   int code;
   PyObject *c, *cp;
 
   PyCursesInitialised
 
-  if (!PyArg_NoArgs(args)) return NULL;
-
   code = start_color();
   if (code != ERR) {
     initialisedcolors = TRUE;
@@ -2362,7 +2317,7 @@ PyCurses_TypeAhead(PyObject *self, PyObject *args)
 
   PyCursesInitialised
 
-  if (!PyArg_Parse(args,"i;fd",&fd)) return NULL;
+  if (!PyArg_ParseTuple(args,"i;fd",&fd)) return NULL;
 
   PyCursesCheckERR(typeahead( fd ), "typeahead");
   Py_INCREF(Py_None);
@@ -2377,7 +2332,7 @@ PyCurses_UnCtrl(PyObject *self, PyObject *args)
 
   PyCursesInitialised
 
-  if (!PyArg_Parse(args,"O;ch or int",&temp)) return NULL;
+  if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;
 
   if (PyInt_Check(temp))
     ch = (chtype) PyInt_AsLong(temp);
@@ -2399,7 +2354,7 @@ PyCurses_UngetCh(PyObject *self, PyObject *args)
 
   PyCursesInitialised
 
-  if (!PyArg_Parse(args,"O;ch or int",&temp)) return NULL;
+  if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;
 
   if (PyInt_Check(temp))
     ch = (chtype) PyInt_AsLong(temp);
@@ -2420,9 +2375,9 @@ PyCurses_Use_Env(PyObject *self, PyObject *args)
 
   PyCursesInitialised
 
-  switch(ARG_COUNT(args)) {
+  switch(PyTuple_Size(args)) {
   case 1:
-    if (!PyArg_Parse(args,"i;True(1), False(0)",&flag))
+    if (!PyArg_ParseTuple(args,"i;True(1), False(0)",&flag))
       return NULL;
     break;
   default:
@@ -2437,83 +2392,83 @@ PyCurses_Use_Env(PyObject *self, PyObject *args)
 /* List of functions defined in the module */
 
 static PyMethodDef PyCurses_methods[] = {
-  {"baudrate",            (PyCFunction)PyCurses_baudrate},
-  {"beep",                (PyCFunction)PyCurses_beep},
-  {"can_change_color",    (PyCFunction)PyCurses_can_change_color},
-  {"cbreak",              (PyCFunction)PyCurses_cbreak},
-  {"color_content",       (PyCFunction)PyCurses_Color_Content},
-  {"color_pair",          (PyCFunction)PyCurses_color_pair},
-  {"curs_set",            (PyCFunction)PyCurses_Curs_Set},
-  {"def_prog_mode",       (PyCFunction)PyCurses_def_prog_mode},
-  {"def_shell_mode",      (PyCFunction)PyCurses_def_shell_mode},
-  {"delay_output",        (PyCFunction)PyCurses_Delay_Output},
-  {"doupdate",            (PyCFunction)PyCurses_doupdate},
-  {"echo",                (PyCFunction)PyCurses_echo},
-  {"endwin",              (PyCFunction)PyCurses_endwin},
-  {"erasechar",           (PyCFunction)PyCurses_EraseChar},
-  {"filter",              (PyCFunction)PyCurses_filter},
-  {"flash",               (PyCFunction)PyCurses_flash},
-  {"flushinp",            (PyCFunction)PyCurses_flushinp},
+  {"baudrate",            (PyCFunction)PyCurses_baudrate, METH_NOARGS},
+  {"beep",                (PyCFunction)PyCurses_beep, METH_NOARGS},
+  {"can_change_color",    (PyCFunction)PyCurses_can_change_color, METH_NOARGS},
+  {"cbreak",              (PyCFunction)PyCurses_cbreak, METH_VARARGS},
+  {"color_content",       (PyCFunction)PyCurses_Color_Content, METH_VARARGS},
+  {"color_pair",          (PyCFunction)PyCurses_color_pair, METH_VARARGS},
+  {"curs_set",            (PyCFunction)PyCurses_Curs_Set, METH_VARARGS},
+  {"def_prog_mode",       (PyCFunction)PyCurses_def_prog_mode, METH_NOARGS},
+  {"def_shell_mode",      (PyCFunction)PyCurses_def_shell_mode, METH_NOARGS},
+  {"delay_output",        (PyCFunction)PyCurses_Delay_Output, METH_VARARGS},
+  {"doupdate",            (PyCFunction)PyCurses_doupdate, METH_NOARGS},
+  {"echo",                (PyCFunction)PyCurses_echo, METH_VARARGS},
+  {"endwin",              (PyCFunction)PyCurses_endwin, METH_NOARGS},
+  {"erasechar",           (PyCFunction)PyCurses_EraseChar, METH_NOARGS},
+  {"filter",              (PyCFunction)PyCurses_filter, METH_NOARGS},
+  {"flash",               (PyCFunction)PyCurses_flash, METH_NOARGS},
+  {"flushinp",            (PyCFunction)PyCurses_flushinp, METH_NOARGS},
 #ifdef NCURSES_MOUSE_VERSION
-  {"getmouse",            (PyCFunction)PyCurses_GetMouse},
+  {"getmouse",            (PyCFunction)PyCurses_GetMouse, METH_NOARGS},
   {"ungetmouse",          (PyCFunction)PyCurses_UngetMouse, METH_VARARGS},
 #endif
-  {"getsyx",              (PyCFunction)PyCurses_getsyx},
-  {"getwin",              (PyCFunction)PyCurses_GetWin},
-  {"has_colors",          (PyCFunction)PyCurses_has_colors},
-  {"has_ic",              (PyCFunction)PyCurses_has_ic},
-  {"has_il",              (PyCFunction)PyCurses_has_il},
+  {"getsyx",              (PyCFunction)PyCurses_getsyx, METH_NOARGS},
+  {"getwin",              (PyCFunction)PyCurses_GetWin, METH_O},
+  {"has_colors",          (PyCFunction)PyCurses_has_colors, METH_NOARGS},
+  {"has_ic",              (PyCFunction)PyCurses_has_ic, METH_NOARGS},
+  {"has_il",              (PyCFunction)PyCurses_has_il, METH_NOARGS},
 #ifndef STRICT_SYSV_CURSES
-  {"has_key",             (PyCFunction)PyCurses_has_key},
+  {"has_key",             (PyCFunction)PyCurses_has_key, METH_VARARGS},
 #endif
-  {"halfdelay",           (PyCFunction)PyCurses_HalfDelay},
-  {"init_color",          (PyCFunction)PyCurses_Init_Color},
-  {"init_pair",           (PyCFunction)PyCurses_Init_Pair},
-  {"initscr",             (PyCFunction)PyCurses_InitScr},
-  {"intrflush",           (PyCFunction)PyCurses_IntrFlush},
-  {"isendwin",            (PyCFunction)PyCurses_isendwin},
+  {"halfdelay",           (PyCFunction)PyCurses_HalfDelay, METH_VARARGS},
+  {"init_color",          (PyCFunction)PyCurses_Init_Color, METH_VARARGS},
+  {"init_pair",           (PyCFunction)PyCurses_Init_Pair, METH_VARARGS},
+  {"initscr",             (PyCFunction)PyCurses_InitScr, METH_NOARGS},
+  {"intrflush",           (PyCFunction)PyCurses_IntrFlush, METH_VARARGS},
+  {"isendwin",            (PyCFunction)PyCurses_isendwin, METH_NOARGS},
 #if !defined(__NetBSD__)
-  {"keyname",             (PyCFunction)PyCurses_KeyName},
+  {"keyname",             (PyCFunction)PyCurses_KeyName, METH_VARARGS},
 #endif
-  {"killchar",            (PyCFunction)PyCurses_KillChar}, 
-  {"longname",            (PyCFunction)PyCurses_longname}, 
-  {"meta",                (PyCFunction)PyCurses_Meta},
+  {"killchar",            (PyCFunction)PyCurses_KillChar, METH_NOARGS}, 
+  {"longname",            (PyCFunction)PyCurses_longname, METH_NOARGS}, 
+  {"meta",                (PyCFunction)PyCurses_Meta, METH_VARARGS},
 #ifdef NCURSES_MOUSE_VERSION
-  {"mouseinterval",       (PyCFunction)PyCurses_MouseInterval},
-  {"mousemask",           (PyCFunction)PyCurses_MouseMask},
+  {"mouseinterval",       (PyCFunction)PyCurses_MouseInterval, METH_VARARGS},
+  {"mousemask",           (PyCFunction)PyCurses_MouseMask, METH_VARARGS},
 #endif
-  {"napms",               (PyCFunction)PyCurses_Napms},
-  {"newpad",              (PyCFunction)PyCurses_NewPad},
-  {"newwin",              (PyCFunction)PyCurses_NewWindow},
-  {"nl",                  (PyCFunction)PyCurses_nl},
-  {"nocbreak",            (PyCFunction)PyCurses_nocbreak},
-  {"noecho",              (PyCFunction)PyCurses_noecho},
-  {"nonl",                (PyCFunction)PyCurses_nonl},
-  {"noqiflush",           (PyCFunction)PyCurses_noqiflush},
-  {"noraw",               (PyCFunction)PyCurses_noraw},
-  {"pair_content",        (PyCFunction)PyCurses_Pair_Content},
-  {"pair_number",         (PyCFunction)PyCurses_pair_number},
-  {"putp",                (PyCFunction)PyCurses_Putp},
-  {"qiflush",             (PyCFunction)PyCurses_QiFlush},
-  {"raw",                 (PyCFunction)PyCurses_raw},
-  {"reset_prog_mode",     (PyCFunction)PyCurses_reset_prog_mode},
-  {"reset_shell_mode",    (PyCFunction)PyCurses_reset_shell_mode},
-  {"resetty",             (PyCFunction)PyCurses_resetty},
-  {"savetty",             (PyCFunction)PyCurses_savetty},
-  {"setsyx",              (PyCFunction)PyCurses_setsyx},
+  {"napms",               (PyCFunction)PyCurses_Napms, METH_VARARGS},
+  {"newpad",              (PyCFunction)PyCurses_NewPad, METH_VARARGS},
+  {"newwin",              (PyCFunction)PyCurses_NewWindow, METH_VARARGS},
+  {"nl",                  (PyCFunction)PyCurses_nl, METH_VARARGS},
+  {"nocbreak",            (PyCFunction)PyCurses_nocbreak, METH_NOARGS},
+  {"noecho",              (PyCFunction)PyCurses_noecho, METH_NOARGS},
+  {"nonl",                (PyCFunction)PyCurses_nonl, METH_NOARGS},
+  {"noqiflush",           (PyCFunction)PyCurses_noqiflush, METH_NOARGS},
+  {"noraw",               (PyCFunction)PyCurses_noraw, METH_NOARGS},
+  {"pair_content",        (PyCFunction)PyCurses_Pair_Content, METH_VARARGS},
+  {"pair_number",         (PyCFunction)PyCurses_pair_number, METH_VARARGS},
+  {"putp",                (PyCFunction)PyCurses_Putp, METH_VARARGS},
+  {"qiflush",             (PyCFunction)PyCurses_QiFlush, METH_VARARGS},
+  {"raw",                 (PyCFunction)PyCurses_raw, METH_VARARGS},
+  {"reset_prog_mode",     (PyCFunction)PyCurses_reset_prog_mode, METH_NOARGS},
+  {"reset_shell_mode",    (PyCFunction)PyCurses_reset_shell_mode, METH_NOARGS},
+  {"resetty",             (PyCFunction)PyCurses_resetty, METH_NOARGS},
+  {"savetty",             (PyCFunction)PyCurses_savetty, METH_NOARGS},
+  {"setsyx",              (PyCFunction)PyCurses_setsyx, METH_VARARGS},
   {"setupterm",           (PyCFunction)PyCurses_setupterm,
    METH_VARARGS|METH_KEYWORDS},
-  {"start_color",         (PyCFunction)PyCurses_Start_Color},
-  {"termattrs",           (PyCFunction)PyCurses_termattrs},
-  {"termname",            (PyCFunction)PyCurses_termname},
+  {"start_color",         (PyCFunction)PyCurses_Start_Color, METH_NOARGS},
+  {"termattrs",           (PyCFunction)PyCurses_termattrs, METH_NOARGS},
+  {"termname",            (PyCFunction)PyCurses_termname, METH_NOARGS},
   {"tigetflag",		  (PyCFunction)PyCurses_tigetflag, METH_VARARGS},
   {"tigetnum",		  (PyCFunction)PyCurses_tigetnum, METH_VARARGS},
   {"tigetstr",		  (PyCFunction)PyCurses_tigetstr, METH_VARARGS},
   {"tparm",               (PyCFunction)PyCurses_tparm, METH_VARARGS},
-  {"typeahead",           (PyCFunction)PyCurses_TypeAhead},
-  {"unctrl",              (PyCFunction)PyCurses_UnCtrl},
-  {"ungetch",             (PyCFunction)PyCurses_UngetCh},
-  {"use_env",             (PyCFunction)PyCurses_Use_Env},
+  {"typeahead",           (PyCFunction)PyCurses_TypeAhead, METH_VARARGS},
+  {"unctrl",              (PyCFunction)PyCurses_UnCtrl, METH_VARARGS},
+  {"ungetch",             (PyCFunction)PyCurses_UngetCh, METH_VARARGS},
+  {"use_env",             (PyCFunction)PyCurses_Use_Env, METH_VARARGS},
   {NULL,		  NULL}		/* sentinel */
 };