* Modules/xxmodule.c: integrated with xxobject.c by Jack

	* Modules/(posix,socket}module.c: more NT changes

diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index 7ffcd660a75994aae3f7eae6c1639bb342588dc0..59e27a7e7b4675aab8d592185021a516469923eb 100644 (file)
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -76,6 +76,11 @@ extern int symlink();
 #include <utime.h>
 #endif /* HAVE_UTIME_H */
 
+#ifdef HAVE_SYS_UTIME_H
+#include <sys/utime.h>
+#define HAVE_UTIME_H /* pretend we do for the rest of this file */
+#endif /* HAVE_SYS_UTIME_H */
+
 #ifdef HAVE_SYS_TIMES_H
 #include <sys/times.h>
 #endif /* HAVE_SYS_TIMES_H */
@@ -1010,6 +1015,26 @@ posix_times(self, args)
                       (double)t.tms_cstime / HZ);
 }
 #endif /* HAVE_TIMES */
+#ifdef NT
+#define HAVE_TIMES     /* so the method table will pick it up */
+static object *
+posix_times(self, args)
+       object *self;
+       object *args;
+{
+       FILETIME create, exit, kernel, user;
+       HANDLE hProc;
+       if (!getnoarg(args))
+               return NULL;
+       hProc = GetCurrentProcess();
+       GetProcessTimes(hProc,&create, &exit, &kernel, &user);
+       return mkvalue("dddd",
+                      (double)(kernel.dwHighDateTime*2E32+kernel.dwLowDateTime) / 2E6,
+                      (double)(user.dwHighDateTime*2E32+user.dwLowDateTime) / 2E6,
+                      (double)0,
+                      (double)0);
+}
+#endif /* NT */
 
 #ifdef HAVE_SETSID
 static object *

diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index 6f50fc3cca298c77eacd3d95b64f9581fc829edc..82250ee242159a258c2e5d79a6d941b0979dc9b6 100644 (file)
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -153,6 +153,18 @@ static object *SocketError;
 static object *
 socket_error()
 {
+#ifdef NT
+       if (WSAGetLastError()) {
+               object *v;
+               v = mkvalue("(is)", WSAGetLastError(), "winsock error");
+               if (v != NULL) {
+                       err_setval(SocketError, v);
+                       DECREF(v);
+               }
+               return NULL;
+       }
+       else
+#endif
        return err_errno(SocketError);
 }
 

diff --git a/Modules/xxmodule.c b/Modules/xxmodule.c
index 4e81810cf41cee88b0020213a9622ed5afed6ab6..52f48954e53f18c786420b530f300837bc5b9f2d 100644 (file)
--- a/Modules/xxmodule.c
+++ b/Modules/xxmodule.c
@@ -22,11 +22,129 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 ******************************************************************/
 
-/* xx module */
+/* Use this file as a template to start implementing a module that
+   also declares objects types. All occurrences of 'xxo' should be changed
+   to something reasonable for your objects. After that, all other
+   occurrences of 'xx' should be changed to something reasonable for your
+   module. If your module is named foo your sourcefile should be named
+   foomodule.c.
+   
+   You will probably want to delete all references to 'x_attr' and add
+   your own types of attributes instead.  Maybe you want to name your
+   local variables other than 'self'.  If your object type is needed in
+   other files, you'll have to create a file "foobarobject.h"; see
+   intobject.h for an example. */
+
+/* Xxo objects */
 
 #include "allobjects.h"
-#include "modsupport.h"
+#include "modsupport.h"                /* For getargs() etc. */
 
+static object *ErrorObject;
+
+typedef struct {
+       OB_HEAD
+       object  *x_attr;        /* Attributes dictionary */
+} xxoobject;
+
+staticforward typeobject Xxotype;
+
+#define is_xxoobject(v)                ((v)->ob_type == &Xxotype)
+
+static xxoobject *
+newxxoobject(arg)
+       object *arg;
+{
+       xxoobject *self;
+       self = NEWOBJ(xxoobject, &Xxotype);
+       if (self == NULL)
+               return NULL;
+       self->x_attr = NULL;
+       return self;
+}
+
+/* Xxo methods */
+
+static void
+xxo_dealloc(self)
+       xxoobject *self;
+{
+       XDECREF(self->x_attr);
+       DEL(self);
+}
+
+static object *
+xxo_demo(self, args)
+       xxoobject *self;
+       object *args;
+{
+       if (!getnoarg(args))
+               return NULL;
+       INCREF(None);
+       return None;
+}
+
+static struct methodlist xxo_methods[] = {
+       {"demo",        (method)xxo_demo},
+       {NULL,          NULL}           /* sentinel */
+};
+
+static object *
+xxo_getattr(self, name)
+       xxoobject *self;
+       char *name;
+{
+       if (self->x_attr != NULL) {
+               object *v = dictlookup(self->x_attr, name);
+               if (v != NULL) {
+                       INCREF(v);
+                       return v;
+               }
+       }
+       return findmethod(xxo_methods, (object *)self, name);
+}
+
+static int
+xxo_setattr(self, name, v)
+       xxoobject *self;
+       char *name;
+       object *v;
+{
+       if (self->x_attr == NULL) {
+               self->x_attr = newdictobject();
+               if (self->x_attr == NULL)
+                       return -1;
+       }
+       if (v == NULL) {
+               int rv = dictremove(self->x_attr, name);
+               if (rv < 0)
+                       err_setstr(AttributeError,
+                               "delete non-existing xxo attribute");
+               return rv;
+       }
+       else
+               return dictinsert(self->x_attr, name, v);
+}
+
+static typeobject Xxotype = {
+       OB_HEAD_INIT(&Typetype)
+       0,                      /*ob_size*/
+       "xxo",                  /*tp_name*/
+       sizeof(xxoobject),      /*tp_basicsize*/
+       0,                      /*tp_itemsize*/
+       /* methods */
+       (destructor)xxo_dealloc, /*tp_dealloc*/
+       0,                      /*tp_print*/
+       (getattrfunc)xxo_getattr, /*tp_getattr*/
+       (setattrfunc)xxo_setattr, /*tp_setattr*/
+       0,                      /*tp_compare*/
+       0,                      /*tp_repr*/
+       0,                      /*tp_as_number*/
+       0,                      /*tp_as_sequence*/
+       0,                      /*tp_as_mapping*/
+       0,                      /*tp_hash*/
+};
+/* --------------------------------------------------------------------- */
 
 /* Function of two integers returning integer */
 
@@ -44,19 +162,22 @@ xx_foo(self, args)
 }
 
 
-/* Function of no arguments returning None */
+/* Function of no arguments returning new xxo object */
 
 static object *
-xx_bar(self, args)
+xx_new(self, args)
        object *self; /* Not used */
        object *args;
 {
        int i, j;
+       xxoobject *rv;
+       
        if (!getnoarg(args))
                return NULL;
-       /* XXX Do something here */
-       INCREF(None);
-       return None;
+       rv = newxxoobject(args);
+       if ( rv == NULL )
+           return NULL;
+       return (object *)rv;
 }
 
 
@@ -64,7 +185,7 @@ xx_bar(self, args)
 
 static struct methodlist xx_methods[] = {
        {"foo",         xx_foo},
-       {"bar",         xx_bar},
+       {"new",         xx_new},
        {NULL,          NULL}           /* sentinel */
 };
 
@@ -74,17 +195,15 @@ static struct methodlist xx_methods[] = {
 void
 initxx()
 {
-       object *m, *d, *x;
+       object *m, *d;
 
        /* Create the module and add the functions */
        m = initmodule("xx", xx_methods);
 
        /* Add some symbolic constants to the module */
        d = getmoduledict(m);
-       x = newstringobject("xx.error");
-       dictinsert(d, "error", x);
-       x = newintobject(42L);
-       dictinsert(d, "magic", x);
+       ErrorObject = newstringobject("xx.error");
+       dictinsert(d, "error", ErrorObject);
 
        /* Check for errors */
        if (err_occurred())