public HlslLexer(SourceFile file, HlslParseOptions options = null, IIncludeFileSystem includeFileSystem = null)
{
_rootFile = file;
_includeFileResolver = new IncludeFileResolver(
includeFileSystem ?? new DummyFileSystem(),
options ?? new HlslParseOptions());
_directives = DirectiveStack.Empty;
if (options != null)
{
foreach (var define in options.PreprocessorDefines)
{
var lexer = new HlslLexer(new SourceFile(
SourceText.From($"#define {define.Key} {define.Value}"),
"__ConfiguredPreprocessorDefinitions__.hlsl"));
lexer._mode = LexerMode.Directive;
lexer.ExpandMacros = false;
var dp = new DirectiveParser(lexer, _directives);
var directive = dp.ParseDirective(true, true, false);
_directives = directive.ApplyDirectives(_directives);
}
}
ExpandMacros = true;
FileSegments = new List <FileSegment>();
_includeStack = new Stack <IncludeContext>();
PushIncludeContext(file);
}
public DirectiveParser(HlslLexer lexer, DirectiveStack directiveStack)
: base(lexer, LexerMode.Directive)
{
_lexer = lexer;
_directiveStack = directiveStack;
}
public BaseMacroExpansionLexer(HlslLexer lexer)
{
_lexer = lexer;
}
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();
}
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(macroReference, i == 0)
.WithSpan(macroReference.SourceRange, macroReference.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(macroReference, i == 0).WithSpan(macroReference.SourceRange, macroReference.FileSpan))
.ToList();
break;
default:
throw new ArgumentOutOfRangeException();
}
return(true);
}
