//
// 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 or 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"
// 
#ifndef GENGN_H
#define GENGN_H

#include "multishift.h"
#include "utils.h"

//
// Godel numbering approximation
//

const Code BaseLen = 6;
const Code BaseMax = (1<<BaseLen)-1;
const Code BaseMask = MASK(BaseLen);
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;
const Code VolBasePos = ConstBasePos+1;
const Code VolBaseQual = 1 << VolBasePos;
const Code ModLen = 8;
const Code ModMask = MASK(ModLen);
const Code ArrayboundLen = 8;
const Code ArrayboundMask = MASK(ArrayboundLen);
const Code ArgcountLen = 2;
const Code MaxArgs = 1;
const Code ArglenLen = 6;

// This is a check to make sure the Godel number for a type can
// fit in the multipart integer.
#define GODEL_NUMBER_LENGTH_CHECK(n) char godel_number_length_check[NumCodes*CodeLen-(n)+1]

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
};

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>::result << ConstBasePos)
			| (IsVol<T>::result << VolBasePos),
		len = QualBaseLen
	};
	GODEL_NUMBER_LENGTH_CHECK(len);
};		

template <class T>
struct GN {
	enum {
		code4 = 0,
		code3 = 0,
		code2 = 0,
		code1 = BaseType<T>::code,
		len = BaseType<T>::len
	};
	GODEL_NUMBER_LENGTH_CHECK(len);
};

template <class T>
struct GN<T *> {
	typedef GN<T> GNT;
	enum {
		c1 = GNT::code1,
		c2 = GNT::code2,
		c3 = GNT::code3,
		c4 = GNT::code4
	};
	typedef ShiftLeft<c4,c3,c2,c1,ModLen> SL;
	enum {
		code4 = SL::code4,
		code3 = SL::code3,
		code2 = SL::code2,
		code1 = SL::code1 | Ptr,
		len = GNT::len+ModLen
	};
	GODEL_NUMBER_LENGTH_CHECK(len);
};

template <class T>
struct GN<T * const> {
	typedef GN<T *> GNTS;
	enum {
		code4 = GNTS::code4,
		code3 = GNTS::code3,
		code2 = GNTS::code2,
		code1 = GNTS::code1 | Const,
		len = GNTS::len
	};
};

template <class T>
struct GN<T * volatile> {
	typedef GN<T *> GNTS;
	enum {
		code4 = GNTS::code4,
		code3 = GNTS::code3,
		code2 = GNTS::code2,
		code1 = GNTS::code1 | Vol,
		len = GNTS::len
	};
};

template <class T>
struct GN<T * const volatile> {
	typedef GN<T *> GNTS;
	enum {
		code4 = GNTS::code4,
		code3 = GNTS::code3,
		code2 = GNTS::code2,
		code1 = GNTS::code1 | Const+Vol,
		len = GNTS::len
	};
};

template <class T>
struct GN<T &> {
	typedef GN<T> GNT;
	enum {
		c1 = GNT::code1,
		c2 = GNT::code2,
		c3 = GNT::code3,
		c4 = GNT::code4
	};
	typedef ShiftLeft<c4,c3,c2,c1,ModLen> SL;
	enum {
		code4 = SL::code4,
		code3 = SL::code3,
		code2 = SL::code2,
		code1 = SL::code1 | Ref,
		len = GNT::len+ModLen
	};
	GODEL_NUMBER_LENGTH_CHECK(len);
};

template <class T, int N>
struct GN<T [N]> {
	typedef GN<T> GNT;
	enum {
		c1 = GNT::code1,
		c2 = GNT::code2,
		c3 = GNT::code3,
		c4 = GNT::code4
	};
	typedef ShiftLeft<c4,c3,c2,c1,ArrayboundLen+ModLen> SL;
	enum {
		code4 = SL::code4,
		code3 = SL::code3,
		code2 = SL::code2,
		code1 = SL::code1 | ((ArrayboundMask&N)<<ModLen) | Ary,
		len = GNT::len+ArrayboundLen+ModLen
	};
	GODEL_NUMBER_LENGTH_CHECK(len);
};

template <typename R>
struct GN<R (void)> {
	typedef GN<R> GNR;
	enum {
		c1 = GNR::code1,
		c2 = GNR::code2,
		c3 = GNR::code3,
		c4 = GNR::code4
	};
	typedef ShiftLeft<c4,c3,c2,c1,ArgcountLen+ModLen> SL;
	enum {
		code4 = SL::code4,
		code3 = SL::code3,
		code2 = SL::code2,
		code1 = SL::code1 | 0 | Fun,
		len = GNR::len+ArgcountLen+ModLen
	};
	GODEL_NUMBER_LENGTH_CHECK(len);
};

template <typename R, typename A>
struct GN<R (A)> {
	typedef R RetType;
	typedef A ArgType;
	typedef R FuncType( A );
	
	typedef GN<A> GNA;
	typedef GN<R> GNR;
	enum {
		argshift = ArglenLen+ArgcountLen+ModLen,
		arglen = GNA::len,
		
		// get code for return type
		retshift = arglen+argshift,
		r1 = GNR::code1,
		r2 = GNR::code2,
		r3 = GNR::code3,
		r4 = GNR::code4,
		retlen = GNR::len,
		
		// get code for arg type
		a1 = GNA::code1,
		a2 = GNA::code2,
		a3 = GNA::code3,
		a4 = GNA::code4
	};
	typedef ShiftLeft<a4,a3,a2,a1,argshift> SLA;
	typedef ShiftLeft<r4,r3,r2,r1,retshift> SLR;
	enum {
		// shift arg type
		sa4 = SLA::code4,
		sa3 = SLA::code3,
		sa2 = SLA::code2,
		sa1 = SLA::code1,
		
		// shift return type
		sr4 = SLR::code4,
		sr3 = SLR::code3,
		sr2 = SLR::code2,
		sr1 = SLR::code1,
		
		// paste everything together
		code4 = sr4 | sa4,
		code3 = sr3 | sa3,
		code2 = sr2 | sa2,
		// note assumption below that ArgcountLen+Modlen < number of bits in Code!
		code1 = sr1 | sa1 | (arglen<<(ArgcountLen+ModLen)) | (1<<ModLen) | Fun,
		
		// calculate total length
		len = retlen+arglen+ArglenLen+ArgcountLen+ModLen
	};
	GODEL_NUMBER_LENGTH_CHECK(len);
};

template <typename T, class C>
struct GN<T C::*> {
	typedef GN<T> GNT;
	enum {
		// Note class type is not qualified: BaseLen, not QualBaseLen, TypeCode, not GN or BaseType.
		c1 = GNT::code1,
		c2 = GNT::code2,
		c3 = GNT::code3,
		c4 = GNT::code4
	};
	typedef ShiftLeft<c4,c3,c2,c1,BaseLen+ModLen> SL;
	enum {
		code4 = SL::code4,
		code3 = SL::code3,
		code2 = SL::code2,
		code1 = SL::code1 | (TypeCode<C>::value<<ModLen) | Pcm,
		len = GNT::len+BaseLen+ModLen
	};
	GODEL_NUMBER_LENGTH_CHECK(len);
};

template <typename T, class C>
struct GN<T C::* const> {
	typedef GN<T C::*> GNTPM;
	enum {
		code4 = GNTPM::code4,
		code3 = GNTPM::code3,
		code2 = GNTPM::code2,
		code1 = GNTPM::code1 | Const,
		len = GNTPM::len
	};
};

template <typename T, class C>
struct GN<T C::* volatile> {
	typedef GN<T C::*> GNTPM;
	enum {
		code4 = GNTPM::code4,
		code3 = GNTPM::code3,
		code2 = GNTPM::code2,
		code1 = GNTPM::code1 | Vol,
		len = GNTPM::len
	};
};

template <typename T, class C>
struct GN<T C::* const volatile> {
	typedef GN<T C::*> GNTPM;
	enum {
		code4 = GNTPM::code4,
		code3 = GNTPM::code3,
		code2 = GNTPM::code2,
		code1 = GNTPM::code1 | Const+Vol,
		len = GNTPM::len
	};
};

//	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;
	enum {
		// Note class type is not qualified: BaseLen, not QualBaseLen, TypeCode, not GN or BaseType.
		c1 = GNM::code1, // could change this to memfun, add cv-quals
		c2 = GNM::code2,
		c3 = GNM::code3,
		c4 = GNM::code4
	};
	typedef ShiftLeft<c4,c3,c2,c1,BaseLen+ModLen> SL;
	enum {
		code4 = SL::code4,
		code3 = SL::code3,
		code2 = SL::code2,
		code1 = SL::code1 | (TypeCode<C>::value<<ModLen) | PcmFun0,
		len = GNM::len+BaseLen+ModLen
	};
	GODEL_NUMBER_LENGTH_CHECK(len);
};

template <typename R, class C>
struct GN<R (C::*)(void) const> {
	typedef GN<R (C::*)(void)> GNMF;
	enum {
		code4 = GNMF::code4,
		code3 = GNMF::code3,
		code2 = GNMF::code2,
		code1 = (GNMF::code1 ^ PcmFun0) | PcmFun0C, // replace existing modifier
		len = GNMF::len
	};
};

template <typename R, class C>
struct GN<R (C::*)(void) volatile> {
	typedef GN<R (C::*)(void)> GNMF;
	enum {
		code4 = GNMF::code4,
		code3 = GNMF::code3,
		code2 = GNMF::code2,
		code1 = (GNMF::code1 ^ PcmFun0) | PcmFun0V,
		len = GNMF::len
	};
};

template <typename R, class C>
struct GN<R (C::*)(void) const volatile> {
	typedef GN<R (C::*)(void)> GNMF;
	enum {
		code4 = GNMF::code4,
		code3 = GNMF::code3,
		code2 = GNMF::code2,
		code1 = (GNMF::code1 ^ PcmFun0) | PcmFun0CV,
		len = GNMF::len
	};
};

template <typename R, typename A, class C>
struct GN<R (C::*)(A)> {
	typedef R Ret;
	typedef A Arg;
	typedef R M(A);
	typedef GN<M> GNM;
	enum {
		// Note class type is not qualified: BaseLen, not QualBaseLen, TypeCode, not GN or BaseType.
		c1 = GNM::code1,
		c2 = GNM::code2,
		c3 = GNM::code3,
		c4 = GNM::code4
	};
	typedef ShiftLeft<c4,c3,c2,c1,BaseLen+ModLen> SL;
	enum {
		code4 = SL::code4,
		code3 = SL::code3,
		code2 = SL::code2,
		code1 = SL::code1 | (TypeCode<C>::value<<ModLen) | PcmFun1,
		len = GNM::len+BaseLen+ModLen
	};
	GODEL_NUMBER_LENGTH_CHECK(len);

};

template <typename R, typename A, class C>
struct GN<R (C::*)(A) const> {
	typedef GN<R (C::*)(A)> GNMF;
	enum {
		code4 = GNMF::code4,
		code3 = GNMF::code3,
		code2 = GNMF::code2,
		code1 = (GNMF::code1 ^ PcmFun1) | PcmFun1C,
		len = GNMF::len
	};
};

template <typename R, typename A, class C>
struct GN<R (C::*)(A) volatile> {
	typedef GN<R (C::*)(A)> GNMF;
	enum {
		code4 = GNMF::code4,
		code3 = GNMF::code3,
		code2 = GNMF::code2,
		code1 = (GNMF::code1 ^ PcmFun1) | PcmFun1V,
		len = GNMF::len
	};
};

template <typename R, typename A, class C>
struct GN<R (C::*)(A) const volatile> {
	typedef GN<R (C::*)(A)> GNMF;
	enum {
		code4 = GNMF::code4,
		code3 = GNMF::code3,
		code2 = GNMF::code2,
		code1 = (GNMF::code1 ^ PcmFun1) | PcmFun1CV,
		len = GNMF::len
	};
};

char (*genGN1( void ))[GN<void>::code1+1]; // no definition
char (*genGN2( void ))[GN<void>::code2+1];
char (*genGN3( void ))[GN<void>::code3+1];
char (*genGN4( void ))[GN<void>::code4+1];

template <typename T>
char (*genGN1( T & ))[GN<T>::code1+1]; // no definition
template <typename T>
char (*genGN2( T & ))[GN<T>::code2+1];
template <typename T>
char (*genGN3( T & ))[GN<T>::code3+1];
template <typename T>
char (*genGN4( T & ))[GN<T>::code4+1];

#endif