### Project Setup with Antlr4BuildTasks

Source: https://context7.com/kaby76/antlr4buildtasks/llms.txt

Integrates Antlr4BuildTasks and Antlr4.Runtime.Standard into a C# project via NuGet. It configures .g4 grammar files for automatic processing during the build, ensuring parser and lexer code generation.

```xml
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <!-- Reference the runtime library -->
    <PackageReference Include="Antlr4.Runtime.Standard" Version="4.13.1" />

    <!-- Reference the build tasks package -->
    <!-- PrivateAssets ensures the DLL is not included in publish output -->
    <PackageReference Include="Antlr4BuildTasks" Version="12.10"
                      PrivateAssets="all"
                      IncludeAssets="build" />
  </ItemGroup>

  <ItemGroup>
    <!-- Mark .g4 files for ANTLR processing -->
    <Antlr4 Include="MyGrammar.g4" />

    <!-- Or use wildcards to include all grammar files -->
    <Antlr4 Include="**/*.g4" />
  </ItemGroup>
</Project>
```

--------------------------------

### Build ANTLR .NET Projects from Command Line (Bash)

Source: https://context7.com/kaby76/antlr4buildtasks/llms.txt

Provides common command-line interface (CLI) commands for building .NET projects that utilize ANTLR grammars. These commands cover basic build, cleaning, release builds, verbose output, and targeting specific projects or frameworks.

```bash
# Basic build (Windows/Linux/macOS)
dotnet build

# Clean and rebuild
dotnet clean
dotnet build

# Build in Release configuration
dotnet build -c Release

# Build with verbose output to see ANTLR tool execution
dotnet build -v detailed

# Build specific project
dotnet build MyProject.csproj

# Restore packages and build
dotnet restore
dotnet build --no-restore

# Build and run
dotnet run

# Publish application (ANTLR-generated files included automatically)
dotnet publish -c Release -o ./publish

# Build with specific target framework (multi-targeting projects)
dotnet build -f net6.0
```

--------------------------------

### Add Antlr4BuildTasks and Antlr4.Runtime.Standard to Project

Source: https://github.com/kaby76/antlr4buildtasks/blob/master/Readme.md

This XML snippet demonstrates how to add the Antlr4BuildTasks and Antlr4.Runtime.Standard NuGet packages to a C# project file (.csproj). This integration enables the build system to automatically process Antlr4 grammars. 'PrivateAssets=all' and 'IncludeAssets=build' ensure the build tasks are available during compilation but not published with the application.

```xml
<ItemGroup>
    <PackageReference Include="Antlr4.Runtime.Standard" Version="4.13.1" />
    <PackageReference Include="Antlr4BuildTasks" Version="12.10" PrivateAssets="all" IncludeAssets="build" />
</ItemGroup>
```

--------------------------------

### Custom Java Executable Configuration for ANTLR

Source: https://context7.com/kaby76/antlr4buildtasks/llms.txt

Specifies how the ANTLR tool should locate or download a Java executable. Supports using the system's PATH, auto-downloading a JRE, or specifying a direct path to a java executable. Includes options for custom download directories and fallback configurations.

```xml
<ItemGroup>
  <!-- Use Java from system PATH (searches PATH environment variable) -->
  <Antlr4 Include="Grammar1.g4">
    <JavaExec>PATH</JavaExec>
  </Antlr4>

  <!-- Auto-download JRE if not found -->
  <Antlr4 Include="Grammar2.g4">
    <JavaExec>DOWNLOAD</JavaExec>
    <JavaDownloadDirectory>USERPROFILE/.jre/</JavaDownloadDirectory>
  </Antlr4>

  <!-- Use specific Java executable path -->
  <Antlr4 Include="Grammar3.g4">
    <JavaExec>C:/Program Files/Java/jdk-11/bin/java.exe</JavaExec>
  </Antlr4>

  <!-- Multiple fallback options (semicolon-separated, tried in order) -->
  <Antlr4 Include="Grammar4.g4">
    <JavaExec>PATH;C:/Java/bin/java.exe;DOWNLOAD</JavaExec>
  </Antlr4>

  <!-- Custom download location for JRE -->
  <Antlr4 Include="Grammar5.g4">
    <JavaExec>DOWNLOAD</JavaExec>
    <JavaDownloadDirectory>C:/BuildTools/Java/</JavaDownloadDirectory>
  </Antlr4>
</ItemGroup>
```

--------------------------------

### Upgrade PackageReference from Antlr4.CodeGenerator to Antlr4BuildTasks

Source: https://github.com/kaby76/antlr4buildtasks/blob/master/Readme.md

Replace legacy Antlr4.CodeGenerator NuGet package with Antlr4BuildTasks and update Antlr4.Runtime to Antlr4.Runtime.Standard. This migration path modernizes the build system and runtime dependencies for ANTLR4 C# projects.

```xml
<ItemGroup>
    <PackageReference Include="Antlr4.CodeGenerator" Version="4.6.6">
        <PrivateAssets>all</PrivateAssets>
        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
    <PackageReference Include="Antlr4.Runtime" Version="4.6.6" />
</ItemGroup>
```

```xml
<ItemGroup>
    <PackageReference Include="Antlr4BuildTasks" Version="12.10" PrivateAssets="all" />
    <PackageReference Include="Antlr4.Runtime.Standard" Version="4.13.1" />
</ItemGroup>
```

--------------------------------

### ANTLR Grammar File Configuration Options

Source: https://context7.com/kaby76/antlr4buildtasks/llms.txt

Configures ANTLR grammar files with various options such as custom namespaces, listener/visitor generation, debugging output, and error handling. Supports specifying library paths and file encoding for the ANTLR tool.

```xml
<ItemGroup>
  <!-- Basic grammar file with default settings -->
  <Antlr4 Include="SimpleGrammar.g4" />

  <!-- Grammar with custom package/namespace -->
  <Antlr4 Include="Arithmetic.g4">
    <Package>MyApp.Parsers</Package>
  </Antlr4>

  <!-- Grammar with advanced options -->
  <Antlr4 Include="ComplexGrammar.g4">
    <!-- C# namespace for generated classes -->
    <Package>MyCompany.Parsers</Package>

    <!-- Generate listener classes (default: true) -->
    <Listener>true</Listener>

    <!-- Generate visitor classes (default: true) -->
    <Visitor>true</Visitor>

    <!-- Generate ATN dot diagrams for debugging -->
    <GAtn>true</GAtn>

    <!-- Treat warnings as errors -->
    <Error>true</Error>

    <!-- Specify library path for imported grammars/tokens -->
    <LibPath>\.\grammars;\.\common</LibPath>

    <!-- Specify file encoding -->
    <Encoding>UTF-8</Encoding>

    <!-- Pass -D options to ANTLR tool (semicolon-separated) -->
    <DOptions>language=CSharp;tokenVocab=CommonLexer</DOptions>
  </Antlr4>
</ItemGroup>
```

--------------------------------

### Configure ANTLR Tool JAR Custom Location

Source: https://context7.com/kaby76/antlr4buildtasks/llms.txt

Sets custom directories for downloading the ANTLR tool JAR and specifies exact JAR file paths or probe paths for discovery. USERPROFILE is a special variable that expands to the user's home directory.

```xml
<PropertyGroup>
  <!-- Default download directory for ANTLR tool JAR -->
  <!-- USERPROFILE expands to user's home directory -->
  <AntlrToolJarDownloadDir>USERPROFILE/.m2/</AntlrToolJarDownloadDir>

  <!-- Custom download directory -->
  <AntlrToolJarDownloadDir>C:/BuildTools/Antlr/</AntlrToolJarDownloadDir>
</PropertyGroup>

<ItemGroup>
  <Antlr4 Include="MyGrammar.g4">
    <!-- Specify exact JAR file path -->
    <AntlrToolJar>C:/Tools/antlr-4.13.1-complete.jar</AntlrToolJar>
  </Antlr4>

  <!-- Configure custom probe paths for JAR discovery -->
  <AntlrProbePath Include="file:///C:/Tools/Antlr/" />
  <AntlrProbePath Include="https://repo1.maven.org/maven2/org/antlr/antlr4/" />
  <AntlrProbePath Include="file:///USERPROFILE/.m2/" />
</ItemGroup>

<ItemGroup>
  <Antlr4 Include="Grammar.g4">
    <!-- Override default probe path -->
    <AntlrToolJarDownloadDir>D:/CustomPath/</AntlrToolJarDownloadDir>
  </Antlr4>
</ItemGroup>
```

--------------------------------

### Configure RunAntlrTool MSBuild Task with Properties (MSBuild)

Source: https://context7.com/kaby76/antlr4buildtasks/llms.txt

Demonstrates the direct usage of the RunAntlrTool MSBuild task, showcasing various properties available for customizing ANTLR code generation. This allows for advanced build configurations beyond the default settings.

```xml
<UsingTask TaskName="Antlr4.Build.Tasks.RunAntlrTool"
           AssemblyFile="$(Antlr4BuildTaskPath)\Antlr4BuildTasks.dll" />

<Target Name="CustomAntlrBuild">
  <RunAntlrTool
    AllowAntlr4cs="false"
    AntlrToolJar="C:/Tools/antlr4-4.13.1-complete.jar"
    AntlrToolJarDownloadDir="$(UserProfile)/.m2/"
    AntOutDir="$(IntermediateOutputPath)"
    DOptions="language=CSharp"
    Encoding="UTF-8"
    Error="false"
    ForceAtn="false"
    GAtn="false"
    IntermediateOutputPath="$(IntermediateOutputPath)"
    JavaDownloadDirectory="$(UserProfile)/.jre/"
    JavaExec="PATH;DOWNLOAD"
    LibPath=""
    Listener="true"
    Log_="false"
    LongMessages="false"
    Package="MyNamespace.Parsers"
    PackageReference="@(PackageReference)"
    PackageVersion="@(PackageVersion)"
    SourceCodeFiles="@(Antlr4 -> '%(FullPath)')"
    TargetFrameworkVersion="$(TargetFrameworkVersion)"
    TargetFrameworks="@(TargetFrameworks)"
    TokensFiles="@(Antlr4Tokens)"
    Visitor="true"
    VersionOfJava="11">

    <Output ItemName="GeneratedCodeFiles" TaskParameter="GeneratedCodeFiles" />
    <Output ItemName="GeneratedFiles" TaskParameter="GeneratedFiles" />
    <Output ItemName="GeneratedDirectories" TaskParameter="GeneratedDirectories" />
  </RunAntlrTool>

  <!-- Add generated files to compilation -->
  <ItemGroup>
    <Compile Include="@(GeneratedCodeFiles)" />
  </ItemGroup>
</Target>
```

--------------------------------

### Configure Antlr4 ItemGroup with Grammar Parameters in MSBuild

Source: https://github.com/kaby76/antlr4buildtasks/blob/master/Readme.md

Define ANTLR grammar file processing parameters within the .csproj file using ItemGroup element. Supports configuration of listener/visitor generation, ATN diagrams, namespace packaging, and error handling. Parameters are passed directly to the ANTLR tool during build process.

```xml
<ItemGroup>
    <Antlr4 Include="MyGrammar.g4">
        <Listener>false</Listener>
        <Visitor>false</Visitor>
        <GAtn>true</GAtn>
        <Package>foo</Package>
        <Error>true</Error>
    </Antlr4>
</ItemGroup>
```

--------------------------------

### Control ANTLR Listener and Visitor Pattern Generation

Source: https://context7.com/kaby76/antlr4buildtasks/llms.txt

Manages the generation of listener and visitor classes for ANTLR parse trees. This allows fine-grained control over the output for different traversal strategies, including generating both, only one, or neither.

```xml
<ItemGroup>
  <!-- Generate both listener and visitor (default behavior) -->
  <Antlr4 Include="FullFeatures.g4">
    <Listener>true</Listener>
    <Visitor>true</Visitor>
  </Antlr4>

  <!-- Generate only listener, no visitor -->
  <Antlr4 Include="ListenerOnly.g4">
    <Listener>true</Listener>
    <Visitor>false</Visitor>
  </Antlr4>

  <!-- Generate only visitor, no listener -->
  <Antlr4 Include="VisitorOnly.g4">
    <Listener>false</Listener>
    <Visitor>true</Visitor>
  </Antlr4>

  <!-- Generate neither listener nor visitor (minimal output) -->
  <Antlr4 Include="MinimalGrammar.g4">
    <Listener>false</Listener>
    <Visitor>false</Visitor>
  </Antlr4>
</ItemGroup>
```

--------------------------------

### Update Project File for Antlr4BuildTasks (MSBuild)

Source: https://context7.com/kaby76/antlr4buildtasks/llms.txt

Compares the old Antlr4.CodeGenerator MSBuild item group with the new Antlr4BuildTasks configuration. It highlights the change from Antlr4.Runtime to Antlr4.Runtime.Standard and the addition of the Antlr4BuildTasks NuGet package.

```xml
<ItemGroup>
  <!-- OLD: Antlr4.CodeGenerator/Antlr4.Runtime (deprecated) -->
  <PackageReference Include="Antlr4.CodeGenerator" Version="4.6.6">
    <PrivateAssets>all</PrivateAssets>
    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
  </PackageReference>
  <PackageReference Include="Antlr4.Runtime" Version="4.6.6" />
</ItemGroup>

<ItemGroup>
  <Antlr4 Update="arithmetic.g4">
    <Listener>true</Listener>
    <Visitor>false</Visitor>
  </Antlr4>
</ItemGroup>

<!-- NEW: Antlr4BuildTasks/Antlr4.Runtime.Standard (recommended) -->
<ItemGroup>
  <PackageReference Include="Antlr4.Runtime.Standard" Version="4.13.1" />
  <PackageReference Include="Antlr4BuildTasks" Version="12.10" PrivateAssets="all" />
</ItemGroup>

<ItemGroup>
  <!-- Change Update to Include -->
  <Antlr4 Include="arithmetic.g4">
    <Listener>true</Listener>
    <Visitor>false</Visitor>
  </Antlr4>
</ItemGroup>
```

--------------------------------

### Configure Antlr4 Grammar Files for Build

Source: https://github.com/kaby76/antlr4buildtasks/blob/master/Readme.md

This XML snippet shows how to specify Antlr4 grammar files (.g4) for processing by the Antlr4BuildTasks. You can either change the 'Build Action' property of the .g4 file in Visual Studio to 'ANTLR 4 grammar', or you can declare them in the .csproj file using the `<Antlr4 Include='*.g4'/>` element. This allows the build system to identify and compile these grammar files.

```xml
<ItemGroup>
    <Antlr4 Include="MyGrammar.g4" />
</ItemGroup>
```

--------------------------------

### Configure ANTLR Multi-Target Grammar with Shared Tokens

Source: https://context7.com/kaby76/antlr4buildtasks/llms.txt

Enables the configuration of lexer and parser grammars that share token definitions using the LibPath property. This is useful for modularizing grammar definitions and ensuring consistent token recognition across different parts of the grammar.

```xml
<ItemGroup>
  <!-- Lexer grammar that defines tokens -->
  <Antlr4 Include="MyLexer.g4">
    <Package>MyApp.Grammar</Package>
    <Listener>false</Listener>
    <Visitor>false</Visitor>
  </Antlr4>

  <!-- Parser grammar that imports lexer tokens -->
  <Antlr4 Include="MyParser.g4">
    <Package>MyApp.Grammar</Package>
    <!-- Point to directory containing MyLexer.tokens -->
    <LibPath>$(IntermediateOutputPath)</LibPath>
    <Listener>true</Listener>
    <Visitor>true</Visitor>
    <!-- Specify token vocabulary in grammar itself or via DOptions -->
    <DOptions>language=CSharp;tokenVocab=MyLexer</DOptions>
  </Antlr4>

  <!-- Multiple library paths (semicolon-separated) -->
  <Antlr4 Include="ComplexParser.g4">
    <LibPath>.\common;.\generated;$(IntermediateOutputPath)</LibPath>
  </Antlr4>
</ItemGroup>
```

--------------------------------

### C# Type Aliases for 32-bit and 64-bit Architectures

Source: https://github.com/kaby76/antlr4buildtasks/blob/master/Antlr4BuildTasks/SharpCompress/Compressors/Rar/UnpackV2017/notes.txt

Conditional compilation directives in C# define aliases for integer types based on whether the target architecture is 32-bit or 64-bit. This allows for consistent handling of native integer types across different platforms, mapping to `System.Int32` or `System.Int64` as appropriate.

```csharp
#if !Rar2017_64bit
using nint = System.Int32;
using nuint = System.UInt32;
using size_t = System.UInt32;
#else
using nint = System.Int64;
using nuint = System.UInt64;
using size_t = System.UInt64;
#endif
using int64 = System.Int64;

```

--------------------------------

### Configure ANTLR Error Handling and Logging

Source: https://context7.com/kaby76/antlr4buildtasks/llms.txt

Sets up error handling and logging options for the ANTLR tool. This includes treating warnings as errors, enabling verbose logging, and configuring long error messages for improved diagnostics during the build process.

```xml
<ItemGroup>
  <!-- Treat ANTLR warnings as errors (stops build on warnings) -->
  <Antlr4 Include="StrictGrammar.g4">
    <Error>true</Error>
  </Antlr4>

  <!-- Enable verbose ANTLR tool logging -->
  <Antlr4 Include="DebugGrammar.g4">
    <Log>true</Log>
  </Antlr4>

  <!-- Enable long error messages for better diagnostics -->
  <Antlr4 Include="DetailedErrors.g4">
    <LongMessages>true</LongMessages>
  </Antlr4>

  <!-- Combination of strict error handling with detailed logging -->
  <Antlr4 Include="ProductionGrammar.g4">
    <Error>true</Error>
    <LongMessages>true</LongMessages>
    <Log>false</Log>
  </Antlr4>
</ItemGroup>
```

--------------------------------

### Migrate from Antlr4.CodeGenerator to Antlr4BuildTasks ItemGroup

Source: https://github.com/kaby76/antlr4buildtasks/blob/master/Readme.md

Update Antlr4 ItemGroup configuration from Update attribute to Include attribute pattern when migrating to Antlr4BuildTasks. This represents the structural change in how grammar files are referenced in modern build task versions.

```xml
<ItemGroup>
    <Antlr4 Update="arithmetic.g4">
        etc etc etc
    </Antlr4>
</ItemGroup>
```

```xml
<ItemGroup>
    <Antlr4 Include="arithmetic.g4" />
</ItemGroup>
```

--------------------------------

### Enabling Very Large Objects in .NET Runtime

Source: https://github.com/kaby76/antlr4buildtasks/blob/master/Antlr4BuildTasks/SharpCompress/Compressors/Rar/UnpackV2017/notes.txt

By default, .NET arrays are limited to a maximum size that can be indexed by `System.Int32.MaxValue`. To support arrays larger than 2GB on x64 systems, the .NET runtime must be configured to allow very large objects. This is achieved by enabling the `gcAllowVeryLargeObjects` element in the application's configuration file.

```xml
<configuration>
  <runtime>
    <gcAllowVeryLargeObjects enabled="true"/>
  </runtime>
</configuration>

```

--------------------------------

### Configure ANTLR Custom Output Directory

Source: https://context7.com/kaby76/antlr4buildtasks/llms.txt

Specifies custom output directories for ANTLR-generated files, separate from the default intermediate output path. This enables organization of generated code, such as lexers and parsers, into distinct subdirectories.

```xml
<ItemGroup>
  <!-- Default: generated files go to $(IntermediateOutputPath) -->
  <Antlr4 Include="DefaultOutput.g4" />

  <!-- Custom output directory -->
  <Antlr4 Include="CustomOutput.g4">
    <AntOutDir>$(ProjectDir)Generated\Parsers\</AntOutDir>
  </Antlr4>

  <!-- Organize by grammar type -->
  <Antlr4 Include="Lexers\*.g4">
    <AntOutDir>$(ProjectDir)Generated\Lexers\</AntOutDir>
  </Antlr4>

  <Antlr4 Include="Parsers\*.g4">
    <AntOutDir>$(ProjectDir)Generated\Parsers\</AntOutDir>
  </Antlr4>
</ItemGroup>
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.