taskjuggler 0.0.6 → 0.0.7

data/doc/TaskJuggler/ProjectFileScanner.html

@@ -215,6 +215,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>
@@ -287,8 +291,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>
@@ -353,6 +355,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>
@@ -399,8 +403,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>
@@ -441,6 +443,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>
@@ -551,6 +555,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>
@@ -634,143 +640,134 @@ to detect the tokens of the TJP syntax.
 <pre>
      <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 21</span>
  21:     <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>)
- 22:       <span class="ruby-keyword kw">super</span>
- 23: 
- 24:       <span class="ruby-identifier">tokenPatterns</span> = [
- 25:         <span class="ruby-comment cmt"># Any white spaces</span>
- 26:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/\s+/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'newPos'</span>) ],
- 27: 
- 28:         <span class="ruby-comment cmt"># Single line comments starting with #</span>
- 29:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-node">/#.*\n?/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'newPos'</span>) ],
- 30: 
- 31:         <span class="ruby-comment cmt"># C++ style single line comments starting with //</span>
- 32:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/\/\/.*\n?/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'newPos'</span>) ],
- 33: 
- 34:         <span class="ruby-comment cmt"># C style single line comment /* .. */.</span>
- 35:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/\/\*.*\*\//</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'newPos'</span>) ],
- 36: 
- 37:         <span class="ruby-comment cmt"># C style multi line comment: We need three patterns here. The first</span>
- 38:         <span class="ruby-comment cmt"># one is for the start of the string. It switches the scanner mode to</span>
- 39:         <span class="ruby-comment cmt"># the :cppComment mode.</span>
- 40:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/\/\*([^*]*[^\/]|.*)\n/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startComment'</span>) ],
- 41:         <span class="ruby-comment cmt"># This is the string end pattern. It switches back to tjp mode.</span>
- 42:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/.*\*\//</span>, <span class="ruby-value">:cppComment</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'endComment'</span>) ],
- 43:         <span class="ruby-comment cmt"># This pattern matches string lines that contain neither the start,</span>
- 44:         <span class="ruby-comment cmt"># nor the end of the string.</span>
- 45:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/^.*\n/</span>, <span class="ruby-value">:cppComment</span> ],
- 46: 
- 47:         <span class="ruby-comment cmt"># Macro Call: This case is more complicated because we want to replace</span>
- 48:         <span class="ruby-comment cmt"># macro calls inside of numbers, strings and identifiers. For this to</span>
- 49:         <span class="ruby-comment cmt"># work, macro calls may have a prefix that looks like a number, a part</span>
- 50:         <span class="ruby-comment cmt"># of a string or an identifier. This prefix is preserved and</span>
- 51:         <span class="ruby-comment cmt"># re-injected into the scanner together with the expanded text. Macro</span>
- 52:         <span class="ruby-comment cmt"># calls may span multiple lines. The ${ and the macro name must be in</span>
- 53:         <span class="ruby-comment cmt"># the first line. Arguments that span multiple lines are not</span>
- 54:         <span class="ruby-comment cmt"># supported. As above, we need rules for the start, the end and lines</span>
- 55:         <span class="ruby-comment cmt"># with neither start nor end. Macro calls inside of strings need a</span>
- 56:         <span class="ruby-comment cmt"># special start pattern that is active in the string modes. Both</span>
- 57:         <span class="ruby-comment cmt"># patterns switch the scanner to macroCall mode.</span>
- 58:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/([-a-zA-Z_0-9&gt;:.+]*|&quot;(\\&quot;|[^&quot;])*|'(\\'|[^'])*|-8&lt;-.*)?\$\{\s*([a-zA-Z_]\w*)(\s*&quot;(\\&quot;|[^&quot;])*&quot;)*/</span>,
- 59:           <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startMacroCall'</span>) ],
- 60:         <span class="ruby-comment cmt"># This pattern is similar to the previous one, but is active inside of</span>
- 61:         <span class="ruby-comment cmt"># multi-line strings. The corresponding rule for sizzors strings</span>
- 62:         <span class="ruby-comment cmt"># can be found below.</span>
- 63:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/(\\&quot;|[^&quot;])*\$\{\s*([a-zA-Z_]\w*)(\s*&quot;(\\&quot;|[^&quot;])*&quot;)*/</span>,
- 64:           <span class="ruby-value">:dqString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startMacroCall'</span>) ],
- 65:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/(\\'|[^'])*\$\{\s*([a-zA-Z_]\w*)(\s*&quot;(\\&quot;|[^&quot;])*&quot;)*/</span>,
- 66:           <span class="ruby-value">:sqString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startMacroCall'</span>) ],
- 67:         <span class="ruby-comment cmt"># This pattern matches the end of a macro call. It injects the prefix</span>
- 68:         <span class="ruby-comment cmt"># and the expanded macro into the scanner again. The mode is restored</span>
- 69:         <span class="ruby-comment cmt"># to the previous mode.</span>
- 70:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/(\s*&quot;(\\&quot;|[^&quot;])*&quot;)*\s*\}/</span>, <span class="ruby-value">:macroCall</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'endMacroCall'</span>) ],
- 71:         <span class="ruby-comment cmt"># This pattern collects macro call arguments in lines that contain</span>
- 72:         <span class="ruby-comment cmt"># neither the start nor the end of the macro.</span>
- 73:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/.*\n/</span>, <span class="ruby-value">:macroCall</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'midMacroCall'</span>) ],
- 74: 
- 75:         <span class="ruby-comment cmt"># An ID with a colon suffix: foo:</span>
- 76:         [ <span class="ruby-value str">'ID_WITH_COLON'</span>, <span class="ruby-regexp re">/[a-zA-Z_]\w*:/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'chop'</span>) ],
- 77: 
- 78:         <span class="ruby-comment cmt"># An absolute ID: a.b.c</span>
- 79:         [ <span class="ruby-value str">'ABSOLUTE_ID'</span>, <span class="ruby-regexp re">/[a-zA-Z_]\w*(\.[a-zA-Z_]\w*)+/</span> ],
- 80: 
- 81:         <span class="ruby-comment cmt"># A normal ID: bar</span>
- 82:         [ <span class="ruby-value str">'ID'</span>, <span class="ruby-regexp re">/[a-zA-Z_]\w*/</span> ],
- 83: 
- 84:         <span class="ruby-comment cmt"># A date</span>
- 85:         [ <span class="ruby-value str">'DATE'</span>, <span class="ruby-regexp re">/\d{4}-\d{1,2}-\d{1,2}(-\d{1,2}:\d{1,2}(:\d{1,2})?(-[-+]?\d{4})?)?/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'to_date'</span>) ],
- 86: 
- 87:         <span class="ruby-comment cmt"># A time of day</span>
- 88:         [ <span class="ruby-value str">'TIME'</span>, <span class="ruby-regexp re">/\d{1,2}:\d{2}/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'to_time'</span>) ],
- 89: 
- 90:         <span class="ruby-comment cmt"># A floating point number (e. g. 3.143)</span>
- 91:         [ <span class="ruby-value str">'FLOAT'</span>, <span class="ruby-regexp re">/\d*\.\d+/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'to_f'</span>) ],
- 92: 
- 93:         <span class="ruby-comment cmt"># An integer number</span>
- 94:         [ <span class="ruby-value str">'INTEGER'</span>, <span class="ruby-regexp re">/\d+/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'to_i'</span>) ],
- 95: 
- 96:         <span class="ruby-comment cmt"># Multi line string enclosed with double quotes. The string may</span>
- 97:         <span class="ruby-comment cmt"># contain double quotes prefixed by a backslash. The first rule</span>
- 98:         <span class="ruby-comment cmt"># switches the scanner to dqString mode.</span>
- 99:         [ <span class="ruby-value str">'nil'</span>, <span class="ruby-regexp re">/&quot;(\\&quot;|[^&quot;])*/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startStringDQ'</span>) ],
-100:         <span class="ruby-comment cmt"># Any line not containing the start or end.</span>
-101:         [ <span class="ruby-value str">'nil'</span>, <span class="ruby-regexp re">/^(\\&quot;|[^&quot;])*\n/</span>, <span class="ruby-value">:dqString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'midStringDQ'</span>) ],
-102:         <span class="ruby-comment cmt"># The end of the string.</span>
-103:         [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-regexp re">/(\\&quot;|[^&quot;])*&quot;/</span>, <span class="ruby-value">:dqString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'endStringDQ'</span>) ],
-104: 
-105:         <span class="ruby-comment cmt"># Multi line string enclosed with single quotes.</span>
-106:         [ <span class="ruby-value str">'nil'</span>, <span class="ruby-regexp re">/'(\\'|[^'])*/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startStringSQ'</span>) ],
-107:         <span class="ruby-comment cmt"># Any line not containing the start or end.</span>
-108:         [ <span class="ruby-value str">'nil'</span>, <span class="ruby-regexp re">/^(\\'|[^'])*\n/</span>, <span class="ruby-value">:sqString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'midStringSQ'</span>) ],
-109:         <span class="ruby-comment cmt"># The end of the string.</span>
-110:         [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-regexp re">/(\\'|[^'])*'/</span>, <span class="ruby-value">:sqString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'endStringSQ'</span>) ],
-111: 
-112:         <span class="ruby-comment cmt"># Scizzors marked string -8&lt;- ... -&gt;8-: The opening mark must be the</span>
-113:         <span class="ruby-comment cmt"># last thing in the line. The indentation of the first line after the</span>
-114:         <span class="ruby-comment cmt"># opening mark determines the indentation for all following lines. So,</span>
-115:         <span class="ruby-comment cmt"># we first switch the scanner to szrString1 mode.</span>
-116:         [ <span class="ruby-value str">'nil'</span>, <span class="ruby-regexp re">/-8&lt;-.*\n/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startStringSZR'</span>) ],
-117:         <span class="ruby-comment cmt"># Since the first line can be the last line (empty string case), we</span>
-118:         <span class="ruby-comment cmt"># need to detect the end in szrString1 and szrString mode. The</span>
-119:         <span class="ruby-comment cmt"># patterns switch the scanner back to tjp mode.</span>
-120:         [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-regexp re">/\s*-&gt;8-/</span>, <span class="ruby-value">:szrString1</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'endStringSZR'</span>) ],
-121:         [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-regexp re">/\s*-&gt;8-/</span>, <span class="ruby-value">:szrString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'endStringSZR'</span>) ],
-122:         <span class="ruby-comment cmt"># This rule handles macros inside of sizzors strings.</span>
-123:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/.*\$\{\s*([a-zA-Z_]\w*)(\s*&quot;(\\&quot;|[^&quot;])*&quot;)*/</span>,
-124:           [ <span class="ruby-value">:szrString</span>, <span class="ruby-value">:szrString1</span> ], <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startMacroCall'</span>) ],
-125:         <span class="ruby-comment cmt"># Any line not containing the start or end.</span>
-126:         [ <span class="ruby-value str">'nil'</span>, <span class="ruby-regexp re">/.*\n/</span>, <span class="ruby-value">:szrString1</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'firstStringSZR'</span>) ],
-127:         [ <span class="ruby-value str">'nil'</span>, <span class="ruby-regexp re">/.*\n/</span>, <span class="ruby-value">:szrString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'midStringSZR'</span>) ],
-128: 
-129:         <span class="ruby-comment cmt"># Single line macro definition</span>
-130:         [ <span class="ruby-value str">'MACRO'</span>, <span class="ruby-regexp re">/\[.*\]\n/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'chop2nl'</span>) ],
-131: 
-132:         <span class="ruby-comment cmt"># Multi line macro definition: The pattern switches the scanner into</span>
-133:         <span class="ruby-comment cmt"># macroDef mode.</span>
-134:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/\[.*\n/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startMacroDef'</span>) ],
-135:         <span class="ruby-comment cmt"># The end of the macro is marked by a ']' that is immediately followed</span>
-136:         <span class="ruby-comment cmt"># by a line break. It switches the scanner back to tjp mode.</span>
-137:         [ <span class="ruby-value str">'MACRO'</span>, <span class="ruby-regexp re">/.*\]\n/</span>, <span class="ruby-value">:macroDef</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'endMacroDef'</span>) ],
-138:         <span class="ruby-comment cmt"># Any line not containing the start or end.</span>
-139:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/.*\n/</span>, <span class="ruby-value">:macroDef</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'midMacroDef'</span>) ],
-140: 
-141:         <span class="ruby-comment cmt"># Some multi-char literals.</span>
-142:         [ <span class="ruby-value str">'LITERAL'</span>, <span class="ruby-regexp re">/&lt;=?/</span> ],
-143:         [ <span class="ruby-value str">'LITERAL'</span>, <span class="ruby-regexp re">/&gt;=?/</span> ],
-144:         [ <span class="ruby-value str">'LITERAL'</span>, <span class="ruby-regexp re">/!=?/</span> ],
-145: 
-146:         <span class="ruby-comment cmt"># Everything else is returned as a single-char literal.</span>
-147:         [ <span class="ruby-value str">'LITERAL'</span>, <span class="ruby-regexp re">/./</span> ]
-148:       ]
-149: 
-150:       <span class="ruby-identifier">tokenPatterns</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">pat</span><span class="ruby-operator">|</span>
-151:         <span class="ruby-identifier">type</span> = <span class="ruby-identifier">pat</span>[<span class="ruby-value">0</span>]
-152:         <span class="ruby-identifier">regExp</span> = <span class="ruby-identifier">pat</span>[<span class="ruby-value">1</span>]
-153:         <span class="ruby-identifier">mode</span> = <span class="ruby-identifier">pat</span>[<span class="ruby-value">2</span>] <span class="ruby-operator">||</span> <span class="ruby-value">:tjp</span>
-154:         <span class="ruby-identifier">postProc</span> = <span class="ruby-identifier">pat</span>[<span class="ruby-value">3</span>]
-155:         <span class="ruby-identifier">addPattern</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">regExp</span>, <span class="ruby-identifier">mode</span>, <span class="ruby-identifier">postProc</span>)
-156:       <span class="ruby-keyword kw">end</span>
-157:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
-158:     <span class="ruby-keyword kw">end</span></pre>
+ 22:       <span class="ruby-identifier">tokenPatterns</span> = [
+ 23:         <span class="ruby-comment cmt"># Any white spaces</span>
+ 24:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/\s+/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'newPos'</span>) ],
+ 25: 
+ 26:         <span class="ruby-comment cmt"># Single line comments starting with #</span>
+ 27:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-node">/#.*\n?/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'newPos'</span>) ],
+ 28: 
+ 29:         <span class="ruby-comment cmt"># C++ style single line comments starting with //</span>
+ 30:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/\/\/.*\n?/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'newPos'</span>) ],
+ 31: 
+ 32:         <span class="ruby-comment cmt"># C style single line comment /* .. */.</span>
+ 33:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/\/\*.*\*\//</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'newPos'</span>) ],
+ 34: 
+ 35:         <span class="ruby-comment cmt"># C style multi line comment: We need three patterns here. The first</span>
+ 36:         <span class="ruby-comment cmt"># one is for the start of the string. It switches the scanner mode to</span>
+ 37:         <span class="ruby-comment cmt"># the :cppComment mode.</span>
+ 38:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/\/\*([^*]*[^\/]|.*)\n/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startComment'</span>) ],
+ 39:         <span class="ruby-comment cmt"># This is the string end pattern. It switches back to tjp mode.</span>
+ 40:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/.*\*\//</span>, <span class="ruby-value">:cppComment</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'endComment'</span>) ],
+ 41:         <span class="ruby-comment cmt"># This pattern matches string lines that contain neither the start,</span>
+ 42:         <span class="ruby-comment cmt"># nor the end of the string.</span>
+ 43:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/^.*\n/</span>, <span class="ruby-value">:cppComment</span> ],
+ 44: 
+ 45:         <span class="ruby-comment cmt"># Macro Call: This case is more complicated because we want to replace</span>
+ 46:         <span class="ruby-comment cmt"># macro calls inside of numbers, strings and identifiers. For this to</span>
+ 47:         <span class="ruby-comment cmt"># work, macro calls may have a prefix that looks like a number, a part</span>
+ 48:         <span class="ruby-comment cmt"># of a string or an identifier. This prefix is preserved and</span>
+ 49:         <span class="ruby-comment cmt"># re-injected into the scanner together with the expanded text. Macro</span>
+ 50:         <span class="ruby-comment cmt"># calls may span multiple lines. The ${ and the macro name must be in</span>
+ 51:         <span class="ruby-comment cmt"># the first line. Arguments that span multiple lines are not</span>
+ 52:         <span class="ruby-comment cmt"># supported. As above, we need rules for the start, the end and lines</span>
+ 53:         <span class="ruby-comment cmt"># with neither start nor end. Macro calls inside of strings need a</span>
+ 54:         <span class="ruby-comment cmt"># special start pattern that is active in the string modes. Both</span>
+ 55:         <span class="ruby-comment cmt"># patterns switch the scanner to macroCall mode.</span>
+ 56:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/([-a-zA-Z_0-9&gt;:.+]*|&quot;(\\&quot;|[^&quot;])*?|'(\\'|[^'])*?)?\$\{\s*([a-zA-Z_]\w*)(\s*&quot;(\\&quot;|[^&quot;])*&quot;)*/</span>,
+ 57:           <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startMacroCall'</span>) ],
+ 58:         <span class="ruby-comment cmt"># This pattern is similar to the previous one, but is active inside of</span>
+ 59:         <span class="ruby-comment cmt"># multi-line strings. The corresponding rule for sizzors strings</span>
+ 60:         <span class="ruby-comment cmt"># can be found below.</span>
+ 61:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/(\\&quot;|[^&quot;])*?\$\{\s*([a-zA-Z_]\w*)(\s*&quot;(\\&quot;|[^&quot;])*&quot;)*/</span>,
+ 62:           <span class="ruby-value">:dqString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startMacroCall'</span>) ],
+ 63:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/(\\'|[^'])*?\$\{\s*([a-zA-Z_]\w*)(\s*&quot;(\\&quot;|[^&quot;])*&quot;)*/</span>,
+ 64:           <span class="ruby-value">:sqString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startMacroCall'</span>) ],
+ 65:         <span class="ruby-comment cmt"># This pattern matches the end of a macro call. It injects the prefix</span>
+ 66:         <span class="ruby-comment cmt"># and the expanded macro into the scanner again. The mode is restored</span>
+ 67:         <span class="ruby-comment cmt"># to the previous mode.</span>
+ 68:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/(\s*&quot;(\\&quot;|[^&quot;])*&quot;)*\s*\}/</span>, <span class="ruby-value">:macroCall</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'endMacroCall'</span>) ],
+ 69:         <span class="ruby-comment cmt"># This pattern collects macro call arguments in lines that contain</span>
+ 70:         <span class="ruby-comment cmt"># neither the start nor the end of the macro.</span>
+ 71:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/.*\n/</span>, <span class="ruby-value">:macroCall</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'midMacroCall'</span>) ],
+ 72: 
+ 73:         <span class="ruby-comment cmt"># An ID with a colon suffix: foo:</span>
+ 74:         [ <span class="ruby-value str">'ID_WITH_COLON'</span>, <span class="ruby-regexp re">/[a-zA-Z_]\w*:/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'chop'</span>) ],
+ 75: 
+ 76:         <span class="ruby-comment cmt"># An absolute ID: a.b.c</span>
+ 77:         [ <span class="ruby-value str">'ABSOLUTE_ID'</span>, <span class="ruby-regexp re">/[a-zA-Z_]\w*(\.[a-zA-Z_]\w*)+/</span> ],
+ 78: 
+ 79:         <span class="ruby-comment cmt"># A normal ID: bar</span>
+ 80:         [ <span class="ruby-value str">'ID'</span>, <span class="ruby-regexp re">/[a-zA-Z_]\w*/</span> ],
+ 81: 
+ 82:         <span class="ruby-comment cmt"># A date</span>
+ 83:         [ <span class="ruby-value str">'DATE'</span>, <span class="ruby-regexp re">/\d{4}-\d{1,2}-\d{1,2}(-\d{1,2}:\d{1,2}(:\d{1,2})?(-[-+]?\d{4})?)?/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'to_date'</span>) ],
+ 84: 
+ 85:         <span class="ruby-comment cmt"># A time of day</span>
+ 86:         [ <span class="ruby-value str">'TIME'</span>, <span class="ruby-regexp re">/\d{1,2}:\d{2}/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'to_time'</span>) ],
+ 87: 
+ 88:         <span class="ruby-comment cmt"># A floating point number (e. g. 3.143)</span>
+ 89:         [ <span class="ruby-value str">'FLOAT'</span>, <span class="ruby-regexp re">/\d*\.\d+/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'to_f'</span>) ],
+ 90: 
+ 91:         <span class="ruby-comment cmt"># An integer number</span>
+ 92:         [ <span class="ruby-value str">'INTEGER'</span>, <span class="ruby-regexp re">/\d+/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'to_i'</span>) ],
+ 93: 
+ 94:         <span class="ruby-comment cmt"># Multi line string enclosed with double quotes. The string may</span>
+ 95:         <span class="ruby-comment cmt"># contain double quotes prefixed by a backslash. The first rule</span>
+ 96:         <span class="ruby-comment cmt"># switches the scanner to dqString mode.</span>
+ 97:         [ <span class="ruby-value str">'nil'</span>, <span class="ruby-regexp re">/&quot;(\\&quot;|[^&quot;])*/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startStringDQ'</span>) ],
+ 98:         <span class="ruby-comment cmt"># Any line not containing the start or end.</span>
+ 99:         [ <span class="ruby-value str">'nil'</span>, <span class="ruby-regexp re">/^(\\&quot;|[^&quot;])*\n/</span>, <span class="ruby-value">:dqString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'midStringDQ'</span>) ],
+100:         <span class="ruby-comment cmt"># The end of the string.</span>
+101:         [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-regexp re">/(\\&quot;|[^&quot;])*&quot;/</span>, <span class="ruby-value">:dqString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'endStringDQ'</span>) ],
+102: 
+103:         <span class="ruby-comment cmt"># Multi line string enclosed with single quotes.</span>
+104:         [ <span class="ruby-value str">'nil'</span>, <span class="ruby-regexp re">/'(\\'|[^'])*/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startStringSQ'</span>) ],
+105:         <span class="ruby-comment cmt"># Any line not containing the start or end.</span>
+106:         [ <span class="ruby-value str">'nil'</span>, <span class="ruby-regexp re">/^(\\'|[^'])*\n/</span>, <span class="ruby-value">:sqString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'midStringSQ'</span>) ],
+107:         <span class="ruby-comment cmt"># The end of the string.</span>
+108:         [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-regexp re">/(\\'|[^'])*'/</span>, <span class="ruby-value">:sqString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'endStringSQ'</span>) ],
+109: 
+110:         <span class="ruby-comment cmt"># Scizzors marked string -8&lt;- ... -&gt;8-: The opening mark must be the</span>
+111:         <span class="ruby-comment cmt"># last thing in the line. The indentation of the first line after the</span>
+112:         <span class="ruby-comment cmt"># opening mark determines the indentation for all following lines. So,</span>
+113:         <span class="ruby-comment cmt"># we first switch the scanner to szrString1 mode.</span>
+114:         [ <span class="ruby-value str">'nil'</span>, <span class="ruby-regexp re">/-8&lt;-.*\n/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startStringSZR'</span>) ],
+115:         <span class="ruby-comment cmt"># Since the first line can be the last line (empty string case), we</span>
+116:         <span class="ruby-comment cmt"># need to detect the end in szrString1 and szrString mode. The</span>
+117:         <span class="ruby-comment cmt"># patterns switch the scanner back to tjp mode.</span>
+118:         [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-regexp re">/\s*-&gt;8-/</span>, <span class="ruby-value">:szrString1</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'endStringSZR'</span>) ],
+119:         [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-regexp re">/\s*-&gt;8-/</span>, <span class="ruby-value">:szrString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'endStringSZR'</span>) ],
+120:         <span class="ruby-comment cmt"># This rule handles macros inside of sizzors strings.</span>
+121:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/.*?\$\{\s*([a-zA-Z_]\w*)(\s*&quot;(\\&quot;|[^&quot;])*&quot;)*/</span>,
+122:           [ <span class="ruby-value">:szrString</span>, <span class="ruby-value">:szrString1</span> ], <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startMacroCall'</span>) ],
+123:         <span class="ruby-comment cmt"># Any line not containing the start or end.</span>
+124:         [ <span class="ruby-value str">'nil'</span>, <span class="ruby-regexp re">/.*\n/</span>, <span class="ruby-value">:szrString1</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'firstStringSZR'</span>) ],
+125:         [ <span class="ruby-value str">'nil'</span>, <span class="ruby-regexp re">/.*\n/</span>, <span class="ruby-value">:szrString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'midStringSZR'</span>) ],
+126: 
+127:         <span class="ruby-comment cmt"># Single line macro definition</span>
+128:         [ <span class="ruby-value str">'MACRO'</span>, <span class="ruby-regexp re">/\[.*\]\n/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'chop2nl'</span>) ],
+129: 
+130:         <span class="ruby-comment cmt"># Multi line macro definition: The pattern switches the scanner into</span>
+131:         <span class="ruby-comment cmt"># macroDef mode.</span>
+132:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/\[.*\n/</span>, <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startMacroDef'</span>) ],
+133:         <span class="ruby-comment cmt"># The end of the macro is marked by a ']' that is immediately followed</span>
+134:         <span class="ruby-comment cmt"># by a line break. It switches the scanner back to tjp mode.</span>
+135:         [ <span class="ruby-value str">'MACRO'</span>, <span class="ruby-regexp re">/.*\]\n/</span>, <span class="ruby-value">:macroDef</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'endMacroDef'</span>) ],
+136:         <span class="ruby-comment cmt"># Any line not containing the start or end.</span>
+137:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/.*\n/</span>, <span class="ruby-value">:macroDef</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'midMacroDef'</span>) ],
+138: 
+139:         <span class="ruby-comment cmt"># Some multi-char literals.</span>
+140:         [ <span class="ruby-value str">'LITERAL'</span>, <span class="ruby-regexp re">/&lt;=?/</span> ],
+141:         [ <span class="ruby-value str">'LITERAL'</span>, <span class="ruby-regexp re">/&gt;=?/</span> ],
+142:         [ <span class="ruby-value str">'LITERAL'</span>, <span class="ruby-regexp re">/!=?/</span> ],
+143: 
+144:         <span class="ruby-comment cmt"># Everything else is returned as a single-char literal.</span>
+145:         [ <span class="ruby-value str">'LITERAL'</span>, <span class="ruby-regexp re">/./</span> ]
+146:       ]
+147: 
+148:       <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">:tjp</span>)
+149:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -807,10 +804,10 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="chop-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 187</span>
-187:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">chop</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-188:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>[<span class="ruby-value">0</span><span class="ruby-operator">..</span><span class="ruby-value">2</span>] ]
-189:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 178</span>
+178:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">chop</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+179:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>[<span class="ruby-value">0</span><span class="ruby-operator">..</span><span class="ruby-value">2</span>] ]
+180:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -841,11 +838,11 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="chop--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 191</span>
-191:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">chop2</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-192:       <span class="ruby-comment cmt"># Remove first and last character.</span>
-193:       [ <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>] ]
-194:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 182</span>
+182:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">chop2</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+183:       <span class="ruby-comment cmt"># Remove first and last character.</span>
+184:       [ <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>] ]
+185:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -876,11 +873,11 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="chop-nl-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 196</span>
-196:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">chop2nl</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-197:       <span class="ruby-comment cmt"># remove first and last 2 characters.</span>
-198:       [ <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">3</span>] ]
-199:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 187</span>
+187:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">chop2nl</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+188:       <span class="ruby-comment cmt"># remove first and last 2 characters.</span>
+189:       [ <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">3</span>] ]
+190:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -911,11 +908,11 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="end-omment-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 206</span>
-206:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">endComment</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-207:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
-208:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-209:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 197</span>
+197:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">endComment</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+198:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
+199:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+200:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -946,48 +943,48 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="end-acro-all-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 320</span>
-320:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">endMacroCall</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-321:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-ivar">@macroCallPreviousMode</span>
-322:       <span class="ruby-ivar">@macroCall</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 311</span>
+311:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">endMacroCall</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+312:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-ivar">@macroCallPreviousMode</span>
+313:       <span class="ruby-ivar">@macroCall</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>
+314: 
+315:       <span class="ruby-comment cmt"># Store any characters that precede the ${ in prefix and remove it from</span>
+316:       <span class="ruby-comment cmt"># @macroCall.</span>
+317:       <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">macroStart</span> = <span class="ruby-ivar">@macroCall</span>.<span class="ruby-identifier">index</span>(<span class="ruby-value str">'${'</span>)) <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
+318:         <span class="ruby-identifier">prefix</span> = <span class="ruby-ivar">@macroCall</span>[<span class="ruby-value">0</span><span class="ruby-operator">..</span>(<span class="ruby-identifier">macroStart</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)]
+319:         <span class="ruby-ivar">@macroCall</span> = <span class="ruby-ivar">@macroCall</span>[<span class="ruby-identifier">macroStart</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>]
+320:       <span class="ruby-keyword kw">else</span>
+321:         <span class="ruby-identifier">prefix</span> = <span class="ruby-value str">''</span>
+322:       <span class="ruby-keyword kw">end</span>
 323: 
-324:       <span class="ruby-comment cmt"># Store any characters that precede the ${ in prefix and remove it from</span>
-325:       <span class="ruby-comment cmt"># @macroCall.</span>
-326:       <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">macroStart</span> = <span class="ruby-ivar">@macroCall</span>.<span class="ruby-identifier">index</span>(<span class="ruby-value str">'${'</span>)) <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
-327:         <span class="ruby-identifier">prefix</span> = <span class="ruby-ivar">@macroCall</span>[<span class="ruby-value">0</span><span class="ruby-operator">..</span>(<span class="ruby-identifier">macroStart</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)]
-328:         <span class="ruby-ivar">@macroCall</span> = <span class="ruby-ivar">@macroCall</span>[<span class="ruby-identifier">macroStart</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>]
+324:       <span class="ruby-comment cmt"># Remove '${' and '}'</span>
+325:       <span class="ruby-identifier">argsStr</span> = <span class="ruby-ivar">@macroCall</span>[<span class="ruby-value">2</span><span class="ruby-operator">..</span><span class="ruby-value">2</span>]
+326:       <span class="ruby-comment cmt"># Extract the macro name.</span>
+327:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">argsStr</span>.<span class="ruby-identifier">index</span>(<span class="ruby-value str">' '</span>).<span class="ruby-identifier">nil?</span>
+328:         <span class="ruby-identifier">expandMacro</span>(<span class="ruby-identifier">prefix</span>, [ <span class="ruby-identifier">argsStr</span> ])
 329:       <span class="ruby-keyword kw">else</span>
-330:         <span class="ruby-identifier">prefix</span> = <span class="ruby-value str">''</span>
-331:       <span class="ruby-keyword kw">end</span>
-332: 
-333:       <span class="ruby-comment cmt"># Remove '${' and '}'</span>
-334:       <span class="ruby-identifier">argsStr</span> = <span class="ruby-ivar">@macroCall</span>[<span class="ruby-value">2</span><span class="ruby-operator">..</span><span class="ruby-value">2</span>]
-335:       <span class="ruby-comment cmt"># Extract the macro name.</span>
-336:       <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">nameEnd</span> = <span class="ruby-identifier">argsStr</span>.<span class="ruby-identifier">index</span>(<span class="ruby-value str">' '</span>)).<span class="ruby-identifier">nil?</span>
-337:         <span class="ruby-identifier">expandMacro</span>(<span class="ruby-identifier">prefix</span>, [ <span class="ruby-identifier">argsStr</span> ])
-338:       <span class="ruby-keyword kw">else</span>
-339:         <span class="ruby-identifier">macroName</span> = <span class="ruby-identifier">argsStr</span>[<span class="ruby-value">0</span>, <span class="ruby-identifier">argsStr</span>.<span class="ruby-identifier">index</span>(<span class="ruby-value str">' '</span>)]
-340:         <span class="ruby-comment cmt"># Remove the name part from argsStr</span>
-341:         <span class="ruby-identifier">argsStr</span> = <span class="ruby-identifier">argsStr</span>[<span class="ruby-identifier">macroName</span>.<span class="ruby-identifier">length</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>]
-342:         <span class="ruby-comment cmt"># Array to hold the arguments</span>
-343:         <span class="ruby-identifier">args</span> = []
-344:         <span class="ruby-comment cmt"># We use another StringScanner to clean the double quotes.</span>
-345:         <span class="ruby-identifier">scanner</span> = <span class="ruby-constant">StringScanner</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">argsStr</span>)
-346:         <span class="ruby-keyword kw">while</span> (<span class="ruby-identifier">scanner</span>.<span class="ruby-identifier">scan</span>(<span class="ruby-regexp re">/\s*&quot;/</span>))
-347:           <span class="ruby-identifier">args</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">scanner</span>.<span class="ruby-identifier">scan</span>(<span class="ruby-regexp re">/(\\&quot;|[^&quot;])*/</span>).<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/\\&quot;/</span>, <span class="ruby-value str">'&quot;'</span>)
-348:           <span class="ruby-identifier">scanner</span>.<span class="ruby-identifier">scan</span>(<span class="ruby-regexp re">/&quot;\s*/</span>)
-349:         <span class="ruby-keyword kw">end</span>
-350: 
-351:         <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">scanner</span>.<span class="ruby-identifier">eos?</span>
-352:           <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Junk found at end of macro: #{argsStr[scanner.pos..-1]}&quot;</span>
-353:         <span class="ruby-keyword kw">end</span>
-354: 
-355:         <span class="ruby-comment cmt"># Expand the macro and inject it into the scanner.</span>
-356:         <span class="ruby-identifier">expandMacro</span>(<span class="ruby-identifier">prefix</span>, [ <span class="ruby-identifier">macroName</span> ] <span class="ruby-operator">+</span> <span class="ruby-identifier">args</span>)
-357:       <span class="ruby-keyword kw">end</span>
-358: 
-359:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-360:     <span class="ruby-keyword kw">end</span></pre>
+330:         <span class="ruby-identifier">macroName</span> = <span class="ruby-identifier">argsStr</span>[<span class="ruby-value">0</span>, <span class="ruby-identifier">argsStr</span>.<span class="ruby-identifier">index</span>(<span class="ruby-value str">' '</span>)]
+331:         <span class="ruby-comment cmt"># Remove the name part from argsStr</span>
+332:         <span class="ruby-identifier">argsStr</span> = <span class="ruby-identifier">argsStr</span>[<span class="ruby-identifier">macroName</span>.<span class="ruby-identifier">length</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>]
+333:         <span class="ruby-comment cmt"># Array to hold the arguments</span>
+334:         <span class="ruby-identifier">args</span> = []
+335:         <span class="ruby-comment cmt"># We use another StringScanner to clean the double quotes.</span>
+336:         <span class="ruby-identifier">scanner</span> = <span class="ruby-constant">StringScanner</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">argsStr</span>)
+337:         <span class="ruby-keyword kw">while</span> (<span class="ruby-identifier">scanner</span>.<span class="ruby-identifier">scan</span>(<span class="ruby-regexp re">/\s*&quot;/</span>))
+338:           <span class="ruby-identifier">args</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">scanner</span>.<span class="ruby-identifier">scan</span>(<span class="ruby-regexp re">/(\\&quot;|[^&quot;])*/</span>).<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/\\&quot;/</span>, <span class="ruby-value str">'&quot;'</span>)
+339:           <span class="ruby-identifier">scanner</span>.<span class="ruby-identifier">scan</span>(<span class="ruby-regexp re">/&quot;\s*/</span>)
+340:         <span class="ruby-keyword kw">end</span>
+341: 
+342:         <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">scanner</span>.<span class="ruby-identifier">eos?</span>
+343:           <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Junk found at end of macro: #{argsStr[scanner.pos..-1]}&quot;</span>
+344:         <span class="ruby-keyword kw">end</span>
+345: 
+346:         <span class="ruby-comment cmt"># Expand the macro and inject it into the scanner.</span>
+347:         <span class="ruby-identifier">expandMacro</span>(<span class="ruby-identifier">prefix</span>, [ <span class="ruby-identifier">macroName</span> ] <span class="ruby-operator">+</span> <span class="ruby-identifier">args</span>)
+348:       <span class="ruby-keyword kw">end</span>
+349: 
+350:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+351:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1018,13 +1015,13 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="end-acro-ef-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 301</span>
-301:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">endMacroDef</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-302:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
-303:       <span class="ruby-comment cmt"># Remove &quot;]\n&quot;</span>
-304:       <span class="ruby-ivar">@macroDef</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>[<span class="ruby-value">0</span><span class="ruby-operator">..</span><span class="ruby-value">3</span>]
-305:       [ <span class="ruby-value str">'MACRO'</span>, <span class="ruby-ivar">@macroDef</span> ]
-306:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 292</span>
+292:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">endMacroDef</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+293:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
+294:       <span class="ruby-comment cmt"># Remove &quot;]\n&quot;</span>
+295:       <span class="ruby-ivar">@macroDef</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>[<span class="ruby-value">0</span><span class="ruby-operator">..</span><span class="ruby-value">3</span>]
+296:       [ <span class="ruby-value str">'MACRO'</span>, <span class="ruby-ivar">@macroDef</span> ]
+297:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1055,13 +1052,13 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="end-tring--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 224</span>
-224:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">endStringDQ</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-225:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
-226:       <span class="ruby-comment cmt"># Remove the trailing &quot; and remove the backslashes from escaped &quot;.</span>
-227:       <span class="ruby-ivar">@string</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>[<span class="ruby-value">0</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>)
-228:       [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-ivar">@string</span> ]
-229:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 215</span>
+215:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">endStringDQ</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+216:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
+217:       <span class="ruby-comment cmt"># Remove the trailing &quot; and remove the backslashes from escaped &quot;.</span>
+218:       <span class="ruby-ivar">@string</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>[<span class="ruby-value">0</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>)
+219:       [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-ivar">@string</span> ]
+220:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1092,13 +1089,13 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="end-tring--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 244</span>
-244:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">endStringSQ</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-245:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
-246:       <span class="ruby-comment cmt"># Remove the trailing ' and remove the backslashes from escaped '.</span>
-247:       <span class="ruby-ivar">@string</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>[<span class="ruby-value">0</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>)
-248:       [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-ivar">@string</span> ]
-249:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 235</span>
+235:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">endStringSQ</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+236:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
+237:       <span class="ruby-comment cmt"># Remove the trailing ' and remove the backslashes from escaped '.</span>
+238:       <span class="ruby-ivar">@string</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>[<span class="ruby-value">0</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>)
+239:       [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-ivar">@string</span> ]
+240:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1129,11 +1126,11 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="end-tring--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 284</span>
-284:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">endStringSZR</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-285:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
-286:       [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-ivar">@string</span> ]
-287:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 275</span>
+275:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">endStringSZR</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+276:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
+277:       [ <span class="ruby-value str">'STRING'</span>, <span class="ruby-ivar">@string</span> ]
+278:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1164,13 +1161,13 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="first-tring--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 266</span>
-266:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">firstStringSZR</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-267:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:szrString</span>
-268:       <span class="ruby-comment cmt"># Split the leading indentation and the rest of the string.</span>
-269:       <span class="ruby-identifier">foo</span>, <span class="ruby-ivar">@indent</span>, <span class="ruby-ivar">@string</span> = *<span class="ruby-regexp re">/(\s*)(.*\n)/</span>.<span class="ruby-identifier">match</span>(<span class="ruby-identifier">match</span>)
-270:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-271:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 257</span>
+257:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">firstStringSZR</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+258:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:szrString</span>
+259:       <span class="ruby-comment cmt"># Split the leading indentation and the rest of the string.</span>
+260:       <span class="ruby-ivar">@indent</span>, <span class="ruby-ivar">@string</span> = *<span class="ruby-regexp re">/(\s*)(.*\n)/</span>.<span class="ruby-identifier">match</span>(<span class="ruby-identifier">match</span>)[<span class="ruby-value">1</span>, <span class="ruby-value">2</span>]
+261:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+262:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1201,11 +1198,11 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="mid-acro-all-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 315</span>
-315:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">midMacroCall</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-316:       <span class="ruby-ivar">@macroCall</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>
-317:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-318:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 306</span>
+306:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">midMacroCall</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+307:       <span class="ruby-ivar">@macroCall</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>
+308:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+309:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1236,11 +1233,11 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="mid-acro-ef-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 296</span>
-296:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">midMacroDef</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-297:       <span class="ruby-ivar">@macroDef</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>
-298:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-299:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 287</span>
+287:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">midMacroDef</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+288:       <span class="ruby-ivar">@macroDef</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>
+289:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+290:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1271,12 +1268,12 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="mid-tring--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 218</span>
-218:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">midStringDQ</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-219:       <span class="ruby-comment cmt"># Remove the backslashes from escaped &quot;.</span>
-220:       <span class="ruby-ivar">@string</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>.<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/\\&quot;/</span>, <span class="ruby-value str">'&quot;'</span>)
-221:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-222:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 209</span>
+209:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">midStringDQ</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+210:       <span class="ruby-comment cmt"># Remove the backslashes from escaped &quot;.</span>
+211:       <span class="ruby-ivar">@string</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>.<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/\\&quot;/</span>, <span class="ruby-value str">'&quot;'</span>)
+212:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+213:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1307,12 +1304,12 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="mid-tring--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 238</span>
-238:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">midStringSQ</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-239:       <span class="ruby-comment cmt"># Remove the backslashes from escaped '.</span>
-240:       <span class="ruby-ivar">@string</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>.<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/\\'/</span>, <span class="ruby-value str">&quot;'&quot;</span>)
-241:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-242:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 229</span>
+229:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">midStringSQ</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+230:       <span class="ruby-comment cmt"># Remove the backslashes from escaped '.</span>
+231:       <span class="ruby-ivar">@string</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>.<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/\\'/</span>, <span class="ruby-value str">&quot;'&quot;</span>)
+232:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+233:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1343,17 +1340,17 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="mid-tring--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 273</span>
-273:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">midStringSZR</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-274:       <span class="ruby-comment cmt"># Ignore all the characters from the begining of match that are the same</span>
-275:       <span class="ruby-comment cmt"># in @indent.</span>
-276:       <span class="ruby-identifier">i</span> = <span class="ruby-value">0</span>
-277:       <span class="ruby-keyword kw">while</span> <span class="ruby-identifier">i</span> <span class="ruby-operator">&lt;</span> <span class="ruby-ivar">@indent</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-ivar">@indent</span>[<span class="ruby-identifier">i</span>] <span class="ruby-operator">==</span> <span class="ruby-identifier">match</span>[<span class="ruby-identifier">i</span>]
-278:         <span class="ruby-identifier">i</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
-279:       <span class="ruby-keyword kw">end</span>
-280:       <span class="ruby-ivar">@string</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>[<span class="ruby-identifier">i</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>]
-281:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-282:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 264</span>
+264:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">midStringSZR</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+265:       <span class="ruby-comment cmt"># Ignore all the characters from the begining of match that are the same</span>
+266:       <span class="ruby-comment cmt"># in @indent.</span>
+267:       <span class="ruby-identifier">i</span> = <span class="ruby-value">0</span>
+268:       <span class="ruby-keyword kw">while</span> <span class="ruby-identifier">i</span> <span class="ruby-operator">&lt;</span> <span class="ruby-ivar">@indent</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-ivar">@indent</span>[<span class="ruby-identifier">i</span>] <span class="ruby-operator">==</span> <span class="ruby-identifier">match</span>[<span class="ruby-identifier">i</span>]
+269:         <span class="ruby-identifier">i</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
+270:       <span class="ruby-keyword kw">end</span>
+271:       <span class="ruby-ivar">@string</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>[<span class="ruby-identifier">i</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>]
+272:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+273:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1384,11 +1381,11 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="new-os-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 182</span>
-182:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">newPos</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-183:       <span class="ruby-ivar">@startOfToken</span> = <span class="ruby-identifier">sourceFileInfo</span>
-184:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-185:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 173</span>
+173:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">newPos</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+174:       <span class="ruby-ivar">@startOfToken</span> = <span class="ruby-identifier">sourceFileInfo</span>
+175:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+176:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1419,11 +1416,11 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="start-omment-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 201</span>
-201:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">startComment</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-202:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:cppComment</span>
-203:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-204:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 192</span>
+192:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">startComment</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+193:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:cppComment</span>
+194:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+195:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1454,13 +1451,13 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="start-acro-all-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 308</span>
-308:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">startMacroCall</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-309:       <span class="ruby-ivar">@macroCallPreviousMode</span> = <span class="ruby-ivar">@scannerMode</span>
-310:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:macroCall</span>
-311:       <span class="ruby-ivar">@macroCall</span> = <span class="ruby-identifier">match</span>
-312:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-313:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 299</span>
+299:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">startMacroCall</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+300:       <span class="ruby-ivar">@macroCallPreviousMode</span> = <span class="ruby-ivar">@scannerMode</span>
+301:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:macroCall</span>
+302:       <span class="ruby-ivar">@macroCall</span> = <span class="ruby-identifier">match</span>
+303:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+304:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1491,13 +1488,13 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="start-acro-ef-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 289</span>
-289:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">startMacroDef</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-290:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:macroDef</span>
-291:       <span class="ruby-comment cmt"># Remove the opening '['</span>
-292:       <span class="ruby-ivar">@macroDef</span> = <span class="ruby-identifier">match</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>]
-293:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-294:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 280</span>
+280:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">startMacroDef</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+281:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:macroDef</span>
+282:       <span class="ruby-comment cmt"># Remove the opening '['</span>
+283:       <span class="ruby-ivar">@macroDef</span> = <span class="ruby-identifier">match</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>]
+284:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+285:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1528,13 +1525,13 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="start-tring--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 211</span>
-211:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">startStringDQ</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-212:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:dqString</span>
-213:       <span class="ruby-comment cmt"># Remove the opening &quot; and remove the backslashes from escaped &quot;.</span>
-214:       <span class="ruby-ivar">@string</span> = <span class="ruby-identifier">match</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>].<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/\\&quot;/</span>, <span class="ruby-value str">'&quot;'</span>)
-215:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-216:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 202</span>
+202:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">startStringDQ</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+203:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:dqString</span>
+204:       <span class="ruby-comment cmt"># Remove the opening &quot; and remove the backslashes from escaped &quot;.</span>
+205:       <span class="ruby-ivar">@string</span> = <span class="ruby-identifier">match</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>].<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/\\&quot;/</span>, <span class="ruby-value str">'&quot;'</span>)
+206:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+207:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1565,13 +1562,13 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="start-tring--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 231</span>
-231:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">startStringSQ</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-232:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:sqString</span>
-233:       <span class="ruby-comment cmt"># Remove the opening ' and remove the backslashes from escaped '.</span>
-234:       <span class="ruby-ivar">@string</span> = <span class="ruby-identifier">match</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>].<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/\\'/</span>, <span class="ruby-value str">&quot;'&quot;</span>)
-235:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-236:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 222</span>
+222:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">startStringSQ</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+223:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:sqString</span>
+224:       <span class="ruby-comment cmt"># Remove the opening ' and remove the backslashes from escaped '.</span>
+225:       <span class="ruby-ivar">@string</span> = <span class="ruby-identifier">match</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">1</span>].<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/\\'/</span>, <span class="ruby-value str">&quot;'&quot;</span>)
+226:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+227:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1602,21 +1599,21 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="start-tring--source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 251</span>
-251:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">startStringSZR</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-252:       <span class="ruby-comment cmt"># There should be a line break after the cut mark, but we allow some</span>
-253:       <span class="ruby-comment cmt"># spaces between the mark and the line break as well.</span>
-254:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">match</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">!=</span> <span class="ruby-value">5</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-regexp re">/-8&lt;-\s*\n$/</span>.<span class="ruby-identifier">match</span>(<span class="ruby-identifier">match</span>).<span class="ruby-identifier">nil?</span>
-255:         <span class="ruby-ivar">@lineDelta</span> = <span class="ruby-value">1</span>
-256:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'junk_after_cut'</span>,
-257:               <span class="ruby-value str">'The cut mark -8&lt;- must be immediately followed by a '</span> <span class="ruby-operator">+</span>
-258:               <span class="ruby-value str">'line break.'</span>)
-259:       <span class="ruby-keyword kw">end</span>
-260:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:szrString1</span>
-261:       <span class="ruby-ivar">@startOfToken</span> = <span class="ruby-identifier">sourceFileInfo</span>
-262:       <span class="ruby-ivar">@string</span> = <span class="ruby-value str">''</span>
-263:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-264:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 242</span>
+242:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">startStringSZR</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+243:       <span class="ruby-comment cmt"># There should be a line break after the cut mark, but we allow some</span>
+244:       <span class="ruby-comment cmt"># spaces between the mark and the line break as well.</span>
+245:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">match</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">!=</span> <span class="ruby-value">5</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-regexp re">/-8&lt;-\s*\n$/</span>.<span class="ruby-identifier">match</span>(<span class="ruby-identifier">match</span>).<span class="ruby-identifier">nil?</span>
+246:         <span class="ruby-ivar">@lineDelta</span> = <span class="ruby-value">1</span>
+247:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'junk_after_cut'</span>,
+248:               <span class="ruby-value str">'The cut mark -8&lt;- must be immediately followed by a '</span> <span class="ruby-operator">+</span>
+249:               <span class="ruby-value str">'line break.'</span>)
+250:       <span class="ruby-keyword kw">end</span>
+251:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:szrString1</span>
+252:       <span class="ruby-ivar">@startOfToken</span> = <span class="ruby-identifier">sourceFileInfo</span>
+253:       <span class="ruby-ivar">@string</span> = <span class="ruby-value str">''</span>
+254:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+255:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1647,10 +1644,10 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="to-date-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 178</span>
-178:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_date</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-179:       [ <span class="ruby-identifier">type</span>, <span class="ruby-constant">TjTime</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">match</span>) ]
-180:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 169</span>
+169:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_date</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+170:       [ <span class="ruby-identifier">type</span>, <span class="ruby-constant">TjTime</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">match</span>) ]
+171:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1681,10 +1678,10 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="to-f-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 166</span>
-166:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_f</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-167:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>.<span class="ruby-identifier">to_f</span> ]
-168:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 157</span>
+157:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_f</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+158:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>.<span class="ruby-identifier">to_f</span> ]
+159:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1715,10 +1712,10 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="to-i-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 162</span>
-162:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_i</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-163:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>.<span class="ruby-identifier">to_i</span> ]
-164:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 153</span>
+153:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_i</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+154:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>.<span class="ruby-identifier">to_i</span> ]
+155:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1749,14 +1746,14 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="to-time-source">
 <pre>
-     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 170</span>
-170:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_time</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
-171:       <span class="ruby-identifier">h</span>, <span class="ruby-identifier">m</span>, <span class="ruby-identifier">s</span> = <span class="ruby-identifier">match</span>.<span class="ruby-identifier">split</span>(<span class="ruby-value str">':'</span>)
-172:       <span class="ruby-identifier">h</span> = <span class="ruby-identifier">h</span>.<span class="ruby-identifier">to_i</span>
-173:       <span class="ruby-identifier">m</span> = <span class="ruby-identifier">m</span>.<span class="ruby-identifier">to_i</span>
-174:       <span class="ruby-identifier">s</span> = <span class="ruby-value">0</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">s</span>.<span class="ruby-identifier">nil?</span>
-175:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">h</span> * <span class="ruby-value">3600</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">m</span> * <span class="ruby-value">60</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">s</span> ]
-176:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 161</span>
+161:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_time</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+162:       <span class="ruby-identifier">h</span>, <span class="ruby-identifier">m</span>, <span class="ruby-identifier">s</span> = <span class="ruby-identifier">match</span>.<span class="ruby-identifier">split</span>(<span class="ruby-value str">':'</span>)
+163:       <span class="ruby-identifier">h</span> = <span class="ruby-identifier">h</span>.<span class="ruby-identifier">to_i</span>
+164:       <span class="ruby-identifier">m</span> = <span class="ruby-identifier">m</span>.<span class="ruby-identifier">to_i</span>
+165:       <span class="ruby-identifier">s</span> = <span class="ruby-value">0</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">s</span>.<span class="ruby-identifier">nil?</span>
+166:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">h</span> * <span class="ruby-value">3600</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">m</span> * <span class="ruby-value">60</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">s</span> ]
+167:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>