BadArrayExtension.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Parser.Expressions.Block.Loop;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Interop;
using BadScript2.Runtime.Interop.Functions;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Functions;
using BadScript2.Runtime.Objects.Native;
using BadScript2.Runtime.Objects.Types;
 
namespace BadScript2.Interop.Common.Extensions;
 
public class BadArrayExtension : BadInteropExtension
{
    protected override void AddExtensions(BadInteropExtensionProvider provider)
    {
        provider.RegisterObject<BadArray>(
            "Add",
            a => new BadDynamicInteropFunction<BadObject>(
                "Add",
                (_, o) => Add(a, o),
                BadAnyPrototype.Instance,
                "elem"
            )
        );
 
        provider.RegisterObject<BadArray>(
            "Clear",
            a => new BadDynamicInteropFunction(
                "Clear",
                _ => Clear(a),
                BadAnyPrototype.Instance
            )
        );
 
        provider.RegisterObject<BadArray>(
            "AddRange",
            a => new BadDynamicInteropFunction<BadObject>(
                "AddRange",
                (ctx, elems) =>
                {
                    if (elems is BadArray arr)
                    {
                        a.InnerArray.AddRange(arr.InnerArray);
                    }
                    else if (BadNativeClassBuilder.Enumerable.IsSuperClassOf(elems.GetPrototype()))
                    {
                        // Get the Enumerator
                        BadObject[] enumerated = BadNativeClassHelper.ExecuteEnumerate(ctx, elems).ToArray();
                        a.InnerArray.AddRange(enumerated);
                    }
                    else
                    {
                        throw BadRuntimeException.Create(ctx.Scope, "Argument is not of type IEnumerable");
                    }
 
                    return BadObject.Null;
                },
                BadAnyPrototype.Instance,
                "elems"
            )
        );
 
        provider.RegisterObject<BadArray>(
            "Insert",
            a => new BadDynamicInteropFunction<decimal, BadObject>(
                "Insert",
                (_, i, o) => Insert(a, i, o),
                BadAnyPrototype.Instance,
                "elem"
            )
        );
 
        provider.RegisterObject<BadArray>(
            "InsertRange",
            a => new BadDynamicInteropFunction<decimal, BadObject>(
                "InsertRange",
                (ctx, num, elems) =>
                {
                    if (elems is BadArray arr)
                    {
                        a.InnerArray.InsertRange((int)num, arr.InnerArray);
                    }
                    else if (BadNativeClassBuilder.Enumerable.IsSuperClassOf(elems.GetPrototype()))
                    {
                        // Get the Enumerator
                        BadObject[] enumerated = BadNativeClassHelper.ExecuteEnumerate(ctx, elems).ToArray();
                        a.InnerArray.InsertRange((int)num, enumerated);
                    }
                    else
                    {
                        throw BadRuntimeException.Create(ctx.Scope, "Argument is not of type IEnumerable");
                    }
 
                    return BadObject.Null;
                },
                BadAnyPrototype.Instance,
                "index",
                "elems"
            )
        );
 
        provider.RegisterObject<BadArray>(
            "Remove",
            a => new BadDynamicInteropFunction<BadObject>(
                "Remove",
                (_, o) => Remove(a, o),
                BadNativeClassBuilder.GetNative("bool"),
                "elem"
            )
        );
 
        provider.RegisterObject<BadArray>(
            "Contains",
            a => new BadDynamicInteropFunction<BadObject>(
                "Contains",
                (_, o) => Contains(a, o),
                BadNativeClassBuilder.GetNative("bool"),
                "elem"
            )
        );
 
        provider.RegisterObject<BadArray>(
            "RemoveAt",
            a => new BadDynamicInteropFunction<decimal>(
                "RemoveAt",
                (_, o) => RemoveAt(a, o),
                BadAnyPrototype.Instance,
                "index"
            )
        );
 
        provider.RegisterObject<BadArray>(
            "Get",
            a => new BadDynamicInteropFunction<decimal>(
                "Get",
                (_, o) => Get(a, o),
                BadAnyPrototype.Instance,
                "index"
            )
        );
 
        provider.RegisterObject<BadArray>(
            "Set",
            a => new BadDynamicInteropFunction<decimal, BadObject>(
                "Set",
                (_, i, v) => Set(a, i, v),
                BadAnyPrototype.Instance,
                "index"
            )
        );
 
        provider.RegisterObject<BadArray>(
            "GetEnumerator",
            a => new BadDynamicInteropFunction(
                "GetEnumerator",
                _ => GetEnumerator(a),
                BadNativeClassBuilder.Enumerator
            )
        );
 
        provider.RegisterObject<BadArray>(
            BadStaticKeys.ARRAY_ACCESS_OPERATOR_NAME,
            a => new BadDynamicInteropFunction<BadObject>(
                BadStaticKeys.ARRAY_ACCESS_OPERATOR_NAME,
                (c, i) => ArrayAccess(c, a, i),
                BadAnyPrototype.Instance,
                "index"
            )
        );
        provider.RegisterObject<BadArray>(
            BadStaticKeys.ARRAY_ACCESS_REVERSE_OPERATOR_NAME,
            a => new BadDynamicInteropFunction<decimal>(
                BadStaticKeys.ARRAY_ACCESS_REVERSE_OPERATOR_NAME,
                (_, i) => BadObjectReference.Make(
                    $"{a}[^{i}]",
                    () => Get(a, a.InnerArray.Count - i),
                    (v, _) => Set(a, a.InnerArray.Count - i, v)
                ),
                BadAnyPrototype.Instance,
                "index"
            )
        );
 
        provider.RegisterObject<BadArray>("Length", a => BadObject.Wrap((decimal)a.InnerArray.Count));
    }
 
    private static BadObject ArrayAccess(BadExecutionContext context, BadArray array, BadObject enumerator)
    {
        BadSourcePosition position = BadSourcePosition.FromSource("ArrayAccess", 0, 1);
        if (enumerator is IBadNumber num)
        {
            return BadObjectReference.Make($"{array}[{num.Value}]", () => Get(array, num.Value), (v, _) => Set(array, num.Value, v));
        }
 
        BadArray result = new BadArray();
 
        if (enumerator.HasProperty("GetEnumerator", context.Scope) && enumerator.GetProperty("GetEnumerator", context.Scope).Dereference() is BadFunction getEnumerator)
        {
            foreach (BadObject e in getEnumerator.Invoke(Array.Empty<BadObject>(), context))
            {
                enumerator = e;
            }
 
            enumerator = enumerator.Dereference();
        }
        (BadFunction moveNext, BadFunction getCurrent) = BadForEachExpression.FindEnumerator(enumerator, context, position);
        
 
        BadObject cond = BadObject.Null;
 
        foreach (BadObject o in moveNext.Invoke(Array.Empty<BadObject>(), context))
        {
            cond = o;
        }
 
        IBadBoolean bRet = cond.Dereference() as IBadBoolean ??
                           throw new BadRuntimeException("While Condition is not a boolean", position);
 
        while (bRet.Value)
        {
            using BadExecutionContext loopContext = new BadExecutionContext(
                context.Scope.CreateChild(
                    "ForEachLoop",
                    context.Scope,
                    null,
                    BadScopeFlags.Breakable | BadScopeFlags.Continuable
                )
            );
 
            BadObject current = BadObject.Null;
 
            foreach (BadObject o in getCurrent.Invoke(Array.Empty<BadObject>(), loopContext))
            {
                current = o;
            }
 
 
 
            if (current is not IBadNumber n)
            {
                throw BadRuntimeException.Create(context.Scope, "Enumerator Current did not return a number", position);
            }
            
            result.InnerArray.Add(Get(array, n.Value));
 
            foreach (BadObject o in moveNext.Invoke(Array.Empty<BadObject>(), loopContext))
            {
                cond = o;
            }
 
 
 
            bRet = cond.Dereference() as IBadBoolean ??
                   throw BadRuntimeException.Create(
                       context.Scope,
                       "Enumerator MoveNext did not return a boolean",
                       position
                   );
        }
        
        return result;
    }
 
    private static BadObject GetEnumerator(BadArray array)
    {
        return new BadInteropEnumerator(array.InnerArray.GetEnumerator());
    }
 
    private static BadObject Clear(BadArray arg)
    {
        arg.InnerArray.Clear();
 
        return BadObject.Null;
    }
 
    private static BadObject Add(BadArray arg, BadObject obj)
    {
        arg.InnerArray.Add(obj);
 
        return BadObject.Null;
    }
 
    private static BadObject Insert(BadArray arg, decimal index, BadObject obj)
    {
        arg.InnerArray.Insert((int)index, obj);
 
        return BadObject.Null;
    }
 
    private static BadObject Contains(BadArray arg, BadObject obj)
    {
        return arg.InnerArray.Contains(obj);
    }
 
    private static BadObject Remove(BadArray arg, BadObject obj)
    {
        return arg.InnerArray.Remove(obj);
    }
 
    private static BadObject RemoveAt(BadArray arg, decimal obj)
    {
        int index = (int)obj;
        arg.InnerArray.RemoveAt(index);
 
        return BadObject.Null;
    }
 
    private static BadObject Get(BadArray arg, decimal obj)
    {
        int index = (int)obj;
 
        return arg.InnerArray[index];
    }
 
    private static BadObject Set(BadArray arg, decimal obj, BadObject value)
    {
        int index = (int)obj;
        arg.InnerArray[index] = value;
 
        return BadObject.Null;
    }
}