zuspec-arl-dm 0.1.0.15264414400rc0__cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

zsp_arl_dm/share/include/zsp/arl/dm/impl/TaskGetSubField.h

@@ -0,0 +1,98 @@
+/**
+ * TaskGetSubField.h
+ *
+ * Copyright 2023 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: 
+ */
+#pragma once
+#include "zsp/arl/dm/impl/VisitorBase.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class TaskGetSubField :
+    public virtual VisitorBase {
+public:
+
+    TaskGetSubField(bool phy=false) : m_phy(phy) { }
+
+    virtual ~TaskGetSubField() { }
+
+    vsc::dm::ITypeField *get(vsc::dm::IDataType *base, int32_t idx) {
+        vsc::dm::ITypeField *ret = 0;
+
+        m_struct = 0;
+        base->accept(m_this);
+        
+        if (m_struct) {
+            ret  = m_struct->getField(idx);
+        }
+
+        if (!ret) {
+            fprintf(stdout, "Failed to get field\n");
+        }
+
+        return ret;
+    }
+
+    virtual void visitDataTypeAddrSpaceC(IDataTypeAddrSpaceC *i) override {
+        m_struct = i;
+    }
+
+    virtual void visitDataTypeAddrSpaceTransparentC(IDataTypeAddrSpaceTransparentC *i) override {
+        m_struct = i;
+    }
+
+	virtual void visitDataTypeAction(IDataTypeAction *i) override {
+        m_struct = i;
+    }
+
+	virtual void visitDataTypeComponent(IDataTypeComponent *t) override {
+        m_struct = t;
+    }
+
+	virtual void visitDataTypeFlowObj(IDataTypeFlowObj *t) override {
+        m_struct = t;
+    }
+
+	virtual void visitDataTypeStruct(vsc::dm::IDataTypeStruct *t) override {
+        m_struct = t;
+    }
+
+    virtual void visitDataTypeWrapper(vsc::dm::IDataTypeWrapper *t) override {
+        if (m_phy) {
+            t->getDataTypePhy()->accept(m_this);
+        } else {
+            t->getDataTypeVirt()->accept(m_this);
+        }
+    }
+
+private:
+    bool                        m_phy;
+    vsc::dm::IDataTypeStruct    *m_struct;
+
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/impl/TaskGetTypeBitWidth.h

@@ -0,0 +1,76 @@
+/**
+ * TaskGetTypeBitWidth.h
+ *
+ * Copyright 2023 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: 
+ */
+#pragma once
+#include "zsp/arl/dm/impl/VisitorBase.h"
+#include "vsc/dm/IDataTypeStruct.h"
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class TaskGetTypeBitWidth :
+    public virtual VisitorBase {
+public:
+
+    TaskGetTypeBitWidth() { }
+
+    virtual ~TaskGetTypeBitWidth() { }
+
+    int32_t width(vsc::dm::IDataType *t) {
+        m_width = 0;
+        t->accept(m_this);
+        return m_width;
+    }
+
+    virtual void visitDataTypeBool(vsc::dm::IDataTypeBool *t) {
+        m_width += 1;
+    }
+
+    virtual void visitDataTypeInt(vsc::dm::IDataTypeInt *t) {
+        m_width += t->getWidth();
+    }
+
+    virtual void visitDataTypePackedStruct(IDataTypePackedStruct *t) {
+        for (std::vector<vsc::dm::ITypeFieldUP>::const_iterator
+            it=t->getFields().begin();
+            it!=t->getFields().end(); it++) {
+            (*it)->getDataType()->accept(m_this);
+        }
+    }
+
+    virtual void visitDataTypeStruct(vsc::dm::IDataTypeStruct *t) {
+        m_width += 8*t->getByteSize();
+    }
+
+    virtual void visitDataTypeWrapper(vsc::dm::IDataTypeWrapper *t) {
+        t->getDataTypeVirt()->accept(m_this);
+    }
+
+private:
+    int32_t     m_width;
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/impl/TaskIsDataTypeFlowObj.h

@@ -0,0 +1,73 @@
+/**
+ * TaskIsDataTypeFlowObj.h
+ *
+ * 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: 
+ */
+#pragma once
+#include "zsp/arl/dm/impl/VisitorBase.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class TaskIsDataTypeFlowObj : public VisitorBase {
+public:
+    TaskIsDataTypeFlowObj() : 
+        m_ret(false), m_check_kind(false), m_kind(FlowObjKindE::Resource) {
+
+    }
+
+    TaskIsDataTypeFlowObj(FlowObjKindE kind) :
+        m_ret(false), m_check_kind(true), m_kind(kind) {
+
+    }
+
+    virtual ~TaskIsDataTypeFlowObj() { }
+
+    static bool test(vsc::dm::IDataType *t) {
+        TaskIsDataTypeFlowObj task;
+        t->accept(&task);
+        return task.m_ret;
+    }
+
+    static bool test(FlowObjKindE kind, vsc::dm::IDataType *t) {
+        TaskIsDataTypeFlowObj task(kind);
+        t->accept(&task);
+        return task.m_ret;
+    }
+
+	virtual void visitDataTypeFlowObj(IDataTypeFlowObj *t) override {
+        if (m_check_kind) {
+            m_ret = (t->kind() == m_kind);
+        } else {
+            m_ret = true;
+        }
+    } 
+
+private:
+    bool                m_ret;
+    bool                m_check_kind;
+    FlowObjKindE        m_kind;
+
+};
+
+}
+}
+}
+

zsp_arl_dm/share/include/zsp/arl/dm/impl/TaskIsDataTypePyObj.h

@@ -0,0 +1,55 @@
+/**
+ * TaskIsDataTypePyObj.h
+ *
+ * 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: 
+ */
+#pragma once
+#include "zsp/arl/dm/impl/VisitorBase.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class TaskIsDataTypePyObj : public VisitorBase {
+public:
+    TaskIsDataTypePyObj() : m_type(0) {
+
+    }
+
+    virtual ~TaskIsDataTypePyObj() { }
+
+    IDataTypePyObj *check(vsc::dm::IDataType *t) {
+        m_type = 0;
+        t->accept(m_this);
+        return m_type;
+    }
+
+	virtual void visitDataTypePyObj(IDataTypePyObj *t) override {
+        m_type = t;
+    } 
+
+private:
+    IDataTypePyObj      *m_type;
+
+};
+
+}
+}
+}
+

zsp_arl_dm/share/include/zsp/arl/dm/impl/TaskIsPackedStruct.h

@@ -0,0 +1,57 @@
+/**
+ * TaskIsPackedStruct.h
+ *
+ * Copyright 2023 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: 
+ */
+#pragma once
+#include "zsp/arl/dm/impl/VisitorBase.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class TaskIsPackedStruct :
+    public virtual VisitorBase {
+public:
+
+    TaskIsPackedStruct() { }
+
+    virtual ~TaskIsPackedStruct() { }
+
+    IDataTypePackedStruct *check(vsc::dm::IDataType *t) {
+        m_packed = 0;
+        t->accept(m_this);
+        return m_packed;
+    }
+
+    virtual void visitDataTypePackedStruct(arl::dm::IDataTypePackedStruct *t) {
+        m_packed = t;
+    }
+
+private:
+    arl::dm::IDataTypePackedStruct *m_packed;
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/impl/TaskIsRefGroupRef.h

@@ -0,0 +1,60 @@
+/**
+ * TaskIsRefGroupRef.h
+ *
+ * Copyright 2023 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: 
+ */
+#pragma once
+#include "zsp/arl/dm/impl/VisitorBase.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class TaskIsRefGroupRef : public virtual VisitorBase {
+public:
+
+    virtual ~TaskIsRefGroupRef() { }
+
+    bool check(vsc::dm::ITypeField *f) {
+        m_ret = false;
+        f->accept(m_this);
+        return m_ret;
+    }
+
+	virtual void visitTypeField(vsc::dm::ITypeField *f) override { }
+
+	virtual void visitTypeFieldPhy(vsc::dm::ITypeFieldPhy *f) override { }
+
+	virtual void visitTypeFieldRef(vsc::dm::ITypeFieldRef *f) override { }
+
+	virtual void visitTypeFieldRegGroup(ITypeFieldRegGroup *f) override {
+        m_ret = true;
+    }
+
+private:
+    bool            m_ret;
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/impl/TaskIsTypeFieldRegGroup.h

@@ -0,0 +1,60 @@
+/**
+ * TaskIsTypeFieldRegGroup.h
+ *
+ * Copyright 2023 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: 
+ */
+#pragma once
+#include "zsp/arl/dm/impl/VisitorBase.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class TaskIsTypeFieldRegGroup :
+    public virtual arl::dm::VisitorBase {
+public:
+
+    virtual ~TaskIsTypeFieldRegGroup() { }
+
+    bool check(vsc::dm::ITypeField *f) {
+        m_ret = false;
+        f->accept(m_this);
+        return m_ret;
+    }
+
+    virtual void visitTypeFieldRegGroup(arl::dm::ITypeFieldRegGroup *f) override {
+        m_ret = true;
+    }
+
+    virtual void visitTypeFieldRegGroupArr(arl::dm::ITypeFieldRegGroupArr *f) override {
+        m_ret = true;
+    }
+
+private:
+    bool            m_ret;
+
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/impl/TaskIsTypeFieldRegGroupArr.h

@@ -0,0 +1,40 @@
+/**
+ * TaskIsTypeFieldRegGroupArr.h
+ *
+ * Copyright 2023 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: 
+ */
+#pragma once
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class TaskIsTypeFieldRegGroupArr {
+public:
+
+    virtual ~TaskIsTypeFieldRegGroupArr() { }
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/impl/TaskPackStruct2Int.h

@@ -0,0 +1,80 @@
+/**
+ * TaskPackStruct2Int.h
+ *
+ * Copyright 2023 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: 
+ */
+#pragma once
+#include "vsc/dm/impl/ValRefInt.h"
+#include "zsp/arl/dm/IContext.h"
+#include "zsp/arl/dm/impl/VisitorBase.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class TaskPackStruct2Int : public virtual VisitorBase {
+public:
+
+    TaskPackStruct2Int(IContext *ctxt) : m_ctxt(ctxt) { }
+
+    virtual ~TaskPackStruct2Int() { }
+
+    vsc::dm::ValRefInt pack(const vsc::dm::ValRef &v) {
+        m_phase = 0;
+        m_bits = 0;
+        v.type()->accept(m_this);
+
+    }
+
+	virtual void visitDataTypeBool(vsc::dm::IDataTypeBool *t) override { 
+        if (m_phase == 1) {
+            // 
+        }
+
+        m_bits += 1;
+    }
+
+	virtual void visitDataTypeInt(vsc::dm::IDataTypeInt *t) override { 
+        if (m_phase == 1) {
+            // 
+        }
+
+        m_bits += t->width();
+    }
+
+	virtual void visitDataTypeStruct(vsc::dm::IDataTypeStruct *t) override {
+        for (uint32_t i=0; i<t->getFields().size(); i++) {
+            t->getField(i)->accept(m_this);
+        }
+    }
+
+protected:
+    IContext                    *m_ctxt;
+    int32_t                     m_phase;
+    int32_t                     m_bits;
+    vsc::dm::ValRef             m_val;
+    vsc::dm::ValRefInt          m_ival;
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+