private void Constants() { StartBlock("internal static class Defines"); foreach (var o in def.Consts) { var type = o.Type; type = Cleanup.ConvertType(type); var val = o.Val; // Don't need to ull in c# if (val.EndsWith("ull")) { val = val.Replace("ull", ""); } val = val.Replace("uint32", "uint"); val = val.Replace("16U", "16"); val = val.Replace("8U", "8"); // we're not an actual typedef so can't cast like this val = val.Replace("( SteamItemInstanceID_t ) ~ 0", "~default(ulong)"); // This is defined as 0xffffffff - which is too big for an int // It seems like the loop around is required, so we just hard code it if (o.Name == "HSERVERQUERY_INVALID" && val == "0xffffffff") { val = "-1"; } WriteLine($"internal static readonly {type} {o.Name} = {val};"); } EndBlock(); }
internal Function AddFunction(string funcName, string returnType, string args) { if (funcName == "Init") { funcName = "DoInit"; } if (funcName == "Shutdown") { funcName = "DoShutdown"; } var f = new Function { Name = funcName, ReturnType = returnType }; args = Regex.Replace(args, "", ""); foreach (var arg in args.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)) { var m = Regex.Match(arg.Trim(), @"(.+?[ |\*|\&])?([a-zA-Z0-9_]+?)( = (.+?))?$"); var t = m.Groups[1].Value.Trim(); var n = m.Groups[2].Value.Trim(); t = Cleanup.ConvertType(t); f.Arguments.Add(n, t); } Functions.Add(f); return(f); }
private void Types() { foreach (var o in def.typedefs.Where(x => !x.Name.Contains("::"))) { var typeName = Cleanup.ConvertType(o.Name); if (!Cleanup.ShouldCreate(typeName)) { continue; } if (SkipTypes.Contains(o.Name)) { continue; } if (SkipTypesStartingWith.Any(x => o.Name.StartsWith(x))) { continue; } StartBlock($"{Cleanup.Expose( typeName )} struct {typeName}"); { WriteLine($"public {ToManagedType( o.Type )} Value;"); WriteLine(); WriteLine($"public static implicit operator {typeName}( {ToManagedType( o.Type )} value ) => new {typeName}(){{ Value = value }};"); WriteLine($"public static implicit operator {ToManagedType( o.Type )}( {typeName} value ) => value.Value;"); WriteLine($"public override string ToString() => Value.ToString();"); } EndBlock(); WriteLine(); } }
public bool IsEnum(string name) { if (def.enums.Any(x => x.Name == name || Cleanup.ConvertType(x.Name) == name)) { return(true); } return(false); }
public bool IsCallback(string name) { if (def.callback_structs.Any(x => x.Name == name || Cleanup.ConvertType(x.Name) == name)) { return(true); } return(false); }
public bool IsTypeDef(string name) { if (def.typedefs.Any(x => x.Name == name || Cleanup.ConvertType(x.Name) == name)) { return(true); } return(false); }
private void Types() { foreach (var o in def.typedefs.Where(x => !x.Name.Contains("::"))) { var typeName = Cleanup.ConvertType(o.Name); if (!Cleanup.ShouldCreate(typeName)) { continue; } if (SkipTypes.Contains(o.Name)) { continue; } if (SkipTypesStartingWith.Any(x => o.Name.StartsWith(x))) { continue; } StartBlock($"{Cleanup.Expose( typeName )} struct {typeName} : IEquatable<{typeName}>, IComparable<{typeName}>"); { WriteLine($"public {ToManagedType( o.Type )} Value;"); WriteLine(); WriteLine($"public static implicit operator {typeName}( {ToManagedType( o.Type )} value ) => new {typeName}(){{ Value = value }};"); WriteLine($"public static implicit operator {ToManagedType( o.Type )}( {typeName} value ) => value.Value;"); WriteLine($"public override string ToString() => Value.ToString();"); WriteLine($"public override int GetHashCode() => Value.GetHashCode();"); WriteLine($"public override bool Equals( object p ) => this.Equals( ({typeName}) p );"); WriteLine($"public bool Equals( {typeName} p ) => p.Value == Value;"); WriteLine($"public static bool operator ==( {typeName} a, {typeName} b ) => a.Equals( b );"); WriteLine($"public static bool operator !=( {typeName} a, {typeName} b ) => !a.Equals( b );"); if (ToManagedType(o.Type) == "IntPtr") { WriteLine($"public int CompareTo( {typeName} other ) => Value.ToInt64().CompareTo( other.Value.ToInt64() );"); } else { WriteLine($"public int CompareTo( {typeName} other ) => Value.CompareTo( other.Value );"); } } EndBlock(); WriteLine(); } }
void Structs() { foreach (var c in def.structs) { var name = Cleanup.ConvertType(c.Name); if (!Cleanup.ShouldCreate(name)) { continue; } if (name.Contains("::")) { continue; } var partial = ""; if (c.Methods != null) { partial = " partial"; } // // Main struct // WriteLine($"[StructLayout( LayoutKind.Sequential, Pack = Platform.{(c.IsPack4OnWindows?"StructPackSize": "StructPlatformPackSize")} )]"); StartBlock($"{Cleanup.Expose( name )}{partial} struct {name}"); { // // The fields // StructFields(c.Fields); WriteLine(); if (c.Enums != null) { foreach (var e in c.Enums) { WriteEnum(e, e.Name); } } } EndBlock(); WriteLine(); } }
private void Enums() { foreach (var o in def.enums) { WriteLine($"//"); WriteLine($"// {o.Name}"); WriteLine($"//"); var name = o.Name; // We're not interested in namespacing if (name.Contains("::")) { name = o.Name.Substring(o.Name.LastIndexOf(":") + 1); } // Skip the E if (name[0] == 'E') { name = name.Substring(1); } name = Cleanup.ConvertType(name); if (!Cleanup.ShouldCreate(name)) { continue; } var lowest = o.Values.Min(x => long.Parse(x.Value)); var highest = o.Values.Max(x => long.Parse(x.Value)); var t = "int"; if (highest > int.MaxValue) { t = "uint"; } WriteEnum(o, name, t); } }
void CustomEnums() { StartBlock("public enum CallbackType"); foreach (var c in def.callback_structs.OrderBy(x => x.CallbackId)) { if (Cleanup.IsDeprecated(c.Name)) { Write("// "); } WriteLine($"{c.Name.Replace( "_t", "" ) } = {c.CallbackId},"); } EndBlock(); int last = -1; StartBlock("internal static partial class CallbackTypeFactory"); StartBlock("internal static System.Collections.Generic.Dictionary<CallbackType, System.Type> All = new System.Collections.Generic.Dictionary<CallbackType, System.Type>"); foreach (var c in def.callback_structs.OrderBy(x => x.CallbackId)) { if (Cleanup.IsDeprecated(c.Name)) { continue; } if (last == c.CallbackId) { Write("// "); } WriteLine($"{{ CallbackType.{c.Name.Replace( "_t", "" ) }, typeof( {Cleanup.ConvertType(c.Name)} )}},"); last = c.CallbackId; } EndBlock(";"); EndBlock(); }
void Structs() { var callbackList = new List <SteamApiDefinition.StructDef>(); foreach (var c in def.structs) { var name = Cleanup.ConvertType(c.Name); if (SkipStructs.Contains(c.Name)) { continue; } if (!Cleanup.ShouldCreate(name)) { continue; } if (name.Contains("::")) { continue; } int defaultPack = c.IsPack4OnWindows ? 4 : 8; var isCallback = !string.IsNullOrEmpty(c.CallbackId); // // Main struct // WriteLine("[StructLayout( LayoutKind.Sequential, Pack = 4 )]"); StartBlock($"{Cleanup.Expose( name )} struct {name}"); { // // The fields // StructFields(c.Fields); WriteLine(); if (isCallback) { WriteLine("#region SteamCallback"); { if (defaultPack == 4) { WriteLine($"internal static readonly int StructSize = System.Runtime.InteropServices.Marshal.SizeOf( typeof({name}) );"); WriteLine($"internal static {name} Fill( IntPtr p ) => (({name})({name}) Marshal.PtrToStructure( p, typeof({name}) ) );"); } else { WriteLine($"internal static readonly int StructSize = System.Runtime.InteropServices.Marshal.SizeOf( Config.PackSmall ? typeof({name}) : typeof(Pack8) );"); WriteLine($"internal static {name} Fill( IntPtr p ) => Config.PackSmall ? (({name})({name}) Marshal.PtrToStructure( p, typeof({name}) )) : (({name})(Pack8) Marshal.PtrToStructure( p, typeof(Pack8) ));"); } WriteLine(); WriteLine($"static Action<{name}> actionClient;"); WriteLine($"[MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) );"); WriteLine($"static Action<{name}> actionServer;"); WriteLine($"[MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) );"); StartBlock($"public static void Install( Action<{name}> action, bool server = false )"); { StartBlock("if ( server )"); { WriteLine($"Event.Register( OnServer, StructSize, {c.CallbackId}, true );"); WriteLine($"actionServer = action;"); } Else(); { WriteLine($"Event.Register( OnClient, StructSize, {c.CallbackId}, false );"); WriteLine($"actionClient = action;"); } EndBlock(); } EndBlock(); StartBlock($"public static async Task<{name}?> GetResultAsync( SteamAPICall_t handle )"); { WriteLine($"bool failed = false;"); WriteLine(); StartBlock($"while ( !SteamUtils.IsCallComplete( handle, out failed ) )"); { WriteLine($"await Task.Delay( 1 );"); } EndBlock(); WriteLine($"if ( failed ) return null;"); WriteLine($""); WriteLine($"var ptr = Marshal.AllocHGlobal( StructSize );"); WriteLine($""); WriteLine($"try"); WriteLine($"{{"); WriteLine($" if ( !SteamUtils.Internal.GetAPICallResult( handle, ptr, StructSize, {c.CallbackId}, ref failed ) || failed )"); WriteLine($" return null;"); WriteLine($""); WriteLine($" return Fill( ptr );"); WriteLine($"}}"); WriteLine($"finally"); WriteLine($"{{"); WriteLine($" Marshal.FreeHGlobal( ptr );"); WriteLine($"}}"); } EndBlock(); } WriteLine("#endregion"); } else { WriteLine("#region Marshalling"); { if (defaultPack == 4) { //WriteLine( $"internal static int GetStructSize() => System.Runtime.InteropServices.Marshal.SizeOf( typeof({name}) );" ); WriteLine($"internal static {name} Fill( IntPtr p ) => (({name})({name}) Marshal.PtrToStructure( p, typeof({name}) ) );"); } else { //WriteLine( $"internal static int GetStructSize() => System.Runtime.InteropServices.Marshal.SizeOf( Config.PackSmall ? typeof({name}) : typeof(Pack8) );" ); WriteLine($"internal static {name} Fill( IntPtr p ) => Config.PackSmall ? (({name})({name}) Marshal.PtrToStructure( p, typeof({name}) )) : (({name})(Pack8) Marshal.PtrToStructure( p, typeof(Pack8) ));"); } } WriteLine("#endregion"); } if (defaultPack != 4) { WriteLine("#region Packed Versions"); { // // Windows Packed version // WriteLine(); WriteLine($"[StructLayout( LayoutKind.Sequential, Pack = {defaultPack} )]"); StartBlock($"public struct Pack8"); { StructFields(c.Fields); // // Implicit convert from PackSmall to regular // WriteLine(); Write($"public static implicit operator {name} ( {name}.Pack8 d ) => "); { Write($"new {name}{{ "); { foreach (var f in c.Fields) { Write($"{CleanMemberName( f.Name )} = d.{CleanMemberName( f.Name )},"); } } WriteLine(" };"); } Write($"public static implicit operator {name}.Pack8 ( {name} d ) => "); { Write($"new {name}.Pack8{{ "); { foreach (var f in c.Fields) { Write($"{CleanMemberName( f.Name )} = d.{CleanMemberName( f.Name )},"); } } WriteLine(" };"); } } EndBlock(); } WriteLine("#endregion"); } if (!string.IsNullOrEmpty(c.CallbackId)) { callbackList.Add(c); } } EndBlock(); WriteLine(); } }
private void StructFields(SteamApiDefinition.StructDef.StructFields[] fields) { foreach (var m in fields) { var t = ToManagedType(m.Type); t = Cleanup.ConvertType(t); if (TypeDefs.ContainsKey(t)) { t = TypeDefs[t].ManagedType; } if (t == "bool") { WriteLine("[MarshalAs(UnmanagedType.I1)]"); } if (t.StartsWith("char ") && t.Contains("[")) { var num = t.Replace("char", "").Trim('[', ']', ' '); t = "string"; WriteLine($"[MarshalAs(UnmanagedType.ByValTStr, SizeConst = {num})]"); } if (t.StartsWith("uint8 ") && t.Contains("[")) { var num = t.Replace("uint8", "").Trim('[', ']', ' '); t = "byte[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num})] // {m.Name}"); } if (t.StartsWith("SteamId") && t.Contains("[")) { var num = t.Replace("SteamId", "").Trim('[', ']', ' '); t = $"ulong[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num}, ArraySubType = UnmanagedType.U8)]"); } if (t.StartsWith("PublishedFileId ") && t.Contains("[")) { var num = t.Replace("PublishedFileId", "").Trim('[', ']', ' '); t = $"PublishedFileId[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num}, ArraySubType = UnmanagedType.U8)]"); } if (t.StartsWith("uint32 ") && t.Contains("[")) { var num = t.Replace("uint32", "").Trim('[', ']', ' '); t = $"uint[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num}, ArraySubType = UnmanagedType.U4)]"); } if (t.StartsWith("float ") && t.Contains("[")) { var num = t.Replace("float", "").Trim('[', ']', ' '); t = $"float[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num}, ArraySubType = UnmanagedType.R4)]"); } if (t == "const char **") { t = "IntPtr"; } if (t.StartsWith("AppId ") && t.Contains("[")) { var num = t.Replace("AppId", "").Trim('[', ']', ' '); t = $"AppId[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num}, ArraySubType = UnmanagedType.U4)]"); } WriteLine($"internal {t} {CleanMemberName( m.Name )}; // {m.Name} {m.Type}"); } }
public static BaseType Parse(string type, string varname = null, string callresult = null) { type = Cleanup.ConvertType(type); if (varname == "ppOutMessages") { return new PointerType { NativeType = "void *", VarName = varname } } ; if (type == "SteamAPIWarningMessageHook_t") { return new PointerType { NativeType = type, VarName = varname } } ; if (type == "SteamAPICall_t") { return new SteamApiCallType { NativeType = type, VarName = varname, CallResult = callresult } } ; if (type == "void") { return new VoidType { NativeType = type, VarName = varname } } ; if (type.Replace(" ", "").StartsWith("constchar*")) { return new ConstCharType { NativeType = type, VarName = varname } } ; if (type == "char *") { return new FetchStringType { NativeType = type, VarName = varname } } ; var basicType = type.Replace("const ", "").Trim(' ', '*', '&'); if (basicType == "void") { return new PointerType { NativeType = type, VarName = varname } } ; if (basicType.StartsWith("ISteam")) { return new PointerType { NativeType = type, VarName = varname } } ; if (basicType == "const void") { return new PointerType { NativeType = type, VarName = varname } } ; if (basicType == "int32" || basicType == "int") { return new IntType { NativeType = type, VarName = varname } } ; if (basicType == "uint") { return new UIntType { NativeType = type, VarName = varname } } ; if (basicType == "uint8") { return new UInt8Type { NativeType = type, VarName = varname } } ; if (basicType == "uint16") { return new UInt16Type { NativeType = type, VarName = varname } } ; if (basicType == "unsigned short") { return new UInt16Type { NativeType = type, VarName = varname } } ; // DANGER DANGER Danger if (basicType == "intptr_t") { return new PointerType { NativeType = type, VarName = varname } } ; if (basicType == "size_t") { return new UIntPtrType { NativeType = type, VarName = varname } } ; if (basicType == "uint64") { return new ULongType { NativeType = type, VarName = varname } } ; if (basicType == "int64") { return new LongType { NativeType = type, VarName = varname } } ; if (basicType == "bool") { return new BoolType { NativeType = type, VarName = varname } } ; // // Enum types are handled in a generic way, but we do need to clean up the name // if (Generator.CodeWriter.Current.IsEnum(basicType)) { return(new BaseType { NativeType = Cleanup.CleanEnum(type), VarName = varname }); } // // Structs are generally sent as plain old data, but need marshalling if they're expected as a pointer // if (Generator.CodeWriter.Current.IsStruct(basicType)) { return(new StructType { NativeType = type, VarName = varname, StructName = basicType }); } // // c# doesn't really have typerdefs, so we convert things like HSteamUser into structs // which from a memory point of view behave in the same way. // if (Generator.CodeWriter.Current.IsTypeDef(basicType)) { return(new StructType { NativeType = type, VarName = varname, StructName = basicType }); } return(new BaseType { NativeType = type, VarName = varname }); }
void Callbacks() { var callbackList = new List <SteamApiDefinition.StructDef>(); foreach (var c in def.callback_structs) { var name = Cleanup.ConvertType(c.Name); if (!Cleanup.ShouldCreate(name)) { continue; } if (name.Contains("::")) { continue; } var partial = ""; if (c.Methods != null) { partial = " partial"; } int defaultPack = c.IsPack4OnWindows ? 4 : 8; var isCallback = true; var iface = ""; if (isCallback) { iface = " : ICallbackData"; } // // Main struct // WriteLine($"[StructLayout( LayoutKind.Sequential, Pack = Platform.{(c.IsPack4OnWindows?"StructPackSize": "StructPlatformPackSize")} )]"); StartBlock($"{Cleanup.Expose( name )}{partial} struct {name}{iface}"); { // // The fields // StructFields(c.Fields); WriteLine(); if (isCallback) { WriteLine("#region SteamCallback"); { WriteLine($"public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof({name}) );"); WriteLine($"public int DataSize => _datasize;"); WriteLine($"public CallbackType CallbackType => CallbackType.{name.Replace( "_t", "" )};"); } WriteLine("#endregion"); } if (c.Enums != null) { foreach (var e in c.Enums) { WriteEnum(e, e.Name); } } // if ( c.CallbackId ) ) { callbackList.Add(c); } } EndBlock(); WriteLine(); } }
private void StructFields(SteamApiDefinition.StructDef.StructFields[] fields) { foreach (var m in fields) { var t = ToManagedType(m.Type); t = Cleanup.ConvertType(t); if (TypeDefs.ContainsKey(t)) { t = TypeDefs[t].ManagedType; } if (t == "bool") { WriteLine("[MarshalAs(UnmanagedType.I1)]"); } if (t.StartsWith("char ") && t.Contains("[")) { WriteLine($"internal string {CleanMemberName( m.Name )}UTF8() => System.Text.Encoding.UTF8.GetString( {CleanMemberName( m.Name )}, 0, System.Array.IndexOf<byte>( {CleanMemberName( m.Name )}, 0 ) );"); var num = t.Replace("char", "").Trim('[', ']', ' '); t = "byte[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num})] // {t} {m.Name}"); } if (t.StartsWith("uint8 ") && t.Contains("[")) { var num = t.Replace("uint8", "").Trim('[', ']', ' '); t = "byte[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num})] // {m.Name}"); } if (t.StartsWith("ushort ") && t.Contains("[")) { var num = t.Replace("ushort", "").Trim('[', ']', ' '); t = $"ushort[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num}, ArraySubType = UnmanagedType.U2)]"); } if (t.StartsWith("SteamId") && t.Contains("[")) { var num = t.Replace("SteamId", "").Trim('[', ']', ' '); t = $"ulong[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num}, ArraySubType = UnmanagedType.U8)]"); } if (t.StartsWith("PublishedFileId ") && t.Contains("[")) { var num = t.Replace("PublishedFileId", "").Trim('[', ']', ' '); t = $"PublishedFileId[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num}, ArraySubType = UnmanagedType.U8)]"); } if (t.StartsWith("uint32 ") && t.Contains("[")) { var num = t.Replace("uint32", "").Trim('[', ']', ' '); t = $"uint[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num}, ArraySubType = UnmanagedType.U4)]"); } if (t.StartsWith("uint ") && t.Contains("[")) { var num = t.Replace("uint", "").Trim('[', ']', ' '); t = $"uint[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num}, ArraySubType = UnmanagedType.U4)]"); } if (t.StartsWith("float ") && t.Contains("[")) { var num = t.Replace("float", "").Trim('[', ']', ' '); t = $"float[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num}, ArraySubType = UnmanagedType.R4)]"); } if (t == "const char **") { t = "IntPtr"; } if (t.StartsWith("AppId ") && t.Contains("[")) { var num = t.Replace("AppId", "").Trim('[', ']', ' '); t = $"AppId[]"; WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num}, ArraySubType = UnmanagedType.U4)]"); } if (t == "SteamInputActionEvent_t.AnalogAction_t") { Write("// "); } WriteLine($"internal {t} {CleanMemberName( m.Name )}; // {m.Name} {m.Type}"); } }
private string ToManagedType(string type) { type = type.Replace("ISteamHTMLSurface::", ""); type = type.Replace("class ", ""); type = type.Replace("struct ", ""); type = type.Replace("const void", "void"); type = type.Replace("union ", ""); type = type.Replace("enum ", ""); type = Cleanup.ConvertType(type); switch (type) { case "uint64": return("ulong"); case "uint32": return("uint"); case "int32": return("int"); case "int32_t": return("int"); case "int64": return("long"); case "int64_t": return("long"); case "void *": return("IntPtr"); case "uint8 *": return("IntPtr"); case "int16": return("short"); case "uint8": return("byte"); case "int8": return("char"); case "unsigned short": return("ushort"); case "unsigned int": return("uint"); case "uint16": return("ushort"); case "const char *": return("string"); case "_Bool": return("bool"); case "SteamId": return("ulong"); case "SteamAPIWarningMessageHook_t": return("IntPtr"); } //type = type.Trim( '*', ' ' ); // Enums - skip the 'E' if (type[0] == 'E') { return(type.Substring(1)); } if (type.StartsWith("ISteamMatchmak") && type.Contains("Response")) { return("IntPtr"); } return(type); }
public static BaseType Parse(string type, string varname = null) { type = Cleanup.ConvertType(type); if (type == "SteamAPIWarningMessageHook_t") { return new PointerType { NativeType = type, VarName = varname } } ; if (type == "SteamAPICall_t") { return new SteamApiCallType { NativeType = type, VarName = varname } } ; if (type == "void") { return new VoidType { NativeType = type, VarName = varname } } ; if (type.Replace(" ", "").StartsWith("constchar*")) { return new ConstCharType { NativeType = type, VarName = varname } } ; if (type == "char *") { return new StringBuilderType { NativeType = type, VarName = varname } } ; var basicType = type.Replace("const ", "").Trim(' ', '*', '&'); if (basicType == "void") { return new PointerType { NativeType = type, VarName = varname } } ; if (basicType.StartsWith("ISteam")) { return new PointerType { NativeType = type, VarName = varname } } ; if (basicType == "const void") { return new PointerType { NativeType = type, VarName = varname } } ; if (basicType == "int32" || basicType == "int") { return new IntType { NativeType = type, VarName = varname } } ; if (basicType == "uint32") { return new UIntType { NativeType = type, VarName = varname } } ; if (basicType == "uint8") { return new UInt8Type { NativeType = type, VarName = varname } } ; if (basicType == "uint16") { return new UInt16Type { NativeType = type, VarName = varname } } ; if (basicType == "SteamId") { return new CSteamIdType { NativeType = type, VarName = varname } } ; // DANGER DANGER Danger if (basicType == "size_t") { return new ULongType { NativeType = type, VarName = varname } } ; if (basicType == "intptr_t") { return new LongType { NativeType = type, VarName = varname } } ; if (basicType == "ptrdiff_t") { return new LongType { NativeType = type, VarName = varname } } ; if (basicType == "uint64") { return new ULongType { NativeType = type, VarName = varname } } ; if (basicType == "int64") { return new LongType { NativeType = type, VarName = varname } } ; if (basicType == "bool") { return new BoolType { NativeType = type, VarName = varname } } ; if (basicType.EndsWith("_t")) { return new StructType { NativeType = type, VarName = varname, StructName = basicType } } ; if (basicType == "InventoryItemId") { return new StructType { NativeType = type, VarName = varname, StructName = basicType } } ; if (basicType == "InventoryDefId") { return new StructType { NativeType = type, VarName = varname, StructName = basicType } } ; if (basicType == "PingLocation") { return new StructType { NativeType = type, VarName = varname, StructName = basicType } } ; if (basicType == "NetworkIdentity") { return new StructType { NativeType = type, VarName = varname, StructName = basicType } } ; if (basicType == "NetworkAddress") { return new StructType { NativeType = type, VarName = varname, StructName = basicType } } ; if (basicType == "ConnectionInfo") { return new StructType { NativeType = type, VarName = varname, StructName = basicType } } ; if (basicType.StartsWith("E") && char.IsUpper(basicType[1])) { return new EnumType { NativeType = type.Substring(1), VarName = varname } } ; return(new BaseType { NativeType = type, VarName = varname }); }
void StructFunctions() { foreach (var c in def.structs.Union(def.callback_structs.Select(x => x as SteamApiDefinition.StructDef)).OrderBy(x => x.Name)) { var name = Cleanup.ConvertType(c.Name); if (name.Contains("::")) { continue; } if (c.Methods == null || c.Methods.Length == 0) { continue; } // // Main struct // StartBlock($"{Cleanup.Expose( name )} partial struct {name}"); { foreach (var func in c.Methods) { if (func.Name.Contains("operator")) { func.Name = func.FlatName.Substring(func.FlatName.LastIndexOf('_') + 1); } var returnType = BaseType.Parse(func.ReturnType, null, func.CallResult); returnType.Func = func.Name; var args = func.Params.Select(x => { var bt = BaseType.Parse(x.ParamType, x.ParamName); bt.Func = func.Name; return(bt); }).ToArray(); for (int i = 0; i < args.Length; i++) { if (args[i] is FetchStringType) { if (args[i + 1] is IntType || args[i + 1] is UIntType || args[i + 1] is UIntPtrType) { if (string.IsNullOrEmpty(args[i + 1].Ref)) { args[i + 1] = new LiteralType(args[i + 1], "(1024 * 32)"); } } else { throw new System.Exception($"String Builder Next Type Is {args[i + 1].GetType()}"); } } } var delegateargstr = string.Join(", ", args.Select(x => x.AsNativeArgument())); if (!string.IsNullOrEmpty(func.Desc)) { WriteLine("/// <summary>"); WriteLine($"/// {func.Desc}"); WriteLine("/// </summary>"); } if (returnType.ReturnAttribute != null) { WriteLine(returnType.ReturnAttribute); } var _unsafe = ""; var firstArg = $"ref {name} self"; // // If this is NetMsg then the ORIGINAL pointer address is important // because we need to pass in the original pointer - not just the data // if (name == "NetMsg") { firstArg = $"{name}* self"; _unsafe = " unsafe"; } WriteLine($"[DllImport( Platform.LibraryName, EntryPoint = \"{func.FlatName}\", CallingConvention = Platform.CC)]"); WriteLine($"internal static{_unsafe} extern {returnType.TypeNameFrom} Internal{func.Name}( {firstArg}, {delegateargstr} );".Replace($"( {firstArg}, )", $"( {firstArg} )")); WriteLine(); } } EndBlock(); WriteLine(); } }
private void Enums() { foreach (var o in def.enums) { WriteLine($"//"); WriteLine($"// {o.Name}"); WriteLine($"//"); var name = o.Name; // We're not interested in namespacing if (name.Contains("::")) { name = o.Name.Substring(o.Name.LastIndexOf(":") + 1); } // Skip the E if (name[0] == 'E') { name = name.Substring(1); } name = Cleanup.ConvertType(name); if (!Cleanup.ShouldCreate(name)) { continue; } StartBlock($"{Cleanup.Expose( name )} enum {name} : int"); { // // If all the enum values start with the same // string, remove it. This converts // "k_EUserHasLicenseResultHasLicense" to "HasLicense" etc // int iFinished = int.MaxValue; for (int i = 0; i < 4096; i++) { var c = o.Values.First().Name[i]; foreach (var entry in o.Values) { if (entry.Name[i] != c) { iFinished = i; break; } } if (iFinished != int.MaxValue) { break; } } foreach (var entry in o.Values) { var ename = entry.Name; if (iFinished != int.MaxValue) { ename = ename.Substring(iFinished); } // // Names aren't allowed to start with a number // So just stick the enum name on the front // if (char.IsNumber(ename[0])) { ename = name + ename; } WriteLine($"{ename} = {entry.Value},"); } } EndBlock(); WriteLine(); } }