BadFunction.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Common.Logging;
using BadScript2.Parser;
using BadScript2.Reader.Token;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects.Native;
using BadScript2.Runtime.Objects.Types;
using BadScript2.Runtime.Settings;
using BadScript2.Utility;
 
namespace BadScript2.Runtime.Objects.Functions;
 
public abstract class BadFunction : BadObject
{
    public static readonly BadClassPrototype Prototype = BadNativeClassBuilder.GetNative("Function");
 
    private readonly Dictionary<int, BadObject> m_Cache = new Dictionary<int, BadObject>();
 
    protected BadFunction(
        BadWordToken? name,
        bool isConstant,
        bool isStatic,
        BadClassPrototype returnType, 
        bool isSingleLine, 
        params BadFunctionParameter[] parameters)
    {
        Name = name;
        IsConstant = isConstant;
        IsStatic = isStatic;
        Parameters = parameters;
        ReturnType = returnType;
        IsSingleLine = isSingleLine;
    }
 
    public BadClassPrototype ReturnType { get; }
 
    public bool IsStatic { get; }
 
    public virtual BadMetaData MetaData => BadMetaData.Empty;
 
    public bool IsConstant { get; }
    
    public bool IsSingleLine { get; }
 
    public BadWordToken? Name { get; }
 
    public BadFunctionParameter[] Parameters { get; }
 
    public override BadClassPrototype GetPrototype()
    {
        return Prototype;
    }
 
    public virtual BadFunction BindParentScope(BadScope scope)
    {
        return this;
    }
 
    protected static BadObject GetParameter(BadObject[] args, int i)
    {
        return args.Length > i ? args[i].Dereference() : Null;
    }
 
    protected void CheckParameters(BadObject[] args, BadExecutionContext caller, BadSourcePosition? position = null)
    {
        for (int i = 0; i < Parameters.Length; i++)
        {
            BadFunctionParameter parameter = Parameters[i];
 
            if (parameter.IsRestArgs)
            {
                //Do Nothing
            }
            else if (args.Length <= i)
            {
                if (!parameter.IsOptional)
                {
                    throw BadRuntimeException.Create(caller.Scope, $"Wrong number of parameters for '{this}'. Expected Argument for '{parameter}'", position);
                }
            }
            else
            {
                if (parameter.IsNullChecked && args[i] == Null)
                {
                    throw BadRuntimeException.Create(caller.Scope, $"Null value not allowed for '{this}' parameter '{parameter}'", position);
                }
            }
        }
    }
 
    public static void ApplyParameters(
        string funcStr,
        BadFunctionParameter[] parameters,
        BadExecutionContext context,
        BadObject[] args,
        BadSourcePosition? position = null)
    {
        for (int i = 0; i < parameters.Length; i++)
        {
            BadFunctionParameter parameter = parameters[i];
 
            if (parameter.IsRestArgs)
            {
                context.Scope.DefineVariable(
                    parameter.Name,
                    new BadArray(args.Skip(i).ToList()),
                    null,
                    new BadPropertyInfo(BadNativeClassBuilder.GetNative("Array"))
                );
            }
            else if (args.Length <= i)
            {
                if (parameter.IsOptional)
                {
                    context.Scope.DefineVariable(parameter.Name, Null, null, new BadPropertyInfo(parameter.Type ?? BadAnyPrototype.Instance));
                }
                else
                {
                    throw BadRuntimeException.Create(context.Scope, $"Wrong number of parameters for '{funcStr}'. Expected Argument for '{parameter}'", position);
                }
            }
            else
            {
                if (parameter.IsNullChecked && args[i] == Null)
                {
                    throw BadRuntimeException.Create(context.Scope, $"Null value not allowed for '{funcStr}' parameter '{parameter}'", position);
                }
 
                context.Scope.DefineVariable(parameter.Name, args[i], null, new BadPropertyInfo(parameter.Type ?? BadAnyPrototype.Instance));
            }
        }
    }
 
    public void ApplyParameters(BadExecutionContext context, BadObject[] args, BadSourcePosition? position = null)
    {
        ApplyParameters(ToString(), Parameters, context, args, position);
    }
 
    private static int? GetHash(IEnumerable<BadObject> args)
    {
        int hash = 0;
 
        //Generate Hash from arguments
        foreach (BadObject o in args)
        {
            if (o is not IBadNative native)
            {
                return null;
            }
 
            hash = hash == 0 ? native.Value.GetHashCode() : BadHashCode.Combine(hash, native.Value);
        }
 
        return hash;
    }
 
    public IEnumerable<BadObject> Invoke(BadObject[] args, BadExecutionContext caller)
    {
        if (IsConstant && BadNativeOptimizationSettings.Instance.UseConstantFunctionCaching)
        {
            int? hash = GetHash(args);
 
            if (hash != null && m_Cache.TryGetValue(hash.Value, out BadObject? v))
            {
                BadLogger.Warn($"Found Cached value with Hash {hash}", "Runtime");
 
                yield return v;
 
                yield break;
            }
        }
 
        BadObject? ret = null;
 
        foreach (BadObject o in InvokeBlock(args, caller))
        {
            ret = o;
 
            yield return o;
        }
        
 
        if (ret != null && !ReturnType.IsAssignableFrom(ret))
        {
            throw new BadRuntimeException(
                $"Invalid return type for function '{GetHeader()}'. Expected '{ReturnType.Name}' got '{ret.GetPrototype().Name}'"
            );
        }
 
        if (!IsConstant ||
            ret == null ||
            !BadNativeOptimizationSettings.Instance.UseConstantFunctionCaching)
        {
            yield break;
        }
 
        {
            int? hash = GetHash(args);
 
            if (hash != null)
            {
                //BadLogger.Warn($"Caching Result {ret.ToSafeString()} for function '{GetHeader()}'", "Runtime");
                m_Cache[hash.Value] = ret;
            }
        }
    }
 
    protected abstract IEnumerable<BadObject> InvokeBlock(BadObject[] args, BadExecutionContext caller);
 
 
    public string GetHeader()
    {
        return GetHeader(Name?.ToString() ?? "<anonymous>", ReturnType, Parameters);
    }
 
    public static string GetHeader(string name, BadClassPrototype returnType, IEnumerable<BadFunctionParameter> parameters)
    {
        return $"{BadStaticKeys.FUNCTION_KEY} {returnType.Name} {name}({string.Join(", ", parameters.Cast<object>())})";
    }
 
    public override string ToSafeString(List<BadObject> done)
    {
        return GetHeader();
    }
}