taskjuggler 0.0.5 → 0.0.6

data/lib/StatusSheetSender.rb

@@ -46,6 +46,7 @@ text, UTF-8 encoded and the status sheet header from 'statussheet' to the period
 end date must be in a single line that starts at the beginning of the line.
 
 EOT
+      @mailSubject = "Your weekly status report template for %s"
     end
 
   end

data/lib/TableColumnDefinition.rb

@@ -57,7 +57,7 @@ class TaskJuggler
   # The column is uniquely identified by an ID.
   class TableColumnDefinition
 
-    attr_reader :id, :cellText, :tooltip, :cellColor, :fontColor
+    attr_reader :id, :cellText, :tooltip, :hAlign, :cellColor, :fontColor
     attr_accessor :title, :start, :end, :scale, :width, :content, :column
 
     def initialize(id, title)
@@ -73,8 +73,10 @@ class TaskJuggler
       # the actual cell content.
       @cellText = CellSettingPatternList.new
       # The content attribute is only used for calendar columns. It specifies
-      # what content should be displayed in the colendar columns.
+      # what content should be displayed in the calendar columns.
       @content = 'load'
+      # Horizontal alignment of the cell content.
+      @hAlign = CellSettingPatternList.new
       # An alternative content for the tooltip message. It should be a
       # RichText object.
       @tooltip = CellSettingPatternList.new

data/lib/Task.rb

@@ -32,21 +32,21 @@ class TaskJuggler
     end
 
     def query_journal(query)
-      journalMessages(query, true)
+      journalText(query, true)
     end
 
     private
 
     # Create a blog-style list of all alert messages that match the Query.
-    def journalMessages(query, longVersion)
+    def journalText(query, longVersion)
       # The components of the message are either UTF-8 text or RichText. For
       # the RichText components, we use the originally provided markup since
       # we compose the result as RichText markup first.
       rText = ''
       list = @project['journal'].entriesByTask(self, query.start, query.end)
       list.reverse.each do |entry|
-        # The TimeSheetRecords associated with this entry.
         tsRecord = entry.timeSheetRecord
+
         if entry.property.is_a?(Task)
           levelRecord = @project['alertLevels'][entry.alertLevel]
           alertName = "[[File:icons/flag-#{levelRecord[0]}.png|" +
@@ -79,15 +79,14 @@ class TaskJuggler
         end
       end
 
+      # Don't generate a RichText object for an empty String.
+      return if rText.empty?
+
       # Now convert the RichText markup String into RichTextIntermediate
       # format.
-      handlers = [
-        RTFNavigator.new(@project),
-        RTFQuery.new(@project),
-        RTFReport.new(@project)
-      ]
       begin
-        rti = RichText.new(rText, handlers).generateIntermediateFormat
+        rti = RichText.new(rText, RTFHandlers.create(@project)).
+          generateIntermediateFormat
       rescue RichTextException => msg
         $stderr.puts "Error while processing Rich Text\n" +
                      "Line #{msg.lineNo}: #{msg.text}\n" +

data/lib/TaskJuggler.rb

@@ -20,7 +20,7 @@ require 'Log'
 # files, schedule them and generate the reports.
 class TaskJuggler
 
-  attr_reader :messageHandler
+  attr_reader :project, :messageHandler
   attr_accessor :maxCpuCores, :warnTsDeltas
 
   # Create a new TaskJuggler object. _console_ is a boolean that determines
@@ -73,9 +73,6 @@ class TaskJuggler
     @parser.open(fileName, false)
     @parser.setGlobalMacros
     return nil if (res = @parser.parse(rule)).nil?
-    # Make sure that _rule_ described the full content of the file. There
-    # should be no more content left.
-    @parser.checkForEnd
     @parser.close
     res
   end
@@ -94,7 +91,8 @@ class TaskJuggler
   # Generate all specified reports. The project must have be scheduled before
   # this method can be called. It returns true if no error occured, false
   # otherwise.
-  def generateReports(outputDir)
+  def generateReports(outputDir = './')
+    outputDir += '/' unless outputDir.empty? || outputDir[-1] == '/'
     @project.outputDir = outputDir
     Log.enter('reports', 'Generating reports ...')
     res = @project.generateReports(@maxCpuCores)
@@ -102,11 +100,15 @@ class TaskJuggler
     res
   end
 
-  # Generate the report with the ID _reportId_.
-  def generateReport(reportId, regExpMode)
+  # Generate the report with the ID _reportId_. If _regExpMode_ is true,
+  # _reportId_ is interpreted as a Regular Expression and all reports with
+  # matching IDs are generated. _dynamicAtributes_ is a String that may
+  # contain attributes to supplement the report definition. The String must be
+  # in TJP format and may be nil if no additional attributes are provided.
+  def generateReport(reportId, regExpMode, dynamicAttributes = nil)
     begin
       Log.enter('generateReport', 'Generating report #{reportId} ...')
-      @project.generateReport(reportId, regExpMode)
+      @project.generateReport(reportId, regExpMode, dynamicAttributes)
     rescue TjException
       Log.exit('generateReport')
       return false
@@ -115,7 +117,9 @@ class TaskJuggler
     true
   end
 
-  # Generate the report with the ID _reportId_.
+  # Generate the report with the ID _reportId_. If _regExpMode_ is true,
+  # _reportId_ is interpreted as a Regular Expression and all reports with
+  # matching IDs are listed.
   def listReports(reportId, regExpMode)
     begin
       Log.enter('listReports', 'Generating report list for #{reportId} ...')
@@ -137,7 +141,7 @@ class TaskJuggler
       # Make sure we don't use data from old time sheets or Journal entries.
       @project.timeSheets.clear
       @project['journal'] = Journal.new
-      return false unless (ts = parseFile(fileName, 'timeSheet'))
+      return false unless (ts = parseFile(fileName, 'timeSheetFile'))
       return false unless @project.checkTimeSheets
       queryAttrs = { 'project' => @project,
                      'property' => ts.resource,
@@ -169,7 +173,7 @@ class TaskJuggler
   def checkStatusSheet(fileName)
     begin
       Log.enter('checkStatusSheet', 'Parsing #{fileName} ...')
-      return false unless (ss = parseFile(fileName, 'statusSheet'))
+      return false unless (ss = parseFile(fileName, 'statusSheetFile'))
       queryAttrs = { 'project' => @project,
                      'property' => ss[0],
                      'scopeProperty' => nil,
@@ -201,6 +205,12 @@ class TaskJuggler
     @project['projectid']
   end
 
+  # Return the name of the project or nil if no project has been loaded yet.
+  def projectName
+    return nil if @project.nil?
+    @project['name']
+  end
+
   # Return the number of errors that had been reported during processing.
   def errors
     @project.messageHandler.errors

data/lib/TaskScenario.rb

@@ -95,10 +95,10 @@ class TaskJuggler
       markMilestone
     end
 
-    # The parser only stores the full task IDs for each of the dependencies. This
-    # function resolves them to task references and checks them. In addition
-    # to the 'depends' and 'precedes' property lists we also keep 4 additional
-    # lists.
+    # The parser only stores the full task IDs for each of the dependencies.
+    # This function resolves them to task references and checks them. In
+    # addition to the 'depends' and 'precedes' property lists we also keep 4
+    # additional lists.
     # startpreds: All precedessors to the start of this task
     # startsuccs: All successors to the start of this task
     # endpreds: All predecessors to the end of this task
@@ -304,7 +304,7 @@ class TaskJuggler
         if ((startSpeced && endSpeced) ||
             (hasDependencies(false) && a('forward') && endSpeced) ||
             (hasDependencies(true) && !a('forward') && startSpeced)) &&
-           durationSpecs > 0 && !a('scheduled')
+           durationSpecs > 0 && !@property.provided('scheduled', @scenarioIdx)
           error('task_overspecified',
                 "Task #{@property.fullId} has a start, an end and a " +
                 'duration specification.')
@@ -842,6 +842,10 @@ class TaskJuggler
           propagateDate(a(thisEnd), !atEnd)
         end
         Log << "Milestone #{@property.fullId}: #{a('start')} -> #{a('end')}"
+      elsif !a('scheduled') && a('start') && a('end') &&
+            !(a('length') == 0 && a('duration') == 0 && a('effort') == 0 &&
+              !a('allocate').empty?)
+        @property['scheduled', @scenarioIdx] = true
       end
 
       # Propagate date to all dependent tasks.
@@ -942,8 +946,6 @@ class TaskJuggler
         end
       end
 
-      @property['scheduled', @scenarioIdx] = true
-
       startSet = endSet = false
       # Propagate the dates to other dependent tasks.
       if a('start').nil? || a('start') > nStart
@@ -954,6 +956,10 @@ class TaskJuggler
         @property['end', @scenarioIdx] = nEnd
         endSet = true
       end
+      unless a('start') && a('end')
+        raise "Start (#{a('start')}) and end (#{a('end')}) must be set"
+      end
+      @property['scheduled', @scenarioIdx] = true
       Log << "Container task #{@property.fullId}: #{a('start')} -> #{a('end')}"
 
       # If we have modified the start or end date, we need to communicate this
@@ -1166,10 +1172,10 @@ class TaskJuggler
         str += "* <nowiki>#{task.name}</nowiki> (#{task.fullId}) "
         if onEnd
           taskEnd = task['end', query.scenarioIdx].to_s(query.timeFormat)
-          str += "[->[ #{taskEnd}"
+          str += "[->] #{taskEnd}"
         else
           taskStart = task['start', query.scenarioIdx].to_s(query.timeFormat)
-          str += "[->] #{taskStart}"
+          str += "[->[ #{taskStart}"
         end
         str += "\n"
       end
@@ -1178,10 +1184,10 @@ class TaskJuggler
         str += "* <nowiki>#{task.name}</nowiki> (#{task.fullId}) "
         if onEnd
           taskEnd = task['end', query.scenarioIdx].to_s(query.timeFormat)
-          str += "]->[ #{taskEnd}"
+          str += "]->] #{taskEnd}"
         else
           taskStart = task['start', query.scenarioIdx].to_s(query.timeFormat)
-          str += "]->] #{taskStart}"
+          str += "]->[ #{taskStart}"
         end
         str += "\n"
       end
@@ -1198,7 +1204,7 @@ class TaskJuggler
         str += "* <nowiki>#{task.name}</nowiki> (#{task.fullId}) "
         if onEnd
           taskEnd = task['end', query.scenarioIdx].to_s(query.timeFormat)
-          str += "]->[ #{taskEnd}"
+          str += "]->] #{taskEnd}"
         else
           taskStart = task['start', query.scenarioIdx].to_s(query.timeFormat)
           str += "[->[ #{taskStart}"
@@ -1213,7 +1219,7 @@ class TaskJuggler
           str += "[->] #{taskEnd}"
         else
           taskStart = task['start', query.scenarioIdx].to_s(query.timeFormat)
-          str += "]->] #{taskStart}"
+          str += "]->[ #{taskStart}"
         end
         str += "\n"
       end
@@ -1333,6 +1339,7 @@ class TaskJuggler
 
     # Check if the Task _task_ depends on this task. _depth_ specifies how
     # many dependent task are traversed at max. A value of 0 means no limit.
+    # TODO: Change this to a non-recursive implementation.
     def isDependencyOf(task, depth)
       return true if task == @property
 
@@ -1364,6 +1371,21 @@ class TaskJuggler
       false
     end
 
+    # If _task_ or any of its sub-tasks depend on this task or any of its
+    # sub-tasks, we call this task a feature of _task_.
+    def isFeatureOf(task)
+      sources = @property.all
+      destinations = task.all
+
+      sources.each do |s|
+        destinations.each do |d|
+          return true if s.isDependencyOf(@scenarioIdx, d, 0)
+        end
+      end
+
+      false
+    end
+
     # Returns true of the _resource_ is assigned to this task or any of its
     # children.
     def hasResourceAllocated?(interval, resource)
@@ -1421,7 +1443,6 @@ class TaskJuggler
         # or start date and propagate the value to neighbouring tasks.
         if (a('length') > 0 && @doneLength >= a('length')) ||
            (a('duration') > 0 && @doneDuration >= a('duration'))
-          @property['scheduled', @scenarioIdx] = true
           if a('forward')
             propagateDate(slot + slotDuration, true)
           else
@@ -1434,7 +1455,6 @@ class TaskJuggler
         if @doneEffort >= a('effort')
           # The specified effort has been reached. The has been fully scheduled
           # now.
-          @property['scheduled', @scenarioIdx] = true
           if a('forward')
             propagateDate(@tentativeEnd, true)
           else
@@ -1508,11 +1528,9 @@ class TaskJuggler
          return if !shifts.onShift?(date)
       end
 
-      # If the task has allocation limits we need to make sure that none of them
-      # is already exceeded.
-      @limits.each do |limit|
-        return if !limit.ok?(date)
-      end
+      # If the task has resource independent allocation limits we need to make
+      # sure that none of them is already exceeded.
+      return unless limitsOk?(date)
 
       sbIdx = @project.dateToIdx(date)
 
@@ -1530,8 +1548,11 @@ class TaskJuggler
           # group must be available.
           allAvailable = true
           candidate.allLeaves.each do |resource|
-            if !resource.available?(@scenarioIdx, sbIdx) ||
+            if !limitsOk?(date, resource) ||
+               !resource.available?(@scenarioIdx, sbIdx) ||
                takenMandatories.include?(resource)
+              # We've found a mandatory resource that is not available for
+              # the slot.
               allAvailable = false
               break
             else
@@ -1573,8 +1594,10 @@ class TaskJuggler
       booked = false
       resource.allLeaves.each do |r|
         # Prevent overbooking when multiple resources are allocated and
-        # available.
-        break if a('effort') > 0 && @doneEffort >= a('effort')
+        # available. If the task has allocation limits we need to make sure
+        # that none of them is already exceeded.
+        break if a('effort') > 0 && @doneEffort >= a('effort') ||
+                 !limitsOk?(date, resource)
 
         if r.book(@scenarioIdx, sbIdx, @property)
 
@@ -1593,7 +1616,7 @@ class TaskJuggler
           # Limits do not take efficiency into account. Limits are usage limits,
           # not effort limits.
           @limits.each do |limit|
-            limit.inc(date)
+            limit.inc(date, resource)
           end
 
           unless a('assignedresources').include?(r)
@@ -1606,6 +1629,18 @@ class TaskJuggler
       booked
     end
 
+    # Check if all of the task limits are not exceded at the given _date_. If
+    # a _resource_ is provided, the limit for that particular resource is
+    # checked. If no resource is provided, only non-resource-specific limits
+    # are checked.
+    def limitsOk?(date, resource = nil)
+      @limits.each do |limit|
+        return false if !limit.ok?(date, true, resource)
+      end
+      true
+    end
+
+
     # Register the user provided bookings with the Resource scoreboards. A
     # booking describes the assignment of a Resource to a certain Task for a
     # specified Interval.
@@ -1617,7 +1652,7 @@ class TaskJuggler
                 "Booked resources may not be group resources", true,
                 booking.sourceFileInfo)
         end
-        unless a('forward') || a('scheduled')
+        unless a('forward') || scheduled
           error('booking_forward_only',
                 "Only forward scheduled tasks may have booking statements.")
         end
@@ -1639,7 +1674,7 @@ class TaskJuggler
               @lastSlot = date if @lastSlot.nil? || date > @lastSlot
               @tentativeEnd = tEnd if @tentativeEnd.nil? ||
                 @tentativeEnd < tEnd
-              if !a('scheduled') && (a('start').nil? || date < a('start'))
+              if !scheduled && (a('start').nil? || date < a('start'))
                 @property['start', @scenarioIdx] = date
               end
 

data/lib/TextParser.rb

@@ -161,7 +161,7 @@ class TaskJuggler
       @@expectedTokens = []
       updateParserTables
       begin
-        result = parseRule(@rules[ruleName])
+        result = parseRuleR(@rules[ruleName])
       rescue TjException
         # error('parse_error', $!.message)
         return nil
@@ -170,21 +170,12 @@ class TaskJuggler
       result
     end
 
-    # Return true if the scanner has processed all files.
-    def checkForEnd
-      token = @scanner.nextToken
-      unless token[0] == '.'
-        error('junk_at_expected_eof',
-              "Found garbage at expected end of file: #{token[1]}")
-      end
-    end
-
     # Return the SourceFileInfo of the TextScanner at the beginning of the
     # currently processed TextParser::Rule. Or return nil if we don't have a
     # current position.
     def sourceFileInfo
       return nil if @stack.empty?
-      @stack.last.sourceFileInfo
+      @stack.last.sourceFileInfo[0]
     end
 
     def matchingRules(keyword)
@@ -196,12 +187,18 @@ class TaskJuggler
       matches
     end
 
-    def error(id, text, property = nil)
-      @scanner.error(id, text, property)
+    def error(id, text, property = nil, sfi = nil)
+      if @scanner
+        @scanner.error(id, text, property, sfi)
+      else
+        message = Message.new(id, 'error', text, property, sfi)
+        @messageHandler.send(message)
+        raise TjException.new, ''
+      end
     end
 
-    def warning(id, text, property = nil)
-      @scanner.warning(id, text, property)
+    def warning(id, text, property = nil, sfi = nil)
+      @scanner.warning(id, text, property, sfi)
     end
 
   private
@@ -274,7 +271,8 @@ class TaskJuggler
           if type == ?$
             if @variables.index(token).nil?
               error('unsupported_token',
-                    "The token #{token} is not supported here.")
+                    "The token #{token} is not supported here.", nil,
+                    token[2])
             end
           elsif type == ?!
             if @rules[token].nil?
@@ -289,8 +287,10 @@ class TaskJuggler
     # This function processes the input starting with the syntax description of
     # _rule_. It recursively calls this function whenever the syntax description
     # contains the reference to another rule.
-    def parseRule(rule)
-      Log.enter('parseRule', "Parsing with rule #{rule.name}")
+    # This recursive version has cleaner code and is about 8% faster than
+    # parseRuleNR.
+    def parseRuleR(rule)
+      #Log.enter('parseRuleR', "Parsing with rule #{rule.name}")
       result = rule.repeatable ? TextParserResultArray.new : nil
       # Rules can be marked 'repeatable'. This flag will be set to true after
       # the first iteration has been completed.
@@ -300,105 +300,34 @@ class TaskJuggler
         # which pattern of the rule needs to be processed.
         token = getNextToken
 
-        # The scanner cannot differentiate between keywords and identifiers. So
-        # whenever an identifier is returned we have to see if we have a
-        # matching keyword first. If none is found, then look for normal
-        # identifiers.
-        if token[0] == 'ID'
-          if (patIdx = rule.matchingPatternIndex('_' + token[1])).nil?
-            patIdx = rule.matchingPatternIndex("$ID")
-          end
-        elsif token[0] == 'LITERAL'
-          patIdx = rule.matchingPatternIndex('_' + token[1])
-        elsif token[0] == false
-          patIdx = rule.matchingPatternIndex('.')
-        else
-          patIdx = rule.matchingPatternIndex('$' + token[0])
-        end
-
-        # If no matching pattern is found for the token we have to check if the
-        # rule is optional or we are in repeat mode. If this is the case, return
-        # the token back to the scanner. Otherwise we have found a token we
-        # cannot handle at this point.
-        if patIdx.nil?
-          # Append the list of expected tokens to the @@expectedToken array.
-          # This may be used in a later rule to provide more details when an
-          # error occured.
-          rule.transitions.each do |transition|
-            keys = transition.keys
-            keys.collect! { |key| key[1..-1] }
-            @@expectedTokens += keys
-            @@expectedTokens.sort!
-          end
-
-          unless rule.optional?(@rules) || repeatMode
-            error('unexpctd_token',
-                  (token[0] != false ?
-                   "Unexpected token '#{token[1]}' of type '#{token[0]}'. " :
-                   "Unexpected end of file in #{@scanner.fileName}. ") +
-                  (@@expectedTokens.length > 1 ?
-                   "Expecting one of #{@@expectedTokens.join(', ')}" :
-                   "Expecting #{@@expectedTokens[0]}"))
-          end
-          returnToken(token)
-          Log.exit('parseRule', "Finished rule #{rule.name}")
-          return result
-        end
-
-        pattern = rule.pattern(patIdx)
-        @stack << TextParser::StackElement.new(rule, pattern.function,
-                                               @scanner.sourceFileInfo)
+        return result unless (pattern = findPattern(rule, token, repeatMode))
+        # The @stack will store the resulting value of each element in the
+        # pattern.
+        @stack << TextParser::StackElement.new(pattern.function)
 
         pattern.each do |element|
           # Separate the type and token text for pattern element.
           elType = element[0]
           elToken = element[1..-1]
           if elType == ?!
-            # The element is a reference to another rule. Return the token if we
-            # still have one and continue with the referenced rule.
+            # The element is a reference to another rule. Return the token if
+            # we still have one and continue with the referenced rule.
             unless token.nil?
+              sfi = token[2]
               returnToken(token)
               token = nil
+            else
+              sfi = nil
             end
-            @stack.last.store(parseRule(@rules[elToken]),
-                              @scanner.sourceFileInfo)
+            @stack.last.store(parseRuleR(@rules[elToken]), sfi)
+            #Log << "Resuming rule #{rule.name}"
           else
             # In case the element is a keyword or variable we have to get a new
             # token if we don't have one anymore.
-            if token.nil?
-              token = getNextToken
-            end
+            token = getNextToken unless token
+
+            processNormalElements(elType, elToken, token)
 
-            if elType == ?_
-              # If the element requires a keyword the token must match this
-              # keyword.
-              if elToken != token[1]
-                text = "'#{elToken}' expected but found " +
-                       "'#{token[1]}' (#{token[0]})."
-                unless @@expectedTokens.empty?
-                  text = "#{@@expectedTokens.join(', ')} or " + text
-                end
-                error('spec_keywork_expctd', text)
-              end
-              @stack.last.store(elToken, @scanner.sourceFileInfo)
-            elsif elType == ?.
-              if token != [ '.', '<END>' ]
-                error('end_expected', 'End expected but found ' +
-                      "'#{token[1]}' (#{token[0]}).")
-              end
-            else
-              # The token must match the expected variable type.
-              if token[0] != elToken
-                text = "'#{elToken}' expected but found " +
-                       "'#{token[1]}' (#{token[0]})."
-                unless @@expectedTokens.empty?
-                  text = "#{@@expectedTokens.join(', ')} or " + text
-                end
-                error('spec_token_expctd', text)
-              end
-              # If the element is a variable store the value of the token.
-              @stack.last.store(token[1], @scanner.sourceFileInfo)
-            end
             # The token has been consumed. Reset the variable.
             token = nil
             @@expectedTokens = []
@@ -409,6 +338,7 @@ class TaskJuggler
         # function for this pattern to operate on the value array. Then pop the
         # entry for this rule from the stack.
         @val = @stack.last.val
+        @sourceFileInfo = @stack.last.sourceFileInfo
         res = nil
         res = @stack.last.function.call unless @stack.last.function.nil?
         @stack.pop
@@ -426,24 +356,256 @@ class TaskJuggler
         repeatMode = true
       end
 
-      Log.exit('parseRule', "Finished rule #{rule.name}")
+      #Log.exit('parseRuleR', "Finished rule #{rule.name}")
+      return result
+    end
+
+    # This function processes the input starting with the syntax description
+    # of _rule_. It's implemented as an unrolled recursion.  It recursively
+    # iterates over the rule tree as controlled by the input file.
+    # This version is not limited by the size of the system stack. So far, I'm
+    # not aware of any project that is too large for the system stack. Since
+    # the recursive version parseRuleR is about 8% faster and has cleaner
+    # code, we use that by default.
+    def parseRuleNR(rule)
+      elementIdx = 0
+      recursionResult = nil
+      # These flags are used to managed the control flow to and from the
+      # recursion point.
+      recur = resume = false
+      # The stack that holds the context for the recursion levels. It's either
+      # just a rule to start a new recursion or an Array of state variables.
+      recursionStack = [ rule ]
+      begin
+        # Pop the top entry from the recursion stack.
+        se = recursionStack.pop
+        if se.is_a?(Array)
+          # We have essentially finished a recursion level and need to get
+          # back to the place where we started the recursion. First, we need
+          # to restore the state again.
+          rule, pattern, elementIdx, result, repeatMode, sfi = se
+          #Log << "Recursion loop started in resume mode for rule #{rule.name}"
+          # Now jump to the recursion point without doing anything else.
+          resume = true
+        else
+          # Start a new recursion level. The rule tells us how to interpret
+          # the input text.
+          rule = se
+          #Log.enter('parseRuleNR', "Parsing with rule #{rule.name}")
+          resume = false
+        end
+
+        unless resume
+          result = rule.repeatable ? TextParserResultArray.new : nil
+          # Rules can be marked 'repeatable'. This flag will be set to true
+          # after the first iteration has been completed.
+          repeatMode = false
+        end
+
+        loop do
+          unless resume
+            # At the beginning of a rule we need a token from the input to
+            # determine which pattern of the rule needs to be processed.
+            token = getNextToken
+
+            break unless (pattern = findPattern(rule, token, repeatMode))
+            # The @stack will store the resulting value of each element in the
+            # pattern.
+            @stack << TextParser::StackElement.new(pattern.function)
+
+            # Once we've found the right pattern, we need to process each
+            # element.
+            elementIdx = 0
+          end
+
+          elementCount = pattern.length
+          while elementIdx < elementCount
+            element = pattern[elementIdx]
+            # Separate the type and token text for pattern element.
+            elType = element[0]
+            elToken = element[1..-1]
+            if elType == ?!
+              unless resume
+                # The element is a reference to another rule. Return the token
+                # if we still have one and continue with the referenced rule.
+                if token
+                  sfi = token[2]
+                  returnToken(token)
+                  token = nil
+                else
+                  sfi = nil
+                end
+                # This is where the recursion would happen. Instead, we push
+                # the state variables and then the next rule onto the
+                # recursion stack.
+                recursionStack.push([ rule, pattern, elementIdx, result,
+                                      repeatMode, sfi ])
+                recursionStack.push(@rules[elToken])
+                # Now terminate all but the outer loops without doing anything
+                # else.
+                recur = true
+                break
+              else
+                # We're back right after where the recursion started. Store
+                # the result and turn resume mode off again.
+                @stack.last.store(recursionResult, sfi)
+                resume = false
+              end
+            else
+              # In case the element is a keyword or variable we have to get a
+              # new token if we don't have one anymore.
+              token = getNextToken unless token
+
+              processNormalElements(elType, elToken, token)
+
+              # The token has been consumed. Reset the variable.
+              token = nil
+              @@expectedTokens = []
+            end
+            elementIdx += 1
+          end # of pattern while loop
+
+          # Skip the rest of the loop in recur mode.
+          break if recur
+
+          elementIdx = 0
+
+          # Once the complete pattern has been processed we call the
+          # processing function for this pattern to operate on the value
+          # array. Then pop the entry for this rule from the stack. The
+          # called function will use @val and @sourceFileInfo to retrieve
+          # data from the parser.
+          @val = @stack.last.val
+          @sourceFileInfo = @stack.last.sourceFileInfo
+          res = @stack.last.function ? @stack.last.function.call : nil
+          @stack.pop
+
+          # If the rule is not repeatable we can store the result and break
+          # the outer loop to exit the function.
+          unless rule.repeatable
+            result = res
+            break
+          end
+
+          # Otherwise we append the result to the result array and turn repeat
+          # mode on.
+          result << res
+          # We have completed the first iteration. Set the repeat mode flag to
+          # indicate that further iterations are already re-runs.
+          repeatMode = true
+        end # of rule processing loop
+
+        if recur
+          recur = false
+        else
+          #Log.exit('parseRuleNR', "Finished rule #{rule.name}")
+          recursionResult = result
+        end
+      end while !recursionStack.empty?
+
       return result
     end
 
     def getNextToken
       begin
         token = nextToken
-        Log << "Token: [#{token[0]}][#{token[1]}]"
+        #Log << "Token: [#{token[0]}][#{token[1]}]"
       rescue TjException
         error('parse_rule', $!.message)
       end
       if @badVariables.include?(token[0])
         error('unsupported_token',
-              "The token #{token[1]} is not supported in this context.")
+              "The token #{token[1]} is not supported in this context.",
+              nil, token[2])
       end
       token
     end
 
+    def findPattern(rule, token, repeatMode)
+      # The scanner cannot differentiate between keywords and identifiers.  So
+      # whenever an identifier is returned we have to see if we have a
+      # matching keyword first. If none is found, then look for normal
+      # identifiers.
+      if token[0] == 'ID'
+        if (patIdx = rule.matchingPatternIndex('_' + token[1])).nil?
+          patIdx = rule.matchingPatternIndex("$ID")
+        end
+      elsif token[0] == 'LITERAL'
+        patIdx = rule.matchingPatternIndex('_' + token[1])
+      elsif token[0] == false
+        patIdx = rule.matchingPatternIndex('.')
+      else
+        patIdx = rule.matchingPatternIndex('$' + token[0])
+      end
+
+      # If no matching pattern is found for the token we have to check if the
+      # rule is optional or we are in repeat mode. If this is the case, return
+      # the token back to the scanner. Otherwise, we have found a token we
+      # cannot handle at this point.
+      if patIdx.nil?
+        # Append the list of expected tokens to the @@expectedToken array.
+        # This may be used in a later rule to provide more details when an
+        # error occured.
+        rule.transitions.each do |transition|
+          keys = transition.keys
+          keys.collect! { |key| key[1..-1] }
+          @@expectedTokens += keys
+          @@expectedTokens.sort!
+        end
+
+        unless rule.optional?(@rules) || repeatMode
+          error('unexpctd_token',
+                (token[0] != false ?
+                 "Unexpected token '#{token[1]}' of type " +
+                 "'#{token[0]}'. " :
+                 "Unexpected end of file in #{@scanner.fileName}. ") +
+                (@@expectedTokens.length > 1 ?
+                 "Expecting one of #{@@expectedTokens.join(', ')}" :
+                 "Expecting #{@@expectedTokens[0]}"))
+        end
+        returnToken(token)
+        return nil
+      end
+
+      rule.pattern(patIdx)
+    end
+
+    # Handle the elements that don't trigger a recursion.
+    def processNormalElements(elType, elToken, token)
+      if elType == ?_
+        # If the element requires a keyword the token must match this
+        # keyword.
+        if elToken != token[1]
+          text = "'#{elToken}' expected but found " +
+                 "'#{token[1]}' (#{token[0]})."
+          unless @@expectedTokens.empty?
+            text = "#{@@expectedTokens.join(', ')} or " + text
+          end
+          error('spec_keywork_expctd', text)
+        end
+        @stack.last.store(elToken, token[2])
+      elsif elType == ?.
+        if token[0..1] != [ '.', '<END>' ]
+          error('end_expected',
+                "Found garbage at expected end of file: #{token[1]}\n" +
+                "If you see this in the middle of your file, you probably " +
+                "have closed your context too early.")
+        end
+      else
+        # The token must match the expected variable type.
+        if token[0] != elToken
+          text = "'#{elToken}' expected but found " +
+                 "'#{token[1]}' (#{token[0]})."
+          unless @@expectedTokens.empty?
+            text = "#{@@expectedTokens.join(', ')} or " + text
+          end
+          error('spec_token_expctd', text)
+        end
+        # If the element is a variable store the value of the token.
+        @stack.last.store(token[1], token[2])
+      end
+    end
+
   end
 
 end