sageFunctors.h

Go to the documentation of this file.

#ifndef _SAGEFUNCTORS_H
#define _SAGEFUNCTORS_H


#include "sageInterface.h"
#include "sageBuilder.h"

namespace sg
{
  template <class SageNode>
  static inline
  SageNode* cloneNode(const SageNode* n)
  {
    if (!n) return 0;

    return SageInterface::deepCopy(n);
  }

  static inline
  void _append(SgExprListExp& container, SgExpression* elem)
  {
    SageInterface::appendExpression(&container, elem);
  }

  static inline
  void _append(SgFunctionParameterList& container, SgInitializedName* elem)
  {
    SageInterface::appendArg(&container, elem);
  }

  struct ScopeSetter
  {
      explicit
      ScopeSetter(SgScopeStatement& the_scope)
      : scope(the_scope)
      {}

      template <class ScopedSageNode>
      void handle(ScopedSageNode* scopeElem) const
      {
        ROSE_ASSERT(scopeElem);

        scopeElem->set_scope(&scope);
      }

      void operator()(SgStatement* scopeElem)       const { handle(scopeElem); }
      void operator()(SgInitializedName* scopeElem) const { handle(scopeElem); }

    private:
      SgScopeStatement& scope;
  };

  struct VarRefBuilder
  {
      explicit
      VarRefBuilder(SgScopeStatement& the_scope)
      : scope(the_scope)
      {}

      SgVarRefExp* operator()(SgInitializedName* initName) const
      {
        return SageBuilder::buildVarRefExp(initName, &scope);
      }

    private:
      SgScopeStatement& scope;
  };

  struct InitNameCloner
  {
      InitNameCloner(SgDeclarationStatement& declaration, SgScopeStatement* enclosing_scope = 0)
      : decl(declaration), scope(enclosing_scope)
      {}

      SgInitializedName* operator()(const SgInitializedName* orig) const
      {
        SgInitializer*     copy_init = cloneNode(orig->get_initializer());
        SgInitializedName* res = SageBuilder::buildInitializedName(orig->get_name(), orig->get_type(), copy_init);

        res->set_scope(scope);

        return res;
      }

    private:
      SgDeclarationStatement& decl;
      SgScopeStatement*       scope;
  };

  template <class SageSequenceContainer>
  struct SageInserter : std::iterator<std::output_iterator_tag, void, void, void, void>
  {
    typedef SageSequenceContainer Container;

    Container& container;

    explicit
    SageInserter(Container& cont)
    : container(cont)
    {}

    // \todo SageElem should be derived form the container type
    template <class SageElem>
    SageInserter& operator=(SageElem* elem)
    {
      _append(container, elem);
      return *this;
    }

    SageInserter& operator*()     { return *this; }
    SageInserter& operator++()    { return *this; }
    SageInserter& operator++(int) { return *this; }
  };

  template <class SageSequenceContainer>
  SageInserter<SageSequenceContainer>
  sage_inserter(SageSequenceContainer& cont)
  {
    return SageInserter<SageSequenceContainer>(cont);
  }
}

#endif /* _SAGEFUNCTORS_H */