include/comma/ast/AstResource.h

Go to the documentation of this file.

//===-- ast/AstResource.h ------------------------------------- -*- C++ -*-===//
//
// This file is distributed under the MIT license.  See LICENSE.txt for details.
//
// Copyright (C) 2008-2009, Stephen Wilson
//
//===----------------------------------------------------------------------===//
//
// The AstResource class provides access to "universal" resources necessary for
// builing and managing Ast trees.  It provides mechanisms for managing the
// allocation of nodes, a single point of contact for fundamental facilities
// like text providers and an identifier pool.
//
//===----------------------------------------------------------------------===//

#ifndef COMMA_AST_ASTRESOURCE_HDR_GUARD
#define COMMA_AST_ASTRESOURCE_HDR_GUARD

#include "comma/ast/AstBase.h"
#include "comma/basic/IdentifierPool.h"
#include "comma/basic/PrimitiveOps.h"

#include "llvm/ADT/FoldingSet.h"

#include <vector>

namespace llvm {

class APInt;

} // end llvm namespace.

namespace comma {

class IndexConstraint;
class RangeConstraint;
class TextProvider;

class AstResource {

public:
    // For now, this class is simply a bag of important classes: A TextProvider
    // associated with the file being processed, and an IdentifierPool for the
    // global managment of identifiers.
    AstResource(TextProvider &txtProvider, IdentifierPool &idPool);

    // FIXME: Eventually we will replace this single TextProvider resource with
    // a manager class which provides services to handle multiple input files.
    TextProvider &getTextProvider() { return txtProvider; }

    IdentifierPool &getIdentifierPool() { return idPool; }

    // Convenience function to extract an IdentifierInfo object from the
    // associated IdentifierPool.
    IdentifierInfo *getIdentifierInfo(const char *name) const {
        return &idPool.getIdentifierInfo(name);
    }
    IdentifierInfo *getIdentifierInfo(const char *name, unsigned len) const {
        return &idPool.getIdentifierInfo(name, len);
    }
    IdentifierInfo *getIdentifierInfo(const std::string &name) const {
        return &idPool.getIdentifierInfo(name);
    }

    FunctionType *getFunctionType(Type **argTypes, unsigned numArgs,
                                  Type *returnType);

    ProcedureType *getProcedureType(Type **argTypes, unsigned numArgs);



    DomainType *createDomainType(DomainTypeDecl *decl);

    DomainType *createDomainSubtype(DomainType *rootTy, IdentifierInfo *name);



    EnumerationDecl *createEnumDecl(IdentifierInfo *name, Location loc,
                                    std::pair<IdentifierInfo*, Location> *elems,
                                    unsigned numElems, DeclRegion *parent);

    EnumerationDecl *createEnumSubtypeDecl(IdentifierInfo *name, Location loc,
                                           EnumerationType *subtype,
                                           Expr *low, Expr *high,
                                           DeclRegion *parent);

    EnumerationDecl *createEnumSubtypeDecl(IdentifierInfo *name, Location loc,
                                           EnumerationType *subtype,
                                           DeclRegion *parent);

    EnumerationType *createEnumType(EnumerationDecl *decl);

    EnumerationType *createEnumSubtype(EnumerationType *base,
                                       EnumerationDecl *decl = 0);

    EnumerationType *createEnumSubtype(EnumerationType *base,
                                       Expr *low, Expr *high,
                                       EnumerationDecl *decl = 0);



    IntegerDecl *createIntegerDecl(IdentifierInfo *name, Location loc,
                                   Expr *lowRange, Expr *highRange,
                                   DeclRegion *parent);

    IntegerDecl *createIntegerSubtypeDecl(IdentifierInfo *name, Location loc,
                                          IntegerType *subtype,
                                          Expr *lower, Expr *upper,
                                          DeclRegion *parent);

    IntegerDecl *createIntegerSubtypeDecl(IdentifierInfo *name, Location loc,
                                          IntegerType *subtype,
                                          DeclRegion *parent);

    IntegerType *createIntegerType(IntegerDecl *decl,
                                   const llvm::APInt &low,
                                   const llvm::APInt &high);

    IntegerType *createIntegerSubtype(IntegerType *base, Expr *low, Expr *high,
                                      IntegerDecl *decl = 0);

    IntegerType *createIntegerSubtype(IntegerType *base,
                                      const llvm::APInt &low,
                                      const llvm::APInt &high,
                                      IntegerDecl *decl = 0);

    IntegerType *createIntegerSubtype(IntegerType *base,
                                      IntegerDecl *decl = 0);

    DiscreteType *createDiscreteSubtype(DiscreteType *base,
                                        Expr *low, Expr *high,
                                        TypeDecl *decl = 0);



    ArrayDecl *createArrayDecl(IdentifierInfo *name, Location loc,
                               unsigned rank, DSTDefinition **indices,
                               Type *component, bool isConstrained,
                               DeclRegion *parent);

    ArrayType *createArrayType(ArrayDecl *decl,
                               unsigned rank, DiscreteType **indices,
                               Type *component, bool isConstrained);

    ArrayType *createArraySubtype(IdentifierInfo *name, ArrayType *base,
                                  DiscreteType **indices);

    ArrayType *createArraySubtype(IdentifierInfo *name, ArrayType *base);



    RecordDecl *createRecordDecl(IdentifierInfo *name, Location loc,
                                 DeclRegion *parent);

    RecordType *createRecordType(RecordDecl *decl);

    RecordType *createRecordSubtype(IdentifierInfo *name, RecordType *base);



    AccessDecl *createAccessDecl(IdentifierInfo *name, Location loc,
                                 Type *targetType, DeclRegion *parent);

    AccessType *createAccessType(AccessDecl *decl, Type *targetType);

    AccessType *createAccessSubtype(IdentifierInfo *name, AccessType *baseType);



    IncompleteTypeDecl *createIncompleteTypeDecl(IdentifierInfo *name,
                                                 Location loc,
                                                 DeclRegion *parent);

    IncompleteType *createIncompleteType(IncompleteTypeDecl *decl);

    IncompleteType *createIncompleteSubtype(IdentifierInfo *name,
                                            IncompleteType *base);

    ExceptionDecl *createExceptionDecl(IdentifierInfo *name, Location loc,
                                       DeclRegion *region);

    FunctionDecl *createPrimitiveDecl(PO::PrimitiveID ID,
                                      Location loc, Type *type,
                                      DeclRegion *region);


    EnumerationDecl *getTheBooleanDecl() const { return theBooleanDecl; }
    EnumerationType *getTheBooleanType() const;

    EnumerationDecl *getTheCharacterDecl() const { return theCharacterDecl; }
    EnumerationType *getTheCharacterType() const;

    IntegerDecl *getTheRootIntegerDecl() const { return theRootIntegerDecl; }
    IntegerType *getTheRootIntegerType() const;

    IntegerDecl *getTheIntegerDecl() const { return theIntegerDecl; }
    IntegerType *getTheIntegerType() const;

    IntegerDecl *getTheNaturalDecl() const { return theNaturalDecl; }
    IntegerType *getTheNaturalType() const;

    IntegerDecl *getThePositiveDecl() const { return thePositiveDecl; }
    IntegerType *getThePositiveType() const;

    ArrayDecl *getTheStringDecl() const { return theStringDecl; }
    ArrayType *getTheStringType() const;

    ExceptionDecl *getTheProgramError() const { return theProgramError; }
    ExceptionDecl *getTheConstraintError() const { return theConstraintError; }
    ExceptionDecl *getTheAssertionError() const { return theAssertionError; }

private:
    TextProvider &txtProvider;
    IdentifierPool &idPool;

    // Vectors of declaration and type nodes.
    std::vector<Decl*> decls;
    std::vector<Type*> types;

    // Tables of uniqued subroutine types.
    llvm::FoldingSet<FunctionType> functionTypes;
    llvm::FoldingSet<ProcedureType> procedureTypes;


    EnumerationDecl *theBooleanDecl;
    EnumerationDecl *theCharacterDecl;
    IntegerDecl *theRootIntegerDecl;
    IntegerDecl *theIntegerDecl;
    IntegerDecl *theNaturalDecl;
    IntegerDecl *thePositiveDecl;
    ArrayDecl *theStringDecl;
    ExceptionDecl *theProgramError;
    ExceptionDecl *theConstraintError;
    ExceptionDecl *theAssertionError;


    void initializeLanguageDefinedNodes();
    void initializeBoolean();
    void initializeCharacter();
    void initializeRootInteger();
    void initializeInteger();
    void initializeNatural();
    void initializePositive();
    void initializeString();
    void initializeExceptions();
};

} // End comma namespace.

#endif

---