// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef _CONSTANT_UNION_INCLUDED_
#define _CONSTANT_UNION_INCLUDED_

#if defined(__ANDROID__) && !defined(ANDROID_HOST_BUILD) && !defined(ANDROID_NDK_BUILD)
#include "../../Common/DebugAndroid.hpp"
#else
#include <assert.h>
#endif

class ConstantUnion {
public:
	POOL_ALLOCATOR_NEW_DELETE()
	ConstantUnion()
	{
		iConst = 0;
		type = EbtVoid;
	}

	bool cast(TBasicType newType, const ConstantUnion &constant)
	{
		switch (newType)
		{
		case EbtFloat:
			switch (constant.type)
			{
			case EbtInt:   setFConst(static_cast<float>(constant.getIConst())); break;
			case EbtUInt:  setFConst(static_cast<float>(constant.getUConst())); break;
			case EbtBool:  setFConst(static_cast<float>(constant.getBConst())); break;
			case EbtFloat: setFConst(static_cast<float>(constant.getFConst())); break;
			default:       return false;
			}
			break;
		case EbtInt:
			switch (constant.type)
			{
			case EbtInt:   setIConst(static_cast<int>(constant.getIConst())); break;
			case EbtUInt:  setIConst(static_cast<int>(constant.getUConst())); break;
			case EbtBool:  setIConst(static_cast<int>(constant.getBConst())); break;
			case EbtFloat: setIConst(static_cast<int>(constant.getFConst())); break;
			default:       return false;
			}
			break;
		case EbtUInt:
			switch (constant.type)
			{
			case EbtInt:   setUConst(static_cast<unsigned int>(constant.getIConst())); break;
			case EbtUInt:  setUConst(static_cast<unsigned int>(constant.getUConst())); break;
			case EbtBool:  setUConst(static_cast<unsigned int>(constant.getBConst())); break;
			case EbtFloat: setUConst(static_cast<unsigned int>(constant.getFConst())); break;
			default:       return false;
			}
			break;
		case EbtBool:
			switch (constant.type)
			{
			case EbtInt:   setBConst(constant.getIConst() != 0);    break;
			case EbtUInt:  setBConst(constant.getUConst() != 0);    break;
			case EbtBool:  setBConst(constant.getBConst());         break;
			case EbtFloat: setBConst(constant.getFConst() != 0.0f); break;
			default:       return false;
			}
			break;
		case EbtStruct:    // Struct fields don't get cast
			switch (constant.type)
			{
			case EbtInt:   setIConst(constant.getIConst()); break;
			case EbtUInt:  setUConst(constant.getUConst()); break;
			case EbtBool:  setBConst(constant.getBConst()); break;
			case EbtFloat: setFConst(constant.getFConst()); break;
			default:       return false;
			}
			break;
		default:
			return false;
		}

		return true;
	}

	void setIConst(int i) {iConst = i; type = EbtInt; }
	void setUConst(unsigned int u) { uConst = u; type = EbtUInt; }
	void setFConst(float f) {fConst = f; type = EbtFloat; }
	void setBConst(bool b) {bConst = b; type = EbtBool; }

	int getIConst() const { return iConst; }
	unsigned int getUConst() const { return uConst; }
	float getFConst() const { return fConst; }
	bool getBConst() const { return bConst; }

	float getAsFloat() const
	{
		const int FFFFFFFFh = 0xFFFFFFFF;

		switch(type)
		{
		case EbtInt:   return reinterpret_cast<const float&>(iConst);
		case EbtUInt:  return reinterpret_cast<const float&>(uConst);
		case EbtFloat: return fConst;
		case EbtBool:  return (bConst == true) ? reinterpret_cast<const float&>(FFFFFFFFh) : 0;
		default:       return 0;
		}
	}

	bool operator==(const int i) const
	{
		return i == iConst;
	}

	bool operator==(const unsigned int u) const
	{
		return u == uConst;
	}

	bool operator==(const float f) const
	{
		return f == fConst;
	}

	bool operator==(const bool b) const
	{
		return b == bConst;
	}

	bool operator==(const ConstantUnion& constant) const
	{
		if (constant.type != type)
			return false;

		switch (type) {
		case EbtInt:
			return constant.iConst == iConst;
		case EbtUInt:
			return constant.uConst == uConst;
		case EbtFloat:
			return constant.fConst == fConst;
		case EbtBool:
			return constant.bConst == bConst;
		default:
			return false;
		}
	}

	bool operator!=(const int i) const
	{
		return !operator==(i);
	}

	bool operator!=(const unsigned int u) const
	{
		return !operator==(u);
	}

	bool operator!=(const float f) const
	{
		return !operator==(f);
	}

	bool operator!=(const bool b) const
	{
		return !operator==(b);
	}

	bool operator!=(const ConstantUnion& constant) const
	{
		return !operator==(constant);
	}

	bool operator>(const ConstantUnion& constant) const
	{
		assert(type == constant.type);
		switch (type) {
		case EbtInt:
			return iConst > constant.iConst;
		case EbtUInt:
			return uConst > constant.uConst;
		case EbtFloat:
			return fConst > constant.fConst;
		default:
			return false;   // Invalid operation, handled at semantic analysis
		}
	}

	bool operator<(const ConstantUnion& constant) const
	{
		assert(type == constant.type);
		switch (type) {
		case EbtInt:
			return iConst < constant.iConst;
		case EbtUInt:
			return uConst < constant.uConst;
		case EbtFloat:
			return fConst < constant.fConst;
		default:
			return false;   // Invalid operation, handled at semantic analysis
		}
	}

	bool operator<=(const ConstantUnion& constant) const
	{
		assert(type == constant.type);
		switch (type) {
		case EbtInt:
			return iConst <= constant.iConst;
		case EbtUInt:
			return uConst <= constant.uConst;
		case EbtFloat:
			return fConst <= constant.fConst;
		default:
			return false;   // Invalid operation, handled at semantic analysis
		}
	}

	bool operator>=(const ConstantUnion& constant) const
	{
		assert(type == constant.type);
		switch (type) {
		case EbtInt:
			return iConst >= constant.iConst;
		case EbtUInt:
			return uConst >= constant.uConst;
		case EbtFloat:
			return fConst >= constant.fConst;
		default:
			return false;   // Invalid operation, handled at semantic analysis
		}
	}

	ConstantUnion operator+(const ConstantUnion& constant) const
	{
		ConstantUnion returnValue;
		assert(type == constant.type);
		switch (type) {
		case EbtInt: returnValue.setIConst(iConst + constant.iConst); break;
		case EbtUInt: returnValue.setUConst(uConst + constant.uConst); break;
		case EbtFloat: returnValue.setFConst(fConst + constant.fConst); break;
		default: assert(false && "Default missing");
		}

		return returnValue;
	}

	ConstantUnion operator-(const ConstantUnion& constant) const
	{
		ConstantUnion returnValue;
		assert(type == constant.type);
		switch (type) {
		case EbtInt: returnValue.setIConst(iConst - constant.iConst); break;
		case EbtUInt: returnValue.setUConst(uConst - constant.uConst); break;
		case EbtFloat: returnValue.setFConst(fConst - constant.fConst); break;
		default: assert(false && "Default missing");
		}

		return returnValue;
	}

	ConstantUnion operator*(const ConstantUnion& constant) const
	{
		ConstantUnion returnValue;
		assert(type == constant.type);
		switch (type) {
		case EbtInt: returnValue.setIConst(iConst * constant.iConst); break;
		case EbtUInt: returnValue.setUConst(uConst * constant.uConst); break;
		case EbtFloat: returnValue.setFConst(fConst * constant.fConst); break;
		default: assert(false && "Default missing");
		}

		return returnValue;
	}

	ConstantUnion operator%(const ConstantUnion& constant) const
	{
		ConstantUnion returnValue;
		assert(type == constant.type);
		switch (type) {
		case EbtInt: returnValue.setIConst(iConst % constant.iConst); break;
		case EbtUInt: returnValue.setUConst(uConst % constant.uConst); break;
		default:     assert(false && "Default missing");
		}

		return returnValue;
	}

	ConstantUnion operator>>(const ConstantUnion& constant) const
	{
		ConstantUnion returnValue;
		assert(type == constant.type);
		switch (type) {
		case EbtInt: returnValue.setIConst(iConst >> constant.iConst); break;
		case EbtUInt: returnValue.setUConst(uConst >> constant.uConst); break;
		default:     assert(false && "Default missing");
		}

		return returnValue;
	}

	ConstantUnion operator<<(const ConstantUnion& constant) const
	{
		ConstantUnion returnValue;
		// The signedness of the second parameter might be different, but we
		// don't care, since the result is undefined if the second parameter is
		// negative, and aliasing should not be a problem with unions.
		assert(constant.type == EbtInt || constant.type == EbtUInt);
		switch (type) {
		case EbtInt: returnValue.setIConst(iConst << constant.iConst); break;
		case EbtUInt: returnValue.setUConst(uConst << constant.uConst); break;
		default:     assert(false && "Default missing");
		}

		return returnValue;
	}

	ConstantUnion operator&(const ConstantUnion& constant) const
	{
		ConstantUnion returnValue;
		assert(constant.type == EbtInt || constant.type == EbtUInt);
		switch (type) {
		case EbtInt:  returnValue.setIConst(iConst & constant.iConst); break;
		case EbtUInt:  returnValue.setUConst(uConst & constant.uConst); break;
		default:     assert(false && "Default missing");
		}

		return returnValue;
	}

	ConstantUnion operator|(const ConstantUnion& constant) const
	{
		ConstantUnion returnValue;
		assert(type == constant.type);
		switch (type) {
		case EbtInt:  returnValue.setIConst(iConst | constant.iConst); break;
		case EbtUInt:  returnValue.setUConst(uConst | constant.uConst); break;
		default:     assert(false && "Default missing");
		}

		return returnValue;
	}

	ConstantUnion operator^(const ConstantUnion& constant) const
	{
		ConstantUnion returnValue;
		assert(type == constant.type);
		switch (type) {
		case EbtInt:  returnValue.setIConst(iConst ^ constant.iConst); break;
		case EbtUInt:  returnValue.setUConst(uConst ^ constant.uConst); break;
		default:     assert(false && "Default missing");
		}

		return returnValue;
	}

	ConstantUnion operator&&(const ConstantUnion& constant) const
	{
		ConstantUnion returnValue;
		assert(type == constant.type);
		switch (type) {
		case EbtBool: returnValue.setBConst(bConst && constant.bConst); break;
		default:     assert(false && "Default missing");
		}

		return returnValue;
	}

	ConstantUnion operator||(const ConstantUnion& constant) const
	{
		ConstantUnion returnValue;
		assert(type == constant.type);
		switch (type) {
		case EbtBool: returnValue.setBConst(bConst || constant.bConst); break;
		default:     assert(false && "Default missing");
		}

		return returnValue;
	}

	TBasicType getType() const { return type; }
private:

	union  {
		int iConst;  // used for ivec, scalar ints
		unsigned int uConst; // used for uvec, scalar uints
		bool bConst; // used for bvec, scalar bools
		float fConst;   // used for vec, mat, scalar floats
	} ;

	TBasicType type;
};

#endif // _CONSTANT_UNION_INCLUDED_