taskjuggler 0.0.6 → 0.0.7

data/doc/TaskJuggler/RichTextParser.html

@@ -180,6 +180,10 @@
 				
 					<li><a href="../TaskJuggler/DurationAttribute.html">TaskJuggler::DurationAttribute</a></li>
 				
+					<li><a href="../TaskJuggler/FileList.html">TaskJuggler::FileList</a></li>
+				
+					<li><a href="../TaskJuggler/FileRecord.html">TaskJuggler::FileRecord</a></li>
+				
 					<li><a href="../TaskJuggler/FixnumAttribute.html">TaskJuggler::FixnumAttribute</a></li>
 				
 					<li><a href="../TaskJuggler/FlagListAttribute.html">TaskJuggler::FlagListAttribute</a></li>
@@ -252,8 +256,6 @@
 				
 					<li><a href="../TaskJuggler/Macro.html">TaskJuggler::Macro</a></li>
 				
-					<li><a href="../TaskJuggler/MacroParser.html">TaskJuggler::MacroParser</a></li>
-				
 					<li><a href="../TaskJuggler/MacroTable.html">TaskJuggler::MacroTable</a></li>
 				
 					<li><a href="../TaskJuggler/ManagerResponsibilities.html">TaskJuggler::ManagerResponsibilities</a></li>
@@ -318,6 +320,8 @@
 				
 					<li><a href="../TaskJuggler/RTFReportLink.html">TaskJuggler::RTFReportLink</a></li>
 				
+					<li><a href="../TaskJuggler/RTFWithQuerySupport.html">TaskJuggler::RTFWithQuerySupport</a></li>
+				
 					<li><a href="../TaskJuggler/RealFormat.html">TaskJuggler::RealFormat</a></li>
 				
 					<li><a href="../TaskJuggler/RealFormatAttribute.html">TaskJuggler::RealFormatAttribute</a></li>
@@ -364,8 +368,6 @@
 				
 					<li><a href="../TaskJuggler/RichTextElement.html">TaskJuggler::RichTextElement</a></li>
 				
-					<li><a href="../TaskJuggler/RichTextException.html">TaskJuggler::RichTextException</a></li>
-				
 					<li><a href="../TaskJuggler/RichTextFunctionExample.html">TaskJuggler::RichTextFunctionExample</a></li>
 				
 					<li><a href="../TaskJuggler/RichTextFunctionHandler.html">TaskJuggler::RichTextFunctionHandler</a></li>
@@ -406,6 +408,8 @@
 				
 					<li><a href="../TaskJuggler/ShiftScenario.html">TaskJuggler::ShiftScenario</a></li>
 				
+					<li><a href="../TaskJuggler/SimpleQueryExpander.html">TaskJuggler::SimpleQueryExpander</a></li>
+				
 					<li><a href="../TaskJuggler/SortListAttribute.html">TaskJuggler::SortListAttribute</a></li>
 				
 					<li><a href="../TaskJuggler/SourceFileInfo.html">TaskJuggler::SourceFileInfo</a></li>
@@ -516,6 +520,8 @@
 				
 					<li><a href="../TaskJuggler/UserManual.html">TaskJuggler::UserManual</a></li>
 				
+					<li><a href="../TaskJuggler/VimSyntax.html">TaskJuggler::VimSyntax</a></li>
+				
 					<li><a href="../TaskJuggler/WebServer.html">TaskJuggler::WebServer</a></li>
 				
 					<li><a href="../TaskJuggler/WorkingHours.html">TaskJuggler::WorkingHours</a></li>
@@ -589,7 +595,7 @@ href="RichTextScanner.html">RichTextScanner</a> class is used.
 				<div class="method-heading">
 				
 					<span class="method-name">new</span><span
-						class="method-args">(rti, sectionCounter = [ 0, 0, 0, 0 ], tokenSet = nil)</span>
+						class="method-args">(messageHandler, rti, sectionCounter = [ 0, 0, 0, 0 ], tokenSet = nil)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -608,27 +614,28 @@ href="RichTextElement.html">RichTextElement</a> objects should belong to.
 						id="new-source">
 <pre>
     <span class="ruby-comment cmt"># File lib/RichTextParser.rb, line 30</span>
-30:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">rti</span>, <span class="ruby-identifier">sectionCounter</span> = [ <span class="ruby-value">0</span>, <span class="ruby-value">0</span>, <span class="ruby-value">0</span>, <span class="ruby-value">0</span> ], <span class="ruby-identifier">tokenSet</span> = <span class="ruby-keyword kw">nil</span>)
-31:       <span class="ruby-keyword kw">super</span>()
-32:       <span class="ruby-ivar">@richTextI</span> = <span class="ruby-identifier">rti</span>
-33:       <span class="ruby-comment cmt"># These are the tokens that can be returned by the RichTextScanner.</span>
-34:       <span class="ruby-ivar">@variables</span> = <span class="ruby-node">%( LINEBREAK SPACE WORD BOLD ITALIC CODE BOLDITALIC PRE
-35:                        HREF HREFEND REF REFEND HLINE
-36:                        QUERY
-37:                        INLINEFUNCSTART INLINEFUNCEND
-38:                        BLOCKFUNCSTART BLOCKFUNCEND ID STRING
-39:                        TITLE1 TITLE2 TITLE3 TITLE4
-40:                        TITLE1END TITLE2END TITLE3END TITLE4END
-41:                        BULLET1 BULLET2 BULLET3 BULLET4
-42:                        NUMBER1 NUMBER2 NUMBER3 NUMBER4 )</span>
-43:       <span class="ruby-identifier">limitTokenSet</span>(<span class="ruby-identifier">tokenSet</span>)
-44:       <span class="ruby-comment cmt"># Load the rule set into the parser.</span>
-45:       <span class="ruby-identifier">initRules</span>
-46:       <span class="ruby-comment cmt"># The sections and numbered list can each nest 3 levels deep. We use these</span>
-47:       <span class="ruby-comment cmt"># counter Arrays to generate proper 1.2.3 type labels.</span>
-48:       <span class="ruby-ivar">@sectionCounter</span> = <span class="ruby-identifier">sectionCounter</span>
-49:       <span class="ruby-ivar">@numberListCounter</span> = [ <span class="ruby-value">0</span>, <span class="ruby-value">0</span>, <span class="ruby-value">0</span>, <span class="ruby-value">0</span> ]
-50:     <span class="ruby-keyword kw">end</span></pre>
+30:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">messageHandler</span>, <span class="ruby-identifier">rti</span>, <span class="ruby-identifier">sectionCounter</span> = [ <span class="ruby-value">0</span>, <span class="ruby-value">0</span>, <span class="ruby-value">0</span>, <span class="ruby-value">0</span> ],
+31:                    <span class="ruby-identifier">tokenSet</span> = <span class="ruby-keyword kw">nil</span>)
+32:       <span class="ruby-keyword kw">super</span>(<span class="ruby-identifier">messageHandler</span>)
+33:       <span class="ruby-ivar">@richTextI</span> = <span class="ruby-identifier">rti</span>
+34:       <span class="ruby-comment cmt"># These are the tokens that can be returned by the RichTextScanner.</span>
+35:       <span class="ruby-ivar">@variables</span> = <span class="ruby-node">%( LINEBREAK SPACE WORD BOLD ITALIC CODE BOLDITALIC PRE
+36:                        HREF HREFEND REF REFEND HLINE
+37:                        QUERY
+38:                        INLINEFUNCSTART INLINEFUNCEND
+39:                        BLOCKFUNCSTART BLOCKFUNCEND ID STRING
+40:                        TITLE1 TITLE2 TITLE3 TITLE4
+41:                        TITLE1END TITLE2END TITLE3END TITLE4END
+42:                        BULLET1 BULLET2 BULLET3 BULLET4
+43:                        NUMBER1 NUMBER2 NUMBER3 NUMBER4 )</span>
+44:       <span class="ruby-identifier">limitTokenSet</span>(<span class="ruby-identifier">tokenSet</span>)
+45:       <span class="ruby-comment cmt"># Load the rule set into the parser.</span>
+46:       <span class="ruby-identifier">initRules</span>
+47:       <span class="ruby-comment cmt"># The sections and numbered list can each nest 3 levels deep. We use these</span>
+48:       <span class="ruby-comment cmt"># counter Arrays to generate proper 1.2.3 type labels.</span>
+49:       <span class="ruby-ivar">@sectionCounter</span> = <span class="ruby-identifier">sectionCounter</span>
+50:       <span class="ruby-ivar">@numberListCounter</span> = [ <span class="ruby-value">0</span>, <span class="ruby-value">0</span>, <span class="ruby-value">0</span>, <span class="ruby-value">0</span> ]
+51:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -667,10 +674,10 @@ Get the next token from the scanner.
 					<div class="method-source-code"
 						id="next-oken-source">
 <pre>
-    <span class="ruby-comment cmt"># File lib/RichTextParser.rb, line 60</span>
-60:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nextToken</span>
-61:       <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">nextToken</span>
-62:     <span class="ruby-keyword kw">end</span></pre>
+    <span class="ruby-comment cmt"># File lib/RichTextParser.rb, line 62</span>
+62:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nextToken</span>
+63:       <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">nextToken</span>
+64:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -703,12 +710,13 @@ Construct the parser and get ready to read.
 					<div class="method-source-code"
 						id="open-source">
 <pre>
-    <span class="ruby-comment cmt"># File lib/RichTextParser.rb, line 53</span>
-53:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">open</span>(<span class="ruby-identifier">text</span>)
-54:       <span class="ruby-comment cmt"># Make sure that the last line is properly terminated with a newline.</span>
-55:       <span class="ruby-comment cmt"># Multiple newlines at the end are simply ignored.</span>
-56:       <span class="ruby-ivar">@scanner</span> = <span class="ruby-constant">RichTextScanner</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">text</span> <span class="ruby-operator">+</span> <span class="ruby-value str">&quot;\n\n&quot;</span>)
-57:     <span class="ruby-keyword kw">end</span></pre>
+    <span class="ruby-comment cmt"># File lib/RichTextParser.rb, line 54</span>
+54:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">open</span>(<span class="ruby-identifier">text</span>)
+55:       <span class="ruby-comment cmt"># Make sure that the last line is properly terminated with a newline.</span>
+56:       <span class="ruby-comment cmt"># Multiple newlines at the end are simply ignored.</span>
+57:       <span class="ruby-ivar">@scanner</span> = <span class="ruby-constant">RichTextScanner</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">text</span> <span class="ruby-operator">+</span> <span class="ruby-value str">&quot;\n\n&quot;</span>, <span class="ruby-ivar">@messageHandler</span>)
+58:       <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">open</span>(<span class="ruby-keyword kw">true</span>)
+59:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -741,10 +749,10 @@ Return the last fetch token again to the scanner.
 					<div class="method-source-code"
 						id="return-oken-source">
 <pre>
-    <span class="ruby-comment cmt"># File lib/RichTextParser.rb, line 65</span>
-65:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>)
-66:       <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>)
-67:     <span class="ruby-keyword kw">end</span></pre>
+    <span class="ruby-comment cmt"># File lib/RichTextParser.rb, line 67</span>
+67:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>)
+68:       <span class="ruby-ivar">@scanner</span>.<span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>)
+69:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>

data/doc/TaskJuggler/RichTextScanner.html

@@ -55,7 +55,7 @@
 			<div id="parent-class-section" class="section">
 				<h3 class="section-header">Parent</h3>
 				
-				<p class="link"><a href="../Object.html">Object</a></p>
+				<p class="link"><a href="TextScanner.html">TaskJuggler::TextScanner</a></p>
 				
 			</div>
 			
@@ -71,55 +71,45 @@
 					
 					<li><a href="#method-c-new">::new</a></li>
 					
-					<li><a href="#method-i-error">#error</a></li>
+					<li><a href="#method-i-bullet">#bullet</a></li>
 					
-					<li><a href="#method-i-fileName">#fileName</a></li>
+					<li><a href="#method-i-dqString">#dqString</a></li>
 					
-					<li><a href="#method-i-isIdStart">#isIdStart</a></li>
+					<li><a href="#method-i-functionEnd">#functionEnd</a></li>
 					
-					<li><a href="#method-i-nextChar">#nextChar</a></li>
+					<li><a href="#method-i-functionStart">#functionStart</a></li>
 					
-					<li><a href="#method-i-nextToken">#nextToken</a></li>
+					<li><a href="#method-i-hrefEnd">#hrefEnd</a></li>
 					
-					<li><a href="#method-i-nextTokenFuncArg">#nextTokenFuncArg</a></li>
+					<li><a href="#method-i-hrefStart">#hrefStart</a></li>
 					
-					<li><a href="#method-i-nextTokenHRef">#nextTokenHRef</a></li>
+					<li><a href="#method-i-inlineMode">#inlineMode</a></li>
 					
-					<li><a href="#method-i-nextTokenNewline">#nextTokenNewline</a></li>
+					<li><a href="#method-i-linebreak">#linebreak</a></li>
 					
-					<li><a href="#method-i-nextTokenNoWikiInline">#nextTokenNoWikiInline</a></li>
+					<li><a href="#method-i-nowikiEnd">#nowikiEnd</a></li>
 					
-					<li><a href="#method-i-nextTokenOpenAngle">#nextTokenOpenAngle</a></li>
+					<li><a href="#method-i-nowikiStart">#nowikiStart</a></li>
 					
-					<li><a href="#method-i-nextTokenRef">#nextTokenRef</a></li>
+					<li><a href="#method-i-number">#number</a></li>
 					
-					<li><a href="#method-i-nextTokenWikiBOL">#nextTokenWikiBOL</a></li>
+					<li><a href="#method-i-pre">#pre</a></li>
 					
-					<li><a href="#method-i-nextTokenWikiInline">#nextTokenWikiInline</a></li>
+					<li><a href="#method-i-query">#query</a></li>
 					
-					<li><a href="#method-i-nextTokenWord">#nextTokenWord</a></li>
+					<li><a href="#method-i-quotes">#quotes</a></li>
 					
-					<li><a href="#method-i-peek">#peek</a></li>
+					<li><a href="#method-i-refEnd">#refEnd</a></li>
 					
-					<li><a href="#method-i-peekMatch">#peekMatch</a></li>
+					<li><a href="#method-i-refStart">#refStart</a></li>
 					
-					<li><a href="#method-i-readBlanks">#readBlanks</a></li>
+					<li><a href="#method-i-space">#space</a></li>
 					
-					<li><a href="#method-i-readCode">#readCode</a></li>
+					<li><a href="#method-i-sqString">#sqString</a></li>
 					
-					<li><a href="#method-i-readId">#readId</a></li>
+					<li><a href="#method-i-titleEnd">#titleEnd</a></li>
 					
-					<li><a href="#method-i-readSequence">#readSequence</a></li>
-					
-					<li><a href="#method-i-readSequenceMax">#readSequenceMax</a></li>
-					
-					<li><a href="#method-i-readString">#readString</a></li>
-					
-					<li><a href="#method-i-returnChar">#returnChar</a></li>
-					
-					<li><a href="#method-i-returnToken">#returnToken</a></li>
-					
-					<li><a href="#method-i-sourceFileInfo">#sourceFileInfo</a></li>
+					<li><a href="#method-i-titleStart">#titleStart</a></li>
 					
 				</ul>
 			</div>
@@ -213,6 +203,10 @@
 				
 					<li><a href="../TaskJuggler/DurationAttribute.html">TaskJuggler::DurationAttribute</a></li>
 				
+					<li><a href="../TaskJuggler/FileList.html">TaskJuggler::FileList</a></li>
+				
+					<li><a href="../TaskJuggler/FileRecord.html">TaskJuggler::FileRecord</a></li>
+				
 					<li><a href="../TaskJuggler/FixnumAttribute.html">TaskJuggler::FixnumAttribute</a></li>
 				
 					<li><a href="../TaskJuggler/FlagListAttribute.html">TaskJuggler::FlagListAttribute</a></li>
@@ -285,8 +279,6 @@
 				
 					<li><a href="../TaskJuggler/Macro.html">TaskJuggler::Macro</a></li>
 				
-					<li><a href="../TaskJuggler/MacroParser.html">TaskJuggler::MacroParser</a></li>
-				
 					<li><a href="../TaskJuggler/MacroTable.html">TaskJuggler::MacroTable</a></li>
 				
 					<li><a href="../TaskJuggler/ManagerResponsibilities.html">TaskJuggler::ManagerResponsibilities</a></li>
@@ -351,6 +343,8 @@
 				
 					<li><a href="../TaskJuggler/RTFReportLink.html">TaskJuggler::RTFReportLink</a></li>
 				
+					<li><a href="../TaskJuggler/RTFWithQuerySupport.html">TaskJuggler::RTFWithQuerySupport</a></li>
+				
 					<li><a href="../TaskJuggler/RealFormat.html">TaskJuggler::RealFormat</a></li>
 				
 					<li><a href="../TaskJuggler/RealFormatAttribute.html">TaskJuggler::RealFormatAttribute</a></li>
@@ -397,8 +391,6 @@
 				
 					<li><a href="../TaskJuggler/RichTextElement.html">TaskJuggler::RichTextElement</a></li>
 				
-					<li><a href="../TaskJuggler/RichTextException.html">TaskJuggler::RichTextException</a></li>
-				
 					<li><a href="../TaskJuggler/RichTextFunctionExample.html">TaskJuggler::RichTextFunctionExample</a></li>
 				
 					<li><a href="../TaskJuggler/RichTextFunctionHandler.html">TaskJuggler::RichTextFunctionHandler</a></li>
@@ -439,6 +431,8 @@
 				
 					<li><a href="../TaskJuggler/ShiftScenario.html">TaskJuggler::ShiftScenario</a></li>
 				
+					<li><a href="../TaskJuggler/SimpleQueryExpander.html">TaskJuggler::SimpleQueryExpander</a></li>
+				
 					<li><a href="../TaskJuggler/SortListAttribute.html">TaskJuggler::SortListAttribute</a></li>
 				
 					<li><a href="../TaskJuggler/SourceFileInfo.html">TaskJuggler::SourceFileInfo</a></li>
@@ -549,6 +543,8 @@
 				
 					<li><a href="../TaskJuggler/UserManual.html">TaskJuggler::UserManual</a></li>
 				
+					<li><a href="../TaskJuggler/VimSyntax.html">TaskJuggler::VimSyntax</a></li>
+				
 					<li><a href="../TaskJuggler/WebServer.html">TaskJuggler::WebServer</a></li>
 				
 					<li><a href="../TaskJuggler/WorkingHours.html">TaskJuggler::WorkingHours</a></li>
@@ -594,11 +590,18 @@
 			<p>
 The <a href="RichTextScanner.html">RichTextScanner</a> is used by the <a
 href="RichTextParser.html">RichTextParser</a> to chop the input text into
-digestable tokens. The parser and the scanner only communicate over <a
-href="RichTextScanner.html#method-i-nextToken">RichTextScanner#nextToken</a>
-and <a
-href="RichTextScanner.html#method-i-returnToken">RichTextScanner#returnToken</a>.
-The scanner can break the text into words and special tokens.
+digestable tokens. It specializes the <a
+href="TextScanner.html">TextScanner</a> class for <a
+href="RichText.html">RichText</a> syntax. The scanner can operate in
+various modes. The current mode is context dependent. The following modes
+are supported:
+</p>
+<p>
+:bop :     at the begining of a paragraph. :bol :     at the begining of a
+line. :inline :  in the middle of a line :nowiki :  ignoring all MediaWiki
+special tokens :ref :     inside of a REF [[ .. ]] :href :    inside of an
+HREF [ .. ] :func :    inside of a block <[ .. ]> or inline <- .. ->
+function
 </p>
 
 		</div>
@@ -621,52 +624,82 @@ The scanner can break the text into words and special tokens.
 				<div class="method-heading">
 				
 					<span class="method-name">new</span><span
-						class="method-args">(text)</span>
+						class="method-args">(masterFile, messageHandler)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
 
 				<div class="method-description">
 					
-					<p>
-Create the <a href="RichTextScanner.html">RichTextScanner</a> object and
-initialize all state variables.
-</p>
+					
 					
 
 					
 					<div class="method-source-code"
 						id="new-source">
 <pre>
-    <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 24</span>
-24:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">text</span>)
-25:       <span class="ruby-comment cmt"># The token buffer is used to hold a returned token. Only one token can</span>
-26:       <span class="ruby-comment cmt"># be returned at a time.</span>
-27:       <span class="ruby-ivar">@tokenBuffer</span> = <span class="ruby-keyword kw">nil</span>
-28:       <span class="ruby-comment cmt"># A reference to the input text.</span>
-29:       <span class="ruby-ivar">@text</span> = <span class="ruby-identifier">text</span>
-30:       <span class="ruby-comment cmt"># The reference text should not change during processing. So we can</span>
-31:       <span class="ruby-comment cmt"># determine the length upfront. It's frequently used.</span>
-32:       <span class="ruby-ivar">@textLength</span> = <span class="ruby-identifier">text</span>.<span class="ruby-identifier">length</span>
-33:       <span class="ruby-comment cmt"># The number of current line.</span>
-34:       <span class="ruby-ivar">@lineNo</span> = <span class="ruby-value">1</span>
-35:       <span class="ruby-comment cmt"># This is the current position withing @text.</span>
-36:       <span class="ruby-ivar">@pos</span> = <span class="ruby-value">0</span>
-37:       <span class="ruby-comment cmt"># This flag is set to true whenever we are at the start of a text line.</span>
-38:       <span class="ruby-ivar">@beginOfLine</span> = <span class="ruby-keyword kw">true</span>
-39:       <span class="ruby-comment cmt"># This is the position of the start of the currently processed line.</span>
-40:       <span class="ruby-comment cmt"># It's only used for error reporting.</span>
-41:       <span class="ruby-ivar">@lineStart</span> = <span class="ruby-value">0</span>
-42:       <span class="ruby-comment cmt"># This variable stores the mode that the parser is operating in. The</span>
-43:       <span class="ruby-comment cmt"># following modes are supported:</span>
-44:       <span class="ruby-comment cmt"># :wiki : accept supported MediaWiki subset plus TJ extensions</span>
-45:       <span class="ruby-comment cmt"># :nowiki : ignore most markup except for the &lt;/nowiki&gt; token</span>
-46:       <span class="ruby-comment cmt"># :funcarg : parse name and parameters of an block  or inline parser</span>
-47:       <span class="ruby-comment cmt"># function.</span>
-48:       <span class="ruby-ivar">@mode</span> = <span class="ruby-value">:wiki</span>
-49:       <span class="ruby-comment cmt"># Enable to trigger printout instead of exception.</span>
-50:       <span class="ruby-ivar">@debug</span> = <span class="ruby-keyword kw">false</span>
-51:     <span class="ruby-keyword kw">end</span></pre>
+    <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 32</span>
+32:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">masterFile</span>, <span class="ruby-identifier">messageHandler</span>)
+33:       <span class="ruby-identifier">tokenPatterns</span> = [
+34:         <span class="ruby-comment cmt"># :bol mode rules</span>
+35:         [ <span class="ruby-value str">'LINEBREAK'</span>, <span class="ruby-regexp re">/\s*\n/</span>, <span class="ruby-value">:bol</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'linebreak'</span>) ],
+36:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/\s+/</span>, <span class="ruby-value">:bol</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'inlineMode'</span>) ],
+37: 
+38:         <span class="ruby-comment cmt"># :bop mode rules</span>
+39:         [ <span class="ruby-value str">'PRE'</span>, <span class="ruby-regexp re">/ [^\n]+\n?/</span>, <span class="ruby-value">:bop</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'pre'</span>) ],
+40:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/\s*\n/</span>, <span class="ruby-value">:bop</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'linebreak'</span>) ],
+41: 
+42:         <span class="ruby-comment cmt"># :inline mode rules</span>
+43:         [ <span class="ruby-value str">'SPACE'</span>, <span class="ruby-regexp re">/[ \t\n]+/</span>, <span class="ruby-value">:inline</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'space'</span>) ],
+44: 
+45:         <span class="ruby-comment cmt"># :bop and :bol mode rules</span>
+46:         [ <span class="ruby-value str">'INLINEFUNCSTART'</span>, <span class="ruby-regexp re">/&lt;-/</span>, [ <span class="ruby-value">:bop</span>, <span class="ruby-value">:bol</span>, <span class="ruby-value">:inline</span> ],
+47:           <span class="ruby-identifier">method</span>(<span class="ruby-value str">'functionStart'</span>) ],
+48:         [ <span class="ruby-value str">'BLOCKFUNCSTART'</span>, <span class="ruby-regexp re">/&lt;\[/</span>, [ <span class="ruby-value">:bop</span>, <span class="ruby-value">:bol</span> ], <span class="ruby-identifier">method</span>(<span class="ruby-value str">'functionStart'</span>) ],
+49:         [ <span class="ruby-value str">'TITLE*'</span>, <span class="ruby-regexp re">/={2,5}/</span>, [ <span class="ruby-value">:bop</span>, <span class="ruby-value">:bol</span> ], <span class="ruby-identifier">method</span>(<span class="ruby-value str">'titleStart'</span>) ],
+50:         [ <span class="ruby-value str">'TITLE*END'</span>, <span class="ruby-regexp re">/={2,5}/</span>, <span class="ruby-value">:inline</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'titleEnd'</span>) ],
+51:         [ <span class="ruby-value str">'BULLET*'</span>, <span class="ruby-regexp re">/\*{1,4} /</span>, [ <span class="ruby-value">:bop</span>, <span class="ruby-value">:bol</span> ], <span class="ruby-identifier">method</span>(<span class="ruby-value str">'bullet'</span>) ],
+52:         [ <span class="ruby-value str">'NUMBER*'</span>, <span class="ruby-regexp re">/\#{1,4} /</span>, [ <span class="ruby-value">:bop</span>, <span class="ruby-value">:bol</span> ], <span class="ruby-identifier">method</span>(<span class="ruby-value str">'number'</span>) ],
+53:         [ <span class="ruby-value str">'HLINE'</span>, <span class="ruby-regexp re">/----/</span>, [ <span class="ruby-value">:bop</span>, <span class="ruby-value">:bol</span> ], <span class="ruby-identifier">method</span>(<span class="ruby-value str">'inlineMode'</span>) ],
+54: 
+55:         <span class="ruby-comment cmt"># :bop, :bol and :inline mode rules</span>
+56:         <span class="ruby-comment cmt"># The &lt;nowiki&gt; token puts the scanner into :nowiki mode.</span>
+57:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/&lt;nowiki&gt;/</span>, [ <span class="ruby-value">:bop</span>, <span class="ruby-value">:bol</span>, <span class="ruby-value">:inline</span> ], <span class="ruby-identifier">method</span>(<span class="ruby-value str">'nowikiStart'</span>) ],
+58:         [ <span class="ruby-value str">'QUOTES'</span>, <span class="ruby-regexp re">/'{2,5}/</span>, [ <span class="ruby-value">:bop</span>, <span class="ruby-value">:bol</span>, <span class="ruby-value">:inline</span> ], <span class="ruby-identifier">method</span>(<span class="ruby-value str">'quotes'</span>) ],
+59:         [ <span class="ruby-value str">'REF'</span>, <span class="ruby-regexp re">/\[\[/</span>, [ <span class="ruby-value">:bop</span>, <span class="ruby-value">:bol</span>, <span class="ruby-value">:inline</span> ], <span class="ruby-identifier">method</span>(<span class="ruby-value str">'refStart'</span>) ],
+60:         [ <span class="ruby-value str">'HREF'</span>, <span class="ruby-regexp re">/\[/</span>, [ <span class="ruby-value">:bop</span>, <span class="ruby-value">:bol</span>, <span class="ruby-value">:inline</span>], <span class="ruby-identifier">method</span>(<span class="ruby-value str">'hrefStart'</span>) ],
+61:         [ <span class="ruby-value str">'WORD'</span>, <span class="ruby-regexp re">/.[^ \n\t\[&lt;']*/</span>, [ <span class="ruby-value">:bop</span>, <span class="ruby-value">:bol</span>, <span class="ruby-value">:inline</span> ],
+62:           <span class="ruby-identifier">method</span>(<span class="ruby-value str">'inlineMode'</span>) ],
+63: 
+64:         <span class="ruby-comment cmt"># :nowiki mode rules</span>
+65:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/&lt;\/nowiki&gt;/</span>, <span class="ruby-value">:nowiki</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'nowikiEnd'</span>) ],
+66:         [ <span class="ruby-value str">'WORD'</span>, <span class="ruby-regexp re">/(&lt;(?!\/nowiki&gt;)|[^ \t\n&lt;])+/</span>, <span class="ruby-value">:nowiki</span> ],
+67:         [ <span class="ruby-value str">'SPACE'</span>, <span class="ruby-regexp re">/[ \t]+/</span>, <span class="ruby-value">:nowiki</span> ],
+68:         [ <span class="ruby-value str">'LINEBREAK'</span>, <span class="ruby-regexp re">/\s*\n/</span>, <span class="ruby-value">:nowiki</span> ],
+69: 
+70:         <span class="ruby-comment cmt"># :ref mode rules</span>
+71:         [ <span class="ruby-value str">'REFEND'</span>, <span class="ruby-regexp re">/\]\]/</span>, <span class="ruby-value">:ref</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'refEnd'</span>) ],
+72:         [ <span class="ruby-value str">'WORD'</span>, <span class="ruby-regexp re">/(&lt;(?!-)|(\](?!\])|[^|&lt;\]]))+/</span>, <span class="ruby-value">:ref</span> ],
+73:         [ <span class="ruby-value str">'QUERY'</span>, <span class="ruby-regexp re">/&lt;-\w+-&gt;/</span>, <span class="ruby-value">:ref</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'query'</span>) ],
+74:         [ <span class="ruby-value str">'LITERAL'</span>, <span class="ruby-regexp re">/./</span>, <span class="ruby-value">:ref</span> ],
+75: 
+76:         <span class="ruby-comment cmt"># :href mode rules</span>
+77:         [ <span class="ruby-value str">'HREFEND'</span>, <span class="ruby-regexp re">/\]/</span>, <span class="ruby-value">:href</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'hrefEnd'</span>) ],
+78:         [ <span class="ruby-value str">'WORD'</span>, <span class="ruby-regexp re">/(&lt;(?!-)|[^ \t\n\]&lt;])+/</span>, <span class="ruby-value">:href</span> ],
+79:         [ <span class="ruby-value str">'QUERY'</span>, <span class="ruby-regexp re">/&lt;-\w+-&gt;/</span>, <span class="ruby-value">:href</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'query'</span>) ],
+80:         [ <span class="ruby-value str">'SPACE'</span>, <span class="ruby-regexp re">/[ \t\n]+/</span>, <span class="ruby-value">:href</span> ],
+81: 
+82:         <span class="ruby-comment cmt"># :func mode rules</span>
+83:         [ <span class="ruby-value str">'INLINEFUNCEND'</span>, <span class="ruby-regexp re">/-&gt;/</span> , <span class="ruby-value">:func</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'functionEnd'</span>) ],
+84:         [ <span class="ruby-value str">'BLOCKFUNCEND'</span>, <span class="ruby-regexp re">/\]&gt;/</span>, <span class="ruby-value">:func</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'functionEnd'</span>) ],
+85:         [ <span class="ruby-value str">'ID'</span>, <span class="ruby-regexp re">/[a-zA-Z_]\w*/</span>, <span class="ruby-value">:func</span> ],
+86:         [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-regexp re">/&quot;(\\&quot;|[^&quot;])*&quot;/</span>, <span class="ruby-value">:func</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'dqString'</span>) ],
+87:         [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-regexp re">/'(\\'|[^'])*'/</span>, <span class="ruby-value">:func</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'sqString'</span>) ],
+88:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/[ \t\n]+/</span>, <span class="ruby-value">:func</span> ],
+89:         [ <span class="ruby-value str">'LITERAL'</span>, <span class="ruby-regexp re">/./</span>, <span class="ruby-value">:func</span> ]
+90:       ]
+91:       <span class="ruby-keyword kw">super</span>(<span class="ruby-identifier">masterFile</span>, <span class="ruby-identifier">messageHandler</span>, <span class="ruby-identifier">tokenPatterns</span>, <span class="ruby-value">:bop</span>)
+92:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -679,79 +712,35 @@ initialize all state variables.
 		
 		</div>
 	
-		<div id="public-instance-method-details" class="method-section section">
-			<h3 class="section-header">Public Instance Methods</h3>
+		<div id="private-instance-method-details" class="method-section section">
+			<h3 class="section-header">Private Instance Methods</h3>
 
 		
-			<div id="error-method" class="method-detail ">
-				<a name="method-i-error"></a>
+			<div id="bullet-method" class="method-detail ">
+				<a name="method-i-bullet"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">error</span><span
-						class="method-args">(id, text, foo = nil, bar = nil)</span>
+					<span class="method-name">bullet</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
 
 				<div class="method-description">
 					
-					<p>
-The parser uses this function to report any errors during parsing.
-</p>
-					
-
-					
-					<div class="method-source-code"
-						id="error-source">
-<pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 115</span>
-115:     <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">foo</span> = <span class="ruby-keyword kw">nil</span>, <span class="ruby-identifier">bar</span> = <span class="ruby-keyword kw">nil</span>)
-116:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@debug</span>
-117:         <span class="ruby-identifier">$stderr</span>.<span class="ruby-identifier">puts</span> <span class="ruby-node">&quot;Line #{@lineNo}: #{text}\n&quot;</span> <span class="ruby-operator">+</span>
-118:                      <span class="ruby-node">&quot;#{@text[@lineStart, @pos - @lineStart]}&quot;</span>
-119:       <span class="ruby-keyword kw">else</span>
-120:         <span class="ruby-identifier">raise</span> <span class="ruby-constant">RichTextException</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">id</span>, <span class="ruby-ivar">@lineNo</span>, <span class="ruby-identifier">text</span>,
-121:                                     <span class="ruby-ivar">@text</span>[<span class="ruby-ivar">@lineStart</span>, <span class="ruby-ivar">@pos</span> <span class="ruby-operator">-</span> <span class="ruby-ivar">@lineStart</span>])
-122:       <span class="ruby-keyword kw">end</span>
-123:     <span class="ruby-keyword kw">end</span></pre>
-					</div>
-					
-				</div>
-
-				
-
-				
-			</div>
-
-		
-			<div id="file-ame-method" class="method-detail ">
-				<a name="method-i-fileName"></a>
-
-				<div class="method-heading">
-				
-					<span class="method-name">fileName</span><span
-						class="method-args">()</span>
-					<span class="method-click-advice">click to toggle source</span>
-				
-				</div>
-
-				<div class="method-description">
 					
-					<p>
-This function makes more sense for parsers that process actual files. As we
-don&#8217;t have a file name, we just return &#8216;input text&#8217;.
-</p>
 					
 
 					
 					<div class="method-source-code"
-						id="file-ame-source">
+						id="bullet-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 110</span>
-110:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">fileName</span>
-111:       <span class="ruby-value str">'input text'</span>
-112:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 125</span>
+125:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">bullet</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+126:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:inline</span>
+127:       [ <span class="ruby-node">&quot;BULLET#{match.length - 1}&quot;</span>, <span class="ruby-identifier">match</span> ]
+128:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -762,100 +751,32 @@ don&#8217;t have a file name, we just return &#8216;input text&#8217;.
 			</div>
 
 		
-			<div id="next-oken-method" class="method-detail ">
-				<a name="method-i-nextToken"></a>
+			<div id="dq-tring-method" class="method-detail ">
+				<a name="method-i-dqString"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">nextToken</span><span
-						class="method-args">()</span>
+					<span class="method-name">dqString</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
 
 				<div class="method-description">
 					
-					<p>
-Return the next token from the input text.
-</p>
-					
-
-					
-					<div class="method-source-code"
-						id="next-oken-source">
-<pre>
-    <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 62</span>
-62:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nextToken</span>
-63:       <span class="ruby-comment cmt"># If we have a returned token, this is returned first.</span>
-64:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@tokenBuffer</span>
-65:         <span class="ruby-identifier">tok</span> = <span class="ruby-ivar">@tokenBuffer</span>
-66:         <span class="ruby-ivar">@tokenBuffer</span> = <span class="ruby-keyword kw">nil</span>
-67:         <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">tok</span>
-68:       <span class="ruby-keyword kw">end</span>
-69: 
-70:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@mode</span> <span class="ruby-operator">==</span> <span class="ruby-value">:funcarg</span>
-71:         <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">nextTokenFuncArg</span>
-72:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-ivar">@mode</span> <span class="ruby-operator">==</span> <span class="ruby-value">:href</span>
-73:         <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">nextTokenHRef</span>
-74:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-ivar">@mode</span> <span class="ruby-operator">==</span> <span class="ruby-value">:ref</span>
-75:         <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">nextTokenRef</span>
-76:       <span class="ruby-keyword kw">end</span>
-77:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@beginOfLine</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-ivar">@mode</span> <span class="ruby-operator">==</span> <span class="ruby-value">:wiki</span>
-78:         <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">res</span> = <span class="ruby-identifier">nextTokenWikiBOL</span>)
-79:           <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">res</span>
-80:         <span class="ruby-keyword kw">end</span>
-81:       <span class="ruby-keyword kw">end</span>
-82: 
-83:       <span class="ruby-comment cmt"># Many inline control character sequences consit of multiple characters.</span>
-84:       <span class="ruby-comment cmt"># In case of incomplete sequences, we roll back to the start character</span>
-85:       <span class="ruby-comment cmt"># and set the ignoreInlineMarkup flag to simply treat them as normal</span>
-86:       <span class="ruby-comment cmt"># text.</span>
-87:       <span class="ruby-ivar">@ignoreInlineMarkup</span> = <span class="ruby-keyword kw">false</span>
-88:       <span class="ruby-identifier">loop</span> <span class="ruby-keyword kw">do</span>
-89:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">res</span> = (<span class="ruby-ivar">@mode</span> <span class="ruby-operator">==</span> <span class="ruby-value">:wiki</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">nextTokenWikiInline</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">nextTokenNoWikiInline</span>)
-90:           <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">res</span>
-91:         <span class="ruby-keyword kw">end</span>
-92:       <span class="ruby-keyword kw">end</span>
-93:     <span class="ruby-keyword kw">end</span></pre>
-					</div>
-					
-				</div>
-
-				
-
-				
-			</div>
-
-		
-			<div id="return-oken-method" class="method-detail ">
-				<a name="method-i-returnToken"></a>
-
-				<div class="method-heading">
-				
-					<span class="method-name">returnToken</span><span
-						class="method-args">(token)</span>
-					<span class="method-click-advice">click to toggle source</span>
-				
-				</div>
-
-				<div class="method-description">
 					
-					<p>
-Return the last issued token to the token buffer.
-</p>
 					
 
 					
 					<div class="method-source-code"
-						id="return-oken-source">
+						id="dq-tring-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 96</span>
- 96:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">returnToken</span>(<span class="ruby-identifier">token</span>)
- 97:       <span class="ruby-keyword kw">unless</span> <span class="ruby-ivar">@tokenBuffer</span>.<span class="ruby-identifier">nil?</span>
- 98:         <span class="ruby-identifier">raise</span> <span class="ruby-constant">TjException</span>.<span class="ruby-identifier">new</span>, <span class="ruby-value str">'Token buffer overflow!'</span>
- 99:       <span class="ruby-keyword kw">end</span>
-100:       <span class="ruby-ivar">@tokenBuffer</span> = <span class="ruby-identifier">token</span>
-101:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 169</span>
+169:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">dqString</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+170:       <span class="ruby-comment cmt"># Remove first and last character and remove backslashes from quoted</span>
+171:       <span class="ruby-comment cmt"># double quotes.</span>
+172:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">2</span>].<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/\\&quot;/</span>, <span class="ruby-value str">'&quot;'</span>) ]
+173:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -866,32 +787,32 @@ Return the last issued token to the token buffer.
 			</div>
 
 		
-			<div id="source-ile-nfo-method" class="method-detail ">
-				<a name="method-i-sourceFileInfo"></a>
+			<div id="function-nd-method" class="method-detail ">
+				<a name="method-i-functionEnd"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">sourceFileInfo</span><span
-						class="method-args">()</span>
+					<span class="method-name">functionEnd</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
 
 				<div class="method-description">
 					
-					<p>
-<a href="Report.html">Report</a> the current cursor position.
-</p>
+					
 					
 
 					
 					<div class="method-source-code"
-						id="source-ile-nfo-source">
+						id="function-nd-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 104</span>
-104:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">sourceFileInfo</span>
-105:       [ <span class="ruby-ivar">@lineNo</span>, <span class="ruby-ivar">@pos</span> ]
-106:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 159</span>
+159:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">functionEnd</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+160:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-ivar">@funcLastMode</span>
+161:       <span class="ruby-ivar">@funcLastMode</span> = <span class="ruby-keyword kw">nil</span>
+162:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span> ]
+163:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -902,19 +823,13 @@ Return the last issued token to the token buffer.
 			</div>
 
 		
-		</div>
-	
-		<div id="private-instance-method-details" class="method-section section">
-			<h3 class="section-header">Private Instance Methods</h3>
-
-		
-			<div id="is-d-tart-method" class="method-detail ">
-				<a name="method-i-isIdStart"></a>
+			<div id="function-tart-method" class="method-detail ">
+				<a name="method-i-functionStart"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">isIdStart</span><span
-						class="method-args">(c)</span>
+					<span class="method-name">functionStart</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -926,12 +841,16 @@ Return the last issued token to the token buffer.
 
 					
 					<div class="method-source-code"
-						id="is-d-tart-source">
+						id="function-tart-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 583</span>
-583:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">isIdStart</span>(<span class="ruby-identifier">c</span>)
-584:       ((<span class="ruby-value str">'a'</span><span class="ruby-operator">..</span><span class="ruby-value str">'z'</span>) <span class="ruby-operator">===</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">||</span> (<span class="ruby-value str">'A'</span><span class="ruby-operator">..</span><span class="ruby-value str">'Z'</span>) <span class="ruby-operator">===</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'_'</span>)
-585:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 151</span>
+151:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">functionStart</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+152:       <span class="ruby-comment cmt"># When restoring :bol or :bop mode, we need to switch to :inline mode.</span>
+153:       <span class="ruby-ivar">@funcLastMode</span> = (<span class="ruby-ivar">@scannerMode</span> <span class="ruby-operator">==</span> <span class="ruby-value">:bop</span> <span class="ruby-operator">||</span> <span class="ruby-ivar">@scannerMode</span> <span class="ruby-operator">==</span> <span class="ruby-value">:bol</span>) <span class="ruby-operator">?</span>
+154:                       <span class="ruby-value">:inline</span> <span class="ruby-operator">:</span> <span class="ruby-ivar">@scannerMode</span>
+155:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:func</span>
+156:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span> ]
+157:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -942,118 +861,32 @@ Return the last issued token to the token buffer.
 			</div>
 
 		
-			<div id="next-har-method" class="method-detail ">
-				<a name="method-i-nextChar"></a>
+			<div id="href-nd-method" class="method-detail ">
+				<a name="method-i-hrefEnd"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">nextChar</span><span
-						class="method-args">()</span>
+					<span class="method-name">hrefEnd</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
 
 				<div class="method-description">
 					
-					<p>
-Deliver the next character. Keep track of the cursor position. In case we
-reach the end, nil is returned.
-</p>
 					
-
-					
-					<div class="method-source-code"
-						id="next-har-source">
-<pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 464</span>
-464:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nextChar</span>
-465:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@pos</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-ivar">@textLength</span>
-466:         <span class="ruby-comment cmt"># Correct @pos so that returnChar works properly but mutliple reads of</span>
-467:         <span class="ruby-comment cmt"># EOT are ignored.</span>
-468:         <span class="ruby-ivar">@pos</span> = <span class="ruby-ivar">@textLength</span> <span class="ruby-operator">+</span> <span class="ruby-value">1</span>
-469:         <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">nil</span>
-470:       <span class="ruby-keyword kw">end</span>
-471:       <span class="ruby-identifier">c</span> = <span class="ruby-ivar">@text</span>[<span class="ruby-ivar">@pos</span>]
-472:       <span class="ruby-ivar">@pos</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
-473:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value">\n\</span>
-474:         <span class="ruby-ivar">@lineNo</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
-475:         <span class="ruby-comment cmt"># Save the position of the line start for later use during error</span>
-476:         <span class="ruby-comment cmt"># reporting. The line begins after the newline.</span>
-477:         <span class="ruby-ivar">@lineStart</span> = <span class="ruby-ivar">@pos</span>
-478:       <span class="ruby-keyword kw">end</span>
-479:       <span class="ruby-comment cmt"># Since Ruby 1.9 is returning Strings for String#[] we need to emulate</span>
-480:       <span class="ruby-comment cmt"># this for Ruby 1.8.</span>
-481:       <span class="ruby-value str">''</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
-482:     <span class="ruby-keyword kw">end</span></pre>
-					</div>
-					
-				</div>
-
-				
-
-				
-			</div>
-
-		
-			<div id="next-oken-unc-rg-method" class="method-detail ">
-				<a name="method-i-nextTokenFuncArg"></a>
-
-				<div class="method-heading">
-				
-					<span class="method-name">nextTokenFuncArg</span><span
-						class="method-args">()</span>
-					<span class="method-click-advice">click to toggle source</span>
-				
-				</div>
-
-				<div class="method-description">
-					
-					<p>
-Function arguments have the following formats:
-</p>
-<pre>
- &lt;[blockfunc par1=&quot;value1&quot; par2='value2']&gt;
- &lt;-inlinefunc par1=&quot;value1&quot; ... -&gt;</pre>
 					
 
 					
 					<div class="method-source-code"
-						id="next-oken-unc-rg-source">
+						id="href-nd-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 130</span>
-130:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nextTokenFuncArg</span>
-131:       <span class="ruby-identifier">token</span> = [ <span class="ruby-value str">'.'</span>, <span class="ruby-value str">'&lt;END&gt;'</span> ]
-132:       <span class="ruby-keyword kw">while</span> (<span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>)
-133:         <span class="ruby-keyword kw">case</span> <span class="ruby-identifier">c</span>
-134:         <span class="ruby-keyword kw">when</span> <span class="ruby-value str">' '</span>, <span class="ruby-value str">&quot;\n&quot;</span>, <span class="ruby-value str">&quot;\t&quot;</span>
-135:           <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">tok</span> = <span class="ruby-identifier">readBlanks</span>(<span class="ruby-identifier">c</span>))
-136:             <span class="ruby-identifier">token</span> = <span class="ruby-identifier">tok</span>
-137:             <span class="ruby-keyword kw">break</span>
-138:           <span class="ruby-keyword kw">end</span>
-139:         <span class="ruby-keyword kw">when</span> <span class="ruby-value str">'='</span>
-140:           <span class="ruby-keyword kw">return</span> [ <span class="ruby-value str">'_='</span>, <span class="ruby-value str">'='</span> ]
-141:         <span class="ruby-keyword kw">when</span> <span class="ruby-value str">&quot;'&quot;</span>
-142:           <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">readString</span>(<span class="ruby-identifier">c</span>)
-143:         <span class="ruby-keyword kw">when</span> <span class="ruby-value str">'&quot;'</span>
-144:           <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">readString</span>(<span class="ruby-identifier">c</span>)
-145:         <span class="ruby-keyword kw">when</span> <span class="ruby-value str">'a'</span><span class="ruby-operator">..</span><span class="ruby-value str">'z'</span>, <span class="ruby-value str">'A'</span><span class="ruby-operator">..</span><span class="ruby-value str">'Z'</span>, <span class="ruby-value str">'_'</span>
-146:           <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">readId</span>(<span class="ruby-identifier">c</span>)
-147:         <span class="ruby-keyword kw">when</span> <span class="ruby-value str">']'</span>
-148:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">nextChar</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'&gt;'</span>
-149:             <span class="ruby-ivar">@mode</span> = <span class="ruby-value">:wiki</span>
-150:             <span class="ruby-keyword kw">return</span> [ <span class="ruby-value str">'BLOCKFUNCEND'</span>, <span class="ruby-value str">']&gt;'</span> ]
-151:           <span class="ruby-keyword kw">end</span>
-152:           <span class="ruby-identifier">returnChar</span>
-153:         <span class="ruby-keyword kw">when</span> <span class="ruby-value str">'-'</span>
-154:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">nextChar</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'&gt;'</span>
-155:             <span class="ruby-ivar">@mode</span> = <span class="ruby-value">:wiki</span>
-156:             <span class="ruby-keyword kw">return</span> [ <span class="ruby-value str">'INLINEFUNCEND'</span>, <span class="ruby-value str">'-&gt;'</span> ]
-157:           <span class="ruby-keyword kw">end</span>
-158:           <span class="ruby-identifier">returnChar</span>
-159:         <span class="ruby-keyword kw">end</span>
-160:       <span class="ruby-keyword kw">end</span>
-161:       <span class="ruby-identifier">token</span>
-162:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 194</span>
+194:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">hrefEnd</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+195:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-ivar">@hrefLastMode</span>
+196:       <span class="ruby-ivar">@hrefLastMode</span> = <span class="ruby-keyword kw">nil</span>
+197:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span> ]
+198:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1064,13 +897,13 @@ Function arguments have the following formats:
 			</div>
 
 		
-			<div id="next-oken-ef-method" class="method-detail ">
-				<a name="method-i-nextTokenHRef"></a>
+			<div id="href-tart-method" class="method-detail ">
+				<a name="method-i-hrefStart"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">nextTokenHRef</span><span
-						class="method-args">()</span>
+					<span class="method-name">hrefStart</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -1082,43 +915,16 @@ Function arguments have the following formats:
 
 					
 					<div class="method-source-code"
-						id="next-oken-ef-source">
+						id="href-tart-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 188</span>
-188:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nextTokenHRef</span>
-189:       <span class="ruby-identifier">token</span> = [ <span class="ruby-value str">'.'</span>, <span class="ruby-value str">'&lt;END&gt;'</span> ]
-190:       <span class="ruby-keyword kw">while</span> (<span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>)
-191:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span>.<span class="ruby-identifier">nil?</span>
-192:           <span class="ruby-comment cmt"># We've reached the end of the text.</span>
-193:           <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">token</span>
-194:         <span class="ruby-keyword kw">elsif</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;\t&quot;</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>
-195:           <span class="ruby-comment cmt"># Sequences of tabs, spaces and newlines are treated as token</span>
-196:           <span class="ruby-comment cmt"># boundaries, but otherwise they are ignored.</span>
-197:           <span class="ruby-identifier">readSequence</span>(<span class="ruby-value str">&quot; \n\t&quot;</span>)
-198:           <span class="ruby-keyword kw">return</span> [ <span class="ruby-value str">'SPACE'</span>, <span class="ruby-value str">' '</span> ]
-199:         <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'&lt;'</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-operator">!</span><span class="ruby-ivar">@ignoreInlineMarkup</span>
-200:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">nextChar</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'-'</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">isIdStart</span>(<span class="ruby-identifier">peek</span>(<span class="ruby-value">1</span>))
-201:             <span class="ruby-identifier">token</span> = <span class="ruby-identifier">readId</span>(<span class="ruby-value str">''</span>, <span class="ruby-value str">'QUERY'</span>)
-202:             <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">nextChar</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'-'</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">nextChar</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'&gt;'</span>
-203:               <span class="ruby-identifier">error</span>(<span class="ruby-value str">'unterminated_query'</span>,
-204:                     <span class="ruby-value str">&quot;Inline query must be terminated with '-&gt;'&quot;</span>)
-205:             <span class="ruby-keyword kw">end</span>
-206:             <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">token</span>
-207:           <span class="ruby-keyword kw">else</span>
-208:             <span class="ruby-comment cmt"># It's not a query.</span>
-209:             <span class="ruby-identifier">returnChar</span>(<span class="ruby-value">2</span>)
-210:             <span class="ruby-ivar">@ignoreInlineMarkup</span> = <span class="ruby-keyword kw">true</span>
-211:             <span class="ruby-keyword kw">next</span>
-212:           <span class="ruby-keyword kw">end</span>
-213:         <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">']'</span>
-214:           <span class="ruby-ivar">@mode</span> = <span class="ruby-value">:wiki</span>
-215:           <span class="ruby-keyword kw">return</span> [ <span class="ruby-value str">'HREFEND'</span>, <span class="ruby-value str">']'</span> ]
-216:         <span class="ruby-keyword kw">else</span>
-217:           <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">nextTokenWord</span>(<span class="ruby-identifier">c</span>)
-218:         <span class="ruby-keyword kw">end</span>
-219:       <span class="ruby-keyword kw">end</span>
-220:       <span class="ruby-identifier">token</span>
-221:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 186</span>
+186:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">hrefStart</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+187:       <span class="ruby-comment cmt"># When restoring :bol or :bop mode, we need to switch to :inline mode.</span>
+188:       <span class="ruby-ivar">@hrefLastMode</span> = (<span class="ruby-ivar">@scannerMode</span> <span class="ruby-operator">==</span> <span class="ruby-value">:bop</span> <span class="ruby-operator">||</span> <span class="ruby-ivar">@scannerMode</span> <span class="ruby-operator">==</span> <span class="ruby-value">:bol</span>) <span class="ruby-operator">?</span>
+189:                       <span class="ruby-value">:inline</span> <span class="ruby-operator">:</span> <span class="ruby-ivar">@scannerMode</span>
+190:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:href</span>
+191:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span> ]
+192:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1129,61 +935,31 @@ Function arguments have the following formats:
 			</div>
 
 		
-			<div id="next-oken-ewline-method" class="method-detail ">
-				<a name="method-i-nextTokenNewline"></a>
+			<div id="inline-ode-method" class="method-detail ">
+				<a name="method-i-inlineMode"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">nextTokenNewline</span><span
-						class="method-args">()</span>
+					<span class="method-name">inlineMode</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
 
 				<div class="method-description">
 					
-					<p>
-We&#8217;ve just read a newline. Now we need to figure out whether this is
-a LINEBREAK or just a SPACE. This is determined by looking at the next
-character.
-</p>
+					
 					
 
 					
 					<div class="method-source-code"
-						id="next-oken-ewline-source">
+						id="inline-ode-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 379</span>
-379:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nextTokenNewline</span>
-380:       <span class="ruby-comment cmt"># Newlines are pretty important as they can terminate blocks and turn</span>
-381:       <span class="ruby-comment cmt"># the next character into the start of a control sequence.</span>
-382:       <span class="ruby-comment cmt"># Hard linebreaks consist of a newline followed by another newline or</span>
-383:       <span class="ruby-comment cmt"># any of the begin-of-line control characters.</span>
-384:       <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>).<span class="ruby-identifier">nil?</span>
-385:         <span class="ruby-comment cmt"># We hit the end of the text.</span>
-386:         [ <span class="ruby-value str">'.'</span>, <span class="ruby-value str">'&lt;END&gt;'</span> ]
-387:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'&lt;'</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">peekMatch</span>(<span class="ruby-value str">'['</span>)
-388:         <span class="ruby-comment cmt"># the '&lt;' can be a start of a block (BLOCKFUNCSTART) or inline text</span>
-389:         <span class="ruby-comment cmt"># (INLINEFUNCSTART). Only for the first case the linebreak is real.</span>
-390:         <span class="ruby-identifier">returnChar</span> <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>
-391:         <span class="ruby-comment cmt"># The next character may be a control character.</span>
-392:         <span class="ruby-ivar">@beginOfLine</span> = <span class="ruby-keyword kw">true</span>
-393:         [ <span class="ruby-value str">'LINEBREAK'</span>, <span class="ruby-value str">&quot;\n&quot;</span> ]
-394:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-node">&quot;\n*#=-&quot;</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">c</span>)
-395:         <span class="ruby-comment cmt"># These characters correspond to the first characters of a block</span>
-396:         <span class="ruby-comment cmt"># element. When they are found at the begin of the line, the newline</span>
-397:         <span class="ruby-comment cmt"># was really a line break.</span>
-398:         <span class="ruby-identifier">returnChar</span> <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>
-399:         <span class="ruby-comment cmt"># The next character may be a control character.</span>
-400:         <span class="ruby-ivar">@beginOfLine</span> = <span class="ruby-keyword kw">true</span>
-401:         [ <span class="ruby-value str">'LINEBREAK'</span>, <span class="ruby-value str">&quot;\n&quot;</span> ]
-402:       <span class="ruby-keyword kw">else</span>
-403:         <span class="ruby-comment cmt"># Single line breaks are treated as spaces. Return the char after</span>
-404:         <span class="ruby-comment cmt"># the newline and start with this one again.</span>
-405:         <span class="ruby-identifier">returnChar</span>
-406:         [ <span class="ruby-value str">'SPACE'</span>, <span class="ruby-value str">' '</span> ]
-407:       <span class="ruby-keyword kw">end</span>
-408:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 111</span>
+111:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">inlineMode</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+112:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:inline</span>
+113:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span> ]
+114:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1194,13 +970,13 @@ character.
 			</div>
 
 		
-			<div id="next-oken-o-iki-nline-method" class="method-detail ">
-				<a name="method-i-nextTokenNoWikiInline"></a>
+			<div id="linebreak-method" class="method-detail ">
+				<a name="method-i-linebreak"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">nextTokenNoWikiInline</span><span
-						class="method-args">()</span>
+					<span class="method-name">linebreak</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -1212,27 +988,13 @@ character.
 
 					
 					<div class="method-source-code"
-						id="next-oken-o-iki-nline-source">
+						id="linebreak-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 357</span>
-357:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nextTokenNoWikiInline</span>
-358:       <span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>
-359:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span>.<span class="ruby-identifier">nil?</span>
-360:         <span class="ruby-comment cmt"># We've reached the end of the text.</span>
-361:         [ <span class="ruby-value str">'.'</span>, <span class="ruby-value str">'&lt;END&gt;'</span> ]
-362:       <span class="ruby-keyword kw">elsif</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;\t&quot;</span>
-363:         <span class="ruby-comment cmt"># Sequences of tabs or spaces are treated as token boundaries, but</span>
-364:         <span class="ruby-comment cmt"># otherwise they are ignored.</span>
-365:         <span class="ruby-identifier">readSequence</span>(<span class="ruby-value str">&quot; \t&quot;</span>)
-366:         [ <span class="ruby-value str">'SPACE'</span>, <span class="ruby-value str">' '</span> ]
-367:       <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>
-368:         <span class="ruby-identifier">nextTokenNewline</span>
-369:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'&lt;'</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-operator">!</span><span class="ruby-ivar">@ignoreInlineMarkup</span>
-370:         <span class="ruby-identifier">nextTokenOpenAngle</span>
-371:       <span class="ruby-keyword kw">else</span>
-372:         <span class="ruby-identifier">nextTokenWord</span>(<span class="ruby-identifier">c</span>)
-373:       <span class="ruby-keyword kw">end</span>
-374:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 106</span>
+106:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">linebreak</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+107:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:bop</span>
+108:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span> ]
+109:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1243,13 +1005,13 @@ character.
 			</div>
 
 		
-			<div id="next-oken-pen-ngle-method" class="method-detail ">
-				<a name="method-i-nextTokenOpenAngle"></a>
+			<div id="nowiki-nd-method" class="method-detail ">
+				<a name="method-i-nowikiEnd"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">nextTokenOpenAngle</span><span
-						class="method-args">()</span>
+					<span class="method-name">nowikiEnd</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -1261,31 +1023,13 @@ character.
 
 					
 					<div class="method-source-code"
-						id="next-oken-pen-ngle-source">
+						id="nowiki-nd-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 410</span>
-410:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nextTokenOpenAngle</span>
-411:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">peekMatch</span>(<span class="ruby-value str">'nowiki&gt;'</span>)
-412:         <span class="ruby-comment cmt"># Turn most wiki markup interpretation off.</span>
-413:         <span class="ruby-ivar">@pos</span> <span class="ruby-operator">+=</span> <span class="ruby-value str">'nowiki&gt;'</span>.<span class="ruby-identifier">length</span>
-414:         <span class="ruby-ivar">@mode</span> = <span class="ruby-value">:nowiki</span>
-415:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">peekMatch</span>(<span class="ruby-value str">'/nowiki&gt;'</span>)
-416:         <span class="ruby-comment cmt"># Turn most wiki markup interpretation on.</span>
-417:         <span class="ruby-ivar">@pos</span> <span class="ruby-operator">+=</span> <span class="ruby-value str">'/nowiki&gt;'</span>.<span class="ruby-identifier">length</span>
-418:         <span class="ruby-ivar">@mode</span> = <span class="ruby-value">:wiki</span>
-419:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">peekMatch</span>(<span class="ruby-value str">'-'</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-ivar">@mode</span> <span class="ruby-operator">==</span> <span class="ruby-value">:wiki</span>
-420:         <span class="ruby-identifier">nextChar</span>
-421:         <span class="ruby-comment cmt"># Switch the parser to function argument parsing mode.</span>
-422:         <span class="ruby-ivar">@mode</span> = <span class="ruby-value">:funcarg</span>
-423:         <span class="ruby-keyword kw">return</span> [ <span class="ruby-value str">'INLINEFUNCSTART'</span>, <span class="ruby-value str">'&lt;-'</span> ]
-424:       <span class="ruby-keyword kw">else</span>
-425:         <span class="ruby-comment cmt"># We've not found a valid control sequence. Push back the character</span>
-426:         <span class="ruby-comment cmt"># and make sure we treat it as a normal character.</span>
-427:         <span class="ruby-ivar">@ignoreInlineMarkup</span> = <span class="ruby-keyword kw">true</span>
-428:         <span class="ruby-identifier">returnChar</span>
-429:       <span class="ruby-keyword kw">end</span>
-430:       <span class="ruby-keyword kw">nil</span>
-431:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 146</span>
+146:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nowikiEnd</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+147:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:inline</span>
+148:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span> ]
+149:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1296,13 +1040,13 @@ character.
 			</div>
 
 		
-			<div id="next-oken-ef-method" class="method-detail ">
-				<a name="method-i-nextTokenRef"></a>
+			<div id="nowiki-tart-method" class="method-detail ">
+				<a name="method-i-nowikiStart"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">nextTokenRef</span><span
-						class="method-args">()</span>
+					<span class="method-name">nowikiStart</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -1314,32 +1058,13 @@ character.
 
 					
 					<div class="method-source-code"
-						id="next-oken-ef-source">
+						id="nowiki-tart-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 164</span>
-164:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nextTokenRef</span>
-165:       <span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>
-166:       <span class="ruby-keyword kw">return</span> [ <span class="ruby-value str">'.'</span>, <span class="ruby-value str">'&lt;END'</span> ] <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span>.<span class="ruby-identifier">nil?</span>
-167: 
-168:       <span class="ruby-keyword kw">return</span> [ <span class="ruby-value str">'LITERAL'</span>, <span class="ruby-value str">'|'</span> ] <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'|'</span>
-169: 
-170:       <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">&amp;&amp;</span> <span class="ruby-identifier">peek</span> <span class="ruby-operator">==</span> <span class="ruby-value str">']'</span>
-171:         <span class="ruby-identifier">nextChar</span>
-172:         <span class="ruby-ivar">@mode</span> = <span class="ruby-value">:wiki</span>
-173:         <span class="ruby-keyword kw">return</span> [ <span class="ruby-value str">'REFEND'</span>, <span class="ruby-value str">']]'</span> ]
-174:       <span class="ruby-keyword kw">end</span>
-175: 
-176:       <span class="ruby-identifier">token</span> = <span class="ruby-identifier">c</span>
-177:       <span class="ruby-keyword kw">while</span> (<span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>)
-178:         <span class="ruby-keyword kw">break</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span>.<span class="ruby-identifier">nil?</span>
-179:         <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">']'</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">peek</span> <span class="ruby-operator">==</span> <span class="ruby-value str">']'</span>)
-180:           <span class="ruby-identifier">returnChar</span>
-181:           <span class="ruby-keyword kw">break</span>
-182:         <span class="ruby-keyword kw">end</span>
-183:         <span class="ruby-identifier">token</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
-184:       <span class="ruby-keyword kw">end</span>
-185:       [ <span class="ruby-value str">'WORD'</span>, <span class="ruby-identifier">token</span> ]
-186:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 141</span>
+141:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nowikiStart</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+142:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:nowiki</span>
+143:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span> ]
+144:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1350,13 +1075,13 @@ character.
 			</div>
 
 		
-			<div id="next-oken-iki--method" class="method-detail ">
-				<a name="method-i-nextTokenWikiBOL"></a>
+			<div id="number-method" class="method-detail ">
+				<a name="method-i-number"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">nextTokenWikiBOL</span><span
-						class="method-args">()</span>
+					<span class="method-name">number</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -1368,79 +1093,13 @@ character.
 
 					
 					<div class="method-source-code"
-						id="next-oken-iki--source">
+						id="number-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 223</span>
-223:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nextTokenWikiBOL</span>
-224:       <span class="ruby-comment cmt"># Some characters have only a special meaning at the start of the line.</span>
-225:       <span class="ruby-comment cmt"># When the last token pushed the cursor into a new line, this flag is set</span>
-226:       <span class="ruby-comment cmt"># to true.</span>
-227: 
-228:       <span class="ruby-comment cmt"># Reset the flag again.</span>
-229:       <span class="ruby-ivar">@beginOfLine</span> = <span class="ruby-keyword kw">false</span>
-230: 
-231:       <span class="ruby-comment cmt"># We already know that the last newline was a real linebreak. Further</span>
-232:       <span class="ruby-comment cmt"># newlines can safely be ignored.</span>
-233:       <span class="ruby-identifier">readSequence</span>(<span class="ruby-value str">&quot;\n&quot;</span>)
-234: 
-235:       <span class="ruby-comment cmt"># All the lead characters of a token here also need to be registered</span>
-236:       <span class="ruby-comment cmt"># with nextTokenNewline!</span>
-237:       <span class="ruby-keyword kw">case</span> (<span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>)
-238:       <span class="ruby-keyword kw">when</span> <span class="ruby-value str">'='</span>
-239:         <span class="ruby-comment cmt"># Headings start with 2 or more = and must be followed by a space.</span>
-240:         <span class="ruby-identifier">level</span> = <span class="ruby-identifier">readSequenceMax</span>(<span class="ruby-value str">'='</span>, <span class="ruby-value">5</span>)
-241:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">level</span> <span class="ruby-operator">==</span> <span class="ruby-value">1</span>
-242:           <span class="ruby-comment cmt"># 1 = does not mean anything. Push it back and process it as normal</span>
-243:           <span class="ruby-comment cmt"># text further down.</span>
-244:           <span class="ruby-identifier">returnChar</span>
-245:         <span class="ruby-keyword kw">else</span>
-246:           <span class="ruby-comment cmt"># Between the = characters and the title text must be exactly one</span>
-247:           <span class="ruby-comment cmt"># space.</span>
-248:           <span class="ruby-keyword kw">return</span> [ <span class="ruby-node">&quot;TITLE#{level - 1}&quot;</span>, <span class="ruby-value str">'='</span> * <span class="ruby-identifier">level</span> ] <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">nextChar</span> <span class="ruby-operator">==</span> <span class="ruby-value str">' '</span>
-249:           <span class="ruby-comment cmt"># If that's missing, The = are treated as normal text further down.</span>
-250:           <span class="ruby-identifier">returnChar</span>(<span class="ruby-identifier">level</span> <span class="ruby-operator">+</span> <span class="ruby-value">1</span>)
-251:         <span class="ruby-keyword kw">end</span>
-252:       <span class="ruby-keyword kw">when</span> <span class="ruby-value str">'-'</span>
-253:         <span class="ruby-comment cmt"># Horizontal ruler. Must have exactly 4 -.</span>
-254:         <span class="ruby-identifier">level</span> = <span class="ruby-identifier">readSequenceMax</span>(<span class="ruby-value str">'-'</span>, <span class="ruby-value">4</span>)
-255:         <span class="ruby-keyword kw">return</span> [ <span class="ruby-value str">&quot;HLINE&quot;</span>, <span class="ruby-value str">'-'</span> * <span class="ruby-value">4</span> ] <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">level</span> <span class="ruby-operator">==</span> <span class="ruby-value">4</span>
-256:         <span class="ruby-identifier">returnChar</span>(<span class="ruby-identifier">level</span>)
-257:       <span class="ruby-keyword kw">when</span> <span class="ruby-value str">'*'</span>
-258:         <span class="ruby-comment cmt"># Bullet lists start with one to three * characters.</span>
-259:         <span class="ruby-identifier">level</span> = <span class="ruby-identifier">readSequenceMax</span>(<span class="ruby-value str">'*'</span>, <span class="ruby-value">4</span>)
-260:         <span class="ruby-comment cmt"># Between the * characters and the bullet text must be exactly one</span>
-261:         <span class="ruby-comment cmt"># space.</span>
-262:         <span class="ruby-keyword kw">return</span> [ <span class="ruby-node">&quot;BULLET#{level}&quot;</span>, <span class="ruby-value str">'*'</span> * <span class="ruby-identifier">level</span> ] <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">nextChar</span> <span class="ruby-operator">==</span> <span class="ruby-value str">' '</span>
-263:         <span class="ruby-comment cmt"># If that's missing, The # are treated as normal text further down.</span>
-264:         <span class="ruby-identifier">returnChar</span>(<span class="ruby-identifier">level</span> <span class="ruby-operator">+</span> <span class="ruby-value">1</span>)
-265:       <span class="ruby-keyword kw">when</span> <span class="ruby-value str">'#'</span>
-266:         <span class="ruby-comment cmt"># Numbered list start with one to three # characters.</span>
-267:         <span class="ruby-identifier">level</span> = <span class="ruby-identifier">readSequenceMax</span>(<span class="ruby-value str">'#'</span>, <span class="ruby-value">4</span>)
-268:         <span class="ruby-comment cmt"># Between the # characters and the bullet text must be exactly one</span>
-269:         <span class="ruby-comment cmt"># space.</span>
-270:         <span class="ruby-keyword kw">return</span> [ <span class="ruby-node">&quot;NUMBER#{level}&quot;</span>, <span class="ruby-value str">'#'</span> * <span class="ruby-identifier">level</span> ] <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">nextChar</span> <span class="ruby-operator">==</span> <span class="ruby-value str">' '</span>
-271:         <span class="ruby-comment cmt"># If that's missing, The # are treated as normal text further down.</span>
-272:         <span class="ruby-identifier">returnChar</span>(<span class="ruby-identifier">level</span> <span class="ruby-operator">+</span> <span class="ruby-value">1</span>)
-273:       <span class="ruby-keyword kw">when</span> <span class="ruby-value str">'&lt;'</span>
-274:         <span class="ruby-comment cmt"># This may be the start of a block generating function.</span>
-275:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">nextChar</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'['</span>
-276:           <span class="ruby-comment cmt"># Switch the parser to block function argument parsing mode.</span>
-277:           <span class="ruby-ivar">@mode</span> = <span class="ruby-value">:funcarg</span>
-278:           <span class="ruby-keyword kw">return</span> [ <span class="ruby-value str">'BLOCKFUNCSTART'</span>, <span class="ruby-value str">'&lt;['</span> ]
-279:         <span class="ruby-keyword kw">end</span>
-280:         <span class="ruby-comment cmt"># Maybe not.</span>
-281:         <span class="ruby-identifier">returnChar</span>(<span class="ruby-value">2</span>)
-282:       <span class="ruby-keyword kw">when</span> <span class="ruby-value str">' '</span>
-283:         <span class="ruby-comment cmt"># Lines that start with a space are treated as verbatim text.</span>
-284:         <span class="ruby-keyword kw">return</span> [ <span class="ruby-value str">&quot;PRE&quot;</span>, <span class="ruby-identifier">readCode</span> ] <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">c</span> = <span class="ruby-identifier">peek</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">!=</span> <span class="ruby-value str">&quot;\n&quot;</span>
-285:       <span class="ruby-keyword kw">else</span>
-286:         <span class="ruby-comment cmt"># If the character is not a known control character we push it back</span>
-287:         <span class="ruby-comment cmt"># and treat it as normal text further down.</span>
-288:         <span class="ruby-identifier">returnChar</span>
-289:       <span class="ruby-keyword kw">end</span>
-290: 
-291:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">nil</span>
-292:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 130</span>
+130:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">number</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+131:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:inline</span>
+132:       [ <span class="ruby-node">&quot;NUMBER#{match.length - 1}&quot;</span>, <span class="ruby-identifier">match</span> ]
+133:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1451,13 +1110,13 @@ character.
 			</div>
 
 		
-			<div id="next-oken-iki-nline-method" class="method-detail ">
-				<a name="method-i-nextTokenWikiInline"></a>
+			<div id="pre-method" class="method-detail ">
+				<a name="method-i-pre"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">nextTokenWikiInline</span><span
-						class="method-args">()</span>
+					<span class="method-name">pre</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -1469,71 +1128,12 @@ character.
 
 					
 					<div class="method-source-code"
-						id="next-oken-iki-nline-source">
+						id="pre-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 294</span>
-294:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nextTokenWikiInline</span>
-295:       <span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>
-296:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span>.<span class="ruby-identifier">nil?</span>
-297:         <span class="ruby-comment cmt"># We've reached the end of the text.</span>
-298:         [ <span class="ruby-value str">'.'</span>, <span class="ruby-value str">'&lt;END&gt;'</span> ]
-299:       <span class="ruby-keyword kw">elsif</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;\t&quot;</span>
-300:         <span class="ruby-comment cmt"># Sequences of tabs or spaces are treated as token boundaries, but</span>
-301:         <span class="ruby-comment cmt"># otherwise they are ignored.</span>
-302:         <span class="ruby-identifier">readSequence</span>(<span class="ruby-value str">&quot; \t&quot;</span>)
-303:         [ <span class="ruby-value str">'SPACE'</span>, <span class="ruby-value str">' '</span> ]
-304:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;'&quot;</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-operator">!</span><span class="ruby-ivar">@ignoreInlineMarkup</span>
-305:         <span class="ruby-comment cmt"># Sequence of 2 ' means italic, 3 ' means bold, 4 ' means monospaced</span>
-306:         <span class="ruby-comment cmt"># code, 5 ' means italic and bold. Anything else is just normal text.</span>
-307:         <span class="ruby-identifier">level</span> = <span class="ruby-identifier">readSequenceMax</span>(<span class="ruby-value str">&quot;'&quot;</span>, <span class="ruby-value">5</span>)
-308:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">level</span> <span class="ruby-operator">==</span> <span class="ruby-value">2</span>
-309:           [ <span class="ruby-value str">'ITALIC'</span>, <span class="ruby-value str">&quot;'&quot;</span> * <span class="ruby-identifier">level</span> ]
-310:         <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">level</span> <span class="ruby-operator">==</span> <span class="ruby-value">3</span>
-311:           [ <span class="ruby-value str">'BOLD'</span>, <span class="ruby-value str">&quot;'&quot;</span> * <span class="ruby-identifier">level</span> ]
-312:         <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">level</span> <span class="ruby-operator">==</span> <span class="ruby-value">4</span>
-313:           [ <span class="ruby-value str">'CODE'</span>, <span class="ruby-value str">&quot;'&quot;</span> * <span class="ruby-identifier">level</span> ]
-314:         <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">level</span> <span class="ruby-operator">==</span> <span class="ruby-value">5</span>
-315:           [ <span class="ruby-value str">'BOLDITALIC'</span>, <span class="ruby-value str">&quot;'&quot;</span> * <span class="ruby-identifier">level</span> ]
-316:         <span class="ruby-keyword kw">else</span>
-317:           <span class="ruby-comment cmt"># We have not found the right syntax. Treat the found characters as</span>
-318:           <span class="ruby-comment cmt"># normal text.  Push all ' back and start again but ignoring the '</span>
-319:           <span class="ruby-comment cmt"># code for once.</span>
-320:           <span class="ruby-identifier">returnChar</span>(<span class="ruby-identifier">level</span>)
-321:           <span class="ruby-ivar">@ignoreInlineMarkup</span> = <span class="ruby-keyword kw">true</span>
-322:           <span class="ruby-keyword kw">nil</span>
-323:         <span class="ruby-keyword kw">end</span>
-324:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'='</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-operator">!</span><span class="ruby-ivar">@ignoreInlineMarkup</span>
-325:         <span class="ruby-identifier">level</span> = <span class="ruby-identifier">readSequenceMax</span>(<span class="ruby-value str">'='</span>, <span class="ruby-value">5</span>)
-326:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">level</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">1</span>
-327:           [ <span class="ruby-node">&quot;TITLE#{level - 1}END&quot;</span>, <span class="ruby-value str">'='</span> * <span class="ruby-identifier">level</span> ]
-328:         <span class="ruby-keyword kw">else</span>
-329:           <span class="ruby-comment cmt"># We have not found the right syntax. Treat found characters as</span>
-330:           <span class="ruby-comment cmt"># normal text.  Push all = back and start again but ignoring the =</span>
-331:           <span class="ruby-comment cmt"># code for once.</span>
-332:           <span class="ruby-identifier">returnChar</span>(<span class="ruby-identifier">level</span>)
-333:           <span class="ruby-ivar">@ignoreInlineMarkup</span> = <span class="ruby-keyword kw">true</span>
-334:           <span class="ruby-keyword kw">nil</span>
-335:         <span class="ruby-keyword kw">end</span>
-336:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'['</span>
-337:         <span class="ruby-identifier">level</span> = <span class="ruby-identifier">readSequenceMax</span>(<span class="ruby-value str">'['</span>, <span class="ruby-value">2</span>)
-338:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">level</span> <span class="ruby-operator">==</span> <span class="ruby-value">1</span>
-339:           <span class="ruby-ivar">@mode</span> = <span class="ruby-value">:href</span>
-340:           [ <span class="ruby-value str">'HREF'</span> , <span class="ruby-value str">'['</span> ]
-341:         <span class="ruby-keyword kw">else</span>
-342:           <span class="ruby-ivar">@mode</span> = <span class="ruby-value">:ref</span>
-343:           [ <span class="ruby-value str">'REF'</span>, <span class="ruby-value str">'[['</span> ]
-344:         <span class="ruby-keyword kw">end</span>
-345:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">']'</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">peek</span> <span class="ruby-operator">==</span> <span class="ruby-value str">']'</span>
-346:         <span class="ruby-identifier">nextChar</span>
-347:         [ <span class="ruby-value str">'REFEND'</span>, <span class="ruby-value str">']]'</span> ]
-348:       <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>
-349:         <span class="ruby-identifier">nextTokenNewline</span>
-350:       <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'&lt;'</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-operator">!</span><span class="ruby-ivar">@ignoreInlineMarkup</span>
-351:         <span class="ruby-identifier">nextTokenOpenAngle</span>
-352:       <span class="ruby-keyword kw">else</span>
-353:         <span class="ruby-identifier">nextTokenWord</span>(<span class="ruby-identifier">c</span>)
-354:       <span class="ruby-keyword kw">end</span>
-355:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 165</span>
+165:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">pre</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+166:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>] ]
+167:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1544,97 +1144,31 @@ character.
 			</div>
 
 		
-			<div id="next-oken-ord-method" class="method-detail ">
-				<a name="method-i-nextTokenWord"></a>
+			<div id="query-method" class="method-detail ">
+				<a name="method-i-query"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">nextTokenWord</span><span
-						class="method-args">(c)</span>
+					<span class="method-name">query</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
 
 				<div class="method-description">
 					
-					<p>
-<em>c</em> does not match any start of a control sequence, so we read
-characters until we find the end of the word.
-</p>
 					
-
-					
-					<div class="method-source-code"
-						id="next-oken-ord-source">
-<pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 435</span>
-435:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">nextTokenWord</span>(<span class="ruby-identifier">c</span>)
-436:       <span class="ruby-comment cmt"># Reset this flag again.</span>
-437:       <span class="ruby-ivar">@ignoreInlineMarkup</span> = <span class="ruby-keyword kw">false</span>
-438:       <span class="ruby-identifier">str</span> = <span class="ruby-value str">''</span>
-439:       <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
-440:       <span class="ruby-comment cmt"># Now we can collect characters of a word until we hit a whitespace.</span>
-441:       <span class="ruby-keyword kw">while</span> (<span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-operator">!</span><span class="ruby-value str">&quot; \n\t&quot;</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">c</span>)
-442:         <span class="ruby-keyword kw">case</span> <span class="ruby-ivar">@mode</span>
-443:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:wiki</span>
-444:           <span class="ruby-comment cmt"># Or at least two ' characters in a row.</span>
-445:           <span class="ruby-keyword kw">break</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;'&quot;</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">peek</span> <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;'&quot;</span>
-446:           <span class="ruby-comment cmt"># Or a ] or &lt;</span>
-447:           <span class="ruby-keyword kw">break</span> <span class="ruby-keyword kw">if</span> <span class="ruby-value str">']&lt;'</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">c</span>)
-448:         <span class="ruby-keyword kw">when</span> <span class="ruby-value">:href</span>
-449:           <span class="ruby-comment cmt"># Look for - of the end mark -&gt; end ']'</span>
-450:           <span class="ruby-keyword kw">break</span> <span class="ruby-keyword kw">if</span> <span class="ruby-value str">'-]&lt;'</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">c</span>)
-451:         <span class="ruby-keyword kw">else</span>
-452:           <span class="ruby-comment cmt"># Make sure we find the &lt;/nowiki&gt; tag even within a word.</span>
-453:           <span class="ruby-keyword kw">break</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'&lt;'</span>
-454:         <span class="ruby-keyword kw">end</span>
-455:         <span class="ruby-identifier">str</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
-456:       <span class="ruby-keyword kw">end</span>
-457:       <span class="ruby-comment cmt"># Return the character that indicated the word end.</span>
-458:       <span class="ruby-identifier">returnChar</span>
-459:       [ <span class="ruby-value str">'WORD'</span>, <span class="ruby-identifier">str</span> ]
-460:     <span class="ruby-keyword kw">end</span></pre>
-					</div>
-					
-				</div>
-
-				
-
-				
-			</div>
-
-		
-			<div id="peek-method" class="method-detail ">
-				<a name="method-i-peek"></a>
-
-				<div class="method-heading">
-				
-					<span class="method-name">peek</span><span
-						class="method-args">(lookAhead = 1)</span>
-					<span class="method-click-advice">click to toggle source</span>
-				
-				</div>
-
-				<div class="method-description">
-					
-					<p>
-Return a character further up the text without moving the cursor.
-<em>lookAhead</em> is the number of characters to peek ahead. A value of 0
-would return the last character provided by nextChar().
-</p>
 					
 
 					
 					<div class="method-source-code"
-						id="peek-source">
+						id="query-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 510</span>
-510:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">peek</span>(<span class="ruby-identifier">lookAhead</span> = <span class="ruby-value">1</span>)
-511:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">nil</span> <span class="ruby-keyword kw">if</span> (<span class="ruby-ivar">@pos</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">lookAhead</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>) <span class="ruby-operator">&gt;=</span> <span class="ruby-ivar">@textLength</span>
-512:       <span class="ruby-comment cmt"># Since Ruby 1.9 is returning Strings for String#[] we need to emulate</span>
-513:       <span class="ruby-comment cmt"># this for Ruby 1.8.</span>
-514:       <span class="ruby-value str">''</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-ivar">@text</span>[<span class="ruby-ivar">@pos</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">lookAhead</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>]
-515:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 181</span>
+181:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">query</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+182:       <span class="ruby-comment cmt"># Remove &lt;- and -&gt;.</span>
+183:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>[<span class="ruby-value">2</span><span class="ruby-operator">..</span><span class="ruby-value">3</span>] ]
+184:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1645,35 +1179,32 @@ would return the last character provided by nextChar().
 			</div>
 
 		
-			<div id="peek-atch-method" class="method-detail ">
-				<a name="method-i-peekMatch"></a>
+			<div id="quotes-method" class="method-detail ">
+				<a name="method-i-quotes"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">peekMatch</span><span
-						class="method-args">(word)</span>
+					<span class="method-name">quotes</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
 
 				<div class="method-description">
 					
-					<p>
-Return true if the next characters match exactly the character sequence in
-word.
-</p>
+					
 					
 
 					
 					<div class="method-source-code"
-						id="peek-atch-source">
+						id="quotes-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 519</span>
-519:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">peekMatch</span>(<span class="ruby-identifier">word</span>)
-520:       <span class="ruby-comment cmt"># Since Ruby 1.9 is returning Strings for String#[] we need to emulate</span>
-521:       <span class="ruby-comment cmt"># this for Ruby 1.8.</span>
-522:       (<span class="ruby-value str">''</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-ivar">@text</span>[<span class="ruby-ivar">@pos</span>, <span class="ruby-identifier">word</span>.<span class="ruby-identifier">length</span>]) <span class="ruby-operator">==</span> <span class="ruby-identifier">word</span>
-523:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 135</span>
+135:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">quotes</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+136:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:inline</span>
+137:       <span class="ruby-identifier">types</span> = [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">'ITALIC'</span>, <span class="ruby-value str">'BOLD'</span> , <span class="ruby-value str">'CODE'</span>, <span class="ruby-value str">'BOLDITALIC'</span> ]
+138:       [ <span class="ruby-identifier">types</span>[<span class="ruby-identifier">match</span>.<span class="ruby-identifier">length</span>], <span class="ruby-identifier">match</span> ]
+139:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1684,13 +1215,13 @@ word.
 			</div>
 
 		
-			<div id="read-lanks-method" class="method-detail ">
-				<a name="method-i-readBlanks"></a>
+			<div id="ref-nd-method" class="method-detail ">
+				<a name="method-i-refEnd"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">readBlanks</span><span
-						class="method-args">(c)</span>
+					<span class="method-name">refEnd</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -1702,18 +1233,13 @@ word.
 
 					
 					<div class="method-source-code"
-						id="read-lanks-source">
+						id="ref-nd-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 573</span>
-573:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">readBlanks</span>(<span class="ruby-identifier">c</span>)
-574:       <span class="ruby-identifier">loop</span> <span class="ruby-keyword kw">do</span>
-575:         <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">&amp;&amp;</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">!=</span> <span class="ruby-value str">&quot;\n&quot;</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">!=</span> <span class="ruby-value str">&quot;\t&quot;</span>
-576:           <span class="ruby-identifier">returnChar</span>
-577:           <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">nil</span>
-578:         <span class="ruby-keyword kw">end</span>
-579:         <span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>
-580:       <span class="ruby-keyword kw">end</span>
-581:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 205</span>
+205:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">refEnd</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+206:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:inline</span>
+207:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span> ]
+208:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1724,50 +1250,31 @@ word.
 			</div>
 
 		
-			<div id="read-ode-method" class="method-detail ">
-				<a name="method-i-readCode"></a>
+			<div id="ref-tart-method" class="method-detail ">
+				<a name="method-i-refStart"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">readCode</span><span
-						class="method-args">()</span>
+					<span class="method-name">refStart</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
 
 				<div class="method-description">
 					
-					<p>
-Read a block of pre-formatted text. All lines must start with a space
-character.
-</p>
+					
 					
 
 					
 					<div class="method-source-code"
-						id="read-ode-source">
+						id="ref-tart-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 552</span>
-552:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">readCode</span>
-553:       <span class="ruby-identifier">tok</span> = <span class="ruby-value str">''</span>
-554:       <span class="ruby-identifier">loop</span> <span class="ruby-keyword kw">do</span>
-555:         <span class="ruby-comment cmt"># Read until the end of the line</span>
-556:         <span class="ruby-keyword kw">while</span> (<span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">!=</span> <span class="ruby-value str">&quot;\n&quot;</span>
-557:           <span class="ruby-comment cmt"># Append a found characters.</span>
-558:           <span class="ruby-identifier">tok</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
-559:         <span class="ruby-keyword kw">end</span>
-560:         <span class="ruby-comment cmt"># Append the newline.</span>
-561:         <span class="ruby-identifier">tok</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
-562:         <span class="ruby-comment cmt"># If the next line does not start with a space, we've reached the end of</span>
-563:         <span class="ruby-comment cmt"># the code block.</span>
-564:         <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">!=</span> <span class="ruby-value str">' '</span>
-565:           <span class="ruby-keyword kw">break</span>
-566:         <span class="ruby-keyword kw">end</span>
-567:       <span class="ruby-keyword kw">end</span>
-568:       <span class="ruby-identifier">returnChar</span>
-569:       <span class="ruby-ivar">@beginOfLine</span> = <span class="ruby-keyword kw">true</span>
-570:       <span class="ruby-identifier">tok</span>
-571:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 200</span>
+200:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">refStart</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+201:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:ref</span>
+202:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span> ]
+203:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1778,13 +1285,13 @@ character.
 			</div>
 
 		
-			<div id="read-d-method" class="method-detail ">
-				<a name="method-i-readId"></a>
+			<div id="space-method" class="method-detail ">
+				<a name="method-i-space"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">readId</span><span
-						class="method-args">(c, tokenType = 'ID')</span>
+					<span class="method-name">space</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -1796,20 +1303,18 @@ character.
 
 					
 					<div class="method-source-code"
-						id="read-d-source">
+						id="space-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 587</span>
-587:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">readId</span>(<span class="ruby-identifier">c</span>, <span class="ruby-identifier">tokenType</span> = <span class="ruby-value str">'ID'</span>)
-588:       <span class="ruby-identifier">token</span> = <span class="ruby-value str">&quot;&quot;</span>
-589:       <span class="ruby-identifier">token</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
-590:       <span class="ruby-keyword kw">while</span> (<span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>) <span class="ruby-operator">&amp;&amp;</span>
-591:             ((<span class="ruby-value str">'a'</span><span class="ruby-operator">..</span><span class="ruby-value str">'z'</span>) <span class="ruby-operator">===</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">||</span> (<span class="ruby-value str">'A'</span><span class="ruby-operator">..</span><span class="ruby-value str">'Z'</span>) <span class="ruby-operator">===</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">||</span> (<span class="ruby-value str">'0'</span><span class="ruby-operator">..</span><span class="ruby-value str">'9'</span>)  <span class="ruby-operator">===</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">||</span>
-592:              <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">'_'</span>)
-593:         <span class="ruby-identifier">token</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
-594:       <span class="ruby-keyword kw">end</span>
-595:       <span class="ruby-identifier">returnChar</span>
-596:       <span class="ruby-keyword kw">return</span> [ <span class="ruby-identifier">tokenType</span>, <span class="ruby-identifier">token</span> ]
-597:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 96</span>
+ 96:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">space</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+ 97:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">match</span>.<span class="ruby-identifier">index</span>(<span class="ruby-value str">&quot;\n&quot;</span>)
+ 98:         <span class="ruby-comment cmt"># If the match contains a linebreak we switch to :bol mode.</span>
+ 99:         <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:bol</span>
+100:         <span class="ruby-comment cmt"># And return an empty string.</span>
+101:         <span class="ruby-identifier">match</span> = <span class="ruby-value str">''</span>
+102:       <span class="ruby-keyword kw">end</span>
+103:       [<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span> ]
+104:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1820,84 +1325,32 @@ character.
 			</div>
 
 		
-			<div id="read-equence-method" class="method-detail ">
-				<a name="method-i-readSequence"></a>
+			<div id="sq-tring-method" class="method-detail ">
+				<a name="method-i-sqString"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">readSequence</span><span
-						class="method-args">(chars)</span>
+					<span class="method-name">sqString</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
 
 				<div class="method-description">
 					
-					<p>
-Read a sequence of characters that are all contained in the <em>chars</em>
-Array. If a character is found that is not in <em>chars</em> the method
-returns the so far found sequence of chars as <a
-href="../String.html">String</a>.
-</p>
-					
-
 					
-					<div class="method-source-code"
-						id="read-equence-source">
-<pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 528</span>
-528:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">readSequence</span>(<span class="ruby-identifier">chars</span>)
-529:       <span class="ruby-identifier">sequence</span> = <span class="ruby-value str">''</span>
-530:       <span class="ruby-keyword kw">while</span> (<span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">chars</span>.<span class="ruby-identifier">index</span>(<span class="ruby-identifier">c</span>)
-531:         <span class="ruby-identifier">sequence</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
-532:       <span class="ruby-keyword kw">end</span>
-533:       <span class="ruby-comment cmt"># Push back the character that did no longer match.</span>
-534:       <span class="ruby-identifier">returnChar</span>
-535:       <span class="ruby-identifier">sequence</span>
-536:     <span class="ruby-keyword kw">end</span></pre>
-					</div>
-					
-				</div>
-
-				
-
-				
-			</div>
-
-		
-			<div id="read-equence-ax-method" class="method-detail ">
-				<a name="method-i-readSequenceMax"></a>
-
-				<div class="method-heading">
-				
-					<span class="method-name">readSequenceMax</span><span
-						class="method-args">(c, max = 3)</span>
-					<span class="method-click-advice">click to toggle source</span>
-				
-				</div>
-
-				<div class="method-description">
-					
-					<p>
-Read a sequence of <em>c</em> characters until a different character is
-found or <em>max</em> count has been reached.
-</p>
 					
 
 					
 					<div class="method-source-code"
-						id="read-equence-ax-source">
+						id="sq-tring-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 540</span>
-540:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">readSequenceMax</span>(<span class="ruby-identifier">c</span>, <span class="ruby-identifier">max</span> = <span class="ruby-value">3</span>)
-541:       <span class="ruby-identifier">i</span> = <span class="ruby-value">1</span>
-542:       <span class="ruby-keyword kw">while</span> <span class="ruby-identifier">nextChar</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">i</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">max</span>
-543:         <span class="ruby-identifier">i</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
-544:       <span class="ruby-keyword kw">end</span>
-545:       <span class="ruby-comment cmt"># Return the non matching character.</span>
-546:       <span class="ruby-identifier">returnChar</span>
-547:       <span class="ruby-identifier">i</span>
-548:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 175</span>
+175:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">sqString</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+176:       <span class="ruby-comment cmt"># Remove first and last character and remove backslashes from quoted</span>
+177:       <span class="ruby-comment cmt"># single quotes.</span>
+178:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">2</span>].<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/\\'/</span>, <span class="ruby-value str">&quot;'&quot;</span>) ]
+179:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1908,13 +1361,13 @@ found or <em>max</em> count has been reached.
 			</div>
 
 		
-			<div id="read-tring-method" class="method-detail ">
-				<a name="method-i-readString"></a>
+			<div id="title-nd-method" class="method-detail ">
+				<a name="method-i-titleEnd"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">readString</span><span
-						class="method-args">(terminator)</span>
+					<span class="method-name">titleEnd</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
@@ -1926,24 +1379,12 @@ found or <em>max</em> count has been reached.
 
 					
 					<div class="method-source-code"
-						id="read-tring-source">
+						id="title-nd-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 599</span>
-599:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">readString</span>(<span class="ruby-identifier">terminator</span>)
-600:       <span class="ruby-identifier">token</span> = <span class="ruby-value str">&quot;&quot;</span>
-601:       <span class="ruby-keyword kw">while</span> (<span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">terminator</span>
-602:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">==</span> <span class="ruby-value str">&quot;\\&quot;</span>
-603:           <span class="ruby-comment cmt"># Terminators can be used as regular characters when prefixed by a \.</span>
-604:           <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">c</span> = <span class="ruby-identifier">nextChar</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">c</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">terminator</span>
-605:             <span class="ruby-comment cmt"># \ followed by non-terminator. Just add both.</span>
-606:             <span class="ruby-identifier">token</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-value str">&quot;\\&quot;</span>
-607:           <span class="ruby-keyword kw">end</span>
-608:         <span class="ruby-keyword kw">end</span>
-609:         <span class="ruby-identifier">token</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span>
-610:       <span class="ruby-keyword kw">end</span>
-611: 
-612:       [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-identifier">token</span> ]
-613:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 121</span>
+121:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">titleEnd</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+122:       [ <span class="ruby-node">&quot;TITLE#{match.length - 1}END&quot;</span>, <span class="ruby-identifier">match</span> ]
+123:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1954,50 +1395,31 @@ found or <em>max</em> count has been reached.
 			</div>
 
 		
-			<div id="return-har-method" class="method-detail ">
-				<a name="method-i-returnChar"></a>
+			<div id="title-tart-method" class="method-detail ">
+				<a name="method-i-titleStart"></a>
 
 				<div class="method-heading">
 				
-					<span class="method-name">returnChar</span><span
-						class="method-args">(n = 1)</span>
+					<span class="method-name">titleStart</span><span
+						class="method-args">(type, match)</span>
 					<span class="method-click-advice">click to toggle source</span>
 				
 				</div>
 
 				<div class="method-description">
 					
-					<p>
-Return one or more characters. <em>n</em> is the number of characters to
-move back the cursor.
-</p>
+					
 					
 
 					
 					<div class="method-source-code"
-						id="return-har-source">
+						id="title-tart-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 486</span>
-486:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">returnChar</span>(<span class="ruby-identifier">n</span> = <span class="ruby-value">1</span>)
-487:       <span class="ruby-identifier">crossedNewline</span> = <span class="ruby-keyword kw">false</span>
-488:       <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@pos</span> <span class="ruby-operator">&lt;=</span> <span class="ruby-ivar">@textLength</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-ivar">@pos</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-identifier">n</span>
-489:         <span class="ruby-comment cmt"># Check for newlines and update @lineNo accordingly.</span>
-490:         <span class="ruby-identifier">n</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
-491:           <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@text</span>[<span class="ruby-ivar">@pos</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">i</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>] <span class="ruby-operator">==</span> <span class="ruby-value">\n\</span>
-492:             <span class="ruby-identifier">crossedNewline</span> = <span class="ruby-keyword kw">true</span>
-493:             <span class="ruby-ivar">@lineNo</span> <span class="ruby-operator">-=</span> <span class="ruby-value">1</span>
-494:           <span class="ruby-keyword kw">end</span>
-495:         <span class="ruby-keyword kw">end</span>
-496:         <span class="ruby-ivar">@pos</span> <span class="ruby-operator">-=</span> <span class="ruby-identifier">n</span>
-497:       <span class="ruby-keyword kw">end</span>
-498: 
-499:       <span class="ruby-comment cmt"># If we have crossed a newline during rewind, we have to find the start of</span>
-500:       <span class="ruby-comment cmt"># the current line again.</span>
-501:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">crossedNewline</span>
-502:         <span class="ruby-ivar">@lineStart</span> = <span class="ruby-ivar">@pos</span>
-503:         <span class="ruby-ivar">@lineStart</span> <span class="ruby-operator">-=</span> <span class="ruby-value">1</span> <span class="ruby-keyword kw">while</span> <span class="ruby-ivar">@lineStart</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-ivar">@text</span>[<span class="ruby-ivar">@lineStart</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>] <span class="ruby-operator">!=</span> <span class="ruby-value">\n\</span>
-504:       <span class="ruby-keyword kw">end</span>
-505:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/RichTextScanner.rb, line 116</span>
+116:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">titleStart</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+117:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:inline</span>
+118:       [ <span class="ruby-node">&quot;TITLE#{match.length - 1}&quot;</span>, <span class="ruby-identifier">match</span> ]
+119:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>