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; }
/// <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; }