//
// 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 GENTYPE_H
#define GENTYPE_H

#include "multishift.h"

//
//	Regenerating a type from a Godel number.
//
template <Code,Code,Code,Code>
struct GenType;

template <Code mod, Code code4, Code code3, Code code2, Code code1>
struct ModSwitch;

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<Ptr,code4,code3,code2,code1> { // *
	typedef typename GenType<code4,code3,code2,code1>::GTR *MSR;
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<Ptr+Const,code4,code3,code2,code1> { // * const
	typedef typename GenType<code4,code3,code2,code1>::GTR * const MSR;
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<Ptr+Vol,code4,code3,code2,code1> { // * volatile
	typedef typename GenType<code4,code3,code2,code1>::GTR * volatile MSR;
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<Ptr+Const+Vol,code4,code3,code2,code1> { // * const volatile
	typedef typename GenType<code4,code3,code2,code1>::GTR * const volatile MSR;
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<Ref,code4,code3,code2,code1> { // &
	typedef typename GenType<code4,code3,code2,code1>::GTR &MSR;
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<Ary,code4,code3,code2,code1> { // [N]
	typedef ShiftRight<code4,code3,code2,code1,ArrayboundLen> SR;
	enum {
		bound = code1 & ArrayboundMask,
		c1 = SR::code1,
		c2 = SR::code2,
		c3 = SR::code3,
		c4 = SR::code4
	};
	typedef typename GenType<c4,c3,c2,c1>::GTR MSR[bound];
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<Pcm,code4,code3,code2,code1> { // C::*
	// Note: BaseLen, not QualBaseLen!
	typedef ShiftRight<code4,code3,code2,code1,BaseLen> SR;
	enum {
		classtype = code1 & BaseMask,
		c1 = SR::code1,
		c2 = SR::code2,
		c3 = SR::code3,
		c4 = SR::code4
	};
	typedef typename GenType<c4,c3,c2,c1>::GTR MemType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef MemType ClassType::*MSR;
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<Pcm+Const,code4,code3,code2,code1> { // C::*const
	typedef const typename ModSwitch<Pcm,code4,code3,code2,code1>::MSR MSR;
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<Pcm+Vol,code4,code3,code2,code1> { // C::*volatile
	typedef volatile typename ModSwitch<Pcm,code4,code3,code2,code1>::MSR MSR;
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<Pcm+Const+Vol,code4,code3,code2,code1> { // C::*const volatile
	typedef const volatile typename ModSwitch<Pcm,code4,code3,code2,code1>::MSR MSR;
};

template <Code argcount, Code code4, Code code3, Code code2, Code code1>
struct FunSwitch;

template <Code code4, Code code3, Code code2, Code code1>
struct FunSwitch<0,code4,code3,code2,code1> {
	typedef typename GenType<code4,code3,code2,code1>::GTR RetType;
	typedef RetType FSR(void);
};

template <Code code4, Code code3, Code code2, Code code1>
struct FunSwitch<1,code4,code3,code2,code1> {
	enum { arglen = code1 & ((1<<ArglenLen)-1) };
	typedef ShiftRight<code4,code3,code2,code1,arglen+ArglenLen> SRR;
	enum {
		rc1 = SRR::code1,
		rc2 = SRR::code2,
		rc3 = SRR::code3,
		rc4 = SRR::code4
	};
	enum { argshiftlen = (CodeLen*NumCodes)-(arglen+ArglenLen) };
	typedef ShiftLeft<code4,code3,code2,code1,argshiftlen> SL;
	enum {
		t1 = SL::code1,
		t2 = SL::code2,
		t3 = SL::code3,
		t4 = SL::code4
	};
	typedef ShiftRight<t4,t3,t2,t1,argshiftlen+ArglenLen> SRA;
	enum {
		ac1 = SRA::code1,
		ac2 = SRA::code2,
		ac3 = SRA::code3,
		ac4 = SRA::code4
	};
	typedef typename GenType<rc4,rc3,rc2,rc1>::GTR RetType;
	typedef typename GenType<ac4,ac3,ac2,ac1>::GTR ArgType;
	typedef RetType FSR( ArgType );
};
	
template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<Fun,code4,code3,code2,code1> { // ()
	typedef ShiftRight<code4,code3,code2,code1,ArgcountLen> SR;
	enum {
		argcount = code1 & ((1<<ArgcountLen)-1),
		c1 = SR::code1,
		c2 = SR::code2,
		c3 = SR::code3,
		c4 = SR::code4
	};
	typedef typename FunSwitch<argcount,c4,c3,c2,c1>::FSR MSR;
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<PcmFun0,code4,code3,code2,code1> { // R (C::*)(void)
	// Note: BaseLen, not QualBaseLen!
	enum {
		classtype = code1 & BaseMask,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 0 (arg count), and Fun mod
	};
	typedef ShiftRight<code4,code3,code2,code1,shiftamt> SR;
	enum {
		c1 = SR::code1,
		c2 = SR::code2,
		c3 = SR::code3,
		c4 = SR::code4
	};
	typedef typename FunSwitch<0,c4,c3,c2,c1>::RetType RetType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)();
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<PcmFun0C,code4,code3,code2,code1> { // R (C::*)(void) const
	// Note: BaseLen, not QualBaseLen!
	enum {
		classtype = code1 & BaseMask,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 0 (arg count), and Fun mod
	};
	typedef ShiftRight<code4,code3,code2,code1,shiftamt> SR;
	enum {
		c1 = SR::code1,
		c2 = SR::code2,
		c3 = SR::code3,
		c4 = SR::code4
	};
	typedef typename FunSwitch<0,c4,c3,c2,c1>::RetType RetType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)() const;
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<PcmFun0V,code4,code3,code2,code1> { // R (C::*)(void) volatile
	// Note: BaseLen, not QualBaseLen!
	enum {
		classtype = code1 & BaseMask,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 0 (arg count), and Fun mod
	};
	typedef ShiftRight<code4,code3,code2,code1,shiftamt> SR;
	enum {
		c1 = SR::code1,
		c2 = SR::code2,
		c3 = SR::code3,
		c4 = SR::code4
	};
	typedef typename FunSwitch<0,c4,c3,c2,c1>::RetType RetType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)() volatile;
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<PcmFun0CV,code4,code3,code2,code1> { // R (C::*)(void) const volatile
	// Note: BaseLen, not QualBaseLen!
	enum {
		classtype = code1 & BaseMask,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 0 (arg count), and Fun mod
	};
	typedef ShiftRight<code4,code3,code2,code1,shiftamt> SR;
	enum {
		c1 = SR::code1,
		c2 = SR::code2,
		c3 = SR::code3,
		c4 = SR::code4
	};
	typedef typename FunSwitch<0,c4,c3,c2,c1>::RetType RetType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)() const volatile;
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<PcmFun1,code4,code3,code2,code1> { // R (C::*)(A)
	// Note: BaseLen, not QualBaseLen!
	enum {
		classtype = code1 & BaseMask,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 1 (arg count), and Fun mod
	};
	typedef ShiftRight<code4,code3,code2,code1,shiftamt> SR;
	enum {
		c1 = SR::code1,
		c2 = SR::code2,
		c3 = SR::code3,
		c4 = SR::code4
	};
	typedef FunSwitch<1,c4,c3,c2,c1> Fun;
	typedef typename Fun::RetType RetType;
	typedef typename Fun::ArgType ArgType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)(ArgType);
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<PcmFun1C,code4,code3,code2,code1> { // R (C::*)(A) const
	// Note: BaseLen, not QualBaseLen!
	enum {
		classtype = code1 & BaseMask,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 1 (arg count), and Fun mod
	};
	typedef ShiftRight<code4,code3,code2,code1,shiftamt> SR;
	enum {
		c1 = SR::code1,
		c2 = SR::code2,
		c3 = SR::code3,
		c4 = SR::code4
	};
	typedef FunSwitch<1,c4,c3,c2,c1> Fun;
	typedef typename Fun::RetType RetType;
	typedef typename Fun::ArgType ArgType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)(ArgType) const;
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<PcmFun1V,code4,code3,code2,code1> { // R (C::*)(A) volatile
	// Note: BaseLen, not QualBaseLen!
	enum {
		classtype = code1 & BaseMask,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 1 (arg count), and Fun mod
	};
	typedef ShiftRight<code4,code3,code2,code1,shiftamt> SR;
	enum {
		c1 = SR::code1,
		c2 = SR::code2,
		c3 = SR::code3,
		c4 = SR::code4
	};
	typedef FunSwitch<1,c4,c3,c2,c1> Fun;
	typedef typename Fun::RetType RetType;
	typedef typename Fun::ArgType ArgType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)(ArgType) volatile;
};

template <Code code4, Code code3, Code code2, Code code1>
struct ModSwitch<PcmFun1CV,code4,code3,code2,code1> { // R (C::*)(A) const volatile
	// Note: BaseLen, not QualBaseLen!
	enum {
		classtype = code1 & BaseMask,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 1 (arg count), and Fun mod
	};
	typedef ShiftRight<code4,code3,code2,code1,shiftamt> SR;
	enum {
		c1 = SR::code1,
		c2 = SR::code2,
		c3 = SR::code3,
		c4 = SR::code4
	};
	typedef FunSwitch<1,c4,c3,c2,c1> Fun;
	typedef typename Fun::RetType RetType;
	typedef typename Fun::ArgType ArgType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)(ArgType) const volatile;
};

template <Code code4, Code code3, Code code2, Code code1>
struct GenModType {
	typedef ShiftRight<code4,code3,code2,code1,ModLen> SR;
	enum {
		mod = code1 & ModMask,
		c1 = SR::code1,
		c2 = SR::code2,
		c3 = SR::code3,
		c4 = SR::code4
	};
	typedef typename ModSwitch<mod,c4,c3,c2,c1>::MSR MR;
};

template <Code code>
struct GenBaseType {
	enum {
		base = code & BaseMask,
		isconst = code & ConstBaseQual,
		isvol = code & VolBaseQual
	};
	typedef typename DeCode<base>::R B;
	typedef typename Select<isconst, const B, B>::Result CB;
	typedef typename Select<isvol, volatile CB, CB>::Result VCB;
	typedef VCB R;
};

template <bool cond, Code code4, Code code3, Code code2, Code code1>
struct GenTypeImpl {
	typedef typename GenBaseType<code1>::R Result; };

template <Code code4, Code code3, Code code2, Code code1>
struct GenTypeImpl<false,code4,code3,code2,code1> {
	typedef typename GenModType<code4,code3,code2,code1>::MR Result; };

template <Code code4, Code code3, Code code2, Code code1>
struct GenType {
	// Indirection necessary to avoid instantiating both possibilities.
	typedef typename GenTypeImpl<ISBASECODE(code1), code4, code3, code2, code1>::Result GTR; };

#endif