taskjuggler 0.0.8 → 0.0.9

data/doc/TaskJuggler/ProjectFileScanner.html

@@ -179,6 +179,8 @@
 				
 					<li><a href="../TaskJuggler/AttributeDefinition.html">TaskJuggler::AttributeDefinition</a></li>
 				
+					<li><a href="../TaskJuggler/AttributeOverwrite.html">TaskJuggler::AttributeOverwrite</a></li>
+				
 					<li><a href="../TaskJuggler/BatchProcessor.html">TaskJuggler::BatchProcessor</a></li>
 				
 					<li><a href="../TaskJuggler/Booking.html">TaskJuggler::Booking</a></li>
@@ -257,6 +259,8 @@
 				
 					<li><a href="../TaskJuggler/Interval.html">TaskJuggler::Interval</a></li>
 				
+					<li><a href="../TaskJuggler/IntervalList.html">TaskJuggler::IntervalList</a></li>
+				
 					<li><a href="../TaskJuggler/IntervalListAttribute.html">TaskJuggler::IntervalListAttribute</a></li>
 				
 					<li><a href="../TaskJuggler/JobInfo.html">TaskJuggler::JobInfo</a></li>
@@ -289,6 +293,8 @@
 				
 					<li><a href="../TaskJuggler/LogicalExpressionAttribute.html">TaskJuggler::LogicalExpressionAttribute</a></li>
 				
+					<li><a href="../TaskJuggler/LogicalExpressionListAttribute.html">TaskJuggler::LogicalExpressionListAttribute</a></li>
+				
 					<li><a href="../TaskJuggler/LogicalFlag.html">TaskJuggler::LogicalFlag</a></li>
 				
 					<li><a href="../TaskJuggler/LogicalFunction.html">TaskJuggler::LogicalFunction</a></li>
@@ -569,6 +575,8 @@
 				
 					<li><a href="../TaskJuggler/WebServer.html">TaskJuggler::WebServer</a></li>
 				
+					<li><a href="../TaskJuggler/WelcomePage.html">TaskJuggler::WelcomePage</a></li>
+				
 					<li><a href="../TaskJuggler/WorkingHours.html">TaskJuggler::WorkingHours</a></li>
 				
 					<li><a href="../TaskJuggler/WorkingHoursAttribute.html">TaskJuggler::WorkingHoursAttribute</a></li>
@@ -595,8 +603,6 @@
 				
 					<li><a href="../String.html">String</a></li>
 				
-					<li><a href="../StringIO.html">StringIO</a></li>
-				
 				</ul>
 				<div id="no-class-search-results" style="display: none;">No matching classes.</div>
 			</div>
@@ -648,136 +654,136 @@ to detect the tokens of the TJP syntax.
 					<div class="method-source-code"
 						id="new-source">
 <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-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">: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">: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">: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">: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">: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">: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">: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">: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">: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">: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">: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">: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">: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">:LITERAL</span>, <span class="ruby-regexp re">/&lt;=?/</span> ],
-141:         [ <span class="ruby-value">:LITERAL</span>, <span class="ruby-regexp re">/&gt;=?/</span> ],
-142:         [ <span class="ruby-value">: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">: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>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 22</span>
+ 22:     <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>)
+ 23:       <span class="ruby-identifier">tokenPatterns</span> = [
+ 24:         <span class="ruby-comment cmt"># Any white spaces</span>
+ 25:         [ <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>) ],
+ 26: 
+ 27:         <span class="ruby-comment cmt"># Single line comments starting with #</span>
+ 28:         [ <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>) ],
+ 29: 
+ 30:         <span class="ruby-comment cmt"># C++ style single line comments starting with //</span>
+ 31:         [ <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>) ],
+ 32: 
+ 33:         <span class="ruby-comment cmt"># C style single line comment /* .. */.</span>
+ 34:         [ <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>) ],
+ 35: 
+ 36:         <span class="ruby-comment cmt"># C style multi line comment: We need three patterns here. The first</span>
+ 37:         <span class="ruby-comment cmt"># one is for the start of the string. It switches the scanner mode to</span>
+ 38:         <span class="ruby-comment cmt"># the :cppComment mode.</span>
+ 39:         [ <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>) ],
+ 40:         <span class="ruby-comment cmt"># This is the string end pattern. It switches back to tjp mode.</span>
+ 41:         [ <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>) ],
+ 42:         <span class="ruby-comment cmt"># This pattern matches string lines that contain neither the start,</span>
+ 43:         <span class="ruby-comment cmt"># nor the end of the string.</span>
+ 44:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/^.*\n/</span>, <span class="ruby-value">:cppComment</span> ],
+ 45: 
+ 46:         <span class="ruby-comment cmt"># Macro Call: This case is more complicated because we want to replace</span>
+ 47:         <span class="ruby-comment cmt"># macro calls inside of numbers, strings and identifiers. For this to</span>
+ 48:         <span class="ruby-comment cmt"># work, macro calls may have a prefix that looks like a number, a part</span>
+ 49:         <span class="ruby-comment cmt"># of a string or an identifier. This prefix is preserved and</span>
+ 50:         <span class="ruby-comment cmt"># re-injected into the scanner together with the expanded text. Macro</span>
+ 51:         <span class="ruby-comment cmt"># calls may span multiple lines. The ${ and the macro name must be in</span>
+ 52:         <span class="ruby-comment cmt"># the first line. Arguments that span multiple lines are not</span>
+ 53:         <span class="ruby-comment cmt"># supported. As above, we need rules for the start, the end and lines</span>
+ 54:         <span class="ruby-comment cmt"># with neither start nor end. Macro calls inside of strings need a</span>
+ 55:         <span class="ruby-comment cmt"># special start pattern that is active in the string modes. Both</span>
+ 56:         <span class="ruby-comment cmt"># patterns switch the scanner to macroCall mode.</span>
+ 57:         [ <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>,
+ 58:           <span class="ruby-value">:tjp</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startMacroCall'</span>) ],
+ 59:         <span class="ruby-comment cmt"># This pattern is similar to the previous one, but is active inside of</span>
+ 60:         <span class="ruby-comment cmt"># multi-line strings. The corresponding rule for sizzors strings</span>
+ 61:         <span class="ruby-comment cmt"># can be found below.</span>
+ 62:         [ <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>,
+ 63:           <span class="ruby-value">:dqString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startMacroCall'</span>) ],
+ 64:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/(\\'|[^'])*?\$\{\s*([a-zA-Z_]\w*)(\s*&quot;(\\&quot;|[^&quot;])*&quot;)*/</span>,
+ 65:           <span class="ruby-value">:sqString</span>, <span class="ruby-identifier">method</span>(<span class="ruby-value str">'startMacroCall'</span>) ],
+ 66:         <span class="ruby-comment cmt"># This pattern matches the end of a macro call. It injects the prefix</span>
+ 67:         <span class="ruby-comment cmt"># and the expanded macro into the scanner again. The mode is restored</span>
+ 68:         <span class="ruby-comment cmt"># to the previous mode.</span>
+ 69:         [ <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>) ],
+ 70:         <span class="ruby-comment cmt"># This pattern collects macro call arguments in lines that contain</span>
+ 71:         <span class="ruby-comment cmt"># neither the start nor the end of the macro.</span>
+ 72:         [ <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>) ],
+ 73: 
+ 74:         <span class="ruby-comment cmt"># An ID with a colon suffix: foo:</span>
+ 75:         [ <span class="ruby-value">: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>) ],
+ 76: 
+ 77:         <span class="ruby-comment cmt"># An absolute ID: a.b.c</span>
+ 78:         [ <span class="ruby-value">:ABSOLUTE_ID</span>, <span class="ruby-regexp re">/[a-zA-Z_]\w*(\.[a-zA-Z_]\w*)+/</span> ],
+ 79: 
+ 80:         <span class="ruby-comment cmt"># A normal ID: bar</span>
+ 81:         [ <span class="ruby-value">:ID</span>, <span class="ruby-regexp re">/[a-zA-Z_]\w*/</span> ],
+ 82: 
+ 83:         <span class="ruby-comment cmt"># A date</span>
+ 84:         [ <span class="ruby-value">: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>) ],
+ 85: 
+ 86:         <span class="ruby-comment cmt"># A time of day</span>
+ 87:         [ <span class="ruby-value">: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>) ],
+ 88: 
+ 89:         <span class="ruby-comment cmt"># A floating point number (e. g. 3.143)</span>
+ 90:         [ <span class="ruby-value">: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>) ],
+ 91: 
+ 92:         <span class="ruby-comment cmt"># An integer number</span>
+ 93:         [ <span class="ruby-value">: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>) ],
+ 94: 
+ 95:         <span class="ruby-comment cmt"># Multi line string enclosed with double quotes. The string may</span>
+ 96:         <span class="ruby-comment cmt"># contain double quotes prefixed by a backslash. The first rule</span>
+ 97:         <span class="ruby-comment cmt"># switches the scanner to dqString mode.</span>
+ 98:         [ <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>) ],
+ 99:         <span class="ruby-comment cmt"># Any line not containing the start or end.</span>
+100:         [ <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>) ],
+101:         <span class="ruby-comment cmt"># The end of the string.</span>
+102:         [ <span class="ruby-value">: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>) ],
+103: 
+104:         <span class="ruby-comment cmt"># Multi line string enclosed with single quotes.</span>
+105:         [ <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>) ],
+106:         <span class="ruby-comment cmt"># Any line not containing the start or end.</span>
+107:         [ <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>) ],
+108:         <span class="ruby-comment cmt"># The end of the string.</span>
+109:         [ <span class="ruby-value">: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>) ],
+110: 
+111:         <span class="ruby-comment cmt"># Scizzors marked string -8&lt;- ... -&gt;8-: The opening mark must be the</span>
+112:         <span class="ruby-comment cmt"># last thing in the line. The indentation of the first line after the</span>
+113:         <span class="ruby-comment cmt"># opening mark determines the indentation for all following lines. So,</span>
+114:         <span class="ruby-comment cmt"># we first switch the scanner to szrString1 mode.</span>
+115:         [ <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>) ],
+116:         <span class="ruby-comment cmt"># Since the first line can be the last line (empty string case), we</span>
+117:         <span class="ruby-comment cmt"># need to detect the end in szrString1 and szrString mode. The</span>
+118:         <span class="ruby-comment cmt"># patterns switch the scanner back to tjp mode.</span>
+119:         [ <span class="ruby-value">: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>) ],
+120:         [ <span class="ruby-value">: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>) ],
+121:         <span class="ruby-comment cmt"># This rule handles macros inside of sizzors strings.</span>
+122:         [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-regexp re">/.*?\$\{\s*([a-zA-Z_]\w*)(\s*&quot;(\\&quot;|[^&quot;])*&quot;)*/</span>,
+123:           [ <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>) ],
+124:         <span class="ruby-comment cmt"># Any line not containing the start or end.</span>
+125:         [ <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>) ],
+126:         [ <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>) ],
+127: 
+128:         <span class="ruby-comment cmt"># Single line macro definition</span>
+129:         [ <span class="ruby-value">: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>) ],
+130: 
+131:         <span class="ruby-comment cmt"># Multi line macro definition: The pattern switches the scanner into</span>
+132:         <span class="ruby-comment cmt"># macroDef mode.</span>
+133:         [ <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>) ],
+134:         <span class="ruby-comment cmt"># The end of the macro is marked by a ']' that is immediately followed</span>
+135:         <span class="ruby-comment cmt"># by a line break. It switches the scanner back to tjp mode.</span>
+136:         [ <span class="ruby-value">: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>) ],
+137:         <span class="ruby-comment cmt"># Any line not containing the start or end.</span>
+138:         [ <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>) ],
+139: 
+140:         <span class="ruby-comment cmt"># Some multi-char literals.</span>
+141:         [ <span class="ruby-value">:LITERAL</span>, <span class="ruby-regexp re">/&lt;=?/</span> ],
+142:         [ <span class="ruby-value">:LITERAL</span>, <span class="ruby-regexp re">/&gt;=?/</span> ],
+143:         [ <span class="ruby-value">:LITERAL</span>, <span class="ruby-regexp re">/!=?/</span> ],
+144: 
+145:         <span class="ruby-comment cmt"># Everything else is returned as a single-char literal.</span>
+146:         [ <span class="ruby-value">:LITERAL</span>, <span class="ruby-regexp re">/./</span> ]
+147:       ]
+148: 
+149:       <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>)
+150:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -814,10 +820,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 191</span>
-191:     <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>)
-192:       [ <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>] ]
-193:     <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">chop</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+193:       [ <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>] ]
+194:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -848,11 +854,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 195</span>
-195:     <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>)
-196:       <span class="ruby-comment cmt"># Remove first and last character.</span>
-197:       [ <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>] ]
-198:     <span class="ruby-keyword kw">end</span></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">chop2</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+197:       <span class="ruby-comment cmt"># Remove first and last character.</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">2</span>] ]
+199:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -883,11 +889,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 200</span>
-200:     <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>)
-201:       <span class="ruby-comment cmt"># remove first and last 2 characters.</span>
-202:       [ <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>] ]
-203:     <span class="ruby-keyword kw">end</span></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">chop2nl</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+202:       <span class="ruby-comment cmt"># remove first and last 2 characters.</span>
+203:       [ <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>] ]
+204:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -918,11 +924,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 210</span>
-210:     <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>)
-211:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
-212:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-213:     <span class="ruby-keyword kw">end</span></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">endComment</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">:tjp</span>
+213:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+214:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -953,48 +959,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 324</span>
-324:     <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>)
-325:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-ivar">@macroCallPreviousMode</span>
-326:       <span class="ruby-ivar">@macroCall</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>
-327: 
-328:       <span class="ruby-comment cmt"># Store any characters that precede the ${ in prefix and remove it from</span>
-329:       <span class="ruby-comment cmt"># @macroCall.</span>
-330:       <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>
-331:         <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>)]
-332:         <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>]
-333:       <span class="ruby-keyword kw">else</span>
-334:         <span class="ruby-identifier">prefix</span> = <span class="ruby-value str">''</span>
-335:       <span class="ruby-keyword kw">end</span>
-336: 
-337:       <span class="ruby-comment cmt"># Remove '${' and '}'</span>
-338:       <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>]
-339:       <span class="ruby-comment cmt"># Extract the macro name.</span>
-340:       <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>
-341:         <span class="ruby-identifier">expandMacro</span>(<span class="ruby-identifier">prefix</span>, [ <span class="ruby-identifier">argsStr</span> ])
-342:       <span class="ruby-keyword kw">else</span>
-343:         <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>)]
-344:         <span class="ruby-comment cmt"># Remove the name part from argsStr</span>
-345:         <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>]
-346:         <span class="ruby-comment cmt"># Array to hold the arguments</span>
-347:         <span class="ruby-identifier">args</span> = []
-348:         <span class="ruby-comment cmt"># We use another StringScanner to clean the double quotes.</span>
-349:         <span class="ruby-identifier">scanner</span> = <span class="ruby-constant">StringScanner</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">argsStr</span>)
-350:         <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>))
-351:           <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>)
-352:           <span class="ruby-identifier">scanner</span>.<span class="ruby-identifier">scan</span>(<span class="ruby-regexp re">/&quot;\s*/</span>)
-353:         <span class="ruby-keyword kw">end</span>
-354: 
-355:         <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">scanner</span>.<span class="ruby-identifier">eos?</span>
-356:           <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Junk found at end of macro: #{argsStr[scanner.pos..-1]}&quot;</span>
-357:         <span class="ruby-keyword kw">end</span>
-358: 
-359:         <span class="ruby-comment cmt"># Expand the macro and inject it into the scanner.</span>
-360:         <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>)
-361:       <span class="ruby-keyword kw">end</span>
-362: 
-363:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-364:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 325</span>
+325:     <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>)
+326:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-ivar">@macroCallPreviousMode</span>
+327:       <span class="ruby-ivar">@macroCall</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>
+328: 
+329:       <span class="ruby-comment cmt"># Store any characters that precede the ${ in prefix and remove it from</span>
+330:       <span class="ruby-comment cmt"># @macroCall.</span>
+331:       <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>
+332:         <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>)]
+333:         <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>]
+334:       <span class="ruby-keyword kw">else</span>
+335:         <span class="ruby-identifier">prefix</span> = <span class="ruby-value str">''</span>
+336:       <span class="ruby-keyword kw">end</span>
+337: 
+338:       <span class="ruby-comment cmt"># Remove '${' and '}'</span>
+339:       <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>]
+340:       <span class="ruby-comment cmt"># Extract the macro name.</span>
+341:       <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>
+342:         <span class="ruby-identifier">expandMacro</span>(<span class="ruby-identifier">prefix</span>, [ <span class="ruby-identifier">argsStr</span> ])
+343:       <span class="ruby-keyword kw">else</span>
+344:         <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>)]
+345:         <span class="ruby-comment cmt"># Remove the name part from argsStr</span>
+346:         <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>]
+347:         <span class="ruby-comment cmt"># Array to hold the arguments</span>
+348:         <span class="ruby-identifier">args</span> = []
+349:         <span class="ruby-comment cmt"># We use another StringScanner to clean the double quotes.</span>
+350:         <span class="ruby-identifier">scanner</span> = <span class="ruby-constant">StringScanner</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">argsStr</span>)
+351:         <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>))
+352:           <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>)
+353:           <span class="ruby-identifier">scanner</span>.<span class="ruby-identifier">scan</span>(<span class="ruby-regexp re">/&quot;\s*/</span>)
+354:         <span class="ruby-keyword kw">end</span>
+355: 
+356:         <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">scanner</span>.<span class="ruby-identifier">eos?</span>
+357:           <span class="ruby-identifier">raise</span> <span class="ruby-node">&quot;Junk found at end of macro: #{argsStr[scanner.pos..-1]}&quot;</span>
+358:         <span class="ruby-keyword kw">end</span>
+359: 
+360:         <span class="ruby-comment cmt"># Expand the macro and inject it into the scanner.</span>
+361:         <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>)
+362:       <span class="ruby-keyword kw">end</span>
+363: 
+364:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+365:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1025,13 +1031,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 305</span>
-305:     <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>)
-306:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
-307:       <span class="ruby-comment cmt"># Remove &quot;]\n&quot;</span>
-308:       <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>]
-309:       [ <span class="ruby-value">:MACRO</span>, <span class="ruby-ivar">@macroDef</span> ]
-310:     <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">endMacroDef</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+307:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
+308:       <span class="ruby-comment cmt"># Remove &quot;]\n&quot;</span>
+309:       <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>]
+310:       [ <span class="ruby-value">:MACRO</span>, <span class="ruby-ivar">@macroDef</span> ]
+311:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1062,13 +1068,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 228</span>
-228:     <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>)
-229:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
-230:       <span class="ruby-comment cmt"># Remove the trailing &quot; and remove the backslashes from escaped &quot;.</span>
-231:       <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>)
-232:       [ <span class="ruby-value">:STRING</span>, <span class="ruby-ivar">@string</span> ]
-233:     <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">endStringDQ</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+230:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
+231:       <span class="ruby-comment cmt"># Remove the trailing &quot; and remove the backslashes from escaped &quot;.</span>
+232:       <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>)
+233:       [ <span class="ruby-value">:STRING</span>, <span class="ruby-ivar">@string</span> ]
+234:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1099,13 +1105,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 248</span>
-248:     <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>)
-249:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
-250:       <span class="ruby-comment cmt"># Remove the trailing ' and remove the backslashes from escaped '.</span>
-251:       <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>)
-252:       [ <span class="ruby-value">:STRING</span>, <span class="ruby-ivar">@string</span> ]
-253:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 249</span>
+249:     <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>)
+250:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
+251:       <span class="ruby-comment cmt"># Remove the trailing ' and remove the backslashes from escaped '.</span>
+252:       <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>)
+253:       [ <span class="ruby-value">:STRING</span>, <span class="ruby-ivar">@string</span> ]
+254:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1136,11 +1142,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 288</span>
-288:     <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>)
-289:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:tjp</span>
-290:       [ <span class="ruby-value">:STRING</span>, <span class="ruby-ivar">@string</span> ]
-291:     <span class="ruby-keyword kw">end</span></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">endStringSZR</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">:tjp</span>
+291:       [ <span class="ruby-value">:STRING</span>, <span class="ruby-ivar">@string</span> ]
+292:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1171,13 +1177,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 270</span>
-270:     <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>)
-271:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:szrString</span>
-272:       <span class="ruby-comment cmt"># Split the leading indentation and the rest of the string.</span>
-273:       <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>]
-274:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-275:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 271</span>
+271:     <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>)
+272:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:szrString</span>
+273:       <span class="ruby-comment cmt"># Split the leading indentation and the rest of the string.</span>
+274:       <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>]
+275:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+276:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1208,11 +1214,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 319</span>
-319:     <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>)
-320:       <span class="ruby-ivar">@macroCall</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>
-321:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-322:     <span class="ruby-keyword kw">end</span></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">midMacroCall</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+321:       <span class="ruby-ivar">@macroCall</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>
+322:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+323:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1243,11 +1249,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 300</span>
-300:     <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>)
-301:       <span class="ruby-ivar">@macroDef</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">match</span>
-302:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-303:     <span class="ruby-keyword kw">end</span></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">midMacroDef</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+302:       <span class="ruby-ivar">@macroDef</span> <span class="ruby-operator">+=</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>
@@ -1278,12 +1284,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 222</span>
-222:     <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>)
-223:       <span class="ruby-comment cmt"># Remove the backslashes from escaped &quot;.</span>
-224:       <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>)
-225:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-226:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 223</span>
+223:     <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>)
+224:       <span class="ruby-comment cmt"># Remove the backslashes from escaped &quot;.</span>
+225:       <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>)
+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>
@@ -1314,12 +1320,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 242</span>
-242:     <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>)
-243:       <span class="ruby-comment cmt"># Remove the backslashes from escaped '.</span>
-244:       <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>)
-245:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-246:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 243</span>
+243:     <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>)
+244:       <span class="ruby-comment cmt"># Remove the backslashes from escaped '.</span>
+245:       <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>)
+246:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+247:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1350,17 +1356,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 277</span>
-277:     <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>)
-278:       <span class="ruby-comment cmt"># Ignore all the characters from the begining of match that are the same</span>
-279:       <span class="ruby-comment cmt"># in @indent.</span>
-280:       <span class="ruby-identifier">i</span> = <span class="ruby-value">0</span>
-281:       <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>]
-282:         <span class="ruby-identifier">i</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
-283:       <span class="ruby-keyword kw">end</span>
-284:       <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>]
-285:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-286:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 278</span>
+278:     <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>)
+279:       <span class="ruby-comment cmt"># Ignore all the characters from the begining of match that are the same</span>
+280:       <span class="ruby-comment cmt"># in @indent.</span>
+281:       <span class="ruby-identifier">i</span> = <span class="ruby-value">0</span>
+282:       <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>]
+283:         <span class="ruby-identifier">i</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
+284:       <span class="ruby-keyword kw">end</span>
+285:       <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>]
+286:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+287:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1391,11 +1397,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 186</span>
-186:     <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>)
-187:       <span class="ruby-ivar">@startOfToken</span> = <span class="ruby-identifier">sourceFileInfo</span>
-188:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-189:     <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">newPos</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+188:       <span class="ruby-ivar">@startOfToken</span> = <span class="ruby-identifier">sourceFileInfo</span>
+189:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+190:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1426,11 +1432,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 205</span>
-205:     <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>)
-206:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:cppComment</span>
-207:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-208:     <span class="ruby-keyword kw">end</span></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">startComment</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">:cppComment</span>
+208:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+209:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1461,13 +1467,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 312</span>
-312:     <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>)
-313:       <span class="ruby-ivar">@macroCallPreviousMode</span> = <span class="ruby-ivar">@scannerMode</span>
-314:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:macroCall</span>
-315:       <span class="ruby-ivar">@macroCall</span> = <span class="ruby-identifier">match</span>
-316:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-317:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 313</span>
+313:     <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>)
+314:       <span class="ruby-ivar">@macroCallPreviousMode</span> = <span class="ruby-ivar">@scannerMode</span>
+315:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:macroCall</span>
+316:       <span class="ruby-ivar">@macroCall</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>
 					</div>
 					
 				</div>
@@ -1498,13 +1504,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 293</span>
-293:     <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>)
-294:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:macroDef</span>
-295:       <span class="ruby-comment cmt"># Remove the opening '['</span>
-296:       <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>]
-297:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-298:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 294</span>
+294:     <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>)
+295:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:macroDef</span>
+296:       <span class="ruby-comment cmt"># Remove the opening '['</span>
+297:       <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>]
+298:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+299:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1535,13 +1541,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 215</span>
-215:     <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>)
-216:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:dqString</span>
-217:       <span class="ruby-comment cmt"># Remove the opening &quot; and remove the backslashes from escaped &quot;.</span>
-218:       <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>)
-219:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-220:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 216</span>
+216:     <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>)
+217:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:dqString</span>
+218:       <span class="ruby-comment cmt"># Remove the opening &quot; and remove the backslashes from escaped &quot;.</span>
+219:       <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>)
+220:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+221:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1572,13 +1578,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 235</span>
-235:     <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>)
-236:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:sqString</span>
-237:       <span class="ruby-comment cmt"># Remove the opening ' and remove the backslashes from escaped '.</span>
-238:       <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>)
-239:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-240:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 236</span>
+236:     <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>)
+237:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:sqString</span>
+238:       <span class="ruby-comment cmt"># Remove the opening ' and remove the backslashes from escaped '.</span>
+239:       <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>)
+240:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+241:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1609,21 +1615,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 255</span>
-255:     <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>)
-256:       <span class="ruby-comment cmt"># There should be a line break after the cut mark, but we allow some</span>
-257:       <span class="ruby-comment cmt"># spaces between the mark and the line break as well.</span>
-258:       <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>
-259:         <span class="ruby-ivar">@lineDelta</span> = <span class="ruby-value">1</span>
-260:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'junk_after_cut'</span>,
-261:               <span class="ruby-value str">'The cut mark -8&lt;- must be immediately followed by a '</span> <span class="ruby-operator">+</span>
-262:               <span class="ruby-value str">'line break.'</span>)
-263:       <span class="ruby-keyword kw">end</span>
-264:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:szrString1</span>
-265:       <span class="ruby-ivar">@startOfToken</span> = <span class="ruby-identifier">sourceFileInfo</span>
-266:       <span class="ruby-ivar">@string</span> = <span class="ruby-value str">''</span>
-267:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
-268:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 256</span>
+256:     <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>)
+257:       <span class="ruby-comment cmt"># There should be a line break after the cut mark, but we allow some</span>
+258:       <span class="ruby-comment cmt"># spaces between the mark and the line break as well.</span>
+259:       <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>
+260:         <span class="ruby-ivar">@lineDelta</span> = <span class="ruby-value">1</span>
+261:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'junk_after_cut'</span>,
+262:               <span class="ruby-value str">'The cut mark -8&lt;- must be immediately followed by a '</span> <span class="ruby-operator">+</span>
+263:               <span class="ruby-value str">'line break.'</span>)
+264:       <span class="ruby-keyword kw">end</span>
+265:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mode</span> = <span class="ruby-value">:szrString1</span>
+266:       <span class="ruby-ivar">@startOfToken</span> = <span class="ruby-identifier">sourceFileInfo</span>
+267:       <span class="ruby-ivar">@string</span> = <span class="ruby-value str">''</span>
+268:       [ <span class="ruby-keyword kw">nil</span>, <span class="ruby-value str">''</span> ]
+269:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1654,14 +1660,14 @@ 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-keyword kw">begin</span>
-180:         [ <span class="ruby-identifier">type</span>, <span class="ruby-constant">TjTime</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">match</span>) ]
-181:       <span class="ruby-keyword kw">rescue</span> <span class="ruby-constant">TjException</span> =<span class="ruby-operator">&gt;</span> <span class="ruby-identifier">msg</span>
-182:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'time_error'</span>, <span class="ruby-identifier">msg</span>)
-183:       <span class="ruby-keyword kw">end</span>
-184:     <span class="ruby-keyword kw">end</span></pre>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 179</span>
+179:     <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>)
+180:       <span class="ruby-keyword kw">begin</span>
+181:         [ <span class="ruby-identifier">type</span>, <span class="ruby-constant">TjTime</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">match</span>) ]
+182:       <span class="ruby-keyword kw">rescue</span> <span class="ruby-constant">TjException</span> =<span class="ruby-operator">&gt;</span> <span class="ruby-identifier">msg</span>
+183:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'time_error'</span>, <span class="ruby-identifier">msg</span>)
+184:       <span class="ruby-keyword kw">end</span>
+185:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1692,10 +1698,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 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>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 158</span>
+158:     <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>)
+159:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>.<span class="ruby-identifier">to_f</span> ]
+160:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1726,10 +1732,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 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>
+     <span class="ruby-comment cmt"># File lib/ProjectFileScanner.rb, line 154</span>
+154:     <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>)
+155:       [ <span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>.<span class="ruby-identifier">to_i</span> ]
+156:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>
@@ -1760,23 +1766,23 @@ 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 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">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-keyword kw">if</span> <span class="ruby-identifier">h</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">h</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">24</span>
-165:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'time_bad_hour'</span>, <span class="ruby-node">&quot;Hour #{h} out of range (0 - 24)&quot;</span>)
-166:       <span class="ruby-keyword kw">end</span>
-167:       <span class="ruby-identifier">m</span> = <span class="ruby-identifier">m</span>.<span class="ruby-identifier">to_i</span>
-168:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">m</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">h</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">59</span>
-169:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'time_bad_minute'</span>, <span class="ruby-node">&quot;Minute #{m} out of range (0 - 59)&quot;</span>)
-170:       <span class="ruby-keyword kw">end</span>
-171:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">h</span> <span class="ruby-operator">==</span> <span class="ruby-value">24</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">m</span> <span class="ruby-operator">!=</span> <span class="ruby-value">0</span>
-172:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'time_bad_time'</span>, <span class="ruby-node">&quot;Time #{match} cannot be larger then 24:00&quot;</span>)
-173:       <span class="ruby-keyword kw">end</span>
-174: 
-175:       [ <span class="ruby-identifier">type</span>, (<span class="ruby-identifier">h</span> * <span class="ruby-value">60</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">m</span>) * <span class="ruby-value">60</span> ]
-176:     <span class="ruby-keyword kw">end</span></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_time</span>(<span class="ruby-identifier">type</span>, <span class="ruby-identifier">match</span>)
+163:       <span class="ruby-identifier">h</span>, <span class="ruby-identifier">m</span> = <span class="ruby-identifier">match</span>.<span class="ruby-identifier">split</span>(<span class="ruby-value str">':'</span>)
+164:       <span class="ruby-identifier">h</span> = <span class="ruby-identifier">h</span>.<span class="ruby-identifier">to_i</span>
+165:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">h</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">h</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">24</span>
+166:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'time_bad_hour'</span>, <span class="ruby-node">&quot;Hour #{h} out of range (0 - 24)&quot;</span>)
+167:       <span class="ruby-keyword kw">end</span>
+168:       <span class="ruby-identifier">m</span> = <span class="ruby-identifier">m</span>.<span class="ruby-identifier">to_i</span>
+169:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">m</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">h</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">59</span>
+170:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'time_bad_minute'</span>, <span class="ruby-node">&quot;Minute #{m} out of range (0 - 59)&quot;</span>)
+171:       <span class="ruby-keyword kw">end</span>
+172:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">h</span> <span class="ruby-operator">==</span> <span class="ruby-value">24</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">m</span> <span class="ruby-operator">!=</span> <span class="ruby-value">0</span>
+173:         <span class="ruby-identifier">error</span>(<span class="ruby-value str">'time_bad_time'</span>, <span class="ruby-node">&quot;Time #{match} cannot be larger then 24:00&quot;</span>)
+174:       <span class="ruby-keyword kw">end</span>
+175: 
+176:       [ <span class="ruby-identifier">type</span>, (<span class="ruby-identifier">h</span> * <span class="ruby-value">60</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">m</span>) * <span class="ruby-value">60</span> ]
+177:     <span class="ruby-keyword kw">end</span></pre>
 					</div>
 					
 				</div>