BadObject.cs

Go to the documentation of this file.

using BadScript2.Runtime.Error;
using BadScript2.Runtime.Interop.Functions.Extensions;
using BadScript2.Runtime.Interop.Reflection;
using BadScript2.Runtime.Objects.Native;
using BadScript2.Runtime.Objects.Types;
using BadScript2.Runtime.Settings;
 
namespace BadScript2.Runtime.Objects;
 
public abstract class BadObject
{
    private static readonly BadClassPrototype s_Prototype = BadAnyPrototype.Instance;
 
    private static readonly Dictionary<string, BadString> s_StringCache = new Dictionary<string, BadString>();
 
    public static readonly BadObject Null = new BadNullObject();
 
    public static readonly BadObject True = new BadBoolean(true);
 
    public static readonly BadObject False = new BadBoolean(false);
 
    public abstract BadClassPrototype GetPrototype();
 
    public static bool CanWrap(object? o)
    {
        return o is string || o is decimal || o is null || o.GetType().IsNumericType();
    }
 
    public static BadObject Wrap<T>(T obj, bool allowNative = true)
    {
        switch (obj)
        {
            case BadObject bObj:
                return bObj;
            case bool b when b:
                return True;
            case bool:
                return False;
            case decimal d:
                return new BadNumber(d);
        }
 
        if (typeof(T).IsNumericType() || obj != null && obj.GetType().IsNumericType())
        {
            return new BadNumber(Convert.ToDecimal(obj));
        }
 
        if (obj is string s)
        {
            if (!BadNativeOptimizationSettings.Instance.UseStringCaching)
            {
                return new BadString(s);
            }
 
            if (s_StringCache.TryGetValue(s, out BadString? wrap))
            {
                return wrap;
            }
 
            return s_StringCache[s] = new BadString(s);
        }
 
        if (Equals(obj, default(T)))
        {
            return Null;
        }
 
 
        if (allowNative)
        {
            return new BadNative<T>(obj);
        }
 
        throw new BadRuntimeException("Cannot wrap native type");
    }
 
    public virtual bool HasProperty(string propName, BadScope? caller = null)
    {
        return caller != null && caller.Provider.HasObject(GetType(), propName);
    }
 
    public virtual BadObjectReference GetProperty(string propName, BadScope? caller = null)
    {
        if (caller == null)
        {
            throw BadRuntimeException.Create(caller, $"No property named {propName} for type {GetType().Name}");
        }
 
        return caller.Provider.GetObjectReference(GetType(), propName, this, caller);
    }
 
    public static implicit operator BadObject(bool b)
    {
        return Wrap(b);
    }
 
    public static implicit operator BadObject(BadNullable<bool> b)
    {
        return b.HasValue ? b.Value : Null;
    }
 
    public static implicit operator BadObject(decimal d)
    {
        return Wrap(d);
    }
 
    public static implicit operator BadObject(BadNullable<decimal> b)
    {
        return b.HasValue ? b.Value : Null;
    }
 
    public static implicit operator BadObject(string s)
    {
        return Wrap(s);
    }
 
    public static implicit operator BadObject(BadNullable<string> b)
    {
        return b.HasValue ? b.Value! : Null;
    }
 
    public abstract string ToSafeString(List<BadObject> done);
 
    public override string ToString()
    {
        return ToSafeString(new List<BadObject>());
    }
 
    private class BadNullObject : BadObject, IBadNative
    {
        public object Value => null!;
 
        public Type Type => typeof(object);
 
        public bool Equals(IBadNative? other)
        {
            return Equals((object?)other);
        }
 
 
        public override BadClassPrototype GetPrototype()
        {
            return s_Prototype;
        }
 
        public override string ToSafeString(List<BadObject> done)
        {
            return "null";
        }
 
 
        public override bool Equals(object? obj)
        {
            return ReferenceEquals(this, obj);
        }
 
        public override int GetHashCode()
        {
            throw new NotSupportedException();
        }
    }
}