source: translator/ResolvExpr/FindOpenVars.cc @ d9a0e76

/*
 * This file is part of the Cforall project
 *
 * $Id: FindOpenVars.cc,v 1.4 2005/08/29 20:14:16 rcbilson Exp $
 *
 */

#include "FindOpenVars.h"
#include "SynTree/Type.h"
#include "SynTree/Visitor.h"


namespace ResolvExpr {

class FindOpenVars : public Visitor
{
public:
  FindOpenVars( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
  
private:
  virtual void visit(PointerType *pointerType);
  virtual void visit(ArrayType *arrayType);
  virtual void visit(FunctionType *functionType);
  virtual void visit(TupleType *tupleType);
  
  void common_action( Type *type );
  
  OpenVarSet &openVars, &closedVars;
  AssertionSet &needAssertions, &haveAssertions;
  bool nextIsOpen;
};

void
findOpenVars( Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen )
{
  FindOpenVars finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
  type->accept( finder );
}

FindOpenVars::FindOpenVars( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen )
  : openVars( openVars ), closedVars( closedVars ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), nextIsOpen( firstIsOpen )
{
}

void
FindOpenVars::common_action( Type *type )
{
  if( nextIsOpen ) {
    for( std::list< TypeDecl* >::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
      openVars[ (*i)->get_name() ] = (*i)->get_kind();
      for( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
        needAssertions[ *assert ] = false;
      }
///       cloneAll( (*i)->get_assertions(), needAssertions );
///       needAssertions.insert( needAssertions.end(), (*i)->get_assertions().begin(), (*i)->get_assertions().end() );
    }
  } else {
    for( std::list< TypeDecl* >::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
      closedVars[ (*i)->get_name() ] = (*i)->get_kind();
      for( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
        haveAssertions[ *assert ] = false;
      }
///       cloneAll( (*i)->get_assertions(), haveAssertions );
///       haveAssertions.insert( haveAssertions.end(), (*i)->get_assertions().begin(), (*i)->get_assertions().end() );
    }
  }
///   std::cout << "type is ";
///   type->print( std::cout );
///   std::cout << std::endl << "need is" << std::endl;
///   printAssertionSet( needAssertions, std::cout );
///   std::cout << std::endl << "have is" << std::endl;
///   printAssertionSet( haveAssertions, std::cout );
}

void 
FindOpenVars::visit(PointerType *pointerType)
{
  common_action( pointerType );
  Visitor::visit( pointerType );
}

void 
FindOpenVars::visit(ArrayType *arrayType)
{
  common_action( arrayType );
  Visitor::visit( arrayType );
}

void 
FindOpenVars::visit(FunctionType *functionType)
{
  common_action( functionType );
  nextIsOpen = !nextIsOpen;
  Visitor::visit( functionType );
  nextIsOpen = !nextIsOpen;
}

void 
FindOpenVars::visit(TupleType *tupleType)
{
  common_action( tupleType );
  Visitor::visit( tupleType );
}

} // namespace ResolvExpr