deepcopy copy works
authorStefan Israelsson Tampe <stefan.itampe@gmail.com>
Wed, 21 Feb 2018 12:57:57 +0000 (13:57 +0100)
committerStefan Israelsson Tampe <stefan.itampe@gmail.com>
Wed, 21 Feb 2018 12:57:57 +0000 (13:57 +0100)
modules/language/python/bytes.scm
modules/language/python/dict.scm
modules/language/python/list.scm
modules/language/python/module/copy.scm [new file with mode: 0644]
modules/language/python/module/string.scm
modules/language/python/number.scm
modules/language/python/persist.scm
modules/language/python/set.scm
modules/language/python/string.scm
modules/language/python/tuple.scm
modules/oop/pf-objects.scm

index 7700a00966cc39676cafa6d420a14068c9502a02..1a0a8af3bf39b1cb30e4e61ce2b41f144c9854a5 100644 (file)
@@ -10,6 +10,7 @@
   #:use-module (language python exceptions)
   #:use-module (language python list)
   #:use-module (language python hash)
+  #:use-module (language python persist)
   #:export (<py-bytes> pybytes-listing bytes bytearray bytes->bytevector
                       <py-bytearray> pybytesarray-listing))
 
 (define-class <py-bytes> () bytes)
 (define-class <py-bytearray> () n vec)
 
+(name-object <py-bytes>)
+(name-object <py-bytearray>)
+
+(cpit <py-bytes> (o (lambda (o n l)
+                     (slot-set! o 'bytes
+                                (let lp ((l l) (i 0) (b (b-make n)))
+                                  (if (pair? l)
+                                      (b-set! b i (car l))
+                                      (lp (cdr l) (+ i 1) b)))))
+                   (let* ((b (slot-ref o 'bytes))
+                          (n (b-len b)))
+                     (list
+                      n
+                      (let lp ((i 0))
+                        (if (< i n)
+                            (cons (b-ref b i) (lp (+ i 1)))
+                            '()))))))
+
+(cpit <py-bytearray> (o (lambda (o n m l)
+                         (slot-set! o 'n m)
+                         (slot-set! o 'vec
+                                    (let lp ((l l) (i 0) (b (b-make n)))
+                                      (if (pair? l)
+                                          (b-set! b i (car l))
+                                          (lp (cdr l) (+ i 1) b)))))
+                       (let* ((b (slot-ref o 'vec))
+                              (n (b-len b)))
+                         (list
+                          n
+                          (slot-ref o 'n)
+                          (let lp ((i 0))
+                            (if (< i n)
+                                (cons (b-ref b i) (lp (+ i 1)))
+                                '()))))))
+
+
 (define-method (b-get (o <bytevector>))
   o)
 (define-method (b-get (o <py-bytes>))
                         (lp (- i 1) (cdr r)))
                       (slot-set! self 'bytes bytes)))))))))))
 
+(name-object bytes)
+
 (define-python-class bytearray (<py-bytearray>)
   (define __init__
     (case-lambda
                       (slot-set! self 'vec bytes)
                       (slot-set! self 'n (b-len bytes)))))))))))))
 
+(name-object bytearray)
+
 (define-syntax-rule (define-py (f o . u) code ...)
   (begin
     (define-method (f (o <bytevector>) . u) code ...)
index b9ab1164e14f9adfc1781008133bfffa2d0df64b..fe18583863a4d8ada3585c970462de1306e89a6d 100644 (file)
@@ -6,6 +6,7 @@
   #:use-module (language python def)
   #:use-module (language python for)
   #:use-module (language python exceptions)
+  #:use-module (language python persist)
   #:use-module (ice-9 match)
   #:use-module (ice-9 control)
   #:use-module (oop goops)
 (define H (hash 1333674836 complexity))
 
 (define-class <py-hashtable> () t h n)
+
+(name-object <py-hashtable>)
+
+(cpit <py-hashtable>
+      (o (lambda (o h n a)
+          (slot-set! o 'h h)
+          (slot-set! o 'n n)
+          (slot-set! o 't
+                     (let ((t (make-hash-table)))
+                       (let lp ((a a))
+                         (if (pair? a)
+                             (begin
+                               (py-hash-set! t (caar a) (cdar a))
+                               (lp (cdr a)))))
+                       t)))
+        (let ((t (slot-ref o 't)))
+          (list
+           (slot-ref o 'h)
+           (slot-ref o 'n)
+           (hash-fold (lambda (k v s) (cons (cons k v) s)) '() t)))))
+
 (define