public BinaryExpr(SourceLocation location, Expr left, JSTokenizerToken binaryOperatorToken, Expr right)
: base(location, right.IsStatement, true)
{
Left = left;
BinaryOperatorToken = binaryOperatorToken;
Right = right;
}
/// <summary>
/// Matches a token. Forwards the head on success.
/// </summary>
/// <param name="token">Must be one of <see cref="JSTokenizerToken"/> value (not an Error one).</param>
/// <returns>True if the given token matches.</returns>
public bool Match(JSTokenizerToken token)
{
if (token < 0)
{
throw new ArgumentException("Token must not be an Error token.");
}
if (_token == (int)token)
{
Forward();
return(true);
}
return(false);
}
Expr HandleAssign(Expr left, bool pureAssign = false)
{
var location = _parser.Location;
AccessorExpr a = left as AccessorExpr;
if (a == null)
{
return(new SyntaxErrorExpr(location, "Invalid assignment left-hand side."));
}
if (pureAssign || _parser.Match(JSTokenizerToken.Assign))
{
return(new AssignExpr(location, a, Expression(JSTokenizer.PrecedenceLevel(JSTokenizerToken.Comma))));
}
JSTokenizerToken binaryTokenType = JSTokenizer.FromAssignOperatorToBinary(_parser.CurrentToken);
_parser.Forward();
return(new AssignExpr(location, a, new BinaryExpr(location, left, binaryTokenType, Expression(0))));
}
public static string Explain(JSTokenizerToken t)
{
if (t < 0)
{
return(((JSTokenizerError)t).ToString());
}
if ((t & JSTokenizerToken.IsAssignOperator) != 0)
{
return(_assignOperator[((int)t & 15) - 1]);
}
if ((t & JSTokenizerToken.IsBinaryOperator) != 0)
{
return(_binaryOperator[((int)t & 15) - 1]);
}
if ((t & JSTokenizerToken.IsCompareOperator) != 0)
{
return(_compareOperator[((int)t & 15) - 1]);
}
if ((t & JSTokenizerToken.IsPunctuation) != 0)
{
return(_punctuations[((int)t & 15) - 1]);
}
if ((t & JSTokenizerToken.IsUnaryOperator) != 0)
{
return(_unaryOperator[((int)t & 15) - 1]);
}
if (t == JSTokenizerToken.Identifier)
{
return("identifier");
}
if (t == JSTokenizerToken.And)
{
return("&&");
}
if (t == JSTokenizerToken.Or)
{
return("||");
}
if (t == JSTokenizerToken.PlusPlus)
{
return("++");
}
if (t == JSTokenizerToken.MinusMinus)
{
return("--");
}
if (t == JSTokenizerToken.String)
{
return("\"string\"");
}
if (t == JSTokenizerToken.Float)
{
return("6.02214129e+23");
}
if (t == JSTokenizerToken.Integer)
{
return("42");
}
if (t == JSTokenizerToken.HexNumber)
{
return("0x00CF12A4");
}
if (t == JSTokenizerToken.NaN)
{
return("NaN");
}
if (t == JSTokenizerToken.Infinity)
{
return("Infinity");
}
if (t == JSTokenizerToken.StarComment)
{
return("/* ... */");
}
if (t == JSTokenizerToken.LineComment)
{
return("// ..." + Environment.NewLine);
}
if (t == JSTokenizerToken.Regex)
{
return("/regex/gi");
}
if (t == JSTokenizerToken.OpenPar)
{
return("(");
}
if (t == JSTokenizerToken.ClosePar)
{
return(")");
}
if (t == JSTokenizerToken.OpenBracket)
{
return("[");
}
if (t == JSTokenizerToken.CloseBracket)
{
return("]");
}
if (t == JSTokenizerToken.OpenCurly)
{
return("{");
}
if (t == JSTokenizerToken.CloseCurly)
{
return("}");
}
return(JSTokenizerToken.None.ToString());
}
static internal JSTokenizerToken FromAssignOperatorToBinary(JSTokenizerToken assignment)
{
Debug.Assert((assignment & JSTokenizerToken.IsAssignOperator) != 0 && assignment != JSTokenizerToken.Assign);
return(_assignBinaryMap[((int)assignment & 15) - 2]);
}
/// <summary>
/// Computes the precedence with a provision of 1 bit to ease the handling of right associative infix operators.
/// </summary>
/// <returns>An even precedence level between 30 and 2. 0 if the token has <see cref="JSTokenizerError.IsErrorOrEndOfInput"/> bit set.</returns>
/// <remarks>
/// This uses <see cref="JSTokenizerToken.OpLevelMask"/> and <see cref="JSTokenizerToken.OpLevelShift"/>.
/// </remarks>
public static int PrecedenceLevel(JSTokenizerToken t)
{
return(t > 0 ? (((int)(t & JSTokenizerToken.OpLevelMask)) >> (int)JSTokenizerToken.OpLevelShift) << 1 : 0);
}
public UnaryExpr(SourceLocation location, JSTokenizerToken type, Expr e)
: base(location, e.IsStatement, false)
{
TokenType = type;
Expression = e;
}
