taskjuggler 0.0.8 → 0.0.9

data/doc/TaskJuggler/TextParser/Pattern.html

@@ -163,6 +163,8 @@
 				
 					<li><a href="../../TaskJuggler/AttributeDefinition.html">TaskJuggler::AttributeDefinition</a></li>
 				
+					<li><a href="../../TaskJuggler/AttributeOverwrite.html">TaskJuggler::AttributeOverwrite</a></li>
+				
 					<li><a href="../../TaskJuggler/BatchProcessor.html">TaskJuggler::BatchProcessor</a></li>
 				
 					<li><a href="../../TaskJuggler/Booking.html">TaskJuggler::Booking</a></li>
@@ -241,6 +243,8 @@
 				
 					<li><a href="../../TaskJuggler/Interval.html">TaskJuggler::Interval</a></li>
 				
+					<li><a href="../../TaskJuggler/IntervalList.html">TaskJuggler::IntervalList</a></li>
+				
 					<li><a href="../../TaskJuggler/IntervalListAttribute.html">TaskJuggler::IntervalListAttribute</a></li>
 				
 					<li><a href="../../TaskJuggler/JobInfo.html">TaskJuggler::JobInfo</a></li>
@@ -273,6 +277,8 @@
 				
 					<li><a href="../../TaskJuggler/LogicalExpressionAttribute.html">TaskJuggler::LogicalExpressionAttribute</a></li>
 				
+					<li><a href="../../TaskJuggler/LogicalExpressionListAttribute.html">TaskJuggler::LogicalExpressionListAttribute</a></li>
+				
 					<li><a href="../../TaskJuggler/LogicalFlag.html">TaskJuggler::LogicalFlag</a></li>
 				
 					<li><a href="../../TaskJuggler/LogicalFunction.html">TaskJuggler::LogicalFunction</a></li>
@@ -553,6 +559,8 @@
 				
 					<li><a href="../../TaskJuggler/WebServer.html">TaskJuggler::WebServer</a></li>
 				
+					<li><a href="../../TaskJuggler/WelcomePage.html">TaskJuggler::WelcomePage</a></li>
+				
 					<li><a href="../../TaskJuggler/WorkingHours.html">TaskJuggler::WorkingHours</a></li>
 				
 					<li><a href="../../TaskJuggler/WorkingHoursAttribute.html">TaskJuggler::WorkingHoursAttribute</a></li>
@@ -579,8 +587,6 @@
 				
 					<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>
@@ -769,55 +775,55 @@ documentary information about the pattern.
 					<div class="method-source-code"
 						id="new-source">
 <pre>
-    <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 45</span>
-45:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">tokens</span>, <span class="ruby-identifier">function</span> = <span class="ruby-keyword kw">nil</span>)
-46:       <span class="ruby-comment cmt"># A unique name for the pattern that is used in the documentation.</span>
-47:       <span class="ruby-ivar">@keyword</span> = <span class="ruby-keyword kw">nil</span>
-48:       <span class="ruby-comment cmt"># Initialize pattern doc as empty.</span>
-49:       <span class="ruby-ivar">@doc</span> = <span class="ruby-keyword kw">nil</span>
-50:       <span class="ruby-comment cmt"># A list of TokenDoc elements that describe the meaning of variable</span>
-51:       <span class="ruby-comment cmt"># tokens. The order of the tokens and entries in the Array must correlate.</span>
-52:       <span class="ruby-ivar">@args</span> = []
-53:       <span class="ruby-comment cmt"># A list of references to other patterns that are related to this pattern.</span>
-54:       <span class="ruby-ivar">@seeAlso</span> = []
-55:       <span class="ruby-comment cmt"># A reference to a file under test/TestSuite/Syntax/Correct and a tag</span>
-56:       <span class="ruby-comment cmt"># within that file. This identifies example TJP code to be included with</span>
-57:       <span class="ruby-comment cmt"># the reference manual.</span>
-58:       <span class="ruby-ivar">@exampleFile</span> = <span class="ruby-keyword kw">nil</span>
-59:       <span class="ruby-ivar">@exampleTag</span> = <span class="ruby-keyword kw">nil</span>
-60: 
-61:       <span class="ruby-ivar">@tokens</span> = []
-62:       <span class="ruby-identifier">tokens</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>
-63:         <span class="ruby-keyword kw">unless</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>])
-64:           <span class="ruby-identifier">raise</span> <span class="ruby-value str">&quot;Fatal Error: All pattern tokens must start with a type &quot;</span> <span class="ruby-operator">+</span>
-65:                 <span class="ruby-node">&quot;identifier [!$_.]: #{tokens.join(', ')}&quot;</span>
-66:         <span class="ruby-keyword kw">end</span>
-67:         <span class="ruby-comment cmt"># For the syntax specification using a prefix character is more</span>
-68:         <span class="ruby-comment cmt"># convenient. But for further processing, we need to split the string</span>
-69:         <span class="ruby-comment cmt"># into two symbols. The prefix determines the token type, the rest is</span>
-70:         <span class="ruby-comment cmt"># the token name. There are 4 types of tokens:</span>
-71:         <span class="ruby-comment cmt"># :reference : a reference to another rule</span>
-72:         <span class="ruby-comment cmt"># :variable : a terminal symbol</span>
-73:         <span class="ruby-comment cmt"># :literal : a user defined string</span>
-74:         <span class="ruby-comment cmt"># :eof : marks the end of an input stream</span>
-75:         <span class="ruby-identifier">type</span> = [ <span class="ruby-value">:reference</span>, <span class="ruby-value">:variable</span>, <span class="ruby-value">:literal</span>, <span class="ruby-value">:eof</span> ][<span class="ruby-value str">'!$_.'</span>.<span class="ruby-identifier">index</span>(<span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>])]
-76:         <span class="ruby-comment cmt"># For literals we use a String to store the token content. For others,</span>
-77:         <span class="ruby-comment cmt"># a symbol is better suited.</span>
-78:         <span class="ruby-identifier">name</span> = <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:literal</span> <span class="ruby-operator">?</span>
-79:                <span class="ruby-identifier">token</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>] <span class="ruby-operator">:</span> (<span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:eof</span> <span class="ruby-operator">?</span> <span class="ruby-value str">'&lt;END&gt;'</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>].<span class="ruby-identifier">intern</span>)
-80:         <span class="ruby-comment cmt"># We favor an Array to store the 2 elements over a Hash for</span>
-81:         <span class="ruby-comment cmt"># performance reasons.</span>
-82:         <span class="ruby-ivar">@tokens</span> <span class="ruby-operator">&lt;&lt;</span> [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span> ]
-83:         <span class="ruby-comment cmt"># Initialize pattern argument descriptions as empty.</span>
-84:         <span class="ruby-ivar">@args</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-keyword kw">nil</span>
-85:       <span class="ruby-keyword kw">end</span>
-86:       <span class="ruby-ivar">@function</span> = <span class="ruby-identifier">function</span>
-87:       <span class="ruby-comment cmt"># In some cases we don't want to show all tokens in the syntax</span>
-88:       <span class="ruby-comment cmt"># documentation. This value specifies the index of the last shown token.</span>
-89:       <span class="ruby-ivar">@lastSyntaxToken</span> = <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>
-90: 
-91:       <span class="ruby-ivar">@transitions</span> = []
-92:     <span class="ruby-keyword kw">end</span></pre>
+    <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 46</span>
+46:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">tokens</span>, <span class="ruby-identifier">function</span> = <span class="ruby-keyword kw">nil</span>)
+47:       <span class="ruby-comment cmt"># A unique name for the pattern that is used in the documentation.</span>
+48:       <span class="ruby-ivar">@keyword</span> = <span class="ruby-keyword kw">nil</span>
+49:       <span class="ruby-comment cmt"># Initialize pattern doc as empty.</span>
+50:       <span class="ruby-ivar">@doc</span> = <span class="ruby-keyword kw">nil</span>
+51:       <span class="ruby-comment cmt"># A list of TokenDoc elements that describe the meaning of variable</span>
+52:       <span class="ruby-comment cmt"># tokens. The order of the tokens and entries in the Array must correlate.</span>
+53:       <span class="ruby-ivar">@args</span> = []
+54:       <span class="ruby-comment cmt"># A list of references to other patterns that are related to this pattern.</span>
+55:       <span class="ruby-ivar">@seeAlso</span> = []
+56:       <span class="ruby-comment cmt"># A reference to a file under test/TestSuite/Syntax/Correct and a tag</span>
+57:       <span class="ruby-comment cmt"># within that file. This identifies example TJP code to be included with</span>
+58:       <span class="ruby-comment cmt"># the reference manual.</span>
+59:       <span class="ruby-ivar">@exampleFile</span> = <span class="ruby-keyword kw">nil</span>
+60:       <span class="ruby-ivar">@exampleTag</span> = <span class="ruby-keyword kw">nil</span>
+61: 
+62:       <span class="ruby-ivar">@tokens</span> = []
+63:       <span class="ruby-identifier">tokens</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>
+64:         <span class="ruby-keyword kw">unless</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>])
+65:           <span class="ruby-identifier">raise</span> <span class="ruby-value str">&quot;Fatal Error: All pattern tokens must start with a type &quot;</span> <span class="ruby-operator">+</span>
+66:                 <span class="ruby-node">&quot;identifier [!$_.]: #{tokens.join(', ')}&quot;</span>
+67:         <span class="ruby-keyword kw">end</span>
+68:         <span class="ruby-comment cmt"># For the syntax specification using a prefix character is more</span>
+69:         <span class="ruby-comment cmt"># convenient. But for further processing, we need to split the string</span>
+70:         <span class="ruby-comment cmt"># into two symbols. The prefix determines the token type, the rest is</span>
+71:         <span class="ruby-comment cmt"># the token name. There are 4 types of tokens:</span>
+72:         <span class="ruby-comment cmt"># :reference : a reference to another rule</span>
+73:         <span class="ruby-comment cmt"># :variable : a terminal symbol</span>
+74:         <span class="ruby-comment cmt"># :literal : a user defined string</span>
+75:         <span class="ruby-comment cmt"># :eof : marks the end of an input stream</span>
+76:         <span class="ruby-identifier">type</span> = [ <span class="ruby-value">:reference</span>, <span class="ruby-value">:variable</span>, <span class="ruby-value">:literal</span>, <span class="ruby-value">:eof</span> ][<span class="ruby-value str">'!$_.'</span>.<span class="ruby-identifier">index</span>(<span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>])]
+77:         <span class="ruby-comment cmt"># For literals we use a String to store the token content. For others,</span>
+78:         <span class="ruby-comment cmt"># a symbol is better suited.</span>
+79:         <span class="ruby-identifier">name</span> = <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:literal</span> <span class="ruby-operator">?</span>
+80:                <span class="ruby-identifier">token</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>] <span class="ruby-operator">:</span> (<span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:eof</span> <span class="ruby-operator">?</span> <span class="ruby-value str">'&lt;END&gt;'</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>].<span class="ruby-identifier">intern</span>)
+81:         <span class="ruby-comment cmt"># We favor an Array to store the 2 elements over a Hash for</span>
+82:         <span class="ruby-comment cmt"># performance reasons.</span>
+83:         <span class="ruby-ivar">@tokens</span> <span class="ruby-operator">&lt;&lt;</span> [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span> ]
+84:         <span class="ruby-comment cmt"># Initialize pattern argument descriptions as empty.</span>
+85:         <span class="ruby-ivar">@args</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-keyword kw">nil</span>
+86:       <span class="ruby-keyword kw">end</span>
+87:       <span class="ruby-ivar">@function</span> = <span class="ruby-identifier">function</span>
+88:       <span class="ruby-comment cmt"># In some cases we don't want to show all tokens in the syntax</span>
+89:       <span class="ruby-comment cmt"># documentation. This value specifies the index of the last shown token.</span>
+90:       <span class="ruby-ivar">@lastSyntaxToken</span> = <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>
+91: 
+92:       <span class="ruby-ivar">@transitions</span> = []
+93:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -856,10 +862,10 @@ Conveniance function to access individual tokens by index.
 					<div class="method-source-code"
 						id="--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 210</span>
-210:     <span class="ruby-keyword kw">def</span> <span class="ruby-operator">[]</span>(<span class="ruby-identifier">i</span>)
-211:       <span class="ruby-ivar">@tokens</span>[<span class="ruby-identifier">i</span>]
-212:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 211</span>
+211:     <span class="ruby-keyword kw">def</span> <span class="ruby-operator">[]</span>(<span class="ruby-identifier">i</span>)
+212:       <span class="ruby-ivar">@tokens</span>[<span class="ruby-identifier">i</span>]
+213:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -902,77 +908,77 @@ the start of the <a href="Rule.html">Rule</a>.
 					<div class="method-source-code"
 						id="add-ransitions-o-tate-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 111</span>
-111:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">addTransitionsToState</span>(<span class="ruby-identifier">states</span>, <span class="ruby-identifier">rules</span>, <span class="ruby-identifier">stateStack</span>, <span class="ruby-identifier">sourceState</span>,
-112:                               <span class="ruby-identifier">destRule</span>, <span class="ruby-identifier">destIndex</span>, <span class="ruby-identifier">loopBack</span>)
-113:       <span class="ruby-comment cmt"># If we hit a token in the pattern that is optional, we need to consider</span>
-114:       <span class="ruby-comment cmt"># the next token of the pattern as well.</span>
-115:       <span class="ruby-identifier">loop</span> <span class="ruby-keyword kw">do</span>
-116:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">destIndex</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">length</span>
-117:           <span class="ruby-comment cmt"># Have we reached the end of the pattern? Such state always trigger</span>
-118:           <span class="ruby-comment cmt"># a reduce operation.</span>
-119:           <span class="ruby-identifier">sourceState</span>.<span class="ruby-identifier">noReduce</span> = <span class="ruby-keyword kw">false</span>
-120:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">sourceState</span>.<span class="ruby-identifier">rule</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">destRule</span>
-121:             <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">destRule</span>.<span class="ruby-identifier">repeatable</span>
-122:               <span class="ruby-comment cmt"># The transition leads us back to the start of the Rule. This</span>
-123:               <span class="ruby-comment cmt"># will generate transitions to the first token of all patterns</span>
-124:               <span class="ruby-comment cmt"># of this Rule.</span>
-125:               <span class="ruby-identifier">destRule</span>.<span class="ruby-identifier">addTransitionsToState</span>(<span class="ruby-identifier">states</span>, <span class="ruby-identifier">rules</span>, [], <span class="ruby-identifier">sourceState</span>,
-126:                                              <span class="ruby-keyword kw">true</span>)
-127:             <span class="ruby-keyword kw">end</span>
-128:           <span class="ruby-keyword kw">end</span>
-129:           <span class="ruby-comment cmt"># We've reached the end of the pattern. No more transitions to</span>
-130:           <span class="ruby-comment cmt"># consider.</span>
-131:           <span class="ruby-keyword kw">return</span>
-132:         <span class="ruby-keyword kw">end</span>
-133: 
-134:         <span class="ruby-comment cmt"># The token descriptor tells us where the transition(s) need to go to.</span>
-135:         <span class="ruby-identifier">tokenType</span>, <span class="ruby-identifier">tokenName</span> = <span class="ruby-identifier">token</span> = <span class="ruby-ivar">@tokens</span>[<span class="ruby-identifier">destIndex</span>]
-136: 
-137:         <span class="ruby-keyword kw">case</span> <span class="ruby-identifier">tokenType</span>
-138:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:reference</span>
-139:           <span class="ruby-comment cmt"># The descriptor references another rule.</span>
-140:           <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">refRule</span> = <span class="ruby-identifier">rules</span>[<span class="ruby-identifier">tokenName</span>])
-141:             <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Unknown rule #{tokenName} referenced in rule #{refRule.name}&quot;</span>
-142:           <span class="ruby-keyword kw">end</span>
-143:           <span class="ruby-comment cmt"># If we reference another rule from a pattern, we need to come back</span>
-144:           <span class="ruby-comment cmt"># to the pattern once we are done with the referenced rule. To be</span>
-145:           <span class="ruby-comment cmt"># able to come back, we collect a list of all the States that we</span>
-146:           <span class="ruby-comment cmt"># have passed during a reference resolution. This list forms a stack</span>
-147:           <span class="ruby-comment cmt"># that is popped during recude operations of the parser FSM.</span>
-148:           <span class="ruby-identifier">skippedState</span> = <span class="ruby-identifier">states</span>[[ <span class="ruby-identifier">destRule</span>, <span class="ruby-keyword kw">self</span>, <span class="ruby-identifier">destIndex</span> ]]
-149:           <span class="ruby-comment cmt"># Rules may reference themselves directly or indirectly. To avoid</span>
-150:           <span class="ruby-comment cmt"># endless recursions of this algorithm, we stop once we have</span>
-151:           <span class="ruby-comment cmt"># detected a recursion. We have already all necessary transitions</span>
-152:           <span class="ruby-comment cmt"># collected. The recursion will be unrolled in the parser FSM.</span>
-153:           <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">stateStack</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">skippedState</span>)
-154:             <span class="ruby-comment cmt"># Push the skipped state on the stateStack before recursing.</span>
-155:             <span class="ruby-identifier">stateStack</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">skippedState</span>)
-156:             <span class="ruby-identifier">refRule</span>.<span class="ruby-identifier">addTransitionsToState</span>(<span class="ruby-identifier">states</span>, <span class="ruby-identifier">rules</span>, <span class="ruby-identifier">stateStack</span>,
-157:                                           <span class="ruby-identifier">sourceState</span>, <span class="ruby-identifier">loopBack</span>)
-158:             <span class="ruby-comment cmt"># Once we're done, remove the State from the stateStack again.</span>
-159:             <span class="ruby-identifier">stateStack</span>.<span class="ruby-identifier">pop</span>
-160:           <span class="ruby-keyword kw">end</span>
-161: 
-162:           <span class="ruby-comment cmt"># If the referenced rule is not optional, we have no further</span>
-163:           <span class="ruby-comment cmt"># transitions for this pattern at this destIndex.</span>
-164:           <span class="ruby-keyword kw">break</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">refRule</span>.<span class="ruby-identifier">optional?</span>(<span class="ruby-identifier">rules</span>)
-165:         <span class="ruby-keyword kw">else</span>
-166:           <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">destState</span> = <span class="ruby-identifier">states</span>[[ <span class="ruby-identifier">destRule</span>, <span class="ruby-keyword kw">self</span>, <span class="ruby-identifier">destIndex</span> ]])
-167:             <span class="ruby-identifier">raise</span> <span class="ruby-value str">&quot;Destination state not found&quot;</span>
-168:           <span class="ruby-keyword kw">end</span>
-169:           <span class="ruby-comment cmt"># We've found a transition to a terminal token. Add the transition</span>
-170:           <span class="ruby-comment cmt"># to the source State.</span>
-171:           <span class="ruby-identifier">sourceState</span>.<span class="ruby-identifier">addTransition</span>(<span class="ruby-ivar">@tokens</span>[<span class="ruby-identifier">destIndex</span>], <span class="ruby-identifier">destState</span>, <span class="ruby-identifier">stateStack</span>,
-172:                                     <span class="ruby-identifier">loopBack</span>)
-173:           <span class="ruby-comment cmt"># Fixed tokens are never optional. There are no more transitions for</span>
-174:           <span class="ruby-comment cmt"># this pattern at this index.</span>
-175:           <span class="ruby-keyword kw">break</span>
-176:         <span class="ruby-keyword kw">end</span>
-177: 
-178:         <span class="ruby-identifier">destIndex</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
-179:       <span class="ruby-keyword kw">end</span>
-180:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 112</span>
+112:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">addTransitionsToState</span>(<span class="ruby-identifier">states</span>, <span class="ruby-identifier">rules</span>, <span class="ruby-identifier">stateStack</span>, <span class="ruby-identifier">sourceState</span>,
+113:                               <span class="ruby-identifier">destRule</span>, <span class="ruby-identifier">destIndex</span>, <span class="ruby-identifier">loopBack</span>)
+114:       <span class="ruby-comment cmt"># If we hit a token in the pattern that is optional, we need to consider</span>
+115:       <span class="ruby-comment cmt"># the next token of the pattern as well.</span>
+116:       <span class="ruby-identifier">loop</span> <span class="ruby-keyword kw">do</span>
+117:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">destIndex</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">length</span>
+118:           <span class="ruby-comment cmt"># Have we reached the end of the pattern? Such state always trigger</span>
+119:           <span class="ruby-comment cmt"># a reduce operation.</span>
+120:           <span class="ruby-identifier">sourceState</span>.<span class="ruby-identifier">noReduce</span> = <span class="ruby-keyword kw">false</span>
+121:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">sourceState</span>.<span class="ruby-identifier">rule</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">destRule</span>
+122:             <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">destRule</span>.<span class="ruby-identifier">repeatable</span>
+123:               <span class="ruby-comment cmt"># The transition leads us back to the start of the Rule. This</span>
+124:               <span class="ruby-comment cmt"># will generate transitions to the first token of all patterns</span>
+125:               <span class="ruby-comment cmt"># of this Rule.</span>
+126:               <span class="ruby-identifier">destRule</span>.<span class="ruby-identifier">addTransitionsToState</span>(<span class="ruby-identifier">states</span>, <span class="ruby-identifier">rules</span>, [], <span class="ruby-identifier">sourceState</span>,
+127:                                              <span class="ruby-keyword kw">true</span>)
+128:             <span class="ruby-keyword kw">end</span>
+129:           <span class="ruby-keyword kw">end</span>
+130:           <span class="ruby-comment cmt"># We've reached the end of the pattern. No more transitions to</span>
+131:           <span class="ruby-comment cmt"># consider.</span>
+132:           <span class="ruby-keyword kw">return</span>
+133:         <span class="ruby-keyword kw">end</span>
+134: 
+135:         <span class="ruby-comment cmt"># The token descriptor tells us where the transition(s) need to go to.</span>
+136:         <span class="ruby-identifier">tokenType</span>, <span class="ruby-identifier">tokenName</span> = <span class="ruby-identifier">token</span> = <span class="ruby-ivar">@tokens</span>[<span class="ruby-identifier">destIndex</span>]
+137: 
+138:         <span class="ruby-keyword kw">case</span> <span class="ruby-identifier">tokenType</span>
+139:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:reference</span>
+140:           <span class="ruby-comment cmt"># The descriptor references another rule.</span>
+141:           <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">refRule</span> = <span class="ruby-identifier">rules</span>[<span class="ruby-identifier">tokenName</span>])
+142:             <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Unknown rule #{tokenName} referenced in rule #{refRule.name}&quot;</span>
+143:           <span class="ruby-keyword kw">end</span>
+144:           <span class="ruby-comment cmt"># If we reference another rule from a pattern, we need to come back</span>
+145:           <span class="ruby-comment cmt"># to the pattern once we are done with the referenced rule. To be</span>
+146:           <span class="ruby-comment cmt"># able to come back, we collect a list of all the States that we</span>
+147:           <span class="ruby-comment cmt"># have passed during a reference resolution. This list forms a stack</span>
+148:           <span class="ruby-comment cmt"># that is popped during recude operations of the parser FSM.</span>
+149:           <span class="ruby-identifier">skippedState</span> = <span class="ruby-identifier">states</span>[[ <span class="ruby-identifier">destRule</span>, <span class="ruby-keyword kw">self</span>, <span class="ruby-identifier">destIndex</span> ]]
+150:           <span class="ruby-comment cmt"># Rules may reference themselves directly or indirectly. To avoid</span>
+151:           <span class="ruby-comment cmt"># endless recursions of this algorithm, we stop once we have</span>
+152:           <span class="ruby-comment cmt"># detected a recursion. We have already all necessary transitions</span>
+153:           <span class="ruby-comment cmt"># collected. The recursion will be unrolled in the parser FSM.</span>
+154:           <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">stateStack</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">skippedState</span>)
+155:             <span class="ruby-comment cmt"># Push the skipped state on the stateStack before recursing.</span>
+156:             <span class="ruby-identifier">stateStack</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">skippedState</span>)
+157:             <span class="ruby-identifier">refRule</span>.<span class="ruby-identifier">addTransitionsToState</span>(<span class="ruby-identifier">states</span>, <span class="ruby-identifier">rules</span>, <span class="ruby-identifier">stateStack</span>,
+158:                                           <span class="ruby-identifier">sourceState</span>, <span class="ruby-identifier">loopBack</span>)
+159:             <span class="ruby-comment cmt"># Once we're done, remove the State from the stateStack again.</span>
+160:             <span class="ruby-identifier">stateStack</span>.<span class="ruby-identifier">pop</span>
+161:           <span class="ruby-keyword kw">end</span>
+162: 
+163:           <span class="ruby-comment cmt"># If the referenced rule is not optional, we have no further</span>
+164:           <span class="ruby-comment cmt"># transitions for this pattern at this destIndex.</span>
+165:           <span class="ruby-keyword kw">break</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">refRule</span>.<span class="ruby-identifier">optional?</span>(<span class="ruby-identifier">rules</span>)
+166:         <span class="ruby-keyword kw">else</span>
+167:           <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">destState</span> = <span class="ruby-identifier">states</span>[[ <span class="ruby-identifier">destRule</span>, <span class="ruby-keyword kw">self</span>, <span class="ruby-identifier">destIndex</span> ]])
+168:             <span class="ruby-identifier">raise</span> <span class="ruby-value str">&quot;Destination state not found&quot;</span>
+169:           <span class="ruby-keyword kw">end</span>
+170:           <span class="ruby-comment cmt"># We've found a transition to a terminal token. Add the transition</span>
+171:           <span class="ruby-comment cmt"># to the source State.</span>
+172:           <span class="ruby-identifier">sourceState</span>.<span class="ruby-identifier">addTransition</span>(<span class="ruby-ivar">@tokens</span>[<span class="ruby-identifier">destIndex</span>], <span class="ruby-identifier">destState</span>, <span class="ruby-identifier">stateStack</span>,
+173:                                     <span class="ruby-identifier">loopBack</span>)
+174:           <span class="ruby-comment cmt"># Fixed tokens are never optional. There are no more transitions for</span>
+175:           <span class="ruby-comment cmt"># this pattern at this index.</span>
+176:           <span class="ruby-keyword kw">break</span>
+177:         <span class="ruby-keyword kw">end</span>
+178: 
+179:         <span class="ruby-identifier">destIndex</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
+180:       <span class="ruby-keyword kw">end</span>
+181:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1005,10 +1011,10 @@ Iterator for tokens.
 					<div class="method-source-code"
 						id="each-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 215</span>
-215:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">each</span>
-216:       <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span><span class="ruby-operator">|</span> <span class="ruby-keyword kw">yield</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span>) }
-217:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 216</span>
+216:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">each</span>
+217:       <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span><span class="ruby-operator">|</span> <span class="ruby-keyword kw">yield</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span>) }
+218:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1041,10 +1047,10 @@ Returns true of the pattern is empty.
 					<div class="method-source-code"
 						id="empty--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 220</span>
-220:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">empty?</span>
-221:       <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">empty?</span>
-222:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 221</span>
+221:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">empty?</span>
+222:       <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">empty?</span>
+223:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1079,12 +1085,12 @@ href="Rule.html">Rule</a> that the pattern belongs to. A list of generated
 					<div class="method-source-code"
 						id="generate-tates-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 97</span>
- 97:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">generateStates</span>(<span class="ruby-identifier">rule</span>)
- 98:       <span class="ruby-identifier">states</span> = []
- 99:       <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">length</span>.<span class="ruby-identifier">times</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span> <span class="ruby-identifier">states</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-constant">State</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">rule</span>, <span class="ruby-keyword kw">self</span>, <span class="ruby-identifier">i</span>) }
-100:       <span class="ruby-identifier">states</span>
-101:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 98</span>
+ 98:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">generateStates</span>(<span class="ruby-identifier">rule</span>)
+ 99:       <span class="ruby-identifier">states</span> = []
+100:       <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">length</span>.<span class="ruby-identifier">times</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span> <span class="ruby-identifier">states</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-constant">State</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">rule</span>, <span class="ruby-keyword kw">self</span>, <span class="ruby-identifier">i</span>) }
+101:       <span class="ruby-identifier">states</span>
+102:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1117,10 +1123,10 @@ Returns the number of tokens in the pattern.
 					<div class="method-source-code"
 						id="length-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 225</span>
-225:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">length</span>
-226:       <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">length</span>
-227:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 226</span>
+226:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">length</span>
+227:       <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">length</span>
+228:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1154,19 +1160,19 @@ references a rule, this rule is followed for the check.
 					<div class="method-source-code"
 						id="optional--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 231</span>
-231:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">optional?</span>(<span class="ruby-identifier">rules</span>)
-232:       <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span><span class="ruby-operator">|</span>
-233:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:literal</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:variable</span>
-234:           <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">false</span>
-235:         <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:reference</span>
-236:           <span class="ruby-keyword kw">if</span> <span class="ruby-operator">!</span><span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">optional?</span>(<span class="ruby-identifier">rules</span>)
-237:             <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">false</span>
-238:           <span class="ruby-keyword kw">end</span>
-239:         <span class="ruby-keyword kw">end</span>
-240:       <span class="ruby-keyword kw">end</span>
-241:       <span class="ruby-keyword kw">true</span>
-242:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 232</span>
+232:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">optional?</span>(<span class="ruby-identifier">rules</span>)
+233:       <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span><span class="ruby-operator">|</span>
+234:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:literal</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:variable</span>
+235:           <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">false</span>
+236:         <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:reference</span>
+237:           <span class="ruby-keyword kw">if</span> <span class="ruby-operator">!</span><span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">optional?</span>(<span class="ruby-identifier">rules</span>)
+238:             <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">false</span>
+239:           <span class="ruby-keyword kw">end</span>
+240:         <span class="ruby-keyword kw">end</span>
+241:       <span class="ruby-keyword kw">end</span>
+242:       <span class="ruby-keyword kw">true</span>
+243:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1199,10 +1205,10 @@ Set the documentation text and for the idx-th variable.
 					<div class="method-source-code"
 						id="set-rg-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 189</span>
-189:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">setArg</span>(<span class="ruby-identifier">idx</span>, <span class="ruby-identifier">doc</span>)
-190:       <span class="ruby-ivar">@args</span>[<span class="ruby-identifier">idx</span>] = <span class="ruby-identifier">doc</span>
-191:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 190</span>
+190:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">setArg</span>(<span class="ruby-identifier">idx</span>, <span class="ruby-identifier">doc</span>)
+191:       <span class="ruby-ivar">@args</span>[<span class="ruby-identifier">idx</span>] = <span class="ruby-identifier">doc</span>
+192:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1235,11 +1241,11 @@ Set the keyword and documentation text for the pattern.
 					<div class="method-source-code"
 						id="set-oc-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 183</span>
-183:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">setDoc</span>(<span class="ruby-identifier">keyword</span>, <span class="ruby-identifier">doc</span>)
-184:       <span class="ruby-ivar">@keyword</span> = <span class="ruby-identifier">keyword</span>
-185:       <span class="ruby-ivar">@doc</span> = <span class="ruby-identifier">doc</span>
-186:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 184</span>
+184:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">setDoc</span>(<span class="ruby-identifier">keyword</span>, <span class="ruby-identifier">doc</span>)
+185:       <span class="ruby-ivar">@keyword</span> = <span class="ruby-identifier">keyword</span>
+186:       <span class="ruby-ivar">@doc</span> = <span class="ruby-identifier">doc</span>
+187:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1272,11 +1278,11 @@ Set the file and tag for the TJP code example.
 					<div class="method-source-code"
 						id="set-xample-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 204</span>
-204:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">setExample</span>(<span class="ruby-identifier">file</span>, <span class="ruby-identifier">tag</span>)
-205:       <span class="ruby-ivar">@exampleFile</span> = <span class="ruby-identifier">file</span>
-206:       <span class="ruby-ivar">@exampleTag</span> = <span class="ruby-identifier">tag</span>
-207:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 205</span>
+205:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">setExample</span>(<span class="ruby-identifier">file</span>, <span class="ruby-identifier">tag</span>)
+206:       <span class="ruby-ivar">@exampleFile</span> = <span class="ruby-identifier">file</span>
+207:       <span class="ruby-ivar">@exampleTag</span> = <span class="ruby-identifier">tag</span>
+208:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1309,10 +1315,10 @@ Restrict the syntax documentation to the first <tt>idx</tt> tokens.
 					<div class="method-source-code"
 						id="set-ast-yntax-oken-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 194</span>
-194:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">setLastSyntaxToken</span>(<span class="ruby-identifier">idx</span>)
-195:       <span class="ruby-ivar">@lastSyntaxToken</span> = <span class="ruby-identifier">idx</span>
-196:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 195</span>
+195:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">setLastSyntaxToken</span>(<span class="ruby-identifier">idx</span>)
+196:       <span class="ruby-ivar">@lastSyntaxToken</span> = <span class="ruby-identifier">idx</span>
+197:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1345,10 +1351,10 @@ Set the references to related patterns.
 					<div class="method-source-code"
 						id="set-ee-lso-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 199</span>
-199:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">setSeeAlso</span>(<span class="ruby-identifier">also</span>)
-200:       <span class="ruby-ivar">@seeAlso</span> = <span class="ruby-identifier">also</span>
-201:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 200</span>
+200:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">setSeeAlso</span>(<span class="ruby-identifier">also</span>)
+201:       <span class="ruby-ivar">@seeAlso</span> = <span class="ruby-identifier">also</span>
+202:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1381,10 +1387,10 @@ Returns true if the i-th token is a terminal symbol.
 					<div class="method-source-code"
 						id="terminal-ymbol--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 245</span>
-245:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">terminalSymbol?</span>(<span class="ruby-identifier">i</span>)
-246:       <span class="ruby-ivar">@tokens</span>[<span class="ruby-identifier">i</span>][<span class="ruby-value">0</span>] <span class="ruby-operator">==</span> <span class="ruby-value">:variable</span> <span class="ruby-operator">||</span> <span class="ruby-ivar">@tokens</span>[<span class="ruby-identifier">i</span>][<span class="ruby-value">0</span>] <span class="ruby-operator">==</span> <span class="ruby-value">:literal</span>
-247:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 246</span>
+246:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">terminalSymbol?</span>(<span class="ruby-identifier">i</span>)
+247:       <span class="ruby-ivar">@tokens</span>[<span class="ruby-identifier">i</span>][<span class="ruby-value">0</span>] <span class="ruby-operator">==</span> <span class="ruby-value">:variable</span> <span class="ruby-operator">||</span> <span class="ruby-ivar">@tokens</span>[<span class="ruby-identifier">i</span>][<span class="ruby-value">0</span>] <span class="ruby-operator">==</span> <span class="ruby-value">:literal</span>
+248:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1419,26 +1425,26 @@ The return value is an Array of [ token, pattern ] tuple.
 					<div class="method-source-code"
 						id="terminal-okens-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 252</span>
-252:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">terminalTokens</span>(<span class="ruby-identifier">rules</span>, <span class="ruby-identifier">index</span> = <span class="ruby-value">0</span>)
-253:       <span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span> = <span class="ruby-ivar">@tokens</span>[<span class="ruby-identifier">index</span>]
-254:       <span class="ruby-comment cmt"># Terminal token start with an underscore or dollar character.</span>
-255:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:literal</span>
-256:         <span class="ruby-keyword kw">return</span> [ [ <span class="ruby-identifier">name</span>, <span class="ruby-keyword kw">self</span> ] ]
-257:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:variable</span>
-258:         <span class="ruby-keyword kw">return</span> []
-259:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:reference</span>
-260:         <span class="ruby-comment cmt"># We have to continue the search at this rule.</span>
-261:         <span class="ruby-identifier">rule</span> = <span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>]
-262:         <span class="ruby-comment cmt"># The rule may only have a single pattern. If not, then this pattern</span>
-263:         <span class="ruby-comment cmt"># has no terminal token.</span>
-264:         <span class="ruby-identifier">tts</span> = []
-265:         <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">patterns</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">p</span><span class="ruby-operator">|</span> <span class="ruby-identifier">tts</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">p</span>.<span class="ruby-identifier">terminalTokens</span>(<span class="ruby-identifier">rules</span>, <span class="ruby-value">0</span>) }
-266:         <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">tts</span>
-267:       <span class="ruby-keyword kw">else</span>
-268:         <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Unexpected token #{type} #{name}&quot;</span>
-269:       <span class="ruby-keyword kw">end</span>
-270:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 253</span>
+253:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">terminalTokens</span>(<span class="ruby-identifier">rules</span>, <span class="ruby-identifier">index</span> = <span class="ruby-value">0</span>)
+254:       <span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span> = <span class="ruby-ivar">@tokens</span>[<span class="ruby-identifier">index</span>]
+255:       <span class="ruby-comment cmt"># Terminal token start with an underscore or dollar character.</span>
+256:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:literal</span>
+257:         <span class="ruby-keyword kw">return</span> [ [ <span class="ruby-identifier">name</span>, <span class="ruby-keyword kw">self</span> ] ]
+258:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:variable</span>
+259:         <span class="ruby-keyword kw">return</span> []
+260:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:reference</span>
+261:         <span class="ruby-comment cmt"># We have to continue the search at this rule.</span>
+262:         <span class="ruby-identifier">rule</span> = <span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>]
+263:         <span class="ruby-comment cmt"># The rule may only have a single pattern. If not, then this pattern</span>
+264:         <span class="ruby-comment cmt"># has no terminal token.</span>
+265:         <span class="ruby-identifier">tts</span> = []
+266:         <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">patterns</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">p</span><span class="ruby-operator">|</span> <span class="ruby-identifier">tts</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">p</span>.<span class="ruby-identifier">terminalTokens</span>(<span class="ruby-identifier">rules</span>, <span class="ruby-value">0</span>) }
+267:         <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">tts</span>
+268:       <span class="ruby-keyword kw">else</span>
+269:         <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Unexpected token #{type} #{name}&quot;</span>
+270:       <span class="ruby-keyword kw">end</span>
+271:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1472,26 +1478,26 @@ original syntax description.
 					<div class="method-source-code"
 						id="to-s-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 354</span>
-354:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_s</span>
-355:       <span class="ruby-identifier">str</span> = <span class="ruby-value str">&quot;&quot;</span>
-356:       <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span><span class="ruby-operator">|</span>
-357:         <span class="ruby-keyword kw">case</span> <span class="ruby-identifier">type</span>
-358:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:reference</span>
-359:           <span class="ruby-identifier">str</span> <span class="ruby-operator">+=</span> <span class="ruby-node">&quot;!#{name} &quot;</span>
-360:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:variable</span>
-361:           <span class="ruby-identifier">str</span> <span class="ruby-operator">+=</span> <span class="ruby-node">&quot;$#{name } &quot;</span>
-362:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:literal</span>
-363:           <span class="ruby-identifier">str</span> <span class="ruby-operator">+=</span> <span class="ruby-node">&quot;#{name} &quot;</span>
-364:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:eof</span>
-365:           <span class="ruby-identifier">str</span> <span class="ruby-operator">+=</span> <span class="ruby-value str">&quot;. &quot;</span>
-366:         <span class="ruby-keyword kw">else</span>
-367:           <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Unknown type #{type}&quot;</span>
-368:         <span class="ruby-keyword kw">end</span>
-369:       <span class="ruby-keyword kw">end</span>
-370: 
-371:       <span class="ruby-identifier">str</span>
-372:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 355</span>
+355:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_s</span>
+356:       <span class="ruby-identifier">str</span> = <span class="ruby-value str">&quot;&quot;</span>
+357:       <span class="ruby-ivar">@tokens</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span><span class="ruby-operator">|</span>
+358:         <span class="ruby-keyword kw">case</span> <span class="ruby-identifier">type</span>
+359:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:reference</span>
+360:           <span class="ruby-identifier">str</span> <span class="ruby-operator">+=</span> <span class="ruby-node">&quot;!#{name} &quot;</span>
+361:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:variable</span>
+362:           <span class="ruby-identifier">str</span> <span class="ruby-operator">+=</span> <span class="ruby-node">&quot;$#{name } &quot;</span>
+363:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:literal</span>
+364:           <span class="ruby-identifier">str</span> <span class="ruby-operator">+=</span> <span class="ruby-node">&quot;#{name} &quot;</span>
+365:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:eof</span>
+366:           <span class="ruby-identifier">str</span> <span class="ruby-operator">+=</span> <span class="ruby-value str">&quot;. &quot;</span>
+367:         <span class="ruby-keyword kw">else</span>
+368:           <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Unknown type #{type}&quot;</span>
+369:         <span class="ruby-keyword kw">end</span>
+370:       <span class="ruby-keyword kw">end</span>
+371: 
+372:       <span class="ruby-identifier">str</span>
+373:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1526,10 +1532,10 @@ the wrapper function that sets up the stack.
 					<div class="method-source-code"
 						id="to-syntax-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 275</span>
-275:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_syntax</span>(<span class="ruby-identifier">argDocs</span>, <span class="ruby-identifier">rules</span>, <span class="ruby-identifier">skip</span> = <span class="ruby-value">0</span>)
-276:       <span class="ruby-identifier">to_syntax_r</span>({}, <span class="ruby-identifier">argDocs</span>, <span class="ruby-identifier">rules</span>, <span class="ruby-identifier">skip</span>)
-277:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 276</span>
+276:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_syntax</span>(<span class="ruby-identifier">argDocs</span>, <span class="ruby-identifier">rules</span>, <span class="ruby-identifier">skip</span> = <span class="ruby-value">0</span>)
+277:       <span class="ruby-identifier">to_syntax_r</span>({}, <span class="ruby-identifier">argDocs</span>, <span class="ruby-identifier">rules</span>, <span class="ruby-identifier">skip</span>)
+278:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1562,78 +1568,78 @@ Generate a syntax description for this pattern.
 					<div class="method-source-code"
 						id="to-syntax-r-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 280</span>
-280:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_syntax_r</span>(<span class="ruby-identifier">stack</span>, <span class="ruby-identifier">argDocs</span>, <span class="ruby-identifier">rules</span>, <span class="ruby-identifier">skip</span>)
-281:       <span class="ruby-comment cmt"># If we find ourself on the stack we hit a recursive pattern. This is used</span>
-282:       <span class="ruby-comment cmt"># in repetitions.</span>
-283:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">stack</span>[<span class="ruby-keyword kw">self</span>]
-284:         <span class="ruby-keyword kw">return</span> <span class="ruby-value str">'[, ... ]'</span>
-285:       <span class="ruby-keyword kw">end</span>
-286: 
-287:       <span class="ruby-comment cmt"># &quot;Push&quot; us on the stack.</span>
-288:       <span class="ruby-identifier">stack</span>[<span class="ruby-keyword kw">self</span>] = <span class="ruby-keyword kw">true</span>
-289: 
-290:       <span class="ruby-identifier">str</span> = <span class="ruby-value str">''</span>
-291:       <span class="ruby-identifier">first</span> = <span class="ruby-keyword kw">true</span>
-292:       <span class="ruby-comment cmt"># Analyze the tokens of the pattern skipping the first 'skip' tokens.</span>
-293:       <span class="ruby-identifier">skip</span>.<span class="ruby-identifier">upto</span>(<span class="ruby-ivar">@lastSyntaxToken</span>) <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
-294:         <span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span> = <span class="ruby-ivar">@tokens</span>[<span class="ruby-identifier">i</span>]
-295:         <span class="ruby-comment cmt"># If the first token is a _{ the pattern describes optional attributes.</span>
-296:         <span class="ruby-comment cmt"># They are represented by a standard idiom.</span>
-297:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">first</span>
-298:           <span class="ruby-identifier">first</span> = <span class="ruby-keyword kw">false</span>
-299:           <span class="ruby-keyword kw">return</span> <span class="ruby-value str">'{ &lt;attributes&gt; }'</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">name</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'{'</span>
-300:         <span class="ruby-keyword kw">else</span>
-301:           <span class="ruby-comment cmt"># Separate the syntax elemens by a whitespace.</span>
-302:           <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-value str">' '</span>
-303:         <span class="ruby-keyword kw">end</span>
-304: 
-305:         <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@args</span>[<span class="ruby-identifier">i</span>]
-306:           <span class="ruby-comment cmt"># The argument is documented in the syntax definition. We copy the</span>
-307:           <span class="ruby-comment cmt"># entry as we need to modify it.</span>
-308:           <span class="ruby-identifier">argDoc</span> = <span class="ruby-ivar">@args</span>[<span class="ruby-identifier">i</span>].<span class="ruby-identifier">dup</span>
-309: 
-310:           <span class="ruby-comment cmt"># A documented argument without a name is a terminal token. We use the</span>
-311:           <span class="ruby-comment cmt"># terminal symbol as name.</span>
-312:           <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@args</span>[<span class="ruby-identifier">i</span>].<span class="ruby-identifier">name</span>.<span class="ruby-identifier">nil?</span>
-313:             <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-node">&quot;#{name}&quot;</span>
-314:             <span class="ruby-identifier">argDoc</span>.<span class="ruby-identifier">name</span> = <span class="ruby-identifier">name</span>
-315:           <span class="ruby-keyword kw">else</span>
-316:             <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-node">&quot;&lt;#{@args[i].name}&gt;&quot;</span>
-317:           <span class="ruby-keyword kw">end</span>
-318:           <span class="ruby-identifier">addArgDoc</span>(<span class="ruby-identifier">argDocs</span>, <span class="ruby-identifier">argDoc</span>)
-319: 
-320:           <span class="ruby-comment cmt"># Documented arguments don't have the type set yet. Use the token</span>
-321:           <span class="ruby-comment cmt"># value for that.</span>
-322:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:variable</span>
-323:             <span class="ruby-identifier">argDoc</span>.<span class="ruby-identifier">typeSpec</span> = <span class="ruby-node">&quot;&lt;#{name}&gt;&quot;</span>
-324:           <span class="ruby-keyword kw">end</span>
-325:         <span class="ruby-keyword kw">else</span>
-326:           <span class="ruby-comment cmt"># Undocumented tokens are recursively expanded.</span>
-327:           <span class="ruby-keyword kw">case</span> <span class="ruby-identifier">type</span>
-328:           <span class="ruby-keyword kw">when</span> <span class="ruby-value">:literal</span>
-329:             <span class="ruby-comment cmt"># Literals are shown as such.</span>
-330:             <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">name</span>.<span class="ruby-identifier">to_s</span>
-331:           <span class="ruby-keyword kw">when</span> <span class="ruby-value">:variable</span>
-332:             <span class="ruby-comment cmt"># Variables are enclosed by angle brackets.</span>
-333:             <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-node">&quot;&lt;#{name}&gt;&quot;</span>
-334:           <span class="ruby-keyword kw">when</span> <span class="ruby-value">:reference</span>
-335:             <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">patterns</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">==</span> <span class="ruby-value">1</span> <span class="ruby-operator">&amp;&amp;</span>
-336:                <span class="ruby-operator">!</span><span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">patterns</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">nil?</span>
-337:               <span class="ruby-identifier">addArgDoc</span>(<span class="ruby-identifier">argDocs</span>, <span class="ruby-constant">TokenDoc</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">patterns</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">keyword</span>,
-338:                                               <span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">patterns</span>[<span class="ruby-value">0</span>]))
-339:               <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-value str">'&lt;'</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">patterns</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">keyword</span> <span class="ruby-operator">+</span> <span class="ruby-value str">'&gt;'</span>
-340:             <span class="ruby-keyword kw">else</span>
-341:               <span class="ruby-comment cmt"># References are followed recursively.</span>
-342:               <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">to_syntax</span>(<span class="ruby-identifier">stack</span>, <span class="ruby-identifier">argDocs</span>, <span class="ruby-identifier">rules</span>, <span class="ruby-value">0</span>)
-343:             <span class="ruby-keyword kw">end</span>
-344:           <span class="ruby-keyword kw">end</span>
-345:         <span class="ruby-keyword kw">end</span>
-346:       <span class="ruby-keyword kw">end</span>
-347:       <span class="ruby-comment cmt"># Remove us from the &quot;stack&quot; again.</span>
-348:       <span class="ruby-identifier">stack</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-keyword kw">self</span>)
-349:       <span class="ruby-identifier">str</span>
-350:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 281</span>
+281:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_syntax_r</span>(<span class="ruby-identifier">stack</span>, <span class="ruby-identifier">argDocs</span>, <span class="ruby-identifier">rules</span>, <span class="ruby-identifier">skip</span>)
+282:       <span class="ruby-comment cmt"># If we find ourself on the stack we hit a recursive pattern. This is used</span>
+283:       <span class="ruby-comment cmt"># in repetitions.</span>
+284:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">stack</span>[<span class="ruby-keyword kw">self</span>]
+285:         <span class="ruby-keyword kw">return</span> <span class="ruby-value str">'[, ... ]'</span>
+286:       <span class="ruby-keyword kw">end</span>
+287: 
+288:       <span class="ruby-comment cmt"># &quot;Push&quot; us on the stack.</span>
+289:       <span class="ruby-identifier">stack</span>[<span class="ruby-keyword kw">self</span>] = <span class="ruby-keyword kw">true</span>
+290: 
+291:       <span class="ruby-identifier">str</span> = <span class="ruby-value str">''</span>
+292:       <span class="ruby-identifier">first</span> = <span class="ruby-keyword kw">true</span>
+293:       <span class="ruby-comment cmt"># Analyze the tokens of the pattern skipping the first 'skip' tokens.</span>
+294:       <span class="ruby-identifier">skip</span>.<span class="ruby-identifier">upto</span>(<span class="ruby-ivar">@lastSyntaxToken</span>) <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
+295:         <span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span> = <span class="ruby-ivar">@tokens</span>[<span class="ruby-identifier">i</span>]
+296:         <span class="ruby-comment cmt"># If the first token is a _{ the pattern describes optional attributes.</span>
+297:         <span class="ruby-comment cmt"># They are represented by a standard idiom.</span>
+298:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">first</span>
+299:           <span class="ruby-identifier">first</span> = <span class="ruby-keyword kw">false</span>
+300:           <span class="ruby-keyword kw">return</span> <span class="ruby-value str">'{ &lt;attributes&gt; }'</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">name</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'{'</span>
+301:         <span class="ruby-keyword kw">else</span>
+302:           <span class="ruby-comment cmt"># Separate the syntax elemens by a whitespace.</span>
+303:           <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-value str">' '</span>
+304:         <span class="ruby-keyword kw">end</span>
+305: 
+306:         <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@args</span>[<span class="ruby-identifier">i</span>]
+307:           <span class="ruby-comment cmt"># The argument is documented in the syntax definition. We copy the</span>
+308:           <span class="ruby-comment cmt"># entry as we need to modify it.</span>
+309:           <span class="ruby-identifier">argDoc</span> = <span class="ruby-ivar">@args</span>[<span class="ruby-identifier">i</span>].<span class="ruby-identifier">dup</span>
+310: 
+311:           <span class="ruby-comment cmt"># A documented argument without a name is a terminal token. We use the</span>
+312:           <span class="ruby-comment cmt"># terminal symbol as name.</span>
+313:           <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@args</span>[<span class="ruby-identifier">i</span>].<span class="ruby-identifier">name</span>.<span class="ruby-identifier">nil?</span>
+314:             <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-node">&quot;#{name}&quot;</span>
+315:             <span class="ruby-identifier">argDoc</span>.<span class="ruby-identifier">name</span> = <span class="ruby-identifier">name</span>
+316:           <span class="ruby-keyword kw">else</span>
+317:             <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-node">&quot;&lt;#{@args[i].name}&gt;&quot;</span>
+318:           <span class="ruby-keyword kw">end</span>
+319:           <span class="ruby-identifier">addArgDoc</span>(<span class="ruby-identifier">argDocs</span>, <span class="ruby-identifier">argDoc</span>)
+320: 
+321:           <span class="ruby-comment cmt"># Documented arguments don't have the type set yet. Use the token</span>
+322:           <span class="ruby-comment cmt"># value for that.</span>
+323:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:variable</span>
+324:             <span class="ruby-identifier">argDoc</span>.<span class="ruby-identifier">typeSpec</span> = <span class="ruby-node">&quot;&lt;#{name}&gt;&quot;</span>
+325:           <span class="ruby-keyword kw">end</span>
+326:         <span class="ruby-keyword kw">else</span>
+327:           <span class="ruby-comment cmt"># Undocumented tokens are recursively expanded.</span>
+328:           <span class="ruby-keyword kw">case</span> <span class="ruby-identifier">type</span>
+329:           <span class="ruby-keyword kw">when</span> <span class="ruby-value">:literal</span>
+330:             <span class="ruby-comment cmt"># Literals are shown as such.</span>
+331:             <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">name</span>.<span class="ruby-identifier">to_s</span>
+332:           <span class="ruby-keyword kw">when</span> <span class="ruby-value">:variable</span>
+333:             <span class="ruby-comment cmt"># Variables are enclosed by angle brackets.</span>
+334:             <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-node">&quot;&lt;#{name}&gt;&quot;</span>
+335:           <span class="ruby-keyword kw">when</span> <span class="ruby-value">:reference</span>
+336:             <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">patterns</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">==</span> <span class="ruby-value">1</span> <span class="ruby-operator">&amp;&amp;</span>
+337:                <span class="ruby-operator">!</span><span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">patterns</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">nil?</span>
+338:               <span class="ruby-identifier">addArgDoc</span>(<span class="ruby-identifier">argDocs</span>, <span class="ruby-constant">TokenDoc</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">patterns</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">keyword</span>,
+339:                                               <span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">patterns</span>[<span class="ruby-value">0</span>]))
+340:               <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-value str">'&lt;'</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">patterns</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">keyword</span> <span class="ruby-operator">+</span> <span class="ruby-value str">'&gt;'</span>
+341:             <span class="ruby-keyword kw">else</span>
+342:               <span class="ruby-comment cmt"># References are followed recursively.</span>
+343:               <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">to_syntax</span>(<span class="ruby-identifier">stack</span>, <span class="ruby-identifier">argDocs</span>, <span class="ruby-identifier">rules</span>, <span class="ruby-value">0</span>)
+344:             <span class="ruby-keyword kw">end</span>
+345:           <span class="ruby-keyword kw">end</span>
+346:         <span class="ruby-keyword kw">end</span>
+347:       <span class="ruby-keyword kw">end</span>
+348:       <span class="ruby-comment cmt"># Remove us from the &quot;stack&quot; again.</span>
+349:       <span class="ruby-identifier">stack</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-keyword kw">self</span>)
+350:       <span class="ruby-identifier">str</span>
+351:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1670,14 +1676,14 @@ Generate a syntax description for this pattern.
 					<div class="method-source-code"
 						id="add-rg-oc-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 376</span>
-376:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">addArgDoc</span>(<span class="ruby-identifier">argDocs</span>, <span class="ruby-identifier">argDoc</span>)
-377:       <span class="ruby-identifier">raise</span> <span class="ruby-value str">'Error'</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">argDoc</span>.<span class="ruby-identifier">name</span>.<span class="ruby-identifier">nil?</span>
-378:       <span class="ruby-identifier">argDocs</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">ad</span><span class="ruby-operator">|</span>
-379:         <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">ad</span>.<span class="ruby-identifier">name</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">argDoc</span>.<span class="ruby-identifier">name</span>
-380:       <span class="ruby-keyword kw">end</span>
-381:       <span class="ruby-identifier">argDocs</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">argDoc</span>
-382:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser/Pattern.rb, line 377</span>
+377:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">addArgDoc</span>(<span class="ruby-identifier">argDocs</span>, <span class="ruby-identifier">argDoc</span>)
+378:       <span class="ruby-identifier">raise</span> <span class="ruby-value str">'Error'</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">argDoc</span>.<span class="ruby-identifier">name</span>.<span class="ruby-identifier">nil?</span>
+379:       <span class="ruby-identifier">argDocs</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">ad</span><span class="ruby-operator">|</span>
+380:         <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">ad</span>.<span class="ruby-identifier">name</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">argDoc</span>.<span class="ruby-identifier">name</span>
+381:       <span class="ruby-keyword kw">end</span>
+382:       <span class="ruby-identifier">argDocs</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">argDoc</span>
+383:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>