sageInterfaceAda.h

#ifndef _SAGEINTERFACE_ADA_H
#define _SAGEINTERFACE_ADA_H 1

#include "sage3basic.hhh"
#include "sageInterface.h"

#include <tuple>

namespace SageInterface
{

namespace Ada
{

namespace
{
  inline
  SgVariableSymbol&
  symOf(const SgVarRefExp& n)
  {
    ASSERT_not_null(n.get_symbol());

    return *n.get_symbol();
  }

  inline
  SgFunctionSymbol&
  symOf(const SgFunctionRefExp& n)
  {
    ASSERT_not_null(n.get_symbol());

    return *n.get_symbol();
  }

  inline
  SgFunctionDeclaration&
  declOf(const SgFunctionSymbol& n)
  {
    ASSERT_not_null(n.get_declaration());

    return *n.get_declaration();
  }

  inline
  SgFunctionDeclaration&
  declOf(const SgFunctionRefExp& n)
  {
    return declOf(symOf(n));
  }

  inline
  SgInitializedName&
  declOf(const SgVarRefExp& n)
  {
    SgVariableSymbol& sy = symOf(n);

    ASSERT_not_null(sy.get_declaration());
    return *sy.get_declaration();
  }

  inline
  SgDeclarationStatement&
  declOf(const SgAdaUnitRefExp& n)
  {
    ASSERT_not_null(n.get_decl());

    return *n.get_decl();
  }



/*
  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));
  }
*/

  inline
  SgAdaRenamingDecl&
  declOf(const SgAdaRenamingRefExp& n)
  {
    ASSERT_not_null(n.get_decl());

    return *n.get_decl();
  }


  inline
  SgName
  nameOf(const SgSymbol& sy)
  {
    return sy.get_name();
  }

  inline
  SgName
  nameOf(const SgVarRefExp& n)
  {
    return nameOf(symOf(n));
  }

  inline
  SgName
  nameOf(const SgFunctionRefExp& n)
  {
    return nameOf(symOf(n));
  }

  inline
  SgName
  nameOf(const SgEnumVal& n)
  {
    return n.get_name();
  }

  inline
  SgName
  nameOf(const SgAdaRenamingDecl& n)
  {
    return n.get_name();
  }

  inline
  SgName
  nameOf(const SgAdaRenamingRefExp& n)
  {
    return nameOf(declOf(n));
  }

  inline
  SgName
  nameOf(const SgAdaUnitRefExp& n)
  {
    return SageInterface::get_name(n.get_decl());
  }


/*
  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())));
  }
*/

} // anononymous namespace for convenience functions


  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);

  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);

  struct FlatArrayType : std::tuple<SgArrayType*, std::vector<SgExpression*> >
  {
    using base = std::tuple<SgArrayType*, std::vector<SgExpression*> >;
    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);

  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(SgConditionalExp& n);

  std::vector<IfStatementInfo>
  flattenIfStatements(SgIfStmt& n);

  long long int
  staticIntegralValue(SgExpression* n);


  SgExpression*
  underlyingExpr(const SgStatement* s);

  SgRangeExp* range(const SgAdaAttributeExp* rangeAttribute);
  SgRangeExp* range(const SgAdaAttributeExp& rangeAttribute);

  SgAdaPackageSpecDecl& getSpecificationDeclaration(const SgAdaPackageBodyDecl& bodyDecl);
  SgAdaPackageSpecDecl* getSpecificationDeclaration(const SgAdaPackageBodyDecl* bodyDecl);

  SgAdaPackageBodyDecl& getPackageBodyDeclaration(const SgAdaPackageSpecDecl& specDecl);
  SgAdaPackageBodyDecl* getPackageBodyDeclaration(const SgAdaPackageSpecDecl* specDecl);

  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 isFunctionTryBlock(const SgTryStmt& n);
  bool isFunctionTryBlock(const SgTryStmt* n);


  bool isPackageTryBlock(const SgTryStmt& n);
  bool isPackageTryBlock(const SgTryStmt* n);


  bool hasUnknownDiscriminants(const SgAdaDiscriminatedTypeDecl& n);
  bool hasUnknownDiscriminants(const SgAdaDiscriminatedTypeDecl* n);


  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 isFixedType(const SgType* ty);
  bool isFixedType(const SgType& ty);

  bool resolvesToFixedType(const SgType* ty);
  bool resolvesToFixedType(const SgType& ty);

  bool isDecimalFixedType(const SgType* ty);
  bool isDecimalFixedType(const SgType& ty);

  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);

  struct TypeDescription : std::tuple<SgType*, bool>
  {
    using base = std::tuple<SgType*, bool>;
    using base::base;

    SgType* typerep()     const { return std::get<0>(*this); }
    SgType& typerep_ref() const;
    bool    polymorphic() const { return std::get<1>(*this); }
  };

  TypeDescription typeRoot(SgType&);
  TypeDescription typeRoot(SgType*);

  TypeDescription typeOfExpr(SgExpression&);
  TypeDescription typeOfExpr(SgExpression*);

  SgScopeStatement* operatorScope(std::string opname, SgTypePtrList argtypes);

  struct ImportedUnitResult : std::tuple<std::string, const SgDeclarationStatement*, const SgAdaRenamingDecl*>
  {
    using base = std::tuple<std::string, const SgDeclarationStatement*, const SgAdaRenamingDecl*>;
    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); }
  };

  ImportedUnitResult
  importedUnit(const SgImportStatement& impdcl);

  const SgExpression&
  importedElement(const SgImportStatement& n);


  SgScopeStatement* pkgStandardScope();

  std::string convertRoseOperatorNameToAdaName(const std::string& nameInRose);

  std::string convertRoseOperatorNameToAdaOperator(const std::string& nameInRose);

  struct AggregateInfo : std::tuple< SgAdaAncestorInitializer*,
                                     SgExpressionPtrList::const_iterator,
                                     SgExpressionPtrList::const_iterator
                                   >
  {
    using base = std::tuple< SgAdaAncestorInitializer*,
                             SgExpressionPtrList::const_iterator,
                             SgExpressionPtrList::const_iterator
                           >;
    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);

  bool isObjectRenaming(const SgAdaRenamingDecl* dcl);
  bool isObjectRenaming(const SgAdaRenamingDecl& dcl);

  bool isExceptionRenaming(const SgAdaRenamingDecl* dcl);
  bool isExceptionRenaming(const SgAdaRenamingDecl& dcl);

  struct PrimitiveParameterDesc : std::tuple<size_t, const SgInitializedName*>
  {
    using base = std::tuple<size_t, const SgInitializedName*>;
    using base::base;

    size_t
    pos()  const { return std::get<0>(*this); }

    const SgInitializedName*
    name() const { return std::get<1>(*this); }
  };

  std::vector<PrimitiveParameterDesc>
  primitiveParameterPositions(const SgFunctionDeclaration&);

  std::vector<PrimitiveParameterDesc>
  primitiveParameterPositions(const SgFunctionDeclaration*);

  SgExpressionPtrList
  normalizedCallArguments(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*
  logicalParentScope(const SgScopeStatement& s);

  const 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);
/*
  SgDeclarationStatement*
  baseDeclaration(const SgType& ty);

  SgDeclarationStatement*
  baseDeclaration(const SgType* ty);
*/
  SgEnumDeclaration*
  baseEnumDeclaration(SgType* ty);

  SgEnumDeclaration*
  baseEnumDeclaration(SgType& ty);

  bool explicitNullProcedure(const SgFunctionDefinition& fndef);

  bool explicitNullRecord(const SgClassDefinition& recdef);

  size_t
  positionalArgumentLimit(const SgExpressionPtrList& arglst);

  size_t
  positionalArgumentLimit(const SgExprListExp& args);

  size_t
  positionalArgumentLimit(const SgExprListExp* args);

  long long int convertIntegerLiteral(const char* img);

  std::string convertStringLiteral(const char* img);

  long double convertRealLiteral(const char* img);

  char convertCharLiteral(const char* img);


  // \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 */