static void WriteWrapper(Function f, BindStreamWriter sw)
{
var valid = true;
var generic_parameters = GenerateGenericTypeString(f);
var parameters = GenerateParameterString(f, out valid);
var ret_parameter = GenerateReturnParameterString(f);
if (!valid)
{
return;
}
if (!String.IsNullOrEmpty(generic_parameters))
{
sw.WriteLine("public static <{0}> {1} {2}({3})", generic_parameters,
ret_parameter, f.TrimmedName, parameters);
}
else
{
sw.WriteLine("public static {0} {1}({2})", ret_parameter, f.TrimmedName,
parameters);
}
sw.WriteLine("{");
sw.Indent();
WriteMethodBody(sw, f);
sw.Unindent();
sw.WriteLine("}");
}
public void WriteEnums(BindStreamWriter sw, EnumCollection enums)
{
foreach (Enum @enum in enums.Values)
{
sw.WriteLine("public enum {0}", @enum.Name);
sw.WriteLine("{");
sw.Indent();
int count = @enum.ConstantCollection.Values.Count;
if (count == 0)
{
// Java enums must have at least one value.
sw.WriteLine("None;");
}
else
{
foreach (var c in @enum.ConstantCollection.Values)
{
sw.WriteLine(String.Format("{0}({1}{2}){3}",
c.Name,
!String.IsNullOrEmpty(c.Reference) ? (c.Reference + Settings.NamespaceSeparator) : "",
!String.IsNullOrEmpty(c.Reference) ? c.Value : c.Value.ToLower(),
--count == 0 ? ";" : ","));
}
sw.WriteLine();
sw.WriteLine("{0} mValue;", @enum.Type);
sw.WriteLine("{0}({1} value) {{ mValue = value; }}", @enum.Name, @enum.Type);
}
sw.Unindent();
sw.WriteLine("}");
sw.WriteLine();
}
}
public void WriteImports(BindStreamWriter sw, DelegateCollection delegates)
{
Trace.WriteLine(String.Format("Writing imports to:\t{0}.{1}.{2}", Settings.OutputNamespace, Settings.OutputClass, Settings.ImportsClass));
sw.WriteLine("#pragma warning disable 3019"); // CLSCompliant attribute
sw.WriteLine("#pragma warning disable 1591"); // Missing doc comments
sw.WriteLine();
sw.WriteLine("partial class {0}", Settings.OutputClass);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine();
sw.WriteLine("internal static partial class {0}", Settings.ImportsClass);
sw.WriteLine("{");
sw.Indent();
//sw.WriteLine("static {0}() {1} {2}", Settings.ImportsClass, "{", "}"); // Disable BeforeFieldInit
sw.WriteLine();
foreach (var overloads in delegates.Values)
{
var d = overloads.First(); // generate only 1 DllImport per entry point
sw.WriteLine("[System.Security.SuppressUnmanagedCodeSecurity()]");
sw.WriteLine(
"[System.Runtime.InteropServices.DllImport({0}.Library, EntryPoint = \"{1}{2}\"{3})]",
Settings.OutputClass,
Settings.FunctionPrefix,
d.EntryPoint,
d.EntryPoint.EndsWith("W") || d.EntryPoint.EndsWith("A") ? ", CharSet = CharSet.Auto" : ", ExactSpelling = true"
);
sw.WriteLine("internal extern static {0};", GetDeclarationString(d, false));
}
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.WriteLine("}");
}
public void WriteEnums(BindStreamWriter sw, EnumCollection enums)
{
foreach (Enum @enum in enums.Values)
{
sw.WriteLine("struct {0} : Enumeration<{0}>", @enum.Name);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("inline {0}(int value) : Enumeration<{0}>(value) {{ }}", @enum.Name);
sw.WriteLine("enum");
sw.WriteLine("{");
sw.Indent();
foreach (var c in @enum.ConstantCollection.Values)
{
sw.WriteLine(String.Format("{0} = {1}{2},",
c.Name,
!String.IsNullOrEmpty(c.Reference) ? (c.Reference + Settings.NamespaceSeparator) : "",
!String.IsNullOrEmpty(c.Reference) ? c.Value : c.Value.ToLower()));
}
sw.Unindent();
sw.WriteLine("};");
sw.Unindent();
sw.WriteLine("};");
sw.WriteLine();
}
}
void WriteConstants(BindStreamWriter sw, IEnumerable <Constant> constants)
{
// Make sure everything is sorted. This will avoid random changes between
// consecutive runs of the program.
constants = constants.OrderBy(c => c);
foreach (var c in constants)
{
if (!Settings.IsEnabled(Settings.Legacy.NoDocumentation))
{
sw.WriteLine("/// <summary>");
sw.WriteLine("/// Original was " + Settings.ConstantPrefix + c.OriginalName + " = " + c.Value);
sw.WriteLine("/// </summary>");
}
var str = String.Format("{0} = {1}((int){2}{3})", c.Name, c.Unchecked ? "unchecked" : "",
!String.IsNullOrEmpty(c.Reference) ? c.Reference + Settings.NamespaceSeparator : "", c.Value);
sw.Write(str);
if (!String.IsNullOrEmpty(str))
{
sw.WriteLine(",");
}
}
}
void WriteDefinitions(BindStreamWriter sw,
EnumCollection enums, FunctionCollection wrappers,
IDictionary <string, string> CSTypes)
{
sw.WriteLine("public class {0}", Settings.GLClass);
sw.WriteLine("{");
sw.Indent();
foreach (string extension in wrappers.Keys)
{
if (extension != "Core")
{
sw.WriteLine("public static class {0}", extension);
sw.WriteLine("{");
sw.Indent();
}
// Write wrappers
foreach (var f in wrappers[extension])
{
WriteWrapper(f, sw);
}
if (extension != "Core")
{
sw.Unindent();
sw.WriteLine("}");
}
}
WriteEnums(sw, enums);
sw.Unindent();
sw.WriteLine("}");
}
void WriteDelegates(BindStreamWriter sw, DelegateCollection delegates)
{
Trace.WriteLine(String.Format("Writing delegates to:\t{0}.{1}.{2}", Settings.OutputNamespace, Settings.OutputClass, Settings.DelegatesClass));
sw.WriteLine("#pragma warning disable 3019"); // CLSCompliant attribute
sw.WriteLine("#pragma warning disable 1591"); // Missing doc comments
sw.WriteLine();
sw.WriteLine("partial class {0}", Settings.OutputClass);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("internal static partial class {0}", Settings.DelegatesClass);
sw.WriteLine("{");
sw.Indent();
foreach (Delegate d in delegates.Values)
{
sw.WriteLine("[System.Security.SuppressUnmanagedCodeSecurity()]");
sw.WriteLine("internal {0};", d.ToString());
sw.WriteLine("internal {0}static {1} {2}{1};", // = null
d.Unsafe ? "unsafe " : "",
d.Name,
Settings.FunctionPrefix);
}
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.WriteLine("}");
}
public void WriteTypes(BindStreamWriter sw, Dictionary <string, string> CSTypes)
{
sw.WriteLine();
foreach (string s in CSTypes.Keys)
{
sw.WriteLine("using {0} = System.{1};", s, CSTypes[s]);
}
}
static void WriteMethodBody(BindStreamWriter sw, Function f)
{
//var callstring = f.Parameters.CallString();
//if (f.ReturnType != null && !f.ReturnType.ToString().ToLower().Contains("void"))
// sw.WriteLine("return GLES20.{0}{1};", f.WrappedDelegate.Name, callstring);
//else
// sw.WriteLine("GLES20.{0}{1};", f.WrappedDelegate.Name, callstring);
}
static Delegate WriteInitDelegate(Delegate last_delegate, BindStreamWriter sw, Function f)
{
if (last_delegate != f.WrappedDelegate)
{
sw.WriteLine("Delegates::{0}() = (Delegates::p{0})OpenTK::Internals::GetAddress(\"gl{0}\");", f.WrappedDelegate.Name);
last_delegate = f.WrappedDelegate;
}
return(last_delegate);
}
void WriteWrapper(BindStreamWriter sw, Function f, EnumCollection enums)
{
if ((Settings.Compatibility & Settings.Legacy.NoDocumentation) == 0)
{
WriteDocumentation(sw, f);
}
WriteMethod(sw, f, enums);
sw.WriteLine();
}
void WriteDocumentation(BindStreamWriter sw, Function f)
{
var docs = f.Documentation;
try
{
string warning = "[deprecated: v{0}]";
string category = "[requires: {0}]";
if (f.Deprecated)
{
warning = String.Format(warning, f.DeprecatedVersion);
docs.Summary = docs.Summary.Insert(0, warning);
}
if (f.Extension != "Core" && !String.IsNullOrEmpty(f.Category))
{
category = String.Format(category, f.Category);
docs.Summary = docs.Summary.Insert(0, category);
}
else if (!String.IsNullOrEmpty(f.Version))
{
if (f.Category.StartsWith("VERSION"))
{
category = String.Format(category, "v" + f.Version);
}
else
{
category = String.Format(category, "v" + f.Version + " and " + f.Category);
}
docs.Summary = docs.Summary.Insert(0, category);
}
for (int i = 0; i < f.WrappedDelegate.Parameters.Count; i++)
{
var param = f.WrappedDelegate.Parameters[i];
if (param.ComputeSize != String.Empty)
{
docs.Parameters[i].Documentation.Insert(0,
String.Format("[length: {0}]", param.ComputeSize));
}
}
sw.Write("/// \brief ");
sw.WriteLine(docs.Summary);
foreach (var p in docs.Parameters)
{
sw.Write(@"/// \param ");
sw.Write(p.Name);
sw.WriteLine(p.Documentation);
}
}
catch (Exception e)
{
Console.WriteLine("[Warning] Error documenting function {0}: {1}", f.WrappedDelegate.Name, e.ToString());
}
}
int WriteWrapper(BindStreamWriter sw, int current, Function f)
{
if ((Settings.Compatibility & Settings.Legacy.NoDocumentation) == 0)
{
Console.WriteLine("Creating docs for #{0} ({1})", current++, f.Name);
WriteDocumentation(sw, f);
}
WriteMethod(sw, f);
return(current);
}
void WriteWrappers(BindStreamWriter sw, FunctionCollection wrappers, EnumCollection enums, IDictionary <string, string> CSTypes)
{
Trace.WriteLine(String.Format("Writing wrappers to:\t{0}.{1}", Settings.OutputNamespace, Settings.OutputClass));
sw.WriteLine("#pragma warning disable 3019"); // CLSCompliant attribute
sw.WriteLine("#pragma warning disable 1591"); // Missing doc comments
sw.WriteLine("#pragma warning disable 1572"); // Wrong param comments
sw.WriteLine("#pragma warning disable 1573"); // Missing param comments
sw.WriteLine();
sw.WriteLine("partial class {0}", Settings.OutputClass);
sw.WriteLine("{");
sw.Indent();
//sw.WriteLine("static {0}() {1} {2}", className, "{", "}"); // Static init in GLHelper.cs
sw.WriteLine();
int current = 0;
foreach (string key in wrappers.Keys)
{
if (((Settings.Compatibility & Settings.Legacy.NoSeparateFunctionNamespaces) == Settings.Legacy.None) && key != "Core")
{
if (!Char.IsDigit(key[0]))
{
sw.WriteLine("public static partial class {0}", key);
}
else
{
// Identifiers cannot start with a number:
sw.WriteLine("public static partial class {0}{1}", Settings.ConstantPrefix, key);
}
sw.WriteLine("{");
sw.Indent();
}
wrappers[key].Sort();
foreach (Function f in wrappers[key])
{
current = WriteWrapper(sw, current, f, enums);
}
if (((Settings.Compatibility & Settings.Legacy.NoSeparateFunctionNamespaces) == Settings.Legacy.None) && key != "Core")
{
sw.Unindent();
sw.WriteLine("}");
sw.WriteLine();
}
}
sw.Unindent();
sw.WriteLine("}");
}
int WriteWrapper(BindStreamWriter sw, int current, Function f, EnumCollection enums)
{
if ((Settings.Compatibility & Settings.Legacy.NoDocumentation) == 0)
{
string text = String.Format("Writing function #{0}: {1}", current++, f.ToString());
ConsoleRewrite(text);
WriteDocumentation(sw, f);
}
WriteMethod(sw, f, enums);
sw.WriteLine();
return(current);
}
static void WriteMethodBody(BindStreamWriter sw, Function f)
{
//var callstring = f.Parameters.CallString()
// .Replace("String[]", "String*");
var callstring = GenerateCallString(f);
if (f.ReturnType != null && !f.ReturnType.ToString().ToLower().Contains("void"))
{
sw.Write("return ");
}
sw.WriteLine("Delegates::{0}()({1});", f.WrappedDelegate.Name, callstring);
}
public BindStreamWriter BeginWriteES()
{
_sw2 = new BindStreamWriter(_esGlFile + ".txt");
_sw2.WriteLine("//autogen " + DateTime.Now.ToString("u"));
_sw2.WriteLine("namespace OpenTK.Graphics." + _esNamespaceName + " {");
_sw2.WriteLine(" using System;");
_sw2.WriteLine(" using System.Text;");
_sw2.WriteLine(" using System.Runtime.InteropServices; ");
//
_sw2.WriteLine(" public partial class GL{");
_sw2.WriteLine(" public void LoadAll(){");
_sw2.WriteLine(" GLDelInit.LoadAll();");
_sw2.WriteLine("}");
return(_sw2);
}
static void WriteDelegate(BindStreamWriter sw, Delegate d, ref Delegate last_delegate)
{
// Avoid multiple definitions of the same function
if (d != last_delegate)
{
last_delegate = d;
bool valid = true;
var parameters = GenerateParameterString(d, false, out valid);
sw.WriteLine("typedef {0} (GLPP_APIENTRY *p{1})({2});", d.ReturnType, d.Name, parameters);
sw.WriteLine("inline p{0}& {0}()", d.Name);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("static p{0} address = 0;", d.Name);
sw.WriteLine("return address;");
sw.Unindent();
sw.WriteLine("}");
}
}
private static void WriteMethod(BindStreamWriter sw, Function f)
{
if (f.Deprecated && Settings.IsEnabled(Settings.Legacy.AddDeprecationWarnings))
{
sw.WriteLine("[Obsolete(\"Deprecated in OpenGL {0}\")]", f.DeprecatedVersion);
}
if (!f.CLSCompliant)
{
sw.WriteLine("[System.CLSCompliant(false)]");
}
sw.WriteLine("[AutoGenerated(Category = \"{0}\", Version = \"{1}\", EntryPoint = \"{2}\")]",
f.Category, f.Version, Settings.FunctionPrefix + f.WrappedDelegate.Name);
sw.WriteLine("public static ");
sw.Write(f);
sw.WriteLine();
}
private void WriteMethod(BindStreamWriter sw, Function f, EnumCollection enums)
{
if (!String.IsNullOrEmpty(f.Obsolete))
{
sw.WriteLine("[Obsolete(\"{0}\")]", f.Obsolete);
}
else if (f.Deprecated && Settings.IsEnabled(Settings.Legacy.AddDeprecationWarnings))
{
sw.WriteLine("[Obsolete(\"Deprecated in OpenGL {0}\")]", f.DeprecatedVersion);
}
sw.WriteLine("[AutoGenerated(Category = \"{0}\", Version = \"{1}\", EntryPoint = \"{2}\")]",
f.Category, f.Version, Settings.FunctionPrefix + f.WrappedDelegate.EntryPoint);
if (!f.CLSCompliant)
{
sw.WriteLine("[CLSCompliant(false)]");
}
sw.WriteLine("public static {0} {{ throw new NotImplementedException(); }}", GetDeclarationString(f, Settings.Compatibility));
}
void WriteMethod2(BindStreamWriter sw, Function f, EnumCollection enums)
{
if (!String.IsNullOrEmpty(f.Obsolete))
{
return; // TODO: add note that we
//sw.WriteLine("[Obsolete(\"{0}\")]", f.Obsolete);
}
else if (f.Deprecated && Settings.IsEnabled(Settings.Legacy.AddDeprecationWarnings))
{
return; //
//sw.WriteLine("[Obsolete(\"Deprecated in OpenGL {0}\")]", f.DeprecatedVersion);
}
//--------------------------------------------------------------------------------------------
#if DEBUG
_dbugWrite_Id++;
sw.WriteLine("//x* " + _dbugWrite_Id);
#endif
//we may not need this...
sw.WriteLine("//[AutoGenerated(Category = \"{0}\", Version = \"{1}\", EntryPoint = \"{2}\")]",
f.Category, f.Version, Settings.FunctionPrefix + f.WrappedDelegate.EntryPoint);
//we may not need to gen [CLSCompliant(false)] if our asm dose not require it
//if (!f.CLSCompliant)
//{
// sw.WriteLine("[CLSCompliant(false)]");
//}
sw.WriteLine($"public static {_hostCSWriter.GetDeclarationString(f, Settings.Compatibility)}");
//body
//-----
//sw.WriteLine("//hello!");
CreateBody(f, f.CLSCompliant, enums, Settings.FunctionPrefix, f.WrappedDelegate);
sw.WriteLine(f.Body.ToString());
}
void WriteDelegates(BindStreamWriter sw, DelegateCollection delegates)
{
Trace.WriteLine(String.Format("Writing delegates to:\t{0}.{1}.{2}", Settings.OutputNamespace, Settings.OutputClass, Settings.DelegatesClass));
sw.WriteLine("#pragma warning disable 3019"); // CLSCompliant attribute
sw.WriteLine("#pragma warning disable 1591"); // Missing doc comments
sw.WriteLine();
sw.WriteLine("partial class {0}", Settings.OutputClass);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("internal static partial class {0}", Settings.DelegatesClass);
sw.WriteLine("{");
sw.Indent();
foreach (var overloads in delegates.Values)
{
// Generate only one delegate per entry point..
// Overloads are only used for wrapper generation,
// so ignore them.
var d = overloads.First();
sw.WriteLine("[System.Security.SuppressUnmanagedCodeSecurity()]");
sw.WriteLine("internal {0};", GetDeclarationString(d, true));
sw.WriteLine("internal {0}static {2} {1}{2};", // = null
d.Unsafe ? "unsafe " : "",
Settings.FunctionPrefix,
d.Name);
}
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.WriteLine("}");
}
static Delegate WriteWrapper(Delegate last_delegate, Function f, BindStreamWriter sw)
{
//if (last_delegate == f.WrappedDelegate)
// return last_delegate; // Multiple wrappers for the same delegate are not necessary in C++
var valid = true;
var parameters = GenerateParameterString(f, true, out valid);
if (!valid)
{
return(last_delegate);
}
last_delegate = f.WrappedDelegate;
sw.WriteLine("inline {0} {1}({2})", f.WrappedDelegate.ReturnType,
f.TrimmedName, parameters);
sw.WriteLine("{");
sw.Indent();
WriteMethodBody(sw, f);
sw.Unindent();
sw.WriteLine("}");
return(last_delegate);
}
private void WriteMethod(BindStreamWriter sw, Function f, EnumCollection enums)
{
CreateBody(f, enums);
if (!String.IsNullOrEmpty(f.Obsolete))
{
sw.WriteLine("[Obsolete(\"{0}\")]", f.Obsolete);
}
else if (f.Deprecated && Settings.IsEnabled(Settings.Legacy.AddDeprecationWarnings))
{
sw.WriteLine("[Obsolete(\"Deprecated in OpenGL {0}\")]", f.DeprecatedVersion);
}
if (!f.CLSCompliant)
{
sw.WriteLine("[System.CLSCompliant(false)]");
}
sw.WriteLine("[AutoGenerated(Category = \"{0}\", Version = \"{1}\", EntryPoint = \"{2}\")]",
f.Category, f.Version, Settings.FunctionPrefix + f.WrappedDelegate.EntryPoint);
sw.WriteLine("public static ");
sw.Write(GetDeclarationString(f));
sw.WriteLine();
}
void WriteDelegates(BindStreamWriter sw, DelegateCollection delegates)
{
Trace.WriteLine(String.Format("Writing delegates to:\t{0}.{1}.{2}", Settings.OutputNamespace, Settings.OutputClass, Settings.DelegatesClass));
sw.WriteLine("#pragma warning disable 3019"); // CLSCompliant attribute
sw.WriteLine("#pragma warning disable 1591"); // Missing doc comments
#if !MOBILE
sw.WriteLine();
sw.WriteLine("partial class {0}", Settings.OutputClass);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("internal static partial class {0}", Settings.DelegatesClass);
sw.WriteLine("{");
sw.Indent();
foreach (Delegate d in delegates.Values)
{
sw.WriteLine("[System.Security.SuppressUnmanagedCodeSecurity()]");
if (!string.IsNullOrEmpty (d.Obsolete))
sw.WriteLine("[Obsolete(\"{0}\")]", d.Obsolete);
sw.WriteLine("internal {0};", d.ToString());
sw.WriteLine("internal {0}static {1} {2}{1};", // = null
d.Unsafe ? "unsafe " : "",
d.Name,
Settings.FunctionPrefix);
}
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.WriteLine("}");
#endif
}
public void WriteLicense(BindStreamWriter sw)
{
sw.WriteLine(File.ReadAllText(Path.Combine(Settings.InputPath, Settings.LicenseFile)));
sw.WriteLine();
}
static void WriteMethodBody(BindStreamWriter sw, Function f)
{
//var callstring = f.Parameters.CallString();
//if (f.ReturnType != null && !f.ReturnType.ToString().ToLower().Contains("void"))
// sw.WriteLine("return GLES20.{0}{1};", f.WrappedDelegate.Name, callstring);
//else
// sw.WriteLine("GLES20.{0}{1};", f.WrappedDelegate.Name, callstring);
}
public void WriteWrappers(BindStreamWriter sw, FunctionCollection wrappers, Dictionary<string, string> CSTypes)
{
Trace.WriteLine(String.Format("Writing wrappers to:\t{0}.{1}", Settings.OutputNamespace, Settings.OutputClass));
sw.WriteLine("#pragma warning disable 3019"); // CLSCompliant attribute
sw.WriteLine("#pragma warning disable 1591"); // Missing doc comments
sw.WriteLine("#pragma warning disable 1572"); // Wrong param comments
sw.WriteLine("#pragma warning disable 1573"); // Missing param comments
sw.WriteLine();
sw.WriteLine("partial class {0}", Settings.OutputClass);
sw.WriteLine("{");
sw.Indent();
//sw.WriteLine("static {0}() {1} {2}", className, "{", "}"); // Static init in GLHelper.cs
sw.WriteLine();
int current = 0;
foreach (string key in wrappers.Keys)
{
if (((Settings.Compatibility & Settings.Legacy.NoSeparateFunctionNamespaces) == Settings.Legacy.None) && key != "Core")
{
if (!Char.IsDigit(key[0]))
{
sw.WriteLine("public static partial class {0}", key);
}
else
{
// Identifiers cannot start with a number:
sw.WriteLine("public static partial class {0}{1}", Settings.ConstantPrefix, key);
}
sw.WriteLine("{");
sw.Indent();
}
wrappers[key].Sort();
foreach (Function f in wrappers[key])
{
current = WriteWrapper(sw, current, f);
}
if (((Settings.Compatibility & Settings.Legacy.NoSeparateFunctionNamespaces) == Settings.Legacy.None) && key != "Core")
{
sw.Unindent();
sw.WriteLine("}");
sw.WriteLine();
}
}
sw.Unindent();
sw.WriteLine("}");
}
void WriteEnums(BindStreamWriter sw, EnumCollection enums, FunctionCollection wrappers)
{
//sw.WriteLine("#pragma warning disable 3019"); // CLSCompliant attribute
//sw.WriteLine("#pragma warning disable 1591"); // Missing doc comments
//sw.WriteLine();
if ((Settings.Compatibility & Settings.Legacy.NestedEnums) != Settings.Legacy.None)
Trace.WriteLine(String.Format("Writing enums to:\t{0}.{1}.{2}", Settings.OutputNamespace, Settings.OutputClass, Settings.NestedEnumsClass));
else
Trace.WriteLine(String.Format("Writing enums to:\t{0}", Settings.EnumsOutput));
if ((Settings.Compatibility & Settings.Legacy.ConstIntEnums) == Settings.Legacy.None)
{
if ((Settings.Compatibility & Settings.Legacy.NestedEnums) != Settings.Legacy.None &&
!String.IsNullOrEmpty(Settings.NestedEnumsClass))
{
sw.WriteLine("public class Enums");
sw.WriteLine("{");
sw.Indent();
}
// Build a dictionary of which functions use which enums
var enum_counts = new Dictionary<Enum, List<Function>>();
foreach (var e in enums.Values)
{
// Initialize the dictionary
enum_counts.Add(e, new List<Function>());
}
foreach (var wrapper in wrappers.Values.SelectMany(w => w))
{
// Add every function to every enum parameter it references
foreach (var parameter in wrapper.Parameters.Where(p => p.IsEnum))
{
var e = enums[parameter.CurrentType];
var list = enum_counts[e];
list.Add(wrapper);
}
}
foreach (Enum @enum in enums.Values)
{
if (!Settings.IsEnabled(Settings.Legacy.NoDocumentation))
{
// Document which functions use this enum.
var functions = enum_counts[@enum]
.Select(w => Settings.GLClass + (w.Extension != "Core" ? ("." + w.Extension) : "") + "." + w.TrimmedName)
.Distinct();
sw.WriteLine("/// <summary>");
sw.WriteLine(String.Format("/// {0}",
functions.Count() >= 3 ?
String.Format("Used in {0} and {1} other function{2}",
String.Join(", ", functions.Take(2).ToArray()),
functions.Count() - 2,
functions.Count() - 2 > 1 ? "s" : "") :
functions.Count() >= 1 ?
String.Format("Used in {0}",
String.Join(", ", functions.ToArray())) :
"Not used directly."));
sw.WriteLine("/// </summary>");
}
if (@enum.IsFlagCollection)
sw.WriteLine("[Flags]");
sw.WriteLine("public enum " + @enum.Name + " : " + @enum.Type);
sw.WriteLine("{");
sw.Indent();
WriteConstants(sw, @enum.ConstantCollection.Values);
sw.Unindent();
sw.WriteLine("}");
sw.WriteLine();
}
if ((Settings.Compatibility & Settings.Legacy.NestedEnums) != Settings.Legacy.None &&
!String.IsNullOrEmpty(Settings.NestedEnumsClass))
{
sw.Unindent();
sw.WriteLine("}");
}
}
else
{
// Tao legacy mode: dump all enums as constants in GLClass.
foreach (Constant c in enums[Settings.CompleteEnumName].ConstantCollection.Values)
{
// Print constants avoiding circular definitions
if (c.Name != c.Value)
{
sw.WriteLine(String.Format(
"public const int {0} = {2}((int){1});",
c.Name.StartsWith(Settings.ConstantPrefix) ? c.Name : Settings.ConstantPrefix + c.Name,
Char.IsDigit(c.Value[0]) ? c.Value : c.Value.StartsWith(Settings.ConstantPrefix) ? c.Value : Settings.ConstantPrefix + c.Value,
c.Unchecked ? "unchecked" : ""));
}
else
{
}
}
}
}
public void WriteTypes(BindStreamWriter sw, Dictionary<string, string> CSTypes)
{
sw.WriteLine();
foreach (string s in CSTypes.Keys)
{
sw.WriteLine("using {0} = System.{1};", s, CSTypes[s]);
}
}
private void WriteMethod(BindStreamWriter sw, Function f, EnumCollection enums)
{
CreateBody(f, enums);
if (f.Deprecated && Settings.IsEnabled(Settings.Legacy.AddDeprecationWarnings))
{
sw.WriteLine("[Obsolete(\"Deprecated in OpenGL {0}\")]", f.DeprecatedVersion);
}
if (!f.CLSCompliant)
{
sw.WriteLine("[System.CLSCompliant(false)]");
}
sw.WriteLine("[AutoGenerated(Category = \"{0}\", Version = \"{1}\", EntryPoint = \"{2}\")]",
f.Category, f.Version, Settings.FunctionPrefix + f.WrappedDelegate.EntryPoint);
sw.WriteLine("public static ");
sw.Write(GetDeclarationString(f));
sw.WriteLine();
}
public void WriteLicense(BindStreamWriter sw)
{
sw.WriteLine(File.ReadAllText(Path.Combine(Settings.InputPath, Settings.LicenseFile)));
sw.WriteLine();
}
static Delegate WriteWrapper(Delegate last_delegate, Function f, BindStreamWriter sw)
{
//if (last_delegate == f.WrappedDelegate)
// return last_delegate; // Multiple wrappers for the same delegate are not necessary in C++
var valid = true;
var parameters = GenerateParameterString(f, true, out valid);
if (!valid)
return last_delegate;
last_delegate = f.WrappedDelegate;
sw.WriteLine("inline {0} {1}({2})", f.WrappedDelegate.ReturnType,
f.TrimmedName, parameters);
sw.WriteLine("{");
sw.Indent();
WriteMethodBody(sw, f);
sw.Unindent();
sw.WriteLine("}");
return last_delegate;
}
void WriteEnums(BindStreamWriter sw, EnumCollection enums, FunctionCollection wrappers)
{
//sw.WriteLine("#pragma warning disable 3019"); // CLSCompliant attribute
//sw.WriteLine("#pragma warning disable 1591"); // Missing doc comments
//sw.WriteLine();
if ((Settings.Compatibility & Settings.Legacy.NestedEnums) != Settings.Legacy.None)
Trace.WriteLine(String.Format("Writing enums to:\t{0}.{1}.{2}", Settings.OutputNamespace, Settings.OutputClass, Settings.NestedEnumsClass));
else
Trace.WriteLine(String.Format("Writing enums to:\t{0}", Settings.EnumsOutput));
if ((Settings.Compatibility & Settings.Legacy.ConstIntEnums) == Settings.Legacy.None)
{
if ((Settings.Compatibility & Settings.Legacy.NestedEnums) != Settings.Legacy.None &&
!String.IsNullOrEmpty(Settings.NestedEnumsClass))
{
sw.WriteLine("public class Enums");
sw.WriteLine("{");
sw.Indent();
}
foreach (Enum @enum in enums.Values)
{
if (!Settings.IsEnabled(Settings.Legacy.NoDocumentation))
{
// Document which functions use this enum.
var functions =
(from wrapper in wrappers
from function in wrapper.Value
from param in function.Parameters
where param.CurrentType == @enum.Name
select Settings.GLClass + (function.Extension != "Core" ? ("." + function.Extension) : "") + "." + function.TrimmedName)
.Distinct();
sw.WriteLine("/// <summary>");
sw.WriteLine(String.Format("/// {0}", functions.Count() > 0 ?
("Used in " + String.Join(", ", functions.ToArray())) : "Not used directly."));
sw.WriteLine("/// </summary>");
}
if (!string.IsNullOrEmpty (@enum.Obsolete))
sw.WriteLine("[Obsolete(\"{0}\")]", @enum.Obsolete);
if (@enum.IsFlagCollection)
sw.WriteLine("[Flags]");
sw.WriteLine("public enum " + @enum.Name + " : " + @enum.Type);
sw.WriteLine("{");
sw.Indent();
WriteConstants(sw, @enum.ConstantCollection.Values);
sw.Unindent();
sw.WriteLine("}");
sw.WriteLine();
}
if ((Settings.Compatibility & Settings.Legacy.NestedEnums) != Settings.Legacy.None &&
!String.IsNullOrEmpty(Settings.NestedEnumsClass))
{
sw.Unindent();
sw.WriteLine("}");
}
}
else
{
// Tao legacy mode: dump all enums as constants in GLClass.
foreach (Constant c in enums[Settings.CompleteEnumName].ConstantCollection.Values)
{
// Print constants avoiding circular definitions
if (c.Name != c.Value)
{
sw.WriteLine(String.Format(
"public const int {0} = {2}((int){1});",
c.Name.StartsWith(Settings.ConstantPrefix) ? c.Name : Settings.ConstantPrefix + c.Name,
Char.IsDigit(c.Value[0]) ? c.Value : c.Value.StartsWith(Settings.ConstantPrefix) ? c.Value : Settings.ConstantPrefix + c.Value,
c.Unchecked ? "unchecked" : ""));
}
else
{
}
}
}
}
private static void WriteMethod(BindStreamWriter sw, Function f)
{
if (f.Deprecated && Settings.IsEnabled(Settings.Legacy.AddDeprecationWarnings))
{
sw.WriteLine("[Obsolete(\"Deprecated in OpenGL {0}\")]", f.DeprecatedVersion);
}
if (!string.IsNullOrEmpty (f.Obsolete))
sw.WriteLine("[Obsolete(\"{0}\")]", f.Obsolete);
if (!f.CLSCompliant)
{
sw.WriteLine("[System.CLSCompliant(false)]");
}
sw.WriteLine("[AutoGenerated(Category = \"{0}\", Version = \"{1}\", EntryPoint = \"{2}\")]",
f.Category, f.Version, Settings.FunctionPrefix + f.WrappedDelegate.Name);
sw.WriteLine("public static ");
sw.Write(f);
sw.WriteLine();
}
int WriteWrapper(BindStreamWriter sw, int current, Function f)
{
if ((Settings.Compatibility & Settings.Legacy.NoDocumentation) == 0)
{
Console.WriteLine("Creating docs for #{0} ({1})", current++, f.Name);
WriteDocumentation(sw, f);
}
WriteMethod(sw, f);
return current;
}
private void WriteMethod(BindStreamWriter sw, Function f, EnumCollection enums)
{
if (!String.IsNullOrEmpty(f.Obsolete))
{
sw.WriteLine("[Obsolete(\"{0}\")]", f.Obsolete);
}
else if (f.Deprecated && Settings.IsEnabled(Settings.Legacy.AddDeprecationWarnings))
{
sw.WriteLine("[Obsolete(\"Deprecated in OpenGL {0}\")]", f.DeprecatedVersion);
}
sw.WriteLine("[AutoGenerated(Category = \"{0}\", Version = \"{1}\", EntryPoint = \"{2}\")]",
f.Category, f.Version, Settings.FunctionPrefix + f.WrappedDelegate.EntryPoint);
if (!f.CLSCompliant)
{
sw.WriteLine("[CLSCompliant(false)]");
}
sw.WriteLine("public static {0} {{ throw new NotImplementedException(); }}", GetDeclarationString(f, Settings.Compatibility));
}
void WriteDocumentation(BindStreamWriter sw, Function f)
{
if (docfiles == null)
{
docfiles = new Dictionary <string, string>();
foreach (string file in Directory.GetFiles(Settings.DocPath))
{
docfiles.Add(Path.GetFileName(file), file);
}
}
string docfile = null;
try
{
docfile = Settings.FunctionPrefix + f.WrappedDelegate.Name + ".xml";
if (!docfiles.ContainsKey(docfile))
{
docfile = Settings.FunctionPrefix + f.TrimmedName + ".xml";
}
if (!docfiles.ContainsKey(docfile))
{
docfile = Settings.FunctionPrefix + f.TrimmedName.TrimEnd(numbers) + ".xml";
}
var docs = new List <string>();
if (docfiles.ContainsKey(docfile))
{
docs.AddRange(Processor.ProcessFile(docfiles[docfile]));
}
if (docs.Count == 0)
{
docs.Add("/// <summary></summary>");
}
int summary_start = docs[0].IndexOf("<summary>") + "<summary>".Length;
string warning = "[deprecated: v{0}]";
string category = "[requires: {0}]";
if (f.Deprecated)
{
warning = String.Format(warning, f.DeprecatedVersion);
docs[0] = docs[0].Insert(summary_start, warning);
}
if (f.Extension != "Core" && !String.IsNullOrEmpty(f.Category))
{
category = String.Format(category, f.Category);
docs[0] = docs[0].Insert(summary_start, category);
}
else if (!String.IsNullOrEmpty(f.Version))
{
if (f.Category.StartsWith("VERSION"))
{
category = String.Format(category, "v" + f.Version);
}
else
{
category = String.Format(category, "v" + f.Version + " and " + f.Category);
}
docs[0] = docs[0].Insert(summary_start, category);
}
foreach (var param in f.WrappedDelegate.Parameters)
{
var index = docs.IndexOf("/// <param name=\"" + param.Name + "\">");
if (index != -1 && param.ComputeSize != "")
{
var compute_size = string.Format("[length: {0}]", param.ComputeSize);
docs[index] = docs[index] + compute_size;
}
}
foreach (var doc in docs)
{
sw.WriteLine(doc);
}
}
catch (Exception e)
{
Console.WriteLine("[Warning] Error processing file {0}: {1}", docfile, e.ToString());
}
}
void WriteDocumentation(BindStreamWriter sw, Function f)
{
var docs = f.Documentation;
try
{
string warning = String.Empty;
string category = String.Empty;
if (f.Deprecated)
{
warning = String.Format("[deprecated: v{0}]", f.DeprecatedVersion);
}
if (f.Extension != "Core" && !String.IsNullOrEmpty(f.Category))
{
category = String.Format("[requires: {0}]", f.Category);
}
else if (!String.IsNullOrEmpty(f.Version))
{
if (f.Category.StartsWith("VERSION"))
category = String.Format("[requires: {0}]", "v" + f.Version);
else
category = String.Format("[requires: {0}]", "v" + f.Version + " or " + f.Category);
}
// Write function summary
sw.Write("/// <summary>");
if (!String.IsNullOrEmpty(category) || !String.IsNullOrEmpty(warning))
{
sw.Write(WriteOptions.NoIndent, "{0}{1}", category, warning);
}
if (!String.IsNullOrEmpty(docs.Summary))
{
sw.WriteLine();
sw.WriteLine("/// {0}", docs.Summary);
sw.WriteLine("/// </summary>");
}
else
{
sw.WriteLine(WriteOptions.NoIndent, "</summary>");
}
// Write function parameters
for (int i = 0; i < f.Parameters.Count; i++)
{
var param = f.Parameters[i];
string length = String.Empty;
if (!String.IsNullOrEmpty(param.ComputeSize))
{
length = String.Format("[length: {0}]", param.ComputeSize);
}
// Try to match the correct parameter from documentation:
// - first by name
// - then by index
var docparam =
(docs.Parameters
.Where(p => p.Name == param.RawName)
.FirstOrDefault()) ??
(docs.Parameters.Count > i ?
docs.Parameters[i] : null);
if (docparam != null)
{
if (docparam.Name != param.RawName &&
docparam.Name != param.RawName.Substring(1)) // '@ref' -> 'ref' etc
{
Console.Error.WriteLine(
"[Warning] Parameter '{0}' in function '{1}' has incorrect doc name '{2}'",
param.RawName, f.Name, docparam.Name);
}
// Note: we use param.Name, because the documentation sometimes
// uses different names than the specification.
sw.Write("/// <param name=\"{0}\">", param.Name);
if (!String.IsNullOrEmpty(length))
{
sw.Write(WriteOptions.NoIndent, "{0}", length);
}
if (!String.IsNullOrEmpty(docparam.Documentation))
{
sw.WriteLine(WriteOptions.NoIndent, " ");
sw.WriteLine("/// {0}", docparam.Documentation);
sw.WriteLine("/// </param>");
}
else
{
sw.WriteLine(WriteOptions.NoIndent, "</param>");
}
}
else
{
Console.Error.WriteLine(
"[Warning] Parameter '{0}' in function '{1}' not found in documentation '{{{2}}}'",
param.Name, f.Name,
String.Join(",", docs.Parameters.Select(p => p.Name).ToArray()));
sw.WriteLine("/// <param name=\"{0}\">{1}</param>",
param.Name, length);
}
}
}
catch (Exception e)
{
Console.WriteLine("[Warning] Error documenting function {0}: {1}", f.WrappedDelegate.Name, e.ToString());
}
}
private void WriteDocumentation(BindStreamWriter sw, Function f)
{
var docs = f.Documentation;
try
{
string warning = String.Empty;
string category = String.Empty;
if (f.Deprecated)
{
warning = String.Format("[deprecated: v{0}]", f.DeprecatedVersion);
}
if (f.Extension != "Core" && !String.IsNullOrEmpty(f.Category))
{
category = String.Format("[requires: {0}]", f.Category);
}
else if (!String.IsNullOrEmpty(f.Version))
{
if (f.Category.StartsWith("VERSION"))
{
category = String.Format("[requires: {0}]", "v" + f.Version);
}
else
{
category = String.Format("[requires: {0}]", "v" + f.Version + " or " + f.Category);
}
}
// Write function summary
sw.Write("/// <summary>");
if (!String.IsNullOrEmpty(category) || !String.IsNullOrEmpty(warning))
{
sw.Write(WriteOptions.NoIndent, "{0}{1}", category, warning);
}
if (!String.IsNullOrEmpty(docs.Summary))
{
sw.WriteLine();
sw.WriteLine("/// {0}", docs.Summary);
sw.WriteLine("/// </summary>");
}
else
{
sw.WriteLine(WriteOptions.NoIndent, "</summary>");
}
// Write function parameters
for (int i = 0; i < f.Parameters.Count; i++)
{
var param = f.Parameters[i];
string length = String.Empty;
if (!String.IsNullOrEmpty(param.ComputeSize))
{
length = String.Format("[length: {0}]", param.ComputeSize);
}
// Try to match the correct parameter from documentation:
// - first by name
// - then by index
var docparam =
(docs.Parameters
.Where(p => p.Name == param.RawName)
.FirstOrDefault()) ??
(docs.Parameters.Count > i ?
docs.Parameters[i] : null);
if (docparam != null)
{
if (docparam.Name != param.RawName &&
docparam.Name != param.RawName.Substring(1)) // '@ref' -> 'ref' etc
{
Console.Error.WriteLine(
"[Warning] Parameter '{0}' in function '{1}' has incorrect doc name '{2}'",
param.RawName, f.Name, docparam.Name);
}
// Note: we use param.Name, because the documentation sometimes
// uses different names than the specification.
sw.Write("/// <param name=\"{0}\">", param.Name);
if (!String.IsNullOrEmpty(length))
{
sw.Write(WriteOptions.NoIndent, "{0}", length);
}
if (!String.IsNullOrEmpty(docparam.Documentation))
{
sw.WriteLine(WriteOptions.NoIndent, "");
sw.WriteLine("/// {0}", docparam.Documentation);
sw.WriteLine("/// </param>");
}
else
{
sw.WriteLine(WriteOptions.NoIndent, "</param>");
}
}
else
{
Console.Error.WriteLine(
"[Warning] Parameter '{0}' in function '{1}' not found in documentation '{{{2}}}'",
param.Name, f.Name,
String.Join(",", docs.Parameters.Select(p => p.Name).ToArray()));
sw.WriteLine("/// <param name=\"{0}\">{1}</param>",
param.Name, length);
}
}
}
catch (Exception e)
{
Console.WriteLine("[Warning] Error documenting function {0}: {1}", f.WrappedDelegate.Name, e.ToString());
}
}
void WriteConstants(BindStreamWriter sw, IEnumerable<Constant> constants)
{
// Make sure everything is sorted. This will avoid random changes between
// consecutive runs of the program.
constants = constants.OrderBy(c => c);
foreach (var c in constants)
{
if (!Settings.IsEnabled(Settings.Legacy.NoDocumentation))
{
sw.WriteLine("/// <summary>");
sw.WriteLine("/// Original was " + Settings.ConstantPrefix + c.OriginalName + " = " + c.Value);
sw.WriteLine("/// </summary>");
}
var str = String.Format("{0} = {1}((int){2}{3})", c.Name, c.Unchecked ? "unchecked" : "",
!String.IsNullOrEmpty(c.Reference) ? c.Reference + Settings.NamespaceSeparator : "", c.Value);
sw.Write(str);
if (!String.IsNullOrEmpty(str))
sw.WriteLine(",");
}
}
public void WriteEnums(BindStreamWriter sw, EnumCollection enums)
{
foreach (Enum @enum in enums.Values)
{
sw.WriteLine("public enum {0}", @enum.Name);
sw.WriteLine("{");
sw.Indent();
int count = @enum.ConstantCollection.Values.Count;
if (count == 0)
{
// Java enums must have at least one value.
sw.WriteLine("None;");
}
else
{
foreach (var c in @enum.ConstantCollection.Values)
{
sw.WriteLine(String.Format("{0}({1}{2}){3}",
c.Name,
!String.IsNullOrEmpty(c.Reference) ? (c.Reference + Settings.NamespaceSeparator) : "",
!String.IsNullOrEmpty(c.Reference) ? c.Value : c.Value.ToLower(),
--count == 0 ? ";" : ","));
}
sw.WriteLine();
sw.WriteLine("{0} mValue;", @enum.Type);
sw.WriteLine("{0}({1} value) {{ mValue = value; }}", @enum.Name, @enum.Type);
}
sw.Unindent();
sw.WriteLine("}");
sw.WriteLine();
}
}
void WriteBindings(DelegateCollection delegates, FunctionCollection wrappers, EnumCollection enums)
{
Console.WriteLine("Writing bindings to {0}", Settings.OutputPath);
if (!Directory.Exists(Settings.OutputPath))
Directory.CreateDirectory(Settings.OutputPath);
string temp_enums_file = Path.GetTempFileName();
string temp_wrappers_file = Path.GetTempFileName();
// Enums
using (BindStreamWriter sw = new BindStreamWriter(temp_enums_file))
{
WriteLicense(sw);
sw.WriteLine("using System;");
sw.WriteLine();
if ((Settings.Compatibility & Settings.Legacy.NestedEnums) != Settings.Legacy.None)
{
sw.WriteLine("namespace {0}", Settings.OutputNamespace);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("static partial class {0}", Settings.OutputClass);
}
else
sw.WriteLine("namespace {0}", Settings.EnumsOutput);
sw.WriteLine("{");
sw.Indent();
WriteEnums(sw, enums, wrappers);
sw.Unindent();
if ((Settings.Compatibility & Settings.Legacy.NestedEnums) != Settings.Legacy.None)
{
sw.WriteLine("}");
sw.Unindent();
}
sw.WriteLine("}");
}
// Wrappers
using (BindStreamWriter sw = new BindStreamWriter(temp_wrappers_file))
{
WriteLicense(sw);
sw.WriteLine("namespace {0}", Settings.OutputNamespace);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("using System;");
sw.WriteLine("using System.Text;");
sw.WriteLine("using System.Runtime.InteropServices;");
WriteWrappers(sw, wrappers, delegates, enums, Generator.CSTypes);
sw.Unindent();
sw.WriteLine("}");
}
string output_enums = Path.Combine(Settings.OutputPath, Settings.EnumsFile);
string output_delegates = Path.Combine(Settings.OutputPath, Settings.DelegatesFile);
string output_core = Path.Combine(Settings.OutputPath, Settings.ImportsFile);
string output_wrappers = Path.Combine(Settings.OutputPath, Settings.WrappersFile);
if (File.Exists(output_enums)) File.Delete(output_enums);
if (File.Exists(output_delegates)) File.Delete(output_delegates);
if (File.Exists(output_core)) File.Delete(output_core);
if (File.Exists(output_wrappers)) File.Delete(output_wrappers);
File.Move(temp_enums_file, output_enums);
File.Move(temp_wrappers_file, output_wrappers);
}
public void WriteImports(BindStreamWriter sw, DelegateCollection delegates)
{
Trace.WriteLine(String.Format("Writing imports to:\t{0}.{1}.{2}", Settings.OutputNamespace, Settings.OutputClass, Settings.ImportsClass));
sw.WriteLine("#pragma warning disable 3019"); // CLSCompliant attribute
sw.WriteLine("#pragma warning disable 1591"); // Missing doc comments
sw.WriteLine();
sw.WriteLine("partial class {0}", Settings.OutputClass);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine();
sw.WriteLine("internal static partial class {0}", Settings.ImportsClass);
sw.WriteLine("{");
sw.Indent();
//sw.WriteLine("static {0}() {1} {2}", Settings.ImportsClass, "{", "}"); // Disable BeforeFieldInit
sw.WriteLine();
foreach (Delegate d in delegates.Values)
{
sw.WriteLine("[System.Security.SuppressUnmanagedCodeSecurity()]");
sw.WriteLine(
"[System.Runtime.InteropServices.DllImport({0}.Library, EntryPoint = \"{1}{2}\"{3})]",
Settings.OutputClass,
Settings.FunctionPrefix,
d.Name,
d.Name.EndsWith("W") || d.Name.EndsWith("A") ? ", CharSet = CharSet.Auto" : ", ExactSpelling = true"
);
sw.WriteLine("internal extern static {0};", d.DeclarationString());
}
sw.Unindent();
sw.WriteLine("}");
sw.Unindent();
sw.WriteLine("}");
}
void WriteDefinitions(BindStreamWriter sw,
EnumCollection enums, FunctionCollection wrappers,
Dictionary<string, string> CSTypes)
{
sw.WriteLine("public class {0}", Settings.GLClass);
sw.WriteLine("{");
sw.Indent();
foreach (string extension in wrappers.Keys)
{
if (extension != "Core")
{
sw.WriteLine("public static class {0}", extension);
sw.WriteLine("{");
sw.Indent();
}
// Write wrappers
foreach (var f in wrappers[extension])
{
WriteWrapper(f, sw);
}
if (extension != "Core")
{
sw.Unindent();
sw.WriteLine("}");
}
}
WriteEnums(sw, enums);
sw.Unindent();
sw.WriteLine("}");
}
static void WriteDelegate(BindStreamWriter sw, Delegate d, ref Delegate last_delegate)
{
// Avoid multiple definitions of the same function
if (d != last_delegate)
{
last_delegate = d;
bool valid = true;
var parameters = GenerateParameterString(d, false, out valid);
sw.WriteLine("typedef {0} (GLPP_APIENTRY *p{1})({2});", d.ReturnType, d.Name, parameters);
sw.WriteLine("inline p{0}& {0}()", d.Name);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("static p{0} address = 0;", d.Name);
sw.WriteLine("return address;");
sw.Unindent();
sw.WriteLine("}");
}
}
static void WriteWrapper(Function f, BindStreamWriter sw)
{
var valid = true;
var generic_parameters = GenerateGenericTypeString(f);
var parameters = GenerateParameterString(f, out valid);
var ret_parameter = GenerateReturnParameterString(f);
if (!valid)
return;
if (!String.IsNullOrEmpty(generic_parameters))
sw.WriteLine("public static <{0}> {1} {2}({3})", generic_parameters,
ret_parameter, f.TrimmedName, parameters);
else
sw.WriteLine("public static {0} {1}({2})", ret_parameter, f.TrimmedName,
parameters);
sw.WriteLine("{");
sw.Indent();
WriteMethodBody(sw, f);
sw.Unindent();
sw.WriteLine("}");
}
static void WriteMethodBody(BindStreamWriter sw, Function f)
{
//var callstring = f.Parameters.CallString()
// .Replace("String[]", "String*");
var callstring = GenerateCallString(f);
if (f.ReturnType != null && !f.ReturnType.ToString().ToLower().Contains("void"))
sw.Write("return ");
sw.WriteLine("Delegates::{0}()({1});", f.WrappedDelegate.Name, callstring);
}
void WriteDocumentation(BindStreamWriter sw, Function f)
{
if (docfiles == null)
{
docfiles = new Dictionary<string, string>();
foreach (string file in Directory.GetFiles(Settings.DocPath))
{
docfiles.Add(Path.GetFileName(file), file);
}
}
string docfile = null;
try
{
docfile = Settings.FunctionPrefix + f.WrappedDelegate.Name + ".xml";
if (!docfiles.ContainsKey(docfile))
docfile = Settings.FunctionPrefix + f.TrimmedName + ".xml";
if (!docfiles.ContainsKey(docfile))
docfile = Settings.FunctionPrefix + f.TrimmedName.TrimEnd(numbers) + ".xml";
string doc = null;
if (docfiles.ContainsKey(docfile))
{
doc = processor.ProcessFile(docfiles[docfile]);
}
if (doc == null)
{
doc = "/// <summary></summary>";
}
int summary_start = doc.IndexOf("<summary>") + "<summary>".Length;
string warning = "[deprecated: v{0}]";
string category = "[requires: {0}]";
if (f.Deprecated)
{
warning = String.Format(warning, f.DeprecatedVersion);
doc = doc.Insert(summary_start, warning);
}
if (f.Extension != "Core" && !String.IsNullOrEmpty(f.Category))
{
category = String.Format(category, f.Category);
doc = doc.Insert(summary_start, category);
}
else if (!String.IsNullOrEmpty(f.Version))
{
if (f.Category.StartsWith("VERSION"))
category = String.Format(category, "v" + f.Version);
else
category = String.Format(category, "v" + f.Version + " and " + f.Category);
doc = doc.Insert(summary_start, category);
}
sw.WriteLine(doc);
}
catch (Exception e)
{
Console.WriteLine("[Warning] Error processing file {0}: {1}", docfile, e.ToString());
}
}
void WriteDocumentation(BindStreamWriter sw, Function f)
{
var docs = f.Documentation;
try
{
string warning = "[deprecated: v{0}]";
string category = "[requires: {0}]";
if (f.Deprecated)
{
warning = String.Format(warning, f.DeprecatedVersion);
docs.Summary = docs.Summary.Insert(0, warning);
}
if (f.Extension != "Core" && !String.IsNullOrEmpty(f.Category))
{
category = String.Format(category, f.Category);
docs.Summary = docs.Summary.Insert(0, category);
}
else if (!String.IsNullOrEmpty(f.Version))
{
if (f.Category.StartsWith("VERSION"))
category = String.Format(category, "v" + f.Version);
else
category = String.Format(category, "v" + f.Version + " and " + f.Category);
docs.Summary = docs.Summary.Insert(0, category);
}
for (int i = 0; i < f.WrappedDelegate.Parameters.Count; i++)
{
var param = f.WrappedDelegate.Parameters[i];
if (param.ComputeSize != String.Empty)
{
docs.Parameters[i].Documentation.Insert(0,
String.Format("[length: {0}]", param.ComputeSize));
}
}
sw.Write("/// \brief ");
sw.WriteLine(docs.Summary);
foreach (var p in docs.Parameters)
{
sw.Write(@"/// \param ");
sw.Write(p.Name);
sw.WriteLine(p.Documentation);
}
}
catch (Exception e)
{
Console.WriteLine("[Warning] Error documenting function {0}: {1}", f.WrappedDelegate.Name, e.ToString());
}
}
void WriteWrappers(BindStreamWriter sw, FunctionCollection wrappers,
DelegateCollection delegates, EnumCollection enums,
IDictionary <string, string> CSTypes)
{
Trace.WriteLine(String.Format("Writing wrappers to:\t{0}.{1}", Settings.OutputNamespace, Settings.OutputClass));
sw.WriteLine("#pragma warning disable 3019"); // CLSCompliant attribute
sw.WriteLine("#pragma warning disable 1591"); // Missing doc comments
sw.WriteLine("#pragma warning disable 1572"); // Wrong param comments
sw.WriteLine("#pragma warning disable 1573"); // Missing param comments
sw.WriteLine("#pragma warning disable 626"); // extern method without DllImport
sw.WriteLine();
sw.WriteLine("partial class {0}", Settings.OutputClass);
sw.WriteLine("{");
sw.Indent();
// Write constructor
sw.WriteLine("static {0}()", Settings.OutputClass);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("EntryPointNames = new string[]", delegates.Count);
sw.WriteLine("{");
sw.Indent();
foreach (var d in delegates.Values.Select(d => d.First()))
{
if (!Settings.IsEnabled(Settings.Legacy.UseDllImports) || d.Extension != "Core")
{
sw.WriteLine("\"{0}{1}\",", Settings.FunctionPrefix, d.Name);
}
}
sw.Unindent();
sw.WriteLine("};");
sw.WriteLine("EntryPoints = new IntPtr[EntryPointNames.Length];");
sw.Unindent();
sw.WriteLine("}");
sw.WriteLine();
int current_wrapper = 0;
foreach (string key in wrappers.Keys)
{
if (((Settings.Compatibility & Settings.Legacy.NoSeparateFunctionNamespaces) == Settings.Legacy.None) && key != "Core")
{
if (!Char.IsDigit(key[0]))
{
sw.WriteLine("public static partial class {0}", key);
}
else
{
// Identifiers cannot start with a number:
sw.WriteLine("public static partial class {0}{1}", Settings.ConstantPrefix, key);
}
sw.WriteLine("{");
sw.Indent();
}
wrappers[key].Sort();
foreach (Function f in wrappers[key])
{
WriteWrapper(sw, f, enums);
current_wrapper++;
}
if (((Settings.Compatibility & Settings.Legacy.NoSeparateFunctionNamespaces) == Settings.Legacy.None) && key != "Core")
{
sw.Unindent();
sw.WriteLine("}");
sw.WriteLine();
}
}
// Emit native signatures.
// These are required by the patcher.
int current_signature = 0;
foreach (var d in wrappers.Values.SelectMany(e => e).Select(w => w.WrappedDelegate).Distinct())
{
sw.WriteLine("[Slot({0})]", d.Slot);
sw.WriteLine("[DllImport(Library, ExactSpelling = true, CallingConvention = CallingConvention.Winapi)]");
sw.WriteLine("static extern {0};", GetDeclarationString(d, false));
current_signature++;
}
sw.Unindent();
sw.WriteLine("}");
Console.WriteLine("Wrote {0} wrappers for {1} signatures", current_wrapper, current_signature);
}
void WriteWrappers(BindStreamWriter sw, FunctionCollection wrappers,
DelegateCollection delegates, EnumCollection enums,
IDictionary<string, string> CSTypes)
{
Trace.WriteLine(String.Format("Writing wrappers to:\t{0}.{1}", Settings.OutputNamespace, Settings.OutputClass));
sw.WriteLine("#pragma warning disable 3019"); // CLSCompliant attribute
sw.WriteLine("#pragma warning disable 1591"); // Missing doc comments
sw.WriteLine("#pragma warning disable 1572"); // Wrong param comments
sw.WriteLine("#pragma warning disable 1573"); // Missing param comments
sw.WriteLine("#pragma warning disable 626"); // extern method without DllImport
sw.WriteLine();
sw.WriteLine("partial class {0}", Settings.OutputClass);
sw.WriteLine("{");
sw.Indent();
// Write constructor
sw.WriteLine("static {0}()", Settings.OutputClass);
sw.WriteLine("{");
sw.Indent();
// Write entry point names.
// Instead of strings, which are costly to construct,
// we use a 1d array of ASCII bytes. Names are laid out
// sequentially, with a nul-terminator between them.
sw.WriteLine("EntryPointNames = new byte[]", delegates.Count);
sw.WriteLine("{");
sw.Indent();
foreach (var d in delegates.Values.Select(d => d.First()))
{
if (d.RequiresSlot(Settings))
{
var name = Settings.FunctionPrefix + d.Name;
sw.WriteLine("{0}, 0,", String.Join(", ",
System.Text.Encoding.ASCII.GetBytes(name).Select(b => b.ToString()).ToArray()));
}
}
sw.Unindent();
sw.WriteLine("};");
// Write entry point name offsets.
// This is an array of offsets into the EntryPointNames[] array above.
sw.WriteLine("EntryPointNameOffsets = new int[]", delegates.Count);
sw.WriteLine("{");
sw.Indent();
int offset = 0;
foreach (var d in delegates.Values.Select(d => d.First()))
{
if (d.RequiresSlot(Settings))
{
sw.WriteLine("{0},", offset);
var name = Settings.FunctionPrefix + d.Name;
offset += name.Length + 1;
}
}
sw.Unindent();
sw.WriteLine("};");
sw.WriteLine("EntryPoints = new IntPtr[EntryPointNameOffsets.Length];");
sw.Unindent();
sw.WriteLine("}");
sw.WriteLine();
int current_wrapper = 0;
foreach (string key in wrappers.Keys)
{
if (((Settings.Compatibility & Settings.Legacy.NoSeparateFunctionNamespaces) == Settings.Legacy.None) && key != "Core")
{
if (!Char.IsDigit(key[0]))
{
sw.WriteLine("public static partial class {0}", key);
}
else
{
// Identifiers cannot start with a number:
sw.WriteLine("public static partial class {0}{1}", Settings.ConstantPrefix, key);
}
sw.WriteLine("{");
sw.Indent();
}
wrappers[key].Sort();
foreach (Function f in wrappers[key])
{
WriteWrapper(sw, f, enums);
current_wrapper++;
}
if (((Settings.Compatibility & Settings.Legacy.NoSeparateFunctionNamespaces) == Settings.Legacy.None) && key != "Core")
{
sw.Unindent();
sw.WriteLine("}");
sw.WriteLine();
}
}
// Emit native signatures.
// These are required by the patcher.
int current_signature = 0;
foreach (var d in wrappers.Values.SelectMany(e => e).Select(w => w.WrappedDelegate).Distinct())
{
sw.WriteLine("[Slot({0})]", d.Slot);
sw.WriteLine("[DllImport(Library, ExactSpelling = true, CallingConvention = CallingConvention.Winapi)]");
sw.WriteLine("static extern {0};", GetDeclarationString(d, false));
current_signature++;
}
sw.Unindent();
sw.WriteLine("}");
Console.WriteLine("Wrote {0} wrappers for {1} signatures", current_wrapper, current_signature);
}
void WriteTypes(BindStreamWriter sw)
{
sw.WriteLine(TypeDefinitions);
}
void WriteWrapper(BindStreamWriter sw, Function f, EnumCollection enums)
{
if ((Settings.Compatibility & Settings.Legacy.NoDocumentation) == 0)
{
WriteDocumentation(sw, f);
}
WriteMethod(sw, f, enums);
sw.WriteLine();
}
static Delegate WriteInitDelegate(Delegate last_delegate, BindStreamWriter sw, Function f)
{
if (last_delegate != f.WrappedDelegate)
{
sw.WriteLine("Delegates::{0}() = (Delegates::p{0})OpenTK::Internals::GetAddress(\"gl{0}\");", f.WrappedDelegate.Name);
last_delegate = f.WrappedDelegate;
}
return last_delegate;
}
void WriteGetAddress(BindStreamWriter sw)
{
sw.WriteLine(GetAddressDefinition);
}
void WriteEnums(BindStreamWriter sw, EnumCollection enums, FunctionCollection wrappers)
{
//sw.WriteLine("#pragma warning disable 3019"); // CLSCompliant attribute
//sw.WriteLine("#pragma warning disable 1591"); // Missing doc comments
//sw.WriteLine();
if ((Settings.Compatibility & Settings.Legacy.NestedEnums) != Settings.Legacy.None)
{
Trace.WriteLine(String.Format("Writing enums to:\t{0}.{1}.{2}", Settings.OutputNamespace, Settings.OutputClass, Settings.NestedEnumsClass));
}
else
{
Trace.WriteLine(String.Format("Writing enums to:\t{0}", Settings.EnumsOutput));
}
if ((Settings.Compatibility & Settings.Legacy.ConstIntEnums) == Settings.Legacy.None)
{
if ((Settings.Compatibility & Settings.Legacy.NestedEnums) != Settings.Legacy.None &&
!String.IsNullOrEmpty(Settings.NestedEnumsClass))
{
sw.WriteLine("public class Enums");
sw.WriteLine("{");
sw.Indent();
}
// Build a dictionary of which functions use which enums
var enum_counts = new Dictionary <Enum, List <Function> >();
foreach (var e in enums.Values)
{
// Initialize the dictionary
enum_counts.Add(e, new List <Function>());
}
foreach (var wrapper in wrappers.Values.SelectMany(w => w))
{
// Add every function to every enum parameter it references
foreach (var parameter in wrapper.Parameters.Where(p => p.IsEnum))
{
var e = enums[parameter.CurrentType];
var list = enum_counts[e];
list.Add(wrapper);
}
}
foreach (Enum @enum in enums.Values)
{
if (!Settings.IsEnabled(Settings.Legacy.NoDocumentation))
{
// Document which functions use this enum.
var functions = enum_counts[@enum]
.Select(w => Settings.GLClass + (w.Extension != "Core" ? ("." + w.Extension) : "") + "." + w.TrimmedName)
.Distinct();
sw.WriteLine("/// <summary>");
sw.WriteLine(String.Format("/// {0}",
functions.Count() >= 3 ?
String.Format("Used in {0} and {1} other function{2}",
String.Join(", ", functions.Take(2).ToArray()),
functions.Count() - 2,
functions.Count() - 2 > 1 ? "s" : "") :
functions.Count() >= 1 ?
String.Format("Used in {0}",
String.Join(", ", functions.ToArray())) :
"Not used directly."));
sw.WriteLine("/// </summary>");
}
if (@enum.IsFlagCollection)
{
sw.WriteLine("[Flags]");
}
sw.WriteLine("public enum " + @enum.Name + " : " + @enum.Type);
sw.WriteLine("{");
sw.Indent();
WriteConstants(sw, @enum.ConstantCollection.Values);
sw.Unindent();
sw.WriteLine("}");
sw.WriteLine();
}
if ((Settings.Compatibility & Settings.Legacy.NestedEnums) != Settings.Legacy.None &&
!String.IsNullOrEmpty(Settings.NestedEnumsClass))
{
sw.Unindent();
sw.WriteLine("}");
}
}
else
{
// Tao legacy mode: dump all enums as constants in GLClass.
foreach (Constant c in enums[Settings.CompleteEnumName].ConstantCollection.Values)
{
// Print constants avoiding circular definitions
if (c.Name != c.Value)
{
sw.WriteLine(String.Format(
"public const int {0} = {2}((int){1});",
c.Name.StartsWith(Settings.ConstantPrefix) ? c.Name : Settings.ConstantPrefix + c.Name,
Char.IsDigit(c.Value[0]) ? c.Value : c.Value.StartsWith(Settings.ConstantPrefix) ? c.Value : Settings.ConstantPrefix + c.Value,
c.Unchecked ? "unchecked" : ""));
}
else
{
}
}
}
}
void WriteDefinitions(BindStreamWriter sw,
EnumCollection enums, FunctionCollection wrappers,
IDictionary<string, string> CSTypes)
{
sw.WriteLine("namespace {0}", Settings.GLClass);
sw.WriteLine("{");
sw.Indent();
foreach (string extension in wrappers.Keys)
{
if (extension != "Core")
{
sw.WriteLine("namespace {0}", extension);
sw.WriteLine("{");
sw.Indent();
}
// Avoid multiple definitions of the same function
Delegate last_delegate = null;
// Write delegates
sw.WriteLine("namespace Delegates");
sw.WriteLine("{");
sw.Indent();
var functions = wrappers[extension];
last_delegate = null;
foreach (var f in functions.Where(f => !f.Deprecated))
{
WriteDelegate(sw, f.WrappedDelegate, ref last_delegate);
}
last_delegate = null;
sw.WriteLine("#if defined({0})", AllowDeprecated);
foreach (var f in functions.Where(f => f.Deprecated))
{
WriteDelegate(sw, f.WrappedDelegate, ref last_delegate);
}
sw.WriteLine("#endif");
sw.Unindent();
sw.WriteLine("};");
// Write wrappers
sw.WriteLine("inline void Init()");
sw.WriteLine("{");
sw.Indent();
last_delegate = null;
foreach (var f in functions.Where(f => !f.Deprecated))
{
last_delegate = WriteInitDelegate(last_delegate, sw, f);
}
last_delegate = null;
sw.WriteLine("#if defined({0})", AllowDeprecated);
foreach (var f in functions.Where(f => f.Deprecated))
{
last_delegate = WriteInitDelegate(last_delegate, sw, f);
}
sw.WriteLine("#endif");
sw.Unindent();
sw.WriteLine("}");
last_delegate = null;
foreach (var f in functions.Where(f => !f.Deprecated))
{
last_delegate = WriteWrapper(last_delegate, f, sw);
}
sw.WriteLine("#if defined({0})", AllowDeprecated);
foreach (var f in functions.Where(f => f.Deprecated))
{
last_delegate = WriteWrapper(last_delegate, f, sw);
}
sw.WriteLine("#endif");
if (extension != "Core")
{
sw.Unindent();
sw.WriteLine("};");
}
}
sw.Unindent();
sw.WriteLine("};");
}
void WriteBindings(DelegateCollection delegates, FunctionCollection wrappers, EnumCollection enums)
{
Console.WriteLine("Writing bindings to {0}", Settings.OutputPath);
if (!Directory.Exists(Settings.OutputPath))
{
Directory.CreateDirectory(Settings.OutputPath);
}
string temp_enums_file = Path.GetTempFileName();
string temp_wrappers_file = Path.GetTempFileName();
// Enums
using (BindStreamWriter sw = new BindStreamWriter(temp_enums_file))
{
WriteLicense(sw);
sw.WriteLine("using System;");
sw.WriteLine();
if ((Settings.Compatibility & Settings.Legacy.NestedEnums) != Settings.Legacy.None)
{
sw.WriteLine("namespace {0}", Settings.OutputNamespace);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("static partial class {0}", Settings.OutputClass);
}
else
{
sw.WriteLine("namespace {0}", Settings.EnumsOutput);
}
sw.WriteLine("{");
sw.Indent();
WriteEnums(sw, enums, wrappers);
sw.Unindent();
if ((Settings.Compatibility & Settings.Legacy.NestedEnums) != Settings.Legacy.None)
{
sw.WriteLine("}");
sw.Unindent();
}
sw.WriteLine("}");
}
// Wrappers
using (BindStreamWriter sw = new BindStreamWriter(temp_wrappers_file))
{
WriteLicense(sw);
sw.WriteLine("namespace {0}", Settings.OutputNamespace);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("using System;");
sw.WriteLine("using System.Text;");
sw.WriteLine("using System.Runtime.InteropServices;");
WriteWrappers(sw, wrappers, delegates, enums, Generator.CSTypes);
sw.Unindent();
sw.WriteLine("}");
}
string output_enums = Path.Combine(Settings.OutputPath, Settings.EnumsFile);
string output_delegates = Path.Combine(Settings.OutputPath, Settings.DelegatesFile);
string output_core = Path.Combine(Settings.OutputPath, Settings.ImportsFile);
string output_wrappers = Path.Combine(Settings.OutputPath, Settings.WrappersFile);
if (File.Exists(output_enums))
{
File.Delete(output_enums);
}
if (File.Exists(output_delegates))
{
File.Delete(output_delegates);
}
if (File.Exists(output_core))
{
File.Delete(output_core);
}
if (File.Exists(output_wrappers))
{
File.Delete(output_wrappers);
}
File.Move(temp_enums_file, output_enums);
File.Move(temp_wrappers_file, output_wrappers);
}
public void WriteEnums(BindStreamWriter sw, EnumCollection enums)
{
foreach (Enum @enum in enums.Values)
{
sw.WriteLine("struct {0} : Enumeration<{0}>", @enum.Name);
sw.WriteLine("{");
sw.Indent();
sw.WriteLine("inline {0}(int value) : Enumeration<{0}>(value) {{ }}", @enum.Name);
sw.WriteLine("enum");
sw.WriteLine("{");
sw.Indent();
foreach (var c in @enum.ConstantCollection.Values)
{
sw.WriteLine(String.Format("{0} = {1}{2},",
c.Name,
!String.IsNullOrEmpty(c.Reference) ? (c.Reference + Settings.NamespaceSeparator) : "",
!String.IsNullOrEmpty(c.Reference) ? c.Value : c.Value.ToLower()));
}
sw.Unindent();
sw.WriteLine("};");
sw.Unindent();
sw.WriteLine("};");
sw.WriteLine();
}
}
