OoasTools

/**

  *

  *                      OOAS Compiler

  *

  *       Copyright 2015, AIT Austrian Institute of Technology.

  * This code is based on the C# Version of the OOAS Compiler, which is

  * copyright 2015 by the Institute of Software Technology, Graz University

  * of Technology with portions copyright by the AIT Austrian Institute of

  * Technology. All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Markus Demetz (AIT)

  *               Christoph Czurda (AIT)

  *

  */

package org.momut.ooas.ast.types;

import java.util.Iterator;

public abstract class UlyssesType extends AstNode implements IAst

{

	private String m_origAnonName;

	protected TypeKind m_kind;

	protected TypeIdentifier m_identifier;

	protected int m_hash;

	//    protected long TimeStamp = DateTime.Now.Ticks;

	public TypeKind kind() { return m_kind; }

	public TypeIdentifier identifier() {

		synchronized(this) {

			if (m_identifier == null)

				SetupAnonymousName();

		}

		return m_identifier;

	}

	public boolean isAnonymousType() {

		final String anonName = AnonymousName();

		if (!m_origAnonName.equals(anonName))

			throw new OoasCompilerRuntimeException("Internal Error: Anonymous Name changed from '%s' to '%s'.", m_origAnonName, anonName);

		return anonName.equals(m_identifier.tokenText());

	}

	protected UlyssesType(TypeKind aKind, TypeIdentifier anIdentifier)

	{

		m_kind = aKind;

		m_identifier = anIdentifier;

		m_hash = aKind.toString().hashCode(); //Enum.GetName(typeof(TypeKind), aKind).GetHashCode();

	}

	@Override

	public /*override*/ String toString()

	{

		return identifier().tokenText();

	}

	public /*virtual*/ String AnonymousName()

	{

		throw new NotImplementedException();

	}

	public void SetTypeIdentifier(TypeIdentifier anId)

	{

		m_identifier = anId;

	}

	public void SetupAnonymousName()

	{

		if (m_identifier == null)

		{

			final String anonymousName = this.AnonymousName();

			m_identifier = new TypeIdentifier(anonymousName, this, null);

			m_origAnonName = anonymousName;

		}

	}

	@Override

	public AstNodeTypeEnum nodeType() { return AstNodeTypeEnum.type; }

	@Override

	public void Accept(IAstVisitor visitor)

	{

		throw new NotImplementedException();

	}

	public boolean IsNumeric()

	{

		final Object o = this;

		return (m_kind == TypeKind.IntType) ||

				(m_kind == TypeKind.FloatType) ||

				(m_kind == TypeKind.EnumeratedType && o instanceof ValuedEnumType);

	}

	public boolean IsQualitative()

	{

		return (m_kind == TypeKind.QrType);

	}

	/**

	 * returns the number of unique values of the type (2 for bool, etc..)

	 */

	public int valueCount() {

		throw new NotImplementedException(); // must be overridden by child

	}

	public static String High(UlyssesType atype)

	{

		switch (atype.kind())

		{

			case BoolType:

				return "1";

			case EnumeratedType:

				return Integer.toString((((EnumType)atype).listOfEnumSymbols().size() - 1));

			case IntType:

				return Integer.toString(((IntType)atype).rangeHigh());

			case FloatType:

				return Double.toString(((FloatType)atype).high());

//			case TypeKind.QrType:

//				return (((QrType)atype).landmarks.Count - 1).ToString();

			default:

				throw new NotImplementedException();

		}

	}

	public static String Low(UlyssesType atype)

	{

		switch (atype.kind())

		{

			case BoolType:

				return "0";

			case EnumeratedType:

				return "0";

			case IntType:

				return Integer.toString(((IntType)atype).rangeLow());

			case FloatType:

				return Double.toString(((FloatType)atype).low());

//			case TypeKind.QrType:

//				return "0";

			default:

				throw new NotImplementedException();

		}

	}

	/// <summary>

	///  Returns a cover for two types (if possible).

	///  note the cover type for two ints, floats, etc. will have max/min values

	///  that reflect the maximum of the two operands.

	/// </summary>

	public static UlyssesType CoverType(UlyssesType type1, UlyssesType type2)

	{

		/*first some sanity checks*/

		if (type1 == null)

			throw new ArgumentException("type1 null");

		if (type2 == null)

			throw new ArgumentException("type2 null");

		if (type1.kind() == TypeKind.OpaqueType)

			throw new ArgumentException("type1 opaque type");

		if (type2.kind() == TypeKind.OpaqueType)

			throw new ArgumentException("type2 opaque type");

		if (type1 == type2)

			return type1;

		if (UlyssesType.TypeEqual(type1, type2))

			return type1;

		final TypeKind tk1 = type1.kind();

		final TypeKind tk2 = type2.kind();

		if (tk1 != tk2)

		{

			// the only notion we support here is int->float and valenum -> int

			if ((tk1 == TypeKind.IntType || tk2 == TypeKind.IntType)

					&& (tk1 == TypeKind.FloatType || tk2 == TypeKind.FloatType))

			{

				final IntType aInt = tk1 == TypeKind.IntType ? (IntType)type1 : (IntType)type2;

				final FloatType aFloat = tk1 == TypeKind.IntType ? (FloatType)type2 : (FloatType)type1;

				final double low = aInt.rangeLow() < aFloat.low() ? (double)aInt.rangeLow() : aFloat.low();

				final double high = aInt.rangeHigh() < aFloat.high() ? aFloat.high() : (double)aInt.rangeHigh();

				final double precision = aFloat.precision() > 1 ? 1.0 : aFloat.precision();

				return new FloatType(low, high, precision, null);

			}

			else if ((tk1 == TypeKind.IntType || tk2 == TypeKind.IntType)

					&& (tk1 == TypeKind.EnumeratedType || tk2 == TypeKind.EnumeratedType))

			{

				final IntType intt1 = tk1 == TypeKind.IntType ? (IntType)type1 : (IntType)type2;

				final EnumType anEnum = tk1 == TypeKind.IntType ? (EnumType)type2 : (EnumType)type1;

				if (anEnum instanceof ValuedEnumType)

				{

					final IntType intt2 = ((ValuedEnumType)anEnum).getIntType();

					final int low = intt1.rangeLow() < intt2.rangeLow() ? intt1.rangeLow() : intt2.rangeLow();

					final int high = intt1.rangeHigh() > intt2.rangeHigh() ? intt1.rangeHigh() : intt2.rangeHigh();

					return new IntType(low, high, null);

				}

				else

					return null;

			}

			else if (tk1 == TypeKind.Any || tk2 == TypeKind.Any)

			{

				final AnyType freeVar = tk1 == TypeKind.Any ? (AnyType)type1 : (AnyType)type2;

				final UlyssesType fixedType = tk1 == TypeKind.Any ? type2 : type1;

				final UlyssesType newcover = freeVar.VariableIdentifier().type().kind() == TypeKind.Any

						? fixedType : CoverType(fixedType, freeVar.VariableIdentifier().type());

				freeVar.VariableIdentifier().SetType(newcover);

				return newcover;

			}

			else if (tk1 == TypeKind.OoActionSystemType && tk2 == TypeKind.Null)

			{

				return type1;

			}

			else if (tk2 == TypeKind.OoActionSystemType && tk1 == TypeKind.Null)

			{

				return type2;

			}

			else

				return null;

		}

		else

		{

			switch (tk1)

			{

				case Any:

					return type1;

				case IntType:

					final IntType intt1 = (IntType)type1;

					final IntType intt2 = (IntType)type2;

					final int low = intt1.rangeLow() < intt2.rangeLow() ? intt1.rangeLow() : intt2.rangeLow();

					final int high = intt1.rangeHigh() > intt2.rangeHigh() ? intt1.rangeHigh() : intt2.rangeHigh();

					return new IntType(low, high, null);

				case BoolType:

					return type1;

				case FloatType:

					final FloatType floatt1 = (FloatType)type1;

					final FloatType floatt2 = (FloatType)type2;

					final double flow = floatt1.low() < floatt2.low() ? floatt1.low() : floatt2.low();

					final double fhigh = floatt1.high() > floatt2.high() ? floatt1.high() : floatt2.high();

					final double fprec = floatt1.precision() < floatt2.precision() ? floatt1.precision() : floatt2.precision();

					return new FloatType(flow, fhigh, fprec, null);

				case EnumeratedType:

					return null;

				case ListType:

					final ListType listt1 = (ListType)type1;

					final ListType listt2 = (ListType)type2;

					int maxelems = listt1.maxNumberOfElements() > listt2.maxNumberOfElements() ?

						listt1.maxNumberOfElements() : listt2.maxNumberOfElements();

					// empty lists lack type, so take the other one

					if ((listt1.innerType().kind() == TypeKind.Null) && (listt2.innerType().kind() != TypeKind.Null))

						return listt2;

					else if ((listt2.innerType().kind() == TypeKind.Null) && (listt1.innerType().kind() != TypeKind.Null))

						return listt1;

					else if (listt1.innerType().kind() == TypeKind.Null && listt2.innerType().kind() == TypeKind.Null)

						return listt1;

					else

					{

						final UlyssesType subtype = UlyssesType.CoverType(listt1.innerType(), listt2.innerType());

						if (subtype != null)

							return new ListType(subtype, maxelems, null);

						else

							return null;

					}

				case MapType:

					final MapType mapt1 = (MapType)type1;

					final MapType mapt2 = (MapType)type2;

					// empty maps lack type, so take the other one.

					if ((mapt1.fromType().kind() == TypeKind.Null && mapt1.toType().kind() == TypeKind.Null)

					   && (mapt2.fromType().kind() != TypeKind.Null && mapt2.toType().kind() != TypeKind.Null))

						return mapt2;

					else if ((mapt2.fromType().kind() == TypeKind.Null && mapt2.toType().kind() == TypeKind.Null)

					   && (mapt1.fromType().kind() != TypeKind.Null && mapt1.toType().kind() != TypeKind.Null))

						return mapt1;

					else if ((mapt2.fromType().kind() == TypeKind.Null && mapt2.toType().kind() == TypeKind.Null)

					   && (mapt1.fromType().kind() == TypeKind.Null && mapt1.toType().kind() == TypeKind.Null))

						return mapt1;

					else

					{

						final UlyssesType sub1 = UlyssesType.CoverType(mapt1.fromType(), mapt2.fromType());

						final UlyssesType sub2 = UlyssesType.CoverType(mapt2.toType(), mapt2.toType());

						maxelems = mapt1.maxNumberOfElements() > mapt2.maxNumberOfElements() ?

							mapt1.maxNumberOfElements() : mapt2.maxNumberOfElements();

						if (sub1 != null && sub2 != null)

							return new MapType(sub1, sub2, maxelems, null);

						else

							return null;

					}

				case QrType:

					return null; /*if refs are equal, we do not reach this statement! see above..*/

				case TupleType:

					final TupleType tuplet1 = (TupleType)type1;

					final TupleType tuplet2 = (TupleType)type2;

					final TupleType result = new TupleType(null);

					final Iterator<UlyssesType> innert1 = tuplet1.innerTypes().iterator();

					final Iterator<UlyssesType> innert2 = tuplet2.innerTypes().iterator();

					while (innert1.hasNext())

					{

						final UlyssesType newinner = UlyssesType.CoverType(innert1.next(), innert2.next());

						if (newinner == null)

							return null;

						result.AddType(newinner);

					}

					return result;

				case OoActionSystemType:

					if (type1.kind() == TypeKind.Null && type2.kind() != TypeKind.Null)

						return type2;

					else if (type2.kind() == TypeKind.Null && type1.kind() != TypeKind.Null)

						return type1;

					else if (type1.kind() == TypeKind.Null && type2.kind() == TypeKind.Null)

						return type2;

					else if (type1 == type2) // ref equals!

						return type1;

					else

						return ClassBaseType((OoActionSystemType)type1, (OoActionSystemType)type2);

				case OpaqueType:

					assert(false);

					return null;

				default:

					throw new NotImplementedException();

			}

		}

	}

	private static UlyssesType ClassBaseType(OoActionSystemType type1, OoActionSystemType type2)

	{

		// this is rather inefficient.. should be done differently

		final OoActionSystemType typea = type1;

		final OoActionSystemType typeb = type2;

		OoActionSystemType basea = type1;

		OoActionSystemType baseb = type2;

		while (basea != null)

		{

			if (basea == typeb)  // ref equals

				return basea;

			basea = basea.baseType();

		}

		while (baseb != null)

		{

			if (baseb == typea) // ref equals

				return baseb;

			baseb = baseb.baseType();

		}

		return null;

	}

	public static boolean FirstTypeLessRange(UlyssesType type1, UlyssesType type2)

	{

		final TypeKind tk1 = type1.kind();

		final TypeKind tk2 = type2.kind();

		if (tk1 != tk2)

			throw new ArgumentException("Types need to be equal");

		switch (tk1)

		{

			case Any:

				return false;

			case IntType:

				final IntType Int1 = (IntType)type1;

				final IntType Int2 = (IntType)type2;

				return Int1.rangeLow() > Int2.rangeLow() ||

					Int1.rangeHigh() < Int2.rangeHigh();

			case BoolType:

				return false;

			case FloatType:

				final FloatType Float1 = (FloatType)type1;

				final FloatType Float2 = (FloatType)type2;

				return Float1.low() > Float2.low()

					|| Float1.high() < Float2.high()

					|| Float1.precision() > Float2.precision();

			case EnumeratedType:

				return false;

			case ListType:

				final ListType listt1 = (ListType)type1;

				final ListType listt2 = (ListType)type2;

				return (listt1.maxNumberOfElements() < listt2.maxNumberOfElements()) ||

					UlyssesType.FirstTypeLessRange(listt1.innerType(), listt2.innerType());

			case MapType:

				final MapType mapt1 = (MapType)type1;

				final MapType mapt2 = (MapType)type2;

				return (mapt1.maxNumberOfElements() < mapt2.maxNumberOfElements()) ||

					UlyssesType.FirstTypeLessRange(mapt1.fromType(), mapt2.fromType()) ||

					UlyssesType.FirstTypeLessRange(mapt1.toType(), mapt2.toType());

			case QrType:

				return false;

			case TupleType:

				final TupleType tuplet1 = (TupleType)type1;

				final TupleType tuplet2 = (TupleType)type2;

				if (tuplet1.innerTypes().size() != tuplet2.innerTypes().size())

					return false;

				final Iterator<UlyssesType> innert1 = tuplet1.innerTypes().iterator();

				final Iterator<UlyssesType> innert2 = tuplet2.innerTypes().iterator();

				while (innert1.hasNext())

				{

					if (UlyssesType.FirstTypeLessRange(innert1.next(), innert2.next()))

						return true;

				}

				return false;

			case OoActionSystemType:

				return false;

			case OpaqueType:

				assert(false);

				return false;

			default:

				throw new NotImplementedException();

		}

	}

	public static boolean TypeEqualByKind(UlyssesType type1, UlyssesType type2)

	{

		if ((type1 == null) || (type2 == null))

			return false;

		final TypeKind tk1 = type1.kind();

		final TypeKind tk2 = type2.kind();

		// if of different kind, then return false..

		if (tk1 != tk2)

			return false;

		// if same kind, make a rigorous check

		switch (tk1)

		{

			case Any:

				return true;

			case IntType:

			case BoolType:

			case FloatType:

				return true;

			case EnumeratedType:

				return type1 == type2; // ref equals

			case ListType:

				final ListType listt1 = (ListType)type1;

				final ListType listt2 = (ListType)type2;

				return UlyssesType.TypeEqualByKind(listt1.innerType(), listt2.innerType());

			case MapType:

				final MapType mapt1 = (MapType)type1;

				final MapType mapt2 = (MapType)type2;

				return UlyssesType.TypeEqualByKind(mapt1.fromType(), mapt2.fromType()) &&

					UlyssesType.TypeEqualByKind(mapt1.toType(), mapt2.toType());

			case QrType:

				final QrType qr1 = (QrType)type1;

				final QrType qr2 = (QrType)type2;

				return qr1 == qr2; // ref equals

			case TupleType:

				final TupleType tuplet1 = (TupleType)type1;

				final TupleType tuplet2 = (TupleType)type2;

				if (tuplet1.innerTypes().size() != tuplet2.innerTypes().size())

					return false;

				final Iterator<UlyssesType> innert1 = tuplet1.innerTypes().iterator();

				final Iterator<UlyssesType> innert2 = tuplet2.innerTypes().iterator();

				while (innert1.hasNext())

				{

					if (!UlyssesType.TypeEqualByKind(innert1.next(), innert2.next()))

						return false;

				}

				return true;

			case OoActionSystemType:

				return type1 == type2; // ref equ.

			case OpaqueType:

				assert(false);

				return false;

			default:

				throw new NotImplementedException();

		}

	}

	public static boolean TypeEqual(UlyssesType type1, UlyssesType type2)

	{

		// this will also work with opaque types...

		while (type1 instanceof OpaqueType)

			type1 = ((OpaqueType)type1).resolvedType();

		while (type2 instanceof OpaqueType)

			type2 = ((OpaqueType)type2).resolvedType();

		if ((type1 == null) || (type2 == null))

			return false;

		final TypeKind tk1 = type1.kind();

		final TypeKind tk2 = type2.kind();

		// if of different kind, then return false..

		if (tk1 != tk2)

			return false;

		// if same kind, make a rigorous check

		switch (tk1)

		{

			case IntType:

				final IntType intt1 = (IntType)type1;

				final IntType intt2 = (IntType)type2;

				return intt1.rangeLow() == intt2.rangeLow() &&

					intt1.rangeHigh() == intt2.rangeHigh();

			case BoolType:

				return true;

			case FloatType:

				final FloatType floatt1 = (FloatType)type1;

				final FloatType floatt2 = (FloatType)type2;

				return floatt1.low() == floatt2.low() &&

					floatt1.high() == floatt2.high() &&

					floatt1.precision() == floatt2.precision();

			case EnumeratedType:

				return type1 == type2; // ref equ

			case ListType:

				final ListType listt1 = (ListType)type1;

				final ListType listt2 = (ListType)type2;

				// an empty list can be of any type..

				/*if ((listt1.innerType.kind == TypeKind.Null) || (listt2.innerType.kind == TypeKind.Null))

					return true;

				else*/

				return UlyssesType.TypeEqual(listt1.innerType(), listt2.innerType()) &&

						listt1.maxNumberOfElements() == listt2.maxNumberOfElements(); // need this because of covertype

			case MapType:

				final MapType mapt1 = (MapType)type1;

				final MapType mapt2 = (MapType)type2;

				return UlyssesType.TypeEqual(mapt1.fromType(), mapt2.fromType()) &&

					UlyssesType.TypeEqual(mapt1.toType(), mapt2.toType()) &&

					mapt1.maxNumberOfElements() == mapt2.maxNumberOfElements(); // need this because of covertype

			case QrType:

				final QrType qr1 = (QrType)type1;

				final QrType qr2 = (QrType)type2;

				return qr1 == qr2; // ref equ.

			case TupleType:

				final TupleType tuplet1 = (TupleType)type1;

				final TupleType tuplet2 = (TupleType)type2;

				if (tuplet1.innerTypes().size() != tuplet2.innerTypes().size())

					return false;

				final Iterator<UlyssesType> innert1 = tuplet1.innerTypes().iterator();

				final Iterator<UlyssesType> innert2 = tuplet2.innerTypes().iterator();

				while (innert1.hasNext())

				{

					if (!UlyssesType.TypeEqual(innert1.next(), innert2.next()))

						return false;

				}

				return true;

			case OoActionSystemType:

				return type1 == type2; // ref equ. // || Covariance((OoActionSystemType)type1, (OoActionSystemType)type2);

			case OpaqueType:

				assert(false);

				return false;

			case Null:

			case Any:

				return true;

			default:

				throw new NotImplementedException();

		}

	}

	/// <summary>

	/// checks if type 2 is a desc. of type 1

	/// </summary>

	public static boolean Covariance(OoActionSystemType ooActionSystemType, OoActionSystemType ooActionSystemType_2)

	{

		// check if type 2 is a desc. of type 1

		while (ooActionSystemType != ooActionSystemType_2 && ooActionSystemType_2.baseType() != null) // ref equ.

			ooActionSystemType_2 = ooActionSystemType_2.baseType();

		return ooActionSystemType == ooActionSystemType_2; // ref equ.

	}

}