zuspec-be-sw 0.1.0.15240461960rc0__cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

zsp_be_sw/__build_num__.py

@@ -0,0 +1 @@
+BUILD_NUM=15240461960

zsp_be_sw/__version__.py

@@ -0,0 +1,3 @@
+BASE="0.1.0"
+SUFFIX=".15240461960rc0"
+VERSION="%s%s" % (BASE, SUFFIX)

zsp_be_sw/share/include/zsp/be/sw/FactoryExt.h

@@ -0,0 +1,5 @@
+
+#pragma
+#include "zsp/be/sw/IFactory.h"
+
+extern "C" zsp::be::sw::IFactory *zsp_be_sw_getFactory();

zsp_be_sw/share/include/zsp/be/sw/IContext.h

@@ -0,0 +1,102 @@
+/**
+ * IContext.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 "zsp/arl/dm/IContext.h"
+#include "zsp/be/sw/INameMap.h"
+
+namespace zsp {
+namespace be {
+namespace sw {
+
+enum class BackendFunctions {
+    Printf,
+    Read8,
+    Read16,
+    Read32,
+    Read64,
+    Write8,
+    Write16,
+    Write32,
+    Write64,
+    NumFuncs
+};
+
+enum class ExecScopeVarFlags {
+    NoFlags = 0,
+    IsPtr = (1 << 0)
+};
+
+static inline ExecScopeVarFlags operator | (const ExecScopeVarFlags lhs, const ExecScopeVarFlags rhs) {
+	return static_cast<ExecScopeVarFlags>(
+			static_cast<uint32_t>(lhs) | static_cast<uint32_t>(rhs));
+}
+
+static inline ExecScopeVarFlags operator & (const ExecScopeVarFlags lhs, const ExecScopeVarFlags rhs) {
+	return static_cast<ExecScopeVarFlags>(
+			static_cast<uint32_t>(lhs) & static_cast<uint32_t>(rhs));
+}
+
+static inline ExecScopeVarFlags operator ~ (const ExecScopeVarFlags lhs) {
+	return static_cast<ExecScopeVarFlags>(~static_cast<uint32_t>(lhs));
+}
+
+struct ExecScopeVarInfo {
+    arl::dm::ITypeProcStmtVarDecl       *var;
+    ExecScopeVarFlags                   flags;
+};
+
+class IContext {
+public:
+
+    virtual ~IContext() { }
+
+    virtual dmgr::IDebugMgr *getDebugMgr() const = 0;
+
+    virtual arl::dm::IContext *ctxt() const = 0;
+
+    virtual INameMap *nameMap() = 0;
+
+    virtual arl::dm::IDataTypeFunction *getBackendFunction(
+        BackendFunctions    func) = 0;
+
+    virtual void pushTypeScope(vsc::dm::IDataTypeStruct *t) = 0;
+
+    virtual vsc::dm::IDataTypeStruct *typeScope() = 0;
+
+    virtual void popTypeScope() = 0;
+
+    virtual void pushExecScope(vsc::dm::IAccept *s) = 0;
+
+    virtual vsc::dm::IAccept *execScope(int32_t off=0) = 0;
+
+    virtual ExecScopeVarInfo execScopeVar(
+        int32_t     scope_off,
+        int32_t     var_off) = 0;
+
+    virtual void popExecScope() = 0;
+
+};
+
+}
+}
+}
+

zsp_be_sw/share/include/zsp/be/sw/IFactory.h

@@ -0,0 +1,92 @@
+/**
+ * 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 "zsp/arl/dm/IModelFieldExecutor.h"
+#include "zsp/be/sw/IContext.h"
+#include "zsp/be/sw/IGeneratorEvalIterator.h"
+#include "zsp/be/sw/IGeneratorFunctions.h"
+#include "zsp/be/sw/IOutput.h"
+
+namespace zsp {
+namespace be {
+namespace sw {
+
+
+
+class IFactory {
+public:
+
+    virtual ~IFactory() { }
+
+    virtual void init(dmgr::IDebugMgr *dmgr) = 0;
+
+    virtual dmgr::IDebugMgr *getDebugMgr() = 0;
+
+    virtual IGeneratorFunctions *mkGeneratorFunctionsThreaded() = 0;
+
+    virtual IGeneratorEvalIterator *mkGeneratorMultiCoreSingleImageEmbCTest(
+        const std::vector<arl::dm::IModelFieldExecutor *> &executors,
+        int32_t                                           dflt_exec,
+        IOutput                                           *out_h,
+        IOutput                                           *out_c
+    ) = 0;
+
+    virtual IContext *mkContext(arl::dm::IContext *ctxt) = 0;
+
+    virtual void generateC(
+        IContext                                        *ctxt,
+        const std::vector<vsc::dm::IAccept *>           &roots,
+        std::ostream                                    *csrc,
+        std::ostream                                    *pub_h,
+        std::ostream                                    *prv_h
+    ) = 0;
+
+    virtual void generateExecModel(
+        arl::dm::IContext                               *ctxt,
+        arl::dm::IDataTypeComponent                     *comp_t,
+        arl::dm::IDataTypeAction                        *action_t,
+        std::ostream                                    *out_c,
+        std::ostream                                    *out_h,
+        std::ostream                                    *out_h_prv) = 0;
+
+    virtual void generateType(
+        IContext                                        *ctxt,
+        vsc::dm::IDataTypeStruct                        *comp_t,
+        std::ostream                                    *out_c,
+        std::ostream                                    *out_h) = 0;
+
+    virtual void generateTypes(
+        IContext                                        *ctxt,
+        vsc::dm::IDataTypeStruct                        *root,
+        const std::string                               &outdir) = 0;
+
+    virtual void initContextC(arl::dm::IContext *ctxt) = 0;
+
+    virtual IOutput *mkFileOutput(const std::string &path) = 0;
+
+};
+
+} /* namespace sw */
+} /* namespace be */
+} /* namespace zsp */
+
+

zsp_be_sw/share/include/zsp/be/sw/IFunctionInfo.h

@@ -0,0 +1,79 @@
+/**
+ * IFunctionInfo.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 <memory>
+#include <string>
+#include "zsp/arl/dm/IDataTypeFunction.h"
+
+namespace zsp {
+namespace be {
+namespace sw {
+
+enum class FunctionFlags {
+    NoFlags = 0,
+    Export = (1 << 0),
+    Import = (1 << 1)
+};
+
+static inline FunctionFlags operator | (const FunctionFlags lhs, const FunctionFlags rhs) {
+	return static_cast<FunctionFlags>(
+			static_cast<uint32_t>(lhs) | static_cast<uint32_t>(rhs));
+}
+
+static inline FunctionFlags operator |= (FunctionFlags &lhs, const FunctionFlags rhs) {
+	lhs = static_cast<FunctionFlags>(
+			static_cast<uint32_t>(lhs) | static_cast<uint32_t>(rhs));
+	return lhs;
+}
+
+static inline FunctionFlags operator & (const FunctionFlags lhs, const FunctionFlags rhs) {
+	return static_cast<FunctionFlags>(
+			static_cast<uint32_t>(lhs) & static_cast<uint32_t>(rhs));
+}
+
+static inline FunctionFlags operator ~ (const FunctionFlags lhs) {
+	return static_cast<FunctionFlags>(~static_cast<uint32_t>(lhs));
+}
+
+class IFunctionInfo;
+using IFunctionInfoUP=std::unique_ptr<IFunctionInfo>;
+class IFunctionInfo {
+public:
+
+    virtual ~IFunctionInfo() { }
+
+    virtual const std::string &getImplName() const = 0;
+
+    virtual void setImplName(const std::string &n) = 0;
+
+    virtual arl::dm::IDataTypeFunction *getDecl() const = 0;
+
+    virtual FunctionFlags getFlags() const = 0;
+
+    virtual void setFlags(FunctionFlags flags) = 0;
+
+};
+
+} /* namespace sw */
+} /* namespace be */
+} /* namespace zsp */
+
+

zsp_be_sw/share/include/zsp/be/sw/IFunctionMap.h

@@ -0,0 +1,48 @@
+/**
+ * IFunctionMap.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/be/sw/IFunctionInfo.h"
+
+namespace zsp {
+namespace be {
+namespace sw {
+
+class IFunctionMap;
+using IFunctionMapUP=std::unique_ptr<IFunctionMap>;
+class IFunctionMap {
+public:
+
+    virtual ~IFunctionMap() { }
+
+    virtual bool addFunction(
+        arl::dm::IDataTypeFunction      *func,
+        FunctionFlags                   flags
+    ) = 0;
+
+    virtual const std::vector<IFunctionInfoUP> &getFunctions() const = 0;
+
+};
+
+} /* namespace sw */
+} /* namespace be */
+} /* namespace zsp */
+
+

zsp_be_sw/share/include/zsp/be/sw/IGeneratorEvalIterator.h

@@ -0,0 +1,49 @@
+/**
+ * IGeneratorEvalIterator.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 <memory>
+#include <vector>
+#include "zsp/arl/dm/IModelEvalIterator.h"
+#include "zsp/arl/dm/IModelFieldComponentRoot.h"
+
+namespace zsp {
+namespace be {
+namespace sw {
+
+
+class IGeneratorEvalIterator;
+using IGeneratorEvalIteratorUP=vsc::dm::UP<IGeneratorEvalIterator>;
+class IGeneratorEvalIterator {
+public:
+
+    virtual ~IGeneratorEvalIterator() { }
+
+    virtual void generate(
+        arl::dm::IModelFieldComponentRoot   *root,
+        arl::dm::IModelEvalIterator         *it) = 0;
+
+};
+
+} /* namespace sw */
+} /* namespace be */
+} /* namespace zsp */
+
+

zsp_be_sw/share/include/zsp/be/sw/IGeneratorFunctions.h

@@ -0,0 +1,55 @@
+/**
+ * IGeneratorFunctions.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 <memory>
+#include <vector>
+#include "zsp/arl/dm/IContext.h"
+#include "zsp/arl/dm/IDataTypeFunction.h"
+#include "zsp/be/sw/IOutput.h"
+
+namespace zsp {
+namespace be {
+namespace sw {
+
+
+class IGeneratorFunctions;
+using IGeneratorFunctionsUP=std::unique_ptr<IGeneratorFunctions>;
+class IGeneratorFunctions {
+public:
+
+    virtual ~IGeneratorFunctions() { }
+
+    virtual void generate(
+        arl::dm::IContext                                   *ctxt,
+        const std::vector<arl::dm::IDataTypeFunction *>     &funcs,
+        const std::vector<std::string>                      &inc_c,
+        const std::vector<std::string>                      &inc_h,
+        IOutput                                             *out_c,
+        IOutput                                             *out_h
+    ) = 0;
+
+};
+
+} /* namespace sw */
+} /* namespace be */
+} /* namespace zsp */
+
+

zsp_be_sw/share/include/zsp/be/sw/IGeneratorUnrolledTrace.h

@@ -0,0 +1,57 @@
+/**
+ * IGeneratorUnrolledTrace.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 <iostream>
+#include <memory>
+#include <vector>
+#include "zsp/IAccept.h"
+#include "zsp/IMarker.h"
+#include "zsp/IModelActivity.h"
+#include "zsp/IModelFieldComponent.h"
+
+namespace zsp {
+namespace be {
+namespace sw {
+
+
+class IGeneratorUnrolledTrace;
+using IGeneratorUnrolledTraceUP=std::unique_ptr<IGeneratorUnrolledTrace>;
+class IGeneratorUnrolledTrace {
+public:
+
+    virtual ~IGeneratorUnrolledTrace() { }
+
+    virtual void generate(
+        std::ostream                *c_os,
+        std::ostream                *h_os,
+        arl::IModelFieldComponent                *pss_top,
+//        std::vector // TODO: executors
+        const std::vector<IModelActivity *>      &activities,
+        std::vector<IMarkerUP>                   &markers
+    ) = 0;
+
+};
+
+} /* namespace sw */
+} /* namespace be */
+} /* namespace arl */
+
+

zsp_be_sw/share/include/zsp/be/sw/IMethodCallFactoryAssocData.h

@@ -0,0 +1,55 @@
+/**
+ * IMethodCallFactoryAssocData.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/IAssociatedData.h"
+#include "zsp/arl/dm/IContext.h"
+#include "zsp/arl/dm/ITypeExprMethodCallContext.h"
+#include "zsp/arl/dm/ITypeExprMethodCallStatic.h"
+#include "zsp/be/sw/IContext.h"
+
+namespace zsp {
+namespace be {
+namespace sw {
+
+
+
+class IMethodCallFactoryAssocData : public virtual vsc::dm::IAssociatedData {
+public:
+
+    virtual ~IMethodCallFactoryAssocData() { }
+
+    virtual vsc::dm::ITypeExpr *mkCallContext(
+        IContext                            *ctxt,
+        arl::dm::ITypeExprMethodCallContext *call
+    ) = 0;
+
+    virtual vsc::dm::ITypeExpr *mkCallStatic(
+        IContext                            *ctxt,
+        arl::dm::ITypeExprMethodCallStatic  *call
+    ) = 0;
+
+};
+
+} /* namespace sw */
+} /* namespace be */
+} /* namespace zsp */
+
+

zsp_be_sw/share/include/zsp/be/sw/INameMap.h

@@ -0,0 +1,60 @@
+/**
+ * INameMap.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/IDataType.h"
+#include "zsp/arl/dm/IDataTypeFunction.h"
+
+namespace zsp {
+namespace be {
+namespace sw {
+
+class INameMap;
+using INameMapUP=vsc::dm::UP<INameMap>;
+class INameMap {
+public:
+
+    enum class Kind {
+        Mangled,
+        Hierarchical
+    };
+
+    virtual ~INameMap() { }
+
+    virtual bool hasName(
+        vsc::dm::IAccept    *type,
+        Kind                kind=Kind::Mangled) = 0;
+
+    virtual void setName(
+        vsc::dm::IAccept    *type,
+        const std::string   &name,
+        Kind                kind=Kind::Mangled) = 0;
+
+    virtual std::string getName(
+        vsc::dm::IAccept    *type,
+        Kind                kind=Kind::Mangled) = 0;
+
+};
+
+} /* namespace sw */
+} /* namespace be */
+} /* namespace zsp */
+
+