private bool TryExpandMacro( SyntaxToken token, IMacroExpansionLexer lexer, out List <SyntaxToken> expandedTokens, out MacroReference macroReference) { expandedTokens = null; macroReference = null; // First, check if this token might be a macro. DefineDirectiveTriviaSyntax directive; if (_directives.IsDefined(token.Text, out directive) != DefineState.Defined) { return(false); } // Check that this macro is not disabled. if (_currentlyExpandingMacros.Contains(directive)) { return(false); } List <SyntaxToken> macroBody; SyntaxToken lastToken; switch (directive.Kind) { case SyntaxKind.FunctionLikeDefineDirectiveTrivia: // For function-like macros, check for, and expand, macro arguments. var functionLikeDefine = (FunctionLikeDefineDirectiveTriviaSyntax)directive; // ... check to see if the next token is an open paren. if (lexer.Peek(_mode).Kind != SyntaxKind.OpenParenToken) { return(false); } // If it is, then parse the macro arguments, and // check that we have the correct number of arguments. ExpandMacros = false; var macroArguments = new MacroArgumentsParser(lexer).ParseArgumentList(); ExpandMacros = true; if (macroArguments.Arguments.Count != functionLikeDefine.Parameters.Parameters.Count) { expandedTokens = new List <SyntaxToken> { token .WithDiagnostic(Diagnostic.Create(HlslMessageProvider.Instance, token.SourceRange, (int)DiagnosticId.NotEnoughMacroParameters, token.Text)) .WithTrailingTrivia(new[] { macroArguments }) }; return(true); } var functionLikeDefineDirective = (FunctionLikeDefineDirectiveTriviaSyntax)directive; macroReference = new FunctionLikeMacroReference(token, macroArguments, functionLikeDefineDirective); // Expand arguments. var expandedArguments = macroArguments.Arguments .Select(x => ExpandNestedMacro(new NestedMacroExpansionLexer(x.Tokens)).ToList()) .ToList(); // Replace parameters with possibly-expanded arguments. macroBody = ReplaceParameters( macroArguments.Arguments.ToList(), expandedArguments, functionLikeDefineDirective.Parameters, functionLikeDefineDirective.Body); lastToken = macroArguments.DescendantTokens().LastOrDefault(x => !x.IsMissing) ?? token; break; case SyntaxKind.ObjectLikeDefineDirectiveTrivia: macroReference = new ObjectLikeMacroReference(token, (ObjectLikeDefineDirectiveTriviaSyntax)directive); macroBody = directive.MacroBody; lastToken = token; break; default: throw new ArgumentOutOfRangeException(); } var localMacroReference = macroReference; switch (_mode) { case LexerMode.Syntax: // Push the current macro onto the stack - this prevents recursive expansion. _currentlyExpandingMacros.Push(directive); if (_mode == LexerMode.Syntax) { // Scan macro body for nested macros. expandedTokens = ExpandNestedMacro(new NestedMacroExpansionLexer(macroBody)); // Relex identifier tokens, because at this point keywords are stored as identifiers. for (var i = 0; i < expandedTokens.Count; i++) { if (expandedTokens[i].Kind == SyntaxKind.IdentifierToken) { var relexedToken = new HlslLexer(new SourceFile(SourceText.From(expandedTokens[i].Text))).Lex(LexerMode.Syntax); expandedTokens[i] = expandedTokens[i].WithKind(relexedToken.Kind).WithContextualKind(relexedToken.ContextualKind); } } var localExpandedTokens = expandedTokens; expandedTokens = expandedTokens .Select((x, i) => { var result = x .WithOriginalMacroReference(localMacroReference, i == 0) .WithSpan(localMacroReference.SourceRange, localMacroReference.FileSpan); if (i == 0) { result = result.WithLeadingTrivia(token.LeadingTrivia); } if (i == localExpandedTokens.Count - 1) { result = result.WithTrailingTrivia(lastToken.TrailingTrivia); } return(result); }) .ToList(); } _currentlyExpandingMacros.Pop(); break; case LexerMode.Directive: // If we're in the middle of parsing a directive, don't expand macro references. expandedTokens = macroBody .Select((x, i) => x.WithOriginalMacroReference(localMacroReference, i == 0).WithSpan(localMacroReference.SourceRange, localMacroReference.FileSpan)) .ToList(); break; default: throw new ArgumentOutOfRangeException(); } return(true); }
public static QuickInfoModel ForMacroReference(SemanticModel semanticModel, TextSpan span, MacroReference macroReference) { var glyph = Glyph.Macro; var symbolMarkup = new SymbolMarkup(new[] { new SymbolMarkupToken(SymbolMarkupKind.PlainText, $"(macro reference) {macroReference.DefineDirective.ToString(true)}") }); return(new QuickInfoModel(semanticModel, span, glyph, symbolMarkup, string.Empty)); }
public static QuickInfoModel ForMacroReference(SemanticModel semanticModel, TextSpan span, MacroReference macroReference) { var glyph = Glyph.Macro; var symbolMarkup = new SymbolMarkup(new[] { new SymbolMarkupToken(SymbolMarkupKind.PlainText, $"(macro reference) {macroReference.DefineDirective.ToString(true)}") }); return new QuickInfoModel(semanticModel, span, glyph, symbolMarkup, string.Empty); }