select compiles
authorStefan Israelsson Tampe <stefan.itampe@gmail.com>
Wed, 25 Jul 2018 18:45:03 +0000 (20:45 +0200)
committerStefan Israelsson Tampe <stefan.itampe@gmail.com>
Wed, 25 Jul 2018 18:45:03 +0000 (20:45 +0200)
modules/language/python/module/errno.scm
modules/language/python/module/select.scm

index f57bf15..1b1a508 100644 (file)
@@ -1,5 +1,6 @@
 (define-module (language python module errno)
   #:use-module (system foreign)
+  #:use-module (rnrs bytevectors)
   #:use-module (oop pf-objects)
   #:export (errno set_errno errorcode))
 
@@ -13,7 +14,7 @@
   (let* ((f (dynamic-pointer "errno" (dynamic-link)))
          (v (pointer->bytevector f 1)))
     (lambda (x)
-      (bytevector-set! v 0 x))))
+      (bytevector-s8-set! v 0 x))))
 
 (define errorcode (make-hash-table))
 
index ae2f9e6..396b6c8 100644 (file)
@@ -1,9 +1,10 @@
-(define-module (languge python module select)
+(define-module (language python module select)
   #:use-module (language python module errno)
   #:use-module ((language python module os) #:prefix os:)
   #:use-module (language python exceptions)
   #:use-module (language python list)
   #:use-module (language python try)
+  #:use-module (language python def)
   #:use-module (oop pf-objects)
   #:use-module (system foreign)
   #:use-module (rnrs bytevectors)
                    EPOLLONESHOT EPOLLWAKEUP EPOLLEXCLUSIVE EPOLLRDHUP
                    EPOLLRDNORM EPOLLRDBAND EPOLLWRNORM EPOLLWRBAND EPOLLMSG
                    POLLERR POLLHUP POLLNVAL POLLIN POLLOUT POLLRDHUP
-                   POLLPRI POLLREMOVE POLLMSG)
+                   POLLPRI POLLREMOVE POLLMSG))
 
+(define PIPE_BUF 1024)
+  
 (define-syntax-rule (aif it p x y) (let ((it p)) (if it x y)))
 
 (define-syntax-rule (ca code)
@@ -69,8 +72,8 @@
               (list int int int '*))))
     (lambda (efd op fd event)
       (rm (let ((v (make-bytevector 16)))
-            (bytevector-i32-set! 0 event (native-endianness))
-            (bytevector-i64-set! 4 fd    (native-endianness))
+            (bytevector-s32-set! v 0 event (native-endianness))
+            (bytevector-s64-set! v 4 fd    (native-endianness))
             (f efd op fd (bytevector->pointer v)))))))
 
 (defineu epoll-wait
               (list '* int int))))
     (lambda (efd max timout)
       (let ((v (make-pointer 0)))
-        (let ((n (f efd v max timout))
-              (v (pointer->bytevector v (* n 12))))
+        (let* ((n (f efd v max timout))
+               (v (pointer->bytevector v (* n 12))))
           (let lp ((i 0) (l '()))
             (if (< i n)
-                (let ((op (bytevector-i32-ref v (* i 12)
-                                              (nativ-endianness)))
-                      (fd (bytevector-i64-ref v (+ (* i 12) 4)
-                                              (nativ-endianness))))
+                (let ((op (bytevector-s32-ref v (* i 12)
+                                              (native-endianness)))
+                      (fd (bytevector-s64-ref v (+ (* i 12) 4)
+                                              (native-endianness))))
                   (lp (+ i 1) (cons (list op fd) l)))
                 (reverse l))))))))
                 
                      0))))
 
   (define poll
-    (lam ((= timeout -1) (= maxevents -1))
+    (lam (self (= timeout -1) (= maxevents -1))
          (epoll-wait
           (ref self '__fd)
           maxevents
               -1
               (inexact->exact (floor (* 1000 timeout))))))))
       
-
-(define PIPE_BUF 1024)
 (define EPOLLIN  #x1)
 (define EPOLLOUT #x4)
 (define EPOLLPRI #x2)
               (dynamic-func "poll" (dynamic-link))
               (list '* int int))))
     (lambda (fds n timespec)
-      (rm (f fds n (inexact->exact (floor (* 1000 timespac))))))))
+      (rm (f fds n (inexact->exact (floor (* 1000 timespec))))))))
 
 
 (define-python-class poll ()
         (aif it (assoc fd data)
              (set-cdr! it eventmask)
              (begin
-               (errno_set ENOENT)
+               (set_errno ENOENT)
                (raise (error "modifying non existant fd")))))))
 
   (define unregister
 
   (define poll
     (let ((k 8))
-      (lambda* (#:optional (timeout -1))
+      (lambda* (self #:optional (timeout -1))
         (define (make-data-pt data n)
           (let ((v (make-bytevector (* n k))))
             (let lp ((i 0) (l data))
               (if (pair? l)
                   (begin
-                    (bytevector-i32-set! v (* i k)    (caar l)
+                    (bytevector-s32-set! v (* i k)    (caar l)
                                          (native-endianness))
-                    (bytevector-i16-set! v (+ (* i k) 4) (cdar l)
+                    (bytevector-s16-set! v (+ (* i k) 4) (cdar l)
                                          (native-endianness))
-                    (bytevector-i16-set! v (+ (* i k) 6) 0
+                    (bytevector-s16-set! v (+ (* i k) 6) 0
                                          (native-endianness))
                     (lp (+ i 1) (cdr l)))
                   (bytevector->pointer v)))))
                      (values x n))))
           
           (lambda (x n)
-            (let lp ((i 0)) 
-              (if (< i n)
-                  (let ((fd (bytevector-i32-ref v (* i k)
-                                                (nativ-endianness)))
-                        (y  (bytevector-i16-ref v (+ (* i k) 6)
-                                                (nativ-endianness))))
-                    (if (not (= y 0))
-                        (cons (list fd y) (lp (+ i 1)))
-                        (lp (+ i 1))))
-                  '()))))))))
+            (let ((v (pointer->bytevector x (* k n))))
+              (let lp ((i 0)) 
+                (if (< i n)
+                    (let ((fd (bytevector-s32-ref v (* i k)
+                                                  (native-endianness)))
+                          (y  (bytevector-s16-ref v (+ (* i k) 6)
+                                                  (native-endianness))))
+                      (if (not (= y 0))
+                          (cons (list fd y) (lp (+ i 1)))
+                          (lp (+ i 1))))
+                    '())))))))))
 
   
-(define* (select rl wl xl #:optional (timout 0))
+(define* (select rl wl xl #:optional (timeout 0))
   (let ((m (inexact->exact (floor timeout)))
         (n (modulo (inexact->exact (floor (* 1000000 timeout))) 1000000)))
     ((@ (guile) select) (to-list rl) (to-list wl) (to-list xl) m n)))