zuspec-arl-eval 0.0.7.13253972717rc0__cp310-cp310-manylinux_2_34_x86_64.whl

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

@@ -0,0 +1,126 @@
+/**
+ * IEval.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/IModelVal.h"
+#include "vsc/dm/impl/ValRef.h"
+#include "vsc/dm/impl/UP.h"
+#include "zsp/arl/eval/IEvalValProvider.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+enum class EvalFlags {
+    NoFlags     = 0,
+    AllFlags    = 0xFF,
+    Complete    = (1 << 0),
+    Error       = (1 << 1),
+    Break       = (1 << 2),
+    Continue    = (1 << 3),
+    Return      = (1 << 4)
+};
+
+static inline EvalFlags operator | (const EvalFlags lhs, const EvalFlags rhs) {
+        return static_cast<EvalFlags>(
+                        static_cast<uint32_t>(lhs) | static_cast<uint32_t>(rhs));
+}
+
+static inline EvalFlags operator & (const EvalFlags lhs, const EvalFlags rhs) {
+        return static_cast<EvalFlags>(
+                        static_cast<uint32_t>(lhs) & static_cast<uint32_t>(rhs));
+}
+
+static inline EvalFlags operator ~ (const EvalFlags lhs) {
+        return static_cast<EvalFlags>(~static_cast<uint32_t>(lhs));
+}
+
+class IEval;
+using IEvalUP=vsc::dm::UP<IEval>;
+class IEval :
+    public virtual IEvalValProvider {
+public:
+
+    virtual ~IEval() { }
+
+    /**
+     * @brief Performs some work. 
+     * 
+     * @return true - if more work remains
+     * @return false - if work is complete
+     */
+    virtual int32_t eval() = 0;
+
+    virtual int32_t getIdx() = 0;
+
+    virtual void setIdx(int32_t idx) = 0;
+
+    virtual IEval *clone() = 0;
+
+    virtual EvalFlags getFlags() const = 0;
+
+    virtual bool hasFlags(EvalFlags flags) const = 0;
+
+    virtual void setFlags(EvalFlags flags) = 0;
+
+    virtual void clrFlags(EvalFlags flags=EvalFlags::AllFlags) = 0;
+
+    virtual const vsc::dm::ValRef &getResult() const = 0;
+
+    virtual void setResult(
+        const vsc::dm::ValRef   &r,
+        EvalFlags               flags=EvalFlags::Complete) = 0;
+
+    virtual void setError(const char *fmt, ...) = 0;
+
+#ifdef UNDEFINED
+    /**
+     * @brief Moves the result, clearing the result here
+     * 
+     * @return EvalResult& 
+     */
+    virtual vsc::dm::ValRef &moveResult() = 0;
+
+    /**
+     * @brief Sets the result, taking ownership of value data
+     * 
+     * @param r 
+     */
+
+    virtual void setVoidResult() = 0;
+
+    virtual void setError(const std::string &msg) = 0;
+
+    virtual bool haveError() const = 0;
+
+    virtual const std::string &getError() const = 0;
+
+    virtual void clrResult(bool clr_err=false) = 0;
+
+    virtual bool haveResult() const = 0;
+#endif
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+

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

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

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

@@ -0,0 +1,162 @@
+/**
+ * IEvalContext.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 <functional>
+#include <vector>
+#include "dmgr/IDebugMgr.h"
+#include "pyapi-compat-if/IPyEval.h"
+#include "vsc/dm/IModelValOp.h"
+#include "zsp/arl/eval/IBuiltinFuncInfo.h"
+#include "zsp/arl/eval/IEval.h"
+#include "zsp/arl/eval/IEvalBackend.h"
+#include "zsp/arl/eval/IEvalListener.h"
+#include "zsp/arl/eval/IEvalFunctionData.h"
+#include "zsp/arl/eval/IEvalValProvider.h"
+#include "zsp/arl/dm/IContext.h"
+#include "zsp/arl/dm/IDataTypeFunction.h"
+#include "zsp/arl/dm/IDataTypeFunctionImport.h"
+#include "zsp/arl/dm/IModelFieldExecutor.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+class IEvalResult;
+
+enum class EvalContextFunc {
+    Write8,
+    Write16,
+    Write32,
+    Write64,
+    Read8,
+    Read16,
+    Read32,
+    Read64,
+    RegWrite,
+    RegWriteMasked,
+    RegWriteVal,
+    RegWriteValMasked,
+    RegRead,
+    RegReadVal,
+    RegGroupSetHandle,
+    Print,
+    NumFunctions
+};
+
+enum class EvalContextFlags {
+    NoFlags = 0,
+    SkipExecBody = (1 << 0)
+};
+
+class IEvalContext;
+using IEvalContextUP=vsc::dm::UP<IEvalContext>;
+class IEvalContext {
+public:
+
+    virtual ~IEvalContext() { }
+
+    virtual void setContextFlags(EvalContextFlags flags) = 0;
+
+    virtual bool hasContextFlags(EvalContextFlags flags) = 0;
+
+    virtual int32_t eval() = 0;
+
+    virtual dm::IContext *ctxt() const = 0;
+
+    virtual EvalFlags getFlags() const = 0;
+
+    virtual bool hasFlags(EvalFlags flags) const = 0;
+
+    virtual void setFlags(EvalFlags flags) = 0;
+
+    virtual void clrFlags(EvalFlags flags=EvalFlags::AllFlags) = 0;
+
+    virtual const vsc::dm::ValRef &getResult() const = 0;
+
+    virtual void setResult(
+        const vsc::dm::ValRef   &r,
+        EvalFlags               flags=EvalFlags::Complete) = 0;
+
+    virtual void setError(const char *fmt, ...) = 0;
+
+    virtual IEvalBackend *getBackend() const = 0;
+
+    virtual void setBackend(IEvalBackend *b, bool owned=false) = 0;
+
+    virtual dm::IModelFieldComponentRoot *getRootComponent() = 0;
+
+    /**
+     * Return just the global solve functions
+     * 
+     * Valid after construction
+     */
+    virtual const std::vector<dm::IDataTypeFunction *> &getSolveFunctions() const = 0;
+
+    /**
+     * Return just the target functions
+     * 
+     * Valid after construction
+     */
+    virtual const std::vector<dm::IDataTypeFunction *> &getTargetFunctions() const = 0;
+
+    virtual void setFunctionData(
+        dm::IDataTypeFunction       *func_t,
+        IEvalFunctionData           *data
+    ) = 0;
+
+    virtual void addListener(IEvalListener *l) = 0;
+
+    virtual void callListener(const std::function<void (IEvalListener *)> &f) = 0;
+
+    virtual dm::IDataTypeFunction *getFunction(EvalContextFunc func) = 0;
+
+    virtual vsc::dm::ValRefInt mkValRefInt(
+        int64_t value, 
+        bool is_signed, 
+        int32_t width) = 0;
+
+    virtual vsc::dm::IModelVal *mkModelValS(int64_t v=0, int32_t w=32) = 0;
+
+    virtual vsc::dm::IModelVal *mkModelValU(uint64_t v=0, int32_t w=32) = 0;
+
+    virtual vsc::dm::IModelValOp *getModelValOp() = 0;
+
+    virtual IEvalStackFrame *mkStackFrame(int32_t n_vars) = 0;
+
+    virtual pyapi::PyEvalObj *getPyModule(dm::IPyImport *imp) = 0;
+
+    virtual pyapi::IPyEval *getPyEval() = 0;
+
+    virtual bool addPyModule(
+        const std::string       &name,
+        pyapi::PyEvalObj        *mod) = 0;
+    
+    virtual dmgr::IDebugMgr *getDebugMgr() const = 0;
+
+    virtual vsc::dm::ValRefInt getAddrHandleValue(const vsc::dm::ValRef &addr_h) = 0;
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+

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

@@ -0,0 +1,52 @@
+/**
+ * IEvalContextActivity.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/IEvalContext.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+
+
+class IEvalContextActivity : public virtual IEvalContext {
+public:
+
+    virtual ~IEvalContextActivity() { }
+
+    virtual int32_t buildCompTree() = 0;
+
+    virtual int32_t initCompTree() = 0;
+
+    /**
+     * Returns the executor objects
+     * 
+     * Valid after initializing the component tree
+     */
+    virtual const std::vector<dm::IModelFieldExecutor *> &getExecutors() const = 0;
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+

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

@@ -0,0 +1,65 @@
+/**
+ * IEvalContextInt.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 "zsp/arl/eval/IBuiltinFuncInfo.h"
+#include "zsp/arl/eval/IEvalThread.h"
+#include "zsp/arl/eval/IEvalThreadId.h"
+#include "zsp/arl/dm/IDataTypeFunction.h"
+#include "zsp/arl/dm/IModelFieldAction.h"
+#include "zsp/arl/eval/IEvalContext.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+enum class CoreValOpsE {
+    AddrSpaceTransparent,
+    AddrHandle,
+    Number
+};
+
+
+class IEvalContextInt : public virtual IEvalContext {
+public:
+
+    virtual ~IEvalContextInt() { }
+
+    virtual void callFuncReq(
+            IEvalThread                         *thread,
+            dm::IDataTypeFunction               *func_t,
+            const std::vector<vsc::dm::ValRef>  &params
+    ) = 0;
+
+    virtual IEvalValProvider *getValProvider(int32_t id) = 0;
+
+    virtual IBuiltinFuncInfo *getBuiltinFuncInfo(
+        dm::IDataTypeFunction *func) = 0;
+
+    virtual vsc::dm::IValOps *getValOps(CoreValOpsE kind) = 0;
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+

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

@@ -0,0 +1,40 @@
+/**
+ * IEvalFunctionData.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 IEvalFunctionData {
+public:
+
+    virtual ~IEvalFunctionData() { }
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+

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

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

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

@@ -0,0 +1,50 @@
+/**
+ * IEvalStackFrame.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/ValRef.h"
+#include "vsc/dm/impl/UP.h"
+#include "vsc/dm/IModelField.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+class IEvalStackFrame;
+using IEvalStackFrameUP=vsc::dm::UP<IEvalStackFrame>;
+class IEvalStackFrame {
+public:
+
+    virtual ~IEvalStackFrame() { }
+
+    virtual const vsc::dm::ValRef &getVariable(uint32_t idx) = 0;
+
+    virtual void setVariable(uint32_t idx, vsc::dm::ValRef &var) = 0;
+    
+    virtual int32_t getNumVariables() = 0;
+
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+