public GenerateResult GenerateEnum(CppEnum cppEnum)
{
var csEnum = new EnumDeclarationSyntax
{
Modifiers = Modifiers.Internal,
Identifier = cppEnum.Name
};
foreach (var cppMember in cppEnum.Items)
{
csEnum.Members.Add(new EnumMemberDeclarationSyntax
{
Identifier = cppMember.Name,
EqualsValue = new EqualsValueClauseSyntax
{
Value = Syntax.LiteralExpression(cppMember.Value)
}
});
}
return(new GenerateResult(cppEnum)
{
Type = csEnum
});
}
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);
}
/// <summary>
/// Parses a C++ enum declaration.
/// </summary>
private CppEnum ParseEnum(XElement xElement)
{
CppEnum cppEnum = new CppEnum();
cppEnum.Name = xElement.Attribute("name") != null?xElement.Attribute("name").Value : String.Empty;
// Anonymous enum
if (cppEnum.Name.StartsWith("$") || string.IsNullOrEmpty(cppEnum.Name))
{
int enumOffset;
string includeFrom = GetIncludeIdFromFileId(xElement.Attribute("file").Value);
if (!mapIncludeToAnonymousEnumCount.TryGetValue(includeFrom, out enumOffset))
{
mapIncludeToAnonymousEnumCount.Add(includeFrom, enumOffset);
}
cppEnum.Name = includeFrom.ToUpper() + "_ENUM_" + enumOffset;
mapIncludeToAnonymousEnumCount[includeFrom]++;
}
foreach (XElement xEnumItems in xElement.Elements())
{
string enumItemName = xEnumItems.Attribute("name") != null?xEnumItems.Attribute("name").Value : String.Empty;
string enumItemInit = xEnumItems.Attribute("init") != null?xEnumItems.Attribute("init").Value : String.Empty;
cppEnum.Add(new CppEnumItem(enumItemName, enumItemInit));
}
return(cppEnum);
}
public void ContextRuleLimitsWhereMappingRuleExecutes()
{
var config = new ConfigFile
{
Id = nameof(ContextRuleLimitsWhereMappingRuleExecutes),
Namespace = nameof(ContextRuleLimitsWhereMappingRuleExecutes),
Includes =
{
new IncludeRule
{
Attach = true,
File = "cppEnum.h",
Namespace = nameof(ContextRuleLimitsWhereMappingRuleExecutes)
},
new IncludeRule
{
Attach = true,
File = "secondFile.h",
Namespace = nameof(ContextRuleLimitsWhereMappingRuleExecutes)
}
},
Mappings =
{
new Config.ContextRule("cppEnum"),
new MappingRule
{
Enum = "AnotherEnum",
MappingNameFinal = "NewEnum"
},
new ClearContextRule()
}
};
var cppModel = new CppModule("SharpGenTestModule");
var cppInclude = new CppInclude("cppEnum");
var cppEnum = new CppEnum("TestEnum");
var secondInclude = new CppInclude("secondFile");
var cppEnum2 = new CppEnum("AnotherEnum");
cppEnum.AddEnumItem("Element1", "0");
cppEnum.AddEnumItem("Element2", "1");
cppInclude.Add(cppEnum);
cppModel.Add(cppInclude);
var(solution, _) = MapModel(cppModel, config);
Assert.Empty(solution.EnumerateDescendants().OfType <CsEnum>().Where(csEnum => csEnum.Name == "AnotherEnum"));
}
public void Enum()
{
var config = new Config.ConfigFile
{
Id = nameof(Enum),
Assembly = nameof(Enum),
Namespace = nameof(Enum),
Includes =
{
new Config.IncludeRule
{
Attach = true,
File = "cppEnum.h",
Namespace = nameof(Enum)
}
},
Mappings =
{
new Config.RemoveRule
{
Enum = @".*ToRemove\d+"
}
}
};
var cppModel = new CppModule();
var cppInclude = new CppInclude
{
Name = "cppEnum"
};
var cppEnum = new CppEnum
{
Name = "TestEnum"
};
cppInclude.Add(cppEnum);
cppInclude.Add(new CppEnum
{
Name = "EnumToRemove1"
});
cppModel.Add(cppInclude);
var(solution, _) = MapModel(cppModel, config);
var members = solution.EnumerateDescendants();
Assert.Single(members.OfType <CsEnum>());
}
public void ExplicitValues()
{
var config = new Config.ConfigFile
{
Id = nameof(ExplicitValues),
Assembly = nameof(ExplicitValues),
Namespace = nameof(ExplicitValues),
Includes =
{
new Config.IncludeRule
{
Attach = true,
File = "cppEnum.h",
Namespace = nameof(ExplicitValues)
}
}
};
var cppModel = new CppModule();
var cppInclude = new CppInclude
{
Name = "cppEnum"
};
var cppEnum = new CppEnum
{
Name = "TestEnum"
};
cppEnum.AddEnumItem("Element1", "10");
cppEnum.AddEnumItem("Element2", "15");
cppEnum.AddEnumItem("Element3", "10");
cppInclude.Add(cppEnum);
cppModel.Add(cppInclude);
var(solution, _) = MapModel(cppModel, config);
var members = solution.EnumerateDescendants();
Assert.Single(members.OfType <CsEnum>());
var csEnum = members.OfType <CsEnum>().First();
Assert.Single(csEnum.EnumItems.Where(item => item.Name == "Element1" && item.Value == "10"));
Assert.Single(csEnum.EnumItems.Where(item => item.Name == "Element2" && item.Value == "15"));
Assert.Single(csEnum.EnumItems.Where(item => item.Name == "Element3" && item.Value == "10"));
Assert.Equal(typeof(int), csEnum.UnderlyingType.Type);
}
public void ExplicitUnderlyingType(Type underlyingType, string underlyingTypeShortName)
{
var config = new Config.ConfigFile
{
Id = nameof(ExplicitUnderlyingType),
Assembly = nameof(ExplicitUnderlyingType),
Namespace = nameof(ExplicitUnderlyingType),
Includes =
{
new Config.IncludeRule
{
Attach = true,
File = "cppEnum.h",
Namespace = nameof(ExplicitUnderlyingType)
}
}
};
var cppModel = new CppModule();
var cppInclude = new CppInclude
{
Name = "cppEnum"
};
var cppEnum = new CppEnum
{
Name = "TestEnum",
UnderlyingType = underlyingTypeShortName
};
cppInclude.Add(cppEnum);
cppModel.Add(cppInclude);
var(solution, _) = MapModel(cppModel, config);
var members = solution.EnumerateDescendants();
Assert.Single(members.OfType <CsEnum>());
var csEnum = members.OfType <CsEnum>().First();
Assert.Equal(underlyingType, csEnum.UnderlyingType.Type);
}
///////////////////////////////////////////
static void BuildEnum(StringBuilder enumText, CppEnum e, int indentPrefix)
{
bool flags = false;
foreach (var i in e.Items)
{
if (i.ValueExpression != null && i.ValueExpression.ToString().Contains("<<"))
{
flags = true;
break;
}
}
string prefix = new string('\t', indentPrefix);
if (e.Comment != null)
{
enumText.AppendLine(BuildCommentSummary(e.Comment, indentPrefix));
}
if (flags)
{
enumText.AppendLine($"{prefix}[Flags]");
}
enumText.AppendLine($"{prefix}public enum {SnakeToCamel(e.Name, true, 0)} {{");
foreach (var i in e.Items)
{
if (i.Comment != null)
{
enumText.AppendLine(BuildCommentSummary(i.Comment, indentPrefix + 1));
}
if (i.ValueExpression == null)
{
enumText.AppendLine($"{prefix} {SnakeToCamel(i.Name, true, e.Name.Length)},");
}
else
{
enumText.AppendLine($"{prefix} {SnakeToCamel(i.Name, true, e.Name.Length),-12} = {BuildExpression(i.ValueExpression, e.Name)},");
}
}
enumText.AppendLine($"{prefix}}}");
}
public CsEnum(CppEnum cppEnum, string name, CsFundamentalType underlyingType) : base(cppEnum, name)
{
UnderlyingType = underlyingType ?? throw new ArgumentNullException(nameof(underlyingType));
if (cppEnum == null)
{
return;
}
// If C++ enum name is ending with FLAG OR FLAGS, then tag this enum as flags
var cppEnumName = cppEnum.Name;
if (cppEnumName.EndsWith("FLAG") || cppEnumName.EndsWith("FLAGS"))
{
IsFlag = true;
}
var tag = cppEnum.Rule;
IsFlag = tag.EnumHasFlags ?? IsFlag;
}
public void Basic()
{
var config = new ConfigFile
{
Id = nameof(Basic),
Namespace = nameof(Basic),
Includes =
{
new IncludeRule
{
Attach = true,
File = "cppEnum.h",
Namespace = nameof(Basic)
}
}
};
var cppModel = new CppModule("SharpGenTestModule");
var cppInclude = new CppInclude("cppEnum");
var cppEnum = new CppEnum("TestEnum");
cppEnum.AddEnumItem("Element1", "0");
cppEnum.AddEnumItem("Element2", "1");
cppInclude.Add(cppEnum);
cppModel.Add(cppInclude);
var(solution, _) = MapModel(cppModel, config);
var members = solution.EnumerateDescendants();
Assert.Single(members.OfType <CsEnum>());
var csEnum = members.OfType <CsEnum>().First();
Assert.Single(csEnum.EnumItems.Where(item => item.Name == "Element1" && item.Value == "0"));
Assert.Single(csEnum.EnumItems.Where(item => item.Name == "Element2" && item.Value == "1"));
Assert.Equal(TypeRegistry.Int32, csEnum.UnderlyingType);
}
public void ExplicitUnderlyingType(string underlyingType)
{
var config = new ConfigFile
{
Id = nameof(ExplicitUnderlyingType),
Namespace = nameof(ExplicitUnderlyingType),
Includes =
{
new IncludeRule
{
Attach = true,
File = "cppEnum.h",
Namespace = nameof(ExplicitUnderlyingType)
}
}
};
var cppModel = new CppModule("SharpGenTestModule");
var cppInclude = new CppInclude("cppEnum");
var cppEnum = new CppEnum("TestEnum")
{
UnderlyingType = underlyingType
};
cppInclude.Add(cppEnum);
cppModel.Add(cppInclude);
var(solution, _) = MapModel(cppModel, config);
Assert.Single(solution.EnumerateDescendants().OfType <CsEnum>());
var csEnum = solution.EnumerateDescendants().OfType <CsEnum>().First();
Assert.Equal(TypeRegistry.ImportPrimitiveType(underlyingType), csEnum.UnderlyingType);
}
static void WriteEnum(StreamWriter writer, CppEnum e, Config config)
{
var hasValue = e.Items.Where(i => i.ValueExpression != null && !string.IsNullOrEmpty(i.ValueExpression.ToString())).Any();
var enumItemNames = e.Items.Select(i => i.Name).ToArray();
if (config.StripEnumItemCommonPrefix && e.Items.Count > 1)
{
string CommonPrefix(string str, params string[] more)
{
var prefixLength = str
.TakeWhile((c, i) => more.All(s => i < s.Length && s[i] == c))
.Count();
return(str.Substring(0, prefixLength));
}
var prefix = CommonPrefix(e.Items[0].Name, e.Items.Select(i => i.Name).Skip(1).ToArray());
enumItemNames = enumItemNames.Select(n => n.Replace(prefix, "")).ToArray();
}
writer.WriteLine($"pub enum {V.GetVEnumName(config.StripFunctionPrefix(e.Name))} {{");
for (var i = 0; i < e.Items.Count; i++)
{
var item = e.Items[i];
writer.Write($"\t{V.GetVEnumItemName(enumItemNames[i])}");
if (hasValue)
{
writer.Write($" = {item.Value}");
}
writer.WriteLine();
}
writer.WriteLine("}");
writer.WriteLine();
}
private static string GetEnumItemName(CppEnum @enum, string cppEnumItemName, string enumNamePrefix)
{
string enumItemName;
if (@enum.Name == "VkFormat")
{
enumItemName = cppEnumItemName.Substring(enumNamePrefix.Length + 1);
var splits = enumItemName.Split(new[] { '_' }, StringSplitOptions.RemoveEmptyEntries);
if (splits.Length <= 1)
{
enumItemName = char.ToUpperInvariant(enumItemName[0]) + enumItemName.Substring(1).ToLowerInvariant();
}
else
{
var sb = new StringBuilder();
foreach (var part in splits)
{
if (part.Equals("UNORM", StringComparison.OrdinalIgnoreCase))
{
sb.Append("UNorm");
}
else if (part.Equals("SNORM", StringComparison.OrdinalIgnoreCase))
{
sb.Append("SNorm");
}
else if (part.Equals("UINT", StringComparison.OrdinalIgnoreCase))
{
sb.Append("UInt");
}
else if (part.Equals("SINT", StringComparison.OrdinalIgnoreCase))
{
sb.Append("SInt");
}
else if (part.Equals("PACK8", StringComparison.OrdinalIgnoreCase))
{
sb.Append("Pack8");
}
else if (part.Equals("PACK16", StringComparison.OrdinalIgnoreCase))
{
sb.Append("Pack16");
}
else if (part.Equals("PACK32", StringComparison.OrdinalIgnoreCase))
{
sb.Append("Pack32");
}
else if (part.Equals("USCALED", StringComparison.OrdinalIgnoreCase))
{
sb.Append("UScaled");
}
else if (part.Equals("SSCALED", StringComparison.OrdinalIgnoreCase))
{
sb.Append("SScaled");
}
else if (part.Equals("UFLOAT", StringComparison.OrdinalIgnoreCase))
{
sb.Append("UFloat");
}
else if (part.Equals("SFLOAT", StringComparison.OrdinalIgnoreCase))
{
sb.Append("SFloat");
}
else if (part.Equals("SRGB", StringComparison.OrdinalIgnoreCase))
{
sb.Append("SRgb");
}
else if (part.Equals("BLOCK", StringComparison.OrdinalIgnoreCase))
{
sb.Append("Block");
}
else if (part.Equals("IMG", StringComparison.OrdinalIgnoreCase))
{
sb.Append("Img");
}
else if (part.Equals("2PACK16", StringComparison.OrdinalIgnoreCase))
{
sb.Append("2Pack16");
}
else if (part.Equals("3PACK16", StringComparison.OrdinalIgnoreCase))
{
sb.Append("3Pack16");
}
else if (part.Equals("4PACK16", StringComparison.OrdinalIgnoreCase))
{
sb.Append("4Pack16");
}
else if (part.Equals("2PLANE", StringComparison.OrdinalIgnoreCase))
{
sb.Append("2Plane");
}
else if (part.Equals("3PLANE", StringComparison.OrdinalIgnoreCase))
{
sb.Append("3Plane");
}
else if (part.Equals("4PLANE", StringComparison.OrdinalIgnoreCase))
{
sb.Append("4Plane");
}
else
{
sb.Append(part);
}
}
enumItemName = sb.ToString();
}
}
else
{
enumItemName = GetPrettyEnumName(cppEnumItemName, enumNamePrefix);
}
return(enumItemName);
}
protected override void BuildEnum(CodeNamespace ns, CppEnum @enum)
{
var decl = new CodeEnum(GetClassName(@enum.Name));
decl.Type = @enum.IntegerType.GetDisplayName();
if (decl.Type != "int" && decl.Type != "unsigned int")
{
Console.WriteLine(decl.Type);
throw new NotImplementedException();
}
decl.Attributes = CodeAttributes.Public;
decl.Comments.AddVSDocComment(@enum.Comment, "summary");
//bool first = true;
//string pattern = @enum.Items.FirstOrDefault()?.Name ?? string.Empty;
//foreach (CppEnumItem item in @enum.Items)
//{
// while (!item.Name.StartsWith(pattern) && pattern.Length > 0)
// {
// pattern = pattern.Remove(pattern.Length - 1);
// }
// if (!first && char.IsDigit(item.Name[pattern.Length]))
// {
// pattern = null;
// break;
// }
// first = false;
//}
bool first = true;
string pattern = @enum.Items.FirstOrDefault()?.Name ?? string.Empty;
foreach (CppEnumItem item in @enum.Items)
{
while (pattern != null && !item.Name.StartsWith(pattern) && pattern.Length > 0)
{
//pattern = pattern.Remove(pattern.Length - 1);
int split = pattern.TrimEnd('_').LastIndexOf('_') + 1;
if (split == 0)
{
pattern = null;
break;
}
pattern = pattern.Remove(split);
}
if (pattern != null && !first && char.IsDigit(item.Name[pattern.Length]))
{
pattern = null;
break;
}
first = false;
}
foreach (CppEnumItem item in @enum.Items)
{
string name = pattern != null?item.Name.Substring(pattern.Length).ToLowerInvariant().ToUpperCamel() : item.Name;
string value = item.ValueExpression?.ToString();
value = (string.IsNullOrEmpty(value) || value.StartsWith("(")) ? item.Value.ToString() : value;
if (pattern != null)
{
string[] combined = value.Split(' ', StringSplitOptions.RemoveEmptyEntries);
if (combined.Length > 1)
{
for (int i = 0; i < combined.Length; i++)
{
string subVal = combined[i];
if (subVal.StartsWith(pattern))
{
combined[i] = subVal.Substring(pattern.Length).ToLowerInvariant().ToUpperCamel();
}
}
value = string.Join(' ', combined);
}
else if (value.StartsWith(pattern))
{
value = value.Substring(pattern.Length).ToLowerInvariant().ToUpperCamel();
}
}
if (Regex.IsMatch(value, @"\d<<\d"))
{
value = value.Replace("<<", " << ");
}
var itemDecl = new CodeEnumItem(name, value);
itemDecl.Comments.AddVSDocComment(item.Comment, "summary");
decl.Members.Add(itemDecl);
}
ns.Types.Add(decl);
}
private async Task ProcessAsync(CppEnum item)
{
await _enumBuilder.BuildAsync(new [] { item });
}
private static string GetEnumItemName(CppEnum @enum, string cppEnumItemName, string enumNamePrefix)
{
string enumItemName = GetPrettyEnumName(cppEnumItemName, enumNamePrefix);
return(enumItemName);
}
protected abstract void BuildEnum(CodeNamespace ns, CppEnum @enum);
public override bool VisitCppEnum(CppEnum cppEnum)
{
Enumeration @enum = new Enumeration();
return(base.VisitCppEnum(cppEnum));
}
