public override bool VisitEnumItemDecl(Enumeration.Item item)
{
PushBlock(BlockKind.EnumItem);
{
WriteLine("// " + item.Name);
WriteOpenBraceAndIndent();
{
var @enum = item.Namespace as Enumeration;
var ctx = new MarshalContext(Context, CurrentIndentation)
{
ArgName = @enum.GetItemValueAsString(item),
ReturnVarName = "item"
};
var marshal = GetMarshalNativeToManagedPrinter(ctx);
item.Visit(marshal);
if (!string.IsNullOrWhiteSpace(marshal.Context.Before))
{
Write(marshal.Context.Before);
}
WriteLine($"JS_SetPropertyStr(ctx, val, \"{item.Name}\", {marshal.Context.Return});");
}
UnindentAndWriteCloseBrace();
}
PopBlock(NewLineKind.BeforeNextBlock);
return(true);
}
public override bool VisitEnumItemDecl(Enumeration.Item item)
{
if (item.Comment != null)
{
GenerateInlineSummary(item.Comment);
}
var @enum = item.Namespace as Enumeration;
Write($"public static final {@enum.Name} {item.Name} = new {@enum.Name}");
var typeName = @enum.BuiltinType.Visit(TypePrinter);
if (item.ExplicitValue)
{
var value = @enum.GetItemValueAsString(item);
if (@enum.BuiltinType.IsUnsigned)
{
Write($"(new {typeName}({value}));");
}
else
{
Write($"(({typeName}){value});");
}
}
return(true);
}
public virtual bool VisitEnumItemDecl(Enumeration.Item item)
{
if (!VisitDeclaration(item))
{
return(false);
}
return(true);
}
public override bool VisitEnumItemDecl(Enumeration.Item item)
{
if (!item.Name.StartsWith("LibLLVM", System.StringComparison.Ordinal))
{
Diagnostics.Error("Extension enum item {0} in {1}, does not use correct prefix", item.Name, item.TranslationUnit.FileName);
}
return(true);
}
public override bool VisitEnumItemDecl(Enumeration.Item item)
{
if (!base.VisitEnumItemDecl(item))
{
return(false);
}
item.Name = CheckName(item.Name);
return(true);
}
public Enumeration VisitEnum(TypeInfo type)
{
var underlyingType = type.GetEnumUnderlyingType();
var @enum = new Enumeration
{
Name = UnmangleTypeName(type.Name),
BuiltinType = VisitType(underlyingType).Type as BuiltinType
};
HandleNamespace(type, @enum);
if (Options.GeneratorKind == GeneratorKind.CPlusPlus)
{
@enum.Modifiers |= Enumeration.EnumModifiers.Scoped;
}
bool flags = type.HasCustomAttribute("System", "FlagsAttribute");
if (flags)
{
@enum.Modifiers |= Enumeration.EnumModifiers.Flags;
}
foreach (var item in type.DeclaredFields)
{
if (!item.IsLiteral)
{
continue;
}
var enumItem = new Enumeration.Item
{
Namespace = @enum,
Name = item.Name,
ExplicitValue = true
};
var rawValue = item.GetRawConstantValue();
if (@enum.BuiltinType.IsUnsigned)
{
enumItem.Value = Convert.ToUInt64(rawValue);
}
else
{
enumItem.Value = (ulong)Convert.ToInt64(rawValue);
}
@enum.AddItem(enumItem);
}
ManagedNames[@enum] = type.FullName;
return(@enum);
}
public static Enumeration.Item GenerateEnumItemFromMacro(this ASTContext context,
MacroDefinition macro)
{
var item = new Enumeration.Item
{
Name = macro.Name,
Expression = macro.Expression,
Value = ParseMacroExpression(macro.Expression)
};
return(item);
}
public override AST.Declaration VisitEnumerationItem(Enumeration.Item decl)
{
var _item = new AST.Enumeration.Item
{
Expression = decl.Expression,
Value = decl.Value
};
VisitDeclaration(decl, _item);
return(_item);
}
public static Enumeration.Item GenerateEnumItemFromMacro(this Enumeration @enum,
MacroDefinition macro)
{
var item = new Enumeration.Item
{
Name = macro.Name,
Expression = macro.Expression,
Value = ParseMacroExpression(macro.Expression),
Namespace = @enum
};
return(item);
}
public override bool VisitEnumItemDecl(Enumeration.Item item)
{
PushBlock(BlockKind.EnumItem);
WriteLine("// " + item.Name);
WriteLine($"napi_value i_{enumItemIndex};");
var @enum = item.Namespace as Enumeration;
var(_, function) = NAPIMarshalNativeToManagedPrinter.GetNAPIPrimitiveType(@enum.BuiltinType.Type);
WriteLine($"status = {function}(env, {@enum.GetItemValueAsString(item)}, &i_{enumItemIndex++});");
WriteLine("assert(status == napi_ok);");
PopBlock(NewLineKind.BeforeNextBlock);
return(true);
}
public Enumeration VisitEnum(TypeInfo type)
{
var underlyingType = type.GetEnumUnderlyingType();
var @enum = new Enumeration
{
Name = UnmangleTypeName(type.Name),
Type = VisitType(underlyingType).Type
};
HandleNamespace(type, @enum);
if (Options.GeneratorKind == GeneratorKind.CPlusPlus)
{
@enum.Modifiers = Enumeration.EnumModifiers.Scoped;
}
var builtinType = @enum.Type as BuiltinType;
foreach (var item in type.DeclaredFields)
{
if (!item.IsLiteral)
{
continue;
}
var enumItem = new Enumeration.Item
{
Namespace = @enum,
Name = item.Name,
ExplicitValue = true
};
var rawValue = item.GetRawConstantValue();
if (builtinType.IsUnsigned)
{
enumItem.Value = Convert.ToUInt64(rawValue);
}
else
{
enumItem.Value = (ulong)Convert.ToInt64(rawValue);
}
@enum.AddItem(enumItem);
}
return(@enum);
}
public override bool VisitEnumItemDecl(Enumeration.Item item)
{
if (!Targets.HasFlag(RenameTargets.EnumItem))
{
return(false);
}
string newName;
if (Rename(item, out newName))
{
item.Name = newName;
return(true);
}
return(true);
}
public virtual bool VisitEnumItemDecl(Enumeration.Item item)
{
if (item.Comment != null)
{
GenerateInlineSummary(item.Comment);
}
Write(item.Name);
var @enum = item.Namespace as Enumeration;
if (item.ExplicitValue)
{
Write(" = {0}", @enum.GetItemValueAsString(item));
}
return(true);
}
public override bool VisitEnumItemDecl(Enumeration.Item item)
{
if (item.Comment != null)
{
GenerateInlineSummary(item.Comment);
}
var @enum = item.Namespace as Enumeration;
var enumItemName = Options.GeneratorKind == GeneratorKind.C ?
$"{@enum.QualifiedName}_{item.Name}" : item.Name;
Write(enumItemName);
if (item.ExplicitValue)
{
Write($" = {@enum.GetItemValueAsString(item)}");
}
return(true);
}
public override bool VisitEnumItemDecl(Enumeration.Item item)
{
if (!VisitDeclaration(item))
{
return(false);
}
if (item.Comment != null)
{
GenerateInlineSummary(item.Comment);
}
var @enum = item.Namespace as Enumeration;
Write($"public static final {@enum.Name} {item.Name} = new {@enum.Name}");
var typeName = @enum.BuiltinType.Visit(TypePrinter);
if (item.ExplicitValue)
{
var value = @enum.GetItemValueAsString(item);
// We need to explicit check for long int literals.
if (item.Value > Int32.MaxValue)
{
value += "L";
}
if (@enum.BuiltinType.IsUnsigned)
{
Write($"(new {typeName}({value}));");
}
else
{
Write($"(({typeName}){value});");
}
}
return(true);
}
public override bool VisitEnumItemDecl(Enumeration.Item item)
{
if (AlreadyVisited(item))
{
return(true);
}
// Prevents collecting previously generated items when generating enums from macros.
if (item.IsImplicit)
{
return(true);
}
var match = regex.Match(item.Name);
if (match.Success)
{
Items.Add(item);
}
return(true);
}
public override bool VisitEnumItemDecl(Enumeration.Item item)
{
if (!VisitDeclaration(item))
{
return(false);
}
if (item.Comment != null)
{
GenerateInlineSummary(item.Comment);
}
var @enum = item.Namespace as Enumeration;
Write($"case {item.Name}");
if (item.ExplicitValue)
{
Write($" = {@enum.GetItemValueAsString(item)}");
}
return(true);
}
public Enumeration VisitEnum(TypeInfo type)
{
var underlyingType = type.GetEnumUnderlyingType();
var @enum = new Enumeration
{
Name = UnmangleTypeName(type.Name),
Type = VisitType(underlyingType).Type
};
HandleNamespace(type, @enum);
if (Options.Language == GeneratorKind.CPlusPlus)
{
@enum.Modifiers = Enumeration.EnumModifiers.Scoped;
}
foreach (var item in type.DeclaredFields)
{
if (!item.IsLiteral)
{
continue;
}
var @value = Convert.ToUInt64(item.GetRawConstantValue());
var enumItem = new Enumeration.Item
{
Name = item.Name,
Value = @value,
ExplicitValue = true
};
@enum.AddItem(enumItem);
}
return(@enum);
}
public override TypePrinterResult VisitEnumItemDecl(Enumeration.Item item)
{
return($"{VisitEnumDecl((Enumeration)item.Namespace)}::{VisitDeclaration(item)}");
}
void CreateMembers () {
foreach (var ns in Lib.Namespaces) {
var parentClass = ns.ParentNamespace as Class;
var @enum = ns as Enumeration;
if (@enum != null) {
if (parentClass != null)
parentClass.NestedEnums.Add (@enum);
foreach (var enumValue in @enum.Node.Children.Where (o => o.Type == "EnumValue")) {
int val;
var item = new Enumeration.Item { Name = enumValue.Attributes ["name"] };
if (enumValue.HasValue ("init") && int.TryParse (enumValue.Attributes ["init"], out val))
item.Value = val;
@enum.Items.Add (item);
}
continue;
}
var klass = ns as Class;
if (klass == null || !klass.Node.HasValue ("members"))
continue;
klass.MangleType = GetType (klass.Node);
if (parentClass != null)
parentClass.NestedClasses.Add (klass);
int fieldCount = 0;
foreach (Node n in klass.Node ["members"].Split (new[] {' '}, StringSplitOptions.RemoveEmptyEntries).Select (id => Node.IdToNode [id])) {
bool ctor = false;
bool dtor = false;
bool skip = false;
switch (n.Type) {
case "Field":
var fieldType = GetType (GetTypeNode (n));
if (fieldType.ElementType == CppTypes.Unknown && fieldType.ElementTypeName == null)
fieldType = new CppType (CppTypes.Void, CppModifiers.Pointer);
string fieldName;
if (n.Name != "")
fieldName = n.Name;
else
fieldName = "field" + fieldCount++;
klass.Fields.Add (new Field (fieldName, fieldType, (Access)Enum.Parse (typeof (Access), n ["access"])));
break;
case "Constructor":
ctor = true;
break;
case "Destructor":
dtor = true;
break;
case "Method":
break;
default:
continue;
}
if ((!dtor && n.HasValue ("overrides") && CheckPrimaryBases (klass, b => b.Node.CheckValueList ("members", n.Attributes ["overrides"]))) || // excl. virtual methods from primary base (except dtor)
(!n.IsTrue ("extern") && !n.IsTrue ("inline")))
continue;
if (n.IsTrue ("inline") && Lib.InlinePolicy == InlineMethods.NotPresent)
skip = true;
string name = dtor ? "Destruct" : n.Name;
var method = new Method (n) {
Name = name,
Access = (Access)Enum.Parse (typeof (Access), n.Attributes ["access"]),
IsVirtual = n.IsTrue ("virtual"),
IsStatic = n.IsTrue ("static"),
IsConst = n.IsTrue ("const"),
IsInline = n.IsTrue ("inline"),
IsArtificial = n.IsTrue ("artificial"),
IsConstructor = ctor,
IsDestructor = dtor
};
if (method.Access == Access.@private)
skip = true;
if (dtor || method.IsArtificial)
method.GenWrapperMethod = false;
CppType retType;
if (n.HasValue ("returns"))
retType = GetType (n.NodeForAttr ("returns"));
else
retType = CppTypes.Void;
if (retType.ElementType == CppTypes.Unknown) {
retType = CppTypes.Void;
skip = true;
}
if (CppTypeToManaged (retType) == null) {
//Console.WriteLine ("\t\tS: " + retType);
retType = CppTypes.Void;
skip = true;
}
method.ReturnType = retType;
int c = 0;
var argTypes = new List<CppType> ();
foreach (Node arg in n.Children.Where (o => o.Type == "Argument")) {
string argname;
if (arg.Name == null || arg.Name == "")
argname = "arg" + c;
else
argname = arg.Name;
var argtype = GetType (GetTypeNode (arg));
if (argtype.ElementType == CppTypes.Unknown) {
//Console.WriteLine ("Skipping method " + klass.Name + "::" + member.Name + " () because it has an argument with unknown type '" + TypeNodeToString (arg) + "'.");
argtype = new CppType (CppTypes.Void, CppModifiers.Pointer);
skip = true;
}
if (CppTypeToManaged (argtype) == null) {
//Console.WriteLine ("\t\tS: " + argtype);
argtype = new CppType (CppTypes.Void, CppModifiers.Pointer);
skip = true;
}
method.Parameters.Add (new Parameter (argname, argtype));
argTypes.Add (argtype);
c++;
}
if (skip && !method.IsVirtual)
continue;
else if (skip && method.IsVirtual)
method.GenWrapperMethod = false;
// FIXME: More complete type name check
if (ctor && argTypes.Count == 1 && argTypes [0].ElementType == CppTypes.Class && argTypes [0].ElementTypeName == klass.Name && argTypes [0].Modifiers.Count == 2 && argTypes [0].Modifiers.Contains (CppModifiers.Const) && argTypes [0].Modifiers.Contains (CppModifiers.Reference))
method.IsCopyCtor = true;
Console.WriteLine ("\t" + klass.Name + "." + method.Name);
klass.Methods.Add (method);
}
foreach (var method in klass.Methods) {
if (AddAsProperty (klass, method))
method.GenWrapperMethod = false;
}
Field f2 = klass.Fields.FirstOrDefault (f => f.Type.ElementType == CppTypes.Unknown);
if (f2 != null) {
Console.WriteLine ("Skipping " + klass.Name + " because field " + f2.Name + " has unknown type.");
klass.Disable = true;
}
}
}
public CSharpTypePrinterResult VisitEnumItemDecl(Enumeration.Item item)
{
return(VisitDeclaration(item));
}
public override TypePrinterResult VisitEnumItemDecl(Enumeration.Item item)
{
return(string.Format("{0}::{1}",
VisitEnumDecl((Enumeration)item.Namespace), VisitDeclaration(item)));
}
public override bool VisitEnumItemDecl(Enumeration.Item item)
{
var @enum = item.Namespace as Enumeration;
return(VisitPrimitiveType(@enum.BuiltinType.Type));
}
public virtual TypePrinterResult VisitEnumItemDecl(Enumeration.Item item)
{
throw new NotImplementedException();
}
public static Enumeration.Item GenerateEnumItemFromMacro(this ASTContext context,
MacroDefinition macro)
{
var item = new Enumeration.Item
{
Name = macro.Name,
Expression = macro.Expression,
Value = ParseMacroExpression(macro.Expression)
};
return item;
}
public virtual TRet Visit(Parser.AST.Declaration decl)
{
switch (decl.Kind)
{
case DeclarationKind.TranslationUnit:
{
var _decl = new TranslationUnit(decl.__Instance);
return(VisitTranslationUnit(_decl));
}
case DeclarationKind.Namespace:
{
var _decl = new Namespace(decl.__Instance);
return(VisitNamespace(_decl));
}
case DeclarationKind.Typedef:
{
var _decl = new TypedefDecl(decl.__Instance);
return(VisitTypedef(_decl));
}
case DeclarationKind.Parameter:
{
var _decl = new Parameter(decl.__Instance);
return(VisitParameter(_decl));
}
case DeclarationKind.Function:
{
var _decl = new Function(decl.__Instance);
return(VisitFunction(_decl));
}
case DeclarationKind.Method:
{
var _decl = new Method(decl.__Instance);
return(VisitMethod(_decl));
}
case DeclarationKind.Enumeration:
{
var _decl = new Enumeration(decl.__Instance);
return(VisitEnumeration(_decl));
}
case DeclarationKind.EnumerationItem:
{
var _decl = new Enumeration.Item(decl.__Instance);
return(VisitEnumerationItem(_decl));
}
case DeclarationKind.Variable:
{
var _decl = new Variable(decl.__Instance);
return(VisitVariable(_decl));
}
case DeclarationKind.Field:
{
var _decl = new Field(decl.__Instance);
return(VisitField(_decl));
}
case DeclarationKind.AccessSpecifier:
{
var _decl = new AccessSpecifierDecl(decl.__Instance);
return(VisitAccessSpecifier(_decl));
}
case DeclarationKind.Class:
{
var _decl = new Class(decl.__Instance);
return(VisitClass(_decl));
}
case DeclarationKind.ClassTemplate:
{
var _decl = new ClassTemplate(decl.__Instance);
return(VisitClassTemplate(_decl));
}
case DeclarationKind.ClassTemplateSpecialization:
{
var _decl = new ClassTemplateSpecialization(decl.__Instance);
return(VisitClassTemplateSpecialization(_decl));
}
case DeclarationKind.ClassTemplatePartialSpecialization:
{
var _decl = new ClassTemplatePartialSpecialization(decl.__Instance);
return(VisitClassTemplatePartialSpecialization(_decl));
}
case DeclarationKind.FunctionTemplate:
{
var _decl = new FunctionTemplate(decl.__Instance);
return(VisitFunctionTemplate(_decl));
}
case DeclarationKind.MacroDefinition:
{
var _decl = new MacroDefinition(decl.__Instance);
return(VisitMacroDefinition(_decl));
}
case DeclarationKind.MacroExpansion:
{
var _decl = new MacroExpansion(decl.__Instance);
return(VisitMacroExpansion(_decl));
}
}
throw new ArgumentOutOfRangeException();
}
public override bool VisitEnumItem(Enumeration.Item item)
{
item.Name = CheckName(item.Name);
return(base.VisitEnumItem(item));
}
public abstract TRet VisitEnumerationItem(Enumeration.Item decl);
public string VisitEnumItemDecl(Enumeration.Item item)
{
return(string.Format("{0}::{1}",
VisitEnumDecl((Enumeration)item.Namespace), VisitDeclaration(item)));
}
public bool VisitEnumItemDecl(Enumeration.Item item)
{
throw new NotImplementedException();
}
public virtual TypePrinterResult VisitEnumItemDecl(Enumeration.Item item)
{
return(VisitDeclaration(@item));
}
public bool VisitEnumItemDecl(Enumeration.Item item)
{
return(false);
}
