BadCompiledFunction.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Parser;
using BadScript2.Reader.Token;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Functions;
using BadScript2.Runtime.Objects.Types;
 
namespace BadScript2.Runtime.VirtualMachine;
 
public class BadCompiledFunction : BadFunction
{
    private readonly BadInstruction[] m_Instructions;
 
    private readonly BadScope m_ParentScope;
 
    private readonly BadSourcePosition m_Position;
 
    private readonly string m_StringSignature;
 
    private readonly bool m_UseOverrides;
 
    public BadCompiledFunction(BadInstruction[] instructions,
                               bool useOverrides,
                               BadScope parentScope,
                               BadSourcePosition position,
                               BadWordToken? name,
                               bool isConstant,
                               bool isStatic,
                               BadMetaData? metaData,
                               BadClassPrototype returnType,
                               bool isSingleLine,
                               params BadFunctionParameter[] parameters) : base(name,
                                                                                isConstant,
                                                                                isStatic,
                                                                                returnType,
                                                                                isSingleLine,
                                                                                parameters
                                                                               )
    {
        m_Instructions = instructions;
        m_UseOverrides = useOverrides;
        m_ParentScope = parentScope;
        m_Position = position;
        MetaData = metaData ?? BadMetaData.Empty;
        m_StringSignature = MakeSignature();
    }
 
    public override BadMetaData MetaData { get; }
 
    public BadExecutionContext CreateExecutionContext(BadExecutionContext caller, BadObject[] args)
    {
        BadExecutionContext ctx = new BadExecutionContext(m_ParentScope.CreateChild("Compiled Function",
                                                               caller.Scope,
                                                               null,
                                                               BadScopeFlags.Returnable |
                                                               BadScopeFlags.AllowThrow |
                                                               BadScopeFlags.CaptureThrow
                                                              )
                                                         );
        ApplyParameters(ctx, args, m_Position);
 
        return ctx;
    }
 
    protected override IEnumerable<BadObject> InvokeBlock(BadObject[] args, BadExecutionContext caller)
    {
        using BadExecutionContext ctx = CreateExecutionContext(caller, args);
 
        if (m_Instructions.Length == 0)
        {
            yield return Null;
 
            yield break;
        }
 
        BadRuntimeVirtualMachine vm = new BadRuntimeVirtualMachine(this, m_Instructions, m_UseOverrides);
 
        foreach (BadObject o in vm.Execute(ctx))
        {
            yield return o;
        }
 
        if (ctx.Scope.ReturnValue != null)
        {
            yield return ctx.Scope.ReturnValue;
        }
        else
        {
            yield return Null;
        }
    }
 
    private string MakeSignature()
    {
        string str = base.ToString() + " at " + m_Position.GetPositionInfo() + '\n';
 
        for (int i = 0; i < m_Instructions.Length; i++)
        {
            str += i + ":\t" + m_Instructions[i] + '\n';
        }
 
        return str;
    }
 
    public override string ToString()
    {
        return m_StringSignature;
    }
}