public static IEnumerable <string> GetNameVariations([NotNull] FunctionOverride functionOverride) { if (functionOverride.NameType == OverrideNameType.EntryPoint) { return(new[] { functionOverride.BaseName }); } var extensionTrimmer = new OpenGLFunctionExtensionTrimmer(); var dataTypeTrimmer = new OpenGLFunctionDataTypeTrimmer(); var variations = new List <string>(); var currentVariation = functionOverride.BaseName; variations.Add(currentVariation); if (OpenGLFunctionExtensionTrimmer.IsRelevant(functionOverride)) { currentVariation = extensionTrimmer.Trim(functionOverride); variations.Add(currentVariation); } if (dataTypeTrimmer.IsRelevant(currentVariation)) { variations.Add(dataTypeTrimmer.Trim(currentVariation)); } return(variations.Distinct().OrderByDescending(v => v.Length)); }
private static FunctionSignature CreateOverriddenFunction ( [NotNull] FunctionSignature functionBase, [NotNull] FunctionOverride functionOverride ) { var newVersion = functionOverride.NewVersion ?? functionBase.IntroducedIn; var newReturnType = functionOverride.NewReturnType ?? functionBase.ReturnType; var newParameters = CreateOverriddenParameters(functionBase, functionOverride); var newDeprecationReason = functionOverride.ObsoletionReason ?? functionBase.DeprecationReason; return(new FunctionSignature ( functionBase.Name, functionBase.NativeEntrypoint, functionBase.Categories, functionBase.Extension, newVersion, newReturnType, newParameters, functionBase.DeprecatedIn, newDeprecationReason )); }
private static IReadOnlyList <ParameterSignature> CreateOverriddenParameters ( [NotNull] FunctionSignature functionBase, [NotNull] FunctionOverride functionOverride ) { var baseParameters = functionBase.Parameters; var parametersWithComputedCounts = new List <(ParameterSignature Parameter, IReadOnlyList <string> ComputedCountParameterNames)>(); var parametersWithValueReferenceCounts = new List <(ParameterSignature Parameter, string ParameterReferenceName)>(); var resultParameters = new List <ParameterSignature>(baseParameters); foreach (var overrideParameter in functionOverride.ParameterOverrides) { var baseParameter = functionBase.Parameters.FirstOrDefault(p => p.Name == overrideParameter.BaseName); if (baseParameter is null) { throw new InvalidDataException ( $"Could not find target parameter with name \"{overrideParameter.BaseName}\" to override." ); } var overriddenParameter = CreateOverriddenParameter ( baseParameter, overrideParameter, out var hasComputedCount, out var computedCountParameterNames, out var hasValueReference, out var valueReferenceName, out var valueReferenceExpression ); if (hasComputedCount) { parametersWithComputedCounts.Add((overriddenParameter, computedCountParameterNames)); } if (hasValueReference) { parametersWithValueReferenceCounts.Add((overriddenParameter, valueReferenceName)); // TODO: Pass on the mathematical expression } var baseIndex = resultParameters.IndexOf(baseParameter); resultParameters[baseIndex] = overriddenParameter; } ParsingHelpers.ResolveComputedCountSignatures(resultParameters, parametersWithComputedCounts); ParsingHelpers.ResolveReferenceCountSignatures(resultParameters, parametersWithValueReferenceCounts); return(resultParameters); }
private static IEnumerable <FunctionSignature> FindBaseFunctions ( [NotNull, ItemNotNull] IReadOnlyCollection <FunctionSignature> existingFunctions, [NotNull] FunctionOverride functionOverride ) { // First, build the list of candidate names var variations = Utilities.GetNameVariations(functionOverride).ToList(); foreach (var variation in variations) { var baseFunctionCandidates = existingFunctions.Where ( f => (f.Name == variation || f.NativeEntrypoint == variation) && f.Extension == functionOverride.BaseExtension ).ToList(); if (!baseFunctionCandidates.Any()) { baseFunctionCandidates = existingFunctions .Where ( f => f.Name == variation || f.NativeEntrypoint == variation ).ToList(); } baseFunctionCandidates = baseFunctionCandidates.Where ( f => functionOverride.ParameterOverrides.All(po => f.Parameters.Any(p => p.Name == po.BaseName)) ).ToList(); // If we have a set of candidates at this point, we've found the most specific set of functions that are // applicable. if (baseFunctionCandidates.Any()) { return(baseFunctionCandidates); } } // If we've reached this point, we couldn't find any targets. Let's gather as much information for the end // developer as possible. foreach (var variation in variations) { var noFunctionsWithThatName = existingFunctions.All(f => f.Name != variation); if (noFunctionsWithThatName) { throw new InvalidDataException ( $"No base function found for the override with the name \"{functionOverride.BaseName}\" when " + $"considering the variation \"{variation}\". " + "Specify another name." ); } var parameterNames = new List <string>(); var functionsWithThatName = existingFunctions.Where(f => f.Name == variation).ToList(); foreach (var functionWithThatName in functionsWithThatName) { var parameterNamesNotFound = functionOverride.ParameterOverrides .Where ( po => functionWithThatName.Parameters.All(p => p.Name != po.BaseName) ).Select(po => po.BaseName); parameterNames.AddRange(parameterNamesNotFound); } if (parameterNames.Any()) { throw new InvalidDataException ( $"No base function found for the override with the name \"{functionOverride.BaseName}\" when " + $"considering the variation \"{variation}\" that had the following parameters: " + $"({string.Join(", ", parameterNames.ToArray())})" + "Specify other parameter names." ); } } throw new InvalidDataException("No base function found for override."); }