internal VariableDeclarationStatement(CsTokenList tokens, bool constant, VariableDeclarationExpression expression) : base(StatementType.VariableDeclaration, tokens) { this.constant = constant; this.expression = expression; base.AddExpression(expression); }
/// <summary> /// Parses and returns a field. /// </summary> /// <param name="parent">The parent of the element.</param> /// <param name="elementReference">A reference to the element being created.</param> /// <param name="unsafeCode">Indicates whether the code is marked as unsafe.</param> /// <param name="generated">Indicates whether the code is marked as generated code.</param> /// <param name="xmlHeader">The element's documentation header.</param> /// <param name="attributes">The attributes on the element.</param> /// <returns>Returns the element.</returns> private Field ParseField( CsElement parent, Reference<ICodePart> elementReference, bool unsafeCode, bool generated, XmlHeader xmlHeader, ICollection<Attribute> attributes) { Param.AssertNotNull(parent, "parent"); Param.AssertNotNull(elementReference, "elementReference"); Param.Ignore(unsafeCode); Param.Ignore(generated); Param.Ignore(xmlHeader); Param.Ignore(attributes); Node<CsToken> previousTokenNode = this.tokens.Last; // Get the modifiers and access. AccessModifierType accessModifier = AccessModifierType.Private; Dictionary<CsTokenType, CsToken> modifiers = this.GetElementModifiers(elementReference, ref accessModifier, FieldModifiers); unsafeCode |= modifiers.ContainsKey(CsTokenType.Unsafe); // Get the field type. TypeToken fieldType = this.GetTypeToken(elementReference, unsafeCode, true); Node<CsToken> fieldTypeNode = this.tokens.InsertLast(fieldType); // Get all of the variable declarators. IList<VariableDeclaratorExpression> declarators = this.ParseFieldDeclarators(elementReference, unsafeCode, fieldType); if (declarators.Count == 0) { throw this.CreateSyntaxException(); } VariableDeclarationExpression declarationExpression = new VariableDeclarationExpression( new CsTokenList(this.tokens, declarators[0].Tokens.First, this.tokens.Last), new LiteralExpression(this.tokens, fieldTypeNode), declarators); // Create the field. Node<CsToken> firstTokenNode = previousTokenNode == null ? this.tokens.First : previousTokenNode.Next; CsTokenList declarationTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last); Declaration declaration = new Declaration( declarationTokens, declarators[0].Identifier.Text, ElementType.Field, accessModifier, modifiers); Field field = new Field( this.document, parent, xmlHeader, attributes, declaration, fieldType, unsafeCode, generated); elementReference.Target = field; // Get the trailing semicolon. this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon, elementReference)); // Create the variable declaration statement and add it to the field. field.VariableDeclarationStatement = new VariableDeclarationStatement( new CsTokenList(this.tokens, declarators[0].Tokens.First, this.tokens.Last), field.Const, declarationExpression); return field; }
/// <summary> /// Reads an expression beginning with two unknown words. /// </summary> /// <param name="type">The type of the variable.</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 VariableDeclarationExpression GetVariableDeclarationExpression( Expression type, ExpressionPrecedence previousPrecedence, bool unsafeCode) { Param.AssertNotNull(type, "type"); Param.Ignore(previousPrecedence); Param.Ignore(unsafeCode); Debug.Assert( type.ExpressionType == ExpressionType.Literal || type.ExpressionType == ExpressionType.MemberAccess, "The left side of a variable declaration must either be a literal or a member access."); VariableDeclarationExpression expression = null; if (CheckPrecedence(previousPrecedence, ExpressionPrecedence.None)) { var expressionReference = new Reference<ICodePart>(); // Convert the type expression to a literal type token expression. LiteralExpression literalType = null; if (type.ExpressionType == ExpressionType.Literal) { literalType = type as LiteralExpression; if (!(literalType.Token is TypeToken)) { literalType = null; } } if (literalType == null) { literalType = this.ConvertTypeExpression(type); } // Get each declarator. List<VariableDeclaratorExpression> declarators = new List<VariableDeclaratorExpression>(); while (true) { // Get the next word. Symbol symbol = this.GetNextSymbol(SymbolType.Other, expressionReference); // Get the identifier. LiteralExpression identifier = this.GetLiteralExpression(expressionReference, unsafeCode); if (identifier == null || identifier.Tokens.First == null) { throw new SyntaxException(this.document.SourceCode, symbol.LineNumber); } // Get the initializer if it exists. Expression initializer = null; symbol = this.GetNextSymbol(expressionReference); if (symbol.SymbolType == SymbolType.Equals) { // Add the equals token. this.tokens.Add(this.GetOperatorToken(OperatorType.Equals, expressionReference)); // Check whether this is an array initializer. symbol = this.GetNextSymbol(expressionReference); if (symbol.SymbolType == SymbolType.OpenCurlyBracket) { initializer = this.GetArrayInitializerExpression(unsafeCode); } else { initializer = this.GetNextExpression(ExpressionPrecedence.None, expressionReference, unsafeCode); } } // Create the token list for the declarator. CsTokenList partialTokens = new CsTokenList( this.tokens, identifier.Tokens.First, this.tokens.Last); // Create and add the declarator. declarators.Add(new VariableDeclaratorExpression(partialTokens, identifier, initializer)); // Now check if the next character is a comma. If so there is another declarator. symbol = this.GetNextSymbol(expressionReference); if (symbol.SymbolType != SymbolType.Comma) { // There are no more declarators. break; } // Add the comma. this.tokens.Add(this.GetToken(CsTokenType.Comma, SymbolType.Comma, expressionReference)); } // Create the token list for the expression. CsTokenList tokenList = new CsTokenList(this.tokens, type.Tokens.First, this.tokens.Last); // Create the expression. expression = new VariableDeclarationExpression(tokenList, literalType, declarators.ToArray()); expressionReference.Target = expression; } return expression; }
private Field ParseField(CsElement parent, bool unsafeCode, bool generated, XmlHeader xmlHeader, ICollection<Microsoft.StyleCop.CSharp.Attribute> attributes) { Microsoft.StyleCop.Node<CsToken> last = this.tokens.Last; AccessModifierType @private = AccessModifierType.Private; Dictionary<CsTokenType, CsToken> elementModifiers = this.GetElementModifiers(ref @private, FieldModifiers); unsafeCode |= elementModifiers.ContainsKey(CsTokenType.Unsafe); TypeToken typeToken = this.GetTypeToken(unsafeCode, true); Microsoft.StyleCop.Node<CsToken> tokenNode = this.tokens.InsertLast(typeToken); IList<VariableDeclaratorExpression> declarators = this.ParseFieldDeclarators(unsafeCode, typeToken); if (declarators.Count == 0) { throw this.CreateSyntaxException(); } VariableDeclarationExpression expression = new VariableDeclarationExpression(new CsTokenList(this.tokens, declarators[0].Tokens.First, this.tokens.Last), new LiteralExpression(this.tokens, tokenNode), declarators); Microsoft.StyleCop.Node<CsToken> firstItemNode = (last == null) ? this.tokens.First : last.Next; CsTokenList tokens = new CsTokenList(this.tokens, firstItemNode, this.tokens.Last); Declaration declaration = new Declaration(tokens, declarators[0].Identifier.Text, ElementType.Field, @private, elementModifiers); Field field = new Field(this.document, parent, xmlHeader, attributes, declaration, typeToken, unsafeCode, generated); this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon)); field.VariableDeclarationStatement = new VariableDeclarationStatement(new CsTokenList(this.tokens, declarators[0].Tokens.First, this.tokens.Last), field.Const, expression); return field; }
internal FixedStatement(CsTokenList tokens, VariableDeclarationExpression fixedVariable) : base(StatementType.Fixed, tokens) { this.fixedVariable = fixedVariable; base.AddExpression(fixedVariable); }