Ejemplo n.º 1
0
 public virtual void VisitFunctionLikeMacroReference(FunctionLikeMacroReference node)
 {
 }
Ejemplo n.º 2
0
 public virtual void VisitFunctionLikeMacroReference(FunctionLikeMacroReference node)
 {
 }
Ejemplo n.º 3
0
        private bool TryExpandMacro(SyntaxToken token, IMacroExpansionLexer lexer, out List <SyntaxToken> expandedTokens)
        {
            expandedTokens = 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);
            }

            MacroReference     macroReference;
            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();
            }

            // Push the current macro onto the stack - this prevents recursive expansion.
            _currentlyExpandingMacros.Push(directive);

            // 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 StringText(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(macroReference, i == 0)
                             .WithSpan(macroReference.SourceRange, macroReference.Span);
                if (i == 0)
                {
                    result = result.WithLeadingTrivia(token.LeadingTrivia);
                }
                if (i == localExpandedTokens.Count - 1)
                {
                    result = result.WithTrailingTrivia(lastToken.TrailingTrivia);
                }
                return(result);
            })
                             .ToList();

            _currentlyExpandingMacros.Pop();

            return(true);
        }
        private bool TryExpandMacro(SyntaxToken token, IMacroExpansionLexer lexer, out List<SyntaxToken> expandedTokens)
        {
            expandedTokens = 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;

            MacroReference macroReference;
            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.
                    var macroArguments = new MacroArgumentsParser(lexer).ParseArgumentList();
                    if (macroArguments.Arguments.Count != functionLikeDefine.Parameters.Parameters.Count)
                    {
                        expandedTokens = new List<SyntaxToken>
                        {
                            token
                                .WithDiagnostic(Diagnostic.Format(token.Span, 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(expandedArguments, functionLikeDefineDirective);

                    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();
            }

            // Push the current macro onto the stack - this prevents recursive expansion.
            _currentlyExpandingMacros.Push(directive);

            // Scan macro body for nested macros.
            expandedTokens = ExpandNestedMacro(new NestedMacroExpansionLexer(macroBody));

            var localExpandedTokens = expandedTokens;
            expandedTokens = expandedTokens
                .Select((x, i) =>
                {
                    var result = x
                        .WithOriginalMacroReference(macroReference, i == 0)
                        .WithSpan(macroReference.SourceRange, macroReference.Span);
                    if (i == 0)
                        result = result.WithLeadingTrivia(token.LeadingTrivia);
                    if (i == localExpandedTokens.Count - 1)
                        result = result.WithTrailingTrivia(lastToken.TrailingTrivia);
                    return result;
                })
                .ToList();

            _currentlyExpandingMacros.Pop();

            return true;
        }