#include <ProGeScriptGenerator.hh>

Collaboration diagram for ProGeScriptGenerator:

Public Member Functions
	ProGeScriptGenerator (const ProGe::HDL language, const IDF::MachineImplementation &idf, const std::string &dstDir, const std::string &progeOutDir, const std::string &sharedOutDir, const std::string &testBenchDir, const std::string &toplevelEntity, const std::string &simulationRuntime="52390")

virtual	~ProGeScriptGenerator ()

void	generateAll ()

void	generateModsimCompile ()

void	generateGhdlCompile ()

void	generateIverilogCompile ()

void	generateModsimSimulate ()

void	generateGhdlSimulate ()

void	generateIverilogSimulate ()

Private Member Functions
void	generateCompileStart (std::ostream &stream)

void	generateSimulationStart (std::ostream &stream)

void	createExecutableFile (const std::string &fileName)

void	outputScriptCommands (std::ostream &stream, const std::list< std::string > &files, const std::string &cmdPrefix, const std::string &cmdPostfix)

void	outputScriptCommand (std::ostream &stream, const std::string &file, const std::string &cmdPrefix, const std::string &cmdPostfix)

template<typename T >
void	findFiles (const std::string &perlre, T files, std::list< std::string > &found)

template<typename T >
void	findFiles (const std::string &perlre, T &files)

void	findText (const std::string &perlre, const unsigned int &matchRegion, const std::string &fileName, std::list< std::string > &found)

void	getBlockOrder (std::list< std::string > &order)

void	sortFilesFirst (std::list< std::string > &toSort, std::list< std::string > &acSort)

void	sortFilesLast (std::list< std::string > &toSort, std::list< std::string > &acSort)

template<typename CONT >
void	uniqueFileNames (CONT &files, const std::string &rootDirectory)

void	prefixStrings (std::list< std::string > &tlist, const std::string &prefix, int start=0, int end=-1)

void	fetchFiles ()

void	packageFilesFirst ()

void	prepareFiles ()

Private Attributes
std::string	dstDir_

std::string	progeOutDir_

std::string	sharedOutDir_

std::string	testBenchDir_

std::list< std::string >	vhdlFiles_

std::list< std::string >	gcuicFiles_

std::list< std::string >	testBenchFiles_

const std::string	workDir_

const std::string	vhdlDir_

const std::string	verDir_

const std::string	gcuicDir_

const std::string	tbDir_

const std::string	modsimCompileScriptName_

const std::string	ghdlCompileScriptName_

const std::string	iverilogCompileScriptName_

const std::string	modsimSimulateScriptName_

const std::string	ghdlSimulateScriptName_

const std::string	iverilogSimulateScriptName_

const std::string	testbenchName_

const std::string	toplevelEntity_

const IDF::MachineImplementation &	idf_

const ProGe::HDL	language_

const std::string	simulationRuntime_

Detailed Description

Class for script generating objects.

Base class for script generating. simulationRuntime defaults to 52390ns, can be changed in generateprocessor with a command line parameter, but not in ProDe yet. TODO.

Definition at line 52 of file ProGeScriptGenerator.hh.

Constructor & Destructor Documentation

◆ ProGeScriptGenerator()

ProGeScriptGenerator::ProGeScriptGenerator	(	const ProGe::HDL	language,
		const IDF::MachineImplementation &	idf,
		const std::string &	dstDir,
		const std::string &	progeOutDir,
		const std::string &	sharedOutDir,
		const std::string &	testBenchDir,
		const std::string &	toplevelEntity = `"tta0"`,
		const std::string &	simulationRuntime = `"52390"`
	)

The constructor.

Script generating needs a IDF file and hdb files mentioned there. Working directory is assumed to be the destination directory for script files.

Parameters

dstDir	Directory where to generate scripts.
progeOutDir	Directory where ProGes output vhdl files lie.
testBenchDir	Directory where a test bench files are located.
projectRoot	Directory that is project root, needed if relative dirs wanted to generated scripts. Useful if other dirs given are under this directory.

Definition at line 86 of file ProGeScriptGenerator.cc.

                                         :
     dstDir_(dstDir), 
     progeOutDir_(progeOutDir),
     sharedOutDir_(sharedOutDir),
     testBenchDir_(testBenchDir),
     workDir_("work"),
     vhdlDir_("vhdl"),
     verDir_("verilog"),
     gcuicDir_("gcu_ic"),
     tbDir_("tb"),
     modsimCompileScriptName_("modsim_compile.sh"),
     ghdlCompileScriptName_("ghdl_compile.sh"),
     iverilogCompileScriptName_("iverilog_compile.sh"),
     modsimSimulateScriptName_("modsim_simulate.sh"),
     ghdlSimulateScriptName_("ghdl_simulate.sh"),
     iverilogSimulateScriptName_("iverilog_simulate.sh"),
     testbenchName_("testbench"),
     toplevelEntity_(toplevelEntity),
     idf_(idf),
     language_(language),
     simulationRuntime_(simulationRuntime){
  
     fetchFiles();
     packageFilesFirst();
     prepareFiles();
 }

References fetchFiles(), packageFilesFirst(), and prepareFiles().

Here is the call graph for this function:

◆ ~ProGeScriptGenerator()

ProGeScriptGenerator::~ProGeScriptGenerator ( )

virtual

The destructor.

Definition at line 125 of file ProGeScriptGenerator.cc.

                                             {
  
 }

Member Function Documentation

◆ createExecutableFile()

void ProGeScriptGenerator::createExecutableFile ( const std::string & fileName )

private

Creates a script file given as parameter and sets permissions.

Parameters

Name	of the script file to be created

Exceptions

IOException

Definition at line 403 of file ProGeScriptGenerator.cc.

                                                                     {
     FileSystem::removeFileOrDirectory(fileName);
     bool isCreated = FileSystem::createFile(fileName);
     if (!isCreated) {
         string errorMsg = "Unable to create file " + fileName;
         throw IOException(__FILE__, __LINE__, __func__, errorMsg);
     }
     FileSystem::setFileExecutable(fileName);
 }

References __func__, FileSystem::createFile(), FileSystem::removeFileOrDirectory(), and FileSystem::setFileExecutable().

Referenced by generateGhdlCompile(), generateGhdlSimulate(), generateIverilogCompile(), generateIverilogSimulate(), generateModsimCompile(), and generateModsimSimulate().

Here is the call graph for this function:

◆ fetchFiles()

void ProGeScriptGenerator::fetchFiles ( )

private

Gets file names from project directory.

Definition at line 716 of file ProGeScriptGenerator.cc.

                                  {
     
     // files that match are accepted
     string vhdlRegex =
     ((language_==VHDL)?".*\\.(vhd|vhdl|pkg)$":".*\\.(v)$");
  
     // generate relative paths
     bool absolutePaths = false;
     
     // getting files from project dir
     string dirName = progeOutDir_ + FileSystem::DIRECTORY_SEPARATOR 
         + ((language_==VHDL)?vhdlDir_:verDir_);
     if (FileSystem::fileIsDirectory(dirName)) {
         findFiles(vhdlRegex, 
             FileSystem::directoryContents(dirName, absolutePaths),
             vhdlFiles_);
         // add the toplevelEntity + _imem_mau_pkg.vhdl to vhdlFiles_.
         // It is generated by PIG so it is not yet present.
         if(language_==VHDL){
             string imemMauPkg = dirName + FileSystem::DIRECTORY_SEPARATOR
                 + toplevelEntity_ + "_imem_mau_pkg.vhdl";
             vhdlFiles_.push_back(imemMauPkg);
         }
     }
     std::string sharedDir = 
         sharedOutDir_ + FileSystem::DIRECTORY_SEPARATOR +
         ((language_==VHDL)?vhdlDir_:verDir_);
         
     if (sharedDir != FileSystem::absolutePathOf(dirName)
         && FileSystem::fileIsDirectory(sharedDir)) {
         findFiles(
             vhdlRegex, 
             FileSystem::directoryContents(sharedDir, absolutePaths),
             vhdlFiles_);
     }    
  
     dirName = progeOutDir_ + FileSystem::DIRECTORY_SEPARATOR + gcuicDir_;
     if (FileSystem::fileIsDirectory(dirName)) {
         findFiles(vhdlRegex, 
             FileSystem::directoryContents(dirName, absolutePaths),
             gcuicFiles_);
     }
  
     if (FileSystem::fileIsDirectory(testBenchDir_)) {
         FileSystem::findFromDirectoryRecursive(vhdlRegex, testBenchDir_,
             testBenchFiles_);
     } else {
         findFiles(vhdlRegex, 
             FileSystem::directoryContents(dstDir_, absolutePaths),
             testBenchFiles_);
     }
 }

References FileSystem::absolutePathOf(), FileSystem::DIRECTORY_SEPARATOR, FileSystem::directoryContents(), dstDir_, FileSystem::fileIsDirectory(), findFiles(), FileSystem::findFromDirectoryRecursive(), gcuicDir_, gcuicFiles_, language_, progeOutDir_, sharedOutDir_, testBenchDir_, testBenchFiles_, toplevelEntity_, verDir_, ProGe::VHDL, vhdlDir_, and vhdlFiles_.

Referenced by ProGeScriptGenerator().

Here is the call graph for this function:

◆ findFiles() [1/2]

template<typename T >

void ProGeScriptGenerator::findFiles	(	const std::string &	perlre,
		T &	files
	)

private

◆ findFiles() [2/2]

template<typename T >

void ProGeScriptGenerator::findFiles	(	const std::string &	perlre,
		T	files,
		std::list< std::string > &	found
	)

private

Referenced by fetchFiles().

◆ findText()

void ProGeScriptGenerator::findText	(	const std::string &	perlre,
		const unsigned int &	matchRegion,
		const std::string &	fileName,
		std::list< std::string > &	found
	)

private

Regex find from a file.

Finds text matching the given regex from file by line at a time. Case is ignored when interpreting the regex.

Parameters

perlre	Perl syntax regular expression.
matchRegion	Region from the match appended to output list.
fileName	Name and path of file name to be opened and read.
found	List where matches are appended.

Definition at line 515 of file ProGeScriptGenerator.cc.

                                {
  
     const int LINESIZE = 1000;
     
     const boost::regex re(perlre, 
             boost::regex::perl|boost::regex::icase);
     
     char line[LINESIZE];
     string::const_iterator begin;
     string::const_iterator end;
     string stemp;
     std::ifstream ifs( fileName.c_str() , std::ifstream::in );
     boost::match_results<string::const_iterator> matches;
     while (ifs.good()) {
  
         ifs.getline(line, LINESIZE-1);
         stemp = string(line);
  
         begin = stemp.begin();
         end = stemp.end();
  
         if (boost::regex_search(begin, end, matches, re)) {
             found.push_back(string(matches[matchRegion].first, 
                 matches[matchRegion].second));
         }
     }
     ifs.close();
 }

◆ generateAll()

void ProGeScriptGenerator::generateAll ( )

Generates all scripts to destination dir (dstDir_).

Exceptions

IOException

Definition at line 136 of file ProGeScriptGenerator.cc.

                                   {
     generateModsimCompile();
     
     if(language_==VHDL)
         generateGhdlCompile();
     else
         generateIverilogCompile();
  
     generateModsimSimulate();
     
     if(language_==VHDL)
         generateGhdlSimulate();
     else
         generateIverilogSimulate();
 }

References generateGhdlCompile(), generateGhdlSimulate(), generateIverilogCompile(), generateIverilogSimulate(), generateModsimCompile(), generateModsimSimulate(), language_, and ProGe::VHDL.

Referenced by ProGe::ProGeUI::generateScripts().

Here is the call graph for this function:

◆ generateCompileStart()

void ProGeScriptGenerator::generateCompileStart ( std::ostream & stream )

private

Generates the start of the shell script for compilation script.

Parameters

stream Stream where output is put.

Definition at line 419 of file ProGeScriptGenerator.cc.

                                                              {
     stream << "#!/bin/bash" << endl;
     stream << "# This script was automatically generated." << endl << endl;
  
     // Copy common compile start from template
     static const string separator(FileSystem::DIRECTORY_SEPARATOR);
     const string scriptTmpl = Environment::dataDirPath("ProGe") +
         separator + "tb" + separator + "compile.sh.tmpl";
  
     std::ifstream scriptTmplIn(scriptTmpl.c_str());
     stream << scriptTmplIn.rdbuf();
 }

References Environment::dataDirPath(), and FileSystem::DIRECTORY_SEPARATOR.

Referenced by generateGhdlCompile(), generateIverilogCompile(), and generateModsimCompile().

Here is the call graph for this function:

◆ generateGhdlCompile()

void ProGeScriptGenerator::generateGhdlCompile ( )

Generates a script for compilation using ghdl.

Exceptions

IOException

Definition at line 226 of file ProGeScriptGenerator.cc.

                                           {
     string dstFile = dstDir_ + FileSystem::DIRECTORY_SEPARATOR +
         ghdlCompileScriptName_;
  
     createExecutableFile(dstFile);
  
     std::ofstream stream(dstFile.c_str(), std::ofstream::out);
     generateCompileStart(stream);
  
     stream << "rm -rf " << workDir_ << endl;
     stream << "mkdir -p work" << endl;
     stream << "rm -rf bus.dump" << endl;
     stream << "rm -rf " << testbenchName_ << endl;
  
     stream << "if [ \"$enable_coverage\" = \"yes\" ]; then" << endl;
     stream << "    echo \"-c option is not available for ghdl.\"; exit 2;"
            << endl;
     stream << "fi" << endl;
  
     stream << endl;
     string program = "ghdl -i --workdir=" + workDir_;
     string exitOnFailure = " || exit 1";
     outputScriptCommands(stream, vhdlFiles_, program, exitOnFailure);
  
     stream << endl;
     outputScriptCommands(stream, gcuicFiles_, program, exitOnFailure);
  
     stream << endl;
     outputScriptCommands(stream, testBenchFiles_, program, exitOnFailure);
  
     stream << endl;
     // compile command for ghdl
     stream << "ghdl -m --workdir=" << workDir_ 
            << " --ieee=synopsys -fexplicit " << testbenchName_ << endl;
  
     stream << "exit 0" << endl;
     stream.close();
 }

References createExecutableFile(), FileSystem::DIRECTORY_SEPARATOR, dstDir_, gcuicFiles_, generateCompileStart(), ghdlCompileScriptName_, outputScriptCommands(), program, testBenchFiles_, testbenchName_, vhdlFiles_, and workDir_.

Referenced by generateAll().

Here is the call graph for this function:

◆ generateGhdlSimulate()

void ProGeScriptGenerator::generateGhdlSimulate ( )

Generates a script for simulating using ghdl.

Exceptions

IOException

Definition at line 344 of file ProGeScriptGenerator.cc.

                                            {
     string dstFile = dstDir_ + FileSystem::DIRECTORY_SEPARATOR +
         ghdlSimulateScriptName_;
     createExecutableFile(dstFile);
  
     std::ofstream stream(dstFile.c_str(), std::ofstream::out);
     generateSimulationStart(stream);
  
     stream << "if [ \"$enable_coverage\" = \"yes\" ]; then" << endl;
     stream << "    echo \"-c option is not available for ghdl.\"; exit 2;"
            << endl;
     stream << "fi" << endl;
     stream << "if [ -e " << testbenchName_ << " ]; then" << endl
            << "    ./" << testbenchName_
            << " --stop-time=${runtime}ns" << endl
            << "else" << endl
            << "    # Newer GHDL versions does not produce binary." << endl
            << "    ghdl -r --workdir=work --ieee=synopsys " << testbenchName_
            << "  --stop-time=${runtime}ns --ieee-asserts=disable-at-0" << endl
            << "fi" << endl;
  
     stream.close();
 }

References createExecutableFile(), FileSystem::DIRECTORY_SEPARATOR, dstDir_, generateSimulationStart(), ghdlSimulateScriptName_, and testbenchName_.

Referenced by generateAll().

Here is the call graph for this function:

◆ generateIverilogCompile()

void ProGeScriptGenerator::generateIverilogCompile ( )

Generates a script for compilation using iVerilog.

Exceptions

IOException

Definition at line 271 of file ProGeScriptGenerator.cc.

                                               {
     string dstFile = dstDir_ + FileSystem::DIRECTORY_SEPARATOR +
         iverilogCompileScriptName_;
  
     createExecutableFile(dstFile);
  
     std::ofstream stream(dstFile.c_str(), std::ofstream::out);
     generateCompileStart(stream);
  
     stream << "if [ \"$enable_coverage\" = \"yes\" ]; then" << endl;
     stream << "    echo \"-c option is not available for iverilog.\"; exit 2;"
            << endl;
     stream << "fi" << endl;
  
     stream << "rm -rf " << testbenchName_ << endl
            << endl
            << "iverilog -g2001 -D _IVERILOG_ "
            << "-D SIMTIME=" << simulationRuntime_ << " "
            << "-Itb -Iverilog -Igcu_ic ";
     outputScriptCommands(stream, vhdlFiles_, ""," \\");
     outputScriptCommands(stream, gcuicFiles_, ""," \\");
     outputScriptCommands(stream, testBenchFiles_, ""," \\");
  
     stream << "-s " << testbenchName_ << " \\" << endl;
     stream << "-o " << testbenchName_ << endl;
     stream.close();
 }

References createExecutableFile(), FileSystem::DIRECTORY_SEPARATOR, dstDir_, gcuicFiles_, generateCompileStart(), iverilogCompileScriptName_, outputScriptCommands(), simulationRuntime_, testBenchFiles_, testbenchName_, and vhdlFiles_.

Referenced by generateAll().

Here is the call graph for this function:

◆ generateIverilogSimulate()

void ProGeScriptGenerator::generateIverilogSimulate ( )

Generates a script for simulating using iVerilog.

Exceptions

IOException

Definition at line 374 of file ProGeScriptGenerator.cc.

                                                {
     string dstFile = dstDir_ + FileSystem::DIRECTORY_SEPARATOR +
         iverilogSimulateScriptName_;
  
     createExecutableFile(dstFile);
  
     std::ofstream stream(dstFile.c_str(), std::ofstream::out);
     generateSimulationStart(stream);
  
     stream << "if [ \"$enable_coverage\" = \"yes\" ]; then" << endl;
     stream << "    echo \"-c option is not available for iverilog.\"; exit 2;"
            << endl;
     stream << "fi" << endl;
  
     stream << "./" << testbenchName_ 
            << " --assert-level=none --stop-time="
            << "${runtime}" << "ns"
            << endl;
  
     stream.close();
 }

References createExecutableFile(), FileSystem::DIRECTORY_SEPARATOR, dstDir_, generateSimulationStart(), iverilogSimulateScriptName_, and testbenchName_.

Referenced by generateAll().

Here is the call graph for this function:

◆ generateModsimCompile()

void ProGeScriptGenerator::generateModsimCompile ( )

Generates a script for compilation using modelsim.

Exceptions

IOException

Definition at line 158 of file ProGeScriptGenerator.cc.

                                             {
     string dstFile = dstDir_ + FileSystem::DIRECTORY_SEPARATOR +
         modsimCompileScriptName_;
     const string coverageOpt = "+cover=sbcet";
  
     createExecutableFile(dstFile);
  
     std::ofstream stream(dstFile.c_str(), std::ofstream::out);
     generateCompileStart(stream);
  
     stream << "rm -rf " << workDir_ << endl;
     stream << "vlib " << workDir_ << endl;
     stream << "vmap"  << endl;
  
     stream << "if [ \"$enable_coverage\" = \"yes\" ]; then" << endl;
     stream << "    coverage_opt=\"" << coverageOpt << "\"" << endl;
     stream << "fi" << endl;
  
     stream << endl;
     string coverageOptAssign = " $coverage_opt";
     string program =
     ((language_==VHDL)?
         "vcom": "vlog +define+SIMTIME=" + simulationRuntime_ +
         " +incdir+verilog +incdir+gcu_ic +incdir+tb");
     string exitOnFailure = "|| exit 1";
     string checkSynthesisFLag = (language_==VHDL)?" -check_synthesis":"";
  
     for (const std::string& file : vhdlFiles_) {
         if (file.find("_pkg.") != std::string::npos) {
             // Do not add coverage option for package files since unused
             // functions in the packages are not excluded and thus spoils
             // code coverage.
             outputScriptCommand(stream, file, program, exitOnFailure);
         } else {
             outputScriptCommand(
                 stream, file, program + coverageOptAssign + checkSynthesisFLag,
                 exitOnFailure);
         }
     }
  
     stream << endl;
     for (const std::string& file : gcuicFiles_) {
         if (file.find("_pkg.") != std::string::npos) {
             // Do not add coverage option for package files since unused
             // functions in the packages are not excluded and thus spoils
             // code coverage.
             outputScriptCommand(stream, file,
                 program + checkSynthesisFLag, exitOnFailure);
         } else {
             outputScriptCommand(
                 stream, file, program + coverageOptAssign + checkSynthesisFLag,
                 exitOnFailure);
         }
     }
  
     stream << endl;
     outputScriptCommands(stream, testBenchFiles_, program, exitOnFailure);
  
     stream << "exit 0" << endl;
     stream.close();
 }

References createExecutableFile(), FileSystem::DIRECTORY_SEPARATOR, dstDir_, gcuicFiles_, generateCompileStart(), language_, modsimCompileScriptName_, outputScriptCommand(), outputScriptCommands(), program, simulationRuntime_, testBenchFiles_, ProGe::VHDL, vhdlFiles_, and workDir_.

Referenced by generateAll().

Here is the call graph for this function:

◆ generateModsimSimulate()

void ProGeScriptGenerator::generateModsimSimulate ( )

Generates a script for simulating using modelsims vsim.

Definition at line 303 of file ProGeScriptGenerator.cc.

                                              {
     string dstFile = dstDir_ + FileSystem::DIRECTORY_SEPARATOR +
         modsimSimulateScriptName_;
  
     createExecutableFile(dstFile);
  
     std::ofstream stream(dstFile.c_str(), std::ofstream::out);
     generateSimulationStart(stream);
  
     stream << "master_coverage_db=accumulated_coverage.ucdb" << endl;
     stream << "coverage_db=cov000.ucdb" << endl;
     stream << "res_opt=\"-t $sim_res\"";
     stream << endl;
     stream << "coverage_opt=\"\"" << endl;
     stream << "if [ \"$enable_coverage\" = \"yes\" ]; then" << endl;
     stream << "    coverage_opt=\"-coverage\"" << endl;
     stream << "    do_script=\"" << "coverage save -onexit ${coverage_db}; "
            << "run ${runtime} ns; exit" << "\"" << endl;
     stream << "else" << endl;
     stream << "    do_script=\"" << "run ${runtime} ns; exit" << "\"" << endl;
     stream << "fi" << endl;
     stream << endl;
     stream << "vsim " << testbenchName_ << " $res_opt -c $coverage_opt"
            << " -do \"$do_script\"" << endl;
     stream << endl;
     stream << "# merge produced code coverage data into master database."
            << endl;
     stream << "if [ \"$enable_coverage\" = \"yes\" ]; then" << endl;
     stream << "    vcover merge $master_coverage_db "
            << "$master_coverage_db $coverage_db > /dev/null 2>&1" << endl;
     stream << "fi" << endl;
  
     stream.close();
 }

References createExecutableFile(), FileSystem::DIRECTORY_SEPARATOR, dstDir_, generateSimulationStart(), modsimSimulateScriptName_, and testbenchName_.

Referenced by generateAll().

Here is the call graph for this function:

◆ generateSimulationStart()

void ProGeScriptGenerator::generateSimulationStart ( std::ostream & stream )

private

Generates the start of the shell script for simulation script.

The script includes option parsing for simulation controls. Shell variable "runtime" holds default simulation time set by this class or user defined time by option.

Parameters

stream Stream where output is put.

Definition at line 442 of file ProGeScriptGenerator.cc.

                                                                 {
     stream << "#!/bin/bash" << endl;
     stream << "# This script was automatically generated." << endl << endl;
     stream << "DEFAULT_RUN_TIME=" << simulationRuntime_ << endl << endl;
  
     // Copy rest of the shell script start from template
     static const string separator(FileSystem::DIRECTORY_SEPARATOR);
     const string scriptTmpl = Environment::dataDirPath("ProGe") +
         separator + "tb" + separator + "simulate.sh.tmpl";
  
     std::ifstream scriptTmplIn(scriptTmpl.c_str());
     stream << scriptTmplIn.rdbuf();
 }

References Environment::dataDirPath(), FileSystem::DIRECTORY_SEPARATOR, and simulationRuntime_.

Referenced by generateGhdlSimulate(), generateIverilogSimulate(), and generateModsimSimulate().

Here is the call graph for this function:

◆ getBlockOrder()

void ProGeScriptGenerator::getBlockOrder ( std::list< std::string > & order )

private

Gets compilation order for vhdl files from IDF/HDB files.

Parameters

order List of file names is relative compilation order.

Definition at line 644 of file ProGeScriptGenerator.cc.

                                                              {
  
     std::set<string> uniqueFiles;    
  
     // FU implementation HDL files
     for (int i = 0; i < idf_.fuImplementationCount(); i++) {
         const FUImplementationLocation& fuLoc = idf_.fuImplementation(i);
         string hdbFile = fuLoc.hdbFile();
         HDB::CachedHDBManager& hdb =
             HDB::HDBRegistry::instance().hdb(hdbFile);
         HDB::FUEntry* fu = hdb.fuByEntryID(fuLoc.id());
         const HDB::FUImplementation& fuImpl = fu->implementation();
         for (int j = 0; j < fuImpl.implementationFileCount(); j++) {
             string file = FileSystem::fileOfPath(fuImpl.file(j).pathToFile());
             if (uniqueFiles.find(file) == uniqueFiles.end()) {
                 order.push_back(file);
                 uniqueFiles.insert(file);
             }
         }
     }
  
     // RF implementation HDL files
     for (int i = 0; i < idf_.rfImplementationCount(); i++) {
         const RFImplementationLocation& rfLoc = idf_.rfImplementation(i);
         string hdbFile = rfLoc.hdbFile();
         HDB::CachedHDBManager& hdb =
             HDB::HDBRegistry::instance().hdb(hdbFile);
         HDB::RFEntry* rf = hdb.rfByEntryID(rfLoc.id());
         const HDB::RFImplementation& rfImpl = rf->implementation();
         for (int j = 0; j < rfImpl.implementationFileCount(); j++) {
             string file = FileSystem::fileOfPath(rfImpl.file(j).pathToFile());
             if (uniqueFiles.find(file) == uniqueFiles.end()) {
                 order.push_back(file);
                 uniqueFiles.insert(file);
             }
         }
     }
 }

References HDB::HWBlockImplementation::file(), FileSystem::fileOfPath(), HDB::HDBManager::fuByEntryID(), IDF::MachineImplementation::fuImplementation(), IDF::MachineImplementation::fuImplementationCount(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), idf_, HDB::RFEntry::implementation(), HDB::FUEntry::implementation(), HDB::HWBlockImplementation::implementationFileCount(), HDB::HDBRegistry::instance(), HDB::BlockImplementationFile::pathToFile(), HDB::HDBManager::rfByEntryID(), IDF::MachineImplementation::rfImplementation(), and IDF::MachineImplementation::rfImplementationCount().

Referenced by prepareFiles().

Here is the call graph for this function:

◆ outputScriptCommand()

void ProGeScriptGenerator::outputScriptCommand	(	std::ostream &	stream,
		const std::string &	file,
		const std::string &	cmdPrefix,
		const std::string &	cmdPostfix
	)

private

Outputs shell command to stream.

Creates script commands using a file and command prefix and outputs them to the given stream.

Parameters

stream	Output stream.
files	List of filenames to use.
cmdPrefix	Prefix command.
cmdPostfix	Postfix command.

Definition at line 493 of file ProGeScriptGenerator.cc.

                                  {
  
     stream << cmdPrefix << " " << file << " " << cmdPostfix << endl;
 }

Referenced by generateModsimCompile(), and outputScriptCommands().

◆ outputScriptCommands()

void ProGeScriptGenerator::outputScriptCommands	(	std::ostream &	stream,
		const std::list< std::string > &	files,
		const std::string &	cmdPrefix,
		const std::string &	cmdPostfix
	)

private

Outputs shell commands to stream.

Creates script commands using list of files and command prefix and outputs them to the given stream.

Parameters

stream	Output stream.
files	List of filenames to use.
cmdPrefix	Prefix command.
cmdPostfix	Prefix command.

Definition at line 469 of file ProGeScriptGenerator.cc.

                                  {
  
     list<string>::const_iterator iter = files.begin();
     while (iter != files.end()) {
         outputScriptCommand(stream, *iter++, cmdPrefix, cmdPostfix);
     }
 }

References outputScriptCommand().

Referenced by generateGhdlCompile(), generateIverilogCompile(), and generateModsimCompile().

Here is the call graph for this function:

◆ packageFilesFirst()

void ProGeScriptGenerator::packageFilesFirst ( )

private

Reorders filename lists by arranging packages (*_pkg*) to the beginning of the lists.

Definition at line 774 of file ProGeScriptGenerator.cc.

                                         {
     auto packageComp = [](const string& str1, const string& str2) -> bool {
         bool str1IsPkg = (str1.find("_pkg") != string::npos);
         bool str2IsPkg = (str2.find("_pkg") != string::npos);
         if (str1IsPkg && !str2IsPkg) {
             return true;
         } else if (!str1IsPkg && str2IsPkg) {
             return false;
         } else {
             return str1 < str2;
         }
     };
  
     vhdlFiles_.sort(packageComp);
     gcuicFiles_.sort(packageComp);
     testBenchFiles_.sort(packageComp);
 }

References gcuicFiles_, testBenchFiles_, and vhdlFiles_.

Referenced by ProGeScriptGenerator().

◆ prefixStrings()

void ProGeScriptGenerator::prefixStrings	(	std::list< std::string > &	tlist,
		const std::string &	prefix,
		int	start = `0`,
		int	end = `-1`
	)

private

Prefixes strings in a container with a string within a range.

Parameters

tlist	Container of strings.
prefix	Prefix to be added to strings in container.
start	Starting location in a container, 0 is the first.
end	Ending location in a container, size-1 is the last.

Definition at line 693 of file ProGeScriptGenerator.cc.

              {
     
     if (end == -1 || end >= static_cast<int>(tlist.size())) {
         end = tlist.size() - 1;
     }
  
     list<string>::iterator itl = tlist.begin();
     for (int c = 0; c <= end; ++c, ++itl) {
         if (c >= start) {
             *itl = prefix + *itl; 
         }
     }
 }

Referenced by prepareFiles().

◆ prepareFiles()

void ProGeScriptGenerator::prepareFiles ( )

private

Prepares filename lists, generally sorts them.

Definition at line 796 of file ProGeScriptGenerator.cc.

                                    {
  
     const string DS = FileSystem::DIRECTORY_SEPARATOR;
     if(language_==VHDL){
         string gcuIcDirName = progeOutDir_ + DS + gcuicDir_ + DS;
         list<string> gcuicFirstOrder;
         gcuicFirstOrder.push_back("gcu_opcodes_pkg.vhdl");
         prefixStrings(gcuicFirstOrder, gcuIcDirName);
         sortFilesFirst(gcuicFiles_, gcuicFirstOrder); 
  
         list<string> gcuicLastOrder;
         gcuicLastOrder.push_back("ic.vhdl");
         prefixStrings(gcuicLastOrder, gcuIcDirName);
         sortFilesLast(gcuicFiles_, gcuicLastOrder);
  
         string vhdlDirName = progeOutDir_ + DS + vhdlDir_ + DS;
         list<string> vhdlFirstOrder;
         vhdlFirstOrder.push_back("tce_util_pkg.vhdl");
         vhdlFirstOrder.push_back(toplevelEntity_ + "_imem_mau_pkg.vhdl");
         vhdlFirstOrder.push_back(toplevelEntity_ + "_globals_pkg.vhdl");
         vhdlFirstOrder.push_back(toplevelEntity_ + "_params_pkg.vhdl");
         // add FU and RF files in correct order
         getBlockOrder(vhdlFirstOrder);
         prefixStrings(vhdlFirstOrder, vhdlDirName);
         sortFilesFirst(vhdlFiles_, vhdlFirstOrder);
         
         list<string> vhdlLastOrder;
         string toplevelFile = toplevelEntity_ + ".vhdl";
         vhdlLastOrder.push_back(toplevelFile);
         prefixStrings(vhdlLastOrder, vhdlDirName);
         sortFilesLast(vhdlFiles_, vhdlLastOrder);
         
         string tbDirName = progeOutDir_ + DS + tbDir_ + DS;
         list<string> testBenchLastOrder;
         testBenchLastOrder.push_back("testbench_cfg.vhdl");
         testBenchLastOrder.push_back("testbench.vhdl");
         testBenchLastOrder.push_back("proc_arch.vhdl");
         testBenchLastOrder.push_back("proc_ent.vhdl");
         prefixStrings(testBenchLastOrder, tbDirName);
         sortFilesLast(testBenchFiles_, testBenchLastOrder);
     } else {
     //nothing to do here
     }
     // make dirs relative to dstDir_
     list<string>::iterator itl;
     itl = vhdlFiles_.begin();
     while (itl != vhdlFiles_.end()) {
         FileSystem::relativeDir(dstDir_, *itl++);
     }
     itl = gcuicFiles_.begin();
     while (itl != gcuicFiles_.end()) {
         FileSystem::relativeDir(dstDir_, *itl++);
     }
     itl = testBenchFiles_.begin();
     while (itl != testBenchFiles_.end()) {
         FileSystem::relativeDir(dstDir_, *itl++);
     }
 }

References FileSystem::DIRECTORY_SEPARATOR, DS, dstDir_, gcuicDir_, gcuicFiles_, getBlockOrder(), language_, prefixStrings(), progeOutDir_, FileSystem::relativeDir(), sortFilesFirst(), sortFilesLast(), tbDir_, testBenchFiles_, toplevelEntity_, ProGe::VHDL, vhdlDir_, and vhdlFiles_.

Referenced by ProGeScriptGenerator().

Here is the call graph for this function:

◆ sortFilesFirst()

void ProGeScriptGenerator::sortFilesFirst	(	std::list< std::string > &	toSort,
		std::list< std::string > &	acSort
	)

private

Relative file name/path sort using a reference.

Sorts file in one list according to other list,placing in beginning of list, only relative order matters (which entry comes first). Algorithm used does relative sort between two lists, the other is sorted according to the other.

Parameters

toSort	List to be sorted.
acSort	List where reference order is taken from.

Definition at line 561 of file ProGeScriptGenerator.cc.

                                 {
  
     typedef std::list<std::string>::iterator listStrIt;
  
     listStrIt itAc1 = acSort.begin();
     listStrIt itTo  = toSort.begin();
     listStrIt itTo2;
  
     while (itAc1 != acSort.end()) {
         // now check list to be sorted
         bool swapped = false;
         itTo2 = itTo;
         while (itTo2 != toSort.end()) {
             if (FileSystem::compareFileNames(*itTo2, *itAc1, dstDir_)) {
                 // now change itTo2 and itTo places                            
                 string temp = *itTo;
                 *itTo = *itTo2;
                 *itTo2 = temp;
                 swapped = true;
                 break;
                 }
             ++itTo2;
         }
         if (swapped) {
             ++itTo;
         }
         ++itAc1;
     }
 }

References FileSystem::compareFileNames(), and dstDir_.

Referenced by prepareFiles().

Here is the call graph for this function:

◆ sortFilesLast()

void ProGeScriptGenerator::sortFilesLast	(	std::list< std::string > &	toSort,
		std::list< std::string > &	acSort
	)

private

Relative file name/path sort using a reference.

Sorts file in one list according to other list, placing in end of list, only relative order matters (which entry comes first). Algorithm used does relative sort between two lists, the other is sorted according to the other.

Parameters

toSort	List to be sorted.
acSort	List where reference order is taken from.

Definition at line 606 of file ProGeScriptGenerator.cc.

                                 {
     typedef std::list<std::string>::iterator listStrIt;
     typedef std::list<std::string>::reverse_iterator  rlistStrIt;
  
     listStrIt itAc1 = acSort.begin();
     rlistStrIt itTo    = toSort.rbegin();
     rlistStrIt itTo2;
  
     while (itAc1 != acSort.end()) {
         // now check list to be sorted
         bool swapped = false;
         itTo2 = itTo;
         while (itTo2 != toSort.rend()) {
             if (FileSystem::compareFileNames(*itTo2, *itAc1,dstDir_)) {
                 // now change itTo2 and itTo places                            
                 string temp  = *itTo;
                 *itTo = *itTo2;
                 *itTo2 = temp;
                 swapped = true;
                 break;
                 }
             ++itTo2;
         }
         if (swapped) {
             ++itTo;
         }
         ++itAc1;
     }
 }

References FileSystem::compareFileNames(), and dstDir_.

Referenced by prepareFiles().

Here is the call graph for this function:

◆ uniqueFileNames()

template<typename CONT >

void ProGeScriptGenerator::uniqueFileNames	(	CONT &	files,
		const std::string &	rootDirectory
	)

private

Member Data Documentation

◆ dstDir_

std::string ProGeScriptGenerator::dstDir_

private

Definition at line 128 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), generateGhdlCompile(), generateGhdlSimulate(), generateIverilogCompile(), generateIverilogSimulate(), generateModsimCompile(), generateModsimSimulate(), prepareFiles(), sortFilesFirst(), and sortFilesLast().

◆ gcuicDir_

const std::string ProGeScriptGenerator::gcuicDir_

private

Definition at line 145 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), and prepareFiles().

◆ gcuicFiles_

std::list<std::string> ProGeScriptGenerator::gcuicFiles_

private

Definition at line 138 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), generateGhdlCompile(), generateIverilogCompile(), generateModsimCompile(), packageFilesFirst(), and prepareFiles().

◆ ghdlCompileScriptName_

const std::string ProGeScriptGenerator::ghdlCompileScriptName_

private

Definition at line 150 of file ProGeScriptGenerator.hh.

Referenced by generateGhdlCompile().

◆ ghdlSimulateScriptName_

const std::string ProGeScriptGenerator::ghdlSimulateScriptName_

private

Definition at line 153 of file ProGeScriptGenerator.hh.

Referenced by generateGhdlSimulate().

◆ idf_

const IDF::MachineImplementation& ProGeScriptGenerator::idf_

private

Definition at line 159 of file ProGeScriptGenerator.hh.

Referenced by getBlockOrder().

◆ iverilogCompileScriptName_

const std::string ProGeScriptGenerator::iverilogCompileScriptName_

private

Definition at line 151 of file ProGeScriptGenerator.hh.

Referenced by generateIverilogCompile().

◆ iverilogSimulateScriptName_

const std::string ProGeScriptGenerator::iverilogSimulateScriptName_

private

Definition at line 154 of file ProGeScriptGenerator.hh.

Referenced by generateIverilogSimulate().

◆ language_

const ProGe::HDL ProGeScriptGenerator::language_

private

Definition at line 160 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), generateAll(), generateModsimCompile(), and prepareFiles().

◆ modsimCompileScriptName_

const std::string ProGeScriptGenerator::modsimCompileScriptName_

private

Definition at line 149 of file ProGeScriptGenerator.hh.

Referenced by generateModsimCompile().

◆ modsimSimulateScriptName_

const std::string ProGeScriptGenerator::modsimSimulateScriptName_

private

Definition at line 152 of file ProGeScriptGenerator.hh.

Referenced by generateModsimSimulate().

◆ progeOutDir_

std::string ProGeScriptGenerator::progeOutDir_

private

Definition at line 130 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), and prepareFiles().

◆ sharedOutDir_

std::string ProGeScriptGenerator::sharedOutDir_

private

Definition at line 132 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles().

◆ simulationRuntime_

const std::string ProGeScriptGenerator::simulationRuntime_

private

Definition at line 163 of file ProGeScriptGenerator.hh.

Referenced by generateIverilogCompile(), generateModsimCompile(), and generateSimulationStart().

◆ tbDir_

const std::string ProGeScriptGenerator::tbDir_

private

Definition at line 146 of file ProGeScriptGenerator.hh.

Referenced by prepareFiles().

◆ testBenchDir_

std::string ProGeScriptGenerator::testBenchDir_

private

Definition at line 134 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles().

◆ testBenchFiles_

std::list<std::string> ProGeScriptGenerator::testBenchFiles_

private

Definition at line 139 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), generateGhdlCompile(), generateIverilogCompile(), generateModsimCompile(), packageFilesFirst(), and prepareFiles().

◆ testbenchName_

const std::string ProGeScriptGenerator::testbenchName_

private

Definition at line 157 of file ProGeScriptGenerator.hh.

Referenced by generateGhdlCompile(), generateGhdlSimulate(), generateIverilogCompile(), generateIverilogSimulate(), and generateModsimSimulate().

◆ toplevelEntity_

const std::string ProGeScriptGenerator::toplevelEntity_

private

Definition at line 158 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), and prepareFiles().

◆ verDir_

const std::string ProGeScriptGenerator::verDir_

private

Definition at line 144 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles().

◆ vhdlDir_

const std::string ProGeScriptGenerator::vhdlDir_

private

Definition at line 143 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), and prepareFiles().

◆ vhdlFiles_

std::list<std::string> ProGeScriptGenerator::vhdlFiles_

private

Definition at line 137 of file ProGeScriptGenerator.hh.

Referenced by fetchFiles(), generateGhdlCompile(), generateIverilogCompile(), generateModsimCompile(), packageFilesFirst(), and prepareFiles().

◆ workDir_

const std::string ProGeScriptGenerator::workDir_

private

Definition at line 142 of file ProGeScriptGenerator.hh.

Referenced by generateGhdlCompile(), and generateModsimCompile().

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ProGeScriptGenerator()

◆ ~ProGeScriptGenerator()

Member Function Documentation

◆ createExecutableFile()

◆ fetchFiles()

◆ findFiles() [1/2]

◆ findFiles() [2/2]

◆ findText()

◆ generateAll()

◆ generateCompileStart()

◆ generateGhdlCompile()

◆ generateGhdlSimulate()

◆ generateIverilogCompile()

◆ generateIverilogSimulate()

◆ generateModsimCompile()

◆ generateModsimSimulate()

◆ generateSimulationStart()

◆ getBlockOrder()

◆ outputScriptCommand()

◆ outputScriptCommands()

◆ packageFilesFirst()

◆ prefixStrings()

◆ prepareFiles()

◆ sortFilesFirst()

◆ sortFilesLast()

◆ uniqueFileNames()

Member Data Documentation

◆ dstDir_

◆ gcuicDir_

◆ gcuicFiles_

◆ ghdlCompileScriptName_

◆ ghdlSimulateScriptName_

◆ idf_

◆ iverilogCompileScriptName_

◆ iverilogSimulateScriptName_

◆ language_

◆ modsimCompileScriptName_

◆ modsimSimulateScriptName_

◆ progeOutDir_

◆ sharedOutDir_

◆ simulationRuntime_

◆ tbDir_

◆ testBenchDir_

◆ testBenchFiles_

◆ testbenchName_

◆ toplevelEntity_

◆ verDir_

◆ vhdlDir_

◆ vhdlFiles_

◆ workDir_