BadTableExtension.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 BadTableExtension : BadInteropExtension
{
    protected override void AddExtensions(BadInteropExtensionProvider provider)
    {
        provider.RegisterObject<BadTable>(
            "RemoveKey",
            o => new BadDynamicInteropFunction<BadObject>(
                "RemoveKey",
                (c, k) =>
                {
                    if (k is not IBadString s)
                    {
                        throw BadRuntimeException.Create(c.Scope, "Key is not a string");
                    }
 
                    return RemoveKey(o, s.Value);
                },
                BadNativeClassBuilder.GetNative("bool"),
                "key"
            )
        );
 
        provider.RegisterObject<BadTable>(
            "MakeReadOnly",
            table => new BadDynamicInteropFunction(
                "MakeReadOnly",
                _ =>
                {
                    foreach (string key in table.InnerTable.Keys)
                    {
                        table.PropertyInfos[key].IsReadOnly = true;
                    }
 
                    return BadObject.Null;
                },
                BadAnyPrototype.Instance
            )
        );
 
        provider.RegisterObject<BadTable>(
            BadStaticKeys.ARRAY_ACCESS_OPERATOR_NAME,
            t => new BadDynamicInteropFunction<BadObject>(
                BadStaticKeys.ARRAY_ACCESS_OPERATOR_NAME,
                (c, o) => ArrayAccess(c, t, o),
                BadAnyPrototype.Instance,
                "key"
            )
        );
 
        provider.RegisterObject<BadTable>("Keys", Keys);
        provider.RegisterObject<BadTable>("Values", Values);
        provider.RegisterObject<BadTable>("Length", a => BadObject.Wrap((decimal)a.InnerTable.Count));
 
        provider.RegisterObject<BadTable>(
            "Join",
            t => new BadInteropFunction(
                "Join",
                (c, a) => JoinTable(c, t, a),
                false,
                BadNativeClassBuilder.GetNative("Table"),
                new BadFunctionParameter(
                    "overwrite",
                    false,
                    true,
                    false,
                    null,
                    BadNativeClassBuilder.GetNative("bool")
                ),
                new BadFunctionParameter("others", false, true, true, null)
            )
        );
    }
    
    private static BadObject ArrayAccess(BadExecutionContext context, BadTable table, BadObject enumerator)
    {
        BadSourcePosition position = BadSourcePosition.FromSource("ArrayAccess", 0, 1);
        if (enumerator is IBadString str)
        {
            return table.GetProperty(str.Value, context.Scope);
        }
 
        BadTable result = new BadTable();
 
        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 IBadString key)
            {
                throw BadRuntimeException.Create(context.Scope, "Enumerator Current did not return a string", position);
            }
            
            result.SetProperty(key.Value, table.GetProperty(key.Value, context.Scope).Dereference());
 
            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 JoinTable(BadExecutionContext ctx, BadTable self, IReadOnlyList<BadObject> args)
    {
        if (args.Count == 0)
        {
            throw BadRuntimeException.Create(ctx.Scope, "Invalid Argument Count");
        }
 
        BadObject overwrite = args[0];
        BadObject[] others = args.Skip(1).ToArray();
 
        if (overwrite is not IBadBoolean ov)
        {
            throw BadRuntimeException.Create(ctx.Scope, "Overwrite is not a boolean value");
        }
 
        foreach (BadObject o in others)
        {
            if (o is not BadTable other)
            {
                throw BadRuntimeException.Create(ctx.Scope, "Others can only be tables");
            }
 
            foreach (KeyValuePair<string, BadObject> kvp in other.InnerTable)
            {
                if (ov.Value || !self.InnerTable.ContainsKey(kvp.Key))
                {
                    self.GetProperty(kvp.Key, ctx.Scope).Set(kvp.Value);
                }
            }
        }
 
        return self;
    }
 
    private static BadObject RemoveKey(BadTable table, string key)
    {
        return table.RemoveKey(key);
    }
 
    private static BadObject Keys(BadTable table)
    {
        return new BadArray(table.InnerTable.Keys.Select(x => (BadObject)x).ToList());
    }
 
    private static BadObject Values(BadTable table)
    {
        return new BadArray(table.InnerTable.Values.ToList());
    }
}