diff --git a/.vs/Supercharger/Tiger/codemap.dat b/.vs/Supercharger/Tiger/codemap.dat
new file mode 100644
index 0000000..8a2c280
--- /dev/null
+++ b/.vs/Supercharger/Tiger/codemap.dat
@@ -0,0 +1 @@
+<ProjectData xmlns="http://schemas.datacontract.org/2004/07/BG8.Supercharger.Features.CodeMap" xmlns:i="http://www.w3.org/2001/XMLSchema-instance"><ProjectAllTimeMostUsedData xmlns:a="http://schemas.microsoft.com/2003/10/Serialization/Arrays"><a:KeyValueOfstringProjectItemDataOfAllTimeMostUsedDataItemIPg14zztYaWdJY9w><a:Key>Program.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>Program.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfAllTimeMostUsedDataItemIPg14zztYaWdJY9w></ProjectAllTimeMostUsedData><ProjectExpandedStateData xmlns:a="http://schemas.microsoft.com/2003/10/Serialization/Arrays"><a:KeyValueOfstringProjectItemDataOfExpandedStateDataItemIPg14zztYaWdJY9w><a:Key>Program.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>Program.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfExpandedStateDataItemIPg14zztYaWdJY9w></ProjectExpandedStateData><ProjectFavoriteData xmlns:a="http://schemas.microsoft.com/2003/10/Serialization/Arrays"><a:KeyValueOfstringProjectItemDataOfFavoriteDataItemIPg14zztYaWdJY9w><a:Key>Program.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>Program.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfFavoriteDataItemIPg14zztYaWdJY9w></ProjectFavoriteData><ProjectHistoryData xmlns:a="http://schemas.microsoft.com/2003/10/Serialization/Arrays"><a:KeyValueOfstringProjectItemDataOfHistoryDataItemIPg14zztYaWdJY9w><a:Key>Program.cs</a:Key><a:Value><DataItems><HistoryDataItem><Char>3615</Char><CodeMapItemPath>Program#Main</CodeMapItemPath><HistoryLevel>1</HistoryLevel><HistoryTimeStamp>2023-09-06T08:41:47.5530823+02:00</HistoryTimeStamp><Line>0</Line><ParameterList>string[]</ParameterList></HistoryDataItem></DataItems><ProjectItemFileName>Program.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfHistoryDataItemIPg14zztYaWdJY9w></ProjectHistoryData><ProjectInCodeHighlightData xmlns:a="http://schemas.microsoft.com/2003/10/Serialization/Arrays"><a:KeyValueOfstringProjectItemDataOfInCodeHighlightDataItemIPg14zztYaWdJY9w><a:Key>Program.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>Program.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfInCodeHighlightDataItemIPg14zztYaWdJY9w></ProjectInCodeHighlightData><ProjectMiniViewData xmlns:a="http://schemas.microsoft.com/2003/10/Serialization/Arrays"><a:KeyValueOfstringProjectItemDataOfMiniViewDataItemIPg14zztYaWdJY9w><a:Key>Program.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>Program.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfMiniViewDataItemIPg14zztYaWdJY9w></ProjectMiniViewData><ProjectName>Tiger</ProjectName></ProjectData>
\ No newline at end of file
diff --git a/.vs/Supercharger/Tiger/global_history.dat b/.vs/Supercharger/Tiger/global_history.dat
new file mode 100644
index 0000000..eec6e76
--- /dev/null
+++ b/.vs/Supercharger/Tiger/global_history.dat
@@ -0,0 +1 @@
+<ProjectData xmlns="http://schemas.datacontract.org/2004/07/BG8.Supercharger.Features.CodeMap.GlobalHistory" xmlns:i="http://www.w3.org/2001/XMLSchema-instance"><ProjectGlobalHistoryData xmlns:a="http://schemas.microsoft.com/2003/10/Serialization/Arrays"><a:KeyValueOfstringProjectItemDatajRe1r2YW><a:Key>D:\yatc\YATC.Compiler\Program.cs</a:Key><a:Value><DataItems><GlobalHistoryDataItem><ID>YATC.Compiler.Program.Mainstatic##int#string[]</ID><ImageSource>img\tvi\x_method-s_private-i_static</ImageSource><IsPinned>false</IsPinned><IsPublic>false</IsPublic><ItemName>Main</ItemName><ItemPath>YATC.Compiler.Program</ItemPath><ProjectFullName>D:\yatc\YATC.Compiler\Tiger.csproj</ProjectFullName><ProjectItemFileName>D:\yatc\YATC.Compiler\Program.cs</ProjectItemFileName><TimeStamp>2023-09-06T08:43:08.8339312+02:00</TimeStamp></GlobalHistoryDataItem><GlobalHistoryDataItem><ID>YATC.Compiler.Program.Printstatic##void#CommonTree</ID><ImageSource>img\tvi\x_method-s_private-i_static</ImageSource><IsPinned>false</IsPinned><IsPublic>false</IsPublic><ItemName>Print</ItemName><ItemPath>YATC.Compiler.Program</ItemPath><ProjectFullName>D:\yatc\YATC.Compiler\Tiger.csproj</ProjectFullName><ProjectItemFileName>D:\yatc\YATC.Compiler\Program.cs</ProjectItemFileName><TimeStamp>2023-09-06T08:43:02.6982502+02:00</TimeStamp></GlobalHistoryDataItem></DataItems><ProjectItemFileName>D:\yatc\YATC.Compiler\Program.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDatajRe1r2YW></ProjectGlobalHistoryData><ProjectName>Tiger</ProjectName></ProjectData>
\ No newline at end of file
diff --git a/.vs/Supercharger/Tiger/workbench.dat b/.vs/Supercharger/Tiger/workbench.dat
new file mode 100644
index 0000000..be43d93
--- /dev/null
+++ b/.vs/Supercharger/Tiger/workbench.dat
@@ -0,0 +1 @@
+<ProjectData xmlns="http://schemas.datacontract.org/2004/07/BG8.Supercharger.Features.CodeMap.Gss" xmlns:i="http://www.w3.org/2001/XMLSchema-instance"><DataItems/><ProjectName>Tiger</ProjectName></ProjectData>
\ No newline at end of file
diff --git a/.vs/Supercharger/YATC/codemap.dat b/.vs/Supercharger/YATC/codemap.dat
new file mode 100644
index 0000000..64d6015
--- /dev/null
+++ b/.vs/Supercharger/YATC/codemap.dat
@@ -0,0 +1 @@
+<ProjectData xmlns="http://schemas.datacontract.org/2004/07/BG8.Supercharger.Features.CodeMap" xmlns:i="http://www.w3.org/2001/XMLSchema-instance"><ProjectAllTimeMostUsedData xmlns:a="http://schemas.microsoft.com/2003/10/Serialization/Arrays"><a:KeyValueOfstringProjectItemDataOfAllTimeMostUsedDataItemIPg14zztYaWdJY9w><a:Key>D:\yatc\Grammar\tigerLexer.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>D:\yatc\Grammar\tigerLexer.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfAllTimeMostUsedDataItemIPg14zztYaWdJY9w><a:KeyValueOfstringProjectItemDataOfAllTimeMostUsedDataItemIPg14zztYaWdJY9w><a:Key>D:\yatc\Grammar\tigerParser.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>D:\yatc\Grammar\tigerParser.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfAllTimeMostUsedDataItemIPg14zztYaWdJY9w><a:KeyValueOfstringProjectItemDataOfAllTimeMostUsedDataItemIPg14zztYaWdJY9w><a:Key>ASTNodes\ProgramNode.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>ASTNodes\ProgramNode.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfAllTimeMostUsedDataItemIPg14zztYaWdJY9w></ProjectAllTimeMostUsedData><ProjectExpandedStateData xmlns:a="http://schemas.microsoft.com/2003/10/Serialization/Arrays"><a:KeyValueOfstringProjectItemDataOfExpandedStateDataItemIPg14zztYaWdJY9w><a:Key>D:\yatc\Grammar\tigerLexer.cs</a:Key><a:Value><DataItems><ExpandedStateDataItem><CodeMapItemPath>tigerLexer#DFA</CodeMapItemPath><IsExpanded>false</IsExpanded><ParameterList/></ExpandedStateDataItem></DataItems><ProjectItemFileName>D:\yatc\Grammar\tigerLexer.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfExpandedStateDataItemIPg14zztYaWdJY9w><a:KeyValueOfstringProjectItemDataOfExpandedStateDataItemIPg14zztYaWdJY9w><a:Key>D:\yatc\Grammar\tigerParser.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>D:\yatc\Grammar\tigerParser.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfExpandedStateDataItemIPg14zztYaWdJY9w><a:KeyValueOfstringProjectItemDataOfExpandedStateDataItemIPg14zztYaWdJY9w><a:Key>ASTNodes\ProgramNode.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>ASTNodes\ProgramNode.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfExpandedStateDataItemIPg14zztYaWdJY9w></ProjectExpandedStateData><ProjectFavoriteData xmlns:a="http://schemas.microsoft.com/2003/10/Serialization/Arrays"><a:KeyValueOfstringProjectItemDataOfFavoriteDataItemIPg14zztYaWdJY9w><a:Key>D:\yatc\Grammar\tigerLexer.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>D:\yatc\Grammar\tigerLexer.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfFavoriteDataItemIPg14zztYaWdJY9w><a:KeyValueOfstringProjectItemDataOfFavoriteDataItemIPg14zztYaWdJY9w><a:Key>D:\yatc\Grammar\tigerParser.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>D:\yatc\Grammar\tigerParser.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfFavoriteDataItemIPg14zztYaWdJY9w><a:KeyValueOfstringProjectItemDataOfFavoriteDataItemIPg14zztYaWdJY9w><a:Key>ASTNodes\ProgramNode.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>ASTNodes\ProgramNode.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfFavoriteDataItemIPg14zztYaWdJY9w></ProjectFavoriteData><ProjectHistoryData xmlns:a="http://schemas.microsoft.com/2003/10/Serialization/Arrays"><a:KeyValueOfstringProjectItemDataOfHistoryDataItemIPg14zztYaWdJY9w><a:Key>D:\yatc\Grammar\tigerLexer.cs</a:Key><a:Value><DataItems><HistoryDataItem><Char>342</Char><CodeMapItemPath>tigerLexer#mFUNCTIONKEY</CodeMapItemPath><HistoryLevel>1</HistoryLevel><HistoryTimeStamp>2023-09-06T09:54:00.6943386+02:00</HistoryTimeStamp><Line>0</Line><ParameterList/></HistoryDataItem></DataItems><ProjectItemFileName>D:\yatc\Grammar\tigerLexer.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfHistoryDataItemIPg14zztYaWdJY9w><a:KeyValueOfstringProjectItemDataOfHistoryDataItemIPg14zztYaWdJY9w><a:Key>D:\yatc\Grammar\tigerParser.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>D:\yatc\Grammar\tigerParser.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfHistoryDataItemIPg14zztYaWdJY9w><a:KeyValueOfstringProjectItemDataOfHistoryDataItemIPg14zztYaWdJY9w><a:Key>ASTNodes\ProgramNode.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>ASTNodes\ProgramNode.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfHistoryDataItemIPg14zztYaWdJY9w></ProjectHistoryData><ProjectInCodeHighlightData xmlns:a="http://schemas.microsoft.com/2003/10/Serialization/Arrays"><a:KeyValueOfstringProjectItemDataOfInCodeHighlightDataItemIPg14zztYaWdJY9w><a:Key>D:\yatc\Grammar\tigerLexer.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>D:\yatc\Grammar\tigerLexer.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfInCodeHighlightDataItemIPg14zztYaWdJY9w><a:KeyValueOfstringProjectItemDataOfInCodeHighlightDataItemIPg14zztYaWdJY9w><a:Key>D:\yatc\Grammar\tigerParser.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>D:\yatc\Grammar\tigerParser.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfInCodeHighlightDataItemIPg14zztYaWdJY9w><a:KeyValueOfstringProjectItemDataOfInCodeHighlightDataItemIPg14zztYaWdJY9w><a:Key>ASTNodes\ProgramNode.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>ASTNodes\ProgramNode.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfInCodeHighlightDataItemIPg14zztYaWdJY9w></ProjectInCodeHighlightData><ProjectMiniViewData xmlns:a="http://schemas.microsoft.com/2003/10/Serialization/Arrays"><a:KeyValueOfstringProjectItemDataOfMiniViewDataItemIPg14zztYaWdJY9w><a:Key>D:\yatc\Grammar\tigerLexer.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>D:\yatc\Grammar\tigerLexer.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfMiniViewDataItemIPg14zztYaWdJY9w><a:KeyValueOfstringProjectItemDataOfMiniViewDataItemIPg14zztYaWdJY9w><a:Key>D:\yatc\Grammar\tigerParser.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>D:\yatc\Grammar\tigerParser.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfMiniViewDataItemIPg14zztYaWdJY9w><a:KeyValueOfstringProjectItemDataOfMiniViewDataItemIPg14zztYaWdJY9w><a:Key>ASTNodes\ProgramNode.cs</a:Key><a:Value><DataItems/><ProjectItemFileName>ASTNodes\ProgramNode.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDataOfMiniViewDataItemIPg14zztYaWdJY9w></ProjectMiniViewData><ProjectName>YATC</ProjectName></ProjectData>
\ No newline at end of file
diff --git a/.vs/Supercharger/YATC/global_history.dat b/.vs/Supercharger/YATC/global_history.dat
new file mode 100644
index 0000000..d4f954a
--- /dev/null
+++ b/.vs/Supercharger/YATC/global_history.dat
@@ -0,0 +1 @@
+<ProjectData xmlns="http://schemas.datacontract.org/2004/07/BG8.Supercharger.Features.CodeMap.GlobalHistory" xmlns:i="http://www.w3.org/2001/XMLSchema-instance"><ProjectGlobalHistoryData xmlns:a="http://schemas.microsoft.com/2003/10/Serialization/Arrays"><a:KeyValueOfstringProjectItemDatajRe1r2YW><a:Key>D:\yatc\Grammar\tigerLexer.cs</a:Key><a:Value><DataItems><GlobalHistoryDataItem><ID>YATC.Grammar.tigerLexer.mFUNCTIONKEY#void#</ID><ImageSource>img\tvi\x_method-s_private-i_instance</ImageSource><IsPinned>false</IsPinned><IsPublic>false</IsPublic><ItemName>mFUNCTIONKEY</ItemName><ItemPath>YATC.Grammar.tigerLexer</ItemPath><ProjectFullName>D:\yatc\YATC\YATC.csproj</ProjectFullName><ProjectItemFileName>D:\yatc\Grammar\tigerLexer.cs</ProjectItemFileName><TimeStamp>2023-09-06T09:21:05.7326172+02:00</TimeStamp></GlobalHistoryDataItem></DataItems><ProjectItemFileName>D:\yatc\Grammar\tigerLexer.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDatajRe1r2YW><a:KeyValueOfstringProjectItemDatajRe1r2YW><a:Key>D:\yatc\Grammar\tigerParser.cs</a:Key><a:Value><DataItems><GlobalHistoryDataItem><ID>YATC.Grammar.tigerParser.GrammarFileName</ID><ImageSource>img\tvi\x_property_override-s_public-i_instance</ImageSource><IsPinned>false</IsPinned><IsPublic>true</IsPublic><ItemName>GrammarFileName</ItemName><ItemPath>YATC.Grammar.tigerParser</ItemPath><ProjectFullName>D:\yatc\YATC\YATC.csproj</ProjectFullName><ProjectItemFileName>D:\yatc\Grammar\tigerParser.cs</ProjectItemFileName><TimeStamp>2023-09-06T08:56:49.7403958+02:00</TimeStamp></GlobalHistoryDataItem></DataItems><ProjectItemFileName>D:\yatc\Grammar\tigerParser.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDatajRe1r2YW><a:KeyValueOfstringProjectItemDatajRe1r2YW><a:Key>D:\yatc\YATC\ASTNodes\ProgramNode.cs</a:Key><a:Value><DataItems><GlobalHistoryDataItem><ID>YATC.ASTNodes.ProgramNode.AddStdLib#void#</ID><ImageSource>img\tvi\x_method-s_private-i_instance</ImageSource><IsPinned>false</IsPinned><IsPublic>false</IsPublic><ItemName>AddStdLib</ItemName><ItemPath>YATC.ASTNodes.ProgramNode</ItemPath><ProjectFullName>D:\yatc\YATC\YATC.csproj</ProjectFullName><ProjectItemFileName>D:\yatc\YATC\ASTNodes\ProgramNode.cs</ProjectItemFileName><TimeStamp>2023-09-06T08:56:15.8291369+02:00</TimeStamp></GlobalHistoryDataItem><GlobalHistoryDataItem><ID>YATC.ASTNodes.ProgramNode</ID><ImageSource>img\tvi\y_class-s_public-i_instance</ImageSource><IsPinned>false</IsPinned><IsPublic>false</IsPublic><ItemName>ProgramNode</ItemName><ItemPath>YATC.ASTNodes</ItemPath><ProjectFullName>D:\yatc\YATC\YATC.csproj</ProjectFullName><ProjectItemFileName>D:\yatc\YATC\ASTNodes\ProgramNode.cs</ProjectItemFileName><TimeStamp>2023-09-06T08:55:41.7786924+02:00</TimeStamp></GlobalHistoryDataItem></DataItems><ProjectItemFileName>D:\yatc\YATC\ASTNodes\ProgramNode.cs</ProjectItemFileName></a:Value></a:KeyValueOfstringProjectItemDatajRe1r2YW></ProjectGlobalHistoryData><ProjectName>YATC</ProjectName></ProjectData>
\ No newline at end of file
diff --git a/.vs/Supercharger/YATC/workbench.dat b/.vs/Supercharger/YATC/workbench.dat
new file mode 100644
index 0000000..24a6f26
--- /dev/null
+++ b/.vs/Supercharger/YATC/workbench.dat
@@ -0,0 +1 @@
+<ProjectData xmlns="http://schemas.datacontract.org/2004/07/BG8.Supercharger.Features.CodeMap.Gss" xmlns:i="http://www.w3.org/2001/XMLSchema-instance"><DataItems/><ProjectName>YATC</ProjectName></ProjectData>
\ No newline at end of file
diff --git a/.vs/Supercharger/_/DTabsHistory.dat b/.vs/Supercharger/_/DTabsHistory.dat
new file mode 100644
index 0000000..0e640cc
--- /dev/null
+++ b/.vs/Supercharger/_/DTabsHistory.dat
@@ -0,0 +1 @@
+<ArrayOfstring xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns:i="http://www.w3.org/2001/XMLSchema-instance"><string>D:0:0:{00000000-0000-0000-0000-000000000000}|&lt;Solution&gt;|Tiger||{95501C48-A850-47C1-A785-2AAA96637F81}</string><string>D:0:0:{8B1FA297-B497-4F06-A6AE-87D73920AA57}|YATC.Compiler\Tiger.csproj|d:\yatc\yatc.compiler\program.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}</string></ArrayOfstring>
\ No newline at end of file
diff --git a/.vs/YATC/FileContentIndex/3f07f1cc-4685-4b0d-9adc-b87b13487c2b.vsidx b/.vs/YATC/FileContentIndex/3f07f1cc-4685-4b0d-9adc-b87b13487c2b.vsidx
new file mode 100644
index 0000000..490bb3d
Binary files /dev/null and b/.vs/YATC/FileContentIndex/3f07f1cc-4685-4b0d-9adc-b87b13487c2b.vsidx differ
diff --git a/.vs/YATC/FileContentIndex/acd5c18f-c380-4d13-bbff-b4bf68025f6d.vsidx b/.vs/YATC/FileContentIndex/acd5c18f-c380-4d13-bbff-b4bf68025f6d.vsidx
new file mode 100644
index 0000000..736fda1
Binary files /dev/null and b/.vs/YATC/FileContentIndex/acd5c18f-c380-4d13-bbff-b4bf68025f6d.vsidx differ
diff --git a/.vs/YATC/FileContentIndex/efc3d55b-f639-4562-b98d-3976465a80d7.vsidx b/.vs/YATC/FileContentIndex/efc3d55b-f639-4562-b98d-3976465a80d7.vsidx
new file mode 100644
index 0000000..3431e4a
Binary files /dev/null and b/.vs/YATC/FileContentIndex/efc3d55b-f639-4562-b98d-3976465a80d7.vsidx differ
diff --git a/YATC.Compiler/Tiger.csproj b/YATC.Compiler/Tiger.csproj
index a7e4f49..45dc371 100644
--- a/YATC.Compiler/Tiger.csproj
+++ b/YATC.Compiler/Tiger.csproj
@@ -11,6 +11,8 @@
     <AssemblyName>tiger</AssemblyName>
     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>
@@ -32,8 +34,8 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Antlr3.Runtime">
-      <HintPath>..\Antlr3.Runtime.dll</HintPath>
+    <Reference Include="Antlr3.Runtime, Version=3.5.0.2, Culture=neutral, PublicKeyToken=eb42632606e9261f, processorArchitecture=MSIL">
+      <HintPath>..\packages\Antlr3.Runtime.3.5.1\lib\net40-client\Antlr3.Runtime.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -49,6 +51,7 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
+    <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\YATC\YATC.csproj">
diff --git a/YATC.Compiler/packages.config b/YATC.Compiler/packages.config
new file mode 100644
index 0000000..9035c0e
--- /dev/null
+++ b/YATC.Compiler/packages.config
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Antlr3.Runtime" version="3.5.1" targetFramework="net45" />
+  <package id="Antlr34" version="3.4.19004.1" targetFramework="net45" />
+</packages>
\ No newline at end of file
diff --git a/YATC/YATC.csproj b/YATC/YATC.csproj
index 9a13653..a003f3a 100644
--- a/YATC/YATC.csproj
+++ b/YATC/YATC.csproj
@@ -31,8 +31,8 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Antlr3.Runtime">
-      <HintPath>..\Antlr3.Runtime.dll</HintPath>
+    <Reference Include="Antlr3.Runtime, Version=3.5.0.2, Culture=neutral, PublicKeyToken=eb42632606e9261f, processorArchitecture=MSIL">
+      <HintPath>..\packages\Antlr.3.5.0.2\lib\Antlr3.Runtime.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -134,6 +134,9 @@
       <CustomToolNamespace>YATC.Grammar</CustomToolNamespace>
     </Antlr3>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/YATC/packages.config b/YATC/packages.config
new file mode 100644
index 0000000..793dd33
--- /dev/null
+++ b/YATC/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Antlr" version="3.5.0.2" targetFramework="net40" />
+</packages>
\ No newline at end of file
diff --git a/packages/Antlr.3.5.0.2/.signature.p7s b/packages/Antlr.3.5.0.2/.signature.p7s
new file mode 100644
index 0000000..f1a86a2
Binary files /dev/null and b/packages/Antlr.3.5.0.2/.signature.p7s differ
diff --git a/packages/Antlr.3.5.0.2/Antlr.3.5.0.2.nupkg b/packages/Antlr.3.5.0.2/Antlr.3.5.0.2.nupkg
new file mode 100644
index 0000000..6c4a15d
Binary files /dev/null and b/packages/Antlr.3.5.0.2/Antlr.3.5.0.2.nupkg differ
diff --git a/packages/Antlr.3.5.0.2/lib/Antlr3.Runtime.dll b/packages/Antlr.3.5.0.2/lib/Antlr3.Runtime.dll
new file mode 100644
index 0000000..b963933
Binary files /dev/null and b/packages/Antlr.3.5.0.2/lib/Antlr3.Runtime.dll differ
diff --git a/packages/Antlr3.Runtime.3.5.1/.signature.p7s b/packages/Antlr3.Runtime.3.5.1/.signature.p7s
new file mode 100644
index 0000000..186744e
Binary files /dev/null and b/packages/Antlr3.Runtime.3.5.1/.signature.p7s differ
diff --git a/packages/Antlr3.Runtime.3.5.1/Antlr3.Runtime.3.5.1.nupkg b/packages/Antlr3.Runtime.3.5.1/Antlr3.Runtime.3.5.1.nupkg
new file mode 100644
index 0000000..b37b2f6
Binary files /dev/null and b/packages/Antlr3.Runtime.3.5.1/Antlr3.Runtime.3.5.1.nupkg differ
diff --git a/packages/Antlr3.Runtime.3.5.1/lib/net20/Antlr3.Runtime.dll b/packages/Antlr3.Runtime.3.5.1/lib/net20/Antlr3.Runtime.dll
new file mode 100644
index 0000000..2bf359a
Binary files /dev/null and b/packages/Antlr3.Runtime.3.5.1/lib/net20/Antlr3.Runtime.dll differ
diff --git a/packages/Antlr3.Runtime.3.5.1/lib/net20/Antlr3.Runtime.xml b/packages/Antlr3.Runtime.3.5.1/lib/net20/Antlr3.Runtime.xml
new file mode 100644
index 0000000..565e15d
--- /dev/null
+++ b/packages/Antlr3.Runtime.3.5.1/lib/net20/Antlr3.Runtime.xml
@@ -0,0 +1,3249 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>Antlr3.Runtime</name>
+    </assembly>
+    <members>
+        <member name="T:Antlr.Runtime.ANTLRFileStream">
+            <summary>
+            This is a char buffer stream that is loaded from a file
+            all at once when you construct the object.  This looks very
+            much like an ANTLReader or ANTLRInputStream, but it's a special case
+            since we know the exact size of the object to load.  We can avoid lots
+            of data copying. 
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.ANTLRInputStream">
+            <summary>
+            A kind of ReaderStream that pulls from an InputStream.
+            Useful for reading from stdin and specifying file encodings etc...
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.ANTLRReaderStream">
+            <summary>
+              Vacuum all input from a Reader and then treat it like a StringStream.
+              Manage the buffer manually to avoid unnecessary data copying.
+              </summary>
+            
+              <remarks>
+              If you need encoding, use ANTLRInputStream.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.ANTLRStringStream">
+            <summary>
+            A pretty quick CharStream that pulls all data from an array
+            directly.  Every method call counts in the lexer.  Java's
+            strings aren't very good so I'm avoiding.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.data">
+            <summary>The data being scanned</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.n">
+            <summary>How many characters are actually in the buffer</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.p">
+            <summary>0..n-1 index into string of next char</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.line">
+            <summary>line number 1..n within the input</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.charPositionInLine">
+            <summary>The index of the character relative to the beginning of the line 0..n-1</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.markDepth">
+            <summary>tracks how deep mark() calls are nested</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.markers">
+            <summary>
+            A list of CharStreamState objects that tracks the stream state
+            values line, charPositionInLine, and p that can change as you
+            move through the input stream.  Indexed from 1..markDepth.
+            A null is kept @ index 0.  Create upon first call to mark().
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.name">
+            <summary>What is name or source of this char stream?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.#ctor(System.String)">
+            <summary>Copy data in string to a local char array</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.#ctor(System.Char[],System.Int32)">
+            <summary>This is the preferred constructor as no data is copied</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.ANTLRStringStream.Index">
+            <summary>
+            Return the current input symbol index 0..n where n indicates the
+            last symbol has been read.  The index is the index of char to
+            be returned from LA(1).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.Reset">
+            <summary>
+            Reset the stream so that it's in the same state it was
+            when the object was created *except* the data array is not
+            touched.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.Seek(System.Int32)">
+            <summary>
+            consume() ahead until p==index; can't just set p=index as we must
+            update line and charPositionInLine.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.BaseRecognizer">
+            <summary>
+            A generic recognizer that can handle recognizers generated from
+            lexer, parser, and tree grammars.  This is all the parsing
+            support code essentially; most of it is error recovery stuff and
+            backtracking.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.BaseRecognizer.state">
+            <summary>
+            State of a lexer, parser, or tree parser are collected into a state
+            object so the state can be shared.  This sharing is needed to
+            have one grammar import others and share same error variables
+            and other state variables.  It's a kind of explicit multiple
+            inheritance via delegation of methods and shared state.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Reset">
+            <summary>reset the parser's state; subclasses must rewinds the input stream</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Match(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>
+              Match current input symbol against ttype.  Attempt
+              single token insertion or deletion error recovery.  If
+              that fails, throw MismatchedTokenException.
+              </summary>
+            
+              <remarks>
+              To turn off single token insertion or deletion error
+              recovery, override recoverFromMismatchedToken() and have it
+              throw an exception. See TreeParser.recoverFromMismatchedToken().
+              This way any error in a rule will cause an exception and
+              immediate exit from rule.  Rule would recover by resynchronizing
+              to the set of symbols that can follow rule ref.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.MatchAny(Antlr.Runtime.IIntStream)">
+            <summary>Match the wildcard: in a symbol</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ReportError(Antlr.Runtime.RecognitionException)">
+            <summary>Report a recognition problem.</summary>
+            
+              <remarks>
+              This method sets errorRecovery to indicate the parser is recovering
+              not parsing.  Once in recovery mode, no errors are generated.
+              To get out of recovery mode, the parser must successfully match
+              a token (after a resync).  So it will go:
+            
+             		1. error occurs
+             		2. enter recovery mode, report error
+             		3. consume until token found in resynch set
+             		4. try to resume parsing
+             		5. next match() will reset errorRecovery mode
+            
+              If you override, make sure to update syntaxErrors if you care about that.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetErrorMessage(Antlr.Runtime.RecognitionException,System.String[])">
+            <summary>What error message should be generated for the various exception types?</summary>
+            
+              <remarks>
+              Not very object-oriented code, but I like having all error message
+              generation within one method rather than spread among all of the
+              exception classes. This also makes it much easier for the exception
+              handling because the exception classes do not have to have pointers back
+              to this object to access utility routines and so on. Also, changing
+              the message for an exception type would be difficult because you
+              would have to subclassing exception, but then somehow get ANTLR
+              to make those kinds of exception objects instead of the default.
+              This looks weird, but trust me--it makes the most sense in terms
+              of flexibility.
+            
+              For grammar debugging, you will want to override this to add
+              more information such as the stack frame with
+              getRuleInvocationStack(e, this.getClass().getName()) and,
+              for no viable alts, the decision description and state etc...
+            
+              Override this to change the message generated for one or more
+              exception types.
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.NumberOfSyntaxErrors">
+            <summary>
+              Get number of recognition errors (lexer, parser, tree parser).  Each
+              recognizer tracks its own number.  So parser and lexer each have
+              separate count.  Does not count the spurious errors found between
+              an error and next valid token match
+              </summary>
+            
+              <seealso cref="M:Antlr.Runtime.BaseRecognizer.ReportError(Antlr.Runtime.RecognitionException)"/>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetErrorHeader(Antlr.Runtime.RecognitionException)">
+            <summary>What is the error header, normally line/character position information?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetTokenErrorDisplay(Antlr.Runtime.IToken)">
+            <summary>
+            How should a token be displayed in an error message? The default
+            is to display just the text, but during development you might
+            want to have a lot of information spit out.  Override in that case
+            to use t.ToString() (which, for CommonToken, dumps everything about
+            the token). This is better than forcing you to override a method in
+            your token objects because you don't have to go modify your lexer
+            so that it creates a new Java type.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.EmitErrorMessage(System.String)">
+            <summary>Override this method to change where error messages go</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Recover(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException)">
+            <summary>
+            Recover from an error found on the input stream.  This is
+            for NoViableAlt and mismatched symbol exceptions.  If you enable
+            single token insertion and deletion, this will usually not
+            handle mismatched symbol exceptions but there could be a mismatched
+            token that the match() routine could not recover from.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.BeginResync">
+            <summary>
+            A hook to listen in on the token consumption during error recovery.
+            The DebugParser subclasses this to fire events to the listenter.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ComputeContextSensitiveRuleFOLLOW">
+            <summary>
+              Compute the context-sensitive FOLLOW set for current rule.
+              This is set of token types that can follow a specific rule
+              reference given a specific call chain.  You get the set of
+              viable tokens that can possibly come next (lookahead depth 1)
+              given the current call chain.  Contrast this with the
+              definition of plain FOLLOW for rule r:
+              </summary>
+            
+               FOLLOW(r)={x | S=>*alpha r beta in G and x in FIRST(beta)}
+            
+              where x in T* and alpha, beta in V*; T is set of terminals and
+              V is the set of terminals and nonterminals.  In other words,
+              FOLLOW(r) is the set of all tokens that can possibly follow
+              references to r in *any* sentential form (context).  At
+              runtime, however, we know precisely which context applies as
+              we have the call chain.  We may compute the exact (rather
+              than covering superset) set of following tokens.
+            
+              For example, consider grammar:
+            
+              stat : ID '=' expr ';'      // FOLLOW(stat)=={EOF}
+                   | "return" expr '.'
+                   ;
+              expr : atom ('+' atom)* ;   // FOLLOW(expr)=={';','.',')'}
+              atom : INT                  // FOLLOW(atom)=={'+',')',';','.'}
+                   | '(' expr ')'
+                   ;
+            
+              The FOLLOW sets are all inclusive whereas context-sensitive
+              FOLLOW sets are precisely what could follow a rule reference.
+              For input input "i=(3);", here is the derivation:
+            
+              stat => ID '=' expr ';'
+                   => ID '=' atom ('+' atom)* ';'
+                   => ID '=' '(' expr ')' ('+' atom)* ';'
+                   => ID '=' '(' atom ')' ('+' atom)* ';'
+                   => ID '=' '(' INT ')' ('+' atom)* ';'
+                   => ID '=' '(' INT ')' ';'
+            
+              At the "3" token, you'd have a call chain of
+            
+                stat -> expr -> atom -> expr -> atom
+            
+              What can follow that specific nested ref to atom?  Exactly ')'
+              as you can see by looking at the derivation of this specific
+              input.  Contrast this with the FOLLOW(atom)={'+',')',';','.'}.
+            
+              You want the exact viable token set when recovering from a
+              token mismatch.  Upon token mismatch, if LA(1) is member of
+              the viable next token set, then you know there is most likely
+              a missing token in the input stream.  "Insert" one by just not
+              throwing an exception.
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.RecoverFromMismatchedToken(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>Attempt to recover from a single missing or extra token.</summary>
+            
+              EXTRA TOKEN
+            
+              LA(1) is not what we are looking for.  If LA(2) has the right token,
+              however, then assume LA(1) is some extra spurious token.  Delete it
+              and LA(2) as if we were doing a normal match(), which advances the
+              input.
+            
+              MISSING TOKEN
+            
+              If current token is consistent with what could come after
+              ttype then it is ok to "insert" the missing token, else throw
+              exception For example, Input "i=(3;" is clearly missing the
+              ')'.  When the parser returns from the nested call to expr, it
+              will have call chain:
+            
+                stat -> expr -> atom
+            
+              and it will be trying to match the ')' at this point in the
+              derivation:
+            
+                   => ID '=' '(' INT ')' ('+' atom)* ';'
+                                      ^
+              match() will see that ';' doesn't match ')' and report a
+              mismatched token error.  To recover, it sees that LA(1)==';'
+              is in the set of tokens that can follow the ')' token
+              reference in rule atom.  It can assume that you forgot the ')'.
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.RecoverFromMismatchedSet(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException,Antlr.Runtime.BitSet)">
+            Not currently used 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetCurrentInputSymbol(Antlr.Runtime.IIntStream)">
+            <summary>
+              Match needs to return the current input symbol, which gets put
+              into the label for the associated token ref; e.g., x=ID.  Token
+              and tree parsers need to return different objects. Rather than test
+              for input stream type or change the IntStream interface, I use
+              a simple method to ask the recognizer to tell me what the current
+              input symbol is.
+              </summary>
+            
+              <remarks>This is ignored for lexers.</remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetMissingSymbol(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>Conjure up a missing token during error recovery.</summary>
+            
+              <remarks>
+              The recognizer attempts to recover from single missing
+              symbols. But, actions might refer to that missing symbol.
+              For example, x=ID {f($x);}. The action clearly assumes
+              that there has been an identifier matched previously and that
+              $x points at that token. If that token is missing, but
+              the next token in the stream is what we want we assume that
+              this token is missing and we keep going. Because we
+              have to return some token to replace the missing token,
+              we have to conjure one up. This method gives the user control
+              over the tokens returned for missing tokens. Mostly,
+              you will want to create something special for identifier
+              tokens. For literals such as '{' and ',', the default
+              action in the parser or tree parser works. It simply creates
+              a CommonToken of the appropriate type. The text will be the token.
+              If you change what tokens must be created by the lexer,
+              override this method to create the appropriate tokens.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ConsumeUntil(Antlr.Runtime.IIntStream,Antlr.Runtime.BitSet)">
+            <summary>Consume tokens until one matches the given token set</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.PushFollow(Antlr.Runtime.BitSet)">
+            <summary>Push a rule's follow set using our own hardcoded stack</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleInvocationStack">
+            <summary>
+              Return <see cref="T:System.Collections.Generic.IList`1"/> of the rules in your parser instance
+              leading up to a call to this method.  You could override if
+              you want more details such as the file/line info of where
+              in the parser java code a rule is invoked.
+              </summary>
+            
+              <remarks>
+              This is very useful for error messages and for context-sensitive
+              error recovery.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleInvocationStack(System.Diagnostics.StackTrace)">
+            <summary>
+            A more general version of GetRuleInvocationStack where you can
+            pass in the StackTrace of, for example, a RecognitionException
+            to get it's rule stack trace.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.Failed">
+            <summary>Return whether or not a backtracking attempt failed.</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.TokenNames">
+            <summary>
+            Used to print out token names like ID during debugging and
+            error reporting.  The generated parsers implement a method
+            that overrides this to point to their String[] tokenNames.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.GrammarFileName">
+            <summary>
+            For debugging and other purposes, might want the grammar name.
+            Have ANTLR generate an implementation for this method.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ToStrings(System.Collections.Generic.ICollection{Antlr.Runtime.IToken})">
+            <summary>
+            A convenience method for use most often with template rewrites.
+            Convert a list of <see cref="T:Antlr.Runtime.IToken"/> to a list of <see cref="T:System.String"/>.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleMemoization(System.Int32,System.Int32)">
+            <summary>
+              Given a rule number and a start token index number, return
+              MEMO_RULE_UNKNOWN if the rule has not parsed input starting from
+              start index.  If this rule has parsed input starting from the
+              start index before, then return where the rule stopped parsing.
+              It returns the index of the last token matched by the rule.
+              </summary>
+            
+              <remarks>
+              For now we use a hashtable and just the slow Object-based one.
+              Later, we can make a special one for ints and also one that
+              tosses out data after we commit past input position i.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.AlreadyParsedRule(Antlr.Runtime.IIntStream,System.Int32)">
+            <summary>
+              Has this rule already parsed input at the current index in the
+              input stream?  Return the stop token index or MEMO_RULE_UNKNOWN.
+              If we attempted but failed to parse properly before, return
+              MEMO_RULE_FAILED.
+              </summary>
+            
+              <remarks>
+              This method has a side-effect: if we have seen this input for
+              this rule and successfully parsed before, then seek ahead to
+              1 past the stop token matched for this rule last time.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Memoize(Antlr.Runtime.IIntStream,System.Int32,System.Int32)">
+            <summary>
+            Record whether or not this rule parsed the input at this position
+            successfully.  Use a standard java hashtable for now.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleMemoizationCacheSize">
+            <summary>return how many rule/input-index pairs there are in total.</summary>
+            TODO: this includes synpreds. :(
+        </member>
+        <member name="T:Antlr.Runtime.BitSet">
+            <summary>
+            A stripped-down version of org.antlr.misc.BitSet that is just
+            good enough to handle runtime requirements such as FOLLOW sets
+            for automatic error recovery.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.BitSet.MOD_MASK">
+            <summary>
+            We will often need to do a mod operator (i mod nbits).  Its
+            turns out that, for powers of two, this mod operation is
+            same as (i &amp; (nbits-1)).  Since mod is slow, we use a
+            precomputed mod mask to do the mod instead.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.BitSet._bits">
+            <summary>The actual data bits</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor">
+            <summary>Construct a bitset of size one word (64 bits)</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor(System.UInt64[])">
+            <summary>Construction from a static array of longs</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor(System.Collections.Generic.IEnumerable{System.Int32})">
+            <summary>Construction from a list of integers</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor(System.Int32)">
+            <summary>Construct a bitset given the size</summary>
+            <param name="nbits">The size of the bitset in bits</param>
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.Or(Antlr.Runtime.BitSet)">
+            <summary>return this | a in a new set</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.Add(System.Int32)">
+            <summary>or this element into this set (grow as necessary to accommodate)</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.GrowToInclude(System.Int32)">
+            <summary>Grows the set to a larger number of bits.</summary>
+            <param name="bit">element that must fit in set</param>
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.SetSize(System.Int32)">
+            <summary>Sets the size of a set.</summary>
+            <param name="nwords">how many words the new set should be</param>
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.LengthInLongWords">
+            <summary>return how much space is being used by the bits array not how many actually have member bits on.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.ToArray">
+            Is this contained within a? 
+        </member>
+        <member name="T:Antlr.Runtime.BufferedTokenStream">
+            Buffer all input tokens but do on-demand fetching of new tokens from
+              lexer. Useful when the parser or lexer has to set context/mode info before
+              proper lexing of future tokens. The ST template parser needs this,
+              for example, because it has to constantly flip back and forth between
+              inside/output templates. E.g., <c>&lt;names:{hi, &lt;it&gt;}&gt;</c> has to parse names
+              as part of an expression but "hi, &lt;it&gt;" as a nested template.
+            
+              You can't use this stream if you pass whitespace or other off-channel
+              tokens to the parser. The stream can't ignore off-channel tokens.
+              (UnbufferedTokenStream is the same way.)
+            
+              This is not a subclass of UnbufferedTokenStream because I don't want
+              to confuse small moving window of tokens it uses for the full buffer.
+        </member>
+        <member name="F:Antlr.Runtime.BufferedTokenStream._tokens">
+            Record every single token pulled from the source so we can reproduce
+            chunks of it later.  The buffer in LookaheadStream overlaps sometimes
+            as its moving window moves through the input.  This list captures
+            everything so we can access complete input text.
+        </member>
+        <member name="F:Antlr.Runtime.BufferedTokenStream._lastMarker">
+            Track the last mark() call result value for use in rewind(). 
+        </member>
+        <member name="F:Antlr.Runtime.BufferedTokenStream._p">
+            The index into the tokens list of the current token (next token
+            to consume).  tokens[p] should be LT(1).  p=-1 indicates need
+            to initialize with first token.  The ctor doesn't get a token.
+            First call to LT(1) or whatever gets the first token and sets p=0;
+        </member>
+        <member name="P:Antlr.Runtime.BufferedTokenStream.Range">
+            <summary>
+            How deep have we gone?
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.Consume">
+            Move the input pointer to the next incoming token.  The stream
+              must become active with LT(1) available.  consume() simply
+              moves the input pointer so that LT(1) points at the next
+              input symbol. Consume at least one token.
+            
+              Walk past any token not on the channel the parser is listening to.
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.Sync(System.Int32)">
+            Make sure index i in tokens has a token. 
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.Fetch(System.Int32)">
+            add n elements to buffer 
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.GetTokens(System.Int32,System.Int32,Antlr.Runtime.BitSet)">
+            Given a start and stop index, return a List of all tokens in
+            the token type BitSet.  Return null if no tokens were found.  This
+            method looks at both on and off channel tokens.
+        </member>
+        <member name="T:Antlr.Runtime.CharStreamState">
+            <summary>
+              When walking ahead with cyclic DFA or for syntactic predicates,
+              we need to record the state of the input stream (char index,
+              line, etc...) so that we can rewind the state after scanning ahead.
+              </summary>
+            
+              <remarks>This is the complete state of a stream.</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.CharStreamState.p">
+            <summary>Index into the char stream of next lookahead char</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CharStreamState.line">
+            <summary>What line number is the scanner at before processing buffer[p]?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CharStreamState.charPositionInLine">
+            <summary>What char position 0..n-1 in line is scanner before processing buffer[p]?</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.ClassicToken">
+            <summary>
+            A Token object like we'd use in ANTLR 2.x; has an actual string created
+            and associated with this object.  These objects are needed for imaginary
+            tree nodes that have payload objects.  We need to create a Token object
+            that has a string; the tree node will point at this token.  CommonToken
+            has indexes into a char stream and hence cannot be used to introduce
+            new strings.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.ClassicToken.index">
+            <summary>What token number is this from 0..n-1 tokens</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.text">
+            <summary>
+            We need to be able to change the text once in a while.  If
+            this is non-null, then getText should return this.  Note that
+            start/stop are not affected by changing this.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.index">
+            <summary>What token number is this from 0..n-1 tokens; &lt; 0 implies invalid index</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.start">
+            <summary>The char position into the input buffer where this token starts</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.stop">
+            <summary>The char position into the input buffer where this token stops</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.CommonTokenStream">
+            <summary>
+              The most common stream of tokens is one where every token is buffered up
+              and tokens are prefiltered for a certain channel (the parser will only
+              see these tokens and cannot change the filter channel number during the
+              parse).
+              </summary>
+            
+              <remarks>TODO: how to access the full token stream?  How to track all tokens matched per rule?</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.CommonTokenStream._channel">
+            Skip tokens on any channel but this one; this is how we skip whitespace... 
+        </member>
+        <member name="P:Antlr.Runtime.CommonTokenStream.TokenSource">
+            Reset this token stream by setting its token source. 
+        </member>
+        <member name="M:Antlr.Runtime.CommonTokenStream.Consume">
+            Always leave p on an on-channel token. 
+        </member>
+        <member name="M:Antlr.Runtime.CommonTokenStream.SkipOffTokenChannels(System.Int32)">
+            Given a starting index, return the index of the first on-channel
+            token.
+        </member>
+        <member name="T:Antlr.Runtime.Debug.IDebugEventListener">
+            <summary>All debugging events that a recognizer can trigger.</summary>
+            
+              <remarks>
+              I did not create a separate AST debugging interface as it would create
+              lots of extra classes and DebugParser has a dbg var defined, which makes
+              it hard to change to ASTDebugEventListener.  I looked hard at this issue
+              and it is easier to understand as one monolithic event interface for all
+              possible events.  Hopefully, adding ST debugging stuff won't be bad.  Leave
+              for future. 4/26/2006.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterRule(System.String,System.String)">
+            <summary>
+            The parser has just entered a rule.  No decision has been made about
+            which alt is predicted.  This is fired AFTER init actions have been
+            executed.  Attributes are defined and available etc...
+            The grammarFileName allows composite grammars to jump around among
+            multiple grammar files.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterAlt(System.Int32)">
+            <summary>
+            Because rules can have lots of alternatives, it is very useful to
+            know which alt you are entering.  This is 1..n for n alts.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ExitRule(System.String,System.String)">
+            <summary>
+            This is the last thing executed before leaving a rule.  It is
+            executed even if an exception is thrown.  This is triggered after
+            error reporting and recovery have occurred (unless the exception is
+            not caught in this rule).  This implies an "exitAlt" event.
+            The grammarFileName allows composite grammars to jump around among
+            multiple grammar files.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterSubRule(System.Int32)">
+            <summary>Track entry into any (...) subrule other EBNF construct</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterDecision(System.Int32,System.Boolean)">
+            <summary>
+            Every decision, fixed k or arbitrary, has an enter/exit event
+            so that a GUI can easily track what LT/consume events are
+            associated with prediction.  You will see a single enter/exit
+            subrule but multiple enter/exit decision events, one for each
+            loop iteration.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeToken(Antlr.Runtime.IToken)">
+            <summary>
+            An input token was consumed; matched by any kind of element.
+            Trigger after the token was matched by things like match(), matchAny().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeHiddenToken(Antlr.Runtime.IToken)">
+            <summary>
+            An off-channel input token was consumed.
+            Trigger after the token was matched by things like match(), matchAny().
+            (unless of course the hidden token is first stuff in the input stream).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.LT(System.Int32,Antlr.Runtime.IToken)">
+            <summary>
+            Somebody (anybody) looked ahead.  Note that this actually gets
+            triggered by both LA and LT calls.  The debugger will want to know
+            which Token object was examined.  Like consumeToken, this indicates
+            what token was seen at that depth.  A remote debugger cannot look
+            ahead into a file it doesn't have so LT events must pass the token
+            even if the info is redundant.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Mark(System.Int32)">
+            <summary>
+            The parser is going to look arbitrarily ahead; mark this location,
+            the token stream's marker is sent in case you need it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Rewind(System.Int32)">
+            <summary>
+            After an arbitrairly long lookahead as with a cyclic DFA (or with
+            any backtrack), this informs the debugger that stream should be
+            rewound to the position associated with marker.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Rewind">
+            <summary>
+            Rewind to the input position of the last marker.
+            Used currently only after a cyclic DFA and just
+            before starting a sem/syn predicate to get the
+            input position back to the start of the decision.
+            Do not "pop" the marker off the state.  mark(i)
+            and rewind(i) should balance still.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Location(System.Int32,System.Int32)">
+            <summary>
+              To watch a parser move through the grammar, the parser needs to
+              inform the debugger what line/charPos it is passing in the grammar.
+              For now, this does not know how to switch from one grammar to the
+              other and back for island grammars etc...
+              </summary>
+            
+              <remarks>
+              This should also allow breakpoints because the debugger can stop
+              the parser whenever it hits this line/pos.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.RecognitionException(Antlr.Runtime.RecognitionException)">
+            <summary>
+              A recognition exception occurred such as NoViableAltException.  I made
+              this a generic event so that I can alter the exception hierachy later
+              without having to alter all the debug objects.
+              </summary>
+            
+              <remarks>
+              Upon error, the stack of enter rule/subrule must be properly unwound.
+              If no viable alt occurs it is within an enter/exit decision, which
+              also must be rewound.  Even the rewind for each mark must be unwount.
+              In the Java target this is pretty easy using try/finally, if a bit
+              ugly in the generated code.  The rewind is generated in DFA.predict()
+              actually so no code needs to be generated for that.  For languages
+              w/o this "finally" feature (C++?), the target implementor will have
+              to build an event stack or something.
+            
+              Across a socket for remote debugging, only the RecognitionException
+              data fields are transmitted.  The token object or whatever that
+              caused the problem was the last object referenced by LT.  The
+              immediately preceding LT event should hold the unexpected Token or
+              char.
+            
+              Here is a sample event trace for grammar:
+            
+              b : C ({;}A|B) // {;} is there to prevent A|B becoming a set
+                | D
+                ;
+            
+              The sequence for this rule (with no viable alt in the subrule) for
+              input 'c c' (there are 3 tokens) is:
+            
+            		commence
+            		LT(1)
+            		enterRule b
+            		location 7 1
+            		enter decision 3
+            		LT(1)
+            		exit decision 3
+            		enterAlt1
+            		location 7 5
+            		LT(1)
+            		consumeToken [c/&lt;4&gt;,1:0]
+            		location 7 7
+            		enterSubRule 2
+            		enter decision 2
+            		LT(1)
+            		LT(1)
+            		recognitionException NoViableAltException 2 1 2
+            		exit decision 2
+            		exitSubRule 2
+            		beginResync
+            		LT(1)
+            		consumeToken [c/&lt;4&gt;,1:1]
+            		LT(1)
+            		endResync
+            		LT(-1)
+            		exitRule b
+            		terminate
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.BeginResync">
+            <summary>
+            Indicates the recognizer is about to consume tokens to resynchronize
+            the parser.  Any consume events from here until the recovered event
+            are not part of the parse--they are dead tokens.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EndResync">
+            <summary>
+            Indicates that the recognizer has finished consuming tokens in order
+            to resychronize.  There may be multiple beginResync/endResync pairs
+            before the recognizer comes out of errorRecovery mode (in which
+            multiple errors are suppressed).  This will be useful
+            in a gui where you want to probably grey out tokens that are consumed
+            but not matched to anything in grammar.  Anything between
+            a beginResync/endResync pair was tossed out by the parser.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.SemanticPredicate(System.Boolean,System.String)">
+            <summary>A semantic predicate was evaluate with this result and action text</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Commence">
+            <summary>
+            Announce that parsing has begun.  Not technically useful except for
+            sending events over a socket.  A GUI for example will launch a thread
+            to connect and communicate with a remote parser.  The thread will want
+            to notify the GUI when a connection is made.  ANTLR parsers
+            trigger this upon entry to the first rule (the ruleLevel is used to
+            figure this out).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Terminate">
+            <summary>
+            Parsing is over; successfully or not.  Mostly useful for telling
+            remote debugging listeners that it's time to quit.  When the rule
+            invocation level goes to zero at the end of a rule, we are done
+            parsing.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeNode(System.Object)">
+            <summary>
+              Input for a tree parser is an AST, but we know nothing for sure
+              about a node except its type and text (obtained from the adaptor).
+              This is the analog of the consumeToken method.  Again, the ID is
+              the hashCode usually of the node so it only works if hashCode is
+              not implemented.  If the type is UP or DOWN, then
+              the ID is not really meaningful as it's fixed--there is
+              just one UP node and one DOWN navigation node.
+              </summary>
+            
+              <param name="t" />
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.LT(System.Int32,System.Object)">
+            <summary>
+            The tree parser lookedahead.  If the type is UP or DOWN,
+            then the ID is not really meaningful as it's fixed--there is
+            just one UP node and one DOWN navigation node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.NilNode(System.Object)">
+            <summary>
+              A nil was created (even nil nodes have a unique ID...
+              they are not "null" per se).  As of 4/28/2006, this
+              seems to be uniquely triggered when starting a new subtree
+              such as when entering a subrule in automatic mode and when
+              building a tree in rewrite mode.
+              </summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only t.ID is set.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ErrorNode(System.Object)">
+            <summary>
+              Upon syntax error, recognizers bracket the error with an error node
+              if they are building ASTs.
+              </summary>
+            
+              <param name="t"/>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.CreateNode(System.Object)">
+            <summary>Announce a new node built from token elements such as type etc...</summary>
+            
+             <remarks>
+             If you are receiving this event over a socket via
+             RemoteDebugEventSocketListener then only t.ID, type, text are
+             set.
+             </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.CreateNode(System.Object,Antlr.Runtime.IToken)">
+            <summary>Announce a new node built from an existing token.</summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only node.ID and token.tokenIndex
+              are set.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.BecomeRoot(System.Object,System.Object)">
+            <summary>Make a node the new root of an existing root.  See</summary>
+            
+              <remarks>
+              Note: the newRootID parameter is possibly different
+              than the TreeAdaptor.becomeRoot() newRoot parameter.
+              In our case, it will always be the result of calling
+              TreeAdaptor.becomeRoot() and not root_n or whatever.
+            
+              The listener should assume that this event occurs
+              only when the current subrule (or rule) subtree is
+              being reset to newRootID.
+             
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only IDs are set.
+              </remarks>
+            
+              <seealso cref="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(System.Object,System.Object)"/>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.AddChild(System.Object,System.Object)">
+            <summary>Make childID a child of rootID.</summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only IDs are set.
+              </remarks>
+            
+              <seealso cref="M:Antlr.Runtime.Tree.ITreeAdaptor.AddChild(System.Object,System.Object)"/>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.SetTokenBoundaries(System.Object,System.Int32,System.Int32)">
+            <summary>Set the token start/stop token index for a subtree root or node.</summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only t.ID is set.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.DFA">
+            <summary>A DFA implemented as a set of transition tables.</summary>
+            
+              <remarks>
+              Any state that has a semantic predicate edge is special; those states
+              are generated with if-then-else structures in a specialStateTransition()
+              which is generated by cyclicDFA template.
+            
+              There are at most 32767 states (16-bit signed short).
+              Could get away with byte sometimes but would have to generate different
+              types and the simulation code too.  For a point of reference, the Java
+              lexer's Tokens rule DFA has 326 states roughly.
+              </remarks>
+        </member>
+        <member name="F:Antlr.Runtime.DFA.recognizer">
+            <summary>Which recognizer encloses this DFA?  Needed to check backtracking</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.DFA.Predict(Antlr.Runtime.IIntStream)">
+            <summary>
+            From the input stream, predict what alternative will succeed
+            using this DFA (representing the covering regular approximation
+            to the underlying CFL).  Return an alternative number 1..n.  Throw
+            an exception upon error.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.DFA.Error(Antlr.Runtime.NoViableAltException)">
+            <summary>A hook for debugging interface</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.DFA.UnpackEncodedString(System.String)">
+            <summary>
+            Given a String that has a run-length-encoding of some unsigned shorts
+            like "\1\2\3\9", convert to short[] {2,9,9,9}.  We do this to avoid
+            static short[] which generates so much init code that the class won't
+            compile. :(
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.DFA.UnpackEncodedStringToUnsignedChars(System.String)">
+            <summary>Hideous duplication of code, but I need different typed arrays out :(</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.EarlyExitException">
+            <summary>The recognizer did not match anything for a (..)+ loop.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.FailedPredicateException">
+            <summary>
+            A semantic predicate failed during validation.  Validation of predicates
+            occurs when normally parsing the alternative just like matching a token.
+            Disambiguating predicate evaluation occurs when we hoist a predicate into
+            a prediction decision.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.IAstRuleReturnScope">
+            <summary>AST rules have trees</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IAstRuleReturnScope.Tree">
+            <summary>Has a value potentially if output=AST;</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.IAstRuleReturnScope`1">
+            <summary>AST rules have trees</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IAstRuleReturnScope`1.Tree">
+            <summary>Has a value potentially if output=AST;</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.ICharStream">
+            <summary>A source of characters for an ANTLR lexer</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ICharStream.Substring(System.Int32,System.Int32)">
+            <summary>
+            For infinite streams, you don't need this; primarily I'm providing
+            a useful interface for action code.  Just make sure actions don't
+            use this on streams that don't support it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ICharStream.LT(System.Int32)">
+            <summary>
+            Get the ith character of lookahead.  This is the same usually as
+            LA(i).  This will be used for labels in the generated
+            lexer code.  I'd prefer to return a char here type-wise, but it's
+            probably better to be 32-bit clean and be consistent with LA.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.ICharStream.Line">
+            <summary>ANTLR tracks the line information automatically</summary> 
+            <summary>Because this stream can rewind, we need to be able to reset the line</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.ICharStream.CharPositionInLine">
+            <summary>The index of the character relative to the beginning of the line 0..n-1</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.IIntStream">
+            <summary>
+            A simple stream of integers used when all I care about is the char
+            or token type sequence (such as interpretation).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.LA(System.Int32)">
+            <summary>
+            Get int at current input pointer + i ahead where i=1 is next int.
+            Negative indexes are allowed.  LA(-1) is previous token (token
+            just matched).  LA(-i) where i is before first token should
+            yield -1, invalid char / EOF.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Mark">
+            <summary>
+            Tell the stream to start buffering if it hasn't already.  Return
+            current input position, Index, or some other marker so that
+            when passed to rewind() you get back to the same spot.
+            rewind(mark()) should not affect the input cursor.  The Lexer
+            track line/col info as well as input index so its markers are
+            not pure input indexes.  Same for tree node streams.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IIntStream.Index">
+            <summary>
+            Return the current input symbol index 0..n where n indicates the
+            last symbol has been read.  The index is the symbol about to be
+            read not the most recently read symbol.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Rewind(System.Int32)">
+            <summary>
+            Reset the stream so that next call to index would return marker.
+            The marker will usually be Index but it doesn't have to be.  It's
+            just a marker to indicate what state the stream was in.  This is
+            essentially calling release() and seek().  If there are markers
+            created after this marker argument, this routine must unroll them
+            like a stack.  Assume the state the stream was in when this marker
+            was created.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Rewind">
+            <summary>
+            Rewind to the input position of the last marker.
+            Used currently only after a cyclic DFA and just
+            before starting a sem/syn predicate to get the
+            input position back to the start of the decision.
+            Do not "pop" the marker off the state.  mark(i)
+            and rewind(i) should balance still. It is
+            like invoking rewind(last marker) but it should not "pop"
+            the marker off.  It's like seek(last marker's input position).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Release(System.Int32)">
+            <summary>
+            You may want to commit to a backtrack but don't want to force the
+            stream to keep bookkeeping objects around for a marker that is
+            no longer necessary.  This will have the same behavior as
+            rewind() except it releases resources without the backward seek.
+            This must throw away resources for all markers back to the marker
+            argument.  So if you're nested 5 levels of mark(), and then release(2)
+            you have to release resources for depths 2..5.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Seek(System.Int32)">
+            <summary>
+              Set the input cursor to the position indicated by index.  This is
+              normally used to seek ahead in the input stream.  No buffering is
+              required to do this unless you know your stream will use seek to
+              move backwards such as when backtracking.
+              </summary>
+            
+              <remarks>
+              This is different from rewind in its multi-directional
+              requirement and in that its argument is strictly an input cursor (index).
+            
+              For char streams, seeking forward must update the stream state such
+              as line number.  For seeking backwards, you will be presumably
+              backtracking using the mark/rewind mechanism that restores state and
+              so this method does not need to update state when seeking backwards.
+            
+              Currently, this method is only used for efficient backtracking using
+              memoization, but in the future it may be used for incremental parsing.
+            
+              The index is 0..n-1.  A seek to position i means that LA(1) will
+              return the ith symbol.  So, seeking to 0 means LA(1) will return the
+              first element in the stream. 
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.IIntStream.Count">
+            <summary>
+            Only makes sense for streams that buffer everything up probably, but
+            might be useful to display the entire stream or for testing.  This
+            value includes a single EOF.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IIntStream.SourceName">
+            <summary>
+            Where are you getting symbols from?  Normally, implementations will
+            pass the buck all the way to the lexer who can ask its input stream
+            for the file name or whatever.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.IRuleReturnScope">
+            <summary>
+            Rules can have start/stop info.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope.Start">
+            <summary>
+            Gets the start element from the input stream
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope.Stop">
+            <summary>
+            Gets the stop element from the input stream
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.IRuleReturnScope`1">
+            <summary>
+            Rules can have start/stop info.
+            </summary>
+            <typeparam name="TLabel">The element type of the input stream.</typeparam>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope`1.Start">
+            <summary>
+            Gets the start element from the input stream
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope`1.Stop">
+            <summary>
+            Gets the stop element from the input stream
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IToken.Text">
+            <summary>Get the text of the token</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IToken.Line">
+            <summary>The line number on which this token was matched; line=1..n</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IToken.CharPositionInLine">
+            <summary>The index of the first character relative to the beginning of the line 0..n-1</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IToken.TokenIndex">
+            <summary>
+            An index from 0..n-1 of the token object in the input stream.
+            This must be valid in order to use the ANTLRWorks debugger.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IToken.InputStream">
+            <summary>
+            From what character stream was this token created?  You don't have to
+            implement but it's nice to know where a Token comes from if you have
+            include files etc... on the input.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.ITokenSource">
+            <summary>
+              A source of tokens must provide a sequence of tokens via nextToken()
+              and also must reveal it's source of characters; CommonToken's text is
+              computed from a CharStream; it only store indices into the char stream.
+              </summary>
+            
+              <remarks>
+              Errors from the lexer are never passed to the parser.  Either you want
+              to keep going or you do not upon token recognition error.  If you do not
+              want to continue lexing then you do not want to continue parsing.  Just
+              throw an exception not under RecognitionException and Java will naturally
+              toss you all the way out of the recognizers.  If you want to continue
+              lexing then you should not throw an exception to the parser--it has already
+              requested a token.  Keep lexing until you get a valid one.  Just report
+              errors and keep going, looking for a valid token.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenSource.NextToken">
+            <summary>
+            Return a Token object from your input stream (usually a CharStream).
+            Do not fail/return upon lexing error; keep chewing on the characters
+            until you get a good one; errors are not passed through to the parser.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.ITokenSource.SourceName">
+            <summary>
+            Where are you getting tokens from? normally the implication will simply
+            ask lexers input stream.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.ITokenStream">
+            <summary>A stream of tokens accessing tokens from a TokenSource</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.LT(System.Int32)">
+            <summary>Get Token at current input pointer + i ahead where i=1 is next Token.
+            i&lt;0 indicates tokens in the past.  So -1 is previous token and -2 is
+            two tokens ago. LT(0) is undefined.  For i&gt;=n, return Token.EOFToken.
+            Return null for LT(0) and any index that results in an absolute address
+            that is negative.</summary>
+        </member>
+        <member name="P:Antlr.Runtime.ITokenStream.Range">
+            <summary>
+            How far ahead has the stream been asked to look?  The return
+            value is a valid index from 0..n-1.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.Get(System.Int32)">
+            <summary>
+            Get a token at an absolute index i; 0..n-1.  This is really only
+            needed for profiling and debugging and token stream rewriting.
+            If you don't want to buffer up tokens, then this method makes no
+            sense for you.  Naturally you can't use the rewrite stream feature.
+            I believe DebugTokenStream can easily be altered to not use
+            this method, removing the dependency.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.ITokenStream.TokenSource">
+            <summary>
+            Where is this stream pulling tokens from?  This is not the name, but
+            the object that provides Token objects.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.ToString(System.Int32,System.Int32)">
+            <summary>
+            Return the text of all tokens from start to stop, inclusive.
+            If the stream does not buffer all the tokens then it can just
+            return "" or null;  Users should not access $ruleLabel.text in
+            an action of course in that case.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.ToString(Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
+            <summary>
+            Because the user is not required to use a token with an index stored
+            in it, we must provide a means for two token objects themselves to
+            indicate the start/end location.  Most often this will just delegate
+            to the other toString(int,int).  This is also parallel with
+            the TreeNodeStream.toString(Object,Object).
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.LegacyCommonTokenStream">
+            <summary>
+              The most common stream of tokens is one where every token is buffered up
+              and tokens are prefiltered for a certain channel (the parser will only
+              see these tokens and cannot change the filter channel number during the
+              parse).
+              </summary>
+            
+              <remarks>TODO: how to access the full token stream?  How to track all tokens matched per rule?</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.tokens">
+            <summary>
+            Record every single token pulled from the source so we can reproduce
+            chunks of it later.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.channelOverrideMap">
+            <summary>Map from token type to channel to override some Tokens' channel numbers</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.discardSet">
+            <summary>Set of token types; discard any tokens with this type</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.channel">
+            <summary>Skip tokens on any channel but this one; this is how we skip whitespace...</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.discardOffChannelTokens">
+            <summary>By default, track all incoming tokens</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.p">
+            <summary>
+            The index into the tokens list of the current token (next token
+            to consume).  p==-1 indicates that the tokens list is empty
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.LegacyCommonTokenStream.Range">
+            <summary>
+            How deep have we gone?
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.SetTokenSource(Antlr.Runtime.ITokenSource)">
+            <summary>Reset this token stream by setting its token source.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.FillBuffer">
+            <summary>
+            Load all tokens from the token source and put in tokens.
+            This is done upon first LT request because you might want to
+            set some token type / channel overrides before filling buffer.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.Consume">
+            <summary>
+              Move the input pointer to the next incoming token.  The stream
+              must become active with LT(1) available.  consume() simply
+              moves the input pointer so that LT(1) points at the next
+              input symbol. Consume at least one token.
+              </summary>
+            
+              <remarks>
+              Walk past any token not on the channel the parser is listening to.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.SkipOffTokenChannels(System.Int32)">
+            <summary>Given a starting index, return the index of the first on-channel token.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.SetTokenTypeChannel(System.Int32,System.Int32)">
+            <summary>
+            A simple filter mechanism whereby you can tell this token stream
+            to force all tokens of type ttype to be on channel.  For example,
+            when interpreting, we cannot exec actions so we need to tell
+            the stream to force all WS and NEWLINE to be a different, ignored
+            channel.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.GetTokens(System.Int32,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>
+            Given a start and stop index, return a List of all tokens in
+            the token type BitSet.  Return null if no tokens were found.  This
+            method looks at both on and off channel tokens.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.LT(System.Int32)">
+            <summary>
+            Get the ith token from the current position 1..n where k=1 is the
+            first symbol of lookahead.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.LB(System.Int32)">
+            <summary>Look backwards k tokens on-channel tokens</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.Get(System.Int32)">
+            <summary>
+            Return absolute token i; ignore which channel the tokens are on;
+            that is, count all tokens not just on-channel tokens.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Lexer">
+            <summary>
+            A lexer is recognizer that draws input symbols from a character stream.
+            lexer grammars result in a subclass of this object. A Lexer object
+            uses simplified match() and error recovery mechanisms in the interest
+            of speed.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Lexer.input">
+            <summary>Where is the lexer drawing characters from?</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Lexer.Text">
+            <summary>
+            Gets or sets the text matched so far for the current token or any text override.
+            </summary>
+            <remarks>
+            <para>Setting this value replaces any previously set value, and overrides the original text.</para>
+            </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.NextToken">
+            <summary>Return a token from this source; i.e., match a token on the char stream.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.GetEndOfFileToken">
+            Returns the EOF token (default), if you need
+            to return a custom token instead override this method.
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Skip">
+            <summary>
+            Instruct the lexer to skip creating a token for current lexer rule
+            and look for another token.  nextToken() knows to keep looking when
+            a lexer rule finishes with token set to SKIP_TOKEN.  Recall that
+            if token==null at end of any token rule, it creates one for you
+            and emits it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.mTokens">
+            <summary>This is the lexer entry point that sets instance var 'token'</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Emit(Antlr.Runtime.IToken)">
+            <summary>
+            Currently does not support multiple emits per nextToken invocation
+            for efficiency reasons.  Subclass and override this method and
+            nextToken (to push tokens into a list and pull from that list rather
+            than a single variable as this implementation does).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Emit">
+            <summary>
+              The standard method called to automatically emit a token at the
+              outermost lexical rule.  The token object should point into the
+              char buffer start..stop.  If there is a text override in 'text',
+              use that to set the token's text.  Override this method to emit
+              custom Token objects.
+              </summary>
+            
+              <remarks>
+              If you are building trees, then you should also override
+              Parser or TreeParser.getMissingSymbol().
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.Lexer.CharIndex">
+            <summary>What is the index of the current character of lookahead?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Recover(Antlr.Runtime.RecognitionException)">
+            <summary>
+            Lexers can normally match any char in it's vocabulary after matching
+            a token, so do the easy thing and just kill a character and hope
+            it all works out.  You can instead use the rule invocation stack
+            to do sophisticated error recovery if you are in a fragment rule.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Misc.FastQueue`1">
+            A queue that can dequeue and get(i) in O(1) and grow arbitrarily large.
+              A linked list is fast at dequeue but slow at get(i).  An array is
+              the reverse.  This is O(1) for both operations.
+            
+              List grows until you dequeue last element at end of buffer. Then
+              it resets to start filling at 0 again.  If adds/removes are balanced, the
+              buffer will not grow too large.
+            
+              No iterator stuff as that's not how we'll use it.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.FastQueue`1._data">
+            <summary>dynamically-sized buffer of elements</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Misc.FastQueue`1._p">
+            <summary>index of next element to fill</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Misc.FastQueue`1.Range">
+            <summary>
+            How deep have we gone?
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Misc.FastQueue`1.Item(System.Int32)">
+            <summary>
+            Return element {@code i} elements ahead of current element. {@code i==0}
+            gets current element. This is not an absolute index into {@link #data}
+            since {@code p} defines the start of the real list.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Misc.FastQueue`1.Dequeue">
+            <summary>Get and remove first element in queue</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.FastQueue`1.ToString">
+            <summary>Return string of current buffer contents; non-destructive</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Misc.LookaheadStream`1">
+            <summary>
+            A lookahead queue that knows how to mark/release locations in the buffer for
+            backtracking purposes. Any markers force the {@link FastQueue} superclass to
+            keep all elements until no more markers; then can reset to avoid growing a
+            huge buffer.
+             </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._currentElementIndex">
+            Absolute token index. It's the index of the symbol about to be
+            read via {@code LT(1)}. Goes from 0 to numtokens.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._previousElement">
+            This is the {@code LT(-1)} element for the first element in {@link #data}.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._eof">
+            Track object returned by nextElement upon end of stream;
+            Return it later when they ask for LT passed end of input.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._markDepth">
+            <summary>tracks how deep mark() calls are nested</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.NextElement">
+            <summary>
+            Implement nextElement to supply a stream of elements to this
+            lookahead buffer.  Return EOF upon end of the stream we're pulling from.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Dequeue">
+            <summary>
+            Get and remove first element in queue; override
+            {@link FastQueue#remove()}; it's the same, just checks for backtracking.
+            </summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Consume">
+            <summary>Make sure we have at least one element to remove, even if EOF</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.SyncAhead(System.Int32)">
+            <summary>
+            Make sure we have 'need' elements from current position p. Last valid
+            p index is data.size()-1.  p+need-1 is the data index 'need' elements
+            ahead.  If we need 1 element, (p+1-1)==p must be &lt; data.size().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Fill(System.Int32)">
+            <summary>add n elements to buffer</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Misc.LookaheadStream`1.Count">
+            <summary>Size of entire stream is unknown; we only know buffer size from FastQueue</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Seek(System.Int32)">
+            <summary>
+            Seek to a 0-indexed absolute token index. Normally used to seek backwards
+            in the buffer. Does not force loading of nodes.
+             </summary>
+             <remarks>
+            To preserve backward compatibility, this method allows seeking past the
+            end of the currently buffered data. In this case, the input pointer will
+            be moved but the data will only actually be loaded upon the next call to
+            {@link #consume} or {@link #LT} for {@code k>0}.
+             </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.MismatchedTokenException">
+            <summary>A mismatched char or Token or tree node</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.MissingTokenException">
+            <summary>
+            We were expecting a token but it's not found.  The current token
+            is actually what we wanted next.  Used for tree node errors too.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Parser">
+            <summary>
+            A parser for TokenStreams.  "parser grammars" result in a subclass
+            of this.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Parser.TokenStream">
+            <summary>Gets or sets the token stream; resets the parser upon a set.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.ParserRuleReturnScope`1">
+            <summary>
+              Rules that return more than a single value must return an object
+              containing all the values.  Besides the properties defined in
+              RuleLabelScope.predefinedRulePropertiesScope there may be user-defined
+              return values.  This class simply defines the minimum properties that
+              are always defined and methods to access the others that might be
+              available depending on output option such as template and tree.
+              </summary>
+            
+              <remarks>
+              Note text is not an actual property of the return value, it is computed
+              from start and stop using the input stream's toString() method.  I
+              could add a ctor to this so that we can pass in and store the input
+              stream, but I'm not sure we want to do that.  It would seem to be undefined
+              to get the .text property anyway if the rule matches tokens from multiple
+              input streams.
+            
+              I do not use getters for fields of objects that are used simply to
+              group values such as this aggregate.  The getters/setters are there to
+              satisfy the superclass interface.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.RecognitionException">
+            <summary>The root of the ANTLR exception hierarchy.</summary>
+            
+              <remarks>
+              To avoid English-only error messages and to generally make things
+              as flexible as possible, these exceptions are not created with strings,
+              but rather the information necessary to generate an error.  Then
+              the various reporting methods in Parser and Lexer can be overridden
+              to generate a localized error message.  For example, MismatchedToken
+              exceptions are built with the expected token type.
+              So, don't expect getMessage() to return anything.
+            
+              Note that as of Java 1.4, you can access the stack trace, which means
+              that you can compute the complete trace of rules from the start symbol.
+              This gives you considerable context information with which to generate
+              useful error messages.
+            
+              ANTLR generates code that throws exceptions upon recognition error and
+              also generates code to catch these exceptions in each rule.  If you
+              want to quit upon first error, you can turn off the automatic error
+              handling mechanism using rulecatch action, but you still need to
+              override methods mismatch and recoverFromMismatchSet.
+            
+              In general, the recognition exceptions can track where in a grammar a
+              problem occurred and/or what was the expected input.  While the parser
+              knows its state (such as current input symbol and line info) that
+              state can change before the exception is reported so current token index
+              is computed and stored at exception time.  From this info, you can
+              perhaps print an entire line of input not just a single token, for example.
+              Better to just say the recognizer had a problem and then let the parser
+              figure out a fancy report.
+              </remarks>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._input">
+            <summary>What input stream did the error occur in?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._k">
+            <summary>
+            What was the lookahead index when this exception was thrown?
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._index">
+            <summary>What is index of token/char were we looking at when the error occurred?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._token">
+            <summary>
+            The current Token when an error occurred.  Since not all streams
+            can retrieve the ith Token, we have to track the Token object.
+            For parsers.  Even when it's a tree parser, token might be set.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._node">
+            <summary>
+            If this is a tree parser exception, node is set to the node with
+            the problem.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._c">
+            <summary>The current char when an error occurred. For lexers.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._line">
+            <summary>
+            Track the line (1-based) at which the error occurred in case this is
+            generated from a lexer.  We need to track this since the
+            unexpected char doesn't carry the line info.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._charPositionInLine">
+            <summary>
+            The 0-based index into the line where the error occurred.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._approximateLineInfo">
+            <summary>
+            If you are parsing a tree node stream, you will encounter som
+            imaginary nodes w/o line/col info.  We now search backwards looking
+            for most recent token with line/col info, but notify getErrorHeader()
+            that info is approximate.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.RecognitionException.#ctor">
+            <summary>Used for remote debugger deserialization</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.RecognitionException.UnexpectedType">
+            <summary>Return the token type or char of the unexpected input element</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.RecognizerSharedState">
+            <summary>
+              The set of fields needed by an abstract recognizer to recognize input
+              and recover from errors etc...  As a separate state object, it can be
+              shared among multiple grammars; e.g., when one grammar imports another.
+              </summary>
+            
+              <remarks>
+              These fields are publically visible but the actual state pointer per
+              parser is protected.
+              </remarks>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.following">
+            <summary>
+            Track the set of token types that can follow any rule invocation.
+            Stack grows upwards.  When it hits the max, it grows 2x in size
+            and keeps going.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.errorRecovery">
+            <summary>
+            This is true when we see an error and before having successfully
+            matched a token.  Prevents generation of more than one error message
+            per error.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.lastErrorIndex">
+            <summary>
+             The index into the input stream where the last error occurred.
+            	This is used to prevent infinite loops where an error is found
+             but no token is consumed during recovery...another error is found,
+             ad naseum.  This is a failsafe mechanism to guarantee that at least
+             one token/tree node is consumed for two errors.
+             </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.failed">
+            <summary>
+            In lieu of a return value, this indicates that a rule or token
+            has failed to match.  Reset to false upon valid token match.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.syntaxErrors">
+            <summary>Did the recognizer encounter a syntax error?  Track how many.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.backtracking">
+            <summary>
+            If 0, no backtracking is going on.  Safe to exec actions etc...
+            If >0 then it's the level of backtracking.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.ruleMemo">
+            <summary>
+              An array[size num rules] of dictionaries that tracks
+              the stop token index for each rule.  ruleMemo[ruleIndex] is
+              the memoization table for ruleIndex.  For key ruleStartIndex, you
+              get back the stop token for associated rule or MEMO_RULE_FAILED.
+              </summary>
+            
+              <remarks>This is only used if rule memoization is on (which it is by default).</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.token">
+            <summary>
+            The goal of all lexer rules/methods is to create a token object.
+            This is an instance variable as multiple rules may collaborate to
+            create a single token.  nextToken will return this object after
+            matching lexer rule(s).  If you subclass to allow multiple token
+            emissions, then set this to the last token to be matched or
+            something nonnull so that the auto token emit mechanism will not
+            emit another token.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartCharIndex">
+            <summary>
+            What character index in the stream did the current token start at?
+            Needed, for example, to get the text for current token.  Set at
+            the start of nextToken.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartLine">
+            <summary>The line on which the first character of the token resides</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartCharPositionInLine">
+            <summary>The character position of first character within the line</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.channel">
+            <summary>The channel number for the current token</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.type">
+            <summary>The token type for the current token</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.text">
+            <summary>
+            You can set the text for the current token to override what is in
+            the input char buffer.  Use setText() or can set this instance var.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenChannels.Default">
+            <summary>
+            All tokens go to the parser (unless skip() is called in that rule)
+            on a particular "channel".  The parser tunes to a particular channel
+            so that whitespace etc... can go to the parser on a "hidden" channel.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenChannels.Hidden">
+            <summary>
+            Anything on different channel than DEFAULT_CHANNEL is not parsed
+            by parser.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.TokenRewriteStream">
+            Useful for dumping out the input stream after doing some
+              augmentation or other manipulations.
+            
+              You can insert stuff, replace, and delete chunks.  Note that the
+              operations are done lazily--only if you convert the buffer to a
+              String.  This is very efficient because you are not moving data around
+              all the time.  As the buffer of tokens is converted to strings, the
+              toString() method(s) check to see if there is an operation at the
+              current index.  If so, the operation is done and then normal String
+              rendering continues on the buffer.  This is like having multiple Turing
+              machine instruction streams (programs) operating on a single input tape. :)
+            
+              Since the operations are done lazily at toString-time, operations do not
+              screw up the token index values.  That is, an insert operation at token
+              index i does not change the index values for tokens i+1..n-1.
+            
+              Because operations never actually alter the buffer, you may always get
+              the original token stream back without undoing anything.  Since
+              the instructions are queued up, you can easily simulate transactions and
+              roll back any changes if there is an error just by removing instructions.
+              For example,
+            
+               CharStream input = new ANTLRFileStream("input");
+               TLexer lex = new TLexer(input);
+               TokenRewriteStream tokens = new TokenRewriteStream(lex);
+               T parser = new T(tokens);
+               parser.startRule();
+            
+             	 Then in the rules, you can execute
+                  Token t,u;
+                  ...
+                  input.insertAfter(t, "text to put after t");}
+             		input.insertAfter(u, "text after u");}
+             		System.out.println(tokens.toString());
+            
+              Actually, you have to cast the 'input' to a TokenRewriteStream. :(
+            
+              You can also have multiple "instruction streams" and get multiple
+              rewrites from a single pass over the input.  Just name the instruction
+              streams and use that name again when printing the buffer.  This could be
+              useful for generating a C file and also its header file--all from the
+              same buffer:
+            
+                  tokens.insertAfter("pass1", t, "text to put after t");}
+             		tokens.insertAfter("pass2", u, "text after u");}
+             		System.out.println(tokens.toString("pass1"));
+             		System.out.println(tokens.toString("pass2"));
+            
+              If you don't use named rewrite streams, a "default" stream is used as
+              the first example shows.
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.RewriteOperation.instructionIndex">
+            <summary>What index into rewrites List are we?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.RewriteOperation.index">
+            <summary>Token buffer index.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.RewriteOperation.Execute(System.Text.StringBuilder)">
+            <summary>
+            Execute the rewrite operation by possibly adding to the buffer.
+            Return the index of the next token to operate on.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.TokenRewriteStream.ReplaceOp">
+            <summary>
+            I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp
+            instructions.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.programs">
+            <summary>
+            You may have multiple, named streams of rewrite operations.
+            I'm calling these things "programs."
+            Maps String (name) -> rewrite (List)
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.lastRewriteTokenIndexes">
+            <summary>Map String (program name) -> Integer index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.Rollback(System.String,System.Int32)">
+            <summary>
+            Rollback the instruction stream for a program so that
+            the indicated instruction (via instructionIndex) is no
+            longer in the stream.  UNTESTED!
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.DeleteProgram(System.String)">
+            <summary>Reset the program so that no instructions exist</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.ReduceToSingleOperationPerIndex(System.Collections.Generic.IList{Antlr.Runtime.TokenRewriteStream.RewriteOperation})">
+            We need to combine operations and report invalid operations (like
+              overlapping replaces that are not completed nested).  Inserts to
+              same index need to be combined etc...   Here are the cases:
+            
+              I.i.u I.j.v								leave alone, nonoverlapping
+              I.i.u I.i.v								combine: Iivu
+            
+              R.i-j.u R.x-y.v	| i-j in x-y			delete first R
+              R.i-j.u R.i-j.v							delete first R
+              R.i-j.u R.x-y.v	| x-y in i-j			ERROR
+              R.i-j.u R.x-y.v	| boundaries overlap	ERROR
+            
+              Delete special case of replace (text==null):
+              D.i-j.u D.x-y.v	| boundaries overlap	combine to max(min)..max(right)
+            
+              I.i.u R.x-y.v | i in (x+1)-y			delete I (since insert before
+            											we're not deleting i)
+              I.i.u R.x-y.v | i not in (x+1)-y		leave alone, nonoverlapping
+              R.x-y.v I.i.u | i in x-y				ERROR
+              R.x-y.v I.x.u 							R.x-y.uv (combine, delete I)
+              R.x-y.v I.i.u | i not in x-y			leave alone, nonoverlapping
+            
+              I.i.u = insert u before op @ index i
+              R.x-y.u = replace x-y indexed tokens with u
+            
+              First we need to examine replaces.  For any replace op:
+            
+             		1. wipe out any insertions before op within that range.
+            		2. Drop any replace op before that is contained completely within
+                     that range.
+            		3. Throw exception upon boundary overlap with any previous replace.
+            
+              Then we can deal with inserts:
+            
+             		1. for any inserts to same index, combine even if not adjacent.
+             		2. for any prior replace with same left boundary, combine this
+                     insert with replace and delete this replace.
+             		3. throw exception if index in same range as previous replace
+            
+              Don't actually delete; make op null in list. Easier to walk list.
+              Later we can throw as we add to index -> op map.
+            
+              Note that I.2 R.2-2 will wipe out I.2 even though, technically, the
+              inserted stuff would be before the replace range.  But, if you
+              add tokens in front of a method body '{' and then delete the method
+              body, I think the stuff before the '{' you added should disappear too.
+            
+              Return a map from token index to operation.
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.GetKindOfOps(System.Collections.Generic.IList{Antlr.Runtime.TokenRewriteStream.RewriteOperation},System.Type,System.Int32)">
+            <summary>Get all operations before an index of a particular kind</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tokens.Skip">
+            <summary>
+            In an action, a lexer rule can set token to this SKIP_TOKEN and ANTLR
+            will avoid creating a token for this symbol and try to fetch another.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenTypes.Down">
+            <summary>imaginary tree navigation type; traverse "get child" link</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.TokenTypes.Up">
+            <summary>imaginary tree navigation type; finish with a child list</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.BaseTree">
+            <summary>
+            A generic tree implementation with no payload.  You must subclass to
+            actually have any user data.  ANTLR v3 uses a list of children approach
+            instead of the child-sibling approach in v2.  A flat tree (a list) is
+            an empty node whose children represent the list.  An empty, but
+            non-null node is called "nil".
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.#ctor(Antlr.Runtime.Tree.ITree)">
+            <summary>
+            Create a new node from an existing node does nothing for BaseTree
+            as there are no fields other than the children list, which cannot
+            be copied as the children are not considered part of this node. 
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.BaseTree.Children">
+            <summary>
+            Get the children internal List; note that if you directly mess with
+            the list, do so at your own risk.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.BaseTree.Parent">
+            <summary>BaseTree doesn't track parent pointers.</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Tree.BaseTree.ChildIndex">
+            <summary>BaseTree doesn't track child indexes.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.AddChild(Antlr.Runtime.Tree.ITree)">
+            <summary>Add t as child of this node.</summary>
+            
+              <remarks>
+              Warning: if t has no children, but child does
+              and child isNil then this routine moves children to t via
+              t.children = child.children; i.e., without copying the array.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.AddChildren(System.Collections.Generic.IEnumerable{Antlr.Runtime.Tree.ITree})">
+            <summary>Add all elements of kids list as children of this node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.InsertChild(System.Int32,Antlr.Runtime.Tree.ITree)">
+            Insert child t at child position i (0..n-1) by shifting children
+            i+1..n-1 to the right one position. Set parent / indexes properly
+            but does NOT collapse nil-rooted t's that come in here like addChild.
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.ReplaceChildren(System.Int32,System.Int32,System.Object)">
+            <summary>
+            Delete children from start to stop and replace with t even if t is
+            a list (nil-root tree).  num of children can increase or decrease.
+            For huge child lists, inserting children can force walking rest of
+            children to set their childindex; could be slow.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.CreateChildrenList">
+            <summary>Override in a subclass to change the impl of children list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.FreshenParentAndChildIndexes">
+            <summary>Set the parent and child index values for all child of t</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.HasAncestor(System.Int32)">
+            <summary>Walk upwards looking for ancestor with this token type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.GetAncestor(System.Int32)">
+            <summary>Walk upwards and get first ancestor with this token type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.GetAncestors">
+            <summary>
+            Return a list of all ancestors of this node.  The first node of
+            list is the root and the last is the parent of this node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.ToStringTree">
+            <summary>Print out a whole tree not just a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.ToString">
+            <summary>Override to say how a node (not a tree) should look as text</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.BaseTreeAdaptor">
+            <summary>A TreeAdaptor that works with any Tree implementation.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BaseTreeAdaptor.treeToUniqueIDMap">
+            <summary>
+            System.identityHashCode() is not always unique; we have to
+            track ourselves.  That's ok, it's only for debugging, though it's
+            expensive: we have to create a hashtable with all tree nodes in it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.ErrorNode(Antlr.Runtime.ITokenStream,Antlr.Runtime.IToken,Antlr.Runtime.IToken,Antlr.Runtime.RecognitionException)">
+            <summary>
+              Create tree node that holds the start and stop tokens associated
+              with an error.
+              </summary>
+            
+              <remarks>
+              If you specify your own kind of tree nodes, you will likely have to
+              override this method. CommonTree returns Token.INVALID_TOKEN_TYPE
+              if no token payload but you might have to set token type for diff
+              node type.
+            
+              You don't have to subclass CommonErrorNode; you will likely need to
+              subclass your own tree node class to avoid class cast exception.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.DupTree(System.Object,System.Object)">
+            <summary>
+            This is generic in the sense that it will work with any kind of
+            tree (not just ITree interface).  It invokes the adaptor routines
+            not the tree node routines to do the construction.  
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.AddChild(System.Object,System.Object)">
+            <summary>
+            Add a child to the tree t.  If child is a flat tree (a list), make all
+            in list children of t.  Warning: if t has no children, but child does
+            and child isNil then you can decide it is ok to move children to t via
+            t.children = child.children; i.e., without copying the array.  Just
+            make sure that this is consistent with have the user will build
+            ASTs.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.BecomeRoot(System.Object,System.Object)">
+            <summary>
+              If oldRoot is a nil root, just copy or move the children to newRoot.
+              If not a nil root, make oldRoot a child of newRoot.
+              </summary>
+            
+              <remarks>
+                old=^(nil a b c), new=r yields ^(r a b c)
+                old=^(a b c), new=r yields ^(r ^(a b c))
+            
+              If newRoot is a nil-rooted single child tree, use the single
+              child as the new root node.
+            
+                old=^(nil a b c), new=^(nil r) yields ^(r a b c)
+                old=^(a b c), new=^(nil r) yields ^(r ^(a b c))
+            
+              If oldRoot was null, it's ok, just return newRoot (even if isNil).
+            
+                old=null, new=r yields r
+                old=null, new=^(nil r) yields ^(nil r)
+            
+              Return newRoot.  Throw an exception if newRoot is not a
+              simple node or nil root with a single child node--it must be a root
+              node.  If newRoot is ^(nil x) return x as newRoot.
+            
+              Be advised that it's ok for newRoot to point at oldRoot's
+              children; i.e., you don't have to copy the list.  We are
+              constructing these nodes so we should have this control for
+              efficiency.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.RulePostProcessing(System.Object)">
+            <summary>Transform ^(nil x) to x and nil to null</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.CreateToken(System.Int32,System.String)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.CreateToken(Antlr.Runtime.IToken)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              This is a variant of createToken where the new token is derived from
+              an actual real input token.  Typically this is for converting '{'
+              tokens to BLOCK etc...  You'll see
+            
+                r : lc='{' ID+ '}' -> ^(BLOCK[$lc] ID+) ;
+            
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.DupNode(System.Object)">
+            <summary>
+              Duplicate a node.  This is part of the factory;
+              override if you want another kind of node to be built.
+              </summary>
+            
+              <remarks>
+              I could use reflection to prevent having to override this
+              but reflection is slow.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.SetTokenBoundaries(System.Object,Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
+            <summary>
+            Track start/stop token for subtree root created for a rule.
+            Only works with Tree nodes.  For rules that match nothing,
+            seems like this will yield start=i and stop=i-1 in a nil node.
+            Might be useful info so I'll not force to be i..i.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.BufferedTreeNodeStream">
+            <summary>A buffered stream of tree nodes.  Nodes can be from a tree of ANY kind.</summary>
+            
+              This node stream sucks all nodes out of the tree specified in
+              the constructor during construction and makes pointers into
+              the tree using an array of Object pointers. The stream necessarily
+              includes pointers to DOWN and UP and EOF nodes.
+            
+              This stream knows how to mark/release for backtracking.
+            
+              This stream is most suitable for tree interpreters that need to
+              jump around a lot or for tree parsers requiring speed (at cost of memory).
+              There is some duplicated functionality here with UnBufferedTreeNodeStream
+              but just in bookkeeping, not tree walking etc...
+            
+              TARGET DEVELOPERS:
+            
+              This is the old CommonTreeNodeStream that buffered up entire node stream.
+              No need to implement really as new CommonTreeNodeStream is much better
+              and covers what we need.
+            
+              @see CommonTreeNodeStream
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.nodes">
+            <summary>The complete mapping from stream index to tree node.
+              This buffer includes pointers to DOWN, UP, and EOF nodes.
+              It is built upon ctor invocation.  The elements are type
+              Object as we don't what the trees look like.</summary>
+            
+              Load upon first need of the buffer so we can set token types
+              of interest for reverseIndexing.  Slows us down a wee bit to
+              do all of the if p==-1 testing everywhere though.
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.root">
+            <summary>Pull nodes from which tree?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.tokens">
+            <summary>IF this tree (root) was created from a token stream, track it.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.adaptor">
+            <summary>What tree adaptor was used to build these trees</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.uniqueNavigationNodes">
+            <summary>Reuse same DOWN, UP navigation nodes unless this is true</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.p">
+            <summary>The index into the nodes list of the current node (next node
+            to consume).  If -1, nodes array not filled yet.</summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.calls">
+            <summary>Stack of indexes used for push/pop calls</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.FillBuffer">
+            Walk tree with depth-first-search and fill nodes buffer.
+            Don't do DOWN, UP nodes if its a list (t is isNil).
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.GetNodeIndex(System.Object)">
+            What is the stream index for node? 0..n-1
+            Return -1 if node not found.
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.AddNavigationNode(System.Int32)">
+            As we flatten the tree, we use UP, DOWN nodes to represent
+            the tree structure.  When debugging we need unique nodes
+            so instantiate new ones when uniqueNavigationNodes is true.
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.LB(System.Int32)">
+            <summary>Look backwards k nodes</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.Push(System.Int32)">
+            <summary>
+            Make stream jump to a new location, saving old location.
+            Switch back with pop().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.Pop">
+            <summary>
+            Seek back to previous index saved during last push() call.
+            Return top of stack (return index).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.ToTokenTypeString">
+            <summary>Used for testing, just return the token type stream</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.ToTokenString(System.Int32,System.Int32)">
+            <summary>Debugging</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.CommonErrorNode">
+            <summary>A node representing erroneous token range in token stream</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.CommonTree">
+            <summary>
+            A tree node that is wrapper for a Token object.  After 3.0 release
+            while building tree rewrite stuff, it became clear that computing
+            parent and child index is very difficult and cumbersome.  Better to
+            spend the space in every tree node.  If you don't want these extra
+            fields, it's easy to cut them out in your own BaseTree subclass.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree._token">
+            <summary>A single token is the payload</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree.startIndex">
+            <summary>
+            What token indexes bracket all tokens associated with this node
+            and below?
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree.parent">
+            <summary>Who is the parent node of this node; if null, implies node is root</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree.childIndex">
+            <summary>What index is this node in the child list? Range: 0..n-1</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTree.SetUnknownTokenBoundaries">
+            <summary>
+            For every node in this subtree, make sure it's start/stop token's
+            are set.  Walk depth first, visit bottom up.  Only updates nodes
+            with at least one token index &lt; 0.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.CommonTreeAdaptor">
+            <summary>
+              A TreeAdaptor that works with any Tree implementation.  It provides
+              really just factory methods; all the work is done by BaseTreeAdaptor.
+              If you would like to have different tokens created than ClassicToken
+              objects, you need to override this and then set the parser tree adaptor to
+              use your subclass.
+              </summary>
+            
+              <remarks>
+              To get your parser to build nodes of a different type, override
+              create(Token), errorNode(), and to be safe, YourTreeClass.dupNode().
+              dupNode is called to duplicate nodes during rewrite operations.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.CreateToken(System.Int32,System.String)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.CreateToken(Antlr.Runtime.IToken)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              This is a variant of createToken where the new token is derived from
+              an actual real input token.  Typically this is for converting '{'
+              tokens to BLOCK etc...  You'll see
+            
+                r : lc='{' ID+ '}' -> ^(BLOCK[$lc] ID+) ;
+            
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.GetToken(System.Object)">
+            <summary>
+            What is the Token associated with this node?  If
+            you are not using CommonTree, then you must
+            override this in your own adaptor.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._root">
+            <summary>Pull nodes from which tree?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream.tokens">
+            <summary>If this tree (root) was created from a token stream, track it.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._adaptor">
+            <summary>What tree adaptor was used to build these trees</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._it">
+            The tree iterator we are using 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._calls">
+            <summary>Stack of indexes used for push/pop calls</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._hasNilRoot">
+            <summary>Tree (nil A B C) trees like flat A B C streams</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._level">
+            <summary>Tracks tree depth.  Level=0 means we're at root node level.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._previousLocationElement">
+             Tracks the last node before the start of {@link #data} which contains
+             position information to provide information for error reporting. This is
+             tracked in addition to {@link #prevElement} which may or may not contain
+             position information.
+            
+             @see #hasPositionInformation
+             @see RecognitionException#extractInformationFromTreeNodeStream
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.Push(System.Int32)">
+            Make stream jump to a new location, saving old location.
+            Switch back with pop().
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.Pop">
+            Seek back to previous index saved during last push() call.
+            Return top of stack (return index).
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.GetKnownPositionElement(System.Boolean)">
+             Returns an element containing position information. If {@code allowApproximateLocation} is {@code false}, then
+             this method will return the {@code LT(1)} element if it contains position information, and otherwise return {@code null}.
+             If {@code allowApproximateLocation} is {@code true}, then this method will return the last known element containing position information.
+            
+             @see #hasPositionInformation
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.ToTokenTypeString">
+            <summary>For debugging; destructive: moves tree iterator to end.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.DotTreeGenerator">
+            A utility class to generate DOT diagrams (graphviz) from
+              arbitrary trees.  You can pass in your own templates and
+              can pass in any kind of tree or use Tree interface method.
+              I wanted this separator so that you don't have to include
+              ST just to use the org.antlr.runtime.tree.* package.
+              This is a set of non-static methods so you can subclass
+              to override.  For example, here is an invocation:
+            
+                  CharStream input = new ANTLRInputStream(System.in);
+                  TLexer lex = new TLexer(input);
+                  CommonTokenStream tokens = new CommonTokenStream(lex);
+                  TParser parser = new TParser(tokens);
+                  TParser.e_return r = parser.e();
+                  Tree t = (Tree)r.tree;
+                  System.out.println(t.toStringTree());
+                  DOTTreeGenerator gen = new DOTTreeGenerator();
+                  StringTemplate st = gen.toDOT(t);
+                  System.out.println(st);
+        </member>
+        <member name="F:Antlr.Runtime.Tree.DotTreeGenerator.nodeToNumberMap">
+            Track node to number mapping so we can get proper node name back 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.DotTreeGenerator.nodeNumber">
+            Track node number so we can get unique node names 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.DotTreeGenerator.ToDot(System.Object,Antlr.Runtime.Tree.ITreeAdaptor)">
+            Generate DOT (graphviz) for a whole tree not just a node.
+              For example, 3+4*5 should generate:
+            
+             digraph {
+               node [shape=plaintext, fixedsize=true, fontsize=11, fontname="Courier",
+                     width=.4, height=.2];
+               edge [arrowsize=.7]
+               "+"->3
+               "+"->"*"
+               "*"->4
+               "*"->5
+             }
+            
+             Takes a Tree interface object.
+        </member>
+        <member name="T:Antlr.Runtime.Tree.IPositionTrackingStream">
+            
+             @author Sam Harwell
+        </member>
+        <member name="M:Antlr.Runtime.Tree.IPositionTrackingStream.GetKnownPositionElement(System.Boolean)">
+             Returns an element containing concrete information about the current
+             position in the stream.
+            
+             @param allowApproximateLocation if {@code false}, this method returns
+             {@code null} if an element containing exact information about the current
+             position is not available
+        </member>
+        <member name="M:Antlr.Runtime.Tree.IPositionTrackingStream.HasPositionInformation(System.Object)">
+             Determines if the specified {@code element} contains concrete position
+             information.
+            
+             @param element the element to check
+             @return {@code true} if {@code element} contains concrete position
+             information, otherwise {@code false}
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITree">
+            <summary>
+              What does a tree look like?  ANTLR has a number of support classes
+              such as CommonTreeNodeStream that work on these kinds of trees.  You
+              don't have to make your trees implement this interface, but if you do,
+              you'll be able to use more support code.
+              </summary>
+            
+              <remarks>
+              NOTE: When constructing trees, ANTLR can build any kind of tree; it can
+              even use Token objects as trees if you add a child list to your tokens.
+            
+              This is a tree node without any payload; just navigation and factory stuff.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.HasAncestor(System.Int32)">
+            <summary>Is there is a node above with token type ttype?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.GetAncestor(System.Int32)">
+            <summary>Walk upwards and get first ancestor with this token type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.GetAncestors">
+            <summary>
+            Return a list of all ancestors of this node.  The first node of
+            list is the root and the last is the parent of this node.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.ChildIndex">
+            <summary>This node is what child index? 0..n-1</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.FreshenParentAndChildIndexes">
+            <summary>Set the parent and child index values for all children</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.AddChild(Antlr.Runtime.Tree.ITree)">
+            <summary>
+            Add t as a child to this node.  If t is null, do nothing.  If t
+            is nil, add all children of t to this' children.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.SetChild(System.Int32,Antlr.Runtime.Tree.ITree)">
+            <summary>Set ith child (0..n-1) to t; t must be non-null and non-nil node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.ReplaceChildren(System.Int32,System.Int32,System.Object)">
+            <summary>
+            Delete children from start to stop and replace with t even if t is
+            a list (nil-root tree).  num of children can increase or decrease.
+            For huge child lists, inserting children can force walking rest of
+            children to set their childindex; could be slow.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.IsNil">
+            <summary>
+            Indicates the node is a nil node but may still have children, meaning
+            the tree is a flat list.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.TokenStartIndex">
+            <summary>
+            What is the smallest token index (indexing from 0) for this node
+            and its children?
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.TokenStopIndex">
+            <summary>
+            What is the largest token index (indexing from 0) for this node
+            and its children?
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.Type">
+            <summary>Return a token type; needed for tree parsing</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.Line">
+            <summary>In case we don't have a token payload, what is the line for errors?</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITreeAdaptor">
+            <summary>
+              How to create and navigate trees.  Rather than have a separate factory
+              and adaptor, I've merged them.  Makes sense to encapsulate.
+              </summary>
+            
+              <remarks>
+              This takes the place of the tree construction code generated in the
+              generated code in 2.x and the ASTFactory.
+            
+              I do not need to know the type of a tree at all so they are all
+              generic Objects.  This may increase the amount of typecasting needed. :(
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(Antlr.Runtime.IToken)">
+            <summary>
+              Create a tree node from Token object; for CommonTree type trees,
+              then the token just becomes the payload.  This is the most
+              common create call.
+              </summary>
+            
+              <remarks>
+              Override if you want another kind of node to be built.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,Antlr.Runtime.IToken)">
+            <summary>
+              Create a new node derived from a token, with a new token type.
+              This is invoked from an imaginary node ref on right side of a
+              rewrite rule as IMAG[$tokenLabel].
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(Token).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,Antlr.Runtime.IToken,System.String)">
+            <summary>
+              Same as create(tokenType,fromToken) except set the text too.
+              This is invoked from an imaginary node ref on right side of a
+              rewrite rule as IMAG[$tokenLabel, "IMAG"].
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(Token).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(Antlr.Runtime.IToken,System.String)">
+            <summary>
+              Same as create(fromToken) except set the text too.
+              This is invoked when the <c>text</c> terminal option is set, as in
+              IMAG&lt;text='IMAG'&gt;.
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(Token).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,System.String)">
+            <summary>
+              Create a new node derived from a token, with a new token type.
+              This is invoked from an imaginary node ref on right side of a
+              rewrite rule as IMAG["IMAG"].
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(int,String).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DupNode(System.Object)">
+            <summary>Duplicate a single tree node.</summary>
+            <remarks>Override if you want another kind of node to be built.</remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DupTree(System.Object)">
+            <summary>Duplicate tree recursively, using dupNode() for each node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Nil">
+            <summary>
+            Return a nil node (an empty but non-null node) that can hold
+            a list of element as the children.  If you want a flat tree (a list)
+            use "t=adaptor.nil(); t.addChild(x); t.addChild(y);"
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.ErrorNode(Antlr.Runtime.ITokenStream,Antlr.Runtime.IToken,Antlr.Runtime.IToken,Antlr.Runtime.RecognitionException)">
+            <summary>
+              Return a tree node representing an error.  This node records the
+              tokens consumed during error recovery.  The start token indicates the
+              input symbol at which the error was detected.  The stop token indicates
+              the last symbol consumed during recovery.
+              </summary>
+            
+              <remarks>
+              You must specify the input stream so that the erroneous text can
+              be packaged up in the error node.  The exception could be useful
+              to some applications; default implementation stores ptr to it in
+              the CommonErrorNode.
+            
+              This only makes sense during token parsing, not tree parsing.
+              Tree parsing should happen only when parsing and tree construction
+              succeed.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.IsNil(System.Object)">
+            <summary>Is tree considered a nil node used to make lists of child nodes?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.AddChild(System.Object,System.Object)">
+            <summary>
+            Add a child to the tree t.  If child is a flat tree (a list), make all
+            in list children of t.  Warning: if t has no children, but child does
+            and child isNil then you can decide it is ok to move children to t via
+            t.children = child.children; i.e., without copying the array.  Just
+            make sure that this is consistent with have the user will build
+            ASTs.  Do nothing if t or child is null.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(System.Object,System.Object)">
+            <summary>
+              If oldRoot is a nil root, just copy or move the children to newRoot.
+              If not a nil root, make oldRoot a child of newRoot.
+              </summary>
+            
+              <remarks>
+                old=^(nil a b c), new=r yields ^(r a b c)
+                old=^(a b c), new=r yields ^(r ^(a b c))
+            
+              If newRoot is a nil-rooted single child tree, use the single
+              child as the new root node.
+            
+                old=^(nil a b c), new=^(nil r) yields ^(r a b c)
+                old=^(a b c), new=^(nil r) yields ^(r ^(a b c))
+            
+              If oldRoot was null, it's ok, just return newRoot (even if isNil).
+            
+                old=null, new=r yields r
+                old=null, new=^(nil r) yields ^(nil r)
+            
+              Return newRoot.  Throw an exception if newRoot is not a
+              simple node or nil root with a single child node--it must be a root
+              node.  If newRoot is ^(nil x) return x as newRoot.
+            
+              Be advised that it's ok for newRoot to point at oldRoot's
+              children; i.e., you don't have to copy the list.  We are
+              constructing these nodes so we should have this control for
+              efficiency.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.RulePostProcessing(System.Object)">
+            <summary>
+              Given the root of the subtree created for this rule, post process
+              it to do any simplifications or whatever you want.  A required
+              behavior is to convert ^(nil singleSubtree) to singleSubtree
+              as the setting of start/stop indexes relies on a single non-nil root
+              for non-flat trees.
+              </summary>
+            
+              <remarks>
+              Flat trees such as for lists like "idlist : ID+ ;" are left alone
+              unless there is only one ID.  For a list, the start/stop indexes
+              are set in the nil node.
+            
+              This method is executed after all rule tree construction and right
+              before setTokenBoundaries().
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetUniqueID(System.Object)">
+            <summary>For identifying trees.</summary>
+            
+              <remarks>
+              How to identify nodes so we can say "add node to a prior node"?
+              Even becomeRoot is an issue.  Use System.identityHashCode(node)
+              usually.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(Antlr.Runtime.IToken,System.Object)">
+            <summary>
+              Create a node for newRoot make it the root of oldRoot.
+              If oldRoot is a nil root, just copy or move the children to newRoot.
+              If not a nil root, make oldRoot a child of newRoot.
+              </summary>
+            
+              <returns>
+              Return node created for newRoot.
+              </returns>
+            
+              <remarks>
+              Be advised: when debugging ASTs, the DebugTreeAdaptor manually
+              calls create(Token child) and then plain becomeRoot(node, node)
+              because it needs to trap calls to create, but it can't since it delegates
+              to not inherits from the TreeAdaptor.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetType(System.Object)">
+            <summary>For tree parsing, I need to know the token type of a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetType(System.Object,System.Int32)">
+            <summary>Node constructors can set the type of a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetText(System.Object,System.String)">
+            <summary>Node constructors can set the text of a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetToken(System.Object)">
+            <summary>
+            Return the token object from which this node was created.
+            Currently used only for printing an error message.
+            The error display routine in BaseRecognizer needs to
+            display where the input the error occurred. If your
+            tree of limitation does not store information that can
+            lead you to the token, you can create a token filled with
+            the appropriate information and pass that back.  See
+            BaseRecognizer.getErrorMessage().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetTokenBoundaries(System.Object,Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
+            <summary>
+            Where are the bounds in the input token stream for this node and
+            all children?  Each rule that creates AST nodes will call this
+            method right before returning.  Flat trees (i.e., lists) will
+            still usually have a nil root node just to hold the children list.
+            That node would contain the start/stop indexes then.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetTokenStartIndex(System.Object)">
+            <summary>Get the token start index for this subtree; return -1 if no such index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetTokenStopIndex(System.Object)">
+            <summary>Get the token stop index for this subtree; return -1 if no such index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChild(System.Object,System.Int32)">
+            <summary>Get a child 0..n-1 node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetChild(System.Object,System.Int32,System.Object)">
+            <summary>Set ith child (0..n-1) to t; t must be non-null and non-nil node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DeleteChild(System.Object,System.Int32)">
+            <summary>Remove ith child and shift children down from right.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChildCount(System.Object)">
+            <summary>How many children?  If 0, then this is a leaf node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetParent(System.Object)">
+            <summary>
+            Who is the parent node of this node; if null, implies node is root.
+            If your node type doesn't handle this, it's ok but the tree rewrites
+            in tree parsers need this functionality.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChildIndex(System.Object)">
+            <summary>
+            What index is this node in the child list? Range: 0..n-1
+            If your node type doesn't handle this, it's ok but the tree rewrites
+            in tree parsers need this functionality.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.ReplaceChildren(System.Object,System.Int32,System.Int32,System.Object)">
+            <summary>
+              Replace from start to stop child index of parent with t, which might
+              be a list.  Number of children may be different after this call.
+              </summary>
+            
+              <remarks>
+              If parent is null, don't do anything; must be at root of overall tree.
+              Can't replace whatever points to the parent externally.  Do nothing.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITreeNodeStream">
+            <summary>A stream of tree nodes, accessing nodes from a tree of some kind</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.Item(System.Int32)">
+            <summary>
+            Get a tree node at an absolute index i; 0..n-1.
+            If you don't want to buffer up nodes, then this method makes no
+            sense for you.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.LT(System.Int32)">
+            <summary>
+             Get tree node at current input pointer + <paramref name="k"/> ahead where
+             <paramref name="k"/>==1 is next node. <paramref name="k"/>&lt;0 indicates nodes in the past. So
+             {@code LT(-1)} is previous node, but implementations are not required to
+             provide results for <paramref name="k"/> &lt; -1. {@code LT(0)} is undefined. For
+             <paramref name="k"/>&lt;=n, return <see langword="null"/>. Return <see langword="null"/> for {@code LT(0)}
+             and any index that results in an absolute address that is negative.
+              </summary>
+            
+              <remarks>
+             This is analogous to <see cref="M:Antlr.Runtime.ITokenStream.LT(System.Int32)"/>, but this returns a tree node
+             instead of a <see cref="T:Antlr.Runtime.IToken"/>. Makes code generation identical for both
+             parser and tree grammars.
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TreeSource">
+            <summary>
+            Where is this stream pulling nodes from?  This is not the name, but
+            the object that provides node objects.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TokenStream">
+            <summary>
+            If the tree associated with this stream was created from a
+            {@link TokenStream}, you can specify it here. Used to do rule
+            {@code $text} attribute in tree parser. Optional unless you use tree
+            parser rule {@code $text} attribute or {@code output=template} and
+            {@code rewrite=true} options.
+             </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TreeAdaptor">
+            <summary>
+            What adaptor can tell me how to interpret/navigate nodes and
+            trees.  E.g., get text of a node.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.UniqueNavigationNodes">
+            <summary>
+            As we flatten the tree, we use {@link Token#UP}, {@link Token#DOWN} nodes
+            to represent the tree structure. When debugging we need unique nodes so
+            we have to instantiate new ones. When doing normal tree parsing, it's
+            slow and a waste of memory to create unique navigation nodes. Default
+            should be {@code false}.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.ToString(System.Object,System.Object)">
+            <summary>
+            Return the text of all nodes from {@code start} to {@code stop},
+            inclusive. If the stream does not buffer all the nodes then it can still
+            walk recursively from start until stop. You can always return
+            {@code null} or {@code ""} too, but users should not access
+            {@code $ruleLabel.text} in an action of course in that case.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.ReplaceChildren(System.Object,System.Int32,System.Int32,System.Object)">
+            <summary>
+             Replace children of {@code parent} from index {@code startChildIndex} to
+             {@code stopChildIndex} with {@code t}, which might be a list. Number of
+             children may be different after this call. The stream is notified because
+             it is walking the tree and might need to know you are monkeying with the
+             underlying tree. Also, it might be able to modify the node stream to
+             avoid restreaming for future phases.
+              </summary>
+            
+              <remarks>
+             If {@code parent} is {@code null}, don't do anything; must be at root of
+             overall tree. Can't replace whatever points to the parent externally. Do
+             nothing.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITreeVisitorAction">
+            <summary>
+            How to execute code for node t when a visitor visits node t.  Execute
+            pre() before visiting children and execute post() after visiting children.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeVisitorAction.Pre(System.Object)">
+            <summary>
+            Execute an action before visiting children of t.  Return t or
+            a rewritten t.  It is up to the visitor to decide what to do
+            with the return value.  Children of returned value will be
+            visited if using TreeVisitor.visit().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeVisitorAction.Post(System.Object)">
+            <summary>
+            Execute an action after visiting children of t.  Return t or
+            a rewritten t.  It is up to the visitor to decide what to do
+            with the return value.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ParseTree">
+            <summary>
+            A record of the rules used to match a token sequence.  The tokens
+            end up as the leaves of this tree and rule nodes are the interior nodes.
+            This really adds no functionality, it is just an alias for CommonTree
+            that is more meaningful (specific) and holds a String to display for a node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ParseTree.ToStringWithHiddenTokens">
+            <summary>
+            Emit a token and all hidden nodes before.  EOF node holds all
+            hidden tokens after last real token.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ParseTree.ToInputString">
+            <summary>
+            Print out the leaves of this tree, which means printing original
+            input back out.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteCardinalityException">
+            <summary>
+            Base class for all exceptions thrown during AST rewrite construction.
+            This signifies a case where the cardinality of two or more elements
+            in a subrule are different: (ID INT)+ where |ID|!=|INT|
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteEarlyExitException">
+            <summary>No elements within a (...)+ in a rewrite rule</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteEmptyStreamException">
+            <summary>Ref to ID or expr but no tokens in ID stream or subtrees in expr stream</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteRuleElementStream">
+            <summary>
+              A generic list of elements tracked in an alternative to be used in
+              a -> rewrite rule.  We need to subclass to fill in the next() method,
+              which returns either an AST node wrapped around a token payload or
+              an existing subtree.
+              </summary>
+            
+              <remarks>
+              Once you start next()ing, do not try to add more elements.  It will
+              break the cursor tracking I believe.
+            
+              TODO: add mechanism to detect/puke on modification after reading from stream
+              </remarks>
+            
+              <see cref="T:Antlr.Runtime.Tree.RewriteRuleSubtreeStream"/>
+              <see cref="T:Antlr.Runtime.Tree.RewriteRuleTokenStream"/>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.cursor">
+            <summary>
+            Cursor 0..n-1.  If singleElement!=null, cursor is 0 until you next(),
+            which bumps it to 1 meaning no more elements.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.singleElement">
+            <summary>Track single elements w/o creating a list.  Upon 2nd add, alloc list</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.elements">
+            <summary>The list of tokens or subtrees we are tracking</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.dirty">
+            <summary>Once a node / subtree has been used in a stream, it must be dup'd
+            from then on.  Streams are reset after subrules so that the streams
+            can be reused in future subrules.  So, reset must set a dirty bit.
+            If dirty, then next() always returns a dup.</summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.elementDescription">
+            <summary>The element or stream description; usually has name of the token or
+            rule reference that this list tracks.  Can include rulename too, but
+            the exception would track that info.</summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.Reset">
+            <summary>
+            Reset the condition of this stream so that it appears we have
+            not consumed any of its elements.  Elements themselves are untouched.
+            Once we reset the stream, any future use will need duplicates.  Set
+            the dirty bit.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.NextTree">
+            <summary>
+            Return the next element in the stream.  If out of elements, throw
+            an exception unless size()==1.  If size is 1, then return elements[0].
+            Return a duplicate node/subtree if stream is out of elements and
+            size==1.  If we've already used the element, dup (dirty bit set).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.NextCore">
+            <summary>
+            Do the work of getting the next element, making sure that it's
+            a tree node or subtree.  Deal with the optimization of single-
+            element list versus list of size > 1.  Throw an exception
+            if the stream is empty or we're out of elements and size>1.
+            protected so you can override in a subclass if necessary.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.Dup(System.Object)">
+            <summary>
+             When constructing trees, sometimes we need to dup a token or AST
+            	subtree.  Dup'ing a token means just creating another AST node
+             around it.  For trees, you must call the adaptor.dupTree() unless
+             the element is for a tree root; then it must be a node dup.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.ToTree(System.Object)">
+            <summary>
+            Ensure stream emits trees; tokens must be converted to AST nodes.
+            AST nodes can be passed through unmolested.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteRuleNodeStream">
+            <summary>
+            Queues up nodes matched on left side of -> in a tree parser. This is
+            the analog of RewriteRuleTokenStream for normal parsers.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleNodeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleNodeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.NextNode">
+            <summary>
+              Treat next element as a single node even if it's a subtree.
+              This is used instead of next() when the result has to be a
+              tree root node.  Also prevents us from duplicating recently-added
+              children; e.g., ^(type ID)+ adds ID to type and then 2nd iteration
+              must dup the type node, but ID has been added.
+              </summary>
+            
+              <remarks>
+              Referencing a rule result twice is ok; dup entire tree as
+              we can't be adding trees as root; e.g., expr expr.
+            
+              Hideous code duplication here with super.next().  Can't think of
+              a proper way to refactor.  This needs to always call dup node
+              and super.next() doesn't know which to call: dup node or dup tree.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.NextNode">
+            <summary>Get next token from stream and make a node for it</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.ToTree(System.Object)">
+            <summary>
+            Don't convert to a tree unless they explicitly call nextTree.
+            This way we can do hetero tree nodes in rewrite.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeIterator">
+            Return a node stream from a doubly-linked tree whose nodes
+              know what child index they are.  No remove() is supported.
+            
+              Emit navigation nodes (DOWN, UP, and EOF) to let show tree structure.
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreeIterator.nodes">
+            If we emit UP/DOWN nodes, we need to spit out multiple nodes per
+            next() call.
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeParser">
+            <summary>
+            A parser for a stream of tree nodes.  "tree grammars" result in a subclass
+            of this.  All the error reporting and recovery is shared with Parser via
+            the BaseRecognizer superclass.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.SetTreeNodeStream(Antlr.Runtime.Tree.ITreeNodeStream)">
+            <summary>Set the input stream</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.MatchAny(Antlr.Runtime.IIntStream)">
+            <summary>
+            Match '.' in tree parser has special meaning.  Skip node or
+            entire tree if node has children.  If children, scan until
+            corresponding UP node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.RecoverFromMismatchedToken(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>
+            We have DOWN/UP nodes in the stream that have no line info; override.
+            plus we want to alter the exception type.  Don't try to recover
+            from tree parser errors inline...
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.GetErrorHeader(Antlr.Runtime.RecognitionException)">
+            <summary>
+            Prefix error message with the grammar name because message is
+            always intended for the programmer because the parser built
+            the input tree not the user.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.GetErrorMessage(Antlr.Runtime.RecognitionException,System.String[])">
+            <summary>
+            Tree parsers parse nodes they usually have a token object as
+            payload. Set the exception token and do the default behavior.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.pattern">
+            <summary>The tree pattern to lex like "(A B C)"</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.p">
+            <summary>Index into input string</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.c">
+            <summary>Current char</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.n">
+            <summary>How long is the pattern in char?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.sval">
+            <summary>Set when token type is ID or ARG (name mimics Java's StreamTokenizer)</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeRewriter.ReportTransformation(System.Object,System.Object)">
+            Override this if you need transformation tracing to go somewhere
+            other than stdout or if you're not using ITree-derived trees.
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeRuleReturnScope`1">
+            <summary>
+            This is identical to the ParserRuleReturnScope except that
+            the start property is a tree nodes not Token object
+            when you are parsing trees.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.TreeRuleReturnScope`1.Start">
+            <summary>Gets the first node or root node of tree matched for this rule.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeVisitor">
+            <summary>Do a depth first walk of a tree, applying pre() and post() actions as we go.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeVisitor.Visit(System.Object,Antlr.Runtime.Tree.ITreeVisitorAction)">
+            <summary>
+            Visit every node in tree t and trigger an action for each node
+            before/after having visited all of its children.  Bottom up walk.
+            Execute both actions even if t has no children.  Ignore return
+            results from transforming children since they will have altered
+            the child list of this node (their parent).  Return result of
+            applying post action to this node.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeWizard">
+            <summary>
+              Build and navigate trees with this object.  Must know about the names
+              of tokens so you have to pass in a map or array of token names (from which
+              this class can build the map).  I.e., Token DECL means nothing unless the
+              class can translate it to a token type.
+              </summary>
+            
+              <remarks>
+              In order to create nodes and navigate, this class needs a TreeAdaptor.
+            
+              This class can build a token type -> node index for repeated use or for
+              iterating over the various nodes with a particular type.
+            
+              This class works in conjunction with the TreeAdaptor rather than moving
+              all this functionality into the adaptor.  An adaptor helps build and
+              navigate trees using methods.  This class helps you do it with string
+              patterns like "(A B C)".  You can create a tree from that pattern or
+              match subtrees against it.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeWizard.TreePattern">
+            <summary>
+            When using %label:TOKENNAME in a tree for parse(), we must
+            track the label.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeWizard.TreePatternTreeAdaptor">
+            <summary>This adaptor creates TreePattern objects for use during scan()</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.ComputeTokenTypes(System.String[])">
+            <summary>
+            Compute a Map&lt;String, Integer&gt; that is an inverted index of
+            tokenNames (which maps int token types to names).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.GetTokenType(System.String)">
+            <summary>Using the map of token names to token types, return the type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Index(System.Object)">
+            <summary>
+              Walk the entire tree and make a node name to nodes mapping.
+              For now, use recursion but later nonrecursive version may be
+              more efficient.  Returns Map&lt;Integer, List&gt; where the List is
+              of your AST node type.  The Integer is the token type of the node.
+              </summary>
+            
+              <remarks>
+              TODO: save this index so that find and visit are faster
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.IndexCore(System.Object,System.Collections.Generic.IDictionary{System.Int32,System.Collections.IList})">
+            <summary>Do the work for index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Find(System.Object,System.Int32)">
+            <summary>Return a List of tree nodes with token type ttype</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Find(System.Object,System.String)">
+            <summary>Return a List of subtrees matching pattern.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Visit(System.Object,System.Int32,Antlr.Runtime.Tree.TreeWizard.IContextVisitor)">
+            <summary>
+            Visit every ttype node in t, invoking the visitor.  This is a quicker
+            version of the general visit(t, pattern) method.  The labels arg
+            of the visitor action method is never set (it's null) since using
+            a token type rather than a pattern doesn't let us set a label.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.VisitCore(System.Object,System.Object,System.Int32,System.Int32,Antlr.Runtime.Tree.TreeWizard.IContextVisitor)">
+            <summary>Do the recursive work for visit</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Visit(System.Object,System.String,Antlr.Runtime.Tree.TreeWizard.IContextVisitor)">
+            <summary>
+            For all subtrees that match the pattern, execute the visit action.
+            The implementation uses the root node of the pattern in combination
+            with visit(t, ttype, visitor) so nil-rooted patterns are not allowed.
+            Patterns with wildcard roots are also not allowed.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Parse(System.Object,System.String,System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+              Given a pattern like (ASSIGN %lhs:ID %rhs:.) with optional labels
+              on the various nodes and '.' (dot) as the node/subtree wildcard,
+              return true if the pattern matches and fill the labels Map with
+              the labels pointing at the appropriate nodes.  Return false if
+              the pattern is malformed or the tree does not match.
+              </summary>
+            
+              <remarks>
+              If a node specifies a text arg in pattern, then that must match
+              for that node in t.
+            
+              TODO: what's a better way to indicate bad pattern? Exceptions are a hassle 
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.ParseCore(System.Object,Antlr.Runtime.Tree.TreeWizard.TreePattern,System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+            Do the work for parse. Check to see if the t2 pattern fits the
+            structure and token types in t1.  Check text if the pattern has
+            text arguments on nodes.  Fill labels map with pointers to nodes
+            in tree matched against nodes in pattern with labels.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Create(System.String)">
+            <summary>
+              Create a tree or node from the indicated tree pattern that closely
+              follows ANTLR tree grammar tree element syntax:
+            
+                  (root child1 ... child2).
+              </summary>
+            
+              <remarks>
+              You can also just pass in a node: ID
+             
+              Any node can have a text argument: ID[foo]
+              (notice there are no quotes around foo--it's clear it's a string).
+            
+              nil is a special name meaning "give me a nil node".  Useful for
+              making lists: (nil A B C) is a list of A B C.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Equals(System.Object,System.Object,Antlr.Runtime.Tree.ITreeAdaptor)">
+            <summary>
+              Compare t1 and t2; return true if token types/text, structure match exactly.
+              The trees are examined in their entirety so that (A B) does not match
+              (A B C) nor (A (B C)). 
+              </summary>
+            
+              <remarks>
+              TODO: allow them to pass in a comparator
+              TODO: have a version that is nonstatic so it can use instance adaptor
+            
+              I cannot rely on the tree node's equals() implementation as I make
+              no constraints at all on the node types nor interface etc... 
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Equals(System.Object,System.Object)">
+            <summary>
+            Compare type, structure, and text of two trees, assuming adaptor in
+            this instance of a TreeWizard.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.UnbufferedTokenStream">
+            A token stream that pulls tokens from the code source on-demand and
+              without tracking a complete buffer of the tokens. This stream buffers
+              the minimum number of tokens possible.  It's the same as
+              OnDemandTokenStream except that OnDemandTokenStream buffers all tokens.
+            
+              You can't use this stream if you pass whitespace or other off-channel
+              tokens to the parser. The stream can't ignore off-channel tokens.
+             
+              You can only look backwards 1 token: LT(-1).
+            
+              Use this when you need to read from a socket or other infinite stream.
+            
+              @see BufferedTokenStream
+              @see CommonTokenStream
+        </member>
+        <member name="F:Antlr.Runtime.UnbufferedTokenStream.channel">
+            Skip tokens on any channel but this one; this is how we skip whitespace... 
+        </member>
+        <member name="T:Antlr.Runtime.UnwantedTokenException">
+            <summary>An extra token while parsing a TokenStream</summary> 
+        </member>
+    </members>
+</doc>
diff --git a/packages/Antlr3.Runtime.3.5.1/lib/net40-client/Antlr3.Runtime.dll b/packages/Antlr3.Runtime.3.5.1/lib/net40-client/Antlr3.Runtime.dll
new file mode 100644
index 0000000..55c8fbd
Binary files /dev/null and b/packages/Antlr3.Runtime.3.5.1/lib/net40-client/Antlr3.Runtime.dll differ
diff --git a/packages/Antlr3.Runtime.3.5.1/lib/net40-client/Antlr3.Runtime.xml b/packages/Antlr3.Runtime.3.5.1/lib/net40-client/Antlr3.Runtime.xml
new file mode 100644
index 0000000..565e15d
--- /dev/null
+++ b/packages/Antlr3.Runtime.3.5.1/lib/net40-client/Antlr3.Runtime.xml
@@ -0,0 +1,3249 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>Antlr3.Runtime</name>
+    </assembly>
+    <members>
+        <member name="T:Antlr.Runtime.ANTLRFileStream">
+            <summary>
+            This is a char buffer stream that is loaded from a file
+            all at once when you construct the object.  This looks very
+            much like an ANTLReader or ANTLRInputStream, but it's a special case
+            since we know the exact size of the object to load.  We can avoid lots
+            of data copying. 
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.ANTLRInputStream">
+            <summary>
+            A kind of ReaderStream that pulls from an InputStream.
+            Useful for reading from stdin and specifying file encodings etc...
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.ANTLRReaderStream">
+            <summary>
+              Vacuum all input from a Reader and then treat it like a StringStream.
+              Manage the buffer manually to avoid unnecessary data copying.
+              </summary>
+            
+              <remarks>
+              If you need encoding, use ANTLRInputStream.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.ANTLRStringStream">
+            <summary>
+            A pretty quick CharStream that pulls all data from an array
+            directly.  Every method call counts in the lexer.  Java's
+            strings aren't very good so I'm avoiding.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.data">
+            <summary>The data being scanned</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.n">
+            <summary>How many characters are actually in the buffer</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.p">
+            <summary>0..n-1 index into string of next char</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.line">
+            <summary>line number 1..n within the input</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.charPositionInLine">
+            <summary>The index of the character relative to the beginning of the line 0..n-1</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.markDepth">
+            <summary>tracks how deep mark() calls are nested</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.markers">
+            <summary>
+            A list of CharStreamState objects that tracks the stream state
+            values line, charPositionInLine, and p that can change as you
+            move through the input stream.  Indexed from 1..markDepth.
+            A null is kept @ index 0.  Create upon first call to mark().
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.name">
+            <summary>What is name or source of this char stream?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.#ctor(System.String)">
+            <summary>Copy data in string to a local char array</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.#ctor(System.Char[],System.Int32)">
+            <summary>This is the preferred constructor as no data is copied</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.ANTLRStringStream.Index">
+            <summary>
+            Return the current input symbol index 0..n where n indicates the
+            last symbol has been read.  The index is the index of char to
+            be returned from LA(1).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.Reset">
+            <summary>
+            Reset the stream so that it's in the same state it was
+            when the object was created *except* the data array is not
+            touched.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.Seek(System.Int32)">
+            <summary>
+            consume() ahead until p==index; can't just set p=index as we must
+            update line and charPositionInLine.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.BaseRecognizer">
+            <summary>
+            A generic recognizer that can handle recognizers generated from
+            lexer, parser, and tree grammars.  This is all the parsing
+            support code essentially; most of it is error recovery stuff and
+            backtracking.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.BaseRecognizer.state">
+            <summary>
+            State of a lexer, parser, or tree parser are collected into a state
+            object so the state can be shared.  This sharing is needed to
+            have one grammar import others and share same error variables
+            and other state variables.  It's a kind of explicit multiple
+            inheritance via delegation of methods and shared state.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Reset">
+            <summary>reset the parser's state; subclasses must rewinds the input stream</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Match(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>
+              Match current input symbol against ttype.  Attempt
+              single token insertion or deletion error recovery.  If
+              that fails, throw MismatchedTokenException.
+              </summary>
+            
+              <remarks>
+              To turn off single token insertion or deletion error
+              recovery, override recoverFromMismatchedToken() and have it
+              throw an exception. See TreeParser.recoverFromMismatchedToken().
+              This way any error in a rule will cause an exception and
+              immediate exit from rule.  Rule would recover by resynchronizing
+              to the set of symbols that can follow rule ref.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.MatchAny(Antlr.Runtime.IIntStream)">
+            <summary>Match the wildcard: in a symbol</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ReportError(Antlr.Runtime.RecognitionException)">
+            <summary>Report a recognition problem.</summary>
+            
+              <remarks>
+              This method sets errorRecovery to indicate the parser is recovering
+              not parsing.  Once in recovery mode, no errors are generated.
+              To get out of recovery mode, the parser must successfully match
+              a token (after a resync).  So it will go:
+            
+             		1. error occurs
+             		2. enter recovery mode, report error
+             		3. consume until token found in resynch set
+             		4. try to resume parsing
+             		5. next match() will reset errorRecovery mode
+            
+              If you override, make sure to update syntaxErrors if you care about that.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetErrorMessage(Antlr.Runtime.RecognitionException,System.String[])">
+            <summary>What error message should be generated for the various exception types?</summary>
+            
+              <remarks>
+              Not very object-oriented code, but I like having all error message
+              generation within one method rather than spread among all of the
+              exception classes. This also makes it much easier for the exception
+              handling because the exception classes do not have to have pointers back
+              to this object to access utility routines and so on. Also, changing
+              the message for an exception type would be difficult because you
+              would have to subclassing exception, but then somehow get ANTLR
+              to make those kinds of exception objects instead of the default.
+              This looks weird, but trust me--it makes the most sense in terms
+              of flexibility.
+            
+              For grammar debugging, you will want to override this to add
+              more information such as the stack frame with
+              getRuleInvocationStack(e, this.getClass().getName()) and,
+              for no viable alts, the decision description and state etc...
+            
+              Override this to change the message generated for one or more
+              exception types.
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.NumberOfSyntaxErrors">
+            <summary>
+              Get number of recognition errors (lexer, parser, tree parser).  Each
+              recognizer tracks its own number.  So parser and lexer each have
+              separate count.  Does not count the spurious errors found between
+              an error and next valid token match
+              </summary>
+            
+              <seealso cref="M:Antlr.Runtime.BaseRecognizer.ReportError(Antlr.Runtime.RecognitionException)"/>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetErrorHeader(Antlr.Runtime.RecognitionException)">
+            <summary>What is the error header, normally line/character position information?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetTokenErrorDisplay(Antlr.Runtime.IToken)">
+            <summary>
+            How should a token be displayed in an error message? The default
+            is to display just the text, but during development you might
+            want to have a lot of information spit out.  Override in that case
+            to use t.ToString() (which, for CommonToken, dumps everything about
+            the token). This is better than forcing you to override a method in
+            your token objects because you don't have to go modify your lexer
+            so that it creates a new Java type.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.EmitErrorMessage(System.String)">
+            <summary>Override this method to change where error messages go</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Recover(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException)">
+            <summary>
+            Recover from an error found on the input stream.  This is
+            for NoViableAlt and mismatched symbol exceptions.  If you enable
+            single token insertion and deletion, this will usually not
+            handle mismatched symbol exceptions but there could be a mismatched
+            token that the match() routine could not recover from.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.BeginResync">
+            <summary>
+            A hook to listen in on the token consumption during error recovery.
+            The DebugParser subclasses this to fire events to the listenter.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ComputeContextSensitiveRuleFOLLOW">
+            <summary>
+              Compute the context-sensitive FOLLOW set for current rule.
+              This is set of token types that can follow a specific rule
+              reference given a specific call chain.  You get the set of
+              viable tokens that can possibly come next (lookahead depth 1)
+              given the current call chain.  Contrast this with the
+              definition of plain FOLLOW for rule r:
+              </summary>
+            
+               FOLLOW(r)={x | S=>*alpha r beta in G and x in FIRST(beta)}
+            
+              where x in T* and alpha, beta in V*; T is set of terminals and
+              V is the set of terminals and nonterminals.  In other words,
+              FOLLOW(r) is the set of all tokens that can possibly follow
+              references to r in *any* sentential form (context).  At
+              runtime, however, we know precisely which context applies as
+              we have the call chain.  We may compute the exact (rather
+              than covering superset) set of following tokens.
+            
+              For example, consider grammar:
+            
+              stat : ID '=' expr ';'      // FOLLOW(stat)=={EOF}
+                   | "return" expr '.'
+                   ;
+              expr : atom ('+' atom)* ;   // FOLLOW(expr)=={';','.',')'}
+              atom : INT                  // FOLLOW(atom)=={'+',')',';','.'}
+                   | '(' expr ')'
+                   ;
+            
+              The FOLLOW sets are all inclusive whereas context-sensitive
+              FOLLOW sets are precisely what could follow a rule reference.
+              For input input "i=(3);", here is the derivation:
+            
+              stat => ID '=' expr ';'
+                   => ID '=' atom ('+' atom)* ';'
+                   => ID '=' '(' expr ')' ('+' atom)* ';'
+                   => ID '=' '(' atom ')' ('+' atom)* ';'
+                   => ID '=' '(' INT ')' ('+' atom)* ';'
+                   => ID '=' '(' INT ')' ';'
+            
+              At the "3" token, you'd have a call chain of
+            
+                stat -> expr -> atom -> expr -> atom
+            
+              What can follow that specific nested ref to atom?  Exactly ')'
+              as you can see by looking at the derivation of this specific
+              input.  Contrast this with the FOLLOW(atom)={'+',')',';','.'}.
+            
+              You want the exact viable token set when recovering from a
+              token mismatch.  Upon token mismatch, if LA(1) is member of
+              the viable next token set, then you know there is most likely
+              a missing token in the input stream.  "Insert" one by just not
+              throwing an exception.
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.RecoverFromMismatchedToken(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>Attempt to recover from a single missing or extra token.</summary>
+            
+              EXTRA TOKEN
+            
+              LA(1) is not what we are looking for.  If LA(2) has the right token,
+              however, then assume LA(1) is some extra spurious token.  Delete it
+              and LA(2) as if we were doing a normal match(), which advances the
+              input.
+            
+              MISSING TOKEN
+            
+              If current token is consistent with what could come after
+              ttype then it is ok to "insert" the missing token, else throw
+              exception For example, Input "i=(3;" is clearly missing the
+              ')'.  When the parser returns from the nested call to expr, it
+              will have call chain:
+            
+                stat -> expr -> atom
+            
+              and it will be trying to match the ')' at this point in the
+              derivation:
+            
+                   => ID '=' '(' INT ')' ('+' atom)* ';'
+                                      ^
+              match() will see that ';' doesn't match ')' and report a
+              mismatched token error.  To recover, it sees that LA(1)==';'
+              is in the set of tokens that can follow the ')' token
+              reference in rule atom.  It can assume that you forgot the ')'.
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.RecoverFromMismatchedSet(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException,Antlr.Runtime.BitSet)">
+            Not currently used 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetCurrentInputSymbol(Antlr.Runtime.IIntStream)">
+            <summary>
+              Match needs to return the current input symbol, which gets put
+              into the label for the associated token ref; e.g., x=ID.  Token
+              and tree parsers need to return different objects. Rather than test
+              for input stream type or change the IntStream interface, I use
+              a simple method to ask the recognizer to tell me what the current
+              input symbol is.
+              </summary>
+            
+              <remarks>This is ignored for lexers.</remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetMissingSymbol(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>Conjure up a missing token during error recovery.</summary>
+            
+              <remarks>
+              The recognizer attempts to recover from single missing
+              symbols. But, actions might refer to that missing symbol.
+              For example, x=ID {f($x);}. The action clearly assumes
+              that there has been an identifier matched previously and that
+              $x points at that token. If that token is missing, but
+              the next token in the stream is what we want we assume that
+              this token is missing and we keep going. Because we
+              have to return some token to replace the missing token,
+              we have to conjure one up. This method gives the user control
+              over the tokens returned for missing tokens. Mostly,
+              you will want to create something special for identifier
+              tokens. For literals such as '{' and ',', the default
+              action in the parser or tree parser works. It simply creates
+              a CommonToken of the appropriate type. The text will be the token.
+              If you change what tokens must be created by the lexer,
+              override this method to create the appropriate tokens.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ConsumeUntil(Antlr.Runtime.IIntStream,Antlr.Runtime.BitSet)">
+            <summary>Consume tokens until one matches the given token set</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.PushFollow(Antlr.Runtime.BitSet)">
+            <summary>Push a rule's follow set using our own hardcoded stack</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleInvocationStack">
+            <summary>
+              Return <see cref="T:System.Collections.Generic.IList`1"/> of the rules in your parser instance
+              leading up to a call to this method.  You could override if
+              you want more details such as the file/line info of where
+              in the parser java code a rule is invoked.
+              </summary>
+            
+              <remarks>
+              This is very useful for error messages and for context-sensitive
+              error recovery.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleInvocationStack(System.Diagnostics.StackTrace)">
+            <summary>
+            A more general version of GetRuleInvocationStack where you can
+            pass in the StackTrace of, for example, a RecognitionException
+            to get it's rule stack trace.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.Failed">
+            <summary>Return whether or not a backtracking attempt failed.</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.TokenNames">
+            <summary>
+            Used to print out token names like ID during debugging and
+            error reporting.  The generated parsers implement a method
+            that overrides this to point to their String[] tokenNames.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.GrammarFileName">
+            <summary>
+            For debugging and other purposes, might want the grammar name.
+            Have ANTLR generate an implementation for this method.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ToStrings(System.Collections.Generic.ICollection{Antlr.Runtime.IToken})">
+            <summary>
+            A convenience method for use most often with template rewrites.
+            Convert a list of <see cref="T:Antlr.Runtime.IToken"/> to a list of <see cref="T:System.String"/>.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleMemoization(System.Int32,System.Int32)">
+            <summary>
+              Given a rule number and a start token index number, return
+              MEMO_RULE_UNKNOWN if the rule has not parsed input starting from
+              start index.  If this rule has parsed input starting from the
+              start index before, then return where the rule stopped parsing.
+              It returns the index of the last token matched by the rule.
+              </summary>
+            
+              <remarks>
+              For now we use a hashtable and just the slow Object-based one.
+              Later, we can make a special one for ints and also one that
+              tosses out data after we commit past input position i.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.AlreadyParsedRule(Antlr.Runtime.IIntStream,System.Int32)">
+            <summary>
+              Has this rule already parsed input at the current index in the
+              input stream?  Return the stop token index or MEMO_RULE_UNKNOWN.
+              If we attempted but failed to parse properly before, return
+              MEMO_RULE_FAILED.
+              </summary>
+            
+              <remarks>
+              This method has a side-effect: if we have seen this input for
+              this rule and successfully parsed before, then seek ahead to
+              1 past the stop token matched for this rule last time.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Memoize(Antlr.Runtime.IIntStream,System.Int32,System.Int32)">
+            <summary>
+            Record whether or not this rule parsed the input at this position
+            successfully.  Use a standard java hashtable for now.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleMemoizationCacheSize">
+            <summary>return how many rule/input-index pairs there are in total.</summary>
+            TODO: this includes synpreds. :(
+        </member>
+        <member name="T:Antlr.Runtime.BitSet">
+            <summary>
+            A stripped-down version of org.antlr.misc.BitSet that is just
+            good enough to handle runtime requirements such as FOLLOW sets
+            for automatic error recovery.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.BitSet.MOD_MASK">
+            <summary>
+            We will often need to do a mod operator (i mod nbits).  Its
+            turns out that, for powers of two, this mod operation is
+            same as (i &amp; (nbits-1)).  Since mod is slow, we use a
+            precomputed mod mask to do the mod instead.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.BitSet._bits">
+            <summary>The actual data bits</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor">
+            <summary>Construct a bitset of size one word (64 bits)</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor(System.UInt64[])">
+            <summary>Construction from a static array of longs</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor(System.Collections.Generic.IEnumerable{System.Int32})">
+            <summary>Construction from a list of integers</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor(System.Int32)">
+            <summary>Construct a bitset given the size</summary>
+            <param name="nbits">The size of the bitset in bits</param>
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.Or(Antlr.Runtime.BitSet)">
+            <summary>return this | a in a new set</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.Add(System.Int32)">
+            <summary>or this element into this set (grow as necessary to accommodate)</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.GrowToInclude(System.Int32)">
+            <summary>Grows the set to a larger number of bits.</summary>
+            <param name="bit">element that must fit in set</param>
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.SetSize(System.Int32)">
+            <summary>Sets the size of a set.</summary>
+            <param name="nwords">how many words the new set should be</param>
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.LengthInLongWords">
+            <summary>return how much space is being used by the bits array not how many actually have member bits on.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.ToArray">
+            Is this contained within a? 
+        </member>
+        <member name="T:Antlr.Runtime.BufferedTokenStream">
+            Buffer all input tokens but do on-demand fetching of new tokens from
+              lexer. Useful when the parser or lexer has to set context/mode info before
+              proper lexing of future tokens. The ST template parser needs this,
+              for example, because it has to constantly flip back and forth between
+              inside/output templates. E.g., <c>&lt;names:{hi, &lt;it&gt;}&gt;</c> has to parse names
+              as part of an expression but "hi, &lt;it&gt;" as a nested template.
+            
+              You can't use this stream if you pass whitespace or other off-channel
+              tokens to the parser. The stream can't ignore off-channel tokens.
+              (UnbufferedTokenStream is the same way.)
+            
+              This is not a subclass of UnbufferedTokenStream because I don't want
+              to confuse small moving window of tokens it uses for the full buffer.
+        </member>
+        <member name="F:Antlr.Runtime.BufferedTokenStream._tokens">
+            Record every single token pulled from the source so we can reproduce
+            chunks of it later.  The buffer in LookaheadStream overlaps sometimes
+            as its moving window moves through the input.  This list captures
+            everything so we can access complete input text.
+        </member>
+        <member name="F:Antlr.Runtime.BufferedTokenStream._lastMarker">
+            Track the last mark() call result value for use in rewind(). 
+        </member>
+        <member name="F:Antlr.Runtime.BufferedTokenStream._p">
+            The index into the tokens list of the current token (next token
+            to consume).  tokens[p] should be LT(1).  p=-1 indicates need
+            to initialize with first token.  The ctor doesn't get a token.
+            First call to LT(1) or whatever gets the first token and sets p=0;
+        </member>
+        <member name="P:Antlr.Runtime.BufferedTokenStream.Range">
+            <summary>
+            How deep have we gone?
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.Consume">
+            Move the input pointer to the next incoming token.  The stream
+              must become active with LT(1) available.  consume() simply
+              moves the input pointer so that LT(1) points at the next
+              input symbol. Consume at least one token.
+            
+              Walk past any token not on the channel the parser is listening to.
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.Sync(System.Int32)">
+            Make sure index i in tokens has a token. 
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.Fetch(System.Int32)">
+            add n elements to buffer 
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.GetTokens(System.Int32,System.Int32,Antlr.Runtime.BitSet)">
+            Given a start and stop index, return a List of all tokens in
+            the token type BitSet.  Return null if no tokens were found.  This
+            method looks at both on and off channel tokens.
+        </member>
+        <member name="T:Antlr.Runtime.CharStreamState">
+            <summary>
+              When walking ahead with cyclic DFA or for syntactic predicates,
+              we need to record the state of the input stream (char index,
+              line, etc...) so that we can rewind the state after scanning ahead.
+              </summary>
+            
+              <remarks>This is the complete state of a stream.</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.CharStreamState.p">
+            <summary>Index into the char stream of next lookahead char</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CharStreamState.line">
+            <summary>What line number is the scanner at before processing buffer[p]?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CharStreamState.charPositionInLine">
+            <summary>What char position 0..n-1 in line is scanner before processing buffer[p]?</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.ClassicToken">
+            <summary>
+            A Token object like we'd use in ANTLR 2.x; has an actual string created
+            and associated with this object.  These objects are needed for imaginary
+            tree nodes that have payload objects.  We need to create a Token object
+            that has a string; the tree node will point at this token.  CommonToken
+            has indexes into a char stream and hence cannot be used to introduce
+            new strings.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.ClassicToken.index">
+            <summary>What token number is this from 0..n-1 tokens</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.text">
+            <summary>
+            We need to be able to change the text once in a while.  If
+            this is non-null, then getText should return this.  Note that
+            start/stop are not affected by changing this.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.index">
+            <summary>What token number is this from 0..n-1 tokens; &lt; 0 implies invalid index</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.start">
+            <summary>The char position into the input buffer where this token starts</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.stop">
+            <summary>The char position into the input buffer where this token stops</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.CommonTokenStream">
+            <summary>
+              The most common stream of tokens is one where every token is buffered up
+              and tokens are prefiltered for a certain channel (the parser will only
+              see these tokens and cannot change the filter channel number during the
+              parse).
+              </summary>
+            
+              <remarks>TODO: how to access the full token stream?  How to track all tokens matched per rule?</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.CommonTokenStream._channel">
+            Skip tokens on any channel but this one; this is how we skip whitespace... 
+        </member>
+        <member name="P:Antlr.Runtime.CommonTokenStream.TokenSource">
+            Reset this token stream by setting its token source. 
+        </member>
+        <member name="M:Antlr.Runtime.CommonTokenStream.Consume">
+            Always leave p on an on-channel token. 
+        </member>
+        <member name="M:Antlr.Runtime.CommonTokenStream.SkipOffTokenChannels(System.Int32)">
+            Given a starting index, return the index of the first on-channel
+            token.
+        </member>
+        <member name="T:Antlr.Runtime.Debug.IDebugEventListener">
+            <summary>All debugging events that a recognizer can trigger.</summary>
+            
+              <remarks>
+              I did not create a separate AST debugging interface as it would create
+              lots of extra classes and DebugParser has a dbg var defined, which makes
+              it hard to change to ASTDebugEventListener.  I looked hard at this issue
+              and it is easier to understand as one monolithic event interface for all
+              possible events.  Hopefully, adding ST debugging stuff won't be bad.  Leave
+              for future. 4/26/2006.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterRule(System.String,System.String)">
+            <summary>
+            The parser has just entered a rule.  No decision has been made about
+            which alt is predicted.  This is fired AFTER init actions have been
+            executed.  Attributes are defined and available etc...
+            The grammarFileName allows composite grammars to jump around among
+            multiple grammar files.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterAlt(System.Int32)">
+            <summary>
+            Because rules can have lots of alternatives, it is very useful to
+            know which alt you are entering.  This is 1..n for n alts.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ExitRule(System.String,System.String)">
+            <summary>
+            This is the last thing executed before leaving a rule.  It is
+            executed even if an exception is thrown.  This is triggered after
+            error reporting and recovery have occurred (unless the exception is
+            not caught in this rule).  This implies an "exitAlt" event.
+            The grammarFileName allows composite grammars to jump around among
+            multiple grammar files.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterSubRule(System.Int32)">
+            <summary>Track entry into any (...) subrule other EBNF construct</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterDecision(System.Int32,System.Boolean)">
+            <summary>
+            Every decision, fixed k or arbitrary, has an enter/exit event
+            so that a GUI can easily track what LT/consume events are
+            associated with prediction.  You will see a single enter/exit
+            subrule but multiple enter/exit decision events, one for each
+            loop iteration.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeToken(Antlr.Runtime.IToken)">
+            <summary>
+            An input token was consumed; matched by any kind of element.
+            Trigger after the token was matched by things like match(), matchAny().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeHiddenToken(Antlr.Runtime.IToken)">
+            <summary>
+            An off-channel input token was consumed.
+            Trigger after the token was matched by things like match(), matchAny().
+            (unless of course the hidden token is first stuff in the input stream).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.LT(System.Int32,Antlr.Runtime.IToken)">
+            <summary>
+            Somebody (anybody) looked ahead.  Note that this actually gets
+            triggered by both LA and LT calls.  The debugger will want to know
+            which Token object was examined.  Like consumeToken, this indicates
+            what token was seen at that depth.  A remote debugger cannot look
+            ahead into a file it doesn't have so LT events must pass the token
+            even if the info is redundant.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Mark(System.Int32)">
+            <summary>
+            The parser is going to look arbitrarily ahead; mark this location,
+            the token stream's marker is sent in case you need it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Rewind(System.Int32)">
+            <summary>
+            After an arbitrairly long lookahead as with a cyclic DFA (or with
+            any backtrack), this informs the debugger that stream should be
+            rewound to the position associated with marker.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Rewind">
+            <summary>
+            Rewind to the input position of the last marker.
+            Used currently only after a cyclic DFA and just
+            before starting a sem/syn predicate to get the
+            input position back to the start of the decision.
+            Do not "pop" the marker off the state.  mark(i)
+            and rewind(i) should balance still.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Location(System.Int32,System.Int32)">
+            <summary>
+              To watch a parser move through the grammar, the parser needs to
+              inform the debugger what line/charPos it is passing in the grammar.
+              For now, this does not know how to switch from one grammar to the
+              other and back for island grammars etc...
+              </summary>
+            
+              <remarks>
+              This should also allow breakpoints because the debugger can stop
+              the parser whenever it hits this line/pos.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.RecognitionException(Antlr.Runtime.RecognitionException)">
+            <summary>
+              A recognition exception occurred such as NoViableAltException.  I made
+              this a generic event so that I can alter the exception hierachy later
+              without having to alter all the debug objects.
+              </summary>
+            
+              <remarks>
+              Upon error, the stack of enter rule/subrule must be properly unwound.
+              If no viable alt occurs it is within an enter/exit decision, which
+              also must be rewound.  Even the rewind for each mark must be unwount.
+              In the Java target this is pretty easy using try/finally, if a bit
+              ugly in the generated code.  The rewind is generated in DFA.predict()
+              actually so no code needs to be generated for that.  For languages
+              w/o this "finally" feature (C++?), the target implementor will have
+              to build an event stack or something.
+            
+              Across a socket for remote debugging, only the RecognitionException
+              data fields are transmitted.  The token object or whatever that
+              caused the problem was the last object referenced by LT.  The
+              immediately preceding LT event should hold the unexpected Token or
+              char.
+            
+              Here is a sample event trace for grammar:
+            
+              b : C ({;}A|B) // {;} is there to prevent A|B becoming a set
+                | D
+                ;
+            
+              The sequence for this rule (with no viable alt in the subrule) for
+              input 'c c' (there are 3 tokens) is:
+            
+            		commence
+            		LT(1)
+            		enterRule b
+            		location 7 1
+            		enter decision 3
+            		LT(1)
+            		exit decision 3
+            		enterAlt1
+            		location 7 5
+            		LT(1)
+            		consumeToken [c/&lt;4&gt;,1:0]
+            		location 7 7
+            		enterSubRule 2
+            		enter decision 2
+            		LT(1)
+            		LT(1)
+            		recognitionException NoViableAltException 2 1 2
+            		exit decision 2
+            		exitSubRule 2
+            		beginResync
+            		LT(1)
+            		consumeToken [c/&lt;4&gt;,1:1]
+            		LT(1)
+            		endResync
+            		LT(-1)
+            		exitRule b
+            		terminate
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.BeginResync">
+            <summary>
+            Indicates the recognizer is about to consume tokens to resynchronize
+            the parser.  Any consume events from here until the recovered event
+            are not part of the parse--they are dead tokens.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EndResync">
+            <summary>
+            Indicates that the recognizer has finished consuming tokens in order
+            to resychronize.  There may be multiple beginResync/endResync pairs
+            before the recognizer comes out of errorRecovery mode (in which
+            multiple errors are suppressed).  This will be useful
+            in a gui where you want to probably grey out tokens that are consumed
+            but not matched to anything in grammar.  Anything between
+            a beginResync/endResync pair was tossed out by the parser.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.SemanticPredicate(System.Boolean,System.String)">
+            <summary>A semantic predicate was evaluate with this result and action text</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Commence">
+            <summary>
+            Announce that parsing has begun.  Not technically useful except for
+            sending events over a socket.  A GUI for example will launch a thread
+            to connect and communicate with a remote parser.  The thread will want
+            to notify the GUI when a connection is made.  ANTLR parsers
+            trigger this upon entry to the first rule (the ruleLevel is used to
+            figure this out).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Terminate">
+            <summary>
+            Parsing is over; successfully or not.  Mostly useful for telling
+            remote debugging listeners that it's time to quit.  When the rule
+            invocation level goes to zero at the end of a rule, we are done
+            parsing.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeNode(System.Object)">
+            <summary>
+              Input for a tree parser is an AST, but we know nothing for sure
+              about a node except its type and text (obtained from the adaptor).
+              This is the analog of the consumeToken method.  Again, the ID is
+              the hashCode usually of the node so it only works if hashCode is
+              not implemented.  If the type is UP or DOWN, then
+              the ID is not really meaningful as it's fixed--there is
+              just one UP node and one DOWN navigation node.
+              </summary>
+            
+              <param name="t" />
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.LT(System.Int32,System.Object)">
+            <summary>
+            The tree parser lookedahead.  If the type is UP or DOWN,
+            then the ID is not really meaningful as it's fixed--there is
+            just one UP node and one DOWN navigation node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.NilNode(System.Object)">
+            <summary>
+              A nil was created (even nil nodes have a unique ID...
+              they are not "null" per se).  As of 4/28/2006, this
+              seems to be uniquely triggered when starting a new subtree
+              such as when entering a subrule in automatic mode and when
+              building a tree in rewrite mode.
+              </summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only t.ID is set.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ErrorNode(System.Object)">
+            <summary>
+              Upon syntax error, recognizers bracket the error with an error node
+              if they are building ASTs.
+              </summary>
+            
+              <param name="t"/>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.CreateNode(System.Object)">
+            <summary>Announce a new node built from token elements such as type etc...</summary>
+            
+             <remarks>
+             If you are receiving this event over a socket via
+             RemoteDebugEventSocketListener then only t.ID, type, text are
+             set.
+             </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.CreateNode(System.Object,Antlr.Runtime.IToken)">
+            <summary>Announce a new node built from an existing token.</summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only node.ID and token.tokenIndex
+              are set.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.BecomeRoot(System.Object,System.Object)">
+            <summary>Make a node the new root of an existing root.  See</summary>
+            
+              <remarks>
+              Note: the newRootID parameter is possibly different
+              than the TreeAdaptor.becomeRoot() newRoot parameter.
+              In our case, it will always be the result of calling
+              TreeAdaptor.becomeRoot() and not root_n or whatever.
+            
+              The listener should assume that this event occurs
+              only when the current subrule (or rule) subtree is
+              being reset to newRootID.
+             
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only IDs are set.
+              </remarks>
+            
+              <seealso cref="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(System.Object,System.Object)"/>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.AddChild(System.Object,System.Object)">
+            <summary>Make childID a child of rootID.</summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only IDs are set.
+              </remarks>
+            
+              <seealso cref="M:Antlr.Runtime.Tree.ITreeAdaptor.AddChild(System.Object,System.Object)"/>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.SetTokenBoundaries(System.Object,System.Int32,System.Int32)">
+            <summary>Set the token start/stop token index for a subtree root or node.</summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only t.ID is set.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.DFA">
+            <summary>A DFA implemented as a set of transition tables.</summary>
+            
+              <remarks>
+              Any state that has a semantic predicate edge is special; those states
+              are generated with if-then-else structures in a specialStateTransition()
+              which is generated by cyclicDFA template.
+            
+              There are at most 32767 states (16-bit signed short).
+              Could get away with byte sometimes but would have to generate different
+              types and the simulation code too.  For a point of reference, the Java
+              lexer's Tokens rule DFA has 326 states roughly.
+              </remarks>
+        </member>
+        <member name="F:Antlr.Runtime.DFA.recognizer">
+            <summary>Which recognizer encloses this DFA?  Needed to check backtracking</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.DFA.Predict(Antlr.Runtime.IIntStream)">
+            <summary>
+            From the input stream, predict what alternative will succeed
+            using this DFA (representing the covering regular approximation
+            to the underlying CFL).  Return an alternative number 1..n.  Throw
+            an exception upon error.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.DFA.Error(Antlr.Runtime.NoViableAltException)">
+            <summary>A hook for debugging interface</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.DFA.UnpackEncodedString(System.String)">
+            <summary>
+            Given a String that has a run-length-encoding of some unsigned shorts
+            like "\1\2\3\9", convert to short[] {2,9,9,9}.  We do this to avoid
+            static short[] which generates so much init code that the class won't
+            compile. :(
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.DFA.UnpackEncodedStringToUnsignedChars(System.String)">
+            <summary>Hideous duplication of code, but I need different typed arrays out :(</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.EarlyExitException">
+            <summary>The recognizer did not match anything for a (..)+ loop.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.FailedPredicateException">
+            <summary>
+            A semantic predicate failed during validation.  Validation of predicates
+            occurs when normally parsing the alternative just like matching a token.
+            Disambiguating predicate evaluation occurs when we hoist a predicate into
+            a prediction decision.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.IAstRuleReturnScope">
+            <summary>AST rules have trees</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IAstRuleReturnScope.Tree">
+            <summary>Has a value potentially if output=AST;</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.IAstRuleReturnScope`1">
+            <summary>AST rules have trees</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IAstRuleReturnScope`1.Tree">
+            <summary>Has a value potentially if output=AST;</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.ICharStream">
+            <summary>A source of characters for an ANTLR lexer</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ICharStream.Substring(System.Int32,System.Int32)">
+            <summary>
+            For infinite streams, you don't need this; primarily I'm providing
+            a useful interface for action code.  Just make sure actions don't
+            use this on streams that don't support it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ICharStream.LT(System.Int32)">
+            <summary>
+            Get the ith character of lookahead.  This is the same usually as
+            LA(i).  This will be used for labels in the generated
+            lexer code.  I'd prefer to return a char here type-wise, but it's
+            probably better to be 32-bit clean and be consistent with LA.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.ICharStream.Line">
+            <summary>ANTLR tracks the line information automatically</summary> 
+            <summary>Because this stream can rewind, we need to be able to reset the line</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.ICharStream.CharPositionInLine">
+            <summary>The index of the character relative to the beginning of the line 0..n-1</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.IIntStream">
+            <summary>
+            A simple stream of integers used when all I care about is the char
+            or token type sequence (such as interpretation).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.LA(System.Int32)">
+            <summary>
+            Get int at current input pointer + i ahead where i=1 is next int.
+            Negative indexes are allowed.  LA(-1) is previous token (token
+            just matched).  LA(-i) where i is before first token should
+            yield -1, invalid char / EOF.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Mark">
+            <summary>
+            Tell the stream to start buffering if it hasn't already.  Return
+            current input position, Index, or some other marker so that
+            when passed to rewind() you get back to the same spot.
+            rewind(mark()) should not affect the input cursor.  The Lexer
+            track line/col info as well as input index so its markers are
+            not pure input indexes.  Same for tree node streams.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IIntStream.Index">
+            <summary>
+            Return the current input symbol index 0..n where n indicates the
+            last symbol has been read.  The index is the symbol about to be
+            read not the most recently read symbol.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Rewind(System.Int32)">
+            <summary>
+            Reset the stream so that next call to index would return marker.
+            The marker will usually be Index but it doesn't have to be.  It's
+            just a marker to indicate what state the stream was in.  This is
+            essentially calling release() and seek().  If there are markers
+            created after this marker argument, this routine must unroll them
+            like a stack.  Assume the state the stream was in when this marker
+            was created.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Rewind">
+            <summary>
+            Rewind to the input position of the last marker.
+            Used currently only after a cyclic DFA and just
+            before starting a sem/syn predicate to get the
+            input position back to the start of the decision.
+            Do not "pop" the marker off the state.  mark(i)
+            and rewind(i) should balance still. It is
+            like invoking rewind(last marker) but it should not "pop"
+            the marker off.  It's like seek(last marker's input position).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Release(System.Int32)">
+            <summary>
+            You may want to commit to a backtrack but don't want to force the
+            stream to keep bookkeeping objects around for a marker that is
+            no longer necessary.  This will have the same behavior as
+            rewind() except it releases resources without the backward seek.
+            This must throw away resources for all markers back to the marker
+            argument.  So if you're nested 5 levels of mark(), and then release(2)
+            you have to release resources for depths 2..5.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Seek(System.Int32)">
+            <summary>
+              Set the input cursor to the position indicated by index.  This is
+              normally used to seek ahead in the input stream.  No buffering is
+              required to do this unless you know your stream will use seek to
+              move backwards such as when backtracking.
+              </summary>
+            
+              <remarks>
+              This is different from rewind in its multi-directional
+              requirement and in that its argument is strictly an input cursor (index).
+            
+              For char streams, seeking forward must update the stream state such
+              as line number.  For seeking backwards, you will be presumably
+              backtracking using the mark/rewind mechanism that restores state and
+              so this method does not need to update state when seeking backwards.
+            
+              Currently, this method is only used for efficient backtracking using
+              memoization, but in the future it may be used for incremental parsing.
+            
+              The index is 0..n-1.  A seek to position i means that LA(1) will
+              return the ith symbol.  So, seeking to 0 means LA(1) will return the
+              first element in the stream. 
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.IIntStream.Count">
+            <summary>
+            Only makes sense for streams that buffer everything up probably, but
+            might be useful to display the entire stream or for testing.  This
+            value includes a single EOF.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IIntStream.SourceName">
+            <summary>
+            Where are you getting symbols from?  Normally, implementations will
+            pass the buck all the way to the lexer who can ask its input stream
+            for the file name or whatever.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.IRuleReturnScope">
+            <summary>
+            Rules can have start/stop info.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope.Start">
+            <summary>
+            Gets the start element from the input stream
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope.Stop">
+            <summary>
+            Gets the stop element from the input stream
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.IRuleReturnScope`1">
+            <summary>
+            Rules can have start/stop info.
+            </summary>
+            <typeparam name="TLabel">The element type of the input stream.</typeparam>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope`1.Start">
+            <summary>
+            Gets the start element from the input stream
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope`1.Stop">
+            <summary>
+            Gets the stop element from the input stream
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IToken.Text">
+            <summary>Get the text of the token</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IToken.Line">
+            <summary>The line number on which this token was matched; line=1..n</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IToken.CharPositionInLine">
+            <summary>The index of the first character relative to the beginning of the line 0..n-1</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IToken.TokenIndex">
+            <summary>
+            An index from 0..n-1 of the token object in the input stream.
+            This must be valid in order to use the ANTLRWorks debugger.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IToken.InputStream">
+            <summary>
+            From what character stream was this token created?  You don't have to
+            implement but it's nice to know where a Token comes from if you have
+            include files etc... on the input.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.ITokenSource">
+            <summary>
+              A source of tokens must provide a sequence of tokens via nextToken()
+              and also must reveal it's source of characters; CommonToken's text is
+              computed from a CharStream; it only store indices into the char stream.
+              </summary>
+            
+              <remarks>
+              Errors from the lexer are never passed to the parser.  Either you want
+              to keep going or you do not upon token recognition error.  If you do not
+              want to continue lexing then you do not want to continue parsing.  Just
+              throw an exception not under RecognitionException and Java will naturally
+              toss you all the way out of the recognizers.  If you want to continue
+              lexing then you should not throw an exception to the parser--it has already
+              requested a token.  Keep lexing until you get a valid one.  Just report
+              errors and keep going, looking for a valid token.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenSource.NextToken">
+            <summary>
+            Return a Token object from your input stream (usually a CharStream).
+            Do not fail/return upon lexing error; keep chewing on the characters
+            until you get a good one; errors are not passed through to the parser.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.ITokenSource.SourceName">
+            <summary>
+            Where are you getting tokens from? normally the implication will simply
+            ask lexers input stream.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.ITokenStream">
+            <summary>A stream of tokens accessing tokens from a TokenSource</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.LT(System.Int32)">
+            <summary>Get Token at current input pointer + i ahead where i=1 is next Token.
+            i&lt;0 indicates tokens in the past.  So -1 is previous token and -2 is
+            two tokens ago. LT(0) is undefined.  For i&gt;=n, return Token.EOFToken.
+            Return null for LT(0) and any index that results in an absolute address
+            that is negative.</summary>
+        </member>
+        <member name="P:Antlr.Runtime.ITokenStream.Range">
+            <summary>
+            How far ahead has the stream been asked to look?  The return
+            value is a valid index from 0..n-1.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.Get(System.Int32)">
+            <summary>
+            Get a token at an absolute index i; 0..n-1.  This is really only
+            needed for profiling and debugging and token stream rewriting.
+            If you don't want to buffer up tokens, then this method makes no
+            sense for you.  Naturally you can't use the rewrite stream feature.
+            I believe DebugTokenStream can easily be altered to not use
+            this method, removing the dependency.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.ITokenStream.TokenSource">
+            <summary>
+            Where is this stream pulling tokens from?  This is not the name, but
+            the object that provides Token objects.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.ToString(System.Int32,System.Int32)">
+            <summary>
+            Return the text of all tokens from start to stop, inclusive.
+            If the stream does not buffer all the tokens then it can just
+            return "" or null;  Users should not access $ruleLabel.text in
+            an action of course in that case.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.ToString(Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
+            <summary>
+            Because the user is not required to use a token with an index stored
+            in it, we must provide a means for two token objects themselves to
+            indicate the start/end location.  Most often this will just delegate
+            to the other toString(int,int).  This is also parallel with
+            the TreeNodeStream.toString(Object,Object).
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.LegacyCommonTokenStream">
+            <summary>
+              The most common stream of tokens is one where every token is buffered up
+              and tokens are prefiltered for a certain channel (the parser will only
+              see these tokens and cannot change the filter channel number during the
+              parse).
+              </summary>
+            
+              <remarks>TODO: how to access the full token stream?  How to track all tokens matched per rule?</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.tokens">
+            <summary>
+            Record every single token pulled from the source so we can reproduce
+            chunks of it later.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.channelOverrideMap">
+            <summary>Map from token type to channel to override some Tokens' channel numbers</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.discardSet">
+            <summary>Set of token types; discard any tokens with this type</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.channel">
+            <summary>Skip tokens on any channel but this one; this is how we skip whitespace...</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.discardOffChannelTokens">
+            <summary>By default, track all incoming tokens</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.p">
+            <summary>
+            The index into the tokens list of the current token (next token
+            to consume).  p==-1 indicates that the tokens list is empty
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.LegacyCommonTokenStream.Range">
+            <summary>
+            How deep have we gone?
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.SetTokenSource(Antlr.Runtime.ITokenSource)">
+            <summary>Reset this token stream by setting its token source.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.FillBuffer">
+            <summary>
+            Load all tokens from the token source and put in tokens.
+            This is done upon first LT request because you might want to
+            set some token type / channel overrides before filling buffer.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.Consume">
+            <summary>
+              Move the input pointer to the next incoming token.  The stream
+              must become active with LT(1) available.  consume() simply
+              moves the input pointer so that LT(1) points at the next
+              input symbol. Consume at least one token.
+              </summary>
+            
+              <remarks>
+              Walk past any token not on the channel the parser is listening to.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.SkipOffTokenChannels(System.Int32)">
+            <summary>Given a starting index, return the index of the first on-channel token.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.SetTokenTypeChannel(System.Int32,System.Int32)">
+            <summary>
+            A simple filter mechanism whereby you can tell this token stream
+            to force all tokens of type ttype to be on channel.  For example,
+            when interpreting, we cannot exec actions so we need to tell
+            the stream to force all WS and NEWLINE to be a different, ignored
+            channel.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.GetTokens(System.Int32,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>
+            Given a start and stop index, return a List of all tokens in
+            the token type BitSet.  Return null if no tokens were found.  This
+            method looks at both on and off channel tokens.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.LT(System.Int32)">
+            <summary>
+            Get the ith token from the current position 1..n where k=1 is the
+            first symbol of lookahead.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.LB(System.Int32)">
+            <summary>Look backwards k tokens on-channel tokens</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.Get(System.Int32)">
+            <summary>
+            Return absolute token i; ignore which channel the tokens are on;
+            that is, count all tokens not just on-channel tokens.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Lexer">
+            <summary>
+            A lexer is recognizer that draws input symbols from a character stream.
+            lexer grammars result in a subclass of this object. A Lexer object
+            uses simplified match() and error recovery mechanisms in the interest
+            of speed.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Lexer.input">
+            <summary>Where is the lexer drawing characters from?</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Lexer.Text">
+            <summary>
+            Gets or sets the text matched so far for the current token or any text override.
+            </summary>
+            <remarks>
+            <para>Setting this value replaces any previously set value, and overrides the original text.</para>
+            </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.NextToken">
+            <summary>Return a token from this source; i.e., match a token on the char stream.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.GetEndOfFileToken">
+            Returns the EOF token (default), if you need
+            to return a custom token instead override this method.
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Skip">
+            <summary>
+            Instruct the lexer to skip creating a token for current lexer rule
+            and look for another token.  nextToken() knows to keep looking when
+            a lexer rule finishes with token set to SKIP_TOKEN.  Recall that
+            if token==null at end of any token rule, it creates one for you
+            and emits it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.mTokens">
+            <summary>This is the lexer entry point that sets instance var 'token'</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Emit(Antlr.Runtime.IToken)">
+            <summary>
+            Currently does not support multiple emits per nextToken invocation
+            for efficiency reasons.  Subclass and override this method and
+            nextToken (to push tokens into a list and pull from that list rather
+            than a single variable as this implementation does).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Emit">
+            <summary>
+              The standard method called to automatically emit a token at the
+              outermost lexical rule.  The token object should point into the
+              char buffer start..stop.  If there is a text override in 'text',
+              use that to set the token's text.  Override this method to emit
+              custom Token objects.
+              </summary>
+            
+              <remarks>
+              If you are building trees, then you should also override
+              Parser or TreeParser.getMissingSymbol().
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.Lexer.CharIndex">
+            <summary>What is the index of the current character of lookahead?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Recover(Antlr.Runtime.RecognitionException)">
+            <summary>
+            Lexers can normally match any char in it's vocabulary after matching
+            a token, so do the easy thing and just kill a character and hope
+            it all works out.  You can instead use the rule invocation stack
+            to do sophisticated error recovery if you are in a fragment rule.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Misc.FastQueue`1">
+            A queue that can dequeue and get(i) in O(1) and grow arbitrarily large.
+              A linked list is fast at dequeue but slow at get(i).  An array is
+              the reverse.  This is O(1) for both operations.
+            
+              List grows until you dequeue last element at end of buffer. Then
+              it resets to start filling at 0 again.  If adds/removes are balanced, the
+              buffer will not grow too large.
+            
+              No iterator stuff as that's not how we'll use it.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.FastQueue`1._data">
+            <summary>dynamically-sized buffer of elements</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Misc.FastQueue`1._p">
+            <summary>index of next element to fill</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Misc.FastQueue`1.Range">
+            <summary>
+            How deep have we gone?
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Misc.FastQueue`1.Item(System.Int32)">
+            <summary>
+            Return element {@code i} elements ahead of current element. {@code i==0}
+            gets current element. This is not an absolute index into {@link #data}
+            since {@code p} defines the start of the real list.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Misc.FastQueue`1.Dequeue">
+            <summary>Get and remove first element in queue</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.FastQueue`1.ToString">
+            <summary>Return string of current buffer contents; non-destructive</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Misc.LookaheadStream`1">
+            <summary>
+            A lookahead queue that knows how to mark/release locations in the buffer for
+            backtracking purposes. Any markers force the {@link FastQueue} superclass to
+            keep all elements until no more markers; then can reset to avoid growing a
+            huge buffer.
+             </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._currentElementIndex">
+            Absolute token index. It's the index of the symbol about to be
+            read via {@code LT(1)}. Goes from 0 to numtokens.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._previousElement">
+            This is the {@code LT(-1)} element for the first element in {@link #data}.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._eof">
+            Track object returned by nextElement upon end of stream;
+            Return it later when they ask for LT passed end of input.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._markDepth">
+            <summary>tracks how deep mark() calls are nested</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.NextElement">
+            <summary>
+            Implement nextElement to supply a stream of elements to this
+            lookahead buffer.  Return EOF upon end of the stream we're pulling from.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Dequeue">
+            <summary>
+            Get and remove first element in queue; override
+            {@link FastQueue#remove()}; it's the same, just checks for backtracking.
+            </summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Consume">
+            <summary>Make sure we have at least one element to remove, even if EOF</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.SyncAhead(System.Int32)">
+            <summary>
+            Make sure we have 'need' elements from current position p. Last valid
+            p index is data.size()-1.  p+need-1 is the data index 'need' elements
+            ahead.  If we need 1 element, (p+1-1)==p must be &lt; data.size().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Fill(System.Int32)">
+            <summary>add n elements to buffer</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Misc.LookaheadStream`1.Count">
+            <summary>Size of entire stream is unknown; we only know buffer size from FastQueue</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Seek(System.Int32)">
+            <summary>
+            Seek to a 0-indexed absolute token index. Normally used to seek backwards
+            in the buffer. Does not force loading of nodes.
+             </summary>
+             <remarks>
+            To preserve backward compatibility, this method allows seeking past the
+            end of the currently buffered data. In this case, the input pointer will
+            be moved but the data will only actually be loaded upon the next call to
+            {@link #consume} or {@link #LT} for {@code k>0}.
+             </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.MismatchedTokenException">
+            <summary>A mismatched char or Token or tree node</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.MissingTokenException">
+            <summary>
+            We were expecting a token but it's not found.  The current token
+            is actually what we wanted next.  Used for tree node errors too.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Parser">
+            <summary>
+            A parser for TokenStreams.  "parser grammars" result in a subclass
+            of this.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Parser.TokenStream">
+            <summary>Gets or sets the token stream; resets the parser upon a set.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.ParserRuleReturnScope`1">
+            <summary>
+              Rules that return more than a single value must return an object
+              containing all the values.  Besides the properties defined in
+              RuleLabelScope.predefinedRulePropertiesScope there may be user-defined
+              return values.  This class simply defines the minimum properties that
+              are always defined and methods to access the others that might be
+              available depending on output option such as template and tree.
+              </summary>
+            
+              <remarks>
+              Note text is not an actual property of the return value, it is computed
+              from start and stop using the input stream's toString() method.  I
+              could add a ctor to this so that we can pass in and store the input
+              stream, but I'm not sure we want to do that.  It would seem to be undefined
+              to get the .text property anyway if the rule matches tokens from multiple
+              input streams.
+            
+              I do not use getters for fields of objects that are used simply to
+              group values such as this aggregate.  The getters/setters are there to
+              satisfy the superclass interface.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.RecognitionException">
+            <summary>The root of the ANTLR exception hierarchy.</summary>
+            
+              <remarks>
+              To avoid English-only error messages and to generally make things
+              as flexible as possible, these exceptions are not created with strings,
+              but rather the information necessary to generate an error.  Then
+              the various reporting methods in Parser and Lexer can be overridden
+              to generate a localized error message.  For example, MismatchedToken
+              exceptions are built with the expected token type.
+              So, don't expect getMessage() to return anything.
+            
+              Note that as of Java 1.4, you can access the stack trace, which means
+              that you can compute the complete trace of rules from the start symbol.
+              This gives you considerable context information with which to generate
+              useful error messages.
+            
+              ANTLR generates code that throws exceptions upon recognition error and
+              also generates code to catch these exceptions in each rule.  If you
+              want to quit upon first error, you can turn off the automatic error
+              handling mechanism using rulecatch action, but you still need to
+              override methods mismatch and recoverFromMismatchSet.
+            
+              In general, the recognition exceptions can track where in a grammar a
+              problem occurred and/or what was the expected input.  While the parser
+              knows its state (such as current input symbol and line info) that
+              state can change before the exception is reported so current token index
+              is computed and stored at exception time.  From this info, you can
+              perhaps print an entire line of input not just a single token, for example.
+              Better to just say the recognizer had a problem and then let the parser
+              figure out a fancy report.
+              </remarks>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._input">
+            <summary>What input stream did the error occur in?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._k">
+            <summary>
+            What was the lookahead index when this exception was thrown?
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._index">
+            <summary>What is index of token/char were we looking at when the error occurred?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._token">
+            <summary>
+            The current Token when an error occurred.  Since not all streams
+            can retrieve the ith Token, we have to track the Token object.
+            For parsers.  Even when it's a tree parser, token might be set.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._node">
+            <summary>
+            If this is a tree parser exception, node is set to the node with
+            the problem.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._c">
+            <summary>The current char when an error occurred. For lexers.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._line">
+            <summary>
+            Track the line (1-based) at which the error occurred in case this is
+            generated from a lexer.  We need to track this since the
+            unexpected char doesn't carry the line info.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._charPositionInLine">
+            <summary>
+            The 0-based index into the line where the error occurred.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._approximateLineInfo">
+            <summary>
+            If you are parsing a tree node stream, you will encounter som
+            imaginary nodes w/o line/col info.  We now search backwards looking
+            for most recent token with line/col info, but notify getErrorHeader()
+            that info is approximate.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.RecognitionException.#ctor">
+            <summary>Used for remote debugger deserialization</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.RecognitionException.UnexpectedType">
+            <summary>Return the token type or char of the unexpected input element</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.RecognizerSharedState">
+            <summary>
+              The set of fields needed by an abstract recognizer to recognize input
+              and recover from errors etc...  As a separate state object, it can be
+              shared among multiple grammars; e.g., when one grammar imports another.
+              </summary>
+            
+              <remarks>
+              These fields are publically visible but the actual state pointer per
+              parser is protected.
+              </remarks>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.following">
+            <summary>
+            Track the set of token types that can follow any rule invocation.
+            Stack grows upwards.  When it hits the max, it grows 2x in size
+            and keeps going.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.errorRecovery">
+            <summary>
+            This is true when we see an error and before having successfully
+            matched a token.  Prevents generation of more than one error message
+            per error.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.lastErrorIndex">
+            <summary>
+             The index into the input stream where the last error occurred.
+            	This is used to prevent infinite loops where an error is found
+             but no token is consumed during recovery...another error is found,
+             ad naseum.  This is a failsafe mechanism to guarantee that at least
+             one token/tree node is consumed for two errors.
+             </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.failed">
+            <summary>
+            In lieu of a return value, this indicates that a rule or token
+            has failed to match.  Reset to false upon valid token match.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.syntaxErrors">
+            <summary>Did the recognizer encounter a syntax error?  Track how many.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.backtracking">
+            <summary>
+            If 0, no backtracking is going on.  Safe to exec actions etc...
+            If >0 then it's the level of backtracking.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.ruleMemo">
+            <summary>
+              An array[size num rules] of dictionaries that tracks
+              the stop token index for each rule.  ruleMemo[ruleIndex] is
+              the memoization table for ruleIndex.  For key ruleStartIndex, you
+              get back the stop token for associated rule or MEMO_RULE_FAILED.
+              </summary>
+            
+              <remarks>This is only used if rule memoization is on (which it is by default).</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.token">
+            <summary>
+            The goal of all lexer rules/methods is to create a token object.
+            This is an instance variable as multiple rules may collaborate to
+            create a single token.  nextToken will return this object after
+            matching lexer rule(s).  If you subclass to allow multiple token
+            emissions, then set this to the last token to be matched or
+            something nonnull so that the auto token emit mechanism will not
+            emit another token.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartCharIndex">
+            <summary>
+            What character index in the stream did the current token start at?
+            Needed, for example, to get the text for current token.  Set at
+            the start of nextToken.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartLine">
+            <summary>The line on which the first character of the token resides</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartCharPositionInLine">
+            <summary>The character position of first character within the line</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.channel">
+            <summary>The channel number for the current token</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.type">
+            <summary>The token type for the current token</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.text">
+            <summary>
+            You can set the text for the current token to override what is in
+            the input char buffer.  Use setText() or can set this instance var.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenChannels.Default">
+            <summary>
+            All tokens go to the parser (unless skip() is called in that rule)
+            on a particular "channel".  The parser tunes to a particular channel
+            so that whitespace etc... can go to the parser on a "hidden" channel.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenChannels.Hidden">
+            <summary>
+            Anything on different channel than DEFAULT_CHANNEL is not parsed
+            by parser.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.TokenRewriteStream">
+            Useful for dumping out the input stream after doing some
+              augmentation or other manipulations.
+            
+              You can insert stuff, replace, and delete chunks.  Note that the
+              operations are done lazily--only if you convert the buffer to a
+              String.  This is very efficient because you are not moving data around
+              all the time.  As the buffer of tokens is converted to strings, the
+              toString() method(s) check to see if there is an operation at the
+              current index.  If so, the operation is done and then normal String
+              rendering continues on the buffer.  This is like having multiple Turing
+              machine instruction streams (programs) operating on a single input tape. :)
+            
+              Since the operations are done lazily at toString-time, operations do not
+              screw up the token index values.  That is, an insert operation at token
+              index i does not change the index values for tokens i+1..n-1.
+            
+              Because operations never actually alter the buffer, you may always get
+              the original token stream back without undoing anything.  Since
+              the instructions are queued up, you can easily simulate transactions and
+              roll back any changes if there is an error just by removing instructions.
+              For example,
+            
+               CharStream input = new ANTLRFileStream("input");
+               TLexer lex = new TLexer(input);
+               TokenRewriteStream tokens = new TokenRewriteStream(lex);
+               T parser = new T(tokens);
+               parser.startRule();
+            
+             	 Then in the rules, you can execute
+                  Token t,u;
+                  ...
+                  input.insertAfter(t, "text to put after t");}
+             		input.insertAfter(u, "text after u");}
+             		System.out.println(tokens.toString());
+            
+              Actually, you have to cast the 'input' to a TokenRewriteStream. :(
+            
+              You can also have multiple "instruction streams" and get multiple
+              rewrites from a single pass over the input.  Just name the instruction
+              streams and use that name again when printing the buffer.  This could be
+              useful for generating a C file and also its header file--all from the
+              same buffer:
+            
+                  tokens.insertAfter("pass1", t, "text to put after t");}
+             		tokens.insertAfter("pass2", u, "text after u");}
+             		System.out.println(tokens.toString("pass1"));
+             		System.out.println(tokens.toString("pass2"));
+            
+              If you don't use named rewrite streams, a "default" stream is used as
+              the first example shows.
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.RewriteOperation.instructionIndex">
+            <summary>What index into rewrites List are we?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.RewriteOperation.index">
+            <summary>Token buffer index.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.RewriteOperation.Execute(System.Text.StringBuilder)">
+            <summary>
+            Execute the rewrite operation by possibly adding to the buffer.
+            Return the index of the next token to operate on.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.TokenRewriteStream.ReplaceOp">
+            <summary>
+            I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp
+            instructions.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.programs">
+            <summary>
+            You may have multiple, named streams of rewrite operations.
+            I'm calling these things "programs."
+            Maps String (name) -> rewrite (List)
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.lastRewriteTokenIndexes">
+            <summary>Map String (program name) -> Integer index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.Rollback(System.String,System.Int32)">
+            <summary>
+            Rollback the instruction stream for a program so that
+            the indicated instruction (via instructionIndex) is no
+            longer in the stream.  UNTESTED!
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.DeleteProgram(System.String)">
+            <summary>Reset the program so that no instructions exist</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.ReduceToSingleOperationPerIndex(System.Collections.Generic.IList{Antlr.Runtime.TokenRewriteStream.RewriteOperation})">
+            We need to combine operations and report invalid operations (like
+              overlapping replaces that are not completed nested).  Inserts to
+              same index need to be combined etc...   Here are the cases:
+            
+              I.i.u I.j.v								leave alone, nonoverlapping
+              I.i.u I.i.v								combine: Iivu
+            
+              R.i-j.u R.x-y.v	| i-j in x-y			delete first R
+              R.i-j.u R.i-j.v							delete first R
+              R.i-j.u R.x-y.v	| x-y in i-j			ERROR
+              R.i-j.u R.x-y.v	| boundaries overlap	ERROR
+            
+              Delete special case of replace (text==null):
+              D.i-j.u D.x-y.v	| boundaries overlap	combine to max(min)..max(right)
+            
+              I.i.u R.x-y.v | i in (x+1)-y			delete I (since insert before
+            											we're not deleting i)
+              I.i.u R.x-y.v | i not in (x+1)-y		leave alone, nonoverlapping
+              R.x-y.v I.i.u | i in x-y				ERROR
+              R.x-y.v I.x.u 							R.x-y.uv (combine, delete I)
+              R.x-y.v I.i.u | i not in x-y			leave alone, nonoverlapping
+            
+              I.i.u = insert u before op @ index i
+              R.x-y.u = replace x-y indexed tokens with u
+            
+              First we need to examine replaces.  For any replace op:
+            
+             		1. wipe out any insertions before op within that range.
+            		2. Drop any replace op before that is contained completely within
+                     that range.
+            		3. Throw exception upon boundary overlap with any previous replace.
+            
+              Then we can deal with inserts:
+            
+             		1. for any inserts to same index, combine even if not adjacent.
+             		2. for any prior replace with same left boundary, combine this
+                     insert with replace and delete this replace.
+             		3. throw exception if index in same range as previous replace
+            
+              Don't actually delete; make op null in list. Easier to walk list.
+              Later we can throw as we add to index -> op map.
+            
+              Note that I.2 R.2-2 will wipe out I.2 even though, technically, the
+              inserted stuff would be before the replace range.  But, if you
+              add tokens in front of a method body '{' and then delete the method
+              body, I think the stuff before the '{' you added should disappear too.
+            
+              Return a map from token index to operation.
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.GetKindOfOps(System.Collections.Generic.IList{Antlr.Runtime.TokenRewriteStream.RewriteOperation},System.Type,System.Int32)">
+            <summary>Get all operations before an index of a particular kind</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tokens.Skip">
+            <summary>
+            In an action, a lexer rule can set token to this SKIP_TOKEN and ANTLR
+            will avoid creating a token for this symbol and try to fetch another.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenTypes.Down">
+            <summary>imaginary tree navigation type; traverse "get child" link</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.TokenTypes.Up">
+            <summary>imaginary tree navigation type; finish with a child list</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.BaseTree">
+            <summary>
+            A generic tree implementation with no payload.  You must subclass to
+            actually have any user data.  ANTLR v3 uses a list of children approach
+            instead of the child-sibling approach in v2.  A flat tree (a list) is
+            an empty node whose children represent the list.  An empty, but
+            non-null node is called "nil".
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.#ctor(Antlr.Runtime.Tree.ITree)">
+            <summary>
+            Create a new node from an existing node does nothing for BaseTree
+            as there are no fields other than the children list, which cannot
+            be copied as the children are not considered part of this node. 
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.BaseTree.Children">
+            <summary>
+            Get the children internal List; note that if you directly mess with
+            the list, do so at your own risk.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.BaseTree.Parent">
+            <summary>BaseTree doesn't track parent pointers.</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Tree.BaseTree.ChildIndex">
+            <summary>BaseTree doesn't track child indexes.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.AddChild(Antlr.Runtime.Tree.ITree)">
+            <summary>Add t as child of this node.</summary>
+            
+              <remarks>
+              Warning: if t has no children, but child does
+              and child isNil then this routine moves children to t via
+              t.children = child.children; i.e., without copying the array.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.AddChildren(System.Collections.Generic.IEnumerable{Antlr.Runtime.Tree.ITree})">
+            <summary>Add all elements of kids list as children of this node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.InsertChild(System.Int32,Antlr.Runtime.Tree.ITree)">
+            Insert child t at child position i (0..n-1) by shifting children
+            i+1..n-1 to the right one position. Set parent / indexes properly
+            but does NOT collapse nil-rooted t's that come in here like addChild.
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.ReplaceChildren(System.Int32,System.Int32,System.Object)">
+            <summary>
+            Delete children from start to stop and replace with t even if t is
+            a list (nil-root tree).  num of children can increase or decrease.
+            For huge child lists, inserting children can force walking rest of
+            children to set their childindex; could be slow.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.CreateChildrenList">
+            <summary>Override in a subclass to change the impl of children list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.FreshenParentAndChildIndexes">
+            <summary>Set the parent and child index values for all child of t</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.HasAncestor(System.Int32)">
+            <summary>Walk upwards looking for ancestor with this token type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.GetAncestor(System.Int32)">
+            <summary>Walk upwards and get first ancestor with this token type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.GetAncestors">
+            <summary>
+            Return a list of all ancestors of this node.  The first node of
+            list is the root and the last is the parent of this node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.ToStringTree">
+            <summary>Print out a whole tree not just a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.ToString">
+            <summary>Override to say how a node (not a tree) should look as text</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.BaseTreeAdaptor">
+            <summary>A TreeAdaptor that works with any Tree implementation.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BaseTreeAdaptor.treeToUniqueIDMap">
+            <summary>
+            System.identityHashCode() is not always unique; we have to
+            track ourselves.  That's ok, it's only for debugging, though it's
+            expensive: we have to create a hashtable with all tree nodes in it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.ErrorNode(Antlr.Runtime.ITokenStream,Antlr.Runtime.IToken,Antlr.Runtime.IToken,Antlr.Runtime.RecognitionException)">
+            <summary>
+              Create tree node that holds the start and stop tokens associated
+              with an error.
+              </summary>
+            
+              <remarks>
+              If you specify your own kind of tree nodes, you will likely have to
+              override this method. CommonTree returns Token.INVALID_TOKEN_TYPE
+              if no token payload but you might have to set token type for diff
+              node type.
+            
+              You don't have to subclass CommonErrorNode; you will likely need to
+              subclass your own tree node class to avoid class cast exception.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.DupTree(System.Object,System.Object)">
+            <summary>
+            This is generic in the sense that it will work with any kind of
+            tree (not just ITree interface).  It invokes the adaptor routines
+            not the tree node routines to do the construction.  
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.AddChild(System.Object,System.Object)">
+            <summary>
+            Add a child to the tree t.  If child is a flat tree (a list), make all
+            in list children of t.  Warning: if t has no children, but child does
+            and child isNil then you can decide it is ok to move children to t via
+            t.children = child.children; i.e., without copying the array.  Just
+            make sure that this is consistent with have the user will build
+            ASTs.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.BecomeRoot(System.Object,System.Object)">
+            <summary>
+              If oldRoot is a nil root, just copy or move the children to newRoot.
+              If not a nil root, make oldRoot a child of newRoot.
+              </summary>
+            
+              <remarks>
+                old=^(nil a b c), new=r yields ^(r a b c)
+                old=^(a b c), new=r yields ^(r ^(a b c))
+            
+              If newRoot is a nil-rooted single child tree, use the single
+              child as the new root node.
+            
+                old=^(nil a b c), new=^(nil r) yields ^(r a b c)
+                old=^(a b c), new=^(nil r) yields ^(r ^(a b c))
+            
+              If oldRoot was null, it's ok, just return newRoot (even if isNil).
+            
+                old=null, new=r yields r
+                old=null, new=^(nil r) yields ^(nil r)
+            
+              Return newRoot.  Throw an exception if newRoot is not a
+              simple node or nil root with a single child node--it must be a root
+              node.  If newRoot is ^(nil x) return x as newRoot.
+            
+              Be advised that it's ok for newRoot to point at oldRoot's
+              children; i.e., you don't have to copy the list.  We are
+              constructing these nodes so we should have this control for
+              efficiency.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.RulePostProcessing(System.Object)">
+            <summary>Transform ^(nil x) to x and nil to null</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.CreateToken(System.Int32,System.String)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.CreateToken(Antlr.Runtime.IToken)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              This is a variant of createToken where the new token is derived from
+              an actual real input token.  Typically this is for converting '{'
+              tokens to BLOCK etc...  You'll see
+            
+                r : lc='{' ID+ '}' -> ^(BLOCK[$lc] ID+) ;
+            
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.DupNode(System.Object)">
+            <summary>
+              Duplicate a node.  This is part of the factory;
+              override if you want another kind of node to be built.
+              </summary>
+            
+              <remarks>
+              I could use reflection to prevent having to override this
+              but reflection is slow.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.SetTokenBoundaries(System.Object,Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
+            <summary>
+            Track start/stop token for subtree root created for a rule.
+            Only works with Tree nodes.  For rules that match nothing,
+            seems like this will yield start=i and stop=i-1 in a nil node.
+            Might be useful info so I'll not force to be i..i.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.BufferedTreeNodeStream">
+            <summary>A buffered stream of tree nodes.  Nodes can be from a tree of ANY kind.</summary>
+            
+              This node stream sucks all nodes out of the tree specified in
+              the constructor during construction and makes pointers into
+              the tree using an array of Object pointers. The stream necessarily
+              includes pointers to DOWN and UP and EOF nodes.
+            
+              This stream knows how to mark/release for backtracking.
+            
+              This stream is most suitable for tree interpreters that need to
+              jump around a lot or for tree parsers requiring speed (at cost of memory).
+              There is some duplicated functionality here with UnBufferedTreeNodeStream
+              but just in bookkeeping, not tree walking etc...
+            
+              TARGET DEVELOPERS:
+            
+              This is the old CommonTreeNodeStream that buffered up entire node stream.
+              No need to implement really as new CommonTreeNodeStream is much better
+              and covers what we need.
+            
+              @see CommonTreeNodeStream
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.nodes">
+            <summary>The complete mapping from stream index to tree node.
+              This buffer includes pointers to DOWN, UP, and EOF nodes.
+              It is built upon ctor invocation.  The elements are type
+              Object as we don't what the trees look like.</summary>
+            
+              Load upon first need of the buffer so we can set token types
+              of interest for reverseIndexing.  Slows us down a wee bit to
+              do all of the if p==-1 testing everywhere though.
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.root">
+            <summary>Pull nodes from which tree?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.tokens">
+            <summary>IF this tree (root) was created from a token stream, track it.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.adaptor">
+            <summary>What tree adaptor was used to build these trees</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.uniqueNavigationNodes">
+            <summary>Reuse same DOWN, UP navigation nodes unless this is true</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.p">
+            <summary>The index into the nodes list of the current node (next node
+            to consume).  If -1, nodes array not filled yet.</summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.calls">
+            <summary>Stack of indexes used for push/pop calls</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.FillBuffer">
+            Walk tree with depth-first-search and fill nodes buffer.
+            Don't do DOWN, UP nodes if its a list (t is isNil).
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.GetNodeIndex(System.Object)">
+            What is the stream index for node? 0..n-1
+            Return -1 if node not found.
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.AddNavigationNode(System.Int32)">
+            As we flatten the tree, we use UP, DOWN nodes to represent
+            the tree structure.  When debugging we need unique nodes
+            so instantiate new ones when uniqueNavigationNodes is true.
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.LB(System.Int32)">
+            <summary>Look backwards k nodes</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.Push(System.Int32)">
+            <summary>
+            Make stream jump to a new location, saving old location.
+            Switch back with pop().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.Pop">
+            <summary>
+            Seek back to previous index saved during last push() call.
+            Return top of stack (return index).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.ToTokenTypeString">
+            <summary>Used for testing, just return the token type stream</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.ToTokenString(System.Int32,System.Int32)">
+            <summary>Debugging</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.CommonErrorNode">
+            <summary>A node representing erroneous token range in token stream</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.CommonTree">
+            <summary>
+            A tree node that is wrapper for a Token object.  After 3.0 release
+            while building tree rewrite stuff, it became clear that computing
+            parent and child index is very difficult and cumbersome.  Better to
+            spend the space in every tree node.  If you don't want these extra
+            fields, it's easy to cut them out in your own BaseTree subclass.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree._token">
+            <summary>A single token is the payload</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree.startIndex">
+            <summary>
+            What token indexes bracket all tokens associated with this node
+            and below?
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree.parent">
+            <summary>Who is the parent node of this node; if null, implies node is root</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree.childIndex">
+            <summary>What index is this node in the child list? Range: 0..n-1</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTree.SetUnknownTokenBoundaries">
+            <summary>
+            For every node in this subtree, make sure it's start/stop token's
+            are set.  Walk depth first, visit bottom up.  Only updates nodes
+            with at least one token index &lt; 0.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.CommonTreeAdaptor">
+            <summary>
+              A TreeAdaptor that works with any Tree implementation.  It provides
+              really just factory methods; all the work is done by BaseTreeAdaptor.
+              If you would like to have different tokens created than ClassicToken
+              objects, you need to override this and then set the parser tree adaptor to
+              use your subclass.
+              </summary>
+            
+              <remarks>
+              To get your parser to build nodes of a different type, override
+              create(Token), errorNode(), and to be safe, YourTreeClass.dupNode().
+              dupNode is called to duplicate nodes during rewrite operations.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.CreateToken(System.Int32,System.String)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.CreateToken(Antlr.Runtime.IToken)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              This is a variant of createToken where the new token is derived from
+              an actual real input token.  Typically this is for converting '{'
+              tokens to BLOCK etc...  You'll see
+            
+                r : lc='{' ID+ '}' -> ^(BLOCK[$lc] ID+) ;
+            
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.GetToken(System.Object)">
+            <summary>
+            What is the Token associated with this node?  If
+            you are not using CommonTree, then you must
+            override this in your own adaptor.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._root">
+            <summary>Pull nodes from which tree?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream.tokens">
+            <summary>If this tree (root) was created from a token stream, track it.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._adaptor">
+            <summary>What tree adaptor was used to build these trees</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._it">
+            The tree iterator we are using 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._calls">
+            <summary>Stack of indexes used for push/pop calls</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._hasNilRoot">
+            <summary>Tree (nil A B C) trees like flat A B C streams</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._level">
+            <summary>Tracks tree depth.  Level=0 means we're at root node level.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._previousLocationElement">
+             Tracks the last node before the start of {@link #data} which contains
+             position information to provide information for error reporting. This is
+             tracked in addition to {@link #prevElement} which may or may not contain
+             position information.
+            
+             @see #hasPositionInformation
+             @see RecognitionException#extractInformationFromTreeNodeStream
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.Push(System.Int32)">
+            Make stream jump to a new location, saving old location.
+            Switch back with pop().
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.Pop">
+            Seek back to previous index saved during last push() call.
+            Return top of stack (return index).
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.GetKnownPositionElement(System.Boolean)">
+             Returns an element containing position information. If {@code allowApproximateLocation} is {@code false}, then
+             this method will return the {@code LT(1)} element if it contains position information, and otherwise return {@code null}.
+             If {@code allowApproximateLocation} is {@code true}, then this method will return the last known element containing position information.
+            
+             @see #hasPositionInformation
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.ToTokenTypeString">
+            <summary>For debugging; destructive: moves tree iterator to end.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.DotTreeGenerator">
+            A utility class to generate DOT diagrams (graphviz) from
+              arbitrary trees.  You can pass in your own templates and
+              can pass in any kind of tree or use Tree interface method.
+              I wanted this separator so that you don't have to include
+              ST just to use the org.antlr.runtime.tree.* package.
+              This is a set of non-static methods so you can subclass
+              to override.  For example, here is an invocation:
+            
+                  CharStream input = new ANTLRInputStream(System.in);
+                  TLexer lex = new TLexer(input);
+                  CommonTokenStream tokens = new CommonTokenStream(lex);
+                  TParser parser = new TParser(tokens);
+                  TParser.e_return r = parser.e();
+                  Tree t = (Tree)r.tree;
+                  System.out.println(t.toStringTree());
+                  DOTTreeGenerator gen = new DOTTreeGenerator();
+                  StringTemplate st = gen.toDOT(t);
+                  System.out.println(st);
+        </member>
+        <member name="F:Antlr.Runtime.Tree.DotTreeGenerator.nodeToNumberMap">
+            Track node to number mapping so we can get proper node name back 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.DotTreeGenerator.nodeNumber">
+            Track node number so we can get unique node names 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.DotTreeGenerator.ToDot(System.Object,Antlr.Runtime.Tree.ITreeAdaptor)">
+            Generate DOT (graphviz) for a whole tree not just a node.
+              For example, 3+4*5 should generate:
+            
+             digraph {
+               node [shape=plaintext, fixedsize=true, fontsize=11, fontname="Courier",
+                     width=.4, height=.2];
+               edge [arrowsize=.7]
+               "+"->3
+               "+"->"*"
+               "*"->4
+               "*"->5
+             }
+            
+             Takes a Tree interface object.
+        </member>
+        <member name="T:Antlr.Runtime.Tree.IPositionTrackingStream">
+            
+             @author Sam Harwell
+        </member>
+        <member name="M:Antlr.Runtime.Tree.IPositionTrackingStream.GetKnownPositionElement(System.Boolean)">
+             Returns an element containing concrete information about the current
+             position in the stream.
+            
+             @param allowApproximateLocation if {@code false}, this method returns
+             {@code null} if an element containing exact information about the current
+             position is not available
+        </member>
+        <member name="M:Antlr.Runtime.Tree.IPositionTrackingStream.HasPositionInformation(System.Object)">
+             Determines if the specified {@code element} contains concrete position
+             information.
+            
+             @param element the element to check
+             @return {@code true} if {@code element} contains concrete position
+             information, otherwise {@code false}
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITree">
+            <summary>
+              What does a tree look like?  ANTLR has a number of support classes
+              such as CommonTreeNodeStream that work on these kinds of trees.  You
+              don't have to make your trees implement this interface, but if you do,
+              you'll be able to use more support code.
+              </summary>
+            
+              <remarks>
+              NOTE: When constructing trees, ANTLR can build any kind of tree; it can
+              even use Token objects as trees if you add a child list to your tokens.
+            
+              This is a tree node without any payload; just navigation and factory stuff.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.HasAncestor(System.Int32)">
+            <summary>Is there is a node above with token type ttype?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.GetAncestor(System.Int32)">
+            <summary>Walk upwards and get first ancestor with this token type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.GetAncestors">
+            <summary>
+            Return a list of all ancestors of this node.  The first node of
+            list is the root and the last is the parent of this node.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.ChildIndex">
+            <summary>This node is what child index? 0..n-1</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.FreshenParentAndChildIndexes">
+            <summary>Set the parent and child index values for all children</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.AddChild(Antlr.Runtime.Tree.ITree)">
+            <summary>
+            Add t as a child to this node.  If t is null, do nothing.  If t
+            is nil, add all children of t to this' children.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.SetChild(System.Int32,Antlr.Runtime.Tree.ITree)">
+            <summary>Set ith child (0..n-1) to t; t must be non-null and non-nil node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.ReplaceChildren(System.Int32,System.Int32,System.Object)">
+            <summary>
+            Delete children from start to stop and replace with t even if t is
+            a list (nil-root tree).  num of children can increase or decrease.
+            For huge child lists, inserting children can force walking rest of
+            children to set their childindex; could be slow.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.IsNil">
+            <summary>
+            Indicates the node is a nil node but may still have children, meaning
+            the tree is a flat list.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.TokenStartIndex">
+            <summary>
+            What is the smallest token index (indexing from 0) for this node
+            and its children?
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.TokenStopIndex">
+            <summary>
+            What is the largest token index (indexing from 0) for this node
+            and its children?
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.Type">
+            <summary>Return a token type; needed for tree parsing</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.Line">
+            <summary>In case we don't have a token payload, what is the line for errors?</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITreeAdaptor">
+            <summary>
+              How to create and navigate trees.  Rather than have a separate factory
+              and adaptor, I've merged them.  Makes sense to encapsulate.
+              </summary>
+            
+              <remarks>
+              This takes the place of the tree construction code generated in the
+              generated code in 2.x and the ASTFactory.
+            
+              I do not need to know the type of a tree at all so they are all
+              generic Objects.  This may increase the amount of typecasting needed. :(
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(Antlr.Runtime.IToken)">
+            <summary>
+              Create a tree node from Token object; for CommonTree type trees,
+              then the token just becomes the payload.  This is the most
+              common create call.
+              </summary>
+            
+              <remarks>
+              Override if you want another kind of node to be built.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,Antlr.Runtime.IToken)">
+            <summary>
+              Create a new node derived from a token, with a new token type.
+              This is invoked from an imaginary node ref on right side of a
+              rewrite rule as IMAG[$tokenLabel].
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(Token).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,Antlr.Runtime.IToken,System.String)">
+            <summary>
+              Same as create(tokenType,fromToken) except set the text too.
+              This is invoked from an imaginary node ref on right side of a
+              rewrite rule as IMAG[$tokenLabel, "IMAG"].
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(Token).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(Antlr.Runtime.IToken,System.String)">
+            <summary>
+              Same as create(fromToken) except set the text too.
+              This is invoked when the <c>text</c> terminal option is set, as in
+              IMAG&lt;text='IMAG'&gt;.
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(Token).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,System.String)">
+            <summary>
+              Create a new node derived from a token, with a new token type.
+              This is invoked from an imaginary node ref on right side of a
+              rewrite rule as IMAG["IMAG"].
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(int,String).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DupNode(System.Object)">
+            <summary>Duplicate a single tree node.</summary>
+            <remarks>Override if you want another kind of node to be built.</remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DupTree(System.Object)">
+            <summary>Duplicate tree recursively, using dupNode() for each node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Nil">
+            <summary>
+            Return a nil node (an empty but non-null node) that can hold
+            a list of element as the children.  If you want a flat tree (a list)
+            use "t=adaptor.nil(); t.addChild(x); t.addChild(y);"
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.ErrorNode(Antlr.Runtime.ITokenStream,Antlr.Runtime.IToken,Antlr.Runtime.IToken,Antlr.Runtime.RecognitionException)">
+            <summary>
+              Return a tree node representing an error.  This node records the
+              tokens consumed during error recovery.  The start token indicates the
+              input symbol at which the error was detected.  The stop token indicates
+              the last symbol consumed during recovery.
+              </summary>
+            
+              <remarks>
+              You must specify the input stream so that the erroneous text can
+              be packaged up in the error node.  The exception could be useful
+              to some applications; default implementation stores ptr to it in
+              the CommonErrorNode.
+            
+              This only makes sense during token parsing, not tree parsing.
+              Tree parsing should happen only when parsing and tree construction
+              succeed.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.IsNil(System.Object)">
+            <summary>Is tree considered a nil node used to make lists of child nodes?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.AddChild(System.Object,System.Object)">
+            <summary>
+            Add a child to the tree t.  If child is a flat tree (a list), make all
+            in list children of t.  Warning: if t has no children, but child does
+            and child isNil then you can decide it is ok to move children to t via
+            t.children = child.children; i.e., without copying the array.  Just
+            make sure that this is consistent with have the user will build
+            ASTs.  Do nothing if t or child is null.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(System.Object,System.Object)">
+            <summary>
+              If oldRoot is a nil root, just copy or move the children to newRoot.
+              If not a nil root, make oldRoot a child of newRoot.
+              </summary>
+            
+              <remarks>
+                old=^(nil a b c), new=r yields ^(r a b c)
+                old=^(a b c), new=r yields ^(r ^(a b c))
+            
+              If newRoot is a nil-rooted single child tree, use the single
+              child as the new root node.
+            
+                old=^(nil a b c), new=^(nil r) yields ^(r a b c)
+                old=^(a b c), new=^(nil r) yields ^(r ^(a b c))
+            
+              If oldRoot was null, it's ok, just return newRoot (even if isNil).
+            
+                old=null, new=r yields r
+                old=null, new=^(nil r) yields ^(nil r)
+            
+              Return newRoot.  Throw an exception if newRoot is not a
+              simple node or nil root with a single child node--it must be a root
+              node.  If newRoot is ^(nil x) return x as newRoot.
+            
+              Be advised that it's ok for newRoot to point at oldRoot's
+              children; i.e., you don't have to copy the list.  We are
+              constructing these nodes so we should have this control for
+              efficiency.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.RulePostProcessing(System.Object)">
+            <summary>
+              Given the root of the subtree created for this rule, post process
+              it to do any simplifications or whatever you want.  A required
+              behavior is to convert ^(nil singleSubtree) to singleSubtree
+              as the setting of start/stop indexes relies on a single non-nil root
+              for non-flat trees.
+              </summary>
+            
+              <remarks>
+              Flat trees such as for lists like "idlist : ID+ ;" are left alone
+              unless there is only one ID.  For a list, the start/stop indexes
+              are set in the nil node.
+            
+              This method is executed after all rule tree construction and right
+              before setTokenBoundaries().
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetUniqueID(System.Object)">
+            <summary>For identifying trees.</summary>
+            
+              <remarks>
+              How to identify nodes so we can say "add node to a prior node"?
+              Even becomeRoot is an issue.  Use System.identityHashCode(node)
+              usually.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(Antlr.Runtime.IToken,System.Object)">
+            <summary>
+              Create a node for newRoot make it the root of oldRoot.
+              If oldRoot is a nil root, just copy or move the children to newRoot.
+              If not a nil root, make oldRoot a child of newRoot.
+              </summary>
+            
+              <returns>
+              Return node created for newRoot.
+              </returns>
+            
+              <remarks>
+              Be advised: when debugging ASTs, the DebugTreeAdaptor manually
+              calls create(Token child) and then plain becomeRoot(node, node)
+              because it needs to trap calls to create, but it can't since it delegates
+              to not inherits from the TreeAdaptor.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetType(System.Object)">
+            <summary>For tree parsing, I need to know the token type of a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetType(System.Object,System.Int32)">
+            <summary>Node constructors can set the type of a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetText(System.Object,System.String)">
+            <summary>Node constructors can set the text of a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetToken(System.Object)">
+            <summary>
+            Return the token object from which this node was created.
+            Currently used only for printing an error message.
+            The error display routine in BaseRecognizer needs to
+            display where the input the error occurred. If your
+            tree of limitation does not store information that can
+            lead you to the token, you can create a token filled with
+            the appropriate information and pass that back.  See
+            BaseRecognizer.getErrorMessage().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetTokenBoundaries(System.Object,Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
+            <summary>
+            Where are the bounds in the input token stream for this node and
+            all children?  Each rule that creates AST nodes will call this
+            method right before returning.  Flat trees (i.e., lists) will
+            still usually have a nil root node just to hold the children list.
+            That node would contain the start/stop indexes then.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetTokenStartIndex(System.Object)">
+            <summary>Get the token start index for this subtree; return -1 if no such index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetTokenStopIndex(System.Object)">
+            <summary>Get the token stop index for this subtree; return -1 if no such index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChild(System.Object,System.Int32)">
+            <summary>Get a child 0..n-1 node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetChild(System.Object,System.Int32,System.Object)">
+            <summary>Set ith child (0..n-1) to t; t must be non-null and non-nil node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DeleteChild(System.Object,System.Int32)">
+            <summary>Remove ith child and shift children down from right.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChildCount(System.Object)">
+            <summary>How many children?  If 0, then this is a leaf node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetParent(System.Object)">
+            <summary>
+            Who is the parent node of this node; if null, implies node is root.
+            If your node type doesn't handle this, it's ok but the tree rewrites
+            in tree parsers need this functionality.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChildIndex(System.Object)">
+            <summary>
+            What index is this node in the child list? Range: 0..n-1
+            If your node type doesn't handle this, it's ok but the tree rewrites
+            in tree parsers need this functionality.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.ReplaceChildren(System.Object,System.Int32,System.Int32,System.Object)">
+            <summary>
+              Replace from start to stop child index of parent with t, which might
+              be a list.  Number of children may be different after this call.
+              </summary>
+            
+              <remarks>
+              If parent is null, don't do anything; must be at root of overall tree.
+              Can't replace whatever points to the parent externally.  Do nothing.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITreeNodeStream">
+            <summary>A stream of tree nodes, accessing nodes from a tree of some kind</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.Item(System.Int32)">
+            <summary>
+            Get a tree node at an absolute index i; 0..n-1.
+            If you don't want to buffer up nodes, then this method makes no
+            sense for you.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.LT(System.Int32)">
+            <summary>
+             Get tree node at current input pointer + <paramref name="k"/> ahead where
+             <paramref name="k"/>==1 is next node. <paramref name="k"/>&lt;0 indicates nodes in the past. So
+             {@code LT(-1)} is previous node, but implementations are not required to
+             provide results for <paramref name="k"/> &lt; -1. {@code LT(0)} is undefined. For
+             <paramref name="k"/>&lt;=n, return <see langword="null"/>. Return <see langword="null"/> for {@code LT(0)}
+             and any index that results in an absolute address that is negative.
+              </summary>
+            
+              <remarks>
+             This is analogous to <see cref="M:Antlr.Runtime.ITokenStream.LT(System.Int32)"/>, but this returns a tree node
+             instead of a <see cref="T:Antlr.Runtime.IToken"/>. Makes code generation identical for both
+             parser and tree grammars.
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TreeSource">
+            <summary>
+            Where is this stream pulling nodes from?  This is not the name, but
+            the object that provides node objects.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TokenStream">
+            <summary>
+            If the tree associated with this stream was created from a
+            {@link TokenStream}, you can specify it here. Used to do rule
+            {@code $text} attribute in tree parser. Optional unless you use tree
+            parser rule {@code $text} attribute or {@code output=template} and
+            {@code rewrite=true} options.
+             </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TreeAdaptor">
+            <summary>
+            What adaptor can tell me how to interpret/navigate nodes and
+            trees.  E.g., get text of a node.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.UniqueNavigationNodes">
+            <summary>
+            As we flatten the tree, we use {@link Token#UP}, {@link Token#DOWN} nodes
+            to represent the tree structure. When debugging we need unique nodes so
+            we have to instantiate new ones. When doing normal tree parsing, it's
+            slow and a waste of memory to create unique navigation nodes. Default
+            should be {@code false}.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.ToString(System.Object,System.Object)">
+            <summary>
+            Return the text of all nodes from {@code start} to {@code stop},
+            inclusive. If the stream does not buffer all the nodes then it can still
+            walk recursively from start until stop. You can always return
+            {@code null} or {@code ""} too, but users should not access
+            {@code $ruleLabel.text} in an action of course in that case.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.ReplaceChildren(System.Object,System.Int32,System.Int32,System.Object)">
+            <summary>
+             Replace children of {@code parent} from index {@code startChildIndex} to
+             {@code stopChildIndex} with {@code t}, which might be a list. Number of
+             children may be different after this call. The stream is notified because
+             it is walking the tree and might need to know you are monkeying with the
+             underlying tree. Also, it might be able to modify the node stream to
+             avoid restreaming for future phases.
+              </summary>
+            
+              <remarks>
+             If {@code parent} is {@code null}, don't do anything; must be at root of
+             overall tree. Can't replace whatever points to the parent externally. Do
+             nothing.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITreeVisitorAction">
+            <summary>
+            How to execute code for node t when a visitor visits node t.  Execute
+            pre() before visiting children and execute post() after visiting children.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeVisitorAction.Pre(System.Object)">
+            <summary>
+            Execute an action before visiting children of t.  Return t or
+            a rewritten t.  It is up to the visitor to decide what to do
+            with the return value.  Children of returned value will be
+            visited if using TreeVisitor.visit().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeVisitorAction.Post(System.Object)">
+            <summary>
+            Execute an action after visiting children of t.  Return t or
+            a rewritten t.  It is up to the visitor to decide what to do
+            with the return value.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ParseTree">
+            <summary>
+            A record of the rules used to match a token sequence.  The tokens
+            end up as the leaves of this tree and rule nodes are the interior nodes.
+            This really adds no functionality, it is just an alias for CommonTree
+            that is more meaningful (specific) and holds a String to display for a node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ParseTree.ToStringWithHiddenTokens">
+            <summary>
+            Emit a token and all hidden nodes before.  EOF node holds all
+            hidden tokens after last real token.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ParseTree.ToInputString">
+            <summary>
+            Print out the leaves of this tree, which means printing original
+            input back out.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteCardinalityException">
+            <summary>
+            Base class for all exceptions thrown during AST rewrite construction.
+            This signifies a case where the cardinality of two or more elements
+            in a subrule are different: (ID INT)+ where |ID|!=|INT|
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteEarlyExitException">
+            <summary>No elements within a (...)+ in a rewrite rule</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteEmptyStreamException">
+            <summary>Ref to ID or expr but no tokens in ID stream or subtrees in expr stream</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteRuleElementStream">
+            <summary>
+              A generic list of elements tracked in an alternative to be used in
+              a -> rewrite rule.  We need to subclass to fill in the next() method,
+              which returns either an AST node wrapped around a token payload or
+              an existing subtree.
+              </summary>
+            
+              <remarks>
+              Once you start next()ing, do not try to add more elements.  It will
+              break the cursor tracking I believe.
+            
+              TODO: add mechanism to detect/puke on modification after reading from stream
+              </remarks>
+            
+              <see cref="T:Antlr.Runtime.Tree.RewriteRuleSubtreeStream"/>
+              <see cref="T:Antlr.Runtime.Tree.RewriteRuleTokenStream"/>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.cursor">
+            <summary>
+            Cursor 0..n-1.  If singleElement!=null, cursor is 0 until you next(),
+            which bumps it to 1 meaning no more elements.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.singleElement">
+            <summary>Track single elements w/o creating a list.  Upon 2nd add, alloc list</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.elements">
+            <summary>The list of tokens or subtrees we are tracking</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.dirty">
+            <summary>Once a node / subtree has been used in a stream, it must be dup'd
+            from then on.  Streams are reset after subrules so that the streams
+            can be reused in future subrules.  So, reset must set a dirty bit.
+            If dirty, then next() always returns a dup.</summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.elementDescription">
+            <summary>The element or stream description; usually has name of the token or
+            rule reference that this list tracks.  Can include rulename too, but
+            the exception would track that info.</summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.Reset">
+            <summary>
+            Reset the condition of this stream so that it appears we have
+            not consumed any of its elements.  Elements themselves are untouched.
+            Once we reset the stream, any future use will need duplicates.  Set
+            the dirty bit.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.NextTree">
+            <summary>
+            Return the next element in the stream.  If out of elements, throw
+            an exception unless size()==1.  If size is 1, then return elements[0].
+            Return a duplicate node/subtree if stream is out of elements and
+            size==1.  If we've already used the element, dup (dirty bit set).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.NextCore">
+            <summary>
+            Do the work of getting the next element, making sure that it's
+            a tree node or subtree.  Deal with the optimization of single-
+            element list versus list of size > 1.  Throw an exception
+            if the stream is empty or we're out of elements and size>1.
+            protected so you can override in a subclass if necessary.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.Dup(System.Object)">
+            <summary>
+             When constructing trees, sometimes we need to dup a token or AST
+            	subtree.  Dup'ing a token means just creating another AST node
+             around it.  For trees, you must call the adaptor.dupTree() unless
+             the element is for a tree root; then it must be a node dup.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.ToTree(System.Object)">
+            <summary>
+            Ensure stream emits trees; tokens must be converted to AST nodes.
+            AST nodes can be passed through unmolested.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteRuleNodeStream">
+            <summary>
+            Queues up nodes matched on left side of -> in a tree parser. This is
+            the analog of RewriteRuleTokenStream for normal parsers.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleNodeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleNodeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.NextNode">
+            <summary>
+              Treat next element as a single node even if it's a subtree.
+              This is used instead of next() when the result has to be a
+              tree root node.  Also prevents us from duplicating recently-added
+              children; e.g., ^(type ID)+ adds ID to type and then 2nd iteration
+              must dup the type node, but ID has been added.
+              </summary>
+            
+              <remarks>
+              Referencing a rule result twice is ok; dup entire tree as
+              we can't be adding trees as root; e.g., expr expr.
+            
+              Hideous code duplication here with super.next().  Can't think of
+              a proper way to refactor.  This needs to always call dup node
+              and super.next() doesn't know which to call: dup node or dup tree.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.NextNode">
+            <summary>Get next token from stream and make a node for it</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.ToTree(System.Object)">
+            <summary>
+            Don't convert to a tree unless they explicitly call nextTree.
+            This way we can do hetero tree nodes in rewrite.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeIterator">
+            Return a node stream from a doubly-linked tree whose nodes
+              know what child index they are.  No remove() is supported.
+            
+              Emit navigation nodes (DOWN, UP, and EOF) to let show tree structure.
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreeIterator.nodes">
+            If we emit UP/DOWN nodes, we need to spit out multiple nodes per
+            next() call.
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeParser">
+            <summary>
+            A parser for a stream of tree nodes.  "tree grammars" result in a subclass
+            of this.  All the error reporting and recovery is shared with Parser via
+            the BaseRecognizer superclass.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.SetTreeNodeStream(Antlr.Runtime.Tree.ITreeNodeStream)">
+            <summary>Set the input stream</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.MatchAny(Antlr.Runtime.IIntStream)">
+            <summary>
+            Match '.' in tree parser has special meaning.  Skip node or
+            entire tree if node has children.  If children, scan until
+            corresponding UP node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.RecoverFromMismatchedToken(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>
+            We have DOWN/UP nodes in the stream that have no line info; override.
+            plus we want to alter the exception type.  Don't try to recover
+            from tree parser errors inline...
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.GetErrorHeader(Antlr.Runtime.RecognitionException)">
+            <summary>
+            Prefix error message with the grammar name because message is
+            always intended for the programmer because the parser built
+            the input tree not the user.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.GetErrorMessage(Antlr.Runtime.RecognitionException,System.String[])">
+            <summary>
+            Tree parsers parse nodes they usually have a token object as
+            payload. Set the exception token and do the default behavior.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.pattern">
+            <summary>The tree pattern to lex like "(A B C)"</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.p">
+            <summary>Index into input string</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.c">
+            <summary>Current char</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.n">
+            <summary>How long is the pattern in char?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.sval">
+            <summary>Set when token type is ID or ARG (name mimics Java's StreamTokenizer)</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeRewriter.ReportTransformation(System.Object,System.Object)">
+            Override this if you need transformation tracing to go somewhere
+            other than stdout or if you're not using ITree-derived trees.
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeRuleReturnScope`1">
+            <summary>
+            This is identical to the ParserRuleReturnScope except that
+            the start property is a tree nodes not Token object
+            when you are parsing trees.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.TreeRuleReturnScope`1.Start">
+            <summary>Gets the first node or root node of tree matched for this rule.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeVisitor">
+            <summary>Do a depth first walk of a tree, applying pre() and post() actions as we go.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeVisitor.Visit(System.Object,Antlr.Runtime.Tree.ITreeVisitorAction)">
+            <summary>
+            Visit every node in tree t and trigger an action for each node
+            before/after having visited all of its children.  Bottom up walk.
+            Execute both actions even if t has no children.  Ignore return
+            results from transforming children since they will have altered
+            the child list of this node (their parent).  Return result of
+            applying post action to this node.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeWizard">
+            <summary>
+              Build and navigate trees with this object.  Must know about the names
+              of tokens so you have to pass in a map or array of token names (from which
+              this class can build the map).  I.e., Token DECL means nothing unless the
+              class can translate it to a token type.
+              </summary>
+            
+              <remarks>
+              In order to create nodes and navigate, this class needs a TreeAdaptor.
+            
+              This class can build a token type -> node index for repeated use or for
+              iterating over the various nodes with a particular type.
+            
+              This class works in conjunction with the TreeAdaptor rather than moving
+              all this functionality into the adaptor.  An adaptor helps build and
+              navigate trees using methods.  This class helps you do it with string
+              patterns like "(A B C)".  You can create a tree from that pattern or
+              match subtrees against it.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeWizard.TreePattern">
+            <summary>
+            When using %label:TOKENNAME in a tree for parse(), we must
+            track the label.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeWizard.TreePatternTreeAdaptor">
+            <summary>This adaptor creates TreePattern objects for use during scan()</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.ComputeTokenTypes(System.String[])">
+            <summary>
+            Compute a Map&lt;String, Integer&gt; that is an inverted index of
+            tokenNames (which maps int token types to names).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.GetTokenType(System.String)">
+            <summary>Using the map of token names to token types, return the type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Index(System.Object)">
+            <summary>
+              Walk the entire tree and make a node name to nodes mapping.
+              For now, use recursion but later nonrecursive version may be
+              more efficient.  Returns Map&lt;Integer, List&gt; where the List is
+              of your AST node type.  The Integer is the token type of the node.
+              </summary>
+            
+              <remarks>
+              TODO: save this index so that find and visit are faster
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.IndexCore(System.Object,System.Collections.Generic.IDictionary{System.Int32,System.Collections.IList})">
+            <summary>Do the work for index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Find(System.Object,System.Int32)">
+            <summary>Return a List of tree nodes with token type ttype</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Find(System.Object,System.String)">
+            <summary>Return a List of subtrees matching pattern.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Visit(System.Object,System.Int32,Antlr.Runtime.Tree.TreeWizard.IContextVisitor)">
+            <summary>
+            Visit every ttype node in t, invoking the visitor.  This is a quicker
+            version of the general visit(t, pattern) method.  The labels arg
+            of the visitor action method is never set (it's null) since using
+            a token type rather than a pattern doesn't let us set a label.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.VisitCore(System.Object,System.Object,System.Int32,System.Int32,Antlr.Runtime.Tree.TreeWizard.IContextVisitor)">
+            <summary>Do the recursive work for visit</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Visit(System.Object,System.String,Antlr.Runtime.Tree.TreeWizard.IContextVisitor)">
+            <summary>
+            For all subtrees that match the pattern, execute the visit action.
+            The implementation uses the root node of the pattern in combination
+            with visit(t, ttype, visitor) so nil-rooted patterns are not allowed.
+            Patterns with wildcard roots are also not allowed.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Parse(System.Object,System.String,System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+              Given a pattern like (ASSIGN %lhs:ID %rhs:.) with optional labels
+              on the various nodes and '.' (dot) as the node/subtree wildcard,
+              return true if the pattern matches and fill the labels Map with
+              the labels pointing at the appropriate nodes.  Return false if
+              the pattern is malformed or the tree does not match.
+              </summary>
+            
+              <remarks>
+              If a node specifies a text arg in pattern, then that must match
+              for that node in t.
+            
+              TODO: what's a better way to indicate bad pattern? Exceptions are a hassle 
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.ParseCore(System.Object,Antlr.Runtime.Tree.TreeWizard.TreePattern,System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+            Do the work for parse. Check to see if the t2 pattern fits the
+            structure and token types in t1.  Check text if the pattern has
+            text arguments on nodes.  Fill labels map with pointers to nodes
+            in tree matched against nodes in pattern with labels.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Create(System.String)">
+            <summary>
+              Create a tree or node from the indicated tree pattern that closely
+              follows ANTLR tree grammar tree element syntax:
+            
+                  (root child1 ... child2).
+              </summary>
+            
+              <remarks>
+              You can also just pass in a node: ID
+             
+              Any node can have a text argument: ID[foo]
+              (notice there are no quotes around foo--it's clear it's a string).
+            
+              nil is a special name meaning "give me a nil node".  Useful for
+              making lists: (nil A B C) is a list of A B C.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Equals(System.Object,System.Object,Antlr.Runtime.Tree.ITreeAdaptor)">
+            <summary>
+              Compare t1 and t2; return true if token types/text, structure match exactly.
+              The trees are examined in their entirety so that (A B) does not match
+              (A B C) nor (A (B C)). 
+              </summary>
+            
+              <remarks>
+              TODO: allow them to pass in a comparator
+              TODO: have a version that is nonstatic so it can use instance adaptor
+            
+              I cannot rely on the tree node's equals() implementation as I make
+              no constraints at all on the node types nor interface etc... 
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Equals(System.Object,System.Object)">
+            <summary>
+            Compare type, structure, and text of two trees, assuming adaptor in
+            this instance of a TreeWizard.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.UnbufferedTokenStream">
+            A token stream that pulls tokens from the code source on-demand and
+              without tracking a complete buffer of the tokens. This stream buffers
+              the minimum number of tokens possible.  It's the same as
+              OnDemandTokenStream except that OnDemandTokenStream buffers all tokens.
+            
+              You can't use this stream if you pass whitespace or other off-channel
+              tokens to the parser. The stream can't ignore off-channel tokens.
+             
+              You can only look backwards 1 token: LT(-1).
+            
+              Use this when you need to read from a socket or other infinite stream.
+            
+              @see BufferedTokenStream
+              @see CommonTokenStream
+        </member>
+        <member name="F:Antlr.Runtime.UnbufferedTokenStream.channel">
+            Skip tokens on any channel but this one; this is how we skip whitespace... 
+        </member>
+        <member name="T:Antlr.Runtime.UnwantedTokenException">
+            <summary>An extra token while parsing a TokenStream</summary> 
+        </member>
+    </members>
+</doc>
diff --git a/packages/Antlr3.Runtime.3.5.1/lib/netstandard1.1/Antlr3.Runtime.dll b/packages/Antlr3.Runtime.3.5.1/lib/netstandard1.1/Antlr3.Runtime.dll
new file mode 100644
index 0000000..1bab12e
Binary files /dev/null and b/packages/Antlr3.Runtime.3.5.1/lib/netstandard1.1/Antlr3.Runtime.dll differ
diff --git a/packages/Antlr3.Runtime.3.5.1/lib/netstandard1.1/Antlr3.Runtime.xml b/packages/Antlr3.Runtime.3.5.1/lib/netstandard1.1/Antlr3.Runtime.xml
new file mode 100644
index 0000000..31d731f
--- /dev/null
+++ b/packages/Antlr3.Runtime.3.5.1/lib/netstandard1.1/Antlr3.Runtime.xml
@@ -0,0 +1,3220 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>Antlr3.Runtime</name>
+    </assembly>
+    <members>
+        <member name="T:Antlr.Runtime.ANTLRInputStream">
+            <summary>
+            A kind of ReaderStream that pulls from an InputStream.
+            Useful for reading from stdin and specifying file encodings etc...
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.ANTLRReaderStream">
+            <summary>
+              Vacuum all input from a Reader and then treat it like a StringStream.
+              Manage the buffer manually to avoid unnecessary data copying.
+              </summary>
+            
+              <remarks>
+              If you need encoding, use ANTLRInputStream.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.ANTLRStringStream">
+            <summary>
+            A pretty quick CharStream that pulls all data from an array
+            directly.  Every method call counts in the lexer.  Java's
+            strings aren't very good so I'm avoiding.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.data">
+            <summary>The data being scanned</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.n">
+            <summary>How many characters are actually in the buffer</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.p">
+            <summary>0..n-1 index into string of next char</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.line">
+            <summary>line number 1..n within the input</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.charPositionInLine">
+            <summary>The index of the character relative to the beginning of the line 0..n-1</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.markDepth">
+            <summary>tracks how deep mark() calls are nested</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.markers">
+            <summary>
+            A list of CharStreamState objects that tracks the stream state
+            values line, charPositionInLine, and p that can change as you
+            move through the input stream.  Indexed from 1..markDepth.
+            A null is kept @ index 0.  Create upon first call to mark().
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.name">
+            <summary>What is name or source of this char stream?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.#ctor(System.String)">
+            <summary>Copy data in string to a local char array</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.#ctor(System.Char[],System.Int32)">
+            <summary>This is the preferred constructor as no data is copied</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.ANTLRStringStream.Index">
+            <summary>
+            Return the current input symbol index 0..n where n indicates the
+            last symbol has been read.  The index is the index of char to
+            be returned from LA(1).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.Reset">
+            <summary>
+            Reset the stream so that it's in the same state it was
+            when the object was created *except* the data array is not
+            touched.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.Seek(System.Int32)">
+            <summary>
+            consume() ahead until p==index; can't just set p=index as we must
+            update line and charPositionInLine.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.BaseRecognizer">
+            <summary>
+            A generic recognizer that can handle recognizers generated from
+            lexer, parser, and tree grammars.  This is all the parsing
+            support code essentially; most of it is error recovery stuff and
+            backtracking.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.BaseRecognizer.state">
+            <summary>
+            State of a lexer, parser, or tree parser are collected into a state
+            object so the state can be shared.  This sharing is needed to
+            have one grammar import others and share same error variables
+            and other state variables.  It's a kind of explicit multiple
+            inheritance via delegation of methods and shared state.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Reset">
+            <summary>reset the parser's state; subclasses must rewinds the input stream</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Match(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>
+              Match current input symbol against ttype.  Attempt
+              single token insertion or deletion error recovery.  If
+              that fails, throw MismatchedTokenException.
+              </summary>
+            
+              <remarks>
+              To turn off single token insertion or deletion error
+              recovery, override recoverFromMismatchedToken() and have it
+              throw an exception. See TreeParser.recoverFromMismatchedToken().
+              This way any error in a rule will cause an exception and
+              immediate exit from rule.  Rule would recover by resynchronizing
+              to the set of symbols that can follow rule ref.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.MatchAny(Antlr.Runtime.IIntStream)">
+            <summary>Match the wildcard: in a symbol</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ReportError(Antlr.Runtime.RecognitionException)">
+            <summary>Report a recognition problem.</summary>
+            
+              <remarks>
+              This method sets errorRecovery to indicate the parser is recovering
+              not parsing.  Once in recovery mode, no errors are generated.
+              To get out of recovery mode, the parser must successfully match
+              a token (after a resync).  So it will go:
+            
+             		1. error occurs
+             		2. enter recovery mode, report error
+             		3. consume until token found in resynch set
+             		4. try to resume parsing
+             		5. next match() will reset errorRecovery mode
+            
+              If you override, make sure to update syntaxErrors if you care about that.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetErrorMessage(Antlr.Runtime.RecognitionException,System.String[])">
+            <summary>What error message should be generated for the various exception types?</summary>
+            
+              <remarks>
+              Not very object-oriented code, but I like having all error message
+              generation within one method rather than spread among all of the
+              exception classes. This also makes it much easier for the exception
+              handling because the exception classes do not have to have pointers back
+              to this object to access utility routines and so on. Also, changing
+              the message for an exception type would be difficult because you
+              would have to subclassing exception, but then somehow get ANTLR
+              to make those kinds of exception objects instead of the default.
+              This looks weird, but trust me--it makes the most sense in terms
+              of flexibility.
+            
+              For grammar debugging, you will want to override this to add
+              more information such as the stack frame with
+              getRuleInvocationStack(e, this.getClass().getName()) and,
+              for no viable alts, the decision description and state etc...
+            
+              Override this to change the message generated for one or more
+              exception types.
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.NumberOfSyntaxErrors">
+            <summary>
+              Get number of recognition errors (lexer, parser, tree parser).  Each
+              recognizer tracks its own number.  So parser and lexer each have
+              separate count.  Does not count the spurious errors found between
+              an error and next valid token match
+              </summary>
+            
+              <seealso cref="M:Antlr.Runtime.BaseRecognizer.ReportError(Antlr.Runtime.RecognitionException)"/>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetErrorHeader(Antlr.Runtime.RecognitionException)">
+            <summary>What is the error header, normally line/character position information?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetTokenErrorDisplay(Antlr.Runtime.IToken)">
+            <summary>
+            How should a token be displayed in an error message? The default
+            is to display just the text, but during development you might
+            want to have a lot of information spit out.  Override in that case
+            to use t.ToString() (which, for CommonToken, dumps everything about
+            the token). This is better than forcing you to override a method in
+            your token objects because you don't have to go modify your lexer
+            so that it creates a new Java type.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.EmitErrorMessage(System.String)">
+            <summary>Override this method to change where error messages go</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Recover(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException)">
+            <summary>
+            Recover from an error found on the input stream.  This is
+            for NoViableAlt and mismatched symbol exceptions.  If you enable
+            single token insertion and deletion, this will usually not
+            handle mismatched symbol exceptions but there could be a mismatched
+            token that the match() routine could not recover from.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.BeginResync">
+            <summary>
+            A hook to listen in on the token consumption during error recovery.
+            The DebugParser subclasses this to fire events to the listenter.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ComputeContextSensitiveRuleFOLLOW">
+            <summary>
+              Compute the context-sensitive FOLLOW set for current rule.
+              This is set of token types that can follow a specific rule
+              reference given a specific call chain.  You get the set of
+              viable tokens that can possibly come next (lookahead depth 1)
+              given the current call chain.  Contrast this with the
+              definition of plain FOLLOW for rule r:
+              </summary>
+            
+               FOLLOW(r)={x | S=>*alpha r beta in G and x in FIRST(beta)}
+            
+              where x in T* and alpha, beta in V*; T is set of terminals and
+              V is the set of terminals and nonterminals.  In other words,
+              FOLLOW(r) is the set of all tokens that can possibly follow
+              references to r in *any* sentential form (context).  At
+              runtime, however, we know precisely which context applies as
+              we have the call chain.  We may compute the exact (rather
+              than covering superset) set of following tokens.
+            
+              For example, consider grammar:
+            
+              stat : ID '=' expr ';'      // FOLLOW(stat)=={EOF}
+                   | "return" expr '.'
+                   ;
+              expr : atom ('+' atom)* ;   // FOLLOW(expr)=={';','.',')'}
+              atom : INT                  // FOLLOW(atom)=={'+',')',';','.'}
+                   | '(' expr ')'
+                   ;
+            
+              The FOLLOW sets are all inclusive whereas context-sensitive
+              FOLLOW sets are precisely what could follow a rule reference.
+              For input input "i=(3);", here is the derivation:
+            
+              stat => ID '=' expr ';'
+                   => ID '=' atom ('+' atom)* ';'
+                   => ID '=' '(' expr ')' ('+' atom)* ';'
+                   => ID '=' '(' atom ')' ('+' atom)* ';'
+                   => ID '=' '(' INT ')' ('+' atom)* ';'
+                   => ID '=' '(' INT ')' ';'
+            
+              At the "3" token, you'd have a call chain of
+            
+                stat -> expr -> atom -> expr -> atom
+            
+              What can follow that specific nested ref to atom?  Exactly ')'
+              as you can see by looking at the derivation of this specific
+              input.  Contrast this with the FOLLOW(atom)={'+',')',';','.'}.
+            
+              You want the exact viable token set when recovering from a
+              token mismatch.  Upon token mismatch, if LA(1) is member of
+              the viable next token set, then you know there is most likely
+              a missing token in the input stream.  "Insert" one by just not
+              throwing an exception.
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.RecoverFromMismatchedToken(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>Attempt to recover from a single missing or extra token.</summary>
+            
+              EXTRA TOKEN
+            
+              LA(1) is not what we are looking for.  If LA(2) has the right token,
+              however, then assume LA(1) is some extra spurious token.  Delete it
+              and LA(2) as if we were doing a normal match(), which advances the
+              input.
+            
+              MISSING TOKEN
+            
+              If current token is consistent with what could come after
+              ttype then it is ok to "insert" the missing token, else throw
+              exception For example, Input "i=(3;" is clearly missing the
+              ')'.  When the parser returns from the nested call to expr, it
+              will have call chain:
+            
+                stat -> expr -> atom
+            
+              and it will be trying to match the ')' at this point in the
+              derivation:
+            
+                   => ID '=' '(' INT ')' ('+' atom)* ';'
+                                      ^
+              match() will see that ';' doesn't match ')' and report a
+              mismatched token error.  To recover, it sees that LA(1)==';'
+              is in the set of tokens that can follow the ')' token
+              reference in rule atom.  It can assume that you forgot the ')'.
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.RecoverFromMismatchedSet(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException,Antlr.Runtime.BitSet)">
+            Not currently used 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetCurrentInputSymbol(Antlr.Runtime.IIntStream)">
+            <summary>
+              Match needs to return the current input symbol, which gets put
+              into the label for the associated token ref; e.g., x=ID.  Token
+              and tree parsers need to return different objects. Rather than test
+              for input stream type or change the IntStream interface, I use
+              a simple method to ask the recognizer to tell me what the current
+              input symbol is.
+              </summary>
+            
+              <remarks>This is ignored for lexers.</remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetMissingSymbol(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>Conjure up a missing token during error recovery.</summary>
+            
+              <remarks>
+              The recognizer attempts to recover from single missing
+              symbols. But, actions might refer to that missing symbol.
+              For example, x=ID {f($x);}. The action clearly assumes
+              that there has been an identifier matched previously and that
+              $x points at that token. If that token is missing, but
+              the next token in the stream is what we want we assume that
+              this token is missing and we keep going. Because we
+              have to return some token to replace the missing token,
+              we have to conjure one up. This method gives the user control
+              over the tokens returned for missing tokens. Mostly,
+              you will want to create something special for identifier
+              tokens. For literals such as '{' and ',', the default
+              action in the parser or tree parser works. It simply creates
+              a CommonToken of the appropriate type. The text will be the token.
+              If you change what tokens must be created by the lexer,
+              override this method to create the appropriate tokens.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ConsumeUntil(Antlr.Runtime.IIntStream,Antlr.Runtime.BitSet)">
+            <summary>Consume tokens until one matches the given token set</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.PushFollow(Antlr.Runtime.BitSet)">
+            <summary>Push a rule's follow set using our own hardcoded stack</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.Failed">
+            <summary>Return whether or not a backtracking attempt failed.</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.TokenNames">
+            <summary>
+            Used to print out token names like ID during debugging and
+            error reporting.  The generated parsers implement a method
+            that overrides this to point to their String[] tokenNames.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.GrammarFileName">
+            <summary>
+            For debugging and other purposes, might want the grammar name.
+            Have ANTLR generate an implementation for this method.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ToStrings(System.Collections.Generic.ICollection{Antlr.Runtime.IToken})">
+            <summary>
+            A convenience method for use most often with template rewrites.
+            Convert a list of <see cref="T:Antlr.Runtime.IToken"/> to a list of <see cref="T:System.String"/>.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleMemoization(System.Int32,System.Int32)">
+            <summary>
+              Given a rule number and a start token index number, return
+              MEMO_RULE_UNKNOWN if the rule has not parsed input starting from
+              start index.  If this rule has parsed input starting from the
+              start index before, then return where the rule stopped parsing.
+              It returns the index of the last token matched by the rule.
+              </summary>
+            
+              <remarks>
+              For now we use a hashtable and just the slow Object-based one.
+              Later, we can make a special one for ints and also one that
+              tosses out data after we commit past input position i.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.AlreadyParsedRule(Antlr.Runtime.IIntStream,System.Int32)">
+            <summary>
+              Has this rule already parsed input at the current index in the
+              input stream?  Return the stop token index or MEMO_RULE_UNKNOWN.
+              If we attempted but failed to parse properly before, return
+              MEMO_RULE_FAILED.
+              </summary>
+            
+              <remarks>
+              This method has a side-effect: if we have seen this input for
+              this rule and successfully parsed before, then seek ahead to
+              1 past the stop token matched for this rule last time.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Memoize(Antlr.Runtime.IIntStream,System.Int32,System.Int32)">
+            <summary>
+            Record whether or not this rule parsed the input at this position
+            successfully.  Use a standard java hashtable for now.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleMemoizationCacheSize">
+            <summary>return how many rule/input-index pairs there are in total.</summary>
+            TODO: this includes synpreds. :(
+        </member>
+        <member name="T:Antlr.Runtime.BitSet">
+            <summary>
+            A stripped-down version of org.antlr.misc.BitSet that is just
+            good enough to handle runtime requirements such as FOLLOW sets
+            for automatic error recovery.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.BitSet.MOD_MASK">
+            <summary>
+            We will often need to do a mod operator (i mod nbits).  Its
+            turns out that, for powers of two, this mod operation is
+            same as (i &amp; (nbits-1)).  Since mod is slow, we use a
+            precomputed mod mask to do the mod instead.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.BitSet._bits">
+            <summary>The actual data bits</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor">
+            <summary>Construct a bitset of size one word (64 bits)</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor(System.UInt64[])">
+            <summary>Construction from a static array of longs</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor(System.Collections.Generic.IEnumerable{System.Int32})">
+            <summary>Construction from a list of integers</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor(System.Int32)">
+            <summary>Construct a bitset given the size</summary>
+            <param name="nbits">The size of the bitset in bits</param>
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.Or(Antlr.Runtime.BitSet)">
+            <summary>return this | a in a new set</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.Add(System.Int32)">
+            <summary>or this element into this set (grow as necessary to accommodate)</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.GrowToInclude(System.Int32)">
+            <summary>Grows the set to a larger number of bits.</summary>
+            <param name="bit">element that must fit in set</param>
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.SetSize(System.Int32)">
+            <summary>Sets the size of a set.</summary>
+            <param name="nwords">how many words the new set should be</param>
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.LengthInLongWords">
+            <summary>return how much space is being used by the bits array not how many actually have member bits on.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.ToArray">
+            Is this contained within a? 
+        </member>
+        <member name="T:Antlr.Runtime.BufferedTokenStream">
+            Buffer all input tokens but do on-demand fetching of new tokens from
+              lexer. Useful when the parser or lexer has to set context/mode info before
+              proper lexing of future tokens. The ST template parser needs this,
+              for example, because it has to constantly flip back and forth between
+              inside/output templates. E.g., <c>&lt;names:{hi, &lt;it&gt;}&gt;</c> has to parse names
+              as part of an expression but "hi, &lt;it&gt;" as a nested template.
+            
+              You can't use this stream if you pass whitespace or other off-channel
+              tokens to the parser. The stream can't ignore off-channel tokens.
+              (UnbufferedTokenStream is the same way.)
+            
+              This is not a subclass of UnbufferedTokenStream because I don't want
+              to confuse small moving window of tokens it uses for the full buffer.
+        </member>
+        <member name="F:Antlr.Runtime.BufferedTokenStream._tokens">
+            Record every single token pulled from the source so we can reproduce
+            chunks of it later.  The buffer in LookaheadStream overlaps sometimes
+            as its moving window moves through the input.  This list captures
+            everything so we can access complete input text.
+        </member>
+        <member name="F:Antlr.Runtime.BufferedTokenStream._lastMarker">
+            Track the last mark() call result value for use in rewind(). 
+        </member>
+        <member name="F:Antlr.Runtime.BufferedTokenStream._p">
+            The index into the tokens list of the current token (next token
+            to consume).  tokens[p] should be LT(1).  p=-1 indicates need
+            to initialize with first token.  The ctor doesn't get a token.
+            First call to LT(1) or whatever gets the first token and sets p=0;
+        </member>
+        <member name="P:Antlr.Runtime.BufferedTokenStream.Range">
+            <summary>
+            How deep have we gone?
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.Consume">
+            Move the input pointer to the next incoming token.  The stream
+              must become active with LT(1) available.  consume() simply
+              moves the input pointer so that LT(1) points at the next
+              input symbol. Consume at least one token.
+            
+              Walk past any token not on the channel the parser is listening to.
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.Sync(System.Int32)">
+            Make sure index i in tokens has a token. 
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.Fetch(System.Int32)">
+            add n elements to buffer 
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.GetTokens(System.Int32,System.Int32,Antlr.Runtime.BitSet)">
+            Given a start and stop index, return a List of all tokens in
+            the token type BitSet.  Return null if no tokens were found.  This
+            method looks at both on and off channel tokens.
+        </member>
+        <member name="T:Antlr.Runtime.CharStreamState">
+            <summary>
+              When walking ahead with cyclic DFA or for syntactic predicates,
+              we need to record the state of the input stream (char index,
+              line, etc...) so that we can rewind the state after scanning ahead.
+              </summary>
+            
+              <remarks>This is the complete state of a stream.</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.CharStreamState.p">
+            <summary>Index into the char stream of next lookahead char</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CharStreamState.line">
+            <summary>What line number is the scanner at before processing buffer[p]?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CharStreamState.charPositionInLine">
+            <summary>What char position 0..n-1 in line is scanner before processing buffer[p]?</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.ClassicToken">
+            <summary>
+            A Token object like we'd use in ANTLR 2.x; has an actual string created
+            and associated with this object.  These objects are needed for imaginary
+            tree nodes that have payload objects.  We need to create a Token object
+            that has a string; the tree node will point at this token.  CommonToken
+            has indexes into a char stream and hence cannot be used to introduce
+            new strings.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.ClassicToken.index">
+            <summary>What token number is this from 0..n-1 tokens</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.text">
+            <summary>
+            We need to be able to change the text once in a while.  If
+            this is non-null, then getText should return this.  Note that
+            start/stop are not affected by changing this.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.index">
+            <summary>What token number is this from 0..n-1 tokens; &lt; 0 implies invalid index</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.start">
+            <summary>The char position into the input buffer where this token starts</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.stop">
+            <summary>The char position into the input buffer where this token stops</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.CommonTokenStream">
+            <summary>
+              The most common stream of tokens is one where every token is buffered up
+              and tokens are prefiltered for a certain channel (the parser will only
+              see these tokens and cannot change the filter channel number during the
+              parse).
+              </summary>
+            
+              <remarks>TODO: how to access the full token stream?  How to track all tokens matched per rule?</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.CommonTokenStream._channel">
+            Skip tokens on any channel but this one; this is how we skip whitespace... 
+        </member>
+        <member name="P:Antlr.Runtime.CommonTokenStream.TokenSource">
+            Reset this token stream by setting its token source. 
+        </member>
+        <member name="M:Antlr.Runtime.CommonTokenStream.Consume">
+            Always leave p on an on-channel token. 
+        </member>
+        <member name="M:Antlr.Runtime.CommonTokenStream.SkipOffTokenChannels(System.Int32)">
+            Given a starting index, return the index of the first on-channel
+            token.
+        </member>
+        <member name="T:Antlr.Runtime.Debug.IDebugEventListener">
+            <summary>All debugging events that a recognizer can trigger.</summary>
+            
+              <remarks>
+              I did not create a separate AST debugging interface as it would create
+              lots of extra classes and DebugParser has a dbg var defined, which makes
+              it hard to change to ASTDebugEventListener.  I looked hard at this issue
+              and it is easier to understand as one monolithic event interface for all
+              possible events.  Hopefully, adding ST debugging stuff won't be bad.  Leave
+              for future. 4/26/2006.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterRule(System.String,System.String)">
+            <summary>
+            The parser has just entered a rule.  No decision has been made about
+            which alt is predicted.  This is fired AFTER init actions have been
+            executed.  Attributes are defined and available etc...
+            The grammarFileName allows composite grammars to jump around among
+            multiple grammar files.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterAlt(System.Int32)">
+            <summary>
+            Because rules can have lots of alternatives, it is very useful to
+            know which alt you are entering.  This is 1..n for n alts.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ExitRule(System.String,System.String)">
+            <summary>
+            This is the last thing executed before leaving a rule.  It is
+            executed even if an exception is thrown.  This is triggered after
+            error reporting and recovery have occurred (unless the exception is
+            not caught in this rule).  This implies an "exitAlt" event.
+            The grammarFileName allows composite grammars to jump around among
+            multiple grammar files.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterSubRule(System.Int32)">
+            <summary>Track entry into any (...) subrule other EBNF construct</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterDecision(System.Int32,System.Boolean)">
+            <summary>
+            Every decision, fixed k or arbitrary, has an enter/exit event
+            so that a GUI can easily track what LT/consume events are
+            associated with prediction.  You will see a single enter/exit
+            subrule but multiple enter/exit decision events, one for each
+            loop iteration.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeToken(Antlr.Runtime.IToken)">
+            <summary>
+            An input token was consumed; matched by any kind of element.
+            Trigger after the token was matched by things like match(), matchAny().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeHiddenToken(Antlr.Runtime.IToken)">
+            <summary>
+            An off-channel input token was consumed.
+            Trigger after the token was matched by things like match(), matchAny().
+            (unless of course the hidden token is first stuff in the input stream).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.LT(System.Int32,Antlr.Runtime.IToken)">
+            <summary>
+            Somebody (anybody) looked ahead.  Note that this actually gets
+            triggered by both LA and LT calls.  The debugger will want to know
+            which Token object was examined.  Like consumeToken, this indicates
+            what token was seen at that depth.  A remote debugger cannot look
+            ahead into a file it doesn't have so LT events must pass the token
+            even if the info is redundant.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Mark(System.Int32)">
+            <summary>
+            The parser is going to look arbitrarily ahead; mark this location,
+            the token stream's marker is sent in case you need it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Rewind(System.Int32)">
+            <summary>
+            After an arbitrairly long lookahead as with a cyclic DFA (or with
+            any backtrack), this informs the debugger that stream should be
+            rewound to the position associated with marker.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Rewind">
+            <summary>
+            Rewind to the input position of the last marker.
+            Used currently only after a cyclic DFA and just
+            before starting a sem/syn predicate to get the
+            input position back to the start of the decision.
+            Do not "pop" the marker off the state.  mark(i)
+            and rewind(i) should balance still.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Location(System.Int32,System.Int32)">
+            <summary>
+              To watch a parser move through the grammar, the parser needs to
+              inform the debugger what line/charPos it is passing in the grammar.
+              For now, this does not know how to switch from one grammar to the
+              other and back for island grammars etc...
+              </summary>
+            
+              <remarks>
+              This should also allow breakpoints because the debugger can stop
+              the parser whenever it hits this line/pos.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.RecognitionException(Antlr.Runtime.RecognitionException)">
+            <summary>
+              A recognition exception occurred such as NoViableAltException.  I made
+              this a generic event so that I can alter the exception hierachy later
+              without having to alter all the debug objects.
+              </summary>
+            
+              <remarks>
+              Upon error, the stack of enter rule/subrule must be properly unwound.
+              If no viable alt occurs it is within an enter/exit decision, which
+              also must be rewound.  Even the rewind for each mark must be unwount.
+              In the Java target this is pretty easy using try/finally, if a bit
+              ugly in the generated code.  The rewind is generated in DFA.predict()
+              actually so no code needs to be generated for that.  For languages
+              w/o this "finally" feature (C++?), the target implementor will have
+              to build an event stack or something.
+            
+              Across a socket for remote debugging, only the RecognitionException
+              data fields are transmitted.  The token object or whatever that
+              caused the problem was the last object referenced by LT.  The
+              immediately preceding LT event should hold the unexpected Token or
+              char.
+            
+              Here is a sample event trace for grammar:
+            
+              b : C ({;}A|B) // {;} is there to prevent A|B becoming a set
+                | D
+                ;
+            
+              The sequence for this rule (with no viable alt in the subrule) for
+              input 'c c' (there are 3 tokens) is:
+            
+            		commence
+            		LT(1)
+            		enterRule b
+            		location 7 1
+            		enter decision 3
+            		LT(1)
+            		exit decision 3
+            		enterAlt1
+            		location 7 5
+            		LT(1)
+            		consumeToken [c/&lt;4&gt;,1:0]
+            		location 7 7
+            		enterSubRule 2
+            		enter decision 2
+            		LT(1)
+            		LT(1)
+            		recognitionException NoViableAltException 2 1 2
+            		exit decision 2
+            		exitSubRule 2
+            		beginResync
+            		LT(1)
+            		consumeToken [c/&lt;4&gt;,1:1]
+            		LT(1)
+            		endResync
+            		LT(-1)
+            		exitRule b
+            		terminate
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.BeginResync">
+            <summary>
+            Indicates the recognizer is about to consume tokens to resynchronize
+            the parser.  Any consume events from here until the recovered event
+            are not part of the parse--they are dead tokens.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EndResync">
+            <summary>
+            Indicates that the recognizer has finished consuming tokens in order
+            to resychronize.  There may be multiple beginResync/endResync pairs
+            before the recognizer comes out of errorRecovery mode (in which
+            multiple errors are suppressed).  This will be useful
+            in a gui where you want to probably grey out tokens that are consumed
+            but not matched to anything in grammar.  Anything between
+            a beginResync/endResync pair was tossed out by the parser.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.SemanticPredicate(System.Boolean,System.String)">
+            <summary>A semantic predicate was evaluate with this result and action text</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Commence">
+            <summary>
+            Announce that parsing has begun.  Not technically useful except for
+            sending events over a socket.  A GUI for example will launch a thread
+            to connect and communicate with a remote parser.  The thread will want
+            to notify the GUI when a connection is made.  ANTLR parsers
+            trigger this upon entry to the first rule (the ruleLevel is used to
+            figure this out).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Terminate">
+            <summary>
+            Parsing is over; successfully or not.  Mostly useful for telling
+            remote debugging listeners that it's time to quit.  When the rule
+            invocation level goes to zero at the end of a rule, we are done
+            parsing.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeNode(System.Object)">
+            <summary>
+              Input for a tree parser is an AST, but we know nothing for sure
+              about a node except its type and text (obtained from the adaptor).
+              This is the analog of the consumeToken method.  Again, the ID is
+              the hashCode usually of the node so it only works if hashCode is
+              not implemented.  If the type is UP or DOWN, then
+              the ID is not really meaningful as it's fixed--there is
+              just one UP node and one DOWN navigation node.
+              </summary>
+            
+              <param name="t" />
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.LT(System.Int32,System.Object)">
+            <summary>
+            The tree parser lookedahead.  If the type is UP or DOWN,
+            then the ID is not really meaningful as it's fixed--there is
+            just one UP node and one DOWN navigation node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.NilNode(System.Object)">
+            <summary>
+              A nil was created (even nil nodes have a unique ID...
+              they are not "null" per se).  As of 4/28/2006, this
+              seems to be uniquely triggered when starting a new subtree
+              such as when entering a subrule in automatic mode and when
+              building a tree in rewrite mode.
+              </summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only t.ID is set.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ErrorNode(System.Object)">
+            <summary>
+              Upon syntax error, recognizers bracket the error with an error node
+              if they are building ASTs.
+              </summary>
+            
+              <param name="t"/>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.CreateNode(System.Object)">
+            <summary>Announce a new node built from token elements such as type etc...</summary>
+            
+             <remarks>
+             If you are receiving this event over a socket via
+             RemoteDebugEventSocketListener then only t.ID, type, text are
+             set.
+             </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.CreateNode(System.Object,Antlr.Runtime.IToken)">
+            <summary>Announce a new node built from an existing token.</summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only node.ID and token.tokenIndex
+              are set.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.BecomeRoot(System.Object,System.Object)">
+            <summary>Make a node the new root of an existing root.  See</summary>
+            
+              <remarks>
+              Note: the newRootID parameter is possibly different
+              than the TreeAdaptor.becomeRoot() newRoot parameter.
+              In our case, it will always be the result of calling
+              TreeAdaptor.becomeRoot() and not root_n or whatever.
+            
+              The listener should assume that this event occurs
+              only when the current subrule (or rule) subtree is
+              being reset to newRootID.
+             
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only IDs are set.
+              </remarks>
+            
+              <seealso cref="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(System.Object,System.Object)"/>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.AddChild(System.Object,System.Object)">
+            <summary>Make childID a child of rootID.</summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only IDs are set.
+              </remarks>
+            
+              <seealso cref="M:Antlr.Runtime.Tree.ITreeAdaptor.AddChild(System.Object,System.Object)"/>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.SetTokenBoundaries(System.Object,System.Int32,System.Int32)">
+            <summary>Set the token start/stop token index for a subtree root or node.</summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only t.ID is set.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.DFA">
+            <summary>A DFA implemented as a set of transition tables.</summary>
+            
+              <remarks>
+              Any state that has a semantic predicate edge is special; those states
+              are generated with if-then-else structures in a specialStateTransition()
+              which is generated by cyclicDFA template.
+            
+              There are at most 32767 states (16-bit signed short).
+              Could get away with byte sometimes but would have to generate different
+              types and the simulation code too.  For a point of reference, the Java
+              lexer's Tokens rule DFA has 326 states roughly.
+              </remarks>
+        </member>
+        <member name="F:Antlr.Runtime.DFA.recognizer">
+            <summary>Which recognizer encloses this DFA?  Needed to check backtracking</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.DFA.Predict(Antlr.Runtime.IIntStream)">
+            <summary>
+            From the input stream, predict what alternative will succeed
+            using this DFA (representing the covering regular approximation
+            to the underlying CFL).  Return an alternative number 1..n.  Throw
+            an exception upon error.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.DFA.Error(Antlr.Runtime.NoViableAltException)">
+            <summary>A hook for debugging interface</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.DFA.UnpackEncodedString(System.String)">
+            <summary>
+            Given a String that has a run-length-encoding of some unsigned shorts
+            like "\1\2\3\9", convert to short[] {2,9,9,9}.  We do this to avoid
+            static short[] which generates so much init code that the class won't
+            compile. :(
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.DFA.UnpackEncodedStringToUnsignedChars(System.String)">
+            <summary>Hideous duplication of code, but I need different typed arrays out :(</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.EarlyExitException">
+            <summary>The recognizer did not match anything for a (..)+ loop.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.FailedPredicateException">
+            <summary>
+            A semantic predicate failed during validation.  Validation of predicates
+            occurs when normally parsing the alternative just like matching a token.
+            Disambiguating predicate evaluation occurs when we hoist a predicate into
+            a prediction decision.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.IAstRuleReturnScope">
+            <summary>AST rules have trees</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IAstRuleReturnScope.Tree">
+            <summary>Has a value potentially if output=AST;</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.IAstRuleReturnScope`1">
+            <summary>AST rules have trees</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IAstRuleReturnScope`1.Tree">
+            <summary>Has a value potentially if output=AST;</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.ICharStream">
+            <summary>A source of characters for an ANTLR lexer</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ICharStream.Substring(System.Int32,System.Int32)">
+            <summary>
+            For infinite streams, you don't need this; primarily I'm providing
+            a useful interface for action code.  Just make sure actions don't
+            use this on streams that don't support it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ICharStream.LT(System.Int32)">
+            <summary>
+            Get the ith character of lookahead.  This is the same usually as
+            LA(i).  This will be used for labels in the generated
+            lexer code.  I'd prefer to return a char here type-wise, but it's
+            probably better to be 32-bit clean and be consistent with LA.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.ICharStream.Line">
+            <summary>ANTLR tracks the line information automatically</summary> 
+            <summary>Because this stream can rewind, we need to be able to reset the line</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.ICharStream.CharPositionInLine">
+            <summary>The index of the character relative to the beginning of the line 0..n-1</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.IIntStream">
+            <summary>
+            A simple stream of integers used when all I care about is the char
+            or token type sequence (such as interpretation).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.LA(System.Int32)">
+            <summary>
+            Get int at current input pointer + i ahead where i=1 is next int.
+            Negative indexes are allowed.  LA(-1) is previous token (token
+            just matched).  LA(-i) where i is before first token should
+            yield -1, invalid char / EOF.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Mark">
+            <summary>
+            Tell the stream to start buffering if it hasn't already.  Return
+            current input position, Index, or some other marker so that
+            when passed to rewind() you get back to the same spot.
+            rewind(mark()) should not affect the input cursor.  The Lexer
+            track line/col info as well as input index so its markers are
+            not pure input indexes.  Same for tree node streams.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IIntStream.Index">
+            <summary>
+            Return the current input symbol index 0..n where n indicates the
+            last symbol has been read.  The index is the symbol about to be
+            read not the most recently read symbol.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Rewind(System.Int32)">
+            <summary>
+            Reset the stream so that next call to index would return marker.
+            The marker will usually be Index but it doesn't have to be.  It's
+            just a marker to indicate what state the stream was in.  This is
+            essentially calling release() and seek().  If there are markers
+            created after this marker argument, this routine must unroll them
+            like a stack.  Assume the state the stream was in when this marker
+            was created.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Rewind">
+            <summary>
+            Rewind to the input position of the last marker.
+            Used currently only after a cyclic DFA and just
+            before starting a sem/syn predicate to get the
+            input position back to the start of the decision.
+            Do not "pop" the marker off the state.  mark(i)
+            and rewind(i) should balance still. It is
+            like invoking rewind(last marker) but it should not "pop"
+            the marker off.  It's like seek(last marker's input position).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Release(System.Int32)">
+            <summary>
+            You may want to commit to a backtrack but don't want to force the
+            stream to keep bookkeeping objects around for a marker that is
+            no longer necessary.  This will have the same behavior as
+            rewind() except it releases resources without the backward seek.
+            This must throw away resources for all markers back to the marker
+            argument.  So if you're nested 5 levels of mark(), and then release(2)
+            you have to release resources for depths 2..5.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Seek(System.Int32)">
+            <summary>
+              Set the input cursor to the position indicated by index.  This is
+              normally used to seek ahead in the input stream.  No buffering is
+              required to do this unless you know your stream will use seek to
+              move backwards such as when backtracking.
+              </summary>
+            
+              <remarks>
+              This is different from rewind in its multi-directional
+              requirement and in that its argument is strictly an input cursor (index).
+            
+              For char streams, seeking forward must update the stream state such
+              as line number.  For seeking backwards, you will be presumably
+              backtracking using the mark/rewind mechanism that restores state and
+              so this method does not need to update state when seeking backwards.
+            
+              Currently, this method is only used for efficient backtracking using
+              memoization, but in the future it may be used for incremental parsing.
+            
+              The index is 0..n-1.  A seek to position i means that LA(1) will
+              return the ith symbol.  So, seeking to 0 means LA(1) will return the
+              first element in the stream. 
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.IIntStream.Count">
+            <summary>
+            Only makes sense for streams that buffer everything up probably, but
+            might be useful to display the entire stream or for testing.  This
+            value includes a single EOF.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IIntStream.SourceName">
+            <summary>
+            Where are you getting symbols from?  Normally, implementations will
+            pass the buck all the way to the lexer who can ask its input stream
+            for the file name or whatever.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.IRuleReturnScope">
+            <summary>
+            Rules can have start/stop info.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope.Start">
+            <summary>
+            Gets the start element from the input stream
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope.Stop">
+            <summary>
+            Gets the stop element from the input stream
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.IRuleReturnScope`1">
+            <summary>
+            Rules can have start/stop info.
+            </summary>
+            <typeparam name="TLabel">The element type of the input stream.</typeparam>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope`1.Start">
+            <summary>
+            Gets the start element from the input stream
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope`1.Stop">
+            <summary>
+            Gets the stop element from the input stream
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IToken.Text">
+            <summary>Get the text of the token</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IToken.Line">
+            <summary>The line number on which this token was matched; line=1..n</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IToken.CharPositionInLine">
+            <summary>The index of the first character relative to the beginning of the line 0..n-1</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IToken.TokenIndex">
+            <summary>
+            An index from 0..n-1 of the token object in the input stream.
+            This must be valid in order to use the ANTLRWorks debugger.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IToken.InputStream">
+            <summary>
+            From what character stream was this token created?  You don't have to
+            implement but it's nice to know where a Token comes from if you have
+            include files etc... on the input.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.ITokenSource">
+            <summary>
+              A source of tokens must provide a sequence of tokens via nextToken()
+              and also must reveal it's source of characters; CommonToken's text is
+              computed from a CharStream; it only store indices into the char stream.
+              </summary>
+            
+              <remarks>
+              Errors from the lexer are never passed to the parser.  Either you want
+              to keep going or you do not upon token recognition error.  If you do not
+              want to continue lexing then you do not want to continue parsing.  Just
+              throw an exception not under RecognitionException and Java will naturally
+              toss you all the way out of the recognizers.  If you want to continue
+              lexing then you should not throw an exception to the parser--it has already
+              requested a token.  Keep lexing until you get a valid one.  Just report
+              errors and keep going, looking for a valid token.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenSource.NextToken">
+            <summary>
+            Return a Token object from your input stream (usually a CharStream).
+            Do not fail/return upon lexing error; keep chewing on the characters
+            until you get a good one; errors are not passed through to the parser.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.ITokenSource.SourceName">
+            <summary>
+            Where are you getting tokens from? normally the implication will simply
+            ask lexers input stream.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.ITokenStream">
+            <summary>A stream of tokens accessing tokens from a TokenSource</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.LT(System.Int32)">
+            <summary>Get Token at current input pointer + i ahead where i=1 is next Token.
+            i&lt;0 indicates tokens in the past.  So -1 is previous token and -2 is
+            two tokens ago. LT(0) is undefined.  For i&gt;=n, return Token.EOFToken.
+            Return null for LT(0) and any index that results in an absolute address
+            that is negative.</summary>
+        </member>
+        <member name="P:Antlr.Runtime.ITokenStream.Range">
+            <summary>
+            How far ahead has the stream been asked to look?  The return
+            value is a valid index from 0..n-1.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.Get(System.Int32)">
+            <summary>
+            Get a token at an absolute index i; 0..n-1.  This is really only
+            needed for profiling and debugging and token stream rewriting.
+            If you don't want to buffer up tokens, then this method makes no
+            sense for you.  Naturally you can't use the rewrite stream feature.
+            I believe DebugTokenStream can easily be altered to not use
+            this method, removing the dependency.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.ITokenStream.TokenSource">
+            <summary>
+            Where is this stream pulling tokens from?  This is not the name, but
+            the object that provides Token objects.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.ToString(System.Int32,System.Int32)">
+            <summary>
+            Return the text of all tokens from start to stop, inclusive.
+            If the stream does not buffer all the tokens then it can just
+            return "" or null;  Users should not access $ruleLabel.text in
+            an action of course in that case.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.ToString(Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
+            <summary>
+            Because the user is not required to use a token with an index stored
+            in it, we must provide a means for two token objects themselves to
+            indicate the start/end location.  Most often this will just delegate
+            to the other toString(int,int).  This is also parallel with
+            the TreeNodeStream.toString(Object,Object).
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.LegacyCommonTokenStream">
+            <summary>
+              The most common stream of tokens is one where every token is buffered up
+              and tokens are prefiltered for a certain channel (the parser will only
+              see these tokens and cannot change the filter channel number during the
+              parse).
+              </summary>
+            
+              <remarks>TODO: how to access the full token stream?  How to track all tokens matched per rule?</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.tokens">
+            <summary>
+            Record every single token pulled from the source so we can reproduce
+            chunks of it later.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.channelOverrideMap">
+            <summary>Map from token type to channel to override some Tokens' channel numbers</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.discardSet">
+            <summary>Set of token types; discard any tokens with this type</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.channel">
+            <summary>Skip tokens on any channel but this one; this is how we skip whitespace...</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.discardOffChannelTokens">
+            <summary>By default, track all incoming tokens</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.p">
+            <summary>
+            The index into the tokens list of the current token (next token
+            to consume).  p==-1 indicates that the tokens list is empty
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.LegacyCommonTokenStream.Range">
+            <summary>
+            How deep have we gone?
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.SetTokenSource(Antlr.Runtime.ITokenSource)">
+            <summary>Reset this token stream by setting its token source.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.FillBuffer">
+            <summary>
+            Load all tokens from the token source and put in tokens.
+            This is done upon first LT request because you might want to
+            set some token type / channel overrides before filling buffer.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.Consume">
+            <summary>
+              Move the input pointer to the next incoming token.  The stream
+              must become active with LT(1) available.  consume() simply
+              moves the input pointer so that LT(1) points at the next
+              input symbol. Consume at least one token.
+              </summary>
+            
+              <remarks>
+              Walk past any token not on the channel the parser is listening to.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.SkipOffTokenChannels(System.Int32)">
+            <summary>Given a starting index, return the index of the first on-channel token.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.SetTokenTypeChannel(System.Int32,System.Int32)">
+            <summary>
+            A simple filter mechanism whereby you can tell this token stream
+            to force all tokens of type ttype to be on channel.  For example,
+            when interpreting, we cannot exec actions so we need to tell
+            the stream to force all WS and NEWLINE to be a different, ignored
+            channel.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.GetTokens(System.Int32,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>
+            Given a start and stop index, return a List of all tokens in
+            the token type BitSet.  Return null if no tokens were found.  This
+            method looks at both on and off channel tokens.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.LT(System.Int32)">
+            <summary>
+            Get the ith token from the current position 1..n where k=1 is the
+            first symbol of lookahead.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.LB(System.Int32)">
+            <summary>Look backwards k tokens on-channel tokens</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.Get(System.Int32)">
+            <summary>
+            Return absolute token i; ignore which channel the tokens are on;
+            that is, count all tokens not just on-channel tokens.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Lexer">
+            <summary>
+            A lexer is recognizer that draws input symbols from a character stream.
+            lexer grammars result in a subclass of this object. A Lexer object
+            uses simplified match() and error recovery mechanisms in the interest
+            of speed.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Lexer.input">
+            <summary>Where is the lexer drawing characters from?</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Lexer.Text">
+            <summary>
+            Gets or sets the text matched so far for the current token or any text override.
+            </summary>
+            <remarks>
+            <para>Setting this value replaces any previously set value, and overrides the original text.</para>
+            </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.NextToken">
+            <summary>Return a token from this source; i.e., match a token on the char stream.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.GetEndOfFileToken">
+            Returns the EOF token (default), if you need
+            to return a custom token instead override this method.
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Skip">
+            <summary>
+            Instruct the lexer to skip creating a token for current lexer rule
+            and look for another token.  nextToken() knows to keep looking when
+            a lexer rule finishes with token set to SKIP_TOKEN.  Recall that
+            if token==null at end of any token rule, it creates one for you
+            and emits it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.mTokens">
+            <summary>This is the lexer entry point that sets instance var 'token'</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Emit(Antlr.Runtime.IToken)">
+            <summary>
+            Currently does not support multiple emits per nextToken invocation
+            for efficiency reasons.  Subclass and override this method and
+            nextToken (to push tokens into a list and pull from that list rather
+            than a single variable as this implementation does).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Emit">
+            <summary>
+              The standard method called to automatically emit a token at the
+              outermost lexical rule.  The token object should point into the
+              char buffer start..stop.  If there is a text override in 'text',
+              use that to set the token's text.  Override this method to emit
+              custom Token objects.
+              </summary>
+            
+              <remarks>
+              If you are building trees, then you should also override
+              Parser or TreeParser.getMissingSymbol().
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.Lexer.CharIndex">
+            <summary>What is the index of the current character of lookahead?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Recover(Antlr.Runtime.RecognitionException)">
+            <summary>
+            Lexers can normally match any char in it's vocabulary after matching
+            a token, so do the easy thing and just kill a character and hope
+            it all works out.  You can instead use the rule invocation stack
+            to do sophisticated error recovery if you are in a fragment rule.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Misc.FastQueue`1">
+            A queue that can dequeue and get(i) in O(1) and grow arbitrarily large.
+              A linked list is fast at dequeue but slow at get(i).  An array is
+              the reverse.  This is O(1) for both operations.
+            
+              List grows until you dequeue last element at end of buffer. Then
+              it resets to start filling at 0 again.  If adds/removes are balanced, the
+              buffer will not grow too large.
+            
+              No iterator stuff as that's not how we'll use it.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.FastQueue`1._data">
+            <summary>dynamically-sized buffer of elements</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Misc.FastQueue`1._p">
+            <summary>index of next element to fill</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Misc.FastQueue`1.Range">
+            <summary>
+            How deep have we gone?
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Misc.FastQueue`1.Item(System.Int32)">
+            <summary>
+            Return element {@code i} elements ahead of current element. {@code i==0}
+            gets current element. This is not an absolute index into {@link #data}
+            since {@code p} defines the start of the real list.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Misc.FastQueue`1.Dequeue">
+            <summary>Get and remove first element in queue</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.FastQueue`1.ToString">
+            <summary>Return string of current buffer contents; non-destructive</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Misc.LookaheadStream`1">
+            <summary>
+            A lookahead queue that knows how to mark/release locations in the buffer for
+            backtracking purposes. Any markers force the {@link FastQueue} superclass to
+            keep all elements until no more markers; then can reset to avoid growing a
+            huge buffer.
+             </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._currentElementIndex">
+            Absolute token index. It's the index of the symbol about to be
+            read via {@code LT(1)}. Goes from 0 to numtokens.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._previousElement">
+            This is the {@code LT(-1)} element for the first element in {@link #data}.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._eof">
+            Track object returned by nextElement upon end of stream;
+            Return it later when they ask for LT passed end of input.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._markDepth">
+            <summary>tracks how deep mark() calls are nested</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.NextElement">
+            <summary>
+            Implement nextElement to supply a stream of elements to this
+            lookahead buffer.  Return EOF upon end of the stream we're pulling from.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Dequeue">
+            <summary>
+            Get and remove first element in queue; override
+            {@link FastQueue#remove()}; it's the same, just checks for backtracking.
+            </summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Consume">
+            <summary>Make sure we have at least one element to remove, even if EOF</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.SyncAhead(System.Int32)">
+            <summary>
+            Make sure we have 'need' elements from current position p. Last valid
+            p index is data.size()-1.  p+need-1 is the data index 'need' elements
+            ahead.  If we need 1 element, (p+1-1)==p must be &lt; data.size().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Fill(System.Int32)">
+            <summary>add n elements to buffer</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Misc.LookaheadStream`1.Count">
+            <summary>Size of entire stream is unknown; we only know buffer size from FastQueue</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Seek(System.Int32)">
+            <summary>
+            Seek to a 0-indexed absolute token index. Normally used to seek backwards
+            in the buffer. Does not force loading of nodes.
+             </summary>
+             <remarks>
+            To preserve backward compatibility, this method allows seeking past the
+            end of the currently buffered data. In this case, the input pointer will
+            be moved but the data will only actually be loaded upon the next call to
+            {@link #consume} or {@link #LT} for {@code k>0}.
+             </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.MismatchedTokenException">
+            <summary>A mismatched char or Token or tree node</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.MissingTokenException">
+            <summary>
+            We were expecting a token but it's not found.  The current token
+            is actually what we wanted next.  Used for tree node errors too.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Parser">
+            <summary>
+            A parser for TokenStreams.  "parser grammars" result in a subclass
+            of this.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Parser.TokenStream">
+            <summary>Gets or sets the token stream; resets the parser upon a set.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.ParserRuleReturnScope`1">
+            <summary>
+              Rules that return more than a single value must return an object
+              containing all the values.  Besides the properties defined in
+              RuleLabelScope.predefinedRulePropertiesScope there may be user-defined
+              return values.  This class simply defines the minimum properties that
+              are always defined and methods to access the others that might be
+              available depending on output option such as template and tree.
+              </summary>
+            
+              <remarks>
+              Note text is not an actual property of the return value, it is computed
+              from start and stop using the input stream's toString() method.  I
+              could add a ctor to this so that we can pass in and store the input
+              stream, but I'm not sure we want to do that.  It would seem to be undefined
+              to get the .text property anyway if the rule matches tokens from multiple
+              input streams.
+            
+              I do not use getters for fields of objects that are used simply to
+              group values such as this aggregate.  The getters/setters are there to
+              satisfy the superclass interface.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.RecognitionException">
+            <summary>The root of the ANTLR exception hierarchy.</summary>
+            
+              <remarks>
+              To avoid English-only error messages and to generally make things
+              as flexible as possible, these exceptions are not created with strings,
+              but rather the information necessary to generate an error.  Then
+              the various reporting methods in Parser and Lexer can be overridden
+              to generate a localized error message.  For example, MismatchedToken
+              exceptions are built with the expected token type.
+              So, don't expect getMessage() to return anything.
+            
+              Note that as of Java 1.4, you can access the stack trace, which means
+              that you can compute the complete trace of rules from the start symbol.
+              This gives you considerable context information with which to generate
+              useful error messages.
+            
+              ANTLR generates code that throws exceptions upon recognition error and
+              also generates code to catch these exceptions in each rule.  If you
+              want to quit upon first error, you can turn off the automatic error
+              handling mechanism using rulecatch action, but you still need to
+              override methods mismatch and recoverFromMismatchSet.
+            
+              In general, the recognition exceptions can track where in a grammar a
+              problem occurred and/or what was the expected input.  While the parser
+              knows its state (such as current input symbol and line info) that
+              state can change before the exception is reported so current token index
+              is computed and stored at exception time.  From this info, you can
+              perhaps print an entire line of input not just a single token, for example.
+              Better to just say the recognizer had a problem and then let the parser
+              figure out a fancy report.
+              </remarks>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._input">
+            <summary>What input stream did the error occur in?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._k">
+            <summary>
+            What was the lookahead index when this exception was thrown?
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._index">
+            <summary>What is index of token/char were we looking at when the error occurred?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._token">
+            <summary>
+            The current Token when an error occurred.  Since not all streams
+            can retrieve the ith Token, we have to track the Token object.
+            For parsers.  Even when it's a tree parser, token might be set.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._node">
+            <summary>
+            If this is a tree parser exception, node is set to the node with
+            the problem.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._c">
+            <summary>The current char when an error occurred. For lexers.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._line">
+            <summary>
+            Track the line (1-based) at which the error occurred in case this is
+            generated from a lexer.  We need to track this since the
+            unexpected char doesn't carry the line info.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._charPositionInLine">
+            <summary>
+            The 0-based index into the line where the error occurred.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._approximateLineInfo">
+            <summary>
+            If you are parsing a tree node stream, you will encounter som
+            imaginary nodes w/o line/col info.  We now search backwards looking
+            for most recent token with line/col info, but notify getErrorHeader()
+            that info is approximate.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.RecognitionException.#ctor">
+            <summary>Used for remote debugger deserialization</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.RecognitionException.UnexpectedType">
+            <summary>Return the token type or char of the unexpected input element</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.RecognizerSharedState">
+            <summary>
+              The set of fields needed by an abstract recognizer to recognize input
+              and recover from errors etc...  As a separate state object, it can be
+              shared among multiple grammars; e.g., when one grammar imports another.
+              </summary>
+            
+              <remarks>
+              These fields are publically visible but the actual state pointer per
+              parser is protected.
+              </remarks>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.following">
+            <summary>
+            Track the set of token types that can follow any rule invocation.
+            Stack grows upwards.  When it hits the max, it grows 2x in size
+            and keeps going.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.errorRecovery">
+            <summary>
+            This is true when we see an error and before having successfully
+            matched a token.  Prevents generation of more than one error message
+            per error.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.lastErrorIndex">
+            <summary>
+             The index into the input stream where the last error occurred.
+            	This is used to prevent infinite loops where an error is found
+             but no token is consumed during recovery...another error is found,
+             ad naseum.  This is a failsafe mechanism to guarantee that at least
+             one token/tree node is consumed for two errors.
+             </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.failed">
+            <summary>
+            In lieu of a return value, this indicates that a rule or token
+            has failed to match.  Reset to false upon valid token match.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.syntaxErrors">
+            <summary>Did the recognizer encounter a syntax error?  Track how many.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.backtracking">
+            <summary>
+            If 0, no backtracking is going on.  Safe to exec actions etc...
+            If >0 then it's the level of backtracking.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.ruleMemo">
+            <summary>
+              An array[size num rules] of dictionaries that tracks
+              the stop token index for each rule.  ruleMemo[ruleIndex] is
+              the memoization table for ruleIndex.  For key ruleStartIndex, you
+              get back the stop token for associated rule or MEMO_RULE_FAILED.
+              </summary>
+            
+              <remarks>This is only used if rule memoization is on (which it is by default).</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.token">
+            <summary>
+            The goal of all lexer rules/methods is to create a token object.
+            This is an instance variable as multiple rules may collaborate to
+            create a single token.  nextToken will return this object after
+            matching lexer rule(s).  If you subclass to allow multiple token
+            emissions, then set this to the last token to be matched or
+            something nonnull so that the auto token emit mechanism will not
+            emit another token.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartCharIndex">
+            <summary>
+            What character index in the stream did the current token start at?
+            Needed, for example, to get the text for current token.  Set at
+            the start of nextToken.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartLine">
+            <summary>The line on which the first character of the token resides</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartCharPositionInLine">
+            <summary>The character position of first character within the line</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.channel">
+            <summary>The channel number for the current token</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.type">
+            <summary>The token type for the current token</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.text">
+            <summary>
+            You can set the text for the current token to override what is in
+            the input char buffer.  Use setText() or can set this instance var.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenChannels.Default">
+            <summary>
+            All tokens go to the parser (unless skip() is called in that rule)
+            on a particular "channel".  The parser tunes to a particular channel
+            so that whitespace etc... can go to the parser on a "hidden" channel.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenChannels.Hidden">
+            <summary>
+            Anything on different channel than DEFAULT_CHANNEL is not parsed
+            by parser.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.TokenRewriteStream">
+            Useful for dumping out the input stream after doing some
+              augmentation or other manipulations.
+            
+              You can insert stuff, replace, and delete chunks.  Note that the
+              operations are done lazily--only if you convert the buffer to a
+              String.  This is very efficient because you are not moving data around
+              all the time.  As the buffer of tokens is converted to strings, the
+              toString() method(s) check to see if there is an operation at the
+              current index.  If so, the operation is done and then normal String
+              rendering continues on the buffer.  This is like having multiple Turing
+              machine instruction streams (programs) operating on a single input tape. :)
+            
+              Since the operations are done lazily at toString-time, operations do not
+              screw up the token index values.  That is, an insert operation at token
+              index i does not change the index values for tokens i+1..n-1.
+            
+              Because operations never actually alter the buffer, you may always get
+              the original token stream back without undoing anything.  Since
+              the instructions are queued up, you can easily simulate transactions and
+              roll back any changes if there is an error just by removing instructions.
+              For example,
+            
+               CharStream input = new ANTLRFileStream("input");
+               TLexer lex = new TLexer(input);
+               TokenRewriteStream tokens = new TokenRewriteStream(lex);
+               T parser = new T(tokens);
+               parser.startRule();
+            
+             	 Then in the rules, you can execute
+                  Token t,u;
+                  ...
+                  input.insertAfter(t, "text to put after t");}
+             		input.insertAfter(u, "text after u");}
+             		System.out.println(tokens.toString());
+            
+              Actually, you have to cast the 'input' to a TokenRewriteStream. :(
+            
+              You can also have multiple "instruction streams" and get multiple
+              rewrites from a single pass over the input.  Just name the instruction
+              streams and use that name again when printing the buffer.  This could be
+              useful for generating a C file and also its header file--all from the
+              same buffer:
+            
+                  tokens.insertAfter("pass1", t, "text to put after t");}
+             		tokens.insertAfter("pass2", u, "text after u");}
+             		System.out.println(tokens.toString("pass1"));
+             		System.out.println(tokens.toString("pass2"));
+            
+              If you don't use named rewrite streams, a "default" stream is used as
+              the first example shows.
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.RewriteOperation.instructionIndex">
+            <summary>What index into rewrites List are we?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.RewriteOperation.index">
+            <summary>Token buffer index.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.RewriteOperation.Execute(System.Text.StringBuilder)">
+            <summary>
+            Execute the rewrite operation by possibly adding to the buffer.
+            Return the index of the next token to operate on.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.TokenRewriteStream.ReplaceOp">
+            <summary>
+            I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp
+            instructions.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.programs">
+            <summary>
+            You may have multiple, named streams of rewrite operations.
+            I'm calling these things "programs."
+            Maps String (name) -> rewrite (List)
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.lastRewriteTokenIndexes">
+            <summary>Map String (program name) -> Integer index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.Rollback(System.String,System.Int32)">
+            <summary>
+            Rollback the instruction stream for a program so that
+            the indicated instruction (via instructionIndex) is no
+            longer in the stream.  UNTESTED!
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.DeleteProgram(System.String)">
+            <summary>Reset the program so that no instructions exist</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.ReduceToSingleOperationPerIndex(System.Collections.Generic.IList{Antlr.Runtime.TokenRewriteStream.RewriteOperation})">
+            We need to combine operations and report invalid operations (like
+              overlapping replaces that are not completed nested).  Inserts to
+              same index need to be combined etc...   Here are the cases:
+            
+              I.i.u I.j.v								leave alone, nonoverlapping
+              I.i.u I.i.v								combine: Iivu
+            
+              R.i-j.u R.x-y.v	| i-j in x-y			delete first R
+              R.i-j.u R.i-j.v							delete first R
+              R.i-j.u R.x-y.v	| x-y in i-j			ERROR
+              R.i-j.u R.x-y.v	| boundaries overlap	ERROR
+            
+              Delete special case of replace (text==null):
+              D.i-j.u D.x-y.v	| boundaries overlap	combine to max(min)..max(right)
+            
+              I.i.u R.x-y.v | i in (x+1)-y			delete I (since insert before
+            											we're not deleting i)
+              I.i.u R.x-y.v | i not in (x+1)-y		leave alone, nonoverlapping
+              R.x-y.v I.i.u | i in x-y				ERROR
+              R.x-y.v I.x.u 							R.x-y.uv (combine, delete I)
+              R.x-y.v I.i.u | i not in x-y			leave alone, nonoverlapping
+            
+              I.i.u = insert u before op @ index i
+              R.x-y.u = replace x-y indexed tokens with u
+            
+              First we need to examine replaces.  For any replace op:
+            
+             		1. wipe out any insertions before op within that range.
+            		2. Drop any replace op before that is contained completely within
+                     that range.
+            		3. Throw exception upon boundary overlap with any previous replace.
+            
+              Then we can deal with inserts:
+            
+             		1. for any inserts to same index, combine even if not adjacent.
+             		2. for any prior replace with same left boundary, combine this
+                     insert with replace and delete this replace.
+             		3. throw exception if index in same range as previous replace
+            
+              Don't actually delete; make op null in list. Easier to walk list.
+              Later we can throw as we add to index -> op map.
+            
+              Note that I.2 R.2-2 will wipe out I.2 even though, technically, the
+              inserted stuff would be before the replace range.  But, if you
+              add tokens in front of a method body '{' and then delete the method
+              body, I think the stuff before the '{' you added should disappear too.
+            
+              Return a map from token index to operation.
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.GetKindOfOps(System.Collections.Generic.IList{Antlr.Runtime.TokenRewriteStream.RewriteOperation},System.Type,System.Int32)">
+            <summary>Get all operations before an index of a particular kind</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tokens.Skip">
+            <summary>
+            In an action, a lexer rule can set token to this SKIP_TOKEN and ANTLR
+            will avoid creating a token for this symbol and try to fetch another.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenTypes.Down">
+            <summary>imaginary tree navigation type; traverse "get child" link</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.TokenTypes.Up">
+            <summary>imaginary tree navigation type; finish with a child list</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.BaseTree">
+            <summary>
+            A generic tree implementation with no payload.  You must subclass to
+            actually have any user data.  ANTLR v3 uses a list of children approach
+            instead of the child-sibling approach in v2.  A flat tree (a list) is
+            an empty node whose children represent the list.  An empty, but
+            non-null node is called "nil".
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.#ctor(Antlr.Runtime.Tree.ITree)">
+            <summary>
+            Create a new node from an existing node does nothing for BaseTree
+            as there are no fields other than the children list, which cannot
+            be copied as the children are not considered part of this node. 
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.BaseTree.Children">
+            <summary>
+            Get the children internal List; note that if you directly mess with
+            the list, do so at your own risk.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.BaseTree.Parent">
+            <summary>BaseTree doesn't track parent pointers.</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Tree.BaseTree.ChildIndex">
+            <summary>BaseTree doesn't track child indexes.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.AddChild(Antlr.Runtime.Tree.ITree)">
+            <summary>Add t as child of this node.</summary>
+            
+              <remarks>
+              Warning: if t has no children, but child does
+              and child isNil then this routine moves children to t via
+              t.children = child.children; i.e., without copying the array.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.AddChildren(System.Collections.Generic.IEnumerable{Antlr.Runtime.Tree.ITree})">
+            <summary>Add all elements of kids list as children of this node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.InsertChild(System.Int32,Antlr.Runtime.Tree.ITree)">
+            Insert child t at child position i (0..n-1) by shifting children
+            i+1..n-1 to the right one position. Set parent / indexes properly
+            but does NOT collapse nil-rooted t's that come in here like addChild.
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.ReplaceChildren(System.Int32,System.Int32,System.Object)">
+            <summary>
+            Delete children from start to stop and replace with t even if t is
+            a list (nil-root tree).  num of children can increase or decrease.
+            For huge child lists, inserting children can force walking rest of
+            children to set their childindex; could be slow.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.CreateChildrenList">
+            <summary>Override in a subclass to change the impl of children list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.FreshenParentAndChildIndexes">
+            <summary>Set the parent and child index values for all child of t</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.HasAncestor(System.Int32)">
+            <summary>Walk upwards looking for ancestor with this token type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.GetAncestor(System.Int32)">
+            <summary>Walk upwards and get first ancestor with this token type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.GetAncestors">
+            <summary>
+            Return a list of all ancestors of this node.  The first node of
+            list is the root and the last is the parent of this node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.ToStringTree">
+            <summary>Print out a whole tree not just a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.ToString">
+            <summary>Override to say how a node (not a tree) should look as text</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.BaseTreeAdaptor">
+            <summary>A TreeAdaptor that works with any Tree implementation.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BaseTreeAdaptor.treeToUniqueIDMap">
+            <summary>
+            System.identityHashCode() is not always unique; we have to
+            track ourselves.  That's ok, it's only for debugging, though it's
+            expensive: we have to create a hashtable with all tree nodes in it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.ErrorNode(Antlr.Runtime.ITokenStream,Antlr.Runtime.IToken,Antlr.Runtime.IToken,Antlr.Runtime.RecognitionException)">
+            <summary>
+              Create tree node that holds the start and stop tokens associated
+              with an error.
+              </summary>
+            
+              <remarks>
+              If you specify your own kind of tree nodes, you will likely have to
+              override this method. CommonTree returns Token.INVALID_TOKEN_TYPE
+              if no token payload but you might have to set token type for diff
+              node type.
+            
+              You don't have to subclass CommonErrorNode; you will likely need to
+              subclass your own tree node class to avoid class cast exception.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.DupTree(System.Object,System.Object)">
+            <summary>
+            This is generic in the sense that it will work with any kind of
+            tree (not just ITree interface).  It invokes the adaptor routines
+            not the tree node routines to do the construction.  
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.AddChild(System.Object,System.Object)">
+            <summary>
+            Add a child to the tree t.  If child is a flat tree (a list), make all
+            in list children of t.  Warning: if t has no children, but child does
+            and child isNil then you can decide it is ok to move children to t via
+            t.children = child.children; i.e., without copying the array.  Just
+            make sure that this is consistent with have the user will build
+            ASTs.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.BecomeRoot(System.Object,System.Object)">
+            <summary>
+              If oldRoot is a nil root, just copy or move the children to newRoot.
+              If not a nil root, make oldRoot a child of newRoot.
+              </summary>
+            
+              <remarks>
+                old=^(nil a b c), new=r yields ^(r a b c)
+                old=^(a b c), new=r yields ^(r ^(a b c))
+            
+              If newRoot is a nil-rooted single child tree, use the single
+              child as the new root node.
+            
+                old=^(nil a b c), new=^(nil r) yields ^(r a b c)
+                old=^(a b c), new=^(nil r) yields ^(r ^(a b c))
+            
+              If oldRoot was null, it's ok, just return newRoot (even if isNil).
+            
+                old=null, new=r yields r
+                old=null, new=^(nil r) yields ^(nil r)
+            
+              Return newRoot.  Throw an exception if newRoot is not a
+              simple node or nil root with a single child node--it must be a root
+              node.  If newRoot is ^(nil x) return x as newRoot.
+            
+              Be advised that it's ok for newRoot to point at oldRoot's
+              children; i.e., you don't have to copy the list.  We are
+              constructing these nodes so we should have this control for
+              efficiency.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.RulePostProcessing(System.Object)">
+            <summary>Transform ^(nil x) to x and nil to null</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.CreateToken(System.Int32,System.String)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.CreateToken(Antlr.Runtime.IToken)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              This is a variant of createToken where the new token is derived from
+              an actual real input token.  Typically this is for converting '{'
+              tokens to BLOCK etc...  You'll see
+            
+                r : lc='{' ID+ '}' -> ^(BLOCK[$lc] ID+) ;
+            
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.DupNode(System.Object)">
+            <summary>
+              Duplicate a node.  This is part of the factory;
+              override if you want another kind of node to be built.
+              </summary>
+            
+              <remarks>
+              I could use reflection to prevent having to override this
+              but reflection is slow.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.SetTokenBoundaries(System.Object,Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
+            <summary>
+            Track start/stop token for subtree root created for a rule.
+            Only works with Tree nodes.  For rules that match nothing,
+            seems like this will yield start=i and stop=i-1 in a nil node.
+            Might be useful info so I'll not force to be i..i.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.BufferedTreeNodeStream">
+            <summary>A buffered stream of tree nodes.  Nodes can be from a tree of ANY kind.</summary>
+            
+              This node stream sucks all nodes out of the tree specified in
+              the constructor during construction and makes pointers into
+              the tree using an array of Object pointers. The stream necessarily
+              includes pointers to DOWN and UP and EOF nodes.
+            
+              This stream knows how to mark/release for backtracking.
+            
+              This stream is most suitable for tree interpreters that need to
+              jump around a lot or for tree parsers requiring speed (at cost of memory).
+              There is some duplicated functionality here with UnBufferedTreeNodeStream
+              but just in bookkeeping, not tree walking etc...
+            
+              TARGET DEVELOPERS:
+            
+              This is the old CommonTreeNodeStream that buffered up entire node stream.
+              No need to implement really as new CommonTreeNodeStream is much better
+              and covers what we need.
+            
+              @see CommonTreeNodeStream
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.nodes">
+            <summary>The complete mapping from stream index to tree node.
+              This buffer includes pointers to DOWN, UP, and EOF nodes.
+              It is built upon ctor invocation.  The elements are type
+              Object as we don't what the trees look like.</summary>
+            
+              Load upon first need of the buffer so we can set token types
+              of interest for reverseIndexing.  Slows us down a wee bit to
+              do all of the if p==-1 testing everywhere though.
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.root">
+            <summary>Pull nodes from which tree?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.tokens">
+            <summary>IF this tree (root) was created from a token stream, track it.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.adaptor">
+            <summary>What tree adaptor was used to build these trees</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.uniqueNavigationNodes">
+            <summary>Reuse same DOWN, UP navigation nodes unless this is true</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.p">
+            <summary>The index into the nodes list of the current node (next node
+            to consume).  If -1, nodes array not filled yet.</summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.calls">
+            <summary>Stack of indexes used for push/pop calls</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.FillBuffer">
+            Walk tree with depth-first-search and fill nodes buffer.
+            Don't do DOWN, UP nodes if its a list (t is isNil).
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.GetNodeIndex(System.Object)">
+            What is the stream index for node? 0..n-1
+            Return -1 if node not found.
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.AddNavigationNode(System.Int32)">
+            As we flatten the tree, we use UP, DOWN nodes to represent
+            the tree structure.  When debugging we need unique nodes
+            so instantiate new ones when uniqueNavigationNodes is true.
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.LB(System.Int32)">
+            <summary>Look backwards k nodes</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.Push(System.Int32)">
+            <summary>
+            Make stream jump to a new location, saving old location.
+            Switch back with pop().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.Pop">
+            <summary>
+            Seek back to previous index saved during last push() call.
+            Return top of stack (return index).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.ToTokenTypeString">
+            <summary>Used for testing, just return the token type stream</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.ToTokenString(System.Int32,System.Int32)">
+            <summary>Debugging</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.CommonErrorNode">
+            <summary>A node representing erroneous token range in token stream</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.CommonTree">
+            <summary>
+            A tree node that is wrapper for a Token object.  After 3.0 release
+            while building tree rewrite stuff, it became clear that computing
+            parent and child index is very difficult and cumbersome.  Better to
+            spend the space in every tree node.  If you don't want these extra
+            fields, it's easy to cut them out in your own BaseTree subclass.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree._token">
+            <summary>A single token is the payload</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree.startIndex">
+            <summary>
+            What token indexes bracket all tokens associated with this node
+            and below?
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree.parent">
+            <summary>Who is the parent node of this node; if null, implies node is root</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree.childIndex">
+            <summary>What index is this node in the child list? Range: 0..n-1</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTree.SetUnknownTokenBoundaries">
+            <summary>
+            For every node in this subtree, make sure it's start/stop token's
+            are set.  Walk depth first, visit bottom up.  Only updates nodes
+            with at least one token index &lt; 0.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.CommonTreeAdaptor">
+            <summary>
+              A TreeAdaptor that works with any Tree implementation.  It provides
+              really just factory methods; all the work is done by BaseTreeAdaptor.
+              If you would like to have different tokens created than ClassicToken
+              objects, you need to override this and then set the parser tree adaptor to
+              use your subclass.
+              </summary>
+            
+              <remarks>
+              To get your parser to build nodes of a different type, override
+              create(Token), errorNode(), and to be safe, YourTreeClass.dupNode().
+              dupNode is called to duplicate nodes during rewrite operations.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.CreateToken(System.Int32,System.String)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.CreateToken(Antlr.Runtime.IToken)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              This is a variant of createToken where the new token is derived from
+              an actual real input token.  Typically this is for converting '{'
+              tokens to BLOCK etc...  You'll see
+            
+                r : lc='{' ID+ '}' -> ^(BLOCK[$lc] ID+) ;
+            
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.GetToken(System.Object)">
+            <summary>
+            What is the Token associated with this node?  If
+            you are not using CommonTree, then you must
+            override this in your own adaptor.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._root">
+            <summary>Pull nodes from which tree?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream.tokens">
+            <summary>If this tree (root) was created from a token stream, track it.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._adaptor">
+            <summary>What tree adaptor was used to build these trees</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._it">
+            The tree iterator we are using 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._calls">
+            <summary>Stack of indexes used for push/pop calls</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._hasNilRoot">
+            <summary>Tree (nil A B C) trees like flat A B C streams</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._level">
+            <summary>Tracks tree depth.  Level=0 means we're at root node level.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._previousLocationElement">
+             Tracks the last node before the start of {@link #data} which contains
+             position information to provide information for error reporting. This is
+             tracked in addition to {@link #prevElement} which may or may not contain
+             position information.
+            
+             @see #hasPositionInformation
+             @see RecognitionException#extractInformationFromTreeNodeStream
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.Push(System.Int32)">
+            Make stream jump to a new location, saving old location.
+            Switch back with pop().
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.Pop">
+            Seek back to previous index saved during last push() call.
+            Return top of stack (return index).
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.GetKnownPositionElement(System.Boolean)">
+             Returns an element containing position information. If {@code allowApproximateLocation} is {@code false}, then
+             this method will return the {@code LT(1)} element if it contains position information, and otherwise return {@code null}.
+             If {@code allowApproximateLocation} is {@code true}, then this method will return the last known element containing position information.
+            
+             @see #hasPositionInformation
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.ToTokenTypeString">
+            <summary>For debugging; destructive: moves tree iterator to end.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.DotTreeGenerator">
+            A utility class to generate DOT diagrams (graphviz) from
+              arbitrary trees.  You can pass in your own templates and
+              can pass in any kind of tree or use Tree interface method.
+              I wanted this separator so that you don't have to include
+              ST just to use the org.antlr.runtime.tree.* package.
+              This is a set of non-static methods so you can subclass
+              to override.  For example, here is an invocation:
+            
+                  CharStream input = new ANTLRInputStream(System.in);
+                  TLexer lex = new TLexer(input);
+                  CommonTokenStream tokens = new CommonTokenStream(lex);
+                  TParser parser = new TParser(tokens);
+                  TParser.e_return r = parser.e();
+                  Tree t = (Tree)r.tree;
+                  System.out.println(t.toStringTree());
+                  DOTTreeGenerator gen = new DOTTreeGenerator();
+                  StringTemplate st = gen.toDOT(t);
+                  System.out.println(st);
+        </member>
+        <member name="F:Antlr.Runtime.Tree.DotTreeGenerator.nodeToNumberMap">
+            Track node to number mapping so we can get proper node name back 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.DotTreeGenerator.nodeNumber">
+            Track node number so we can get unique node names 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.DotTreeGenerator.ToDot(System.Object,Antlr.Runtime.Tree.ITreeAdaptor)">
+            Generate DOT (graphviz) for a whole tree not just a node.
+              For example, 3+4*5 should generate:
+            
+             digraph {
+               node [shape=plaintext, fixedsize=true, fontsize=11, fontname="Courier",
+                     width=.4, height=.2];
+               edge [arrowsize=.7]
+               "+"->3
+               "+"->"*"
+               "*"->4
+               "*"->5
+             }
+            
+             Takes a Tree interface object.
+        </member>
+        <member name="T:Antlr.Runtime.Tree.IPositionTrackingStream">
+            
+             @author Sam Harwell
+        </member>
+        <member name="M:Antlr.Runtime.Tree.IPositionTrackingStream.GetKnownPositionElement(System.Boolean)">
+             Returns an element containing concrete information about the current
+             position in the stream.
+            
+             @param allowApproximateLocation if {@code false}, this method returns
+             {@code null} if an element containing exact information about the current
+             position is not available
+        </member>
+        <member name="M:Antlr.Runtime.Tree.IPositionTrackingStream.HasPositionInformation(System.Object)">
+             Determines if the specified {@code element} contains concrete position
+             information.
+            
+             @param element the element to check
+             @return {@code true} if {@code element} contains concrete position
+             information, otherwise {@code false}
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITree">
+            <summary>
+              What does a tree look like?  ANTLR has a number of support classes
+              such as CommonTreeNodeStream that work on these kinds of trees.  You
+              don't have to make your trees implement this interface, but if you do,
+              you'll be able to use more support code.
+              </summary>
+            
+              <remarks>
+              NOTE: When constructing trees, ANTLR can build any kind of tree; it can
+              even use Token objects as trees if you add a child list to your tokens.
+            
+              This is a tree node without any payload; just navigation and factory stuff.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.HasAncestor(System.Int32)">
+            <summary>Is there is a node above with token type ttype?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.GetAncestor(System.Int32)">
+            <summary>Walk upwards and get first ancestor with this token type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.GetAncestors">
+            <summary>
+            Return a list of all ancestors of this node.  The first node of
+            list is the root and the last is the parent of this node.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.ChildIndex">
+            <summary>This node is what child index? 0..n-1</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.FreshenParentAndChildIndexes">
+            <summary>Set the parent and child index values for all children</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.AddChild(Antlr.Runtime.Tree.ITree)">
+            <summary>
+            Add t as a child to this node.  If t is null, do nothing.  If t
+            is nil, add all children of t to this' children.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.SetChild(System.Int32,Antlr.Runtime.Tree.ITree)">
+            <summary>Set ith child (0..n-1) to t; t must be non-null and non-nil node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.ReplaceChildren(System.Int32,System.Int32,System.Object)">
+            <summary>
+            Delete children from start to stop and replace with t even if t is
+            a list (nil-root tree).  num of children can increase or decrease.
+            For huge child lists, inserting children can force walking rest of
+            children to set their childindex; could be slow.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.IsNil">
+            <summary>
+            Indicates the node is a nil node but may still have children, meaning
+            the tree is a flat list.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.TokenStartIndex">
+            <summary>
+            What is the smallest token index (indexing from 0) for this node
+            and its children?
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.TokenStopIndex">
+            <summary>
+            What is the largest token index (indexing from 0) for this node
+            and its children?
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.Type">
+            <summary>Return a token type; needed for tree parsing</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.Line">
+            <summary>In case we don't have a token payload, what is the line for errors?</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITreeAdaptor">
+            <summary>
+              How to create and navigate trees.  Rather than have a separate factory
+              and adaptor, I've merged them.  Makes sense to encapsulate.
+              </summary>
+            
+              <remarks>
+              This takes the place of the tree construction code generated in the
+              generated code in 2.x and the ASTFactory.
+            
+              I do not need to know the type of a tree at all so they are all
+              generic Objects.  This may increase the amount of typecasting needed. :(
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(Antlr.Runtime.IToken)">
+            <summary>
+              Create a tree node from Token object; for CommonTree type trees,
+              then the token just becomes the payload.  This is the most
+              common create call.
+              </summary>
+            
+              <remarks>
+              Override if you want another kind of node to be built.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,Antlr.Runtime.IToken)">
+            <summary>
+              Create a new node derived from a token, with a new token type.
+              This is invoked from an imaginary node ref on right side of a
+              rewrite rule as IMAG[$tokenLabel].
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(Token).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,Antlr.Runtime.IToken,System.String)">
+            <summary>
+              Same as create(tokenType,fromToken) except set the text too.
+              This is invoked from an imaginary node ref on right side of a
+              rewrite rule as IMAG[$tokenLabel, "IMAG"].
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(Token).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(Antlr.Runtime.IToken,System.String)">
+            <summary>
+              Same as create(fromToken) except set the text too.
+              This is invoked when the <c>text</c> terminal option is set, as in
+              IMAG&lt;text='IMAG'&gt;.
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(Token).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,System.String)">
+            <summary>
+              Create a new node derived from a token, with a new token type.
+              This is invoked from an imaginary node ref on right side of a
+              rewrite rule as IMAG["IMAG"].
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(int,String).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DupNode(System.Object)">
+            <summary>Duplicate a single tree node.</summary>
+            <remarks>Override if you want another kind of node to be built.</remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DupTree(System.Object)">
+            <summary>Duplicate tree recursively, using dupNode() for each node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Nil">
+            <summary>
+            Return a nil node (an empty but non-null node) that can hold
+            a list of element as the children.  If you want a flat tree (a list)
+            use "t=adaptor.nil(); t.addChild(x); t.addChild(y);"
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.ErrorNode(Antlr.Runtime.ITokenStream,Antlr.Runtime.IToken,Antlr.Runtime.IToken,Antlr.Runtime.RecognitionException)">
+            <summary>
+              Return a tree node representing an error.  This node records the
+              tokens consumed during error recovery.  The start token indicates the
+              input symbol at which the error was detected.  The stop token indicates
+              the last symbol consumed during recovery.
+              </summary>
+            
+              <remarks>
+              You must specify the input stream so that the erroneous text can
+              be packaged up in the error node.  The exception could be useful
+              to some applications; default implementation stores ptr to it in
+              the CommonErrorNode.
+            
+              This only makes sense during token parsing, not tree parsing.
+              Tree parsing should happen only when parsing and tree construction
+              succeed.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.IsNil(System.Object)">
+            <summary>Is tree considered a nil node used to make lists of child nodes?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.AddChild(System.Object,System.Object)">
+            <summary>
+            Add a child to the tree t.  If child is a flat tree (a list), make all
+            in list children of t.  Warning: if t has no children, but child does
+            and child isNil then you can decide it is ok to move children to t via
+            t.children = child.children; i.e., without copying the array.  Just
+            make sure that this is consistent with have the user will build
+            ASTs.  Do nothing if t or child is null.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(System.Object,System.Object)">
+            <summary>
+              If oldRoot is a nil root, just copy or move the children to newRoot.
+              If not a nil root, make oldRoot a child of newRoot.
+              </summary>
+            
+              <remarks>
+                old=^(nil a b c), new=r yields ^(r a b c)
+                old=^(a b c), new=r yields ^(r ^(a b c))
+            
+              If newRoot is a nil-rooted single child tree, use the single
+              child as the new root node.
+            
+                old=^(nil a b c), new=^(nil r) yields ^(r a b c)
+                old=^(a b c), new=^(nil r) yields ^(r ^(a b c))
+            
+              If oldRoot was null, it's ok, just return newRoot (even if isNil).
+            
+                old=null, new=r yields r
+                old=null, new=^(nil r) yields ^(nil r)
+            
+              Return newRoot.  Throw an exception if newRoot is not a
+              simple node or nil root with a single child node--it must be a root
+              node.  If newRoot is ^(nil x) return x as newRoot.
+            
+              Be advised that it's ok for newRoot to point at oldRoot's
+              children; i.e., you don't have to copy the list.  We are
+              constructing these nodes so we should have this control for
+              efficiency.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.RulePostProcessing(System.Object)">
+            <summary>
+              Given the root of the subtree created for this rule, post process
+              it to do any simplifications or whatever you want.  A required
+              behavior is to convert ^(nil singleSubtree) to singleSubtree
+              as the setting of start/stop indexes relies on a single non-nil root
+              for non-flat trees.
+              </summary>
+            
+              <remarks>
+              Flat trees such as for lists like "idlist : ID+ ;" are left alone
+              unless there is only one ID.  For a list, the start/stop indexes
+              are set in the nil node.
+            
+              This method is executed after all rule tree construction and right
+              before setTokenBoundaries().
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetUniqueID(System.Object)">
+            <summary>For identifying trees.</summary>
+            
+              <remarks>
+              How to identify nodes so we can say "add node to a prior node"?
+              Even becomeRoot is an issue.  Use System.identityHashCode(node)
+              usually.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(Antlr.Runtime.IToken,System.Object)">
+            <summary>
+              Create a node for newRoot make it the root of oldRoot.
+              If oldRoot is a nil root, just copy or move the children to newRoot.
+              If not a nil root, make oldRoot a child of newRoot.
+              </summary>
+            
+              <returns>
+              Return node created for newRoot.
+              </returns>
+            
+              <remarks>
+              Be advised: when debugging ASTs, the DebugTreeAdaptor manually
+              calls create(Token child) and then plain becomeRoot(node, node)
+              because it needs to trap calls to create, but it can't since it delegates
+              to not inherits from the TreeAdaptor.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetType(System.Object)">
+            <summary>For tree parsing, I need to know the token type of a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetType(System.Object,System.Int32)">
+            <summary>Node constructors can set the type of a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetText(System.Object,System.String)">
+            <summary>Node constructors can set the text of a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetToken(System.Object)">
+            <summary>
+            Return the token object from which this node was created.
+            Currently used only for printing an error message.
+            The error display routine in BaseRecognizer needs to
+            display where the input the error occurred. If your
+            tree of limitation does not store information that can
+            lead you to the token, you can create a token filled with
+            the appropriate information and pass that back.  See
+            BaseRecognizer.getErrorMessage().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetTokenBoundaries(System.Object,Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
+            <summary>
+            Where are the bounds in the input token stream for this node and
+            all children?  Each rule that creates AST nodes will call this
+            method right before returning.  Flat trees (i.e., lists) will
+            still usually have a nil root node just to hold the children list.
+            That node would contain the start/stop indexes then.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetTokenStartIndex(System.Object)">
+            <summary>Get the token start index for this subtree; return -1 if no such index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetTokenStopIndex(System.Object)">
+            <summary>Get the token stop index for this subtree; return -1 if no such index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChild(System.Object,System.Int32)">
+            <summary>Get a child 0..n-1 node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetChild(System.Object,System.Int32,System.Object)">
+            <summary>Set ith child (0..n-1) to t; t must be non-null and non-nil node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DeleteChild(System.Object,System.Int32)">
+            <summary>Remove ith child and shift children down from right.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChildCount(System.Object)">
+            <summary>How many children?  If 0, then this is a leaf node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetParent(System.Object)">
+            <summary>
+            Who is the parent node of this node; if null, implies node is root.
+            If your node type doesn't handle this, it's ok but the tree rewrites
+            in tree parsers need this functionality.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChildIndex(System.Object)">
+            <summary>
+            What index is this node in the child list? Range: 0..n-1
+            If your node type doesn't handle this, it's ok but the tree rewrites
+            in tree parsers need this functionality.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.ReplaceChildren(System.Object,System.Int32,System.Int32,System.Object)">
+            <summary>
+              Replace from start to stop child index of parent with t, which might
+              be a list.  Number of children may be different after this call.
+              </summary>
+            
+              <remarks>
+              If parent is null, don't do anything; must be at root of overall tree.
+              Can't replace whatever points to the parent externally.  Do nothing.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITreeNodeStream">
+            <summary>A stream of tree nodes, accessing nodes from a tree of some kind</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.Item(System.Int32)">
+            <summary>
+            Get a tree node at an absolute index i; 0..n-1.
+            If you don't want to buffer up nodes, then this method makes no
+            sense for you.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.LT(System.Int32)">
+            <summary>
+             Get tree node at current input pointer + <paramref name="k"/> ahead where
+             <paramref name="k"/>==1 is next node. <paramref name="k"/>&lt;0 indicates nodes in the past. So
+             {@code LT(-1)} is previous node, but implementations are not required to
+             provide results for <paramref name="k"/> &lt; -1. {@code LT(0)} is undefined. For
+             <paramref name="k"/>&lt;=n, return <see langword="null"/>. Return <see langword="null"/> for {@code LT(0)}
+             and any index that results in an absolute address that is negative.
+              </summary>
+            
+              <remarks>
+             This is analogous to <see cref="M:Antlr.Runtime.ITokenStream.LT(System.Int32)"/>, but this returns a tree node
+             instead of a <see cref="T:Antlr.Runtime.IToken"/>. Makes code generation identical for both
+             parser and tree grammars.
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TreeSource">
+            <summary>
+            Where is this stream pulling nodes from?  This is not the name, but
+            the object that provides node objects.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TokenStream">
+            <summary>
+            If the tree associated with this stream was created from a
+            {@link TokenStream}, you can specify it here. Used to do rule
+            {@code $text} attribute in tree parser. Optional unless you use tree
+            parser rule {@code $text} attribute or {@code output=template} and
+            {@code rewrite=true} options.
+             </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TreeAdaptor">
+            <summary>
+            What adaptor can tell me how to interpret/navigate nodes and
+            trees.  E.g., get text of a node.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.UniqueNavigationNodes">
+            <summary>
+            As we flatten the tree, we use {@link Token#UP}, {@link Token#DOWN} nodes
+            to represent the tree structure. When debugging we need unique nodes so
+            we have to instantiate new ones. When doing normal tree parsing, it's
+            slow and a waste of memory to create unique navigation nodes. Default
+            should be {@code false}.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.ToString(System.Object,System.Object)">
+            <summary>
+            Return the text of all nodes from {@code start} to {@code stop},
+            inclusive. If the stream does not buffer all the nodes then it can still
+            walk recursively from start until stop. You can always return
+            {@code null} or {@code ""} too, but users should not access
+            {@code $ruleLabel.text} in an action of course in that case.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.ReplaceChildren(System.Object,System.Int32,System.Int32,System.Object)">
+            <summary>
+             Replace children of {@code parent} from index {@code startChildIndex} to
+             {@code stopChildIndex} with {@code t}, which might be a list. Number of
+             children may be different after this call. The stream is notified because
+             it is walking the tree and might need to know you are monkeying with the
+             underlying tree. Also, it might be able to modify the node stream to
+             avoid restreaming for future phases.
+              </summary>
+            
+              <remarks>
+             If {@code parent} is {@code null}, don't do anything; must be at root of
+             overall tree. Can't replace whatever points to the parent externally. Do
+             nothing.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITreeVisitorAction">
+            <summary>
+            How to execute code for node t when a visitor visits node t.  Execute
+            pre() before visiting children and execute post() after visiting children.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeVisitorAction.Pre(System.Object)">
+            <summary>
+            Execute an action before visiting children of t.  Return t or
+            a rewritten t.  It is up to the visitor to decide what to do
+            with the return value.  Children of returned value will be
+            visited if using TreeVisitor.visit().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeVisitorAction.Post(System.Object)">
+            <summary>
+            Execute an action after visiting children of t.  Return t or
+            a rewritten t.  It is up to the visitor to decide what to do
+            with the return value.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ParseTree">
+            <summary>
+            A record of the rules used to match a token sequence.  The tokens
+            end up as the leaves of this tree and rule nodes are the interior nodes.
+            This really adds no functionality, it is just an alias for CommonTree
+            that is more meaningful (specific) and holds a String to display for a node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ParseTree.ToStringWithHiddenTokens">
+            <summary>
+            Emit a token and all hidden nodes before.  EOF node holds all
+            hidden tokens after last real token.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ParseTree.ToInputString">
+            <summary>
+            Print out the leaves of this tree, which means printing original
+            input back out.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteCardinalityException">
+            <summary>
+            Base class for all exceptions thrown during AST rewrite construction.
+            This signifies a case where the cardinality of two or more elements
+            in a subrule are different: (ID INT)+ where |ID|!=|INT|
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteEarlyExitException">
+            <summary>No elements within a (...)+ in a rewrite rule</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteEmptyStreamException">
+            <summary>Ref to ID or expr but no tokens in ID stream or subtrees in expr stream</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteRuleElementStream">
+            <summary>
+              A generic list of elements tracked in an alternative to be used in
+              a -> rewrite rule.  We need to subclass to fill in the next() method,
+              which returns either an AST node wrapped around a token payload or
+              an existing subtree.
+              </summary>
+            
+              <remarks>
+              Once you start next()ing, do not try to add more elements.  It will
+              break the cursor tracking I believe.
+            
+              TODO: add mechanism to detect/puke on modification after reading from stream
+              </remarks>
+            
+              <see cref="T:Antlr.Runtime.Tree.RewriteRuleSubtreeStream"/>
+              <see cref="T:Antlr.Runtime.Tree.RewriteRuleTokenStream"/>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.cursor">
+            <summary>
+            Cursor 0..n-1.  If singleElement!=null, cursor is 0 until you next(),
+            which bumps it to 1 meaning no more elements.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.singleElement">
+            <summary>Track single elements w/o creating a list.  Upon 2nd add, alloc list</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.elements">
+            <summary>The list of tokens or subtrees we are tracking</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.dirty">
+            <summary>Once a node / subtree has been used in a stream, it must be dup'd
+            from then on.  Streams are reset after subrules so that the streams
+            can be reused in future subrules.  So, reset must set a dirty bit.
+            If dirty, then next() always returns a dup.</summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.elementDescription">
+            <summary>The element or stream description; usually has name of the token or
+            rule reference that this list tracks.  Can include rulename too, but
+            the exception would track that info.</summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.Reset">
+            <summary>
+            Reset the condition of this stream so that it appears we have
+            not consumed any of its elements.  Elements themselves are untouched.
+            Once we reset the stream, any future use will need duplicates.  Set
+            the dirty bit.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.NextTree">
+            <summary>
+            Return the next element in the stream.  If out of elements, throw
+            an exception unless size()==1.  If size is 1, then return elements[0].
+            Return a duplicate node/subtree if stream is out of elements and
+            size==1.  If we've already used the element, dup (dirty bit set).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.NextCore">
+            <summary>
+            Do the work of getting the next element, making sure that it's
+            a tree node or subtree.  Deal with the optimization of single-
+            element list versus list of size > 1.  Throw an exception
+            if the stream is empty or we're out of elements and size>1.
+            protected so you can override in a subclass if necessary.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.Dup(System.Object)">
+            <summary>
+             When constructing trees, sometimes we need to dup a token or AST
+            	subtree.  Dup'ing a token means just creating another AST node
+             around it.  For trees, you must call the adaptor.dupTree() unless
+             the element is for a tree root; then it must be a node dup.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.ToTree(System.Object)">
+            <summary>
+            Ensure stream emits trees; tokens must be converted to AST nodes.
+            AST nodes can be passed through unmolested.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteRuleNodeStream">
+            <summary>
+            Queues up nodes matched on left side of -> in a tree parser. This is
+            the analog of RewriteRuleTokenStream for normal parsers.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleNodeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleNodeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.NextNode">
+            <summary>
+              Treat next element as a single node even if it's a subtree.
+              This is used instead of next() when the result has to be a
+              tree root node.  Also prevents us from duplicating recently-added
+              children; e.g., ^(type ID)+ adds ID to type and then 2nd iteration
+              must dup the type node, but ID has been added.
+              </summary>
+            
+              <remarks>
+              Referencing a rule result twice is ok; dup entire tree as
+              we can't be adding trees as root; e.g., expr expr.
+            
+              Hideous code duplication here with super.next().  Can't think of
+              a proper way to refactor.  This needs to always call dup node
+              and super.next() doesn't know which to call: dup node or dup tree.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.NextNode">
+            <summary>Get next token from stream and make a node for it</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.ToTree(System.Object)">
+            <summary>
+            Don't convert to a tree unless they explicitly call nextTree.
+            This way we can do hetero tree nodes in rewrite.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeIterator">
+            Return a node stream from a doubly-linked tree whose nodes
+              know what child index they are.  No remove() is supported.
+            
+              Emit navigation nodes (DOWN, UP, and EOF) to let show tree structure.
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreeIterator.nodes">
+            If we emit UP/DOWN nodes, we need to spit out multiple nodes per
+            next() call.
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeParser">
+            <summary>
+            A parser for a stream of tree nodes.  "tree grammars" result in a subclass
+            of this.  All the error reporting and recovery is shared with Parser via
+            the BaseRecognizer superclass.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.SetTreeNodeStream(Antlr.Runtime.Tree.ITreeNodeStream)">
+            <summary>Set the input stream</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.MatchAny(Antlr.Runtime.IIntStream)">
+            <summary>
+            Match '.' in tree parser has special meaning.  Skip node or
+            entire tree if node has children.  If children, scan until
+            corresponding UP node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.RecoverFromMismatchedToken(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>
+            We have DOWN/UP nodes in the stream that have no line info; override.
+            plus we want to alter the exception type.  Don't try to recover
+            from tree parser errors inline...
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.GetErrorHeader(Antlr.Runtime.RecognitionException)">
+            <summary>
+            Prefix error message with the grammar name because message is
+            always intended for the programmer because the parser built
+            the input tree not the user.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.GetErrorMessage(Antlr.Runtime.RecognitionException,System.String[])">
+            <summary>
+            Tree parsers parse nodes they usually have a token object as
+            payload. Set the exception token and do the default behavior.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.pattern">
+            <summary>The tree pattern to lex like "(A B C)"</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.p">
+            <summary>Index into input string</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.c">
+            <summary>Current char</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.n">
+            <summary>How long is the pattern in char?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.sval">
+            <summary>Set when token type is ID or ARG (name mimics Java's StreamTokenizer)</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeRewriter.ReportTransformation(System.Object,System.Object)">
+            Override this if you need transformation tracing to go somewhere
+            other than stdout or if you're not using ITree-derived trees.
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeRuleReturnScope`1">
+            <summary>
+            This is identical to the ParserRuleReturnScope except that
+            the start property is a tree nodes not Token object
+            when you are parsing trees.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.TreeRuleReturnScope`1.Start">
+            <summary>Gets the first node or root node of tree matched for this rule.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeVisitor">
+            <summary>Do a depth first walk of a tree, applying pre() and post() actions as we go.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeVisitor.Visit(System.Object,Antlr.Runtime.Tree.ITreeVisitorAction)">
+            <summary>
+            Visit every node in tree t and trigger an action for each node
+            before/after having visited all of its children.  Bottom up walk.
+            Execute both actions even if t has no children.  Ignore return
+            results from transforming children since they will have altered
+            the child list of this node (their parent).  Return result of
+            applying post action to this node.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeWizard">
+            <summary>
+              Build and navigate trees with this object.  Must know about the names
+              of tokens so you have to pass in a map or array of token names (from which
+              this class can build the map).  I.e., Token DECL means nothing unless the
+              class can translate it to a token type.
+              </summary>
+            
+              <remarks>
+              In order to create nodes and navigate, this class needs a TreeAdaptor.
+            
+              This class can build a token type -> node index for repeated use or for
+              iterating over the various nodes with a particular type.
+            
+              This class works in conjunction with the TreeAdaptor rather than moving
+              all this functionality into the adaptor.  An adaptor helps build and
+              navigate trees using methods.  This class helps you do it with string
+              patterns like "(A B C)".  You can create a tree from that pattern or
+              match subtrees against it.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeWizard.TreePattern">
+            <summary>
+            When using %label:TOKENNAME in a tree for parse(), we must
+            track the label.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeWizard.TreePatternTreeAdaptor">
+            <summary>This adaptor creates TreePattern objects for use during scan()</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.ComputeTokenTypes(System.String[])">
+            <summary>
+            Compute a Map&lt;String, Integer&gt; that is an inverted index of
+            tokenNames (which maps int token types to names).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.GetTokenType(System.String)">
+            <summary>Using the map of token names to token types, return the type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Index(System.Object)">
+            <summary>
+              Walk the entire tree and make a node name to nodes mapping.
+              For now, use recursion but later nonrecursive version may be
+              more efficient.  Returns Map&lt;Integer, List&gt; where the List is
+              of your AST node type.  The Integer is the token type of the node.
+              </summary>
+            
+              <remarks>
+              TODO: save this index so that find and visit are faster
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.IndexCore(System.Object,System.Collections.Generic.IDictionary{System.Int32,System.Collections.IList})">
+            <summary>Do the work for index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Find(System.Object,System.Int32)">
+            <summary>Return a List of tree nodes with token type ttype</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Find(System.Object,System.String)">
+            <summary>Return a List of subtrees matching pattern.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Visit(System.Object,System.Int32,Antlr.Runtime.Tree.TreeWizard.IContextVisitor)">
+            <summary>
+            Visit every ttype node in t, invoking the visitor.  This is a quicker
+            version of the general visit(t, pattern) method.  The labels arg
+            of the visitor action method is never set (it's null) since using
+            a token type rather than a pattern doesn't let us set a label.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.VisitCore(System.Object,System.Object,System.Int32,System.Int32,Antlr.Runtime.Tree.TreeWizard.IContextVisitor)">
+            <summary>Do the recursive work for visit</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Visit(System.Object,System.String,Antlr.Runtime.Tree.TreeWizard.IContextVisitor)">
+            <summary>
+            For all subtrees that match the pattern, execute the visit action.
+            The implementation uses the root node of the pattern in combination
+            with visit(t, ttype, visitor) so nil-rooted patterns are not allowed.
+            Patterns with wildcard roots are also not allowed.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Parse(System.Object,System.String,System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+              Given a pattern like (ASSIGN %lhs:ID %rhs:.) with optional labels
+              on the various nodes and '.' (dot) as the node/subtree wildcard,
+              return true if the pattern matches and fill the labels Map with
+              the labels pointing at the appropriate nodes.  Return false if
+              the pattern is malformed or the tree does not match.
+              </summary>
+            
+              <remarks>
+              If a node specifies a text arg in pattern, then that must match
+              for that node in t.
+            
+              TODO: what's a better way to indicate bad pattern? Exceptions are a hassle 
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.ParseCore(System.Object,Antlr.Runtime.Tree.TreeWizard.TreePattern,System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+            Do the work for parse. Check to see if the t2 pattern fits the
+            structure and token types in t1.  Check text if the pattern has
+            text arguments on nodes.  Fill labels map with pointers to nodes
+            in tree matched against nodes in pattern with labels.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Create(System.String)">
+            <summary>
+              Create a tree or node from the indicated tree pattern that closely
+              follows ANTLR tree grammar tree element syntax:
+            
+                  (root child1 ... child2).
+              </summary>
+            
+              <remarks>
+              You can also just pass in a node: ID
+             
+              Any node can have a text argument: ID[foo]
+              (notice there are no quotes around foo--it's clear it's a string).
+            
+              nil is a special name meaning "give me a nil node".  Useful for
+              making lists: (nil A B C) is a list of A B C.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Equals(System.Object,System.Object,Antlr.Runtime.Tree.ITreeAdaptor)">
+            <summary>
+              Compare t1 and t2; return true if token types/text, structure match exactly.
+              The trees are examined in their entirety so that (A B) does not match
+              (A B C) nor (A (B C)). 
+              </summary>
+            
+              <remarks>
+              TODO: allow them to pass in a comparator
+              TODO: have a version that is nonstatic so it can use instance adaptor
+            
+              I cannot rely on the tree node's equals() implementation as I make
+              no constraints at all on the node types nor interface etc... 
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Equals(System.Object,System.Object)">
+            <summary>
+            Compare type, structure, and text of two trees, assuming adaptor in
+            this instance of a TreeWizard.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.UnbufferedTokenStream">
+            A token stream that pulls tokens from the code source on-demand and
+              without tracking a complete buffer of the tokens. This stream buffers
+              the minimum number of tokens possible.  It's the same as
+              OnDemandTokenStream except that OnDemandTokenStream buffers all tokens.
+            
+              You can't use this stream if you pass whitespace or other off-channel
+              tokens to the parser. The stream can't ignore off-channel tokens.
+             
+              You can only look backwards 1 token: LT(-1).
+            
+              Use this when you need to read from a socket or other infinite stream.
+            
+              @see BufferedTokenStream
+              @see CommonTokenStream
+        </member>
+        <member name="F:Antlr.Runtime.UnbufferedTokenStream.channel">
+            Skip tokens on any channel but this one; this is how we skip whitespace... 
+        </member>
+        <member name="T:Antlr.Runtime.UnwantedTokenException">
+            <summary>An extra token while parsing a TokenStream</summary> 
+        </member>
+    </members>
+</doc>
diff --git a/packages/Antlr3.Runtime.3.5.1/lib/portable-net4+sl5+netcore45+wpa81+wp8+MonoAndroid1+MonoTouch1/Antlr3.Runtime.dll b/packages/Antlr3.Runtime.3.5.1/lib/portable-net4+sl5+netcore45+wpa81+wp8+MonoAndroid1+MonoTouch1/Antlr3.Runtime.dll
new file mode 100644
index 0000000..63a4ba8
Binary files /dev/null and b/packages/Antlr3.Runtime.3.5.1/lib/portable-net4+sl5+netcore45+wpa81+wp8+MonoAndroid1+MonoTouch1/Antlr3.Runtime.dll differ
diff --git a/packages/Antlr3.Runtime.3.5.1/lib/portable-net4+sl5+netcore45+wpa81+wp8+MonoAndroid1+MonoTouch1/Antlr3.Runtime.xml b/packages/Antlr3.Runtime.3.5.1/lib/portable-net4+sl5+netcore45+wpa81+wp8+MonoAndroid1+MonoTouch1/Antlr3.Runtime.xml
new file mode 100644
index 0000000..31d731f
--- /dev/null
+++ b/packages/Antlr3.Runtime.3.5.1/lib/portable-net4+sl5+netcore45+wpa81+wp8+MonoAndroid1+MonoTouch1/Antlr3.Runtime.xml
@@ -0,0 +1,3220 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>Antlr3.Runtime</name>
+    </assembly>
+    <members>
+        <member name="T:Antlr.Runtime.ANTLRInputStream">
+            <summary>
+            A kind of ReaderStream that pulls from an InputStream.
+            Useful for reading from stdin and specifying file encodings etc...
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.ANTLRReaderStream">
+            <summary>
+              Vacuum all input from a Reader and then treat it like a StringStream.
+              Manage the buffer manually to avoid unnecessary data copying.
+              </summary>
+            
+              <remarks>
+              If you need encoding, use ANTLRInputStream.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.ANTLRStringStream">
+            <summary>
+            A pretty quick CharStream that pulls all data from an array
+            directly.  Every method call counts in the lexer.  Java's
+            strings aren't very good so I'm avoiding.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.data">
+            <summary>The data being scanned</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.n">
+            <summary>How many characters are actually in the buffer</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.p">
+            <summary>0..n-1 index into string of next char</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.line">
+            <summary>line number 1..n within the input</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.charPositionInLine">
+            <summary>The index of the character relative to the beginning of the line 0..n-1</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.markDepth">
+            <summary>tracks how deep mark() calls are nested</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.markers">
+            <summary>
+            A list of CharStreamState objects that tracks the stream state
+            values line, charPositionInLine, and p that can change as you
+            move through the input stream.  Indexed from 1..markDepth.
+            A null is kept @ index 0.  Create upon first call to mark().
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.ANTLRStringStream.name">
+            <summary>What is name or source of this char stream?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.#ctor(System.String)">
+            <summary>Copy data in string to a local char array</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.#ctor(System.Char[],System.Int32)">
+            <summary>This is the preferred constructor as no data is copied</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.ANTLRStringStream.Index">
+            <summary>
+            Return the current input symbol index 0..n where n indicates the
+            last symbol has been read.  The index is the index of char to
+            be returned from LA(1).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.Reset">
+            <summary>
+            Reset the stream so that it's in the same state it was
+            when the object was created *except* the data array is not
+            touched.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ANTLRStringStream.Seek(System.Int32)">
+            <summary>
+            consume() ahead until p==index; can't just set p=index as we must
+            update line and charPositionInLine.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.BaseRecognizer">
+            <summary>
+            A generic recognizer that can handle recognizers generated from
+            lexer, parser, and tree grammars.  This is all the parsing
+            support code essentially; most of it is error recovery stuff and
+            backtracking.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.BaseRecognizer.state">
+            <summary>
+            State of a lexer, parser, or tree parser are collected into a state
+            object so the state can be shared.  This sharing is needed to
+            have one grammar import others and share same error variables
+            and other state variables.  It's a kind of explicit multiple
+            inheritance via delegation of methods and shared state.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Reset">
+            <summary>reset the parser's state; subclasses must rewinds the input stream</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Match(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>
+              Match current input symbol against ttype.  Attempt
+              single token insertion or deletion error recovery.  If
+              that fails, throw MismatchedTokenException.
+              </summary>
+            
+              <remarks>
+              To turn off single token insertion or deletion error
+              recovery, override recoverFromMismatchedToken() and have it
+              throw an exception. See TreeParser.recoverFromMismatchedToken().
+              This way any error in a rule will cause an exception and
+              immediate exit from rule.  Rule would recover by resynchronizing
+              to the set of symbols that can follow rule ref.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.MatchAny(Antlr.Runtime.IIntStream)">
+            <summary>Match the wildcard: in a symbol</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ReportError(Antlr.Runtime.RecognitionException)">
+            <summary>Report a recognition problem.</summary>
+            
+              <remarks>
+              This method sets errorRecovery to indicate the parser is recovering
+              not parsing.  Once in recovery mode, no errors are generated.
+              To get out of recovery mode, the parser must successfully match
+              a token (after a resync).  So it will go:
+            
+             		1. error occurs
+             		2. enter recovery mode, report error
+             		3. consume until token found in resynch set
+             		4. try to resume parsing
+             		5. next match() will reset errorRecovery mode
+            
+              If you override, make sure to update syntaxErrors if you care about that.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetErrorMessage(Antlr.Runtime.RecognitionException,System.String[])">
+            <summary>What error message should be generated for the various exception types?</summary>
+            
+              <remarks>
+              Not very object-oriented code, but I like having all error message
+              generation within one method rather than spread among all of the
+              exception classes. This also makes it much easier for the exception
+              handling because the exception classes do not have to have pointers back
+              to this object to access utility routines and so on. Also, changing
+              the message for an exception type would be difficult because you
+              would have to subclassing exception, but then somehow get ANTLR
+              to make those kinds of exception objects instead of the default.
+              This looks weird, but trust me--it makes the most sense in terms
+              of flexibility.
+            
+              For grammar debugging, you will want to override this to add
+              more information such as the stack frame with
+              getRuleInvocationStack(e, this.getClass().getName()) and,
+              for no viable alts, the decision description and state etc...
+            
+              Override this to change the message generated for one or more
+              exception types.
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.NumberOfSyntaxErrors">
+            <summary>
+              Get number of recognition errors (lexer, parser, tree parser).  Each
+              recognizer tracks its own number.  So parser and lexer each have
+              separate count.  Does not count the spurious errors found between
+              an error and next valid token match
+              </summary>
+            
+              <seealso cref="M:Antlr.Runtime.BaseRecognizer.ReportError(Antlr.Runtime.RecognitionException)"/>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetErrorHeader(Antlr.Runtime.RecognitionException)">
+            <summary>What is the error header, normally line/character position information?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetTokenErrorDisplay(Antlr.Runtime.IToken)">
+            <summary>
+            How should a token be displayed in an error message? The default
+            is to display just the text, but during development you might
+            want to have a lot of information spit out.  Override in that case
+            to use t.ToString() (which, for CommonToken, dumps everything about
+            the token). This is better than forcing you to override a method in
+            your token objects because you don't have to go modify your lexer
+            so that it creates a new Java type.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.EmitErrorMessage(System.String)">
+            <summary>Override this method to change where error messages go</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Recover(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException)">
+            <summary>
+            Recover from an error found on the input stream.  This is
+            for NoViableAlt and mismatched symbol exceptions.  If you enable
+            single token insertion and deletion, this will usually not
+            handle mismatched symbol exceptions but there could be a mismatched
+            token that the match() routine could not recover from.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.BeginResync">
+            <summary>
+            A hook to listen in on the token consumption during error recovery.
+            The DebugParser subclasses this to fire events to the listenter.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ComputeContextSensitiveRuleFOLLOW">
+            <summary>
+              Compute the context-sensitive FOLLOW set for current rule.
+              This is set of token types that can follow a specific rule
+              reference given a specific call chain.  You get the set of
+              viable tokens that can possibly come next (lookahead depth 1)
+              given the current call chain.  Contrast this with the
+              definition of plain FOLLOW for rule r:
+              </summary>
+            
+               FOLLOW(r)={x | S=>*alpha r beta in G and x in FIRST(beta)}
+            
+              where x in T* and alpha, beta in V*; T is set of terminals and
+              V is the set of terminals and nonterminals.  In other words,
+              FOLLOW(r) is the set of all tokens that can possibly follow
+              references to r in *any* sentential form (context).  At
+              runtime, however, we know precisely which context applies as
+              we have the call chain.  We may compute the exact (rather
+              than covering superset) set of following tokens.
+            
+              For example, consider grammar:
+            
+              stat : ID '=' expr ';'      // FOLLOW(stat)=={EOF}
+                   | "return" expr '.'
+                   ;
+              expr : atom ('+' atom)* ;   // FOLLOW(expr)=={';','.',')'}
+              atom : INT                  // FOLLOW(atom)=={'+',')',';','.'}
+                   | '(' expr ')'
+                   ;
+            
+              The FOLLOW sets are all inclusive whereas context-sensitive
+              FOLLOW sets are precisely what could follow a rule reference.
+              For input input "i=(3);", here is the derivation:
+            
+              stat => ID '=' expr ';'
+                   => ID '=' atom ('+' atom)* ';'
+                   => ID '=' '(' expr ')' ('+' atom)* ';'
+                   => ID '=' '(' atom ')' ('+' atom)* ';'
+                   => ID '=' '(' INT ')' ('+' atom)* ';'
+                   => ID '=' '(' INT ')' ';'
+            
+              At the "3" token, you'd have a call chain of
+            
+                stat -> expr -> atom -> expr -> atom
+            
+              What can follow that specific nested ref to atom?  Exactly ')'
+              as you can see by looking at the derivation of this specific
+              input.  Contrast this with the FOLLOW(atom)={'+',')',';','.'}.
+            
+              You want the exact viable token set when recovering from a
+              token mismatch.  Upon token mismatch, if LA(1) is member of
+              the viable next token set, then you know there is most likely
+              a missing token in the input stream.  "Insert" one by just not
+              throwing an exception.
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.RecoverFromMismatchedToken(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>Attempt to recover from a single missing or extra token.</summary>
+            
+              EXTRA TOKEN
+            
+              LA(1) is not what we are looking for.  If LA(2) has the right token,
+              however, then assume LA(1) is some extra spurious token.  Delete it
+              and LA(2) as if we were doing a normal match(), which advances the
+              input.
+            
+              MISSING TOKEN
+            
+              If current token is consistent with what could come after
+              ttype then it is ok to "insert" the missing token, else throw
+              exception For example, Input "i=(3;" is clearly missing the
+              ')'.  When the parser returns from the nested call to expr, it
+              will have call chain:
+            
+                stat -> expr -> atom
+            
+              and it will be trying to match the ')' at this point in the
+              derivation:
+            
+                   => ID '=' '(' INT ')' ('+' atom)* ';'
+                                      ^
+              match() will see that ';' doesn't match ')' and report a
+              mismatched token error.  To recover, it sees that LA(1)==';'
+              is in the set of tokens that can follow the ')' token
+              reference in rule atom.  It can assume that you forgot the ')'.
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.RecoverFromMismatchedSet(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException,Antlr.Runtime.BitSet)">
+            Not currently used 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetCurrentInputSymbol(Antlr.Runtime.IIntStream)">
+            <summary>
+              Match needs to return the current input symbol, which gets put
+              into the label for the associated token ref; e.g., x=ID.  Token
+              and tree parsers need to return different objects. Rather than test
+              for input stream type or change the IntStream interface, I use
+              a simple method to ask the recognizer to tell me what the current
+              input symbol is.
+              </summary>
+            
+              <remarks>This is ignored for lexers.</remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetMissingSymbol(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>Conjure up a missing token during error recovery.</summary>
+            
+              <remarks>
+              The recognizer attempts to recover from single missing
+              symbols. But, actions might refer to that missing symbol.
+              For example, x=ID {f($x);}. The action clearly assumes
+              that there has been an identifier matched previously and that
+              $x points at that token. If that token is missing, but
+              the next token in the stream is what we want we assume that
+              this token is missing and we keep going. Because we
+              have to return some token to replace the missing token,
+              we have to conjure one up. This method gives the user control
+              over the tokens returned for missing tokens. Mostly,
+              you will want to create something special for identifier
+              tokens. For literals such as '{' and ',', the default
+              action in the parser or tree parser works. It simply creates
+              a CommonToken of the appropriate type. The text will be the token.
+              If you change what tokens must be created by the lexer,
+              override this method to create the appropriate tokens.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ConsumeUntil(Antlr.Runtime.IIntStream,Antlr.Runtime.BitSet)">
+            <summary>Consume tokens until one matches the given token set</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.PushFollow(Antlr.Runtime.BitSet)">
+            <summary>Push a rule's follow set using our own hardcoded stack</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.Failed">
+            <summary>Return whether or not a backtracking attempt failed.</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.TokenNames">
+            <summary>
+            Used to print out token names like ID during debugging and
+            error reporting.  The generated parsers implement a method
+            that overrides this to point to their String[] tokenNames.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.BaseRecognizer.GrammarFileName">
+            <summary>
+            For debugging and other purposes, might want the grammar name.
+            Have ANTLR generate an implementation for this method.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.ToStrings(System.Collections.Generic.ICollection{Antlr.Runtime.IToken})">
+            <summary>
+            A convenience method for use most often with template rewrites.
+            Convert a list of <see cref="T:Antlr.Runtime.IToken"/> to a list of <see cref="T:System.String"/>.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleMemoization(System.Int32,System.Int32)">
+            <summary>
+              Given a rule number and a start token index number, return
+              MEMO_RULE_UNKNOWN if the rule has not parsed input starting from
+              start index.  If this rule has parsed input starting from the
+              start index before, then return where the rule stopped parsing.
+              It returns the index of the last token matched by the rule.
+              </summary>
+            
+              <remarks>
+              For now we use a hashtable and just the slow Object-based one.
+              Later, we can make a special one for ints and also one that
+              tosses out data after we commit past input position i.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.AlreadyParsedRule(Antlr.Runtime.IIntStream,System.Int32)">
+            <summary>
+              Has this rule already parsed input at the current index in the
+              input stream?  Return the stop token index or MEMO_RULE_UNKNOWN.
+              If we attempted but failed to parse properly before, return
+              MEMO_RULE_FAILED.
+              </summary>
+            
+              <remarks>
+              This method has a side-effect: if we have seen this input for
+              this rule and successfully parsed before, then seek ahead to
+              1 past the stop token matched for this rule last time.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.Memoize(Antlr.Runtime.IIntStream,System.Int32,System.Int32)">
+            <summary>
+            Record whether or not this rule parsed the input at this position
+            successfully.  Use a standard java hashtable for now.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleMemoizationCacheSize">
+            <summary>return how many rule/input-index pairs there are in total.</summary>
+            TODO: this includes synpreds. :(
+        </member>
+        <member name="T:Antlr.Runtime.BitSet">
+            <summary>
+            A stripped-down version of org.antlr.misc.BitSet that is just
+            good enough to handle runtime requirements such as FOLLOW sets
+            for automatic error recovery.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.BitSet.MOD_MASK">
+            <summary>
+            We will often need to do a mod operator (i mod nbits).  Its
+            turns out that, for powers of two, this mod operation is
+            same as (i &amp; (nbits-1)).  Since mod is slow, we use a
+            precomputed mod mask to do the mod instead.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.BitSet._bits">
+            <summary>The actual data bits</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor">
+            <summary>Construct a bitset of size one word (64 bits)</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor(System.UInt64[])">
+            <summary>Construction from a static array of longs</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor(System.Collections.Generic.IEnumerable{System.Int32})">
+            <summary>Construction from a list of integers</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.#ctor(System.Int32)">
+            <summary>Construct a bitset given the size</summary>
+            <param name="nbits">The size of the bitset in bits</param>
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.Or(Antlr.Runtime.BitSet)">
+            <summary>return this | a in a new set</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.Add(System.Int32)">
+            <summary>or this element into this set (grow as necessary to accommodate)</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.GrowToInclude(System.Int32)">
+            <summary>Grows the set to a larger number of bits.</summary>
+            <param name="bit">element that must fit in set</param>
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.SetSize(System.Int32)">
+            <summary>Sets the size of a set.</summary>
+            <param name="nwords">how many words the new set should be</param>
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.LengthInLongWords">
+            <summary>return how much space is being used by the bits array not how many actually have member bits on.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.BitSet.ToArray">
+            Is this contained within a? 
+        </member>
+        <member name="T:Antlr.Runtime.BufferedTokenStream">
+            Buffer all input tokens but do on-demand fetching of new tokens from
+              lexer. Useful when the parser or lexer has to set context/mode info before
+              proper lexing of future tokens. The ST template parser needs this,
+              for example, because it has to constantly flip back and forth between
+              inside/output templates. E.g., <c>&lt;names:{hi, &lt;it&gt;}&gt;</c> has to parse names
+              as part of an expression but "hi, &lt;it&gt;" as a nested template.
+            
+              You can't use this stream if you pass whitespace or other off-channel
+              tokens to the parser. The stream can't ignore off-channel tokens.
+              (UnbufferedTokenStream is the same way.)
+            
+              This is not a subclass of UnbufferedTokenStream because I don't want
+              to confuse small moving window of tokens it uses for the full buffer.
+        </member>
+        <member name="F:Antlr.Runtime.BufferedTokenStream._tokens">
+            Record every single token pulled from the source so we can reproduce
+            chunks of it later.  The buffer in LookaheadStream overlaps sometimes
+            as its moving window moves through the input.  This list captures
+            everything so we can access complete input text.
+        </member>
+        <member name="F:Antlr.Runtime.BufferedTokenStream._lastMarker">
+            Track the last mark() call result value for use in rewind(). 
+        </member>
+        <member name="F:Antlr.Runtime.BufferedTokenStream._p">
+            The index into the tokens list of the current token (next token
+            to consume).  tokens[p] should be LT(1).  p=-1 indicates need
+            to initialize with first token.  The ctor doesn't get a token.
+            First call to LT(1) or whatever gets the first token and sets p=0;
+        </member>
+        <member name="P:Antlr.Runtime.BufferedTokenStream.Range">
+            <summary>
+            How deep have we gone?
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.Consume">
+            Move the input pointer to the next incoming token.  The stream
+              must become active with LT(1) available.  consume() simply
+              moves the input pointer so that LT(1) points at the next
+              input symbol. Consume at least one token.
+            
+              Walk past any token not on the channel the parser is listening to.
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.Sync(System.Int32)">
+            Make sure index i in tokens has a token. 
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.Fetch(System.Int32)">
+            add n elements to buffer 
+        </member>
+        <member name="M:Antlr.Runtime.BufferedTokenStream.GetTokens(System.Int32,System.Int32,Antlr.Runtime.BitSet)">
+            Given a start and stop index, return a List of all tokens in
+            the token type BitSet.  Return null if no tokens were found.  This
+            method looks at both on and off channel tokens.
+        </member>
+        <member name="T:Antlr.Runtime.CharStreamState">
+            <summary>
+              When walking ahead with cyclic DFA or for syntactic predicates,
+              we need to record the state of the input stream (char index,
+              line, etc...) so that we can rewind the state after scanning ahead.
+              </summary>
+            
+              <remarks>This is the complete state of a stream.</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.CharStreamState.p">
+            <summary>Index into the char stream of next lookahead char</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CharStreamState.line">
+            <summary>What line number is the scanner at before processing buffer[p]?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CharStreamState.charPositionInLine">
+            <summary>What char position 0..n-1 in line is scanner before processing buffer[p]?</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.ClassicToken">
+            <summary>
+            A Token object like we'd use in ANTLR 2.x; has an actual string created
+            and associated with this object.  These objects are needed for imaginary
+            tree nodes that have payload objects.  We need to create a Token object
+            that has a string; the tree node will point at this token.  CommonToken
+            has indexes into a char stream and hence cannot be used to introduce
+            new strings.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.ClassicToken.index">
+            <summary>What token number is this from 0..n-1 tokens</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.text">
+            <summary>
+            We need to be able to change the text once in a while.  If
+            this is non-null, then getText should return this.  Note that
+            start/stop are not affected by changing this.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.index">
+            <summary>What token number is this from 0..n-1 tokens; &lt; 0 implies invalid index</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.start">
+            <summary>The char position into the input buffer where this token starts</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.CommonToken.stop">
+            <summary>The char position into the input buffer where this token stops</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.CommonTokenStream">
+            <summary>
+              The most common stream of tokens is one where every token is buffered up
+              and tokens are prefiltered for a certain channel (the parser will only
+              see these tokens and cannot change the filter channel number during the
+              parse).
+              </summary>
+            
+              <remarks>TODO: how to access the full token stream?  How to track all tokens matched per rule?</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.CommonTokenStream._channel">
+            Skip tokens on any channel but this one; this is how we skip whitespace... 
+        </member>
+        <member name="P:Antlr.Runtime.CommonTokenStream.TokenSource">
+            Reset this token stream by setting its token source. 
+        </member>
+        <member name="M:Antlr.Runtime.CommonTokenStream.Consume">
+            Always leave p on an on-channel token. 
+        </member>
+        <member name="M:Antlr.Runtime.CommonTokenStream.SkipOffTokenChannels(System.Int32)">
+            Given a starting index, return the index of the first on-channel
+            token.
+        </member>
+        <member name="T:Antlr.Runtime.Debug.IDebugEventListener">
+            <summary>All debugging events that a recognizer can trigger.</summary>
+            
+              <remarks>
+              I did not create a separate AST debugging interface as it would create
+              lots of extra classes and DebugParser has a dbg var defined, which makes
+              it hard to change to ASTDebugEventListener.  I looked hard at this issue
+              and it is easier to understand as one monolithic event interface for all
+              possible events.  Hopefully, adding ST debugging stuff won't be bad.  Leave
+              for future. 4/26/2006.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterRule(System.String,System.String)">
+            <summary>
+            The parser has just entered a rule.  No decision has been made about
+            which alt is predicted.  This is fired AFTER init actions have been
+            executed.  Attributes are defined and available etc...
+            The grammarFileName allows composite grammars to jump around among
+            multiple grammar files.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterAlt(System.Int32)">
+            <summary>
+            Because rules can have lots of alternatives, it is very useful to
+            know which alt you are entering.  This is 1..n for n alts.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ExitRule(System.String,System.String)">
+            <summary>
+            This is the last thing executed before leaving a rule.  It is
+            executed even if an exception is thrown.  This is triggered after
+            error reporting and recovery have occurred (unless the exception is
+            not caught in this rule).  This implies an "exitAlt" event.
+            The grammarFileName allows composite grammars to jump around among
+            multiple grammar files.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterSubRule(System.Int32)">
+            <summary>Track entry into any (...) subrule other EBNF construct</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterDecision(System.Int32,System.Boolean)">
+            <summary>
+            Every decision, fixed k or arbitrary, has an enter/exit event
+            so that a GUI can easily track what LT/consume events are
+            associated with prediction.  You will see a single enter/exit
+            subrule but multiple enter/exit decision events, one for each
+            loop iteration.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeToken(Antlr.Runtime.IToken)">
+            <summary>
+            An input token was consumed; matched by any kind of element.
+            Trigger after the token was matched by things like match(), matchAny().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeHiddenToken(Antlr.Runtime.IToken)">
+            <summary>
+            An off-channel input token was consumed.
+            Trigger after the token was matched by things like match(), matchAny().
+            (unless of course the hidden token is first stuff in the input stream).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.LT(System.Int32,Antlr.Runtime.IToken)">
+            <summary>
+            Somebody (anybody) looked ahead.  Note that this actually gets
+            triggered by both LA and LT calls.  The debugger will want to know
+            which Token object was examined.  Like consumeToken, this indicates
+            what token was seen at that depth.  A remote debugger cannot look
+            ahead into a file it doesn't have so LT events must pass the token
+            even if the info is redundant.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Mark(System.Int32)">
+            <summary>
+            The parser is going to look arbitrarily ahead; mark this location,
+            the token stream's marker is sent in case you need it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Rewind(System.Int32)">
+            <summary>
+            After an arbitrairly long lookahead as with a cyclic DFA (or with
+            any backtrack), this informs the debugger that stream should be
+            rewound to the position associated with marker.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Rewind">
+            <summary>
+            Rewind to the input position of the last marker.
+            Used currently only after a cyclic DFA and just
+            before starting a sem/syn predicate to get the
+            input position back to the start of the decision.
+            Do not "pop" the marker off the state.  mark(i)
+            and rewind(i) should balance still.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Location(System.Int32,System.Int32)">
+            <summary>
+              To watch a parser move through the grammar, the parser needs to
+              inform the debugger what line/charPos it is passing in the grammar.
+              For now, this does not know how to switch from one grammar to the
+              other and back for island grammars etc...
+              </summary>
+            
+              <remarks>
+              This should also allow breakpoints because the debugger can stop
+              the parser whenever it hits this line/pos.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.RecognitionException(Antlr.Runtime.RecognitionException)">
+            <summary>
+              A recognition exception occurred such as NoViableAltException.  I made
+              this a generic event so that I can alter the exception hierachy later
+              without having to alter all the debug objects.
+              </summary>
+            
+              <remarks>
+              Upon error, the stack of enter rule/subrule must be properly unwound.
+              If no viable alt occurs it is within an enter/exit decision, which
+              also must be rewound.  Even the rewind for each mark must be unwount.
+              In the Java target this is pretty easy using try/finally, if a bit
+              ugly in the generated code.  The rewind is generated in DFA.predict()
+              actually so no code needs to be generated for that.  For languages
+              w/o this "finally" feature (C++?), the target implementor will have
+              to build an event stack or something.
+            
+              Across a socket for remote debugging, only the RecognitionException
+              data fields are transmitted.  The token object or whatever that
+              caused the problem was the last object referenced by LT.  The
+              immediately preceding LT event should hold the unexpected Token or
+              char.
+            
+              Here is a sample event trace for grammar:
+            
+              b : C ({;}A|B) // {;} is there to prevent A|B becoming a set
+                | D
+                ;
+            
+              The sequence for this rule (with no viable alt in the subrule) for
+              input 'c c' (there are 3 tokens) is:
+            
+            		commence
+            		LT(1)
+            		enterRule b
+            		location 7 1
+            		enter decision 3
+            		LT(1)
+            		exit decision 3
+            		enterAlt1
+            		location 7 5
+            		LT(1)
+            		consumeToken [c/&lt;4&gt;,1:0]
+            		location 7 7
+            		enterSubRule 2
+            		enter decision 2
+            		LT(1)
+            		LT(1)
+            		recognitionException NoViableAltException 2 1 2
+            		exit decision 2
+            		exitSubRule 2
+            		beginResync
+            		LT(1)
+            		consumeToken [c/&lt;4&gt;,1:1]
+            		LT(1)
+            		endResync
+            		LT(-1)
+            		exitRule b
+            		terminate
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.BeginResync">
+            <summary>
+            Indicates the recognizer is about to consume tokens to resynchronize
+            the parser.  Any consume events from here until the recovered event
+            are not part of the parse--they are dead tokens.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EndResync">
+            <summary>
+            Indicates that the recognizer has finished consuming tokens in order
+            to resychronize.  There may be multiple beginResync/endResync pairs
+            before the recognizer comes out of errorRecovery mode (in which
+            multiple errors are suppressed).  This will be useful
+            in a gui where you want to probably grey out tokens that are consumed
+            but not matched to anything in grammar.  Anything between
+            a beginResync/endResync pair was tossed out by the parser.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.SemanticPredicate(System.Boolean,System.String)">
+            <summary>A semantic predicate was evaluate with this result and action text</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Commence">
+            <summary>
+            Announce that parsing has begun.  Not technically useful except for
+            sending events over a socket.  A GUI for example will launch a thread
+            to connect and communicate with a remote parser.  The thread will want
+            to notify the GUI when a connection is made.  ANTLR parsers
+            trigger this upon entry to the first rule (the ruleLevel is used to
+            figure this out).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Terminate">
+            <summary>
+            Parsing is over; successfully or not.  Mostly useful for telling
+            remote debugging listeners that it's time to quit.  When the rule
+            invocation level goes to zero at the end of a rule, we are done
+            parsing.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeNode(System.Object)">
+            <summary>
+              Input for a tree parser is an AST, but we know nothing for sure
+              about a node except its type and text (obtained from the adaptor).
+              This is the analog of the consumeToken method.  Again, the ID is
+              the hashCode usually of the node so it only works if hashCode is
+              not implemented.  If the type is UP or DOWN, then
+              the ID is not really meaningful as it's fixed--there is
+              just one UP node and one DOWN navigation node.
+              </summary>
+            
+              <param name="t" />
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.LT(System.Int32,System.Object)">
+            <summary>
+            The tree parser lookedahead.  If the type is UP or DOWN,
+            then the ID is not really meaningful as it's fixed--there is
+            just one UP node and one DOWN navigation node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.NilNode(System.Object)">
+            <summary>
+              A nil was created (even nil nodes have a unique ID...
+              they are not "null" per se).  As of 4/28/2006, this
+              seems to be uniquely triggered when starting a new subtree
+              such as when entering a subrule in automatic mode and when
+              building a tree in rewrite mode.
+              </summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only t.ID is set.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ErrorNode(System.Object)">
+            <summary>
+              Upon syntax error, recognizers bracket the error with an error node
+              if they are building ASTs.
+              </summary>
+            
+              <param name="t"/>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.CreateNode(System.Object)">
+            <summary>Announce a new node built from token elements such as type etc...</summary>
+            
+             <remarks>
+             If you are receiving this event over a socket via
+             RemoteDebugEventSocketListener then only t.ID, type, text are
+             set.
+             </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.CreateNode(System.Object,Antlr.Runtime.IToken)">
+            <summary>Announce a new node built from an existing token.</summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only node.ID and token.tokenIndex
+              are set.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.BecomeRoot(System.Object,System.Object)">
+            <summary>Make a node the new root of an existing root.  See</summary>
+            
+              <remarks>
+              Note: the newRootID parameter is possibly different
+              than the TreeAdaptor.becomeRoot() newRoot parameter.
+              In our case, it will always be the result of calling
+              TreeAdaptor.becomeRoot() and not root_n or whatever.
+            
+              The listener should assume that this event occurs
+              only when the current subrule (or rule) subtree is
+              being reset to newRootID.
+             
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only IDs are set.
+              </remarks>
+            
+              <seealso cref="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(System.Object,System.Object)"/>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.AddChild(System.Object,System.Object)">
+            <summary>Make childID a child of rootID.</summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only IDs are set.
+              </remarks>
+            
+              <seealso cref="M:Antlr.Runtime.Tree.ITreeAdaptor.AddChild(System.Object,System.Object)"/>
+        </member>
+        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.SetTokenBoundaries(System.Object,System.Int32,System.Int32)">
+            <summary>Set the token start/stop token index for a subtree root or node.</summary>
+            
+              <remarks>
+              If you are receiving this event over a socket via
+              RemoteDebugEventSocketListener then only t.ID is set.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.DFA">
+            <summary>A DFA implemented as a set of transition tables.</summary>
+            
+              <remarks>
+              Any state that has a semantic predicate edge is special; those states
+              are generated with if-then-else structures in a specialStateTransition()
+              which is generated by cyclicDFA template.
+            
+              There are at most 32767 states (16-bit signed short).
+              Could get away with byte sometimes but would have to generate different
+              types and the simulation code too.  For a point of reference, the Java
+              lexer's Tokens rule DFA has 326 states roughly.
+              </remarks>
+        </member>
+        <member name="F:Antlr.Runtime.DFA.recognizer">
+            <summary>Which recognizer encloses this DFA?  Needed to check backtracking</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.DFA.Predict(Antlr.Runtime.IIntStream)">
+            <summary>
+            From the input stream, predict what alternative will succeed
+            using this DFA (representing the covering regular approximation
+            to the underlying CFL).  Return an alternative number 1..n.  Throw
+            an exception upon error.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.DFA.Error(Antlr.Runtime.NoViableAltException)">
+            <summary>A hook for debugging interface</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.DFA.UnpackEncodedString(System.String)">
+            <summary>
+            Given a String that has a run-length-encoding of some unsigned shorts
+            like "\1\2\3\9", convert to short[] {2,9,9,9}.  We do this to avoid
+            static short[] which generates so much init code that the class won't
+            compile. :(
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.DFA.UnpackEncodedStringToUnsignedChars(System.String)">
+            <summary>Hideous duplication of code, but I need different typed arrays out :(</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.EarlyExitException">
+            <summary>The recognizer did not match anything for a (..)+ loop.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.FailedPredicateException">
+            <summary>
+            A semantic predicate failed during validation.  Validation of predicates
+            occurs when normally parsing the alternative just like matching a token.
+            Disambiguating predicate evaluation occurs when we hoist a predicate into
+            a prediction decision.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.IAstRuleReturnScope">
+            <summary>AST rules have trees</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IAstRuleReturnScope.Tree">
+            <summary>Has a value potentially if output=AST;</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.IAstRuleReturnScope`1">
+            <summary>AST rules have trees</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IAstRuleReturnScope`1.Tree">
+            <summary>Has a value potentially if output=AST;</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.ICharStream">
+            <summary>A source of characters for an ANTLR lexer</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ICharStream.Substring(System.Int32,System.Int32)">
+            <summary>
+            For infinite streams, you don't need this; primarily I'm providing
+            a useful interface for action code.  Just make sure actions don't
+            use this on streams that don't support it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ICharStream.LT(System.Int32)">
+            <summary>
+            Get the ith character of lookahead.  This is the same usually as
+            LA(i).  This will be used for labels in the generated
+            lexer code.  I'd prefer to return a char here type-wise, but it's
+            probably better to be 32-bit clean and be consistent with LA.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.ICharStream.Line">
+            <summary>ANTLR tracks the line information automatically</summary> 
+            <summary>Because this stream can rewind, we need to be able to reset the line</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.ICharStream.CharPositionInLine">
+            <summary>The index of the character relative to the beginning of the line 0..n-1</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.IIntStream">
+            <summary>
+            A simple stream of integers used when all I care about is the char
+            or token type sequence (such as interpretation).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.LA(System.Int32)">
+            <summary>
+            Get int at current input pointer + i ahead where i=1 is next int.
+            Negative indexes are allowed.  LA(-1) is previous token (token
+            just matched).  LA(-i) where i is before first token should
+            yield -1, invalid char / EOF.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Mark">
+            <summary>
+            Tell the stream to start buffering if it hasn't already.  Return
+            current input position, Index, or some other marker so that
+            when passed to rewind() you get back to the same spot.
+            rewind(mark()) should not affect the input cursor.  The Lexer
+            track line/col info as well as input index so its markers are
+            not pure input indexes.  Same for tree node streams.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IIntStream.Index">
+            <summary>
+            Return the current input symbol index 0..n where n indicates the
+            last symbol has been read.  The index is the symbol about to be
+            read not the most recently read symbol.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Rewind(System.Int32)">
+            <summary>
+            Reset the stream so that next call to index would return marker.
+            The marker will usually be Index but it doesn't have to be.  It's
+            just a marker to indicate what state the stream was in.  This is
+            essentially calling release() and seek().  If there are markers
+            created after this marker argument, this routine must unroll them
+            like a stack.  Assume the state the stream was in when this marker
+            was created.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Rewind">
+            <summary>
+            Rewind to the input position of the last marker.
+            Used currently only after a cyclic DFA and just
+            before starting a sem/syn predicate to get the
+            input position back to the start of the decision.
+            Do not "pop" the marker off the state.  mark(i)
+            and rewind(i) should balance still. It is
+            like invoking rewind(last marker) but it should not "pop"
+            the marker off.  It's like seek(last marker's input position).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Release(System.Int32)">
+            <summary>
+            You may want to commit to a backtrack but don't want to force the
+            stream to keep bookkeeping objects around for a marker that is
+            no longer necessary.  This will have the same behavior as
+            rewind() except it releases resources without the backward seek.
+            This must throw away resources for all markers back to the marker
+            argument.  So if you're nested 5 levels of mark(), and then release(2)
+            you have to release resources for depths 2..5.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.IIntStream.Seek(System.Int32)">
+            <summary>
+              Set the input cursor to the position indicated by index.  This is
+              normally used to seek ahead in the input stream.  No buffering is
+              required to do this unless you know your stream will use seek to
+              move backwards such as when backtracking.
+              </summary>
+            
+              <remarks>
+              This is different from rewind in its multi-directional
+              requirement and in that its argument is strictly an input cursor (index).
+            
+              For char streams, seeking forward must update the stream state such
+              as line number.  For seeking backwards, you will be presumably
+              backtracking using the mark/rewind mechanism that restores state and
+              so this method does not need to update state when seeking backwards.
+            
+              Currently, this method is only used for efficient backtracking using
+              memoization, but in the future it may be used for incremental parsing.
+            
+              The index is 0..n-1.  A seek to position i means that LA(1) will
+              return the ith symbol.  So, seeking to 0 means LA(1) will return the
+              first element in the stream. 
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.IIntStream.Count">
+            <summary>
+            Only makes sense for streams that buffer everything up probably, but
+            might be useful to display the entire stream or for testing.  This
+            value includes a single EOF.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IIntStream.SourceName">
+            <summary>
+            Where are you getting symbols from?  Normally, implementations will
+            pass the buck all the way to the lexer who can ask its input stream
+            for the file name or whatever.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.IRuleReturnScope">
+            <summary>
+            Rules can have start/stop info.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope.Start">
+            <summary>
+            Gets the start element from the input stream
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope.Stop">
+            <summary>
+            Gets the stop element from the input stream
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.IRuleReturnScope`1">
+            <summary>
+            Rules can have start/stop info.
+            </summary>
+            <typeparam name="TLabel">The element type of the input stream.</typeparam>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope`1.Start">
+            <summary>
+            Gets the start element from the input stream
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IRuleReturnScope`1.Stop">
+            <summary>
+            Gets the stop element from the input stream
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IToken.Text">
+            <summary>Get the text of the token</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IToken.Line">
+            <summary>The line number on which this token was matched; line=1..n</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IToken.CharPositionInLine">
+            <summary>The index of the first character relative to the beginning of the line 0..n-1</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.IToken.TokenIndex">
+            <summary>
+            An index from 0..n-1 of the token object in the input stream.
+            This must be valid in order to use the ANTLRWorks debugger.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.IToken.InputStream">
+            <summary>
+            From what character stream was this token created?  You don't have to
+            implement but it's nice to know where a Token comes from if you have
+            include files etc... on the input.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.ITokenSource">
+            <summary>
+              A source of tokens must provide a sequence of tokens via nextToken()
+              and also must reveal it's source of characters; CommonToken's text is
+              computed from a CharStream; it only store indices into the char stream.
+              </summary>
+            
+              <remarks>
+              Errors from the lexer are never passed to the parser.  Either you want
+              to keep going or you do not upon token recognition error.  If you do not
+              want to continue lexing then you do not want to continue parsing.  Just
+              throw an exception not under RecognitionException and Java will naturally
+              toss you all the way out of the recognizers.  If you want to continue
+              lexing then you should not throw an exception to the parser--it has already
+              requested a token.  Keep lexing until you get a valid one.  Just report
+              errors and keep going, looking for a valid token.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenSource.NextToken">
+            <summary>
+            Return a Token object from your input stream (usually a CharStream).
+            Do not fail/return upon lexing error; keep chewing on the characters
+            until you get a good one; errors are not passed through to the parser.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.ITokenSource.SourceName">
+            <summary>
+            Where are you getting tokens from? normally the implication will simply
+            ask lexers input stream.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.ITokenStream">
+            <summary>A stream of tokens accessing tokens from a TokenSource</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.LT(System.Int32)">
+            <summary>Get Token at current input pointer + i ahead where i=1 is next Token.
+            i&lt;0 indicates tokens in the past.  So -1 is previous token and -2 is
+            two tokens ago. LT(0) is undefined.  For i&gt;=n, return Token.EOFToken.
+            Return null for LT(0) and any index that results in an absolute address
+            that is negative.</summary>
+        </member>
+        <member name="P:Antlr.Runtime.ITokenStream.Range">
+            <summary>
+            How far ahead has the stream been asked to look?  The return
+            value is a valid index from 0..n-1.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.Get(System.Int32)">
+            <summary>
+            Get a token at an absolute index i; 0..n-1.  This is really only
+            needed for profiling and debugging and token stream rewriting.
+            If you don't want to buffer up tokens, then this method makes no
+            sense for you.  Naturally you can't use the rewrite stream feature.
+            I believe DebugTokenStream can easily be altered to not use
+            this method, removing the dependency.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.ITokenStream.TokenSource">
+            <summary>
+            Where is this stream pulling tokens from?  This is not the name, but
+            the object that provides Token objects.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.ToString(System.Int32,System.Int32)">
+            <summary>
+            Return the text of all tokens from start to stop, inclusive.
+            If the stream does not buffer all the tokens then it can just
+            return "" or null;  Users should not access $ruleLabel.text in
+            an action of course in that case.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.ITokenStream.ToString(Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
+            <summary>
+            Because the user is not required to use a token with an index stored
+            in it, we must provide a means for two token objects themselves to
+            indicate the start/end location.  Most often this will just delegate
+            to the other toString(int,int).  This is also parallel with
+            the TreeNodeStream.toString(Object,Object).
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.LegacyCommonTokenStream">
+            <summary>
+              The most common stream of tokens is one where every token is buffered up
+              and tokens are prefiltered for a certain channel (the parser will only
+              see these tokens and cannot change the filter channel number during the
+              parse).
+              </summary>
+            
+              <remarks>TODO: how to access the full token stream?  How to track all tokens matched per rule?</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.tokens">
+            <summary>
+            Record every single token pulled from the source so we can reproduce
+            chunks of it later.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.channelOverrideMap">
+            <summary>Map from token type to channel to override some Tokens' channel numbers</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.discardSet">
+            <summary>Set of token types; discard any tokens with this type</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.channel">
+            <summary>Skip tokens on any channel but this one; this is how we skip whitespace...</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.discardOffChannelTokens">
+            <summary>By default, track all incoming tokens</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.LegacyCommonTokenStream.p">
+            <summary>
+            The index into the tokens list of the current token (next token
+            to consume).  p==-1 indicates that the tokens list is empty
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.LegacyCommonTokenStream.Range">
+            <summary>
+            How deep have we gone?
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.SetTokenSource(Antlr.Runtime.ITokenSource)">
+            <summary>Reset this token stream by setting its token source.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.FillBuffer">
+            <summary>
+            Load all tokens from the token source and put in tokens.
+            This is done upon first LT request because you might want to
+            set some token type / channel overrides before filling buffer.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.Consume">
+            <summary>
+              Move the input pointer to the next incoming token.  The stream
+              must become active with LT(1) available.  consume() simply
+              moves the input pointer so that LT(1) points at the next
+              input symbol. Consume at least one token.
+              </summary>
+            
+              <remarks>
+              Walk past any token not on the channel the parser is listening to.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.SkipOffTokenChannels(System.Int32)">
+            <summary>Given a starting index, return the index of the first on-channel token.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.SetTokenTypeChannel(System.Int32,System.Int32)">
+            <summary>
+            A simple filter mechanism whereby you can tell this token stream
+            to force all tokens of type ttype to be on channel.  For example,
+            when interpreting, we cannot exec actions so we need to tell
+            the stream to force all WS and NEWLINE to be a different, ignored
+            channel.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.GetTokens(System.Int32,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>
+            Given a start and stop index, return a List of all tokens in
+            the token type BitSet.  Return null if no tokens were found.  This
+            method looks at both on and off channel tokens.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.LT(System.Int32)">
+            <summary>
+            Get the ith token from the current position 1..n where k=1 is the
+            first symbol of lookahead.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.LB(System.Int32)">
+            <summary>Look backwards k tokens on-channel tokens</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.LegacyCommonTokenStream.Get(System.Int32)">
+            <summary>
+            Return absolute token i; ignore which channel the tokens are on;
+            that is, count all tokens not just on-channel tokens.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Lexer">
+            <summary>
+            A lexer is recognizer that draws input symbols from a character stream.
+            lexer grammars result in a subclass of this object. A Lexer object
+            uses simplified match() and error recovery mechanisms in the interest
+            of speed.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Lexer.input">
+            <summary>Where is the lexer drawing characters from?</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Lexer.Text">
+            <summary>
+            Gets or sets the text matched so far for the current token or any text override.
+            </summary>
+            <remarks>
+            <para>Setting this value replaces any previously set value, and overrides the original text.</para>
+            </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.NextToken">
+            <summary>Return a token from this source; i.e., match a token on the char stream.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.GetEndOfFileToken">
+            Returns the EOF token (default), if you need
+            to return a custom token instead override this method.
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Skip">
+            <summary>
+            Instruct the lexer to skip creating a token for current lexer rule
+            and look for another token.  nextToken() knows to keep looking when
+            a lexer rule finishes with token set to SKIP_TOKEN.  Recall that
+            if token==null at end of any token rule, it creates one for you
+            and emits it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.mTokens">
+            <summary>This is the lexer entry point that sets instance var 'token'</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Emit(Antlr.Runtime.IToken)">
+            <summary>
+            Currently does not support multiple emits per nextToken invocation
+            for efficiency reasons.  Subclass and override this method and
+            nextToken (to push tokens into a list and pull from that list rather
+            than a single variable as this implementation does).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Emit">
+            <summary>
+              The standard method called to automatically emit a token at the
+              outermost lexical rule.  The token object should point into the
+              char buffer start..stop.  If there is a text override in 'text',
+              use that to set the token's text.  Override this method to emit
+              custom Token objects.
+              </summary>
+            
+              <remarks>
+              If you are building trees, then you should also override
+              Parser or TreeParser.getMissingSymbol().
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.Lexer.CharIndex">
+            <summary>What is the index of the current character of lookahead?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Lexer.Recover(Antlr.Runtime.RecognitionException)">
+            <summary>
+            Lexers can normally match any char in it's vocabulary after matching
+            a token, so do the easy thing and just kill a character and hope
+            it all works out.  You can instead use the rule invocation stack
+            to do sophisticated error recovery if you are in a fragment rule.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Misc.FastQueue`1">
+            A queue that can dequeue and get(i) in O(1) and grow arbitrarily large.
+              A linked list is fast at dequeue but slow at get(i).  An array is
+              the reverse.  This is O(1) for both operations.
+            
+              List grows until you dequeue last element at end of buffer. Then
+              it resets to start filling at 0 again.  If adds/removes are balanced, the
+              buffer will not grow too large.
+            
+              No iterator stuff as that's not how we'll use it.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.FastQueue`1._data">
+            <summary>dynamically-sized buffer of elements</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Misc.FastQueue`1._p">
+            <summary>index of next element to fill</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Misc.FastQueue`1.Range">
+            <summary>
+            How deep have we gone?
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Misc.FastQueue`1.Item(System.Int32)">
+            <summary>
+            Return element {@code i} elements ahead of current element. {@code i==0}
+            gets current element. This is not an absolute index into {@link #data}
+            since {@code p} defines the start of the real list.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Misc.FastQueue`1.Dequeue">
+            <summary>Get and remove first element in queue</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.FastQueue`1.ToString">
+            <summary>Return string of current buffer contents; non-destructive</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Misc.LookaheadStream`1">
+            <summary>
+            A lookahead queue that knows how to mark/release locations in the buffer for
+            backtracking purposes. Any markers force the {@link FastQueue} superclass to
+            keep all elements until no more markers; then can reset to avoid growing a
+            huge buffer.
+             </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._currentElementIndex">
+            Absolute token index. It's the index of the symbol about to be
+            read via {@code LT(1)}. Goes from 0 to numtokens.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._previousElement">
+            This is the {@code LT(-1)} element for the first element in {@link #data}.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._eof">
+            Track object returned by nextElement upon end of stream;
+            Return it later when they ask for LT passed end of input.
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Misc.LookaheadStream`1._markDepth">
+            <summary>tracks how deep mark() calls are nested</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.NextElement">
+            <summary>
+            Implement nextElement to supply a stream of elements to this
+            lookahead buffer.  Return EOF upon end of the stream we're pulling from.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Dequeue">
+            <summary>
+            Get and remove first element in queue; override
+            {@link FastQueue#remove()}; it's the same, just checks for backtracking.
+            </summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Consume">
+            <summary>Make sure we have at least one element to remove, even if EOF</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.SyncAhead(System.Int32)">
+            <summary>
+            Make sure we have 'need' elements from current position p. Last valid
+            p index is data.size()-1.  p+need-1 is the data index 'need' elements
+            ahead.  If we need 1 element, (p+1-1)==p must be &lt; data.size().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Fill(System.Int32)">
+            <summary>add n elements to buffer</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Misc.LookaheadStream`1.Count">
+            <summary>Size of entire stream is unknown; we only know buffer size from FastQueue</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Misc.LookaheadStream`1.Seek(System.Int32)">
+            <summary>
+            Seek to a 0-indexed absolute token index. Normally used to seek backwards
+            in the buffer. Does not force loading of nodes.
+             </summary>
+             <remarks>
+            To preserve backward compatibility, this method allows seeking past the
+            end of the currently buffered data. In this case, the input pointer will
+            be moved but the data will only actually be loaded upon the next call to
+            {@link #consume} or {@link #LT} for {@code k>0}.
+             </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.MismatchedTokenException">
+            <summary>A mismatched char or Token or tree node</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.MissingTokenException">
+            <summary>
+            We were expecting a token but it's not found.  The current token
+            is actually what we wanted next.  Used for tree node errors too.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Parser">
+            <summary>
+            A parser for TokenStreams.  "parser grammars" result in a subclass
+            of this.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Parser.TokenStream">
+            <summary>Gets or sets the token stream; resets the parser upon a set.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.ParserRuleReturnScope`1">
+            <summary>
+              Rules that return more than a single value must return an object
+              containing all the values.  Besides the properties defined in
+              RuleLabelScope.predefinedRulePropertiesScope there may be user-defined
+              return values.  This class simply defines the minimum properties that
+              are always defined and methods to access the others that might be
+              available depending on output option such as template and tree.
+              </summary>
+            
+              <remarks>
+              Note text is not an actual property of the return value, it is computed
+              from start and stop using the input stream's toString() method.  I
+              could add a ctor to this so that we can pass in and store the input
+              stream, but I'm not sure we want to do that.  It would seem to be undefined
+              to get the .text property anyway if the rule matches tokens from multiple
+              input streams.
+            
+              I do not use getters for fields of objects that are used simply to
+              group values such as this aggregate.  The getters/setters are there to
+              satisfy the superclass interface.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.RecognitionException">
+            <summary>The root of the ANTLR exception hierarchy.</summary>
+            
+              <remarks>
+              To avoid English-only error messages and to generally make things
+              as flexible as possible, these exceptions are not created with strings,
+              but rather the information necessary to generate an error.  Then
+              the various reporting methods in Parser and Lexer can be overridden
+              to generate a localized error message.  For example, MismatchedToken
+              exceptions are built with the expected token type.
+              So, don't expect getMessage() to return anything.
+            
+              Note that as of Java 1.4, you can access the stack trace, which means
+              that you can compute the complete trace of rules from the start symbol.
+              This gives you considerable context information with which to generate
+              useful error messages.
+            
+              ANTLR generates code that throws exceptions upon recognition error and
+              also generates code to catch these exceptions in each rule.  If you
+              want to quit upon first error, you can turn off the automatic error
+              handling mechanism using rulecatch action, but you still need to
+              override methods mismatch and recoverFromMismatchSet.
+            
+              In general, the recognition exceptions can track where in a grammar a
+              problem occurred and/or what was the expected input.  While the parser
+              knows its state (such as current input symbol and line info) that
+              state can change before the exception is reported so current token index
+              is computed and stored at exception time.  From this info, you can
+              perhaps print an entire line of input not just a single token, for example.
+              Better to just say the recognizer had a problem and then let the parser
+              figure out a fancy report.
+              </remarks>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._input">
+            <summary>What input stream did the error occur in?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._k">
+            <summary>
+            What was the lookahead index when this exception was thrown?
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._index">
+            <summary>What is index of token/char were we looking at when the error occurred?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._token">
+            <summary>
+            The current Token when an error occurred.  Since not all streams
+            can retrieve the ith Token, we have to track the Token object.
+            For parsers.  Even when it's a tree parser, token might be set.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._node">
+            <summary>
+            If this is a tree parser exception, node is set to the node with
+            the problem.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._c">
+            <summary>The current char when an error occurred. For lexers.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._line">
+            <summary>
+            Track the line (1-based) at which the error occurred in case this is
+            generated from a lexer.  We need to track this since the
+            unexpected char doesn't carry the line info.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._charPositionInLine">
+            <summary>
+            The 0-based index into the line where the error occurred.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognitionException._approximateLineInfo">
+            <summary>
+            If you are parsing a tree node stream, you will encounter som
+            imaginary nodes w/o line/col info.  We now search backwards looking
+            for most recent token with line/col info, but notify getErrorHeader()
+            that info is approximate.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.RecognitionException.#ctor">
+            <summary>Used for remote debugger deserialization</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.RecognitionException.UnexpectedType">
+            <summary>Return the token type or char of the unexpected input element</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.RecognizerSharedState">
+            <summary>
+              The set of fields needed by an abstract recognizer to recognize input
+              and recover from errors etc...  As a separate state object, it can be
+              shared among multiple grammars; e.g., when one grammar imports another.
+              </summary>
+            
+              <remarks>
+              These fields are publically visible but the actual state pointer per
+              parser is protected.
+              </remarks>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.following">
+            <summary>
+            Track the set of token types that can follow any rule invocation.
+            Stack grows upwards.  When it hits the max, it grows 2x in size
+            and keeps going.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.errorRecovery">
+            <summary>
+            This is true when we see an error and before having successfully
+            matched a token.  Prevents generation of more than one error message
+            per error.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.lastErrorIndex">
+            <summary>
+             The index into the input stream where the last error occurred.
+            	This is used to prevent infinite loops where an error is found
+             but no token is consumed during recovery...another error is found,
+             ad naseum.  This is a failsafe mechanism to guarantee that at least
+             one token/tree node is consumed for two errors.
+             </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.failed">
+            <summary>
+            In lieu of a return value, this indicates that a rule or token
+            has failed to match.  Reset to false upon valid token match.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.syntaxErrors">
+            <summary>Did the recognizer encounter a syntax error?  Track how many.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.backtracking">
+            <summary>
+            If 0, no backtracking is going on.  Safe to exec actions etc...
+            If >0 then it's the level of backtracking.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.ruleMemo">
+            <summary>
+              An array[size num rules] of dictionaries that tracks
+              the stop token index for each rule.  ruleMemo[ruleIndex] is
+              the memoization table for ruleIndex.  For key ruleStartIndex, you
+              get back the stop token for associated rule or MEMO_RULE_FAILED.
+              </summary>
+            
+              <remarks>This is only used if rule memoization is on (which it is by default).</remarks>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.token">
+            <summary>
+            The goal of all lexer rules/methods is to create a token object.
+            This is an instance variable as multiple rules may collaborate to
+            create a single token.  nextToken will return this object after
+            matching lexer rule(s).  If you subclass to allow multiple token
+            emissions, then set this to the last token to be matched or
+            something nonnull so that the auto token emit mechanism will not
+            emit another token.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartCharIndex">
+            <summary>
+            What character index in the stream did the current token start at?
+            Needed, for example, to get the text for current token.  Set at
+            the start of nextToken.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartLine">
+            <summary>The line on which the first character of the token resides</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartCharPositionInLine">
+            <summary>The character position of first character within the line</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.channel">
+            <summary>The channel number for the current token</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.type">
+            <summary>The token type for the current token</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.RecognizerSharedState.text">
+            <summary>
+            You can set the text for the current token to override what is in
+            the input char buffer.  Use setText() or can set this instance var.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenChannels.Default">
+            <summary>
+            All tokens go to the parser (unless skip() is called in that rule)
+            on a particular "channel".  The parser tunes to a particular channel
+            so that whitespace etc... can go to the parser on a "hidden" channel.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenChannels.Hidden">
+            <summary>
+            Anything on different channel than DEFAULT_CHANNEL is not parsed
+            by parser.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.TokenRewriteStream">
+            Useful for dumping out the input stream after doing some
+              augmentation or other manipulations.
+            
+              You can insert stuff, replace, and delete chunks.  Note that the
+              operations are done lazily--only if you convert the buffer to a
+              String.  This is very efficient because you are not moving data around
+              all the time.  As the buffer of tokens is converted to strings, the
+              toString() method(s) check to see if there is an operation at the
+              current index.  If so, the operation is done and then normal String
+              rendering continues on the buffer.  This is like having multiple Turing
+              machine instruction streams (programs) operating on a single input tape. :)
+            
+              Since the operations are done lazily at toString-time, operations do not
+              screw up the token index values.  That is, an insert operation at token
+              index i does not change the index values for tokens i+1..n-1.
+            
+              Because operations never actually alter the buffer, you may always get
+              the original token stream back without undoing anything.  Since
+              the instructions are queued up, you can easily simulate transactions and
+              roll back any changes if there is an error just by removing instructions.
+              For example,
+            
+               CharStream input = new ANTLRFileStream("input");
+               TLexer lex = new TLexer(input);
+               TokenRewriteStream tokens = new TokenRewriteStream(lex);
+               T parser = new T(tokens);
+               parser.startRule();
+            
+             	 Then in the rules, you can execute
+                  Token t,u;
+                  ...
+                  input.insertAfter(t, "text to put after t");}
+             		input.insertAfter(u, "text after u");}
+             		System.out.println(tokens.toString());
+            
+              Actually, you have to cast the 'input' to a TokenRewriteStream. :(
+            
+              You can also have multiple "instruction streams" and get multiple
+              rewrites from a single pass over the input.  Just name the instruction
+              streams and use that name again when printing the buffer.  This could be
+              useful for generating a C file and also its header file--all from the
+              same buffer:
+            
+                  tokens.insertAfter("pass1", t, "text to put after t");}
+             		tokens.insertAfter("pass2", u, "text after u");}
+             		System.out.println(tokens.toString("pass1"));
+             		System.out.println(tokens.toString("pass2"));
+            
+              If you don't use named rewrite streams, a "default" stream is used as
+              the first example shows.
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.RewriteOperation.instructionIndex">
+            <summary>What index into rewrites List are we?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.RewriteOperation.index">
+            <summary>Token buffer index.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.RewriteOperation.Execute(System.Text.StringBuilder)">
+            <summary>
+            Execute the rewrite operation by possibly adding to the buffer.
+            Return the index of the next token to operate on.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.TokenRewriteStream.ReplaceOp">
+            <summary>
+            I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp
+            instructions.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.programs">
+            <summary>
+            You may have multiple, named streams of rewrite operations.
+            I'm calling these things "programs."
+            Maps String (name) -> rewrite (List)
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenRewriteStream.lastRewriteTokenIndexes">
+            <summary>Map String (program name) -> Integer index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.Rollback(System.String,System.Int32)">
+            <summary>
+            Rollback the instruction stream for a program so that
+            the indicated instruction (via instructionIndex) is no
+            longer in the stream.  UNTESTED!
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.DeleteProgram(System.String)">
+            <summary>Reset the program so that no instructions exist</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.ReduceToSingleOperationPerIndex(System.Collections.Generic.IList{Antlr.Runtime.TokenRewriteStream.RewriteOperation})">
+            We need to combine operations and report invalid operations (like
+              overlapping replaces that are not completed nested).  Inserts to
+              same index need to be combined etc...   Here are the cases:
+            
+              I.i.u I.j.v								leave alone, nonoverlapping
+              I.i.u I.i.v								combine: Iivu
+            
+              R.i-j.u R.x-y.v	| i-j in x-y			delete first R
+              R.i-j.u R.i-j.v							delete first R
+              R.i-j.u R.x-y.v	| x-y in i-j			ERROR
+              R.i-j.u R.x-y.v	| boundaries overlap	ERROR
+            
+              Delete special case of replace (text==null):
+              D.i-j.u D.x-y.v	| boundaries overlap	combine to max(min)..max(right)
+            
+              I.i.u R.x-y.v | i in (x+1)-y			delete I (since insert before
+            											we're not deleting i)
+              I.i.u R.x-y.v | i not in (x+1)-y		leave alone, nonoverlapping
+              R.x-y.v I.i.u | i in x-y				ERROR
+              R.x-y.v I.x.u 							R.x-y.uv (combine, delete I)
+              R.x-y.v I.i.u | i not in x-y			leave alone, nonoverlapping
+            
+              I.i.u = insert u before op @ index i
+              R.x-y.u = replace x-y indexed tokens with u
+            
+              First we need to examine replaces.  For any replace op:
+            
+             		1. wipe out any insertions before op within that range.
+            		2. Drop any replace op before that is contained completely within
+                     that range.
+            		3. Throw exception upon boundary overlap with any previous replace.
+            
+              Then we can deal with inserts:
+            
+             		1. for any inserts to same index, combine even if not adjacent.
+             		2. for any prior replace with same left boundary, combine this
+                     insert with replace and delete this replace.
+             		3. throw exception if index in same range as previous replace
+            
+              Don't actually delete; make op null in list. Easier to walk list.
+              Later we can throw as we add to index -> op map.
+            
+              Note that I.2 R.2-2 will wipe out I.2 even though, technically, the
+              inserted stuff would be before the replace range.  But, if you
+              add tokens in front of a method body '{' and then delete the method
+              body, I think the stuff before the '{' you added should disappear too.
+            
+              Return a map from token index to operation.
+        </member>
+        <member name="M:Antlr.Runtime.TokenRewriteStream.GetKindOfOps(System.Collections.Generic.IList{Antlr.Runtime.TokenRewriteStream.RewriteOperation},System.Type,System.Int32)">
+            <summary>Get all operations before an index of a particular kind</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tokens.Skip">
+            <summary>
+            In an action, a lexer rule can set token to this SKIP_TOKEN and ANTLR
+            will avoid creating a token for this symbol and try to fetch another.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.TokenTypes.Down">
+            <summary>imaginary tree navigation type; traverse "get child" link</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.TokenTypes.Up">
+            <summary>imaginary tree navigation type; finish with a child list</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.BaseTree">
+            <summary>
+            A generic tree implementation with no payload.  You must subclass to
+            actually have any user data.  ANTLR v3 uses a list of children approach
+            instead of the child-sibling approach in v2.  A flat tree (a list) is
+            an empty node whose children represent the list.  An empty, but
+            non-null node is called "nil".
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.#ctor(Antlr.Runtime.Tree.ITree)">
+            <summary>
+            Create a new node from an existing node does nothing for BaseTree
+            as there are no fields other than the children list, which cannot
+            be copied as the children are not considered part of this node. 
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.BaseTree.Children">
+            <summary>
+            Get the children internal List; note that if you directly mess with
+            the list, do so at your own risk.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.BaseTree.Parent">
+            <summary>BaseTree doesn't track parent pointers.</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Tree.BaseTree.ChildIndex">
+            <summary>BaseTree doesn't track child indexes.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.AddChild(Antlr.Runtime.Tree.ITree)">
+            <summary>Add t as child of this node.</summary>
+            
+              <remarks>
+              Warning: if t has no children, but child does
+              and child isNil then this routine moves children to t via
+              t.children = child.children; i.e., without copying the array.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.AddChildren(System.Collections.Generic.IEnumerable{Antlr.Runtime.Tree.ITree})">
+            <summary>Add all elements of kids list as children of this node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.InsertChild(System.Int32,Antlr.Runtime.Tree.ITree)">
+            Insert child t at child position i (0..n-1) by shifting children
+            i+1..n-1 to the right one position. Set parent / indexes properly
+            but does NOT collapse nil-rooted t's that come in here like addChild.
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.ReplaceChildren(System.Int32,System.Int32,System.Object)">
+            <summary>
+            Delete children from start to stop and replace with t even if t is
+            a list (nil-root tree).  num of children can increase or decrease.
+            For huge child lists, inserting children can force walking rest of
+            children to set their childindex; could be slow.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.CreateChildrenList">
+            <summary>Override in a subclass to change the impl of children list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.FreshenParentAndChildIndexes">
+            <summary>Set the parent and child index values for all child of t</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.HasAncestor(System.Int32)">
+            <summary>Walk upwards looking for ancestor with this token type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.GetAncestor(System.Int32)">
+            <summary>Walk upwards and get first ancestor with this token type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.GetAncestors">
+            <summary>
+            Return a list of all ancestors of this node.  The first node of
+            list is the root and the last is the parent of this node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.ToStringTree">
+            <summary>Print out a whole tree not just a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTree.ToString">
+            <summary>Override to say how a node (not a tree) should look as text</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.BaseTreeAdaptor">
+            <summary>A TreeAdaptor that works with any Tree implementation.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BaseTreeAdaptor.treeToUniqueIDMap">
+            <summary>
+            System.identityHashCode() is not always unique; we have to
+            track ourselves.  That's ok, it's only for debugging, though it's
+            expensive: we have to create a hashtable with all tree nodes in it.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.ErrorNode(Antlr.Runtime.ITokenStream,Antlr.Runtime.IToken,Antlr.Runtime.IToken,Antlr.Runtime.RecognitionException)">
+            <summary>
+              Create tree node that holds the start and stop tokens associated
+              with an error.
+              </summary>
+            
+              <remarks>
+              If you specify your own kind of tree nodes, you will likely have to
+              override this method. CommonTree returns Token.INVALID_TOKEN_TYPE
+              if no token payload but you might have to set token type for diff
+              node type.
+            
+              You don't have to subclass CommonErrorNode; you will likely need to
+              subclass your own tree node class to avoid class cast exception.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.DupTree(System.Object,System.Object)">
+            <summary>
+            This is generic in the sense that it will work with any kind of
+            tree (not just ITree interface).  It invokes the adaptor routines
+            not the tree node routines to do the construction.  
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.AddChild(System.Object,System.Object)">
+            <summary>
+            Add a child to the tree t.  If child is a flat tree (a list), make all
+            in list children of t.  Warning: if t has no children, but child does
+            and child isNil then you can decide it is ok to move children to t via
+            t.children = child.children; i.e., without copying the array.  Just
+            make sure that this is consistent with have the user will build
+            ASTs.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.BecomeRoot(System.Object,System.Object)">
+            <summary>
+              If oldRoot is a nil root, just copy or move the children to newRoot.
+              If not a nil root, make oldRoot a child of newRoot.
+              </summary>
+            
+              <remarks>
+                old=^(nil a b c), new=r yields ^(r a b c)
+                old=^(a b c), new=r yields ^(r ^(a b c))
+            
+              If newRoot is a nil-rooted single child tree, use the single
+              child as the new root node.
+            
+                old=^(nil a b c), new=^(nil r) yields ^(r a b c)
+                old=^(a b c), new=^(nil r) yields ^(r ^(a b c))
+            
+              If oldRoot was null, it's ok, just return newRoot (even if isNil).
+            
+                old=null, new=r yields r
+                old=null, new=^(nil r) yields ^(nil r)
+            
+              Return newRoot.  Throw an exception if newRoot is not a
+              simple node or nil root with a single child node--it must be a root
+              node.  If newRoot is ^(nil x) return x as newRoot.
+            
+              Be advised that it's ok for newRoot to point at oldRoot's
+              children; i.e., you don't have to copy the list.  We are
+              constructing these nodes so we should have this control for
+              efficiency.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.RulePostProcessing(System.Object)">
+            <summary>Transform ^(nil x) to x and nil to null</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.CreateToken(System.Int32,System.String)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.CreateToken(Antlr.Runtime.IToken)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              This is a variant of createToken where the new token is derived from
+              an actual real input token.  Typically this is for converting '{'
+              tokens to BLOCK etc...  You'll see
+            
+                r : lc='{' ID+ '}' -> ^(BLOCK[$lc] ID+) ;
+            
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.DupNode(System.Object)">
+            <summary>
+              Duplicate a node.  This is part of the factory;
+              override if you want another kind of node to be built.
+              </summary>
+            
+              <remarks>
+              I could use reflection to prevent having to override this
+              but reflection is slow.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.SetTokenBoundaries(System.Object,Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
+            <summary>
+            Track start/stop token for subtree root created for a rule.
+            Only works with Tree nodes.  For rules that match nothing,
+            seems like this will yield start=i and stop=i-1 in a nil node.
+            Might be useful info so I'll not force to be i..i.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.BufferedTreeNodeStream">
+            <summary>A buffered stream of tree nodes.  Nodes can be from a tree of ANY kind.</summary>
+            
+              This node stream sucks all nodes out of the tree specified in
+              the constructor during construction and makes pointers into
+              the tree using an array of Object pointers. The stream necessarily
+              includes pointers to DOWN and UP and EOF nodes.
+            
+              This stream knows how to mark/release for backtracking.
+            
+              This stream is most suitable for tree interpreters that need to
+              jump around a lot or for tree parsers requiring speed (at cost of memory).
+              There is some duplicated functionality here with UnBufferedTreeNodeStream
+              but just in bookkeeping, not tree walking etc...
+            
+              TARGET DEVELOPERS:
+            
+              This is the old CommonTreeNodeStream that buffered up entire node stream.
+              No need to implement really as new CommonTreeNodeStream is much better
+              and covers what we need.
+            
+              @see CommonTreeNodeStream
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.nodes">
+            <summary>The complete mapping from stream index to tree node.
+              This buffer includes pointers to DOWN, UP, and EOF nodes.
+              It is built upon ctor invocation.  The elements are type
+              Object as we don't what the trees look like.</summary>
+            
+              Load upon first need of the buffer so we can set token types
+              of interest for reverseIndexing.  Slows us down a wee bit to
+              do all of the if p==-1 testing everywhere though.
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.root">
+            <summary>Pull nodes from which tree?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.tokens">
+            <summary>IF this tree (root) was created from a token stream, track it.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.adaptor">
+            <summary>What tree adaptor was used to build these trees</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.uniqueNavigationNodes">
+            <summary>Reuse same DOWN, UP navigation nodes unless this is true</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.p">
+            <summary>The index into the nodes list of the current node (next node
+            to consume).  If -1, nodes array not filled yet.</summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.lastMarker">
+            <summary>Track the last mark() call result value for use in rewind().</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.BufferedTreeNodeStream.calls">
+            <summary>Stack of indexes used for push/pop calls</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.FillBuffer">
+            Walk tree with depth-first-search and fill nodes buffer.
+            Don't do DOWN, UP nodes if its a list (t is isNil).
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.GetNodeIndex(System.Object)">
+            What is the stream index for node? 0..n-1
+            Return -1 if node not found.
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.AddNavigationNode(System.Int32)">
+            As we flatten the tree, we use UP, DOWN nodes to represent
+            the tree structure.  When debugging we need unique nodes
+            so instantiate new ones when uniqueNavigationNodes is true.
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.LB(System.Int32)">
+            <summary>Look backwards k nodes</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.Push(System.Int32)">
+            <summary>
+            Make stream jump to a new location, saving old location.
+            Switch back with pop().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.Pop">
+            <summary>
+            Seek back to previous index saved during last push() call.
+            Return top of stack (return index).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.ToTokenTypeString">
+            <summary>Used for testing, just return the token type stream</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.BufferedTreeNodeStream.ToTokenString(System.Int32,System.Int32)">
+            <summary>Debugging</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.CommonErrorNode">
+            <summary>A node representing erroneous token range in token stream</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.CommonTree">
+            <summary>
+            A tree node that is wrapper for a Token object.  After 3.0 release
+            while building tree rewrite stuff, it became clear that computing
+            parent and child index is very difficult and cumbersome.  Better to
+            spend the space in every tree node.  If you don't want these extra
+            fields, it's easy to cut them out in your own BaseTree subclass.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree._token">
+            <summary>A single token is the payload</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree.startIndex">
+            <summary>
+            What token indexes bracket all tokens associated with this node
+            and below?
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree.parent">
+            <summary>Who is the parent node of this node; if null, implies node is root</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTree.childIndex">
+            <summary>What index is this node in the child list? Range: 0..n-1</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTree.SetUnknownTokenBoundaries">
+            <summary>
+            For every node in this subtree, make sure it's start/stop token's
+            are set.  Walk depth first, visit bottom up.  Only updates nodes
+            with at least one token index &lt; 0.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.CommonTreeAdaptor">
+            <summary>
+              A TreeAdaptor that works with any Tree implementation.  It provides
+              really just factory methods; all the work is done by BaseTreeAdaptor.
+              If you would like to have different tokens created than ClassicToken
+              objects, you need to override this and then set the parser tree adaptor to
+              use your subclass.
+              </summary>
+            
+              <remarks>
+              To get your parser to build nodes of a different type, override
+              create(Token), errorNode(), and to be safe, YourTreeClass.dupNode().
+              dupNode is called to duplicate nodes during rewrite operations.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.CreateToken(System.Int32,System.String)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.CreateToken(Antlr.Runtime.IToken)">
+            <summary>
+              Tell me how to create a token for use with imaginary token nodes.
+              For example, there is probably no input symbol associated with imaginary
+              token DECL, but you need to create it as a payload or whatever for
+              the DECL node as in ^(DECL type ID).
+              </summary>
+            
+              <remarks>
+              This is a variant of createToken where the new token is derived from
+              an actual real input token.  Typically this is for converting '{'
+              tokens to BLOCK etc...  You'll see
+            
+                r : lc='{' ID+ '}' -> ^(BLOCK[$lc] ID+) ;
+            
+              If you care what the token payload objects' type is, you should
+              override this method and any other createToken variant.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.GetToken(System.Object)">
+            <summary>
+            What is the Token associated with this node?  If
+            you are not using CommonTree, then you must
+            override this in your own adaptor.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._root">
+            <summary>Pull nodes from which tree?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream.tokens">
+            <summary>If this tree (root) was created from a token stream, track it.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._adaptor">
+            <summary>What tree adaptor was used to build these trees</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._it">
+            The tree iterator we are using 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._calls">
+            <summary>Stack of indexes used for push/pop calls</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._hasNilRoot">
+            <summary>Tree (nil A B C) trees like flat A B C streams</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._level">
+            <summary>Tracks tree depth.  Level=0 means we're at root node level.</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream._previousLocationElement">
+             Tracks the last node before the start of {@link #data} which contains
+             position information to provide information for error reporting. This is
+             tracked in addition to {@link #prevElement} which may or may not contain
+             position information.
+            
+             @see #hasPositionInformation
+             @see RecognitionException#extractInformationFromTreeNodeStream
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.Push(System.Int32)">
+            Make stream jump to a new location, saving old location.
+            Switch back with pop().
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.Pop">
+            Seek back to previous index saved during last push() call.
+            Return top of stack (return index).
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.GetKnownPositionElement(System.Boolean)">
+             Returns an element containing position information. If {@code allowApproximateLocation} is {@code false}, then
+             this method will return the {@code LT(1)} element if it contains position information, and otherwise return {@code null}.
+             If {@code allowApproximateLocation} is {@code true}, then this method will return the last known element containing position information.
+            
+             @see #hasPositionInformation
+        </member>
+        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.ToTokenTypeString">
+            <summary>For debugging; destructive: moves tree iterator to end.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.DotTreeGenerator">
+            A utility class to generate DOT diagrams (graphviz) from
+              arbitrary trees.  You can pass in your own templates and
+              can pass in any kind of tree or use Tree interface method.
+              I wanted this separator so that you don't have to include
+              ST just to use the org.antlr.runtime.tree.* package.
+              This is a set of non-static methods so you can subclass
+              to override.  For example, here is an invocation:
+            
+                  CharStream input = new ANTLRInputStream(System.in);
+                  TLexer lex = new TLexer(input);
+                  CommonTokenStream tokens = new CommonTokenStream(lex);
+                  TParser parser = new TParser(tokens);
+                  TParser.e_return r = parser.e();
+                  Tree t = (Tree)r.tree;
+                  System.out.println(t.toStringTree());
+                  DOTTreeGenerator gen = new DOTTreeGenerator();
+                  StringTemplate st = gen.toDOT(t);
+                  System.out.println(st);
+        </member>
+        <member name="F:Antlr.Runtime.Tree.DotTreeGenerator.nodeToNumberMap">
+            Track node to number mapping so we can get proper node name back 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.DotTreeGenerator.nodeNumber">
+            Track node number so we can get unique node names 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.DotTreeGenerator.ToDot(System.Object,Antlr.Runtime.Tree.ITreeAdaptor)">
+            Generate DOT (graphviz) for a whole tree not just a node.
+              For example, 3+4*5 should generate:
+            
+             digraph {
+               node [shape=plaintext, fixedsize=true, fontsize=11, fontname="Courier",
+                     width=.4, height=.2];
+               edge [arrowsize=.7]
+               "+"->3
+               "+"->"*"
+               "*"->4
+               "*"->5
+             }
+            
+             Takes a Tree interface object.
+        </member>
+        <member name="T:Antlr.Runtime.Tree.IPositionTrackingStream">
+            
+             @author Sam Harwell
+        </member>
+        <member name="M:Antlr.Runtime.Tree.IPositionTrackingStream.GetKnownPositionElement(System.Boolean)">
+             Returns an element containing concrete information about the current
+             position in the stream.
+            
+             @param allowApproximateLocation if {@code false}, this method returns
+             {@code null} if an element containing exact information about the current
+             position is not available
+        </member>
+        <member name="M:Antlr.Runtime.Tree.IPositionTrackingStream.HasPositionInformation(System.Object)">
+             Determines if the specified {@code element} contains concrete position
+             information.
+            
+             @param element the element to check
+             @return {@code true} if {@code element} contains concrete position
+             information, otherwise {@code false}
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITree">
+            <summary>
+              What does a tree look like?  ANTLR has a number of support classes
+              such as CommonTreeNodeStream that work on these kinds of trees.  You
+              don't have to make your trees implement this interface, but if you do,
+              you'll be able to use more support code.
+              </summary>
+            
+              <remarks>
+              NOTE: When constructing trees, ANTLR can build any kind of tree; it can
+              even use Token objects as trees if you add a child list to your tokens.
+            
+              This is a tree node without any payload; just navigation and factory stuff.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.HasAncestor(System.Int32)">
+            <summary>Is there is a node above with token type ttype?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.GetAncestor(System.Int32)">
+            <summary>Walk upwards and get first ancestor with this token type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.GetAncestors">
+            <summary>
+            Return a list of all ancestors of this node.  The first node of
+            list is the root and the last is the parent of this node.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.ChildIndex">
+            <summary>This node is what child index? 0..n-1</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.FreshenParentAndChildIndexes">
+            <summary>Set the parent and child index values for all children</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.AddChild(Antlr.Runtime.Tree.ITree)">
+            <summary>
+            Add t as a child to this node.  If t is null, do nothing.  If t
+            is nil, add all children of t to this' children.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.SetChild(System.Int32,Antlr.Runtime.Tree.ITree)">
+            <summary>Set ith child (0..n-1) to t; t must be non-null and non-nil node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITree.ReplaceChildren(System.Int32,System.Int32,System.Object)">
+            <summary>
+            Delete children from start to stop and replace with t even if t is
+            a list (nil-root tree).  num of children can increase or decrease.
+            For huge child lists, inserting children can force walking rest of
+            children to set their childindex; could be slow.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.IsNil">
+            <summary>
+            Indicates the node is a nil node but may still have children, meaning
+            the tree is a flat list.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.TokenStartIndex">
+            <summary>
+            What is the smallest token index (indexing from 0) for this node
+            and its children?
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.TokenStopIndex">
+            <summary>
+            What is the largest token index (indexing from 0) for this node
+            and its children?
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.Type">
+            <summary>Return a token type; needed for tree parsing</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITree.Line">
+            <summary>In case we don't have a token payload, what is the line for errors?</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITreeAdaptor">
+            <summary>
+              How to create and navigate trees.  Rather than have a separate factory
+              and adaptor, I've merged them.  Makes sense to encapsulate.
+              </summary>
+            
+              <remarks>
+              This takes the place of the tree construction code generated in the
+              generated code in 2.x and the ASTFactory.
+            
+              I do not need to know the type of a tree at all so they are all
+              generic Objects.  This may increase the amount of typecasting needed. :(
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(Antlr.Runtime.IToken)">
+            <summary>
+              Create a tree node from Token object; for CommonTree type trees,
+              then the token just becomes the payload.  This is the most
+              common create call.
+              </summary>
+            
+              <remarks>
+              Override if you want another kind of node to be built.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,Antlr.Runtime.IToken)">
+            <summary>
+              Create a new node derived from a token, with a new token type.
+              This is invoked from an imaginary node ref on right side of a
+              rewrite rule as IMAG[$tokenLabel].
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(Token).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,Antlr.Runtime.IToken,System.String)">
+            <summary>
+              Same as create(tokenType,fromToken) except set the text too.
+              This is invoked from an imaginary node ref on right side of a
+              rewrite rule as IMAG[$tokenLabel, "IMAG"].
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(Token).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(Antlr.Runtime.IToken,System.String)">
+            <summary>
+              Same as create(fromToken) except set the text too.
+              This is invoked when the <c>text</c> terminal option is set, as in
+              IMAG&lt;text='IMAG'&gt;.
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(Token).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,System.String)">
+            <summary>
+              Create a new node derived from a token, with a new token type.
+              This is invoked from an imaginary node ref on right side of a
+              rewrite rule as IMAG["IMAG"].
+              </summary>
+            
+              <remarks>
+              This should invoke createToken(int,String).
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DupNode(System.Object)">
+            <summary>Duplicate a single tree node.</summary>
+            <remarks>Override if you want another kind of node to be built.</remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DupTree(System.Object)">
+            <summary>Duplicate tree recursively, using dupNode() for each node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Nil">
+            <summary>
+            Return a nil node (an empty but non-null node) that can hold
+            a list of element as the children.  If you want a flat tree (a list)
+            use "t=adaptor.nil(); t.addChild(x); t.addChild(y);"
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.ErrorNode(Antlr.Runtime.ITokenStream,Antlr.Runtime.IToken,Antlr.Runtime.IToken,Antlr.Runtime.RecognitionException)">
+            <summary>
+              Return a tree node representing an error.  This node records the
+              tokens consumed during error recovery.  The start token indicates the
+              input symbol at which the error was detected.  The stop token indicates
+              the last symbol consumed during recovery.
+              </summary>
+            
+              <remarks>
+              You must specify the input stream so that the erroneous text can
+              be packaged up in the error node.  The exception could be useful
+              to some applications; default implementation stores ptr to it in
+              the CommonErrorNode.
+            
+              This only makes sense during token parsing, not tree parsing.
+              Tree parsing should happen only when parsing and tree construction
+              succeed.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.IsNil(System.Object)">
+            <summary>Is tree considered a nil node used to make lists of child nodes?</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.AddChild(System.Object,System.Object)">
+            <summary>
+            Add a child to the tree t.  If child is a flat tree (a list), make all
+            in list children of t.  Warning: if t has no children, but child does
+            and child isNil then you can decide it is ok to move children to t via
+            t.children = child.children; i.e., without copying the array.  Just
+            make sure that this is consistent with have the user will build
+            ASTs.  Do nothing if t or child is null.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(System.Object,System.Object)">
+            <summary>
+              If oldRoot is a nil root, just copy or move the children to newRoot.
+              If not a nil root, make oldRoot a child of newRoot.
+              </summary>
+            
+              <remarks>
+                old=^(nil a b c), new=r yields ^(r a b c)
+                old=^(a b c), new=r yields ^(r ^(a b c))
+            
+              If newRoot is a nil-rooted single child tree, use the single
+              child as the new root node.
+            
+                old=^(nil a b c), new=^(nil r) yields ^(r a b c)
+                old=^(a b c), new=^(nil r) yields ^(r ^(a b c))
+            
+              If oldRoot was null, it's ok, just return newRoot (even if isNil).
+            
+                old=null, new=r yields r
+                old=null, new=^(nil r) yields ^(nil r)
+            
+              Return newRoot.  Throw an exception if newRoot is not a
+              simple node or nil root with a single child node--it must be a root
+              node.  If newRoot is ^(nil x) return x as newRoot.
+            
+              Be advised that it's ok for newRoot to point at oldRoot's
+              children; i.e., you don't have to copy the list.  We are
+              constructing these nodes so we should have this control for
+              efficiency.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.RulePostProcessing(System.Object)">
+            <summary>
+              Given the root of the subtree created for this rule, post process
+              it to do any simplifications or whatever you want.  A required
+              behavior is to convert ^(nil singleSubtree) to singleSubtree
+              as the setting of start/stop indexes relies on a single non-nil root
+              for non-flat trees.
+              </summary>
+            
+              <remarks>
+              Flat trees such as for lists like "idlist : ID+ ;" are left alone
+              unless there is only one ID.  For a list, the start/stop indexes
+              are set in the nil node.
+            
+              This method is executed after all rule tree construction and right
+              before setTokenBoundaries().
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetUniqueID(System.Object)">
+            <summary>For identifying trees.</summary>
+            
+              <remarks>
+              How to identify nodes so we can say "add node to a prior node"?
+              Even becomeRoot is an issue.  Use System.identityHashCode(node)
+              usually.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(Antlr.Runtime.IToken,System.Object)">
+            <summary>
+              Create a node for newRoot make it the root of oldRoot.
+              If oldRoot is a nil root, just copy or move the children to newRoot.
+              If not a nil root, make oldRoot a child of newRoot.
+              </summary>
+            
+              <returns>
+              Return node created for newRoot.
+              </returns>
+            
+              <remarks>
+              Be advised: when debugging ASTs, the DebugTreeAdaptor manually
+              calls create(Token child) and then plain becomeRoot(node, node)
+              because it needs to trap calls to create, but it can't since it delegates
+              to not inherits from the TreeAdaptor.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetType(System.Object)">
+            <summary>For tree parsing, I need to know the token type of a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetType(System.Object,System.Int32)">
+            <summary>Node constructors can set the type of a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetText(System.Object,System.String)">
+            <summary>Node constructors can set the text of a node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetToken(System.Object)">
+            <summary>
+            Return the token object from which this node was created.
+            Currently used only for printing an error message.
+            The error display routine in BaseRecognizer needs to
+            display where the input the error occurred. If your
+            tree of limitation does not store information that can
+            lead you to the token, you can create a token filled with
+            the appropriate information and pass that back.  See
+            BaseRecognizer.getErrorMessage().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetTokenBoundaries(System.Object,Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
+            <summary>
+            Where are the bounds in the input token stream for this node and
+            all children?  Each rule that creates AST nodes will call this
+            method right before returning.  Flat trees (i.e., lists) will
+            still usually have a nil root node just to hold the children list.
+            That node would contain the start/stop indexes then.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetTokenStartIndex(System.Object)">
+            <summary>Get the token start index for this subtree; return -1 if no such index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetTokenStopIndex(System.Object)">
+            <summary>Get the token stop index for this subtree; return -1 if no such index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChild(System.Object,System.Int32)">
+            <summary>Get a child 0..n-1 node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetChild(System.Object,System.Int32,System.Object)">
+            <summary>Set ith child (0..n-1) to t; t must be non-null and non-nil node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DeleteChild(System.Object,System.Int32)">
+            <summary>Remove ith child and shift children down from right.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChildCount(System.Object)">
+            <summary>How many children?  If 0, then this is a leaf node</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetParent(System.Object)">
+            <summary>
+            Who is the parent node of this node; if null, implies node is root.
+            If your node type doesn't handle this, it's ok but the tree rewrites
+            in tree parsers need this functionality.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChildIndex(System.Object)">
+            <summary>
+            What index is this node in the child list? Range: 0..n-1
+            If your node type doesn't handle this, it's ok but the tree rewrites
+            in tree parsers need this functionality.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.ReplaceChildren(System.Object,System.Int32,System.Int32,System.Object)">
+            <summary>
+              Replace from start to stop child index of parent with t, which might
+              be a list.  Number of children may be different after this call.
+              </summary>
+            
+              <remarks>
+              If parent is null, don't do anything; must be at root of overall tree.
+              Can't replace whatever points to the parent externally.  Do nothing.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITreeNodeStream">
+            <summary>A stream of tree nodes, accessing nodes from a tree of some kind</summary> 
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.Item(System.Int32)">
+            <summary>
+            Get a tree node at an absolute index i; 0..n-1.
+            If you don't want to buffer up nodes, then this method makes no
+            sense for you.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.LT(System.Int32)">
+            <summary>
+             Get tree node at current input pointer + <paramref name="k"/> ahead where
+             <paramref name="k"/>==1 is next node. <paramref name="k"/>&lt;0 indicates nodes in the past. So
+             {@code LT(-1)} is previous node, but implementations are not required to
+             provide results for <paramref name="k"/> &lt; -1. {@code LT(0)} is undefined. For
+             <paramref name="k"/>&lt;=n, return <see langword="null"/>. Return <see langword="null"/> for {@code LT(0)}
+             and any index that results in an absolute address that is negative.
+              </summary>
+            
+              <remarks>
+             This is analogous to <see cref="M:Antlr.Runtime.ITokenStream.LT(System.Int32)"/>, but this returns a tree node
+             instead of a <see cref="T:Antlr.Runtime.IToken"/>. Makes code generation identical for both
+             parser and tree grammars.
+              </remarks>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TreeSource">
+            <summary>
+            Where is this stream pulling nodes from?  This is not the name, but
+            the object that provides node objects.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TokenStream">
+            <summary>
+            If the tree associated with this stream was created from a
+            {@link TokenStream}, you can specify it here. Used to do rule
+            {@code $text} attribute in tree parser. Optional unless you use tree
+            parser rule {@code $text} attribute or {@code output=template} and
+            {@code rewrite=true} options.
+             </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TreeAdaptor">
+            <summary>
+            What adaptor can tell me how to interpret/navigate nodes and
+            trees.  E.g., get text of a node.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.UniqueNavigationNodes">
+            <summary>
+            As we flatten the tree, we use {@link Token#UP}, {@link Token#DOWN} nodes
+            to represent the tree structure. When debugging we need unique nodes so
+            we have to instantiate new ones. When doing normal tree parsing, it's
+            slow and a waste of memory to create unique navigation nodes. Default
+            should be {@code false}.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.ToString(System.Object,System.Object)">
+            <summary>
+            Return the text of all nodes from {@code start} to {@code stop},
+            inclusive. If the stream does not buffer all the nodes then it can still
+            walk recursively from start until stop. You can always return
+            {@code null} or {@code ""} too, but users should not access
+            {@code $ruleLabel.text} in an action of course in that case.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.ReplaceChildren(System.Object,System.Int32,System.Int32,System.Object)">
+            <summary>
+             Replace children of {@code parent} from index {@code startChildIndex} to
+             {@code stopChildIndex} with {@code t}, which might be a list. Number of
+             children may be different after this call. The stream is notified because
+             it is walking the tree and might need to know you are monkeying with the
+             underlying tree. Also, it might be able to modify the node stream to
+             avoid restreaming for future phases.
+              </summary>
+            
+              <remarks>
+             If {@code parent} is {@code null}, don't do anything; must be at root of
+             overall tree. Can't replace whatever points to the parent externally. Do
+             nothing.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ITreeVisitorAction">
+            <summary>
+            How to execute code for node t when a visitor visits node t.  Execute
+            pre() before visiting children and execute post() after visiting children.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeVisitorAction.Pre(System.Object)">
+            <summary>
+            Execute an action before visiting children of t.  Return t or
+            a rewritten t.  It is up to the visitor to decide what to do
+            with the return value.  Children of returned value will be
+            visited if using TreeVisitor.visit().
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ITreeVisitorAction.Post(System.Object)">
+            <summary>
+            Execute an action after visiting children of t.  Return t or
+            a rewritten t.  It is up to the visitor to decide what to do
+            with the return value.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.ParseTree">
+            <summary>
+            A record of the rules used to match a token sequence.  The tokens
+            end up as the leaves of this tree and rule nodes are the interior nodes.
+            This really adds no functionality, it is just an alias for CommonTree
+            that is more meaningful (specific) and holds a String to display for a node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ParseTree.ToStringWithHiddenTokens">
+            <summary>
+            Emit a token and all hidden nodes before.  EOF node holds all
+            hidden tokens after last real token.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.ParseTree.ToInputString">
+            <summary>
+            Print out the leaves of this tree, which means printing original
+            input back out.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteCardinalityException">
+            <summary>
+            Base class for all exceptions thrown during AST rewrite construction.
+            This signifies a case where the cardinality of two or more elements
+            in a subrule are different: (ID INT)+ where |ID|!=|INT|
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteEarlyExitException">
+            <summary>No elements within a (...)+ in a rewrite rule</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteEmptyStreamException">
+            <summary>Ref to ID or expr but no tokens in ID stream or subtrees in expr stream</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteRuleElementStream">
+            <summary>
+              A generic list of elements tracked in an alternative to be used in
+              a -> rewrite rule.  We need to subclass to fill in the next() method,
+              which returns either an AST node wrapped around a token payload or
+              an existing subtree.
+              </summary>
+            
+              <remarks>
+              Once you start next()ing, do not try to add more elements.  It will
+              break the cursor tracking I believe.
+            
+              TODO: add mechanism to detect/puke on modification after reading from stream
+              </remarks>
+            
+              <see cref="T:Antlr.Runtime.Tree.RewriteRuleSubtreeStream"/>
+              <see cref="T:Antlr.Runtime.Tree.RewriteRuleTokenStream"/>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.cursor">
+            <summary>
+            Cursor 0..n-1.  If singleElement!=null, cursor is 0 until you next(),
+            which bumps it to 1 meaning no more elements.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.singleElement">
+            <summary>Track single elements w/o creating a list.  Upon 2nd add, alloc list</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.elements">
+            <summary>The list of tokens or subtrees we are tracking</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.dirty">
+            <summary>Once a node / subtree has been used in a stream, it must be dup'd
+            from then on.  Streams are reset after subrules so that the streams
+            can be reused in future subrules.  So, reset must set a dirty bit.
+            If dirty, then next() always returns a dup.</summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream.elementDescription">
+            <summary>The element or stream description; usually has name of the token or
+            rule reference that this list tracks.  Can include rulename too, but
+            the exception would track that info.</summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.Reset">
+            <summary>
+            Reset the condition of this stream so that it appears we have
+            not consumed any of its elements.  Elements themselves are untouched.
+            Once we reset the stream, any future use will need duplicates.  Set
+            the dirty bit.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.NextTree">
+            <summary>
+            Return the next element in the stream.  If out of elements, throw
+            an exception unless size()==1.  If size is 1, then return elements[0].
+            Return a duplicate node/subtree if stream is out of elements and
+            size==1.  If we've already used the element, dup (dirty bit set).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.NextCore">
+            <summary>
+            Do the work of getting the next element, making sure that it's
+            a tree node or subtree.  Deal with the optimization of single-
+            element list versus list of size > 1.  Throw an exception
+            if the stream is empty or we're out of elements and size>1.
+            protected so you can override in a subclass if necessary.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.Dup(System.Object)">
+            <summary>
+             When constructing trees, sometimes we need to dup a token or AST
+            	subtree.  Dup'ing a token means just creating another AST node
+             around it.  For trees, you must call the adaptor.dupTree() unless
+             the element is for a tree root; then it must be a node dup.
+             </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream.ToTree(System.Object)">
+            <summary>
+            Ensure stream emits trees; tokens must be converted to AST nodes.
+            AST nodes can be passed through unmolested.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.RewriteRuleNodeStream">
+            <summary>
+            Queues up nodes matched on left side of -> in a tree parser. This is
+            the analog of RewriteRuleTokenStream for normal parsers.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleNodeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleNodeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.NextNode">
+            <summary>
+              Treat next element as a single node even if it's a subtree.
+              This is used instead of next() when the result has to be a
+              tree root node.  Also prevents us from duplicating recently-added
+              children; e.g., ^(type ID)+ adds ID to type and then 2nd iteration
+              must dup the type node, but ID has been added.
+              </summary>
+            
+              <remarks>
+              Referencing a rule result twice is ok; dup entire tree as
+              we can't be adding trees as root; e.g., expr expr.
+            
+              Hideous code duplication here with super.next().  Can't think of
+              a proper way to refactor.  This needs to always call dup node
+              and super.next() doesn't know which to call: dup node or dup tree.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
+            <summary>Create a stream with one element</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
+            <summary>Create a stream, but feed off an existing list</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.NextNode">
+            <summary>Get next token from stream and make a node for it</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.ToTree(System.Object)">
+            <summary>
+            Don't convert to a tree unless they explicitly call nextTree.
+            This way we can do hetero tree nodes in rewrite.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeIterator">
+            Return a node stream from a doubly-linked tree whose nodes
+              know what child index they are.  No remove() is supported.
+            
+              Emit navigation nodes (DOWN, UP, and EOF) to let show tree structure.
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreeIterator.nodes">
+            If we emit UP/DOWN nodes, we need to spit out multiple nodes per
+            next() call.
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeParser">
+            <summary>
+            A parser for a stream of tree nodes.  "tree grammars" result in a subclass
+            of this.  All the error reporting and recovery is shared with Parser via
+            the BaseRecognizer superclass.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.SetTreeNodeStream(Antlr.Runtime.Tree.ITreeNodeStream)">
+            <summary>Set the input stream</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.MatchAny(Antlr.Runtime.IIntStream)">
+            <summary>
+            Match '.' in tree parser has special meaning.  Skip node or
+            entire tree if node has children.  If children, scan until
+            corresponding UP node.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.RecoverFromMismatchedToken(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
+            <summary>
+            We have DOWN/UP nodes in the stream that have no line info; override.
+            plus we want to alter the exception type.  Don't try to recover
+            from tree parser errors inline...
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.GetErrorHeader(Antlr.Runtime.RecognitionException)">
+            <summary>
+            Prefix error message with the grammar name because message is
+            always intended for the programmer because the parser built
+            the input tree not the user.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeParser.GetErrorMessage(Antlr.Runtime.RecognitionException,System.String[])">
+            <summary>
+            Tree parsers parse nodes they usually have a token object as
+            payload. Set the exception token and do the default behavior.
+            </summary>
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.pattern">
+            <summary>The tree pattern to lex like "(A B C)"</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.p">
+            <summary>Index into input string</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.c">
+            <summary>Current char</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.n">
+            <summary>How long is the pattern in char?</summary> 
+        </member>
+        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.sval">
+            <summary>Set when token type is ID or ARG (name mimics Java's StreamTokenizer)</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeRewriter.ReportTransformation(System.Object,System.Object)">
+            Override this if you need transformation tracing to go somewhere
+            other than stdout or if you're not using ITree-derived trees.
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeRuleReturnScope`1">
+            <summary>
+            This is identical to the ParserRuleReturnScope except that
+            the start property is a tree nodes not Token object
+            when you are parsing trees.
+            </summary>
+        </member>
+        <member name="P:Antlr.Runtime.Tree.TreeRuleReturnScope`1.Start">
+            <summary>Gets the first node or root node of tree matched for this rule.</summary> 
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeVisitor">
+            <summary>Do a depth first walk of a tree, applying pre() and post() actions as we go.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeVisitor.Visit(System.Object,Antlr.Runtime.Tree.ITreeVisitorAction)">
+            <summary>
+            Visit every node in tree t and trigger an action for each node
+            before/after having visited all of its children.  Bottom up walk.
+            Execute both actions even if t has no children.  Ignore return
+            results from transforming children since they will have altered
+            the child list of this node (their parent).  Return result of
+            applying post action to this node.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeWizard">
+            <summary>
+              Build and navigate trees with this object.  Must know about the names
+              of tokens so you have to pass in a map or array of token names (from which
+              this class can build the map).  I.e., Token DECL means nothing unless the
+              class can translate it to a token type.
+              </summary>
+            
+              <remarks>
+              In order to create nodes and navigate, this class needs a TreeAdaptor.
+            
+              This class can build a token type -> node index for repeated use or for
+              iterating over the various nodes with a particular type.
+            
+              This class works in conjunction with the TreeAdaptor rather than moving
+              all this functionality into the adaptor.  An adaptor helps build and
+              navigate trees using methods.  This class helps you do it with string
+              patterns like "(A B C)".  You can create a tree from that pattern or
+              match subtrees against it.
+              </remarks>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeWizard.TreePattern">
+            <summary>
+            When using %label:TOKENNAME in a tree for parse(), we must
+            track the label.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.Tree.TreeWizard.TreePatternTreeAdaptor">
+            <summary>This adaptor creates TreePattern objects for use during scan()</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.ComputeTokenTypes(System.String[])">
+            <summary>
+            Compute a Map&lt;String, Integer&gt; that is an inverted index of
+            tokenNames (which maps int token types to names).
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.GetTokenType(System.String)">
+            <summary>Using the map of token names to token types, return the type.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Index(System.Object)">
+            <summary>
+              Walk the entire tree and make a node name to nodes mapping.
+              For now, use recursion but later nonrecursive version may be
+              more efficient.  Returns Map&lt;Integer, List&gt; where the List is
+              of your AST node type.  The Integer is the token type of the node.
+              </summary>
+            
+              <remarks>
+              TODO: save this index so that find and visit are faster
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.IndexCore(System.Object,System.Collections.Generic.IDictionary{System.Int32,System.Collections.IList})">
+            <summary>Do the work for index</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Find(System.Object,System.Int32)">
+            <summary>Return a List of tree nodes with token type ttype</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Find(System.Object,System.String)">
+            <summary>Return a List of subtrees matching pattern.</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Visit(System.Object,System.Int32,Antlr.Runtime.Tree.TreeWizard.IContextVisitor)">
+            <summary>
+            Visit every ttype node in t, invoking the visitor.  This is a quicker
+            version of the general visit(t, pattern) method.  The labels arg
+            of the visitor action method is never set (it's null) since using
+            a token type rather than a pattern doesn't let us set a label.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.VisitCore(System.Object,System.Object,System.Int32,System.Int32,Antlr.Runtime.Tree.TreeWizard.IContextVisitor)">
+            <summary>Do the recursive work for visit</summary> 
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Visit(System.Object,System.String,Antlr.Runtime.Tree.TreeWizard.IContextVisitor)">
+            <summary>
+            For all subtrees that match the pattern, execute the visit action.
+            The implementation uses the root node of the pattern in combination
+            with visit(t, ttype, visitor) so nil-rooted patterns are not allowed.
+            Patterns with wildcard roots are also not allowed.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Parse(System.Object,System.String,System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+              Given a pattern like (ASSIGN %lhs:ID %rhs:.) with optional labels
+              on the various nodes and '.' (dot) as the node/subtree wildcard,
+              return true if the pattern matches and fill the labels Map with
+              the labels pointing at the appropriate nodes.  Return false if
+              the pattern is malformed or the tree does not match.
+              </summary>
+            
+              <remarks>
+              If a node specifies a text arg in pattern, then that must match
+              for that node in t.
+            
+              TODO: what's a better way to indicate bad pattern? Exceptions are a hassle 
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.ParseCore(System.Object,Antlr.Runtime.Tree.TreeWizard.TreePattern,System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+            Do the work for parse. Check to see if the t2 pattern fits the
+            structure and token types in t1.  Check text if the pattern has
+            text arguments on nodes.  Fill labels map with pointers to nodes
+            in tree matched against nodes in pattern with labels.
+            </summary>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Create(System.String)">
+            <summary>
+              Create a tree or node from the indicated tree pattern that closely
+              follows ANTLR tree grammar tree element syntax:
+            
+                  (root child1 ... child2).
+              </summary>
+            
+              <remarks>
+              You can also just pass in a node: ID
+             
+              Any node can have a text argument: ID[foo]
+              (notice there are no quotes around foo--it's clear it's a string).
+            
+              nil is a special name meaning "give me a nil node".  Useful for
+              making lists: (nil A B C) is a list of A B C.
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Equals(System.Object,System.Object,Antlr.Runtime.Tree.ITreeAdaptor)">
+            <summary>
+              Compare t1 and t2; return true if token types/text, structure match exactly.
+              The trees are examined in their entirety so that (A B) does not match
+              (A B C) nor (A (B C)). 
+              </summary>
+            
+              <remarks>
+              TODO: allow them to pass in a comparator
+              TODO: have a version that is nonstatic so it can use instance adaptor
+            
+              I cannot rely on the tree node's equals() implementation as I make
+              no constraints at all on the node types nor interface etc... 
+              </remarks>
+        </member>
+        <member name="M:Antlr.Runtime.Tree.TreeWizard.Equals(System.Object,System.Object)">
+            <summary>
+            Compare type, structure, and text of two trees, assuming adaptor in
+            this instance of a TreeWizard.
+            </summary>
+        </member>
+        <member name="T:Antlr.Runtime.UnbufferedTokenStream">
+            A token stream that pulls tokens from the code source on-demand and
+              without tracking a complete buffer of the tokens. This stream buffers
+              the minimum number of tokens possible.  It's the same as
+              OnDemandTokenStream except that OnDemandTokenStream buffers all tokens.
+            
+              You can't use this stream if you pass whitespace or other off-channel
+              tokens to the parser. The stream can't ignore off-channel tokens.
+             
+              You can only look backwards 1 token: LT(-1).
+            
+              Use this when you need to read from a socket or other infinite stream.
+            
+              @see BufferedTokenStream
+              @see CommonTokenStream
+        </member>
+        <member name="F:Antlr.Runtime.UnbufferedTokenStream.channel">
+            Skip tokens on any channel but this one; this is how we skip whitespace... 
+        </member>
+        <member name="T:Antlr.Runtime.UnwantedTokenException">
+            <summary>An extra token while parsing a TokenStream</summary> 
+        </member>
+    </members>
+</doc>
diff --git a/packages/Antlr34.3.4.19004.1/.signature.p7s b/packages/Antlr34.3.4.19004.1/.signature.p7s
new file mode 100644
index 0000000..cc290e2
Binary files /dev/null and b/packages/Antlr34.3.4.19004.1/.signature.p7s differ
diff --git a/packages/Antlr34.3.4.19004.1/Antlr34.3.4.19004.1.nupkg b/packages/Antlr34.3.4.19004.1/Antlr34.3.4.19004.1.nupkg
new file mode 100644
index 0000000..6076bdc
Binary files /dev/null and b/packages/Antlr34.3.4.19004.1/Antlr34.3.4.19004.1.nupkg differ
diff --git a/packages/Antlr34.3.4.19004.1/lib/Antlr3.Runtime.dll b/packages/Antlr34.3.4.19004.1/lib/Antlr3.Runtime.dll
new file mode 100644
index 0000000..34bd478
Binary files /dev/null and b/packages/Antlr34.3.4.19004.1/lib/Antlr3.Runtime.dll differ
diff --git a/packages/Antlr34.3.4.19004.1/tools/Antlr3.Runtime.Debug.dll b/packages/Antlr34.3.4.19004.1/tools/Antlr3.Runtime.Debug.dll
new file mode 100644
index 0000000..2937899
Binary files /dev/null and b/packages/Antlr34.3.4.19004.1/tools/Antlr3.Runtime.Debug.dll differ
diff --git a/packages/Antlr34.3.4.19004.1/tools/Antlr3.Runtime.JavaExtensions.dll b/packages/Antlr34.3.4.19004.1/tools/Antlr3.Runtime.JavaExtensions.dll
new file mode 100644
index 0000000..7ff67dc
Binary files /dev/null and b/packages/Antlr34.3.4.19004.1/tools/Antlr3.Runtime.JavaExtensions.dll differ
diff --git a/packages/Antlr34.3.4.19004.1/tools/Antlr3.Runtime.dll b/packages/Antlr34.3.4.19004.1/tools/Antlr3.Runtime.dll
new file mode 100644
index 0000000..34bd478
Binary files /dev/null and b/packages/Antlr34.3.4.19004.1/tools/Antlr3.Runtime.dll differ
diff --git a/packages/Antlr34.3.4.19004.1/tools/Antlr3.exe.config b/packages/Antlr34.3.4.19004.1/tools/Antlr3.exe.config
new file mode 100644
index 0000000..bd4cf43
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Antlr3.exe.config
@@ -0,0 +1,3 @@
+<?xml version="1.0"?>
+<configuration>
+	<startup><supportedRuntime version="v2.0.50727" sku="Client"/></startup></configuration>
diff --git a/packages/Antlr34.3.4.19004.1/tools/Antlr3.targets b/packages/Antlr34.3.4.19004.1/tools/Antlr3.targets
new file mode 100644
index 0000000..3a440da
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Antlr3.targets
@@ -0,0 +1,163 @@
+<!--
+   [The "BSD licence"]
+   Copyright (c) 2011 Sam Harwell
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+   1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+   2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+   3. The name of the author may not be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+   IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+   IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-->
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <BuildSystem>MSBuild</BuildSystem>
+    <TaskVersion>3.3.0.7239</TaskVersion>
+    <TaskKeyToken>eb42632606e9261f</TaskKeyToken>
+    <AntlrBuildTaskAssemblyName Condition="'$(AntlrBuildTaskAssemblyName)'==''">AntlrBuildTask, Version=$(TaskVersion), Culture=neutral, PublicKeyToken=$(TaskKeyToken)</AntlrBuildTaskAssemblyName>
+  </PropertyGroup>
+
+  <!--<PropertyGroup>
+    <LoadTimeSensitiveTargets>
+      $(LoadTimeSensitiveTargets);
+      AntlrCompile;
+    </LoadTimeSensitiveTargets>
+    <LoadTimeSensitiveProperties>
+      $(LoadTimeSensitiveProperties);
+      AntlrCompileDependsOn;
+    </LoadTimeSensitiveProperties>
+
+
+    <PrepareResourcesDependsOn>
+      AntlrCompile;
+      $(PrepareResourcesDependsOn)
+    </PrepareResourcesDependsOn>
+  </PropertyGroup>-->
+
+  <PropertyGroup>
+    <AntlrBuildTaskLocation Condition="'$(AntlrBuildTaskPath)'==''">$(MSBuildBinPath)</AntlrBuildTaskLocation>
+    <AntlrBuildTaskLocation Condition="'$(AntlrBuildTaskPath)'!=''">$(AntlrBuildTaskPath)</AntlrBuildTaskLocation>
+    <AntlrToolLocation Condition="'$(AntlrToolPath)'==''">$(MSBuildBinPath)\Antlr3\Antlr3.exe</AntlrToolLocation>
+    <AntlrToolLocation Condition="'$(AntlrToolPath)'!=''">$(AntlrToolPath)</AntlrToolLocation>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <AntlrGenCodeFileNames Condition="'$(AntlrGenCodeFileNames)'==''">$(MSBuildProjectFile).AntlrGeneratedCodeFileListAbsolute.txt</AntlrGenCodeFileNames>
+  </PropertyGroup>
+
+  <UsingTask Condition="'$(AntlrBuildTaskPath)'==''" TaskName="Antlr3.Build.Tasks.AntlrClassGenerationTask" AssemblyName="$(AntlrBuildTaskAssemblyName)" />
+  <UsingTask Condition="'$(AntlrBuildTaskPath)'!=''" TaskName="Antlr3.Build.Tasks.AntlrClassGenerationTask" AssemblyFile="$(AntlrBuildTaskPath)\AntlrBuildTask.dll" />
+
+  <PropertyGroup>
+    <PrepareResourcesDependsOn>
+      AntlrCompile;
+      AntlrCompileAddFilesGenerated;
+      $(PrepareResourcesDependsOn)
+    </PrepareResourcesDependsOn>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <AntlrCompileDependsOn>
+      AntlrCompileReadGeneratedFileList
+    </AntlrCompileDependsOn>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(BuildingInsideVisualStudio)'=='true'">
+    <AvailableItemName Include="Antlr3" />
+    <AvailableItemName Include="AntlrTokens" />
+    <AvailableItemName Include="AntlrAbstractGrammar" />
+  </ItemGroup>
+
+  <Target Name="AntlrCompileReadGeneratedFileList">
+    <ReadLinesFromFile File="$(IntermediateOutputPath)$(AntlrGenCodeFileNames)">
+      <Output TaskParameter="Lines" ItemName="AntlrOutputCodeFilesList"/>
+    </ReadLinesFromFile>
+  </Target>
+
+  <PropertyGroup>
+    <!-- Add grammar compilation to the CoreCompileDependsOn so that the IDE inproc compilers (particularly VB)
+         can "see" the generated source files. -->
+    <CoreCompileDependsOn Condition="'$(BuildingInsideVisualStudio)' == 'true' ">
+      DesignTimeGrammarCompilation;
+      $(CoreCompileDependsOn)
+    </CoreCompileDependsOn>
+  </PropertyGroup>
+
+  <Target Name="DesignTimeGrammarCompilation">
+    <!-- Only if we are not actually performing a compile i.e. we are in design mode -->
+    <CallTarget Condition="'$(BuildingProject)' != 'true'"
+                Targets="AntlrCompile" />
+  </Target>
+
+  <Target Name="AntlrCompile"
+          DependsOnTargets="$(AntlrCompileDependsOn)"
+          Condition="'@(Antlr3)' != ''"
+          Inputs="@(Antlr3);@(AntlrTokens);@(AntlrAbstractGrammar)"
+          Outputs="@(AntlrOutputCodeFilesList);
+                  $(IntermediateOutputPath)$(AntlrGenCodeFileNames);">
+
+    <ItemGroup>
+      <AntlrGeneratedCodeFiles Remove="@(AntlrGeneratedCodeFiles)" />
+    </ItemGroup>
+
+    <PropertyGroup>
+      <_IntellisenseOnlyCompile>false</_IntellisenseOnlyCompile>
+      <_IntellisenseOnlyCompile Condition="'$(BuildingProject)' != 'true'">true</_IntellisenseOnlyCompile>
+    </PropertyGroup>
+    <AntlrClassGenerationTask
+      AntlrToolPath="$(AntlrToolLocation)"
+      BuildTaskPath="$(AntlrBuildTaskLocation)"
+      OutputPath="$(IntermediateOutputPath)"
+      Language="$(Language)"
+      SourceCodeFiles="@(Antlr3)"
+      ContinueOnError="$(_IntellisenseOnlyCompile)"
+      TokensFiles="@(AntlrTokens)"
+      AbstractGrammarFiles="@(AntlrAbstractGrammar)">
+
+      <Output ItemName="AntlrGeneratedCodeFiles" TaskParameter="GeneratedCodeFiles" />
+      <Output ItemName="Compile" TaskParameter="GeneratedCodeFiles" />
+    </AntlrClassGenerationTask>
+
+    <WriteLinesToFile
+      Condition="'$(_IntellisenseOnlyCompile)' != 'true'"
+      File="$(IntermediateOutputPath)$(AntlrGenCodeFileNames)"
+      Lines="@(AntlrGeneratedCodeFiles)"
+      Overwrite="true"/>
+  </Target>
+
+  <Target Name="AntlrCompileAddFilesGenerated"
+          DependsOnTargets="AntlrCompile"
+          Condition="'@(Antlr3)' != ''">
+
+    <ItemGroup>
+      <Compile Condition="'@(AntlrGeneratedCodeFiles)' == ''" Include="@(AntlrOutputCodeFilesList)" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <_AntlrCodeGenFileWrites Condition="'@(AntlrGeneratedCodeFiles)' != ''" Include="@(AntlrGeneratedCodeFiles)" />
+      <_AntlrCodeGenFileWrites Condition="'@(AntlrGeneratedCodeFiles)' == ''" Include="@(AntlrOutputCodeFilesList)" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <FileWrites Include="@(_AntlrCodeGenFileWrites);
+                           $(IntermediateOutputPath)$(AntlrGenCodeFileNames);" />
+    </ItemGroup>
+
+  </Target>
+</Project>
diff --git a/packages/Antlr34.3.4.19004.1/tools/Antlr4.StringTemplate.Visualizer.dll b/packages/Antlr34.3.4.19004.1/tools/Antlr4.StringTemplate.Visualizer.dll
new file mode 100644
index 0000000..ba49dbc
Binary files /dev/null and b/packages/Antlr34.3.4.19004.1/tools/Antlr4.StringTemplate.Visualizer.dll differ
diff --git a/packages/Antlr34.3.4.19004.1/tools/Antlr4.StringTemplate.dll b/packages/Antlr34.3.4.19004.1/tools/Antlr4.StringTemplate.dll
new file mode 100644
index 0000000..e24622e
Binary files /dev/null and b/packages/Antlr34.3.4.19004.1/tools/Antlr4.StringTemplate.dll differ
diff --git a/packages/Antlr34.3.4.19004.1/tools/AntlrBuildTask.dll b/packages/Antlr34.3.4.19004.1/tools/AntlrBuildTask.dll
new file mode 100644
index 0000000..7be3707
Binary files /dev/null and b/packages/Antlr34.3.4.19004.1/tools/AntlrBuildTask.dll differ
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/AST.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/AST.stg
new file mode 100644
index 0000000..a898b69
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/AST.stg
@@ -0,0 +1,430 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2007-2008 Johannes Luber
+ * Copyright (c) 2005-2007 Kunle Odutola
+ * Copyright (c) 2011 Sam Harwell
+ * Copyright (c) 2011 Terence Parr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+@outputFile.imports() ::= <<
+<@super.imports()>
+
+<if(!TREE_PARSER)>
+<! tree parser would already have imported !>
+using Antlr.Runtime.Tree;
+using RewriteRuleITokenStream = Antlr.Runtime.Tree.RewriteRuleTokenStream;
+<endif>
+>>
+
+@genericParser.members() ::= <<
+<@super.members()>
+<parserMembers()>
+>>
+
+parserCtorBody() ::= <%
+<super.parserCtorBody()><\n>
+TreeAdaptor = 
+<if(actions.(actionScope).treeAdaptorInitializer)>
+	<actions.(actionScope).treeAdaptorInitializer>
+<else>
+	new <actions.(actionScope).treeAdaptorType; null="CommonTreeAdaptor">()
+<end>
+;
+%>
+
+/** Add an adaptor property that knows how to build trees */
+parserMembers() ::= <<
+private <treeAdaptorType()> adaptor;
+
+public <treeAdaptorType()> TreeAdaptor
+{
+	get
+	{
+		return adaptor;
+	}
+
+	set
+	{
+		this.adaptor = value;
+		<grammar.directDelegates:{g|<g:delegateName()>.TreeAdaptor = this.adaptor;}>
+	}
+}
+>>
+
+treeAdaptorType() ::= <<
+<actions.(actionScope).treeAdaptorType; null="ITreeAdaptor">
+>>
+
+ruleReturnBaseType() ::= <%
+Ast<if(TREE_PARSER)>Tree<else>Parser<endif>RuleReturnScope\<<ASTLabelType>, <labelType>>
+%>
+
+/** Add a variable to track rule's return AST */
+ruleDeclarations() ::= <<
+<super.ruleDeclarations()>
+<ASTLabelType> root_0 = default(<ASTLabelType>);<\n>
+>>
+
+ruleLabelDefs() ::= <<
+<super.ruleLabelDefs()>
+<[ruleDescriptor.tokenLabels,ruleDescriptor.wildcardTreeLabels,ruleDescriptor.wildcardTreeListLabels]
+	:{it|<ASTLabelType> <it.label.text>_tree = default(<ASTLabelType>);}; separator="\n">
+<ruleDescriptor.tokenListLabels:{it|<ASTLabelType> <it.label.text>_tree = default(<ASTLabelType>);}; separator="\n">
+<ruleDescriptor.allTokenRefsInAltsWithRewrites
+	:{it|RewriteRule<rewriteElementType>Stream stream_<it>=new RewriteRule<rewriteElementType>Stream(adaptor,"token <it>");}; separator="\n">
+<ruleDescriptor.allRuleRefsInAltsWithRewrites
+	:{it|RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"rule <it>");}; separator="\n">
+>>
+
+/** When doing auto AST construction, we must define some variables;
+ *  These should be turned off if doing rewrites.  This must be a "mode"
+ *  as a rule could have both rewrite and AST within the same alternative
+ *  block.
+ */
+@alt.declarations() ::= <<
+<if(autoAST)>
+<if(outerAlt)>
+<if(!rewriteMode)>
+root_0 = (<ASTLabelType>)adaptor.Nil();
+<endif>
+<endif>
+<endif>
+>>
+
+// T r a c k i n g  R u l e  E l e m e n t s
+
+/** ID and track it for use in a rewrite rule */
+tokenRefTrack(token,label,elementIndex,terminalOptions) ::= <<
+<tokenRefBang(...)> <! Track implies no auto AST construction!>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>stream_<token>.Add(<label>);<\n>
+>>
+
+/** ids+=ID and track it for use in a rewrite rule; adds to ids *and*
+ *  to the tracking list stream_ID for use in the rewrite.
+ */
+tokenRefTrackAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<tokenRefTrack(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** ^(ID ...) track for rewrite */
+tokenRefRuleRootTrack(token,label,elementIndex,terminalOptions) ::= <<
+<tokenRefBang(...)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>stream_<token>.Add(<label>);
+>>
+
+/** Match ^(label+=TOKEN ...) track for rewrite */
+tokenRefRuleRootTrackAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<tokenRefRuleRootTrack(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** rule when output=AST and tracking for rewrite */
+ruleRefTrack(rule,label,elementIndex,args,scope) ::= <<
+<super.ruleRef(...)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>stream_<rule.name>.Add(<label>.Tree);
+>>
+
+/** x+=rule when output=AST and tracking for rewrite */
+ruleRefTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefTrack(...)>
+<listLabelElem(elem={<label>.Tree},elemType=ASTLabelType,...)>
+>>
+
+/** ^(rule ...) rewrite */
+ruleRefRuleRootTrack(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefRuleRoot(...)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>stream_<rule>.Add(<label>.Tree);
+>>
+
+/** ^(x+=rule ...) rewrite */
+ruleRefRuleRootTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefRuleRootTrack(...)>
+<listLabelElem(elem={<label>.Tree},elemType=ASTLabelType,...)>
+>>
+
+// R e w r i t e
+
+rewriteCode(
+	alts, description,
+	referencedElementsDeep, // ALL referenced elements to right of ->
+	referencedTokenLabels,
+	referencedTokenListLabels,
+	referencedRuleLabels,
+	referencedRuleListLabels,
+	referencedWildcardLabels,
+	referencedWildcardListLabels,
+	rewriteBlockLevel, enclosingTreeLevel, treeLevel) ::= <<
+<\n>{
+// AST REWRITE
+// elements: <referencedElementsDeep; separator=", ">
+// token labels: <referencedTokenLabels; separator=", ">
+// rule labels: <referencedRuleLabels; separator=", ">
+// token list labels: <referencedTokenListLabels; separator=", ">
+// rule list labels: <referencedRuleListLabels; separator=", ">
+// wildcard labels: <[referencedWildcardLabels,referencedWildcardListLabels]; separator=", ">
+<if(backtracking)>
+if (<actions.(actionScope).synpredgate>) {
+<endif>
+<prevRuleRootRef()>.Tree = root_0;
+<rewriteCodeLabels()>
+root_0 = (<ASTLabelType>)adaptor.Nil();
+<alts:rewriteAlt(); separator="else ">
+<! if tree parser and rewrite=true !>
+<if(TREE_PARSER&&rewriteMode)>
+<prevRuleRootRef()>.Tree = (<ASTLabelType>)adaptor.RulePostProcessing(root_0);
+if (<prevRuleRootRef()>.Tree != null)
+	input.ReplaceChildren(adaptor.GetParent(retval.Start), adaptor.GetChildIndex(retval.Start), adaptor.GetChildIndex(_last), retval.Tree);
+<endif>
+<! if parser or tree-parser && rewrite!=true, we need to set result !>
+<if(!TREE_PARSER||!rewriteMode)>
+<prevRuleRootRef()>.Tree = root_0;
+<endif>
+<if(backtracking)>
+}
+<endif>
+}
+
+>>
+
+rewriteCodeLabels() ::= <<
+<referencedTokenLabels
+    :{it|RewriteRule<rewriteElementType>Stream stream_<it>=new RewriteRule<rewriteElementType>Stream(adaptor,"token <it>",<it>);};
+    separator="\n"
+>
+<referencedTokenListLabels
+    :{it|RewriteRule<rewriteElementType>Stream stream_<it>=new RewriteRule<rewriteElementType>Stream(adaptor,"token <it>", list_<it>);};
+    separator="\n"
+>
+<referencedWildcardLabels
+	:{it|RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"wildcard <it>",<it>);};
+	separator="\n"
+>
+<referencedWildcardListLabels
+	:{it|RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"wildcard <it>",list_<it>);};
+	separator="\n"
+>
+<referencedRuleLabels
+    :{it|RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"rule <it>",<it>!=null?<it>.Tree:null);};
+    separator="\n"
+>
+<referencedRuleListLabels
+    :{it|RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"token <it>",list_<it>);};
+    separator="\n"
+>
+>>
+
+/** Generate code for an optional rewrite block; note it uses the deep ref'd element
+  *  list rather shallow like other blocks.
+  */
+rewriteOptionalBlock(
+	alt,rewriteBlockLevel,
+	referencedElementsDeep, // all nested refs
+	referencedElements, // elements in immediately block; no nested blocks
+	description) ::=
+<<
+// <fileName>:<description>
+if (<referencedElementsDeep:{el | stream_<el>.HasNext}; separator="||">)
+{
+	<alt>
+}
+<referencedElementsDeep:{el | stream_<el>.Reset();<\n>}>
+>>
+
+rewriteClosureBlock(
+	alt,rewriteBlockLevel,
+	referencedElementsDeep, // all nested refs
+	referencedElements, // elements in immediately block; no nested blocks
+	description) ::=
+<<
+// <fileName>:<description>
+while ( <referencedElements:{el | stream_<el>.HasNext}; separator="||"> )
+{
+	<alt>
+}
+<referencedElements:{el | stream_<el>.Reset();<\n>}>
+>>
+
+rewritePositiveClosureBlock(
+	alt,rewriteBlockLevel,
+	referencedElementsDeep, // all nested refs
+	referencedElements, // elements in immediately block; no nested blocks
+	description) ::=
+<<
+if (!(<referencedElements:{el | stream_<el>.HasNext}; separator="||">))
+{
+	throw new RewriteEarlyExitException();
+}
+while ( <referencedElements:{el | stream_<el>.HasNext}; separator="||"> )
+{
+	<alt>
+}
+<referencedElements:{el | stream_<el>.Reset();<\n>}>
+>>
+
+rewriteAlt(a) ::= <<
+// <a.description>
+<if(a.pred)>
+if (<a.pred>)
+{
+	<a.alt>
+}
+<else>
+{
+	<a.alt>
+}
+<endif>
+>>
+
+/** For empty rewrites: "r : ... -> ;" */
+rewriteEmptyAlt() ::= "root_0 = null;"
+
+rewriteTree(root,children,description,enclosingTreeLevel,treeLevel) ::= <<
+// <fileName>:<description>
+{
+<ASTLabelType> root_<treeLevel> = (<ASTLabelType>)adaptor.Nil();
+<root:rewriteElement()>
+<children:rewriteElement()>
+adaptor.AddChild(root_<enclosingTreeLevel>, root_<treeLevel>);
+}<\n>
+>>
+
+rewriteElementList(elements) ::= "<elements:rewriteElement()>"
+
+rewriteElement(e) ::= <%
+<@pregen()>
+DebugLocation(<e.line>, <e.pos>);<\n>
+<e.el>
+%>
+
+/** Gen ID or ID[args] */
+rewriteTokenRef(token,elementIndex,terminalOptions,args) ::= <<
+adaptor.AddChild(root_<treeLevel>, <createRewriteNodeFromElement(...)>);<\n>
+>>
+
+/** Gen $label ... where defined via label=ID */
+rewriteTokenLabelRef(label,elementIndex) ::= <<
+adaptor.AddChild(root_<treeLevel>, stream_<label>.NextNode());<\n>
+>>
+
+/** Gen $label ... where defined via label+=ID */
+rewriteTokenListLabelRef(label,elementIndex) ::= <<
+adaptor.AddChild(root_<treeLevel>, stream_<label>.NextNode());<\n>
+>>
+
+/** Gen ^($label ...) */
+rewriteTokenLabelRefRoot(label,elementIndex) ::= <<
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(stream_<label>.NextNode(), root_<treeLevel>);<\n>
+>>
+
+/** Gen ^($label ...) where label+=... */
+rewriteTokenListLabelRefRoot ::= rewriteTokenLabelRefRoot
+
+/** Gen ^(ID ...) or ^(ID[args] ...) */
+rewriteTokenRefRoot(token,elementIndex,terminalOptions,args) ::= <<
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<createRewriteNodeFromElement(...)>, root_<treeLevel>);<\n>
+>>
+
+rewriteImaginaryTokenRef(args,token,terminalOptions,elementIndex) ::= <<
+adaptor.AddChild(root_<treeLevel>, <createImaginaryNode(tokenType=token, ...)>);<\n>
+>>
+
+rewriteImaginaryTokenRefRoot(args,token,terminalOptions,elementIndex) ::= <<
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<createImaginaryNode(tokenType=token, ...)>, root_<treeLevel>);<\n>
+>>
+
+/** plain -> {foo} action */
+rewriteAction(action) ::= <<
+root_0 = <action>;<\n>
+>>
+
+/** What is the name of the previous value of this rule's root tree?  This
+ *  let's us refer to $rule to mean previous value.  I am reusing the
+ *  variable 'tree' sitting in retval struct to hold the value of root_0 right
+ *  before I set it during rewrites.  The assign will be to retval.tree.
+ */
+prevRuleRootRef() ::= "retval"
+
+rewriteRuleRef(rule) ::= <<
+adaptor.AddChild(root_<treeLevel>, stream_<rule>.NextTree());<\n>
+>>
+
+rewriteRuleRefRoot(rule) ::= <<
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(stream_<rule>.NextNode(), root_<treeLevel>);<\n>
+>>
+
+rewriteNodeAction(action) ::= <<
+adaptor.AddChild(root_<treeLevel>, <action>);<\n>
+>>
+
+rewriteNodeActionRoot(action) ::= <<
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<action>, root_<treeLevel>);<\n>
+>>
+
+/** Gen $ruleLabel ... where defined via ruleLabel=rule */
+rewriteRuleLabelRef(label) ::= <<
+adaptor.AddChild(root_<treeLevel>, stream_<label>.NextTree());<\n>
+>>
+
+/** Gen $ruleLabel ... where defined via ruleLabel+=rule */
+rewriteRuleListLabelRef(label) ::= <<
+adaptor.AddChild(root_<treeLevel>, stream_<label>.NextTree());<\n>
+>>
+
+/** Gen ^($ruleLabel ...) where ruleLabel=rule */
+rewriteRuleLabelRefRoot(label) ::= <<
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(stream_<label>.NextNode(), root_<treeLevel>);<\n>
+>>
+
+/** Gen ^($ruleLabel ...) where ruleLabel+=rule */
+rewriteRuleListLabelRefRoot(label) ::= <<
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(stream_<label>.NextNode(), root_<treeLevel>);<\n>
+>>
+
+rewriteWildcardLabelRef(label) ::= <<
+adaptor.AddChild(root_<treeLevel>, stream_<label>.NextTree());<\n>
+>>
+
+createImaginaryNode(tokenType,terminalOptions,args) ::= <%
+<if(terminalOptions.node)>
+<! new MethodNode(IDLabel, args) !>
+new <terminalOptions.node>(<tokenType><if(args)>, <args; separator=", "><endif>)
+<else>
+(<ASTLabelType>)adaptor.Create(<tokenType>, <args; separator=", "><if(!args)>"<tokenType>"<endif>)
+<endif>
+%>
+
+createRewriteNodeFromElement(token,terminalOptions,args) ::= <%
+<if(terminalOptions.node)>
+new <terminalOptions.node>(stream_<token>.NextToken()<if(args)>, <args; separator=", "><endif>)
+<else>
+<if(args)> <! must create new node from old !>
+adaptor.Create(<token>, <args; separator=", ">)
+<else>
+stream_<token>.NextNode()
+<endif>
+<endif>
+%>
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTDbg.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTDbg.stg
new file mode 100644
index 0000000..0d2a441
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTDbg.stg
@@ -0,0 +1,94 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2007-2008 Johannes Luber
+ * Copyright (c) 2005-2007 Kunle Odutola
+ * Copyright (c) 2005 Terence Parr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** Template overrides to add debugging to AST stuff.  Dynamic inheritance
+ *  hierarchy is set up as ASTDbg : AST : Dbg : Java by code generator.
+ */
+
+parserMembers() ::= <<
+protected DebugTreeAdaptor adaptor;
+
+public ITreeAdaptor TreeAdaptor
+{
+	get
+	{
+		return adaptor;
+	}
+	set
+	{
+<if(grammar.grammarIsRoot)>
+		this.adaptor = new DebugTreeAdaptor(dbg,adaptor);
+<else>
+		this.adaptor = (DebugTreeAdaptor)adaptor; // delegator sends dbg adaptor
+<endif><\n>
+		<grammar.directDelegates:{g|<g:delegateName()>.TreeAdaptor = this.adaptor;}>
+	}
+}<\n>
+>>
+
+parserCtorBody() ::= <<
+<super.parserCtorBody()>
+>>
+
+createListenerAndHandshake() ::= <<
+DebugEventSocketProxy proxy = new DebugEventSocketProxy( this, port, <if(TREE_PARSER)>input.TreeAdaptor<else>adaptor<endif> );
+DebugListener = proxy;
+<inputStreamType> = new Debug<inputStreamType>( input, proxy );
+try
+{
+	proxy.Handshake();
+}
+catch ( IOException ioe )
+{
+	ReportError( ioe );
+}
+>>
+
+@ctorForRootGrammar.finally() ::= <<
+ITreeAdaptor adap = new CommonTreeAdaptor();
+TreeAdaptor = adap;
+proxy.TreeAdaptor = adap;
+>>
+
+@ctorForProfilingRootGrammar.finally() ::=<<
+ITreeAdaptor adap = new CommonTreeAdaptor();
+TreeAdaptor = adap;
+>>
+
+@ctorForPredefinedListener.superClassRef() ::= ": base( input, dbg )"
+
+@ctorForPredefinedListener.finally() ::=<<
+<if(grammar.grammarIsRoot)><! don't create new adaptor for delegates !>
+ITreeAdaptor adap = new CommonTreeAdaptor();
+TreeAdaptor = adap;<\n>
+<endif>
+>>
+
+//@rewriteElement.pregen() ::= "dbg.Location( <e.line>, <e.pos> );"
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTParser.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTParser.stg
new file mode 100644
index 0000000..6413dfe
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTParser.stg
@@ -0,0 +1,192 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2007-2008 Johannes Luber
+ * Copyright (c) 2005-2007 Kunle Odutola
+ * Copyright (c) 2011 Sam Harwell
+ * Copyright (c) 2011 Terence Parr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** Templates for building ASTs during normal parsing.
+ *
+ *  Deal with many combinations.  Dimensions are:
+ *  Auto build or rewrite
+ *    no label, label, list label  (label/no-label handled together)
+ *    child, root
+ *    token, set, rule, wildcard
+ *
+ *  The situation is not too bad as rewrite (->) usage makes ^ and !
+ *  invalid. There is no huge explosion of combinations.
+ */
+
+@rule.setErrorReturnValue() ::= <<
+retval.Tree = (<ASTLabelType>)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
+<! System.out.WriteLine("<ruleName> returns "+((CommonTree)retval.tree).toStringTree()); !>
+>>
+
+// TOKEN AST STUFF
+
+/** ID and output=AST */
+tokenRef(token,label,elementIndex,terminalOptions) ::= <<
+<super.tokenRef(...)>
+<if(backtracking)>if (state.backtracking == 0) {<endif>
+<label>_tree = <createNodeFromToken(...)>;
+adaptor.AddChild(root_0, <label>_tree);
+<if(backtracking)>}<endif>
+>>
+
+/** ID! and output=AST (same as plain tokenRef) */
+tokenRefBang(token,label,elementIndex) ::= "<super.tokenRef(...)>"
+
+/** ID^ and output=AST */
+tokenRefRuleRoot(token,label,elementIndex,terminalOptions) ::= <<
+<super.tokenRef(...)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<label>_tree = <createNodeFromToken(...)>;
+root_0 = (<ASTLabelType>)adaptor.BecomeRoot(<label>_tree, root_0);
+<if(backtracking)>}<endif>
+>>
+
+/** ids+=ID! and output=AST */
+tokenRefBangAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<tokenRefBang(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** label+=TOKEN when output=AST but not rewrite alt */
+tokenRefAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<tokenRef(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** Match label+=TOKEN^ when output=AST but not rewrite alt */
+tokenRefRuleRootAndListLabel(token,label,terminalOptions,elementIndex) ::= <<
+<tokenRefRuleRoot(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+// SET AST
+
+// the match set stuff is interesting in that it uses an argument list
+// to pass code to the default matchSet; another possible way to alter
+// inherited code.  I don't use the region stuff because I need to pass
+// different chunks depending on the operator.  I don't like making
+// the template name have the operator as the number of templates gets
+// large but this is the most flexible--this is as opposed to having
+// the code generator call matchSet then add root code or ruleroot code
+// plus list label plus ...  The combinations might require complicated
+// rather than just added on code.  Investigate that refactoring when
+// I have more time.
+
+matchSet(s,label,terminalOptions,elementIndex,postmatchCode) ::= <<
+<super.matchSet(postmatchCode={<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>adaptor.AddChild(root_0, <createNodeFromToken(...)>);}, ...)>
+>>
+
+matchRuleBlockSet(s,label,terminalOptions,elementIndex,postmatchCode,treeLevel="0") ::= <<
+<matchSet(...)>
+>>
+
+matchSetBang(s,label,elementIndex,terminalOptions,postmatchCode) ::= "<super.matchSet(...)>"
+
+// note there is no matchSetTrack because -> rewrites force sets to be
+// plain old blocks of alts: (A|B|...|C)
+
+matchSetRuleRoot(s,label,terminalOptions,elementIndex,debug) ::= <<
+<if(label)>
+<label>=(<labelType>)input.LT(1);
+<endif>
+<super.matchSet(postmatchCode={<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>root_0 = (<ASTLabelType>)adaptor.BecomeRoot(<createNodeFromToken(...)>, root_0);}, ...)>
+>>
+
+// RULE REF AST
+
+/** rule when output=AST */
+ruleRef(rule,label,elementIndex,args,scope) ::= <<
+<super.ruleRef(...)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>adaptor.AddChild(root_0, <label>.Tree);
+>>
+
+/** rule! is same as normal rule ref */
+ruleRefBang(rule,label,elementIndex,args,scope) ::= "<super.ruleRef(...)>"
+
+/** rule^ */
+ruleRefRuleRoot(rule,label,elementIndex,args,scope) ::= <<
+<super.ruleRef(...)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>root_0 = (<ASTLabelType>)adaptor.BecomeRoot(<label>.Tree, root_0);
+>>
+
+/** x+=rule when output=AST */
+ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRef(...)>
+<listLabelElem(elem={<label>.Tree},elemType=ASTLabelType,...)>
+>>
+
+/** x+=rule! when output=AST is a rule ref with list addition */
+ruleRefBangAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefBang(...)>
+<listLabelElem(elem={<label>.Tree},elemType=ASTLabelType,...)>
+>>
+
+/** x+=rule^ */
+ruleRefRuleRootAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefRuleRoot(...)>
+<listLabelElem(elem={<label>.Tree},elemType=ASTLabelType,...)>
+>>
+
+// WILDCARD AST
+
+wildcard(token,label,elementIndex,terminalOptions) ::= <<
+<super.wildcard(...)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<label>_tree = (<ASTLabelType>)adaptor.Create(<label>);
+adaptor.AddChild(root_0, <label>_tree);
+<if(backtracking)>}<endif>
+>>
+
+wildcardBang(label,elementIndex) ::= "<super.wildcard(...)>"
+
+wildcardRuleRoot(token,label,elementIndex,terminalOptions) ::= <<
+<super.wildcard(...)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<label>_tree = (<ASTLabelType>)adaptor.Create(<label>);
+root_0 = (<ASTLabelType>)adaptor.BecomeRoot(<label>_tree, root_0);
+<if(backtracking)>}<endif>
+>>
+
+createNodeFromToken(label,terminalOptions) ::= <%
+<if(terminalOptions.node)>
+new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>)
+<else>
+(<ASTLabelType>)adaptor.Create(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>)
+<endif>
+%>
+
+ruleCleanUp() ::= <<
+<super.ruleCleanUp()>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+retval.Tree = (<ASTLabelType>)adaptor.RulePostProcessing(root_0);
+adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+<if(backtracking)>}<endif>
+>>
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTTreeParser.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTTreeParser.stg
new file mode 100644
index 0000000..fc6df64
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ASTTreeParser.stg
@@ -0,0 +1,380 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2007-2008 Johannes Luber
+ * Copyright (c) 2005-2007 Kunle Odutola
+ * Copyright (c) 2011 Sam Harwell
+ * Copyright (c) 2011 Terence Parr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** Templates for building ASTs during tree parsing.
+ *
+ *  Deal with many combinations.  Dimensions are:
+ *  Auto build or rewrite
+ *    no label, label, list label  (label/no-label handled together)
+ *    child, root
+ *    token, set, rule, wildcard
+ *
+ *  Each combination has its own template except that label/no label
+ *  is combined into tokenRef, ruleRef, ...
+ */
+
+/** Add a variable to track last element matched */
+ruleDeclarations() ::= <<
+<super.ruleDeclarations()>
+<if(!ruleDescriptor.isSynPred)>
+<ASTLabelType> _first_0 = default(<ASTLabelType>);
+<ASTLabelType> _last = default(<ASTLabelType>);
+<endif>
+>>
+
+/** What to emit when there is no rewrite rule.  For auto build
+ *  mode, does nothing.
+ */
+noRewrite(rewriteBlockLevel, treeLevel) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<if(rewriteMode)>
+retval.Tree = (<ASTLabelType>)_first_0;
+if (adaptor.GetParent(retval.Tree)!=null && adaptor.IsNil(adaptor.GetParent(retval.Tree)))
+    retval.Tree = (<ASTLabelType>)adaptor.GetParent(retval.Tree);
+<endif>
+<if(backtracking)>}<endif>
+<endif>
+>>
+
+/** match ^(root children) in tree parser; override here to
+ *  add tree construction actions.
+ */
+tree(root, actionsAfterRoot, children, nullableChildList,
+     enclosingTreeLevel, treeLevel) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+{
+<ASTLabelType> _save_last_<treeLevel> = _last;
+<ASTLabelType> _first_<treeLevel> = default(<ASTLabelType>);
+<if(!rewriteMode)>
+<ASTLabelType> root_<treeLevel> = (<ASTLabelType>)adaptor.Nil();
+<endif>
+<root:element()>
+<if(rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>)<endif>
+<if(root.el.rule)>
+if (_first_<enclosingTreeLevel> == null) _first_<enclosingTreeLevel> = <root.el.label>.Tree;
+<else>
+if (_first_<enclosingTreeLevel> == null) _first_<enclosingTreeLevel> = <root.el.label>;
+<endif>
+<endif>
+<actionsAfterRoot:element()>
+<if(nullableChildList)>
+if (input.LA(1) == TokenTypes.Down) {
+    Match(input, TokenTypes.Down, null); <checkRuleBacktrackFailure()>
+    <children:element()>
+    Match(input, TokenTypes.Up, null); <checkRuleBacktrackFailure()>
+}
+<else>
+Match(input, TokenTypes.Down, null); <checkRuleBacktrackFailure()>
+<children:element()>
+Match(input, TokenTypes.Up, null); <checkRuleBacktrackFailure()>
+<endif>
+<if(!rewriteMode)>
+adaptor.AddChild(root_<enclosingTreeLevel>, root_<treeLevel>);
+<endif>
+_last = _save_last_<treeLevel>;
+}
+<else>
+<super.tree(...)>
+<endif>
+>>
+
+// TOKEN AST STUFF
+
+/** ID! and output=AST (same as plain tokenRef) 'cept add
+ *  setting of _last
+ */
+tokenRefBang(token,label,elementIndex,terminalOptions) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.tokenRef(...)>
+<else>
+<super.tokenRefBang(...)>
+<endif>
+>>
+
+/** ID auto construct */
+tokenRef(token,label,elementIndex,terminalOptions) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.tokenRef(...)>
+<if(!rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<if(terminalOptions.node)>
+<label>_tree = new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<else>
+<label>_tree = (<ASTLabelType>)adaptor.DupNode(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<endif><\n>
+adaptor.AddChild(root_<treeLevel>, <label>_tree);
+<if(backtracking)>}<endif>
+<else> <! rewrite mode !>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>)<endif>
+if (_first_<treeLevel> == null) _first_<treeLevel> = <label>;
+<endif>
+<else>
+<super.tokenRef(...)>
+<endif>
+>>
+
+/** label+=TOKEN auto construct */
+tokenRefAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<tokenRef(...)>
+<listLabelElem(elem=label,...)>
+<else>
+<super.tokenRefAndListLabel(...)>
+<endif>
+>>
+
+/** ^(ID ...) auto construct */
+tokenRefRuleRoot(token,label,elementIndex,terminalOptions) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.tokenRef(...)>
+<if(!rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<if(terminalOptions.node)>
+<label>_tree = new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<else>
+<label>_tree = (<ASTLabelType>)adaptor.DupNode(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<endif><\n>
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<label>_tree, root_<treeLevel>);
+<if(backtracking)>}<endif>
+<endif>
+<else>
+<super.tokenRefRuleRoot(...)>
+<endif>
+>>
+
+/** Match ^(label+=TOKEN ...) auto construct */
+tokenRefRuleRootAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<tokenRefRuleRoot(...)>
+<listLabelElem(elem=label,...)>
+<else>
+<super.tokenRefRuleRootAndListLabel(...)>
+<endif>
+>>
+
+/** Match . wildcard and auto dup the node/subtree */
+wildcard(token,label,elementIndex,terminalOptions) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.wildcard(...)>
+<if(!rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<label>_tree = (<ASTLabelType>)adaptor.DupTree(<label>);
+adaptor.AddChild(root_<treeLevel>, <label>_tree);
+<if(backtracking)>}<endif>
+<else> <! rewrite mode !>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>)<endif>
+if (_first_<treeLevel> == null) _first_<treeLevel> = <label>;
+<endif>
+<else>
+<super.wildcard(...)>
+<endif>
+>>
+
+// SET AST
+
+matchSet(s,label,terminalOptions,elementIndex,postmatchCode) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.matchSet(postmatchCode={
+<if(!rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<if(terminalOptions.node)>
+<label>_tree = new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<else>
+<label>_tree = (<ASTLabelType>)adaptor.DupNode(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<endif><\n>
+adaptor.AddChild(root_<treeLevel>, <label>_tree);
+<if(backtracking)>\}<endif>
+<endif>
+}, ...
+)>
+<else>
+<super.matchSet(...)>
+<endif>
+>>
+
+matchRuleBlockSet(s,label,terminalOptions,elementIndex,postmatchCode,treeLevel="0") ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<matchSet(...)>
+<noRewrite(...)> <! set return tree !>
+<else>
+<super.matchRuleBlockSet(...)>
+<endif>
+>>
+
+matchSetBang(s,label,terminalOptions,elementIndex,postmatchCode) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.matchSet(...)>
+<else>
+<super.matchSetBang(...)>
+<endif>
+>>
+
+matchSetRuleRoot(s,label,terminalOptions,elementIndex,debug) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<super.matchSet(postmatchCode={
+<if(!rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<if(terminalOptions.node)>
+<label>_tree = new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<else>
+<label>_tree = (<ASTLabelType>)adaptor.DupNode(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<endif><\n>
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<label>_tree, root_<treeLevel>);
+<if(backtracking)>\}<endif>
+<endif>
+}, ...
+)>
+<else>
+<super.matchSetRuleRoot(...)>
+<endif>
+>>
+
+// RULE REF AST
+
+/** rule auto construct */
+ruleRef(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.ruleRef(...)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>)<endif>
+<if(!rewriteMode)>
+adaptor.AddChild(root_<treeLevel>, <label>.Tree);
+<else> <! rewrite mode !>
+if (_first_<treeLevel> == null) _first_<treeLevel> = <label>.Tree;
+<endif>
+<else>
+<super.ruleRef(...)>
+<endif>
+>>
+
+/** x+=rule auto construct */
+ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<ruleRef(...)>
+<listLabelElem(elem={<label>.Tree},...)>
+<else>
+<super.ruleRefAndListLabel(...)>
+<endif>
+>>
+
+/** ^(rule ...) auto construct */
+ruleRefRuleRoot(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.ruleRef(...)>
+<if(!rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<label>.Tree, root_<treeLevel>);
+<endif>
+<else>
+<super.ruleRefRuleRoot(...)>
+<endif>
+>>
+
+/** ^(x+=rule ...) auto construct */
+ruleRefRuleRootAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<ruleRefRuleRoot(...)>
+<listLabelElem(elem={<label>.Tree},...)>
+<else>
+<super.ruleRefRuleRootAndListLabel(...)>
+<endif>
+>>
+
+/** rule when output=AST and tracking for rewrite */
+ruleRefTrack(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.ruleRefTrack(...)>
+<else>
+<super.ruleRefTrack(...)>
+<endif>
+>>
+
+/** x+=rule when output=AST and tracking for rewrite */
+ruleRefTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.ruleRefTrackAndListLabel(...)>
+<else>
+<super.ruleRefTrackAndListLabel(...)>
+<endif>
+>>
+
+/** ^(rule ...) rewrite */
+ruleRefRuleRootTrack(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.ruleRefRootTrack(...)>
+<else>
+<super.ruleRefRuleRootTrack(...)>
+<endif>
+>>
+
+/** ^(x+=rule ...) rewrite */
+ruleRefRuleRootTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.ruleRefRuleRootTrackAndListLabel(...)>
+<else>
+<super.ruleRefRuleRootTrackAndListLabel(...)>
+<endif>
+>>
+
+/** Streams for token refs are tree nodes now; override to
+ *  change NextToken to NextNode.
+ */
+createRewriteNodeFromElement(token,terminalOptions,args) ::= <%
+<if(terminalOptions.node)>
+new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif>stream_<token>.NextNode())
+<else>
+stream_<token>.NextNode()
+<endif>
+%>
+
+ruleCleanUp() ::= <<
+<super.ruleCleanUp()>
+<if(!ruleDescriptor.isSynPred)>
+<if(!rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+retval.Tree = (<ASTLabelType>)adaptor.RulePostProcessing(root_0);
+<if(backtracking)>}<endif>
+<endif>
+<endif>
+>>
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/CSharp2.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/CSharp2.stg
new file mode 100644
index 0000000..c5e1fd8
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/CSharp2.stg
@@ -0,0 +1,1765 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2007-2008 Johannes Luber
+ * Copyright (c) 2005-2007 Kunle Odutola
+ * Copyright (c) 2011 Sam Harwell
+ * Copyright (c) 2011 Terence Parr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+csharpVisibilityMap ::= [
+	"private":"private",
+	"protected":"protected",
+	"public":"public",
+	"fragment":"private",
+	default:"private"
+]
+
+/** The overall file structure of a recognizer; stores methods for rules
+ *  and cyclic DFAs plus support code.
+ */
+outputFile(	LEXER,PARSER,TREE_PARSER, actionScope, actions,
+			docComment, recognizer,
+			name, tokens, tokenNames, rules, cyclicDFAs,
+			bitsets, buildTemplate, buildAST, rewriteMode, profile,
+			backtracking, synpreds, memoize, numRules,
+			fileName, ANTLRVersion, generatedTimestamp, trace,
+			scopes, superClass, literals) ::=
+<<
+//------------------------------------------------------------------------------
+// \<auto-generated>
+//     This code was generated by a tool.
+//     ANTLR Version: <ANTLRVersion>
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// \</auto-generated>
+//------------------------------------------------------------------------------
+
+// $ANTLR <ANTLRVersion> <fileName> <generatedTimestamp>
+
+<if(trace)>
+#define ANTLR_TRACE
+<endif>
+<@debugPreprocessor()>
+// The variable 'variable' is assigned but its value is never used.
+#pragma warning disable 168, 219
+// Unreachable code detected.
+#pragma warning disable 162
+// Missing XML comment for publicly visible type or member 'Type_or_Member'
+#pragma warning disable 1591
+
+<actions.(actionScope).header>
+
+<@imports>
+using System.Collections.Generic;
+using Antlr.Runtime;
+using Antlr.Runtime.Misc;
+<if(TREE_PARSER)>
+using Antlr.Runtime.Tree;
+using RewriteRuleITokenStream = Antlr.Runtime.Tree.RewriteRuleTokenStream;
+<endif>
+using ConditionalAttribute = System.Diagnostics.ConditionalAttribute;
+<@end>
+<if(actions.(actionScope).namespace)>
+namespace <actions.(actionScope).namespace>
+{
+<endif>
+<docComment>
+<recognizer>
+<if(actions.(actionScope).namespace)>
+
+} // namespace <actions.(actionScope).namespace>
+<endif>
+>>
+
+lexerInputStreamType() ::= <<
+<actions.(actionScope).inputStreamType; null="ICharStream">
+>>
+
+lexer(grammar, name, tokens, scopes, rules, numRules, filterMode, labelType="CommonToken",
+      superClass={<if(actions.(actionScope).superClass)><actions.(actionScope).superClass><else>Antlr.Runtime.Lexer<endif>}) ::= <<
+[System.CodeDom.Compiler.GeneratedCode("ANTLR", "<ANTLRVersion>")]
+[System.CLSCompliant(false)]
+<parserModifier(grammar=grammar, actions=actions)> partial class <grammar.recognizerName> : <@superClassName><superClass><@end>
+{
+	<tokens:{it|public const int <it.name; format="id">=<it.type>;}; separator="\n">
+	<scopes:{it|<if(it.isDynamicGlobalScope)><globalAttributeScope(scope=it)><endif>}>
+	<actions.lexer.members>
+
+    // delegates
+    <grammar.delegates:
+         {g|private <g.recognizerName> <g:delegateName()>;}; separator="\n">
+    // delegators
+    <grammar.delegators:
+         {g|private <g.recognizerName> <g:delegateName()>;}; separator="\n">
+    <last(grammar.delegators):{g|private <g.recognizerName> gParent;}>
+
+	<actions.(actionScope).ctorModifier; null="public"> <grammar.recognizerName>()<! needed by subclasses !>
+	{
+		OnCreated();
+	}
+
+	<actions.(actionScope).ctorModifier; null="public"> <grammar.recognizerName>(<lexerInputStreamType()> input<grammar.delegators:{g|, <g.recognizerName> <g:delegateName()>}> )
+		: this(input, new RecognizerSharedState()<grammar.delegators:{g|, <g:delegateName()>}>)
+	{
+	}
+
+	<actions.(actionScope).ctorModifier; null="public"> <grammar.recognizerName>(<lexerInputStreamType()> input, RecognizerSharedState state<grammar.delegators:{g|, <g.recognizerName> <g:delegateName()>}>)
+		: base(input, state)
+	{
+<if(memoize)>
+<if(grammar.grammarIsRoot)>
+		state.ruleMemo = new System.Collections.Generic.Dictionary\<int, int>[<numRules>+1];<\n><! index from 1..n !>
+<endif>
+<endif>
+		<grammar.directDelegates:
+		 {g|<g:delegateName()> = new <g.recognizerName>(input, this.state<trunc(g.delegators):{p|, <p:delegateName()>}>, this);}; separator="\n">
+		<grammar.delegators:
+		 {g|this.<g:delegateName()> = <g:delegateName()>;}; separator="\n">
+		<last(grammar.delegators):{g|gParent = <g:delegateName()>;}>
+
+		OnCreated();
+	}
+	public override string GrammarFileName { get { return "<fileName>"; } }
+
+	private static readonly bool[] decisionCanBacktrack = new bool[0];
+
+<if(grammar.hasDelegates)>
+	public override <lexerInputStreamType()> CharStream
+	{
+		get
+		{
+			return base.CharStream;
+		}
+		set
+		{
+			base.CharStream = value;
+			<grammar.directDelegates:
+			 {g|<g:delegateName()> = new <g.recognizerName>(input, state<trunc(g.delegators):{p|, <p:delegateName()>}>, this);}; separator="\n">
+			<grammar.delegators:
+			 {g|this.<g:delegateName()> = <g:delegateName()>;}; separator="\n">
+			<last(grammar.delegators):{g|gParent = <g:delegateName()>;}>
+		}
+	}
+
+<if(grammar.delegates)>
+	public override void SetState(RecognizerSharedState state)
+	{
+		base.SetState(state);
+		<grammar.delegates:{g|<g:delegateName()>.SetState(state);}; separator="\n">
+	}
+<endif>
+
+<endif>
+<if(filterMode)>
+	<filteringNextToken()>
+<endif>
+
+	[Conditional("ANTLR_TRACE")]
+	protected virtual void OnCreated() {}
+	[Conditional("ANTLR_TRACE")]
+	protected virtual void EnterRule(string ruleName, int ruleIndex) {}
+	[Conditional("ANTLR_TRACE")]
+	protected virtual void LeaveRule(string ruleName, int ruleIndex) {}
+
+    <rules; separator="\n">
+
+	<insertLexerSynpreds(synpreds)>
+
+	#region DFA
+	<cyclicDFAs:{dfa | DFA<dfa.decisionNumber> dfa<dfa.decisionNumber>;}; separator="\n">
+
+	protected override void InitDFAs()
+	{
+		base.InitDFAs();
+		<cyclicDFAs:{dfa | dfa<dfa.decisionNumber> = new DFA<dfa.decisionNumber>(this<if(dfa.specialStateSTs)>, SpecialStateTransition<dfa.decisionNumber><endif>);}; separator="\n">
+	}
+
+	<cyclicDFAs:cyclicDFA()> <! dump tables for all DFA !>
+	#endregion
+
+}
+>>
+
+/** A override of Lexer.nextToken() that backtracks over mTokens() looking
+ *  for matches.  No error can be generated upon error; just rewind, consume
+ *  a token and then try again.  backtracking needs to be set as well.
+ *  Make rule memoization happen only at levels above 1 as we start mTokens
+ *  at backtracking==1.
+ */
+filteringNextToken() ::= <<
+public override IToken NextToken()
+{
+	while (true)
+	{
+		if (input.LA(1) == CharStreamConstants.EndOfFile)
+		{
+			IToken eof = new CommonToken((ICharStream)input, CharStreamConstants.EndOfFile, TokenChannels.Default, input.Index, input.Index);
+			eof.Line = Line;
+			eof.CharPositionInLine = CharPositionInLine;
+			return eof;
+		}
+		state.token = null;
+		state.channel = TokenChannels.Default;
+		state.tokenStartCharIndex = input.Index;
+		state.tokenStartCharPositionInLine = input.CharPositionInLine;
+		state.tokenStartLine = input.Line;
+		state.text = null;
+		try
+		{
+			int m = input.Mark();
+			state.backtracking=1;<! means we won't throw slow exception !>
+			state.failed=false;
+			mTokens();
+			state.backtracking=0;
+			<! mTokens backtracks with synpred at backtracking==2
+			   and we set the synpredgate to allow actions at level 1. !>
+			if (state.failed)
+			{
+				input.Rewind(m);
+				input.Consume();<! advance one char and try again !>
+			}
+			else
+			{
+				Emit();
+				return state.token;
+			}
+		}
+		catch (RecognitionException re)
+		{
+			// shouldn't happen in backtracking mode, but...
+			ReportError(re);
+			Recover(re);
+		}
+	}
+}
+
+public override void Memoize(IIntStream input, int ruleIndex, int ruleStartIndex)
+{
+	if (state.backtracking > 1)
+		base.Memoize(input, ruleIndex, ruleStartIndex);
+}
+
+public override bool AlreadyParsedRule(IIntStream input, int ruleIndex)
+{
+	if (state.backtracking > 1)
+		return base.AlreadyParsedRule(input, ruleIndex);
+
+	return false;
+}
+>>
+
+actionGate() ::= "state.backtracking == 0"
+
+filteringActionGate() ::= "state.backtracking == 1"
+
+/** How to generate a parser */
+genericParser(grammar, name, scopes, tokens, tokenNames, rules, numRules,
+              bitsets, inputStreamType, superClass,
+              labelType, members, rewriteElementType,
+              filterMode, ASTLabelType="object") ::= <<
+[System.CodeDom.Compiler.GeneratedCode("ANTLR", "<ANTLRVersion>")]
+[System.CLSCompliant(false)]
+<parserModifier(grammar=grammar, actions=actions)> partial class <grammar.recognizerName> : <@superClassName><superClass><@end>
+{
+<if(grammar.grammarIsRoot)>
+	internal static readonly string[] tokenNames = new string[] {
+		"\<invalid>", "\<EOR>", "\<DOWN>", "\<UP>", <tokenNames; separator=", ">
+	};
+<endif>
+	<tokens:{it|public const int <it.name; format="id">=<it.type>;}; separator="\n">
+
+<if(grammar.delegates)>
+	// delegates
+	<grammar.delegates:
+		 {g|private <g.recognizerName> <g:delegateName()>;}; separator="\n">
+<endif>
+<if(grammar.delegators)>
+	// delegators
+	<grammar.delegators:
+		 {g|private <g.recognizerName> <g:delegateName()>;}; separator="\n">
+	<last(grammar.delegators):{g|private <g.recognizerName> gParent;}>
+<endif>
+
+<if(grammar.delegates)>
+	public override void SetState(RecognizerSharedState state)
+	{
+		base.SetState(state);
+		<grammar.delegates:{g|<g:delegateName()>.SetState(state);}; separator="\n">
+	}
+
+<if(TREE_PARSER)>
+	public override void SetTreeNodeStream(ITreeNodeStream input)
+	{
+		base.SetTreeNodeStream(input);
+		<grammar.delegates:{g|<g:delegateName()>.SetTreeNodeStream(input);}; separator="\n">
+	}
+<endif>
+<endif>
+
+	<scopes:{it|<if(it.isDynamicGlobalScope)><globalAttributeScope(scope=it)><endif>}>
+	<@members()>
+
+	public override string[] TokenNames { get { return <grammar.composite.rootGrammar.recognizerName>.tokenNames; } }
+	public override string GrammarFileName { get { return "<fileName>"; } }
+
+	<members>
+
+	[Conditional("ANTLR_TRACE")]
+	protected virtual void OnCreated() {}
+	[Conditional("ANTLR_TRACE")]
+	protected virtual void EnterRule(string ruleName, int ruleIndex) {}
+	[Conditional("ANTLR_TRACE")]
+	protected virtual void LeaveRule(string ruleName, int ruleIndex) {}
+
+	#region Rules
+	<rules; separator="\n">
+	#endregion Rules
+
+<if(grammar.delegatedRules)>
+<! generate rule/method definitions for imported rules so they
+   appear to be defined in this recognizer. !>
+	#region Delegated rules
+<grammar.delegatedRules:{ruleDescriptor|
+	<ruleModifier(grammar=grammar,ruleDescriptor=ruleDescriptor)> <returnType(ruleDescriptor)> <ruleDescriptor.name; format="id">(<ruleDescriptor.parameterScope:parameterScope()>) <!throws RecognitionException !>{ <if(ruleDescriptor.hasReturnValue)>return <endif><ruleDescriptor.grammar:delegateName()>.<ruleDescriptor.name; format="id">(<ruleDescriptor.parameterScope.attributes:{a|<a.name; format="id">}; separator=", ">); \}}; separator="\n">
+	#endregion Delegated rules
+<endif>
+
+	<insertSynpreds(synpreds)>
+
+<if(cyclicDFAs)>
+	#region DFA
+	<cyclicDFAs:{dfa | private DFA<dfa.decisionNumber> dfa<dfa.decisionNumber>;}; separator="\n">
+
+	protected override void InitDFAs()
+	{
+		base.InitDFAs();
+		<cyclicDFAs:{dfa | dfa<dfa.decisionNumber> = new DFA<dfa.decisionNumber>( this<if(dfa.specialStateSTs)>, SpecialStateTransition<dfa.decisionNumber><endif> );}; separator="\n">
+	}
+
+	<cyclicDFAs:cyclicDFA()><! dump tables for all DFA !>
+	#endregion DFA
+<endif>
+
+<if(bitsets)>
+	#region Follow sets
+	private static class Follow
+	{
+		<bitsets:{it|<bitset(name={_<it.name>_in_<it.inName><it.tokenIndex>}, words64=it.bits)>}; separator="\n">
+	}
+	#endregion Follow sets
+<endif>
+}
+>>
+
+@genericParser.members() ::= <<
+#if ANTLR_DEBUG
+	private static readonly bool[] decisionCanBacktrack =
+		new bool[]
+		{
+			false, // invalid decision
+			<grammar.decisions:{d | <d.dfa.hasSynPred>}; wrap="\n", separator=", ">
+		};
+#else
+	private static readonly bool[] decisionCanBacktrack = new bool[0];
+#endif
+<! WARNING. bug in ST: this is cut-n-paste into Dbg.stg !>
+<actions.(actionScope).ctorModifier; null="public"> <grammar.recognizerName>(<inputStreamType> input<grammar.delegators:{g|, <g.recognizerName> <g:delegateName()>}>)
+	: this(input, new RecognizerSharedState()<grammar.delegators:{g|, <g:delegateName()>}>)
+{
+}
+<actions.(actionScope).ctorModifier; null="public"> <grammar.recognizerName>(<inputStreamType> input, RecognizerSharedState state<grammar.delegators:{g|, <g.recognizerName> <g:delegateName()>}>)
+	: base(input, state)
+{
+<if(grammar.directDelegates)>
+	<grammar.directDelegates:
+	 {g|<g:delegateName()> = new <g.recognizerName>(input, state<trunc(g.delegators):{p|, <p:delegateName()>}>, this);}; separator="\n">
+<endif>
+<if(grammar.indirectDelegates)>
+	<grammar.indirectDelegates:{g | <g:delegateName()> = <g.delegator:delegateName()>.<g:delegateName()>;}; separator="\n">
+<endif>
+<if(grammar.delegators)>
+	<last(grammar.delegators):{g|gParent = <g:delegateName()>;}>
+<endif>
+	<parserCtorBody()>
+	OnCreated();
+}
+>>
+
+// imported grammars are 'public' (can't be internal because their return scope classes must be accessible)
+parserModifier(grammar, actions) ::= <<
+<if(grammar.grammarIsRoot)><actions.(actionScope).modifier; null="public"><else>public<endif>
+>>
+
+parserCtorBody() ::= <<
+<if(memoize)>
+<if(grammar.grammarIsRoot)>
+this.state.ruleMemo = new System.Collections.Generic.Dictionary\<int, int>[<length(grammar.allImportedRules)>+1];<\n><! index from 1..n !>
+<endif>
+<endif>
+<grammar.delegators:
+ {g|this.<g:delegateName()> = <g:delegateName()>;}; separator="\n">
+>>
+
+parser(grammar, name, scopes, tokens, tokenNames, rules, numRules, bitsets,
+       ASTLabelType="object", superClass={<if(actions.(actionScope).superClass)><actions.(actionScope).superClass><else>Antlr.Runtime.Parser<endif>}, labelType="IToken",
+       members={<actions.parser.members>}) ::= <<
+<genericParser(inputStreamType="ITokenStream", rewriteElementType="IToken", ...)>
+>>
+
+/** How to generate a tree parser; same as parser except the input
+ *  stream is a different type.
+ */
+treeParser(grammar, name, scopes, tokens, tokenNames, globalAction, rules,
+           numRules, bitsets, filterMode, labelType={<ASTLabelType>}, ASTLabelType="object",
+           superClass={<if(actions.(actionScope).superClass)><actions.(actionScope).superClass><else>Antlr.Runtime.Tree.<if(filterMode)><if(buildAST)>TreeRewriter<else>TreeFilter<endif><else>TreeParser<endif><endif>},
+           members={<actions.treeparser.members>}) ::= <<
+<genericParser(inputStreamType="ITreeNodeStream", rewriteElementType="Node", ...)>
+>>
+
+/** A simpler version of a rule template that is specific to the imaginary
+ *  rules created for syntactic predicates.  As they never have return values
+ *  nor parameters etc..., just give simplest possible method.  Don't do
+ *  any of the normal memoization stuff in here either; it's a waste.
+ *  As predicates cannot be inlined into the invoking rule, they need to
+ *  be in a rule by themselves.
+ */
+synpredRule(ruleName, ruleDescriptor, block, description, nakedBlock) ::=
+<<
+[Conditional("ANTLR_TRACE")]
+protected virtual void EnterRule_<ruleName>_fragment() {}
+[Conditional("ANTLR_TRACE")]
+protected virtual void LeaveRule_<ruleName>_fragment() {}
+
+// $ANTLR start <ruleName>
+public <!final !>void <ruleName>_fragment(<ruleDescriptor.parameterScope:parameterScope()>)
+{
+	<ruleLabelDefs()>
+	EnterRule_<ruleName>_fragment();
+	EnterRule("<ruleName>_fragment", <ruleDescriptor.index>);
+	TraceIn("<ruleName>_fragment", <ruleDescriptor.index>);
+	try
+	{
+		<block>
+	}
+	finally
+	{
+		TraceOut("<ruleName>_fragment", <ruleDescriptor.index>);
+		LeaveRule("<ruleName>_fragment", <ruleDescriptor.index>);
+		LeaveRule_<ruleName>_fragment();
+	}
+}
+// $ANTLR end <ruleName>
+>>
+
+insertLexerSynpreds(synpreds) ::= <<
+<insertSynpreds(synpreds)>
+>>
+
+insertSynpreds(synpreds) ::= <<
+<if(synpreds)>
+#region Synpreds
+private bool EvaluatePredicate(System.Action fragment)
+{
+	bool success = false;
+	state.backtracking++;
+	<@start()>
+	try { DebugBeginBacktrack(state.backtracking);
+	int start = input.Mark();
+	try
+	{
+		fragment();
+	}
+	catch ( RecognitionException re )
+	{
+		System.Console.Error.WriteLine("impossible: "+re);
+	}
+	success = !state.failed;
+	input.Rewind(start);
+	} finally { DebugEndBacktrack(state.backtracking, success); }
+	<@stop()>
+	state.backtracking--;
+	state.failed=false;
+	return success;
+}
+#endregion Synpreds
+<endif>
+>>
+
+ruleMemoization(name) ::= <<
+<if(memoize)>
+if (state.backtracking > 0 && AlreadyParsedRule(input, <ruleDescriptor.index>)) { <returnFromRule()> }
+<endif>
+>>
+
+/** How to test for failure and return from rule */
+checkRuleBacktrackFailure() ::= <<
+<if(backtracking)>if (state.failed) <returnFromRule()><endif>
+>>
+
+/** This rule has failed, exit indicating failure during backtrack */
+ruleBacktrackFailure() ::= <<
+<if(backtracking)>if (state.backtracking>0) {state.failed=true; <returnFromRule()>}<endif>
+>>
+
+ruleWrapperMap ::= [
+	"bottomup":{<ruleWrapperBottomup()>},
+	"topdown":{<ruleWrapperTopdown()>},
+	default:""
+]
+
+ruleWrapperBottomup() ::= <<
+<if(TREE_PARSER && filterMode)>
+protected override <if(buildAST)>IAstRuleReturnScope<else>void<endif> Bottomup() { return bottomup(); }
+<endif>
+>>
+
+ruleWrapperTopdown() ::= <<
+<if(TREE_PARSER && filterMode)>
+protected override <if(buildAST)>IAstRuleReturnScope<else>void<endif> Topdown() { return topdown(); }
+<endif>
+>>
+
+/** How to generate code for a rule.  This includes any return type
+ *  data aggregates required for multiple return values.
+ */
+rule(ruleName,ruleDescriptor,block,emptyRule,description,exceptions,finally,memoize) ::= <<
+<ruleAttributeScope(scope=ruleDescriptor.ruleScope)>
+<returnScope(ruleDescriptor.returnScope)>
+
+[Conditional("ANTLR_TRACE")]
+protected virtual void EnterRule_<ruleName>() {}
+[Conditional("ANTLR_TRACE")]
+protected virtual void LeaveRule_<ruleName>() {}
+<ruleWrapperMap.(ruleName)>
+// $ANTLR start "<ruleName>"
+// <fileName>:<description>
+[GrammarRule("<ruleName>")]
+<ruleModifier(grammar=grammar,ruleDescriptor=ruleDescriptor)> <returnType(ruleDescriptor)> <ruleName; format="id">(<ruleDescriptor.parameterScope:parameterScope()>)
+{
+	EnterRule_<ruleName>();
+	EnterRule("<ruleName>", <ruleDescriptor.index>);
+	TraceIn("<ruleName>", <ruleDescriptor.index>);
+    <ruleScopeSetUp()>
+    <ruleDeclarations()>
+    <ruleLabelDefs()>
+    <ruleDescriptor.actions.init>
+	try { DebugEnterRule(GrammarFileName, "<ruleName>");
+	DebugLocation(<ruleDescriptor.tree.line>, <ruleDescriptor.EORNode.charPositionInLine>);
+	<@preamble()>
+	try
+	{
+		<ruleMemoization(name=ruleName)>
+		<block>
+		<ruleCleanUp()>
+		<(ruleDescriptor.actions.after):execAction()>
+	}
+<if(exceptions)>
+	<exceptions:{e|<catch(decl=e.decl,action=e.action)><\n>}>
+<else>
+<if(!emptyRule)>
+<if(actions.(actionScope).rulecatch)>
+	<actions.(actionScope).rulecatch>
+<else>
+	catch (RecognitionException re)
+	{
+		ReportError(re);
+		Recover(input,re);
+	<@setErrorReturnValue()>
+	}
+<endif>
+<endif>
+<endif>
+	finally
+	{
+		TraceOut("<ruleName>", <ruleDescriptor.index>);
+		LeaveRule("<ruleName>", <ruleDescriptor.index>);
+		LeaveRule_<ruleName>();
+        <memoize()>
+        <ruleScopeCleanUp()>
+        <finally>
+    }
+ 	DebugLocation(<ruleDescriptor.EORNode.line>, <ruleDescriptor.EORNode.charPositionInLine>);
+	} finally { DebugExitRule(GrammarFileName, "<ruleName>"); }
+	<@postamble()>
+	<returnFromRule()><\n>
+}
+// $ANTLR end "<ruleName>"
+>>
+
+// imported grammars need to have internal rules
+ruleModifier(grammar,ruleDescriptor) ::= <<
+<if(grammar.grammarIsRoot)><csharpVisibilityMap.(ruleDescriptor.modifier); null="private"><else>internal<endif>
+>>
+
+// imported grammars need to have public return scopes
+returnScopeModifier(grammar,ruleDescriptor) ::= <<
+<if(grammar.grammarIsRoot)><csharpVisibilityMap.(ruleDescriptor.modifier); null="private"><else>public<endif>
+>>
+
+catch(decl,action) ::= <<
+catch (<e.decl>)
+{
+	<e.action>
+}
+>>
+
+ruleDeclarations() ::= <<
+<if(ruleDescriptor.hasMultipleReturnValues)>
+<returnType(ruleDescriptor)> retval = new <returnType(ruleDescriptor)>();
+retval.Start = (<labelType>)input.LT(1);
+<else>
+<ruleDescriptor.returnScope.attributes:{ a |
+<a.type> <a.name; format="id"> = <if(a.initValue)><a.initValue><else><initValue(a.type)><endif>;
+}>
+<endif>
+<if(memoize)>
+int <ruleDescriptor.name>_StartIndex = input.Index;
+<endif>
+>>
+
+ruleScopeSetUp() ::= <<
+<ruleDescriptor.useScopes:{it|<it>_stack.Push(new <it>_scope());<it>_scopeInit(<it>_stack.Peek());}; separator="\n">
+<ruleDescriptor.ruleScope:{it|<it.name>_stack.Push(new <it.name>_scope());<it.name>_scopeInit(<it.name>_stack.Peek());}; separator="\n">
+>>
+
+ruleScopeCleanUp() ::= <<
+<ruleDescriptor.useScopes:{it|<it>_scopeAfter(<it>_stack.Peek());<it>_stack.Pop();}; separator="\n">
+<ruleDescriptor.ruleScope:{it|<it.name>_scopeAfter(<it.name>_stack.Peek());<it.name>_stack.Pop();}; separator="\n">
+>>
+
+ruleLabelDefs() ::= <<
+<[ruleDescriptor.tokenLabels,ruleDescriptor.tokenListLabels,ruleDescriptor.wildcardTreeLabels,ruleDescriptor.wildcardTreeListLabels]
+    :{it|<labelType> <it.label.text> = default(<labelType>);}; separator="\n"
+>
+<ruleDescriptor.tokenListLabels
+    :{it|List\<<labelType>\> list_<it.label.text> = null;}; separator="\n"
+>
+<[ruleDescriptor.ruleListLabels,ruleDescriptor.wildcardTreeListLabels]
+    :{it|List\<<ASTLabelType>\> list_<it.label.text> = null;}; separator="\n"
+>
+<ruleDescriptor.ruleLabels:ruleLabelDef(); separator="\n">
+<ruleDescriptor.ruleListLabels:ruleLabelDef(); separator="\n">
+>>
+
+lexerRuleLabelDefs() ::= <<
+<[ruleDescriptor.tokenLabels,
+  ruleDescriptor.tokenListLabels,
+  ruleDescriptor.ruleLabels]
+    :{it|<labelType> <it.label.text> = default(<labelType>);}; separator="\n"
+>
+<[ruleDescriptor.charListLabels,
+  ruleDescriptor.charLabels]
+	:{it|int <it.label.text> = 0;}; separator="\n"
+>
+<[ruleDescriptor.tokenListLabels,
+  ruleDescriptor.ruleListLabels]
+    :{it|List\<<labelType>\> list_<it.label.text> = null;}; separator="\n"
+>
+<ruleDescriptor.charListLabels:{it|List\<int\> list_<it.label.text> = null;}; separator="\n"
+>
+>>
+
+returnFromRule() ::= <%
+return
+<if(!ruleDescriptor.isSynPred)>
+<if(ruleDescriptor.hasReturnValue)>
+<if(ruleDescriptor.hasSingleReturnValue)>
+<! This comment is a hack to make sure the following
+   single space appears in the output. !> <ruleDescriptor.singleValueReturnName>
+<else>
+<!!> retval
+<endif>
+<endif>
+<endif>
+;
+%>
+
+ruleCleanUp() ::= <<
+<if(ruleDescriptor.hasMultipleReturnValues)>
+<if(!TREE_PARSER)>
+retval.Stop = (<labelType>)input.LT(-1);
+<endif>
+<endif>
+>>
+
+memoize() ::= <<
+<if(memoize)>
+<if(backtracking)>
+if (state.backtracking > 0) { Memoize(input, <ruleDescriptor.index>, <ruleDescriptor.name>_StartIndex); }
+<endif>
+<endif>
+>>
+
+/** How to generate a rule in the lexer; naked blocks are used for
+ *  fragment rules.
+ */
+lexerRule(ruleName,nakedBlock,ruleDescriptor,block,memoize) ::= <<
+
+[Conditional("ANTLR_TRACE")]
+protected virtual void EnterRule_<ruleName>() {}
+[Conditional("ANTLR_TRACE")]
+protected virtual void LeaveRule_<ruleName>() {}
+
+// $ANTLR start "<ruleName>"
+[GrammarRule("<ruleName>")]
+<ruleModifier(grammar=grammar,ruleDescriptor=ruleDescriptor)> void m<ruleName>(<ruleDescriptor.parameterScope:parameterScope()>)
+{
+	EnterRule_<ruleName>();
+	EnterRule("<ruleName>", <ruleDescriptor.index>);
+	TraceIn("<ruleName>", <ruleDescriptor.index>);
+    <ruleScopeSetUp()>
+    <ruleDeclarations()>
+		try
+		{
+<if(nakedBlock)>
+		<ruleMemoization(name=ruleName)>
+		<lexerRuleLabelDefs()>
+		<ruleDescriptor.actions.init>
+		<block>
+<else>
+		int _type = <ruleName>;
+		int _channel = DefaultTokenChannel;
+		<ruleMemoization(name=ruleName)>
+		<lexerRuleLabelDefs()>
+		<ruleDescriptor.actions.init>
+		<block>
+		<ruleCleanUp()>
+		state.type = _type;
+		state.channel = _channel;
+		<(ruleDescriptor.actions.after):execAction()>
+<endif>
+	}
+	finally
+	{
+		TraceOut("<ruleName>", <ruleDescriptor.index>);
+		LeaveRule("<ruleName>", <ruleDescriptor.index>);
+		LeaveRule_<ruleName>();
+        <ruleScopeCleanUp()>
+        <memoize()>
+    }
+}
+// $ANTLR end "<ruleName>"
+>>
+
+/** How to generate code for the implicitly-defined lexer grammar rule
+ *  that chooses between lexer rules.
+ */
+tokensRule(ruleName,nakedBlock,args,block,ruleDescriptor) ::= <<
+
+public override void mTokens()
+{
+	<block><\n>
+}
+>>
+
+// S U B R U L E S
+
+/** A (...) subrule with multiple alternatives */
+block(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
+// <fileName>:<description>
+int alt<decisionNumber>=<maxAlt>;
+<decls>
+<@predecision()>
+try { DebugEnterSubRule(<decisionNumber>);
+try { DebugEnterDecision(<decisionNumber>, decisionCanBacktrack[<decisionNumber>]);
+<decision>
+} finally { DebugExitDecision(<decisionNumber>); }
+<@postdecision()>
+<@prebranch()>
+switch (alt<decisionNumber>)
+{
+<alts:{a|<altSwitchCase(i,a)>}>
+}
+} finally { DebugExitSubRule(<decisionNumber>); }
+<@postbranch()>
+>>
+
+/** A rule block with multiple alternatives */
+ruleBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
+// <fileName>:<description>
+int alt<decisionNumber>=<maxAlt>;
+<decls>
+<@predecision()>
+try { DebugEnterDecision(<decisionNumber>, decisionCanBacktrack[<decisionNumber>]);
+<decision>
+} finally { DebugExitDecision(<decisionNumber>); }
+<@postdecision()>
+switch (alt<decisionNumber>)
+{
+<alts:{a|<altSwitchCase(i,a)>}>
+}
+>>
+
+ruleBlockSingleAlt(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,description) ::= <<
+// <fileName>:<description>
+<decls>
+<@prealt()>
+DebugEnterAlt(1);
+<alts>
+<@postalt()>
+>>
+
+/** A special case of a (...) subrule with a single alternative */
+blockSingleAlt(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,description) ::= <<
+// <fileName>:<description>
+<decls>
+<@prealt()>
+DebugEnterAlt(1);
+<alts>
+<@postalt()>
+>>
+
+/** A (..)+ block with 1 or more alternatives */
+positiveClosureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
+// <fileName>:<description>
+int cnt<decisionNumber>=0;
+<decls>
+<@preloop()>
+try { DebugEnterSubRule(<decisionNumber>);
+while (true)
+{
+	int alt<decisionNumber>=<maxAlt>;
+	<@predecision()>
+	try { DebugEnterDecision(<decisionNumber>, decisionCanBacktrack[<decisionNumber>]);
+	<decision>
+	} finally { DebugExitDecision(<decisionNumber>); }
+	<@postdecision()>
+	switch (alt<decisionNumber>)
+	{
+	<alts:{a|<altSwitchCase(i,a)>}>
+	default:
+		if (cnt<decisionNumber> >= 1)
+			goto loop<decisionNumber>;
+
+		<ruleBacktrackFailure()>
+		EarlyExitException eee<decisionNumber> = new EarlyExitException( <decisionNumber>, input );
+		DebugRecognitionException(eee<decisionNumber>);
+		<@earlyExitException()>
+		throw eee<decisionNumber>;
+	}
+	cnt<decisionNumber>++;
+}
+loop<decisionNumber>:
+	;
+
+} finally { DebugExitSubRule(<decisionNumber>); }
+<@postloop()>
+>>
+
+positiveClosureBlockSingleAlt ::= positiveClosureBlock
+
+/** A (..)* block with 1 or more alternatives */
+closureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
+// <fileName>:<description>
+<decls>
+<@preloop()>
+try { DebugEnterSubRule(<decisionNumber>);
+while (true)
+{
+	int alt<decisionNumber>=<maxAlt>;
+	<@predecision()>
+	try { DebugEnterDecision(<decisionNumber>, decisionCanBacktrack[<decisionNumber>]);
+	<decision>
+	} finally { DebugExitDecision(<decisionNumber>); }
+	<@postdecision()>
+	switch ( alt<decisionNumber> )
+	{
+	<alts:{a|<altSwitchCase(i,a)>}>
+	default:
+		goto loop<decisionNumber>;
+	}
+}
+
+loop<decisionNumber>:
+	;
+
+} finally { DebugExitSubRule(<decisionNumber>); }
+<@postloop()>
+>>
+
+closureBlockSingleAlt ::= closureBlock
+
+/** Optional blocks (x)? are translated to (x|) by before code generation
+ *  so we can just use the normal block template
+ */
+optionalBlock ::= block
+
+optionalBlockSingleAlt ::= block
+
+/** A case in a switch that jumps to an alternative given the alternative
+ *  number.  A DFA predicts the alternative and then a simple switch
+ *  does the jump to the code that actually matches that alternative.
+ */
+altSwitchCase(altNum,alt) ::= <<
+case <altNum>:
+	<@prealt()>
+	DebugEnterAlt(<altNum>);
+	<alt>
+	break;<\n>
+>>
+
+/** An alternative is just a list of elements; at outermost level */
+alt(elements,altNum,description,autoAST,outerAlt,treeLevel,rew) ::= <<
+// <fileName>:<description>
+{
+<@declarations()>
+<elements:element()>
+<rew>
+<@cleanup()>
+}
+>>
+
+/** What to emit when there is no rewrite.  For auto build
+ *  mode, does nothing.
+ */
+noRewrite(rewriteBlockLevel, treeLevel) ::= ""
+
+// E L E M E N T S
+
+/** Dump the elements one per line */
+element(it) ::= <%
+<@prematch()>
+DebugLocation(<it.line>, <it.pos>);<\n>
+<it.el><\n>
+%>
+
+/** match a token optionally with a label in front */
+tokenRef(token,label,elementIndex,terminalOptions) ::= <<
+<if(label)><label>=(<labelType>)<endif>Match(input,<token>,Follow._<token>_in_<ruleName><elementIndex>); <checkRuleBacktrackFailure()>
+>>
+
+/** ids+=ID */
+tokenRefAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<tokenRef(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+listLabelElem(label,elem,elemType) ::= <<
+if (list_<label>==null) list_<label>=new List\<<elemType; null={<labelType>}>\>();
+list_<label>.Add(<elem>);<\n>
+>>
+
+/** match a character */
+charRef(char,label) ::= <<
+<if(label)>
+<label> = input.LA(1);<\n>
+<endif>
+Match(<char>); <checkRuleBacktrackFailure()>
+>>
+
+/** match a character range */
+charRangeRef(a,b,label) ::= <<
+<if(label)>
+<label> = input.LA(1);<\n>
+<endif>
+MatchRange(<a>,<b>); <checkRuleBacktrackFailure()>
+>>
+
+/** For now, sets are interval tests and must be tested inline */
+matchSet(s,label,terminalOptions,elementIndex,postmatchCode="") ::= <<
+<if(label)>
+<matchSetLabel()>
+<endif>
+if (<s>)
+{
+	input.Consume();
+	<postmatchCode>
+	<if(!LEXER)>state.errorRecovery=false;<endif><if(backtracking)>state.failed=false;<endif>
+}
+else
+{
+	<ruleBacktrackFailure()>
+	MismatchedSetException mse = new MismatchedSetException(null,input);
+	DebugRecognitionException(mse);
+	<@mismatchedSetException()>
+<if(LEXER)>
+	Recover(mse);
+	throw mse;
+<else>
+	throw mse;
+	<! use following code to make it recover inline; remove throw mse;
+	recoverFromMismatchedSet(input,mse,Follow._set_in_<ruleName><elementIndex>);
+	!>
+<endif>
+}<\n>
+>>
+
+matchSetUnchecked(s,label,elementIndex,postmatchCode=false) ::= <%
+<if(label)>
+<matchSetLabel()><\n>
+<endif>
+input.Consume();<\n>
+<if(postmatchCode)>
+<postmatchCode><\n>
+<endif>
+<if(!LEXER)>state.errorRecovery=false;<endif><if(backtracking)>state.failed=false;<endif>
+%>
+
+matchSetLabel() ::= <%
+<if(LEXER)>
+<label>= input.LA(1);
+<else>
+<label>=(<labelType>)input.LT(1);
+<endif>
+%>
+
+matchRuleBlockSet ::= matchSet
+
+matchSetAndListLabel(s,label,elementIndex,postmatchCode) ::= <<
+<matchSet(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** Match a string literal */
+lexerStringRef(string,label,elementIndex) ::= <%
+<if(label)>
+int <label>Start = CharIndex;<\n>
+Match(<string>); <checkRuleBacktrackFailure()><\n>
+int <label>StartLine<elementIndex> = Line;<\n>
+int <label>StartCharPos<elementIndex> = CharPositionInLine;<\n>
+<label> = new <labelType>(input, TokenTypes.Invalid, TokenChannels.Default, <label>Start, CharIndex-1);<\n>
+<label>.Line = <label>StartLine<elementIndex>;<\n>
+<label>.CharPositionInLine = <label>StartCharPos<elementIndex>;
+<else>
+Match(<string>); <checkRuleBacktrackFailure()><\n>
+<endif>
+%>
+
+wildcard(token,label,elementIndex,terminalOptions) ::= <<
+<if(label)>
+<label>=(<labelType>)input.LT(1);<\n>
+<endif>
+MatchAny(input); <checkRuleBacktrackFailure()>
+>>
+
+wildcardAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<wildcard(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** Match . wildcard in lexer */
+wildcardChar(label, elementIndex) ::= <<
+<if(label)>
+<label> = input.LA(1);<\n>
+<endif>
+MatchAny(); <checkRuleBacktrackFailure()>
+>>
+
+wildcardCharListLabel(label, elementIndex) ::= <<
+<wildcardChar(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** Match a rule reference by invoking it possibly with arguments
+ *  and a return value or values.  The 'rule' argument was the
+ *  target rule name, but now is type Rule, whose toString is
+ *  same: the rule name.  Now though you can access full rule
+ *  descriptor stuff.
+ */
+ruleRef(rule,label,elementIndex,args,scope) ::= <<
+PushFollow(Follow._<rule.name>_in_<ruleName><elementIndex>);
+<if(label)><label>=<endif><if(scope)><scope:delegateName()>.<endif><rule.name; format="id">(<args; separator=", ">);
+PopFollow();
+<checkRuleBacktrackFailure()>
+>>
+
+/** ids+=r */
+ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRef(...)>
+<listLabelElem(elem=label,elemType={<ASTLabelType>},...)>
+>>
+
+/** A lexer rule reference.
+ *
+ *  The 'rule' argument was the target rule name, but now
+ *  is type Rule, whose toString is same: the rule name.
+ *  Now though you can access full rule descriptor stuff.
+ */
+lexerRuleRef(rule,label,args,elementIndex,scope) ::= <%
+<if(label)>
+int <label>Start<elementIndex> = CharIndex;<\n>
+int <label>StartLine<elementIndex> = Line;<\n>
+int <label>StartCharPos<elementIndex> = CharPositionInLine;<\n>
+<if(scope)><scope:delegateName()>.<endif>m<rule.name>(<args; separator=", ">); <checkRuleBacktrackFailure()><\n>
+<label> = new <labelType>(input, TokenTypes.Invalid, TokenChannels.Default, <label>Start<elementIndex>, CharIndex-1);<\n>
+<label>.Line = <label>StartLine<elementIndex>;<\n>
+<label>.CharPositionInLine = <label>StartCharPos<elementIndex>;
+<else>
+<if(scope)><scope:delegateName()>.<endif>m<rule.name>(<args; separator=", ">); <checkRuleBacktrackFailure()>
+<endif>
+%>
+
+/** i+=INT in lexer */
+lexerRuleRefAndListLabel(rule,label,args,elementIndex,scope) ::= <<
+<lexerRuleRef(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** EOF in the lexer */
+lexerMatchEOF(label,elementIndex) ::= <%
+<if(label)>
+int <label>Start<elementIndex> = CharIndex;<\n>
+int <label>StartLine<elementIndex> = Line;<\n>
+int <label>StartCharPos<elementIndex> = CharPositionInLine;<\n>
+Match(EOF); <checkRuleBacktrackFailure()><\n>
+<labelType> <label> = new <labelType>(input, EOF, TokenChannels.Default, <label>Start<elementIndex>, CharIndex-1);<\n>
+<label>.Line = <label>StartLine<elementIndex>;<\n>
+<label>.CharPositionInLine = <label>StartCharPos<elementIndex>;
+<else>
+Match(EOF); <checkRuleBacktrackFailure()>
+<endif>
+%>
+
+// used for left-recursive rules
+recRuleDefArg()                       ::= "int <recRuleArg()>"
+recRuleArg()                          ::= "_p"
+recRuleAltPredicate(ruleName,opPrec)  ::= "<recRuleArg()> \<= <opPrec>"
+recRuleSetResultAction()              ::= "root_0=$<ruleName>_primary.tree;"
+recRuleSetReturnAction(src,name)      ::= "$<name>=$<src>.<name>;"
+
+/** match ^(root children) in tree parser */
+tree(root, actionsAfterRoot, children, nullableChildList,
+     enclosingTreeLevel, treeLevel) ::= <<
+<root:element()>
+<actionsAfterRoot:element()>
+<if(nullableChildList)>
+if (input.LA(1) == TokenTypes.Down)
+{
+	Match(input, TokenTypes.Down, null); <checkRuleBacktrackFailure()>
+	<children:element()>
+	Match(input, TokenTypes.Up, null); <checkRuleBacktrackFailure()>
+}
+<else>
+Match(input, TokenTypes.Down, null); <checkRuleBacktrackFailure()>
+<children:element()>
+Match(input, TokenTypes.Up, null); <checkRuleBacktrackFailure()>
+<endif>
+>>
+
+/** Every predicate is used as a validating predicate (even when it is
+ *  also hoisted into a prediction expression).
+ */
+validateSemanticPredicate(pred,description) ::= <<
+if (!(<evalPredicate(...)>))
+{
+	<ruleBacktrackFailure()>
+	throw new FailedPredicateException(input, "<ruleName>", "<description>");
+}
+>>
+
+// F i x e d  D F A  (if-then-else)
+
+dfaState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
+int LA<decisionNumber>_<k> = input.LA(<k>);<\n>
+<edges; separator="\nelse ">
+else
+{
+<if(eotPredictsAlt)>
+	alt<decisionNumber> = <eotPredictsAlt>;
+<else>
+	<ruleBacktrackFailure()>
+	NoViableAltException nvae = new NoViableAltException("<description>", <decisionNumber>, <stateNumber>, input, <k>);
+	DebugRecognitionException(nvae);
+	<@noViableAltException()>
+	throw nvae;
+<endif>
+}
+>>
+
+/** Same as a normal DFA state except that we don't examine lookahead
+ *  for the bypass alternative.  It delays error detection but this
+ *  is faster, smaller, and more what people expect.  For (X)? people
+ *  expect "if ( LA(1)==X ) match(X);" and that's it.
+ */
+dfaOptionalBlockState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
+int LA<decisionNumber>_<k> = input.LA(<k>);<\n>
+<edges; separator="\nelse ">
+>>
+
+/** A DFA state that is actually the loopback decision of a closure
+ *  loop.  If end-of-token (EOT) predicts any of the targets then it
+ *  should act like a default clause (i.e., no error can be generated).
+ *  This is used only in the lexer so that for ('a')* on the end of a rule
+ *  anything other than 'a' predicts exiting.
+ */
+dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
+int LA<decisionNumber>_<k> = input.LA(<k>);<\n>
+<edges; separator="\nelse "><\n>
+<if(eotPredictsAlt)>
+<if(!edges)>
+alt<decisionNumber> = <eotPredictsAlt>;<! if no edges, don't gen ELSE !>
+<else>
+else
+{
+	alt<decisionNumber> = <eotPredictsAlt>;
+}<\n>
+<endif>
+<endif>
+>>
+
+/** An accept state indicates a unique alternative has been predicted */
+dfaAcceptState(alt) ::= "alt<decisionNumber> = <alt>;"
+
+/** A simple edge with an expression.  If the expression is satisfied,
+ *  enter to the target state.  To handle gated productions, we may
+ *  have to evaluate some predicates for this edge.
+ */
+dfaEdge(labelExpr, targetState, predicates) ::= <<
+if ((<labelExpr>)<if(predicates)> && (<predicates>)<endif>)
+{
+	<targetState>
+}
+>>
+
+// F i x e d  D F A  (switch case)
+
+/** A DFA state where a SWITCH may be generated.  The code generator
+ *  decides if this is possible: CodeGenerator.canGenerateSwitch().
+ */
+dfaStateSwitch(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
+switch (input.LA(<k>))
+{
+<edges; separator="\n">
+default:
+<if(eotPredictsAlt)>
+	alt<decisionNumber>=<eotPredictsAlt>;
+	break;<\n>
+<else>
+	{
+		<ruleBacktrackFailure()>
+		NoViableAltException nvae = new NoViableAltException("<description>", <decisionNumber>, <stateNumber>, input, <k>);
+		DebugRecognitionException(nvae);
+		<@noViableAltException()>
+		throw nvae;
+	}
+<endif>
+}<\n>
+>>
+
+dfaOptionalBlockStateSwitch(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
+switch (input.LA(<k>))
+{
+<edges; separator="\n">
+}<\n>
+>>
+
+dfaLoopbackStateSwitch(k, edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
+switch (input.LA(<k>))
+{
+<edges; separator="\n">
+<if(eotPredictsAlt)>
+default:
+	alt<decisionNumber>=<eotPredictsAlt>;
+	break;<\n>
+<endif>
+}<\n>
+>>
+
+dfaEdgeSwitch(labels, targetState) ::= <<
+<labels:{it|case <it>:}; separator="\n">
+	{
+	<targetState>
+	}
+	break;
+>>
+
+// C y c l i c  D F A
+
+/** The code to initiate execution of a cyclic DFA; this is used
+ *  in the rule to predict an alt just like the fixed DFA case.
+ *  The <name> attribute is inherited via the parser, lexer, ...
+ */
+dfaDecision(decisionNumber,description) ::= <<
+try
+{
+	alt<decisionNumber> = dfa<decisionNumber>.Predict(input);
+}
+catch (NoViableAltException nvae)
+{
+	DebugRecognitionException(nvae);
+	throw;
+}
+>>
+
+/* Dump DFA tables as run-length-encoded Strings of octal values.
+ * Can't use hex as compiler translates them before compilation.
+ * These strings are split into multiple, concatenated strings.
+ * Java puts them back together at compile time thankfully.
+ * Java cannot handle large static arrays, so we're stuck with this
+ * encode/decode approach.  See analysis and runtime DFA for
+ * the encoding methods.
+ */
+cyclicDFA(dfa) ::= <<
+private class DFA<dfa.decisionNumber> : DFA
+{
+	private const string DFA<dfa.decisionNumber>_eotS =
+		"<dfa.javaCompressedEOT; wrap="\"+\n\t\t\"">";
+	private const string DFA<dfa.decisionNumber>_eofS =
+		"<dfa.javaCompressedEOF; wrap="\"+\n\t\t\"">";
+	private const string DFA<dfa.decisionNumber>_minS =
+		"<dfa.javaCompressedMin; wrap="\"+\n\t\t\"">";
+	private const string DFA<dfa.decisionNumber>_maxS =
+		"<dfa.javaCompressedMax; wrap="\"+\n\t\t\"">";
+	private const string DFA<dfa.decisionNumber>_acceptS =
+		"<dfa.javaCompressedAccept; wrap="\"+\n\t\t\"">";
+	private const string DFA<dfa.decisionNumber>_specialS =
+		"<dfa.javaCompressedSpecial; wrap="\"+\n\t\t\"">}>";
+	private static readonly string[] DFA<dfa.decisionNumber>_transitionS =
+		{
+			<dfa.javaCompressedTransition:{s|"<s; wrap="\"+\n\"">"}; separator=",\n">
+		};
+
+	private static readonly short[] DFA<dfa.decisionNumber>_eot = DFA.UnpackEncodedString(DFA<dfa.decisionNumber>_eotS);
+	private static readonly short[] DFA<dfa.decisionNumber>_eof = DFA.UnpackEncodedString(DFA<dfa.decisionNumber>_eofS);
+	private static readonly char[] DFA<dfa.decisionNumber>_min = DFA.UnpackEncodedStringToUnsignedChars(DFA<dfa.decisionNumber>_minS);
+	private static readonly char[] DFA<dfa.decisionNumber>_max = DFA.UnpackEncodedStringToUnsignedChars(DFA<dfa.decisionNumber>_maxS);
+	private static readonly short[] DFA<dfa.decisionNumber>_accept = DFA.UnpackEncodedString(DFA<dfa.decisionNumber>_acceptS);
+	private static readonly short[] DFA<dfa.decisionNumber>_special = DFA.UnpackEncodedString(DFA<dfa.decisionNumber>_specialS);
+	private static readonly short[][] DFA<dfa.decisionNumber>_transition;
+
+	static DFA<dfa.decisionNumber>()
+	{
+		int numStates = DFA<dfa.decisionNumber>_transitionS.Length;
+		DFA<dfa.decisionNumber>_transition = new short[numStates][];
+		for ( int i=0; i \< numStates; i++ )
+		{
+			DFA<dfa.decisionNumber>_transition[i] = DFA.UnpackEncodedString(DFA<dfa.decisionNumber>_transitionS[i]);
+		}
+	}
+
+	public DFA<dfa.decisionNumber>( BaseRecognizer recognizer<if(dfa.specialStateSTs)>, SpecialStateTransitionHandler specialStateTransition<endif> )
+<if(dfa.specialStateSTs)>
+		: base(specialStateTransition)
+<endif>
+	{
+		this.recognizer = recognizer;
+		this.decisionNumber = <dfa.decisionNumber>;
+		this.eot = DFA<dfa.decisionNumber>_eot;
+		this.eof = DFA<dfa.decisionNumber>_eof;
+		this.min = DFA<dfa.decisionNumber>_min;
+		this.max = DFA<dfa.decisionNumber>_max;
+		this.accept = DFA<dfa.decisionNumber>_accept;
+		this.special = DFA<dfa.decisionNumber>_special;
+		this.transition = DFA<dfa.decisionNumber>_transition;
+	}
+
+	public override string Description { get { return "<dfa.description>"; } }
+
+	public override void Error(NoViableAltException nvae)
+	{
+		DebugRecognitionException(nvae);
+	}
+}<\n>
+<if(dfa.specialStateSTs)>
+private int SpecialStateTransition<dfa.decisionNumber>(DFA dfa, int s, IIntStream _input)<! throws NoViableAltException!>
+{
+	<if(LEXER)>
+	IIntStream input = _input;
+	<endif>
+	<if(PARSER)>
+	ITokenStream input = (ITokenStream)_input;
+	<endif>
+	<if(TREE_PARSER)>
+	ITreeNodeStream input = (ITreeNodeStream)_input;
+	<endif>
+	int _s = s;
+	s = -1;
+	<! pull these outside the switch cases to save space on locals !>
+	int LA<dfa.decisionNumber>_1 = input.LA(1);
+	int index<dfa.decisionNumber>_1 = input.Index;
+	switch (_s)
+	{
+	<dfa.specialStateSTs:{state |case <i0>:<! compressed special state numbers 0..n-1 !>
+	<state>}; separator="\n">
+
+	default:
+		break;
+	}
+
+	if (s >= 0)
+		return s;
+
+<if(backtracking)>
+	if (state.backtracking > 0) {state.failed=true; return -1;}
+<endif>
+	NoViableAltException nvae = new NoViableAltException(dfa.Description, <dfa.decisionNumber>, _s, input);
+	dfa.Error(nvae);
+	throw nvae;
+}
+<endif>
+>>
+
+/** A state in a cyclic DFA; it's a special state and part of a big switch on
+ *  state.
+ */
+cyclicDFAState(decisionNumber,stateNumber,edges,needErrorClause,semPredState) ::= <<
+{
+<if(semPredState)>
+	<! get next lookahead symbol to test edges, then rewind !>
+	input.Rewind();
+<endif>
+	<edges; separator="\nelse ">
+<if(semPredState)>
+	<! return input cursor to state before we rewound !>
+	input.Seek(index<decisionNumber>_1);
+<endif>
+	break;
+}
+>>
+
+/** Just like a fixed DFA edge, test the lookahead and indicate what
+ *  state to jump to next if successful.
+ */
+cyclicDFAEdge(labelExpr, targetStateNumber, edgeNumber, predicates) ::= <<
+if ((<labelExpr>)<if(predicates)> && (<predicates>)<endif>) {s = <targetStateNumber>;}<\n>
+>>
+
+/** An edge pointing at end-of-token; essentially matches any char;
+ *  always jump to the target.
+ */
+eotDFAEdge(targetStateNumber,edgeNumber, predicates) ::= <<
+s = <targetStateNumber>;<\n>
+>>
+
+
+// D F A  E X P R E S S I O N S
+
+andPredicates(left,right) ::= "(<left>&&<right>)"
+
+orPredicates(operands) ::= "(<first(operands)><rest(operands):{o | ||<o>}>)"
+
+notPredicate(pred) ::= "!(<evalPredicate(...)>)"
+
+evalPredicate(pred,description) ::= "(<pred>)"
+
+evalSynPredicate(pred,description) ::= "EvaluatePredicate(<pred>_fragment)"
+
+lookaheadTest(atom,k,atomAsInt) ::= "LA<decisionNumber>_<k>==<atom>"
+
+/** Sometimes a lookahead test cannot assume that LA(k) is in a temp variable
+ *  somewhere.  Must ask for the lookahead directly.
+ */
+isolatedLookaheadTest(atom,k,atomAsInt) ::= "input.LA(<k>)==<atom>"
+
+lookaheadRangeTest(lower,upper,k,rangeNumber,lowerAsInt,upperAsInt) ::= <%
+(LA<decisionNumber>_<k><ge()><lower> && LA<decisionNumber>_<k><le()><upper>)
+%>
+
+isolatedLookaheadRangeTest(lower,upper,k,rangeNumber,lowerAsInt,upperAsInt) ::= "(input.LA(<k>)<ge()><lower> && input.LA(<k>)<le()><upper>)"
+
+le() ::= "\<="
+ge() ::= ">="
+
+setTest(ranges) ::= <<
+<ranges; separator="||">
+>>
+
+// A T T R I B U T E S
+
+attributeScope(scope) ::= <<
+<if(scope.attributes)>
+protected sealed partial class <scope.name>_scope
+{
+	<scope.attributes:{it|public <it.decl>;}; separator="\n">
+}
+<if(scope.actions.scopeinit)>
+protected void <scope.name>_scopeInit( <scope.name>_scope scope )
+{
+	<scope.actions.scopeinit>
+}
+<else>
+protected virtual void <scope.name>_scopeInit( <scope.name>_scope scope ) {}
+<endif>
+<if(scope.actions.scopeafter)>
+protected void <scope.name>_scopeAfter( <scope.name>_scope scope )
+{
+	<scope.actions.scopeafter>
+}
+<else>
+protected virtual void <scope.name>_scopeAfter( <scope.name>_scope scope ) {}
+<endif>
+protected readonly ListStack\<<scope.name>_scope\> <scope.name>_stack = new ListStack\<<scope.name>_scope\>();
+<endif>
+>>
+
+globalAttributeScope(scope) ::= <<
+<attributeScope(...)>
+>>
+
+ruleAttributeScope(scope) ::= <<
+<attributeScope(...)>
+>>
+
+returnStructName(it) ::= "<it.name>_return"
+
+returnType(ruleDescriptor) ::= <%
+<if(ruleDescriptor.returnScope.attributes && ruleDescriptor.hasMultipleReturnValues)>
+	<ruleDescriptor.grammar.recognizerName>.<ruleDescriptor:returnStructName()>
+<elseif(ruleDescriptor.hasMultipleReturnValues)>
+	<ruleReturnBaseType()>
+<elseif(ruleDescriptor.hasSingleReturnValue)>
+	<ruleDescriptor.singleValueReturnType>
+<else>
+	void
+<endif>
+%>
+
+/** Generate the C# type associated with a single or multiple return
+ *  values.
+ */
+ruleLabelType(referencedRule) ::= <%
+<if(referencedRule.returnScope.attributes&&referencedRule.hasMultipleReturnValues)>
+	<referencedRule.grammar.recognizerName>.<referencedRule:returnStructName()>
+<elseif(referencedRule.hasMultipleReturnValues)>
+	<ruleReturnBaseType()>
+<elseif(referencedRule.hasSingleReturnValue)>
+	<referencedRule.singleValueReturnType>
+<else>
+	void
+<endif>
+%>
+
+delegateName(it) ::= <<
+<if(it.label)><it.label><else>g<it.name><endif>
+>>
+
+/** Using a type to init value map, try to init a type; if not in table
+ *  must be an object, default value is "null".
+ */
+initValue(typeName) ::= <<
+default(<typeName>)
+>>
+
+/** Define a rule label including default value */
+ruleLabelDef(label) ::= <%
+<ruleLabelType(referencedRule=label.referencedRule)> <label.label.text> = <initValue(typeName=ruleLabelType(referencedRule=label.referencedRule))>;
+%>
+
+/** Define a return struct for a rule if the code needs to access its
+ *  start/stop tokens, tree stuff, attributes, ...  Leave a hole for
+ *  subgroups to stick in members.
+ */
+returnScope(scope) ::= <<
+<if(scope.attributes && ruleDescriptor.hasMultipleReturnValues)>
+<returnScopeModifier(grammar=grammar,ruleDescriptor=ruleDescriptor)> sealed partial class <ruleDescriptor:returnStructName()> : <ruleReturnBaseType()><@ruleReturnInterfaces()>
+{
+	<scope.attributes:{it|public <it.decl>;}; separator="\n">
+	<@ruleReturnMembers()>
+}
+<endif>
+>>
+
+ruleReturnBaseType() ::= <%
+<if(TREE_PARSER)>Tree<else>Parser<endif>RuleReturnScope\<<labelType>>
+%>
+
+@returnScope.ruleReturnMembers() ::= <<
+>>
+
+parameterScope(scope) ::= <<
+<scope.attributes:{it|<it.decl>}; separator=", ">
+>>
+
+parameterAttributeRef(attr) ::= <<
+<attr.name; format="id">
+>>
+
+parameterSetAttributeRef(attr,expr) ::= <<
+<attr.name; format="id"> =<expr>;
+>>
+
+scopeAttributeRef(scope,attr,index,negIndex) ::= <%
+<if(negIndex)>
+<scope>_stack[<scope>_stack.Count - <negIndex> - 1].<attr.name; format="id">
+<else>
+<if(index)>
+<scope>_stack[<index>].<attr.name; format="id">
+<else>
+<scope>_stack.Peek().<attr.name; format="id">
+<endif>
+<endif>
+%>
+
+scopeSetAttributeRef(scope,attr,expr,index,negIndex) ::= <%
+<if(negIndex)>
+<scope>_stack[<scope>_stack.Count - <negIndex> - 1].<attr.name; format="id"> = <expr>;
+<else>
+<if(index)>
+<scope>_stack[<index>].<attr.name; format="id"> = <expr>;
+<else>
+<scope>_stack.Peek().<attr.name; format="id"> = <expr>;
+<endif>
+<endif>
+%>
+
+/** $x is either global scope or x is rule with dynamic scope; refers
+ *  to stack itself not top of stack.  This is useful for predicates
+ *  like {$function.Count>0 && $function::name.Equals("foo")}?
+ */
+isolatedDynamicScopeRef(scope) ::= "<scope>_stack"
+
+/** reference an attribute of rule; might only have single return value */
+ruleLabelRef(referencedRule,scope,attr) ::= <%
+<if(referencedRule.hasMultipleReturnValues)>
+(<scope>!=null?<scope>.<attr.name; format="id">:<initValue(attr.type)>)
+<else>
+<scope>
+<endif>
+%>
+
+returnAttributeRef(ruleDescriptor,attr) ::= <%
+<if(ruleDescriptor.hasMultipleReturnValues)>
+retval.<attr.name; format="id">
+<else>
+<attr.name; format="id">
+<endif>
+%>
+
+returnSetAttributeRef(ruleDescriptor,attr,expr) ::= <%
+<if(ruleDescriptor.hasMultipleReturnValues)>
+retval.<attr.name; format="id"> =<expr>;
+<else>
+<attr.name; format="id"> =<expr>;
+<endif>
+%>
+
+/** How to translate $tokenLabel */
+tokenLabelRef(label) ::= "<label>"
+
+/** ids+=ID {$ids} or e+=expr {$e} */
+listLabelRef(label) ::= "list_<label>"
+
+
+// not sure the next are the right approach
+
+tokenLabelPropertyRef_text(scope,attr) ::= "(<scope>!=null?<scope>.Text:null)"
+tokenLabelPropertyRef_type(scope,attr) ::= "(<scope>!=null?<scope>.Type:0)"
+tokenLabelPropertyRef_line(scope,attr) ::= "(<scope>!=null?<scope>.Line:0)"
+tokenLabelPropertyRef_pos(scope,attr) ::= "(<scope>!=null?<scope>.CharPositionInLine:0)"
+tokenLabelPropertyRef_channel(scope,attr) ::= "(<scope>!=null?<scope>.Channel:0)"
+tokenLabelPropertyRef_index(scope,attr) ::= "(<scope>!=null?<scope>.TokenIndex:0)"
+tokenLabelPropertyRef_tree(scope,attr) ::= "<scope>_tree"
+tokenLabelPropertyRef_int(scope,attr) ::= "(<scope>!=null?int.Parse(<scope>.Text):0)"
+
+ruleLabelPropertyRef_start(scope,attr) ::= "(<scope>!=null?((<labelType>)<scope>.Start):default(<labelType>))"
+ruleLabelPropertyRef_stop(scope,attr) ::= "(<scope>!=null?((<labelType>)<scope>.Stop):default(<labelType>))"
+ruleLabelPropertyRef_tree(scope,attr) ::= "(<scope>!=null?((<ASTLabelType>)<scope>.Tree):default(<ASTLabelType>))"
+ruleLabelPropertyRef_text(scope,attr) ::= <%
+<if(TREE_PARSER)>
+(<scope>!=null?(input.TokenStream.ToString(
+  input.TreeAdaptor.GetTokenStartIndex(<scope>.Start),
+  input.TreeAdaptor.GetTokenStopIndex(<scope>.Start))):null)
+<else>
+(<scope>!=null?input.ToString(<scope>.Start,<scope>.Stop):null)
+<endif>
+%>
+
+ruleLabelPropertyRef_st(scope,attr) ::= "(<scope>!=null?<scope>.Template:null)"
+
+/** Isolated $RULE ref ok in lexer as it's a Token */
+lexerRuleLabel(label) ::= "<label>"
+
+lexerRuleLabelPropertyRef_type(scope,attr) ::=
+    "(<scope>!=null?<scope>.Type:0)"
+
+lexerRuleLabelPropertyRef_line(scope,attr) ::=
+    "(<scope>!=null?<scope>.Line:0)"
+
+lexerRuleLabelPropertyRef_pos(scope,attr) ::=
+    "(<scope>!=null?<scope>.CharPositionInLine:-1)"
+
+lexerRuleLabelPropertyRef_channel(scope,attr) ::=
+    "(<scope>!=null?<scope>.Channel:0)"
+
+lexerRuleLabelPropertyRef_index(scope,attr) ::=
+    "(<scope>!=null?<scope>.TokenIndex:0)"
+
+lexerRuleLabelPropertyRef_text(scope,attr) ::=
+    "(<scope>!=null?<scope>.Text:null)"
+
+lexerRuleLabelPropertyRef_int(scope,attr) ::=
+    "(<scope>!=null?int.Parse(<scope>.Text):0)"
+
+// Somebody may ref $template or $tree or $stop within a rule:
+rulePropertyRef_start(scope,attr) ::= "retval.Start"
+rulePropertyRef_stop(scope,attr) ::= "retval.Stop"
+rulePropertyRef_tree(scope,attr) ::= "retval.Tree"
+rulePropertyRef_text(scope,attr) ::= <%
+<if(TREE_PARSER)>
+input.TokenStream.ToString(
+  input.TreeAdaptor.GetTokenStartIndex(retval.Start),
+  input.TreeAdaptor.GetTokenStopIndex(retval.Start))
+<else>
+input.ToString(retval.Start,input.LT(-1))
+<endif>
+%>
+rulePropertyRef_st(scope,attr) ::= "retval.Template"
+
+lexerRulePropertyRef_text(scope,attr) ::= "Text"
+lexerRulePropertyRef_type(scope,attr) ::= "_type"
+lexerRulePropertyRef_line(scope,attr) ::= "state.tokenStartLine"
+lexerRulePropertyRef_pos(scope,attr) ::= "state.tokenStartCharPositionInLine"
+lexerRulePropertyRef_index(scope,attr) ::= "-1" // undefined token index in lexer
+lexerRulePropertyRef_channel(scope,attr) ::= "_channel"
+lexerRulePropertyRef_start(scope,attr) ::= "state.tokenStartCharIndex"
+lexerRulePropertyRef_stop(scope,attr) ::= "(CharIndex-1)"
+lexerRulePropertyRef_int(scope,attr) ::= "int.Parse(<scope>.Text)"
+
+// setting $st and $tree is allowed in local rule. everything else
+// is flagged as error
+ruleSetPropertyRef_tree(scope,attr,expr) ::= "retval.Tree = <expr>;"
+ruleSetPropertyRef_st(scope,attr,expr) ::= "retval.Template =<expr>;"
+
+/** How to execute an action (only when not backtracking) */
+execAction(action) ::= <%
+<if(backtracking)>
+if (<actions.(actionScope).synpredgate>)<\n>
+{<\n>
+<@indentedAction()><\n>
+}
+<else>
+<action>
+<endif>
+%>
+
+@execAction.indentedAction() ::= <<
+	<action>
+>>
+
+/** How to always execute an action even when backtracking */
+execForcedAction(action) ::= "<action>"
+
+// M I S C (properties, etc...)
+
+bitset(name, words64) ::= <<
+public static readonly BitSet <name> = new BitSet(new ulong[]{<words64:{it|<it>UL};separator=",">});
+>>
+
+codeFileExtension() ::= ".cs"
+
+true_value() ::= "true"
+false_value() ::= "false"
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/Dbg.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/Dbg.stg
new file mode 100644
index 0000000..16f6de2
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/Dbg.stg
@@ -0,0 +1,313 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2007-2008 Johannes Luber
+ * Copyright (c) 2005-2007 Kunle Odutola
+ * Copyright (c) 2011 Sam Harwell
+ * Copyright (c) 2011 Terence Parr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** Template overrides to add debugging to normal Java output;
+ *  If ASTs are built, then you'll also get ASTDbg.stg loaded.
+ */
+
+@outputFile.debugPreprocessor() ::= "#define ANTLR_DEBUG"
+
+@outputFile.imports() ::= <<
+<@super.imports()>
+using Antlr.Runtime.Debug;
+using IOException = System.IO.IOException;
+>>
+
+@genericParser.members() ::= <<
+<if(grammar.grammarIsRoot)>
+public static readonly string[] ruleNames =
+	new string[]
+	{
+		"invalidRule", <grammar.allImportedRules:{rST | "<rST.name>"}; wrap="\n	", separator=", ">
+	};<\n>
+<endif>
+<if(grammar.grammarIsRoot)><! grammar imports other grammar(s) !>
+	int ruleLevel = 0;
+	public virtual int RuleLevel { get { return ruleLevel; } }
+	public virtual void IncRuleLevel() { ruleLevel++; }
+	public virtual void DecRuleLevel() { ruleLevel--; }
+<if(profile)>
+	<ctorForProfilingRootGrammar()>
+<else>
+	<ctorForRootGrammar()>
+<endif>
+<ctorForPredefinedListener()>
+<else><! imported grammar !>
+	public int RuleLevel { get { return <grammar.delegators:{g| <g:delegateName()>}>.RuleLevel; } }
+	public void IncRuleLevel() { <grammar.delegators:{g| <g:delegateName()>}>.IncRuleLevel(); }
+	public void DecRuleLevel() { <grammar.delegators:{g| <g:delegateName()>}>.DecRuleLevel(); }
+	<ctorForDelegateGrammar()>
+<endif>
+<if(profile)>
+public override bool AlreadyParsedRule( IIntStream input, int ruleIndex )
+{
+	int stopIndex = GetRuleMemoization(ruleIndex, input.Index);
+	((Profiler)dbg).ExamineRuleMemoization(input, ruleIndex, stopIndex, <grammar.composite.rootGrammar.recognizerName>.ruleNames[ruleIndex]);
+	return base.AlreadyParsedRule(input, ruleIndex);
+}<\n>
+public override void Memoize( IIntStream input, int ruleIndex, int ruleStartIndex )
+{
+	((Profiler)dbg).Memoize(input, ruleIndex, ruleStartIndex, <grammar.composite.rootGrammar.recognizerName>.ruleNames[ruleIndex]);
+	base.Memoize(input, ruleIndex, ruleStartIndex);
+}<\n>
+<endif>
+protected virtual bool EvalPredicate( bool result, string predicate )
+{
+	dbg.SemanticPredicate( result, predicate );
+	return result;
+}<\n>
+>>
+
+ctorForRootGrammar() ::= <<
+<! bug: can't use <@super.members()> cut-n-paste instead !>
+<! Same except we add port number and profile stuff if root grammar !>
+<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input )
+	: this( input, DebugEventSocketProxy.DefaultDebuggerPort, new RecognizerSharedState() )
+{
+}
+<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input, int port, RecognizerSharedState state )
+	: base( input, state )
+{
+	<createListenerAndHandshake()>
+	<grammar.directDelegates:{g|<g:delegateName()> = new <g.recognizerName>( input, dbg, this.state, this<grammar.delegators:{g|, <g:delegateName()>}> );}; separator="\n">
+	<parserCtorBody()>
+	<@finally()>
+}<\n>
+>>
+
+ctorForProfilingRootGrammar() ::= <<
+<! bug: can't use <@super.members()> cut-n-paste instead !>
+<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input )
+	: this( input, new Profiler(null), new RecognizerSharedState() )
+{
+}
+<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input, IDebugEventListener dbg, RecognizerSharedState state )
+	: base( input, dbg, state )
+{
+	Profiler p = (Profiler)dbg;
+	p.setParser(this);
+	<grammar.directDelegates:
+	 {g|<g:delegateName()> = new <g.recognizerName>( input, dbg, this.state, this<grammar.delegators:{g|, <g:delegateName()>}> );}; separator="\n">
+	<parserCtorBody()>
+	<@finally()>
+}
+<\n>
+>>
+
+/** Basically we don't want to set any dbg listeners are root will have it. */
+ctorForDelegateGrammar() ::= <<
+<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input, IDebugEventListener dbg, RecognizerSharedState state<grammar.delegators:{g|, <g.recognizerName> <g:delegateName()>}> )
+	: base( input, dbg, state )
+{
+	<grammar.directDelegates:
+	 {g|<g:delegateName()> = new <g.recognizerName>( input, this, this.state<grammar.delegators:{g|, <g:delegateName()>}> );}; separator="\n">
+	<parserCtorBody()>
+}<\n>
+>>
+
+ctorForPredefinedListener() ::= <<
+<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input, IDebugEventListener dbg )
+	<@superClassRef>: base( input, dbg, new RecognizerSharedState() )<@end>
+{
+<if(profile)>
+	Profiler p = (Profiler)dbg;
+	p.setParser(this);
+<endif>
+	<grammar.directDelegates:{g|<g:delegateName()> = new <g.recognizerName>(input, dbg, this.state, this<grammar.delegators:{g|, <g:delegateName()>}>);}; separator="\n">
+	<parserCtorBody()>
+	<@finally()>
+}<\n>
+>>
+
+createListenerAndHandshake() ::= <<
+<if(TREE_PARSER)>
+DebugEventSocketProxy proxy = new DebugEventSocketProxy( this, port, input.TreeAdaptor );<\n>
+<else>
+DebugEventSocketProxy proxy = new DebugEventSocketProxy( this, port, null );<\n>
+<endif>
+DebugListener = proxy;
+try
+{
+	proxy.Handshake();
+}
+catch ( IOException ioe )
+{
+	ReportError( ioe );
+}
+>>
+
+@genericParser.superClassName() ::= "Debug<@super.superClassName()>"
+
+/*
+ * Many of the following rules were merged into CSharp2.stg.
+ */
+
+@rule.preamble() ::= <<
+if (RuleLevel == 0)
+	DebugListener.Commence();
+IncRuleLevel();
+>>
+//@rule.preamble() ::= <<
+//try
+//{
+//	dbg.EnterRule( GrammarFileName, "<ruleName>" );
+//	if ( RuleLevel == 0 )
+//	{
+//		dbg.Commence();
+//	}
+//	IncRuleLevel();
+//	dbg.Location( <ruleDescriptor.tree.line>, <ruleDescriptor.tree.charPositionInLine> );<\n>
+//>>
+
+@rule.postamble() ::= <<
+DecRuleLevel();
+if (RuleLevel == 0)
+	DebugListener.Terminate();
+>>
+//@rule.postamble() ::= <<
+//dbg.Location(<ruleDescriptor.EORNode.line>, <ruleDescriptor.EORNode.charPositionInLine>);<\n>
+//}
+//finally
+//{
+//	dbg.ExitRule( GrammarFileName, "<ruleName>" );
+//	DecRuleLevel();
+//	if ( RuleLevel == 0 )
+//	{
+//		dbg.Terminate();
+//	}
+//}<\n>
+//>>
+
+//@insertSynpreds.start() ::= "dbg.BeginBacktrack( state.backtracking );"
+//@insertSynpreds.stop() ::= "dbg.EndBacktrack( state.backtracking, success );"
+
+// Common debug event triggers used by region overrides below
+
+//enterSubRule() ::= <<
+//try
+//{
+//	dbg.EnterSubRule( <decisionNumber> );<\n>
+//>>
+
+//exitSubRule() ::= <<
+//}
+//finally
+//{
+//	dbg.ExitSubRule( <decisionNumber> );
+//}<\n>
+//>>
+
+//enterDecision() ::= <<
+//try
+//{
+//	dbg.EnterDecision( <decisionNumber> );<\n>
+//>>
+
+//exitDecision() ::= <<
+//}
+//finally
+//{
+//	dbg.ExitDecision( <decisionNumber> );
+//}<\n>
+//>>
+
+//enterAlt(n) ::= "dbg.EnterAlt( <n> );<\n>"
+
+// Region overrides that tell various constructs to add debugging triggers
+
+//@block.predecision() ::= "<enterSubRule()><enterDecision()>"
+
+//@block.postdecision() ::= "<exitDecision()>"
+
+//@block.postbranch() ::= "<exitSubRule()>"
+
+//@ruleBlock.predecision() ::= "<enterDecision()>"
+
+//@ruleBlock.postdecision() ::= "<exitDecision()>"
+
+//@ruleBlockSingleAlt.prealt() ::= "<enterAlt(n=\"1\")>"
+
+//@blockSingleAlt.prealt() ::= "<enterAlt(n=\"1\")>"
+
+//@positiveClosureBlock.preloop() ::= "<enterSubRule()>"
+
+//@positiveClosureBlock.postloop() ::= "<exitSubRule()>"
+
+//@positiveClosureBlock.predecision() ::= "<enterDecision()>"
+
+//@positiveClosureBlock.postdecision() ::= "<exitDecision()>"
+
+//@positiveClosureBlock.earlyExitException() ::=
+//	"dbg.RecognitionException( eee<decisionNumber> );<\n>"
+
+//@closureBlock.preloop() ::= "<enterSubRule()>"
+
+//@closureBlock.postloop() ::= "<exitSubRule()>"
+
+//@closureBlock.predecision() ::= "<enterDecision()>"
+
+//@closureBlock.postdecision() ::= "<exitDecision()>"
+
+//@altSwitchCase.prealt() ::= "<enterAlt(n=i)>"
+
+//@element.prematch() ::=
+//	"dbg.Location( <it.line>, <it.pos> );"
+
+//@matchSet.mismatchedSetException() ::=
+//	"dbg.RecognitionException( mse );"
+
+//@dfaState.noViableAltException() ::= "dbg.RecognitionException( nvae );"
+
+//@dfaStateSwitch.noViableAltException() ::= "dbg.RecognitionException( nvae );"
+
+//dfaDecision(decisionNumber,description) ::= <<
+//try
+//{
+//	isCyclicDecision = true;
+//	<super.dfaDecision(...)>
+//}
+//catch ( NoViableAltException nvae )
+//{
+//	dbg.RecognitionException( nvae );
+//	throw nvae;
+//}
+//>>
+
+//@cyclicDFA.errorMethod() ::= <<
+//public override void Error( NoViableAltException nvae )
+//{
+//	((DebugParser)recognizer).dbg.RecognitionException( nvae );
+//}
+//>>
+
+/** Force predicate validation to trigger an event */
+evalPredicate(pred,description) ::= <<
+EvalPredicate(<pred>, "<description>")
+>>
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ST.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ST.stg
new file mode 100644
index 0000000..d6dd973
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp2/ST.stg
@@ -0,0 +1,171 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2007-2008 Johannes Luber
+ * Copyright (c) 2005-2007 Kunle Odutola
+ * Copyright (c) 2011 Sam Harwell
+ * Copyright (c) 2011 Terence Parr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** Template subgroup to add template rewrite output
+ *  If debugging, then you'll also get STDbg.stg loaded.
+ */
+
+@outputFile.imports() ::= <<
+<@super.imports()>
+using Antlr.StringTemplate;
+using Antlr.StringTemplate.Language;
+<if(!backtracking)>
+using Hashtable = System.Collections.Hashtable;
+<endif>
+
+>>
+
+/** Add this to each rule's return value struct */
+@returnScope.ruleReturnMembers() ::= <<
+private StringTemplate _st;
+public StringTemplate Template { get { return _st; } set { _st = value; } }
+public override string ToString() { return (Template==null) ? string.Empty : Template.ToString(); }
+>>
+
+@genericParser.members() ::= <<
+<@super.members()>
+protected StringTemplateGroup templateLib = new StringTemplateGroup("<name>Templates", typeof(AngleBracketTemplateLexer) );
+
+public StringTemplateGroup TemplateLib
+{
+ 	get { return this.templateLib; }
+ 	set { this.templateLib = value; }
+}
+
+/// \<summary> Allows convenient multi-value initialization:
+///  "new STAttrMap().Add(...).Add(...)"
+/// \</summary>
+protected class STAttrMap : Hashtable
+{
+  public STAttrMap Add(string attrName, object value)
+  {
+    base.Add(attrName, value);
+    return this;
+  }
+  public STAttrMap Add(string attrName, int value)
+  {
+    base.Add(attrName, value);
+    return this;
+  }
+}
+>>
+
+/** x+=rule when output=template */
+ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRef(...)>
+<listLabel(elem=label+".Template",...)>
+>>
+
+rewriteTemplate(alts) ::= <<
+
+// TEMPLATE REWRITE
+<if(backtracking)>
+if ( <actions.(actionScope).synpredgate> )
+{
+  <alts:rewriteTemplateAlt(); separator="else ">
+  <if(rewriteMode)><replaceTextInLine()><endif>
+}
+<else>
+<alts:rewriteTemplateAlt(); separator="else ">
+<if(rewriteMode)><replaceTextInLine()><endif>
+<endif>
+>>
+
+replaceTextInLine() ::= <<
+<if(TREE_PARSER)>
+((TokenRewriteStream)input.TokenStream).Replace(
+  input.TreeAdaptor.GetTokenStartIndex(retval.Start),
+  input.TreeAdaptor.GetTokenStopIndex(retval.Start),
+  retval.Template);
+<else>
+((TokenRewriteStream)input).Replace(
+  ((IToken)retval.Start).TokenIndex,
+  input.LT(-1).TokenIndex,
+  retval.Template);
+<endif>
+>>
+
+rewriteTemplateAlt() ::= <<
+// <it.description>
+<if(it.pred)>
+if (<it.pred>) {
+    retval.Template = <it.alt>;
+}<\n>
+<else>
+{
+    retval.Template = <it.alt>;
+}<\n>
+<endif>
+>>
+
+rewriteEmptyTemplate(alts) ::= <<
+null;
+>>
+
+/** Invoke a template with a set of attribute name/value pairs.
+ *  Set the value of the rule's template *after* having set
+ *  the attributes because the rule's template might be used as
+ *  an attribute to build a bigger template; you get a self-embedded
+ *  template.
+ */
+rewriteExternalTemplate(name,args) ::= <<
+templateLib.GetInstanceOf("<name>"<if(args)>,
+  new STAttrMap()<args:{a | .Add("<a.name>", <a.value>)}>
+  <endif>)
+>>
+
+/** expr is a string expression that says what template to load */
+rewriteIndirectTemplate(expr,args) ::= <<
+templateLib.GetInstanceOf(<expr><if(args)>,
+  new STAttrMap()<args:{a | .Add("<a.name>", <a.value>)}>
+  <endif>)
+>>
+
+/** Invoke an inline template with a set of attribute name/value pairs */
+rewriteInlineTemplate(args, template) ::= <<
+new StringTemplate(templateLib, "<template>"<if(args)>,
+  new STAttrMap()<args:{a | .Add("<a.name>", <a.value>)}>
+  <endif>)
+>>
+
+/** plain -> {foo} action */
+rewriteAction(action) ::= <<
+<action>
+>>
+
+/** An action has %st.attrName=expr; or %{st}.attrName=expr; */
+actionSetAttribute(st,attrName,expr) ::= <<
+(<st>).SetAttribute("<attrName>",<expr>);
+>>
+
+/** Translate %{stringExpr} */
+actionStringConstructor(stringExpr) ::= <<
+new StringTemplate(templateLib,<stringExpr>)
+>>
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/AST.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/AST.stg
new file mode 100644
index 0000000..5eba4ed
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/AST.stg
@@ -0,0 +1,428 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2011 Terence Parr
+ * All rights reserved.
+ *
+ * Conversion to C#:
+ * Copyright (c) 2011 Sam Harwell, Pixel Mine, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+@outputFile.imports() ::= <<
+<@super.imports()>
+
+<if(!TREE_PARSER)>
+<! tree parser would already have imported !>
+using Antlr.Runtime.Tree;
+using RewriteRuleITokenStream = Antlr.Runtime.Tree.RewriteRuleTokenStream;
+<endif>
+>>
+
+@genericParser.members() ::= <<
+<@super.members()>
+<parserMembers()>
+>>
+
+parserCtorBody() ::= <<
+<super.parserCtorBody()>
+<treeAdaptorType()> treeAdaptor = default(<treeAdaptorType()>);
+CreateTreeAdaptor(ref treeAdaptor);
+TreeAdaptor = treeAdaptor<if(!actions.(actionScope).treeAdaptorType)> ?? new CommonTreeAdaptor()<endif>;
+>>
+
+/** Add an adaptor property that knows how to build trees */
+parserMembers() ::= <<
+// Implement this function in your helper file to use a custom tree adaptor
+partial void CreateTreeAdaptor(ref <treeAdaptorType()> adaptor);
+
+private <treeAdaptorType()> adaptor;
+
+public <treeAdaptorType()> TreeAdaptor
+{
+	get
+	{
+		return adaptor;
+	}
+
+	set
+	{
+		this.adaptor = value;
+		<grammar.directDelegates:{g|<g:delegateName()>.TreeAdaptor = this.adaptor;}>
+	}
+}
+>>
+
+treeAdaptorType() ::= <<
+<actions.(actionScope).treeAdaptorType; null="ITreeAdaptor">
+>>
+
+ruleReturnBaseType() ::= <%
+Ast<if(TREE_PARSER)>Tree<else>Parser<endif>RuleReturnScope\<<ASTLabelType>, <labelType>>
+%>
+
+/** Add a variable to track rule's return AST */
+ruleDeclarations() ::= <<
+<super.ruleDeclarations()>
+<ASTLabelType> root_0 = default(<ASTLabelType>);<\n>
+>>
+
+ruleLabelDefs(ruleDescriptor, labelType, ASTLabelType, rewriteElementType) ::= <%
+<super.ruleLabelDefs(...)>
+<if(!ruleDescriptor.isSynPred)>
+<[ruleDescriptor.tokenLabels,ruleDescriptor.wildcardTreeLabels,ruleDescriptor.wildcardTreeListLabels]
+	:{it|<\n><ASTLabelType> <it.label.text>_tree = default(<ASTLabelType>);}>
+<ruleDescriptor.tokenListLabels:{it|<\n><ASTLabelType> <it.label.text>_tree = default(<ASTLabelType>);}>
+<ruleDescriptor.allTokenRefsInAltsWithRewrites
+	:{it|<\n>RewriteRule<rewriteElementType>Stream stream_<it>=new RewriteRule<rewriteElementType>Stream(adaptor,"token <it>");}>
+<ruleDescriptor.allRuleRefsInAltsWithRewrites
+	:{it|<\n>RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"rule <it>");}>
+<endif>
+%>
+
+/** When doing auto AST construction, we must define some variables;
+ *  These should be turned off if doing rewrites.  This must be a "mode"
+ *  as a rule could have both rewrite and AST within the same alternative
+ *  block.
+ */
+@alt.declarations() ::= <<
+<if(autoAST && outerAlt && !rewriteMode && !ruleDescriptor.isSynPred)>
+root_0 = (<ASTLabelType>)adaptor.Nil();
+<endif>
+>>
+
+// T r a c k i n g  R u l e  E l e m e n t s
+
+/** ID and track it for use in a rewrite rule */
+tokenRefTrack(token,label,elementIndex,terminalOptions) ::= <<
+<tokenRefBang(...)> <! Track implies no auto AST construction!>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>stream_<token>.Add(<label>);<\n>
+>>
+
+/** ids+=ID and track it for use in a rewrite rule; adds to ids *and*
+ *  to the tracking list stream_ID for use in the rewrite.
+ */
+tokenRefTrackAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<tokenRefTrack(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** ^(ID ...) track for rewrite */
+tokenRefRuleRootTrack(token,label,elementIndex,terminalOptions) ::= <<
+<tokenRefBang(...)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>stream_<token>.Add(<label>);
+>>
+
+/** Match ^(label+=TOKEN ...) track for rewrite */
+tokenRefRuleRootTrackAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<tokenRefRuleRootTrack(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** rule when output=AST and tracking for rewrite */
+ruleRefTrack(rule,label,elementIndex,args,scope) ::= <<
+<super.ruleRef(...)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>stream_<rule.name>.Add(<label>.Tree);
+>>
+
+/** x+=rule when output=AST and tracking for rewrite */
+ruleRefTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefTrack(...)>
+<listLabelElem(elem={<label>.Tree},elemType=ASTLabelType,...)>
+>>
+
+/** ^(rule ...) rewrite */
+ruleRefRuleRootTrack(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefRuleRoot(...)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>stream_<rule>.Add(<label>.Tree);
+>>
+
+/** ^(x+=rule ...) rewrite */
+ruleRefRuleRootTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefRuleRootTrack(...)>
+<listLabelElem(elem={<label>.Tree},elemType=ASTLabelType,...)>
+>>
+
+// R e w r i t e
+
+rewriteCode(
+	alts, description,
+	referencedElementsDeep, // ALL referenced elements to right of ->
+	referencedTokenLabels,
+	referencedTokenListLabels,
+	referencedRuleLabels,
+	referencedRuleListLabels,
+	referencedWildcardLabels,
+	referencedWildcardListLabels,
+	rewriteBlockLevel, enclosingTreeLevel, treeLevel) ::= <<
+<\n>{
+// AST REWRITE
+// elements: <referencedElementsDeep; separator=", ">
+// token labels: <referencedTokenLabels; separator=", ">
+// rule labels: <referencedRuleLabels; separator=", ">
+// token list labels: <referencedTokenListLabels; separator=", ">
+// rule list labels: <referencedRuleListLabels; separator=", ">
+// wildcard labels: <[referencedWildcardLabels,referencedWildcardListLabels]; separator=", ">
+<if(backtracking)>
+if (<actions.(actionScope).synpredgate>) {
+<endif>
+<prevRuleRootRef()>.Tree = root_0;
+<rewriteCodeLabels()>
+root_0 = (<ASTLabelType>)adaptor.Nil();
+<alts:rewriteAlt(); separator="else ">
+<! if tree parser and rewrite=true !>
+<if(TREE_PARSER&&rewriteMode)>
+<prevRuleRootRef()>.Tree = (<ASTLabelType>)adaptor.RulePostProcessing(root_0);
+if (<prevRuleRootRef()>.Tree != null)
+	input.ReplaceChildren(adaptor.GetParent(retval.Start), adaptor.GetChildIndex(retval.Start), adaptor.GetChildIndex(_last), retval.Tree);
+<endif>
+<! if parser or tree-parser && rewrite!=true, we need to set result !>
+<if(!TREE_PARSER||!rewriteMode)>
+<prevRuleRootRef()>.Tree = root_0;
+<endif>
+<if(backtracking)>
+}
+<endif>
+}
+
+>>
+
+rewriteCodeLabels() ::= <<
+<referencedTokenLabels
+    :{it|RewriteRule<rewriteElementType>Stream stream_<it>=new RewriteRule<rewriteElementType>Stream(adaptor,"token <it>",<it>);};
+    separator="\n"
+>
+<referencedTokenListLabels
+    :{it|RewriteRule<rewriteElementType>Stream stream_<it>=new RewriteRule<rewriteElementType>Stream(adaptor,"token <it>", list_<it>);};
+    separator="\n"
+>
+<referencedWildcardLabels
+	:{it|RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"wildcard <it>",<it>);};
+	separator="\n"
+>
+<referencedWildcardListLabels
+	:{it|RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"wildcard <it>",list_<it>);};
+	separator="\n"
+>
+<referencedRuleLabels
+    :{it|RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"rule <it>",<it>!=null?<it>.Tree:null);};
+    separator="\n"
+>
+<referencedRuleListLabels
+    :{it|RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"token <it>",list_<it>);};
+    separator="\n"
+>
+>>
+
+/** Generate code for an optional rewrite block; note it uses the deep ref'd element
+  *  list rather shallow like other blocks.
+  */
+rewriteOptionalBlock(
+	alt,rewriteBlockLevel,
+	referencedElementsDeep, // all nested refs
+	referencedElements, // elements in immediately block; no nested blocks
+	description) ::=
+<<
+// <fileName>:<description>
+if (<referencedElementsDeep:{el | stream_<el>.HasNext}; separator="||">)
+{
+	<alt>
+}
+<referencedElementsDeep:{el | stream_<el>.Reset();<\n>}>
+>>
+
+rewriteClosureBlock(
+	alt,rewriteBlockLevel,
+	referencedElementsDeep, // all nested refs
+	referencedElements, // elements in immediately block; no nested blocks
+	description) ::=
+<<
+// <fileName>:<description>
+while ( <referencedElements:{el | stream_<el>.HasNext}; separator="||"> )
+{
+	<alt>
+}
+<referencedElements:{el | stream_<el>.Reset();<\n>}>
+>>
+
+rewritePositiveClosureBlock(
+	alt,rewriteBlockLevel,
+	referencedElementsDeep, // all nested refs
+	referencedElements, // elements in immediately block; no nested blocks
+	description) ::=
+<<
+if (!(<referencedElements:{el | stream_<el>.HasNext}; separator="||">))
+{
+	throw new RewriteEarlyExitException();
+}
+while ( <referencedElements:{el | stream_<el>.HasNext}; separator="||"> )
+{
+	<alt>
+}
+<referencedElements:{el | stream_<el>.Reset();<\n>}>
+>>
+
+rewriteAlt(a) ::= <<
+// <a.description>
+<if(a.pred)>
+if (<a.pred>)
+{
+	<a.alt>
+}
+<else>
+{
+	<a.alt>
+}
+<endif>
+>>
+
+/** For empty rewrites: "r : ... -> ;" */
+rewriteEmptyAlt() ::= "root_0 = null;"
+
+rewriteTree(root,children,description,enclosingTreeLevel,treeLevel) ::= <<
+// <fileName>:<description>
+{
+<ASTLabelType> root_<treeLevel> = (<ASTLabelType>)adaptor.Nil();
+<root:rewriteElement()>
+<children:rewriteElement()>
+adaptor.AddChild(root_<enclosingTreeLevel>, root_<treeLevel>);
+}<\n>
+>>
+
+rewriteElementList(elements) ::= "<elements:rewriteElement()>"
+
+rewriteElement(e) ::= <%
+<@pregen()>
+DebugLocation(<e.line>, <e.pos>);<\n>
+<e.el>
+%>
+
+/** Gen ID or ID[args] */
+rewriteTokenRef(token,elementIndex,terminalOptions,args) ::= <<
+adaptor.AddChild(root_<treeLevel>, <createRewriteNodeFromElement(...)>);<\n>
+>>
+
+/** Gen $label ... where defined via label=ID */
+rewriteTokenLabelRef(label,elementIndex) ::= <<
+adaptor.AddChild(root_<treeLevel>, stream_<label>.NextNode());<\n>
+>>
+
+/** Gen $label ... where defined via label+=ID */
+rewriteTokenListLabelRef(label,elementIndex) ::= <<
+adaptor.AddChild(root_<treeLevel>, stream_<label>.NextNode());<\n>
+>>
+
+/** Gen ^($label ...) */
+rewriteTokenLabelRefRoot(label,elementIndex) ::= <<
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(stream_<label>.NextNode(), root_<treeLevel>);<\n>
+>>
+
+/** Gen ^($label ...) where label+=... */
+rewriteTokenListLabelRefRoot ::= rewriteTokenLabelRefRoot
+
+/** Gen ^(ID ...) or ^(ID[args] ...) */
+rewriteTokenRefRoot(token,elementIndex,terminalOptions,args) ::= <<
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<createRewriteNodeFromElement(...)>, root_<treeLevel>);<\n>
+>>
+
+rewriteImaginaryTokenRef(args,token,terminalOptions,elementIndex) ::= <<
+adaptor.AddChild(root_<treeLevel>, <createImaginaryNode(tokenType=token, ...)>);<\n>
+>>
+
+rewriteImaginaryTokenRefRoot(args,token,terminalOptions,elementIndex) ::= <<
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<createImaginaryNode(tokenType=token, ...)>, root_<treeLevel>);<\n>
+>>
+
+/** plain -> {foo} action */
+rewriteAction(action) ::= <<
+root_0 = <action>;<\n>
+>>
+
+/** What is the name of the previous value of this rule's root tree?  This
+ *  let's us refer to $rule to mean previous value.  I am reusing the
+ *  variable 'tree' sitting in retval struct to hold the value of root_0 right
+ *  before I set it during rewrites.  The assign will be to retval.tree.
+ */
+prevRuleRootRef() ::= "retval"
+
+rewriteRuleRef(rule) ::= <<
+adaptor.AddChild(root_<treeLevel>, stream_<rule>.NextTree());<\n>
+>>
+
+rewriteRuleRefRoot(rule) ::= <<
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(stream_<rule>.NextNode(), root_<treeLevel>);<\n>
+>>
+
+rewriteNodeAction(action) ::= <<
+adaptor.AddChild(root_<treeLevel>, <action>);<\n>
+>>
+
+rewriteNodeActionRoot(action) ::= <<
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<action>, root_<treeLevel>);<\n>
+>>
+
+/** Gen $ruleLabel ... where defined via ruleLabel=rule */
+rewriteRuleLabelRef(label) ::= <<
+adaptor.AddChild(root_<treeLevel>, stream_<label>.NextTree());<\n>
+>>
+
+/** Gen $ruleLabel ... where defined via ruleLabel+=rule */
+rewriteRuleListLabelRef(label) ::= <<
+adaptor.AddChild(root_<treeLevel>, stream_<label>.NextTree());<\n>
+>>
+
+/** Gen ^($ruleLabel ...) where ruleLabel=rule */
+rewriteRuleLabelRefRoot(label) ::= <<
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(stream_<label>.NextNode(), root_<treeLevel>);<\n>
+>>
+
+/** Gen ^($ruleLabel ...) where ruleLabel+=rule */
+rewriteRuleListLabelRefRoot(label) ::= <<
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(stream_<label>.NextNode(), root_<treeLevel>);<\n>
+>>
+
+rewriteWildcardLabelRef(label) ::= <<
+adaptor.AddChild(root_<treeLevel>, stream_<label>.NextTree());<\n>
+>>
+
+createImaginaryNode(tokenType,terminalOptions,args) ::= <%
+<if(terminalOptions.node)>
+<! new MethodNode(IDLabel, args) !>
+new <terminalOptions.node>(<tokenType><if(args)>, <args; separator=", "><endif>)
+<else>
+(<ASTLabelType>)adaptor.Create(<tokenType>, <args; separator=", "><if(!args)>"<tokenType>"<endif>)
+<endif>
+%>
+
+createRewriteNodeFromElement(token,terminalOptions,args) ::= <%
+<if(terminalOptions.node)>
+new <terminalOptions.node>(stream_<token>.NextToken()<if(args)>, <args; separator=", "><endif>)
+<else>
+<if(args)> <! must create new node from old !>
+adaptor.Create(<token>, <args; separator=", ">)
+<else>
+stream_<token>.NextNode()
+<endif>
+<endif>
+%>
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/ASTDbg.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/ASTDbg.stg
new file mode 100644
index 0000000..35d1629
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/ASTDbg.stg
@@ -0,0 +1,98 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2005-2008 Terence Parr
+ * All rights reserved.
+ *
+ * Conversion to C#:
+ * Copyright (c) 2008-2009 Sam Harwell, Pixel Mine, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** Template overrides to add debugging to AST stuff.  Dynamic inheritance
+ *  hierarchy is set up as ASTDbg : AST : Dbg : Java by code generator.
+ */
+
+parserMembers() ::= <<
+// Implement this function in your helper file to use a custom tree adaptor
+partial void InitializeTreeAdaptor();
+protected DebugTreeAdaptor adaptor;
+
+public ITreeAdaptor TreeAdaptor
+{
+	get
+	{
+		return adaptor;
+	}
+	set
+	{
+<if(grammar.grammarIsRoot)>
+		this.adaptor = new DebugTreeAdaptor(dbg,adaptor);
+<else>
+		this.adaptor = (DebugTreeAdaptor)adaptor; // delegator sends dbg adaptor
+<endif><\n>
+		<grammar.directDelegates:{g|<g:delegateName()>.TreeAdaptor = this.adaptor;}>
+	}
+}<\n>
+>>
+
+parserCtorBody() ::= <<
+<super.parserCtorBody()>
+>>
+
+createListenerAndHandshake() ::= <<
+DebugEventSocketProxy proxy = new DebugEventSocketProxy( this, port, <if(TREE_PARSER)>input.TreeAdaptor<else>adaptor<endif> );
+DebugListener = proxy;
+<inputStreamType> = new Debug<inputStreamType>( input, proxy );
+try
+{
+	proxy.Handshake();
+}
+catch ( IOException ioe )
+{
+	ReportError( ioe );
+}
+>>
+
+@ctorForRootGrammar.finally() ::= <<
+ITreeAdaptor adap = new CommonTreeAdaptor();
+TreeAdaptor = adap;
+proxy.TreeAdaptor = adap;
+>>
+
+@ctorForProfilingRootGrammar.finally() ::=<<
+ITreeAdaptor adap = new CommonTreeAdaptor();
+TreeAdaptor = adap;
+>>
+
+@ctorForPredefinedListener.superClassRef() ::= ": base( input, dbg )"
+
+@ctorForPredefinedListener.finally() ::=<<
+<if(grammar.grammarIsRoot)><! don't create new adaptor for delegates !>
+ITreeAdaptor adap = new CommonTreeAdaptor();
+TreeAdaptor = adap;<\n>
+<endif>
+>>
+
+//@rewriteElement.pregen() ::= "dbg.Location( <e.line>, <e.pos> );"
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/ASTParser.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/ASTParser.stg
new file mode 100644
index 0000000..8b507c7
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/ASTParser.stg
@@ -0,0 +1,203 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2011 Terence Parr
+ * All rights reserved.
+ *
+ * Conversion to C#:
+ * Copyright (c) 2011 Sam Harwell, Pixel Mine, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** Templates for building ASTs during normal parsing.
+ *
+ *  Deal with many combinations.  Dimensions are:
+ *  Auto build or rewrite
+ *    no label, label, list label  (label/no-label handled together)
+ *    child, root
+ *    token, set, rule, wildcard
+ *
+ *  The situation is not too bad as rewrite (->) usage makes ^ and !
+ *  invalid. There is no huge explosion of combinations.
+ */
+
+@rule.setErrorReturnValue() ::= <<
+retval.Tree = (<ASTLabelType>)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
+<! System.out.WriteLine("<ruleName> returns "+((CommonTree)retval.tree).toStringTree()); !>
+>>
+
+// TOKEN AST STUFF
+
+/** ID and output=AST */
+tokenRef(token,label,elementIndex,terminalOptions) ::= <%
+<super.tokenRef(...)>
+<if(!ruleDescriptor.isSynPred)>
+<if(backtracking)><\n>if (state.backtracking == 0) {<endif>
+<\n><label>_tree = <createNodeFromToken(...)>;
+<\n>adaptor.AddChild(root_0, <label>_tree);
+<if(backtracking)><\n>}<endif>
+<endif>
+%>
+
+/** ID! and output=AST (same as plain tokenRef) */
+tokenRefBang(token,label,elementIndex,terminalOptions) ::= "<super.tokenRef(...)>"
+
+/** ID^ and output=AST */
+tokenRefRuleRoot(token,label,elementIndex,terminalOptions) ::= <%
+<super.tokenRef(...)>
+<if(!ruleDescriptor.isSynPred)>
+<if(backtracking)><\n>if (<actions.(actionScope).synpredgate>) {<endif>
+<\n><label>_tree = <createNodeFromToken(...)>;
+<\n>root_0 = (<ASTLabelType>)adaptor.BecomeRoot(<label>_tree, root_0);
+<if(backtracking)><\n>}<endif>
+<endif>
+%>
+
+/** ids+=ID! and output=AST */
+tokenRefBangAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<tokenRefBang(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** label+=TOKEN when output=AST but not rewrite alt */
+tokenRefAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<tokenRef(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** Match label+=TOKEN^ when output=AST but not rewrite alt */
+tokenRefRuleRootAndListLabel(token,label,terminalOptions,elementIndex) ::= <<
+<tokenRefRuleRoot(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+// SET AST
+
+// the match set stuff is interesting in that it uses an argument list
+// to pass code to the default matchSet; another possible way to alter
+// inherited code.  I don't use the region stuff because I need to pass
+// different chunks depending on the operator.  I don't like making
+// the template name have the operator as the number of templates gets
+// large but this is the most flexible--this is as opposed to having
+// the code generator call matchSet then add root code or ruleroot code
+// plus list label plus ...  The combinations might require complicated
+// rather than just added on code.  Investigate that refactoring when
+// I have more time.
+
+matchSet(s,label,terminalOptions,elementIndex,postmatchCode) ::= <<
+<super.matchSet(postmatchCode={<if(!ruleDescriptor.isSynPred)><if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>adaptor.AddChild(root_0, <createNodeFromToken(...)>);<endif>}, ...)>
+>>
+
+matchRuleBlockSet(s,label,terminalOptions,elementIndex,postmatchCode,treeLevel="0") ::= <<
+<matchSet(...)>
+>>
+
+matchSetBang(s,label,elementIndex,terminalOptions,postmatchCode) ::= "<super.matchSet(...)>"
+
+// note there is no matchSetTrack because -> rewrites force sets to be
+// plain old blocks of alts: (A|B|...|C)
+
+matchSetRuleRoot(s,label,terminalOptions,elementIndex,debug) ::= <<
+<if(label)>
+<label>=(<labelType>)input.LT(1);
+<endif>
+<super.matchSet(postmatchCode={<if(!ruleDescriptor.isSynPred)><if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>root_0 = (<ASTLabelType>)adaptor.BecomeRoot(<createNodeFromToken(...)>, root_0);<endif>}, ...)>
+>>
+
+// RULE REF AST
+
+/** rule when output=AST */
+ruleRef(rule,label,elementIndex,args,scope) ::= <%
+<super.ruleRef(...)>
+<if(!ruleDescriptor.isSynPred)>
+<\n><if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>adaptor.AddChild(root_0, <label>.Tree);
+<endif>
+%>
+
+/** rule! is same as normal rule ref */
+ruleRefBang(rule,label,elementIndex,args,scope) ::= "<super.ruleRef(...)>"
+
+/** rule^ */
+ruleRefRuleRoot(rule,label,elementIndex,args,scope) ::= <<
+<super.ruleRef(...)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>root_0 = (<ASTLabelType>)adaptor.BecomeRoot(<label>.Tree, root_0);
+>>
+
+/** x+=rule when output=AST */
+ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRef(...)>
+<listLabelElem(elem={<label>.Tree},elemType=ASTLabelType,...)>
+>>
+
+/** x+=rule! when output=AST is a rule ref with list addition */
+ruleRefBangAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefBang(...)>
+<listLabelElem(elem={<label>.Tree},elemType=ASTLabelType,...)>
+>>
+
+/** x+=rule^ */
+ruleRefRuleRootAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRefRuleRoot(...)>
+<listLabelElem(elem={<label>.Tree},elemType=ASTLabelType,...)>
+>>
+
+// WILDCARD AST
+
+wildcard(token,label,elementIndex,terminalOptions) ::= <<
+<super.wildcard(...)>
+<if(!ruleDescriptor.isSynPred)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<label>_tree = (<ASTLabelType>)adaptor.Create(<label>);
+adaptor.AddChild(root_0, <label>_tree);
+<if(backtracking)>}<endif>
+<endif>
+>>
+
+wildcardBang(label,elementIndex) ::= "<super.wildcard(...)>"
+
+wildcardRuleRoot(token,label,elementIndex,terminalOptions) ::= <<
+<super.wildcard(...)>
+<if(!ruleDescriptor.isSynPred)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<label>_tree = (<ASTLabelType>)adaptor.Create(<label>);
+root_0 = (<ASTLabelType>)adaptor.BecomeRoot(<label>_tree, root_0);
+<if(backtracking)>}<endif>
+<endif>
+>>
+
+createNodeFromToken(label,terminalOptions) ::= <%
+<if(terminalOptions.node)>
+new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>)
+<else>
+(<ASTLabelType>)adaptor.Create(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>)
+<endif>
+%>
+
+ruleCleanUp() ::= <<
+<super.ruleCleanUp()>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+retval.Tree = (<ASTLabelType>)adaptor.RulePostProcessing(root_0);
+adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+<if(backtracking)>}<endif>
+>>
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/ASTTreeParser.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/ASTTreeParser.stg
new file mode 100644
index 0000000..676ba00
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/ASTTreeParser.stg
@@ -0,0 +1,377 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2011 Terence Parr
+ * All rights reserved.
+ *
+ * Conversion to C#:
+ * Copyright (c) 2011 Sam Harwell, Pixel Mine, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** Templates for building ASTs during tree parsing.
+ *
+ *  Deal with many combinations.  Dimensions are:
+ *  Auto build or rewrite
+ *    no label, label, list label  (label/no-label handled together)
+ *    child, root
+ *    token, set, rule, wildcard
+ *
+ *  Each combination has its own template except that label/no label
+ *  is combined into tokenRef, ruleRef, ...
+ */
+
+/** Add a variable to track last element matched */
+ruleDeclarations() ::= <<
+<super.ruleDeclarations()>
+<if(!ruleDescriptor.isSynPred)>
+<ASTLabelType> _first_0 = default(<ASTLabelType>);
+<ASTLabelType> _last = default(<ASTLabelType>);
+<endif>
+>>
+
+/** What to emit when there is no rewrite rule.  For auto build
+ *  mode, does nothing.
+ */
+noRewrite(rewriteBlockLevel, treeLevel) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<if(rewriteMode)>
+retval.Tree = (<ASTLabelType>)_first_0;
+if (adaptor.GetParent(retval.Tree)!=null && adaptor.IsNil(adaptor.GetParent(retval.Tree)))
+    retval.Tree = (<ASTLabelType>)adaptor.GetParent(retval.Tree);
+<endif>
+<if(backtracking)>}<endif>
+<endif>
+>>
+
+/** match ^(root children) in tree parser; override here to
+ *  add tree construction actions.
+ */
+tree(root, actionsAfterRoot, children, nullableChildList,
+     enclosingTreeLevel, treeLevel) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+{
+<ASTLabelType> _save_last_<treeLevel> = _last;
+<ASTLabelType> _first_<treeLevel> = default(<ASTLabelType>);
+<if(!rewriteMode)>
+<ASTLabelType> root_<treeLevel> = (<ASTLabelType>)adaptor.Nil();
+<endif>
+<root:element()>
+<if(rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>)<endif>
+<if(root.el.rule)>
+if (_first_<enclosingTreeLevel> == null) _first_<enclosingTreeLevel> = <root.el.label>.Tree;
+<else>
+if (_first_<enclosingTreeLevel> == null) _first_<enclosingTreeLevel> = <root.el.label>;
+<endif>
+<endif>
+<actionsAfterRoot:element()>
+<if(nullableChildList)>
+if (input.LA(1) == TokenTypes.Down) {
+    Match(input, TokenTypes.Down, null); <checkRuleBacktrackFailure()>
+    <children:element()>
+    Match(input, TokenTypes.Up, null); <checkRuleBacktrackFailure()>
+}
+<else>
+Match(input, TokenTypes.Down, null); <checkRuleBacktrackFailure()>
+<children:element()>
+Match(input, TokenTypes.Up, null); <checkRuleBacktrackFailure()>
+<endif>
+<if(!rewriteMode)>
+adaptor.AddChild(root_<enclosingTreeLevel>, root_<treeLevel>);
+<endif>
+_last = _save_last_<treeLevel>;
+}
+<else>
+<super.tree(...)>
+<endif>
+>>
+
+// TOKEN AST STUFF
+
+/** ID! and output=AST (same as plain tokenRef) 'cept add
+ *  setting of _last
+ */
+tokenRefBang(token,label,elementIndex,terminalOptions) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.tokenRef(...)>
+<else>
+<super.tokenRefBang(...)>
+<endif>
+>>
+
+/** ID auto construct */
+tokenRef(token,label,elementIndex,terminalOptions) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.tokenRef(...)>
+<if(!rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<if(terminalOptions.node)>
+<label>_tree = new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<else>
+<label>_tree = (<ASTLabelType>)adaptor.DupNode(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<endif><\n>
+adaptor.AddChild(root_<treeLevel>, <label>_tree);
+<if(backtracking)>}<endif>
+<else> <! rewrite mode !>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>)<endif>
+if (_first_<treeLevel> == null) _first_<treeLevel> = <label>;
+<endif>
+<else>
+<super.tokenRef(...)>
+<endif>
+>>
+
+/** label+=TOKEN auto construct */
+tokenRefAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<tokenRef(...)>
+<listLabelElem(elem=label,...)>
+<else>
+<super.tokenRefAndListLabel(...)>
+<endif>
+>>
+
+/** ^(ID ...) auto construct */
+tokenRefRuleRoot(token,label,elementIndex,terminalOptions) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.tokenRef(...)>
+<if(!rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<if(terminalOptions.node)>
+<label>_tree = new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<else>
+<label>_tree = (<ASTLabelType>)adaptor.DupNode(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<endif><\n>
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<label>_tree, root_<treeLevel>);
+<if(backtracking)>}<endif>
+<endif>
+<else>
+<super.tokenRefRuleRoot(...)>
+<endif>
+>>
+
+/** Match ^(label+=TOKEN ...) auto construct */
+tokenRefRuleRootAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<tokenRefRuleRoot(...)>
+<listLabelElem(elem=label,...)>
+<else>
+<super.tokenRefRuleRootAndListLabel(...)>
+<endif>
+>>
+
+/** Match . wildcard and auto dup the node/subtree */
+wildcard(token,label,elementIndex,terminalOptions) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.wildcard(...)>
+<if(!rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<label>_tree = (<ASTLabelType>)adaptor.DupTree(<label>);
+adaptor.AddChild(root_<treeLevel>, <label>_tree);
+<if(backtracking)>}<endif>
+<else> <! rewrite mode !>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>)<endif>
+if (_first_<treeLevel> == null) _first_<treeLevel> = <label>;
+<endif>
+<else>
+<super.wildcard(...)>
+<endif>
+>>
+
+// SET AST
+
+matchSet(s,label,terminalOptions,elementIndex,postmatchCode) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.matchSet(postmatchCode={
+<if(!rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<if(terminalOptions.node)>
+<label>_tree = new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<else>
+<label>_tree = (<ASTLabelType>)adaptor.DupNode(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<endif><\n>
+adaptor.AddChild(root_<treeLevel>, <label>_tree);
+<if(backtracking)>\}<endif>
+<endif>
+}, ...
+)>
+<else>
+<super.matchSet(...)>
+<endif>
+>>
+
+matchRuleBlockSet(s,label,terminalOptions,elementIndex,postmatchCode,treeLevel="0") ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<matchSet(...)>
+<noRewrite(...)> <! set return tree !>
+<else>
+<super.matchRuleBlockSet(...)>
+<endif>
+>>
+
+matchSetBang(s,label,terminalOptions,elementIndex,postmatchCode) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.matchSet(...)>
+<else>
+<super.matchSetBang(...)>
+<endif>
+>>
+
+matchSetRuleRoot(s,label,terminalOptions,elementIndex,debug) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<super.matchSet(postmatchCode={
+<if(!rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+<if(terminalOptions.node)>
+<label>_tree = new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<else>
+<label>_tree = (<ASTLabelType>)adaptor.DupNode(<if(terminalOptions.type)><terminalOptions.type>,<endif><label><if(terminalOptions.text)>,<terminalOptions.text; format="string"><endif>);
+<endif><\n>
+root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<label>_tree, root_<treeLevel>);
+<if(backtracking)>\}<endif>
+<endif>
+}, ...
+)>
+<else>
+<super.matchSetRuleRoot(...)>
+<endif>
+>>
+
+// RULE REF AST
+
+/** rule auto construct */
+ruleRef(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.ruleRef(...)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>)<endif>
+<if(!rewriteMode)>
+adaptor.AddChild(root_<treeLevel>, <label>.Tree);
+<else> <! rewrite mode !>
+if (_first_<treeLevel> == null) _first_<treeLevel> = <label>.Tree;
+<endif>
+<else>
+<super.ruleRef(...)>
+<endif>
+>>
+
+/** x+=rule auto construct */
+ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<ruleRef(...)>
+<listLabelElem(elem={<label>.Tree},...)>
+<else>
+<super.ruleRefAndListLabel(...)>
+<endif>
+>>
+
+/** ^(rule ...) auto construct */
+ruleRefRuleRoot(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.ruleRef(...)>
+<if(!rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) <endif>root_<treeLevel> = (<ASTLabelType>)adaptor.BecomeRoot(<label>.Tree, root_<treeLevel>);
+<endif>
+<else>
+<super.ruleRefRuleRoot(...)>
+<endif>
+>>
+
+/** ^(x+=rule ...) auto construct */
+ruleRefRuleRootAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+<ruleRefRuleRoot(...)>
+<listLabelElem(elem={<label>.Tree},...)>
+<else>
+<super.ruleRefRuleRootAndListLabel(...)>
+<endif>
+>>
+
+/** rule when output=AST and tracking for rewrite */
+ruleRefTrack(rule,label,elementIndex,args,scope) ::= <<
+_last = (<ASTLabelType>)input.LT(1);
+<super.ruleRefTrack(...)>
+>>
+
+/** x+=rule when output=AST and tracking for rewrite */
+ruleRefTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.ruleRefTrackAndListLabel(...)>
+<else>
+<super.ruleRefTrackAndListLabel(...)>
+<endif>
+>>
+
+/** ^(rule ...) rewrite */
+ruleRefRuleRootTrack(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.ruleRefRootTrack(...)>
+<else>
+<super.ruleRefRuleRootTrack(...)>
+<endif>
+>>
+
+/** ^(x+=rule ...) rewrite */
+ruleRefRuleRootTrackAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<if(!ruleDescriptor.isSynPred)>
+_last = (<ASTLabelType>)input.LT(1);
+<super.ruleRefRuleRootTrackAndListLabel(...)>
+<else>
+<super.ruleRefRuleRootTrackAndListLabel(...)>
+<endif>
+>>
+
+/** Streams for token refs are tree nodes now; override to
+ *  change NextToken to NextNode.
+ */
+createRewriteNodeFromElement(token,terminalOptions,args) ::= <%
+<if(terminalOptions.node)>
+new <terminalOptions.node>(<if(terminalOptions.type)><terminalOptions.type>,<endif>stream_<token>.NextNode())
+<else>
+stream_<token>.NextNode()
+<endif>
+%>
+
+ruleCleanUp() ::= <<
+<super.ruleCleanUp()>
+<if(!ruleDescriptor.isSynPred)>
+<if(!rewriteMode)>
+<if(backtracking)>if (<actions.(actionScope).synpredgate>) {<endif>
+retval.Tree = (<ASTLabelType>)adaptor.RulePostProcessing(root_0);
+<if(backtracking)>}<endif>
+<endif>
+<endif>
+>>
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/CSharp3.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/CSharp3.stg
new file mode 100644
index 0000000..bf7ca36
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/CSharp3.stg
@@ -0,0 +1,1749 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2011 Terence Parr
+ * All rights reserved.
+ *
+ * Conversion to C#:
+ * Copyright (c) 2011 Sam Harwell, Pixel Mine, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+csharpVisibilityMap ::= [
+	"private":"private",
+	"protected":"protected",
+	"public":"public",
+	"fragment":"private",
+	default:"private"
+]
+
+/** The overall file structure of a recognizer; stores methods for rules
+ *  and cyclic DFAs plus support code.
+ */
+outputFile(	LEXER,PARSER,TREE_PARSER, actionScope, actions,
+			docComment, recognizer,
+			name, tokens, tokenNames, rules, cyclicDFAs,
+			bitsets, buildTemplate, buildAST, rewriteMode, profile,
+			backtracking, synpreds, memoize, numRules,
+			fileName, ANTLRVersion, generatedTimestamp, trace,
+			scopes, superClass, literals) ::=
+<<
+//------------------------------------------------------------------------------
+// \<auto-generated>
+//     This code was generated by a tool.
+//     ANTLR Version: <ANTLRVersion>
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// \</auto-generated>
+//------------------------------------------------------------------------------
+
+// $ANTLR <ANTLRVersion> <fileName> <generatedTimestamp>
+
+// The variable 'variable' is assigned but its value is never used.
+#pragma warning disable 219
+// Unreachable code detected.
+#pragma warning disable 162
+// Missing XML comment for publicly visible type or member 'Type_or_Member'
+#pragma warning disable 1591
+// CLS compliance checking will not be performed on 'type' because it is not visible from outside this assembly.
+#pragma warning disable 3019
+
+<actions.(actionScope).header>
+
+<@imports>
+using System.Collections.Generic;
+using Antlr.Runtime;
+using Antlr.Runtime.Misc;
+<if(TREE_PARSER)>
+using Antlr.Runtime.Tree;
+using RewriteRuleITokenStream = Antlr.Runtime.Tree.RewriteRuleTokenStream;
+<endif>
+<@end>
+<if(actions.(actionScope).namespace)>
+namespace <actions.(actionScope).namespace>
+{
+<endif>
+<docComment>
+<recognizer>
+<if(actions.(actionScope).namespace)>
+
+} // namespace <actions.(actionScope).namespace>
+<endif>
+>>
+
+lexerInputStreamType() ::= <<
+<actions.(actionScope).inputStreamType; null="ICharStream">
+>>
+
+lexer(grammar, name, tokens, scopes, rules, numRules, filterMode, labelType="CommonToken",
+      superClass={<if(actions.(actionScope).superClass)><actions.(actionScope).superClass><else>Antlr.Runtime.Lexer<endif>},
+	  rewriteElementType={}, ASTLabelType={}) ::= <<
+[System.CodeDom.Compiler.GeneratedCode("ANTLR", "<ANTLRVersion>")]
+[System.CLSCompliant(false)]
+<parserModifier(grammar=grammar, actions=actions)> partial class <grammar.recognizerName> : <@superClassName><superClass><@end>
+{
+	<tokens:{it|public const int <it.name; format="id">=<it.type>;}; separator="\n">
+	<scopes:{it|<if(it.isDynamicGlobalScope)><globalAttributeScope(scope=it)><endif>}>
+	<actions.lexer.members>
+
+    // delegates
+    <grammar.delegates:
+         {g|private <g.recognizerName> <g:delegateName()>;}; separator="\n">
+    // delegators
+    <grammar.delegators:
+         {g|private <g.recognizerName> <g:delegateName()>;}; separator="\n">
+    <last(grammar.delegators):{g|private <g.recognizerName> gParent;}>
+
+	<actions.(actionScope).ctorModifier; null="public"> <grammar.recognizerName>()<! needed by subclasses !>
+	{
+		OnCreated();
+	}
+
+	<actions.(actionScope).ctorModifier; null="public"> <grammar.recognizerName>(<lexerInputStreamType()> input<grammar.delegators:{g|, <g.recognizerName> <g:delegateName()>}> )
+		: this(input, new RecognizerSharedState()<grammar.delegators:{g|, <g:delegateName()>}>)
+	{
+	}
+
+	<actions.(actionScope).ctorModifier; null="public"> <grammar.recognizerName>(<lexerInputStreamType()> input, RecognizerSharedState state<grammar.delegators:{g|, <g.recognizerName> <g:delegateName()>}>)
+		: base(input, state)
+	{
+<if(memoize)>
+<if(grammar.grammarIsRoot)>
+		state.ruleMemo = new System.Collections.Generic.Dictionary\<int, int>[<numRules>+1];<\n><! index from 1..n !>
+<endif>
+<endif>
+		<grammar.directDelegates:
+		 {g|<g:delegateName()> = new <g.recognizerName>(input, this.state<trunc(g.delegators):{p|, <p:delegateName()>}>, this);}; separator="\n">
+		<grammar.delegators:
+		 {g|this.<g:delegateName()> = <g:delegateName()>;}; separator="\n">
+		<last(grammar.delegators):{g|gParent = <g:delegateName()>;}>
+
+		OnCreated();
+	}
+	public override string GrammarFileName { get { return "<fileName>"; } }
+
+<if(grammar.hasDelegates)>
+	public override <lexerInputStreamType()> CharStream
+	{
+		get
+		{
+			return base.CharStream;
+		}
+		set
+		{
+			base.CharStream = value;
+			<grammar.directDelegates:
+			 {g|<g:delegateName()> = new <g.recognizerName>(input, state<trunc(g.delegators):{p|, <p:delegateName()>}>, this);}; separator="\n">
+			<grammar.delegators:
+			 {g|this.<g:delegateName()> = <g:delegateName()>;}; separator="\n">
+			<last(grammar.delegators):{g|gParent = <g:delegateName()>;}>
+		}
+	}
+
+<if(grammar.delegates)>
+	public override void SetState(RecognizerSharedState state)
+	{
+		base.SetState(state);
+		<grammar.delegates:{g|<g:delegateName()>.SetState(state);}; separator="\n">
+	}
+<endif>
+
+<endif>
+<if(filterMode)>
+	<filteringNextToken()>
+<endif>
+
+
+	partial void OnCreated();
+	partial void EnterRule(string ruleName, int ruleIndex);
+	partial void LeaveRule(string ruleName, int ruleIndex);
+
+	<rules; separator="\n">
+
+	<insertLexerSynpreds(synpreds)>
+
+	#region DFA
+	<cyclicDFAs:{dfa | DFA<dfa.decisionNumber> dfa<dfa.decisionNumber>;}; separator="\n">
+
+	protected override void InitDFAs()
+	{
+		base.InitDFAs();
+		<cyclicDFAs:{dfa | dfa<dfa.decisionNumber> = new DFA<dfa.decisionNumber>(this<if(dfa.specialStateSTs)>, SpecialStateTransition<dfa.decisionNumber><endif>);}; separator="\n">
+	}
+
+	<cyclicDFAs:cyclicDFA()> <! dump tables for all DFA !>
+	#endregion
+
+}
+>>
+
+/** A override of Lexer.nextToken() that backtracks over mTokens() looking
+ *  for matches.  No error can be generated upon error; just rewind, consume
+ *  a token and then try again.  backtracking needs to be set as well.
+ *  Make rule memoization happen only at levels above 1 as we start mTokens
+ *  at backtracking==1.
+ */
+filteringNextToken() ::= <<
+public override IToken NextToken()
+{
+	while (true)
+	{
+		if (input.LA(1) == CharStreamConstants.EndOfFile)
+		{
+			IToken eof = new CommonToken((ICharStream)input, CharStreamConstants.EndOfFile, TokenChannels.Default, input.Index, input.Index);
+			eof.Line = Line;
+			eof.CharPositionInLine = CharPositionInLine;
+			return eof;
+		}
+		state.token = null;
+		state.channel = TokenChannels.Default;
+		state.tokenStartCharIndex = input.Index;
+		state.tokenStartCharPositionInLine = input.CharPositionInLine;
+		state.tokenStartLine = input.Line;
+		state.text = null;
+		try
+		{
+			int m = input.Mark();
+			state.backtracking=1;<! means we won't throw slow exception !>
+			state.failed=false;
+			mTokens();
+			state.backtracking=0;
+			<! mTokens backtracks with synpred at backtracking==2
+			   and we set the synpredgate to allow actions at level 1. !>
+			if (state.failed)
+			{
+				input.Rewind(m);
+				input.Consume();<! advance one char and try again !>
+			}
+			else
+			{
+				Emit();
+				return state.token;
+			}
+		}
+		catch (RecognitionException re)
+		{
+			// shouldn't happen in backtracking mode, but...
+			ReportError(re);
+			Recover(re);
+		}
+	}
+}
+
+public override void Memoize(IIntStream input, int ruleIndex, int ruleStartIndex)
+{
+	if (state.backtracking > 1)
+		base.Memoize(input, ruleIndex, ruleStartIndex);
+}
+
+public override bool AlreadyParsedRule(IIntStream input, int ruleIndex)
+{
+	if (state.backtracking > 1)
+		return base.AlreadyParsedRule(input, ruleIndex);
+
+	return false;
+}
+>>
+
+actionGate() ::= "state.backtracking == 0"
+
+filteringActionGate() ::= "state.backtracking == 1"
+
+/** How to generate a parser */
+genericParser(grammar, name, scopes, tokens, tokenNames, rules, numRules,
+              bitsets, inputStreamType, superClass,
+              labelType, members, rewriteElementType,
+              filterMode, ASTLabelType="object") ::= <<
+[System.CodeDom.Compiler.GeneratedCode("ANTLR", "<ANTLRVersion>")]
+[System.CLSCompliant(false)]
+<parserModifier(grammar=grammar, actions=actions)> partial class <grammar.recognizerName> : <@superClassName><superClass><@end>
+{
+<if(grammar.grammarIsRoot)>
+	internal static readonly string[] tokenNames = new string[] {
+		"\<invalid>", "\<EOR>", "\<DOWN>", "\<UP>", <tokenNames; separator=", ">
+	};
+<endif>
+	<tokens:{it|public const int <it.name; format="id">=<it.type>;}; separator="\n">
+
+<if(grammar.delegates)>
+	// delegates
+	<grammar.delegates:
+		 {g|private <g.recognizerName> <g:delegateName()>;}; separator="\n">
+<endif>
+<if(grammar.delegators)>
+	// delegators
+	<grammar.delegators:
+		 {g|private <g.recognizerName> <g:delegateName()>;}; separator="\n">
+	<last(grammar.delegators):{g|private <g.recognizerName> gParent;}>
+<endif>
+
+<if(grammar.delegates)>
+	public override void SetState(RecognizerSharedState state)
+	{
+		base.SetState(state);
+		<grammar.delegates:{g|<g:delegateName()>.SetState(state);}; separator="\n">
+	}
+
+<if(TREE_PARSER)>
+	public override void SetTreeNodeStream(ITreeNodeStream input)
+	{
+		base.SetTreeNodeStream(input);
+		<grammar.delegates:{g|<g:delegateName()>.SetTreeNodeStream(input);}; separator="\n">
+	}
+<endif>
+<endif>
+
+	<scopes:{it|<if(it.isDynamicGlobalScope)><globalAttributeScope(scope=it)><endif>}>
+	<@members()>
+
+	public override string[] TokenNames { get { return <grammar.composite.rootGrammar.recognizerName>.tokenNames; } }
+	public override string GrammarFileName { get { return "<fileName>"; } }
+
+	<members>
+
+	partial void OnCreated();
+	partial void EnterRule(string ruleName, int ruleIndex);
+	partial void LeaveRule(string ruleName, int ruleIndex);
+
+	#region Rules
+	<rules; separator="\n">
+	#endregion Rules
+
+<if(grammar.delegatedRules)>
+<! generate rule/method definitions for imported rules so they
+   appear to be defined in this recognizer. !>
+	#region Delegated rules
+<grammar.delegatedRules:{ruleDescriptor|
+	<ruleModifier(grammar=grammar,ruleDescriptor=ruleDescriptor)> <returnType(ruleDescriptor)> <ruleDescriptor.name; format="id">(<ruleDescriptor.parameterScope:parameterScope()>) <!throws RecognitionException !>{ <if(ruleDescriptor.hasReturnValue)>return <endif><ruleDescriptor.grammar:delegateName()>.<ruleDescriptor.name; format="id">(<ruleDescriptor.parameterScope.attributes:{a|<a.name; format="id">}; separator=", ">); \}}; separator="\n">
+	#endregion Delegated rules
+<endif>
+
+	<insertSynpreds(synpreds)>
+
+<if(cyclicDFAs)>
+	#region DFA
+	<cyclicDFAs:{dfa | private DFA<dfa.decisionNumber> dfa<dfa.decisionNumber>;}; separator="\n">
+
+	protected override void InitDFAs()
+	{
+		base.InitDFAs();
+		<cyclicDFAs:{dfa | dfa<dfa.decisionNumber> = new DFA<dfa.decisionNumber>( this<if(dfa.specialStateSTs)>, SpecialStateTransition<dfa.decisionNumber><endif> );}; separator="\n">
+	}
+
+	<cyclicDFAs:cyclicDFA()><! dump tables for all DFA !>
+	#endregion DFA
+<endif>
+
+<if(bitsets)>
+	#region Follow sets
+	private static class Follow
+	{
+		<bitsets:{it|<bitset(name={_<it.name>_in_<it.inName><it.tokenIndex>}, words64=it.bits)>}; separator="\n">
+	}
+	#endregion Follow sets
+<endif>
+}
+>>
+
+@genericParser.members() ::= <<
+<! WARNING. bug in ST: this is cut-n-paste into Dbg.stg !>
+<actions.(actionScope).ctorModifier; null="public"> <grammar.recognizerName>(<inputStreamType> input<grammar.delegators:{g|, <g.recognizerName> <g:delegateName()>}>)
+	: this(input, new RecognizerSharedState()<grammar.delegators:{g|, <g:delegateName()>}>)
+{
+}
+<actions.(actionScope).ctorModifier; null="public"> <grammar.recognizerName>(<inputStreamType> input, RecognizerSharedState state<grammar.delegators:{g|, <g.recognizerName> <g:delegateName()>}>)
+	: base(input, state)
+{
+<if(grammar.directDelegates)>
+	<grammar.directDelegates:
+		{g|<g:delegateName()> = new <g.recognizerName>(input, state<trunc(g.delegators):{p|, <p:delegateName()>}>, this);}; separator="\n">
+<endif>
+<if(grammar.indirectDelegates)>
+	<grammar.indirectDelegates:{g | <g:delegateName()> = <g.delegator:delegateName()>.<g:delegateName()>;}; separator="\n">
+<endif>
+<if(grammar.delegators)>
+	<last(grammar.delegators):{g|gParent = <g:delegateName()>;}>
+<endif>
+	<parserCtorBody()>
+	OnCreated();
+}
+>>
+
+// imported grammars are 'public' (can't be internal because their return scope classes must be accessible)
+parserModifier(grammar, actions) ::= <<
+<if(grammar.grammarIsRoot)><actions.(actionScope).modifier; null="public"><else>public<endif>
+>>
+
+parserCtorBody() ::= <<
+<if(memoize)>
+<if(grammar.grammarIsRoot)>
+this.state.ruleMemo = new System.Collections.Generic.Dictionary\<int, int>[<length(grammar.allImportedRules)>+1];<\n><! index from 1..n !>
+<endif>
+<endif>
+<grammar.delegators:
+ {g|this.<g:delegateName()> = <g:delegateName()>;}; separator="\n">
+>>
+
+parser(grammar, name, scopes, tokens, tokenNames, rules, numRules, bitsets,
+       ASTLabelType="object", superClass={<if(actions.(actionScope).superClass)><actions.(actionScope).superClass><else>Antlr.Runtime.Parser<endif>}, labelType="IToken",
+       members={<actions.parser.members>}) ::= <<
+<genericParser(inputStreamType="ITokenStream", rewriteElementType="IToken", filterMode=false, ...)>
+>>
+
+/** How to generate a tree parser; same as parser except the input
+ *  stream is a different type.
+ */
+treeParser(grammar, name, scopes, tokens, tokenNames, globalAction, rules,
+           numRules, bitsets, filterMode, labelType={<ASTLabelType>}, ASTLabelType="object",
+           superClass={<if(actions.(actionScope).superClass)><actions.(actionScope).superClass><else>Antlr.Runtime.Tree.<if(filterMode)><if(buildAST)>TreeRewriter<else>TreeFilter<endif><else>TreeParser<endif><endif>},
+           members={<actions.treeparser.members>}) ::= <<
+<genericParser(inputStreamType="ITreeNodeStream", rewriteElementType="Node", ...)>
+>>
+
+/** A simpler version of a rule template that is specific to the imaginary
+ *  rules created for syntactic predicates.  As they never have return values
+ *  nor parameters etc..., just give simplest possible method.  Don't do
+ *  any of the normal memoization stuff in here either; it's a waste.
+ *  As predicates cannot be inlined into the invoking rule, they need to
+ *  be in a rule by themselves.
+ */
+synpredRule(ruleName, ruleDescriptor, block, description, nakedBlock) ::=
+<<
+
+partial void EnterRule_<ruleName>_fragment();
+partial void LeaveRule_<ruleName>_fragment();
+
+// $ANTLR start <ruleName>
+public <!final !>void <ruleName>_fragment(<ruleDescriptor.parameterScope:parameterScope()>)
+{
+	<ruleLabelDefs(...)>
+	EnterRule_<ruleName>_fragment();
+	EnterRule("<ruleName>_fragment", <ruleDescriptor.index>);
+	TraceIn("<ruleName>_fragment", <ruleDescriptor.index>);
+	try
+	{
+		<block>
+	}
+	finally
+	{
+		TraceOut("<ruleName>_fragment", <ruleDescriptor.index>);
+		LeaveRule("<ruleName>_fragment", <ruleDescriptor.index>);
+		LeaveRule_<ruleName>_fragment();
+	}
+}
+// $ANTLR end <ruleName>
+>>
+
+insertLexerSynpreds(synpreds) ::= <<
+<insertSynpreds(synpreds)>
+>>
+
+insertSynpreds(synpreds) ::= <<
+<if(synpreds)>
+#region Synpreds
+private bool EvaluatePredicate(System.Action fragment)
+{
+	bool success = false;
+	state.backtracking++;
+	<@start()>
+	try { DebugBeginBacktrack(state.backtracking);
+	int start = input.Mark();
+	try
+	{
+		fragment();
+	}
+	catch ( RecognitionException re )
+	{
+		System.Console.Error.WriteLine("impossible: "+re);
+	}
+	success = !state.failed;
+	input.Rewind(start);
+	} finally { DebugEndBacktrack(state.backtracking, success); }
+	<@stop()>
+	state.backtracking--;
+	state.failed=false;
+	return success;
+}
+#endregion Synpreds
+<endif>
+>>
+
+ruleMemoization(name) ::= <<
+<if(memoize)>
+if (state.backtracking > 0 && AlreadyParsedRule(input, <ruleDescriptor.index>)) { <returnFromRule()> }
+<endif>
+>>
+
+/** How to test for failure and return from rule */
+checkRuleBacktrackFailure() ::= <<
+<if(backtracking)>if (state.failed) <returnFromRule()><endif>
+>>
+
+/** This rule has failed, exit indicating failure during backtrack */
+ruleBacktrackFailure() ::= <<
+<if(backtracking)>if (state.backtracking>0) {state.failed=true; <returnFromRule()>}<endif>
+>>
+
+ruleWrapperMap ::= [
+	"bottomup":{<ruleWrapperBottomup()>},
+	"topdown":{<ruleWrapperTopdown()>},
+	default:""
+]
+
+ruleWrapperBottomup() ::= <<
+<if(TREE_PARSER && filterMode)>
+protected override <if(buildAST)>IAstRuleReturnScope<else>void<endif> Bottomup() { <if(buildAST)>return <endif>bottomup(); }
+<endif>
+>>
+
+ruleWrapperTopdown() ::= <<
+<if(TREE_PARSER && filterMode)>
+protected override <if(buildAST)>IAstRuleReturnScope<else>void<endif> Topdown() { <if(buildAST)>return <endif>topdown(); }
+<endif>
+>>
+
+/** How to generate code for a rule.  This includes any return type
+ *  data aggregates required for multiple return values.
+ */
+rule(ruleName,ruleDescriptor,block,emptyRule,description,exceptions,finally,memoize) ::= <<
+<ruleAttributeScope(scope=ruleDescriptor.ruleScope)>
+<returnScope(ruleDescriptor.returnScope)>
+partial void EnterRule_<ruleName>();
+partial void LeaveRule_<ruleName>();
+<ruleWrapperMap.(ruleName)>
+// $ANTLR start "<ruleName>"
+// <fileName>:<description>
+[GrammarRule("<ruleName>")]
+<ruleModifier(grammar=grammar,ruleDescriptor=ruleDescriptor)> <returnType(ruleDescriptor)> <ruleName; format="id">(<ruleDescriptor.parameterScope:parameterScope()>)
+{
+	EnterRule_<ruleName>();
+	EnterRule("<ruleName>", <ruleDescriptor.index>);
+	TraceIn("<ruleName>", <ruleDescriptor.index>);
+	<ruleScopeSetUp()>
+	<ruleDeclarations()>
+	<ruleLabelDefs(...)>
+	<ruleDescriptor.actions.init>
+	try { DebugEnterRule(GrammarFileName, "<ruleName>");
+	DebugLocation(<ruleDescriptor.tree.line>, <ruleDescriptor.EORNode.charPositionInLine>);
+	<@preamble()>
+	try
+	{
+		<ruleMemoization(name=ruleName)>
+		<block>
+		<ruleCleanUp()>
+		<(ruleDescriptor.actions.after):execAction()>
+	}
+<if(exceptions)>
+	<exceptions:{e|<catch(decl=e.decl,action=e.action)><\n>}>
+<else>
+<if(!emptyRule)>
+<if(actions.(actionScope).rulecatch)>
+	<actions.(actionScope).rulecatch>
+<else>
+	catch (RecognitionException re)
+	{
+		ReportError(re);
+		Recover(input,re);
+	<@setErrorReturnValue()>
+	}
+<endif>
+<endif>
+<endif>
+	finally
+	{
+		TraceOut("<ruleName>", <ruleDescriptor.index>);
+		LeaveRule("<ruleName>", <ruleDescriptor.index>);
+		LeaveRule_<ruleName>();
+		<memoize()>
+		<ruleScopeCleanUp()>
+		<finally>
+	}
+	DebugLocation(<ruleDescriptor.EORNode.line>, <ruleDescriptor.EORNode.charPositionInLine>);
+	} finally { DebugExitRule(GrammarFileName, "<ruleName>"); }
+	<@postamble()>
+	<returnFromRule()><\n>
+}
+// $ANTLR end "<ruleName>"
+>>
+
+// imported grammars need to have internal rules
+ruleModifier(grammar,ruleDescriptor) ::= <<
+<if(grammar.grammarIsRoot)><csharpVisibilityMap.(ruleDescriptor.modifier); null="private"><else>internal<endif>
+>>
+
+// imported grammars need to have public return scopes
+returnScopeModifier(grammar,ruleDescriptor) ::= <<
+<if(grammar.grammarIsRoot)><csharpVisibilityMap.(ruleDescriptor.modifier); null="private"><else>public<endif>
+>>
+
+catch(decl,action) ::= <<
+catch (<e.decl>)
+{
+	<e.action>
+}
+>>
+
+ruleDeclarations() ::= <<
+<if(ruleDescriptor.hasMultipleReturnValues)>
+<returnType(ruleDescriptor)> retval = new <returnType(ruleDescriptor)>(<if(ruleDescriptor.returnScope.attributes)>this<endif>);
+retval.Start = (<labelType>)input.LT(1);
+<else>
+<ruleDescriptor.returnScope.attributes:{ a |
+<a.type> <a.name; format="id"> = <if(a.initValue)><a.initValue><else><initValue(a.type)><endif>;
+}>
+<endif>
+<if(memoize)>
+int <ruleDescriptor.name>_StartIndex = input.Index;
+<endif>
+>>
+
+ruleScopeSetUp() ::= <<
+<ruleDescriptor.useScopes:{it|<it>_stack.Push(new <it>_scope(this));<it>_scopeInit(<it>_stack.Peek());}; separator="\n">
+<ruleDescriptor.ruleScope:{it|<it.name>_stack.Push(new <it.name>_scope(this));<it.name>_scopeInit(<it.name>_stack.Peek());}; separator="\n">
+>>
+
+ruleScopeCleanUp() ::= <<
+<ruleDescriptor.useScopes:{it|<it>_scopeAfter(<it>_stack.Peek());<it>_stack.Pop();}; separator="\n">
+<ruleDescriptor.ruleScope:{it|<it.name>_scopeAfter(<it.name>_stack.Peek());<it.name>_stack.Pop();}; separator="\n">
+>>
+
+ruleLabelDefs(ruleDescriptor, labelType, ASTLabelType, rewriteElementType) ::= <<
+<[ruleDescriptor.tokenLabels,ruleDescriptor.tokenListLabels,ruleDescriptor.wildcardTreeLabels,ruleDescriptor.wildcardTreeListLabels]
+    :{it|<labelType> <it.label.text> = default(<labelType>);}; separator="\n"
+>
+<ruleDescriptor.tokenListLabels
+    :{it|List\<<labelType>\> list_<it.label.text> = null;}; separator="\n"
+>
+<[ruleDescriptor.ruleListLabels,ruleDescriptor.wildcardTreeListLabels]
+    :{it|List\<<ASTLabelType>\> list_<it.label.text> = null;}; separator="\n"
+>
+<ruleDescriptor.ruleLabels:ruleLabelDef(); separator="\n">
+<ruleDescriptor.ruleListLabels:ruleLabelDef(); separator="\n">
+>>
+
+lexerRuleLabelDefs() ::= <<
+<[ruleDescriptor.tokenLabels,
+  ruleDescriptor.tokenListLabels,
+  ruleDescriptor.ruleLabels]
+    :{it|<labelType> <it.label.text> = default(<labelType>);}; separator="\n"
+>
+<[ruleDescriptor.charListLabels,
+  ruleDescriptor.charLabels]
+	:{it|int <it.label.text> = 0;}; separator="\n"
+>
+<[ruleDescriptor.tokenListLabels,
+  ruleDescriptor.ruleListLabels]
+    :{it|List\<<labelType>\> list_<it.label.text> = null;}; separator="\n"
+>
+<ruleDescriptor.charListLabels:{it|List\<int\> list_<it.label.text> = null;}; separator="\n"
+>
+>>
+
+returnFromRule() ::= <%
+return
+<if(!ruleDescriptor.isSynPred)>
+<if(ruleDescriptor.hasReturnValue)>
+<if(ruleDescriptor.hasSingleReturnValue)>
+<! This comment is a hack to make sure the following
+   single space appears in the output. !> <ruleDescriptor.singleValueReturnName>
+<else>
+<!!> retval
+<endif>
+<endif>
+<endif>
+;
+%>
+
+ruleCleanUp() ::= <<
+<if(ruleDescriptor.hasMultipleReturnValues)>
+<if(!TREE_PARSER)>
+retval.Stop = (<labelType>)input.LT(-1);
+<endif>
+<endif>
+>>
+
+memoize() ::= <<
+<if(memoize)>
+<if(backtracking)>
+if (state.backtracking > 0) { Memoize(input, <ruleDescriptor.index>, <ruleDescriptor.name>_StartIndex); }
+<endif>
+<endif>
+>>
+
+/** How to generate a rule in the lexer; naked blocks are used for
+ *  fragment rules.
+ */
+lexerRule(ruleName,nakedBlock,ruleDescriptor,block,memoize) ::= <<
+
+partial void EnterRule_<ruleName>();
+partial void LeaveRule_<ruleName>();
+
+// $ANTLR start "<ruleName>"
+[GrammarRule("<ruleName>")]
+<ruleModifier(grammar=grammar,ruleDescriptor=ruleDescriptor)> void m<ruleName>(<ruleDescriptor.parameterScope:parameterScope()>)
+{
+	EnterRule_<ruleName>();
+	EnterRule("<ruleName>", <ruleDescriptor.index>);
+	TraceIn("<ruleName>", <ruleDescriptor.index>);
+	<ruleScopeSetUp()>
+	<ruleDeclarations()>
+	try
+	{
+<if(nakedBlock)>
+		<ruleMemoization(name=ruleName)>
+		<lexerRuleLabelDefs()>
+		<ruleDescriptor.actions.init>
+		<block>
+<else>
+		int _type = <ruleName>;
+		int _channel = DefaultTokenChannel;
+		<ruleMemoization(name=ruleName)>
+		<lexerRuleLabelDefs()>
+		<ruleDescriptor.actions.init>
+		<block>
+		<ruleCleanUp()>
+		state.type = _type;
+		state.channel = _channel;
+		<(ruleDescriptor.actions.after):execAction()>
+<endif>
+	}
+	finally
+	{
+		TraceOut("<ruleName>", <ruleDescriptor.index>);
+		LeaveRule("<ruleName>", <ruleDescriptor.index>);
+		LeaveRule_<ruleName>();
+		<ruleScopeCleanUp()>
+		<memoize()>
+	}
+}
+// $ANTLR end "<ruleName>"
+>>
+
+/** How to generate code for the implicitly-defined lexer grammar rule
+ *  that chooses between lexer rules.
+ */
+tokensRule(ruleName,nakedBlock,args,block,ruleDescriptor) ::= <<
+
+public override void mTokens()
+{
+	<block><\n>
+}
+>>
+
+// S U B R U L E S
+
+/** A (...) subrule with multiple alternatives */
+block(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
+// <fileName>:<description>
+int alt<decisionNumber>=<maxAlt>;
+<decls>
+<@predecision()>
+try { DebugEnterSubRule(<decisionNumber>);
+try { DebugEnterDecision(<decisionNumber>, false<!<decision.dfa.hasSynPred>!>);
+<decision>
+} finally { DebugExitDecision(<decisionNumber>); }
+<@postdecision()>
+<@prebranch()>
+switch (alt<decisionNumber>)
+{
+<alts:{a|<altSwitchCase(i,a)>}>
+}
+} finally { DebugExitSubRule(<decisionNumber>); }
+<@postbranch()>
+>>
+
+/** A rule block with multiple alternatives */
+ruleBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
+// <fileName>:<description>
+int alt<decisionNumber>=<maxAlt>;
+<decls>
+<@predecision()>
+try { DebugEnterDecision(<decisionNumber>, false<!<decision.dfa.hasSynPred>!>);
+<decision>
+} finally { DebugExitDecision(<decisionNumber>); }
+<@postdecision()>
+switch (alt<decisionNumber>)
+{
+<alts:{a|<altSwitchCase(i,a)>}>
+}
+>>
+
+ruleBlockSingleAlt(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,description) ::= <<
+// <fileName>:<description>
+<decls>
+<@prealt()>
+DebugEnterAlt(1);
+<alts>
+<@postalt()>
+>>
+
+/** A special case of a (...) subrule with a single alternative */
+blockSingleAlt(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,description) ::= <<
+// <fileName>:<description>
+<decls>
+<@prealt()>
+DebugEnterAlt(1);
+<alts>
+<@postalt()>
+>>
+
+/** A (..)+ block with 1 or more alternatives */
+positiveClosureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
+// <fileName>:<description>
+int cnt<decisionNumber>=0;
+<decls>
+<@preloop()>
+try { DebugEnterSubRule(<decisionNumber>);
+while (true)
+{
+	int alt<decisionNumber>=<maxAlt>;
+	<@predecision()>
+	try { DebugEnterDecision(<decisionNumber>, false<!<decision.dfa.hasSynPred>!>);
+	<decision>
+	} finally { DebugExitDecision(<decisionNumber>); }
+	<@postdecision()>
+	switch (alt<decisionNumber>)
+	{
+	<alts:{a|<altSwitchCase(i,a)>}>
+	default:
+		if (cnt<decisionNumber> >= 1)
+			goto loop<decisionNumber>;
+
+		<ruleBacktrackFailure()>
+		EarlyExitException eee<decisionNumber> = new EarlyExitException( <decisionNumber>, input );
+		DebugRecognitionException(eee<decisionNumber>);
+		<@earlyExitException()>
+		throw eee<decisionNumber>;
+	}
+	cnt<decisionNumber>++;
+}
+loop<decisionNumber>:
+	;
+
+} finally { DebugExitSubRule(<decisionNumber>); }
+<@postloop()>
+>>
+
+positiveClosureBlockSingleAlt ::= positiveClosureBlock
+
+/** A (..)* block with 1 or more alternatives */
+closureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
+// <fileName>:<description>
+<decls>
+<@preloop()>
+try { DebugEnterSubRule(<decisionNumber>);
+while (true)
+{
+	int alt<decisionNumber>=<maxAlt>;
+	<@predecision()>
+	try { DebugEnterDecision(<decisionNumber>, false<!<decision.dfa.hasSynPred>!>);
+	<decision>
+	} finally { DebugExitDecision(<decisionNumber>); }
+	<@postdecision()>
+	switch ( alt<decisionNumber> )
+	{
+	<alts:{a|<altSwitchCase(i,a)>}>
+	default:
+		goto loop<decisionNumber>;
+	}
+}
+
+loop<decisionNumber>:
+	;
+
+} finally { DebugExitSubRule(<decisionNumber>); }
+<@postloop()>
+>>
+
+closureBlockSingleAlt ::= closureBlock
+
+/** Optional blocks (x)? are translated to (x|) by before code generation
+ *  so we can just use the normal block template
+ */
+optionalBlock ::= block
+
+optionalBlockSingleAlt ::= block
+
+/** A case in a switch that jumps to an alternative given the alternative
+ *  number.  A DFA predicts the alternative and then a simple switch
+ *  does the jump to the code that actually matches that alternative.
+ */
+altSwitchCase(altNum,alt) ::= <<
+case <altNum>:
+	<@prealt()>
+	DebugEnterAlt(<altNum>);
+	<alt>
+	break;<\n>
+>>
+
+/** An alternative is just a list of elements; at outermost level */
+alt(elements,altNum,description,autoAST,outerAlt,treeLevel,rew) ::= <<
+// <fileName>:<description>
+{
+<@declarations()>
+<elements:element()>
+<rew>
+<@cleanup()>
+}
+>>
+
+/** What to emit when there is no rewrite.  For auto build
+ *  mode, does nothing.
+ */
+noRewrite(rewriteBlockLevel, treeLevel) ::= ""
+
+// E L E M E N T S
+
+/** Dump the elements one per line */
+element(it) ::= <%
+<@prematch()>
+DebugLocation(<it.line>, <it.pos>);<\n>
+<it.el><\n>
+%>
+
+/** match a token optionally with a label in front */
+tokenRef(token,label,elementIndex,terminalOptions) ::= <<
+<if(label)><label>=(<labelType>)<endif>Match(input,<token>,Follow._<token>_in_<ruleName><elementIndex>); <checkRuleBacktrackFailure()>
+>>
+
+/** ids+=ID */
+tokenRefAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<tokenRef(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+listLabel(label,elem) ::= <<
+#error The listLabel template should not be used with this target.<\n>
+>>
+
+listLabelElem(label,elem,elemType) ::= <<
+if (list_<label>==null) list_<label>=new List\<<elemType; null={<labelType>}>\>();
+list_<label>.Add(<elem>);<\n>
+>>
+
+/** match a character */
+charRef(char,label) ::= <<
+<if(label)>
+<label> = input.LA(1);<\n>
+<endif>
+Match(<char>); <checkRuleBacktrackFailure()>
+>>
+
+/** match a character range */
+charRangeRef(a,b,label) ::= <<
+<if(label)>
+<label> = input.LA(1);<\n>
+<endif>
+MatchRange(<a>,<b>); <checkRuleBacktrackFailure()>
+>>
+
+/** For now, sets are interval tests and must be tested inline */
+matchSet(s,label,terminalOptions,elementIndex,postmatchCode="") ::= <<
+<if(label)>
+<matchSetLabel()>
+<endif>
+if (<s>)
+{
+	input.Consume();
+	<postmatchCode>
+	<if(!LEXER)>state.errorRecovery=false;<endif><if(backtracking)>state.failed=false;<endif>
+}
+else
+{
+	<ruleBacktrackFailure()>
+	MismatchedSetException mse = new MismatchedSetException(null,input);
+	DebugRecognitionException(mse);
+	<@mismatchedSetException()>
+<if(LEXER)>
+	Recover(mse);
+	throw mse;
+<else>
+	throw mse;
+	<! use following code to make it recover inline; remove throw mse;
+	recoverFromMismatchedSet(input,mse,Follow._set_in_<ruleName><elementIndex>);
+	!>
+<endif>
+}<\n>
+>>
+
+matchSetUnchecked(s,label,elementIndex,postmatchCode=false) ::= <%
+<if(label)>
+<matchSetLabel()><\n>
+<endif>
+input.Consume();<\n>
+<if(postmatchCode)>
+<postmatchCode><\n>
+<endif>
+<if(!LEXER)>state.errorRecovery=false;<endif><if(backtracking)>state.failed=false;<endif>
+%>
+
+matchSetLabel() ::= <%
+<if(LEXER)>
+<label>= input.LA(1);
+<else>
+<label>=(<labelType>)input.LT(1);
+<endif>
+%>
+
+matchRuleBlockSet ::= matchSet
+
+matchSetAndListLabel(s,label,elementIndex,postmatchCode) ::= <<
+<matchSet(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** Match a string literal */
+lexerStringRef(string,label,elementIndex) ::= <%
+<if(label)>
+int <label>Start = CharIndex;<\n>
+Match(<string>); <checkRuleBacktrackFailure()><\n>
+int <label>StartLine<elementIndex> = Line;<\n>
+int <label>StartCharPos<elementIndex> = CharPositionInLine;<\n>
+<label> = new <labelType>(input, TokenTypes.Invalid, TokenChannels.Default, <label>Start, CharIndex-1);<\n>
+<label>.Line = <label>StartLine<elementIndex>;<\n>
+<label>.CharPositionInLine = <label>StartCharPos<elementIndex>;
+<else>
+Match(<string>); <checkRuleBacktrackFailure()><\n>
+<endif>
+%>
+
+wildcard(token,label,elementIndex,terminalOptions) ::= <<
+<if(label)>
+<label>=(<labelType>)input.LT(1);<\n>
+<endif>
+MatchAny(input); <checkRuleBacktrackFailure()>
+>>
+
+wildcardAndListLabel(token,label,elementIndex,terminalOptions) ::= <<
+<wildcard(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** Match . wildcard in lexer */
+wildcardChar(label, elementIndex) ::= <<
+<if(label)>
+<label> = input.LA(1);<\n>
+<endif>
+MatchAny(); <checkRuleBacktrackFailure()>
+>>
+
+wildcardCharListLabel(label, elementIndex) ::= <<
+<wildcardChar(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** Match a rule reference by invoking it possibly with arguments
+ *  and a return value or values.  The 'rule' argument was the
+ *  target rule name, but now is type Rule, whose toString is
+ *  same: the rule name.  Now though you can access full rule
+ *  descriptor stuff.
+ */
+ruleRef(rule,label,elementIndex,args,scope) ::= <<
+PushFollow(Follow._<rule.name>_in_<ruleName><elementIndex>);
+<if(label)><label>=<endif><if(scope)><scope:delegateName()>.<endif><rule.name; format="id">(<args; separator=", ">);
+PopFollow();
+<checkRuleBacktrackFailure()>
+>>
+
+/** ids+=r */
+ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRef(...)>
+<listLabelElem(elem=label,elemType={<ASTLabelType>},...)>
+>>
+
+/** A lexer rule reference.
+ *
+ *  The 'rule' argument was the target rule name, but now
+ *  is type Rule, whose toString is same: the rule name.
+ *  Now though you can access full rule descriptor stuff.
+ */
+lexerRuleRef(rule,label,args,elementIndex,scope) ::= <%
+<if(label)>
+int <label>Start<elementIndex> = CharIndex;<\n>
+int <label>StartLine<elementIndex> = Line;<\n>
+int <label>StartCharPos<elementIndex> = CharPositionInLine;<\n>
+<if(scope)><scope:delegateName()>.<endif>m<rule.name>(<args; separator=", ">); <checkRuleBacktrackFailure()><\n>
+<label> = new <labelType>(input, TokenTypes.Invalid, TokenChannels.Default, <label>Start<elementIndex>, CharIndex-1);<\n>
+<label>.Line = <label>StartLine<elementIndex>;<\n>
+<label>.CharPositionInLine = <label>StartCharPos<elementIndex>;
+<else>
+<if(scope)><scope:delegateName()>.<endif>m<rule.name>(<args; separator=", ">); <checkRuleBacktrackFailure()>
+<endif>
+%>
+
+/** i+=INT in lexer */
+lexerRuleRefAndListLabel(rule,label,args,elementIndex,scope) ::= <<
+<lexerRuleRef(...)>
+<listLabelElem(elem=label,elemType=labelType,...)>
+>>
+
+/** EOF in the lexer */
+lexerMatchEOF(label,elementIndex) ::= <%
+<if(label)>
+int <label>Start<elementIndex> = CharIndex;<\n>
+int <label>StartLine<elementIndex> = Line;<\n>
+int <label>StartCharPos<elementIndex> = CharPositionInLine;<\n>
+Match(EOF); <checkRuleBacktrackFailure()><\n>
+<labelType> <label> = new <labelType>(input, EOF, TokenChannels.Default, <label>Start<elementIndex>, CharIndex-1);<\n>
+<label>.Line = <label>StartLine<elementIndex>;<\n>
+<label>.CharPositionInLine = <label>StartCharPos<elementIndex>;
+<else>
+Match(EOF); <checkRuleBacktrackFailure()>
+<endif>
+%>
+
+// used for left-recursive rules
+recRuleDefArg()                       ::= "int <recRuleArg()>"
+recRuleArg()                          ::= "_p"
+recRuleAltPredicate(ruleName,opPrec)  ::= "<recRuleArg()> \<= <opPrec>"
+recRuleSetResultAction()              ::= "root_0=$<ruleName>_primary.tree;"
+
+/** match ^(root children) in tree parser */
+tree(root, actionsAfterRoot, children, nullableChildList,
+     enclosingTreeLevel, treeLevel) ::= <<
+<root:element()>
+<actionsAfterRoot:element()>
+<if(nullableChildList)>
+if (input.LA(1) == TokenTypes.Down)
+{
+	Match(input, TokenTypes.Down, null); <checkRuleBacktrackFailure()>
+	<children:element()>
+	Match(input, TokenTypes.Up, null); <checkRuleBacktrackFailure()>
+}
+<else>
+Match(input, TokenTypes.Down, null); <checkRuleBacktrackFailure()>
+<children:element()>
+Match(input, TokenTypes.Up, null); <checkRuleBacktrackFailure()>
+<endif>
+>>
+
+/** Every predicate is used as a validating predicate (even when it is
+ *  also hoisted into a prediction expression).
+ */
+validateSemanticPredicate(pred,description) ::= <<
+if (!(<evalPredicate(...)>))
+{
+	<ruleBacktrackFailure()>
+	throw new FailedPredicateException(input, "<ruleName>", "<description>");
+}
+>>
+
+// F i x e d  D F A  (if-then-else)
+
+dfaState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
+int LA<decisionNumber>_<k> = input.LA(<k>);<\n>
+<edges; separator="\nelse ">
+else
+{
+<if(eotPredictsAlt)>
+	alt<decisionNumber> = <eotPredictsAlt>;
+<else>
+	<ruleBacktrackFailure()>
+	NoViableAltException nvae = new NoViableAltException("<description>", <decisionNumber>, <stateNumber>, input, <k>);
+	DebugRecognitionException(nvae);
+	<@noViableAltException()>
+	throw nvae;
+<endif>
+}
+>>
+
+/** Same as a normal DFA state except that we don't examine lookahead
+ *  for the bypass alternative.  It delays error detection but this
+ *  is faster, smaller, and more what people expect.  For (X)? people
+ *  expect "if ( LA(1)==X ) match(X);" and that's it.
+ */
+dfaOptionalBlockState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
+int LA<decisionNumber>_<k> = input.LA(<k>);<\n>
+<edges; separator="\nelse ">
+>>
+
+/** A DFA state that is actually the loopback decision of a closure
+ *  loop.  If end-of-token (EOT) predicts any of the targets then it
+ *  should act like a default clause (i.e., no error can be generated).
+ *  This is used only in the lexer so that for ('a')* on the end of a rule
+ *  anything other than 'a' predicts exiting.
+ */
+dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
+int LA<decisionNumber>_<k> = input.LA(<k>);<\n>
+<edges; separator="\nelse "><\n>
+<if(eotPredictsAlt)>
+<if(!edges)>
+alt<decisionNumber> = <eotPredictsAlt>;<! if no edges, don't gen ELSE !>
+<else>
+else
+{
+	alt<decisionNumber> = <eotPredictsAlt>;
+}<\n>
+<endif>
+<endif>
+>>
+
+/** An accept state indicates a unique alternative has been predicted */
+dfaAcceptState(alt) ::= "alt<decisionNumber> = <alt>;"
+
+/** A simple edge with an expression.  If the expression is satisfied,
+ *  enter to the target state.  To handle gated productions, we may
+ *  have to evaluate some predicates for this edge.
+ */
+dfaEdge(labelExpr, targetState, predicates) ::= <<
+if ((<labelExpr>)<if(predicates)> && (<predicates>)<endif>)
+{
+	<targetState>
+}
+>>
+
+// F i x e d  D F A  (switch case)
+
+/** A DFA state where a SWITCH may be generated.  The code generator
+ *  decides if this is possible: CodeGenerator.canGenerateSwitch().
+ */
+dfaStateSwitch(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
+switch (input.LA(<k>))
+{
+<edges; separator="\n">
+default:
+<if(eotPredictsAlt)>
+	alt<decisionNumber>=<eotPredictsAlt>;
+	break;<\n>
+<else>
+	{
+		<ruleBacktrackFailure()>
+		NoViableAltException nvae = new NoViableAltException("<description>", <decisionNumber>, <stateNumber>, input, <k>);
+		DebugRecognitionException(nvae);
+		<@noViableAltException()>
+		throw nvae;
+	}
+<endif>
+}<\n>
+>>
+
+dfaOptionalBlockStateSwitch(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
+switch (input.LA(<k>))
+{
+<edges; separator="\n">
+}<\n>
+>>
+
+dfaLoopbackStateSwitch(k, edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
+switch (input.LA(<k>))
+{
+<edges; separator="\n">
+<if(eotPredictsAlt)>
+default:
+	alt<decisionNumber>=<eotPredictsAlt>;
+	break;<\n>
+<endif>
+}<\n>
+>>
+
+dfaEdgeSwitch(labels, targetState) ::= <<
+<labels:{it|case <it>:}; separator="\n">
+	{
+	<targetState>
+	}
+	break;
+>>
+
+// C y c l i c  D F A
+
+/** The code to initiate execution of a cyclic DFA; this is used
+ *  in the rule to predict an alt just like the fixed DFA case.
+ *  The <name> attribute is inherited via the parser, lexer, ...
+ */
+dfaDecision(decisionNumber,description) ::= <<
+try
+{
+	alt<decisionNumber> = dfa<decisionNumber>.Predict(input);
+}
+catch (NoViableAltException nvae)
+{
+	DebugRecognitionException(nvae);
+	throw;
+}
+>>
+
+/* Dump DFA tables as run-length-encoded Strings of octal values.
+ * Can't use hex as compiler translates them before compilation.
+ * These strings are split into multiple, concatenated strings.
+ * Java puts them back together at compile time thankfully.
+ * Java cannot handle large static arrays, so we're stuck with this
+ * encode/decode approach.  See analysis and runtime DFA for
+ * the encoding methods.
+ */
+cyclicDFA(dfa) ::= <<
+private class DFA<dfa.decisionNumber> : DFA
+{
+	private const string DFA<dfa.decisionNumber>_eotS =
+		"<dfa.javaCompressedEOT; wrap="\"+\n\t\t\"">";
+	private const string DFA<dfa.decisionNumber>_eofS =
+		"<dfa.javaCompressedEOF; wrap="\"+\n\t\t\"">";
+	private const string DFA<dfa.decisionNumber>_minS =
+		"<dfa.javaCompressedMin; wrap="\"+\n\t\t\"">";
+	private const string DFA<dfa.decisionNumber>_maxS =
+		"<dfa.javaCompressedMax; wrap="\"+\n\t\t\"">";
+	private const string DFA<dfa.decisionNumber>_acceptS =
+		"<dfa.javaCompressedAccept; wrap="\"+\n\t\t\"">";
+	private const string DFA<dfa.decisionNumber>_specialS =
+		"<dfa.javaCompressedSpecial; wrap="\"+\n\t\t\"">}>";
+	private static readonly string[] DFA<dfa.decisionNumber>_transitionS =
+		{
+			<dfa.javaCompressedTransition:{s|"<s; wrap="\"+\n\"">"}; separator=",\n">
+		};
+
+	private static readonly short[] DFA<dfa.decisionNumber>_eot = DFA.UnpackEncodedString(DFA<dfa.decisionNumber>_eotS);
+	private static readonly short[] DFA<dfa.decisionNumber>_eof = DFA.UnpackEncodedString(DFA<dfa.decisionNumber>_eofS);
+	private static readonly char[] DFA<dfa.decisionNumber>_min = DFA.UnpackEncodedStringToUnsignedChars(DFA<dfa.decisionNumber>_minS);
+	private static readonly char[] DFA<dfa.decisionNumber>_max = DFA.UnpackEncodedStringToUnsignedChars(DFA<dfa.decisionNumber>_maxS);
+	private static readonly short[] DFA<dfa.decisionNumber>_accept = DFA.UnpackEncodedString(DFA<dfa.decisionNumber>_acceptS);
+	private static readonly short[] DFA<dfa.decisionNumber>_special = DFA.UnpackEncodedString(DFA<dfa.decisionNumber>_specialS);
+	private static readonly short[][] DFA<dfa.decisionNumber>_transition;
+
+	static DFA<dfa.decisionNumber>()
+	{
+		int numStates = DFA<dfa.decisionNumber>_transitionS.Length;
+		DFA<dfa.decisionNumber>_transition = new short[numStates][];
+		for ( int i=0; i \< numStates; i++ )
+		{
+			DFA<dfa.decisionNumber>_transition[i] = DFA.UnpackEncodedString(DFA<dfa.decisionNumber>_transitionS[i]);
+		}
+	}
+
+	public DFA<dfa.decisionNumber>( BaseRecognizer recognizer<if(dfa.specialStateSTs)>, SpecialStateTransitionHandler specialStateTransition<endif> )
+<if(dfa.specialStateSTs)>
+		: base(specialStateTransition)
+<endif>
+	{
+		this.recognizer = recognizer;
+		this.decisionNumber = <dfa.decisionNumber>;
+		this.eot = DFA<dfa.decisionNumber>_eot;
+		this.eof = DFA<dfa.decisionNumber>_eof;
+		this.min = DFA<dfa.decisionNumber>_min;
+		this.max = DFA<dfa.decisionNumber>_max;
+		this.accept = DFA<dfa.decisionNumber>_accept;
+		this.special = DFA<dfa.decisionNumber>_special;
+		this.transition = DFA<dfa.decisionNumber>_transition;
+	}
+
+	public override string Description { get { return "<dfa.description>"; } }
+
+	public override void Error(NoViableAltException nvae)
+	{
+		DebugRecognitionException(nvae);
+	}
+}<\n>
+<if(dfa.specialStateSTs)>
+private int SpecialStateTransition<dfa.decisionNumber>(DFA dfa, int s, IIntStream _input)<! throws NoViableAltException!>
+{
+	<if(LEXER)>
+	IIntStream input = _input;
+	<endif>
+	<if(PARSER)>
+	ITokenStream input = (ITokenStream)_input;
+	<endif>
+	<if(TREE_PARSER)>
+	ITreeNodeStream input = (ITreeNodeStream)_input;
+	<endif>
+	int _s = s;
+	s = -1;
+	<! pull these outside the switch cases to save space on locals !>
+	int LA<dfa.decisionNumber>_1 = input.LA(1);
+	int index<dfa.decisionNumber>_1 = input.Index;
+	switch (_s)
+	{
+	<dfa.specialStateSTs:{state |case <i0>:<! compressed special state numbers 0..n-1 !>
+	<state>}; separator="\n">
+
+	default:
+		break;
+	}
+
+	if (s >= 0)
+		return s;
+
+<if(backtracking)>
+	if (state.backtracking > 0) {state.failed=true; return -1;}
+<endif>
+	NoViableAltException nvae = new NoViableAltException(dfa.Description, <dfa.decisionNumber>, _s, input);
+	dfa.Error(nvae);
+	throw nvae;
+}
+<endif>
+>>
+
+/** A state in a cyclic DFA; it's a special state and part of a big switch on
+ *  state.
+ */
+cyclicDFAState(decisionNumber,stateNumber,edges,needErrorClause,semPredState) ::= <<
+{
+<if(semPredState)>
+	<! get next lookahead symbol to test edges, then rewind !>
+	input.Rewind();
+<endif>
+	<edges; separator="\nelse ">
+<if(semPredState)>
+	<! return input cursor to state before we rewound !>
+	input.Seek(index<decisionNumber>_1);
+<endif>
+	break;
+}
+>>
+
+/** Just like a fixed DFA edge, test the lookahead and indicate what
+ *  state to jump to next if successful.
+ */
+cyclicDFAEdge(labelExpr, targetStateNumber, edgeNumber, predicates) ::= <<
+if ((<labelExpr>)<if(predicates)> && (<predicates>)<endif>) {s = <targetStateNumber>;}<\n>
+>>
+
+/** An edge pointing at end-of-token; essentially matches any char;
+ *  always jump to the target.
+ */
+eotDFAEdge(targetStateNumber,edgeNumber, predicates) ::= <<
+s = <targetStateNumber>;<\n>
+>>
+
+
+// D F A  E X P R E S S I O N S
+
+andPredicates(left,right) ::= "(<left>&&<right>)"
+
+orPredicates(operands) ::= "(<first(operands)><rest(operands):{o | ||<o>}>)"
+
+notPredicate(pred) ::= "!(<evalPredicate(...)>)"
+
+evalPredicate(pred,description) ::= "(<pred>)"
+
+evalSynPredicate(pred,description) ::= "EvaluatePredicate(<pred>_fragment)"
+
+lookaheadTest(atom,k,atomAsInt) ::= "LA<decisionNumber>_<k>==<atom>"
+
+/** Sometimes a lookahead test cannot assume that LA(k) is in a temp variable
+ *  somewhere.  Must ask for the lookahead directly.
+ */
+isolatedLookaheadTest(atom,k,atomAsInt) ::= "input.LA(<k>)==<atom>"
+
+lookaheadRangeTest(lower,upper,k,rangeNumber,lowerAsInt,upperAsInt) ::= <%
+(LA<decisionNumber>_<k><ge()><lower> && LA<decisionNumber>_<k><le()><upper>)
+%>
+
+isolatedLookaheadRangeTest(lower,upper,k,rangeNumber,lowerAsInt,upperAsInt) ::= "(input.LA(<k>)<ge()><lower> && input.LA(<k>)<le()><upper>)"
+
+le() ::= "\<="
+ge() ::= ">="
+
+setTest(ranges) ::= <<
+<ranges; separator="||">
+>>
+
+// A T T R I B U T E S
+
+attributeScope(scope) ::= <<
+<if(scope.attributes)>
+protected sealed partial class <scope.name>_scope
+{
+	<scope.attributes:{it|public <it.decl>;}; separator="\n">
+
+	public <scope.name>_scope(<grammar.recognizerName> grammar) { OnCreated(grammar); }
+	partial void OnCreated(<grammar.recognizerName> grammar);
+}
+<if(scope.actions.scopeinit)>
+protected void <scope.name>_scopeInit( <scope.name>_scope scope )
+{
+	<scope.actions.scopeinit>
+}
+<else>
+partial void <scope.name>_scopeInit( <scope.name>_scope scope );
+<endif>
+<if(scope.actions.scopeafter)>
+protected void <scope.name>_scopeAfter( <scope.name>_scope scope )
+{
+	<scope.actions.scopeafter>
+}
+<else>
+partial void <scope.name>_scopeAfter( <scope.name>_scope scope );
+<endif>
+protected readonly ListStack\<<scope.name>_scope\> <scope.name>_stack = new ListStack\<<scope.name>_scope\>();
+<endif>
+>>
+
+globalAttributeScope(scope) ::= <<
+<attributeScope(...)>
+>>
+
+ruleAttributeScope(scope) ::= <<
+<attributeScope(...)>
+>>
+
+returnStructName(it) ::= "<it.name>_return"
+
+returnType(ruleDescriptor) ::= <%
+<if(ruleDescriptor.returnScope.attributes && ruleDescriptor.hasMultipleReturnValues)>
+	<ruleDescriptor.grammar.recognizerName>.<ruleDescriptor:returnStructName()>
+<elseif(ruleDescriptor.hasMultipleReturnValues)>
+	<ruleReturnBaseType()>
+<elseif(ruleDescriptor.hasSingleReturnValue)>
+	<ruleDescriptor.singleValueReturnType>
+<else>
+	void
+<endif>
+%>
+
+/** Generate the C# type associated with a single or multiple return
+ *  values.
+ */
+ruleLabelType(referencedRule) ::= <%
+<if(referencedRule.returnScope.attributes&&referencedRule.hasMultipleReturnValues)>
+	<referencedRule.grammar.recognizerName>.<referencedRule:returnStructName()>
+<elseif(referencedRule.hasMultipleReturnValues)>
+	<ruleReturnBaseType()>
+<elseif(referencedRule.hasSingleReturnValue)>
+	<referencedRule.singleValueReturnType>
+<else>
+	void
+<endif>
+%>
+
+delegateName(it) ::= <<
+<if(it.label)><it.label><else>g<it.name><endif>
+>>
+
+/** Using a type to init value map, try to init a type; if not in table
+ *  must be an object, default value is "null".
+ */
+initValue(typeName) ::= <<
+default(<typeName>)
+>>
+
+/** Define a rule label including default value */
+ruleLabelDef(label) ::= <%
+<ruleLabelType(label.referencedRule)> <label.label.text> = <initValue(ruleLabelType(label.referencedRule))>;
+%>
+
+/** Define a return struct for a rule if the code needs to access its
+ *  start/stop tokens, tree stuff, attributes, ...  Leave a hole for
+ *  subgroups to stick in members.
+ */
+returnScope(scope) ::= <<
+<if(scope.attributes && ruleDescriptor.hasMultipleReturnValues)>
+<returnScopeModifier(grammar=grammar,ruleDescriptor=ruleDescriptor)> sealed partial class <ruleDescriptor:returnStructName()> : <ruleReturnBaseType()><@ruleReturnInterfaces()>
+{
+	<scope.attributes:{it|public <it.decl>;}; separator="\n">
+	<@ruleReturnMembers()>
+}
+<endif>
+>>
+
+ruleReturnBaseType() ::= <%
+<if(TREE_PARSER)>Tree<else>Parser<endif>RuleReturnScope\<<labelType>>
+%>
+
+@returnScope.ruleReturnMembers() ::= <<
+public <ruleDescriptor:returnStructName()>(<grammar.recognizerName> grammar) {OnCreated(grammar);}
+partial void OnCreated(<grammar.recognizerName> grammar);
+>>
+
+parameterScope(scope) ::= <<
+<scope.attributes:{it|<it.decl>}; separator=", ">
+>>
+
+parameterAttributeRef(attr) ::= <<
+<attr.name; format="id">
+>>
+
+parameterSetAttributeRef(attr,expr) ::= <<
+<attr.name; format="id"> =<expr>;
+>>
+
+scopeAttributeRef(scope,attr,index,negIndex) ::= <%
+<if(negIndex)>
+<scope>_stack[<scope>_stack.Count - <negIndex> - 1].<attr.name; format="id">
+<else>
+<if(index)>
+<scope>_stack[<index>].<attr.name; format="id">
+<else>
+<scope>_stack.Peek().<attr.name; format="id">
+<endif>
+<endif>
+%>
+
+scopeSetAttributeRef(scope,attr,expr,index,negIndex) ::= <%
+<if(negIndex)>
+<scope>_stack[<scope>_stack.Count - <negIndex> - 1].<attr.name; format="id"> = <expr>;
+<else>
+<if(index)>
+<scope>_stack[<index>].<attr.name; format="id"> = <expr>;
+<else>
+<scope>_stack.Peek().<attr.name; format="id"> = <expr>;
+<endif>
+<endif>
+%>
+
+/** $x is either global scope or x is rule with dynamic scope; refers
+ *  to stack itself not top of stack.  This is useful for predicates
+ *  like {$function.Count>0 && $function::name.Equals("foo")}?
+ */
+isolatedDynamicScopeRef(scope) ::= "<scope>_stack"
+
+/** reference an attribute of rule; might only have single return value */
+ruleLabelRef(referencedRule,scope,attr) ::= <%
+<if(referencedRule.hasMultipleReturnValues)>
+(<scope>!=null?<scope>.<attr.name; format="id">:<initValue(attr.type)>)
+<else>
+<scope>
+<endif>
+%>
+
+returnAttributeRef(ruleDescriptor,attr) ::= <%
+<if(ruleDescriptor.hasMultipleReturnValues)>
+retval.<attr.name; format="id">
+<else>
+<attr.name; format="id">
+<endif>
+%>
+
+returnSetAttributeRef(ruleDescriptor,attr,expr) ::= <%
+<if(ruleDescriptor.hasMultipleReturnValues)>
+retval.<attr.name; format="id"> =<expr>;
+<else>
+<attr.name; format="id"> =<expr>;
+<endif>
+%>
+
+/** How to translate $tokenLabel */
+tokenLabelRef(label) ::= "<label>"
+
+/** ids+=ID {$ids} or e+=expr {$e} */
+listLabelRef(label) ::= "list_<label>"
+
+
+// not sure the next are the right approach
+
+tokenLabelPropertyRef_text(scope,attr) ::= "(<scope>!=null?<scope>.Text:null)"
+tokenLabelPropertyRef_type(scope,attr) ::= "(<scope>!=null?<scope>.Type:0)"
+tokenLabelPropertyRef_line(scope,attr) ::= "(<scope>!=null?<scope>.Line:0)"
+tokenLabelPropertyRef_pos(scope,attr) ::= "(<scope>!=null?<scope>.CharPositionInLine:0)"
+tokenLabelPropertyRef_channel(scope,attr) ::= "(<scope>!=null?<scope>.Channel:0)"
+tokenLabelPropertyRef_index(scope,attr) ::= "(<scope>!=null?<scope>.TokenIndex:0)"
+tokenLabelPropertyRef_tree(scope,attr) ::= "<scope>_tree"
+tokenLabelPropertyRef_int(scope,attr) ::= "(<scope>!=null?int.Parse(<scope>.Text):0)"
+
+ruleLabelPropertyRef_start(scope,attr) ::= "(<scope>!=null?((<labelType>)<scope>.Start):default(<labelType>))"
+ruleLabelPropertyRef_stop(scope,attr) ::= "(<scope>!=null?((<labelType>)<scope>.Stop):default(<labelType>))"
+ruleLabelPropertyRef_tree(scope,attr) ::= "(<scope>!=null?((<ASTLabelType>)<scope>.Tree):default(<ASTLabelType>))"
+ruleLabelPropertyRef_text(scope,attr) ::= <%
+<if(TREE_PARSER)>
+(<scope>!=null?(input.TokenStream.ToString(
+  input.TreeAdaptor.GetTokenStartIndex(<scope>.Start),
+  input.TreeAdaptor.GetTokenStopIndex(<scope>.Start))):null)
+<else>
+(<scope>!=null?input.ToString(<scope>.Start,<scope>.Stop):null)
+<endif>
+%>
+
+ruleLabelPropertyRef_st(scope,attr) ::= "(<scope>!=null?<scope>.Template:null)"
+
+/** Isolated $RULE ref ok in lexer as it's a Token */
+lexerRuleLabel(label) ::= "<label>"
+
+lexerRuleLabelPropertyRef_type(scope,attr) ::=
+    "(<scope>!=null?<scope>.Type:0)"
+
+lexerRuleLabelPropertyRef_line(scope,attr) ::=
+    "(<scope>!=null?<scope>.Line:0)"
+
+lexerRuleLabelPropertyRef_pos(scope,attr) ::=
+    "(<scope>!=null?<scope>.CharPositionInLine:-1)"
+
+lexerRuleLabelPropertyRef_channel(scope,attr) ::=
+    "(<scope>!=null?<scope>.Channel:0)"
+
+lexerRuleLabelPropertyRef_index(scope,attr) ::=
+    "(<scope>!=null?<scope>.TokenIndex:0)"
+
+lexerRuleLabelPropertyRef_text(scope,attr) ::=
+    "(<scope>!=null?<scope>.Text:null)"
+
+lexerRuleLabelPropertyRef_int(scope,attr) ::=
+    "(<scope>!=null?int.Parse(<scope>.Text):0)"
+
+// Somebody may ref $template or $tree or $stop within a rule:
+rulePropertyRef_start(scope,attr) ::= "retval.Start"
+rulePropertyRef_stop(scope,attr) ::= "retval.Stop"
+rulePropertyRef_tree(scope,attr) ::= "retval.Tree"
+rulePropertyRef_text(scope,attr) ::= <%
+<if(TREE_PARSER)>
+input.TokenStream.ToString(
+  input.TreeAdaptor.GetTokenStartIndex(retval.Start),
+  input.TreeAdaptor.GetTokenStopIndex(retval.Start))
+<else>
+input.ToString(retval.Start,input.LT(-1))
+<endif>
+%>
+rulePropertyRef_st(scope,attr) ::= "retval.Template"
+
+lexerRulePropertyRef_text(scope,attr) ::= "Text"
+lexerRulePropertyRef_type(scope,attr) ::= "_type"
+lexerRulePropertyRef_line(scope,attr) ::= "state.tokenStartLine"
+lexerRulePropertyRef_pos(scope,attr) ::= "state.tokenStartCharPositionInLine"
+lexerRulePropertyRef_index(scope,attr) ::= "-1" // undefined token index in lexer
+lexerRulePropertyRef_channel(scope,attr) ::= "_channel"
+lexerRulePropertyRef_start(scope,attr) ::= "state.tokenStartCharIndex"
+lexerRulePropertyRef_stop(scope,attr) ::= "(CharIndex-1)"
+lexerRulePropertyRef_int(scope,attr) ::= "int.Parse(<scope>.Text)"
+
+// setting $st and $tree is allowed in local rule. everything else
+// is flagged as error
+ruleSetPropertyRef_tree(scope,attr,expr) ::= "retval.Tree = <expr>;"
+ruleSetPropertyRef_st(scope,attr,expr) ::= "retval.Template =<expr>;"
+
+/** How to execute an action (only when not backtracking) */
+execAction(action) ::= <%
+<if(backtracking)>
+if (<actions.(actionScope).synpredgate>)<\n>
+{<\n>
+<@indentedAction()><\n>
+}
+<else>
+<action>
+<endif>
+%>
+
+@execAction.indentedAction() ::= <<
+	<action>
+>>
+
+/** How to always execute an action even when backtracking */
+execForcedAction(action) ::= "<action>"
+
+// M I S C (properties, etc...)
+
+bitset(name, words64) ::= <<
+public static readonly BitSet <name> = new BitSet(new ulong[]{<words64:{it|<it>UL};separator=",">});
+>>
+
+codeFileExtension() ::= ".cs"
+
+true_value() ::= "true"
+false_value() ::= "false"
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/Dbg.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/Dbg.stg
new file mode 100644
index 0000000..c16a848
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/Dbg.stg
@@ -0,0 +1,312 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2005-2008 Terence Parr
+ * All rights reserved.
+ *
+ * Conversion to C#:
+ * Copyright (c) 2008-2009 Sam Harwell, Pixel Mine, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** Template overrides to add debugging to normal Java output;
+ *  If ASTs are built, then you'll also get ASTDbg.stg loaded.
+ */
+
+@outputFile.imports() ::= <<
+<@super.imports()>
+using Antlr.Runtime.Debug;
+using IOException = System.IO.IOException;
+>>
+
+@genericParser.members() ::= <<
+<if(grammar.grammarIsRoot)>
+public static readonly string[] ruleNames =
+	new string[]
+	{
+		"invalidRule", <grammar.allImportedRules:{rST | "<rST.name>"}; wrap="\n	", separator=", ">
+	};<\n>
+<endif>
+<if(grammar.grammarIsRoot)><! grammar imports other grammar(s) !>
+	int ruleLevel = 0;
+	public virtual int RuleLevel { get { return ruleLevel; } }
+	public virtual void IncRuleLevel() { ruleLevel++; }
+	public virtual void DecRuleLevel() { ruleLevel--; }
+<if(profile)>
+	<ctorForProfilingRootGrammar()>
+<else>
+	<ctorForRootGrammar()>
+<endif>
+<ctorForPredefinedListener()>
+<else><! imported grammar !>
+	public int RuleLevel { get { return <grammar.delegators:{g| <g:delegateName()>}>.RuleLevel; } }
+	public void IncRuleLevel() { <grammar.delegators:{g| <g:delegateName()>}>.IncRuleLevel(); }
+	public void DecRuleLevel() { <grammar.delegators:{g| <g:delegateName()>}>.DecRuleLevel(); }
+	<ctorForDelegateGrammar()>
+<endif>
+<if(profile)>
+public override bool AlreadyParsedRule( IIntStream input, int ruleIndex )
+{
+	int stopIndex = GetRuleMemoization(ruleIndex, input.Index);
+	((Profiler)dbg).ExamineRuleMemoization(input, ruleIndex, stopIndex, <grammar.composite.rootGrammar.recognizerName>.ruleNames[ruleIndex]);
+	return base.AlreadyParsedRule(input, ruleIndex);
+}<\n>
+public override void Memoize( IIntStream input, int ruleIndex, int ruleStartIndex )
+{
+	((Profiler)dbg).Memoize(input, ruleIndex, ruleStartIndex, <grammar.composite.rootGrammar.recognizerName>.ruleNames[ruleIndex]);
+	base.Memoize(input, ruleIndex, ruleStartIndex);
+}<\n>
+<endif>
+protected virtual bool EvalPredicate( bool result, string predicate )
+{
+	dbg.SemanticPredicate( result, predicate );
+	return result;
+}<\n>
+>>
+
+ctorForRootGrammar() ::= <<
+<! bug: can't use <@super.members()> cut-n-paste instead !>
+<! Same except we add port number and profile stuff if root grammar !>
+<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input )
+	: this( input, DebugEventSocketProxy.DefaultDebuggerPort, new RecognizerSharedState() )
+{
+}
+<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input, int port, RecognizerSharedState state )
+	: base( input, state )
+{
+	<createListenerAndHandshake()>
+	<grammar.directDelegates:{g|<g:delegateName()> = new <g.recognizerName>( input, dbg, this.state, this<grammar.delegators:{g|, <g:delegateName()>}> );}; separator="\n">
+	<parserCtorBody()>
+	<@finally()>
+}<\n>
+>>
+
+ctorForProfilingRootGrammar() ::= <<
+<! bug: can't use <@super.members()> cut-n-paste instead !>
+<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input )
+	: this( input, new Profiler(null), new RecognizerSharedState() )
+{
+}
+<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input, IDebugEventListener dbg, RecognizerSharedState state )
+	: base( input, dbg, state )
+{
+	Profiler p = (Profiler)dbg;
+	p.setParser(this);
+	<grammar.directDelegates:
+	 {g|<g:delegateName()> = new <g.recognizerName>( input, dbg, this.state, this<grammar.delegators:{g|, <g:delegateName()>}> );}; separator="\n">
+	<parserCtorBody()>
+	<@finally()>
+}
+<\n>
+>>
+
+/** Basically we don't want to set any dbg listeners are root will have it. */
+ctorForDelegateGrammar() ::= <<
+<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input, IDebugEventListener dbg, RecognizerSharedState state<grammar.delegators:{g|, <g.recognizerName> <g:delegateName()>}> )
+	: base( input, dbg, state )
+{
+	<grammar.directDelegates:
+	 {g|<g:delegateName()> = new <g.recognizerName>( input, this, this.state<grammar.delegators:{g|, <g:delegateName()>}> );}; separator="\n">
+	<parserCtorBody()>
+}<\n>
+>>
+
+ctorForPredefinedListener() ::= <<
+<actions.(actionScope).ctorModifier; null="public"> <name>( <inputStreamType> input, IDebugEventListener dbg )
+	<@superClassRef>: base( input, dbg, new RecognizerSharedState() )<@end>
+{
+<if(profile)>
+	Profiler p = (Profiler)dbg;
+	p.setParser(this);
+<endif>
+	<grammar.directDelegates:{g|<g:delegateName()> = new <g.recognizerName>(input, dbg, this.state, this<grammar.delegators:{g|, <g:delegateName()>}>);}; separator="\n">
+	<parserCtorBody()>
+	<@finally()>
+}<\n>
+>>
+
+createListenerAndHandshake() ::= <<
+<if(TREE_PARSER)>
+DebugEventSocketProxy proxy = new DebugEventSocketProxy( this, port, input.TreeAdaptor );<\n>
+<else>
+DebugEventSocketProxy proxy = new DebugEventSocketProxy( this, port, null );<\n>
+<endif>
+DebugListener = proxy;
+try
+{
+	proxy.Handshake();
+}
+catch ( IOException ioe )
+{
+	ReportError( ioe );
+}
+>>
+
+@genericParser.superClassName() ::= "Debug<@super.superClassName()>"
+
+/*
+ * Much of the following rules were merged into CSharp3.stg.
+ */
+
+@rule.preamble() ::= <<
+if (RuleLevel == 0)
+	DebugListener.Commence();
+IncRuleLevel();
+>>
+//@rule.preamble() ::= <<
+//try
+//{
+//	dbg.EnterRule( GrammarFileName, "<ruleName>" );
+//	if ( RuleLevel == 0 )
+//	{
+//		dbg.Commence();
+//	}
+//	IncRuleLevel();
+//	dbg.Location( <ruleDescriptor.tree.line>, <ruleDescriptor.tree.charPositionInLine> );<\n>
+//>>
+
+@rule.postamble() ::= <<
+DecRuleLevel();
+if (RuleLevel == 0)
+	DebugListener.Terminate();
+>>
+//@rule.postamble() ::= <<
+//dbg.Location(<ruleDescriptor.EORNode.line>, <ruleDescriptor.EORNode.charPositionInLine>);<\n>
+//}
+//finally
+//{
+//	dbg.ExitRule( GrammarFileName, "<ruleName>" );
+//	DecRuleLevel();
+//	if ( RuleLevel == 0 )
+//	{
+//		dbg.Terminate();
+//	}
+//}<\n>
+//>>
+
+//@insertSynpreds.start() ::= "dbg.BeginBacktrack( state.backtracking );"
+//@insertSynpreds.stop() ::= "dbg.EndBacktrack( state.backtracking, success );"
+
+// Common debug event triggers used by region overrides below
+
+//enterSubRule() ::= <<
+//try
+//{
+//	dbg.EnterSubRule( <decisionNumber> );<\n>
+//>>
+
+//exitSubRule() ::= <<
+//}
+//finally
+//{
+//	dbg.ExitSubRule( <decisionNumber> );
+//}<\n>
+//>>
+
+//enterDecision() ::= <<
+//try
+//{
+//	dbg.EnterDecision( <decisionNumber> );<\n>
+//>>
+
+//exitDecision() ::= <<
+//}
+//finally
+//{
+//	dbg.ExitDecision( <decisionNumber> );
+//}<\n>
+//>>
+
+//enterAlt(n) ::= "dbg.EnterAlt( <n> );<\n>"
+
+// Region overrides that tell various constructs to add debugging triggers
+
+//@block.predecision() ::= "<enterSubRule()><enterDecision()>"
+
+//@block.postdecision() ::= "<exitDecision()>"
+
+//@block.postbranch() ::= "<exitSubRule()>"
+
+//@ruleBlock.predecision() ::= "<enterDecision()>"
+
+//@ruleBlock.postdecision() ::= "<exitDecision()>"
+
+//@ruleBlockSingleAlt.prealt() ::= "<enterAlt(n=\"1\")>"
+
+//@blockSingleAlt.prealt() ::= "<enterAlt(n=\"1\")>"
+
+//@positiveClosureBlock.preloop() ::= "<enterSubRule()>"
+
+//@positiveClosureBlock.postloop() ::= "<exitSubRule()>"
+
+//@positiveClosureBlock.predecision() ::= "<enterDecision()>"
+
+//@positiveClosureBlock.postdecision() ::= "<exitDecision()>"
+
+//@positiveClosureBlock.earlyExitException() ::=
+//	"dbg.RecognitionException( eee<decisionNumber> );<\n>"
+
+//@closureBlock.preloop() ::= "<enterSubRule()>"
+
+//@closureBlock.postloop() ::= "<exitSubRule()>"
+
+//@closureBlock.predecision() ::= "<enterDecision()>"
+
+//@closureBlock.postdecision() ::= "<exitDecision()>"
+
+//@altSwitchCase.prealt() ::= "<enterAlt(n=i)>"
+
+//@element.prematch() ::=
+//	"dbg.Location( <it.line>, <it.pos> );"
+
+//@matchSet.mismatchedSetException() ::=
+//	"dbg.RecognitionException( mse );"
+
+//@dfaState.noViableAltException() ::= "dbg.RecognitionException( nvae );"
+
+//@dfaStateSwitch.noViableAltException() ::= "dbg.RecognitionException( nvae );"
+
+//dfaDecision(decisionNumber,description) ::= <<
+//try
+//{
+//	isCyclicDecision = true;
+//	<super.dfaDecision(...)>
+//}
+//catch ( NoViableAltException nvae )
+//{
+//	dbg.RecognitionException( nvae );
+//	throw nvae;
+//}
+//>>
+
+//@cyclicDFA.errorMethod() ::= <<
+//public override void Error( NoViableAltException nvae )
+//{
+//	((DebugParser)recognizer).dbg.RecognitionException( nvae );
+//}
+//>>
+
+/** Force predicate validation to trigger an event */
+evalPredicate(pred,description) ::= <<
+EvalPredicate(<pred>, "<description>")
+>>
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/ST.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/ST.stg
new file mode 100644
index 0000000..fd1322f
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/CSharp3/ST.stg
@@ -0,0 +1,153 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2011 Terence Parr
+ * All rights reserved.
+ *
+ * Conversion to C#:
+ * Copyright (c) 2011 Sam Harwell, Pixel Mine, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** Template subgroup to add template rewrite output
+ *  If debugging, then you'll also get STDbg.stg loaded.
+ */
+
+@outputFile.imports() ::= <<
+<@super.imports()>
+using Antlr3.ST;
+using Antlr3.ST.Language;
+>>
+
+@genericParser.members() ::= <<
+<@super.members()>
+private StringTemplateGroup _templateGroup = new StringTemplateGroup("<name>Templates", typeof(AngleBracketTemplateLexer) );
+
+public StringTemplateGroup TemplateGroup
+{
+	get { return _templateGroup; }
+	set { _templateGroup = value; }
+}
+>>
+
+ruleReturnBaseType() ::= <%
+Template<if(TREE_PARSER)>Tree<else>Parser<endif>RuleReturnScope\<StringTemplate, <labelType>>
+%>
+
+/** x+=rule when output=template */
+ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
+<ruleRef(...)>
+<listLabelElem(elem={<label>.Template},elemType="StringTemplate",...)>
+>>
+
+rewriteTemplate(alts) ::= <<
+
+// TEMPLATE REWRITE
+<if(backtracking)>
+if (<actions.(actionScope).synpredgate>)
+{
+	<alts:rewriteTemplateAlt(); separator="else ">
+	<if(rewriteMode)><replaceTextInLine()><endif>
+}
+<else>
+<alts:rewriteTemplateAlt(); separator="else ">
+<if(rewriteMode)><replaceTextInLine()><endif>
+<endif>
+>>
+
+replaceTextInLine() ::= <<
+<if(TREE_PARSER)>
+((TokenRewriteStream)input.TokenStream).Replace(
+	input.TreeAdaptor.GetTokenStartIndex(retval.Start),
+	input.TreeAdaptor.GetTokenStopIndex(retval.Start),
+	retval.Template);
+<else>
+((TokenRewriteStream)input).Replace(
+	retval.Start.TokenIndex,
+	input.LT(-1).TokenIndex,
+	retval.Template);
+<endif>
+>>
+
+rewriteTemplateAlt(it) ::= <<
+// <it.description>
+<if(it.pred)>
+if (<it.pred>)
+{
+	retval.Template = <it.alt>;
+}<\n>
+<else>
+{
+	retval.Template = <it.alt>;
+}<\n>
+<endif>
+>>
+
+rewriteEmptyTemplate(alts) ::= <<
+null;
+>>
+
+/** Invoke a template with a set of attribute name/value pairs.
+ *  Set the value of the rule's template *after* having set
+ *  the attributes because the rule's template might be used as
+ *  an attribute to build a bigger template; you get a self-embedded
+ *  template.
+ */
+rewriteExternalTemplate(name,args) ::= <%
+TemplateGroup.GetInstanceOf("<name>"<optionalArguments(args)>)
+%>
+
+/** expr is a string expression that says what template to load */
+rewriteIndirectTemplate(expr,args) ::= <%
+TemplateGroup.GetInstanceOf(<expr><optionalArguments(args)>)
+%>
+
+/** Invoke an inline template with a set of attribute name/value pairs */
+rewriteInlineTemplate(args, template) ::= <%
+new StringTemplate(TemplateGroup, "<template>"<optionalArguments(args)>)
+%>
+
+optionalArguments(args) ::= <<
+<if(args)>,
+	new Dictionary\<string, object>() { <args:optionalArgument(); separator=", "> }
+<endif>
+>>
+
+optionalArgument(it) ::= <<
+{"<it.name>", <it.value>}
+>>
+
+/** plain -> {foo} action */
+rewriteAction(action) ::= <<
+<action>
+>>
+
+/** An action has %st.attrName=expr; or %{st}.attrName=expr; */
+actionSetAttribute(st,attrName,expr) ::= <<
+(<st>).SetAttribute("<attrName>",<expr>);
+>>
+
+/** Translate %{stringExpr} */
+actionStringConstructor(stringExpr) ::= <<
+new StringTemplate(TemplateGroup,<stringExpr>)
+>>
diff --git a/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/LeftRecursiveRules.stg b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/LeftRecursiveRules.stg
new file mode 100644
index 0000000..e39b1b6
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Codegen/Templates/LeftRecursiveRules.stg
@@ -0,0 +1,82 @@
+/*
+ [The "BSD license"]
+ Copyright (c) 2010 Terence Parr
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/** How to generate rules derived from left-recursive rules.
+ *  These rely on recRuleDefArg(), recRuleAltPredicate(),
+ *  recRuleArg(), recRuleSetResultAction(), recRuleSetReturnAction()
+ *  templates in main language.stg
+ */
+group LeftRecursiveRules;
+
+recRuleName(ruleName) ::= "<ruleName>_"
+recPrimaryName(ruleName) ::= "<ruleName>_primary"
+
+recRuleStart(ruleName, minPrec, userRetvals, userRetvalAssignments) ::= <<
+<ruleName><if(userRetvals)> returns [<userRetvals>]<endif>
+  : <recRuleName(...)>[<minPrec>]
+    <if(userRetvals)>
+    {
+        <userRetvalAssignments; separator="\n">
+    }
+    <endif>
+  ;
+>>
+
+recRule(ruleName, precArgDef, argName, alts, setResultAction, buildAST,
+        userRetvals, userRetvalAssignments) ::= <<
+<recRuleName(...)>[<precArgDef>]<if(userRetvals)> returns [<userRetvals>]<endif>
+    :   <recPrimaryName(...)>
+        <if(buildAST)>
+        {
+            <setResultAction>
+        }
+        <endif>
+        <if(userRetvals)>
+        {
+            <userRetvalAssignments; separator="\n">
+        }
+        <endif>
+        ( options {backtrack=false;}
+        : ( options {backtrack=false;}
+          : <alts; separator="\n          | ">
+          )
+        )*
+    ;
+>>
+
+recPrimaryRule(ruleName, alts, userRetvals) ::= <<
+<recPrimaryName(...)><if(userRetvals)> returns [<userRetvals>]<endif>
+options {backtrack=true;}
+    : <alts; separator="\n    | ">
+    ;
+>>
+
+recRuleAlt(alt, pred) ::= "{<pred>}?=> <alt>"
+
+recRuleRef(ruleName, arg) ::= "<recRuleName(...)>[<arg>]"
+
diff --git a/packages/Antlr34.3.4.19004.1/tools/LICENSE.txt b/packages/Antlr34.3.4.19004.1/tools/LICENSE.txt
new file mode 100644
index 0000000..f63a069
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/LICENSE.txt
@@ -0,0 +1,27 @@
+[The "BSD license"]
+Copyright (c) 2011 Terence Parr
+C# Port (c) 2011 Sam Harwell, Tunnel Vision Laboratories, LLC
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/packages/Antlr34.3.4.19004.1/tools/Targets/Antlr3.Targets.CSharp2.dll b/packages/Antlr34.3.4.19004.1/tools/Targets/Antlr3.Targets.CSharp2.dll
new file mode 100644
index 0000000..4091db6
Binary files /dev/null and b/packages/Antlr34.3.4.19004.1/tools/Targets/Antlr3.Targets.CSharp2.dll differ
diff --git a/packages/Antlr34.3.4.19004.1/tools/Targets/Antlr3.Targets.CSharp3.dll b/packages/Antlr34.3.4.19004.1/tools/Targets/Antlr3.Targets.CSharp3.dll
new file mode 100644
index 0000000..d661e00
Binary files /dev/null and b/packages/Antlr34.3.4.19004.1/tools/Targets/Antlr3.Targets.CSharp3.dll differ
diff --git a/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/depend.stg b/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/depend.stg
new file mode 100644
index 0000000..c093054
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/depend.stg
@@ -0,0 +1,12 @@
+/** templates used to generate make-compatible dependencies */
+group depend;
+
+/** Generate "f : x, y, z" dependencies for input
+ *  dependencies and generated files. in and out
+ *  are File objects.  For example, you can say
+ *  <f.canonicalPath>
+ */
+dependencies(grammarFileName,in,out) ::= <<
+<if(in)><grammarFileName>: <in; separator=", "><endif>
+<out:{f | <f> : <grammarFileName>}; separator="\n">
+>>
diff --git a/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/dot/dot.stg b/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/dot/dot.stg
new file mode 100644
index 0000000..96981dc
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/dot/dot.stg
@@ -0,0 +1,73 @@
+/*
+ * [The "BSD license"]
+ * Copyright (c) 2011 Terence Parr
+ * All rights reserved.
+ *
+ * Conversion to C#:
+ * Copyright (c) 2011 Sam Harwell, Tunnel Vision Laboratories, LLC.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+dfa(decisionRanks,states,edges,rankdir,startState,useBox) ::= <<
+digraph NFA {
+<if(rankdir)>rankdir=<rankdir>;<endif>
+<decisionRanks; separator="\n">
+<states; separator="\n">
+<edges; separator="\n">
+}
+>>
+
+nfa(decisionRanks,states,edges,rankdir,startState) ::= <<
+digraph NFA {
+rankdir=LR;
+<decisionRanks; separator="\n">
+<states; separator="\n">
+<edges; separator="\n">
+}
+>>
+
+decision_rank(states) ::= <<
+{rank=same; rankdir=TB; <states; separator="; ">}
+>>
+
+edge(src,target,label,arrowhead) ::= <<
+<src> -> <target> [fontsize=11, fontname="Courier", arrowsize=.7, label = "<label>"<if(arrowhead)>, arrowhead = <arrowhead><endif>];
+>>
+
+action_edge(src,target,label,arrowhead) ::= <<
+<src> -> <target> [fontsize=11, fontname="Courier", arrowsize=.7, label = "<label>"<if(arrowhead)>, arrowhead = <arrowhead><endif>];
+>>
+
+epsilon_edge(src,target,label,arrowhead) ::= <<
+<src> -> <target> [fontname="Times-Italic", label = "e"];
+>>
+
+state(name,useBox) ::= <<
+node [fontsize=11, shape = <if(useBox)>box<else>circle, fixedsize=true, width=.4<endif>]; <name>
+>>
+
+stopstate(name,useBox) ::= <<
+node [fontsize=11, shape = <if(useBox)>polygon,sides=4,peripheries=2<else>doublecircle, fixedsize=true, width=.6<endif>]; <name>
+>>
diff --git a/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/messages/formats/antlr.stg b/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/messages/formats/antlr.stg
new file mode 100644
index 0000000..9fb4612
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/messages/formats/antlr.stg
@@ -0,0 +1,42 @@
+/*
+ [The "BSD license"]
+ Copyright (c) 2006 Kay Roepke
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*
+ New style messages. This file contains the actual layout of the messages emitted by ANTLR.
+ The text itself is coming out of the languages/*stg files, according to the chosen locale.
+ This file contains the default format ANTLR uses.
+*/
+
+group antlr;
+
+location(file, line, column) ::= "<file>:<line>:<column>:"
+
+message(id, text) ::= "(<id>) <text>"
+
+report(location, message, type) ::= "<type>(<message.id>): <location> <message.text>"
+
+wantsSingleLineMessage() ::= "false"
\ No newline at end of file
diff --git a/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/messages/formats/vs2005.stg b/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/messages/formats/vs2005.stg
new file mode 100644
index 0000000..0c94e48
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/messages/formats/vs2005.stg
@@ -0,0 +1,42 @@
+/*
+ [The "BSD license"]
+ Copyright (c) 2006 Kay Roepke
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*
+ New style messages. This file contains the actual layout of the messages emitted by ANTLR.
+ The text itself is coming out of the languages/*stg files, according to the chosen locale.
+ This file contains the default format ANTLR uses.
+*/
+
+group antlr;
+
+location(file, line, column) ::= "<file>(<line>,<column>)"
+
+message(id, text) ::= "error <id> : <text>"
+
+report(location, message, type) ::= "<location> : <type> <message.id> : <message.text>"
+
+wantsSingleLineMessage() ::= "true"
diff --git a/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/messages/languages/en.stg b/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/messages/languages/en.stg
new file mode 100644
index 0000000..ea27ddc
--- /dev/null
+++ b/packages/Antlr34.3.4.19004.1/tools/Tool/Templates/messages/languages/en.stg
@@ -0,0 +1,297 @@
+/*
+ [The "BSD license"]
+ Copyright (c) 2010 Terence Parr
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*
+ New style messages. This file only contains the messages in English, but no
+ information about which file, line, or column it occurred in.
+ The location and message ids are taken out of the formats directory.
+														Kay Roepke
+*/
+group en_US;
+
+// TOOL ERRORS
+// file errors
+CANNOT_WRITE_FILE(arg,exception,stackTrace) ::= <<
+cannot write file <arg>: <exception>
+<stackTrace; separator="\n">
+>>
+CANNOT_CLOSE_FILE(arg,exception,stackTrace) ::= "cannot close file <arg>: <exception>"
+CANNOT_FIND_TOKENS_FILE(arg) ::= "cannot find tokens file <arg>"
+ERROR_READING_TOKENS_FILE(arg,exception,stackTrace) ::= <<
+problem reading token vocabulary file <arg>: <exception>
+<stackTrace; separator="\n">
+>>
+DIR_NOT_FOUND(arg,exception,stackTrace) ::= "directory not found: <arg>"
+OUTPUT_DIR_IS_FILE(arg,exception,stackTrace) ::= "output directory is a file: <arg>"
+CANNOT_OPEN_FILE(arg,exception,stackTrace) ::= "cannot find or open file: <arg><if(exception)>; reason: <exception><endif>"
+CIRCULAR_DEPENDENCY() ::= "your grammars contain a circular dependency and cannot be sorted into a valid build order."
+
+INTERNAL_ERROR(arg,arg2,exception,stackTrace) ::= <<
+internal error: <arg> <arg2><if(exception)>: <exception><endif>
+<stackTrace; separator="\n">
+>>
+INTERNAL_WARNING(arg) ::= "internal warning: <arg>"
+ERROR_CREATING_ARTIFICIAL_RULE(arg,exception,stackTrace) ::= <<
+problems creating lexer rule listing all tokens: <exception>
+<stackTrace; separator="\n">
+>>
+TOKENS_FILE_SYNTAX_ERROR(arg,arg2) ::=
+	"problems parsing token vocabulary file <arg> on line <arg2>"
+CANNOT_GEN_DOT_FILE(arg,exception,stackTrace) ::=
+	"cannot write DFA DOT file <arg>: <exception>"
+BAD_ACTION_AST_STRUCTURE(exception,stackTrace) ::=
+	"bad internal tree structure for action '<arg>': <exception>"
+BAD_AST_STRUCTURE(arg,exception,stackTrace) ::= <<
+bad internal tree structure '<arg>': <exception>
+<stackTrace; separator="\n">
+>>
+FILE_AND_GRAMMAR_NAME_DIFFER(arg,arg2) ::=
+  "file <arg2> contains grammar <arg>; names must be identical"
+FILENAME_EXTENSION_ERROR(arg) ::=
+  "file <arg> must end in a file extension, normally .g"
+
+// code gen errors
+MISSING_CODE_GEN_TEMPLATES(arg) ::=
+	"cannot find code generation templates <arg>.stg"
+MISSING_CYCLIC_DFA_CODE_GEN_TEMPLATES() ::=
+	"cannot find code generation cyclic DFA templates for language <arg>"
+CODE_GEN_TEMPLATES_INCOMPLETE(arg) ::=
+	"at least one code generation template missing for language <arg>"
+CANNOT_CREATE_TARGET_GENERATOR(arg,exception,stackTrace) ::=
+	"cannot create target <arg> code generator: <exception>"
+CANNOT_COMPUTE_SAMPLE_INPUT_SEQ() ::=
+	"cannot generate a sample input sequence from lookahead DFA"
+
+// grammar interpretation errors
+/*
+NO_VIABLE_DFA_ALT(arg,arg2) ::=
+	"no viable transition from state <arg> on <arg2> while interpreting DFA"
+*/
+
+// GRAMMAR ERRORS
+SYNTAX_ERROR(arg) ::= "syntax error: <arg>"
+RULE_REDEFINITION(arg) ::=
+	"rule <arg> redefinition"
+LEXER_RULES_NOT_ALLOWED(arg) ::=
+	"lexer rule <arg> not allowed in parser"
+PARSER_RULES_NOT_ALLOWED(arg) ::=
+	"parser rule <arg> not allowed in lexer"
+CANNOT_FIND_ATTRIBUTE_NAME_IN_DECL(arg) ::=
+	"cannot find an attribute name in attribute declaration"
+NO_TOKEN_DEFINITION(arg) ::=
+	"no lexer rule corresponding to token: <arg>"
+UNDEFINED_RULE_REF(arg) ::=
+	"reference to undefined rule: <arg>"
+LITERAL_NOT_ASSOCIATED_WITH_LEXER_RULE(arg) ::=
+	"literal has no associated lexer rule: <arg>"
+CANNOT_ALIAS_TOKENS_IN_LEXER(arg) ::=
+	"literals are illegal in lexer tokens{} section: <arg>"
+ATTRIBUTE_REF_NOT_IN_RULE(arg,arg2) ::=
+	"reference to attribute outside of a rule: <arg><if(arg2)>.<arg2><endif>"
+UNKNOWN_ATTRIBUTE_IN_SCOPE(arg,arg2) ::=
+	"unknown attribute for <arg>: <arg2>"
+UNKNOWN_RULE_ATTRIBUTE(arg,arg2) ::=
+	"unknown attribute for rule <arg>: <arg2>"
+UNKNOWN_SIMPLE_ATTRIBUTE(arg,args2) ::=
+	"attribute is not a token, parameter, or return value: <arg>"
+ISOLATED_RULE_SCOPE(arg) ::=
+	"missing attribute access on rule scope: <arg>"
+INVALID_RULE_PARAMETER_REF(arg,arg2) ::=
+	"cannot access rule <arg>'s parameter: <arg2>"
+INVALID_RULE_SCOPE_ATTRIBUTE_REF(arg,arg2) ::=
+	"cannot access rule <arg>'s dynamically-scoped attribute: <arg2>"
+SYMBOL_CONFLICTS_WITH_GLOBAL_SCOPE(arg) ::=
+	"symbol <arg> conflicts with global dynamic scope with same name"
+WRITE_TO_READONLY_ATTR(arg,arg2,arg3) ::=
+	"cannot write to read only attribute: $<arg><if(arg2)>.<arg2><endif>"
+LABEL_CONFLICTS_WITH_RULE(arg) ::=
+	"label <arg> conflicts with rule with same name"
+LABEL_CONFLICTS_WITH_TOKEN(arg) ::=
+	"label <arg> conflicts with token with same name"
+LABEL_CONFLICTS_WITH_RULE_SCOPE_ATTRIBUTE(arg,arg2) ::=
+	"label <arg> conflicts with rule <arg2>'s dynamically-scoped attribute with same name"
+LABEL_CONFLICTS_WITH_RULE_ARG_RETVAL(arg,arg2) ::=
+	"label <arg> conflicts with rule <arg2>'s return value or parameter with same name"
+ATTRIBUTE_CONFLICTS_WITH_RULE(arg,arg2) ::=
+	"rule <arg2>'s dynamically-scoped attribute <arg> conflicts with the rule name"
+ATTRIBUTE_CONFLICTS_WITH_RULE_ARG_RETVAL(arg,arg2) ::=
+	"rule <arg2>'s dynamically-scoped attribute <arg> conflicts with<arg2>'s return value or parameter with same name"
+LABEL_TYPE_CONFLICT(arg,arg2) ::=
+	"label <arg> type mismatch with previous definition: <arg2>"
+ARG_RETVAL_CONFLICT(arg,arg2) ::=
+	"rule <arg2>'s argument <arg> conflicts a return value with same name"
+NONUNIQUE_REF(arg) ::=
+	"<arg> is a non-unique reference"
+FORWARD_ELEMENT_REF(arg) ::=
+	"illegal forward reference: <arg>"
+MISSING_RULE_ARGS(arg) ::=
+	"missing parameter(s) on rule reference: <arg>"
+RULE_HAS_NO_ARGS(arg) ::=
+	"rule <arg> has no defined parameters"
+ARGS_ON_TOKEN_REF(arg) ::=
+	"token reference <arg> may not have parameters"
+ILLEGAL_OPTION(arg) ::=
+	"illegal option <arg>"
+LIST_LABEL_INVALID_UNLESS_RETVAL_STRUCT(arg) ::=
+	"rule '+=' list labels are not allowed w/o output option: <arg>"
+UNDEFINED_TOKEN_REF_IN_REWRITE(arg) ::=
+  "reference to undefined token in rewrite rule: <arg>"
+REWRITE_ELEMENT_NOT_PRESENT_ON_LHS(arg) ::=
+  "reference to rewrite element <arg> without reference on left of ->"
+UNDEFINED_LABEL_REF_IN_REWRITE(arg) ::=
+  "reference to undefined label in rewrite rule: $<arg>"
+NO_GRAMMAR_START_RULE (arg) ::=
+  "grammar <arg>: no start rule (no rule can obviously be followed by EOF)"
+EMPTY_COMPLEMENT(arg) ::= <<
+<if(arg)>
+set complement ~<arg> is empty
+<else>
+set complement is empty
+<endif>
+>>
+UNKNOWN_DYNAMIC_SCOPE(arg) ::=
+  "unknown dynamic scope: <arg>"
+UNKNOWN_DYNAMIC_SCOPE_ATTRIBUTE(arg,arg2) ::=
+  "unknown dynamically-scoped attribute for scope <arg>: <arg2>"
+RULE_REF_AMBIG_WITH_RULE_IN_ALT(arg) ::=
+  "reference $<arg> is ambiguous; rule <arg> is enclosing rule and referenced in the production (assuming enclosing rule)"
+ISOLATED_RULE_ATTRIBUTE(arg) ::=
+  "reference to locally-defined rule scope attribute without rule name: <arg>"
+INVALID_ACTION_SCOPE(arg,arg2) ::=
+  "unknown or invalid action scope for <arg2> grammar: <arg>"
+ACTION_REDEFINITION(arg) ::=
+  "redefinition of <arg> action"
+DOUBLE_QUOTES_ILLEGAL(arg) ::=
+  "string literals must use single quotes (such as \'begin\'): <arg>"
+INVALID_TEMPLATE_ACTION(arg) ::=
+  "invalid StringTemplate % shorthand syntax: '<arg>'"
+MISSING_ATTRIBUTE_NAME() ::=
+  "missing attribute name on $ reference"
+ARG_INIT_VALUES_ILLEGAL(arg) ::=
+  "rule parameters may not have init values: <arg>"
+REWRITE_OR_OP_WITH_NO_OUTPUT_OPTION(arg) ::=
+  "<if(arg)>rule <arg> uses <endif>rewrite syntax or operator with no output option; setting output=AST"
+AST_OP_WITH_NON_AST_OUTPUT_OPTION(arg) ::=
+  "AST operator with non-AST output option: <arg>"
+NO_RULES(arg) ::= "grammar file <arg> has no rules"
+MISSING_AST_TYPE_IN_TREE_GRAMMAR(arg) ::=
+  "tree grammar <arg> has no ASTLabelType option"
+REWRITE_FOR_MULTI_ELEMENT_ALT(arg) ::=
+  "with rewrite=true, alt <arg> not simple node or obvious tree element; text attribute for rule not guaranteed to be correct"
+RULE_INVALID_SET(arg) ::=
+  "Cannot complement rule <arg>; not a simple set or element"
+HETERO_ILLEGAL_IN_REWRITE_ALT(arg) ::=
+  "alts with rewrites can't use heterogeneous types left of ->"
+NO_SUCH_GRAMMAR_SCOPE(arg,arg2) ::=
+  "reference to undefined grammar in rule reference: <arg>.<arg2>"
+NO_SUCH_RULE_IN_SCOPE(arg,arg2) ::=
+  "rule <arg2> is not defined in grammar <arg>"
+TOKEN_ALIAS_CONFLICT(arg,arg2) ::=
+  "cannot alias <arg>; string already assigned to <arg2>"
+TOKEN_ALIAS_REASSIGNMENT(arg,arg2) ::=
+  "cannot alias <arg>; token name already assigned to <arg2>"
+TOKEN_VOCAB_IN_DELEGATE(arg,arg2) ::=
+  "tokenVocab option ignored in imported grammar <arg>"
+INVALID_IMPORT(arg,arg2) ::=
+  "<arg.grammarTypeString> grammar <arg.name> cannot import <arg2.grammarTypeString> grammar <arg2.name>"
+IMPORTED_TOKENS_RULE_EMPTY(arg,arg2) ::=
+  "no lexer rules contributed to <arg> from imported grammar <arg2>"
+IMPORT_NAME_CLASH(arg,arg2) ::=
+  "combined grammar <arg.name> and imported <arg2.grammarTypeString> grammar <arg2.name> both generate <arg2.recognizerName>; import ignored"
+AST_OP_IN_ALT_WITH_REWRITE(arg,arg2) ::=
+  "rule <arg> alt <arg2> uses rewrite syntax and also an AST operator"
+WILDCARD_AS_ROOT(arg) ::= "Wildcard invalid as root; wildcard can itself be a tree"
+CONFLICTING_OPTION_IN_TREE_FILTER(arg,arg2) ::= "option <arg>=<arg2> conflicts with tree grammar filter mode"
+ILLEGAL_OPTION_VALUE(arg, arg2) ::= "value '<arg2>' invalid for option <arg>"
+ALL_OPS_NEED_SAME_ASSOC(arg) ::= "all operators of alt <alt> of left-recursive rule must have same associativity"
+
+// GRAMMAR WARNINGS
+
+GRAMMAR_NONDETERMINISM(input,conflictingAlts,paths,disabled,hasPredicateBlockedByAction) ::=
+<<
+<if(paths)>
+Decision can match input such as "<input>" using multiple alternatives:
+<paths:{ it |  alt <it.alt> via NFA path <it.states; separator=","><\n>}>
+<else>
+Decision can match input such as "<input>" using multiple alternatives: <conflictingAlts; separator=", ">
+<endif>
+<if(disabled)><\n>As a result, alternative(s) <disabled; separator=","> were disabled for that input<endif><if(hasPredicateBlockedByAction)><\n>Semantic predicates were present but were hidden by actions.<endif>
+>>
+
+DANGLING_STATE(danglingAlts,input) ::= <<
+the decision cannot distinguish between alternative(s) <danglingAlts; separator=","> for input such as "<input>"
+>>
+
+UNREACHABLE_ALTS(alts) ::= <<
+The following alternatives can never be matched: <alts; separator=","><\n>
+>>
+
+INSUFFICIENT_PREDICATES(upon,altToLocations,hasPredicateBlockedByAction) ::= <<
+Input such as "<upon>" is insufficiently covered with predicates at locations: <altToLocations.keys:{alt|alt <alt>: <altToLocations.(alt):{loc| line <loc.line>:<loc.column> at <loc.text>}; separator=", ">}; separator=", "><if(hasPredicateBlockedByAction)><\n>Semantic predicates were present but were hidden by actions.<endif>
+>>
+
+DUPLICATE_SET_ENTRY(arg) ::=
+	"duplicate token type <arg> when collapsing subrule into set"
+
+ANALYSIS_ABORTED(enclosingRule) ::= <<
+ANTLR could not analyze this decision in rule <enclosingRule>; often this is because of recursive rule references visible from the left edge of alternatives.  ANTLR will re-analyze the decision with a fixed lookahead of k=1.  Consider using "options {k=1;}" for that decision and possibly adding a syntactic predicate.
+>>
+
+RECURSION_OVERLOW(alt,input,targetRules,callSiteStates) ::= <<
+Alternative <alt>: after matching input such as <input> decision cannot predict what comes next due to recursion overflow <targetRules,callSiteStates:{t,c|to <t> from <c:{s|<s.enclosingRule.name>};separator=", ">}; separator=" and ">
+>>
+
+LEFT_RECURSION(targetRules,alt,callSiteStates) ::= <<
+Alternative <alt> discovers infinite left-recursion <targetRules,callSiteStates:{t,c|to <t> from <c:{s|<s.enclosingRule>};separator=", ">}; separator=" and ">
+>>
+
+UNREACHABLE_TOKENS(tokens) ::= <<
+The following token definitions can never be matched because prior tokens match the same input: <tokens; separator=",">
+>>
+
+TOKEN_NONDETERMINISM(input,conflictingTokens,paths,disabled,hasPredicateBlockedByAction) ::=
+<<
+<if(paths)>
+Decision can match input such as "<input>" using multiple alternatives:
+<paths:{ it | alt <it.alt> via NFA path <it.states; separator=","><\n>}>
+<else>
+Multiple token rules can match input such as "<input>": <conflictingTokens; separator=", "><\n>
+<endif>
+<if(disabled)><\n>As a result, token(s) <disabled; separator=","> were disabled for that input<endif><if(hasPredicateBlockedByAction)><\n>Semantic predicates were present but were hidden by actions.<endif>
+>>
+
+LEFT_RECURSION_CYCLES(listOfCycles) ::= <<
+The following sets of rules are mutually left-recursive <listOfCycles:{c| [<c:{r|<r.name>}; separator=", ">]}; separator=" and ">
+>>
+
+NONREGULAR_DECISION(ruleName,alts) ::= <<
+[fatal] rule <ruleName> has non-LL(*) decision due to recursive rule invocations reachable from alts <alts; separator=",">.  Resolve by left-factoring or using syntactic predicates or using backtrack=true option.
+>>
+
+/* l10n for message levels */
+warning() ::= "warning"
+error() ::= "error"