/// <summary> /// Reads a NOT expression. /// </summary> /// <param name="sourceCode"> /// The source code containing the expression. /// </param> /// <param name="parentReference"> /// The parent code part. /// </param> /// <returns> /// Returns the expression. /// </returns> private UnaryExpression GetConditionalPreprocessorNotExpression(SourceCode sourceCode, Reference <ICodePart> parentReference) { Param.AssertNotNull(sourceCode, "sourceCode"); Param.AssertNotNull(parentReference, "parentReference"); Reference <ICodePart> expressionReference = new Reference <ICodePart>(); // Get the symbol. this.AdvanceToNextConditionalDirectiveCodeSymbol(parentReference); Symbol symbol = this.symbols.Peek(1); Debug.Assert(symbol != null, "The next symbol should not be null"); // Create the token based on the type of the symbol. OperatorSymbol token = new OperatorSymbol(symbol.Text, OperatorCategory.Unary, OperatorType.Not, symbol.Location, expressionReference, this.symbols.Generated); Node <CsToken> tokenNode = this.tokens.InsertLast(token); // Advance up to the symbol and add it to the document. this.symbols.Advance(); // Get the expression after the operator. Expression innerExpression = this.GetNextConditionalPreprocessorExpression(sourceCode, ExpressionPrecedence.Unary); if (innerExpression == null || innerExpression.Tokens.First == null) { throw new SyntaxException(sourceCode, symbol.LineNumber); } // Create the partial token list for the expression. CsTokenList partialTokens = new CsTokenList(this.tokens, tokenNode, this.tokens.Last); // Create and return the expression. UnaryExpression expression = new UnaryExpression(partialTokens, UnaryExpression.Operator.Not, innerExpression); expressionReference.Target = expression; return(expression); }
/// <summary> /// Determines whether the given token is preceded by a member access symbol. /// </summary> /// <param name="literalTokenNode"> /// The token to check. /// </param> /// <param name="masterList"> /// The list containing the token. /// </param> /// <returns> /// Returns true if the token is preceded by a member access symbol. /// </returns> private static bool IsLiteralTokenPrecededByMemberAccessSymbol(Node <CsToken> literalTokenNode, MasterList <CsToken> masterList) { Param.AssertNotNull(literalTokenNode, "literalTokenNode"); Param.AssertNotNull(masterList, "masterList"); // Get the previous non-whitespace token. CsToken previousToken = ReadabilityRules.GetPreviousToken(literalTokenNode.Previous, masterList); if (previousToken == null) { return(false); } if (previousToken.CsTokenType == CsTokenType.OperatorSymbol) { OperatorSymbol symbol = (OperatorSymbol)previousToken; if (symbol.SymbolType == OperatorType.MemberAccess || symbol.SymbolType == OperatorType.Pointer || symbol.SymbolType == OperatorType.QualifiedAlias) { return(true); } } return(false); }
/// <summary> /// Reads an unsafe type expression. /// </summary> /// <param name="type"> /// The type expression. /// </param> /// <param name="previousPrecedence"> /// The precedence of the previous expression. /// </param> /// <param name="parentReference"> /// The parent code unit. /// </param> /// <returns> /// Returns the expression. /// </returns> private UnsafeAccessExpression GetUnsafeTypeExpression(Expression type, ExpressionPrecedence previousPrecedence, Reference<ICodePart> parentReference) { Param.Ignore(type); Param.AssertNotNull(previousPrecedence, "previousPrecedence"); Param.AssertNotNull(parentReference, "parentReference"); UnsafeAccessExpression expression = null; if (CheckPrecedence(previousPrecedence, ExpressionPrecedence.Unary)) { // Get the operator symbol. Symbol symbol = this.GetNextSymbol(parentReference); Reference<ICodePart> expressionReference = new Reference<ICodePart>(); OperatorType operatorType; UnsafeAccessExpression.Operator unsafeOperatorType; if (symbol.SymbolType == SymbolType.LogicalAnd) { operatorType = OperatorType.AddressOf; unsafeOperatorType = UnsafeAccessExpression.Operator.AddressOf; } else if (symbol.SymbolType == SymbolType.Multiplication) { operatorType = OperatorType.Dereference; unsafeOperatorType = UnsafeAccessExpression.Operator.Dereference; } else { Debug.Fail("Unexpected operator type."); throw new InvalidOperationException(); } // Create a token for the operator symbol. this.symbols.Advance(); OperatorSymbol token = new OperatorSymbol( symbol.Text, OperatorCategory.Reference, operatorType, symbol.Location, expressionReference, this.symbols.Generated); this.tokens.Add(token); // Create the partial token list for the expression. CsTokenList partialTokens = new CsTokenList(this.tokens, type.Tokens.First, this.tokens.Last); // Create and return the expression. expression = new UnsafeAccessExpression(partialTokens, unsafeOperatorType, type); expressionReference.Target = expression; } return expression; }
/// <summary> /// Reads an unsafe access expression. /// </summary> /// <param name="parentReference"> /// The parent code unit. /// </param> /// <param name="unsafeCode"> /// Indicates whether the code being parsed resides in an unsafe code block. /// </param> /// <returns> /// Returns the expression. /// </returns> private UnsafeAccessExpression GetUnsafeAccessExpression(Reference<ICodePart> parentReference, bool unsafeCode) { Param.AssertNotNull(parentReference, "parentReference"); Param.Assert(unsafeCode, "unsafeCode", "Un unsafe access must reside in an unsafe code block."); // Get the operator symbol. Symbol symbol = this.GetNextSymbol(parentReference); Reference<ICodePart> expressionReference = new Reference<ICodePart>(); OperatorType operatorType; UnsafeAccessExpression.Operator unsafeOperatorType; if (symbol.SymbolType == SymbolType.LogicalAnd) { operatorType = OperatorType.AddressOf; unsafeOperatorType = UnsafeAccessExpression.Operator.AddressOf; } else if (symbol.SymbolType == SymbolType.Multiplication) { operatorType = OperatorType.Dereference; unsafeOperatorType = UnsafeAccessExpression.Operator.Dereference; } else { Debug.Fail("Unexpected operator type."); throw new InvalidOperationException(); } // Create a token for the operator symbol. this.symbols.Advance(); OperatorSymbol token = new OperatorSymbol(symbol.Text, OperatorCategory.Reference, operatorType, symbol.Location, expressionReference, this.symbols.Generated); Node<CsToken> tokenNode = this.tokens.InsertLast(token); // Get the expression being accessed. Expression innerExpression = this.GetNextExpression(ExpressionPrecedence.Unary, expressionReference, unsafeCode); if (innerExpression == null || innerExpression.Tokens.First == null) { throw new SyntaxException(this.document.SourceCode, symbol.LineNumber); } // Create the partial token list for the expression. CsTokenList partialTokens = new CsTokenList(this.tokens, tokenNode, this.tokens.Last); // Create and return the expression. UnsafeAccessExpression expression = new UnsafeAccessExpression(partialTokens, unsafeOperatorType, innerExpression); expressionReference.Target = expression; return expression; }
/// <summary> /// Reads a unary expression. /// </summary> /// <param name="parentReference"> /// The parent code part. /// </param> /// <param name="unsafeCode"> /// Indicates whether the code being parsed resides in an unsafe code block. /// </param> /// <returns> /// Returns the expression. /// </returns> private UnaryExpression GetUnaryExpression(Reference<ICodePart> parentReference, bool unsafeCode) { Param.AssertNotNull(parentReference, "parentReference"); Param.Ignore(unsafeCode); Reference<ICodePart> expressionReference = new Reference<ICodePart>(); // Create the token based on the type of the symbol. Symbol symbol = this.GetNextSymbol(parentReference); OperatorSymbol token; UnaryExpression.Operator operatorType; if (symbol.SymbolType == SymbolType.Plus) { operatorType = UnaryExpression.Operator.Positive; token = new OperatorSymbol(symbol.Text, OperatorCategory.Unary, OperatorType.Positive, symbol.Location, expressionReference, this.symbols.Generated); } else if (symbol.SymbolType == SymbolType.Minus) { operatorType = UnaryExpression.Operator.Negative; token = new OperatorSymbol(symbol.Text, OperatorCategory.Unary, OperatorType.Negative, symbol.Location, expressionReference, this.symbols.Generated); } else if (symbol.SymbolType == SymbolType.Not) { operatorType = UnaryExpression.Operator.Not; token = new OperatorSymbol(symbol.Text, OperatorCategory.Unary, OperatorType.Not, symbol.Location, expressionReference, this.symbols.Generated); } else if (symbol.SymbolType == SymbolType.Tilde) { operatorType = UnaryExpression.Operator.BitwiseCompliment; token = new OperatorSymbol( symbol.Text, OperatorCategory.Unary, OperatorType.BitwiseCompliment, symbol.Location, expressionReference, this.symbols.Generated); } else { // This is not a unary type. Debug.Fail("Unexpected operator type"); throw new StyleCopException(); } Node<CsToken> tokenNode = this.tokens.InsertLast(token); this.symbols.Advance(); // Get the expression after the operator. Expression innerExpression = this.GetNextExpression(ExpressionPrecedence.Unary, expressionReference, unsafeCode); if (innerExpression == null || innerExpression.Tokens.First == null) { throw this.CreateSyntaxException(); } // Create the partial token list for the expression. CsTokenList partialTokens = new CsTokenList(this.tokens, tokenNode, this.tokens.Last); // Create and return the expression. UnaryExpression expression = new UnaryExpression(partialTokens, operatorType, innerExpression); expressionReference.Target = expression; return expression; }
/// <summary> /// Reads a NOT expression. /// </summary> /// <param name="sourceCode"> /// The source code containing the expression. /// </param> /// <param name="parentReference"> /// The parent code part. /// </param> /// <returns> /// Returns the expression. /// </returns> private UnaryExpression GetConditionalPreprocessorNotExpression(SourceCode sourceCode, Reference<ICodePart> parentReference) { Param.AssertNotNull(sourceCode, "sourceCode"); Param.AssertNotNull(parentReference, "parentReference"); Reference<ICodePart> expressionReference = new Reference<ICodePart>(); // Get the symbol. this.AdvanceToNextConditionalDirectiveCodeSymbol(parentReference); Symbol symbol = this.symbols.Peek(1); Debug.Assert(symbol != null, "The next symbol should not be null"); // Create the token based on the type of the symbol. OperatorSymbol token = new OperatorSymbol(symbol.Text, OperatorCategory.Unary, OperatorType.Not, symbol.Location, expressionReference, this.symbols.Generated); Node<CsToken> tokenNode = this.tokens.InsertLast(token); // Advance up to the symbol and add it to the document. this.symbols.Advance(); // Get the expression after the operator. Expression innerExpression = this.GetNextConditionalPreprocessorExpression(sourceCode, ExpressionPrecedence.Unary); if (innerExpression == null || innerExpression.Tokens.First == null) { throw new SyntaxException(sourceCode, symbol.LineNumber); } // Create the partial token list for the expression. CsTokenList partialTokens = new CsTokenList(this.tokens, tokenNode, this.tokens.Last); // Create and return the expression. UnaryExpression expression = new UnaryExpression(partialTokens, UnaryExpression.Operator.Not, innerExpression); expressionReference.Target = expression; return expression; }
/// <summary> /// Reads a relational expression. /// </summary> /// <param name="sourceCode"> /// The file containing the expression. /// </param> /// <param name="parentReference"> /// The parent code unit. /// </param> /// <param name="leftHandSide"> /// The expression on the left hand side of the operator. /// </param> /// <param name="previousPrecedence"> /// The precedence of the expression just before this one. /// </param> /// <returns> /// Returns the expression. /// </returns> private RelationalExpression GetConditionalPreprocessorEqualityExpression( SourceCode sourceCode, Reference<ICodePart> parentReference, Expression leftHandSide, ExpressionPrecedence previousPrecedence) { Param.AssertNotNull(sourceCode, "sourceCode"); Param.AssertNotNull(parentReference, "parentReference"); Param.AssertNotNull(leftHandSide, "leftHandSide"); Param.Ignore(previousPrecedence); RelationalExpression expression = null; this.AdvanceToNextConditionalDirectiveCodeSymbol(parentReference); Symbol firstSymbol = this.symbols.Peek(1); if (firstSymbol == null) { throw new SyntaxException(sourceCode, firstSymbol.LineNumber); } Reference<ICodePart> expressionReference = new Reference<ICodePart>(); // Create the operator symbol. OperatorType type; OperatorCategory category; GetOperatorType(firstSymbol, out type, out category); OperatorSymbol operatorToken = new OperatorSymbol(firstSymbol.Text, category, type, firstSymbol.Location, expressionReference, this.symbols.Generated); // Check the precedence of the operators to make sure we can gather this statement now. ExpressionPrecedence precedence = GetOperatorPrecedence(operatorToken.SymbolType); if (CheckPrecedence(previousPrecedence, precedence)) { // Add the operator token to the document and advance the symbol manager up to it. this.symbols.Advance(); this.tokens.Add(operatorToken); // Get the expression on the right-hand side of the operator. Expression rightHandSide = this.GetNextConditionalPreprocessorExpression(sourceCode, precedence); if (rightHandSide == null) { throw new SyntaxException(sourceCode, operatorToken.LineNumber); } // Create the partial token list for the expression. CsTokenList partialTokens = new CsTokenList(this.tokens, leftHandSide.Tokens.First, this.tokens.Last); // Get the expression operator type. RelationalExpression.Operator relationalType; switch (operatorToken.SymbolType) { case OperatorType.ConditionalEquals: relationalType = RelationalExpression.Operator.EqualTo; break; case OperatorType.NotEquals: relationalType = RelationalExpression.Operator.NotEqualTo; break; default: throw new SyntaxException(sourceCode, operatorToken.LineNumber); } // Create and return the expression. expression = new RelationalExpression(partialTokens, relationalType, leftHandSide, rightHandSide); expressionReference.Target = expression; } return expression; }
/// <summary> /// Reads a relational expression. /// </summary> /// <param name="sourceCode"> /// The file containing the expression. /// </param> /// <param name="parentReference"> /// The parent code unit. /// </param> /// <param name="leftHandSide"> /// The expression on the left hand side of the operator. /// </param> /// <param name="previousPrecedence"> /// The precedence of the expression just before this one. /// </param> /// <returns> /// Returns the expression. /// </returns> private RelationalExpression GetConditionalPreprocessorEqualityExpression( SourceCode sourceCode, Reference <ICodePart> parentReference, Expression leftHandSide, ExpressionPrecedence previousPrecedence) { Param.AssertNotNull(sourceCode, "sourceCode"); Param.AssertNotNull(parentReference, "parentReference"); Param.AssertNotNull(leftHandSide, "leftHandSide"); Param.Ignore(previousPrecedence); RelationalExpression expression = null; this.AdvanceToNextConditionalDirectiveCodeSymbol(parentReference); Symbol firstSymbol = this.symbols.Peek(1); if (firstSymbol == null) { throw new SyntaxException(sourceCode, firstSymbol.LineNumber); } Reference <ICodePart> expressionReference = new Reference <ICodePart>(); // Create the operator symbol. OperatorType type; OperatorCategory category; GetOperatorType(firstSymbol, out type, out category); OperatorSymbol operatorToken = new OperatorSymbol(firstSymbol.Text, category, type, firstSymbol.Location, expressionReference, this.symbols.Generated); // Check the precedence of the operators to make sure we can gather this statement now. ExpressionPrecedence precedence = GetOperatorPrecedence(operatorToken.SymbolType); if (CheckPrecedence(previousPrecedence, precedence)) { // Add the operator token to the document and advance the symbol manager up to it. this.symbols.Advance(); this.tokens.Add(operatorToken); // Get the expression on the right-hand side of the operator. Expression rightHandSide = this.GetNextConditionalPreprocessorExpression(sourceCode, precedence); if (rightHandSide == null) { throw new SyntaxException(sourceCode, operatorToken.LineNumber); } // Create the partial token list for the expression. CsTokenList partialTokens = new CsTokenList(this.tokens, leftHandSide.Tokens.First, this.tokens.Last); // Get the expression operator type. RelationalExpression.Operator relationalType; switch (operatorToken.SymbolType) { case OperatorType.ConditionalEquals: relationalType = RelationalExpression.Operator.EqualTo; break; case OperatorType.NotEquals: relationalType = RelationalExpression.Operator.NotEqualTo; break; default: throw new SyntaxException(sourceCode, operatorToken.LineNumber); } // Create and return the expression. expression = new RelationalExpression(partialTokens, relationalType, leftHandSide, rightHandSide); expressionReference.Target = expression; } return(expression); }