# File lib/taskjuggler/TextParser.rb, line 80
def initialize
  # This Hash will store the ruleset that the parser is operating on.
  @rules = { }
  # Array to hold the token types that the scanner can return.
  @variables = []
  # An list of token types that are not allowed in the current context.
  # For performance reasons we use a hash with the token as key. The value
  # is irrelevant.
  @blockedVariables = {}
  # The currently processed rule.
  @cr = nil

  @states = {}
  # The stack used by the FSM.
  @stack = nil
end

# File lib/taskjuggler/TextParser.rb, line 220
def error(id, text, sfi = nil, data = nil)
  sfi ||= sourceFileInfo
  if @scanner
    # The scanner has some more context information, so we pass the error
    # on to the TextScanner.
    @scanner.error(id, text, sfi, data)
  else
    error(id, text, sfi, data)
  end
end

# File lib/taskjuggler/TextParser.rb, line 112
def initRules
  methods.each do |m|
    if m[0, 5] == 'rule_'
      # Create a new rule with the suffix of the function name as name.
      newRule(m[5..-1])
      # Call the function.
      send(m)
    end
  end
end

# File lib/taskjuggler/TextParser.rb, line 99
def limitTokenSet(tokenSet)
  return unless tokenSet

  # Create a copy of all supported variables.
  blockedVariables = @variables.dup
  # Then delete all that are in the limited set.
  blockedVariables.delete_if { |v| tokenSet.include?(v) }
  # And convert the list into a Hash for faster lookups.
  @blockedVariables = {}
  blockedVariables.each { |v| @blockedVariables[v] = true }
end

# File lib/taskjuggler/TextParser.rb, line 128
def newRule(name)
  # Use a symbol instead of a String.
  name = name.intern
  raise "Fatal Error: Rule #{name} already exists" if @rules.has_key?(name)

  if block_given?
    saveCr = @cr
    @rules[name] = @cr = TextParser::Rule.new(name)
    yield
    @cr = saveCr
  else
    @rules[name] = @cr = TextParser::Rule.new(name)
  end
end

# File lib/taskjuggler/TextParser.rb, line 160
def optional
  @cr.setOptional
end

# File lib/taskjuggler/TextParser.rb, line 197
def parse(ruleName)
  @stack = []
  @@expectedTokens = []
  begin
    result = parseFSM(@rules[ruleName])
  rescue TjException => msg
    if msg.message && !msg.message.empty?
      critical('parse', msg.message)
    end
    return false
  end

  result
end

# File lib/taskjuggler/TextParser.rb, line 154
def pattern(tokens, func = nil)
  @cr.addPattern(TextParser::Pattern.new(tokens, func))
end

# File lib/taskjuggler/TextParser.rb, line 166
def repeatable
  @cr.setRepeatable
end

# File lib/taskjuggler/TextParser.rb, line 215
def sourceFileInfo
  return @scanner.sourceFileInfo if @stack.nil? || @stack.length <= 1
  @stack.last.firstSourceFileInfo
end

# File lib/taskjuggler/TextParser.rb, line 174
def updateParserTables
  saveFsmStack
  # Invalidate some cached data.
  @rules.each_value { |rule| rule.flushCache }
  @states = {}
  # Generate the parser states for all patterns of all rules.
  @rules.each_value do |rule|
    rule.generateStates(@rules).each do |s|
      @states[[ s.rule, s.pattern, s.index ]] = s
    end
    checkRule(rule)
  end
  # Compute the transitions between the generated states.
  @states.each_value do |state|
    state.addTransitions(@states, @rules)
  end
  restoreFsmStack
end

# File lib/taskjuggler/TextParser.rb, line 231
def warning(id, text, sfi = nil, data = nil)
  sfi ||= sourceFileInfo
  if @scanner
    # The scanner has some more context information, so we pass the
    # warning on to the TextScanner.
    @scanner.warning(id, text, sfi, data)
  else
    warning(id, text, sfi, data)
  end
end