zuspec-arl-dm 0.1.0.15264414400rc0__cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

zsp_arl_dm/share/include/zsp/arl/dm/IDataTypeFunction.h

@@ -0,0 +1,115 @@
+/**
+ * IDataTypeFunction.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 <vector>
+#include "vsc/dm/IAssociatedData.h"
+#include "vsc/dm/IDataTypeStruct.h"
+#include "zsp/arl/dm/IDataTypeFunctionImport.h"
+#include "zsp/arl/dm/IDataTypeFunctionParamDecl.h"
+#include "zsp/arl/dm/ITypeProcStmtDeclScope.h"
+#include "zsp/arl/dm/ITypeProcStmtScope.h"
+#include "vsc/dm/IAccept.h"
+#include "vsc/dm/IDataType.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+enum class DataTypeFunctionFlags {
+    NoFlags = 0,
+    Solve   = (1 << 0),
+    Target  = (1 << 1), // Target function
+    Blocks  = (1 << 2), // Blocking target function
+    Core    = (1 << 3),
+    Context = (1 << 4), // Non-static member of a containing type
+    Import  = (1 << 5),
+    Export  = (1 << 6),
+};
+
+static inline DataTypeFunctionFlags operator | (const DataTypeFunctionFlags lhs, const DataTypeFunctionFlags rhs) {
+        return static_cast<DataTypeFunctionFlags>(
+                        static_cast<uint32_t>(lhs) | static_cast<uint32_t>(rhs));
+}
+
+static inline DataTypeFunctionFlags operator & (const DataTypeFunctionFlags lhs, const DataTypeFunctionFlags rhs) {
+        return static_cast<DataTypeFunctionFlags>(
+                        static_cast<uint32_t>(lhs) & static_cast<uint32_t>(rhs));
+}
+
+static inline DataTypeFunctionFlags operator ~ (const DataTypeFunctionFlags lhs) {
+        return static_cast<DataTypeFunctionFlags>(~static_cast<uint32_t>(lhs));
+}
+
+class IDataTypeFunction;
+using IDataTypeFunctionUP=vsc::dm::UP<IDataTypeFunction>;
+class IDataTypeFunction : 
+    public virtual vsc::dm::IAccept {
+public:
+
+    virtual ~IDataTypeFunction() { }
+
+    virtual const std::string &name() const = 0;
+
+    virtual vsc::dm::IDataType *getReturnType() const = 0;
+
+    virtual const std::vector<IDataTypeFunctionParamDecl *> &getParameters() const = 0;
+
+    virtual void addParameter(IDataTypeFunctionParamDecl *p) = 0;
+
+    // Returns the data type of the parameters frame
+    virtual vsc::dm::IDataTypeStruct *getParametersType() const = 0;
+
+    // Appears to not be used
+    virtual ITypeProcStmtDeclScope *getParamScope() = 0;
+
+    virtual vsc::dm::IDataTypeStruct *getContext() const = 0;
+
+    virtual bool getIsExport() const = 0;
+
+    virtual void setIsExport(bool e) = 0;
+
+    virtual ITypeProcStmtScope *getBody() const = 0;
+
+    virtual const std::vector<IDataTypeFunctionImportUP> &getImportSpecs() const = 0;
+
+    virtual void addImportSpec(IDataTypeFunctionImport *spec) = 0;
+
+    virtual DataTypeFunctionFlags getFlags() const = 0;
+
+    virtual void setFlags(DataTypeFunctionFlags flags) = 0;
+
+    virtual bool hasFlags(DataTypeFunctionFlags f) const = 0;
+
+    virtual void clrFlags(DataTypeFunctionFlags f) = 0;
+
+    virtual void setAssociatedData(vsc::dm::IAssociatedData *data) = 0;
+
+    virtual vsc::dm::IAssociatedData *getAssociatedData() const = 0;
+
+};
+
+}
+}
+}
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IDataTypeFunctionImport.h

@@ -0,0 +1,45 @@
+/**
+ * IDataTypeFunctionImport.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/UP.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+class IDataTypeFunctionImport;
+using IDataTypeFunctionImportUP=vsc::dm::UP<IDataTypeFunctionImport>;
+class IDataTypeFunctionImport {
+public:
+
+    virtual ~IDataTypeFunctionImport() { }
+
+    virtual bool isTarget() = 0;
+
+    virtual bool isSolve() = 0;
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IDataTypeFunctionParamDecl.h

@@ -0,0 +1,53 @@
+/**
+ * IDataTypeFunctionParamDecl.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 "vsc/dm/IDataType.h"
+#include "vsc/dm/ITypeExpr.h"
+#include "zsp/arl/dm/ITypeProcStmtVarDecl.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+enum class ParamDir {
+    In,
+    Out,
+    InOut
+};
+
+class IDataTypeFunctionParamDecl;
+using IDataTypeFunctionParamDeclUP=vsc::dm::UP<IDataTypeFunctionParamDecl>;
+class IDataTypeFunctionParamDecl : public virtual ITypeProcStmtVarDecl {
+public:
+
+    virtual ~IDataTypeFunctionParamDecl() { }
+
+    virtual ParamDir getDirection() const = 0;
+
+};
+
+}
+}
+}
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IDataTypePackedStruct.h

@@ -0,0 +1,48 @@
+/**
+ * IDataTypePackedStruct.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/IDataTypeStruct.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+enum class Endian {
+    Big,
+    Little
+};
+
+class IDataTypePackedStruct;
+using IDataTypePackedStructUP=vsc::dm::UP<IDataTypePackedStruct>;
+class IDataTypePackedStruct : public virtual vsc::dm::IDataTypeStruct {
+public:
+
+    virtual ~IDataTypePackedStruct() { }
+
+    virtual Endian getEndian() const = 0;
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IDataTypePureComponent.h

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

zsp_arl_dm/share/include/zsp/arl/dm/IDataTypePyObj.h

@@ -0,0 +1,41 @@
+/**
+ * IDataTypePyObj.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"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class IDataTypePyObj : public virtual vsc::dm::IDataType {
+public:
+
+    virtual ~IDataTypePyObj() { }
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IDataTypeReg.h

@@ -0,0 +1,55 @@
+/**
+ * IDataTypeReg.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 <stdint.h>
+#include "zsp/arl/dm/IDataTypePackedStruct.h"
+#include "zsp/arl/dm/IDataTypePureComponent.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+enum class RegAccess {
+    READWRITE,
+    READONLY,
+    WRITEONLY
+};
+
+class IDataTypeReg : public virtual IDataTypePureComponent {
+public:
+
+    virtual ~IDataTypeReg() { }
+
+    virtual IDataTypePackedStruct *getDataType() const = 0;
+
+    virtual uint32_t getOffset() const = 0;
+
+    virtual uint32_t getWidth() const = 0;
+    
+    virtual RegAccess getAccess() const = 0;
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IDataTypeRegGroup.h

@@ -0,0 +1,40 @@
+/**
+ * IDataTypeRegGroup.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/IDataTypeComponent.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class IDataTypeRegGroup : public virtual IDataTypeComponent {
+public:
+
+    virtual ~IDataTypeRegGroup() { }
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IDataTypeResource.h

@@ -0,0 +1,22 @@
+
+#pragma once
+#include "zsp/arl/dm/IDataTypeFlowObj.h"
+#include "vsc/dm/ITypeField.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class IDataTypeResource : public virtual IDataTypeFlowObj {
+public:
+
+    virtual ~IDataTypeResource() { }
+
+    virtual vsc::dm::ITypeField *getInstanceId() const = 0;
+
+};
+
+}
+}
+}

zsp_arl_dm/share/include/zsp/arl/dm/IDataTypeTransparentAddrSpace.h

@@ -0,0 +1,44 @@
+/**
+ * IDataTypeTransparentAddrSpace.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/IValOpsDelegator.h"
+#include "zsp/arl/dm/IDataTypeComponent.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class IDataTypeTransparentAddrSpace : 
+    public virtual IDataTypeComponent,
+    public virtual vsc::dm::IValOpsDelegator {
+public:
+
+    virtual ~IDataTypeTransparentAddrSpace() { }
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IFactory.h

@@ -0,0 +1,64 @@
+/**
+ * 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 <iostream>
+#include "dmgr/IDebugMgr.h"
+#include "vsc/dm/IContext.h"
+#include "zsp/arl/dm/IContext.h"
+#include "zsp/arl/dm/IContextDumper.h"
+#include "zsp/arl/dm/IContextLoader.h"
+#include "zsp/arl/dm/IRewriteContext.h"
+#include "zsp/arl/dm/ITypeModelDumper.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class IFactory {
+public:
+
+    virtual ~IFactory() { }
+
+    virtual void init(dmgr::IDebugMgr *dmgr) = 0;
+
+    virtual dmgr::IDebugMgr *getDebugMgr() = 0;
+
+    virtual IContext *mkContext(vsc::dm::IContext *ctxt) = 0;
+
+    virtual IRewriteContext *mkRewriteContext(
+            IContext                                *ctxt,
+            const std::vector<vsc::dm::IAccept *>   &roots) = 0;
+
+    virtual ITypeModelDumper *mkTypeModelDumperJSON(
+        std::ostream *out, int32_t indent) = 0;
+
+//    virtual IContextDumper *mkContextDumperJSON(std::ostream *out) = 0;
+
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IMarker.h

@@ -0,0 +1,56 @@
+/**
+ * IMarker.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 "vsc/dm/IAccept.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+enum class MarkerSeverity {
+    Note,
+    Warning,
+    Error
+};
+
+class IMarker;
+using IMarkerUP=vsc::dm::UP<IMarker>;
+class IMarker {
+public:
+
+    virtual ~IMarker() { }
+
+    virtual vsc::dm::IAccept *getTarget() const = 0;
+
+    virtual MarkerSeverity getSeverity() const = 0;
+
+    virtual const std::string &getMessage() const = 0;
+
+};
+
+}
+}
+}
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IModelActivity.h

@@ -0,0 +1,39 @@
+/*
+ * IModelActivity.h
+ *
+ *  Created on: Jun 5, 2022
+ *      Author: mballance
+ */
+
+#pragma once
+#include <memory>
+#include <vector>
+#include "vsc/dm/IAccept.h"
+#include "vsc/dm/IModelConstraint.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class IModelActivity;
+using IModelActivityUP=vsc::dm::UP<IModelActivity>;
+class IModelActivity : public virtual vsc::dm::IAccept {
+public:
+
+	virtual ~IModelActivity() { }
+
+	virtual int32_t getNext() const = 0;
+
+	virtual void setNext(int32_t n) = 0;
+
+	/*
+	virtual void getConstraintsLookahead(
+			std::vector<vsc::dm::IModelConstraint *> &constraints) = 0;
+	 */
+
+};
+
+}
+}
+}