| /* |
| 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: ResolveSymbols.cpp |
| * Author: alain |
| * |
| * Created on July 1, 2017, 12:38 PM |
| */ |
| #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 "../Testbench/Program.h" |
| #include "../Testbench/ClassDefinition.h" |
| #include "CompileDesign.h" |
| #include "ResolveSymbols.h" |
| |
| using namespace SURELOG; |
| |
| ResolveSymbols::~ResolveSymbols() { |
| } |
| |
| int FunctorCreateLookup::operator() () const |
| { |
| ResolveSymbols* instance = new ResolveSymbols (m_compileDesign, m_fileData, m_symbolTable, m_errorContainer); |
| instance->createFastLookup (); |
| delete instance; |
| return true; |
| } |
| |
| int FunctorResolve::operator() () const |
| { |
| ResolveSymbols* instance = new ResolveSymbols (m_compileDesign, m_fileData, m_symbolTable, m_errorContainer); |
| instance->resolve (); |
| delete instance; |
| return true; |
| } |
| |
| std::string |
| ResolveSymbols::SymName (NodeId index) |
| { |
| return m_fileData->getSymbolTable ()->getSymbol (Name (index)); |
| } |
| |
| void |
| ResolveSymbols::createFastLookup () |
| { |
| Library* lib = m_fileData->getLibrary (); |
| std::string libName = lib->getName (); |
| |
| //std::string fileName = "FILE: " + m_fileData->getFileName() + " " + m_fileData->getChunkFileName () + "\n"; |
| //std::cout << fileName; |
| |
| std::vector<VObjectType> types = { |
| VObjectType::slModule_declaration, |
| VObjectType::slPackage_declaration, |
| VObjectType::slConfig_declaration, |
| VObjectType::slUdp_declaration, |
| VObjectType::slInterface_declaration, |
| VObjectType::slProgram_declaration, |
| VObjectType::slClass_declaration |
| }; |
| |
| std::vector<VObjectType> stopPoints = { |
| VObjectType::slModule_declaration, |
| VObjectType::slPackage_declaration, |
| VObjectType::slProgram_declaration, |
| VObjectType::slClass_declaration |
| }; |
| |
| std::vector<NodeId> objects = m_fileData->sl_collect_all (m_fileData->getRootNode (), types, stopPoints); |
| |
| for (auto object : objects) |
| { |
| VObjectType type = m_fileData->Type (object); |
| NodeId stId = m_fileData->sl_collect (object, VObjectType::slStringConst, VObjectType::slAttr_spec ); |
| if (stId != InvalidNodeId) |
| { |
| std::string name = SymName (stId); |
| m_fileData->insertObjectLookup(name, object, m_errorContainer); |
| std::string fullName = libName + "@" + name; |
| |
| switch (type) |
| { |
| case VObjectType::slPackage_declaration: |
| { |
| // Package names are not prefixed by Library names! |
| std::string pkgname = name; |
| Package* pdef = new Package (pkgname, lib, m_fileData, object); |
| m_fileData->addPackageDefinition (pkgname, pdef); |
| |
| std::vector<VObjectType> subtypes = {VObjectType::slClass_declaration}; |
| std::vector<NodeId> subobjects = m_fileData->sl_collect_all (object, subtypes, subtypes); |
| for (auto subobject : subobjects) |
| { |
| NodeId stId = m_fileData->sl_collect (subobject, VObjectType::slStringConst, VObjectType::slAttr_spec); |
| if (stId != InvalidNodeId) |
| { |
| std::string name = SymName (stId); |
| std::string fullSubName = pkgname + "::" + name; |
| m_fileData->insertObjectLookup(fullSubName, subobject, m_errorContainer); |
| |
| ClassDefinition* def = new ClassDefinition (fullSubName, lib, pdef, m_fileData, subobject, NULL); |
| m_fileData->addClassDefinition (fullSubName, def); |
| pdef->addClassDefinition (fullSubName, def); |
| } |
| } |
| break; |
| } |
| case VObjectType::slProgram_declaration: |
| { |
| Program* mdef = new Program (fullName, lib, m_fileData, object); |
| m_fileData->addProgramDefinition (fullName, mdef); |
| |
| std::vector<VObjectType> subtypes = {VObjectType::slClass_declaration}; |
| std::vector<NodeId> subobjects = m_fileData->sl_collect_all (object, subtypes, subtypes); |
| for (auto subobject : subobjects) |
| { |
| NodeId stId = m_fileData->sl_collect (subobject, VObjectType::slStringConst, VObjectType::slAttr_spec); |
| if (stId != InvalidNodeId) |
| { |
| std::string name = SymName (stId); |
| std::string fullSubName = fullName + "::" + name; |
| m_fileData->insertObjectLookup(fullSubName, subobject, m_errorContainer); |
| ClassDefinition* def = new ClassDefinition (fullSubName, lib, mdef, m_fileData, subobject, NULL); |
| m_fileData->addClassDefinition (fullSubName, def); |
| mdef->addClassDefinition (fullSubName, def); |
| } |
| } |
| break; |
| } |
| case VObjectType::slClass_declaration: |
| { |
| ClassDefinition* def = new ClassDefinition (fullName, lib, NULL, m_fileData, object, NULL); |
| m_fileData->addClassDefinition (fullName, def); |
| break; |
| } |
| case VObjectType::slModule_declaration: |
| { |
| ModuleDefinition* mdef = new ModuleDefinition (m_fileData, object, fullName); |
| m_fileData->addModuleDefinition (fullName, mdef); |
| |
| std::vector<VObjectType> subtypes = {VObjectType::slClass_declaration, |
| VObjectType::slModule_declaration}; |
| std::vector<NodeId> subobjects = m_fileData->sl_collect_all (object, subtypes, subtypes); |
| for (auto subobject : subobjects) |
| { |
| NodeId stId = m_fileData->sl_collect (subobject, VObjectType::slStringConst, VObjectType::slAttr_spec); |
| if (stId != InvalidNodeId) |
| { |
| std::string name = SymName (stId); |
| std::string fullSubName = fullName + "::" + name; |
| m_fileData->insertObjectLookup(fullSubName, subobject, m_errorContainer); |
| |
| if (m_fileData->Type(subobject) == VObjectType::slClass_declaration) |
| { |
| ClassDefinition* def = new ClassDefinition (fullSubName, lib, mdef, m_fileData, subobject, NULL); |
| m_fileData->addClassDefinition (fullSubName, def); |
| mdef->addClassDefinition (fullSubName, def); |
| } |
| else |
| { |
| ModuleDefinition* def = new ModuleDefinition (m_fileData, subobject, fullSubName); |
| m_fileData->addModuleDefinition (fullSubName, def); |
| } |
| } |
| } |
| |
| break; |
| } |
| case VObjectType::slConfig_declaration: |
| case VObjectType::slUdp_declaration: |
| case VObjectType::slInterface_declaration: |
| default: |
| ModuleDefinition* def = new ModuleDefinition (m_fileData, object, fullName); |
| m_fileData->addModuleDefinition (fullName, def); |
| break; |
| } |
| } |
| } |
| } |
| |
| |
| VObject& ResolveSymbols::Object (NodeId index) { |
| if (index == InvalidNodeId) |
| return m_fileData->Object (0); |
| return m_fileData->Object (index); |
| } |
| |
| NodeId ResolveSymbols::UniqueId (NodeId index){ |
| return index; |
| } |
| |
| SymbolId ResolveSymbols::Name (NodeId index){ |
| if (index == InvalidNodeId) |
| return 0; |
| return Object(index).m_name; |
| } |
| |
| NodeId ResolveSymbols::Child (NodeId index){ |
| if (index == InvalidNodeId) |
| return 0; |
| return Object(index).m_child; |
| } |
| |
| NodeId ResolveSymbols::Sibling (NodeId index){ |
| if (index == InvalidNodeId) |
| return 0; |
| return Object(index).m_sibling; |
| } |
| |
| static NodeId UndefinedObjectDefinition = 0; |
| NodeId& ResolveSymbols::Definition (NodeId index){ |
| if (index == InvalidNodeId) |
| return UndefinedObjectDefinition; |
| return Object(index).m_definition; |
| } |
| |
| NodeId ResolveSymbols::Parent (NodeId index){ |
| if (index == InvalidNodeId) |
| return 0; |
| return Object(index).m_parent; |
| } |
| |
| static unsigned short UndefinedObjectType = 0; |
| unsigned short& ResolveSymbols::Type (NodeId index){ |
| if (index == InvalidNodeId) |
| return UndefinedObjectType; |
| return Object(index).m_type; |
| } |
| |
| unsigned int ResolveSymbols::Line (NodeId index){ |
| if (index == InvalidNodeId) |
| return 0; |
| return Object(index).m_line; |
| } |
| |
| std::string ResolveSymbols::Symbol(SymbolId id) { |
| return m_fileData->getSymbolTable()->getSymbol (id); |
| } |
| |
| NodeId |
| ResolveSymbols::sl_get (NodeId parent, VObjectType type) { |
| return m_fileData->sl_get(parent, type); |
| } |
| |
| NodeId ResolveSymbols::sl_parent(NodeId parent, VObjectType type) { |
| return m_fileData->sl_parent(parent, type); |
| } |
| |
| NodeId ResolveSymbols::sl_parent(NodeId parent, std::vector<VObjectType> types, VObjectType& actualType) { |
| return m_fileData->sl_parent(parent, types, actualType); |
| } |
| |
| std::vector<NodeId> |
| ResolveSymbols::sl_get_all (NodeId parent, VObjectType type) { |
| return m_fileData->sl_get_all(parent, type); |
| } |
| |
| NodeId |
| ResolveSymbols::sl_collect (NodeId parent, VObjectType type) { |
| return m_fileData->sl_collect(parent, type); |
| } |
| |
| std::vector<NodeId> |
| ResolveSymbols::sl_collect_all (NodeId parent, VObjectType type) { |
| return m_fileData->sl_collect_all(parent, type); |
| } |
| |
| bool |
| ResolveSymbols::bindDefinition_ (unsigned int objIndex, std::vector<VObjectType> bindTypes) |
| { |
| std::string modName = SymName (sl_collect (objIndex, VObjectType::slStringConst)); |
| std::string instName = SymName (Child (sl_collect (objIndex, slName_of_instance))); |
| Design::FileIdDesignContentMap& all_files = this->m_compileDesign->getCompiler ()->getDesign ()->getAllFileContents (); |
| |
| bool found = false; |
| for (auto file : all_files) |
| { |
| SymbolId fileId = file.first; |
| FileContent* fcontent = file.second; |
| |
| auto itr = fcontent->getObjectLookup ().find (modName); |
| if (itr != fcontent->getObjectLookup ().end ()) |
| { |
| VObjectType actualType; |
| NodeId index = (*itr).second; |
| NodeId mod = fcontent->sl_parent (index, bindTypes, actualType); |
| if (mod != InvalidNodeId) |
| { |
| Definition(objIndex) = mod; |
| fcontent->getReferencedObjects().insert(modName); |
| m_fileData->SetDefinitionFile(objIndex,fileId); |
| switch (actualType) |
| { |
| case VObjectType::slUdp_declaration: |
| Type(objIndex) = VObjectType::slUdp_instantiation; |
| break; |
| case VObjectType::slModule_declaration: |
| Type (objIndex) = VObjectType::slModule_instantiation; |
| break; |
| case VObjectType::slInterface_declaration: |
| Type (objIndex) = VObjectType::slInterface_instantiation; |
| break; |
| case VObjectType::slProgram_declaration: |
| Type (objIndex) = VObjectType::slProgram_instantiation; |
| break; |
| default: |
| break; |
| } |
| found = true; |
| //std::cout << "FOUND MODEL FOR " << modName << " " << instName << std::endl; |
| //std::cout << m_fileData->printSubTree (objIndex) << std::endl; |
| break; |
| } |
| } |
| } |
| return found; |
| } |
| |
| bool |
| ResolveSymbols::resolve () |
| { |
| |
| unsigned int size = m_fileData->getVObjects ().size (); |
| for (unsigned int objIndex = 0; objIndex < size; objIndex++) |
| { |
| //ErrorDefinition::ErrorType errorType; |
| bool bind = false; |
| if (Type (objIndex) == VObjectType::slUdp_instantiation) |
| { |
| bind = true; |
| //errorType = ErrorDefinition::ELAB_NO_UDP_DEFINITION; |
| } |
| else if (Type (objIndex) == VObjectType::slModule_instantiation) |
| { |
| bind = true; |
| //errorType = ErrorDefinition::ELAB_NO_MODULE_DEFINITION; |
| } |
| else if (Type (objIndex) == VObjectType::slInterface_instantiation) |
| { |
| bind = true; |
| //errorType = ErrorDefinition::ELAB_NO_INTERFACE_DEFINITION; |
| } |
| else if (Type (objIndex) == VObjectType::slProgram_instantiation) |
| { |
| bind = true; |
| //errorType = ErrorDefinition::ELAB_NO_PROGRAM_DEFINITION; |
| } |
| if (bind) |
| { |
| /*bool found = */ |
| bindDefinition_ (objIndex,{slUdp_declaration, slModule_declaration, slInterface_declaration, slProgram_declaration}); |
| /* |
| * This warning is now treated in the elaboration to give the library information |
| if (!found) |
| { |
| std::string modName = SymName (sl_collect (objIndex, slStringConst)); |
| Location loc (m_fileData->getFileId (), Line (objIndex), 0, m_symbolTable->registerSymbol (modName)); |
| Error err (errorType, loc); |
| m_errorContainer->addError (err, false, false); |
| } |
| */ |
| } |
| |
| } |
| |
| return true; |
| } |
| |
