Tesearis.GlslParser 1.0.0

Tesearis.GlslParser

Standalone GLSL/GLSL ES lexer, preprocessor and syntax tree for shader source.

Tesearis.GlslParser parses GLSL source — either a whole standalone file or a region embedded inside a document (e.g. a ShaderLab GLSLPROGRAM/GLSLINCLUDE block) — into an immutable, strongly-typed AST for static analysis and diagnostics tooling. It's a genuinely independent implementation with no runtime dependencies at all, so it stays consumable entirely on its own.

Features

• Zero dependencies: no runtime dependencies at all.
• Standalone and embeddable: parses a whole .glsl/.vert/.frag file directly, or a substring embedded inside a document.
• Full core grammar: structs, interface blocks (uniform/buffer/in/out blocks), layout qualifiers, precision statements, functions, and full statement/expression parsing inside function bodies.
• Real preprocessor: genuine #define/#undef macro expansion, #if/#ifdef/#ifndef/#elif/#else/#endif conditional evaluation, and GLSL's #version/#extension directives (recognized structurally, not interpreted — see below).
• Best-effort recovery: never throws on malformed source; it returns a (possibly partial) tree plus a full diagnostics list.
• Targeted: netstandard2.0 (for use in older/.NET-Framework-era tooling) and net8.0.

What this library does not do

• It never reads files from disk.
• It never resolves #include targets.
• It doesn't evaluate #version/#extension/predefined macros like GL_ES — what those actually enable is environment-provided information (the GLSL compiler's own behavior), which is out of scope for this library. They're surfaced structurally on the AST (CompilationUnitNode.Version/.Extensions) for a caller to interpret.
• No C-style cast syntax exists in core GLSL, so this parser has no CastExpressionNode at all — type conversion is parsed as ordinary constructor-call syntax (float(x), vec3(x)), which InvocationExpressionNode already covers.

Usage

Parsing a standalone file

using Tesearis.GlslParser.Parsing;
using Tesearis.GlslParser.Syntax;

GlslParseResult result = Glsl.Parse(sourceText, "shader.glsl");

if (result.HasErrors)
{
    foreach (var diagnostic in result.Diagnostics)
    {
        Console.WriteLine(diagnostic);
    }
}

var compilationUnit = (CompilationUnitNode)result.Root;
foreach (var declaration in compilationUnit.Declarations)
{
    Console.WriteLine(declaration.Kind);
}

Glsl.Parse never throws on malformed input — it always returns a (possibly partial) tree in result.Root alongside result.Diagnostics.

Parsing an embedded region

Use Glsl.ParseEmbedded when the GLSL source is a substring of a larger document (e.g. a ShaderLab GLSLPROGRAM block). Spans and diagnostics are reported in terms of the outer document, using the offset/line where the embedded block starts:

GlslParseResult result = Glsl.ParseEmbedded(
    body: glslBlockText,
    baseOffset: glslBlockStartOffset,
    fileName: "MyShader.shader",
    baseLine: glslBlockStartLine);

Walking the syntax tree

using System.Linq;

var functions = result.Root.DescendantsAndSelf().OfType<FunctionDeclarationNode>();

For more structured traversal, subclass GlslVisitor and override the node kinds you care about:

class FunctionCollector : GlslVisitor
{
    public List<FunctionDeclarationNode> Functions { get; } = new();

    public override void VisitFunctionDeclaration(FunctionDeclarationNode node)
    {
        Functions.Add(node);
        base.DefaultVisit(node);
    }
}

var collector = new FunctionCollector();
collector.Visit(result.Root);

To inspect the whole tree at a glance, GlslTreeDumper.Dump renders it as indented text:

string dump = GlslTreeDumper.Dump(result.Root, result.Source);

Diagnostics

using Tesearis.GlslParser.Diagnostics;

foreach (Diagnostic diagnostic in result.Diagnostics)
{
    Console.WriteLine(diagnostic); // "shader.glsl(3,10): error GL0203: ..."
}

Building & testing

dotnet build Tesearis.GlslParser.slnx
dotnet test Tesearis.GlslParser.slnx

License

MIT — see LICENSE.