public override void WriteCallLogArgParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (IsArrayLengthParameter(this, ctx, parentCommand)) { CommandParameter arrayParam = GetArrayParameter(this, ctx, parentCommand); switch (arrayParam.LengthMode) { case CommandParameterLengthMode.ArgumentReference: sw.Write("{0}.Length", arrayParam.GetDelegateCallVarName(parentCommand)); break; case CommandParameterLengthMode.ArgumentMultiple: uint multiple = arrayParam.LengthMultiple; if (multiple > 1) { sw.Write("{0}.Length / {1}", arrayParam.GetDelegateCallVarName(parentCommand), multiple); } else { sw.Write("{0}.Length", arrayParam.GetDelegateCallVarName(parentCommand)); } break; } } else { base.WriteCallLogArgParam(sw, ctx, parentCommand); } }
public override void WriteDelegateParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { string paramModifier = GetImplementationTypeModifier(ctx, parentCommand); if (mIsPinned) { if (paramModifier != null) { sw.Write("{0} ", paramModifier); } // Object parameters are pinned sw.Write("{0}.AddrOfPinnedObject()", PinnedLocalVarName); } else if (IsFixed(ctx, parentCommand)) { if (paramModifier != null) { sw.Write("{0} ", paramModifier); } // Fixed parameters are fixed in overloaded method call sw.Write(DelegateCallVarName); } else { base.WriteDelegateParam(sw, ctx, parentCommand); } }
/// <summary> /// Generate the command delegate source code. /// </summary> /// <param name="sw"> /// The <see cref="SourceStreamWriter"/> used to write the source code. /// </param> /// <param name="ctx"> /// The <see cref="RegistryContext"/> defining the OpenGL registry information. /// </param> internal void GenerateDelegate(SourceStreamWriter sw, RegistryContext ctx) { // No sure if it is really necessary sw.WriteLine("[SuppressUnmanagedCodeSecurity()]"); // Delegate type definition sw.WriteIdentation(); sw.Write("internal "); if (IsSafeImplementation == false) { sw.Write("unsafe "); } sw.Write("delegate "); sw.Write("{0} {1}(", DelegateReturnType, ImportName); int paramCount = Parameters.Count; foreach (CommandParameter param in Parameters) { string paramAttributes = param.GetDelegateTypeAttributes(ctx, this); string paramModifier = param.GetDelegateTypeModifier(ctx, this); if (paramAttributes != null) { sw.Write("{0} ", paramAttributes); } if (paramModifier != null) { sw.Write("{0} ", paramModifier); } sw.Write("{0} {1}", param.GetDelegateType(ctx, this), param.ImportName); paramCount--; if (paramCount > 0) { sw.Write(", "); } } sw.Write(");"); sw.WriteLine(); sw.WriteLine(); if (Aliases.Count > 0) { sw.WriteLine("[AliasOf(\"{0}\")]", ImportName); foreach (Command aliasOf in Aliases) { sw.WriteLine("[AliasOf(\"{0}\")]", aliasOf.ImportName); } } // Required on Windows platform: different threads can bind different OpenGL context, which can have different // entry points sw.WriteLine("[ThreadStatic]"); // Delegate field sw.WriteLine("internal static {0} {1};", ImportName, DelegateName); }
public virtual void WriteDelegateParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (IsFixed(ctx, parentCommand) == false) { sw.Write(DelegateCallVarName); } else { sw.Write(FixedLocalVarName); } }
public static void WriteCallLogArgParam(SourceStreamWriter sw, string implementationName, string implementationType) { if (implementationType.EndsWith("*")) { sw.Write("new IntPtr({0})", implementationName); } //else if (implementationType == "IntPtr") // sw.Write("{0}.ToString(\"X8\")", implementationName); else { sw.Write("{0}", implementationName); } }
public virtual void WriteCallLogFormatParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand, int paramIndex) { string implementationType = GetImplementationType(ctx, parentCommand); bool safeImplementationType = !implementationType.EndsWith("*") && implementationType != "IntPtr"; if (safeImplementationType == false) { sw.Write("0x{{{0}}}", paramIndex); } else { sw.Write("{{{0}}}", paramIndex); } }
/// <summary> /// Generate the C# source code for this enumerant. /// </summary> /// <param name="sw"> /// A <see cref="SourceStreamWriter"/> used for writing the source code. /// </param> internal void GenerateSource(SourceStreamWriter sw, RegistryContext ctx) { if (sw == null) { throw new ArgumentNullException("sw"); } RegistryDocumentation.GenerateDocumentation(sw, ctx, this); foreach (Enumerant aliasOf in AliasOf) { sw.WriteLine("[AliasOf(\"{0}\")]", aliasOf.Name); } foreach (IFeature feature in RequiredBy) { sw.WriteLine("[RequiredByFeature(\"{0}\")]", feature.Name); } foreach (Enumerant aliasOf in AliasOf) { foreach (IFeature feature in aliasOf.RequiredBy) { sw.WriteLine("[RequiredByFeature(\"{0}\")]", feature.Name); } } foreach (IFeature feature in RemovedBy) { sw.WriteLine("[RemovedByFeature(\"{0}\")]", feature.Name); } // This metadata is used for procedure logging function bool requiresLogAttribute = ParentEnumerantBlock.Type == "bitmask"; if (requiresLogAttribute == true) { if (ParentEnumerantBlock.Type == "bitmask") { sw.WriteLine("[Log(BitmaskName = \"{0}\")]", ParentEnumerantBlock.Namespace); } } if (IsDeprecated) { sw.Write("#if DEBUG && !OPENGL_NET_COMPATIBILITY_PROFILE" + Environment.NewLine); sw.WriteLine("[Obsolete(\"Deprecated/removed by {0}.\")]", SpecificationStyle.GetKhronosVersionHumanReadable(RemovedBy[0].Name)); sw.Write("#endif" + Environment.NewLine); } sw.WriteLine(Declaration); }
public static void WriteCallLogArgParam(SourceStreamWriter sw, string implementationName, string implementationType) { if (implementationType.EndsWith("*")) { sw.Write("{0} != null ? {0}->ToString() : \"(null)\"", implementationName); } else if (implementationType == "IntPtr") { sw.Write("{0}.ToString(\"X8\")", implementationName); } else { sw.Write("{0}", implementationName); } }
public override void WriteDelegateParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (mIsStrong) { // Strongly typed enum must be casted to delegate call type (int or uint) sw.Write("({0}){1}", OverridenParameter.ImportType, DelegateCallVarName); } else base.WriteDelegateParam(sw, ctx, parentCommand); }
public virtual void WriteCallLogArgParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { CommandFlagsDatabase.CommandItem.ParameterItemFlags parameterFlags = CommandFlagsDatabase.GetCommandParameterFlags(parentCommand, this); if (((Type != null) && (Type == "GLenum")) || ((parameterFlags & CommandFlagsDatabase.CommandItem.ParameterItemFlags.LogAsEnum) != 0)) { sw.Write("LogEnumName({0})", ImplementationName); } else if (IsManagedArray && GetImplementationTypeModifier(ctx, parentCommand) != "out") { sw.Write("LogValue({0})", ImplementationName); } else { WriteCallLogArgParam(sw, ImplementationName, GetImplementationType(ctx, parentCommand)); } }
public virtual void WriteDelegateParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (IsFixed(ctx, parentCommand) == false) { string modifier = CommandFlagsDatabase.GetCommandArgumentModifier(parentCommand, this); if (modifier != null) { sw.Write(modifier + " "); } sw.Write(GetDelegateCallVarName(parentCommand)); } else { sw.Write(FixedLocalVarName); } }
public override void WriteCallLogArgParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (_IsPointer == true) { sw.Write("new IntPtr({0}).ToString(\"X8\")", ImplementationName); } else { base.WriteCallLogArgParam(sw, ctx, parentCommand); } }
public override void WriteDelegateParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (IsArrayLengthParameter(this, ctx, parentCommand)) { int arrayLengthParamIndex = parentCommand.Parameters.FindIndex(delegate(CommandParameter item) { return(parentCommand.Parameters.FindIndex(delegate(CommandParameter subitem) { return (item.Length == Name); }) >= 0); }); if (OverridenParameter.ImportType != "int") { sw.Write("({0})", OverridenParameter.ImportType); } sw.Write("{0}.Length", parentCommand.Parameters[arrayLengthParamIndex].DelegateCallVarName); } else { base.WriteDelegateParam(sw, ctx, parentCommand); } }
public override void WriteDelegateParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (mIsStrong) { // Strongly typed enum must be casted to delegate call type (int or uint) sw.Write("({0}){1}", OverridenParameter.GetImportType(parentCommand), GetDelegateCallVarName(parentCommand)); } else { base.WriteDelegateParam(sw, ctx, parentCommand); } }
public override void WriteDelegateParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (_IsPointer == true) { // Writer plain variable name sw.Write(DelegateCallVarName); } else { base.WriteDelegateParam(sw, ctx, parentCommand); } }
/// <summary> /// Generate the command import source code. /// </summary> /// <param name="sw"> /// The <see cref="SourceStreamWriter"/> used to write the source code. /// </param> /// <param name="ctx"> /// The <see cref="RegistryContext"/> defining the OpenGL registry information. /// </param> internal void GenerateImport(SourceStreamWriter sw, RegistryContext ctx) { // The SuppressUnmanagedCodeSecurity attribute is used to increase P/Invoke performance sw.WriteLine("[SuppressUnmanagedCodeSecurity()]"); // Import definition CommandFlags commandFlags = CommandFlagsDatabase.GetCommandFlags(this); if ((commandFlags & CommandFlags.SetLastError) != 0) { sw.WriteLine("[DllImport(Library, EntryPoint = \"{0}\", ExactSpelling = true, SetLastError = true)]", ImportName); } else { sw.WriteLine("[DllImport(Library, EntryPoint = \"{0}\", ExactSpelling = true)]", ImportName); } // GLboolean is mapped to 'unsigned char': instruct to marshal return value as 1 byte boolean if (Prototype.Type == "GLboolean") { sw.WriteLine("[return: MarshalAs(UnmanagedType.I1)]"); } // BOOL is mapped to 'unsigned int': instruct to marshal return value as 4 byte boolean if (Prototype.Type == "BOOL") { sw.WriteLine("[return: MarshalAs(UnmanagedType.Bool)]"); } // Import declaration sw.WriteIdentation(); sw.Write("internal extern static "); if (IsSafeImplementation == false) { sw.Write("unsafe "); } sw.Write("{0} {1}(", DelegateReturnType, ImportName); int paramCount = Parameters.Count; foreach (CommandParameter param in Parameters) { sw.Write("{0} {1}", param.ImportType, param.ImportName); paramCount--; if (paramCount > 0) { sw.Write(", "); } } sw.Write(");"); sw.WriteLine(); }
public virtual void WriteCallLogFormatParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand, int paramIndex) { string implementationType = GetImplementationType(ctx, parentCommand); bool safeImplementationType = !implementationType.EndsWith("*") && implementationType != "IntPtr"; if (safeImplementationType == false) sw.Write("0x{{{0}}}", paramIndex); else sw.Write("{{{0}}}", paramIndex); }
public override void WriteCallLogArgParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (_IsPointer == true) { sw.Write("new IntPtr({0}).ToString(\"X8\")", ImplementationName); } else base.WriteCallLogArgParam(sw, ctx, parentCommand); }
public virtual void WriteDelegateParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (IsFixed(ctx, parentCommand) == false) { sw.Write(DelegateCallVarName); } else sw.Write(FixedLocalVarName); }
/// <summary> /// Generate the command implementation signature and the method documentation. /// </summary> /// <param name="sw"> /// The <see cref="SourceStreamWriter"/> used to write the source code. /// </param> /// <param name="ctx"> /// The <see cref="RegistryContext"/> defining the OpenGL registry information. /// </param> /// <param name="commandParams"> /// A <see cref="T:List{CommandParameter}"/> determining the method overload. /// </param> private void GenerateImplementation_Signature(SourceStreamWriter sw, RegistryContext ctx, List<CommandParameter> commandParams, string implementationName, string returnType) { #if !DEBUG // Documentation RegistryDocumentation.GenerateDocumentation(sw, ctx, this, commandParams); #endif foreach (IFeature feature in RequiredBy) sw.WriteLine("[RequiredByFeature(\"{0}\")]", feature.Name); foreach (IFeature feature in RemovedBy) sw.WriteLine("[RemovedByFeature(\"{0}\")]", feature.Name); #region Signature sw.WriteIdentation(); // Signature sw.Write("{0} static ", CommandFlagsDatabase.GetCommandVisibility(this)); if (IsUnsafeImplementationSignature(ctx, commandParams)) sw.Write("unsafe "); sw.Write("{0} {1}(", returnType, implementationName); // Signature - Parameters int paramCount = commandParams.FindAll(delegate(CommandParameter item) { return (!item.IsImplicit(ctx, this)); }).Count; foreach (CommandParameter param in commandParams) { // Skip in signature implicit parameters if (param.IsImplicit(ctx, this)) continue; string paramAttributes = param.GetImplementationTypeAttributes(ctx, this); string paramModifier = param.GetImplementationTypeModifier(ctx, this); if (paramAttributes != null) sw.Write("{0} ", paramAttributes); if (paramModifier != null) sw.Write("{0} ", paramModifier); if ((paramCount == 1) && (param.IsManagedArray) && ((Flags & CommandFlags.VariadicParams) != 0)) sw.Write("params "); sw.Write("{0} {1}", param.GetImplementationType(ctx, this), param.ImplementationName); paramCount--; if (paramCount > 0) sw.Write(", "); } sw.Write(")"); sw.WriteLine(); #endregion }
public override void WriteDelegateParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (_IsPointer == true) { // Writer plain variable name sw.Write(DelegateCallVarName); } else base.WriteDelegateParam(sw, ctx, parentCommand); }
/// <summary> /// Generate the command implementation (fixed variant). /// </summary> /// <param name="sw"> /// The <see cref="SourceStreamWriter"/> used to write the source code. /// </param> /// <param name="ctx"> /// The <see cref="RegistryContext"/> defining the OpenGL registry information. /// </param> /// <param name="commandParams"> /// A <see cref="T:List{CommandParameter}"/> determining the method overload. /// </param> private void GenerateImplementation_Default(SourceStreamWriter sw, RegistryContext ctx, List<CommandParameter> commandParams) { List<Command> aliases = new List<Command>(); Command aliasCommand = this; // The implementation returned type string returnType = aliasCommand.GetImplementationReturnType(ctx); // Is fixed implementation bool fixedImplementation = IsFixedImplementation(ctx, commandParams); aliases.Add(this); aliases.AddRange(Aliases); // Signature GenerateImplementation_Signature(sw, ctx, commandParams); // Implementation block sw.WriteLine("{"); sw.Indent(); #region Debug Assertions // Debug assertions foreach (CommandParameter param in commandParams) param.WriteDebugAssertion(sw, ctx, this); #endregion #region Local Variables // Local variable: returned value if (HasReturnValue) { sw.WriteLine("{0} {1};", DelegateReturnType, ReturnVariableName); sw.WriteLine(); } #endregion #region Unsafe Block (Open) if (fixedImplementation) { sw.WriteLine("unsafe {"); // (1) sw.Indent(); foreach (CommandParameter param in commandParams) param.WriteFixedStatement(sw, ctx, this); sw.WriteLine("{"); // (2) sw.Indent(); } #endregion sw.WriteLine("Debug.Assert(Delegates.{0} != null, \"{0} not implemented\");", aliasCommand.DelegateName); #region Delegate Call sw.WriteIdentation(); // Local return value if (HasReturnValue) sw.Write("{0} = ", ReturnVariableName); sw.Write("Delegates.{0}(", aliasCommand.DelegateName); #region Parameters for (int i = 0; i < commandParams.Count; i++) { CommandParameter param = commandParams[i]; param.WriteDelegateParam(sw, ctx, this); if (i != Parameters.Count - 1) sw.Write(", "); } #endregion sw.Write(")"); sw.Write(";"); sw.WriteLine(); #endregion #region Call Log sw.WriteIdentation(); sw.Write("LogFunction("); #region Call Log - Format String sw.Write("\"{0}(", aliasCommand.ImportName); for (int i = 0; i < commandParams.Count; i++) { commandParams[i].WriteCallLogFormatParam(sw, ctx, this, i); if (i < commandParams.Count - 1) sw.Write(", "); } sw.Write(")"); if (HasReturnValue) sw.Write(" = {{{0}}}", commandParams.Count); sw.Write("\""); #endregion #region Call Log - Format Arguments if ((commandParams.Count > 0) || HasReturnValue) { sw.Write(", "); for (int i = 0; i < commandParams.Count; i++) { commandParams[i].WriteCallLogArgParam(sw, ctx, this); if (i < commandParams.Count - 1) sw.Write(", "); } } // Return value if (HasReturnValue) { if (commandParams.Count > 0) sw.Write(", "); CommandParameter.WriteCallLogArgParam(sw, GetReturnValueExpression(ctx), returnType); } #endregion sw.Write(");"); sw.WriteLine(); #endregion #region Unsafe Block (Close) if (fixedImplementation) { sw.Unindent(); sw.WriteLine("}"); // (2) CLOSED sw.Unindent(); sw.WriteLine("}"); // (1) CLOSED } #endregion // Check call errors if ((Flags & CommandFlags.NoGetError) == 0) { string returnValue = "null"; // Optionally pass the returned value to error checking method if (HasReturnValue) returnValue = ReturnVariableName; sw.WriteLine("DebugCheckErrors({0});", returnValue); } // Returns value if (HasReturnValue) { sw.WriteLine(); sw.WriteLine("return ({0});", GetReturnValueExpression(ctx)); } sw.Unindent(); sw.WriteLine("}"); }
/// <summary> /// Generate the command delegate source code. /// </summary> /// <param name="sw"> /// The <see cref="SourceStreamWriter"/> used to write the source code. /// </param> /// <param name="ctx"> /// The <see cref="RegistryContext"/> defining the OpenGL registry information. /// </param> internal void GenerateDelegate(SourceStreamWriter sw, RegistryContext ctx) { // Attributes required for checking API commands support string classDefaultApi = ctx.Class.ToLower(); foreach (IFeature feature in RequiredBy) { sw.WriteLine(feature.GenerateRequiredByAttribute(this, classDefaultApi)); } foreach (IFeature feature in RemovedBy) { sw.WriteLine(feature.GenerateRemovedByAttribute(classDefaultApi)); } // Not yet sure if it is really necessary sw.WriteLine("[SuppressUnmanagedCodeSecurity()]"); // Delegate type definition sw.WriteIdentation(); sw.Write("internal "); if (IsSafeImplementation == false) { sw.Write("unsafe "); } sw.Write("delegate "); sw.Write("{0} {1}(", DelegateReturnType, ImportName); int paramCount = Parameters.Count; foreach (CommandParameter param in Parameters) { string paramAttributes = param.GetDelegateTypeAttributes(ctx, this); string paramModifier = param.GetDelegateTypeModifier(ctx, this); if (paramAttributes != null) { sw.Write("{0} ", paramAttributes); } if (paramModifier != null) { sw.Write("{0} ", paramModifier); } sw.Write("{0} {1}", param.GetDelegateType(ctx, this), param.ImportName); paramCount--; if (paramCount > 0) { sw.Write(", "); } } sw.Write(");"); sw.WriteLine(); sw.WriteLine(); foreach (IFeature feature in RequiredBy) { sw.WriteLine(feature.GenerateRequiredByAttribute(this, classDefaultApi)); } foreach (IFeature feature in RemovedBy) { sw.WriteLine(feature.GenerateRemovedByAttribute(classDefaultApi)); } // Required on Windows platform: different threads can bind different OpenGL context, which can have different // entry points if (ctx.Class == "Gl") { sw.WriteLine("[ThreadStatic]"); } // Delegate field sw.WriteLine("internal static {0} {1};", ImportName, DelegateName); }
public static void WriteCallLogArgParam(SourceStreamWriter sw, string implementationName, string implementationType) { if (implementationType.EndsWith("*")) sw.Write("{0} != null ? {0}->ToString() : \"(null)\"", implementationName); else if (implementationType == "IntPtr") sw.Write("{0}.ToString(\"X8\")", implementationName); else sw.Write("{0}", implementationName); }
public override void WriteDelegateParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { string paramModifier = GetImplementationTypeModifier(ctx, parentCommand); if (mIsPinned) { if (paramModifier != null) sw.Write("{0} ", paramModifier); // Object parameters are pinned sw.Write("{0}.AddrOfPinnedObject()", PinnedLocalVarName); } else if (IsFixed(ctx, parentCommand)) { if (paramModifier != null) sw.Write("{0} ", paramModifier); // Fixed parameters are fixed in overloaded method call sw.Write(DelegateCallVarName); } else base.WriteDelegateParam(sw, ctx, parentCommand); }
public virtual void WriteImplementationParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { sw.Write(DelegateCallVarName); }
/// <summary> /// Generate the command implementation (generate one object variant). /// </summary> /// <param name="sw"> /// The <see cref="SourceStreamWriter"/> used to write the source code. /// </param> /// <param name="ctx"> /// The <see cref="RegistryContext"/> defining the OpenGL registry information. /// </param> /// <param name="commandParams"> /// A <see cref="T:List{CommandParameter}"/> determining the method overload. /// </param> private void GenerateImplementation_GenOneObject(SourceStreamWriter sw, RegistryContext ctx) { List <CommandParameter> commandParams = new List <CommandParameter>(); string implementationName = GetImplementationName(ctx); if (implementationName.EndsWith("ies")) { implementationName = implementationName.Substring(0, implementationName.Length - 3) + "y"; } else if (implementationName.EndsWith("s")) { implementationName = implementationName.Substring(0, implementationName.Length - 1); } foreach (CommandParameter commandParameter in Parameters) { commandParams.Add(new CommandParameterArrayLength(commandParameter, ctx, this)); } List <CommandParameterArrayLength> arrayParameters = new List <CommandParameterArrayLength>(); List <CommandParameter> signatureParams = commandParams.FindAll(delegate(CommandParameter item) { bool compatible = CommandParameterArrayLength.IsCompatible(ctx, this, item); bool arrayLengthParam = CommandParameterArrayLength.IsArrayLengthParameter(item, ctx, this); if (compatible) { arrayParameters.Add((CommandParameterArrayLength)item); } return(!compatible && !arrayLengthParam); }); Debug.Assert(arrayParameters.Count == 1); CommandParameterArrayLength returnParameter = arrayParameters[0]; string returnParameterType = returnParameter.GetImplementationType(ctx, this); // Remove [] returnParameterType = returnParameterType.Substring(0, returnParameterType.Length - 2); // Signature GenerateImplementation_Signature(sw, ctx, signatureParams, implementationName, returnParameterType); // Implementation block sw.WriteLine("{"); sw.Indent(); #region Local Variables sw.WriteLine("{0}[] {1} = new {0}[1];", returnParameterType, ReturnVariableName); #endregion #region Implementation Call sw.WriteIdentation(); sw.Write("{0}(", GetImplementationName(ctx)); #region Parameters for (int i = 0; i < commandParams.Count; i++) { CommandParameter param = commandParams[i]; if (CommandParameterArrayLength.IsArrayLengthParameter(param, ctx, this)) { continue; } else if (CommandParameterArrayLength.IsCompatible(ctx, this, param)) { sw.Write(ReturnVariableName); } else { param.WriteDelegateParam(sw, ctx, this); } if (i != commandParams.Count - 1) { sw.Write(", "); } } #endregion sw.Write(");"); sw.WriteLine(); sw.WriteLine("return ({0}[0]);", ReturnVariableName); #endregion sw.Unindent(); sw.WriteLine("}"); }
/// <summary> /// Generate the C# source code for this enumerant. /// </summary> /// <param name="sw"> /// A <see cref="SourceStreamWriter"/> used for writing the source code. /// </param> internal void GenerateSource(SourceStreamWriter sw, RegistryContext ctx) { if (sw == null) throw new ArgumentNullException("sw"); RegistryDocumentation.GenerateDocumentation(sw, ctx, this); foreach (Enumerant aliasOf in AliasOf) sw.WriteLine("[AliasOf(\"{0}\")]", aliasOf.Name); foreach (IFeature feature in RequiredBy) sw.WriteLine("[RequiredByFeature(\"{0}\")]", feature.Name); foreach (Enumerant aliasOf in AliasOf) { foreach (IFeature feature in aliasOf.RequiredBy) sw.WriteLine("[RequiredByFeature(\"{0}\")]", feature.Name); } foreach (IFeature feature in RemovedBy) sw.WriteLine("[RemovedByFeature(\"{0}\")]", feature.Name); if (IsDeprecated) { sw.Write("#if DEBUG && !OPENGL_NET_COMPATIBILITY_PROFILE" + Environment.NewLine); sw.WriteLine("[Obsolete(\"Deprecated/removed by {0}.\")]", SpecificationStyle.GetHumanToken(RemovedBy[0].Name)); sw.Write("#endif" + Environment.NewLine); } sw.WriteLine(Declaration); }
/// <summary> /// Generate the command import source code. /// </summary> /// <param name="sw"> /// The <see cref="SourceStreamWriter"/> used to write the source code. /// </param> /// <param name="ctx"> /// The <see cref="RegistryContext"/> defining the OpenGL registry information. /// </param> internal void GenerateImport(SourceStreamWriter sw, RegistryContext ctx) { // The SuppressUnmanagedCodeSecurity attribute is used to increase P/Invoke performance sw.WriteLine("[SuppressUnmanagedCodeSecurity()]"); // Import definition sw.WriteLine("[DllImport(Library, EntryPoint = \"{0}\", ExactSpelling = true)]", ImportName); // GLboolean is mapped to 'unsigned char': instruct to marshal return value as 1 byte boolean if (Prototype.Type == "GLboolean") sw.WriteLine("[return: MarshalAs(UnmanagedType.I1)]"); // BOOL is mapped to 'unsigned int': instruct to marshal return value as 4 byte boolean if (Prototype.Type == "BOOL") sw.WriteLine("[return: MarshalAs(UnmanagedType.Bool)]"); // Import declaration sw.WriteIdentation(); sw.Write("internal extern static "); if (IsSafeImplementation == false) sw.Write("unsafe "); sw.Write("{0} {1}(", DelegateReturnType, ImportName); int paramCount = Parameters.Count; foreach (CommandParameter param in Parameters) { sw.Write("{0} {1}", param.ImportType, param.ImportName); paramCount--; if (paramCount > 0) sw.Write(", "); } sw.Write(");"); sw.WriteLine(); }
/// <summary> /// Generate the command implementation (generate one object variant). /// </summary> /// <param name="sw"> /// The <see cref="SourceStreamWriter"/> used to write the source code. /// </param> /// <param name="ctx"> /// The <see cref="RegistryContext"/> defining the OpenGL registry information. /// </param> /// <param name="commandParams"> /// A <see cref="T:List{CommandParameter}"/> determining the method overload. /// </param> private void GenerateImplementation_GenOneObject(SourceStreamWriter sw, RegistryContext ctx) { List<CommandParameter> commandParams = new List<CommandParameter>(); string implementationName = GetImplementationName(ctx); if (implementationName.EndsWith("ies")) implementationName = implementationName.Substring(0, implementationName.Length - 3) + "y"; else if (implementationName.EndsWith("s")) implementationName = implementationName.Substring(0, implementationName.Length - 1); foreach (CommandParameter commandParameter in Parameters) commandParams.Add(new CommandParameterArray(commandParameter, ctx, this)); List<CommandParameterArray> arrayParameters = new List<CommandParameterArray>(); List<CommandParameter> signatureParams = commandParams.FindAll(delegate(CommandParameter item) { bool compatible = CommandParameterArray.IsCompatible(item, ctx, this); bool arrayLengthParam = CommandParameterArray.IsArrayLengthParameter(item, ctx, this); if (compatible) arrayParameters.Add((CommandParameterArray)item); return (!compatible && !arrayLengthParam); }); Debug.Assert(arrayParameters.Count == 1); CommandParameterArray returnParameter = arrayParameters[0]; string returnParameterType = returnParameter.GetImplementationType(ctx, this); // Remove [] returnParameterType = returnParameterType.Substring(0, returnParameterType.Length - 2); // Signature GenerateImplementation_Signature(sw, ctx, signatureParams, implementationName, returnParameterType); // Implementation block sw.WriteLine("{"); sw.Indent(); #region Local Variables sw.WriteLine("{0}[] {1} = new {0}[1];", returnParameterType, ReturnVariableName); #endregion #region Implementation Call sw.WriteIdentation(); sw.Write("{0}(", GetImplementationName(ctx)); #region Parameters for (int i = 0; i < commandParams.Count; i++) { CommandParameter param = commandParams[i]; if (CommandParameterArray.IsArrayLengthParameter(param, ctx, this)) { continue; } else if (CommandParameterArray.IsCompatible(param, ctx, this)) sw.Write(ReturnVariableName); else param.WriteDelegateParam(sw, ctx, this); if (i != commandParams.Count - 1) sw.Write(", "); } #endregion sw.Write(");"); sw.WriteLine(); sw.WriteLine("return ({0}[0]);", ReturnVariableName); #endregion sw.Unindent(); sw.WriteLine("}"); }
/// <summary> /// Generate the command implementation (pinned variant). /// </summary> /// <param name="sw"> /// The <see cref="SourceStreamWriter"/> used to write the source code. /// </param> /// <param name="ctx"> /// The <see cref="RegistryContext"/> defining the OpenGL registry information. /// </param> /// <param name="commandParams"> /// A <see cref="T:List{CommandParameter}"/> determining the method overload. /// </param> private void GenerateImplementation_Pinned(SourceStreamWriter sw, RegistryContext ctx, List<CommandParameter> commandParams) { // Signature GenerateImplementation_Signature(sw, ctx, commandParams); // Implementation block sw.WriteLine("{"); sw.Indent(); #region Pinned Object Block (Open) foreach (CommandParameter param in commandParams) param.WritePinnedVariable(sw, ctx, this); sw.WriteLine("try {"); sw.Indent(); #endregion #region Implementation Call sw.WriteIdentation(); if (HasReturnValue) sw.Write("return ("); sw.Write("{0}(", GetImplementationName(ctx)); #region Parameters for (int i = 0; i < commandParams.Count; i++) { CommandParameter param = commandParams[i]; param.WriteDelegateParam(sw, ctx, this); if (i != commandParams.Count - 1) sw.Write(", "); } #endregion sw.Write(")"); if (HasReturnValue) sw.Write(")"); sw.Write(";"); sw.WriteLine(); #endregion #region Pinned Object Block (Close) sw.Unindent(); sw.WriteLine("} finally {"); sw.Indent(); foreach (CommandParameter param in commandParams) param.WriteUnpinCommand(sw, ctx, this); sw.Unindent(); sw.WriteLine("}"); #endregion sw.Unindent(); sw.WriteLine("}"); }
/// <summary> /// Generate the command implementation (fixed variant). /// </summary> /// <param name="sw"> /// The <see cref="SourceStreamWriter"/> used to write the source code. /// </param> /// <param name="ctx"> /// The <see cref="RegistryContext"/> defining the OpenGL registry information. /// </param> /// <param name="commandParams"> /// A <see cref="T:List{CommandParameter}"/> determining the method overload. /// </param> private void GenerateImplementation_Default(SourceStreamWriter sw, RegistryContext ctx, List<CommandParameter> commandParams) { List<Command> aliases = new List<Command>(); Command aliasCommand = this; // The implementation returned type string returnType = aliasCommand.GetImplementationReturnType(ctx); // The delegate returned type string delegateReturnType = aliasCommand.DelegateReturnType; bool fixedImplementation = IsFixedImplementation(ctx, commandParams); // At least one parameter is an array with length correlated with another parameter bool isArrayImplementation = commandParams.FindIndex(delegate(CommandParameter item) { return (item is CommandParameterArray); }) >= 0; // Returned value must be marshalled as string bool marshalReturnedString = aliasCommand.HasReturnValue && (returnType.ToLower() == "string") && (delegateReturnType.ToLower() != "string"); // Returned value must be marshalled as structure bool marshalReturnedStruct = aliasCommand.HasReturnValue && (DelegateReturnType == "IntPtr") && (GetImplementationReturnType(ctx) != "IntPtr"); aliases.Add(this); aliases.AddRange(Aliases); // Signature GenerateImplementation_Signature(sw, ctx, commandParams); // Implementation block sw.WriteLine("{"); sw.Indent(); #region Debug Assertions // Debug assertions foreach (CommandParameter param in commandParams) param.WriteDebugAssertion(sw, ctx, this); #endregion #region Local Variables // Local variable: returned value if (HasReturnValue) { sw.WriteLine("{0} {1};", DelegateReturnType, ReturnVariableName); sw.WriteLine(); } #endregion #region Unsafe Block (Open) if (fixedImplementation) { sw.WriteLine("unsafe {"); // (1) sw.Indent(); foreach (CommandParameter param in commandParams) param.WriteFixedStatement(sw, ctx, this); sw.WriteLine("{"); // (2) sw.Indent(); } #endregion sw.WriteLine("Debug.Assert(Delegates.{0} != null, \"{0} not implemented\");", aliasCommand.DelegateName); #region Delegate Call sw.WriteIdentation(); // Local return value if (HasReturnValue) sw.Write("{0} = ", ReturnVariableName); sw.Write("Delegates.{0}(", aliasCommand.DelegateName); #region Parameters for (int i = 0; i < commandParams.Count; i++) { CommandParameter param = commandParams[i]; param.WriteDelegateParam(sw, ctx, this); if (i != Parameters.Count - 1) sw.Write(", "); } #endregion sw.Write(")"); sw.Write(";"); sw.WriteLine(); #endregion #region Call Log sw.WriteIdentation(); sw.Write("CallLog("); #region Call Log - Format String sw.Write("\"{0}(", aliasCommand.ImportName); for (int i = 0; i < commandParams.Count; i++) { commandParams[i].WriteCallLogFormatParam(sw, ctx, this, i); if (i < commandParams.Count - 1) sw.Write(", "); } sw.Write(")"); if (HasReturnValue) sw.Write(" = {{{0}}}", commandParams.Count); sw.Write("\""); #endregion #region Call Log - Format Arguments if ((commandParams.Count > 0) || HasReturnValue) { sw.Write(", "); for (int i = 0; i < commandParams.Count; i++) { commandParams[i].WriteCallLogArgParam(sw, ctx, this); if (i < commandParams.Count - 1) sw.Write(", "); } } // Return value if (HasReturnValue) { if (commandParams.Count > 0) sw.Write(", "); CommandParameter.WriteCallLogArgParam(sw, ReturnVariableName, returnType); } #endregion sw.Write(");"); sw.WriteLine(); #endregion #region Unsafe Block (Close) if (fixedImplementation) { sw.Unindent(); sw.WriteLine("}"); // (2) CLOSED sw.Unindent(); sw.WriteLine("}"); // (1) CLOSED } #endregion // Check call errors if ((Flags & CommandFlags.NoGetError) == 0) sw.WriteLine("DebugCheckErrors();"); // Returns value if (HasReturnValue) { sw.WriteLine(); if (marshalReturnedString) sw.WriteLine("return (Marshal.PtrToStringAnsi({0}));", ReturnVariableName); else if (marshalReturnedStruct) sw.WriteLine("return (({1})Marshal.PtrToStructure({0}, typeof({1})));", ReturnVariableName, GetImplementationReturnType(ctx)); else if (returnType != delegateReturnType) sw.WriteLine("return (({1}){0});", ReturnVariableName, GetImplementationReturnType(ctx)); else sw.WriteLine("return ({0});", ReturnVariableName); } sw.Unindent(); sw.WriteLine("}"); }
public virtual void WriteCallLogArgParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { CommandFlagsDatabase.CommandItem.ParameterItemFlags parameterFlags = CommandFlagsDatabase.GetCommandParameterFlags(parentCommand, this); if (((Type != null) && (Type == "GLenum")) || ((parameterFlags & CommandFlagsDatabase.CommandItem.ParameterItemFlags.LogAsEnum) != 0)) sw.Write("LogEnumName({0})", ImplementationName); else if (IsManagedArray && GetImplementationTypeModifier(ctx, parentCommand) != "out") sw.Write("LogValue({0})", ImplementationName); else WriteCallLogArgParam(sw, ImplementationName, GetImplementationType(ctx, parentCommand)); }
public override void WriteCallLogArgParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (IsArrayLengthParameter(this, ctx, parentCommand)) { int arrayLengthParamIndex = parentCommand.Parameters.FindIndex(delegate(CommandParameter item) { return (parentCommand.Parameters.FindIndex(delegate(CommandParameter subitem) { return (item.Length == Name); }) >= 0); }); sw.Write("{0}.Length", parentCommand.Parameters[arrayLengthParamIndex].DelegateCallVarName); } else base.WriteCallLogArgParam(sw, ctx, parentCommand); }
public override void WriteDelegateParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (IsArrayLengthParameter(this, ctx, parentCommand)) { int arrayLengthParamIndex = parentCommand.Parameters.FindIndex(delegate(CommandParameter item) { return (parentCommand.Parameters.FindIndex(delegate(CommandParameter subitem) { return (item.Length == Name); }) >= 0); }); if (OverridenParameter.ImportType != "int") sw.Write("({0})", OverridenParameter.ImportType); sw.Write("{0}.Length", parentCommand.Parameters[arrayLengthParamIndex].DelegateCallVarName); } else if (mIsStrong) { // Strongly typed enum must be casted to delegate call type (int or uint) sw.Write("({0}){1}", OverridenParameter.ImportType, DelegateCallVarName); } else base.WriteDelegateParam(sw, ctx, parentCommand); }
/// <summary> /// Generate the command implementation signature and the method documentation. /// </summary> /// <param name="sw"> /// The <see cref="SourceStreamWriter"/> used to write the source code. /// </param> /// <param name="ctx"> /// The <see cref="RegistryContext"/> defining the OpenGL registry information. /// </param> /// <param name="commandParams"> /// A <see cref="T:List{CommandParameter}"/> determining the method overload. /// </param> private void GenerateImplementation_Signature(SourceStreamWriter sw, RegistryContext ctx, List <CommandParameter> commandParams, string implementationName, string returnType) { #if !DEBUG // Documentation RegistryDocumentation.GenerateDocumentation(sw, ctx, this, commandParams); #endif foreach (IFeature feature in RequiredBy) { sw.WriteLine("[RequiredByFeature(\"{0}\")]", feature.Name); } foreach (IFeature feature in RemovedBy) { sw.WriteLine("[RemovedByFeature(\"{0}\")]", feature.Name); } #region Signature sw.WriteIdentation(); // Signature sw.Write("{0} static ", CommandFlagsDatabase.GetCommandVisibility(this)); if (IsUnsafeImplementationSignature(ctx, commandParams)) { sw.Write("unsafe "); } sw.Write("{0} {1}(", returnType, implementationName); // Signature - Parameters int paramCount = commandParams.FindAll(delegate(CommandParameter item) { return(!item.IsImplicit(ctx, this)); }).Count; foreach (CommandParameter param in commandParams) { // Skip in signature implicit parameters if (param.IsImplicit(ctx, this)) { continue; } string paramAttributes = param.GetImplementationTypeAttributes(ctx, this); string paramModifier = param.GetImplementationTypeModifier(ctx, this); if (paramAttributes != null) { sw.Write("{0} ", paramAttributes); } if (paramModifier != null) { sw.Write("{0} ", paramModifier); } if ((paramCount == 1) && (param.IsManagedArray) && ((Flags & CommandFlags.VariadicParams) != 0)) { sw.Write("params "); } sw.Write("{0} {1}", param.GetImplementationType(ctx, this), param.ImplementationName); paramCount--; if (paramCount > 0) { sw.Write(", "); } } sw.Write(")"); sw.WriteLine(); #endregion }
/// <summary> /// Generate the C# source code for this enumerant. /// </summary> /// <param name="sw"> /// A <see cref="SourceStreamWriter"/> used for writing the source code. /// </param> internal void GenerateSource(SourceStreamWriter sw, RegistryContext ctx) { if (sw == null) throw new ArgumentNullException("sw"); RegistryDocumentation.GenerateDocumentation(sw, ctx, this); foreach (Enumerant aliasOf in AliasOf) sw.WriteLine("[AliasOf(\"{0}\")]", aliasOf.Name); foreach (IFeature feature in RequiredBy) sw.WriteLine("[RequiredByFeature(\"{0}\")]", feature.Name); foreach (Enumerant aliasOf in AliasOf) { foreach (IFeature feature in aliasOf.RequiredBy) sw.WriteLine("[RequiredByFeature(\"{0}\")]", feature.Name); } foreach (IFeature feature in RemovedBy) sw.WriteLine("[RemovedByFeature(\"{0}\")]", feature.Name); // This metadata is used for procedure logging function bool requiresLogAttribute = ParentEnumerantBlock.Type == "bitmask"; if (requiresLogAttribute == true) { if (ParentEnumerantBlock.Type == "bitmask") sw.WriteLine("[Log(BitmaskName = \"{0}\")]", ParentEnumerantBlock.Namespace); } if (IsDeprecated) { sw.Write("#if DEBUG && !OPENGL_NET_COMPATIBILITY_PROFILE" + Environment.NewLine); sw.WriteLine("[Obsolete(\"Deprecated/removed by {0}.\")]", SpecificationStyle.GetKhronosVersionHumanReadable(RemovedBy[0].Name)); sw.Write("#endif" + Environment.NewLine); } sw.WriteLine(Declaration); }
/// <summary> /// Generate the command implementation (fixed variant). /// </summary> /// <param name="sw"> /// The <see cref="SourceStreamWriter"/> used to write the source code. /// </param> /// <param name="ctx"> /// The <see cref="RegistryContext"/> defining the OpenGL registry information. /// </param> /// <param name="commandParams"> /// A <see cref="T:List{CommandParameter}"/> determining the method overload. /// </param> private void GenerateImplementation_Default(SourceStreamWriter sw, RegistryContext ctx, List <CommandParameter> commandParams) { List <Command> aliases = new List <Command>(); Command aliasCommand = this; // The implementation returned type string returnType = aliasCommand.GetImplementationReturnType(ctx); // Is fixed implementation bool fixedImplementation = IsFixedImplementation(ctx, commandParams); aliases.Add(this); aliases.AddRange(Aliases); // Signature GenerateImplementation_Signature(sw, ctx, commandParams); // Implementation block sw.WriteLine("{"); sw.Indent(); #region Debug Assertions // Debug assertions foreach (CommandParameter param in commandParams) { param.WriteDebugAssertion(sw, ctx, this); } #endregion #region Local Variables // Local variable: returned value if (HasReturnValue) { sw.WriteLine("{0} {1};", DelegateReturnType, ReturnVariableName); sw.WriteLine(); } #endregion #region Unsafe Block (Open) if (fixedImplementation) { sw.WriteLine("unsafe {"); // (1) sw.Indent(); foreach (CommandParameter param in commandParams) { param.WriteFixedStatement(sw, ctx, this); } sw.WriteLine("{"); // (2) sw.Indent(); } #endregion sw.WriteLine("Debug.Assert(Delegates.{0} != null, \"{0} not implemented\");", aliasCommand.DelegateName); #region Delegate Call sw.WriteIdentation(); // Local return value if (HasReturnValue) { sw.Write("{0} = ", ReturnVariableName); } sw.Write("Delegates.{0}(", aliasCommand.DelegateName); #region Parameters for (int i = 0; i < commandParams.Count; i++) { CommandParameter param = commandParams[i]; param.WriteDelegateParam(sw, ctx, this); if (i != Parameters.Count - 1) { sw.Write(", "); } } #endregion sw.Write(")"); sw.Write(";"); sw.WriteLine(); #endregion #region Call Log sw.WriteIdentation(); sw.Write("LogFunction("); #region Call Log - Format String sw.Write("\"{0}(", aliasCommand.ImportName); for (int i = 0; i < commandParams.Count; i++) { commandParams[i].WriteCallLogFormatParam(sw, ctx, this, i); if (i < commandParams.Count - 1) { sw.Write(", "); } } sw.Write(")"); if (HasReturnValue) { sw.Write(" = {{{0}}}", commandParams.Count); } sw.Write("\""); #endregion #region Call Log - Format Arguments if ((commandParams.Count > 0) || HasReturnValue) { sw.Write(", "); for (int i = 0; i < commandParams.Count; i++) { commandParams[i].WriteCallLogArgParam(sw, ctx, this); if (i < commandParams.Count - 1) { sw.Write(", "); } } } // Return value if (HasReturnValue) { if (commandParams.Count > 0) { sw.Write(", "); } CommandParameter.WriteCallLogArgParam(sw, GetReturnValueExpression(ctx), returnType); } #endregion sw.Write(");"); sw.WriteLine(); #endregion #region Unsafe Block (Close) if (fixedImplementation) { sw.Unindent(); sw.WriteLine("}"); // (2) CLOSED sw.Unindent(); sw.WriteLine("}"); // (1) CLOSED } #endregion // Check call errors if ((Flags & CommandFlags.NoGetError) == 0) { string returnValue = "null"; // Optionally pass the returned value to error checking method if (HasReturnValue) { returnValue = ReturnVariableName; } sw.WriteLine("DebugCheckErrors({0});", returnValue); } // Returns value if (HasReturnValue) { sw.WriteLine(); sw.WriteLine("return ({0});", GetReturnValueExpression(ctx)); } sw.Unindent(); sw.WriteLine("}"); }
/// <summary> /// Generate the command implementation (pinned variant). /// </summary> /// <param name="sw"> /// The <see cref="SourceStreamWriter"/> used to write the source code. /// </param> /// <param name="ctx"> /// The <see cref="RegistryContext"/> defining the OpenGL registry information. /// </param> /// <param name="commandParams"> /// A <see cref="T:List{CommandParameter}"/> determining the method overload. /// </param> private void GenerateImplementation_Pinned(SourceStreamWriter sw, RegistryContext ctx, List <CommandParameter> commandParams) { // Signature GenerateImplementation_Signature(sw, ctx, commandParams); // Implementation block sw.WriteLine("{"); sw.Indent(); #region Pinned Object Block (Open) foreach (CommandParameter param in commandParams) { param.WritePinnedVariable(sw, ctx, this); } sw.WriteLine("try {"); sw.Indent(); #endregion #region Implementation Call sw.WriteIdentation(); if (HasReturnValue) { sw.Write("return ("); } sw.Write("{0}(", GetImplementationName(ctx)); #region Parameters for (int i = 0; i < commandParams.Count; i++) { CommandParameter param = commandParams[i]; param.WriteDelegateParam(sw, ctx, this); if (i != commandParams.Count - 1) { sw.Write(", "); } } #endregion sw.Write(")"); if (HasReturnValue) { sw.Write(")"); } sw.Write(";"); sw.WriteLine(); #endregion #region Pinned Object Block (Close) sw.Unindent(); sw.WriteLine("} finally {"); sw.Indent(); foreach (CommandParameter param in commandParams) { param.WriteUnpinCommand(sw, ctx, this); } sw.Unindent(); sw.WriteLine("}"); #endregion sw.Unindent(); sw.WriteLine("}"); }
/// <summary> /// Generate the command delegate source code. /// </summary> /// <param name="sw"> /// The <see cref="SourceStreamWriter"/> used to write the source code. /// </param> /// <param name="ctx"> /// The <see cref="RegistryContext"/> defining the OpenGL registry information. /// </param> internal void GenerateDelegate(SourceStreamWriter sw, RegistryContext ctx) { if (Aliases.Count > 0) { sw.WriteLine("[AliasOf(\"{0}\")]", ImportName); foreach (Command aliasOf in Aliases) sw.WriteLine("[AliasOf(\"{0}\")]", aliasOf.ImportName); } // No sure if it is really necessary sw.WriteLine("[SuppressUnmanagedCodeSecurity()]"); // Delegate type definition sw.WriteIdentation(); sw.Write("internal "); if (IsSafeImplementation == false) sw.Write("unsafe "); sw.Write("delegate "); sw.Write("{0} {1}(", DelegateReturnType, ImportName); int paramCount = Parameters.Count; foreach (CommandParameter param in Parameters) { string paramAttributes = param.GetDelegateTypeAttributes(ctx, this); string paramModifier = param.GetDelegateTypeModifier(ctx, this); if (paramAttributes != null) sw.Write("{0} ", paramAttributes); if (paramModifier != null) sw.Write("{0} ", paramModifier); sw.Write("{0} {1}", param.GetDelegateType(ctx, this), param.ImportName); paramCount--; if (paramCount > 0) sw.Write(", "); } sw.Write(");"); sw.WriteLine(); // Required on Windows platform: different threads can bind different OpenGL context, which can have different // entry points sw.WriteLine("[ThreadStatic]"); // Delegate field sw.WriteLine("internal static {0} {1};", ImportName, DelegateName); }