os

1 files changed, 109 insertions, 7 deletions

diff --git a/modules/language/python/module/string.scm b/modules/language/python/module/string.scm
index 6ece062..08dabcd 100644
--- a/modules/language/python/module/string.scm
+++ b/modules/language/python/module/string.scm
@@ -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]")))))
@@ -78,6 +78,100 @@
                (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))
@@ -97,13 +191,21 @@
                (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)
@@ -117,7 +219,7 @@
                    (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))
@@ -254,7 +356,6 @@
                   (lp (+ i 1))
                   (warn "unused arg" i)))))
       (for ((k v : kwargs)) ()
-           (pk 'key k)
            (if (not (member k used_args))
                (warn "unused arg" k)))))
             
@@ -276,3 +377,4 @@
        (else
         (throw TypeError "conversion" conversion))))))
 
+(set! (@@ (language python string) formatter) (Formatter))