/// <summary>
/// Returns true if the parser is in a state that allows the creation of an implemented operator
/// </summary>
/// <param name="parser">Parser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns>True if this Expression operator can create an expression</returns>
public override bool CanCreate(HlExpressionParser parser, HlExpression currentNode)
{
return(parser.CurrentToken.Type == HlTokenType.OpPlus &&
parser.Reader.PeekNext().Type == HlTokenType.OpPlus ||
parser.CurrentToken.Type == HlTokenType.OpMinus &&
parser.Reader.PeekNext().Type == HlTokenType.OpMinus);
}
/// <summary>
/// Returns true if the parser is in a state that allows the creation of an implemented operator
/// </summary>
/// <param name="parser">Parser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns>True if this Expression operator can create an expression</returns>
public override bool CanCreate(HlExpressionParser parser, HlExpression currentNode)
{
return(parser.CurrentToken.Type == HlTokenType.OpLessThan &&
parser.Reader.PeekNext().Type == HlTokenType.OpLessThan ||
parser.CurrentToken.Type == HlTokenType.OpGreaterThan &&
parser.Reader.PeekNext().Type == HlTokenType.OpGreaterThan);
}
/// <summary>
/// Returns true if the parser is in a state that allows the creation of an implemented operator
/// </summary>
/// <param name="parser">Parser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns>True if this Expression operator can create an expression</returns>
public override bool CanCreate(HlExpressionParser parser, HlExpression currentNode)
{
return((parser.CurrentToken.Type == HlTokenType.OpAsterisk ||
parser.CurrentToken.Type == HlTokenType.OpFwdSlash ||
parser.CurrentToken.Type == HlTokenType.OpPercent) &&
parser.Reader.PeekNext().Type != HlTokenType.OpEquality);
}
/// <summary>
/// Returns true if the parser is in a state that allows the creation of an implemented operator
/// </summary>
/// <param name="parser">Parser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns>True if this Expression operator can create an expression</returns>
public override bool CanCreate(HlExpressionParser parser, HlExpression currentNode)
{
return(parser.CurrentToken.Type == HlTokenType.OpMinus &&
parser.Reader.PeekNext().Type == HlTokenType.OpMinus ||
parser.CurrentToken.Type == HlTokenType.OpBang &&
parser.Reader.PeekNext().Type != HlTokenType.OpEquality ||
parser.CurrentToken.Type == HlTokenType.OpTilde &&
parser.Reader.PeekNext().Type != HlTokenType.OpEquality);
}
/// <summary>
/// Creates an implemented expression
/// </summary>
/// <param name="parser">XLExpressionParser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns></returns>
public override HlExpression Create(HlExpressionParser parser, HlExpression currentNode)
{
parser.Eat(HlTokenType.OpCap);
return(new HlBinaryOp(
currentNode,
HlTokenType.OpCap,
parser.ParseExpr(PrecedenceLevel)
));
}
/// <summary>
/// Creates an implemented expression
/// </summary>
/// <param name="parser">XLExpressionParser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns></returns>
public override HlExpression Create(HlExpressionParser parser, HlExpression currentNode)
{
HlTokenType type = parser.CurrentToken.Type;
parser.Eat(type);
HlExpression token = new HlUnaryOp(parser.ParseExpr(PrecedenceLevel), type);
return(token);
}
/// <summary>
/// Creates an implemented expression
/// </summary>
/// <param name="parser">XLExpressionParser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns></returns>
public override HlExpression Create(HlExpressionParser parser, HlExpression currentNode)
{
HlTokenType tt = parser.CurrentToken.Type == HlTokenType.OpPlus
? HlTokenType.OpUnaryPostfixIncrement
: HlTokenType.OpUnaryPostfixDecrement;
parser.Eat(parser.CurrentToken.Type);
parser.Eat(parser.CurrentToken.Type);
HlExpression token =
new HlUnaryOp(currentNode, tt);
return(token);
}
/// <summary>
/// Creates an implemented expression
/// </summary>
/// <param name="parser">XLExpressionParser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns></returns>
public override HlExpression Create(HlExpressionParser parser, HlExpression currentNode)
{
parser.Eat(HlTokenType.OpBang);
parser.Eat(HlTokenType.OpEquality);
return(new HlUnaryOp(
new HlBinaryOp(
currentNode,
HlTokenType.OpComparison,
parser.ParseExpr(PrecedenceLevel)
),
HlTokenType.OpBang
));
}
/// <summary>
/// Returns true if the parser is in a state that allows the creation of an implemented operator
/// </summary>
/// <param name="parser">Parser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns>True if this Expression operator can create an expression</returns>
public override bool CanCreate(HlExpressionParser parser, HlExpression currentNode)
{
return((parser.CurrentToken.Type == HlTokenType.OpPlus ||
parser.CurrentToken.Type == HlTokenType.OpMinus ||
parser.CurrentToken.Type == HlTokenType.OpAsterisk ||
parser.CurrentToken.Type == HlTokenType.OpFwdSlash ||
parser.CurrentToken.Type == HlTokenType.OpPercent ||
parser.CurrentToken.Type == HlTokenType.OpAnd ||
parser.CurrentToken.Type == HlTokenType.OpPipe ||
parser.CurrentToken.Type == HlTokenType.OpCap) &&
parser.Reader.PeekNext().Type == HlTokenType.OpEquality ||
parser.CurrentToken.Type == HlTokenType.OpLessThan &&
parser.Reader.PeekNext().Type == HlTokenType.OpLessThan &&
parser.Reader.PeekNext(2).Type == HlTokenType.OpLessThan ||
parser.CurrentToken.Type == HlTokenType.OpGreaterThan &&
parser.Reader.PeekNext().Type == HlTokenType.OpGreaterThan &&
parser.Reader.PeekNext(2).Type == HlTokenType.OpLessThan);
}
/// <summary>
/// Creates an implemented expression
/// </summary>
/// <param name="parser">XLExpressionParser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns></returns>
public override HlExpression Create(HlExpressionParser parser, HlExpression currentNode)
{
HlTokenType type = parser.CurrentToken.Type;
parser.Eat(parser.CurrentToken.Type);
HlExpression node = null;
if (type == HlTokenType.OpLessThan)
{
if (parser.CurrentToken.Type == HlTokenType.OpEquality)
{
parser.Eat(HlTokenType.OpEquality);
node = new HlBinaryOp(
currentNode,
HlTokenType.OpLessOrEqual,
parser.ParseExpr(PrecedenceLevel)
);
}
else
{
node = new HlBinaryOp(currentNode, type, parser.ParseExpr(PrecedenceLevel));
}
}
else if (type == HlTokenType.OpGreaterThan)
{
if (parser.CurrentToken.Type == HlTokenType.OpEquality)
{
parser.Eat(HlTokenType.OpEquality);
node = new HlBinaryOp(
currentNode,
HlTokenType.OpGreaterOrEqual,
parser.ParseExpr(PrecedenceLevel)
);
}
else
{
node = new HlBinaryOp(currentNode, type, parser.ParseExpr(PrecedenceLevel));
}
}
return(node);
}
/// <summary>
/// Creates an implemented expression
/// </summary>
/// <param name="parser">XLExpressionParser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns></returns>
public override HlExpression Create(HlExpressionParser parser, HlExpression currentNode)
{
HlTokenType type = parser.CurrentToken.Type;
parser.Eat(type);
parser.Eat(type);
if (type == HlTokenType.OpLessThan)
{
type = HlTokenType.OpShiftLeft;
}
else if (type == HlTokenType.OpGreaterThan)
{
type = HlTokenType.OpShiftRight;
}
return(new HlBinaryOp(
currentNode,
type,
parser.ParseExpr(PrecedenceLevel)
));
}
/// <summary>
/// Creates an implemented expression
/// </summary>
/// <param name="parser">XLExpressionParser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns></returns>
public override HlExpression Create(HlExpressionParser parser, HlExpression currentNode)
{
parser.Eat(HlTokenType.OpIndexerBracketOpen);
List <HlExpression> parameterList = new List <HlExpression>();
bool comma = false;
while (parser.CurrentToken.Type != HlTokenType.OpIndexerBracketClose)
{
if (comma)
{
parser.Eat(HlTokenType.OpComma);
}
else
{
parameterList.Add(parser.ParseExpr());
comma = true;
}
}
parser.Eat(HlTokenType.OpIndexerBracketClose);
return(new HlArrayAccessorOp(currentNode, parameterList));
}
/// <summary>
/// Returns true if the parser is in a state that allows the creation of an implemented operator
/// </summary>
/// <param name="parser">Parser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns>True if this Expression operator can create an expression</returns>
public override bool CanCreate(HlExpressionParser parser, HlExpression currentNode)
{
return(parser.CurrentToken.Type == HlTokenType.OpIndexerBracketOpen);
}
/// <summary>
/// Creates an implemented expression
/// </summary>
/// <param name="parser">XLExpressionParser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns></returns>
public override HlExpression Create(HlExpressionParser parser, HlExpression currentNode)
{
parser.Eat(HlTokenType.OpDot);
return(new HlMemberAccessOp(currentNode, parser.ParseExpr(PrecedenceLevel)));
}
/// <summary>
/// Returns true if the parser is in a state that allows the creation of an implemented operator
/// </summary>
/// <param name="parser">Parser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns>True if this Expression operator can create an expression</returns>
public override bool CanCreate(HlExpressionParser parser, HlExpression currentNode)
{
return(parser.CurrentToken.Type == HlTokenType.OpDot);
}
/// <summary>
/// Creates an implemented expression
/// </summary>
/// <param name="parser">XLExpressionParser</param>
/// <param name="currentNode">Current Expression Node</param>
/// <returns></returns>
public override HlExpression Create(HlExpressionParser parser, HlExpression currentNode)
{
IHlToken token = parser.CurrentToken;
HlTokenType tt;
switch (parser.CurrentToken.Type)
{
case HlTokenType.OpPlus:
tt = HlTokenType.OpSumAssign;
break;
case HlTokenType.OpMinus:
tt = HlTokenType.OpDifAssign;
break;
case HlTokenType.OpAsterisk:
tt = HlTokenType.OpProdAssign;
break;
case HlTokenType.OpFwdSlash:
tt = HlTokenType.OpQuotAssign;
break;
case HlTokenType.OpPercent:
tt = HlTokenType.OpRemAssign;
break;
case HlTokenType.OpPipe:
tt = HlTokenType.OpOrAssign;
break;
case HlTokenType.OpAnd:
tt = HlTokenType.OpAndAssign;
break;
case HlTokenType.OpCap:
tt = HlTokenType.OpXOrAssign;
break;
case HlTokenType.OpGreaterThan:
tt = HlTokenType.OpShiftRightAssign;
parser.Eat(token.Type);
break;
case HlTokenType.OpLessThan:
tt = HlTokenType.OpShiftLeftAssign;
parser.Eat(token.Type);
break;
default:
EventManager <ErrorEvent> .SendEvent(
new HlTokenReadEvent(
HlTokenType.Any,
parser.CurrentToken.Type
)
);
tt = HlTokenType.Unknown;
break;
}
parser.Eat(token.Type);
parser.Eat(HlTokenType.OpEquality);
return(new HlBinaryOp(currentNode, tt, parser.ParseExpr(PrecedenceLevel)));
}
