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);
}
public MyTestClassA(CSharpEnum data)
{
this.data = data;
}
