| /* | |
| Copyright 2019 Alain Dargelas | |
| 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. | |
| */ | |
| /* | |
| * File: TestbenchElaboration.cpp | |
| * Author: alain | |
| * | |
| * Created on February 6, 2019, 9:01 PM | |
| */ | |
| #include <queue> | |
| #include "../SourceCompile/VObjectTypes.h" | |
| #include "../Design/VObject.h" | |
| #include "../Library/Library.h" | |
| #include "../Design/FileContent.h" | |
| #include "../SourceCompile/SymbolTable.h" | |
| #include "../ErrorReporting/Error.h" | |
| #include "../ErrorReporting/Location.h" | |
| #include "../ErrorReporting/Error.h" | |
| #include "../ErrorReporting/ErrorDefinition.h" | |
| #include "../ErrorReporting/ErrorContainer.h" | |
| #include "../SourceCompile/CompilationUnit.h" | |
| #include "../SourceCompile/PreprocessFile.h" | |
| #include "../SourceCompile/CompileSourceFile.h" | |
| #include "../SourceCompile/ParseFile.h" | |
| #include "../SourceCompile/Compiler.h" | |
| #include "CompileDesign.h" | |
| #include "../Testbench/Property.h" | |
| #include "../Design/Function.h" | |
| #include "../Testbench/ClassDefinition.h" | |
| #include "TestbenchElaboration.h" | |
| using namespace SURELOG; | |
| TestbenchElaboration::~TestbenchElaboration () { } | |
| bool TestbenchElaboration::bindTypedefs_() { | |
| Compiler* compiler = m_compileDesign->getCompiler (); | |
| ErrorContainer* errors = compiler->getErrorContainer (); | |
| SymbolTable* symbols = compiler->getSymbolTable (); | |
| Design* design = compiler->getDesign(); | |
| std::vector<std::pair < TypeDef*, DesignComponent*>> defs; | |
| for (auto file : design->getAllFileContents ()) | |
| { | |
| FileContent* fC = file.second; | |
| for (auto typed : fC ->getTypeDefMap ()) | |
| { | |
| TypeDef* typd = typed.second; | |
| defs.push_back (std::make_pair (typd, fC)); | |
| } | |
| } | |
| for (auto package : design->getPackageDefinitions ()) | |
| { | |
| Package* pack = package.second; | |
| for (auto typed : pack->getTypeDefMap ()) | |
| { | |
| TypeDef* typd = typed.second; | |
| defs.push_back (std::make_pair (typd, pack)); | |
| } | |
| } | |
| for (auto program_def : design->getProgramDefinitions ()) | |
| { | |
| Program* program = program_def.second; | |
| for (auto typed : program->getTypeDefMap ()) | |
| { | |
| TypeDef* typd = typed.second; | |
| defs.push_back (std::make_pair (typd, program)); | |
| } | |
| } | |
| for (auto class_def : design->getClassDefinitions ()) | |
| { | |
| ClassDefinition* classp = class_def.second; | |
| for (auto typed : classp->getTypeDefMap ()) | |
| { | |
| TypeDef* typd = typed.second; | |
| defs.push_back (std::make_pair (typd, classp)); | |
| } | |
| } | |
| for (auto def : defs) | |
| { | |
| TypeDef* typd = def.first; | |
| DesignComponent* comp = def.second; | |
| if (typd->getDefinition () == NULL) | |
| { | |
| DataType* def = bindTypeDef_ (typd, comp, ErrorDefinition::NO_ERROR_MESSAGE); | |
| if (def && (typd != def)) | |
| { | |
| typd->setDefinition (def); | |
| } | |
| else | |
| { | |
| FileContent* fC = typd->getFileContent (); | |
| NodeId id = typd->getNodeId (); | |
| std::string fileName = fC->getFileName (id); | |
| unsigned int line = fC->Line (id); | |
| std::string definition_string; | |
| NodeId defNode = typd->getDefinitionNode (); | |
| VObjectType defType = fC->Type (defNode); | |
| if (defType == VObjectType::slStringConst) | |
| { | |
| definition_string = fC->SymName (defNode); | |
| } | |
| Location loc1 (symbols->registerSymbol (fileName), line, 0, symbols->registerSymbol (definition_string)); | |
| Error err1 (ErrorDefinition::COMP_UNDEFINED_TYPE, loc1); | |
| errors->addError (err1); | |
| } | |
| } | |
| } | |
| return true; | |
| } | |
| bool checkValidFunction(DataType* dtype, std::string function, | |
| Statement* stmt, Design* design, std::string& datatypeName) | |
| { | |
| bool validFunction = true; | |
| VObjectType type = dtype->getType (); | |
| DataType* def = dtype->getDefinition (); | |
| if (type == VObjectType::slClass_declaration) | |
| { | |
| ClassDefinition* the_class = dynamic_cast<ClassDefinition*> (dtype); | |
| if (the_class) | |
| { | |
| Function* func = the_class->getFunction (function); | |
| if (func) | |
| stmt->setFunction (func); | |
| else | |
| validFunction = false; | |
| } | |
| else | |
| { | |
| the_class = dynamic_cast<ClassDefinition*> (def); | |
| if (the_class) | |
| { | |
| Function* func = the_class->getFunction (function); | |
| if (func) | |
| stmt->setFunction (func); | |
| else | |
| validFunction = false; | |
| } | |
| } | |
| } | |
| else if (dtype->isString_type (type)) | |
| { | |
| ClassDefinition* array = design->getClassDefinition ("builtin::string"); | |
| Function* func = array->getFunction (function); | |
| if (func) | |
| stmt->setFunction (func); | |
| else | |
| { | |
| datatypeName = "string"; | |
| validFunction = false; | |
| } | |
| } | |
| else | |
| validFunction = false; | |
| return validFunction; | |
| } | |
| bool checkValidBuiltinClass_(std::string classname, std::string function, | |
| Statement* stmt, Design* design, std::string& datatypeName) | |
| { | |
| bool validFunction = true; | |
| ClassDefinition* array = design->getClassDefinition ("builtin::" + classname); | |
| Function* func = array->getFunction (function); | |
| if (func) | |
| stmt->setFunction (func); | |
| else | |
| { | |
| datatypeName = classname; | |
| validFunction = false; | |
| } | |
| return validFunction; | |
| } | |
| void computeVarChain(FileContent* fC, NodeId nodeId, std::vector<std::string>& var_chain) { | |
| while (nodeId) | |
| { | |
| VObjectType type = fC->Type(nodeId); | |
| switch (type) | |
| { | |
| case VObjectType::slStringConst: | |
| { | |
| var_chain.push_back (fC->SymName(nodeId)); | |
| break; | |
| } | |
| case VObjectType::slImplicit_class_handle: | |
| { | |
| NodeId child = fC->Child(nodeId); | |
| VObjectType childType = fC->Type(child); | |
| if (childType == VObjectType::slThis_keyword) | |
| var_chain.push_back("this"); | |
| else if (childType == VObjectType::slSuper_keyword) | |
| var_chain.push_back("super"); | |
| else | |
| var_chain.push_back("UNKNOWN_TYPE"); | |
| break; | |
| } | |
| default: | |
| var_chain.push_back("UNKNOWN_NAME"); | |
| break; | |
| } | |
| nodeId = fC->Sibling(nodeId); | |
| } | |
| } | |
| bool TestbenchElaboration::bindClasses_() { | |
| checkForMultipleDefinition_(); | |
| bindBaseClasses_(); | |
| bindDataTypes_(); | |
| bindFunctions_(); | |
| bindTasks_(); | |
| return true; | |
| } | |
| bool TestbenchElaboration::checkForMultipleDefinition_() { | |
| Compiler* compiler = m_compileDesign->getCompiler (); | |
| ErrorContainer* errors = compiler->getErrorContainer (); | |
| SymbolTable* symbols = compiler->getSymbolTable (); | |
| Design* design = compiler->getDesign(); | |
| ClassNameClassDefinitionMultiMap classes = design->getClassDefinitions (); | |
| // Check for multiple definition | |
| std::string prevClassName = ""; | |
| ClassDefinition* prevClassDefinition = NULL; | |
| for (ClassNameClassDefinitionMultiMap::iterator itr = classes.begin(); itr != classes.end(); itr++) | |
| { | |
| std::string className = (*itr).first; | |
| ClassDefinition* classDefinition = (*itr).second; | |
| bool done = false; | |
| if (className == prevClassName) | |
| { | |
| FileContent* fC1 = classDefinition->getFileContents()[0]; | |
| NodeId nodeId1 = classDefinition->getNodeIds()[0]; | |
| std::string fileName1 = fC1->getFileName (nodeId1); | |
| unsigned int line1 = fC1->Line (nodeId1); | |
| Location loc1 (symbols->registerSymbol (fileName1), line1, 0, symbols->registerSymbol (className)); | |
| std::vector<Location> locations; | |
| while (1) | |
| { | |
| FileContent* fC2 = prevClassDefinition->getFileContents ()[0]; | |
| NodeId nodeId2 = prevClassDefinition->getNodeIds ()[0]; | |
| std::string fileName2 = fC2->getFileName (nodeId2); | |
| unsigned int line2 = fC2->Line (nodeId2); | |
| Location loc2 (symbols->registerSymbol (fileName2), line2, 0, symbols->registerSymbol (className)); | |
| if ((fileName1 != fileName2) || (line1 != line2)) | |
| { | |
| std::string diff; | |
| if (fC1->diffTree (diff, nodeId1, fC2, nodeId2)) | |
| { | |
| locations.push_back(loc2); | |
| } | |
| } | |
| itr++; | |
| if (itr == classes.end()) | |
| { | |
| done = true; | |
| break; | |
| } | |
| else | |
| { | |
| std::string nextClassName = (*itr).first; | |
| ClassDefinition* nextClassDefinition = (*itr).second; | |
| prevClassName = nextClassName; | |
| prevClassDefinition = nextClassDefinition; | |
| if (prevClassName != className) | |
| { | |
| className = prevClassName; | |
| classDefinition = prevClassDefinition; | |
| break; | |
| } | |
| } | |
| } | |
| if (locations.size()) | |
| { | |
| Error err1 (ErrorDefinition::COMP_MULTIPLY_DEFINED_CLASS, loc1, &locations); | |
| errors->addError (err1); | |
| } | |
| } | |
| prevClassName = className; | |
| prevClassDefinition = classDefinition; | |
| if (done) | |
| break; | |
| } | |
| return true; | |
| } | |
| bool TestbenchElaboration::bindBaseClasses_() { | |
| Compiler* compiler = m_compileDesign->getCompiler (); | |
| Design* design = compiler->getDesign(); | |
| ClassNameClassDefinitionMultiMap classes = design->getClassDefinitions (); | |
| // Bind base classes | |
| for (ClassNameClassDefinitionMultiMap::iterator itr = classes.begin(); itr != classes.end(); itr++) | |
| { | |
| std::string className = (*itr).first; | |
| ClassDefinition* classDefinition = (*itr).second; | |
| for (auto& class_def : classDefinition->getBaseClassMap ()) | |
| { | |
| DataType* the_def = bindDataType_(class_def.first, class_def.second->getFileContent (), | |
| class_def.second->getNodeId (), | |
| classDefinition, ErrorDefinition::COMP_UNDEFINED_BASE_CLASS); | |
| class_def.second = dynamic_cast<ClassDefinition*> (the_def); | |
| if(class_def.second) | |
| { | |
| // Super | |
| DataType* thisdt = new DataType (class_def.second->getFileContent (), class_def.second->getNodeId (), class_def.second->getName (), VObjectType::slClass_declaration); | |
| thisdt->setDefinition (class_def.second); | |
| Property* prop = new Property (thisdt, classDefinition->getFileContent (), classDefinition->getNodeId(), 0, "super", false, false, | |
| false, false, false); | |
| classDefinition->insertProperty (prop); | |
| } | |
| else | |
| { | |
| class_def.second = dynamic_cast<Parameter*> (the_def); | |
| if (class_def.second) | |
| { | |
| // Super | |
| DataType* thisdt = new DataType (class_def.second->getFileContent (), class_def.second->getNodeId (), class_def.second->getName (), VObjectType::slClass_declaration); | |
| thisdt->setDefinition (class_def.second); | |
| Property* prop = new Property (thisdt, classDefinition->getFileContent (), classDefinition->getNodeId (), 0, "super", false, false, | |
| false, false, false); | |
| classDefinition->insertProperty (prop); | |
| } | |
| } | |
| } | |
| } | |
| return true; | |
| } | |
| bool TestbenchElaboration::bindDataTypes_() { | |
| Compiler* compiler = m_compileDesign->getCompiler (); | |
| Design* design = compiler->getDesign(); | |
| ClassNameClassDefinitionMultiMap classes = design->getClassDefinitions (); | |
| // Bind data types | |
| for (ClassNameClassDefinitionMultiMap::iterator itr = classes.begin(); itr != classes.end(); itr++) | |
| { | |
| std::string className = (*itr).first; | |
| ClassDefinition* classDefinition = (*itr).second; | |
| for (auto& datatype : classDefinition->getUsedDataTypeMap ()) | |
| { | |
| std::string dataTypeName = datatype.first; | |
| DataType* dtype = datatype.second; | |
| if (dtype->getDefinition ()) | |
| continue; | |
| VObjectType type = dtype->getType (); | |
| if (type == VObjectType::slStringConst || | |
| type == VObjectType::slNull_rule || | |
| type == VObjectType::slClass_scope) | |
| { | |
| DataType* the_def = bindDataType_ (dataTypeName, dtype->getFileContent (), dtype->getNodeId (), | |
| classDefinition, ErrorDefinition::COMP_UNDEFINED_TYPE); | |
| if (the_def != dtype) | |
| dtype->setDefinition (the_def); | |
| } | |
| } | |
| for (auto& func : classDefinition->getFunctionMap ()) | |
| { | |
| for (auto& datatype : func.second->getUsedDataTypeMap ()) | |
| { | |
| std::string dataTypeName = datatype.first; | |
| DataType* dtype = datatype.second; | |
| if (dtype->getDefinition ()) | |
| continue; | |
| VObjectType type = dtype->getType (); | |
| if (type == VObjectType::slStringConst || | |
| type == VObjectType::slNull_rule || | |
| type == VObjectType::slClass_scope) | |
| { | |
| DataType* the_def = bindDataType_ (dataTypeName, dtype->getFileContent (), dtype->getNodeId (), | |
| classDefinition, ErrorDefinition::COMP_UNDEFINED_TYPE); | |
| if (the_def != dtype) | |
| dtype->setDefinition (the_def); | |
| } | |
| } | |
| } | |
| } | |
| return true; | |
| } | |
| bool TestbenchElaboration::bindFunctions_() { | |
| bindFunctionReturnTypesAndParamaters_(); | |
| bindFunctionBodies_(); | |
| return true; | |
| } | |
| bool TestbenchElaboration::bindFunctionReturnTypesAndParamaters_() { | |
| Compiler* compiler = m_compileDesign->getCompiler (); | |
| ErrorContainer* errors = compiler->getErrorContainer (); | |
| SymbolTable* symbols = compiler->getSymbolTable (); | |
| Design* design = compiler->getDesign(); | |
| ClassNameClassDefinitionMultiMap classes = design->getClassDefinitions (); | |
| // Bind Function return values, parameters and body | |
| for (ClassNameClassDefinitionMultiMap::iterator itr = classes.begin(); itr != classes.end(); itr++) | |
| { | |
| std::string className = (*itr).first; | |
| ClassDefinition* classDefinition = (*itr).second; | |
| for (auto& func : classDefinition->getFunctionMap ()) | |
| { | |
| DataType* dtype = func.second->getReturnType (); | |
| std::string dataTypeName = dtype->getName (); | |
| if (dtype->getDefinition ()) | |
| continue; | |
| if (dtype->getFileContent () == NULL) | |
| continue; | |
| if (dtype->getType () == VObjectType::slStringConst) | |
| { | |
| DataType* the_def = bindDataType_ (dataTypeName, dtype->getFileContent (), func.second->getNodeId (), | |
| classDefinition, ErrorDefinition::COMP_UNDEFINED_TYPE); | |
| if (the_def != dtype) | |
| dtype->setDefinition (the_def); | |
| } | |
| for (auto& param : func.second->getParams ()) | |
| { | |
| DataType* dtype = param->getDataType (); | |
| std::string dataTypeName = dtype->getName (); | |
| if (dtype->getDefinition ()) | |
| continue; | |
| if (dtype->getFileContent () == NULL) | |
| continue; | |
| if (dtype->getType () == VObjectType::slStringConst) | |
| { | |
| DataType* the_def = bindDataType_ (dataTypeName, dtype->getFileContent (), param->getNodeId (), | |
| classDefinition, ErrorDefinition::COMP_UNDEFINED_TYPE); | |
| if (the_def != dtype) | |
| dtype->setDefinition (the_def); | |
| if (the_def && the_def->isParameter ()) | |
| continue; | |
| Value* value = param->getDefault (); | |
| if (value) | |
| { | |
| if (!dtype->isCompatible (value)) | |
| { | |
| std::string name = param->getName (); | |
| std::string typeName = dtype->getName (); | |
| NodeId p = param->getNodeId (); | |
| FileContent* fC = dtype->getFileContent (); | |
| std::string fileName = fC->getFileName (p); | |
| unsigned int line = fC->Line (p); | |
| Location loc1 (symbols->registerSymbol (fileName), line, 0, symbols->registerSymbol (name + " of type " + typeName)); | |
| std::string exp; | |
| if (value->getType () == Value::String) | |
| exp = value->getValueS (); | |
| else if (value->getType () == Value::Double) | |
| exp = std::to_string (value->getValueD (0)); | |
| else | |
| exp = std::to_string (value->getValueL (0)); | |
| Location loc2 (0, 0, 0, symbols->registerSymbol (exp)); | |
| Error err1 (ErrorDefinition::COMP_INCOMPATIBLE_TYPES, loc1, loc2); | |
| errors->addError (err1); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return true; | |
| } | |
| bool TestbenchElaboration::bindSubRoutineCall_(ClassDefinition* classDefinition, Statement* stmt, Design* design, SymbolTable* symbols, ErrorContainer* errors) | |
| { | |
| std::string datatypeName; | |
| SubRoutineCallStmt* st = dynamic_cast<SubRoutineCallStmt*> (stmt); | |
| std::vector<std::string> var_chain = st->getVarChainNames (); | |
| std::string function = st->getFunc (); | |
| bool validFunction = true; | |
| DataType* dtype = NULL; | |
| Variable* the_obj = NULL; | |
| if (st->isStatic ()) | |
| the_obj = locateStaticVariable_ (var_chain, st->getFileContent (), st->getNodeId (), stmt->getScope (), classDefinition, ErrorDefinition::ELAB_UNDEF_VARIABLE); | |
| else | |
| the_obj = locateVariable_ (var_chain, st->getFileContent (), st->getNodeId (), stmt->getScope (), classDefinition, ErrorDefinition::ELAB_UNDEF_VARIABLE); | |
| if (the_obj) | |
| { | |
| dtype = the_obj->getDataType (); | |
| if (dtype == NULL) | |
| return true; | |
| VObjectType type = dtype->getType (); | |
| DataType* def = dtype->getDefinition (); | |
| if (type == VObjectType::slClass_declaration) | |
| { | |
| validFunction = checkValidFunction (dtype, function, stmt, design, datatypeName); | |
| } | |
| else if (dtype->isNumber (type) || dtype->isInteger_type (type) || | |
| dtype->isNon_integer_type (type) || dtype->isString_type (type)) | |
| { | |
| if (def) | |
| { | |
| type = def->getType (); | |
| dtype = def; | |
| } | |
| NodeId range = the_obj->getRange (); | |
| if (range) | |
| { | |
| VObjectType rangeType = the_obj->getFileContent ()->Type (range); | |
| if (rangeType == VObjectType::slUnsized_dimension) | |
| { | |
| // Vector | |
| validFunction = checkValidBuiltinClass_("array", function, stmt, design, datatypeName); | |
| } | |
| else if (rangeType == VObjectType::slVariable_dimension) | |
| { | |
| FileContent* sfC = the_obj->getFileContent (); | |
| NodeId subRange = sfC->Child (range); | |
| VObjectType the_type = sfC->Type (subRange); | |
| if (the_type == VObjectType::slQueue_dimension) | |
| { | |
| // Queue | |
| // foreach (darray[id]) darray[id].func() | |
| NodeId tmp = stmt->getNodeId (); | |
| tmp = sfC->Child (tmp); | |
| tmp = sfC->Sibling (tmp); | |
| VObjectType t = sfC->Type (tmp); | |
| if ((t == VObjectType::slConstant_bit_select) && sfC->Child (tmp)) | |
| { | |
| // there is an actual array index | |
| if (type == VObjectType::slClass_declaration) | |
| { | |
| validFunction = checkValidFunction (dtype, function, stmt, design, datatypeName); | |
| } | |
| } | |
| else | |
| { | |
| validFunction = checkValidBuiltinClass_("queue", function, stmt, design, datatypeName); | |
| } | |
| } | |
| else if (the_type == VObjectType::slUnpacked_dimension) | |
| { | |
| // foreach (darray[id]) darray[id].func() | |
| NodeId subroutine_call = stmt->getNodeId (); | |
| NodeId var_id = sfC->Child (subroutine_call); | |
| NodeId constant_bit_select = sfC->Sibling (var_id); | |
| VObjectType t = sfC->Type (constant_bit_select); | |
| NodeId select_id = sfC->Child (constant_bit_select); | |
| if ((t == VObjectType::slConstant_bit_select) && select_id) | |
| { | |
| validFunction = checkValidFunction (dtype, function, stmt, design, datatypeName); | |
| } | |
| else | |
| { | |
| validFunction = checkValidBuiltinClass_("queue", function, stmt, design, datatypeName); | |
| } | |
| } | |
| } | |
| } | |
| else | |
| { | |
| validFunction = checkValidFunction (dtype, function, stmt, design, datatypeName); | |
| } | |
| } | |
| } | |
| if (var_chain.size () == 0) | |
| { | |
| if (st->isSystemCall ()) | |
| { | |
| validFunction = checkValidBuiltinClass_("system", function, stmt, design, datatypeName); | |
| if (!validFunction) | |
| { | |
| FileContent* fC = st->getFileContent (); | |
| NodeId p = st->getNodeId (); | |
| std::string fileName = fC->getFileName (p); | |
| unsigned int line = fC->Line (p); | |
| Location loc1 (symbols->registerSymbol (fileName), line, 0, symbols->registerSymbol (function)); | |
| Error err1 (ErrorDefinition::COMP_UNDEFINED_SYSTEM_FUNCTION, loc1); | |
| errors->addError (err1); | |
| return true; | |
| } | |
| } | |
| else | |
| { | |
| Function* func = classDefinition->getFunction (function); | |
| if (func) | |
| stmt->setFunction (func); | |
| else | |
| { | |
| validFunction = false; | |
| dtype = classDefinition; | |
| } | |
| } | |
| } | |
| if (validFunction == false) | |
| { | |
| if (dtype->isParameter ()) | |
| { | |
| return true; | |
| } | |
| std::string name; | |
| for (auto v : var_chain) name += v + "."; | |
| if (name.size ()) | |
| name = name.substr (0, name.size () - 1); | |
| while (dtype && dtype->getDefinition ()) | |
| { | |
| dtype = dtype->getDefinition (); | |
| } | |
| if (name == "") | |
| { | |
| name = "this"; | |
| } | |
| std::string typeName = dtype->getName (); | |
| if (datatypeName != "") | |
| typeName = datatypeName; | |
| NodeId p = st->getNodeId (); | |
| FileContent* fC = st->getFileContent (); | |
| std::string fileName = fC->getFileName (p); | |
| unsigned int line = fC->Line (p); | |
| Location loc1 (symbols->registerSymbol (fileName), line, 0, symbols->registerSymbol ("\"" + name + "\"" + " of type " + typeName)); | |
| FileContent* fC2 = dtype->getFileContent (); | |
| std::string fileName2 = fC2->getFileName (dtype->getNodeId ()); | |
| unsigned int line2 = fC2->Line (dtype->getNodeId ()); | |
| Location loc2 (symbols->registerSymbol (fileName2), line2, 0, symbols->registerSymbol (function)); | |
| Error err1 (ErrorDefinition::COMP_NO_METHOD_FOR_TYPE, loc1, loc2); | |
| errors->addError (err1); | |
| } | |
| return true; | |
| } | |
| bool TestbenchElaboration::bindForLoop_(ClassDefinition* classDefinition, Statement* stmt, ForLoopStmt* st) { | |
| FileContent* sfC = st->getFileContent (); | |
| NodeId fid = st->getNodeId (); | |
| VObjectType itr_type = st->getIteratorType (); | |
| DataType* itrDataType = new DataType (sfC, fid, "integer", itr_type); | |
| for (auto itrId : st->getIteratorIds ()) | |
| { | |
| Variable* var = new Variable (itrDataType, sfC, itrId.first, 0, sfC->SymName (itrId.first)); | |
| st->getParentScope ()->addVariable (var); | |
| } | |
| return true; | |
| } | |
| bool TestbenchElaboration::bindForeachLoop_(ClassDefinition* classDefinition, Statement* stmt, ForeachLoopStmt* st) { | |
| NodeId arrayId = st->getArrayId (); | |
| FileContent* sfC = st->getFileContent (); | |
| std::vector<std::string> var_chain; | |
| computeVarChain (sfC, arrayId, var_chain); | |
| Variable* arrayVar = locateVariable_ (var_chain, sfC, arrayId, stmt->getScope (), classDefinition, ErrorDefinition::ELAB_UNDEF_VARIABLE); | |
| if (arrayVar) | |
| { | |
| NodeId range = arrayVar->getRange (); | |
| NodeId rangeTypeId = range; | |
| DataType* itrDataType = NULL; | |
| while (range) | |
| { | |
| rangeTypeId = range; | |
| range = sfC->Child (rangeTypeId); | |
| } | |
| VObjectType rangeType = sfC->Type (rangeTypeId); | |
| if (rangeType == VObjectType::slStringConst) | |
| { | |
| std::string dataTypeName = sfC->SymName (rangeTypeId); | |
| itrDataType = bindDataType_ (dataTypeName, sfC, rangeTypeId, | |
| classDefinition, ErrorDefinition::COMP_UNDEFINED_TYPE); | |
| } | |
| else if (rangeType == VObjectType::slAssociative_dimension || | |
| rangeType == VObjectType::slQueue_dimension) | |
| { | |
| // Integer Type | |
| itrDataType = new DataType (sfC, arrayId, "integer", VObjectType::slIntegerAtomType_Int); | |
| } | |
| for (auto itrId : st->getIteratorIds ()) | |
| { | |
| Variable* var = new Variable (itrDataType, sfC, itrId, 0, sfC->SymName (itrId)); | |
| st->getParentScope ()->addVariable (var); | |
| } | |
| } | |
| return true; | |
| } | |
| bool TestbenchElaboration::bindFunctionBodies_() { | |
| Compiler* compiler = m_compileDesign->getCompiler (); | |
| ErrorContainer* errors = compiler->getErrorContainer (); | |
| SymbolTable* symbols = compiler->getSymbolTable (); | |
| Design* design = compiler->getDesign(); | |
| ClassNameClassDefinitionMultiMap classes = design->getClassDefinitions (); | |
| // Bind Function return values, parameters and body | |
| for (ClassNameClassDefinitionMultiMap::iterator itr = classes.begin(); itr != classes.end(); itr++) | |
| { | |
| std::string className = (*itr).first; | |
| ClassDefinition* classDefinition = (*itr).second; | |
| for (auto& func : classDefinition->getFunctionMap ()) | |
| { | |
| // Skip binding of parameterized classes | |
| if (!classDefinition->hasCompleteBaseSpecification ()) | |
| continue; | |
| std::queue<Statement*> stmts; | |
| for (Statement* stmt : func.second->getStmts ()) | |
| stmts.push (stmt); | |
| while (stmts.size()) | |
| { | |
| Statement* stmt = stmts.front (); | |
| stmts.pop(); | |
| for (Statement* stmt1 : stmt->getStatements()) | |
| stmts.push (stmt1); | |
| VObjectType stmt_type = stmt->getType(); | |
| switch (stmt_type) | |
| { | |
| case VObjectType::slPs_or_hierarchical_array_identifier: | |
| { | |
| // Foreach loop | |
| ForeachLoopStmt* st = dynamic_cast<ForeachLoopStmt*> (stmt); | |
| if (st) | |
| { | |
| bindForeachLoop_(classDefinition, stmt, st); | |
| } | |
| break; | |
| } | |
| case VObjectType::slFor_initialization: | |
| { | |
| // For loop | |
| ForLoopStmt* st = dynamic_cast<ForLoopStmt*> (stmt); | |
| if (st) | |
| { | |
| bindForLoop_(classDefinition, stmt, st); | |
| } | |
| break; | |
| } | |
| case VObjectType::slSubroutine_call_statement: | |
| bindSubRoutineCall_(classDefinition, stmt, design, symbols, errors); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| return true; | |
| } | |
| bool TestbenchElaboration::bindTasks_() { | |
| Compiler* compiler = m_compileDesign->getCompiler (); | |
| //ErrorContainer* errors = compiler->getErrorContainer (); | |
| //SymbolTable* symbols = compiler->getSymbolTable (); | |
| Design* design = compiler->getDesign(); | |
| ClassNameClassDefinitionMultiMap classes = design->getClassDefinitions (); | |
| // Bind Tasks parameters and body | |
| for (ClassNameClassDefinitionMultiMap::iterator itr = classes.begin(); itr != classes.end(); itr++) | |
| { | |
| std::string className = (*itr).first; | |
| ClassDefinition* classDefinition = (*itr).second; | |
| // Bind Tasks parameters | |
| for (auto& func : classDefinition->getTaskMap ()) | |
| { | |
| for (auto param : func.second->getParams ()) | |
| { | |
| DataType* dtype = param->getDataType (); | |
| std::string dataTypeName = dtype->getName (); | |
| if (dtype->getDefinition ()) | |
| continue; | |
| if (dtype->getFileContent () == NULL) | |
| continue; | |
| if (dtype->getType () == VObjectType::slStringConst) | |
| { | |
| DataType* the_def = bindDataType_ (dataTypeName, dtype->getFileContent (), param->getNodeId (), | |
| classDefinition, ErrorDefinition::COMP_UNDEFINED_TYPE); | |
| if (the_def != dtype) | |
| dtype->setDefinition (the_def); | |
| } | |
| } | |
| } | |
| } | |
| return true; | |
| } | |