diff --git a/src/Generator/Filter.cs b/src/Generator/Filter.cs new file mode 100644 index 00000000..89d04f0e --- /dev/null +++ b/src/Generator/Filter.cs @@ -0,0 +1,36 @@ +using System; +using System.Linq; +using System.Xml.Linq; +using System.Collections.Generic; + +public enum FilterMode { + Include, + Exclude, + External +} + +public enum ImplementationType { + @class, + @struct +} + +public struct Filter { + + public string TypeName { get; set; } + public FilterMode Mode { get; set; } + public ImplementationType ImplType { get; set; } + + public static Dictionary Load (XDocument doc, out FilterMode @default) + { + string value; + @default = (value = (string)doc.Root.Attribute ("default")) != null ? (FilterMode)Enum.Parse (typeof (FilterMode), value) : FilterMode.Include; + + var rules = from rule in doc.Root.Elements () + let mode = (FilterMode)Enum.Parse (typeof (FilterMode), rule.Name.LocalName) + let impl = (value = (string)rule.Attribute ("implementation")) != null ? (ImplementationType)Enum.Parse (typeof (ImplementationType), value) : ImplementationType.@class + select new Filter { TypeName = rule.Value, Mode = mode, ImplType = impl }; + + + return rules.ToDictionary (r => r.TypeName); + } +} \ No newline at end of file diff --git a/src/Generator/Generator.cs b/src/Generator/Generator.cs new file mode 100644 index 00000000..b47328cd --- /dev/null +++ b/src/Generator/Generator.cs @@ -0,0 +1,243 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Text.RegularExpressions; + +using Cxxi; +using Cxxi.Templates; + +public partial class Generator +{ + public List Transformations { get; set; } + + Library Library; + Options Options; + + public Generator(Library library, Options options) + { + Transformations = new List(); + + Library = library; + Options = options; + } + + public void Process() + { + TransformModule(); + ProcessModules(); + } + + // Generates the binding code. + public void Generate() + { + GenerateModules(); + } + + int UniqueType = 0; + + void CleanupText(ref string debugText) + { + // Strip off newlines from the debug text. + if (String.IsNullOrWhiteSpace(debugText)) + debugText = String.Empty; + + // TODO: Make this transformation in the output. + debugText = Regex.Replace(debugText, " ( )+", " "); + debugText = Regex.Replace(debugText, "\n", ""); + } + + void ProcessType(Declaration type) + { + // If after all the transformations the type still does + // not have a name, then generate one. + + if (String.IsNullOrWhiteSpace(type.Name)) + type.Name = String.Format("UnnamedType{0}", UniqueType++); + + CleanupText(ref type.DebugText); + } + + void ProcessTypes(List types) where T : Declaration + { + foreach (T type in types) + ProcessType(type); + } + + void ProcessClasses(List Classes) + { + ProcessTypes(Classes); + + foreach (var @class in Classes) + ProcessTypes(@class.Fields); + } + + void ProcessFunctions(List Functions) + { + ProcessTypes(Functions); + + foreach (var function in Functions) + { + if (function.ReturnType == null) + { + // Ignore and warn about unknown types. + function.Ignore = true; + + var s = "Function '{0}' was ignored due to unknown return type..."; + Console.WriteLine( String.Format(s, function.Name) ); + } + + ProcessTypes(function.Parameters); + } + } + + void ProcessModules() + { + if (String.IsNullOrEmpty(Library.Name)) + Library.Name = ""; + + // Process everything in the global namespace for now. + foreach (var module in Library.Modules) + { + ProcessNamespace(module.Global); + } + } + + void ProcessNamespace(Namespace @namespace) + { + ProcessTypes(@namespace.Enums); + ProcessFunctions(@namespace.Functions); + ProcessClasses(@namespace.Classes); + } + + void TransformModule() + { + if (String.IsNullOrEmpty(Library.Name)) + Library.Name = ""; + + // Process everything in the global namespace for now. + foreach (var module in Library.Modules) + { + Namespace global = module.Global; + + foreach (Enumeration @enum in global.Enums) + TransformEnum(@enum); + + foreach (Function function in global.Functions) + TransformFunction(function); + + foreach (Class @class in global.Classes) + TransformClass(@class); + } + } + + void TransformType(Declaration type) + { + foreach (var transform in Transformations) + transform.ProcessType(type); + } + + void TransformClass(Class @class) + { + TransformType(@class); + + foreach (var field in @class.Fields) + TransformType(field); + } + + void TransformFunction(Function function) + { + TransformType(function); + + foreach (var param in function.Parameters) + TransformType(param); + } + + + void TransformEnum(Enumeration @enum) + { + TransformType(@enum); + + foreach (var transform in Transformations) + { + foreach (var item in @enum.Items) + transform.ProcessEnumItem(item); + } + + // If the enumeration only has power of two values, assume it's + // a flags enum. + + bool isFlags = true; + bool hasBigRange = false; + + foreach (var item in @enum.Items) + { + if (item.Name.Length >= 1 && Char.IsDigit(item.Name[0])) + item.Name = String.Format("_{0}", item.Name); + + long value = item.Value; + if (value >= 4) + hasBigRange = true; + if (value <= 1 || value.IsPowerOfTwo()) + continue; + isFlags = false; + } + + // Only apply this heuristic if there are enough values to have a + // reasonable chance that it really is a bitfield. + + if (isFlags && hasBigRange) + { + @enum.Modifiers |= Enumeration.EnumModifiers.Flags; + } + + // If we still do not have a valid name, then try to guess one + // based on the enum value names. + + if (!String.IsNullOrWhiteSpace(@enum.Name)) + return; + + var names = new List(); + + foreach (var item in @enum.Items) + names.Add(item.Name); + + var prefix = names.ToArray().CommonPrefix(); + + // Try a simple heuristic to make sure we end up with a valid name. + if (prefix.Length >= 3) + { + prefix = prefix.Trim().Trim(new char[] { '_' }); + @enum.Name = prefix; + } + } + + void GenerateModules() + { + // Process everything in the global namespace for now. + foreach (var module in Library.Modules) + { + if (module.Ignore || !module.HasDeclarations) + continue; + + // Generate the code from templates. + var template = new CSharpModule(); + template.Library = Library; + template.Options = Options; + template.Module = module; + + if (!Directory.Exists(Options.OutputDir)) + Directory.CreateDirectory(Options.OutputDir); + + var file = Path.GetFileNameWithoutExtension(module.FileName) + ".cs"; + var path = Path.Combine(Options.OutputDir, file); + + // Normalize path. + path = Path.GetFullPath(path); + + string code = template.TransformText(); + + Console.WriteLine(" Generated '" + file + "'."); + File.WriteAllText(path, code); + } + } +} \ No newline at end of file diff --git a/src/Generator/Generator.csproj b/src/Generator/Generator.csproj new file mode 100644 index 00000000..332af767 --- /dev/null +++ b/src/Generator/Generator.csproj @@ -0,0 +1,91 @@ + + + + Debug + x86 + 8.0.30703 + 2.0 + {73499B8E-A6A4-42FF-AB8A-754CE2780777} + Exe + Properties + Cxxi + Generator + v4.0 + Client + 512 + + + x86 + true + full + false + $(SolutionDir)bin\ + DEBUG;TRACE + prompt + 4 + true + + + x86 + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + Program + + + + ..\..\bin\Parser_d.dll + + + + + + + + + + + + + + + + + + + True + True + CSharpModule.tt + + + + + + + TextTemplatingFilePreprocessor + CSharpModule.cs + + + + + + + + {6BEB8FA2-97AA-40B7-AB92-42F6EDDC4490} + Bridge + + + + + \ No newline at end of file diff --git a/src/Generator/Generator.csproj.user b/src/Generator/Generator.csproj.user new file mode 100644 index 00000000..a2e0b59a --- /dev/null +++ b/src/Generator/Generator.csproj.user @@ -0,0 +1,8 @@ + + + + true + --debug --ns=SDL -outdir=gen/build/NSDL SDL/SDL.h + C:\Development\cxxi\bin\ + + \ No newline at end of file diff --git a/src/Generator/Generator.t4properties b/src/Generator/Generator.t4properties new file mode 100644 index 00000000..cd5e60eb --- /dev/null +++ b/src/Generator/Generator.t4properties @@ -0,0 +1,10 @@ + + + + + Templates\CSharpModule.tt + Host + VisualStudio + + + \ No newline at end of file diff --git a/src/Generator/Glob.cs b/src/Generator/Glob.cs new file mode 100644 index 00000000..e2e2d81d --- /dev/null +++ b/src/Generator/Glob.cs @@ -0,0 +1,34 @@ +using System; +using System.Collections.Generic; +using System.IO; + +public static class Glob +{ + static public string[] GetFiles(string[] patterns) + { + List filelist = new List(); + foreach (string pattern in patterns) + filelist.AddRange(GetFiles(pattern)); + string[] files = new string[filelist.Count]; + filelist.CopyTo(files, 0); + return files; + } + + static public string[] GetFiles(string patternlist) + { + List filelist = new List(); + foreach (string pattern in + patternlist.Split(Path.GetInvalidPathChars())) + { + string dir = Path.GetDirectoryName(pattern); + if (String.IsNullOrEmpty(dir)) dir = + Directory.GetCurrentDirectory(); + filelist.AddRange(Directory.GetFiles( + Path.GetFullPath(dir), + Path.GetFileName(pattern))); + } + string[] files = new string[filelist.Count]; + filelist.CopyTo(files, 0); + return files; + } +} \ No newline at end of file diff --git a/src/Generator/Helpers.cs b/src/Generator/Helpers.cs new file mode 100644 index 00000000..f53bbec1 --- /dev/null +++ b/src/Generator/Helpers.cs @@ -0,0 +1,79 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Cxxi.Templates +{ + public partial class CSharpModule + { + public Library Library; + public Options Options; + public Module Module; + + readonly string DefaultIndent = " "; + + // from https://github.com/mono/mono/blob/master/mcs/class/System/Microsoft.CSharp/CSharpCodeGenerator.cs + private static string[] keywords = new string[] + { + "abstract","event","new","struct","as","explicit","null","switch","base","extern", + "this","false","operator","throw","break","finally","out","true", + "fixed","override","try","case","params","typeof","catch","for", + "private","foreach","protected","checked","goto","public", + "unchecked","class","if","readonly","unsafe","const","implicit","ref", + "continue","in","return","using","virtual","default", + "interface","sealed","volatile","delegate","internal","do","is", + "sizeof","while","lock","stackalloc","else","static","enum", + "namespace", + "object","bool","byte","float","uint","char","ulong","ushort", + "decimal","int","sbyte","short","double","long","string","void", + "partial", "yield", "where" + }; + + public static string SafeIdentifier(string proposedName) + { + proposedName = new string(((IEnumerable)proposedName).Select(c => char.IsLetterOrDigit(c) ? c : '_').ToArray()); + return keywords.Contains(proposedName) ? "@" + proposedName : proposedName; + } + } + + public static class IntHelpers + { + public static bool IsPowerOfTwo(this long x) + { + return (x != 0) && ((x & (x - 1)) == 0); + } + } + + public static class StringHelpers + { + public static string CommonPrefix(this string[] ss) + { + if (ss.Length == 0) + { + return ""; + } + + if (ss.Length == 1) + { + return ss[0]; + } + + int prefixLength = 0; + + foreach (char c in ss[0]) + { + foreach (string s in ss) + { + if (s.Length <= prefixLength || s[prefixLength] != c) + { + return ss[0].Substring(0, prefixLength); + } + } + prefixLength++; + } + + return ss[0]; // all strings identical + } + } +} \ No newline at end of file diff --git a/src/Generator/Options.cs b/src/Generator/Options.cs new file mode 100644 index 00000000..d86de259 --- /dev/null +++ b/src/Generator/Options.cs @@ -0,0 +1,1434 @@ +// +// Options.cs +// +// Authors: +// Jonathan Pryor +// Federico Di Gregorio +// +// Copyright (C) 2008 Novell (http://www.novell.com) +// Copyright (C) 2009 Federico Di Gregorio. +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// + +// Compile With: +// gmcs -debug+ -r:System.Core Options.cs -o:NDesk.Options.dll +// gmcs -debug+ -d:LINQ -r:System.Core Options.cs -o:NDesk.Options.dll +// +// The LINQ version just changes the implementation of +// OptionSet.Parse(IEnumerable), and confers no semantic changes. + +// +// A Getopt::Long-inspired option parsing library for C#. +// +// NDesk.Options.OptionSet is built upon a key/value table, where the +// key is a option format string and the value is a delegate that is +// invoked when the format string is matched. +// +// Option format strings: +// Regex-like BNF Grammar: +// name: .+ +// type: [=:] +// sep: ( [^{}]+ | '{' .+ '}' )? +// aliases: ( name type sep ) ( '|' name type sep )* +// +// Each '|'-delimited name is an alias for the associated action. If the +// format string ends in a '=', it has a required value. If the format +// string ends in a ':', it has an optional value. If neither '=' or ':' +// is present, no value is supported. `=' or `:' need only be defined on one +// alias, but if they are provided on more than one they must be consistent. +// +// Each alias portion may also end with a "key/value separator", which is used +// to split option values if the option accepts > 1 value. If not specified, +// it defaults to '=' and ':'. If specified, it can be any character except +// '{' and '}' OR the *string* between '{' and '}'. If no separator should be +// used (i.e. the separate values should be distinct arguments), then "{}" +// should be used as the separator. +// +// Options are extracted either from the current option by looking for +// the option name followed by an '=' or ':', or is taken from the +// following option IFF: +// - The current option does not contain a '=' or a ':' +// - The current option requires a value (i.e. not a Option type of ':') +// +// The `name' used in the option format string does NOT include any leading +// option indicator, such as '-', '--', or '/'. All three of these are +// permitted/required on any named option. +// +// Option bundling is permitted so long as: +// - '-' is used to start the option group +// - all of the bundled options are a single character +// - at most one of the bundled options accepts a value, and the value +// provided starts from the next character to the end of the string. +// +// This allows specifying '-a -b -c' as '-abc', and specifying '-D name=value' +// as '-Dname=value'. +// +// Option processing is disabled by specifying "--". All options after "--" +// are returned by OptionSet.Parse() unchanged and unprocessed. +// +// Unprocessed options are returned from OptionSet.Parse(). +// +// Examples: +// int verbose = 0; +// OptionSet p = new OptionSet () +// .Add ("v", v => ++verbose) +// .Add ("name=|value=", v => Console.WriteLine (v)); +// p.Parse (new string[]{"-v", "--v", "/v", "-name=A", "/name", "B", "extra"}); +// +// The above would parse the argument string array, and would invoke the +// lambda expression three times, setting `verbose' to 3 when complete. +// It would also print out "A" and "B" to standard output. +// The returned array would contain the string "extra". +// +// C# 3.0 collection initializers are supported and encouraged: +// var p = new OptionSet () { +// { "h|?|help", v => ShowHelp () }, +// }; +// +// System.ComponentModel.TypeConverter is also supported, allowing the use of +// custom data types in the callback type; TypeConverter.ConvertFromString() +// is used to convert the value option to an instance of the specified +// type: +// +// var p = new OptionSet () { +// { "foo=", (Foo f) => Console.WriteLine (f.ToString ()) }, +// }; +// +// Random other tidbits: +// - Boolean options (those w/o '=' or ':' in the option format string) +// are explicitly enabled if they are followed with '+', and explicitly +// disabled if they are followed with '-': +// string a = null; +// var p = new OptionSet () { +// { "a", s => a = s }, +// }; +// p.Parse (new string[]{"-a"}); // sets v != null +// p.Parse (new string[]{"-a+"}); // sets v != null +// p.Parse (new string[]{"-a-"}); // sets v == null +// + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Globalization; +using System.IO; +using System.Runtime.Serialization; +using System.Security.Permissions; +using System.Text; +using System.Text.RegularExpressions; + +#if LINQ +using System.Linq; +#endif + +#if TEST +using NDesk.Options; +#endif + +#if NDESK_OPTIONS +namespace NDesk.Options +#else +namespace Mono.Options +#endif +{ + static class StringCoda + { + + public static IEnumerable WrappedLines(string self, params int[] widths) + { + IEnumerable w = widths; + return WrappedLines(self, w); + } + + public static IEnumerable WrappedLines(string self, IEnumerable widths) + { + if (widths == null) + throw new ArgumentNullException("widths"); + return CreateWrappedLinesIterator(self, widths); + } + + private static IEnumerable CreateWrappedLinesIterator(string self, IEnumerable widths) + { + if (string.IsNullOrEmpty(self)) + { + yield return string.Empty; + yield break; + } + using (IEnumerator ewidths = widths.GetEnumerator()) + { + bool? hw = null; + int width = GetNextWidth(ewidths, int.MaxValue, ref hw); + int start = 0, end; + do + { + end = GetLineEnd(start, width, self); + char c = self[end - 1]; + if (char.IsWhiteSpace(c)) + --end; + bool needContinuation = end != self.Length && !IsEolChar(c); + string continuation = ""; + if (needContinuation) + { + --end; + continuation = "-"; + } + string line = self.Substring(start, end - start) + continuation; + yield return line; + start = end; + if (char.IsWhiteSpace(c)) + ++start; + width = GetNextWidth(ewidths, width, ref hw); + } while (start < self.Length); + } + } + + private static int GetNextWidth(IEnumerator ewidths, int curWidth, ref bool? eValid) + { + if (!eValid.HasValue || (eValid.HasValue && eValid.Value)) + { + curWidth = (eValid = ewidths.MoveNext()).Value ? ewidths.Current : curWidth; + // '.' is any character, - is for a continuation + const string minWidth = ".-"; + if (curWidth < minWidth.Length) + throw new ArgumentOutOfRangeException("widths", + string.Format("Element must be >= {0}, was {1}.", minWidth.Length, curWidth)); + return curWidth; + } + // no more elements, use the last element. + return curWidth; + } + + private static bool IsEolChar(char c) + { + return !char.IsLetterOrDigit(c); + } + + private static int GetLineEnd(int start, int length, string description) + { + int end = System.Math.Min(start + length, description.Length); + int sep = -1; + for (int i = start; i < end; ++i) + { + if (description[i] == '\n') + return i + 1; + if (IsEolChar(description[i])) + sep = i + 1; + } + if (sep == -1 || end == description.Length) + return end; + return sep; + } + } + + public class OptionValueCollection : IList, IList + { + + List values = new List(); + OptionContext c; + + internal OptionValueCollection(OptionContext c) + { + this.c = c; + } + + #region ICollection + void ICollection.CopyTo(Array array, int index) { (values as ICollection).CopyTo(array, index); } + bool ICollection.IsSynchronized { get { return (values as ICollection).IsSynchronized; } } + object ICollection.SyncRoot { get { return (values as ICollection).SyncRoot; } } + #endregion + + #region ICollection + public void Add(string item) { values.Add(item); } + public void Clear() { values.Clear(); } + public bool Contains(string item) { return values.Contains(item); } + public void CopyTo(string[] array, int arrayIndex) { values.CopyTo(array, arrayIndex); } + public bool Remove(string item) { return values.Remove(item); } + public int Count { get { return values.Count; } } + public bool IsReadOnly { get { return false; } } + #endregion + + #region IEnumerable + IEnumerator IEnumerable.GetEnumerator() { return values.GetEnumerator(); } + #endregion + + #region IEnumerable + public IEnumerator GetEnumerator() { return values.GetEnumerator(); } + #endregion + + #region IList + int IList.Add(object value) { return (values as IList).Add(value); } + bool IList.Contains(object value) { return (values as IList).Contains(value); } + int IList.IndexOf(object value) { return (values as IList).IndexOf(value); } + void IList.Insert(int index, object value) { (values as IList).Insert(index, value); } + void IList.Remove(object value) { (values as IList).Remove(value); } + void IList.RemoveAt(int index) { (values as IList).RemoveAt(index); } + bool IList.IsFixedSize { get { return false; } } + object IList.this[int index] { get { return this[index]; } set { (values as IList)[index] = value; } } + #endregion + + #region IList + public int IndexOf(string item) { return values.IndexOf(item); } + public void Insert(int index, string item) { values.Insert(index, item); } + public void RemoveAt(int index) { values.RemoveAt(index); } + + private void AssertValid(int index) + { + if (c.Option == null) + throw new InvalidOperationException("OptionContext.Option is null."); + if (index >= c.Option.MaxValueCount) + throw new ArgumentOutOfRangeException("index"); + if (c.Option.OptionValueType == OptionValueType.Required && + index >= values.Count) + throw new OptionException(string.Format( + c.OptionSet.MessageLocalizer("Missing required value for option '{0}'."), c.OptionName), + c.OptionName); + } + + public string this[int index] + { + get + { + AssertValid(index); + return index >= values.Count ? null : values[index]; + } + set + { + values[index] = value; + } + } + #endregion + + public List ToList() + { + return new List(values); + } + + public string[] ToArray() + { + return values.ToArray(); + } + + public override string ToString() + { + return string.Join(", ", values.ToArray()); + } + } + + public class OptionContext + { + private Option option; + private string name; + private int index; + private OptionSet set; + private OptionValueCollection c; + + public OptionContext(OptionSet set) + { + this.set = set; + this.c = new OptionValueCollection(this); + } + + public Option Option + { + get { return option; } + set { option = value; } + } + + public string OptionName + { + get { return name; } + set { name = value; } + } + + public int OptionIndex + { + get { return index; } + set { index = value; } + } + + public OptionSet OptionSet + { + get { return set; } + } + + public OptionValueCollection OptionValues + { + get { return c; } + } + } + + public enum OptionValueType + { + None, + Optional, + Required, + } + + public abstract class Option + { + string prototype, description; + string[] names; + OptionValueType type; + int count; + string[] separators; + + protected Option(string prototype, string description) + : this(prototype, description, 1) + { + } + + protected Option(string prototype, string description, int maxValueCount) + { + if (prototype == null) + throw new ArgumentNullException("prototype"); + if (prototype.Length == 0) + throw new ArgumentException("Cannot be the empty string.", "prototype"); + if (maxValueCount < 0) + throw new ArgumentOutOfRangeException("maxValueCount"); + + this.prototype = prototype; + this.description = description; + this.count = maxValueCount; + this.names = (this is OptionSet.Category) + // append GetHashCode() so that "duplicate" categories have distinct + // names, e.g. adding multiple "" categories should be valid. + ? new[] { prototype + this.GetHashCode() } + : prototype.Split('|'); + + if (this is OptionSet.Category) + return; + + this.type = ParsePrototype(); + + if (this.count == 0 && type != OptionValueType.None) + throw new ArgumentException( + "Cannot provide maxValueCount of 0 for OptionValueType.Required or " + + "OptionValueType.Optional.", + "maxValueCount"); + if (this.type == OptionValueType.None && maxValueCount > 1) + throw new ArgumentException( + string.Format("Cannot provide maxValueCount of {0} for OptionValueType.None.", maxValueCount), + "maxValueCount"); + if (Array.IndexOf(names, "<>") >= 0 && + ((names.Length == 1 && this.type != OptionValueType.None) || + (names.Length > 1 && this.MaxValueCount > 1))) + throw new ArgumentException( + "The default option handler '<>' cannot require values.", + "prototype"); + } + + public string Prototype { get { return prototype; } } + public string Description { get { return description; } } + public OptionValueType OptionValueType { get { return type; } } + public int MaxValueCount { get { return count; } } + + public string[] GetNames() + { + return (string[])names.Clone(); + } + + public string[] GetValueSeparators() + { + if (separators == null) + return new string[0]; + return (string[])separators.Clone(); + } + + protected static T Parse(string value, OptionContext c) + { + Type tt = typeof(T); + bool nullable = tt.IsValueType && tt.IsGenericType && + !tt.IsGenericTypeDefinition && + tt.GetGenericTypeDefinition() == typeof(Nullable<>); + Type targetType = nullable ? tt.GetGenericArguments()[0] : typeof(T); + TypeConverter conv = TypeDescriptor.GetConverter(targetType); + T t = default(T); + try + { + if (value != null) + t = (T)conv.ConvertFromString(value); + } + catch (Exception e) + { + throw new OptionException( + string.Format( + c.OptionSet.MessageLocalizer("Could not convert string `{0}' to type {1} for option `{2}'."), + value, targetType.Name, c.OptionName), + c.OptionName, e); + } + return t; + } + + internal string[] Names { get { return names; } } + internal string[] ValueSeparators { get { return separators; } } + + static readonly char[] NameTerminator = new char[] { '=', ':' }; + + private OptionValueType ParsePrototype() + { + char type = '\0'; + List seps = new List(); + for (int i = 0; i < names.Length; ++i) + { + string name = names[i]; + if (name.Length == 0) + throw new ArgumentException("Empty option names are not supported.", "prototype"); + + int end = name.IndexOfAny(NameTerminator); + if (end == -1) + continue; + names[i] = name.Substring(0, end); + if (type == '\0' || type == name[end]) + type = name[end]; + else + throw new ArgumentException( + string.Format("Conflicting option types: '{0}' vs. '{1}'.", type, name[end]), + "prototype"); + AddSeparators(name, end, seps); + } + + if (type == '\0') + return OptionValueType.None; + + if (count <= 1 && seps.Count != 0) + throw new ArgumentException( + string.Format("Cannot provide key/value separators for Options taking {0} value(s).", count), + "prototype"); + if (count > 1) + { + if (seps.Count == 0) + this.separators = new string[] { ":", "=" }; + else if (seps.Count == 1 && seps[0].Length == 0) + this.separators = null; + else + this.separators = seps.ToArray(); + } + + return type == '=' ? OptionValueType.Required : OptionValueType.Optional; + } + + private static void AddSeparators(string name, int end, ICollection seps) + { + int start = -1; + for (int i = end + 1; i < name.Length; ++i) + { + switch (name[i]) + { + case '{': + if (start != -1) + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + start = i + 1; + break; + case '}': + if (start == -1) + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + seps.Add(name.Substring(start, i - start)); + start = -1; + break; + default: + if (start == -1) + seps.Add(name[i].ToString()); + break; + } + } + if (start != -1) + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + } + + public void Invoke(OptionContext c) + { + OnParseComplete(c); + c.OptionName = null; + c.Option = null; + c.OptionValues.Clear(); + } + + protected abstract void OnParseComplete(OptionContext c); + + public override string ToString() + { + return Prototype; + } + } + + public abstract class ArgumentSource + { + + protected ArgumentSource() + { + } + + public abstract string[] GetNames(); + public abstract string Description { get; } + public abstract bool GetArguments(string value, out IEnumerable replacement); + + public static IEnumerable GetArgumentsFromFile(string file) + { + return GetArguments(File.OpenText(file), true); + } + + public static IEnumerable GetArguments(TextReader reader) + { + return GetArguments(reader, false); + } + + // Cribbed from mcs/driver.cs:LoadArgs(string) + static IEnumerable GetArguments(TextReader reader, bool close) + { + try + { + StringBuilder arg = new StringBuilder(); + + string line; + while ((line = reader.ReadLine()) != null) + { + int t = line.Length; + + for (int i = 0; i < t; i++) + { + char c = line[i]; + + if (c == '"' || c == '\'') + { + char end = c; + + for (i++; i < t; i++) + { + c = line[i]; + + if (c == end) + break; + arg.Append(c); + } + } + else if (c == ' ') + { + if (arg.Length > 0) + { + yield return arg.ToString(); + arg.Length = 0; + } + } + else + arg.Append(c); + } + if (arg.Length > 0) + { + yield return arg.ToString(); + arg.Length = 0; + } + } + } + finally + { + if (close) + reader.Close(); + } + } + } + + public class ResponseFileSource : ArgumentSource + { + + public override string[] GetNames() + { + return new string[] { "@file" }; + } + + public override string Description + { + get { return "Read response file for more options."; } + } + + public override bool GetArguments(string value, out IEnumerable replacement) + { + if (string.IsNullOrEmpty(value) || !value.StartsWith("@")) + { + replacement = null; + return false; + } + replacement = ArgumentSource.GetArgumentsFromFile(value.Substring(1)); + return true; + } + } + + [Serializable] + public class OptionException : Exception + { + private string option; + + public OptionException() + { + } + + public OptionException(string message, string optionName) + : base(message) + { + this.option = optionName; + } + + public OptionException(string message, string optionName, Exception innerException) + : base(message, innerException) + { + this.option = optionName; + } + + protected OptionException(SerializationInfo info, StreamingContext context) + : base(info, context) + { + this.option = info.GetString("OptionName"); + } + + public string OptionName + { + get { return this.option; } + } + + [SecurityPermission(SecurityAction.LinkDemand, SerializationFormatter = true)] + public override void GetObjectData(SerializationInfo info, StreamingContext context) + { + base.GetObjectData(info, context); + info.AddValue("OptionName", option); + } + } + + public delegate void OptionAction(TKey key, TValue value); + + public class OptionSet : KeyedCollection + { + public OptionSet() + : this(delegate(string f) { return f; }) + { + } + + public OptionSet(Converter localizer) + { + this.localizer = localizer; + this.roSources = new ReadOnlyCollection(sources); + } + + Converter localizer; + + public Converter MessageLocalizer + { + get { return localizer; } + } + + List sources = new List(); + ReadOnlyCollection roSources; + + public ReadOnlyCollection ArgumentSources + { + get { return roSources; } + } + + + protected override string GetKeyForItem(Option item) + { + if (item == null) + throw new ArgumentNullException("option"); + if (item.Names != null && item.Names.Length > 0) + return item.Names[0]; + // This should never happen, as it's invalid for Option to be + // constructed w/o any names. + throw new InvalidOperationException("Option has no names!"); + } + + [Obsolete("Use KeyedCollection.this[string]")] + protected Option GetOptionForName(string option) + { + if (option == null) + throw new ArgumentNullException("option"); + try + { + return base[option]; + } + catch (KeyNotFoundException) + { + return null; + } + } + + protected override void InsertItem(int index, Option item) + { + base.InsertItem(index, item); + AddImpl(item); + } + + protected override void RemoveItem(int index) + { + Option p = Items[index]; + base.RemoveItem(index); + // KeyedCollection.RemoveItem() handles the 0th item + for (int i = 1; i < p.Names.Length; ++i) + { + Dictionary.Remove(p.Names[i]); + } + } + + protected override void SetItem(int index, Option item) + { + base.SetItem(index, item); + AddImpl(item); + } + + private void AddImpl(Option option) + { + if (option == null) + throw new ArgumentNullException("option"); + List added = new List(option.Names.Length); + try + { + // KeyedCollection.InsertItem/SetItem handle the 0th name. + for (int i = 1; i < option.Names.Length; ++i) + { + Dictionary.Add(option.Names[i], option); + added.Add(option.Names[i]); + } + } + catch (Exception) + { + foreach (string name in added) + Dictionary.Remove(name); + throw; + } + } + + public OptionSet Add(string header) + { + if (header == null) + throw new ArgumentNullException("header"); + Add(new Category(header)); + return this; + } + + internal sealed class Category : Option + { + + // Prototype starts with '=' because this is an invalid prototype + // (see Option.ParsePrototype(), and thus it'll prevent Category + // instances from being accidentally used as normal options. + public Category(string description) + : base("=:Category:= " + description, description) + { + } + + protected override void OnParseComplete(OptionContext c) + { + throw new NotSupportedException("Category.OnParseComplete should not be invoked."); + } + } + + + public new OptionSet Add(Option option) + { + base.Add(option); + return this; + } + + sealed class ActionOption : Option + { + Action action; + + public ActionOption(string prototype, string description, int count, Action action) + : base(prototype, description, count) + { + if (action == null) + throw new ArgumentNullException("action"); + this.action = action; + } + + protected override void OnParseComplete(OptionContext c) + { + action(c.OptionValues); + } + } + + public OptionSet Add(string prototype, Action action) + { + return Add(prototype, null, action); + } + + public OptionSet Add(string prototype, string description, Action action) + { + if (action == null) + throw new ArgumentNullException("action"); + Option p = new ActionOption(prototype, description, 1, + delegate(OptionValueCollection v) { action(v[0]); }); + base.Add(p); + return this; + } + + public OptionSet Add(string prototype, OptionAction action) + { + return Add(prototype, null, action); + } + + public OptionSet Add(string prototype, string description, OptionAction action) + { + if (action == null) + throw new ArgumentNullException("action"); + Option p = new ActionOption(prototype, description, 2, + delegate(OptionValueCollection v) { action(v[0], v[1]); }); + base.Add(p); + return this; + } + + sealed class ActionOption : Option + { + Action action; + + public ActionOption(string prototype, string description, Action action) + : base(prototype, description, 1) + { + if (action == null) + throw new ArgumentNullException("action"); + this.action = action; + } + + protected override void OnParseComplete(OptionContext c) + { + action(Parse(c.OptionValues[0], c)); + } + } + + sealed class ActionOption : Option + { + OptionAction action; + + public ActionOption(string prototype, string description, OptionAction action) + : base(prototype, description, 2) + { + if (action == null) + throw new ArgumentNullException("action"); + this.action = action; + } + + protected override void OnParseComplete(OptionContext c) + { + action( + Parse(c.OptionValues[0], c), + Parse(c.OptionValues[1], c)); + } + } + + public OptionSet Add(string prototype, Action action) + { + return Add(prototype, null, action); + } + + public OptionSet Add(string prototype, string description, Action action) + { + return Add(new ActionOption(prototype, description, action)); + } + + public OptionSet Add(string prototype, OptionAction action) + { + return Add(prototype, null, action); + } + + public OptionSet Add(string prototype, string description, OptionAction action) + { + return Add(new ActionOption(prototype, description, action)); + } + + public OptionSet Add(ArgumentSource source) + { + if (source == null) + throw new ArgumentNullException("source"); + sources.Add(source); + return this; + } + + protected virtual OptionContext CreateOptionContext() + { + return new OptionContext(this); + } + + public List Parse(IEnumerable arguments) + { + if (arguments == null) + throw new ArgumentNullException("arguments"); + OptionContext c = CreateOptionContext(); + c.OptionIndex = -1; + bool process = true; + List unprocessed = new List(); + Option def = Contains("<>") ? this["<>"] : null; + ArgumentEnumerator ae = new ArgumentEnumerator(arguments); + foreach (string argument in ae) + { + ++c.OptionIndex; + if (argument == "--") + { + process = false; + continue; + } + if (!process) + { + Unprocessed(unprocessed, def, c, argument); + continue; + } + if (AddSource(ae, argument)) + continue; + if (!Parse(argument, c)) + Unprocessed(unprocessed, def, c, argument); + } + if (c.Option != null) + c.Option.Invoke(c); + return unprocessed; + } + + class ArgumentEnumerator : IEnumerable + { + List> sources = new List>(); + + public ArgumentEnumerator(IEnumerable arguments) + { + sources.Add(arguments.GetEnumerator()); + } + + public void Add(IEnumerable arguments) + { + sources.Add(arguments.GetEnumerator()); + } + + public IEnumerator GetEnumerator() + { + do + { + IEnumerator c = sources[sources.Count - 1]; + if (c.MoveNext()) + yield return c.Current; + else + { + c.Dispose(); + sources.RemoveAt(sources.Count - 1); + } + } while (sources.Count > 0); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } + + bool AddSource(ArgumentEnumerator ae, string argument) + { + foreach (ArgumentSource source in sources) + { + IEnumerable replacement; + if (!source.GetArguments(argument, out replacement)) + continue; + ae.Add(replacement); + return true; + } + return false; + } + + private static bool Unprocessed(ICollection extra, Option def, OptionContext c, string argument) + { + if (def == null) + { + extra.Add(argument); + return false; + } + c.OptionValues.Add(argument); + c.Option = def; + c.Option.Invoke(c); + return false; + } + + private readonly Regex ValueOption = new Regex( + @"^(?--|-|/)(?[^:=]+)((?[:=])(?.*))?$"); + + protected bool GetOptionParts(string argument, out string flag, out string name, out string sep, out string value) + { + if (argument == null) + throw new ArgumentNullException("argument"); + + flag = name = sep = value = null; + Match m = ValueOption.Match(argument); + if (!m.Success) + { + return false; + } + flag = m.Groups["flag"].Value; + name = m.Groups["name"].Value; + if (m.Groups["sep"].Success && m.Groups["value"].Success) + { + sep = m.Groups["sep"].Value; + value = m.Groups["value"].Value; + } + return true; + } + + protected virtual bool Parse(string argument, OptionContext c) + { + if (c.Option != null) + { + ParseValue(argument, c); + return true; + } + + string f, n, s, v; + if (!GetOptionParts(argument, out f, out n, out s, out v)) + return false; + + Option p; + if (Contains(n)) + { + p = this[n]; + c.OptionName = f + n; + c.Option = p; + switch (p.OptionValueType) + { + case OptionValueType.None: + c.OptionValues.Add(n); + c.Option.Invoke(c); + break; + case OptionValueType.Optional: + case OptionValueType.Required: + ParseValue(v, c); + break; + } + return true; + } + // no match; is it a bool option? + if (ParseBool(argument, n, c)) + return true; + // is it a bundled option? + if (ParseBundledValue(f, string.Concat(n + s + v), c)) + return true; + + return false; + } + + private void ParseValue(string option, OptionContext c) + { + if (option != null) + foreach (string o in c.Option.ValueSeparators != null + ? option.Split(c.Option.ValueSeparators, c.Option.MaxValueCount - c.OptionValues.Count, StringSplitOptions.None) + : new string[] { option }) + { + c.OptionValues.Add(o); + } + if (c.OptionValues.Count == c.Option.MaxValueCount || + c.Option.OptionValueType == OptionValueType.Optional) + c.Option.Invoke(c); + else if (c.OptionValues.Count > c.Option.MaxValueCount) + { + throw new OptionException(localizer(string.Format( + "Error: Found {0} option values when expecting {1}.", + c.OptionValues.Count, c.Option.MaxValueCount)), + c.OptionName); + } + } + + private bool ParseBool(string option, string n, OptionContext c) + { + Option p; + string rn; + if (n.Length >= 1 && (n[n.Length - 1] == '+' || n[n.Length - 1] == '-') && + Contains((rn = n.Substring(0, n.Length - 1)))) + { + p = this[rn]; + string v = n[n.Length - 1] == '+' ? option : null; + c.OptionName = option; + c.Option = p; + c.OptionValues.Add(v); + p.Invoke(c); + return true; + } + return false; + } + + private bool ParseBundledValue(string f, string n, OptionContext c) + { + if (f != "-") + return false; + for (int i = 0; i < n.Length; ++i) + { + Option p; + string opt = f + n[i].ToString(); + string rn = n[i].ToString(); + if (!Contains(rn)) + { + if (i == 0) + return false; + throw new OptionException(string.Format(localizer( + "Cannot bundle unregistered option '{0}'."), opt), opt); + } + p = this[rn]; + switch (p.OptionValueType) + { + case OptionValueType.None: + Invoke(c, opt, n, p); + break; + case OptionValueType.Optional: + case OptionValueType.Required: + { + string v = n.Substring(i + 1); + c.Option = p; + c.OptionName = opt; + ParseValue(v.Length != 0 ? v : null, c); + return true; + } + default: + throw new InvalidOperationException("Unknown OptionValueType: " + p.OptionValueType); + } + } + return true; + } + + private static void Invoke(OptionContext c, string name, string value, Option option) + { + c.OptionName = name; + c.Option = option; + c.OptionValues.Add(value); + option.Invoke(c); + } + + private const int OptionWidth = 29; + private const int Description_FirstWidth = 80 - OptionWidth; + private const int Description_RemWidth = 80 - OptionWidth - 2; + + public void WriteOptionDescriptions(TextWriter o) + { + foreach (Option p in this) + { + int written = 0; + + Category c = p as Category; + if (c != null) + { + WriteDescription(o, p.Description, "", 80, 80); + continue; + } + + if (!WriteOptionPrototype(o, p, ref written)) + continue; + + if (written < OptionWidth) + o.Write(new string(' ', OptionWidth - written)); + else + { + o.WriteLine(); + o.Write(new string(' ', OptionWidth)); + } + + WriteDescription(o, p.Description, new string(' ', OptionWidth + 2), + Description_FirstWidth, Description_RemWidth); + } + + foreach (ArgumentSource s in sources) + { + string[] names = s.GetNames(); + if (names == null || names.Length == 0) + continue; + + int written = 0; + + Write(o, ref written, " "); + Write(o, ref written, names[0]); + for (int i = 1; i < names.Length; ++i) + { + Write(o, ref written, ", "); + Write(o, ref written, names[i]); + } + + if (written < OptionWidth) + o.Write(new string(' ', OptionWidth - written)); + else + { + o.WriteLine(); + o.Write(new string(' ', OptionWidth)); + } + + WriteDescription(o, s.Description, new string(' ', OptionWidth + 2), + Description_FirstWidth, Description_RemWidth); + } + } + + void WriteDescription(TextWriter o, string value, string prefix, int firstWidth, int remWidth) + { + bool indent = false; + foreach (string line in GetLines(localizer(GetDescription(value)), firstWidth, remWidth)) + { + if (indent) + o.Write(prefix); + o.WriteLine(line); + indent = true; + } + } + + bool WriteOptionPrototype(TextWriter o, Option p, ref int written) + { + string[] names = p.Names; + + int i = GetNextOptionIndex(names, 0); + if (i == names.Length) + return false; + + if (names[i].Length == 1) + { + Write(o, ref written, " -"); + Write(o, ref written, names[0]); + } + else + { + Write(o, ref written, " --"); + Write(o, ref written, names[0]); + } + + for (i = GetNextOptionIndex(names, i + 1); + i < names.Length; i = GetNextOptionIndex(names, i + 1)) + { + Write(o, ref written, ", "); + Write(o, ref written, names[i].Length == 1 ? "-" : "--"); + Write(o, ref written, names[i]); + } + + if (p.OptionValueType == OptionValueType.Optional || + p.OptionValueType == OptionValueType.Required) + { + if (p.OptionValueType == OptionValueType.Optional) + { + Write(o, ref written, localizer("[")); + } + Write(o, ref written, localizer("=" + GetArgumentName(0, p.MaxValueCount, p.Description))); + string sep = p.ValueSeparators != null && p.ValueSeparators.Length > 0 + ? p.ValueSeparators[0] + : " "; + for (int c = 1; c < p.MaxValueCount; ++c) + { + Write(o, ref written, localizer(sep + GetArgumentName(c, p.MaxValueCount, p.Description))); + } + if (p.OptionValueType == OptionValueType.Optional) + { + Write(o, ref written, localizer("]")); + } + } + return true; + } + + static int GetNextOptionIndex(string[] names, int i) + { + while (i < names.Length && names[i] == "<>") + { + ++i; + } + return i; + } + + static void Write(TextWriter o, ref int n, string s) + { + n += s.Length; + o.Write(s); + } + + private static string GetArgumentName(int index, int maxIndex, string description) + { + if (description == null) + return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1); + string[] nameStart; + if (maxIndex == 1) + nameStart = new string[] { "{0:", "{" }; + else + nameStart = new string[] { "{" + index + ":" }; + for (int i = 0; i < nameStart.Length; ++i) + { + int start, j = 0; + do + { + start = description.IndexOf(nameStart[i], j); + } while (start >= 0 && j != 0 ? description[j++ - 1] == '{' : false); + if (start == -1) + continue; + int end = description.IndexOf("}", start); + if (end == -1) + continue; + return description.Substring(start + nameStart[i].Length, end - start - nameStart[i].Length); + } + return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1); + } + + private static string GetDescription(string description) + { + if (description == null) + return string.Empty; + StringBuilder sb = new StringBuilder(description.Length); + int start = -1; + for (int i = 0; i < description.Length; ++i) + { + switch (description[i]) + { + case '{': + if (i == start) + { + sb.Append('{'); + start = -1; + } + else if (start < 0) + start = i + 1; + break; + case '}': + if (start < 0) + { + if ((i + 1) == description.Length || description[i + 1] != '}') + throw new InvalidOperationException("Invalid option description: " + description); + ++i; + sb.Append("}"); + } + else + { + sb.Append(description.Substring(start, i - start)); + start = -1; + } + break; + case ':': + if (start < 0) + goto default; + start = i + 1; + break; + default: + if (start < 0) + sb.Append(description[i]); + break; + } + } + return sb.ToString(); + } + + private static IEnumerable GetLines(string description, int firstWidth, int remWidth) + { + return StringCoda.WrappedLines(description, firstWidth, remWidth); + } + } +} diff --git a/src/Generator/Program.cs b/src/Generator/Program.cs new file mode 100644 index 00000000..e32ae9ae --- /dev/null +++ b/src/Generator/Program.cs @@ -0,0 +1,181 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using Mono.Options; +using Cxxi; + +public class Options +{ + public bool Verbose = false; + public string IncludeDirs; + public string OutputDir; + public bool ShowHelpText = false; + public bool OutputDebug = false; + public string OutputNamespace; + public List Headers; +} + +class Program +{ + static void ShowHelp(OptionSet options) + { + var module = Process.GetCurrentProcess().MainModule; + var exeName = Path.GetFileName(module.FileName); + Console.WriteLine("Usage: " + exeName + " [options]+ headers"); + Console.WriteLine("Generates C# bindings from C/C++ header files."); + Console.WriteLine(); + Console.WriteLine("Options:"); + options.WriteOptionDescriptions(Console.Out); + } + + bool ParseCommandLineOptions(String[] args) + { + var set = new OptionSet() + { + // Parser options + { "C|compiler=", v => new object() }, + { "D|defines=", v => new object() }, + { "I|include=", v => options.IncludeDirs = v }, + // Generator options + { "ns|namespace=", v => options.OutputNamespace = v }, + { "o|outdir=", v => options.OutputDir = v }, + { "debug", v => options.OutputDebug = true }, + // Misc. options + { "v|verbose", v => { options.Verbose = true; } }, + { "h|?|help", v => options.ShowHelpText = v != null }, + }; + + if (args.Length == 0 || options.ShowHelpText) + { + ShowHelp(set); + return false; + } + + try + { + options.Headers = set.Parse(args); + } + catch (OptionException ex) + { + Console.WriteLine("Error parsing the command line."); + ShowHelp(set); + return false; + } + + return true; + } + + Library library; + Options options; + + public void GenerateCode() + { + Console.WriteLine("Generating wrapper code..."); + + if (library.Modules.Count > 0) + { + var gen = new Generator(library, options); + TransformSDL(gen); + gen.Generate(); + } + } + + public void ParseNativeHeaders() + { + Console.WriteLine("Parsing native code..."); + + foreach (var file in options.Headers) + { + var path = String.Empty; + + try + { + path = Path.GetFullPath(file); + } + catch (ArgumentException ex) + { + Console.WriteLine("Invalid path '" + file + "'."); + continue; + } + + var Opts = new ParserOptions(); + Opts.FileName = path; + Opts.Library = library; + Opts.Verbose = false; + + if (!ClangParser.Parse(Opts)) + { + Console.WriteLine(" Could not parse '" + file + "'."); + continue; + } + + Console.WriteLine(" Parsed '" + file + "'."); + } + } + + void TransformSDL(Generator g) + { + g.IgnoreEnumWithMatchingItem("SDL_FALSE"); + g.IgnoreEnumWithMatchingItem("DUMMY_ENUM_VALUE"); + g.IgnoreEnumWithMatchingItem("SDL_ENOMEM"); + + g.SetNameOfEnumWithMatchingItem("SDL_SCANCODE_UNKNOWN", "ScanCode"); + g.SetNameOfEnumWithMatchingItem("SDLK_UNKNOWN", "Key"); + g.SetNameOfEnumWithMatchingItem("KMOD_NONE", "KeyModifier"); + g.SetNameOfEnumWithMatchingItem("SDL_LOG_CATEGORY_CUSTOM", "LogCategory"); + + g.GenerateEnumFromMacros("InitFlags", "SDL_INIT_(.*)").SetFlags(); + g.GenerateEnumFromMacros("Endianness", "SDL_(.*)_ENDIAN"); + g.GenerateEnumFromMacros("KeyState", "SDL_RELEASED", "SDL_PRESSED"); + + g.GenerateEnumFromMacros("AlphaState", "SDL_ALPHA_(.*)"); + + g.GenerateEnumFromMacros("HatState", "SDL_HAT_(.*)"); + + g.IgnoreModuleWithName("SDL_atomic*"); + g.IgnoreModuleWithName("SDL_endian*"); + g.IgnoreModuleWithName("SDL_main*"); + g.IgnoreModuleWithName("SDL_mutex*"); + g.IgnoreModuleWithName("SDL_stdinc*"); + + g.RemovePrefix("SDL_"); + g.RemovePrefix("SCANCODE_"); + g.RemovePrefix("SDLK_"); + g.RemovePrefix("KMOD_"); + g.RemovePrefix("LOG_CATEGORY_"); + + g.Process(); + + g.FindEnum("PIXELTYPE").Name = "PixelType"; + g.FindEnum("BITMAPORDER").Name = "BitmapOrder"; + g.FindEnum("PACKEDORDER").Name = "PackedOrder"; + g.FindEnum("ARRAYORDER").Name = "ArrayOrder"; + g.FindEnum("PACKEDLAYOUT").Name = "PackedLayout"; + g.FindEnum("PIXELFORMAT").Name = "PixelFormat"; + g.FindEnum("assert_state").Name = "AssertState"; + + //gen.FindEnum("LOG_CATEGORY").Name = "LogCategory"; + } + + public void Run(String[] args) + { + options = new Options(); + + if (!ParseCommandLineOptions(args)) + return; + + library = new Library(options.OutputNamespace); + + ParseNativeHeaders(); + GenerateCode(); + } + + static void Main(String[] args) + { + var program = new Program(); + program.Run(args); + + Console.ReadKey(); + } +} \ No newline at end of file diff --git a/src/Generator/Properties/AssemblyInfo.cs b/src/Generator/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..f9a8c4c5 --- /dev/null +++ b/src/Generator/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Generator")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Microsoft")] +[assembly: AssemblyProduct("Generator")] +[assembly: AssemblyCopyright("Copyright © Microsoft 2012")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("16e665d1-888a-41e4-bb81-02075f7907b2")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/src/Generator/Templates/CSharpModule.cs b/src/Generator/Templates/CSharpModule.cs new file mode 100644 index 00000000..885e2632 --- /dev/null +++ b/src/Generator/Templates/CSharpModule.cs @@ -0,0 +1,684 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version: 10.0.0.0 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ +namespace Cxxi.Templates +{ + using System; + + + #line 1 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + [System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.TextTemplating", "10.0.0.0")] + public partial class CSharpModule : CSharpModuleBase + { + public virtual string TransformText() + { + this.Write("using System;\r\nusing System.Runtime.InteropServices;\r\n\r\nnamespace "); + + #line 6 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + this.Write(this.ToStringHelper.ToStringWithCulture(SafeIdentifier(Library.Name))); + + #line default + #line hidden + this.Write("\r\n{\r\n"); + + #line 8 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + + GenerateDeclarations(); + + + #line default + #line hidden + this.Write("}\r\n\r\n"); + return this.GenerationEnvironment.ToString(); + } + + #line 13 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + +public void GenerateDeclarations() +{ + PushIndent(DefaultIndent); + + bool NeedsNewline = false; + + // Generate all the enum declarations for the module. + for(int i = 0; i < Module.Global.Enums.Count; ++i) + { + var E = Module.Global.Enums[i]; + if (E.Ignore) continue; + + GenerateEnum(E); + NeedsNewline = true; + if (i < Module.Global.Enums.Count - 1) + WriteLine(""); + } + + if (NeedsNewline) + WriteLine(""); + + NeedsNewline = false; + + // Generate all the struct/class declarations for the module. + for(int i = 0; i < Module.Global.Classes.Count; ++i) + { + var C = Module.Global.Classes[i]; + if (C.Ignore) continue; + + GenerateClass(C); + NeedsNewline = true; + if (i < Module.Global.Classes.Count - 1) + WriteLine(""); + } + + if (NeedsNewline) + WriteLine(""); + + if (Module.Global.HasFunctions) + { + WriteLine("public partial class " + SafeIdentifier(Library.Name)); + WriteLine("{"); + PushIndent(DefaultIndent); + } + + // Generate all the function declarations for the module. + foreach(var E in Module.Global.Functions) + { + GenerateFunction(E); + } + + if (Module.Global.HasFunctions) + { + PopIndent(); + WriteLine("}"); + } + + PopIndent(); +} + + + #line default + #line hidden + + #line 75 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + +public void GenerateTypeCommon(Declaration T) +{ + GenerateSummary(T.BriefComment); + GenerateDebug(T); +} + + + #line default + #line hidden + + #line 83 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + +public void GenerateClass(Class C) +{ + if(C.Ignore) return; + GenerateTypeCommon(C); + + Write("public "); + + if (C.IsAbstract) + Write("abstract "); + + Write("class {0}", C.Name); + + if (C.HasBase) + Write(" : {0}", C.Bases[0].Class.Name); + + WriteLine(String.Empty); + WriteLine("{"); + + PushIndent(DefaultIndent); + foreach(var F in C.Fields) + { + GenerateTypeCommon(F); + WriteLine("public {0} {1};", F.Type, F.Name); + } + PopIndent(); + + WriteLine("}"); +} + + + #line default + #line hidden + + #line 115 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + +public void GenerateFunction(Function F) +{ + if(F.Ignore) return; + GenerateTypeCommon(F); + + + #line default + #line hidden + + #line 120 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write("[DllImport(\""); + + + #line default + #line hidden + + #line 121 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write(this.ToStringHelper.ToStringWithCulture(SafeIdentifier(Library.Name))); + + + #line default + #line hidden + + #line 121 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write(".dll\")]\r\npublic static extern "); + + + #line default + #line hidden + + #line 122 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write(this.ToStringHelper.ToStringWithCulture(F.ReturnType)); + + + #line default + #line hidden + + #line 122 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write(" "); + + + #line default + #line hidden + + #line 122 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write(this.ToStringHelper.ToStringWithCulture(SafeIdentifier(F.Name))); + + + #line default + #line hidden + + #line 122 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write("("); + + + #line default + #line hidden + + #line 122 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + +for(int i = 0; i < F.Parameters.Count; ++i) +{ + var P = F.Parameters[i]; + Write("{0} {1}", P.Type, SafeIdentifier(P.Name)); + if (i < F.Parameters.Count - 1) + Write(", "); +} + + + #line default + #line hidden + + #line 130 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write(");\r\n"); + + + #line default + #line hidden + + #line 131 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + +WriteLine(""); +} + + + #line default + #line hidden + + #line 136 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + +public void GenerateDebug(Declaration T) +{ + if(Options.OutputDebug && !String.IsNullOrWhiteSpace(T.DebugText)) + WriteLine("// DEBUG: " + T.DebugText); +} + + + #line default + #line hidden + + #line 144 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + +public void GenerateSummary(string Comment) +{ + if(String.IsNullOrWhiteSpace(Comment)) + return; + + + #line default + #line hidden + + #line 149 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write("/// \r\n/// "); + + + #line default + #line hidden + + #line 151 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write(this.ToStringHelper.ToStringWithCulture(Comment)); + + + #line default + #line hidden + + #line 151 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write("\r\n/// \r\n"); + + + #line default + #line hidden + + #line 153 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + +} + + + #line default + #line hidden + + #line 157 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + +public void GenerateInlineSummary(string Comment) +{ + if(String.IsNullOrWhiteSpace(Comment)) + return; + + + #line default + #line hidden + + #line 162 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write("/// "); + + + #line default + #line hidden + + #line 163 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write(this.ToStringHelper.ToStringWithCulture(Comment)); + + + #line default + #line hidden + + #line 163 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write(" \r\n"); + + + #line default + #line hidden + + #line 164 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + +} + + + #line default + #line hidden + + #line 168 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + +public void GenerateEnum(Enumeration E) +{ + if(E.Ignore) return; + GenerateTypeCommon(E); + + if(E.Modifiers.HasFlag(Enumeration.EnumModifiers.Flags)) + WriteLine("[Flags]"); + + + #line default + #line hidden + + #line 176 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write("public enum "); + + + #line default + #line hidden + + #line 177 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write(this.ToStringHelper.ToStringWithCulture(SafeIdentifier(E.Name))); + + + #line default + #line hidden + + #line 177 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write("\r\n"); + + + #line default + #line hidden + + #line 178 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + +if(E.Type.Type != PrimitiveType.Int32) + WriteLine(" : {0}", E.Type.Type.ConvertToTypeName()); +WriteLine("{"); + +PushIndent(DefaultIndent); +for(int i = 0; i < E.Items.Count; ++i) +{ + var I = E.Items[i]; + GenerateInlineSummary(I.Comment); + if (I.ExplicitValue) + Write(String.Format("{0} = {1}", SafeIdentifier(I.Name), I.Value)); + else + Write(String.Format("{0}", SafeIdentifier(I.Name))); + + if (i < E.Items.Count - 1) + WriteLine(","); +} +PopIndent(); +WriteLine(""); + + + #line default + #line hidden + + #line 198 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" +this.Write("}\r\n"); + + + #line default + #line hidden + + #line 200 "C:\Users\Tritonite\Development\cxxi\src\Generator\Templates\CSharpModule.tt" + +} + + + #line default + #line hidden + } + + #line default + #line hidden + #region Base class + /// + /// Base class for this transformation + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.TextTemplating", "10.0.0.0")] + public class CSharpModuleBase + { + #region Fields + private global::System.Text.StringBuilder generationEnvironmentField; + private global::System.CodeDom.Compiler.CompilerErrorCollection errorsField; + private global::System.Collections.Generic.List indentLengthsField; + private string currentIndentField = ""; + private bool endsWithNewline; + private global::System.Collections.Generic.IDictionary sessionField; + #endregion + #region Properties + /// + /// The string builder that generation-time code is using to assemble generated output + /// + protected System.Text.StringBuilder GenerationEnvironment + { + get + { + if ((this.generationEnvironmentField == null)) + { + this.generationEnvironmentField = new global::System.Text.StringBuilder(); + } + return this.generationEnvironmentField; + } + set + { + this.generationEnvironmentField = value; + } + } + /// + /// The error collection for the generation process + /// + public System.CodeDom.Compiler.CompilerErrorCollection Errors + { + get + { + if ((this.errorsField == null)) + { + this.errorsField = new global::System.CodeDom.Compiler.CompilerErrorCollection(); + } + return this.errorsField; + } + } + /// + /// A list of the lengths of each indent that was added with PushIndent + /// + private System.Collections.Generic.List indentLengths + { + get + { + if ((this.indentLengthsField == null)) + { + this.indentLengthsField = new global::System.Collections.Generic.List(); + } + return this.indentLengthsField; + } + } + /// + /// Gets the current indent we use when adding lines to the output + /// + public string CurrentIndent + { + get + { + return this.currentIndentField; + } + } + /// + /// Current transformation session + /// + public virtual global::System.Collections.Generic.IDictionary Session + { + get + { + return this.sessionField; + } + set + { + this.sessionField = value; + } + } + #endregion + #region Transform-time helpers + /// + /// Write text directly into the generated output + /// + public void Write(string textToAppend) + { + if (string.IsNullOrEmpty(textToAppend)) + { + return; + } + // If we're starting off, or if the previous text ended with a newline, + // we have to append the current indent first. + if (((this.GenerationEnvironment.Length == 0) + || this.endsWithNewline)) + { + this.GenerationEnvironment.Append(this.currentIndentField); + this.endsWithNewline = false; + } + // Check if the current text ends with a newline + if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture)) + { + this.endsWithNewline = true; + } + // This is an optimization. If the current indent is "", then we don't have to do any + // of the more complex stuff further down. + if ((this.currentIndentField.Length == 0)) + { + this.GenerationEnvironment.Append(textToAppend); + return; + } + // Everywhere there is a newline in the text, add an indent after it + textToAppend = textToAppend.Replace(global::System.Environment.NewLine, (global::System.Environment.NewLine + this.currentIndentField)); + // If the text ends with a newline, then we should strip off the indent added at the very end + // because the appropriate indent will be added when the next time Write() is called + if (this.endsWithNewline) + { + this.GenerationEnvironment.Append(textToAppend, 0, (textToAppend.Length - this.currentIndentField.Length)); + } + else + { + this.GenerationEnvironment.Append(textToAppend); + } + } + /// + /// Write text directly into the generated output + /// + public void WriteLine(string textToAppend) + { + this.Write(textToAppend); + this.GenerationEnvironment.AppendLine(); + this.endsWithNewline = true; + } + /// + /// Write formatted text directly into the generated output + /// + public void Write(string format, params object[] args) + { + this.Write(string.Format(global::System.Globalization.CultureInfo.CurrentCulture, format, args)); + } + /// + /// Write formatted text directly into the generated output + /// + public void WriteLine(string format, params object[] args) + { + this.WriteLine(string.Format(global::System.Globalization.CultureInfo.CurrentCulture, format, args)); + } + /// + /// Raise an error + /// + public void Error(string message) + { + System.CodeDom.Compiler.CompilerError error = new global::System.CodeDom.Compiler.CompilerError(); + error.ErrorText = message; + this.Errors.Add(error); + } + /// + /// Raise a warning + /// + public void Warning(string message) + { + System.CodeDom.Compiler.CompilerError error = new global::System.CodeDom.Compiler.CompilerError(); + error.ErrorText = message; + error.IsWarning = true; + this.Errors.Add(error); + } + /// + /// Increase the indent + /// + public void PushIndent(string indent) + { + if ((indent == null)) + { + throw new global::System.ArgumentNullException("indent"); + } + this.currentIndentField = (this.currentIndentField + indent); + this.indentLengths.Add(indent.Length); + } + /// + /// Remove the last indent that was added with PushIndent + /// + public string PopIndent() + { + string returnValue = ""; + if ((this.indentLengths.Count > 0)) + { + int indentLength = this.indentLengths[(this.indentLengths.Count - 1)]; + this.indentLengths.RemoveAt((this.indentLengths.Count - 1)); + if ((indentLength > 0)) + { + returnValue = this.currentIndentField.Substring((this.currentIndentField.Length - indentLength)); + this.currentIndentField = this.currentIndentField.Remove((this.currentIndentField.Length - indentLength)); + } + } + return returnValue; + } + /// + /// Remove any indentation + /// + public void ClearIndent() + { + this.indentLengths.Clear(); + this.currentIndentField = ""; + } + #endregion + #region ToString Helpers + /// + /// Utility class to produce culture-oriented representation of an object as a string. + /// + public class ToStringInstanceHelper + { + private System.IFormatProvider formatProviderField = global::System.Globalization.CultureInfo.InvariantCulture; + /// + /// Gets or sets format provider to be used by ToStringWithCulture method. + /// + public System.IFormatProvider FormatProvider + { + get + { + return this.formatProviderField ; + } + set + { + if ((value != null)) + { + this.formatProviderField = value; + } + } + } + /// + /// This is called from the compile/run appdomain to convert objects within an expression block to a string + /// + public string ToStringWithCulture(object objectToConvert) + { + if ((objectToConvert == null)) + { + throw new global::System.ArgumentNullException("objectToConvert"); + } + System.Type t = objectToConvert.GetType(); + System.Reflection.MethodInfo method = t.GetMethod("ToString", new System.Type[] { + typeof(System.IFormatProvider)}); + if ((method == null)) + { + return objectToConvert.ToString(); + } + else + { + return ((string)(method.Invoke(objectToConvert, new object[] { + this.formatProviderField }))); + } + } + } + private ToStringInstanceHelper toStringHelperField = new ToStringInstanceHelper(); + public ToStringInstanceHelper ToStringHelper + { + get + { + return this.toStringHelperField; + } + } + #endregion + } + #endregion +} diff --git a/src/Generator/Templates/CSharpModule.tt b/src/Generator/Templates/CSharpModule.tt new file mode 100644 index 00000000..d3f62b6e --- /dev/null +++ b/src/Generator/Templates/CSharpModule.tt @@ -0,0 +1,202 @@ +<#@ template debug="true" language="C#" #> +<#@ output extension=".cs" #> +using System; +using System.Runtime.InteropServices; + +namespace <#= SafeIdentifier(Library.Name) #> +{ +<# + GenerateDeclarations(); +#> +} + +<#+ +public void GenerateDeclarations() +{ + PushIndent(DefaultIndent); + + bool NeedsNewline = false; + + // Generate all the enum declarations for the module. + for(int i = 0; i < Module.Global.Enums.Count; ++i) + { + var E = Module.Global.Enums[i]; + if (E.Ignore) continue; + + GenerateEnum(E); + NeedsNewline = true; + if (i < Module.Global.Enums.Count - 1) + WriteLine(""); + } + + if (NeedsNewline) + WriteLine(""); + + NeedsNewline = false; + + // Generate all the struct/class declarations for the module. + for(int i = 0; i < Module.Global.Classes.Count; ++i) + { + var C = Module.Global.Classes[i]; + if (C.Ignore) continue; + + GenerateClass(C); + NeedsNewline = true; + if (i < Module.Global.Classes.Count - 1) + WriteLine(""); + } + + if (NeedsNewline) + WriteLine(""); + + if (Module.Global.HasFunctions) + { + WriteLine("public partial class " + SafeIdentifier(Library.Name)); + WriteLine("{"); + PushIndent(DefaultIndent); + } + + // Generate all the function declarations for the module. + foreach(var E in Module.Global.Functions) + { + GenerateFunction(E); + } + + if (Module.Global.HasFunctions) + { + PopIndent(); + WriteLine("}"); + } + + PopIndent(); +} +#> + +<#+ +public void GenerateTypeCommon(CppType T) +{ + GenerateSummary(T.BriefComment); + GenerateDebug(T); +} +#> + +<#+ +public void GenerateClass(Class C) +{ + if(C.Ignore) return; + GenerateTypeCommon(C); + + Write("public "); + + if (C.IsAbstract) + Write("abstract "); + + Write("class {0}", C.Name); + + if (C.HasBase) + Write(" : {0}", C.Bases[0].Class.Name); + + WriteLine(String.Empty); + WriteLine("{"); + + PushIndent(DefaultIndent); + foreach(var F in C.Fields) + { + GenerateTypeCommon(F); + WriteLine("public {0} {1};", F.Type, F.Name); + } + PopIndent(); + + WriteLine("}"); +} +#> + + +<#+ +public void GenerateFunction(Function F) +{ + if(F.Ignore) return; + GenerateTypeCommon(F); +#> +[DllImport("<#= SafeIdentifier(Library.Name) #>.dll")] +public static extern <#= F.ReturnType #> <#= SafeIdentifier(F.Name) #>(<#+ +for(int i = 0; i < F.Parameters.Count; ++i) +{ + var P = F.Parameters[i]; + Write("{0} {1}", P.Type, SafeIdentifier(P.Name)); + if (i < F.Parameters.Count - 1) + Write(", "); +} +#>); +<#+ +WriteLine(""); +} +#> + +<#+ +public void GenerateDebug(CppType T) +{ + if(Options.OutputDebug && !String.IsNullOrWhiteSpace(T.DebugText)) + WriteLine("// DEBUG: " + T.DebugText); +} +#> + +<#+ +public void GenerateSummary(string Comment) +{ + if(String.IsNullOrWhiteSpace(Comment)) + return; +#> +/// +/// <#= Comment #> +/// +<#+ +} +#> + +<#+ +public void GenerateInlineSummary(string Comment) +{ + if(String.IsNullOrWhiteSpace(Comment)) + return; +#> +/// <#= Comment #> +<#+ +} +#> + +<#+ +public void GenerateEnum(Enumeration E) +{ + if(E.Ignore) return; + GenerateTypeCommon(E); + + if(E.Modifiers.HasFlag(Enumeration.EnumModifiers.Flags)) + WriteLine("[Flags]"); +#> +public enum <#= SafeIdentifier(E.Name) #> +<#+ +if(E.Type.Type != PrimitiveType.Int32) + WriteLine(" : {0}", E.Type.Type.ConvertToTypeName()); +WriteLine("{"); + +PushIndent(DefaultIndent); +for(int i = 0; i < E.Items.Count; ++i) +{ + var I = E.Items[i]; + GenerateInlineSummary(I.Comment); + if (I.ExplicitValue) + Write(String.Format("{0} = {1}", SafeIdentifier(I.Name), I.Value)); + else + Write(String.Format("{0}", SafeIdentifier(I.Name))); + + if (i < E.Items.Count - 1) + WriteLine(","); +} +PopIndent(); +WriteLine(""); +#> +} +<#+ +} +#> \ No newline at end of file diff --git a/src/Generator/Transform.cs b/src/Generator/Transform.cs new file mode 100644 index 00000000..71c87e22 --- /dev/null +++ b/src/Generator/Transform.cs @@ -0,0 +1,177 @@ +using System; +using System.Collections.Generic; +using System.Text.RegularExpressions; +using System.Linq; +using System.Globalization; +using Cxxi; + +public abstract class Transformation +{ + public virtual bool ProcessType(Declaration type) + { + return false; + } + + public virtual bool ProcessEnumItem(Enumeration.Item item) + { + return false; + } +} + +public class RenameTransform : Transformation +{ + public string Pattern; + public string Replacement; + + public RenameTransform(string pattern, string replacement) + { + Pattern = pattern; + Replacement = replacement; + } + + public override bool ProcessType(Declaration type) + { + return Rename(ref type.Name); + } + + public override bool ProcessEnumItem(Enumeration.Item item) + { + return Rename(ref item.Name); + } + + bool Rename(ref string name) + { + string replace = Regex.Replace(name, Pattern, Replacement); + + if (!name.Equals(replace)) + { + name = replace; + return true; + } + + return false; + } +} + +public partial class Generator +{ + public void RemovePrefix(string prefix) + { + Transformations.Add(new RenameTransform(prefix, String.Empty)); + } + + public void RemoveType(Declaration type) + { + + } + + public Enumeration FindEnum(string name) + { + foreach (var module in Library.Modules) + { + var @enum = module.Global.FindEnumWithName(name); + if (@enum != null) + return @enum; + } + + return null; + } + + public Enumeration GetEnumWithMatchingItem(string Pattern) + { + foreach (var module in Library.Modules) + { + Enumeration @enum = module.Global.FindEnumWithItem(Pattern); + if (@enum == null) continue; + return @enum; + } + + return null; + } + + public Module IgnoreModuleWithName(string Pattern) + { + Module module = Library.Modules.Find( + m => Regex.Match(m.FilePath, Pattern).Success); + + if (module != null) + module.Ignore = true; + + return module; + } + + public void IgnoreEnumWithMatchingItem(string Pattern) + { + Enumeration @enum = GetEnumWithMatchingItem(Pattern); + if (@enum != null) + @enum.Ignore = true; + } + + public void SetNameOfEnumWithMatchingItem(string Pattern, string Name) + { + Enumeration @enum = GetEnumWithMatchingItem(Pattern); + if (@enum != null) + @enum.Name = Name; + } + + static bool ParseToNumber(string num, out long val) + { + if (num.StartsWith("0x", StringComparison.CurrentCultureIgnoreCase)) + { + num = num.Substring(2); + + return long.TryParse(num, NumberStyles.HexNumber, + CultureInfo.CurrentCulture, out val); + } + + return long.TryParse(num, out val); + } + + static long ParseMacroExpression(string Expression) + { + long val; + if (ParseToNumber(Expression, out val)) + return val; + // TODO: Handle string expressions + return 0; + } + + public Enumeration.Item GenerateEnumItemFromMacro(MacroDefine macro) + { + var item = new Enumeration.Item(); + item.Name = macro.Name; + item.Expression = macro.Expression; + item.Value = ParseMacroExpression(macro.Expression); + + return item; + } + + public Enumeration GenerateEnumFromMacros(string Name, params string[] Macros) + { + Enumeration @enum = new Enumeration(); + @enum.Name = Name; + + var pattern = String.Join("|", Macros); + var regex = new Regex(pattern); + + foreach (var module in Library.Modules) + { + foreach (var macro in module.Macros) + { + var match = regex.Match(macro.Name); + if (!match.Success) continue; + + var item = GenerateEnumItemFromMacro(macro); + @enum.AddItem(item); + } + + if (@enum.Items.Count > 0) + { + module.Global.Enums.Add(@enum); + break; + } + } + + return @enum; + } +} \ No newline at end of file diff --git a/src/Generator/packages.config b/src/Generator/packages.config new file mode 100644 index 00000000..9ba11398 --- /dev/null +++ b/src/Generator/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file