public void Child4()
{
NativeEnum e1 = new NativeEnum("e1");
e1.Members.Add(new NativeMember("m1", new NativeBuiltinType(BuiltinType.NativeByte)));
VerifyTree(e1, "e1");
}
/// <summary>
/// Generate the specified enumeration
/// </summary>
/// <param name="ntEnum"></param>
/// <returns></returns>
/// <remarks></remarks>
public CodeTypeDeclaration GenerateEnum(NativeEnum ntEnum)
{
if (ntEnum == null)
{
throw new ArgumentNullException("ntEnum");
}
// Generate the type
CodeTypeDeclaration ctd = new CodeTypeDeclaration();
ctd.Name = ntEnum.Name;
ctd.IsEnum = true;
ctd.UserData[TransformConstants.DefinedType] = ntEnum;
// Add the values
foreach (NativeEnumValue enumValue in ntEnum.Values)
{
CodeMemberField member = new CodeMemberField();
member.Name = enumValue.Name;
if (enumValue.Value != null && !string.IsNullOrEmpty(enumValue.Value.Expression))
{
GenerateInitExpression(member, enumValue, enumValue.Value);
// Regardless of what the generation code believes, we want the type of the member field
// to be an integer because this is a specific enum value.
member.Type = new CodeTypeReference(typeof(Int32));
}
ctd.Members.Add(member);
}
return(ctd);
}
public void Child5()
{
NativeEnum e1 = new NativeEnum("e1");
e1.Values.Add(new NativeEnumValue("e1", "n1", "v1"));
e1.ReplaceChild(e1.Values[0], new NativeEnumValue("e1", "n2", "v2"));
VerifyTree(e1, "e1(n2(Value(v2)))");
}
public void Child3()
{
NativeEnum e1 = new NativeEnum("e1");
e1.AddValue("n1", "v1");
VerifyTree(e1, "e1(n1(Value(v1)))");
e1.AddValue("n2", "v2");
VerifyTree(e1, "e1(n1(Value(v1)))(n2(Value(v2)))");
}
public void Invalid2()
{
NativeSymbolBag bag = new NativeSymbolBag(StorageFactory.CreateStandard());
NativeEnum e1 = new NativeEnum("e1");
e1.AddValue("v1", "(S1)5");
bag.AddDefinedType(e1);
VerifyEnumValue(bag, e1, "v1", "\"(S1)5\"");
}
public void Gen4()
{
NativeSymbolBag bag = new NativeSymbolBag();
bag.AddConstant(new NativeConstant("C1", "42"));
NativeEnum e1 = new NativeEnum("e1");
e1.AddValue("v1", "C1+2");
bag.AddDefinedType(e1);
VerifyEnumValue(bag, e1, "v1", string.Format("({0}.C1 + 2)", TransformConstants.NativeConstantsName));
}
public void Gen2()
{
NativeSymbolBag bag = new NativeSymbolBag();
NativeEnum e1 = new NativeEnum("e1");
e1.AddValue("v1", "2");
e1.AddValue("v2", "v1+1");
bag.AddEnumAndValues(e1);
VerifyEnumValue(bag, e1, "v1", "2");
VerifyEnumValue(bag, e1, "v2", "(e1.v1 + 1)");
}
public void Value2()
{
NativeSymbolBag bag = new NativeSymbolBag();
NativeEnum ntEnum = new NativeEnum("Enum1");
ntEnum.AddValue("v1", "1");
ntEnum.AddValue("v2", "v1+1");
bag.AddDefinedType(ntEnum);
Assert.Equal(1, bag.FindUnresolvedNativeValues().Count);
Assert.True(bag.TryResolveSymbolsAndValues());
}
public void EnumWithValues()
{
var e = new NativeEnum("e1");
e.Values.Add(new NativeEnumValue("e1", "v1"));
e.Values.Add(new NativeEnumValue("e1", "v2"));
var storage = new BasicSymbolStorage();
storage.AddEnumAndValues(e);
TestRoundTrip(storage);
}
public void EnumAdd()
{
var enumeration = new NativeEnum("e");
enumeration.AddValue("v1", "1");
enumeration.AddValue("v2", "2");
_storage.AddDefinedType(enumeration);
Assert.True(_storage.Contains("v1"));
Assert.True(_storage.Contains("v2"));
}
private void WriteEnum(NativeEnum e)
{
_writer.WriteNameKind(NativeNameKind.Enum);
_writer.WriteString(e.Name);
_writer.WriteInt32(e.Values.Count);
foreach (var value in e.Values)
{
_writer.WriteString(value.Name);
_writer.WriteString(value.Value.Expression);
}
}
public void EnumEquality3()
{
NativeEnum e1 = new NativeEnum("e");
NativeEnum e2 = new NativeEnum("e");
e1.Values.Add(new NativeEnumValue("e", "v1"));
e2.Values.Add(new NativeEnumValue("e", "v2"));
NativeTypeEqualityComparer eq = NativeTypeEqualityComparer.TopLevel;
Assert.False(eq.Equals1(e1, e2));
}
public void EnumEquality2()
{
NativeEnum e1 = new NativeEnum("e");
NativeEnum e2 = new NativeEnum("e");
e1.AddValue("v1", "foo");
e2.AddValue("v1", "");
NativeTypeEqualityComparer eq = NativeTypeEqualityComparer.TopLevel;
Assert.False(eq.Equals1(e1, e2));
}
public void IgnoreNamedTypes()
{
NativeEnum e1 = new NativeEnum("e");
NativeEnum e2 = new NativeEnum("e");
NativeNamedType n2 = new NativeNamedType("e", e2);
e1.Values.Add(new NativeEnumValue("e", "v1"));
e2.Values.Add(new NativeEnumValue("e", "v1"));
NativeTypeEqualityComparer eq = NativeTypeEqualityComparer.TopLevel;
Assert.True(eq.Equals1(e1, n2));
}
private NativeGlobalSymbol ImportEnum()
{
var e = new NativeEnum(_reader.ReadString());
var count = _reader.ReadInt32();
for (var i = 0; i < count; i++)
{
var name = _reader.ReadString();
var value = _reader.ReadString();
e.AddValue(name, value);
}
return(new NativeGlobalSymbol(e));
}
public void ValueFromStorage2()
{
var ns = new BasicSymbolStorage();
var bag = new NativeSymbolBag(ns);
NativeEnum ntEnum = new NativeEnum("e1");
ntEnum.AddValue("v1", "5");
bag.AddDefinedType(ntEnum);
NativeConstant ntConst1 = new NativeConstant("c1", "5+v1");
bag.AddConstant(ntConst1);
Assert.Equal(1, bag.FindUnresolvedNativeValues().Count);
Assert.True(bag.TryResolveSymbolsAndValues());
}
private void VerifyEnum(NativeType nt, string name, params string[] args)
{
NativeEnum ntEnum = nt as NativeEnum;
Assert.NotNull(ntEnum);
Assert.Equal(name, ntEnum.Name);
List<NativeEnumValue> list = new List<NativeEnumValue>(ntEnum.Values);
for (int i = 0; i <= args.Length - 1; i += 2)
{
Assert.True(list.Count > 0, "No more values");
string valueName = args[i];
string valueValue = args[i + 1];
NativeEnumValue ntValue = list[0];
list.RemoveAt(0);
Assert.Equal(valueName, ntValue.Name);
Assert.Equal(valueValue, ntValue.Value.Expression);
}
}
private static string GetManagedEnum(NativeEnum nativeEnum)
{
var commonPrefix = GetCommonPrefix(nativeEnum.Values.Select(e => e.Name)).If(p => p.EndsWith("_"));
var commonSuffix = GetCommonSuffix(nativeEnum.Values.Select(e => e.Name)).If(p => p.StartsWith("_"));
var prefixLength = commonPrefix?.Length ?? 0;
var suffixLength = commonSuffix?.Length ?? 0;
var guessedEnumName =
(prefixLength >= suffixLength) ? Regex.Replace(SnakeCaseToPascalCase(commonPrefix.TrimEnd('_')), "^Rocksdb", "", RegexOptions.IgnoreCase) :
(suffixLength > 0) ? SnakeCaseToPascalCase(commonSuffix.TrimStart('_')) :
"(Unable To Guess Name)";
var enumName = nativeEnum.Name.OrElse(guessedEnumName).OrElse(ManualEnumName(nativeEnum));
var values = nativeEnum.Values
.Select(v => $" {SnakeCaseToPascalCase(v.Name.Substring(prefixLength, v.Name.Length - prefixLength - suffixLength))} = {v.Value},\n");
return($"\npublic enum {enumName}\n{{\n{string.Join("", values)}}}\n");
/*
* if (enumName == "")
* enumName = EnumNamesForValues[entries.First().Name];
* var entriesOut = entries.Select(e => $" {SnakeCaseToPascalCase(e.Name.Substring(commonPrefix.Length))} = {e.Value},");
* return $"}}\npublic enum {enumName} {{\n{string.Join("\n", entriesOut)}\n}}\npublic abstract partial class Native {{";
*/
throw new NotImplementedException();
}
private bool EqualsDefinedCore(NativeDefinedType left, NativeDefinedType right)
{
if (left.IsAnonymous && right.IsAnonymous)
{
// don't compare names when both types are anonymous
}
else if (0 != string.CompareOrdinal(left.Name, right.Name))
{
return(false);
}
// If this is an enum, compare the values
if (left.Kind == NativeSymbolKind.EnumType)
{
NativeEnum leftEnum = (NativeEnum)left;
NativeEnum rightEnum = (NativeEnum)right;
if (rightEnum.Values.Count != leftEnum.Values.Count)
{
return(false);
}
for (int i = 0; i <= leftEnum.Values.Count - 1; i++)
{
NativeEnumValue e1 = leftEnum.Values[i];
NativeEnumValue e2 = rightEnum.Values[i];
if (0 != string.CompareOrdinal(e1.Name, e2.Name) || 0 != string.CompareOrdinal(e1.Value.Expression, e2.Value.Expression))
{
return(false);
}
}
}
return(true);
}
public static bool TryGetEnumByValueName(this INativeSymbolLookup lookup, string enumValueName, out NativeEnum enumeration, out NativeEnumValue value)
{
if (!lookup.TryGetGlobalSymbol(new NativeName(enumValueName, NativeNameKind.EnumValue), out value))
{
enumeration = null;
return(false);
}
return(lookup.TryGetGlobalSymbol(
new NativeName(value.EnumName, NativeNameKind.Enum),
out enumeration));
}
public void EnumSimple()
{
var ns = new NativeEnum("e1");
TestRoundTrip(ns);
}
internal EnumDeclarationSyntax GenerateEnum(NativeEnum nativeEnum)
{
throw new NotSupportedException();
}
public static void VerifyEnumValue(NativeSymbolBag bag, NativeEnum e, string name, string val)
{
VerifyEnumValue(LanguageType.VisualBasic, bag, e, name, val);
}
/* Some enum names can't be guessed because there are no clues, * Damn you, C enums! * So if that happens, we can just manually enter them here */ private static string ManualEnumName(NativeEnum nativeEnum) => nativeEnum.Values.Any(v => v.Name == "rocksdb_enable_time_except_for_mutex") ? "PerfLevel" : nativeEnum.Values.Any(v => v.Name == "rocksdb_user_key_comparison_count") ? "PerfMetric" : "";
/// <summary>
/// Find all NativeEnum which have a value of this name in this lookup.
/// </summary>
public static bool TryGetEnumByValueName(this INativeSymbolLookup lookup, string enumValueName, out NativeEnum enumeration)
{
NativeEnumValue value;
return(TryGetEnumByValueName(lookup, enumValueName, out enumeration, out value));
}
public static void VerifyEnumValue(LanguageType lang, NativeSymbolBag bag, NativeEnum e, string name, string val)
{
Assert.True(bag.TryResolveSymbolsAndValues());
BasicConverter con = new BasicConverter(lang, StorageFactory.CreateStandard());
CodeTypeDeclarationCollection col = con.ConvertToCodeDom(bag, new ErrorProvider());
// Look for the constants class
CodeTypeDeclaration ctd = null;
foreach (CodeTypeDeclaration cur in col)
{
if (0 == string.CompareOrdinal(e.Name, cur.Name))
{
ctd = cur;
break;
}
}
Assert.NotNull(ctd);
// Find the value
CodeTypeMember cMem = null;
foreach (CodeTypeMember mem in ctd.Members)
{
if (0 == string.CompareOrdinal(name, mem.Name))
{
cMem = mem;
break;
}
}
Assert.NotNull(cMem);
// Make sure it's a constant value
CodeMemberField field = cMem as CodeMemberField;
Assert.NotNull(field);
// Get the provider
var provider = default(CodeDomProvider);
switch (lang)
{
case LanguageType.CSharp:
provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case LanguageType.VisualBasic:
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
default:
provider = null;
break;
}
using (var writer = new StringWriter())
{
provider.GenerateCodeFromExpression(field.InitExpression, writer, new CodeGeneratorOptions());
Assert.Equal(val, writer.ToString());
}
}
public static void AddEnumAndValues(this INativeSymbolStorage storage, NativeEnum enumeration)
{
// Enumerations are already special cased hence this behavior is automatic.
// https://github.com/jaredpar/pinvoke/issues/16
storage.Add(new NativeGlobalSymbol(enumeration));
}
