src/ScriptEngine/Compiler/ModuleDumpWriter.cs - develop - EvilBeaver/OneScript

src/ScriptEngine/Compiler/ModuleDumpWriter.cs
229 строк8 KB
Mr-Rm
VM: имена свойств и методов в отдельный список
25 дек 2025, 15:17
25 дек 2025, 15:174ba9eb7
/*----------------------------------------------------------
This Source Code Form is subject to the terms of the 
Mozilla Public License, v.2.0. If a copy of the MPL 
was not distributed with this file, You can obtain one 
at http://mozilla.org/MPL/2.0/.
----------------------------------------------------------*/
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using OneScript.Commons;
using OneScript.Compilation;
using OneScript.Compilation.Binding;
using OneScript.Contexts;
using OneScript.Execution;
using OneScript.Native.Compiler;
using OneScript.Native.Runtime;
using OneScript.Sources;
using ScriptEngine.Machine;

namespace ScriptEngine.Compiler
{
    public class ModuleDumpWriter
    {
        readonly ICompilerFrontend _compiler;
        private readonly IBslProcess _process;

        public ModuleDumpWriter(ICompilerFrontend compilerService, IBslProcess process)
        {
            _compiler = compilerService;
            _process = process;
        }

        public void Write(TextWriter output, SourceCode source)
        {
            var compilerResult = _compiler.Compile(source, _process);
            if (compilerResult is StackRuntimeModule stackModule)
            {
                var module = stackModule;
                WriteImage(output, module);
            }
            else
            {
                WriteNativeModule(output, (DynamicModule)compilerResult);
            }

        }

        private void WriteNativeModule(TextWriter output, DynamicModule compilerResult)
        {
            foreach (var attribute in compilerResult.ModuleAttributes)
            {
                output.WriteLine($"[{attribute.Name}]");
            }
            output.WriteLine("class DynamicModule");
            output.WriteLine("{");
            output.WriteLine(".fields");
            foreach (var field in compilerResult.Fields)
            {
                PrintField(output, field);
            }
            
            output.WriteLine(".properties");
            foreach (var prop in compilerResult.Properties)
            {
                PrintProperty(output, prop);
            }
            
            output.WriteLine(".methods");
            foreach (var method in compilerResult.Methods)
            {
                PrintMethod(output, (BslNativeMethodInfo)method);
            }
            
            output.WriteLine("}");
        }

        private void PrintProperty(TextWriter output, BslPropertyInfo prop)
        {
            output.WriteLine();
            foreach (var attribute in prop.GetAnnotations())
            {
                output.WriteLine($"[{attribute.Name}]");
            }
            output.WriteLine($"{prop.PropertyType} {prop.Name}");
        }
        
        private void PrintMethod(TextWriter output, BslNativeMethodInfo method)
        {
            output.WriteLine();
            foreach (var attribute in method.GetAnnotations())
            {
                output.WriteLine($"[{attribute.Name}]");
            }
            
            var propertyInfo = typeof(Expression).GetProperty("DebugView", BindingFlags.Instance | BindingFlags.NonPublic);
            output.WriteLine(propertyInfo.GetValue(method.Implementation) as string);
        }

        private void PrintField(TextWriter output, BslFieldInfo field)
        {
            output.WriteLine();
            foreach (var attribute in field.GetAnnotations())
            {
                output.WriteLine($"[{attribute.Name}]");
            }
            output.WriteLine($"{field.FieldType} {field.Name}");
        }

        public void Write(TextWriter output, StackRuntimeModule module)
        {
            WriteImage(output, module);
        }

        private void WriteImage(TextWriter output, StackRuntimeModule module)
        {
            output.WriteLine(".variableFrame:");
            module.Fields
                .Cast<BslScriptFieldInfo>()
                .OrderBy(x=>x.DispatchId)
                .ForEach(x=>output.WriteLine($"{x.DispatchId}:{x.Name}{(x.IsPublic ? " export" : "")}"));
            
            output.WriteLine(".constants");
            for (int i = 0; i < module.Constants.Count; i++)
            {
                var item = module.Constants[i];
                output.WriteLine(
                    $"{i,-3}:type: {item.SystemType.Alias}, val: {item}");
            }
            output.WriteLine(".identifiers");
            for (int i = 0; i < module.Identifiers.Count; i++)
            {
                var item = module.Identifiers[i];
                output.WriteLine(
                    $"{i,-3}: {item}");
            }
            output.WriteLine(".code");
            for (int i = 0; i < module.Code.Count; i++)
            {
                var item = module.Code[i];
                output.WriteLine(
                    $"{i,-3}:({Enum.GetName(typeof(OperationCode), item.Code),-10}{item.Argument,3})");
            }
            output.WriteLine(".procedures");
            foreach (var item in module.Methods.Cast<MachineMethodInfo>())
            {
                WriteMethodDefinition(output, item.GetRuntimeMethod());
            }
            output.WriteLine(".varmap");
            WriteSymbolMap(output, module.VariableRefs);
            output.WriteLine(".procmap");
            WriteSymbolMap(output, module.MethodRefs);
            output.WriteLine(".moduleEntry");
            output.WriteLine(module.EntryMethodIndex.ToString());
        }

        private void WriteSymbolMap(TextWriter output, IList<ModuleSymbolBinding> map)
        {
            for (int i = 0; i < map.Count; i++)
            {
                var item = map[i];
                var targetInfo = item.Kind switch
                {
                    ScopeBindingKind.Static => item.Target?.GetType().Name ?? "null",
                    ScopeBindingKind.ThisScope => "this",
                    ScopeBindingKind.FrameScope => $"frame[{item.ScopeIndex}]",
                    _ => "unknown"
                };
                output.Write(string.Format("{0,-3}:({1},{2},{3})\n", i, item.Kind, targetInfo, item.MemberNumber));
            }
        }

        private void WriteAnnotationsList(TextWriter output, AnnotationDefinition[] annotations)
        {
            output.WriteLine(".annotations [");
            foreach (var annotation in annotations)
            {
                output.Write(" {0}", annotation.Name);
                if (annotation.ParamCount != 0)
                {
                    var delimiter = ": ";
                    foreach (var parameter in annotation.Parameters)
                    {
                        output.Write(delimiter);
                        output.Write(parameter);
                        delimiter = ", ";
                    }
                }
                output.WriteLine("");
            }
            output.WriteLine("]");
        }

        private void WriteMethodDefinition(TextWriter output, MachineMethod item)
        {
            output.Write(item.Signature.IsFunction ? "Func " : "Proc ");
            output.Write(
                $"{item.Signature.Name} entryPoint: {item.EntryPoint}, frameSize:{item.LocalVariables.Length}\n");
            if (item.Signature.AnnotationsCount != 0)
            {
                WriteAnnotationsList(output, item.Signature.Annotations);
            }
            output.Write(".args {0}\n", item.Signature.ArgCount);
            if (item.Signature.Params != null)
            {
                for (int i = 0; i < item.Signature.Params.Length; i++)
                {
                    output.Write("{0,-3}: ByVal={1}", i, item.Signature.Params[i].IsByValue);
                    if (item.Signature.Params[i].HasDefaultValue)
                    {
                        output.Write(" defValue: {0}\n", item.Signature.Params[i].DefaultValueIndex);
                    }
                    else
                    {
                        output.WriteLine();
                    }
                }
            }
            output.WriteLine(".variables [");
            for (int i = 0; i < item.LocalVariables.Length; i++)
            {
                output.WriteLine($" {i}:{item.LocalVariables[i]}");
            }
            output.WriteLine("]");
        }
    }
}