switch root namespace name to NITLOAD
This commit is contained in:
Youmu Liu
@@ -0,0 +1,268 @@
|
||||
// -----------------------------------------------------------------------------
|
||||
// file="ManagedApiPlanner"
|
||||
// Project: StgSharp
|
||||
// Copyright (c) Nitload.
|
||||
// SPDX-License-Identifier: MIT
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Collections.ObjectModel;
|
||||
using System.Linq;
|
||||
using StgSharp.GenerateGL.Analysis;
|
||||
using StgSharp.GenerateGL.Naming;
|
||||
using StgSharp.GenerateGL.Registry;
|
||||
|
||||
namespace StgSharp.GenerateGL.Generation
|
||||
{
|
||||
internal sealed class ManagedApiPlanner
|
||||
{
|
||||
|
||||
private readonly IReadOnlyList<IGlApiFilter> _filters = Array.AsReadOnly<IGlApiFilter>(
|
||||
new IGlApiFilter[]
|
||||
{
|
||||
new GlManagedApiSuppressionFilter(),
|
||||
new GlOverloadApiFilter(),
|
||||
new GlGetValueApiFilter(),
|
||||
new GlHandleApiFilter(),
|
||||
});
|
||||
private readonly GlEquivalentTypeMapper _typeMapper;
|
||||
private readonly GlEnumTypeMap _enumTypeMap;
|
||||
private readonly GlManagedApiNamePolicy _namePolicy;
|
||||
|
||||
public ManagedApiPlanner(
|
||||
GlEquivalentTypeMapper typeMapper,
|
||||
GlFunctionFamilyAnalysis familyAnalysis,
|
||||
GlEnumTypeMap enumTypeMap
|
||||
)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(typeMapper);
|
||||
ArgumentNullException.ThrowIfNull(familyAnalysis);
|
||||
ArgumentNullException.ThrowIfNull(enumTypeMap);
|
||||
_typeMapper = typeMapper;
|
||||
_enumTypeMap = enumTypeMap;
|
||||
_namePolicy = new GlManagedApiNamePolicy(familyAnalysis);
|
||||
}
|
||||
|
||||
public IReadOnlyList<ManagedMethodDefinition> Plan(
|
||||
IReadOnlyList<GlCommandDefinition> commands
|
||||
)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(commands);
|
||||
|
||||
List<ManagedMethodDefinition> result = new List<ManagedMethodDefinition>();
|
||||
foreach (GlCommandDefinition command in commands)
|
||||
{
|
||||
IReadOnlyList<ManagedMethodDefinition> methods = Array.AsReadOnly(
|
||||
new[]
|
||||
{
|
||||
CreateRawMethod(command),
|
||||
});
|
||||
foreach (IGlApiFilter filter in _filters)
|
||||
{
|
||||
methods = filter.Apply(command, methods, _typeMapper);
|
||||
}
|
||||
|
||||
methods = ApplyEnumTypes(command, methods);
|
||||
|
||||
result.AddRange(
|
||||
methods.Select(
|
||||
method => method with
|
||||
{
|
||||
Name = _namePolicy.ReadMethodName(command, method.Name),
|
||||
DocumentationPage = _namePolicy.ReadDocumentationPage(command),
|
||||
Parameters = Array.AsReadOnly(
|
||||
method.Parameters.Select(
|
||||
parameter => parameter with
|
||||
{
|
||||
Name = CSharpIdentifierPolicy.NormalizeParameterName(
|
||||
parameter.Name),
|
||||
}).ToArray()),
|
||||
}));
|
||||
}
|
||||
|
||||
ResolveNameCollisions(result);
|
||||
return Array.AsReadOnly(result.ToArray());
|
||||
}
|
||||
|
||||
private ReadOnlyCollection<ManagedMethodDefinition> ApplyEnumTypes(
|
||||
GlCommandDefinition command,
|
||||
IReadOnlyList<ManagedMethodDefinition> methods
|
||||
)
|
||||
{
|
||||
bool hasEnumReturn = _enumTypeMap.TryReadReturnType(
|
||||
command.Return,
|
||||
out string enumReturnType);
|
||||
return Array.AsReadOnly(
|
||||
methods.Select(
|
||||
method => ConvertEnumReturn(method, hasEnumReturn, enumReturnType)).ToArray());
|
||||
}
|
||||
|
||||
private ManagedMethodDefinition ConvertEnumReturn(
|
||||
ManagedMethodDefinition method,
|
||||
bool hasEnumReturn,
|
||||
string enumReturnType
|
||||
)
|
||||
{
|
||||
string returnType = string.Empty;
|
||||
bool isEnumReturn = hasEnumReturn && TryReplaceNativeEnumType(
|
||||
method.ReturnType,
|
||||
enumReturnType,
|
||||
out returnType);
|
||||
return method with
|
||||
{
|
||||
ReturnType = isEnumReturn ? returnType : method.ReturnType,
|
||||
IsEnumReturn = isEnumReturn,
|
||||
Parameters = Array.AsReadOnly(
|
||||
method.Parameters.Select(ConvertEnumParameter).ToArray()),
|
||||
};
|
||||
}
|
||||
|
||||
private ManagedParameterDefinition ConvertEnumParameter(
|
||||
ManagedParameterDefinition parameter
|
||||
)
|
||||
{
|
||||
if (parameter.NativeParameter is null ||
|
||||
!_enumTypeMap.TryReadParameterType(
|
||||
parameter.NativeParameter,
|
||||
out string enumType) ||
|
||||
!TryReplaceNativeEnumType(parameter.Type, enumType, out string convertedType))
|
||||
{
|
||||
return parameter;
|
||||
}
|
||||
|
||||
return parameter with
|
||||
{
|
||||
Type = convertedType,
|
||||
IsEnum = true,
|
||||
};
|
||||
}
|
||||
|
||||
private static bool TryReplaceNativeEnumType(
|
||||
string nativeType,
|
||||
string enumType,
|
||||
out string convertedType
|
||||
)
|
||||
{
|
||||
const string nativeBaseType = "uint";
|
||||
if (!nativeType.StartsWith(nativeBaseType, StringComparison.Ordinal) ||
|
||||
nativeType.AsSpan(nativeBaseType.Length).ContainsAnyExcept('*'))
|
||||
{
|
||||
convertedType = string.Empty;
|
||||
return false;
|
||||
}
|
||||
|
||||
convertedType = enumType + nativeType[nativeBaseType.Length..];
|
||||
return true;
|
||||
}
|
||||
|
||||
public static void Validate(
|
||||
IEnumerable<ManagedMethodDefinition> methods
|
||||
)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(methods);
|
||||
|
||||
Dictionary<string, ManagedMethodDefinition> signatures = new Dictionary<string, ManagedMethodDefinition>(
|
||||
StringComparer.Ordinal);
|
||||
foreach (ManagedMethodDefinition method in methods)
|
||||
{
|
||||
string signature = $"{method.Name}({string.Join(",", method.Parameters.Select(value => value.Type))})";
|
||||
if (signatures.TryGetValue(signature, out ManagedMethodDefinition? previous))
|
||||
{
|
||||
throw new InvalidOperationException(
|
||||
$"Managed overload '{signature}' is produced by both " +
|
||||
$"'{previous.NativeCommand.Name}' and '{method.NativeCommand.Name}'.");
|
||||
}
|
||||
|
||||
signatures.Add(signature, method);
|
||||
}
|
||||
}
|
||||
|
||||
private static void ResolveNameCollisions(
|
||||
List<ManagedMethodDefinition> methods
|
||||
)
|
||||
{
|
||||
ILookup<string, int> indicesBySignature = methods
|
||||
.Select(
|
||||
(method, index) => new
|
||||
{
|
||||
Index = index,
|
||||
Signature = ReadManagedSignature(method),
|
||||
})
|
||||
.ToLookup(value => value.Signature, value => value.Index, StringComparer.Ordinal);
|
||||
foreach (IGrouping<string, int> group in indicesBySignature)
|
||||
{
|
||||
int[] indices = group.ToArray();
|
||||
if (indices.Length < 2)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
string[] nativeNames = indices
|
||||
.Select(value => methods[value].NativeCommand.Name)
|
||||
.Distinct(StringComparer.Ordinal)
|
||||
.ToArray();
|
||||
if (nativeNames.Length != indices.Length)
|
||||
{
|
||||
throw new InvalidOperationException(
|
||||
$"Managed overload '{group.Key}' is duplicated by one native command.");
|
||||
}
|
||||
|
||||
foreach (int index in indices)
|
||||
{
|
||||
ManagedMethodDefinition method = methods[index];
|
||||
methods[index] = method with
|
||||
{
|
||||
Name = GlManagedApiNamePolicy.ReadNativeMethodName(
|
||||
method.NativeCommand),
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static string ReadManagedSignature(
|
||||
ManagedMethodDefinition method
|
||||
)
|
||||
{
|
||||
return $"{method.Name}({string.Join(",", method.Parameters.Select(value => value.Type))})";
|
||||
}
|
||||
|
||||
private ManagedMethodDefinition CreateRawMethod(
|
||||
GlCommandDefinition command
|
||||
)
|
||||
{
|
||||
List<ManagedParameterDefinition> parameters = new List<ManagedParameterDefinition>(
|
||||
command.Parameters.Count);
|
||||
List<ManagedArgument> arguments = new List<ManagedArgument>(
|
||||
command.Parameters.Count);
|
||||
for (int index = 0; index < command.Parameters.Count; index++)
|
||||
{
|
||||
GlParameterDefinition source = command.Parameters[index];
|
||||
parameters.Add(
|
||||
new ManagedParameterDefinition(
|
||||
_typeMapper.ReadParameterType(source),
|
||||
source.Name,
|
||||
source));
|
||||
arguments.Add(new ParameterArgument(index));
|
||||
}
|
||||
|
||||
return new ManagedMethodDefinition(
|
||||
ReadMethodName(command.Name),
|
||||
_typeMapper.ReadReturnType(command),
|
||||
Array.AsReadOnly(parameters.ToArray()),
|
||||
command,
|
||||
new DirectInvocation(Array.AsReadOnly(arguments.ToArray())));
|
||||
}
|
||||
|
||||
private static string ReadMethodName(
|
||||
string commandName
|
||||
)
|
||||
{
|
||||
return commandName.StartsWith("gl", StringComparison.Ordinal) &&
|
||||
commandName.Length > 2
|
||||
? commandName[2..]
|
||||
: commandName;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user