Facepunch.Steamworks/Generator/CodeWriter.PlatformClass.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Generator
{
    public partial class CodeWriter
    {
        bool LargePack;

        private void PlatformClass( string type, string libraryName, bool LargePack )
        {
            this.LargePack = LargePack;

            StartBlock( $"internal static partial class Platform" );
            {
                StartBlock( $"public class {type} : Interface" );
                {
                    WriteLine( "internal IntPtr _ptr;" );
                    WriteLine( "public bool IsValid { get{ return _ptr != null; } }" );
                    WriteLine();

                    WriteLine( "//" );
                    WriteLine( "// Constructor sets pointer to native class" );
                    WriteLine( "//" );
                    StartBlock( $"public {type}( IntPtr pointer )" );
                    {
                        WriteLine( "_ptr = pointer;" );
                    }
                    EndBlock();

                    WriteLine( "//" );
                    WriteLine( "// When shutting down clear all the internals to avoid accidental use" );
                    WriteLine( "//" );
                    StartBlock( $"public virtual void Dispose()" );
                    {
                        WriteLine( "_ptr = IntPtr.Zero;" );
                    }
                    EndBlock();
                    WriteLine();

                    foreach ( var c in def.methods.GroupBy( x => x.ClassName ) )
                    {
                        PlatformClass( c.Key, c.ToArray() );
                    }

                    StartBlock( $"internal static unsafe class Native" );
                    {
                        foreach ( var c in def.methods.GroupBy( x => x.ClassName ) )
                        {
                            InteropClass( libraryName, c.Key, c.ToArray() );
                        }
                    }
                    EndBlock();
                }
                EndBlock();
            }
            EndBlock();
        }

        private void PlatformClass( string className, SteamApiDefinition.MethodDef[] methodDef )
        {
            if ( ShouldIgnoreClass( className ) ) return;

            LastMethodName = "";
            foreach ( var m in methodDef )
            {
                PlatformClassMethod( className, m );
            }

            WriteLine();
        }





        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})" );

            if ( methodDef.NeedsSelfPointer )
            {
                WriteLine( $"if ( _ptr == null ) 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.{classname}.{methodName}({argstring});" );

            WriteLines( AfterLines );

            if ( retcode.StartsWith( "var" ) )
            {
                WriteLine( "return ret;" );
            }

            EndBlock();

            

            LastMethodName = methodDef.Name;
        }

        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} ";

            WriteLine( $"[DllImportAttribute( \"{library}\", EntryPoint = \"{flatName}\" )]" );

            if ( ret.Return() == "bool" ) WriteLine( "[return: MarshalAs(UnmanagedType.U1)]" );

            WriteLine( $"internal static extern {ret.Return()} {methodName}({argstring});" );
            LastMethodName = methodDef.Name;
        }

        private void InteropClass( string libraryName, string className, SteamApiDefinition.MethodDef[] methodDef )
        {
            if ( ShouldIgnoreClass( className ) ) return;

            StartBlock( $"internal static unsafe class {className}" );

            LastMethodName = "";
            foreach ( var m in methodDef )
            {
                InteropClassMethod( libraryName, className, m );
            }

            EndBlock();

            WriteLine();
        }


    }
}