taskjuggler 0.0.8 → 0.0.9

data/doc/TaskJuggler/TextFormatter.html

@@ -133,6 +133,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>
@@ -211,6 +213,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>
@@ -243,6 +247,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>
@@ -523,6 +529,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>
@@ -549,8 +557,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>
@@ -659,15 +665,15 @@ be indented and limited to a given text width.
 					<div class="method-source-code"
 						id="new-source">
 <pre>
-    <span class="ruby-comment cmt"># File lib/TextFormatter.rb, line 23</span>
-23:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">width</span> = <span class="ruby-value">80</span>, <span class="ruby-identifier">indentation</span> = <span class="ruby-value">0</span>, <span class="ruby-identifier">firstLineIndent</span> = <span class="ruby-keyword kw">nil</span>)
-24:       <span class="ruby-comment cmt"># The width of the text including the indent.</span>
-25:       <span class="ruby-ivar">@width</span> = <span class="ruby-identifier">width</span>
-26:       <span class="ruby-comment cmt"># The indent for the first line of a paragraph</span>
-27:       <span class="ruby-ivar">@firstLineIndent</span> = <span class="ruby-identifier">firstLineIndent</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">indentation</span>
-28:       <span class="ruby-comment cmt"># The indent for other lines.</span>
-29:       <span class="ruby-ivar">@indentation</span> = <span class="ruby-identifier">indentation</span>
-30:     <span class="ruby-keyword kw">end</span></pre>
+    <span class="ruby-comment cmt"># File lib/TextFormatter.rb, line 24</span>
+24:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">width</span> = <span class="ruby-value">80</span>, <span class="ruby-identifier">indentation</span> = <span class="ruby-value">0</span>, <span class="ruby-identifier">firstLineIndent</span> = <span class="ruby-keyword kw">nil</span>)
+25:       <span class="ruby-comment cmt"># The width of the text including the indent.</span>
+26:       <span class="ruby-ivar">@width</span> = <span class="ruby-identifier">width</span>
+27:       <span class="ruby-comment cmt"># The indent for the first line of a paragraph</span>
+28:       <span class="ruby-ivar">@firstLineIndent</span> = <span class="ruby-identifier">firstLineIndent</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">indentation</span>
+29:       <span class="ruby-comment cmt"># The indent for other lines.</span>
+30:       <span class="ruby-ivar">@indentation</span> = <span class="ruby-identifier">indentation</span>
+31:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -707,78 +713,78 @@ the class settings.
 					<div class="method-source-code"
 						id="format-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextFormatter.rb, line 73</span>
- 73:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">format</span>(<span class="ruby-identifier">str</span>)
- 74:       <span class="ruby-comment cmt"># The resulting String.</span>
- 75:       <span class="ruby-ivar">@out</span> = <span class="ruby-value str">''</span>
- 76:       <span class="ruby-comment cmt"># The column of the last character of the current line.</span>
- 77:       <span class="ruby-ivar">@linePos</span> = <span class="ruby-value">0</span>
- 78:       <span class="ruby-comment cmt"># A buffer for the currently processed word.</span>
- 79:       <span class="ruby-ivar">@wordBuf</span> = <span class="ruby-value str">''</span>
- 80:       <span class="ruby-comment cmt"># True of we are at the beginning of a line.</span>
- 81:       <span class="ruby-ivar">@beginOfLine</span> = <span class="ruby-keyword kw">true</span>
- 82:       <span class="ruby-comment cmt"># A buffer for the indentation to be used for the next line.</span>
- 83:       <span class="ruby-ivar">@indentBuf</span> = <span class="ruby-value str">' '</span> * <span class="ruby-ivar">@firstLineIndent</span>
- 84:       <span class="ruby-comment cmt"># The status of the state machine.</span>
- 85:       <span class="ruby-identifier">state</span> = <span class="ruby-value">:beginOfParagraph</span>
- 86: 
- 87:       <span class="ruby-comment cmt"># Process the input String from start to finish.</span>
- 88:       <span class="ruby-identifier">str</span>.<span class="ruby-identifier">each_utf8_char</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">c</span><span class="ruby-operator">|</span>
- 89:         <span class="ruby-keyword kw">case</span> <span class="ruby-identifier">state</span>
- 90:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:beginOfParagraph</span>
- 91:           <span class="ruby-comment cmt"># We are currently a the beginning of a new paragraph.</span>
- 92:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">' '</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\n&quot;</span>
- 93:             <span class="ruby-comment cmt"># ignore it</span>
- 94:           <span class="ruby-keyword kw">else</span>
- 95:             <span class="ruby-comment cmt"># A new word started.</span>
- 96:             <span class="ruby-ivar">@wordBuf</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
- 97:             <span class="ruby-identifier">state</span> = <span class="ruby-value">:inWord</span>
- 98:           <span class="ruby-keyword kw">end</span>
- 99:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:inWord</span>
-100:           <span class="ruby-comment cmt"># We are in the middle of processing a word.</span>
-101:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">' '</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\n&quot;</span>
-102:             <span class="ruby-comment cmt"># The word has ended.</span>
-103:             <span class="ruby-identifier">appendWord</span>
-104:             <span class="ruby-identifier">state</span> = <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">' '</span> <span class="ruby-operator">?</span> <span class="ruby-value">:betweenWords</span> <span class="ruby-operator">:</span> <span class="ruby-value">:betweenWordsOrLines</span>
-105:           <span class="ruby-keyword kw">else</span>
-106:             <span class="ruby-comment cmt"># Add the character to the word buffer.</span>
-107:             <span class="ruby-ivar">@wordBuf</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
-108:           <span class="ruby-keyword kw">end</span>
-109:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:betweenWords</span>
-110:           <span class="ruby-comment cmt"># We are in between words.</span>
-111:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">' '</span>
-112:             <span class="ruby-comment cmt"># ignore it</span>
-113:           <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\n&quot;</span>
-114:             <span class="ruby-identifier">state</span> = <span class="ruby-value">:betweenWordsOrLines</span>
-115:           <span class="ruby-keyword kw">else</span>
-116:             <span class="ruby-comment cmt"># A new word started.</span>
-117:             <span class="ruby-ivar">@wordBuf</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
-118:             <span class="ruby-identifier">state</span> = <span class="ruby-value">:inWord</span>
-119:           <span class="ruby-keyword kw">end</span>
-120:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:betweenWordsOrLines</span>
-121:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\n&quot;</span>
-122:             <span class="ruby-comment cmt"># The word break is really a paragraph break.</span>
-123:             <span class="ruby-ivar">@indentBuf</span> = <span class="ruby-value str">&quot;\n\n&quot;</span> <span class="ruby-operator">+</span> <span class="ruby-value str">' '</span> * <span class="ruby-ivar">@firstLineIndent</span>
-124:             <span class="ruby-ivar">@beginOfLine</span> = <span class="ruby-keyword kw">true</span>
-125:             <span class="ruby-identifier">state</span> = <span class="ruby-value">:beginOfParagraph</span>
-126:           <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">' '</span>
-127:             <span class="ruby-identifier">state</span> = <span class="ruby-value">:betweenWords</span>
-128:           <span class="ruby-keyword kw">else</span>
-129:             <span class="ruby-ivar">@wordBuf</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
-130:             <span class="ruby-identifier">state</span> = <span class="ruby-value">:inWord</span>
-131:           <span class="ruby-keyword kw">end</span>
-132:         <span class="ruby-keyword kw">else</span>
-133:           <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Unknown state in state machine: #{state}&quot;</span>
-134:         <span class="ruby-keyword kw">end</span>
-135:       <span class="ruby-keyword kw">end</span>
-136:       <span class="ruby-comment cmt"># Add any still pending word.</span>
-137:       <span class="ruby-identifier">appendWord</span>
-138: 
-139:       <span class="ruby-comment cmt"># Always end with a line break</span>
-140:       <span class="ruby-ivar">@out</span> <span class="ruby-operator">+=</span> <span class="ruby-value str">&quot;\n&quot;</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-ivar">@out</span>[<span class="ruby-value">1</span>] <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\n&quot;</span>
-141: 
-142:       <span class="ruby-ivar">@out</span>
-143:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextFormatter.rb, line 74</span>
+ 74:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">format</span>(<span class="ruby-identifier">str</span>)
+ 75:       <span class="ruby-comment cmt"># The resulting String.</span>
+ 76:       <span class="ruby-ivar">@out</span> = <span class="ruby-value str">''</span>
+ 77:       <span class="ruby-comment cmt"># The column of the last character of the current line.</span>
+ 78:       <span class="ruby-ivar">@linePos</span> = <span class="ruby-value">0</span>
+ 79:       <span class="ruby-comment cmt"># A buffer for the currently processed word.</span>
+ 80:       <span class="ruby-ivar">@wordBuf</span> = <span class="ruby-value str">''</span>
+ 81:       <span class="ruby-comment cmt"># True of we are at the beginning of a line.</span>
+ 82:       <span class="ruby-ivar">@beginOfLine</span> = <span class="ruby-keyword kw">true</span>
+ 83:       <span class="ruby-comment cmt"># A buffer for the indentation to be used for the next line.</span>
+ 84:       <span class="ruby-ivar">@indentBuf</span> = <span class="ruby-value str">' '</span> * <span class="ruby-ivar">@firstLineIndent</span>
+ 85:       <span class="ruby-comment cmt"># The status of the state machine.</span>
+ 86:       <span class="ruby-identifier">state</span> = <span class="ruby-value">:beginOfParagraph</span>
+ 87: 
+ 88:       <span class="ruby-comment cmt"># Process the input String from start to finish.</span>
+ 89:       <span class="ruby-identifier">str</span>.<span class="ruby-identifier">each_utf8_char</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">c</span><span class="ruby-operator">|</span>
+ 90:         <span class="ruby-keyword kw">case</span> <span class="ruby-identifier">state</span>
+ 91:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:beginOfParagraph</span>
+ 92:           <span class="ruby-comment cmt"># We are currently a the beginning of a new paragraph.</span>
+ 93:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">' '</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\n&quot;</span>
+ 94:             <span class="ruby-comment cmt"># ignore it</span>
+ 95:           <span class="ruby-keyword kw">else</span>
+ 96:             <span class="ruby-comment cmt"># A new word started.</span>
+ 97:             <span class="ruby-ivar">@wordBuf</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
+ 98:             <span class="ruby-identifier">state</span> = <span class="ruby-value">:inWord</span>
+ 99:           <span class="ruby-keyword kw">end</span>
+100:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:inWord</span>
+101:           <span class="ruby-comment cmt"># We are in the middle of processing a word.</span>
+102:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">' '</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\n&quot;</span>
+103:             <span class="ruby-comment cmt"># The word has ended.</span>
+104:             <span class="ruby-identifier">appendWord</span>
+105:             <span class="ruby-identifier">state</span> = <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">' '</span> <span class="ruby-operator">?</span> <span class="ruby-value">:betweenWords</span> <span class="ruby-operator">:</span> <span class="ruby-value">:betweenWordsOrLines</span>
+106:           <span class="ruby-keyword kw">else</span>
+107:             <span class="ruby-comment cmt"># Add the character to the word buffer.</span>
+108:             <span class="ruby-ivar">@wordBuf</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
+109:           <span class="ruby-keyword kw">end</span>
+110:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:betweenWords</span>
+111:           <span class="ruby-comment cmt"># We are in between words.</span>
+112:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">' '</span>
+113:             <span class="ruby-comment cmt"># ignore it</span>
+114:           <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\n&quot;</span>
+115:             <span class="ruby-identifier">state</span> = <span class="ruby-value">:betweenWordsOrLines</span>
+116:           <span class="ruby-keyword kw">else</span>
+117:             <span class="ruby-comment cmt"># A new word started.</span>
+118:             <span class="ruby-ivar">@wordBuf</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
+119:             <span class="ruby-identifier">state</span> = <span class="ruby-value">:inWord</span>
+120:           <span class="ruby-keyword kw">end</span>
+121:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:betweenWordsOrLines</span>
+122:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\n&quot;</span>
+123:             <span class="ruby-comment cmt"># The word break is really a paragraph break.</span>
+124:             <span class="ruby-ivar">@indentBuf</span> = <span class="ruby-value str">&quot;\n\n&quot;</span> <span class="ruby-operator">+</span> <span class="ruby-value str">' '</span> * <span class="ruby-ivar">@firstLineIndent</span>
+125:             <span class="ruby-ivar">@beginOfLine</span> = <span class="ruby-keyword kw">true</span>
+126:             <span class="ruby-identifier">state</span> = <span class="ruby-value">:beginOfParagraph</span>
+127:           <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">' '</span>
+128:             <span class="ruby-identifier">state</span> = <span class="ruby-value">:betweenWords</span>
+129:           <span class="ruby-keyword kw">else</span>
+130:             <span class="ruby-ivar">@wordBuf</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
+131:             <span class="ruby-identifier">state</span> = <span class="ruby-value">:inWord</span>
+132:           <span class="ruby-keyword kw">end</span>
+133:         <span class="ruby-keyword kw">else</span>
+134:           <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Unknown state in state machine: #{state}&quot;</span>
+135:         <span class="ruby-keyword kw">end</span>
+136:       <span class="ruby-keyword kw">end</span>
+137:       <span class="ruby-comment cmt"># Add any still pending word.</span>
+138:       <span class="ruby-identifier">appendWord</span>
+139: 
+140:       <span class="ruby-comment cmt"># Always end with a line break</span>
+141:       <span class="ruby-ivar">@out</span> <span class="ruby-operator">+=</span> <span class="ruby-value str">&quot;\n&quot;</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-ivar">@out</span>[<span class="ruby-value">1</span>] <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\n&quot;</span>
+142: 
+143:       <span class="ruby-ivar">@out</span>
+144:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -813,43 +819,43 @@ line will be indented by @firstLineIndent. Lines that are longer than
 					<div class="method-source-code"
 						id="indent-source">
 <pre>
-    <span class="ruby-comment cmt"># File lib/TextFormatter.rb, line 35</span>
-35:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">indent</span>(<span class="ruby-identifier">str</span>)
-36:       <span class="ruby-identifier">out</span> = <span class="ruby-value str">''</span>
-37:       <span class="ruby-comment cmt"># Indentation to be used for the currently processed line. It will be</span>
-38:       <span class="ruby-comment cmt"># set to nil if it was inserted already.</span>
-39:       <span class="ruby-identifier">indentBuf</span> = <span class="ruby-value str">' '</span> * <span class="ruby-ivar">@firstLineIndent</span>
-40:       <span class="ruby-identifier">linePos</span> = <span class="ruby-value">0</span>
-41:       <span class="ruby-comment cmt"># Process the input String from start to finish.</span>
-42:       <span class="ruby-identifier">str</span>.<span class="ruby-identifier">each_utf8_char</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">c</span><span class="ruby-operator">|</span>
-43:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\n&quot;</span>
-44:           <span class="ruby-comment cmt"># To prevent trailing white spaces we only insert a line break</span>
-45:           <span class="ruby-comment cmt"># instead of the indent buffer.</span>
-46:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">indentBuf</span>
-47:             <span class="ruby-identifier">out</span> <span class="ruby-operator">+=</span> <span class="ruby-value str">&quot;\n&quot;</span>
-48:           <span class="ruby-keyword kw">end</span>
-49:           <span class="ruby-comment cmt"># The indent buffer for the next line.</span>
-50:           <span class="ruby-identifier">indentBuf</span> = <span class="ruby-value str">&quot;\n&quot;</span> <span class="ruby-operator">+</span> <span class="ruby-value str">' '</span> * <span class="ruby-ivar">@indentation</span>
-51:         <span class="ruby-keyword kw">else</span>
-52:           <span class="ruby-comment cmt"># If we still have a indent buffer, we need to insert it first.</span>
-53:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">indentBuf</span>
-54:             <span class="ruby-identifier">out</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">indentBuf</span>
-55:             <span class="ruby-identifier">linePos</span> = <span class="ruby-identifier">indentBuf</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-value str">&quot;\n&quot;</span>).<span class="ruby-identifier">length</span>
-56:             <span class="ruby-identifier">indentBuf</span> = <span class="ruby-keyword kw">nil</span>
-57:           <span class="ruby-keyword kw">end</span>
-58:           <span class="ruby-comment cmt"># Discard all characters that extend of the requested line width.</span>
-59:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">linePos</span> <span class="ruby-operator">&lt;</span> <span class="ruby-ivar">@width</span>
-60:             <span class="ruby-identifier">out</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
-61:             <span class="ruby-identifier">linePos</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
-62:           <span class="ruby-keyword kw">end</span>
-63:         <span class="ruby-keyword kw">end</span>
-64:       <span class="ruby-keyword kw">end</span>
-65: 
-66:       <span class="ruby-comment cmt"># Always end with a line break</span>
-67:       <span class="ruby-identifier">out</span> <span class="ruby-operator">+=</span> <span class="ruby-value str">&quot;\n&quot;</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">out</span>[<span class="ruby-value">1</span>] <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\n&quot;</span>
-68: 
-69:       <span class="ruby-identifier">out</span>
-70:     <span class="ruby-keyword kw">end</span></pre>
+    <span class="ruby-comment cmt"># File lib/TextFormatter.rb, line 36</span>
+36:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">indent</span>(<span class="ruby-identifier">str</span>)
+37:       <span class="ruby-identifier">out</span> = <span class="ruby-value str">''</span>
+38:       <span class="ruby-comment cmt"># Indentation to be used for the currently processed line. It will be</span>
+39:       <span class="ruby-comment cmt"># set to nil if it was inserted already.</span>
+40:       <span class="ruby-identifier">indentBuf</span> = <span class="ruby-value str">' '</span> * <span class="ruby-ivar">@firstLineIndent</span>
+41:       <span class="ruby-identifier">linePos</span> = <span class="ruby-value">0</span>
+42:       <span class="ruby-comment cmt"># Process the input String from start to finish.</span>
+43:       <span class="ruby-identifier">str</span>.<span class="ruby-identifier">each_utf8_char</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">c</span><span class="ruby-operator">|</span>
+44:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\n&quot;</span>
+45:           <span class="ruby-comment cmt"># To prevent trailing white spaces we only insert a line break</span>
+46:           <span class="ruby-comment cmt"># instead of the indent buffer.</span>
+47:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">indentBuf</span>
+48:             <span class="ruby-identifier">out</span> <span class="ruby-operator">+=</span> <span class="ruby-value str">&quot;\n&quot;</span>
+49:           <span class="ruby-keyword kw">end</span>
+50:           <span class="ruby-comment cmt"># The indent buffer for the next line.</span>
+51:           <span class="ruby-identifier">indentBuf</span> = <span class="ruby-value str">&quot;\n&quot;</span> <span class="ruby-operator">+</span> <span class="ruby-value str">' '</span> * <span class="ruby-ivar">@indentation</span>
+52:         <span class="ruby-keyword kw">else</span>
+53:           <span class="ruby-comment cmt"># If we still have a indent buffer, we need to insert it first.</span>
+54:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">indentBuf</span>
+55:             <span class="ruby-identifier">out</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">indentBuf</span>
+56:             <span class="ruby-identifier">linePos</span> = <span class="ruby-identifier">indentBuf</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-value str">&quot;\n&quot;</span>).<span class="ruby-identifier">length</span>
+57:             <span class="ruby-identifier">indentBuf</span> = <span class="ruby-keyword kw">nil</span>
+58:           <span class="ruby-keyword kw">end</span>
+59:           <span class="ruby-comment cmt"># Discard all characters that extend of the requested line width.</span>
+60:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">linePos</span> <span class="ruby-operator">&lt;</span> <span class="ruby-ivar">@width</span>
+61:             <span class="ruby-identifier">out</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
+62:             <span class="ruby-identifier">linePos</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
+63:           <span class="ruby-keyword kw">end</span>
+64:         <span class="ruby-keyword kw">end</span>
+65:       <span class="ruby-keyword kw">end</span>
+66: 
+67:       <span class="ruby-comment cmt"># Always end with a line break</span>
+68:       <span class="ruby-identifier">out</span> <span class="ruby-operator">+=</span> <span class="ruby-value str">&quot;\n&quot;</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">out</span>[<span class="ruby-value">1</span>] <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\n&quot;</span>
+69: 
+70:       <span class="ruby-identifier">out</span>
+71:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -886,34 +892,34 @@ line will be indented by @firstLineIndent. Lines that are longer than
 					<div class="method-source-code"
 						id="append-ord-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextFormatter.rb, line 147</span>
-147:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">appendWord</span>
-148:       <span class="ruby-comment cmt"># Ignore empty words.</span>
-149:       <span class="ruby-identifier">wordLength</span> = <span class="ruby-ivar">@wordBuf</span>.<span class="ruby-identifier">length</span>
-150:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">wordLength</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
-151: 
-152:       <span class="ruby-comment cmt"># If the word does not fit into the current line anymore, we have to</span>
-153:       <span class="ruby-comment cmt"># start a new line.</span>
-154:       <span class="ruby-ivar">@beginOfLine</span> = <span class="ruby-keyword kw">true</span> <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@linePos</span> <span class="ruby-operator">+</span> <span class="ruby-value">1</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">wordLength</span> <span class="ruby-operator">&gt;</span> <span class="ruby-ivar">@width</span>
-155: 
-156:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@beginOfLine</span>
-157:         <span class="ruby-comment cmt"># Insert the content of the @indentBuf and reset @linePos and</span>
-158:         <span class="ruby-comment cmt"># @indentBuf.</span>
-159:         <span class="ruby-ivar">@out</span> <span class="ruby-operator">+=</span> <span class="ruby-ivar">@indentBuf</span>
-160:         <span class="ruby-ivar">@linePos</span> = <span class="ruby-ivar">@indentBuf</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-value str">&quot;\n&quot;</span>).<span class="ruby-identifier">length</span>
-161:         <span class="ruby-ivar">@indentBuf</span> = <span class="ruby-value str">&quot;\n&quot;</span> <span class="ruby-operator">+</span> <span class="ruby-value str">' '</span> * <span class="ruby-ivar">@indentation</span>
-162:       <span class="ruby-keyword kw">else</span>
-163:         <span class="ruby-comment cmt"># Insert a space to separate the words.</span>
-164:         <span class="ruby-ivar">@out</span> <span class="ruby-operator">+=</span> <span class="ruby-value str">' '</span>
-165:         <span class="ruby-ivar">@linePos</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
-166:       <span class="ruby-keyword kw">end</span>
-167: 
-168:       <span class="ruby-comment cmt"># Append the word and reset the @wordBuf.</span>
-169:       <span class="ruby-ivar">@out</span> <span class="ruby-operator">+=</span> <span class="ruby-ivar">@wordBuf</span>
-170:       <span class="ruby-ivar">@wordBuf</span> = <span class="ruby-value str">''</span>
-171:       <span class="ruby-ivar">@linePos</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">wordLength</span>
-172:       <span class="ruby-ivar">@beginOfLine</span> = <span class="ruby-keyword kw">false</span> <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@beginOfLine</span>
-173:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextFormatter.rb, line 148</span>
+148:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">appendWord</span>
+149:       <span class="ruby-comment cmt"># Ignore empty words.</span>
+150:       <span class="ruby-identifier">wordLength</span> = <span class="ruby-ivar">@wordBuf</span>.<span class="ruby-identifier">length</span>
+151:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">wordLength</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
+152: 
+153:       <span class="ruby-comment cmt"># If the word does not fit into the current line anymore, we have to</span>
+154:       <span class="ruby-comment cmt"># start a new line.</span>
+155:       <span class="ruby-ivar">@beginOfLine</span> = <span class="ruby-keyword kw">true</span> <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@linePos</span> <span class="ruby-operator">+</span> <span class="ruby-value">1</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">wordLength</span> <span class="ruby-operator">&gt;</span> <span class="ruby-ivar">@width</span>
+156: 
+157:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@beginOfLine</span>
+158:         <span class="ruby-comment cmt"># Insert the content of the @indentBuf and reset @linePos and</span>
+159:         <span class="ruby-comment cmt"># @indentBuf.</span>
+160:         <span class="ruby-ivar">@out</span> <span class="ruby-operator">+=</span> <span class="ruby-ivar">@indentBuf</span>
+161:         <span class="ruby-ivar">@linePos</span> = <span class="ruby-ivar">@indentBuf</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-value str">&quot;\n&quot;</span>).<span class="ruby-identifier">length</span>
+162:         <span class="ruby-ivar">@indentBuf</span> = <span class="ruby-value str">&quot;\n&quot;</span> <span class="ruby-operator">+</span> <span class="ruby-value str">' '</span> * <span class="ruby-ivar">@indentation</span>
+163:       <span class="ruby-keyword kw">else</span>
+164:         <span class="ruby-comment cmt"># Insert a space to separate the words.</span>
+165:         <span class="ruby-ivar">@out</span> <span class="ruby-operator">+=</span> <span class="ruby-value str">' '</span>
+166:         <span class="ruby-ivar">@linePos</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
+167:       <span class="ruby-keyword kw">end</span>
+168: 
+169:       <span class="ruby-comment cmt"># Append the word and reset the @wordBuf.</span>
+170:       <span class="ruby-ivar">@out</span> <span class="ruby-operator">+=</span> <span class="ruby-ivar">@wordBuf</span>
+171:       <span class="ruby-ivar">@wordBuf</span> = <span class="ruby-value str">''</span>
+172:       <span class="ruby-ivar">@linePos</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">wordLength</span>
+173:       <span class="ruby-ivar">@beginOfLine</span> = <span class="ruby-keyword kw">false</span> <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@beginOfLine</span>
+174:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>

data/doc/TaskJuggler/TextParser.html

@@ -199,6 +199,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>
@@ -277,6 +279,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>
@@ -309,6 +313,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>
@@ -589,6 +595,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>
@@ -615,8 +623,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>
@@ -672,11 +678,13 @@ called with the name of the start rule.
 <hr style="height: 1px"></hr><p>
 encoding: UTF-8
 </p>
-<h1>Rule.rb &#8212; The <a href="../TaskJuggler.html">TaskJuggler</a> III <a href="Project.html">Project</a> Management Software</h1>
+<h1>State.rb &#8212; The <a href="../TaskJuggler.html">TaskJuggler</a> III <a href="Project.html">Project</a> Management Software</h1>
 <p>
-Copyright &#169; 2006, 2007, 2008, 2009, 2010 by Chris Schlaeger
-<cs@kde.org>
+Copyright &#169; 2006, 2007, 2008, 2009, 2010, 2011
 </p>
+<pre>
+              by Chris Schlaeger &lt;chris@linux.com&gt;
+</pre>
 <p>
 This program is free software; you can redistribute it and/or modify it
 under the terms of version 2 of the GNU General Public License as published
@@ -687,9 +695,11 @@ encoding: UTF-8
 </p>
 <h1>TokenDoc.rb &#8212; The <a href="../TaskJuggler.html">TaskJuggler</a> III <a href="Project.html">Project</a> Management Software</h1>
 <p>
-Copyright &#169; 2006, 2007, 2008, 2009, 2010 by Chris Schlaeger
-<cs@kde.org>
+Copyright &#169; 2006, 2007, 2008, 2009, 2010, 2011
 </p>
+<pre>
+              by Chris Schlaeger &lt;chris@linux.com&gt;
+</pre>
 <p>
 This program is free software; you can redistribute it and/or modify it
 under the terms of version 2 of the GNU General Public License as published
@@ -768,25 +778,25 @@ Create a new <a href="TextParser.html">TextParser</a> object.
 					<div class="method-source-code"
 						id="new-source">
 <pre>
-    <span class="ruby-comment cmt"># File lib/TextParser.rb, line 77</span>
-77:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">messageHandler</span>)
-78:       <span class="ruby-comment cmt"># The message handler will collect all error messages.</span>
-79:       <span class="ruby-ivar">@messageHandler</span> = <span class="ruby-identifier">messageHandler</span>
-80:       <span class="ruby-comment cmt"># This Hash will store the ruleset that the parser is operating on.</span>
-81:       <span class="ruby-ivar">@rules</span> = { }
-82:       <span class="ruby-comment cmt"># Array to hold the token types that the scanner can return.</span>
-83:       <span class="ruby-ivar">@variables</span> = []
-84:       <span class="ruby-comment cmt"># An list of token types that are not allowed in the current context.</span>
-85:       <span class="ruby-comment cmt"># For performance reasons we use a hash with the token as key. The value</span>
-86:       <span class="ruby-comment cmt"># is irrelevant.</span>
-87:       <span class="ruby-ivar">@blockedVariables</span> = {}
-88:       <span class="ruby-comment cmt"># The currently processed rule.</span>
-89:       <span class="ruby-ivar">@cr</span> = <span class="ruby-keyword kw">nil</span>
-90: 
-91:       <span class="ruby-ivar">@states</span> = {}
-92:       <span class="ruby-comment cmt"># The stack used by the FSM.</span>
-93:       <span class="ruby-ivar">@stack</span> = <span class="ruby-keyword kw">nil</span>
-94:     <span class="ruby-keyword kw">end</span></pre>
+    <span class="ruby-comment cmt"># File lib/TextParser.rb, line 78</span>
+78:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">messageHandler</span>)
+79:       <span class="ruby-comment cmt"># The message handler will collect all error messages.</span>
+80:       <span class="ruby-ivar">@messageHandler</span> = <span class="ruby-identifier">messageHandler</span>
+81:       <span class="ruby-comment cmt"># This Hash will store the ruleset that the parser is operating on.</span>
+82:       <span class="ruby-ivar">@rules</span> = { }
+83:       <span class="ruby-comment cmt"># Array to hold the token types that the scanner can return.</span>
+84:       <span class="ruby-ivar">@variables</span> = []
+85:       <span class="ruby-comment cmt"># An list of token types that are not allowed in the current context.</span>
+86:       <span class="ruby-comment cmt"># For performance reasons we use a hash with the token as key. The value</span>
+87:       <span class="ruby-comment cmt"># is irrelevant.</span>
+88:       <span class="ruby-ivar">@blockedVariables</span> = {}
+89:       <span class="ruby-comment cmt"># The currently processed rule.</span>
+90:       <span class="ruby-ivar">@cr</span> = <span class="ruby-keyword kw">nil</span>
+91: 
+92:       <span class="ruby-ivar">@states</span> = {}
+93:       <span class="ruby-comment cmt"># The stack used by the FSM.</span>
+94:       <span class="ruby-ivar">@stack</span> = <span class="ruby-keyword kw">nil</span>
+95:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -823,17 +833,17 @@ Create a new <a href="TextParser.html">TextParser</a> object.
 					<div class="method-source-code"
 						id="error-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 219</span>
-219:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">error</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span> = <span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">data</span> = <span class="ruby-keyword kw">nil</span>)
-220:       <span class="ruby-identifier">sfi</span> <span class="ruby-operator">||=</span> <span class="ruby-identifier">sourceFileInfo</span>
-221:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@scanner</span>
-222:         <span class="ruby-comment cmt"># The scanner has some more context information, so we pass the error</span>
-223:         <span class="ruby-comment cmt"># on to the TextScanner.</span>
-224:         <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">error</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
-225:       <span class="ruby-keyword kw">else</span>
-226:         <span class="ruby-ivar">@messageHandler</span>.<span class="ruby-identifier">error</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
-227:       <span class="ruby-keyword kw">end</span>
-228:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 220</span>
+220:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">error</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span> = <span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">data</span> = <span class="ruby-keyword kw">nil</span>)
+221:       <span class="ruby-identifier">sfi</span> <span class="ruby-operator">||=</span> <span class="ruby-identifier">sourceFileInfo</span>
+222:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@scanner</span>
+223:         <span class="ruby-comment cmt"># The scanner has some more context information, so we pass the error</span>
+224:         <span class="ruby-comment cmt"># on to the TextScanner.</span>
+225:         <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">error</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
+226:       <span class="ruby-keyword kw">else</span>
+227:         <span class="ruby-ivar">@messageHandler</span>.<span class="ruby-identifier">error</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
+228:       <span class="ruby-keyword kw">end</span>
+229:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -867,17 +877,17 @@ rules.
 					<div class="method-source-code"
 						id="init-ules-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 111</span>
-111:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initRules</span>
-112:       <span class="ruby-identifier">methods</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">m</span><span class="ruby-operator">|</span>
-113:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">m</span>[<span class="ruby-value">0</span>, <span class="ruby-value">5</span>] <span class="ruby-operator">==</span> <span class="ruby-value str">'rule_'</span>
-114:           <span class="ruby-comment cmt"># Create a new rule with the suffix of the function name as name.</span>
-115:           <span class="ruby-identifier">newRule</span>(<span class="ruby-identifier">m</span>[<span class="ruby-value">5</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>])
-116:           <span class="ruby-comment cmt"># Call the function.</span>
-117:           <span class="ruby-identifier">send</span>(<span class="ruby-identifier">m</span>)
-118:         <span class="ruby-keyword kw">end</span>
-119:       <span class="ruby-keyword kw">end</span>
-120:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 112</span>
+112:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initRules</span>
+113:       <span class="ruby-identifier">methods</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">m</span><span class="ruby-operator">|</span>
+114:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">m</span>[<span class="ruby-value">0</span>, <span class="ruby-value">5</span>] <span class="ruby-operator">==</span> <span class="ruby-value str">'rule_'</span>
+115:           <span class="ruby-comment cmt"># Create a new rule with the suffix of the function name as name.</span>
+116:           <span class="ruby-identifier">newRule</span>(<span class="ruby-identifier">m</span>[<span class="ruby-value">5</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>])
+117:           <span class="ruby-comment cmt"># Call the function.</span>
+118:           <span class="ruby-identifier">send</span>(<span class="ruby-identifier">m</span>)
+119:         <span class="ruby-keyword kw">end</span>
+120:       <span class="ruby-keyword kw">end</span>
+121:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -911,18 +921,18 @@ Limit the allowed tokens of the scanner to the subset passed by the
 					<div class="method-source-code"
 						id="limit-oken-et-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 98</span>
- 98:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">limitTokenSet</span>(<span class="ruby-identifier">tokenSet</span>)
- 99:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">tokenSet</span>
-100: 
-101:       <span class="ruby-comment cmt"># Create a copy of all supported variables.</span>
-102:       <span class="ruby-identifier">blockedVariables</span> = <span class="ruby-ivar">@variables</span>.<span class="ruby-identifier">dup</span>
-103:       <span class="ruby-comment cmt"># Then delete all that are in the limited set.</span>
-104:       <span class="ruby-identifier">blockedVariables</span>.<span class="ruby-identifier">delete_if</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">v</span><span class="ruby-operator">|</span> <span class="ruby-identifier">tokenSet</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">v</span>) }
-105:       <span class="ruby-comment cmt"># And convert the list into a Hash for faster lookups.</span>
-106:       <span class="ruby-ivar">@blockedVariables</span> = {}
-107:       <span class="ruby-identifier">blockedVariables</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">v</span><span class="ruby-operator">|</span> <span class="ruby-ivar">@blockedVariables</span>[<span class="ruby-identifier">v</span>] = <span class="ruby-keyword kw">true</span> }
-108:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 99</span>
+ 99:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">limitTokenSet</span>(<span class="ruby-identifier">tokenSet</span>)
+100:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">tokenSet</span>
+101: 
+102:       <span class="ruby-comment cmt"># Create a copy of all supported variables.</span>
+103:       <span class="ruby-identifier">blockedVariables</span> = <span class="ruby-ivar">@variables</span>.<span class="ruby-identifier">dup</span>
+104:       <span class="ruby-comment cmt"># Then delete all that are in the limited set.</span>
+105:       <span class="ruby-identifier">blockedVariables</span>.<span class="ruby-identifier">delete_if</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">v</span><span class="ruby-operator">|</span> <span class="ruby-identifier">tokenSet</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">v</span>) }
+106:       <span class="ruby-comment cmt"># And convert the list into a Hash for faster lookups.</span>
+107:       <span class="ruby-ivar">@blockedVariables</span> = {}
+108:       <span class="ruby-identifier">blockedVariables</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">v</span><span class="ruby-operator">|</span> <span class="ruby-ivar">@blockedVariables</span>[<span class="ruby-identifier">v</span>] = <span class="ruby-keyword kw">true</span> }
+109:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -960,21 +970,21 @@ then implicitely operate on the most recently added rule.
 					<div class="method-source-code"
 						id="new-ule-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 127</span>
-127:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">newRule</span>(<span class="ruby-identifier">name</span>)
-128:       <span class="ruby-comment cmt"># Use a symbol instead of a String.</span>
-129:       <span class="ruby-identifier">name</span> = <span class="ruby-identifier">name</span>.<span class="ruby-identifier">intern</span>
-130:       <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Fatal Error: Rule #{name} already exists&quot;</span> <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@rules</span>.<span class="ruby-identifier">has_key?</span>(<span class="ruby-identifier">name</span>)
-131: 
-132:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">block_given?</span>
-133:         <span class="ruby-identifier">saveCr</span> = <span class="ruby-ivar">@cr</span>
-134:         <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-ivar">@cr</span> = <span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">Rule</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">name</span>)
-135:         <span class="ruby-keyword kw">yield</span>
-136:         <span class="ruby-ivar">@cr</span> = <span class="ruby-identifier">saveCr</span>
-137:       <span class="ruby-keyword kw">else</span>
-138:         <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-ivar">@cr</span> = <span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">Rule</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">name</span>)
-139:       <span class="ruby-keyword kw">end</span>
-140:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 128</span>
+128:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">newRule</span>(<span class="ruby-identifier">name</span>)
+129:       <span class="ruby-comment cmt"># Use a symbol instead of a String.</span>
+130:       <span class="ruby-identifier">name</span> = <span class="ruby-identifier">name</span>.<span class="ruby-identifier">intern</span>
+131:       <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Fatal Error: Rule #{name} already exists&quot;</span> <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@rules</span>.<span class="ruby-identifier">has_key?</span>(<span class="ruby-identifier">name</span>)
+132: 
+133:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">block_given?</span>
+134:         <span class="ruby-identifier">saveCr</span> = <span class="ruby-ivar">@cr</span>
+135:         <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-ivar">@cr</span> = <span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">Rule</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">name</span>)
+136:         <span class="ruby-keyword kw">yield</span>
+137:         <span class="ruby-ivar">@cr</span> = <span class="ruby-identifier">saveCr</span>
+138:       <span class="ruby-keyword kw">else</span>
+139:         <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-ivar">@cr</span> = <span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">Rule</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">name</span>)
+140:       <span class="ruby-keyword kw">end</span>
+141:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1008,10 +1018,10 @@ elements.
 					<div class="method-source-code"
 						id="optional-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 159</span>
-159:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">optional</span>
-160:       <span class="ruby-ivar">@cr</span>.<span class="ruby-identifier">setOptional</span>
-161:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 160</span>
+160:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">optional</span>
+161:       <span class="ruby-ivar">@cr</span>.<span class="ruby-identifier">setOptional</span>
+162:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1047,21 +1057,21 @@ an error, the result is false.
 					<div class="method-source-code"
 						id="parse-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 196</span>
-196:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">parse</span>(<span class="ruby-identifier">ruleName</span>)
-197:       <span class="ruby-ivar">@stack</span> = []
-198:       <span class="ruby-identifier">@@expectedTokens</span> = []
-199:       <span class="ruby-keyword kw">begin</span>
-200:         <span class="ruby-identifier">result</span> = <span class="ruby-identifier">parseFSM</span>(<span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">ruleName</span>])
-201:       <span class="ruby-keyword kw">rescue</span> <span class="ruby-constant">TjException</span> =<span class="ruby-operator">&gt;</span> <span class="ruby-identifier">msg</span>
-202:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">msg</span>.<span class="ruby-identifier">message</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-operator">!</span><span class="ruby-identifier">msg</span>.<span class="ruby-identifier">message</span>.<span class="ruby-identifier">empty?</span>
-203:           <span class="ruby-ivar">@messageHandler</span>.<span class="ruby-identifier">critical</span>(<span class="ruby-value str">'parse'</span>, <span class="ruby-identifier">msg</span>.<span class="ruby-identifier">message</span>)
-204:         <span class="ruby-keyword kw">end</span>
-205:         <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">false</span>
-206:       <span class="ruby-keyword kw">end</span>
-207: 
-208:       <span class="ruby-identifier">result</span>
-209:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 197</span>
+197:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">parse</span>(<span class="ruby-identifier">ruleName</span>)
+198:       <span class="ruby-ivar">@stack</span> = []
+199:       <span class="ruby-identifier">@@expectedTokens</span> = []
+200:       <span class="ruby-keyword kw">begin</span>
+201:         <span class="ruby-identifier">result</span> = <span class="ruby-identifier">parseFSM</span>(<span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">ruleName</span>])
+202:       <span class="ruby-keyword kw">rescue</span> <span class="ruby-constant">TjException</span> =<span class="ruby-operator">&gt;</span> <span class="ruby-identifier">msg</span>
+203:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">msg</span>.<span class="ruby-identifier">message</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-operator">!</span><span class="ruby-identifier">msg</span>.<span class="ruby-identifier">message</span>.<span class="ruby-identifier">empty?</span>
+204:           <span class="ruby-ivar">@messageHandler</span>.<span class="ruby-identifier">critical</span>(<span class="ruby-value str">'parse'</span>, <span class="ruby-identifier">msg</span>.<span class="ruby-identifier">message</span>)
+205:         <span class="ruby-keyword kw">end</span>
+206:         <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">false</span>
+207:       <span class="ruby-keyword kw">end</span>
+208: 
+209:       <span class="ruby-identifier">result</span>
+210:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1115,10 +1125,10 @@ completed the processing of this rule.
 					<div class="method-source-code"
 						id="pattern-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 153</span>
-153:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">pattern</span>(<span class="ruby-identifier">tokens</span>, <span class="ruby-identifier">func</span> = <span class="ruby-keyword kw">nil</span>)
-154:       <span class="ruby-ivar">@cr</span>.<span class="ruby-identifier">addPattern</span>(<span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">Pattern</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">tokens</span>, <span class="ruby-identifier">func</span>))
-155:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 154</span>
+154:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">pattern</span>(<span class="ruby-identifier">tokens</span>, <span class="ruby-identifier">func</span> = <span class="ruby-keyword kw">nil</span>)
+155:       <span class="ruby-ivar">@cr</span>.<span class="ruby-identifier">addPattern</span>(<span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">Pattern</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">tokens</span>, <span class="ruby-identifier">func</span>))
+156:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1152,10 +1162,10 @@ elements.
 					<div class="method-source-code"
 						id="repeatable-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 165</span>
-165:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">repeatable</span>
-166:       <span class="ruby-ivar">@cr</span>.<span class="ruby-identifier">setRepeatable</span>
-167:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 166</span>
+166:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">repeatable</span>
+167:       <span class="ruby-ivar">@cr</span>.<span class="ruby-identifier">setRepeatable</span>
+168:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1191,11 +1201,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 214</span>
-214:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">sourceFileInfo</span>
-215:       <span class="ruby-keyword kw">return</span> <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">sourceFileInfo</span> <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-operator">||</span> <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">&lt;=</span> <span class="ruby-value">1</span>
-216:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">firstSourceFileInfo</span>
-217:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 215</span>
+215:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">sourceFileInfo</span>
+216:       <span class="ruby-keyword kw">return</span> <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">sourceFileInfo</span> <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-operator">||</span> <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">&lt;=</span> <span class="ruby-value">1</span>
+217:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">firstSourceFileInfo</span>
+218:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1232,25 +1242,25 @@ the states that are currently on the stack have not been modified.
 					<div class="method-source-code"
 						id="update-arser-ables-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 173</span>
-173:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">updateParserTables</span>
-174:       <span class="ruby-identifier">saveFsmStack</span>
-175:       <span class="ruby-comment cmt"># Invalidate some cached data.</span>
-176:       <span class="ruby-ivar">@rules</span>.<span class="ruby-identifier">each_value</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">rule</span><span class="ruby-operator">|</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">flushCache</span> }
-177:       <span class="ruby-ivar">@states</span> = {}
-178:       <span class="ruby-comment cmt"># Generate the parser states for all patterns of all rules.</span>
-179:       <span class="ruby-ivar">@rules</span>.<span class="ruby-identifier">each_value</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">rule</span><span class="ruby-operator">|</span>
-180:         <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">generateStates</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">s</span><span class="ruby-operator">|</span>
-181:           <span class="ruby-ivar">@states</span>[[ <span class="ruby-identifier">s</span>.<span class="ruby-identifier">rule</span>, <span class="ruby-identifier">s</span>.<span class="ruby-identifier">pattern</span>, <span class="ruby-identifier">s</span>.<span class="ruby-identifier">index</span> ]] = <span class="ruby-identifier">s</span>
-182:         <span class="ruby-keyword kw">end</span>
-183:         <span class="ruby-identifier">checkRule</span>(<span class="ruby-identifier">rule</span>)
-184:       <span class="ruby-keyword kw">end</span>
-185:       <span class="ruby-comment cmt"># Compute the transitions between the generated states.</span>
-186:       <span class="ruby-ivar">@states</span>.<span class="ruby-identifier">each_value</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">state</span><span class="ruby-operator">|</span>
-187:         <span class="ruby-identifier">state</span>.<span class="ruby-identifier">addTransitions</span>(<span class="ruby-ivar">@states</span>, <span class="ruby-ivar">@rules</span>)
-188:       <span class="ruby-keyword kw">end</span>
-189:       <span class="ruby-identifier">restoreFsmStack</span>
-190:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 174</span>
+174:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">updateParserTables</span>
+175:       <span class="ruby-identifier">saveFsmStack</span>
+176:       <span class="ruby-comment cmt"># Invalidate some cached data.</span>
+177:       <span class="ruby-ivar">@rules</span>.<span class="ruby-identifier">each_value</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">rule</span><span class="ruby-operator">|</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">flushCache</span> }
+178:       <span class="ruby-ivar">@states</span> = {}
+179:       <span class="ruby-comment cmt"># Generate the parser states for all patterns of all rules.</span>
+180:       <span class="ruby-ivar">@rules</span>.<span class="ruby-identifier">each_value</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">rule</span><span class="ruby-operator">|</span>
+181:         <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">generateStates</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">s</span><span class="ruby-operator">|</span>
+182:           <span class="ruby-ivar">@states</span>[[ <span class="ruby-identifier">s</span>.<span class="ruby-identifier">rule</span>, <span class="ruby-identifier">s</span>.<span class="ruby-identifier">pattern</span>, <span class="ruby-identifier">s</span>.<span class="ruby-identifier">index</span> ]] = <span class="ruby-identifier">s</span>
+183:         <span class="ruby-keyword kw">end</span>
+184:         <span class="ruby-identifier">checkRule</span>(<span class="ruby-identifier">rule</span>)
+185:       <span class="ruby-keyword kw">end</span>
+186:       <span class="ruby-comment cmt"># Compute the transitions between the generated states.</span>
+187:       <span class="ruby-ivar">@states</span>.<span class="ruby-identifier">each_value</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">state</span><span class="ruby-operator">|</span>
+188:         <span class="ruby-identifier">state</span>.<span class="ruby-identifier">addTransitions</span>(<span class="ruby-ivar">@states</span>, <span class="ruby-ivar">@rules</span>)
+189:       <span class="ruby-keyword kw">end</span>
+190:       <span class="ruby-identifier">restoreFsmStack</span>
+191:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1281,17 +1291,17 @@ the states that are currently on the stack have not been modified.
 					<div class="method-source-code"
 						id="warning-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 230</span>
-230:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">warning</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span> = <span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">data</span> = <span class="ruby-keyword kw">nil</span>)
-231:       <span class="ruby-identifier">sfi</span> <span class="ruby-operator">||=</span> <span class="ruby-identifier">sourceFileInfo</span>
-232:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@scanner</span>
-233:         <span class="ruby-comment cmt"># The scanner has some more context information, so we pass the</span>
-234:         <span class="ruby-comment cmt"># warning on to the TextScanner.</span>
-235:         <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">warning</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
-236:       <span class="ruby-keyword kw">else</span>
-237:         <span class="ruby-ivar">@messageHandler</span>.<span class="ruby-identifier">warning</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
-238:       <span class="ruby-keyword kw">end</span>
-239:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 231</span>
+231:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">warning</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span> = <span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">data</span> = <span class="ruby-keyword kw">nil</span>)
+232:       <span class="ruby-identifier">sfi</span> <span class="ruby-operator">||=</span> <span class="ruby-identifier">sourceFileInfo</span>
+233:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@scanner</span>
+234:         <span class="ruby-comment cmt"># The scanner has some more context information, so we pass the</span>
+235:         <span class="ruby-comment cmt"># warning on to the TextScanner.</span>
+236:         <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">warning</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
+237:       <span class="ruby-keyword kw">else</span>
+238:         <span class="ruby-ivar">@messageHandler</span>.<span class="ruby-identifier">warning</span>(<span class="ruby-identifier">id</span>, <span class="ruby-identifier">text</span>, <span class="ruby-identifier">sfi</span>, <span class="ruby-identifier">data</span>)
+239:       <span class="ruby-keyword kw">end</span>
+240:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1328,28 +1338,28 @@ the states that are currently on the stack have not been modified.
 					<div class="method-source-code"
 						id="check-ule-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 243</span>
-243:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">checkRule</span>(<span class="ruby-identifier">rule</span>)
-244:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">patterns</span>.<span class="ruby-identifier">empty?</span>
-245:         <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Rule #{rule.name} must have at least one pattern&quot;</span>
-246:       <span class="ruby-keyword kw">end</span>
-247: 
-248:       <span class="ruby-identifier">rule</span>.<span class="ruby-identifier">patterns</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">pat</span><span class="ruby-operator">|</span>
-249:         <span class="ruby-identifier">pat</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span><span class="ruby-operator">|</span>
-250:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:variable</span>
-251:             <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@variables</span>.<span class="ruby-identifier">index</span>(<span class="ruby-identifier">name</span>).<span class="ruby-identifier">nil?</span>
-252:               <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unsupported_token'</span>,
-253:                     <span class="ruby-node">&quot;The token #{name} is not supported here.&quot;</span>)
-254:             <span class="ruby-keyword kw">end</span>
-255:           <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:reference</span>
-256:             <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">nil?</span>
-257:               <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Fatal Error: Reference to unknown rule #{name} in &quot;</span> <span class="ruby-operator">+</span>
-258:                     <span class="ruby-node">&quot;pattern '#{pat}' of rule #{rule.name}&quot;</span>
-259:             <span class="ruby-keyword kw">end</span>
-260:           <span class="ruby-keyword kw">end</span>
-261:         <span class="ruby-keyword kw">end</span>
-262:       <span class="ruby-keyword kw">end</span>
-263:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 244</span>
+244:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">checkRule</span>(<span class="ruby-identifier">rule</span>)
+245:       <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>
+246:         <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Rule #{rule.name} must have at least one pattern&quot;</span>
+247:       <span class="ruby-keyword kw">end</span>
+248: 
+249:       <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>
+250:         <span class="ruby-identifier">pat</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">type</span>, <span class="ruby-identifier">name</span><span class="ruby-operator">|</span>
+251:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:variable</span>
+252:             <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@variables</span>.<span class="ruby-identifier">index</span>(<span class="ruby-identifier">name</span>).<span class="ruby-identifier">nil?</span>
+253:               <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unsupported_token'</span>,
+254:                     <span class="ruby-node">&quot;The token #{name} is not supported here.&quot;</span>)
+255:             <span class="ruby-keyword kw">end</span>
+256:           <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">==</span> <span class="ruby-value">:reference</span>
+257:             <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@rules</span>[<span class="ruby-identifier">name</span>].<span class="ruby-identifier">nil?</span>
+258:               <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Fatal Error: Reference to unknown rule #{name} in &quot;</span> <span class="ruby-operator">+</span>
+259:                     <span class="ruby-node">&quot;pattern '#{pat}' of rule #{rule.name}&quot;</span>
+260:             <span class="ruby-keyword kw">end</span>
+261:           <span class="ruby-keyword kw">end</span>
+262:         <span class="ruby-keyword kw">end</span>
+263:       <span class="ruby-keyword kw">end</span>
+264:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1380,30 +1390,30 @@ the states that are currently on the stack have not been modified.
 					<div class="method-source-code"
 						id="dump-tack-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 400</span>
-400:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">dumpStack</span>
-401:       <span class="ruby-comment cmt">#puts &quot;Stack level #{@stack.length}&quot;</span>
-402:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">sl</span><span class="ruby-operator">|</span>
-403:         <span class="ruby-identifier">print</span> <span class="ruby-node">&quot;#{@stack.index(sl)}: &quot;</span>
-404:         <span class="ruby-identifier">sl</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">v</span><span class="ruby-operator">|</span>
-405:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">v</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Array</span>)
-406:             <span class="ruby-keyword kw">begin</span>
-407:               <span class="ruby-identifier">print</span> <span class="ruby-node">&quot;[#{v.join('|')}]|&quot;</span>
-408:             <span class="ruby-keyword kw">rescue</span>
-409:               <span class="ruby-identifier">print</span> <span class="ruby-node">&quot;[#{v[0].class}...]|&quot;</span>
-410:             <span class="ruby-keyword kw">end</span>
-411:           <span class="ruby-keyword kw">else</span>
-412:             <span class="ruby-keyword kw">begin</span>
-413:               <span class="ruby-identifier">print</span> <span class="ruby-node">&quot;#{v}|&quot;</span>
-414:             <span class="ruby-keyword kw">rescue</span>
-415:               <span class="ruby-identifier">print</span> <span class="ruby-identifier">v</span>.<span class="ruby-identifier">class</span>
-416:             <span class="ruby-keyword kw">end</span>
-417:           <span class="ruby-keyword kw">end</span>
-418:         <span class="ruby-keyword kw">end</span>
-419:         <span class="ruby-identifier">print</span> <span class="ruby-node">&quot; -&gt; #{sl.state ? sl.state.to_s(true) : 'nil'} #{sl.function.nil? ? '' : '(Called)'}&quot;</span>
-420:         <span class="ruby-identifier">puts</span> <span class="ruby-value str">&quot;&quot;</span>
-421:       <span class="ruby-keyword kw">end</span>
-422:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 405</span>
+405:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">dumpStack</span>
+406:       <span class="ruby-comment cmt">#puts &quot;Stack level #{@stack.length}&quot;</span>
+407:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">sl</span><span class="ruby-operator">|</span>
+408:         <span class="ruby-identifier">print</span> <span class="ruby-node">&quot;#{@stack.index(sl)}: &quot;</span>
+409:         <span class="ruby-identifier">sl</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">v</span><span class="ruby-operator">|</span>
+410:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">v</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Array</span>)
+411:             <span class="ruby-keyword kw">begin</span>
+412:               <span class="ruby-identifier">print</span> <span class="ruby-node">&quot;[#{v.join('|')}]|&quot;</span>
+413:             <span class="ruby-keyword kw">rescue</span>
+414:               <span class="ruby-identifier">print</span> <span class="ruby-node">&quot;[#{v[0].class}...]|&quot;</span>
+415:             <span class="ruby-keyword kw">end</span>
+416:           <span class="ruby-keyword kw">else</span>
+417:             <span class="ruby-keyword kw">begin</span>
+418:               <span class="ruby-identifier">print</span> <span class="ruby-node">&quot;#{v}|&quot;</span>
+419:             <span class="ruby-keyword kw">rescue</span>
+420:               <span class="ruby-identifier">print</span> <span class="ruby-identifier">v</span>.<span class="ruby-identifier">class</span>
+421:             <span class="ruby-keyword kw">end</span>
+422:           <span class="ruby-keyword kw">end</span>
+423:         <span class="ruby-keyword kw">end</span>
+424:         <span class="ruby-identifier">print</span> <span class="ruby-node">&quot; -&gt; #{sl.state ? sl.state.to_s(true) : 'nil'} #{sl.function.nil? ? '' : '(Called)'}&quot;</span>
+425:         <span class="ruby-identifier">puts</span> <span class="ruby-value str">&quot;&quot;</span>
+426:       <span class="ruby-keyword kw">end</span>
+427:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1434,52 +1444,56 @@ the states that are currently on the stack have not been modified.
 					<div class="method-source-code"
 						id="finish-attern-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 354</span>
-354:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">finishPattern</span>(<span class="ruby-identifier">token</span>)
-355:       <span class="ruby-comment cmt">#dumpStack</span>
-356:       <span class="ruby-comment cmt"># To finish a pattern we need to pop the StackElement with the token</span>
-357:       <span class="ruby-comment cmt"># values from the stack.</span>
-358:       <span class="ruby-identifier">stackEntry</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">pop</span>
-359:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-operator">||</span> <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">empty?</span>
-360:         <span class="ruby-comment cmt"># Check if we have reached the bottom of the stack.</span>
-361:         <span class="ruby-identifier">token</span> = <span class="ruby-identifier">getNextToken</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">token</span>
-362:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">==</span> <span class="ruby-value">:endOfText</span>
-363:           <span class="ruby-comment cmt"># If the token is the end of the top-level file, we're done. We push</span>
-364:           <span class="ruby-comment cmt"># back the StackEntry since it holds the overall result of the</span>
-365:           <span class="ruby-comment cmt"># parsing.</span>
-366:           <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">stackEntry</span>)
-367:           <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">true</span>
-368:         <span class="ruby-keyword kw">end</span>
-369:         <span class="ruby-comment cmt"># If it's not the EOF token, we found a token that violates the syntax</span>
-370:         <span class="ruby-comment cmt"># rules.</span>
-371:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unexpctd_token'</span>, <span class="ruby-node">&quot;Unexpected token '#{token[1]}' found. &quot;</span> <span class="ruby-operator">+</span>
-372:               <span class="ruby-value str">&quot;Expecting one of &quot;</span> <span class="ruby-operator">+</span>
-373:               <span class="ruby-node">&quot;#{stackEntry.state.expectedTokens.join(', ')}&quot;</span>)
-374:       <span class="ruby-keyword kw">end</span>
-375:       <span class="ruby-comment cmt"># Memorize if the rule for this pattern was repeatable. Then we will</span>
-376:       <span class="ruby-comment cmt"># store the result of the pattern in an Array.</span>
-377:       <span class="ruby-identifier">ruleIsRepeatable</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">state</span>.<span class="ruby-identifier">rule</span>.<span class="ruby-identifier">repeatable</span>
-378: 
-379:       <span class="ruby-identifier">state</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">state</span>
-380:       <span class="ruby-identifier">result</span> = <span class="ruby-keyword kw">nil</span>
-381:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span>
-382:         <span class="ruby-comment cmt"># Make the token values and their SourceFileInfo available.</span>
-383:         <span class="ruby-ivar">@val</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">val</span>
-384:         <span class="ruby-ivar">@sourceFileInfo</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">sourceFileInfo</span>
-385:         <span class="ruby-comment cmt"># Now call the pattern action to compute the value of the pattern.</span>
-386:         <span class="ruby-identifier">result</span> = <span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span>.<span class="ruby-identifier">call</span>
-387:       <span class="ruby-keyword kw">end</span>
-388: 
-389:       <span class="ruby-comment cmt"># We use the SourceFileInfo of the first token of the pattern to store</span>
-390:       <span class="ruby-comment cmt"># it with the result of the pattern.</span>
-391:       <span class="ruby-identifier">firstSourceFileInfo</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">firstSourceFileInfo</span>
-392:       <span class="ruby-comment cmt"># Store the result at the correct position into the next lower level of</span>
-393:       <span class="ruby-comment cmt"># the stack.</span>
-394:       <span class="ruby-identifier">stackEntry</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>
-395:       <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">insert</span>(<span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">state</span>.<span class="ruby-identifier">index</span>, <span class="ruby-identifier">result</span>,
-396:                         <span class="ruby-identifier">firstSourceFileInfo</span>, <span class="ruby-identifier">ruleIsRepeatable</span>)
-397:       <span class="ruby-keyword kw">false</span>
-398:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 355</span>
+355:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">finishPattern</span>(<span class="ruby-identifier">token</span>)
+356:       <span class="ruby-comment cmt">#dumpStack</span>
+357:       <span class="ruby-comment cmt"># To finish a pattern we need to pop the StackElement with the token</span>
+358:       <span class="ruby-comment cmt"># values from the stack.</span>
+359:       <span class="ruby-identifier">stackEntry</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">pop</span>
+360:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-operator">||</span> <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">empty?</span>
+361:         <span class="ruby-comment cmt"># Check if we have reached the bottom of the stack.</span>
+362:         <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>
+363:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">==</span> <span class="ruby-value">:endOfText</span>
+364:           <span class="ruby-comment cmt"># If the token is the end of the top-level file, we're done. We push</span>
+365:           <span class="ruby-comment cmt"># back the StackEntry since it holds the overall result of the</span>
+366:           <span class="ruby-comment cmt"># parsing.</span>
+367:           <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">stackEntry</span>)
+368:           <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">true</span>
+369:         <span class="ruby-keyword kw">end</span>
+370:         <span class="ruby-comment cmt"># If it's not the EOF token, we found a token that violates the syntax</span>
+371:         <span class="ruby-comment cmt"># rules.</span>
+372:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unexpctd_token'</span>, <span class="ruby-node">&quot;Unexpected token '#{token[1]}' found. &quot;</span> <span class="ruby-operator">+</span>
+373:               <span class="ruby-value str">&quot;Expecting one of &quot;</span> <span class="ruby-operator">+</span>
+374:               <span class="ruby-node">&quot;#{stackEntry.state.expectedTokens.join(', ')}&quot;</span>)
+375:       <span class="ruby-keyword kw">end</span>
+376:       <span class="ruby-comment cmt"># Memorize if the rule for this pattern was repeatable. Then we will</span>
+377:       <span class="ruby-comment cmt"># store the result of the pattern in an Array.</span>
+378:       <span class="ruby-identifier">ruleIsRepeatable</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">state</span>.<span class="ruby-identifier">rule</span>.<span class="ruby-identifier">repeatable</span>
+379: 
+380:       <span class="ruby-identifier">state</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">state</span>
+381:       <span class="ruby-identifier">result</span> = <span class="ruby-keyword kw">nil</span>
+382:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span>
+383:         <span class="ruby-comment cmt"># Make the token values and their SourceFileInfo available.</span>
+384:         <span class="ruby-ivar">@val</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">val</span>
+385:         <span class="ruby-ivar">@sourceFileInfo</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">sourceFileInfo</span>
+386:         <span class="ruby-comment cmt"># Now call the pattern action to compute the value of the pattern.</span>
+387:         <span class="ruby-keyword kw">begin</span>
+388:           <span class="ruby-identifier">result</span> = <span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span>.<span class="ruby-identifier">call</span>
+389:         <span class="ruby-keyword kw">rescue</span> <span class="ruby-constant">AttributeOverwrite</span>
+390:           <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">warning</span>(<span class="ruby-value str">'attr_overwrite'</span>, <span class="ruby-identifier">$!</span>.<span class="ruby-identifier">to_s</span>)
+391:         <span class="ruby-keyword kw">end</span>
+392:       <span class="ruby-keyword kw">end</span>
+393: 
+394:       <span class="ruby-comment cmt"># We use the SourceFileInfo of the first token of the pattern to store</span>
+395:       <span class="ruby-comment cmt"># it with the result of the pattern.</span>
+396:       <span class="ruby-identifier">firstSourceFileInfo</span> = <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">firstSourceFileInfo</span>
+397:       <span class="ruby-comment cmt"># Store the result at the correct position into the next lower level of</span>
+398:       <span class="ruby-comment cmt"># the stack.</span>
+399:       <span class="ruby-identifier">stackEntry</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>
+400:       <span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">insert</span>(<span class="ruby-identifier">stackEntry</span>.<span class="ruby-identifier">state</span>.<span class="ruby-identifier">index</span>, <span class="ruby-identifier">result</span>,
+401:                         <span class="ruby-identifier">firstSourceFileInfo</span>, <span class="ruby-identifier">ruleIsRepeatable</span>)
+402:       <span class="ruby-keyword kw">false</span>
+403:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1510,17 +1524,17 @@ the states that are currently on the stack have not been modified.
 					<div class="method-source-code"
 						id="get-ext-oken-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 447</span>
-447:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">getNextToken</span>
-448:       <span class="ruby-identifier">token</span> = <span class="ruby-identifier">nextToken</span>
-449:       <span class="ruby-comment cmt">#Log &lt;&lt; &quot;Token: [#{token[0]}][#{token[1]}]&quot;</span>
-450:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@blockedVariables</span>[<span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>]]
-451:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unsupported_token'</span>,
-452:               <span class="ruby-node">&quot;The token #{token[1]} is not supported in this context.&quot;</span>,
-453:               <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>])
-454:       <span class="ruby-keyword kw">end</span>
-455:       <span class="ruby-identifier">token</span>
-456:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 452</span>
+452:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">getNextToken</span>
+453:       <span class="ruby-identifier">token</span> = <span class="ruby-identifier">nextToken</span>
+454:       <span class="ruby-comment cmt">#Log &lt;&lt; &quot;Token: [#{token[0]}][#{token[1]}]&quot;</span>
+455:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@blockedVariables</span>[<span class="ruby-identifier">token</span>[<span class="ruby-value">0</span>]]
+456:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unsupported_token'</span>,
+457:               <span class="ruby-node">&quot;The token #{token[1]} is not supported in this context.&quot;</span>,
+458:               <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>])
+459:       <span class="ruby-keyword kw">end</span>
+460:       <span class="ruby-identifier">token</span>
+461:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1551,95 +1565,95 @@ the states that are currently on the stack have not been modified.
 					<div class="method-source-code"
 						id="parse--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">parseFSM</span>(<span class="ruby-identifier">rule</span>)
-266:       <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">state</span> = <span class="ruby-ivar">@states</span>[[ <span class="ruby-identifier">rule</span>, <span class="ruby-keyword kw">nil</span>, <span class="ruby-value">0</span> ]])
-267:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">&quot;no_start_state&quot;</span>, <span class="ruby-node">&quot;No start state for rule #{rule.name} found&quot;</span>)
-268:       <span class="ruby-keyword kw">end</span>
-269:       <span class="ruby-ivar">@stack</span> = [ <span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">StackElement</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">state</span>) ]
-270: 
-271:       <span class="ruby-identifier">loop</span> <span class="ruby-keyword kw">do</span>
-272:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">transitions</span>.<span class="ruby-identifier">empty?</span>
-273:           <span class="ruby-comment cmt"># The final states of each pattern have no pre-compiled transitions.</span>
-274:           <span class="ruby-comment cmt"># For such a state, we don't need to get a new token.</span>
-275:           <span class="ruby-identifier">transition</span> = <span class="ruby-identifier">token</span> = <span class="ruby-keyword kw">nil</span>
-276:         <span class="ruby-keyword kw">else</span>
-277:           <span class="ruby-identifier">transition</span> = <span class="ruby-identifier">state</span>.<span class="ruby-identifier">transition</span>(<span class="ruby-identifier">token</span> = <span class="ruby-identifier">getNextToken</span>)
-278:         <span class="ruby-keyword kw">end</span>
-279: 
-280:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">transition</span>
-281:           <span class="ruby-comment cmt"># Shift: This for normal state transitions. This may be from one</span>
-282:           <span class="ruby-comment cmt"># token of a pattern to the next token of the same pattern, to the</span>
-283:           <span class="ruby-comment cmt"># start of a new pattern or a loop-back to the start of a pattern of</span>
-284:           <span class="ruby-comment cmt"># the same rule. The transition tells us what state we have to</span>
-285:           <span class="ruby-comment cmt"># process next.</span>
-286:           <span class="ruby-identifier">state</span> = <span class="ruby-identifier">transition</span>.<span class="ruby-identifier">state</span>
-287: 
-288:           <span class="ruby-comment cmt"># If we have looped-back we need to finish the pattern first. Final</span>
-289:           <span class="ruby-comment cmt"># tokens of repeatable rules do have transitions!</span>
-290:           <span class="ruby-identifier">finishPattern</span>(<span class="ruby-identifier">token</span>) <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">transition</span>.<span class="ruby-identifier">loopBack</span>
-291: 
-292:           <span class="ruby-comment cmt"># Transitions that enter rules generate states which we need to</span>
-293:           <span class="ruby-comment cmt"># resume at when a rule has been completely processed. We push this</span>
-294:           <span class="ruby-comment cmt"># list of states on the @stack.</span>
-295:           <span class="ruby-identifier">stackElement</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>
-296:           <span class="ruby-identifier">first</span> = <span class="ruby-keyword kw">true</span>
-297:           <span class="ruby-identifier">transition</span>.<span class="ruby-identifier">stateStack</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">s</span><span class="ruby-operator">|</span>
-298:             <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">first</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">s</span>.<span class="ruby-identifier">pattern</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">stackElement</span>.<span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>
-299:               <span class="ruby-comment cmt"># The first state in the list may just be another state of the</span>
-300:               <span class="ruby-comment cmt"># current pattern. In this case, we already have the</span>
-301:               <span class="ruby-comment cmt"># StackElement on the @stack. We only need to update the State</span>
-302:               <span class="ruby-comment cmt"># for the current StackElement.</span>
-303:               <span class="ruby-identifier">stackElement</span>.<span class="ruby-identifier">state</span> = <span class="ruby-identifier">s</span>
-304:             <span class="ruby-keyword kw">else</span>
-305:               <span class="ruby-comment cmt"># For other patterns, we just push a new StackElement onto the</span>
-306:               <span class="ruby-comment cmt"># @stack.</span>
-307:               <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">push</span>(<span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">StackElement</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">s</span>))
-308:             <span class="ruby-keyword kw">end</span>
-309:             <span class="ruby-identifier">first</span> = <span class="ruby-keyword kw">false</span>
-310:           <span class="ruby-keyword kw">end</span>
-311: 
-312:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">index</span> <span class="ruby-operator">==</span> <span class="ruby-value">0</span>
-313:             <span class="ruby-comment cmt"># If we have just started with a new pattern (or loop-ed back) we</span>
-314:             <span class="ruby-comment cmt"># need to push a new StackEntry onto the @stack. The StackEntry</span>
-315:             <span class="ruby-comment cmt"># stores the result of the pattern and keeps the State that we</span>
-316:             <span class="ruby-comment cmt"># need to return to in case we jump to other patterns from this</span>
-317:             <span class="ruby-comment cmt"># pattern.</span>
-318:             <span class="ruby-identifier">function</span> = <span class="ruby-identifier">state</span>.<span class="ruby-identifier">index</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">tokens</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span> <span class="ruby-operator">?</span>
-319:                        <span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span> <span class="ruby-operator">:</span> <span class="ruby-keyword kw">nil</span>
-320:             <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">push</span>(<span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">StackElement</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span>,
-321:                                                      <span class="ruby-identifier">state</span>))
-322:           <span class="ruby-keyword kw">end</span>
-323: 
-324:           <span class="ruby-comment cmt"># Store the token value in the result Array.</span>
-325:           <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">insert</span>(<span class="ruby-identifier">state</span>.<span class="ruby-identifier">index</span>, <span class="ruby-identifier">token</span>[<span class="ruby-value">1</span>], <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>], <span class="ruby-keyword kw">false</span>)
-326:         <span class="ruby-keyword kw">else</span>
-327:           <span class="ruby-comment cmt"># Reduce: We've reached the end of a rule. There is no pre-compiled</span>
-328:           <span class="ruby-comment cmt"># transition available. The current token, if we have one, is of no</span>
-329:           <span class="ruby-comment cmt"># use to us during this state. We just return it to the scanner. The</span>
-330:           <span class="ruby-comment cmt"># next state is determined by the first matching state from the</span>
-331:           <span class="ruby-comment cmt"># @stack.</span>
-332:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">noReduce</span>
-333:             <span class="ruby-comment cmt"># Only states that finish a rule may trigger a reduce operation.</span>
-334:             <span class="ruby-comment cmt"># Other states have the noReduce flag set. If a reduce for such a</span>
-335:             <span class="ruby-comment cmt"># state is triggered, we found a token that is not supported by</span>
-336:             <span class="ruby-comment cmt"># the syntax rules.</span>
-337:             <span class="ruby-identifier">error</span>(<span class="ruby-value str">&quot;no_reduce&quot;</span>,
-338:                   <span class="ruby-node">&quot;Unexpected token '#{token[1]}' found. &quot;</span> <span class="ruby-operator">+</span>
-339:                   <span class="ruby-value str">&quot;Expecting one of &quot;</span> <span class="ruby-operator">+</span>
-340:                   <span class="ruby-node">&quot;#{@stack.last.state.expectedTokens.join(', ')}&quot;</span>)
-341:           <span class="ruby-keyword kw">end</span>
-342:           <span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>) <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">token</span>
-343:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">finishPattern</span>(<span class="ruby-identifier">token</span>)
-344:             <span class="ruby-comment cmt"># Accept: We're done with parsing.</span>
-345:             <span class="ruby-keyword kw">break</span>
-346:           <span class="ruby-keyword kw">end</span>
-347:           <span class="ruby-identifier">state</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">state</span>
-348:         <span class="ruby-keyword kw">end</span>
-349:       <span class="ruby-keyword kw">end</span>
-350: 
-351:       <span class="ruby-ivar">@stack</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">val</span>[<span class="ruby-value">0</span>]
-352:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 266</span>
+266:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">parseFSM</span>(<span class="ruby-identifier">rule</span>)
+267:       <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">state</span> = <span class="ruby-ivar">@states</span>[[ <span class="ruby-identifier">rule</span>, <span class="ruby-keyword kw">nil</span>, <span class="ruby-value">0</span> ]])
+268:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">&quot;no_start_state&quot;</span>, <span class="ruby-node">&quot;No start state for rule #{rule.name} found&quot;</span>)
+269:       <span class="ruby-keyword kw">end</span>
+270:       <span class="ruby-ivar">@stack</span> = [ <span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">StackElement</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">state</span>) ]
+271: 
+272:       <span class="ruby-identifier">loop</span> <span class="ruby-keyword kw">do</span>
+273:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">transitions</span>.<span class="ruby-identifier">empty?</span>
+274:           <span class="ruby-comment cmt"># The final states of each pattern have no pre-compiled transitions.</span>
+275:           <span class="ruby-comment cmt"># For such a state, we don't need to get a new token.</span>
+276:           <span class="ruby-identifier">transition</span> = <span class="ruby-identifier">token</span> = <span class="ruby-keyword kw">nil</span>
+277:         <span class="ruby-keyword kw">else</span>
+278:           <span class="ruby-identifier">transition</span> = <span class="ruby-identifier">state</span>.<span class="ruby-identifier">transition</span>(<span class="ruby-identifier">token</span> = <span class="ruby-identifier">getNextToken</span>)
+279:         <span class="ruby-keyword kw">end</span>
+280: 
+281:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">transition</span>
+282:           <span class="ruby-comment cmt"># Shift: This for normal state transitions. This may be from one</span>
+283:           <span class="ruby-comment cmt"># token of a pattern to the next token of the same pattern, to the</span>
+284:           <span class="ruby-comment cmt"># start of a new pattern or a loop-back to the start of a pattern of</span>
+285:           <span class="ruby-comment cmt"># the same rule. The transition tells us what state we have to</span>
+286:           <span class="ruby-comment cmt"># process next.</span>
+287:           <span class="ruby-identifier">state</span> = <span class="ruby-identifier">transition</span>.<span class="ruby-identifier">state</span>
+288: 
+289:           <span class="ruby-comment cmt"># If we have looped-back we need to finish the pattern first. Final</span>
+290:           <span class="ruby-comment cmt"># tokens of repeatable rules do have transitions!</span>
+291:           <span class="ruby-identifier">finishPattern</span>(<span class="ruby-identifier">token</span>) <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">transition</span>.<span class="ruby-identifier">loopBack</span>
+292: 
+293:           <span class="ruby-comment cmt"># Transitions that enter rules generate states which we need to</span>
+294:           <span class="ruby-comment cmt"># resume at when a rule has been completely processed. We push this</span>
+295:           <span class="ruby-comment cmt"># list of states on the @stack.</span>
+296:           <span class="ruby-identifier">stackElement</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>
+297:           <span class="ruby-identifier">first</span> = <span class="ruby-keyword kw">true</span>
+298:           <span class="ruby-identifier">transition</span>.<span class="ruby-identifier">stateStack</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">s</span><span class="ruby-operator">|</span>
+299:             <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">first</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">s</span>.<span class="ruby-identifier">pattern</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">stackElement</span>.<span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>
+300:               <span class="ruby-comment cmt"># The first state in the list may just be another state of the</span>
+301:               <span class="ruby-comment cmt"># current pattern. In this case, we already have the</span>
+302:               <span class="ruby-comment cmt"># StackElement on the @stack. We only need to update the State</span>
+303:               <span class="ruby-comment cmt"># for the current StackElement.</span>
+304:               <span class="ruby-identifier">stackElement</span>.<span class="ruby-identifier">state</span> = <span class="ruby-identifier">s</span>
+305:             <span class="ruby-keyword kw">else</span>
+306:               <span class="ruby-comment cmt"># For other patterns, we just push a new StackElement onto the</span>
+307:               <span class="ruby-comment cmt"># @stack.</span>
+308:               <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">push</span>(<span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">StackElement</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">s</span>))
+309:             <span class="ruby-keyword kw">end</span>
+310:             <span class="ruby-identifier">first</span> = <span class="ruby-keyword kw">false</span>
+311:           <span class="ruby-keyword kw">end</span>
+312: 
+313:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">index</span> <span class="ruby-operator">==</span> <span class="ruby-value">0</span>
+314:             <span class="ruby-comment cmt"># If we have just started with a new pattern (or loop-ed back) we</span>
+315:             <span class="ruby-comment cmt"># need to push a new StackEntry onto the @stack. The StackEntry</span>
+316:             <span class="ruby-comment cmt"># stores the result of the pattern and keeps the State that we</span>
+317:             <span class="ruby-comment cmt"># need to return to in case we jump to other patterns from this</span>
+318:             <span class="ruby-comment cmt"># pattern.</span>
+319:             <span class="ruby-identifier">function</span> = <span class="ruby-identifier">state</span>.<span class="ruby-identifier">index</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">tokens</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span> <span class="ruby-operator">?</span>
+320:                        <span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span> <span class="ruby-operator">:</span> <span class="ruby-keyword kw">nil</span>
+321:             <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">push</span>(<span class="ruby-constant">TextParser</span><span class="ruby-operator">::</span><span class="ruby-constant">StackElement</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">state</span>.<span class="ruby-identifier">pattern</span>.<span class="ruby-identifier">function</span>,
+322:                                                      <span class="ruby-identifier">state</span>))
+323:           <span class="ruby-keyword kw">end</span>
+324: 
+325:           <span class="ruby-comment cmt"># Store the token value in the result Array.</span>
+326:           <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">insert</span>(<span class="ruby-identifier">state</span>.<span class="ruby-identifier">index</span>, <span class="ruby-identifier">token</span>[<span class="ruby-value">1</span>], <span class="ruby-identifier">token</span>[<span class="ruby-value">2</span>], <span class="ruby-keyword kw">false</span>)
+327:         <span class="ruby-keyword kw">else</span>
+328:           <span class="ruby-comment cmt"># Reduce: We've reached the end of a rule. There is no pre-compiled</span>
+329:           <span class="ruby-comment cmt"># transition available. The current token, if we have one, is of no</span>
+330:           <span class="ruby-comment cmt"># use to us during this state. We just return it to the scanner. The</span>
+331:           <span class="ruby-comment cmt"># next state is determined by the first matching state from the</span>
+332:           <span class="ruby-comment cmt"># @stack.</span>
+333:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">state</span>.<span class="ruby-identifier">noReduce</span>
+334:             <span class="ruby-comment cmt"># Only states that finish a rule may trigger a reduce operation.</span>
+335:             <span class="ruby-comment cmt"># Other states have the noReduce flag set. If a reduce for such a</span>
+336:             <span class="ruby-comment cmt"># state is triggered, we found a token that is not supported by</span>
+337:             <span class="ruby-comment cmt"># the syntax rules.</span>
+338:             <span class="ruby-identifier">error</span>(<span class="ruby-value str">&quot;no_reduce&quot;</span>,
+339:                   <span class="ruby-node">&quot;Unexpected token '#{token[1]}' found. &quot;</span> <span class="ruby-operator">+</span>
+340:                   <span class="ruby-value str">&quot;Expecting one of &quot;</span> <span class="ruby-operator">+</span>
+341:                   <span class="ruby-node">&quot;#{@stack.last.state.expectedTokens.join(', ')}&quot;</span>)
+342:           <span class="ruby-keyword kw">end</span>
+343:           <span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>) <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">token</span>
+344:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">finishPattern</span>(<span class="ruby-identifier">token</span>)
+345:             <span class="ruby-comment cmt"># Accept: We're done with parsing.</span>
+346:             <span class="ruby-keyword kw">break</span>
+347:           <span class="ruby-keyword kw">end</span>
+348:           <span class="ruby-identifier">state</span> = <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">last</span>.<span class="ruby-identifier">state</span>
+349:         <span class="ruby-keyword kw">end</span>
+350:       <span class="ruby-keyword kw">end</span>
+351: 
+352:       <span class="ruby-ivar">@stack</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">val</span>[<span class="ruby-value">0</span>]
+353:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1673,16 +1687,16 @@ respective <a href="TextParser/State.html">State</a> objects again.
 					<div class="method-source-code"
 						id="restore-sm-tack-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 437</span>
-437:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">restoreFsmStack</span>
-438:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-ivar">@stack</span>
-439: 
-440:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">s</span><span class="ruby-operator">|</span>
-441:         <span class="ruby-keyword kw">next</span> <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">state</span> = <span class="ruby-ivar">@states</span>[<span class="ruby-identifier">s</span>.<span class="ruby-identifier">state</span>])
-442:         <span class="ruby-identifier">raise</span> <span class="ruby-value str">&quot;Stack restore failed. Cannot find state&quot;</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">state</span>
-443:         <span class="ruby-identifier">s</span>.<span class="ruby-identifier">state</span> = <span class="ruby-identifier">state</span>
-444:       <span class="ruby-keyword kw">end</span>
-445:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 442</span>
+442:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">restoreFsmStack</span>
+443:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-ivar">@stack</span>
+444: 
+445:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">s</span><span class="ruby-operator">|</span>
+446:         <span class="ruby-keyword kw">next</span> <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">state</span> = <span class="ruby-ivar">@states</span>[<span class="ruby-identifier">s</span>.<span class="ruby-identifier">state</span>])
+447:         <span class="ruby-identifier">raise</span> <span class="ruby-value str">&quot;Stack restore failed. Cannot find state&quot;</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">state</span>
+448:         <span class="ruby-identifier">s</span>.<span class="ruby-identifier">state</span> = <span class="ruby-identifier">state</span>
+449:       <span class="ruby-keyword kw">end</span>
+450:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1717,15 +1731,15 @@ href="TextParser/State.html">State</a> objects into [ rule, pattern, index
 					<div class="method-source-code"
 						id="save-sm-tack-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 426</span>
-426:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">saveFsmStack</span>
-427:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-ivar">@stack</span>
-428: 
-429:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">s</span><span class="ruby-operator">|</span>
-430:         <span class="ruby-keyword kw">next</span> <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">st</span> = <span class="ruby-identifier">s</span>.<span class="ruby-identifier">state</span>)
-431:         <span class="ruby-identifier">s</span>.<span class="ruby-identifier">state</span> = [ <span class="ruby-identifier">st</span>.<span class="ruby-identifier">rule</span>, <span class="ruby-identifier">st</span>.<span class="ruby-identifier">pattern</span>, <span class="ruby-identifier">st</span>.<span class="ruby-identifier">index</span> ]
-432:       <span class="ruby-keyword kw">end</span>
-433:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/TextParser.rb, line 431</span>
+431:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">saveFsmStack</span>
+432:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-ivar">@stack</span>
+433: 
+434:       <span class="ruby-ivar">@stack</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">s</span><span class="ruby-operator">|</span>
+435:         <span class="ruby-keyword kw">next</span> <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">st</span> = <span class="ruby-identifier">s</span>.<span class="ruby-identifier">state</span>)
+436:         <span class="ruby-identifier">s</span>.<span class="ruby-identifier">state</span> = [ <span class="ruby-identifier">st</span>.<span class="ruby-identifier">rule</span>, <span class="ruby-identifier">st</span>.<span class="ruby-identifier">pattern</span>, <span class="ruby-identifier">st</span>.<span class="ruby-identifier">index</span> ]
+437:       <span class="ruby-keyword kw">end</span>
+438:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>