private static void AddEnumToOutput(string[] parts, CsNamespace ns, CsEnum en)
{
if (!parts.Any())
{
ns.AddEnum(en);
return;
}
CsClass cl = null;
foreach (var ii in parts)
{
CsClass newClass;
if (cl is null)
{
newClass = ns.GetOrCreateClass(ii);
}
else
{
newClass = cl.GetOrCreateNested(ii);
}
cl = newClass;
}
throw new NotSupportedException("Need nested enum which is not supported by isukces.code yet");
}
public EnumFlagsBuilder(CsEnum target, string none = "None")
{
_target = target;
if (!string.IsNullOrEmpty(none))
{
_target.Items.Add(new CsEnumItem(none)
{
EncodedValue = "0"
});
}
}
protected virtual TsEnum Rewrite(CsEnum csEnum)
{
return(new TsEnum
{
CsType = csEnum.CsType,
Name = csEnum.Name,
ExportKind = TsExportKind.Named,
Values = csEnum.Values
.Select(Rewrite)
.ToArray()
});
}
public void MakeEnumIfNecessary()
{
if (EnumOptions is null)
{
return;
}
var en = new CsEnum(ShortTypeName);
foreach (var i in EnumOptions.Items)
{
en.Items.Add(new CsEnumItem(i.CsValue));
}
TargetNamespace.AddEnum(en);
}
/// <summary>
/// Extension method that will lookup the value of an enumeration by the enumeration type name.
/// </summary>
/// <param name="source">The target <see cref="IDotNetEnum"/> model to get the enumeration value from.</param>
/// <param name="enumName">The target numerical named item to use to lookup the enumeration value.</param>
/// <returns>The target enumeration value or null if it could not be found.</returns>
public static string CSharpFormatEnumValue(this CsEnum source, string enumName)
{
if (source == null)
{
return(null);
}
if (string.IsNullOrEmpty(enumName))
{
return(null);
}
if (!source.Values.Any())
{
return(null);
}
var enumValue = source.Values.Where(v => string.Equals(v.Name, enumName)).Select(v => v.Value).FirstOrDefault();
return(enumValue);
}
/// <summary>
/// Prepares the specified C++ element to a C# element.
/// </summary>
/// <param name="cppElement">The C++ element.</param>
/// <returns>The C# element created and registered to the <see cref="TransformManager"/></returns>
public override CsBase Prepare(CppElement cppElement)
{
var cppEnum = (CppEnum)cppElement;
// Create C# enum
var newEnum = new CsEnum
{
Name = NamingRules.Rename(cppEnum),
CppElement = cppEnum
};
// Get the namespace for this particular include and enum
var nameSpace = Manager.ResolveNamespace(cppEnum);
nameSpace.Add(newEnum);
// Bind C++ enum to C# enum
Manager.BindType(cppEnum.Name, newEnum);
return(newEnum);
}
/// <summary>
/// Maps a C++ Enum to a C# enum.
/// </summary>
/// <param name="newEnum">the C# enum.</param>
private void Process(CsEnum newEnum)
{
var cppEnum = (CppEnum)newEnum.CppElement;
// Get tag from C++ enum
var tag = cppEnum.GetTagOrDefault <MappingRule>();
// Determine enum type. Default is int
string typeName = cppEnum.GetTypeNameWithMapping();
switch (typeName)
{
case "byte":
newEnum.Type = typeof(byte);
newEnum.SizeOf = 1;
break;
case "short":
newEnum.Type = typeof(short);
newEnum.SizeOf = 1;
break;
case "int":
newEnum.Type = typeof(int);
newEnum.SizeOf = 4;
break;
default:
Logger.Error("Invalid type [{0}] for enum [{1}]. Types supported are : int, byte, short", typeName, cppEnum);
break;
}
// Find Root Name of this enum
// All enum items should start with the same root name and the root name should be at least 4 chars
string rootName = cppEnum.Name;
string rootNameFound = null;
bool isRootNameFound = false;
for (int i = rootName.Length; i >= 4 && !isRootNameFound; i--)
{
rootNameFound = rootName.Substring(0, i);
isRootNameFound = true;
foreach (var cppEnumItem in cppEnum.EnumItems)
{
if (!cppEnumItem.Name.StartsWith(rootNameFound))
{
isRootNameFound = false;
break;
}
}
}
if (isRootNameFound)
{
rootName = rootNameFound;
}
// Create enum items for enum
foreach (var cppEnumItem in cppEnum.EnumItems)
{
string enumName = NamingRules.Rename(cppEnumItem, rootName);
string enumValue = cppEnumItem.Value;
var csharpEnumItem = new CsEnumItem(enumName, enumValue)
{
CppElement = cppEnumItem
};
newEnum.Add(csharpEnumItem);
if (cppEnumItem.Name != "None")
{
Manager.BindType(cppEnumItem.Name, csharpEnumItem);
}
}
bool tryToAddNone = tag.EnumHasNone.HasValue ? tag.EnumHasNone.Value : false;
// If C++ enum name is ending with FLAG OR FLAGS
// Then tag this enum as flags and add None if necessary
if (cppEnum.Name.EndsWith("FLAG") || cppEnum.Name.EndsWith("FLAGS"))
{
newEnum.IsFlag = true;
if (!tag.EnumHasNone.HasValue)
{
tryToAddNone = !newEnum.Items.Cast <CsEnumItem>().Any(item => item.Name == "None");
}
}
// Add None value
if (tryToAddNone)
{
var csharpEnumItem = new CsEnumItem("None", "0");
csharpEnumItem.CppElement = new CppElement {
Description = "None."
};
newEnum.Add(csharpEnumItem);
}
}
private void ProcessDefines(ConfigFile file)
{
foreach (var defineRule in file.Extension.OfType <DefineExtensionRule>())
{
CsTypeBase defineType = null;
if (defineRule.Enum != null)
{
var newEnum = new CsEnum
{
Name = defineRule.Enum,
UnderlyingType = !string.IsNullOrWhiteSpace(defineRule.UnderlyingType)
? (CsFundamentalType)typeRegistry.ImportType(defineRule.UnderlyingType)
: null
};
defineType = newEnum;
if (defineRule.SizeOf.HasValue && newEnum.UnderlyingType == null)
{
var size = defineRule.SizeOf.Value;
switch (size)
{
case 1:
newEnum.UnderlyingType = typeRegistry.ImportType(typeof(byte));
break;
case 2:
newEnum.UnderlyingType = typeRegistry.ImportType(typeof(short));
break;
case 4:
newEnum.UnderlyingType = typeRegistry.ImportType(typeof(int));
break;
default:
break;
}
}
}
else if (defineRule.Struct != null)
{
var newStruct = new CsStruct {
Name = defineRule.Struct
};
defineType = newStruct;
if (defineRule.HasCustomMarshal.HasValue)
{
newStruct.HasMarshalType = defineRule.HasCustomMarshal.Value;
}
if (defineRule.IsStaticMarshal.HasValue)
{
newStruct.IsStaticMarshal = defineRule.IsStaticMarshal.Value;
}
if (defineRule.HasCustomNew.HasValue)
{
newStruct.HasCustomNew = defineRule.HasCustomNew.Value;
}
if (defineRule.SizeOf.HasValue)
{
newStruct.SetSize(defineRule.SizeOf.Value);
}
if (defineRule.Align.HasValue)
{
newStruct.Align = defineRule.Align.Value;
}
}
else if (defineRule.Interface != null)
{
var iface = new CsInterface
{
Name = defineRule.Interface,
ShadowName = defineRule.ShadowName,
VtblName = defineRule.VtblName
};
if (defineRule.NativeImplementation != null)
{
iface.NativeImplementation = new CsInterface {
Name = defineRule.NativeImplementation, IsDualCallback = true
};
iface.IsCallback = true;
iface.IsDualCallback = true;
typeRegistry.DefineType(iface.NativeImplementation);
}
defineType = iface;
}
else
{
Logger.Error(LoggingCodes.MissingElementInRule, "Invalid rule [{0}]. Requires one of enum, struct, or interface", defineRule);
continue;
}
// Define this type
typeRegistry.DefineType(defineType);
}
}
private static string GetMask(CsEnum csEnum, params string[] enumItem)
{
var q = enumItem.Distinct().Select(enumName => $"{csEnum.Name}.{enumName}");
return(string.Join(" | ", q));
}
private static string GetMask(CsEnum csEnum, params CsEnumItem[] enumItem)
{
return(GetMask(csEnum, enumItem.Select(a => a.EnumName).ToArray()));
}
private static string GetEnumCondition(string variableName, CsEnum csEnum, CsEnumItem enumItem)
{
var mask = GetMask(csEnum, enumItem);
return($"({variableName} & {mask}) != 0");
}
