/// <summary> /// Check number types. /// </summary> /// <param name="isChanged">True upon return if a number type was changed.</param> public void CheckNumberType(ref bool isChanged) { foreach (IEntityDeclaration EntityDeclaration in EntityDeclarationList) { EntityDeclaration.CheckNumberType(ref isChanged); } foreach (IInstruction Instruction in InitInstructionList) { Instruction.CheckNumberType(ref isChanged); } ((IExpression)WhileCondition).CheckNumberType(ref isChanged); foreach (IInstruction Instruction in LoopInstructionList) { Instruction.CheckNumberType(ref isChanged); } foreach (IInstruction Instruction in IterationInstructionList) { Instruction.CheckNumberType(ref isChanged); } if (Variant.IsAssigned) { ((IExpression)Variant.Item).CheckNumberType(ref isChanged); } }
/// <summary> /// Validates number types. If not valid, adds an error. /// </summary> /// <param name="errorList">The list of errors found.</param> public void ValidateNumberType(IErrorList errorList) { foreach (IEntityDeclaration EntityDeclaration in EntityDeclarationList) { EntityDeclaration.ValidateNumberType(errorList); } foreach (IInstruction Instruction in InitInstructionList) { Instruction.ValidateNumberType(errorList); } ((IExpression)WhileCondition).ValidateNumberType(errorList); foreach (IInstruction Instruction in LoopInstructionList) { Instruction.ValidateNumberType(errorList); } foreach (IInstruction Instruction in IterationInstructionList) { Instruction.ValidateNumberType(errorList); } if (Variant.IsAssigned) { ((IExpression)Variant.Item).ValidateNumberType(errorList); } }
/// <summary> /// Creates an instance of a class type, or reuse an existing instance. /// </summary> /// <param name="instancingClassType">The class type to instanciate.</param> /// <param name="resolvedTypeName">The proposed type instance name.</param> /// <param name="resolvedType">The proposed type instance.</param> public void InstanciateType(ICompiledTypeWithFeature instancingClassType, ref ITypeName resolvedTypeName, ref ICompiledType resolvedType) { ISealableDictionary <ITypeName, ICompiledType> TypeTable = GetTypeTable(); Debug.Assert(TypeTable.Count == 0); bool IsNewInstance = false; IList <IEntityDeclaration> InstancedFieldList = new List <IEntityDeclaration>(); foreach (IEntityDeclaration Field in EntityDeclarationList) { Debug.Assert(Field.ValidEntity.IsAssigned); Debug.Assert(Field.ValidEntity.Item.ResolvedEffectiveTypeName.IsAssigned); Debug.Assert(Field.ValidEntity.Item.ResolvedEffectiveType.IsAssigned); ITypeName InstancedFieldTypeName = Field.ValidEntity.Item.ResolvedEffectiveTypeName.Item; ICompiledType InstancedFieldType = Field.ValidEntity.Item.ResolvedEffectiveType.Item; InstancedFieldType.InstanciateType(instancingClassType, ref InstancedFieldTypeName, ref InstancedFieldType); IsNewInstance |= InstancedFieldType != Field.ValidEntity.Item.ResolvedEffectiveType.Item; IEntityDeclaration InstancedField = new EntityDeclaration(Field, InstancedFieldTypeName, InstancedFieldType); InstancedFieldList.Add(InstancedField); } if (IsNewInstance) { ISealableDictionary <ITypeName, ICompiledType> InstancingTypeTable = instancingClassType.GetTypeTable(); ResolveType(InstancingTypeTable, EntityDeclarationList, Sharing, out resolvedTypeName, out resolvedType); } }
/// <summary> /// Validates number types. If not valid, adds an error. /// </summary> /// <param name="errorList">The list of errors found.</param> public void ValidateNumberType(IErrorList errorList) { foreach (IEntityDeclaration EntityDeclaration in ParameterList) { EntityDeclaration.ValidateNumberType(errorList); } ((IBody)CommandBody).ValidateNumberType(errorList); }
/// <summary> /// Check number types. /// </summary> /// <param name="isChanged">True upon return if a number type was changed.</param> public void CheckNumberType(ref bool isChanged) { foreach (IEntityDeclaration EntityDeclaration in ParameterList) { EntityDeclaration.CheckNumberType(ref isChanged); } ((IBody)CommandBody).CheckNumberType(ref isChanged); }
/// <summary> /// Validates number types. If not valid, adds an error. /// </summary> /// <param name="errorList">The list of errors found.</param> public void ValidateNumberType(IErrorList errorList) { foreach (IEntityDeclaration EntityDeclaration in EntityDeclarationList) { EntityDeclaration.ValidateNumberType(errorList); } foreach (IInstruction Instruction in BodyInstructionList) { Instruction.ValidateNumberType(errorList); } }
/// <summary> /// Check number types. /// </summary> /// <param name="isChanged">True upon return if a number type was changed.</param> public void CheckNumberType(ref bool isChanged) { foreach (IEntityDeclaration EntityDeclaration in EntityDeclarationList) { EntityDeclaration.CheckNumberType(ref isChanged); } foreach (IInstruction Instruction in BodyInstructionList) { Instruction.CheckNumberType(ref isChanged); } }
/// <summary> /// Restarts a check of number types. /// </summary> public void RestartNumberType(ref bool isChanged) { foreach (IEntityDeclaration EntityDeclaration in EntityDeclarationList) { EntityDeclaration.RestartNumberType(ref isChanged); } foreach (IInstruction Instruction in InstructionList) { Instruction.RestartNumberType(ref isChanged); } }
/// <summary> /// Creates an instance of a class type, or reuse an existing instance. /// </summary> /// <param name="instancingClassType">The class type to instanciate.</param> /// <param name="resolvedTypeName">The proposed type instance name.</param> /// <param name="resolvedType">The proposed type instance.</param> public void InstanciateType(ICompiledTypeWithFeature instancingClassType, ref ITypeName resolvedTypeName, ref ICompiledType resolvedType) { bool IsNewInstance = false; ITypeName InstancedBaseTypeName = ResolvedBaseTypeName.Item; ICompiledType InstancedBaseType = ResolvedBaseType.Item; InstancedBaseType.InstanciateType(instancingClassType, ref InstancedBaseTypeName, ref InstancedBaseType); IsNewInstance |= InstancedBaseType != ResolvedBaseType.Item; ITypeName InstancedEntityTypeName = ResolvedEntityTypeName.Item; ICompiledType InstancedEntityType = ResolvedEntityType.Item; InstancedEntityType.InstanciateType(instancingClassType, ref InstancedEntityTypeName, ref InstancedEntityType); IsNewInstance |= InstancedEntityType != ResolvedEntityType.Item; IList <IEntityDeclaration> InstancedIndexParameterList = new List <IEntityDeclaration>(); foreach (IEntityDeclaration Parameter in IndexParameterList) { ITypeName InstancedParameterTypeName = Parameter.ValidEntity.Item.ResolvedEffectiveTypeName.Item; ICompiledType InstancedParameterType = Parameter.ValidEntity.Item.ResolvedEffectiveType.Item; InstancedParameterType.InstanciateType(instancingClassType, ref InstancedParameterTypeName, ref InstancedParameterType); IEntityDeclaration InstancedParameter = new EntityDeclaration(Parameter, InstancedParameterTypeName, InstancedParameterType); IName ParameterName = (Name)Parameter.EntityName; IScopeAttributeFeature NewEntity; if (Parameter.DefaultValue.IsAssigned) { // The default value has already been checked and validated. bool IsCreated = ScopeAttributeFeature.Create(Parameter, ParameterName.ValidText.Item, InstancedParameterTypeName, InstancedParameterType, (IExpression)Parameter.DefaultValue.Item, ErrorList.Ignored, out NewEntity); Debug.Assert(IsCreated); } else { NewEntity = ScopeAttributeFeature.Create(Parameter, ParameterName.ValidText.Item, InstancedParameterTypeName, InstancedParameterType); } IsNewInstance |= InstancedParameterType != Parameter.ValidEntity.Item.ResolvedEffectiveType.Item; InstancedParameter.ValidEntity.Item = NewEntity; InstancedIndexParameterList.Add(InstancedParameter); } if (IsNewInstance) { ISealableDictionary <ITypeName, ICompiledType> TypeTable = instancingClassType.GetTypeTable(); ResolveType(TypeTable, InstancedBaseTypeName, (IClassType)InstancedBaseType, InstancedEntityTypeName, InstancedEntityType, IndexerKind, InstancedIndexParameterList, ParameterEnd, GetRequireList, GetEnsureList, GetExceptionIdentifierList, SetRequireList, SetEnsureList, SetExceptionIdentifierList, out resolvedTypeName, out resolvedType); } }
/// <summary> /// Restarts a check of number types. /// </summary> public void RestartNumberType(ref bool isChanged) { foreach (IEntityDeclaration EntityDeclaration in ParameterList) { EntityDeclaration.RestartNumberType(ref isChanged); } foreach (IEntityDeclaration EntityDeclaration in ResultList) { EntityDeclaration.RestartNumberType(ref isChanged); } if (Variant.IsAssigned) { ((IExpression)Variant).RestartNumberType(ref isChanged); } ((IBody)QueryBody).RestartNumberType(ref isChanged); if (ParameterTable.Count > 0) { if (NumberArgumentTable.Count == 0) { for (int i = 0; i < ParameterTable.Count; i++) { IParameter Parameter = ParameterTable[i]; NumberArgumentTable.Add(Parameter, new List <NumberKinds>()); } } else { // Result of the previous pass. for (int i = 0; i < ParameterTable.Count; i++) { IParameter Parameter = ParameterTable[i]; Debug.Assert(NumberArgumentTable.ContainsKey(Parameter)); Debug.Assert(Parameter.ResolvedParameter.ResolvedEffectiveType.IsAssigned); if (Parameter.ResolvedParameter.ResolvedEffectiveType.Item is ICompiledNumberType AsNumberType) { NumberKinds BestGuess = AsNumberType.GetDefaultNumberKind(); UpdateParameterKind(NumberArgumentTable[Parameter], ref BestGuess); AsNumberType.UpdateNumberKind(BestGuess, ref isChanged); } NumberArgumentTable[Parameter].Clear(); } } } }
/// <summary> /// Finds or creates an overload type with the corresponding parameters. /// </summary> /// <param name="instancingClassType">The type attempting to find the overload type.</param> /// <param name="instancedOverload">The new overload type upon return if not found.</param> public static void InstanciateCommandOverloadType(ICompiledTypeWithFeature instancingClassType, ref ICommandOverloadType instancedOverload) { bool IsNewInstance = false; IList <IEntityDeclaration> InstancedParameterList = new List <IEntityDeclaration>(); foreach (IEntityDeclaration Parameter in instancedOverload.ParameterList) { ITypeName InstancedParameterTypeName = Parameter.ValidEntity.Item.ResolvedEffectiveTypeName.Item; ICompiledType InstancedParameterType = Parameter.ValidEntity.Item.ResolvedEffectiveType.Item; InstancedParameterType.InstanciateType(instancingClassType, ref InstancedParameterTypeName, ref InstancedParameterType); IEntityDeclaration InstancedParameter = new EntityDeclaration(Parameter, InstancedParameterTypeName, InstancedParameterType); IName ParameterName = (IName)Parameter.EntityName; IScopeAttributeFeature NewEntity; if (Parameter.DefaultValue.IsAssigned) { // The default value has already been checked and validated. bool IsCreated = ScopeAttributeFeature.Create(Parameter, ParameterName.ValidText.Item, InstancedParameterTypeName, InstancedParameterType, (IExpression)Parameter.DefaultValue.Item, ErrorList.Ignored, out NewEntity); Debug.Assert(IsCreated); } else { NewEntity = ScopeAttributeFeature.Create(Parameter, ParameterName.ValidText.Item, InstancedParameterTypeName, InstancedParameterType); } InstancedParameter.ValidEntity.Item = NewEntity; InstancedParameterList.Add(InstancedParameter); if (InstancedParameterType != Parameter.ValidEntity.Item.ResolvedEffectiveType.Item) { IsNewInstance = true; } } if (IsNewInstance) { ICommandOverloadType NewOverloadInstance = new CommandOverloadType(InstancedParameterList, instancedOverload.ParameterEnd, instancedOverload.RequireList, instancedOverload.EnsureList, instancedOverload.ExceptionIdentifierList); foreach (IEntityDeclaration Item in InstancedParameterList) { string ValidName = Item.ValidEntity.Item.ValidFeatureName.Item.Name; NewOverloadInstance.ParameterTable.Add(new Parameter(ValidName, Item.ValidEntity.Item)); } instancedOverload = NewOverloadInstance; } }
/// <summary> /// Validates number types. If not valid, adds an error. /// </summary> /// <param name="errorList">The list of errors found.</param> public void ValidateNumberType(IErrorList errorList) { foreach (IEntityDeclaration EntityDeclaration in ParameterList) { EntityDeclaration.ValidateNumberType(errorList); } foreach (IEntityDeclaration EntityDeclaration in ResultList) { EntityDeclaration.ValidateNumberType(errorList); } if (Variant.IsAssigned) { ((IExpression)Variant).ValidateNumberType(errorList); } ((IBody)QueryBody).ValidateNumberType(errorList); }
/// <summary> /// Check number types. /// </summary> /// <param name="isChanged">True upon return if a number type was changed.</param> public void CheckNumberType(ref bool isChanged) { foreach (IEntityDeclaration EntityDeclaration in ParameterList) { EntityDeclaration.CheckNumberType(ref isChanged); } foreach (IEntityDeclaration EntityDeclaration in ResultList) { EntityDeclaration.CheckNumberType(ref isChanged); } if (Variant.IsAssigned) { ((IExpression)Variant).CheckNumberType(ref isChanged); } ((IBody)QueryBody).CheckNumberType(ref isChanged); }