os
authorStefan Israelsson Tampe <stefan.itampe@gmail.com>
Mon, 19 Feb 2018 17:12:48 +0000 (18:12 +0100)
committerStefan Israelsson Tampe <stefan.itampe@gmail.com>
Mon, 19 Feb 2018 17:12:48 +0000 (18:12 +0100)
modules/language/python/compile.scm
modules/language/python/for.scm
modules/language/python/list.scm
modules/language/python/module/os.scm [new file with mode: 0644]
modules/language/python/module/python.scm
modules/language/python/module/string.scm
modules/language/python/string.scm

index 75ceba1c0754c01a2a9264f4ff066e9d41bbe7d4..d0e1ca57d383eb1f18cfa5be9a6b50168e62513f 100644 (file)
    ((__setitem__)  (L 'pylist-set!))
    
    ;; String
-   ((format)     (S 'py-format ))
+   ((format)     (S 'py-strformat))
+   ((format_map) (S 'py-format-map))
    ((capitalize) (S 'py-capitalize))
    ((center)     (S 'py-center ))
    ((endswith)   (S 'py-endswith))
    ((upper)      (S 'py-upper  ))
    ((lstrip)     (S 'py-lstrip ))
    ((rstrip)     (S 'py-rstrip ))
-   ((partition)  (S 'py-partiti))
+   ((partition)  (S 'py-partition))
    ((replace)    (S 'py-replace))
    ((strip)      (S 'py-strip  ))
    ((title)      (S 'py-title  ))
index bd9fa41ef180729e4bc0c1c7d3f85078cad65d5b..ec245dfc0dcd893870b7a3132be30cd38b0d9928 100644 (file)
 (define-method (wrap-in (o <yield>))
   o)
 
+(define-method (wrap-in (o <p>))
+  (aif it (ref o '__iter__)
+       (it)
+       (next-method)))
+
 (define-method (next (l <p>))
   ((ref l '__next__)))
 
index 013132814f68d49f1df866f3909241ebae6bb362..5f4fbb783c2873b4e5ec8d5f8d5e8d820a000ae0 100644 (file)
     (to-pylist l)))
 
 (define-method (pylist-slice (o <string>) n1 n2 n3)
-  (define N (slot-ref o 'n))
+  (define N (string-length o))
   (define (f n) (if (< n 0) (+ N n) n))
     
   (let* ((n1   (f (if (eq? n1 None) 0                n1)))
          (n2   (f (if (eq? n2 None) (slot-ref o 'n)  n2)))
          (n3   (f (if (eq? n3 None) 1                n3))))
     (list->string
-     (map (lambda (x) (string-ref x 0))
-          (to-list
-           (pylist-slice (to-pylist o) n1 n2 n3))))))
+     (to-list
+      (pylist-slice (to-pylist o) n1 n2 n3)))))
 
 
 (defpair (pylist-slice o n1 n2 n3)
diff --git a/modules/language/python/module/os.scm b/modules/language/python/module/os.scm
new file mode 100644 (file)
index 0000000..b5b8a18
--- /dev/null
@@ -0,0 +1,63 @@
+(define-module (language python module os)
+  #:use-module (system foreign)
+  #:use-module (oop pf-objects)
+  #:use-module (oop goops)
+  #:use-module (language python for)
+  #:use-module (language python yield)
+  #:use-module (language python string)
+  #:export (error name ctermid environ))
+
+(define error 'OSError)
+(define name  "posix")
+(define ctermid
+  (@ (guile) ctermid))
+    
+
+(define environ
+  (let ()
+    (define e (dereference-pointer (dynamic-pointer "environ" (dynamic-link))))
+    (define (get-envs)
+      (let lp ((e e))
+        (let ((*e  (dereference-pointer e)))
+          (if (null-pointer? *e)
+              '()
+              (cons
+               (pointer->string *e)
+               (lp (make-pointer (+ (pointer-address e) 8))))))))
+    
+    (define (getkw)
+      (let lp ((es (get-envs)))
+        (if (pair? es)
+            (let ((x (string-split (car es) #\=)))
+              (let ((k (car x))
+                    (v (string-join (cdr x) "=")))
+                (cons (cons k v) (lp (cdr es)))))
+            '())))
+
+    (define-python-class Env ()
+      (define __init__
+        (lambda (self) (values)))
+
+      (define __getitem__
+        (lambda (self k)
+          (getenv (slot-ref (pystring k) 'str))))
+
+      (define __setitem__
+        (lambda (self k v) 
+          (putenv (slot-ref (pystring (+ k "=" v)) 'str))))
+
+      (define __delitem__
+        (lambda (self k)
+          (putenv (slot-ref (pystring k) 'str))))
+      
+      (define __iter__
+        (lambda (self)
+          ((make-generator ()
+             (lambda (yield)
+               (for ((x : (getkw))) ()
+                    (yield (car x) (cdr x)))))))))
+    
+    
+    (Env)))
+
+(for ((k v : environ)) () (pk k))
index 69e02b048ad6b7c030af50b128beb2697e9e8a56..2ea57eba8bb1deba3c8e73a74e0e4a250ff9ad81 100644 (file)
@@ -6,6 +6,7 @@
                 (<p> <property> class-method static-method ref
                      py-super-mac type object pylist-ref))
   #:use-module (language python exceptions       )
+  #:use-module ((language python module string   ) #:select ())
   #:use-module (language python def              )
   #:use-module (language python for              )
   #:use-module (language python try              )
index 6ece062fd3f5a6cd7f5b3da5a5f5beed1bdd3b7b..08dabcd9351e199b7c02376c8079cd6b51811d79 100644 (file)
@@ -3,7 +3,6 @@
   #:use-module (oop goops)
   #:use-module (ice-9 match)
   #:use-module (language python number)
-  #:use-module ((language python module python) #:select (repr))
   #:use-module (language python exceptions)
   #:use-module (language python yield)
   #:use-module (language python list)
@@ -13,6 +12,7 @@
   #:use-module (parser stis-parser)
   #:export (Formatter))
 
+(define (repr x) ((@ (guile) format) #f "~a" x))
 (define int (mk-token (f+ (f-reg! "[0-9]")) string->number))
 (define id  (mk-token (f-seq (f-reg! "[_a-zA-Z]")
                              (f* (f-reg! "[_0-9a-zA-Z]")))))
                (values (- s) "-")
                (values s     " "))))))
 
+(define (convert-float s format-str)
+  (match (pk 'conv-float
+             (with-fluids ((*whitespace* f-true))
+               (stis-parse format-str (f-seq formatSpec f-eof))))
+    ((align sign sharp zero width comma prec type)
+     (call-with-values (lambda () (gen-sign s sign))                         
+       (lambda (s s-sign)
+         (let* ((prec (if prec prec 6))
+                (s    (let lp ((type type))
+                        (match type
+                          (#f (lp "g"))
+                          
+                          ("f"
+                           (format #f (+ "~," (number->string prec) "f") s))
+                          
+                          ("F"
+                           (let ((s (format #f (+ "~," (number->string prec)
+                                                  "f")
+                                            s)))
+                             (py-replace
+                              (py-replace s "nan" "NAN")
+                              "inf" "INF")))
+
+                          ("e"
+                           (py-replace
+                            (format #f (+ "~," (number->string prec) "e") s)
+                            "E" "e"))
+
+                          ("E"
+                           (format #f (+ "~," (number->string prec) "e") s))
+                          
+                          ("g"
+                           (let ((exp (log10 (abs s))))
+                             (if (and (<= -4  exp)
+                                      (<= exp (max 1 prec)))
+                                 (lp "f")
+                                 (lp "e"))))
+                          ("G"
+                           (let ((exp (log10 (abs s))))
+                             (if (and (<= -4  exp)
+                                      (<= exp (max 1 prec)))
+                                 (lp "F")
+                                 (lp "E"))))
+                          ("n"
+                           (let ((exp (log10 (abs s))))
+                             (if (and (<= -4  exp)
+                                      (<= exp (max 1 prec)))
+                                 (lp "f")
+                                 (format #f (+ "~," (number->string prec) "h")
+                                         s))))
+
+                          ("%"
+                           (set s (* s 100))
+                           (+ (lp "f") "%"))))))
+                
+           (if width
+               (if zero
+                   (get-align s '(#:align "0" "=") width
+                              s-sign)
+                   (get-align s align width
+                              s-sign))
+                          
+               (+ s-sign s))))))))
+
+(define (convert-complex s format-str)
+  (match (pk 'conv-complex
+             (with-fluids ((*whitespace* f-true))
+               (stis-parse format-str (f-seq formatSpec f-eof))))
+    ((align sign sharp zero width comma prec type)
+     (let* ((prec (if prec prec 6))
+            (s    (let lp ((type type))
+                    (match type
+                      (#f (lp "f"))
+                      ("f"
+                       (format #f (+ "~," (number->string prec) "i") s))))))
+       (if width
+           (get-align s align width "")
+           s)))))
+                
+                        
+(define-method (py-format (s <real>) f)
+  (convert-float s f))
+(define-method (py-format (s <py-float>) f)
+  (convert-float s f))
+
+(define-method (py-format (s <complex>) f)
+  (convert-complex s f))
+(define-method (py-format (s <py-complex>) f)
+  (convert-complex s f))
+
+                        
+                         
+                        
+         
 (define (convert-integer s format-str)
   (match (pk 'conv-int
              (with-fluids ((*whitespace* f-true))
                (s (let lp ((type type))
                     (match type
                       ("b"
-                       (format #f "~b"       s))
+                       (if comma
+                           (format #f "~:b"       s)
+                           (format #f "~b"        s)))
                       ("x"
-                       (format #f "~x"       s))
+                       (if comma
+                           (format #f "~:x"      s)
+                           (format #f "~x"       s)))
                       ("X"
-                       (format #f "~:@(~x~)" s))
+                       (if comma
+                           (format #f "~:@(~:x~)" s)
+                           (format #f "~:@(~x~)"  s)))
                       ("o"
-                       (format #f "~o"       s))
+                       (if comma
+                           (format #f "~:o"      s)
+                           (format #f "~o"       s)))
                       ("d"
                        (if comma
                            (format #f "~:d" s)
                    (get-align (+ prefix s) align width
                               s-sign))
                
-               (+ sign prefix s))))))))
+               (+ s-sign prefix s))))))))
 
 (define-method (py-format (s <integer>) f)
   (convert-integer s f))
                   (lp (+ i 1))
                   (warn "unused arg" i)))))
       (for ((k v : kwargs)) ()
-           (pk 'key k)
            (if (not (member k used_args))
                (warn "unused arg" k)))))
             
        (else
         (throw TypeError "conversion" conversion))))))
 
+(set! (@@ (language python string) formatter) (Formatter))
index 1b9883d0a5de3cb7a14e1d5ce7077ed85f44453a..8d6d642be11c94c6e7f23f7fc75bbd4e76460a44 100644 (file)
@@ -11,7 +11,7 @@
                       py-expandtabs py-find py-rfind
                       py-isalnum py-isalpha py-isdigit py-islower
                       py-isspace py-isupper py-istitle py-join py-ljust
-                      py-rjust
+                      py-rjust py-format-map
                       py-rljust py-lower py-upper py-lstrip py-rstrip
                       py-partition py-replace py-strip py-title
                       py-rpartitio py-rindex py-split py-rsplit py-splitlines
              (- n it (len sub))
              -1)))))
 
+(define formatter #f)
+(define-py (py-strformat format s . l)  
+  (apply (ref formatter 'format) s l))
+
+(define-py (py-format-map format_map s map)  
+  (apply (ref formatter 'vformat) s '() map))
+
 (define format (lambda (a b) a))
 (define-py (py-format format s format-string)
   (format s format-string))
                 (()
                  #\space))))
     (if (< width n)
-        (pylist-slice s 0 width)
+        (pylist-slice s 0 width 1)
         (let ((ret (make-string width ch)))
           (let lp ((i 0))
             (if (< i n)
                (()
                 #\space))))
     (if (< width n)
-        (pylist-slice s (- width) (len s))
+        (pylist-slice s (- width) (len s) 1)
         (let ((ret (make-string width ch)))
           (let lp ((i 0) (j (- width n)))
             (if (< i n)
     (let lp ((i 0))
       (if (< i n)
           (if (test i)
-              (list (pylist-slice s 0 i) sep (pylist-slice s (+ i m) n))
+              (list (pylist-slice s 0 i 1) sep (pylist-slice s (+ i m) n 1))
               (lp (+ i 1)))
           (list s "" "")))))
 
+(define-py (py-partition partition s (sep <py-string>))
+  (py-partition s (slot-ref sep 'str)))
+
+  
 (define-py (py-rpartition rpartition ss (ssep <string>))
   (let* ((s    (string-reverse ss))
          (sep  (string-reverse ssep))
       (if (< i n)
           (if (test i)
               (list (string-reverse
-                     (pylist-slice s (+ i m) n))
+                     (pylist-slice s (+ i m) n 1))
                     ssep
                     (string-reverse
-                     (pylist-slice s 0 i)))
+                     (pylist-slice s 0 i 1)))
               (lp (+ i 1)))
           (list "" "" s)))))
-    
+
+(define-py (py-rpartition rpartition s (sep <py-string>))
+  (py-rpartition s (slot-ref sep 'str)))
+
 (define-py (py-replace replace s old new . l)
   (let ((n (match l (() #f) ((n . _) n))))
     (string-join
                            isdigit islower isspace istitle isupper join
                            ljust lower lstrip partition replace rfind rindex
                            rjust rpartition rsplit rstrip split splitlines
-                           startswith strip swapcase
+                           startswith strip swapcase format_map
                            title translate upper zfill)))))
     (pylist-sort! l)
     l))