SVIncCompil/Library/ParseLibraryDef.cpp - third_party/Surelog - Git at Google

 /*
  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:   ParseLibraryDef.cpp
  * Author: alain
  *
  * Created on January 27, 2018, 5:05 PM
  */
 #include "../Utils/StringUtils.h"
 #include "../CommandLine/CommandLineParser.hpp"
 #include "../SourceCompile/CompilationUnit.h"
 #include "../SourceCompile/PreprocessFile.h"
 #include "../SourceCompile/CompileSourceFile.h"
 #include "../SourceCompile/Compiler.h"
 #include "../SourceCompile/ParseFile.h"
 #include "ParseLibraryDef.h"
 #include "../Utils/FileUtils.h"
 #include "antlr4-runtime.h"
 #include "atn/ParserATNSimulator.h"
 using namespace antlr4;
 using namespace SURELOG;
 #include "../parser/SV3_1aLexer.h"
 #include "../parser/SV3_1aParser.h"
 #include "SVLibShapeListener.h"
 #include "AntlrLibParserErrorListener.h"


 ParseLibraryDef::ParseLibraryDef (CommandLineParser* commandLineParser, ErrorContainer* errors, SymbolTable* symbolTable,
                                   LibrarySet* librarySet, ConfigSet* configSet) : m_fileId(0),
   m_commandLineParser(commandLineParser), m_errors(errors), m_symbolTable(symbolTable), m_librarySet(librarySet),
         m_configSet(configSet), m_fileContent(NULL) {
 }

 ParseLibraryDef::ParseLibraryDef (const ParseLibraryDef& orig) {
 }

 ParseLibraryDef::~ParseLibraryDef () {
 }

 bool ParseLibraryDef::parseLibrariesDefinition()
 {

   // Get .map files from command line
   std::vector<SymbolId> libraryMapFiles = m_commandLineParser->getLibraryMapFiles ();
   if (libraryMapFiles.empty ())
     {
       // or scan local dir
       libraryMapFiles = FileUtils::collectFiles ("./", ".map", m_symbolTable);
     }

   // If "work" library is not yet declared from command line, create it
   std::string workN = "work";
   if (m_librarySet->getLibrary (workN) == NULL)
     {
       Library work (workN, m_symbolTable);
       m_librarySet->addLibrary (work);
     }

   //Config files are parsed using the library top rule
   std::vector<SymbolId> cfgFiles = m_commandLineParser->getConfigFiles ();
   for (auto file : cfgFiles)
     {
       libraryMapFiles.push_back (file);
     }

   for (auto fileId : libraryMapFiles)
     {
       parseLibraryDefinition(fileId);
     }

   for (auto file : cfgFiles)
     {
       std::string fullPath = FileUtils::getFullPath (m_symbolTable->getSymbol (file));
       m_librarySet->getLibrary (m_symbolTable->registerSymbol (fullPath)); // Register configuration files in "work" library
     }

   unsigned int size = m_commandLineParser->getSourceFiles ().size ();
   for (unsigned int i = 0; i < size; i++)
     {
       SymbolId id = m_commandLineParser->getSourceFiles ()[i];
       std::string fullPath = FileUtils::getFullPath (m_symbolTable->getSymbol (id));
       m_librarySet->getLibrary (m_symbolTable->registerSymbol (fullPath)); // Register files in "work" library
     }

   m_librarySet->checkErrors (m_symbolTable, m_errors);

    if (m_commandLineParser->getDebugLibraryDef ())
      {
        std::cout << m_librarySet->report (m_symbolTable) << std::endl;
      }
   return true;
 }

 bool ParseLibraryDef::parseLibraryDefinition(SymbolId fileId, Library* lib)
 {
   m_fileId = fileId;
   std::string fileName = m_symbolTable->getSymbol (fileId);
   std::string relativePath = FileUtils::getPathName (fileName);
   std::ifstream stream;
   stream.open (fileName);

   if (!stream.good ())
     {
       Location ppfile (fileId);
       Error err (ErrorDefinition::PA_CANNOT_OPEN_FILE, ppfile);
       m_errors->addError (err);
       return false;
     }

   Location ppfile (fileId);
   Error err (ErrorDefinition::PP_PROCESSING_SOURCE_FILE, ppfile);
   m_errors->addError (err);
   m_errors->printMessage (err, m_commandLineParser->muteStdout ());

   AntlrLibParserErrorListener* errorListener = new AntlrLibParserErrorListener (this);
   antlr4::ANTLRInputStream* m_inputStream = new ANTLRInputStream (stream);
   SV3_1aLexer* m_lexer = new SV3_1aLexer (m_inputStream);
   m_lexer->removeErrorListeners ();
   m_lexer->addErrorListener (errorListener);
   antlr4::CommonTokenStream* m_tokens = new CommonTokenStream (m_lexer);
   m_tokens->fill ();
   SV3_1aParser* m_parser = new SV3_1aParser (m_tokens);
   m_parser->removeErrorListeners ();
   m_parser->addErrorListener (errorListener);
   antlr4::tree::ParseTree* m_tree = m_parser->top_level_library_rule ();

   SVLibShapeListener* m_listener = new SVLibShapeListener (this, m_tokens, relativePath);
   tree::ParseTreeWalker::DEFAULT.walk (m_listener, m_tree);
   m_fileContent = m_listener->getFileContent();

   if (m_fileContent->getLibrary () == NULL)
     {
       if (lib)
         {
           m_fileContent->setLibrary(lib);
         }
       else
         {
           std::string fullPath = FileUtils::getFullPath (m_symbolTable->getSymbol (m_fileId));
           m_fileContent->setLibrary (m_librarySet->getLibrary (m_symbolTable->registerSymbol (fullPath)));
         }
     }

   if (m_commandLineParser->getDebugAstModel ())
     {
       std::cout << m_fileContent->printObjects ();
     }

   //delete m_tree;
   delete m_parser;
   delete m_tokens;
   delete m_lexer;
   delete m_inputStream;
   delete m_listener;
   return parseConfigDefinition();
 }

 bool
 ParseLibraryDef::parseConfigDefinition ()
 {
   FileContent* fC = m_fileContent;
   if (!fC)
     return false;

   std::vector<VObjectType> types = {VObjectType::slConfig_declaration};
   std::vector<NodeId> configs = fC->sl_collect_all (0, types);
   for (auto config : configs)
     {
       NodeId ident = fC->Child (config);
       std::string name = fC->getLibrary ()->getName () + "@" + fC->SymName (ident);
       m_symbolTable->registerSymbol (name);
       Config conf (name, fC, config);

       // Design clause
       std::vector<VObjectType> designStmt = {VObjectType::slDesign_statement};
       std::vector<NodeId> designs = fC->sl_collect_all (config, designStmt);
       if (designs.size () == 0)
         {
           // TODO: Error
         }
       else if (designs.size () > 1)
         {
           // TODO: Error
         }
       else
         {
           NodeId design = designs[0];
           NodeId libName = fC->Child (design);
           NodeId topName = fC->Sibling (libName);
           if (topName == 0)
             {
               conf.setDesignLib (fC->getLibrary ()->getName ());
               conf.setDesignTop (fC->SymName (libName));
             }
           else
             {
               conf.setDesignLib (fC->SymName (libName));
               conf.setDesignTop (fC->SymName (topName));
             }
         }

       // Default clause
       std::vector<VObjectType> defaultStmt = {VObjectType::slDefault_clause};
       std::vector<NodeId> defaults = fC->sl_collect_all (config, defaultStmt);
       if (defaults.size () > 0)
         {
           NodeId defaultClause = defaults[0];
           NodeId libList = fC->Sibling (defaultClause);
           if (fC->Type (libList) == VObjectType::slLiblist_clause)
             {
               NodeId lib = fC->Child (libList);
               while (lib)
                 {
                   conf.addDefaultLib (fC->SymName (lib));
                   lib = fC->Sibling (lib);
                 }
             }
         }

       // Instance and Cell clauses
       std::vector<VObjectType> instanceStmt = {VObjectType::slInst_clause,
         VObjectType::slCell_clause};
       std::vector<NodeId> instances = fC->sl_collect_all (config, instanceStmt);
       for (auto inst : instances)
         {
           VObjectType type = fC->Type (inst);
           NodeId instName = fC->Child (inst);
           if (type == slInst_clause)
             instName = fC->Child (instName);
           std::string instNameS;
           while (instName)
             {
               if (instNameS == "")
                 instNameS = fC->SymName (instName);
               else
                 instNameS += "." + fC->SymName (instName);
               instName = fC->Sibling (instName);
             }
           NodeId instClause = fC->Sibling (inst);
           if (fC->Type (instClause) == VObjectType::slLiblist_clause)
             {
               NodeId libList = fC->Child (instClause);
               std::vector<std::string> libs;
               while (libList)
                 {
                   libs.push_back(fC->SymName (libList));
                   libList = fC->Sibling(libList);
                 }

               UseClause usec (UseClause::UseLib, libs, fC, instClause);
               if (type == slInst_clause)
                 conf.addInstanceUseClause (instNameS, usec);
               else
                 conf.addCellUseClause (instNameS, usec);
             }
           else if (fC->Type (instClause) == VObjectType::slUse_clause)
             {
               NodeId use = fC->Child (instClause);
               std::string useName;
               VObjectType useType = fC->Type (use);
               if (useType == slParameter_value_assignment)
                 {
                   UseClause usec (UseClause::UseParam, fC, use);
                   conf.addInstanceUseClause (instNameS, usec);
                 }
               else
                 {
                   NodeId mem = use;
                   while (use)
                     {
                       if (useName == "")
                         useName = fC->SymName (use);
                       else
                         useName += "." + fC->SymName (use);
                       use = fC->Sibling (use);
                     }
                   useName = StringUtils::replaceAll (useName, ".", "@");
                   UseClause usec (UseClause::UseModule, useName, fC, mem);
                   if (type == slInst_clause)
                     conf.addInstanceUseClause (instNameS, usec);
                   else
                     conf.addCellUseClause (instNameS, usec);
                 }
             }
           else if (fC->Type (instClause) == VObjectType::slUse_clause_config)
             {
               NodeId use = fC->Child (instClause);
               std::string useName;
               NodeId mem = use;
               while (use)
                 {
                   if (useName == "")
                     useName = fC->SymName (use);
                   else
                     useName += "@" + fC->SymName (use);
                   use = fC->Sibling (use);
                 }
               UseClause usec (UseClause::UseConfig, useName, fC, mem);
               if (type == slInst_clause)
                 conf.addInstanceUseClause (instNameS, usec);
               else
                 conf.addCellUseClause (instNameS, usec);

             }
         }


       m_configSet->addConfig (conf);
     }

   return true;
 }
	/*
	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: ParseLibraryDef.cpp
	* Author: alain
	*
	* Created on January 27, 2018, 5:05 PM
	*/
	#include "../Utils/StringUtils.h"
	#include "../CommandLine/CommandLineParser.hpp"
	#include "../SourceCompile/CompilationUnit.h"
	#include "../SourceCompile/PreprocessFile.h"
	#include "../SourceCompile/CompileSourceFile.h"
	#include "../SourceCompile/Compiler.h"
	#include "../SourceCompile/ParseFile.h"
	#include "ParseLibraryDef.h"
	#include "../Utils/FileUtils.h"
	#include "antlr4-runtime.h"
	#include "atn/ParserATNSimulator.h"
	using namespace antlr4;
	using namespace SURELOG;
	#include "../parser/SV3_1aLexer.h"
	#include "../parser/SV3_1aParser.h"
	#include "SVLibShapeListener.h"
	#include "AntlrLibParserErrorListener.h"


	ParseLibraryDef::ParseLibraryDef (CommandLineParser* commandLineParser, ErrorContainer* errors, SymbolTable* symbolTable,
	LibrarySet* librarySet, ConfigSet* configSet) : m_fileId(0),
	m_commandLineParser(commandLineParser), m_errors(errors), m_symbolTable(symbolTable), m_librarySet(librarySet),
	m_configSet(configSet), m_fileContent(NULL) {
	}

	ParseLibraryDef::ParseLibraryDef (const ParseLibraryDef& orig) {
	}

	ParseLibraryDef::~ParseLibraryDef () {
	}

	bool ParseLibraryDef::parseLibrariesDefinition()
	{

	// Get .map files from command line
	std::vector<SymbolId> libraryMapFiles = m_commandLineParser->getLibraryMapFiles ();
	if (libraryMapFiles.empty ())
	{
	// or scan local dir
	libraryMapFiles = FileUtils::collectFiles ("./", ".map", m_symbolTable);
	}

	// If "work" library is not yet declared from command line, create it
	std::string workN = "work";
	if (m_librarySet->getLibrary (workN) == NULL)
	{
	Library work (workN, m_symbolTable);
	m_librarySet->addLibrary (work);
	}

	//Config files are parsed using the library top rule
	std::vector<SymbolId> cfgFiles = m_commandLineParser->getConfigFiles ();
	for (auto file : cfgFiles)
	{
	libraryMapFiles.push_back (file);
	}

	for (auto fileId : libraryMapFiles)
	{
	parseLibraryDefinition(fileId);
	}

	for (auto file : cfgFiles)
	{
	std::string fullPath = FileUtils::getFullPath (m_symbolTable->getSymbol (file));
	m_librarySet->getLibrary (m_symbolTable->registerSymbol (fullPath)); // Register configuration files in "work" library
	}

	unsigned int size = m_commandLineParser->getSourceFiles ().size ();
	for (unsigned int i = 0; i < size; i++)
	{
	SymbolId id = m_commandLineParser->getSourceFiles ()[i];
	std::string fullPath = FileUtils::getFullPath (m_symbolTable->getSymbol (id));
	m_librarySet->getLibrary (m_symbolTable->registerSymbol (fullPath)); // Register files in "work" library
	}

	m_librarySet->checkErrors (m_symbolTable, m_errors);

	if (m_commandLineParser->getDebugLibraryDef ())
	{
	std::cout << m_librarySet->report (m_symbolTable) << std::endl;
	}
	return true;
	}

	bool ParseLibraryDef::parseLibraryDefinition(SymbolId fileId, Library* lib)
	{
	m_fileId = fileId;
	std::string fileName = m_symbolTable->getSymbol (fileId);
	std::string relativePath = FileUtils::getPathName (fileName);
	std::ifstream stream;
	stream.open (fileName);

	if (!stream.good ())
	{
	Location ppfile (fileId);
	Error err (ErrorDefinition::PA_CANNOT_OPEN_FILE, ppfile);
	m_errors->addError (err);
	return false;
	}

	Location ppfile (fileId);
	Error err (ErrorDefinition::PP_PROCESSING_SOURCE_FILE, ppfile);
	m_errors->addError (err);
	m_errors->printMessage (err, m_commandLineParser->muteStdout ());

	AntlrLibParserErrorListener* errorListener = new AntlrLibParserErrorListener (this);
	antlr4::ANTLRInputStream* m_inputStream = new ANTLRInputStream (stream);
	SV3_1aLexer* m_lexer = new SV3_1aLexer (m_inputStream);
	m_lexer->removeErrorListeners ();
	m_lexer->addErrorListener (errorListener);
	antlr4::CommonTokenStream* m_tokens = new CommonTokenStream (m_lexer);
	m_tokens->fill ();
	SV3_1aParser* m_parser = new SV3_1aParser (m_tokens);
	m_parser->removeErrorListeners ();
	m_parser->addErrorListener (errorListener);
	antlr4::tree::ParseTree* m_tree = m_parser->top_level_library_rule ();

	SVLibShapeListener* m_listener = new SVLibShapeListener (this, m_tokens, relativePath);
	tree::ParseTreeWalker::DEFAULT.walk (m_listener, m_tree);
	m_fileContent = m_listener->getFileContent();

	if (m_fileContent->getLibrary () == NULL)
	{
	if (lib)
	{
	m_fileContent->setLibrary(lib);
	}
	else
	{
	std::string fullPath = FileUtils::getFullPath (m_symbolTable->getSymbol (m_fileId));
	m_fileContent->setLibrary (m_librarySet->getLibrary (m_symbolTable->registerSymbol (fullPath)));
	}
	}

	if (m_commandLineParser->getDebugAstModel ())
	{
	std::cout << m_fileContent->printObjects ();
	}

	//delete m_tree;
	delete m_parser;
	delete m_tokens;
	delete m_lexer;
	delete m_inputStream;
	delete m_listener;
	return parseConfigDefinition();
	}

	bool
	ParseLibraryDef::parseConfigDefinition ()
	{
	FileContent* fC = m_fileContent;
	if (!fC)
	return false;

	std::vector<VObjectType> types = {VObjectType::slConfig_declaration};
	std::vector<NodeId> configs = fC->sl_collect_all (0, types);
	for (auto config : configs)
	{
	NodeId ident = fC->Child (config);
	std::string name = fC->getLibrary ()->getName () + "@" + fC->SymName (ident);
	m_symbolTable->registerSymbol (name);
	Config conf (name, fC, config);

	// Design clause
	std::vector<VObjectType> designStmt = {VObjectType::slDesign_statement};
	std::vector<NodeId> designs = fC->sl_collect_all (config, designStmt);
	if (designs.size () == 0)
	{
	// TODO: Error
	}
	else if (designs.size () > 1)
	{
	// TODO: Error
	}
	else
	{
	NodeId design = designs[0];
	NodeId libName = fC->Child (design);
	NodeId topName = fC->Sibling (libName);
	if (topName == 0)
	{
	conf.setDesignLib (fC->getLibrary ()->getName ());
	conf.setDesignTop (fC->SymName (libName));
	}
	else
	{
	conf.setDesignLib (fC->SymName (libName));
	conf.setDesignTop (fC->SymName (topName));
	}
	}

	// Default clause
	std::vector<VObjectType> defaultStmt = {VObjectType::slDefault_clause};
	std::vector<NodeId> defaults = fC->sl_collect_all (config, defaultStmt);
	if (defaults.size () > 0)
	{
	NodeId defaultClause = defaults[0];
	NodeId libList = fC->Sibling (defaultClause);
	if (fC->Type (libList) == VObjectType::slLiblist_clause)
	{
	NodeId lib = fC->Child (libList);
	while (lib)
	{
	conf.addDefaultLib (fC->SymName (lib));
	lib = fC->Sibling (lib);
	}
	}
	}

	// Instance and Cell clauses
	std::vector<VObjectType> instanceStmt = {VObjectType::slInst_clause,
	VObjectType::slCell_clause};
	std::vector<NodeId> instances = fC->sl_collect_all (config, instanceStmt);
	for (auto inst : instances)
	{
	VObjectType type = fC->Type (inst);
	NodeId instName = fC->Child (inst);
	if (type == slInst_clause)
	instName = fC->Child (instName);
	std::string instNameS;
	while (instName)
	{
	if (instNameS == "")
	instNameS = fC->SymName (instName);
	else
	instNameS += "." + fC->SymName (instName);
	instName = fC->Sibling (instName);
	}
	NodeId instClause = fC->Sibling (inst);
	if (fC->Type (instClause) == VObjectType::slLiblist_clause)
	{
	NodeId libList = fC->Child (instClause);
	std::vector<std::string> libs;
	while (libList)
	{
	libs.push_back(fC->SymName (libList));
	libList = fC->Sibling(libList);
	}

	UseClause usec (UseClause::UseLib, libs, fC, instClause);
	if (type == slInst_clause)
	conf.addInstanceUseClause (instNameS, usec);
	else
	conf.addCellUseClause (instNameS, usec);
	}
	else if (fC->Type (instClause) == VObjectType::slUse_clause)
	{
	NodeId use = fC->Child (instClause);
	std::string useName;
	VObjectType useType = fC->Type (use);
	if (useType == slParameter_value_assignment)
	{
	UseClause usec (UseClause::UseParam, fC, use);
	conf.addInstanceUseClause (instNameS, usec);
	}
	else
	{
	NodeId mem = use;
	while (use)
	{
	if (useName == "")
	useName = fC->SymName (use);
	else
	useName += "." + fC->SymName (use);
	use = fC->Sibling (use);
	}
	useName = StringUtils::replaceAll (useName, ".", "@");
	UseClause usec (UseClause::UseModule, useName, fC, mem);
	if (type == slInst_clause)
	conf.addInstanceUseClause (instNameS, usec);
	else
	conf.addCellUseClause (instNameS, usec);
	}
	}
	else if (fC->Type (instClause) == VObjectType::slUse_clause_config)
	{
	NodeId use = fC->Child (instClause);
	std::string useName;
	NodeId mem = use;
	while (use)
	{
	if (useName == "")
	useName = fC->SymName (use);
	else
	useName += "@" + fC->SymName (use);
	use = fC->Sibling (use);
	}
	UseClause usec (UseClause::UseConfig, useName, fC, mem);
	if (type == slInst_clause)
	conf.addInstanceUseClause (instNameS, usec);
	else
	conf.addCellUseClause (instNameS, usec);

	}
	}


	m_configSet->addConfig (conf);
	}

	return true;
	}