/// <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);
}
