Ejemplo n.º 1
0
        public static void WriteElements(TypeDecl decl, CodeWriter writer)
        {
            foreach (var declare in decl.Declare.Handlers)
            {
                var @return  = "void";
                var @params  = string.Join(", ", declare.Params.Select(param => $"{GetType(param)} {param.Name.Underscore()}"));
                var function = $"{@return} {declare.Name.Underscore()}({@params})";

                var comment = CommentHelper.FormatComment(declare.Comment);
                writer.AppendLines(comment);

                var implement = decl.Implement?.Handlers.FirstOrDefault(i => i.Name == declare.Name);
                // Abstract
                if (implement == null)
                {
                    writer.AppendLine($"virtual {function} = 0;");
                }
                // Override
                else if (implement.Override == YesNo.Y)
                {
                    writer.AppendLine($"virtual {function} override;");
                }
                // No modifiers.
                else
                {
                    writer.AppendLine($"{function};");
                }

                writer.AppendNewLineWithoutIndent();
            }
        }
        public static void WriteElements(List <ElementDecl> elements, CodeWriter writer)
        {
            foreach (var element in elements)
            {
                var comment = CommentHelper.FormatComment(element.Comment);
                writer.AppendLines(comment);

                var type = GetType(element);
                writer.AppendLine($"{type} {element.Name.Underscore()};");
                writer.AppendNewLineWithoutIndent();
            }
        }
        private static void WriteMethods(TypeDecl decl, CodeWriter writer)
        {
            bool HasImplement(HandlerDeclareItem declare)
            {
                return(decl.Implement?.Handlers.FirstOrDefault(t => t.Name == declare.Name) == null);
            }

            var declarations = decl.Declare.Handlers;

            foreach (var declare in declarations)
            {
                bool isAbstract = !HasImplement(declare);
                if (isAbstract)
                {
                    writer.AppendLine("@abstractmethod");
                }

                var parameters = "";
                foreach (var parameter in declare.Params)
                {
                    parameters += ($", {parameter.Name.Underscore()}: {GetTypeHint(decl, parameter)}");
                }

                writer.AppendLine($"def {declare.Name.Underscore()}(self{parameters}):");
                writer.PushIndent();

                writer.AppendLines(CommentHelper.PyComment(declare.Comment));

                writer.AppendLine(isAbstract ? "pass" : "raise NotImplemented");

                if (declarations.IndexOf(declare) != declarations.Count - 1)
                {
                    writer.AppendNewLineWithoutIndent();
                }

                writer.PopIndent();
            }
        }
Ejemplo n.º 4
0
        private static void BuildEnumDeclaration(EnumDecl decl, CodeWriter writer)
        {
            var settings = GeneratorSettingsProvider.Get(decl.Module.ModuleName);
            var type     = decl.Name.Underscore();

            writer.AppendNewLineWithoutIndent();

            writer.AppendLines(CommentHelper.FormatComment(decl.Comment));

            writer.AppendLine($"class {settings.DeclSpec} {type} : public dot::enum_base");
            writer.AppendLine("{");

            writer.PushIndent();
            writer.AppendLine($"typedef {type} self;");
            writer.PopIndent();
            writer.AppendNewLineWithoutIndent();

            var elements = decl.Items;

            writer.AppendLine("public:");
            writer.AppendNewLineWithoutIndent();
            writer.PushIndent();

            writer.AppendLine("enum enum_type {");
            writer.PushIndent();
            foreach (EnumItem item in elements)
            {
                writer.AppendLines(CommentHelper.FormatComment(item.Comment));
                writer.AppendLine($"{item.Name.Underscore()},");
                // Do not add new line after last item
                if (elements.IndexOf(item) != elements.Count - 1)
                {
                    writer.AppendNewLineWithoutIndent();
                }
            }

            writer.PopIndent();
            writer.AppendLine("};");
            writer.AppendNewLineWithoutIndent();
            writer.PopIndent();

            writer.AppendLines(@"private:
    static dot::object make_self() { return self(); }

public:
    typedef self element_type;
    typedef dot::struct_wrapper_impl<self>* pointer_type;
    using dot::enum_base::enum_base;

    operator dot::object();
    operator int() const;
    self& operator=(int rhs);
    self& operator=(const self& other);
    virtual dot::type_t type();
    static dot::type_t typeof();

protected:
    virtual dot::dictionary<dot::string, int> get_enum_map() override;");

            writer.AppendLine("};");
        }
        /// <summary>
        /// Generate python classes from declaration.
        /// </summary>
        public static string Build(TypeDecl decl, List <IDecl> declarations)
        {
            var writer = new CodeWriter();

            string name = decl.Name;

            // Determine if we are inside datacentric package
            // based on module name. This affects the imports
            // and namespace use.
            bool insideDc = PyExtensions.GetPackage(decl) == "datacentric";

            // If not generating for DataCentric package, use dc. namespace
            // in front of datacentric types, otherwise use no prefix
            string dcNamespacePrefix = insideDc ? "" : "dc.";

            PythonImportsBuilder.WriteImports(decl, declarations, writer);

            writer.AppendNewLineWithoutIndent();
            writer.AppendNewLineWithoutIndent();

            // Get base classes for current declaration
            List <string> bases = new List <string>();

            if (decl.Keys.Any())
            {
                bases.Add(dcNamespacePrefix + "Record");
            }
            else if (decl.Inherit != null)
            {
                // Full package name and short namespace of the parent class,
                // or null if there is no parent
                bool   parentClassInDifferentModule = !PyExtensions.IsPackageEquals(decl, decl.Inherit);
                string parentPackage = PyExtensions.GetPackage(decl.Inherit);
                string parentClassNamespacePrefix =
                    parentClassInDifferentModule ? PyExtensions.GetAlias(parentPackage) + "." : "";
                bases.Add(parentClassNamespacePrefix + decl.Inherit.Name);
            }
            else
            {
                bases.Add(dcNamespacePrefix + "Data");
            }

            if (decl.Kind == TypeKind.Abstract)
            {
                bases.Add("ABC");
            }

            // Python 3.8:
            // if (decl.Kind == TypeKind.Final)
            // writer.AppendLine("@final");
            writer.AppendLine("@attr.s(slots=True, auto_attribs=True)");
            writer.AppendLine($"class {name}({string.Join(", ", bases)}):");
            writer.PushIndent();
            writer.AppendLines(CommentHelper.PyComment(decl.Comment));

            writer.AppendNewLineWithoutIndent();
            if (!decl.Elements.Any())
            {
                writer.AppendLine("pass");
            }

            foreach (var element in decl.Elements)
            {
                // TODO: Should be replaced with callable with specific format instead of skipping
                string skipRepresentation = element.Vector == YesNo.Y ? ", repr=False" : "";

                writer.AppendLine($"{element.Name.Underscore()}: {GetTypeHint(decl, element)} = attr.ib(default=None, kw_only=True{skipRepresentation}{GetMetaData(element)})");
                writer.AppendLines(CommentHelper.PyComment(element.Comment));
                if (element != decl.Elements.Last())
                {
                    writer.AppendNewLineWithoutIndent();
                }
            }

            // Add to_key and create_key() methods
            if (decl.Keys.Any())
            {
                var keyElements = decl.Elements.Where(e => decl.Keys.Contains(e.Name)).ToList();

                writer.AppendNewLineWithoutIndent();
                writer.AppendLine("def to_key(self) -> str:");
                writer.PushIndent();
                writer.AppendLine(CommentHelper.PyComment($"Get {decl.Name} key."));
                writer.AppendLines($"return '{decl.Name}='{GetToKeyArgs(decl.Name, keyElements, true)}");
                writer.PopIndent();

                writer.AppendNewLineWithoutIndent();

                var    namedParams       = keyElements.Select(e => $"{e.Name.Underscore()}: {GetTypeHint(decl, e)}").ToList();
                var    joinedNamedParams = string.Join(", ", namedParams);
                string start             = "def create_key(";

                // Check if tokens should be separated by new line
                if (4 + start.Length + joinedNamedParams.Length > 120)
                {
                    var indent = new string(' ', start.Length);
                    joinedNamedParams = string.Join("," + Environment.NewLine + indent, namedParams);
                }

                writer.AppendLine("@classmethod");
                writer.AppendLines($"def create_key(cls, *, {joinedNamedParams}) -> str:");

                writer.PushIndent();
                writer.AppendLine(CommentHelper.PyComment($"Create {decl.Name} key."));
                writer.AppendLines($"return '{decl.Name}='{GetToKeyArgs(decl.Name, keyElements, false)}");
                writer.PopIndent();
            }

            if (decl.Declare != null)
            {
                writer.AppendNewLineWithoutIndent();
                WriteMethods(decl, writer);
            }

            // Class end
            writer.PopIndent();

            return(writer.ToString());
        }
        private static void BuildClassDeclaration(TypeDecl decl, CodeWriter writer)
        {
            var  settings  = GeneratorSettingsProvider.Get(decl.Module.ModuleName);
            var  type      = decl.Name.Underscore();
            bool isRecord  = decl.Keys.Any();
            bool isDerived = decl.Inherit != null;

            // Self-forward
            writer.AppendLine($"class {type}_data_impl; using {type}_data = dot::ptr<{type}_data_impl>;");
            if (isRecord)
            {
                writer.AppendLine($"class {type}_key_impl; using {type}_key = dot::ptr<{type}_key_impl>;");
            }

            // Get unique keys and data from elements
            var dataForwards = decl.Elements.Where(e => e.Data != null)
                               .Where(e => e.Data.Module.ModuleName == decl.Module.ModuleName)
                               .Select(e => $"{e.Data.Name.Underscore()}_data").ToList();

            var keysForwards = decl.Elements.Where(e => e.Key != null)
                               .Where(e => e.Key.Module.ModuleName == decl.Module.ModuleName)
                               .Select(e => $"{e.Key.Name.Underscore()}_key").ToList();

            var forwards = keysForwards.Union(dataForwards).Distinct();

            // Appends forwards
            foreach (var f in forwards)
            {
                writer.AppendLine($"class {f}_impl; using {f} = dot::ptr<{f}_impl>;");
            }
            writer.AppendNewLineWithoutIndent();

            writer.AppendLine($"inline {type}_data make_{type}_data();");
            writer.AppendNewLineWithoutIndent();

            writer.AppendLines(CommentHelper.FormatComment(decl.Comment));

            var baseType = isRecord ? $"record_impl<{type}_key_impl, {type}_data_impl>" :
                           isDerived    ? $"{decl.Inherit.Name.Underscore()}_data_impl" :
                           "data_impl";

            writer.AppendLine($"class {settings.DeclSpec} {type}_data_impl : public {baseType}");
            writer.AppendLine("{");

            writer.PushIndent();
            writer.AppendLine($"typedef {type}_data_impl self;");
            writer.AppendLine($"friend {type}_data make_{type}_data();");
            writer.PopIndent();
            writer.AppendNewLineWithoutIndent();

            writer.AppendLine("public: // FIELDS");
            writer.AppendNewLineWithoutIndent();

            var elements = decl.Elements;

            if (elements.Any())
            {
                writer.PushIndent();
                CppElementBuilder.WriteElements(decl.Elements, writer);
                writer.PopIndent();
            }

            if (decl.Declare != null)
            {
                writer.AppendLine("public: // METHODS");
                writer.AppendNewLineWithoutIndent();
                writer.PushIndent();
                CppMethodBuilder.WriteElements(decl, writer);
                writer.PopIndent();
            }

            writer.AppendLine("public:");
            writer.PushIndent();
            writer.AppendLine("virtual dot::type_t type();");
            writer.AppendLine("static dot::type_t typeof();");
            writer.PopIndent();

            writer.AppendLine("};");
            writer.AppendNewLineWithoutIndent();

            writer.AppendLine("/// Create an empty instance.");
            writer.AppendLine($"inline {type}_data make_{type}_data() {{ return new {type}_data_impl; }}");
        }