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 static IReadOnlyList<SyntaxToken> ParseAllTokens(SourceText sourceText, IIncludeFileSystem fileSystem = null)
{
var tokens = new List<SyntaxToken>();
var lexer = new HlslLexer(sourceText, fileSystem: fileSystem);
SyntaxToken token;
do
{
tokens.Add(token = lexer.Lex(LexerMode.Syntax));
} while (token.Kind != SyntaxKind.EndOfFileToken);
return tokens;
}
private static SyntaxTree Parse(SourceText sourceText, ParserOptions options, IIncludeFileSystem fileSystem, Func<HlslParser, SyntaxNode> parseFunc)
{
var lexer = new HlslLexer(sourceText, options, fileSystem);
var parser = new HlslParser(lexer);
var result = new SyntaxTree(sourceText,
syntaxTree => new Tuple<SyntaxNode, List<FileSegment>>(
parseFunc(parser),
lexer.FileSegments));
Debug.WriteLine(DateTime.Now + " - Finished parsing");
return result;
}
public static IReadOnlyList <SyntaxToken> ParseAllTokens(SourceFile file, IIncludeFileSystem fileSystem = null)
{
var tokens = new List <SyntaxToken>();
var lexer = new HlslLexer(file, includeFileSystem: fileSystem);
SyntaxToken token;
do
{
tokens.Add(token = lexer.Lex(LexerMode.Syntax));
} while (token.Kind != SyntaxKind.EndOfFileToken);
return(tokens);
}
public HlslLexer(SourceText text, ParserOptions options = null, IIncludeFileSystem fileSystem = null)
{
_fileSystem = fileSystem ?? new DummyFileSystem();
_directives = DirectiveStack.Empty;
if (options != null)
foreach (var define in options.PreprocessorDefines)
{
_directives = _directives.Add(new Directive(new ObjectLikeDefineDirectiveTriviaSyntax(
null, null, SyntaxFactory.ParseToken(define), new List<SyntaxToken>
{
SyntaxFactory.ParseToken("1")
}, null, true)));
}
ExpandMacros = true;
FileSegments = new List<FileSegment>();
_includeStack = new Stack<IncludeContext>();
PushIncludeContext(text);
}
public HlslLexer(SourceText text, ParserOptions options = null, IIncludeFileSystem fileSystem = null)
{
_fileSystem = fileSystem ?? new DummyFileSystem();
_directives = DirectiveStack.Empty;
if (options != null)
{
foreach (var define in options.PreprocessorDefines)
{
_directives = _directives.Add(new Directive(new ObjectLikeDefineDirectiveTriviaSyntax(
null, null, SyntaxFactory.ParseToken(define), new List <SyntaxToken>
{
SyntaxFactory.ParseToken("1")
}, null, true)));
}
}
ExpandMacros = true;
FileSegments = new List <FileSegment>();
_includeStack = new Stack <IncludeContext>();
PushIncludeContext(text);
}
public static CompilationUnitSyntax ParseCompilationUnit(string text, IIncludeFileSystem fileSystem = null)
{
return (CompilationUnitSyntax) Parse(SourceText.From(text), null, fileSystem, p => p.ParseCompilationUnit(CancellationToken.None)).Root;
}
internal static SyntaxTree ParseSyntaxTree(SourceText sourceText, HlslParseOptions options = null, IIncludeFileSystem fileSystem = null, CancellationToken cancellationToken = default)
{
return(ParseSyntaxTree(new SourceFile(sourceText), options, fileSystem, cancellationToken));
}
private static IReadOnlyList <SyntaxToken> LexAllTokens(SourceText text, IIncludeFileSystem fileSystem = null)
{
return(SyntaxFactory.ParseAllTokens(text, fileSystem));
}
private static CompilationUnitSyntax Parse(string text, IIncludeFileSystem fileSystem = null)
{
return SyntaxFactory.ParseCompilationUnit(text, fileSystem);
}
public HlslSyntaxTreeFactoryService(Workspace workspace, IIncludeFileSystem fileSystem)
{
_workspace = workspace;
_fileSystem = fileSystem;
}
private static SyntaxTree Parse(SourceFile sourceFile, HlslParseOptions options, IIncludeFileSystem fileSystem, Func <HlslParser, SyntaxNode> parseFunc)
{
var lexer = new HlslLexer(sourceFile, options, fileSystem);
var parser = new HlslParser(lexer);
var result = new SyntaxTree(
sourceFile,
options,
syntaxTree =>
{
var node = parseFunc(parser);
node.SetSyntaxTree(syntaxTree);
return(new Tuple <SyntaxNode, List <FileSegment> >(
node,
lexer.FileSegments));
});
Debug.WriteLine(DateTime.Now + " - Finished parsing");
return(result);
}
public static SyntaxTree ParseSyntaxTree(SourceFile file, HlslParseOptions options = null, IIncludeFileSystem fileSystem = null, CancellationToken cancellationToken = default)
{
return(Parse(file, options, fileSystem ?? new DummyFileSystem(), p => p.ParseCompilationUnit(cancellationToken)));
}
public IncludeFileResolver(IIncludeFileSystem fileSystem)
{
_fileSystem = fileSystem;
}
private static IReadOnlyList<SyntaxToken> LexAllTokens(SourceText text, IIncludeFileSystem fileSystem = null)
{
return SyntaxFactory.ParseAllTokens(text, fileSystem);
}
private static CompilationUnitSyntax Parse(string text, IIncludeFileSystem fileSystem = null)
{
return(SyntaxFactory.ParseCompilationUnit(text, fileSystem));
}
public static SyntaxTree ParseSyntaxTree(SourceText sourceText, ParserOptions options = null, IIncludeFileSystem fileSystem = null, CancellationToken cancellationToken = default(CancellationToken))
{
return Parse(sourceText, options, fileSystem ?? new DummyFileSystem(), p => p.ParseCompilationUnit(cancellationToken));
}
public IncludeFileResolver(IIncludeFileSystem fileSystem, HlslParseOptions parserOptions)
{
_fileSystem = fileSystem;
_parserOptions = parserOptions;
}
public static CompilationUnitSyntax ParseCompilationUnit(string text, IIncludeFileSystem fileSystem = null)
{
return((CompilationUnitSyntax)Parse(SourceText.From(text), null, fileSystem, p => p.ParseCompilationUnit(CancellationToken.None)).Root);
}
public static CompilationUnitSyntax ParseCompilationUnit(SourceFile file, IIncludeFileSystem fileSystem = null)
{
return((CompilationUnitSyntax)Parse(file, null, fileSystem, p => p.ParseCompilationUnit(CancellationToken.None)).Root);
}
