zuspec-dataclasses 0.0.1__py3-none-any.whl

zuspec/dataclasses/__init__.py

@@ -0,0 +1,17 @@
+
+
+# from .activity_stmts import *
+from .decorators import dataclass, field, export, process, input, output, sync, const, port, export, bind
+from .tlm import *
+# from .claims_refs import *
+# from .shared_stmts import *
+# from .types import *
+# from .core_lib import *
+# from vsc_dataclasses.expr import *
+
+from .bit import Bit
+from .component import Component
+from .struct import Struct
+from .ports import Input, Output, Port
+
+from asyncio import Event

zuspec/dataclasses/__version__.py

@@ -0,0 +1,4 @@
+
+BASE="0.0.1"
+SUFFIX=".17420876924rc0"
+VERSION="%s%s" % (BASE, SUFFIX)

zuspec/dataclasses/action.py

@@ -0,0 +1,25 @@
+from typing import Self, Type, TypeVar
+from .decorators import dataclass, field
+from .component import Component
+from .struct import Struct
+
+CompT = TypeVar('CompT', bound=Component)
+
+@dataclass
+class Action[CompT](Struct):
+    """
+    Action-derived types 
+
+    Valid fields
+    - All Struct fields
+    - Input / Output fields of Buffer, Stream, and State types
+    - Lock / Share fields of Resource types
+    Valid sub-regions
+    - All Struct sub-regions
+    - activity
+    """
+    comp : Type[CompT] = field()
+
+@dataclass
+class MyAction(Action[Component]):
+    pass

zuspec/dataclasses/addr_reg.py

@@ -0,0 +1,61 @@
+import abc
+import zuspec.dataclasses as zdc
+from typing import Annotated, TypeVar, Type, Union
+from .struct import StructPacked
+
+class AddrTrait(zdc.Struct): pass
+
+
+class AddrSpaceBase:
+    pass
+
+uint64_t = Annotated[int, "abc"]
+
+AddrTraitT = TypeVar('AddrTraitT', bound=AddrTrait)
+
+class AddrRegion[AddrTraitT]():
+    trait : Type[AddrTraitT] = zdc.trait()
+    pass
+
+class MyTrait(AddrTrait):
+    a : int = 5
+
+class TransparentAddrSpace[AddrTraitT](AddrSpaceBase):
+
+    def add_region(self, region : AddrRegion[AddrTraitT]): pass
+
+    pass
+
+class MyAddrTrait(AddrTrait):
+    pass
+
+class Other(object):
+    pass
+
+t : TransparentAddrSpace = TransparentAddrSpace()
+o = Other()
+
+r = AddrRegion[MyTrait]()
+r2 = AddrRegion[Other]()
+
+t.add_region(r2)
+
+r.trait.a
+
+RegT = TypeVar("RegT", bound=Union[int,StructPacked])
+
+class Reg[RegT](object):
+
+    @abc.abstractmethod
+    def read(self) -> Type[RegT]: pass
+
+    @abc.abstractmethod
+    def write(self, data : Type[RegT]): pass
+
+class RegGroup(object):
+    @abc.abstractmethod
+    def get_handle(self): pass
+
+    @abc.abstractmethod
+    def set_handle(self, h): pass
+

zuspec/dataclasses/annotation.py

@@ -0,0 +1,16 @@
+import dataclasses as dc
+from typing import Callable, ClassVar
+
+@dc.dataclass
+class Annotation(object):
+    NAME : ClassVar[str] = "__zsp_annotation__"
+
+    @classmethod
+    def apply(cls, o, v):
+        setattr(o, cls.NAME, v)
+    pass
+
+@dc.dataclass
+class AnnotationSync(Annotation):
+    clock : Callable
+    reset : Callable

zuspec/dataclasses/api/__init__.py

@@ -0,0 +1,2 @@
+
+from .visitor import Visitor

zuspec/dataclasses/api/visitor.py

@@ -0,0 +1,64 @@
+import dataclasses as dc
+from typing import Callable, ClassVar, Dict, Type
+from ..annotation import Annotation
+from ..component import Component
+from ..ports import Input, Output
+from ..struct import Struct
+
+@dc.dataclass
+class Visitor(object):
+    _type_m : Dict[Type,Callable] = dc.field(default_factory=dict)
+    _field_factory_m : Dict[Type,Callable] = dc.field(default_factory=dict)
+
+    def __post_init__(self):
+        self._type_m = {
+            Component : self.visitComponentType
+        }
+        self._field_factory_m = {
+            Input : self.visitInput,
+            Output : self.visitOutput
+        }
+
+    def visit(self, t):
+        found = False
+        for base_t,method in self._type_m.items():
+            if issubclass(t, base_t):
+                method(t)
+                found = True
+                break
+        if not found:
+            raise Exception("Unsupported class %s" % str(type(t)))
+
+    def visitComponentType(self, t):
+        self.visitStructType(t)
+        pass
+
+    def visitStructType(self, t : Struct):
+        for f in dc.fields(t):
+            self._dispatchField(f)
+        
+        for f in dir(t):
+            o = getattr(t, f)
+            if callable(o) and hasattr(o, Annotation.NAME):
+                self.visitExec(f, o)
+                print("Found")
+
+    def visitExec(self, name, m):
+        pass
+
+    def _dispatchField(self, f : dc.Field):
+        if f.default_factory in self._field_factory_m.keys():
+            self._field_factory_m[f.default_factory](f)
+        else:
+            self.visitField(f)
+
+    def visitField(self, f : dc.Field):
+        pass
+
+    def visitInput(self, f : dc.Field):
+        self.visitField(f)
+        pass
+
+    def visitOutput(self, f : dc.Field):
+        self.visitField(f)
+        pass

zuspec/dataclasses/bit.py

@@ -0,0 +1,26 @@
+import dataclasses as dc
+from typing import Dict
+
+class BitMeta(type):
+
+    def __new__(cls, name, bases, attrs):
+        return super().__new__(cls, name, bases, attrs)
+    
+    def __init__(self, name, bases, attrs):
+        super().__init__(name, bases, attrs)
+        self.type_m : Dict = {}
+    
+    def __getitem__(self, W : int):
+        if W in self.type_m.keys():
+            return self.type_m[W]
+        else:
+            t = type("bit[%d]" % W, (Bit,), {
+                "T" : W
+            })
+            self.type_m[W] = t
+            return t
+
+
+class Bit(metaclass=BitMeta):
+    T : int = 1
+    pass

zuspec/dataclasses/bundle.py

@@ -0,0 +1,32 @@
+from typing import Annotated, Type, TypeVar
+from .decorators import dataclass
+
+@dataclass
+class Bundle(object):
+    """
+    A bundle type collects one or more ports, exports,
+    inputs, outputs, or bundles. 
+
+    Bundle fields are created with field(). Bundle-mirror
+    fields are created with mirror() or field(mirror=True)
+
+    A bundle field can be connected to a mirror field. 
+    - Bundle
+    - Bundle Mirror
+    - Bundle Monitor (all are inputs / exports)
+    """
+    pass
+
+#BundleT=TypeVar('BundleT', bound=Bundle)
+
+#class Mirror[BundleT](Annotated[Type[BundleT], "is mirror"]): pass
+
+# class MirrorMeta[BundleT](type):
+
+#     def __getitem__(self, t : BundleT) -> BundleT:
+#         pass
+
+# @dataclass
+# class Mirror[BundleT](metaclass=MirrorMeta[BundleT]):
+#     pass
+

zuspec/dataclasses/clock.py

@@ -0,0 +1,3 @@
+
+class Clock(object):
+    pass

zuspec/dataclasses/component.py

@@ -0,0 +1,15 @@
+from .decorators import dataclass
+from .struct import Struct
+
+@dataclass
+class Component(Struct):
+    """
+    Component classes are structural in nature. 
+    The lifecycle of a component tree is as follows:
+    - The root component and fields of component type are constructed
+    - The 'init_down' method is invoked in a depth-first manner
+    - The 'init_up' method is invoked
+    """
+
+    def build(self): pass
+

zuspec/dataclasses/decorators.py

@@ -0,0 +1,302 @@
+'''
+Created on Mar 19, 2022
+
+@author: mballance
+'''
+import dataclasses
+import dataclasses as dc
+from typing import Any, Callable, Dict, Self, TypeVar
+# from vsc_dataclasses.decorators import *
+# from .impl.action_decorator_impl import ActionDecoratorImpl
+# from .impl.exec_decorator_impl import ExecDecoratorImpl
+# from .impl.exec_kind_e import ExecKindE
+# from .impl.extend_kind_e import ExtendKindE
+# from .impl.extend_decorator_impl import ExtendDecoratorImpl
+# from .impl.extend_action_decorator_impl import ExtendActionDecoratorImpl
+# from .impl.extend_component_decorator_impl import ExtendComponentDecoratorImpl
+# from .impl.fn_decorator_impl import FnDecoratorImpl
+# from .impl.struct_decorator_impl import StructDecoratorImpl
+# from .impl.struct_kind_e import StructKindE
+# from .impl.component_decorator_impl import ComponentDecoratorImpl
+# from .impl.activity_decorator_impl import ActivityDecoratorImpl
+# from .impl.type_kind_e import TypeKindE
+from .annotation import Annotation, AnnotationSync
+from .ports import Input, Output
+from .clock import Clock
+
+def dataclass(cls, **kwargs):
+    return dc.dataclass(cls, **kwargs)
+
+def bundle():
+    return dc.field()
+
+def mirror():
+    return dc.field()
+
+class BitLiteral(int):
+    width : int = 1
+    def __getitem__(self, v) -> 'BitLiteral':
+        return self
+        pass
+    pass
+
+def bit(t : int) -> BitLiteral:
+    return BitLiteral(t)
+
+def val(t : int) -> int:
+    return t
+
+def always(instr : BitLiteral):
+   match instr[0:1]:
+      case bit(0):
+        match instr[13:15]:
+           case bit(0):
+              pass
+           case bit(2):
+              pass
+    # unique case (instr_i[1:0])
+    #   // C0
+    #   2'b00: begin
+    #     unique case (instr_i[15:13])
+    #       3'b000: begin
+    #         // c.addi4spn -> addi rd', x2, imm
+    #         instr_o = {2'b0, instr_i[10:7], instr_i[12:11], instr_i[5],
+    #                    instr_i[6], 2'b00, 5'h02, 3'b000, 2'b01, instr_i[4:2], {OPCODE_OP_IMM}};
+    #         if (instr_i[12:5] == 8'b0)  illegal_instr_o = 1'b1;
+    #       end
+
+    #       3'b010: begin
+    #         // c.lw -> lw rd', imm(rs1')
+    #         instr_o = {5'b0, instr_i[5], instr_i[12:10], instr_i[6],
+    #                    2'b00, 2'b01, instr_i[9:7], 3'b010, 2'b01, instr_i[4:2], {OPCODE_LOAD}};
+    #       end
+
+    #       3'b110: begin
+    #         // c.sw -> sw rs2', imm(rs1')
+    #         instr_o = {5'b0, instr_i[5], instr_i[12], 2'b01, instr_i[4:2],
+    #                    2'b01, instr_i[9:7], 3'b010, instr_i[11:10], instr_i[6],
+    #                    2'b00, {OPCODE_STORE}};
+    #       end
+
+    #       3'b001,
+    #       3'b011,
+    #       3'b100,
+    #       3'b101,
+    #       3'b111: begin
+    #         illegal_instr_o = 1'b1;
+    #       end
+
+    #       default: begin
+    #         illegal_instr_o = 1'b1;
+    #       end
+    #     endcase
+
+a = bit(20)[3:4] 
+
+SelfT = TypeVar('SelfT')
+
+class bind[T](object):
+    def __init__(self, c : Callable[[T],Dict[Any,Any]]):
+        self._c = c
+    def __call__(self, s) -> Dict[Any,Any]:
+        return self._c(s)
+    
+#a = bind2(lambda s:{s.}, selfT=Self)
+
+def field(rand=False, bind : Callable[[object],Dict[Any,Any]] = None):
+    pass
+    
+    # @staticmethod
+    # def __call__(rand=False, bind : Callable[[T],Dict[Any,Any]] = None):
+    #     pass
+
+    # """
+    # Marks a plain data field
+    # - rand -- Marks the field as being randomizable
+    # - 
+    # """
+    # # TODO: 
+    # return dc.field()
+
+def input(*args, **kwargs):
+    return dataclasses.field(default_factory=Input)
+
+def output(*args, **kwargs):
+    return dc.field(default_factory=Output)
+
+def lock(*args, **kwargs):
+    return dc.field(default_factory=Lock)
+
+def share(*args, **kwargs):
+    return dc.field(default_factory=Share)
+
+def port():
+    return dc.field()
+
+def export(*args, bind=None, **kwargs):
+    return dc.field(*args, **kwargs)
+
+def process(T):
+    return T
+
+def reg(offset=0):
+    return dc.field()
+    pass
+
+def const(**kwargs):
+    return dc.field()
+
+def sync(*args, clock=None, reset=None):
+    # TODO: handle two forms
+    if len(args) == 0:
+        def __call__(T):
+            Annotation.apply(T, AnnotationSync(clock=clock, reset=reset))
+            return T
+        return __call__
+    else:
+        Annotation.apply(args[0], AnnotationSync(clock=clock, reset=reset))
+        return args[0]
+
+# def action(*args, **kwargs): 
+#     if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#         # No-argument form
+#         return ActionDecoratorImpl([], {})(args[0])
+#     else:
+#         # Argument form
+#         return ActionDecoratorImpl(args, kwargs)
+    
+# def activity(*args, **kwargs):
+#     if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#         # No-argument form
+#         return ActivityDecoratorImpl([], {})(args[0])
+#     else:
+#         return ActivityDecoratorImpl(args, kwargs)
+
+# def component(*args, **kwargs):
+#     if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#         # No-argument form
+#         return ComponentDecoratorImpl([], {})(args[0])
+#     else:
+#         return ComponentDecoratorImpl(args, kwargs)
+
+def constraint(T):
+    setattr(T, "__constraint__", True)
+    return T
+    
+ # def constraint(*args, **kwargs):
+# #     if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+# #         # No-argument form
+# #         return ConstraintDecoratorImpl({})(args[0])
+# #     else:
+# #         return ConstraintDecoratorImpl(kwargs)
+
+# def buffer(*args, **kwargs): 
+#     if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#         # No-argument form
+#         return StructDecoratorImpl(StructKindE.Buffer, [], {})(args[0])
+#     else:
+#         return ActionDecoratorImpl(StructKindE.Buffer, args, kwargs)
+    
+# def resource(*args, **kwargs): 
+#     if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#         # No-argument form
+#         return StructDecoratorImpl(StructKindE.Resource, [], {})(args[0])
+#     else:
+#         return StructDecoratorImpl(StructKindE.Resource, [], kwargs)
+    
+# def state(*args, **kwargs): 
+#     if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#         # No-argument form
+#         return StructDecoratorImpl(StructKindE.State, {})(args[0])
+#     else:
+#         return ActionDecoratorImpl(StructKindE.State, kwargs)
+    
+# def stream(*args, **kwargs): 
+#     if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#         # No-argument form
+#         return StructDecoratorImpl(StructKindE.Stream, {})(args[0])
+#     else:
+#         return ActionDecoratorImpl(StructKindE.Stream, kwargs)
+    
+# def struct(*args, **kwargs): 
+#     if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#         # No-argument form
+#         return StructDecoratorImpl(StructKindE.Struct, [], {})(args[0])
+#     else:
+#         return ActionDecoratorImpl(StructKindE.Struct, args, kwargs)
+
+# class exec(object):
+#     @staticmethod
+#     def body(*args, **kwargs):
+#         if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#             # No-argument form
+#             return ExecDecoratorImpl(ExecKindE.Body, [], {})(args[0])
+#         else:
+#             return ExecDecoratorImpl(ExecKindE.Body, args, kwargs)
+        
+#     @staticmethod
+#     def init_down(*args, **kwargs):
+#         if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#             # No-argument form
+#             return ExecDecoratorImpl(ExecKindE.InitDown, [], {})(args[0])
+#         else:
+#             return ExecDecoratorImpl(ExecKindE.InitDown, args, kwargs)
+        
+#     @staticmethod
+#     def init_up(*args, **kwargs):
+#         if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#             # No-argument form
+#             return ExecDecoratorImpl(ExecKindE.InitUp, [], {})(args[0])
+#         else:
+#             return ExecDecoratorImpl(ExecKindE.InitUp, args, kwargs)
+        
+#     @staticmethod
+#     def pre_solve(*args, **kwargs):
+#         if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#             # No-argument form
+#             return ExecDecoratorImpl(ExecKindE.PreSolve, [], {})(args[0])
+#         else:
+#             return ExecDecoratorImpl(ExecKindE.PreSolve, args, kwargs)
+        
+#     @staticmethod
+#     def post_solve(*args, **kwargs):
+#         if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#             # No-argument form
+#             return ExecDecoratorImpl(ExecKindE.PostSolve, [], {})(args[0])
+#         else:
+#             return ExecDecoratorImpl(ExecKindE.PostSolve, args, kwargs)
+
+# class extend(object):
+#     @staticmethod
+#     def action(target, *args, **kwargs):
+#         return ExtendActionDecoratorImpl(target, args, kwargs)
+
+#     @staticmethod
+#     def component(target, *args, **kwargs):
+#         return ExtendComponentDecoratorImpl(target, args, kwargs)
+
+# class extern(object):
+
+#     # TODO:    
+#     @staticmethod
+#     def action(*args, **kwargs):
+#         raise NotImplementedError("extern.action not implemented")
+#         if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#             # No-argument form
+#             return ExecDecoratorImpl(ExecKindE.PreSolve, {})(args[0])
+#         else:
+#             return ExecDecoratorImpl(ExecKindE.PreSolve, kwargs)
+
+# def fn(*args, **kwargs): 
+#     if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#         # No-argument form
+#         return FnDecoratorImpl(False, {})(args[0])
+#     else:
+#         return FnDecoratorImpl(False, kwargs)
+
+# def import_fn(*args, **kwargs): 
+#     if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+#         # No-argument form
+#         return FnDecoratorImpl(True, {})(args[0])
+#     else:
+#         return FnDecoratorImpl(True, kwargs)

zuspec/dataclasses/dependency.py

@@ -0,0 +1,22 @@
+import abc
+import dataclasses as dc
+from typing import List
+
+class DependencyProvider(abc.ABC): pass
+
+class Pool[T](DependencyProvider): pass
+
+class TrackingDependencyProvider[T](DependencyProvider):
+    """
+    Dependency provider that tracks its dependencies. 
+    This is typically used by a component that must use
+    dependency information to properly build itself.
+    """
+
+    @abc.abstractmethod
+    def dependents(self) -> List[T]:
+        """
+        List of dependencies bound to this provider
+        """
+        pass
+

zuspec/dataclasses/ports.py

@@ -0,0 +1,61 @@
+import dataclasses as dc
+from typing import ClassVar, Dict, Generic, Type
+from abc import abstractmethod
+
+
+class Port[T]():
+
+    @abstractmethod
+    def __call__(self) -> T:
+        pass
+
+# # Bundle is a collection of ports/exports
+# class WishboneI():
+#     valid : Output[bool]
+#     ready : Input[bool]
+#     pass
+
+# class ReverseT(type):
+#     def __new__(cls, name, bases, attrs):
+#         return super().__new__(cls, name, bases, attrs)
+
+#     def __getitem__(self, T : type):
+#         pass
+
+
+# class Reverse[T](metaclass=ReverseT):
+
+#     def __class_getitem__(cls):
+#         pass
+
+#     pass
+
+# WishboneIM=Reverse[WishboneI]
+
+# class Api[T](ABC):
+
+#     @abstractmethod
+#     def put(self, val : T):
+#         pass
+
+#     @abstractmethod
+#     def get(self) -> T:
+#         pass
+
+# class MyModule:
+#     init_o : Port[WishboneI]
+#     dat_o : Port[Api[int]]
+
+#     def doit(self):
+#         self.init_o().ready = 1
+#         if self.init_o().valid:
+#             pass
+
+#         a = self.dat_o().get()
+#         self.dat_o().put(5)
+
+class Input(object):
+    pass
+
+class Output(object):
+    pass

zuspec/dataclasses/py.typed

@@ -0,0 +1 @@
+

zuspec/dataclasses/reset.py

@@ -0,0 +1,3 @@
+
+class Reset(object):
+    pass

zuspec/dataclasses/struct.py

@@ -0,0 +1,42 @@
+import abc
+from typing import Dict, Optional, Type
+from .decorators import dataclass
+
+@dataclass
+class StructPacked(object):
+    """
+    StructPacked types are fixed-size data structures. 
+    Fields may only be of a fixed size. 
+
+    Valid sub-regions
+    - constraint
+    - pre_solve / post_solve
+    """
+    pass
+
+@dataclass
+class Struct(object):
+    """
+    Struct types are data structures that may contain
+    variable-size fields. 
+
+    Valid sub-regions
+    - constraint
+    - pre_solve / post_solve
+    - method
+    """
+
+    # @abc.abstractmethod
+    # def bind[T](self, t : T):
+    #             t : Type[T], 
+    #             init : Optional[Dict]=None,
+    #             bind : Optional[Dict]=None) -> T:
+    #     """
+    #     Public API
+    #     Applies service Creates a new instance of the specified class.
+    #     - Resolves service claims relative to the context
+    #       object and any bind specifications.
+    #     """
+    #     pass
+
+    pass

zuspec/dataclasses/timebase.py

@@ -0,0 +1,27 @@
+import abc
+from .component import Component
+from .decorators import dataclass, input
+from .bit import Bit
+
+@dataclass
+class TimeBase(object):
+    """
+    TimeBase exposes the notion of design time
+    """
+
+    @abc.abstractmethod
+    async def wait(self, amt : float, units):
+        """Scales the time to the timebase and waits"""
+        pass
+
+    @abc.abstractmethod
+    def wait_ev(self, amt : float, units):
+        """Scales the time to the timebase and returns an event"""
+        pass
+
+    pass
+
+class TimeBaseSignal(TimeBase,Component):
+    clock : Bit = input()
+    reset : Bit = input()
+

zuspec/dataclasses/tlm.py

@@ -0,0 +1,12 @@
+import abc
+import dataclasses as dc
+from typing import Callable, Dict, Awaitable, Type, dataclass_transform
+
+@dc.dataclass
+class IPut[T]():
+    put : Callable[[Type[T]], Awaitable] = dc.field()
+
+@dc.dataclass
+class IGet[T]():
+    get : Callable[[], Awaitable[T]] = dc.field()
+

zuspec/dataclasses/util/extract_cpp_embedded_dsl.py

@@ -0,0 +1,197 @@
+#****************************************************************************
+#* extract_cpp_embedded_dsl.py
+#*
+#* Copyright 2022 Matthew Ballance and Contributors
+#*
+#* Licensed under the Apache License, Version 2.0 (the "License"); you may 
+#* not use this file except in compliance with the License.  
+#* You may obtain a copy of the License at:
+#*
+#*   http://www.apache.org/licenses/LICENSE-2.0
+#*
+#* Unless required by applicable law or agreed to in writing, software 
+#* distributed under the License is distributed on an "AS IS" BASIS, 
+#* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
+#* See the License for the specific language governing permissions and 
+#* limitations under the License.
+#*
+#* Created on:
+#*     Author: 
+#*
+#****************************************************************************
+from typing import List
+
+#
+#
+#  ZSP_DATACLASSES(TestSuite_testname, RootComp, RootAction, R"(
+#    @vdc.randclass
+#    class MyC(object):
+#      a : vdc.rand_uint32_t
+#  )")
+#
+#
+
+class DSLContent(object):
+    def __init__(self,
+                 name,
+                 root_comp,
+                 root_action,
+                 content):
+        self.name = name
+        self.root_comp = root_comp
+        self.root_action = root_action
+        self.content = content
+
+class ExtractCppEmbeddedDSL(object):
+
+    def __init__(self, 
+            file_or_fp,
+            name=None,
+            macro_name="ZSP_DATACLASSES"):
+        self._macro_name = macro_name
+        if hasattr(file_or_fp, "read"):
+            # This is a stream-like object
+            self._fp = file_or_fp
+            if name is None:
+                self._name = self._fp.name()
+        else:
+            self._fp = open(file_or_fp, "r")
+            self._name = file_or_fp
+        
+        self._lineno = 0
+        self._unget_ch = None
+        self._last_ch = None
+        self._buffer = ""
+        self._buffer_i = 0
+
+    def extract(self) -> List[DSLContent]:
+        ret = []
+
+        while self.find_macro():
+
+            lineno = self._lineno
+            while True:
+                ch = self.getch()
+
+                if ch is None or ch == '(':
+                    break
+
+            if ch is None:
+                raise Exception("Failed to parse embedded DSL @ %s:%d" % (self._name, self._lineno))
+            
+            # Now, collect the complete content of the macro
+            content = ""
+            count_b = 1
+            while count_b > 0:
+                ch = self.getch()
+
+                if ch is None:
+                    break
+                content += ch
+
+                if ch == '(':
+                    count_b += 1
+                elif ch == ')':
+                    count_b -= 1
+
+            if count_b > 0:
+                raise Exception("Unbalanced parens")
+            content = content[:-2]
+            
+            # We now have text from a macro invocation
+            start = 0
+            count_b = 0
+            params = []
+
+            for i in range(len(content)):
+                if content[i] == "," and count_b == 0:
+                    params.append(content[start:i].strip())
+                    start = i+1
+                elif content[i] == '(':
+                    count_b += 1
+                elif content[i] == ')':
+                    count_b -= 1
+
+            if count_b != 0:
+                raise Exception("Unbalanced parens while tokenizing") 
+
+            if start < len(content):
+                params.append(content[start:].strip())
+
+            if len(params) != 4:
+                raise Exception("Expected 3 params; received %d" % len(params))
+
+            if params[-1].startswith('R"('):
+                params[-1] = params[-1][3:-2]
+
+            content = params[-1].split("\n")
+            min_ws = 10000
+
+            for l in content:
+                l_strip = l.strip()
+                if l_strip != "":
+                    ws_l = len(l) - len(l_strip)
+                    if ws_l < min_ws:
+                        min_ws = ws_l
+
+            for i in range(len(content)):
+                content[i] = content[i][min_ws:]
+
+            vsc_content = "\n".join(content)
+
+            root_comp = params[1]
+            root_action = params[2]
+
+            info = DSLContent(params[0], root_comp, root_action, vsc_content)
+            ret.append(info)
+
+        self._fp.close()
+        return ret
+
+    def find_macro(self):
+
+        while True:
+            line = self._fp.readline()
+            self._lineno += 1
+
+            if line == "":
+                break
+            
+            idx = line.find(self._macro_name)
+            
+            if idx >= 0:
+                self._buffer = line
+                self._buffer_i = idx + len(self._macro_name)
+                return True
+        
+        return False
+
+    def getch(self):
+        if self._buffer is None:
+            return None
+
+        if self._buffer_i >= len(self._buffer):
+            try:
+                self._buffer = self._fp.readline()
+                self._buffer_i = 0
+                self._lineno += 1
+                if self._buffer == "":
+                    self._buffer = None
+                    return None
+            except Exception:
+                self._buffer = None
+                return None
+            
+        ret = self._buffer[self._buffer_i]
+        self._buffer_i += 1
+        return ret
+    
+    def ungetch(self, ch):
+        if self._buffer is None:
+            self._buffer = ch
+        elif self._buffer_i > 0:
+            self._buffer_i -= 1
+            self._buffer[self._buffer_i] = ch
+        else:
+            self._buffer.insert(0, ch)
+

zuspec/dataclasses/util/gen_cpp_dt_defs/__main__.py

@@ -0,0 +1,102 @@
+#****************************************************************************
+#* __main__.py
+#*
+#* zsp_dataclasses.util.gen_cpp_dt_defs
+#*
+#* Copyright 2022 Matthew Ballance and Contributors
+#*
+#* Licensed under the Apache License, Version 2.0 (the "License"); you may 
+#* not use this file except in compliance with the License.  
+#* You may obtain a copy of the License at:
+#*
+#*   http://www.apache.org/licenses/LICENSE-2.0
+#*
+#* Unless required by applicable law or agreed to in writing, software 
+#* distributed under the License is distributed on an "AS IS" BASIS, 
+#* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
+#* See the License for the specific language governing permissions and 
+#* limitations under the License.
+#*
+#* Created on:
+#*     Author: 
+#*
+#****************************************************************************
+
+import argparse
+import os
+import zuspec as zdc
+from zuspec.impl.ctor import Ctor
+from zuspec.impl.pyctxt.context import Context
+from zuspec.impl.generators.zsp_data_model_cpp_gen import ZspDataModelCppGen
+from ..extract_cpp_embedded_dsl import ExtractCppEmbeddedDSL
+
+def get_parser():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-o","--outdir", default="zspdefs",
+        help="Specifies the output directory")
+    parser.add_argument("-d", "--depfile",
+        help="Specifies a dependency file")
+    parser.add_argument("files", nargs='+')
+
+    return parser
+
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+
+    deps_ts = None
+    if args.depfile is not None and os.path.isfile(args.depfile):
+        deps_ts = os.path.getmtime(args.depfile)
+
+    fragment_m = {}
+    for file in args.files:
+        print("Process %s" % file)
+        if deps_ts is not None:
+            file_ts = os.path.getmtime(file)
+            if file_ts <= deps_ts:
+                print("Skip due to deps")
+                continue
+
+        fragments = ExtractCppEmbeddedDSL(file).extract()
+        print("fragments: %s" % str(fragments))
+
+        for f in fragments:
+            if f.name in fragment_m.keys():
+                raise Exception("Duplicate fragment-name %s" % f.name)
+            fragment_m[f.name] = f
+
+    if not os.path.isdir(args.outdir):
+        os.makedirs(args.outdir, exist_ok=True)
+
+    for fn in fragment_m.keys():
+        Ctor.init(Context())
+
+        print("--> Process Fragment %s" % fn)
+        _globals = globals().copy()
+        exec(fragment_m[fn].content, _globals)
+        print("<-- Process Fragment %s" % fn)
+
+        Ctor.inst().elab()
+
+        header_path = os.path.join(args.outdir, "%s.h" % fn)
+        root_comp = Ctor.inst().ctxt().findDataTypeComponent(fragment_m[fn].root_comp)
+        if root_comp is None:
+            raise Exception("Failed to find root component %s" % fragment_m[fn].root_comp)
+        root_action = Ctor.inst().ctxt().findDataTypeAction(fragment_m[fn].root_action)
+        if root_action is None:
+            raise Exception("Failed to find root action %s" % fragment_m[fn].root_action)
+        gen = ZspDataModelCppGen()
+        gen._ctxt = "m_ctxt"
+        with open(header_path, "w") as fp:
+            fp.write(gen.generate(
+                root_comp, 
+                root_action, 
+                Ctor.inst().ctxt().getDataTypeFunctions()))
+
+    if args.depfile is not None:
+        with open(args.depfile, "w") as fp:
+            fp.write("\n")
+
+if __name__ == "__main__":
+    main()
+

zuspec/impl/__init__.py

@@ -0,0 +1 @@
+# Package marker for zuspec.impl

zuspec_dataclasses-0.0.1.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: zuspec-dataclasses
+Version: 0.0.1
+License-File: LICENSE
+Dynamic: license-file

zuspec_dataclasses-0.0.1.dist-info/RECORD

@@ -0,0 +1,28 @@
+zuspec/dataclasses/__init__.py,sha256=N7A7kcH2MWv11kqVA-s0SyKnWBAKD6ijQXJOrzfRyf8,452
+zuspec/dataclasses/__version__.py,sha256=hYXCtEyKiPU-TrubK6Unu2SK0ieIr0qyB5gzlj9a-2Y,71
+zuspec/dataclasses/action.py,sha256=z7aMc6e_k_-NCzYDm8K1ymEPfcGeyqlO79of0Gucack,570
+zuspec/dataclasses/addr_reg.py,sha256=QmxPQ8lq1255ZfOjQRGFGWGGwK-pSpPFJ4mdzJlj8dw,1111
+zuspec/dataclasses/annotation.py,sha256=M41iS93Oi8M-ER_ZIBI8CIWJ1bvEMI0nHa-RxbmWJUs,328
+zuspec/dataclasses/bit.py,sha256=Zxm3F04GcfuJczmwCrMuvpcBCunWMZQFffB4JvNterI,614
+zuspec/dataclasses/bundle.py,sha256=6fqjfoTS_-_izl4FlPFgurfOg3tnj_1fmEdSa1FF4C0,781
+zuspec/dataclasses/clock.py,sha256=pM0rO-3bp0SGJccxtU-17vIcF9EaSlqD-q1_9O0of1o,30
+zuspec/dataclasses/component.py,sha256=vzPCmLdAgm-x46Or18RtBYRClVUkbqIZ1yqp1nu5sL4,416
+zuspec/dataclasses/decorators.py,sha256=fSJpsTbahzQdtFtlVhDFSHFFuYmiRxg_3S_W1DpjLDY,9797
+zuspec/dataclasses/dependency.py,sha256=kGxdFqKlviUP7qmvN-FbnXIiqCPdgRRel83feuu8OoU,532
+zuspec/dataclasses/ports.py,sha256=3pbBwdBzDMAJTZ15Qf6sSXB-XOH5cJ-G5H8kQa5JurQ,1106
+zuspec/dataclasses/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+zuspec/dataclasses/reset.py,sha256=DV8tiKq_k-AGUNBbpJCJFx_EEfA07UgUJK2veYli0b0,30
+zuspec/dataclasses/struct.py,sha256=vId0487ZJmhnTbTg421B-iN9PtxNexCv9DMqRO8RXBU,973
+zuspec/dataclasses/timebase.py,sha256=rjEiGB2lNPMTewE-Z4iX-CHnbx1QVTUbtwEXnKMkesI,599
+zuspec/dataclasses/tlm.py,sha256=TjODFwvombQR7AVVI7HlW37MEm22Zu9JdVYpOCU4_Vg,277
+zuspec/dataclasses/api/__init__.py,sha256=HfJhJ_B1RJSpJn5NmWzEK3l2IruubiEKd3xwLDuED6Q,30
+zuspec/dataclasses/api/visitor.py,sha256=8-5er0GxAWnvxhDmiR_OBn2iMxtymtol5qM09ucKdLI,1780
+zuspec/dataclasses/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+zuspec/dataclasses/util/extract_cpp_embedded_dsl.py,sha256=SyMMLumZD6fsubj40hyekYzWyrcoUGTijJH3NmK1ihY,5630
+zuspec/dataclasses/util/gen_cpp_dt_defs/__main__.py,sha256=t3CnHJKcN_N33sxCsDH-R36ghCcQ7xjMcjUrzUT2SGM,3447
+zuspec/impl/__init__.py,sha256=GZWCeBPdVzLR0RNPkmXNXPgdS-2vg5dMC1goTYJs3yI,33
+zuspec_dataclasses-0.0.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+zuspec_dataclasses-0.0.1.dist-info/METADATA,sha256=HFi2cIVpagjnV1Dcq5GW7aM9cF8MgMv3P9c4WAVdESE,106
+zuspec_dataclasses-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+zuspec_dataclasses-0.0.1.dist-info/top_level.txt,sha256=3WM_V5g1RvpI4_z1TPY_AmroKhWIp6QJo4Vz5Tqbgak,7
+zuspec_dataclasses-0.0.1.dist-info/RECORD,,

zuspec_dataclasses-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

zuspec_dataclasses-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

zuspec_dataclasses-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+zuspec