/// <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 CoexistingPrecursorName = string.Empty; string CoexistingPrecursorRootName = ParentFeature.CoexistingPrecursorName; if (!string.IsNullOrEmpty(CoexistingPrecursorRootName)) { CoexistingPrecursorName = CSharpNames.ToCSharpIdentifier(CoexistingPrecursorRootName + " " + "Base"); } ICSharpExpressionContext ExpressionContext = new CSharpExpressionContext(); string ArgumentListString = CSharpArgument.CSharpArgumentList(writer, ExpressionContext, FeatureCall); if (CoexistingPrecursorName.Length > 0) { writer.WriteIndentedLine($"{CoexistingPrecursorName}({ArgumentListString});"); } else { string ProcedureName = CSharpNames.ToCSharpIdentifier(ParentFeature.Name); writer.WriteIndentedLine($"base.{ProcedureName}({ArgumentListString});"); } }
private void WriteCSharpAgentCall(ICSharpWriter writer, ICSharpExpressionContext expressionContext, int skippedIndex) { CSharpArgument.CSharpArgumentList(writer, expressionContext, FeatureCall, skippedIndex, true, out string ArgumentListText, out IList <string> OutgoingResultList); string QueryText = Query.CSharpText(writer, 0); IIdentifier AgentIdentifier = (IIdentifier)Source.Query.Path[Source.Query.Path.Count - 1]; string AgentIdentifierText = CSharpNames.ToCSharpIdentifier(AgentIdentifier.ValidText.Item); if (Source.Query.Path.Count > 1) { QueryText = Query.CSharpText(writer, 1); } else { QueryText = "this"; } if (FeatureCall.ArgumentList.Count > 0) { expressionContext.SetSingleReturnValue($"{AgentIdentifierText}({QueryText}, {ArgumentListText})"); } else { expressionContext.SetSingleReturnValue($"{AgentIdentifierText}({QueryText})"); } }
/// <summary> /// Gets the source code corresponding to the expression. /// </summary> /// <param name="writer">The stream on which to write.</param> /// <param name="expressionContext">The context.</param> /// <param name="skippedIndex">Index of a destination to skip.</param> public override void WriteCSharp(ICSharpWriter writer, ICSharpExpressionContext expressionContext, int skippedIndex) { Debug.Assert(WriteDown); CSharpArgument.CSharpArgumentList(writer, expressionContext, FeatureCall, skippedIndex, false, out string ArgumentListText, out IList <string> OutgoingResultList); expressionContext.SetSingleReturnValue($"base[{ArgumentListText}]"); }
/// <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 ExceptionTypeString = ExceptionType.Type2CSharpString(writer, CSharpTypeFormats.Normal, CSharpNamespaceFormats.None); ICSharpExpressionContext ExpressionContext = new CSharpExpressionContext(); string ArgumentListString = CSharpArgument.CSharpArgumentList(writer, ExpressionContext, FeatureCall); // TODO: CreationRoutine writer.WriteIndentedLine($"throw new {ExceptionTypeString}({ArgumentListString});"); }
/// <summary> /// Gets the source code corresponding to the expression. /// </summary> /// <param name="writer">The stream on which to write.</param> /// <param name="expressionContext">The context.</param> /// <param name="skippedIndex">Index of a destination to skip.</param> public override void WriteCSharp(ICSharpWriter writer, ICSharpExpressionContext expressionContext, int skippedIndex) { Debug.Assert(WriteDown); ICSharpExpressionContext SourceExpressionContext = new CSharpExpressionContext(); IndexedExpression.WriteCSharp(writer, SourceExpressionContext, -1); string IndexedText = SourceExpressionContext.ReturnValue; CSharpArgument.CSharpArgumentList(writer, expressionContext, FeatureCall, -1, false, out string ArgumentListText, out IList <string> OutgoingResultList); expressionContext.SetSingleReturnValue($"{IndexedText}[{ArgumentListText}]"); }
/// <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; ICSharpExpressionContext ExpressionContext = new CSharpExpressionContext(); string ArgumentListString = CSharpArgument.CSharpArgumentList(writer, ExpressionContext, FeatureCall); writer.WriteIndentedLine($"base[{ArgumentListString}] = {SourceString};"); }
private void WriteCSharpFeatureCall(ICSharpWriter writer, ICSharpExpressionContext expressionContext, int skippedIndex) { Feature.GetOutputFormat(SelectedOverloadType, out int OutgoingParameterCount, out int ReturnValueIndex); CSharpArgument.CSharpArgumentList(writer, expressionContext, FeatureCall, ReturnValueIndex, false, out string ArgumentListText, out IList <string> OutgoingResultList); string QueryText = Query.CSharpText(writer, 0); Debug.Assert(OutgoingParameterCount > 0); if (OutgoingParameterCount == 1) { if (ArgumentListText.Length > 0) { expressionContext.SetSingleReturnValue($"{QueryText}({ArgumentListText})"); } else if (Feature is ICSharpFunctionFeature) { expressionContext.SetSingleReturnValue($"{QueryText}()"); } else { if (writer.AttachmentMap.ContainsKey(QueryText)) { QueryText = writer.AttachmentMap[QueryText]; } expressionContext.SetSingleReturnValue(QueryText); } } else { if (ReturnValueIndex >= 0) { string TemporaryResultName = writer.GetTemporaryName(); writer.WriteIndentedLine($"var {TemporaryResultName} = {QueryText}({ArgumentListText});"); OutgoingResultList.Insert(ReturnValueIndex, TemporaryResultName); } else { writer.WriteIndentedLine($"{QueryText}({ArgumentListText});"); } expressionContext.SetMultipleResult(OutgoingResultList, ReturnValueIndex); } }
private void WriteCSharpCustomOperator(ICSharpWriter writer, ICSharpExpressionContext expressionContext, int skippedIndex) { string OperatorText = CSharpNames.ToCSharpIdentifier(Operator.Name); if (LeftExpression.IsSingleResult && RightExpression.IsSingleResult) { string LeftText = SingleResultExpressionText(writer, LeftExpression); ICSharpExpressionContext SourceExpressionContext = new CSharpExpressionContext(); RightExpression.WriteCSharp(writer, SourceExpressionContext, -1); string RightText = SourceExpressionContext.ReturnValue; expressionContext.SetSingleReturnValue($"{LeftText}.{OperatorText}({RightText})"); } else { Operator.GetOutputFormat(SelectedOverloadType, out int OutgoingParameterCount, out int ReturnValueIndex); string LeftText = SingleResultExpressionText(writer, LeftExpression); CSharpArgument.CSharpArgumentList(writer, expressionContext, FeatureCall, ReturnValueIndex, false, out string ArgumentListText, out IList <string> OutgoingResultList); if (ReturnValueIndex >= 0) { string TemporaryResultName = writer.GetTemporaryName(); writer.WriteIndentedLine($"var {TemporaryResultName} = {LeftText}.{OperatorText}({ArgumentListText});"); OutgoingResultList.Insert(ReturnValueIndex, TemporaryResultName); } else { writer.WriteIndentedLine($"{LeftText}.{OperatorText}({ArgumentListText});"); } expressionContext.SetMultipleResult(OutgoingResultList, ReturnValueIndex); } }
/// <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 CommandText; if (IsCallingNumberFeature) { CommandText = Command.CSharpText(writer, 0); IList <IIdentifier> ValidPath = ((IQualifiedName)Source.Command).ValidPath.Item; IIdentifier FinalFeatureIdentifier = ValidPath[ValidPath.Count - 1]; if (FinalFeatureIdentifier.ValidText.Item == "Increment") { CommandText = CommandText.Substring(0, CommandText.Length - 10); writer.WriteIndentedLine($"{CommandText}++;"); return; } else if (FinalFeatureIdentifier.ValidText.Item == "Decrement") { CommandText = CommandText.Substring(0, CommandText.Length - 10); writer.WriteIndentedLine($"{CommandText}--;"); return; } } bool IsAgent = !(FinalFeature is ICSharpProcedureFeature); if (IsAgent) { IIdentifier AgentIdentifier = (IIdentifier)Source.Command.Path[Source.Command.Path.Count - 1]; string AgentIdentifierText = CSharpNames.ToCSharpIdentifier(AgentIdentifier.ValidText.Item); if (Source.Command.Path.Count > 1) { CommandText = Command.CSharpText(writer, 1); } else { CommandText = "this"; } if (FeatureCall.ArgumentList.Count > 0) { ICSharpExpressionContext ExpressionContext = new CSharpExpressionContext(); string ArgumentListText = CSharpArgument.CSharpArgumentList(writer, ExpressionContext, FeatureCall); writer.WriteIndentedLine($"{AgentIdentifierText}({CommandText}, {ArgumentListText});"); } else { writer.WriteIndentedLine($"{AgentIdentifierText}({CommandText});"); } } else { CommandText = Command.CSharpText(writer, SkipLastInPath ? 1 : 0); ICSharpExpressionContext ExpressionContext = new CSharpExpressionContext(); string ArgumentListText = CSharpArgument.CSharpArgumentList(writer, ExpressionContext, FeatureCall); writer.WriteIndentedLine($"{CommandText}({ArgumentListText});"); } }
/// <summary> /// Gets the source code corresponding to the expression. /// </summary> /// <param name="writer">The stream on which to write.</param> /// <param name="expressionContext">The context.</param> /// <param name="skippedIndex">Index of a destination to skip.</param> public override void WriteCSharp(ICSharpWriter writer, ICSharpExpressionContext expressionContext, int skippedIndex) { Debug.Assert(WriteDown); string CoexistingPrecursorName = string.Empty; string CoexistingPrecursorRootName = ParentFeature.CoexistingPrecursorName; if (!string.IsNullOrEmpty(CoexistingPrecursorRootName)) { CoexistingPrecursorName = CSharpNames.ToCSharpIdentifier(CoexistingPrecursorRootName + " " + "Base"); } PrecursorFeature.GetOutputFormat(SelectedOverloadType, out int OutgoingParameterCount, out int ReturnValueIndex); CSharpArgument.CSharpArgumentList(writer, expressionContext, FeatureCall, ReturnValueIndex, false, out string ArgumentListText, out IList <string> OutgoingResultList); Debug.Assert(OutgoingParameterCount > 0); bool HasArguments = (ParentFeature is ICSharpFunctionFeature) || FeatureCall.ArgumentList.Count > 0; if (HasArguments) { ArgumentListText = $"({ArgumentListText})"; } if (!string.IsNullOrEmpty(CoexistingPrecursorRootName)) { expressionContext.SetSingleReturnValue($"{CoexistingPrecursorName}{ArgumentListText}"); } else { string FunctionName = CSharpNames.ToCSharpIdentifier(ParentFeature.Name); if (OutgoingParameterCount == 1) { if (ArgumentListText.Length > 0) { expressionContext.SetSingleReturnValue($"base.{FunctionName}{ArgumentListText}"); } else if (SelectedOverloadType != null) { expressionContext.SetSingleReturnValue($"base.{FunctionName}()"); } else { expressionContext.SetSingleReturnValue($"base.{FunctionName}"); } } else { if (ReturnValueIndex >= 0) { string TemporaryResultName = writer.GetTemporaryName(); writer.WriteIndentedLine($"var {TemporaryResultName} = base.{FunctionName}{ArgumentListText};"); OutgoingResultList.Insert(ReturnValueIndex, TemporaryResultName); } else { writer.WriteIndentedLine($"base.{FunctionName}{ArgumentListText};"); } expressionContext.SetMultipleResult(OutgoingResultList, ReturnValueIndex); } } }
/// <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 EntityString = CSharpNames.ToCSharpIdentifier(CreatedObjectName); string EntityTypeString = EntityType.Type2CSharpString(writer, CSharpTypeFormats.Normal, CSharpNamespaceFormats.None); bool IsAnchoredToCreationType = false; if (EntityType.Source is IAnchoredType AsAnchoredType) { if (AsAnchoredType.AnchorKind == BaseNode.AnchorKinds.Creation) { IsAnchoredToCreationType = true; } } string CreationRoutineString = CSharpNames.ToCSharpIdentifier(CreationRoutineName); ICSharpExpressionContext ExpressionContext = new CSharpExpressionContext(); string ArgumentListText = CSharpArgument.CSharpArgumentList(writer, ExpressionContext, FeatureCall); CSharpConstructorTypes ClassConstructorType = CSharpConstructorTypes.OneConstructor; if (EntityType is ICSharpClassType AsClassType) { ClassConstructorType = AsClassType.Class.ClassConstructorType; if (AsClassType.Class.Source.ClassGuid == LanguageClasses.List.Guid && CreationRoutineString == "MakeEmpty") { ClassConstructorType = CSharpConstructorTypes.NoConstructor; } } bool IsHandled = false; switch (ClassConstructorType) { case CSharpConstructorTypes.NoConstructor: case CSharpConstructorTypes.OneConstructor: if (IsAnchoredToCreationType) { writer.WriteIndentedLine($"{EntityString} = Activator.CreateInstance(typeof({EntityTypeString}).Assembly.FullName, typeof({EntityTypeString}).FullName, {ArgumentListText}).Unwrap() as {EntityTypeString};"); } else { writer.WriteIndentedLine($"{EntityString} = new {EntityTypeString}({ArgumentListText});"); } IsHandled = true; break; case CSharpConstructorTypes.ManyConstructors: if (IsAnchoredToCreationType) { writer.WriteIndentedLine($"{EntityString} = Activator.CreateInstance(typeof({EntityTypeString}).Assembly.FullName, typeof({EntityTypeString}).FullName).Unwrap() as {EntityTypeString};"); writer.WriteIndentedLine($"{EntityString}.{CreationRoutineString}({ArgumentListText});"); } else { writer.WriteIndentedLine($"{EntityString} = new {EntityTypeString}();"); writer.WriteIndentedLine($"{EntityString}.{CreationRoutineString}({ArgumentListText});"); } IsHandled = true; break; } Debug.Assert(IsHandled); }