verilog2c++.cc

将Verilog代码转换成C++代码的软件

	printProgress(std::cerr,(100.0*curr)/total);
      
      vector<Process*>::const_iterator i;
      for( i=top_->process().begin();i!=top_->process().end();++i )
	{
	  curr ++;
	  
	  if( typeid( *((*i)->statement()) )==typeid( Assign ) )
	    {
	      Assign* ass=(Assign*)(*i)->statement();
	      
	      if( ass->isSimple() )
		if( typeid( *(ass->rightValue()) )==typeid( Identifier )&&
		    ((Identifier*)ass->rightValue())->net()==net )
		  _trace(((Identifier*)ass->leftValue())->net(),type,sync,curr,total);
	    }
	  else
	    {
	      const Statement* stat;
	      stat =(*i)->queryStatement(type,net);
	      if( stat!=NULL )
		{
		  set<const Net*> right;
		  RightNetChainCB cb( right );
		  stat->callback( cb );

		  Handle handle(stat);
		  handle.setRight( right );
		  sync.handle().push_back( handle );
		}
	    }
	}
    }
    bool trace(const Net* net,int type,Synchronous& sync)
    {
      printProgress(std::cerr,-1);
      int curr=0;
      int total=0;
      
      vector<Process*>::const_iterator i;
      for( i=top_->process().begin();i!=top_->process().end();++i )
	{
	  curr ++;
	  
	  if( typeid( *((*i)->statement()) )==typeid( Assign ) )
	    {
	      Assign* ass=(Assign*)(*i)->statement();
	      
	      if( ass->isSimple() )
		if( typeid( *(ass->rightValue()) )==typeid( Identifier )&&
		    ((Identifier*)ass->rightValue())->net()==net )
		  _trace(((Identifier*)ass->leftValue())->net(),type,sync,curr,total);
	    }
	  else
	    {
	      const Statement* stat;
	      stat =(*i)->queryStatement(type,net);
	      if( stat!=NULL )
		{
		  set<const Net*> right;
		  RightNetChainCB cb( right );
		  stat->callback( cb );
 
		  Handle handle(stat);
		  handle.setRight( right );
		  sync.handle().push_back( handle );
		}
	    }
	}
      
      printProgress(std::cerr,100.0);
      return true;
    }
    ////////////////////////////////////////////////////////////////////////
    void _relate(const Net* net,
		 set<const Net*>& actnet,
		 set<const Statement*>& actstat,
		 list<Handle>& chain)
    {
      if( actnet.find(net)==actnet.end() )
	{
	  actnet.insert( net );
	  
	  multimap<const Net*,const Statement*>::const_iterator i;
	  set<const Net*>::const_iterator ii;
	  i =map_.find( net );
	  if( i!=map_.end() )
	    {
	      do
		{
		  if( actstat.find( i->second )==actstat.end() )
		    {
		      actstat.insert( i->second );
		      
		      set<const Net*> left;
		      set<const Net*> right;
		      LeftNetChainCB  lcb( left );
		      RightNetChainCB rcb( right );
		      i->second->callback( lcb );
		      i->second->callback( rcb );
		
		      Handle handle( i->second );
		      handle.setRight( right );
		      handle.setLeft( left );
		      chain.push_front( handle );
		      
		      for( ii=right.begin();ii!=right.end();++ii )
			_relate(*ii,actnet,actstat,chain);
		    }
		  i++;
		}
	      while( i!=map_.upper_bound( net ) );
	    }
	}
    }
    ////////////////////////////////////
    bool relate(list<Handle>& chain)
    {
      set<const Net*> actnet;
      
      set<const Statement*> actstat;
      list<Handle>::const_iterator i;
      set<const Net*>::const_iterator ii;
      
      double per =0.0;
      double step =100.0/chain.size();
      
      printProgress(std::cerr,-1);
      for( i=chain.begin();i!=chain.end();++i )
	{
	  printProgress(std::cerr,per);
	  per +=step;
	  
	  for( ii=(*i).right().begin();ii!=(*i).right().end();++ii )
	    _relate(*ii,actnet,actstat,chain);
	}
      printProgress(std::cerr,100.0);
      
      return true;
    }
    ////////////////////////////////////////////////////////////////////////
    bool _inclusion(const set<const Net*>& l,const set<const Net*>& r)
    {
      set<const Net*>::const_iterator i;
      for( i=l.begin();i!=l.end();++i )
	if( r.find( *i )!=r.end() )
	  return true;
      return false; 
    }
    ////////////////////////////////////
    bool inspect(list<Handle>& chain)
    {
      list<Handle>::iterator i;
      list<Handle>::iterator ii;
      
      double per =0.0;
      double step =100.0/chain.size();
      printProgress(std::cerr,-1);
      for( i=chain.begin();i!=chain.end();++i )
	{
	  printProgress(std::cerr,per);
	  per +=step;
	  
	  for( ii=i;ii!=chain.end();++ii )
	    {
	      if( i!=ii )
		if( _inclusion( (*i).right(),(*ii).left() ) )
		  {
		    chain.insert( i,(*ii) );
		    chain.erase( ii );
		    return true;
		  }
	    }
	}
      printProgress(std::cerr,100.0);
      
      return false;
    }
    ////////////////////////////////////
    bool sort(list<Handle>& chain)
    {
      bool swap;
      set<const Handle*> loop;
      list<Handle>::iterator i;
      list<Handle>::iterator ii;
      
      double per =0.0;
      double step =100.0/chain.size();
      
      printProgress(std::cerr,-1);
      for( i=chain.begin();i!=chain.end();++i )
	{
	  printProgress(std::cerr,per);
	  per +=step;
	  
	  do
	    {
	      for( ii=i;ii!=chain.end();++ii )
		{
		  swap=false;
		  if( i!=ii )
		    if( _inclusion( (*i).right(),(*ii).left() ) )
		      {
			if( loop.find( &(*ii) )!=loop.end() )
			  {
			    std::cerr << "\nlacing error !\n";
			    (*ii).statement()->toVerilog(cerr,0);
			    
			    return false;
			  }
			
			i =chain.insert( i,(*ii) );
			chain.erase( ii );
			
			loop.insert( &(*ii)  );
			
			swap=true;
			break;
		      }
		  if( swap )
		    break;
		}
	    }
	  while( swap );
	  loop.clear();
	}
      
      printProgress(std::cerr,100.0);
      
      return true;
    }
    ////////////////////////////////////////////////////////////////////////
    
    
  public:
    Convert(bool debug=false):
      Verilog(debug),
      top_(NULL),
      anysync_(NULL,Event::ANYEDGE)
    {}
    ~Convert(){}
    
    const vector<Synchronous>& synchronous() const { return sync_; }
    const set<const Net*>&  latch() const { return latch_; }
    const set<const Net*>&  flipflop() const { return flipflop_; }
    //    const set<const Net*>&  constant() const { return constant_; }
    //    const set<const Net*>&  input() const { return input_; }
    //    const set<const Net*>&  output() const { return output_; }
    const multimap<const Net*,const Statement*>& handle() const { return map_; }
    
    
    ////////////////////////////////////////////////////////////////////////
    bool setTop(const char* name)
    {
      top_=findModule(name);
      
      if( top_!=NULL )
	{
	  cerr << "ungroup instance...\n";
	  top_->ungroup();
	  
	  cerr << "link net...\n";
	  top_->link();
	  
	  {
	    vector<Process*>::const_iterator i;
	    for( i=top_->process().begin();i!=top_->process().end();++i )
	      {
		if( (*i)->isStorage()&&(*i)->isEdge() )
		  {
		    set<const Net*>::const_iterator ii;
		    //for( ii=(*i)->leftChain().begin();ii!=(*i)->leftChain().end();++ii )
		    for( ii=(*i)->nbLeftChain().begin();ii!=(*i)->nbLeftChain().end();++ii )
		      {
			flipflop_.insert( (*ii) );
		      }
		  }
		else
		  {
		    if( (*i)->isStorage()&&(*i)->isLevel() )
		      latch_.insert( (*i)->leftChain().begin(),(*i)->leftChain().end() );
		    
		    switch( (*i)->type() )
		      {
			
		      case Process::ASSIGN:
			{
			  
		    
			  set<const Net*>::const_iterator ii;
			  for( ii=(*i)->leftChain().begin();ii!=(*i)->leftChain().end();++ii )
			    map_.insert( pair<const Net*,const Statement*>
					 ((*ii),(*i)->statement()) );			    
			}
			break;
			
		      case Process::ALWAYS:
			{
			  if( typeid( *(*i)->statement() )==typeid( EventStatement ) )
			    {
			      
			      if( typeid( *( ((EventStatement*)(*i)->statement())->statement() ) )==
				  typeid( Block ) )
				{
				  /**
				  vector<Statement*>::const_iterator ii;
				  for( ii=((Block*)(((EventStatement*)(*i)->statement())->statement()))->list().begin();
				       ii!=((Block*)(((EventStatement*)(*i)->statement())->statement()))->list().end();
				       ++ii )
				    {
				      set<const Net*> chain;
				      LeftNetChainCB cb(chain);
				      (*ii)->callback(cb);
				      
				      set<const Net*>::const_iterator iii;
				      for( iii=chain.begin();iii!=chain.end();++iii )
					map_.insert( pair<const Net*,const Statement*>
						     ((*iii),(*ii)) );
				    }
				  **/
				  set<const Net*>::const_iterator ii;
				  for( ii=(*i)->leftChain().begin();ii!=(*i)->leftChain().end();++ii )
				    map_.insert( pair<const Net*,const Statement*>
						 ((*ii),
						  ((EventStatement*)(*i)->statement())->statement()) );
				  
				}
			      else
				{
				  set<const Net*>::const_iterator ii;
				  for( ii=(*i)->leftChain().begin();ii!=(*i)->leftChain().end();++ii )
				    map_.insert( pair<const Net*,const Statement*>
						 ((*ii),
						  ((EventStatement*)(*i)->statement())->statement()) );
				}
			    }
			}
			break;
			
		      }
		  }
	      }
	  }
	  
	  return true;
	}
      else
	return false;
    }
    ////////////////////////////////////////////////////////////////////////
    bool setSynchronous(const char* name,int type)
    {
      if( top_!=NULL )
	{
	  bool ret;
	  const Net* net =top_->findNet(name);
	  
	  if( net!=NULL )
	    {
	      syncsrc_.insert(net);
	      
	      std::cerr << "synchronous source : ";
	      
	      std::cerr << name;
	      if( type==Event::POSEDGE )
		std::cerr << ".posedge";
	      else if( type==Event::NEGEDGE )
		std::cerr << ".negedge";
	      else
		std::cerr << ".anyedge";	    
	      std::cerr << endl;
	      
	      sync_.push_back( Synchronous(net,type) );
	      
	      std::cerr << "trace... ";
	      trace(net,type,sync_.back());
	      std::cerr << '\n';
	      
	      std::cerr << "relate... ";
	      ret =relate(sync_.back().handle());
	      std::cerr << '\n';
	      
	      std::cerr << "sort... ";
	      sort(sync_.back().handle());
	      std::cerr << '\n';
	      
	      std::cerr << "inspect... ";
	      inspect(sync_.back().handle());
	      std::cerr << '\n';
	      
	      return ret;
	    }
	}
      return false;
    }
    bool setAnything()
    {
      if( top_!=NULL )
	{
	  bool ret;
	  
	  std::cerr << "anything source... \n";
	  
	  {
	    map<string,Net*>::const_iterator i;
	    for( i=top_->net().begin();i!=top_->net().end();++i )
	      {
		if( ((i->second->interface()==Net::OUTPUT)||
		     (i->second->interface()==Net::INOUT))&&
		    (flipflop_.find(i->second)==flipflop_.end()) )
		  {
		    set<const Net*> right;
		    right.insert( i->second );
		    Handle handle(NULL);
		    handle.setRight( right );
		    anysync_.handle().push_back( handle );
		  }
	      }
	  }
	  
	  std::cerr << "relate... ";
	  ret =relate(anysync_.handle());
	  std::cerr << '\n';
	  
	  std::cerr << "sort... ";
	  sort(anysync_.handle());
	  std::cerr << '\n';
	  
	  std::cerr << "inspect... ";
	  inspect(anysync_.handle());
	  std::cerr << '\n';
	  
	  return ret;
	}
      else
	return false;
    }
    ////////////////////////////////////////////////////////////////////////
    void toEmVer(const char* path,bool comm=false,bool vcd=false)
    {
      string fname;
      int indent;
      set<const Net*> vcdNet;
      
      ////////////////////////////////////////////////////////////////////////
      ////////////////////////////////////////////////////////////////////////
      ////////////////////////////////////////////////////////////////////////
      
      fname =string(path) + findName( top_ ) + ".hh";
      std::ofstream hhstr(fname.c_str());
      indent=0;
      
      ////////////////////////////////////////////////////////
      // create header file
      hhstr << setw(indent) << "" << "#include <EmVer.hh>" << endl;
      
      hhstr << setw(indent) << "" << "namespace moe" << endl;
      hhstr << setw(indent) << "" << '{' << endl;
      indent+=2;
      
      hhstr << setw(indent) << "" << "class " << findName( top_ ) << ": public EmVer" << endl;
      hhstr << setw(indent) << "" << "{" << endl;indent+=2;
      
      ////////////////////////////////////
      // vcd
      if( vcd )
	{
	  hhstr << setw(indent) << "" << "////////////////////////////////////////////////////////////////////////\n";
	  hhstr << setw(indent) << "" << "std::ostream* vcd_;\n";
	  hhstr << setw(indent) << "" << "long          time_;\n";
	  hhstr << setw(indent) << "" << "////////////////////////////////////////////////////////////////////////\n";
	}
      


      /***
      ////////////////////////////////////
      // constant
      {
	set<string>::const_iterator i;
	for( i=pool(Number()).begin();i!=pool(Number()).end();++i )
	  {
	    if( (*i).size()>64 )
	      {
		hhstr << setw(indent) << "" << "UIntN<" << setw(3) << (*i).size() << "> ";
		hhstr.form("c%08X;",i);
		if( comm )
		  hhstr << " // " << (*i) << ".constant";
		hhstr << endl;
	      }
	  }
      }
      ***/
      

      ////////////////////////////////////
      // regist
      {
	map<string,Net*>::const_iterator i;
	for( i=top_->net().begin();i!=top_->net().end();++i )
	  {
	    if( syncsrc_.find( i->second )==syncsrc_.end() )
	      {
		if( (i->second->interface()!=Net::PRIVATE)||
		    (flipflop_.find(i->second)!=flipflop_.end())||
		    (latch_.find(i->second)!=latch_.end()) )	       
		  {
		    printNet(hhstr,indent,i->second);

		    /**
		    printClass(hhstr,i->second->width(),indent);
		    //		    hhstr.form("n%08X",i->second);
		    hhstr << 'n' << (uint)i->second;
		    if( i->second->isArray() )
		      hhstr << '[' << i->second->depth() << ']';
		    hhstr << ";";
		    **/

		    if( comm )
		      {
			hhstr << " // " << i->first;
			if( flipflop_.find(i->second)!=flipflop_.end() )
			  hhstr << ":flipflop";
			if( latch_.find(i->second)!=latch_.end() )
			  hhstr << ":latch";
			if( i->second->interface()!=Net::PRIVATE )
			  hhstr << ":port";
		      }
		    hhstr << endl;
		    
		    vcdNet.insert( i->second );

		    ////////////////////////////////////
		    /**
		    if( flipflop_.find(i->second)!=flipflop_.end() )
		      {
			hhstr << setw(indent) << "" << "bool       ";
			//			hhstr.form("b%08X",i->second);
			hhstr << 'b' << (uint)i->second;
			hhstr << ";";
			if( comm )
			  {
			    hhstr << " // " << i->first;
			    if( flipflop_.find(i->second)!=flipflop_.end() )
			      hhstr << ":booth";
			  }
			hhstr << endl;
		      }
		    **/
		  }
	      }
	  }
      }


      ////////////////////////////////////
      // function
      {
	hhstr << setw(indent) << "" << "////////////////////////////////////////////////////////////////////////\n";

	map<string,Function*>::const_iterator i;
	for( i=top_->function().begin();i!=top_->function().end();++i )
	  {
	    Function* func =i->second;
	    vector<string>::const_iterator ii;
	    bool second=false;