taskjuggler 0.0.5 → 0.0.6

data/doc/TaskJuggler/TextFormatter.html

@@ -69,13 +69,13 @@
 				<h3 class="section-header">Methods</h3>
 				<ul class="link-list">
 					
-					<li><a href="#M001604">::new</a></li>
+					<li><a href="#method-c-new">::new</a></li>
 					
-					<li><a href="#M001607">#appendWord</a></li>
+					<li><a href="#method-i-appendWord">#appendWord</a></li>
 					
-					<li><a href="#M001606">#format</a></li>
+					<li><a href="#method-i-format">#format</a></li>
 					
-					<li><a href="#M001605">#indent</a></li>
+					<li><a href="#method-i-indent">#indent</a></li>
 					
 				</ul>
 			</div>
@@ -92,6 +92,8 @@
 				<h3 class="section-header">Files</h3>
 				<ul>
 				
+					<li class="file"><a href="../CHANGELOG.html">CHANGELOG</a></li>
+				
 					<li class="file"><a href="../COPYING.html">COPYING</a></li>
 				
 					<li class="file"><a href="../README.html">README</a></li>
@@ -261,6 +263,8 @@
 				
 					<li><a href="../TaskJuggler/NikuResource.html">TaskJuggler::NikuResource</a></li>
 				
+					<li><a href="../TaskJuggler/NodeListAttribute.html">TaskJuggler::NodeListAttribute</a></li>
+				
 					<li><a href="../TaskJuggler/OnShiftCache.html">TaskJuggler::OnShiftCache</a></li>
 				
 					<li><a href="../TaskJuggler/ProcessIntercom.html">TaskJuggler::ProcessIntercom</a></li>
@@ -275,6 +279,8 @@
 				
 					<li><a href="../TaskJuggler/ProjectFileParser.html">TaskJuggler::ProjectFileParser</a></li>
 				
+					<li><a href="../TaskJuggler/ProjectFileScanner.html">TaskJuggler::ProjectFileScanner</a></li>
+				
 					<li><a href="../TaskJuggler/ProjectRecord.html">TaskJuggler::ProjectRecord</a></li>
 				
 					<li><a href="../TaskJuggler/ProjectServer.html">TaskJuggler::ProjectServer</a></li>
@@ -291,12 +297,16 @@
 				
 					<li><a href="../TaskJuggler/Query.html">TaskJuggler::Query</a></li>
 				
+					<li><a href="../TaskJuggler/RTFHandlers.html">TaskJuggler::RTFHandlers</a></li>
+				
 					<li><a href="../TaskJuggler/RTFNavigator.html">TaskJuggler::RTFNavigator</a></li>
 				
 					<li><a href="../TaskJuggler/RTFQuery.html">TaskJuggler::RTFQuery</a></li>
 				
 					<li><a href="../TaskJuggler/RTFReport.html">TaskJuggler::RTFReport</a></li>
 				
+					<li><a href="../TaskJuggler/RTFReportLink.html">TaskJuggler::RTFReportLink</a></li>
+				
 					<li><a href="../TaskJuggler/RealFormat.html">TaskJuggler::RealFormat</a></li>
 				
 					<li><a href="../TaskJuggler/RealFormatAttribute.html">TaskJuggler::RealFormatAttribute</a></li>
@@ -315,6 +325,8 @@
 				
 					<li><a href="../TaskJuggler/ReportServerRecord.html">TaskJuggler::ReportServerRecord</a></li>
 				
+					<li><a href="../TaskJuggler/ReportServlet.html">TaskJuggler::ReportServlet</a></li>
+				
 					<li><a href="../TaskJuggler/ReportTable.html">TaskJuggler::ReportTable</a></li>
 				
 					<li><a href="../TaskJuggler/ReportTableCell.html">TaskJuggler::ReportTableCell</a></li>
@@ -443,6 +455,8 @@
 				
 					<li><a href="../TaskJuggler/TextScanner/FileStreamHandle.html">TaskJuggler::TextScanner::FileStreamHandle</a></li>
 				
+					<li><a href="../TaskJuggler/TextScanner/MacroStackEntry.html">TaskJuggler::TextScanner::MacroStackEntry</a></li>
+				
 					<li><a href="../TaskJuggler/TextScanner/StreamHandle.html">TaskJuggler::TextScanner::StreamHandle</a></li>
 				
 					<li><a href="../TaskJuggler/TimeSheet.html">TaskJuggler::TimeSheet</a></li>
@@ -487,8 +501,12 @@
 				
 					<li><a href="../TaskJuggler/TjpSyntaxRules.html">TaskJuggler::TjpSyntaxRules</a></li>
 				
+					<li><a href="../TaskJuggler/URLParameter.html">TaskJuggler::URLParameter</a></li>
+				
 					<li><a href="../TaskJuggler/UserManual.html">TaskJuggler::UserManual</a></li>
 				
+					<li><a href="../TaskJuggler/WebServer.html">TaskJuggler::WebServer</a></li>
+				
 					<li><a href="../TaskJuggler/WorkingHours.html">TaskJuggler::WorkingHours</a></li>
 				
 					<li><a href="../TaskJuggler/WorkingHoursAttribute.html">TaskJuggler::WorkingHoursAttribute</a></li>
@@ -515,6 +533,8 @@
 				
 					<li><a href="../String.html">String</a></li>
 				
+					<li><a href="../StringIO.html">StringIO</a></li>
+				
 				</ul>
 				<div id="no-class-search-results" style="display: none;">No matching classes.</div>
 			</div>
@@ -604,7 +624,7 @@ be indented and limited to a given text width.
 
 		
 			<div id="new-method" class="method-detail ">
-				<a name="M001604"></a>
+				<a name="method-c-new"></a>
 
 				<div class="method-heading">
 				
@@ -649,7 +669,7 @@ be indented and limited to a given text width.
 
 		
 			<div id="format-method" class="method-detail ">
-				<a name="M001606"></a>
+				<a name="method-i-format"></a>
 
 				<div class="method-heading">
 				
@@ -754,7 +774,7 @@ the class settings.
 
 		
 			<div id="indent-method" class="method-detail ">
-				<a name="M001605"></a>
+				<a name="method-i-indent"></a>
 
 				<div class="method-heading">
 				
@@ -831,7 +851,7 @@ line will be indented by @firstLineIndent. Lines that are longer than
 
 		
 			<div id="append-ord-method" class="method-detail ">
-				<a name="M001607"></a>
+				<a name="method-i-appendWord"></a>
 
 				<div class="method-heading">
 				

data/doc/TaskJuggler/TextParser.html

@@ -98,41 +98,45 @@
 				<h3 class="section-header">Methods</h3>
 				<ul class="link-list">
 					
-					<li><a href="#M000671">::new</a></li>
+					<li><a href="#method-c-new">::new</a></li>
 					
-					<li><a href="#M000680">#checkForEnd</a></li>
+					<li><a href="#method-i-checkRule">#checkRule</a></li>
 					
-					<li><a href="#M000686">#checkRule</a></li>
+					<li><a href="#method-i-error">#error</a></li>
 					
-					<li><a href="#M000683">#error</a></li>
+					<li><a href="#method-i-findPattern">#findPattern</a></li>
 					
-					<li><a href="#M000688">#getNextToken</a></li>
+					<li><a href="#method-i-getNextToken">#getNextToken</a></li>
 					
-					<li><a href="#M000685">#getTransitions</a></li>
+					<li><a href="#method-i-getTransitions">#getTransitions</a></li>
 					
-					<li><a href="#M000673">#initRules</a></li>
+					<li><a href="#method-i-initRules">#initRules</a></li>
 					
-					<li><a href="#M000672">#limitTokenSet</a></li>
+					<li><a href="#method-i-limitTokenSet">#limitTokenSet</a></li>
 					
-					<li><a href="#M000682">#matchingRules</a></li>
+					<li><a href="#method-i-matchingRules">#matchingRules</a></li>
 					
-					<li><a href="#M000674">#newRule</a></li>
+					<li><a href="#method-i-newRule">#newRule</a></li>
 					
-					<li><a href="#M000676">#optional</a></li>
+					<li><a href="#method-i-optional">#optional</a></li>
 					
-					<li><a href="#M000679">#parse</a></li>
+					<li><a href="#method-i-parse">#parse</a></li>
 					
-					<li><a href="#M000687">#parseRule</a></li>
+					<li><a href="#method-i-parseRuleNR">#parseRuleNR</a></li>
 					
-					<li><a href="#M000675">#pattern</a></li>
+					<li><a href="#method-i-parseRuleR">#parseRuleR</a></li>
 					
-					<li><a href="#M000677">#repeatable</a></li>
+					<li><a href="#method-i-pattern">#pattern</a></li>
 					
-					<li><a href="#M000681">#sourceFileInfo</a></li>
+					<li><a href="#method-i-processNormalElements">#processNormalElements</a></li>
 					
-					<li><a href="#M000678">#updateParserTables</a></li>
+					<li><a href="#method-i-repeatable">#repeatable</a></li>
 					
-					<li><a href="#M000684">#warning</a></li>
+					<li><a href="#method-i-sourceFileInfo">#sourceFileInfo</a></li>
+					
+					<li><a href="#method-i-updateParserTables">#updateParserTables</a></li>
+					
+					<li><a href="#method-i-warning">#warning</a></li>
 					
 				</ul>
 			</div>
@@ -149,6 +153,8 @@
 				<h3 class="section-header">Files</h3>
 				<ul>
 				
+					<li class="file"><a href="../CHANGELOG.html">CHANGELOG</a></li>
+				
 					<li class="file"><a href="../COPYING.html">COPYING</a></li>
 				
 					<li class="file"><a href="../README.html">README</a></li>
@@ -318,6 +324,8 @@
 				
 					<li><a href="../TaskJuggler/NikuResource.html">TaskJuggler::NikuResource</a></li>
 				
+					<li><a href="../TaskJuggler/NodeListAttribute.html">TaskJuggler::NodeListAttribute</a></li>
+				
 					<li><a href="../TaskJuggler/OnShiftCache.html">TaskJuggler::OnShiftCache</a></li>
 				
 					<li><a href="../TaskJuggler/ProcessIntercom.html">TaskJuggler::ProcessIntercom</a></li>
@@ -332,6 +340,8 @@
 				
 					<li><a href="../TaskJuggler/ProjectFileParser.html">TaskJuggler::ProjectFileParser</a></li>
 				
+					<li><a href="../TaskJuggler/ProjectFileScanner.html">TaskJuggler::ProjectFileScanner</a></li>
+				
 					<li><a href="../TaskJuggler/ProjectRecord.html">TaskJuggler::ProjectRecord</a></li>
 				
 					<li><a href="../TaskJuggler/ProjectServer.html">TaskJuggler::ProjectServer</a></li>
@@ -348,12 +358,16 @@
 				
 					<li><a href="../TaskJuggler/Query.html">TaskJuggler::Query</a></li>
 				
+					<li><a href="../TaskJuggler/RTFHandlers.html">TaskJuggler::RTFHandlers</a></li>
+				
 					<li><a href="../TaskJuggler/RTFNavigator.html">TaskJuggler::RTFNavigator</a></li>
 				
 					<li><a href="../TaskJuggler/RTFQuery.html">TaskJuggler::RTFQuery</a></li>
 				
 					<li><a href="../TaskJuggler/RTFReport.html">TaskJuggler::RTFReport</a></li>
 				
+					<li><a href="../TaskJuggler/RTFReportLink.html">TaskJuggler::RTFReportLink</a></li>
+				
 					<li><a href="../TaskJuggler/RealFormat.html">TaskJuggler::RealFormat</a></li>
 				
 					<li><a href="../TaskJuggler/RealFormatAttribute.html">TaskJuggler::RealFormatAttribute</a></li>
@@ -372,6 +386,8 @@
 				
 					<li><a href="../TaskJuggler/ReportServerRecord.html">TaskJuggler::ReportServerRecord</a></li>
 				
+					<li><a href="../TaskJuggler/ReportServlet.html">TaskJuggler::ReportServlet</a></li>
+				
 					<li><a href="../TaskJuggler/ReportTable.html">TaskJuggler::ReportTable</a></li>
 				
 					<li><a href="../TaskJuggler/ReportTableCell.html">TaskJuggler::ReportTableCell</a></li>
@@ -500,6 +516,8 @@
 				
 					<li><a href="../TaskJuggler/TextScanner/FileStreamHandle.html">TaskJuggler::TextScanner::FileStreamHandle</a></li>
 				
+					<li><a href="../TaskJuggler/TextScanner/MacroStackEntry.html">TaskJuggler::TextScanner::MacroStackEntry</a></li>
+				
 					<li><a href="../TaskJuggler/TextScanner/StreamHandle.html">TaskJuggler::TextScanner::StreamHandle</a></li>
 				
 					<li><a href="../TaskJuggler/TimeSheet.html">TaskJuggler::TimeSheet</a></li>
@@ -544,8 +562,12 @@
 				
 					<li><a href="../TaskJuggler/TjpSyntaxRules.html">TaskJuggler::TjpSyntaxRules</a></li>
 				
+					<li><a href="../TaskJuggler/URLParameter.html">TaskJuggler::URLParameter</a></li>
+				
 					<li><a href="../TaskJuggler/UserManual.html">TaskJuggler::UserManual</a></li>
 				
+					<li><a href="../TaskJuggler/WebServer.html">TaskJuggler::WebServer</a></li>
+				
 					<li><a href="../TaskJuggler/WorkingHours.html">TaskJuggler::WorkingHours</a></li>
 				
 					<li><a href="../TaskJuggler/WorkingHoursAttribute.html">TaskJuggler::WorkingHoursAttribute</a></li>
@@ -572,6 +594,8 @@
 				
 					<li><a href="../String.html">String</a></li>
 				
+					<li><a href="../StringIO.html">StringIO</a></li>
+				
 				</ul>
 				<div id="no-class-search-results" style="display: none;">No matching classes.</div>
 			</div>
@@ -641,19 +665,20 @@ declare all variables ($SOMENAME) that the scanner may deliver.
 </p>
 <p>
 To describe the syntax the functions <a
-href="TextParser.html#M000675">TextParser#pattern</a>, <a
-href="TextParser.html#M000676">TextParser#optional</a> and <a
-href="TextParser.html#M000677">TextParser#repeatable</a> can be used. When
-the rule set is changed during parsing, <a
-href="TextParser.html#M000678">TextParser#updateParserTables</a> must be
-called to make the changes effective. The parser can also document the
-syntax automatically. To document a pattern, the functions TextParser#doc,
-TextParser#descr, TextParser#also and TextParser#arg can be used.
+href="TextParser.html#method-i-pattern">TextParser#pattern</a>, <a
+href="TextParser.html#method-i-optional">TextParser#optional</a> and <a
+href="TextParser.html#method-i-repeatable">TextParser#repeatable</a> can be
+used. When the rule set is changed during parsing, <a
+href="TextParser.html#method-i-updateParserTables">TextParser#updateParserTables</a>
+must be called to make the changes effective. The parser can also document
+the syntax automatically. To document a pattern, the functions
+TextParser#doc, TextParser#descr, TextParser#also and TextParser#arg can be
+used.
 </p>
 <p>
 To start parsing the input the function <a
-href="TextParser.html#M000679">TextParser#parse</a> needs to be called with
-the name of the start rule.
+href="TextParser.html#method-i-parse">TextParser#parse</a> needs to be
+called with the name of the start rule.
 </p>
 
 		</div>
@@ -692,7 +717,7 @@ the name of the start rule.
 
 		
 			<div id="new-method" class="method-detail ">
-				<a name="M000671"></a>
+				<a name="method-c-new"></a>
 
 				<div class="method-heading">
 				
@@ -739,53 +764,13 @@ Create a new <a href="TextParser.html">TextParser</a> object.
 			<h3 class="section-header">Public Instance Methods</h3>
 
 		
-			<div id="check-or-nd-method" class="method-detail ">
-				<a name="M000680"></a>
-
-				<div class="method-heading">
-				
-					<span class="method-name">checkForEnd</span><span
-						class="method-args">()</span>
-					<span class="method-click-advice">click to toggle source</span>
-				
-				</div>
-
-				<div class="method-description">
-					
-					<p>
-Return true if the scanner has processed all files.
-</p>
-					
-
-					
-					<div class="method-source-code"
-						id="check-or-nd-source">
-<pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 174</span>
-174:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">checkForEnd</span>
-175:       <span class="ruby-identifier">token</span> = <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">nextToken</span>
-176:       <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">==</span> <span class="ruby-value str">'.'</span>
-177:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'junk_at_expected_eof'</span>,
-178:               <span class="ruby-node">&quot;Found garbage at expected end of file: #{token[1]}&quot;</span>)
-179:       <span class="ruby-keyword kw">end</span>
-180:     <span class="ruby-keyword kw">end</span></pre>
-					</div>
-					
-				</div>
-
-				
-
-				
-			</div>
-
-		
 			<div id="error-method" class="method-detail ">
-				<a name="M000683"></a>
+				<a name="method-i-error"></a>
 
 				<div class="method-heading">
 				
 					<span class="method-name">error</span><span
-						class="method-args">(id, text, property = nil)</span>
+						class="method-args">(id, text, property = nil, sfi = nil)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -799,10 +784,16 @@ Return true if the scanner has processed all files.
 					<div class="method-source-code"
 						id="error-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 199</span>
-199:     <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">property</span> = <span class="ruby-keyword kw">nil</span>)
-200:       <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">property</span>)
-201:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 190</span>
+190:     <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">property</span> = <span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">sfi</span> = <span class="ruby-keyword kw">nil</span>)
+191:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@scanner</span>
+192:         <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">property</span>, <span class="ruby-identifier">sfi</span>)
+193:       <span class="ruby-keyword kw">else</span>
+194:         <span class="ruby-identifier">message</span> = <span class="ruby-constant">Message</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">id</span>, <span class="ruby-value str">'error'</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">property</span>, <span class="ruby-identifier">sfi</span>)
+195:         <span class="ruby-ivar">@messageHandler</span>.<span class="ruby-identifier">send</span>(<span class="ruby-identifier">message</span>)
+196:         <span class="ruby-identifier">raise</span> <span class="ruby-constant">TjException</span>.<span class="ruby-identifier">new</span>, <span class="ruby-value str">''</span>
+197:       <span class="ruby-keyword kw">end</span>
+198:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -814,7 +805,7 @@ Return true if the scanner has processed all files.
 
 		
 			<div id="init-ules-method" class="method-detail ">
-				<a name="M000673"></a>
+				<a name="method-i-initRules"></a>
 
 				<div class="method-heading">
 				
@@ -858,7 +849,7 @@ rules.
 
 		
 			<div id="limit-oken-et-method" class="method-detail ">
-				<a name="M000672"></a>
+				<a name="method-i-limitTokenSet"></a>
 
 				<div class="method-heading">
 				
@@ -898,7 +889,7 @@ Limit the allowed tokens of the scanner to the subset passed by the
 
 		
 			<div id="matching-ules-method" class="method-detail ">
-				<a name="M000682"></a>
+				<a name="method-i-matchingRules"></a>
 
 				<div class="method-heading">
 				
@@ -917,15 +908,15 @@ Limit the allowed tokens of the scanner to the subset passed by the
 					<div class="method-source-code"
 						id="matching-ules-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 190</span>
-190:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">matchingRules</span>(<span class="ruby-identifier">keyword</span>)
-191:       <span class="ruby-identifier">matches</span> = []
-192:       <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>
-193:         <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>)
-194:         <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>
-195:       <span class="ruby-keyword kw">end</span>
-196:       <span class="ruby-identifier">matches</span>
-197:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 181</span>
+181:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">matchingRules</span>(<span class="ruby-identifier">keyword</span>)
+182:       <span class="ruby-identifier">matches</span> = []
+183:       <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>
+184:         <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>)
+185:         <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>
+186:       <span class="ruby-keyword kw">end</span>
+187:       <span class="ruby-identifier">matches</span>
+188:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -937,7 +928,7 @@ Limit the allowed tokens of the scanner to the subset passed by the
 
 		
 			<div id="new-ule-method" class="method-detail ">
-				<a name="M000674"></a>
+				<a name="method-i-newRule"></a>
 
 				<div class="method-heading">
 				
@@ -952,10 +943,10 @@ Limit the allowed tokens of the scanner to the subset passed by the
 					<p>
 Add a new rule to the rule set. <em>name</em> must be a unique identifier.
 The function also sets the class variable @cr to the new rule. Subsequent
-calls to <a href="TextParser.html#M000675">TextParser#pattern</a>, <a
-href="TextParser.html#M000676">TextParser#optional</a> or <a
-href="TextParser.html#M000677">TextParser#repeatable</a> will then
-implicitely operate on the most recently added rule.
+calls to <a href="TextParser.html#method-i-pattern">TextParser#pattern</a>,
+<a href="TextParser.html#method-i-optional">TextParser#optional</a> or <a
+href="TextParser.html#method-i-repeatable">TextParser#repeatable</a> will
+then implicitely operate on the most recently added rule.
 </p>
 					
 
@@ -987,7 +978,7 @@ implicitely operate on the most recently added rule.
 
 		
 			<div id="optional-method" class="method-detail ">
-				<a name="M000676"></a>
+				<a name="method-i-optional"></a>
 
 				<div class="method-heading">
 				
@@ -1024,7 +1015,7 @@ elements.
 
 		
 			<div id="parse-method" class="method-detail ">
-				<a name="M000679"></a>
+				<a name="method-i-parse"></a>
 
 				<div class="method-heading">
 				
@@ -1053,7 +1044,7 @@ top-level parser rule that was specified by <em>ruleName</em>.
 161:       <span class="ruby-identifier">@@expectedTokens</span> = []
 162:       <span class="ruby-identifier">updateParserTables</span>
 163:       <span class="ruby-keyword kw">begin</span>
-164:         <span class="ruby-identifier">result</span> = <span class="ruby-identifier">parseRule</span>(<span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">ruleName</span>])
+164:         <span class="ruby-identifier">result</span> = <span class="ruby-identifier">parseRuleR</span>(<span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">ruleName</span>])
 165:       <span class="ruby-keyword kw">rescue</span> <span class="ruby-constant">TjException</span>
 166:         <span class="ruby-comment cmt"># error('parse_error', $!.message)</span>
 167:         <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">nil</span>
@@ -1072,7 +1063,7 @@ top-level parser rule that was specified by <em>ruleName</em>.
 
 		
 			<div id="pattern-method" class="method-detail ">
-				<a name="M000675"></a>
+				<a name="method-i-pattern"></a>
 
 				<div class="method-heading">
 				
@@ -1129,7 +1120,7 @@ completed the processing of this rule.
 
 		
 			<div id="repeatable-method" class="method-detail ">
-				<a name="M000677"></a>
+				<a name="method-i-repeatable"></a>
 
 				<div class="method-heading">
 				
@@ -1166,7 +1157,7 @@ elements.
 
 		
 			<div id="source-ile-nfo-method" class="method-detail ">
-				<a name="M000681"></a>
+				<a name="method-i-sourceFileInfo"></a>
 
 				<div class="method-heading">
 				
@@ -1190,11 +1181,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 185</span>
-185:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">sourceFileInfo</span>
-186:       <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">empty?</span>
-187:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">sourceFileInfo</span>
-188:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 176</span>
+176:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">sourceFileInfo</span>
+177:       <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">empty?</span>
+178:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">sourceFileInfo</span>[<span class="ruby-value">0</span>]
+179:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1206,7 +1197,7 @@ nil if we don&#8217;t have a current position.
 
 		
 			<div id="update-arser-ables-method" class="method-detail ">
-				<a name="M000678"></a>
+				<a name="method-i-updateParserTables"></a>
 
 				<div class="method-heading">
 				
@@ -1221,7 +1212,7 @@ 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#M000679">TextParser#parse</a>.
+href="TextParser.html#method-i-parse">TextParser#parse</a>.
 </p>
 					
 
@@ -1248,12 +1239,12 @@ href="TextParser.html#M000679">TextParser#parse</a>.
 
 		
 			<div id="warning-method" class="method-detail ">
-				<a name="M000684"></a>
+				<a name="method-i-warning"></a>
 
 				<div class="method-heading">
 				
 					<span class="method-name">warning</span><span
-						class="method-args">(id, text, property = nil)</span>
+						class="method-args">(id, text, property = nil, sfi = nil)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -1267,10 +1258,10 @@ href="TextParser.html#M000679">TextParser#parse</a>.
 					<div class="method-source-code"
 						id="warning-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 203</span>
-203:     <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">property</span> = <span class="ruby-keyword kw">nil</span>)
-204:       <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">property</span>)
-205:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 200</span>
+200:     <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">property</span> = <span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">sfi</span> = <span class="ruby-keyword kw">nil</span>)
+201:       <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">property</span>, <span class="ruby-identifier">sfi</span>)
+202:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1288,7 +1279,7 @@ href="TextParser.html#M000679">TextParser#parse</a>.
 
 		
 			<div id="check-ule-method" class="method-detail ">
-				<a name="M000686"></a>
+				<a name="method-i-checkRule"></a>
 
 				<div class="method-heading">
 				
@@ -1307,30 +1298,110 @@ href="TextParser.html#M000679">TextParser#parse</a>.
 					<div class="method-source-code"
 						id="check-ule-source">
 <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">checkRule</span>(<span class="ruby-identifier">rule</span>)
-266:       <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>
-267:         <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Rule #{rule.name} must have at least one pattern&quot;</span>
-268:       <span class="ruby-keyword kw">end</span>
-269: 
-270:       <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>
-271:         <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>
-272:           <span class="ruby-identifier">type</span> = <span class="ruby-identifier">tok</span>[<span class="ruby-value">0</span>]
-273:           <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>]
-274:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">$$</span>
-275:             <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>
-276:               <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unsupported_token'</span>,
-277:                     <span class="ruby-node">&quot;The token #{token} is not supported here.&quot;</span>)
-278:             <span class="ruby-keyword kw">end</span>
-279:           <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">!!</span>
-280:             <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>
-281:               <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>
-282:                     <span class="ruby-node">&quot;pattern '#{pat}' of rule #{rule.name}&quot;</span>
-283:             <span class="ruby-keyword kw">end</span>
-284:           <span class="ruby-keyword kw">end</span>
-285:         <span class="ruby-keyword kw">end</span>
-286:       <span class="ruby-keyword kw">end</span>
-287:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 262</span>
+262:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">checkRule</span>(<span class="ruby-identifier">rule</span>)
+263:       <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>
+264:         <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Rule #{rule.name} must have at least one pattern&quot;</span>
+265:       <span class="ruby-keyword kw">end</span>
+266: 
+267:       <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>
+268:         <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>
+269:           <span class="ruby-identifier">type</span> = <span class="ruby-identifier">tok</span>[<span class="ruby-value">0</span>]
+270:           <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>]
+271:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">$$</span>
+272:             <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>
+273:               <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unsupported_token'</span>,
+274:                     <span class="ruby-node">&quot;The token #{token} is not supported here.&quot;</span>, <span class="ruby-keyword kw">nil</span>,
+275:                     <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>])
+276:             <span class="ruby-keyword kw">end</span>
+277:           <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">!!</span>
+278:             <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>
+279:               <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>
+280:                     <span class="ruby-node">&quot;pattern '#{pat}' of rule #{rule.name}&quot;</span>
+281:             <span class="ruby-keyword kw">end</span>
+282:           <span class="ruby-keyword kw">end</span>
+283:         <span class="ruby-keyword kw">end</span>
+284:       <span class="ruby-keyword kw">end</span>
+285:     <span class="ruby-keyword kw">end</span></pre>
+					</div>
+					
+				</div>
+
+				
+
+				
+			</div>
+
+		
+			<div id="find-attern-method" class="method-detail ">
+				<a name="method-i-findPattern"></a>
+
+				<div class="method-heading">
+				
+					<span class="method-name">findPattern</span><span
+						class="method-args">(rule, token, repeatMode)</span>
+					<span class="method-click-advice">click to toggle source</span>
+				
+				</div>
+
+				<div class="method-description">
+					
+					
+					
+
+					
+					<div class="method-source-code"
+						id="find-attern-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 524</span>
+524:     <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>)
+525:       <span class="ruby-comment cmt"># The scanner cannot differentiate between keywords and identifiers.  So</span>
+526:       <span class="ruby-comment cmt"># whenever an identifier is returned we have to see if we have a</span>
+527:       <span class="ruby-comment cmt"># matching keyword first. If none is found, then look for normal</span>
+528:       <span class="ruby-comment cmt"># identifiers.</span>
+529:       <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>
+530:         <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>
+531:           <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>)
+532:         <span class="ruby-keyword kw">end</span>
+533:       <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>
+534:         <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>])
+535:       <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>
+536:         <span class="ruby-identifier">patIdx</span> = <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">matchingPatternIndex</span>(<span class="ruby-value str">'.'</span>)
+537:       <span class="ruby-keyword kw">else</span>
+538:         <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>])
+539:       <span class="ruby-keyword kw">end</span>
+540: 
+541:       <span class="ruby-comment cmt"># If no matching pattern is found for the token we have to check if the</span>
+542:       <span class="ruby-comment cmt"># rule is optional or we are in repeat mode. If this is the case, return</span>
+543:       <span class="ruby-comment cmt"># the token back to the scanner. Otherwise, we have found a token we</span>
+544:       <span class="ruby-comment cmt"># cannot handle at this point.</span>
+545:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">patIdx</span>.<span class="ruby-identifier">nil?</span>
+546:         <span class="ruby-comment cmt"># Append the list of expected tokens to the @@expectedToken array.</span>
+547:         <span class="ruby-comment cmt"># This may be used in a later rule to provide more details when an</span>
+548:         <span class="ruby-comment cmt"># error occured.</span>
+549:         <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>
+550:           <span class="ruby-identifier">keys</span> = <span class="ruby-identifier">transition</span>.<span class="ruby-identifier">keys</span>
+551:           <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>] }
+552:           <span class="ruby-identifier">@@expectedTokens</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">keys</span>
+553:           <span class="ruby-identifier">@@expectedTokens</span>.<span class="ruby-identifier">sort!</span>
+554:         <span class="ruby-keyword kw">end</span>
+555: 
+556:         <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>
+557:           <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unexpctd_token'</span>,
+558:                 (<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>
+559:                  <span class="ruby-node">&quot;Unexpected token '#{token[1]}' of type &quot;</span> <span class="ruby-operator">+</span>
+560:                  <span class="ruby-node">&quot;'#{token[0]}'. &quot;</span> <span class="ruby-operator">:</span>
+561:                  <span class="ruby-node">&quot;Unexpected end of file in #{@scanner.fileName}. &quot;</span>) <span class="ruby-operator">+</span>
+562:                 (<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>
+563:                  <span class="ruby-node">&quot;Expecting one of #{@@expectedTokens.join(', ')}&quot;</span> <span class="ruby-operator">:</span>
+564:                  <span class="ruby-node">&quot;Expecting #{@@expectedTokens[0]}&quot;</span>))
+565:         <span class="ruby-keyword kw">end</span>
+566:         <span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>)
+567:         <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">nil</span>
+568:       <span class="ruby-keyword kw">end</span>
+569: 
+570:       <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">pattern</span>(<span class="ruby-identifier">patIdx</span>)
+571:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1342,7 +1413,7 @@ href="TextParser.html#M000679">TextParser#parse</a>.
 
 		
 			<div id="get-ext-oken-method" class="method-detail ">
-				<a name="M000688"></a>
+				<a name="method-i-getNextToken"></a>
 
 				<div class="method-heading">
 				
@@ -1361,20 +1432,21 @@ href="TextParser.html#M000679">TextParser#parse</a>.
 					<div class="method-source-code"
 						id="get-ext-oken-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 433</span>
-433:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">getNextToken</span>
-434:       <span class="ruby-keyword kw">begin</span>
-435:         <span class="ruby-identifier">token</span> = <span class="ruby-identifier">nextToken</span>
-436:         <span class="ruby-constant">Log</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-node">&quot;Token: [#{token[0]}][#{token[1]}]&quot;</span>
-437:       <span class="ruby-keyword kw">rescue</span> <span class="ruby-constant">TjException</span>
-438:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'parse_rule'</span>, <span class="ruby-identifier">$!</span>.<span class="ruby-identifier">message</span>)
-439:       <span class="ruby-keyword kw">end</span>
-440:       <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>])
-441:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unsupported_token'</span>,
-442:               <span class="ruby-node">&quot;The token #{token[1]} is not supported in this context.&quot;</span>)
-443:       <span class="ruby-keyword kw">end</span>
-444:       <span class="ruby-identifier">token</span>
-445:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 509</span>
+509:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">getNextToken</span>
+510:       <span class="ruby-keyword kw">begin</span>
+511:         <span class="ruby-identifier">token</span> = <span class="ruby-identifier">nextToken</span>
+512:         <span class="ruby-comment cmt">#Log &lt;&lt; &quot;Token: [#{token[0]}][#{token[1]}]&quot;</span>
+513:       <span class="ruby-keyword kw">rescue</span> <span class="ruby-constant">TjException</span>
+514:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'parse_rule'</span>, <span class="ruby-identifier">$!</span>.<span class="ruby-identifier">message</span>)
+515:       <span class="ruby-keyword kw">end</span>
+516:       <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>])
+517:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unsupported_token'</span>,
+518:               <span class="ruby-node">&quot;The token #{token[1]} is not supported in this context.&quot;</span>,
+519:               <span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>])
+520:       <span class="ruby-keyword kw">end</span>
+521:       <span class="ruby-identifier">token</span>
+522:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1386,7 +1458,7 @@ href="TextParser.html#M000679">TextParser#parse</a>.
 
 		
 			<div id="get-ransitions-method" class="method-detail ">
-				<a name="M000685"></a>
+				<a name="method-i-getTransitions"></a>
 
 				<div class="method-heading">
 				
@@ -1412,56 +1484,233 @@ in a token -> rule hash.
 					<div class="method-source-code"
 						id="get-ransitions-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 215</span>
-215:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">getTransitions</span>(<span class="ruby-identifier">rule</span>)
-216:       <span class="ruby-comment cmt"># If we have processed this rule before we can just return a copy</span>
-217:       <span class="ruby-comment cmt"># of the transitions of this rule. This avoids endless recursions.</span>
-218:       <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>
-219: 
-220:       <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">transitions</span> = []
-221:       <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>
-222:         <span class="ruby-identifier">allTokensOptional</span> = <span class="ruby-keyword kw">true</span>
-223:         <span class="ruby-identifier">transitions</span> = { }
-224:         <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>
-225:           <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>]
-226:           <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>
-227:             <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>)
-228:               <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>
-229:                     <span class="ruby-node">&quot;#{pat} + of rule #{rule.name}&quot;</span>
-230:             <span class="ruby-keyword kw">end</span>
-231:             <span class="ruby-identifier">refRule</span> = <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">tokenId</span>]
-232:             <span class="ruby-comment cmt"># If the referenced rule describes optional content, we need to look</span>
-233:             <span class="ruby-comment cmt"># at the next token as well.</span>
-234:             <span class="ruby-identifier">res</span> = <span class="ruby-identifier">getTransitions</span>(<span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">tokenId</span>])
-235:             <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>)
-236:             <span class="ruby-comment cmt"># Combine the hashes for each pattern into a single hash</span>
-237:             <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>
-238:               <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> }
-239:             <span class="ruby-keyword kw">end</span>
-240:             <span class="ruby-identifier">optional</span> = <span class="ruby-keyword kw">true</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">refRule</span>.<span class="ruby-identifier">optional</span>
-241:           <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>])
-242:             <span class="ruby-identifier">transitions</span>[<span class="ruby-identifier">token</span>] = <span class="ruby-identifier">rule</span>
-243:             <span class="ruby-identifier">allTokensOptional</span> = <span class="ruby-keyword kw">false</span>
-244:           <span class="ruby-keyword kw">else</span>
-245:             <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>
-246:                   <span class="ruby-node">&quot;: #{tokenId}&quot;</span>
-247:           <span class="ruby-keyword kw">end</span>
-248:           <span class="ruby-keyword kw">break</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">allTokensOptional</span>
-249:         <span class="ruby-keyword kw">end</span>
-250:         <span class="ruby-comment cmt"># Make sure that we only have one possible transition for each</span>
-251:         <span class="ruby-comment cmt"># target.</span>
-252:         <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>
-253:           <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>
-254:             <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>)
-255:               <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>
-256:                     <span class="ruby-node">&quot;transitions for target #{key}&quot;</span>
-257:             <span class="ruby-keyword kw">end</span>
-258:           <span class="ruby-keyword kw">end</span>
-259:         <span class="ruby-keyword kw">end</span>
-260:         <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>
-261:       <span class="ruby-keyword kw">end</span>
-262:       <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">transitions</span>.<span class="ruby-identifier">dup</span>
-263:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 212</span>
+212:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">getTransitions</span>(<span class="ruby-identifier">rule</span>)
+213:       <span class="ruby-comment cmt"># If we have processed this rule before we can just return a copy</span>
+214:       <span class="ruby-comment cmt"># of the transitions of this rule. This avoids endless recursions.</span>
+215:       <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>
+216: 
+217:       <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">transitions</span> = []
+218:       <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>
+219:         <span class="ruby-identifier">allTokensOptional</span> = <span class="ruby-keyword kw">true</span>
+220:         <span class="ruby-identifier">transitions</span> = { }
+221:         <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>
+222:           <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>]
+223:           <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>
+224:             <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>)
+225:               <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>
+226:                     <span class="ruby-node">&quot;#{pat} + of rule #{rule.name}&quot;</span>
+227:             <span class="ruby-keyword kw">end</span>
+228:             <span class="ruby-identifier">refRule</span> = <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">tokenId</span>]
+229:             <span class="ruby-comment cmt"># If the referenced rule describes optional content, we need to look</span>
+230:             <span class="ruby-comment cmt"># at the next token as well.</span>
+231:             <span class="ruby-identifier">res</span> = <span class="ruby-identifier">getTransitions</span>(<span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">tokenId</span>])
+232:             <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>)
+233:             <span class="ruby-comment cmt"># Combine the hashes for each pattern into a single hash</span>
+234:             <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>
+235:               <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> }
+236:             <span class="ruby-keyword kw">end</span>
+237:             <span class="ruby-identifier">optional</span> = <span class="ruby-keyword kw">true</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">refRule</span>.<span class="ruby-identifier">optional</span>
+238:           <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>])
+239:             <span class="ruby-identifier">transitions</span>[<span class="ruby-identifier">token</span>] = <span class="ruby-identifier">rule</span>
+240:             <span class="ruby-identifier">allTokensOptional</span> = <span class="ruby-keyword kw">false</span>
+241:           <span class="ruby-keyword kw">else</span>
+242:             <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>
+243:                   <span class="ruby-node">&quot;: #{tokenId}&quot;</span>
+244:           <span class="ruby-keyword kw">end</span>
+245:           <span class="ruby-keyword kw">break</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">allTokensOptional</span>
+246:         <span class="ruby-keyword kw">end</span>
+247:         <span class="ruby-comment cmt"># Make sure that we only have one possible transition for each</span>
+248:         <span class="ruby-comment cmt"># target.</span>
+249:         <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>
+250:           <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>
+251:             <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>)
+252:               <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>
+253:                     <span class="ruby-node">&quot;transitions for target #{key}&quot;</span>
+254:             <span class="ruby-keyword kw">end</span>
+255:           <span class="ruby-keyword kw">end</span>
+256:         <span class="ruby-keyword kw">end</span>
+257:         <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>
+258:       <span class="ruby-keyword kw">end</span>
+259:       <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">transitions</span>.<span class="ruby-identifier">dup</span>
+260:     <span class="ruby-keyword kw">end</span></pre>
+					</div>
+					
+				</div>
+
+				
+
+				
+			</div>
+
+		
+			<div id="parse-ule--method" class="method-detail ">
+				<a name="method-i-parseRuleNR"></a>
+
+				<div class="method-heading">
+				
+					<span class="method-name">parseRuleNR</span><span
+						class="method-args">(rule)</span>
+					<span class="method-click-advice">click to toggle source</span>
+				
+				</div>
+
+				<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">
+<pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 370</span>
+370:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">parseRuleNR</span>(<span class="ruby-identifier">rule</span>)
+371:       <span class="ruby-identifier">elementIdx</span> = <span class="ruby-value">0</span>
+372:       <span class="ruby-identifier">recursionResult</span> = <span class="ruby-keyword kw">nil</span>
+373:       <span class="ruby-comment cmt"># These flags are used to managed the control flow to and from the</span>
+374:       <span class="ruby-comment cmt"># recursion point.</span>
+375:       <span class="ruby-identifier">recur</span> = <span class="ruby-identifier">resume</span> = <span class="ruby-keyword kw">false</span>
+376:       <span class="ruby-comment cmt"># The stack that holds the context for the recursion levels. It's either</span>
+377:       <span class="ruby-comment cmt"># just a rule to start a new recursion or an Array of state variables.</span>
+378:       <span class="ruby-identifier">recursionStack</span> = [ <span class="ruby-identifier">rule</span> ]
+379:       <span class="ruby-keyword kw">begin</span>
+380:         <span class="ruby-comment cmt"># Pop the top entry from the recursion stack.</span>
+381:         <span class="ruby-identifier">se</span> = <span class="ruby-identifier">recursionStack</span>.<span class="ruby-identifier">pop</span>
+382:         <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>)
+383:           <span class="ruby-comment cmt"># We have essentially finished a recursion level and need to get</span>
+384:           <span class="ruby-comment cmt"># back to the place where we started the recursion. First, we need</span>
+385:           <span class="ruby-comment cmt"># to restore the state again.</span>
+386:           <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>
+387:           <span class="ruby-comment cmt">#Log &lt;&lt; &quot;Recursion loop started in resume mode for rule #{rule.name}&quot;</span>
+388:           <span class="ruby-comment cmt"># Now jump to the recursion point without doing anything else.</span>
+389:           <span class="ruby-identifier">resume</span> = <span class="ruby-keyword kw">true</span>
+390:         <span class="ruby-keyword kw">else</span>
+391:           <span class="ruby-comment cmt"># Start a new recursion level. The rule tells us how to interpret</span>
+392:           <span class="ruby-comment cmt"># the input text.</span>
+393:           <span class="ruby-identifier">rule</span> = <span class="ruby-identifier">se</span>
+394:           <span class="ruby-comment cmt">#Log.enter('parseRuleNR', &quot;Parsing with rule #{rule.name}&quot;)</span>
+395:           <span class="ruby-identifier">resume</span> = <span class="ruby-keyword kw">false</span>
+396:         <span class="ruby-keyword kw">end</span>
+397: 
+398:         <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">resume</span>
+399:           <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>
+400:           <span class="ruby-comment cmt"># Rules can be marked 'repeatable'. This flag will be set to true</span>
+401:           <span class="ruby-comment cmt"># after the first iteration has been completed.</span>
+402:           <span class="ruby-identifier">repeatMode</span> = <span class="ruby-keyword kw">false</span>
+403:         <span class="ruby-keyword kw">end</span>
+404: 
+405:         <span class="ruby-identifier">loop</span> <span class="ruby-keyword kw">do</span>
+406:           <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">resume</span>
+407:             <span class="ruby-comment cmt"># At the beginning of a rule we need a token from the input to</span>
+408:             <span class="ruby-comment cmt"># determine which pattern of the rule needs to be processed.</span>
+409:             <span class="ruby-identifier">token</span> = <span class="ruby-identifier">getNextToken</span>
+410: 
+411:             <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>))
+412:             <span class="ruby-comment cmt"># The @stack will store the resulting value of each element in the</span>
+413:             <span class="ruby-comment cmt"># pattern.</span>
+414:             <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>)
+415: 
+416:             <span class="ruby-comment cmt"># Once we've found the right pattern, we need to process each</span>
+417:             <span class="ruby-comment cmt"># element.</span>
+418:             <span class="ruby-identifier">elementIdx</span> = <span class="ruby-value">0</span>
+419:           <span class="ruby-keyword kw">end</span>
+420: 
+421:           <span class="ruby-identifier">elementCount</span> = <span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">length</span>
+422:           <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>
+423:             <span class="ruby-identifier">element</span> = <span class="ruby-identifier">pattern</span>[<span class="ruby-identifier">elementIdx</span>]
+424:             <span class="ruby-comment cmt"># Separate the type and token text for pattern element.</span>
+425:             <span class="ruby-identifier">elType</span> = <span class="ruby-identifier">element</span>[<span class="ruby-value">0</span>]
+426:             <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>]
+427:             <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">elType</span> <span class="ruby-operator">==</span> <span class="ruby-value">!!</span>
+428:               <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">resume</span>
+429:                 <span class="ruby-comment cmt"># The element is a reference to another rule. Return the token</span>
+430:                 <span class="ruby-comment cmt"># if we still have one and continue with the referenced rule.</span>
+431:                 <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">token</span>
+432:                   <span class="ruby-identifier">sfi</span> = <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>]
+433:                   <span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>)
+434:                   <span class="ruby-identifier">token</span> = <span class="ruby-keyword kw">nil</span>
+435:                 <span class="ruby-keyword kw">else</span>
+436:                   <span class="ruby-identifier">sfi</span> = <span class="ruby-keyword kw">nil</span>
+437:                 <span class="ruby-keyword kw">end</span>
+438:                 <span class="ruby-comment cmt"># This is where the recursion would happen. Instead, we push</span>
+439:                 <span class="ruby-comment cmt"># the state variables and then the next rule onto the</span>
+440:                 <span class="ruby-comment cmt"># recursion stack.</span>
+441:                 <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>,
+442:                                       <span class="ruby-identifier">repeatMode</span>, <span class="ruby-identifier">sfi</span> ])
+443:                 <span class="ruby-identifier">recursionStack</span>.<span class="ruby-identifier">push</span>(<span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">elToken</span>])
+444:                 <span class="ruby-comment cmt"># Now terminate all but the outer loops without doing anything</span>
+445:                 <span class="ruby-comment cmt"># else.</span>
+446:                 <span class="ruby-identifier">recur</span> = <span class="ruby-keyword kw">true</span>
+447:                 <span class="ruby-keyword kw">break</span>
+448:               <span class="ruby-keyword kw">else</span>
+449:                 <span class="ruby-comment cmt"># We're back right after where the recursion started. Store</span>
+450:                 <span class="ruby-comment cmt"># the result and turn resume mode off again.</span>
+451:                 <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>)
+452:                 <span class="ruby-identifier">resume</span> = <span class="ruby-keyword kw">false</span>
+453:               <span class="ruby-keyword kw">end</span>
+454:             <span class="ruby-keyword kw">else</span>
+455:               <span class="ruby-comment cmt"># In case the element is a keyword or variable we have to get a</span>
+456:               <span class="ruby-comment cmt"># new token if we don't have one anymore.</span>
+457:               <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>
+458: 
+459:               <span class="ruby-identifier">processNormalElements</span>(<span class="ruby-identifier">elType</span>, <span class="ruby-identifier">elToken</span>, <span class="ruby-identifier">token</span>)
+460: 
+461:               <span class="ruby-comment cmt"># The token has been consumed. Reset the variable.</span>
+462:               <span class="ruby-identifier">token</span> = <span class="ruby-keyword kw">nil</span>
+463:               <span class="ruby-identifier">@@expectedTokens</span> = []
+464:             <span class="ruby-keyword kw">end</span>
+465:             <span class="ruby-identifier">elementIdx</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
+466:           <span class="ruby-keyword kw">end</span> <span class="ruby-comment cmt"># of pattern while loop</span>
+467: 
+468:           <span class="ruby-comment cmt"># Skip the rest of the loop in recur mode.</span>
+469:           <span class="ruby-keyword kw">break</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">recur</span>
+470: 
+471:           <span class="ruby-identifier">elementIdx</span> = <span class="ruby-value">0</span>
+472: 
+473:           <span class="ruby-comment cmt"># Once the complete pattern has been processed we call the</span>
+474:           <span class="ruby-comment cmt"># processing function for this pattern to operate on the value</span>
+475:           <span class="ruby-comment cmt"># array. Then pop the entry for this rule from the stack. The</span>
+476:           <span class="ruby-comment cmt"># called function will use @val and @sourceFileInfo to retrieve</span>
+477:           <span class="ruby-comment cmt"># data from the parser.</span>
+478:           <span class="ruby-ivar">@val</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">val</span>
+479:           <span class="ruby-ivar">@sourceFileInfo</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">sourceFileInfo</span>
+480:           <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>
+481:           <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">pop</span>
+482: 
+483:           <span class="ruby-comment cmt"># If the rule is not repeatable we can store the result and break</span>
+484:           <span class="ruby-comment cmt"># the outer loop to exit the function.</span>
+485:           <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">repeatable</span>
+486:             <span class="ruby-identifier">result</span> = <span class="ruby-identifier">res</span>
+487:             <span class="ruby-keyword kw">break</span>
+488:           <span class="ruby-keyword kw">end</span>
+489: 
+490:           <span class="ruby-comment cmt"># Otherwise we append the result to the result array and turn repeat</span>
+491:           <span class="ruby-comment cmt"># mode on.</span>
+492:           <span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">res</span>
+493:           <span class="ruby-comment cmt"># We have completed the first iteration. Set the repeat mode flag to</span>
+494:           <span class="ruby-comment cmt"># indicate that further iterations are already re-runs.</span>
+495:           <span class="ruby-identifier">repeatMode</span> = <span class="ruby-keyword kw">true</span>
+496:         <span class="ruby-keyword kw">end</span> <span class="ruby-comment cmt"># of rule processing loop</span>
+497: 
+498:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">recur</span>
+499:           <span class="ruby-identifier">recur</span> = <span class="ruby-keyword kw">false</span>
+500:         <span class="ruby-keyword kw">else</span>
+501:           <span class="ruby-comment cmt">#Log.exit('parseRuleNR', &quot;Finished rule #{rule.name}&quot;)</span>
+502:           <span class="ruby-identifier">recursionResult</span> = <span class="ruby-identifier">result</span>
+503:         <span class="ruby-keyword kw">end</span>
+504:       <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>
+505: 
+506:       <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">result</span>
+507:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1472,12 +1721,12 @@ in a token -> rule hash.
 			</div>
 
 		
-			<div id="parse-ule-method" class="method-detail ">
-				<a name="M000687"></a>
+			<div id="parse-ule--method" class="method-detail ">
+				<a name="method-i-parseRuleR"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">parseRule</span><span
+					<span class="method-name">parseRuleR</span><span
 						class="method-args">(rule)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
@@ -1488,17 +1737,18 @@ in a token -> rule hash.
 					<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.
+description contains the reference to another rule. This recursive version
+has cleaner code and is about 8% faster than parseRuleNR.
 </p>
 					
 
 					
 					<div class="method-source-code"
-						id="parse-ule-source">
+						id="parse-ule--source">
 <pre>
      <span class="ruby-comment cmt"># File lib/TextParser.rb, line 292</span>
-292:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">parseRule</span>(<span class="ruby-identifier">rule</span>)
-293:       <span class="ruby-constant">Log</span>.<span class="ruby-identifier">enter</span>(<span class="ruby-value str">'parseRule'</span>, <span class="ruby-node">&quot;Parsing with rule #{rule.name}&quot;</span>)
+292:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">parseRuleR</span>(<span class="ruby-identifier">rule</span>)
+293:       <span class="ruby-comment cmt">#Log.enter('parseRuleR', &quot;Parsing with rule #{rule.name}&quot;)</span>
 294:       <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>
 295:       <span class="ruby-comment cmt"># Rules can be marked 'repeatable'. This flag will be set to true after</span>
 296:       <span class="ruby-comment cmt"># the first iteration has been completed.</span>
@@ -1508,135 +1758,132 @@ description contains the reference to another rule.
 300:         <span class="ruby-comment cmt"># which pattern of the rule needs to be processed.</span>
 301:         <span class="ruby-identifier">token</span> = <span class="ruby-identifier">getNextToken</span>
 302: 
-303:         <span class="ruby-comment cmt"># The scanner cannot differentiate between keywords and identifiers. So</span>
-304:         <span class="ruby-comment cmt"># whenever an identifier is returned we have to see if we have a</span>
-305:         <span class="ruby-comment cmt"># matching keyword first. If none is found, then look for normal</span>
-306:         <span class="ruby-comment cmt"># identifiers.</span>
-307:         <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>
-308:           <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>
-309:             <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>)
-310:           <span class="ruby-keyword kw">end</span>
-311:         <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>
-312:           <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>])
-313:         <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>
-314:           <span class="ruby-identifier">patIdx</span> = <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">matchingPatternIndex</span>(<span class="ruby-value str">'.'</span>)
-315:         <span class="ruby-keyword kw">else</span>
-316:           <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>])
-317:         <span class="ruby-keyword kw">end</span>
-318: 
-319:         <span class="ruby-comment cmt"># If no matching pattern is found for the token we have to check if the</span>
-320:         <span class="ruby-comment cmt"># rule is optional or we are in repeat mode. If this is the case, return</span>
-321:         <span class="ruby-comment cmt"># the token back to the scanner. Otherwise we have found a token we</span>
-322:         <span class="ruby-comment cmt"># cannot handle at this point.</span>
-323:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">patIdx</span>.<span class="ruby-identifier">nil?</span>
-324:           <span class="ruby-comment cmt"># Append the list of expected tokens to the @@expectedToken array.</span>
-325:           <span class="ruby-comment cmt"># This may be used in a later rule to provide more details when an</span>
-326:           <span class="ruby-comment cmt"># error occured.</span>
-327:           <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>
-328:             <span class="ruby-identifier">keys</span> = <span class="ruby-identifier">transition</span>.<span class="ruby-identifier">keys</span>
-329:             <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>] }
-330:             <span class="ruby-identifier">@@expectedTokens</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">keys</span>
-331:             <span class="ruby-identifier">@@expectedTokens</span>.<span class="ruby-identifier">sort!</span>
-332:           <span class="ruby-keyword kw">end</span>
-333: 
-334:           <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>
-335:             <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unexpctd_token'</span>,
-336:                   (<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>
-337:                    <span class="ruby-node">&quot;Unexpected token '#{token[1]}' of type '#{token[0]}'. &quot;</span> <span class="ruby-operator">:</span>
-338:                    <span class="ruby-node">&quot;Unexpected end of file in #{@scanner.fileName}. &quot;</span>) <span class="ruby-operator">+</span>
-339:                   (<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>
-340:                    <span class="ruby-node">&quot;Expecting one of #{@@expectedTokens.join(', ')}&quot;</span> <span class="ruby-operator">:</span>
-341:                    <span class="ruby-node">&quot;Expecting #{@@expectedTokens[0]}&quot;</span>))
-342:           <span class="ruby-keyword kw">end</span>
-343:           <span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>)
-344:           <span class="ruby-constant">Log</span>.<span class="ruby-identifier">exit</span>(<span class="ruby-value str">'parseRule'</span>, <span class="ruby-node">&quot;Finished rule #{rule.name}&quot;</span>)
-345:           <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">result</span>
-346:         <span class="ruby-keyword kw">end</span>
-347: 
-348:         <span class="ruby-identifier">pattern</span> = <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">pattern</span>(<span class="ruby-identifier">patIdx</span>)
-349:         <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">rule</span>, <span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span>,
-350:                                                <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">sourceFileInfo</span>)
-351: 
-352:         <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>
-353:           <span class="ruby-comment cmt"># Separate the type and token text for pattern element.</span>
-354:           <span class="ruby-identifier">elType</span> = <span class="ruby-identifier">element</span>[<span class="ruby-value">0</span>]
-355:           <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>]
-356:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">elType</span> <span class="ruby-operator">==</span> <span class="ruby-value">!!</span>
-357:             <span class="ruby-comment cmt"># The element is a reference to another rule. Return the token if we</span>
-358:             <span class="ruby-comment cmt"># still have one and continue with the referenced rule.</span>
-359:             <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">token</span>.<span class="ruby-identifier">nil?</span>
-360:               <span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>)
-361:               <span class="ruby-identifier">token</span> = <span class="ruby-keyword kw">nil</span>
-362:             <span class="ruby-keyword kw">end</span>
-363:             <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">store</span>(<span class="ruby-identifier">parseRule</span>(<span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">elToken</span>]),
-364:                               <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">sourceFileInfo</span>)
-365:           <span class="ruby-keyword kw">else</span>
-366:             <span class="ruby-comment cmt"># In case the element is a keyword or variable we have to get a new</span>
-367:             <span class="ruby-comment cmt"># token if we don't have one anymore.</span>
-368:             <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">token</span>.<span class="ruby-identifier">nil?</span>
-369:               <span class="ruby-identifier">token</span> = <span class="ruby-identifier">getNextToken</span>
-370:             <span class="ruby-keyword kw">end</span>
-371: 
-372:             <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">elType</span> <span class="ruby-operator">==</span> <span class="ruby-value">__</span>
-373:               <span class="ruby-comment cmt"># If the element requires a keyword the token must match this</span>
-374:               <span class="ruby-comment cmt"># keyword.</span>
-375:               <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>]
-376:                 <span class="ruby-identifier">text</span> = <span class="ruby-node">&quot;'#{elToken}' expected but found &quot;</span> <span class="ruby-operator">+</span>
-377:                        <span class="ruby-node">&quot;'#{token[1]}' (#{token[0]}).&quot;</span>
-378:                 <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">@@expectedTokens</span>.<span class="ruby-identifier">empty?</span>
-379:                   <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>
-380:                 <span class="ruby-keyword kw">end</span>
-381:                 <span class="ruby-identifier">error</span>(<span class="ruby-value str">'spec_keywork_expctd'</span>, <span class="ruby-identifier">text</span>)
-382:               <span class="ruby-keyword kw">end</span>
-383:               <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-ivar">@scanner</span>.<span class="ruby-identifier">sourceFileInfo</span>)
-384:             <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">elType</span> <span class="ruby-operator">==</span> <span class="ruby-value">..</span>
-385:               <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">token</span> <span class="ruby-operator">!=</span> [ <span class="ruby-value str">'.'</span>, <span class="ruby-value str">'&lt;END&gt;'</span> ]
-386:                 <span class="ruby-identifier">error</span>(<span class="ruby-value str">'end_expected'</span>, <span class="ruby-value str">'End expected but found '</span> <span class="ruby-operator">+</span>
-387:                       <span class="ruby-node">&quot;'#{token[1]}' (#{token[0]}).&quot;</span>)
-388:               <span class="ruby-keyword kw">end</span>
-389:             <span class="ruby-keyword kw">else</span>
-390:               <span class="ruby-comment cmt"># The token must match the expected variable type.</span>
-391:               <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>
-392:                 <span class="ruby-identifier">text</span> = <span class="ruby-node">&quot;'#{elToken}' expected but found &quot;</span> <span class="ruby-operator">+</span>
-393:                        <span class="ruby-node">&quot;'#{token[1]}' (#{token[0]}).&quot;</span>
-394:                 <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">@@expectedTokens</span>.<span class="ruby-identifier">empty?</span>
-395:                   <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>
-396:                 <span class="ruby-keyword kw">end</span>
-397:                 <span class="ruby-identifier">error</span>(<span class="ruby-value str">'spec_token_expctd'</span>, <span class="ruby-identifier">text</span>)
-398:               <span class="ruby-keyword kw">end</span>
-399:               <span class="ruby-comment cmt"># If the element is a variable store the value of the token.</span>
-400:               <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-ivar">@scanner</span>.<span class="ruby-identifier">sourceFileInfo</span>)
-401:             <span class="ruby-keyword kw">end</span>
-402:             <span class="ruby-comment cmt"># The token has been consumed. Reset the variable.</span>
-403:             <span class="ruby-identifier">token</span> = <span class="ruby-keyword kw">nil</span>
-404:             <span class="ruby-identifier">@@expectedTokens</span> = []
-405:           <span class="ruby-keyword kw">end</span>
-406:         <span class="ruby-keyword kw">end</span>
-407: 
-408:         <span class="ruby-comment cmt"># Once the complete pattern has been processed we call the processing</span>
-409:         <span class="ruby-comment cmt"># function for this pattern to operate on the value array. Then pop the</span>
-410:         <span class="ruby-comment cmt"># entry for this rule from the stack.</span>
-411:         <span class="ruby-ivar">@val</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">val</span>
-412:         <span class="ruby-identifier">res</span> = <span class="ruby-keyword kw">nil</span>
-413:         <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>
-414:         <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">pop</span>
-415: 
-416:         <span class="ruby-comment cmt"># If the rule is not repeatable we can store the result and break the</span>
-417:         <span class="ruby-comment cmt"># outer loop to exit the function.</span>
-418:         <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">repeatable</span>
-419:           <span class="ruby-identifier">result</span> = <span class="ruby-identifier">res</span>
-420:           <span class="ruby-keyword kw">break</span>
-421:         <span class="ruby-keyword kw">end</span>
-422: 
-423:         <span class="ruby-comment cmt"># Otherwise we append the result to the result array and turn repeat</span>
-424:         <span class="ruby-comment cmt"># mode on.</span>
-425:         <span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">res</span>
-426:         <span class="ruby-identifier">repeatMode</span> = <span class="ruby-keyword kw">true</span>
-427:       <span class="ruby-keyword kw">end</span>
-428: 
-429:       <span class="ruby-constant">Log</span>.<span class="ruby-identifier">exit</span>(<span class="ruby-value str">'parseRule'</span>, <span class="ruby-node">&quot;Finished rule #{rule.name}&quot;</span>)
-430:       <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">result</span>
-431:     <span class="ruby-keyword kw">end</span></pre>
+303:         <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>))
+304:         <span class="ruby-comment cmt"># The @stack will store the resulting value of each element in the</span>
+305:         <span class="ruby-comment cmt"># pattern.</span>
+306:         <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>)
+307: 
+308:         <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>
+309:           <span class="ruby-comment cmt"># Separate the type and token text for pattern element.</span>
+310:           <span class="ruby-identifier">elType</span> = <span class="ruby-identifier">element</span>[<span class="ruby-value">0</span>]
+311:           <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>]
+312:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">elType</span> <span class="ruby-operator">==</span> <span class="ruby-value">!!</span>
+313:             <span class="ruby-comment cmt"># The element is a reference to another rule. Return the token if</span>
+314:             <span class="ruby-comment cmt"># we still have one and continue with the referenced rule.</span>
+315:             <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">token</span>.<span class="ruby-identifier">nil?</span>
+316:               <span class="ruby-identifier">sfi</span> = <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>]
+317:               <span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>)
+318:               <span class="ruby-identifier">token</span> = <span class="ruby-keyword kw">nil</span>
+319:             <span class="ruby-keyword kw">else</span>
+320:               <span class="ruby-identifier">sfi</span> = <span class="ruby-keyword kw">nil</span>
+321:             <span class="ruby-keyword kw">end</span>
+322:             <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>)
+323:             <span class="ruby-comment cmt">#Log &lt;&lt; &quot;Resuming rule #{rule.name}&quot;</span>
+324:           <span class="ruby-keyword kw">else</span>
+325:             <span class="ruby-comment cmt"># In case the element is a keyword or variable we have to get a new</span>
+326:             <span class="ruby-comment cmt"># token if we don't have one anymore.</span>
+327:             <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>
+328: 
+329:             <span class="ruby-identifier">processNormalElements</span>(<span class="ruby-identifier">elType</span>, <span class="ruby-identifier">elToken</span>, <span class="ruby-identifier">token</span>)
+330: 
+331:             <span class="ruby-comment cmt"># The token has been consumed. Reset the variable.</span>
+332:             <span class="ruby-identifier">token</span> = <span class="ruby-keyword kw">nil</span>
+333:             <span class="ruby-identifier">@@expectedTokens</span> = []
+334:           <span class="ruby-keyword kw">end</span>
+335:         <span class="ruby-keyword kw">end</span>
+336: 
+337:         <span class="ruby-comment cmt"># Once the complete pattern has been processed we call the processing</span>
+338:         <span class="ruby-comment cmt"># function for this pattern to operate on the value array. Then pop the</span>
+339:         <span class="ruby-comment cmt"># entry for this rule from the stack.</span>
+340:         <span class="ruby-ivar">@val</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">val</span>
+341:         <span class="ruby-ivar">@sourceFileInfo</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">sourceFileInfo</span>
+342:         <span class="ruby-identifier">res</span> = <span class="ruby-keyword kw">nil</span>
+343:         <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>
+344:         <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">pop</span>
+345: 
+346:         <span class="ruby-comment cmt"># If the rule is not repeatable we can store the result and break the</span>
+347:         <span class="ruby-comment cmt"># outer loop to exit the function.</span>
+348:         <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">repeatable</span>
+349:           <span class="ruby-identifier">result</span> = <span class="ruby-identifier">res</span>
+350:           <span class="ruby-keyword kw">break</span>
+351:         <span class="ruby-keyword kw">end</span>
+352: 
+353:         <span class="ruby-comment cmt"># Otherwise we append the result to the result array and turn repeat</span>
+354:         <span class="ruby-comment cmt"># mode on.</span>
+355:         <span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">res</span>
+356:         <span class="ruby-identifier">repeatMode</span> = <span class="ruby-keyword kw">true</span>
+357:       <span class="ruby-keyword kw">end</span>
+358: 
+359:       <span class="ruby-comment cmt">#Log.exit('parseRuleR', &quot;Finished rule #{rule.name}&quot;)</span>
+360:       <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">result</span>
+361:     <span class="ruby-keyword kw">end</span></pre>
+					</div>
+					
+				</div>
+
+				
+
+				
+			</div>
+
+		
+			<div id="process-ormal-lements-method" class="method-detail ">
+				<a name="method-i-processNormalElements"></a>
+
+				<div class="method-heading">
+				
+					<span class="method-name">processNormalElements</span><span
+						class="method-args">(elType, elToken, token)</span>
+					<span class="method-click-advice">click to toggle source</span>
+				
+				</div>
+
+				<div class="method-description">
+					
+					<p>
+Handle the elements that don&#8217;t trigger a recursion.
+</p>
+					
+
+					
+					<div class="method-source-code"
+						id="process-ormal-lements-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 574</span>
+574:     <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>)
+575:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">elType</span> <span class="ruby-operator">==</span> <span class="ruby-value">__</span>
+576:         <span class="ruby-comment cmt"># If the element requires a keyword the token must match this</span>
+577:         <span class="ruby-comment cmt"># keyword.</span>
+578:         <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>]
+579:           <span class="ruby-identifier">text</span> = <span class="ruby-node">&quot;'#{elToken}' expected but found &quot;</span> <span class="ruby-operator">+</span>
+580:                  <span class="ruby-node">&quot;'#{token[1]}' (#{token[0]}).&quot;</span>
+581:           <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">@@expectedTokens</span>.<span class="ruby-identifier">empty?</span>
+582:             <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>
+583:           <span class="ruby-keyword kw">end</span>
+584:           <span class="ruby-identifier">error</span>(<span class="ruby-value str">'spec_keywork_expctd'</span>, <span class="ruby-identifier">text</span>)
+585:         <span class="ruby-keyword kw">end</span>
+586:         <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>])
+587:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">elType</span> <span class="ruby-operator">==</span> <span class="ruby-value">..</span>
+588:         <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> ]
+589:           <span class="ruby-identifier">error</span>(<span class="ruby-value str">'end_expected'</span>,
+590:                 <span class="ruby-node">&quot;Found garbage at expected end of file: #{token[1]}\n&quot;</span> <span class="ruby-operator">+</span>
+591:                 <span class="ruby-value str">&quot;If you see this in the middle of your file, you probably &quot;</span> <span class="ruby-operator">+</span>
+592:                 <span class="ruby-value str">&quot;have closed your context too early.&quot;</span>)
+593:         <span class="ruby-keyword kw">end</span>
+594:       <span class="ruby-keyword kw">else</span>
+595:         <span class="ruby-comment cmt"># The token must match the expected variable type.</span>
+596:         <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>
+597:           <span class="ruby-identifier">text</span> = <span class="ruby-node">&quot;'#{elToken}' expected but found &quot;</span> <span class="ruby-operator">+</span>
+598:                  <span class="ruby-node">&quot;'#{token[1]}' (#{token[0]}).&quot;</span>
+599:           <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">@@expectedTokens</span>.<span class="ruby-identifier">empty?</span>
+600:             <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>
+601:           <span class="ruby-keyword kw">end</span>
+602:           <span class="ruby-identifier">error</span>(<span class="ruby-value str">'spec_token_expctd'</span>, <span class="ruby-identifier">text</span>)
+603:         <span class="ruby-keyword kw">end</span>
+604:         <span class="ruby-comment cmt"># If the element is a variable store the value of the token.</span>
+605:         <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>])
+606:       <span class="ruby-keyword kw">end</span>
+607:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>