private static UnionType GenerateAllUnionTypes() { UnionType unions = new UnionType(); unions.AddType(CharType.Instance); unions.AddType(IntType.Instance); unions.AddType(DoubleType.Instance); return(unions); }
protected override UnionType GenerateAllUnionTypes() { UnionType unions = new UnionType(); if (!(node.FirstOperand.ExpressionType is NullType) && !(node.SecondOperand.ExpressionType is NullType)) { unions.AddType(IntType.Instance); unions.AddType(DoubleType.Instance); unions.AddType(CharType.Instance); } return(unions); }
protected override UnionType GenerateAllUnionTypes() { UnionType unions = new UnionType(); unions.AddType(IntType.Instance); unions.AddType(DoubleType.Instance); unions.AddType(CharType.Instance); if (((ArithmeticExpression)node).Operator == ArithmeticOperator.Plus) { unions.AddType(StringType.Instance); } return(unions); }
protected override UnionType GenerateAllUnionTypes() { UnionType unions = new UnionType(); unions.AddType(IntType.Instance); return(unions); }
private UnionType GenerateAllUnionTypes() { UnionType unions = new UnionType(); if (node.Operator == UnaryOperator.Plus || node.Operator == UnaryOperator.Minus || node.Operator == UnaryOperator.BitwiseNot) { unions.AddType(CharType.Instance); unions.AddType(IntType.Instance); unions.AddType(DoubleType.Instance); } else if (node.Operator == UnaryOperator.Not) { unions.AddType(BoolType.Instance); } return(unions); }
private static TypeExpression getFieldType(TypeExpression type, string fieldName) { ClassType classType = TypeExpression.As <ClassType>(type); if (classType != null) { if (!classType.Fields.ContainsKey(fieldName)) { return(null); } TypeExpression field = classType.Fields[fieldName].Type; FieldType fieldType = TypeExpression.As <FieldType>(field); if (fieldType == null) { return(field); } return(fieldType.FieldTypeExpression); } UnionType unionType = TypeExpression.As <UnionType>(type); if (unionType != null) { UnionType newUnionType = new UnionType(); foreach (TypeExpression typeInUnion in unionType.TypeSet) { TypeExpression newType = SSAHelper.getFieldType(typeInUnion, fieldName); newUnionType.AddType(newType); } return(newUnionType); } return(null); }
private TypeExpression InternalPromotion(UnionType from, object arg) { if (from.IsFreshVariable() && this.methodAnalyzed != null) { // * A constraint is added to the method analyzed PromotionConstraint constraint = new PromotionConstraint(from, this.to, this.op, this.location); this.methodAnalyzed.AddConstraint(constraint); return(this.to); } // * Static Behaviour: All the types in typeset must promote // * Dynamic Behaviour: One of the types in typeset must promote int aux = 0; UnionType dynamicUnionType = new UnionType(); dynamicUnionType.IsDynamic = true; foreach (TypeExpression subType in from.TypeSet) { if (from.IsDynamic) { // * Dynamic if (subType.IsFreshVariable()) { dynamicUnionType.AddType(subType); } else { aux = (int)subType.AcceptOperation(new PromotionLevelOperation(this.to), arg); if (aux != -1) { return(this.to); } } } else // * !from.IsDynamic, so it is static { aux = (int)subType.AcceptOperation(new PromotionLevelOperation(this.to), arg); if (aux == -1) { return((TypeExpression)ReportError(from)); } } } if (dynamicUnionType.Count != 0) // * If the union type is dynamic and no type in the type set promotes, then we generate a constraint with one promotion grouping the fresh types in the type set { PromotionConstraint constraint = new PromotionConstraint(dynamicUnionType, this.to, this.op, this.location); this.methodAnalyzed.AddConstraint(constraint); return(this.to); } if (from.IsDynamic && aux == -1) { // * No promotion at all return((TypeExpression)ReportError(from)); } return(this.to); }
public override object Exec(TypeExpression typeExpression, object arg) { if (typeExpression is UnionType) { this.Exec(typeExpression as UnionType, arg); } else if (typeExpression is TypeVariable) { this.Exec(typeExpression as TypeVariable, arg); } else if (typeExpression is PropertyType) { this.Exec(((PropertyType)typeExpression).PropertyTypeExpression, arg); } else if (typeExpression is FieldType) { FieldType fieldType = ((FieldType)typeExpression); if (fieldType.FieldTypeExpression is TypeVariable && ((TypeVariable)fieldType.FieldTypeExpression).Substitution != null && ((TypeVariable)fieldType.FieldTypeExpression).Substitution.IsValueType()) { UnionType union = new UnionType(); union.AddType(((TypeVariable)((FieldType)typeExpression).FieldTypeExpression).Substitution); this.Exec(union, arg); } else { this.Exec(((FieldType)typeExpression).FieldTypeExpression, arg); } } else if (IsValueType(typeExpression) || TypeExpression.Is <StringType>(typeExpression)) { GenerateRightOperand(typeExpression, this.node.SecondOperand.ILTypeExpression); } else if (typeExpression is NullType) { this.codeGenerator.ldnull(this.indent); GenerateRightOperand(typeExpression, this.node.SecondOperand.ILTypeExpression); } else if (typeExpression is UserType) { GenerateRightOperand(typeExpression, this.node.SecondOperand.ILTypeExpression); } return(null); }
private void GenerateRightOperand(TypeExpression teLeft, TypeExpression teRight) { if (teRight is UnionType) { this.GenerateRightOperand(teLeft, teRight as UnionType); } else if (teRight is TypeVariable) { this.GenerateRightOperand(teLeft, teRight as TypeVariable); } else if (teRight is PropertyType) { GenerateRightOperand(teLeft, ((PropertyType)teRight).PropertyTypeExpression); } else if (teRight is FieldType) { FieldType fieldType = ((FieldType)teRight); if (fieldType.FieldTypeExpression is TypeVariable && ((TypeVariable)fieldType.FieldTypeExpression).Substitution != null && ((TypeVariable)fieldType.FieldTypeExpression).Substitution.IsValueType()) { UnionType union = new UnionType(); union.AddType(((TypeVariable)((FieldType)teRight).FieldTypeExpression).Substitution); GenerateRightOperand(teLeft, union); } else { GenerateRightOperand(teLeft, ((FieldType)teRight).FieldTypeExpression); } } else if (IsValueType(teRight) || TypeExpression.Is <StringType>(teRight)) { if (IsInternallyAnObject(node.FirstOperand)) { if (!(teLeft is StringType) && IsValueType(teRight)) { this.codeGenerator.UnboxAny(indent, teLeft); } } else { if (!CheckUnBox(teLeft, teRight)) { CheckBox(teLeft, teRight); } } LoadSecondOperand(); if (IsInternallyAnObject(node.SecondOperand)) { if (!(teRight is StringType) && IsValueType(teLeft)) { this.codeGenerator.UnboxAny(indent, teRight); } } else { if (!CheckUnBox(teRight, teLeft)) { CheckBox(teRight, teLeft); } } GenerateOperator(node, MajorType(teLeft, teRight)); } else if (teRight is NullType) { this.codeGenerator.ldnull(this.indent); GenerateOperator(node, MajorType(teLeft, teRight)); } }