public override bool Equals(object obj) { if (obj is ReturnTypeNode) { var o = obj as ReturnTypeNode; return(DataType.Equals(o.DataType)); } return(false); }
public static bool IsVoid(TypeNode type) { TypeModifier mtype = type as TypeModifier; if (mtype != null) { return(IsVoid(mtype.ModifiedType)); } if (type != null && type.Equals(Cci.SystemTypes.Void)) { return(true); } return(false); }
public void validateRelationBetween(ref TypeNode f, ref TypeNode typeAssignmentNode) { var ogiginalType = f; var tdn = (typeAssignmentNode is ArrayTypeNode || typeAssignmentNode is AbstractTypeNode)?getTypeForIdentifier(Utils.getNameForType(typeAssignmentNode)):typeAssignmentNode; var t = (f is AbstractTypeNode || f is ArrayTypeNode)?getTypeForIdentifier(Utils.getNameForType(f)):f; t = (t is VarTypeNode)?tdn:t; string rule = f.ToString() + "," + typeAssignmentNode.ToString(); string rule2 = (t is AbstractTypeNode)?"":t.getComparativeType() + "," + typeAssignmentNode.ToString(); string rule3 = (t is AbstractTypeNode)?"":t.getComparativeType() + "," + tdn.getComparativeType(); if (!assignmentRules.Contains(rule) && !assignmentRules.Contains(rule2) && !assignmentRules.Contains(rule3) && f.ToString() != typeAssignmentNode.ToString() && !f.Equals(typeAssignmentNode)) { f = (f is AbstractTypeNode || f is ArrayTypeNode)?getTypeForIdentifier(Utils.getNameForType(f)):f; f = (f is VarTypeNode)?tdn:f; if (f.ToString() == "Person" && tdn.ToString() == "Student") { Console.Write(""); } if (f.getComparativeType() == Utils.Class && tdn.getComparativeType() == Utils.Class) { if (!checkRelationBetween(f, tdn)) { Utils.ThrowError("1Not a valid assignment. Trying to assign " + tdn.ToString() + " to field with type " + f.ToString() + " " + f.token.getLine()); } } else if ((!(f.getComparativeType() == Utils.Class || f.getComparativeType() == Utils.String) && tdn is NullTypeNode)) { Utils.ThrowError("2Not a valid assignment. Trying to assign " + tdn.ToString() + " to field with type " + f.ToString() + " " + f.token.getLine()); } else { Utils.ThrowError("3Not a valid assignment. Trying to assign " + tdn.ToString() + " to field with type " + f.ToString() + " " + f.token.getLine()); } if (ogiginalType is ArrayTypeNode) { f = ogiginalType; } } }
public override TypeNode EvaluateType(API api, TypeNode type, bool isStatic) { TypeNode t1 = leftExpression.EvaluateType(api, null, true); TypeNode t2 = rightExpression.EvaluateType(api, null, true); t1 = (t1 is AbstractTypeNode || t1 is ArrayTypeNode)?api.getTypeForIdentifier(Utils.getNameForType(t1)):t1; t2 = (t2 is AbstractTypeNode || t2 is ArrayTypeNode)?api.getTypeForIdentifier(Utils.getNameForType(t2)):t2; string rule = t1.ToString() + "," + t2.ToString(); string rule2 = t1.getComparativeType() + "," + t2.ToString(); string rule3 = t1.getComparativeType() + "," + t2.getComparativeType(); if (!rule.Contains(rule) && !rule.Contains(rule2) && !rule.Contains(rule3) && !t1.Equals(t2)) { if (t1.getComparativeType() == Utils.Class && t2.getComparativeType() == Utils.Class) { if (!api.checkRelationBetween(t1, t2)) { Utils.ThrowError("Not a valid assignment. Trying to assign " + t2.ToString() + " to field with type " + t1.ToString()); } } else if ((!(t1.getComparativeType() == Utils.Class || t1.getComparativeType() == Utils.String) && t2 is NullTypeNode)) { Utils.ThrowError("Not a valid assignment. Trying to assign " + t2.ToString() + " to field with type " + t1.ToString()); } else if (t1.getComparativeType() == Utils.Var) { t1 = t2; } else if (t1.getComparativeType() == Utils.Array && t2.getComparativeType() == Utils.Array) { var token = new Token(); token.row = -1; token.column = -1; api.checkArrays(t1, t2, token); } else { throw new SemanticException("Not a valid assignment. Trying to assign " + t2.ToString() + " to field with type " + t1.ToString()); } } return(t1); }
public override bool TrySetType(TypeNode expectedType, IMetaDataProvider metaDataProvider, out TypeNode resultType) { if (typeof(T) == typeof(Parameter)) { var p = (Parameter)(object)this.Element; TypeNode type = metaDataProvider.ParameterType(p); this.isManagedPointer = metaDataProvider.IsManagedPointer(type); ResultType = resultType = metaDataProvider.ManagedPointer(type); return(true); } if (typeof(T) == typeof(Field)) { var f = (Field)(object)this.Element; TypeNode type = metaDataProvider.FieldType(f); this.isStatic = metaDataProvider.IsStatic(f); this.isManagedPointer = metaDataProvider.IsManagedPointer(type); ResultType = resultType = metaDataProvider.ManagedPointer(type); TypeNode declaringType = metaDataProvider.DeclaringType(f); if (metaDataProvider.IsManagedPointer(expectedType)) { expectedType = metaDataProvider.ElementType(expectedType); } expectedType = metaDataProvider.Unspecialized(expectedType); if (!metaDataProvider.IsStatic(f) && declaringType.Equals(expectedType) && (!metaDataProvider.DerivesFrom(expectedType, declaringType) || !metaDataProvider.IsProtected(f) && !metaDataProvider.IsPublic(f))) { this.castTo = metaDataProvider.FullName(declaringType); } return(true); } if (typeof(T) == typeof(Local)) { var local = (Local)(object)this.Element; TypeNode type = metaDataProvider.LocalType(local); this.isManagedPointer = metaDataProvider.IsManagedPointer(type); ResultType = resultType = metaDataProvider.ManagedPointer(type); return(true); } if (typeof(T) == typeof(Method)) { var method = (Method)(object)this.Element; ResultType = resultType = !IsAddressOf ? metaDataProvider.ReturnType(method) : metaDataProvider.ManagedPointer(metaDataProvider.ReturnType(method)); if (metaDataProvider.IsManagedPointer(expectedType)) { expectedType = metaDataProvider.ElementType(expectedType); } expectedType = metaDataProvider.Unspecialized(expectedType); TypeNode declaringType = metaDataProvider.DeclaringType(method); if (!metaDataProvider.IsStatic(method) && declaringType.Equals(expectedType) && (!metaDataProvider.DerivesFrom(expectedType, declaringType) || !metaDataProvider.IsProtected(method) && !metaDataProvider.IsPublic(method))) { this.castTo = metaDataProvider.FullName(declaringType); } return(true); } ResultType = resultType = default(TypeNode); return(false); }
public bool IsVoid(TypeNode type) { return(type.Equals(System_Void)); }
public override TypeNode EvaluateType(API api, TypeNode type, bool isStatic) { TypeNode expType = expresion.EvaluateType(api, null, isStatic); TypeNode t = api.getTypeForIdentifier(Utils.getNameForType(targetCastType)); string rule = t.ToString() + "," + expType.ToString(); string rule2 = t.getComparativeType() + "," + expType.ToString(); string rule3 = t.getComparativeType() + "," + expType.getComparativeType(); if (rules.Contains(rule) || rules.Contains(rule2) || rules.Contains(rule3) || t.Equals(expType)) { return(t); } if (!(t is ClassTypeNode)) { Utils.ThrowError("There is no relation between " + expType.ToString() + " and " + t.ToString()); } if (expType is ClassTypeNode) { if (api.checkRelationBetween(expType, t)) { return(t); } } if (!(expType is NullTypeNode)) { Utils.ThrowError("There is no relation between " + expType.ToString() + " and " + t.ToString()); } return(t); }
public override TypeNode EvaluateType(API api, TypeNode type, bool isStatic) { TypeNode tdn = null; int arraysOfarrays = 0; VariableInitializerNode previous_expr = null; foreach (VariableInitializerNode vi in arrayInitializers) { if (previous_expr != null) { validateExpressions(previous_expr, vi); } previous_expr = vi; TypeNode tdn2 = vi.EvaluateType(api, null, isStatic); if (tdn != null) { if (!tdn.Equals(tdn2)) { if ((tdn is NullTypeNode && tdn2 is PrimitiveTypeNode) || (tdn2 is NullTypeNode && tdn is PrimitiveTypeNode)) { throw new SemanticException("Cannot use 'null' and primitive values in an array initialization."); } if (!(tdn is NullTypeNode && tdn2 is NullTypeNode)) { throw new SemanticException("Values in array initialization are not equal. '" + tdn.ToString() + "' and '" + tdn2.ToString() + "'"); } } } tdn = tdn2; if ((vi is InlineExpressionNode)) { if (((InlineExpressionNode)vi).primary is ArrayInstantiationNode) { arraysOfarrays++; } } } if (tdn is ArrayTypeNode) { if (arraysOfarrays > 0) { for (int i = 0; i < arraysOfarrays - 1; i++) { ((ArrayTypeNode)tdn).multidimsArrays.Add(new MultidimensionArrayTypeNode(1, null)); } } else { ((ArrayTypeNode)tdn).multidimsArrays[0].dimensions++; } } else { var i = new MultidimensionArrayTypeNode(1, null); var l = new List <MultidimensionArrayTypeNode>(); l.Add(i); var a = new ArrayTypeNode(tdn, l, null); return(a); } return(tdn); }