BadScope.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Parser.Expressions;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Interop;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Functions;
using BadScript2.Runtime.Objects.Native;
using BadScript2.Runtime.Objects.Types;
 
namespace BadScript2.Runtime;
 
public class BadScope : BadObject, IDisposable
{
    private readonly Dictionary<string, BadObject[]> m_Attributes = new Dictionary<string, BadObject[]>();
 
    private readonly List<Action> m_Finalizers = new List<Action>();
 
    private readonly BadInteropExtensionProvider m_Provider;
 
    private readonly List<string> m_RegisteredApis = new List<string>();
 
    private readonly BadTable m_ScopeVariables = new BadTable();
 
    private readonly Dictionary<Type, object> m_SingletonCache = new Dictionary<Type, object>();
 
    private readonly bool m_UseVisibility;
 
    private BadScope? m_Caller;
 
    private BadObject? m_Exports;
 
    private bool m_IsDisposed;
 
    public BadScope(string name,
                    BadInteropExtensionProvider provider,
                    BadScope? caller = null,
                    BadScopeFlags flags = BadScopeFlags.RootScope)
    {
        Name = name;
        Flags = flags;
        m_Caller = caller;
        m_Provider = provider;
        m_ScopeVariables.SetChangeInterceptor(OnChange);
        m_ScopeVariables.OnChangedProperty += OnChanged;
    }
 
    public BadScope(string name,
                    BadInteropExtensionProvider provider,
                    BadTable locals,
                    BadScope? caller = null,
                    BadScopeFlags flags = BadScopeFlags.RootScope)
    {
        Name = name;
        Flags = flags;
        m_Caller = caller;
        m_ScopeVariables = locals;
        m_Provider = provider;
        m_ScopeVariables.SetChangeInterceptor(OnChange);
        m_ScopeVariables.OnChangedProperty += OnChanged;
    }
 
    private BadScope(BadScope parent,
                     BadScope? caller,
                     string name,
                     BadScopeFlags flags = BadScopeFlags.RootScope,
                     bool useVisibility = false) : this(name,
                                                        parent.Provider,
                                                        caller,
                                                        ClearCaptures(parent.Flags) | flags
                                                       )
    {
        m_UseVisibility = useVisibility;
        Parent = parent;
    }
 
    public IReadOnlyDictionary<string, BadObject[]> Attributes => m_Attributes;
 
    public IReadOnlyCollection<string> RegisteredApis => Parent?.RegisteredApis ?? m_RegisteredApis;
 
    public BadInteropExtensionProvider Provider => Parent != null ? Parent.Provider : m_Provider;
 
    public BadClass? ClassObject { get; internal set; }
 
    public BadFunction? FunctionObject { get; internal set; }
 
 
    public BadScope? Parent { get; }
 
    public string Name { get; }
 
    public BadScopeFlags Flags { get; private set; }
 
    private bool CountInStackTrace => (Flags & BadScopeFlags.CaptureReturn) != 0;
 
    public bool IsBreak { get; private set; }
 
    public bool IsContinue { get; private set; }
 
    public BadObject? ReturnValue { get; private set; }
 
 
    public static BadClassPrototype Prototype { get; } = new BadNativeClassPrototype<BadScope>("Scope",
                                                                                               (c, args) =>
                                                                                               {
                                                                                                   switch (args.Length)
                                                                                                   {
                                                                                                       case 0:
                                                                                                       {
                                                                                                           return CreateScope(c, "SCOPE");
                                                                                                       }
                                                                                                       case 1:
                                                                                                       {
                                                                                                           if (args[0] is not IBadString name)
                                                                                                           {
                                                                                                               throw new BadRuntimeException("Expected Name in Scope Constructor");
                                                                                                           }
 
                                                                                                           return CreateScope(c, name.Value);
                                                                                                       }
                                                                                                       case 2:
                                                                                                       {
                                                                                                           if (args[0] is not IBadString name)
                                                                                                           {
                                                                                                               throw new BadRuntimeException("Expected Name in Scope Constructor");
                                                                                                           }
 
                                                                                                           if (args[1] is not BadTable locals)
                                                                                                           {
                                                                                                               throw new BadRuntimeException("Expected Locals Table in Scope Constructor");
                                                                                                           }
 
                                                                                                           return CreateScope(c, name.Value, locals);
                                                                                                       }
                                                                                                       default:
                                                                                                           throw new BadRuntimeException("Expected 1 or 2 Arguments in Scope Constructor");
                                                                                                   }
                                                                                               }
                                                                                              );
 
#region IDisposable Members
 
    public void Dispose()
    {
        if (m_IsDisposed)
        {
            return;
        }
 
        m_IsDisposed = true;
 
        foreach (Action finalizer in m_Finalizers)
        {
            finalizer();
        }
 
        m_Finalizers.Clear();
    }
 
#endregion
 
    public BadArray GetMemberInfos()
    {
        return new BadArray(m_ScopeVariables.InnerTable.Keys.Select(x => (BadObject)new BadMemberInfo(x, this))
                                            .ToList()
                           );
    }
 
    internal void SetRegisteredApi(string api)
    {
        if (Parent != null)
        {
            Parent.SetRegisteredApi(api);
 
            return;
        }
 
        if (!m_RegisteredApis.Contains(api))
        {
            m_RegisteredApis.Add(api);
        }
    }
 
    public void AddFinalizer(Action finalizer)
    {
        if (m_IsDisposed)
        {
            throw BadRuntimeException.Create(this, "Scope is already disposed");
        }
 
        m_Finalizers.Add(finalizer);
    }
 
    public void SetCaller(BadScope? caller)
    {
        m_Caller = caller;
    }
 
    public BadScope GetRootScope()
    {
        return Parent?.GetRootScope() ?? this;
    }
 
    public void AddSingleton<T>(T instance) where T : class
    {
        if (instance == null)
        {
            throw new BadRuntimeException("Cannot add null as singleton");
        }
 
        m_SingletonCache.Add(typeof(T), instance);
    }
 
    public T? GetSingleton<T>()
    {
        if (Parent != null)
        {
            return Parent.GetSingleton<T>();
        }
 
        if (m_SingletonCache.TryGetValue(typeof(T), out object? value))
        {
            return (T)value;
        }
 
        return default;
    }
 
    public T GetSingleton<T>(bool createNew) where T : new()
    {
        if (Parent != null)
        {
            return Parent.GetSingleton<T>(createNew);
        }
 
        if (m_SingletonCache.ContainsKey(typeof(T)))
        {
            return (T)m_SingletonCache[typeof(T)];
        }
 
        if (!createNew)
        {
            throw new Exception("Singleton not found");
        }
 
        T v = new T();
        m_SingletonCache[typeof(T)] = v;
 
        return v;
    }
 
    public override BadClassPrototype GetPrototype()
    {
        return Prototype;
    }
 
    private static BadScope CreateScope(BadExecutionContext ctx, string name, BadTable? locals = null)
    {
        BadScope s = locals != null
                         ? new BadScope(name, ctx.Scope.Provider, locals)
                         : new BadScope(name, ctx.Scope.Provider);
 
        foreach (KeyValuePair<Type, object> kvp in ctx.Scope.GetRootScope()
                                                      .m_SingletonCache)
        {
            s.m_SingletonCache.Add(kvp.Key, kvp.Value);
        }
 
        return s;
    }
 
    public void SetFlags(BadScopeFlags flags)
    {
        Flags = flags;
    }
 
    public string GetStackTrace()
    {
        return GetStackTrace(this);
    }
 
    private static string GetStackTrace(BadScope scope)
    {
        BadScope? current = scope;
        List<BadScope> stack = new List<BadScope>();
 
        while (current != null)
        {
            if (current.CountInStackTrace)
            {
                stack.Add(current);
            }
 
            current = current.m_Caller ?? current.Parent;
        }
 
        return string.Join("\n", stack.Select(s => s.Name));
    }
    
    private static IEnumerable<BadScope> GetStackTraceEnumerable(BadScope scope)
    {
        BadScope? current = scope;
 
        while (current != null)
        {
            if (current.CountInStackTrace)
            {
                yield return current;
            }
 
            current = current.m_Caller ?? current.Parent;
        }
    }
    
    public IEnumerable<BadScope> GetStackTraceEnumerable() => GetStackTraceEnumerable(this);
    
    public BadScope GetFirstTracableOrRoot() => CountInStackTrace ? this : Parent?.GetFirstTracableOrRoot() ?? this;
 
    private static BadScopeFlags ClearCaptures(BadScopeFlags flags)
    {
        return flags &
               ~(BadScopeFlags.CaptureReturn |
                 BadScopeFlags.CaptureBreak |
                 BadScopeFlags.CaptureContinue |
                 BadScopeFlags.CaptureThrow);
    }
 
    public void SetBreak()
    {
        if ((Flags & BadScopeFlags.AllowBreak) == 0)
        {
            throw new BadRuntimeException("Break not allowed in this scope");
        }
 
        IsBreak = true;
 
        if ((Flags & BadScopeFlags.CaptureBreak) == 0)
        {
            Parent?.SetBreak();
        }
    }
 
    public void SetContinue()
    {
        if ((Flags & BadScopeFlags.AllowContinue) == 0)
        {
            throw new BadRuntimeException("Continue not allowed in this scope");
        }
 
        IsContinue = true;
 
        if ((Flags & BadScopeFlags.CaptureContinue) == 0)
        {
            Parent?.SetContinue();
        }
    }
 
    public BadObject GetExports()
    {
        return m_Exports ?? Null;
    }
 
    public void SetExports(BadExecutionContext ctx, BadObject exports)
    {
        if (m_Exports != null)
        {
            throw BadRuntimeException.Create(ctx.Scope, "Exports are already set");
        }
 
        m_Exports = exports;
    }
 
    public void AddExport(string key, BadObject value)
    {
        if (Parent != null)
        {
            Parent.AddExport(key, value);
        }
        else
        {
            if (m_Exports == null)
            {
                m_Exports = new BadTable();
            }
 
            m_Exports.SetProperty(key, value);
        }
    }
 
    public void SetReturnValue(BadObject? value)
    {
        if ((Flags & BadScopeFlags.AllowReturn) == 0)
        {
            throw new BadRuntimeException("Return not allowed in this scope");
        }
 
        ReturnValue = value;
 
        if ((Flags & BadScopeFlags.CaptureReturn) == 0)
        {
            Parent?.SetReturnValue(value);
        }
    }
 
    public BadTable GetTable()
    {
        return m_ScopeVariables;
    }
 
 
    public BadScope CreateChild(string name,
                                BadScope? caller,
                                bool? useVisibility,
                                BadScopeFlags flags = BadScopeFlags.RootScope)
    {
        BadScope sc = new BadScope(this, caller, name, flags, useVisibility ?? m_UseVisibility)
        {
            ClassObject = ClassObject, FunctionObject = FunctionObject,
        };
 
        return sc;
    }
 
    internal void OnChanged(string name, BadObject oldValue, BadObject newValue)
    {
        if (ClassObject == null)
        {
            return;
        }
 
        if (m_Attributes.TryGetValue(name, out BadObject[]? attributes))
        {
            BadMemberInfo? member = new BadMemberInfo(name, this);
 
            foreach (BadClass attribute in attributes.OfType<BadClass>())
            {
                if (attribute.InheritsFrom(BadNativeClassBuilder.ChangedAttribute))
                {
                    BadFunction? invoke = (BadFunction)attribute.GetProperty("OnChanged")
                                                                .Dereference(null);
 
                    BadMemberChangedEvent? eventObj =
                        new BadMemberChangedEvent(ClassObject!, member, oldValue, newValue);
 
                    foreach (BadObject o in invoke.Invoke(new BadObject[] { eventObj },
                                                          new BadExecutionContext(this)
                                                         ))
                    {
                        //Execute
                    }
                }
            }
        }
    }
 
    internal bool OnChange(string name, BadObject oldValue, BadObject newValue)
    {
        if (ClassObject == null)
        {
            return false;
        }
 
        if (m_Attributes.TryGetValue(name, out BadObject[]? attributes))
        {
            BadMemberInfo? member = new BadMemberInfo(name, this);
 
            foreach (BadClass attribute in attributes.OfType<BadClass>())
            {
                if (attribute.InheritsFrom(BadNativeClassBuilder.ChangeAttribute))
                {
                    BadFunction? invoke = (BadFunction)attribute.GetProperty("OnChange")
                                                                .Dereference(null);
 
                    BadMemberChangingEvent? eventObj =
                        new BadMemberChangingEvent(ClassObject!, member, oldValue, newValue);
                    BadObject? obj = Null;
 
                    foreach (BadObject o in invoke.Invoke(new BadObject[] { eventObj },
                                                          new BadExecutionContext(this)
                                                         ))
                    {
                        //Execute
                        obj = o;
                    }
 
                    if (eventObj.Cancel)
                    {
                        return true;
                    }
                }
            }
        }
 
        return false;
    }
 
    internal IEnumerable<BadObject> InitializeAttributes()
    {
        if (ClassObject == null)
        {
            throw new BadRuntimeException("Scope is not a class scope");
        }
 
        foreach (KeyValuePair<string, BadObject[]> kvp in m_Attributes)
        {
            BadMemberInfo? member = new BadMemberInfo(kvp.Key, this);
 
            foreach (BadClass attribute in kvp.Value.OfType<BadClass>())
            {
                if (attribute.InheritsFrom(BadNativeClassBuilder.InitializeAttribute))
                {
                    BadFunction? invoke = (BadFunction)attribute.GetProperty("Initialize")
                                                                .Dereference(null);
 
                    foreach (BadObject o in invoke.Invoke(new BadObject[] { ClassObject!, member },
                                                          new BadExecutionContext(this)
                                                         ))
                    {
                        //Execute
                        yield return o;
                    }
                }
            }
        }
    }
 
    public void DefineProperty(string name,
                               BadClassPrototype type,
                               BadExpression getAccessor,
                               BadExpression? setAccessor,
                               BadExecutionContext caller,
                               BadObject[] attributes)
    {
        if (HasLocal(name, caller.Scope, false))
        {
            throw new BadRuntimeException($"Property {name} is already defined");
        }
 
        Action<BadObject, BadSourcePosition?, BadPropertyInfo?>? setter = null;
 
        if (setAccessor != null)
        {
            setter = (value, p, pi) =>
            {
                BadExecutionContext? setCtx =
                    new BadExecutionContext(caller.Scope.CreateChild($"set {name}", caller.Scope, null));
 
                setCtx.Scope.DefineVariable("value",
                                            value,
                                            setCtx.Scope,
                                            new BadPropertyInfo(BadAnyPrototype.Instance, true)
                                           );
 
                foreach (BadObject o in setCtx.Execute(setAccessor))
                {
                    //Execute
                }
            };
        }
 
        m_ScopeVariables.PropertyInfos.Add(name, new BadPropertyInfo(type, setter == null));
 
        m_ScopeVariables.InnerTable.Add(name,
                                        BadObjectReference.Make($"property {name}",
                                                                (p) =>
                                                                {
                                                                    BadExecutionContext? getCtx =
                                                                        new BadExecutionContext(caller.Scope
                                                                                .CreateChild($"get {name}",
                                                                                     caller.Scope,
                                                                                     null
                                                                                    )
                                                                            );
                                                                    BadObject? get = Null;
 
                                                                    foreach (BadObject o in getCtx.Execute(getAccessor))
                                                                    {
                                                                        get = o;
                                                                    }
 
                                                                    return get.Dereference(p);
                                                                },
                                                                setter
                                                               )
                                       );
 
        m_Attributes[name] = attributes;
    }
 
    public void DefineVariable(string name,
                               BadObject value,
                               BadScope? caller = null,
                               BadPropertyInfo? info = null,
                               BadObject[]? attributes = null)
    {
        if (HasLocal(name, caller ?? this, false))
        {
            throw new BadRuntimeException($"Variable {name} is already defined");
        }
 
        m_Attributes[name] = attributes ?? [];
 
        m_ScopeVariables.GetProperty(name, false, caller ?? this)
                        .Set(value, null, info, true);
    }
 
    public BadPropertyInfo GetVariableInfo(string name)
    {
        if (HasLocal(name, this))
        {
            return m_ScopeVariables.GetPropertyInfo(name);
        }
 
        if (Parent == null)
        {
            throw new BadRuntimeException($"Variable '{name}' is not defined");
        }
 
        return Parent!.GetVariableInfo(name);
    }
 
    public static BadPropertyVisibility GetPropertyVisibility(string propName)
    {
        char first = propName[0];
        char second = propName.Length > 1 ? propName[1] : '\0';
 
        return second switch
        {
            '_' => first == '_' ? BadPropertyVisibility.Private : BadPropertyVisibility.Public,
            _   => first == '_' ? BadPropertyVisibility.Protected : BadPropertyVisibility.Public,
        };
    }
 
    public bool IsVisibleParentOf(BadScope scope)
    {
        if (scope == this)
        {
            return true;
        }
 
        BadScope? current = scope.Parent;
 
        while (current != null)
        {
            if (!current.m_UseVisibility)
            {
                return false;
            }
 
            if (current == this)
            {
                return true;
            }
 
            current = current.Parent;
        }
 
        return false;
    }
 
    public BadObjectReference GetVariable(string name, BadScope caller)
    {
        if (m_UseVisibility)
        {
            BadPropertyVisibility vis = IsVisibleParentOf(caller)
                                            ? BadPropertyVisibility.All
                                            : BadPropertyVisibility.Public;
 
            if ((GetPropertyVisibility(name) & vis) == 0)
            {
                throw BadRuntimeException.Create(caller, $"Variable '{name}' is not visible to {caller}");
            }
        }
 
        if (HasLocal(name, caller))
        {
            return m_ScopeVariables.GetProperty(name, caller);
        }
 
        if (Parent == null)
        {
            throw BadRuntimeException.Create(caller, $"Variable '{name}' is not defined");
        }
 
        return Parent!.GetVariable(name, caller);
    }
 
    public BadObjectReference GetVariable(string name)
    {
        return GetVariable(name, this);
    }
 
    public bool HasLocal(string name, BadScope caller, bool useExtensions = true)
    {
        return !useExtensions
                   ? m_ScopeVariables.InnerTable.ContainsKey(name)
                   : m_ScopeVariables.HasProperty(name, caller);
    }
 
    public bool HasVariable(string name, BadScope caller)
    {
        return HasLocal(name, caller) || (Parent != null && Parent.HasVariable(name, caller));
    }
 
 
    public override BadObjectReference GetProperty(string propName, BadScope? caller = null)
    {
        return HasVariable(propName, caller ?? this)
                   ? GetVariable(propName, caller ?? this)
                   : base.GetProperty(propName, caller);
    }
 
    public override bool HasProperty(string propName, BadScope? caller = null)
    {
        return HasVariable(propName, caller ?? this) || base.HasProperty(propName, caller);
    }
 
 
    public override string ToSafeString(List<BadObject> done)
    {
        done.Add(this);
 
        return m_ScopeVariables.ToSafeString(done);
    }
}