BadExpressionFunction.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Parser;
using BadScript2.Parser.Expressions;
using BadScript2.Reader.Token;
using BadScript2.Runtime.Objects.Types;
 
namespace BadScript2.Runtime.Objects.Functions;
 
public class BadExpressionFunction : BadFunction
{
    private readonly List<BadExpression> m_Body;
 
    public readonly BadScope ParentScope;
 
    public readonly BadSourcePosition Position;
 
    private string? m_FuncString;
 
    public BadExpressionFunction(BadScope parentScope,
                                 BadWordToken? name,
                                 List<BadExpression> expressions,
                                 BadFunctionParameter[] parameters,
                                 BadSourcePosition position,
                                 bool isConstant,
                                 bool isStatic,
                                 BadMetaData? metaData,
                                 BadClassPrototype returnType,
                                 bool isSingleLine) : base(name,
                                                           isConstant,
                                                           isStatic,
                                                           returnType,
                                                           isSingleLine,
                                                           parameters
                                                          )
    {
        m_Body = expressions;
        Position = position;
        ParentScope = parentScope;
        MetaData = metaData ?? BadMetaData.Empty;
    }
 
    public IEnumerable<BadExpression> Body => m_Body;
 
 
    public override BadMetaData MetaData { get; }
 
    public override BadFunction BindParentScope(BadScope scope)
    {
        return new BadExpressionFunction(scope,
                                         Name,
                                         m_Body,
                                         Parameters,
                                         Position,
                                         IsConstant,
                                         IsStatic,
                                         MetaData,
                                         ReturnType,
                                         IsSingleLine
                                        );
    }
 
    protected override IEnumerable<BadObject> InvokeBlock(BadObject[] args, BadExecutionContext caller)
    {
        using BadExecutionContext ctx = new BadExecutionContext(ParentScope.CreateChild(ToString(),
                                                                     caller.Scope,
                                                                     null,
                                                                     BadScopeFlags.Returnable |
                                                                     BadScopeFlags.AllowThrow |
                                                                     BadScopeFlags.CaptureThrow
                                                                    )
                                                               );
 
        ctx.Scope.FunctionObject = this;
 
        ApplyParameters(ctx, args, Position);
 
        if (m_Body.Count == 0)
        {
            yield return Null;
 
            yield break;
        }
 
        foreach (BadObject o in ctx.Execute(Body))
        {
            yield return o;
        }
 
        if (ctx.Scope.ReturnValue != null)
        {
            yield return ctx.Scope.ReturnValue;
        }
        else
        {
            yield return Null;
        }
    }
 
    public override string ToString()
    {
        if (m_FuncString == null)
        {
            m_FuncString = base.ToString() + " at " + Position.GetPositionInfo();
        }
 
        return m_FuncString;
    }
}