include/comma/ast/AstBase.h

Go to the documentation of this file.

//===-- ast/AstBase.h ----------------------------------------- -*- C++ -*-===//
//
// This file is distributed under the MIT license.  See LICENSE.txt for details.
//
// Copyright (C) 2008-2010, Stephen Wilson
//
//===----------------------------------------------------------------------===//
//
// This header contains forwards declarations for all AST nodes, and definitions
// for a few choice fundamental nodes and types.
//
//===----------------------------------------------------------------------===//

#ifndef COMMA_AST_ASTBASE_HDR_GUARD
#define COMMA_AST_ASTBASE_HDR_GUARD

#include "comma/basic/Location.h"
#include "comma/basic/IdentifierInfo.h"
#include "llvm/Support/Casting.h"
#include <iosfwd>

namespace comma {

//
// Forward declarations for all Ast nodes.
//
class AbstractDomainDecl;
class AccessDecl;
class AccessType;
class AddDecl;
class AggregateExpr;
class AllocatorExpr;
class ArrayBoundAE;
class ArrayDecl;
class ArrayRangeAttrib;
class ArrayType;
class AssignmentStmt;
class Ast;
class AstRewriter;
class AstResource;
class AttribExpr;
class BlockStmt;
class CarrierDecl;
class ComponentDecl;
class CompositeType;
class CompilationUnit;
class ConversionExpr;
class Decl;
class DeclRegion;
class DeclRefExpr;
class DeclRewriter;
class DereferenceExpr;
class DiamondExpr;
class DiscreteType;
class DomainDecl;
class DomainInstanceDecl;
class DomainType;
class DomainTypeDecl;
class Domoid;
class DSTDefinition;
class EnumerationDecl;
class EnumLiteral;
class EnumerationType;
class ExceptionDecl;
class ExceptionRef;
class Expr;
class FirstAE;
class FirstArrayAE;
class ForStmt;
class FunctionAttribDecl;
class FunctionCallExpr;
class FunctionDecl;
class FunctionType;
class FunctorDecl;
class FunctorType;
class HandlerStmt;
class Identifier;
class IfStmt;
class ImportDecl;
class IndexedArrayExpr;
class IncompleteType;
class IncompleteTypeDecl;
class InjExpr;
class IntegerDecl;
class IntegerLiteral;
class IntegerType;
class KeywordSelector;
class LastAE;
class LastArrayAE;
class LoopDecl;
class LoopStmt;
class ModelDecl;
class NullExpr;
class NullStmt;
class ObjectDecl;
class ParamValueDecl;
class PercentDecl;
class PosAD;
class Pragma;
class PragmaAssert;
class PragmaImport;
class PragmaStmt;
class PrimaryType;
class PrjExpr;
class ProcedureCallStmt;
class ProcedureDecl;
class ProcedureType;
class QualifiedExpr;
class RaiseStmt;
class Range;
class RangeAttrib;
class RecordDecl;
class RecordType;
class RenamedObjectDecl;
class ReturnStmt;
class ScalarBoundAE;
class ScalarRangeAttrib;
class SelectedExpr;
class Sigoid;
class SignatureDecl;
class SigInstanceDecl;
class Stmt;
class StmtSequence;
class StringLiteral;
class SubroutineCall;
class SubroutineDecl;
class SubroutineRef;
class SubroutineType;
class Type;
class TypeDecl;
class TypeRef;
class UniversalType;
class ValAD;
class ValueDecl;
class VarietyDecl;
class VarietyType;
class WhileStmt;

class Ast {

public:
    enum AstKind {

        //
        // Decl nodes.  There are currently four sub-categories.
        //
        //    - Model decls which denotes signatures and domains.
        //
        //    - Type declarations (carriers, enums, etc).
        //
        //    - Subroutine decls denoting functions and procedures.
        //
        //    - Value decls denoting elements of a type.
        //
        AST_SignatureDecl,      
        AST_DomainDecl,         
        AST_VarietyDecl,        
        AST_FunctorDecl,        
        AST_AddDecl,            

        AST_AccessDecl,         
        AST_CarrierDecl,        
        AST_EnumerationDecl,    
        AST_IncompleteTypeDecl, 
        AST_IntegerDecl,        
        AST_ArrayDecl,          
        AST_RecordDecl,         
        AST_AbstractDomainDecl, 
        AST_DomainInstanceDecl, 
        AST_PercentDecl,        

        AST_SigInstanceDecl,    

        //
        // Value declaration nodes.
        //
        AST_LoopDecl,           
        AST_ObjectDecl,         
        AST_ParamValueDecl,     
        AST_RenamedObjectDecl,  

        //
        // Subroutine declaration nodes.
        //
        AST_ProcedureDecl,      
        AST_FunctionDecl,       
        AST_EnumLiteral,        
        AST_PosAD,              
        AST_ValAD,              

        AST_ImportDecl,         
        AST_ExceptionDecl,      
        AST_ComponentDecl,      

        //
        // Type nodes.
        //
        AST_UniversalType,      
        AST_FunctionType,       
        AST_ProcedureType,      

        //
        // Primary Types.
        //
        AST_AccessType,         
        AST_ArrayType,          
        AST_DomainType,         
        AST_EnumerationType,    
        AST_IncompleteType,     
        AST_IntegerType,        
        AST_RecordType,         

        //
        // Expr nodes.
        //
        AST_AllocatorExpr,      
        AST_ConversionExpr,     
        AST_DiamondExpr,        
        AST_DeclRefExpr,        
        AST_DereferenceExpr,    
        AST_FunctionCallExpr,   
        AST_IndexedArrayExpr,   
        AST_InjExpr,            
        AST_IntegerLiteral,     
        AST_NullExpr,           
        AST_AggregateExpr,      
        AST_PrjExpr,            
        AST_QualifiedExpr,      
        AST_SelectedExpr,       
        AST_StringLiteral,      

        //
        // Expr attributes.
        //
        AST_FirstAE,            
        AST_FirstArrayAE,       
        AST_LastArrayAE,        
        AST_LastAE,             

        //
        // Stmt nodes.
        //
        AST_AssignmentStmt,     
        AST_BlockStmt,          
        AST_ForStmt,            
        AST_HandlerStmt,        
        AST_IfStmt,             
        AST_LoopStmt,           
        AST_NullStmt,           
        AST_ProcedureCallStmt,  
        AST_RaiseStmt,          
        AST_ReturnStmt,         
        AST_StmtSequence,       
        AST_WhileStmt,          
        AST_PragmaStmt,         

        //
        // Miscellaneous helper nodes.
        //
        AST_KeywordSelector,    
        AST_DSTDefinition,      
        AST_Range,              
        AST_ArrayRangeAttrib,   
        AST_ScalarRangeAttrib,  
        AST_SubroutineRef,      
        AST_TypeRef,            
        AST_ExceptionRef,       
        AST_Identifier,         
        AST_ComponentKey,       

        //
        // Delimitiers providing classification of the above codes.
        //
        LAST_AstKind,

        FIRST_Decl = AST_SignatureDecl,
        LAST_Decl = AST_ComponentDecl,

        FIRST_ModelDecl = AST_SignatureDecl,
        LAST_ModelDecl = AST_FunctorDecl,

        FIRST_TypeDecl = AST_AccessDecl,
        LAST_TypeDecl = AST_PercentDecl,

        FIRST_DomainType = AST_AbstractDomainDecl,
        LAST_DomainType = AST_PercentDecl,

        FIRST_ValueDecl = AST_LoopDecl,
        LAST_ValueDecl = AST_RenamedObjectDecl,

        FIRST_SubroutineDecl = AST_ProcedureDecl,
        LAST_SubroutineDecl = AST_ValAD,

        FIRST_Type = AST_UniversalType,
        LAST_Type = AST_RecordType,

        FIRST_PrimaryType = AST_AccessType,
        LAST_PrimaryType = AST_RecordType,

        FIRST_Expr = AST_AllocatorExpr,
        LAST_Expr = AST_LastAE,

        FIRST_AttribExpr = AST_FirstAE,
        LAST_AttribExpr = AST_LastAE,

        FIRST_Stmt = AST_AssignmentStmt,
        LAST_Stmt = AST_PragmaStmt
    };

    virtual ~Ast() { }

    AstKind getKind() const { return kind; }

    virtual Location getLocation() const { return Location(); }

    bool isValid() const { return validFlag == true; }

    void markInvalid() { validFlag = false; }

    bool isDeletable() const { return deletable; }

    bool denotesDecl() const {
        return (FIRST_Decl <= kind && kind <= LAST_Decl);
    }

    bool denotesModelDecl() const {
        return (FIRST_ModelDecl <= kind && kind <= LAST_ModelDecl);
    }

    bool denotesTypeDecl() const {
        return (FIRST_TypeDecl <= kind && kind <= LAST_TypeDecl);
    }

    bool denotesSubroutineDecl() const {
        return (FIRST_SubroutineDecl <= kind && kind <= LAST_SubroutineDecl);
    }

    bool denotesValueDecl() const {
        return (FIRST_ValueDecl <= kind && kind <= LAST_ValueDecl);
    }

    bool denotesDomainTypeDecl() const {
        return (FIRST_DomainType <= kind && kind <= LAST_DomainType);
    }

    bool denotesType() const {
        return (FIRST_Type <= kind && kind <= LAST_Type);
    }

    bool denotesPrimaryType() const {
        return (FIRST_PrimaryType <= kind && kind <= LAST_PrimaryType);
    }

    bool denotesSubroutineType() const {
        return (kind == AST_FunctionType ||
                kind == AST_ProcedureType);
    }

    bool denotesCompositeType() const {
        return (kind == AST_ArrayType || kind == AST_RecordType);
    }

    bool denotesExpr() const {
        return (FIRST_Expr <= kind && kind <= LAST_Expr);
    }

    bool denotesAttribExpr() const {
        return (FIRST_AttribExpr <= kind && kind <= LAST_AttribExpr);
    }

    bool denotesStmt() const {
        return (FIRST_Stmt <= kind && kind <= LAST_Stmt);
    }

    const char *getKindString() const { return kindStrings[kind]; }

    virtual void dump();

    static bool classof(const Ast *node) { return true; }

protected:
    Ast(AstKind kind)
        : kind(kind),
          validFlag(true),
          deletable(true),
          bits(0) { }

    AstKind  kind      : 8;     
    bool     validFlag : 1;     
    bool     deletable : 1;     
    unsigned bits      : 23;    

    static const char *kindStrings[LAST_AstKind];
};

} // End comma namespace.

#endif

---