BadExpression.cs

Go to the documentation of this file.

using System.Runtime.ExceptionServices;
 
using BadScript2.Common;
using BadScript2.Debugging;
using BadScript2.Parser.Expressions.Access;
using BadScript2.Parser.Expressions.Constant;
using BadScript2.Parser.Expressions.Function;
using BadScript2.Parser.Expressions.Types;
using BadScript2.Parser.Expressions.Variables;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Functions;
using BadScript2.Runtime.Objects.Types;
using BadScript2.Runtime.Settings;
 
namespace BadScript2.Parser.Expressions;
 
public abstract class BadExpression
{
    protected BadExpression(bool isConstant, BadSourcePosition position)
    {
        IsConstant = isConstant;
        Position = position;
        Attributes = [];
    }
 
    public IEnumerable<BadExpression> Attributes { get; private set; }
 
    public bool IsConstant { get; }
 
    public BadSourcePosition Position { get; private set; }
 
    public void SetAttributes(IEnumerable<BadExpression> attributes)
    {
        Attributes = attributes;
    }
 
    protected IEnumerable<BadObject> ComputeAttributes(BadExecutionContext ctx, List<BadObject> attributes)
    {
        foreach (BadExpression? attribute in Attributes)
        {
            BadObject? obj = BadObject.Null;
            BadExpression? attrib = null;
            BadExpression access;
            IEnumerable<BadExpression> args;
 
            if (attribute is BadInvocationExpression invoc)
            {
                access = invoc.Left;
                args = invoc.Arguments;
            }
            else if (attribute is BadMemberAccessExpression || attribute is BadVariableExpression)
            {
                access = attribute;
                args = Array.Empty<BadExpression>();
            }
            else
            {
                throw BadRuntimeException.Create(ctx.Scope, "Attribute Expression not Supported.", attribute.Position);
            }
 
            BadClassPrototype? attribClass = null;
 
            if (access is BadVariableExpression varExpr)
            {
                //Check if the variable exists and is a class.
                if (ctx.Scope.HasVariable(varExpr.Name, ctx.Scope)) // Try to get the variable
                {
                    BadObject? attribObj = ctx.Scope.GetVariable(varExpr.Name, ctx.Scope)
                                              .Dereference(Position);
 
                    //Check if the variable is a class and inherits from IAttribute
                    if (attribObj is BadClassPrototype cls && BadNativeClassBuilder.Attribute.IsSuperClassOf(cls))
                    {
                        attribClass = cls;
                    }
                }
 
                //If the variable does not exist, check if the variable name + "Attribute" exists and is a class.
                if (attribClass == null &&
                    !varExpr.Name.EndsWith("Attribute") &&
                    ctx.Scope.HasVariable(varExpr.Name + "Attribute", ctx.Scope))
                {
                    BadObject? attribObj = ctx.Scope.GetVariable(varExpr.Name + "Attribute", ctx.Scope)
                                              .Dereference(Position);
 
                    //Check if the variable is a class and inherits from IAttribute
                    if (attribObj is BadClassPrototype cls && BadNativeClassBuilder.Attribute.IsSuperClassOf(cls))
                    {
                        attribClass = cls;
                    }
                }
            }
            else if (access is BadMemberAccessExpression mac)
            {
                //evaluate left side of the member access
                foreach (BadObject? o in mac.Left.Execute(ctx))
                {
                    obj = o;
                }
 
                BadObject? parent = obj.Dereference(Position);
 
                //Check if parent has property
                if (parent.HasProperty(mac.Right.Text, ctx.Scope))
                {
                    BadObject? attribObj = parent.GetProperty(mac.Right.Text, ctx.Scope)
                                                 .Dereference(Position);
 
                    //Check if the property is a class and inherits from IAttribute
                    if (attribObj is BadClassPrototype cls && BadNativeClassBuilder.Attribute.IsSuperClassOf(cls))
                    {
                        attribClass = cls;
                    }
                }
 
                if (parent.HasProperty(mac.Right.Text + "Attribute", ctx.Scope))
                {
                    BadObject? attribObj = parent.GetProperty(mac.Right.Text + "Attribute", ctx.Scope)
                                                 .Dereference(access.Position);
 
                    //Check if the property is a class and inherits from IAttribute
                    if (attribObj is BadClassPrototype cls && BadNativeClassBuilder.Attribute.IsSuperClassOf(cls))
                    {
                        attribClass = cls;
                    }
                }
            }
 
            if (attribClass == null)
            {
                throw BadRuntimeException.Create(ctx.Scope, "Attribute must be a class", attribute.Position);
            }
 
            attrib =
                new BadNewExpression(new BadInvocationExpression(new BadConstantExpression(attribute.Position,
                                                                      attribClass
                                                                     ),
                                                                 args,
                                                                 attribute.Position
                                                                ),
                                     attribute.Position
                                    );
 
            foreach (BadObject? o in attrib.Execute(ctx))
            {
                yield return o;
                obj = o;
            }
 
            BadObject? a = obj.Dereference(Position);
 
            if (a is not BadClass c)
            {
                throw BadRuntimeException.Create(ctx.Scope, "Attribute must be a class", attrib.Position);
            }
 
            if (!c.InheritsFrom(BadNativeClassBuilder.Attribute))
            {
                throw BadRuntimeException.Create(ctx.Scope, "Attribute must inherit from IAttribute", attrib.Position);
            }
 
            attributes.Add(a);
        }
    }
 
    public virtual void Optimize() { }
 
    public abstract IEnumerable<BadExpression> GetDescendants();
 
    public IEnumerable<BadExpression> GetDescendantsAndSelf()
    {
        yield return this;
 
        foreach (BadExpression? descendant in GetDescendants())
        {
            yield return descendant;
        }
    }
 
    public void SetPosition(BadSourcePosition pos)
    {
        Position = pos;
    }
 
    protected abstract IEnumerable<BadObject> InnerExecute(BadExecutionContext context);
 
    private IEnumerable<BadObject> ExecuteWithCatch(BadExecutionContext context)
    {
        using IEnumerator<BadObject> e = InnerExecute(context)
            .GetEnumerator();
 
        while (true)
        {
            try
            {
                if (!e.MoveNext())
                {
                    break;
                }
            }
            catch (BadRuntimeErrorException err)
            {
                ExceptionDispatchInfo.Capture(err)
                                     .Throw();
            }
            catch (Exception exception)
            {
                throw new BadRuntimeErrorException(BadRuntimeError.FromException(exception,
                                                        context.Scope.GetStackTrace()
                                                       )
                                                  );
            }
 
            yield return e.Current ?? BadObject.Null;
        }
    }
 
    public IEnumerable<BadObject> Execute(BadExecutionContext context)
    {
        if (BadDebugger.IsAttached)
        {
            BadDebugger.Step(new BadDebuggerStep(context, Position, this));
        }
 
        if (BadRuntimeSettings.Instance.CatchRuntimeExceptions)
        {
            return ExecuteWithCatch(context);
        }
 
        return InnerExecute(context);
    }
 
    protected static IEnumerable<BadObject> ExecuteOperatorOverride(BadObject left,
                                                                    BadObject right,
                                                                    BadExecutionContext context,
                                                                    string name,
                                                                    BadSourcePosition position)
    {
        if (left.GetProperty(name, context.Scope)
                .Dereference(position) is not BadFunction func)
        {
            throw new BadRuntimeException($"{left.GetType().Name} has no {name} property",
                                          position
                                         );
        }
 
        foreach (BadObject o in func.Invoke(new[] { right },
                                            context
                                           ))
        {
            yield return o;
        }
    }
 
    protected static IEnumerable<BadObject> ExecuteOperatorOverride(BadObject left,
                                                                    BadExecutionContext context,
                                                                    string name,
                                                                    BadSourcePosition position)
    {
        if (left.GetProperty(name, context.Scope)
                .Dereference(position) is not BadFunction func)
        {
            throw new BadRuntimeException($"{left.GetType().Name} has no {name} property",
                                          position
                                         );
        }
 
        foreach (BadObject o in func.Invoke(Array.Empty<BadObject>(), context))
        {
            yield return o;
        }
    }
}