| /* | |
| 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: ElaborationStep.cpp | |
| * Author: alain | |
| * | |
| * Created on July 12, 2017, 8:55 PM | |
| */ | |
| #include "../SourceCompile/VObjectTypes.h" | |
| #include "../Design/VObject.h" | |
| #include "../Library/Library.h" | |
| #include "../Utils/StringUtils.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/ClassDefinition.h" | |
| #include "ElaborationStep.h" | |
| using namespace SURELOG; | |
| ElaborationStep::~ElaborationStep () { } | |
| DataType* | |
| ElaborationStep::bindTypeDef_ (TypeDef* typd, DesignComponent* parent, ErrorDefinition::ErrorType errtype) | |
| { | |
| Compiler* compiler = m_compileDesign->getCompiler (); | |
| SymbolTable* symbols = compiler->getSymbolTable (); | |
| NodeId defNode = typd->getDefinitionNode (); | |
| FileContent* fC = typd->getFileContent (); | |
| VObjectType defType = fC->Type (defNode); | |
| std::string objName; | |
| if (defType == VObjectType::slStringConst) | |
| { | |
| objName = fC->SymName (defNode); | |
| } | |
| else | |
| { | |
| objName = "NOT_A_VALID_TYPE_NAME"; | |
| symbols->registerSymbol (objName); | |
| } | |
| DataType* result = bindDataType_ (objName, fC, defNode, parent, errtype); | |
| if (result != typd) | |
| return result; | |
| else | |
| return NULL; | |
| } | |
| DataType* | |
| ElaborationStep::bindDataType_ (std::string type_name, FileContent* fC, NodeId id, DesignComponent* parent, ErrorDefinition::ErrorType errtype) | |
| { | |
| DataType* result = NULL; | |
| Compiler* compiler = m_compileDesign->getCompiler (); | |
| ErrorContainer* errors = compiler->getErrorContainer (); | |
| SymbolTable* symbols = compiler->getSymbolTable (); | |
| Design* design = compiler->getDesign (); | |
| std::string libName = "work"; | |
| if (parent->getFileContents ().size()) | |
| libName = parent->getFileContents ()[0]->getLibrary ()->getName (); | |
| ClassNameClassDefinitionMultiMap classes = design->getClassDefinitions (); | |
| bool found = false; | |
| bool classFound = false; | |
| std::string class_in_lib = libName + "@" + type_name; | |
| ClassNameClassDefinitionMultiMap::iterator itr1 = classes.end (); | |
| if (type_name == "signed") | |
| { | |
| result = new DataType(fC, id, type_name, VObjectType::slSigning_Signed); | |
| return result; | |
| } | |
| else if (type_name == "unsigned") | |
| { | |
| result = new DataType(fC, id, type_name, VObjectType::slSigning_Unsigned); | |
| return result; | |
| } | |
| else if (type_name == "logic") | |
| { | |
| result = new DataType(fC, id, type_name, VObjectType::slIntVec_TypeLogic); | |
| return result; | |
| } | |
| else if (type_name == "bit") | |
| { | |
| result = new DataType(fC, id, type_name, VObjectType::slIntVec_TypeBit); | |
| return result; | |
| } | |
| else if (type_name == "byte") | |
| { | |
| result = new DataType(fC, id, type_name, VObjectType::slIntegerAtomType_Byte); | |
| return result; | |
| } | |
| if ((result = parent->getDataType (type_name))) | |
| { | |
| found = true; | |
| } | |
| if (found == false) | |
| { | |
| itr1 = classes.find (class_in_lib); | |
| if (itr1 != classes.end ()) | |
| { | |
| found = true; | |
| classFound = true; | |
| } | |
| } | |
| if (found == false) | |
| { | |
| std::string class_in_class = parent->getName () + "::" + type_name; | |
| itr1 = classes.find (class_in_class); | |
| if (itr1 != classes.end ()) | |
| { | |
| found = true; | |
| classFound = true; | |
| } | |
| } | |
| if (found == false) | |
| { | |
| if (parent->getParentScope ()) | |
| { | |
| std::string class_in_own_package = ((DesignComponent*) parent->getParentScope ())->getName () + "::" + type_name; | |
| itr1 = classes.find (class_in_own_package); | |
| if (itr1 != classes.end ()) | |
| { | |
| found = true; | |
| classFound = true; | |
| } | |
| } | |
| } | |
| if (found == false) | |
| { | |
| for (auto package : parent->getAccessPackages ()) | |
| { | |
| std::string class_in_package = package->getName () + "::" + type_name; | |
| itr1 = classes.find (class_in_package); | |
| if (itr1 != classes.end ()) | |
| { | |
| found = true; | |
| classFound = true; | |
| break; | |
| } | |
| DataType* dtype = package->getDataType (type_name); | |
| if (dtype) | |
| { | |
| found = true; | |
| result = dtype; | |
| break; | |
| } | |
| } | |
| } | |
| if (found == false) | |
| { | |
| ClassDefinition* classDefinition = dynamic_cast<ClassDefinition*> (parent); | |
| if (classDefinition) | |
| { | |
| if (classDefinition->getName () == type_name) | |
| { | |
| result = classDefinition; | |
| found = true; | |
| } | |
| if (found == false) | |
| { | |
| Parameter* param = classDefinition->getParameter (type_name); | |
| if (param) | |
| { | |
| found = true; | |
| result = param; | |
| } | |
| } | |
| if (found == false) | |
| { | |
| if ((result = classDefinition->getBaseDataType (type_name))) | |
| { | |
| found = true; | |
| } | |
| } | |
| if (found == false) | |
| { | |
| if (classDefinition->getContainer ()) | |
| { | |
| DataType* dtype = classDefinition->getContainer ()->getDataType (type_name); | |
| if (dtype) | |
| { | |
| found = true; | |
| result = dtype; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if (found == false) | |
| { | |
| TypeDef* def = parent->getTypeDef (type_name); | |
| if (def) | |
| { | |
| found = true; | |
| result = def; | |
| } | |
| } | |
| if (found == false) | |
| { | |
| auto res = parent->getNamedObject (type_name); | |
| if (res) | |
| { | |
| DesignComponent* comp = res->second; | |
| result = dynamic_cast<ClassDefinition*> (comp); | |
| if (result) | |
| found = true; | |
| } | |
| } | |
| if (found == false) | |
| { | |
| auto res = parent->getNamedObject (libName + "@" + type_name); | |
| if (res) | |
| { | |
| DesignComponent* comp = res->second; | |
| result = dynamic_cast<ClassDefinition*> (comp); | |
| if (result) | |
| found = true; | |
| } | |
| } | |
| if (found == false) | |
| { | |
| const char* sname = type_name.c_str(); | |
| if (strstr(sname, "::")) | |
| { | |
| std::vector<std::string> args; | |
| StringUtils::tokenizeMulti(type_name, "::", args); | |
| std::string classOrPackageName = args[0]; | |
| std::string the_type_name = args[1]; | |
| itr1 = classes.find (libName + "@"+ classOrPackageName); | |
| if (itr1 == classes.end()) | |
| { | |
| if (parent->getParentScope ()) | |
| { | |
| std::string class_in_own_package = ((DesignComponent*) parent->getParentScope ())->getName () + "::" + classOrPackageName; | |
| itr1 = classes.find (class_in_own_package); | |
| } | |
| } | |
| if (itr1 != classes.end()) | |
| { | |
| DataType* dtype = (*itr1).second->getDataType (the_type_name); | |
| if (dtype) | |
| { | |
| result = dtype; | |
| found = true; | |
| } | |
| } | |
| if (found == false) | |
| { | |
| Package* pack = design->getPackage (classOrPackageName); | |
| if (pack) | |
| { | |
| DataType* dtype = pack->getDataType (the_type_name); | |
| if (dtype) | |
| { | |
| result = dtype; | |
| found = true; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if ((found == false) && (errtype != ErrorDefinition::NO_ERROR_MESSAGE)) | |
| { | |
| std::string fileName = fC->getFileName (id); | |
| unsigned int line = fC->Line (id); | |
| Location loc1 (symbols->registerSymbol (fileName), line, 0, symbols->registerSymbol (type_name)); | |
| Location loc2 (0, 0, 0, symbols->registerSymbol (parent->getName ())); | |
| Error err1 (errtype, loc1, loc2); | |
| errors->addError (err1); | |
| } | |
| else | |
| { | |
| if (classFound == true) | |
| { | |
| // Binding | |
| ClassDefinition* def = (*itr1).second; | |
| result = def; | |
| } | |
| } | |
| while (result && result->getDefinition ()) | |
| { | |
| result = result->getDefinition (); | |
| } | |
| return result; | |
| } | |
| Variable* ElaborationStep::bindVariable_ (std::string var_name, Scope* scope, FileContent* fC, NodeId id, | |
| DesignComponent* parent, ErrorDefinition::ErrorType errtype, bool returnClassParam) | |
| { | |
| Compiler* compiler = m_compileDesign->getCompiler (); | |
| ErrorContainer* errors = compiler->getErrorContainer (); | |
| SymbolTable* symbols = compiler->getSymbolTable (); | |
| Variable* result = NULL; | |
| ClassDefinition* classDefinition = dynamic_cast<ClassDefinition*> (parent); | |
| if (classDefinition) | |
| result = classDefinition->getProperty (var_name); | |
| if (result == NULL) | |
| { | |
| if (scope) | |
| { | |
| result = scope->getVariable (var_name); | |
| } | |
| } | |
| if ((result == NULL) && scope) | |
| { | |
| Scope* itr_scope = scope; | |
| while (itr_scope) | |
| { | |
| Procedure* proc = dynamic_cast<Procedure*> (itr_scope); | |
| if (proc) | |
| { | |
| for (auto param : proc->getParams ()) | |
| { | |
| if (param->getName () == var_name) | |
| { | |
| result = param; | |
| break; | |
| } | |
| } | |
| } | |
| if (result) | |
| break; | |
| itr_scope = itr_scope->getParentScope (); | |
| } | |
| } | |
| if (result == NULL && parent) | |
| { | |
| for (auto package : parent->getAccessPackages ()) | |
| { | |
| Value* val = package->getValue (var_name); | |
| if (val) | |
| { | |
| break; | |
| } | |
| } | |
| } | |
| if ((result == NULL) && (errtype != ErrorDefinition::NO_ERROR_MESSAGE)) | |
| { | |
| std::string fileName = fC->getFileName (id); | |
| unsigned int line = fC->Line (id); | |
| Location loc1 (symbols->registerSymbol (fileName), line, 0, symbols->registerSymbol (var_name)); | |
| Location loc2 (0, 0, 0, symbols->registerSymbol (parent->getName ())); | |
| Error err1 (errtype, loc1, loc2); | |
| errors->addError (err1); | |
| } | |
| if (!returnClassParam) | |
| { | |
| // Class parameters datatype have no definition and are strings | |
| if (result) | |
| { | |
| DataType* dtype = result->getDataType (); | |
| if (dtype && !dtype->getDefinition ()) | |
| { | |
| if (dtype->getType () == VObjectType::slStringConst) | |
| { | |
| result = NULL; | |
| } | |
| } | |
| } | |
| } | |
| return result; | |
| } | |
| Variable* | |
| ElaborationStep::locateVariable_ (std::vector<std::string>& var_chain, FileContent* fC, NodeId id, Scope* scope, DesignComponent* parentComponent, | |
| ErrorDefinition::ErrorType errtype) | |
| { | |
| Variable* the_obj = NULL; | |
| DesignComponent* currentComponent = parentComponent; | |
| for (auto var : var_chain) | |
| { | |
| if (var == "this") | |
| { | |
| } | |
| else if (var == "super") | |
| { | |
| ClassDefinition* classDefinition = dynamic_cast<ClassDefinition*> (currentComponent); | |
| if (classDefinition) | |
| { | |
| currentComponent = NULL; | |
| for (auto cc : classDefinition->getBaseClassMap ()) | |
| { | |
| currentComponent = dynamic_cast<ClassDefinition*> (cc.second); | |
| var = "this"; | |
| break; | |
| } | |
| if (currentComponent == NULL) | |
| { | |
| var = "super"; | |
| currentComponent = parentComponent; | |
| } | |
| } | |
| } | |
| the_obj = bindVariable_ (var, scope, fC, id, currentComponent, errtype, false); | |
| if (the_obj) | |
| { | |
| DataType* dtype = the_obj->getDataType (); | |
| while (dtype && dtype->getDefinition ()) | |
| { | |
| dtype = dtype->getDefinition (); | |
| } | |
| ClassDefinition* tmpClass = dynamic_cast<ClassDefinition*> (dtype); | |
| if (tmpClass) | |
| { | |
| currentComponent = tmpClass; | |
| } | |
| } | |
| } | |
| return the_obj; | |
| } | |
| Variable* ElaborationStep::locateStaticVariable_ (std::vector<std::string>& var_chain, FileContent* fC, NodeId id, Scope* scope, DesignComponent* parentComponent, | |
| ErrorDefinition::ErrorType errtype) { | |
| std::string name; | |
| for (unsigned int i = 0; i < var_chain.size(); i++) | |
| { | |
| name += var_chain[i]; | |
| if (i < var_chain.size()-1) | |
| name += "::"; | |
| } | |
| std::map<std::string, Variable*>::iterator itr = m_staticVariables.find(name); | |
| if (itr != m_staticVariables.end()) | |
| return (*itr).second; | |
| Variable* result = NULL; | |
| Design* design = m_compileDesign->getCompiler ()->getDesign (); | |
| if (var_chain.size() > 0) | |
| { | |
| Package* package = design->getPackage (var_chain[0]); | |
| if (package) | |
| { | |
| if (var_chain.size() > 1) | |
| { | |
| ClassDefinition* classDefinition = package->getClassDefinition (var_chain[1]); | |
| if (classDefinition) | |
| { | |
| if (var_chain.size () == 2) | |
| { | |
| result = new Variable (classDefinition, classDefinition->getFileContent (), classDefinition->getNodeId (), 0, classDefinition->getName ()); | |
| } | |
| if (var_chain.size () == 3) | |
| { | |
| std::vector<std::string> tmp; | |
| tmp.push_back (var_chain[2]); | |
| result = locateVariable_ (tmp, fC, id, scope, classDefinition, errtype); | |
| } | |
| } | |
| } | |
| } | |
| if (result == NULL) | |
| { | |
| ClassDefinition* classDefinition = design->getClassDefinition (var_chain[0]); | |
| if (classDefinition == NULL) | |
| { | |
| std::string name; | |
| if (parentComponent && parentComponent->getParentScope ()) | |
| { | |
| name = ((DesignComponent*)parentComponent->getParentScope ())->getName (); | |
| name += "::" + var_chain[0]; | |
| classDefinition = design->getClassDefinition (name); | |
| } | |
| } | |
| if (classDefinition) | |
| { | |
| if (var_chain.size () == 1) | |
| result = new Variable (classDefinition, classDefinition->getFileContent (), classDefinition->getNodeId (), 0, classDefinition->getName ()); | |
| if (var_chain.size () == 2) | |
| { | |
| std::vector<std::string> tmp; | |
| tmp.push_back (var_chain[1]); | |
| DataType* dtype = bindDataType_ (var_chain[1], fC, id, classDefinition, ErrorDefinition::NO_ERROR_MESSAGE); | |
| if (dtype) | |
| { | |
| result = new Variable (dtype, dtype->getFileContent (), dtype->getNodeId (), 0, dtype->getName ()); | |
| } | |
| else | |
| result = locateVariable_ (tmp, fC, id, scope, classDefinition, errtype); | |
| } | |
| } | |
| } | |
| } | |
| if (result == NULL) | |
| { | |
| if (var_chain.size ()) | |
| { | |
| DataType* dtype = bindDataType_ (var_chain[0], fC, id, parentComponent, errtype); | |
| if (dtype) | |
| { | |
| result = new Variable (dtype, dtype->getFileContent (), dtype->getNodeId (), 0, dtype->getName ()); | |
| } | |
| } | |
| } | |
| m_staticVariables.insert(std::make_pair(name, result)); | |
| return result; | |
| } | |