enum class almost loading
authorStefan Israelsson Tampe <stefan.itampe@gmail.com>
Mon, 16 Apr 2018 19:49:02 +0000 (21:49 +0200)
committerStefan Israelsson Tampe <stefan.itampe@gmail.com>
Mon, 16 Apr 2018 19:49:02 +0000 (21:49 +0200)
modules/language/python/compile.scm
modules/language/python/module/enum.py
modules/oop/pf-objects.scm

index a54dab8e1fc9904cc469b5b517a5b3c4b508f8c5..93adc75a68b490138891b6e9e8dd2ab2a89f0b78 100644 (file)
         (let* ((es2   (map (g vs exp) es))
                (vs2   (union es2 vs))
                (code2 (exp vs2 code))
-               (p     (is-ec #t code2 #t (list (C 'break) (C 'continue))))
+               (p     (is-ec #t code2 #t (list (C 'continue))))
                (else2 (if else (exp vs2 else) #f))
                (in2   (map (g vs exp) in)))
           (list (C 'cfor) es2 in2 code2 else2 p)))))))
                     (,(C 'with-return) ,r
                      ,(mk `(let ,(map (lambda (x) (list x #f)) ls)
                              (,(C 'with-self) ,c? ,aa
-                             ,(with-fluids ((return r))
+                              ,(with-fluids ((return r))
                                 (exp ns code))))))))))
             
            (if y?
                 ,(make-set vs op (car l) (exp vs (car u)))
                 (values))
              `(begin
-                @,(map (lambda (l u) (make-set vs op l u))
+                ,@(map (lambda (l u) (make-set vs op l u))
                        l
                        (map (g vs exp) u))
                 (values))))
                 ,(make-set vs op (car l) (exp vs (car u)))
                 ,(exp vs (car l)))
              `(begin
-                @,(map (lambda (l u) (make-set vs op l u))
+                ,@(map (lambda (l u) (make-set vs op l u))
                        l
                        (map (g vs exp) u))
                 (values ,@(map (g exp vs) l)))))
   (syntax-parameterize ((x (lambda (y) #'v)) ...) code ...))
 
 (define (is-ec ret x tail tags)
-  (syntax-case (pr 'is-ec x) (begin let if define @@)
+  (syntax-case (pr 'is-ec x) (begin let if define set! @@)
     ((begin a ... b)
      #t
      (or
     ((define . _)
      #t
      #f)
+
+    ((set! . _)
+     #t
+     #f)
     
     ((if p a)
      #t
   (syntax-rules ()
     ((_ (x) (a) code #f #f)
      (if (pair? a)
-         (let lp ((l a))
-           (if (pair? l)
-               (begin
-                 (set! x (car l))
-                 (with-sp ((continue (lp (cdr l)))
-                           (break    (values)))                          
-                          code
-                          (lp (cdr l))))))
+         (let/ec break-ret
+           (let lp ((l a))
+             (if (pair? l)
+                 (begin
+                   (set! x (car l))
+                   (with-sp ((continue (values))
+                             (break    (break-ret)))
+                            code)
+                   (lp (cdr l))))))
          (for/adv1 (x) (a) code #f #f)))
 
     ((_ (x) (a) code #f #t)
          (let/ec break-ret
            (let lp ((l a))
              (if (pair? l)
-                 (begin
-                   (let/ec continue-ret
-                     (set! x (car l))
-                     (with-sp ((continue (continue-ret))
-                               (break    (break-ret)))                     
-                              code))
-                   (lp (cdr l))))))
+                 (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)
      (if (pair? a)
          (let/ec break-ret
-           (let ((x (let lp ((l a) (old #f))
-                      (if (pair? l)
-                          (begin
-                            (set! x (car l))
-                            (let/ec continue-ret
-                              (with-sp ((continue (continue-ret))
-                                        (break    (break-ret)))
-                                       code))
-                            (lp (cdr l)))
-                          old))))
-             next))
+           (let lp ((l a))
+             (if (pair? l)
+                 (begin
+                   (set! x (car l))
+                   (with-sp ((continue (values))
+                             (break    (break-ret)))
+                      code))
+                 (lp (cdr l))))
+           next)
+         (for/adv1 (x) (a) code next #f)))
+
+    ((_ (x) (a) code next #t)
+     (if (pair? a)
+         (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))))
+           next)
          (for/adv1 (x) (a) code next #f)))
     
     ((_ x a code next p)
index 1549862cb8d389c052ca4d9d9a24b4b0bd5e64ed..7e7e46ceda49306e98fd1ee43b7301bb6cd88a79 100644 (file)
@@ -118,7 +118,6 @@ class EnumMeta(type):
     def __prepare__(metacls, cls, bases):
         # create the namespace dict
         enum_dict = _EnumDict()
-        pk('got dict')
         
         # inherit previous flags and _generate_next_value_ function
         member_type, first_enum = metacls._get_mixins_(bases)
@@ -133,37 +132,36 @@ class EnumMeta(type):
         # cannot be mixed with other types (int, float, etc.) if it has an
         # inherited __new__ unless a new __new__ is defined (or the resulting
         # class will fail).
-        pk('new enum meta')
         member_type, first_enum = metacls._get_mixins_(bases)
         __new__, save_new, use_args = metacls._find_new_(classdict, member_type,
                                                         first_enum)
-        pk(1)
+
         # save enum items into separate mapping so they don't get baked into
         # the new class
         enum_members = {k: classdict[k] for k in classdict._member_names}
         for name in classdict._member_names:
             del classdict[name]
-        pk(2)
+
         # adjust the sunders
         _order_ = classdict.pop('_order_', None)
-        pk(3)
+
         # check for illegal enum names (any others?)
         invalid_names = set(enum_members) & {'mro', }
         if invalid_names:
             raise ValueError('Invalid enum member name: {0}'.format(
                 ','.join(invalid_names)))
-        pk(4)
+
         # create a default docstring if one has not been provided
         if '__doc__' not in classdict:
             classdict['__doc__'] = 'An enumeration.'
-        pk(5)
+
         # create our new Enum type
         enum_class = super().__new__(metacls, cls, bases, classdict)
         
         enum_class._member_names_ = []               # names in definition order
         enum_class._member_map_ = OrderedDict()      # name->value map
         enum_class._member_type_ = member_type
-        pk(6)
+
         # save attributes from super classes so we know if we can take
         # the shortcut of storing members in the class dict
 
@@ -171,7 +169,7 @@ class EnumMeta(type):
 
         # Reverse value->name map for hashable values.
         enum_class._value2member_map_ = {}
-        pk(7)
+
         # If a custom type is mixed into the Enum, and it does not know how
         # to pickle itself, pickle.dumps will succeed but pickle.loads will
         # fail.  Rather than have the error show up later and possibly far
@@ -188,7 +186,7 @@ class EnumMeta(type):
                         '__reduce_ex__', '__reduce__')
                 if not any(m in member_type.__dict__ for m in methods):
                     _make_class_unpicklable(enum_class)
-        pk(8)
+
         # instantiate them, checking for duplicates as we go
         # we instantiate first instead of checking for duplicates first in case
         # a custom __new__ is doing something funky with the values -- such as
@@ -238,7 +236,7 @@ class EnumMeta(type):
                 enum_class._value2member_map_[value] = enum_member
             except TypeError:
                 pass
-        pk(9)
+
         # double check that repr and friends are not the mixin's or various
         # things break (such as pickle)
         for name in ('__repr__', '__str__', '__format__', '__reduce_ex__'):
@@ -247,7 +245,7 @@ class EnumMeta(type):
             enum_method = getattr(first_enum, name, None)
             if obj_method is not None and obj_method is class_method:
                 setattr(enum_class, name, enum_method)
-        pk(10)
+
         # replace any other __new__ with our own (as long as Enum is not None,
         # anyway) -- again, this is to support pickle
         if Enum is not None:
@@ -256,14 +254,14 @@ class EnumMeta(type):
             if save_new:
                 enum_class.__new_member__ = __new__
             enum_class.__new__ = Enum.__new__
-        pk(11)
+
         # py3 support for definition order (helps keep py2/py3 code in sync)
         if _order_ is not None:
             if isinstance(_order_, str):
                 _order_ = _order_.replace(',', ' ').split()
             if _order_ != enum_class._member_names_:
                 raise TypeError('member order does not match _order_')
-        pk(12)
+        pk('enum class fom new',enum_class)
         return enum_class
 
     def __bool__(self):
@@ -432,10 +430,10 @@ class EnumMeta(type):
         bases: the tuple of bases that was given to __new__
 
         """
-        pk('bases',bases)
+
         if not bases:
             return object, Enum
-        pk(2)
+
         # double check that we are not subclassing a class with existing
         # enumeration members; while we're at it, see if any other data
         # type has been mixed in so we can use the correct __new__
@@ -445,9 +443,7 @@ class EnumMeta(type):
                     issubclass(base, Enum) and
                     base._member_names_):
                 raise TypeError("Cannot extend enumerations")
-        pk(3)
-        pk(base)
-        pk(bases)
+
         # base is now the last base in bases
         if not issubclass(base, Enum):
             raise TypeError("new enumerations must be created as "
@@ -485,12 +481,12 @@ class EnumMeta(type):
         # now find the correct __new__, checking to see of one was defined
         # by the user; also check earlier enum classes in case a __new__ was
         # saved as __new_member__
-        pk(0)
+
         __new__ = classdict.get('__new__', None)
-        pk(1)
+
         # should __new__ be saved as __new_member__ later?
         save_new = __new__ is not None
-        pk(2)
+
         if __new__ is None:
             # check all possibles for __new_member__ before falling back to
             # __new__
@@ -509,7 +505,7 @@ class EnumMeta(type):
                     break
             else:
                 __new__ = object.__new__
-        pk(3)
+
         # if a non-object.__new__ is used then whatever value/tuple was
         # assigned to the enum member name will be passed to __new__ and to the
         # new enum member's __init__
@@ -517,9 +513,10 @@ class EnumMeta(type):
             use_args = False
         else:
             use_args = True
-        pk(4)
+
         return __new__, save_new, use_args
 
+pk(1)
 class Enum(metaclass=EnumMeta):
     """Generic enumeration.
 
@@ -649,7 +646,7 @@ class Enum(metaclass=EnumMeta):
         module_globals[name] = cls
         return cls
 
-pk(6)
+pk(2)
 
 class IntEnum(int, Enum):
     """Enum where members are also (and must be) ints"""
index 9ebce3ff9d9a3d26bd4fc9e07f5c2277d43f3811..479c035336de2a291d8916914e8efef6b84e8772 100644 (file)
@@ -210,7 +210,6 @@ explicitly tell it to not update etc.
 
 
 (define (new-class0 meta name parents dict . kw)
-  (pk 'new-class0)
   (let* ((goops (pylist-ref dict '__goops__))
         (p     (kwclass->class kw meta))         
         (class (make-p p)))
@@ -241,26 +240,23 @@ explicitly tell it to not update etc.
     class))
 
 (define (new-class meta name parents dict kw)
-  (pk 'new-class)
   (aif it (and meta (ficap meta '__new__ #f))
        (apply it meta name parents dict kw)
        (apply new-class0 meta name parents dict kw)))
 
 (define (type- meta name parents dict keys)
-  (pk 'type-)
   (let ((class (new-class meta name parents dict keys)))
-    (aif it (and meta (find-in-class meta '__init__ #f))
+    (aif it (and meta (find-in-class-and-parents meta '__init__ #f))
          (it class name parents dict keys)
          #f)
-    class))
+    (pk 'res class)))
 
 
 (define (the-create-object class x)
-  (pk 'the-create-object)
   (let* ((meta  (ref class '__class__))
          (goops (ref class '__goops__))
-         (obj   (aif it (pk '__new__ (ficap class '__new__ #f))
-                     (begin (pk-obj class) (apply it class x))
+         (obj   (aif it (ficap class '__new__ #f)
+                     (apply it class x)
                      (make-object class meta goops))))
     
     (aif it (ref obj '__init__)
@@ -276,8 +272,7 @@ explicitly tell it to not update etc.
     obj))
 
 (define (create-object class x)
-  (pk 'create-object)
-  (if (pk 'type? (pytype? class))
+  (if (pytype? class)
       (apply type-call class x)
       (let ((meta (find-in-class class '__class__ #f)))
        (with-fluids ((*make-class* #t))
@@ -287,8 +282,7 @@ explicitly tell it to not update etc.
 
 (define type-call
   (lambda (class . l)
-    (pk 'type-call)
-    (if (pk 'type? (pytype? class))
+    (if (pytype? class)
         (apply (case-lambda
                  ((meta obj)
                   (ref obj '__class__ 'None))
@@ -303,7 +297,6 @@ explicitly tell it to not update etc.
        (make-hash-table)))
 
 (define (create-class meta name parents gen-methods keys)
-  (pk 'create-class)
   (let ((dict (gen-methods (get-dict meta name parents))))
     (aif it (ref meta '__class__)
          (aif it (find-in-class it '__call__ #f)
@@ -312,7 +305,6 @@ explicitly tell it to not update etc.
          (type- meta name parents dict keys))))
 
 (define (make-object class meta goops)
-  (pk 'make-object)
   (let ((obj (make-p goops)))
     (set obj '__class__ class)
     obj))
@@ -867,6 +859,7 @@ explicitly tell it to not update etc.
 
     (let ((cl (with-fluids ((*make-class* #t))
                 (create-class meta name parents gen-methods kw))))
+      (pk 'got cl)
       (aif it (ref meta '__init_subclass__)
           (let lp ((ps cparents))
             (if (pair? ps)
@@ -874,7 +867,7 @@ explicitly tell it to not update etc.
                   (it cl super)
                   (lp (cdr ps)))))
           #f)
-      
+      (pk 'return)
       cl))))
                    
 
@@ -976,22 +969,26 @@ explicitly tell it to not update etc.
        #'(let ()
            (define name 
              (letruc ((dname (make-up dval)) ...)
-                 body
-                 (make-p-class 'name doc
-                               parents
-                               (lambda (dict)
-                                 (pylist-set! dict 'dname dname)
-                                 ...
-                                 (values)))))
-
+                      body
+                      (make-p-class 'name doc
+                                    parents
+                                    (lambda (dict)
+                                      (pylist-set! dict 'dname dname)
+                                      ...
+                                      (values)))))
+
+            (pk 1)
            (begin
+              (pk 'ddname 'dname)
              (module-define! (current-module) 'ddname (ref name 'dname))
+              (pk '*)
              (name-object ddname))
            ...
-
+            (pk 2)
            (module-define! (current-module) 'nname (ref name '__goops__))
            (name-object nname)
            (name-object name)
+            (pk 3)
            name))))))
 
 (define-syntax mk-p-class-noname
@@ -1301,20 +1298,20 @@ explicitly tell it to not update etc.
        '()))
 
 (set! type
-      (make-python-class type ()
-       (define __new__           new-class0)
-       (define __init_subclass__ (lambda x (values)))
-       (define ___zub_classes__  (make-weak-key-hash-table))
-       (define __subclasses__    subclasses)
-        (define __call__          type-call)
-        (define mro               (lambda (self) (ref self '__mro__)))))
+  (make-python-class type ()
+     (define __new__           new-class0)
+     (define __init_subclass__ (lambda x (values)))
+     (define ___zub_classes__  (make-weak-key-hash-table))
+     (define __subclasses__    subclasses)
+     (define __call__          type-call)
+     (define mro               (lambda (self) (ref self '__mro__)))))
 
 (set type '__class__ type)
 
 (set! object (make-python-class object ()
-               (define __init__       (lambda x (values)))
-               (define __subclasses__ subclasses)
-               (define __weakref__    (lambda (self) self))))
+    (define __init__       (lambda x (values)))
+    (define __subclasses__ subclasses)
+    (define __weakref__    (lambda (self) self))))
                
 
 (name-object type)