protected void InsertCodeInRunWorkflowMethod(GraphicElement root, StringBuilder code)
{
ICSharpClass cls = (ICSharpClass)root;
string existingCode = String.Empty;
// TODO: Verify that root.Json["Code"] defines the namespace, class, and stub, or figure out how to include "using" and field initialization and properties such that
// we can create the namespace, class, and stub for the user.
if (root.Json.ContainsKey("Code"))
{
existingCode = root.Json["Code"];
}
//string before = existingCode.LeftOf("void RunWorkflow()");
//string after = existingCode.RightOf("void RunWorkflow()").RightOfMatching('{', '}');
//StringBuilder finalCode = new StringBuilder(before);
StringBuilder finalCode = new StringBuilder();
finalCode.AppendLine("using System;");
finalCode.AppendLine("using System.Linq;");
finalCode.AppendLine();
finalCode.AppendLine("namespace " + cls.NamespaceName);
finalCode.AppendLine("{");
finalCode.AppendLine(" public partial class " + cls.ClassName);
finalCode.AppendLine(" {");
finalCode.AppendLine(new String(' ', 8) + "public void " + cls.MethodName + "()");
finalCode.AppendLine(new String(' ', 8) + "{");
finalCode.AppendLine(new String(' ', 12) + code.ToString().Trim());
finalCode.AppendLine(new String(' ', 8) + "}");
finalCode.AppendLine(" }");
finalCode.AppendLine("}");
// finalCode.Append(after);
root.Json["Code"] = finalCode.ToString();
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpFeatureCall"/> class.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="source">Details of the feature call.</param>
public CSharpFeatureCall(ICSharpContext context, IFeatureCall source)
{
foreach (IParameter Item in source.ParameterList)
{
ICSharpClass Owner = context.GetClass(Item.ResolvedParameter.Location.EmbeddingClass);
ICSharpParameter NewParameter = CSharpParameter.Create(context, Item, Owner);
ParameterList.Add(NewParameter);
}
foreach (IParameter Item in source.ResultList)
{
ICSharpClass Owner = context.GetClass(Item.ResolvedParameter.Location.EmbeddingClass);
ICSharpParameter NewParameter = CSharpParameter.Create(context, Item, Owner);
ResultList.Add(NewParameter);
}
foreach (IArgument Item in source.ArgumentList)
{
ICSharpArgument NewArgument = CSharpArgument.Create(context, Item);
ArgumentList.Add(NewArgument);
}
Debug.Assert(ParameterList.Count >= ArgumentList.Count);
Count = ParameterList.Count;
ArgumentStyle = source.TypeArgumentStyle;
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpFeature{T}"/> class.
/// </summary>
/// <param name="owner">The class where the feature is declared.</param>
/// <param name="source">The source Easly feature.</param>
protected CSharpFeature(ICSharpClass owner, T source)
: base(source)
{
Debug.Assert(source is IScopeAttributeFeature);
Owner = owner;
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpInheritance"/> class.
/// </summary>
/// <param name="source">The Easly node from which the C# node is created.</param>
/// <param name="ancestorClass">The ancestor class.</param>
protected CSharpInheritance(IInheritance source, ICSharpClass ancestorClass)
: base(source)
{
Debug.Assert(ancestorClass != null);
AncestorClass = ancestorClass;
}
/// <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="CSharpFeature{T}"/> class.
/// </summary>
/// <param name="owner">The class where the feature is declared.</param>
/// <param name="instance">The source feature instance.</param>
/// <param name="source">The source Easly feature.</param>
protected CSharpFeature(ICSharpClass owner, IFeatureInstance instance, T source)
: base(source)
{
Owner = owner;
Instance = instance;
Debug.Assert(Instance.Feature == Source);
}
private bool GetBaseClass(ICSharpClass cSharpClass, IClassSplitting splitting, IDictionary <IClass, ICSharpClass> classTable, out ICSharpClass result)
{
result = null;
IClass BaseClass = null;
// If the class inherits from a class that must be a parent, select it as base class.
foreach (IInheritance InheritanceItem in cSharpClass.Source.InheritanceList)
{
IClassType ClassParentType = InheritanceItem.ResolvedClassParentType.Item;
IClass ParentClass = ClassParentType.BaseClass;
Debug.Assert(ParentClass != null);
if (splitting.MustInherit.Contains(ParentClass))
{
Debug.Assert(BaseClass == null);
BaseClass = ParentClass;
}
}
// No such class. Try classes that don't have to be interface.
if (BaseClass == null)
{
IList <IClass> ParentCandidates = new List <IClass>();
foreach (IInheritance InheritanceItem in cSharpClass.Source.InheritanceList)
{
IClassType ClassParentType = InheritanceItem.ResolvedClassParentType.Item;
IClass ParentClass = ClassParentType.BaseClass;
if (splitting.OtherParents.Contains(ParentClass))
{
ParentCandidates.Add(ParentClass);
}
}
if (ParentCandidates.Count > 0)
{
BaseClass = ParentCandidates[0];
}
}
if (BaseClass != null)
{
foreach (KeyValuePair <IClass, ICSharpClass> Entry in classTable)
{
ICSharpClass Item = Entry.Value;
if (Item.Source == BaseClass)
{
Debug.Assert(result == null);
result = Item;
}
}
}
return(result != null);
}
/// <summary>
/// Gets the export status of a feature in the class that implements it.
/// </summary>
/// <param name="sourceClass">The class implementing the feature.</param>
public virtual CSharpExports GetExportStatus(ICSharpClass sourceClass)
{
bool IsExportedToClient;
IFeature AsFeature = Source as IFeature;
Debug.Assert(AsFeature != null);
IIdentifier Identifier = (IIdentifier)AsFeature.ExportIdentifier;
string ExportIdentifier = Identifier.ValidText.Item;
if (ExportIdentifier == "All")
{
IsExportedToClient = true;
}
else if (ExportIdentifier == "None" || ExportIdentifier == "Self")
{
IsExportedToClient = false;
}
else
{
FeatureName.TableContain(Owner.Source.ExportTable, ExportIdentifier, out IFeatureName ExportName, out ISealableDictionary <string, IClass> ExportList);
Debug.Assert(ExportList.Count > 0);
if (ExportList.Count > 1)
{
IsExportedToClient = true;
}
else
{
if (ExportList.ContainsKey(sourceClass.ValidClassName))
{
IsExportedToClient = false; // Export to self = self + descendant = protected
}
else
{
IsExportedToClient = true; // export to another = export to all = public
}
}
}
if (IsExportedToClient)
{
return(CSharpExports.Public);
}
else if (AsFeature.Export == BaseNode.ExportStatus.Exported)
{
return(CSharpExports.Protected);
}
else
{
return(CSharpExports.Private);
}
}
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);
}
private bool CreateClasses(out IDictionary <IClass, ICSharpClass> classTable)
{
classTable = null;
if (!ClassSplitting.Create(Compiler.LoadedRoot.ClassList, ErrorList, out IClassSplitting Splitting))
{
return(false);
}
classTable = new Dictionary <IClass, ICSharpClass>();
ICSharpClass ClassAny = CSharpClass.Create(Class.ClassAny);
classTable.Add(Class.ClassAny, ClassAny);
ICSharpClass ClassAnyReference = CSharpClass.Create(Class.ClassAnyReference);
classTable.Add(Class.ClassAnyReference, ClassAnyReference);
ICSharpClass ClassAnyValue = CSharpClass.Create(Class.ClassAnyValue);
classTable.Add(Class.ClassAnyValue, ClassAnyValue);
foreach (IClass Class in Compiler.LoadedRoot.ClassList)
{
ICSharpClass NewCSharpClass = CSharpClass.Create(Class);
classTable.Add(Class, NewCSharpClass);
}
foreach (KeyValuePair <IClass, ICSharpClass> Entry in classTable)
{
ICSharpClass Class = Entry.Value;
if (GetBaseClass(Class, Splitting, classTable, out ICSharpClass BaseClass))
{
Class.SetBaseClass(BaseClass);
}
Class.SetAncestorClasses(classTable);
}
foreach (KeyValuePair <IClass, ICSharpClass> Entry in classTable)
{
ICSharpClass Class = Entry.Value;
CheckRename(Class, ErrorList);
}
if (!ErrorList.IsEmpty)
{
return(false);
}
return(true);
}
private void WriteCSharpImplementation(ICSharpWriter writer, CSharpExports exportStatus, ref bool isFirstFeature, ref bool isMultiline)
{
bool IsEvent = false;
if (Type is ICSharpClassType AsClassType)
{
ICSharpClass Class = AsClassType.Class;
if (Class.InheritFromDotNetEvent)
{
IsEvent = true;
}
}
writer.WriteDocumentation(Source);
CSharpAssertion.WriteContract(writer, new List <ICSharpAssertion>(), EnsureList, CSharpContractLocations.Other, false, ref isFirstFeature, ref isMultiline);
string TypeString = Type.Type2CSharpString(writer, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None);
string AttributeString = CSharpNames.ToCSharpIdentifier(Name);
string ExportString = CSharpNames.ComposedExportStatus(false, false, true, exportStatus);
if (IsEvent)
{
writer.WriteIndentedLine($"{ExportString} event {TypeString} {AttributeString};");
}
else if (Type.GetSingletonString(writer, CSharpTypeFormats.Normal, CSharpNamespaceFormats.None, out string SingletonString))
{
writer.WriteIndentedLine($"{ExportString} {TypeString} {AttributeString} {{ get {{ return {SingletonString}; }} }}");
}
else if (EnsureList.Count > 0)
{
writer.WriteIndentedLine($"{ExportString} {TypeString} {AttributeString} {{ get; private set; }}");
writer.WriteIndentedLine($"protected void Set_{AttributeString}({TypeString} value)");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
writer.WriteIndentedLine($"{AttributeString} = value;");
writer.WriteEmptyLine();
foreach (ICSharpAssertion Assertion in EnsureList)
{
Assertion.WriteCSharp(writer);
}
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
else
{
writer.WriteIndentedLine($"{ExportString} {TypeString} {AttributeString} {{ get; protected set; }}");
}
}
private void CheckSharedName(ICSharpClass cSharpClass, IDictionary <IClass, ICSharpClass> classTable)
{
foreach (KeyValuePair <IClass, ICSharpClass> Entry in classTable)
{
ICSharpClass OtherClass = Entry.Value;
if (cSharpClass.ValidClassName == OtherClass.ValidClassName)
{
cSharpClass.SetIsSharedName();
break;
}
}
}
/// <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>
/// Gets the source code corresponding to the qualified name.
/// </summary>
/// <param name="usingCollection">The collection of using directives.</param>
/// <param name="skippedAtEnd">Number of identifiers to skip at the end.</param>
public string CSharpText(ICSharpUsingCollection usingCollection, int skippedAtEnd)
{
string Result;
int i = 0;
/*
* if (Context.AttachmentAliasTable.ContainsKey(ValidPath.Item[i].ValidText.Item))
* {
* Result = Context.AttachmentAliasTable[ValidPath.Item[i].ValidText.Item];
* i++;
* }
* else*/
Result = string.Empty;
for (; i + skippedAtEnd < Source.ValidPath.Item.Count; i++)
{
if (Result.Length > 0)
{
Result += ".";
}
IIdentifier Item = Source.ValidPath.Item[i];
ICSharpClass ItemClass = i < ClassPath.Count ? ClassPath[i] : null;
string ItemText = Item.ValidText.Item;
if (i == 0 && usingCollection.AttachmentMap.ContainsKey(Item.ValidText.Item))
{
ItemText = usingCollection.AttachmentMap[ItemText];
}
else
{
ItemText = CSharpNames.ToCSharpIdentifier(ItemText);
}
if (ItemClass != null)
{
if (ItemClass.IsUnparameterizedSingleton && ItemClass.ValidSourceName != "Microsoft .NET")
{
string TypeText = ItemClass.Type.Type2CSharpString(usingCollection, CSharpTypeFormats.Normal, CSharpNamespaceFormats.None);
ItemText = $"{TypeText}.Singleton";
}
}
Result += ItemText;
}
return(Result);
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpProcedureType"/> class.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="source">The Easly type from which the C# type is created.</param>
/// <param name="originatingTypedef">The typedef where this type is declared.</param>
protected CSharpProcedureType(ICSharpContext context, IProcedureType source, ICSharpTypedef originatingTypedef)
: base(context, source, originatingTypedef)
{
Debug.Assert(source.OverloadList.Count > 0);
ICSharpClass Owner = context.GetClass(source.EmbeddingClass);
BaseType = Create(context, source.ResolvedBaseType.Item) as ICSharpTypeWithFeature;
Debug.Assert(BaseType != null);
foreach (ICommandOverloadType OverloadType in source.OverloadList)
{
ICSharpCommandOverloadType NewOverloadType = CSharpCommandOverloadType.Create(context, OverloadType, Owner);
OverloadTypeList.Add(NewOverloadType);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpFunctionType"/> class.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="source">The Easly type from which the C# type is created.</param>
protected CSharpFunctionType(ICSharpContext context, IFunctionType source)
: base(context, source)
{
Debug.Assert(source.OverloadList.Count > 0);
ICSharpClass Owner = source.EmbeddingClass != null?context.GetClass(source.EmbeddingClass) : null;
BaseType = Create(context, source.ResolvedBaseType.Item) as ICSharpTypeWithFeature;
Debug.Assert(BaseType != null);
foreach (IQueryOverloadType OverloadType in source.OverloadList)
{
ICSharpQueryOverloadType NewOverloadType = CSharpQueryOverloadType.Create(context, OverloadType, Owner);
OverloadTypeList.Add(NewOverloadType);
}
}
/// <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);
}
}
private void WriteCSharpImplementationConstructor(ICSharpWriter writer, bool isOverride, string nameString, CSharpExports exportStatus, ref bool isFirstFeature, ref bool isMultiline, ref bool skipFirstInstruction)
{
CSharpArgument.BuildParameterList(writer, ParameterList, out string ParameterEntityList, out string ParameterNameList);
string ExportStatusText = CSharpNames.ComposedExportStatus(isOverride, false, true, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {nameString}({ParameterEntityList})");
ICSharpEffectiveBody AsEffectiveBody = Body as ICSharpEffectiveBody;
ICSharpClass Owner = ParentFeature.Owner;
if (Owner.BaseClass != null)
{
ICSharpClass ParentClass = Owner.BaseClass;
if (ParentClass.ClassConstructorType == CSharpConstructorTypes.OneConstructor)
{
if (AsEffectiveBody.BodyInstructionList.Count > 0)
{
/*TODO
* ICommandInstruction AsCommandInstruction;
* if ((AsCommandInstruction = AsEffectiveBody.BodyInstructionList[0] as ICommandInstruction) != null)
* {
* if (AsCommandInstruction.SelectedFeature.IsAssigned)
* {
* ICreationFeature AsCreationFeature;
* if ((AsCreationFeature = AsCommandInstruction.SelectedFeature.Item as ICreationFeature) != null)
* {
* ICommandOverloadType SelectedOverload = AsCommandInstruction.SelectedOverload.Item;
* ISealableList<Parameter> SelectedParameterList = SelectedOverload.ParameterTable;
* string ArgumentListString = CSharpRootOutput.CSharpArgumentList(Context, SelectedParameterList, AsCommandInstruction.ArgumentList, new List<IQualifiedName>());
*
* SkipFirstInstruction = true;
* CSharpRootOutput.IncreaseIndent();
* writer.WriteIndentedLine(":" + " " + "base" + "(" + ArgumentListString + ")");
* CSharpRootOutput.DecreaseIndent();
* }
* }
* }
*/
}
}
}
}
private static void CreateClassFeatures(ICSharpClass cSharpClass, IList <ICSharpFeature> featureList)
{
foreach (KeyValuePair <IFeatureName, IFeatureInstance> Entry in cSharpClass.Source.FeatureTable)
{
IFeatureInstance Instance = Entry.Value;
Debug.Assert(Instance.Feature != null && Instance.Owner != null);
// Only create features that belong to this class directly, or are not inherited from a base class.
if (!IsDirectOrNotMainParentFeature(Instance, cSharpClass))
{
continue;
}
bool IsCreated = CreateFeature(cSharpClass, Instance, out ICSharpFeature NewFeature);
Debug.Assert(IsCreated);
featureList.Add(NewFeature);
}
}
private bool CreateFeatures(IDictionary <IClass, ICSharpClass> classTable, out IDictionary <ICompiledFeature, ICSharpFeature> featureTable)
{
featureTable = new Dictionary <ICompiledFeature, ICSharpFeature>();
foreach (KeyValuePair <IClass, ICSharpClass> Entry in classTable)
{
ICSharpClass Class = Entry.Value;
IList <ICSharpFeature> FeatureList = new List <ICSharpFeature>();
CreateClassFeatures(Class, FeatureList);
foreach (ICSharpFeature Feature in FeatureList)
{
Debug.Assert(!featureTable.ContainsKey(Feature.Source));
featureTable.Add(Feature.Source, Feature);
}
}
return(true);
}
private static bool CheckRename(ICSharpClass cSharpClass, IErrorList errorList)
{
bool Result = true;
foreach (IInheritance InheritanceItem in cSharpClass.Source.InheritanceList)
{
IClassType ParentType = InheritanceItem.ResolvedClassParentType.Item;
IClass ParentClass = ParentType.BaseClass;
bool BadRename = false;
foreach (IRename RenameItem in InheritanceItem.RenameList)
{
string ValidSourceText = RenameItem.ValidSourceText.Item;
if (!FeatureName.TableContain(ParentClass.FeatureTable, ValidSourceText, out IFeatureName Key, out IFeatureInstance Instance))
{
BadRename = true;
break;
}
IClass SourceClass = Instance.Owner;
ICompiledFeature SourceFeature = Instance.Feature;
CSharpExports ExportStatus = GetExportStatus(Key, SourceClass, cSharpClass.Source.ExportTable, (IFeature)SourceFeature);
if (ExportStatus == CSharpExports.Public && !(SourceFeature is ICreationFeature))
{
BadRename = true;
break;
}
}
if (BadRename)
{
errorList.AddError(new ErrorInvalidRename(InheritanceItem));
}
Result &= !BadRename;
}
return(Result);
}
/// <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="CSharpCreationFeature"/> class.
/// </summary>
/// <param name="owner">The class where the feature is declared.</param>
/// <param name="instance">The source feature instance.</param>
/// <param name="source">The source Easly feature.</param>
protected CSharpCreationFeature(ICSharpClass owner, IFeatureInstance instance, ICreationFeature source)
: base(owner, instance, source)
{
Name = Source.ValidFeatureName.Item.Name;
}
/// <summary>
/// Translates nodes from the compiler to the target language.
/// </summary>
public override void Translate()
{
ErrorList.ClearErrors();
if (!CreateClasses(out IDictionary <IClass, ICSharpClass> ClassTable))
{
return;
}
if (!CreateFeatures(ClassTable, out IDictionary <ICompiledFeature, ICSharpFeature> FeatureTable))
{
return;
}
ICSharpContext Context = new CSharpContext(ClassTable, FeatureTable);
foreach (KeyValuePair <IClass, ICSharpClass> ClassEntry in ClassTable)
{
ICSharpClass Class = ClassEntry.Value;
IList <ICSharpFeature> ClassFeatureList = new List <ICSharpFeature>();
IList <ICSharpFeature> InheritedFeatureList = new List <ICSharpFeature>();
foreach (KeyValuePair <ICompiledFeature, ICSharpFeature> FeatureEntry in FeatureTable)
{
ICSharpFeature Feature = FeatureEntry.Value;
IFeatureInstance Instance = Feature.Instance;
if (Instance.IsDiscontinued)
{
continue;
}
if (FeatureEntry.Value.Owner == Class)
{
ClassFeatureList.Add(Feature);
}
else if (!IsDirectOrNotMainParentFeature(Instance, Class))
{
InheritedFeatureList.Add(Feature);
}
}
Class.SetFeatureList(Context, ClassFeatureList, InheritedFeatureList);
}
foreach (KeyValuePair <ICompiledFeature, ICSharpFeature> Entry in FeatureTable)
{
ICSharpFeature Feature = Entry.Value;
Feature.InitOverloadsAndBodies(Context);
}
foreach (KeyValuePair <ICompiledFeature, ICSharpFeature> Entry in FeatureTable)
{
ICSharpFeature Feature = Entry.Value;
Feature.InitHierarchy(Context);
}
foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable)
{
ICSharpClass Class = Entry.Value;
CheckSharedName(Class, ClassTable);
}
foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable)
{
ICSharpClass Class = Entry.Value;
Class.CheckOverrides();
}
foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable)
{
ICSharpClass Class = Entry.Value;
Class.CheckOverrides();
}
bool Continue;
do
{
Continue = false;
foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable)
{
ICSharpClass Class = Entry.Value;
Class.CheckForcedReadWrite(FeatureTable, ref Continue);
}
}while (Continue);
foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable)
{
ICSharpClass Class = Entry.Value;
Class.CheckSideBySideAttributes();
}
foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable)
{
ICSharpClass Class = Entry.Value;
Class.CheckInheritSideBySideAttributes(FeatureTable);
}
foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable)
{
ICSharpClass Class = Entry.Value;
Class.CreateDelegates();
}
ICSharpFeature SingledClassFeature = null;
if (SingledGuid != Guid.Empty || SingledGuid == Guid.Empty)
{
foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable)
{
ICSharpClass Class = Entry.Value;
if (Class.Source.ClassGuid == SingledGuid || SingledGuid == Guid.Empty || SingledGuid != Guid.Empty)
{
foreach (ICSharpFeature Feature in Class.FeatureList)
{
if (Feature is ICSharpFeatureWithName AsWithName && AsWithName.Name == SingledName)
{
SingledClassFeature = Feature;
break;
}
}
}
if (SingledClassFeature != null)
{
break;
}
}
}
if (SingledClassFeature == null)
{
foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable)
{
ICSharpClass Class = Entry.Value;
Class.SetWriteDown();
foreach (ICSharpFeature Feature in Class.FeatureList)
{
Feature.SetWriteDown();
}
foreach (ICSharpAssertion Invariant in Class.InvariantList)
{
Invariant.SetWriteDown();
}
}
}
else
{
SingledClassFeature.SetWriteDown();
}
if (!Directory.Exists(OutputRootFolder))
{
Directory.CreateDirectory(OutputRootFolder);
}
foreach (KeyValuePair <IClass, ICSharpClass> Entry in ClassTable)
{
ICSharpClass Class = Entry.Value;
if (!CSharpClass.IsLanguageClass(Class.Source) && !IsClassFromLibrary(Class.Source))
{
if (Class.WriteDown)
{
Class.Write(OutputRootFolder, Namespace, SourceFileName, SingledClassFeature);
}
}
}
}
private static bool IsDirectOrNotMainParentFeature(IFeatureInstance instance, ICSharpClass cSharpClass)
{
IClass Owner = instance.Owner;
// Feature directly implemented in the class?
if (Owner == cSharpClass.Source)
{
return(true);
}
while (cSharpClass.BaseClass != null)
{
cSharpClass = cSharpClass.BaseClass;
// Feature implemented in one of the base classes?
if (Owner == cSharpClass.Source)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpTypedef"/> 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="embeddingClass">The class where the C# node is created.</param>
protected CSharpTypedef(ICSharpContext context, ITypedef source, ICSharpClass embeddingClass)
: base(source)
{
Name = ((IName)source.EntityName).ValidText.Item;
Type = CSharpType.Create(context, source.ResolvedDefinedType.Item);
}
/// <summary>
/// Create a new C# inheritance.
/// </summary>
/// <param name="source">The Easly node from which the C# node is created.</param>
/// <param name="ancestorClass">The ancestor class.</param>
public static ICSharpInheritance Create(IInheritance source, ICSharpClass ancestorClass)
{
return(new CSharpInheritance(source, ancestorClass));
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpQueryOverload"/> 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="parentFeature">The parent feature.</param>
/// <param name="owner">The class where the overload is declared.</param>
protected CSharpQueryOverload(ICSharpContext context, IQueryOverload source, ICSharpFeature parentFeature, ICSharpClass owner)
: base(source)
{
ParentFeature = parentFeature;
foreach (IParameter Parameter in source.ParameterTable)
{
ICSharpParameter NewParameter = CSharpParameter.Create(context, Parameter, owner);
ParameterList.Add(NewParameter);
}
foreach (IParameter Result in source.ResultTable)
{
ICSharpParameter NewResult = CSharpParameter.Create(context, Result, owner);
ResultList.Add(NewResult);
}
Body = CSharpBody.Create(context, parentFeature, source.ResolvedBody.Item);
}
/// <summary>
/// Create a new C# overload.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="source">The Easly node from which the C# node is created.</param>
/// <param name="parentFeature">The parent feature.</param>
/// <param name="owner">The class where the overload is declared.</param>
public static ICSharpQueryOverload Create(ICSharpContext context, IQueryOverload source, ICSharpFeature parentFeature, ICSharpClass owner)
{
return(new CSharpQueryOverload(context, source, parentFeature, owner));
}
/// <summary>
/// Create a new C# constructor.
/// </summary>
/// <param name="owner">The class where the feature is declared.</param>
/// <param name="instance">The source feature instance.</param>
/// <param name="source">The source Easly feature.</param>
public static ICSharpCreationFeature Create(ICSharpClass owner, IFeatureInstance instance, ICreationFeature source)
{
return(new CSharpCreationFeature(owner, instance, source));
}
