private static string AppendCopyright(this string input, IDecl declaration) { string package = PyExtensions.GetPackage(declaration); string dcCopyright = @"# Copyright (C) 2013-present The DataCentric Authors. # # Licensed under the Apache License, Version 2.0 (the ""License""); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an ""AS IS"" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. "; if (package == "datacentric") { return(dcCopyright + input); } else { throw new Exception($"Copyright header is not specified for module {package}."); } }
/// <summary> /// Return top level package name for given declaration. /// </summary> public static string GetPackage(IDecl decl) { if (decl.Module.ModuleName.StartsWith("DataCentric")) { return("datacentric"); } throw new Exception($"Unknown module: {decl.Module.ModuleName}"); }
public Decl(DeclKind kind, IDecl parent) { Kind = kind; Parent = parent as Decl; if (Parent != null) { Parent.Decls.Add(this); } }
private static string GetIncludePath(IDecl decl) { var settings = GeneratorSettingsProvider.Get(decl.Module.ModuleName); // Avoid adding trailing path separator return(!string.IsNullOrEmpty(decl.Category) && !decl.Category.Equals(".") ? $"{settings.Namespace}.{decl.Category}".Underscore().Replace('.', '/') : $"{settings.Namespace}".Underscore().Replace('.', '/')); }
int Compare(IDecl decl1, IDecl decl2) { if (decl1 is LocalDecl && decl2 is LocalDecl) { LocalDecl aDecl1 = (LocalDecl)decl1; LocalDecl aDecl2 = (LocalDecl)decl2; if (aDecl1.ParentMethod != aDecl2.ParentMethod) { return(aDecl1.ParentMethod.GetHashCode().CompareTo(aDecl2.ParentMethod.GetHashCode()));//Here, I assume that the hash codes will always be diffrent. } } return(decl1.Name.CompareTo(decl2.Name)); }
/// <summary> /// Translate the exploded guy into a C# declaration /// </summary> /// <param name="r"></param> /// <returns></returns> internal static string TranslateToCSharp(IDecl r) { if (r is RegularDecl) { var typ = (r as RegularDecl).Type; typ = TypeDefTranslator.ResolveTypedef(typ); if (typ == "string") { throw new NotImplementedException("Unable to translate the C++ type of string"); } var clsInfo = ROOTNET.NTClass.GetClass(typ); if (clsInfo != null) { if (!clsInfo.IsShellTClass()) { typ = "ROOTNET.Interface.N" + typ; } else { typ = typ.SanitizedName(); } } else { typ = typ.SimpleCPPTypeToCSharpType(); } if (typ == null) { throw new InvalidOperationException("Don't know how to deal with type '" + (r as RegularDecl).Type + "'."); } return(typ); } var t = r as TemplateInfo; if (t.TemplateName != "vector") { throw new NotImplementedException("Don't know how to deal with anything but a vector right now!"); } var argTrans = TranslateToCSharp(t.Arguments[0]); return(argTrans + "[]"); }
public class AccessSpecDecl : Decl { internal AccessSpecDecl(IDecl parent) : base(DeclKind.AccessSpec, parent) { }
public class NamespaceAliasDecl : NamedDecl { internal NamespaceAliasDecl(IDecl parent) : base(DeclKind.NamespaceAlias, parent) { }
internal NamedDecl(DeclKind kind, IDecl parent) : base(kind, parent) { }
internal LabelDecl(IDecl parent) : base(DeclKind.Label, parent) { }
/// <summary> /// Add import statements for given declaration. /// </summary> public static void WriteImports(TypeDecl decl, List <IDecl> declarations, CodeWriter writer) { // Always import attr module writer.AppendLine("import attr"); // Instant is generated as Union[dt.datetime, dc.Instant] thus dt import is required if (decl.Elements.Any(e => e.Value != null && (e.Value.Type == ValueParamType.Instant || e.Value.Type == ValueParamType.NullableInstant))) { writer.AppendLine("import datetime as dt"); } // If type is abstract - ABC import is needed if (decl.Kind == TypeKind.Abstract) { writer.AppendLine("from abc import ABC"); } // Check if ObjectId is used bool hasObjectId = decl.Elements.Any(e => e.Value != null && (e.Value.Type == ValueParamType.TemporalId || e.Value.Type == ValueParamType.NullableTemporalId)); if (hasObjectId) { writer.AppendLine("from bson import ObjectId"); } // Check imports from typing var typingImports = new List <string>(); // Python 3.8 // if (decl.Keys.Any() || decl.Kind == TypeKind.Final) // typingImports.Add("final"); if (decl.Elements.Any(e => e.Vector == YesNo.Y)) { typingImports.Add("List"); } if (typingImports.Any()) { var items = string.Join(", ", typingImports); writer.AppendLine($"from typing import {items}"); } bool insideDc = PyExtensions.GetPackage(decl) == "datacentric"; List <string> packagesToImport = new List <string>(); List <string> individualImports = new List <string>(); // Import parent class package as its namespace, or if inside the same package, // import individual class instead if (decl.Inherit != null) { if (PyExtensions.IsPackageEquals(decl, decl.Inherit)) { IDecl parentDecl = declarations.FindByKey(decl.Inherit); individualImports.Add($"from {parentDecl.Category} import {decl.Inherit.Name}"); } else { packagesToImport.Add(PyExtensions.GetPackage(decl.Inherit)); } } // Import datacentric package as dc, or if inside datacentric, // import individual classes instead else if (decl.IsRecord) { if (insideDc) { individualImports.Add("from datacentric.storage.record import Record"); } else { packagesToImport.Add("datacentric"); } } // First child class of Data else { if (insideDc) { individualImports.Add("from datacentric.storage.data import Data"); } else { packagesToImport.Add("datacentric"); } } foreach (var data in decl.Elements.Where(d => d.Data != null).Select(d => d.Data)) { if (PyExtensions.IsPackageEquals(decl, data)) { IDecl dataDecl = declarations.FindByKey(data); individualImports.Add($"from {dataDecl.Category} import {data.Name}"); } else { packagesToImport.Add(PyExtensions.GetPackage(data)); } } foreach (var enumElement in decl.Elements.Where(d => d.Enum != null).Select(d => d.Enum)) { if (PyExtensions.IsPackageEquals(decl, enumElement)) { IDecl enumDecl = declarations.FindByKey(enumElement); individualImports.Add($"from {enumDecl.Category} import {enumElement.Name}"); } else { packagesToImport.Add(PyExtensions.GetPackage(enumElement)); } } foreach (var package in packagesToImport.Distinct()) { writer.AppendLine($"import {package} as {PyExtensions.GetAlias(package)}"); } foreach (var import in individualImports.Distinct()) { writer.AppendLine(import); } }
public class FriendDecl : Decl { internal FriendDecl(IDecl parent) : base(DeclKind.Friend, parent) { }
/// <summary> /// Translate the exploded guy into a C# declaration /// </summary> /// <param name="r"></param> /// <returns></returns> internal static string TranslateToCSharp(IDecl r) { if (r is RegularDecl) { var typ = (r as RegularDecl).Type; typ = TypeDefTranslator.ResolveTypedef(typ); if (typ == "string") { throw new NotImplementedException("Unable to translate the C++ type of string"); } var clsInfo = ROOTNET.NTClass.GetClass(typ); if (clsInfo != null) { if (!clsInfo.IsShellTClass()) typ = "ROOTNET.Interface.N" + typ; else typ = typ.SanitizedName(); } else { typ = typ.SimpleCPPTypeToCSharpType(); } if (typ == null) throw new InvalidOperationException("Don't know how to deal with type '" + (r as RegularDecl).Type + "'."); return typ; } var t = r as TemplateInfo; if (t.TemplateName != "vector") { throw new NotImplementedException("Don't know how to deal with anything but a vector right now!"); } var argTrans = TranslateToCSharp(t.Arguments[0]); return argTrans + "[]"; }
public class ObjCCategoryDecl : ObjCContainerDecl { internal ObjCCategoryDecl(IDecl parent) : base(DeclKind.ObjCCategory, parent) { }
public class PragmaDetectMismatchDecl : Decl { internal PragmaDetectMismatchDecl(IDecl parent) : base(DeclKind.PragmaDetectMismatch, parent) { }
public class StaticAssertDecl : Decl { internal StaticAssertDecl(IDecl parent) : base(DeclKind.StaticAssert, parent) { }
public class PragmaCommentDecl : Decl { internal PragmaCommentDecl(IDecl parent) : base(DeclKind.PragmaComment, parent) { }
public class ObjCPropertyImplDecl : Decl { internal ObjCPropertyImplDecl(IDecl parent) : base(DeclKind.ObjCPropertyImpl, parent) { }
public class OMPThreadPrivateDecl : Decl { internal OMPThreadPrivateDecl(IDecl parent) : base(DeclKind.OMPThreadPrivate, parent) { }
public class ObjCCompatibleAliasDecl : NamedDecl { internal ObjCCompatibleAliasDecl(IDecl parent) : base(DeclKind.ObjCCompatibleAlias, parent) { }
public class OMPDeclareReductionDecl : ValueDecl { internal OMPDeclareReductionDecl(IDecl parent) : base(DeclKind.OMPDeclareReduction, parent) { }
public class ObjCContainerDecl : NamedDecl { internal ObjCContainerDecl(DeclKind kind, IDecl parent) : base(kind, parent) { }
public class IndirectFieldDecl : ValueDecl { internal IndirectFieldDecl(IDecl parent) : base(DeclKind.IndirectField, parent) { }
public class VarTemplatePartialSpecializationDecl : VarTemplateSpecializationDecl { internal VarTemplatePartialSpecializationDecl(IDecl parent) : base(DeclKind.VarTemplatePartialSpecialization, parent) { }
public class EnumConstantDecl : ValueDecl { internal EnumConstantDecl(IDecl parent) : base(DeclKind.EnumConstant, parent) { }
public class TranslationUnitDecl : Decl { internal TranslationUnitDecl(IDecl parent) : base(DeclKind.TranslationUnit, parent) { }
public class UnresolvedUsingValueDecl : ValueDecl { internal UnresolvedUsingValueDecl(IDecl parent) : base(DeclKind.UnresolvedUsingValue, parent) { }
public TemplateInfo(string templateName, IDecl[] args) { TemplateName = templateName; Arguments = args; }
public class FriendTemplateDecl : Decl { internal FriendTemplateDecl(IDecl parent) : base(DeclKind.FriendTemplate, parent) { }
int Compare(IDecl decl1, IDecl decl2) { if (decl1 is LocalDecl && decl2 is LocalDecl) { LocalDecl aDecl1 = (LocalDecl)decl1; LocalDecl aDecl2 = (LocalDecl)decl2; if (aDecl1.ParentMethod != aDecl2.ParentMethod) return aDecl1.ParentMethod.GetHashCode().CompareTo(aDecl2.ParentMethod.GetHashCode());//Here, I assume that the hash codes will always be diffrent. } return decl1.Name.CompareTo(decl2.Name); }
public class ImportDecl : Decl { internal ImportDecl(IDecl parent) : base(DeclKind.Import, parent) { }
public IDecl CreateDecl(DeclKind kind, IDecl parent) { Decl ret; switch (kind) { case DeclKind.AccessSpec: ret = new AccessSpecDecl(parent); break; case DeclKind.Block: ret = new BlockDecl(parent); break; case DeclKind.Captured: ret = new CapturedDecl(parent); break; case DeclKind.ClassScopeFunctionSpecialization: ret = new ClassScopeFunctionSpecializationDecl(parent); break; case DeclKind.Empty: ret = new EmptyDecl(parent); break; case DeclKind.Export: ret = new ExportDecl(parent); break; case DeclKind.ExternCContext: ret = new ExternCContextDecl(parent); break; case DeclKind.FileScopeAsm: ret = new FileScopeAsmDecl(parent); break; case DeclKind.Friend: ret = new FriendDecl(parent); break; case DeclKind.FriendTemplate: ret = new FriendTemplateDecl(parent); break; case DeclKind.Import: ret = new ImportDecl(parent); break; case DeclKind.LinkageSpec: ret = new LinkageSpecDecl(parent); break; case DeclKind.Label: ret = new LabelDecl(parent); break; case DeclKind.Namespace: ret = new NamespaceDecl(parent); break; case DeclKind.NamespaceAlias: ret = new NamespaceAliasDecl(parent); break; case DeclKind.ObjCCompatibleAlias: ret = new ObjCCompatibleAliasDecl(parent); break; case DeclKind.ObjCCategory: ret = new ObjCCategoryDecl(parent); break; case DeclKind.ObjCCategoryImpl: ret = new ObjCCategoryImplDecl(parent); break; case DeclKind.ObjCImplementation: ret = new ObjCImplementationDecl(parent); break; case DeclKind.ObjCInterface: ret = new ObjCInterfaceDecl(parent); break; case DeclKind.ObjCProtocol: ret = new ObjCProtocolDecl(parent); break; case DeclKind.ObjCMethod: ret = new ObjCMethodDecl(parent); break; case DeclKind.ObjCProperty: ret = new ObjCPropertyDecl(parent); break; case DeclKind.BuiltinTemplate: ret = new BuiltinTemplateDecl(parent); break; case DeclKind.ClassTemplate: ret = new ClassTemplateDecl(parent); break; case DeclKind.FunctionTemplate: ret = new FunctionTemplateDecl(parent); break; case DeclKind.TypeAliasTemplate: ret = new TypeAliasTemplateDecl(parent); break; case DeclKind.VarTemplate: ret = new VarTemplateDecl(parent); break; case DeclKind.TemplateTemplateParm: ret = new TemplateTemplateParmDecl(parent); break; case DeclKind.Enum: ret = new EnumDecl(parent); break; case DeclKind.Record: ret = new RecordDecl(parent); break; case DeclKind.CXXRecord: ret = new CXXRecordDecl(parent); break; case DeclKind.ClassTemplateSpecialization: ret = new ClassTemplateSpecializationDecl(parent); break; case DeclKind.ClassTemplatePartialSpecialization: ret = new ClassTemplatePartialSpecializationDecl(parent); break; case DeclKind.TemplateTypeParm: ret = new TemplateTypeParmDecl(parent); break; case DeclKind.ObjCTypeParam: ret = new ObjCTypeParamDecl(parent); break; case DeclKind.TypeAlias: ret = new TypeAliasDecl(parent); break; case DeclKind.Typedef: ret = new TypedefDecl(parent); break; case DeclKind.UnresolvedUsingTypename: ret = new UnresolvedUsingTypenameDecl(parent); break; case DeclKind.Using: ret = new UsingDecl(parent); break; case DeclKind.UsingDirective: ret = new UsingDirectiveDecl(parent); break; case DeclKind.UsingPack: ret = new UsingPackDecl(parent); break; case DeclKind.UsingShadow: ret = new UsingShadowDecl(parent); break; case DeclKind.ConstructorUsingShadow: ret = new ConstructorUsingShadowDecl(parent); break; case DeclKind.Binding: ret = new BindingDecl(parent); break; case DeclKind.Field: ret = new FieldDecl(parent); break; case DeclKind.ObjCAtDefsField: ret = new ObjCAtDefsFieldDecl(parent); break; case DeclKind.ObjCIvar: ret = new ObjCIvarDecl(parent); break; case DeclKind.Function: ret = new FunctionDecl(parent); break; case DeclKind.CXXDeductionGuide: ret = new CXXDeductionGuideDecl(parent); break; case DeclKind.CXXMethod: ret = new CXXMethodDecl(parent); break; case DeclKind.CXXConstructor: ret = new CXXConstructorDecl(parent); break; case DeclKind.CXXConversion: ret = new CXXConversionDecl(parent); break; case DeclKind.CXXDestructor: ret = new CXXDestructorDecl(parent); break; case DeclKind.MSProperty: ret = new MSPropertyDecl(parent); break; case DeclKind.NonTypeTemplateParm: ret = new NonTypeTemplateParmDecl(parent); break; case DeclKind.Var: ret = new VarDecl(parent); break; case DeclKind.Decomposition: ret = new DecompositionDecl(parent); break; case DeclKind.ImplicitParam: ret = new ImplicitParamDecl(parent); break; case DeclKind.OMPCapturedExpr: ret = new OMPCapturedExprDecl(parent); break; case DeclKind.ParmVar: ret = new ParmVarDecl(parent); break; case DeclKind.VarTemplateSpecialization: ret = new VarTemplateSpecializationDecl(parent); break; case DeclKind.VarTemplatePartialSpecialization: ret = new VarTemplatePartialSpecializationDecl(parent); break; case DeclKind.EnumConstant: ret = new EnumConstantDecl(parent); break; case DeclKind.IndirectField: ret = new IndirectFieldDecl(parent); break; case DeclKind.OMPDeclareReduction: ret = new OMPDeclareReductionDecl(parent); break; case DeclKind.UnresolvedUsingValue: ret = new UnresolvedUsingValueDecl(parent); break; case DeclKind.OMPThreadPrivate: ret = new OMPThreadPrivateDecl(parent); break; case DeclKind.ObjCPropertyImpl: ret = new ObjCPropertyImplDecl(parent); break; case DeclKind.PragmaComment: ret = new PragmaCommentDecl(parent); break; case DeclKind.PragmaDetectMismatch: ret = new PragmaDetectMismatchDecl(parent); break; case DeclKind.StaticAssert: ret = new StaticAssertDecl(parent); break; case DeclKind.TranslationUnit: ret = new TranslationUnitDecl(parent); break; default: throw new NotImplementedException(); } if (parent == null) { Decls.Add(ret); } return(ret); }
public class LinkageSpecDecl : Decl { internal LinkageSpecDecl(IDecl parent) : base(DeclKind.LinkageSpec, parent) { }