//
// Copyright (c) 2002 by Stephen C. Dewhurst
// Permission to use, copy, modify, distribute and sell this software for any purpose is
// hereby granted without fee, provided that the above copyright notice appears in all copies
// and that both that copyright notice and this permission notice appear in supporting documentation.
// The author makes no representations about the suitability of this software for any purpose.
// It is provided "as is" without express or implied warranty.
//

// "typeof" operator implementation
//
// Described in CUJ 20(8, 10, and 12), August, October, and December 2002:  "A Bit-Wise Typeof"
// This version is a re-write of the original implementation that employs the typeint implementation
// of extended precision compile time arithmetic.  Typeints are described in CUJ online experts
// column, February 2003.
// 
#ifndef GENGN_H
#define GENGN_H

#include "utils.h"
#include "typeint.h"

#include <limits>

typedef unsigned short Code;
const Code CodeLen = std::numeric_limits<Code>::digits;

#define MASK( n ) (((1<<((n)-1))-1)|(1<<((n)-1)))

const Code NumCodes = 4;
const Code CodeMax = MASK(CodeLen);
const Code CodeMask = CodeMax;

//
// Godel numbering approximation
//

const Code BaseLen = 6;
const Code BaseMax = (1<<BaseLen)-1;
const Code BaseMask = MASK(BaseLen);
typedef TypeInt<BaseMask>::R BaseMaskT;
const Code QualBaseLen = BaseLen+2;
#define ISBASECODE( n ) ((n)<(1<<QualBaseLen))
const Code QualBaseMax = (1<<QualBaseLen)-1;
const Code ConstBasePos = BaseLen;
const Code ConstBaseQual = 1 << ConstBasePos;
typedef TypeInt<ConstBaseQual>::R ConstBaseQualT;
const Code VolBasePos = ConstBasePos+1;
const Code VolBaseQual = 1 << VolBasePos;
typedef TypeInt<VolBaseQual>::R VolBaseQualT;
const Code ModLen = 8;
const Code ModMask = MASK(ModLen);
typedef TypeInt<ModMask>::R ModMaskT;
const Code ArrayboundLen = 8;
const Code ArrayboundMask = MASK(ArrayboundLen);
typedef TypeInt<ArrayboundMask>::R ArrayboundMaskT;
const Code ArgcountLen = 2;
const Code MaxArgs = 1;
const Code ArglenLen = 6;

enum BaseTypeCodes {
	BoolVal = 1,
	CharVal,
	UCharVal,
	SCharVal,
	ShortVal,
	UShortVal,
	IntVal,
	UIntVal,
	LongVal,
	ULongVal,
	FloatVal,
	DoubleVal,
	LDoubleVal,
	VoidVal,
	FirstUnreservedTypeVal
};

enum ModifierCodes {
	Ptr = 0x01,
	Ref = 0x02,
	Ary = 0x03,
	Pcm = 0x04,
	Fun = 0x05,
	PcmFun0 = 0x06,
	PcmFun0C = 0x07,
	PcmFun0V = 0x09,
	PcmFun0CV = 0x0A,
	PcmFun1 = 0x0B,
	PcmFun1C = 0x0C,
	PcmFun1V = 0x0D,
	PcmFun1CV = 0x0E,
	Const = 0x40,
	Vol = 0x80
};

// TypeInt versions of modifier codes
typedef TypeInt<Ptr>::R PtrT;
typedef TypeInt<Ptr+Const>::R CPtrT;
typedef TypeInt<Ptr+Vol>::R VPtrT;
typedef TypeInt<Ptr+Const+Vol>::R CVPtrT;
typedef TypeInt<Ref>::R RefT;
typedef TypeInt<Ary>::R AryT;
typedef TypeInt<Pcm>::R PcmT;
typedef TypeInt<Pcm+Const>::R CPcmT;
typedef TypeInt<Pcm+Vol>::R VPcmT;
typedef TypeInt<Pcm+Const+Vol>::R CVPcmT;
typedef TypeInt<Fun>::R FunT;
typedef TypeInt<PcmFun0>::R PcmFun0T;
typedef TypeInt<PcmFun0C>::R PcmFun0CT;
typedef TypeInt<PcmFun0V>::R PcmFun0VT;
typedef TypeInt<PcmFun0CV>::R PcmFun0CVT;
typedef TypeInt<PcmFun1>::R PcmFun1T;
typedef TypeInt<PcmFun1C>::R PcmFun1CT;
typedef TypeInt<PcmFun1V>::R PcmFun1VT;
typedef TypeInt<PcmFun1CV>::R PcmFun1CVT;
typedef TypeInt<Const>::R ConstT;
typedef TypeInt<Vol>::R VolT;

const Code QualMask = Const+Vol;

//
//	"Round trip" generation of registered base types.
//	TypeCode turns type into integer, DeCode turns integer back into type.
//
template <class T>
struct TypeCode;

template <Code code>
struct DeCode;

// Special handling for void, due to inability to declare void &.
Int2Int<VoidVal> typeCode( void );
template <>
struct TypeCode<void> {
	enum { value = VoidVal };
};

template <> struct DeCode<VoidVal>
	{ typedef void R; };

#define REGISTER( T, N )\
	Int2Int<N>\
	typeCode(T &);\
	template <>\
	struct TypeCode<T> {\
		enum { value = N };\
	};\
	template <>\
	struct DeCode<N> {\
		typedef T R;\
	}

// Pre-registration of built-in types.
// Users are responsible for registering user-defined types.
REGISTER( bool, BoolVal );
REGISTER( char, CharVal );
REGISTER( unsigned char, UCharVal );
REGISTER( signed char, SCharVal );
REGISTER( short, ShortVal );
REGISTER( unsigned short, UShortVal );
REGISTER( int, IntVal );
REGISTER( unsigned int, UIntVal );
REGISTER( long, LongVal );
REGISTER( unsigned long, ULongVal );
REGISTER( float, FloatVal );
REGISTER( double, DoubleVal );
REGISTER( long double, LDoubleVal );

template <class T>
struct BaseType {
	typedef typename DeQual<T>::R S;
	enum {
		base = TypeCode<S>::value,
		code = base
			| (IsConst<T>::r << ConstBasePos)
			| (IsVol<T>::r << VolBasePos),
		len = QualBaseLen
	};
	typedef typename TypeInt<code>::R Code;
};		

template <class T>
struct GN {
	enum { len = BaseType<T>::len };
	typedef typename BaseType<T>::Code Code;
};

template <class T>
struct GN<T *> {
	enum { len = GN<T>::len+ModLen };
	typedef typename Or<typename LShift<typename GN<T>::Code,ModLen>::R,PtrT>::R Code;
};

template <class T>
struct GN<T * const> {
	enum { len = GN<T>::len+ModLen };
	typedef typename GN<T>::Code T1;
	typedef typename LShift<T1,ModLen>::R T2;
	typedef typename Or<T2,CPtrT>::R Code;
};

template <class T>
struct GN<T * volatile> {
	enum { len = GN<T>::len+ModLen };
	typedef typename GN<T>::Code T1;
	typedef typename LShift<T1,ModLen>::R T2;
	typedef typename Or<T2,VPtrT>::R Code;
};

template <class T>
struct GN<T * const volatile> {
	enum { len = GN<T>::len+ModLen };
	typedef typename GN<T>::Code T1;
	typedef typename LShift<T1,ModLen>::R T2;
	typedef typename Or<T2,CVPtrT>::R Code;
};

template <class T>
struct GN<T &> {
	enum { len = GN<T>::len+ModLen };
	typedef typename GN<T>::Code T1;
	typedef typename LShift<T1,ModLen>::R T2;
	typedef typename Or<T2,RefT>::R Code;
};

template <class T, int N>
struct GN<T [N]> {
	enum { len = GN<T>::len+ArrayboundLen+ModLen };
	typedef typename GN<T>::Code T1;
	typedef typename LShift<T1,ArrayboundLen+ModLen>::R T2;
	typedef typename TypeInt<((ArrayboundMask&N)<<ModLen) | Ary>::R T3;
	typedef typename Or<T2,T3>::R Code;
};

template <typename R>
struct GN<R (void)> {
	enum { len = GN<R>::len+ArgcountLen+ModLen };
	typedef typename GN<R>::Code T1;
	typedef typename LShift<T1,ArgcountLen+ModLen>::R T2;
	typedef typename Or<T2,FunT>::R Code;
};

template <typename R, typename A>
struct GN<R (A)> {
	typedef R RetType;
	typedef A ArgType;
	typedef R FuncType( A );
	enum {
		// calculate lengths and shift amounts
		argshift = ArglenLen+ArgcountLen+ModLen,
		arglen = GN<ArgType>::len,
		retshift = arglen+argshift,
		retlen = GN<RetType>::len,
		len = retlen+arglen+ArglenLen+ArgcountLen+ModLen
	};
	//typedef typename GN<R>::Code Ret; // GN for return type
	//typedef typename GN<A>::Code Arg; // GN for argument type
	//typedef typename LShift<Arg,argshift>::R SA; // shift arg to proper position
	//typedef typename LShift<Ret,retshift>::R SR; // shift ret to proper position
	//typedef typename Or<SR,SA>::R T1; // or them together
	//typedef typename TypeInt<(arglen<<(ArgcountLen+ModLen)) | (1<<ModLen) | Fun>::R T2; // gen code for function modifier, etc.
	//typedef typename Or<T1,T2>::R Code; // or modifier into previous result
	
	typedef typename Or<typename Or<typename LShift<typename GN<R>::Code,retshift>::R,typename LShift<typename GN<A>::Code,argshift>::R>::R,typename TypeInt<(arglen<<(ArgcountLen+ModLen)) | (1<<ModLen) | Fun>::R>::R Code;
};

template <typename T, class C>
struct GN<T C::*> {
	enum {
		// Note class type is not qualified: BaseLen, not QualBaseLen, TypeCode, not GN or BaseType.
		len = GN<T>::len+BaseLen+ModLen
	};
	typedef typename GN<T>::Code T1;
	typedef typename LShift<T1,BaseLen+ModLen>::R T2;
	typedef typename Or<T2,typename TypeInt<TypeCode<C>::value<<ModLen>::R>::R T3;
	typedef typename Or<T3,PcmT>::R Code;
};

//====== COMMENT OUT THIS BLOCK FOR METROWERKS

template <typename T, class C>
struct GN<T C::* const> {
	enum { len = GN<T>::len+BaseLen+ModLen };
	typedef typename GN<T>::Code T1;
	typedef typename LShift<T1,BaseLen+ModLen>::R T2;
	typedef typename Or<T2,typename TypeInt<TypeCode<C>::value<<ModLen>::R>::R T3;
	typedef typename Or<T3,CPcmT>::R Code;
};

template <typename T, class C>
struct GN<T C::* volatile> {
	enum { len = GN<T>::len+BaseLen+ModLen };
	typedef typename GN<T>::Code T1;
	typedef typename LShift<T1,BaseLen+ModLen>::R T2;
	typedef typename Or<T2,typename TypeInt<TypeCode<C>::value<<ModLen>::R>::R T3;
	typedef typename Or<T3,VPcmT>::R Code;
};

template <typename T, class C>
struct GN<T C::* const volatile> {
	enum { len = GN<T>::len+BaseLen+ModLen };
	typedef typename GN<T>::Code T1;
	typedef typename LShift<T1,BaseLen+ModLen>::R T2;
	typedef typename Or<T2,typename TypeInt<TypeCode<C>::value<<ModLen>::R>::R T3;
	typedef typename Or<T3,CVPcmT>::R Code;
};

//	Note that a member function is a very different beast from
//	a non-member function, so we have to special-case for them.
//	However, we can leverage much of our implementation of non-member
//	functions if we're careful.
//	Note also that (for pedegogic reasons?) we've taken a different tack
//	with the implementation of pointers to member functions.  We're being
//	more "combinatorial" here, with different modifier codes for each number
//	of arguments and each cv-qualifer combination.  This does cause
//	something of a "combinatorial explosion" when combined with the possible
//	cv-qualifiers of the pointer to member itself (4*4*(max_#_args+1)).
//	This can be improved by factoring the templates, which I'll get around to some day...
//	Laziness compelled me to permit only unqualified pointers to member
//	function below, though the member functions themselves may be qualified.

template <typename R, class C>
struct GN<R (C::*)(void)> {
	typedef R M();
	typedef GN<M> GNM;
	typedef typename GNM::Code T1;
	typedef typename LShift<T1,BaseLen+ModLen>::R T2;
	typedef typename Or<T2,typename TypeInt<TypeCode<C>::r<<ModLen>::R>::R T3;
	typedef typename Or<T3,PcmFun0T>::R Code;
	enum { len = GNM::len+BaseLen+ModLen };
	
};

template <typename R, class C>
struct GN<R (C::*)(void) const> {
	typedef GN<R (C::*)(void)> GNMF;
	typedef typename GNMF::Code T1;
	enum { len = GNMF::len };
	typedef typename Xor<T1,PcmFun0T>::R T2;
	typedef typename Or<T2,PcmFun0CT>::R Code;
};

template <typename R, class C>
struct GN<R (C::*)(void) volatile> {
	typedef GN<R (C::*)(void)> GNMF;
	typedef typename GNMF::Code T1;
	enum { len = GNMF::len };
	typedef typename Xor<T1,PcmFun0T>::R T2;
	typedef typename Or<T2,PcmFun0VT>::R Code;
};

template <typename R, class C>
struct GN<R (C::*)(void) const volatile> {
	typedef GN<R (C::*)(void)> GNMF;
	typedef typename GNMF::Code T1;
	enum { len = GNMF::len };
	typedef typename Xor<T1,PcmFun0T>::R T2;
	typedef typename Or<T2,PcmFun0CVT>::R Code;
};

template <typename R, typename A, class C>
struct GN<R (C::*)(A)> {
	typedef R Ret;
	typedef A Arg;
	typedef R M(A);
	typedef typename GN<M>::Code T1;
	typedef typename LShift<Code,BaseLen+ModLen>::R T2;
	typedef typename Or<T2,typename TypeInt<TypeCode<C>::r<<ModLen>::R>::R T3;
	typedef typename Or<T3,PcmFun1T>::R Code;
	enum { len = T1::len+BaseLen+ModLen };
};

template <typename R, typename A, class C>
struct GN<R (C::*)(A) const> {
	typedef GN<R (C::*)(A)> GNMF;
	typedef typename GNMF::Code T1;
	typedef typename Xor<T1,PcmFun1T>::R T2;
	typedef typename Or<T2,PcmFun1CT>::R Code;
	enum { len = GNMF::len };
};

template <typename R, typename A, class C>
struct GN<R (C::*)(A) volatile> {
	typedef GN<R (C::*)(A)> GNMF;
	typedef typename GNMF::Code T1;
	typedef typename Xor<T1,PcmFun1T>::R T2;
	typedef typename Or<T2,PcmFun1VT>::R Code;
	enum { len = GNMF::len };
};

template <typename R, typename A, class C>
struct GN<R (C::*)(A) const volatile> {
	typedef GN<R (C::*)(A)> GNMF;
	typedef typename GNMF::Code T1;
	typedef typename Xor<T1,PcmFun1T>::R T2;
	typedef typename Or<T2,PcmFun1CVT>::R Code;
	enum { len = GNMF::len };
};

//===================  END OF METROWERKS COMMENT OUT

const int nb = CodeLen;

typedef TypeInt<(1<<nb)-1>::R Mask;

#define V( T, n ) (Value<typename And<typename RShift<typename GN<T>::Code,(n)*nb>::R,Mask>::R>::r)
#define Vv( n ) (Value<And<RShift<GN<void>::Code,(n)*nb>::R,Mask>::R>::r)

char (*genGN1( void ))[Vv(0)+1]; // no definition
char (*genGN2( void ))[Vv(1)+1];
char (*genGN3( void ))[Vv(2)+1];
char (*genGN4( void ))[Vv(3)+1];

template <typename T>
char (*genGN1( T & ))[V(T,0)+1]; // no definition

template <typename T>
char (*genGN2( T & ))[V(T,1)+1];
	
template <typename T>
char (*genGN3( T & ))[V(T,2)+1];
	
template <typename T>
char (*genGN4( T & ))[V(T,3)+1];


#endif