// Semantics Consulting's Tyr Library
// http://www.semantics.org
//
// Copyright (c) 2003 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 GENTYPE_H
#define GENTYPE_H

#include "typeint.h"

namespace Tyr {

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

template <int mod, typename Code>
struct ModSwitch;

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

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

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

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

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

template <typename Code>
struct ModSwitch<Ary,Code> { // [N]
	enum {
		bound = Value<typename And<Code,ArrayboundMaskT>::R>::r
	};
	typedef typename GenType<typename RShift<Code,ArrayboundLen>::R>::GTR MSR[bound];
};

template <typename Code>
struct ModSwitch<Pcm,Code> { // C::*
	// Note: BaseLen, not QualBaseLen!
	typedef typename GenType<typename RShift<Code,BaseLen>::R>::GTR MemType;
	typedef typename DeCode<Value<typename And<Code,BaseMaskT>::R>::r>::R ClassType;
	typedef MemType ClassType::*MSR;
};

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

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

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

template <Code argcount, typename Code>
struct FunSwitch;

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

template <typename Code>
struct FunSwitch<1,Code> {
	typedef typename TypeInt<(1<<ArglenLen)-1>::R ArglenLenMaskT;
	typedef typename And<Code,ArglenLenMaskT>::R ArgLenT;
	enum { arglen = Value<ArgLenT>::r };
	typedef typename RShift<Code,arglen>::R T1;
	
	enum { argshiftlen = (CodeLen*NumCodes)-(arglen+ArglenLen) };
	typedef typename LShift<Code,argshiftlen>::R T2;
	typedef typename RShift<T2,argshiftlen+ArglenLen>::R T3;
	
	typedef typename GenType<T1>::GTR RetType;
	typedef typename GenType<T3>::GTR ArgType;
	typedef RetType FSR( ArgType );
};
	
template <typename Code>
struct ModSwitch<Fun,Code> { // ()
	typedef typename RShift<Code,ArgcountLen>::R T1;
	typedef typename TypeInt<(1<<ArgcountLen)-1>::R ArgcountLenMaskT;
	typedef typename And<Code,ArgcountLenMaskT>::R ArgcountT;
	enum { argcount = Value<ArgcountT>::r };
	typedef typename FunSwitch<argcount,T1>::FSR MSR;
};

template <typename Code>
struct ModSwitch<PcmFun0,Code> { // R (C::*)(void)
	// Note: BaseLen, not QualBaseLen!
	typedef typename And<Code,BaseMaskT>::R ClassCode;
	enum {
		classtype = Value<ClassCode>::r,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 0 (arg count), and Fun mod
	};
	typedef typename RShift<Code,shiftamt>::R T1;
	typedef typename FunSwitch<0,T1>::RetType RetType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)();
};

template <typename Code>
struct ModSwitch<PcmFun0C,Code> { // R (C::*)(void) const
	// Note: BaseLen, not QualBaseLen!
	typedef typename And<Code,BaseMaskT>::R ClassCode;
	enum {
		classtype = Value<ClassCode>::r,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 0 (arg count), and Fun mod
	};
	typedef typename RShift<Code,shiftamt>::R T1;
	typedef typename FunSwitch<0,T1>::RetType RetType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)() const;
};

template <typename Code>
struct ModSwitch<PcmFun0V,Code> { // R (C::*)(void) volatile
	// Note: BaseLen, not QualBaseLen!
	typedef typename And<Code,BaseMaskT>::R ClassCode;
	enum {
		classtype = Value<ClassCode>::r,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 0 (arg count), and Fun mod
	};
	typedef typename RShift<Code,shiftamt>::R T1;
	typedef typename FunSwitch<0,T1>::RetType RetType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)() volatile;
};

template <typename Code>
struct ModSwitch<PcmFun0CV,Code> { // R (C::*)(void) const volatile
	// Note: BaseLen, not QualBaseLen!
	typedef typename And<Code,BaseMaskT>::R ClassCode;
	enum {
		classtype = Value<ClassCode>::r,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 0 (arg count), and Fun mod
	};
	typedef typename RShift<Code,shiftamt>::R T1;
	typedef typename FunSwitch<0,T1>::RetType RetType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)() const volatile;
};

template <typename Code>
struct ModSwitch<PcmFun1,Code> { // R (C::*)(A)
	// Note: BaseLen, not QualBaseLen!
	typedef typename And<Code,BaseMaskT>::R ClassCode;
	enum {
		classtype = Value<ClassCode>::r,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 1 (arg count), and Fun mod
	};
	typedef typename RShift<Code,shiftamt>::R T1;
	typedef FunSwitch<1,T1> Fun;
	typedef typename Fun::RetType RetType;
	typedef typename Fun::ArgType ArgType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)(ArgType);
};

template <typename Code>
struct ModSwitch<PcmFun1C,Code> { // R (C::*)(A) const
	// Note: BaseLen, not QualBaseLen!
	typedef typename And<Code,BaseMaskT>::R ClassCode;
	enum {
		classtype = Value<ClassCode>::r,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 1 (arg count), and Fun mod
	};
	typedef typename RShift<Code,shiftamt>::R T1;
	typedef FunSwitch<1,T1> Fun;
	typedef typename Fun::RetType RetType;
	typedef typename Fun::ArgType ArgType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)(ArgType) const;
};

template <typename Code>
struct ModSwitch<PcmFun1V,Code> { // R (C::*)(A) volatile
	// Note: BaseLen, not QualBaseLen!
	typedef typename And<Code,BaseMaskT>::R ClassCode;
	enum {
		classtype = Value<ClassCode>::r,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 1 (arg count), and Fun mod
	};
	typedef typename RShift<Code,shiftamt>::R T1;
	typedef FunSwitch<1,T1> Fun;
	typedef typename Fun::RetType RetType;
	typedef typename Fun::ArgType ArgType;
	typedef typename DeCode<classtype>::R ClassType;
	typedef RetType (ClassType::*MSR)(ArgType) volatile;
};

template <typename Code>
struct ModSwitch<PcmFun1CV,Code> { // R (C::*)(A) const volatile
	// Note: BaseLen, not QualBaseLen!
	typedef typename And<Code,BaseMaskT>::R ClassCode;
	enum {
		classtype = Value<ClassCode>::r,
		shiftamt = BaseLen+ArgcountLen+ModLen // pop off class code, 1 (arg count), and Fun mod
	};
	typedef typename RShift<Code,shiftamt>::R T1;
	typedef FunSwitch<1,T1> 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 <typename Code>
struct GenModType {
	enum {
		mod = Value<typename And<Code,ModMaskT>::R>::r
	};
	typedef typename ModSwitch<mod,typename RShift<Code,ModLen>::R>::MSR MR;
};

template <typename Code>
struct GenBaseType {
	enum {
		base = Value<typename And<Code,BaseMaskT>::R>::r,
		isconst = Value<typename And<Code,ConstBaseQualT>::R>::r,
		isvol = Value<typename And<Code,VolBaseQualT>::R>::r
	};
	typedef typename DeCode<base>::R B;
	typedef typename Select<isconst, const B, B>::R CB;
	typedef typename Select<isvol, volatile CB, CB>::R VCB;
	typedef VCB R;
};

template <bool cond, typename Code>
struct GenTypeImpl {
	typedef typename GenBaseType<Code>::R R;
};

template <typename Code>
struct GenTypeImpl<false,Code> {
	typedef typename GenModType<Code>::MR R;
};

template <typename Code>
struct GenType {
	// Indirection necessary to avoid instantiating both possibilities.
	//typedef typename GenTypeImpl<ISBASECODE(Code),Code>::R GTR;
	//typedef typename GenTypeImpl<Less<Code,typename TypeInt<1<<QualBaseLen>::R>::r,Code>::R GTR;
	enum {
		lhs = Value<Code>::r,
		rhs = 1<<QualBaseLen
	};
	typedef typename GenTypeImpl<(lhs<rhs),Code>::R GTR;
};

} // namespace Tyr

#endif