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); }