zuspec-arl-dm 0.1.0.15264414400rc0__cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

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

@@ -0,0 +1,123 @@
+/**
+ * TaskUnpackInt2Struct.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 "dmgr/IDebugMgr.h"
+#include "dmgr/impl/DebugMacros.h"
+#include "vsc/dm/impl/ValRefBool.h"
+#include "vsc/dm/impl/ValRefStruct.h"
+#include "zsp/arl/dm/IContext.h"
+#include "zsp/arl/dm/impl/VisitorBase.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class TaskUnpackInt2Struct : public virtual VisitorBase {
+public:
+
+    TaskUnpackInt2Struct(
+        dmgr::IDebugMgr     *dmgr,
+        IContext            *ctxt) : m_dbg(0), m_ctxt(ctxt) { 
+        DEBUG_INIT("zsp::arl::dm::TaskUnpackInt2Struct", dmgr);
+    }
+
+    virtual ~TaskUnpackInt2Struct() { }
+
+    vsc::dm::ValRef unpack(
+        const vsc::dm::ValRef       &val_i,
+        vsc::dm::IDataTypeStruct    *dst_t) {
+        DEBUG_ENTER("unpack val_i=0x%08x", vsc::dm::ValRefInt(val_i).get_val_u());
+        vsc::dm::ValRefStruct val_s(m_ctxt->mkValRefStruct(dst_t));
+        m_bit = 0;
+        m_val_i = val_i;
+        m_val_result_s.clear();
+        m_val_result_s.push_back(val_s);
+        dst_t->accept(m_this);
+        DEBUG("val_s[0]=0x%08x", vsc::dm::ValRefInt(val_s.getFieldRef(0)).get_val_u());
+        DEBUG("val_s[1]=0x%08x", vsc::dm::ValRefInt(val_s.getFieldRef(1)).get_val_u());
+        DEBUG_LEAVE("unpack");
+        return val_s;
+    }
+
+	virtual void visitDataTypeBool(vsc::dm::IDataTypeBool *t) override { 
+        DEBUG_ENTER("visitDataTypeBool");
+        vsc::dm::ValRefBool val(m_val_result_s.back());
+        val.set_val((m_val_i.get_val_u() >> m_bit) & 1);
+
+        m_bit += 1;
+        DEBUG_LEAVE("visitDataTypeBool");
+    }
+
+	virtual void visitDataTypeEnum(vsc::dm::IDataTypeEnum *t) override { 
+        DEBUG_ENTER("visitDataTypeEnum");
+        vsc::dm::ValRefInt val(m_val_result_s.back());
+        val.set_val((m_val_i.get_val_u() >> m_bit) & 0xFFFFFFFF);
+
+        m_bit += 32;
+        DEBUG_LEAVE("visitDataTypeEnum");
+    }
+
+	virtual void visitDataTypeInt(vsc::dm::IDataTypeInt *t) override { 
+        DEBUG_ENTER("visitDataTypeInt width=%d", t->getWidth());
+        vsc::dm::ValRefInt val(m_val_result_s.back());
+        if (t->width() == 64) {
+            val.set_val((m_val_i.get_val_u() >> m_bit));
+        } else {
+            uint64_t ival = (m_val_i.get_val_u() >> m_bit) & (1ULL << t->getWidth())-1;
+            DEBUG("set_val: 0x%08x", ival);
+            val.set_val(ival);
+            DEBUG("get_val: 0x%08x", val.get_val_u());
+        }
+
+        m_bit += t->getWidth();
+        DEBUG_LEAVE("visitDataTypeInt width=%d", t->getWidth());
+    }
+
+	virtual void visitDataTypeStruct(vsc::dm::IDataTypeStruct *t) override {
+        DEBUG_ENTER("visitDataTypeStruct");
+
+        vsc::dm::ValRefStruct val_s(m_val_result_s.back());
+        for (uint32_t i=0; i<t->getFields().size(); i++) {
+            m_val_result_s.push_back(val_s.getFieldRef(i));
+            t->getFields().at(i)->getDataType()->accept(m_this);
+            m_val_result_s.pop_back();
+        }
+
+        DEBUG_LEAVE("visitDataTypeStruct");
+    }
+
+
+private:
+    dmgr::IDebug                      *m_dbg;
+    IContext                          *m_ctxt;
+    uint32_t                          m_bit;
+    vsc::dm::ValRefInt                m_val_i;
+    std::vector<vsc::dm::ValRef>      m_val_result_s;
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

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

@@ -0,0 +1,70 @@
+/**
+ * TaskVisitActionTypeClaimRef.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 <functional>
+#include "zsp/arl/dm/impl/VisitorBase.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class TaskVisitActionTypeClaimRef : public VisitorBase {
+public:
+    TaskVisitActionTypeClaimRef(
+        const std::function<void (ITypeFieldInOut *)>  &ref_f,
+        const std::function<void (ITypeFieldClaim *)>  &claim_f
+    ) : m_depth(0), m_ref_f(ref_f), m_claim_f(claim_f) { }
+
+    virtual ~TaskVisitActionTypeClaimRef() { }
+
+    void visit(IDataTypeAction *t) {
+        t->accept(m_this);
+    }
+
+	virtual void visitDataTypeAction(IDataTypeAction *i) override {
+        if (!m_depth) {
+            m_depth++;
+            VisitorBase::visitDataTypeAction(i);
+            m_depth--;
+        }
+    }
+
+	virtual void visitTypeFieldInOut(ITypeFieldInOut *f) override {
+        m_ref_f(f);
+    }
+
+	virtual void visitTypeFieldClaim(ITypeFieldClaim *f) override {
+        m_claim_f(f);
+    }
+
+private:
+    int32_t                                   m_depth;
+    std::function<void (ITypeFieldInOut *)>   m_ref_f;
+    std::function<void (ITypeFieldClaim *)>   m_claim_f;
+};
+
+}
+}
+}
+
+

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

@@ -0,0 +1,64 @@
+/**
+ * TaskVisitModelFieldClaim.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 <functional>
+#include "zsp/arl/dm/impl/VisitorBase.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class TaskVisitModelFieldClaim : public VisitorBase {
+public:
+    TaskVisitModelFieldClaim(
+        const std::function<void (IModelFieldClaim *)> &func) : 
+            m_func(func), m_depth(0) { }
+
+    virtual ~TaskVisitModelFieldClaim() { }
+
+    void visit(IModelFieldAction *action) {
+        m_depth = 0;
+        action->accept(m_this);
+    }
+
+	virtual void visitModelFieldAction(IModelFieldAction *f) override {
+        if (!m_depth) {
+            m_depth++;
+            VisitorBase::visitModelFieldAction(f);
+            m_depth--;
+        }
+    }
+
+	virtual void visitModelFieldClaim(IModelFieldClaim *f) override {
+        m_func(f);
+    }
+
+private:
+    uint32_t                                        m_depth;
+    std::function<void (IModelFieldClaim *)>        m_func;
+};
+
+}
+}
+}
+
+

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

@@ -0,0 +1,64 @@
+/**
+ * TaskVisitModelFieldInOut.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 <functional>
+#include "zsp/arl/dm/impl/VisitorBase.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class TaskVisitModelFieldInOut : public VisitorBase {
+public:
+    TaskVisitModelFieldInOut(
+        const std::function<void (IModelFieldInOut *)> &func) :
+            m_func(func), m_depth(0) { }
+
+    virtual ~TaskVisitModelFieldInOut() { }
+
+    void visit(IModelFieldAction *t) {
+        t->accept(m_this);
+    }
+
+	virtual void visitModelFieldAction(IModelFieldAction *f) override {
+        if (!m_depth) {
+            m_depth++;
+            VisitorBase::visitModelFieldAction(f);
+            m_depth--;
+        }
+    }
+
+	virtual void visitModelFieldInOut(IModelFieldInOut *f) override {
+        m_func(f);
+    }
+
+private:
+    std::function<void (IModelFieldInOut *)>        m_func;
+    uint32_t                                        m_depth;
+};
+
+}
+}
+}
+
+

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

@@ -0,0 +1,43 @@
+/**
+ * ValRefAction.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/ValRefStruct.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class ValRefAction : public vsc::dm::ValRefStruct{
+public:
+
+    ValRefAction(const vsc::dm::ValRef &rhs) : ValRefStruct(rhs) { }
+
+    virtual ~ValRefAction() { }
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

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

@@ -0,0 +1,63 @@
+/**
+ * ValRefActivity.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/ValRefStruct.h"
+#include "zsp/arl/dm/IDataTypeActivityScope.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class ValRefActivityScope : public vsc::dm::ValRefStruct {
+public:
+
+    ValRefActivityScope(const ValRef &rhs) : ValRefStruct(rhs) { }
+
+    virtual ~ValRefActivityScope() { }
+
+    int32_t getNumActivities() const {
+        return dynamic_cast<IDataTypeActivityScope *>(type())->getActivities().size();
+    }
+
+    vsc::dm::ValRef getActivityRef(int32_t i) {
+        char *ptr = reinterpret_cast<char *>(m_vp);
+        IDataTypeActivityScope *scope = dynamic_cast<IDataTypeActivityScope *>(type());
+        ITypeFieldActivity *activity = scope->getActivities().at(i).get();
+        vsc::dm::ValRef::Flags flags = static_cast<ValRef::Flags>(
+            static_cast<uint32_t>(m_flags) & ~static_cast<uint32_t>(ValRef::Flags::Owned));
+        flags = flags | ValRef::Flags::IsPtr;
+        int32_t offset = scope->getActivityOffset()+activity->getOffset();
+        return vsc::dm::ValRef(
+            reinterpret_cast<uintptr_t>(&ptr[offset]),
+            field,
+            flags
+        );
+    }
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

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

@@ -0,0 +1,51 @@
+/**
+ * ValRefActivity.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/ValRefStruct.h"
+#include "zsp/arl/dm/IDataTypeActivity.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class ValRefActivity : public vsc::dm::ValRefStruct {
+public:
+
+    ValRefActivity(const ValRef &rhs) : ValRefStruct(rhs) { }
+
+    virtual ~ValRefActivity() { }
+
+    int32_t getNumActivities() const {
+        return dynamic_cast<IDataTypeActivity *>(type())->getA
+
+    }
+
+    ValRef getActivityRef(int32_t)
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

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

@@ -0,0 +1,75 @@
+/**
+ * ValRefPyObj.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/ValRefPtr.h"
+
+namespace pyapi {
+    struct PyEvalObj;
+}
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class ValRefPyObj : public virtual vsc::dm::ValRefPtr {
+public:
+
+    ValRefPyObj(const ValRef &rhs) : vsc::dm::ValRefPtr(rhs) {
+        if (type()) {
+            // Acquire the object
+            type()->initVal(*this);
+        }
+    }
+
+    virtual ~ValRefPyObj() {
+        if (type()) {
+            // Release the object
+            type()->finiVal(*this);
+        }
+    }
+
+    pyapi::PyEvalObj *getObj() const {
+        return reinterpret_cast<pyapi::PyEvalObj *>(ValRefPtr::get_val());
+    }
+
+    void setObj(pyapi::PyEvalObj *obj) {
+        // Release current object
+        if (type() && get_val()) {
+            type()->finiVal(*this);
+        }
+
+        set_val(reinterpret_cast<uintptr_t>(obj));
+
+        // Acquire the new object 
+        if (type() && get_val()) {
+            type()->initVal(*this);
+        }
+    }
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

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

@@ -0,0 +1,32 @@
+/**
+ * ValRefRegGroup.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
+
+
+
+class ValRefRegGroup {
+public:
+
+    virtual ~ValRefRegGroup() { }
+
+};
+
+