diff options
| -rw-r--r-- | devel/py-kjbuckets/Makefile | 10 | ||||
| -rw-r--r-- | devel/py-kjbuckets/files/patch-aa | 4 | ||||
| -rw-r--r-- | devel/py-kjbuckets/files/patch-ab | 2333 | ||||
| -rw-r--r-- | devel/py-kjbuckets/pkg-plist | 4 | ||||
| -rw-r--r-- | x11-toolkits/py-gtk/Makefile | 6 | ||||
| -rw-r--r-- | x11-toolkits/py-gtk/pkg-plist | 66 | ||||
| -rw-r--r-- | x11-toolkits/py-gtk2/Makefile | 6 | ||||
| -rw-r--r-- | x11-toolkits/py-gtk2/pkg-plist | 66 |
8 files changed, 2399 insertions, 96 deletions
diff --git a/devel/py-kjbuckets/Makefile b/devel/py-kjbuckets/Makefile index d69e12232331..876e906848af 100644 --- a/devel/py-kjbuckets/Makefile +++ b/devel/py-kjbuckets/Makefile @@ -14,16 +14,14 @@ DISTNAME= kjb MAINTAINER= nectar@FreeBSD.org -BUILD_DEPENDS= python1.5:${PORTSDIR}/lang/python15 -RUN_DEPENDS= python1.5:${PORTSDIR}/lang/python15 - +USE_PYTHON= yes NO_WRKSUBDIR= yes +MAKE_ENV= PYTHON_VERSION=${PYTHON_VERSION} MAKEFILE= makefile do-install: - ${MKDIR} ${PREFIX}/lib/python1.5/site-packages - ${INSTALL_DATA} ${WRKSRC}/kjbucketsmodule.so \ - ${PREFIX}/lib/python1.5/site-packages/ + ${MKDIR} ${PYTHON_SITELIBDIR} + ${INSTALL_DATA} ${WRKSRC}/kjbucketsmodule.so ${PYTHON_SITELIBDIR} .if !defined(NOPORTDOCS) ${INSTALL_DATA} ${WRKSRC}/kjbuckets.html ${PREFIX}/share/doc/ .endif diff --git a/devel/py-kjbuckets/files/patch-aa b/devel/py-kjbuckets/files/patch-aa index 9739c96790ce..158f49a0c731 100644 --- a/devel/py-kjbuckets/files/patch-aa +++ b/devel/py-kjbuckets/files/patch-aa @@ -13,8 +13,8 @@ -srcdir= /usr/local/include/python1.4 -cfgdir= /usr/local/lib/python1.4/config -#objdir= /big/arw/Python-1.3/Objects -+srcdir= ${PREFIX}/include/python1.5 -+cfgdir= ${PREFIX}/lib/python1.5/config ++srcdir= ${PREFIX}/include/${PYTHON_VERSION} ++cfgdir= ${PREFIX}/lib/${PYTHON_VERSION}/config # Compiler flags -OPT= -g diff --git a/devel/py-kjbuckets/files/patch-ab b/devel/py-kjbuckets/files/patch-ab index 58197ca68b1d..9c914a4e2e79 100644 --- a/devel/py-kjbuckets/files/patch-ab +++ b/devel/py-kjbuckets/files/patch-ab @@ -1,6 +1,14 @@ ---- kjbucketsmodule.c.orig Thu Jun 26 09:06:40 1997 -+++ kjbucketsmodule.c Sat Mar 27 20:27:50 1999 -@@ -157,7 +157,7 @@ +--- kjbucketsmodule.c.orig Thu Jun 26 16:06:40 1997 ++++ kjbucketsmodule.c Wed Sep 13 19:45:45 2000 +@@ -90,7 +90,6 @@ + /* include a bunch of stuff */ + + #include "Python.h" +-#include "rename2.h" + /* #include "allobjects.h" */ + /* #include "modsupport.h" */ + /* #include "ceval.h" */ +@@ -157,7 +156,7 @@ ( (tp->entries * RESIZEFACTOR) < (tp->size * GSIZE) ) ) /* group states */ @@ -9,7 +17,230 @@ /* bucket behaviors, smaller is less general! */ enum BucketFlag { SETFLAG=0, DICTFLAG=1, GRAPHFLAG=2 }; -@@ -607,7 +607,7 @@ +@@ -172,11 +171,11 @@ + + #ifdef CACHE_HASH + #define GETHASH(hashvalue, object) \ +- if (!is_stringobject(object) || \ +- (hashvalue = ((stringobject *) object)->ob_shash) == -1)\ +- hashvalue = hashobject(object) ++ if (!PyString_Check(object) || \ ++ (hashvalue = ((PyStringObject *) object)->ob_shash) == -1)\ ++ hashvalue = PyObject_Hash(object) + #else +-#define GETHASH(hashvalue, object) hashvalue = hashobject(object) ++#define GETHASH(hashvalue, object) hashvalue = PyObject_Hash(object) + #endif + + /*********************************************************/ +@@ -185,14 +184,14 @@ + /* set bucket structure */ + typedef struct { + long hash; +- object * member; ++ PyObject * member; + } SetBucket; + + /* graph and dict bucket structure */ + typedef struct { + long hash; +- object * member; +- object * map; ++ PyObject * member; ++ PyObject * map; + } DiBucket; + + /* for passing general buckets around, with external flags */ +@@ -203,7 +202,7 @@ + + /* destructuring a bucket (macroized) */ + #define BPtrDestructure(/*Bucketptr*/ Bp, /*enum BucketFlag*/ flag,\ +- /*long*/ hp, /*object*/ memp, /*object*/ mapp)\ ++ /*long*/ hp, /*PyObject*/ memp, /*PyObject*/ mapp)\ + {\ + switch (flag) {\ + case SETFLAG:\ +@@ -225,17 +224,17 @@ + static long BPtrDump(Bucketptr Bp, enum BucketFlag flag, FILE *fp) + { + long h; +- object *mem, *map; ++ PyObject *mem, *map; + BPtrDestructure(Bp, flag, h, mem, map); + fprintf(fp, "Bkt[%ld, ",h); + if (mem == 0) { fprintf(fp, "NULL"); } + /*else { +- if (printobject(mem, fp, 0) != 0) { return -1; } ++ if (PyObject_Print(mem, fp, 0) != 0) { return -1; } + }*/ + fprintf(fp, "%ld, ",mem); + if (map == 0) { fprintf(fp, "NULL"); } + /*else { +- if (printobject(map, fp, 0) != 0) { return -1; } ++ if (PyObject_Print(map, fp, 0) != 0) { return -1; } + }*/ + fprintf(fp, "%ld] ",map); + return 0; +@@ -243,13 +242,13 @@ + #endif + + /* setting a bucket +- INCREFs handled here. ++ Py_INCREFs handled here. + assumes initial contents are null or garbage. (macroized) + */ + /* static long */ + #define BPtrSet( \ + /* Bucketptr */ Bp, /* enum BucketFlag */ flag,\ +- /* long */ h, /* object * */mem1, /* object * */map1)\ ++ /* long */ h, /* PyObject * */mem1, /* PyObject * */map1)\ + {\ + switch(flag) {\ + case SETFLAG:\ +@@ -257,15 +256,15 @@ + /* ignore map */\ + Bp.SBucketp->hash = h;\ + Bp.SBucketp->member = mem1;\ +- if (mem1 != 0) { XINCREF (mem1); }\ ++ if (mem1 != 0) { Py_XINCREF (mem1); }\ + break;\ + case DICTFLAG:\ + case GRAPHFLAG:\ + Bp.DBucketp->hash = h;\ + Bp.DBucketp->member = mem1;\ +- if (mem1 != 0) { XINCREF (mem1); }\ ++ if (mem1 != 0) { Py_XINCREF (mem1); }\ + Bp.DBucketp->map = map1;\ +- if (map1 != 0) { XINCREF (map1); }\ ++ if (map1 != 0) { Py_XINCREF (map1); }\ + break;\ + }\ + } +@@ -275,13 +274,13 @@ + */ + /*static long BPtrInit( Bucketptr Bp, enum BucketFlag flag ) + { +- object *dummy; ++ PyObject *dummy; + dummy = 0; + BPtrSet( Bp, flag, NOHASH, dummy, dummy ); + }*/ + + /* re-initialization assuming valid value +- DECREFs handled here. ++ Py_DECREFs handled here. + to save values in the bucket for use after reinitialization, + incref them first and decref after... + (macroized) +@@ -290,11 +289,11 @@ + #define BPtrReInit( /*Bucketptr*/ Bp, /*enum BucketFlag*/ flag )\ + {\ + long hashBBB;\ +- object *MemberBBB, *MapBBB, *dummyBBB;\ ++ PyObject *MemberBBB, *MapBBB, *dummyBBB;\ + BPtrDestructure( Bp, flag, hashBBB, MemberBBB, MapBBB );\ +- if ( MemberBBB != 0 ) { XDECREF(MemberBBB); }\ ++ if ( MemberBBB != 0 ) { Py_XDECREF(MemberBBB); }\ + /* don't decref map for sets!! */\ +- if ( (MapBBB != 0) && (flag != SETFLAG) ) { XDECREF(MapBBB); }\ ++ if ( (MapBBB != 0) && (flag != SETFLAG) ) { Py_XDECREF(MapBBB); }\ + dummyBBB = 0;\ + BPtrSet( Bp, flag, NOHASH, dummyBBB, dummyBBB );\ + } +@@ -308,14 +307,14 @@ + /*Bucketptr*/ Bp, \ + /*enum BucketFlag*/ flag,\ + /*long*/ h, \ +- /*object * */ Mm, \ +- /*object * */ Mp, \ ++ /*PyObject * */ Mm, \ ++ /*PyObject * */ Mp, \ + /*enum ForceFlag*/ Force,\ + /*long * */ newflag, \ + /*long * */ dirtyflag) \ + {\ + long hashAAA;\ +- object *MemberAAA, *MapAAA, *dummyAAA;\ ++ PyObject *MemberAAA, *MapAAA, *dummyAAA;\ + newflag = 0; /* default assumption */\ + result = 0; /* default: fail */\ + BPtrDestructure( Bp, flag, hashAAA, MemberAAA, MapAAA );\ +@@ -336,7 +335,7 @@ + if (h == NOHASH)\ + { result = 1; } /* bucket full, hash null == null match */\ + else { /* fully defined match */\ +- if ((h == hashAAA) && (cmpobject(Mm, MemberAAA)==0))\ ++ if ((h == hashAAA) && (PyObject_Compare(Mm, MemberAAA)==0))\ + { result = 1; } /* hash defined, all eq == match */\ + }\ + }\ +@@ -349,12 +348,12 @@ + /* Forced match succeeds if bucket is empty or members match */\ + if ((Force == FORCE) &&\ + ( (hashAAA == NOHASH) || \ +- ((h == hashAAA)&&(cmpobject(Mm, MemberAAA)==0)) ) ) {\ ++ ((h == hashAAA)&&(PyObject_Compare(Mm, MemberAAA)==0)) ) ) {\ + if ((Mm == 0) || (Mp == 0)) { result = -1; } /* error */\ + else {\ + if (hashAAA == NOHASH) { newflag = 1; } /* new if old was empty */\ + else {\ +- if (cmpobject(MapAAA,Mp)!=0) { /* overwriting: dirty */\ ++ if (PyObject_Compare(MapAAA,Mp)!=0) { /* overwriting: dirty */\ + dirtyflag = 1;\ + }\ + }\ +@@ -364,8 +363,8 @@ + }\ + } else {\ + if ( (h!=NOHASH) && (h==hashAAA) &&\ +- (Mm != 0) && (cmpobject(Mm, MemberAAA)==0) &&\ +- ( ( Mp == 0 ) || (cmpobject(MapAAA,Mp)==0) ) )\ ++ (Mm != 0) && (PyObject_Compare(Mm, MemberAAA)==0) &&\ ++ ( ( Mp == 0 ) || (PyObject_Compare(MapAAA,Mp)==0) ) )\ + { result = 1; } /* successful unforced match */\ + }\ + }\ +@@ -390,8 +389,8 @@ + } else {\ + /* unforced match, can match if Mm is null */\ + if (( hashAAA != NOHASH ) && ( hashAAA == h ) &&\ +- (Mm != 0) && ( cmpobject(Mm,MemberAAA)==0 ) && \ +- ( (Mp == 0) || ( cmpobject(MapAAA,Mp)==0 ))) {\ ++ (Mm != 0) && ( PyObject_Compare(Mm,MemberAAA)==0 ) && \ ++ ( (Mp == 0) || ( PyObject_Compare(MapAAA,Mp)==0 ))) {\ + Dprint(("graph unforced match\n")); \ + result = 1; /* successful unforced match */\ + }\ +@@ -483,7 +482,7 @@ + /*Groupptr*/ Eg, /*enum BucketFlag*/ Eflag)\ + {\ + long Eh;\ +- object *EMm, *EMp;\ ++ PyObject *EMm, *EMp;\ + Bucketptr EBp;\ + GetBucket(EBp, Eg, Eflag, 0);\ + BPtrDestructure(EBp, Eflag, Eh, EMm, EMp);\ +@@ -498,7 +497,7 @@ + #define Groupinit(/*Groupptr*/ Dg, /*enum BucketFlag*/ Dflag)\ + {\ + Bucketptr DBp;\ +- object *Ddummy;\ ++ PyObject *Ddummy;\ + long Di;\ + Ddummy = 0;\ + for (Di=0; Di<GSIZE; Di++) {\ +@@ -551,8 +550,8 @@ + /* Groupptr */ g, \ + /* enum BucketFlag */ flag,\ + /* long */ hash1, \ +- /* object * */ Member1, \ +- /* object * */ Map1, \ ++ /* PyObject * */ Member1, \ ++ /* PyObject * */ Map1, \ + /* enum ForceFlag */ Force, \ + /* long */ StartAfter,\ + /* long * */ index, /* use literal */\ +@@ -607,7 +606,7 @@ Nextptr = &(SGptr->mem.free.Next);\ break;\ case ROOT:\ @@ -18,7 +249,7 @@ case UNKNOWN:\ templateptr.sbp = &(SGptr->mem.group);\ Nextptr = &(SGptr->mem.group.Next);\ -@@ -623,7 +623,7 @@ +@@ -623,7 +622,7 @@ Nextptr = &(DGptr->mem.free.Next);\ break;\ case ROOT:\ @@ -27,7 +258,7 @@ case UNKNOWN:\ templateptr.dbp = &(DGptr->mem.group);\ Nextptr = &(DGptr->mem.group.Next);\ -@@ -739,7 +739,7 @@ +@@ -739,7 +738,7 @@ GArrayRef(Jarray,Jflag,Jprevious, Jgprev, JPrevState, JNextOfPrev);\ GArrayRef(Jarray,Jflag,Jtoindex, Jgother, JOtherState, JNextOfOther);\ *JNextOfOther = *JNext;\ @@ -36,7 +267,21 @@ GroupCopy(Jgother, Jg, Jflag);\ *JNextOfPrev = Jtoindex;\ Groupinit(Jg, Jflag);\ -@@ -879,7 +879,7 @@ +@@ -822,11 +821,11 @@ + (DiGroup *) calloc(sizeof(DiGroup), size); + break; + default: +- err_setstr(SystemError, "invalid internal table behavior flag"); ++ PyErr_SetString(PyExc_SystemError, "invalid internal table behavior flag"); + return 0; /* error */ + } + if (groups.Dgroups == NULL) { +- err_nomem(); ++ PyErr_NoMemory(); + return 0; /* error */ + } + /* initialize all states to unknown */ +@@ -879,7 +878,7 @@ fprintf(fp, "ROOT(next=%ld)",*Next); if (GroupDump(g,flag,fp)!=0) { return -1; } break; @@ -45,7 +290,7 @@ fprintf(fp, "OVFLW(next=%ld)",*Next); if (GroupDump(g,flag,fp)!=0) { return -1; } break; -@@ -903,7 +903,7 @@ +@@ -903,7 +902,7 @@ for (i=0; i<size; i++) { Dprint(("greinit at %ld\n",i)); GArrayRef(g, flag, i, groupp, State, d); @@ -54,7 +299,43 @@ for (j=0; j<GSIZE; j++) { GetBucket(Bp,groupp,flag,j); BPtrReInit(Bp, flag); -@@ -1056,7 +1056,7 @@ +@@ -921,7 +920,7 @@ + /* reinitialize all buckets */ + groupsReinit(g, flag, size); + /* now delete the array */ +- DEL(g.Sgroups); ++ PyMem_DEL(g.Sgroups); + } + + /* unfreeing a group in the Table *assumed free with garbage contents* */ +@@ -1001,7 +1000,7 @@ + */ + /* crazy idea: macroize this monster, and use stub only for recursive + calls... */ +-static long tableMatch( Table *tp, object *member1, object *map1, ++static long tableMatch( Table *tp, PyObject *member1, PyObject *map1, + enum ForceFlag Force, + long rootgroupI, long lastgroupI, long lastbucketI, long hsh, + /*outputs*/ long *rtgrp, long *nxtgrp, long *nxtbkt, Bucketptr *Bp, +@@ -1021,7 +1020,7 @@ + + /* sanity checks (comment out later?) */ + if ( (member1 == 0) && ( (rootgroupI < 0) || (Force == FORCE) ) ) { +- err_setstr(SystemError, "bug in kjbuckets implementation (tableMatch)"); ++ PyErr_SetString(PyExc_SystemError, "bug in kjbuckets implementation (tableMatch)"); + return -1; + } + +@@ -1036,7 +1035,7 @@ + /*if (tp->Free != -1) { + GArrayRef(groups, flag, tp->Free, root, state, rNext); + if (*state != FREE) { +- err_setstr(SystemError, "free index not free in table"); ++ PyErr_SetString(PyExc_SystemError, "free index not free in table"); + return -1; + } + }*/ +@@ -1056,7 +1055,7 @@ /* lastgroup and lastbucket must be none */ lastgroupI = lastbucketI = -1; /* otherwise must force an insert, need root group... */ @@ -63,7 +344,25 @@ /* swap out the overflow group */ Dprint(("root is overflow %ld\n",rootgroupI)); if (tp->Free == -1) { -@@ -1130,7 +1130,7 @@ +@@ -1076,7 +1075,7 @@ + Dprint(("unfreeing rootgroup %ld\n", rootgroupI)); + UnFreeTableIndex(rootgroupI, tp, rootgroupI); + } else { +- err_setstr(SystemError, "bad rootgroup state in tablematch"); ++ PyErr_SetString(PyExc_SystemError, "bad rootgroup state in tablematch"); + return -1; /* error */ + } + } +@@ -1107,7 +1106,7 @@ + if (found != 0) { + Dprint(("tm: found = %ld\n",found)); + if (found<0) { +- err_setstr(SystemError, "groupmatch abnormal return"); ++ PyErr_SetString(PyExc_SystemError, "groupmatch abnormal return"); + return -1; + } + if (*isnew != 0) { tp->entries++; } +@@ -1130,13 +1129,13 @@ } UnFreeTableIndex(AvailableI, tp, tp->Free); GArrayRef(groups, flag, AvailableI, avail, availState, availNext); @@ -72,7 +371,69 @@ *availNext = rootgroupI; *Next = AvailableI; groupmatch(found, avail,flag,hsh,member1,map1, -@@ -1235,7 +1235,7 @@ + Force, -1, (*nxtbkt), (*Bp), (*isnew), (*dirtyptr)); + if (found<0) { +- err_setstr(SystemError, "groupmatch abnormal return"); ++ PyErr_SetString(PyExc_SystemError, "groupmatch abnormal return"); + return -1; + } + *nxtgrp = AvailableI; +@@ -1149,16 +1148,16 @@ + /* some simple uses of table matching */ + + /* find (or set) a matching pair */ +-static long TableGet1( Table *tp, object *member1, object *map1, long hash, ++static long TableGet1( Table *tp, PyObject *member1, PyObject *map1, long hash, + enum ForceFlag Force, +- object **memout, object **mapout) ++ PyObject **memout, PyObject **mapout) + { + long hashout; + long rt, nxt, nxtb, isnew, found; + Bucketptr Bp; + enum BucketFlag flag = tp->flag; + if (member1 == NULL) { +- err_setstr(SystemError, "TableGet1 called with NULL??"); ++ PyErr_SetString(PyExc_SystemError, "TableGet1 called with NULL??"); + return -1; + } + Dprint(("tg1: calling tablematch\n")); +@@ -1167,7 +1166,7 @@ + &rt, &nxt, &nxtb, &Bp, &hashout, &isnew); + if (found == -1) { return -1; } + if (found == 0) { +- err_setval(KeyError, member1); ++ PyErr_SetObject(PyExc_KeyError, member1); + return -1; + } + BPtrDestructure(Bp, flag, hashout, *memout, *mapout); +@@ -1178,7 +1177,7 @@ + /* could macroize */ + long ReInsertGroup( Groupptr g, enum BucketFlag flag, Table *tp) + { +- object *Member, *Map; ++ PyObject *Member, *Map; + long i, rt, nxt, nxtb, isnew, test; + long hash, h; + Bucketptr Bp, Bpdummy; +@@ -1189,7 +1188,7 @@ + test = tableMatch(tp, Member, Map, FORCE, -1, -1, -1, hash, + &rt, &nxt, &nxtb, &Bpdummy, &h, &isnew); + if (test != 1) { +- err_setstr(SystemError, "unable to resize table"); ++ PyErr_SetString(PyExc_SystemError, "unable to resize table"); + return 0; + } + } +@@ -1228,14 +1227,14 @@ + if (*State != FREE) { + Dprint(("free ptr %ld corrupted in resize/alloc, State=%ld not %ld\n",\ + tp->Free,*State,FREE)); +- err_setstr(SystemError, "resize fail (1)"); ++ PyErr_SetString(PyExc_SystemError, "resize fail (1)"); + return 0; + } + }*/ /* now reinsert all former contents */ for (i=0; i<size; i++) { GArrayRef(oldgroups, flag, i, g, State, Next); @@ -81,7 +442,94 @@ if (ReInsertGroup(g, flag, tp) == 0) { success = 0; break; -@@ -1401,7 +1401,7 @@ +@@ -1247,7 +1246,7 @@ + Dprint((\ + "free ptr %ld corrupted in resize/reinsert %ld, State=%ld not %ld\n",\ + tp->Free,i,*State,FREE)); +- err_setstr(SystemError, "resize fail (2)"); ++ PyErr_SetString(PyExc_SystemError, "resize fail (2)"); + return 0; + }*/ + } +@@ -1261,7 +1260,7 @@ + if (*State != FREE) { + Dprint(("free ptr %ld corrupted in resize, State=%ld not %ld\n",tp->Free,\ + *State,FREE)); +- err_setstr(SystemError, "resize fail (3)"); ++ PyErr_SetString(PyExc_SystemError, "resize fail (3)"); + return 0; + }*/ + if (success==0) Dprint(("failing in tableresize\n")); +@@ -1269,9 +1268,9 @@ + } + + /* deleting a member from a group, deletes *all* matching members */ +-long deleteFromTable(Table *tp, object *member1, object *map1) ++long deleteFromTable(Table *tp, PyObject *member1, PyObject *map1) + { +- object *M, *Mp; ++ PyObject *M, *Mp; + enum BucketFlag flag = tp->flag; + GroupArray groups = tp->groups; + long hash, bhash; +@@ -1286,7 +1285,7 @@ + &rtgrp, &nxtgrp, &nxtbkt, &Bp, &hash, &isnew); + if (found == -1) { return 0; } /* external error */ + if (found == 0) { +- err_setval(KeyError, member1); ++ PyErr_SetObject(PyExc_KeyError, member1); + return 0; + } + /* mark the table as dirty */ +@@ -1310,20 +1309,20 @@ + while (found) { + BPtrDestructure(Bp, flag, hash, M, Mp); + tp->entries--; +- /* !!! NOTE: since BPtrReInit DECREFs the contents, must +- INCREF contents here to prevent deallocation of the ++ /* !!! NOTE: since BPtrReInit Py_DECREFs the contents, must ++ Py_INCREF contents here to prevent deallocation of the + members and decref after reinstallation in the table + !!! (kinda subtle python thing!) !!! */ +- XINCREF(M); +- XINCREF(Mp); ++ Py_XINCREF(M); ++ Py_XINCREF(Mp); + BPtrReInit(Bp,flag); + bfound = tableMatch(tp, M, Mp, + FORCE, brt, bnxtgrp, bnxtbkt, hash, + &brt, &bnxtgrp, &bnxtbkt, &bBp, &bhash, &bisnew); +- XDECREF(M); +- XDECREF(Mp); ++ Py_XDECREF(M); ++ Py_XDECREF(Mp); + if (found != 1) { +- err_setstr(SystemError, "?? cannot backfill on delete"); ++ PyErr_SetString(PyExc_SystemError, "?? cannot backfill on delete"); + return 0; + } + found = tableMatch(tp, 0, 0, +@@ -1370,8 +1369,8 @@ + long root; + long lastgroup; + long lastbucket; +- object *key; +- object *map; ++ PyObject *key; ++ PyObject *map; + long hash; + } TableWalker; + +@@ -1386,7 +1385,7 @@ + enum BucketFlag flag; + enum GState *State; + long *Next, size, found, isnew, dirtyptr; +- object *dummy; ++ PyObject *dummy; + Table *tp = twp->tp; + size = tp->size; + flag = tp->flag; +@@ -1401,7 +1400,7 @@ found = 0; do { GArrayRef(tp->groups, flag, twp->lastgroup, g, State, Next); @@ -90,3 +538,1864 @@ dummy = 0; groupmatch(found, g, flag, NOHASH, dummy, dummy, NOFORCE,\ (twp->lastbucket), (twp->lastbucket), \ +@@ -1438,7 +1437,7 @@ + static long Nextbykey(TableWalker *twp) + { + Bucketptr Bp; +- object *dummyk; ++ PyObject *dummyk; + long dummyh; + long isnew; + Dprint(("Nextbykey\n")); +@@ -1454,7 +1453,7 @@ + } + + /* could macroize */ +-static void Initbykey(TableWalker *twp, Table *tp, object *key, long hash) ++static void Initbykey(TableWalker *twp, Table *tp, PyObject *key, long hash) + { + Dprint(("Initbykey\n")); + twp->tp = tp; +@@ -1475,7 +1474,7 @@ + { + long test; + TableWalker tw; +- object *d1, *d2; ++ PyObject *d1, *d2; + /* walk through the source */ + (void) InitAll(&tw, source); + while (tw.valid == 1) { +@@ -1496,11 +1495,11 @@ + { + long test; + TableWalker tw; +- object *d1, *d2; ++ PyObject *d1, *d2; + enum BucketFlag tflag = target->flag; + /* source flag cannot be set */ + if (source->flag == SETFLAG) { +- err_setstr(TypeError, "Cannot transpose set"); ++ PyErr_SetString(PyExc_TypeError, "Cannot transpose set"); + return -1; /* error return */ + } + /* walk through the source */ +@@ -1535,7 +1534,7 @@ + long prelim) + { + TableWalker lwalker, rwalker; +- object *d1, *d2; ++ PyObject *d1, *d2; + long test, count, exclude, rt, nxt, nxtb, isnew; + Bucketptr Bp; + long hashout; +@@ -1592,7 +1591,7 @@ + long test, rt, nxt, nxtb, isnew, found, count; + Bucketptr Bp; + TableWalker tw; +- object *d1, *d2; ++ PyObject *d1, *d2; + /* walk through left */ + (void) InitAll(&tw, left); + count = 0; +@@ -1622,7 +1621,7 @@ + return 1 if found, else 0 (-1 on error). + */ + static long Tmindiff(Table *left, Table *right, +- object **mem, object **map, long *hash) ++ PyObject **mem, PyObject **map, long *hash) + { + long hashout; + long gotit, rt, nxt, nxtb, isnew, found, cmp; +@@ -1646,9 +1645,9 @@ + gotit = 1; + } else { + cmp = *hash - tw.hash; +- if (cmp == 0) { cmp = cmpobject( tw.key, *mem ); } ++ if (cmp == 0) { cmp = PyObject_Compare( tw.key, *mem ); } + if ((cmp>0) || +- ((cmp==0) && (tw.map!=0) && (cmpobject( tw.map, *map )>0))) { ++ ((cmp==0) && (tw.map!=0) && (PyObject_Compare( tw.map, *map )>0))) { + *mem = tw.key; + *map = tw.map; + *hash = tw.hash; +@@ -1683,7 +1682,7 @@ + /* general structure for all table behaviors */ + + typedef struct { +- OB_VARHEAD ++ PyObject_VAR_HEAD + /* the hash flag */ + /* IF THIS IS NOT NOHASH THE TABLE SHOULD BE IMMUTABLE */ + long hashvalue; +@@ -1692,9 +1691,9 @@ + } TableWrapper; + + /* predeclarations of type objects */ +-staticforward typeobject kjSettype; +-staticforward typeobject kjDicttype; +-staticforward typeobject kjGraphtype; ++staticforward PyTypeObject kjSettype; ++staticforward PyTypeObject kjDicttype; ++staticforward PyTypeObject kjGraphtype; + + /* type test macros */ + #define is_kjSetobject(op) ((op)->ob_type == &kjSettype) +@@ -1710,14 +1709,14 @@ + if (in->rep.Dirty!=0) out->rep.Dirty = 1 + + /* internal allocation function for table wrappers */ +-static object * newWrapper(long expectedsize, enum BucketFlag flag) ++static PyObject * newWrapper(long expectedsize, enum BucketFlag flag) + { + /* allocate one wrapper */ + TableWrapper *wp; + Dprint(("WnewWrapper\n")); +- wp = NEW(TableWrapper, 1); ++ wp = PyMem_NEW(TableWrapper, 1); + if (wp == NULL) { +- return err_nomem(); /* allocation failure */ ++ return PyErr_NoMemory(); /* allocation failure */ + } + switch (flag) { + case SETFLAG: +@@ -1727,28 +1726,28 @@ + case GRAPHFLAG: + wp->ob_type = &kjGraphtype; break; + default: +- err_setstr(SystemError, "invalid internal table flag"); ++ PyErr_SetString(PyExc_SystemError, "invalid internal table flag"); + return NULL; + } + /* initialize the internal table */ + if (initTable(&(wp->rep), flag, expectedsize) == 0) { + /* initialization failed, assume an appropriate error is set */ +- DEL(wp); ++ PyMem_DEL(wp); + return NULL; + } + Dprint(("WnewWrapper: table initialized\n")); + wp->hashvalue = NOHASH; + /* INITIALIZE THE REFERENCE COUNT FOR THE NEW OBJECT */ +- NEWREF(wp); +- return (object *) wp; ++ _Py_NewReference(wp); ++ return (PyObject *) wp; + } + + /* *almost* an external python constructor for wrappers */ +-static object * makeWrapper(object *module, object *args, ++static PyObject * makeWrapper(PyObject *module, PyObject *args, + enum BucketFlag flag) + { + TableWrapper *result, *initWrapper; +- object *initlist, *pair, *key, *map, *d1, *d2; ++ PyObject *initlist, *pair, *key, *map, *d1, *d2; + long len, members, valid, index, islist, iskjtable, istuple; + Table *tp; + islist = 0; +@@ -1761,15 +1760,15 @@ + if (args == NULL) { + members = 0; + } else { /* some args: check it and determine its length */ +- valid = getargs(args, "i", &members); ++ valid = PyArg_Parse(args, "i", &members); + if (!valid) { +- err_clear(); +- valid = getargs(args, "O", &initlist); ++ PyErr_Clear(); ++ valid = PyArg_Parse(args, "O", &initlist); + if (valid) { +- islist = is_listobject(initlist); ++ islist = PyList_Check(initlist); + if (islist) { + Dprint(("makeWrapper from list\n")); +- len = getlistsize(initlist); ++ len = PyList_Size(initlist); + } else { + iskjtable = is_kjTable(initlist); + if (iskjtable) { +@@ -1777,10 +1776,10 @@ + initWrapper = (TableWrapper *) initlist; + len = initWrapper->rep.entries; + } else { +- istuple = is_tupleobject(initlist); ++ istuple = PyTuple_Check(initlist); + if (istuple) { + Dprint(("makeWrapper from tuple\n")); +- len = gettuplesize(initlist); ++ len = PyTuple_Size(initlist); + } else { + valid = 0; + } +@@ -1788,7 +1787,7 @@ + } + } + if (!valid) { +- err_setstr(TypeError, ++ PyErr_SetString(PyExc_TypeError, + "initializer must be integer or list or tuple or kj-Table"); + return NULL; + } +@@ -1806,24 +1805,24 @@ + tp = &(result->rep); + for (index = 0; index<len; index++) { + if ( islist ) { +- pair = getlistitem(initlist, index); ++ pair = PyList_GetItem(initlist, index); + } else { +- pair = gettupleitem(initlist, index); ++ pair = PyTuple_GetItem(initlist, index); + } + if (flag == SETFLAG) { + valid = TableGet1(tp, pair, 0, NOHASH, FORCE, &d1, &d2); + if (valid == -1) { +- DECREF(result); ++ Py_DECREF(result); + return NULL; + } + } else { +- if (!getargs(pair, "(OO)", &key, &map)) { +- DECREF(result); ++ if (!PyArg_Parse(pair, "(OO)", &key, &map)) { ++ Py_DECREF(result); + return NULL; + } + valid = TableGet1(tp, key, map, NOHASH, FORCE, &d1, &d2); + if (valid == -1) { +- DECREF(result); ++ Py_DECREF(result); + return NULL; + } + } +@@ -1833,39 +1832,39 @@ + /* initWrapper = (TableWrapper *) initlist; already done... */ + valid = Taugment( &(result->rep), &(initWrapper->rep) ); + if (valid!=0) { +- DECREF(result); ++ Py_DECREF(result); + return NULL; + } + } + } +- return (object *) result; ++ return (PyObject *) result; + } + + /* specialization for sets */ +-static object * makekjSet(object *module, object *args) ++static PyObject * makekjSet(PyObject *module, PyObject *args) + { + return makeWrapper(module, args, SETFLAG); + } + + /* specialization for graphs */ +-static object * makekjGraph(object *module, object *args) ++static PyObject * makekjGraph(PyObject *module, PyObject *args) + { + return makeWrapper(module, args, GRAPHFLAG); + } + + /* specialization for dicts */ +-static object * makekjDict(object *module, object *args) ++static PyObject * makekjDict(PyObject *module, PyObject *args) + { + return makeWrapper(module, args, DICTFLAG); + } + + #ifdef KJBDEBUG +-static object * Wdebug( object *m, object *a) ++static PyObject * Wdebug( PyObject *m, PyObject *a) + { + if (DebugLevel) { DebugLevel = 0; } + else { DebugLevel = 1; } +- INCREF(None); +- return None; ++ Py_INCREF(Py_None); ++ return Py_None; + } + #endif + +@@ -1873,7 +1872,7 @@ + { + /* must properly decref references... */ + groupsDealloc( wp->rep.groups, wp->rep.flag, wp->rep.size ); +- DEL(wp); ++ PyMem_DEL(wp); + } + + /* hash value: symmetrical on members, a symmetrical within pairs */ +@@ -1898,7 +1897,7 @@ + to keep this of "fix" it. Hmmm. */ + if ( (flag != SETFLAG) &&(tw.map != 0)) { + GETHASH(that,tw.map); +- if (that == -1) { err_clear(); } ++ if (that == -1) { PyErr_Clear(); } + this += (that*23); + } + result ^= this; +@@ -1910,18 +1909,18 @@ + return result; + } + +-static object * WrapperItems1(TableWrapper *wp, object *args, ++static PyObject * WrapperItems1(TableWrapper *wp, PyObject *args, + long dokey, long domap) + { +- object *resultlist, *membertuple; ++ PyObject *resultlist, *membertuple; + TableWalker tw; + long index, entries; + Dprint(("WItems1\n")); + +- if (!getnoarg(args)) { return NULL; } /* error */ ++ if (!PyArg_Parse(args, "")) { return NULL; } /* error */ + entries = wp->rep.entries; + /* make a list for all entries */ +- resultlist = newlistobject( entries ); ++ resultlist = PyList_New( entries ); + if (resultlist == NULL) { return NULL; } /* error */ + /* walk through the table */ + (void) InitAll(&tw, &(wp->rep)); +@@ -1929,44 +1928,44 @@ + while (tw.valid == 1) { + /* sanity check */ + if (index >= entries) { +- DECREF(resultlist); +- err_setstr(SystemError, "loop overflowing in WrapperItems"); ++ Py_DECREF(resultlist); ++ PyErr_SetString(PyExc_SystemError, "loop overflowing in WrapperItems"); + return NULL; /* error */ + } + /* get only the key, if requested */ + if ((dokey != 0) && (domap == 0)) { +- XINCREF(tw.key); +- setlistitem(resultlist, index, tw.key); ++ Py_XINCREF(tw.key); ++ PyList_SetItem(resultlist, index, tw.key); + } else { + /* get only the map, if requested */ + if ((domap != 0) && (dokey == 0)) { +- XINCREF(tw.map); +- setlistitem(resultlist, index, tw.map); ++ Py_XINCREF(tw.map); ++ PyList_SetItem(resultlist, index, tw.map); + } else { + /* otherwise get both */ +- membertuple = newtupleobject(2); ++ membertuple = PyTuple_New(2); + if (membertuple == NULL) { +- DECREF(resultlist); ++ Py_DECREF(resultlist); + return NULL; /* error */ + } +- XINCREF(tw.key); +- settupleitem(membertuple, 0, tw.key); +- XINCREF(tw.map); +- settupleitem(membertuple, 1, tw.map); +- setlistitem(resultlist, index, membertuple); ++ Py_XINCREF(tw.key); ++ PyTuple_SetItem(membertuple, 0, tw.key); ++ Py_XINCREF(tw.map); ++ PyTuple_SetItem(membertuple, 1, tw.map); ++ PyList_SetItem(resultlist, index, membertuple); + } + } + index++; + (void) NextAll(&tw); + } + if (tw.valid == -1) { +- DECREF(resultlist); ++ Py_DECREF(resultlist); + return NULL; /* error */ + } + return resultlist; + } + +-static object * WrapperItems(TableWrapper *wp, object *args) ++static PyObject * WrapperItems(TableWrapper *wp, PyObject *args) + { + Dprint(("WItems\n")); + if (wp->rep.flag == SETFLAG) { +@@ -1981,7 +1980,7 @@ + /* prlong function with debug option */ + static long WrapperPrint(TableWrapper *wp, FILE *fp, long flags) + { +- object * items; ++ PyObject * items; + #ifdef WDEBUGPRINT + if (WDEBUGPRINT) { + return TableDump((wp->rep), fp); +@@ -2002,15 +2001,15 @@ + fprintf(fp, "??couldn't allocate items??\n"); + return -1; + } +- if (printobject(items, fp, 0) != 0) { return -1; } +- DECREF(items); ++ if (PyObject_Print(items, fp, 0) != 0) { return -1; } ++ Py_DECREF(items); + fprintf(fp, ")"); + return 0; + } + +-static object* WrapperRepr(TableWrapper *wp) ++static PyObject* WrapperRepr(TableWrapper *wp) + { +- object *items, *result, *itemstring; ++ PyObject *items, *result, *itemstring; + char buf[256]; + switch (wp->rep.flag) { + case SETFLAG: +@@ -2020,18 +2019,18 @@ + case GRAPHFLAG: + sprintf(buf, "kjGraph("); break; + default: +- err_setstr(SystemError, "Bad flag in table"); ++ PyErr_SetString(PyExc_SystemError, "Bad flag in table"); + return NULL; + } +- result = newstringobject(buf); ++ result = PyString_FromString(buf); + items = WrapperItems(wp, NULL); + if (items == NULL) { + return NULL; + } +- itemstring = reprobject(items); +- DECREF(items); +- joinstring_decref(&result, itemstring); +- joinstring_decref(&result, newstringobject(")")); ++ itemstring = PyObject_Repr(items); ++ Py_DECREF(items); ++ PyString_ConcatAndDel(&result, itemstring); ++ PyString_ConcatAndDel(&result, PyString_FromString(")")); + return result; + } + +@@ -2053,7 +2052,7 @@ + */ + static long Wcompare(TableWrapper *left, TableWrapper *right) + { +- object *lmem, *lmap, *rmem, *rmap; ++ PyObject *lmem, *lmap, *rmem, *rmap; + long lhash, rhash; + long lentries, rentries, lfound, rfound, cmp; + Table *ltable, *rtable; +@@ -2078,54 +2077,54 @@ + if ((lfound == 0) && (rfound == 0)) { return 0; } + /* otherwise compare min differences */ + cmp = lhash - rhash; +- if (cmp == 0) { cmp = cmpobject( lmem, rmem ); } ++ if (cmp == 0) { cmp = PyObject_Compare( lmem, rmem ); } + if (cmp < 0) { return -1; } + if (cmp > 0) { return 1; } + /* mems are identical, try maps */ + if ( (lmap != 0) && (rmap != 0) ) { + /* if we get this far the following shouldn't return 0, ever. */ +- return cmpobject(lmap,rmap); ++ return PyObject_Compare(lmap,rmap); + } + /* this should be an error, but it can't be done?? */ + return 0; + } + + +-static object * Whas_key(TableWrapper *wp, object *args) ++static PyObject * Whas_key(TableWrapper *wp, PyObject *args) + { + long test, rt, nxt, nxtb, isnew; + long hashout; + Bucketptr Bp; +- object *key; ++ PyObject *key; + Dprint(("Whas_key\n")); +- if ((args == NULL) || !getargs(args, "O", &key)) { +- err_setstr(TypeError, "table method has_key requires an argument"); ++ if ((args == NULL) || !PyArg_Parse(args, "O", &key)) { ++ PyErr_SetString(PyExc_TypeError, "table method has_key requires an argument"); + return NULL; + } + test = tableMatch(&(wp->rep), key, 0, NOFORCE, + -1, -1, -1, NOHASH, + &rt, &nxt, &nxtb, &Bp, &hashout, &isnew); + if (test == -1) { return NULL; } /* error */ +- return newintobject((long) test); ++ return PyInt_FromLong((long) test); + } + + /* + Get the neighbors of a node in a graph. + */ +-static object *Gneighbors(TableWrapper *wp, object *args) ++static PyObject *Gneighbors(TableWrapper *wp, PyObject *args) + { +- object *key, *resultlist; ++ PyObject *key, *resultlist; + Table *tp; + TableWalker tw; + long count, index; + Dprint(("Gneighbors\n")); +- if ((args == NULL) || !getargs(args, "O", &key)) { +- err_setstr(TypeError, "table method neighbors requires an argument"); ++ if ((args == NULL) || !PyArg_Parse(args, "O", &key)) { ++ PyErr_SetString(PyExc_TypeError, "table method neighbors requires an argument"); + return NULL; + } + tp = &(wp->rep); + if ( tp->flag == SETFLAG ) { +- err_setstr(TypeError, "neighbors not defined for table of this type"); ++ PyErr_SetString(PyExc_TypeError, "neighbors not defined for table of this type"); + return NULL; + } + /* find out how many neighbors there are */ +@@ -2139,7 +2138,7 @@ + if (tw.valid == -1) { return NULL; } /* error */ + /* make a list large enough */ + Dprint(("Gneighbors: making resultlist\n")); +- resultlist = newlistobject( count ); ++ resultlist = PyList_New( count ); + if (resultlist == NULL) { return NULL; } /* failure to allocate */ + /* record neighbors in list */ + (void) Initbykey(&tw, tp, key, NOHASH); +@@ -2147,17 +2146,17 @@ + Dprint(("Gneighbors: storing results\n")); + while (tw.valid == 1) { + if (index >= count) { +- DECREF(resultlist); +- err_setstr(SystemError, "loop overflow in neighbors calculation"); ++ Py_DECREF(resultlist); ++ PyErr_SetString(PyExc_SystemError, "loop overflow in neighbors calculation"); + return NULL; + } +- XINCREF(tw.map); +- setlistitem(resultlist, index, tw.map); ++ Py_XINCREF(tw.map); ++ PyList_SetItem(resultlist, index, tw.map); + index++; + (void) Nextbykey(&tw); + } + if (tw.valid == -1) { +- DECREF(resultlist); ++ Py_DECREF(resultlist); + return NULL; + } + return resultlist; +@@ -2167,18 +2166,18 @@ + if domaps is set this will get maps uniquely *only if + all maps are hashable!* + */ +-static object *Wparts(TableWrapper *wp, object *args, long domaps) ++static PyObject *Wparts(TableWrapper *wp, PyObject *args, long domaps) + { + TableWalker tw; + Table *tp, *Settp; + TableWrapper *tempSet; +- object *mem, *map, *items; ++ PyObject *mem, *map, *items; + long test; + Dprint(("Wparts\n")); +- if (!getnoarg(args)) { return NULL; } /* error */ ++ if (!PyArg_Parse(args, "")) { return NULL; } /* error */ + tp = &(wp->rep); + if (tp->flag == SETFLAG) { +- err_setstr(TypeError, "keys/values not defined for sets"); ++ PyErr_SetString(PyExc_TypeError, "keys/values not defined for sets"); + return NULL; + } + /* initialize a temp set to hold the keys */ +@@ -2198,21 +2197,21 @@ + (void) NextAll(&tw); + } + if ((test == -1) || (tw.valid == -1)) { +- XDECREF(tempSet); ++ Py_XDECREF(tempSet); + return NULL; + } + items = WrapperItems(tempSet, NULL); +- XDECREF(tempSet); ++ Py_XDECREF(tempSet); + return items; + } + +-static object *Wkeys(TableWrapper *wp, object *args) ++static PyObject *Wkeys(TableWrapper *wp, PyObject *args) + { + Dprint(("Wkeys\n")); + return Wparts(wp, args, 0); + } + +-static object *Wvalues(TableWrapper *wp, object *args) ++static PyObject *Wvalues(TableWrapper *wp, PyObject *args) + { + Dprint(("Wvalues\n")); + /* return Wparts(wp, args, 1); -- wrong! */ +@@ -2220,25 +2219,25 @@ + } + + /* choose an arbitrary key from the table or raise an indexerror if none */ +-static object *Wchoose_key(TableWrapper *wp, object *args) ++static PyObject *Wchoose_key(TableWrapper *wp, PyObject *args) + { + TableWalker tw; + Dprint(("Wchoose_key\n")); +- if (!getnoarg(args)) { return NULL; } /* error */ ++ if (!PyArg_Parse(args, "")) { return NULL; } /* error */ + (void) InitAll(&tw, &(wp->rep)); + if (tw.valid == 1) { +- XINCREF(tw.key); ++ Py_XINCREF(tw.key); + return tw.key; + } + if (tw.valid == 0) { +- err_setstr(IndexError, "table is empty"); ++ PyErr_SetString(PyExc_IndexError, "table is empty"); + return NULL; + } + /* external error otherwise (tw.valid == -1) */ + return NULL; + } + +-static object *WSubset(TableWrapper *subset, object *args) ++static PyObject *WSubset(TableWrapper *subset, PyObject *args) + { + TableWrapper *superset; + long hashout; +@@ -2249,12 +2248,12 @@ + Dprint(("WSubset\n")); + /* verify argument */ + if (args == NULL) { +- err_setstr(TypeError, "Subset test requires argument"); ++ PyErr_SetString(PyExc_TypeError, "Subset test requires argument"); + return NULL; + } +- if (!getargs(args, "O", &superset)) { return NULL; } ++ if (!PyArg_Parse(args, "O", &superset)) { return NULL; } + if ( !is_kjTable(superset)) { +- err_setstr(TypeError, "Subset defined only between kj-tables"); ++ PyErr_SetString(PyExc_TypeError, "Subset defined only between kj-tables"); + return NULL; + } + /* walk through subset, test for membership of all members */ +@@ -2267,18 +2266,18 @@ + if (found == -1) { return NULL; } /* error */ + if (found == 0) { + /* subset test fails */ +- return newintobject((long) 0); ++ return PyInt_FromLong((long) 0); + } + (void) NextAll(&tw); + } + if (tw.valid == -1) { return NULL; } /* error */ + /* otherwise, success */ +- return newintobject((long) 1); ++ return PyInt_FromLong((long) 1); + } + + /* transitive closure of a graph */ + /* algorithm could be made faster, KISS for now. */ +-static object *Wtransclose(TableWrapper *wp, object *args) ++static PyObject *Wtransclose(TableWrapper *wp, PyObject *args) + { + Table *source, *target, Delta; + TableWrapper *closure; +@@ -2286,11 +2285,11 @@ + long count, test, abort; + + Dprint(("Wtransclose\n")); +- if (!getnoarg(args)) { return NULL; } /* error */ ++ if (!PyArg_Parse(args, "")) { return NULL; } /* error */ + source = &(wp->rep); + flag = source->flag; + if (flag != GRAPHFLAG) { +- err_setstr(TypeError, ++ PyErr_SetString(PyExc_TypeError, + "transitive closure not defined for this table type"); + return NULL; + } +@@ -2303,7 +2302,7 @@ + Dprint(("tc: augmenting closure\n")); + test = Taugment( target, source ); + if (test != 0) { +- DECREF(closure); ++ Py_DECREF(closure); + return NULL; + } + /* initialize temp table Delta for transitive arcs */ +@@ -2330,27 +2329,27 @@ + Dprint(("tc: deallocating Delta\n")); + groupsDealloc(Delta.groups, flag, Delta.size); + if (abort != 0) { +- DECREF(closure); ++ Py_DECREF(closure); + return NULL; + } +- return (object *) closure; ++ return (PyObject *) closure; + } + + static void Wset_hash_error() + { +- err_setstr(TypeError, "table has been hashed, it is now immutable"); ++ PyErr_SetString(PyExc_TypeError, "table has been hashed, it is now immutable"); + } + +-static object * Wdelete_arc(TableWrapper *wp, object *args) ++static PyObject * Wdelete_arc(TableWrapper *wp, PyObject *args) + { +- object *key, *map; ++ PyObject *key, *map; + Dprint(("Wdelete_arc\n")); +- if ((args == NULL) || !getargs(args, "(OO)", &key, &map)) { +- err_setstr(TypeError, "delete_arc requires two arguments"); ++ if ((args == NULL) || !PyArg_Parse(args, "(OO)", &key, &map)) { ++ PyErr_SetString(PyExc_TypeError, "delete_arc requires two arguments"); + return NULL; + } + if (wp->rep.flag == SETFLAG) { +- err_setstr(TypeError, "delete_arc not defined on sets"); ++ PyErr_SetString(PyExc_TypeError, "delete_arc not defined on sets"); + return NULL; + } + if (wp->hashvalue != NOHASH) { +@@ -2358,14 +2357,14 @@ + return NULL; + } + if (deleteFromTable(&(wp->rep), key, map) == 0) { return NULL; } +- INCREF(None); +- return None; ++ Py_INCREF(Py_None); ++ return Py_None; + } + + /* simple membership test */ +-static object * Wmember1(TableWrapper *wp, object *args, long insert) ++static PyObject * Wmember1(TableWrapper *wp, PyObject *args, long insert) + { +- object *key, *map; ++ PyObject *key, *map; + Table *tp; + enum BucketFlag flag; + long hashout; +@@ -2376,7 +2375,7 @@ + flag = tp->flag; + /* determine key and map */ + if (args == NULL) { +- err_setstr(TypeError, "membership test requires argument(s)"); ++ PyErr_SetString(PyExc_TypeError, "membership test requires argument(s)"); + return NULL; + } + if ((insert!=0) & (wp->hashvalue!=NOHASH)) { +@@ -2384,48 +2383,48 @@ + return NULL; + } + if (flag == SETFLAG) { +- if (!getargs(args, "O", &key)) { return NULL; } ++ if (!PyArg_Parse(args, "O", &key)) { return NULL; } + map = 0; + } else { +- if (!getargs(args, "(OO)", &key, &map)) { return NULL; } ++ if (!PyArg_Parse(args, "(OO)", &key, &map)) { return NULL; } + } + if (insert == 0) { + found = tableMatch(tp, key, map, NOFORCE, + -1, -1, -1, NOHASH, + &rt, &nxt, &nxtb, &Bp, &hashout, &isnew); +- return newintobject((long) found); ++ return PyInt_FromLong((long) found); + } else { + found = TableGet1(tp, key, map, NOHASH, FORCE, &key, &map); + if (found == -1) { return NULL; } +- INCREF(None); +- return None; ++ Py_INCREF(Py_None); ++ return Py_None; + } + } + +-static object * Wmember(TableWrapper *wp, object *args) ++static PyObject * Wmember(TableWrapper *wp, PyObject *args) + { + Dprint(("Wmember\n")); + return Wmember1(wp, args, 0); + } + +-static object * Waddmember(TableWrapper *wp, object *args) ++static PyObject * Waddmember(TableWrapper *wp, PyObject *args) + { + Dprint(("Waddmember\n")); + return Wmember1(wp, args, 1); + } + + /* generate identity graph from a set */ +-static object * Gidentity(TableWrapper *SourceSet, object *args) ++static PyObject * Gidentity(TableWrapper *SourceSet, PyObject *args) + { + TableWrapper *resultGraph; + Table *Graphtp; + TableWalker tw; + long test; +- object *d1, *d2; ++ PyObject *d1, *d2; + Dprint(("Gidentity\n")); +- if (!getnoarg(args)) { return NULL; } ++ if (!PyArg_Parse(args, "")) { return NULL; } + if (SourceSet->rep.flag != SETFLAG) { +- err_setstr(TypeError, "graph identity not defined for table of this type"); ++ PyErr_SetString(PyExc_TypeError, "graph identity not defined for table of this type"); + return NULL; + } + /* make a new DICTIONARY for result, may waste space for graphs */ +@@ -2441,26 +2440,26 @@ + (void) NextAll(&tw); + } + if ((test == -1) || (tw.valid == -1)) { +- DECREF(resultGraph); ++ Py_DECREF(resultGraph); + return NULL; + } +- return (object *) resultGraph; ++ return (PyObject *) resultGraph; + } + +-static object * Greachable(TableWrapper *graph, object *args) ++static PyObject * Greachable(TableWrapper *graph, PyObject *args) + { +- object *key, *d1, *d2; ++ PyObject *key, *d1, *d2; + TableWrapper *resultSet, *tempSet, *deltaSet; + Table *resulttp, *temptp, *deltatp, *graphtp; + TableWalker deltaW, graphW; + long test, fail; + Dprint(("Greachable\n")); + if (graph->rep.flag == SETFLAG) { +- err_setstr(TypeError, "reachable not defined for this table type"); ++ PyErr_SetString(PyExc_TypeError, "reachable not defined for this table type"); + return NULL; + } +- if ((args == NULL) || (!getargs(args, "O", &key))) { +- err_setstr(TypeError, "reachable requires key argument"); ++ if ((args == NULL) || (!PyArg_Parse(args, "O", &key))) { ++ PyErr_SetString(PyExc_TypeError, "reachable requires key argument"); + return NULL; + } + /* make result and temporary sets for computation */ +@@ -2468,9 +2467,9 @@ + tempSet = (TableWrapper *) newWrapper(0, SETFLAG); + deltaSet = (TableWrapper *) newWrapper(0, SETFLAG); + if ((deltaSet == NULL) || (resultSet == NULL) || (tempSet == NULL)) { +- XDECREF(deltaSet); +- XDECREF(resultSet); +- XDECREF(tempSet); ++ Py_XDECREF(deltaSet); ++ Py_XDECREF(resultSet); ++ Py_XDECREF(tempSet); + return NULL; + } + propagateDirt(graph, resultSet); +@@ -2513,48 +2512,48 @@ + } + } /* endwhile delta has entries... */ + /* get rid of temporaries */ +- DECREF(tempSet); +- DECREF(deltaSet); ++ Py_DECREF(tempSet); ++ Py_DECREF(deltaSet); + if (fail != 0) { +- DECREF(resultSet); ++ Py_DECREF(resultSet); + return NULL; + } +- return (object *) resultSet; ++ return (PyObject *) resultSet; + } + + /* Clean filter: returns argument if the table + is clean, otherwise NULL */ +-static object * WClean(TableWrapper *wp, object *args) ++static PyObject * WClean(TableWrapper *wp, PyObject *args) + { + Dprint(("WClean\n")); +- if (!getnoarg(args)) { return NULL; } ++ if (!PyArg_Parse(args, "")) { return NULL; } + if (wp->rep.Dirty) { +- INCREF(None); +- return None; ++ Py_INCREF(Py_None); ++ return Py_None; + } else { +- INCREF(wp); +- return (object *) wp; ++ Py_INCREF(wp); ++ return (PyObject *) wp; + } + } + + /* force a table to be dirty */ +-static object * WSoil(TableWrapper *wp, object *args) ++static PyObject * WSoil(TableWrapper *wp, PyObject *args) + { + Dprint(("WSoil\n")); +- if (!getnoarg(args)) { return NULL; } ++ if (!PyArg_Parse(args, "")) { return NULL; } + wp->rep.Dirty = 1; +- INCREF(None); +- return None; ++ Py_INCREF(Py_None); ++ return Py_None; + } + + /* force a table to be clean */ +-static object * WWash(TableWrapper *wp, object *args) ++static PyObject * WWash(TableWrapper *wp, PyObject *args) + { + Dprint(("WWash\n")); +- if (!getnoarg(args)) { return NULL; } ++ if (!PyArg_Parse(args, "")) { return NULL; } + wp->rep.Dirty = 0; +- INCREF(None); +- return None; ++ Py_INCREF(Py_None); ++ return Py_None; + } + + /* remap remaps a dictionary using a table which represents +@@ -2563,22 +2562,22 @@ + If the result is "dirty" (ie, if name/value collisions) + None is returned. + */ +-static object * Dremap(TableWrapper *wp, object *args) ++static PyObject * Dremap(TableWrapper *wp, PyObject *args) + { + TableWrapper *remapper, *result; + long count; + Dprint(("Dremap\n")); + if (!is_kjDictobject(wp)) { +- err_setstr(TypeError, "remap only defined for kjDicts"); ++ PyErr_SetString(PyExc_TypeError, "remap only defined for kjDicts"); + return NULL; + } + if (args == NULL) { +- err_setstr(TypeError, "remap requires equality table argument"); ++ PyErr_SetString(PyExc_TypeError, "remap requires equality table argument"); + return NULL; + } +- if (!getargs(args, "O", &remapper)) { return NULL; } ++ if (!PyArg_Parse(args, "O", &remapper)) { return NULL; } + if ( !is_kjTable(remapper)) { +- err_setstr(TypeError, "remap defined only between kj-tables"); ++ PyErr_SetString(PyExc_TypeError, "remap defined only between kj-tables"); + return NULL; + } + /* don't assume anything about size of result */ +@@ -2588,75 +2587,75 @@ + propagateDirt(remapper, result); + /* return NONE if result is dirty (save some work) */ + if (result->rep.Dirty != 0) { +- DECREF(result); +- INCREF(None); +- return None; ++ Py_DECREF(result); ++ Py_INCREF(Py_None); ++ return Py_None; + } + count = Tcompose( &(result->rep), &(remapper->rep), &(wp->rep), 0, 0); + if (count<0) { +- DECREF(result); ++ Py_DECREF(result); + return NULL; /* error */ + } + /* return NONE if result is dirty after composition */ + if (result->rep.Dirty != 0) { +- DECREF(result); +- INCREF(None); +- return None; ++ Py_DECREF(result); ++ Py_INCREF(Py_None); ++ return Py_None; + } +- return (object *) result; ++ return (PyObject *) result; + } + + /* forward declarations needed below */ +-static object * kjDict_subscript(TableWrapper *Set, object *key); +-static long kjDict_ass_subscript(object *Set, object *key, object *thing); ++static PyObject * kjDict_subscript(TableWrapper *Set, PyObject *key); ++static long kjDict_ass_subscript(PyObject *Set, PyObject *key, PyObject *thing); + + /* for dumping a dictionary to a tuple */ + /* D.dump(tup) produces D[tup[0]] if tup of len 1 + or (D[tup[0]], D[tup[1]],...) if tup of len > 1 + or keyerror if keys aren't present. + */ +-static object * kjDictDump(TableWrapper *wp, object *args) ++static PyObject * kjDictDump(TableWrapper *wp, PyObject *args) + { +- object *result, *input, *key, *map; ++ PyObject *result, *input, *key, *map; + long valid, index, length; + Dprint(("kjDictDump\n")); + if (!is_kjDictobject(wp) && !is_kjGraphobject(wp)) { +- err_setstr(TypeError, "dump only defined for kjDicts"); ++ PyErr_SetString(PyExc_TypeError, "dump only defined for kjDicts"); + return NULL; + } + if (args == NULL) { +- err_setstr(TypeError, "dictionary dump requires tuple argument"); ++ PyErr_SetString(PyExc_TypeError, "dictionary dump requires tuple argument"); + return NULL; + } +- valid = getargs(args, "O", &input); +- if (valid && (is_tupleobject(input))) { +- length = gettuplesize(input); ++ valid = PyArg_Parse(args, "O", &input); ++ if (valid && (PyTuple_Check(input))) { ++ length = PyTuple_Size(input); + if (length < 1) { +- err_setstr(TypeError, "dictionary dump requires nonempty tuple arg"); ++ PyErr_SetString(PyExc_TypeError, "dictionary dump requires nonempty tuple arg"); + return NULL; + } + if (length == 1) { + /* return D[input[0]] */ +- key = gettupleitem(input, 0); ++ key = PyTuple_GetItem(input, 0); + return kjDict_subscript(wp, key); /* incref done by function */ + } else { + /* return ( D[input[0]], D[input[1]], ..., D[input[n]] ) */ +- result = newtupleobject(length); ++ result = PyTuple_New(length); + if (result == NULL) { return NULL; } /* failure to allocate */ + for (index = 0; index<length; index++) { +- key = gettupleitem(input, index); ++ key = PyTuple_GetItem(input, index); + map = kjDict_subscript(wp, key); /* incref done by function */ + if (map == NULL) { +- DECREF(result); ++ Py_DECREF(result); + return NULL; /* keyerror, normally */ + } + /* map was increfed by kjDict_subscript already */ +- settupleitem(result, index, map); ++ PyTuple_SetItem(result, index, map); + } + return result; + } + } else { +- err_setstr(TypeError, "dictionary dump arg must be tuple"); ++ PyErr_SetString(PyExc_TypeError, "dictionary dump arg must be tuple"); + return NULL; + } + } +@@ -2667,24 +2666,24 @@ + kjDict( [ (tup[0], thing[0]), (tup[1], thing[1]) ] ) + if tup of len>1 and thing of same len, or error + */ +-static object * kjUndumpToDict(object *self, object *args) ++static PyObject * kjUndumpToDict(PyObject *self, PyObject *args) + { + TableWrapper *result; +- object *tup, *thing, *key, *map; ++ PyObject *tup, *thing, *key, *map; + long valid, index, length; + Dprint(("kjUndump\n")); + if (args == NULL) { +- err_setstr(TypeError, "kjUndump called with no args"); ++ PyErr_SetString(PyExc_TypeError, "kjUndump called with no args"); + return NULL; + } +- valid = getargs(args, "(OO)", &tup, &thing); ++ valid = PyArg_Parse(args, "(OO)", &tup, &thing); + if (valid) { +- valid = is_tupleobject(tup); ++ valid = PyTuple_Check(tup); + } + if (valid) { +- length = gettuplesize(tup); ++ length = PyTuple_Size(tup); + if (length<1) { +- err_setstr(ValueError, "kjUndump: tuple must be non-empty"); ++ PyErr_SetString(PyExc_ValueError, "kjUndump: tuple must be non-empty"); + return NULL; + } + /* try to save a little space */ +@@ -2692,39 +2691,39 @@ + if (result == NULL) { return NULL; } /* allocation failure */ + if (length == 1) { + /* return D[tup[0]] = thing */ +- key = gettupleitem(tup, 0); +- valid = kjDict_ass_subscript((object *) result, key, thing); ++ key = PyTuple_GetItem(tup, 0); ++ valid = kjDict_ass_subscript((PyObject *) result, key, thing); + if (valid == -1) { +- DECREF(result); ++ Py_DECREF(result); + return NULL; + } +- return (object *) result; ++ return (PyObject *) result; + } else { + /* return for i in len(tup): + D[tup[i]] = thing[i] + */ +- if (is_tupleobject(thing)) { +- if (gettuplesize(thing) != length) { +- err_setstr(TypeError,"kjUndump -- tuple lengths don't match"); ++ if (PyTuple_Check(thing)) { ++ if (PyTuple_Size(thing) != length) { ++ PyErr_SetString(PyExc_TypeError,"kjUndump -- tuple lengths don't match"); + return NULL; + } + for (index = 0; index<length; index++) { +- key = gettupleitem(tup, index); +- map = gettupleitem(thing, index); +- valid = kjDict_ass_subscript((object *) result, key, map); ++ key = PyTuple_GetItem(tup, index); ++ map = PyTuple_GetItem(thing, index); ++ valid = kjDict_ass_subscript((PyObject *) result, key, map); + if (valid == -1){ +- DECREF(result); ++ Py_DECREF(result); + return NULL; + } + } +- return (object *) result; ++ return (PyObject *) result; + } else { +- err_setstr(TypeError,"kjUndump -- nonunary tuple with non-tuple"); ++ PyErr_SetString(PyExc_TypeError,"kjUndump -- nonunary tuple with non-tuple"); + return NULL; + } + } + } else { +- err_setstr(TypeError,"kjUndump requires 2 args, first must be tuple"); ++ PyErr_SetString(PyExc_TypeError,"kjUndump requires 2 args, first must be tuple"); + return NULL; + } + } +@@ -2737,21 +2736,21 @@ + + but faster, doesn't allocate unneeded set + */ +-static object * kjWRestrict(TableWrapper *wp, object *args) ++static PyObject * kjWRestrict(TableWrapper *wp, PyObject *args) + { + long test; + TableWrapper *result, *compare; +- object *d1, *d2; /* dummies */ ++ PyObject *d1, *d2; /* dummies */ + enum BucketFlag flag; + TableWalker compareWalker, wpWalker; + Table *tp, *resulttp, *comparetp; +- if ((args == NULL) || (!getargs(args, "O", &compare))) { +- err_setstr(TypeError, ++ if ((args == NULL) || (!PyArg_Parse(args, "O", &compare))) { ++ PyErr_SetString(PyExc_TypeError, + "restriction function requires one kjTable argument"); + return NULL; + } + if (!is_kjTable(compare)) { +- err_setstr(TypeError, "restrict function requires kjTable argument"); ++ PyErr_SetString(PyExc_TypeError, "restrict function requires kjTable argument"); + return NULL; + } + flag = wp->rep.flag; +@@ -2807,11 +2806,11 @@ + } + /* test for error cases */ + if (test == -1) { +- XDECREF(result); ++ Py_XDECREF(result); + return NULL; + } + /* otherwise just return result */ +- return (object *) result; ++ return (PyObject *) result; + } + + /* special function for retrieving from dict-dumped indices +@@ -2831,7 +2830,7 @@ + (may retrieve "too many neighbors" for key of None or (None,) + + defined benieth following utility function as +- static object * kjWdget(TableWrapper *wp, object *args) ++ static PyObject * kjWdget(TableWrapper *wp, PyObject *args) + + */ + +@@ -2839,27 +2838,27 @@ + return 1 if neighbors set is nonempty, else, 0 + */ + /* #ifndef PYTHON1DOT2 */ +-static object * kjWdget1(TableWrapper *wp, object *args, long testonly) ++static PyObject * kjWdget1(TableWrapper *wp, PyObject *args, long testonly) + { +- object *d, *dumper, *result, *err_type /*, *err_value */; ++ PyObject *d, *dumper, *result, *err_type /*, *err_value */; + TableWrapper *dict; + /* get and verify args */ + if (args == NULL) { +- err_setstr(TypeError, "dget requires 2 arguments"); ++ PyErr_SetString(PyExc_TypeError, "dget requires 2 arguments"); + return NULL; + } +- if (!getargs(args, "(OO)", &dict, &dumper)) { +- err_setstr(TypeError, ++ if (!PyArg_Parse(args, "(OO)", &dict, &dumper)) { ++ PyErr_SetString(PyExc_TypeError, + "dget requires dict, dumper"); + return NULL; + } + if (!((is_kjDictobject(dict)) || (is_kjGraphobject(dict)))) { +- err_setstr(TypeError, ++ PyErr_SetString(PyExc_TypeError, + "first arg of dget must be kjDict or kjGraph"); + return NULL; + } +- if (!is_tupleobject(dumper)) { +- err_setstr(TypeError, ++ if (!PyTuple_Check(dumper)) { ++ PyErr_SetString(PyExc_TypeError, + "second arg of dget must be tuple"); + return NULL; + } +@@ -2869,16 +2868,16 @@ + /* unable to dump */ + /* check that error was a keyerror ??? */ + /* err_get(&err_type, &err_value); */ +- err_type = err_occurred(); +- if (err_type != KeyError) { ++ err_type = PyErr_Occurred(); ++ if (err_type != PyExc_KeyError) { + /* some other error... abort */ +- /* err_setval(err_type, err_value); */ ++ /* PyErr_SetObject(err_type, err_value); */ + return NULL; + } +- err_clear(); +- /* in case of KeyError, just return None */ +- INCREF(None); +- return None; ++ PyErr_Clear(); ++ /* in case of PyExc_KeyError, just return None */ ++ Py_INCREF(Py_None); ++ return Py_None; + } + /* if dump was successful, return neighbors */ + /* ??? should return d also ??? */ +@@ -2887,7 +2886,7 @@ + } else { + result = Whas_key(wp, d); + } +- XDECREF(d); ++ Py_XDECREF(d); + return result; + } + /* #endif */ +@@ -2903,13 +2902,13 @@ + except KeyError: return None + */ + /* #ifndef PYTHON1DOT2 */ +-static object * kjWdtest(TableWrapper *wp, object *args) ++static PyObject * kjWdtest(TableWrapper *wp, PyObject *args) + { + return kjWdget1(wp, args, 1); /* test only */ + } + /* #endif + #ifndef PYTHON1DOT2 */ +-static object * kjWdget(TableWrapper *wp, object *args) ++static PyObject * kjWdget(TableWrapper *wp, PyObject *args) + { + return kjWdget1(wp, args, 0); /* don't test only */ + } +@@ -2918,67 +2917,67 @@ + /* + miscellaneous methods for these types + */ +-static struct methodlist Wrapper_methods[] = { +- {"member", (method)Wmember}, +- {"add", (method)Waddmember}, +- {"delete_arc", (method)Wdelete_arc}, +- {"has_key", (method)Whas_key}, +- {"choose_key", (method)Wchoose_key}, +- {"Clean", (method)WClean}, +- {"neighbors", (method)Gneighbors}, +- {"dump", (method)kjDictDump}, ++static struct PyMethodDef Wrapper_methods[] = { ++ {"member", (PyCFunction)Wmember}, ++ {"add", (PyCFunction)Waddmember}, ++ {"delete_arc", (PyCFunction)Wdelete_arc}, ++ {"has_key", (PyCFunction)Whas_key}, ++ {"choose_key", (PyCFunction)Wchoose_key}, ++ {"Clean", (PyCFunction)WClean}, ++ {"neighbors", (PyCFunction)Gneighbors}, ++ {"dump", (PyCFunction)kjDictDump}, + /* #ifndef PYTHON1DOT2 */ +- {"dget", (method)kjWdget}, +- {"dtest", (method)kjWdtest}, ++ {"dget", (PyCFunction)kjWdget}, ++ {"dtest", (PyCFunction)kjWdtest}, + /* #endif */ +- {"reachable", (method)Greachable}, +- {"subset", (method)WSubset}, +- {"items", (method)WrapperItems}, +- {"keys", (method)Wkeys}, +- {"values", (method)Wvalues}, +- {"ident", (method)Gidentity}, +- {"remap", (method)Dremap}, +- {"restrict", (method)kjWRestrict}, +- {"tclosure", (method)Wtransclose}, +- {"Soil", (method)WSoil}, +- {"Wash", (method)WWash}, ++ {"reachable", (PyCFunction)Greachable}, ++ {"subset", (PyCFunction)WSubset}, ++ {"items", (PyCFunction)WrapperItems}, ++ {"keys", (PyCFunction)Wkeys}, ++ {"values", (PyCFunction)Wvalues}, ++ {"ident", (PyCFunction)Gidentity}, ++ {"remap", (PyCFunction)Dremap}, ++ {"restrict", (PyCFunction)kjWRestrict}, ++ {"tclosure", (PyCFunction)Wtransclose}, ++ {"Soil", (PyCFunction)WSoil}, ++ {"Wash", (PyCFunction)WWash}, + {NULL, NULL} /* sentinel */ + }; + + /* getattr snarfed from mappingobject.c */ +-static object * Wrapper_getattr(object *mp, char *name) ++static PyObject * Wrapper_getattr(PyObject *mp, char *name) + { +- return findmethod(Wrapper_methods, (object *)mp, name); ++ return Py_FindMethod(Wrapper_methods, (PyObject *)mp, name); + } + + + /* methods for special behaviors as number and mapping */ + + /* undefined operations */ +-static object * undefbin(object *v, object *w) ++static PyObject * undefbin(PyObject *v, PyObject *w) + { +- err_setstr(TypeError, "op not valid for table of this type"); ++ PyErr_SetString(PyExc_TypeError, "op not valid for table of this type"); + return NULL; + } +-static object * undefter(object *v, object *w, object *z) ++static PyObject * undefter(PyObject *v, PyObject *w, PyObject *z) + { +- err_setstr(TypeError, "op not valid for table of this type"); ++ PyErr_SetString(PyExc_TypeError, "op not valid for table of this type"); + return NULL; + } +-static object * undefun(object *v) ++static PyObject * undefun(PyObject *v) + { +- err_setstr(TypeError, "op not valid for table of this type"); ++ PyErr_SetString(PyExc_TypeError, "op not valid for table of this type"); + return NULL; + } + + /* transpose of non 1:1 dict will have nondeterministic results */ +-static object *Wtranspose(TableWrapper *source) ++static PyObject *Wtranspose(TableWrapper *source) + { + TableWrapper *result; + long size, test; + Dprint(("Wtranspose\n")); + if (source->rep.flag == SETFLAG) { +- err_setstr(TypeError, "Cannot transpose set"); ++ PyErr_SetString(PyExc_TypeError, "Cannot transpose set"); + return NULL; + } + /* conservative estimate of size (may save space, maybe not) */ +@@ -2989,22 +2988,22 @@ + propagateDirt(source, result); + test = Ttranspose( &(result->rep), &(source->rep) ); + if (test!=0) { +- DECREF(result); ++ Py_DECREF(result); + return NULL; + } +- return (object *) result; ++ return (PyObject *) result; + } + +-static object *Wunion(TableWrapper *left, TableWrapper *right) ++static PyObject *Wunion(TableWrapper *left, TableWrapper *right) + { + enum BucketFlag flag; + TableWrapper *result; + long size, test; + Dprint(("Wunion\n")); + /* None unioned with anything returns None (universal set) */ +- if (((object *) left == None) || ((object *) right == None)) { +- INCREF(None); +- return None; ++ if (((PyObject *) left == Py_None) || ((PyObject *) right == Py_None)) { ++ Py_INCREF(Py_None); ++ return Py_None; + } + /* arbitrary size heuristic */ + if (left->rep.entries > right->rep.entries) +@@ -3015,7 +3014,7 @@ + /* determine coercion if possible, default=more general */ + test = FlagCoercion(left->rep.flag, right->rep.flag, &flag, 1); + if (test != 1) { +- err_setstr(TypeError, "incompatible types for table union"); ++ PyErr_SetString(PyExc_TypeError, "incompatible types for table union"); + return NULL; + } + /* allocate a wrapper and augment it with both inputs */ +@@ -3028,14 +3027,14 @@ + test = Taugment( &(result->rep), &(right->rep) ); + } + if (test!=0) { +- DECREF(result); ++ Py_DECREF(result); + return NULL; + } +- return (object *) result; ++ return (PyObject *) result; + } + + /* utility function for intersection and difference */ +-static object * Wintdiff(TableWrapper *left, TableWrapper *right, ++static PyObject * Wintdiff(TableWrapper *left, TableWrapper *right, + long include, enum BucketFlag flagout) + { + TableWrapper *result; +@@ -3053,23 +3052,23 @@ + propagateDirt( right, result ); + count = Tintdiff(&(result->rep), &(left->rep), &(right->rep), include, 0); + if (count < 0) { +- DECREF(result); ++ Py_DECREF(result); + return NULL; + } +- return (object *) result; ++ return (PyObject *) result; + } + + /* intersection */ +-static object * Wintersect(TableWrapper *left, TableWrapper *right) ++static PyObject * Wintersect(TableWrapper *left, TableWrapper *right) + { + long test; + enum BucketFlag flag, lflag, rflag; + Dprint(("Wintersect\n")); + /* None intersected with anything returns copy of anything... */ +- if ((object *)left == None) { ++ if ((PyObject *)left == Py_None) { + return Wunion(right, right); + } +- if ((object *)right == None) { ++ if ((PyObject *)right == Py_None) { + return Wunion(left, left); + } + /* determine flag: default to less general */ +@@ -3078,12 +3077,12 @@ + /* coerce to more general, unless one arg is a set, + in which case coerce to set */ + if ( (rflag != lflag) && ((rflag == SETFLAG)||(lflag == SETFLAG)) ) { +- err_setstr(TypeError, "mixed intersection not allowed with kjSet"); ++ PyErr_SetString(PyExc_TypeError, "mixed intersection not allowed with kjSet"); + return NULL; + } + test = FlagCoercion(left->rep.flag, right->rep.flag, &flag, -1); + if (test!=1) { +- err_setstr(TypeError, "unable to coerce for intersection"); ++ PyErr_SetString(PyExc_TypeError, "unable to coerce for intersection"); + return NULL; + } + /* iterate over the smaller argument */ +@@ -3095,32 +3094,32 @@ + } + + /* difference */ +-static object * Wdifference(TableWrapper *left, TableWrapper *right) ++static PyObject * Wdifference(TableWrapper *left, TableWrapper *right) + { + enum BucketFlag lflag, rflag; + /* left cannot be None */ + Dprint(("Wdifference\n")); +- if ((object *)left == None) { +- err_setstr(TypeError, "cannot difference from None"); ++ if ((PyObject *)left == Py_None) { ++ PyErr_SetString(PyExc_TypeError, "cannot difference from None"); + return NULL; + } + /* if right is None return empty */ +- if ((object *)right == None) { +- return (object *) newWrapper(0, left->rep.flag); ++ if ((PyObject *)right == Py_None) { ++ return (PyObject *) newWrapper(0, left->rep.flag); + } + rflag = right->rep.flag; + lflag = left->rep.flag; + /* diff default coerce to whatever left is, unless one arg is a + set, in which case raise an error */ + if ( (rflag != lflag) && ((rflag == SETFLAG)||(lflag == SETFLAG)) ) { +- err_setstr(TypeError, "mixed difference not allowed with kjSet"); ++ PyErr_SetString(PyExc_TypeError, "mixed difference not allowed with kjSet"); + return NULL; + } + return Wintdiff(left, right, 0, lflag); + } + + /* composition of two tables */ +-static object * Wcompose(TableWrapper *left, TableWrapper *right) ++static PyObject * Wcompose(TableWrapper *left, TableWrapper *right) + { + enum BucketFlag flag; + TableWrapper *result; +@@ -3128,8 +3127,8 @@ + Table *Ltable, *Rtable; + Dprint(("Wcompose\n")); + /* neither arg may be None */ +- if (((object *)left == None) || ((object *)right == None)) { +- err_setstr(TypeError, "cannot compose None"); ++ if (((PyObject *)left == Py_None) || ((PyObject *)right == Py_None)) { ++ PyErr_SetString(PyExc_TypeError, "cannot compose None"); + return NULL; + } + Ltable = &(left->rep); +@@ -3137,7 +3136,7 @@ + /* find coercion, prefer more general */ + test = FlagCoercion(Ltable->flag, Rtable->flag, &flag, 1); + if (test!=1) { +- err_setstr(TypeError, "incompatible types for composition"); ++ PyErr_SetString(PyExc_TypeError, "incompatible types for composition"); + return NULL; + } + /* DON'T determine required table size, (not easily done correctly) */ +@@ -3154,10 +3153,10 @@ + propagateDirt( right, result ); + count = Tcompose(&(result->rep), Ltable, Rtable, 0, 0); + if (count < 0) { +- DECREF(result); ++ Py_DECREF(result); + return NULL; /* error */ + } +- return (object *) result; ++ return (PyObject *) result; + } + + /* coercion: +@@ -3165,16 +3164,16 @@ + all other logic is at the function level + (None == universal set) + */ +-static long Wrapper_coerce(object **pv, object **pw) ++static long Wrapper_coerce(PyObject **pv, PyObject **pw) + { +- object *w; ++ PyObject *w; + w = *pw; + Dprint(("Wcoerce\n")); +- if ( (w == None) || ++ if ( (w == Py_None) || + is_kjTable(w) ) { + /* both w and *pv are "returned", hence must be increfed */ +- INCREF(w); +- INCREF(*pv); ++ Py_INCREF(w); ++ Py_INCREF(*pv); + return 0; /* okay */ + } + return 1; /* Nope! */ +@@ -3183,7 +3182,7 @@ + + + /* the number methods structure for all kjSets, kjDicts, kjGraphs */ +-static number_methods kjSet_as_number = { ++static PyNumberMethods kjSet_as_number = { + (binaryfunc)Wunion, /*nb_add*/ + (binaryfunc)Wdifference, /*nb_subtract*/ + (binaryfunc)Wcompose, /*nb_multiply*/ +@@ -3209,19 +3208,19 @@ + (unaryfunc)undefun, /*nb_hex*/ + }; + +-static object * kjSet_subscript(TableWrapper *Set, object *key) ++static PyObject * kjSet_subscript(TableWrapper *Set, PyObject *key) + { +- object *mem, *map; ++ PyObject *mem, *map; + long test; + Dprint(("kjSet_subscript\n")); + test = TableGet1(&(Set->rep), key, 0, NOHASH, NOFORCE, &mem, &map); + if (test == -1) { return NULL; } +- return newintobject((long) 1); ++ return PyInt_FromLong((long) 1); + } + +-static long kjSet_ass_subscript(object *Set, object *key, object *thing) ++static long kjSet_ass_subscript(PyObject *Set, PyObject *key, PyObject *thing) + { +- object *mem, *map; ++ PyObject *mem, *map; + TableWrapper *S; + Dprint(("kjSet_ass_subscript\n")); + S = (TableWrapper *) Set; +@@ -3239,20 +3238,20 @@ + } + } + +-static object * kjDict_subscript(TableWrapper *Set, object *key) ++static PyObject * kjDict_subscript(TableWrapper *Set, PyObject *key) + { +- object *mem, *map; ++ PyObject *mem, *map; + long test; + Dprint(("kjDict_subscript\n")); + test = TableGet1(&(Set->rep), key, 0, NOHASH, NOFORCE, &mem, &map); + if (test == -1) { return NULL; } +- XINCREF(map); ++ Py_XINCREF(map); + return map; + } + +-static long kjDict_ass_subscript(object *Set, object *key, object *thing) ++static long kjDict_ass_subscript(PyObject *Set, PyObject *key, PyObject *thing) + { +- object *mem, *map; ++ PyObject *mem, *map; + TableWrapper *S; + Dprint(("kjDict_ass_subscript\n")); + S = (TableWrapper *) Set; +@@ -3276,7 +3275,7 @@ + } + + /* mapping methods for jkSets */ +-static mapping_methods kjSet_as_mapping = { ++static PyMappingMethods kjSet_as_mapping = { + (inquiry)Wrapper_length, /*mp_length*/ + (binaryfunc)kjSet_subscript, /*mp_subscript*/ + (objobjargproc)kjSet_ass_subscript, /*mp_ass_subscript*/ +@@ -3284,15 +3283,15 @@ + + + /* mapping methods for kjDicts AND kjGraphs */ +-static mapping_methods kjDict_as_mapping = { ++static PyMappingMethods kjDict_as_mapping = { + (inquiry)Wrapper_length, /*mp_length*/ + (binaryfunc)kjDict_subscript, /*mp_subscript*/ + (objobjargproc)kjDict_ass_subscript, /*mp_ass_subscript*/ + }; + + /* THE TYPE OBJECT FOR SETS */ +-static typeobject kjSettype = { +- OB_HEAD_INIT(&Typetype) ++static PyTypeObject kjSettype = { ++ PyObject_HEAD_INIT(&PyType_Type) + 0, + (char *) "kjSet", /*tp_name for printing */ + (unsigned int) sizeof(TableWrapper), /*tp_basicsize */ +@@ -3303,16 +3302,16 @@ + (setattrfunc)NULL, /*tp_setattr*/ + (cmpfunc)Wcompare, /*tp_compare*/ + (reprfunc)WrapperRepr, /*tp_repr*/ +- (number_methods *)&kjSet_as_number, /*tp_as_number*/ +- (sequence_methods *)NULL, /*tp_as_sequence*/ +- (mapping_methods *)&kjSet_as_mapping, /*tp_as_mapping*/ ++ (PyNumberMethods *)&kjSet_as_number, /*tp_as_number*/ ++ (PySequenceMethods *)NULL, /*tp_as_sequence*/ ++ (PyMappingMethods *)&kjSet_as_mapping, /*tp_as_mapping*/ + (hashfunc)Wrapper_hash, /*tp_hash*/ +- (binaryfunc)NULL, /*tp_call*/ ++ (ternaryfunc)NULL, /*tp_call*/ + }; + + /* THE TYPE OBJECT FOR DICTS */ +-static typeobject kjDicttype = { +- OB_HEAD_INIT(&Typetype) ++static PyTypeObject kjDicttype = { ++ PyObject_HEAD_INIT(&PyType_Type) + 0, + (char *) "kjDict", /*tp_name for printing */ + (unsigned int) sizeof(TableWrapper), /*tp_basicsize */ +@@ -3323,16 +3322,16 @@ + (setattrfunc)0, /*tp_setattr*/ + (cmpfunc)Wcompare, /*tp_compare*/ + (reprfunc)WrapperRepr, /*tp_repr*/ +- (number_methods *)&kjSet_as_number, /*tp_as_number*/ +- (sequence_methods *)0, /*tp_as_sequence*/ +- (mapping_methods *)&kjDict_as_mapping, /*tp_as_mapping*/ ++ (PyNumberMethods *)&kjSet_as_number, /*tp_as_number*/ ++ (PySequenceMethods *)0, /*tp_as_sequence*/ ++ (PyMappingMethods *)&kjDict_as_mapping, /*tp_as_mapping*/ + (hashfunc)Wrapper_hash, /*tp_hash*/ +- (binaryfunc)0, /*tp_call*/ ++ (ternaryfunc)0, /*tp_call*/ + }; + + /* THE TYPE OBJECT FOR GRAPHSS */ +-static typeobject kjGraphtype = { +- OB_HEAD_INIT(&Typetype) ++static PyTypeObject kjGraphtype = { ++ PyObject_HEAD_INIT(&PyType_Type) + 0, + (char *) "kjGraph", /*tp_name for printing */ + (unsigned int) sizeof(TableWrapper), /*tp_basicsize */ +@@ -3343,11 +3342,11 @@ + (setattrfunc)0, /*tp_setattr*/ + (cmpfunc)Wcompare, /*tp_compare*/ + (reprfunc)WrapperRepr, /*tp_repr*/ +- (number_methods *)&kjSet_as_number, /*tp_as_number*/ +- (sequence_methods *)0, /*tp_as_sequence*/ +- (mapping_methods *)&kjDict_as_mapping, /*tp_as_mapping*/ ++ (PyNumberMethods *)&kjSet_as_number, /*tp_as_number*/ ++ (PySequenceMethods *)0, /*tp_as_sequence*/ ++ (PyMappingMethods *)&kjDict_as_mapping, /*tp_as_mapping*/ + (hashfunc)Wrapper_hash, /*tp_hash*/ +- (binaryfunc)0, /*tp_call*/ ++ (ternaryfunc)0, /*tp_call*/ + }; + + /* special method for adding to a "dumped index" +@@ -3376,39 +3375,39 @@ + nullbag is kjDict or kjGraph + */ + /* #ifndef PYTHON1DOT2 */ +-static object * kjKeyPut(object *self, object *args) ++static PyObject * kjKeyPut(PyObject *self, PyObject *args) + { + long valid; + TableWrapper *dict, *index, *nullbag; +- object *dumper, *psuedokey, *d, *pair, *err_type /*, *err_value */; ++ PyObject *dumper, *psuedokey, *d, *pair, *err_type /*, *err_value */; + /* get and verify args */ + if (args == NULL) { +- err_setstr(TypeError, "KeyPut requires 5 arguments"); ++ PyErr_SetString(PyExc_TypeError, "KeyPut requires 5 arguments"); + return NULL; + } +- if (!getargs(args, "(OOOOO)", ++ if (!PyArg_Parse(args, "(OOOOO)", + &dict, &dumper, &index, &psuedokey, &nullbag)) { +- err_setstr(TypeError, ++ PyErr_SetString(PyExc_TypeError, + "KeyPut requires dict, dumper, index, psuedokey, nullbag"); + return NULL; + } + if (!((is_kjDictobject(dict)) || (is_kjGraphobject(dict)))) { +- err_setstr(TypeError, ++ PyErr_SetString(PyExc_TypeError, + "first arg of KeyPut must be kjDict or kjGraph"); + return NULL; + } + if (!((is_kjDictobject(index)) || (is_kjGraphobject(index)))) { +- err_setstr(TypeError, ++ PyErr_SetString(PyExc_TypeError, + "third arg of KeyPut must be kjDict or kjGraph"); + return NULL; + } + if (!((is_kjDictobject(nullbag)) || (is_kjGraphobject(nullbag)))) { +- err_setstr(TypeError, ++ PyErr_SetString(PyExc_TypeError, + "fifth arg of KeyPut must be kjDict or kjGraph"); + return NULL; + } +- if (!is_tupleobject(dumper)) { +- err_setstr(TypeError, ++ if (!PyTuple_Check(dumper)) { ++ PyErr_SetString(PyExc_TypeError, + "second arg of KeyPut must be tuple"); + return NULL; + } +@@ -3418,43 +3417,43 @@ + /* unable to dump */ + /* check that error was a keyerror ??? */ + /* err_get(&err_type, &err_value); */ +- err_type = err_occurred(); +- if (err_type != KeyError) { ++ err_type = PyErr_Occurred(); ++ if (err_type != PyExc_KeyError) { + /* some other error... abort */ +- /* err_setval(err_type, err_value); */ ++ /* PyErr_SetObject(err_type, err_value); */ + return NULL; + } +- /* in case of KeyError, augment the Nullbag, return None */ +- err_clear(); +- valid = kjDict_ass_subscript((object *) nullbag, +- psuedokey, (object *) dict); ++ /* in case of PyExc_KeyError, augment the Nullbag, return None */ ++ PyErr_Clear(); ++ valid = kjDict_ass_subscript((PyObject *) nullbag, ++ psuedokey, (PyObject *) dict); + if (valid == -1) { + return NULL; + } +- INCREF(None); +- return None; ++ Py_INCREF(Py_None); ++ return Py_None; + } + /* if dump succeeded... */ +- /* initialize pair, INCREF components */ +- pair = newtupleobject(2); ++ /* initialize pair, Py_INCREF components */ ++ pair = PyTuple_New(2); + if (pair == NULL) { return NULL; } +- settupleitem(pair, 0, psuedokey); +- INCREF(psuedokey); +- settupleitem(pair, 1, (object *) dict); +- INCREF(dict); ++ PyTuple_SetItem(pair, 0, psuedokey); ++ Py_INCREF(psuedokey); ++ PyTuple_SetItem(pair, 1, (PyObject *) dict); ++ Py_INCREF(dict); + /* remap None to (None,) if needed */ +- if (d == None) { ++ if (d == Py_None) { + /* preserve extra reference to None... */ +- d = newtupleobject(1); +- settupleitem(d, 0, None); ++ d = PyTuple_New(1); ++ PyTuple_SetItem(d, 0, Py_None); + } + /* set index[d] = pair, creates an extra ref to pair */ +- valid = kjDict_ass_subscript((object *) index, d, pair); ++ valid = kjDict_ass_subscript((PyObject *) index, d, pair); + if (valid == -1) { +- XDECREF(pair); ++ Py_XDECREF(pair); + return NULL; + } +- XDECREF(pair); /* dispose of extra ref to pair */ ++ Py_XDECREF(pair); /* dispose of extra ref to pair */ + return d; + } + /* #endif */ +@@ -3462,16 +3461,16 @@ + /* THE "METHODS" FOR THIS MODULE */ + /* These are the basic external interfaces for python to + access this module. */ +-static struct methodlist kjbuckets_methods[] = { +- {"kjSet", (method)makekjSet}, +- {"kjDict", (method)makekjDict}, +- {"kjGraph", (method)makekjGraph}, +- {"kjUndump", (method)kjUndumpToDict}, ++static struct PyMethodDef kjbuckets_methods[] = { ++ {"kjSet", (PyCFunction)makekjSet}, ++ {"kjDict", (PyCFunction)makekjDict}, ++ {"kjGraph", (PyCFunction)makekjGraph}, ++ {"kjUndump", (PyCFunction)kjUndumpToDict}, + /* #ifndef PYTHON1DOT2 */ +- {"kjKeyPut", (method)kjKeyPut}, ++ {"kjKeyPut", (PyCFunction)kjKeyPut}, + /* #endif */ + #ifdef KJBDEBUG +- {"debug", (method)Wdebug}, ++ {"debug", (PyCFunction)Wdebug}, + #endif + {NULL, NULL} /* sentinel */ + }; +@@ -3479,7 +3478,7 @@ + void + initkjbuckets() + { +- initmodule("kjbuckets", kjbuckets_methods); ++ Py_InitModule("kjbuckets", kjbuckets_methods); + } + + /* end of kjbuckets module by Aaron Watters */ diff --git a/devel/py-kjbuckets/pkg-plist b/devel/py-kjbuckets/pkg-plist index 9aab0c6c39ef..ab72c5c42954 100644 --- a/devel/py-kjbuckets/pkg-plist +++ b/devel/py-kjbuckets/pkg-plist @@ -1,3 +1,3 @@ -@exec mkdir -p %D/lib/python1.5/site-packages -lib/python1.5/site-packages/kjbucketsmodule.so +@exec mkdir -p %D/lib/%%PYTHON_VERSION%%/site-packages +lib/%%PYTHON_VERSION%%/site-packages/kjbucketsmodule.so share/doc/kjbuckets.html diff --git a/x11-toolkits/py-gtk/Makefile b/x11-toolkits/py-gtk/Makefile index 4aa8b76312c2..237a1d16a069 100644 --- a/x11-toolkits/py-gtk/Makefile +++ b/x11-toolkits/py-gtk/Makefile @@ -14,15 +14,13 @@ DISTNAME= gnome-python-1.0.53 MAINTAINER= nectar@FreeBSD.org -BUILD_DEPENDS= python1.5:${PORTSDIR}/lang/python15 LIB_DEPENDS= gtk12.2:${PORTSDIR}/x11-toolkits/gtk12 \ Imlib.5:${PORTSDIR}/graphics/imlib -RUN_DEPENDS= python1.5:${PORTSDIR}/lang/python15 GTK_CONFIG= ${X11BASE}/bin/gtk12-config USE_GMAKE= yes -CONFIGURE_ENV= GTK_CONFIG=${GTK_CONFIG} -CONFIGURE_ARGS= --with-python=python1.5 +USE_PYTHON= yes +CONFIGURE_ENV= GTK_CONFIG=${GTK_CONFIG} PYTHON=${PREFIX}/bin/${PYTHON_CMD} USE_LIBTOOL= yes PLIST_COMPLETE= ${PKGDIR}/PLIST diff --git a/x11-toolkits/py-gtk/pkg-plist b/x11-toolkits/py-gtk/pkg-plist index 7e9eec6fd2ee..a3b39ddc87a6 100644 --- a/x11-toolkits/py-gtk/pkg-plist +++ b/x11-toolkits/py-gtk/pkg-plist @@ -1,37 +1,37 @@ include/pygtk/pygdkimlib.h include/pygtk/pygtk.h -lib/python1.5/site-packages/GDK.py -lib/python1.5/site-packages/GDK.pyc -lib/python1.5/site-packages/GDK.pyo -lib/python1.5/site-packages/GTK.py -lib/python1.5/site-packages/GTK.pyc -lib/python1.5/site-packages/GTK.pyo -lib/python1.5/site-packages/GdkImlib.py -lib/python1.5/site-packages/GdkImlib.pyc -lib/python1.5/site-packages/GdkImlib.pyo -lib/python1.5/site-packages/GtkExtra.py -lib/python1.5/site-packages/GtkExtra.pyc -lib/python1.5/site-packages/GtkExtra.pyo -lib/python1.5/site-packages/Gtkinter.py -lib/python1.5/site-packages/Gtkinter.pyc -lib/python1.5/site-packages/Gtkinter.pyo -lib/python1.5/site-packages/_gdkimlibmodule.so -lib/python1.5/site-packages/_gtkmodule.so -lib/python1.5/site-packages/gtk.py -lib/python1.5/site-packages/gtk.pyc -lib/python1.5/site-packages/gtk.pyo -lib/python1.5/site-packages/pyglade/__init__.py -lib/python1.5/site-packages/pyglade/__init__.pyc -lib/python1.5/site-packages/pyglade/__init__.pyo -lib/python1.5/site-packages/pyglade/build.py -lib/python1.5/site-packages/pyglade/build.pyc -lib/python1.5/site-packages/pyglade/build.pyo -lib/python1.5/site-packages/pyglade/style.py -lib/python1.5/site-packages/pyglade/style.pyc -lib/python1.5/site-packages/pyglade/style.pyo -lib/python1.5/site-packages/pyglade/xmlparse.py -lib/python1.5/site-packages/pyglade/xmlparse.pyc -lib/python1.5/site-packages/pyglade/xmlparse.pyo +lib/%%PYTHON_VERSION%%/site-packages/GDK.py +lib/%%PYTHON_VERSION%%/site-packages/GDK.pyc +lib/%%PYTHON_VERSION%%/site-packages/GDK.pyo +lib/%%PYTHON_VERSION%%/site-packages/GTK.py +lib/%%PYTHON_VERSION%%/site-packages/GTK.pyc +lib/%%PYTHON_VERSION%%/site-packages/GTK.pyo +lib/%%PYTHON_VERSION%%/site-packages/GdkImlib.py +lib/%%PYTHON_VERSION%%/site-packages/GdkImlib.pyc +lib/%%PYTHON_VERSION%%/site-packages/GdkImlib.pyo +lib/%%PYTHON_VERSION%%/site-packages/GtkExtra.py +lib/%%PYTHON_VERSION%%/site-packages/GtkExtra.pyc +lib/%%PYTHON_VERSION%%/site-packages/GtkExtra.pyo +lib/%%PYTHON_VERSION%%/site-packages/Gtkinter.py +lib/%%PYTHON_VERSION%%/site-packages/Gtkinter.pyc +lib/%%PYTHON_VERSION%%/site-packages/Gtkinter.pyo +lib/%%PYTHON_VERSION%%/site-packages/_gdkimlibmodule.so +lib/%%PYTHON_VERSION%%/site-packages/_gtkmodule.so +lib/%%PYTHON_VERSION%%/site-packages/gtk.py +lib/%%PYTHON_VERSION%%/site-packages/gtk.pyc +lib/%%PYTHON_VERSION%%/site-packages/gtk.pyo +lib/%%PYTHON_VERSION%%/site-packages/pyglade/__init__.py +lib/%%PYTHON_VERSION%%/site-packages/pyglade/__init__.pyc +lib/%%PYTHON_VERSION%%/site-packages/pyglade/__init__.pyo +lib/%%PYTHON_VERSION%%/site-packages/pyglade/build.py +lib/%%PYTHON_VERSION%%/site-packages/pyglade/build.pyc +lib/%%PYTHON_VERSION%%/site-packages/pyglade/build.pyo +lib/%%PYTHON_VERSION%%/site-packages/pyglade/style.py +lib/%%PYTHON_VERSION%%/site-packages/pyglade/style.pyc +lib/%%PYTHON_VERSION%%/site-packages/pyglade/style.pyo +lib/%%PYTHON_VERSION%%/site-packages/pyglade/xmlparse.py +lib/%%PYTHON_VERSION%%/site-packages/pyglade/xmlparse.pyc +lib/%%PYTHON_VERSION%%/site-packages/pyglade/xmlparse.pyo share/doc/py-gtk/MAPPING share/examples/py-gtk/gl/README share/examples/py-gtk/gl/cone.py @@ -83,7 +83,7 @@ share/examples/py-gtk/testgtk/test.xpm share/examples/py-gtk/testgtk/testgtk.py share/examples/py-gtk/testgtk/testgtkrc @dirrm include/pygtk -@dirrm lib/python1.5/site-packages/pyglade +@dirrm lib/%%PYTHON_VERSION%%/site-packages/pyglade @dirrm share/doc/py-gtk @dirrm share/examples/py-gtk/gl @dirrm share/examples/py-gtk/glade diff --git a/x11-toolkits/py-gtk2/Makefile b/x11-toolkits/py-gtk2/Makefile index 4aa8b76312c2..237a1d16a069 100644 --- a/x11-toolkits/py-gtk2/Makefile +++ b/x11-toolkits/py-gtk2/Makefile @@ -14,15 +14,13 @@ DISTNAME= gnome-python-1.0.53 MAINTAINER= nectar@FreeBSD.org -BUILD_DEPENDS= python1.5:${PORTSDIR}/lang/python15 LIB_DEPENDS= gtk12.2:${PORTSDIR}/x11-toolkits/gtk12 \ Imlib.5:${PORTSDIR}/graphics/imlib -RUN_DEPENDS= python1.5:${PORTSDIR}/lang/python15 GTK_CONFIG= ${X11BASE}/bin/gtk12-config USE_GMAKE= yes -CONFIGURE_ENV= GTK_CONFIG=${GTK_CONFIG} -CONFIGURE_ARGS= --with-python=python1.5 +USE_PYTHON= yes +CONFIGURE_ENV= GTK_CONFIG=${GTK_CONFIG} PYTHON=${PREFIX}/bin/${PYTHON_CMD} USE_LIBTOOL= yes PLIST_COMPLETE= ${PKGDIR}/PLIST diff --git a/x11-toolkits/py-gtk2/pkg-plist b/x11-toolkits/py-gtk2/pkg-plist index 7e9eec6fd2ee..a3b39ddc87a6 100644 --- a/x11-toolkits/py-gtk2/pkg-plist +++ b/x11-toolkits/py-gtk2/pkg-plist @@ -1,37 +1,37 @@ include/pygtk/pygdkimlib.h include/pygtk/pygtk.h -lib/python1.5/site-packages/GDK.py -lib/python1.5/site-packages/GDK.pyc -lib/python1.5/site-packages/GDK.pyo -lib/python1.5/site-packages/GTK.py -lib/python1.5/site-packages/GTK.pyc -lib/python1.5/site-packages/GTK.pyo -lib/python1.5/site-packages/GdkImlib.py -lib/python1.5/site-packages/GdkImlib.pyc -lib/python1.5/site-packages/GdkImlib.pyo -lib/python1.5/site-packages/GtkExtra.py -lib/python1.5/site-packages/GtkExtra.pyc -lib/python1.5/site-packages/GtkExtra.pyo -lib/python1.5/site-packages/Gtkinter.py -lib/python1.5/site-packages/Gtkinter.pyc -lib/python1.5/site-packages/Gtkinter.pyo -lib/python1.5/site-packages/_gdkimlibmodule.so -lib/python1.5/site-packages/_gtkmodule.so -lib/python1.5/site-packages/gtk.py -lib/python1.5/site-packages/gtk.pyc -lib/python1.5/site-packages/gtk.pyo -lib/python1.5/site-packages/pyglade/__init__.py -lib/python1.5/site-packages/pyglade/__init__.pyc -lib/python1.5/site-packages/pyglade/__init__.pyo -lib/python1.5/site-packages/pyglade/build.py -lib/python1.5/site-packages/pyglade/build.pyc -lib/python1.5/site-packages/pyglade/build.pyo -lib/python1.5/site-packages/pyglade/style.py -lib/python1.5/site-packages/pyglade/style.pyc -lib/python1.5/site-packages/pyglade/style.pyo -lib/python1.5/site-packages/pyglade/xmlparse.py -lib/python1.5/site-packages/pyglade/xmlparse.pyc -lib/python1.5/site-packages/pyglade/xmlparse.pyo +lib/%%PYTHON_VERSION%%/site-packages/GDK.py +lib/%%PYTHON_VERSION%%/site-packages/GDK.pyc +lib/%%PYTHON_VERSION%%/site-packages/GDK.pyo +lib/%%PYTHON_VERSION%%/site-packages/GTK.py +lib/%%PYTHON_VERSION%%/site-packages/GTK.pyc +lib/%%PYTHON_VERSION%%/site-packages/GTK.pyo +lib/%%PYTHON_VERSION%%/site-packages/GdkImlib.py +lib/%%PYTHON_VERSION%%/site-packages/GdkImlib.pyc +lib/%%PYTHON_VERSION%%/site-packages/GdkImlib.pyo +lib/%%PYTHON_VERSION%%/site-packages/GtkExtra.py +lib/%%PYTHON_VERSION%%/site-packages/GtkExtra.pyc +lib/%%PYTHON_VERSION%%/site-packages/GtkExtra.pyo +lib/%%PYTHON_VERSION%%/site-packages/Gtkinter.py +lib/%%PYTHON_VERSION%%/site-packages/Gtkinter.pyc +lib/%%PYTHON_VERSION%%/site-packages/Gtkinter.pyo +lib/%%PYTHON_VERSION%%/site-packages/_gdkimlibmodule.so +lib/%%PYTHON_VERSION%%/site-packages/_gtkmodule.so +lib/%%PYTHON_VERSION%%/site-packages/gtk.py +lib/%%PYTHON_VERSION%%/site-packages/gtk.pyc +lib/%%PYTHON_VERSION%%/site-packages/gtk.pyo +lib/%%PYTHON_VERSION%%/site-packages/pyglade/__init__.py +lib/%%PYTHON_VERSION%%/site-packages/pyglade/__init__.pyc +lib/%%PYTHON_VERSION%%/site-packages/pyglade/__init__.pyo +lib/%%PYTHON_VERSION%%/site-packages/pyglade/build.py +lib/%%PYTHON_VERSION%%/site-packages/pyglade/build.pyc +lib/%%PYTHON_VERSION%%/site-packages/pyglade/build.pyo +lib/%%PYTHON_VERSION%%/site-packages/pyglade/style.py +lib/%%PYTHON_VERSION%%/site-packages/pyglade/style.pyc +lib/%%PYTHON_VERSION%%/site-packages/pyglade/style.pyo +lib/%%PYTHON_VERSION%%/site-packages/pyglade/xmlparse.py +lib/%%PYTHON_VERSION%%/site-packages/pyglade/xmlparse.pyc +lib/%%PYTHON_VERSION%%/site-packages/pyglade/xmlparse.pyo share/doc/py-gtk/MAPPING share/examples/py-gtk/gl/README share/examples/py-gtk/gl/cone.py @@ -83,7 +83,7 @@ share/examples/py-gtk/testgtk/test.xpm share/examples/py-gtk/testgtk/testgtk.py share/examples/py-gtk/testgtk/testgtkrc @dirrm include/pygtk -@dirrm lib/python1.5/site-packages/pyglade +@dirrm lib/%%PYTHON_VERSION%%/site-packages/pyglade @dirrm share/doc/py-gtk @dirrm share/examples/py-gtk/gl @dirrm share/examples/py-gtk/glade |