Example #1
0
        public void WriteHeader(CodeTextStorage storage)
        {
            using (var _ = storage.EnterScope(translateContext.FocusedAssemblyInformation.IdentName))
            {
                foreach (var module in translateContext.FocusedAssemblyInformation.Modules.Values)
                {
                    var totalHeaderWriter = storage.Wirter(module.CXXHeaderName + ".h");
                    totalHeaderWriter.WriteLine("#pragma once");
                    totalHeaderWriter.WriteLine(EnvIncludes);
                    foreach (var type in module.Types.Values)
                    {
                        var codeWriter = storage.Wirter(type.TypeName + ".h");
                        typeHeaderWriters[type.FullName] = codeWriter;
                        codeWriter.WriteLine("#pragma once");
                        codeWriter.WriteLine(EnvIncludes);
                        using (var ___ = new CXXScopeDisposer(codeWriter, "\nnamespace " + type.CXXNamespace))
                        {
                            WriteTypeRecursively(codeWriter, type);
                        }
                        typeHeaderWriters[type.FullName].Flush();

                        totalHeaderWriter.WriteLine($"#include \"{type.TypeName}.h\"");
                    }

                    totalHeaderWriter.Flush();
                }
            }//End Dispose EnterScope
        }
Example #2
0
        public void WriteTypeRecursively(CodeTextWriter codeWriter, Metadata.TypeInformation type)
        {
            if (type.HasGenericParameters)
            {
                codeWriter.WriteLine($"template<{type.CXXTemplateParam}>");
            }
            string Interfaces = string.Join(',', type.Interfaces.Select(a => $"public {a.CXXTypeName}"));

            if (type.Interfaces.Count > 0)
            {
                Interfaces = "," + Interfaces;
            }
            string BaseType = type.BaseType != null ? type.BaseType.CXXTypeName : "RTCLI::System::Object";

            using (var classScope = new CXXScopeDisposer(codeWriter,
                                                         type.IsStruct ?
                                                         $"struct {type.CXXTypeNameShort}"
                               : $"class {type.CXXTypeNameShort} : public {BaseType}{Interfaces}",

                                                         true))
            {
                codeWriter.unindent().WriteLine("public:").indent();
                foreach (var nested in type.Nested)
                {
                    WriteTypeRecursively(codeWriter, nested);
                }
                foreach (var method in type.Methods)
                {
                    if (method.HasGenericParameters)
                    {
                        codeWriter.WriteLine($"template<{method.CXXTemplateParam}>");
                    }

                    codeWriter.WriteLine($"{(method.IsNewSlot?"virtual ":"")}{method.CXXMethodSignature(true)};");
                }
                foreach (var field in type.Fields)
                {
                    codeWriter.WriteLine(field.CXXFieldDeclaration);
                }
            }

            if (!type.IsStruct)
            {
                return;
            }

            if (type.HasGenericParameters)
            {
                codeWriter.WriteLine($"template<{type.CXXTemplateParam}>");
            }
            string classDef = $"class {type.CXXTypeNameShort}_V : public RTCLI::System::ValueType{Interfaces}";

            using (var classScope = new CXXScopeDisposer(codeWriter, classDef, true))
            {
                codeWriter.unindent().WriteLine("public:").indent();
                codeWriter.WriteLine($"using ValueType = {type.CXXTypeNameShort};");
                //codeWriter.WriteLine($"using ValueType = struct {type.CXXTypeNameShort};");
                codeWriter.WriteLine($"{type.CXXTypeNameShort} value;");
                foreach (var method in type.Methods)
                {
                    if (method.HasGenericParameters)
                    {
                        codeWriter.WriteLine($"template<{method.CXXTemplateParam}>");
                    }
                    codeWriter.WriteLine($"RTCLI_FORCEINLINE {method.CXXMethodSignature(true)} {{ value.{method.CXXMethodNameShort}{method.CXXArgSequence}; }}");
                }
            }
        }
 public void WriteHeader(CodeTextStorage storage)
 {
     using (var _ = storage.EnterScope(translateContext.FocusedAssemblyInformation.IdentName))
     {
         foreach (var module in translateContext.FocusedAssemblyInformation.Modules.Values)
         {
             foreach (var type in module.Types.Values)
             {
                 var codeWriter = storage.Wirter(type.TypeName + ".h");
                 typeHeaderWriters[type.FullName] = codeWriter;
                 codeWriter.WriteLine(EnvIncludes);
                 using (var ___ = new CXXScopeDisposer(codeWriter, "\nnamespace " + type.CXXNamespace))
                 {
                     using (var classScope = new CXXScopeDisposer(codeWriter, $"RTCLI_API class {type.CXXTypeNameShort} : public RTCLI::System::Object", true))
                     {
                         codeWriter.WriteLine("public:");
                         foreach (var method in type.Methods)
                         {
                             if (method.IsPublic)
                             {
                                 codeWriter.WriteLine(method.CXXMethodSignature);
                             }
                         }
                         foreach (var field in type.Fields)
                         {
                             if (field.IsPublic)
                             {
                                 codeWriter.WriteLine(field.CXXFieldDeclaration);
                             }
                         }
                         codeWriter.WriteLine("private:");
                         foreach (var method in type.Methods)
                         {
                             if (method.IsPrivate)
                             {
                                 codeWriter.WriteLine(method.CXXMethodSignature);
                             }
                         }
                         foreach (var field in type.Fields)
                         {
                             if (field.IsPrivate)
                             {
                                 codeWriter.WriteLine(field.CXXFieldDeclaration);
                             }
                         }
                         codeWriter.WriteLine("protected:");
                         foreach (var method in type.Methods)
                         {
                             if (method.IsFamily)
                             {
                                 codeWriter.WriteLine(method.CXXMethodSignature);
                             }
                         }
                         foreach (var field in type.Fields)
                         {
                             if (field.IsFamily)
                             {
                                 codeWriter.WriteLine(field.CXXFieldDeclaration);
                             }
                         }
                     }
                 }
                 typeHeaderWriters[type.FullName].Flush();
             }
         }
     }//End Dispose EnterScope
 }