/// <summary>
/// Writes down the C# instruction.
/// </summary>
/// <param name="writer">The stream on which to write.</param>
public override void WriteCSharp(ICSharpWriter writer)
{
Debug.Assert(WriteDown);
ICSharpExpressionContext SourceExpressionContext = new CSharpExpressionContext();
SourceExpression.WriteCSharp(writer, SourceExpressionContext, -1);
string SourceString = SourceExpressionContext.ReturnValue;
writer.WriteIndentedLine($"switch ({SourceString})");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
bool WithInserted = false;
foreach (ICSharpWith Item in WithList)
{
if (!WithInserted)
{
WithInserted = true;
}
else
{
writer.WriteEmptyLine();
}
Item.WriteCSharp(writer);
}
if (WithInserted)
{
writer.WriteEmptyLine();
}
writer.WriteIndentedLine("default:");
if (ElseInstructions != null)
{
ElseInstructions.WriteCSharp(writer, CSharpCurlyBracketsInsertions.Indifferent, false);
writer.WriteIndentedLine("break;");
}
else
{
writer.IncreaseIndent();
writer.WriteIndentedLine("throw new ArgumentOutOfRangeException();");
writer.DecreaseIndent();
}
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
/// <summary>
/// Writes down a contract.
/// </summary>
/// <param name="writer">The stream on which to write.</param>
/// <param name="requireList">The list of require assertions in the contract.</param>
/// <param name="ensureList">The list of ensure assertions in the contract.</param>
/// <param name="contractLocation">Where the contract appears in the feature.</param>
/// <param name="writeEmptyContract">True if the contract must be written, even if empty.</param>
/// <param name="isFirstFeature">True if the feature is the first in a list.</param>
/// <param name="isMultiline">True if there is a separating line above.</param>
public static void WriteContract(ICSharpWriter writer, IList <ICSharpAssertion> requireList, IList <ICSharpAssertion> ensureList, CSharpContractLocations contractLocation, bool writeEmptyContract, ref bool isFirstFeature, ref bool isMultiline)
{
if (writeEmptyContract || requireList.Count > 0 || ensureList.Count > 0)
{
if (!isFirstFeature)
{
writer.WriteEmptyLine();
}
isMultiline = true;
if (requireList.Count == 0 && ensureList.Count == 0)
{
writer.WriteIndentedLine("// Contract: None");
}
else
{
bool IsHandled = false;
switch (contractLocation)
{
case CSharpContractLocations.Getter:
writer.WriteIndentedLine("// Contract (getter):");
WriteContract(writer, requireList);
IsHandled = true;
break;
case CSharpContractLocations.Setter:
writer.WriteIndentedLine("// Contract (setter):");
WriteContract(writer, requireList);
IsHandled = true;
break;
case CSharpContractLocations.Other:
if (requireList.Count > 0)
{
writer.WriteIndentedLine("// Require:");
WriteContract(writer, requireList);
}
if (ensureList.Count > 0)
{
writer.WriteIndentedLine("// Ensure:");
WriteContract(writer, ensureList);
}
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
}
}
isFirstFeature = false;
}
private void WriteCSharpInvariant(ICSharpWriter writer)
{
if (InvariantList.Count > 0)
{
writer.WriteEmptyLine();
}
foreach (ICSharpAssertion Assertion in InvariantList)
{
Assertion.WriteCSharp(writer);
}
}
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 WriteCSharpImplementationPrecursor(ICSharpWriter writer, ICSharpPrecursorBody precursorBody, bool isOverride, string nameString, CSharpExports exportStatus, bool isConstructor, ref bool isFirstFeature, ref bool isMultiline)
{
CSharpArgument.BuildParameterList(writer, ParameterList, out string ParameterEntityList, out string ParameterNameList);
if (isMultiline)
{
writer.WriteEmptyLine();
}
string ExportStatusText = CSharpNames.ComposedExportStatus(true, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} void {nameString}({ParameterEntityList})");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
writer.WriteIndentedLine($"base.{nameString}({ParameterNameList});");
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
isMultiline = true;
}
/// <summary>
/// Writes down the C# feature.
/// </summary>
/// <param name="writer">The stream on which to write.</param>
/// <param name="featureTextType">The write mode.</param>
/// <param name="exportStatus">The feature export status.</param>
/// <param name="isLocal">True if the feature is local to the class.</param>
/// <param name="isFirstFeature">True if the feature is the first in a list.</param>
/// <param name="isMultiline">True if there is a separating line above.</param>
public override void WriteCSharp(ICSharpWriter writer, CSharpFeatureTextTypes featureTextType, CSharpExports exportStatus, bool isLocal, ref bool isFirstFeature, ref bool isMultiline)
{
if (!WriteDown)
{
return;
}
if (isMultiline)
{
writer.WriteEmptyLine();
}
isFirstFeature = false;
isMultiline = false;
if (featureTextType == CSharpFeatureTextTypes.Implementation)
{
WriteCSharpImplementation(writer, exportStatus, isLocal, ref isFirstFeature, ref isMultiline);
}
}
/// <summary>
/// Writes down the C# instruction.
/// </summary>
/// <param name="writer">The stream on which to write.</param>
public override void WriteCSharp(ICSharpWriter writer)
{
Debug.Assert(WriteDown);
bool IsElseIf = false;
foreach (ICSharpConditional Item in ConditionalList)
{
if (IsElseIf)
{
writer.WriteEmptyLine();
}
Item.WriteCSharp(writer, IsElseIf);
IsElseIf = true;
}
if (ElseInstructions != null)
{
writer.WriteIndentedLine("else");
ElseInstructions.WriteCSharp(writer, CSharpCurlyBracketsInsertions.Indifferent, false);
}
}
/// <summary>
/// Writes down the C# overload of a feature.
/// </summary>
/// <param name="writer">The stream on which to write.</param>
/// <param name="featureTextType">The write mode.</param>
/// <param name="isOverride">True if the feature is an override.</param>
/// <param name="nameString">The composed feature name.</param>
/// <param name="exportStatus">The feature export status.</param>
/// <param name="isConstructor">True if the feature is a constructor.</param>
/// <param name="isFirstFeature">True if the feature is the first in a list.</param>
/// <param name="isMultiline">True if there is a separating line above.</param>
public void WriteCSharp(ICSharpWriter writer, CSharpFeatureTextTypes featureTextType, bool isOverride, string nameString, CSharpExports exportStatus, bool isConstructor, ref bool isFirstFeature, ref bool isMultiline)
{
Debug.Assert(WriteDown);
IList <ICSharpParameter> SelectedParameterList = ParameterList;
IList <ICSharpParameter> SelectedResultList = ResultList;
if (isOverride && Precursor != null)
{
SelectedParameterList = Precursor.ParameterList;
SelectedResultList = Precursor.ResultList;
}
CSharpArgument.BuildParameterList(writer, SelectedParameterList, SelectedResultList, featureTextType, out string ArgumentEntityList, out string ArgumentNameList, out string ResultType);
string ExportStatusText;
if (featureTextType == CSharpFeatureTextTypes.Implementation)
{
bool IsHandled = false;
switch (Body)
{
case ICSharpDeferredBody AsDeferredBody:
CSharpAssertion.WriteContract(writer, AsDeferredBody.RequireList, AsDeferredBody.EnsureList, CSharpContractLocations.Other, true, ref isFirstFeature, ref isMultiline);
ExportStatusText = CSharpNames.ComposedExportStatus(false, true, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {ResultType} {nameString}({ArgumentEntityList});");
isMultiline = false;
IsHandled = true;
break;
case ICSharpEffectiveBody AsEffectiveBody:
CSharpAssertion.WriteContract(writer, AsEffectiveBody.RequireList, AsEffectiveBody.EnsureList, CSharpContractLocations.Other, true, ref isFirstFeature, ref isMultiline);
CSharpBodyFlags Flags = CSharpBodyFlags.MandatoryCurlyBrackets;
string ResultString = string.Empty;
List <string> InitialisationStringList = new List <string>();
if (ResultList.Count == 1)
{
Flags |= CSharpBodyFlags.HasResult;
ICSharpParameter Result = ResultList[0];
ResultString = Result.Feature.Type.Type2CSharpString(writer, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None);
}
else
{
if (ResultType != "void")
{
Flags |= CSharpBodyFlags.HasResult;
ResultString = ResultType;
}
foreach (ICSharpParameter Item in ResultList)
{
string InitValueString;
ICSharpType ResultEntityType = Item.Feature.Type;
if (ResultEntityType is ICSharpClassType AsClassType)
{
// TODO: when the type inherit from Enumeration
if (AsClassType.Class.Source.ClassGuid == LanguageClasses.AnyOptionalReference.Guid)
{
InitValueString = "new OptionalReference<>(null)"; // TODO
}
else if (AsClassType.Class.Source.ClassGuid == LanguageClasses.String.Guid)
{
InitValueString = "\"\"";
}
else if (AsClassType.Class.Source.ClassGuid == LanguageClasses.Boolean.Guid)
{
InitValueString = "false";
}
else if (AsClassType.Class.Source.ClassGuid == LanguageClasses.Character.Guid)
{
InitValueString = "'\0'";
}
else if (AsClassType.Class.Source.ClassGuid == LanguageClasses.Number.Guid)
{
InitValueString = "0";
}
else
{
InitValueString = "null";
}
}
else
{
InitValueString = "null"; // TODO : tuples
}
string InitNameString = CSharpNames.ToCSharpIdentifier(Item.Name);
InitialisationStringList.Add($"{InitNameString} = {InitValueString};");
}
}
ExportStatusText = CSharpNames.ComposedExportStatus(isOverride, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {ResultType} {nameString}({ArgumentEntityList})");
AsEffectiveBody.WriteCSharp(writer, Flags, ResultString, false, InitialisationStringList);
isMultiline = true;
IsHandled = true;
break;
case ICSharpPrecursorBody AsPrecursorBody:
if (isMultiline)
{
writer.WriteEmptyLine();
}
ExportStatusText = CSharpNames.ComposedExportStatus(true, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {ResultType} {nameString}({ArgumentEntityList})");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
writer.WriteIndentedLine($"return base.{nameString}({ArgumentNameList});");
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
isMultiline = true;
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
}
else
{
writer.WriteIndentedLine($"{ResultType} {nameString}({ArgumentEntityList});");
isMultiline = false;
}
}
/// <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("}");
}
/// <summary>
/// Writes down the C# instruction.
/// </summary>
/// <param name="writer">The stream on which to write.</param>
public override void WriteCSharp(ICSharpWriter writer)
{
Debug.Assert(WriteDown);
bool UseCurlyBrackets = false;
/*TODO
* List<AttachmentAlias> AttachmentVariableTable = new List<AttachmentAlias>();
* foreach (IInstruction Item in InitInstructionList)
* Item.AddAttachmentVariables(Context, AttachmentVariableTable);
* foreach (IInstruction Item in LoopInstructionList)
* Item.AddAttachmentVariables(Context, AttachmentVariableTable);
* foreach (IInstruction Item in IterationInstructionList)
* Item.AddAttachmentVariables(Context, AttachmentVariableTable);
*/
if (EntityDeclarationList.Count > 0 /* || AttachmentVariableTable.Count > 0*/ || InitInstructionList.Count > 1)
{
UseCurlyBrackets = true;
}
if (UseCurlyBrackets)
{
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
}
foreach (ICSharpScopeAttributeFeature Item in EntityDeclarationList)
{
Item.WriteCSharp(writer);
}
if (Source.Variant.IsAssigned)
{
writer.WriteIndentedLine("double LoopVariant = double.NaN;");
}
/*
* 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 (EntityDeclarationList.Count > 0 /* || AttachmentVariableTable.Count > 0*/)
{
writer.WriteEmptyLine();
}
foreach (ICSharpInstruction Item in InitInstructionList)
{
Item.WriteCSharp(writer);
}
WriteCSharpInvariant(writer);
if (InvariantList.Count > 0)
{
writer.WriteEmptyLine();
}
ICSharpExpressionContext SourceExpressionContext = new CSharpExpressionContext();
WhileCondition.WriteCSharp(writer, SourceExpressionContext, -1);
string WhileString = SourceExpressionContext.ReturnValue;
writer.WriteIndentedLine($"while ({WhileString})");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
foreach (ICSharpInstruction Item in LoopInstructionList)
{
Item.WriteCSharp(writer);
}
if (LoopInstructionList.Count > 0 && IterationInstructionList.Count > 0)
{
writer.WriteEmptyLine();
}
foreach (ICSharpInstruction Item in IterationInstructionList)
{
Item.WriteCSharp(writer);
}
if (VariantExpression != null)
{
ICSharpExpressionContext VariantExpressionContext = new CSharpExpressionContext();
VariantExpression.WriteCSharp(writer, VariantExpressionContext, -1);
string ExpressionText = VariantExpressionContext.ReturnValue;
writer.WriteIndentedLine($"double NewVariantResult = {ExpressionText};");
writer.WriteIndentedLine("if (NewVariantResult >= LoopVariant)// Takes advantage of the fact that 'x >= NaN' is always false");
writer.IncreaseIndent();
writer.WriteIndentedLine("throw new InvalidOperationException();");
writer.DecreaseIndent();
writer.WriteIndentedLine("LoopVariant = NewVariantResult;");
}
WriteCSharpInvariant(writer);
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
/*
* foreach (AttachmentAlias AliasItem in AttachmentVariableTable)
* Context.AttachmentVariableTable.Remove(AliasItem);
*/
if (UseCurlyBrackets)
{
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
}
private void WriteCSharpForcedReadWriteProperty(ICSharpWriter writer, bool isOverride, CSharpExports exportStatus, string propertyName, string resultType, ref bool isFirstFeature, ref bool isMultiline)
{
bool IsDeferred = false;
bool IsPrecursor = false;
isFirstFeature = false;
if (GetterBody != null)
{
if (GetterBody is ICSharpDeferredBody)
{
IsDeferred = true;
}
if (GetterBody is ICSharpPrecursorBody)
{
IsPrecursor = true;
}
}
if (SetterBody != null)
{
if (SetterBody is ICSharpDeferredBody)
{
IsDeferred = true;
}
if (SetterBody is ICSharpPrecursorBody)
{
IsPrecursor = true;
}
}
if (GetterBody != null || SetterBody != null)
{
if (IsDeferred)
{
bool IsGetterMultiline = isMultiline;
bool IsSetterMultiline = isMultiline;
if (GetterBody != null)
{
ICSharpDeferredBody DeferredGetterBody = GetterBody as ICSharpDeferredBody;
Debug.Assert(DeferredGetterBody != null);
CSharpAssertion.WriteContract(writer, DeferredGetterBody.RequireList, DeferredGetterBody.EnsureList, CSharpContractLocations.Getter, false, ref isFirstFeature, ref IsGetterMultiline);
IsSetterMultiline = false;
}
if (SetterBody != null)
{
ICSharpDeferredBody DeferredSetterBody = SetterBody as ICSharpDeferredBody;
Debug.Assert(DeferredSetterBody != null);
CSharpAssertion.WriteContract(writer, DeferredSetterBody.RequireList, DeferredSetterBody.EnsureList, CSharpContractLocations.Setter, false, ref isFirstFeature, ref IsSetterMultiline);
}
string ExportStatusText = CSharpNames.ComposedExportStatus(false, true, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {resultType} {propertyName} {{ get; set; }}");
isMultiline = IsGetterMultiline || IsSetterMultiline;
}
else
{
if (isMultiline)
{
writer.WriteEmptyLine();
}
string ExportStatusText = CSharpNames.ComposedExportStatus(IsOverride, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {resultType} {propertyName}");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
if (IsPrecursor)
{
if (Source.PropertyKind != BaseNode.UtilityType.WriteOnly)
{
writer.WriteIndentedLine($"get {{ return base.{propertyName}; }}");
}
else
{
writer.WriteIndentedLine($"get {{ throw new InvalidOperationException(); }}");
}
if (Source.PropertyKind != BaseNode.UtilityType.ReadOnly)
{
writer.WriteIndentedLine($"set {{ base.{propertyName} = value; }}");
}
else
{
writer.WriteIndentedLine($"set {{ throw new InvalidOperationException(); }}");
}
}
else
{
if (GetterBody != null)
{
ICSharpEffectiveBody EffectiveGetterBody = GetterBody as ICSharpEffectiveBody;
Debug.Assert(EffectiveGetterBody != null);
isMultiline = false;
CSharpAssertion.WriteContract(writer, EffectiveGetterBody.RequireList, EffectiveGetterBody.EnsureList, CSharpContractLocations.Other, false, ref isFirstFeature, ref isMultiline);
writer.WriteIndentedLine("get");
EffectiveGetterBody.WriteCSharp(writer, CSharpBodyFlags.MandatoryCurlyBrackets | CSharpBodyFlags.HasResult, resultType, false, new List <string>());
}
else
{
writer.WriteIndentedLine($"get {{ throw new InvalidOperationException(); }}");
}
if (SetterBody != null)
{
ICSharpEffectiveBody EffectiveSetterBody = SetterBody as ICSharpEffectiveBody;
Debug.Assert(EffectiveSetterBody != null);
isMultiline = false;
CSharpAssertion.WriteContract(writer, EffectiveSetterBody.RequireList, EffectiveSetterBody.EnsureList, CSharpContractLocations.Other, false, ref isFirstFeature, ref isMultiline);
writer.WriteIndentedLine("set");
EffectiveSetterBody.WriteCSharp(writer, CSharpBodyFlags.MandatoryCurlyBrackets | CSharpBodyFlags.HasValue, string.Empty, false, new List <string>());
}
else
{
writer.WriteIndentedLine($"set {{ throw new InvalidOperationException(); }}");
}
}
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
isMultiline = true;
}
}
else
{
if (isMultiline)
{
writer.WriteEmptyLine();
}
string ExportStatusText = CSharpNames.ComposedExportStatus(IsOverride, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {resultType} {propertyName}");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
if (Source.PropertyKind != BaseNode.UtilityType.WriteOnly)
{
writer.WriteIndentedLine($"get {{ return _{propertyName}; }}");
}
else
{
writer.WriteIndentedLine($"get {{ throw new InvalidOperationException(); }}");
}
if (Source.PropertyKind != BaseNode.UtilityType.ReadOnly)
{
writer.WriteIndentedLine($"set {{ _{propertyName} = value; }}");
}
else
{
writer.WriteIndentedLine($"set {{ throw new InvalidOperationException(); }}");
}
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
isMultiline = true;
}
}
private void WriteCSharpWriteOnlyProperty(ICSharpWriter writer, bool isOverride, CSharpExports exportStatus, string propertyName, string resultType, ref bool isFirstFeature, ref bool isMultiline)
{
bool IsDeferred = false;
bool IsPrecursor = false;
isFirstFeature = false;
if (SetterBody != null)
{
if (SetterBody is ICSharpDeferredBody)
{
IsDeferred = true;
}
if (SetterBody is ICSharpPrecursorBody)
{
IsPrecursor = true;
}
}
if (SetterBody != null)
{
if (IsDeferred)
{
ICSharpDeferredBody DeferredSetterBody = SetterBody as ICSharpDeferredBody;
Debug.Assert(DeferredSetterBody != null);
CSharpAssertion.WriteContract(writer, DeferredSetterBody.RequireList, DeferredSetterBody.EnsureList, CSharpContractLocations.Other, false, ref isFirstFeature, ref isMultiline);
string ExportStatusText = CSharpNames.ComposedExportStatus(false, true, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {resultType} {propertyName} {{ protected get; set; }}");
isMultiline = false;
}
else
{
if (isMultiline)
{
writer.WriteEmptyLine();
}
string ExportStatusText = CSharpNames.ComposedExportStatus(IsOverride, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {resultType} {propertyName}");
if (IsPrecursor)
{
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
writer.WriteIndentedLine($"set {{ base.{propertyName} = value; }}");
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
else
{
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
writer.WriteIndentedLine($"protected get {{ return _{propertyName}; }}");
ICSharpEffectiveBody EffectiveSetterBody = SetterBody as ICSharpEffectiveBody;
Debug.Assert(EffectiveSetterBody != null);
isMultiline = false;
CSharpAssertion.WriteContract(writer, EffectiveSetterBody.RequireList, EffectiveSetterBody.EnsureList, CSharpContractLocations.Other, false, ref isFirstFeature, ref isMultiline);
writer.WriteIndentedLine("set");
EffectiveSetterBody.WriteCSharp(writer, CSharpBodyFlags.MandatoryCurlyBrackets | CSharpBodyFlags.HasValue, string.Empty, false, new List <string>());
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
isMultiline = true;
}
}
else
{
if (isMultiline)
{
writer.WriteEmptyLine();
}
string ExportStatusText = CSharpNames.ComposedExportStatus(IsOverride, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {resultType} {propertyName} {{ protected get; set; }}");
isMultiline = false;
}
}
/// <summary>
/// Writes down the C# instruction.
/// </summary>
/// <param name="writer">The stream on which to write.</param>
public override void WriteCSharp(ICSharpWriter writer)
{
Debug.Assert(WriteDown);
string ContinueExpressionText;
for (int i = 0; i < ContinuationList.Count; i++)
{
ICSharpContinuation Item = ContinuationList[i];
if (i > 0)
{
writer.WriteEmptyLine();
}
WriteCSharpContinueCondition(writer, out ContinueExpressionText);
writer.WriteIndentedLine($"if ({ContinueExpressionText})");
Item.WriteCSharpInstructions(writer);
int CleanupInstructionCount = 0;
for (int j = i; j > 0; j--)
{
ICSharpContinuation PreviousItem = ContinuationList[j - 1];
CleanupInstructionCount += PreviousItem.CleanupList.Count;
}
if (CleanupInstructionCount > 0)
{
writer.WriteIndentedLine("else");
if (CleanupInstructionCount > 1)
{
writer.WriteIndentedLine("{");
}
writer.IncreaseIndent();
for (int j = i; j > 0; j--)
{
if (j < i)
{
writer.WriteEmptyLine();
}
ICSharpContinuation PreviousItem = ContinuationList[j - 1];
PreviousItem.WriteCSharpCleanupInstructions(writer);
}
writer.DecreaseIndent();
if (CleanupInstructionCount > 1)
{
writer.WriteIndentedLine("}");
}
}
}
if (ElseInstructions != null)
{
writer.WriteEmptyLine();
WriteCSharpContinueCondition(writer, out ContinueExpressionText);
writer.WriteIndentedLine($"if (!({ContinueExpressionText}))");
ElseInstructions.WriteCSharp(writer, CSharpCurlyBracketsInsertions.Mandatory, false);
}
}
/// <summary>
/// Writes down the C# instruction.
/// </summary>
/// <param name="writer">The stream on which to write.</param>
public override void WriteCSharp(ICSharpWriter writer)
{
Debug.Assert(WriteDown);
ICSharpExpressionContext SourceExpressionContext = new CSharpExpressionContext();
OverList.WriteCSharp(writer, SourceExpressionContext, -1);
string OverListString = SourceExpressionContext.ReturnValue;
ICSharpScopeAttributeFeature Indexer = IndexerList[0];
string IndexerNameString = Indexer.Name;
string TypeString = Indexer.Type.Type2CSharpString(writer, CSharpTypeFormats.Normal, CSharpNamespaceFormats.None);
//TODO: support multiple indexers and IterationType
if (ExitEntityName != null)
{
string ExitEntityNameString = CSharpNames.ToCSharpIdentifier(ExitEntityName);
writer.WriteIndentedLine($"{ExitEntityNameString} = false;");
writer.WriteIndentedLine($"foreach ({TypeString} {IndexerNameString} in {OverListString})");
writer.WriteIndentedLine("{");
LoopInstructions.WriteCSharp(writer, CSharpCurlyBracketsInsertions.AlreadyInserted, false);
WriteCSharpInvariant(writer);
writer.WriteEmptyLine();
writer.IncreaseIndent();
writer.WriteIndentedLine($"if ({ExitEntityNameString})");
writer.IncreaseIndent();
writer.WriteIndentedLine("break;");
writer.DecreaseIndent();
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
else if (InvariantList.Count > 0)
{
writer.WriteIndentedLine($"foreach ({TypeString} {IndexerNameString} in {OverListString})");
writer.WriteIndentedLine("{");
LoopInstructions.WriteCSharp(writer, CSharpCurlyBracketsInsertions.AlreadyInserted, false);
writer.IncreaseIndent();
WriteCSharpInvariant(writer);
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
else
{
writer.WriteIndentedLine($"foreach ({TypeString} {IndexerNameString} in {OverListString})");
LoopInstructions.WriteCSharp(writer, CSharpCurlyBracketsInsertions.Indifferent, false);
}
//TODO: InvariantBlocks
//TODO: Variant
}
/// <summary>
/// Writes down the C# scope.
/// </summary>
/// <param name="writer">The stream on which to write.</param>
/// <param name="curlyBracketsInsertion">The mode to use to write the C# scope..</param>
/// <param name="endWithBreak">Add a break instruction at the end.</param>
public virtual void WriteCSharp(ICSharpWriter writer, CSharpCurlyBracketsInsertions curlyBracketsInsertion, bool endWithBreak)
{
Debug.Assert(WriteDown);
bool UseCurlyBrackets = false;
if (curlyBracketsInsertion.HasFlag(CSharpCurlyBracketsInsertions.Mandatory))
{
UseCurlyBrackets = true;
}
/*
* List<AttachmentAlias> AttachmentVariableTable = new List<AttachmentAlias>();
* foreach (IInstruction Item in InstructionList)
* Item.AddAttachmentVariables(Context, AttachmentVariableTable);
*/
if (EntityDeclarationList.Count > 0 /* || AttachmentVariableTable.Count > 0*/ || InstructionList.Count != 1)
{
UseCurlyBrackets = true;
}
if (curlyBracketsInsertion.HasFlag(CSharpCurlyBracketsInsertions.AlreadyInserted))
{
UseCurlyBrackets = false;
}
if (UseCurlyBrackets)
{
writer.WriteIndentedLine("{");
}
writer.IncreaseIndent();
foreach (ICSharpScopeAttributeFeature Item in EntityDeclarationList)
{
Item.WriteCSharp(writer);
}
/*
* 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 (EntityDeclarationList.Count > 0 /* || AttachmentVariableTable.Count > 0*/)
{
writer.WriteEmptyLine();
}
foreach (ICSharpInstruction Item in InstructionList)
{
Item.WriteCSharp(writer);
}
if (endWithBreak)
{
writer.WriteIndentedLine("break;");
}
/*
* foreach (AttachmentAlias AliasItem in AttachmentVariableTable)
* Context.AttachmentVariableTable.Remove(AliasItem);
*/
writer.DecreaseIndent();
if (UseCurlyBrackets)
{
writer.WriteIndentedLine("}");
}
}