BadClass.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects.Functions;
 
namespace BadScript2.Runtime.Objects.Types;
 
public class BadClass : BadObject
{
    private readonly BadClass? m_BaseClass;
 
    public BadClass(string name, BadExecutionContext context, BadClass? baseClass, BadClassPrototype prototype)
    {
        Name = name;
        Context = context;
        m_BaseClass = baseClass;
        Prototype = prototype;
    }
 
    public BadScope Scope => Context.Scope;
 
    public BadExecutionContext Context { get; }
 
    public string Name { get; }
 
    public BadClassPrototype Prototype { get; }
 
    public BadClass? SuperClass { get; private set; }
 
 
    public bool InheritsFrom(BadClassPrototype proto)
    {
        return proto.IsSuperClassOf(Prototype);
    }
 
 
    public void SetThis()
    {
        SetThis(this);
    }
 
    private void SetThis(BadClass thisInstance)
    {
        SuperClass = thisInstance;
        Scope.GetTable().GetProperty(BadStaticKeys.THIS_KEY).Set(thisInstance, new BadPropertyInfo(thisInstance.Prototype, true));
        m_BaseClass?.SetThis(thisInstance);
    }
 
    public override BadClassPrototype GetPrototype()
    {
        return Prototype;
    }
 
    public override bool HasProperty(string propName, BadScope? caller = null)
    {
        if (Scope.GetTable().InnerTable.ContainsKey(propName))
        {
            return true;
        }
 
        if (m_BaseClass != null)
        {
            return m_BaseClass.HasProperty(propName, caller);
        }
 
        return caller != null && caller.Provider.HasObject(GetType(), propName);
    }
 
 
    public BadObjectReference GetProperty(string propName, BadPropertyVisibility visibility, BadScope? caller = null)
    {
        BadPropertyVisibility vis = BadScope.GetPropertyVisibility(propName);
 
        if (caller != null)
        {
            if (caller.ClassObject == null)
            {
                visibility = BadPropertyVisibility.Public;
            }
            else if (caller.ClassObject == this)
            {
                visibility = BadPropertyVisibility.All;
            }
            else if (caller.ClassObject.InheritsFrom(Prototype))
            {
                visibility = BadPropertyVisibility.Public | BadPropertyVisibility.Protected;
            }
            else
            {
                visibility = BadPropertyVisibility.Public;
            }
        }
 
        if (!HasProperty(propName, Scope))
        {
            throw BadRuntimeException.Create(
                caller,
                $"Property {propName} not found in class {Name} or any of its base classes"
            );
        }
 
        if ((vis & visibility) == 0)
        {
            throw BadRuntimeException.Create(
                caller,
                $"Property {Name}.{propName} is not visible from {caller?.Name ?? "global"}"
            );
        }
 
        if (Scope.GetTable().InnerTable.ContainsKey(propName))
        {
            return BadObjectReference.Make(
                $"{Name}.{propName}",
                () => Scope.GetTable().InnerTable[propName],
                (o, t) =>
                {
                    BadPropertyInfo info = Scope.GetTable().GetPropertyInfo(propName);
                    
                    BadObject? existing = Scope.GetTable().InnerTable[propName];
 
                    if (existing != Null && info.IsReadOnly)
                    {
                        throw BadRuntimeException.Create(caller, $"{Name}.{propName} is read-only");
                    }
 
                    if (info.Type != null && !info.Type.IsAssignableFrom(o))
                    {
                        throw BadRuntimeException.Create(
                            caller,
                            $"Cannot assign object {o.GetType().Name} to property '{propName}' of type '{info.Type.Name}'"
                        );
                    }
 
                    if (existing is BadObjectReference reference)
                    {
                        reference.Set(o, t);
                    }
                    else
                    {
                        if (existing != Null && Scope.OnChange(propName, existing, o))
                            return;
                        Scope.GetTable().InnerTable[propName] = o;
                        Scope.OnChanged(propName, existing ?? Null, o);
                    }
                }
            );
        }
 
        if (m_BaseClass != null)
        {
            return m_BaseClass.GetProperty(
                propName,
                visibility & ~BadPropertyVisibility.Private & BadPropertyVisibility.All,
                caller
            ); //Allow public, protected
        }
 
        if (caller == null)
        {
            throw BadRuntimeException.Create(caller, $"No property named {propName} for type {Name}");
        }
 
        return caller.Provider.GetObjectReference(GetType(), propName, SuperClass ?? this, caller);
    }
 
    public override BadObjectReference GetProperty(string propName, BadScope? caller = null)
    {
        return GetProperty(propName, BadPropertyVisibility.Public, caller);
    }
 
 
    public override string ToSafeString(List<BadObject> done)
    {
        done.Add(this);
 
        if (Scope.HasLocal("ToString", Scope, false) && Scope.GetProperty("ToString", Scope).Dereference() is BadFunction toString)
        {
            BadObject? result = Null;
            foreach (BadObject? o in toString.Invoke(Array.Empty<BadObject>(), Context))
            {
                result = o;
            }
 
            result = result.Dereference();
 
            return result.ToSafeString(done);
        }
 
        return
            $"class {Name}\n{Scope.ToSafeString(done)}";
    }
}