public void TestEnumGeneration() { // arrange var draftEnumMember = new CSharpEnumMember { Name = "Draft" }; var finalEnumMember = new CSharpEnumMember { Name = "Final" }; var csharpEnum = new CSharpEnum { Name = "BillStatus", Members = new List <CSharpEnumMember> { draftEnumMember, finalEnumMember } }; var output = new StringWriter(); var expectOutputWriter = new StringWriter(); expectOutputWriter.WriteLine(" public enum BillStatus"); expectOutputWriter.WriteLine(" {"); draftEnumMember.Generate(expectOutputWriter, false); finalEnumMember.Generate(expectOutputWriter, true); expectOutputWriter.WriteLine(" }"); // act csharpEnum.Generate(output); // assert Assert.Equal(expectOutputWriter.GetStringBuilder().ToString(), output.GetStringBuilder().ToString()); }
public static CSharpElement ConvertEnum(CSharpConverter converter, CppEnum cppEnum, CSharpElement context) { var enumName = converter.GetCSharpName(cppEnum, context); var csEnum = new CSharpEnum(enumName) { CppElement = cppEnum }; if (cppEnum.IsAnonymous) { csEnum.Name += "AnonymousEnum"; } var container = converter.GetCSharpContainer(cppEnum, context); container.Members.Add(csEnum); converter.ApplyDefaultVisibility(csEnum, container); csEnum.Comment = converter.GetCSharpComment(cppEnum, csEnum); csEnum.BaseTypes.Add(converter.GetCSharpType(cppEnum.IntegerType, csEnum)); return(csEnum); }
protected override ICSharpType BuildTypeInner() { var type = new CSharpEnum(Identifier); type.Values.AddRange(Schema.Enum.OfType <OpenApiString>().Select(x => new CSharpEnumValue(Naming.Property(x.Value)) { Attributes = { Attributes.EnumMember(x.Value) } })); return(type); }
public static void ProcedureCSharpEnumArg(CSharpEnum x) { Service.ProcedureCSharpEnumArg (x); }
public MyTestClassA(CSharpEnum data) { this.data = data; }
private static void ProcessEnum(CSharpConverterOptions cppOptions, CSharpCompilation csCompilation, string enumPrefix, string enumClassName) { var ns = csCompilation.Members.OfType <CSharpGeneratedFile>().First().Members.OfType <CSharpNamespace>().First(); var rawElfClass = ns.Members.OfType <CSharpClass>().First(); var enumRawFields = rawElfClass.Members.OfType <CSharpField>().Where(x => (x.Modifiers & CSharpModifiers.Const) != 0 && x.Name.StartsWith(enumPrefix)).ToList(); var enumClass = new CSharpStruct(enumClassName) { Modifiers = CSharpModifiers.Partial | CSharpModifiers.ReadOnly }; ns.Members.Add(enumClass); CSharpEnum stdEnum = null; var enumItemType = enumRawFields[0].FieldType; bool isReloc = enumPrefix == "R_"; if (!isReloc) { enumClass.Name = enumClass.Name + "Ex"; stdEnum = new CSharpEnum(enumClassName) { Visibility = CSharpVisibility.Public }; ns.Members.Add(stdEnum); stdEnum.BaseTypes.Add(enumItemType); } var filteredFields = new List <CSharpField>(); foreach (var enumRawField in enumRawFields) { var rawName = enumRawField.Name; string relocArch = null; if (isReloc) { foreach (var mapReloc in MapRelocMachineToArch) { if (rawName.StartsWith(mapReloc.Key)) { relocArch = mapReloc.Value; break; } } if (relocArch == null) { continue; } } // skip lo/hi user if (rawName.StartsWith("DW_") && (rawName.Contains("_lo_") || rawName.Contains("_hi_"))) { continue; } // NUM fields if (rawName.EndsWith("_NUM")) { continue; } filteredFields.Add(enumRawField); var csFieldName = isReloc ? rawName : rawName.Substring(enumPrefix.Length); // discard EM_ if (csFieldName.StartsWith("386")) { csFieldName = $"I{csFieldName}"; } else { switch (csFieldName) { case "88K": csFieldName = "M88K"; break; case "860": csFieldName = "I860"; break; case "960": csFieldName = "I960"; break; default: // assume Motorola if (csFieldName.StartsWith("68")) { csFieldName = $"M{csFieldName}"; } break; } } if (char.IsDigit(csFieldName[0])) { throw new InvalidOperationException($"The enum name `{rawName}` starts with a number and needs to be modified"); } if (rawName.StartsWith("DW_")) { csFieldName = CSharpifyName(csFieldName); } csFieldName = CSharpHelper.EscapeName(csFieldName); var enumField = new CSharpField(csFieldName) { Modifiers = CSharpModifiers.Static | CSharpModifiers.ReadOnly, FieldType = enumClass, Visibility = CSharpVisibility.Public, Comment = enumRawField.Comment, InitValue = relocArch != null ? $"new {enumClass.Name}(ElfArch.{relocArch}, {cppOptions.DefaultClassLib}.{rawName})" : $"new {enumClass.Name}({cppOptions.DefaultClassLib}.{rawName})" }; enumClass.Members.Add(enumField); if (!isReloc) { var stdEnumField = new CSharpEnumItem(csFieldName, $"{cppOptions.DefaultClassLib}.{rawName}"); stdEnum.Members.Add(stdEnumField); } } var toStringInternal = new CSharpMethod() { Name = "ToStringInternal", Visibility = CSharpVisibility.Private, ReturnType = CSharpPrimitiveType.String }; enumClass.Members.Add(toStringInternal); toStringInternal.Body = (writer, element) => { var values = new HashSet <object>(); if (isReloc) { writer.WriteLine("switch (((ulong)Value << 16) | (ulong)Arch.Value)"); } else { writer.WriteLine($"switch (({enumItemType})Value)"); } writer.OpenBraceBlock(); foreach (var rawField in filteredFields) { var cppField = ((CppField)rawField.CppElement); if (isReloc) { string relocMachine = null; foreach (var mapReloc in MapRelocMachineToMachine) { if (rawField.Name.StartsWith(mapReloc.Key)) { relocMachine = mapReloc.Value; break; } } if (relocMachine == null) { continue; } if (!values.Add(relocMachine + "$" + cppField.InitValue.Value)) { continue; } writer.WriteLine($"case ((ulong){cppOptions.DefaultClassLib}.{rawField.Name} << 16) | {cppOptions.DefaultClassLib}.{relocMachine} : return \"{rawField.Name}\";"); } else { if (!values.Add(cppField.InitValue.Value)) { continue; } string descriptionText = rawField.Name; //if (cppField.Comment != null) //{ // descriptionText += " - " + cppField.Comment.ToString().Replace("\"", "\\\""); //} descriptionText = descriptionText.Replace("\r\n", "").Replace("\n", ""); writer.WriteLine($"case {cppOptions.DefaultClassLib}.{rawField.Name}: return \"{descriptionText}\";"); } } writer.WriteLine($"default: return null;"); writer.CloseBraceBlock(); }; }
int ParseArguments(String[] args) { bool help = false; var p = new OptionSet { { "h|?|help", "Show this help message", v => help = v != null }, { "o=|out=", "Set the output directory", v => OutputDir = v }, { "ns=|namespace=", "Set the namespace of the generated code", v => Lib.BaseNamespace = v }, { "lib=", "The base name of the C++ library, i.e. 'qt' for libqt.so", v => Lib.BaseName = v }, { "filters=", "A file containing filter directives for filtering classes", v => FilterFile = v }, { "inline=", "Inline methods in lib are: notpresent (default), present, surrogatelib (present in %lib%-inline)", v => Lib.InlinePolicy = (InlineMethods)Enum.Parse(typeof(InlineMethods), v, true) }, { "abi=", "ABI type: ItaniumAbi, MsvcAbi", v => Lib.AbiType = AbiTypeFromValue(v) } }; try { args = p.Parse(args).ToArray(); } catch (OptionException) { Console.WriteLine("Try `generator --help' for more information."); return(1); } if (help) { p.WriteOptionDescriptions(Console.Error); return(1); } if (args.Length != 1) { Console.WriteLine("Usage: generator <options> <input xml file>"); return(1); } // Code templates LibsTemplate = new CSharpLibs(); ClassTemplate = new CSharpClass(); EnumTemplate = new CSharpEnum(); FunctionTemplate = new CSharpFunction(); InputFileName = args [0]; if (Lib.BaseName == null) { Console.WriteLine("The --lib= option is required."); return(1); } if (Lib.AbiType == null) { Lib.AbiType = typeof(ItaniumAbi).Name; } if (Lib.BaseNamespace == null) { Lib.BaseNamespace = Path.GetFileNameWithoutExtension(Lib.BaseName); } if (OutputDir == null) { OutputDir = "output"; } return(0); }