sageInterfaceAda.h

 
 
#ifndef _SAGEINTERFACE_ADA_H
#define _SAGEINTERFACE_ADA_H 1
 
#include "sage3basic.hhh"
#include "sageInterface.h"
 
#include <tuple>
 
#include <boost/optional.hpp>
 
namespace SageInterface
{
 
namespace Ada
{
  template <class SageRefExp>
  static inline
  auto symOf(const SageRefExp& n) -> decltype( *n.get_symbol() )
  {
    auto* symp = n.get_symbol();
    ASSERT_not_null(symp);
 
    return *symp;
  }
 
  template <class SageSymbol>
  static inline
  auto declOf(const SageSymbol& n) -> decltype( *n.get_declaration() )
  {
    auto* dclp = n.get_declaration();
    ASSERT_not_null(dclp);
 
    return *dclp;
  }
 
  static inline
  SgFunctionDeclaration& declOf(const SgFunctionRefExp& n)
  {
    return declOf(symOf(n));
  }
 
  static inline
  SgInitializedName& declOf(const SgVarRefExp& n)
  {
    return declOf(symOf(n));
  }
 
 
  // \todo normalize Sage nodes that use this function
  //       and make them go through symbols, like any other
  //       ref exp.
  template <class SageAdaRefExp>
  static inline
  auto declOfRef(const SageAdaRefExp& n) -> decltype( *n.get_decl() )
  {
    auto* dclp = n.get_decl();
    ASSERT_not_null(dclp);
 
    return *dclp;
  }
 
  static inline
  SgAdaRenamingDecl& declOf(const SgAdaRenamingRefExp& n)
  {
    return declOfRef(n);
  }
 
  static inline
  SgDeclarationStatement& declOf(const SgAdaUnitRefExp& n)
  {
    return declOfRef(n);
  }
 
  static inline
  SgAdaTaskSpecDecl& declOf(const SgAdaTaskRefExp& n)
  {
    SgAdaTaskSpecDecl* res = isSgAdaTaskSpecDecl(&declOfRef(n));
 
    ASSERT_not_null(res);
    return *res;
  }
 
  static inline
  SgAdaProtectedSpecDecl& declOf(const SgAdaProtectedRefExp& n)
  {
    SgAdaProtectedSpecDecl* res = isSgAdaProtectedSpecDecl(&declOfRef(n));
 
    ASSERT_not_null(res);
    return *res;
  }
 
  static inline
  SgLabelStatement& declOf(const SgLabelRefExp& n)
  {
    return declOf(symOf(n));
  }
 
 
/*
  inline
  SgVariableDeclaration& declOf(const SgVariableSymbol& n)
  {
    SgNode* varnode = SG_DEREF(n.get_declaration()).get_parent();
 
    return SG_DEREF(isSgVariableDeclaration(varnode));
  }
 
  inline
  SgVariableDeclaration& declOf(const SgVarRefExp& n)
  {
    return declOf(symOf(n));
  }
*/
 
  static inline
  SgName nameOf(const SgSymbol& sy)
  {
    return sy.get_name();
  }
 
 
  template <class SageRefExp>
  static inline
  auto nameOf(const SageRefExp& n) -> decltype( nameOf(symOf(n)) )
  {
    return nameOf(symOf(n));
  }
 
  static inline
  SgName nameOf(const SgEnumVal& n)
  {
    return n.get_name();
  }
 
  static inline
  SgName nameOf(const SgAdaUnitRefExp& n)
  {
    return SageInterface::get_name(n.get_decl());
  }
 
 
/*
  inline
  SgName
  nameOf(const SgAdaRenamingDecl& n)
  {
    return n.get_name();
  }
*/
 
 
/*
  inline
  SgName nameOf(const SgImportStatement& import)
  {
    const SgExpressionPtrList& lst = import.get_import_list();
    ROSE_ASSERT(lst.size() == 1);
 
    return nameOf(SG_DEREF(isSgVarRefExp(lst.back())));
  }
*/
 
  SgInitializedName& declOf(const SgEnumVal&);
 
 
  extern const std::string roseOperatorPrefix;
  extern const std::string packageStandardName;
  extern const std::string durationTypeName;
  extern const std::string exceptionName;
 
  bool withPrivateDefinition(const SgDeclarationStatement* dcl);
  bool withPrivateDefinition(const SgDeclarationStatement& dcl);
 
  bool unconstrained(const SgArrayType* ty);
  bool unconstrained(const SgArrayType& ty);
 
  bool anonymousAccess(const SgType* ty);
  bool anonymousAccess(const SgType& ty);
 
  using StatementRange = std::pair<SgDeclarationStatementPtrList::iterator, SgDeclarationStatementPtrList::iterator>;
 
  StatementRange
  declsInPackage(SgGlobal& globalScope, const std::string& mainFile);
 
  StatementRange
  declsInPackage(SgGlobal& globalScope, const SgSourceFile& mainFile);
 
 
  int firstLastDimension(SgExprListExp& args);
  int firstLastDimension(SgExprListExp* args);
 
  using FlatArrayTypeBase = std::tuple<SgArrayType*, std::vector<SgExpression*> >;
 
  struct FlatArrayType : FlatArrayTypeBase
  {
    using base = FlatArrayTypeBase;
    using base::base;
 
    SgArrayType*                      type() const { return std::get<0>(*this); }
    std::vector<SgExpression*> const& dims() const { return std::get<1>(*this); }
    std::vector<SgExpression*>&       dims()       { return std::get<1>(*this); }
  };
 
  FlatArrayType getArrayTypeInfo(SgType* atype);
  FlatArrayType getArrayTypeInfo(SgType& atype);
 
 
  SgType& standardType(const std::string& name);
 
  using RecordFieldBase = std::tuple<const SgSymbol*>;
 
  struct RecordField : RecordFieldBase
  {
    using base = RecordFieldBase;
    using base::base;
 
    const SgSymbol&          symbol()         const;
    const SgSymbol&          originalSymbol() const;
    const SgClassDefinition& record()         const;
    bool                     inherited()      const { return isSgAliasSymbol(&symbol()); }
    bool                     discriminant()   const;
  };
 
 
  std::vector<RecordField>
  getAllRecordFields(const SgClassDefinition& rec);
 
  std::vector<RecordField>
  getAllRecordFields(const SgClassDefinition* rec);
 
 
  template <class SageLocatedNode>
  struct IfInfo : std::tuple<SgExpression*, SageLocatedNode*>
  {
    using base = std::tuple<SgExpression*, SageLocatedNode*>;
    using base::base;
 
    SgExpression*    condition()  const { return std::get<0>(*this); }
    SageLocatedNode* trueBranch() const { return std::get<1>(*this); }
    bool             isElse()     const { return condition() == nullptr; }
  };
 
  using IfExpressionInfo = IfInfo<SgExpression>;
  using IfStatementInfo  = IfInfo<SgStatement>;
 
  std::vector<IfExpressionInfo>
  flattenIfExpressions(const SgConditionalExp& n);
 
  std::vector<IfStatementInfo>
  flattenIfStatements(const SgIfStmt& n);
 
  long long int
  staticIntegralValue(SgExpression* n);
 
 
  SgExpression*
  underlyingExpr(const SgStatement* s);
 
  SgRangeExp* range(const SgAdaAttributeExp* rangeAttribute);
  SgRangeExp* range(const SgAdaAttributeExp& rangeAttribute);
 
  bool denotesRange(const SgExpression& e);
  bool denotesRange(const SgExpression* e);
 
  SgAdaPackageSpecDecl& getSpecificationDeclaration(const SgAdaPackageBodyDecl& bodyDecl);
  SgAdaPackageSpecDecl* getSpecificationDeclaration(const SgAdaPackageBodyDecl* bodyDecl);
 
 
  SgAdaPackageBodyDecl& getPackageBodyDeclaration(const SgAdaPackageSpecDecl& specDecl);
  SgAdaPackageBodyDecl* getPackageBodyDeclaration(const SgAdaPackageSpecDecl* specDecl);
 
  SgAdaPackageSpec& getSpecificationDefinition(const SgAdaPackageBody& body);
  SgAdaPackageSpec* getSpecificationDefinition(const SgAdaPackageBody* body);
 
  SgAdaPackageBody& getBodyDefinition(const SgAdaPackageSpec& spec);
  SgAdaPackageBody* getBodyDefinition(const SgAdaPackageSpec* spec);
 
  SgDeclarationStatement& getSpecificationDeclaration(const SgAdaTaskBodyDecl& bodyDecl);
  SgDeclarationStatement* getSpecificationDeclaration(const SgAdaTaskBodyDecl* bodyDecl);
 
  SgDeclarationStatement& getSpecificationDeclaration(const SgAdaProtectedBodyDecl& bodyDecl);
  SgDeclarationStatement* getSpecificationDeclaration(const SgAdaProtectedBodyDecl* bodyDecl);
 
  const SgScopeStatement* correspondingBody(const SgScopeStatement* scope);
 
  SgStatementPtrList::iterator declarationLimit(SgStatementPtrList& list);
  SgStatementPtrList::iterator declarationLimit(SgBasicBlock& block);
  SgStatementPtrList::iterator declarationLimit(SgBasicBlock* block);
  SgStatementPtrList::const_iterator declarationLimit(const SgStatementPtrList& list);
  SgStatementPtrList::const_iterator declarationLimit(const SgBasicBlock& block);
  SgStatementPtrList::const_iterator declarationLimit(const SgBasicBlock* block);
 
  bool tryFollowsDeclarativeBlock(const SgTryStmt& n);
  bool tryFollowsDeclarativeBlock(const SgTryStmt* n);
 
 
  bool isPackageTryBlock(const SgTryStmt& n);
  bool isPackageTryBlock(const SgTryStmt* n);
 
 
  bool hasUnknownDiscriminants(const SgAdaDiscriminatedTypeDecl& n);
  bool hasUnknownDiscriminants(const SgAdaDiscriminatedTypeDecl* n);
 
  bool isOutInoutArgument(const SgFunctionCallExp& call, const SgExpression& arg);
  bool isOutInoutArgument(const SgFunctionCallExp* call, const SgExpression* arg);
 
 
 
  bool isModularType(const SgType& ty);
  bool isModularType(const SgType* ty);
  bool isIntegerType(const SgType& ty);
  bool isIntegerType(const SgType* ty);
  bool isFloatingPointType(const SgType& ty);
  bool isFloatingPointType(const SgType* ty);
  bool isDiscreteType(const SgType* ty);
  bool isDiscreteType(const SgType& ty);
  bool isBooleanType(const SgType* ty);
  bool isBooleanType(const SgType& ty);
 
  bool isFixedType(const SgType* ty);
  bool isFixedType(const SgType& ty);
 
  bool isScalarType(const SgType* ty);
  bool isScalarType(const SgType& ty);
 
  bool isDiscreteArrayType(const SgType& ty);
  bool isDiscreteArrayType(const SgType* ty);
 
  bool resolvesToFixedType(const SgType* ty);
  bool resolvesToFixedType(const SgType& ty);
 
  bool isDecimalFixedType(const SgType* ty);
  bool isDecimalFixedType(const SgType& ty);
 
 
  boost::optional<bool>
  booleanConstant(const SgExpression* e);
 
  boost::optional<bool>
  booleanConstant(const SgExpression& e);
 
 
  SgAdaGenericDecl* isGenericDecl(const SgDeclarationStatement& n);
  SgAdaGenericDecl* isGenericDecl(const SgDeclarationStatement* n);
 
  bool unitRefDenotesGenericInstance(const SgAdaUnitRefExp& n);
  bool unitRefDenotesGenericInstance(const SgAdaUnitRefExp* n);
 
  SgAdaGenericDecl& getGenericDecl(const SgAdaGenericInstanceDecl& n);
  SgAdaGenericDecl* getGenericDecl(const SgAdaGenericInstanceDecl* n);
 
 
  SgAdaDiscriminatedTypeDecl* getAdaDiscriminatedTypeDecl(const SgDeclarationStatement& n);
  SgAdaDiscriminatedTypeDecl* getAdaDiscriminatedTypeDecl(const SgDeclarationStatement* n);
 
  bool hasSeparatedBody(const SgDeclarationStatement& dcl);
  bool hasSeparatedBody(const SgDeclarationStatement* dcl);
 
  bool isSeparatedBody(const SgDeclarationStatement& n);
  bool isSeparatedBody(const SgDeclarationStatement* n);
 
  bool isSeparatedDefinition(const SgFunctionDeclaration& n);
  bool isSeparatedDefinition(const SgFunctionDeclaration* n);
 
  using TypeDescriptionBase = std::tuple<SgType*, bool, std::vector<SgAdaTypeConstraint*> >;
 
  struct TypeDescription : TypeDescriptionBase
  {
    static constexpr bool classwide = true;
 
    using base = TypeDescriptionBase;
 
    explicit
    TypeDescription(SgType& ty, bool polymorph = false, std::vector<SgAdaTypeConstraint*> constr = {})
    : base(&ty, polymorph, std::move(constr))
    {}
 
    explicit
    TypeDescription(SgType* ty = nullptr)
    : base(ty, false, {})
    {}
 
    SgType* typerep()     const { return std::get<0>(*this); }
    SgType& typerep_ref() const;
    bool    polymorphic() const { return std::get<1>(*this); }
 
    const std::vector<SgAdaTypeConstraint*>&
    toplevelConstraints() const & { return std::get<2>(*this); }
 
    std::vector<SgAdaTypeConstraint*>
    toplevelConstraints() &&    { return std::move(std::get<2>(*this)); }
  };
 
  TypeDescription typeRoot(SgType&);
  TypeDescription typeRoot(SgType*);
 
  TypeDescription typeOfExpr(const SgExpression&);
  TypeDescription typeOfExpr(const SgExpression*);
 
  SgType* baseOfAccessType(const SgType* ty);
  SgType* baseOfAccessType(const SgType& ty);
 
  using DominantArgInfoBase = std::tuple<const SgType*, std::size_t>;
 
  struct DominantArgInfo : DominantArgInfoBase
  {
    using base = DominantArgInfoBase;
    using base::base;
 
    const SgType* type() const { return std::get<0>(*this); }
    std::size_t   pos()  const { return std::get<1>(*this); }
  };
 
  DominantArgInfo
  operatorArgumentWithNamedRootIfAvail(const SgTypePtrList& argtypes);
 
  using OperatorScopeInfoBase = std::tuple<SgScopeStatement*, std::size_t>;
 
  struct OperatorScopeInfo : OperatorScopeInfoBase
  {
    using base = OperatorScopeInfoBase;
    using base::base;
 
    // the scope associated with the dominant parameter
    SgScopeStatement* scope()  const { return std::get<0>(*this); }
 
    // the position of the dominant parameter in the parameter list
    std::size_t       argpos() const { return std::get<1>(*this); }
  };
 
  OperatorScopeInfo
  operatorScope(const std::string& opname, const SgTypePtrList& argtypes);
 
 
  SgScopeStatement&
  operatorScope(const std::string& opname, const SgType& ty);
 
  SgScopeStatement*
  operatorScope(const std::string& opname, const SgType* ty);
 
 
  SgScopeStatement* declarationScope(const SgType* ty);
  SgScopeStatement* declarationScope(const SgType& ty);
 
  using ImportedUnitResultBase = std::tuple< std::string,
                                             const SgDeclarationStatement*,
                                             const SgAdaRenamingDecl*,
                                             const SgExpression*
                                           >;
 
  struct ImportedUnitResult : ImportedUnitResultBase
  {
    using base = ImportedUnitResultBase;
    using base::base;
 
    const std::string&            name()         const { return std::get<0>(*this); }
 
    const SgDeclarationStatement& decl()         const
    {
      ASSERT_not_null(std::get<1>(*this));
      return *(std::get<1>(*this));
    }
 
    const SgAdaRenamingDecl*      renamingDecl() const { return std::get<2>(*this); }
 
    const SgExpression&           unitref()      const
    {
      ASSERT_not_null(std::get<3>(*this));
      return *std::get<3>(*this);
    }
  };
 
  std::vector<ImportedUnitResult>
  importedUnits(const SgImportStatement& impdcl);
 
 
  SgScopeStatement* pkgStandardScope();
 
  std::string convertRoseOperatorNameToAdaName(const std::string& nameInRose);
 
  std::string convertRoseOperatorNameToAdaOperator(const std::string& nameInRose);
 
  using AggregateInfoBase = std::tuple< SgAdaAncestorInitializer*,
                                        SgExpressionPtrList::const_iterator,
                                        SgExpressionPtrList::const_iterator
                                      >;
 
  struct AggregateInfo : AggregateInfoBase
  {
    using base = AggregateInfoBase;
    using base::base;
 
    SgAdaAncestorInitializer* ancestor() const { return std::get<0>(*this); }
 
    SgExpressionPtrList::const_iterator begin() const { return std::get<1>(*this); }
 
    SgExpressionPtrList::const_iterator end() const { return std::get<2>(*this); }
 
    bool nullRecord() const { return begin() == end(); }
  };
 
  AggregateInfo splitAggregate(const SgExprListExp& exp);
  AggregateInfo splitAggregate(const SgExprListExp* exp);
 
 
  SgAdaPackageSpecDecl* renamedPackage(const SgAdaRenamingDecl& n);
  SgAdaPackageSpecDecl* renamedPackage(const SgAdaRenamingDecl* n);
 
 
  bool isFunction(const SgFunctionType& ty);
  bool isFunction(const SgFunctionType* ty);
  bool isFunction(const SgAdaSubroutineType& ty);
  bool isFunction(const SgAdaSubroutineType* ty);
 
  const SgFunctionType* functionType(const SgFunctionSymbol* fnsy);
  const SgFunctionType& functionType(const SgFunctionSymbol& fnsy);
 
 
  bool isObjectRenaming(const SgAdaRenamingDecl* dcl);
  bool isObjectRenaming(const SgAdaRenamingDecl& dcl);
 
  bool isExceptionRenaming(const SgAdaRenamingDecl* dcl);
  bool isExceptionRenaming(const SgAdaRenamingDecl& dcl);
 
  using PrimitiveParameterDescBase = std::tuple<size_t, const SgInitializedName*, const SgDeclarationStatement*>;
 
  struct PrimitiveParameterDesc : PrimitiveParameterDescBase
  {
    using base = PrimitiveParameterDescBase;
    using base::base;
 
    size_t
    pos()  const { return std::get<0>(*this); }
 
    const SgInitializedName*
    name() const { return std::get<1>(*this); }
 
    const SgDeclarationStatement*
    typeDeclaration() const { return std::get<2>(*this); }
  };
 
  std::vector<PrimitiveParameterDesc>
  primitiveParameterPositions(const SgFunctionDeclaration& fn);
 
  std::vector<PrimitiveParameterDesc>
  primitiveParameterPositions(const SgFunctionDeclaration* fn);
 
  using PrimitiveSignatureElementsDescBase = std::tuple< const SgDeclarationStatement*
                                                       , std::vector<PrimitiveParameterDesc>
                                                       >;
 
  struct PrimitiveSignatureElementsDesc : PrimitiveSignatureElementsDescBase
  {
    using base = PrimitiveSignatureElementsDescBase;
    using base::base;
 
    const SgDeclarationStatement*
    result() const { return std::get<0>(*this); }
 
    const std::vector<PrimitiveParameterDesc>&
    parameters() const & { return std::get<1>(*this); }
 
    std::vector<PrimitiveParameterDesc>
    parameters() && { return std::move(std::get<1>(*this)); }
  };
 
  PrimitiveSignatureElementsDesc
  primitiveSignatureElements(const SgFunctionDeclaration&);
 
  PrimitiveSignatureElementsDesc
  primitiveSignatureElements(const SgFunctionDeclaration*);
 
 
  const SgVariableDeclaration*
  exceptionTypeDecl(const SgVariableDeclaration& n);
 
  const SgVariableDeclaration*
  exceptionTypeDecl(const SgVariableDeclaration* n);
 
  SgVariableDeclaration*
  exceptionTypeDecl(SgVariableDeclaration& n);
 
  SgVariableDeclaration*
  exceptionTypeDecl(SgVariableDeclaration* n);
 
  SgExpressionPtrList
  normalizedCallArguments2(const SgFunctionCallExp& n, const SgFunctionParameterList& arglist, bool withDefaultArguments = false);
 
  SgExpressionPtrList
  normalizedCallArguments(const SgFunctionCallExp& n, bool withDefaultArguments = false);
 
  SgFunctionParameterList*
  calleeParameterList(const SgFunctionCallExp& n);
 
  SgFunctionParameterList*
  calleeParameterList(const SgFunctionCallExp* n);
 
 
  std::size_t
  normalizedArgumentPosition(const SgFunctionCallExp& call, const SgExpression& arg);
 
 
  std::tuple<const SgScopeStatement*, const SgSymbol*>
  findSymbolInContext(std::string id, const SgScopeStatement& scope, const SgScopeStatement* limit = nullptr);
 
 
 
  SgScopeStatement*
  overridingScope(const SgExprListExp& args, const std::vector<PrimitiveParameterDesc>& primitiveArgs);
 
  SgScopeStatement*
  overridingScope(const SgExprListExp* args, const std::vector<PrimitiveParameterDesc>& primitiveArgs);
 
  const SgScopeStatement* canonicalScope(const SgScopeStatement* scope);
  const SgScopeStatement& canonicalScope(const SgScopeStatement& scope);
 
  bool sameCanonicalScope(const SgScopeStatement* lhs, const SgScopeStatement* rhs);
 
  SgScopeStatement*
  logicalParentScope(const SgScopeStatement& s);
 
  SgScopeStatement*
  logicalParentScope(const SgScopeStatement* s);
 
 
  SgDeclarationStatement* associatedDeclaration(const SgSymbol& n);
 
  SgDeclarationStatement* associatedDeclaration(const SgType& ty);
  SgDeclarationStatement* associatedDeclaration(const SgType* ty);
 
  SgType*
  baseType(const SgType& ty);
 
  SgType*
  baseType(const SgType* ty);
 
 
  SgEnumDeclaration*
  baseEnumDeclaration(SgType* ty);
 
  SgEnumDeclaration*
  baseEnumDeclaration(SgType& ty);
 
  SgEnumType*
  characterBaseType(SgEnumType* ty);
 
  SgEnumType*
  characterBaseType(SgEnumType& ty);
 
 
  bool explicitNullProcedure(const SgFunctionDefinition& fndef);
 
  bool explicitNullRecord(const SgClassDefinition& recdef);
 
  bool isReverseForLoop(const SgForStatement* n);
  bool isReverseForLoop(const SgForStatement& n);
  bool isReverseForLoop(const SgForInitStatement* n);
  bool isReverseForLoop(const SgForInitStatement& n);
 
 
  size_t
  positionalArgumentLimit(const SgExpressionPtrList& arglst);
 
  size_t
  positionalArgumentLimit(const SgExprListExp& args);
 
  size_t
  positionalArgumentLimit(const SgExprListExp* args);
 
  bool blockExistsInSource(const SgBasicBlock* blk);
  bool blockExistsInSource(const SgBasicBlock& blk);
 
  SgFunctionSymbol*
  findPubliclyVisibleFunction( SgFunctionSymbol& fnsym,
                               const SgFunctionType& drvFunTy,
                               const SgNamedType& dervTy
                             );
 
  bool isAttribute(const SgAdaAttributeExp& attr, const std::string& attrname);
 
  bool isAnyAccessAttribute(const SgAdaAttributeExp& attr);
 
  SgExprListExp*
  isPragma(const SgPragmaDeclaration& prgdcl, const std::string& pragmaname);
 
  void simpleTraversal(std::function<void(SgNode*)>&& fn, SgNode* root);
  void simpleTraversal(std::function<void(SgNode*)>&& fn, StatementRange roots);
 
  void conversionTraversal(std::function<void(SgNode*)>&& fn, SgNode* root);
  void conversionTraversal(std::function<void(SgNode*)>&& fn, StatementRange roots);
 
 
  long long int convertIntegerLiteral(const char* img);
 
  std::string convertStringLiteral(const char* img);
 
  long double convertRealLiteral(const char* img);
 
  char convertCharLiteral(const char* img);
 
  struct ScopePath : private std::vector<const SgScopeStatement*>
  {
      using base = std::vector<const SgScopeStatement*>;
      using base::base;
 
      using base::const_reverse_iterator;
      using base::reverse_iterator;
      using base::const_iterator;
      using base::value_type;
      using base::reference;
 
      using base::end;
      using base::begin;
      using base::rend;
      using base::rbegin;
 
      using base::size;
      using base::back;
 
      void push_back(base::value_type ptr)
      {
        ROSE_ASSERT(isSgScopeStatement(ptr) || isSgDeclarationStatement(ptr));
        ROSE_ASSERT(!isSgGlobal(ptr));
 
        base::push_back(ptr);
      }
  };
 
  ScopePath pathToGlobal(const SgScopeStatement& n);
 
  void copyFileInfo(SgLocatedNode& tgt, const SgLocatedNode& src);
  // void copyFileInfo(SgExpression&  tgt, const SgExpression& src);
 
  void setSourcePositionInSubtreeToCompilerGenerated(SgLocatedNode* n);
  void setSourcePositionInSubtreeToCompilerGenerated(SgLocatedNode& n);
 
  // \todo mv into Ada to C++ converter
  void convertAdaToCxxComments(SgNode* root, bool cxxLineComments = true);
 
  // \todo mv into Ada to C++ converter
  void convertToCaseSensitiveSymbolTables(SgNode* root);
 
  // \todo mv into Ada to C++ converter
  void convertToOperatorRepresentation(SgNode* root, bool convertCallSyntax = false, bool convertNamedArguments = false);
} // Ada
} // SageInterface
 
#endif /* _SAGEINTERFACE_ADA_H */