/// <summary></summary>
protected virtual void GenerateCompilationDateTime()
{
DateTime Now = DateTime.UtcNow;
string IsoString = Now.ToString("u", CultureInfo.InvariantCulture);
CompilationDateTime = InitializedStringExpression(LanguageClasses.DateAndTime.Name, nameof(DateAndTime.ToUtcDateAndTime), IsoString);
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpInitializedObjectExpression"/> class.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="source">The Easly expression from which the C# expression is created.</param>
protected CSharpInitializedObjectExpression(ICSharpContext context, IInitializedObjectExpression source)
: base(context, source)
{
Class = context.GetClass(source.ResolvedClassType.Item.BaseClass);
foreach (IAssignmentArgument Argument in source.AssignmentList)
{
ICSharpAssignmentArgument NewAssignment = CSharpAssignmentArgument.Create(context, Argument);
AssignmentList.Add(NewAssignment);
}
}
/// <summary>
/// Finds the matching nodes of a <see cref="IInitializedObjectExpression"/>.
/// </summary>
/// <param name="node">The agent expression to check.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="resolvedResult">The expression result types upon return.</param>
/// <param name="resolvedException">Exceptions the expression can throw upon return.</param>
/// <param name="constantSourceList">Sources of the constant expression upon return, if any.</param>
/// <param name="expressionConstant">The expression constant upon return.</param>
/// <param name="initializedObjectTypeName">The initialized object type name upon return.</param>
/// <param name="initializedObjectType">The initialized object type upon return.</param>
/// <param name="assignedFeatureTable">The table of assigned values upon return.</param>
public static bool ResolveCompilerReferences(IInitializedObjectExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant, out ITypeName initializedObjectTypeName, out IClassType initializedObjectType, out ISealableDictionary <string, ICompiledFeature> assignedFeatureTable)
{
resolvedResult = null;
resolvedException = null;
constantSourceList = new SealableList <IExpression>();
expressionConstant = NeutralLanguageConstant.NotConstant;
initializedObjectTypeName = null;
initializedObjectType = null;
assignedFeatureTable = new SealableDictionary <string, ICompiledFeature>();
IIdentifier ClassIdentifier = (IIdentifier)node.ClassIdentifier;
IList <IAssignmentArgument> AssignmentList = node.AssignmentList;
IClass EmbeddingClass = node.EmbeddingClass;
string ValidText = ClassIdentifier.ValidText.Item;
if (!EmbeddingClass.ImportedClassTable.ContainsKey(ValidText))
{
errorList.AddError(new ErrorUnknownIdentifier(ClassIdentifier, ValidText));
return(false);
}
IClass BaseClass = EmbeddingClass.ImportedClassTable[ValidText].Item;
Debug.Assert(BaseClass.ResolvedClassTypeName.IsAssigned);
Debug.Assert(BaseClass.ResolvedClassType.IsAssigned);
initializedObjectTypeName = BaseClass.ResolvedClassTypeName.Item;
initializedObjectType = BaseClass.ResolvedClassType.Item;
if (!CheckAssignemntList(node, errorList, BaseClass.FeatureTable, constantSourceList, assignedFeatureTable))
{
return(false);
}
resolvedResult = new ResultType(initializedObjectTypeName, initializedObjectType, string.Empty);
if (!ResolveObjectInitialization(node, errorList, assignedFeatureTable))
{
return(false);
}
resolvedException = new ResultException();
#if COVERAGE
Debug.Assert(!node.IsComplex);
#endif
return(true);
}
/// <summary>
/// Compares two expressions.
/// </summary>
/// <param name="other">The other expression.</param>
protected bool IsExpressionEqual(IInitializedObjectExpression other)
{
Debug.Assert(other != null);
bool Result = true;
Result &= AssignmentList.Count == other.AssignmentList.Count;
for (int i = 0; i < AssignmentList.Count && i < other.AssignmentList.Count; i++)
{
IAssignmentArgument InitializationAssignment1 = AssignmentList[i];
IAssignmentArgument InitializationAssignment2 = other.AssignmentList[i];
Result &= AssignmentArgument.IsAssignmentArgumentEqual(InitializationAssignment1, InitializationAssignment2);
}
return(Result);
}
/// <summary></summary>
protected virtual IInitializedObjectExpression InitializedExpression(string className, string identifierName, BaseNode.IExpression manifestValue)
{
BaseNode.IIdentifier ClassIdentifier = NodeHelper.CreateSimpleIdentifier(className);
BaseNode.IIdentifier FirstIdentifier = NodeHelper.CreateSimpleIdentifier(identifierName);
BaseNode.IAssignmentArgument FirstArgument = NodeHelper.CreateAssignmentArgument(new List <BaseNode.IIdentifier>()
{
FirstIdentifier
}, manifestValue);
BaseNode.IInitializedObjectExpression Expression = NodeHelper.CreateInitializedObjectExpression(ClassIdentifier, new List <BaseNode.IAssignmentArgument>()
{
FirstArgument
});
IInitializedObjectExpression Result = ToCompilerNode <BaseNode.IInitializedObjectExpression, IInitializedObjectExpression>(Expression);
return(Result);
}
private static bool CheckAssignemntList(IInitializedObjectExpression node, IErrorList errorList, ISealableDictionary <IFeatureName, IFeatureInstance> featureTable, ISealableList <IExpression> constantSourceList, ISealableDictionary <string, ICompiledFeature> assignedFeatureTable)
{
bool Success = true;
IList <IAssignmentArgument> AssignmentList = node.AssignmentList;
foreach (IAssignmentArgument AssignmentItem in AssignmentList)
{
constantSourceList.Add((IExpression)AssignmentItem.Source);
IResultType ExpressionResult = AssignmentItem.ResolvedResult.Item;
if (ExpressionResult.Count < AssignmentItem.ParameterList.Count)
{
errorList.AddError(new ErrorInvalidInstruction(AssignmentItem));
Success = false;
}
foreach (IIdentifier IdentifierItem in AssignmentItem.ParameterList)
{
Success &= CheckAssignemntIdentifier(errorList, featureTable, assignedFeatureTable, IdentifierItem);
}
}
return(Success);
}
/// <summary>
/// Creates a new C# expression.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="source">The Easly expression from which the C# expression is created.</param>
public static ICSharpInitializedObjectExpression Create(ICSharpContext context, IInitializedObjectExpression source)
{
return(new CSharpInitializedObjectExpression(context, source));
}
