protected override Data.OverloadSetting GetOverload(Type neosType)
{
NodeOverload typeOverload = neosType.GetCustomAttribute <NodeOverload>();
if (Overloads.TryGetValue(neosType.FullName, out Data.OverloadSetting overloadSetting))
{
return(overloadSetting);
}
if (typeOverload != null)
{
if (Overloads.TryGetValue(typeOverload.FunctionName, out overloadSetting))
{
return(overloadSetting);
}
Type foundTypeOverload = LogixHelper.GetMatchingOverload(typeOverload.FunctionName, null, new Func <Type, int>(GetTypeRank));
if (foundTypeOverload != null)
{
OverloadCache.Add(typeOverload.FunctionName);
return(new Data.OverloadSetting {
OverloadType = foundTypeOverload?.FullName
});
}
}
return(new Data.OverloadSetting {
OverloadType = neosType.FullName
});
}
public SmokeTest ToSmokeTestOrNull()
{
// We just need to fill in the arguments...
var candidate = new SmokeTest {
Client = Client, Method = Method
};
// Parameterless RPCs are very rare, but are good candidates for smoke tests.
// Admittedly this has some false positives, e.g. in Vision, ProductSearchClient.PurgeProducts.
if (Overloads.Any(o => o.RequiredParameters.Count == 0))
{
// No arguments required
return(candidate);
}
// If there's a method that accepts just a ProjectName, find its equivalent accepting a string. (There should be exactly one.)
if (Overloads.Any(o => o.HasSingleParameterOfType("Google.Api.Gax.ResourceNames.ProjectName")))
{
var stringParameter = Overloads.Single(o => o.HasSingleParameterOfType(typeof(string))).RequiredParameters[0];
candidate.Arguments[stringParameter.Name] = "projects/${PROJECT_ID}";
return(candidate);
}
// If there's a method that accepts just a LocationName, find its equivalent accepting a string. (There should be exactly one.)
if (Overloads.Any(o => o.HasSingleParameterOfType("Google.Api.Gax.ResourceNames.LocationName")))
{
var stringParameter = Overloads.Single(o => o.HasSingleParameterOfType(typeof(string))).RequiredParameters[0];
candidate.Arguments[stringParameter.Name] = "projects/${PROJECT_ID}/locations/us-east1";
return(candidate);
}
return(null);
}
public override bool AltMem <EqA>(A a)
{
Fun <A, List <A> > wrap = delegate(A e) { return(new Cons <A>(e, new Nil <A>())); };
return(Overloads.Eq <EqA, A>(a, h) || t.Map(wrap).Mem <EqList <EqA, A> >(wrap(a)));
//return Eq(a,h) || t.Map(wrap).Mem(wrap(a));
}
public IEnumerable <string> GetExtensions()
{
var nativeExtensions = NativeSignatures.Select(f => f.Extension);
var overloadExtensions = Overloads.Select(f => f.Extension);
return(nativeExtensions.Concat(overloadExtensions).Distinct());
}
public DrawStrings()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
_overload = Overloads.Overload3;
}
public IEnumerable <string> GetCategories()
{
var nativeCategories = NativeSignatures.SelectMany(f => f.Categories);
var overloadCategories = Overloads.SelectMany(f => f.Categories);
return(nativeCategories.Concat(overloadCategories).Distinct());
}
/// <summary>
/// Executes this command with specified context.
/// </summary>
/// <param name="ctx">Context to execute the command in.</param>
/// <returns>Command's execution results.</returns>
public virtual async Task <CommandResult> ExecuteAsync(CommandContext ctx)
{
CommandResult res = default;
try
{
var executed = false;
foreach (var ovl in Overloads.OrderByDescending(x => x.Priority))
{
ctx.Overload = ovl;
var args = await CommandsNextUtilities.BindArguments(ctx, ctx.Config.IgnoreExtraArguments).ConfigureAwait(false);
if (!args.IsSuccessful)
{
continue;
}
ctx.RawArguments = args.Raw;
var mdl = ovl.InvocationTarget ?? Module?.GetInstance(ctx.Services);
if (mdl is BaseCommandModule bcmBefore)
{
await bcmBefore.BeforeExecutionAsync(ctx).ConfigureAwait(false);
}
args.Converted[0] = mdl;
var ret = (Task)ovl.Callable.DynamicInvoke(args.Converted);
await ret.ConfigureAwait(false);
executed = true;
res = new CommandResult
{
IsSuccessful = true,
Context = ctx
};
if (mdl is BaseCommandModule bcmAfter)
{
await bcmAfter.AfterExecutionAsync(ctx).ConfigureAwait(false);
}
break;
}
if (!executed)
{
throw new ArgumentException("Could not find a suitable overload for the command.");
}
}
catch (Exception ex)
{
res = new CommandResult
{
IsSuccessful = false,
Exception = ex,
Context = ctx
};
}
return(res);
}
internal override Command Build(CommandGroup parent)
{
var cmd = new CommandGroup
{
Name = Name,
Description = Description,
Aliases = Aliases,
ExecutionChecks = ExecutionChecks,
IsHidden = IsHidden,
Parent = parent,
Overloads = new ReadOnlyCollection <CommandOverload>(Overloads.Select(xo => xo.Build()).ToList()),
Module = Module,
CustomAttributes = CustomAttributes
};
var cs = new List <Command>();
foreach (var xc in Children)
{
cs.Add(xc.Build(cmd));
}
cmd.Children = new ReadOnlyCollection <Command>(cs);
return(cmd);
}
public override void AddOverload(ICompletionData n)
{
if (Overloads == null)
{
Overloads = new List <ICompletionData>();
Overloads.Add(this);
}
Overloads.Add(n);
}
public FunctionSignature FindFunctionWithEntrypoint([NotNull] string entrypoint)
{
var nativeSignature = NativeSignatures.FirstOrDefault(f => f.NativeEntrypoint == entrypoint);
if (nativeSignature is null)
{
return(Overloads.FirstOrDefault(f => f.NativeEntrypoint == entrypoint));
}
return(nativeSignature);
}
public FunctionSymbol(string name, IEnumerable <FunctionOverload> overloads)
: base(name)
{
Overloads = overloads.ToImmutableArray();
FunctionFlags = Overloads.First().Flags;
if (Overloads.Skip(1).Any(fo => fo.Flags != FunctionFlags))
{
// we should catch this as early as possible
throw new ArgumentException("Inconsistent function flags found on overloads");
}
}
private bool VerifyReadLineParseOverloads(Overloads overloads)
{
if (overloads.Name != "ReadLine")
{
return(false);
}
if (overloads.ReturnType != "string")
{
return(false);
}
if (overloads.Count() != 1)
{
return(false);
}
return(true);
}
public async Task RequestParameters(string code, int cursorPosition, int tokenStart)
{
await DoCancellableAction(async (token) =>
{
var paramsRaw = await ideServices.GetOverloadsAndParametersAsync(code, cursorPosition, token);
// If cancelled, then don't bother sending details back to the client
token.ThrowIfCancellationRequested();
if (paramsRaw != null) // Don't bother calling back if there is no parameter list to show
{
var overloads = new Overloads(paramsRaw);
Clients.Caller.ParamsCallback(overloads, tokenStart);
}
}, Context.ConnectionId, inProgressParams);
}
internal virtual Command Build(CommandGroup parent)
{
var cmd = new Command
{
Name = Name,
Description = Description,
Aliases = Aliases,
ExecutionChecks = ExecutionChecks,
IsHidden = IsHidden,
Parent = parent,
Overloads = new ReadOnlyCollection <CommandOverload>(Overloads.Select(xo => xo.Build()).ToList()),
Module = Module,
CustomAttributes = CustomAttributes
};
return(cmd);
}
private bool VerifyDateTimeParseOverloads(Overloads overloads)
{
if (overloads.Name != "Parse")
{
return(false);
}
if (overloads.ReturnType != "DateTime")
{
return(false);
}
if (overloads.Count() != 3)
{
return(false);
}
var threeParams = overloads.Single(method => method.Parameters.Count == 3).Parameters.ToArray();
if (threeParams[0].Name != "s")
{
return(false);
}
if (threeParams[0].Type != "string")
{
return(false);
}
if (threeParams[1].Name != "provider")
{
return(false);
}
if (threeParams[1].Type != "IFormatProvider")
{
return(false);
}
if (threeParams[2].Name != "styles")
{
return(false);
}
if (threeParams[2].Type != "DateTimeStyles")
{
return(false);
}
return(true);
}
public static void Run()
{
List <int> l1 = FromArray(1, 2, 3, 4);
List <int> l2 = FromArray(5, 6, 7, 8);
Console.WriteLine("Lists: Eq(null,null)={0}", Overloads.Eq <EqList <EqInt, int>, List <int> >(null, null));
Console.WriteLine("Lists: Eq(null,l1)={0}", Overloads.Eq <EqList <EqInt, int>, List <int> >(null, l1));
Console.WriteLine("Lists: Eq(l1,null)={0}", Overloads.Eq <EqList <EqInt, int>, List <int> >(l1, null));
Console.WriteLine("Lists: Eq(l1,l1)={0}", Overloads.Eq <EqList <EqInt, int>, List <int> >(l1, l1));
Console.WriteLine("Lists: Eq(l1,l2)={0}", Overloads.Eq <EqList <EqInt, int>, List <int> >(l1, l2));
List <List <int> > ll1 = FromArray(l1, l2);
List <List <int> > ll2 = FromArray(l2, l1);
Console.WriteLine("Lists: Eq(null,null)={0}", Overloads.Eq <EqList <EqList <EqInt, int>, List <int> >, List <List <int> > >(null, null));
Console.WriteLine("Lists: Eq(null,ll1)={0}", Overloads.Eq <EqList <EqList <EqInt, int>, List <int> >, List <List <int> > >(null, ll1));
Console.WriteLine("Lists: Eq(ll1,null)={0}", Overloads.Eq <EqList <EqList <EqInt, int>, List <int> >, List <List <int> > >(ll1, null));
Console.WriteLine("Lists: Eq(ll1,ll1)={0}", Overloads.Eq <EqList <EqList <EqInt, int>, List <int> >, List <List <int> > >(ll1, ll1));
Console.WriteLine("Lists: Eq(ll1,ll2)={0}", Overloads.Eq <EqList <EqList <EqInt, int>, List <int> >, List <List <int> > >(ll1, ll2));
}
bool Eq <List <A> > .Equals(List <A> a, List <A> b)
{
Nil <A> an = a as Nil <A>;
if (an != null)
{
Nil <A> ab = b as Nil <A>;
return(b != null);
}
;
Cons <A> ac = a as Cons <A>;
if (ac != null)
{
Cons <A> bc = b as Cons <A>;
return(bc != null && Overloads.Eq <EqA, A>(ac.h, bc.h) && Overloads.Eq <EqList <EqA, A>, List <A> >(ac.t, bc.t));
}
return(b == null);
}
protected override void Update(GameTime gameTime)
{
KeyboardState currentState = Keyboard.GetState();
if (currentState.IsKeyDown(Keys.Escape) && _lastState.IsKeyUp(Keys.Escape))
this.Exit();
if (_overload == Overloads.Overload6)
_overload = Overloads.Overload3;
else
{
if (currentState.IsKeyDown(Keys.O) && _lastState.IsKeyUp(Keys.O))
_overload++;
}
_lastState = currentState;
base.Update(gameTime);
}
internal override IEnumerable <NameExpression> Walk()
{
List <NameExpression> freeVars = new List <NameExpression>();
foreach (Definition definition in Definitions)
{
freeVars.AddRange(definition.Walk());
}
DeclaredVariables = new List <Variable>();
foreach (Definition definition in Definitions)
{
if (!(definition is FunctionDefinition))
{
DeclaredVariables.Add(definition.DeclaredVariable);
}
}
List <FunctionDefinition> functions = Definitions
.Where(statement => statement is FunctionDefinition)
.Select(statement => statement as FunctionDefinition)
.ToList();
Overloads = Compiler.GenerateOverloads(functions);
DeclaredVariables.AddRange(Overloads.Select(o => o.variable));
foreach (Variable variable in DeclaredVariables)
{
variable.Global = true;
}
Compiler.MatchVariables(freeVars, DeclaredVariables);
return(freeVars);
// TODO: Walk the imports that refer to actual Redwood modules?
}
public Overloads(Overloads overloads)
: this(overloads.members, overloads.scope, overloads.positionOfSelectedMember, overloads.helper, overloads.OverloadKind) {
}
public override bool Mem <EqA>(A a)
{
return(Overloads.Eq <EqA, A>(a, h) || t.Mem <EqA>(a));
//return Eq(a, h) || t.Mem(a);
}
public override bool Eq <EqA>(List <A> a)
{
Cons <A> ca = a as Cons <A>;
return((a != null) && ca != null && Overloads.Eq <EqA, A>(h, ca.h) && this.t.Eq <EqA>(ca.t));
}
internal override IEnumerable <NameExpression> Walk()
{
Type = RedwoodType.Make(this);
base.Walk();
DeclaredVariable.KnownType = RedwoodType.GetForCSharpType(typeof(RedwoodType));
DeclaredVariable.DefinedConstant = true;
DeclaredVariable.ConstantValue = Type;
List <NameExpression> freeVars = new List <NameExpression>();
List <Variable> declaredVars = new List <Variable>();
InterfaceImplicitConversionVars = new List <Variable>();
int maxConstructorArgs = 0;
This = new Variable
{
Name = "this",
KnownType = Type
};
declaredVars.Add(This);
if (ParameterFields != null)
{
maxConstructorArgs = ParameterFields.Length;
foreach (ParameterDefinition param in ParameterFields)
{
freeVars.AddRange(param.Walk());
declaredVars.Add(param.DeclaredVariable);
}
}
foreach (TypeSyntax interfaceType in Interfaces)
{
freeVars.AddRange(interfaceType.Walk());
// TODO: What if we inherit an implicit, or if we
// a function that is meant to represent this, or
// an implicit declared function?
InterfaceImplicitConversionVars.Add(
new Variable
{
Name = RuntimeUtil.GetNameOfConversionToType(interfaceType.TypeName.Name),
Closured = true,
DefinedConstant = true
}
);
}
foreach (LetDefinition field in InstanceFields)
{
freeVars.AddRange(field.Walk());
declaredVars.Add(field.DeclaredVariable);
}
foreach (FunctionDefinition constructor in Constructors)
{
freeVars.AddRange(constructor.Walk());
maxConstructorArgs = Math.Max(maxConstructorArgs, constructor.Parameters.Length);
}
TempArgumentVariables = new List <Variable>();
for (int i = 0; i < maxConstructorArgs; i++)
{
TempArgumentVariables.Add(new Variable
{
Temporary = true
});
}
foreach (FunctionDefinition method in Methods)
{
freeVars.AddRange(method.Walk());
// Closure these variables even though they aren't in the
// object's map so that they can be directly accessed
method.DeclaredVariable.Closured = true;
}
Overloads = Compiler.GenerateOverloads(Methods.ToList());
declaredVars.AddRange(Overloads.Select(o => o.variable));
declaredVars.AddRange(InterfaceImplicitConversionVars);
MemberVariables = declaredVars;
// Make sure that all of our variables end up in the closure that
// makes up our RedwoodObject
foreach (Variable member in declaredVars)
{
member.Closured = true;
}
// Treat the class as a closure that can be populated and then
// updated by all methods.
Compiler.MatchVariables(freeVars, declaredVars);
// When it comes to static methods, we don't want to match to
// our own instance variables.
foreach (FunctionDefinition method in StaticMethods)
{
freeVars.AddRange(method.Walk());
}
StaticOverloads = Compiler.GenerateOverloads(StaticMethods.ToList());
return(freeVars);
}
private static void Write(
string outputPath,
string className,
string enumType,
List <EnumData> enums,
List <FunctionData> functions,
bool includeLoadAssemblyFunction,
string initFunctionName = "")
{
string[] license = File.ReadAllLines(Path.Combine(AssemblyDirectory, "License.txt"));
StringBuilder sb = new StringBuilder(1024);
foreach (var line in license)
{
sb.Append("// ");
sb.AppendLine(line);
}
sb.AppendLine();
sb.AppendLine("#nullable disable");
sb.AppendLine();
sb.AppendLine("using System;");
sb.AppendLine("using System.Runtime.InteropServices;");
sb.AppendLine("using System.Security;");
sb.AppendLine("using System.Text;");
sb.AppendLine();
sb.AppendLine("namespace GLESDotNet");
sb.AppendLine("{");
sb.AppendLine($"\tpublic static unsafe partial class {className}");
sb.AppendLine("\t{");
foreach (var @enum in enums.OrderBy(x => x.Name))
{
string type = enumType;
string name = @enum.Name;
string value = @enum.Value;
if (value == "0xFFFFFFFFFFFFFFFFull")
{
value = "0xFFFFFFFFFFFFFFFF";
}
if (value.EndsWith("ull") || value == "0xFFFFFFFFFFFFFFFF")
{
type = "ulong";
}
else if (value.EndsWith("u") || value == "0xFFFFFFFF")
{
type = "uint";
}
if (value.StartsWith("EGL_CAST("))
{
int index = value.LastIndexOf(',') + 1;
value = value.Substring(index, value.Length - index - 1);
}
sb.AppendLine($"\t\tpublic const {type} {name} = {value};");
}
sb.AppendLine();
var orderedFunctions = functions.OrderBy(x => x.Name);
sb.AppendLine("\t\tprivate static class Delegates");
sb.AppendLine("\t\t{");
foreach (var function in orderedFunctions)
{
string returnType = GetReturnType(function.ReturnType);
string parameters = string.Join(", ", function.Params.Select(x => GetParamType(x) + " " + GetParamName(x.Name)));
sb.AppendLine($"\t\t\t[UnmanagedFunctionPointer(CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]");
sb.AppendLine($"\t\t\tpublic delegate {returnType} {function.Name}({parameters});");
sb.AppendLine();
}
sb.AppendLine("\t\t}");
sb.AppendLine();
foreach (var function in orderedFunctions)
{
sb.AppendLine($"\t\tprivate static Delegates.{function.Name} _{function.Name};");
sb.AppendLine();
}
if (includeLoadAssemblyFunction)
{
sb.AppendLine($"\t\tstatic {className}()");
sb.AppendLine("\t\t{");
sb.AppendLine("\t\t\tLoadFunctions(LoadAssembly());");
}
else
{
sb.AppendLine($"\t\tpublic static void {initFunctionName}(Func<string, IntPtr> getProcAddress)");
sb.AppendLine("\t\t{");
sb.AppendLine("\t\t\tLoadFunctions(getProcAddress);");
}
sb.AppendLine("\t\t}");
sb.AppendLine();
sb.AppendLine($"\t\tprivate static void LoadFunctions(Func<string, IntPtr> getProcAddress)");
sb.AppendLine("\t\t{");
sb.AppendLine("\t\t\tT getProc<T>(string name) => Marshal.GetDelegateForFunctionPointer<T>(getProcAddress(name));");
sb.AppendLine();
foreach (var function in orderedFunctions)
{
sb.AppendLine($"\t\t\t_{function.Name} = getProc<Delegates.{function.Name}>(\"{function.Name}\");");
}
sb.AppendLine("\t\t}");
sb.AppendLine();
foreach (var function in orderedFunctions)
{
string returnType = GetReturnType(function.ReturnType);
string parameters = string.Join(", ", function.Params.Select(x => GetParamType(x) + " " + GetParamName(x.Name)));
string parameterNames = string.Join(", ", function.Params.Select(x => GetParamName(x.Name)));
sb.AppendLine($"\t\tpublic static {returnType} {function.Name}({parameters})");
sb.AppendLine("\t\t{");
sb.Append("\t\t\t");
if (returnType != "void")
{
sb.Append("return ");
}
sb.AppendLine($"_{function.Name}({parameterNames});");
sb.AppendLine("\t\t}");
sb.AppendLine();
if (function.GenerateIntPtrOverload)
{
parameters = string.Join(", ", function.Params.Select(x => (GetParamType(x) == "void*" ? "IntPtr" : GetParamType(x)) + " " + GetParamName(x.Name)));
parameterNames = string.Join(", ", function.Params.Select(x => (GetParamType(x) == "void*" ? "(void*)" : "") + GetParamName(x.Name)));
sb.AppendLine($"\t\tpublic static {returnType} {function.Name}({parameters})");
sb.AppendLine("\t\t{");
sb.Append("\t\t\t");
if (returnType != "void")
{
sb.Append("return ");
}
sb.AppendLine($"_{function.Name}({parameterNames});");
sb.AppendLine("\t\t}");
sb.AppendLine();
}
if (function.GenerateArrayOverload)
{
parameters = string.Join(", ", function.Params.Select(x => GetParamType(x).Replace("*", "[]") + " " + GetParamName(x.Name)));
parameterNames = string.Join(", ", function.Params.Select(x => GetParamName(x.Name) + (x.UseForArrayOverload ? "Ptr" : "")));
sb.AppendLine($"\t\tpublic static {returnType} {function.Name}({parameters})");
sb.AppendLine("\t\t{");
foreach (var param in function.Params.Where(x => x.UseForArrayOverload))
{
sb.AppendLine($"\t\t\tfixed ({GetParamType(param)} {GetParamName(param.Name)}Ptr = {GetParamName(param.Name)})");
}
sb.AppendLine("\t\t\t{");
sb.Append("\t\t\t\t");
if (returnType != "void")
{
sb.Append("return ");
}
sb.AppendLine($"_{function.Name}({parameterNames});");
sb.AppendLine("\t\t\t}");
sb.AppendLine("\t\t}");
sb.AppendLine();
}
if (function.GenerateGenericOverload)
{
// T[]
parameters = string.Join(", ", function.Params.Select(x => (x.UseForGenericOverload ? "T[]" : GetParamType(x)) + " " + GetParamName(x.Name)));
parameterNames = string.Join(", ", function.Params.Select(x => GetParamName(x.Name) + (x.UseForGenericOverload ? "Ptr" : "")));
sb.AppendLine($"\t\tpublic static {returnType} {function.Name}<T>({parameters})");
sb.AppendLine("\t\t\twhere T: unmanaged");
sb.AppendLine("\t\t{");
foreach (var param in function.Params.Where(x => x.UseForGenericOverload))
{
sb.AppendLine($"\t\t\tfixed ({GetParamType(param)} {GetParamName(param.Name)}Ptr = {GetParamName(param.Name)})");
}
sb.AppendLine("\t\t\t{");
sb.Append("\t\t\t\t");
if (returnType != "void")
{
sb.Append("return ");
}
sb.AppendLine($"_{function.Name}({parameterNames});");
sb.AppendLine("\t\t\t}");
sb.AppendLine("\t\t}");
sb.AppendLine();
// ref T
parameters = string.Join(", ", function.Params.Select(x => (x.UseForGenericOverload ? "ref T" : GetParamType(x)) + " " + GetParamName(x.Name)));
parameterNames = string.Join(", ", function.Params.Select(x => GetParamName(x.Name) + (x.UseForGenericOverload ? "Ptr" : "")));
sb.AppendLine($"\t\tpublic static {returnType} {function.Name}<T>({parameters})");
sb.AppendLine("\t\t\twhere T: unmanaged");
sb.AppendLine("\t\t{");
foreach (var param in function.Params.Where(x => x.UseForGenericOverload))
{
sb.AppendLine($"\t\t\tfixed ({GetParamType(param)} {GetParamName(param.Name)}Ptr = &{GetParamName(param.Name)})");
}
sb.AppendLine("\t\t\t{");
sb.Append("\t\t\t\t");
if (returnType != "void")
{
sb.Append("return ");
}
sb.AppendLine($"_{function.Name}({parameterNames});");
sb.AppendLine("\t\t\t}");
sb.AppendLine("\t\t}");
sb.AppendLine();
}
if (function.GenerateRefOverload)
{
parameters = string.Join(", ", function.Params.Select(x => (x.UseForRefOverload ? "ref " : "") + GetParamType(x, isRefOrOutOverload: x.UseForRefOverload) + " " + GetParamName(x.Name)));
parameterNames = string.Join(", ", function.Params.Select(x => GetParamName(x.Name) + (x.UseForRefOverload ? "Ptr" : "")));
sb.AppendLine($"\t\tpublic static {returnType} {function.Name}({parameters})");
sb.AppendLine("\t\t{");
foreach (var param in function.Params.Where(x => x.UseForRefOverload))
{
sb.AppendLine($"\t\t\tfixed ({GetParamType(param)} {GetParamName(param.Name)}Ptr = &{GetParamName(param.Name)})");
}
sb.AppendLine("\t\t\t{");
sb.Append("\t\t\t\t");
if (returnType != "void")
{
sb.Append("return ");
}
sb.AppendLine($"_{function.Name}({parameterNames});");
sb.AppendLine("\t\t\t}");
sb.AppendLine("\t\t}");
sb.AppendLine();
}
if (function.GenerateOutOverload)
{
parameters = string.Join(", ", function.Params.Select(x => (x.UseForOutOverload ? "out " : "") + GetParamType(x, isRefOrOutOverload: x.UseForOutOverload) + " " + GetParamName(x.Name)));
parameterNames = string.Join(", ", function.Params.Select(x => GetParamName(x.Name) + (x.UseForOutOverload ? "Ptr" : "")));
sb.AppendLine($"\t\tpublic static {returnType} {function.Name}({parameters})");
sb.AppendLine("\t\t{");
foreach (var param in function.Params.Where(x => x.UseForOutOverload))
{
sb.AppendLine($"\t\t\tfixed ({GetParamType(param)} {GetParamName(param.Name)}Ptr = &{GetParamName(param.Name)})");
}
sb.AppendLine("\t\t\t{");
sb.Append("\t\t\t\t");
if (returnType != "void")
{
sb.Append("return ");
}
sb.AppendLine($"_{function.Name}({parameterNames});");
sb.AppendLine("\t\t\t}");
sb.AppendLine("\t\t}");
sb.AppendLine();
}
if (Overloads.ContainsKey(function.Name))
{
sb.AppendLine(Overloads[function.Name].Trim('\r', '\n'));
sb.AppendLine();
}
}
sb.AppendLine("\t}");
sb.AppendLine("}");
File.WriteAllText(Path.GetFullPath(outputPath), sb.ToString());
}
public override int GetHashCode() => base.GetHashCode() ^ Overloads.GetHashCode();
public static IEnumerable <object[]> GetOverloads() => Overloads.Select(o => new[] { (object)o });
public OptionOverloadOption(Overloads p)
{
Value = p;
}
