/// <summary> /// Reads a new array allocation expression from the code. /// </summary> /// <param name="unsafeCode"> /// Indicates whether the code being parsed resides in an unsafe code block. /// </param> /// <param name="firstTokenNode"> /// The first token in the expression. /// </param> /// <param name="type"> /// The type of the array. This may be null for an implicitly typed array. /// </param> /// <param name="expressionReference"> /// A reference to the expression being created. /// </param> /// <returns> /// Returns the expression. /// </returns> private NewArrayExpression GetNewArrayTypeExpression(bool unsafeCode, Node<CsToken> firstTokenNode, Expression type, Reference<ICodePart> expressionReference) { Param.Ignore(unsafeCode); Param.AssertNotNull(firstTokenNode, "firstTokenNode"); Param.Ignore(type); Param.AssertNotNull(expressionReference, "expressionReference"); // Get the next symbol. Symbol symbol = this.GetNextSymbol(SymbolType.OpenSquareBracket, expressionReference); // If the type is null, then this is an implicitly typed array and we will only find // array brackets here. Otherwise, we must get the array access expression which includes the type. if (type == null) { this.MovePastArrayBrackets(expressionReference); } else { // Get all of the array access expressions. while (symbol.SymbolType == SymbolType.OpenSquareBracket) { type = this.GetArrayAccessExpression(type, ExpressionPrecedence.None, unsafeCode); if (type == null || type.Tokens.First == null) { throw this.CreateSyntaxException(); } symbol = this.GetNextSymbol(expressionReference); } } // Make sure there was at least one array access. if (type != null && type.ExpressionType != ExpressionType.ArrayAccess) { throw this.CreateSyntaxException(); } // Get the next symbol and check the type. symbol = this.GetNextSymbol(expressionReference); // Get the initializer if there is one. ArrayInitializerExpression initializer = null; if (symbol.SymbolType == SymbolType.OpenCurlyBracket) { initializer = this.GetArrayInitializerExpression(unsafeCode); } // For an implicitly typed array, an array initializer is required. if (type == null && initializer == null) { throw this.CreateSyntaxException(); } // Create the token list for the new array expression. CsTokenList partialTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last); // Create and return the expression. NewArrayExpression expression = new NewArrayExpression(partialTokens, type as ArrayAccessExpression, initializer); expressionReference.Target = expression; return expression; }
/// <summary> /// The save. /// </summary> /// <param name="newArrayExpression"> /// The new array expression. /// </param> private void Save(NewArrayExpression newArrayExpression) { this.cppWriter.Write("new "); @switch(newArrayExpression.Type); if (newArrayExpression.Initializer != null) { @switch(newArrayExpression.Initializer); } }