summaryrefslogtreecommitdiff
path: root/modules/language/python
diff options
context:
space:
mode:
Diffstat (limited to 'modules/language/python')
-rw-r--r--modules/language/python/compile.scm78
-rw-r--r--modules/language/python/module/enum.py47
2 files changed, 69 insertions, 56 deletions
diff --git a/modules/language/python/compile.scm b/modules/language/python/compile.scm
index a54dab8..93adc75 100644
--- a/modules/language/python/compile.scm
+++ b/modules/language/python/compile.scm
@@ -1062,7 +1062,7 @@
(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)))))))
@@ -1211,7 +1211,7 @@
(,(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?
@@ -1321,7 +1321,7 @@
,(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))))
@@ -1388,7 +1388,7 @@
,(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)))))
@@ -1578,7 +1578,7 @@
(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
@@ -1609,6 +1609,10 @@
((define . _)
#t
#f)
+
+ ((set! . _)
+ #t
+ #f)
((if p a)
#t
@@ -1728,14 +1732,15 @@
(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)
@@ -1743,29 +1748,40 @@
(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)
diff --git a/modules/language/python/module/enum.py b/modules/language/python/module/enum.py
index 1549862..7e7e46c 100644
--- a/modules/language/python/module/enum.py
+++ b/modules/language/python/module/enum.py
@@ -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"""
generated by cgit v1.2.3 (git 2.46.0) at 2024-10-19 05:35:09 +0000