source: translator/Parser.old/TypeData.h@ c8ffe20b

#ifndef TYPEDATA_H
#define TYPEDATA_H

#include <list>
#include "ParseNode.h"
#include "SynTree/SynTree.h"
#include "SynTree/Type.h"
#include "SynTree/Declaration.h"
#include "SemanticError.h"
#include "LinkageSpec.h"

struct TypeData
{
  enum Kind { Unknown, Basic, Pointer, Array, Function, Aggregate, AggregateInst,
              Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof } kind;

  TypeData( Kind k = Unknown );
  ~TypeData();
  void print( std::ostream &, int indent = 0 ) const;
  TypeData *clone() const;

  Type *build() const;
  FunctionType *buildFunction() const;

  TypeData *base;
  std::list< DeclarationNode::Qualifier > qualifiers;
  DeclarationNode *forall;

  struct Basic_t {
    std::list< DeclarationNode::BasicType > typeSpec;
    std::list< DeclarationNode::Modifier > modifiers;
  };

  struct Aggregate_t {
    DeclarationNode::TyCon kind;
    std::string name;
    DeclarationNode *params;
    ExpressionNode *actuals;    // holds actual parameters that will later be applied to AggInst
    DeclarationNode *members;
  };

  struct AggInst_t {
    TypeData *aggregate;
    ExpressionNode *params;
  };

  struct Array_t {
    ExpressionNode *dimension;
    bool isVarLen;
    bool isStatic;
  };

  struct Enumeration_t {
    std::string name;
    DeclarationNode *constants;
  };

  struct Function_t {
    DeclarationNode *params;
    DeclarationNode *idList; // old-style
    DeclarationNode *oldDeclList;
    StatementNode *body;
    bool hasBody;
  };

  struct Symbolic_t {
    std::string name;
    bool isTypedef;
    DeclarationNode *params;
    ExpressionNode *actuals;
    DeclarationNode *assertions;
  };

  struct Variable_t {
    DeclarationNode::TypeClass tyClass;
    std::string name;
    DeclarationNode *assertions;
  };

  struct Tuple_t {
    DeclarationNode *members;
  };
  
  struct Typeof_t {
    ExpressionNode *expr;
  };

  union {
    Basic_t *basic;
    Aggregate_t *aggregate;
    AggInst_t *aggInst;
    Array_t *array;
    Enumeration_t *enumeration;
    Function_t *function;
    Symbolic_t *symbolic;
    Variable_t *variable;
    Tuple_t *tuple;
    Typeof_t *typeexpr;
  };

  TypeData *extractAggregate( bool toplevel = true ) const;
  /* helper function for DeclNodeImpl::build */
  Declaration * buildDecl( std::string name, Declaration::StorageClass sc, Expression *bitfieldWidth, bool isInline, LinkageSpec::Type linkage, Initializer *init = 0 ) const;
  /* helper functions for build() */
  Type::Qualifiers buildQualifiers() const;
  Type *buildBasicType() const;
  PointerType * buildPointer() const;
  ArrayType * buildArray() const;
  AggregateDecl * buildAggregate() const;
  ReferenceToType * buildAggInst() const;
  NamedTypeDecl * buildSymbolic( const std::string &name, Declaration::StorageClass sc ) const;
  TypeDecl* buildVariable() const;
  EnumDecl* buildEnum() const;
  TypeInstType * buildSymbolicInst() const;
  TupleType * buildTuple() const;
  TypeofType * buildTypeof() const;
};

#endif /* #ifndef TYPEDATA_H */