//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// Type.h --
//
// Author           : Richard C. Bilson
// Created On       : Mon May 18 07:44:20 2015
// Last Modified By : Peter A. Buhr
// Last Modified On : Thu Feb 23 16:38:53 2017
// Update Count     : 34
//

#ifndef TYPE_H
#define TYPE_H

#include "BaseSyntaxNode.h"
#include "Mutator.h"
#include "SynTree.h"
#include "Visitor.h"
#include "Common/utility.h"

class Type : public BaseSyntaxNode {
  public:
	struct Qualifiers {
		Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ) {}
		Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ) {}

		Qualifiers &operator&=( const Qualifiers &other );
		Qualifiers &operator+=( const Qualifiers &other );
		Qualifiers &operator-=( const Qualifiers &other );
		Qualifiers operator+( const Type::Qualifiers &other );
		bool operator==( const Qualifiers &other );
		bool operator!=( const Qualifiers &other );
		bool operator<=( const Qualifiers &other );
		bool operator>=( const Qualifiers &other );
		bool operator<( const Qualifiers &other );
		bool operator>( const Qualifiers &other );
		void print( std::ostream &os, int indent = 0 ) const;

		bool isConst;
		bool isVolatile;
		bool isRestrict;
		bool isLvalue;
		bool isAtomic;
	};

	Type( const Qualifiers &tq, const std::list< Attribute * > & attributes );
	Type( const Type &other );
	virtual ~Type();

	Qualifiers &get_qualifiers() { return tq; }
	bool get_isConst() { return tq.isConst; }
	bool get_isVolatile() { return tq.isVolatile; }
	bool get_isRestrict() { return tq.isRestrict; }
	bool get_isLvalue() { return tq.isLvalue; }
	bool get_isAtomic() { return tq.isAtomic; }
	void set_isConst( bool newValue ) { tq.isConst = newValue; }
	void set_isVolatile( bool newValue ) { tq.isVolatile = newValue; }
	void set_isRestrict( bool newValue ) { tq.isRestrict = newValue; }
	void set_isLvalue( bool newValue ) { tq.isLvalue = newValue; }
	void set_isAtomic( bool newValue ) { tq.isAtomic = newValue; }

	typedef std::list<TypeDecl *> ForallList;
	ForallList& get_forall() { return forall; }

	std::list< Attribute * >& get_attributes() { return attributes; }
	const std::list< Attribute * >& get_attributes() const { return attributes; }

	/// How many elemental types are represented by this type
	virtual unsigned size() const { return 1; };
	virtual bool isVoid() const { return size() == 0; }
	virtual Type * getComponent( unsigned i ) { assertf( size() == 1 && i == 0, "Type::getComponent was called with size %d and index %d\n", size(), i ); return this; }

	virtual bool isComplete() const { return true; }

	virtual Type *clone() const = 0;
	virtual void accept( Visitor &v ) = 0;
	virtual Type *acceptMutator( Mutator &m ) = 0;
	virtual void print( std::ostream &os, int indent = 0 ) const;
  private:
	Qualifiers tq;
	ForallList forall;
	std::list< Attribute * > attributes;
};

extern Type::Qualifiers emptyQualifiers;				// no qualifiers on constants

class VoidType : public Type {
  public:
	VoidType( const Type::Qualifiers &tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );

	virtual unsigned size() const { return 0; };
	virtual bool isComplete() const { return false; }

	virtual VoidType *clone() const { return new VoidType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
	virtual void print( std::ostream &os, int indent = 0 ) const;
};

class BasicType : public Type {
  public:
	enum Kind {
		Bool,
		Char,
		SignedChar,
		UnsignedChar,
		ShortSignedInt,
		ShortUnsignedInt,
		SignedInt,
		UnsignedInt,
		LongSignedInt,
		LongUnsignedInt,
		LongLongSignedInt,
		LongLongUnsignedInt,
		Float,
		Double,
		LongDouble,
		FloatComplex,
		DoubleComplex,
		LongDoubleComplex,
		FloatImaginary,
		DoubleImaginary,
		LongDoubleImaginary,
		NUMBER_OF_BASIC_TYPES
	};

	static const char *typeNames[];						// string names for basic types, MUST MATCH with Kind

	BasicType( const Type::Qualifiers &tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );

	Kind get_kind() { return kind; }
	void set_kind( Kind newValue ) { kind = newValue; }

	virtual BasicType *clone() const { return new BasicType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
	virtual void print( std::ostream &os, int indent = 0 ) const;

	bool isInteger() const;
  private:
	Kind kind;
};

class PointerType : public Type {
  public:
	PointerType( const Type::Qualifiers &tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
	PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
	PointerType( const PointerType& );
	virtual ~PointerType();

	Type *get_base() { return base; }
	void set_base( Type *newValue ) { base = newValue; }
	Expression *get_dimension() { return dimension; }
	void set_dimension( Expression *newValue ) { dimension = newValue; }
	bool get_isVarLen() { return isVarLen; }
	void set_isVarLen( bool newValue ) { isVarLen = newValue; }
	bool get_isStatic() { return isStatic; }
	void set_isStatic( bool newValue ) { isStatic = newValue; }

	virtual PointerType *clone() const { return new PointerType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
	virtual void print( std::ostream &os, int indent = 0 ) const;
  private:
	Type *base;

	// In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
	Expression *dimension;
	bool isVarLen;
	bool isStatic;
};

class ArrayType : public Type {
  public:
	ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
	ArrayType( const ArrayType& );
	virtual ~ArrayType();

	Type *get_base() { return base; }
	void set_base( Type *newValue ) { base = newValue; }
	Expression *get_dimension() { return dimension; }
	void set_dimension( Expression *newValue ) { dimension = newValue; }
	bool get_isVarLen() { return isVarLen; }
	void set_isVarLen( bool newValue ) { isVarLen = newValue; }
	bool get_isStatic() { return isStatic; }
	void set_isStatic( bool newValue ) { isStatic = newValue; }

	virtual bool isComplete() const { return ! isVarLen; }

	virtual ArrayType *clone() const { return new ArrayType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
	virtual void print( std::ostream &os, int indent = 0 ) const;
  private:
	Type *base;
	Expression *dimension;
	bool isVarLen;
	bool isStatic;
};

class FunctionType : public Type {
  public:
	FunctionType( const Type::Qualifiers &tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
	FunctionType( const FunctionType& );
	virtual ~FunctionType();

	std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
	std::list<DeclarationWithType*> & get_parameters() { return parameters; }
	bool get_isVarArgs() const { return isVarArgs; }
	void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }

	bool isTtype() const;

	virtual FunctionType *clone() const { return new FunctionType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
	virtual void print( std::ostream &os, int indent = 0 ) const;
  private:
	std::list<DeclarationWithType*> returnVals;
	std::list<DeclarationWithType*> parameters;

	// Does the function accept a variable number of arguments following the arguments specified in the parameters list.
	// This could be because of
	// - an ellipsis in a prototype declaration
	// - an unprototyped declaration
	bool isVarArgs;
};

class ReferenceToType : public Type {
  public:
	ReferenceToType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes );
	ReferenceToType( const ReferenceToType &other );
	virtual ~ReferenceToType();

	const std::string &get_name() const { return name; }
	void set_name( std::string newValue ) { name = newValue; }
	std::list< Expression* >& get_parameters() { return parameters; }
	bool get_hoistType() const { return hoistType; }
	void set_hoistType( bool newValue ) { hoistType = newValue; }

	virtual ReferenceToType *clone() const = 0;
	virtual void accept( Visitor &v ) = 0;
	virtual Type *acceptMutator( Mutator &m ) = 0;
	virtual void print( std::ostream &os, int indent = 0 ) const;
  protected:
	virtual std::string typeString() const = 0;
	std::list< Expression* > parameters;
	std::string name;
  private:
	bool hoistType;
};

class StructInstType : public ReferenceToType {
	typedef ReferenceToType Parent;
  public:
	StructInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
	StructInstType( const Type::Qualifiers &tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
	StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}

	StructDecl *get_baseStruct() const { return baseStruct; }
	void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }

	/// Accesses generic parameters of base struct (NULL if none such)
	std::list<TypeDecl*> * get_baseParameters();

	virtual bool isComplete() const;

	/// Looks up the members of this struct named "name" and places them into "foundDecls".
	/// Clones declarations into "foundDecls", caller responsible for freeing
	void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;

	virtual StructInstType *clone() const { return new StructInstType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }

	virtual void print( std::ostream &os, int indent = 0 ) const;
  private:
	virtual std::string typeString() const;

	// this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
	// where the structure used in this type is actually defined
	StructDecl *baseStruct;
};

class UnionInstType : public ReferenceToType {
	typedef ReferenceToType Parent;
  public:
	UnionInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
	UnionInstType( const Type::Qualifiers &tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
	UnionInstType( const UnionInstType &other ) : Parent( other ), baseUnion( other.baseUnion ) {}

	UnionDecl *get_baseUnion() const { return baseUnion; }
	void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }

	/// Accesses generic parameters of base union (NULL if none such)
	std::list< TypeDecl * > * get_baseParameters();

	virtual bool isComplete() const;

	/// looks up the members of this union named "name" and places them into "foundDecls"
	/// Clones declarations into "foundDecls", caller responsible for freeing
	void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;

	virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }

	virtual void print( std::ostream &os, int indent = 0 ) const;
  private:
	virtual std::string typeString() const;

	// this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
	// where the union used in this type is actually defined
	UnionDecl *baseUnion;
};

class EnumInstType : public ReferenceToType {
	typedef ReferenceToType Parent;
  public:
	EnumInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
	EnumInstType( const Type::Qualifiers &tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
	EnumInstType( const EnumInstType &other ) : Parent( other ), baseEnum( other.baseEnum ) {}

	EnumDecl *get_baseEnum() const { return baseEnum; }
	void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }

	virtual bool isComplete() const;

	virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
  private:
	virtual std::string typeString() const;

	// this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
	// where the union used in this type is actually defined
	EnumDecl *baseEnum = nullptr;
};

class TraitInstType : public ReferenceToType {
	typedef ReferenceToType Parent;
  public:
	TraitInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
	TraitInstType( const TraitInstType &other );
	~TraitInstType();

	std::list< Declaration* >& get_members() { return members; }

	virtual bool isComplete() const;

	virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
  private:
	virtual std::string typeString() const;

	// this member is filled in by the validate pass, which instantiates the members of the correponding
	// aggregate with the actual type parameters specified for this use of the context
	std::list< Declaration* > members;
};

class TypeInstType : public ReferenceToType {
	typedef ReferenceToType Parent;
  public:
	TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
	TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
	TypeInstType( const TypeInstType &other );
	~TypeInstType();

	TypeDecl *get_baseType() const { return baseType; }
	void set_baseType( TypeDecl *newValue );
	bool get_isFtype() const { return isFtype; }
	void set_isFtype( bool newValue ) { isFtype = newValue; }

	virtual bool isComplete() const;

	virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
	virtual void print( std::ostream &os, int indent = 0 ) const;
  private:
	virtual std::string typeString() const;
	// this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
	// where the type used here is actually defined
	TypeDecl *baseType;
	bool isFtype;
};

class TupleType : public Type {
  public:
	TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
	TupleType( const TupleType& );
	virtual ~TupleType();

	typedef std::list<Type*> value_type;
	typedef value_type::iterator iterator;

	std::list<Type*>& get_types() { return types; }
	virtual unsigned size() const { return types.size(); };

	iterator begin() { return types.begin(); }
	iterator end() { return types.end(); }

	virtual Type * getComponent( unsigned i ) {
		assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
		return *(begin()+i);
	}

	// virtual bool isComplete() const { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness

	virtual TupleType *clone() const { return new TupleType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
	virtual void print( std::ostream &os, int indent = 0 ) const;
  private:
	std::list<Type*> types;
};

class TypeofType : public Type {
  public:
	TypeofType( const Type::Qualifiers &tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
	TypeofType( const TypeofType& );
	virtual ~TypeofType();

	Expression *get_expr() const { return expr; }
	void set_expr( Expression *newValue ) { expr = newValue; }

	virtual bool isComplete() const { assert( false ); return false; }

	virtual TypeofType *clone() const { return new TypeofType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
	virtual void print( std::ostream &os, int indent = 0 ) const;
  private:
	Expression *expr;
};

class AttrType : public Type {
  public:
	AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
	AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
	AttrType( const AttrType& );
	virtual ~AttrType();

	const std::string &get_name() const { return name; }
	void set_name( const std::string &newValue ) { name = newValue; }
	Expression *get_expr() const { return expr; }
	void set_expr( Expression *newValue ) { expr = newValue; }
	Type *get_type() const { return type; }
	void set_type( Type *newValue ) { type = newValue; }
	bool get_isType() const { return isType; }
	void set_isType( bool newValue ) { isType = newValue; }

	virtual bool isComplete() const { assert( false ); } // xxx - not sure what to do here

	virtual AttrType *clone() const { return new AttrType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
	virtual void print( std::ostream &os, int indent = 0 ) const;
  private:
	std::string name;
	Expression *expr;
	Type *type;
	bool isType;
};

/// Represents the GCC built-in varargs type
class VarArgsType : public Type {
  public:
	VarArgsType();
	VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );

	virtual bool isComplete() const{ return true; } // xxx - is this right?

	virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
	virtual void print( std::ostream &os, int indent = 0 ) const;
};

/// Represents a zero constant
class ZeroType : public Type {
  public:
	ZeroType();
	ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );

	virtual ZeroType *clone() const { return new ZeroType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
	virtual void print( std::ostream &os, int indent = 0 ) const;
};

/// Represents a one constant
class OneType : public Type {
  public:
	OneType();
	OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );

	virtual OneType *clone() const { return new OneType( *this ); }
	virtual void accept( Visitor &v ) { v.visit( this ); }
	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
	virtual void print( std::ostream &os, int indent = 0 ) const;
};

inline Type::Qualifiers &Type::Qualifiers::operator&=( const Type::Qualifiers &other ) {
	isConst &= other.isConst;
	isVolatile &= other.isVolatile;
	isRestrict &= other.isRestrict;
	isLvalue &= other.isLvalue;
	isAtomic &= other.isAtomic;
	return *this;
}

inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
	isConst |= other.isConst;
	isVolatile |= other.isVolatile;
	isRestrict |= other.isRestrict;
	isLvalue |= other.isLvalue;
	isAtomic |= other.isAtomic;
	return *this;
}

inline Type::Qualifiers &Type::Qualifiers::operator-=( const Type::Qualifiers &other ) {
	if ( other.isConst ) isConst = 0;
	if ( other.isVolatile ) isVolatile = 0;
	if ( other.isRestrict ) isRestrict = 0;
	if ( other.isAtomic ) isAtomic = 0;
	return *this;
}

inline Type::Qualifiers Type::Qualifiers::operator+( const Type::Qualifiers &other ) {
	Qualifiers q = other;
	q += *this;
	return q;
}

inline bool Type::Qualifiers::operator==( const Qualifiers &other ) {
	return isConst == other.isConst
		&& isVolatile == other.isVolatile
//		&& isRestrict == other.isRestrict
//		&& isLvalue == other.isLvalue
		&& isAtomic == other.isAtomic;
}

inline bool Type::Qualifiers::operator!=( const Qualifiers &other ) {
	return isConst != other.isConst
		|| isVolatile != other.isVolatile
//		|| isRestrict != other.isRestrict
//		|| isLvalue != other.isLvalue
		|| isAtomic != other.isAtomic;
}

inline bool Type::Qualifiers::operator<=( const Type::Qualifiers &other ) {
	return isConst <= other.isConst
		&& isVolatile <= other.isVolatile
//		&& isRestrict <= other.isRestrict
//		&& isLvalue >= other.isLvalue
		&& isAtomic == other.isAtomic;
}

inline bool Type::Qualifiers::operator>=( const Type::Qualifiers &other ) {
	return isConst >= other.isConst
		&& isVolatile >= other.isVolatile
//		&& isRestrict >= other.isRestrict
//		&& isLvalue <= other.isLvalue
		&& isAtomic == other.isAtomic;
}

inline bool Type::Qualifiers::operator<( const Type::Qualifiers &other ) {
	return operator!=( other ) && operator<=( other );
}

inline bool Type::Qualifiers::operator>( const Type::Qualifiers &other ) {
	return operator!=( other ) && operator>=( other );
}

std::ostream & operator<<( std::ostream & out, const Type * type );

#endif // TYPE_H

// Local Variables: //
// tab-width: 4 //
// mode: c++ //
// compile-command: "make install" //
// End: //