/// <summary> /// Initializes a new instance of the <see cref="CSharpEntityExpression"/> class. /// </summary> /// <param name="context">The creation context.</param> /// <param name="source">The Easly expression from which the C# expression is created.</param> protected CSharpEntityExpression(ICSharpContext context, IEntityExpression source) : base(context, source) { if (Source.ResolvedFinalFeature.IsAssigned) { ICompiledFeature ResolvedFeature = Source.ResolvedFinalFeature.Item; if (ResolvedFeature is IScopeAttributeFeature AsScopeAttributeFeature) { ICSharpClass Owner = context.GetClass(source.EmbeddingClass); Feature = CSharpScopeAttributeFeature.Create(context, Owner, AsScopeAttributeFeature); } else { Feature = context.GetFeature(Source.ResolvedFinalFeature.Item); } } if (Source.ResolvedFinalDiscrete.IsAssigned) { ICSharpClass Class = context.GetClass(Source.ResolvedFinalDiscrete.Item.EmbeddingClass); foreach (ICSharpDiscrete Item in Class.DiscreteList) { if (Item.Source == Source.ResolvedFinalDiscrete.Item) { Debug.Assert(Discrete == null); Discrete = Item; } } } Debug.Assert((Feature != null && Discrete == null) || (Feature == null && Discrete != null)); Query = CSharpQualifiedName.Create(context, (IQualifiedName)Source.Query, Feature, Discrete, false); }
/// <summary> /// Initializes a new instance of the <see cref="CSharpOverLoopInstruction"/> class. /// </summary> /// <param name="context">The creation context.</param> /// <param name="parentFeature">The parent feature.</param> /// <param name="source">The Easly instruction from which the C# instruction is created.</param> protected CSharpOverLoopInstruction(ICSharpContext context, ICSharpFeature parentFeature, IOverLoopInstruction source) : base(context, parentFeature, source) { OverList = CSharpExpression.Create(context, (IExpression)source.OverList); LoopInstructions = CSharpScope.Create(context, parentFeature, (IScope)source.LoopInstructions); foreach (IName Name in source.IndexerList) { string IndexerName = Name.ValidText.Item; IScopeAttributeFeature IndexerFeature = Source.InnerLoopScope[IndexerName]; ICSharpScopeAttributeFeature NewIndexer = CSharpScopeAttributeFeature.Create(context, ParentFeature.Owner, IndexerFeature); IndexerList.Add(NewIndexer); } if (source.ExitEntityName.IsAssigned) { ExitEntityName = ((IIdentifier)source.ExitEntityName.Item).ValidText.Item; } foreach (IAssertion Item in Source.InvariantList) { ICSharpAssertion NewAssertion = CSharpAssertion.Create(context, Item); InvariantList.Add(NewAssertion); } }
private static bool CreateFeature(ICSharpClass owner, IFeatureInstance instance, out ICSharpFeature result) { result = null; bool IsHandled = false; ICompiledFeature SourceFeature = instance.Feature; switch (SourceFeature) { case IAttributeFeature AsAttributeFeature: result = CSharpAttributeFeature.Create(owner, instance, AsAttributeFeature); IsHandled = true; break; case IConstantFeature AsConstantFeature: result = CSharpConstantFeature.Create(owner, instance, AsConstantFeature); IsHandled = true; break; case ICreationFeature AsCreationFeature: result = CSharpCreationFeature.Create(owner, instance, AsCreationFeature); IsHandled = true; break; case IFunctionFeature AsFunctionFeature: result = CSharpFunctionFeature.Create(owner, instance, AsFunctionFeature); IsHandled = true; break; case IIndexerFeature AsIndexerFeature: result = CSharpIndexerFeature.Create(owner, instance, AsIndexerFeature); IsHandled = true; break; case IProcedureFeature AsProcedureFeature: result = CSharpProcedureFeature.Create(owner, instance, AsProcedureFeature); IsHandled = true; break; case IPropertyFeature AsPropertyFeature: result = CSharpPropertyFeature.Create(owner, instance, AsPropertyFeature); IsHandled = true; break; case IScopeAttributeFeature AsScopeAttributeFeature: result = CSharpScopeAttributeFeature.Create(owner, AsScopeAttributeFeature); IsHandled = true; break; } Debug.Assert(IsHandled); return(result != null); }
/// <summary> /// Initializes a new instance of the <see cref="CSharpQueryExpression"/> class. /// </summary> /// <param name="context">The creation context.</param> /// <param name="source">The Easly expression from which the C# expression is created.</param> protected CSharpQueryExpression(ICSharpContext context, IQueryExpression source) : base(context, source) { FeatureCall = new CSharpFeatureCall(context, source.FeatureCall.Item); if (Source.ResolvedFinalFeature.IsAssigned) { ICompiledFeature ResolvedFeature = Source.ResolvedFinalFeature.Item; if (ResolvedFeature is IScopeAttributeFeature AsScopeAttributeFeature) { ICSharpClass Owner = context.GetClass(source.EmbeddingClass); Feature = CSharpScopeAttributeFeature.Create(context, Owner, AsScopeAttributeFeature); } else { Feature = context.GetFeature(Source.ResolvedFinalFeature.Item); } } if (Source.ResolvedFinalDiscrete.IsAssigned) { DiscreteOwner = context.GetClass(Source.ResolvedFinalDiscrete.Item.EmbeddingClass); foreach (ICSharpDiscrete Item in DiscreteOwner.DiscreteList) { if (Item.Source == Source.ResolvedFinalDiscrete.Item) { Debug.Assert(Discrete == null); Discrete = Item; } } } Debug.Assert((Feature != null && Discrete == null) || (Feature == null && Discrete != null)); if (Source.SelectedOverloadType.IsAssigned) { Debug.Assert(Feature != null); SelectedOverloadType = CSharpQueryOverloadType.Create(context, Source.SelectedOverloadType.Item, Feature.Owner); } else { SelectedOverloadType = null; } Query = CSharpQualifiedName.Create(context, (IQualifiedName)Source.Query, Feature, Discrete, source.InheritBySideAttribute); }
/// <summary> /// Initializes a new instance of the <see cref="CSharpEffectiveBody"/> class. /// </summary> /// <param name="context">The creation context.</param> /// <param name="parentFeature">The parent feature.</param> /// <param name="source">The Easly body from which the C# body is created.</param> protected CSharpEffectiveBody(ICSharpContext context, ICSharpFeature parentFeature, IEffectiveBody source) : base(context, parentFeature, source) { foreach (IInstruction Instruction in source.BodyInstructionList) { ICSharpInstruction NewInstruction = CSharpInstruction.Create(context, parentFeature, Instruction); BodyInstructionList.Add(NewInstruction); } ICSharpClass Owner = parentFeature.Owner; foreach (IEntityDeclaration Item in source.EntityDeclarationList) { ICSharpScopeAttributeFeature NewDeclaration = CSharpScopeAttributeFeature.Create(context, Owner, Item.ValidEntity.Item); EntityDeclarationList.Add(NewDeclaration); } }
/// <summary> /// Initializes a new instance of the <see cref="CSharpScope"/> class. /// </summary> /// <param name="context">The creation context.</param> /// <param name="parentFeature">The parent feature.</param> /// <param name="source">The Easly node from which the C# node is created.</param> protected CSharpScope(ICSharpContext context, ICSharpFeature parentFeature, IScope source) : base(source) { ParentFeature = parentFeature; foreach (IEntityDeclaration Declaration in source.EntityDeclarationList) { ICSharpScopeAttributeFeature NewDeclaration = CSharpScopeAttributeFeature.Create(context, parentFeature.Owner, Declaration.ValidEntity.Item); EntityDeclarationList.Add(NewDeclaration); } foreach (IInstruction Instruction in source.InstructionList) { ICSharpInstruction NewInstruction = CSharpInstruction.Create(context, parentFeature, Instruction); InstructionList.Add(NewInstruction); } }
/// <summary> /// Initializes a new instance of the <see cref="CSharpForLoopInstruction"/> class. /// </summary> /// <param name="context">The creation context.</param> /// <param name="parentFeature">The parent feature.</param> /// <param name="source">The Easly instruction from which the C# instruction is created.</param> protected CSharpForLoopInstruction(ICSharpContext context, ICSharpFeature parentFeature, IForLoopInstruction source) : base(context, parentFeature, source) { foreach (IEntityDeclaration Declaration in source.EntityDeclarationList) { ICSharpScopeAttributeFeature NewDeclaration = CSharpScopeAttributeFeature.Create(context, parentFeature.Owner, Declaration.ValidEntity.Item); EntityDeclarationList.Add(NewDeclaration); } foreach (IInstruction Instruction in source.InitInstructionList) { ICSharpInstruction NewInstruction = Create(context, parentFeature, Instruction); InitInstructionList.Add(NewInstruction); } WhileCondition = CSharpExpression.Create(context, (IExpression)source.WhileCondition); foreach (IInstruction Instruction in source.LoopInstructionList) { ICSharpInstruction NewInstruction = Create(context, parentFeature, Instruction); LoopInstructionList.Add(NewInstruction); } foreach (IInstruction Instruction in source.IterationInstructionList) { ICSharpInstruction NewInstruction = Create(context, parentFeature, Instruction); IterationInstructionList.Add(NewInstruction); } if (source.Variant.IsAssigned) { VariantExpression = CSharpExpression.Create(context, (IExpression)source.Variant.Item); } foreach (IAssertion Item in Source.InvariantList) { ICSharpAssertion NewAssertion = CSharpAssertion.Create(context, Item); InvariantList.Add(NewAssertion); } }
/// <summary> /// Initializes a new instance of the <see cref="CSharpCommandInstruction"/> class. /// </summary> /// <param name="context">The creation context.</param> /// <param name="parentFeature">The parent feature.</param> /// <param name="source">The Easly instruction from which the C# instruction is created.</param> protected CSharpCommandInstruction(ICSharpContext context, ICSharpFeature parentFeature, ICommandInstruction source) : base(context, parentFeature, source) { Command = CSharpQualifiedName.Create(context, (IQualifiedName)source.Command, parentFeature, null, false); FeatureCall = new CSharpFeatureCall(context, source.FeatureCall.Item); ICompiledFeature SourceFeature = source.SelectedFeature.Item; if (SourceFeature is IScopeAttributeFeature AsScopeAttributeFeature) { FinalFeature = CSharpScopeAttributeFeature.Create(null, AsScopeAttributeFeature); } else { FinalFeature = context.GetFeature(SourceFeature); } ICompiledTypeWithFeature ResolvedBaseType = Source.CommandFinalType.Item.ResolvedBaseType.Item; FinalType = CSharpType.Create(context, ResolvedBaseType) as ICSharpTypeWithFeature; Debug.Assert(FinalType != null); IList <ICSharpClassType> ConformingClassTypeList = FinalType.ConformingClassTypeList; bool InheritFromDotNetEvent = false; bool IsNumberType = false; foreach (ICSharpClassType Item in ConformingClassTypeList) { ICSharpClass CallClass = Item.Class; InheritFromDotNetEvent |= CallClass.InheritFromDotNetEvent; IsNumberType = Item.IsNumberType; } SkipLastInPath = InheritFromDotNetEvent; IsCallingNumberFeature = IsNumberType; }
/// <summary> /// Initializes a new instance of the <see cref="CSharpAssignmentInstruction"/> class. /// </summary> /// <param name="context">The creation context.</param> /// <param name="parentFeature">The parent feature.</param> /// <param name="source">The Easly instruction from which the C# instruction is created.</param> protected CSharpAssignmentInstruction(ICSharpContext context, ICSharpFeature parentFeature, IAssignmentInstruction source) : base(context, parentFeature, source) { SourceExpression = CSharpExpression.Create(context, (IExpression)Source.Source); foreach (IQualifiedName Destination in source.DestinationList) { ICompiledFeature SourceFeature = source.FinalFeatureTable[Destination]; ICSharpFeature FinalFeature; if (SourceFeature is IScopeAttributeFeature AsScopeAttributeFeature) { FinalFeature = CSharpScopeAttributeFeature.Create(null, AsScopeAttributeFeature); } else { FinalFeature = context.GetFeature(SourceFeature); } ICSharpQualifiedName NewDestination = CSharpQualifiedName.Create(context, Destination, FinalFeature, null, false); DestinationList.Add(NewDestination); } }
/// <summary> /// Initializes a new instance of the <see cref="CSharpParameter"/> class. /// </summary> /// <param name="context">The creation context.</param> /// <param name="source">The Easly node from which the C# node is created.</param> /// <param name="owner">The class where the parameter is declared.</param> protected CSharpParameter(ICSharpContext context, IParameter source, ICSharpClass owner) : base(source) { Feature = CSharpScopeAttributeFeature.Create(context, owner, source.ResolvedParameter); }