zuspec-arl-eval 0.0.7.13253972717rc0__cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

zsp_arl_eval/share/include/zsp/arl/eval/IEvalThread.h

@@ -0,0 +1,94 @@
+/**
+ * IEvalThread.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 <vector>
+#include "dmgr/IDebugMgr.h"
+#include "vsc/dm/impl/UP.h"
+#include "vsc/dm/impl/ValRefInt.h"
+#include "zsp/arl/dm/IDataTypeFunction.h"
+#include "zsp/arl/eval/IEval.h"
+#include "zsp/arl/eval/IEvalStackFrame.h"
+#include "zsp/arl/eval/IEvalThreadId.h"
+#include "zsp/arl/eval/IEvalValProvider.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+class IEvalBackend;
+
+class IEvalThread;
+using IEvalThreadUP=vsc::dm::UP<IEvalThread>;
+class IEvalThread : public virtual IEval {
+public:
+
+    virtual ~IEvalThread() { }
+
+    virtual IEvalBackend *getBackend() const = 0;
+
+    /**
+     * @brief Push an eval-stack entry
+     */
+    virtual void pushEval(IEval *e, bool owned=false) = 0;
+
+    /**
+     * @brief Convert eval-stack entry to a suspended entry
+     */
+    virtual void suspendEval(IEval *e) = 0;
+
+    virtual void popEval(IEval *e) = 0;
+
+    virtual IEvalThreadId *getThreadId() const = 0;
+
+    virtual void setThreadId(IEvalThreadId *tid) = 0;
+
+    /**
+     * @brief Initiates a method call using this thread as context.
+     *        If the return is '0', then the result is immediately
+     *        available. Otherwise, subsequent calls to eval must
+     *        be made.
+     * 
+     * @param method 
+     * @param method_ctxt 
+     * @param params 
+     * @return int32_t 
+     */
+    virtual int32_t evalMethodCallContext(
+        dm::IDataTypeFunction                   *method,
+        vsc::dm::IModelField                    *method_ctxt,
+        const std::vector<vsc::dm::ITypeExpr *> &params) =  0;
+
+    virtual vsc::dm::ValRefInt getAddrHandleValue(const vsc::dm::ValRef &addr_h) = 0;
+
+    virtual dmgr::IDebugMgr *getDebugMgr() const = 0;
+
+    virtual vsc::dm::ValRefInt mkValRefInt(
+        int64_t value, 
+        bool is_signed, 
+        int32_t width) = 0;
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_eval/share/include/zsp/arl/eval/IEvalThreadEventListener.h

@@ -0,0 +1,42 @@
+/**
+ * IEvalThreadEventListener.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 eval {
+
+
+
+class IEvalThreadEventListener {
+public:
+
+    virtual ~IEvalThreadEventListener() { }
+
+    virtual void event() = 0;
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_eval/share/include/zsp/arl/eval/IEvalThreadId.h

@@ -0,0 +1,41 @@
+/**
+ * IEvalThreadId.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/UP.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+class IEvalThreadId;
+using IEvalThreadIdUP=vsc::dm::UP<IEvalThreadId>;
+class IEvalThreadId {
+public:
+
+    virtual ~IEvalThreadId() { }
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_eval/share/include/zsp/arl/eval/IEvalValProvider.h

@@ -0,0 +1,52 @@
+/**
+ * IEvalValProvider.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/ITypeExprFieldRef.h"
+#include "vsc/dm/impl/ValRef.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+
+
+class IEvalValProvider {
+public:
+
+    virtual ~IEvalValProvider() { }
+
+    virtual vsc::dm::ValRef getImmVal(
+        vsc::dm::ITypeExprFieldRef::RootRefKind root_kind,
+        int32_t                                 root_offset,
+        int32_t                                 val_offset) = 0;
+
+    virtual vsc::dm::ValRef getMutVal(
+        vsc::dm::ITypeExprFieldRef::RootRefKind root_kind,
+        int32_t                                 root_offset,
+        int32_t                                 val_offset) = 0;
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_eval/share/include/zsp/arl/eval/IFactory.h

@@ -0,0 +1,90 @@
+/**
+ * IFactory.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 "dmgr/IDebugMgr.h"
+#include "pyapi-compat-if/IPyEval.h"
+#include "vsc/solvers/IFactory.h"
+#include "zsp/arl/dm/IContext.h"
+#include "zsp/arl/eval/IComponentTreeData.h"
+#include "zsp/arl/eval/IModelEvaluator.h"
+#include "zsp/arl/eval/IEvalBackend.h"
+#include "zsp/arl/eval/IEvalContext.h"
+#include "zsp/arl/eval/IEvalStackFrame.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+
+
+class IFactory {
+public:
+
+    virtual ~IFactory() { }
+
+    virtual void init(dmgr::IDebugMgr *dmgr) = 0;
+
+    virtual IComponentTreeData *mkComponentTreeData(
+        arl::dm::IDataTypeComponent     *root_t) = 0;
+
+    virtual IModelEvaluator *mkModelEvaluator(
+        ModelEvaluatorKind          kind,
+        vsc::solvers::IFactory      *solvers_f,
+        arl::dm::IContext           *ctxt) = 0;
+
+    virtual IEvalContext *mkEvalContextFullElab(
+        vsc::solvers::IFactory          *solvers_f,
+        arl::dm::IContext               *ctxt,
+        const vsc::solvers::IRandState  *randstate,
+        pyapi::IPyEval                  *pyeval,
+        dm::IDataTypeComponent          *root_comp,
+        dm::IDataTypeAction             *root_action,
+        IEvalBackend                    *backend) = 0;
+
+    virtual IEvalThread *mkEvalThread(
+        IEvalBackend                    *backend,
+        IEvalThread                     *parent) = 0;
+
+    virtual IEvalContext *mkEvalContextFunctionStatic(
+        vsc::solvers::IFactory                      *solvers_f,
+        arl::dm::IContext                           *ctxt,
+        const vsc::solvers::IRandState              *randstate,
+        IEvalBackend                                *backend,
+        dm::IDataTypeFunction                       *func,
+        const std::vector<vsc::dm::ITypeExpr *>     &params) = 0;
+
+    virtual IEvalContext *mkEvalContextFunctionContext(
+        vsc::solvers::IFactory                      *solvers_f,
+        arl::dm::IContext                           *ctxt,
+        const vsc::solvers::IRandState              *randstate,
+        IEvalBackend                                *backend,
+        dm::IDataTypeFunction                       *func,
+        vsc::dm::IModelField                        *func_ctxt,
+        const std::vector<vsc::dm::ITypeExpr *>     &params) = 0;
+
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_eval/share/include/zsp/arl/eval/IModelAddressSpace.h

@@ -0,0 +1,46 @@
+/**
+ * IModelAddressSpace.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/eval/IEvalThread.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+
+
+class IModelAddressSpace {
+public:
+
+    virtual ~IModelAddressSpace() { }
+
+    virtual void addNonallocatableRegion(
+        IEvalThread                     *thread,
+        const vsc::dm::ValRefStruct     &region) = 0;
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_eval/share/include/zsp/arl/eval/IModelEvaluator.h

@@ -0,0 +1,42 @@
+/*
+ * IModelEvaluator.h
+ *
+ *  Created on: Apr 24, 2022
+ *      Author: mballance
+ */
+
+#pragma once
+#include "zsp/arl/dm/IModelEvalIterator.h"
+#include "zsp/arl/dm/IModelFieldComponent.h"
+#include "vsc/dm/IModelField.h"
+#include "vsc/solvers/IRandState.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+
+class IDataTypeAction;
+
+enum class ModelEvaluatorKind {
+	FullElab,
+	IncrElab
+};
+
+class IModelEvaluator;
+using IModelEvaluatorUP=vsc::dm::UP<IModelEvaluator>;
+class IModelEvaluator {
+public:
+
+	virtual ~IModelEvaluator() { }
+
+	virtual dm::IModelEvalIterator *eval(
+			const vsc::solvers::IRandState	    *randstate,
+			dm::IModelFieldComponent	        *root_comp,
+			dm::IDataTypeAction		            *root_action) = 0;
+
+};
+
+}
+}
+}

zsp_arl_eval/share/include/zsp/arl/eval/impl/EvalBackendBase.h

@@ -0,0 +1,76 @@
+/**
+ * EvalBackendBase.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/eval/IEvalBackend.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+
+
+class EvalBackendBase : public virtual IEvalBackend {
+public:
+    EvalBackendBase() { }
+
+    virtual ~EvalBackendBase() { }
+
+    virtual void init(IEvalContext *ctxt) override {
+        m_ctxt = ctxt;
+    }
+
+    virtual void enterThreads(
+        const std::vector<IEvalThread *>    &threads) override { }
+    
+    virtual void enterThread(IEvalThread *thread) override { }
+
+    virtual void leaveThread(IEvalThread *thread) override { }
+
+    virtual void leaveThreads(
+        const std::vector<IEvalThread *>    &threads) override { }
+
+    virtual void enterAction(
+        IEvalThread                         *thread,
+        dm::IDataTypeAction                 *action_t,
+        const vsc::dm::ValRef               &action_v) override { }
+
+    virtual void leaveAction(
+        IEvalThread                         *thread,
+        dm::IDataTypeAction                 *action_t,
+        const vsc::dm::ValRef               &action_v) override { }
+
+    virtual void callFuncReq(
+            IEvalThread                         *thread,
+            dm::IDataTypeFunction               *func_t,
+            const std::vector<vsc::dm::ValRef>  &params) override { }
+
+    virtual void emitMessage(const std::string &msg) override { }
+
+protected:
+    IEvalContext                        *m_ctxt;
+
+};
+
+}
+}
+}
+
+

zsp_arl_eval/share/include/zsp/arl/eval/impl/EvalListenerBase.h

@@ -0,0 +1,59 @@
+/**
+ * EvalListenerBase.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/eval/IEvalListener.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+
+
+class EvalListenerBase : public virtual IEvalListener {
+public:
+
+    EvalListenerBase() { }
+
+    virtual ~EvalListenerBase() { }
+
+    virtual void enterThreads(const std::vector<IEvalThread *> &threads) override { }
+
+    virtual void enterThread(IEvalThread *t) override { }
+
+    virtual void enterAction(
+        IEvalThread             *t,
+        dm::IModelFieldAction   *action) override { }
+
+    virtual void leaveAction(
+        IEvalThread             *t,
+        dm::IModelFieldAction   *action) override { }
+
+    virtual void leaveThread(IEvalThread *t) override { }
+
+    virtual void leaveThreads(const std::vector<IEvalThread *> &threads) override { }
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_eval/share/include/zsp/arl/eval/impl/TaskEvalGetLval.h

@@ -0,0 +1,148 @@
+/**
+ * TaskEvalGetLval.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/impl/DebugMacros.h"
+#include "vsc/dm/impl/ValRefStruct.h"
+#include "zsp/arl/dm/impl/VisitorBase.h"
+#include "zsp/arl/eval/IEvalThread.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+
+
+class TaskEvalGetLval : 
+    public virtual dm::VisitorBase {
+public:
+    TaskEvalGetLval(
+        dmgr::IDebugMgr     *dmgr,
+        IEvalValProvider    *vp) : m_vp(vp), m_dbg(0) { 
+        DEBUG_INIT("zsp::arl::eval::TaskEvalGetLval", dmgr);
+
+    }
+
+    virtual ~TaskEvalGetLval() { };
+
+    vsc::dm::ValRef eval(vsc::dm::ITypeExpr *expr) {
+        DEBUG_ENTER("eval");
+        m_val.reset();
+        expr->accept(m_this);
+        DEBUG_LEAVE("eval %p", m_val);
+        return m_val;
+    }
+
+	virtual void visitTypeExprArrIndex(vsc::dm::ITypeExprArrIndex *e) override {
+        DEBUG_ENTER("visitTypeExprArrIndex");
+        DEBUG("TODO: visitTypeExprArrIndex");
+        DEBUG_LEAVE("visitTypeExprArrIndex");
+    }
+
+	virtual void visitTypeExprFieldRef(vsc::dm::ITypeExprFieldRef *e) override {
+        int32_t path_idx = 0;
+        DEBUG_ENTER("visitTypeExprFieldRef");
+
+#ifdef UNDEFINED
+        if (e->getPath().size() == 0) {
+            DEBUG_ERROR("Path is empty");
+            return;
+        }
+
+        DEBUG("root_ref_kind=%d offset=%d", 
+            e->getRootRefKind(),
+            e->getRootRefOffset());
+        DEBUG("path.size=%d path_idx=%d index=%d",
+            e->getPath().size(),
+            path_idx,
+            e->getPath().at(path_idx));
+        DEBUG("vp=%p", m_vp);
+        m_val = m_vp->getMutVal(
+            e->getRootRefKind(),
+            e->getRootRefOffset(),
+            e->getPath().at(path_idx++)
+        );
+        // switch (e->getRootRefKind()) {
+        //     case vsc::dm::ITypeExprFieldRef::RootRefKind::BottomUpScope: {
+        //         IEvalStackFrame *frame = m_thread->stackFrame(e->getPath().at(path_idx++));
+        //         var.setWeakRef(frame->getVariable(e->getPath().at(path_idx++)));
+        //     } break;
+        //     case vsc::dm::ITypeExprFieldRef::RootRefKind::TopDownScope: {
+        //         vsc::dm::ValRefStruct scope_s(m_scope);
+        //         var.setWeakRef(scope_s.getFieldRef(e->getPath().at(path_idx++)));
+        //     } break;
+        // }
+
+        // vsc::dm::IModelField *field = 0;
+        // if (path_idx >= e->getPath().size()) {
+        //     m_val.setWeakRef(var);
+        // } else {
+        //     while (path_idx < e->getPath().size()) {
+        //         vsc::dm::ValRefStruct val_s(var);
+        //         var = val_s.getFieldRef(e->getPath().at(path_idx));
+        //         DEBUG("Get field-ref @ %d", e->getPath().at(path_idx));
+        //         path_idx++;
+        //     }
+        //     m_val.setWeakRef(var);
+        // }
+
+#endif /* UNDEFINED */
+
+        DEBUG_LEAVE("visitTypeExprFieldRef");
+    }
+
+	virtual void visitTypeExprRefBottomUp(vsc::dm::ITypeExprRefBottomUp *e) override { 
+        DEBUG_ENTER("visitTypeExprRefBottomUp");
+        m_val = m_vp->getMutVal(
+            vsc::dm::ITypeExprFieldRef::RootRefKind::BottomUpScope,
+            e->getScopeOffset(),
+            e->getSubFieldIndex());
+        DEBUG_LEAVE("visitTypeExprRefBottomUp");
+    }
+
+	virtual void visitTypeExprRefTopDown(vsc::dm::ITypeExprRefTopDown *e) override { 
+        DEBUG_ENTER("visitTypeExprRefTopDown");
+        m_val = m_vp->getMutVal(
+            vsc::dm::ITypeExprFieldRef::RootRefKind::TopDownScope,
+            -1,
+            -1);
+        DEBUG_LEAVE("visitTypeExprRefTopDown");
+    }
+
+	virtual void visitTypeExprSubField(vsc::dm::ITypeExprSubField *e) override {
+        DEBUG_ENTER("visitTypeExprSubField");
+        e->getRootExpr()->accept(m_this);
+        vsc::dm::ValRefStruct val_s(m_val);
+        m_val = val_s.getFieldRef(e->getSubFieldIndex());
+        DEBUG_LEAVE("visitTypeExprSubField");
+    }
+
+private:
+    dmgr::IDebug            *m_dbg;
+    IEvalValProvider        *m_vp;
+    vsc::dm::ValRef         m_val;
+
+};
+
+}
+}
+}
+
+