private void PlatformInterfaceMethod(SteamApiDefinition.MethodDef m)
{
var arguments = BuildArguments(m.Params);
var ret = new Argument("return", m.ReturnType, TypeDefs);
var methodName = m.Name;
if (LastMethodName == methodName)
{
methodName = methodName + "0";
}
var flatName = $"SteamAPI_{m.ClassName}_{methodName}";
if (m.ClassName == "SteamApi")
{
flatName = methodName;
}
var argstring = string.Join(", ", arguments.Select(x => x.InteropParameter(true, true)));
if (argstring != "")
{
argstring = $" {argstring} ";
}
WriteLine($"{ret.Return()} {m.ClassName}_{methodName}({argstring});");
LastMethodName = m.Name;
}
private void CallPlatformClass(string classname, SteamApiDefinition.MethodDef m, List <string> argList, string returnVar)
{
if (classname == null)
{
classname = "SteamApi";
}
var methodName = m.Name;
if (LastMethodName == methodName)
{
methodName += "0";
}
var args = string.Join(", ", argList);
if (args != "")
{
args = $" {args} ";
}
var r = "";
if (ReturnType != "void")
{
r = "return ";
}
if (returnVar != "")
{
r = returnVar + " = ";
}
BeforeLines.Add($"{r}platform.{classname}_{methodName}({args});");
}
private void WriteMarshalledFunction(SteamApiDefinition.MethodDef func)
{
var returnType = BaseType.Parse(func.ReturnType);
returnType.Func = func.Name;
if (func.Params == null)
{
func.Params = new SteamApiDefinition.MethodDef.ParamType[0];
}
var args = func.Params.Select(x =>
{
var bt = BaseType.Parse(x.Type, x.Name);
bt.Func = func.Name;
return(bt);
}).ToArray();
var argstr = string.Join(", ", args.Select(x => x.AsArgument()));
var delegateargstr = string.Join(", ", args.Select(x => x.AsArgument()));
WriteLine($"[DllImport( Platform.LibraryName, EntryPoint = \"{func.Name}\", CallingConvention = CallingConvention.Cdecl )]");
if (returnType.ReturnAttribute != null)
{
WriteLine(returnType.ReturnAttribute);
}
WriteLine($"public static extern {(returnType.IsReturnedWeird ? "void" : returnType.TypeNameFrom)} {func.Name}( {delegateargstr} );");
WriteLine();
}
private void ClassMethod(string classname, SteamApiDefinition.MethodDef m)
{
var argList = BuildArguments(m.Params);
var callargs = BuildArguments(m.Params);
BeforeLines = new List <string>();
AfterLines = new List <string>();
ReturnType = ToManagedType(m.ReturnType);
ReturnVar = "";
MethodDef = m;
ClassName = classname;
var statc = classname == null ? " static" : "";
Detect_VectorReturn(argList, callargs);
Detect_InterfaceReturn(argList, callargs);
Detect_StringFetch(argList, callargs);
Detect_StringReturn(argList, callargs);
Detect_MatchmakingFilters(argList, callargs);
Detect_ReturningStruct();
Detect_IntPtrArgs(argList, callargs);
Detect_MultiSizeArrayReturn(argList, callargs);
Detect_StringArray(argList, callargs);
Detect_CallResult(argList, callargs);
var methodName = m.Name;
if (LastMethodName == methodName)
{
methodName += MethodNameCount.ToString();
MethodNameCount++;
}
else
{
MethodNameCount = 0;
}
var argString = string.Join(", ", argList.Select(x => x.ManagedParameter()));
if (argString != "")
{
argString = " " + argString + " ";
}
StartBlock($"public{statc} {ReturnType} {methodName}({argString})");
CallPlatformClass(classname, m, callargs.Select(x => x.InteropVariable(true)).ToList(), ReturnVar);
WriteLines(BeforeLines);
WriteLines(AfterLines);
EndBlock();
WriteLine();
LastMethodName = m.Name;
}
private void WriteGlobalFunction(string cname, SteamApiDefinition.MethodDef func)
{
var cleanName = func.Name.Substring(cname.Length).Trim('_');
var returnType = BaseType.Parse(func.ReturnType);
returnType.Func = func.Name;
if (func.Params == null)
{
func.Params = new SteamApiDefinition.MethodDef.ParamType[0];
}
var args = func.Params.Select(x =>
{
var bt = BaseType.Parse(x.Type, x.Name);
bt.Func = func.Name;
return(bt);
}).ToArray();
var argstr = string.Join(", ", args.Select(x => x.AsArgument()));
var delegateargstr = string.Join(", ", args.Select(x => x.AsArgument()));
if (returnType.IsReturnedWeird)
{
throw new System.Exception("TODO");
}
StartBlock($"static internal {returnType.ReturnType} {cleanName}( {argstr} )");
{
var callargs = string.Join(", ", args.Select(x => x.AsCallArgument()));
if (returnType.IsReturnedWeird)
{
WriteLine($"var retVal = default( {returnType.TypeName} );");
WriteLine($"Native.{func.Name}( ref retVal, {callargs} );");
WriteLine($"{returnType.Return( "retVal" )}");
}
else if (returnType.IsVoid)
{
WriteLine($"Native.{func.Name}( {callargs} );");
}
else
{
var v = $"Native.{func.Name}( {callargs} )";
WriteLine(returnType.Return(v));
}
}
EndBlock();
}
private void InteropClassMethod(string library, string classname, SteamApiDefinition.MethodDef methodDef)
{
var arguments = BuildArguments(methodDef.Params);
var ret = new Argument("return", methodDef.ReturnType, TypeDefs);
var methodName = methodDef.Name;
if (LastMethodName == methodName)
{
methodName = methodName + "0";
}
var flatName = $"SteamAPI_{classname}_{methodName}";
if (classname == "SteamApi")
{
flatName = methodName;
}
var argstring = string.Join(", ", arguments.Select(x => x.InteropParameter(LargePack, true)));
if (methodDef.NeedsSelfPointer)
{
argstring = "IntPtr " + classname + (argstring.Length > 0 ? ", " : "") + argstring;
}
if (argstring != "")
{
argstring = $" {argstring} ";
}
if (X86)
{
Write($"[DllImport( \"{library}\", CallingConvention = CallingConvention.Cdecl )] ");
}
else
{
Write($"[DllImport( \"{library}\" )] ");
}
if (ret.Return() == "bool")
{
WriteLine("[return: MarshalAs(UnmanagedType.U1)]");
}
WriteLine($"internal static extern {ret.Return()} {flatName}({argstring});");
LastMethodName = methodDef.Name;
}
private void PlatformClassMethod(string classname, SteamApiDefinition.MethodDef methodDef)
{
var arguments = BuildArguments(methodDef.Params);
var ret = new Argument("return", methodDef.ReturnType, TypeDefs);
var methodName = methodDef.Name;
if (LastMethodName == methodName)
{
methodName = methodName + "0";
}
var flatName = $"SteamAPI_{classname}_{methodName}";
if (classname == "SteamApi")
{
flatName = methodName;
}
var argstring = string.Join(", ", arguments.Select(x => x.InteropParameter(true, true)));
if (argstring != "")
{
argstring = $" {argstring} ";
}
StartBlock($"public virtual {ret.Return()} {classname}_{methodName}({argstring})");
{
// var vars = string.Join( " + \",\" + ", arguments.Where( x => !x.InteropParameter( true, true ).StartsWith( "out " ) ).Select( x => x.Name ) );
// if ( vars != "" ) vars = "\" + " + vars + " + \"";
// WriteLine( $"Console.WriteLine( \"{classname}_{methodName}( {vars} )\" );" );
if (methodDef.NeedsSelfPointer)
{
WriteLine($"if ( _ptr == IntPtr.Zero ) throw new System.Exception( \"{classname} _ptr is null!\" );");
WriteLine();
}
var retcode = "";
if (ret.NativeType != "void")
{
retcode = "return ";
}
AfterLines = new List <string>();
foreach (var a in arguments)
{
if (a.InteropParameter(LargePack).Contains(".PackSmall"))
{
WriteLine($"var {a.Name}_ps = new {a.ManagedType.Trim( '*' )}.PackSmall();");
AfterLines.Add($"{a.Name} = {a.Name}_ps;");
a.Name = "ref " + a.Name + "_ps";
if (retcode != "")
{
retcode = "var ret = ";
}
}
}
argstring = string.Join(", ", arguments.Select(x => x.InteropVariable(false)));
if (methodDef.NeedsSelfPointer)
{
argstring = "_ptr" + (argstring.Length > 0 ? ", " : "") + argstring;
}
WriteLine($"{retcode}Native.{flatName}({argstring});");
WriteLines(AfterLines);
if (retcode.StartsWith("var"))
{
WriteLine("return ret;");
}
}
EndBlock();
LastMethodName = methodDef.Name;
}
