private bool NeedsWindowsSpecificFunction(CodeParser.Class.Function func, BaseType returnType, BaseType[] args)
        {
            if (returnType.IsReturnedWeird)
            {
                return(true);
            }
            if (returnType.WindowsSpecific)
            {
                return(true);
            }
            if (args.Any(x => x.WindowsSpecific))
            {
                return(true);
            }

            return(false);
        }
        private void WriteFunction(CodeParser.Class clss, CodeParser.Class.Function func)
        {
            var returnType = BaseType.Parse(func.ReturnType);

            returnType.Func = func.Name;

            var args = func.Arguments.Select(x =>
            {
                var bt  = BaseType.Parse(x.Value, x.Key);
                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()));

            var windowsSpecific = NeedsWindowsSpecificFunction(func, returnType, args);

            if (returnType is SteamApiCallType sap)
            {
                sap.CallResult = func.CallResult;

                argstr = string.Join(", ", args.Select(x => x.AsArgument().Replace("ref ", " /* ref */ ")));
            }

            WriteLine($"#region FunctionMeta");

            WriteLine($"[UnmanagedFunctionPointer( Platform.MemberConvention )]");

            if (returnType.ReturnAttribute != null)
            {
                WriteLine(returnType.ReturnAttribute);
            }

            if (returnType.IsReturnedWeird)
            {
                WriteLine("#if PLATFORM_WIN");
                WriteLine($"private delegate void F{func.Name}( IntPtr self, ref {returnType.TypeName} retVal, {delegateargstr} );".Replace(" retVal,  )", " retVal )"));
                WriteLine("#else");
            }

            WriteLine($"private delegate {returnType.TypeNameFrom} F{func.Name}( IntPtr self, {delegateargstr} );".Replace("( IntPtr self,  )", "( IntPtr self )"));

            if (returnType.IsReturnedWeird)
            {
                WriteLine("#endif");
            }

            WriteLine($"private F{func.Name} _{func.Name};");

            WriteLine();
            WriteLine($"#endregion");

            StartBlock($"internal {returnType.ReturnType} {func.Name}( {argstr} )".Replace("(  )", "()"));
            {
                var callargs = string.Join(", ", args.Select(x => x.AsCallArgument()));

                if (returnType.IsReturnedWeird)
                {
                    WriteLine("#if PLATFORM_WIN");
                    {
                        WriteLine($"var retVal = default( {returnType.TypeName} );");
                        WriteLine($"_{func.Name}( Self, ref retVal, {callargs} );".Replace(",  );", " );"));
                        WriteLine($"{returnType.Return( "retVal" )}");
                    }
                    WriteLine("#else");
                }

                if (returnType.IsVoid)
                {
                    WriteLine($"_{func.Name}( Self, {callargs} );".Replace("( Self,  )", "( Self )"));
                }
                else
                {
                    var v = $"_{func.Name}( Self, {callargs} )".Replace("( Self,  )", "( Self )");

                    WriteLine(returnType.Return(v));
                }

                if (returnType.IsReturnedWeird)
                {
                    WriteLine("#endif");
                }
            }
            EndBlock();
        }
Пример #3
0
        private void WriteFunction(CodeParser.Class clss, CodeParser.Class.Function func)
        {
            var returnType = BaseType.Parse(func.ReturnType);

            returnType.Func = func.Name;

            var args = func.Arguments.Select(x =>
            {
                var bt  = BaseType.Parse(x.Value, x.Key);
                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()));

            var windowsSpecific = NeedsWindowsSpecificFunction(func, returnType, args);

            if (returnType is SteamApiCallType sap)
            {
                sap.CallResult = func.CallResult;

                argstr = string.Join(", ", args.Select(x => x.AsArgument().Replace("ref ", " /* ref */ ")));
            }

            WriteLine($"#region FunctionMeta");

            WriteLine($"[UnmanagedFunctionPointer( CallingConvention.ThisCall )]");

            if (returnType.ReturnAttribute != null)
            {
                WriteLine(returnType.ReturnAttribute);
            }

            WriteLine($"private delegate {returnType.TypeNameFrom} F{func.Name}( IntPtr self, {delegateargstr} );".Replace("( IntPtr self,  )", "( IntPtr self )"));
            WriteLine($"private F{func.Name} _{func.Name};");

            if (windowsSpecific)
            {
                var delegateargstrw = string.Join(", ", args.Select(x => x.AsWinArgument()));
                WriteLine($"[UnmanagedFunctionPointer( CallingConvention.ThisCall )]");

                if (returnType.IsReturnedWeird)
                {
                    var windelargs = $"ref {returnType.TypeName} retVal, {delegateargstrw}".Trim(',', ' ');
                    WriteLine($"private delegate void F{func.Name}_Windows( IntPtr self, {windelargs} );".Replace("( IntPtr self,  )", "( IntPtr self )"));
                }
                else
                {
                    if (returnType.ReturnAttribute != null)
                    {
                        WriteLine(returnType.ReturnAttribute);
                    }


                    WriteLine($"private delegate {returnType.TypeNameFrom} F{func.Name}_Windows( IntPtr self, {delegateargstrw} );".Replace("( IntPtr self,  )", "( IntPtr self )"));
                }

                WriteLine($"private F{func.Name}_Windows _{func.Name}_Windows;");
            }

            WriteLine();
            WriteLine($"#endregion");

            StartBlock($"internal {returnType.ReturnType} {func.Name}( {argstr} )".Replace("(  )", "()"));
            {
                var callargs = string.Join(", ", args.Select(x => x.AsCallArgument()));

                if (returnType.IsReturnedWeird)
                {
                    StartBlock("if ( Config.Os == OsType.Windows )");
                    {
                        WriteLine($"var retVal = default( {returnType.TypeName} );");
                        WriteLine($"_{func.Name}_Windows( Self, ref retVal, {callargs} );".Replace(",  );", " );"));
                        WriteLine($"{returnType.Return( "retVal" )}");
                    }
                    EndBlock();
                    WriteLine();
                }
                else if (windowsSpecific)
                {
                    StartBlock("if ( Config.Os == OsType.Windows )");
                    {
                        var wincallargs = callargs;

                        foreach (var arg in args)
                        {
                            if (!arg.WindowsSpecific)
                            {
                                continue;
                            }

                            if (arg.IsVector)
                            {
                                WriteLine($"{arg.TypeName}.Pack8[] {arg.VarName}_windows = {arg.VarName};");
                            }
                            else
                            {
                                WriteLine($"{arg.TypeName}.Pack8 {arg.VarName}_windows = {arg.VarName};");
                            }

                            wincallargs = wincallargs.Replace($" {arg.VarName}", $" {arg.VarName}_windows");
                        }

                        if (!returnType.IsVoid)
                        {
                            Write("var retVal = ");
                        }

                        WriteLine($"_{func.Name}_Windows( Self, {wincallargs} );".Replace("( Self,  )", "( Self )"));

                        foreach (var arg in args)
                        {
                            if (!arg.WindowsSpecific)
                            {
                                continue;
                            }

                            WriteLine($"{arg.VarName} = {arg.VarName}_windows;");
                        }

                        if (!returnType.IsVoid)
                        {
                            WriteLine(returnType.Return("retVal"));
                        }
                    }
                    EndBlock();
                    WriteLine();
                }

                if (returnType.IsVoid)
                {
                    WriteLine($"_{func.Name}( Self, {callargs} );".Replace("( Self,  )", "( Self )"));
                }
                else
                {
                    var v = $"_{func.Name}( Self, {callargs} )".Replace("( Self,  )", "( Self )");

                    WriteLine(returnType.Return(v));
                }
            }
            EndBlock();
        }
        private void WriteFunction(CodeParser.Class clss, CodeParser.Class.Function func)
        {
            var returnType = BaseType.Parse(func.ReturnType);

            returnType.Func = func.Name;

            var args = func.Arguments.Select(x =>
            {
                var bt  = BaseType.Parse(x.Value, x.Key);
                bt.Func = func.Name;
                return(bt);
            }).ToArray();

            for (int i = 0; i < args.Length; i++)
            {
                if (args[i] is StringType)
                {
                    if (args[i + 1] is IntType || args[i + 1] is UIntType)
                    {
                        if (args[i + 1].Ref == string.Empty)
                        {
                            args[i + 1] = new ConstValueType(args[i + 1], "(1024 * 32)");
                        }
                    }
                    else
                    {
                        throw new System.Exception($"String Builder Next Type Is {args[i+1].GetType()}");
                    }
                }
            }

            var argstr         = string.Join(", ", args.Where(x => !x.ShouldSkipAsArgument).Select(x => x.AsArgument()));;
            var delegateargstr = string.Join(", ", args.Select(x => x.AsNativeArgument()));

            var windowsSpecific = NeedsWindowsSpecificFunction(func, returnType, args);

            if (returnType is SteamApiCallType sap)
            {
                sap.CallResult = func.CallResult;

                argstr = string.Join(", ", args.Select(x => x.AsArgument().Replace("ref ", " /* ref */ ")));
            }

            WriteLine($"#region FunctionMeta");

            WriteLine($"[UnmanagedFunctionPointer( Platform.MemberConvention )]");

            if (returnType.ReturnAttribute != null)
            {
                WriteLine(returnType.ReturnAttribute);
            }

            if (returnType.IsReturnedWeird)
            {
                WriteLine("#if PLATFORM_WIN");
                WriteLine($"private delegate void F{func.Name}( IntPtr self, ref {returnType.TypeName} retVal, {delegateargstr} );".Replace(" retVal,  )", " retVal )"));
                WriteLine("#else");
            }

            WriteLine($"private delegate {returnType.TypeNameFrom} F{func.Name}( IntPtr self, {delegateargstr} );".Replace("( IntPtr self,  )", "( IntPtr self )"));

            if (returnType.IsReturnedWeird)
            {
                WriteLine("#endif");
            }

            WriteLine($"private F{func.Name} _{func.Name};");

            WriteLine();
            WriteLine($"#endregion");

            StartBlock($"internal {returnType.ReturnType} {func.Name}( {argstr} )".Replace("(  )", "()"));
            {
                var callargs = string.Join(", ", args.Select(x => x.AsCallArgument()));

                //
                // Code before any calls
                //
                foreach (var arg in args)
                {
                    if (arg is StringType sb)
                    {
                        WriteLine($"IntPtr mem{sb.VarName} = Helpers.TakeMemory();");
                    }
                }

                //
                // The actual call
                //
                if (returnType.IsReturnedWeird)
                {
                    WriteLine("#if PLATFORM_WIN");
                    {
                        WriteLine($"var retVal = default( {returnType.TypeName} );");
                        WriteLine($"_{func.Name}( Self, ref retVal, {callargs} );".Replace(",  );", " );"));
                        WriteLine($"{returnType.Return( "retVal" )}");
                    }
                    WriteLine("#else");
                }

                if (returnType.IsVoid)
                {
                    WriteLine($"_{func.Name}( Self, {callargs} );".Replace("( Self,  )", "( Self )"));
                }
                else
                {
                    WriteLine($"var returnValue = _{func.Name}( Self, {callargs} );".Replace("( Self,  )", "( Self )"));
                }

                //
                // Code after the call
                //
                foreach (var arg in args)
                {
                    if (arg is StringType sb)
                    {
                        WriteLine($"{sb.VarName} = Helpers.MemoryToString( mem{sb.VarName} );");
                    }
                }

                //
                // Return
                //
                if (!returnType.IsVoid)
                {
                    WriteLine(returnType.Return("returnValue"));
                }

                if (returnType.IsReturnedWeird)
                {
                    WriteLine("#endif");
                }
            }
            EndBlock();
        }