/// <summary>
/// Implements the binary `==` operator.
/// </summary>
public static bool eq(BoxedValue l, BoxedValue r)
{
if (Operators.same(l, r))
{
return(true);
}
if (l.IsNull && r.IsUndefined ||
l.IsUndefined && r.IsNull)
{
return(true);
}
if (l.IsNumber && r.IsString)
{
return(l.Number == TypeConverter.ToNumber(r));
}
if (l.IsString && r.IsNumber)
{
return(TypeConverter.ToNumber(l) == r.Number);
}
if (l.Tag == TypeTags.Bool)
{
var newL = BoxedValue.Box(TypeConverter.ToNumber(l));
return(Operators.eq(newL, r));
}
if (r.Tag == TypeTags.Bool)
{
var newR = BoxedValue.Box(TypeConverter.ToNumber(r));
return(Operators.eq(l, newR));
}
if (l.Tag >= TypeTags.Object)
{
if (r.Tag == TypeTags.SuffixString || r.Tag == TypeTags.String || r.IsNumber)
{
var newL = TypeConverter.ToPrimitive(l.Object, DefaultValueHint.None);
return(Operators.eq(newL, r));
}
return(false);
}
if (r.Tag >= TypeTags.Object)
{
if (l.Tag == TypeTags.SuffixString || l.Tag == TypeTags.String || l.IsNumber)
{
var newR = TypeConverter.ToPrimitive(r.Object, DefaultValueHint.None);
return(Operators.eq(l, newR));
}
return(false);
}
return(false);
}
/// <summary>
/// Implements the binary `+` operator.
/// </summary>
public static BoxedValue add(BoxedValue l, BoxedValue r)
{
if (l.Tag == TypeTags.SuffixString)
{
var newString = SuffixString.Concat(
l.SuffixString,
TypeConverter.ToString(TypeConverter.ToPrimitive(r)));
return(BoxedValue.Box(newString));
}
if (l.Tag == TypeTags.String ||
r.Tag == TypeTags.String ||
r.Tag == TypeTags.SuffixString)
{
var newString = SuffixString.Concat(
TypeConverter.ToString(TypeConverter.ToPrimitive(l)),
TypeConverter.ToString(TypeConverter.ToPrimitive(r)));
return(BoxedValue.Box(newString));
}
var lPrim = TypeConverter.ToPrimitive(l);
var rPrim = TypeConverter.ToPrimitive(r);
if (lPrim.Tag == TypeTags.SuffixString)
{
var newString = SuffixString.Concat(
lPrim.SuffixString,
TypeConverter.ToString(rPrim));
return(BoxedValue.Box(newString));
}
if (lPrim.Tag == TypeTags.String ||
rPrim.Tag == TypeTags.String ||
rPrim.Tag == TypeTags.SuffixString)
{
var newString = SuffixString.Concat(
TypeConverter.ToString(lPrim),
TypeConverter.ToString(rPrim));
return(BoxedValue.Box(newString));
}
return(BoxedValue.Box(TypeConverter.ToNumber(lPrim) + TypeConverter.ToNumber(rPrim)));
}
/// <summary>
/// Supports the binary comparison operators.
/// </summary>
private static bool Compare(BoxedValue l, BoxedValue r, bool rightToLeft, Func <string, string, bool> stringCompare, Func <double, double, bool> numberCompare)
{
if ((l.Tag == TypeTags.String || l.Tag == TypeTags.SuffixString) &&
(r.Tag == TypeTags.String || r.Tag == TypeTags.SuffixString))
{
return(stringCompare(
l.Clr.ToString(),
r.Clr.ToString()));
}
if (l.IsNumber && r.IsNumber)
{
return(numberCompare(
l.Number,
r.Number));
}
BoxedValue lPrim, rPrim;
if (rightToLeft)
{
rPrim = TypeConverter.ToPrimitive(r, DefaultValueHint.Number);
lPrim = TypeConverter.ToPrimitive(l, DefaultValueHint.Number);
}
else
{
lPrim = TypeConverter.ToPrimitive(l, DefaultValueHint.Number);
rPrim = TypeConverter.ToPrimitive(r, DefaultValueHint.Number);
}
if ((lPrim.Tag == TypeTags.String || lPrim.Tag == TypeTags.SuffixString) &&
(rPrim.Tag == TypeTags.String || rPrim.Tag == TypeTags.SuffixString))
{
return(stringCompare(
lPrim.Clr.ToString(),
rPrim.Clr.ToString()));
}
var lNum = TypeConverter.ToNumber(lPrim);
var rNum = TypeConverter.ToNumber(rPrim);
return(numberCompare(
lNum,
rNum));
}
