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)
                   : 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();
    }
}