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