SelectableInt as _SelectableInt,
BitRange as _BitRange,
selectconcat as _selectconcat,
+ selectltu as _selectltu,
)
return op(lhs, rhs)
def __lt__(self, other):
- return self.__binary_operator(_operator.lt, other)
+ return self.__binary_operator(_selectltu, other)
def __eq__(self, other):
return self.__binary_operator(_operator.eq, other)
+ def __bool__(self):
+ return bool(int(self))
+
def __int__(self):
span = dict.fromkeys(self.__class__.span).keys()
return int(_selectconcat(*(self.storage[bit] for bit in span)))
return super().__new__(metacls, clsname, bases, ns)
- def __getitem__(cls, size):
- clsname = f"{cls.__name__}[{size}]"
- items = ((Field,) * size)
- return ArrayMeta(clsname, (Array,), {}, items=items)
-
def __repr__(cls):
if not cls.__members__:
return cls.__name__
def __len__(cls):
return len(cls.__members__)
+ def __getitem__(cls, selector):
+ if isinstance(selector, int):
+ selector = (selector,)
+
+ items = []
+ for idx in selector:
+ if not isinstance(idx, int):
+ raise ValueError(selector)
+ item = cls.__members__[idx]
+ items.append(item)
+
+ return cls.__class__(cls.__name__, (Field,), {}, items=items)
+
def remap(cls, scheme):
if isinstance(scheme, type) and issubclass(scheme, Mapping):
scheme = range(len(scheme))
rlen = f"len({cls.__name__})"
raise RemapError(f"{llen} != {rlen}")
+ ns = {}
+ ns["__doc__"] = cls.__doc__
items = map(lambda item: scheme.__members__[item], cls)
- return cls.__class__(cls.__name__, (cls,), {}, items=items)
+ return cls.__class__(cls.__name__, (cls,), ns, items=items)
@property
def span(cls):
return cls.__members__
- def traverse(cls, path):
- yield (path, cls.__members__)
-
class Field(Reference, metaclass=FieldMeta):
- def __len__(self):
- return self.__class__.__len__()
-
def __repr__(self):
return f"[{len(self.__class__)}]0x{int(self):x}"
for bit in self.__class__:
yield self.storage[bit]
-
-class ArrayMeta(type):
- def __new__(metacls, clsname, bases, ns, items=()):
- assert "__members__" not in ns
-
- members = []
- for item in items:
- if not (isinstance(item, type) and issubclass(item, Field)):
- item = FieldMeta("Field", (Field,), {}, items=item)
- members.append(item)
-
- ns["__members__"] = tuple(members)
-
- return super().__new__(metacls, clsname, bases, ns)
-
- def __repr__(cls):
- if not cls.__members__:
- return cls.__name__
- return f"{cls.__name__}{cls.__members__!r}"
-
- def __iter__(cls):
- yield from enumerate(cls.__members__)
-
- def __len__(cls):
- length = 0
- for field in cls.__members__:
- length += len(field)
- return length
-
- def remap(cls, scheme):
- scheme_md = []
- scheme_sd = []
-
- for item in scheme:
- if not isinstance(item, int):
- scheme_md.append(item)
- else:
- scheme_sd.append(item)
-
- if scheme_md and scheme_sd:
- raise ValueError(scheme)
-
- def remap_md(scheme):
- scheme = cls.__class__(cls.__name__, (cls,), {}, items=scheme)
- if len(cls) == 0:
- if len(cls.__members__) != len(scheme.__members__):
- llen = f"len(scheme.__members__)"
- rlen = f"len({cls.__name__}.__members__)"
- raise RemapError(f"{llen} != {rlen}")
- return scheme
- elif len(scheme) != len(cls):
- llen = f"len(scheme)"
- rlen = f"len({cls.__name__})"
- raise RemapError(f"{llen} != {rlen}")
-
- items = []
- for (idx, field) in enumerate(cls):
- try:
- item = field.remap(scheme.__members__[idx])
- except RemapError as error:
- raise RemapError(f"[{idx}]: {error}")
- items.append(item)
-
- return cls.__class__(cls.__name__, (cls,), {}, items=items)
-
- def remap_sd(scheme):
- items = tuple(item.remap(scheme) for item in cls.__members__)
- return cls.__class__(cls.__name__, (cls,), {}, items=items)
-
- if scheme_md:
- return remap_md(scheme_md)
- else:
- return remap_sd(scheme_sd)
-
- @property
- def span(cls):
- for field in cls.__members__:
- yield from field.span
-
- def traverse(cls, path=""):
- for (idx, field) in cls:
- yield from field.traverse(path=f"{path}[{idx}]")
-
-
-class Array(Reference, metaclass=ArrayMeta):
- def __init__(self, storage):
- members = []
- for (idx, cls) in self.__class__:
- members.append(cls(storage))
-
- self.__members = tuple(members)
-
- return super().__init__(storage)
-
- def __repr__(self):
- items = tuple(f"[{idx}]={field!r}" for (idx, field) in self)
- return f"[{', '.join(items)}]"
-
- def __iter__(self):
- yield from enumerate(self.__members)
-
def __getitem__(self, key):
- return self.__members[key]
+ if isinstance(key, int):
+ bit = self.storage[self.__class__.__members__[key]]
+ return _SelectableInt(value=bit, bits=1)
+ if isinstance(key, slice):
+ assert key.step is None or key.step == 1
+ key = range(key.start, key.stop)
+
+ return _selectconcat(*(self[bit] for bit in tuple(key)))
- def __setitem__(self, key, value):
- self.__members[key].assign(value)
+ def traverse(self, path):
+ span = self.__class__.__members__
+ yield (path, self.storage[span], span)
class MappingMeta(type):
for (name, cls) in ns.get("__annotations__", {}).items():
if not (isinstance(cls, type) and
- issubclass(cls, (Mapping, Array, Field))):
+ issubclass(cls, (Mapping, Field))):
raise ValueError(f"{clsname}.{name}: {cls!r}")
if name in ns:
except RemapError as error:
raise RemapError(f"{name}: {error}")
else:
- if cls in (Array, Field):
- raise ValueError(f"{clsname}.{name}: " + \
- "base class without initializer")
+ if cls is Field:
+ raise ValueError(f"{clsname}.{name}: missing initializer")
members[name] = cls
ns["__members__"] = members
length = max(length, len(field))
return length
+ def __getitem__(cls, selector):
+ return cls.__members__["_"][selector]
+
def remap(cls, scheme):
ns = {}
annotations = {}
for (name, field) in cls:
annotations[name] = field.remap(scheme)
ns["__annotations__"] = annotations
+ ns["__doc__"] = cls.__doc__
return cls.__class__(cls.__name__, (cls,), ns)
for field in cls.__members__.values():
yield from field.span
- def traverse(cls, path=""):
- for (name, field) in cls:
- if name == "_":
- yield from field.traverse(path=path)
- elif path == "":
- yield from field.traverse(path=name)
- else:
- yield from field.traverse(path=f"{path}.{name}")
-
class Mapping(Reference, metaclass=MappingMeta):
def __init__(self, storage, **kwargs):
def __getitem__(self, key):
if isinstance(key, (int, slice, list, tuple, range)):
- return self.storage[key]
+ return self["_"][key]
return self.__members[key]
+ def traverse(self, path=""):
+ for (name, member) in self.__members.items():
+ if name == "_":
+ yield from member.traverse(path=path)
+ elif path == "":
+ yield from member.traverse(path=name)
+ else:
+ yield from member.traverse(path=f"{path}.{name}")
+
def decode_instructions(form):
res = {}
projects / openpower-isa.git / blobdiff