public LocalDeclarationStatement(IType type, IdentifierExpression identifier, ExpressionNode rightSide)
: base(identifier.RelatedToken)
{
this.type = type;
this.identifiers.Expressions.Add(identifier);
this.rightSide = rightSide;
}
public MemberAccessExpression(ExpressionNode left, ExpressionNode right, TokenID qualifierKind)
: base(left.RelatedToken)
{
this.left = left;
this.right = right;
this.qualifierKind = qualifierKind;
}
public ConditionalExpression(ExpressionNode test, ExpressionNode left, ExpressionNode right)
: base(test.RelatedToken)
{
this.test = test;
this.left = left;
this.right = right;
}
public BinaryExpression(TokenID op, ExpressionNode left, ExpressionNode right)
: base(left.RelatedToken)
{
this.op = op;
this.left = left;
this.right = right; // right must be 'type'
}
public SizeOfExpression(ExpressionNode expression)
: base(expression.RelatedToken)
{
this.expression = expression;
}
public StackallocExpression(IType type, ExpressionNode expression, Token relatedToken)
: base(relatedToken)
{
this.type = type;
this.expression = expression;
}
public void AddDeclarator(IdentifierExpression identifier, ExpressionNode initializer)
{
declarators.Add(new Declarator(identifier, initializer));
}
public LocalDeclarationStatement(IType type, IdentifierExpression identifier, ExpressionNode rightSide)
: base(identifier.RelatedToken)
{
decl = new LocalDeclaration(type, identifier, rightSide);
}
public MemberAccessExpression(IMemberAccessible left, ExpressionNode right)
: base(((BaseNode)left).RelatedToken)
{
this.left = left;
this.right = right;
}
public InvocationExpression(ExpressionNode leftSide, NodeCollection<ArgumentNode> argumentList)
: base(leftSide.RelatedToken)
{
this.leftSide = leftSide;
this.argumentList = argumentList;
}
public BinaryExpression(TokenID op, ExpressionNode left)
: base(left.RelatedToken)
{
this.op = op;
this.left = left;
}
private void CheckRankSpecifier(ExpressionNode node)
{
// now any 'rank only' specifiers (without size decls)
while (curtok.ID == TokenID.LBracket)
{
if ( curTokNode != null &&
curTokNode.Value.ID != TokenID.RBracket &&
curTokNode.Value.ID != TokenID.Comma)
{
// anything with size or accessor decls has own node type
break;
}
if (!(node is IType))
{
node = new TypeNode( node );
}
Advance(); // over lbracket
int commaCount = 0;
while (curtok.ID == TokenID.Comma)
{
commaCount++;
Advance();
}
((IType)node).RankSpecifiers.Add(commaCount);
AssertAndAdvance(TokenID.RBracket);
}
}
public DereferenceExpression(ExpressionNode expression)
: base(expression.RelatedToken)
{
this.expression = expression;
}
public CheckedExpression(ExpressionNode expression)
: base(expression.RelatedToken)
{
this.expression = expression;
}
public AssignmentExpression(TokenID op, ExpressionNode variable, ExpressionNode rightSide): base(variable.RelatedToken)
{
this.op = op;
this.variable = variable;
this.rightSide = rightSide;
}
public PPIfNode(ExpressionNode expression)
: base(expression.RelatedToken)
{
this.expression = expression;
}
public ParenthesizedExpression(ExpressionNode expression)
: base(expression.RelatedToken)
{
this.expression = expression;
}
private ExpressionNode CheckIdentifierIsType(ExpressionNode expr, bool consumeTypeParameter, bool allowTypeParameterAttributes, bool inDeclaration)
{
ExpressionNode result = expr;
if (consumeTypeParameter)
{
//check if it is a generic type
ParsePossibleTypeParameterNode(allowTypeParameterAttributes, inDeclaration, true);
if (curTypeParameters != null
&& curTypeParameters.Count != 0
//&& curtok.ID != TokenID.LParen
)
{
TypeNode type = result as TypeNode;
if (type == null)
{
type = new TypeNode(result.RelatedToken);
type.Identifier.Expressions.Add(result);
result = type;
}
ApplyTypeParameters(type);
}
}
switch (curtok.ID)
{
case TokenID.LBracket:
if (!isNewStatement)
{
CheckRankSpecifier(result);
}
break;
}
return result;
}
private void PopLocalDeclaration(ExpressionNode node)
{
ExpressionNode expr = node;
// local declaration case
BlockStatement curBlock = blockStack.Peek();
do
{
curBlock.Statements.Add(new ExpressionStatement(expr ));
expr = (exprStack.Count > 0) ? exprStack.Pop() : null;
}
while (expr is LocalDeclarationStatement);
}
/// <summary>
/// tag a type as nullable.
/// If node is not a type, the method converts it to a type
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
private static ExpressionNode TagAsNullableType(ExpressionNode node)
{
// this is not a type declaration
// the parser convert it to inullable type
if ( !(node is INullableType) )
{
node = new TypeNode(node );
}
((INullableType)node).IsNullableType = true;
return node;
}
public PPIfNode(ExpressionNode expression)
: base(expression.RelatedToken)
{
this.expression = expression;
}
/// <summary>
/// tag a type as pointer.
/// If node is not a type pointer, the method converts it to a type pointer
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
private static ExpressionNode TagAsPointerType(ExpressionNode node)
{
if (!(node is IPointer))
{
node = new TypeNode(node );
}
return new TypePointerNode(node );
}
public Declarator(IdentifierExpression identifier, ExpressionNode initializer)
{
Identifier = identifier;
Initializer = initializer;
}
public UnaryCastExpression(IType type, ExpressionNode child, Token relatedToken)
: base(relatedToken)
{
this.type = type;
this.child = child;
}
public LocalDeclaration(IType type, IdentifierExpression identifier, ExpressionNode rightSide)
: base(identifier.RelatedToken)
{
this.type = type;
AddDeclarator(identifier, rightSide);
}
public ElementAccessExpression(ExpressionNode leftSide)
: base(leftSide.RelatedToken)
{
this.leftSide = leftSide;
}
public PostDecrementExpression(ExpressionNode expression)
: base(expression.RelatedToken)
{
this.expression = expression;
}
public ElementAccessExpression(ExpressionNode leftSide, ExpressionList expressions)
: base(leftSide.RelatedToken)
{
this.leftSide = leftSide;
this.expressions = expressions;
}
public OutNode(ExpressionNode variableReference) : base(variableReference.RelatedToken)
{
this.variableReference = variableReference;
}
public ConstantExpression(ExpressionNode val)
: base(val.RelatedToken)
{
this.val = val;
}
public BaseAccessExpression(ExpressionNode expression) :base(expression.RelatedToken)
{
this.expression = expression;
}
public TypeOfExpression(ExpressionNode expression)
: base(expression.RelatedToken)
{
this.expression = expression;
}
