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, null, 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}",
                                           (p) => Scope.GetTable()
                                                      .InnerTable[propName],
                                           (o, p, 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",p
                                                       );
                                               }
 
                                               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}'",p
                                                       );
                                               }
 
                                               if (existing is BadObjectReference reference)
                                               {
                                                   reference.Set(o, p, 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(null) is BadFunction toString)
        {
            BadObject? result = Null;
 
            foreach (BadObject? o in toString.Invoke(Array.Empty<BadObject>(), Context))
            {
                result = o;
            }
 
            result = result.Dereference(null);
 
            return result.ToSafeString(done);
        }
 
        return
            $"class {Name}\n{Scope.ToSafeString(done)}";
    }
}