torc::generic::VerilogImporter Class Reference

Importer from structural verilog format into a generic design. More...

#include <VerilogImporter.hpp>

Collaboration diagram for torc::generic::VerilogImporter:

Public Member Functions
	VerilogImporter (void)
	Construct the parser importer context. More...
bool	operator() (const boost::filesystem::path &inFilename, const std::string &inArguments=std::string())
	Import Verilog from a file. More...
void	failure (void)
	Signals a parsing failure by deasserting the success flag. More...
RootSharedPtr	getRootPtr (void)
	Returns a shared pointer for the root. More...

Protected Types
typedef std::string	string
	Imported type name. More...

Protected Attributes
string	mStreamName
	Name of file or input stream for error messages. More...
bool	mSuccess
	Flag signaling parsing success. More...
RootSharedPtr	mRootPtr
	Root of generic netlist. More...

Friends
class	torc::generic::generic::VerilogImporterUnitTest
	The unit test class has access to our internals. More...

Detailed Description

Importer from structural verilog format into a generic design.

Definition at line 38 of file VerilogImporter.hpp.

Member Typedef Documentation

typedef std::string torc::generic::VerilogImporter::string

protected

Imported type name.

Definition at line 45 of file VerilogImporter.hpp.

Constructor & Destructor Documentation

torc::generic::VerilogImporter::VerilogImporter

(

void

)

Construct the parser importer context.

Definition at line 92 of file VerilogImporter.cpp.

                                         {
        // assume success unless we encounter an error
        mSuccess = true;
    }

Member Function Documentation

void torc::generic::VerilogImporter::failure ( void  )

inline

Signals a parsing failure by deasserting the success flag.

Definition at line 67 of file VerilogImporter.hpp.

{ mSuccess = false; }

RootSharedPtr torc::generic::VerilogImporter::getRootPtr ( void  )

inline

Returns a shared pointer for the root.

This root is created and populated during verilog import process.

Definition at line 71 of file VerilogImporter.hpp.

{ return mRootPtr; }

Here is the caller graph for this function:

bool torc::generic::VerilogImporter::operator()	(	const boost::filesystem::path &	inFilename,
		const std::string &	inArguments = std::string()
	)

Import Verilog from a file.

Parameters

inFilename	Input file name.
inArguments	Additional Verilator command line arguments.

Returns

true if successfully parsed.

Todo:

Release the arguments in argv after use with free()

Definition at line 97 of file VerilogImporter.cpp.

                                      {

        int argc = 0;
        char* env[] = {
            0
        };
        std::string arguments = 
            "./VerilogImporter " 
            + inFilename.string()
            + " --cc "
            + "-Itorc/externals/verilator/include "
        //  + "--dump-tree "
            ;
        // combine the local arguments and the user supplied arguments
        std::string input = arguments + " " + inArguments;
        // tokenize just so we can count arguments (so much uglier than it should be ...)
        boost::char_separator<char> sep(" ");
        boost::tokenizer< boost::char_separator<char> > tokens(input, sep);
        typedef boost::token_iterator_generator< boost::char_separator<char> >::type Iterator;
        Iterator p = boost::make_token_iterator<string>(input.begin(), input.end(), sep);
        Iterator e = boost::make_token_iterator<string>(input.end(), input.end(), sep);
        while(p != e) { *p++; argc++; }
        // declare an array of sufficient size
        char* argv[argc];
        // put all of the arguments into the array
        argc = 0;
        BOOST_FOREACH(const string& t, tokens) { argv[argc++] = strdup(t.c_str()); }
        /// \todo Release the arguments in argv after use with free()

        // General initialization
        ios::sync_with_stdio();

        // enable the following if we ever allow command line -D definitions
        V3PreShell::boot(env);

        // parse command line options
        v3Global.opt.bin(argv[0]);
        string argString = V3Options::argString(argc-1, argv+1);
        v3Global.opt.parseOpts(new FileLine("COMMAND_LINE",0), argc-1, argv+1);
        if(!v3Global.opt.outFormatOk() && !v3Global.opt.preprocOnly() && !v3Global.opt.lintOnly() 
            && !v3Global.opt.cdc()) {
            v3fatal("verilator: Need --cc, --sc, --sp, --cdc, --lint-only or --E option");
        }
        // release memory allocated for the command line arguments
        while(argc) { free(argv[--argc]); }

        // extract environment variables
        V3Options::getenvSYSTEMC();
        V3Options::getenvSYSTEMC_ARCH();
        V3Options::getenvSYSTEMC_INCLUDE();
        V3Options::getenvSYSTEMC_LIBDIR();
        V3Options::getenvSYSTEMPERL();
        V3Options::getenvSYSTEMPERL_INCLUDE();

        V3Error::abortIfErrors();

        V3File::addSrcDepend(v3Global.opt.bin());

        // Internal tests (after option parsing as need debug() setting)
        V3Graph::test();

        // Read first filename
        v3Global.readFiles();

        // restore C++ and C io to their default unsyncronized state
        ios::sync_with_stdio(false);

        // create a Generic object factory and root
        torc::generic::ObjectFactorySharedPtr objectFactoryPtr(new torc::generic::ObjectFactory());
        mRootPtr = objectFactoryPtr->newRootPtr("WORK");

        // visit the abstract syntax tree and extract the generic netlist representation
        torc::generic::VerilogImporterVisitor verilogImporterVisitor(objectFactoryPtr, mRootPtr);
        v3Global.rootp()->accept(verilogImporterVisitor);

        // export the EDIF design
        string outFileName = "output.edf";
        fstream edifExport(outFileName.c_str(), ios_base::out);
        torc::generic::EdifExporter exporter(edifExport);
        exporter(mRootPtr);

        return mSuccess;
    }

Friends And Related Function Documentation

friend class torc::generic::generic::VerilogImporterUnitTest

friend

The unit test class has access to our internals.

Definition at line 42 of file VerilogImporter.hpp.

Field Documentation

RootSharedPtr torc::generic::VerilogImporter::mRootPtr

protected

Root of generic netlist.

Definition at line 53 of file VerilogImporter.hpp.

string torc::generic::VerilogImporter::mStreamName

protected

Name of file or input stream for error messages.

Definition at line 48 of file VerilogImporter.hpp.

bool torc::generic::VerilogImporter::mSuccess

protected

Flag signaling parsing success.

Definition at line 51 of file VerilogImporter.hpp.

---

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

• VerilogImporter.hpp
• VerilogImporter.cpp