static int Main(string [] args) { try { return(Main2(args)); } catch (Exception e) { ErrorHelper.Show(e); return(1); } }
public override void Process(IEnumerable <Assembly> input) { base.Process(input); Types = Types.OrderBy((arg) => arg.Type.FullName).OrderBy((arg) => Types.HasClass(arg.Type.BaseType)).ToList(); Console.WriteLine($"\t{Types.Count} types found"); // proceed with extra adjustments before giving results to the generator foreach (var t in Types) { foreach (var uctor in GetUnavailableParentCtors(t)) { var c = new ProcessedConstructor(uctor.Constructor, this) { Unavailable = true }; t.Constructors.Add(c); } } // we want to create wrappers only if the signature does not already exists, e.g. both `.ctor ()` and `.ctor (int i = 0)` can co-exists in .net foreach (var dv in members_with_default_values) { var pt = GetProcessedType(dv.DeclaringType); var ci = dv as ConstructorInfo; if (ci != null) { foreach (var pc in AddDefaultValuesWrappers(ci)) { if (!pt.SignatureExists(pc)) { pt.Constructors.Add(pc); } else { Delayed.Add(ErrorHelper.CreateWarning(1021, $"Constructor `{ci}` has default values for which no wrapper is generated.")); } } continue; } var mi = dv as MethodInfo; foreach (var pm in AddDefaultValuesWrappers(mi)) { if (!pt.SignatureExists(pm)) { pt.Methods.Add(pm); } else { Delayed.Add(ErrorHelper.CreateWarning(1032, $"Method `{mi}` has default values for which no wrapper is generated.")); } } } ErrorHelper.Show(Delayed); }
public override void Process(IEnumerable <Assembly> input) { foreach (var a in input) { var pa = new ProcessedAssembly(a); // ignoring/warning one is not an option as they could be different (e.g. different builds/versions) if (!AddIfUnique(pa)) { throw ErrorHelper.CreateError(12, $"The assembly name `{pa.Name}` is not unique"); } foreach (var t in GetTypes(a)) { if (t.IsEnum) { enums.Add(new ProcessedType(t)); continue; } if (t.IsInterface) { protocols.Add(new ProcessedType(t)); } else { types.Add(new ProcessedType(t)); } extension_type = t.HasCustomAttribute("System.Runtime.CompilerServices", "ExtensionAttribute"); implement_system_icomparable = t.Implements("System", "IComparable"); implement_system_icomparable_t = t.Implements("System", "IComparable`1"); var constructors = GetConstructors(t).OrderBy((arg) => arg.ParameterCount).ToList(); var processedConstructors = PostProcessConstructors(constructors).ToList(); if (processedConstructors.Count > 0) { ctors.Add(t, processedConstructors); } var typeEquals = equals.Where(x => x.Key == t).Select(x => x.Value); var meths = GetMethods(t).OrderBy((arg) => arg.Name).ToList(); var processedMethods = PostProcessMethods(meths, typeEquals).ToList(); if (processedMethods.Count > 0) { methods.Add(t, processedMethods); } var props = new List <PropertyInfo> (); var subscriptProps = new List <PropertyInfo> (); foreach (var pi in GetProperties(t)) { var getter = pi.GetGetMethod(); var setter = pi.GetSetMethod(); // setter only property are valid in .NET and we need to generate a method in ObjC (there's no writeonly properties) if (getter == null) { continue; } // indexers are implemented as methods and object subscripting if ((getter.ParameterCount > 0) || ((setter != null) && setter.ParameterCount > 1)) { subscriptProps.Add(pi); continue; } // we can do better than methods for the more common cases (readonly and readwrite) processedMethods.RemoveAll(x => x.Method == getter); processedMethods.RemoveAll(x => x.Method == setter); props.Add(pi); } props = props.OrderBy((arg) => arg.Name).ToList(); var processedProperties = PostProcessProperties(props).ToList(); if (processedProperties.Count > 0) { properties.Add(t, processedProperties); } if (subscriptProps.Count > 0) { if (subscriptProps.Count > 1) { delayed.Add(ErrorHelper.CreateWarning(1041, $"Indexed properties on {t.Name} is not generated because multiple indexed properties not supported.")); } else { subscriptProperties.Add(t, PostProcessSubscriptProperties(subscriptProps).ToList()); } } // fields will need to be wrapped within properties var f = GetFields(t).OrderBy((arg) => arg.Name).ToList(); var processedFields = PostProcessFields(f).ToList(); if (processedFields.Count > 0) { fields.Add(t, processedFields); } } } types = types.OrderBy((arg) => arg.Type.FullName).OrderBy((arg) => types.Contains(arg.Type.BaseType)).ToList(); Console.WriteLine($"\t{types.Count} types found"); ErrorHelper.Show(delayed); }