/// <summary> /// Initializes a new instance of the StackallocExpression class. /// </summary> /// <param name="tokens"> /// The list of tokens that form the expression. /// </param> /// <param name="type"> /// The array type. /// </param> internal StackallocExpression(CsTokenList tokens, ArrayAccessExpression type) : base(ExpressionType.Stackalloc, tokens) { Param.AssertNotNull(tokens, "tokens"); Param.AssertNotNull(type, "type"); this.type = type; this.AddExpression(type); }
/// <summary> /// Checks an array access expression to make that the parameters are positioned correctly. /// </summary> /// <param name="element"> /// The element containing the expression. /// </param> /// <param name="expression"> /// The expression to check. /// </param> private void CheckIndexerAccessParameters(CsElement element, ArrayAccessExpression expression) { Param.AssertNotNull(element, "element"); Param.AssertNotNull(expression, "expression"); if (expression.Tokens.First != null && !expression.Tokens.First.Value.Generated) { ArgumentList argumentList = new ArgumentList(expression.Arguments); CsTokenList argumentListTokens = GetArgumentListTokens( expression.Tokens, expression.Array.Tokens.Last, CsTokenType.OpenSquareBracket, CsTokenType.CloseSquareBracket); if (argumentListTokens != null) { this.CheckParameters( element, argumentListTokens, argumentList, expression.LineNumber, CsTokenType.OpenSquareBracket, CsTokenType.CloseSquareBracket, "indexer"); } } }
/// <summary> /// Initializes a new instance of the NewArrayExpression class. /// </summary> /// <param name="tokens"> /// The list of tokens that form the expression. /// </param> /// <param name="type"> /// The array type. /// </param> /// <param name="initializer"> /// The array initializer expression. /// </param> internal NewArrayExpression(CsTokenList tokens, ArrayAccessExpression type, ArrayInitializerExpression initializer) : base(ExpressionType.NewArray, tokens) { Param.AssertNotNull(tokens, "tokens"); Param.Ignore(type, "type"); Param.Ignore(initializer); this.type = type; this.initializer = initializer; if (type != null) { this.AddExpression(type); } if (initializer != null) { this.AddExpression(initializer); } }
/// <summary> /// Checks the given expression. /// </summary> /// <param name="expression"> /// The expression being visited. /// </param> /// <param name="parentExpression"> /// The parent expression, if any. /// </param> /// <param name="parentStatement"> /// The parent statement, if any. /// </param> /// <param name="parentElement"> /// The parent element, if any. /// </param> /// <param name="context"> /// The optional visitor context data. /// </param> /// <returns> /// Returns true to continue, or false to stop the walker. /// </returns> private bool ProcessExpression(Expression expression, Expression parentExpression, Statement parentStatement, CsElement parentElement, object context) { Param.AssertNotNull(expression, "expression"); Param.Ignore(parentExpression); Param.Ignore(parentStatement); Param.AssertNotNull(parentElement, "parentElement"); Param.Ignore(context); if (!parentElement.Generated) { switch (expression.ExpressionType) { case ExpressionType.Query: this.CheckQueryExpression(parentElement, (QueryExpression)expression); break; case ExpressionType.MethodInvocation: this.CheckMethodInvocationParameters(parentElement, (MethodInvocationExpression)expression); break; case ExpressionType.MemberAccess: this.CheckBuiltInTypeForMemberAccessExpressions(((MemberAccessExpression)expression).LeftHandSide.Tokens.First); break; case ExpressionType.ArrayAccess: // Calling this[x] shows up as an ArrayAccessExpression. ArrayAccessExpression a = (ArrayAccessExpression)expression; if (a.Array.Text == "this") { this.CheckIndexerAccessParameters(parentElement, (ArrayAccessExpression)expression); } break; } } return(true); }
/// <summary> /// Reads an array access expression. /// </summary> /// <param name="array"> /// The array being accessed. /// </param> /// <param name="previousPrecedence"> /// The precedence of the previous expression. /// </param> /// <param name="unsafeCode"> /// Indicates whether the code being parsed resides in an unsafe code block. /// </param> /// <returns> /// Returns the expression. /// </returns> private ArrayAccessExpression GetArrayAccessExpression(Expression array, ExpressionPrecedence previousPrecedence, bool unsafeCode) { Param.AssertNotNull(array, "array"); Param.Ignore(previousPrecedence); Param.Ignore(unsafeCode); ArrayAccessExpression expression = null; if (CheckPrecedence(previousPrecedence, ExpressionPrecedence.Primary)) { Reference<ICodePart> expressionReference = new Reference<ICodePart>(); // The next symbol will be the opening bracket. Bracket openingBracket = this.GetBracketToken(CsTokenType.OpenSquareBracket, SymbolType.OpenSquareBracket, expressionReference); Node<CsToken> openingBracketNode = this.tokens.InsertLast(openingBracket); // Get the argument list now. IList<Argument> argumentList = this.GetArgumentList(SymbolType.CloseSquareBracket, expressionReference, unsafeCode); // Get the closing bracket. Bracket closingBracket = this.GetBracketToken(CsTokenType.CloseSquareBracket, SymbolType.CloseSquareBracket, expressionReference); Node<CsToken> closingBracketNode = this.tokens.InsertLast(closingBracket); openingBracket.MatchingBracketNode = closingBracketNode; closingBracket.MatchingBracketNode = openingBracketNode; // Pull out the first token from the array. Node<CsToken> firstTokenNode = array.Tokens.First; // Create the token list for the method invocation expression. CsTokenList partialTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last); // Create and return the expression. expression = new ArrayAccessExpression(partialTokens, array, argumentList); expressionReference.Target = expression; } return expression; }
/// <summary> /// The save. /// </summary> /// <param name="arrayAccessExpression"> /// The array access expression. /// </param> private void Save(ArrayAccessExpression arrayAccessExpression) { @switch(arrayAccessExpression.Array); this.cppWriter.Write("["); this.Save(arrayAccessExpression.Arguments); this.cppWriter.Write("]"); }