sageInterfaceAda.h

#ifndef _SAGEINTERFACE_ADA_H
#define _SAGEINTERFACE_ADA_H 1

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

#include <tuple>

namespace SageInterface
{

namespace Ada
{

namespace
{
  template <class SageRefExp>
  auto symOf(const SageRefExp& n) -> decltype( *n.get_symbol() )
  {
    auto* symp = n.get_symbol();
    ASSERT_not_null(symp);

    return *symp;
  }

  template <class SageSymbol>
  auto declOf(const SageSymbol& n) -> decltype( *n.get_declaration() )
  {
    auto* dclp = n.get_declaration();
    ASSERT_not_null(dclp);

    return *dclp;
  }

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

  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>
  auto declOfRef(const SageAdaRefExp& n) -> decltype( *n.get_decl() )
  {
    auto* dclp = n.get_decl();
    ASSERT_not_null(dclp);

    return *dclp;
  }

  inline
  SgAdaRenamingDecl& declOf(const SgAdaRenamingRefExp& n)
  {
    return declOfRef(n);
  }

  inline
  SgDeclarationStatement& declOf(const SgAdaUnitRefExp& n)
  {
    return declOfRef(n);
  }

  inline
  SgAdaTaskSpecDecl& declOf(const SgAdaTaskRefExp& n)
  {
    return declOfRef(n);
  }

  inline
  SgAdaProtectedSpecDecl& declOf(const SgAdaProtectedRefExp& n)
  {
    return declOfRef(n);
  }

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

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


  template <class SageRefExp>
  inline
  auto nameOf(const SageRefExp& n) -> decltype( nameOf(symOf(n)) )
  {
    return nameOf(symOf(n));
  }

  template <class SageRefExp>
  inline
  auto nameOf(const SageRefExp& n) -> decltype( n.get_decl()->get_name() )
  {
    return declOf(n).get_name();
  }


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

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

} // 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);
  FlatArrayType getArrayTypeInfo(SgType& atype);

  struct RecordField : std::tuple<const SgSymbol*>
  {
    using base = std::tuple<const SgSymbol*>;
    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(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 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 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);

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

  struct DominantArgInfo : std::tuple<const SgType*, std::size_t>
  {
    using base = std::tuple<const SgType*, std::size_t>;
    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);

  struct OperatorScopeInfo : std::tuple<SgScopeStatement*, std::size_t>
  {
    using base = std::tuple<SgScopeStatement*, std::size_t>;
    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);

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

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

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

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