zuspec-arl-dm 0.1.0.15264414400rc0__cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

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

@@ -0,0 +1,346 @@
+/**
+ * RewriteVisitorBase.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 "vsc/dm/impl/RewriteVisitorBase.h"
+#include "zsp/arl/dm/IVisitor.h"
+#include "zsp/arl/dm/IDataTypeAction.h"
+#include "zsp/arl/dm/IDataTypeActivityBind.h"
+#include "zsp/arl/dm/IDataTypeActivityParallel.h"
+#include "zsp/arl/dm/IDataTypeActivityReplicate.h"
+#include "zsp/arl/dm/IDataTypeActivitySchedule.h"
+#include "zsp/arl/dm/IDataTypeActivitySequence.h"
+#include "zsp/arl/dm/IDataTypeActivityTraverse.h"
+#include "zsp/arl/dm/IDataTypeComponent.h"
+#include "zsp/arl/dm/IDataTypeFlowObj.h"
+#include "zsp/arl/dm/IDataTypeFunction.h"
+#include "zsp/arl/dm/IDataTypeFunctionParamDecl.h"
+#include "zsp/arl/dm/IDataTypeResource.h"
+#include "zsp/arl/dm/IModelActivityBind.h"
+#include "zsp/arl/dm/IModelActivityParallel.h"
+#include "zsp/arl/dm/IModelActivityReplicate.h"
+#include "zsp/arl/dm/IModelActivitySchedule.h"
+#include "zsp/arl/dm/IModelActivityScope.h"
+#include "zsp/arl/dm/IModelActivitySequence.h"
+#include "zsp/arl/dm/IModelActivityTraverse.h"
+#include "zsp/arl/dm/IModelFieldAction.h"
+#include "zsp/arl/dm/IModelFieldClaim.h"
+#include "zsp/arl/dm/IModelFieldComponent.h"
+#include "zsp/arl/dm/IModelFieldComponentRoot.h"
+#include "zsp/arl/dm/IModelFieldExecutor.h"
+#include "zsp/arl/dm/IModelFieldExecutorClaim.h"
+#include "zsp/arl/dm/IModelFieldInOut.h"
+#include "zsp/arl/dm/IModelFieldPool.h"
+#include "zsp/arl/dm/IVisitor.h"
+#include "zsp/arl/dm/ITypeExprMethodCallContext.h"
+#include "zsp/arl/dm/ITypeExprMethodCallStatic.h"
+#include "zsp/arl/dm/ITypeExecProc.h"
+#include "zsp/arl/dm/ITypeFieldActivity.h"
+#include "zsp/arl/dm/ITypeFieldClaim.h"
+#include "zsp/arl/dm/ITypeFieldExecutor.h"
+#include "zsp/arl/dm/ITypeFieldExecutorClaim.h"
+#include "zsp/arl/dm/ITypeFieldInOut.h"
+#include "zsp/arl/dm/ITypeFieldPool.h"
+#include "zsp/arl/dm/ITypeProcStmtAssign.h"
+#include "zsp/arl/dm/ITypeProcStmtBreak.h"
+#include "zsp/arl/dm/ITypeProcStmtContinue.h"
+#include "zsp/arl/dm/ITypeProcStmtExpr.h"
+#include "zsp/arl/dm/ITypeProcStmtForeach.h"
+#include "zsp/arl/dm/ITypeProcStmtIfElse.h"
+#include "zsp/arl/dm/ITypeProcStmtMatch.h"
+#include "zsp/arl/dm/ITypeProcStmtRepeat.h"
+#include "zsp/arl/dm/ITypeProcStmtRepeatWhile.h"
+#include "zsp/arl/dm/ITypeProcStmtReturn.h"
+#include "zsp/arl/dm/ITypeProcStmtScope.h"
+#include "zsp/arl/dm/ITypeProcStmtVarDecl.h"
+#include "zsp/arl/dm/ITypeProcStmtWhile.h"
+
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class RewriteVisitorBase :
+    public virtual IVisitor,
+    public virtual vsc::dm::RewriteVisitorBase {
+public:
+    RewriteVisitorBase() { }
+
+    virtual ~RewriteVisitorBase() { }
+
+	virtual void visitDataTypeAction(IDataTypeAction *i) override {
+		m_this->visitDataTypeStruct(i);
+		for (std::vector<ITypeFieldActivity *>::const_iterator
+				it=i->activities().begin();
+				it!=i->activities().end(); it++) {
+			(*it)->accept(m_this);
+		}
+	}
+
+	virtual void visitDataTypeActivityBind(IDataTypeActivityBind *t) override {
+		for (std::vector<vsc::dm::ITypeExprFieldRefUP>::const_iterator
+			it=t->getTargets().begin();
+			it!=t->getTargets().end(); it++) {
+			(*it)->accept(m_this);
+		}
+	}
+
+	virtual void visitDataTypeActivityParallel(IDataTypeActivityParallel *t) override {
+		m_this->visitDataTypeStruct(t);
+	}
+
+	virtual void visitDataTypeActivityReplicate(IDataTypeActivityReplicate *t) override {
+		t->getCount()->accept(m_this);
+		m_this->visitDataTypeStruct(t);
+	}
+
+	virtual void visitDataTypeActivitySchedule(IDataTypeActivitySchedule *t) override {
+		m_this->visitDataTypeStruct(t);
+	}
+
+	virtual void visitDataTypeActivitySequence(IDataTypeActivitySequence *t) override {
+		m_this->visitDataTypeStruct(t);
+	}
+
+	virtual void visitDataTypeActivityTraverse(IDataTypeActivityTraverse *t) override { }
+
+	virtual void visitDataTypeComponent(IDataTypeComponent *t) override {
+		m_this->visitDataTypeStruct(t);
+	}
+
+	virtual void visitDataTypeFlowObj(IDataTypeFlowObj *t) override {
+		m_this->visitDataTypeStruct(t);
+	}
+
+	virtual void visitDataTypeFunction(IDataTypeFunction *t) override {
+
+	}
+    
+	virtual void visitDataTypeFunctionParamDecl(IDataTypeFunctionParamDecl *t) override {
+        t->getDataType()->accept(m_this);
+        if (t->getInit()) {
+            t->getInit()->accept(m_this);
+        }
+    }
+
+	virtual void visitDataTypeResource(IDataTypeResource *t) override {
+		visitDataTypeFlowObj(t);
+	}
+
+	virtual void visitModelActivityBind(IModelActivityBind *a) override {
+		for (std::vector<vsc::dm::IModelExprUP>::const_iterator
+			it=a->getTargets().begin();
+			it!=a->getTargets().end(); it++) {
+			(*it)->accept(m_this);
+		}
+	}
+
+	virtual void visitModelActivityParallel(IModelActivityParallel *a) override {
+		for (std::vector<IModelActivity *>::const_iterator
+				it=a->branches().begin();
+				it!=a->branches().end(); it++) {
+			(*it)->accept(m_this);
+		}
+	}
+
+	virtual void visitModelActivityReplicate(IModelActivityReplicate *a) override {
+		a->getCountExpr()->accept(m_this);
+		visitModelActivityScope(a);
+	}
+
+	virtual void visitModelActivitySchedule(IModelActivitySchedule *a) override {
+		for (std::vector<IModelActivity *>::const_iterator
+				it=a->activities().begin();
+				it!=a->activities().end(); it++) {
+			(*it)->accept(m_this);
+		}
+	}
+	
+	virtual void visitModelActivityScope(IModelActivityScope *a) override {
+		for (std::vector<IModelActivity *>::const_iterator
+				it=a->activities().begin();
+				it!=a->activities().end(); it++) {
+			(*it)->accept(m_this);
+		}
+	}
+
+	virtual void visitModelActivitySequence(IModelActivitySequence *a) override {
+		for (std::vector<IModelActivity *>::const_iterator
+				it=a->activities().begin();
+				it!=a->activities().end(); it++) {
+			(*it)->accept(m_this);
+		}
+	}
+
+	virtual void visitModelActivityTraverse(IModelActivityTraverse *a) override {
+		a->getTarget()->accept(m_this);
+		if (a->getWithC()) {
+			a->getWithC()->accept(m_this);
+		}
+	}
+
+	virtual void visitModelFieldAction(IModelFieldAction *f) override {
+		m_this->visitModelField(f);
+		if (f->getActivity()) {
+			f->getActivity()->accept(m_this);
+		}
+	}
+
+	virtual void visitModelFieldClaim(IModelFieldClaim *f) override { }
+
+	virtual void visitModelFieldComponent(IModelFieldComponent *f) override {
+		m_this->visitModelField(f);
+	}
+
+	virtual void visitModelFieldComponentRoot(IModelFieldComponentRoot *f) override {
+		visitModelFieldComponent(f);
+	}
+
+	virtual void visitModelFieldExecutor(IModelFieldExecutor *f) override {
+		m_this->visitModelField(f);
+	}
+
+	virtual void visitModelFieldExecutorClaim(IModelFieldExecutorClaim *f) override {
+		m_this->visitModelFieldRef(f);
+	}
+
+	virtual void visitModelFieldInOut(IModelFieldInOut *f) override { }
+
+	virtual void visitModelFieldPool(IModelFieldPool *f) override {
+		m_this->visitModelField(f);
+	}
+
+    virtual void visitTypeExprMethodCallContext(ITypeExprMethodCallContext *e) override {
+        visitTypeExprMethodCallStatic(e);
+        e->getContext()->accept(m_this);
+    }
+
+    virtual void visitTypeExprMethodCallStatic(ITypeExprMethodCallStatic *e) override {
+        e->getTarget()->accept(m_this);
+    }
+
+	virtual void visitTypeExec(ITypeExec *e) override { }
+
+	virtual void visitTypeExecProc(ITypeExecProc *e) override {
+        dynamic_cast<IVisitor *>(m_this)->visitTypeExec(e);
+        e->getBody()->accept(m_this);
+    }
+
+	virtual void visitTypeFieldActivity(ITypeFieldActivity *f) override {
+		m_this->visitTypeField(f);
+	}
+
+	virtual void visitTypeFieldClaim(ITypeFieldClaim *f) override {
+		m_this->visitTypeFieldRef(f);
+	}
+
+	virtual void visitTypeFieldExecutor(ITypeFieldExecutor *f) override {
+		m_this->visitTypeField(f);
+	}
+
+	virtual void visitTypeFieldExecutorClaim(ITypeFieldExecutorClaim *f) override {
+		m_this->visitTypeFieldRef(f);
+	}
+
+	virtual void visitTypeFieldInOut(ITypeFieldInOut *f) override {
+		m_this->visitTypeFieldRef(f);
+	}
+
+	virtual void visitTypeFieldPool(ITypeFieldPool *f) override {
+		m_this->visitTypeField(f);
+	}
+
+	virtual void visitTypeProcStmtAssign(ITypeProcStmtAssign *s) override {
+		s->getLhs()->accept(m_this);
+		s->getRhs()->accept(m_this);
+	}
+
+	virtual void visitTypeProcStmtBreak(ITypeProcStmtBreak *s) override {
+
+	}
+
+	virtual void visitTypeProcStmtContinue(ITypeProcStmtContinue *s) override {
+
+	}
+
+	virtual void visitTypeProcStmtExpr(ITypeProcStmtExpr *s) override {
+        s->getExpr()->accept(m_this);
+	}
+
+	virtual void visitTypeProcStmtForeach(ITypeProcStmtForeach *s) override {
+
+	}
+
+	virtual void visitTypeProcStmtIfElse(ITypeProcStmtIfElse *s) override {
+		s->getCond()->accept(m_this);
+		s->getTrue()->accept(m_this);
+		if (s->getFalse()) {
+			s->getFalse()->accept(m_this);
+		}
+	}
+
+	virtual void visitTypeProcStmtMatch(ITypeProcStmtMatch *s) override {
+		s->getCond()->accept(m_this);
+	}
+
+	virtual void visitTypeProcStmtRepeat(ITypeProcStmtRepeat *s) override {
+		s->getExpr()->accept(m_this);
+		s->getBody()->accept(m_this);
+	}
+
+	virtual void visitTypeProcStmtRepeatWhile(ITypeProcStmtRepeatWhile *s) override {
+		s->getExpr()->accept(m_this);
+		s->getBody()->accept(m_this);
+	}
+
+	virtual void visitTypeProcStmtReturn(ITypeProcStmtReturn *s) override {
+		if (s->getExpr()) {
+			s->getExpr()->accept(m_this);
+		}
+	}
+
+	virtual void visitTypeProcStmtScope(ITypeProcStmtScope *s) override {
+		for (std::vector<ITypeProcStmtUP>::const_iterator
+			it=s->getStatements().begin();
+			it!=s->getStatements().end(); it++) {
+			(*it)->accept(m_this);
+		}
+	}
+
+	virtual void visitTypeProcStmtVarDecl(ITypeProcStmtVarDecl *s) override {
+		s->getDataType()->accept(m_this);
+		if (s->getInit()) {
+			s->getInit()->accept(m_this);
+		}
+	}
+
+	virtual void visitTypeProcStmtWhile(ITypeProcStmtWhile *s) override {
+		s->getExpr()->accept(m_this);
+		s->getBody()->accept(m_this);
+	}
+
+};
+
+}
+}
+}
+
+

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

@@ -0,0 +1,76 @@
+/**
+ * TaskActionHasMemClaim.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 TaskActionHasMemClaim : 
+    public virtual VisitorBase {
+public:
+
+    TaskActionHasMemClaim() { };
+
+    virtual ~TaskActionHasMemClaim() { }
+
+    bool check(IDataTypeAction *a) {
+        m_has = false;
+        m_depth = 0;
+        a->accept(m_this);
+        return m_has;
+    }
+
+    virtual void visitDataTypeAction(IDataTypeAction *t) {
+        if (m_depth == 0) {
+            m_depth++;
+            for (std::vector<vsc::dm::ITypeFieldUP>::const_iterator
+                it=t->getFields().begin();
+                it!=t->getFields().end(); it++) {
+                (*it)->accept(m_this);
+            }
+            m_depth--;
+        }
+    }
+
+    virtual void visitTypeFieldAddrClaim(ITypeFieldAddrClaim *t) {
+        m_has = true;
+    }
+
+    virtual void visitTypeFieldAddrClaimTransparent(ITypeFieldAddrClaimTransparent *t) {
+        m_has = true;
+    }
+
+
+private:
+    int32_t         m_depth;
+    bool            m_has;
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

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

@@ -0,0 +1,63 @@
+
+#pragma once
+#include "dmgr/impl/DebugMacros.h"
+#include "zsp/arl/dm/impl/VisitorBase.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class TaskCollectTopLevelActivities : public virtual VisitorBase {
+public:
+
+    TaskCollectTopLevelActivities() {
+//        DEBUG_INIT("TaskCollectTopLevelActivities");
+        m_activities = 0;
+        m_dbg = 0;
+    }
+    
+    virtual ~TaskCollectTopLevelActivities() { }
+
+    void collect(
+        std::vector<IModelActivity *>   &activities,
+        IModelActivity                  *activity) {
+        DEBUG_ENTER("collect");
+        m_activities = &activities;
+
+        activity->accept(m_this);
+        DEBUG_LEAVE("collect %d", activities.size());
+    }
+
+	virtual void visitModelActivityParallel(IModelActivityParallel *a) override {
+        DEBUG_ENTER("visitModelActivityParallel");
+        m_activities->push_back(a);
+        DEBUG_LEAVE("visitModelActivityParallel");
+    }
+
+	virtual void visitModelActivitySchedule(IModelActivitySchedule *a) override {
+        DEBUG_ENTER("visitModelActivitySchedule");
+        m_activities->push_back(a);
+        DEBUG_LEAVE("visitModelActivitySchedule");
+    }
+
+	virtual void visitModelActivitySequence(IModelActivitySequence *a) override {
+        DEBUG_ENTER("visitModelActivitySequence");
+        VisitorBase::visitModelActivitySequence(a);
+        DEBUG_LEAVE("visitModelActivitySequence");
+    }
+
+	virtual void visitModelActivityTraverse(IModelActivityTraverse *a) override {
+        DEBUG_ENTER("visitModelActivityTraverse");
+        m_activities->push_back(a);
+        DEBUG_LEAVE("visitModelActivityTraverse");
+    }
+
+private:
+    dmgr::IDebug                        *m_dbg;
+    std::vector<IModelActivity *>       *m_activities;
+};
+
+}
+}
+}

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

@@ -0,0 +1,69 @@
+/**
+ * TaskFindExecutor.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/IModelFieldExecutor.h"
+#include "zsp/arl/dm/impl/VisitorBase.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+
+class TaskFindExecutor : public VisitorBase {
+public:
+
+    TaskFindExecutor() : m_executor(0) { }
+
+    virtual ~TaskFindExecutor() { }
+
+    IModelFieldExecutor *find(vsc::dm::IModelField *f) {
+        m_executor = 0;
+        m_depth = 0;
+        f->accept(m_this);
+        return m_executor;
+    }
+
+    virtual void visitModelField(vsc::dm::IModelField *f) override {
+        // Block from recursing
+        if (!m_depth) {
+            m_depth++;
+            VisitorBase::visitModelField(f);
+            m_depth--;
+        }
+    }
+
+	virtual void visitModelFieldExecutorClaim(IModelFieldExecutorClaim *f) override {
+        m_executor = dynamic_cast<IModelFieldExecutor *>(f->getRef());
+    }
+
+private:
+    IModelFieldExecutor                 *m_executor;
+    uint32_t                            m_depth;
+
+};
+
+}
+}
+}
+
+

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

@@ -0,0 +1,84 @@
+/**
+ * TaskGetExprDataType.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/IContext.h"
+#include "zsp/arl/dm/impl/VisitorBase.h" 
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class TaskGetExprDataType :
+    public virtual arl::dm::VisitorBase {
+public:
+
+    TaskGetExprDataType(IContext *ctxt) : m_ctxt(ctxt) { }
+
+    virtual ~TaskGetExprDataType() { }
+
+    vsc::dm::IDataType *get_type(vsc::dm::ITypeExpr *e) {
+        m_type = 0;
+        e->accept(m_this);
+        return m_type;
+    }
+
+    virtual void visitTypeExprBin(vsc::dm::ITypeExprBin *e) {
+        switch (e->op()) {
+	        case vsc::dm::BinOp::Eq:
+	        case vsc::dm::BinOp::Ne:
+	        case vsc::dm::BinOp::Gt:
+	        case vsc::dm::BinOp::Ge:
+	        case vsc::dm::BinOp::Lt:
+	        case vsc::dm::BinOp::Le:
+                m_type = m_ctxt->getDataTypeCore(vsc::dm::DataTypeCoreE::Bool);
+                break;
+	        case vsc::dm::BinOp::Add:
+	        case vsc::dm::BinOp::Sub:
+	        case vsc::dm::BinOp::Div:
+	        case vsc::dm::BinOp::Mul:
+	        case vsc::dm::BinOp::Mod:
+	        case vsc::dm::BinOp::BinAnd:
+	        case vsc::dm::BinOp::BinOr:
+	        case vsc::dm::BinOp::BinXor:
+	        case vsc::dm::BinOp::LogAnd:
+	        case vsc::dm::BinOp::LogOr:
+	        case vsc::dm::BinOp::LogXor:
+	        case vsc::dm::BinOp::Sll:
+	        case vsc::dm::BinOp::Srl:
+                e->lhs()->accept(m_this);
+                break;
+        }
+    }
+
+
+private:
+    IContext                    *m_ctxt;
+    vsc::dm::IDataType          *m_type;
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+