# File lib/taskjuggler/TjpSyntaxRules.rb, line 21
  def rule_absoluteTaskId
    pattern(%w( !taskIdUnverifd ), lambda {
      id = (@taskprefix.empty? ? '' : @taskprefix + '.') + @val[0]
      if (task = @project.task(id)).nil?
        error('unknown_abs_task', "Unknown task #{id}", @sourceFileInfo[0])
      end
      task
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 31
  def rule_account
    pattern(%w( !accountHeader !accountBody ), lambda {
       @property = @property.parent
    })
    doc('account', "Declares an account. Accounts can be used to calculate costs of tasks or the\nwhole project. Account declaration may be nested, but only leaf accounts may\nbe used to track turnover. When the cost of a task is split over multiple\naccounts they all must have the same top-level group account. Top-level\naccounts can be used for profit/loss calculations. The sub-account structure\nof a top-level account should be organized accordingly.\n\nAccounts have a global name space. All IDs must be unique within the accounts of the project.\n"
       )
    example('Account', '1')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 50
  def rule_accountAttributes
    repeatable
    optional
    pattern(%w( !account))
    pattern(%w( !accountScenarioAttributes ))
    pattern(%w( !scenarioIdCol !accountScenarioAttributes ), lambda {
      @scenarioIdx = 0
    })
    # Other attributes will be added automatically.
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 61
  def rule_accountBody
    optionsRule('accountAttributes')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 65
  def rule_accountCredit
    pattern(%w( !valDate $STRING !number ), lambda {
      AccountCredit.new(@val[0], @val[1], @val[2])
    })
    arg(1, 'description', 'Short description of the transaction')
    arg(2, 'amount', 'Amount to be booked.')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 73
  def rule_accountCredits
    listRule('moreAccountCredits', '!accountCredit')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 77
  def rule_accountHeader
    pattern(%w( _account !optionalID $STRING ), lambda {
      if @property.nil? && !@accountprefix.empty?
        @property = @project.accout(@accountprefix)
      end
      if @val[1] && @project.account(@val[1])
        error('account_exists', "Account #{@val[1]} has already been defined.",
              @sourceFileInfo[1], @property)
      end
      @property = Account.new(@project, @val[1], @val[2], @property)
      @property.sourceFileInfo = @sourceFileInfo[0]
      @property.inheritAttributes
      @scenarioIdx = 0
    })
    arg(2, 'name', 'A name or short description of the account')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 94
  def rule_accountId
    pattern(%w( $ID ), lambda {
      id = @val[0]
      id = @accountprefix + '.' + id unless @accountprefix.empty?
      # In case we have a nested supplement, we need to prepend the parent ID.
      id = @property.fullId + '.' + id if @property && @property.is_a?(Account)
      if (account = @project.account(id)).nil?
        error('unknown_account', "Unknown account #{id}", @sourceFileInfo[0])
      end
      account
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 107
  def rule_accountReport
    pattern(%w( !accountReportHeader !reportBody ), lambda {
      @property = @property.parent
    })
    level(:beta)
    doc('accountreport', "The report lists accounts and their respective values in a table. The report\ncan operate in two modes:\n\n# Balance mode: If a [[balance]] has been set, the report will include the\ndefined cost and revenue accounts as well as all their sub accounts. To reduce\nthe list of included accounts, you can use the [[hideaccount]],\n[[rollupaccount]] or [[accountroot]] attributes. The order of the task can\nbe controlled with [[sortaccounts]]. If the first sorting criteria is tree\nsorting, the parent accounts will always be included to form the tree.\nTree sorting is the default. You need to change it if you do not want certain\nparent accounts to be included in the report. Additionally, it will contain a line at the end that lists the balance (revenue - cost).\n\n# Normal mode: All reports are listed in the order and completeness as defined\nby the other report attributes. No balance line will be included.\n"
       )
    example('AccountReport')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 133
  def rule_accountReportHeader
    pattern(%w( _accountreport !optionalID !reportName ), lambda {
      newReport(@val[1], @val[2], :accountreport, @sourceFileInfo[0])

      unless @property.modified?('columns')
        # Set the default columns for this report.
        %w( bsi name monthly ).each do |col|
          @property.get('columns') <<
          TableColumnDefinition.new(col, columnTitle(col))
        end
      end
      # Show all accounts, sorted by tree, seqno-up.
      unless @property.modified?('hideAccount')
        @property.set('hideAccount',
                      LogicalExpression.new(LogicalOperation.new(0)))
      end
      unless @property.modified?('sortAccounts')
        @property.set('sortAccounts',
                      [ [ 'tree', true, -1 ],
                        [ 'seqno', true, -1 ] ])
      end
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 157
  def rule_accountScenarioAttributes
    pattern(%w( _aggregate !aggregate ), lambda {
      @property.set('aggregate', @val[1])
    })
    doc('aggregate', "Specifies whether the account is used to track task or resource specific\namounts. The default is to track tasks.\n"
       )
    example('AccountReport')

    pattern(%w( _credits !accountCredits ), lambda {
      begin
        @property['credits', @scenarioIdx] += @val[1]
      rescue AttributeOverwrite
        # Adding multiple credits for an account is a pretty common idiom.
      end
    })
    doc('credits', "Book the specified amounts to the account at the specified date. The\ndesciptions are just used for documentary purposes.\n"
       )
    example('Account', '1')

    pattern(%w( !flags ))
    doc('flags.account', "Attach a set of flags. The flags can be used in logical expressions to filter\nproperties from the reports.\n"
       )

    # Other attributes will be added automatically.
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 195
  def rule_aggregate
    pattern(%w( _resources ), lambda {
      :resources
    })
    descr('Aggregate resources')

    pattern(%w( _tasks ), lambda {
      :tasks
    })
    descr('Aggregate tasks')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 207
  def rule_alertLevel
    pattern(%w( $ID ), lambda {
      level = @project['alertLevels'].indexById(@val[0])
      unless level
        levels = @project['alertLevels'].map { |l| l.id }
        error('bad_alert', "Unknown alert level #{@val[0]}. Must be " +
              "one of #{levels.join(', ')}", @sourceFileInfo[0])
      end
      level
    })
    arg(0, 'alert level', "By default supported values are ''''green'''', ''''yellow'''' and ''''red''''.\nThe default value is ''''green''''. You can define your own levels with\n[[alertlevels]].\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 226
  def rule_alertLevelDefinition
    pattern(%w( $ID $STRING !color ), lambda {
      [ @val[0], @val[1], @val[2] ]
    })
    arg(0, 'ID', "A unique ID for the alert level")
    arg(1, 'color name', 'A unique name of the alert level color')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 234
  def rule_alertLevelDefinitions
    listRule('moreAlertLevelDefinitions', '!alertLevelDefinition')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 434
  def rule_allOrNone
    pattern(%w( _all ), lambda {
      1
    })
    pattern(%w( _none ), lambda {
      0
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 238
  def rule_allocate
    pattern(%w( _allocate !allocations ), lambda {
      checkContainer('allocate')
      # Don't use << operator here so the 'provided' flag gets set properly.
      begin
        @property['allocate', @scenarioIdx] =
          @property['allocate', @scenarioIdx] + @val[1]
      rescue AttributeOverwrite
        # Adding multiple allocates for a task is a pretty common idiom.
      end
    })
    doc('allocate', "Specify which resources should be allocated to the task. The\nattributes provide numerous ways to control which resource is used and when\nexactly it will be assigned to the task. Shifts and limits can be used to\nrestrict the allocation to certain time intervals or to limit them to a\ncertain maximum per time period. The purge statement can be used to remove\ninherited allocations or flags.\n"
       )
    example('Allocate-1', '1')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 422
  def rule_allocateShiftAssignments
    pattern(%w( _shift ), lambda {
      @shiftAssignments = @allocate.shifts
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 428
  def rule_allocateShiftsAssignments
    pattern(%w( _shifts ), lambda {
      @shiftAssignments = @allocate.shifts
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 262
  def rule_allocation
    pattern(%w( !allocationHeader !allocationBody ), lambda {
      @val[0]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 268
  def rule_allocationAttributes
    optional
    repeatable

    pattern(%w( _alternative !resourceId !moreAlternatives ), lambda {
      ([ @val[1] ] + (@val[2] ? @val[2] : [])).each do |candidate|
        @allocate.addCandidate(candidate)
      end
    })
    doc('alternative', "Specify which resources should be allocated to the task. The optional\nattributes provide numerous ways to control which resource is used and when\nexactly it will be assigned to the task. Shifts and limits can be used to\nrestrict the allocation to certain time intervals or to limit them to a\ncertain maximum per time period.\n"
       )
    example('Alternative', '1')

    pattern(%w( !limits ), lambda {
      limits = @property['limits', @scenarioIdx] = @val[0]
      @allocate.candidates.each do |resource|
         limits.limits.each do |l|
           l.resource = resource if resource.leaf?
         end
      end
    })
    level(:removed)
    doc('limits.allocate', '')

    pattern(%w( _select !allocationSelectionMode ), lambda {
      @allocate.setSelectionMode(@val[1])
    })
    doc('select', "The select functions controls which resource is picked from an allocation and\nit's alternatives. The selection is re-evaluated each time the resource used\nin the previous time slot becomes unavailable.\n\nEven for non-persistent allocations a change in the resource selection only\nhappens if the resource used in the previous (or next for ASAP tasks) time\nslot has become unavailable.\n"
       )

    pattern(%w( _persistent ), lambda {
      @allocate.persistent = true
    })
    doc('persistent', "Specifies that once a resource is picked from the list of alternatives this\nresource is used for the whole task. This is useful when several alternative\nresources have been specified. Normally the selected resource can change after\neach break. A break is an interval of at least one timeslot where no resources\nwere available.\n"
       )

    pattern(%w( _mandatory ), lambda {
      @allocate.mandatory = true
    })
    doc('mandatory', "Makes a resource allocation mandatory. This means, that for each time slot\nonly then resources are allocated when all mandatory resources are available.\nSo either all mandatory resources can be allocated for the time slot, or no\nresource will be allocated.\n"
       )
    pattern(%w( !allocateShiftAssignments !shiftAssignment ), lambda {
      begin
        @allocate.shifts = @shiftAssignments
      rescue AttributeOverwrite
        # Multiple shift assignments are a common idiom, so don't warn about
        # them.
      end
      @shiftAssignments = nil
    })
    level(:deprecated)
    also('shifts.allocate')
    doc('shift.allocate', "Limits the allocations of resources during the specified interval to the\nspecified shift. Multiple shifts can be defined, but shift intervals may not\noverlap. Allocation shifts are an additional restriction to the\n[[shifts.task|task shifts]] and [[shifts.resource|resource shifts]] or\n[[workinghours.resource|resource working hours]]. Allocations will only be\nmade for time slots that are specified as duty time in all relevant shifts.\nThe restriction to the shift is only active during the specified time\ninterval. Outside of this interval, no restrictions apply.\n"
       )

    pattern(%w( !allocateShiftsAssignments !shiftAssignments ), lambda {
      begin
        @allocate.shifts = @shiftAssignments
      rescue AttributeOverwrite
        # Multiple shift assignments are a common idiom, so don't warn about
        # them.
      end
      @shiftAssignments = nil
    })
    doc('shifts.allocate', "Limits the allocations of resources during the specified interval to the\nspecified shift. Multiple shifts can be defined, but shift intervals may not\noverlap. Allocation shifts are an additional restriction to the\n[[shifts.task|task shifts]] and [[shifts.resource|resource shifts]] or\n[[workinghours.resource|resource working hours]]. Allocations will only be\nmade for time slots that are specified as duty time in all relevant shifts.\nThe restriction to the shift is only active during the specified time\ninterval. Outside of this interval, no restrictions apply.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 385
  def rule_allocationBody
    optionsRule('allocationAttributes')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 389
  def rule_allocationHeader
    pattern(%w( !resourceId ), lambda {
      @allocate = Allocation.new([ @val[0] ])
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 399
  def rule_allocationSelectionMode
    singlePattern('_maxloaded')
    descr('Pick the available resource that has been used the most so far.')

    singlePattern('_minloaded')
    descr('Pick the available resource that has been used the least so far.')

    singlePattern('_minallocated')
    descr("Pick the resource that has the smallest allocation factor. The\nallocation factor is calculated from the various allocations of the resource\nacross the tasks. This is the default setting.)\n"
         )

    singlePattern('_order')
    descr('Pick the first available resource from the list.')

    singlePattern('_random')
    descr('Pick a random resource from the list.')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 395
  def rule_allocations
    listRule('moreAllocations', '!allocation')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 443
  def rule_argument
    singlePattern('$ABSOLUTE_ID')
    singlePattern('!date')
    singlePattern('$ID')
    singlePattern('$INTEGER')
    singlePattern('$FLOAT')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 451
  def rule_argumentList
    optional
    pattern(%w( _( !argumentListBody _) ), lambda {
      @val[1].nil? ? [] : @val[1]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 458
  def rule_argumentListBody
    optional
    pattern(%w( !argument !moreArguments ), lambda {
      [ @val[0] ] + (@val[1].nil? ? [] : @val[1])
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 465
  def rule_author
    pattern(%w( _author !resourceId ), lambda {
      @journalEntry.author = @val[1]
    })
    doc('author', "This attribute can be used to capture the authorship or source of the\ninformation.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 477
  def rule_balance
    pattern(%w( _balance !balanceAccounts ), lambda {
      @val[1]
    })
    doc('balance', "During report generation, TaskJuggler can consider some accounts to be revenue accounts, while other can be considered cost accounts. By using the balance attribute, two top-level accounts can be designated for a profit-loss-analysis. This analysis includes all sub accounts of these two top-level accounts.\n\nTo clear a previously set balance, just use a ''''-''''.\n"
       )
    example('AccountReport')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 491
  def rule_balanceAccounts
    pattern(%w( !accountId !accountId ), lambda {
      if @val[0].parent
        error('cost_acct_no_top',
              "The cost account #{@val[0].fullId} is not a top-level account.",
              @sourceFileInfo[0])
      end
      if @val[1].parent
        error('rev_acct_no_top',
              "The revenue account #{@val[1].fullId} is not a top-level " +
              "account.", @sourceFileInfo[1])
      end
      if @val[0] == @val[1]
        error('cost_rev_same',
              'The cost and revenue accounts may not be the same.',
              @sourceFileInfo[0])
      end
      [ @val[0], @val[1] ]
    })
    arg(0, 'cost account', "The top-level account that is used for all cost related charges.\n"
       )
    arg(2, 'revenue account', "The top-level account that is used for all revenue related charges.\n"
       )

    pattern([ '_-' ], lambda {
      [ nil, nil ]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 526
  def rule_bookingAttributes
    optional
    repeatable

    pattern(%w( _overtime $INTEGER ), lambda {
      if @val[1] < 0 || @val[1] > 2
        error('overtime_range',
              "Overtime value #{@val[1]} out of range (0 - 2).",
              @sourceFileInfo[1], @property)
      end
      @booking.overtime = @val[1]
    })
    doc('overtime.booking', "This attribute enables bookings during off-hours and leaves. It implicitly\nsets the [[sloppy.booking|sloppy]] attribute accordingly.\n"
       )
    arg(1, 'value', "* '''0''': You can only book available working time. (Default)\n\n* '''1''': You can book off-hours as well.\n\n* '''2''': You can book working time, off-hours and vacation time.\n"
       )

    pattern(%w( _sloppy $INTEGER ), lambda {
      if @val[1] < 0 || @val[1] > 2
        error('sloppy_range',
              "Sloppyness value #{@val[1]} out of range (0 - 2).",
              @sourceFileInfo[1], @property)
      end
      @booking.sloppy = @val[1]
    })
    doc('sloppy.booking', "Controls how strict TaskJuggler checks booking intervals for conflicts with\nworking periods and leaves. This attribute only affects the check for\nconflicts. No assignments will be made unless the [[overtime.booking|\novertime]] attribute is set accordingly.\n"
       )
    arg(1, 'sloppyness', "* '''0''': Period may not contain any off-duty hours, vacation or other task\nassignments. (default)\n\n* '''1''': Period may contain off-duty hours, but no vacation time or other\ntask assignments.\n\n* '''2''': Period may contain off-duty hours and vacation time, but no other\ntask assignments.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 584
  def rule_bookingBody
    optionsRule('bookingAttributes')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 588
  def rule_calendarDuration
    pattern(%w( !number !durationUnit ), lambda {
      convFactors = [ 60.0, # minutes
                      60.0 * 60, # hours
                      60.0 * 60 * 24, # days
                      60.0 * 60 * 24 * 7, # weeks
                      60.0 * 60 * 24 * 30.4167, # months
                      60.0 * 60 * 24 * 365 # years
                     ]
      ((@val[0] * convFactors[@val[1]]) / @project['scheduleGranularity']).to_i
    })
    arg(0, 'value', 'A floating point or integer number')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 642
  def rule_chargeMode
    singlePattern('_onstart')
    descr('Charge the amount on starting the task.')

    singlePattern('_onend')
    descr('Charge the amount on finishing the task.')

    singlePattern('_perhour')
    descr('Charge the amount for every hour the task lasts.')

    singlePattern('_perday')
    descr('Charge the amount for every day the task lasts.')

    singlePattern('_perweek')
    descr('Charge the amount for every week the task lasts.')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 659
  def rule_chargeSetItem
    pattern(%w( !accountId !optionalPercent ), lambda {
      if @property.is_a?(Task)
        aggregate = :tasks
      elsif @property.is_a?(Resource)
        aggregate = :resources
      else
        raise "Unknown property type #{@property.class}"
      end

      if @val[0].get('aggregate') != aggregate
        error('account_bad_aggregate',
              "The account #{@val[0].fullId} cannot aggregate amounts " +
              "related to #{aggregate}.")
      end

      [ @val[0], @val[1] ]
    })
    arg(0, 'account', 'The ID of a previously defined leaf account.')
    arg(1, 'share', 'A percentage between 0 and 100%')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 602
  def rule_chargeset
    pattern(%w( _chargeset !chargeSetItem !moreChargeSetItems ), lambda {
      checkContainer('chargeset')
      items = [ @val[1] ]
      items += @val[2] if @val[2]
      chargeSet = ChargeSet.new
      begin
        items.each do |item|
          chargeSet.addAccount(item[0], item[1])
        end
        chargeSet.complete
      rescue TjException
        error('chargeset', $!.message, @sourceFileInfo[0], @property)
      end
      masterAccounts = []
      @property['chargeset', @scenarioIdx].each do |set|
        masterAccounts << set.master
      end
      if masterAccounts.include?(chargeSet.master)
        error('chargeset_master',
              "All charge sets for this property must have different " +
              "top-level accounts.", @sourceFileInfo[0], @property)
      end
      @property['chargeset', @scenarioIdx] =
        @property['chargeset', @scenarioIdx] + [ chargeSet ]
    })
    doc('chargeset', "A chargeset defines how the turnover associated with the property will be\ncharged to one or more accounts. A property may have any number of charge sets,\nbut each chargeset must deal with a different top-level account. A charge set\nconsists of one or more accounts. Each account must be a leaf account. The\naccount ID may be followed by a percentage value that determines the share for\nthis account. The total percentage of all accounts must be exactly 100%. If\nsome accounts don't have a percentage specification, the remainder to 100% is\ndistributed evenly to them.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 681
  def rule_chartScale
    singlePattern('_hour')
    descr('Set chart resolution to 1 hour.')

    singlePattern('_day')
    descr('Set chart resolution to 1 day.')

    singlePattern('_week')
    descr('Set chart resolution to 1 week.')

    singlePattern('_month')
    descr('Set chart resolution to 1 month.')

    singlePattern('_quarter')
    descr('Set chart resolution to 1 quarter.')

    singlePattern('_year')
    descr('Set chart resolution to 1 year.')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 701
  def rule_color
    pattern(%w( $STRING ), lambda {
      col = @val[0]
      unless /#[0-9A-Fa-f]{3}/ =~ col || /#[0-9A-Fa-f]{3}/ =~ col
        error('bad_color',
              "Color values must be specified as '#RGB' or '#RRGGBB' values",
              @sourceFileInfo[0])
      end
      col
    })
    arg(0, 'color', "The RGB color values of the color. The following formats are supported: #RGB\nand #RRGGBB. Where R, G, B are hexadecimal values. See\n[http://en.wikipedia.org/wiki/Web_colors Wikipedia] for more details.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 720
  def rule_columnBody
    optionsRule('columnOptions')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 724
  def rule_columnDef
    pattern(%w( !columnId !columnBody ), lambda {
      @val[0]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 730
  def rule_columnId
    pattern(%w( !reportableAttributes ), lambda {
      @column = TableColumnDefinition.new(@val[0], columnTitle(@val[0]))
    })
    doc('columnid', "This is a comprehensive list of all pre-defined [[columns]]. In addition to\nthe listed IDs all user defined attributes can be used as column IDs.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 742
  def rule_columnOptions
    optional
    repeatable

    pattern(%w( _celltext !logicalExpression $STRING ), lambda {
      @column.cellText.addPattern(
        CellSettingPattern.new(newRichText(@val[2], @sourceFileInfo[2]),
                               @val[1]))
    })
    doc('celltext.column', "Specifies an alternative content that is used for the cells of the column.\nUsually such a text contains a query function. Otherwise all cells of the\ncolumn will have the same fixed value. The logical expression specifies for\nwhich cells the text should be used. If multiple celltext patterns are\nprovided for a column, the first matching one is taken for each cell.\n"
        )
    arg(1, 'text',
        'Alterntive cell text specified as [[Rich_Text_Attributes|Rich Text]]')

    pattern(%w( _cellcolor !logicalExpression !color ), lambda {
      @column.cellColor.addPattern(
        CellSettingPattern.new(@val[2], @val[1]))
    })
    doc('cellcolor.column', "Specifies an alternative background color for the cells of this column. The\nlogical expression specifies for which cells the color should be used. If\nmultiple cellcolor patterns are provided for a column, the first\nmatching one is used for each cell.\n"
       )

    pattern(%w( _end !date ), lambda {
      @column.end = @val[1]
    })
    doc('end.column', "Normally, columns with calculated values take the specified report period into\naccount when calculating their values. With this attribute, the user can\nspecify an end date for the period that should be used when calculating the\nvalues of this column. It does not have an impact on column with time\ninvariant values.\n"
       )

    pattern(%w( _fontcolor !logicalExpression !color ), lambda {
      @column.fontColor.addPattern(
        CellSettingPattern.new(@val[2], @val[1]))
    })
    doc('fontcolor.column', "Specifies an alternative font color for the cells of this column. The\nlogical expression specifies for which cells the color should be used. If\nmultiple fontcolor patterns are provided for a column, the first\nmatching one is used for each cell.\n"
       )

    pattern(%w( _halign !logicalExpression !hAlignment ), lambda {
      @column.hAlign.addPattern(
        CellSettingPattern.new(@val[2], @val[1]))
    })
    doc('halign.column', "Specifies the horizontal alignment of the cell content. The logical expression\nspecifies for which cells the alignment setting should be used. If multiple\nhalign patterns are provided for a column, the first matching one is used for\neach cell.\n"
       )

    pattern(%w( _listitem $STRING ), lambda {
      @column.listItem = @val[1]
    })
    doc('listitem.column', "Specifies a RichText pattern that is used to generate the text for the list\nitems. The pattern should contain at least one ''''<nowiki><</nowiki>-query\nattribute='XXX'->'''' element that will be replaced with the value of\nattribute XXX. For the replacement, the property of the query will be the list\nitem.\n"
       )

    pattern(%w( _listtype !listType ), lambda {
      @column.listType = @val[1]
    })
    also(%w( listitem.column ))
    doc('listtype.column', "Specifies what type of list should be used. This attribute only affects\ncolumns that contain a list of items.\n"
       )

    pattern(%w( _period !interval ), lambda {
      @column.start = @val[1].start
      @column.end = @val[1].end
    })
    doc('period.column', "This property is a shortcut for setting the [[start.column|start]] and\n[[end.column|end]] property at the same time.\n"
       )

    pattern(%w( _scale !chartScale ), lambda {
      @column.scale = @val[1]
    })
    doc('scale.column', "Specifies the scale that should be used for a chart column. This value is ignored for all other columns.\n"
       )

    pattern(%w( _start !date ), lambda {
      @column.start = @val[1]
    })
    doc('start.column', "Normally, columns with calculated values take the specified report period into\naccount when calculating their values. With this attribute, the user can\nspecify a start date for the period that should be used when calculating the\nvalues of this column. It does not have an impact on column with time\ninvariant values.\n"
       )

    pattern(%w( _title $STRING ), lambda {
      @column.title = @val[1]
    })
    doc('title.column', "Specifies an alternative title for a report column.\n"
       )
    arg(1, 'text', 'The new column title.')

    pattern(%w( _tooltip !logicalExpression $STRING ), lambda {
      @column.tooltip.addPattern(
        CellSettingPattern.new(newRichText(@val[2], @sourceFileInfo[2]),
                               @val[1]))
    })
    doc('tooltip.column', "Specifies an alternative content for the tooltip. This will replace the\noriginal content of the tooltip that would be available for columns with text\nthat does not fit the column with.  The logical expression specifies for which\ncells the text should be used. If multiple tooltip patterns are provided for a\ncolumn, the first matching one is taken for each cell.\n"
       )
    arg(2, 'text', "The content of the tooltip. The text is interpreted as [[Rich_Text_Attributes|\nRich Text]].\n"
       )

    pattern(%w( _width !number ), lambda {
      @column.width = @val[1]
    })
    doc('width.column', "Specifies the width of the column in screen pixels. If the content of the\ncolumn does not fit into this width, it will be cut off. In some cases a\nscrollbar is added or a tooltip window with the complete content is shown when\nthe mouse is moved over the column. The latter is only supported in\ninteractive output formats.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 917
  def rule_currencyFormat
    pattern(%w( _currencyformat $STRING $STRING $STRING $STRING $INTEGER ),
        lambda {
      RealFormat.new(@val.slice(1, 5))
    })
    doc('currencyformat',
        'These values specify the default format used for all currency ' +
        'values.')
    example('Currencyformat')
    arg(1, 'negativeprefix', 'Prefix for negative numbers')
    arg(2, 'negativesuffix', 'Suffix for negative numbers')
    arg(3, 'thousandsep', 'Separator used for every 3rd digit')
    arg(4, 'fractionsep', 'Separator used to separate the fraction digits')
    arg(5, 'fractiondigits', 'Number of fraction digits to show')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 933
  def rule_date
    pattern(%w( !dateCalcedOrNot ), lambda {
      resolution = @project.nil? ? Project.maxScheduleGranularity :
                                   @project['scheduleGranularity']
      if @val[0] % resolution != 0
        error('misaligned_date',
              "The date must be aligned to the timing resolution (" +
              "#{resolution / 60} min) of the project.",
              @sourceFileInfo[0])
      end
      @val[0]
    })
    doc('date', "A DATE is date and time specification similar to the ISO 8601 date format.\nInstead of the hard to read ISO notation with a ''''T'''' between the date and\ntime sections, we simply use the more intuitive and easier to read dash:\n''''<nowiki>YYYY-MM-DD[-hh:mm[:ss]][-TIMEZONE]</nowiki>''''. Hour, minutes,\nseconds, and the ''''TIMEZONE'''' are optional. If not specified, the values\nare set to 0.  ''''TIMEZONE'''' must be an offset to GMT or UTC, specified as\n''''+HHMM'''' or ''''-HHMM''''. Dates must always be aligned with the\n[[timingresolution]].\n\nTaskJuggler also supports simple date calculations. You can add or substract a\ngiven interval from a fixed date.\n\n %{2009-11-01 + 8m}\n\nThis will result in an actual date of around 2009-07-01. Keep in mind that due\nto the varying lengths of months TaskJuggler cannot add exactly 8 calendar\nmonths. The date calculation functionality makes most sense when used with\nmacros.\n\n %{${now} - 2w}\n\nThis is result in a date 2 weeks earlier than the current (or specified) date.\nSee [[duration]] for a complete list of supported time intervals. Don't forget\nto put at least one space character after the date to prevent TaskJuggler from\ninterpreting the interval as an hour.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 976
  def rule_dateCalcedOrNot
    singlePattern('$DATE')
    pattern(%w( _% _{ $DATE !plusOrMinus !intervalDuration _} ), lambda {
      @val[2] + ((@val[3] == '+' ? 1 : -1) * @val[4])
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 983
  def rule_declareFlagList
    listRule('moreDeclareFlagList', '$ID')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 987
  def rule_details
    pattern(%w( _details $STRING ), lambda {
      return if @val[1].empty?

      rtTokenSetMore =
        [ :LINEBREAK, :SPACE, :WORD, :BOLD, :ITALIC, :CODE, :BOLDITALIC,
          :PRE, :HREF, :HREFEND, :REF, :REFEND, :HLINE, :TITLE2, :TITLE3,
          :TITLE4, :TITLE2END, :TITLE3END, :TITLE4END,
          :BULLET1, :BULLET2, :BULLET3, :BULLET4, :NUMBER1, :NUMBER2, :NUMBER3,
          :NUMBER4 ]
      if @val[1] == "Some more details\n"
        error('ts_default_details',
              "'Some more details' is not a valid value",
              @sourceFileInfo[1])
      end
      @journalEntry.details = newRichText(@val[1], @sourceFileInfo[1],
                                          rtTokenSetMore)
    })
    doc('details', "This is a continuation of the [[summary]] of the journal or status entry. It\ncan be several paragraphs long.\n"
       )
    arg(1, 'text', "The text will be interpreted as [[Rich_Text_Attributes|Rich Text]]. Only a\nsubset of the markup is supported for this attribute. You can use word\nformatting, paragraphs, hyperlinks, lists, section and subsection\nheaders.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1021
  def rule_durationUnit
    pattern(%w( _min ), lambda { 0 })
    descr('minutes')

    pattern(%w( _h ), lambda { 1 })
    descr('hours')

    pattern(%w( _d ), lambda { 2 })
    descr('days')

    pattern(%w( _w ), lambda { 3 })
    descr('weeks')

    pattern(%w( _m ), lambda { 4 })
    descr('months')

    pattern(%w( _y ), lambda { 5 })
    descr('years')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1041
  def rule_durationUnitOrPercent
    pattern(%w( _% ), lambda { -1 })
    descr('percentage of reported period')

    pattern(%w( _min ), lambda { 0 })
    descr('minutes')

    pattern(%w( _h ), lambda { 1 })
    descr('hours')

    pattern(%w( _d ), lambda { 2 })
    descr('days')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1055
  def rule_export
    pattern(%w( !exportHeader !exportBody ), lambda {
      @property = nil
    })
    doc('export', "The export report looks like a regular TaskJuggler file with the provided\ninput data complemented by the results of the scheduling process. The content\nof the report can be controlled with the [[definitions]] attribute. In case\nthe file contains the project header, a ''''.tjp'''' extension is added to the\nfile name. Otherwise, a ''''.tji'''' extension is used.\n\nThe [[resourceattributes]] and [[taskattributes]] attributes provide even more\ncontrol over the content of the file.\n\nThe export report can be used to share certain tasks or milestones with other\nprojects or to save past resource allocations as immutable part for future\nscheduling runs. When an export report is included the project IDs of the\nincluded tasks must be declared first with the project id property.\n"
       )
    example('Export')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1104
  def rule_exportAttributes
    optional
    repeatable

    pattern(%w( _definitions !exportDefinitions ), lambda {
      @property.set('definitions', @val[1])
    })
    doc('definitions', "This attributes controls what definitions will be contained in the report. If\nthe list includes ''project'', the generated file will have a ''''.tjp''''\nextension. Otherwise it will have a ''''.tji'''' extension.\n\nBy default, the report contains everything and the generated files has a ''''.tjp'''' extension.\n"
       )
    allOrNothingListRule('exportDefinitions',
                         { 'flags' => 'Include flag definitions',
                           'project' => 'Include project header',
                           'projecids' => 'Include project IDs',
                           'tasks' => 'Include task definitions',
                           'resources' => 'Include resource definitions' })
    pattern(%w( !hideresource ))
    pattern(%w( !hidetask ))
    pattern(%w( !reportEnd ))
    pattern(%w( !reportPeriod ))
    pattern(%w( !reportStart ))

    pattern(%w( _resourceattributes !exportableResourceAttributes ), lambda {
      @property.set('resourceAttributes', @val[1])
    })
    doc('resourceattributes', "Define a list of resource attributes that should be included in the report.\n"
       )
    allOrNothingListRule('exportableResourceAttributes',
                         { 'booking' => 'Include bookings',
                           'leaves' => 'Include leaves',
                           'workinghours' => 'Include working hours' })

    pattern(%w( !rollupresource ))
    pattern(%w( !rolluptask ))

    pattern(%w( _scenarios !scenarioIdList ), lambda {
      # Don't include disabled scenarios in the report
      @val[1].delete_if { |sc| !@project.scenario(sc).get('active') }
      @property.set('scenarios', @val[1])
    })
    doc('scenarios.export', "List of scenarios that should be included in the report. By default, all\nscenarios will be included. This attribute can be used to limit the included\nscenarios to a defined list.\n"
       )

    pattern(%w( _taskattributes !exportableTaskAttributes ), lambda {
      @property.set('taskAttributes', @val[1])
    })
    doc('taskattributes', "Define a list of task attributes that should be included in the report.\n"
       )
    allOrNothingListRule('exportableTaskAttributes',
                         { 'booking' => 'Include bookings',
                           'complete' => 'Include completion values',
                           'depends' => 'Include dependencies',
                           'flags' => 'Include flags',
                           'maxend' => 'Include maximum end dates',
                           'maxstart' => 'Include maximum start dates',
                           'minend' =>  'Include minimum end dates',
                           'minstart' => 'Include minimum start dates',
                           'note' => 'Include notes',
                           'priority' => 'Include priorities',
                           'responsible' => 'Include responsible resource' })

    pattern(%w( _timezone !validTimeZone ), lambda {
      @property.set('timezone', @val[1])
    })
    doc('timezone.export',
        "Set the time zone to be used for all dates in the report.")
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1189
  def rule_exportBody
    optionsRule('exportAttributes')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1079
  def rule_exportHeader
    pattern(%w( _export !optionalID $STRING ), lambda {
      newReport(@val[1], @val[2], :export, @sourceFileInfo[0])
      @property.set('formats', [ :tjp ])

      # By default, we export all scenarios.
      scenarios = Array.new(@project.scenarios.items) { |i| i }
      scenarios.delete_if { |sc| !@project.scenario(sc).get('active') }
      @property.set('scenarios', scenarios)
      # Show all tasks, sorted by seqno-up.
      @property.set('hideTask', LogicalExpression.new(LogicalOperation.new(0)))
      @property.set('sortTasks', [ [ 'seqno', true, -1 ] ])
      # Show all resources, sorted by seqno-up.
      @property.set('hideResource',
                    LogicalExpression.new(LogicalOperation.new(0)))
      @property.set('sortResources', [ [ 'seqno', true, -1 ] ])
    })
    arg(2, 'file name', "The name of the report file to generate. It must end with a .tjp or .tji\nextension, or use . to use the standard output channel.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1193
  def rule_extendAttributes
    optional
    repeatable

    pattern(%w( _date !extendId  $STRING !extendOptionsBody ), lambda {
      # Extend the propertySet definition and parser rules
      if extendPropertySetDefinition(DateAttribute, nil)
        @ruleToExtendWithScenario.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '!date' ], lambda {
            @property[@val[0], @scenarioIdx] = @val[1]
          }))
      else
        @ruleToExtend.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '!date' ], lambda {
            @property.set(@val[0], @val[1])
          }))
      end
    })
    doc('date.extend', "Extend the property with a new attribute of type date.\n"
       )
    arg(2, 'name', 'The name of the new attribute. It is used as header ' +
                   'in report columns and the like.')

    pattern(%w( _reference !extendId $STRING !extendOptionsBody ), lambda {
      # Extend the propertySet definition and parser rules
      if extendPropertySetDefinition(ReferenceAttribute, nil)
        @ruleToExtendWithScenario.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '$STRING', '!referenceBody' ], lambda {
            @property[@val[0], @scenarioIdx] = [ @val[1], @val[2] ]
          }))
      else
        @ruleToExtend.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '$STRING', '!referenceBody' ], lambda {
            @property.set(@val[0], [ @val[1], @val[2] ])
          }))
      end
    })
    doc('reference.extend', "Extend the property with a new attribute of type reference. A reference is a\nURL and an optional text that will be shown instead of the URL if needed.\n"
       )
    arg(2, 'name', 'The name of the new attribute. It is used as header ' +
                   'in report columns and the like.')

    pattern(%w( _richtext !extendId $STRING !extendOptionsBody ), lambda {
      # Extend the propertySet definition and parser rules
      if extendPropertySetDefinition(RichTextAttribute, nil)
        @ruleToExtendWithScenario.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '$STRING' ], lambda {
            @property[@val[0], @scenarioIdx] =
              newRichText(@val[1], @sourceFileInfo[1])
          }))
      else
        @ruleToExtend.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '$STRING' ], lambda {
            @property.set(@val[0], newRichText(@val[1], @sourceFileInfo[1]))
          }))
      end
    })
    doc('richtext.extend', "Extend the property with a new attribute of type [[Rich_Text_Attributes|Rich\nText]].\n"
       )
    arg(2, 'name', 'The name of the new attribute. It is used as header ' +
                   'in report columns and the like.')

    pattern(%w( _text !extendId $STRING !extendOptionsBody ), lambda {
      # Extend the propertySet definition and parser rules
      if extendPropertySetDefinition(StringAttribute, nil)
        @ruleToExtendWithScenario.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '$STRING' ], lambda {
            @property[@val[0], @scenarioIdx] = @val[1]
          }))
      else
        @ruleToExtend.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '$STRING' ], lambda {
            @property.set(@val[0], @val[1])
          }))
      end
    })
    doc('text.extend', "Extend the property with a new attribute of type text. A text is a character\nsequence enclosed in single or double quotes.\n"
       )
    arg(2, 'name', 'The name of the new attribute. It is used as header ' +
                   'in report columns and the like.')

  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1291
  def rule_extendBody
    optionsRule('extendAttributes')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1295
  def rule_extendId
    pattern(%w( $ID ), lambda {
      unless (?A..?Z) === @val[0][0]
        error('extend_id_cap',
              "User defined attributes IDs must start with a capital letter",
              @sourceFileInfo[0])
      end
      @val[0]
    })
    arg(0, 'id', 'The ID of the new attribute. It can be used like the ' +
                 'built-in IDs.')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1308
  def rule_extendOptions
    optional
    repeatable

    singlePattern('_inherit')
    doc('inherit.extend', "If the this attribute is used, the property extension will be inherited by\nchild properties from their parent property.\n"
       )

    singlePattern('_scenariospecific')
    doc('scenariospecific.extend', "If this attribute is used, the property extension is scenario specific. A\ndifferent value can be set for each scenario.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1329
  def rule_extendOptionsBody
    optionsRule('extendOptions')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1333
  def rule_extendProperty
    pattern(%w( !extendPropertyId ), lambda {
      case @val[0]
      when 'task'
        @ruleToExtend = @rules[:taskAttributes]
        @ruleToExtendWithScenario = @rules[:taskScenarioAttributes]
        @propertySet = @project.tasks
      when 'resource'
        @ruleToExtend = @rules[:resourceAttributes]
        @ruleToExtendWithScenario = @rules[:resourceScenarioAttributes]
        @propertySet = @project.resources
      end
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1348
  def rule_extendPropertyId
    singlePattern('_task')
    singlePattern('_resource')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1353
  def rule_fail
    pattern(%w( _fail !logicalExpression ), lambda {
      begin
        @property.set('fail', @property.get('fail') + [ @val[1] ])
      rescue AttributeOverwrite
      end
    })
    doc('fail', "The fail attribute adds a logical expression to the property. The condition\ndescribed by the logical expression is checked after the scheduling and an\nerror is raised if the condition evaluates to true. This attribute is\nprimarily intended for testing purposes.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1370
  def rule_flag
    pattern(%w( $ID ), lambda {
      unless @project['flags'].include?(@val[0])
        error('undecl_flag', "Undeclared flag '#{@val[0]}'",
              @sourceFileInfo[0])
      end
      @val[0]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1491
  def rule_flagList
    listRule('moreFlagList', '!flag')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1380
  def rule_flagLogicalExpression
    pattern(%w( !flagOperation ), lambda {
      LogicalExpression.new(@val[0], sourceFileInfo)
    })
    doc('logicalflagexpression', "A logical flag expression is a combination of operands and mathematical\noperations.  The final result of a logical expression is always true or false.\nLogical expressions are used the reduce the properties in a report to a\ncertain subset or to select alternatives for the cell content of a table. When\nused with attributes like [[hidejournalentry]] the logical expression\nevaluates to true for a certain property, this property is hidden or rolled-up\nin the report.\n\nOperands must be previously declared flags or another logical expression.\nWhen you combine logical operations to a more complex expression, the\noperators are evaluated from left to right. '''a | b & c''' is identical to\n'''(a | b) & c'''. It's highly recommended that you always use brackets to\ncontrol the evaluation sequence. Currently, TaskJuggler does not support the\nconcept of operator precedence or right-left associativity. This may change in\nthe future.\n"
       )
    also(%w( functions ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1406
  def rule_flagOperand
    pattern(%w( _( !flagOperation _) ), lambda {
      @val[1]
    })
    pattern(%w( _~ !flagOperand ), lambda {
      operation = LogicalOperation.new(@val[1])
      operation.operator = '~'
      operation
    })

    pattern(%w( $ID ), lambda {
      unless @project['flags'].include?(@val[0])
        error('operand_unkn_flag', "Undeclared flag '#{@val[0]}'",
              @sourceFileInfo[0])
      end
      LogicalFlag.new(@val[0])
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1425
  def rule_flagOperation
    pattern(%w( !flagOperand !flagOperationChain ), lambda {
      operation = LogicalOperation.new(@val[0])
      if @val[1]
        # Further operators/operands create an operation tree.
        @val[1].each do |ops|
          operation = LogicalOperation.new(operation)
          operation.operator = ops[0]
          operation.operand2 = ops[1]
        end
      end
      operation
    })
    arg(0, 'operand', "An operand is a declared flag. An operand can be a negated operand by\nprefixing a ~ charater or it can be another logical expression enclosed in\nbraces.\n"
        )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1447
  def rule_flagOperationChain
    optional
    repeatable
    pattern(%w( !flagOperatorAndOperand), lambda {
      @val[0]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1468
  def rule_flagOperator
    singlePattern('_|')
    descr('The \'or\' operator')

    singlePattern('_&')
    descr('The \'and\' operator')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1455
  def rule_flagOperatorAndOperand
    pattern(%w( !flagOperator !flagOperand), lambda{
      [ @val[0], @val[1] ]
    })
    arg(1, 'operand', "An operand is a declared flag. An operand can be a negated operand by\nprefixing a ~ charater or it can be another logical expression enclosed in\nbraces.\n"
        )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1477
  def rule_flags
    pattern(%w( _flags !flagList ), lambda {
      @val[1].each do |flag|
        next if @property['flags', @scenarioIdx].include?(flag)

        # We allow multiple instances of flag definitions.
        begin
          @property['flags', @scenarioIdx] += [ flag ]
        rescue AttributeOverwrite
        end
      end
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1495
  def rule_formats
    pattern(%w( _formats !outputFormats ), lambda {
      @property.set('formats', @val[1])
    })
    doc('formats', "This attribute defines for which output formats the report should be\ngenerated. By default, this list is empty. Unless a formats attribute was\nadded to a report definition, no output will be generated for this report.\n\nAs reports are composable, a report may include other report definitions. A\nformat definition is only needed for the outermost report that includes the\nothers.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1558
  def rule_functionPatterns
    # This rule is not used by the parser. It's only for the documentation.
    pattern(%w( _hasalert _( $INTEGER _, !date _) ))
    doc('hasalert', "Will evaluate to true if the current property has a current alert message within the report time frame and with at least the provided alert level.\n"
       )
    arg(2, 'Level', 'The minimum required alert level to be considered.')

    pattern(%w( _isactive _( $ID _) ))
    doc('isactive', "Will evaluate to true for tasks and resources if they have bookings in\nthe scenario during the report time frame.\n"
       )
    arg(2, 'ID', 'A scenario ID')

    pattern(%w( _ischildof _( $ID _) ))
    doc('ischildof', "Will evaluate to true for tasks and resources if current property is a child\nof the provided parent property.\n"
       )
    arg(2, 'ID', 'The ID of the parent')

    pattern(%w( _isdependencyof _( $ID _, $ID _, $INTEGER _) ))
    doc('isdependencyof', "Will evaluate to true for tasks that depend on the specified task in\nthe specified scenario and are no more than distance tasks away. If\ndistance is 0, all dependencies are considered independent of their\ndistance.\n"
       )
    arg(2, 'Task ID', 'The ID of a defined task')
    arg(4, 'Scenario ID', 'A scenario ID')
    arg(6, 'Distance', 'The maximum task distance to be considered')

    pattern(%w( _isdutyof _( $ID _, $ID _) ))
    doc('isdutyof', "Will evaluate to true for tasks that have the specified resource\nassigned to it in the specified scenario.\n"
       )
    arg(2, 'Resource ID', 'The ID of a defined resource')
    arg(4, 'Scenario ID', 'A scenario ID')

    pattern(%w( _isfeatureof _( $ID _, $ID _) ))
    doc('isfeatureof', "If the provided task or any of its sub-tasks depend on this task or any of its\nsub-tasks, we call this task a feature of the provided task.\n"
       )
    arg(2, 'Task ID', 'The ID of a defined task')
    arg(4, 'Scenario ID', 'A scenario ID')

    pattern(['_isleaf', '_(', '_)' ])
    doc('isleaf', 'The result is true if the property is not a container.')

    pattern(%w( _ismilestone _( $ID _) ))
    doc('ismilestone', "The result is true if the property is a milestone in the provided scenario.\n"
       )
    arg(2, 'Scenario ID', 'A scenario ID')

    pattern(%w( _isongoing _( $ID _) ))
    doc('isongoing', "Will evaluate to true for tasks that overlap with the report period in given\nscenario.\n"
       )
    arg(2, 'ID', 'A scenario ID')

    pattern(['_isresource', '_(', '_)' ])
    doc('isresource', 'The result is true if the property is a resource.')

    pattern(%w( _isresponsibilityof _( $ID _, $ID _) ))
    doc('isresponsibilityof', "Will evaluate to true for tasks that have the specified resource\nassigned as [[responsible]] in the specified scenario.\n"
       )
    arg(2, 'Resource ID', 'The ID of a defined resource')
    arg(4, 'Scenario ID', 'A scenario ID')

    pattern(['_istask', '_(', '_)' ])
    doc('istask', 'The result is true if the property is a task.')

    pattern(%w( _treelevel _( _) ))
    doc('treelevel', "Returns the nesting level of a property in the property tree.\nTop level properties have a level of 1, their children 2 and so on.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1512
  def rule_functions
    # This rule is not used by the parser. It's only for the documentation.
    pattern(%w( !functionsBody ))
    doc('functions', "The following functions are supported in logical expressions. These functions\nare evaluated in logical conditions such as hidetask or rollupresource. For\nthe evaluation, implicit and explicit parameters are used.\n\nAll functions may operate on the current property and the scope property. The\nscope property is the enclosing property in reports with nested properties.\nImagine e. g a task report with nested resources. When the function is called\nfor a task line, the task is the property and we don't have a scope property.\nWhen the function is called for a resource line, the resource is the property\nand the enclosing task is the scope property.\n\nThese number of arguments that are passed in brackets to the function depends\non the specific function. See the reference for details on each function.\n\nAll functions can be suffixed with an underscore character. In that case, the\nfunction is operating on the scope property as if it were the property. The\noriginal property is ignored in that case. In our task report example from\nabove, calling a function with an appended dash would mean that a task\nline would be evaluated for the enclosing resource.\n\nIn the example below you can see how this can be used. To generate a task\nreport that lists all assigned leaf resources for leaf task lines only we use\nthe expression\n\n hideresource ~(isleaf() & isleaf_())\n\nThe tilde in front of the bracketed expression means not that expression. In\nother words: show resources that are leaf resources and show them for leaf\ntasks only. The regular form isleaf() (without the appended underscore)\noperates on the resource. The isleaf_() variant operates on the\nenclosing task.\n"
       )
    example('LogicalFunction', '1')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1553
  def rule_functionsBody
    # This rule is not used by the parser. It's only for the documentation.
    optionsRule('functionPatterns')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1664
  def rule_hAlignment
    pattern(%w( _center ), lambda {
      :center
    })
    doc('halign.center', 'Center the cell content')

    pattern(%w( _left ), lambda {
      :left
    })
    doc('halign.left', 'Left align the cell content')

    pattern(%w( _right ), lambda {
      :right
    })
    doc('halign.right', 'Right align the cell content')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1681
  def rule_headline
    pattern(%w( _headline $STRING ), lambda {
      @property.set('headline', newRichText(@val[1], @sourceFileInfo[1]))
    })
    doc('headline', "Specifies the headline for a report.\n"
       )
    arg(1, 'text', "The text used for the headline. It is interpreted as\n[[Rich_Text_Attributes|Rich Text]].\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1698
  def rule_hideaccount
    pattern(%w( _hideaccount !logicalExpression ), lambda {
      @property.set('hideAccount', @val[1])
    })
    doc('hideaccount', "Do not include accounts that match the specified logical expression. If the\nreport is sorted in ''''tree'''' mode (default) then enclosing accounts are\nlisted even if the expression matches the account.\n"
       )
    also(%w( sortaccounts ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1712
  def rule_hidejournalentry
    pattern(%w( _hidejournalentry !flagLogicalExpression ), lambda {
      @property.set('hideJournalEntry', @val[1])
    })
    doc('hidejournalentry', "Do not include journal entries that match the specified logical expression.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1723
  def rule_hideresource
    pattern(%w( _hideresource !logicalExpression ), lambda {
      @property.set('hideResource', @val[1])
    })
    doc('hideresource', "Do not include resources that match the specified logical expression. If the\nreport is sorted in ''''tree'''' mode (default) then enclosing resources are\nlisted even if the expression matches the resource.\n"
       )
    also(%w( sortresources ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1737
  def rule_hidetask
    pattern(%w( _hidetask !logicalExpression ), lambda {
      @property.set('hideTask', @val[1])
    })
    doc('hidetask', "Do not include tasks that match the specified logical expression. If the\nreport is sorted in ''''tree'''' mode (default) then enclosing tasks are\nlisted even if the expression matches the task.\n"
       )
    also(%w( sorttasks ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1750
  def rule_iCalReport
    pattern(%w( !iCalReportHeader !iCalReportBody ), lambda {
      @property = nil
    })
    doc('icalreport', "Generates an RFC5545 compliant iCalendar file. This file can be used to export\ntask information to calendar applications or other tools that read iCalendar\nfiles.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1766
  def rule_iCalReportAttributes
    optional
    repeatable

    pattern(%w( !hideresource ))
    pattern(%w( !hidejournalentry ))
    pattern(%w( !hidetask ))
    pattern(%w( !reportEnd ))
    pattern(%w( !reportPeriod ))
    pattern(%w( !reportStart ))
    pattern(%w( !rollupresource ))
    pattern(%w( !rolluptask ))

    pattern(%w( _scenario !scenarioId ), lambda {
      # Don't include disabled scenarios in the report
      sc = @val[1]
      unless @project.scenario(sc).get('active')
        warning('ical_sc_disabled',
                "Scenario #{sc} has been disabled")
      else
        @property.set('scenarios', [ @val[1] ])
      end
    })
    doc('scenario.ical', "Id of the scenario that should be included in the report. By default, the\ntop-level scenario will be included. This attribute can be used select another\nscenario.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1762
  def rule_iCalReportBody
    optionsRule('iCalReportAttributes')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1798
  def rule_iCalReportHeader
    pattern(%w( _icalreport !optionalID $STRING ), lambda {
      newReport(@val[1], @val[2], :iCal, @sourceFileInfo[0])
      @property.set('formats', [ :iCal ])

      # By default, we export only the first scenario.
      unless @project.scenario(0).get('active')
        @property.set('scenarios', [ 0 ])
      end
      # Show all tasks, sorted by seqno-up.
      @property.set('hideTask', LogicalExpression.new(LogicalOperation.new(0)))
      @property.set('sortTasks', [ [ 'seqno', true, -1 ] ])
      # Show all resources, sorted by seqno-up.
      @property.set('hideResource',
                    LogicalExpression.new(LogicalOperation.new(0)))
      @property.set('sortResources', [ [ 'seqno', true, -1 ] ])
      # Show all journal entries.
      @property.set('hideJournalEntry',
                    LogicalExpression.new(LogicalOperation.new(0)))
    })
    arg(1, 'file name', "The name of the report file to generate without an extension.  Use . to use\nthe standard output channel.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1826
  def rule_idOrAbsoluteId
    singlePattern('$ID')
    singlePattern('$ABSOLUTE_ID')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1831
  def rule_includeAttributes
    optionsRule('includeAttributesBody')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1835
  def rule_includeAttributesBody
    optional
    repeatable

    pattern(%w( _accountprefix !accountId ), lambda {
      @accountprefix = @val[1].fullId
    })
    doc('accountprefix', "This attribute can be used to insert the accounts of the included file as\nsub-account of the account specified by ID. The parent account must already be\ndefined.\n"
    )
    arg(1, 'account ID', 'The absolute ID of an already defined account')

    pattern(%w( _reportprefix !reportId ), lambda {
      @reportprefix = @val[1].fullId
    })
    doc('reportprefix', "This attribute can be used to insert the reports of the included file as\nsub-report of the report specified by ID. The parent report must already\nbe defined.\n"
    )
    arg(1, 'report ID', 'The absolute ID of an already defined report.')

    pattern(%w( _resourceprefix !resourceId ), lambda {
      @resourceprefix = @val[1].fullId
    })
    doc('resourceprefix', "This attribute can be used to insert the resources of the included file as\nsub-resource of the resource specified by ID. The parent resource must already\nbe defined.\n"
    )
    arg(1, 'resource ID', 'The ID of an already defined resource')

    pattern(%w( _taskprefix !taskId ), lambda {
      @taskprefix = @val[1].fullId
    })
    doc('taskprefix', "This attribute can be used to insert the tasks of the included file as\nsub-task of the task specified by ID. The parent task must already be defined.\n"
    )
    arg(1, 'task ID', 'The absolute ID of an already defined task.')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1887
  def rule_includeFile
    pattern(%w( !includeFileName ), lambda {
      unless @project
        error('include_before_project',
              "You must declare the project header before you include other " +
              "files.")
      end
      @project.inputFiles << @scanner.include(@val[0], @sourceFileInfo[0]) do
        popFileStack
      end
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1900
  def rule_includeFileName
    pattern(%w( $STRING ), lambda {
      unless @val[0][-4, 4] == '.tji'
        error('bad_include_suffix', "Included files must have a '.tji'" +
                                    "extension: '#{@val[0]}'",
              @sourceFileInfo[0])
      end
      pushFileStack
      @val[0]
    })
    arg(0, 'filename', "Name of the file to include. This must have a ''''.tji'''' extension. The name\nmay have an absolute or relative path. You need to use ''''/'''' characters to\nseparate directories.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1919
  def rule_includeProperties
    pattern(%w( !includeFileName !includeAttributes ), lambda {
      @project.inputFiles << @scanner.include(@val[0], @sourceFileInfo[0]) do
        popFileStack
      end
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1960
  def rule_interval
    pattern(%w( !date !intervalEnd ), lambda {
      mode = @val[1][0]
      endSpec = @val[1][1]
      if mode == 0
        unless @val[0] < endSpec
          error('start_before_end', "The end date (#{endSpec}) must be after " +
                "the start date (#{@val[0]}).", @sourceFileInfo[0])
        end
        TimeInterval.new(@val[0], endSpec)
      else
        TimeInterval.new(@val[0], @val[0] + endSpec)
      end
    })
    doc('interval2', "There are two ways to specify a date interval. The first is the most\nobvious. A date interval consists of a start and end DATE. Watch out for end\ndates without a time specification! Date specifications are 0 extended. An\nend date without a time is expanded to midnight that day. So the day of the\nend date is not included in the interval! The start and end dates must be separated by a hyphen character.\n\nIn the second form specifies the start date and an interval duration. The\nduration must be prefixed by a plus character.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1988
  def rule_intervalDuration
    pattern(%w( !number !durationUnit ), lambda {
      convFactors = [ 60, # minutes
                      60 * 60, # hours
                      60 * 60 * 24, # days
                      60 * 60 * 24 * 7, # weeks
                      60 * 60 * 24 * 30.4167, # months
                      60 * 60 * 24 * 365 # years
                     ]
      if @val[0] == 0.0
        error('zero_duration', "The interval duration may not be 0.",
              @sourceFileInfo[1])
      end
      duration = @val[0] * convFactors[@val[1]]
      resolution = @project.nil? ? 60 * 60 : @project['scheduleGranularity']
      # Make sure the interval aligns with the timing resolution.
      (duration / resolution).to_i * resolution
    })
    arg(0, 'duration', 'The duration of the interval. May not be 0.')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2009
  def rule_intervalEnd
    pattern([ '_-', '!date' ], lambda {
      [ 0, @val[1] ]
    })

    pattern(%w( _+ !intervalDuration ), lambda {
      [ 1, @val[1] ]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2034
  def rule_intervalOptional
    optional
    singlePattern('!interval')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2019
  def rule_intervalOptionalEnd
    optional
    pattern([ '_-', '!date' ], lambda {
      [ 0, @val[1] ]
    })

    pattern(%w( _+ !intervalDuration ), lambda {
      [ 1, @val[1] ]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1927
  def rule_intervalOrDate
    pattern(%w( !date !intervalOptionalEnd ), lambda {
      if @val[1]
        mode = @val[1][0]
        endSpec = @val[1][1]
        if mode == 0
          unless @val[0] < endSpec
            error('start_before_end', "The end date (#{endSpec}) must be " +
                  "after the start date (#{@val[0]}).", @sourceFileInfo[0])
          end
          TimeInterval.new(@val[0], endSpec)
        else
          TimeInterval.new(@val[0], @val[0] + endSpec)
        end
      else
        TimeInterval.new(@val[0], @val[0].sameTimeNextDay)
      end
    })
    doc('interval3', "There are three ways to specify a date interval. The first is the most\nobvious. A date interval consists of a start and end DATE. Watch out for end\ndates without a time specification! Date specifications are 0 extended. An\nend date without a time is expanded to midnight that day. So the day of the\nend date is not included in the interval! The start and end dates must be separated by a hyphen character.\n\nIn the second form, the end date is omitted. A 24 hour interval is assumed.\n\nThe third form specifies the start date and an interval duration. The duration must be prefixed by a plus character.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2030
  def rule_intervals
    listRule('moreIntervals', '!intervalOrDate')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2039
  def rule_intervalsOptional
    optional
    singlePattern('!intervals')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2138
  def rule_journalEntry
    pattern(%w( !journalEntryHeader !journalEntryBody ), lambda {
      @val[0]
    })
    doc('journalentry', "This attribute adds an entry to the journal of the project. A journal can be\nused to record events, decisions or news that happened at a particular moment\nduring the project. Depending on the context, a journal entry may or may not\nbe associated with a specific property or author.\n\nA journal entry can consists of up to three parts. The headline is mandatory\nand should be only 5 to 10 words long. The introduction is optional and should\nbe only one or two sentences long. All other details should be put into the\nthird part.\n\nDepending on the context, journal entries are listed with headlines only, as\nheadlines plus introduction or in full.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2160
  def rule_journalEntryAttributes
    optional
    repeatable

    pattern(%w( _alert !alertLevel ), lambda {
      @journalEntry.alertLevel = @val[1]
    })
    doc('alert', "Specify the alert level for this entry. This attribute is inteded to be used for\nstatus reporting. When used for a journal entry that is associated with a\nproperty, the value can be reported in the alert column. When multiple entries\nhave been specified for the property, the entry with the date closest to the\nreport end date will be used. Container properties will inherit the highest\nalert level of all its sub properties unless it has an own journal entry dated\ncloser to the report end than all of its sub properties.\n"
       )

    pattern(%w( !author ))

    pattern(%w( _flags !flagList ), lambda {
      @val[1].each do |flag|
        next if @journalEntry.flags.include?(flag)

        @journalEntry.flags << flag
      end
    })
    doc('flags.journalentry', "Journal entries can have flags attached to them. These can be used to\ninclude only entries in a report that have a certain flag.\n"
       )

    pattern(%w( !summary ))

    pattern(%w( !details ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2200
  def rule_journalEntryBody
    optionsRule('journalEntryAttributes')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2204
  def rule_journalEntryHeader
    pattern(%w( _journalentry !valDate $STRING ), lambda {
      @journalEntry = JournalEntry.new(@project['journal'], @val[1], @val[2],
                                       @property, @sourceFileInfo[0])
    })
    arg(2, 'headline', "The headline of the journal entry. It will be interpreted as\n[[Rich_Text_Attributes|Rich Text]].\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2044
  def rule_journalReportAttributes
    pattern(%w( _journalattributes !journalReportAttributesList ), lambda {
      @property.set('journalAttributes', @val[1])
    })
    doc('journalattributes', "A list that determines which of the journal attributes should be included in\nthe journal report.\n"
       )
    allOrNothingListRule('journalReportAttributesList',
                         { 'alert' => 'Include the alert status',
                           'author' => 'Include the author if known',
                           'date' => 'Include the date',
                           'details' => 'Include the details',
                           'flags' => 'Include the flags',
                           'headline' => 'Include the headline',
                           'property' => 'Include the task or resource name',
                           'propertyid' => 'Include the property ID. ' +
                                           'Requires \'property\'.',
                           'summary' => 'Include the summary',
                           'timesheet' => 'Include the timesheet information.' +
                                          ' Requires \'property\'.'})
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2069
  def rule_journalReportMode
    pattern(%w( _journal ), lambda { :journal })
    descr("This is the regular journal. It contains all journal entries that are dated in\nthe query interval. If a property is given, only entries of this property are\nincluded. Without a property context, all the project entries are included\nunless hidden by other attributes like [[hidejournalentry]].\n"
       )
    pattern(%w( _journal_sub ), lambda { :journal_sub })
    descr("This mode only yields entries if used in the context of a task. It contains\nall journal entries that are dated in the query interval for the task and all\nits sub tasks.\n"
       )
    pattern(%w( _status_dep ), lambda { :status_dep })
    descr("In this mode only the last entries before the report end date for each\nproperty and all its sub-properties and their dependencies are included. If\nthere are multiple entries at the exact same date, then all these entries are\nincluded.\n"
       )
    pattern(%w( _status_down ), lambda { :status_down })
    descr("In this mode only the last entries before the report end date for each\nproperty and all its sub-properties are included. If there are multiple entries\nat the exact same date, then all these entries are included.\n"
       )
    pattern(%w( _status_up ), lambda { :status_up })
    descr("In this mode only the last entries before the report end date for each\nproperty are included. If there are multiple entries at the exact same date,\nthen all these entries are included. If any of the parent properties has a\nmore recent entry that is still before the report end date, no entries will be\nincluded.\n"
       )
    pattern(%w( _alerts_dep ), lambda { :alerts_dep })
    descr("In this mode only the last entries before the report end date for the context\nproperty and all its sub-properties and their dependencies is included. If\nthere are multiple entries at the exact same date, then all these entries are\nincluded. In contrast to the ''''status_down'''' mode, only entries with an\nalert level above the default level, and only those with the highest overall\nalert level are included.\n"
       )
    pattern(%w( _alerts_down ), lambda { :alerts_down })
    descr("In this mode only the last entries before the report end date for the context\nproperty and all its sub-properties is included. If there are multiple entries\nat the exact same date, then all these entries are included. In contrast to\nthe ''''status_down'''' mode, only entries with an alert level above the\ndefault level, and only those with the highest overall alert level are\nincluded.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2217
  def rule_journalSortCriteria
    pattern(%w( !journalSortCriterium !moreJournalSortCriteria ), lambda {
      [ @val[0] ] + (@val[1].nil? ? [] : @val[1])
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2223
  def rule_journalSortCriterium
    pattern(%w( $ABSOLUTE_ID ), lambda {
      supported = []
      JournalEntryList::SortingAttributes.each do |attr|
        supported << "#{attr}.up"
        supported << "#{attr}.down"
      end
      unless supported.include?(@val[0])
        error('bad_journal_sort_criterium',
              "Unsupported sorting criterium #{@val[0]}. Must be one of " +
              "#{supported.join(', ')}.")
      end
      attr, direction = @val[0].split('.')
      [ attr.intern, direction == 'up' ? 1 : -1 ]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2240
  def rule_leafResourceId
    pattern(%w( !resourceId ), lambda {
      resource = @val[0]
      unless resource.leaf?
        error('leaf_resource_id_expected',
              "#{resource.id} is not a leaf resource.", @sourceFileInfo[0])
      end
      resource
    })
    arg(0, 'resource', 'The ID of a leaf resource')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2252
  def rule_leave
    pattern(%w( !leaveType !vacationName !intervalOrDate ), lambda {
      Leave.new(@val[0].intern, @val[2], @val[1])
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2270
  def rule_leaveAllowance
    pattern(%w( _annual !valDate !optionalMinus !workingDuration ), lambda {
      LeaveAllowance.new(:annual, @val[1], (@val[2] ? -1 : 1) * @val[3])
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2276
  def rule_leaveAllowanceList
    listRule('moreLeaveAllowanceList', '!leaveAllowance')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2280
  def rule_leaveAllowances
    pattern(%w( _leaveallowances !leaveAllowanceList ), lambda {
      appendScListAttribute('leaveallowances', @val[1])
    })
    doc('leaveallowance', "Add or subtract leave allowances. Currently, only allowances for the annual\nleaves are supported. Allowances can be negative to deal with expired\nallowances. The ''''leaveallowancebalance'''' report [[columns|column]] can be\nused to report the current annual leave balance.\n\nLeaves outside of the project period are silently ignored and will not be\nconsidered in the leave balance calculation. Therefor, leave allowances are\nonly allowed within the project period.\n"
      )
    level(:beta)
    example('Leave')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2258
  def rule_leaveList
    listRule('moreLeaveList', '!leave')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2262
  def rule_leaveName
    optional
    pattern(%w( $STRING ), lambda {
      @val[0]
    })
    arg(0, 'name', 'An optional name or reason for the leave')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2325
  def rule_leaveType
    singlePattern('_project')
    descr('Assignment to another project (lowest priority)')

    singlePattern('_annual')
    descr('Personal leave based on annual allowance')

    singlePattern('_special')
    descr('Personal leave based on a special occasion')

    singlePattern('_sick')
    descr('Sick leave')

    singlePattern('_unpaid')
    descr('Unpaid leave')

    singlePattern('_holiday')
    descr('Public or bank holiday (highest priority)')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2300
  def rule_leaves
    pattern(%w( _leaves !leaveList ), lambda {
      LeaveList.new(@val[1])
    })
    doc('leaves', "Describe a list of leave periods. A leave can be due to a public holiday,\npersonal or sick leave. At global scope, the leaves determine which day is\nconsidered a working day. Subsequent resource definitions will inherit the\nleave list.\n\nLeaves can be defined at global level, at resource level and at shift level\nand intervals may overlap. The leave types have different priorities. A higher\npriority leave type can overwrite a lower priority type. This means that\nresource level leaves can overwrite global leaves when they have a higher\npriority. A sub resource can overwrite a leave of a enclosing resource.\n\nLeave periods outside of the project interval are silently ignored. For leave\nperiods that are partially outside of the project period only the part inside\nthe project period will be considered.\n"
       )
    example('Leave')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2345
  def rule_limitAttributes
    optionsRule('limitAttributesBody')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2349
  def rule_limitAttributesBody
    optional
    repeatable

    pattern(%w( _end !valDate ), lambda {
      @limitInterval.end = @val[1]
    })
    doc('end.limit', "The end date of the limit interval. It must be within the project time frame.\n"
    )

    pattern(%w( _period !valInterval ), lambda {
      @limitInterval = ScoreboardInterval.new(@project['start'],
                                              @project['scheduleGranularity'],
                                              @val[1].start, @val[1].end)
    })
    doc('period.limit', "This property is a shortcut for setting the start and end dates of the limit\ninterval. Both dates must be within the project time frame.\n"
       )

    pattern(%w( _resources !resourceLeafList ), lambda {
      @limitResources = @val[1]
    })
    doc('resources.limit', "When [[limits]] are used in a [[task]] context, the limits can be restricted\nto a list of resources that are allocated to the task. In that case each\nlisted resource will not be allocated more than the specified upper limit.\nLower limits have no impact on the scheduler but do generate a warning when\nnot met.  All specified resources must be leaf resources.\n"
       )
    example('Limits-1', '5')

    pattern(%w( _start !valDate ), lambda {
      @limitInterval.start = @val[1]
    })
    doc('start.limit', "The start date of the limit interval. It must be within the project time frame.\n"
    )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2398
  def rule_limitValue
    pattern([ '!workingDuration' ], lambda {
      @limitInterval = ScoreboardInterval.new(@project['start'],
                                              @project['scheduleGranularity'],
                                              @project['start'], @project['end'])
      @limitResources = []
      @val[0]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2408
  def rule_limits
    pattern(%w( !limitsHeader !limitsBody ), lambda {
      @val[0]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2414
  def rule_limitsAttributes
    optional
    repeatable

    pattern(%w( _dailymax !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('dailymax', "Set a maximum limit for each calendar day.\n"
       )
    example('Limits-1', '1')

    pattern(%w( _dailymin !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('dailymin', "Minimum required effort for any calendar day. This value cannot be guaranteed by\nthe scheduler. It is only checked after the schedule is complete. In case the\nminium required amount has not been reached, a warning will be generated.\n"
       )
    example('Limits-1', '4')

    pattern(%w( _maximum !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('maximum', "Set a maximum limit for the specified period. You must ensure that the overall\neffort can be achieved!\n"
       )

    pattern(%w( _minimum !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('minimum', "Set a minim limit for each calendar month. This will only result in a warning\nif not met.\n"
       )

    pattern(%w( _monthlymax !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('monthlymax', "Set a maximum limit for each calendar month.\n"
       )

    pattern(%w( _monthlymin !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('monthlymin', "Minimum required effort for any calendar month. This value cannot be\nguaranteed by the scheduler. It is only checked after the schedule is\ncomplete. In case the minium required amount has not been reached, a warning\nwill be generated.\n"
       )

    pattern(%w( _weeklymax !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('weeklymax', "Set a maximum limit for each calendar week.\n"
       )

    pattern(%w( _weeklymin !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('weeklymin', "Minimum required effort for any calendar week. This value cannot be guaranteed by\nthe scheduler. It is only checked after the schedule is complete. In case the\nminium required amount has not been reached, a warning will be generated.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2502
  def rule_limitsBody
    optionsRule('limitsAttributes')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2506
  def rule_limitsHeader
    pattern(%w( _limits ), lambda {
      @limits = Limits.new
      @limits.setProject(@project)
      @limits
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2514
  def rule_listOfDays
    pattern(%w( !weekDayInterval !moreListOfDays), lambda {
      weekDays = Array.new(7, false)
      ([ @val[0] ] + (@val[1] ? @val[1] : [])).each do |dayList|
        7.times { |i| weekDays[i] = true if dayList[i] }
      end
      weekDays
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2524
  def rule_listOfTimes
    pattern(%w( _off ), lambda {
      [ ]
    })
    pattern(%w( !timeInterval !moreTimeIntervals ), lambda {
      [ @val[0] ] + (@val[1].nil? ? [] : @val[1])
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2533
  def rule_listType
    pattern([ '_bullets' ], lambda { :bullets })
    descr('List items as bullet list')

    pattern([ '_comma' ], lambda { :comma })
    descr('List items as comma separated list')

    pattern([ '_numbered' ], lambda { :numbered })
    descr('List items as numbered list')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2544
  def rule_loadunit
    pattern([ '_days' ], lambda { :days })
    descr('Display all load and duration values as days.')

    pattern([ '_hours' ], lambda { :hours })
    descr('Display all load and duration values as hours.')

    pattern([ '_longauto'] , lambda { :longauto })
    descr("Automatically select the unit that produces the shortest and most readable\nvalue. The unit name will not be abbreviated. It will not use quarters since\nit is not common.\n"
         )

    pattern([ '_minutes' ], lambda { :minutes })
    descr('Display all load and duration values as minutes.')

    pattern([ '_months' ], lambda { :months })
    descr('Display all load and duration values as months.')

    pattern([ '_quarters' ], lambda { :quarters })
    descr('Display all load and duration values as quarters.')

    pattern([ '_shortauto' ], lambda { :shortauto })
    descr("Automatically select the unit that produces the shortest and most readable\nvalue. The unit name will be abbreviated. It will not use quarters since it is\nnot common.\n"
         )

    pattern([ '_weeks' ], lambda { :weeks })
    descr('Display all load and duration values as weeks.')

    pattern([ '_years' ], lambda { :years })
    descr('Display all load and duration values as years.')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2585
  def rule_logicalExpression
    pattern(%w( !operation ), lambda {
      LogicalExpression.new(@val[0], sourceFileInfo)
    })
    pattern(%w( _@ !allOrNone ), lambda {
      LogicalOperation.new(@val[1])
    })
    doc('logicalexpression', "A logical expression is a combination of operands and mathematical operations.\nThe final result of a logical expression is always true or false. Logical\nexpressions are used the reduce the properties in a report to a certain subset\nor to select alternatives for the cell content of a table. When used with\nattributes like [[hidetask]] or [[hideresource]] the logical expression\nevaluates to true for a certain property, this property is hidden or rolled-up\nin the report.\n\nOperands can be previously declared flags, built-in [[functions]], property\nattributes (specified as scenario.attribute) or another logical expression.\nWhen you combine logical operations to a more complex expression, the\noperators are evaluated from left to right. '''a | b & c''' is identical to\n'''(a | b) & c'''. It's highly recommended that you always use brackets to\ncontrol the evaluation sequence. Currently, TaskJuggler does not support the\nconcept of operator precedence or right-left associativity. This may change in\nthe future.\n\nAn operand can also be just a number. 0 evaluates to false, all other numbers\nto true. The logical expression can also be the special constants ''''@all'''' or ''''@none''''. The first always evaluates to true, the latter to false.\n"
       )
    also(%w( functions ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2618
  def rule_macro
    pattern(%w( _macro $ID $MACRO ), lambda {
      if @scanner.macroDefined?(@val[1])
        warning('marco_redefinition', "Redefining macro #{@val[1]}")
      end
      @scanner.addMacro(TextParser::Macro.new(@val[1], @val[2],
                                              @sourceFileInfo[0]))
    })
    doc('macro', "Defines a text fragment that can later be inserted by using the specified ID.\nTo insert the text fragment anywhere in the text you need to write ${ID}.The\nbody is not optional. It must be enclosed in square brackets. Macros can be\ndeclared like this:\n\n macro FOO [ This text ]\n\nIf later ''''${FOO}'''' is found in the project file, it is expanded to\n''''This text''''.\n\nMacros may have arguments. Arguments are accessed with special macros with\nnumbers as names.  The number specifies the index of the argument.\n\n macro FOO [ This ${1} text ]\n\nwill expand to ''''This stupid text'''' if called as ''''${FOO \"stupid\"}''''.\nMacros may call other macros. All macro arguments must be enclosed by double\nquotes. In case the argument contains a double quote, it must be escaped by a\nslash (''''/'''').\n\nUser defined macro IDs must have at least one uppercase letter as all\nlowercase letter IDs are reserved for built-in macros.\n\nTo terminate the macro definition, the ''''<nowiki>]</nowiki>'''' must be the\nlast character in the line. If there are any other characters trailing it\n(even spaces or comments) the ''''<nowiki>]</nowiki>'''' will not be\nconsidered the end of the macro definition.\n\nIn macro calls the macro names can be prefixed by a question mark. In this\ncase the macro will expand to nothing if the macro is not defined. Otherwise\nthe undefined macro would be flagged with an error message.\n\nThe macro call\n\n ${?foo}\n\nwill expand to nothing if foo is undefined.\n"
       )
    example('Macro-1')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2676
  def rule_moreAlternatives
    commaListRule('!resourceId')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2680
  def rule_moreArguments
    commaListRule('!argument')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2670
  def rule_moreBangs
    optional
    repeatable
    singlePattern('_!')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2684
  def rule_moreChargeSetItems
    commaListRule('!chargeSetItem')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2688
  def rule_moreColumnDef
    commaListRule('!columnDef')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2692
  def rule_moreDepTasks
    commaListRule('!taskDep')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2696
  def rule_moreJournalSortCriteria
    commaListRule('!journalSortCriterium')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2700
  def rule_moreListOfDays
    commaListRule('!weekDayInterval')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2704
  def rule_moreOutputFormats
    commaListRule('!outputFormat')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2712
  def rule_morePredTasks
    commaListRule('!taskPred')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2708
  def rule_moreProjectIDs
    commaListRule('$ID')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2716
  def rule_moreSortCriteria
    commaListRule('!sortNonTree')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2720
  def rule_moreTimeIntervals
    commaListRule('!timeInterval')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2724
  def rule_navigator
    pattern(%w( !navigatorHeader !navigatorBody ), lambda {
      @project['navigators'][@navigator.id] = @navigator
    })
    doc('navigator', "Defines a navigator object with the specified ID. This object can be used in\nreports to include a navigation bar with references to other reports.\n"
          )
    example('navigator')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2737
  def rule_navigatorAttributes
    optional
    repeatable
    pattern(%w( _hidereport !logicalExpression ), lambda {
      @navigator.hideReport = @val[1]
    })
    doc('hidereport', "This attribute can be used to exclude the reports that match the specified\nexpression from the navigation bar.\n"
          )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2751
  def rule_navigatorBody
    optional
    pattern(%w( _{ !navigatorAttributes _} ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2756
  def rule_navigatorHeader
    pattern(%w( _navigator $ID ), lambda {
      if @project['navigators'][@val[1]]
        error('navigator_exists',
              "The navigator #{@val[1]} has already been defined.",
              @sourceFileInfo[0])
      end
      @navigator = Navigator.new(@val[1], @project)
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2817
  def rule_nikuReport
    pattern(%w( !nikuReportHeader !nikuReportBody ), lambda {
      @property = nil
    })
    doc('nikureport', "This report generates an XML file to be imported into the enterprise resource\nmanagement software Clarity(R) from Computer Associates(R). The files contains\nallocation curves for the specified resources. All tasks with identical user\ndefined attributes ''''ClarityPID'''' and ''''ClarityPNAME'''' are bundled\ninto a Clarity project. The resulting XML file can be imported into Clarity\nwith the xog-in tool.\n"
       )
    example('Niku')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2767
  def rule_nikuReportAttributes
    optional
    repeatable

    pattern(%w( !formats ))
    pattern(%w( !headline ))
    pattern(%w( !hideresource ))
    pattern(%w( !hidetask ))

    pattern(%w( !numberFormat ), lambda {
      @property.set('numberFormat', @val[0])
    })

    pattern(%w( !reportEnd ))
    pattern(%w( !reportPeriod ))
    pattern(%w( !reportStart ))
    pattern(%w( !reportTitle ))

    pattern(%w( _timeoff $STRING $STRING ), lambda {
      @property.set('timeOffId', @val[1])
      @property.set('timeOffName', @val[2])
    })
    doc('timeoff.nikureport', "Set the Clarity project ID and name that the vacation time will be reported to.\n"
       )
    arg(1, 'ID', 'The Clarity project ID')
    arg(2, 'Name', 'The Clarity project name')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2798
  def rule_nikuReportBody
    pattern(%w( _{ !nikuReportAttributes _} ), lambda {

    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2804
  def rule_nikuReportHeader
    pattern(%w( _nikureport !optionalID $STRING ), lambda {
      newReport(@val[1], @val[2], :niku, @sourceFileInfo[0])
      @property.set('numberFormat', RealFormat.new(['-', '', '', '.', 2]))
    })
    arg(1, 'file name', "The name of the time sheet report file to generate. It must end with a .tji\nextension, or use . to use the standard output channel.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2834
  def rule_nodeId
    pattern(%w( !idOrAbsoluteId !subNodeId ), lambda {
      case @property.typeSpec
      when :taskreport
        if (p1 = @project.task(@val[0])).nil?
          error('unknown_main_node',
                "Unknown task ID #{@val[0]}", @sourceFileInfo[0])
        end
        if @val[1]
          if (p2 = @project.resource(@val[1])).nil?
            error('unknown_sub_node',
                  "Unknown resource ID #{@val[0]}", @sourceFileInfo[0])
          end
          return [ p2, p1 ]
        end
        return [ p1, nil ]
      when :resourcereport
        if (p1 = @project.task(@val[0])).nil?
          error('unknown_main_node',
                "Unknown task ID #{@val[0]}", @sourceFileInfo[0])
        end
        if @val[1]
          if (p2 = @project.resource(@val[1])).nil?
            error('unknown_sub_node',
                  "Unknown resource ID #{@val[0]}", @sourceFileInfo[0])
          end
          return [ p2, p1 ]
        end
        return [ p1, nil ]
      end

      raise "Node list is not supported for this report type: " +
            "#{@property.typeSpec}"
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2870
  def rule_nodeIdList
    listRule('moreNodeIdList', '!nodeId')
    pattern([ '_-' ], lambda {
      []
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2877
  def rule_number
    singlePattern('$INTEGER')
    singlePattern('$FLOAT')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2882
  def rule_numberFormat
    pattern(%w( _numberformat $STRING $STRING $STRING $STRING $INTEGER ),
        lambda {
      RealFormat.new(@val.slice(1, 5))
    })
    doc('numberformat',
        'These values specify the default format used for all numerical ' +
        'real values.')
    arg(1, 'negativeprefix', 'Prefix for negative numbers')
    arg(2, 'negativesuffix', 'Suffix for negative numbers')
    arg(3, 'thousandsep', 'Separator used for every 3rd digit')
    arg(4, 'fractionsep', 'Separator used to separate the fraction digits')
    arg(5, 'fractiondigits', 'Number of fraction digits to show')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2897
  def rule_operand
    pattern(%w( _( !operation _) ), lambda {
      @val[1]
    })
    pattern(%w( _~ !operand ), lambda {
      operation = LogicalOperation.new(@val[1])
      operation.operator = '~'
      operation
    })

    pattern(%w( $ABSOLUTE_ID ), lambda {
      if @val[0].count('.') > 1
        error('operand_attribute',
              'Attributes must be specified as <scenarioID>.<attribute>',
              @sourceFileInfo[0])
      end
      scenario, attribute = @val[0].split('.')
      if (scenarioIdx = @project.scenarioIdx(scenario)).nil?
        error('operand_unkn_scen', "Unknown scenario ID #{scenario}",
              @sourceFileInfo[0])
      end
      # TODO: Do at least some basic sanity checks of the attribute is valid.
      LogicalAttribute.new(attribute, @project.scenario(scenarioIdx))
    })
    pattern(%w( !date ), lambda {
      LogicalOperation.new(@val[0])
    })
    pattern(%w( $ID !argumentList ), lambda {
      if @val[1].nil?
        unless @project['flags'].include?(@val[0])
          error('operand_unkn_flag', "Undeclared flag '#{@val[0]}'",
                @sourceFileInfo[0])
        end
        LogicalFlag.new(@val[0])
      else
        func = LogicalFunction.new(@val[0])
        res = func.setArgumentsAndCheck(@val[1])
        unless res.nil?
          error(*res)
        end
        func
      end
    })
    pattern(%w( $INTEGER ), lambda {
      LogicalOperation.new(@val[0])
    })
    pattern(%w( $FLOAT ), lambda {
      LogicalOperation.new(@val[0])
    })
    pattern(%w( $STRING ), lambda {
      LogicalOperation.new(@val[0])
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2951
  def rule_operation
    pattern(%w( !operand !operationChain ), lambda {
      operation = LogicalOperation.new(@val[0])
      if @val[1]
        # Further operators/operands create an operation tree.
        @val[1].each do |ops|
          operation = LogicalOperation.new(operation)
          operation.operator = ops[0]
          operation.operand2 = ops[1]
        end
      end
      operation
    })
    arg(0, 'operand', "An operand can consist of a date, a text string, a [[functions|function]], a\nproperty attribute or a numerical value. It can also be the name of a declared\nflag.  Use the ''''scenario_id.attribute'''' notation to use an attribute of\nthe currently evaluated property. The scenario ID always has to be specified,\nalso for non-scenario specific attributes. This is necessary to distinguish\nthem from flags. See [[columnid]] for a list of available attributes. The use\nof list attributes is not recommended. User defined attributes are available\nas well.\n\nAn operand can be a negated operand by prefixing a ~ charater or it can be\nanother logical expression enclosed in braces.\n"
        )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2981
  def rule_operationChain
    optional
    repeatable
    pattern(%w( !operatorAndOperand), lambda {
      @val[0]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3000
  def rule_operator
    singlePattern('_|')
    descr('The \'or\' operator')

    singlePattern('_&')
    descr('The \'and\' operator')

    singlePattern('_>')
    descr('The \'greater than\' operator')

    singlePattern('_<')
    descr('The \'smaller than\' operator')

    singlePattern('_=')
    descr('The \'equal\' operator')

    singlePattern('_>=')
    descr('The \'greater-or-equal\' operator')

    singlePattern('_<=')
    descr('The \'smaller-or-equal\' operator')

    singlePattern('_!=')
    descr('The \'not-equal\' operator')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2989
  def rule_operatorAndOperand
    pattern(%w( !operator !operand), lambda{
      [ @val[0], @val[1] ]
    })
    arg(1, 'operand', "An operand can consist of a date, a text string or a numerical value. It can also be the name of a declared flag. Finally, an operand can be a negated operand by prefixing a ~ charater or it can be another operation enclosed in braces.\n"
        )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3026
  def rule_optionalID
    optional
    pattern(%w( $ID ), lambda {
      @val[0]
    })
    arg(0, 'id', "An optional ID. If you ever want to reference this property, you must specify\nyour own unique ID. If no ID is specified one will be automatically generated.\nThese IDs may become visible in reports, but may change at any time. You may\nnever rely on automatically generated IDs.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3041
  def rule_optionalMinus
    optional
    pattern(%w( _- ), lambda {
      true
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3048
  def rule_optionalPercent
    optional
    pattern(%w( !number _% ), lambda {
      @val[0] / 100.0
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3055
  def rule_optionalVersion
    optional
    pattern(%w( $STRING ), lambda {
      @val[0]
    })
    arg(0, 'version', "An optional version ID. This can be something simple as \"4.2\" or an ID tag of\na revision control system. If not specified, it defaults to \"1.0\".\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3068
  def rule_outputFormat
    pattern(%w( _csv ), lambda {
      :csv
    })
    descr("The report lists the resources and their respective values as\ncolon-separated-value (CSV) format. Due to the very simple nature of the CSV\nformat, only a small subset of features will be supported for CSV output.\nIncluding tasks or listing multiple scenarios will result in very difficult to\nread reports.\n"
         )

    pattern(%w( _html ), lambda {
      :html
    })
    descr('Generate a web page (HTML file)')

    pattern(%w( _niku ), lambda {
      :niku
    })
    descr('Generate a XOG XML file to be used with Clarity.')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3093
  def rule_outputFormats
    pattern(%w( !outputFormat !moreOutputFormats ), lambda {
      [ @val[0] ] + (@val[1].nil? ? [] : @val[1])
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3099
  def rule_plusOrMinus
    singlePattern('_+')
    singlePattern('_-')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3104
  def rule_project
    pattern(%w( !projectProlog !projectDeclaration !properties . ), lambda {
      @val[1]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3110
  def rule_projectBody
    optionsRule('projectBodyAttributes')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3114
  def rule_projectBodyAttributes
    repeatable
    optional

    pattern(%w( _alertlevels !alertLevelDefinitions ), lambda {
      if @val[1].length < 2
        error('too_few_alert_levels',
              'You must specify at least 2 different alert levels.',
              @sourceFileInfo[1])
      end
      levels = @project['alertLevels']
      levels.clear
      @val[1].each do |level|
        if levels.indexById(level[0])
          error('alert_level_redef',
                "Alert level '#{level[0]}' has been defined multiple times.",
                @sourceFileInfo[1])
        end

        if levels.indexByName(level[1])
          error('alert_name_redef',
                "Alert level name '#{level[1]}' has been defined multiple " +
                "times.", @sourceFileInfo[1])
        end

        @project['alertLevels'].add(AlertLevelDefinition.new(*level))
      end
    })
    level(:beta)
    doc('alertlevels', "By default TaskJuggler supports the pre-defined alert levels: green, yellow\nand red. This attribute can be used to replace them with your own set of alert\nlevels. You can define any number of levels, but you need to define at least\ntwo and they must be specified in ascending order from the least severity to\nhighest severity. Additionally, you need to provide a 15x15 pixel image file\nwith the name ''''flag-X.png'''' for each level where ''''X'''' matches the ID\nof the alert level. These files need to be in the ''''icons'''' directory to\nbe found by the browser when showing HTML reports.\n"
       )
    example('AlertLevels')

    pattern(%w( !currencyFormat ), lambda {
      @project['currencyFormat'] = @val[0]
    })

    pattern(%w( _currency $STRING ), lambda {
      @project['currency'] = @val[1]
    })
    doc('currency', 'The default currency unit.')
    example('Account')
    arg(1, 'symbol', 'Currency symbol')

    pattern(%w( _dailyworkinghours !number ), lambda {
      @project['dailyworkinghours'] = @val[1]
    })
    doc('dailyworkinghours', "Set the average number of working hours per day. This is used as\nthe base to convert working hours into working days. This affects\nfor example the length task attribute. The default value is 8 hours\nand should work for most Western countries. The value you specify should match\nthe settings you specified as your default [[workinghours.project|working\nhours]].\n"
       )
    example('Project')
    arg(1, 'hours', 'Average number of working hours per working day')

    pattern(%w( _extend !extendProperty !extendBody ), lambda {
      updateParserTables
    })
    doc('extend', "Often it is desirable to collect more information in the project file than is\nnecessary for task scheduling and resource allocation. To add such information\nto tasks, resources or accounts the user can extend these properties with\nuser-defined attributes. The new attributes can be of various types such as\ntext, date or reference to capture various types of data. Optionally the user\ncan specify if the attribute value should be inherited from the enclosing\nproperty.\n"
       )
    example('CustomAttributes')

    pattern(%w( !projectBodyInclude ))

    pattern(%w( !journalEntry ))

    pattern(%w( _now !date ), lambda {
      @project['now'] = @val[1]
      @scanner.addMacro(TextParser::Macro.new('now', @val[1].to_s,
                                              @sourceFileInfo[0]))
      @scanner.addMacro(TextParser::Macro.new(
        'today', @val[1].to_s(@project['timeFormat']), @sourceFileInfo[0]))
    })
    doc('now', "Specify the date that TaskJuggler uses for calculation as current\ndate. If no value is specified, the current value of the system\nclock is used.\n"
       )
    arg(1, 'date', 'Alternative date to be used as current date for all ' +
        'computations')

    pattern(%w( !numberFormat ), lambda {
      @project['numberFormat'] = @val[0]
    })

    pattern(%w( !scenario ))
    pattern(%w( _shorttimeformat $STRING ), lambda {
      @project['shortTimeFormat'] = @val[1]
    })
    doc('shorttimeformat',
        'Specifies time format for time short specifications. This is normal' +
        'just the hour and minutes.')
    arg(1, 'format', 'strftime like format string')

    pattern(%w( !timeformat ), lambda {
      @project['timeFormat'] = @val[0]
    })

    pattern(%w( !timezone ), lambda {
      @val[0]
    })

    pattern(%w( _timingresolution $INTEGER _min ), lambda {
      goodValues = [ 5, 10, 15, 20, 30, 60 ]
      unless goodValues.include?(@val[1])
        error('bad_timing_res',
              "Timing resolution must be one of #{goodValues.join(', ')} min.",
              @sourceFileInfo[1])
      end
      if @val[1] > (Project.maxScheduleGranularity / 60)
        error('too_large_timing_res',
              'The maximum allowed timing resolution for the timezone is ' +
              "#{Project.maxScheduleGranularity / 60} minutes.",
              @sourceFileInfo[1])
      end
      @project['scheduleGranularity'] = @val[1] * 60
    })
    doc('timingresolution', "Sets the minimum timing resolution. The smaller the value, the longer the\nscheduling process lasts and the more memory the application needs. The\ndefault and maximum value is 1 hour. The smallest value is 5 min.\nThis value is a pretty fundamental setting of TaskJuggler. It has a severe\nimpact on memory usage and scheduling performance. You should set this value\nto the minimum required resolution. Make sure that all values that you specify\nare aligned with the resolution.\n\nChanging the timing resolution will reset the [[workinghours.project|working\nhours]] to the default times. It's recommended that this is the very first\noption in the project header section.\n\nDo not use this option after you've set the time zone!\n"
        )

    pattern(%w( _trackingscenario !scenarioId ), lambda {
      @project['trackingScenarioIdx'] = @val[1]
      # The tracking scenario and all child scenarios will always be scheduled
      # in projection mode.
      @project.scenario(@val[1]).all.each do |scenario|
        scenario.set('projection', true)
      end
    })
    doc('trackingscenario', "Specifies which scenario is used to capture what actually has happened with\nthe project. All sub-scenarios of this scenario inherit the bookings of the\ntracking scenario and may not have any bookings of their own. The tracking\nscenario must also be specified to use time and status sheet reports.\n\nThe tracking scenario must be defined after all scenario have been defined.\n\nThe tracking scenario and all scenarios derived from it will be scheduled in\nprojection mode. This means that the scheduler will only add bookings after\nthe current date or the date specified by [[now]]. It is assumed that all\nallocations prior to this date have been provided as [[booking.task|\ntask bookings]] or [[booking.resource|resource bookings]].\n"
       )
    example('TimeSheet1', '2')

    pattern(%w( _weekstartsmonday ), lambda {
      @project['weekStartsMonday'] = true
    })
    doc('weekstartsmonday',
        'Specify that you want to base all week calculation on weeks ' +
        'starting on Monday. This is common in many European countries.')

    pattern(%w( _weekstartssunday ), lambda {
      @project['weekStartsMonday'] = false
    })
    doc('weekstartssunday',
        'Specify that you want to base all week calculation on weeks ' +
        'starting on Sunday. This is common in the United States of America.')

    pattern(%w( !workinghoursProject ))
    pattern(%w( _yearlyworkingdays !number ), lambda {
      @project['yearlyworkingdays'] = @val[1]
    })
    doc('yearlyworkingdays', "Specifies the number of average working days per year. This should correlate\nto the specified workinghours and vacation. It affects the conversion of\nworking hours, working days, working weeks, working months and working years\ninto each other.\n\nWhen public holidays and leaves are disregarded, this value should be equal\nto the number of working days per week times 52.1428 (the average number of\nweeks per year). E. g. for a culture with 5 working days it is 260.714 (the\ndefault), for 6 working days it is 312.8568 and for 7 working days it is\n365.\n"
       )
    arg(1, 'days', 'Number of average working days for a year')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3424
  def rule_projectBodyInclude
    pattern(%w( _include !includeFile !projectBodyAttributes . ))
    lastSyntaxToken(1)
    doc('include.project', "Includes the specified file name as if its contents would be written\ninstead of the include property. When the included files contains other\ninclude statements or report definitions, the filenames are relative to file\nwhere they are defined in.\n\nThis version of the include directive may only be used inside the [[project]]\nheader section. The included files must only contain content that may be\npresent in a project header section.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3336
  def rule_projectDeclaration
    pattern(%w( !projectHeader !projectBody ), lambda {
      # If the user has specified a tracking scenario, we mark all children of
      # that scenario to disallow own bookings. These scenarios will inherit
      # their bookings from the tracking scenario.
      if (idx = @project['trackingScenarioIdx'])
        @project.scenario(idx).allLeaves(true).each do |scenario|
          scenario.set('ownbookings', false)
        end
      end
      @val[0]
    })
    doc('project', "The project property is mandatory and should be the first property\nin a project file. It is used to capture basic attributes such as\nthe project id, name and the expected time frame.\n\nBe aware that the dates for the project period default to UTC times. See [[interval2]] for details.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3359
  def rule_projectHeader
    pattern(%w( _project !optionalID $STRING !optionalVersion !interval ), lambda {
      @project = Project.new(@val[1], @val[2], @val[3])
      @project['start'] = @val[4].start
      @project['end'] = @val[4].end
      @projectId = @val[1]
      setGlobalMacros
      @property = nil
      @reportCounter = 0
      @project
    })
    arg(2, 'name', 'The name of the project')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3373
  def rule_projectIDs
    pattern(%w( $ID !moreProjectIDs ), lambda {
      [ @val[0] ] + (@val[1].nil? ? [] : @val[1])
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3400
  def rule_projectProlog
    optional
    repeatable
    pattern(%w( !prologInclude ))
    pattern(%w( !macro ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3407
  def rule_projectProperties
    # This rule is not defining actual syntax. It's only used for the
    # documentation.
    pattern(%w( !projectPropertiesBody ))
    doc('properties', "The project properties. Every project must consists of at least one task. The other properties are optional. To save the scheduled data at least one output generating property should be used.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3418
  def rule_projectPropertiesBody
    # This rule is not defining actual syntax. It's only used for the
    # documentation.
    optionsRule('properties')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3379
  def rule_projection
    optionsRule('projectionAttributes')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3383
  def rule_projectionAttributes
    optional
    repeatable
    pattern(%w( _sloppy ))
    level(:deprecated)
    also('trackingscenario')
    doc('sloppy.projection', '')

    pattern(%w( _strict ), lambda {
      warning('projection_strict',
              'The strict mode is now always used.')
    })
    level(:deprecated)
    also('trackingscenario')
    doc('strict.projection', '')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3441
  def rule_prologInclude
    pattern(%w( _include !includeFile !projectProlog . ))
    lastSyntaxToken(1)
    doc('include.macro', "Includes the specified file name as if its contents would be written\ninstead of the include property. The only exception is the include\nstatement itself. When the included files contains other include\nstatements or report definitions, the filenames are relative to file\nwhere they are defined in.\n\nThe included file may only contain macro definitions. This version of the\ninclude directive can only be used before the [[project]] header.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3458
  def rule_properties
    pattern(%w( !propertiesBody ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3462
  def rule_propertiesBody
    repeatable
    optional

    pattern(%w( !account ))

    pattern(%w( _copyright $STRING ), lambda {
      @project['copyright'] = @val[1]
    })
    doc('copyright', "Set a copyright notice for the project file and its content. This copyright notice will be added to all reports that can support it.\n"
       )
    example('Caption', '2')

    pattern(%w( !balance ), lambda {
      @project['costaccount'] = @val[0][0]
      @project['revenueaccount'] = @val[0][1]
    })

    pattern(%w( _flags !declareFlagList ), lambda {
      unless @project['flags'].include?(@val[1])
        @project['flags'] += @val[1]
      end
    })
    doc('flags', "Declare one or more flag for later use. Flags can be used to mark tasks, resources or other properties to filter them in reports.\n"
       )

    pattern(%w( !propertiesInclude ))

    pattern(%w( !leaves ), lambda {
      @val[0].each do |v|
        @project['leaves'] << v
      end
    })

    pattern(%w( !limits ), lambda {
      @project['limits'] = @val[0]
    })
    doc('limits', "Set per-interval allocation limits for the following resource definitions.\nThe limits can be overwritten in each resource definition and the global\nlimits can be changed later.\n"
       )

    pattern(%w( !macro ))

    pattern(%w( !navigator ))

    pattern(%w( _projectid $ID ), lambda {
      @project['projectids'] << @val[1]
      @project['projectids'].uniq!
      @project['projectid'] = @projectId = @val[1]
    })
    doc('projectid', "This declares a new project id and activates it. All subsequent\ntask definitions will inherit this ID. The tasks of a project can have\ndifferent IDs.  This is particularly helpful if the project is merged from\nseveral sub projects that each have their own ID.\n"
       )

    pattern(%w( _projectids !projectIDs ), lambda {
      @project['projectids'] += @val[1]
      @project['projectids'].uniq!
    })
    doc('projectids', "Declares a list of project IDs. When an include file that was generated from another project brings different project IDs, these need to be declared first.\n"
        )

    pattern(%w( _rate !number ), lambda {
      @project['rate'] = @val[1].to_f
    })
    doc('rate', "Set the default rate for all subsequently defined resources. The rate describes the daily cost of a resource.\n"
        )

    pattern(%w( !reportProperties ))
    pattern(%w( !resource ))
    pattern(%w( !shift ))
    pattern(%w( !statusSheet ))

    pattern(%w( _supplement !supplement ))
    doc('supplement', "The supplement keyword provides a mechanism to add more attributes to already\ndefined accounts, tasks or resources. The additional attributes must obey the\nsame rules as in regular task or resource definitions and must be enclosed by\ncurly braces.\n\nThis construct is primarily meant for situations where the information about a\ntask or resource is split over several files. E. g. the vacation dates for the\nresources may be in a separate file that was generated by some other tool.\n"
       )
    example('Supplement')

    pattern(%w( !task ))
    pattern(%w( !timeSheet ))
    pattern(%w( _vacation !vacationName !intervals ), lambda {
      @val[2].each do |interval|
        @project['leaves'] << Leave.new(:holiday, interval)
      end
    })
    doc('vacation', "Specify a global vacation period for all subsequently defined resources. A\nvacation can also be used to block out the time before a resource joined or\nafter it left. For employees changing their work schedule from full-time to\npart-time, or vice versa, please refer to the 'Shift' property.\n"
       )
    arg(1, 'name', 'Name or purpose of the vacation')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3588
  def rule_propertiesFile
    pattern(%w( !propertiesBody . ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3592
  def rule_propertiesInclude
    pattern(%w( _include !includeProperties !properties . ), lambda {
    })
    lastSyntaxToken(1)
    doc('include.properties', "Includes the specified file name as if its contents would be written\ninstead of the include property. The only exception is the include\nstatement itself. When the included files contains other include\nstatements or report definitions, the filenames are relative to file\nwhere they are defined in. include commands can be used in the project\nheader, at global scope or between property declarations of tasks,\nresources, and accounts.\n\nFor technical reasons you have to supply the optional pair of curly\nbrackets if the include is followed immediately by a macro call that\nis defined within the included file.\n"
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3613
  def rule_purge
    pattern(%w( _purge $ID ), lambda {
      if (attributeDefinition = @property.attributeDefinition(@val[1])).nil?
        error('purge_unknown_id',
              "#{@val[1]} is not a known attribute for this property",
              @sourceFileInfo[1])
      end
      if attributeDefinition.scenarioSpecific
        attr = @property[@val[1], 0]
      else
        attr = @property.get(@val[1])
      end
      if @property.attributeDefinition(@val[1]).scenarioSpecific
        @property.getAttribute(@val[1], @scenarioIdx).reset
      else
        @property.getAttribute(@val[1]).reset
      end
    })
    doc('purge', "Many attributes inherit their values from the enclosing property or the global\nscope. In certain circumstances, this is not desirable, e. g. for list\nattributes. A list attribute is any attribute that takes a comma separated\nlist of values as argument. [[allocate]] and [[flags.task]] are\ngood examples of commonly used list attributes. By defining values for\nsuch a list attribute in a nested property, the new values will be appended to\nthe list that was inherited from the enclosing property. The purge\nattribute resets any attribute to its default value. A subsequent definition\nfor the attribute within the property will then add their values to an empty\nlist. The value of the enclosing property is not affected by purge.\n"
       )
    arg(1, 'attribute', 'Any name of a list attribute')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3648
  def rule_referenceAttributes
    optional
    repeatable
    pattern(%w( _label $STRING ), lambda {
      @val[1]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3656
  def rule_referenceBody
    optionsRule('referenceAttributes')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3660
  def rule_relativeId
    pattern(%w( _! !moreBangs !idOrAbsoluteId ), lambda {
      str = '!'
      if @val[1]
        @val[1].each { |bang| str += bang }
      end
      str += @val[2]
      str
    })
  end