taskjuggler 0.0.7 → 0.0.8

data/doc/TaskJuggler/TextFormatter.html

@@ -155,12 +155,18 @@
 				
 					<li><a href="../TaskJuggler/ChargeSetListAttribute.html">TaskJuggler::ChargeSetListAttribute</a></li>
 				
+					<li><a href="../TaskJuggler/CollisionDetector.html">TaskJuggler::CollisionDetector</a></li>
+				
 					<li><a href="../TaskJuggler/ColumnListAttribute.html">TaskJuggler::ColumnListAttribute</a></li>
 				
 					<li><a href="../TaskJuggler/ColumnTable.html">TaskJuggler::ColumnTable</a></li>
 				
 					<li><a href="../TaskJuggler/Daemon.html">TaskJuggler::Daemon</a></li>
 				
+					<li><a href="../TaskJuggler/DataCache.html">TaskJuggler::DataCache</a></li>
+				
+					<li><a href="../TaskJuggler/DataCacheEntry.html">TaskJuggler::DataCacheEntry</a></li>
+				
 					<li><a href="../TaskJuggler/DateAttribute.html">TaskJuggler::DateAttribute</a></li>
 				
 					<li><a href="../TaskJuggler/DefinitionListAttribute.html">TaskJuggler::DefinitionListAttribute</a></li>
@@ -267,7 +273,7 @@
 				
 					<li><a href="../TaskJuggler/NodeListAttribute.html">TaskJuggler::NodeListAttribute</a></li>
 				
-					<li><a href="../TaskJuggler/OnShiftCache.html">TaskJuggler::OnShiftCache</a></li>
+					<li><a href="../TaskJuggler/PlaceHolderCell.html">TaskJuggler::PlaceHolderCell</a></li>
 				
 					<li><a href="../TaskJuggler/ProcessIntercom.html">TaskJuggler::ProcessIntercom</a></li>
 				
@@ -447,6 +453,10 @@
 				
 					<li><a href="../TaskJuggler/TextParser/StackElement.html">TaskJuggler::TextParser::StackElement</a></li>
 				
+					<li><a href="../TaskJuggler/TextParser/State.html">TaskJuggler::TextParser::State</a></li>
+				
+					<li><a href="../TaskJuggler/TextParser/StateTransition.html">TaskJuggler::TextParser::StateTransition</a></li>
+				
 					<li><a href="../TaskJuggler/TextParser/TextParserResultArray.html">TaskJuggler::TextParser::TextParserResultArray</a></li>
 				
 					<li><a href="../TaskJuggler/TextParser/TokenDoc.html">TaskJuggler::TextParser::TokenDoc</a></li>

data/doc/TaskJuggler/TextParser.html

@@ -44,6 +44,9 @@
 						<li><a href="../lib/TextParser/Pattern_rb.html?TB_iframe=true&amp;height=550&amp;width=785"
 							class="thickbox" title="lib/TextParser/Pattern.rb">lib/TextParser/Pattern.rb</a></li>
 					
+						<li><a href="../lib/TextParser/State_rb.html?TB_iframe=true&amp;height=550&amp;width=785"
+							class="thickbox" title="lib/TextParser/State.rb">lib/TextParser/State.rb</a></li>
+					
 						<li><a href="../lib/TextParser/Rule_rb.html?TB_iframe=true&amp;height=550&amp;width=785"
 							class="thickbox" title="lib/TextParser/Rule.rb">lib/TextParser/Rule.rb</a></li>
 					
@@ -84,6 +87,10 @@
 					
 					<li><span class="type">CLASS</span> <a href="TextParser/StackElement.html">TaskJuggler::TextParser::StackElement</a></li>
 					
+					<li><span class="type">CLASS</span> <a href="TextParser/State.html">TaskJuggler::TextParser::State</a></li>
+					
+					<li><span class="type">CLASS</span> <a href="TextParser/StateTransition.html">TaskJuggler::TextParser::StateTransition</a></li>
+					
 					<li><span class="type">CLASS</span> <a href="TextParser/TextParserResultArray.html">TaskJuggler::TextParser::TextParserResultArray</a></li>
 					
 					<li><span class="type">CLASS</span> <a href="TextParser/TokenDoc.html">TaskJuggler::TextParser::TokenDoc</a></li>
@@ -102,36 +109,34 @@
 					
 					<li><a href="#method-i-checkRule">#checkRule</a></li>
 					
+					<li><a href="#method-i-dumpStack">#dumpStack</a></li>
+					
 					<li><a href="#method-i-error">#error</a></li>
 					
-					<li><a href="#method-i-findPattern">#findPattern</a></li>
+					<li><a href="#method-i-finishPattern">#finishPattern</a></li>
 					
 					<li><a href="#method-i-getNextToken">#getNextToken</a></li>
 					
-					<li><a href="#method-i-getTransitions">#getTransitions</a></li>
-					
 					<li><a href="#method-i-initRules">#initRules</a></li>
 					
 					<li><a href="#method-i-limitTokenSet">#limitTokenSet</a></li>
 					
-					<li><a href="#method-i-matchingRules">#matchingRules</a></li>
-					
 					<li><a href="#method-i-newRule">#newRule</a></li>
 					
 					<li><a href="#method-i-optional">#optional</a></li>
 					
 					<li><a href="#method-i-parse">#parse</a></li>
 					
-					<li><a href="#method-i-parseRuleNR">#parseRuleNR</a></li>
-					
-					<li><a href="#method-i-parseRuleR">#parseRuleR</a></li>
+					<li><a href="#method-i-parseFSM">#parseFSM</a></li>
 					
 					<li><a href="#method-i-pattern">#pattern</a></li>
 					
-					<li><a href="#method-i-processNormalElements">#processNormalElements</a></li>
-					
 					<li><a href="#method-i-repeatable">#repeatable</a></li>
 					
+					<li><a href="#method-i-restoreFsmStack">#restoreFsmStack</a></li>
+					
+					<li><a href="#method-i-saveFsmStack">#saveFsmStack</a></li>
+					
 					<li><a href="#method-i-sourceFileInfo">#sourceFileInfo</a></li>
 					
 					<li><a href="#method-i-updateParserTables">#updateParserTables</a></li>
@@ -216,12 +221,18 @@
 				
 					<li><a href="../TaskJuggler/ChargeSetListAttribute.html">TaskJuggler::ChargeSetListAttribute</a></li>
 				
+					<li><a href="../TaskJuggler/CollisionDetector.html">TaskJuggler::CollisionDetector</a></li>
+				
 					<li><a href="../TaskJuggler/ColumnListAttribute.html">TaskJuggler::ColumnListAttribute</a></li>
 				
 					<li><a href="../TaskJuggler/ColumnTable.html">TaskJuggler::ColumnTable</a></li>
 				
 					<li><a href="../TaskJuggler/Daemon.html">TaskJuggler::Daemon</a></li>
 				
+					<li><a href="../TaskJuggler/DataCache.html">TaskJuggler::DataCache</a></li>
+				
+					<li><a href="../TaskJuggler/DataCacheEntry.html">TaskJuggler::DataCacheEntry</a></li>
+				
 					<li><a href="../TaskJuggler/DateAttribute.html">TaskJuggler::DateAttribute</a></li>
 				
 					<li><a href="../TaskJuggler/DefinitionListAttribute.html">TaskJuggler::DefinitionListAttribute</a></li>
@@ -328,7 +339,7 @@
 				
 					<li><a href="../TaskJuggler/NodeListAttribute.html">TaskJuggler::NodeListAttribute</a></li>
 				
-					<li><a href="../TaskJuggler/OnShiftCache.html">TaskJuggler::OnShiftCache</a></li>
+					<li><a href="../TaskJuggler/PlaceHolderCell.html">TaskJuggler::PlaceHolderCell</a></li>
 				
 					<li><a href="../TaskJuggler/ProcessIntercom.html">TaskJuggler::ProcessIntercom</a></li>
 				
@@ -508,6 +519,10 @@
 				
 					<li><a href="../TaskJuggler/TextParser/StackElement.html">TaskJuggler::TextParser::StackElement</a></li>
 				
+					<li><a href="../TaskJuggler/TextParser/State.html">TaskJuggler::TextParser::State</a></li>
+				
+					<li><a href="../TaskJuggler/TextParser/StateTransition.html">TaskJuggler::TextParser::StateTransition</a></li>
+				
 					<li><a href="../TaskJuggler/TextParser/TextParserResultArray.html">TaskJuggler::TextParser::TextParserResultArray</a></li>
 				
 					<li><a href="../TaskJuggler/TextParser/TokenDoc.html">TaskJuggler::TextParser::TokenDoc</a></li>
@@ -615,14 +630,12 @@
 
 		<div id="description">
 			<p>
-The <a href="TextParser.html">TextParser</a> implements a regular LALR
-parser. But it uses a recursive rule traversor instead of the more commonly
-found state machine generated by yacc-like tools. Since stack depths is not
-really an issue with a Ruby implementation this approach has one big
-advantage. The syntax of the parser can be modified during parsing. This
-allows support for languages that can extend themself. The <a
-href="../TaskJuggler.html">TaskJuggler</a> syntax is such an beast.
-Traditional yacc generated parsers would fail with such a syntax.
+The <a href="TextParser.html">TextParser</a> implements a somewhat modified
+LL(1) parser. It uses a dynamically compiled state machine. Dynamically
+means, that the syntax can be extended during the parse process. This
+allows support for languages that can extend their syntax during the parse
+process. The <a href="../TaskJuggler.html">TaskJuggler</a> syntax is such
+an beast.
 </p>
 <p>
 This class is just a base class. A complete parser would derive from this
@@ -643,6 +656,15 @@ TextParser#doc, TextParser#descr, TextParser#also and TextParser#arg can be
 used.
 </p>
 <p>
+In contrast to conventional LL grammars, we use a slightly improved syntax
+descriptions. Repeated patterns are not described by recursive call but we
+use a repeat flag for syntax rules that consists of repeatable patterns.
+This removes the need for recursion elimination when compiling the state
+machine and makes the syntax a lot more readable. However, it adds a bit
+more complexity to the state machine. Optional patterns are described by a
+rule flag, not by adding an empty pattern.
+</p>
+<p>
 To start parsing the input the function <a
 href="TextParser.html#method-i-parse">TextParser#parse</a> needs to be
 called with the name of the start rule.
@@ -672,19 +694,6 @@ Copyright &#169; 2006, 2007, 2008, 2009, 2010 by Chris Schlaeger
 This program is free software; you can redistribute it and/or modify it
 under the terms of version 2 of the GNU General Public License as published
 by the Free Software Foundation.
-</p>
-<hr style="height: 1px"></hr><p>
-encoding: UTF-8
-</p>
-<h1>StackElement.rb &#8212; The <a href="../TaskJuggler.html">TaskJuggler</a> III <a href="Project.html">Project</a> Management Software</h1>
-<p>
-Copyright &#169; 2006, 2007, 2008, 2009, 2010 by Chris Schlaeger
-<cs@kde.org>
-</p>
-<p>
-This program is free software; you can redistribute it and/or modify it
-under the terms of version 2 of the GNU General Public License as published
-by the Free Software Foundation.
 </p>
 
 		</div>
@@ -759,19 +768,25 @@ Create a new <a href="TextParser.html">TextParser</a> object.
 					<div class="method-source-code"
 						id="new-source">
 <pre>
-    <span class="ruby-comment cmt"># File lib/TextParser.rb, line 71</span>
-71:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">messageHandler</span>)
-72:       <span class="ruby-comment cmt"># The message handler will collect all error messages.</span>
-73:       <span class="ruby-ivar">@messageHandler</span> = <span class="ruby-identifier">messageHandler</span>
-74:       <span class="ruby-comment cmt"># This Hash will store the ruleset that the parser is operating on.</span>
-75:       <span class="ruby-ivar">@rules</span> = { }
-76:       <span class="ruby-comment cmt"># Array to hold the token types that the scanner can return.</span>
-77:       <span class="ruby-ivar">@variables</span> = []
-78:       <span class="ruby-comment cmt"># An list of token types that are not allowed in the current context.</span>
-79:       <span class="ruby-ivar">@badVariables</span> = []
-80:       <span class="ruby-comment cmt"># The currently processed rule.</span>
-81:       <span class="ruby-ivar">@cr</span> = <span class="ruby-keyword kw">nil</span>
-82:     <span class="ruby-keyword kw">end</span></pre>
+    <span class="ruby-comment cmt"># File lib/TextParser.rb, line 77</span>
+77:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">messageHandler</span>)
+78:       <span class="ruby-comment cmt"># The message handler will collect all error messages.</span>
+79:       <span class="ruby-ivar">@messageHandler</span> = <span class="ruby-identifier">messageHandler</span>
+80:       <span class="ruby-comment cmt"># This Hash will store the ruleset that the parser is operating on.</span>
+81:       <span class="ruby-ivar">@rules</span> = { }
+82:       <span class="ruby-comment cmt"># Array to hold the token types that the scanner can return.</span>
+83:       <span class="ruby-ivar">@variables</span> = []
+84:       <span class="ruby-comment cmt"># An list of token types that are not allowed in the current context.</span>
+85:       <span class="ruby-comment cmt"># For performance reasons we use a hash with the token as key. The value</span>
+86:       <span class="ruby-comment cmt"># is irrelevant.</span>
+87:       <span class="ruby-ivar">@blockedVariables</span> = {}
+88:       <span class="ruby-comment cmt"># The currently processed rule.</span>
+89:       <span class="ruby-ivar">@cr</span> = <span class="ruby-keyword kw">nil</span>
+90: 
+91:       <span class="ruby-ivar">@states</span> = {}
+92:       <span class="ruby-comment cmt"># The stack used by the FSM.</span>
+93:       <span class="ruby-ivar">@stack</span> = <span class="ruby-keyword kw">nil</span>
+94:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -808,17 +823,17 @@ Create a new <a href="TextParser.html">TextParser</a> object.
 					<div class="method-source-code"
 						id="error-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 197</span>
-197:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">error</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span> = <span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">data</span> = <span class="ruby-keyword kw">nil</span>)
-198:       <span class="ruby-identifier">sfi</span> <span class="ruby-operator">||=</span> <span class="ruby-identifier">sourceFileInfo</span>
-199:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@scanner</span>
-200:         <span class="ruby-comment cmt"># The scanner has some more context information, so we pass the error</span>
-201:         <span class="ruby-comment cmt"># on to the TextScanner.</span>
-202:         <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">error</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
-203:       <span class="ruby-keyword kw">else</span>
-204:         <span class="ruby-ivar">@messageHandler</span>.<span class="ruby-identifier">error</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
-205:       <span class="ruby-keyword kw">end</span>
-206:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 219</span>
+219:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">error</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span> = <span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">data</span> = <span class="ruby-keyword kw">nil</span>)
+220:       <span class="ruby-identifier">sfi</span> <span class="ruby-operator">||=</span> <span class="ruby-identifier">sourceFileInfo</span>
+221:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@scanner</span>
+222:         <span class="ruby-comment cmt"># The scanner has some more context information, so we pass the error</span>
+223:         <span class="ruby-comment cmt"># on to the TextScanner.</span>
+224:         <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">error</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
+225:       <span class="ruby-keyword kw">else</span>
+226:         <span class="ruby-ivar">@messageHandler</span>.<span class="ruby-identifier">error</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
+227:       <span class="ruby-keyword kw">end</span>
+228:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -852,17 +867,17 @@ rules.
 					<div class="method-source-code"
 						id="init-ules-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 94</span>
- 94:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initRules</span>
- 95:       <span class="ruby-identifier">methods</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">m</span><span class="ruby-operator">|</span>
- 96:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">m</span>[<span class="ruby-value">0</span>, <span class="ruby-value">5</span>] <span class="ruby-operator">==</span> <span class="ruby-value str">'rule_'</span>
- 97:           <span class="ruby-comment cmt"># Create a new rule with the suffix of the function name as name.</span>
- 98:           <span class="ruby-identifier">newRule</span>(<span class="ruby-identifier">m</span>[<span class="ruby-value">5</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>])
- 99:           <span class="ruby-comment cmt"># Call the function.</span>
-100:           <span class="ruby-identifier">send</span>(<span class="ruby-identifier">m</span>)
-101:         <span class="ruby-keyword kw">end</span>
-102:       <span class="ruby-keyword kw">end</span>
-103:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 111</span>
+111:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initRules</span>
+112:       <span class="ruby-identifier">methods</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">m</span><span class="ruby-operator">|</span>
+113:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">m</span>[<span class="ruby-value">0</span>, <span class="ruby-value">5</span>] <span class="ruby-operator">==</span> <span class="ruby-value str">'rule_'</span>
+114:           <span class="ruby-comment cmt"># Create a new rule with the suffix of the function name as name.</span>
+115:           <span class="ruby-identifier">newRule</span>(<span class="ruby-identifier">m</span>[<span class="ruby-value">5</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>])
+116:           <span class="ruby-comment cmt"># Call the function.</span>
+117:           <span class="ruby-identifier">send</span>(<span class="ruby-identifier">m</span>)
+118:         <span class="ruby-keyword kw">end</span>
+119:       <span class="ruby-keyword kw">end</span>
+120:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -896,52 +911,18 @@ Limit the allowed tokens of the scanner to the subset passed by the
 					<div class="method-source-code"
 						id="limit-oken-et-source">
 <pre>
-    <span class="ruby-comment cmt"># File lib/TextParser.rb, line 86</span>
-86:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">limitTokenSet</span>(<span class="ruby-identifier">tokenSet</span>)
-87:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">tokenSet</span>
-88: 
-89:       <span class="ruby-ivar">@badVariables</span> = <span class="ruby-ivar">@variables</span>.<span class="ruby-identifier">dup</span>
-90:       <span class="ruby-ivar">@badVariables</span>.<span class="ruby-identifier">delete_if</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">v</span><span class="ruby-operator">|</span> <span class="ruby-identifier">tokenSet</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">v</span>) }
-91:     <span class="ruby-keyword kw">end</span></pre>
-					</div>
-					
-				</div>
-
-				
-
-				
-			</div>
-
-		
-			<div id="matching-ules-method" class="method-detail ">
-				<a name="method-i-matchingRules"></a>
-
-				<div class="method-heading">
-				
-					<span class="method-name">matchingRules</span><span
-						class="method-args">(keyword)</span>
-					<span class="method-click-advice">click to toggle source</span>
-				
-				</div>
-
-				<div class="method-description">
-					
-					
-					
-
-					
-					<div class="method-source-code"
-						id="matching-ules-source">
-<pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 188</span>
-188:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">matchingRules</span>(<span class="ruby-identifier">keyword</span>)
-189:       <span class="ruby-identifier">matches</span> = []
-190:       <span class="ruby-ivar">@rules</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">name</span>, <span class="ruby-identifier">rule</span><span class="ruby-operator">|</span>
-191:         <span class="ruby-identifier">patIdx</span> = <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">matchingPatternIndex</span>(<span class="ruby-value str">'_'</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">keyword</span>)
-192:         <span class="ruby-identifier">matches</span> <span class="ruby-operator">&lt;&lt;</span> [ <span class="ruby-identifier">rule</span>, <span class="ruby-identifier">patIdx</span> ] <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">patIdx</span>
-193:       <span class="ruby-keyword kw">end</span>
-194:       <span class="ruby-identifier">matches</span>
-195:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 98</span>
+ 98:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">limitTokenSet</span>(<span class="ruby-identifier">tokenSet</span>)
+ 99:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">tokenSet</span>
+100: 
+101:       <span class="ruby-comment cmt"># Create a copy of all supported variables.</span>
+102:       <span class="ruby-identifier">blockedVariables</span> = <span class="ruby-ivar">@variables</span>.<span class="ruby-identifier">dup</span>
+103:       <span class="ruby-comment cmt"># Then delete all that are in the limited set.</span>
+104:       <span class="ruby-identifier">blockedVariables</span>.<span class="ruby-identifier">delete_if</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">v</span><span class="ruby-operator">|</span> <span class="ruby-identifier">tokenSet</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">v</span>) }
+105:       <span class="ruby-comment cmt"># And convert the list into a Hash for faster lookups.</span>
+106:       <span class="ruby-ivar">@blockedVariables</span> = {}
+107:       <span class="ruby-identifier">blockedVariables</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">v</span><span class="ruby-operator">|</span> <span class="ruby-ivar">@blockedVariables</span>[<span class="ruby-identifier">v</span>] = <span class="ruby-keyword kw">true</span> }
+108:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -979,19 +960,21 @@ then implicitely operate on the most recently added rule.
 					<div class="method-source-code"
 						id="new-ule-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 110</span>
-110:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">newRule</span>(<span class="ruby-identifier">name</span>)
-111:       <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Fatal Error: Rule #{name} already exists&quot;</span> <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@rules</span>.<span class="ruby-identifier">has_key?</span>(<span class="ruby-identifier">name</span>)
-112: 
-113:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">block_given?</span>
-114:         <span class="ruby-identifier">saveCr</span> = <span class="ruby-ivar">@cr</span>
-115:         <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-ivar">@cr</span> = <span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">Rule</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">name</span>)
-116:         <span class="ruby-keyword kw">yield</span>
-117:         <span class="ruby-ivar">@cr</span> = <span class="ruby-identifier">saveCr</span>
-118:       <span class="ruby-keyword kw">else</span>
-119:         <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-ivar">@cr</span> = <span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">Rule</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">name</span>)
-120:       <span class="ruby-keyword kw">end</span>
-121:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 127</span>
+127:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">newRule</span>(<span class="ruby-identifier">name</span>)
+128:       <span class="ruby-comment cmt"># Use a symbol instead of a String.</span>
+129:       <span class="ruby-identifier">name</span> = <span class="ruby-identifier">name</span>.<span class="ruby-identifier">intern</span>
+130:       <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Fatal Error: Rule #{name} already exists&quot;</span> <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@rules</span>.<span class="ruby-identifier">has_key?</span>(<span class="ruby-identifier">name</span>)
+131: 
+132:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">block_given?</span>
+133:         <span class="ruby-identifier">saveCr</span> = <span class="ruby-ivar">@cr</span>
+134:         <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-ivar">@cr</span> = <span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">Rule</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">name</span>)
+135:         <span class="ruby-keyword kw">yield</span>
+136:         <span class="ruby-ivar">@cr</span> = <span class="ruby-identifier">saveCr</span>
+137:       <span class="ruby-keyword kw">else</span>
+138:         <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-ivar">@cr</span> = <span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">Rule</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">name</span>)
+139:       <span class="ruby-keyword kw">end</span>
+140:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1025,10 +1008,10 @@ elements.
 					<div class="method-source-code"
 						id="optional-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 140</span>
-140:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">optional</span>
-141:       <span class="ruby-ivar">@cr</span>.<span class="ruby-identifier">setOptional</span>
-142:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 159</span>
+159:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">optional</span>
+160:       <span class="ruby-ivar">@cr</span>.<span class="ruby-identifier">setOptional</span>
+161:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1064,22 +1047,21 @@ an error, the result is false.
 					<div class="method-source-code"
 						id="parse-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 164</span>
-164:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">parse</span>(<span class="ruby-identifier">ruleName</span>)
-165:       <span class="ruby-ivar">@stack</span> = []
-166:       <span class="ruby-identifier">@@expectedTokens</span> = []
-167:       <span class="ruby-identifier">updateParserTables</span>
-168:       <span class="ruby-keyword kw">begin</span>
-169:         <span class="ruby-identifier">result</span> = <span class="ruby-identifier">parseRuleR</span>(<span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">ruleName</span>])
-170:       <span class="ruby-keyword kw">rescue</span> <span class="ruby-constant">TjException</span> =<span class="ruby-operator">&gt;</span> <span class="ruby-identifier">msg</span>
-171:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">msg</span>.<span class="ruby-identifier">message</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-operator">!</span><span class="ruby-identifier">msg</span>.<span class="ruby-identifier">message</span>.<span class="ruby-identifier">empty?</span>
-172:           <span class="ruby-ivar">@messageHandler</span>.<span class="ruby-identifier">critical</span>(<span class="ruby-value str">'parse'</span>, <span class="ruby-identifier">msg</span>.<span class="ruby-identifier">message</span>)
-173:         <span class="ruby-keyword kw">end</span>
-174:         <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">false</span>
-175:       <span class="ruby-keyword kw">end</span>
-176: 
-177:       <span class="ruby-identifier">result</span>
-178:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 196</span>
+196:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">parse</span>(<span class="ruby-identifier">ruleName</span>)
+197:       <span class="ruby-ivar">@stack</span> = []
+198:       <span class="ruby-identifier">@@expectedTokens</span> = []
+199:       <span class="ruby-keyword kw">begin</span>
+200:         <span class="ruby-identifier">result</span> = <span class="ruby-identifier">parseFSM</span>(<span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">ruleName</span>])
+201:       <span class="ruby-keyword kw">rescue</span> <span class="ruby-constant">TjException</span> =<span class="ruby-operator">&gt;</span> <span class="ruby-identifier">msg</span>
+202:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">msg</span>.<span class="ruby-identifier">message</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-operator">!</span><span class="ruby-identifier">msg</span>.<span class="ruby-identifier">message</span>.<span class="ruby-identifier">empty?</span>
+203:           <span class="ruby-ivar">@messageHandler</span>.<span class="ruby-identifier">critical</span>(<span class="ruby-value str">'parse'</span>, <span class="ruby-identifier">msg</span>.<span class="ruby-identifier">message</span>)
+204:         <span class="ruby-keyword kw">end</span>
+205:         <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">false</span>
+206:       <span class="ruby-keyword kw">end</span>
+207: 
+208:       <span class="ruby-identifier">result</span>
+209:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1133,10 +1115,10 @@ completed the processing of this rule.
 					<div class="method-source-code"
 						id="pattern-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 134</span>
-134:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">pattern</span>(<span class="ruby-identifier">tokens</span>, <span class="ruby-identifier">func</span> = <span class="ruby-keyword kw">nil</span>)
-135:       <span class="ruby-ivar">@cr</span>.<span class="ruby-identifier">addPattern</span>(<span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">Pattern</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">tokens</span>, <span class="ruby-identifier">func</span>))
-136:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 153</span>
+153:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">pattern</span>(<span class="ruby-identifier">tokens</span>, <span class="ruby-identifier">func</span> = <span class="ruby-keyword kw">nil</span>)
+154:       <span class="ruby-ivar">@cr</span>.<span class="ruby-identifier">addPattern</span>(<span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">Pattern</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">tokens</span>, <span class="ruby-identifier">func</span>))
+155:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1170,10 +1152,10 @@ elements.
 					<div class="method-source-code"
 						id="repeatable-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 146</span>
-146:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">repeatable</span>
-147:       <span class="ruby-ivar">@cr</span>.<span class="ruby-identifier">setRepeatable</span>
-148:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 165</span>
+165:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">repeatable</span>
+166:       <span class="ruby-ivar">@cr</span>.<span class="ruby-identifier">setRepeatable</span>
+167:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1209,11 +1191,11 @@ nil if we don&#8217;t have a current position.
 					<div class="method-source-code"
 						id="source-ile-nfo-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 183</span>
-183:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">sourceFileInfo</span>
-184:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">nil</span> <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-operator">||</span> <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">empty?</span>
-185:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">sourceFileInfo</span>[<span class="ruby-value">0</span>]
-186:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 214</span>
+214:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">sourceFileInfo</span>
+215:       <span class="ruby-keyword kw">return</span> <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">sourceFileInfo</span> <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-operator">||</span> <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">&lt;=</span> <span class="ruby-value">1</span>
+216:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">firstSourceFileInfo</span>
+217:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1240,7 +1222,9 @@ nil if we don&#8217;t have a current position.
 					<p>
 This function needs to be called whenever new rules or patterns have been
 added and before the next call to <a
-href="TextParser.html#method-i-parse">TextParser#parse</a>.
+href="TextParser.html#method-i-parse">TextParser#parse</a>. It&#8217;s
+perfectly ok to call this function from within a parse() call as long as
+the states that are currently on the stack have not been modified.
 </p>
 					
 
@@ -1248,14 +1232,25 @@ href="TextParser.html#method-i-parse">TextParser#parse</a>.
 					<div class="method-source-code"
 						id="update-arser-ables-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 152</span>
-152:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">updateParserTables</span>
-153:       <span class="ruby-ivar">@rules</span>.<span class="ruby-identifier">each_value</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">rule</span><span class="ruby-operator">|</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">transitions</span> = {} }
-154:       <span class="ruby-ivar">@rules</span>.<span class="ruby-identifier">each_value</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">rule</span><span class="ruby-operator">|</span>
-155:         <span class="ruby-identifier">getTransitions</span>(<span class="ruby-identifier">rule</span>)
-156:         <span class="ruby-identifier">checkRule</span>(<span class="ruby-identifier">rule</span>)
-157:       <span class="ruby-keyword kw">end</span>
-158:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 173</span>
+173:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">updateParserTables</span>
+174:       <span class="ruby-identifier">saveFsmStack</span>
+175:       <span class="ruby-comment cmt"># Invalidate some cached data.</span>
+176:       <span class="ruby-ivar">@rules</span>.<span class="ruby-identifier">each_value</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">rule</span><span class="ruby-operator">|</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">flushCache</span> }
+177:       <span class="ruby-ivar">@states</span> = {}
+178:       <span class="ruby-comment cmt"># Generate the parser states for all patterns of all rules.</span>
+179:       <span class="ruby-ivar">@rules</span>.<span class="ruby-identifier">each_value</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">rule</span><span class="ruby-operator">|</span>
+180:         <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">generateStates</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">s</span><span class="ruby-operator">|</span>
+181:           <span class="ruby-ivar">@states</span>[[ <span class="ruby-identifier">s</span>.<span class="ruby-identifier">rule</span>, <span class="ruby-identifier">s</span>.<span class="ruby-identifier">pattern</span>, <span class="ruby-identifier">s</span>.<span class="ruby-identifier">index</span> ]] = <span class="ruby-identifier">s</span>
+182:         <span class="ruby-keyword kw">end</span>
+183:         <span class="ruby-identifier">checkRule</span>(<span class="ruby-identifier">rule</span>)
+184:       <span class="ruby-keyword kw">end</span>
+185:       <span class="ruby-comment cmt"># Compute the transitions between the generated states.</span>
+186:       <span class="ruby-ivar">@states</span>.<span class="ruby-identifier">each_value</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">state</span><span class="ruby-operator">|</span>
+187:         <span class="ruby-identifier">state</span>.<span class="ruby-identifier">addTransitions</span>(<span class="ruby-ivar">@states</span>, <span class="ruby-ivar">@rules</span>)
+188:       <span class="ruby-keyword kw">end</span>
+189:       <span class="ruby-identifier">restoreFsmStack</span>
+190:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1286,17 +1281,17 @@ href="TextParser.html#method-i-parse">TextParser#parse</a>.
 					<div class="method-source-code"
 						id="warning-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 208</span>
-208:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">warning</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span> = <span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">data</span> = <span class="ruby-keyword kw">nil</span>)
-209:       <span class="ruby-identifier">sfi</span> <span class="ruby-operator">||=</span> <span class="ruby-identifier">sourceFileInfo</span>
-210:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@scanner</span>
-211:         <span class="ruby-comment cmt"># The scanner has some more context information, so we pass the</span>
-212:         <span class="ruby-comment cmt"># warning on to the TextScanner.</span>
-213:         <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">warning</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
-214:       <span class="ruby-keyword kw">else</span>
-215:         <span class="ruby-ivar">@messageHandler</span>.<span class="ruby-identifier">warning</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
-216:       <span class="ruby-keyword kw">end</span>
-217:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 230</span>
+230:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">warning</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span> = <span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">data</span> = <span class="ruby-keyword kw">nil</span>)
+231:       <span class="ruby-identifier">sfi</span> <span class="ruby-operator">||=</span> <span class="ruby-identifier">sourceFileInfo</span>
+232:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@scanner</span>
+233:         <span class="ruby-comment cmt"># The scanner has some more context information, so we pass the</span>
+234:         <span class="ruby-comment cmt"># warning on to the TextScanner.</span>
+235:         <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">warning</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
+236:       <span class="ruby-keyword kw">else</span>
+237:         <span class="ruby-ivar">@messageHandler</span>.<span class="ruby-identifier">warning</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
+238:       <span class="ruby-keyword kw">end</span>
+239:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1333,30 +1328,28 @@ href="TextParser.html#method-i-parse">TextParser#parse</a>.
 					<div class="method-source-code"
 						id="check-ule-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 277</span>
-277:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">checkRule</span>(<span class="ruby-identifier">rule</span>)
-278:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">patterns</span>.<span class="ruby-identifier">empty?</span>
-279:         <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Rule #{rule.name} must have at least one pattern&quot;</span>
-280:       <span class="ruby-keyword kw">end</span>
-281: 
-282:       <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">patterns</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">pat</span><span class="ruby-operator">|</span>
-283:         <span class="ruby-identifier">pat</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">tok</span><span class="ruby-operator">|</span>
-284:           <span class="ruby-identifier">type</span> = <span class="ruby-identifier">tok</span>[<span class="ruby-value">0</span>]
-285:           <span class="ruby-identifier">token</span> = <span class="ruby-identifier">tok</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>]
-286:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">$$</span>
-287:             <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@variables</span>.<span class="ruby-identifier">index</span>(<span class="ruby-identifier">token</span>).<span class="ruby-identifier">nil?</span>
-288:               <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unsupported_token'</span>,
-289:                     <span class="ruby-node">&quot;The token #{token} is not supported here.&quot;</span>, <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>])
-290:             <span class="ruby-keyword kw">end</span>
-291:           <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">!!</span>
-292:             <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">token</span>].<span class="ruby-identifier">nil?</span>
-293:               <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Fatal Error: Reference to unknown rule #{token} in &quot;</span> <span class="ruby-operator">+</span>
-294:                     <span class="ruby-node">&quot;pattern '#{pat}' of rule #{rule.name}&quot;</span>
-295:             <span class="ruby-keyword kw">end</span>
-296:           <span class="ruby-keyword kw">end</span>
-297:         <span class="ruby-keyword kw">end</span>
-298:       <span class="ruby-keyword kw">end</span>
-299:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 243</span>
+243:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">checkRule</span>(<span class="ruby-identifier">rule</span>)
+244:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">patterns</span>.<span class="ruby-identifier">empty?</span>
+245:         <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Rule #{rule.name} must have at least one pattern&quot;</span>
+246:       <span class="ruby-keyword kw">end</span>
+247: 
+248:       <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">patterns</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">pat</span><span class="ruby-operator">|</span>
+249:         <span class="ruby-identifier">pat</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span><span class="ruby-operator">|</span>
+250:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:variable</span>
+251:             <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@variables</span>.<span class="ruby-identifier">index</span>(<span class="ruby-identifier">name</span>).<span class="ruby-identifier">nil?</span>
+252:               <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unsupported_token'</span>,
+253:                     <span class="ruby-node">&quot;The token #{name} is not supported here.&quot;</span>)
+254:             <span class="ruby-keyword kw">end</span>
+255:           <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:reference</span>
+256:             <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">nil?</span>
+257:               <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Fatal Error: Reference to unknown rule #{name} in &quot;</span> <span class="ruby-operator">+</span>
+258:                     <span class="ruby-node">&quot;pattern '#{pat}' of rule #{rule.name}&quot;</span>
+259:             <span class="ruby-keyword kw">end</span>
+260:           <span class="ruby-keyword kw">end</span>
+261:         <span class="ruby-keyword kw">end</span>
+262:       <span class="ruby-keyword kw">end</span>
+263:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1367,13 +1360,13 @@ href="TextParser.html#method-i-parse">TextParser#parse</a>.
 			</div>
 
 		
-			<div id="find-attern-method" class="method-detail ">
-				<a name="method-i-findPattern"></a>
+			<div id="dump-tack-method" class="method-detail ">
+				<a name="method-i-dumpStack"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">findPattern</span><span
-						class="method-args">(rule, token, repeatMode)</span>
+					<span class="method-name">dumpStack</span><span
+						class="method-args">()</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -1385,57 +1378,32 @@ href="TextParser.html#method-i-parse">TextParser#parse</a>.
 
 					
 					<div class="method-source-code"
-						id="find-attern-source">
+						id="dump-tack-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 537</span>
-537:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">findPattern</span>(<span class="ruby-identifier">rule</span>, <span class="ruby-identifier">token</span>, <span class="ruby-identifier">repeatMode</span>)
-538:       <span class="ruby-comment cmt"># The scanner cannot differentiate between keywords and identifiers.  So</span>
-539:       <span class="ruby-comment cmt"># whenever an identifier is returned we have to see if we have a</span>
-540:       <span class="ruby-comment cmt"># matching keyword first. If none is found, then look for normal</span>
-541:       <span class="ruby-comment cmt"># identifiers.</span>
-542:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">==</span> <span class="ruby-value str">'ID'</span>
-543:         <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">patIdx</span> = <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">matchingPatternIndex</span>(<span class="ruby-value str">'_'</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">1</span>])).<span class="ruby-identifier">nil?</span>
-544:           <span class="ruby-identifier">patIdx</span> = <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">matchingPatternIndex</span>(<span class="ruby-value str">&quot;$ID&quot;</span>)
-545:         <span class="ruby-keyword kw">end</span>
-546:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">==</span> <span class="ruby-value str">'LITERAL'</span>
-547:         <span class="ruby-identifier">patIdx</span> = <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">matchingPatternIndex</span>(<span class="ruby-value str">'_'</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">1</span>])
-548:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">==</span> <span class="ruby-keyword kw">false</span>
-549:         <span class="ruby-identifier">patIdx</span> = <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">matchingPatternIndex</span>(<span class="ruby-value str">'.'</span>)
-550:       <span class="ruby-keyword kw">else</span>
-551:         <span class="ruby-identifier">patIdx</span> = <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">matchingPatternIndex</span>(<span class="ruby-value str">'$'</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>])
-552:       <span class="ruby-keyword kw">end</span>
-553: 
-554:       <span class="ruby-comment cmt"># If no matching pattern is found for the token we have to check if the</span>
-555:       <span class="ruby-comment cmt"># rule is optional or we are in repeat mode. If this is the case, return</span>
-556:       <span class="ruby-comment cmt"># the token back to the scanner. Otherwise, we have found a token we</span>
-557:       <span class="ruby-comment cmt"># cannot handle at this point.</span>
-558:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">patIdx</span>.<span class="ruby-identifier">nil?</span>
-559:         <span class="ruby-comment cmt"># Append the list of expected tokens to the @@expectedToken array.</span>
-560:         <span class="ruby-comment cmt"># This may be used in a later rule to provide more details when an</span>
-561:         <span class="ruby-comment cmt"># error occured.</span>
-562:         <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">transitions</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">transition</span><span class="ruby-operator">|</span>
-563:           <span class="ruby-identifier">keys</span> = <span class="ruby-identifier">transition</span>.<span class="ruby-identifier">keys</span>
-564:           <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">collect!</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">key</span><span class="ruby-operator">|</span> <span class="ruby-identifier">key</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>] }
-565:           <span class="ruby-identifier">@@expectedTokens</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">keys</span>
-566:           <span class="ruby-identifier">@@expectedTokens</span>.<span class="ruby-identifier">sort!</span>
-567:         <span class="ruby-keyword kw">end</span>
-568: 
-569:         <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">optional?</span>(<span class="ruby-ivar">@rules</span>) <span class="ruby-operator">||</span> <span class="ruby-identifier">repeatMode</span>
-570:           <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unexpctd_token'</span>,
-571:                 (<span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">!=</span> <span class="ruby-keyword kw">false</span> <span class="ruby-operator">?</span>
-572:                  <span class="ruby-node">&quot;Unexpected token '#{token[1]}' of type &quot;</span> <span class="ruby-operator">+</span>
-573:                  <span class="ruby-node">&quot;'#{token[0]}'. &quot;</span> <span class="ruby-operator">:</span>
-574:                  <span class="ruby-node">&quot;Unexpected end of file in #{@scanner.fileName}. &quot;</span>) <span class="ruby-operator">+</span>
-575:                 (<span class="ruby-identifier">@@expectedTokens</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">1</span> <span class="ruby-operator">?</span>
-576:                  <span class="ruby-node">&quot;Expecting one of #{@@expectedTokens.join(', ')}&quot;</span> <span class="ruby-operator">:</span>
-577:                  <span class="ruby-node">&quot;Expecting #{@@expectedTokens[0]}&quot;</span>), <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>])
-578:         <span class="ruby-keyword kw">end</span>
-579:         <span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>)
-580:         <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">nil</span>
-581:       <span class="ruby-keyword kw">end</span>
-582: 
-583:       <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">pattern</span>(<span class="ruby-identifier">patIdx</span>)
-584:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 400</span>
+400:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">dumpStack</span>
+401:       <span class="ruby-comment cmt">#puts &quot;Stack level #{@stack.length}&quot;</span>
+402:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">sl</span><span class="ruby-operator">|</span>
+403:         <span class="ruby-identifier">print</span> <span class="ruby-node">&quot;#{@stack.index(sl)}: &quot;</span>
+404:         <span class="ruby-identifier">sl</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">v</span><span class="ruby-operator">|</span>
+405:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">v</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Array</span>)
+406:             <span class="ruby-keyword kw">begin</span>
+407:               <span class="ruby-identifier">print</span> <span class="ruby-node">&quot;[#{v.join('|')}]|&quot;</span>
+408:             <span class="ruby-keyword kw">rescue</span>
+409:               <span class="ruby-identifier">print</span> <span class="ruby-node">&quot;[#{v[0].class}...]|&quot;</span>
+410:             <span class="ruby-keyword kw">end</span>
+411:           <span class="ruby-keyword kw">else</span>
+412:             <span class="ruby-keyword kw">begin</span>
+413:               <span class="ruby-identifier">print</span> <span class="ruby-node">&quot;#{v}|&quot;</span>
+414:             <span class="ruby-keyword kw">rescue</span>
+415:               <span class="ruby-identifier">print</span> <span class="ruby-identifier">v</span>.<span class="ruby-identifier">class</span>
+416:             <span class="ruby-keyword kw">end</span>
+417:           <span class="ruby-keyword kw">end</span>
+418:         <span class="ruby-keyword kw">end</span>
+419:         <span class="ruby-identifier">print</span> <span class="ruby-node">&quot; -&gt; #{sl.state ? sl.state.to_s(true) : 'nil'} #{sl.function.nil? ? '' : '(Called)'}&quot;</span>
+420:         <span class="ruby-identifier">puts</span> <span class="ruby-value str">&quot;&quot;</span>
+421:       <span class="ruby-keyword kw">end</span>
+422:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1446,13 +1414,13 @@ href="TextParser.html#method-i-parse">TextParser#parse</a>.
 			</div>
 
 		
-			<div id="get-ext-oken-method" class="method-detail ">
-				<a name="method-i-getNextToken"></a>
+			<div id="finish-attern-method" class="method-detail ">
+				<a name="method-i-finishPattern"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">getNextToken</span><span
-						class="method-args">()</span>
+					<span class="method-name">finishPattern</span><span
+						class="method-args">(token)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -1464,19 +1432,54 @@ href="TextParser.html#method-i-parse">TextParser#parse</a>.
 
 					
 					<div class="method-source-code"
-						id="get-ext-oken-source">
+						id="finish-attern-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 526</span>
-526:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">getNextToken</span>
-527:       <span class="ruby-identifier">token</span> = <span class="ruby-identifier">nextToken</span>
-528:       <span class="ruby-comment cmt">#Log &lt;&lt; &quot;Token: [#{token[0]}][#{token[1]}]&quot;</span>
-529:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@badVariables</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>])
-530:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unsupported_token'</span>,
-531:               <span class="ruby-node">&quot;The token #{token[1]} is not supported in this context.&quot;</span>,
-532:               <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>])
-533:       <span class="ruby-keyword kw">end</span>
-534:       <span class="ruby-identifier">token</span>
-535:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 354</span>
+354:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">finishPattern</span>(<span class="ruby-identifier">token</span>)
+355:       <span class="ruby-comment cmt">#dumpStack</span>
+356:       <span class="ruby-comment cmt"># To finish a pattern we need to pop the StackElement with the token</span>
+357:       <span class="ruby-comment cmt"># values from the stack.</span>
+358:       <span class="ruby-identifier">stackEntry</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">pop</span>
+359:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-operator">||</span> <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">empty?</span>
+360:         <span class="ruby-comment cmt"># Check if we have reached the bottom of the stack.</span>
+361:         <span class="ruby-identifier">token</span> = <span class="ruby-identifier">getNextToken</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">token</span>
+362:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">==</span> <span class="ruby-value">:endOfText</span>
+363:           <span class="ruby-comment cmt"># If the token is the end of the top-level file, we're done. We push</span>
+364:           <span class="ruby-comment cmt"># back the StackEntry since it holds the overall result of the</span>
+365:           <span class="ruby-comment cmt"># parsing.</span>
+366:           <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">stackEntry</span>)
+367:           <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">true</span>
+368:         <span class="ruby-keyword kw">end</span>
+369:         <span class="ruby-comment cmt"># If it's not the EOF token, we found a token that violates the syntax</span>
+370:         <span class="ruby-comment cmt"># rules.</span>
+371:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unexpctd_token'</span>, <span class="ruby-node">&quot;Unexpected token '#{token[1]}' found. &quot;</span> <span class="ruby-operator">+</span>
+372:               <span class="ruby-value str">&quot;Expecting one of &quot;</span> <span class="ruby-operator">+</span>
+373:               <span class="ruby-node">&quot;#{stackEntry.state.expectedTokens.join(', ')}&quot;</span>)
+374:       <span class="ruby-keyword kw">end</span>
+375:       <span class="ruby-comment cmt"># Memorize if the rule for this pattern was repeatable. Then we will</span>
+376:       <span class="ruby-comment cmt"># store the result of the pattern in an Array.</span>
+377:       <span class="ruby-identifier">ruleIsRepeatable</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">state</span>.<span class="ruby-identifier">rule</span>.<span class="ruby-identifier">repeatable</span>
+378: 
+379:       <span class="ruby-identifier">state</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">state</span>
+380:       <span class="ruby-identifier">result</span> = <span class="ruby-keyword kw">nil</span>
+381:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span>
+382:         <span class="ruby-comment cmt"># Make the token values and their SourceFileInfo available.</span>
+383:         <span class="ruby-ivar">@val</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">val</span>
+384:         <span class="ruby-ivar">@sourceFileInfo</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">sourceFileInfo</span>
+385:         <span class="ruby-comment cmt"># Now call the pattern action to compute the value of the pattern.</span>
+386:         <span class="ruby-identifier">result</span> = <span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span>.<span class="ruby-identifier">call</span>
+387:       <span class="ruby-keyword kw">end</span>
+388: 
+389:       <span class="ruby-comment cmt"># We use the SourceFileInfo of the first token of the pattern to store</span>
+390:       <span class="ruby-comment cmt"># it with the result of the pattern.</span>
+391:       <span class="ruby-identifier">firstSourceFileInfo</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">firstSourceFileInfo</span>
+392:       <span class="ruby-comment cmt"># Store the result at the correct position into the next lower level of</span>
+393:       <span class="ruby-comment cmt"># the stack.</span>
+394:       <span class="ruby-identifier">stackEntry</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>
+395:       <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">insert</span>(<span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">state</span>.<span class="ruby-identifier">index</span>, <span class="ruby-identifier">result</span>,
+396:                         <span class="ruby-identifier">firstSourceFileInfo</span>, <span class="ruby-identifier">ruleIsRepeatable</span>)
+397:       <span class="ruby-keyword kw">false</span>
+398:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1487,83 +1490,37 @@ href="TextParser.html#method-i-parse">TextParser#parse</a>.
 			</div>
 
 		
-			<div id="get-ransitions-method" class="method-detail ">
-				<a name="method-i-getTransitions"></a>
+			<div id="get-ext-oken-method" class="method-detail ">
+				<a name="method-i-getNextToken"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">getTransitions</span><span
-						class="method-args">(rule)</span>
+					<span class="method-name">getNextToken</span><span
+						class="method-args">()</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
 
 				<div class="method-description">
 					
-					<p>
-getTransitions recursively determines all possible target tokens that the
-<em>rule</em> matches. A target token can either be a fixed token (prefixed
-with _), a variable token (prefixed with $) or an end token (just a .). The
-list of found target tokens is stored in the <em>transitions</em> list of
-the rule. For each rule pattern we store the transitions for this pattern
-in a token -> rule hash.
-</p>
+					
 					
 
 					
 					<div class="method-source-code"
-						id="get-ransitions-source">
+						id="get-ext-oken-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 227</span>
-227:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">getTransitions</span>(<span class="ruby-identifier">rule</span>)
-228:       <span class="ruby-comment cmt"># If we have processed this rule before we can just return a copy</span>
-229:       <span class="ruby-comment cmt"># of the transitions of this rule. This avoids endless recursions.</span>
-230:       <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">transitions</span>.<span class="ruby-identifier">dup</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">transitions</span>.<span class="ruby-identifier">empty?</span>
-231: 
-232:       <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">transitions</span> = []
-233:       <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">patterns</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">pat</span><span class="ruby-operator">|</span>
-234:         <span class="ruby-identifier">allTokensOptional</span> = <span class="ruby-keyword kw">true</span>
-235:         <span class="ruby-identifier">transitions</span> = { }
-236:         <span class="ruby-identifier">pat</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">token</span><span class="ruby-operator">|</span>
-237:           <span class="ruby-identifier">tokenId</span> = <span class="ruby-identifier">token</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>]
-238:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">==</span> <span class="ruby-value">!!</span>
-239:             <span class="ruby-keyword kw">unless</span> <span class="ruby-ivar">@rules</span>.<span class="ruby-identifier">has_key?</span>(<span class="ruby-identifier">tokenId</span>)
-240:               <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Fatal Error: Unknown reference to #{tokenId} in pattern &quot;</span> <span class="ruby-operator">+</span>
-241:                     <span class="ruby-node">&quot;#{pat} + of rule #{rule.name}&quot;</span>
-242:             <span class="ruby-keyword kw">end</span>
-243:             <span class="ruby-identifier">refRule</span> = <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">tokenId</span>]
-244:             <span class="ruby-comment cmt"># If the referenced rule describes optional content, we need to look</span>
-245:             <span class="ruby-comment cmt"># at the next token as well.</span>
-246:             <span class="ruby-identifier">res</span> = <span class="ruby-identifier">getTransitions</span>(<span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">tokenId</span>])
-247:             <span class="ruby-identifier">allTokensOptional</span> = <span class="ruby-keyword kw">false</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">refRule</span>.<span class="ruby-identifier">optional?</span>(<span class="ruby-ivar">@rules</span>)
-248:             <span class="ruby-comment cmt"># Combine the hashes for each pattern into a single hash</span>
-249:             <span class="ruby-identifier">res</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">pat_i</span><span class="ruby-operator">|</span>
-250:               <span class="ruby-identifier">pat_i</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">tok</span>, <span class="ruby-identifier">r</span><span class="ruby-operator">|</span> <span class="ruby-identifier">transitions</span>[<span class="ruby-identifier">tok</span>] = <span class="ruby-identifier">r</span> }
-251:             <span class="ruby-keyword kw">end</span>
-252:           <span class="ruby-keyword kw">elsif</span> <span class="ruby-value str">'_$.'</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>])
-253:             <span class="ruby-identifier">transitions</span>[<span class="ruby-identifier">token</span>] = <span class="ruby-identifier">rule</span>
-254:             <span class="ruby-identifier">allTokensOptional</span> = <span class="ruby-keyword kw">false</span>
-255:           <span class="ruby-keyword kw">else</span>
-256:             <span class="ruby-identifier">raise</span> <span class="ruby-value str">'Fatal Error: Illegal token type specifier used for token'</span> <span class="ruby-operator">+</span>
-257:                   <span class="ruby-node">&quot;: #{tokenId}&quot;</span>
-258:           <span class="ruby-keyword kw">end</span>
-259:           <span class="ruby-keyword kw">break</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">allTokensOptional</span>
-260:         <span class="ruby-keyword kw">end</span>
-261:         <span class="ruby-comment cmt"># Make sure that we only have one possible transition for each</span>
-262:         <span class="ruby-comment cmt"># target.</span>
-263:         <span class="ruby-identifier">transitions</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">key</span>, <span class="ruby-identifier">value</span><span class="ruby-operator">|</span>
-264:           <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">transitions</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">trans</span><span class="ruby-operator">|</span>
-265:             <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">trans</span>.<span class="ruby-identifier">has_key?</span>(<span class="ruby-identifier">key</span>)
-266:               <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">dump</span>
-267:               <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Fatal Error: Rule #{rule.name} has ambiguous &quot;</span> <span class="ruby-operator">+</span>
-268:                     <span class="ruby-node">&quot;transitions for target #{key}&quot;</span>
-269:             <span class="ruby-keyword kw">end</span>
-270:           <span class="ruby-keyword kw">end</span>
-271:         <span class="ruby-keyword kw">end</span>
-272:         <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">transitions</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">transitions</span>
-273:       <span class="ruby-keyword kw">end</span>
-274:       <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">transitions</span>.<span class="ruby-identifier">dup</span>
-275:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 447</span>
+447:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">getNextToken</span>
+448:       <span class="ruby-identifier">token</span> = <span class="ruby-identifier">nextToken</span>
+449:       <span class="ruby-comment cmt">#Log &lt;&lt; &quot;Token: [#{token[0]}][#{token[1]}]&quot;</span>
+450:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@blockedVariables</span>[<span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>]]
+451:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unsupported_token'</span>,
+452:               <span class="ruby-node">&quot;The token #{token[1]} is not supported in this context.&quot;</span>,
+453:               <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>])
+454:       <span class="ruby-keyword kw">end</span>
+455:       <span class="ruby-identifier">token</span>
+456:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1574,12 +1531,12 @@ in a token -> rule hash.
 			</div>
 
 		
-			<div id="parse-ule--method" class="method-detail ">
-				<a name="method-i-parseRuleNR"></a>
+			<div id="parse--method" class="method-detail ">
+				<a name="method-i-parseFSM"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">parseRuleNR</span><span
+					<span class="method-name">parseFSM</span><span
 						class="method-args">(rule)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
@@ -1587,160 +1544,102 @@ in a token -> rule hash.
 
 				<div class="method-description">
 					
-					<p>
-This function processes the input starting with the syntax description of
-<em>rule</em>. It&#8217;s implemented as an unrolled recursion.  It
-recursively iterates over the rule tree as controlled by the input file.
-This version is not limited by the size of the system stack. So far,
-I&#8217;m not aware of any project that is too large for the system stack.
-Since the recursive version parseRuleR is about 8% faster and has cleaner
-code, we use that by default.
-</p>
+					
 					
 
 					
 					<div class="method-source-code"
-						id="parse-ule--source">
+						id="parse--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 387</span>
-387:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">parseRuleNR</span>(<span class="ruby-identifier">rule</span>)
-388:       <span class="ruby-identifier">elementIdx</span> = <span class="ruby-value">0</span>
-389:       <span class="ruby-identifier">recursionResult</span> = <span class="ruby-keyword kw">nil</span>
-390:       <span class="ruby-comment cmt"># These flags are used to managed the control flow to and from the</span>
-391:       <span class="ruby-comment cmt"># recursion point.</span>
-392:       <span class="ruby-identifier">recur</span> = <span class="ruby-identifier">resume</span> = <span class="ruby-keyword kw">false</span>
-393:       <span class="ruby-comment cmt"># The stack that holds the context for the recursion levels. It's either</span>
-394:       <span class="ruby-comment cmt"># just a rule to start a new recursion or an Array of state variables.</span>
-395:       <span class="ruby-identifier">recursionStack</span> = [ <span class="ruby-identifier">rule</span> ]
-396:       <span class="ruby-keyword kw">begin</span>
-397:         <span class="ruby-comment cmt"># Pop the top entry from the recursion stack.</span>
-398:         <span class="ruby-identifier">se</span> = <span class="ruby-identifier">recursionStack</span>.<span class="ruby-identifier">pop</span>
-399:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">se</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Array</span>)
-400:           <span class="ruby-comment cmt"># We have essentially finished a recursion level and need to get</span>
-401:           <span class="ruby-comment cmt"># back to the place where we started the recursion. First, we need</span>
-402:           <span class="ruby-comment cmt"># to restore the state again.</span>
-403:           <span class="ruby-identifier">rule</span>, <span class="ruby-identifier">pattern</span>, <span class="ruby-identifier">elementIdx</span>, <span class="ruby-identifier">result</span>, <span class="ruby-identifier">repeatMode</span>, <span class="ruby-identifier">sfi</span> = <span class="ruby-identifier">se</span>
-404:           <span class="ruby-comment cmt">#Log &lt;&lt; &quot;Recursion loop started in resume mode for rule #{rule.name}&quot;</span>
-405:           <span class="ruby-comment cmt"># Now jump to the recursion point without doing anything else.</span>
-406:           <span class="ruby-identifier">resume</span> = <span class="ruby-keyword kw">true</span>
-407:         <span class="ruby-keyword kw">else</span>
-408:           <span class="ruby-comment cmt"># Start a new recursion level. The rule tells us how to interpret</span>
-409:           <span class="ruby-comment cmt"># the input text.</span>
-410:           <span class="ruby-identifier">rule</span> = <span class="ruby-identifier">se</span>
-411:           <span class="ruby-comment cmt">#Log.enter('parseRuleNR', &quot;Parsing with rule #{rule.name}&quot;)</span>
-412:           <span class="ruby-identifier">resume</span> = <span class="ruby-keyword kw">false</span>
-413:         <span class="ruby-keyword kw">end</span>
-414: 
-415:         <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">resume</span>
-416:           <span class="ruby-identifier">result</span> = <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">repeatable</span> <span class="ruby-operator">?</span> <span class="ruby-constant">TextParserResultArray</span>.<span class="ruby-identifier">new</span> <span class="ruby-operator">:</span> <span class="ruby-keyword kw">nil</span>
-417:           <span class="ruby-comment cmt"># Rules can be marked 'repeatable'. This flag will be set to true</span>
-418:           <span class="ruby-comment cmt"># after the first iteration has been completed.</span>
-419:           <span class="ruby-identifier">repeatMode</span> = <span class="ruby-keyword kw">false</span>
-420:         <span class="ruby-keyword kw">end</span>
-421: 
-422:         <span class="ruby-identifier">loop</span> <span class="ruby-keyword kw">do</span>
-423:           <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">resume</span>
-424:             <span class="ruby-comment cmt"># At the beginning of a rule we need a token from the input to</span>
-425:             <span class="ruby-comment cmt"># determine which pattern of the rule needs to be processed.</span>
-426:             <span class="ruby-identifier">token</span> = <span class="ruby-identifier">getNextToken</span>
-427: 
-428:             <span class="ruby-keyword kw">break</span> <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">pattern</span> = <span class="ruby-identifier">findPattern</span>(<span class="ruby-identifier">rule</span>, <span class="ruby-identifier">token</span>, <span class="ruby-identifier">repeatMode</span>))
-429:             <span class="ruby-comment cmt"># The @stack will store the resulting value of each element in the</span>
-430:             <span class="ruby-comment cmt"># pattern.</span>
-431:             <span class="ruby-ivar">@stack</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">StackElement</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span>)
-432: 
-433:             <span class="ruby-comment cmt"># Once we've found the right pattern, we need to process each</span>
-434:             <span class="ruby-comment cmt"># element.</span>
-435:             <span class="ruby-identifier">elementIdx</span> = <span class="ruby-value">0</span>
-436:           <span class="ruby-keyword kw">end</span>
-437: 
-438:           <span class="ruby-identifier">elementCount</span> = <span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">length</span>
-439:           <span class="ruby-keyword kw">while</span> <span class="ruby-identifier">elementIdx</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">elementCount</span>
-440:             <span class="ruby-identifier">element</span> = <span class="ruby-identifier">pattern</span>[<span class="ruby-identifier">elementIdx</span>]
-441:             <span class="ruby-comment cmt"># Separate the type and token text for pattern element.</span>
-442:             <span class="ruby-identifier">elType</span> = <span class="ruby-identifier">element</span>[<span class="ruby-value">0</span>]
-443:             <span class="ruby-identifier">elToken</span> = <span class="ruby-identifier">element</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>]
-444:             <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">elType</span> <span class="ruby-operator">==</span> <span class="ruby-value">!!</span>
-445:               <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">resume</span>
-446:                 <span class="ruby-comment cmt"># The element is a reference to another rule. Return the token</span>
-447:                 <span class="ruby-comment cmt"># if we still have one and continue with the referenced rule.</span>
-448:                 <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">token</span>
-449:                   <span class="ruby-identifier">sfi</span> = <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>]
-450:                   <span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>)
-451:                   <span class="ruby-identifier">token</span> = <span class="ruby-keyword kw">nil</span>
-452:                 <span class="ruby-keyword kw">else</span>
-453:                   <span class="ruby-identifier">sfi</span> = <span class="ruby-keyword kw">nil</span>
-454:                 <span class="ruby-keyword kw">end</span>
-455:                 <span class="ruby-comment cmt"># This is where the recursion would happen. Instead, we push</span>
-456:                 <span class="ruby-comment cmt"># the state variables and then the next rule onto the</span>
-457:                 <span class="ruby-comment cmt"># recursion stack.</span>
-458:                 <span class="ruby-identifier">recursionStack</span>.<span class="ruby-identifier">push</span>([ <span class="ruby-identifier">rule</span>, <span class="ruby-identifier">pattern</span>, <span class="ruby-identifier">elementIdx</span>, <span class="ruby-identifier">result</span>,
-459:                                       <span class="ruby-identifier">repeatMode</span>, <span class="ruby-identifier">sfi</span> ])
-460:                 <span class="ruby-identifier">recursionStack</span>.<span class="ruby-identifier">push</span>(<span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">elToken</span>])
-461:                 <span class="ruby-comment cmt"># Now terminate all but the outer loops without doing anything</span>
-462:                 <span class="ruby-comment cmt"># else.</span>
-463:                 <span class="ruby-identifier">recur</span> = <span class="ruby-keyword kw">true</span>
-464:                 <span class="ruby-keyword kw">break</span>
-465:               <span class="ruby-keyword kw">else</span>
-466:                 <span class="ruby-comment cmt"># We're back right after where the recursion started. Store</span>
-467:                 <span class="ruby-comment cmt"># the result and turn resume mode off again.</span>
-468:                 <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">store</span>(<span class="ruby-identifier">recursionResult</span>, <span class="ruby-identifier">sfi</span>)
-469:                 <span class="ruby-identifier">resume</span> = <span class="ruby-keyword kw">false</span>
-470:               <span class="ruby-keyword kw">end</span>
-471:             <span class="ruby-keyword kw">else</span>
-472:               <span class="ruby-comment cmt"># In case the element is a keyword or variable we have to get a</span>
-473:               <span class="ruby-comment cmt"># new token if we don't have one anymore.</span>
-474:               <span class="ruby-identifier">token</span> = <span class="ruby-identifier">getNextToken</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">token</span>
-475: 
-476:               <span class="ruby-identifier">processNormalElements</span>(<span class="ruby-identifier">elType</span>, <span class="ruby-identifier">elToken</span>, <span class="ruby-identifier">token</span>)
-477: 
-478:               <span class="ruby-comment cmt"># The token has been consumed. Reset the variable.</span>
-479:               <span class="ruby-identifier">token</span> = <span class="ruby-keyword kw">nil</span>
-480:               <span class="ruby-identifier">@@expectedTokens</span> = []
-481:             <span class="ruby-keyword kw">end</span>
-482:             <span class="ruby-identifier">elementIdx</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
-483:           <span class="ruby-keyword kw">end</span> <span class="ruby-comment cmt"># of pattern while loop</span>
-484: 
-485:           <span class="ruby-comment cmt"># Skip the rest of the loop in recur mode.</span>
-486:           <span class="ruby-keyword kw">break</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">recur</span>
-487: 
-488:           <span class="ruby-identifier">elementIdx</span> = <span class="ruby-value">0</span>
-489: 
-490:           <span class="ruby-comment cmt"># Once the complete pattern has been processed we call the</span>
-491:           <span class="ruby-comment cmt"># processing function for this pattern to operate on the value</span>
-492:           <span class="ruby-comment cmt"># array. Then pop the entry for this rule from the stack. The</span>
-493:           <span class="ruby-comment cmt"># called function will use @val and @sourceFileInfo to retrieve</span>
-494:           <span class="ruby-comment cmt"># data from the parser.</span>
-495:           <span class="ruby-ivar">@val</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">val</span>
-496:           <span class="ruby-ivar">@sourceFileInfo</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">sourceFileInfo</span>
-497:           <span class="ruby-identifier">res</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">function</span> <span class="ruby-operator">?</span> <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">function</span>.<span class="ruby-identifier">call</span> <span class="ruby-operator">:</span> <span class="ruby-keyword kw">nil</span>
-498:           <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">pop</span>
-499: 
-500:           <span class="ruby-comment cmt"># If the rule is not repeatable we can store the result and break</span>
-501:           <span class="ruby-comment cmt"># the outer loop to exit the function.</span>
-502:           <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">repeatable</span>
-503:             <span class="ruby-identifier">result</span> = <span class="ruby-identifier">res</span>
-504:             <span class="ruby-keyword kw">break</span>
-505:           <span class="ruby-keyword kw">end</span>
-506: 
-507:           <span class="ruby-comment cmt"># Otherwise we append the result to the result array and turn repeat</span>
-508:           <span class="ruby-comment cmt"># mode on.</span>
-509:           <span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">res</span>
-510:           <span class="ruby-comment cmt"># We have completed the first iteration. Set the repeat mode flag to</span>
-511:           <span class="ruby-comment cmt"># indicate that further iterations are already re-runs.</span>
-512:           <span class="ruby-identifier">repeatMode</span> = <span class="ruby-keyword kw">true</span>
-513:         <span class="ruby-keyword kw">end</span> <span class="ruby-comment cmt"># of rule processing loop</span>
-514: 
-515:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">recur</span>
-516:           <span class="ruby-identifier">recur</span> = <span class="ruby-keyword kw">false</span>
-517:         <span class="ruby-keyword kw">else</span>
-518:           <span class="ruby-comment cmt">#Log.exit('parseRuleNR', &quot;Finished rule #{rule.name}&quot;)</span>
-519:           <span class="ruby-identifier">recursionResult</span> = <span class="ruby-identifier">result</span>
-520:         <span class="ruby-keyword kw">end</span>
-521:       <span class="ruby-keyword kw">end</span> <span class="ruby-keyword kw">while</span> <span class="ruby-operator">!</span><span class="ruby-identifier">recursionStack</span>.<span class="ruby-identifier">empty?</span>
-522: 
-523:       <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">result</span>
-524:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 265</span>
+265:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">parseFSM</span>(<span class="ruby-identifier">rule</span>)
+266:       <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">state</span> = <span class="ruby-ivar">@states</span>[[ <span class="ruby-identifier">rule</span>, <span class="ruby-keyword kw">nil</span>, <span class="ruby-value">0</span> ]])
+267:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">&quot;no_start_state&quot;</span>, <span class="ruby-node">&quot;No start state for rule #{rule.name} found&quot;</span>)
+268:       <span class="ruby-keyword kw">end</span>
+269:       <span class="ruby-ivar">@stack</span> = [ <span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">StackElement</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">state</span>) ]
+270: 
+271:       <span class="ruby-identifier">loop</span> <span class="ruby-keyword kw">do</span>
+272:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">transitions</span>.<span class="ruby-identifier">empty?</span>
+273:           <span class="ruby-comment cmt"># The final states of each pattern have no pre-compiled transitions.</span>
+274:           <span class="ruby-comment cmt"># For such a state, we don't need to get a new token.</span>
+275:           <span class="ruby-identifier">transition</span> = <span class="ruby-identifier">token</span> = <span class="ruby-keyword kw">nil</span>
+276:         <span class="ruby-keyword kw">else</span>
+277:           <span class="ruby-identifier">transition</span> = <span class="ruby-identifier">state</span>.<span class="ruby-identifier">transition</span>(<span class="ruby-identifier">token</span> = <span class="ruby-identifier">getNextToken</span>)
+278:         <span class="ruby-keyword kw">end</span>
+279: 
+280:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">transition</span>
+281:           <span class="ruby-comment cmt"># Shift: This for normal state transitions. This may be from one</span>
+282:           <span class="ruby-comment cmt"># token of a pattern to the next token of the same pattern, to the</span>
+283:           <span class="ruby-comment cmt"># start of a new pattern or a loop-back to the start of a pattern of</span>
+284:           <span class="ruby-comment cmt"># the same rule. The transition tells us what state we have to</span>
+285:           <span class="ruby-comment cmt"># process next.</span>
+286:           <span class="ruby-identifier">state</span> = <span class="ruby-identifier">transition</span>.<span class="ruby-identifier">state</span>
+287: 
+288:           <span class="ruby-comment cmt"># If we have looped-back we need to finish the pattern first. Final</span>
+289:           <span class="ruby-comment cmt"># tokens of repeatable rules do have transitions!</span>
+290:           <span class="ruby-identifier">finishPattern</span>(<span class="ruby-identifier">token</span>) <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">transition</span>.<span class="ruby-identifier">loopBack</span>
+291: 
+292:           <span class="ruby-comment cmt"># Transitions that enter rules generate states which we need to</span>
+293:           <span class="ruby-comment cmt"># resume at when a rule has been completely processed. We push this</span>
+294:           <span class="ruby-comment cmt"># list of states on the @stack.</span>
+295:           <span class="ruby-identifier">stackElement</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>
+296:           <span class="ruby-identifier">first</span> = <span class="ruby-keyword kw">true</span>
+297:           <span class="ruby-identifier">transition</span>.<span class="ruby-identifier">stateStack</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">s</span><span class="ruby-operator">|</span>
+298:             <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">first</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">s</span>.<span class="ruby-identifier">pattern</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">stackElement</span>.<span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>
+299:               <span class="ruby-comment cmt"># The first state in the list may just be another state of the</span>
+300:               <span class="ruby-comment cmt"># current pattern. In this case, we already have the</span>
+301:               <span class="ruby-comment cmt"># StackElement on the @stack. We only need to update the State</span>
+302:               <span class="ruby-comment cmt"># for the current StackElement.</span>
+303:               <span class="ruby-identifier">stackElement</span>.<span class="ruby-identifier">state</span> = <span class="ruby-identifier">s</span>
+304:             <span class="ruby-keyword kw">else</span>
+305:               <span class="ruby-comment cmt"># For other patterns, we just push a new StackElement onto the</span>
+306:               <span class="ruby-comment cmt"># @stack.</span>
+307:               <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">push</span>(<span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">StackElement</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">s</span>))
+308:             <span class="ruby-keyword kw">end</span>
+309:             <span class="ruby-identifier">first</span> = <span class="ruby-keyword kw">false</span>
+310:           <span class="ruby-keyword kw">end</span>
+311: 
+312:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">index</span> <span class="ruby-operator">==</span> <span class="ruby-value">0</span>
+313:             <span class="ruby-comment cmt"># If we have just started with a new pattern (or loop-ed back) we</span>
+314:             <span class="ruby-comment cmt"># need to push a new StackEntry onto the @stack. The StackEntry</span>
+315:             <span class="ruby-comment cmt"># stores the result of the pattern and keeps the State that we</span>
+316:             <span class="ruby-comment cmt"># need to return to in case we jump to other patterns from this</span>
+317:             <span class="ruby-comment cmt"># pattern.</span>
+318:             <span class="ruby-identifier">function</span> = <span class="ruby-identifier">state</span>.<span class="ruby-identifier">index</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">tokens</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span> <span class="ruby-operator">?</span>
+319:                        <span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span> <span class="ruby-operator">:</span> <span class="ruby-keyword kw">nil</span>
+320:             <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">push</span>(<span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">StackElement</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span>,
+321:                                                      <span class="ruby-identifier">state</span>))
+322:           <span class="ruby-keyword kw">end</span>
+323: 
+324:           <span class="ruby-comment cmt"># Store the token value in the result Array.</span>
+325:           <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">insert</span>(<span class="ruby-identifier">state</span>.<span class="ruby-identifier">index</span>, <span class="ruby-identifier">token</span>[<span class="ruby-value">1</span>], <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>], <span class="ruby-keyword kw">false</span>)
+326:         <span class="ruby-keyword kw">else</span>
+327:           <span class="ruby-comment cmt"># Reduce: We've reached the end of a rule. There is no pre-compiled</span>
+328:           <span class="ruby-comment cmt"># transition available. The current token, if we have one, is of no</span>
+329:           <span class="ruby-comment cmt"># use to us during this state. We just return it to the scanner. The</span>
+330:           <span class="ruby-comment cmt"># next state is determined by the first matching state from the</span>
+331:           <span class="ruby-comment cmt"># @stack.</span>
+332:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">noReduce</span>
+333:             <span class="ruby-comment cmt"># Only states that finish a rule may trigger a reduce operation.</span>
+334:             <span class="ruby-comment cmt"># Other states have the noReduce flag set. If a reduce for such a</span>
+335:             <span class="ruby-comment cmt"># state is triggered, we found a token that is not supported by</span>
+336:             <span class="ruby-comment cmt"># the syntax rules.</span>
+337:             <span class="ruby-identifier">error</span>(<span class="ruby-value str">&quot;no_reduce&quot;</span>,
+338:                   <span class="ruby-node">&quot;Unexpected token '#{token[1]}' found. &quot;</span> <span class="ruby-operator">+</span>
+339:                   <span class="ruby-value str">&quot;Expecting one of &quot;</span> <span class="ruby-operator">+</span>
+340:                   <span class="ruby-node">&quot;#{@stack.last.state.expectedTokens.join(', ')}&quot;</span>)
+341:           <span class="ruby-keyword kw">end</span>
+342:           <span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>) <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">token</span>
+343:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">finishPattern</span>(<span class="ruby-identifier">token</span>)
+344:             <span class="ruby-comment cmt"># Accept: We're done with parsing.</span>
+345:             <span class="ruby-keyword kw">break</span>
+346:           <span class="ruby-keyword kw">end</span>
+347:           <span class="ruby-identifier">state</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">state</span>
+348:         <span class="ruby-keyword kw">end</span>
+349:       <span class="ruby-keyword kw">end</span>
+350: 
+351:       <span class="ruby-ivar">@stack</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">val</span>[<span class="ruby-value">0</span>]
+352:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1751,13 +1650,13 @@ code, we use that by default.
 			</div>
 
 		
-			<div id="parse-ule--method" class="method-detail ">
-				<a name="method-i-parseRuleR"></a>
+			<div id="restore-sm-tack-method" class="method-detail ">
+				<a name="method-i-restoreFsmStack"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">parseRuleR</span><span
-						class="method-args">(rule)</span>
+					<span class="method-name">restoreFsmStack</span><span
+						class="method-args">()</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -1765,91 +1664,25 @@ code, we use that by default.
 				<div class="method-description">
 					
 					<p>
-This function processes the input starting with the syntax description of
-<em>rule</em>. It recursively calls this function whenever the syntax
-description contains the reference to another rule. This recursive version
-has cleaner code and is about 8% faster than parseRuleNR.
+Convert the FSM stack state entries from [ rule, pattern, index ] into the
+respective <a href="TextParser/State.html">State</a> objects again.
 </p>
 					
 
 					
 					<div class="method-source-code"
-						id="parse-ule--source">
+						id="restore-sm-tack-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 306</span>
-306:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">parseRuleR</span>(<span class="ruby-identifier">rule</span>)
-307:       <span class="ruby-comment cmt">#Log.enter('parseRuleR', &quot;Parsing with rule #{rule.name}&quot;)</span>
-308:       <span class="ruby-comment cmt">#puts &quot;Parsing with rule #{rule.name}&quot;</span>
-309:       <span class="ruby-identifier">result</span> = <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">repeatable</span> <span class="ruby-operator">?</span> <span class="ruby-constant">TextParserResultArray</span>.<span class="ruby-identifier">new</span> <span class="ruby-operator">:</span> <span class="ruby-keyword kw">nil</span>
-310:       <span class="ruby-comment cmt"># Rules can be marked 'repeatable'. This flag will be set to true after</span>
-311:       <span class="ruby-comment cmt"># the first iteration has been completed.</span>
-312:       <span class="ruby-identifier">repeatMode</span> = <span class="ruby-keyword kw">false</span>
-313:       <span class="ruby-identifier">loop</span> <span class="ruby-keyword kw">do</span>
-314:         <span class="ruby-comment cmt"># At the beginning of a rule we need a token from the input to determine</span>
-315:         <span class="ruby-comment cmt"># which pattern of the rule needs to be processed.</span>
-316:         <span class="ruby-identifier">token</span> = <span class="ruby-identifier">getNextToken</span>
-317: 
-318:         <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">result</span> <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">pattern</span> = <span class="ruby-identifier">findPattern</span>(<span class="ruby-identifier">rule</span>, <span class="ruby-identifier">token</span>, <span class="ruby-identifier">repeatMode</span>))
-319:         <span class="ruby-comment cmt"># The @stack will store the resulting value of each element in the</span>
-320:         <span class="ruby-comment cmt"># pattern.</span>
-321:         <span class="ruby-ivar">@stack</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">StackElement</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span>)
-322: 
-323:         <span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">element</span><span class="ruby-operator">|</span>
-324:           <span class="ruby-comment cmt"># Separate the type and token text for pattern element.</span>
-325:           <span class="ruby-identifier">elType</span> = <span class="ruby-identifier">element</span>[<span class="ruby-value">0</span>]
-326:           <span class="ruby-identifier">elToken</span> = <span class="ruby-identifier">element</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>]
-327:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">elType</span> <span class="ruby-operator">==</span> <span class="ruby-value">!!</span>
-328:             <span class="ruby-comment cmt"># The element is a reference to another rule. Return the token if</span>
-329:             <span class="ruby-comment cmt"># we still have one and continue with the referenced rule.</span>
-330:             <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">token</span>.<span class="ruby-identifier">nil?</span>
-331:               <span class="ruby-identifier">sfi</span> = <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>]
-332:               <span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>)
-333:               <span class="ruby-identifier">token</span> = <span class="ruby-keyword kw">nil</span>
-334:             <span class="ruby-keyword kw">else</span>
-335:               <span class="ruby-identifier">sfi</span> = <span class="ruby-keyword kw">nil</span>
-336:             <span class="ruby-keyword kw">end</span>
-337:             <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">store</span>(<span class="ruby-identifier">parseRuleR</span>(<span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">elToken</span>]), <span class="ruby-identifier">sfi</span>)
-338:             <span class="ruby-comment cmt">#Log &lt;&lt; &quot;Resuming rule #{rule.name}&quot;</span>
-339:             <span class="ruby-comment cmt">#puts &quot;Resuming rule #{rule.name}&quot;</span>
-340:           <span class="ruby-keyword kw">else</span>
-341:             <span class="ruby-comment cmt"># In case the element is a keyword or variable we have to get a new</span>
-342:             <span class="ruby-comment cmt"># token if we don't have one anymore.</span>
-343:             <span class="ruby-identifier">token</span> = <span class="ruby-identifier">getNextToken</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">token</span>
-344: 
-345:             <span class="ruby-identifier">processNormalElements</span>(<span class="ruby-identifier">elType</span>, <span class="ruby-identifier">elToken</span>, <span class="ruby-identifier">token</span>)
-346: 
-347:             <span class="ruby-comment cmt"># The token has been consumed. Reset the variable.</span>
-348:             <span class="ruby-identifier">token</span> = <span class="ruby-keyword kw">nil</span>
-349:             <span class="ruby-identifier">@@expectedTokens</span> = []
-350:           <span class="ruby-keyword kw">end</span>
-351:         <span class="ruby-keyword kw">end</span>
-352: 
-353:         <span class="ruby-comment cmt"># Once the complete pattern has been processed we call the processing</span>
-354:         <span class="ruby-comment cmt"># function for this pattern to operate on the value array. Then pop the</span>
-355:         <span class="ruby-comment cmt"># entry for this rule from the stack.</span>
-356:         <span class="ruby-ivar">@val</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">val</span>
-357:         <span class="ruby-ivar">@sourceFileInfo</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">sourceFileInfo</span>
-358:         <span class="ruby-identifier">res</span> = <span class="ruby-keyword kw">nil</span>
-359:         <span class="ruby-identifier">res</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">function</span>.<span class="ruby-identifier">call</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">function</span>.<span class="ruby-identifier">nil?</span>
-360:         <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">pop</span>
-361: 
-362:         <span class="ruby-comment cmt"># If the rule is not repeatable we can store the result and break the</span>
-363:         <span class="ruby-comment cmt"># outer loop to exit the function.</span>
-364:         <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">repeatable</span>
-365:           <span class="ruby-identifier">result</span> = <span class="ruby-identifier">res</span>
-366:           <span class="ruby-keyword kw">break</span>
-367:         <span class="ruby-keyword kw">end</span>
-368: 
-369:         <span class="ruby-comment cmt"># Otherwise we append the result to the result array and turn repeat</span>
-370:         <span class="ruby-comment cmt"># mode on.</span>
-371:         <span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">res</span>
-372:         <span class="ruby-identifier">repeatMode</span> = <span class="ruby-keyword kw">true</span>
-373:       <span class="ruby-keyword kw">end</span>
-374: 
-375:       <span class="ruby-comment cmt">#Log.exit('parseRuleR', &quot;Finished rule #{rule.name}&quot;)</span>
-376:       <span class="ruby-comment cmt">#puts &quot;Finished rule #{rule.name}&quot;</span>
-377:       <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">result</span>
-378:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 437</span>
+437:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">restoreFsmStack</span>
+438:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-ivar">@stack</span>
+439: 
+440:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">s</span><span class="ruby-operator">|</span>
+441:         <span class="ruby-keyword kw">next</span> <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">state</span> = <span class="ruby-ivar">@states</span>[<span class="ruby-identifier">s</span>.<span class="ruby-identifier">state</span>])
+442:         <span class="ruby-identifier">raise</span> <span class="ruby-value str">&quot;Stack restore failed. Cannot find state&quot;</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">state</span>
+443:         <span class="ruby-identifier">s</span>.<span class="ruby-identifier">state</span> = <span class="ruby-identifier">state</span>
+444:       <span class="ruby-keyword kw">end</span>
+445:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1860,13 +1693,13 @@ has cleaner code and is about 8% faster than parseRuleNR.
 			</div>
 
 		
-			<div id="process-ormal-lements-method" class="method-detail ">
-				<a name="method-i-processNormalElements"></a>
+			<div id="save-sm-tack-method" class="method-detail ">
+				<a name="method-i-saveFsmStack"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">processNormalElements</span><span
-						class="method-args">(elType, elToken, token)</span>
+					<span class="method-name">saveFsmStack</span><span
+						class="method-args">()</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -1874,49 +1707,25 @@ has cleaner code and is about 8% faster than parseRuleNR.
 				<div class="method-description">
 					
 					<p>
-Handle the elements that don&#8217;t trigger a recursion.
+Convert the FSM stack state entries from <a
+href="TextParser/State.html">State</a> objects into [ rule, pattern, index
+] equivalents.
 </p>
 					
 
 					
 					<div class="method-source-code"
-						id="process-ormal-lements-source">
+						id="save-sm-tack-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 587</span>
-587:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">processNormalElements</span>(<span class="ruby-identifier">elType</span>, <span class="ruby-identifier">elToken</span>, <span class="ruby-identifier">token</span>)
-588:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">elType</span> <span class="ruby-operator">==</span> <span class="ruby-value">__</span>
-589:         <span class="ruby-comment cmt"># If the element requires a keyword the token must match this</span>
-590:         <span class="ruby-comment cmt"># keyword.</span>
-591:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">elToken</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">1</span>]
-592:           <span class="ruby-identifier">text</span> = <span class="ruby-node">&quot;'#{elToken}' expected but found &quot;</span> <span class="ruby-operator">+</span>
-593:                  <span class="ruby-node">&quot;'#{token[1]}' (#{token[0]}).&quot;</span>
-594:           <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">@@expectedTokens</span>.<span class="ruby-identifier">empty?</span>
-595:             <span class="ruby-identifier">text</span> = <span class="ruby-node">&quot;#{@@expectedTokens.join(', ')} or &quot;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">text</span>
-596:           <span class="ruby-keyword kw">end</span>
-597:           <span class="ruby-identifier">error</span>(<span class="ruby-value str">'spec_keywork_expctd'</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>])
-598:         <span class="ruby-keyword kw">end</span>
-599:         <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">store</span>(<span class="ruby-identifier">elToken</span>, <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>])
-600:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">elType</span> <span class="ruby-operator">==</span> <span class="ruby-value">..</span>
-601:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">0</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>] <span class="ruby-operator">!=</span> [ <span class="ruby-value str">'.'</span>, <span class="ruby-value str">'&lt;END&gt;'</span> ]
-602:           <span class="ruby-identifier">error</span>(<span class="ruby-value str">'end_expected'</span>,
-603:                 <span class="ruby-node">&quot;Found garbage at expected end of text: #{token[1]}\n&quot;</span> <span class="ruby-operator">+</span>
-604:                 <span class="ruby-value str">&quot;If you see this in the middle of your text, you probably &quot;</span> <span class="ruby-operator">+</span>
-605:                 <span class="ruby-value str">&quot;have closed your context too early.&quot;</span>, <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>])
-606:         <span class="ruby-keyword kw">end</span>
-607:       <span class="ruby-keyword kw">else</span>
-608:         <span class="ruby-comment cmt"># The token must match the expected variable type.</span>
-609:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">!=</span> <span class="ruby-identifier">elToken</span>
-610:           <span class="ruby-identifier">text</span> = <span class="ruby-node">&quot;'#{elToken}' expected but found &quot;</span> <span class="ruby-operator">+</span>
-611:                  <span class="ruby-node">&quot;'#{token[1]}' (#{token[0]}).&quot;</span>
-612:           <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">@@expectedTokens</span>.<span class="ruby-identifier">empty?</span>
-613:             <span class="ruby-identifier">text</span> = <span class="ruby-node">&quot;#{@@expectedTokens.join(', ')} or &quot;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">text</span>
-614:           <span class="ruby-keyword kw">end</span>
-615:           <span class="ruby-identifier">error</span>(<span class="ruby-value str">'spec_token_expctd'</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>])
-616:         <span class="ruby-keyword kw">end</span>
-617:         <span class="ruby-comment cmt"># If the element is a variable store the value of the token.</span>
-618:         <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">store</span>(<span class="ruby-identifier">token</span>[<span class="ruby-value">1</span>], <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>])
-619:       <span class="ruby-keyword kw">end</span>
-620:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 426</span>
+426:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">saveFsmStack</span>
+427:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-ivar">@stack</span>
+428: 
+429:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">s</span><span class="ruby-operator">|</span>
+430:         <span class="ruby-keyword kw">next</span> <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">st</span> = <span class="ruby-identifier">s</span>.<span class="ruby-identifier">state</span>)
+431:         <span class="ruby-identifier">s</span>.<span class="ruby-identifier">state</span> = [ <span class="ruby-identifier">st</span>.<span class="ruby-identifier">rule</span>, <span class="ruby-identifier">st</span>.<span class="ruby-identifier">pattern</span>, <span class="ruby-identifier">st</span>.<span class="ruby-identifier">index</span> ]
+432:       <span class="ruby-keyword kw">end</span>
+433:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>