/// <summary> /// Check if convert is necessary /// </summary> /// <param name="leftType">Type of the left.</param> /// <param name="rightType">Type of the right.</param> /// <returns>True if a cast is necessary between this two types</returns> public static bool NeedConvertForBinary(TypeBase leftType, TypeBase rightType) { return leftType != null && rightType != null && leftType != rightType && !((leftType is ScalarType && (rightType is VectorType || rightType is MatrixType) && TypeBase.GetBaseType(rightType) == leftType) || (rightType is ScalarType && (leftType is VectorType || leftType is MatrixType) && TypeBase.GetBaseType(leftType) == rightType)); }
protected void Visit(TypeBase typeBase) { typeBase.TypeInference.Declaration = null; typeBase.TypeInference.TargetType = null; typeBase.TypeInference.ExpectedType = null; Visit((Node)typeBase); }
/// <summary> /// Initializes a new instance of the <see cref="Variable"/> class. /// </summary> /// <param name="type">The type.</param> /// <param name="name">The name.</param> /// <param name="initialValue">The initial value.</param> public Variable(TypeBase type, string name, Expression initialValue = null) { Type = type; Name = new Identifier(name); InitialValue = initialValue; Attributes = new List<AttributeBase>(); Qualifiers = Qualifier.None; }
private void Visit(TypeBase typeBase) { Visit((Node)typeBase); if (sourceManager.IsClassExists(typeBase.Name.Text)) { FoundClasses.Add(typeBase.Name.Text); } else if (typeBase is ShaderTypeName) { // Special case for ShaderTypeName as we must generate an error if it is not found log.Error(XenkoMessageCode.ErrorClassNotFound, typeBase.Span, typeBase.Name.Text); } }
/// <summary> /// Gets the type of the binary implicit conversion. /// </summary> /// <param name="span">The span.</param> /// <param name="left">The left.</param> /// <param name="right">The right.</param> /// <returns>The implicit conversion between between to two types</returns> protected override TypeBase GetDivideImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right) { if (left.ResolveType().IsStreamsType() || right.ResolveType().IsStreamsType()) return StreamsType.Streams; return base.GetDivideImplicitConversionType(span, left, right); }
/// <summary> /// Initializes a new instance of the <see cref="MethodDefinition"/> class. /// </summary> /// <param name="returntype">The returntype.</param> /// <param name="name">The name.</param> public MethodDefinition(TypeBase returntype, string name) : this() { ReturnType = returntype; Name = new Identifier(name); declaration = this; }
public static int GetDimensionSize(TypeBase typeDeclaration, int dimension) { if (typeDeclaration is VectorType) { if (dimension != 1) return 1; return ((VectorType)typeDeclaration).Dimension; } if (typeDeclaration is MatrixType) { var matrixType = (MatrixType)typeDeclaration; return dimension == 0 ? matrixType.RowCount : matrixType.ColumnCount; } return 1; }
/// <summary> /// Determines whether the specified type is a float/half/double. /// </summary> /// <param name="type">The type.</param> /// <returns> /// <c>true</c> if the specified type is float/half/double; otherwise, <c>false</c>. /// </returns> public static bool IsFloat(TypeBase type) { return(type == Float || type == Double || type == Half); }
private void ChangeVariableType(Variable samplerVariable, TypeBase newType) { if (samplerVariable != null) { samplerVariable.Type = newType; if (samplerVariable is Parameter) { return; } var variableInitialValue = samplerVariable.InitialValue as VariableReferenceExpression; if (variableInitialValue != null) { this.ChangeVariableType(variableInitialValue.TypeInference.Declaration as Variable, newType); } } }
protected static bool IsTextureType(TypeBase type) { // TODO we should improve AST type system return type is TextureType || (type is GenericBaseType && type.Name.Text.Contains("Texture")); }
/// <summary> /// Checks the constraint. /// </summary> /// <param name="parameterType">Type of the parameter.</param> /// <param name="typeToCheck">The type to check.</param> /// <returns></returns> public bool CheckConstraint(GenericParameterType parameterType, TypeBase typeToCheck) { foreach (var genericParameterConstraint in ParameterConstraints) { if (genericParameterConstraint.Name == parameterType.Name) { return genericParameterConstraint.Constraint(typeToCheck); } } return false; }
/// <summary> /// Gets the type of the binary implicit conversion. /// </summary> /// <param name="span">The span.</param> /// <param name="left">The left.</param> /// <param name="right">The right.</param> /// <returns>The implicit conversion between between to two types</returns> protected override TypeBase GetMultiplyImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right) { if (left.ResolveType() is StreamsType || right.ResolveType() is StreamsType) return StreamsType.Streams; return base.GetMultiplyImplicitConversionType(span, left, right); }
public static bool HasDimensions(TypeBase typeDeclaration) { return((typeDeclaration is ScalarType) || (typeDeclaration is VectorType) || (typeDeclaration is MatrixType)); }
/// <summary> /// Initializes a new instance of the <see cref="TypeReferenceExpression"/> class. /// </summary> /// <param name="type">The type.</param> public TypeReferenceExpression(TypeBase type) { Type = type; }
/// <summary> /// Initializes a new instance of the <see cref="Parameter"/> class. /// </summary> /// <param name="type">The type.</param> /// <param name="name">The name.</param> /// <param name="initialValue">The initial value.</param> public Parameter(TypeBase type, string name = null, Expression initialValue = null) : base(type, name, initialValue) { }
/// <summary> /// Determines whether the specified type is an integer. /// </summary> /// <param name="type">The type.</param> /// <returns> /// <c>true</c> if the specified type is an integer; otherwise, <c>false</c>. /// </returns> public static bool IsInteger(TypeBase type) { return(type == Int || type == UInt); }
/// <summary> /// Finds the declaration inside the compositions and calls the base method too /// </summary> /// <param name="typeBase">the type of the object</param> /// <param name="memberName">the name of its member</param> /// <returns>a collection of all possible members</returns> protected override IEnumerable<IDeclaration> FindDeclarationsFromObject(TypeBase typeBase, string memberName) { if (typeBase == null) { yield break; } // look if it is a composition // the typebase is unique for each extern so there is no need to look for the right class //var mixin = compositionsVirtualTables.FirstOrDefault(x => ReferenceEquals(x.Key.ResolveType(), typeBase.ResolveType())).Value; var mixin = moduleMixins.FirstOrDefault(x => x.MixinName == typeBase.Name.Text); if (mixin != null) { foreach (var member in mixin.VirtualTable.Variables.Where(x => x.Variable.Name.Text == memberName)) yield return member.Variable; foreach (var member in mixin.VirtualTable.Methods.Where(x => x.Method.Name.Text == memberName)) yield return member.Method; if (mixin.MixinName == memberName) yield return mixin.Shader; foreach (var dep in mixin.InheritanceList.Where(x => x.MixinName == memberName).Select(x => x.Shader)) yield return dep; } else { foreach (var item in base.FindDeclarationsFromObject(typeBase.ResolveType(), memberName)) yield return item; } }
/// <summary> /// Gets the type of the binary implicit conversion. /// </summary> /// <param name="span">The span.</param> /// <param name="left">The left.</param> /// <param name="right">The right.</param> /// <param name="isBinaryOperator">if set to <c>true</c> [is binary operator].</param> /// <returns> /// The implicit conversion between between to two types /// </returns> protected virtual TypeBase GetBinaryImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right, bool isBinaryOperator) { var result = CastHelper.GetBinaryImplicitConversionType(left, right, isBinaryOperator); if (result == null) Error(MessageCode.ErrorBinaryTypeDeduction, span, left, right); return result; }
/// <summary> /// Gets the type of the binary implicit conversion. /// </summary> /// <param name="span">The span.</param> /// <param name="left">The left.</param> /// <param name="right">The right.</param> /// <returns>The implicit conversion between between to two types</returns> protected virtual TypeBase GetDivideImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right) { var result = CastHelper.GetDivideImplicitConversionType(left.ResolveType(), right.ResolveType()); if (result == null) Error(MessageCode.ErrorBinaryTypeDeduction, span, left, right); return result; }
public static bool IsInputOutputStream(TypeBase type) { var streamType = type as StreamsType; if (streamType == null) { return false; } return streamType.IsInputOutput; }
protected static bool IsBufferType(TypeBase type) { // TODO we should improve AST type system return type is GenericBaseType && type.Name.Text.Contains("Buffer"); }
public static TypeBase GetBaseType(TypeBase type) { if (type is MatrixType) return ((MatrixType)type).Type; if (type is VectorType) return ((VectorType)type).Type; return type; }
/// <summary> /// Gets the type of the binary implicit scalar conversion. /// </summary> /// <param name="span">The span.</param> /// <param name="left">The left.</param> /// <param name="right">The right.</param> /// <returns> /// The implicit conversion between the two scalar types /// </returns> protected ScalarType GetBinaryImplicitScalarConversionType(SourceSpan span, TypeBase left, TypeBase right) { var result = CastHelper.GetBinaryImplicitScalarConversionType(left, right); if (result == null) Error(MessageCode.ErrorScalarTypeConversion, span, left, right); return result; }
/// <summary> /// Initializes a new instance of the <see cref="TypeName"/> class. /// </summary> /// <param name="typeBase">The type base.</param> public TypeName(TypeBase typeBase) : base(typeBase.Name) { TypeInference.TargetType = typeBase; }
/// <summary> /// Creates a type based on a new base type. If type is a matrix or vector, then the base type is changed to match the newBaseType. /// </summary> /// <param name="type">The type.</param> /// <param name="newBaseType">New type of the base.</param> /// <returns>A new type</returns> public static TypeBase CreateWithBaseType(TypeBase type, ScalarType newBaseType) { if (type is MatrixType) return new MatrixType(newBaseType, ((MatrixType)type).RowCount, ((MatrixType)type).ColumnCount); if (type is VectorType) return new VectorType(newBaseType, ((VectorType)type).Dimension); return newBaseType; }
public void Visit(TypeBase typeReference) { Visit((Node)typeReference); AddReference(GetDeclarationContainer(), (Node)typeReference.TypeInference.Declaration); }
public static bool HasDimensions(TypeBase typeDeclaration) { return (typeDeclaration is ScalarType) || (typeDeclaration is VectorType) || (typeDeclaration is MatrixType); }
/// <summary> /// Equalses the specified other. /// </summary> /// <param name="other"> /// The other. /// </param> /// <returns> /// <c>true</c> if the specified <see cref="TypeBase"/> is equal to this instance; otherwise, <c>false</c>. /// </returns> public bool Equals(TypeBase other) { if (ReferenceEquals(null, other)) { return false; } if (ReferenceEquals(this, other)) { return true; } return Equals(other.Name, Name); }
/// <summary> /// Gets the type of the binary implicit conversion. /// </summary> /// <param name="span">The span.</param> /// <param name="left">The left.</param> /// <param name="right">The right.</param> /// <param name="isBinaryOperator">if set to <c>true</c> [is binary operator].</param> /// <returns> /// The implicit conversion between between to two types /// </returns> protected override TypeBase GetBinaryImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right, bool isBinaryOperator) { if (left.ResolveType().IsStreamsType() || right.ResolveType().IsStreamsType()) return StreamsType.Streams; return base.GetBinaryImplicitConversionType(span, left, right, isBinaryOperator); }
private Expression Cast(TypeBase fromType, TypeBase toType, Expression expression) { if (fromType != null && toType != null) { if (fromType != toType) { var castMethod = new MethodInvocationExpression(new TypeReferenceExpression(toType)); castMethod.Arguments.Add(expression); expression = castMethod; expression.TypeInference.TargetType = toType; } } return expression; }
/// <summary> /// Find the base type in case of array /// </summary> /// <param name="typeBase">the type to explore</param> /// <returns>the base type</returns> private static TypeBase FindFinalType(TypeBase typeBase) { if (typeBase is ArrayType) return FindFinalType((typeBase as ArrayType).Type); return typeBase.ResolveType(); }
private Expression ConvertExpressionToBool(Expression expression, TypeBase typeToCheck) { if (typeToCheck != ScalarType.Bool) return new MethodInvocationExpression(new TypeReferenceExpression(ScalarType.Bool), expression); return expression; }
/// <summary> /// Tests the arguments of the method - check streams type here /// </summary> /// <param name="argTypeBase">the argument typebase</param> /// <param name="expectedTypeBase">the expected typebase</param> /// <param name="argType">the argument type</param> /// <param name="expectedType">the expected type</param> /// <param name="score">the score of the overload</param> /// <returns>true if the overload is correct, false otherwise</returns> protected override bool TestMethodInvocationArgument(TypeBase argTypeBase, TypeBase expectedTypeBase, TypeBase argType, TypeBase expectedType, ref int score) { if (argTypeBase == StreamsType.Streams && expectedTypeBase == StreamsType.Output) // streams and output are the same return true; if (argTypeBase.IsStreamsType() && expectedType.IsStreamsType()) return argTypeBase == expectedType; return base.TestMethodInvocationArgument(argTypeBase, expectedTypeBase, argType, expectedType, ref score); }
/// <summary> /// Initializes a new instance of the <see cref="ArrayType"/> class. /// </summary> /// <param name="type">The type.</param> /// <param name="dimensions">The dimensions.</param> public ArrayType(TypeBase type, params Expression[] dimensions) : base("$array") { Type = type; Dimensions = new List <Expression>(); Dimensions.AddRange(dimensions); }