public virtual void WriteDebugAssertion(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { switch (LengthMode) { case CommandParameterLengthMode.Constant: // Note: // - The argument must be an Array instance if (IsManagedArray(ctx, parentCommand)) { sw.WriteLine("Debug.Assert({0}.Length >= {1});", ImplementationName, LengthConstant); } break; case CommandParameterLengthMode.ArgumentMultiple: uint multiple = LengthMultiple; // Note: // - The array must provide 'n' elements for each unit in counter parameter if (IsManagedArray(ctx, parentCommand) && multiple > 1) { sw.WriteLine("Debug.Assert({0}.Length > 0 && ({0}.Length % {1}) == 0, \"empty or not multiple of {1}\");", ImplementationName, multiple); } break; } }
internal void GenerateDocumentation(SourceStreamWriter sw, RegistryContext ctx) { if (ctx.RefPages.Count > 0) { ctx.RefPages.GenerateDocumentation(sw, ctx, this); } }
/// <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(nameof(sw)); } GenerateDocumentation(sw, ctx); GenerateRequirements(sw, ctx); // 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 override void WritePinnedVariable(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (GetImplementationType(ctx, parentCommand) == "Object") { sw.WriteLine("GCHandle {0} = GCHandle.Alloc({1}, GCHandleType.Pinned);", PinnedLocalVarName, 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 override void WriteUnpinCommand(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (GetImplementationType(ctx, parentCommand) == "Object") { sw.WriteLine("{0}.Free();", PinnedLocalVarName); } }
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); } }
/// <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 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)); }
/// <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"); } if (ctx.RefPages.Count > 0) { ctx.RefPages.GenerateDocumentation(sw, ctx, this); } foreach (Enumerant aliasOf in AliasOf) { sw.WriteLine("[AliasOf(\"{0}\")]", aliasOf.Name); } string classDefaultApi = ctx.Class.ToLower(); foreach (IFeature feature in RequiredBy) { sw.WriteLine(feature.GetRequiredByFeature(classDefaultApi)); } foreach (Enumerant aliasOf in AliasOf) // Note: not sure that Profile is considered here { foreach (IFeature feature in aliasOf.RequiredBy) { sw.WriteLine(feature.GetRequiredByFeature(classDefaultApi)); } } foreach (IFeature feature in RemovedBy) { sw.WriteLine(feature.GetRemovedByFeature(classDefaultApi)); } // 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 virtual void WriteDelegateParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (IsFixed(ctx, parentCommand) == false) { sw.Write(DelegateCallVarName); } 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 (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); } }
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); } }
/// <summary> /// Generate the command implementation 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> /// <param name="commandParams"> /// A <see cref="T:List{CommandParameter}"/> determining the method overload. /// </param> private void GenerateImplementation(SourceStreamWriter sw, RegistryContext ctx, List <CommandParameter> commandParams) { bool isPinnedImplementation = commandParams.FindIndex(delegate(CommandParameter item) { return(item is CommandParameterPinned); }) >= 0; if (!isPinnedImplementation) { GenerateImplementation_Default(sw, ctx, commandParams); } else { GenerateImplementation_Pinned(sw, ctx, commandParams); } }
/// <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 (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 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 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 virtual void WriteDebugAssertion(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (Length == null) { return; } if (CommandParameterArrayLength.IsCompatible(ctx, parentCommand, this)) { sw.WriteLine("Debug.Assert({0}.Length >= {1});", ImplementationName, Length); } #if false if (Regex.IsMatch(Length, @"[0-9]+")) { sw.WriteLine("Debug.Assert({0}.Length >= {1});", ImplementationName, Length); } #endif }
public virtual void WriteFixedStatement(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (IsFixed(ctx, parentCommand) == false) { return; } string dereference = String.Empty; switch (GetImplementationTypeModifier(ctx, parentCommand)) { case "out": case "ref": dereference = "&"; break; } sw.WriteLine("fixed ({0} {1} = {2}{3})", ImportType, FixedLocalVarName, dereference, ImplementationName); }
internal void GenerateRequirements(SourceStreamWriter sw, RegistryContext ctx) { string classDefaultApi = ctx.Class.ToLower(); List <IFeature> requiredByFeatures = RequiredBy; foreach (Enumerant aliasOf in AliasOf) { requiredByFeatures = requiredByFeatures.Union(aliasOf.RequiredBy).ToList(); } foreach (IFeature feature in requiredByFeatures) { sw.WriteLine(feature.GenerateRequiredByAttribute(null, classDefaultApi)); } foreach (IFeature feature in RemovedBy) { sw.WriteLine(feature.GenerateRemovedByAttribute(classDefaultApi)); } }
/// <summary> /// Generate the command implementations source code (all overloads). /// </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 GenerateImplementations(SourceStreamWriter sw, RegistryContext ctx) { List <CommandParameter>[] overridenParams = GetOverridenImplementations(ctx); for (int i = 0; i < overridenParams.Length; i++) { // Generate implementation GenerateImplementation(sw, ctx, overridenParams[i]); // Separate next implementation with a new line, if not the last if (i < overridenParams.Length - 1) { sw.WriteLine(); } } if (IsGenImplementation(ctx)) { sw.WriteLine(); GenerateImplementation_GenOneObject(sw, ctx); } }
public virtual void WritePinnedVariable(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { // No code for common parameter }
internal void GenerateSource(SourceStreamWriter sw, RegistryContext ctx) { if (sw == null) throw new ArgumentNullException("sw"); if (ctx == null) throw new ArgumentNullException("ctx"); bool bitmask = Enums.TrueForAll(delegate(Enumerant item) { Enumerant actualEnumerant = ctx.Registry.GetEnumerant(item.Name); return (actualEnumerant == null || actualEnumerant.ParentEnumerantBlock.Type == "bitmask"); }); // Collect group enumerants by their value Dictionary<string, List<Enumerant>> groupEnums = new Dictionary<string, List<Enumerant>>(); // ...include all enums defined in this group foreach (Enumerant item in Enums) { Enumerant itemValue = ctx.Registry.GetEnumerant(item.Name); if (itemValue != null) { if (!groupEnums.ContainsKey(itemValue.Value)) groupEnums.Add(itemValue.Value, new List<Enumerant>()); groupEnums[itemValue.Value].Add(itemValue); } } // Modify canonical enumeration (value/block/group) definition CommandFlagsDatabase.EnumerantItem enumerantExtension = CommandFlagsDatabase.FindEnumerant(Name); if (enumerantExtension != null) { // ...override group information if (enumerantExtension.Type != null) { switch (enumerantExtension.Type) { case "bitmask": bitmask = true; break; } } // ...include all enums to be added by additional configuration foreach (string addedEnum in enumerantExtension.AddEnumerants) { Enumerant addedEnumValue = ctx.Registry.GetEnumerant(addedEnum); if (addedEnumValue != null) { if (!groupEnums.ContainsKey(addedEnumValue.Value)) groupEnums.Add(addedEnumValue.Value, new List<Enumerant>()); // Note: since specification can be updated while the CommandFlags.xml is not in synch, the specification // may defined missed enumerant values. In this case do not add enumerant value if (groupEnums[addedEnumValue.Value].Contains(addedEnumValue) == false) groupEnums[addedEnumValue.Value].Add(addedEnumValue); } } } // Make enumerants distinct (discard duplicated enumerants, mainly from extensions _ARB, _EXT, ...) List<Enumerant> uniqueEnums = new List<Enumerant>(); foreach (KeyValuePair<string, List<Enumerant>> pair in groupEnums) { if (pair.Value.Count > 1) { Enumerant shorterNameEnum = null; foreach (Enumerant item in pair.Value) { if ((shorterNameEnum == null) || (shorterNameEnum.Name.Length > item.Name.Length)) shorterNameEnum = item; } uniqueEnums.Add(shorterNameEnum); } else uniqueEnums.Add(pair.Value[0]); } sw.WriteLine("/// <summary>"); sw.WriteLine("/// Strongly typed enumeration {0}.", Name); sw.WriteLine("/// </summary>"); if (bitmask) sw.WriteLine("[Flags()]"); sw.WriteLine("public enum {0}{1}", Name, bitmask ? " : uint" : String.Empty); sw.WriteLine("{"); sw.Indent(); foreach (Enumerant enumerant in uniqueEnums) { List<Enumerant> allEnums = groupEnums[enumerant.Value]; string bindingName = enumerant.EnumAlias == null ? enumerant.ImplementationName : enumerant.EnumAlias.ImplementationName; string camelCase = SpecificationStyle.GetCamelCase(bindingName); sw.WriteLine("/// <summary>"); if (allEnums.Count > 1) { StringBuilder sb = new StringBuilder(); sb.Append("Strongly typed for value "); for (int i = 0; i < allEnums.Count; i++) { sb.Append(allEnums[i].Name); if (i < allEnums.Count - 1) sb.Append(", "); } sb.Append("."); foreach (string docLine in RegistryDocumentation.SplitDocumentationLines(sb.ToString())) sw.WriteLine("/// {0}", docLine); } else sw.WriteLine("/// Strongly typed for value {0}.", enumerant.Name); sw.WriteLine("/// </summary>"); sw.WriteLine("{0} = Gl.{1},", camelCase, bindingName); sw.WriteLine(); } 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("}"); }
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 override void WritePinnedVariable(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (GetImplementationType(ctx, parentCommand) == "Object") sw.WriteLine("GCHandle {0} = GCHandle.Alloc({1}, GCHandleType.Pinned);", PinnedLocalVarName, ImplementationName); }
/// <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 (_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 (_IsPointer == true) { // Writer plain variable name sw.Write(DelegateCallVarName); } else base.WriteDelegateParam(sw, 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); }
/// <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) { GenerateImplementation_Signature(sw, ctx, commandParams, GetImplementationName(ctx), GetImplementationReturnType(ctx)); }
/// <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 virtual void WriteUnpinCommand(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { // No code for common parameter }
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); }
public override void WriteDebugAssertion(SourceStreamWriter sw, RegistryContext ctx, Command 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("}"); }
public virtual void WriteDebugAssertion(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (Length == null) return; if (CommandParameterArray.IsCompatible(this, ctx, parentCommand)) sw.WriteLine("Debug.Assert({0}.Length >= {1});", ImplementationName, Length); #if false if (Regex.IsMatch(Length, @"[0-9]+")) sw.WriteLine("Debug.Assert({0}.Length >= {1});", ImplementationName, Length); #endif }
/// <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(); }
internal void GenerateSource(SourceStreamWriter sw, RegistryContext ctx) { if (sw == null) throw new ArgumentNullException("sw"); if (ctx == null) throw new ArgumentNullException("ctx"); bool bitmask = Enums.TrueForAll(delegate(Enumerant item) { Enumerant actualEnumerant = ctx.Registry.GetGlEnumerant(item.Name); return (actualEnumerant == null || actualEnumerant.ParentEnumerantBlock.Type == "bitmask"); }); // Collect group enumerants by their value Dictionary<string, List<Enumerant>> groupEnums = new Dictionary<string, List<Enumerant>>(); foreach (Enumerant item in Enums) { Enumerant itemValue = ctx.Registry.GetGlEnumerant(item.Name); if (itemValue != null) { if (!groupEnums.ContainsKey(itemValue.Value)) groupEnums.Add(itemValue.Value, new List<Enumerant>()); groupEnums[itemValue.Value].Add(itemValue); } } // Make enumerants distinct (discard duplicated enumerants, mainly from extensions) List<Enumerant> uniqueEnums = new List<Enumerant>(); foreach (KeyValuePair<string, List<Enumerant>> pair in groupEnums) { if (pair.Value.Count > 1) { Enumerant shortedNameEnum = null; foreach (Enumerant item in pair.Value) { if ((shortedNameEnum == null) || (shortedNameEnum.Name.Length > item.Name.Length)) shortedNameEnum = item; } uniqueEnums.Add(shortedNameEnum); } else uniqueEnums.Add(pair.Value[0]); } sw.WriteLine("/// <summary>"); sw.WriteLine("/// Strongly typed enumeration {0}.", Name); sw.WriteLine("/// </summary>"); if (bitmask) sw.WriteLine("[Flags()]"); sw.WriteLine("public enum {0}{1}", Name, bitmask ? " : uint" : String.Empty); sw.WriteLine("{"); sw.Indent(); foreach (Enumerant enumerant in uniqueEnums) { List<Enumerant> allEnums = groupEnums[enumerant.Value]; string bindingName = enumerant.EnumAlias == null ? enumerant.ImplementationName : enumerant.EnumAlias.ImplementationName; string camelCase = SpecificationStyle.GetCamelCase(bindingName); sw.WriteLine("/// <summary>"); if (allEnums.Count > 1) { StringBuilder sb = new StringBuilder(); sb.Append("Strongly typed for value "); for (int i = 0; i < allEnums.Count; i++) { sb.Append(allEnums[i].Name); if (i < allEnums.Count - 1) sb.Append(", "); } sb.Append("."); foreach (string docLine in RegistryDocumentation.SplitDocumentationLines(sb.ToString())) sw.WriteLine("/// {0}", docLine); } else sw.WriteLine("/// Strongly typed for value {0}.", enumerant.Name); sw.WriteLine("/// </summary>"); sw.WriteLine("{0} = Gl.{1},", camelCase, bindingName); sw.WriteLine(); } sw.Unindent(); sw.WriteLine("}"); }
/// <summary> /// Generate the command implementation 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> /// <param name="commandParams"> /// A <see cref="T:List{CommandParameter}"/> determining the method overload. /// </param> private void GenerateImplementation(SourceStreamWriter sw, RegistryContext ctx, List<CommandParameter> commandParams) { bool isPinnedImplementation = commandParams.FindIndex(delegate(CommandParameter item) { return (item is CommandParameterPinned); }) >= 0; if (!isPinnedImplementation) GenerateImplementation_Default(sw, ctx, commandParams); else GenerateImplementation_Pinned(sw, ctx, commandParams); }
internal void GenerateSource(SourceStreamWriter sw, RegistryContext ctx) { if (sw == null) { throw new ArgumentNullException("sw"); } if (ctx == null) { throw new ArgumentNullException("ctx"); } bool bitmask = Enums.TrueForAll(delegate(Enumerant item) { Enumerant actualEnumerant = ctx.Registry.GetEnumerant(item.Name); return(actualEnumerant == null || actualEnumerant.ParentEnumerantBlock.Type == "bitmask"); }); // Collect group enumerants by their value Dictionary <string, List <Enumerant> > groupEnums = new Dictionary <string, List <Enumerant> >(); // ...include all enums defined in this group foreach (Enumerant item in Enums) { Enumerant itemValue = ctx.Registry.GetEnumerant(item.Name); if (itemValue != null) { if (!groupEnums.ContainsKey(itemValue.Value)) { groupEnums.Add(itemValue.Value, new List <Enumerant>()); } groupEnums[itemValue.Value].Add(itemValue); } } // Modify canonical enumeration (value/block/group) definition CommandFlagsDatabase.EnumerantItem enumerantExtension = CommandFlagsDatabase.FindEnumerant(Name); if (enumerantExtension != null) { // ...override group information if (enumerantExtension.Type != null) { switch (enumerantExtension.Type) { case "bitmask": bitmask = true; break; } } // ...include all enums to be added by additional configuration foreach (string addedEnum in enumerantExtension.AddEnumerants) { Enumerant addedEnumValue = ctx.Registry.GetEnumerant(addedEnum); if (addedEnumValue != null) { if (!groupEnums.ContainsKey(addedEnumValue.Value)) { groupEnums.Add(addedEnumValue.Value, new List <Enumerant>()); } // Note: since specification can be updated while the CommandFlags.xml is not in synch, the specification // may defined missed enumerant values. In this case do not add enumerant value if (groupEnums[addedEnumValue.Value].Contains(addedEnumValue) == false) { groupEnums[addedEnumValue.Value].Add(addedEnumValue); } } } } // Make enumerants distinct (discard duplicated enumerants, mainly from extensions _ARB, _EXT, ...) List <Enumerant> uniqueEnums = new List <Enumerant>(); foreach (KeyValuePair <string, List <Enumerant> > pair in groupEnums) { if (pair.Value.Count > 1) { List <Enumerant> uniqueNames = new List <Enumerant>(); foreach (Enumerant item in pair.Value) { if (item.Alias != null) { continue; } if (item.EnumAlias != null) { continue; } if (uniqueNames.FindIndex(delegate(Enumerant item1) { return(item.Name.StartsWith(item1.Name)); }) >= 0) { continue; } if (uniqueNames.FindIndex(delegate(Enumerant item1) { return(item1.Name.StartsWith(item.Name)); }) >= 0) { uniqueNames.RemoveAll(delegate(Enumerant item1) { return(item1.Name.StartsWith(item.Name)); }); } uniqueNames.Add(item); } uniqueEnums.AddRange(uniqueNames); } else { uniqueEnums.AddRange(pair.Value); } } sw.WriteLine("/// <summary>"); sw.WriteLine("/// Strongly typed enumeration {0}.", Name); sw.WriteLine("/// </summary>"); if (bitmask) { sw.WriteLine("[Flags()]"); } sw.WriteLine("public enum {0}{1}", Name, bitmask ? " : uint" : String.Empty); sw.WriteLine("{"); sw.Indent(); foreach (Enumerant enumerant in uniqueEnums) { List <Enumerant> allEnums = groupEnums[enumerant.Value]; string bindingName = enumerant.EnumAlias == null ? enumerant.ImplementationName : enumerant.EnumAlias.ImplementationName; string camelCase = SpecificationStyle.GetCamelCase(bindingName); if (enumerantExtension != null && enumerantExtension.ItemPrefix != null && camelCase.StartsWith(enumerantExtension.ItemPrefix)) { camelCase = camelCase.Substring(enumerantExtension.ItemPrefix.Length); } sw.WriteLine("/// <summary>"); if (allEnums.Count > 1) { StringBuilder sb = new StringBuilder(); sb.Append("Strongly typed for value "); for (int i = 0; i < allEnums.Count; i++) { sb.Append(allEnums[i].Name); if (i < allEnums.Count - 1) { sb.Append(", "); } } sb.Append("."); foreach (string docLine in RegistryDocumentation.SplitDocumentationLines(sb.ToString())) { sw.WriteLine("/// {0}", docLine); } } else { sw.WriteLine("/// Strongly typed for value {0}.", enumerant.Name); } sw.WriteLine("/// </summary>"); Enumerant enumvalue = ctx.Registry.GetEnumerant(ctx.Class.ToUpperInvariant() + "_" + bindingName); string classDefaultApi = ctx.Class.ToLower(); if (enumvalue != null) { // RequiredByFeature foreach (IFeature feature in enumvalue.RequiredBy) { sw.WriteLine(feature.GenerateRequiredByAttribute(null, classDefaultApi)); } // RequiredByFeature (from aliases) Note: not sure that Profile is considered here foreach (Enumerant aliasOf in enumvalue.AliasOf) { foreach (IFeature feature in aliasOf.RequiredBy) { sw.WriteLine(feature.GenerateRequiredByAttribute(null, classDefaultApi)); } } // RemovedByFeature foreach (IFeature feature in enumvalue.RemovedBy) { sw.WriteLine(feature.GenerateRemovedByAttribute(classDefaultApi)); } } sw.WriteLine("{0} = {1}.{2},", camelCase, ctx.Class, bindingName); sw.WriteLine(); } sw.Unindent(); sw.WriteLine("}"); }
public override void WriteUnpinCommand(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (GetImplementationType(ctx, parentCommand) == "Object") sw.WriteLine("{0}.Free();", PinnedLocalVarName); }
internal void GenerateSource(SourceStreamWriter sw, RegistryContext ctx) { if (sw == null) { throw new ArgumentNullException("sw"); } if (ctx == null) { throw new ArgumentNullException("ctx"); } bool bitmask = Enums.TrueForAll(delegate(Enumerant item) { Enumerant actualEnumerant = ctx.Registry.GetEnumerant(item.Name); return(actualEnumerant == null || actualEnumerant.ParentEnumerantBlock.Type == "bitmask"); }); // Collect group enumerants by their value Dictionary <string, List <Enumerant> > groupEnums = new Dictionary <string, List <Enumerant> >(); // ...include all enums defined in this group foreach (Enumerant item in Enums) { Enumerant itemValue = ctx.Registry.GetEnumerant(item.Name); if (itemValue != null) { if (!groupEnums.ContainsKey(itemValue.Value)) { groupEnums.Add(itemValue.Value, new List <Enumerant>()); } groupEnums[itemValue.Value].Add(itemValue); } } // Modify canonical enumeration (value/block/group) definition CommandFlagsDatabase.EnumerantItem enumerantExtension = CommandFlagsDatabase.FindEnumerant(Name); if (enumerantExtension != null) { // ...override group information if (enumerantExtension.Type != null) { switch (enumerantExtension.Type) { case "bitmask": bitmask = true; break; } } // ...include all enums to be added by additional configuration foreach (string addedEnum in enumerantExtension.AddEnumerants) { Enumerant addedEnumValue = ctx.Registry.GetEnumerant(addedEnum); if (addedEnumValue != null) { if (!groupEnums.ContainsKey(addedEnumValue.Value)) { groupEnums.Add(addedEnumValue.Value, new List <Enumerant>()); } // Note: since specification can be updated while the CommandFlags.xml is not in synch, the specification // may defined missed enumerant values. In this case do not add enumerant value if (groupEnums[addedEnumValue.Value].Contains(addedEnumValue) == false) { groupEnums[addedEnumValue.Value].Add(addedEnumValue); } } } } // Make enumerants distinct (discard duplicated enumerants, mainly from extensions _ARB, _EXT, ...) List <Enumerant> uniqueEnums = new List <Enumerant>(); foreach (KeyValuePair <string, List <Enumerant> > pair in groupEnums) { if (pair.Value.Count > 1) { Enumerant shorterNameEnum = null; foreach (Enumerant item in pair.Value) { if ((shorterNameEnum == null) || (shorterNameEnum.Name.Length > item.Name.Length)) { shorterNameEnum = item; } } uniqueEnums.Add(shorterNameEnum); } else { uniqueEnums.Add(pair.Value[0]); } } sw.WriteLine("/// <summary>"); sw.WriteLine("/// Strongly typed enumeration {0}.", Name); sw.WriteLine("/// </summary>"); if (bitmask) { sw.WriteLine("[Flags()]"); } sw.WriteLine("public enum {0}{1}", Name, bitmask ? " : uint" : String.Empty); sw.WriteLine("{"); sw.Indent(); foreach (Enumerant enumerant in uniqueEnums) { List <Enumerant> allEnums = groupEnums[enumerant.Value]; string bindingName = enumerant.EnumAlias == null ? enumerant.ImplementationName : enumerant.EnumAlias.ImplementationName; string camelCase = SpecificationStyle.GetCamelCase(bindingName); sw.WriteLine("/// <summary>"); if (allEnums.Count > 1) { StringBuilder sb = new StringBuilder(); sb.Append("Strongly typed for value "); for (int i = 0; i < allEnums.Count; i++) { sb.Append(allEnums[i].Name); if (i < allEnums.Count - 1) { sb.Append(", "); } } sb.Append("."); foreach (string docLine in RegistryDocumentation.SplitDocumentationLines(sb.ToString())) { sw.WriteLine("/// {0}", docLine); } } else { sw.WriteLine("/// Strongly typed for value {0}.", enumerant.Name); } sw.WriteLine("/// </summary>"); sw.WriteLine("{0} = Gl.{1},", camelCase, bindingName); sw.WriteLine(); } sw.Unindent(); sw.WriteLine("}"); }
/// <summary> /// Generate the command implementations source code (all overloads). /// </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 GenerateImplementations(SourceStreamWriter sw, RegistryContext ctx) { List<CommandParameter>[] overridenParams = GetOverridenImplementations(ctx); for (int i = 0; i < overridenParams.Length; i++) { // Generate implementation GenerateImplementation(sw, ctx, overridenParams[i]); // Separate next implementation with a new line, if not the last if (i < overridenParams.Length - 1) sw.WriteLine(); } if (IsGenImplementation(ctx)) { sw.WriteLine(); GenerateImplementation_GenOneObject(sw, ctx); } }
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 virtual void WriteFixedStatement(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (IsFixed(ctx, parentCommand) == false) return; string dereference = String.Empty; switch (GetImplementationTypeModifier(ctx, parentCommand)) { case "out": case "ref": dereference = "&"; break; } sw.WriteLine("fixed ({0} {1} = {2}{3})", ImportType, FixedLocalVarName, dereference, ImplementationName); }
/// <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("}"); }
public virtual void WriteDelegateParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { if (IsFixed(ctx, parentCommand) == false) { sw.Write(DelegateCallVarName); } else sw.Write(FixedLocalVarName); }
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 virtual void WriteCallLogArgParam(SourceStreamWriter sw, RegistryContext ctx, Command parentCommand) { WriteCallLogArgParam(sw, ImplementationName, GetImplementationType(ctx, parentCommand)); }
/// <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); }