gettext works
authorStefan Israelsson Tampe <stefan.itampe@gmail.com>
Tue, 14 Aug 2018 16:32:35 +0000 (18:32 +0200)
committerStefan Israelsson Tampe <stefan.itampe@gmail.com>
Tue, 14 Aug 2018 16:32:35 +0000 (18:32 +0200)
modules/language/python/bytes.scm
modules/language/python/compile.scm
modules/language/python/dict.scm
modules/language/python/exceptions.scm
modules/language/python/module/copy.scm
modules/language/python/module/gettext.py
modules/language/python/module/struct.scm
modules/language/python/string.scm

index d9ccab26cc9dc5551f0dc3f41113752cb1d284cb..494fd287d1314f386bfc9e89c15448e95a496472 100644 (file)
     (pylist-sort! l)
     l))
 
+(define (_in x y n)
+  (let lp ((i 0))
+    (if (< i n)
+        (if (= (b-ref y i) x)
+            #t
+            (lp (+ i 1)))
+        #f)))
+
+(define (_in2 x y n)
+  (let lp ((i 0))
+    (if (< i n)
+        (let lp2 ((j i) (r x))
+          (if (null? r)
+              #t
+              (if (< j n)
+                  (if (= (b-ref y j) (car r))
+                      (lp2 (+ j 1) (cdr r))
+                      (lp (+ i 1)))
+                  #f)))
+        #f)))
+
+(define-method (in (x <integer>) (b <bytevector>))
+  (_in x b (len b)))
+(define-method (in (x <integer>) (b <py-bytes>))
+  (_in x (slot-ref b 'bytes) (len b)))
+(define-method (in (x <integer>) (b <py-bytearray>))
+  (_in x (slot-ref b 'vec) (len b)))
+
+(define-method (in (x <pair>) (b <bytevector>))
+  (_in2 x b (len b)))
+(define-method (in (x <pair>) (b <py-bytes>))
+  (_in2 x (slot-ref b 'bytes) (len b)))
+(define-method (in (x <pair>) (b <py-bytearray>))
+  (_in2 x (slot-ref b 'vec) (len b)))
+
+(define-method (in (x <bytevector>) b)
+  (in (b->list x) b))
+(define-method (in (x <py-bytes>) b)
+  (in (b->list x) b))
+(define-method (in (x <py-bytearray>) b)
+  (in (b->list x) b))
+
+
 (set! (@@ (language python string) bytes) bytes)
+(set! (@@ (language python string) b?)
+  (lambda (x)
+    (or (is-a? x <bytevector>)
+        (is-a? x <py-bytes>)
+        (is-a? x <py-bytearray>))))
+(set! (@@ (language python string) b-decode) py-decode)
+
+(define b-enc   #f)
index 087d22799607c74c74bab09091e86f54ec72bd85..5f27706f627f4435b3cf9231d033640a92293647 100644 (file)
        #'(if (pair? a)
              (let/ec break-ret
                (let lp ((l a))
+                 (pk 'l l)
                  (if (pair? l)
                      (begin
                        (set! x (car l))
+                       (pk 'x x)
                        (with-sp ((continue (values))
                                  (break    (break-ret)))
                                 code)
            (let/ec break-ret
              (let lp ((l a))
                (if (pair? l)
-                   (let/ec continue-ret
-                     (set! x (car l))
-                     (with-sp ((continue (continue-ret))
-                               (break    (break-ret)))                     
-                              code))
-                   (lp (cdr l)))))
+                   (begin
+                     (let/ec continue-ret
+                       (set! x (car l))
+                       (with-sp ((continue (continue-ret))
+                                 (break    (break-ret)))                     
+                                code))
+                     (lp (cdr l))))))
            (for/adv1 (x) (a) code #f #t)))
 
     ((_ (x) (a) code next #f)
index 1d825b6b6c92283dbf3334e070c8e4a34c1c7d76..194da2db26e63e2c918fee69cb6161738e800141 100644 (file)
 
 (define-py (py-setdefault setdefault o k . l)
   (<hashtable>
-   (pylist-set! o k (apply py-get o k l)))
+   (pylist-set! o k (apply py-get o k l))
+   (apply py-get o k l))
+                
   (<py-hashtable>
-   (pylist-set! o k (apply py-get o k l))))
+   (pylist-set! o k (apply py-get o k l))
+   (apply py-get o k l)))
 
 (define update
   (lam (o (* L) (** K))
index 25c565f6cecd700d0dc3cfd126a5e6ddd9feb373..60aff9329ed867df55e79157806679b37a84b776 100644 (file)
@@ -11,7 +11,7 @@
                           ModuleNotFoundError BlockingIOError
                           InterruptedError BaseException
                          ZeroDivisionError ArithmeticError
-                         OverflowError))
+                         OverflowError RecursionError))
 
 (define-syntax-rule (aif it p x y) (let ((it p)) (if it x y)))
 
@@ -48,6 +48,7 @@
 (define StopIteration           'StopIteration)
 (define GeneratorExit           'GeneratorExit)
 (define-er  OverflowError       'OverflowError)
+(define-er  RecursionError      'RecursionError)
 (define-er  ArithmeticError     'ArithmeticError)
 (define-er  BaseException       'BaseException)
 (define-er  ZeroDivisionError   'ZeroDivisionError)
index 2673e7ec48d9ad8ee79ca60b256228a417dc759b..795fff1a6ed5f85c33b80761f99a38fc87f20232 100644 (file)
@@ -1,7 +1,12 @@
 (define-module (language python module copy)
+  #:use-module (ice-9 match)
   #:export (Error copy deepcopy))
 
 (define Error 'CopyError)
 
-(define (copy     x) ((@@ (logic guile-log persistance)      copy) x))
-(define (deepcopy x) ((@@ (logic guile-log persistance) deep-copy) x))
+(define (s x)
+  (match x
+    ((#:obj x) x)
+    (x x)))
+(define (copy     x) (s ((@@ (logic guile-log persistance)      copy) x)))
+(define (deepcopy x) (S ((@@ (logic guile-log persistance) deep-copy) x)))
index 80a9ebeeb2e58016bbbf73b1940c945ac7e0655c..0ea54aa4014d205bc275972584cdf24f58f1007a 100644 (file)
@@ -335,26 +335,18 @@ class GNUTranslations(NullTranslations):
 
     def _parse(self, fp):
         """Override this method to support alternative .mo formats."""
-        pk('_parse')
-        unpack = pk('unpack',struct.unpack)
-        pk(1)
+        unpack = struct.unpack
         filename = getattr(fp, 'name', '')
-        pk(2,filename)
         # Parse the .mo file header, which consists of 5 little endian 32
         # bit words.
         self._catalog = catalog = {}        
         self.plural = lambda n: int(n != 1) # germanic plural by default
-        pk(3)
         buf = fp.read()
         buflen = len(buf)
-        pk(4,buf)
         # Are we big endian or little endian?
         magic = unpack('<I', buf[:4])[0]
-        pk('magic')
-        pk('magic',magic,'LE',self.LE_MAGIC,'BE',self.BE_MAGIC)
         if magic == self.LE_MAGIC:
             version, msgcount, masteridx, transidx = unpack('<4I', buf[4:20])
-            pk(version,msgcount,masteridx,transidx)
             ii = '<II'
         elif magic == self.BE_MAGIC:
             version, msgcount, masteridx, transidx = unpack('>4I', buf[4:20])
@@ -363,7 +355,6 @@ class GNUTranslations(NullTranslations):
             raise OSError(0, 'Bad magic number', filename)
 
         major_version, minor_version = self._get_versions(version)
-        pk('version',major_version,self.VERSIONS)
         if major_version not in self.VERSIONS:
             raise OSError(0, 'Bad version number ' + str(major_version), filename)
 
@@ -379,15 +370,13 @@ class GNUTranslations(NullTranslations):
                 tmsg = buf[toff:tend]
             else:
                 raise OSError(0, 'File is corrupt', filename)
-            pk('msg',mlen,tlen,msg,tmsg)
+
             # See if we're looking at GNU .mo conventions for metadata
             if mlen == 0:
                 # Catalog description
                 lastk = None
-                for b_item in pk('split',tmsg.split(b'\n')):
-                    pk('item',b_item)
+                for b_item in tmsg.split(b'\n'):
                     item = b_item.decode().strip()
-                    pk('decode',item)
                     if not item:
                         continue
                     k = v = None
@@ -395,20 +384,16 @@ class GNUTranslations(NullTranslations):
                         k, v = item.split(':', 1)
                         k = k.strip().lower()
                         v = v.strip()
-                        pk('pair',k,v)
                         self._info[k] = v
                         lastk = k
                     elif lastk:
                         self._info[lastk] += '\n' + item
-                        pk('lastk',lastk,self._info[lastk])
                     if k == 'content-type':
                         self._charset = v.split('charset=')[1]
-                        pk('charset',self._charset)
                     elif k == 'plural-forms':
                         v = v.split(';')
                         plural = v[1].split('plural=')[1]
                         self.plural = c2py(plural)
-                        pk('plural',self.plural)
             # Note: we unconditionally convert both msgids and msgstrs to
             # Unicode using the character encoding specified in the charset
             # parameter of the Content-Type header.  The gettext documentation
@@ -548,19 +533,16 @@ def translation(domain, localedir=None, languages=None,
     # once.
     result = None
     for mofile in mofiles:
-        pk('mofile',mofile)
-        key = pk((class_, os.path.abspath(mofile)))
-        t = pk('tr',_translations.get(key))
+        key = (class_, os.path.abspath(mofile))
+        t = _translations.get(key)
         if t is None:
             with open(mofile, 'rb') as fp:
-                pk('process')
-                t = _translations.setdefault(key, pk('cl',class_(fp)))
+                t = _translations.setdefault(key, class_(fp))
         # Copy the translation object to allow setting fallbacks and
         # output charset. All other instance data is shared with the
         # cached object.
-        pk('t1',t)
         t = copy.copy(t)
-        pk('t2',t)
+
         if codeset:
             t.set_output_charset(codeset)
         if result is None:
index 05b38f23ea44a31ca65b1ab0a3d84985d5a631a1..66496d342fddb17b92b1763363b182a29d5e0b62 100644 (file)
   (define c-i4
     (lambda (k)
       (lambda (bv i)
-        (pk bv i)
         (cons (bytevector-s32-ref bv i end)
               (k bv (incr i 4))))))
 
    (bv-scm bv) n))
               
 (define (unpack format buffer)  
-  (unpacker (pk (analyze format)) buffer 0))
+  (unpacker (analyze format) buffer 0))
 
 (define unpack_from
   (lam (format buffer (= offset 0)) 
index 7ed0193024ccd7803f784777a680f03bfdb3b384..7d5bdd7dbd81565937d1733d657f1d0816ac2d48 100644 (file)
 
 (define bytes #f)
 
+(define (geterr errors)
+  (set! errors   (py-lower (scm-str errors)))
+  (cond
+   ((equal? errors "strict")
+    'error)
+   ((equal? errors "escape")
+    'escape)
+   ((equal? errors "replace")
+    'substitute)
+   ((equal? errors "ignore")
+    (warn
+     (string-append
+      "not possible to use ignore "
+      "encodong error strategy "
+      "using replace in stead"))
+    'substitute)
+   (else
+    (warn
+     "not a correct encodong error strategy")
+    'error)))
+
 (define-py (py-encode encode s . l) 
   (apply (lam ((= encoding "UTF-8") (= errors "strict"))       
-             (set! errors   (py-lower (scm-str errors)))
-             (set! errors   (cond
-                             ((equal? errors "strict")
-                              'error)
-                             ((equal? errors "escape")
-                              'escape)
-                             ((equal? errors "replace")
-                              'substitute)
-                             ((equal? errors "ignore")
-                              (warn
-                               (string-append
-                                "not possible to use ignore "
-                                "encodong error strategy "
-                                "using replace in stead"))
-                              'substitute)
-                             (else
-                              (warn
-                               "not a correct encodong error strategy")
-                              'error)))
              (set! encoding (py-upper (scm-str encoding)))
-
+              (set! errors (geterr errors))
              (bytes (string->bytevector (scm-str s) encoding errors)))
         l))
 
                 (lp (+ i 1))))
           s))))
 
+(define b?       #f)
+(define b-decode #f)
 (define-python-class string (<py-string>)
   (define __init__
     (case-lambda
-     ((self s)  
-       (cond
-        ((is-a? s <py-string>)
-         (slot-ref s 'str))
-        ((is-a? s <string>)
-         s)
-       (else
-        (aif it (ref s '__str__)
-             (it)
-             (__init__ self ((@ (guile) format) #f "~a" s))))))))
+     ((self s . l)  
+      (cond
+       ((is-a? s <py-string>)
+        (slot-ref s 'str))
+       ((is-a? s <string>)
+        s)
+       ((b? s)
+        (apply b-decode s l))
+       (else
+        (aif it (ref s '__str__)
+             (it)
+             (__init__ self ((@ (guile) format) #f "~a" s))))))))
+       
   
   (define __new__
     (lambda x