BadAddExpression.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Native;
 
namespace BadScript2.Parser.Expressions.Binary.Math;
 
public class BadAddExpression : BadBinaryExpression
{
    public BadAddExpression(BadExpression left, BadExpression right, BadSourcePosition position) : base(left,
                                                                                                        right,
                                                                                                        position
                                                                                                       ) { }
 
 
    protected override string GetSymbol()
    {
        return "+";
    }
 
    public static BadObject Add(BadObject left, BadObject right, BadSourcePosition pos)
    {
        switch (left)
        {
            case IBadString lStr when right is IBadNative rNative:
                return BadObject.Wrap(lStr.Value + rNative.Value);
            case IBadString lStr:
                return BadObject.Wrap(lStr.Value + right);
            case IBadNumber lNum when right is IBadString rStr:
                return BadObject.Wrap(lNum.Value + rStr.Value);
            case IBadNumber lNum when right is IBadNumber rNum:
                return BadObject.Wrap(lNum.Value + rNum.Value);
            case IBadNumber:
                break;
            case IBadBoolean lBool:
            {
                if (right is IBadString rStr)
                {
                    return BadObject.Wrap(lBool.Value + rStr.Value);
                }
 
                break;
            }
            default:
            {
                if (right is IBadString rStr)
                {
                    return BadObject.Wrap(left + rStr.Value);
                }
 
                break;
            }
        }
 
        throw new BadRuntimeException($"Can not apply operator '+' to {left} and {right}", pos);
    }
 
    public static IEnumerable<BadObject> AddWithOverride(BadExecutionContext? context,
                                                         BadObject leftRef,
                                                         BadObject right,
                                                         BadSourcePosition position)
    {
        BadObject left = leftRef.Dereference(position);
 
        if (left.HasProperty(BadStaticKeys.ADD_OPERATOR_NAME, context?.Scope))
        {
            foreach (BadObject o in ExecuteOperatorOverride(left,
                                                            right,
                                                            context!,
                                                            BadStaticKeys.ADD_OPERATOR_NAME,
                                                            position
                                                           ))
            {
                yield return o;
            }
        }
        else
        {
            yield return Add(left, right, position);
        }
    }
 
    protected override IEnumerable<BadObject> InnerExecute(BadExecutionContext context)
    {
        BadObject left = BadObject.Null;
 
        foreach (BadObject o in Left.Execute(context))
        {
            left = o;
 
            yield return o;
        }
 
        left = left.Dereference(Position);
        BadObject right = BadObject.Null;
 
        foreach (BadObject o in Right.Execute(context))
        {
            right = o;
 
            yield return o;
        }
 
        right = right.Dereference(Position);
 
        foreach (BadObject? o in AddWithOverride(context, left, right, Position))
        {
            yield return o;
        }
    }
}