Пример #1
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}; }}");
                }
            }
        }
Пример #2
0
        public void WriteMethodRecursive(CodeTextWriter codeWriter, Metadata.TypeInformation type)
        {
            foreach (var nested in type.Nested)
            {
                WriteMethodRecursive(codeWriter, nested);
            }
            foreach (var method in type.Methods)
            {
                if (method.Body == null)
                {
                    continue;
                }
                CXXMethodTranslateContext methodContext = new CXXMethodTranslateContext(translateContext, method);

                // [2-2-1] Method Code
                if (type.HasGenericParameters)
                {
                    codeWriter.WriteLine($"template<{type.CXXTemplateParam}>");
                }
                if (method.HasGenericParameters)
                {
                    codeWriter.WriteLine($"template<{method.CXXTemplateParam}>");
                }

                codeWriter.WriteLine(
                    method.CXXRetType + " " + method.CXXMethodDeclareName + method.CXXParamSequence(false));

                codeWriter.WriteLine("{");
                // [2-2-2] Code Body
                codeWriter.indent();
                if (method.IsConstructor && method.IsStatic)
                {
                    codeWriter.WriteLine("static std::once_flag flag;");
                    codeWriter.WriteLine("std::call_once(flag,[&]()");
                    codeWriter.WriteLine("{");
                    codeWriter.indent();
                }
                foreach (var localVar in method.LocalVariables)
                {
                    if (method.InitLocals)
                    {
                        codeWriter.WriteLine($"{localVar.CXXVarDeclaration} v{localVar.Index} = {localVar.CXXVarInitVal};");
                    }
                    else
                    {
                        codeWriter.WriteLine($"{localVar.CXXVarDeclaration} v{localVar.Index};");
                    }
                }
                foreach (var instruction in method.Body.Instructions)
                {
                    codeWriter.WriteLine(NoteILInstruction(instruction, methodContext));
                    codeWriter.WriteLine(
                        instruction.GetLabel() + ": " +
                        TranslateILInstruction(instruction, methodContext));
                }
                if (method.IsConstructor && method.IsStatic)
                {
                    codeWriter.unindent();
                    codeWriter.WriteLine("});");
                }
                codeWriter.unindent();
                codeWriter.WriteLine("}");
            }
        }