private static void BuildResultListNoResult(ICSharpUsingCollection usingCollection, IList <ICSharpParameter> resultList, ref string parameterListText, ref string parameterNameListText, out string resultTypeText) { resultTypeText = "void"; foreach (ICSharpParameter Result in resultList) { ICSharpScopeAttributeFeature ResultAttribute = Result.Feature; ICSharpType ParameterType = ResultAttribute.Type; CSharpTypeFormats ParameterFormat = ParameterType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string TypeString = ParameterType.Type2CSharpString(usingCollection, ParameterFormat, CSharpNamespaceFormats.None); string AttributeString = CSharpNames.ToCSharpIdentifier(Result.Name); if (parameterListText.Length > 0) { parameterListText += ", "; } if (parameterNameListText.Length > 0) { parameterNameListText += ", "; } parameterListText += $"out {TypeString} {AttributeString}"; parameterNameListText += $"out {AttributeString}"; } }
/// <summary> /// Builds a list of parameters, with and without their type. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="parameterList">The list of parameters.</param> /// <param name="parameterListText">The list of parameters with type upon return.</param> /// <param name="parameterNameListText">The list of parameters without type upon return.</param> public static void BuildParameterList(ICSharpUsingCollection usingCollection, IList <ICSharpParameter> parameterList, out string parameterListText, out string parameterNameListText) { parameterListText = string.Empty; parameterNameListText = string.Empty; foreach (ICSharpParameter Parameter in parameterList) { if (parameterListText.Length > 0) { parameterListText += ", "; } if (parameterNameListText.Length > 0) { parameterNameListText += ", "; } string ParameterName = Parameter.Name; ICSharpType ParameterType = Parameter.Feature.Type; CSharpTypeFormats ParameterFormat = ParameterType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string ParameterText = ParameterType.Type2CSharpString(usingCollection, ParameterFormat, CSharpNamespaceFormats.None); string ParameterNameText = CSharpNames.ToCSharpIdentifier(ParameterName); parameterListText += $"{ParameterText} {ParameterNameText}"; parameterNameListText += ParameterNameText; } }
/// <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); Debug.Assert(TypeList.Count > 0); string CloneMethod = Source.Type == BaseNode.CloneType.Shallow ? "CloneShallow" : "Clone"; ICSharpExpressionContext SourceExpressionContext = new CSharpExpressionContext(); SourceExpression.WriteCSharp(writer, SourceExpressionContext, -1); IList <string> ResultList = new List <string>(); int ReturnValueIndex = SourceExpressionContext.ReturnValueIndex; string ReturnValue = SourceExpressionContext.ReturnValue; if (TypeList.Count == 1) { ICSharpType ClonedType = TypeList[0]; string SourceTypeText = ClonedType.Type2CSharpString(writer, CSharpTypeFormats.Normal, CSharpNamespaceFormats.None); string SourceText = SourceExpressionContext.ReturnValue; Debug.Assert(SourceText != null); expressionContext.SetSingleReturnValue($"({SourceTypeText})({SourceText}).{CloneMethod}()"); } else { for (int i = 0; i < SourceExpressionContext.CompleteDestinationNameList.Count; i++) { if (i == ReturnValueIndex) { Debug.Assert(ReturnValue != null); ResultList.Add(ReturnValue); } else { ResultList.Add(SourceExpressionContext.CompleteDestinationNameList[i]); } } Debug.Assert(TypeList.Count == ResultList.Count); IList <string> OutgoingResultList = new List <string>(); for (int i = 0; i < TypeList.Count; i++) { ICSharpType ClonedType = TypeList[i]; string SourceTypeText = ClonedType.Type2CSharpString(writer, CSharpTypeFormats.Normal, CSharpNamespaceFormats.None); string SourceText = ResultList[i]; OutgoingResultList.Add($"({SourceTypeText})({SourceText}).{CloneMethod}()"); } expressionContext.SetMultipleResult(OutgoingResultList, ReturnValueIndex); } }
/// <summary> /// Builds a list of parameters, with and without their type. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="parameterList">The list of parameters.</param> /// <param name="resultList">The list of results.</param> /// <param name="featureTextType">The write mode.</param> /// <param name="parameterListText">The list of parameters with type upon return.</param> /// <param name="parameterNameListText">The list of parameters without type upon return.</param> /// <param name="resultTypeText">The type text upon return.</param> public static void BuildParameterList(ICSharpUsingCollection usingCollection, IList <ICSharpParameter> parameterList, IList <ICSharpParameter> resultList, CSharpFeatureTextTypes featureTextType, out string parameterListText, out string parameterNameListText, out string resultTypeText) { parameterListText = string.Empty; parameterNameListText = string.Empty; foreach (ICSharpParameter Parameter in parameterList) { if (parameterListText.Length > 0) { parameterListText += ", "; } if (parameterNameListText.Length > 0) { parameterNameListText += ", "; } string ParameterName = Parameter.Name; ICSharpType ParameterType = Parameter.Feature.Type; CSharpTypeFormats ParameterFormat = ParameterType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string ParameterText = ParameterType.Type2CSharpString(usingCollection, ParameterFormat, CSharpNamespaceFormats.None); string ParameterNameText = CSharpNames.ToCSharpIdentifier(ParameterName); parameterListText += $"{ParameterText} {ParameterNameText}"; parameterNameListText += ParameterNameText; } if (resultList.Count == 1) { BuildResultListSingle(usingCollection, resultList, out resultTypeText); } else { int ResultIndex = -1; for (int i = 0; i < resultList.Count; i++) { ICSharpParameter Result = resultList[i]; if (Result.Name == nameof(BaseNode.Keyword.Result)) { ResultIndex = i; break; } } if (ResultIndex < 0) { BuildResultListNoResult(usingCollection, resultList, ref parameterListText, ref parameterNameListText, out resultTypeText); } else { BuildResultListWithResult(usingCollection, resultList, ResultIndex, ref parameterListText, ref parameterNameListText, out resultTypeText); } } }
/// <summary> /// Get the name of a type. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="cSharpTypeFormat">The type format.</param> /// <param name="cSharpNamespaceFormat">The namespace format.</param> public override string Type2CSharpString(ICSharpUsingCollection usingCollection, CSharpTypeFormats cSharpTypeFormat, CSharpNamespaceFormats cSharpNamespaceFormat) { SetUsedInCode(); string Result; // TODO: detect delegate call parameters to select the proper overload if (OriginatingTypedef != null) { string DelegateName = CSharpNames.ToCSharpIdentifier(OriginatingTypedef.Name); Result = CommandOverloadType2CSharpString(DelegateName, Source.OverloadList[0]); } else { ICSharpCommandOverloadType OverloadType = OverloadTypeList[0]; string ActionArgumentText = BaseType.Type2CSharpString(usingCollection, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None); foreach (ICSharpParameter Parameter in OverloadType.ParameterList) { ICSharpType ParameterType = Parameter.Feature.Type; CSharpTypeFormats ParameterFormat = ParameterType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string ParameterText = ParameterType.Type2CSharpString(usingCollection, ParameterFormat, CSharpNamespaceFormats.None); ActionArgumentText += $", {ParameterText}"; } Result = $"Action<{ActionArgumentText}>"; usingCollection.AddUsing(nameof(System)); } return(Result); }
private static void BuildResultListWithResult(ICSharpUsingCollection usingCollection, IList <ICSharpParameter> resultList, int resultIndex, ref string parameterListText, ref string parameterNameListText, out string resultTypeText) { resultTypeText = null; for (int i = 0; i < resultList.Count; i++) { ICSharpParameter Result = resultList[i]; ICSharpScopeAttributeFeature ResultAttribute = Result.Feature; ICSharpType ParameterType = ResultAttribute.Type; CSharpTypeFormats ParameterFormat = ParameterType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string TypeString = ParameterType.Type2CSharpString(usingCollection, ParameterFormat, CSharpNamespaceFormats.None); string AttributeString = CSharpNames.ToCSharpIdentifier(Result.Name); if (i == resultIndex) { resultTypeText = TypeString; } else { if (parameterListText.Length > 0) { parameterListText += ", "; } if (parameterNameListText.Length > 0) { parameterNameListText += ", "; } parameterListText += $"out {TypeString} {AttributeString}"; parameterNameListText += $"out {AttributeString}"; } } Debug.Assert(resultTypeText != null); }
/// <summary> /// Get the name of a type. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="cSharpTypeFormat">The type format.</param> /// <param name="cSharpNamespaceFormat">The namespace format.</param> public override string Type2CSharpString(ICSharpUsingCollection usingCollection, CSharpTypeFormats cSharpTypeFormat, CSharpNamespaceFormats cSharpNamespaceFormat) { SetUsedInCode(); string Result; if (OriginatingTypedef != null) { // TODO: detect delegate call parameters to select the proper overload string DelegateName = CSharpNames.ToCSharpIdentifier(OriginatingTypedef.Name); Result = QueryOverloadType2CSharpString(DelegateName, Source.OverloadList[0]); } else { ICSharpQueryOverloadType OverloadType = OverloadTypeList[0]; string ActionArgumentText = BaseType.Type2CSharpString(usingCollection, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None); foreach (ICSharpParameter Parameter in OverloadType.ParameterList) { ICSharpType ParameterType = Parameter.Feature.Type; CSharpTypeFormats ParameterFormat = ParameterType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string ParameterText = ParameterType.Type2CSharpString(usingCollection, ParameterFormat, CSharpNamespaceFormats.None); ActionArgumentText += $", {ParameterText}"; } Debug.Assert(OverloadType.ResultList.Count >= 1); if (OverloadType.ResultList.Count == 1) { ICSharpParameter Parameter = OverloadType.ResultList[0]; ICSharpType ResultType = Parameter.Feature.Type; CSharpTypeFormats ResultFormat = ResultType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string ResultText = ResultType.Type2CSharpString(usingCollection, ResultFormat, CSharpNamespaceFormats.None); ActionArgumentText += $", {ResultText}"; } else { string FuncResultText = string.Empty; foreach (ICSharpParameter Parameter in OverloadType.ResultList) { if (FuncResultText.Length > 0) { FuncResultText += ", "; } ICSharpType ResultType = Parameter.Feature.Type; CSharpTypeFormats ResultFormat = ResultType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string ResultText = ResultType.Type2CSharpString(usingCollection, ResultFormat, CSharpNamespaceFormats.None); FuncResultText += $", {ResultText}"; } ActionArgumentText += $", Tuple<{FuncResultText}>"; } Result = $"Func<{ActionArgumentText}>"; usingCollection.AddUsing(nameof(System)); } return(Result); }