/// <summary>
/// Sets the precursor.
/// </summary>
/// <param name="precursor">The precursor.</param>
public virtual void SetPrecursor(ICSharpQueryOverload precursor)
{
Debug.Assert(precursor != null);
Debug.Assert(Precursor == null);
Precursor = precursor;
}
/// <summary>
/// Initializes the feature precursor hierarchy.
/// </summary>
/// <param name="context">The initialization context.</param>
public override void InitHierarchy(ICSharpContext context)
{
if (Instance.OriginalPrecursor.IsAssigned)
{
IPrecursorInstance Item = Instance.OriginalPrecursor.Item;
ICompiledFeature PrecursorFeature = Item.Precursor.Feature;
OriginalPrecursor = context.GetFeature(PrecursorFeature) as ICSharpFunctionFeature;
Debug.Assert(OriginalPrecursor != null);
IList <ICSharpOverload> PrecursorOverloadList = OriginalPrecursor.OverloadList;
foreach (ICSharpQueryOverload Overload in OverloadList)
{
IQueryOverloadType ResolvedAssociatedType = Overload.Source.ResolvedAssociatedType.Item;
ICSharpQueryOverload ParentPrecursorOverload = null;
foreach (ICSharpQueryOverload PrecursorOverload in PrecursorOverloadList)
{
IQueryOverloadType PrecursorResolvedAssociatedType = PrecursorOverload.Source.ResolvedAssociatedType.Item;
if (ObjectType.QueryOverloadConformToBase(ResolvedAssociatedType, PrecursorResolvedAssociatedType, ErrorList.Ignored, ErrorList.NoLocation))
{
Debug.Assert(ParentPrecursorOverload == null);
ParentPrecursorOverload = PrecursorOverload;
}
}
Debug.Assert(ParentPrecursorOverload != null);
Overload.SetPrecursor(ParentPrecursorOverload);
}
}
}
/// <summary>
/// Initializes the feature overloads and bodies.
/// </summary>
/// <param name="context">The initialization context.</param>
public override void InitOverloadsAndBodies(ICSharpContext context)
{
foreach (IQueryOverload Overload in Source.OverloadList)
{
ICSharpQueryOverload NewOverload = CSharpQueryOverload.Create(context, Overload, this, Owner);
OverloadList.Add(NewOverload);
}
}
private string CSharpTextFunction(ICSharpUsingCollection usingCollection, ICSharpFunctionFeature feature)
{
string Result;
// TODO handle several overloads.
Debug.Assert(feature.OverloadList.Count > 0);
ICSharpQueryOverload Overload = feature.OverloadList[0] as ICSharpQueryOverload;
Debug.Assert(Overload != null);
string BaseTypeText;
if (BaseType != null)
{
BaseTypeText = EffectiveBaseType.Type2CSharpString(usingCollection, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.OneWord);
}
else
{
BaseTypeText = $"I{CSharpNames.ToCSharpIdentifier(Delegated.Owner.ValidClassName)}";
}
string AgentParameters;
string ParameterNameListText;
if (Overload.ParameterList.Count > 0)
{
CSharpArgument.BuildParameterList(usingCollection, Overload.ParameterList, out string ParameterListText, out ParameterNameListText);
AgentParameters = $"({BaseTypeText} agentBase, {ParameterListText})";
}
else
{
AgentParameters = $"({BaseTypeText} agentBase)";
ParameterNameListText = string.Empty;
}
Result = $"{AgentParameters} => {{ return agentBase.{CSharpNames.ToCSharpIdentifier(Delegated.Name)}({ParameterNameListText}); }}";
return(Result);
}
/// <summary>
/// Writes down the body source code.
/// </summary>
/// <param name="writer">The stream on which to write down.</param>
/// <param name="flags">Some flags.</param>
/// <param name="resultType">Type of the result, if any.</param>
/// <param name="skipFirstInstruction">Skip the first instruction.</param>
/// <param name="initialisationStringList">List of initializations.</param>
public virtual void WriteCSharp(ICSharpWriter writer, CSharpBodyFlags flags, string resultType, bool skipFirstInstruction, IList <string> initialisationStringList)
{
Debug.Assert(WriteDown);
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
IList <ICSharpAssertion> EffectiveRequireList = RequireList;
IList <ICSharpAssertion> EffectiveEnsureList = EnsureList;
switch (ParentFeature)
{
case ICSharpFunctionFeature AsFunctionFeature:
if (AsFunctionFeature.OriginalPrecursor != null)
{
ICSharpQueryOverload ParentOverload = null;
foreach (ICSharpQueryOverload Overload in AsFunctionFeature.OverloadList)
{
if (Overload.Body == this)
{
ParentOverload = Overload;
break;
}
}
Debug.Assert(ParentOverload != null);
ICSharpQueryOverload ParentPrecursorOverload = ParentOverload.Precursor;
if (ParentPrecursorOverload != null)
{
ICSharpBody PrecursorBody = ParentPrecursorOverload.Body;
if (RequireList.Count == 0 && PrecursorBody.RequireList.Count > 0)
{
EffectiveRequireList = PrecursorBody.RequireList;
}
if (EnsureList.Count == 0 && PrecursorBody.EnsureList.Count > 0)
{
EffectiveEnsureList = PrecursorBody.EnsureList;
}
}
}
break;
case ICSharpProcedureFeature AsProcedureFeature:
if (AsProcedureFeature.OriginalPrecursor != null)
{
ICSharpCommandOverload ParentOverload = null;
foreach (ICSharpCommandOverload Overload in AsProcedureFeature.OverloadList)
{
if (Overload.Body == this)
{
ParentOverload = Overload;
break;
}
}
Debug.Assert(ParentOverload != null);
ICSharpCommandOverload ParentPrecursorOverload = ParentOverload.Precursor;
if (ParentPrecursorOverload != null)
{
ICSharpBody PrecursorBody = ParentPrecursorOverload.Body;
if (RequireList.Count == 0 && PrecursorBody.RequireList.Count > 0)
{
EffectiveRequireList = PrecursorBody.RequireList;
}
if (EnsureList.Count == 0 && PrecursorBody.EnsureList.Count > 0)
{
EffectiveEnsureList = PrecursorBody.EnsureList;
}
}
}
break;
case ICSharpPropertyFeature AsPropertyFeature:
if (AsPropertyFeature.OriginalPrecursor != null)
{
ICSharpBody PrecursorBody = null;
if (this == AsPropertyFeature.GetterBody)
{
PrecursorBody = AsPropertyFeature.OriginalPrecursor.GetterBody;
}
else if (this == AsPropertyFeature.SetterBody)
{
PrecursorBody = AsPropertyFeature.OriginalPrecursor.SetterBody;
}
if (PrecursorBody != null)
{
if (RequireList.Count == 0 && PrecursorBody.RequireList.Count > 0)
{
EffectiveRequireList = PrecursorBody.RequireList;
}
if (EnsureList.Count == 0 && PrecursorBody.EnsureList.Count > 0)
{
EffectiveEnsureList = PrecursorBody.EnsureList;
}
}
}
break;
case ICSharpIndexerFeature AsIndexerFeature:
if (AsIndexerFeature.OriginalPrecursor != null)
{
ICSharpBody PrecursorBody = null;
if (this == AsIndexerFeature.GetterBody)
{
PrecursorBody = AsIndexerFeature.OriginalPrecursor.GetterBody;
}
else if (this == AsIndexerFeature.SetterBody)
{
PrecursorBody = AsIndexerFeature.OriginalPrecursor.SetterBody;
}
if (PrecursorBody != null)
{
if (RequireList.Count == 0 && PrecursorBody.RequireList.Count > 0)
{
EffectiveRequireList = PrecursorBody.RequireList;
}
if (EnsureList.Count == 0 && PrecursorBody.EnsureList.Count > 0)
{
EffectiveEnsureList = PrecursorBody.EnsureList;
}
}
}
break;
}
foreach (ICSharpAssertion Assertion in EffectiveRequireList)
{
Assertion.WriteCSharp(writer);
}
if (EffectiveRequireList.Count > 0)
{
writer.WriteEmptyLine();
}
/*TODO
* List<AttachmentAlias> AttachmentVariableTable = new List<AttachmentAlias>();
* foreach (IInstruction Item in BodyInstructionList)
* Item.AddAttachmentVariables(Context, AttachmentVariableTable);
*/
if (flags.HasFlag(CSharpBodyFlags.HasResult))
{
writer.WriteIndentedLine($"{resultType} Result = default;");
}
foreach (ICSharpScopeAttributeFeature Item in EntityDeclarationList)
{
Item.WriteCSharp(writer);
}
/*TODO
* foreach (AttachmentAlias AliasItem in AttachmentVariableTable)
* {
* string AttachedVariableName = AliasItem.EntityName;
* string AttachmentTypeString = CSharpTypes.Type2CSharpString(AliasItem.EntityType, Context, AliasItem.AttachmentFormat, CSharpNamespaceFormats.None);
*
* writer.WriteIndentedLine(AttachmentTypeString + " " + AttachedVariableName + ";");
* Context.AttachmentVariableTable.Add(AliasItem);
* }
*/
if (flags.HasFlag(CSharpBodyFlags.HasResult) || EntityDeclarationList.Count > 0 /* || AttachmentVariableTable.Count > 0*/)
{
writer.WriteEmptyLine();
}
foreach (string s in initialisationStringList)
{
writer.WriteIndentedLine(s);
}
if (initialisationStringList.Count > 0)
{
writer.WriteEmptyLine();
}
for (int i = 0; i < BodyInstructionList.Count; i++)
{
if (i == 0 && skipFirstInstruction)
{
continue;
}
ICSharpInstruction Item = BodyInstructionList[i];
Item.WriteCSharp(writer);
}
if (EffectiveEnsureList.Count > 0)
{
writer.WriteEmptyLine();
foreach (ICSharpAssertion Assertion in EffectiveEnsureList)
{
Assertion.WriteCSharp(writer);
}
if (flags.HasFlag(CSharpBodyFlags.HasResult))
{
writer.WriteEmptyLine();
}
}
// TODO: ExceptionHandlerList
if (ParentFeature.Owner.HasCheckInvariant)
{
writer.WriteEmptyLine();
writer.WriteIndentedLine("CheckInvariant();");
}
if (flags.HasFlag(CSharpBodyFlags.HasResult))
{
writer.WriteIndentedLine("return Result;");
}
/*TODO
* foreach (AttachmentAlias AliasItem in AttachmentVariableTable)
* Context.AttachmentVariableTable.Remove(AliasItem);
*/
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
