/// <summary>
/// Extracts the body of the given preprocessor directive symbol, parses it, and returns the parsed expression.
/// </summary>
/// <param name="parser">
/// The C# parser.
/// </param>
/// <param name="sourceCode">
/// The source code containing the preprocessor directive symbol.
/// </param>
/// <param name="preprocessorSymbol">
/// The preprocessor directive symbol.
/// </param>
/// <param name="startIndex">
/// The index of the start of the expression body within the text string.
/// </param>
/// <returns>
/// Returns the expression.
/// </returns>
internal static Expression GetConditionalPreprocessorBodyExpression(CsParser parser, SourceCode sourceCode, Symbol preprocessorSymbol, int startIndex)
{
Param.AssertNotNull(parser, "parser");
Param.AssertNotNull(sourceCode, "sourceCode");
Param.AssertNotNull(preprocessorSymbol, "preprocessorSymbol");
Param.AssertGreaterThanOrEqualToZero(startIndex, "startIndex");
Debug.Assert(preprocessorSymbol.SymbolType == SymbolType.PreprocessorDirective, "The symbol is not a preprocessor directive.");
string text = preprocessorSymbol.Text.Substring(startIndex, preprocessorSymbol.Text.Length - startIndex).Trim();
if (text.Length > 0)
{
using (StringReader reader = new StringReader(text))
{
// Extract the symbols within this text.
CodeLexer lexer = new CodeLexer(parser, sourceCode, new CodeReader(reader));
List<Symbol> symbolList = lexer.GetSymbols(sourceCode, null);
SymbolManager directiveSymbols = new SymbolManager(symbolList);
CodeParser preprocessorBodyParser = new CodeParser(parser, directiveSymbols);
// Parse these symbols to create the body expression.
return preprocessorBodyParser.GetNextConditionalPreprocessorExpression(sourceCode);
}
}
// The directive has no body.
return null;
}
/// <summary>
/// Initializes a new instance of the CodeParser class.
/// </summary>
/// <param name="parser">
/// The C# parser.
/// </param>
/// <param name="lexer">
/// The lexer to use for parsing the code.
/// </param>
public CodeParser(CsParser parser, CodeLexer lexer)
{
Param.AssertNotNull(parser, "parser");
Param.AssertNotNull(lexer, "lexer");
this.parser = parser;
this.lexer = lexer;
}
public override bool ParseFile(SourceCode sourceCode, int passNumber, ref CodeDocument document)
{
Param.RequireNotNull(sourceCode, "sourceCode");
Param.RequireGreaterThanOrEqualToZero(passNumber, "passNumber");
Param.Ignore(document);
StyleCopTrace.In(sourceCode, passNumber, document);
// The document is parsed on the first pass. On any subsequent passes, we do not do anything.
if (passNumber == 0)
{
if (this.SkipAnalysisForDocument(sourceCode))
{
return false;
}
try
{
using (TextReader reader = sourceCode.Read())
{
// Create the document.
if (reader == null)
{
this.AddViolation(sourceCode, 1, Rules.FileMustBeReadable);
}
else
{
// Create the lexer object for the code string.
CodeLexer lexer = new CodeLexer(this, sourceCode, new CodeReader(reader));
// Parse the document.
CodeParser parser = new CodeParser(this, lexer);
parser.ParseDocument();
document = parser.Document;
}
}
}
catch (SyntaxException syntaxex)
{
this.AddViolation(syntaxex.SourceCode, syntaxex.LineNumber, Rules.SyntaxException, syntaxex.Message);
CsDocument csdocument = new CsDocument(sourceCode, this);
csdocument.FileHeader = new FileHeader(string.Empty, new CsTokenList(csdocument.Tokens), new Reference<ICodePart>(csdocument));
document = csdocument;
}
}
return StyleCopTrace.Out(false);
}
